class Complex

Ein Complex-Objekt speichert ein Paar von Werten, die bei der Erstellung des Objekts entweder als kartesische Koordinaten oder Polarkoordinaten übergeben werden.

Kartesische Koordinaten

Die kartesischen Koordinaten einer komplexen Zahl werden als reeller und imaginärer Teil bezeichnet; siehe Definition der komplexen Zahl.

Sie können ein Complex-Objekt aus kartesischen Koordinaten erstellen mit

Ein Komplex-Literal.
Methode Complex.rect.
Methode Kernel#Complex, entweder mit numerischen Argumenten oder mit bestimmten Zeichenkettenargumenten.
Methode String#to_c, für bestimmte Zeichenketten.

Beachten Sie, dass jeder der gespeicherten Teile eine Instanz einer der Klassen Complex, Float, Integer oder Rational sein kann; sie können abrufen werden

Separat mit den Methoden Complex#real und Complex#imaginary.
Zusammen mit der Methode Complex#rect.

Die entsprechenden (berechneten) Polarkoordinaten können abgerufen werden

Separat mit den Methoden Complex#abs und Complex#arg.
Zusammen mit der Methode Complex#polar.

Polarkoordinaten

Die Polarkoordinaten einer komplexen Zahl werden als Absolutbetrag und Argument bezeichnet; siehe Komplexe Polarebene.

In dieser Klasse wird der Argumentteil in Radiant (nicht in Grad) ausgedrückt.

Sie können ein Complex-Objekt aus Polarkoordinaten erstellen mit

Methode Complex.polar.
Methode Kernel#Complex, mit bestimmten Zeichenkettenargumenten.
Methode String#to_c, für bestimmte Zeichenketten.

Beachten Sie, dass jeder der gespeicherten Teile eine Instanz einer der Klassen Complex, Float, Integer oder Rational sein kann; sie können abrufen werden

Separat mit den Methoden Complex#abs und Complex#arg.
Zusammen mit der Methode Complex#polar.

Die entsprechenden (berechneten) kartesischen Koordinaten können abgerufen werden

Separat mit den Methoden Complex#real und Complex#imag.
Zusammen mit der Methode Complex#rect.

Was gibt es hier

Zunächst, was sonst noch da ist

Die Klasse Complex erbt (direkt oder indirekt) von den Klassen Numeric und Object.
Enthält (indirekt) das Modul Comparable.

Hier hat die Klasse Complex Methoden für

Erstellung von Complex-Objekten

::polar: Gibt ein neues Complex-Objekt zurück, das auf den angegebenen Polarkoordinaten basiert.
::rect (und sein Alias ::rectangular): Gibt ein neues Complex-Objekt zurück, das auf den angegebenen kartesischen Koordinaten basiert.

Abfragen

abs (und sein Alias magnitude): Gibt den Absolutbetrag für self zurück.
arg (und seine Aliase angle und phase): Gibt das Argument (den Winkel) für self in Radiant zurück.
denominator: Gibt den Nenner von self zurück.
finite?: Gibt zurück, ob sowohl self.real als auch self.image endlich sind.
hash: Gibt den ganzzahligen Hash-Wert für self zurück.
imag (und sein Alias imaginary): Gibt den imaginären Wert für self zurück.
infinite?: Gibt zurück, ob self.real oder self.image unendlich ist.
numerator: Gibt den Zähler von self zurück.
polar: Gibt das Array [self.abs, self.arg] zurück.
inspect: Gibt eine Zeichenkettenrepräsentation von self zurück.
real: Gibt den reellen Wert für self zurück.
real?: Gibt false zurück; zur Kompatibilität mit Numeric#real?.
rect (und sein Alias rectangular): Gibt das Array [self.real, self.imag] zurück.

Vergleichen

<=>: Gibt zurück, ob self kleiner als, gleich oder größer als das gegebene Argument ist.
==: Gibt zurück, ob self gleich dem gegebenen Argument ist.

Konvertieren

rationalize: Gibt ein Rational-Objekt zurück, dessen Wert exakt oder annähernd gleich dem von self.real ist.
to_c: Gibt self zurück.
to_d: Gibt den Wert als BigDecimal-Objekt zurück.
to_f: Gibt den Wert von self.real als Float zurück, falls möglich.
to_i: Gibt den Wert von self.real als Integer zurück, falls möglich.
to_r: Gibt den Wert von self.real als Rational zurück, falls möglich.
to_s: Gibt eine Zeichenkettenrepräsentation von self zurück.

Ausführen von `Complex`-Arithmetik

*: Gibt das Produkt von self und der gegebenen Zahl zurück.
**: Gibt self potenziert mit der gegebenen Zahl zurück.
+: Gibt die Summe von self und der gegebenen Zahl zurück.
-: Gibt die Differenz von self und der gegebenen Zahl zurück.
-@: Gibt die Negation von self zurück.
/: Gibt den Quotienten von self und der gegebenen Zahl zurück.
abs2: Gibt das Quadrat des Absolutbetrags (Betrags) für self zurück.
conj (und sein Alias conjugate): Gibt die Konjugierte von self zurück.
fdiv: Gibt Complex.rect(self.real/numeric, self.imag/numeric) zurück.

Arbeiten mit `JSON`

::json_create: Gibt ein neues Complex-Objekt zurück, deserialisiert aus dem gegebenen serialisierten Hash.
as_json: Gibt einen serialisierten Hash zurück, der aus self konstruiert wurde.
to_json: Gibt eine JSON-Zeichenkette zurück, die self darstellt.

Diese Methoden werden vom JSON-Gem bereitgestellt. Um diese Methoden verfügbar zu machen

require 'json/add/complex'

Constants

I

Entspricht Complex.rect(0, 1)

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

Öffentliche Klassenmethoden

json_create (object)

Source

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

Siehe as_json.

polar(abs, arg = 0) → complex

Source

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

Gibt ein neues Complex-Objekt zurück, das aus den Argumenten gebildet wird. Jedes Argument muss eine Instanz von Numeric oder eine Instanz einer seiner Unterklassen sein: Complex, Float, Integer, Rational. Das Argument arg wird in Radiant angegeben; siehe Polarkoordinaten

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

Source

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.rect(3)             # => (3+0i)
Complex.rect(3, Math::PI)   # => (3+3.141592653589793i)
Complex.rect(-3, -Math::PI) # => (-3-3.141592653589793i)

Complex.rectangular ist ein Alias für Complex.rect.

rect(real, imag = 0) → complex

Source

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.rect(3)             # => (3+0i)
Complex.rect(3, Math::PI)   # => (3+3.141592653589793i)
Complex.rect(-3, -Math::PI) # => (-3-3.141592653589793i)

Complex.rectangular ist ein Alias für Complex.rect.

Öffentliche Instanzmethoden

self * other → numeric

Source

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

Gibt das numerische Produkt von self und other zurück.

Complex.rect(9, 8)  * 4                   # => (36+32i)
Complex.rect(20, 9) * 9.8                 # => (196.0+88.2i)
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)  * Rational(2, 3)      # => ((6/1)+(16/3)*i)

self ** exponent → complex

Source

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

Gibt self hoch exponent zurück.

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

self + other → numeric

Source

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

Gibt die Summe von self und other zurück.

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

Complex(1, 2) + 1.0  # => (2.0+2i)

Complex(1, 2) + Complex(2, 1)     # => (3+3i)
Complex(1, 2) + Complex(2.0, 1.0) # => (3.0+3.0i)

Complex(1, 2) + Rational(1, 1) # => ((2/1)+2i)
Complex(1, 2) + Rational(1, 2) # => ((3/2)+2i)

Bei einer Berechnung mit Floats kann das Ergebnis ungenau sein (siehe Float#+).

Complex(1, 2) + 3.14 # => (4.140000000000001+2i)

self - other → complex

Source

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

Gibt die Differenz von self und other zurück.

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)

-self → complex

Source

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

Gibt self negiert zurück, was die Negation jedes seiner Teile ist.

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

self / other → complex

Source

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

Gibt den Quotienten von self und other zurück.

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)

self <=> other → -1, 0, 1, or nil

Source

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

Vergleicht self und other.

Gibt zurück

self.real <=> other.real, wenn beide der folgenden Bedingungen erfüllt sind
- self.imag == 0.
- other.imag == 0 (immer wahr, wenn other numerisch, aber nicht komplex ist).
nil andernfalls.

Beispiele

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.

Die Klasse Complex enthält das Modul Comparable, dessen Methoden für Vergleiche Complex#<=> verwenden.

complex == object → true or false

Source

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

Gibt true zurück, wenn self.real == object.real und self.imag == object.imag

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

abs → float

Source

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

Gibt den Absolutbetrag (Betrag) für self zurück; siehe Polarkoordinaten

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

Wenn self mit kartesischen Koordinaten erstellt wurde, wird der zurückgegebene Wert berechnet und kann ungenau sein.

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

Auch aliasisiert als: magnitude

abs2 → float

Source

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

Gibt das Quadrat des Absolutbetrags (Betrags) für self zurück; siehe Polarkoordinaten

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

Wenn self mit kartesischen Koordinaten erstellt wurde, wird der zurückgegebene Wert berechnet und kann ungenau sein.

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

angle

Alias für: arg

arg → float

Source

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

Gibt das Argument (den Winkel) für self in Radiant zurück; siehe Polarkoordinaten

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

Wenn self mit kartesischen Koordinaten erstellt wurde, wird der zurückgegebene Wert berechnet und kann ungenau sein.

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

Auch aliasisiert als: angle, phase

as_json (*)

Source

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

Die Methoden Complex#as_json und Complex.json_create können verwendet werden, um ein Complex-Objekt zu serialisieren und zu deserialisieren; siehe Marshal.

Die Methode Complex#as_json serialisiert self und gibt einen 2-Element-Hash zurück, der self repräsentiert.

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}

Die Methode JSON.create deserialisiert einen solchen Hash und gibt ein Complex-Objekt zurück.

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

conj → complex

Gibt die Konjugierte von self zurück, Complex.rect(self.imag, self.real)

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

Alias für: conjugate

conjugate

Source

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

Auch aliasisiert als: conj

denominator → integer

Source

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

Gibt den Nenner von self zurück, der das kleinste gemeinsame Vielfache von self.real.denominator und self.imag.denominator ist.

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

Beachten Sie, dass n.denominator einer nicht-rationalen Zahl 1 ist.

Zugehörig: Complex#numerator.

fdiv(numeric) → new_complex

Source

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

Gibt Complex.rect(self.real/numeric, self.imag/numeric) zurück.

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

finite? → true or false

Source

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

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

Gibt true zurück, wenn sowohl self.real.finite? als auch self.imag.finite? wahr sind, andernfalls false.

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

Zugehörig: Numeric#finite?, Float#finite?.

hash → integer

Source

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

Gibt den ganzzahligen Hash-Wert für self zurück.

Zwei Complex-Objekte, die aus denselben Werten erstellt wurden, haben denselben Hash-Wert (und vergleichen sich mit eql?).

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

imag → numeric

Gibt den imaginären Wert für self zurück.

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

Wenn self mit Polarkoordinaten erstellt wurde, wird der zurückgegebene Wert berechnet und kann ungenau sein.

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

Alias für: imaginary

imaginary

Source

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

Auch aliasisiert als: imag

infinite? → 1 or nil

Source

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

Gibt 1 zurück, wenn entweder self.real.infinite? oder self.imag.infinite? wahr ist, andernfalls nil.

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

Zugehörig: Numeric#infinite?, Float#infinite?.

inspect → String

Source

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

Gibt eine String-Repräsentation von self zurück.

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

Alias für: abs

numerator → new_complex

Source

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

Gibt das Complex-Objekt zurück, das aus den Zählern der reellen und imaginären Teile von self gebildet wird, nachdem jeder Teil in den kleinsten gemeinsamen Nenner der beiden konvertiert wurde.

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

In diesem Beispiel ist der kleinste gemeinsame Nenner der beiden Teile 12; die beiden konvertierten Teile können als Rational(8, 12) und Rational(9, 12) betrachtet werden, deren Zähler 8 bzw. 9 sind; daher ist der zurückgegebene Wert von c.numerator Complex.rect(8, 9).

Zugehörig: Complex#denominator.

phase

Alias für: arg

polar → array

Source

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

Gibt das Array [self.abs, self.arg] zurück.

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

Siehe Polarkoordinaten.

Wenn self mit kartesischen Koordinaten erstellt wurde, wird der zurückgegebene Wert berechnet und kann ungenau sein.

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

self / other → complex

Source

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

Gibt den Quotienten von self und other zurück.

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) → rational

Source

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

Gibt ein Rational-Objekt zurück, dessen Wert exakt oder annähernd gleich dem von self.real ist.

Wenn kein Argument epsilon angegeben ist, wird ein Rational-Objekt zurückgegeben, dessen Wert exakt gleich dem von self.real.rationalize ist.

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

Wenn das Argument epsilon angegeben ist, wird ein Rational-Objekt zurückgegeben, dessen Wert exakt oder annähernd gleich dem von self.real bis zur angegebenen Genauigkeit ist.

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)

Zugehörig: Complex#to_r.

real → numeric

Source

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

Gibt den reellen Wert für self zurück.

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

Wenn self mit Polarkoordinaten erstellt wurde, wird der zurückgegebene Wert berechnet und kann ungenau sein.

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

real? → false

Source

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

Gibt false zurück; zur Kompatibilität mit Numeric#real?.

rect → array

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

Complex.rectangular ist ein Alias für Complex.rect.

Alias für: rectangular

rectangular

Source

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

Auch aliasisiert als: rect, rect

to_c → self

Source

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

Gibt self zurück.

to_f → float

Source

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

Gibt den Wert von self.real als Float zurück, falls möglich.

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

Löst RangeError aus, wenn self.imag nicht exakt null ist (entweder Integer(0) oder Rational(0, n)).

to_i → integer

Source

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

Gibt den Wert von self.real als Integer zurück, falls möglich.

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

Löst RangeError aus, wenn self.imag nicht exakt null ist (entweder Integer(0) oder Rational(0, n)).

to_json (*args)

Source

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

Gibt einen JSON-String zurück, der self repräsentiert

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

Ausgabe

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

to_r → rational

Source

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

Gibt den Wert von self.real als Rational zurück, falls möglich.

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)

Löst RangeError aus, wenn self.imag nicht exakt null ist (entweder Integer(0) oder Rational(0, n)) und self.imag.to_r nicht exakt null ist.

Zugehörig: Complex#rationalize.

to_s → String

Source

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

Gibt eine String-Repräsentation von self zurück.

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"

class Complex

Ausführen von Complex-Arithmetik

Ausführen von `Complex`-Arithmetik