Returns big modulo other. See Numeric.divmod for more information.

Performs bitwise and between big and numeric.

Multiplies big and other, returning the result.

Alias for rpower

Raises big to the exponent power (which may be an integer, float, or anything that will coerce to a number). The result may be a Fixnum, Bignum, or Float

  123456789 ** 2      #=> 15241578750190521
  123456789 ** 1.2    #=> 5126464716.09932
  123456789 ** -2     #=> 6.5610001194102e-17

Adds big and other, returning the result.

Subtracts other from big, returning the result.

Unary minus (returns a new Bignum whose value is 0-big)

Divides big by other, returning the result.

Shifts big left numeric positions (right if numeric is negative).

Comparison—Returns -1, 0, or +1 depending on whether big is less than, equal to, or greater than numeric. This is the basis for the tests in Comparable.

Returns true only if obj has the same value as big. Contrast this with Bignum#eql?, which requires obj to be a Bignum.

   68719476736 == 68719476736.0   #=> true

Shifts big right numeric positions (left if numeric is negative).

Bit Reference—Returns the nth bit in the (assumed) binary representation of big, where big[0] is the least significant bit.

   a = 9**15
   50.downto(0) do |n|
     print a[n]
   end

produces:

   000101110110100000111000011110010100111100010111001

Performs bitwise +exclusive or+ between big and numeric.

Returns the absolute value of big.

   -1234567890987654321.abs   #=> 1234567890987654321

MISSING: documentation

Divides big by other, returning the result.

See Numeric#divmod.

Returns true only if obj is a Bignum with the same value as big. Contrast this with Bignum#==, which performs type conversions.

   68719476736.eql?(68719476736.0)   #=> false

Compute a hash based on the value of big.

Returns big modulo other. See Numeric.divmod for more information.

Alias for #**

If Rational is defined, returns a Rational number instead of a Bignum.

Returns the floating point result of dividing big by numeric.

   -1234567890987654321.quo(13731)      #=> -89910996357705.5
   -1234567890987654321.quo(13731.24)   #=> -89909424858035.7

Alias for quo

Returns the remainder after dividing big by numeric.

   -1234567890987654321.remainder(13731)      #=> -6966
   -1234567890987654321.remainder(13731.24)   #=> -9906.22531493148

Returns a Rational number if the result is in fact rational (i.e. other < 0).

Returns the number of bytes in the machine representation of big.

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

Converts big to a Float. If big doesn’t fit in a Float, the result is infinity.

Returns a string containing the representation of big radix base (2 through 36).

   12345654321.to_s         #=> "12345654321"
   12345654321.to_s(2)      #=> "1011011111110110111011110000110001"
   12345654321.to_s(8)      #=> "133766736061"
   12345654321.to_s(16)     #=> "2dfdbbc31"
   78546939656932.to_s(36)  #=> "rubyrules"

Performs bitwise or between big and numeric.

Inverts the bits in big. As Bignums are conceptually infinite length, the result acts as if it had an infinite number of one bits to the left. In hex representations, this is displayed as two periods to the left of the digits.

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