Fan

 

const final class

sys::Int

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

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

Slots

absSource

Int abs()

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

andSource

Int and(Int b)

Bitwise-and of this and b. Shortcut is a&b.

compareSource

override Int compare(Obj obj)

Overrides sys::Obj.compare

Compare based on integer value.

decrementSource

Int decrement()

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

defValSource

static Int defVal

Default value is zero.

divSource

Int div(Int b)

Divide this by b. Shortcut is a/b.

equalsSource

override Bool equals(Obj? obj)

Overrides sys::Obj.equals

Return true if same integer value.

equalsIgnoreCaseSource

Bool equalsIgnoreCase(Int ch)

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

fromDigitSource

Int? fromDigit(Int radix := 10)

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
fromStrSource

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

Parse a Str into a Int using the specified radix. If invalid format and checked is false return null, otherwise throw ParseErr.

hashSource

override Int hash()

Overrides sys::Obj.hash

Return this.

incrementSource

Int increment()

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

inverseSource

Int inverse()

Bitwise inverse of this. Shortcut is ~a.

isAlphaSource

Bool isAlpha()

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

isAlphaNumSource

Bool isAlphaNum()

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

isDigitSource

Bool isDigit(Int radix := 10)

Return if this Unicode char is an 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
isEvenSource

Bool isEven()

Return if this integer is evenly divisible by two.

isLowerSource

Bool isLower()

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

isOddSource

Bool isOdd()

Return if this integer is not evenly divisible by two.

isSpaceSource

Bool isSpace()

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

isUpperSource

Bool isUpper()

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

localeIsLowerSource

Bool localeIsLower()

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

localeIsUpperSource

Bool localeIsUpper()

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

localeLowerSource

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.

localeUpperSource

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.localeLower should be preferred. See also localeLower and upper.

lowerSource

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'
lshiftSource

Int lshift(Int b)

Bitwise left shift of this by b. Shortcut is a<<b.

maxSource

Int max(Int that)

Return the larger of this and the specified Int values.

maxValSource

static Int maxVal

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

minSource

Int min(Int that)

Return the smaller of this and the specified Int values.

minValSource

static Int minVal

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

minusSource

Int minus(Int b)

Subtract b from this. Shortcut is a-b.

modSource

Int mod(Int b)

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

multSource

Int mult(Int b)

Multiply this with b. Shortcut is a*b.

negateSource

Int negate()

Negative of this. Shortcut is -a.

orSource

Int or(Int b)

Bitwise-or of this and b. Shortcut is a|b.

plusSource

Int plus(Int b)

Add this with b. Shortcut is a+b.

randomSource

static Int random(Range? r := null)

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.

Examples:

r := Int.random
r := Int.random(0..100)
rshiftSource

Int rshift(Int b)

Bitwise right shift of this by b. Shortcut is a>>b.

timesSource

Void times(|Int| c)

Call the specified function to this times passing the current counter.

toCharSource

Str toChar()

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

toCodeSource

Str toCode(Int base := 10)

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

toDateTimeSource

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

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

toDigitSource

Int? toDigit(Int radix := 10)

Convert this number into a Unicode char 0-'9'. If radix is 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
toDurationSource

Duration toDuration()

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

toHexSource

Str toHex(Int? width := null)

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"
toLocaleSource

Str toLocale(Str? pattern := null)

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.

Examples:

3.toLocale("00")             =>  03
3.toLocale("000")            =>  003
123456789.toLocale("#,###")  =>  123,456,789
toStrSource

override Str toStr()

Overrides sys::Obj.toStr

Return decimal string representation.

upperSource

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'
xorSource

Int xor(Int b)

Bitwise-exclusive-or of this and b. Shortcut is a^b.