i64

conversion to float

private division and remainder with crash in case of div-by-zero

create hash code from this number
redefines hasHash.hash:
create hash code for this instance

find the highest 1 bit in this integer and return integer with
this single bit set or 0 if this is 0.

redefines numeric.infix !=:

redefines integer.infix %:
division remainder
redefines numeric.infix %:
basic operations: 'infix %' (division remainder)

bitwise and, or and xor operations
redefines integer.infix &:
bitwise operations

redefines wrappingInteger.infix *°:

redefines wrappingInteger.infix +°:

redefines wrappingInteger.infix -°:

division and remainder with check for div-by-zero
redefines numeric.infix /:
basic operations: 'infix /' (division)

redefines ordered.infix <:
does this come strictly before other?

redefines integer.infix <<:

redefines partiallyOrdered.infix <=:
does this come before other?

comparison
redefines numeric.infix ==:
comparison

redefines ordered.infix >:
does this come strictly after other?

redefines ordered.infix >=:
does this come after other?

shift operations (signed)
redefines integer.infix >>:
shift operations

redefines integer.infix ^:

redefines integer.infix |:

casting bit representation to unsigned

NYI: max is redefined here only to solve repeated inheritance conflict. Since max inherited
from hasInterval is abstract, fz should not complain about this conflict.
redefines i64s.max:

redefines wrappingIntegers.max:

count the number of 1 bits in the binary representation of this
integer.

redefines partiallyOrdered.orderedThis:
get value of type T.

NYI: Once Eiffel-style 'like this' works, we can use 'like this' instead of
T and no longer need this feature.

would addtion thiz + other cause an overflow or underflow?
redefines wrappingInteger.overflowOnAdd:
would addtion thiz + other cause an overflow or underflow?

would multiplication thiz * other cause an overflow or underflow?
redefines wrappingInteger.overflowOnMul:
would multiplication thiz * other cause an overflow or underflow?

would subtraction thiz - other cause an overflow or underflow?
redefines wrappingInteger.overflowOnSub:
would subtraction thiz - other cause an overflow or underflow?

neg, add, sub, mul with wrap-around semantics
redefines wrappingInteger.prefix -°:
neg, add, sub, mul with wrap-around semantics

redefines numeric.thiz:
get numeric.this value of type T. This is used for a generic implemention
of some features (e.g. prefix -, abs

count the number of trailing zeros in this integer.

redefines wrappingInteger.underflowOnAdd:

redefines wrappingInteger.underflowOnMul:

redefines wrappingInteger.underflowOnSub:

would negation -thiz cause an overflow?
redefines wrappingInteger.wrappedOnNeg:
would negation -thiz cause an overflow?