class Float

Ein Float-Objekt speichert eine reelle Zahl unter Verwendung der Double-Precision-Gleitkommadarstellung der nativen Architektur.

Float-Ungenauigkeiten

Einige reelle Zahlen können als Float-Objekte präzise dargestellt werden.

37.5    # => 37.5
98.75   # => 98.75
12.3125 # => 12.3125

Andere nicht; darunter sind transzendente Zahlen, einschließlich

Pi, π: In der Mathematik eine Zahl unendlicher Präzision: 3.1415926535897932384626433... (auf 25 Stellen); in Ruby hat sie begrenzte Präzision (in diesem Fall auf 16 Dezimalstellen).
```
Math::PI # => 3.141592653589793
```
Eulersche Zahl, e: In der Mathematik eine Zahl unendlicher Präzision: 2.7182818284590452353602874... (auf 25 Stellen); in Ruby hat sie begrenzte Präzision (in diesem Fall auf 15 Dezimalstellen).
```
Math::E # => 2.718281828459045
```

Einige Gleitkomma-Berechnungen in Ruby ergeben präzise Ergebnisse.

1.0/2   # => 0.5
100.0/8 # => 12.5

Andere nicht.

In der Mathematik ist 2/3 als Dezimalzahl eine unendlich wiederholte Dezimalzahl: 0.666... (für immer); in Ruby hat 2.0/3 eine begrenzte Präzision (in diesem Fall auf 16 Dezimalstellen).
```
2.0/3 # => 0.6666666666666666
```
In der Mathematik ist die Quadratwurzel von 2 eine irrationale Zahl mit unendlicher Präzision: 1.4142135623730950488016887... (auf 25 Dezimalstellen); in Ruby hat sie begrenzte Präzision (in diesem Fall auf 16 Dezimalstellen).
```
Math.sqrt(2.0) # => 1.4142135623730951
```

Selbst eine einfache Berechnung kann Ungenauigkeiten einführen.

x = 0.1 + 0.2 # => 0.30000000000000004
y = 0.3       # => 0.3
x == y        # => false

Siehe

Beachten Sie, dass die präzise Speicherung und Berechnung von rationalen Zahlen mit Rational-Objekten möglich ist.

Erstellen eines Floats

Sie können ein Float-Objekt explizit mit

einem Gleitkomma-Literal erstellen.

Sie können bestimmte Objekte mit

der Methode Float in Floats konvertieren.

Was gibt es hier

Zuerst, was anderswo ist. Klasse Float

Erbt von Klasse Numeric und Klasse Object.
Enthält das Modul Comparable.

Hier bietet die Klasse Float Methoden zum

Abfragen

finite?: Gibt zurück, ob self endlich ist.
hash: Gibt den ganzzahligen Hash-Code für self zurück.
infinite?: Gibt zurück, ob self unendlich ist.
nan?: Gibt zurück, ob self NaN (Not-a-Number) ist.

Vergleichen

<: Gibt zurück, ob self kleiner als der gegebene Wert ist.
<=: Gibt zurück, ob self kleiner oder gleich dem gegebenen Wert ist.
<=>: Gibt eine Zahl zurück, die angibt, ob self kleiner, gleich oder größer als der gegebene Wert ist.
== (alias für === und eql?): Gibt zurück, ob self gleich dem gegebenen Wert ist.
>: Gibt zurück, ob self größer als der gegebene Wert ist.
>=: Gibt zurück, ob self größer oder gleich dem gegebenen Wert ist.

Konvertieren

% (alias für modulo): Gibt self modulo dem gegebenen Wert zurück.
*: Gibt das Produkt von self und dem gegebenen Wert zurück.
**: Gibt den Wert von self hoch dem gegebenen Wert zurück.
+: Gibt die Summe von self und dem gegebenen Wert zurück.
-: Gibt die Differenz von self und dem gegebenen Wert zurück.
/: Gibt den Quotienten von self und dem gegebenen Wert zurück.
ceil: Gibt die kleinste Zahl zurück, die größer oder gleich self ist.
coerce: Gibt ein 2-elementiges Array zurück, das den gegebenen Wert, konvertiert zu einem Float, und self enthält.
divmod: Gibt ein 2-elementiges Array zurück, das den Quotienten und den Rest der Division von self durch den gegebenen Wert enthält.
fdiv: Gibt das Float-Ergebnis der Division von self durch den gegebenen Wert zurück.
floor: Gibt die größte Zahl zurück, die kleiner oder gleich self ist.
next_float: Gibt den nächstgrößeren darstellbaren Float zurück.
prev_float: Gibt den nächstkleineren darstellbaren Float zurück.
quo: Gibt den Quotienten aus der Division von self durch den gegebenen Wert zurück.
round: Gibt self auf den nächstgelegenen Wert gerundet zurück, mit einer gegebenen Präzision.
to_i (alias für to_int): Gibt self als Integer gekürzt zurück.
to_s (alias für inspect): Gibt eine Zeichenkette mit der Stellenwertdarstellung von self in der gegebenen Basis zurück.
truncate: Gibt self mit einer gegebenen Präzision gekürzt zurück.

Constants

DIG

Die minimale Anzahl signifikanter Dezimalstellen in einer Double-Precision-Gleitkommazahl.

Standardmäßig normalerweise 15.

EPSILON

Die Differenz zwischen 1 und der kleinsten Double-Precision-Gleitkommazahl, die größer als 1 ist.

Standardmäßig normalerweise 2.2204460492503131e-16.

INFINITY

Ein Ausdruck, der positive Unendlichkeit darstellt.

MANT_DIG

Die Anzahl der Basis-Ziffern für den Datentyp double.

Standardmäßig normalerweise 53.

MAX

Die größte mögliche ganze Zahl in einer Double-Precision-Gleitkommazahl.

Standardmäßig normalerweise 1.7976931348623157e+308.

MAX_10_EXP

Der größte positive Exponent in einer Double-Precision-Gleitkommazahl, bei der 10 hoch diese Potenz minus 1.

Standardmäßig normalerweise 308.

MAX_EXP

Der größtmögliche Exponentenwert in einer Double-Precision-Gleitkommazahl.

Standardmäßig normalerweise 1024.

MIN

Die kleinste positive normalisierte Zahl in einer Double-Precision-Gleitkommazahl.

Standardmäßig normalerweise 2.2250738585072014e-308.

Wenn die Plattform denormalisierte Zahlen unterstützt, gibt es Zahlen zwischen Null und Float::MIN. 0.0.next_float gibt die kleinste positive Gleitkommazahl zurück, einschließlich denormalisierter Zahlen.

MIN_10_EXP

Der kleinste negative Exponent in einer Double-Precision-Gleitkommazahl, bei der 10 hoch diese Potenz minus 1.

Standardmäßig normalerweise -307.

MIN_EXP

Der kleinstmögliche Exponentenwert in einer Double-Precision-Gleitkommazahl.

Standardmäßig normalerweise -1021.

NAN

Ein Ausdruck, der einen Wert darstellt, der „keine Zahl“ ist.

RADIX

Die Basis der Gleitkommazahl oder die Anzahl der eindeutigen Ziffern, die zur Darstellung der Zahl verwendet werden.

Standardmäßig normalerweise 2 auf den meisten Systemen, was einer Basis-10-Dezimalzahl entsprechen würde.

Öffentliche Instanzmethoden

self % other → float

Source

static VALUE
flo_mod(VALUE x, VALUE y)
{
    double fy;

    if (FIXNUM_P(y)) {
        fy = (double)FIX2LONG(y);
    }
    else if (RB_BIGNUM_TYPE_P(y)) {
        fy = rb_big2dbl(y);
    }
    else if (RB_FLOAT_TYPE_P(y)) {
        fy = RFLOAT_VALUE(y);
    }
    else {
        return rb_num_coerce_bin(x, y, '%');
    }
    return DBL2NUM(ruby_float_mod(RFLOAT_VALUE(x), fy));
}

Gibt self modulo other als Float zurück.

Für einen Float f und eine reelle Zahl r sind diese Ausdrücke äquivalent.

f % r
f-r*(f/r).floor
f.divmod(r)[1]

Siehe Numeric#divmod.

Beispiele

10.0 % 2              # => 0.0
10.0 % 3              # => 1.0
10.0 % 4              # => 2.0

10.0 % -2             # => 0.0
10.0 % -3             # => -2.0
10.0 % -4             # => -2.0

10.0 % 4.0            # => 2.0
10.0 % Rational(4, 1) # => 2.0

Auch alias für: modulo

self * other → numeric

Source

VALUE
rb_float_mul(VALUE x, VALUE y)
{
    if (FIXNUM_P(y)) {
        return DBL2NUM(RFLOAT_VALUE(x) * (double)FIX2LONG(y));
    }
    else if (RB_BIGNUM_TYPE_P(y)) {
        return DBL2NUM(RFLOAT_VALUE(x) * rb_big2dbl(y));
    }
    else if (RB_FLOAT_TYPE_P(y)) {
        return DBL2NUM(RFLOAT_VALUE(x) * RFLOAT_VALUE(y));
    }
    else {
        return rb_num_coerce_bin(x, y, '*');
    }
}

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

f = 3.14
f * 2              # => 6.28
f * 2.0            # => 6.28
f * Rational(1, 2) # => 1.57
f * Complex(2, 0)  # => (6.28+0.0i)

self ** exponent → numeric

Source

VALUE
rb_float_pow(VALUE x, VALUE y)
{
    double dx, dy;
    if (y == INT2FIX(2)) {
        dx = RFLOAT_VALUE(x);
        return DBL2NUM(dx * dx);
    }
    else if (FIXNUM_P(y)) {
        dx = RFLOAT_VALUE(x);
        dy = (double)FIX2LONG(y);
    }
    else if (RB_BIGNUM_TYPE_P(y)) {
        dx = RFLOAT_VALUE(x);
        dy = rb_big2dbl(y);
    }
    else if (RB_FLOAT_TYPE_P(y)) {
        dx = RFLOAT_VALUE(x);
        dy = RFLOAT_VALUE(y);
        if (dx < 0 && dy != round(dy))
            return rb_dbl_complex_new_polar_pi(pow(-dx, dy), dy);
    }
    else {
        return rb_num_coerce_bin(x, y, idPow);
    }
    return DBL2NUM(pow(dx, dy));
}

Gibt self hoch exponent zurück.

f = 3.14
f ** 2              # => 9.8596
f ** -2             # => 0.1014239928597509
f ** 2.1            # => 11.054834900588839
f ** Rational(2, 1) # => 9.8596
f ** Complex(2, 0)  # => (9.8596+0i)

self + other → float or complex

Source

VALUE
rb_float_plus(VALUE x, VALUE y)
{
    if (FIXNUM_P(y)) {
        return DBL2NUM(RFLOAT_VALUE(x) + (double)FIX2LONG(y));
    }
    else if (RB_BIGNUM_TYPE_P(y)) {
        return DBL2NUM(RFLOAT_VALUE(x) + rb_big2dbl(y));
    }
    else if (RB_FLOAT_TYPE_P(y)) {
        return DBL2NUM(RFLOAT_VALUE(x) + RFLOAT_VALUE(y));
    }
    else {
        return rb_num_coerce_bin(x, y, '+');
    }
}

Gibt die Summe von self und other zurück; das Ergebnis kann ungenau sein (siehe Float).

3.14 + 0              # => 3.14
3.14 + 1              # => 4.140000000000001
-3.14 + 0             # => -3.14
-3.14 + 1             # => -2.14

3.14 + -3.14          # => 0.0
-3.14 + -3.14         # => -6.28

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

self - other → numeric

Source

VALUE
rb_float_minus(VALUE x, VALUE y)
{
    if (FIXNUM_P(y)) {
        return DBL2NUM(RFLOAT_VALUE(x) - (double)FIX2LONG(y));
    }
    else if (RB_BIGNUM_TYPE_P(y)) {
        return DBL2NUM(RFLOAT_VALUE(x) - rb_big2dbl(y));
    }
    else if (RB_FLOAT_TYPE_P(y)) {
        return DBL2NUM(RFLOAT_VALUE(x) - RFLOAT_VALUE(y));
    }
    else {
        return rb_num_coerce_bin(x, y, '-');
    }
}

Gibt die Differenz von self und other zurück.

f = 3.14
f - 1                 # => 2.14
f - 1.0               # => 2.14
f - Rational(1, 1)    # => 2.14
f - Complex(1, 0)     # => (2.14+0i)

-self → float

Source

# File numeric.rb, line 389
def -@
  Primitive.attr! :leaf
  Primitive.cexpr! 'rb_float_uminus(self)'
end

Gibt self, negiert, zurück.

-3.14    # => -3.14
-(-3.14) # => 3.14
-0.0     # => -0.0

self / other → numeric

Source

VALUE
rb_float_div(VALUE x, VALUE y)
{
    double num = RFLOAT_VALUE(x);
    double den;
    double ret;

    if (FIXNUM_P(y)) {
        den = FIX2LONG(y);
    }
    else if (RB_BIGNUM_TYPE_P(y)) {
        den = rb_big2dbl(y);
    }
    else if (RB_FLOAT_TYPE_P(y)) {
        den = RFLOAT_VALUE(y);
    }
    else {
        return rb_num_coerce_bin(x, y, '/');
    }

    ret = double_div_double(num, den);
    return DBL2NUM(ret);
}

Gibt den Quotienten von self und other zurück.

f = 3.14
f / 2              # => 1.57
f / 2.0            # => 1.57
f / Rational(2, 1) # => 1.57
f / Complex(2, 0)  # => (1.57+0.0i)

self < other → true or false

Source

static VALUE
flo_lt(VALUE x, VALUE y)
{
    double a, b;

    a = RFLOAT_VALUE(x);
    if (RB_INTEGER_TYPE_P(y)) {
        VALUE rel = rb_integer_float_cmp(y, x);
        if (FIXNUM_P(rel))
            return RBOOL(-FIX2LONG(rel) < 0);
        return Qfalse;
    }
    else if (RB_FLOAT_TYPE_P(y)) {
        b = RFLOAT_VALUE(y);
    }
    else {
        return rb_num_coerce_relop(x, y, '<');
    }
    return RBOOL(a < b);
}

Gibt zurück, ob der Wert von self kleiner ist als der Wert von other; other muss numerisch sein, darf aber kein Complex sein.

2.0 < 3              # => true
2.0 < 3.0            # => true
2.0 < Rational(3, 1) # => true
2.0 < 2.0            # => false

Float::NAN < Float::NAN gibt einen implementierungsabhängigen Wert zurück.

self <= other → true or false

Source

static VALUE
flo_le(VALUE x, VALUE y)
{
    double a, b;

    a = RFLOAT_VALUE(x);
    if (RB_INTEGER_TYPE_P(y)) {
        VALUE rel = rb_integer_float_cmp(y, x);
        if (FIXNUM_P(rel))
            return RBOOL(-FIX2LONG(rel) <= 0);
        return Qfalse;
    }
    else if (RB_FLOAT_TYPE_P(y)) {
        b = RFLOAT_VALUE(y);
    }
    else {
        return rb_num_coerce_relop(x, y, idLE);
    }
    return RBOOL(a <= b);
}

Gibt zurück, ob der Wert von self kleiner oder gleich dem Wert von other ist; other muss numerisch sein, darf aber kein Complex sein.

2.0 <= 3              # => true
2.0 <= 3.0            # => true
2.0 <= Rational(3, 1) # => true
2.0 <= 2.0            # => true
2.0 <= 1.0            # => false

Float::NAN <= Float::NAN gibt einen implementierungsabhängigen Wert zurück.

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

Source

static VALUE
flo_cmp(VALUE x, VALUE y)
{
    double a, b;
    VALUE i;

    a = RFLOAT_VALUE(x);
    if (isnan(a)) return Qnil;
    if (RB_INTEGER_TYPE_P(y)) {
        VALUE rel = rb_integer_float_cmp(y, x);
        if (FIXNUM_P(rel))
            return LONG2FIX(-FIX2LONG(rel));
        return rel;
    }
    else if (RB_FLOAT_TYPE_P(y)) {
        b = RFLOAT_VALUE(y);
    }
    else {
        if (isinf(a) && !UNDEF_P(i = rb_check_funcall(y, rb_intern("infinite?"), 0, 0))) {
            if (RTEST(i)) {
                int j = rb_cmpint(i, x, y);
                j = (a > 0.0) ? (j > 0 ? 0 : +1) : (j < 0 ? 0 : -1);
                return INT2FIX(j);
            }
            if (a > 0.0) return INT2FIX(1);
            return INT2FIX(-1);
        }
        return rb_num_coerce_cmp(x, y, id_cmp);
    }
    return rb_dbl_cmp(a, b);
}

Vergleicht self und other.

Gibt zurück

-1, wenn self kleiner als other ist.
0, wenn self gleich other ist.
1, wenn self größer als other ist.
nil, wenn die beiden Werte inkommensurabel sind.

Beispiele

2.0 <=> 2.1            # => -1
2.0 <=> 2              # => 0
2.0 <=> 2.0            # => 0
2.0 <=> Rational(2, 1) # => 0
2.0 <=> Complex(2, 0)  # => 0
2.0 <=> 1.9            # => 1
2.0 <=> 'foo'          # => nil

Float::NAN <=> Float::NAN gibt einen implementierungsabhängigen Wert zurück.

Die Klasse Float enthält das Modul Comparable, dessen Methoden Float#<=> zum Vergleichen verwenden.

self == other → true oder false

Source

VALUE
rb_float_equal(VALUE x, VALUE y)
{
    volatile double a, b;

    if (RB_INTEGER_TYPE_P(y)) {
        return rb_integer_float_eq(y, x);
    }
    else if (RB_FLOAT_TYPE_P(y)) {
        b = RFLOAT_VALUE(y);
    }
    else {
        return num_equal(x, y);
    }
    a = RFLOAT_VALUE(x);
    return RBOOL(a == b);
}

Gibt true zurück, wenn other denselben Wert wie self hat, andernfalls false.

2.0 == 2              # => true
2.0 == 2.0            # => true
2.0 == Rational(2, 1) # => true
2.0 == Complex(2, 0)  # => true

Float::NAN == Float::NAN gibt einen implementierungsabhängigen Wert zurück.

Verwandt: Float#eql? (erfordert, dass other ein Float ist).

Auch alias für: ===

===

Alias für: ==

self > other → true or false

Source

VALUE
rb_float_gt(VALUE x, VALUE y)
{
    double a, b;

    a = RFLOAT_VALUE(x);
    if (RB_INTEGER_TYPE_P(y)) {
        VALUE rel = rb_integer_float_cmp(y, x);
        if (FIXNUM_P(rel))
            return RBOOL(-FIX2LONG(rel) > 0);
        return Qfalse;
    }
    else if (RB_FLOAT_TYPE_P(y)) {
        b = RFLOAT_VALUE(y);
    }
    else {
        return rb_num_coerce_relop(x, y, '>');
    }
    return RBOOL(a > b);
}

Gibt true zurück, wenn self numerisch größer als other ist.

2.0 > 1              # => true
2.0 > 1.0            # => true
2.0 > Rational(1, 2) # => true
2.0 > 2.0            # => false

Float::NAN > Float::NAN gibt einen implementierungsabhängigen Wert zurück.

self >= other → true or false

Source

static VALUE
flo_ge(VALUE x, VALUE y)
{
    double a, b;

    a = RFLOAT_VALUE(x);
    if (RB_TYPE_P(y, T_FIXNUM) || RB_BIGNUM_TYPE_P(y)) {
        VALUE rel = rb_integer_float_cmp(y, x);
        if (FIXNUM_P(rel))
            return RBOOL(-FIX2LONG(rel) >= 0);
        return Qfalse;
    }
    else if (RB_FLOAT_TYPE_P(y)) {
        b = RFLOAT_VALUE(y);
    }
    else {
        return rb_num_coerce_relop(x, y, idGE);
    }
    return RBOOL(a >= b);
}

Gibt true zurück, wenn self numerisch größer oder gleich other ist.

2.0 >= 1              # => true
2.0 >= 1.0            # => true
2.0 >= Rational(1, 2) # => true
2.0 >= 2.0            # => true
2.0 >= 2.1            # => false

Float::NAN >= Float::NAN gibt einen implementierungsabhängigen Wert zurück.

abs → float

Source

# File numeric.rb, line 373
def abs
  Primitive.attr! :leaf
  Primitive.cexpr! 'rb_float_abs(self)'
end

Gibt den Absolutwert von self zurück.

(-34.56).abs # => 34.56
-34.56.abs   # => 34.56
34.56.abs    # => 34.56

Auch alias für: magnitude

angle

Alias für: arg

arg → 0 or Math::PI

Source

static VALUE
float_arg(VALUE self)
{
    if (isnan(RFLOAT_VALUE(self)))
        return self;
    if (f_tpositive_p(self))
        return INT2FIX(0);
    return rb_const_get(rb_mMath, id_PI);
}

Gibt 0 zurück, wenn self positiv ist, andernfalls Math::PI.

Auch alias für: angle, phase

ceil(ndigits = 0) → float or integer

Source

static VALUE
flo_ceil(int argc, VALUE *argv, VALUE num)
{
    int ndigits = flo_ndigits(argc, argv);
    return rb_float_ceil(num, ndigits);
}

Gibt eine Zahl zurück, die ein "Deckenwert" für self ist, wie durch das gegebene ndigits angegeben, welches ein integer-konvertierbares Objekt sein muss.

Wenn ndigits positiv ist, gibt es einen Float mit ndigits Dezimalstellen nach dem Dezimalpunkt zurück (sofern verfügbar, aber nicht weniger als 1).

f = 12345.6789
f.ceil(1) # => 12345.7
f.ceil(3) # => 12345.679
f.ceil(30) # => 12345.6789
f = -12345.6789
f.ceil(1) # => -12345.6
f.ceil(3) # => -12345.678
f.ceil(30) # => -12345.6789
f = 0.0
f.ceil(1)   # => 0.0
f.ceil(100) # => 0.0

Wenn ndigits nicht-positiv ist, gibt es einen Integer zurück, der auf einer berechneten Granularität basiert.

Die Granularität ist 10 ** ndigits.abs.
Der zurückgegebene Wert ist das größte Vielfache der Granularität, das kleiner oder gleich self ist.

Beispiele mit positivem self

ndigits	Granularität	12345.6789.ceil(ndigits)
0	1	12346
-1	10	12350
-2	100	12400
-3	1000	13000
-4	10000	20000
-5	100000	100000

Beispiele mit negativem self

ndigits	Granularität	-12345.6789.ceil(ndigits)
0	1	-12345
-1	10	-12340
-2	100	-12300
-3	1000	-12000
-4	10000	-10000
-5	100000	0

Wenn self Null ist und ndigits nicht-positiv ist, gibt es eine Integer-Null zurück.

0.0.ceil(0)  # => 0
0.0.ceil(-1) # => 0
0.0.ceil(-2) # => 0

Beachten Sie, dass die begrenzte Präzision der Gleitkomma-Arithmetik zu überraschenden Ergebnissen führen kann.

(2.1 / 0.7).ceil  #=> 4 # Not 3 (because 2.1 / 0.7 # => 3.0000000000000004, not 3.0)

Verwandt: Float#floor.

coerce(other) → array

Source

static VALUE
flo_coerce(VALUE x, VALUE y)
{
    return rb_assoc_new(rb_Float(y), x);
}

Gibt ein 2-elementiges Array zurück, das other, konvertiert zu einem Float, und self enthält.

f = 3.14                 # => 3.14
f.coerce(2)              # => [2.0, 3.14]
f.coerce(2.0)            # => [2.0, 3.14]
f.coerce(Rational(1, 2)) # => [0.5, 3.14]
f.coerce(Complex(1, 0))  # => [1.0, 3.14]

Löst eine Ausnahme aus, wenn eine Typkonvertierung fehlschlägt.

denominator → integer

Source

VALUE
rb_float_denominator(VALUE self)
{
    double d = RFLOAT_VALUE(self);
    VALUE r;
    if (!isfinite(d))
        return INT2FIX(1);
    r = float_to_r(self);
    return nurat_denominator(r);
}

Gibt den Nenner zurück (immer positiv). Das Ergebnis ist maschinenabhängig.

Siehe auch Float#numerator.

divmod(other) → array

Source

static VALUE
flo_divmod(VALUE x, VALUE y)
{
    double fy, div, mod;
    volatile VALUE a, b;

    if (FIXNUM_P(y)) {
        fy = (double)FIX2LONG(y);
    }
    else if (RB_BIGNUM_TYPE_P(y)) {
        fy = rb_big2dbl(y);
    }
    else if (RB_FLOAT_TYPE_P(y)) {
        fy = RFLOAT_VALUE(y);
    }
    else {
        return rb_num_coerce_bin(x, y, id_divmod);
    }
    flodivmod(RFLOAT_VALUE(x), fy, &div, &mod);
    a = dbl2ival(div);
    b = DBL2NUM(mod);
    return rb_assoc_new(a, b);
}

Gibt ein 2-elementiges Array [q, r] zurück, wobei

q = (self/other).floor      # Quotient
r = self % other            # Remainder

Beispiele

11.0.divmod(4)              # => [2, 3.0]
11.0.divmod(-4)             # => [-3, -1.0]
-11.0.divmod(4)             # => [-3, 1.0]
-11.0.divmod(-4)            # => [2, -3.0]

12.0.divmod(4)              # => [3, 0.0]
12.0.divmod(-4)             # => [-3, 0.0]
-12.0.divmod(4)             # => [-3, -0.0]
-12.0.divmod(-4)            # => [3, -0.0]

13.0.divmod(4.0)            # => [3, 1.0]
13.0.divmod(Rational(4, 1)) # => [3, 1.0]

eql?(other) → true oder false

Source

VALUE
rb_float_eql(VALUE x, VALUE y)
{
    if (RB_FLOAT_TYPE_P(y)) {
        double a = RFLOAT_VALUE(x);
        double b = RFLOAT_VALUE(y);
        return RBOOL(a == b);
    }
    return Qfalse;
}

Gibt true zurück, wenn other ein Float mit demselben Wert wie self ist, andernfalls false.

2.0.eql?(2.0)            # => true
2.0.eql?(1.0)            # => false
2.0.eql?(1)              # => false
2.0.eql?(Rational(2, 1)) # => false
2.0.eql?(Complex(2, 0))  # => false

Float::NAN.eql?(Float::NAN) gibt einen implementierungsabhängigen Wert zurück.

Verwandt: Float#== (führt Typkonvertierungen durch).

fdiv

Alias für: quo

finite? → true or false

Source

VALUE
rb_flo_is_finite_p(VALUE num)
{
    double value = RFLOAT_VALUE(num);

    return RBOOL(isfinite(value));
}

Gibt true zurück, wenn self nicht Infinity, -Infinity oder NaN ist, andernfalls false.

f = 2.0      # => 2.0
f.finite?    # => true
f = 1.0/0.0  # => Infinity
f.finite?    # => false
f = -1.0/0.0 # => -Infinity
f.finite?    # => false
f = 0.0/0.0  # => NaN
f.finite?    # => false

floor(ndigits = 0) → float or integer

Source

static VALUE
flo_floor(int argc, VALUE *argv, VALUE num)
{
    int ndigits = flo_ndigits(argc, argv);
    return rb_float_floor(num, ndigits);
}

Gibt einen Float oder Integer zurück, der ein "Bodenwert" für self ist, wie durch ndigits angegeben, welches ein integer-konvertierbares Objekt sein muss.

Wenn self Null ist, wird ein Nullwert zurückgegeben: ein Float, wenn ndigits positiv ist, andernfalls ein Integer.

f = 0.0      # => 0.0
f.floor(20)  # => 0.0
f.floor(0)   # => 0
f.floor(-20) # => 0

Wenn self nicht-Null ist und ndigits positiv ist, wird ein Float mit ndigits Stellen nach dem Dezimalpunkt zurückgegeben (sofern verfügbar).

f = 12345.6789
f.floor(1)  # => 12345.6
f.floor(3)  # => 12345.678
f.floor(30) # => 12345.6789
f = -12345.6789
f.floor(1)  # => -12345.7
f.floor(3)  # => -12345.679
f.floor(30) # => -12345.6789

Wenn self nicht-Null ist und ndigits nicht-positiv ist, wird ein Integerwert zurückgegeben, der auf einer berechneten Granularität basiert.

Die Granularität ist 10 ** ndigits.abs.
Der zurückgegebene Wert ist das größte Vielfache der Granularität, das kleiner oder gleich self ist.

Beispiele mit positivem self

ndigits	Granularität	12345.6789.floor(ndigits)
0	1	12345
-1	10	12340
-2	100	12300
-3	1000	12000
-4	10000	10000
-5	100000	0

Beispiele mit negativem self

ndigits	Granularität	-12345.6789.floor(ndigits)
0	1	-12346
-1	10	-12350
-2	100	-12400
-3	1000	-13000
-4	10000	-20000
-5	100000	-100000
-6	1000000	-1000000

Beachten Sie, dass die begrenzte Präzision der Gleitkomma-Arithmetik zu überraschenden Ergebnissen führen kann.

(0.3 / 0.1).floor  # => 2 # Not 3, (because (0.3 / 0.1) # => 2.9999999999999996, not 3.0)

Verwandt: Float#ceil.

hash → integer

Source

static VALUE
flo_hash(VALUE num)
{
    return rb_dbl_hash(RFLOAT_VALUE(num));
}

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

Siehe auch Object#hash.

infinite? → -1, 1, or nil

Source

VALUE
rb_flo_is_infinite_p(VALUE num)
{
    double value = RFLOAT_VALUE(num);

    if (isinf(value)) {
        return INT2FIX( value < 0 ? -1 : 1 );
    }

    return Qnil;
}

Gibt zurück

1, wenn self Infinity ist.
-1, wenn self -Infinity ist.
nil, andernfalls.

Beispiele

f = 1.0/0.0  # => Infinity
f.infinite?  # => 1
f = -1.0/0.0 # => -Infinity
f.infinite?  # => -1
f = 1.0      # => 1.0
f.infinite?  # => nil
f = 0.0/0.0  # => NaN
f.infinite?  # => nil

inspect

Alias für: to_s

magnitude

Alias für: abs

modulo

Alias für: %

nan? → true or false

Source

static VALUE
flo_is_nan_p(VALUE num)
{
    double value = RFLOAT_VALUE(num);

    return RBOOL(isnan(value));
}

Gibt true zurück, wenn self NaN ist, andernfalls false.

f = -1.0     #=> -1.0
f.nan?       #=> false
f = 0.0/0.0  #=> NaN
f.nan?       #=> true

negative? → true or false

Source

# File numeric.rb, line 416
def negative?
  Primitive.attr! :leaf
  Primitive.cexpr! 'RBOOL(RFLOAT_VALUE(self) < 0.0)'
end

Gibt true zurück, wenn self kleiner als 0 ist, andernfalls false.

next_float → float

Source

static VALUE
flo_next_float(VALUE vx)
{
    return flo_nextafter(vx, HUGE_VAL);
}

Gibt den nächstgrößeren darstellbaren Float zurück.

Diese Beispiele zeigen die intern gespeicherten Werte (64-Bit Hexadezimal) für jeden Float f und für den entsprechenden f.next_float.

f = 0.0      # 0x0000000000000000
f.next_float # 0x0000000000000001

f = 0.01     # 0x3f847ae147ae147b
f.next_float # 0x3f847ae147ae147c

In den übrigen Beispielen hier wird die Ausgabe auf die übliche Weise gezeigt (Ergebnis to_s).

0.01.next_float    # => 0.010000000000000002
1.0.next_float     # => 1.0000000000000002
100.0.next_float   # => 100.00000000000001

f = 0.01
(0..3).each_with_index {|i| printf "%2d %-20a %s\n", i, f, f.to_s; f = f.next_float }

Ausgabe

 0 0x1.47ae147ae147bp-7 0.01
 1 0x1.47ae147ae147cp-7 0.010000000000000002
 2 0x1.47ae147ae147dp-7 0.010000000000000004
 3 0x1.47ae147ae147ep-7 0.010000000000000005

f = 0.0; 100.times { f += 0.1 }
f                           # => 9.99999999999998       # should be 10.0 in the ideal world.
10-f                        # => 1.9539925233402755e-14 # the floating point error.
10.0.next_float-10          # => 1.7763568394002505e-15 # 1 ulp (unit in the last place).
(10-f)/(10.0.next_float-10) # => 11.0                   # the error is 11 ulp.
(10-f)/(10*Float::EPSILON)  # => 8.8                    # approximation of the above.
"%a" % 10                   # => "0x1.4p+3"
"%a" % f                    # => "0x1.3fffffffffff5p+3" # the last hex digit is 5.  16 - 5 = 11 ulp.

Verwandt: Float#prev_float

numerator → integer

Source

VALUE
rb_float_numerator(VALUE self)
{
    double d = RFLOAT_VALUE(self);
    VALUE r;
    if (!isfinite(d))
        return self;
    r = float_to_r(self);
    return nurat_numerator(r);
}

Gibt den Zähler zurück. Das Ergebnis ist maschinenabhängig.

n = 0.3.numerator    #=> 5404319552844595
d = 0.3.denominator  #=> 18014398509481984
n.fdiv(d)            #=> 0.3

Siehe auch Float#denominator.

phase

Alias für: arg

positive? → true or false

Source

# File numeric.rb, line 407
def positive?
  Primitive.attr! :leaf
  Primitive.cexpr! 'RBOOL(RFLOAT_VALUE(self) > 0.0)'
end

Gibt true zurück, wenn self größer als 0 ist, andernfalls false.

prev_float → float

Source

static VALUE
flo_prev_float(VALUE vx)
{
    return flo_nextafter(vx, -HUGE_VAL);
}

Gibt den nächstkleineren darstellbaren Float zurück.

Diese Beispiele zeigen die intern gespeicherten Werte (64-Bit Hexadezimal) für jeden Float f und für den entsprechenden f.pev_float.

f = 5e-324   # 0x0000000000000001
f.prev_float # 0x0000000000000000

f = 0.01     # 0x3f847ae147ae147b
f.prev_float # 0x3f847ae147ae147a

In den übrigen Beispielen hier wird die Ausgabe auf die übliche Weise gezeigt (Ergebnis to_s).

0.01.prev_float   # => 0.009999999999999998
1.0.prev_float    # => 0.9999999999999999
100.0.prev_float  # => 99.99999999999999

f = 0.01
(0..3).each_with_index {|i| printf "%2d %-20a %s\n", i, f, f.to_s; f = f.prev_float }

Ausgabe

0 0x1.47ae147ae147bp-7 0.01
1 0x1.47ae147ae147ap-7 0.009999999999999998
2 0x1.47ae147ae1479p-7 0.009999999999999997
3 0x1.47ae147ae1478p-7 0.009999999999999995

Verwandt: Float#next_float.

quo(other) → numeric

Source

static VALUE
flo_quo(VALUE x, VALUE y)
{
    return num_funcall1(x, '/', y);
}

Gibt den Quotienten aus der Division von self durch other zurück.

f = 3.14
f.quo(2)              # => 1.57
f.quo(-2)             # => -1.57
f.quo(Rational(2, 1)) # => 1.57
f.quo(Complex(2, 0))  # => (1.57+0.0i)

Auch alias für: fdiv

rationalize([eps]) → rational

Source

static VALUE
float_rationalize(int argc, VALUE *argv, VALUE self)
{
    double d = RFLOAT_VALUE(self);
    VALUE rat;
    int neg = d < 0.0;
    if (neg) self = DBL2NUM(-d);

    if (rb_check_arity(argc, 0, 1)) {
        rat = rb_flt_rationalize_with_prec(self, argv[0]);
    }
    else {
        rat = rb_flt_rationalize(self);
    }
    if (neg) RATIONAL_SET_NUM(rat, rb_int_uminus(RRATIONAL(rat)->num));
    return rat;
}

Gibt eine einfachere Annäherung des Wertes zurück (flt-|eps| <= Ergebnis <= flt+|eps|). Wenn das optionale Argument eps nicht angegeben wird, wird es automatisch gewählt.

0.3.rationalize          #=> (3/10)
1.333.rationalize        #=> (1333/1000)
1.333.rationalize(0.01)  #=> (4/3)

Siehe auch Float#to_r.

round(ndigits = 0, half: :up) → integer or float

Source

static VALUE
flo_round(int argc, VALUE *argv, VALUE num)
{
    double number, f, x;
    VALUE nd, opt;
    int ndigits = 0;
    enum ruby_num_rounding_mode mode;

    if (rb_scan_args(argc, argv, "01:", &nd, &opt)) {
        ndigits = NUM2INT(nd);
    }
    mode = rb_num_get_rounding_option(opt);
    number = RFLOAT_VALUE(num);
    if (number == 0.0) {
        return ndigits > 0 ? DBL2NUM(number) : INT2FIX(0);
    }
    if (ndigits < 0) {
        return rb_int_round(flo_to_i(num), ndigits, mode);
    }
    if (ndigits == 0) {
        x = ROUND_CALL(mode, round, (number, 1.0));
        return dbl2ival(x);
    }
    if (isfinite(number)) {
        int binexp;
        frexp(number, &binexp);
        if (float_round_overflow(ndigits, binexp)) return num;
        if (float_round_underflow(ndigits, binexp)) return DBL2NUM(0);
        if (ndigits > 14) {
            /* In this case, pow(10, ndigits) may not be accurate. */
            return rb_flo_round_by_rational(argc, argv, num);
        }
        f = pow(10, ndigits);
        x = ROUND_CALL(mode, round, (number, f));
        return DBL2NUM(x / f);
    }
    return num;
}

Gibt self gerundet auf den nächstgelegenen Wert mit einer Präzision von ndigits Dezimalstellen zurück.

Wenn ndigits nicht-negativ ist, wird ein Float mit ndigits Stellen nach dem Dezimalpunkt zurückgegeben (sofern verfügbar).

f = 12345.6789
f.round(1) # => 12345.7
f.round(3) # => 12345.679
f = -12345.6789
f.round(1) # => -12345.7
f.round(3) # => -12345.679

Wenn ndigits negativ ist, wird ein Integer mit mindestens ndigits.abs Nullen am Ende zurückgegeben.

f = 12345.6789
f.round(0)  # => 12346
f.round(-3) # => 12000
f = -12345.6789
f.round(0)  # => -12346
f.round(-3) # => -12000

Wenn das Schlüsselwortargument half gegeben ist und self von den beiden Kandidatenwerten gleich weit entfernt ist, wird die Rundung gemäß dem gegebenen half-Wert vorgenommen.

:up oder nil: Rundung weg von Null.

2.5.round(half: :up)      # => 3
3.5.round(half: :up)      # => 4
(-2.5).round(half: :up)   # => -3

:down: Rundung zur Null hin.

2.5.round(half: :down)    # => 2
3.5.round(half: :down)    # => 3
(-2.5).round(half: :down) # => -2

:even: Rundung zur Kandidatin mit der geraden letzten Nicht-Null-Ziffer.

2.5.round(half: :even)    # => 2
3.5.round(half: :even)    # => 4
(-2.5).round(half: :even) # => -2

Löst eine Ausnahme aus, wenn der Wert für half ungültig ist.

Verwandt: Float#truncate.

to_f → self

Source

# File numeric.rb, line 360
def to_f
  self
end

Gibt self zurück (welches bereits ein Float ist).

to_i → integer

Source

static VALUE
flo_to_i(VALUE num)
{
    double f = RFLOAT_VALUE(num);

    if (f > 0.0) f = floor(f);
    if (f < 0.0) f = ceil(f);

    return dbl2ival(f);
}

Gibt self als Integer gekürzt zurück.

1.2.to_i    # => 1
(-1.2).to_i # => -1

Beachten Sie, dass die begrenzte Präzision der Gleitkomma-Arithmetik zu überraschenden Ergebnissen führen kann.

(0.3 / 0.1).to_i  # => 2 (!)

Auch alias für: to_int

to_int

Alias für: to_i

to_r → rational

Source

static VALUE
float_to_r(VALUE self)
{
    VALUE f;
    int n;

    float_decode_internal(self, &f, &n);
#if FLT_RADIX == 2
    if (n == 0)
        return rb_rational_new1(f);
    if (n > 0)
        return rb_rational_new1(rb_int_lshift(f, INT2FIX(n)));
    n = -n;
    return rb_rational_new2(f, rb_int_lshift(ONE, INT2FIX(n)));
#else
    f = rb_int_mul(f, rb_int_pow(INT2FIX(FLT_RADIX), n));
    if (RB_TYPE_P(f, T_RATIONAL))
        return f;
    return rb_rational_new1(f);
#endif
}

Gibt den Wert als rationale Zahl zurück.

2.0.to_r    #=> (2/1)
2.5.to_r    #=> (5/2)
-0.75.to_r  #=> (-3/4)
0.0.to_r    #=> (0/1)
0.3.to_r    #=> (5404319552844595/18014398509481984)

HINWEIS: 0.3.to_r ist nicht dasselbe wie „0.3“.to_r. Letzteres ist äquivalent zu „3/10“.to_r, aber das erstere nicht.

0.3.to_r   == 3/10r  #=> false
"0.3".to_r == 3/10r  #=> true

Siehe auch Float#rationalize.

to_s → String

Source

static VALUE
flo_to_s(VALUE flt)
{
    enum {decimal_mant = DBL_MANT_DIG-DBL_DIG};
    enum {float_dig = DBL_DIG+1};
    char buf[float_dig + roomof(decimal_mant, CHAR_BIT) + 10];
    double value = RFLOAT_VALUE(flt);
    VALUE s;
    char *p, *e;
    int sign, decpt, digs;

    if (isinf(value)) {
        static const char minf[] = "-Infinity";
        const int pos = (value > 0); /* skip "-" */
        return rb_usascii_str_new(minf+pos, strlen(minf)-pos);
    }
    else if (isnan(value))
        return rb_usascii_str_new2("NaN");

    p = ruby_dtoa(value, 0, 0, &decpt, &sign, &e);
    s = sign ? rb_usascii_str_new_cstr("-") : rb_usascii_str_new(0, 0);
    if ((digs = (int)(e - p)) >= (int)sizeof(buf)) digs = (int)sizeof(buf) - 1;
    memcpy(buf, p, digs);
    free(p);
    if (decpt > 0) {
        if (decpt < digs) {
            memmove(buf + decpt + 1, buf + decpt, digs - decpt);
            buf[decpt] = '.';
            rb_str_cat(s, buf, digs + 1);
        }
        else if (decpt <= DBL_DIG) {
            long len;
            char *ptr;
            rb_str_cat(s, buf, digs);
            rb_str_resize(s, (len = RSTRING_LEN(s)) + decpt - digs + 2);
            ptr = RSTRING_PTR(s) + len;
            if (decpt > digs) {
                memset(ptr, '0', decpt - digs);
                ptr += decpt - digs;
            }
            memcpy(ptr, ".0", 2);
        }
        else {
            goto exp;
        }
    }
    else if (decpt > -4) {
        long len;
        char *ptr;
        rb_str_cat(s, "0.", 2);
        rb_str_resize(s, (len = RSTRING_LEN(s)) - decpt + digs);
        ptr = RSTRING_PTR(s);
        memset(ptr += len, '0', -decpt);
        memcpy(ptr -= decpt, buf, digs);
    }
    else {
        goto exp;
    }
    return s;

  exp:
    if (digs > 1) {
        memmove(buf + 2, buf + 1, digs - 1);
    }
    else {
        buf[2] = '0';
        digs++;
    }
    buf[1] = '.';
    rb_str_cat(s, buf, digs + 1);
    rb_str_catf(s, "e%+03d", decpt - 1);
    return s;
}

Gibt eine Zeichenkette zurück, die eine Darstellung von self enthält; abhängig vom Wert von self kann die Zeichenkettendarstellung enthalten:

Eine Festkommazahl.
```
3.14.to_s         # => "3.14"
```
Eine Zahl in „wissenschaftlicher Notation“ (die einen Exponenten enthält).
```
(10.1**50).to_s   # => "1.644631821843879e+50"
```
„Infinity“.
```
(10.1**500).to_s  # => "Infinity"
```
„-Infinity“.
```
(-10.1**500).to_s # => "-Infinity"
```
„NaN“ (was für Not-a-Number steht).
```
(0.0/0.0).to_s    # => "NaN"
```

Auch alias für: inspect

truncate(ndigits = 0) → float or integer

Source

static VALUE
flo_truncate(int argc, VALUE *argv, VALUE num)
{
    if (signbit(RFLOAT_VALUE(num)))
        return flo_ceil(argc, argv, num);
    else
        return flo_floor(argc, argv, num);
}

Gibt self (gegen Null gekürzt) mit einer Präzision von ndigits Dezimalstellen zurück.

Wenn ndigits positiv ist, wird ein Float mit ndigits Stellen nach dem Dezimalpunkt zurückgegeben (sofern verfügbar).

f = 12345.6789
f.truncate(1) # => 12345.6
f.truncate(3) # => 12345.678
f = -12345.6789
f.truncate(1) # => -12345.6
f.truncate(3) # => -12345.678

Wenn ndigits negativ ist, wird ein Integer mit mindestens ndigits.abs Nullen am Ende zurückgegeben.

f = 12345.6789
f.truncate(0)  # => 12345
f.truncate(-3) # => 12000
f = -12345.6789
f.truncate(0)  # => -12345
f.truncate(-3) # => -12000

Beachten Sie, dass die begrenzte Präzision der Gleitkomma-Arithmetik zu überraschenden Ergebnissen führen kann.

(0.3 / 0.1).truncate  #=> 2 (!)

Verwandt: Float#round.

zero? → true or false

Source

# File numeric.rb, line 398
def zero?
  Primitive.attr! :leaf
  Primitive.cexpr! 'RBOOL(FLOAT_ZERO_P(self))'
end

Gibt true zurück, wenn self 0.0 ist, andernfalls false.