Module TableclothInt
The platform-dependant signed integer type.
An int is a whole number.
ints are subject to
overflow, meaning that
Int.maximumValue + 1 = Int.minimumValue.
If you need to work with integers larger than
maximumValue (or smaller than
minimumValue you can use the Integer module.
Valid syntax for ints includes:
0
42
9000
1_000_000
1_000_000
0xFF (* 255 in hexadecimal *)
0x000A (* 10 in hexadecimal *)
Note: The number of bits used for an int is platform dependent.
When targeting Bucklescript Ints are 32 bits.
When targeting native OCaml uses 31-bits on 32-bit platforms and 63-bits
on 64-bit platforms which means that int math is well-defined in the
range -2 ** 30 to 2 ** 30 - 1 for 32bit platforms -2 ** 62 to
2 ** 62 - 1 for 64bit platforms.
Outside of that range, the behavior is determined by the compilation target.
You can read about the reasons for OCaml's unusual integer sizes here.
Historical Note: The name int comes from the term
integer). It appears that the
int abbreviation was introduced in the programming language ALGOL 68.
Today, almost all programming languages use this abbreviation.
type t
type t = int
Constants
val zero
val zero : t
The literal 0 as a named value
val one
val one : t
The literal 1 as a named value
val maximumValue
val maximumValue : t
The maximum representable int on the current platform
val maximum_value
val maximum_value : t
val minimumValue
val minimumValue : t
The minimum representable int on the current platform
val minimum_value
val minimum_value : t
Create
val fromString
val fromString : string -> t option
Attempt to parse a string into a int.
Examples
Int.fromString "0" = Some 0.
Int.fromString "42" = Some 42.
Int.fromString "-3" = Some (-3)
Int.fromString "123_456" = Some 123_456
Int.fromString "0xFF" = Some 255
Int.fromString "0x00A" = Some 10
Int.fromString "Infinity" = None
Int.fromString "NaN" = None
val from_string
val from_string : string -> t option
Operators
Note You do not need to open the Int module to use the
(+), (-), (*),
(**), (mod) or (/)
operators, these are available as soon as you open Tablecloth
val add
val add : t -> t -> t
Add two Int numbers.
Int.add 3002 4004 = 7006
Or using the globally available operator:
3002 + 4004 = 7006
You cannot add an int and a float directly though.
See Float.add for why, and how to overcome this limitation.
val (+)
val (+) : t -> t -> t
See Int.add
val subtract
val subtract : t -> t -> t
Subtract numbers
Int.subtract 4 3 = 1
Alternatively the operator can be used:
4 - 3 = 1
val ( )
val (-) : t -> t -> t
See Int.subtract
val multiply
val multiply : t -> t -> t
Multiply ints like
Int.multiply 2 7 = 14
Alternatively the operator can be used:
(2 * 7) = 14
val (*)
val (*) : t -> t -> t
See Int.multiply
val divide
val divide : t -> by:t -> t
Integer division
Notice that the remainder is discarded.
Exceptions
Throws Division_by_zero when the divisor is 0.
Examples
Int.divide 3 ~by:2 = 1
27 / 5 = 5
val (/)
val (/) : t -> t -> t
See Int.divide
val (/.)
val (/.) : t -> t -> float
Floating point division
Examples
Int.(3 /. 2) = 1.5
Int.(27 /. 5) = 5.25
Int.(8 /. 4) = 2.0
val power
val power : base:t -> exponent:t -> t
Exponentiation, takes the base first, then the exponent.
Examples
Int.power ~base:7 ~exponent:3 = 343
Alternatively the ** operator can be used:
7 ** 3 = 343
val (**)
val (**) : t -> t -> t
See Int.power
val negate
val negate : t -> t
Flips the 'sign' of an integer so that positive integers become negative and negative integers become positive. Zero stays as it is.
Examples
Int.negate 8 = (-8)
Int.negate (-7) = 7
Int.negate 0 = 0
Alternatively the ~- operator can be used:
~-(7) = (-7)
val (~ )
val (~-) : t -> t
See Int.negate
val absolute
val absolute : t -> t
Get the absolute value of a number.
Examples
Int.absolute 8 = 8
Int.absolute (-7) = 7
Int.absolute 0 = 0
val modulo
val modulo : t -> by:t -> t
Perform modular arithmetic.
If you intend to use modulo to detect even and odd numbers consider
using Int.isEven or Int.isOdd.
The modulo function works in the typical mathematical way when you run
into negative numbers
Use Int.remainder for a different treatment of negative numbers.
Examples
Int.modulo ~by:3 (-4) = 1
Int.modulo ~by:3 (-3 )= 0
Int.modulo ~by:3 (-2) = 2
Int.modulo ~by:3 (-1) = 1
Int.modulo ~by:3 0 = 0
Int.modulo ~by:3 1 = 1
Int.modulo ~by:3 2 = 2
Int.modulo ~by:3 3 = 0
Int.modulo ~by:3 4 = 1
val (mod)
val (mod) : t -> t -> t
See Int.modulo
val remainder
val remainder : t -> by:t -> t
Get the remainder after division. Here are bunch of examples of dividing by four:
Use Int.modulo for a different treatment of negative numbers.
Examples
List.map
~f:(Int.remainder ~by:4)
[(-5); (-4); (-3); (-2); (-1); 0; 1; 2; 3; 4; 5] =
[(-1); 0; (-3); (-2); (-1); 0; 1; 2; 3; 0; 1]
val maximum
val maximum : t -> t -> t
Returns the larger of two ints
Examples
Int.maximum 7 9 = 9
Int.maximum (-4) (-1) = (-1)
val minimum
val minimum : t -> t -> t
Returns the smaller of two ints
Examples
Int.minimum 7 9 = 7
Int.minimum (-4) (-1) = (-4)
Query
val isEven
val isEven : t -> bool
Check if an int is even
Examples
Int.isEven 8 = true
Int.isEven 7 = false
Int.isEven 0 = true
val is_even
val is_even : t -> bool
val isOdd
val isOdd : t -> bool
Check if an int is odd
Examples
Int.isOdd 7 = true
Int.isOdd 8 = false
Int.isOdd 0 = false
val is_odd
val is_odd : t -> bool
val clamp
val clamp : t -> lower:t -> upper:t -> t
Clamps n within the inclusive lower and upper bounds.
Exceptions
Throws an Invalid_argument exception if lower > upper
Examples
Int.clamp ~lower:0 ~upper:8 5 = 5
Int.clamp ~lower:0 ~upper:8 9 = 8
Int.clamp ~lower:(-10) ~upper:(-5) 5 = (-5)
val inRange
val inRange : t -> lower:t -> upper:t -> bool
Checks if n is between lower and up to, but not including, upper.
Exceptions
Throws an Invalid_argument exception if lower > upper
Examples
Int.inRange ~lower:2 ~upper:4 3 = true
Int.inRange ~lower:5 ~upper:8 4 = false
Int.inRange ~lower:(-6) ~upper:(-2) (-3) = true
val in_range
val in_range : t -> lower:t -> upper:t -> bool
Convert
val toFloat
val toFloat : t -> float
Convert an integer into a float. Useful when mixing Int and Float
values like this:
Examples
let halfOf (number : int) : float =
Float.((Int.toFloat number) / 2)
(* Note that locally opening the {!Float} module here allows us to use the floating point division operator *)
in
halfOf 7 = 3.5
val to_float
val to_float : t -> float
val toString
val toString : t -> string
Convert an int into a string representation.
Guarantees that
Int.(fromString (toString n)) = Some n
Examples
Int.toString 3 = "3"
Int.toString (-3) = "-3"
Int.to_sString 0 = "0"
val to_string
val to_string : t -> string
Compare
val equal
val equal : t -> t -> bool
Test two ints for equality
val compare
val compare : t -> t -> int
Compare two ints
type identity
type identity
The unique identity for Comparator
val comparator
val comparator : ( t, identity ) TableclothComparator.t