123456789_123456789_123456789_123456789_123456789_

Class: Complex

Relationships & Source Files
Namespace Children
Classes:
Super Chains via Extension / Inclusion / Inheritance
Class Chain:
self, ::Numeric
Instance Chain:
Inherits: Numeric
Defined in: complex.c

Overview

A complex number can be represented as a paired real number with imaginary unit; a+bi. Where a is real part, b is imaginary part and i is imaginary unit. Real a equals complex a+0i mathematically.

Complex object can be created as literal, and also by using Kernel.Complex, .rect, .polar or to_c method.

2+1i                 #=> (2+1i)
Complex(1)           #=> (1+0i)
Complex(2, 3)        #=> (2+3i)
Complex.polar(2, 3)  #=> (-1.9799849932008908+0.2822400161197344i)
3.to_c               #=> (3+0i)

You can also create complex object from floating-point numbers or strings.

Complex(0.3)         #=> (0.3+0i)
Complex('0.3-0.5i')  #=> (0.3-0.5i)
Complex('2/3+3/4i')  #=> ((2/3)+(3/4)*i)
Complex('1@2')       #=> (-0.4161468365471424+0.9092974268256817i)

0.3.to_c             #=> (0.3+0i)
'0.3-0.5i'.to_c      #=> (0.3-0.5i)
'2/3+3/4i'.to_c      #=> ((2/3)+(3/4)*i)
'1@2'.to_c           #=> (-0.4161468365471424+0.9092974268256817i)

A complex object is either an exact or an inexact number.

Complex(1, 1) / 2    #=> ((1/2)+(1/2)*i)
Complex(1, 1) / 2.0  #=> (0.5+0.5i)

Constant Summary

Class Method Summary

Instance Attribute Summary

::Numeric - Inherited

#finite?

Returns true if num is a finite number, otherwise returns false.

#infinite?

Returns nil, -1, or 1 depending on whether the value is finite, -Infinity, or +Infinity.

#integer?

Returns true if num is an ::Integer.

#negative?

Returns true if num is less than 0.

#nonzero?

Returns self if num is not zero, nil otherwise.

#positive?

Returns true if num is greater than 0.

#real

Returns self.

#real?

Returns true if num is a real number (i.e.

#zero?

Returns true if num has a zero value.

Instance Method Summary

::Numeric - Inherited

#%

x.modulo(y) means x-y*(x/y).floor.

#+@

Unary Plus—Returns the receiver.

#-@

Unary Minus—Returns the receiver, negated.

#<=>

Returns zero if number equals other, otherwise returns nil.

#abs

Returns the absolute value of num.

#abs2

Returns square of self.

#angle

Alias for Numeric#arg.

#arg

Returns 0 if the value is positive, pi otherwise.

#ceil

Returns the smallest number greater than or equal to num with a precision of ndigits decimal digits (default: 0).

#clone

Returns the receiver.

#coerce,
#conj

Returns self.

#conjugate

Alias for Numeric#conj.

#denominator

Returns the denominator (always positive).

#div

Uses #/ to perform division, then converts the result to an integer.

#divmod

Returns an array containing the quotient and modulus obtained by dividing num by numeric.

#dup

Returns the receiver.

#eql?

Returns true if num and numeric are the same type and have equal values.

#fdiv

Returns float division.

#floor

Returns the largest number less than or equal to num with a precision of ndigits decimal digits (default: 0).

#i

Returns the corresponding imaginary number.

#imag

Returns zero.

#imaginary

Alias for Numeric#imag.

#magnitude

Alias for Numeric#abs.

#modulo

Alias for Numeric#%.

#numerator

Returns the numerator.

#phase

Alias for Numeric#arg.

#polar

Returns an array; [num.abs, num.arg].

#quo

Returns the most exact division (rational for integers, float for floats).

#rect

Returns an array; [num, 0].

#rectangular

Alias for Numeric#rect.

#remainder

x.remainder(y) means x-y*(x/y).truncate.

#round

Returns num rounded to the nearest value with a precision of ndigits decimal digits (default: 0).

#step

Invokes the given block with the sequence of numbers starting at num, incremented by step (defaulted to 1) on each call.

#to_c

Returns the value as a complex.

#to_int

Invokes the child class's #to_i method to convert num to an integer.

#truncate

Returns num truncated (toward zero) to a precision of ndigits decimal digits (default: 0).

#singleton_method_added

Trap attempts to add methods to ::Numeric objects.

::Comparable - Included

#<

Compares two objects based on the receiver's <=> method, returning true if it returns -1.

#<=

Compares two objects based on the receiver's <=> method, returning true if it returns -1 or 0.

#==

Compares two objects based on the receiver's <=> method, returning true if it returns 0.

#>

Compares two objects based on the receiver's <=> method, returning true if it returns 1.

#>=

Compares two objects based on the receiver's <=> method, returning true if it returns 0 or 1.

#between?

Returns false if obj <=> min is less than zero or if anObject <=> max is greater than zero, true otherwise.

#clamp

Returns min if obj <=> min is less than zero, max if obj <=> max is greater than zero and obj otherwise.

Class Method Details

.polar(abs[, arg]) ⇒ Complex

Returns a complex object which denotes the given polar form.

Complex.polar(3, 0)            #=> (3.0+0.0i)
Complex.polar(3, Math::PI/2)   #=> (1.836909530733566e-16+3.0i)
Complex.polar(3, Math::PI)     #=> (-3.0+3.673819061467132e-16i)
Complex.polar(3, -Math::PI/2)  #=> (1.836909530733566e-16-3.0i)
[ GitHub ]

  
# File 'complex.c', line 626

static VALUE
nucomp_s_polar(int argc, VALUE *argv, VALUE klass)
{
    VALUE abs, arg;

    switch (rb_scan_args(argc, argv, "11", &abs, &arg)) {
      case 1:
	nucomp_real_check(abs);
	if (canonicalization) return abs;
	return nucomp_s_new_internal(klass, abs, ZERO);
      default:
	nucomp_real_check(abs);
	nucomp_real_check(arg);
	break;
    }
    return f_complex_polar(klass, abs, arg);
}

.rect(real[, imag]) ⇒ Complex .rectangular(real[, imag]) ⇒ Complex
Also known as: .rectangular

Returns a complex object which denotes the given rectangular form.

Complex.rectangular(1, 2)  #=> (1+2i)
[ GitHub ]

  
# File 'complex.c', line 425

static VALUE
nucomp_s_new(int argc, VALUE *argv, VALUE klass)
{
    VALUE real, imag;

    switch (rb_scan_args(argc, argv, "11", &real, &imag)) {
      case 1:
	nucomp_real_check(real);
	imag = ZERO;
	break;
      default:
	nucomp_real_check(real);
	nucomp_real_check(imag);
	break;
    }

    return nucomp_s_canonicalize_internal(klass, real, imag);
}

.rect(real[, imag]) ⇒ Complex .rectangular(real[, imag]) ⇒ Complex

Alias for .rect.

Instance Attribute Details

#complex?Boolean (readonly)

This method is for internal use only.
[ GitHub ]

  
# File 'complex.c', line 1156

static VALUE
nucomp_true(VALUE self)
{
    return Qtrue;
}

#exact?Boolean (readonly)

This method is for internal use only.
[ GitHub ]

  
# File 'complex.c', line 1177

static VALUE
nucomp_exact_p(VALUE self)
{
    get_dat1(self);
    return f_boolcast(k_exact_p(dat->real) && k_exact_p(dat->imag));
}

#finite?Boolean (readonly)

Returns true if cmp's magnitude is a finite number, otherwise returns false.

[ GitHub ]

  
# File 'complex.c', line 1359

static VALUE
rb_complex_finite_p(VALUE self)
{
    get_dat1(self);

    if (f_finite_p(dat->real) && f_finite_p(dat->imag)) {
	return Qtrue;
    }
    return Qfalse;
}

#inexact?Boolean (readonly)

This method is for internal use only.
[ GitHub ]

  
# File 'complex.c', line 1185

static VALUE
nucomp_inexact_p(VALUE self)
{
    return f_boolcast(!nucomp_exact_p(self));
}

#infinite?Boolean (readonly)

Returns values corresponding to the value of cmp's magnitude:

finite

nil

+Infinity

+1

For example:

   (1+1i).infinite?                   #=> nil
   (Float::INFINITY + 1i).infinite?   #=> 1
[ GitHub ]

  
# File 'complex.c', line 1384

static VALUE
rb_complex_infinite_p(VALUE self)
{
    get_dat1(self);

    if (NIL_P(f_infinite_p(dat->real)) && NIL_P(f_infinite_p(dat->imag))) {
	return Qnil;
    }
    return ONE;
}

#realNumeric (readonly)

Returns the real part.

Complex(7).real      #=> 7
Complex(9, -4).real  #=> 9
[ GitHub ]

  
# File 'complex.c', line 653

static VALUE
nucomp_real(VALUE self)
{
    get_dat1(self);
    return dat->real;
}

#real?Boolean (readonly)

Returns false.

[ GitHub ]

  
# File 'complex.c', line 1169

static VALUE
nucomp_false(VALUE self)
{
    return Qfalse;
}

Instance Method Details

#*

[ GitHub ]

#**(numeric) ⇒ Complex

Performs exponentiation.

Complex('i') ** 2              #=> (-1+0i)
Complex(-8) ** Rational(1, 3)  #=> (1.0000000000000002+1.7320508075688772i)
[ GitHub ]

  
# File 'complex.c', line 922

static VALUE
nucomp_expt(VALUE self, VALUE other)
{
    if (k_numeric_p(other) && k_exact_zero_p(other))
	return f_complex_new_bang1(CLASS_OF(self), ONE);

    if (RB_TYPE_P(other, T_RATIONAL) && RRATIONAL(other)->den == LONG2FIX(1))
	other = RRATIONAL(other)->num; /* c14n */

    if (RB_TYPE_P(other, T_COMPLEX)) {
	get_dat1(other);

	if (k_exact_zero_p(dat->imag))
	    other = dat->real; /* c14n */
    }

    if (RB_TYPE_P(other, T_COMPLEX)) {
	VALUE r, theta, nr, ntheta;

	get_dat1(other);

	r = f_abs(self);
	theta = f_arg(self);

	nr = m_exp_bang(f_sub(f_mul(dat->real, m_log_bang(r)),
			      f_mul(dat->imag, theta)));
	ntheta = f_add(f_mul(theta, dat->real),
		       f_mul(dat->imag, m_log_bang(r)));
	return f_complex_polar(CLASS_OF(self), nr, ntheta);
    }
    if (FIXNUM_P(other)) {
	if (f_gt_p(other, ZERO)) {
	    VALUE x, z;
	    long n;

	    x = self;
	    z = x;
	    n = FIX2LONG(other) - 1;

	    while (n) {
		long q, r;

		while (1) {
		    get_dat1(x);

		    q = n / 2;
		    r = n % 2;

		    if (r)
			break;

		    x = nucomp_s_new_internal(CLASS_OF(self),
				       f_sub(f_mul(dat->real, dat->real),
					     f_mul(dat->imag, dat->imag)),
				       f_mul(f_mul(TWO, dat->real), dat->imag));
		    n = q;
		}
		z = f_mul(z, x);
		n--;
	    }
	    return z;
	}
	return f_expt(f_reciprocal(self), rb_int_uminus(other));
    }
    if (k_numeric_p(other) && f_real_p(other)) {
	VALUE r, theta;

	if (RB_TYPE_P(other, T_BIGNUM))
	    rb_warn("in a**b, b may be too big");

	r = f_abs(self);
	theta = f_arg(self);

	return f_complex_polar(CLASS_OF(self), f_expt(r, other),
			       f_mul(theta, other));
    }
    return rb_num_coerce_bin(self, other, id_expt);
}

#+(numeric) ⇒ Complex

Performs addition.

Complex(2, 3)  + Complex(2, 3)   #=> (4+6i)
Complex(900)   + Complex(1)      #=> (901+0i)
Complex(-2, 9) + Complex(-9, 2)  #=> (-11+11i)
Complex(9, 8)  + 4               #=> (13+8i)
Complex(20, 9) + 9.8             #=> (29.8+9i)
[ GitHub ]

  
# File 'complex.c', line 705

VALUE
rb_complex_plus(VALUE self, VALUE other)
{
    if (RB_TYPE_P(other, T_COMPLEX)) {
	VALUE real, imag;

	get_dat2(self, other);

	real = f_add(adat->real, bdat->real);
	imag = f_add(adat->imag, bdat->imag);

	return f_complex_new2(CLASS_OF(self), real, imag);
    }
    if (k_numeric_p(other) && f_real_p(other)) {
	get_dat1(self);

	return f_complex_new2(CLASS_OF(self),
			      f_add(dat->real, other), dat->imag);
    }
    return rb_num_coerce_bin(self, other, '+');
}

#-(numeric) ⇒ Complex

Performs subtraction.

Complex(2, 3)  - Complex(2, 3)   #=> (0+0i)
Complex(900)   - Complex(1)      #=> (899+0i)
Complex(-2, 9) - Complex(-9, 2)  #=> (7+7i)
Complex(9, 8)  - 4               #=> (5+8i)
Complex(20, 9) - 9.8             #=> (10.2+9i)
[ GitHub ]

  
# File 'complex.c', line 739

static VALUE
nucomp_sub(VALUE self, VALUE other)
{
    if (RB_TYPE_P(other, T_COMPLEX)) {
	VALUE real, imag;

	get_dat2(self, other);

	real = f_sub(adat->real, bdat->real);
	imag = f_sub(adat->imag, bdat->imag);

	return f_complex_new2(CLASS_OF(self), real, imag);
    }
    if (k_numeric_p(other) && f_real_p(other)) {
	get_dat1(self);

	return f_complex_new2(CLASS_OF(self),
			      f_sub(dat->real, other), dat->imag);
    }
    return rb_num_coerce_bin(self, other, '-');
}

#-Complex

Returns negation of the value.

-Complex(1, 2)  #=> (-1-2i)
[ GitHub ]

  
# File 'complex.c', line 685

static VALUE
nucomp_negate(VALUE self)
{
  get_dat1(self);
  return f_complex_new2(CLASS_OF(self),
			f_negate(dat->real), f_negate(dat->imag));
}

#/(numeric) ⇒ Complex #quo(numeric) ⇒ Complex

Performs division.

Complex(2, 3)  / Complex(2, 3)   #=> ((1/1)+(0/1)*i)
Complex(900)   / Complex(1)      #=> ((900/1)+(0/1)*i)
Complex(-2, 9) / Complex(-9, 2)  #=> ((36/85)-(77/85)*i)
Complex(9, 8)  / 4               #=> ((9/4)+(2/1)*i)
Complex(20, 9) / 9.8             #=> (2.0408163265306123+0.9183673469387754i)
[ GitHub ]

  
# File 'complex.c', line 885

static VALUE
nucomp_div(VALUE self, VALUE other)
{
    return f_divide(self, other, f_quo, id_quo);
}

#==(object) ⇒ Boolean

Returns true if cmp equals object numerically.

Complex(2, 3)  == Complex(2, 3)   #=> true
Complex(5)     == 5               #=> true
Complex(0)     == 0.0             #=> true
Complex('1/3') == 0.33            #=> false
Complex('1/2') == '1/2'           #=> false
[ GitHub ]

  
# File 'complex.c', line 1013

static VALUE
nucomp_eqeq_p(VALUE self, VALUE other)
{
    if (RB_TYPE_P(other, T_COMPLEX)) {
	get_dat2(self, other);

	return f_boolcast(f_eqeq_p(adat->real, bdat->real) &&
			  f_eqeq_p(adat->imag, bdat->imag));
    }
    if (k_numeric_p(other) && f_real_p(other)) {
	get_dat1(self);

	return f_boolcast(f_eqeq_p(dat->real, other) && f_zero_p(dat->imag));
    }
    return f_boolcast(f_eqeq_p(other, self));
}

#absNumeric #magnitudeNumeric
Also known as: #magnitude

Returns the absolute part of its polar form.

Complex(-1).abs         #=> 1
Complex(3.0, -4.0).abs  #=> 5.0
[ GitHub ]

  
# File 'complex.c', line 1054

static VALUE
nucomp_abs(VALUE self)
{
    get_dat1(self);

    if (f_zero_p(dat->real)) {
	VALUE a = f_abs(dat->imag);
	if (RB_FLOAT_TYPE_P(dat->real) && !RB_FLOAT_TYPE_P(dat->imag))
	    a = f_to_f(a);
	return a;
    }
    if (f_zero_p(dat->imag)) {
	VALUE a = f_abs(dat->real);
	if (!RB_FLOAT_TYPE_P(dat->real) && RB_FLOAT_TYPE_P(dat->imag))
	    a = f_to_f(a);
	return a;
    }
    return rb_math_hypot(dat->real, dat->imag);
}

#abs2Numeric

Returns square of the absolute value.

Complex(-1).abs2         #=> 1
Complex(3.0, -4.0).abs2  #=> 25.0
[ GitHub ]

  
# File 'complex.c', line 1083

static VALUE
nucomp_abs2(VALUE self)
{
    get_dat1(self);
    return f_add(f_mul(dat->real, dat->real),
		 f_mul(dat->imag, dat->imag));
}

#argFloat #angleFloat #phaseFloat

Alias for #arg.

#argFloat #angleFloat #phaseFloat
Also known as: #angle, #phase

Returns the angle part of its polar form.

Complex.polar(3, Math::PI/2).arg  #=> 1.5707963267948966
[ GitHub ]

  
# File 'complex.c', line 1101

static VALUE
nucomp_arg(VALUE self)
{
    get_dat1(self);
    return rb_math_atan2(dat->imag, dat->real);
}

#coerce(other)

This method is for internal use only.
[ GitHub ]

  
# File 'complex.c', line 1031

static VALUE
nucomp_coerce(VALUE self, VALUE other)
{
    if (k_numeric_p(other) && f_real_p(other))
	return rb_assoc_new(f_complex_new_bang1(CLASS_OF(self), other), self);
    if (RB_TYPE_P(other, T_COMPLEX))
	return rb_assoc_new(other, self);

    rb_raise(rb_eTypeError, "%"PRIsVALUE" can't be coerced into %"PRIsVALUE,
	     rb_obj_class(other), rb_obj_class(self));
    return Qnil;
}

#conjComplex #conjugateComplex

Alias for #~.

#conjComplex #conjugateComplex

Alias for #~.

#denominatorInteger

Returns the denominator (lcm of both denominator - real and imag).

See numerator.

[ GitHub ]

  
# File 'complex.c', line 1200

static VALUE
nucomp_denominator(VALUE self)
{
    get_dat1(self);
    return rb_lcm(f_denominator(dat->real), f_denominator(dat->imag));
}

#eql?(other) ⇒ Boolean

This method is for internal use only.
[ GitHub ]

  
# File 'complex.c', line 1257

static VALUE
nucomp_eql_p(VALUE self, VALUE other)
{
    if (RB_TYPE_P(other, T_COMPLEX)) {
	get_dat2(self, other);

	return f_boolcast((CLASS_OF(adat->real) == CLASS_OF(bdat->real)) &&
			  (CLASS_OF(adat->imag) == CLASS_OF(bdat->imag)) &&
			  f_eqeq_p(self, other));

    }
    return Qfalse;
}

#fdiv(numeric) ⇒ Complex

Performs division as each part is a float, never returns a float.

Complex(11, 22).fdiv(3)  #=> (3.6666666666666665+7.333333333333333i)
[ GitHub ]

  
# File 'complex.c', line 901

static VALUE
nucomp_fdiv(VALUE self, VALUE other)
{
    return f_divide(self, other, f_fdiv, id_fdiv);
}

#hash

This method is for internal use only.
[ GitHub ]

  
# File 'complex.c', line 1241

static VALUE
nucomp_hash(VALUE self)
{
    st_index_t v, h[2];
    VALUE n;

    get_dat1(self);
    n = rb_hash(dat->real);
    h[0] = NUM2LONG(n);
    n = rb_hash(dat->imag);
    h[1] = NUM2LONG(n);
    v = rb_memhash(h, sizeof(h));
    return ST2FIX(v);
}

#imagNumeric #imaginaryNumeric
Also known as: #imaginary

Returns the imaginary part.

Complex(7).imaginary      #=> 0
Complex(9, -4).imaginary  #=> -4
[ GitHub ]

  
# File 'complex.c', line 670

static VALUE
nucomp_imag(VALUE self)
{
    get_dat1(self);
    return dat->imag;
}

#imagNumeric #imaginaryNumeric

Alias for #imag.

#inspectString

Returns the value as a string for inspection.

Complex(2).inspect                       #=> "(2+0i)"
Complex('-8/6').inspect                  #=> "((-4/3)+0i)"
Complex('1/2i').inspect                  #=> "(0+(1/2)*i)"
Complex(0, Float::INFINITY).inspect      #=> "(0+Infinity*i)"
Complex(Float::NAN, Float::NAN).inspect  #=> "(NaN+NaN*i)"
[ GitHub ]

  
# File 'complex.c', line 1338

static VALUE
nucomp_inspect(VALUE self)
{
    VALUE s;

    s = rb_usascii_str_new2("(");
    rb_str_concat(s, f_format(self, rb_inspect));
    rb_str_cat2(s, ")");

    return s;
}

#absNumeric #magnitudeNumeric

Alias for #abs.

#marshal_dump (private)

This method is for internal use only.
[ GitHub ]

  
# File 'complex.c', line 1416

static VALUE
nucomp_marshal_dump(VALUE self)
{
    VALUE a;
    get_dat1(self);

    a = rb_assoc_new(dat->real, dat->imag);
    rb_copy_generic_ivar(a, self);
    return a;
}

#numeratorNumeric

Returns the numerator.

    1   2       3+4i  <-  numerator
    - + -i  ->  ----
    2   3        6    <-  denominator

c = Complex('1/2+2/3i')  #=> ((1/2)+(2/3)*i)
n = c.numerator          #=> (3+4i)
d = c.denominator        #=> 6
n / d                    #=> ((1/2)+(2/3)*i)
Complex(Rational(n.real, d), Rational(n.imag, d))
                         #=> ((1/2)+(2/3)*i)

See denominator.

[ GitHub ]

  
# File 'complex.c', line 1225

static VALUE
nucomp_numerator(VALUE self)
{
    VALUE cd;

    get_dat1(self);

    cd = f_denominator(self);
    return f_complex_new2(CLASS_OF(self),
			  f_mul(f_numerator(dat->real),
				f_div(cd, f_denominator(dat->real))),
			  f_mul(f_numerator(dat->imag),
				f_div(cd, f_denominator(dat->imag))));
}

#argFloat #angleFloat #phaseFloat

Alias for #arg.

#polarArray

Returns an array; [cmp.abs, cmp.arg].

Complex(1, 2).polar  #=> [2.23606797749979, 1.1071487177940904]
[ GitHub ]

  
# File 'complex.c', line 1132

static VALUE
nucomp_polar(VALUE self)
{
    return rb_assoc_new(f_abs(self), f_arg(self));
}

#quo

[ GitHub ]

#rationalize([eps]) ⇒ Rational

Returns the value as a rational if possible (the imaginary part should be exactly zero).

Complex(1.0/3, 0).rationalize  #=> (1/3)
Complex(1, 0.0).rationalize    # RangeError
Complex(1, 2).rationalize      # RangeError

See to_r.

[ GitHub ]

  
# File 'complex.c', line 1558

static VALUE
nucomp_rationalize(int argc, VALUE *argv, VALUE self)
{
    get_dat1(self);

    rb_scan_args(argc, argv, "01", NULL);

    if (!k_exact_zero_p(dat->imag)) {
       rb_raise(rb_eRangeError, "can't convert %"PRIsVALUE" into Rational",
                self);
    }
    return rb_funcallv(dat->real, id_rationalize, argc, argv);
}

#rectArray #rectangularArray
Also known as: #rectangular

Returns an array; [cmp.real, cmp.imag].

Complex(1, 2).rectangular  #=> [1, 2]
[ GitHub ]

  
# File 'complex.c', line 1117

static VALUE
nucomp_rect(VALUE self)
{
    get_dat1(self);
    return rb_assoc_new(dat->real, dat->imag);
}

#rectArray #rectangularArray

Alias for #rect.

#to_cself

Returns self.

Complex(2).to_c      #=> (2+0i)
Complex(-8, 6).to_c  #=> (-8+6i)
[ GitHub ]

  
# File 'complex.c', line 1581

static VALUE
nucomp_to_c(VALUE self)
{
    return self;
}

#to_fFloat

Returns the value as a float if possible (the imaginary part should be exactly zero).

Complex(1, 0).to_f    #=> 1.0
Complex(1, 0.0).to_f  # RangeError
Complex(1, 2).to_f    # RangeError
[ GitHub ]

  
# File 'complex.c', line 1508

static VALUE
nucomp_to_f(VALUE self)
{
    get_dat1(self);

    if (!k_exact_zero_p(dat->imag)) {
	rb_raise(rb_eRangeError, "can't convert %"PRIsVALUE" into Float",
		 self);
    }
    return f_to_f(dat->real);
}

#to_iInteger

Returns the value as an integer if possible (the imaginary part should be exactly zero).

Complex(1, 0).to_i    #=> 1
Complex(1, 0.0).to_i  # RangeError
Complex(1, 2).to_i    # RangeError
[ GitHub ]

  
# File 'complex.c', line 1485

static VALUE
nucomp_to_i(VALUE self)
{
    get_dat1(self);

    if (!k_exact_zero_p(dat->imag)) {
	rb_raise(rb_eRangeError, "can't convert %"PRIsVALUE" into Integer",
		 self);
    }
    return f_to_i(dat->real);
}

#to_rRational

Returns the value as a rational if possible (the imaginary part should be exactly zero).

Complex(1, 0).to_r    #=> (1/1)
Complex(1, 0.0).to_r  # RangeError
Complex(1, 2).to_r    # RangeError

See rationalize.

[ GitHub ]

  
# File 'complex.c', line 1533

static VALUE
nucomp_to_r(VALUE self)
{
    get_dat1(self);

    if (!k_exact_zero_p(dat->imag)) {
	rb_raise(rb_eRangeError, "can't convert %"PRIsVALUE" into Rational",
		 self);
    }
    return f_to_r(dat->real);
}

#to_sString

Returns the value as a string.

Complex(2).to_s                       #=> "2+0i"
Complex('-8/6').to_s                  #=> "-4/3+0i"
Complex('1/2i').to_s                  #=> "0+1/2i"
Complex(0, Float::INFINITY).to_s      #=> "0+Infinity*i"
Complex(Float::NAN, Float::NAN).to_s  #=> "NaN+NaN*i"
[ GitHub ]

  
# File 'complex.c', line 1320

static VALUE
nucomp_to_s(VALUE self)
{
    return f_format(self, rb_String);
}

#conjComplex #conjugateComplex
Also known as: #conjugate, #conj

Returns the complex conjugate.

Complex(1, 2).conjugate  #=> (1-2i)
[ GitHub ]

  
# File 'complex.c', line 1147

static VALUE
nucomp_conj(VALUE self)
{
    get_dat1(self);
    return f_complex_new2(CLASS_OF(self), dat->real, f_negate(dat->imag));
}