struct BigInt

Overview

A BigInt can represent arbitrarily large integers.

It is implemented under the hood with GMP.

Included Modules

Defined in:

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

Constructors

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 : BigRational) : BigRational
-(other : BigDecimal) : BigDecimal
-
, /(other : BigRational) /, //(other : Int::Primitive) //, <<(count : Int) <<, <=>(other : BigInt)
<=>(other : Int) : Int32
<=>(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
, hash(hasher) hash, 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
, 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) 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 : BigFloat)
<=>(other) : Int32?
<=>
, ==(other : Complex) ==, abs : self abs, abs2 abs2, cis : Complex cis, divmod(number) divmod, format(io : IO, separator = '.', delimiter = ',', decimal_places : Int? = nil, *, group : Int = 3, only_significant : Bool = false) : Nil
format(separator = '.', delimiter = ',', decimal_places : Int? = nil, *, group : Int = 3, only_significant : Bool = false) : String
format
, 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, 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? si_prefix

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 : 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! 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

Constructor Detail

def self.new(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

[View source]
def self.new(num : Int::Signed) #

Creates a BigInt from the given num.


[View source]
def self.new(num : Int::Unsigned) #

Creates a BigInt from the given num.


[View source]
def self.new(num : Float::Primitive) #

Creates a BigInt from the given num.


[View source]
def self.new(num : BigFloat) #

Creates a BigInt from the given num.


[View source]
def self.new(num : BigDecimal) #

Creates a BigInt from the given num.


[View source]
def self.new(num : BigRational) #

Creates a BigInt from the given num.


[View source]
def self.new(num : BigInt) #

Returns num. Useful for generic code that does T.new(...) with T being a Number.


[View source]
def self.new #

Creates a BigInt with the value zero.

require "big"

BigInt.new # => 0

[View source]

Instance Method Detail

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

Returns self modulo other.

This uses floored division.

See Int#/ for more details.


[View source]
def &(other : Int) : BigInt #

[View source]
def &*(other) : BigInt #

[View source]
def &+(other) : BigInt #

[View source]
def &-(other) : BigInt #

[View source]
def *(other : BigInt) : BigInt #

[View source]
def *(other : LibGMP::IntPrimitiveSigned) : BigInt #

[View source]
def *(other : LibGMP::IntPrimitiveUnsigned) : BigInt #

[View source]
def *(other : Int) : BigInt #

[View source]
def **(other : Int) : BigInt #
Description copied from struct Int

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

[View source]
def +(other : BigInt) : BigInt #

[View source]
def +(other : Int) : BigInt #

[View source]
def -(other : BigInt) : BigInt #

[View source]
def -(other : Int) : BigInt #

[View source]
def - : BigInt #

[View source]
def /(other : BigInt) : BigFloat #

[View source]
def /(other : BigDecimal) : BigDecimal #

[View source]
def /(other : BigRational) : BigRational #

[View source]
def /(other : Int8) : BigFloat #

[View source]
def /(other : UInt8) : BigFloat #

[View source]
def /(other : Int16) : BigFloat #

[View source]
def /(other : UInt16) : BigFloat #

[View source]
def /(other : Int32) : BigFloat #

[View source]
def /(other : UInt32) : BigFloat #

[View source]
def /(other : Int64) : BigFloat #

[View source]
def /(other : UInt64) : BigFloat #

[View source]
def /(other : Int128) : BigFloat #

[View source]
def /(other : UInt128) : BigFloat #

[View source]
def /(other : Float32) : BigFloat #

[View source]
def /(other : Float64) : BigFloat #

[View source]
def //(other : Int::Unsigned) : BigInt #

[View source]
def //(other : Int) : BigInt #

[View source]
def <<(other : Int) : BigInt #
Description copied from struct Int

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

[View source]
def <=>(other : BigInt) #

[View source]
def <=>(other : Int::Signed) #

[View source]
def <=>(other : Int::Unsigned) #

[View source]
def <=>(other : Float) #
Description copied from module Comparable(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]

[View source]
def >>(other : Int) : BigInt #
Description copied from struct Int

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

[View source]
def ^(other : Int) : BigInt #

[View source]
def abs : BigInt #
Description copied from struct Number

Returns the absolute value of this number.

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

[View source]
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 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

[View source]
def clone #

[View source]
def divmod(number : BigInt) : Tuple(BigInt, BigInt) #

[View source]
def divmod(number : LibGMP::ULong) #

[View source]
def divmod(number : Int::Signed) : Tuple(BigInt, BigInt) #

[View source]
def divmod(number : Int::Unsigned) #

[View source]
def factorial : BigInt #

[View source]
def gcd(other : BigInt) : BigInt #

Returns the greatest common divisor of self and other.


[View source]
def gcd(other : Int) : Int #

Returns the greatest common divisor of self and other.


[View source]
def hash(hasher) #

TODO check hash equality for numbers >= 2**63


[View source]
def lcm(other : BigInt) : BigInt #

Returns the least common multiple of self and other.


[View source]
def lcm(other : Int) : BigInt #

Returns the least common multiple of self and other.


[View source]
def popcount : Int #
Description copied from struct Int

Counts 1-bits in the binary representation of this integer.

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

[View source]
def remainder(other : Int) : BigInt #
Description copied from struct Int

Returns self remainder other.

This uses truncated division.

See Int#tdiv for more details.


[View source]
def tdiv(other : Int) : BigInt #
Description copied from struct Int

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.


[View source]
def to_big_d : BigDecimal #
Description copied from struct Int

Converts self to BigDecimal.

require "big"
12123415151254124124.to_big_d

[View source]
def to_big_f : BigFloat #

[View source]
def to_big_i : BigInt #
Description copied from struct Int

Returns a BigInt representing this integer.

require "big"

123.to_big_i

[View source]
def to_big_r : BigRational #
Description copied from struct Int

Returns a BigRational representing this integer.

require "big"

123.to_big_r

[View source]
def to_f : Float64 #

[View source]
def to_f! #

[View source]
def to_f32 : Float32 #

[View source]
def to_f32! #

[View source]
def to_f64 : Float64 #

[View source]
def to_f64! #

[View source]
def to_i : Int32 #

[View source]
def to_i! #

[View source]
def to_i16 : Int16 #

[View source]
def to_i16! : Int16 #

[View source]
def to_i32 : Int32 #

[View source]
def to_i32! : Int32 #

[View source]
def to_i64 : Int64 #

[View source]
def to_i64! : Int64 #

[View source]
def to_i8 : Int8 #

[View source]
def to_i8! : Int8 #

[View source]
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 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.


[View source]
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 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"

[View source]
def to_u : UInt32 #

[View source]
def to_u! #

[View source]
def to_u16 : UInt16 #

[View source]
def to_u16! : UInt16 #

[View source]
def to_u32 : UInt32 #

[View source]
def to_u32! : UInt32 #

[View source]
def to_u64 : UInt64 #

[View source]
def to_u64! : UInt64 #

[View source]
def to_u8 : UInt8 #

[View source]
def to_u8! : UInt8 #

[View source]
def to_unsafe #

[View source]
def trailing_zeros_count : Int #
Description copied from struct Int

Returns the number of trailing 0-bits.


[View source]
def unsafe_floored_div(other : BigInt) : BigInt #

[View source]
def unsafe_floored_div(other : Int) : BigInt #

[View source]
def unsafe_floored_divmod(number : BigInt) : Tuple(BigInt, BigInt) #

[View source]
def unsafe_floored_divmod(number : LibGMP::ULong) : Tuple(BigInt, BigInt) #

[View source]
def unsafe_floored_mod(other : BigInt) : BigInt #

[View source]
def unsafe_floored_mod(other : Int) : BigInt #

[View source]
def unsafe_truncated_div(other : BigInt) : BigInt #

[View source]
def unsafe_truncated_div(other : Int) : BigInt #

[View source]
def unsafe_truncated_divmod(number : BigInt) #

[View source]
def unsafe_truncated_divmod(number : LibGMP::ULong) #

[View source]
def unsafe_truncated_mod(other : BigInt) : BigInt #

[View source]
def unsafe_truncated_mod(other : LibGMP::IntPrimitive) : BigInt #

[View source]
def unsafe_truncated_mod(other : Int) : BigInt #

[View source]
def |(other : Int) : BigInt #

[View source]
def ~ : BigInt #

[View source]