struct BigInt

Overview

ABigInt can represent arbitrarily large integers.

It is implemented under the hood withGMP.

NOTE To useBigInt, you must explicitly import it withrequire "big"

Included Modules

Defined in:

big.cr
big/big_int.cr
big/json.cr
big/number.cr

Constructors

Class Method Summary

Instance Method Summary

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) : Int32
<=>(other : BigRational) : Int32
<=>(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, unit_separator = nil, format : BinaryPrefixFormat = :IEC) : Nil
humanize_bytes(precision : Int = 3, separator = '.', *, significant : Bool = true, unit_separator = nil, 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, tdivmod(other : Int) tdivmod, 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, unit_separator = nil, prefixes : Indexable = SI_PREFIXES) : Nil
humanize(io : IO, precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, unit_separator = nil, prefixes : Proc) : Nil
humanize(precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, unit_separator = nil, prefixes = SI_PREFIXES) : String
humanize(io : IO, precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, unit_separator = nil, &prefixes : Int32, Float64 -> Tuple(Int32, _) | Tuple(Int32, _, Bool)) : Nil
humanize(precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, unit_separator = nil, &) : String
humanize(precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, unit_separator = nil, 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, &) : Nil
step(*, 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 : Log::Metadata::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 : String | IO, root : String)
from_json(string_or_io : String | 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

def self.from_digits(digits : Enumerable(Int), base : Int = 10) : self #

Returns a number for givendigits andbase. The digits are expected as anEnumerable with the least significant digit as the first element.

base must not be less than 2.

All digits must be within0...base.


def self.new(str : String, base : Int32 = 10) #

Creates aBigInt with the value denoted bystr in the givenbase.

RaisesArgumentError 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

def self.new(ctx : YAML::ParseContext, node : YAML::Nodes::Node) : self #

def self.new(num : Int::Primitive) : self #

Creates aBigInt from the givennum.


def self.new(num : Float::Primitive) #

Returns a read-onlySlice of the limbs that make up this integer, which is effectivelyabs.digits(2 ** N) whereN is the number of bits in LibGMP::MpLimb, except that an emptySlice 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.


def self.new(num : BigFloat) : self #

Returns a read-onlySlice of the limbs that make up this integer, which is effectivelyabs.digits(2 ** N) whereN is the number of bits in LibGMP::MpLimb, except that an emptySlice is returned for zero.

This assumes GMP wasn't built with its experimental nails support: https://gmplib.org/manual/Low_002dlevel-Functions


def self.new(num : BigDecimal) : self #

Returns a read-onlySlice of the limbs that make up this integer, which is effectivelyabs.digits(2 ** N) whereN is the number of bits in LibGMP::MpLimb, except that an emptySlice is returned for zero.

This assumes GMP wasn't built with its experimental nails support: https://gmplib.org/manual/Low_002dlevel-Functions


def self.new(num : BigRational) : self #

Returns a read-onlySlice of the limbs that make up this integer, which is effectivelyabs.digits(2 ** N) whereN is the number of bits in LibGMP::MpLimb, except that an emptySlice is returned for zero.

This assumes GMP wasn't built with its experimental nails support: https://gmplib.org/manual/Low_002dlevel-Functions


def self.new(num : BigInt) : self #

Returnsnum. Useful for generic code that doesT.new(...) withT being aNumber.


def self.new(pull : JSON::PullParser) : self #

def self.new #

Creates aBigInt with the value zero.

require "big"

BigInt.new # => 0

Class Method Detail

def self.from_json_object_key?(key : String) : BigInt | Nil #

Instance Method Detail

def %(other : Int) : BigInt #
Description copied from struct Int

Returnsself moduloother.

This uses floored division.

SeeInt#/ for more details.


def &(other : BigInt) : BigInt #

def &(other : Int) : BigInt #

def &*(other) : BigInt #

def &+(other) : BigInt #

def &-(other) : BigInt #

def *(other : BigInt) : BigInt #

def *(other : Int) : BigInt #

def **(other : Int) : BigInt #
Description copied from struct Int

Returns the value of raisingself to the power ofexponent.

RaisesArgumentError ifexponent is negative: if this is needed, either use a float base or a float exponent.

RaisesOverflowError in case of overflow.

2 ** 3  # => 8
2 ** 0  # => 1
2 ** -1 # ArgumentError

def +(other : BigInt) : BigInt #

def +(other : Int) : BigInt #

def -(other : BigInt) : BigInt #

def -(other : Int) : BigInt #

def - : BigInt #

def /(other : BigInt) : BigFloat #

def /(other : BigDecimal) : BigDecimal #

def /(other : BigRational) : BigRational #

def /(other : Int8) : BigFloat #

def /(other : UInt8) : BigFloat #

def /(other : Int16) : BigFloat #

def /(other : UInt16) : BigFloat #

def /(other : Int32) : BigFloat #

def /(other : UInt32) : BigFloat #

def /(other : Int64) : BigFloat #

def /(other : UInt64) : BigFloat #

def /(other : Int128) : BigFloat #

def /(other : UInt128) : BigFloat #

def /(other : Float32) : BigFloat #

def /(other : Float64) : BigFloat #

def //(other : Int) : BigInt #

def <<(other : Int) : BigInt #
Description copied from struct Int

Returns the result of shifting this number's bitscount positions to the left.

  • Ifcount is greater than the number of bits of this integer, returns 0
  • Ifcount is negative, a right shift is performed
8000 << 1  # => 16000
8000 << 2  # => 32000
8000 << 32 # => 0
8000 << -1 # => 4000

def <=>(other : BigInt) #

def <=>(other : Int) #

def <=>(other : Float::Primitive) : Int32 | Nil #

def >>(other : Int) : BigInt #
Description copied from struct Int

Returns the result of shifting this number's bitscount positions to the right. Also known as arithmetic right shift.

  • Ifcount is greater than the number of bits of this integer, returns 0
  • Ifcount is negative, a left shift is performed
8000 >> 1  # => 4000
8000 >> 2  # => 2000
8000 >> 32 # => 0
8000 >> -1 # => 16000

-8000 >> 1 # => -4000

def ^(other : BigInt) : BigInt #

def ^(other : Int) : BigInt #

def |(other : BigInt) : BigInt #

def |(other : Int) : BigInt #

def ~ : BigInt #

def abs : BigInt #
Description copied from struct Int

Returns the absolute value of this number.

123.abs  # => 123
-123.abs # => 123

def bit(bit : Int) : Int32 #

def bit_length : Int32 #
Description copied from struct Int

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 returnsceil(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

def clone : BigInt #

def digits(base = 10) : Array(Int32) #
Description copied from struct Int

Returns 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) # => ArgumentError

def divisible_by?(number : BigInt) : Bool #

def divisible_by?(number : Int) : Bool #

def divmod(number : Int) : Tuple(BigInt, BigInt) #

def factorial : BigInt #

def gcd(other : BigInt) : BigInt #

Returns the greatest common divisor ofself andother.


def gcd(other : Int) : Int #

Returns the greatest common divisor ofself andother.


def lcm(other : BigInt) : BigInt #

Returns the least common multiple ofself andother.


def lcm(other : Int) : BigInt #

Returns the least common multiple ofself andother.


def popcount : Int #
Description copied from struct Int

Counts1-bits in the binary representation of this integer.

5.popcount   # => 2
-15.popcount # => 29

def remainder(other : Int) : BigInt #
Description copied from struct Int

Returnsself remainderother.

This uses truncated division.

SeeInt#tdiv for more details.


def tdiv(other : Int) : BigInt #
Description copied from struct Int

Dividesself byother 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 x
  • 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 ifother is0, or ifother is-1 and self is signed and is the minimum value for that integer type.


def to_big_d : BigDecimal #
Description copied from struct Int

Convertsself toBigDecimal.

require "big"
123456789012345678.to_big_d

def to_big_f : BigFloat #

def to_big_i : BigInt #
Description copied from struct Int

Returns aBigInt representing this integer.

require "big"

123.to_big_i

def to_big_r : BigRational #
Description copied from struct Int

Returns aBigRational representing this integer.

require "big"

123.to_big_r

def to_f : Float64 #

def to_f! #

def to_f32 : Float32 #

def to_f32! #

def to_f64 : Float64 #

def to_f64! #

def to_i : Int32 #

def to_i! : Int32 #

def to_i128 : Int128 #

def to_i128! : Int128 #

def to_i16 : Int16 #

def to_i16! : Int16 #

def to_i32 : Int32 #

def to_i32! : Int32 #

def to_i64 : Int64 #

def to_i64! : Int64 #

def to_i8 : Int8 #

def to_i8! : Int8 #

def to_json(json : JSON::Builder) : Nil #

def to_json_object_key : String #

def to_s(io : IO, base : Int = 10, *, precision : Int = 1, upcase : Bool = false) : Nil #
Description copied from struct Int

Appends a string representation of this integer to the givenio.

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 ifupcase istrue, unless base 62 is used. In that case, lowercase letters are used for 10 to 35, and uppercase ones for 36 to 61, andupcase must befalse.

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. Ifself andprecision are both zero, returns an empty string.


def to_s(base : Int = 10, *, precision : Int = 1, upcase : Bool = false) : String #
Description copied from struct Int

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 ifupcase istrue, unless base 62 is used. In that case, lowercase letters are used for 10 to 35, and uppercase ones for 36 to 61, andupcase must befalse.

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. Ifself andprecision 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"

def to_u : UInt32 #

def to_u! : UInt32 #

def to_u128 : UInt128 #

def to_u128! : UInt128 #

def to_u16 : UInt16 #

def to_u16! : UInt16 #

def to_u32 : UInt32 #

def to_u32! : UInt32 #

def to_u64 : UInt64 #

def to_u64! : UInt64 #

def to_u8 : UInt8 #

def to_u8! : UInt8 #

def to_unsafe : Pointer(LibGMP::MPZ) #

def trailing_zeros_count : Int #
Description copied from struct Int

Returns the number of trailing0-bits.


def unsafe_floored_div(other : BigInt) : BigInt #

def unsafe_floored_div(other : Int) : BigInt #

def unsafe_floored_divmod(number : BigInt) : Tuple(BigInt, BigInt) #

def unsafe_floored_divmod(number : Int) : Tuple(BigInt, BigInt) #

def unsafe_floored_mod(other : BigInt) : BigInt #

def unsafe_floored_mod(other : Int) : BigInt #

def unsafe_truncated_div(other : BigInt) : BigInt #

def unsafe_truncated_div(other : Int) : BigInt #

def unsafe_truncated_divmod(number : BigInt) : Tuple(BigInt, BigInt) #

def unsafe_truncated_divmod(number : Int) #

def unsafe_truncated_mod(other : BigInt) : BigInt #

def unsafe_truncated_mod(other : Int) : BigInt #