Ruby 3.3.6p108 (2024-11-05 revision 75015d4c1f6965b5e85e96fb309f1f2129f933c0)
complex.c
1/*
2 complex.c: Coded by Tadayoshi Funaba 2008-2012
3
4 This implementation is based on Keiju Ishitsuka's Complex library
5 which is written in ruby.
6*/
7
8#include "ruby/internal/config.h"
9
10#if defined _MSC_VER
11/* Microsoft Visual C does not define M_PI and others by default */
12# define _USE_MATH_DEFINES 1
13#endif
14
15#include <ctype.h>
16#include <math.h>
17
18#include "id.h"
19#include "internal.h"
20#include "internal/array.h"
21#include "internal/class.h"
22#include "internal/complex.h"
23#include "internal/math.h"
24#include "internal/numeric.h"
25#include "internal/object.h"
26#include "internal/rational.h"
27#include "internal/string.h"
28#include "ruby_assert.h"
29
30#define ZERO INT2FIX(0)
31#define ONE INT2FIX(1)
32#define TWO INT2FIX(2)
33#if USE_FLONUM
34#define RFLOAT_0 DBL2NUM(0)
35#else
36static VALUE RFLOAT_0;
37#endif
38
40
41static ID id_abs, id_arg,
42 id_denominator, id_numerator,
43 id_real_p, id_i_real, id_i_imag,
44 id_finite_p, id_infinite_p, id_rationalize,
45 id_PI;
46#define id_to_i idTo_i
47#define id_to_r idTo_r
48#define id_negate idUMinus
49#define id_expt idPow
50#define id_to_f idTo_f
51#define id_quo idQuo
52#define id_fdiv idFdiv
53
54#define fun1(n) \
55inline static VALUE \
56f_##n(VALUE x)\
57{\
58 return rb_funcall(x, id_##n, 0);\
59}
60
61#define fun2(n) \
62inline static VALUE \
63f_##n(VALUE x, VALUE y)\
64{\
65 return rb_funcall(x, id_##n, 1, y);\
66}
67
68#define PRESERVE_SIGNEDZERO
69
70inline static VALUE
71f_add(VALUE x, VALUE y)
72{
73 if (RB_INTEGER_TYPE_P(x) &&
74 LIKELY(rb_method_basic_definition_p(rb_cInteger, idPLUS))) {
75 if (FIXNUM_ZERO_P(x))
76 return y;
77 if (FIXNUM_ZERO_P(y))
78 return x;
79 return rb_int_plus(x, y);
80 }
81 else if (RB_FLOAT_TYPE_P(x) &&
82 LIKELY(rb_method_basic_definition_p(rb_cFloat, idPLUS))) {
83 if (FIXNUM_ZERO_P(y))
84 return x;
85 return rb_float_plus(x, y);
86 }
87 else if (RB_TYPE_P(x, T_RATIONAL) &&
88 LIKELY(rb_method_basic_definition_p(rb_cRational, idPLUS))) {
89 if (FIXNUM_ZERO_P(y))
90 return x;
91 return rb_rational_plus(x, y);
92 }
93
94 return rb_funcall(x, '+', 1, y);
95}
96
97inline static VALUE
98f_div(VALUE x, VALUE y)
99{
100 if (FIXNUM_P(y) && FIX2LONG(y) == 1)
101 return x;
102 return rb_funcall(x, '/', 1, y);
103}
104
105inline static int
106f_gt_p(VALUE x, VALUE y)
107{
108 if (RB_INTEGER_TYPE_P(x)) {
109 if (FIXNUM_P(x) && FIXNUM_P(y))
110 return (SIGNED_VALUE)x > (SIGNED_VALUE)y;
111 return RTEST(rb_int_gt(x, y));
112 }
113 else if (RB_FLOAT_TYPE_P(x))
114 return RTEST(rb_float_gt(x, y));
115 else if (RB_TYPE_P(x, T_RATIONAL)) {
116 int const cmp = rb_cmpint(rb_rational_cmp(x, y), x, y);
117 return cmp > 0;
118 }
119 return RTEST(rb_funcall(x, '>', 1, y));
120}
121
122inline static VALUE
123f_mul(VALUE x, VALUE y)
124{
125 if (RB_INTEGER_TYPE_P(x) &&
126 LIKELY(rb_method_basic_definition_p(rb_cInteger, idMULT))) {
127 if (FIXNUM_ZERO_P(y))
128 return ZERO;
129 if (FIXNUM_ZERO_P(x) && RB_INTEGER_TYPE_P(y))
130 return ZERO;
131 if (x == ONE) return y;
132 if (y == ONE) return x;
133 return rb_int_mul(x, y);
134 }
135 else if (RB_FLOAT_TYPE_P(x) &&
136 LIKELY(rb_method_basic_definition_p(rb_cFloat, idMULT))) {
137 if (y == ONE) return x;
138 return rb_float_mul(x, y);
139 }
140 else if (RB_TYPE_P(x, T_RATIONAL) &&
141 LIKELY(rb_method_basic_definition_p(rb_cRational, idMULT))) {
142 if (y == ONE) return x;
143 return rb_rational_mul(x, y);
144 }
145 else if (LIKELY(rb_method_basic_definition_p(CLASS_OF(x), idMULT))) {
146 if (y == ONE) return x;
147 }
148 return rb_funcall(x, '*', 1, y);
149}
150
151inline static VALUE
152f_sub(VALUE x, VALUE y)
153{
154 if (FIXNUM_ZERO_P(y) &&
155 LIKELY(rb_method_basic_definition_p(CLASS_OF(x), idMINUS))) {
156 return x;
157 }
158 return rb_funcall(x, '-', 1, y);
159}
160
161inline static VALUE
162f_abs(VALUE x)
163{
164 if (RB_INTEGER_TYPE_P(x)) {
165 return rb_int_abs(x);
166 }
167 else if (RB_FLOAT_TYPE_P(x)) {
168 return rb_float_abs(x);
169 }
170 else if (RB_TYPE_P(x, T_RATIONAL)) {
171 return rb_rational_abs(x);
172 }
173 else if (RB_TYPE_P(x, T_COMPLEX)) {
174 return rb_complex_abs(x);
175 }
176 return rb_funcall(x, id_abs, 0);
177}
178
179static VALUE numeric_arg(VALUE self);
180static VALUE float_arg(VALUE self);
181
182inline static VALUE
183f_arg(VALUE x)
184{
185 if (RB_INTEGER_TYPE_P(x)) {
186 return numeric_arg(x);
187 }
188 else if (RB_FLOAT_TYPE_P(x)) {
189 return float_arg(x);
190 }
191 else if (RB_TYPE_P(x, T_RATIONAL)) {
192 return numeric_arg(x);
193 }
194 else if (RB_TYPE_P(x, T_COMPLEX)) {
195 return rb_complex_arg(x);
196 }
197 return rb_funcall(x, id_arg, 0);
198}
199
200inline static VALUE
201f_numerator(VALUE x)
202{
203 if (RB_TYPE_P(x, T_RATIONAL)) {
204 return RRATIONAL(x)->num;
205 }
206 if (RB_FLOAT_TYPE_P(x)) {
207 return rb_float_numerator(x);
208 }
209 return x;
210}
211
212inline static VALUE
213f_denominator(VALUE x)
214{
215 if (RB_TYPE_P(x, T_RATIONAL)) {
216 return RRATIONAL(x)->den;
217 }
218 if (RB_FLOAT_TYPE_P(x)) {
219 return rb_float_denominator(x);
220 }
221 return INT2FIX(1);
222}
223
224inline static VALUE
225f_negate(VALUE x)
226{
227 if (RB_INTEGER_TYPE_P(x)) {
228 return rb_int_uminus(x);
229 }
230 else if (RB_FLOAT_TYPE_P(x)) {
231 return rb_float_uminus(x);
232 }
233 else if (RB_TYPE_P(x, T_RATIONAL)) {
234 return rb_rational_uminus(x);
235 }
236 else if (RB_TYPE_P(x, T_COMPLEX)) {
237 return rb_complex_uminus(x);
238 }
239 return rb_funcall(x, id_negate, 0);
240}
241
242static bool nucomp_real_p(VALUE self);
243
244static inline bool
245f_real_p(VALUE x)
246{
247 if (RB_INTEGER_TYPE_P(x)) {
248 return true;
249 }
250 else if (RB_FLOAT_TYPE_P(x)) {
251 return true;
252 }
253 else if (RB_TYPE_P(x, T_RATIONAL)) {
254 return true;
255 }
256 else if (RB_TYPE_P(x, T_COMPLEX)) {
257 return nucomp_real_p(x);
258 }
259 return rb_funcall(x, id_real_p, 0);
260}
261
262inline static VALUE
263f_to_i(VALUE x)
264{
265 if (RB_TYPE_P(x, T_STRING))
266 return rb_str_to_inum(x, 10, 0);
267 return rb_funcall(x, id_to_i, 0);
268}
269
270inline static VALUE
271f_to_f(VALUE x)
272{
273 if (RB_TYPE_P(x, T_STRING))
274 return DBL2NUM(rb_str_to_dbl(x, 0));
275 return rb_funcall(x, id_to_f, 0);
276}
277
278fun1(to_r)
279
280inline static int
281f_eqeq_p(VALUE x, VALUE y)
282{
283 if (FIXNUM_P(x) && FIXNUM_P(y))
284 return x == y;
285 else if (RB_FLOAT_TYPE_P(x) || RB_FLOAT_TYPE_P(y))
286 return NUM2DBL(x) == NUM2DBL(y);
287 return (int)rb_equal(x, y);
288}
289
290fun2(expt)
291fun2(fdiv)
292
293static VALUE
294f_quo(VALUE x, VALUE y)
295{
296 if (RB_INTEGER_TYPE_P(x))
297 return rb_numeric_quo(x, y);
298 if (RB_FLOAT_TYPE_P(x))
299 return rb_float_div(x, y);
300 if (RB_TYPE_P(x, T_RATIONAL))
301 return rb_numeric_quo(x, y);
302
303 return rb_funcallv(x, id_quo, 1, &y);
304}
305
306inline static int
307f_negative_p(VALUE x)
308{
309 if (RB_INTEGER_TYPE_P(x))
310 return INT_NEGATIVE_P(x);
311 else if (RB_FLOAT_TYPE_P(x))
312 return RFLOAT_VALUE(x) < 0.0;
313 else if (RB_TYPE_P(x, T_RATIONAL))
314 return INT_NEGATIVE_P(RRATIONAL(x)->num);
315 return rb_num_negative_p(x);
316}
317
318#define f_positive_p(x) (!f_negative_p(x))
319
320inline static bool
321f_zero_p(VALUE x)
322{
323 if (RB_FLOAT_TYPE_P(x)) {
324 return FLOAT_ZERO_P(x);
325 }
326 else if (RB_INTEGER_TYPE_P(x)) {
327 return FIXNUM_ZERO_P(x);
328 }
329 else if (RB_TYPE_P(x, T_RATIONAL)) {
330 const VALUE num = RRATIONAL(x)->num;
331 return FIXNUM_ZERO_P(num);
332 }
333 return rb_equal(x, ZERO) != 0;
334}
335
336#define f_nonzero_p(x) (!f_zero_p(x))
337
338static inline bool
339always_finite_type_p(VALUE x)
340{
341 if (FIXNUM_P(x)) return true;
342 if (FLONUM_P(x)) return true; /* Infinity can't be a flonum */
343 return (RB_INTEGER_TYPE_P(x) || RB_TYPE_P(x, T_RATIONAL));
344}
345
346inline static int
347f_finite_p(VALUE x)
348{
349 if (always_finite_type_p(x)) {
350 return TRUE;
351 }
352 else if (RB_FLOAT_TYPE_P(x)) {
353 return isfinite(RFLOAT_VALUE(x));
354 }
355 return RTEST(rb_funcallv(x, id_finite_p, 0, 0));
356}
357
358inline static int
359f_infinite_p(VALUE x)
360{
361 if (always_finite_type_p(x)) {
362 return FALSE;
363 }
364 else if (RB_FLOAT_TYPE_P(x)) {
365 return isinf(RFLOAT_VALUE(x));
366 }
367 return RTEST(rb_funcallv(x, id_infinite_p, 0, 0));
368}
369
370inline static int
371f_kind_of_p(VALUE x, VALUE c)
372{
373 return (int)rb_obj_is_kind_of(x, c);
374}
375
376inline static int
377k_numeric_p(VALUE x)
378{
379 return f_kind_of_p(x, rb_cNumeric);
380}
381
382#define k_exact_p(x) (!RB_FLOAT_TYPE_P(x))
383
384#define k_exact_zero_p(x) (k_exact_p(x) && f_zero_p(x))
385
386#define get_dat1(x) \
387 struct RComplex *dat = RCOMPLEX(x)
388
389#define get_dat2(x,y) \
390 struct RComplex *adat = RCOMPLEX(x), *bdat = RCOMPLEX(y)
391
392inline static VALUE
393nucomp_s_new_internal(VALUE klass, VALUE real, VALUE imag)
394{
395 NEWOBJ_OF(obj, struct RComplex, klass,
397
398 RCOMPLEX_SET_REAL(obj, real);
399 RCOMPLEX_SET_IMAG(obj, imag);
400 OBJ_FREEZE_RAW((VALUE)obj);
401
402 return (VALUE)obj;
403}
404
405static VALUE
406nucomp_s_alloc(VALUE klass)
407{
408 return nucomp_s_new_internal(klass, ZERO, ZERO);
409}
410
411inline static VALUE
412f_complex_new_bang1(VALUE klass, VALUE x)
413{
414 assert(!RB_TYPE_P(x, T_COMPLEX));
415 return nucomp_s_new_internal(klass, x, ZERO);
416}
417
418inline static VALUE
419f_complex_new_bang2(VALUE klass, VALUE x, VALUE y)
420{
421 assert(!RB_TYPE_P(x, T_COMPLEX));
422 assert(!RB_TYPE_P(y, T_COMPLEX));
423 return nucomp_s_new_internal(klass, x, y);
424}
425
426WARN_UNUSED_RESULT(inline static VALUE nucomp_real_check(VALUE num));
427inline static VALUE
428nucomp_real_check(VALUE num)
429{
430 if (!RB_INTEGER_TYPE_P(num) &&
431 !RB_FLOAT_TYPE_P(num) &&
432 !RB_TYPE_P(num, T_RATIONAL)) {
433 if (RB_TYPE_P(num, T_COMPLEX) && nucomp_real_p(num)) {
434 VALUE real = RCOMPLEX(num)->real;
435 assert(!RB_TYPE_P(real, T_COMPLEX));
436 return real;
437 }
438 if (!k_numeric_p(num) || !f_real_p(num))
439 rb_raise(rb_eTypeError, "not a real");
440 }
441 return num;
442}
443
444inline static VALUE
445nucomp_s_canonicalize_internal(VALUE klass, VALUE real, VALUE imag)
446{
447 int complex_r, complex_i;
448 complex_r = RB_TYPE_P(real, T_COMPLEX);
449 complex_i = RB_TYPE_P(imag, T_COMPLEX);
450 if (!complex_r && !complex_i) {
451 return nucomp_s_new_internal(klass, real, imag);
452 }
453 else if (!complex_r) {
454 get_dat1(imag);
455
456 return nucomp_s_new_internal(klass,
457 f_sub(real, dat->imag),
458 f_add(ZERO, dat->real));
459 }
460 else if (!complex_i) {
461 get_dat1(real);
462
463 return nucomp_s_new_internal(klass,
464 dat->real,
465 f_add(dat->imag, imag));
466 }
467 else {
468 get_dat2(real, imag);
469
470 return nucomp_s_new_internal(klass,
471 f_sub(adat->real, bdat->imag),
472 f_add(adat->imag, bdat->real));
473 }
474}
475
476/*
477 * call-seq:
478 * Complex.rect(real, imag = 0) -> complex
479 *
480 * Returns a new \Complex object formed from the arguments,
481 * each of which must be an instance of Numeric,
482 * or an instance of one of its subclasses:
483 * \Complex, Float, Integer, Rational;
484 * see {Rectangular Coordinates}[rdoc-ref:Complex@Rectangular+Coordinates]:
485 *
486 * Complex.rect(3) # => (3+0i)
487 * Complex.rect(3, Math::PI) # => (3+3.141592653589793i)
488 * Complex.rect(-3, -Math::PI) # => (-3-3.141592653589793i)
489 *
490 * \Complex.rectangular is an alias for \Complex.rect.
491 */
492static VALUE
493nucomp_s_new(int argc, VALUE *argv, VALUE klass)
494{
495 VALUE real, imag;
496
497 switch (rb_scan_args(argc, argv, "11", &real, &imag)) {
498 case 1:
499 real = nucomp_real_check(real);
500 imag = ZERO;
501 break;
502 default:
503 real = nucomp_real_check(real);
504 imag = nucomp_real_check(imag);
505 break;
506 }
507
508 return nucomp_s_new_internal(klass, real, imag);
509}
510
511inline static VALUE
512f_complex_new2(VALUE klass, VALUE x, VALUE y)
513{
514 if (RB_TYPE_P(x, T_COMPLEX)) {
515 get_dat1(x);
516 x = dat->real;
517 y = f_add(dat->imag, y);
518 }
519 return nucomp_s_canonicalize_internal(klass, x, y);
520}
521
522static VALUE nucomp_convert(VALUE klass, VALUE a1, VALUE a2, int raise);
523static VALUE nucomp_s_convert(int argc, VALUE *argv, VALUE klass);
524
525/*
526 * call-seq:
527 * Complex(real, imag = 0, exception: true) -> complex or nil
528 * Complex(s, exception: true) -> complex or nil
529 *
530 * Returns a new \Complex object if the arguments are valid;
531 * otherwise raises an exception if +exception+ is +true+;
532 * otherwise returns +nil+.
533 *
534 * With Numeric arguments +real+ and +imag+,
535 * returns <tt>Complex.rect(real, imag)</tt> if the arguments are valid.
536 *
537 * With string argument +s+, returns a new \Complex object if the argument is valid;
538 * the string may have:
539 *
540 * - One or two numeric substrings,
541 * each of which specifies a Complex, Float, Integer, Numeric, or Rational value,
542 * specifying {rectangular coordinates}[rdoc-ref:Complex@Rectangular+Coordinates]:
543 *
544 * - Sign-separated real and imaginary numeric substrings
545 * (with trailing character <tt>'i'</tt>):
546 *
547 * Complex('1+2i') # => (1+2i)
548 * Complex('+1+2i') # => (1+2i)
549 * Complex('+1-2i') # => (1-2i)
550 * Complex('-1+2i') # => (-1+2i)
551 * Complex('-1-2i') # => (-1-2i)
552 *
553 * - Real-only numeric string (without trailing character <tt>'i'</tt>):
554 *
555 * Complex('1') # => (1+0i)
556 * Complex('+1') # => (1+0i)
557 * Complex('-1') # => (-1+0i)
558 *
559 * - Imaginary-only numeric string (with trailing character <tt>'i'</tt>):
560 *
561 * Complex('1i') # => (0+1i)
562 * Complex('+1i') # => (0+1i)
563 * Complex('-1i') # => (0-1i)
564 *
565 * - At-sign separated real and imaginary rational substrings,
566 * each of which specifies a Rational value,
567 * specifying {polar coordinates}[rdoc-ref:Complex@Polar+Coordinates]:
568 *
569 * Complex('1/2@3/4') # => (0.36584443443691045+0.34081938001166706i)
570 * Complex('+1/2@+3/4') # => (0.36584443443691045+0.34081938001166706i)
571 * Complex('+1/2@-3/4') # => (0.36584443443691045-0.34081938001166706i)
572 * Complex('-1/2@+3/4') # => (-0.36584443443691045-0.34081938001166706i)
573 * Complex('-1/2@-3/4') # => (-0.36584443443691045+0.34081938001166706i)
574 *
575 */
576static VALUE
577nucomp_f_complex(int argc, VALUE *argv, VALUE klass)
578{
579 VALUE a1, a2, opts = Qnil;
580 int raise = TRUE;
581
582 if (rb_scan_args(argc, argv, "11:", &a1, &a2, &opts) == 1) {
583 a2 = Qundef;
584 }
585 if (!NIL_P(opts)) {
586 raise = rb_opts_exception_p(opts, raise);
587 }
588 if (argc > 0 && CLASS_OF(a1) == rb_cComplex && UNDEF_P(a2)) {
589 return a1;
590 }
591 return nucomp_convert(rb_cComplex, a1, a2, raise);
592}
593
594#define imp1(n) \
595inline static VALUE \
596m_##n##_bang(VALUE x)\
597{\
598 return rb_math_##n(x);\
599}
600
601imp1(cos)
602imp1(cosh)
603imp1(exp)
604
605static VALUE
606m_log_bang(VALUE x)
607{
608 return rb_math_log(1, &x);
609}
610
611imp1(sin)
612imp1(sinh)
613
614static VALUE
615m_cos(VALUE x)
616{
617 if (!RB_TYPE_P(x, T_COMPLEX))
618 return m_cos_bang(x);
619 {
620 get_dat1(x);
621 return f_complex_new2(rb_cComplex,
622 f_mul(m_cos_bang(dat->real),
623 m_cosh_bang(dat->imag)),
624 f_mul(f_negate(m_sin_bang(dat->real)),
625 m_sinh_bang(dat->imag)));
626 }
627}
628
629static VALUE
630m_sin(VALUE x)
631{
632 if (!RB_TYPE_P(x, T_COMPLEX))
633 return m_sin_bang(x);
634 {
635 get_dat1(x);
636 return f_complex_new2(rb_cComplex,
637 f_mul(m_sin_bang(dat->real),
638 m_cosh_bang(dat->imag)),
639 f_mul(m_cos_bang(dat->real),
640 m_sinh_bang(dat->imag)));
641 }
642}
643
644static VALUE
645f_complex_polar_real(VALUE klass, VALUE x, VALUE y)
646{
647 if (f_zero_p(x) || f_zero_p(y)) {
648 return nucomp_s_new_internal(klass, x, RFLOAT_0);
649 }
650 if (RB_FLOAT_TYPE_P(y)) {
651 const double arg = RFLOAT_VALUE(y);
652 if (arg == M_PI) {
653 x = f_negate(x);
654 y = RFLOAT_0;
655 }
656 else if (arg == M_PI_2) {
657 y = x;
658 x = RFLOAT_0;
659 }
660 else if (arg == M_PI_2+M_PI) {
661 y = f_negate(x);
662 x = RFLOAT_0;
663 }
664 else if (RB_FLOAT_TYPE_P(x)) {
665 const double abs = RFLOAT_VALUE(x);
666 const double real = abs * cos(arg), imag = abs * sin(arg);
667 x = DBL2NUM(real);
668 y = DBL2NUM(imag);
669 }
670 else {
671 const double ax = sin(arg), ay = cos(arg);
672 y = f_mul(x, DBL2NUM(ax));
673 x = f_mul(x, DBL2NUM(ay));
674 }
675 return nucomp_s_new_internal(klass, x, y);
676 }
677 return nucomp_s_canonicalize_internal(klass,
678 f_mul(x, m_cos(y)),
679 f_mul(x, m_sin(y)));
680}
681
682static VALUE
683f_complex_polar(VALUE klass, VALUE x, VALUE y)
684{
685 x = nucomp_real_check(x);
686 y = nucomp_real_check(y);
687 return f_complex_polar_real(klass, x, y);
688}
689
690#ifdef HAVE___COSPI
691# define cospi(x) __cospi(x)
692#else
693# define cospi(x) cos((x) * M_PI)
694#endif
695#ifdef HAVE___SINPI
696# define sinpi(x) __sinpi(x)
697#else
698# define sinpi(x) sin((x) * M_PI)
699#endif
700/* returns a Complex or Float of ang*PI-rotated abs */
701VALUE
702rb_dbl_complex_new_polar_pi(double abs, double ang)
703{
704 double fi;
705 const double fr = modf(ang, &fi);
706 int pos = fr == +0.5;
707
708 if (pos || fr == -0.5) {
709 if ((modf(fi / 2.0, &fi) != fr) ^ pos) abs = -abs;
710 return rb_complex_new(RFLOAT_0, DBL2NUM(abs));
711 }
712 else if (fr == 0.0) {
713 if (modf(fi / 2.0, &fi) != 0.0) abs = -abs;
714 return DBL2NUM(abs);
715 }
716 else {
717 const double real = abs * cospi(ang), imag = abs * sinpi(ang);
718 return rb_complex_new(DBL2NUM(real), DBL2NUM(imag));
719 }
720}
721
722/*
723 * call-seq:
724 * Complex.polar(abs, arg = 0) -> complex
725 *
726 * Returns a new \Complex object formed from the arguments,
727 * each of which must be an instance of Numeric,
728 * or an instance of one of its subclasses:
729 * \Complex, Float, Integer, Rational.
730 * Argument +arg+ is given in radians;
731 * see {Polar Coordinates}[rdoc-ref:Complex@Polar+Coordinates]:
732 *
733 * Complex.polar(3) # => (3+0i)
734 * Complex.polar(3, 2.0) # => (-1.2484405096414273+2.727892280477045i)
735 * Complex.polar(-3, -2.0) # => (1.2484405096414273+2.727892280477045i)
736 *
737 */
738static VALUE
739nucomp_s_polar(int argc, VALUE *argv, VALUE klass)
740{
741 VALUE abs, arg;
742
743 argc = rb_scan_args(argc, argv, "11", &abs, &arg);
744 abs = nucomp_real_check(abs);
745 if (argc == 2) {
746 arg = nucomp_real_check(arg);
747 }
748 else {
749 arg = ZERO;
750 }
751 return f_complex_polar_real(klass, abs, arg);
752}
753
754/*
755 * call-seq:
756 * real -> numeric
757 *
758 * Returns the real value for +self+:
759 *
760 * Complex(7).real #=> 7
761 * Complex(9, -4).real #=> 9
762 *
763 * If +self+ was created with
764 * {polar coordinates}[rdoc-ref:Complex@Polar+Coordinates], the returned value
765 * is computed, and may be inexact:
766 *
767 * Complex.polar(1, Math::PI/4).real # => 0.7071067811865476 # Square root of 2.
768 *
769 */
770VALUE
771rb_complex_real(VALUE self)
772{
773 get_dat1(self);
774 return dat->real;
775}
776
777/*
778 * call-seq:
779 * imag -> numeric
780 *
781 * Returns the imaginary value for +self+:
782 *
783 * Complex(7).imaginary #=> 0
784 * Complex(9, -4).imaginary #=> -4
785 *
786 * If +self+ was created with
787 * {polar coordinates}[rdoc-ref:Complex@Polar+Coordinates], the returned value
788 * is computed, and may be inexact:
789 *
790 * Complex.polar(1, Math::PI/4).imag # => 0.7071067811865476 # Square root of 2.
791 *
792 */
793VALUE
794rb_complex_imag(VALUE self)
795{
796 get_dat1(self);
797 return dat->imag;
798}
799
800/*
801 * call-seq:
802 * -complex -> new_complex
803 *
804 * Returns the negation of +self+, which is the negation of each of its parts:
805 *
806 * -Complex(1, 2) # => (-1-2i)
807 * -Complex(-1, -2) # => (1+2i)
808 *
809 */
810VALUE
811rb_complex_uminus(VALUE self)
812{
813 get_dat1(self);
814 return f_complex_new2(CLASS_OF(self),
815 f_negate(dat->real), f_negate(dat->imag));
816}
817
818/*
819 * call-seq:
820 * complex + numeric -> new_complex
821 *
822 * Returns the sum of +self+ and +numeric+:
823 *
824 * Complex(2, 3) + Complex(2, 3) # => (4+6i)
825 * Complex(900) + Complex(1) # => (901+0i)
826 * Complex(-2, 9) + Complex(-9, 2) # => (-11+11i)
827 * Complex(9, 8) + 4 # => (13+8i)
828 * Complex(20, 9) + 9.8 # => (29.8+9i)
829 *
830 */
831VALUE
832rb_complex_plus(VALUE self, VALUE other)
833{
834 if (RB_TYPE_P(other, T_COMPLEX)) {
835 VALUE real, imag;
836
837 get_dat2(self, other);
838
839 real = f_add(adat->real, bdat->real);
840 imag = f_add(adat->imag, bdat->imag);
841
842 return f_complex_new2(CLASS_OF(self), real, imag);
843 }
844 if (k_numeric_p(other) && f_real_p(other)) {
845 get_dat1(self);
846
847 return f_complex_new2(CLASS_OF(self),
848 f_add(dat->real, other), dat->imag);
849 }
850 return rb_num_coerce_bin(self, other, '+');
851}
852
853/*
854 * call-seq:
855 * complex - numeric -> new_complex
856 *
857 * Returns the difference of +self+ and +numeric+:
858 *
859 * Complex(2, 3) - Complex(2, 3) # => (0+0i)
860 * Complex(900) - Complex(1) # => (899+0i)
861 * Complex(-2, 9) - Complex(-9, 2) # => (7+7i)
862 * Complex(9, 8) - 4 # => (5+8i)
863 * Complex(20, 9) - 9.8 # => (10.2+9i)
864 *
865 */
866VALUE
867rb_complex_minus(VALUE self, VALUE other)
868{
869 if (RB_TYPE_P(other, T_COMPLEX)) {
870 VALUE real, imag;
871
872 get_dat2(self, other);
873
874 real = f_sub(adat->real, bdat->real);
875 imag = f_sub(adat->imag, bdat->imag);
876
877 return f_complex_new2(CLASS_OF(self), real, imag);
878 }
879 if (k_numeric_p(other) && f_real_p(other)) {
880 get_dat1(self);
881
882 return f_complex_new2(CLASS_OF(self),
883 f_sub(dat->real, other), dat->imag);
884 }
885 return rb_num_coerce_bin(self, other, '-');
886}
887
888static VALUE
889safe_mul(VALUE a, VALUE b, bool az, bool bz)
890{
891 double v;
892 if (!az && bz && RB_FLOAT_TYPE_P(a) && (v = RFLOAT_VALUE(a), !isnan(v))) {
893 a = signbit(v) ? DBL2NUM(-1.0) : DBL2NUM(1.0);
894 }
895 if (!bz && az && RB_FLOAT_TYPE_P(b) && (v = RFLOAT_VALUE(b), !isnan(v))) {
896 b = signbit(v) ? DBL2NUM(-1.0) : DBL2NUM(1.0);
897 }
898 return f_mul(a, b);
899}
900
901static void
902comp_mul(VALUE areal, VALUE aimag, VALUE breal, VALUE bimag, VALUE *real, VALUE *imag)
903{
904 bool arzero = f_zero_p(areal);
905 bool aizero = f_zero_p(aimag);
906 bool brzero = f_zero_p(breal);
907 bool bizero = f_zero_p(bimag);
908 *real = f_sub(safe_mul(areal, breal, arzero, brzero),
909 safe_mul(aimag, bimag, aizero, bizero));
910 *imag = f_add(safe_mul(areal, bimag, arzero, bizero),
911 safe_mul(aimag, breal, aizero, brzero));
912}
913
914/*
915 * call-seq:
916 * complex * numeric -> new_complex
917 *
918 * Returns the product of +self+ and +numeric+:
919 *
920 * Complex(2, 3) * Complex(2, 3) # => (-5+12i)
921 * Complex(900) * Complex(1) # => (900+0i)
922 * Complex(-2, 9) * Complex(-9, 2) # => (0-85i)
923 * Complex(9, 8) * 4 # => (36+32i)
924 * Complex(20, 9) * 9.8 # => (196.0+88.2i)
925 *
926 */
927VALUE
928rb_complex_mul(VALUE self, VALUE other)
929{
930 if (RB_TYPE_P(other, T_COMPLEX)) {
931 VALUE real, imag;
932 get_dat2(self, other);
933
934 comp_mul(adat->real, adat->imag, bdat->real, bdat->imag, &real, &imag);
935
936 return f_complex_new2(CLASS_OF(self), real, imag);
937 }
938 if (k_numeric_p(other) && f_real_p(other)) {
939 get_dat1(self);
940
941 return f_complex_new2(CLASS_OF(self),
942 f_mul(dat->real, other),
943 f_mul(dat->imag, other));
944 }
945 return rb_num_coerce_bin(self, other, '*');
946}
947
948inline static VALUE
949f_divide(VALUE self, VALUE other,
950 VALUE (*func)(VALUE, VALUE), ID id)
951{
952 if (RB_TYPE_P(other, T_COMPLEX)) {
953 VALUE r, n, x, y;
954 int flo;
955 get_dat2(self, other);
956
957 flo = (RB_FLOAT_TYPE_P(adat->real) || RB_FLOAT_TYPE_P(adat->imag) ||
958 RB_FLOAT_TYPE_P(bdat->real) || RB_FLOAT_TYPE_P(bdat->imag));
959
960 if (f_gt_p(f_abs(bdat->real), f_abs(bdat->imag))) {
961 r = (*func)(bdat->imag, bdat->real);
962 n = f_mul(bdat->real, f_add(ONE, f_mul(r, r)));
963 x = (*func)(f_add(adat->real, f_mul(adat->imag, r)), n);
964 y = (*func)(f_sub(adat->imag, f_mul(adat->real, r)), n);
965 }
966 else {
967 r = (*func)(bdat->real, bdat->imag);
968 n = f_mul(bdat->imag, f_add(ONE, f_mul(r, r)));
969 x = (*func)(f_add(f_mul(adat->real, r), adat->imag), n);
970 y = (*func)(f_sub(f_mul(adat->imag, r), adat->real), n);
971 }
972 if (!flo) {
973 x = rb_rational_canonicalize(x);
974 y = rb_rational_canonicalize(y);
975 }
976 return f_complex_new2(CLASS_OF(self), x, y);
977 }
978 if (k_numeric_p(other) && f_real_p(other)) {
979 VALUE x, y;
980 get_dat1(self);
981 x = rb_rational_canonicalize((*func)(dat->real, other));
982 y = rb_rational_canonicalize((*func)(dat->imag, other));
983 return f_complex_new2(CLASS_OF(self), x, y);
984 }
985 return rb_num_coerce_bin(self, other, id);
986}
987
988#define rb_raise_zerodiv() rb_raise(rb_eZeroDivError, "divided by 0")
989
990/*
991 * call-seq:
992 * complex / numeric -> new_complex
993 *
994 * Returns the quotient of +self+ and +numeric+:
995 *
996 * Complex(2, 3) / Complex(2, 3) # => ((1/1)+(0/1)*i)
997 * Complex(900) / Complex(1) # => ((900/1)+(0/1)*i)
998 * Complex(-2, 9) / Complex(-9, 2) # => ((36/85)-(77/85)*i)
999 * Complex(9, 8) / 4 # => ((9/4)+(2/1)*i)
1000 * Complex(20, 9) / 9.8 # => (2.0408163265306123+0.9183673469387754i)
1001 *
1002 */
1003VALUE
1004rb_complex_div(VALUE self, VALUE other)
1005{
1006 return f_divide(self, other, f_quo, id_quo);
1007}
1008
1009#define nucomp_quo rb_complex_div
1010
1011/*
1012 * call-seq:
1013 * fdiv(numeric) -> new_complex
1014 *
1015 * Returns <tt>Complex(self.real/numeric, self.imag/numeric)</tt>:
1016 *
1017 * Complex(11, 22).fdiv(3) # => (3.6666666666666665+7.333333333333333i)
1018 *
1019 */
1020static VALUE
1021nucomp_fdiv(VALUE self, VALUE other)
1022{
1023 return f_divide(self, other, f_fdiv, id_fdiv);
1024}
1025
1026inline static VALUE
1027f_reciprocal(VALUE x)
1028{
1029 return f_quo(ONE, x);
1030}
1031
1032static VALUE
1033zero_for(VALUE x)
1034{
1035 if (RB_FLOAT_TYPE_P(x))
1036 return DBL2NUM(0);
1037 if (RB_TYPE_P(x, T_RATIONAL))
1038 return rb_rational_new(INT2FIX(0), INT2FIX(1));
1039
1040 return INT2FIX(0);
1041}
1042
1043static VALUE
1044complex_pow_for_special_angle(VALUE self, VALUE other)
1045{
1046 if (!rb_integer_type_p(other)) {
1047 return Qundef;
1048 }
1049
1050 get_dat1(self);
1051 VALUE x = Qundef;
1052 int dir;
1053 if (f_zero_p(dat->imag)) {
1054 x = dat->real;
1055 dir = 0;
1056 }
1057 else if (f_zero_p(dat->real)) {
1058 x = dat->imag;
1059 dir = 2;
1060 }
1061 else if (f_eqeq_p(dat->real, dat->imag)) {
1062 x = dat->real;
1063 dir = 1;
1064 }
1065 else if (f_eqeq_p(dat->real, f_negate(dat->imag))) {
1066 x = dat->imag;
1067 dir = 3;
1068 }
1069
1070 if (x == Qundef) return x;
1071
1072 if (f_negative_p(x)) {
1073 x = f_negate(x);
1074 dir += 4;
1075 }
1076
1077 VALUE zx;
1078 if (dir % 2 == 0) {
1079 zx = rb_num_pow(x, other);
1080 }
1081 else {
1082 zx = rb_num_pow(
1083 rb_funcall(rb_int_mul(TWO, x), '*', 1, x),
1084 rb_int_div(other, TWO)
1085 );
1086 if (rb_int_odd_p(other)) {
1087 zx = rb_funcall(zx, '*', 1, x);
1088 }
1089 }
1090 static const int dirs[][2] = {
1091 {1, 0}, {1, 1}, {0, 1}, {-1, 1}, {-1, 0}, {-1, -1}, {0, -1}, {1, -1}
1092 };
1093 int z_dir = FIX2INT(rb_int_modulo(rb_int_mul(INT2FIX(dir), other), INT2FIX(8)));
1094
1095 VALUE zr = Qfalse, zi = Qfalse;
1096 switch (dirs[z_dir][0]) {
1097 case 0: zr = zero_for(zx); break;
1098 case 1: zr = zx; break;
1099 case -1: zr = f_negate(zx); break;
1100 }
1101 switch (dirs[z_dir][1]) {
1102 case 0: zi = zero_for(zx); break;
1103 case 1: zi = zx; break;
1104 case -1: zi = f_negate(zx); break;
1105 }
1106 return nucomp_s_new_internal(CLASS_OF(self), zr, zi);
1107}
1108
1109
1110/*
1111 * call-seq:
1112 * complex ** numeric -> new_complex
1113 *
1114 * Returns +self+ raised to power +numeric+:
1115 *
1116 * Complex('i') ** 2 # => (-1+0i)
1117 * Complex(-8) ** Rational(1, 3) # => (1.0000000000000002+1.7320508075688772i)
1118 *
1119 */
1120VALUE
1121rb_complex_pow(VALUE self, VALUE other)
1122{
1123 if (k_numeric_p(other) && k_exact_zero_p(other))
1124 return f_complex_new_bang1(CLASS_OF(self), ONE);
1125
1126 if (RB_TYPE_P(other, T_RATIONAL) && RRATIONAL(other)->den == LONG2FIX(1))
1127 other = RRATIONAL(other)->num; /* c14n */
1128
1129 if (RB_TYPE_P(other, T_COMPLEX)) {
1130 get_dat1(other);
1131
1132 if (k_exact_zero_p(dat->imag))
1133 other = dat->real; /* c14n */
1134 }
1135
1136 if (other == ONE) {
1137 get_dat1(self);
1138 return nucomp_s_new_internal(CLASS_OF(self), dat->real, dat->imag);
1139 }
1140
1141 VALUE result = complex_pow_for_special_angle(self, other);
1142 if (result != Qundef) return result;
1143
1144 if (RB_TYPE_P(other, T_COMPLEX)) {
1145 VALUE r, theta, nr, ntheta;
1146
1147 get_dat1(other);
1148
1149 r = f_abs(self);
1150 theta = f_arg(self);
1151
1152 nr = m_exp_bang(f_sub(f_mul(dat->real, m_log_bang(r)),
1153 f_mul(dat->imag, theta)));
1154 ntheta = f_add(f_mul(theta, dat->real),
1155 f_mul(dat->imag, m_log_bang(r)));
1156 return f_complex_polar(CLASS_OF(self), nr, ntheta);
1157 }
1158 if (FIXNUM_P(other)) {
1159 long n = FIX2LONG(other);
1160 if (n == 0) {
1161 return nucomp_s_new_internal(CLASS_OF(self), ONE, ZERO);
1162 }
1163 if (n < 0) {
1164 self = f_reciprocal(self);
1165 other = rb_int_uminus(other);
1166 n = -n;
1167 }
1168 {
1169 get_dat1(self);
1170 VALUE xr = dat->real, xi = dat->imag, zr = xr, zi = xi;
1171
1172 if (f_zero_p(xi)) {
1173 zr = rb_num_pow(zr, other);
1174 }
1175 else if (f_zero_p(xr)) {
1176 zi = rb_num_pow(zi, other);
1177 if (n & 2) zi = f_negate(zi);
1178 if (!(n & 1)) {
1179 VALUE tmp = zr;
1180 zr = zi;
1181 zi = tmp;
1182 }
1183 }
1184 else {
1185 while (--n) {
1186 long q, r;
1187
1188 for (; q = n / 2, r = n % 2, r == 0; n = q) {
1189 VALUE tmp = f_sub(f_mul(xr, xr), f_mul(xi, xi));
1190 xi = f_mul(f_mul(TWO, xr), xi);
1191 xr = tmp;
1192 }
1193 comp_mul(zr, zi, xr, xi, &zr, &zi);
1194 }
1195 }
1196 return nucomp_s_new_internal(CLASS_OF(self), zr, zi);
1197 }
1198 }
1199 if (k_numeric_p(other) && f_real_p(other)) {
1200 VALUE r, theta;
1201
1202 if (RB_BIGNUM_TYPE_P(other))
1203 rb_warn("in a**b, b may be too big");
1204
1205 r = f_abs(self);
1206 theta = f_arg(self);
1207
1208 return f_complex_polar(CLASS_OF(self), f_expt(r, other),
1209 f_mul(theta, other));
1210 }
1211 return rb_num_coerce_bin(self, other, id_expt);
1212}
1213
1214/*
1215 * call-seq:
1216 * complex == object -> true or false
1217 *
1218 * Returns +true+ if <tt>self.real == object.real</tt>
1219 * and <tt>self.imag == object.imag</tt>:
1220 *
1221 * Complex(2, 3) == Complex(2.0, 3.0) # => true
1222 *
1223 */
1224static VALUE
1225nucomp_eqeq_p(VALUE self, VALUE other)
1226{
1227 if (RB_TYPE_P(other, T_COMPLEX)) {
1228 get_dat2(self, other);
1229
1230 return RBOOL(f_eqeq_p(adat->real, bdat->real) &&
1231 f_eqeq_p(adat->imag, bdat->imag));
1232 }
1233 if (k_numeric_p(other) && f_real_p(other)) {
1234 get_dat1(self);
1235
1236 return RBOOL(f_eqeq_p(dat->real, other) && f_zero_p(dat->imag));
1237 }
1238 return RBOOL(f_eqeq_p(other, self));
1239}
1240
1241static bool
1242nucomp_real_p(VALUE self)
1243{
1244 get_dat1(self);
1245 return f_zero_p(dat->imag);
1246}
1247
1248/*
1249 * call-seq:
1250 * complex <=> object -> -1, 0, 1, or nil
1251 *
1252 * Returns:
1253 *
1254 * - <tt>self.real <=> object.real</tt> if both of the following are true:
1255 *
1256 * - <tt>self.imag == 0</tt>.
1257 * - <tt>object.imag == 0</tt>. # Always true if object is numeric but not complex.
1258 *
1259 * - +nil+ otherwise.
1260 *
1261 * Examples:
1262 *
1263 * Complex(2) <=> 3 # => -1
1264 * Complex(2) <=> 2 # => 0
1265 * Complex(2) <=> 1 # => 1
1266 * Complex(2, 1) <=> 1 # => nil # self.imag not zero.
1267 * Complex(1) <=> Complex(1, 1) # => nil # object.imag not zero.
1268 * Complex(1) <=> 'Foo' # => nil # object.imag not defined.
1269 *
1270 */
1271static VALUE
1272nucomp_cmp(VALUE self, VALUE other)
1273{
1274 if (!k_numeric_p(other)) {
1275 return rb_num_coerce_cmp(self, other, idCmp);
1276 }
1277 if (!nucomp_real_p(self)) {
1278 return Qnil;
1279 }
1280 if (RB_TYPE_P(other, T_COMPLEX)) {
1281 if (nucomp_real_p(other)) {
1282 get_dat2(self, other);
1283 return rb_funcall(adat->real, idCmp, 1, bdat->real);
1284 }
1285 }
1286 else {
1287 get_dat1(self);
1288 if (f_real_p(other)) {
1289 return rb_funcall(dat->real, idCmp, 1, other);
1290 }
1291 else {
1292 return rb_num_coerce_cmp(dat->real, other, idCmp);
1293 }
1294 }
1295 return Qnil;
1296}
1297
1298/* :nodoc: */
1299static VALUE
1300nucomp_coerce(VALUE self, VALUE other)
1301{
1302 if (RB_TYPE_P(other, T_COMPLEX))
1303 return rb_assoc_new(other, self);
1304 if (k_numeric_p(other) && f_real_p(other))
1305 return rb_assoc_new(f_complex_new_bang1(CLASS_OF(self), other), self);
1306
1307 rb_raise(rb_eTypeError, "%"PRIsVALUE" can't be coerced into %"PRIsVALUE,
1308 rb_obj_class(other), rb_obj_class(self));
1309 return Qnil;
1310}
1311
1312/*
1313 * call-seq:
1314 * abs -> float
1315 *
1316 * Returns the absolute value (magnitude) for +self+;
1317 * see {polar coordinates}[rdoc-ref:Complex@Polar+Coordinates]:
1318 *
1319 * Complex.polar(-1, 0).abs # => 1.0
1320 *
1321 * If +self+ was created with
1322 * {rectangular coordinates}[rdoc-ref:Complex@Rectangular+Coordinates], the returned value
1323 * is computed, and may be inexact:
1324 *
1325 * Complex.rectangular(1, 1).abs # => 1.4142135623730951 # The square root of 2.
1326 *
1327 */
1328VALUE
1329rb_complex_abs(VALUE self)
1330{
1331 get_dat1(self);
1332
1333 if (f_zero_p(dat->real)) {
1334 VALUE a = f_abs(dat->imag);
1335 if (RB_FLOAT_TYPE_P(dat->real) && !RB_FLOAT_TYPE_P(dat->imag))
1336 a = f_to_f(a);
1337 return a;
1338 }
1339 if (f_zero_p(dat->imag)) {
1340 VALUE a = f_abs(dat->real);
1341 if (!RB_FLOAT_TYPE_P(dat->real) && RB_FLOAT_TYPE_P(dat->imag))
1342 a = f_to_f(a);
1343 return a;
1344 }
1345 return rb_math_hypot(dat->real, dat->imag);
1346}
1347
1348/*
1349 * call-seq:
1350 * abs2 -> float
1351 *
1352 * Returns square of the absolute value (magnitude) for +self+;
1353 * see {polar coordinates}[rdoc-ref:Complex@Polar+Coordinates]:
1354 *
1355 * Complex.polar(2, 2).abs2 # => 4.0
1356 *
1357 * If +self+ was created with
1358 * {rectangular coordinates}[rdoc-ref:Complex@Rectangular+Coordinates], the returned value
1359 * is computed, and may be inexact:
1360 *
1361 * Complex.rectangular(1.0/3, 1.0/3).abs2 # => 0.2222222222222222
1362 *
1363 */
1364static VALUE
1365nucomp_abs2(VALUE self)
1366{
1367 get_dat1(self);
1368 return f_add(f_mul(dat->real, dat->real),
1369 f_mul(dat->imag, dat->imag));
1370}
1371
1372/*
1373 * call-seq:
1374 * arg -> float
1375 *
1376 * Returns the argument (angle) for +self+ in radians;
1377 * see {polar coordinates}[rdoc-ref:Complex@Polar+Coordinates]:
1378 *
1379 * Complex.polar(3, Math::PI/2).arg # => 1.57079632679489660
1380 *
1381 * If +self+ was created with
1382 * {rectangular coordinates}[rdoc-ref:Complex@Rectangular+Coordinates], the returned value
1383 * is computed, and may be inexact:
1384 *
1385 * Complex.polar(1, 1.0/3).arg # => 0.33333333333333326
1386 *
1387 */
1388VALUE
1389rb_complex_arg(VALUE self)
1390{
1391 get_dat1(self);
1392 return rb_math_atan2(dat->imag, dat->real);
1393}
1394
1395/*
1396 * call-seq:
1397 * rect -> array
1398 *
1399 * Returns the array <tt>[self.real, self.imag]</tt>:
1400 *
1401 * Complex.rect(1, 2).rect # => [1, 2]
1402 *
1403 * See {Rectangular Coordinates}[rdoc-ref:Complex@Rectangular+Coordinates].
1404 *
1405 * If +self+ was created with
1406 * {polar coordinates}[rdoc-ref:Complex@Polar+Coordinates], the returned value
1407 * is computed, and may be inexact:
1408 *
1409 * Complex.polar(1.0, 1.0).rect # => [0.5403023058681398, 0.8414709848078965]
1410 *
1411 *
1412 * Complex#rectangular is an alias for Complex#rect.
1413 */
1414static VALUE
1415nucomp_rect(VALUE self)
1416{
1417 get_dat1(self);
1418 return rb_assoc_new(dat->real, dat->imag);
1419}
1420
1421/*
1422 * call-seq:
1423 * polar -> array
1424 *
1425 * Returns the array <tt>[self.abs, self.arg]</tt>:
1426 *
1427 * Complex.polar(1, 2).polar # => [1.0, 2.0]
1428 *
1429 * See {Polar Coordinates}[rdoc-ref:Complex@Polar+Coordinates].
1430 *
1431 * If +self+ was created with
1432 * {rectangular coordinates}[rdoc-ref:Complex@Rectangular+Coordinates], the returned value
1433 * is computed, and may be inexact:
1434 *
1435 * Complex.rect(1, 1).polar # => [1.4142135623730951, 0.7853981633974483]
1436 *
1437 */
1438static VALUE
1439nucomp_polar(VALUE self)
1440{
1441 return rb_assoc_new(f_abs(self), f_arg(self));
1442}
1443
1444/*
1445 * call-seq:
1446 * conj -> complex
1447 *
1448 * Returns the conjugate of +self+, <tt>Complex.rect(self.imag, self.real)</tt>:
1449 *
1450 * Complex.rect(1, 2).conj # => (1-2i)
1451 *
1452 */
1453VALUE
1454rb_complex_conjugate(VALUE self)
1455{
1456 get_dat1(self);
1457 return f_complex_new2(CLASS_OF(self), dat->real, f_negate(dat->imag));
1458}
1459
1460/*
1461 * call-seq:
1462 * real? -> false
1463 *
1464 * Returns +false+; for compatibility with Numeric#real?.
1465 */
1466static VALUE
1467nucomp_real_p_m(VALUE self)
1468{
1469 return Qfalse;
1470}
1471
1472/*
1473 * call-seq:
1474 * denominator -> integer
1475 *
1476 * Returns the denominator of +self+, which is
1477 * the {least common multiple}[https://en.wikipedia.org/wiki/Least_common_multiple]
1478 * of <tt>self.real.denominator</tt> and <tt>self.imag.denominator</tt>:
1479 *
1480 * Complex.rect(Rational(1, 2), Rational(2, 3)).denominator # => 6
1481 *
1482 * Note that <tt>n.denominator</tt> of a non-rational numeric is +1+.
1483 *
1484 * Related: Complex#numerator.
1485 */
1486static VALUE
1487nucomp_denominator(VALUE self)
1488{
1489 get_dat1(self);
1490 return rb_lcm(f_denominator(dat->real), f_denominator(dat->imag));
1491}
1492
1493/*
1494 * call-seq:
1495 * numerator -> new_complex
1496 *
1497 * Returns the \Complex object created from the numerators
1498 * of the real and imaginary parts of +self+,
1499 * after converting each part to the
1500 * {lowest common denominator}[https://en.wikipedia.org/wiki/Lowest_common_denominator]
1501 * of the two:
1502 *
1503 * c = Complex(Rational(2, 3), Rational(3, 4)) # => ((2/3)+(3/4)*i)
1504 * c.numerator # => (8+9i)
1505 *
1506 * In this example, the lowest common denominator of the two parts is 12;
1507 * the two converted parts may be thought of as \Rational(8, 12) and \Rational(9, 12),
1508 * whose numerators, respectively, are 8 and 9;
1509 * so the returned value of <tt>c.numerator</tt> is <tt>Complex(8, 9)</tt>.
1510 *
1511 * Related: Complex#denominator.
1512 */
1513static VALUE
1514nucomp_numerator(VALUE self)
1515{
1516 VALUE cd;
1517
1518 get_dat1(self);
1519
1520 cd = nucomp_denominator(self);
1521 return f_complex_new2(CLASS_OF(self),
1522 f_mul(f_numerator(dat->real),
1523 f_div(cd, f_denominator(dat->real))),
1524 f_mul(f_numerator(dat->imag),
1525 f_div(cd, f_denominator(dat->imag))));
1526}
1527
1528/* :nodoc: */
1529st_index_t
1530rb_complex_hash(VALUE self)
1531{
1532 st_index_t v, h[2];
1533 VALUE n;
1534
1535 get_dat1(self);
1536 n = rb_hash(dat->real);
1537 h[0] = NUM2LONG(n);
1538 n = rb_hash(dat->imag);
1539 h[1] = NUM2LONG(n);
1540 v = rb_memhash(h, sizeof(h));
1541 return v;
1542}
1543
1544/*
1545 * :call-seq:
1546 * hash -> integer
1547 *
1548 * Returns the integer hash value for +self+.
1549 *
1550 * Two \Complex objects created from the same values will have the same hash value
1551 * (and will compare using #eql?):
1552 *
1553 * Complex(1, 2).hash == Complex(1, 2).hash # => true
1554 *
1555 */
1556static VALUE
1557nucomp_hash(VALUE self)
1558{
1559 return ST2FIX(rb_complex_hash(self));
1560}
1561
1562/* :nodoc: */
1563static VALUE
1564nucomp_eql_p(VALUE self, VALUE other)
1565{
1566 if (RB_TYPE_P(other, T_COMPLEX)) {
1567 get_dat2(self, other);
1568
1569 return RBOOL((CLASS_OF(adat->real) == CLASS_OF(bdat->real)) &&
1570 (CLASS_OF(adat->imag) == CLASS_OF(bdat->imag)) &&
1571 f_eqeq_p(self, other));
1572
1573 }
1574 return Qfalse;
1575}
1576
1577inline static int
1578f_signbit(VALUE x)
1579{
1580 if (RB_FLOAT_TYPE_P(x)) {
1581 double f = RFLOAT_VALUE(x);
1582 return !isnan(f) && signbit(f);
1583 }
1584 return f_negative_p(x);
1585}
1586
1587inline static int
1588f_tpositive_p(VALUE x)
1589{
1590 return !f_signbit(x);
1591}
1592
1593static VALUE
1594f_format(VALUE self, VALUE (*func)(VALUE))
1595{
1596 VALUE s;
1597 int impos;
1598
1599 get_dat1(self);
1600
1601 impos = f_tpositive_p(dat->imag);
1602
1603 s = (*func)(dat->real);
1604 rb_str_cat2(s, !impos ? "-" : "+");
1605
1606 rb_str_concat(s, (*func)(f_abs(dat->imag)));
1607 if (!rb_isdigit(RSTRING_PTR(s)[RSTRING_LEN(s) - 1]))
1608 rb_str_cat2(s, "*");
1609 rb_str_cat2(s, "i");
1610
1611 return s;
1612}
1613
1614/*
1615 * call-seq:
1616 * to_s -> string
1617 *
1618 * Returns a string representation of +self+:
1619 *
1620 * Complex(2).to_s # => "2+0i"
1621 * Complex('-8/6').to_s # => "-4/3+0i"
1622 * Complex('1/2i').to_s # => "0+1/2i"
1623 * Complex(0, Float::INFINITY).to_s # => "0+Infinity*i"
1624 * Complex(Float::NAN, Float::NAN).to_s # => "NaN+NaN*i"
1625 *
1626 */
1627static VALUE
1628nucomp_to_s(VALUE self)
1629{
1630 return f_format(self, rb_String);
1631}
1632
1633/*
1634 * call-seq:
1635 * inspect -> string
1636 *
1637 * Returns a string representation of +self+:
1638 *
1639 * Complex(2).inspect # => "(2+0i)"
1640 * Complex('-8/6').inspect # => "((-4/3)+0i)"
1641 * Complex('1/2i').inspect # => "(0+(1/2)*i)"
1642 * Complex(0, Float::INFINITY).inspect # => "(0+Infinity*i)"
1643 * Complex(Float::NAN, Float::NAN).inspect # => "(NaN+NaN*i)"
1644 *
1645 */
1646static VALUE
1647nucomp_inspect(VALUE self)
1648{
1649 VALUE s;
1650
1651 s = rb_usascii_str_new2("(");
1652 rb_str_concat(s, f_format(self, rb_inspect));
1653 rb_str_cat2(s, ")");
1654
1655 return s;
1656}
1657
1658#define FINITE_TYPE_P(v) (RB_INTEGER_TYPE_P(v) || RB_TYPE_P(v, T_RATIONAL))
1659
1660/*
1661 * call-seq:
1662 * finite? -> true or false
1663 *
1664 * Returns +true+ if both <tt>self.real.finite?</tt> and <tt>self.imag.finite?</tt>
1665 * are true, +false+ otherwise:
1666 *
1667 * Complex(1, 1).finite? # => true
1668 * Complex(Float::INFINITY, 0).finite? # => false
1669 *
1670 * Related: Numeric#finite?, Float#finite?.
1671 */
1672static VALUE
1673rb_complex_finite_p(VALUE self)
1674{
1675 get_dat1(self);
1676
1677 return RBOOL(f_finite_p(dat->real) && f_finite_p(dat->imag));
1678}
1679
1680/*
1681 * call-seq:
1682 * infinite? -> 1 or nil
1683 *
1684 * Returns +1+ if either <tt>self.real.infinite?</tt> or <tt>self.imag.infinite?</tt>
1685 * is true, +nil+ otherwise:
1686 *
1687 * Complex(Float::INFINITY, 0).infinite? # => 1
1688 * Complex(1, 1).infinite? # => nil
1689 *
1690 * Related: Numeric#infinite?, Float#infinite?.
1691 */
1692static VALUE
1693rb_complex_infinite_p(VALUE self)
1694{
1695 get_dat1(self);
1696
1697 if (!f_infinite_p(dat->real) && !f_infinite_p(dat->imag)) {
1698 return Qnil;
1699 }
1700 return ONE;
1701}
1702
1703/* :nodoc: */
1704static VALUE
1705nucomp_dumper(VALUE self)
1706{
1707 return self;
1708}
1709
1710/* :nodoc: */
1711static VALUE
1712nucomp_loader(VALUE self, VALUE a)
1713{
1714 get_dat1(self);
1715
1716 RCOMPLEX_SET_REAL(dat, rb_ivar_get(a, id_i_real));
1717 RCOMPLEX_SET_IMAG(dat, rb_ivar_get(a, id_i_imag));
1718 OBJ_FREEZE_RAW(self);
1719
1720 return self;
1721}
1722
1723/* :nodoc: */
1724static VALUE
1725nucomp_marshal_dump(VALUE self)
1726{
1727 VALUE a;
1728 get_dat1(self);
1729
1730 a = rb_assoc_new(dat->real, dat->imag);
1731 rb_copy_generic_ivar(a, self);
1732 return a;
1733}
1734
1735/* :nodoc: */
1736static VALUE
1737nucomp_marshal_load(VALUE self, VALUE a)
1738{
1739 Check_Type(a, T_ARRAY);
1740 if (RARRAY_LEN(a) != 2)
1741 rb_raise(rb_eArgError, "marshaled complex must have an array whose length is 2 but %ld", RARRAY_LEN(a));
1742 rb_ivar_set(self, id_i_real, RARRAY_AREF(a, 0));
1743 rb_ivar_set(self, id_i_imag, RARRAY_AREF(a, 1));
1744 return self;
1745}
1746
1747VALUE
1748rb_complex_raw(VALUE x, VALUE y)
1749{
1750 return nucomp_s_new_internal(rb_cComplex, x, y);
1751}
1752
1753VALUE
1754rb_complex_new(VALUE x, VALUE y)
1755{
1756 return nucomp_s_canonicalize_internal(rb_cComplex, x, y);
1757}
1758
1759VALUE
1760rb_complex_new_polar(VALUE x, VALUE y)
1761{
1762 return f_complex_polar(rb_cComplex, x, y);
1763}
1764
1765VALUE
1767{
1768 return rb_complex_new_polar(x, y);
1769}
1770
1771VALUE
1772rb_Complex(VALUE x, VALUE y)
1773{
1774 VALUE a[2];
1775 a[0] = x;
1776 a[1] = y;
1777 return nucomp_s_convert(2, a, rb_cComplex);
1778}
1779
1780VALUE
1781rb_dbl_complex_new(double real, double imag)
1782{
1783 return rb_complex_raw(DBL2NUM(real), DBL2NUM(imag));
1784}
1785
1786/*
1787 * call-seq:
1788 * to_i -> integer
1789 *
1790 * Returns the value of <tt>self.real</tt> as an Integer, if possible:
1791 *
1792 * Complex(1, 0).to_i # => 1
1793 * Complex(1, Rational(0, 1)).to_i # => 1
1794 *
1795 * Raises RangeError if <tt>self.imag</tt> is not exactly zero
1796 * (either <tt>Integer(0)</tt> or <tt>Rational(0, _n_)</tt>).
1797 */
1798static VALUE
1799nucomp_to_i(VALUE self)
1800{
1801 get_dat1(self);
1802
1803 if (!k_exact_zero_p(dat->imag)) {
1804 rb_raise(rb_eRangeError, "can't convert %"PRIsVALUE" into Integer",
1805 self);
1806 }
1807 return f_to_i(dat->real);
1808}
1809
1810/*
1811 * call-seq:
1812 * to_f -> float
1813 *
1814 * Returns the value of <tt>self.real</tt> as a Float, if possible:
1815 *
1816 * Complex(1, 0).to_f # => 1.0
1817 * Complex(1, Rational(0, 1)).to_f # => 1.0
1818 *
1819 * Raises RangeError if <tt>self.imag</tt> is not exactly zero
1820 * (either <tt>Integer(0)</tt> or <tt>Rational(0, _n_)</tt>).
1821 */
1822static VALUE
1823nucomp_to_f(VALUE self)
1824{
1825 get_dat1(self);
1826
1827 if (!k_exact_zero_p(dat->imag)) {
1828 rb_raise(rb_eRangeError, "can't convert %"PRIsVALUE" into Float",
1829 self);
1830 }
1831 return f_to_f(dat->real);
1832}
1833
1834/*
1835 * call-seq:
1836 * to_r -> rational
1837 *
1838 * Returns the value of <tt>self.real</tt> as a Rational, if possible:
1839 *
1840 * Complex(1, 0).to_r # => (1/1)
1841 * Complex(1, Rational(0, 1)).to_r # => (1/1)
1842 *
1843 * Raises RangeError if <tt>self.imag</tt> is not exactly zero
1844 * (either <tt>Integer(0)</tt> or <tt>Rational(0, _n_)</tt>).
1845 *
1846 * Related: Complex#rationalize.
1847 */
1848static VALUE
1849nucomp_to_r(VALUE self)
1850{
1851 get_dat1(self);
1852
1853 if (!k_exact_zero_p(dat->imag)) {
1854 rb_raise(rb_eRangeError, "can't convert %"PRIsVALUE" into Rational",
1855 self);
1856 }
1857 return f_to_r(dat->real);
1858}
1859
1860/*
1861 * call-seq:
1862 * rationalize(epsilon = nil) -> rational
1863 *
1864 * Returns a Rational object whose value is exactly or approximately
1865 * equivalent to that of <tt>self.real</tt>.
1866 *
1867 * With no argument +epsilon+ given, returns a \Rational object
1868 * whose value is exactly equal to that of <tt>self.real.rationalize</tt>:
1869 *
1870 * Complex(1, 0).rationalize # => (1/1)
1871 * Complex(1, Rational(0, 1)).rationalize # => (1/1)
1872 * Complex(3.14159, 0).rationalize # => (314159/100000)
1873 *
1874 * With argument +epsilon+ given, returns a \Rational object
1875 * whose value is exactly or approximately equal to that of <tt>self.real</tt>
1876 * to the given precision:
1877 *
1878 * Complex(3.14159, 0).rationalize(0.1) # => (16/5)
1879 * Complex(3.14159, 0).rationalize(0.01) # => (22/7)
1880 * Complex(3.14159, 0).rationalize(0.001) # => (201/64)
1881 * Complex(3.14159, 0).rationalize(0.0001) # => (333/106)
1882 * Complex(3.14159, 0).rationalize(0.00001) # => (355/113)
1883 * Complex(3.14159, 0).rationalize(0.000001) # => (7433/2366)
1884 * Complex(3.14159, 0).rationalize(0.0000001) # => (9208/2931)
1885 * Complex(3.14159, 0).rationalize(0.00000001) # => (47460/15107)
1886 * Complex(3.14159, 0).rationalize(0.000000001) # => (76149/24239)
1887 * Complex(3.14159, 0).rationalize(0.0000000001) # => (314159/100000)
1888 * Complex(3.14159, 0).rationalize(0.0) # => (3537115888337719/1125899906842624)
1889 *
1890 * Related: Complex#to_r.
1891 */
1892static VALUE
1893nucomp_rationalize(int argc, VALUE *argv, VALUE self)
1894{
1895 get_dat1(self);
1896
1897 rb_check_arity(argc, 0, 1);
1898
1899 if (!k_exact_zero_p(dat->imag)) {
1900 rb_raise(rb_eRangeError, "can't convert %"PRIsVALUE" into Rational",
1901 self);
1902 }
1903 return rb_funcallv(dat->real, id_rationalize, argc, argv);
1904}
1905
1906/*
1907 * call-seq:
1908 * to_c -> self
1909 *
1910 * Returns +self+.
1911 */
1912static VALUE
1913nucomp_to_c(VALUE self)
1914{
1915 return self;
1916}
1917
1918/*
1919 * call-seq:
1920 * to_c -> (0+0i)
1921 *
1922 * Returns zero as a Complex:
1923 *
1924 * nil.to_c # => (0+0i)
1925 *
1926 */
1927static VALUE
1928nilclass_to_c(VALUE self)
1929{
1930 return rb_complex_new1(INT2FIX(0));
1931}
1932
1933/*
1934 * call-seq:
1935 * to_c -> complex
1936 *
1937 * Returns +self+ as a Complex object.
1938 */
1939static VALUE
1940numeric_to_c(VALUE self)
1941{
1942 return rb_complex_new1(self);
1943}
1944
1945inline static int
1946issign(int c)
1947{
1948 return (c == '-' || c == '+');
1949}
1950
1951static int
1952read_sign(const char **s,
1953 char **b)
1954{
1955 int sign = '?';
1956
1957 if (issign(**s)) {
1958 sign = **b = **s;
1959 (*s)++;
1960 (*b)++;
1961 }
1962 return sign;
1963}
1964
1965inline static int
1966isdecimal(int c)
1967{
1968 return isdigit((unsigned char)c);
1969}
1970
1971static int
1972read_digits(const char **s, int strict,
1973 char **b)
1974{
1975 int us = 1;
1976
1977 if (!isdecimal(**s))
1978 return 0;
1979
1980 while (isdecimal(**s) || **s == '_') {
1981 if (**s == '_') {
1982 if (us) {
1983 if (strict) return 0;
1984 break;
1985 }
1986 us = 1;
1987 }
1988 else {
1989 **b = **s;
1990 (*b)++;
1991 us = 0;
1992 }
1993 (*s)++;
1994 }
1995 if (us)
1996 do {
1997 (*s)--;
1998 } while (**s == '_');
1999 return 1;
2000}
2001
2002inline static int
2003islettere(int c)
2004{
2005 return (c == 'e' || c == 'E');
2006}
2007
2008static int
2009read_num(const char **s, int strict,
2010 char **b)
2011{
2012 if (**s != '.') {
2013 if (!read_digits(s, strict, b))
2014 return 0;
2015 }
2016
2017 if (**s == '.') {
2018 **b = **s;
2019 (*s)++;
2020 (*b)++;
2021 if (!read_digits(s, strict, b)) {
2022 (*b)--;
2023 return 0;
2024 }
2025 }
2026
2027 if (islettere(**s)) {
2028 **b = **s;
2029 (*s)++;
2030 (*b)++;
2031 read_sign(s, b);
2032 if (!read_digits(s, strict, b)) {
2033 (*b)--;
2034 return 0;
2035 }
2036 }
2037 return 1;
2038}
2039
2040inline static int
2041read_den(const char **s, int strict,
2042 char **b)
2043{
2044 if (!read_digits(s, strict, b))
2045 return 0;
2046 return 1;
2047}
2048
2049static int
2050read_rat_nos(const char **s, int strict,
2051 char **b)
2052{
2053 if (!read_num(s, strict, b))
2054 return 0;
2055 if (**s == '/') {
2056 **b = **s;
2057 (*s)++;
2058 (*b)++;
2059 if (!read_den(s, strict, b)) {
2060 (*b)--;
2061 return 0;
2062 }
2063 }
2064 return 1;
2065}
2066
2067static int
2068read_rat(const char **s, int strict,
2069 char **b)
2070{
2071 read_sign(s, b);
2072 if (!read_rat_nos(s, strict, b))
2073 return 0;
2074 return 1;
2075}
2076
2077inline static int
2078isimagunit(int c)
2079{
2080 return (c == 'i' || c == 'I' ||
2081 c == 'j' || c == 'J');
2082}
2083
2084static VALUE
2085str2num(char *s)
2086{
2087 if (strchr(s, '/'))
2088 return rb_cstr_to_rat(s, 0);
2089 if (strpbrk(s, ".eE"))
2090 return DBL2NUM(rb_cstr_to_dbl(s, 0));
2091 return rb_cstr_to_inum(s, 10, 0);
2092}
2093
2094static int
2095read_comp(const char **s, int strict,
2096 VALUE *ret, char **b)
2097{
2098 char *bb;
2099 int sign;
2100 VALUE num, num2;
2101
2102 bb = *b;
2103
2104 sign = read_sign(s, b);
2105
2106 if (isimagunit(**s)) {
2107 (*s)++;
2108 num = INT2FIX((sign == '-') ? -1 : + 1);
2109 *ret = rb_complex_new2(ZERO, num);
2110 return 1; /* e.g. "i" */
2111 }
2112
2113 if (!read_rat_nos(s, strict, b)) {
2114 **b = '\0';
2115 num = str2num(bb);
2116 *ret = rb_complex_new2(num, ZERO);
2117 return 0; /* e.g. "-" */
2118 }
2119 **b = '\0';
2120 num = str2num(bb);
2121
2122 if (isimagunit(**s)) {
2123 (*s)++;
2124 *ret = rb_complex_new2(ZERO, num);
2125 return 1; /* e.g. "3i" */
2126 }
2127
2128 if (**s == '@') {
2129 int st;
2130
2131 (*s)++;
2132 bb = *b;
2133 st = read_rat(s, strict, b);
2134 **b = '\0';
2135 if (strlen(bb) < 1 ||
2136 !isdecimal(*(bb + strlen(bb) - 1))) {
2137 *ret = rb_complex_new2(num, ZERO);
2138 return 0; /* e.g. "1@-" */
2139 }
2140 num2 = str2num(bb);
2141 *ret = rb_complex_new_polar(num, num2);
2142 if (!st)
2143 return 0; /* e.g. "1@2." */
2144 else
2145 return 1; /* e.g. "1@2" */
2146 }
2147
2148 if (issign(**s)) {
2149 bb = *b;
2150 sign = read_sign(s, b);
2151 if (isimagunit(**s))
2152 num2 = INT2FIX((sign == '-') ? -1 : + 1);
2153 else {
2154 if (!read_rat_nos(s, strict, b)) {
2155 *ret = rb_complex_new2(num, ZERO);
2156 return 0; /* e.g. "1+xi" */
2157 }
2158 **b = '\0';
2159 num2 = str2num(bb);
2160 }
2161 if (!isimagunit(**s)) {
2162 *ret = rb_complex_new2(num, ZERO);
2163 return 0; /* e.g. "1+3x" */
2164 }
2165 (*s)++;
2166 *ret = rb_complex_new2(num, num2);
2167 return 1; /* e.g. "1+2i" */
2168 }
2169 /* !(@, - or +) */
2170 {
2171 *ret = rb_complex_new2(num, ZERO);
2172 return 1; /* e.g. "3" */
2173 }
2174}
2175
2176inline static void
2177skip_ws(const char **s)
2178{
2179 while (isspace((unsigned char)**s))
2180 (*s)++;
2181}
2182
2183static int
2184parse_comp(const char *s, int strict, VALUE *num)
2185{
2186 char *buf, *b;
2187 VALUE tmp;
2188 int ret = 1;
2189
2190 buf = ALLOCV_N(char, tmp, strlen(s) + 1);
2191 b = buf;
2192
2193 skip_ws(&s);
2194 if (!read_comp(&s, strict, num, &b)) {
2195 ret = 0;
2196 }
2197 else {
2198 skip_ws(&s);
2199
2200 if (strict)
2201 if (*s != '\0')
2202 ret = 0;
2203 }
2204 ALLOCV_END(tmp);
2205
2206 return ret;
2207}
2208
2209static VALUE
2210string_to_c_strict(VALUE self, int raise)
2211{
2212 char *s;
2213 VALUE num;
2214
2215 rb_must_asciicompat(self);
2216
2217 if (raise) {
2218 s = StringValueCStr(self);
2219 }
2220 else if (!(s = rb_str_to_cstr(self))) {
2221 return Qnil;
2222 }
2223
2224 if (!parse_comp(s, TRUE, &num)) {
2225 if (!raise) return Qnil;
2226 rb_raise(rb_eArgError, "invalid value for convert(): %+"PRIsVALUE,
2227 self);
2228 }
2229
2230 return num;
2231}
2232
2233/*
2234 * call-seq:
2235 * to_c -> complex
2236 *
2237 * Returns +self+ interpreted as a Complex object;
2238 * leading whitespace and trailing garbage are ignored:
2239 *
2240 * '9'.to_c # => (9+0i)
2241 * '2.5'.to_c # => (2.5+0i)
2242 * '2.5/1'.to_c # => ((5/2)+0i)
2243 * '-3/2'.to_c # => ((-3/2)+0i)
2244 * '-i'.to_c # => (0-1i)
2245 * '45i'.to_c # => (0+45i)
2246 * '3-4i'.to_c # => (3-4i)
2247 * '-4e2-4e-2i'.to_c # => (-400.0-0.04i)
2248 * '-0.0-0.0i'.to_c # => (-0.0-0.0i)
2249 * '1/2+3/4i'.to_c # => ((1/2)+(3/4)*i)
2250 * '1.0@0'.to_c # => (1+0.0i)
2251 * "1.0@#{Math::PI/2}".to_c # => (0.0+1i)
2252 * "1.0@#{Math::PI}".to_c # => (-1+0.0i)
2253 *
2254 * Returns \Complex zero if the string cannot be converted:
2255 *
2256 * 'ruby'.to_c # => (0+0i)
2257 *
2258 * See Kernel#Complex.
2259 */
2260static VALUE
2261string_to_c(VALUE self)
2262{
2263 VALUE num;
2264
2265 rb_must_asciicompat(self);
2266
2267 (void)parse_comp(rb_str_fill_terminator(self, 1), FALSE, &num);
2268
2269 return num;
2270}
2271
2272static VALUE
2273to_complex(VALUE val)
2274{
2275 return rb_convert_type(val, T_COMPLEX, "Complex", "to_c");
2276}
2277
2278static VALUE
2279nucomp_convert(VALUE klass, VALUE a1, VALUE a2, int raise)
2280{
2281 if (NIL_P(a1) || NIL_P(a2)) {
2282 if (!raise) return Qnil;
2283 rb_raise(rb_eTypeError, "can't convert nil into Complex");
2284 }
2285
2286 if (RB_TYPE_P(a1, T_STRING)) {
2287 a1 = string_to_c_strict(a1, raise);
2288 if (NIL_P(a1)) return Qnil;
2289 }
2290
2291 if (RB_TYPE_P(a2, T_STRING)) {
2292 a2 = string_to_c_strict(a2, raise);
2293 if (NIL_P(a2)) return Qnil;
2294 }
2295
2296 if (RB_TYPE_P(a1, T_COMPLEX)) {
2297 {
2298 get_dat1(a1);
2299
2300 if (k_exact_zero_p(dat->imag))
2301 a1 = dat->real;
2302 }
2303 }
2304
2305 if (RB_TYPE_P(a2, T_COMPLEX)) {
2306 {
2307 get_dat1(a2);
2308
2309 if (k_exact_zero_p(dat->imag))
2310 a2 = dat->real;
2311 }
2312 }
2313
2314 if (RB_TYPE_P(a1, T_COMPLEX)) {
2315 if (UNDEF_P(a2) || (k_exact_zero_p(a2)))
2316 return a1;
2317 }
2318
2319 if (UNDEF_P(a2)) {
2320 if (k_numeric_p(a1) && !f_real_p(a1))
2321 return a1;
2322 /* should raise exception for consistency */
2323 if (!k_numeric_p(a1)) {
2324 if (!raise) {
2325 a1 = rb_protect(to_complex, a1, NULL);
2326 rb_set_errinfo(Qnil);
2327 return a1;
2328 }
2329 return to_complex(a1);
2330 }
2331 }
2332 else {
2333 if ((k_numeric_p(a1) && k_numeric_p(a2)) &&
2334 (!f_real_p(a1) || !f_real_p(a2)))
2335 return f_add(a1,
2336 f_mul(a2,
2337 f_complex_new_bang2(rb_cComplex, ZERO, ONE)));
2338 }
2339
2340 {
2341 int argc;
2342 VALUE argv2[2];
2343 argv2[0] = a1;
2344 if (UNDEF_P(a2)) {
2345 argv2[1] = Qnil;
2346 argc = 1;
2347 }
2348 else {
2349 if (!raise && !RB_INTEGER_TYPE_P(a2) && !RB_FLOAT_TYPE_P(a2) && !RB_TYPE_P(a2, T_RATIONAL))
2350 return Qnil;
2351 argv2[1] = a2;
2352 argc = 2;
2353 }
2354 return nucomp_s_new(argc, argv2, klass);
2355 }
2356}
2357
2358static VALUE
2359nucomp_s_convert(int argc, VALUE *argv, VALUE klass)
2360{
2361 VALUE a1, a2;
2362
2363 if (rb_scan_args(argc, argv, "11", &a1, &a2) == 1) {
2364 a2 = Qundef;
2365 }
2366
2367 return nucomp_convert(klass, a1, a2, TRUE);
2368}
2369
2370/*
2371 * call-seq:
2372 * abs2 -> real
2373 *
2374 * Returns the square of +self+.
2375 */
2376static VALUE
2377numeric_abs2(VALUE self)
2378{
2379 return f_mul(self, self);
2380}
2381
2382/*
2383 * call-seq:
2384 * arg -> 0 or Math::PI
2385 *
2386 * Returns zero if +self+ is positive, Math::PI otherwise.
2387 */
2388static VALUE
2389numeric_arg(VALUE self)
2390{
2391 if (f_positive_p(self))
2392 return INT2FIX(0);
2393 return DBL2NUM(M_PI);
2394}
2395
2396/*
2397 * call-seq:
2398 * rect -> array
2399 *
2400 * Returns array <tt>[self, 0]</tt>.
2401 */
2402static VALUE
2403numeric_rect(VALUE self)
2404{
2405 return rb_assoc_new(self, INT2FIX(0));
2406}
2407
2408/*
2409 * call-seq:
2410 * polar -> array
2411 *
2412 * Returns array <tt>[self.abs, self.arg]</tt>.
2413 */
2414static VALUE
2415numeric_polar(VALUE self)
2416{
2417 VALUE abs, arg;
2418
2419 if (RB_INTEGER_TYPE_P(self)) {
2420 abs = rb_int_abs(self);
2421 arg = numeric_arg(self);
2422 }
2423 else if (RB_FLOAT_TYPE_P(self)) {
2424 abs = rb_float_abs(self);
2425 arg = float_arg(self);
2426 }
2427 else if (RB_TYPE_P(self, T_RATIONAL)) {
2428 abs = rb_rational_abs(self);
2429 arg = numeric_arg(self);
2430 }
2431 else {
2432 abs = f_abs(self);
2433 arg = f_arg(self);
2434 }
2435 return rb_assoc_new(abs, arg);
2436}
2437
2438/*
2439 * call-seq:
2440 * arg -> 0 or Math::PI
2441 *
2442 * Returns 0 if +self+ is positive, Math::PI otherwise.
2443 */
2444static VALUE
2445float_arg(VALUE self)
2446{
2447 if (isnan(RFLOAT_VALUE(self)))
2448 return self;
2449 if (f_tpositive_p(self))
2450 return INT2FIX(0);
2451 return rb_const_get(rb_mMath, id_PI);
2452}
2453
2454/*
2455 * A \Complex object houses a pair of values,
2456 * given when the object is created as either <i>rectangular coordinates</i>
2457 * or <i>polar coordinates</i>.
2458 *
2459 * == Rectangular Coordinates
2460 *
2461 * The rectangular coordinates of a complex number
2462 * are called the _real_ and _imaginary_ parts;
2463 * see {Complex number definition}[https://en.wikipedia.org/wiki/Complex_number#Definition].
2464 *
2465 * You can create a \Complex object from rectangular coordinates with:
2466 *
2467 * - A {complex literal}[rdoc-ref:doc/syntax/literals.rdoc@Complex+Literals].
2468 * - \Method Complex.rect.
2469 * - \Method Kernel#Complex, either with numeric arguments or with certain string arguments.
2470 * - \Method String#to_c, for certain strings.
2471 *
2472 * Note that each of the stored parts may be a an instance one of the classes
2473 * Complex, Float, Integer, or Rational;
2474 * they may be retrieved:
2475 *
2476 * - Separately, with methods Complex#real and Complex#imaginary.
2477 * - Together, with method Complex#rect.
2478 *
2479 * The corresponding (computed) polar values may be retrieved:
2480 *
2481 * - Separately, with methods Complex#abs and Complex#arg.
2482 * - Together, with method Complex#polar.
2483 *
2484 * == Polar Coordinates
2485 *
2486 * The polar coordinates of a complex number
2487 * are called the _absolute_ and _argument_ parts;
2488 * see {Complex polar plane}[https://en.wikipedia.org/wiki/Complex_number#Polar_complex_plane].
2489 *
2490 * In this class, the argument part
2491 * in expressed {radians}[https://en.wikipedia.org/wiki/Radian]
2492 * (not {degrees}[https://en.wikipedia.org/wiki/Degree_(angle)]).
2493 *
2494 * You can create a \Complex object from polar coordinates with:
2495 *
2496 * - \Method Complex.polar.
2497 * - \Method Kernel#Complex, with certain string arguments.
2498 * - \Method String#to_c, for certain strings.
2499 *
2500 * Note that each of the stored parts may be a an instance one of the classes
2501 * Complex, Float, Integer, or Rational;
2502 * they may be retrieved:
2503 *
2504 * - Separately, with methods Complex#abs and Complex#arg.
2505 * - Together, with method Complex#polar.
2506 *
2507 * The corresponding (computed) rectangular values may be retrieved:
2508 *
2509 * - Separately, with methods Complex#real and Complex#imag.
2510 * - Together, with method Complex#rect.
2511 *
2512 */
2513void
2514Init_Complex(void)
2515{
2516 VALUE compat;
2517 id_abs = rb_intern_const("abs");
2518 id_arg = rb_intern_const("arg");
2519 id_denominator = rb_intern_const("denominator");
2520 id_numerator = rb_intern_const("numerator");
2521 id_real_p = rb_intern_const("real?");
2522 id_i_real = rb_intern_const("@real");
2523 id_i_imag = rb_intern_const("@image"); /* @image, not @imag */
2524 id_finite_p = rb_intern_const("finite?");
2525 id_infinite_p = rb_intern_const("infinite?");
2526 id_rationalize = rb_intern_const("rationalize");
2527 id_PI = rb_intern_const("PI");
2528
2530
2531 rb_define_alloc_func(rb_cComplex, nucomp_s_alloc);
2532 rb_undef_method(CLASS_OF(rb_cComplex), "allocate");
2533
2535
2536 rb_define_singleton_method(rb_cComplex, "rectangular", nucomp_s_new, -1);
2537 rb_define_singleton_method(rb_cComplex, "rect", nucomp_s_new, -1);
2538 rb_define_singleton_method(rb_cComplex, "polar", nucomp_s_polar, -1);
2539
2540 rb_define_global_function("Complex", nucomp_f_complex, -1);
2541
2542 rb_undef_methods_from(rb_cComplex, RCLASS_ORIGIN(rb_mComparable));
2545 rb_undef_method(rb_cComplex, "divmod");
2546 rb_undef_method(rb_cComplex, "floor");
2548 rb_undef_method(rb_cComplex, "modulo");
2549 rb_undef_method(rb_cComplex, "remainder");
2550 rb_undef_method(rb_cComplex, "round");
2552 rb_undef_method(rb_cComplex, "truncate");
2554
2555 rb_define_method(rb_cComplex, "real", rb_complex_real, 0);
2556 rb_define_method(rb_cComplex, "imaginary", rb_complex_imag, 0);
2557 rb_define_method(rb_cComplex, "imag", rb_complex_imag, 0);
2558
2559 rb_define_method(rb_cComplex, "-@", rb_complex_uminus, 0);
2560 rb_define_method(rb_cComplex, "+", rb_complex_plus, 1);
2561 rb_define_method(rb_cComplex, "-", rb_complex_minus, 1);
2562 rb_define_method(rb_cComplex, "*", rb_complex_mul, 1);
2563 rb_define_method(rb_cComplex, "/", rb_complex_div, 1);
2564 rb_define_method(rb_cComplex, "quo", nucomp_quo, 1);
2565 rb_define_method(rb_cComplex, "fdiv", nucomp_fdiv, 1);
2566 rb_define_method(rb_cComplex, "**", rb_complex_pow, 1);
2567
2568 rb_define_method(rb_cComplex, "==", nucomp_eqeq_p, 1);
2569 rb_define_method(rb_cComplex, "<=>", nucomp_cmp, 1);
2570 rb_define_method(rb_cComplex, "coerce", nucomp_coerce, 1);
2571
2572 rb_define_method(rb_cComplex, "abs", rb_complex_abs, 0);
2573 rb_define_method(rb_cComplex, "magnitude", rb_complex_abs, 0);
2574 rb_define_method(rb_cComplex, "abs2", nucomp_abs2, 0);
2575 rb_define_method(rb_cComplex, "arg", rb_complex_arg, 0);
2576 rb_define_method(rb_cComplex, "angle", rb_complex_arg, 0);
2577 rb_define_method(rb_cComplex, "phase", rb_complex_arg, 0);
2578 rb_define_method(rb_cComplex, "rectangular", nucomp_rect, 0);
2579 rb_define_method(rb_cComplex, "rect", nucomp_rect, 0);
2580 rb_define_method(rb_cComplex, "polar", nucomp_polar, 0);
2581 rb_define_method(rb_cComplex, "conjugate", rb_complex_conjugate, 0);
2582 rb_define_method(rb_cComplex, "conj", rb_complex_conjugate, 0);
2583
2584 rb_define_method(rb_cComplex, "real?", nucomp_real_p_m, 0);
2585
2586 rb_define_method(rb_cComplex, "numerator", nucomp_numerator, 0);
2587 rb_define_method(rb_cComplex, "denominator", nucomp_denominator, 0);
2588
2589 rb_define_method(rb_cComplex, "hash", nucomp_hash, 0);
2590 rb_define_method(rb_cComplex, "eql?", nucomp_eql_p, 1);
2591
2592 rb_define_method(rb_cComplex, "to_s", nucomp_to_s, 0);
2593 rb_define_method(rb_cComplex, "inspect", nucomp_inspect, 0);
2594
2595 rb_undef_method(rb_cComplex, "positive?");
2596 rb_undef_method(rb_cComplex, "negative?");
2597
2598 rb_define_method(rb_cComplex, "finite?", rb_complex_finite_p, 0);
2599 rb_define_method(rb_cComplex, "infinite?", rb_complex_infinite_p, 0);
2600
2601 rb_define_private_method(rb_cComplex, "marshal_dump", nucomp_marshal_dump, 0);
2602 /* :nodoc: */
2603 compat = rb_define_class_under(rb_cComplex, "compatible", rb_cObject);
2604 rb_define_private_method(compat, "marshal_load", nucomp_marshal_load, 1);
2605 rb_marshal_define_compat(rb_cComplex, compat, nucomp_dumper, nucomp_loader);
2606
2607 rb_define_method(rb_cComplex, "to_i", nucomp_to_i, 0);
2608 rb_define_method(rb_cComplex, "to_f", nucomp_to_f, 0);
2609 rb_define_method(rb_cComplex, "to_r", nucomp_to_r, 0);
2610 rb_define_method(rb_cComplex, "rationalize", nucomp_rationalize, -1);
2611 rb_define_method(rb_cComplex, "to_c", nucomp_to_c, 0);
2612 rb_define_method(rb_cNilClass, "to_c", nilclass_to_c, 0);
2613 rb_define_method(rb_cNumeric, "to_c", numeric_to_c, 0);
2614
2615 rb_define_method(rb_cString, "to_c", string_to_c, 0);
2616
2617 rb_define_private_method(CLASS_OF(rb_cComplex), "convert", nucomp_s_convert, -1);
2618
2619 rb_define_method(rb_cNumeric, "abs2", numeric_abs2, 0);
2620 rb_define_method(rb_cNumeric, "arg", numeric_arg, 0);
2621 rb_define_method(rb_cNumeric, "angle", numeric_arg, 0);
2622 rb_define_method(rb_cNumeric, "phase", numeric_arg, 0);
2623 rb_define_method(rb_cNumeric, "rectangular", numeric_rect, 0);
2624 rb_define_method(rb_cNumeric, "rect", numeric_rect, 0);
2625 rb_define_method(rb_cNumeric, "polar", numeric_polar, 0);
2626
2627 rb_define_method(rb_cFloat, "arg", float_arg, 0);
2628 rb_define_method(rb_cFloat, "angle", float_arg, 0);
2629 rb_define_method(rb_cFloat, "phase", float_arg, 0);
2630
2631 /*
2632 * Equivalent
2633 * to <tt>Complex(0, 1)</tt>:
2634 *
2635 * Complex::I # => (0+1i)
2636 *
2637 */
2639 f_complex_new_bang2(rb_cComplex, ZERO, ONE));
2640
2641#if !USE_FLONUM
2642 rb_gc_register_mark_object(RFLOAT_0 = DBL2NUM(0.0));
2643#endif
2644
2645 rb_provide("complex.so"); /* for backward compatibility */
2646}
static int rb_isdigit(int c)
Our own locale-insensitive version of isdigit(3).
Definition ctype.h:302
#define rb_define_method(klass, mid, func, arity)
Defines klass#mid.
#define rb_define_singleton_method(klass, mid, func, arity)
Defines klass.mid.
#define rb_define_private_method(klass, mid, func, arity)
Defines klass#mid and makes it private.
#define rb_define_global_function(mid, func, arity)
Defines rb_mKernel #mid.
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
Definition class.c:970
VALUE rb_define_class_under(VALUE outer, const char *name, VALUE super)
Defines a class under the namespace of outer.
Definition class.c:1002
void rb_undef_method(VALUE klass, const char *name)
Defines an undef of a method.
Definition class.c:2156
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
Retrieves argument from argc and argv to given VALUE references according to the format string.
Definition class.c:2622
#define T_COMPLEX
Old name of RUBY_T_COMPLEX.
Definition value_type.h:59
#define NEWOBJ_OF
Old name of RB_NEWOBJ_OF.
Definition newobj.h:61
#define RB_INTEGER_TYPE_P
Old name of rb_integer_type_p.
Definition value_type.h:87
#define RFLOAT_VALUE
Old name of rb_float_value.
Definition double.h:28
#define T_STRING
Old name of RUBY_T_STRING.
Definition value_type.h:78
#define Qundef
Old name of RUBY_Qundef.
#define INT2FIX
Old name of RB_INT2FIX.
Definition long.h:48
#define rb_str_cat2
Old name of rb_str_cat_cstr.
Definition string.h:1683
#define OBJ_FREEZE_RAW
Old name of RB_OBJ_FREEZE_RAW.
Definition fl_type.h:136
#define CLASS_OF
Old name of rb_class_of.
Definition globals.h:203
#define LONG2FIX
Old name of RB_INT2FIX.
Definition long.h:49
#define FIX2INT
Old name of RB_FIX2INT.
Definition int.h:41
#define T_RATIONAL
Old name of RUBY_T_RATIONAL.
Definition value_type.h:76
#define NUM2DBL
Old name of rb_num2dbl.
Definition double.h:27
VALUE rb_complex_polar(VALUE x, VALUE y)
Old name of rb_complex_new_polar.
Definition complex.c:1766
#define rb_usascii_str_new2
Old name of rb_usascii_str_new_cstr.
Definition string.h:1680
#define FLONUM_P
Old name of RB_FLONUM_P.
#define ST2FIX
Old name of RB_ST2FIX.
Definition st_data_t.h:33
#define Qnil
Old name of RUBY_Qnil.
#define Qfalse
Old name of RUBY_Qfalse.
#define FIX2LONG
Old name of RB_FIX2LONG.
Definition long.h:46
#define T_ARRAY
Old name of RUBY_T_ARRAY.
Definition value_type.h:56
#define NIL_P
Old name of RB_NIL_P.
#define ALLOCV_N
Old name of RB_ALLOCV_N.
Definition memory.h:399
#define FL_WB_PROTECTED
Old name of RUBY_FL_WB_PROTECTED.
Definition fl_type.h:59
#define DBL2NUM
Old name of rb_float_new.
Definition double.h:29
#define NUM2LONG
Old name of RB_NUM2LONG.
Definition long.h:51
#define FIXNUM_P
Old name of RB_FIXNUM_P.
#define ALLOCV_END
Old name of RB_ALLOCV_END.
Definition memory.h:400
VALUE rb_eRangeError
RangeError exception.
Definition error.c:1348
VALUE rb_eTypeError
TypeError exception.
Definition error.c:1344
void rb_warn(const char *fmt,...)
Identical to rb_warning(), except it reports unless $VERBOSE is nil.
Definition error.c:423
VALUE rb_cRational
Rational class.
Definition rational.c:47
VALUE rb_convert_type(VALUE val, int type, const char *name, const char *mid)
Converts an object into another type.
Definition object.c:3053
VALUE rb_cComplex
Complex class.
Definition complex.c:39
VALUE rb_mMath
Math module.
Definition math.c:29
VALUE rb_cInteger
Module class.
Definition numeric.c:198
VALUE rb_cNilClass
NilClass class.
Definition object.c:69
double rb_str_to_dbl(VALUE str, int mode)
Identical to rb_cstr_to_dbl(), except it accepts a Ruby's string instead of C's.
Definition object.c:3432
VALUE rb_cNumeric
Numeric class.
Definition numeric.c:196
VALUE rb_obj_class(VALUE obj)
Queries the class of an object.
Definition object.c:215
VALUE rb_inspect(VALUE obj)
Generates a human-readable textual representation of the given object.
Definition object.c:645
VALUE rb_equal(VALUE lhs, VALUE rhs)
This function is an optimised version of calling #==.
Definition object.c:147
VALUE rb_obj_is_kind_of(VALUE obj, VALUE klass)
Queries if the given object is an instance (of possibly descendants) of the given class.
Definition object.c:830
double rb_cstr_to_dbl(const char *str, int mode)
Converts a textual representation of a real number into a numeric, which is the nearest value that th...
Definition object.c:3390
VALUE rb_mComparable
Comparable module.
Definition compar.c:19
VALUE rb_cFloat
Float class.
Definition numeric.c:197
VALUE rb_String(VALUE val)
This is the logic behind Kernel#String.
Definition object.c:3671
VALUE rb_cString
String class.
Definition string.c:78
VALUE rb_funcall(VALUE recv, ID mid, int n,...)
Calls a method.
Definition vm_eval.c:1121
#define RGENGC_WB_PROTECTED_COMPLEX
This is a compile-time flag to enable/disable write barrier for struct RComplex.
Definition gc.h:561
#define rb_complex_new2(x, y)
Just another name of rb_complex_new.
Definition complex.h:77
#define rb_complex_new1(x)
Shorthand of x+0i.
Definition complex.h:74
static int rb_check_arity(int argc, int min, int max)
Ensures that the passed integer is in the passed range.
Definition error.h:280
void rb_provide(const char *feature)
Declares that the given feature is already provided by someone else.
Definition load.c:714
VALUE rb_num_coerce_cmp(VALUE lhs, VALUE rhs, ID op)
Identical to rb_num_coerce_bin(), except for return values.
Definition numeric.c:484
VALUE rb_num_coerce_bin(VALUE lhs, VALUE rhs, ID op)
Coerced binary operation.
Definition numeric.c:477
st_index_t rb_memhash(const void *ptr, long len)
This is a universal hash function.
Definition random.c:1747
void rb_must_asciicompat(VALUE obj)
Asserts that the given string's encoding is (Ruby's definition of) ASCII compatible.
Definition string.c:2530
VALUE rb_str_concat(VALUE dst, VALUE src)
Identical to rb_str_append(), except it also accepts an integer as a codepoint.
Definition string.c:3500
VALUE rb_const_get(VALUE space, ID name)
Identical to rb_const_defined(), except it returns the actual defined value.
Definition variable.c:3141
VALUE rb_ivar_set(VALUE obj, ID name, VALUE val)
Identical to rb_iv_set(), except it accepts the name as an ID instead of a C string.
Definition variable.c:1854
VALUE rb_ivar_get(VALUE obj, ID name)
Identical to rb_iv_get(), except it accepts the name as an ID instead of a C string.
Definition variable.c:1340
void rb_define_alloc_func(VALUE klass, rb_alloc_func_t func)
Sets the allocator function of a class.
static ID rb_intern_const(const char *str)
This is a "tiny optimisation" over rb_intern().
Definition symbol.h:276
void rb_define_const(VALUE klass, const char *name, VALUE val)
Defines a Ruby level constant under a namespace.
Definition variable.c:3690
void rb_marshal_define_compat(VALUE newclass, VALUE oldclass, VALUE(*dumper)(VALUE), VALUE(*loader)(VALUE, VALUE))
Marshal format compatibility layer.
Definition marshal.c:150
void rb_copy_generic_ivar(VALUE clone, VALUE obj)
Copies the list of instance variables.
Definition variable.c:2031
#define RARRAY_LEN
Just another name of rb_array_len.
Definition rarray.h:51
#define RARRAY_AREF(a, i)
Definition rarray.h:403
#define StringValueCStr(v)
Identical to StringValuePtr, except it additionally checks for the contents for viability as a C stri...
Definition rstring.h:89
#define RTEST
This is an old name of RB_TEST.
Internal header for Complex.
Definition complex.h:13
intptr_t SIGNED_VALUE
A signed integer type that has the same width with VALUE.
Definition value.h:63
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
Definition value.h:52
uintptr_t VALUE
Type that represents a Ruby object.
Definition value.h:40
static bool RB_FLOAT_TYPE_P(VALUE obj)
Queries if the object is an instance of rb_cFloat.
Definition value_type.h:263
static void Check_Type(VALUE v, enum ruby_value_type t)
Identical to RB_TYPE_P(), except it raises exceptions on predication failure.
Definition value_type.h:432
static bool rb_integer_type_p(VALUE obj)
Queries if the object is an instance of rb_cInteger.
Definition value_type.h:203