Whether this byte is even.

The hash value of the value, which allows the value to be an element of a hash-based set or key of a hash-based map. Implementations must respect the constraint that:

• if x==y then x.hash==y.hash.

Therefore, a class which refines Object.equals() must also refine hash.

In general, hash values vary between platforms and between executions of the same program.

Note that when executing on a Java Virtual Machine, the 64-bit Integer value returned by an implementation of hash is truncated to a 32-bit integer value by taking the exclusive disjunction of the 32 lowest-order bits with the 32 highest-order bits, before returning the value to the caller.

The additive inverse of this byte. For any integer x:

(-x.byte).signed = -x.byte.signed

The binary complement of this sequence of bits.

The predecessor of this value.

This byte interpreted as a signed integer in the range -128..127 (that is, -#80..#7F).

The unsigned interpretation of this byte as a string.

The successor of this value.

Whether this byte is one.

This byte interpreted as an unsigned integer in the range 0..255 (that is, 0..#FF).

Whether this byte is zero.

Performs a logical AND operation.

Returns an instance with the given bit set to 0 if 0 <= index < size, otherwise returns a value with the same bits as this value.

Determine if two values are equal.

For any two non-null objects x and y, x.equals(y) may be written as:

x == y 

Implementations should respect the constraints that:

• if x===y then x==y (reflexivity),
• if x==y then y==x (symmetry),
• if x==y and y==z then x==z (transitivity).

Furthermore it is recommended that implementations ensure that if x==y then x and y have the same concrete class.

A class which explicitly refines equals() is said to support value equality, and the equality operator == is considered much more meaningful for such classes than for a class which simply inherits the default implementation of identity equality from Identifiable.

Note that an implementation of equals() that always returns false does satisfy the constraints given above, as long as the class does not inherit Identifiable. Therefore, in very rare cases where there is no reasonable definition of value equality for a class, for example, function references, it is acceptable for equals() to be defined to return false for every argument.

Returns an instance with the given bit flipped to its opposite value if 0 <= index < size, otherwise returns a value with the same bits as this value.

Retrieves a given bit from this bit sequence if 0 <= index < size, otherwise returns false.

If shift is in the range 0..$111, shift the 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($111) positions, using zero extension.

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.

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 modulo 256 sum of this byte and the given byte.

If shift is in the range 0..$111, shift the 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($111) positions, using sign extension.

If shift is in the range 0..$111, shift the 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($111) positions, using zero extension.

Returns an instance with the given bit set to the given value if 0 <= index < size, otherwise returns a value with the same bits as this value.

Performs a logical exclusive OR operation.