Bigint and EBigint types

The EGL Bigint type is a value type that lets you create an eight-byte value that ranges from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807, inclusive, with no decimal places. In Eclipse IDE for EGL Developers, the type definition for Bigint is EBigint.

EGL package name

eglx.lang

Example use
Type detail
In the following detail, the Operation annotation indicates that the specified operation is available. For example, use “==” to compare two values, not “$EQ”. Two exceptions are the widen and narrow operations, which are invoked during data conversions; for example, when the as operator is used.
externalType EBigint extends ENumber type ClassType

   /* Unary + has no effect on the numeric value.                       */
   static function $Plus(value EBigint in) 
          returns (EBigint) {@Operation{"+"}};

   /* Operation + adds two numbers.                                     */
   static function $Plus(lvalue EBigint in, rvalue EBigint in) 
          returns (EBigint) {@Operation{"+"}};

   /* Operation - negates the value.                                    */
   static function $Minus(value EBigint in) 
          returns (EBigint) {@Operation{"-"}};

   /* Operation - subtracts one number from another.                    */
   static function $Minus(lvalue EBigint in, rvalue EBigint in) 
          returns (EBigint) {@Operation{"-"}};

   /* Operation * multiplies two numbers.                               */
   static function $Multiply(lvalue EBigint in, rvalue EBigint in) 
          returns (EBigint) {@Operation{"*"}};

   /* Operation / divides one number by another.                        */
   static function $Divide(lvalue EBigint in, rvalue EBigint in) 
          returns (EDecimal) {@Operation{"/"}};

   /* Operation % computes the remainder of division.                   */
   static function $Modulo(lvalue EBigint in, rvalue EBigint in) 
          returns (EBigint) {@Operation{"%"}};

   /* Operation ** computes lvalue to the power of rvalue.              */
   static function $PowerOf(lvalue EBigint in, rvalue EBigint in) 
          returns (EFloat) {@Operation{"**"}};

   /* Operation < compares two numbers.                                 */
   static function $LT(lvalue EBigint in, rvalue EBigint in) 
          returns (EBoolean) {@Operation{"<"}};

   /* Operation > compares two numbers.                                 */
   static function $GT(lvalue EBigint in, rvalue EBigint in) 
          returns (EBoolean) {@Operation{">"}};

   /* Operation <= compares two numbers.                                */
   static function $LTE(lvalue EBigint in, rvalue EBigint in) 
          returns (EBoolean) {@Operation{"<="}};

   /* Operation >= compares two numbers.                                */
   static function $GTE(lvalue EBigint in, rvalue EBigint in) 
          returns (EBoolean) {@Operation{">="}};

   /* Operation == compares two numbers.                                */
   static function $EQ(lvalue EBigint in, rvalue EBigint in) 
          returns(EBoolean) {@Operation{"=="}};

   /* Operation != compares two numbers.                                */
   static function $NEQ(lvalue EBigint in, rvalue EBigint in)
          returns(EBoolean) {@Operation{"!="}};

   /* Operation narrow converts a string to a bigint.                    *
   *  The string might begin with an optional + or - sign.               *
   *  After the sign must be a sequence of one or more digit             *
   *  characters. Nothing can follow the digits.  The digits             *
   *  in the string must be within the valid range for a Bigint.         *
   *  A TypeCastException is thrown if the string can't be parsed        *
   *  into a bigint.                                                    */
   static function asBigint(value EString in) 
          returns(EBigint) {@Operation{"narrow"}};

   /* Operation narrow converts a smallfloat to a bigint.                *
   *  Digits after the decimal point are discarded.                      *
   *  A TypeCastException is thrown if the smallfloat is out of range    *
   *  for a bigint.                                                     */
   static function asBigint(value ESmallfloat in) 
          returns(EBigint) {@Operation{"narrow"}};

   /* Operation narrow converts a float to a bigint.                     *
   *  Digits after the decimal point are discarded.                      *
   *  A TypeCastException is thrown                                      *
   *  if the float is out of range for a bigint.                        */
   static function asBigint(value EFloat in) 
          returns(EBigint) {@Operation{"narrow"}};

   /* Operation narrow converts a decimal to a bigint.                   *
   *  Digits after the decimal point are discarded.                      *
   *  A TypeCastException is thrown if the decimal is                    *
   *  out of range for a bigint.                                        */
   static function asBigint(value EDecimal in) 
          returns(EBigint) {@Operation{"narrow"}};

   /* Operation narrow converts a number to a bigint.                    *
   *  Digits after the decimal point are discarded.                      *
   *  A TypeCastException is thrown if the number is out of              *
   *  range for a bigint.                                               */
   static function asBigint(value ENumber in) 
          returns(EBigint) {@Operation{"narrow"}};

   /* Operation widen converts a smallint to a bigint.                  */
   static function asBigint(value ESmallint in)  
          returns(EBigint) {@Operation{"widen"}};  

   /* Operation widen converts an int to a bigint.                      */
   static function asBigint(value EInt in) 
          returns(EBigint) {@Operation{"widen"}};

   /* Operation widen converts a bigint to a number.                    */
   static function asNumber(value EBigint in) 
          returns(ENumber) {@Operation{"widen"}};
end
Comments
Compatibility
Table 1. Compatibility
Target Issue
Java No issues.
JavaScript No issues.