Complex 类

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、Float、Integer 或 Rational 类的实例；它们可以被检索

分别使用方法 Complex#abs 和 Complex#arg.
一起使用方法 Complex#polar.

相应的（计算的）矩形值可以通过以下方法单独获取：

方法 Complex#real 和 Complex#imag。
一起使用方法 Complex#rect.

常量

I

等效于 Complex(0, 1)

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

公共类方法

polar(abs, arg = 0) → complex 点击切换源代码

返回一个由参数组成的新的 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)

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

rect(real, imag = 0) → complex 点击切换源代码

返回一个由参数组成的新的 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 的别名。

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

rect(real, imag = 0) → complex 点击切换源代码

返回一个由参数组成的新的 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 的别名。

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 → new_complex 点击切换源代码

返回 self 和 numeric 的乘积

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

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

complex ** numeric → new_complex 点击切换源代码

返回 self 的 numeric 次方

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

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 (result != Qundef) 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);
}

complex + numeric → new_complex 点击切换源代码

返回 self 和 numeric 的和

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)

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

complex - numeric → new_complex 点击切换源代码

返回 self 和 numeric 的差

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)

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

-complex → new_complex 点击切换源代码

返回 self 的相反数，即其各个部分的相反数

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

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

complex / numeric → new_complex 点击切换源代码

返回self 和 numeric 的商

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)

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

complex <=> object → -1, 0, 1, 或 nil 点击切换源代码

返回值

self.real <=> object.real 如果以下两个条件都满足
- self.imag == 0.
- object.imag == 0。# 如果 object 是数值类型但不是复数，则始终为真。
否则返回 nil。

示例

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

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

complex == object → true 或 false 点击切换源代码

如果 self.real == object.real 且 self.imag == object.imag，则返回 true

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

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

abs → float 点击切换源代码

返回 self 的绝对值（幅度）；参见极坐标

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

如果 self 是使用直角坐标创建的，则返回的值是计算出来的，可能不精确

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

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

别名：magnitude

abs2 → float 点击切换源代码

返回 self 的绝对值（幅度）的平方；参见极坐标

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

如果 self 是使用直角坐标创建的，则返回的值是计算出来的，可能不精确

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

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

angle()

返回 self 的辐角（角度），以弧度为单位；参见极坐标

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

如果 self 是使用直角坐标创建的，则返回的值是计算出来的，可能不精确

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

别名：arg

arg → float 点击切换源代码

返回 self 的辐角（角度），以弧度为单位；参见极坐标

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

如果 self 是使用直角坐标创建的，则返回的值是计算出来的，可能不精确

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

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

别名：angle，phase

conj → complex

返回 self 的共轭复数，Complex.rect(self.imag, self.real)

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

别名：conjugate

conjugate -> complex 点击切换源代码

返回 self 的共轭复数，Complex.rect(self.imag, self.real)

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

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

别名：conj

denominator → integer 点击切换源代码

返回 self 的分母，即 self.real.denominator 和 self.imag.denominator 的最小公倍数

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

请注意，非有理数的 n.denominator 为 1。