Modul Math

Das Modul Math bietet Methoden für grundlegende trigonometrische, logarithmische und transzendente Funktionen sowie für das Extrahieren von Wurzeln.

Sie können seine Konstanten und Methodenaufrufe wie folgt schreiben

Math::PI      # => 3.141592653589793
Math::E       # => 2.718281828459045
Math.sin(0.0) # => 0.0
Math.cos(0.0) # => 1.0

Wenn Sie das Modul Math einbinden, können Sie einfachere Formen verwenden

include Math
PI       # => 3.141592653589793
E        # => 2.718281828459045
sin(0.0) # => 0.0
cos(0.0) # => 1.0

Der Einfachheit halber wird in den Beispielen hier angenommen

include Math
INFINITY = Float::INFINITY

Die Domänen und Wertebereiche für die Methoden werden durch offene oder geschlossene Intervalle mit runden bzw. eckigen Klammern bezeichnet

Ein offenes Intervall schließt die Endpunkte nicht ein
```
(-INFINITY, INFINITY)
```
Ein geschlossenes Intervall schließt die Endpunkte ein
```
[-1.0, 1.0]
```
Ein halboffenes Intervall schließt einen Endpunkt ein, aber nicht den anderen
```
[1.0, INFINITY)
```

Viele Werte, die von Math-Methoden zurückgegeben werden, sind numerische Annäherungen. Das liegt daran, dass viele solcher Werte in der Mathematik unendliche Genauigkeit haben, während in der numerischen Berechnung die Genauigkeit endlich ist.

So ist in der Mathematik cos(π/2) exakt Null, aber in unserer Berechnung ist cos(PI/2) eine Zahl, die sehr nahe bei Null liegt.

cos(PI/2) # => 6.123031769111886e-17

Für sehr große und sehr kleine zurückgegebene Werte haben wir zur besseren Lesbarkeit formatierte Zahlen hinzugefügt

tan(PI/2)  # => 1.633123935319537e+16   # 16331239353195370.0
tan(PI)    # => -1.2246467991473532e-16 # -0.0000000000000001

Siehe Klasse Float für die Konstanten, die die Gleitkommaarithmetik von Ruby beeinflussen.

Was gibt es hier

Trigonometrische Funktionen

::cos: Gibt den Kosinus des gegebenen Arguments zurück.
::sin: Gibt den Sinus des gegebenen Arguments zurück.
::tan: Gibt den Tangens des gegebenen Arguments zurück.

Inverse trigonometrische Funktionen

::acos: Gibt den Arkuskosinus des gegebenen Arguments zurück.
::asin: Gibt den Arcussinus des gegebenen Arguments zurück.
::atan: Gibt den Arkustangens des gegebenen Arguments zurück.
::atan2: Gibt den Arkustangens zweier gegebener Argumente zurück.

Hyperbolische trigonometrische Funktionen

::cosh: Gibt den hyperbolischen Kosinus des gegebenen Arguments zurück.
::sinh: Gibt den hyperbolischen Sinus des gegebenen Arguments zurück.
::tanh: Gibt den hyperbolischen Tangens des gegebenen Arguments zurück.

Inverse hyperbolische trigonometrische Funktionen

::acosh: Gibt den inversen hyperbolischen Kosinus des gegebenen Arguments zurück.
::asinh: Gibt den inversen hyperbolischen Sinus des gegebenen Arguments zurück.
::atanh: Gibt den inversen hyperbolischen Tangens des gegebenen Arguments zurück.

Exponentiations- und logarithmische Funktionen

::exp: Gibt den Wert von e hoch dem gegebenen Wert zurück.
::log: Gibt den Logarithmus eines gegebenen Werts zur gegebenen Basis zurück.
::log10: Gibt den Logarithmus zur Basis 10 des gegebenen Arguments zurück.
::log2: Gibt den Logarithmus zur Basis 2 des gegebenen Arguments zurück.

Bruch- und Exponentenfunktionen

::frexp: Gibt den Bruch und den Exponenten des gegebenen Arguments zurück.
::ldexp: Gibt den Wert für einen gegebenen Bruch und Exponenten zurück.

Wurzelfunktionen

::cbrt: Gibt die Kubikwurzel des gegebenen Arguments zurück.
::sqrt: Gibt die Quadratwurzel des gegebenen Arguments zurück.

Fehlerfunktionen

::erf: Gibt den Wert der Gaußschen Fehlerfunktion für das gegebene Argument zurück.
::erfc: Gibt den Wert der komplementären Fehlerfunktion für das gegebene Argument zurück.

Gamma-Funktionen

::gamma: Gibt den Wert der Gamma-Funktion für das gegebene Argument zurück.
::lgamma: Gibt den Wert der logarithmischen Gamma-Funktion für das gegebene Argument zurück.

Hypotenusenfunktion

::hypot: Gibt sqrt(a**2 + b**2) für die gegebenen a und b zurück.

Constants

E: Definition der mathematischen Konstante E für die Eulersche Zahl (e) als Float-Zahl.
PI: Definition der mathematischen Konstante PI als Float-Zahl.

Öffentliche Klassenmethoden

acos(x) → float

Source

static VALUE
math_acos(VALUE unused_obj, VALUE x)
{
    math_arc(x, acos)
}

Gibt den Arkuskosinus von x zurück.

Domäne: [-1, 1].
Wertebereich: [0, PI].

Beispiele

acos(-1.0) # => 3.141592653589793  # PI
acos(0.0)  # => 1.5707963267948966 # PI/2
acos(1.0)  # => 0.0

acosh(x) → float

Source

static VALUE
math_acosh(VALUE unused_obj, VALUE x)
{
    double d;

    d = Get_Double(x);
    domain_check_min(d, 1.0, "acosh");
    return DBL2NUM(acosh(d));
}

Gibt den inversen hyperbolischen Kosinus von x zurück.

Domäne: [1, INFINITY].
Wertebereich: [0, INFINITY].

Beispiele

acosh(1.0)      # => 0.0
acosh(INFINITY) # => Infinity

asin(x) → float

Source

static VALUE
math_asin(VALUE unused_obj, VALUE x)
{
    math_arc(x, asin)
}

Gibt den Arcussinus von x zurück.

Domäne: [-1, -1].
Wertebereich: [-PI/2, PI/2].

Beispiele

asin(-1.0) # => -1.5707963267948966 # -PI/2
asin(0.0)  # => 0.0
asin(1.0)  # => 1.5707963267948966  # PI/2

asinh(x) → float

Source

static VALUE
math_asinh(VALUE unused_obj, VALUE x)
{
    return DBL2NUM(asinh(Get_Double(x)));
}

Gibt den inversen hyperbolischen Sinus von x zurück.

Domäne: [-INFINITY, INFINITY].
Wertebereich: [-INFINITY, INFINITY].

Beispiele

asinh(-INFINITY) # => -Infinity
asinh(0.0)       # => 0.0
asinh(INFINITY)  # => Infinity

atan(x) → Float

Source

static VALUE
math_atan(VALUE unused_obj, VALUE x)
{
    return DBL2NUM(atan(Get_Double(x)));
}

Gibt den Arkustangens von x zurück.

Domäne: [-INFINITY, INFINITY].
Wertebereich: [-PI/2, PI/2] .

Beispiele

atan(-INFINITY) # => -1.5707963267948966 # -PI2
atan(-PI)       # => -1.2626272556789115
atan(-PI/2)     # => -1.0038848218538872
atan(0.0)       # => 0.0
atan(PI/2)      # => 1.0038848218538872
atan(PI)        # => 1.2626272556789115
atan(INFINITY)  # => 1.5707963267948966  # PI/2

atan2(y, x) → float

Source

static VALUE
math_atan2(VALUE unused_obj, VALUE y, VALUE x)
{
    double dx, dy;
    dx = Get_Double(x);
    dy = Get_Double(y);
    if (dx == 0.0 && dy == 0.0) {
        if (!signbit(dx))
            return DBL2NUM(dy);
        if (!signbit(dy))
            return DBL2NUM(M_PI);
        return DBL2NUM(-M_PI);
    }
#ifndef ATAN2_INF_C99
    if (isinf(dx) && isinf(dy)) {
        /* optimization for FLONUM */
        if (dx < 0.0) {
            const double dz = (3.0 * M_PI / 4.0);
            return (dy < 0.0) ? DBL2NUM(-dz) : DBL2NUM(dz);
        }
        else {
            const double dz = (M_PI / 4.0);
            return (dy < 0.0) ? DBL2NUM(-dz) : DBL2NUM(dz);
        }
    }
#endif
    return DBL2NUM(atan2(dy, dx));
}

Gibt den Arkustangens von y und x in Radiant zurück.

Domäne von y: [-INFINITY, INFINITY].
Domäne von x: [-INFINITY, INFINITY].
Wertebereich: [-PI, PI].

Beispiele

atan2(-1.0, -1.0) # => -2.356194490192345  # -3*PI/4
atan2(-1.0, 0.0)  # => -1.5707963267948966 # -PI/2
atan2(-1.0, 1.0)  # => -0.7853981633974483 # -PI/4
atan2(0.0, -1.0)  # => 3.141592653589793   # PI

atanh(x) → float

Source

static VALUE
math_atanh(VALUE unused_obj, VALUE x)
{
    double d;

    d = Get_Double(x);
    domain_check_range(d, -1.0, +1.0, "atanh");
    /* check for pole error */
    if (d == -1.0) return DBL2NUM(-HUGE_VAL);
    if (d == +1.0) return DBL2NUM(+HUGE_VAL);
    return DBL2NUM(atanh(d));
}

Gibt den inversen hyperbolischen Tangens von x zurück.

Domäne: [-1, 1].
Wertebereich: [-INFINITY, INFINITY].

Beispiele

atanh(-1.0) # => -Infinity
atanh(0.0)  # => 0.0
atanh(1.0)  # => Infinity

cbrt(x) → float

Source

static VALUE
math_cbrt(VALUE unused_obj, VALUE x)
{
    double f = Get_Double(x);
    double r = cbrt(f);
#if defined __GLIBC__
    if (isfinite(r) && !(f == 0.0 && r == 0.0)) {
        r = (2.0 * r + (f / r / r)) / 3.0;
    }
#endif
    return DBL2NUM(r);
}

Gibt die Kubikwurzel von x zurück.

Domäne: [-INFINITY, INFINITY].
Wertebereich: [-INFINITY, INFINITY].

Beispiele

cbrt(-INFINITY) # => -Infinity
cbrt(-27.0)     # => -3.0
cbrt(-8.0)      # => -2.0
cbrt(-2.0)      # => -1.2599210498948732
cbrt(1.0)       # => 1.0
cbrt(0.0)       # => 0.0
cbrt(1.0)       # => 1.0
cbrt(2.0)       # => 1.2599210498948732
cbrt(8.0)       # => 2.0
cbrt(27.0)      # => 3.0
cbrt(INFINITY)  # => Infinity

cos(x) → float

Source

static VALUE
math_cos(VALUE unused_obj, VALUE x)
{
    return DBL2NUM(cos(Get_Double(x)));
}

Gibt den Kosinus von x in Radiant zurück.

Domäne: (-INFINITY, INFINITY).
Wertebereich: [-1.0, 1.0].

Beispiele

cos(-PI)   # => -1.0
cos(-PI/2) # => 6.123031769111886e-17 # 0.0000000000000001
cos(0.0)   # => 1.0
cos(PI/2)  # => 6.123031769111886e-17 # 0.0000000000000001
cos(PI)    # => -1.0

cosh(x) → float

Source

static VALUE
math_cosh(VALUE unused_obj, VALUE x)
{
    return DBL2NUM(cosh(Get_Double(x)));
}

Gibt den hyperbolischen Kosinus von x in Radiant zurück.

Domäne: [-INFINITY, INFINITY].
Wertebereich: [1, INFINITY].

Beispiele

cosh(-INFINITY) # => Infinity
cosh(0.0)       # => 1.0
cosh(INFINITY)  # => Infinity

erf(x) → float

Source

static VALUE
math_erf(VALUE unused_obj, VALUE x)
{
    return DBL2NUM(erf(Get_Double(x)));
}

Gibt den Wert der Gaußschen Fehlerfunktion für x zurück.

Domäne: [-INFINITY, INFINITY].
Wertebereich: [-1, 1].

Beispiele

erf(-INFINITY) # => -1.0
erf(0.0)       # => 0.0
erf(INFINITY)  # => 1.0

Verwandt: Math.erfc.

erfc(x) → Float

Source

static VALUE
math_erfc(VALUE unused_obj, VALUE x)
{
    return DBL2NUM(erfc(Get_Double(x)));
}

Gibt den Wert der komplementären Fehlerfunktion für x zurück.

Domäne: [-INFINITY, INFINITY].
Wertebereich: [0, 2].

Beispiele

erfc(-INFINITY) # => 2.0
erfc(0.0)       # => 1.0
erfc(INFINITY)  # => 0.0

Verwandt: Math.erf.

exp(x) → float

Source

static VALUE
math_exp(VALUE unused_obj, VALUE x)
{
    return DBL2NUM(exp(Get_Double(x)));
}

Gibt e hoch die Potenz x zurück.

Domäne: [-INFINITY, INFINITY].
Wertebereich: [0, INFINITY].

Beispiele

exp(-INFINITY) # => 0.0
exp(-1.0)      # => 0.36787944117144233 # 1.0/E
exp(0.0)       # => 1.0
exp(0.5)       # => 1.6487212707001282  # sqrt(E)
exp(1.0)       # => 2.718281828459045   # E
exp(2.0)       # => 7.38905609893065    # E**2
exp(INFINITY)  # => Infinity

expm1(x) → float

Source

static VALUE
math_expm1(VALUE unused_obj, VALUE x)
{
    return DBL2NUM(expm1(Get_Double(x)));
}

Gibt “exp(x) - 1” zurück, also e hoch die Potenz x, minus 1.

Domäne: [-INFINITY, INFINITY].
Wertebereich: [-1.0, INFINITY].

Beispiele

expm1(-INFINITY) # => 0.0
expm1(-1.0)      # => -0.6321205588285577 # 1.0/E - 1
expm1(0.0)       # => 0.0
expm1(0.5)       # => 0.6487212707001282  # sqrt(E) - 1
expm1(1.0)       # => 1.718281828459045   # E - 1
expm1(2.0)       # => 6.38905609893065    # E**2 - 1
expm1(INFINITY)  # => Infinity

frexp(x) → [bruch, exponent]

Source

static VALUE
math_frexp(VALUE unused_obj, VALUE x)
{
    double d;
    int exp;

    d = frexp(Get_Double(x), &exp);
    return rb_assoc_new(DBL2NUM(d), INT2NUM(exp));
}

Gibt ein Array mit 2 Elementen zurück, das den normalisierten signierten Float-Wert bruch und den Integer-Wert exponent von x enthält, so dass

x = fraction * 2**exponent

Siehe IEEE 754 double-precision binary floating-point format: binary64.

Domäne: [-INFINITY, INFINITY].
Range [-INFINITY, INFINITY].

Beispiele

frexp(-INFINITY) # => [-Infinity, -1]
frexp(-2.0)      # => [-0.5, 2]
frexp(-1.0)      # => [-0.5, 1]
frexp(0.0)       # => [0.0, 0]
frexp(1.0)       # => [0.5, 1]
frexp(2.0)       # => [0.5, 2]
frexp(INFINITY)  # => [Infinity, -1]

Verwandt: Math.ldexp (invers zu Math.frexp).

gamma(x) → float

Source

static VALUE
math_gamma(VALUE unused_obj, VALUE x)
{
    static const double fact_table[] = {
        /* fact(0) */ 1.0,
        /* fact(1) */ 1.0,
        /* fact(2) */ 2.0,
        /* fact(3) */ 6.0,
        /* fact(4) */ 24.0,
        /* fact(5) */ 120.0,
        /* fact(6) */ 720.0,
        /* fact(7) */ 5040.0,
        /* fact(8) */ 40320.0,
        /* fact(9) */ 362880.0,
        /* fact(10) */ 3628800.0,
        /* fact(11) */ 39916800.0,
        /* fact(12) */ 479001600.0,
        /* fact(13) */ 6227020800.0,
        /* fact(14) */ 87178291200.0,
        /* fact(15) */ 1307674368000.0,
        /* fact(16) */ 20922789888000.0,
        /* fact(17) */ 355687428096000.0,
        /* fact(18) */ 6402373705728000.0,
        /* fact(19) */ 121645100408832000.0,
        /* fact(20) */ 2432902008176640000.0,
        /* fact(21) */ 51090942171709440000.0,
        /* fact(22) */ 1124000727777607680000.0,
        /* fact(23)=25852016738884976640000 needs 56bit mantissa which is
         * impossible to represent exactly in IEEE 754 double which have
         * 53bit mantissa. */
    };
    enum {NFACT_TABLE = numberof(fact_table)};
    double d;
    d = Get_Double(x);
    /* check for domain error */
    if (isinf(d)) {
        if (signbit(d)) domain_error("gamma");
        return DBL2NUM(HUGE_VAL);
    }
    if (d == 0.0) {
        return signbit(d) ? DBL2NUM(-HUGE_VAL) : DBL2NUM(HUGE_VAL);
    }
    if (d == floor(d)) {
        domain_check_min(d, 0.0, "gamma");
        if (1.0 <= d && d <= (double)NFACT_TABLE) {
            return DBL2NUM(fact_table[(int)d - 1]);
        }
    }
    return DBL2NUM(tgamma(d));
}

Gibt den Wert der Gamma-Funktion für x zurück.

Domäne: (-INFINITY, INFINITY] ausgenommen negative ganze Zahlen.
Wertebereich: [-INFINITY, INFINITY].

Beispiele

gamma(-2.5)      # => -0.9453087204829431
gamma(-1.5)      # => 2.3632718012073513
gamma(-0.5)      # => -3.5449077018110375
gamma(0.0)      # => Infinity
gamma(1.0)      # => 1.0
gamma(2.0)      # => 1.0
gamma(3.0)      # => 2.0
gamma(4.0)      # => 6.0
gamma(5.0)      # => 24.0

Verwandt: Math.lgamma.

hypot(a, b) → float

Source

static VALUE
math_hypot(VALUE unused_obj, VALUE x, VALUE y)
{
    return DBL2NUM(hypot(Get_Double(x), Get_Double(y)));
}

Gibt sqrt(a**2 + b**2) zurück, was der Länge der längsten Seite c (der Hypotenuse) eines rechtwinkligen Dreiecks mit den Seitenlängen a und b entspricht.

Domäne von a: [-INFINITY, INFINITY].
Domäne von +ab: [-INFINITY, INFINITY].
Wertebereich: [0, INFINITY].

Beispiele

hypot(0.0, 1.0)       # => 1.0
hypot(1.0, 1.0)       # => 1.4142135623730951 # sqrt(2.0)
hypot(3.0, 4.0)       # => 5.0
hypot(5.0, 12.0)      # => 13.0
hypot(1.0, sqrt(3.0)) # => 1.9999999999999998 # Near 2.0

Beachten Sie, dass wenn eines der Argumente INFINITY oder -INFINITY ist, das Ergebnis Infinity ist.

ldexp(bruch, exponent) → float

Source

static VALUE
math_ldexp(VALUE unused_obj, VALUE x, VALUE n)
{
    return DBL2NUM(ldexp(Get_Double(x), NUM2INT(n)));
}

Gibt den Wert von bruch * 2**exponent zurück.

Domäne von bruch: [0.0, 1.0).
Domäne von exponent: [0, 1024] (größere Werte sind äquivalent zu 1024).

Siehe IEEE 754 double-precision binary floating-point format: binary64.

Beispiele

ldexp(-INFINITY, -1) # => -Infinity
ldexp(-0.5, 2)       # => -2.0
ldexp(-0.5, 1)       # => -1.0
ldexp(0.0, 0)        # => 0.0
ldexp(-0.5, 1)       # => 1.0
ldexp(-0.5, 2)       # => 2.0
ldexp(INFINITY, -1)  # => Infinity

Verwandt: Math.frexp (invers zu Math.ldexp).

lgamma(x) → [float, -1 oder 1]

Source

static VALUE
math_lgamma(VALUE unused_obj, VALUE x)
{
    double d;
    int sign=1;
    VALUE v;
    d = Get_Double(x);
    /* check for domain error */
    if (isinf(d)) {
        if (signbit(d)) domain_error("lgamma");
        return rb_assoc_new(DBL2NUM(HUGE_VAL), INT2FIX(1));
    }
    if (d == 0.0) {
        VALUE vsign = signbit(d) ? INT2FIX(-1) : INT2FIX(+1);
        return rb_assoc_new(DBL2NUM(HUGE_VAL), vsign);
    }
    v = DBL2NUM(lgamma_r(d, &sign));
    return rb_assoc_new(v, INT2FIX(sign));
}

Gibt ein Array mit 2 Elementen zurück, das äquivalent ist zu

[Math.log(Math.gamma(x).abs), Math.gamma(x) < 0 ? -1 : 1]

Siehe Log-Gamma-Funktion.

Domäne: (-INFINITY, INFINITY].
Range des ersten Elements: (-INFINITY, INFINITY].
Das zweite Element ist -1 oder 1.

Beispiele

lgamma(-4.0) # => [Infinity, -1]
lgamma(-3.0) # => [Infinity, -1]
lgamma(-2.0) # => [Infinity, -1]
lgamma(-1.0) # => [Infinity, -1]
lgamma(0.0)  # => [Infinity, 1]

lgamma(1.0)  # => [0.0, 1]
lgamma(2.0)  # => [0.0, 1]
lgamma(3.0)  # => [0.6931471805599436, 1]
lgamma(4.0)  # => [1.7917594692280545, 1]

lgamma(-2.5) # => [-0.05624371649767279, -1]
lgamma(-1.5) # => [0.8600470153764797, 1]
lgamma(-0.5) # => [1.265512123484647, -1]
lgamma(0.5)  # => [0.5723649429247004, 1]
lgamma(1.5)  # => [-0.12078223763524676, 1]
lgamma(2.5)      # => [0.2846828704729205, 1]

Verwandt: Math.gamma.

log(x, basis = Math::E) → Float

Source

static VALUE
math_log(int argc, const VALUE *argv, VALUE unused_obj)
{
    return rb_math_log(argc, argv);
}

Gibt den Logarithmus von x zur Basis basis zurück.

Domäne: [0, INFINITY].
Wertebereich: [-INFINITY, INFINITY).

Beispiele

log(0.0)        # => -Infinity
log(1.0)        # => 0.0
log(E)          # => 1.0
log(INFINITY)   # => Infinity

log(0.0, 2.0)   # => -Infinity
log(1.0, 2.0)   # => 0.0
log(2.0, 2.0)   # => 1.0

log(0.0, 10.0)  # => -Infinity
log(1.0, 10.0)  # => 0.0
log(10.0, 10.0) # => 1.0

log10(x) → float

Source

static VALUE
math_log10(VALUE unused_obj, VALUE x)
{
    size_t numbits;
    double d = get_double_rshift(x, &numbits);

    domain_check_min(d, 0.0, "log10");
    /* check for pole error */
    if (d == 0.0) return DBL2NUM(-HUGE_VAL);

    return DBL2NUM(log10(d) + numbits * log10(2)); /* log10(d * 2 ** numbits) */
}

Gibt den Logarithmus von x zur Basis 10 zurück.

Domäne: [0, INFINITY].
Wertebereich: [-INFINITY, INFINITY].

Beispiele

log10(0.0)      # => -Infinity
log10(1.0)      # => 0.0
log10(10.0)     # => 1.0
log10(INFINITY) # => Infinity

log1p(x) → float

Source

static VALUE
math_log1p(VALUE unused_obj, VALUE x)
{
    size_t numbits;
    double d = get_double_rshift(x, &numbits);

    if (numbits != 0) {
        x = rb_big_plus(x, INT2FIX(1));
        d = math_log_split(x, &numbits);
        /* check for pole error */
        if (d == 0.0) return DBL2NUM(-HUGE_VAL);
        d = log(d);
        d += numbits * M_LN2;
        return DBL2NUM(d);
    }

    domain_check_min(d, -1.0, "log1p");
    /* check for pole error */
    if (d == -1.0) return DBL2NUM(-HUGE_VAL);

    return DBL2NUM(log1p(d)); /* log10(d * 2 ** numbits) */
}

Gibt “log(x + 1)” zurück, also den E-basierten Logarithmus von (x + 1).

Domäne: [-1, INFINITY].
Wertebereich: [-INFINITY, INFINITY].

Beispiele

log1p(-1.0)     # => -Infinity
log1p(0.0)      # => 0.0
log1p(E - 1)    # => 1.0
log1p(INFINITY) # => Infinity

log2(x) → float

Source

static VALUE
math_log2(VALUE unused_obj, VALUE x)
{
    size_t numbits;
    double d = get_double_rshift(x, &numbits);

    domain_check_min(d, 0.0, "log2");
    /* check for pole error */
    if (d == 0.0) return DBL2NUM(-HUGE_VAL);

    return DBL2NUM(log2(d) + numbits); /* log2(d * 2 ** numbits) */
}

Gibt den Logarithmus von x zur Basis 2 zurück.

Domäne: [0, INFINITY].
Wertebereich: [-INFINITY, INFINITY].

Beispiele

log2(0.0)      # => -Infinity
log2(1.0)      # => 0.0
log2(2.0)      # => 1.0
log2(INFINITY) # => Infinity

sin(x) → float

Source

static VALUE
math_sin(VALUE unused_obj, VALUE x)
{
    return DBL2NUM(sin(Get_Double(x)));
}

Gibt den Sinus von x in Radiant zurück.

Domäne: (-INFINITY, INFINITY).
Wertebereich: [-1.0, 1.0].

Beispiele

sin(-PI)   # => -1.2246063538223773e-16 # -0.0000000000000001
sin(-PI/2) # => -1.0
sin(0.0)   # => 0.0
sin(PI/2)  # => 1.0
sin(PI)    # => 1.2246063538223773e-16  # 0.0000000000000001

sinh(x) → float

Source

static VALUE
math_sinh(VALUE unused_obj, VALUE x)
{
    return DBL2NUM(sinh(Get_Double(x)));
}

Gibt den hyperbolischen Sinus von x in Radiant zurück.

Domäne: [-INFINITY, INFINITY].
Wertebereich: [-INFINITY, INFINITY].

Beispiele

sinh(-INFINITY) # => -Infinity
sinh(0.0)       # => 0.0
sinh(INFINITY)  # => Infinity

sqrt(x) → float

Source

static VALUE
math_sqrt(VALUE unused_obj, VALUE x)
{
    return rb_math_sqrt(x);
}

Gibt die primäre (nicht-negative) Quadratwurzel von x zurück.

Domäne: [0, INFINITY].
Wertebereich: [0, INFINITY].

Beispiele

sqrt(0.0)      # => 0.0
sqrt(0.5)      # => 0.7071067811865476
sqrt(1.0)      # => 1.0
sqrt(2.0)      # => 1.4142135623730951
sqrt(4.0)      # => 2.0
sqrt(9.0)      # => 3.0
sqrt(INFINITY) # => Infinity

tan(x) → float

Source

static VALUE
math_tan(VALUE unused_obj, VALUE x)
{
    return DBL2NUM(tan(Get_Double(x)));
}

Gibt den Tangens von x in Radiant zurück.

Domäne: (-INFINITY, INFINITY).
Wertebereich: (-INFINITY, INFINITY).

Beispiele

tan(-PI)   # => 1.2246467991473532e-16  # -0.0000000000000001
tan(-PI/2) # => -1.633123935319537e+16  # -16331239353195370.0
tan(0.0)   # => 0.0
tan(PI/2)  # => 1.633123935319537e+16   # 16331239353195370.0
tan(PI)    # => -1.2246467991473532e-16 # -0.0000000000000001

tanh(x) → float

Source

static VALUE
math_tanh(VALUE unused_obj, VALUE x)
{
    return DBL2NUM(tanh(Get_Double(x)));
}

Gibt den hyperbolischen Tangens von x in Radiant zurück.

Domäne: [-INFINITY, INFINITY].
Wertebereich: [-1, 1].

Beispiele

tanh(-INFINITY) # => -1.0
tanh(0.0)       # => 0.0
tanh(INFINITY)  # => 1.0