abstract struct Int

Overview

Int is the base type of all integer types.

There are four signed integer types: Int8, Int16, Int32 and Int64, being able to represent numbers of 8, 16, 32 and 64 bits respectively. There are four unsigned integer types: UInt8, UInt16, UInt32 and UInt64.

An integer literal is an optional #+ or #- sign, followed by a sequence of digits and underscores, optionally followed by a suffix. If no suffix is present, the literal's type is the lowest between Int32, Int64 and UInt64 in which the number fits:

1 # Int32

1_i8  # Int8
1_i16 # Int16
1_i32 # Int32
1_i64 # Int64

1_u8  # UInt8
1_u16 # UInt16
1_u32 # UInt32
1_u64 # UInt64

+10 # Int32
-20 # Int32

2147483648          # Int64
9223372036854775808 # UInt64

The underscore _ before the suffix is optional.

Underscores can be used to make some numbers more readable:

1_000_000 # better than 1000000

Binary numbers start with 0b:

0b1101 # == 13

Octal numbers start with 0o:

0o123 # == 83

Hexadecimal numbers start with 0x:

0xFE012D # == 16646445
0xfe012d # == 16646445

Included Modules

Direct Known Subclasses

Defined in:

int.cr
humanize.cr
time/span.cr:398
time/span.cr:566
big/big_int.cr
big/big_rational.cr
big/big_decimal.cr
json/to_json.cr

Constructors

Instance Method Summary

Instance methods inherited from module Comparable(BigDecimal)

<(other : T) <, <=(other : T) <=, <=>(other : T) <=>, ==(other : T) ==, >(other : T) >, >=(other : T) >=

Instance methods inherited from module Comparable(BigRational)

<(other : T) <, <=(other : T) <=, <=>(other : T) <=>, ==(other : T) ==, >(other : T) >, >=(other : T) >=

Instance methods inherited from module Comparable(BigInt)

<(other : T) <, <=(other : T) <=, <=>(other : T) <=>, ==(other : T) ==, >(other : T) >, >=(other : T) >=

Instance methods inherited from struct Number

*(other : Complex)
*(other : BigFloat) *, +(other : BigFloat)
+(other : Complex)
+ +, -(other : Complex)
-(other : BigFloat) -, /(other : Complex)
/(other : BigFloat) /, //(other : BigFloat) //, <=>(other : BigFloat)
<=>(other) : Int32? <=>, ==(other : Complex) ==, abs abs, abs2 abs2, cis cis, clamp(min, max)
clamp(range : Range) clamp, 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(precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, prefixes : Proc) : Nil
humanize(precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, &block) : String
humanize(io : IO, precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, &prefixes : Int32, Float64 -> Tuple(Int32, UNDERSCORE) | Tuple(Int32, UNDERSCORE, Bool)) : 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 : Proc) : Nil humanize, i i, round(digits = 0, base = 10) round, sign sign, significant(digits, base = 10) significant, step(*, to = nil, by = 1)
step(*, to = nil, by = 1, &block) step, to_big_f to_big_f, to_c to_c, to_yaml(yaml : YAML::Nodes::Builder) to_yaml, zero? : Bool zero?

Constructor methods inherited from struct Number

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) <, <=(other : T) <=, <=>(other : T) <=>, ==(other : T) ==, >(other : T) >, >=(other : T) >=

Instance methods inherited from module Comparable(Number)

<(other : T) <, <=(other : T) <=, <=>(other : T) <=>, ==(other : T) ==, >(other : T) >, >=(other : T) >=

Instance methods inherited from struct Value

==(other : JSON::Any)
==(other : YAML::Any)
==(other) ==, dup dup

Instance methods inherited from class Object

!=(other) !=, !~(other) !~, ==(other) ==, ===(other : JSON::Any)
===(other : YAML::Any)
===(other) ===, =~(other) =~, class class, dup dup, hash(hasher)
hash hash, inspect(io : IO) : Nil
inspect : String inspect, itself itself, not_nil! not_nil!, pretty_inspect(width = 79, newline = "\n", indent = 0) : String pretty_inspect, pretty_print(pp : PrettyPrint) : Nil pretty_print, tap(&block) tap, to_json(io : IO)
to_json to_json, to_pretty_json(indent : String = " ")
to_pretty_json(io : IO, indent : String = " ") to_pretty_json, to_s : String
to_s(io : IO) : Nil to_s, to_yaml(io : IO)
to_yaml to_yaml, try(&block) try, unsafe_as(type : T.class) forall T unsafe_as

Constructor methods inherited from class Object

from_json(string_or_io, root : String) : self
from_json(string_or_io) : self from_json, from_yaml(string_or_io : String | IO) : self from_yaml

Constructor Detail

def self.from_io(io : IO, format : IO::ByteFormat) : self #

Reads an integer from the given io in the given format.

See also: IO#read_bytes.


[View source]

Instance Method Detail

def %(other : BigInt) : BigInt #

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

Returns self modulo other.

This uses floored division.

See Int#/ for more details.


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

[View source]
def &**(exponent : Int) : self #

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.

Intermediate multiplication will wrap around silently in case of overflow.

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

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

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

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

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

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

[View source]
def **(exponent : Int) : self #

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 **(exponent : Float) : Float64 #

Returns the value of raising self to the power of exponent.

2 ** 3.0  # => 8.0
2 ** 0.0  # => 1.0
2 ** -1.0 # => 0.5

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

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

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

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

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

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

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

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

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

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

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

Divides self by other as floating point numbers and applies the floor function to that result.

The result will be of the same type as self.


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

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

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

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

Divides self by other using floored division.

In floored division, given two integers x and y:

  • q = x / y is rounded toward negative infinity
  • r = x % y has the sign of the second argument
  • x == q*y + r

For example:

 x     y     x / y     x % y
 5     3       1         2
-5     3      -2         1
 5    -3      -2        -1
-5    -3       1        -2

Raises if other is zero, or if other is -1 and self is signed and is the minimum value for that integer type.


[View source]
def <<(count : 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 : BigDecimal) #

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

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

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

[View source]
def ===(char : Char) #

[View source]
def >>(count : 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 abs #

[View source]
def bit(bit) #

Returns this number's bitth bit, starting with the least-significant.

11.bit(0) # => 1
11.bit(1) # => 1
11.bit(2) # => 0
11.bit(3) # => 1
11.bit(4) # => 0

[View source]
def bits_set?(mask) #

Returns true if all bits in mask are set on self.

0b0110.bits_set?(0b0110) # => true
0b1101.bits_set?(0b0111) # => false
0b1101.bits_set?(0b1100) # => true

[View source]
def ceil #

[View source]
def chr #

Returns a Char that has the unicode codepoint of self.

Raises ArgumentError if this integer's value doesn't fit a char's range (0..0x10ffff).

97.chr # => 'a'

[View source]
def day : Time::Span #

Returns a Time::Span of self days.


[View source]
def days : Time::Span #

Returns a Time::Span of self days.


[View source]
def divisible_by?(num) #

[View source]
def downto(to) #

[View source]
def downto(to, &block : self -> ) : Nil #

[View source]
def even? #

[View source]
def fdiv(other) #

[View source]
def floor #

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

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

[View source]
def hash(hasher) #

See Object#hash(hasher)


[View source]
def hour : Time::Span #

Returns a Time::Span of self hours.


[View source]
def hours : Time::Span #

Returns a Time::Span of self hours.


[View source]
def humanize_bytes(io : IO, precision : Int = 3, separator = '.', *, significant : Bool = true, format : BinaryPrefixFormat = :IEC) : Nil #

Prints this integer as a binary value in a human-readable format using a BinaryPrefixFormat.

Values with binary measurements such as computer storage (e.g. RAM size) are typically expressed using unit prefixes based on 1024 (instead of multiples of 1000 as per SI standard). This method by default uses the IEC standard prefixes (Ki, Mi, Gi, Ti, Pi, Ei, Zi, Yi) based on powers of 1000 (see BinaryPrefixFormat::IEC).

format can be set to use the extended range of JEDEC units (K, M, G, T, P, E, Z, Y) which equals to the prefixes of the SI system except for uppercase K and is based on powers of 1024 (see BinaryPrefixFormat::JEDEC).

1.humanize_bytes                        # => "1B"
1024.humanize_bytes                     # => "1.0kiB"
1536.humanize_bytes                     # => "1.5kiB"
524288.humanize_bytes                   # => "512kiB"
1073741824.humanize_bytes(format: :IEC) # => "1.0GiB"

See Number#humanize for more details on the behaviour and arguments.


[View source]
def humanize_bytes(precision : Int = 3, separator = '.', *, significant : Bool = true, format : BinaryPrefixFormat = :IEC) : String #

Prints this integer as a binary value in a human-readable format using a BinaryPrefixFormat.

Values with binary measurements such as computer storage (e.g. RAM size) are typically expressed using unit prefixes based on 1024 (instead of multiples of 1000 as per SI standard). This method by default uses the IEC standard prefixes (Ki, Mi, Gi, Ti, Pi, Ei, Zi, Yi) based on powers of 1000 (see BinaryPrefixFormat::IEC).

format can be set to use the extended range of JEDEC units (K, M, G, T, P, E, Z, Y) which equals to the prefixes of the SI system except for uppercase K and is based on powers of 1024 (see BinaryPrefixFormat::JEDEC).

1.humanize_bytes                        # => "1B"
1024.humanize_bytes                     # => "1.0kiB"
1536.humanize_bytes                     # => "1.5kiB"
524288.humanize_bytes                   # => "512kiB"
1073741824.humanize_bytes(format: :IEC) # => "1.0GiB"

See Number#humanize for more details on the behaviour and arguments.


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

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

[View source]
def microsecond : Time::Span #

Returns a Time::Span of self microseconds.


[View source]
def microseconds : Time::Span #

Returns a Time::Span of self microseconds.


[View source]
def millisecond : Time::Span #

Returns a Time::Span of self milliseconds.


[View source]
def milliseconds : Time::Span #

Returns a Time::Span of self milliseconds.


[View source]
def minute : Time::Span #

Returns a Time::Span of self minutes.


[View source]
def minutes : Time::Span #

Returns a Time::Span of self minutes.


[View source]
def modulo(other) #

[View source]
def month : Time::MonthSpan #

Returns a Time::MonthSpan of self months.


[View source]
def months : Time::MonthSpan #

Returns a Time::MonthSpan of self months.


[View source]
def nanosecond : Time::Span #

Returns a Time::Span of self nanoseconds.


[View source]
def nanoseconds : Time::Span #

Returns a Time::Span of self nanoseconds.


[View source]
def odd? #

[View source]
abstract def popcount #

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

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

[View source]
def pred #

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

Returns self remainder other.

This uses truncated division.

See Int#div for more details.


[View source]
def round #

[View source]
def second : Time::Span #

Returns a Time::Span of self seconds.


[View source]
def seconds : Time::Span #

Returns a Time::Span of self seconds.


[View source]
def succ #

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

Divides self by other using truncated division.

In truncated division, given two integers x and y:

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

[View source]
def times(&block : self -> ) : Nil #

[View source]
def to(to) #

[View source]
def to(to, &block : self -> ) : Nil #

[View source]
def to_big_d #

Converts self to BigDecimal.

require "big"
12123415151254124124.to_big_d

[View source]
def to_big_i : BigInt #

Returns a BigInt representing this integer.

require "big"

123.to_big_i

[View source]
def to_big_r #

Returns a BigRational representing this integer.

require "big"

123.to_big_r

[View source]
def to_io(io : IO, format : IO::ByteFormat) #

Writes this integer to the given io in the given format.

See also: IO#write_bytes.


[View source]
def to_json(json : JSON::Builder) #

[View source]
def to_s(base : Int, upcase : Bool = false) : String #

[View source]
def to_s(io : IO) : Nil #

[View source]
def to_s(base : Int, io : IO, upcase : Bool = false) : Nil #

[View source]
def to_s : String #

[View source]
abstract def trailing_zeros_count #

Returns the number of trailing 0-bits.


[View source]
def trunc #

[View source]
def upto(to) #

[View source]
def upto(to, &block : self -> ) : Nil #

[View source]
def week : Time::Span #

Returns a Time::Span of self weeks.


[View source]
def weeks : Time::Span #

Returns a Time::Span of self weeks.


[View source]
def year : Time::MonthSpan #

Returns a Time::MonthSpan of self years.


[View source]
def years : Time::MonthSpan #

Returns a Time::MonthSpan of self years.


[View source]
def ~ #

[View source]