The Standard Library

Booleans

def enum  Boolean: 'false'|'true'; # 1 bit
def value Bit:     0..1;           # 1 bit

Memory words

def value UByte:        0..   0xFF; # 1 byte
def value SByte:    -0x80..   0x7F; # 1 byte
def value UHWord:       0.. 0xFFFF; # 2 bytes 1/2 (half) word
def value SHWord: -0x8000.. 0x7FFF; # 2 bytes
          UNWord:                 ; # 4 bytes 1 (normal) word
  etc...  SNWord:                 ; # 4 bytes
          UDWord:                 ; # 8 bytes 2 (double) words
          SDWord:                 ; # 8 bytes
          UQWord:                 ; #16 bytes 4 (quad) words
          SQWord:                 ; #16 bytes
          UOWord:                 ; #32 bytes 8 (octal) words
          SOWord:                 ; #32 bytes
alias name Integer : SNWord;

IEEE-754 Floats

def struct IHFloat: (
  'plus'|'min' sign //
  0..0xFF shifted_exponent //
  0..0x7F_FFFF mantissa );
def struct INFloat (
  'plus'|'min' sign //
  0..0xFFF shifted_exponent //
  0..0x7_FFFF_FFFF_FFFF mantissa );
def struct ILFloat (
  'plus'|'min' sign //
  0..0xFFF shifted_exponent //
  0..0x7_FFFF_FFFF_FFFF_FFFF_FFFF mantissa );

Do some research on what IEEE-754 really entails

'Big' numbers

def concrete BigNumber;
alias name \u02115: BigNumber;
def concrete BigInteger;
alias name \u02124: BigInteger;
def concrete BigRational;
alias name \u0211A: BigRational;

The 'Big' types (actually classes) are 'unlimited' length numbers. The word 'unlimited' is quoted because the number has to fit in available memory. The implementation of the 'Big' types is not defined in the Ocean specification, but either a full binary or BCD is adviced.

alias dyadic <=> compare;

Boolean Symbols

Computational Symbols

alias dyadic 6 lr + addValue;
alias dyadic 6 lr - subtractValue; alias dyadic \u02212 subtractValue;
alias dyadic 4 lr * multiplyBy; alias dyadic \u000xx multiplyBy;
alias dyadic 4 lr / divideBy;   alias dyadic \u000xx divideBy;
alias dyadic 4 in \ moduloWith;
alias dyadic 2 rl ** raisePowerOf;
alias dyadic 2 in \u022xx rootOf;
alias unary  - negateValue;
alias unary  \u02212 negateValue;
alias unary  \u022xx squareRootOf;

Binary Symbols

alias dyadic 5 /\ binaryAnd;
alias dyadic 5 \u02227 binaryAnd;
alias dyadic 7 \/ binaryOr;
alias dyadic 7 \u02228 binaryOr;
alias dyadic 7 %  binaryXor;
alias dyadic 7 \u022BC binaryXor; ## Check !
alias unary  ~  binaryNot;
alias unary  \u000AC BinaryNot;
alias dyadic 5 << binaryShiftLeft;
alias dyadic 5 >> binaryShiftRight;
alias dyadic 5 \u0226A binaryShiftLeft;
alias dyadic 5 \u0226B binaryShiftRight;

Assignment Symbols

alias symbol := assignValue;
alias symbol \u02254 assignValue;

variant object  clone()
  Creates and returns a copy of this object.
boolean         equals(Object obj)
  Indicates whether some other object is "equal to" this one.
String          toString()
  Returns a string representation of the object.
Class           getClass()
  Returns the runtime class of an object.
int             hashCode()
  Returns a hash code value for the object.

void            notify()
  Wakes up a single thread that is waiting on this object's monitor.
void            notifyAll()
  Wakes up all threads that are waiting on this object's monitor.
void            wait()
  Causes current thread to wait until another thread invokes the notify()
  method or the notifyAll() method for this object.
void            wait(long timeout)
  Causes current thread to wait until either another thread invokes the
  notify() method or the notifyAll() method for this object, or a specified
  amount of time has elapsed.
void            wait(long timeout, int nanos)
  Causes current thread to wait until another thread invokes the notify()
  method or the notifyAll() method for this object, or some other thread
  interrupts the current thread, or a certain amount of real time has elapsed.