# struct BigInt

- BigInt
- Int
- Number
- Value
- Object

##
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.cr
big/big_int.cr
big/json.cr
big/number.cr

##
Constructors

- .new(str : String, base = 10)

  Creates a `BigInt` with the value denoted by str in the given base.

- .new(ctx : YAML::ParseContext, node : YAML::Nodes::Node)
- .new(num : Int::Primitive)

  Creates a `BigInt` from the given num.

- .new(num : Float::Primitive)

  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.

- .new(num : BigFloat)

  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.

- .new(num : BigDecimal)

  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.

- .new(num : BigRational)

  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.

- .new(num : BigInt)

  Returns num.

- .new(pull : JSON::PullParser)
- .new

  Creates a `BigInt` with the value zero.

##
Class Method Summary

- .from_json_object_key?(key : String) : BigInt | Nil

##
Instance Method Summary

- #%(other : Int) : BigInt

  Returns `self` modulo 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 `self` to 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 `self` and other.

- #gcd(other : Int) : Int

  Returns the greatest common divisor of `self` and other.

- #lcm(other : BigInt) : BigInt

  Returns the least common multiple of `self` and other.

- #lcm(other : Int) : BigInt

  Returns the least common multiple of `self` and other.

- #popcount : Int

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

- #remainder(other : Int) : BigInt

  Returns `self` remainder other.

- #tdiv(other : Int) : BigInt

  Divides `self` by other using truncated division.

- #to_big_d : BigDecimal

  Converts `self` to `BigDecimal`.

- #to_big_f : BigFloat
- #to_big_i : BigInt

  Returns a `BigInt` representing this integer.

- #to_big_r : BigRational

  Returns a `BigRational` representing 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_json(json : JSON::Builder) : Nil
- #to_json_object_key : String
- #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, 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, 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 : 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

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

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

Creates a `BigInt` from the given num.

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

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

num must be finite.

def self.new(num : BigFloat) #

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

def self.new(num : BigDecimal) #

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

def self.new(num : BigRational) #

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

def self.new(num : BigInt) #

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

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

Creates a `BigInt` 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

Returns `self` modulo other.

This uses floored division.

See `Int#/` 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 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

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

def <=>(other : BigInt) #
def <=>(other : Int) #
def <=>(other : Float::Primitive) #
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

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 Number

Returns the absolute value of this number.

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

def bit(bit : Int) #
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

def clone #
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 of `self` and other.

def gcd(other : Int) : Int #

Returns the greatest common divisor of `self` and other.

def lcm(other : BigInt) : BigInt #

Returns the least common multiple of `self` and other.

def lcm(other : Int) : BigInt #

Returns the least common multiple of `self` and other.

def popcount : Int #
Description copied from struct Int

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

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

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

Returns `self` remainder other.

This uses truncated division.

See `Int#tdiv` for more details.

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.

def to_big_d : BigDecimal #
Description copied from struct Int

Converts `self` to `BigDecimal`.

    require "big"
    123456789012345678.to_big_d

def to_big_f : BigFloat #
def to_big_i : BigInt #
Description copied from struct Int

Returns a `BigInt` representing this integer.

    require "big"

    123.to_big_i

def to_big_r : BigRational #
Description copied from struct Int

Returns a `BigRational` 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 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.

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"

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 #
def trailing_zeros_count : Int #
Description copied from struct Int

Returns the number of trailing `0`-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) #
def unsafe_truncated_divmod(number : Int) #
def unsafe_truncated_mod(other : BigInt) : BigInt #
def unsafe_truncated_mod(other : Int) : BigInt #