A Byte whose signed and unsigned interpretations are congruent modulo 256 to this integer.

The UTF-32 character with this UCS code point.

Determine if this integer is even.

An integer i is even if there exists an integer k such that:

i == 2*k

Thus, i is even if and only if i%2 == 0.

The number, represented as a Float, if such a representation is possible.

• Any integer with magnitude smaller than runtime.maxExactIntegralFloat (2⁵³) has such a representation.
• For larger integers on the JVM platform, an OverflowException is thrown. If this behavior is not desired, use nearestFloat instead.

The fractional part of this number, after truncation of the integral part. For Integral numeric types, the fractional part is always zero.

The hash code of this Integer, which is just the Integer itself, except on the JVM platform where, as with all hash codes, this 64-bit Integer value is truncated to 32 bits by taking the exclusive disjunction of the 32 lowest-order bits with the 32 highest-order bits, that is:

int.hash == int.rightArithmeticShift(32).exclusiveOr(int)

The magnitude of this number, defined for any instance x as:

• -x if x<0, or
• x otherwise,

where 0 is the additive identity. Hence:

• x.magnitude >= 0 for any x, and
• x.magnitude == 0 if and only if x==0.

The nearest Float to this number.

• For any integer with magnitude smaller than runtime.maxExactIntegralFloat (2⁵³), this is a Float with the exact same mathematical value (and the same value as float).
• For larger integers on the JVM platform, the Floats are less dense than the Integers so there may be loss of precision.

This method never throws an OverflowException.

The additive inverse of this value.

Determine if the number is strictly negative, that is, if this<0, where 0 is the additive identity.

The binary complement of this sequence of bits.

Determine if the number is strictly positive, that is, if this>0, where 0 is the additive identity.

The predecessor of this value.

The sign of this number:

• 1 if the number is Number.positive,
• -1 if it is Number.negative, or
• 0 if it is the additive identity.

Must satisfy:

x.magnitude.timesInteger(x.sign) == x

A developer-friendly string representing the instance. Concatenates the name of the concrete class of the instance with the hash of the instance. Subclasses are encouraged to refine this implementation to produce a more meaningful representation.

The successor of this value.

Determine if the number is the multiplicative identity.

The integral value of the number after truncation of the fractional part. For Integral numeric types, the integral value of a number is the number itself.

Determine if the number is the additive identity.

Performs a logical AND operation.

If the index is for an addressable bit, an instance with the same addressable bits as this instance, but with that bit cleared. Otherwise an instance with the same addressable bits as this instance.

Compare this integer with the given integer, returning:

• smaller, if this < other,
• larger, if this > other, or
• equal, if this == other.

The quotient obtained by dividing this number by the given number. For integral numeric types, this operation rounds toward 0, the additive identity, and results in a remainder.

When the given divisor is exactly 0, the additive identity, the behavior depends on the numeric type:

• For some numeric types, including Integer, division by 0 results in an exception.
• For others, including Float, it results in a special value of the type, for example, infinity.

Determines if this integer is a factor of the given integer, that is, if remainder(other)==0.

Determines if the given object is equal to this Integer, that is, if:

• the given object is an Integer representing the same whole number.

Or if:

• the given object is a Float,
• its value is neither Float.undefined, nor infinity,
• the fractional part of its value equals 0.0, and
• the integer part part of its value equals this integer, and
• this integer is between -2⁵³ and 2⁵³ (exclusive).

If the index is for an addressable bit, an instance with the same addressable bits as this instance, but with that bit flipped. Otherwise an instance with the same addressable bits as this instance.

The string representation of the given integer in the base given by radix. If the given integer is negative, the string representation will begin with -. Digits consist of decimal digits 0 to 9, together with and lowercase letters a to z for bases greater than 10.

For example:

• Integer.format(-46) is "-46"
• Integer.format(9,2) is "1001"
• Integer.format(10,8) is "12"
• Integer.format(511,16) is "1ff"
• Integer.format(512,32) is "g0"

If the index is for an addressable bit, the value of that bit. Otherwise false.

Determines if this value is strictly larger than the given value.

The larger of the two given integers.

If the given shift is in the range of addressable bits given by

0..runtime.integerAddressableSize-1

shift the addressable bits to the left by shift positions, using zero extension to fill in the least significant bits. Otherwise shift the addressable bits to the left by

shift.and(runtime.integerAddressableSize-1)

positions, using zero extension.

The largest integer in the given stream, or null if the stream is empty.

The smallest integer in the given stream, or null if the stream is empty.

The difference between this number and the given number. Must produce the value x + -y.

The modulo, after dividing this number by the given number. This differs from Integral.remainder() in that the result is always positive or 0.

The indirect successor or predecessor at the given offset, where:

• x.neighbour(0) == x,
• x.neighbour(i+1) == x.neighbour(i).successor, and
• x.neighbour(i-1) == x.neighbour(i).predecessor.

Determines if this value is smaller than or equal to the given value.

Determines if this value is larger than or equal to the given value.

Compute the offset from the given value, where:

• x.offset(x) == 0, and
• x.successor.offset(x) == 1 if x!=x.successor.

The sign of the offset from the given value.

Performs a logical inclusive OR operation.

The Integer value of the given string representation of an integer value in the base given by radix, or null if the string does not represent an integer in that base, or if the mathematical integer it represents is too large in magnitude to be represented by an instance of the class Integer.

The syntax accepted by this function depends upon the given base:

• For base 10, the accepted syntax is the same as the syntax for an Integer literal in the Ceylon language except that it may optionally begin with a sign character (+ or -) and may not contain grouping underscore characters. That is, an optional sign character, followed by a string of decimal digits, followed by an optional SI magnitude: k, M, G, T, or P.
• For other bases, the accepted syntax is an optional sign character, followed by a string of digits of the given base.

The given radix specifies the base of the string representation. The list of available digits starts from 0 to 9, followed by a to z. When parsing in a specific base, the first radix digits from the available digits list is used. This function is not case sensitive; a and A both correspond to the digit a whose decimal value is 10.

Integer: Base10 | BaseN Base10: Sign? Base10Digits Magnitude BaseN: Sign? BaseNDigits Sign: '+' | '-' Magnitude: 'k' | 'M' | 'G' | 'T' | 'P' Base10Digits: ('0'..'9')+ BaseNDigits: ('0'..'9'|'a'..'z'|'A'..'Z')+

The result of adding the given value to this value. This operation should never perform any kind of mutation upon either the receiving value or the argument value.

For any two instances x and y of a type that implements Summable, x.plus(y) may be written as:

x + y

The result of adding this number to the given Integer.

The result of raising this number to the given non-negative integer power, where 0^0 evaluates to 1.

The result of raising this number to the given non-negative integer power, where 0^0 evaluates to 1.

The product of all the integers in the given stream, or 1 if the stream is empty.

The remainder, after dividing this number by the given number. The sign of the remainder depends upon the sign of this number, and of the argument divisor:

• if this dividend is positive, the remainder has the opposite sign as the divisor, or is 0,
• if this dividend is negative, the remainder has the same sign as the divisor, or is 0, or
• if this dividend is zero, the remainder is always 0.

Thus, in order to satisfy the identity x == (x/y)*y + x%y, division for an integral numeric type must round toward 0, the additive identity.

If the given shift is in the range of addressable bits given by

0..runtime.integerAddressableSize-1

shift the addressable bits to the right by shift positions, using sign extension to fill in the most significant bits. Otherwise shift the addressable bits to the right by

shift.and(runtime.integerAddressableSize-1)

positions, using sign extension.

If the given shift is in the range of addressable bits given by

0..runtime.integerAddressableSize-1

shift the addressable bits to the right by shift positions, using zero extension to fill in the most significant bits. Otherwise shift the addressable bits to the right by

shift.and(runtime.integerAddressableSize-1)

positions, using zero extension.

If the index is for an addressable bit, an instance with the same addressable bits as this instance, but with that bit set to bit. Otherwise an instance with the same addressable bits as this instance.

Determines if this value is strictly smaller than the given value.

The smaller of the two given integers.

The sum of all the integers in the given stream, or 0 if the stream is empty.

The product of this number and the given number.

The result of multiplying this number by the given Integer.

Performs a logical exclusive OR operation.