Int and EInt types

The EGL Int type is a value type that lets you create an eight-byte value that ranges from -2,147,483,648 to 2,147,483,647, inclusive, with no decimal places. In Eclipse IDE for EGL Developers, the type definition for Int is EInt.

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 EInt extends ENumber type ClassType
/**
	 * {@Operation +} A unary plus (has no effect on the numeric value).
	 */
static function $Plus(value EInt in) returns (EInt) {@Operation{"+"}};

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

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

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

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

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

/**
	 * {@Operation %} Computes the remainder of dividing one number by another.
	 */
static function $Modulo(lvalue EInt in, rvalue EInt in) 
       returns (EInt) {@Operation{"%"}};

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

/**
	 * {@Operation &} Computes the bitwise AND of two numbers.
	 */
static function $BitAnd(lvalue EInt in, rvalue EInt in) 
       returns (EInt) {@Operation{"&"}};

/**
	 * {@Operation |} Computes the bitwise OR of two numbers.
	 */
static function $BitOr(lvalue EInt in, rvalue EInt in) 
       returns (EInt) {@Operation{"|"}};

/**
	 * {@Operation xor} Computes the bitwise exclusive OR of two numbers.
	 */
static function $BitXor(lvalue EInt in, rvalue EInt in) 
       returns (EInt) {@Operation{"xor"}};

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

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

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

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

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

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

/**
	 * {@Operation narrow} Converts a string to an int.  The string is parsed
	 * as follows: It may begin with an optional + or - sign.  After the sign there
	 * must be a sequence of one or more digit characters.  Nothing may follow the
	 * digits.  The digits in the string must be within the valid range for an int.
	 *
	 * @throws TypeCastException if the string can't be parsed into an int.
	 */
static function asInt(value EString in) 
       returns(EInt) {@Operation{"narrow"}};
	
/**
	 * {@Operation widen} Converts an int to a smallint.
	 */
static function asInt(value ESmallint in) 
       returns(EInt) {@Operation{"widen"}};

/**
	 * {@Operation narrow} Converts a smallfloat to an int.  Digits after the
	 * decimal point are discarded.
	 *
	 * @throws TypeCastException if the smallfloat is out of range for an int.
	 */
static function asInt(value ESmallfloat in) 
       returns(EInt) {@Operation{"narrow"}};

/**
	 * {@Operation narrow} Converts a decimal to an int.  Digits after the
	 * decimal point are discarded.
	 *
	 * @throws TypeCastException if the decimal is out of range for an int.
	 */
static function asInt(value EDecimal in) 
       returns(EInt) {@Operation{"narrow"}};

/**
	 * {@Operation narrow} Converts a float to an int.  Digits after the
	 * decimal point are discarded.
	 *
	 * @throws TypeCastException if the float is out of range for an int.
	 */
static function asInt(value EFloat in) 
       returns(EInt) {@Operation{"narrow"}};

	/**
	 * {@Operation narrow} Converts a bigint to an int.
	 *
	 * @throws TypeCastException if the bigint is out of range for an int.
	 */
static function asInt(value EBigint in) 
       returns(EInt) {@Operation{"narrow"}};

/**
	 * {@Operation narrow} Converts a number to an int.  Digits after the
	 * decimal point are discarded.
	 *
	 * @throws TypeCastException if the number is out of range for an int.
	 */
static function asInt(value ENumber in) 
       returns(EInt) {@Operation{"narrow"}};
	
/**
	 * {@Operation widen} Converts an int to a number.
	 */
static function asNumber(value EInt in) 
       returns(ENumber) {@Operation{"widen"}};
end
Comments
Compatibility
Table 1. Compatibility
Target Issue
Java No issues.
JavaScript No issues.