class 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。
这里有什么¶ ↑
首先，看看别的地方有什么
-
（间接地）包含模块 Comparable。
在这里，Complex 类具有以下方法：
创建 Complex 对象¶ ↑
-
::polar：基于给定的极坐标返回一个新的 Complex 对象。 -
::rect（及其别名::rectangular）：基于给定的直角坐标返回一个新的 Complex 对象。
查询¶ ↑
-
denominator：返回self的分母。 -
finite?：返回self.real和self.image是否都是有限的。 -
hash：返回self的整数哈希值。 -
infinite?：返回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]。
比较¶ ↑
转换¶ ↑
-
rationalize：返回一个Rational对象，其值与self.real的值完全或近似相等。 -
to_c：返回self。 -
to_d：将值作为
BigDecimal对象返回。 -
to_s：返回self的字符串表示。
执行 Complex 运算¶ ↑
-
*：返回self和给定数值的乘积。 -
**：返回self的给定数值次幂。 -
+：返回self和给定数值的和。 -
-：返回self和给定数值的差。 -
-@：返回self的负数。 -
/：返回self和给定数值的商。 -
abs2：返回self的绝对值（模）的平方。
使用 JSON¶ ↑
-
::json_create：返回一个根据给定的序列化哈希反序列化后的新的 Complex 对象。 -
as_json：返回一个由self构建的序列化哈希。
这些方法由 JSON gem 提供。要使这些方法可用：
require 'json/add/complex'
常量
- I
-
Complex::I # => (0+1i)
公共类方法
来源
# File ext/json/lib/json/add/complex.rb, line 9 def self.json_create(object) Complex(object['r'], object['i']) end
请参阅 as_json。
来源
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)
来源
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 的别名。
来源
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 的别名。
公共实例方法
来源
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)
来源
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)
来源
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)
来源
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)
来源
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)
来源
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)
来源
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。# 如果 object 是数值而不是复数，则始终为 true。
-
-
否则返回
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.
来源
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));
}
如果 self.real == object.real 且 self.imag == object.imag，则返回 true
Complex.rect(2, 3) == Complex.rect(2.0, 3.0) # => true
来源
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.
来源
来源
来源
# 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，返回一个表示 self 的 2 元素哈希。
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)
返回 self 的共轭，Complex.rect(self.imag, self.real)
Complex.rect(1, 2).conj # => (1-2i)
来源
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。
来源
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)
来源
static VALUE
rb_complex_finite_p(VALUE self)
{
get_dat1(self);
return RBOOL(f_finite_p(dat->real) && f_finite_p(dat->imag));
}
如果 self.real.finite? 和 self.imag.finite? 都为 true，则返回 true，否则返回 false。
Complex.rect(1, 1).finite? # => true Complex.rect(Float::INFINITY, 0).finite? # => false
相关： Numeric#finite?, Float#finite?。
来源
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
返回 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.
来源
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;
}
如果 self.real.infinite? 或 self.imag.infinite? 为 true，则返回 1，否则返回 nil。
Complex.rect(Float::INFINITY, 0).infinite? # => 1 Complex.rect(1, 1).infinite? # => nil
来源
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)"
来源
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))));
}
返回由 self 的实部和虚部的分子创建的 Complex 对象，在将每个部分转换为两者的最小公分母之后。
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。
来源
来源
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)
来源
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。
来源
VALUE
rb_complex_real(VALUE self)
{
get_dat1(self);
return dat->real;
}
返回 self 的实数值。
Complex.rect(7).real # => 7 Complex.rect(9, -4).real # => 9
如果 self 是使用 极坐标创建的，则返回的值是计算出来的，可能不精确。
Complex.polar(1, Math::PI/4).real # => 0.7071067811865476 # Square root of 2.
来源
static VALUE
nucomp_real_p_m(VALUE self)
{
return Qfalse;
}
返回 false；为了与 Numeric#real? 兼容。
返回一个由参数形成的新 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_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
如果 self.imag 不完全为零（要么是 Integer(0)，要么是 Rational(0, n)），则会引发 RangeError。
来源
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
如果 self.imag 不完全为零（要么是 Integer(0)，要么是 Rational(0, n)），则会引发 RangeError。
来源
# File ext/json/lib/json/add/complex.rb, line 48 def to_json(*args) as_json.to_json(*args) end
返回一个表示 self 的 JSON 字符串。
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}
来源
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)
如果 self.imag 不完全为零（要么是 Integer(0)，要么是 Rational(0, n)），并且 self.imag.to_r 不完全为零，则会引发 RangeError。
相关： Complex#rationalize。
来源
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"