6.24 Numbers🔗ℹ

Numbers are comparable, which means that generic operations like < and > work on numbers, while specialized operations like .< and .> work only on numbers.

> 5 is_a Number

#true

> 5/2 is_a Number

#true

> #inf is_a Number

#true

> math.sqrt(-1) is_a Number

#true

> 5 is_a Exact

#true

> 5.0 is_a Inexact

#true

> 5.0 is_a Exact

#false

> 5 is_a Inexact

#false

The Int.in annotation constraints a integers to be within the given range, where each end of the range is inclusive by default, but ~inclusive or ~exclusive can be specified.

> 5 is_a Int

#true

> 5 is_a PosInt

#true

> -5 is_a NegInt

#true

> 0 is_a NonnegInt

#true

> 0 is_a Int.in(0, 1 ~exclusive)

#true

> 1 is_a Int.in(0, 1 ~exclusive)

#false

The Real.at_least, Real.above, Real.below, and Real.at_most annotations furher constrain the number to be equal to or greater than, greater than, less then, or equal to or less than the given number, respectively.

The Real.in annotation constraints a real number to be within the given range, where each end of the range is inclusive by default, but ~inclusive or ~exclusive can be specified.

> 5 is_a Real

#true

> 5.0 is_a Real

#true

> 5.1 is_a Real

#true

> #inf is_a Real

#true

> math.sqrt(-1) is_a Real

#false

> 1 is_a Real.at_least(1)

#true

> 1 is_a Real.above(1)

#false

> 0 is_a Real.in(0, 1 ~exclusive)

#true

> 1 is_a Real.in(0, 1 ~exclusive)

#false

> 5 is_a Rational

#true

> #inf is_a Rational

#false

> 5 is_a Integral

#true

> 5.0 is_a Integral

#true

> 5.1 is_a Integral

#false

> 5.0 is_a Flonum

#true

> #inf is_a Flonum

#true

> 5 is_a Flonum

#false

> 5/2 is_a Flonum

#false

> 5 is_a Byte

#true

> 256 is_a Byte

#false

Note that forms like +1, -1, and 1/2 are immediate numbers, as opposed to uses of the +, -, and / operators.

> 1+2
3
> 3-4
-1
> - 4
-4
> 5*6
30
> 8 / 2
4
> 7 / 2
7/2
> 7.0/2
3.5
> 1+2*3
7
> 2**10
1024
> 6 / 2 * 3
9

> 7 div 5
1
> 7 rem 5
2
> 7 mod 5
2
> 7 mod -5
-3

> 1 .< 2

#true

> 3 .>= 3.0

#true

> math.abs(-1.5)
1.5
> math.min(1, 2)
1
> math.max(1, 2)
2
> math.floor(1.5)
1.0
> math.ceiling(1.5)
2.0
> math.round(1.5)
2.0
> math.sqrt(4)
2
> math.cos(3.14)
-0.9999987317275395
> math.sin(3.14)
0.0015926529164868282
> math.tan(3.14 / 4)
0.9992039901050427
> math.acos(1)
0
> math.asin(1)
1.5707963267948966
> math.atan(0.5)
0.4636476090008061
> math.atan(1, 2)
0.4636476090008061
> math.log(2.718)
0.999896315728952
> math.exp(1)
2.718281828459045

> math.exact(5.0)

5

> math.inexact(5)

5.0

> math.real_part(5)
5
> math.real_part(math.sqrt(-1))
0
> math.imag_part(math.sqrt(-1))
1
> math.magnitude(1 + math.sqrt(-1))
1.4142135623730951
> math.angle(1 + math.sqrt(-1))
0.7853981633974483

> math.numerator(256/6)

128

> math.denominator(256/6)

3

> math.denominator(0.125)

8.0

For non-integer arguments, the result for math.gcd is the greatest common divisor of the numerators divided by the least common multiple of the denominators. The result for math.lcm for non-integer arguments is the absolute value of the product divided by the math.gcd of the arguments.

If no arguments are provided, the result of math.gcd is 0 and the result of math.lcm is 1. If all arguments for math.gcd are zero, the result is zero. If any argument for math.lcm is zero, the result is zero, and the result is exact 0 if any argument is exact 0.

> math.gcd(2, 3, 7)
1
> math.gcd(4, 2, 16)
2
> math.lcm(2, 3, 7)
42
> math.lcm(4, 10, 2)
20
> math.gcd()
0
> math.lcm()
1

When called with n, returns a random integer between 0 (inclusive) and n (exclusive).

When called with start and end, returns a random integer between start (inclusive) and end (exclusive).

See also Random.random.

> math.random()

0.5348255534758128

> math.random(17)

13

> math.random(1, 42)

21

> math.sum()

0

> math.sum(1, 2, 3, 4)

10

> math.product(1, 2, 3, 4)

24

> math.less()

#true

> math.less(1)

#true

> math.less(2, 1)

#false

> math.less(1, 2, 3, 4)

#true

> math.less(1, 2, 3, 0)

#false

> math.pi

3.141592653589793

• bits.and, bits.or (inclusive), bits.xor, work on pairs of bits from n and m;

• bits.not inverts every bit in n;

• bits.(<<) and bits.(>>) perform a left shift or arithmetic right shift of n by m bits;

• bits.(?) reports whether the bit at position m (counting from 0 as the least-significant bit) is set within n;

• bits.length reports the number of bits that remain in n if all identical leading bits (0s for a position n or 1s for a negative n) are removed; and

• bits.field produces the integer represented by bits start (inclusive) through end (exclusive) of n.

> 5 bits.and 3
1
> 5 bits.or 3
7
> 5 bits.xor 3
6
> bits.not 3
-4
> 5 bits.(<<) 2
20
> 5 bits.(>>) 2
1
> bits.length(2)
2
> bits.length(-2)
1
> bits.field(255, 1, 4)
7