Binary Representations in Digital Logic

Binary representation is the method of expressing numbers using binary digits (bits). In digital logic, binary representations are important as they are the foundation for all computations and data processing in computers.

• Binary numbers form the backbone of digital circuits and systems.
• Each binary digit represents a power of 2, enabling efficient computation and storage.
• Binary representation simplifies the implementation of logic gates and operations in digital systems.
• It allows for the accurate and reliable representation of data in electronic devices.

1. Binary Representation of Unsigned Numbers

It is a way to represent positive numbers using only 0s and 1s. It is a system where numbers are expressed using only their magnitude, with no sign bit. In this system, all numbers are treated as positive, including zero.

Features of Unsigned Representation:

• Each bit in an unsigned binary number represents a power of 2.
• The rightmost bit is the least significant bit (LSB) and the leftmost bit is the most significant bit (MSB).
• The value is determined by summing the powers of 2 for each '1' bit. For example, (0010)₂ = 2¹ = 2
• An n-bit unsigned binary can represent numbers from 0 to 2ⁿ - 1. For example, an 8-bit unsigned binary can represent numbers from 0 to 255.

Limitations of Unsigned Representation:

• Unsigned binary represents only positive values and zero, limiting its use in signed systems.
• Its range is restricted by the number of bits (e.g., 0 to 255 for 8 bits).
• Overflow occurs when the value exceeds the maximum limit, causing errors (e.g., 255 + 1 = 0 in 8-bit).
• Operations requiring signed values need conversion to signed binary for efficiency.

Example: 4-Bit Unsigned Binary

2. Binary Representation of Signed Numbers

Binary Representation of Signed Numbers representation allows both positive and negative numbers. There are various signed binary representations.

Sign-Magnitude

In the sign bit method, the leftmost bit (MSB) is used to represent the sign of the number. A '0' in the MSB indicates a positive number and a '1' indicates a negative number. The remaining bits represent the magnitude of the number in binary form. The range of values in an n-bit system is from -2^n-1 -1 to 2^n-1 - 1.

For example, in an 8-bit signed binary system:

01000101 represents +69 in decimal (MSB is 0, so the number is positive).

11000101 represents -69 in decimal (MSB is 1, so the number is negative).

Limitations:

• It has an unequal range for positive and negative numbers.
• The representation of zero is ambiguous; it can be both 00000000 and 10000000.
• Arithmetic operations like addition and subtraction are more complex compared to unsigned binary.
• It wastes one bit for the sign, reducing the total available bits for magnitude.
• Overflow handling is less efficient compared to other methods like Two's Complement.

One's Complement

In the 1's complement method, negative numbers are represented by flipping all the bits of the corresponding positive number. The leftmost bit (MSB) indicates the sign. A '0' in the MSB represents a positive number and a '1' represents a negative number.

For example, in an 8-bit system:

00000101 represents +5 in decimal.

11111010 represents -5 in decimal (flip all bits of 00000101).

Limitations:

• The 1's complement method has separate representations for +0 (00000000) and -0 (11111111), wasting one usable number code.
• It requires an end-around carry for additions and extra correction steps after operations, making arithmetic more complex.
• Overflow detection is difficult and requires additional logic circuits.
• 1's complement is not used in modern processors and has been replaced by the more efficient two's complement.

Two's complement

The 2's complement method is used to represent both positive and negative numbers in binary. To find the 2's complement of a number, invert all the bits of the binary number and add 1 to the result. The 2's complement method eliminates the need for separate zero representations and simplifies arithmetic operations like addition and subtraction. The range of values in an n-bit system is from -2^n-1 to 2^n-1 - 1. It is widely used in modern processors due to its efficiency and ease of operation.

For example, in an 8-bit system:

00000101 represents +5 in decimal.

11111011 represents -5 in decimal (invert 00000101 to get 11111010, then add 1 to get 11111011).

Limitations:

• The range of representable values is asymmetric, with one more negative value than positive, e.g., for 8-bit the range is -128 to +127.
• Overflow occurs silently without warning, requiring explicit checks in programming.
• Converting 2's complement to decimal requires a sign check first, making it more complex than unsigned binary conversion.
• Hardware implementation needs adder circuits to handle the sign bit, which is slightly more complex than unsigned operations.

Note: Despite these limitations two's complement remains the universal standard due to its efficient arithmetic operations and single zero representation. Modern processors include dedicated circuits to handle these limitations effectively.

3. Floating-Point Representation (IEEE 754 standard)

IEEE 754 is the most widely used standard for representing floating-point numbers in computers. It uses three components: the sign bit, the exponent and the fraction (mantissa). These components allow for the representation of real numbers with a large range of values.

32-bit Single Precision Format

The single precision format consists of 32 bits and is divided as follows:

• 1 bit for the sign (S).
• 8 bits for the exponent (E).
• 23 bits for the mantissa (M).

In this format, the number is represented as:

(-1)^S× ( 1 + M) × 2^E-127

64-bit Double Precision Format

The double precision format consists of 64 bits and is divided as follows:

• 1 bit for the sign (S).
• 11 bits for the exponent (E).
• 52 bits for the mantissa (M).

The number is represented as:

(-1)^S× ( 1 + M) × 2^E-1023

Example (32-bit Single Precision): The number -13.25 in binary is represented as:

Sign bit: 1 (negative)

Exponent: 10000001 (8 in decimal)

Mantissa: 10101000000000000000000

Final representation: 1 10000001 10101000000000000000000

Features:

• The leftmost bit indicates the number's sign (0 for positive, 1 for negative).
• Exponent determines the range of the number. The exponent is stored with a bias to handle both positive and negative exponents.
• Mantissa represents the significant digits of the number. It’s normalized to maximize precision.
• It can represent very large and very small numbers.
• It provides better precision compared to fixed-point representation.

Limitations:

• Limited precision may result in rounding errors, especially for very large or very small numbers.
• The representation can’t handle numbers beyond its range, leading to overflow or underflow.
• Some decimal numbers cannot be exactly represented, causing minor inaccuracies.
• Floating-point arithmetic is slower than integer arithmetic due to the need for normalization and rounding.

4. Gray Code Binary Representation

Gray code is a binary numeral system in which two successive values differ by only one bit. Unlike the standard binary system, where multiple bits change when counting from one number to the next, Gray code ensures that only one bit changes at a time. This feature makes Gray code especially useful in reducing errors that may occur in digital systems, particularly when transitioning from one value to another. It is commonly used in applications like rotary encoders, analog-to-digital conversions and digital-to-analog conversions where small changes are needed.

Working of Gray Code:

To convert a binary number to Gray code:

1. The most significant bit (MSB) of the binary number is copied as the MSB of the Gray code.
2. Each subsequent bit in the Gray code is obtained by XORing the corresponding binary bit with the previous binary bit.

Example: To convert the binary number 011 to Gray code:

Start with the MSB: 0 (the same for both binary and Gray).

XOR the next bit (1) with the previous bit (0): 0 XOR 1 = 1, so the second bit of Gray code is 1.

XOR the final bit (1) with the previous bit (1): 1 XOR 1 = 0, so the last bit of Gray code is 0.

Thus, the binary number 011 converts to Gray code 010.

3-bit Gray Codes:

Features:

• Only one bit changes between successive numbers, reducing errors during transitions.
• Useful in systems where bit errors can lead to incorrect results, such as rotary encoders.
• Easy to convert between binary and Gray code using simple rules.
• Efficient for representing values where small transitions are important.

Limitations:

• Performing arithmetic operations such as addition and subtraction is more complex compared to binary.
• Requires additional bits for representation when compared to standard binary.
• Gray code is not intuitive for humans to interpret without conversion to standard binary.
• Primarily used in specialized applications like encoding, not for general-purpose computing.

5. Binary-Coded Decimal (BCD) Representation

Binary-Coded Decimal (BCD) is a system for representing decimal numbers in binary form. In this system, each decimal digit is encoded as a 4-bit binary number. Each of the decimal digits, from 0 to 9, is assigned a unique 4-bit binary code, ensuring that decimal values are directly mapped into binary representations. BCD is often used in applications where precision in decimal representation is required, such as in financial systems, digital clocks and calculators.

Working:

In BCD, each decimal digit is individually represented by a 4-bit binary number. For example:

• The decimal digit 0 is represented by 0000 in binary.
• The decimal digit 1 is represented by 0001 in binary.
• The decimal digit 2 is represented by 0010 in binary.
• This continues up to the decimal digit 9, which is represented by 1001 in binary.

Example: To represent decimal number 259 in BCD:

Decimal 2 = 0010 (4-bit binary for 2)

Decimal 5 = 0101 (4-bit binary for 5)

Decimal 9 = 1001 (4-bit binary for 9)

Therefore, the decimal number 259 is represented as: 0010 0101 1001 in BCD. Each of the digits (2, 5 and 9) is represented as a separate 4-bit binary value. The length of the BCD representation grows with the number of digits in the decimal number.

Features:

• Each decimal digit is represented as a separate 4-bit binary number, simplifying conversion between decimal and binary.
• Converting between decimal and BCD is straightforward, with each decimal digit converted to its 4-bit binary equivalent.
• BCD is used when decimal precision is essential, such as in financial calculations or digital clocks.
• It avoids rounding errors common in floating-point systems.
• It is widely used in systems like calculators and digital displays, as it closely matches human-readable decimal numbers.

Limitations:

• BCD requires 4 bits per decimal digit, making it less efficient than binary (e.g., 12 bits for a 3-digit number vs 8 bits in binary).
• Arithmetic operations are more complex in BCD as each digit must be handled separately.
• BCD can only represent decimal values and larger numbers require more memory and computation.
• Operations like addition and subtraction need special handling for carry and borrow, complicating hardware design.
• BCD is inefficient for large numbers or general-purpose computing where exact decimal representation is not needed.

6. Excess 3 Code Representation

Excess-3 (also known as XS-3) is a binary code used to represent decimal numbers. It is a form of Binary-Coded Decimal (BCD) where each decimal digit is represented by its 4-bit binary equivalent, but with an offset of 3 added to the binary value. This shift by 3 ensures that all the values are positive and avoids the need for negative digits, providing certain advantages in arithmetic operations. The main idea behind Excess-3 is to simplify arithmetic operations such as addition and subtraction and to ensure that all the digits are represented by a positive 4-bit value, thus making it easier for digital circuits to process them.

Working:

To convert a decimal digit into Excess-3:

1. Take the 4-bit binary representation of the decimal digit.
2. Add 3 (which in binary is 0011) to the 4-bit binary value.

Example: Excess 3 code for decimal number 4 is,

The binary equivalent of decimal 4 is 0100.

Add 3 (which is 0011) to 0100: 0100 + 0011 = 0111.

Therefore, the Excess-3 code for decimal 4 is 0111.

Features of Excess-3 Code:

• Excess-3 avoids negative numbers by shifting values, ensuring positive digits.
• Adding or subtracting BCD digits is easier due to the offset of 3 simplifying carry-over.
• Conversion between binary-coded decimal and regular binary is straightforward in Excess-3.
• Excess-3 provides error detection by ensuring only valid digits (0-9) are used.

Limitations of Excess-3 Code:

• Excess-3 requires 4 bits per decimal digit plus an offset, leading to inefficient space usage.
• Its range is limited to decimal digits 0-9 and cannot represent other values without extra encoding.
• Some operations are simplified, but others, like subtraction, need adjustments due to its non-binary nature.
• Excess-3 is less common in modern systems, with more efficient methods like binary and two's complement preferred.