An 8-bit byte. A Byte value represents a congruence class of integers modulo 256, and may be interpreted as:

  • an unsigned integer value in the range 0..255, or
  • a signed integer value in the range -128..127.

Byte is not considered a full numeric type, supporting only:

  • bitwise operations, and
  • addition and subtraction modulo 256.

Bytes with modular addition form a mathematical group. Thus, every byte b has an additive inverse -b where:

(-b).signed == -b.signed
(-b).unsigned == b.unsigned==0 then 0 else 256 - b.unsigned

Byte is a recursive enumerable type. For example, the range:

254.byte .. 1.byte

contains the values 254.byte, 255.byte, 0.byte, 1.byte.

Byte does not have a total order because any such order would:

  • be inconsistent with the definition of successor and predecessor under modular addition, and
  • would depend on interpretation of the Byte value as signed or unsigned.

Thus, to compare the magnitude of two bytes, it is necessary to first convert them to either their signed or unsigned integer values.

Bytes are useful mainly because they can be efficiently stored in an Array.

no subtypes hierarchy

Byte(Integer congruent)
  • congruent

    An integer member of the congruence class of the resulting Byte.

    For any integer x>=0:

    x.byte.unsigned == x % 256
    x.byte.signed == x % 256

    And for an integer x<0:

    x.byte.unsigned == 256 + x % 256
    x.byte.signed == x % 256

    And for any integers x and y which are congruent modulo 256:

    x.byte == y.byte
evenSource Codeshared Boolean even

Whether this byte is even.

hashSource Codeshared actual Integer hash

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.

Refines Object.hash
negatedSource Codeshared actual Byte negated

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

(-x.byte).signed = -x.byte.signed
notSource Codeshared actual Byte not

The binary complement of this sequence of bits.

Refines Binary.not
predecessorSource Codeshared actual Byte predecessor

The predecessor of this value.

Refines Enumerable.predecessor ultimately refines Ordinal.predecessor
signedSource Codeshared Integer signed

This byte interpreted as a signed integer in the range -128..127.

stringSource Codeshared actual String string

The unsigned interpretation of this byte as a string.

successorSource Codeshared actual Byte successor

The successor of this value.

Refines Enumerable.successor ultimately refines Ordinal.successor
unitSource Codeshared Boolean unit

Whether this byte is one.

unsignedSource Codeshared Integer unsigned

This byte interpreted as an unsigned integer in the range 0..255.

zeroSource Codeshared Boolean zero

Whether this byte is zero.

Inherited Attributes
Attributes inherited from: Binary<Other>
Attributes inherited from: Invertible<Other>
Attributes inherited from: Ordinal<Other>
andSource Codeshared actual Byte and(Byte other)

Performs a logical AND operation.

Refines Binary.and
equalsSource Codeshared actual Boolean equals(Object that)

Determine if two values are equal. 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.

flipSource Codeshared actual Byte flip(Integer index)

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.

Refines Binary.flip
getSource Codeshared actual Boolean get(Integer index)

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

Refines Binary.get
leftLogicalShiftSource Codeshared actual Byte leftLogicalShift(Integer shift)

Shift the sequence of bits to the left, by the given number of places, filling the least significant bits with zeroes.

neighbourSource Codeshared actual Byte neighbour(Integer offset)

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.
offsetSource Codeshared actual Integer offset(Byte other)

Compute the offset from the given value, where:

  • x.offset(x) == 0, and
  • x.successor.offset(x) == 1 if x!=x.successor.
offsetSignSource Codeshared actual Integer offsetSign(Byte other)

The sign of the offset from the given value.

orSource Codeshared actual Byte or(Byte other)

Performs a logical inclusive OR operation.

Refines Binary.or
plusSource Codeshared actual Byte plus(Byte other)

The modulo 256 sum of this byte and the given byte.

rightArithmeticShiftSource Codeshared actual Byte rightArithmeticShift(Integer shift)

Shift the sequence of bits to the right, by the given number of places, preserving the values of the most significant bits.

If the sequence of bits represents a signed integer, the sign is preserved.

rightLogicalShiftSource Codeshared actual Byte rightLogicalShift(Integer shift)

Shift the sequence of bits to the right, by the given number of places, filling the most significant bits with zeroes.

If the sequence of bits represents a signed integer, the sign is not preserved.

setSource Codeshared actual Byte set(Integer index, Boolean bit)

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.

Refines Binary.set
xorSource Codeshared actual Byte xor(Byte other)

Performs a logical exclusive OR operation.

Refines Binary.xor
Inherited Methods
Methods inherited from: Binary<Other>
Methods inherited from: Enumerable<Other>
Methods inherited from: Invertible<Other>
Methods inherited from: Summable<Other>