struct BigInt
inherits Int
¶
A BigInt can represent arbitrarily large integers.
It is implemented under the hood with GMP.
Included modules
Comparable
Comparable
Comparable
Comparable
Class methods¶
.new(str : String, base = 10)
¶
(str : String, base = 10)
Creates a BigInt with the value denoted by str in the given base.
Raises ArgumentError if the string doesn't denote a valid integer.
require "big"
BigInt.new("123456789123456789123456789123456789") # => 123456789123456789123456789123456789
BigInt.new("123_456_789_123_456_789_123_456_789") # => 123456789123456789123456789
BigInt.new("1234567890ABCDEF", base: 16) # => 1311768467294899695
.new(num : BigInt)
¶
(num : BigInt)
Returns num. Useful for generic code that does T.new(...) with T
being a Number.
Methods¶
#%(other : Int) : BigInt
¶
View source
(other : Int) : BigInt
#**(other : Int) : BigInt
¶
(other : Int) : BigInt
Returns the value of raising self to the power of exponent.
Raises ArgumentError if exponent is negative: if this is needed,
either use a float base or a float exponent.
Raises OverflowError in case of overflow.
2 ** 3 # => 8
2 ** 0 # => 1
2 ** -1 # ArgumentError
#<<(other : Int) : BigInt
¶
(other : Int) : BigInt
Returns the result of shifting this number's bits count positions to the left.
- If count is greater than the number of bits of this integer, returns 0
- If count is negative, a right shift is performed
8000 << 1 # => 16000
8000 << 2 # => 32000
8000 << 32 # => 0
8000 << -1 # => 4000
#<=>(other : Float)
¶
(other : Float)
The comparison operator. Returns 0 if the two objects are equal,
a negative number if this object is considered less than other,
a positive number if this object is considered greater than other,
or nil if the two objects are not comparable.
Subclasses define this method to provide class-specific ordering.
The comparison operator is usually used to sort values:
# Sort in a descending way:
[3, 1, 2].sort { |x, y| y <=> x } # => [3, 2, 1]
# Sort in an ascending way:
[3, 1, 2].sort { |x, y| x <=> y } # => [1, 2, 3]
#>>(other : Int) : BigInt
¶
(other : Int) : BigInt
Returns the result of shifting this number's bits count positions to the right. Also known as arithmetic right shift.
- If count is greater than the number of bits of this integer, returns 0
- If count is negative, a left shift is performed
8000 >> 1 # => 4000
8000 >> 2 # => 2000
8000 >> 32 # => 0
8000 >> -1 # => 16000
-8000 >> 1 # => -4000
#abs : BigInt
¶
: BigInt
Returns the absolute value of this number.
123.abs # => 123
-123.abs # => 123
#bit_length : Int32
¶
: Int32
Returns the number of bits of this int value.
“The number of bits” means that the bit position of the highest bit which is different to the sign bit. (The bit position of the bit 2**n is n+1.) If there is no such bit (zero or minus one), zero is returned.
I.e. This method returns ceil(log2(self < 0 ? -self : self + 1)).
0.bit_length # => 0
1.bit_length # => 1
2.bit_length # => 2
3.bit_length # => 2
4.bit_length # => 3
5.bit_length # => 3
# The above is the same as
0b0.bit_length # => 0
0b1.bit_length # => 1
0b10.bit_length # => 2
0b11.bit_length # => 2
0b100.bit_length # => 3
0b101.bit_length # => 3
#popcount
¶
Counts 1-bits in the binary representation of this integer.
5.popcount # => 2
-15.popcount # => 29
#remainder(other : Int) : BigInt
¶
View source
(other : Int) : BigInt
#tdiv(other : Int) : BigInt
¶
(other : Int) : BigInt
Divides self by other using truncated division.
In truncated division, given two integers x and y:
* q = x.tdiv(y) is rounded toward zero
* r = x.remainder(y) has the sign of the first argument
* x == q*y + r
For example:
x y x / y x % y
5 3 1 2
-5 3 -1 -2
5 -3 -1 2
-5 -3 1 -2
Raises if other is 0, or if other is -1 and
self is signed and is the minimum value for that
integer type.
#to_s : String
¶
: String
Returns a string representation of self.
require "big"
BigInt.new("123456789101101987654321").to_s # => 123456789101101987654321
#to_s(base : Int) : String
¶
(base : Int) : String
Returns a string containing the representation of big radix base (2 through 36).
require "big"
BigInt.new("123456789101101987654321").to_s(8) # => "32111154373025463465765261"
BigInt.new("123456789101101987654321").to_s(16) # => "1a249b1f61599cd7eab1"
BigInt.new("123456789101101987654321").to_s(36) # => "k3qmt029k48nmpd"
#to_s(io : IO) : Nil
¶
(io : IO) : Nil
Returns a string representation of self.
require "big"
BigInt.new("123456789101101987654321").to_s # => 123456789101101987654321