12 KiB
Integers
Tomo has five types of integers:
Int: the default integer type, which uses an efficient tagged 29-bit integer value for small numbers, and falls back to a bigint implementation when values are too large to fit in 29-bits. The bigint implementation uses the GNU MP library. These integers are fast for small numbers and guaranteed to always be correct and never overflow.Int8/Int16/Int32/Int64: Fixed-size integers that take upNbits. These integers must be explicitly constructed using their type name (e.g.Int64(5)) and are subject to overflowing on arithmetic operations. If an overflow occurs, a runtime error will be raised.- In cases where it is possible to infer that an integer literal should be
used as a fixed-size integer, the literal will be converted at compile time
to the appropriate fixed-size integer type and checked to ensure that it
can fit in the needed size. For example, if you declare a variable as
x := Int64(0)and later dox + 1, it's inferred that the1is a 64-bit integer literal.
Runtime conversion between integer types (casting) can be done explicitly by
calling the target type as a function: Int32(x). For fixed-width types, the
conversion function also accepts a second parameter, truncate. If truncate
is no (the default), conversion will create a runtime error if the value is
too large to fit in the target type. If truncate is yes, then the resulting
value will be a truncated form of the input value.
Integers support the standard math operations (x+y, x-y, x*y, x/y) as
well as powers/exponentiation (x^y), modulus (x mod y and x mod1 y), and
bitwise operations: x and y, x or y, x xor y, x << y, x >> y, x >>> y (unsigned right shift), and x <<< y (unsighted left shift). The operators
and, or, and xor are bitwise, not logical operators.
Integer Literals
The simplest form of integer literal is a string of digits, which is inferred
to have type Int (unbounded size).
>>> 123456789012345678901234567890
= 123456789012345678901234567890 : Int
Underscores may also be used to visually break up the integer for readability:
a_million := 1_000_000
Hexadecimal, octal, and binary integer literals are also supported:
hex := 0x123F
octal := 0o644
binary := 0b10101
For fixed-sized integers, use the type's name as a constructor:
my_int64 := Int64(12345)
my_int32 := Int32(12345)
my_int16 := Int32(12345)
my_int8 := Int32(123)
A compiler error will be raised if you attempt to construct a value that cannot
fit in the specified integer size (e.g. Int8(99999)).
A Note on Division
Unlike some other languages (including C), Tomo uses a mathematically consistent definition of division called Euclidean Division that upholds the following invariants for all inputs:
quotient := numerator / denominator
remainder := numerator mod denominator
# Modulus always gives a non-negative result:
>> remainder >= 0
= yes
# The numerator can be reconstructed sensibly:
>> numerator == denominator * quotient + remainder
= yes
Importantly, these invariants hold for both positive and negative numerators and denominators. When the numerator and denominator are both positive, you will not notice any difference from how integer division and modulus work in other programming languages. However, the behavior is a bit different when negative numbers are involved. Integer division rounds down instead of rounding towards zero, and modulus never gives negative results:
>> quotient := -1 / 5
= -1
>> remainder := -1 mod 5
= 4
>> -1 == 5 * -1 + 4
= yes
>> quotient := 16 / -5
= -3
>> remainder := -1 mod 5
= 1
>> 16 == -5 * -3 + 1
= yes
Integer Functions
Each integer type has its own version of the following functions. Functions
can be called either on the type itself: Int.sqrt(x) or as a method call:
x:sqrt(). Method call syntax is preferred.
func abs(x: Int -> Int)func choose(n: Int, k: Int -> Int)func clamped(x, low, high: Int -> Int)func factorial(n: Int -> Text)func format(i: Int, digits: Int = 0 -> Text)func hex(i: Int, digits: Int = 0, uppercase: Bool = yes, prefix: Bool = yes -> Text)func is_prime(x: Int, reps: Int = 50 -> Bool)func next_prime(x: Int -> Int)func octal(i: Int, digits: Int = 0, prefix: Bool = yes -> Text)func onward(first: Int, step: Int = 1 -> Text)func parse(text: Text -> Int?)func prev_prime(x: Int -> Int)func sqrt(x: Int -> Int)func to(first: Int, last: Int, step : Int? = none:Int -> func(->Int?))
abs
Calculates the absolute value of an integer.
func abs(x: Int -> Int)
x: The integer whose absolute value is to be calculated.
Returns:
The absolute value of x.
Example:
>> -10:abs()
= 10
choose
Computes the binomial coefficient of the given numbers (the equivalent of n
choose k in combinatorics). This is equal to n:factorial()/(k:factorial() * (n-k):factorial()).
func choose(n: Int, k: Int -> Int)
n: The number of things to choose from.k: The number of things to be chosen.
Returns:
The binomial coefficient, equivalent to the number of ways to uniquely choose
k objects from among n objects, ignoring order.
Example:
>> 4:choose(2)
= 6
clamped
Returns the given number clamped between two values so that it is within that range.
func clamped(x, low, high: Int -> Int)
x: The integer to clamp.low: The lowest value the result can take.high: The highest value the result can take.
Returns:
The first argument clamped between the other two arguments.
Example:
>> 2:clamped(5, 10)
= 5
factorial
Computes the factorial of an integer.
func factorial(n: Int -> Text)
n: The integer to compute the factorial of.
Returns:
The factorial of the given integer.
Example:
>> 10:factorial()
= 3628800
format
Formats an integer as a string with a specified number of digits.
func format(i: Int, digits: Int = 0 -> Text)
i: The integer to be formatted.digits: The minimum number of digits to which the integer should be padded. Default is0.
Returns:
A string representation of the integer, padded to the specified number of digits.
Example:
>> 42:format(digits=5)
= "00042"
hex
Converts an integer to its hexadecimal representation.
func hex(i: Int, digits: Int = 0, uppercase: Bool = yes, prefix: Bool = yes -> Text)
i: The integer to be converted.digits: The minimum number of digits in the output string. Default is0.uppercase: Whether to use uppercase letters for hexadecimal digits. Default isyes.prefix: Whether to include a "0x" prefix. Default isyes.
Returns:
The hexadecimal string representation of the integer.
Example:
>> 255:hex(digits=4, uppercase=yes, prefix=yes)
= "0x00FF"
is_prime
Determines if an integer is a prime number.
Note: This function is probabilistic. With the default arguments, the chances of getting an incorrect answer are astronomically small (on the order of 10^(-30)). See the GNU MP docs for more details.
func is_prime(x: Int, reps: Int = 50 -> Bool)
x: The integer to be checked.reps: The number of repetitions for primality tests. Default is50.
Returns:
yes if x is a prime number, no otherwise.
Example:
>> 7:is_prime()
= yes
>> 6:is_prime()
= no
next_prime
Finds the next prime number greater than the given integer.
Note: This function is probabilistic, but the chances of getting an incorrect answer are astronomically small (on the order of 10^(-30)). See the GNU MP docs for more details.
func next_prime(x: Int -> Int)
x: The integer after which to find the next prime.
Returns:
The next prime number greater than x.
Example:
>> 11:next_prime()
= 13
octal
Converts an integer to its octal representation.
func octal(i: Int, digits: Int = 0, prefix: Bool = yes -> Text)
i: The integer to be converted.digits: The minimum number of digits in the output string. Default is0.prefix: Whether to include a "0o" prefix. Default isyes.
Returns:
The octal string representation of the integer.
Example:
>> 64:octal(digits=4, prefix=yes)
= "0o0100"
onward
Return an iterator that counts infinitely from the starting integer (with an optional step size).
func onward(first: Int, step: Int = 1 -> Text)
first: The starting integer.step: The increment step size (default: 1).
Returns:
An iterator function that counts onward from the starting integer.
Example:
nums := &[:Int]
for i in 5:onward():
nums:insert(i)
stop if i == 10
>> nums[]
= [5, 6, 7, 8, 9, 10]
parse
Converts a text representation of an integer into an integer.
func parse(text: Text -> Int?)
text: The text containing the integer.
Returns:
The integer represented by the text. If the given text contains a value outside
of the representable range or if the entire text can't be parsed as an integer,
none will be returned.
Example:
>> Int.parse("123")
= 123 : Int?
>> Int.parse("0xFF")
= 255 : Int?
# Can't parse:
>> Int.parse("asdf")
= none : Int?
# Outside valid range:
>> Int8.parse("9999999")
= none : Int8?
prev_prime
Finds the previous prime number less than the given integer.
If there is no previous prime number (i.e. if a number less than 2 is
provided), then the function will create a runtime error.
Note: This function is probabilistic, but the chances of getting an incorrect answer are astronomically small (on the order of 10^(-30)). See the GNU MP docs for more details.
func prev_prime(x: Int -> Int)
x: The integer before which to find the previous prime.
Returns:
The previous prime number less than x.
Example:
>> 11:prev_prime()
= 7
sqrt
Calculates the square root of an integer.
func sqrt(x: Int -> Int)
x: The integer whose square root is to be calculated.
Returns:
The integer part of the square root of x.
Example:
>> 16:sqrt()
= 4
>> 17:sqrt()
= 4
to
Returns an iterator function that iterates over the range of numbers specified. Iteration is assumed to be nonempty and
func to(first: Int, last: Int, step : Int? = none:Int -> func(->Int?))
first: The starting value of the range.last: The ending value of the range.step: An optional step size to use. If unspecified ornone, the step will be inferred to be+1iflast >= first, otherwise-1.
Returns:
An iterator function that returns each integer in the given range (inclusive).
Example:
>> 2:to(5)
= func(->Int?)
>> [x for x in 2:to(5)]
= [2, 3, 4, 5]
>> [x for x in 5:to(2)]
= [5, 4, 3, 2]
>> [x for x in 2:to(5, step=2)]
= [2, 4]