logo

const final class

sys::Int

sys::Obj
  sys::Num
    sys::Int
//
// Copyright (c) 2006, Brian Frank and Andy Frank
// Licensed under the Academic Free License version 3.0
//
// History:
//   2 Dec 05  Brian Frank  Creation
//

**
** Int is used to represent a signed 64-bit integer.
**
const final class Int : Num
{

//////////////////////////////////////////////////////////////////////////
// Constructor
//////////////////////////////////////////////////////////////////////////

  **
  ** Parse a Str into a Int using the specified radix.
  ** If invalid format and checked is false return null,
  ** otherwise throw ParseErr.
  **
  static Int fromStr(Str s, Int radix := 10, Bool checked := true)

  **
  ** 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)
  **
  static Int random(Range r := null)

  **
  ** Private constructor.
  **
  private new make()

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

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

//////////////////////////////////////////////////////////////////////////
// Obj Overrides
//////////////////////////////////////////////////////////////////////////

  **
  ** Return true if same integer value.
  **
  override Bool equals(Obj obj)

  **
  ** Compare based on integer value.
  **
  override Int compare(Obj obj)

  **
  ** Return this.
  **
  override Int hash()

//////////////////////////////////////////////////////////////////////////
// Operations
//////////////////////////////////////////////////////////////////////////

  **
  ** Negative of this.  Shortcut is -a.
  **
  Int negate()

  **
  ** Bitwise inverse of this.  Shortcut is  ~a.
  **
  Int tilde()

  **
  ** Multiply this with b.  Shortcut is a*b.
  **
  Int star(Int b)

  **
  ** Divide this by b.  Shortcut is a/b.
  **
  Int slash(Int b)

  **
  ** Return remainder of this divided by b.  Shortcut is a%b.
  **
  Int percent(Int b)

  **
  ** Add this with b.  Shortcut is a+b.
  **
  Int plus(Int b)

  **
  ** Subtract b from this.  Shortcut is a-b.
  **
  Int minus(Int b)

  **
  ** Bitwise-and of this and b.  Shortcut is a&b.
  **
  Int amp(Int b)

  **
  ** Bitwise-or of this and b.  Shortcut is a|b.
  **
  Int pipe(Int b)

  **
  ** Bitwise-exclusive-or of this and b.  Shortcut is a^b.
  **
  Int caret(Int b)

  **
  ** Bitwise left shift of this by b.  Shortcut is a<<b.
  **
  Int lshift(Int b)

  **
  ** Bitwise right shift of this by b.  Shortcut is a>>b.
  **
  Int rshift(Int b)

  **
  ** Increment by one.  Shortcut is ++a or a++.
  **
  Int increment()

  **
  ** Decrement by one.  Shortcut is --a or a--.
  **
  Int decrement()

/////////////////////////////////////////////////////////////////////////
// Num
//////////////////////////////////////////////////////////////////////////

  **
  ** Return this.
  **
  override Int toInt()

  **
  ** Convert this Int to a Float.
  **
  override Float toFloat()

/////////////////////////////////////////////////////////////////////////
// Math
//////////////////////////////////////////////////////////////////////////

  **
  ** Return the absolute value of this integer.  If this value is
  ** positive then return this, otherwise return the negation.
  **
  Int abs()

  **
  ** Return the smaller of this and the specified Int values.
  **
  Int min(Int that)

  **
  ** Return the larger of this and the specified Int values.
  **
  Int max(Int that)

  **
  ** Return if this integer is evenly divisible by two.
  **
  Bool isEven()

  **
  ** Return if this integer is not evenly divisible by two.
  **
  Bool isOdd()

/////////////////////////////////////////////////////////////////////////
// Char
//////////////////////////////////////////////////////////////////////////

  **
  ** Return if this Unicode char is whitespace: space \t \n \r \f
  **
  Bool isSpace()

  **
  ** Return if this Unicode char is an ASCII alpha char: isUpper||isLower
  **
  Bool isAlpha()

  **
  ** Return if this Unicode char is an ASCII alpha-numeric char: isAlpha||isDigit
  **
  Bool isAlphaNum()

  **
  ** Return if this Unicode char is an ASCII uppercase alphabetic char: A-Z
  **
  Bool isUpper()

  **
  ** Return if this Unicode char is an ASCII lowercase alphabetic char: a-z
  **
  Bool isLower()

  **
  ** 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 upper()

  **
  ** 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 lower()

  **
  ** 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
  **
  Bool isDigit(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
  **
  Int toDigit(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
  **
  Int fromDigit(Int radix := 10)

/////////////////////////////////////////////////////////////////////////
// Locale
//////////////////////////////////////////////////////////////////////////

  **
  ** Return if this Unicode char is an uppercase letter in
  ** the current locale.  See also `localeIsLower` and `isUpper`.
  **
  Bool localeIsUpper()

  **
  ** Return if this Unicode char is a lowercase letter in
  ** the current locale.  See also `localeIsUpper` and `isLower`.
  **
  Bool localeIsLower()

  **
  ** 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`.
  **
  Int localeUpper()

  **
  ** 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 localeLower()

/////////////////////////////////////////////////////////////////////////
// Conversion
//////////////////////////////////////////////////////////////////////////

  **
  ** Return decimal string representation.
  **
  override Str toStr()

  **
  ** Return hexdecimal string representation.
  **
  Str toHex()

  **
  ** Map as a Unicode code point to a single character Str.
  **
  Str toChar()

/////////////////////////////////////////////////////////////////////////
// Closures
//////////////////////////////////////////////////////////////////////////

  **
  ** Call the specified function to this times passing the current counter.
  **
  Void times(|Int i| c)

}