Numbers¶

Construction¶

Example

Type

Description

123

int

123L

long

12345678901

long

long since out of range for int.

0.0

double

0.0d

double

0.0f

float

NaN

double

Not a number

NaN(double)

double

Not a number

NaN(float)

float

Not a number

Inf

double

Going into infinity in the positive direction.

+Inf

double

Same as Inf.

-Inf

double

Going into infinity in the negative direction

The remaining number types can be constructed with:

Type

tinyint( <number, string or bool>)
byte (<number, string or bool>)

byte

smallint (<number, string or bool >)
short( <number, string or bool >)

short

integer( <number, string or bool >)
int(<number, string or bool >)

int

bigint(<number, string or bool>)
long(<number, string or bool>)

long

real(<number, string or bool>)
float(<number, string or bool>)

float

double(<number, string or bool>)

double

numeric(<number, string or bool>)
decimal(<number, string or bool>)

decimal

Note

To construct a decimal without precision loss, convert from a string as in decimal("12345.123"). The remaining constructors may lead to loss of precision if the destination type is less precise than the source.

All operations described implicitly convert numbers to the most precise type following the type hierarchy:

byte < short < int < long < float < double < decimal.

Note

Overflows are not checked by default. To protect against overflow, either choose an appropriate type that is large enough to accommodate the operation or use the overflow-safe version of the operators, which always checks for overflows.

Sum two numbers.

Syntax:

<number> + <number>

For example:

1 + 2 // 3

inf + inf // inf

-inf + -inf // -inf

1 + null // null
null + 1 // null

1 + inf // inf
inf + 1 // inf

1 + -inf // -inf
-inf + 1 // -inf

null + inf // null
inf + null // null

null + -inf // null
-inf + null // null

inf + -inf // nan
-inf + inf // nan

1 + nan // nan
nan + 1 // nan

Subtraction¶

Subtract two numbers.

Syntax:

<number> - <number>

For example:

1 - 2 // -1

inf - inf // nan

-inf - -inf // nan

1 - null // null
null - 1 // null

1 - inf // -inf
inf - 1 // inf

1 - -inf // inf
-inf - 1 // -inf

null - inf // null
inf - null // null

null - -inf // null
-inf - null // null

inf - -inf // inf
-inf - inf // -inf

1 - nan // nan
nan - 1 // nan

Multiplication¶

Multiply two numbers.

Syntax:

<number> * <number>

For example:

1 * 2 // 2

inf * inf // inf

-inf * -inf // inf

1 * null // null
null * 1 // null

1 * inf // inf
inf * 1 // inf
0 * inf // nan
inf * 0 // nan

1 * -inf // -inf
-inf * 1 // -inf
0 * -inf // nan
-inf * 0 // nan

null * inf // null
inf * null // null

null * -inf // null
-inf * null // null

inf * -inf // -inf
-inf * inf // -inf

1 * nan // nan
nan * 1 // nan

Division¶

Divide two numbers.

Syntax:

<number> / <number>

For example:

1 / 2 // 1
1.0 / 2 // 0.5
1 / 0 // nan

inf / inf // nan

-inf / -inf // nan

1 / null // null
null / 1 // null

1 / inf // 0.0
inf / 1 // inf

1 / -inf // -0.0
-inf / 1 // -inf

null / inf // null
inf / null // null

null / -inf // null
-inf / null // null

inf / -inf // nan
-inf / inf // nan

1 / nan // nan
nan / 1 // nan

Modulo¶

Finds the remainder of the division of a number by another.

Syntax:

<number> % <number>

For example:

1 % 2 // 1

inf % inf // nan

-inf % -inf // nan

1 % null // null
null % 1 // null

1 % inf // 1.0
inf % 1 // nan

1 % -inf // -inf
-inf % 1 // nan

null % inf // null
inf % null // null

null % -inf // null
-inf % null // null

inf % -inf // nan
-inf % inf // nan

1 % nan // nan
nan % 1 // nan

Negate a number.

Syntax:

- <expression>

For example:

-(1+1) // -2

Comparisons¶

Equal¶

Checks if two numbers are equal.

Syntax:

<number> = <number>
<number> == <number>

For example:

1 = 1 // true
1 == 1 // Same as 1 = 1

null = null // null

inf = inf // true

-inf = -inf // true

1 = null // null
null = 1 // null

1 = inf // false
inf = 1 // false

1 = -inf // false
-inf = 1 // false

null = inf // null
inf = null // null

null = -inf // null
-inf = null // null

inf = -inf // false
-inf = inf // false

<number or nan> = nan // false
nan = <number or nan> // false

To know if an expression is NaN (not a number), it is not possible to compare it with equality, since the result is always false. Instead use:

nan IS NAN // true
ISNAN(nan) // Same as nan IS NAN
1 IS NAN // false

Not equal¶

Checks if two numbers are not equal.

Syntax:

<number> <> <number>
<number> != <number>

For example:

1 <> 2 // false
1 != 2 // Same as 1 <> 2

null <> null // null

inf <> inf // false

-inf <> -inf // false

1 <> null // null
null <> 1 // null

1 <> inf // true
inf <> 1 // true

1 <> -inf // true
-inf <> 1 // true

null <> inf // null
inf <> null // null

null <> -inf // null
-inf <> null // null

inf <> -inf // true
-inf <> inf // true

<number or nan> <> nan // true
nan <> <number or nan> // true

Inequality¶

Check if a number if greater than (>), greater or equal than (>=), less than (<), less or equal than (<=) another number.

Syntax:

<number> > <number>
<number> >= <number>
<number> < <number>
<number> <= <number>

For example:

2 > 2 // false
2 >= 2 // true
1 < 2 // true
1 <= 2 // true

null < null // null
null > null // null

inf < inf // false
inf > inf // false

-inf < -inf // false
-inf > -inf // false

1 > null // null
null > 1 // null

1 > inf // false
inf > 1 // true

1 > -inf // true
-inf > 1 // false

null > inf // null
inf > null // null

null > -inf // null
-inf > null // null

inf > -inf // true
inf < -inf // false
-inf > inf // false
-inf < inf // true

Overflow protection¶

Addition, subtraction and multiplication binary operators, and the negation unary operator, have variants with overflow protection. To use these, place the suffix ? in the operator.

Syntax:

<number> +? <number>
<number> -? <number>
<number> *? <number>
-? <number>

For example:

1 +? 1
1 -? 9
-? 12
145 *? 999

The operation returns null if an overflow occurred or the value if it succeeded.

Attention

Overflow protection operators are not currently implemented.

Casts¶

Number types can be casted to:

• other number types, which may result in loss of precision if the final type is less precise than the original type;

• boolean, where zero becomes false whilst every other number is true;

• string, which creates a string representation of the number.

Casting nan to a natural number (int, long, byte, short) will result in 0.

Casting inf to int or long will result in the maximum value of the respective type. Similarly, casting -inf to int or long will result in the minimum value of the respective type.

Casting inf and -inf to short or byte will result in an overflow.