const class sys::Int

sys::Obj
  sys::Num
    sys::Int

@Serializable { simple=true }

Source

Int is used to represent a signed 64-bit integer.

abs

Int abs()

Source

Return the absolute value of this integer. If this value is positive then return this, otherwise return the negation.

and

Int and(Int b)

Source

Bitwise-and of this and b.

clamp

Int clamp(Int min, Int max)

Source

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.

compare

virtual override Int compare(Obj obj)

Source

Compare based on integer value.

decrement

@Operator
Int decrement()

Source

Decrement by one. Shortcut is --a or a--.

defVal

const static Int defVal

Source

Default value is zero.

div

@Operator
Int div(Int b)

Source

Divide this by b. Shortcut is a/b.

divDecimal

@Operator
Decimal divDecimal(Decimal b)

Source

Divide this by b. Shortcut is a/b.

divFloat

@Operator
Float divFloat(Float b)

Source

Divide this by b. Shortcut is a/b.

equals

virtual override Bool equals(Obj? obj)

Source

Return true if same integer value.

equalsIgnoreCase

Bool equalsIgnoreCase(Int ch)

Source

Return if the two Unicode chars are equal without regard to ASCII case.

fromDigit

Int? fromDigit(Int radix := 10)

Source

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

fromStr

static new fromStr(Str s, Int radix := 10, Bool checked := true)

Source

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.

hash

virtual override Int hash()

Source

Return this.

increment

@Operator
Int increment()

Source

Increment by one. Shortcut is ++a or a++.

isAlpha

Bool isAlpha()

Source

Return if this Unicode char is an ASCII alpha char: isUpper||isLower

isAlphaNum

Bool isAlphaNum()

Source

Return if this Unicode char is an ASCII alpha-numeric char: isAlpha||isDigit

isDigit

Bool isDigit(Int radix := 10)

Source

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

isEven

Bool isEven()

Source

Return if this integer is evenly divisible by two.

isLower

Bool isLower()

Source

Return if this Unicode char is an ASCII lowercase alphabetic char: a-z

isOdd

Bool isOdd()

Source

Return if this integer is not evenly divisible by two.

isSpace

Bool isSpace()

Source

Return if this Unicode char is whitespace: space \t \n \r \f

isUpper

Bool isUpper()

Source

Return if this Unicode char is an ASCII uppercase alphabetic char: A-Z

localeIsLower

Bool localeIsLower()

Source

Return if this Unicode char is a lowercase letter in the current locale. See also localeIsUpper and isLower.

localeIsUpper

Bool localeIsUpper()

Source

Return if this Unicode char is an uppercase letter in the current locale. See also localeIsLower and isUpper.

localeLower

Int localeLower()

Source

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.

localeUpper

Int localeUpper()

Source

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.

lower

Int lower()

Source

If this Unicode char is an ASCII uppercase char, then return it as lowercase, otherwise return this.

Example:

'A'.lower => 'a'
'h'.lower => 'h'

max

Int max(Int that)

Source

Return the larger of this and the specified Int values.

maxVal

const static Int maxVal

Source

Maximum value which can be stored in a signed 64-bit Int: 9,223,372,036,854,775,807

min

Int min(Int that)

Source

Return the smaller of this and the specified Int values.

minVal

const static Int minVal

Source

Minimum value which can be stored in a signed 64-bit Int: -9,223,372,036,854,775,808

minus

@Operator
Int minus(Int b)

Source

Subtract b from this. Shortcut is a-b.

minusDecimal

@Operator
Decimal minusDecimal(Decimal b)

Source

Subtract b from this. Shortcut is a-b.

minusFloat

@Operator
Float minusFloat(Float b)

Source

Subtract b from this. Shortcut is a-b.

mod

@Operator
Int mod(Int b)

Source

Return remainder of this divided by b. Shortcut is a%b.

modDecimal

@Operator
Decimal modDecimal(Decimal b)

Source

Return remainder of this divided by b. Shortcut is a%b.

modFloat

@Operator
Float modFloat(Float b)

Source

Return remainder of this divided by b. Shortcut is a%b.

mult

@Operator
Int mult(Int b)

Source

Multiply this with b. Shortcut is a*b.

multDecimal

@Operator
Decimal multDecimal(Decimal b)

Source

Multiply this with b. Shortcut is a*b.

multFloat

@Operator
Float multFloat(Float b)

Source

Multiply this with b. Shortcut is a*b.

negate

@Operator
Int negate()

Source

Negative of this. Shortcut is -a.

not

Int not()

Source

Bitwise not/inverse of this.

or

Int or(Int b)

Source

Bitwise-or of this and b.

plus

@Operator
Int plus(Int b)

Source

Add this with b. Shortcut is a+b.

plusDecimal

@Operator
Decimal plusDecimal(Decimal b)

Source

Add this with b. Shortcut is a+b.

plusFloat

@Operator
Float plusFloat(Float b)

Source

Add this with b. Shortcut is a+b.

pow

Int pow(Int pow)

Source

Return this value raised to the specified power. Throw ArgErr if pow is less than zero.

random

static Int random(Range? r := null)

Source

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)

shifta

Int shifta(Int b)

Source

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.

shiftl

Int shiftl(Int b)

Source

Bitwise left shift of this by b.

shiftr

Int shiftr(Int b)

Source

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.

times

Void times(|Int| c)

Source

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

toChar

Str toChar()

Source

Map as a Unicode code point to a single character Str.

toCode

Str toCode(Int base := 10)

Source

Get this Int as a Fantom code literal. Base must be 10 or 16.

toDateTime

DateTime toDateTime(TimeZone tz := TimeZone.cur())

Source

Convert nano-seconds ticks since 1-Jan-2000 to a DateTime. Convenience for DateTime.makeTicks.

toDigit

Int? toDigit(Int radix := 10)

Source

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

toDuration

Duration toDuration()

Source

Convert nano-seconds ticks to a Duration. Convenience for Duration.make.

toHex

Str toHex(Int? width := null)

Source

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"

toLocale

Str toLocale(Str? pattern := null, Locale locale := Locale.cur())

Source

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

toRadix

Str toRadix(Int radix, Int? width := null)

Source

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"

toStr

virtual override Str toStr()

Source

Return decimal string representation.

upper

Int upper()

Source

If this Unicode char is an ASCII lowercase char, then return it as uppercase, otherwise return this.

Example:

'a'.upper => 'A'
'4'.upper => '4'

xor

Int xor(Int b)

Source

Bitwise-exclusive-or of this and b.