struct BigInt
Overview
A BigInt can represent arbitrarily large integers.
It is implemented under the hood with GMP.
NOTE To use BigInt, you must explicitly import it with require "big"
Included Modules
- Comparable(Float)
- Comparable(BigInt)
- Comparable(UInt128 | UInt16 | UInt32 | UInt64 | UInt8)
- Comparable(Int128 | Int16 | Int32 | Int64 | Int8)
Defined in:
big.crbig/big_int.cr
big/number.cr
Constructors
-
.new(str : String, base = 10)
Creates a
BigIntwith the value denoted by str in the given base. -
.new(num : Int::Primitive)
Creates a
BigIntfrom the given num. - .new(num : Float::Primitive)
- .new(num : BigFloat)
- .new(num : BigDecimal)
- .new(num : BigRational)
-
.new(num : BigInt)
Returns num.
-
.new
Creates a
BigIntwith the value zero.
Instance Method Summary
-
#%(other : Int) : BigInt
Returns
selfmodulo other. - #&(other : BigInt) : BigInt
- #&(other : Int) : BigInt
- #&*(other) : BigInt
- #&+(other) : BigInt
- #&-(other) : BigInt
- #*(other : BigInt) : BigInt
- #*(other : Int) : BigInt
-
#**(other : Int) : BigInt
Returns the value of raising
selfto the power of exponent. - #+(other : BigInt) : BigInt
- #+(other : Int) : BigInt
- #-(other : BigInt) : BigInt
- #-(other : Int) : BigInt
- #- : BigInt
- #/(other : BigInt) : BigFloat
- #/(other : BigDecimal) : BigDecimal
- #/(other : BigRational) : BigRational
- #/(other : Int8) : BigFloat
- #/(other : UInt8) : BigFloat
- #/(other : Int16) : BigFloat
- #/(other : UInt16) : BigFloat
- #/(other : Int32) : BigFloat
- #/(other : UInt32) : BigFloat
- #/(other : Int64) : BigFloat
- #/(other : UInt64) : BigFloat
- #/(other : Int128) : BigFloat
- #/(other : UInt128) : BigFloat
- #/(other : Float32) : BigFloat
- #/(other : Float64) : BigFloat
- #//(other : Int) : BigInt
-
#<<(other : Int) : BigInt
Returns the result of shifting this number's bits count positions to the left.
- #<=>(other : BigInt)
- #<=>(other : Int)
- #<=>(other : Float::Primitive)
-
#>>(other : Int) : BigInt
Returns the result of shifting this number's bits count positions to the right.
- #^(other : BigInt) : BigInt
- #^(other : Int) : BigInt
- #|(other : BigInt) : BigInt
- #|(other : Int) : BigInt
- #~ : BigInt
-
#abs : BigInt
Returns the absolute value of this number.
- #bit(bit : Int)
-
#bit_length : Int32
Returns the number of bits of this int value.
- #clone
-
#digits(base = 10) : Array(Int32)
Returns the digits of a number in a given base.
- #divisible_by?(number : BigInt) : Bool
- #divisible_by?(number : Int) : Bool
- #divmod(number : Int) : Tuple(BigInt, BigInt)
- #factorial : BigInt
-
#gcd(other : BigInt) : BigInt
Returns the greatest common divisor of
selfand other. -
#gcd(other : Int) : Int
Returns the greatest common divisor of
selfand other. -
#lcm(other : BigInt) : BigInt
Returns the least common multiple of
selfand other. -
#lcm(other : Int) : BigInt
Returns the least common multiple of
selfand other. -
#popcount : Int
Counts
1-bits in the binary representation of this integer. -
#remainder(other : Int) : BigInt
Returns
selfremainder other. -
#tdiv(other : Int) : BigInt
Divides
selfby other using truncated division. -
#to_big_d : BigDecimal
Converts
selftoBigDecimal. - #to_big_f : BigFloat
-
#to_big_i : BigInt
Returns a
BigIntrepresenting this integer. -
#to_big_r : BigRational
Returns a
BigRationalrepresenting this integer. - #to_f : Float64
- #to_f!
- #to_f32 : Float32
- #to_f32!
- #to_f64 : Float64
- #to_f64!
- #to_i : Int32
- #to_i! : Int32
- #to_i128 : Int128
- #to_i128! : Int128
- #to_i16 : Int16
- #to_i16! : Int16
- #to_i32 : Int32
- #to_i32! : Int32
- #to_i64 : Int64
- #to_i64! : Int64
- #to_i8 : Int8
- #to_i8! : Int8
-
#to_s(io : IO, base : Int = 10, *, precision : Int = 1, upcase : Bool = false) : Nil
Appends a string representation of this integer to the given io.
-
#to_s(base : Int = 10, *, precision : Int = 1, upcase : Bool = false) : String
Returns a string representation of this integer.
- #to_u : UInt32
- #to_u! : UInt32
- #to_u128 : UInt128
- #to_u128! : UInt128
- #to_u16 : UInt16
- #to_u16! : UInt16
- #to_u32 : UInt32
- #to_u32! : UInt32
- #to_u64 : UInt64
- #to_u64! : UInt64
- #to_u8 : UInt8
- #to_u8! : UInt8
- #to_unsafe
-
#trailing_zeros_count : Int
Returns the number of trailing
0-bits. - #unsafe_floored_div(other : BigInt) : BigInt
- #unsafe_floored_div(other : Int) : BigInt
- #unsafe_floored_divmod(number : BigInt) : Tuple(BigInt, BigInt)
- #unsafe_floored_divmod(number : Int) : Tuple(BigInt, BigInt)
- #unsafe_floored_mod(other : BigInt) : BigInt
- #unsafe_floored_mod(other : Int) : BigInt
- #unsafe_truncated_div(other : BigInt) : BigInt
- #unsafe_truncated_div(other : Int) : BigInt
- #unsafe_truncated_divmod(number : BigInt)
- #unsafe_truncated_divmod(number : Int)
- #unsafe_truncated_mod(other : BigInt) : BigInt
- #unsafe_truncated_mod(other : Int) : BigInt
Instance methods inherited from module Comparable(Float)
<(other : T) : Bool
<,
<=(other : T)
<=,
<=>(other : T)
<=>,
==(other : T)
==,
>(other : T) : Bool
>,
>=(other : T)
>=,
clamp(min, max)clamp(range : Range) clamp
Instance methods inherited from module Comparable(BigInt)
<(other : T) : Bool
<,
<=(other : T)
<=,
<=>(other : T)
<=>,
==(other : T)
==,
>(other : T) : Bool
>,
>=(other : T)
>=,
clamp(min, max)clamp(range : Range) clamp
Instance methods inherited from module Comparable(UInt128 | UInt16 | UInt32 | UInt64 | UInt8)
<(other : T | T | T | T | T) : Bool
<,
<=(other : T | T | T | T | T)
<=,
<=>(other : T | T | T | T | T)
<=>,
==(other : T | T | T | T | T)
==,
>(other : T | T | T | T | T) : Bool
>,
>=(other : T | T | T | T | T)
>=,
clamp(min, max)clamp(range : Range) clamp
Instance methods inherited from module Comparable(Int128 | Int16 | Int32 | Int64 | Int8)
<(other : T | T | T | T | T) : Bool
<,
<=(other : T | T | T | T | T)
<=,
<=>(other : T | T | T | T | T)
<=>,
==(other : T | T | T | T | T)
==,
>(other : T | T | T | T | T) : Bool
>,
>=(other : T | T | T | T | T)
>=,
clamp(min, max)clamp(range : Range) clamp
Instance methods inherited from struct Int
%(other : BigInt) : BigInt%(other : Int) %, &*(other : BigInt) : BigInt &*, &**(exponent : Int) : self &**, &+(other : BigInt) : BigInt &+, &-(other : BigInt) : BigInt &-, *(other : BigInt) : BigInt
*(other : BigRational) : BigRational
*(other : BigDecimal) : BigDecimal *, **(exponent : Int) : self
**(exponent : Float) : Float64 **, +(other : BigInt) : BigInt
+(other : BigRational) : BigRational
+(other : BigDecimal) : BigDecimal +, -(other : BigInt) : BigInt
-(other : BigFloat) : BigFloat
-(other : BigRational) : BigRational
-(other : BigDecimal) : BigDecimal -, /(other : BigFloat) : BigFloat
/(other : BigRational) /, //(other : Int::Primitive) //, <<(count : Int) <<, <=>(other : BigInt)
<=>(other : Int) : Int32
<=>(other : BigFloat)
<=>(other : BigRational)
<=>(other : BigDecimal) <=>, ===(char : Char) ===, >>(count : Int) >>, ~ ~, abs : self abs, bit(bit) bit, bit_length : Int32 bit_length, bits(range : Range) bits, bits_set?(mask) : Bool bits_set?, ceil : self ceil, chr : Char chr, day : Time::Span day, days : Time::Span days, digits(base = 10) : Array(Int32) digits, divisible_by?(num) : Bool divisible_by?, downto(to, &block : self -> ) : Nil
downto(to) downto, even? : Bool even?, fdiv(other) : Float64 fdiv, floor : self floor, gcd(other : self) : self
gcd(other : BigInt) : Int gcd, hour : Time::Span hour, hours : Time::Span hours, humanize_bytes(io : IO, precision : Int = 3, separator = '.', *, significant : Bool = true, format : BinaryPrefixFormat = :IEC) : Nil
humanize_bytes(precision : Int = 3, separator = '.', *, significant : Bool = true, format : BinaryPrefixFormat = :IEC) : String humanize_bytes, integer? : Bool integer?, lcm(other : BigInt) : BigInt
lcm(other : Int) lcm, microsecond : Time::Span microsecond, microseconds : Time::Span microseconds, millisecond : Time::Span millisecond, milliseconds : Time::Span milliseconds, minute : Time::Span minute, minutes : Time::Span minutes, modulo(other) modulo, month : Time::MonthSpan month, months : Time::MonthSpan months, nanosecond : Time::Span nanosecond, nanoseconds : Time::Span nanoseconds, odd? : Bool odd?, popcount popcount, pred : self pred, remainder(other : Int) remainder, round(mode : RoundingMode) : self round, round_away round_away, round_even : self round_even, second : Time::Span second, seconds : Time::Span seconds, succ : self succ, tdiv(other : Int) tdiv, times(&block : self -> ) : Nil
times times, to(to, &block : self -> ) : Nil
to(to) to, to_big_d : BigDecimal to_big_d, to_big_i : BigInt to_big_i, to_big_r : BigRational to_big_r, to_io(io : IO, format : IO::ByteFormat) : Nil to_io, to_json(json : JSON::Builder) : Nil to_json, to_json_object_key : String to_json_object_key, to_s(io : IO, base : Int = 10, *, precision : Int = 1, upcase : Bool = false) : Nil
to_s(base : Int = 10, *, precision : Int = 1, upcase : Bool = false) : String to_s, trailing_zeros_count trailing_zeros_count, trunc : self trunc, upto(to, &block : self -> ) : Nil
upto(to) upto, week : Time::Span week, weeks : Time::Span weeks, year : Time::MonthSpan year, years : Time::MonthSpan years
Constructor methods inherited from struct Int
from_io(io : IO, format : IO::ByteFormat) : self
from_io
Instance methods inherited from module Comparable(BigDecimal)
<(other : T) : Bool
<,
<=(other : T)
<=,
<=>(other : T)
<=>,
==(other : T)
==,
>(other : T) : Bool
>,
>=(other : T)
>=,
clamp(min, max)clamp(range : Range) clamp
Instance methods inherited from module Comparable(BigRational)
<(other : T) : Bool
<,
<=(other : T)
<=,
<=>(other : T)
<=>,
==(other : T)
==,
>(other : T) : Bool
>,
>=(other : T)
>=,
clamp(min, max)clamp(range : Range) clamp
Instance methods inherited from module Comparable(BigInt)
<(other : T) : Bool
<,
<=(other : T)
<=,
<=>(other : T)
<=>,
==(other : T)
==,
>(other : T) : Bool
>,
>=(other : T)
>=,
clamp(min, max)clamp(range : Range) clamp
Instance methods inherited from struct Number
*(other : BigFloat) : BigFloat*(other : Complex) : Complex *, +(other : BigFloat)
+(other : Complex) : Complex
+ +, -(other : BigFloat)
-(other : Complex) : Complex -, /(other : BigFloat) : BigFloat
/(other : Complex) : Complex /, //(other) //, <=>(other) : Int32 | Nil <=>, ==(other : Complex) ==, abs : self abs, abs2 abs2, cis : Complex cis, divmod(number) divmod, format(io : IO, separator = '.', delimiter = ',', decimal_places : Int | Nil = nil, *, group : Int = 3, only_significant : Bool = false) : Nil
format(separator = '.', delimiter = ',', decimal_places : Int | Nil = nil, *, group : Int = 3, only_significant : Bool = false) : String format, hash(hasher) hash, humanize(io : IO, precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, prefixes : Indexable = SI_PREFIXES) : Nil
humanize(io : IO, precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, prefixes : Proc) : Nil
humanize(precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, prefixes = SI_PREFIXES) : String
humanize(io : IO, precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, &prefixes : Int32, Float64 -> Tuple(Int32, _) | Tuple(Int32, _, Bool)) : Nil
humanize(precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, &) : String
humanize(precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, prefixes : Proc) : String humanize, i : Complex i, integer? : Bool integer?, negative? : Bool negative?, positive? : Bool positive?, round(mode : RoundingMode = :ties_even) : self
round(digits : Number, base = 10, *, mode : RoundingMode = :ties_even) round, sign : Int32 sign, significant(digits, base = 10) significant, step(*, to limit = nil, exclusive : Bool = false, &) : Nil
step(*, to limit = nil, exclusive : Bool = false) step, to_big_f : BigFloat to_big_f, to_c : Complex to_c, to_yaml(yaml : YAML::Nodes::Builder) : Nil to_yaml, zero? : Bool zero?
Constructor methods inherited from struct Number
additive_identity : self
additive_identity,
multiplicative_identity : self
multiplicative_identity,
zero : self
zero
Class methods inherited from struct Number
si_prefix(magnitude : Int, prefixes = SI_PREFIXES) : Char | Nil
si_prefix
Macros inherited from struct Number
[](*nums)
[],
slice(*nums, read_only = false)
slice,
static_array(*nums)
static_array
Instance methods inherited from module Comparable(BigFloat)
<(other : T) : Bool
<,
<=(other : T)
<=,
<=>(other : T)
<=>,
==(other : T)
==,
>(other : T) : Bool
>,
>=(other : T)
>=,
clamp(min, max)clamp(range : Range) clamp
Instance methods inherited from module Steppable
step(*, to limit = nil, by step, exclusive : Bool = false, &) : Nilstep(*, to limit = nil, by step, exclusive : Bool = false) step
Instance methods inherited from module Comparable(Number)
<(other : T) : Bool
<,
<=(other : T)
<=,
<=>(other : T)
<=>,
==(other : T)
==,
>(other : T) : Bool
>,
>=(other : T)
>=,
clamp(min, max)clamp(range : Range) clamp
Instance methods inherited from struct Value
==(other : JSON::Any)==(other : YAML::Any)
==(other) ==, dup dup
Instance methods inherited from class Object
! : Bool
!,
!=(other)
!=,
!~(other)
!~,
==(other)
==,
===(other : JSON::Any)===(other : YAML::Any)
===(other) ===, =~(other) =~, as(type : Class) as, as?(type : Class) as?, class class, dup dup, hash(hasher)
hash hash, in?(collection : Object) : Bool
in?(*values : Object) : Bool in?, inspect(io : IO) : Nil
inspect : String inspect, is_a?(type : Class) : Bool is_a?, itself itself, nil? : Bool nil?, not_nil!(message)
not_nil! not_nil!, pretty_inspect(width = 79, newline = "\n", indent = 0) : String pretty_inspect, pretty_print(pp : PrettyPrint) : Nil pretty_print, responds_to?(name : Symbol) : Bool responds_to?, tap(&) tap, to_json(io : IO) : Nil
to_json : String to_json, to_pretty_json(indent : String = " ") : String
to_pretty_json(io : IO, indent : String = " ") : Nil to_pretty_json, to_s(io : IO) : Nil
to_s : String to_s, to_yaml(io : IO) : Nil
to_yaml : String to_yaml, try(&) try, unsafe_as(type : T.class) forall T unsafe_as
Class methods inherited from class Object
from_json(string_or_io, root : String)from_json(string_or_io) from_json, from_yaml(string_or_io : String | IO) from_yaml
Macros inherited from class Object
class_getter(*names, &block)
class_getter,
class_getter!(*names)
class_getter!,
class_getter?(*names, &block)
class_getter?,
class_property(*names, &block)
class_property,
class_property!(*names)
class_property!,
class_property?(*names, &block)
class_property?,
class_setter(*names)
class_setter,
def_clone
def_clone,
def_equals(*fields)
def_equals,
def_equals_and_hash(*fields)
def_equals_and_hash,
def_hash(*fields)
def_hash,
delegate(*methods, to object)
delegate,
forward_missing_to(delegate)
forward_missing_to,
getter(*names, &block)
getter,
getter!(*names)
getter!,
getter?(*names, &block)
getter?,
property(*names, &block)
property,
property!(*names)
property!,
property?(*names, &block)
property?,
setter(*names)
setter
Constructor Detail
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) # => 1311768467294899695Returns a read-only Slice of the limbs that make up this integer, which
is effectively abs.digits(2 ** N) where N is the number of bits in
LibGMP::MpLimb, except that an empty Slice is returned for zero.
This assumes GMP wasn't built with its experimental nails support: https://gmplib.org/manual/Low_002dlevel-Functions
num must be finite.
Returns a read-only Slice of the limbs that make up this integer, which
is effectively abs.digits(2 ** N) where N is the number of bits in
LibGMP::MpLimb, except that an empty Slice is returned for zero.
This assumes GMP wasn't built with its experimental nails support: https://gmplib.org/manual/Low_002dlevel-Functions
Returns a read-only Slice of the limbs that make up this integer, which
is effectively abs.digits(2 ** N) where N is the number of bits in
LibGMP::MpLimb, except that an empty Slice is returned for zero.
This assumes GMP wasn't built with its experimental nails support: https://gmplib.org/manual/Low_002dlevel-Functions
Returns a read-only Slice of the limbs that make up this integer, which
is effectively abs.digits(2 ** N) where N is the number of bits in
LibGMP::MpLimb, except that an empty Slice is returned for zero.
This assumes GMP wasn't built with its experimental nails support: https://gmplib.org/manual/Low_002dlevel-Functions
Instance Method Detail
Returns self modulo other.
This uses floored division.
See Int#/ for more details.
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 # ArgumentErrorReturns 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 # => 4000Returns 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 # => -4000Returns the absolute value of this number.
123.abs # => 123
-123.abs # => 123Returns 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 # => 3Returns the digits of a number in a given base. The digits are returned as an array with the least significant digit as the first array element.
12345.digits # => [5, 4, 3, 2, 1]
12345.digits(7) # => [4, 6, 6, 0, 5]
12345.digits(100) # => [45, 23, 1]
-12345.digits(7) # => ArgumentErrorReturns the greatest common divisor of self and other.
Returns the least common multiple of self and other.
Counts 1-bits in the binary representation of this integer.
5.popcount # => 2
-15.popcount # => 29Returns self remainder other.
This uses truncated division.
See Int#tdiv for more details.
Divides self by other using truncated division.
In truncated division, given two integers x and y:
q = x.tdiv(y)is rounded toward zeror = x.remainder(y)has the sign of the first argumentx == 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 -2Raises if other is 0, or if other is -1 and
self is signed and is the minimum value for that
integer type.
Converts self to BigDecimal.
require "big"
123456789012345678.to_big_dReturns a BigInt representing this integer.
require "big"
123.to_big_iReturns a BigRational representing this integer.
require "big"
123.to_big_rAppends a string representation of this integer to the given io.
base specifies the radix of the written string, and must be either 62 or
a number between 2 and 36. By default, digits above 9 are represented by
ASCII lowercase letters (a for 10, b for 11, etc.), but uppercase
letters may be used if upcase is true, unless base 62 is used. In that
case, lowercase letters are used for 10 to 35, and uppercase ones for 36 to
61, and upcase must be false.
precision specifies the minimum number of digits in the written string.
If there are fewer digits than this number, the string is left-padded by
zeros. If self and precision are both zero, returns an empty string.
Returns a string representation of this integer.
base specifies the radix of the returned string, and must be either 62 or
a number between 2 and 36. By default, digits above 9 are represented by
ASCII lowercase letters (a for 10, b for 11, etc.), but uppercase
letters may be used if upcase is true, unless base 62 is used. In that
case, lowercase letters are used for 10 to 35, and uppercase ones for 36 to
61, and upcase must be false.
precision specifies the minimum number of digits in the returned string.
If there are fewer digits than this number, the string is left-padded by
zeros. If self and precision are both zero, returns an empty string.
1234.to_s # => "1234"
1234.to_s(2) # => "10011010010"
1234.to_s(16) # => "4d2"
1234.to_s(16, upcase: true) # => "4D2"
1234.to_s(36) # => "ya"
1234.to_s(62) # => "jU"
1234.to_s(precision: 2) # => "1234"
1234.to_s(precision: 6) # => "001234"Returns the number of trailing 0-bits.