Int
@Serializable { simple=true }
const class Int : Num
Int is used to represent a signed 64-bit integer.
Parse a Str into a Int using the specified radix
Maximum value which can be stored in a signed 64-bit Int
Minimum value which can be stored in a signed 64-bit Int
Default value is zero
Bitwise left shift of this by b
Return remainder of this divided by b
Multiply this with b
Divide this by b
If this Unicode char is an ASCII lowercase char, then return it as uppercase, otherwise return this
Return if this Unicode char is whitespace
Divide this by b
If this Unicode char is a lowercase char, then return it as uppercase according to the current locale
Add this with b
Return if this Unicode char is an ASCII uppercase alphabetic char
Bitwise right shift of this by b
Return if the two Unicode chars are equal without regard to ASCII case
Clamp this integer between the min and max
Convert nano-seconds ticks since 1-Jan-2000 to a DateTime
Return remainder of this divided by b
Return decimal string representation
Multiply this with b
Return if this Unicode char is an ASCII alpha-numeric char
Return string representation in given radix
Return if this Unicode char is an ASCII alpha char
Get this Int as a Fantom code literal
If this Unicode char is an ASCII uppercase char, then return it as lowercase, otherwise return this
Add this with b
Divide this by b
Return if this Unicode char is a lowercase letter in the current locale
Return hexdecimal string representation
Bitwise arithmetic right-shift of this by b
Return if this Unicode char is a digit in the specified radix
If this Unicode char is an uppercase char, then return it as lowercase according to the current locale
Convert nano-seconds ticks to a Duration
Return this
Subtract b from this
Compare based on integer value
Return if this integer is evenly divisible by two
Increment by one
Add this with b
Return if this Unicode char is an uppercase letter in the current locale
Generate a random number
Bitwise not/inverse of this
Call the specified function to this times passing the current counter
Return the smaller of this and the specified Int values
Subtract b from this
Bitwise-and of this and b
Subtract b from this
Return if this integer is not evenly divisible by two
Return this value raised to the specified power
Bitwise-exclusive-or of this and b
Convert this number into a Unicode char 0-'9'
Map as a Unicode code point to a single character Str
Format this integer number for the current locale
Return remainder of this divided by b
Bitwise-or of this and b
Return the larger of this and the specified Int values
Convert a Unicode digit character into a number for the specified radix
Return the absolute value of this integer
Decrement by one
Negative of this
Return true if same integer value
Return if this Unicode char is an ASCII lowercase alphabetic char
Multiply this with b
Int abs()
Return the absolute value of this integer. If this value is positive then return this, otherwise return the negation.
Int and(Int b)
Bitwise-and of this and b.
Int clamp(Int min, Int max)
Clamp this integer between the min and max. If it's less than min then return min, if it's greater than max return max, otherwise return this integer itself.
virtual Int compare(Obj obj)
Compare based on integer value.
@Operator
Int decrement()
Decrement by one. Shortcut is --a or a--.
const static Int : defVal
Default value is zero.
@Operator
Int div(Int b)
Divide this by b. Shortcut is a/b.
@Operator
Decimal divDecimal(Decimal b)
Divide this by b. Shortcut is a/b.
@Operator
Float divFloat(Float b)
Divide this by b. Shortcut is a/b.
virtual Bool equals(Obj? obj)
Return true if same integer value.
Bool equalsIgnoreCase(Int ch)
Return if the two Unicode chars are equal without regard to ASCII case.
Int? fromDigit(Int radix)
Convert a Unicode digit character into a number for the specified radix. Return null if this char is not a valid digit.
Example:
'3'.fromDigit => 3 'f'.fromDigit(16) => 15 '%'.fromDigit => null
static new fromStr(Str s, Int radix, Bool checked)
Parse a Str into a Int using the specified radix. Unless the radix is 10, then a leading minus sign is illegal. If invalid format and checked is false return null, otherwise throw ParseErr.
virtual Int hash()
Return this.
@Operator
Int increment()
Increment by one. Shortcut is ++a or a++.
Bool isAlpha()
Return if this Unicode char is an ASCII alpha char: isUpper||isLower
Bool isAlphaNum()
Return if this Unicode char is an ASCII alpha-numeric char: isAlpha||isDigit
Bool isDigit(Int radix)
Return if this Unicode char is a digit in the specified radix. A decimal radix of ten returns true for 0-9. A radix of 16 also returns true for a-f and A-F.
Example:
'3'.toDigit => true 3.toDigit => false 'B'.toDigit(16) => true
Bool isEven()
Return if this integer is evenly divisible by two.
Bool isLower()
Return if this Unicode char is an ASCII lowercase alphabetic char: a-z
Bool isOdd()
Return if this integer is not evenly divisible by two.
Bool isSpace()
Return if this Unicode char is whitespace: space \t \n \r \f
Bool isUpper()
Return if this Unicode char is an ASCII uppercase alphabetic char: A-Z
Bool localeIsLower()
Return if this Unicode char is a lowercase letter in the current locale. See also localeIsUpper and isLower.
Bool localeIsUpper()
Return if this Unicode char is an uppercase letter in the current locale. See also localeIsLower and isUpper.
Int localeLower()
If this Unicode char is an uppercase char, then return it as lowercase according to the current locale. Note that Unicode contains some case conversion rules that don't work correctly on a single character, so Str.localeLower should be preferred. See also localeUpper and lower.
Int localeUpper()
If this Unicode char is a lowercase char, then return it as uppercase according to the current locale. Note that Unicode contains some case conversion rules that don't work correctly on a single character, so Str.localeUpper should be preferred. See also localeLower and upper.
Int lower()
If this Unicode char is an ASCII uppercase char, then return it as lowercase, otherwise return this.
Example:
'A'.lower => 'a' 'h'.lower => 'h'
Int max(Int that)
Return the larger of this and the specified Int values.
const static Int : maxVal
Maximum value which can be stored in a signed 64-bit Int: 9,223,372,036,854,775,807
Int min(Int that)
Return the smaller of this and the specified Int values.
const static Int : minVal
Minimum value which can be stored in a signed 64-bit Int: -9,223,372,036,854,775,808
@Operator
Int minus(Int b)
Subtract b from this. Shortcut is a-b.
@Operator
Decimal minusDecimal(Decimal b)
Subtract b from this. Shortcut is a-b.
@Operator
Float minusFloat(Float b)
Subtract b from this. Shortcut is a-b.
@Operator
Int mod(Int b)
Return remainder of this divided by b. Shortcut is a%b.
@Operator
Decimal modDecimal(Decimal b)
Return remainder of this divided by b. Shortcut is a%b.
@Operator
Float modFloat(Float b)
Return remainder of this divided by b. Shortcut is a%b.
@Operator
Int mult(Int b)
Multiply this with b. Shortcut is a*b.
@Operator
Decimal multDecimal(Decimal b)
Multiply this with b. Shortcut is a*b.
@Operator
Float multFloat(Float b)
Multiply this with b. Shortcut is a*b.
@Operator
Int negate()
Negative of this. Shortcut is -a.
Int not()
Bitwise not/inverse of this.
Int or(Int b)
Bitwise-or of this and b.
@Operator
Int plus(Int b)
Add this with b. Shortcut is a+b.
@Operator
Decimal plusDecimal(Decimal b)
Add this with b. Shortcut is a+b.
@Operator
Float plusFloat(Float b)
Add this with b. Shortcut is a+b.
Int pow(Int pow)
Return this value raised to the specified power. Throw ArgErr if pow is less than zero.
static Int random(Range? r)
Generate a random number. If range is null then all 2^64 integer values (both negative and positive) are produced with equal probability. If range is non-null, then the result is guaranteed to be inclusive of the range. Also see Float.random , Range.random , List.random , and Random.
Examples:
r := Int.random r := Int.random(0..100)
Int shifta(Int b)
Bitwise arithmetic right-shift of this by b. The left-most bit is shifted into the highest bits performing like a signed shift. This is equivalent to the Java >> operator.
Int shiftl(Int b)
Bitwise left shift of this by b.
Int shiftr(Int b)
Bitwise right shift of this by b. Zero is shifted into the highest bits performing like an unsigned shift. This is equivalent to the Java >>> operator.
Void times(|Int| c)
Call the specified function to this times passing the current counter. The counter begins at zero. Also see Range.each.
Example:
3.times |i| { echo(i) } => 0, 1, 2
Str toChar()
Map as a Unicode code point to a single character Str.
Str toCode(Int base)
Get this Int as a Fantom code literal. Base must be 10 or 16.
DateTime toDateTime(TimeZone tz)
Convert nano-seconds ticks since 1-Jan-2000 to a DateTime. Convenience for DateTime.makeTicks.
Int? toDigit(Int radix)
Convert this number into a Unicode char 0-'9'. If radix is greater than 10, then use a lower case letter. Return null if this number cannot be represented as a single digit character for the specified radix.
Example:
3.toDigit => '3' 15.toDigit(16) => 'f' 99.toDigit => null
Duration toDuration()
Convert nano-seconds ticks to a Duration. Convenience for Duration.make.
Str toHex(Int? width)
Return hexdecimal string representation. If width is non-null, then leading zeros are prepended to ensure the specified number of nibble characters.
Examples:
255.toHex => "ff" 255.toHex(4) => "00ff"
Str toLocale(Str? pattern, Locale locale)
Format this integer number for the current locale. If pattern is null, then the locale's default pattern is used. See Float.toLocale for pattern language. Fractional formatting is not supported for integers.
In addition Int.toLocale supports the "B" pattern which will format a number of bytes with the appropriate B, KB, MB, GB suffix based on the magnitude (1024B == 1KB).
Examples:
3.toLocale("00") => 03
3.toLocale("000") => 003
123456789.toLocale("#,###") => 123,456,789
123.toLocale("B") => 123B
1234.toLocale("B") => 1.2KB
100_000.toLocale("B") => 98KB
(3*1024*1024).toLocale("B") => 3MB
Str toRadix(Int radix, Int? width)
Return string representation in given radix. If width is non-null, then leading zeros are prepended to ensure the specified width.
Examples:
255.toRadix(8) => "377" 255.toRadix(8, 5) => "00377"
virtual Str toStr()
Return decimal string representation.
Int upper()
If this Unicode char is an ASCII lowercase char, then return it as uppercase, otherwise return this.
Example:
'a'.upper => 'A' '4'.upper => '4'
Int xor(Int b)
Bitwise-exclusive-or of this and b.