класс Complex

Родитель:: Numeric

Объект Complex хранит пару значений, заданных при создании объекта как прямоугольные координаты или полярные координаты.

Прямоугольные координаты

Прямоугольные координаты комплексного числа называются действительной и мнимой частями; см. Определение комплексного числа.

Вы можете создать объект Complex из прямоугольных координат с помощью:

Комплекерной литерал.
Метода Complex.rect.
Метода Kernel#Complex, либо с числовыми аргументами, либо с определёнными строковыми аргументами.
Метода String#to_c, для определённых строк.

Обратите внимание, что каждая из хранимых частей может быть экземпляром одного из классов Complex, Float, Integer или Rational; их можно получить:

По отдельности, с помощью методов Complex#real и Complex#imaginary.
Вместе, с помощью метода Complex#rect.

Соответствующие (вычисленные) полярные значения можно получить:

По отдельности, с помощью методов Complex#abs и Complex#arg.
Вместе, с помощью метода Complex#polar.

Полярные координаты

Полярные координаты комплексного числа называются абсолютной и аргументной частями; см. Полярная форма комплексного числа.

В данном классе аргументная часть выражается в радианах (а не в градусах).

Вы можете создать объект Complex из полярных координат с помощью:

Метода Complex.polar.
Метода Kernel#Complex, с определёнными строковыми аргументами.
Метода String#to_c, для определённых строк.

По отдельности, с помощью методов Complex#abs и Complex#arg.
Вместе, с помощью метода Complex#polar.

Соответствующие (вычисленные) прямоугольные значения можно получить:

По отдельности, с помощью методов Complex#real и Complex#imag.
Вместе, с помощью метода Complex#rect.

Что здесь

Сначала, что в другом месте:

Класс Complex наследует (прямо или косвенно) от классов Numeric и Object.
Включает (косвенно) модуль Comparable.

Здесь класс Complex имеет методы для:

Создание объектов Complex

::polar: Возвращает новый объект Complex на основе заданных полярных координат.
::rect (и его псевдоним ::rectangular): Возвращает новый объект Complex на основе заданных прямоугольных координат.

Запрос

abs (и его псевдоним magnitude): Возвращает абсолютное значение для self.
arg (и его псевдонимы angle и phase): Возвращает аргумент (угол) для self в радианах.
denominator: Возвращает знаменатель для self.
finite?: Возвращает true, если оба self.real и self.image являются конечными.
hash: Возвращает целочисленное значение хэша для self.
imag (и его псевдоним imaginary): Возвращает мнимое значение для self.
infinite?: Возвращает true, если self.real или self.image бесконечны.
numerator: Возвращает числитель для self.
polar: Возвращает массив [self.abs, self.arg].
inspect: Возвращает строковое представление для self.
real: Возвращает действительное значение для self.
real?: Возвращает false; для совместимости с Numeric#real?.
rect (и его псевдоним rectangular): Возвращает массив [self.real, self.imag].

Сравнение

<=>: Возвращает результат сравнения self.
==: Возвращает true, если self равно заданному аргументу.

Преобразование

rationalize: Возвращает объект Rational, значение которого точно или приблизительно равно значению self.real.
to_c: Возвращает self.
to_d: Возвращает значение как объект BigDecimal.
to_f: Возвращает значение self.real как Float, если возможно.
to_i: Возвращает значение self.real как Integer, если возможно.
to_r: Возвращает значение self.real как Rational, если возможно.
to_s: Возвращает строковое представление для self.

Выполнение арифметических операций с комплексными числами

*: Возвращает произведение self и заданного числа.
**: Возвращает self в степени заданного числа.
+: Возвращает сумму self и заданного числа.
-: Возвращает разность self и заданного числа.
-@: Возвращает отрицание self.
/: Возвращает частное self и заданного числа.
abs2: Возвращает квадрат абсолютного значения (модуля) для self.
conj (и его псевдоним conjugate): Возвращает сопряжённое значение self.
fdiv: Возвращает Complex.rect(self.real/numeric, self.imag/numeric).

Работа с `JSON`

::json_create: Возвращает новый объект Complex, десериализованный из заданной сериализованной структуры.
as_json: Возвращает сериализованную структуру, построенную из self.
to_json: Возвращает JSON строку, представляющую self.

Эти методы предоставляются драгоценностью JSON. Чтобы использовать эти методы:

require 'json/add/complex'

Константы

I

Эквивалентно Complex.rect(0, 1):

Complex::I # => (0+1i)

Методы открытого класса

json_create (object)

Исходный код

# File ext/json/lib/json/add/complex.rb, line 9
def self.json_create(object)
  Complex(object['r'], object['i'])
end

См. as_json.

polar(abs, arg = 0) → complex

Исходный код

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

    argc = rb_scan_args(argc, argv, "11", &abs, &arg);
    abs = nucomp_real_check(abs);
    if (argc == 2) {
        arg = nucomp_real_check(arg);
    }
    else {
        arg = ZERO;
    }
    return f_complex_polar_real(klass, abs, arg);
}

Возвращает новый объект Complex, образованный из аргументов, каждый из которых должен быть экземпляром Numeric, или экземпляром одного из его подклассов: Complex, Float, Integer, Rational. Аргумент arg задается в радианах; см. Полярные координаты:

Complex.polar(3)        # => (3+0i)
Complex.polar(3, 2.0)   # => (-1.2484405096414273+2.727892280477045i)
Complex.polar(-3, -2.0) # => (1.2484405096414273+2.727892280477045i)

rect(real, imag = 0) → complex

Исходный код

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:
        real = nucomp_real_check(real);
        imag = ZERO;
        break;
      default:
        real = nucomp_real_check(real);
        imag = nucomp_real_check(imag);
        break;
    }

    return nucomp_s_new_internal(klass, real, imag);
}

Возвращает новый объект Complex, образованный из аргументов, каждый из которых должен быть экземпляром Numeric, или экземпляром одного из его подклассов: Complex, Float, Integer, Rational; см. Прямоугольные координаты:

Complex.rect(3)             # => (3+0i)
Complex.rect(3, Math::PI)   # => (3+3.141592653589793i)
Complex.rect(-3, -Math::PI) # => (-3-3.141592653589793i)

Complex.rectangular — псевдоним для Complex.rect.

rect(real, imag = 0) → complex

Исходный код

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:
        real = nucomp_real_check(real);
        imag = ZERO;
        break;
      default:
        real = nucomp_real_check(real);
        imag = nucomp_real_check(imag);
        break;
    }

    return nucomp_s_new_internal(klass, real, imag);
}

Возвращает новый объект Complex, образованный из аргументов, каждый из которых должен быть экземпляром Numeric, или экземпляром одного из его подклассов: Complex, Float, Integer, Rational; см. Прямоугольные координаты:

Complex.rect(3)             # => (3+0i)
Complex.rect(3, Math::PI)   # => (3+3.141592653589793i)
Complex.rect(-3, -Math::PI) # => (-3-3.141592653589793i)

Complex.rectangular — псевдоним для Complex.rect.

Методы экземпляров Public

complex * numeric → new_complex

Исходный код

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

        comp_mul(adat->real, adat->imag, bdat->real, bdat->imag, &real, &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_mul(dat->real, other),
                              f_mul(dat->imag, other));
    }
    return rb_num_coerce_bin(self, other, '*');
}

Возвращает произведение self и numeric:

Complex.rect(2, 3)  * Complex.rect(2, 3)  # => (-5+12i)
Complex.rect(900)   * Complex.rect(1)     # => (900+0i)
Complex.rect(-2, 9) * Complex.rect(-9, 2) # => (0-85i)
Complex.rect(9, 8)  * 4                   # => (36+32i)
Complex.rect(20, 9) * 9.8                 # => (196.0+88.2i)

complex ** numeric → new_complex

Исходный код

VALUE
rb_complex_pow(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 (other == ONE) {
        get_dat1(self);
        return nucomp_s_new_internal(CLASS_OF(self), dat->real, dat->imag);
    }

    VALUE result = complex_pow_for_special_angle(self, other);
    if (!UNDEF_P(result)) return result;

    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)) {
        long n = FIX2LONG(other);
        if (n == 0) {
            return nucomp_s_new_internal(CLASS_OF(self), ONE, ZERO);
        }
        if (n < 0) {
            self = f_reciprocal(self);
            other = rb_int_uminus(other);
            n = -n;
        }
        {
            get_dat1(self);
            VALUE xr = dat->real, xi = dat->imag, zr = xr, zi = xi;

            if (f_zero_p(xi)) {
                zr = rb_num_pow(zr, other);
            }
            else if (f_zero_p(xr)) {
                zi = rb_num_pow(zi, other);
                if (n & 2) zi = f_negate(zi);
                if (!(n & 1)) {
                    VALUE tmp = zr;
                    zr = zi;
                    zi = tmp;
                }
            }
            else {
                while (--n) {
                    long q, r;

                    for (; q = n / 2, r = n % 2, r == 0; n = q) {
                        VALUE tmp = f_sub(f_mul(xr, xr), f_mul(xi, xi));
                        xi = f_mul(f_mul(TWO, xr), xi);
                        xr = tmp;
                    }
                    comp_mul(zr, zi, xr, xi, &zr, &zi);
                }
            }
            return nucomp_s_new_internal(CLASS_OF(self), zr, zi);
        }
    }
    if (k_numeric_p(other) && f_real_p(other)) {
        VALUE r, theta;

        if (RB_BIGNUM_TYPE_P(other))
            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);
}

Возвращает self в степени numeric:

Complex.rect(0, 1) ** 2            # => (-1+0i)
Complex.rect(-8) ** Rational(1, 3) # => (1.0000000000000002+1.7320508075688772i)

complex + numeric → new_complex

Исходный код

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, '+');
}

Возвращает сумму self и numeric:

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

complex - numeric → new_complex

Исходный код

VALUE
rb_complex_minus(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, '-');
}

Возвращает разность self и numeric:

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

-complex → new_complex

Исходный код

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

Возвращает отрицание self, являющееся отрицанием каждой из его составляющих:

-Complex.rect(1, 2)   # => (-1-2i)
-Complex.rect(-1, -2) # => (1+2i)

complex / numeric → new_complex

Исходный код

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

Возвращает частное self и numeric:

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

complex <=> object → -1, 0, 1, или nil

Исходный код

static VALUE
nucomp_cmp(VALUE self, VALUE other)
{
    if (!k_numeric_p(other)) {
        return rb_num_coerce_cmp(self, other, idCmp);
    }
    if (!nucomp_real_p(self)) {
        return Qnil;
    }
    if (RB_TYPE_P(other, T_COMPLEX)) {
        if (nucomp_real_p(other)) {
            get_dat2(self, other);
            return rb_funcall(adat->real, idCmp, 1, bdat->real);
        }
    }
    else {
        get_dat1(self);
        if (f_real_p(other)) {
            return rb_funcall(dat->real, idCmp, 1, other);
        }
        else {
            return rb_num_coerce_cmp(dat->real, other, idCmp);
        }
    }
    return Qnil;
}

Возвращает:

self.real <=> object.real если оба следующих утверждения истинны:
- self.imag == 0.
- object.imag == 0. # Всегда истинно, если объект является числовым, но не комплексным.
nil в противном случае.

Примеры:

Complex.rect(2) <=> 3                  # => -1
Complex.rect(2) <=> 2                  # => 0
Complex.rect(2) <=> 1                  # => 1
Complex.rect(2, 1) <=> 1               # => nil # self.imag not zero.
Complex.rect(1) <=> Complex.rect(1, 1) # => nil # object.imag not zero.
Complex.rect(1) <=> 'Foo'              # => nil # object.imag not defined.

complex == object → true или false

Исходный код

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

        return RBOOL(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 RBOOL(f_eqeq_p(dat->real, other) && f_zero_p(dat->imag));
    }
    return RBOOL(f_eqeq_p(other, self));
}

Возвращает true если self.real == object.real и self.imag == object.imag:

Complex.rect(2, 3)  == Complex.rect(2.0, 3.0) # => true

abs → float

Исходный код

VALUE
rb_complex_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);
}

Возвращает абсолютное значение (модуль) для self; см. полярные координаты:

Complex.polar(-1, 0).abs # => 1.0

Если self был создан с помощью прямоугольных координат, возвращаемое значение вычисляется и может быть неточным:

Complex.rectangular(1, 1).abs # => 1.4142135623730951 # The square root of 2.

Также алиас: magnitude

abs2 → float

Исходный код

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

Возвращает квадрат абсолютного значения (модуля) для self; см. полярные координаты:

Complex.polar(2, 2).abs2 # => 4.0

Complex.rectangular(1.0/3, 1.0/3).abs2 # => 0.2222222222222222

угол

Псевдоним для: arg

arg → float

Исходный код

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

Возвращает аргумент (угол) для self в радианах; см. полярные координаты:

Complex.polar(3, Math::PI/2).arg  # => 1.57079632679489660

Complex.polar(1, 1.0/3).arg # => 0.33333333333333326

Также алиас: угол, фаза

as_json (*)

Исходный код

# File ext/json/lib/json/add/complex.rb, line 29
def as_json(*)
  {
    JSON.create_id => self.class.name,
    'r'            => real,
    'i'            => imag,
  }
end

Методы Complex#as_json и Complex.json_create могут использоваться для сериализации и десериализации объекта Complex; см. Marshal.

Метод Complex#as_json сериализует self, возвращая хеш из 2 элементов, представляющий self:

require 'json/add/complex'
x = Complex(2).as_json      # => {"json_class"=>"Complex", "r"=>2, "i"=>0}
y = Complex(2.0, 4).as_json # => {"json_class"=>"Complex", "r"=>2.0, "i"=>4}

Метод JSON.create десериализует такой хеш, возвращая объект Complex:

Complex.json_create(x) # => (2+0i)
Complex.json_create(y) # => (2.0+4i)

conj → complex

Возвращает сопряжённое значение self, Complex.rect(self.imag, self.real):

Complex.rect(1, 2).conj # => (1-2i)

Псевдоним для: conjugate

сопряжённое

Исходный код

Также алиас: conj

знаменатель → целое

Исходный код

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

Возвращает знаменатель self, который представляет собой наименьшее общее кратное self.real.denominator и self.imag.denominator:

Complex.rect(Rational(1, 2), Rational(2, 3)).denominator # => 6

Обратите внимание, что знаменатель нерационального числа n.denominator 1.

Связанно с: Complex#numerator.

END_OF_DOCUMENT_MARKER

fdiv(numeric) → new_complex

Исходный код

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

Возвращает Complex.rect(self.real/numeric, self.imag/numeric):

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

finite? → true или false

Исходный код

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

    return RBOOL(f_finite_p(dat->real) && f_finite_p(dat->imag));
}

Возвращает true, если оба self.real.finite? и self.imag.finite? истинны, false в противном случае:

Complex.rect(1, 1).finite?               # => true
Complex.rect(Float::INFINITY, 0).finite? # => false

Связанные: Numeric#finite?, Float#finite?.

hash → целое число

Исходный код

static VALUE
nucomp_hash(VALUE self)
{
    return ST2FIX(rb_complex_hash(self));
}

Возвращает целочисленное значение хэша для self.

Два объекта Complex, созданные из одних и тех же значений, будут иметь одинаковое значение хэша (и будут сравниваться с помощью eql?):

Complex.rect(1, 2).hash == Complex.rect(1, 2).hash # => true

imag → числовой тип

Возвращает мнимое значение для self:

Complex.rect(7).imag     # => 0
Complex.rect(9, -4).imag # => -4

Если self был создан с использованием полярных координат, возвращаемое значение вычисляется и может быть приближенным:

Complex.polar(1, Math::PI/4).imag # => 0.7071067811865476 # Square root of 2.

Псевдоним для: imaginary

imaginary

Исходный код

Также псевдоним для: imag

infinite? → 1 или nil

Исходный код

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

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

Возвращает 1, если либо self.real.infinite? , либо self.imag.infinite? истинно, nil в противном случае:

Complex.rect(Float::INFINITY, 0).infinite? # => 1
Complex.rect(1, 1).infinite?               # => nil

Связанные: Numeric#infinite?, Float#infinite?.

inspect → строка

Исходный код

static VALUE
nucomp_inspect(VALUE self)
{
    VALUE s;

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

    return s;
}

Возвращает строковое представление self:

Complex.rect(2).inspect                      # => "(2+0i)"
Complex.rect(-8, 6).inspect                  # => "(-8+6i)"
Complex.rect(0, Rational(1, 2)).inspect      # => "(0+(1/2)*i)"
Complex.rect(0, Float::INFINITY).inspect     # => "(0+Infinity*i)"
Complex.rect(Float::NAN, Float::NAN).inspect # => "(NaN+NaN*i)"

magnitude

Псевдоним для: abs

numerator → new_complex

Исходный код

static VALUE
nucomp_numerator(VALUE self)
{
    VALUE cd;

    get_dat1(self);

    cd = nucomp_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))));
}

Возвращает объект Complex, созданный из числителей вещественной и мнимой частей self, после преобразования каждой части к наименьшему общему знаменателю двух частей:

c = Complex.rect(Rational(2, 3), Rational(3, 4)) # => ((2/3)+(3/4)*i)
c.numerator                                      # => (8+9i)

В данном примере наименьший общий знаменатель двух частей равен 12; две преобразованные части можно представить как Rational(8, 12) и Rational(9, 12), числители которых соответственно равны 8 и 9; таким образом, возвращаемое значение c.numerator равно Complex.rect(8, 9).

Связанные: Complex#denominator.

phase

Псевдоним для: arg

polar → массив

Исходный код

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

Возвращает массив [self.abs, self.arg]:

Complex.polar(1, 2).polar # => [1.0, 2.0]

См. Полярные координаты.

Если self был создан с использованием прямоугольных координат, возвращаемое значение вычисляется и может быть приближенным:

Complex.rect(1, 1).polar # => [1.4142135623730951, 0.7853981633974483]

complex / numeric → new_complex

Исходный код

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

Возвращает частное от self и numeric:

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

rationalize(epsilon = nil) → рациональное

Исходный код

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

    rb_check_arity(argc, 0, 1);

    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);
}

Возвращает объект Rational, значение которого точно или приблизительно эквивалентно значению self.real.

Без аргумента epsilon возвращает объект Rational, значение которого точно равно значению self.real.rationalize:

Complex.rect(1, 0).rationalize              # => (1/1)
Complex.rect(1, Rational(0, 1)).rationalize # => (1/1)
Complex.rect(3.14159, 0).rationalize        # => (314159/100000)

С аргументом epsilon возвращает объект Rational, значение которого точно или приблизительно равно значению self.real с заданной точностью:

Complex.rect(3.14159, 0).rationalize(0.1)          # => (16/5)
Complex.rect(3.14159, 0).rationalize(0.01)         # => (22/7)
Complex.rect(3.14159, 0).rationalize(0.001)        # => (201/64)
Complex.rect(3.14159, 0).rationalize(0.0001)       # => (333/106)
Complex.rect(3.14159, 0).rationalize(0.00001)      # => (355/113)
Complex.rect(3.14159, 0).rationalize(0.000001)     # => (7433/2366)
Complex.rect(3.14159, 0).rationalize(0.0000001)    # => (9208/2931)
Complex.rect(3.14159, 0).rationalize(0.00000001)   # => (47460/15107)
Complex.rect(3.14159, 0).rationalize(0.000000001)  # => (76149/24239)
Complex.rect(3.14159, 0).rationalize(0.0000000001) # => (314159/100000)
Complex.rect(3.14159, 0).rationalize(0.0)          # => (3537115888337719/1125899906842624)

Связанные: Complex#to_r.

real → числовой тип

Исходный код

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

Возвращает вещественное значение для self:

Complex.rect(7).real     # => 7
Complex.rect(9, -4).real # => 9

Complex.polar(1, Math::PI/4).real # => 0.7071067811865476 # Square root of 2.

real? → false

Исходный код

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

Возвращает false; для совместимости с Numeric#real?.

rect → массив

Возвращает новый объект Complex, сформированный из аргументов, каждый из которых должен быть экземпляром Numeric, или экземпляром одного из его подклассов: Complex, Float, Integer, Rational; см. Прямоугольные координаты:

Complex.rect(3)             # => (3+0i)
Complex.rect(3, Math::PI)   # => (3+3.141592653589793i)
Complex.rect(-3, -Math::PI) # => (-3-3.141592653589793i)

Complex.rectangular — псевдоним для Complex.rect.

Псевдоним для: rectangular

rectangular

Исходный код

Также алиасирован как: rect, rect

to_c → self

Исходный код

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

Возвращает self.

to_f → float

Исходный код

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);
}

Возвращает значение self.real в виде Float, если это возможно:

Complex.rect(1, 0).to_f              # => 1.0
Complex.rect(1, Rational(0, 1)).to_f # => 1.0

Вызывает RangeError, если self.imag не равно нулю (ни Integer(0), ни Rational(0, n)).

to_i → integer

Исходный код

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);
}

Возвращает значение self.real в виде Integer, если это возможно:

Complex.rect(1, 0).to_i              # => 1
Complex.rect(1, Rational(0, 1)).to_i # => 1

Вызывает RangeError, если self.imag не равно нулю (ни Integer(0), ни Rational(0, n)).

to_json (*args)

Исходный код

# File ext/json/lib/json/add/complex.rb, line 48
def to_json(*args)
  as_json.to_json(*args)
end

Возвращает строку JSON, представляющую self:

require 'json/add/complex'
puts Complex(2).to_json
puts Complex(2.0, 4).to_json

Вывод:

{"json_class":"Complex","r":2,"i":0}
{"json_class":"Complex","r":2.0,"i":4}

to_r → rational

Исходный код

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

    if (RB_FLOAT_TYPE_P(dat->imag) && FLOAT_ZERO_P(dat->imag)) {
        /* Do nothing here */
    }
    else if (!k_exact_zero_p(dat->imag)) {
        VALUE imag = rb_check_convert_type_with_id(dat->imag, T_RATIONAL, "Rational", idTo_r);
        if (NIL_P(imag) || !k_exact_zero_p(imag)) {
            rb_raise(rb_eRangeError, "can't convert %"PRIsVALUE" into Rational",
                     self);
        }
    }
    return f_to_r(dat->real);
}

Возвращает значение self.real в виде Rational, если это возможно:

Complex.rect(1, 0).to_r              # => (1/1)
Complex.rect(1, Rational(0, 1)).to_r # => (1/1)
Complex.rect(1, 0.0).to_r            # => (1/1)

Вызывает RangeError, если self.imag не равно нулю (ни Integer(0), ни Rational(0, n)) и self.imag.to_r не равно нулю.

Связанно с: Complex#rationalize.

to_s → string

Исходный код

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

Возвращает строковое представление self:

Complex.rect(2).to_s                      # => "2+0i"
Complex.rect(-8, 6).to_s                  # => "-8+6i"
Complex.rect(0, Rational(1, 2)).to_s      # => "0+1/2i"
Complex.rect(0, Float::INFINITY).to_s     # => "0+Infinity*i"
Complex.rect(Float::NAN, Float::NAN).to_s # => "NaN+NaN*i"

Ruby Core © 1993–2024 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.

класс Complex

Прямоугольные координаты

Полярные координаты

Что здесь

Создание объектов Complex

Запрос

Сравнение

Преобразование

Выполнение арифметических операций с комплексными числами

Работа с JSON

Работа с `JSON`