Companion

The CheckedMethod for divideStatic.

Extract a Kotlin Double from the receiver.

The CheckedMethod for extractDoubleStatic.

Extract a Java float from the receiver.

Extract a 32-bit signed Kotlin Int from the receiver.

The CheckedMethod for extractInt.

Extract a 64-bit signed Java Long from the receiver.

Extract an unsigned nybble from the receiver. Return it as a Java Byte.

Extract a signed byte from the receiver.

Extract a signed short from the receiver.

Extract an unsigned byte from the receiver. Return it in a Java Short to avoid sign bit reinterpretation.

Extract an unsigned short from the receiver. Return it in a Kotlin Int to avoid sign bit reinterpretation.

Answer whether this value is a double-precision floating point number.

The CheckedMethod for isDouble.

Answer whether this value is a single-precision floating point number.

Answer whether this value is an integer in the i32 range.

The CheckedMethod for isInt.

Answer whether this value is an integer in the i64 range.

Answer whether this number is numerically equal to some finite integer.

Answer whether this integral infinity is positive.

Answer whether this value is an integer in the range [-128..127].

Answer whether this value is an integer in the range [-32768..32767].

Answer whether this value is an integer in the range [0..65535].

The CheckedMethod for minusStatic.

The CheckedMethod for numericCompare.

The CheckedMethod for timesCanDestroy.

Given an Avail integer, answer which power of two it is. 1->0, 2->1, 4->2, 8->3, etc. If the number is not a power of two, answer -1.

Add the receiver to the given double, destroying one or the other if it's mutable and canDestroy is true. Because of the requirement that the argument be a double rather than an arbitrary A_Number, this is usually only used for double-dispatching.

Add the receiver to the given float, destroying one or the other if it's mutable and canDestroy is true. Because of the requirement that the argument be a float rather than an arbitrary A_Number, this is usually only used for double-dispatching.

Add the receiver to the integral infinity with the given Sign, destroying one or the other if it's mutable and canDestroy is true. Because of the requirement that the argument be an integral infinity rather than an arbitrary A_Number, this is usually only used for double-dispatching.

Add the receiver to the given finite integer, destroying one or the other if it's mutable and canDestroy is true. Because of the requirement that the argument be an integer rather than an arbitrary A_Number, this is usually only used for double-dispatching.

Convert the receiver, which must be an integer, into a Java BigInteger.

Produce an integer like the receiver, but with the bit corresponding to 2^bitPosition either set or cleared, depending on value. The receiver may be recycled or destroyed if canDestroy is true.

Shift this integer left by the specified number of bits. If the shift amount is negative, perform a right shift instead (of the negation of the specified amount). In the case that the receiver is negative, shift in zeroes on the right or ones on the left.

Shift the non-negative integer to the left by the specified number of bits, then truncate the representation to force bits above the specified position to be zeroed. The shift factor may be negative, indicating a right shift by the corresponding positive amount, in which case truncation will still happen.

Extract the bit with value 2^bitPosition from the integer, as a Boolean.

Compute the boolean and operation for the corresponding bits of the receiver and anInteger. Both values are signed 2's complement integers.

Compute the boolean or operation for the corresponding bits of the receiver and anInteger. Both values are signed 2's complement integers.

Compute the boolean exclusive-or operation for the corresponding bits of the receiver and anInteger. Both values are signed 2's complement integers.

Divide the receiver by the argument aNumber and answer the result.

Divide the double argument by the receiver, destroying one or the other if it's mutable and canDestroy is true. Because of the requirement that the argument be a double rather than an arbitrary A_Number, this is usually only used for double-dispatching.

Divide the float argument by the receiver, destroying one or the other if it's mutable and canDestroy is true. Because of the requirement that the argument be a float rather than an arbitrary A_Number, this is usually only used for double-dispatching.

Divide the infinity having the specified Sign by the receiver, destroying one or the other if it's mutable and canDestroy is true. Because of the requirement that the argument be an infinity rather than an arbitrary A_Number, this is usually only used for double-dispatching.

Divide the Avail integer argument by the receiver, destroying one or the other if it's mutable and canDestroy is true. Because of the requirement that the argument be an integer rather than an arbitrary A_Number, this is usually only used for double-dispatching.

Answer whether the receiver is an infinity with the specified Sign.

Determine if the receiver is an Avail integer equivalent to the specified Kotlin Int. Note that a non-integer should simply answer false, not fail. This operation was placed in A_Number for organizational reasons, not type restriction.

Answer whether the receiver is numerically greater than or equivalent to the argument.

Answer whether the receiver is numerically greater than the argument.

Answer whether the receiver is numerically less than or equivalent to the argument.

Answer whether the receiver is numerically less than the argument.

Subtract the argument aNumber from a receiver and answer the result.

Multiply the receiver by the given double, destroying one or the other if it's mutable and canDestroy is true. Because of the requirement that the argument be a double rather than an arbitrary A_Number, this is usually only used for double-dispatching.

Multiply the receiver by the given float, destroying one or the other if it's mutable and canDestroy is true. Because of the requirement that the argument be a float rather than an arbitrary A_Number, this is usually only used for double-dispatching.

Multiply the receiver by the infinity with the given sign, potentially destroying the receiver if it's mutable and canDestroy is true.

Multiply the receiver by the given integer, destroying one or the other if it's mutable and canDestroy is true. Because of the requirement that the argument be an integer rather than an arbitrary A_Number, this is usually only used for double-dispatching.

Divide the receiver by the argument aNumber and answer the result. The operation is not allowed to fail, so the caller must ensure that the arguments are valid, i.e. the divisor is not zero.

Difference the receiver and the argument aNumber and answer the result. The operation is not allowed to fail, so the caller must ensure that the arguments are valid, i.e. not infinities of like sign.

Add the receiver and the argument aNumber and answer the result. The operation is not allowed to fail, so the caller must ensure that the arguments are valid, i.e. not infinities of unlike sign.

Multiply the receiver and the argument aNumber and answer the result. The operation is not allowed to fail, so the caller must ensure that the arguments are valid, i.e. not zero and infinity.

Answer an ordering between the receiver and the argument. This compares the underlying real numeric values of the two A_Numbers, which does not necessarily agree with the equals semantics. In particular, under numerical ordering, 5 = 5.0 = 5.0f, and 0.0/0.0 is incomparable to every number, even itself. Under ordinary equality (the equals method), an integer never equals a float, and neither ever equals a double. However, 0.0/0.0 is equal to 0.0/0.0, since they have the same kind (double) and the same bit pattern. Note that hash agrees with general equality, not the numeric ordering.

This produces the same value as numericCompare, but the argument is an unboxed double value.

This produces the same value as numericCompare, but the argument is known to be an integral infinity whose Sign is provided.

This produces the same value as numericCompare, but the argument is known to be an integer.

Add the receiver and the argument aNumber and answer the result.

Extract a (signed) base 2^32 digit from the integer. The index must be in range for the integer's representation.

Replace a (signed) base 2^32 digit of the integer. The index must be in range for the integer's representation, and the receiver must be mutable.

Extract an unsigned base 2^32 digit from the integer. The index must be in range for the integer's representation.

Replace an unsigned base 2^32 digit of the integer. The index must be in range for the integer's representation, and the receiver must be mutable.

Subtract the receiver from the given double, destroying one or the other if it's mutable and canDestroy is true. Because of the requirement that the argument be a double rather than an arbitrary A_Number, this is usually only used for double-dispatching.

Subtract the receiver from the given float, destroying one or the other if it's mutable and canDestroy is true. Because of the requirement that the argument be a float rather than an arbitrary A_Number, this is usually only used for double-dispatching.

Subtract the receiver from the infinity with the specified sign, destroying one or the other if it's mutable and canDestroy is true.

Subtract the receiver from the given integer, destroying one or the other if it's mutable and canDestroy is true.

Multiply the receiver and the argument aNumber and answer the result.

Normalize the integer to have the minimum number of base 2^32 digits.