logo

const class

sys::Int

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

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

Slots

abs

Int abs()

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

amp

Int amp(Int b)

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

caret

Int caret(Int b)

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

compare

override Int compare(Obj obj)

Compare based on integer value.

decrement

Int decrement()

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

equals

override Bool equals(Obj obj)

Return true if same integer value.

fromDigit

Int fromDigit(Int radix := def)

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 Int fromStr(Str s, Int radix := def, Bool checked := def)

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

hash

override Int hash()

Return this.

increment

Int increment()

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

isAlpha

Bool isAlpha()

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

isAlphaNum

Bool isAlphaNum()

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

isDigit

Bool isDigit(Int radix := def)

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
isEven

Bool isEven()

Return if this integer is evenly divisible by two.

isLower

Bool isLower()

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

isOdd

Bool isOdd()

Return if this integer is not evenly divisible by two.

isSpace

Bool isSpace()

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

isUpper

Bool isUpper()

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

localeIsLower

Bool localeIsLower()

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

localeIsUpper

Bool localeIsUpper()

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

localeLower

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.

localeUpper

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.

lower

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

Int lshift(Int b)

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

max

Int max(Int that)

Return the larger of this and the specified Int values.

min

Int min(Int that)

Return the smaller of this and the specified Int values.

minus

Int minus(Int b)

Subtract b from this. Shortcut is a-b.

negate

Int negate()

Negative of this. Shortcut is -a.

percent

Int percent(Int b)

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

pipe

Int pipe(Int b)

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

plus

Int plus(Int b)

Add this with b. Shortcut is a+b.

random

static Int random(Range r := def)

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)
rshift

Int rshift(Int b)

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

slash

Int slash(Int b)

Divide this by b. Shortcut is a/b.

star

Int star(Int b)

Multiply this with b. Shortcut is a*b.

tilde

Int tilde()

Bitwise inverse of this. Shortcut is ~a.

times

Void times(|Int| c)

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

toChar

Str toChar()

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

toDigit

Int toDigit(Int radix := def)

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
toFloat

override Float toFloat()

Convert this Int to a Float.

toHex

Str toHex()

Return hexdecimal string representation.

toInt

override Int toInt()

Return this.

toStr

override Str toStr()

Return decimal string representation.

upper

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'