class Integer

Ein Integer-Objekt repräsentiert einen Ganzzahlwert.

Sie können ein Integer-Objekt explizit mit

einem Ganzzahl-Literal erstellen.

Sie können bestimmte Objekte mit

der Methode Integer in Integer konvertieren.

Der Versuch, eine Singleton-Methode zu einer Instanz dieser Klasse hinzuzufügen, löst eine Ausnahme aus.

Was gibt es hier

Zuerst, was anderswo ist. Klasse Integer

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

Hier bietet die Klasse Integer Methoden für

Abfragen

allbits?: Gibt zurück, ob alle Bits in self gesetzt sind.
anybits?: Gibt zurück, ob irgendwelche Bits in self gesetzt sind.
nobits?: Gibt zurück, ob keine Bits in self gesetzt sind.

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 ===): Gibt zurück, ob self gleich dem gegebenen
```
value.
```
>: 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

::sqrt: Gibt die ganzzahlige Quadratwurzel des gegebenen Wertes zurück.
::try_convert: Gibt den gegebenen Wert, konvertiert in einen Integer, zurück.
% (alias für modulo): Gibt self modulo des gegebenen Wertes zurück.
&: Gibt das bitweise UND von self und dem gegebenen Wert zurück.
*: Gibt das Produkt von self und dem gegebenen Wert zurück.
**: Gibt den Wert von self potenziert mit 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.
<<: Gibt den Wert von self nach einer Links-Bitverschiebung zurück.
>>: Gibt den Wert von self nach einer Rechts-Bitverschiebung zurück.
[]: Gibt einen Bit-Slice aus self zurück.
^: Gibt das bitweise EXKLUSIV-ODER von self und dem gegebenen Wert zurück.
|: Gibt das bitweise ODER von self und dem gegebenen Wert zurück.
ceil: Gibt die kleinste Zahl zurück, die größer oder gleich self ist.
chr: Gibt einen 1-Zeichen-String zurück, der das durch den Wert von self dargestellte Zeichen enthält.
digits: Gibt ein Array von Integern zurück, die die Ziffern von self in der Basis-radix darstellen.
div: Gibt das ganzzahlige Ergebnis der Division von self durch den gegebenen Wert zurück.
divmod: Gibt ein 2-Element-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.
pow: Gibt die modulare Potenzierung von self zurück.
pred: Gibt den Vorgänger von self zurück.
remainder: Gibt den Rest nach der Division von self durch den gegebenen Wert zurück.
round: Gibt self gerundet auf den nächstgelegenen Wert mit der gegebenen Präzision zurück.
succ (alias für next): Gibt den Nachfolger von self zurück.
to_f: Gibt self, konvertiert in einen Float, zurück.
to_s (alias für inspect): Gibt einen String zurück, der die Stellenwertdarstellung von self in der gegebenen Basis enthält.
truncate: Gibt self, abgeschnitten auf die gegebene Präzision, zurück.

Sonstiges

downto: Ruft den gegebenen Block mit jedem Ganzzahlwert von self abwärts bis zum gegebenen Wert auf.
times: Ruft den gegebenen Block self mal mit jeder Ganzzahl in (0..self-1) auf.
upto: Ruft den gegebenen Block mit jedem Ganzzahlwert von self aufwärts bis zum gegebenen Wert auf.

Constants

GMP_VERSION: Die Version des geladenen GMP.

Öffentliche Klassenmethoden

sqrt(numeric) → integer

Source

static VALUE
rb_int_s_isqrt(VALUE self, VALUE num)
{
    unsigned long n, sq;
    num = rb_to_int(num);
    if (FIXNUM_P(num)) {
        if (FIXNUM_NEGATIVE_P(num)) {
            domain_error("isqrt");
        }
        n = FIX2ULONG(num);
        sq = rb_ulong_isqrt(n);
        return LONG2FIX(sq);
    }
    else {
        size_t biglen;
        if (RBIGNUM_NEGATIVE_P(num)) {
            domain_error("isqrt");
        }
        biglen = BIGNUM_LEN(num);
        if (biglen == 0) return INT2FIX(0);
#if SIZEOF_BDIGIT <= SIZEOF_LONG
        /* short-circuit */
        if (biglen == 1) {
            n = BIGNUM_DIGITS(num)[0];
            sq = rb_ulong_isqrt(n);
            return ULONG2NUM(sq);
        }
#endif
        return rb_big_isqrt(num);
    }
}

Gibt die ganzzahlige Quadratwurzel der nicht-negativen Ganzzahl n zurück, was die größte nicht-negative Ganzzahl ist, die kleiner oder gleich der Quadratwurzel von numeric ist.

Integer.sqrt(0)       # => 0
Integer.sqrt(1)       # => 1
Integer.sqrt(24)      # => 4
Integer.sqrt(25)      # => 5
Integer.sqrt(10**400) # => 10**200

Wenn numeric keine Ganzzahl ist, wird es in eine Ganzzahl konvertiert.

Integer.sqrt(Complex(4, 0))  # => 2
Integer.sqrt(Rational(4, 1)) # => 2
Integer.sqrt(4.0)            # => 2
Integer.sqrt(3.14159)        # => 1

Diese Methode ist äquivalent zu Math.sqrt(numeric).floor, außer dass das Ergebnis des letzteren Codes aufgrund der begrenzten Genauigkeit der Gleitkomma-Arithmetik vom wahren Wert abweichen kann.

Integer.sqrt(10**46)    # => 100000000000000000000000
Math.sqrt(10**46).floor # => 99999999999999991611392

Löst eine Ausnahme aus, wenn numeric negativ ist.

try_convert(object) → object, integer, or nil

Source

static VALUE
int_s_try_convert(VALUE self, VALUE num)
{
    return rb_check_integer_type(num);
}

Wenn object ein Integer-Objekt ist, gibt object zurück.

Integer.try_convert(1) # => 1

Andernfalls, wenn object auf :to_int reagiert, wird object.to_int aufgerufen und das Ergebnis zurückgegeben.

Integer.try_convert(1.25) # => 1

Gibt nil zurück, wenn object nicht auf :to_int reagiert.

Integer.try_convert([]) # => nil

Löst eine Ausnahme aus, es sei denn, object.to_int gibt ein Integer-Objekt zurück.

Öffentliche Instanzmethoden

self % other → real_numeric

Source

VALUE
rb_int_modulo(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_mod(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_modulo(x, y);
    }
    return num_modulo(x, y);
}

Gibt self modulo other als reelle Zahl (Integer, Float oder Rational) zurück.

Für die Ganzzahl n und die reelle Zahl r sind diese Ausdrücke äquivalent

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

Siehe Numeric#divmod.

Beispiele

10 % 2              # => 0
10 % 3              # => 1
10 % 4              # => 2

10 % -2             # => 0
10 % -3             # => -2
10 % -4             # => -2

10 % 3.0            # => 1.0
10 % Rational(3, 1) # => (1/1)

Auch alias für: modulo

self & other → integer

Source

VALUE
rb_int_and(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_and(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_and(x, y);
    }
    return Qnil;
}

Bitweises UND; jedes Bit im Ergebnis ist 1, wenn beide entsprechenden Bits in self und other 1 sind, andernfalls 0.

"%04b" % (0b0101 & 0b0110) # => "0100"

Löst eine Ausnahme aus, wenn other keine Ganzzahl ist.

Zugehörig: Integer#| (bitweises ODER), Integer#^ (bitweises EXKLUSIV-ODER).

self * other → numeric

Source

VALUE
rb_int_mul(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_mul(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_mul(x, y);
    }
    return rb_num_coerce_bin(x, y, '*');
}

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

4 * 2              # => 8
-4 * 2             # => -8
4 * -2             # => -8
4 * 2.0            # => 8.0
4 * Rational(1, 3) # => (4/3)
4 * Complex(2, 0)  # => (8+0i)

self ** exponent → numeric

Source

VALUE
rb_int_pow(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_pow(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_pow(x, y);
    }
    return Qnil;
}

Gibt self hoch exponent zurück.

# Result for non-negative Integer exponent is Integer.
2 ** 0   # => 1
2 ** 1   # => 2
2 ** 2   # => 4
2 ** 3   # => 8
-2 ** 3  # => -8
# Result for negative Integer exponent is Rational, not Float.
2 ** -3  # => (1/8)
-2 ** -3 # => (-1/8)

# Result for Float exponent is Float.
2 ** 0.0   # => 1.0
2 ** 1.0   # => 2.0
2 ** 2.0   # => 4.0
2 ** 3.0   # => 8.0
-2 ** 3.0  # => -8.0
2 ** -3.0  # => 0.125
-2 ** -3.0 # => -0.125

# Result for non-negative Complex exponent is Complex with Integer parts.
2 ** Complex(0, 0)   # => (1+0i)
2 ** Complex(1, 0)   # => (2+0i)
2 ** Complex(2, 0)   # => (4+0i)
2 ** Complex(3, 0)   # => (8+0i)
-2 ** Complex(3, 0) # => (-8+0i)
# Result for negative Complex exponent is Complex with Rational parts.
2 ** Complex(-3, 0)  # => ((1/8)+(0/1)*i)
-2 ** Complex(-3, 0) # => ((-1/8)+(0/1)*i)

# Result for Rational exponent is Rational.
2 ** Rational(0, 1)   # => (1/1)
2 ** Rational(1, 1)   # => (2/1)
2 ** Rational(2, 1)   # => (4/1)
2 ** Rational(3, 1)   # => (8/1)
-2 ** Rational(3, 1)  # => (-8/1)
2 ** Rational(-3, 1)  # => (1/8)
-2 ** Rational(-3, 1) # => (-1/8)

self + other → numeric

Source

VALUE
rb_int_plus(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_plus(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_plus(x, y);
    }
    return rb_num_coerce_bin(x, y, '+');
}

Gibt die Summe von self und other zurück.

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

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

1 + 3.14           # => 4.140000000000001

self - other → numeric

Source

VALUE
rb_int_minus(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_minus(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_minus(x, y);
    }
    return rb_num_coerce_bin(x, y, '-');
}

Gibt die Differenz von self und other zurück.

4 - 2              # => 2
-4 - 2             # => -6
-4 - -2            # => -2
4 - 2.0            # => 2.0
4 - Rational(2, 1) # => (2/1)
4 - Complex(2, 0)  # => (2+0i)

-self → integer

Source

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

Gibt self, negiert, zurück.

-1    # => -1
-(-1) # => 1
-0    # => 0

self / other → numeric

Source

VALUE
rb_int_div(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_div(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_div(x, y);
    }
    return Qnil;
}

Gibt den Quotienten von self und other zurück.

Für eine ganze Zahl other wird das Ergebnis zu einer ganzen Zahl trunkatiert.

4 / 3              # => 1
4 / -3             # => -2
-4 / 3             # => -2
-4 / -3            # => 1

Für eine nicht-ganze Zahl other wird ein nicht-ganzzahliger Wert zurückgegeben.

4 / 3.0            # => 1.3333333333333333
4 / Rational(3, 1) # => (4/3)
4 / Complex(3, 0)  # => ((4/3)+0i)

self < other → true or false

Source

static VALUE
int_lt(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_lt(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_lt(x, y);
    }
    return Qnil;
}

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

1 < 0              # => false
1 < 1              # => false
1 < 2              # => true
1 < 0.5            # => false
1 < Rational(1, 2) # => false

self << count → integer

Source

VALUE
rb_int_lshift(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return rb_fix_lshift(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_lshift(x, y);
    }
    return Qnil;
}

Gibt self zurück, wobei die Bits um count Positionen nach links verschoben werden, oder nach rechts, wenn count negativ ist.

n = 0b11110000
"%08b" % (n << 1)  # => "111100000"
"%08b" % (n << 3)  # => "11110000000"
"%08b" % (n << -1) # => "01111000"
"%08b" % (n << -3) # => "00011110"

Zugehörig: Integer#>>.

self <= other → true or false

Source

static VALUE
int_le(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_le(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_le(x, y);
    }
    return Qnil;
}

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

  1 <= 0              # => false
  1 <= 1              # => true
  1 <= 2              # => true
  1 <= 0.5            # => false
  1 <= Rational(1, 2) # => false

Raises an exception if the comparison cannot be made.

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

Source

VALUE
rb_int_cmp(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_cmp(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_cmp(x, y);
    }
    else {
        rb_raise(rb_eNotImpError, "need to define '<=>' in %s", rb_obj_classname(x));
    }
}

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 self und other nicht vergleichbar sind.

Beispiele

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

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

self == other → true oder false

Gibt true zurück, wenn self numerisch gleich other ist; andernfalls false.

1 == 2     #=> false
1 == 1.0   #=> true

Zugehörig: Integer#eql? (erfordert, dass other eine Ganzzahl ist).

Alias für: ===

===

Source

VALUE
rb_int_equal(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_equal(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_eq(x, y);
    }
    return Qnil;
}

Auch alias für: ==

self > other → true or false

Source

VALUE
rb_int_gt(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_gt(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_gt(x, y);
    }
    return Qnil;
}

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

  1 > 0              # => true
  1 > 1              # => false
  1 > 2              # => false
  1 > 0.5            # => true
  1 > Rational(1, 2) # => true

Raises an exception if the comparison cannot be made.

self >= real → true or false

Source

VALUE
rb_int_ge(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_ge(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_ge(x, y);
    }
    return Qnil;
}

Gibt true zurück, wenn der Wert von self größer oder gleich dem von other ist.

1 >= 0              # => true
1 >= 1              # => true
1 >= 2              # => false
1 >= 0.5            # => true
1 >= Rational(1, 2) # => true

Löst eine Ausnahme aus, wenn der Vergleich nicht durchgeführt werden kann.

self >> count → integer

Source

VALUE
rb_int_rshift(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return rb_fix_rshift(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_rshift(x, y);
    }
    return Qnil;
}

Gibt self zurück, wobei die Bits um count Positionen nach rechts verschoben werden, oder nach links, wenn count negativ ist.

n = 0b11110000
"%08b" % (n >> 1)  # => "01111000"
"%08b" % (n >> 3)  # => "00011110"
"%08b" % (n >> -1) # => "111100000"
"%08b" % (n >> -3) # => "11110000000"

Zugehörig: Integer#<<.

self[offset] → 0 or 1

self[offset, size] → integer

self[range] → integer

Source

static VALUE
int_aref(int const argc, VALUE * const argv, VALUE const num)
{
    rb_check_arity(argc, 1, 2);
    if (argc == 2) {
        return int_aref2(num, argv[0], argv[1]);
    }
    return int_aref1(num, argv[0]);

    return Qnil;
}

Gibt einen Bit-Slice aus self zurück.

Mit dem Argument offset wird das Bit an der gegebenen Position zurückgegeben, wobei die Position 0 das niederwertigste Bit bezeichnet.

n = 0b10 # => 2
n[0]     # => 0
n[1]     # => 1
n[2]     # => 0
n[3]     # => 0

Im Prinzip ist n[i] äquivalent zu (n >> i) & 1. Daher gibt ein negativer Index immer Null zurück.

255[-1] # => 0

Mit den Argumenten offset und size werden size Bits aus self zurückgegeben, beginnend bei offset und einschließlich der höherwertigen Bits.

n = 0b111000       # => 56
"%010b" % n[0, 10] # => "0000111000"
"%010b" % n[4, 10] # => "0000000011"

Mit dem Argument range werden range.size Bits aus self zurückgegeben, beginnend bei range.begin und einschließlich der höherwertigen Bits.

n = 0b111000      # => 56
"%010b" % n[0..9] # => "0000111000"
"%010b" % n[4..9] # => "0000000011"

Löst eine Ausnahme aus, wenn der Slice nicht erstellt werden kann.

self ^ other → integer

Source

VALUE
rb_int_xor(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_xor(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_xor(x, y);
    }
    return Qnil;
}

Bitweises EXKLUSIV-ODER; jedes Bit im Ergebnis ist 1, wenn die entsprechenden Bits in self und other unterschiedlich sind, andernfalls 0.

"%04b" % (0b0101 ^ 0b0110) # => "0011"

Löst eine Ausnahme aus, wenn other keine Ganzzahl ist.

Zugehörig: Integer#& (bitweises UND), Integer#| (bitweises ODER).

self | other → integer

Source

static VALUE
int_or(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_or(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_or(x, y);
    }
    return Qnil;
}

Bitweises ODER; jedes Bit im Ergebnis ist 1, wenn entweder das entsprechende Bit in self oder other 1 ist, andernfalls 0.

"%04b" % (0b0101 | 0b0110) # => "0111"

Löst eine Ausnahme aus, wenn other keine Ganzzahl ist.

Zugehörig: Integer#& (bitweises UND), Integer#^ (bitweises EXKLUSIV-ODER).

~int → integer

Source

# File numeric.rb, line 123
def ~
  Primitive.attr! :leaf
  Primitive.cexpr! 'rb_int_comp(self)'
end

Einer-Komplement: Gibt den Wert von self zurück, wobei jedes Bit invertiert ist.

Da ein Ganzzahlwert konzeptionell unendlich lang ist, wirkt das Ergebnis so, als hätte es unendlich viele Einsen links davon. In Hex-Darstellungen wird dies durch zwei Punkte links von den Ziffern angezeigt.

sprintf("%X", ~0x1122334455)    # => "..FEEDDCCBBAA"

abs → integer

Source

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

Gibt den Absolutwert von self zurück.

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

Auch alias für: magnitude

allbits?(mask) → true or false

Source

static VALUE
int_allbits_p(VALUE num, VALUE mask)
{
    mask = rb_to_int(mask);
    return rb_int_equal(rb_int_and(num, mask), mask);
}

Gibt true zurück, wenn alle Bits, die in mask gesetzt (=1) sind, auch in self gesetzt sind; gibt andernfalls false zurück.

Beispielwerte

0b1010101  self
0b1010100  mask
0b1010100  self & mask
     true  self.allbits?(mask)

0b1010100  self
0b1010101  mask
0b1010100  self & mask
    false  self.allbits?(mask)

Zugehörig: Integer#anybits?, Integer#nobits?.

anybits?(mask) → true or false

Source

static VALUE
int_anybits_p(VALUE num, VALUE mask)
{
    mask = rb_to_int(mask);
    return RBOOL(!int_zero_p(rb_int_and(num, mask)));
}

Gibt true zurück, wenn jedes Bit, das in mask gesetzt (=1) ist, auch in self gesetzt ist; gibt andernfalls false zurück.

Beispielwerte

0b10000010  self
0b11111111  mask
0b10000010  self & mask
      true  self.anybits?(mask)

0b00000000  self
0b11111111  mask
0b00000000  self & mask
     false  self.anybits?(mask)

Zugehörig: Integer#allbits?, Integer#nobits?.

bit_length → integer

Source

# File numeric.rb, line 184
def bit_length
  Primitive.attr! :leaf
  Primitive.cexpr! 'rb_int_bit_length(self)'
end

Gibt die Anzahl der Bits des Wertes von self zurück, was die Bitposition des höchstwertigen Bits ist, das sich vom Vorzeichenbit unterscheidet (wobei das niederwertigste Bit die Bitposition 1 hat). Wenn kein solches Bit vorhanden ist (Null oder Minus Eins), wird Null zurückgegeben.

Diese Methode gibt ceil(log2(self < 0 ? -self : self + 1)) zurück.

(-2**1000-1).bit_length   # => 1001
(-2**1000).bit_length     # => 1000
(-2**1000+1).bit_length   # => 1000
(-2**12-1).bit_length     # => 13
(-2**12).bit_length       # => 12
(-2**12+1).bit_length     # => 12
-0x101.bit_length         # => 9
-0x100.bit_length         # => 8
-0xff.bit_length          # => 8
-2.bit_length             # => 1
-1.bit_length             # => 0
0.bit_length              # => 0
1.bit_length              # => 1
0xff.bit_length           # => 8
0x100.bit_length          # => 9
(2**12-1).bit_length      # => 12
(2**12).bit_length        # => 13
(2**12+1).bit_length      # => 13
(2**1000-1).bit_length    # => 1000
(2**1000).bit_length      # => 1001
(2**1000+1).bit_length    # => 1001

Für Integer n kann diese Methode verwendet werden, um Überläufe in Array#pack zu erkennen.

if n.bit_length < 32
  [n].pack('l') # No overflow.
else
  raise 'Overflow'
end

ceil(ndigits = 0) → integer

Source

static VALUE
int_ceil(int argc, VALUE* argv, VALUE num)
{
    int ndigits;

    if (!rb_check_arity(argc, 0, 1)) return num;
    ndigits = NUM2INT(argv[0]);
    if (ndigits >= 0) {
        return num;
    }
    return rb_int_ceil(num, ndigits);
}

Gibt eine Ganzzahl zurück, die ein "Decken"-Wert für self ist, wie durch die gegebene ndigits angegeben, die ein integer-konvertierbares Objekt sein muss.

Wenn self Null ist, wird Null zurückgegeben (unabhängig vom Wert von ndigits).
```
0.ceil(2)  # => 0
0.ceil(-2) # => 0
```
Wenn self ungleich Null ist und ndigits nicht negativ ist, wird self zurückgegeben.
```
555.ceil     # => 555
555.ceil(50) # => 555
```
Wenn self ungleich Null ist und ndigits negativ ist, wird ein Wert basierend auf einer berechneten Granularität zurückgegeben.
- Die Granularität ist 10 ** ndigits.abs.
- Der zurückgegebene Wert ist das kleinste Vielfache der Granularität, das größer oder gleich self ist.
Beispiele mit positivem self

ndigits Granularität 1234.ceil(ndigits)

-1 10 1240

-2 100 1300

-3 1000 2000

-4 10000 10000

-5 100000 100000

Beispiele mit negativem self

ndigits Granularität -1234.ceil(ndigits)

-1 10 -1230

-2 100 -1200

-3 1000 -1000

-4 10000 0

-5 100000 0

ndigits	Granularität	1234.ceil(ndigits)
-1	10	1240
-2	100	1300
-3	1000	2000
-4	10000	10000
-5	100000	100000

ndigits	Granularität	-1234.ceil(ndigits)
-1	10	-1230
-2	100	-1200
-3	1000	-1000
-4	10000	0
-5	100000	0

Zugehörig: Integer#floor.

ceildiv(numeric) → integer

Source

# File numeric.rb, line 308
def ceildiv(other)
  -div(0 - other)
end

Gibt das Ergebnis der Division self durch numeric zurück, aufgerundet auf die nächste ganze Zahl.

3.ceildiv(3)   # => 1
4.ceildiv(3)   # => 2

4.ceildiv(-3)  # => -1
-4.ceildiv(3)  # => -1
-4.ceildiv(-3) # => 2

3.ceildiv(1.2) # => 3

chr → string

chr(encoding) → string

Source

static VALUE
int_chr(int argc, VALUE *argv, VALUE num)
{
    char c;
    unsigned int i;
    rb_encoding *enc;

    if (rb_num_to_uint(num, &i) == 0) {
    }
    else if (FIXNUM_P(num)) {
        rb_raise(rb_eRangeError, "%ld out of char range", FIX2LONG(num));
    }
    else {
        rb_raise(rb_eRangeError, "bignum out of char range");
    }

    switch (argc) {
      case 0:
        if (0xff < i) {
            enc = rb_default_internal_encoding();
            if (!enc) {
                rb_raise(rb_eRangeError, "%u out of char range", i);
            }
            goto decode;
        }
        c = (char)i;
        if (i < 0x80) {
            return rb_usascii_str_new(&c, 1);
        }
        else {
            return rb_str_new(&c, 1);
        }
      case 1:
        break;
      default:
        rb_error_arity(argc, 0, 1);
    }
    enc = rb_to_encoding(argv[0]);
    if (!enc) enc = rb_ascii8bit_encoding();
  decode:
    return rb_enc_uint_chr(i, enc);
}

Gibt einen 1-Zeichen-String zurück, der das durch den Wert von self dargestellte Zeichen gemäß der angegebenen encoding enthält.

65.chr                   # => "A"
0.chr                    # => "\x00"
255.chr                  # => "\xFF"
string = 255.chr(Encoding::UTF_8)
string.encoding          # => Encoding::UTF_8

Löst eine Ausnahme aus, wenn self negativ ist.

Zugehörig: Integer#ord.

coerce(numeric) → array

Source

static VALUE
rb_int_coerce(VALUE x, VALUE y)
{
    if (RB_INTEGER_TYPE_P(y)) {
        return rb_assoc_new(y, x);
    }
    else {
        x = rb_Float(x);
        y = rb_Float(y);
        return rb_assoc_new(y, x);
    }
}

Gibt ein Array zurück, das sowohl numeric als auch int als Integer-Objekte oder Float-Objekte repräsentiert.

Dies geschieht durch Konvertierung von numeric in einen Integer oder einen Float.

Eine TypeError wird ausgelöst, wenn numeric kein Integer oder Float-Typ ist.

(0x3FFFFFFFFFFFFFFF+1).coerce(42)   #=> [42, 4611686018427387904]

denominator → 1

Source

# File numeric.rb, line 326
def denominator
  1
end

Gibt 1 zurück.

digits(base = 10) → array_of_integers

Source

static VALUE
rb_int_digits(int argc, VALUE *argv, VALUE num)
{
    VALUE base_value;
    long base;

    if (rb_num_negative_p(num))
        rb_raise(rb_eMathDomainError, "out of domain");

    if (rb_check_arity(argc, 0, 1)) {
        base_value = rb_to_int(argv[0]);
        if (!RB_INTEGER_TYPE_P(base_value))
            rb_raise(rb_eTypeError, "wrong argument type %s (expected Integer)",
                     rb_obj_classname(argv[0]));
        if (RB_BIGNUM_TYPE_P(base_value))
            return rb_int_digits_bigbase(num, base_value);

        base = FIX2LONG(base_value);
        if (base < 0)
            rb_raise(rb_eArgError, "negative radix");
        else if (base < 2)
            rb_raise(rb_eArgError, "invalid radix %ld", base);
    }
    else
        base = 10;

    if (FIXNUM_P(num))
        return rb_fix_digits(num, base);
    else if (RB_BIGNUM_TYPE_P(num))
        return rb_int_digits_bigbase(num, LONG2FIX(base));

    return Qnil;
}

Gibt ein Array von ganzen Zahlen zurück, die die Ziffern von self in der Basis base darstellen; das erste Element des Arrays repräsentiert die niederwertigste Ziffer.

12345.digits      # => [5, 4, 3, 2, 1]
12345.digits(7)   # => [4, 6, 6, 0, 5]
12345.digits(100) # => [45, 23, 1]

Löst eine Ausnahme aus, wenn self negativ ist oder base kleiner als 2 ist.

div(numeric) → integer

Source

VALUE
rb_int_idiv(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_idiv(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_idiv(x, y);
    }
    return num_div(x, y);
}

Führt Ganzzahl-Division durch; gibt das ganzzahlige Ergebnis der Division von self durch numeric zurück.

4.div(3)              # => 1
4.div(-3)             # => -2
-4.div(3)             # => -2
-4.div(-3)            # => 1
4.div(3.0)            # => 1
4.div(Rational(3, 1)) # => 1

Löst eine Ausnahme aus, wenn numeric nicht die Methode div hat.

divmod(other) → array

Source

VALUE
rb_int_divmod(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        return fix_divmod(x, y);
    }
    else if (RB_BIGNUM_TYPE_P(x)) {
        return rb_big_divmod(x, y);
    }
    return Qnil;
}

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

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

Beispiele

11.divmod(4)              # => [2, 3]
11.divmod(-4)             # => [-3, -1]
-11.divmod(4)             # => [-3, 1]
-11.divmod(-4)            # => [2, -3]

12.divmod(4)              # => [3, 0]
12.divmod(-4)             # => [-3, 0]
-12.divmod(4)             # => [-3, 0]
-12.divmod(-4)            # => [3, 0]

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

downto(limit) {|i| ... } → self

downto(limit) → enumerator

Source

static VALUE
int_downto(VALUE from, VALUE to)
{
    RETURN_SIZED_ENUMERATOR(from, 1, &to, int_downto_size);
    if (FIXNUM_P(from) && FIXNUM_P(to)) {
        long i, end;

        end = FIX2LONG(to);
        for (i=FIX2LONG(from); i >= end; i--) {
            rb_yield(LONG2FIX(i));
        }
    }
    else {
        VALUE i = from, c;

        while (!(c = rb_funcall(i, '<', 1, to))) {
            rb_yield(i);
            i = rb_funcall(i, '-', 1, INT2FIX(1));
        }
        if (NIL_P(c)) rb_cmperr(i, to);
    }
    return from;
}

Ruft den gegebenen Block mit jedem ganzzahligen Wert von self abwärts bis zum limit auf; gibt self zurück.

a = []
10.downto(5) {|i| a << i }              # => 10
a                                       # => [10, 9, 8, 7, 6, 5]
a = []
0.downto(-5) {|i| a << i }              # => 0
a                                       # => [0, -1, -2, -3, -4, -5]
4.downto(5) {|i| fail 'Cannot happen' } # => 4

Ohne Block wird ein Enumerator zurückgegeben.

even? → true or false

Source

# File numeric.rb, line 193
def even?
  Primitive.attr! :leaf
  Primitive.cexpr! 'rb_int_even_p(self)'
end

Gibt true zurück, wenn self eine gerade Zahl ist, andernfalls false.

fdiv(numeric) → float

Source

VALUE
rb_int_fdiv(VALUE x, VALUE y)
{
    if (RB_INTEGER_TYPE_P(x)) {
        return DBL2NUM(rb_int_fdiv_double(x, y));
    }
    return Qnil;
}

Gibt das Float-Ergebnis der Division von self durch numeric zurück.

4.fdiv(2)      # => 2.0
4.fdiv(-2)      # => -2.0
-4.fdiv(2)      # => -2.0
4.fdiv(2.0)      # => 2.0
4.fdiv(Rational(3, 4))      # => 5.333333333333333

Löst eine Ausnahme aus, wenn numeric nicht in einen Float konvertiert werden kann.

floor(ndigits = 0) → integer

Source

static VALUE
int_floor(int argc, VALUE* argv, VALUE num)
{
    int ndigits;

    if (!rb_check_arity(argc, 0, 1)) return num;
    ndigits = NUM2INT(argv[0]);
    if (ndigits >= 0) {
        return num;
    }
    return rb_int_floor(num, ndigits);
}

Gibt eine Ganzzahl zurück, die ein "Boden"-Wert für self ist, wie durch die gegebene ndigits angegeben, die ein integer-konvertierbares Objekt sein muss.

Wenn self Null ist, wird Null zurückgegeben (unabhängig vom Wert von ndigits).
```
0.floor(2)  # => 0
0.floor(-2) # => 0
```
Wenn self ungleich Null ist und ndigits nicht negativ ist, wird self zurückgegeben.
```
555.floor     # => 555
555.floor(50) # => 555
```
Wenn self ungleich Null ist und ndigits negativ ist, wird ein Wert basierend auf einer berechneten Granularität zurückgegeben.
- 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 1234.floor(ndigits)

-1 10 1230

-2 100 1200

-3 1000 1000

-4 10000 0

-5 100000 0

Beispiele mit negativem self

ndigits Granularität -1234.floor(ndigits)

-1 10 -1240

-2 100 -1300

-3 1000 -2000

-4 10000 -10000

-5 100000 -100000

ndigits	Granularität	1234.floor(ndigits)
-1	10	1230
-2	100	1200
-3	1000	1000
-4	10000	0
-5	100000	0

ndigits	Granularität	-1234.floor(ndigits)
-1	10	-1240
-2	100	-1300
-3	1000	-2000
-4	10000	-10000
-5	100000	-100000

Zugehörig: Integer#ceil.

gcd(other_int) → integer

Source

VALUE
rb_gcd(VALUE self, VALUE other)
{
    other = nurat_int_value(other);
    return f_gcd(self, other);
}

Gibt den größten gemeinsamen Teiler der beiden ganzen Zahlen zurück. Das Ergebnis ist immer positiv. 0.gcd(x) und x.gcd(0) geben x.abs zurück.

36.gcd(60)                  #=> 12
2.gcd(2)                    #=> 2
3.gcd(-7)                   #=> 1
((1<<31)-1).gcd((1<<61)-1)  #=> 1

gcdlcm(other_int) → array

Source

VALUE
rb_gcdlcm(VALUE self, VALUE other)
{
    other = nurat_int_value(other);
    return rb_assoc_new(f_gcd(self, other), f_lcm(self, other));
}

Gibt ein Array mit dem größten gemeinsamen Teiler und dem kleinsten gemeinsamen Vielfachen der beiden ganzen Zahlen zurück, [gcd, lcm].

36.gcdlcm(60)                  #=> [12, 180]
2.gcdlcm(2)                    #=> [2, 2]
3.gcdlcm(-7)                   #=> [1, 21]
((1<<31)-1).gcdlcm((1<<61)-1)  #=> [1, 4951760154835678088235319297]

inspect

Alias für: to_s

integer? → true

Source

# File numeric.rb, line 202
def integer?
  true
end

Da self bereits eine Ganzzahl ist, wird immer true zurückgegeben.

lcm(other_int) → integer

Source

VALUE
rb_lcm(VALUE self, VALUE other)
{
    other = nurat_int_value(other);
    return f_lcm(self, other);
}

Gibt das kleinste gemeinsame Vielfache der beiden ganzen Zahlen zurück. Das Ergebnis ist immer positiv. 0.lcm(x) und x.lcm(0) geben Null zurück.

36.lcm(60)                  #=> 180
2.lcm(2)                    #=> 2
3.lcm(-7)                   #=> 21
((1<<31)-1).lcm((1<<61)-1)  #=> 4951760154835678088235319297

magnitude

Alias für: abs

modulo

Alias für: %

Alias für: succ

nobits?(mask) → true or false

Source

static VALUE
int_nobits_p(VALUE num, VALUE mask)
{
    mask = rb_to_int(mask);
    return RBOOL(int_zero_p(rb_int_and(num, mask)));
}

Gibt true zurück, wenn kein Bit, das in mask gesetzt (=1) ist, auch in self gesetzt ist; gibt andernfalls false zurück.

Beispielwerte

0b11110000  self
0b00001111  mask
0b00000000  self & mask
      true  self.nobits?(mask)

0b00000001  self
0b11111111  mask
0b00000001  self & mask
     false  self.nobits?(mask)

Zugehörig: Integer#allbits?, Integer#anybits?.

numerator → self

Source

# File numeric.rb, line 318
def numerator
  self
end

Gibt self zurück.

odd? → true or false

Source

# File numeric.rb, line 212
def odd?
  Primitive.attr! :leaf
  Primitive.cexpr! 'rb_int_odd_p(self)'
end

Gibt true zurück, wenn self eine ungerade Zahl ist, andernfalls false.

ord → self

Source

# File numeric.rb, line 222
def ord
  self
end

Gibt self zurück; gedacht für Kompatibilität mit Zeichen-Literalen in Ruby 1.9.

pow(numeric) → numeric

pow(integer, integer) → integer

Source

VALUE
rb_int_powm(int const argc, VALUE * const argv, VALUE const num)
{
    rb_check_arity(argc, 1, 2);

    if (argc == 1) {
        return rb_int_pow(num, argv[0]);
    }
    else {
        VALUE const a = num;
        VALUE const b = argv[0];
        VALUE m = argv[1];
        int nega_flg = 0;
        if ( ! RB_INTEGER_TYPE_P(b)) {
            rb_raise(rb_eTypeError, "Integer#pow() 2nd argument not allowed unless a 1st argument is integer");
        }
        if (rb_int_negative_p(b)) {
            rb_raise(rb_eRangeError, "Integer#pow() 1st argument cannot be negative when 2nd argument specified");
        }
        if (!RB_INTEGER_TYPE_P(m)) {
            rb_raise(rb_eTypeError, "Integer#pow() 2nd argument not allowed unless all arguments are integers");
        }

        if (rb_int_negative_p(m)) {
            m = rb_int_uminus(m);
            nega_flg = 1;
        }

        if (FIXNUM_P(m)) {
            long const half_val = (long)HALF_LONG_MSB;
            long const mm = FIX2LONG(m);
            if (!mm) rb_num_zerodiv();
            if (mm == 1) return INT2FIX(0);
            if (mm <= half_val) {
                return int_pow_tmp1(rb_int_modulo(a, m), b, mm, nega_flg);
            }
            else {
                return int_pow_tmp2(rb_int_modulo(a, m), b, mm, nega_flg);
            }
        }
        else {
            if (rb_bigzero_p(m)) rb_num_zerodiv();
            if (bignorm(m) == INT2FIX(1)) return INT2FIX(0);
            return int_pow_tmp3(rb_int_modulo(a, m), b, m, nega_flg);
        }
    }
    UNREACHABLE_RETURN(Qnil);
}

Gibt (modulare) Potenzierung als

a.pow(b)     #=> same as a**b
a.pow(b, m)  #=> same as (a**b) % m, but avoids huge temporary values

pred → next_integer

Source

static VALUE
rb_int_pred(VALUE num)
{
    if (FIXNUM_P(num)) {
        long i = FIX2LONG(num) - 1;
        return LONG2NUM(i);
    }
    if (RB_BIGNUM_TYPE_P(num)) {
        return rb_big_minus(num, INT2FIX(1));
    }
    return num_funcall1(num, '-', INT2FIX(1));
}

Gibt den Vorgänger von self zurück (entspricht self - 1).

1.pred  #=> 0
-1.pred #=> -2

Zugehörig: Integer#succ (Nachfolgerwert).

rationalize([eps]) → rational

Source

static VALUE
integer_rationalize(int argc, VALUE *argv, VALUE self)
{
    rb_check_arity(argc, 0, 1);
    return integer_to_r(self);
}

Gibt den Wert als rationale Zahl zurück. Das optionale Argument eps wird immer ignoriert.

remainder(other) → real_number

Source

static VALUE
int_remainder(VALUE x, VALUE y)
{
    if (FIXNUM_P(x)) {
        if (FIXNUM_P(y)) {
            VALUE z = fix_mod(x, y);
            RUBY_ASSERT(FIXNUM_P(z));
            if (z != INT2FIX(0) && (SIGNED_VALUE)(x ^ y) < 0)
                z = fix_minus(z, y);
            return z;
        }
        else if (!RB_BIGNUM_TYPE_P(y)) {
            return num_remainder(x, y);
        }
        x = rb_int2big(FIX2LONG(x));
    }
    else if (!RB_BIGNUM_TYPE_P(x)) {
        return Qnil;
    }
    return rb_big_remainder(x, y);
}

Gibt den Rest nach der Division von self durch other zurück.

Beispiele

11.remainder(4)              # => 3
11.remainder(-4)             # => 3
-11.remainder(4)             # => -3
-11.remainder(-4)            # => -3

12.remainder(4)              # => 0
12.remainder(-4)             # => 0
-12.remainder(4)             # => 0
-12.remainder(-4)            # => 0

13.remainder(4.0)            # => 1.0
13.remainder(Rational(4, 1)) # => (1/1)

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

Source

static VALUE
int_round(int argc, VALUE* argv, VALUE num)
{
    int ndigits;
    int mode;
    VALUE nd, opt;

    if (!rb_scan_args(argc, argv, "01:", &nd, &opt)) return num;
    ndigits = NUM2INT(nd);
    mode = rb_num_get_rounding_option(opt);
    if (ndigits >= 0) {
        return num;
    }
    return rb_int_round(num, ndigits, mode);
}

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

Wenn ndigits negativ ist, hat der zurückgegebene Wert mindestens ndigits.abs Nullen am Ende.

555.round(-1)      # => 560
555.round(-2)      # => 600
555.round(-3)      # => 1000
-555.round(-2)     # => -600
555.round(-4)      # => 0

Gibt self zurück, wenn ndigits Null oder positiv ist.

555.round     # => 555
555.round(1)  # => 555
555.round(50) # => 555

Wenn das Schlüsselwortargument half gegeben ist und self von zwei Kandidatenwerten gleich weit entfernt ist, wird entsprechend dem gegebenen half-Wert gerundet.

:up oder nil: Rundung vom Betrag weg.

25.round(-1, half: :up)      # => 30
(-25).round(-1, half: :up)   # => -30

:down: Rundung zum Betrag hin.

25.round(-1, half: :down)    # => 20
(-25).round(-1, half: :down) # => -20

:even: Rundung zum Kandidaten mit der letzten nicht-null Ziffer gerade.

25.round(-1, half: :even)    # => 20
15.round(-1, half: :even)    # => 20
(-25).round(-1, half: :even) # => -20

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

Zugehörig: Integer#truncate.

size → integer

Source

# File numeric.rb, line 239
def size
  Primitive.attr! :leaf
  Primitive.cexpr! 'rb_int_size(self)'
end

Gibt die Anzahl der Bytes in der Maschinendarstellung von self zurück; der Wert ist systemabhängig.

1.size             # => 8
-1.size            # => 8
2147483647.size    # => 8
(256**10 - 1).size # => 10
(256**20 - 1).size # => 20
(256**40 - 1).size # => 40

succ → next_integer

Source

VALUE
rb_int_succ(VALUE num)
{
    if (FIXNUM_P(num)) {
        long i = FIX2LONG(num) + 1;
        return LONG2NUM(i);
    }
    if (RB_BIGNUM_TYPE_P(num)) {
        return rb_big_plus(num, INT2FIX(1));
    }
    return num_funcall1(num, '+', INT2FIX(1));
}

Gibt den Nachfolger-Integer von self zurück (entspricht self + 1).

1.succ  #=> 2
-1.succ #=> 0

Zugehörig: Integer#pred (Vorgängerwert).

Auch alias für: next

times {|i| ... } → self

times → enumerator

Source

# File numeric.rb, line 255
def times
  Primitive.attr! :inline_block
  unless defined?(yield)
    return Primitive.cexpr! 'SIZED_ENUMERATOR(self, 0, 0, int_dotimes_size)'
  end
  i = 0
  while i < self
    yield i
    i = i.succ
  end
  self
end

Ruft den gegebenen Block self mal mit jeder Ganzzahl in (0..self-1) auf.

a = []
5.times {|i| a.push(i) } # => 5
a                        # => [0, 1, 2, 3, 4]

Ohne Block wird ein Enumerator zurückgegeben.

to_bn ()

Source

# File ext/openssl/lib/openssl/bn.rb, line 37
def to_bn
  OpenSSL::BN::new(self)
end

Konvertiert einen Integer in einen OpenSSL::BN.

Siehe `man bn` für weitere Informationen.

to_f → float

Source

static VALUE
int_to_f(VALUE num)
{
    double val;

    if (FIXNUM_P(num)) {
        val = (double)FIX2LONG(num);
    }
    else if (RB_BIGNUM_TYPE_P(num)) {
        val = rb_big2dbl(num);
    }
    else {
        rb_raise(rb_eNotImpError, "Unknown subclass for to_f: %s", rb_obj_classname(num));
    }

    return DBL2NUM(val);
}

Konvertiert self in einen Float.

1.to_f  # => 1.0
-1.to_f # => -1.0

Wenn der Wert von self nicht in einen Float passt, ist das Ergebnis unendlich.

(10**400).to_f  # => Infinity
(-10**400).to_f # => -Infinity

to_i → self

Source

# File numeric.rb, line 272
def to_i
  self
end

Gibt self zurück (das bereits eine Ganzzahl ist).

to_int → self

Source

# File numeric.rb, line 280
def to_int
  self
end

Gibt self zurück (das bereits eine Ganzzahl ist).

to_r → rational

Source

static VALUE
integer_to_r(VALUE self)
{
    return rb_rational_new1(self);
}

Gibt den Wert als rationale Zahl zurück.

1.to_r        #=> (1/1)
(1<<64).to_r  #=> (18446744073709551616/1)

to_s(base = 10) → string

Source

VALUE
rb_int_to_s(int argc, VALUE *argv, VALUE x)
{
    int base;

    if (rb_check_arity(argc, 0, 1))
        base = NUM2INT(argv[0]);
    else
        base = 10;
    return rb_int2str(x, base);
}

Gibt einen String zurück, der die Stellenwertdarstellung von self in der Basis base (in 2..36) enthält.

12345.to_s               # => "12345"
12345.to_s(2)            # => "11000000111001"
12345.to_s(8)            # => "30071"
12345.to_s(10)           # => "12345"
12345.to_s(16)           # => "3039"
12345.to_s(36)           # => "9ix"
78546939656932.to_s(36)  # => "rubyrules"

Löst eine Ausnahme aus, wenn base außerhalb des gültigen Bereichs liegt.

Auch alias für: inspect

truncate(ndigits = 0) → integer

Source

static VALUE
int_truncate(int argc, VALUE* argv, VALUE num)
{
    int ndigits;

    if (!rb_check_arity(argc, 0, 1)) return num;
    ndigits = NUM2INT(argv[0]);
    if (ndigits >= 0) {
        return num;
    }
    return rb_int_truncate(num, ndigits);
}

Gibt self (in Richtung Null) auf eine Präzision von ndigits Dezimalstellen abgeschnitten zurück.

Wenn ndigits negativ ist, hat der zurückgegebene Wert mindestens ndigits.abs Nullen am Ende.

555.truncate(-1)  # => 550
555.truncate(-2)  # => 500
-555.truncate(-2) # => -500

Gibt self zurück, wenn ndigits Null oder positiv ist.

555.truncate     # => 555
555.truncate(50) # => 555

Zugehörig: Integer#round.

upto(limit) {|i| ... } → self

upto(limit) → enumerator

Source

static VALUE
int_upto(VALUE from, VALUE to)
{
    RETURN_SIZED_ENUMERATOR(from, 1, &to, int_upto_size);
    if (FIXNUM_P(from) && FIXNUM_P(to)) {
        long i, end;

        end = FIX2LONG(to);
        for (i = FIX2LONG(from); i <= end; i++) {
            rb_yield(LONG2FIX(i));
        }
    }
    else {
        VALUE i = from, c;

        while (!(c = rb_funcall(i, '>', 1, to))) {
            rb_yield(i);
            i = rb_funcall(i, '+', 1, INT2FIX(1));
        }
        ensure_cmp(c, i, to);
    }
    return from;
}

Ruft den gegebenen Block mit jedem ganzzahligen Wert von self aufwärts bis zum limit auf; gibt self zurück.

a = []
5.upto(10) {|i| a << i }              # => 5
a                                     # => [5, 6, 7, 8, 9, 10]
a = []
-5.upto(0) {|i| a << i }              # => -5
a                                     # => [-5, -4, -3, -2, -1, 0]
5.upto(4) {|i| fail 'Cannot happen' } # => 5

Ohne Block wird ein Enumerator zurückgegeben.

zero? → true or false

Source

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

Gibt true zurück, wenn self einen Nullwert hat, andernfalls false.