Fuzion Language Portal

Fuzion • API-Documentation • wrappingInteger

☰

🌌wrappingInteger

§wrappingInteger<T>
=>
wrappingInteger<wrappingInteger.T>
:
integer<T>,wrappingIntegers<T>
[src]

wrappingInteger

wrappingInteger is the abstract ancestor of integer numbers that have min and
max values and operations with wrap-around semantics.

§infix %!(other T)

=>

:

redefines numeric.infix %!:

§infix *(other T)

=>

T

:

multiplication, with check for overflow
redefines numeric.infix *:
basic operations: 'infix *' (multiplication)

§infix *!(other T)

=>

:

redefines numeric.infix *!:

§infix **(other T)

=>

T

:

exponentiation for positive exponent

'zero ** zero' is permitted and results in 'one'.

redefines numeric.infix **:
basic operations: 'infix **' (exponentiation)

§infix **!(other T)

=>

:

redefines numeric.infix **!:

§infix **?(other T)

=>

numOption<wrappingInteger.T>

:

exponentiation with overflow checking semantics

'zero **? zero' is permitted and results in 'one'.

redefines numeric.infix **?:

§infix **^(other T)

=>

T

:

exponentiation with saturating semantics

'zero **^ zero' is permitted and results in 'one'.

redefines numeric.infix **^:

§infix **°(other T)

=>

T

:

exponentiation with wrap-around semantics

'zero **° zero' is permitted and results in 'one'.

§infix *?(other T)

=>

numOption<wrappingInteger.T>

:

redefines numeric.infix *?:

§infix *^(other T)

=>

T

:

redefines numeric.infix *^:

§infix *°(other T)

=>

T

:

§infix +(other T)

=>

T

:

addition, with check for overflow
redefines numeric.infix +:
basic operations: 'infix +' (addition)

§infix +!(other T)

=>

:

redefines numeric.infix +!:

§infix +?(other T)

=>

numOption<wrappingInteger.T>

:

redefines numeric.infix +?:

§infix +^(other T)

=>

T

:

redefines numeric.infix +^:

§infix +°(other T)

=>

T

:

§infix -(other T)

=>

T

:

substraction, with check for overflow
redefines numeric.infix -:
basic operations: 'infix -' (substraction)

§infix -!(other T)

=>

:

redefines numeric.infix -!:

§infix -?(other T)

=>

numOption<wrappingInteger.T>

:

redefines numeric.infix -?:

§infix -^(other T)

=>

T

:

redefines numeric.infix -^:

§infix -°(other T)

=>

T

:

§infix /!(other T)

=>

:

redefines numeric.infix /!:

=>

:

=>

:

§overflowOnAdd(other T)

=>

:

would addtion thiz + other cause an overflow or underflow?

§overflowOnExp(other T)

=>

:

would exponentiation 'this ** other' cause an overflow?

§overflowOnMul(other T)

=>

:

would multiplication thiz * other cause an overflow or underflow?

§overflowOnSub(other T)

=>

:

would subtraction thiz - other cause an overflow or underflow?

=>

T

:

negation, with check for overflow
redefines numeric.prefix -:
basic operations: 'prefix -' (negation)

=>

:

preconditions used in 'numeric' for basic operations: true if the
operation is permitted for the given values
redefines numeric.prefix -!:

=>

numOption<wrappingInteger.T>

:

overflow checking operations
redefines numeric.prefix -?:
overflow checking operations

=>

T

:

saturating operations
redefines numeric.prefix -^:
saturating operations

=>

T

:

neg, add, sub, mul with wrap-around semantics

§underflowOnAdd(other T)

=>

:

§underflowOnMul(other T)

=>

:

§underflowOnSub(other T)

=>

:

§wrappedOnAdd(other T)

=>

:

§wrappedOnMul(other T)

=>

:

=>

:

would negation -thiz cause an overflow?

§wrappedOnSub(other T)

=>

: