Class: Bignum

Inherits:
Integer show all
Defined in:
bignum.c

Overview

Bignum objects hold integers outside the range of Fixnum. Bignum objects are created automatically when integer calculations would otherwise overflow a Fixnum. When a calculation involving Bignum objects returns a result that will fit in a Fixnum, the result is automatically converted.

For the purposes of the bitwise operations and [], a Bignum is treated as if it were an infinite-length bitstring with 2’s complement representation.

While Fixnum values are immediate, Bignum objects are not—assignment and parameter passing work with references to objects, not the objects themselves.

Instance Method Summary collapse

Methods inherited from Integer

#ceil, #chr, #downto, #even?, #floor, induced_from, #integer?, #next, #odd?, #ord, #pred, #round, #succ, #times, #to_i, #to_int, #truncate, #upto

Methods included from Precision

included, #prec, #prec_f, #prec_i

Methods inherited from Numeric

#+@, #ceil, #floor, #initialize_copy, #integer?, #nonzero?, #round, #singleton_method_added, #step, #to_int, #truncate, #zero?

Methods included from Comparable

#<, #<=, #>, #>=, #between?

Instance Method Details

#%(other) ⇒ Numeric #modulo(other) ⇒ Numeric

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

Overloads:



1529
1530
1531
 
# File 'bignum.c', line 1529

static VALUE
rb_big_modulo(x, y)
VALUE x, y;

#&(numeric) ⇒ Integer

Performs bitwise and between big and numeric.

Returns:



1825
1826
1827
 
# File 'bignum.c', line 1825

VALUE
rb_big_and(xx, yy)
VALUE xx, yy;

#*(other) ⇒ Numeric

Multiplies big and other, returning the result.

Returns:



1335
1336
1337
 
# File 'bignum.c', line 1335

VALUE
rb_big_mul(x, y)
VALUE x, y;

#**(exponent# = > numeric)) ⇒ Object

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



1770
1771
1772
 
# File 'bignum.c', line 1770

VALUE
rb_big_pow(x, y)
VALUE x, y;

#+(other) ⇒ Numeric

Adds big and other, returning the result.

Returns:



1236
1237
1238
 
# File 'bignum.c', line 1236

VALUE
rb_big_plus(x, y)
VALUE x, y;

#-(other) ⇒ Numeric

Subtracts other from big, returning the result.

Returns:



1262
1263
1264
 
# File 'bignum.c', line 1262

VALUE
rb_big_minus(x, y)
VALUE x, y;

#- ⇒ Object

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



1095
1096
1097
 
# File 'bignum.c', line 1095

static VALUE
rb_big_uminus(x)
VALUE x;

#/(other) ⇒ Numeric #div(other) ⇒ Numeric

Divides big by other, returning the result.

Overloads:



1498
1499
1500
 
# File 'bignum.c', line 1498

static VALUE
rb_big_div(x, y)
VALUE x, y;

#<<(numeric) ⇒ Integer

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

Returns:



2008
2009
2010
 
# File 'bignum.c', line 2008

VALUE
rb_big_lshift(x, y)
VALUE x, y;

#<=>(numeric) ⇒ -1, ...

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:

  • (-1, 0, +1) 


992
993
994
 
# File 'bignum.c', line 992

static VALUE
rb_big_cmp(x, y)
VALUE x, y;

#==(obj) ⇒ Boolean

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

Returns:

  • (Boolean) 


1038
1039
1040
 
# File 'bignum.c', line 1038

static VALUE
rb_big_eq(x, y)
VALUE x, y;

#>>(numeric) ⇒ Integer

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

Returns:



2075
2076
2077
 
# File 'bignum.c', line 2075

VALUE
rb_big_rshift(x, y)
VALUE x, y;

#[](n) ⇒ 0, 1

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

Returns:

  • (0, 1) 


2173
2174
2175
 
# File 'bignum.c', line 2173

static VALUE
rb_big_aref(x, y)
VALUE x, y;

#^(numeric) ⇒ Integer

Performs bitwise exclusive or between big and numeric.

Returns:



1938
1939
1940
 
# File 'bignum.c', line 1938

VALUE
rb_big_xor(xx, yy)
VALUE xx, yy;

#abs ⇒ Bignum

Returns the absolute value of big.

-1234567890987654321.abs   #=> 1234567890987654321

Returns:



2267
2268
2269
 
# File 'bignum.c', line 2267

static VALUE
rb_big_abs(x)
VALUE x;

#coerce ⇒ Object

MISSING: documentation



2240
2241
2242
 
# File 'bignum.c', line 2240

static VALUE
rb_big_coerce(x, y)
VALUE x, y;

#/(other) ⇒ Numeric #div(other) ⇒ Numeric

Divides big by other, returning the result.

Overloads:



1498
1499
1500
 
# File 'bignum.c', line 1498

static VALUE
rb_big_div(x, y)
VALUE x, y;

#divmod(numeric) ⇒ Array

See Numeric#divmod.

Returns:



1624
1625
1626
 
# File 'bignum.c', line 1624

VALUE
rb_big_divmod(x, y)
VALUE x, y;

#eql?(obj) ⇒ Boolean

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

Returns:

  • (Boolean) 


1077
1078
1079
 
# File 'bignum.c', line 1077

static VALUE
rb_big_eql(x, y)
VALUE x, y;

#quo(numeric) ⇒ Float #fdiv(numeric) ⇒ Float

Returns the floating point result of dividing big by numeric.

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

Overloads:



1659
1660
1661
 
# File 'bignum.c', line 1659

static VALUE
rb_big_quo(x, y)
VALUE x, y;

#hash ⇒ Fixnum

Compute a hash based on the value of big.

Returns:



2222
2223
2224
 
# File 'bignum.c', line 2222

static VALUE
rb_big_hash(x)
VALUE x;

#%(other) ⇒ Numeric #modulo(other) ⇒ Numeric

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

Overloads:



1529
1530
1531
 
# File 'bignum.c', line 1529

static VALUE
rb_big_modulo(x, y)
VALUE x, y;

#quo(numeric) ⇒ Float #fdiv(numeric) ⇒ Float

Returns the floating point result of dividing big by numeric.

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

Overloads:



1659
1660
1661
 
# File 'bignum.c', line 1659

static VALUE
rb_big_quo(x, y)
VALUE x, y;

#remainder(numeric) ⇒ Numeric

Returns the remainder after dividing big by numeric.

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

Returns:



1560
1561
1562
 
# File 'bignum.c', line 1560

static VALUE
rb_big_remainder(x, y)
VALUE x, y;

#size ⇒ Integer

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

Returns:



2311
2312
2313
 
# File 'bignum.c', line 2311

static VALUE
rb_big_size(big)
VALUE big;

#to_f ⇒ Float

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

Returns:



975
976
977
 
# File 'bignum.c', line 975

static VALUE
rb_big_to_f(x)
VALUE x;

#to_s(base = 10) ⇒ String

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"

Returns:



776
777
778
 
# File 'bignum.c', line 776

static VALUE
rb_big_to_s(argc, argv, x)
int argc;

#|(numeric) ⇒ Integer

Performs bitwise or between big and numeric.

Returns:



1881
1882
1883
 
# File 'bignum.c', line 1881

VALUE
rb_big_or(xx, yy)
VALUE xx, yy;

#~ ⇒ Integer

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"

Returns:



1118
1119
1120
 
# File 'bignum.c', line 1118

static VALUE
rb_big_neg(x)
VALUE x;