Number systems Revision Notes

Computers represent all data using the binary number system, which consists of only two digits: 0 and 1. This choice is fundamentally linked to the physical design of computer hardware. Electronic circuits inside computers have two stable states, often represented as off and on, or low voltage and high voltage. These two states naturally correspond to the binary digits 0 and 1.

Using binary simplifies the design of electronic components such as transistors and logic gates, which can reliably detect and switch between these two states. This reliability is crucial because it reduces errors caused by electrical noise or signal degradation, which would be more problematic if more states were used.

• Binary uses only two digits: 0 and 1.
• Electronic circuits have two stable states matching binary digits.
• Binary representation reduces hardware complexity and error rates.

Computers process various types of data including numbers, text, images, and sound. Regardless of the data type, it must be converted into binary form before processing. For example, text characters are converted into binary codes using standards like ASCII or Unicode, where each character corresponds to a unique binary number.

Images are represented as a grid of pixels, each pixel’s colour encoded in binary according to colour depth. Sound is sampled at regular intervals, with each sample converted into a binary number representing the amplitude at that moment.

This universal binary representation allows the computer’s central processing unit (CPU) to handle all data uniformly using the same basic operations on binary numbers.

• Text, images, and sound are all converted into binary.
• Text uses binary codes like ASCII or Unicode.
• Images use binary to represent pixel colours.
• Sound is sampled and converted into binary amplitude values.

Logic gates are the fundamental building blocks of digital circuits. They perform basic logical operations on binary inputs to produce a binary output. Common logic gates include AND, OR, NOT, NAND, NOR, XOR, and XNOR.

Each gate implements a simple Boolean function. For example, an AND gate outputs 1 only if both inputs are 1; otherwise, it outputs 0. By combining these gates, complex operations such as addition, subtraction, and data comparison can be performed on binary numbers.

Logic gates enable the CPU to execute instructions by manipulating binary data according to the program’s logic.

• Logic gates perform operations on binary inputs.
• Basic gates include AND, OR, NOT, NAND, NOR, XOR, XNOR.
• Complex operations are built by combining gates.
• Logic gates enable CPU instruction execution.

Registers are small, fast storage locations within the CPU that hold binary data temporarily during processing. They store values such as operands for arithmetic operations, memory addresses, or intermediate results.

Each register consists of a set of flip-flops or similar circuits that can hold a binary digit (bit). For example, an 8-bit register can store an 8-bit binary number, allowing the CPU to process data in fixed-size chunks.

Registers enable quick access to data without the delay of accessing main memory, improving processing speed.

• Registers store binary data temporarily inside the CPU.
• They consist of circuits that hold individual bits.
• Registers have fixed sizes, e.g., 8-bit or 16-bit.
• They provide fast access to data during processing.

In summary, computers use binary because it aligns with the physical properties of electronic circuits, allowing reliable and efficient data representation. All data types are converted into binary so that the CPU can process them uniformly using logic gates. Registers hold this binary data temporarily to facilitate fast computation.

For example, to represent the letter 'A' in binary, the ASCII code 65 is used. The decimal number 65 converts to binary as 01000001. This 8-bit binary number can be stored in a register and manipulated by logic gates during processing.

• Binary matches electronic circuit states for reliability.
• All data types are converted to binary for uniform processing.
• Logic gates manipulate binary data to perform operations.
• Registers temporarily hold binary data for quick access.
• Example: 'A' in ASCII is 65 decimal, which is 01000001 binary.

Number systems represent values using a set of digits and a base that determines place value. Denary (base 10) uses digits 0 to 9, with each digit's place value increasing by powers of 10 from right to left. Binary (base 2) uses only digits 0 and 1, with place values increasing by powers of 2. Hexadecimal (base 16) uses digits 0 to 9 and letters A to F (representing values 10 to 15), with place values increasing by powers of 16.

Understanding these bases is essential because computers operate using binary internally, but hexadecimal provides a more compact and human-friendly way to represent binary data. Denary is the familiar system used in everyday counting and calculations.

• Denary digits: 0–9, base 10.
• Binary digits: 0, 1, base 2.
• Hexadecimal digits: 0–9, A–F, base 16.

To convert a positive denary integer to binary, repeatedly divide the number by 2, recording the remainder each time. The binary number is formed by reading the remainders from last to first.

For example, convert denary 13 to binary: divide 13 by 2: quotient 6, remainder 1; divide 6 by 2: quotient 3, remainder 0; divide 3 by 2: quotient 1, remainder 1; divide 1 by 2: quotient 0, remainder 1. Reading remainders bottom-up gives 1101.

This method works because each division extracts the least significant bit (LSB) of the binary representation. The process continues until the quotient is zero.

• Divide by 2, note remainder.
• Repeat with quotient until zero.
• Binary is remainders read in reverse order.

To convert binary to denary, multiply each binary digit by its place value (a power of 2) and sum the results.

For example, binary 10110 represents: (1 × 2⁴) + (0 × 2³) + (1 × 2²) + (1 × 2¹) + (0 × 2⁰) = 16 + 0 + 4 + 2 + 0 = 22 denary.

This method uses the positional value of each bit, starting from the rightmost bit as 2⁰.

• Multiply each bit by 2 to the power of its position index.
• Sum all products for denary value.

Convert denary to hexadecimal by repeatedly dividing the number by 16 and recording the remainder each time. The hexadecimal number is formed by reading the remainders from last to first, using digits 0–9 and letters A–F for remainders 10–15.

For example, convert denary 254 to hexadecimal: divide 254 by 16: quotient 15, remainder 14 (E); divide 15 by 16: quotient 0, remainder 15 (F). Reading remainders bottom-up gives FE.

This method is analogous to denary-to-binary conversion but uses base 16 instead of 2.

• Divide by 16, note remainder.
• Repeat with quotient until zero.
• Use digits 0–9 and letters A–F for remainders.
• Read remainders in reverse order for hex number.

To convert hexadecimal to denary, multiply each digit by its place value (a power of 16) and sum the results.

For example, hexadecimal 3B7 represents: (3 × 16²) + (11 × 16¹) + (7 × 16⁰) = 768 + 176 + 7 = 951 denary.

Letters A–F correspond to decimal values 10–15. The rightmost digit is multiplied by 16⁰, the next by 16¹, and so on.

• Convert letters A–F to decimal 10–15.
• Multiply each digit by 16 to the power of its position index.
• Sum all products for denary value.

Each hexadecimal digit corresponds exactly to four binary digits (bits), because 16 = 2⁴. To convert hexadecimal to binary, replace each hex digit with its 4-bit binary equivalent.

For example, hex 2F converts to binary by converting 2 → 0010 and F → 1111, so 2F = 00101111 binary.

To convert binary to hexadecimal, split the binary number into groups of four bits starting from the right. Convert each group to its hexadecimal digit. Add leading zeros if necessary to complete the leftmost group of four bits.

• Hex digit = 4 binary bits.
• Hex to binary: replace each hex digit with 4-bit binary.
• Binary to hex: group bits in fours, convert each group to hex digit.
• Pad with leading zeros if needed.

Hexadecimal is a base-16 number system that uses sixteen distinct symbols: the digits 0 to 9 and the letters A to F, where A represents 10 and F represents 15 in decimal. Each hexadecimal digit corresponds exactly to four binary digits (bits). This direct relationship allows easy conversion between binary and hexadecimal.

For example, the binary number 11011110 can be split into two groups of four bits: 1101 and 1110. The first group, 1101, equals 13 in decimal, which is D in hexadecimal. The second group, 1110, equals 14 in decimal, which is E in hexadecimal. Thus, 11011110 in binary is DE in hexadecimal.

• Hexadecimal is base 16, using digits 0–9 and letters A–F.
• Each hex digit represents exactly 4 binary bits.
• Conversion between binary and hex is straightforward by grouping bits in fours.

Binary numbers can become very long and difficult to read or write, especially when representing large values. Hexadecimal reduces the length of these numbers by a factor of four, making them more compact and easier to interpret.

For instance, an 8-bit binary number like 11110000 is eight digits long, but its hexadecimal equivalent is F0, only two digits. This compactness reduces errors when reading or writing numbers and simplifies debugging and programming tasks.

• Hexadecimal shortens long binary sequences by grouping bits.
• Improves readability and reduces human error.
• Simplifies writing and interpreting binary data.

Hexadecimal is widely used in computer science wherever binary data needs to be represented in a human-friendly form. Key applications include:

Memory addressing: Memory locations are often shown in hexadecimal to compactly represent addresses that would be very long in binary.

Colour representation: In web design and graphics, colours are commonly specified using hexadecimal codes, such as #FF5733, where each pair of hex digits represents red, green, and blue intensity levels respectively, each ranging from 00 to FF (0 to 255 decimal). This makes colour codes concise and easy to manipulate compared to binary or decimal values.

• Memory addresses are displayed in hexadecimal for compactness.
• Hexadecimal codes represent colours in graphics and web design.
• Programming languages use hex to represent binary data efficiently.

To convert a binary number to hexadecimal, split the binary number into groups of four bits starting from the right. Convert each group to its hexadecimal equivalent.

Example: Convert binary 101101111001 to hexadecimal.

Step 1: Split into groups of four bits: 1011 0111 1001. Step 2: Convert each group: 1011 = 11 decimal = B hex; 0111 = 7 decimal = 7 hex; 1001 = 9 decimal = 9 hex. Step 3: Combine: B79 hex. Therefore, 101101111001 binary equals B79 hexadecimal.

• Group binary digits in fours from right to left.
• Convert each group to decimal, then to hex digit.
• Combine hex digits for the final hexadecimal number.

Hexadecimal provides a concise, readable way to represent binary data, reducing the length of binary strings by a factor of four. This makes it easier for humans to read, write, and debug data in computing contexts.

Its applications in memory addressing, colour coding, and programming highlight its importance in computer science. Understanding hexadecimal and its relationship to binary is essential for efficient data representation and manipulation.

• Hexadecimal condenses binary data for human use.
• Widely applied in memory addresses and colour codes.
• Essential for programmers and computer scientists to interpret binary data efficiently.

An 8-bit binary number consists of 8 binary digits (bits), each bit representing a power of 2, starting from 2^0 on the right to 2^7 on the left. Because each bit can be either 0 or 1, the smallest value is 00000000 (decimal 0) and the largest is 11111111 (decimal 255).

The maximum decimal value for an 8-bit unsigned binary number is calculated as:

(2^7) + (2^6) + (2^5) + (2^4) + (2^3) + (2^2) + (2^1) + (2^0) = 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255.

• 8 bits represent values from 0 to 255 inclusive.
• Each bit corresponds to a power of 2, from 2^0 to 2^7.
• The largest 8-bit number is 11111111 in binary, equal to 255 in decimal.

Binary addition follows rules similar to decimal addition but uses base 2. The rules for adding two bits are:

0 + 0 = 0 (sum 0, carry 0) 0 + 1 = 1 (sum 1, carry 0) 1 + 0 = 1 (sum 1, carry 0) 1 + 1 = 0 (sum 0, carry 1) — because 1 + 1 in binary equals 10 (2 in decimal).

When adding two 8-bit numbers, start from the least significant bit (rightmost) and move left, adding each pair of bits along with any carry from the previous addition. The carry is added to the next bit pair.

• Add bits from right to left, including any carry.
• If sum of bits is 2 (binary 10), write 0 and carry 1 to next bit.
• Continue until all bits and carry are processed.
• If a carry remains after the leftmost bit, it indicates overflow.

Add the two 8-bit binary numbers: 00110110 (decimal 54) and 01001101 (decimal 77).

Step 1: Write the numbers aligned by bit position:

00110110 (54) + 01001101 (77) ----------------- Step 2: Add bit by bit from right to left, including carry: Bit 0: 0 + 1 = 1, carry 0 Bit 1: 1 + 0 = 1, carry 0 Bit 2: 1 + 1 = 0, carry 1 Bit 3: 0 + 1 + carry 1 = 0, carry 1 Bit 4: 1 + 0 + carry 1 = 0, carry 1 Bit 5: 1 + 0 + carry 1 = 0, carry 1 Bit 6: 0 + 1 + carry 1 = 0, carry 1 Bit 7: 0 + 0 + carry 1 = 1, carry 0 Step 3: Write the result bits from left to right: 10000011 Step 4: Convert result to decimal: 1×128 + 0 + 0 + 0 + 0 + 0 + 1×2 + 1×1 = 128 + 0 + 0 + 0 + 0 + 0 + 2 + 1 = 131 Step 5: Check decimal sum: 54 + 77 = 131, which matches the binary result. No overflow occurred because the result fits within 8 bits.

• Add bits right to left, including carry.
• Result is 10000011 (binary) = 131 (decimal).
• Sum is within 0–255, so no overflow.

Overflow happens when the sum of two binary numbers exceeds the maximum value that can be stored in the given number of bits. For an 8-bit register, this maximum is 255. If the result is greater than 255, the register cannot represent the correct value, causing an overflow error.

Overflow is detected if there is a carry out of the most significant bit (leftmost bit) after addition. This carry cannot be stored in the 8-bit register, so the result wraps around, leading to an incorrect value.

For example, adding 11111111 (255) and 00000001 (1) results in 1 00000000 (binary 9 bits), but only the lower 8 bits (00000000) are stored, which is 0 in decimal — an incorrect result due to overflow.

• Overflow occurs if sum > 255 for 8-bit numbers.
• Carry out of the leftmost bit indicates overflow.
• Overflow causes incorrect results due to limited register size.

Overflow can cause serious errors in computations if not detected or handled properly. In computer systems, overflow detection is important to ensure data integrity.

Some processors have flags (overflow or carry flags) that indicate when overflow occurs, allowing software to respond appropriately, such as by raising an error or using larger registers.

Understanding overflow helps in designing algorithms and systems that avoid exceeding data limits or that use larger bit-widths when necessary.

• Overflow detection is critical for reliable computing.
• Processors use flags to signal overflow.
• Programmers must consider overflow when working with fixed-size registers.

Logical binary shifts move all bits in a binary number either to the left or to the right by a specified number of positions. This operation is performed on fixed-length binary numbers, such as 8-bit registers, which can represent integers from 0 to 255 when unsigned.

In a logical left shift, bits move towards the more significant positions (left), and zeros fill the least significant bits (right). Conversely, a logical right shift moves bits towards the less significant positions (right), and zeros fill the most significant bits (left).

Bits that move beyond the register boundary are discarded and lost permanently. This loss can affect the numerical value represented by the binary number.

• Shifting moves bits left or right within a fixed-length register.
• Zeros fill the vacant bit positions opposite to the shift direction.
• Bits shifted out of the register are lost and cannot be recovered.

Each logical left shift on a positive binary number effectively multiplies the number by 2, provided no significant bits are lost during the shift.

For example, consider the 8-bit binary number 00011010, which equals 26 in decimal.

Performing one logical left shift: shift all bits one place left, discard the leftmost bit if it moves out, and insert a zero at the rightmost bit.

• Original: 00011010 (decimal 26)
• After 1 left shift: 00110100 (decimal 52)
• Calculation: 26 × 2 = 52
• If multiple left shifts are performed, multiply by 2 for each shift (e.g., two shifts multiply by 4).

Each logical right shift divides the number by 2, discarding any remainder, as bits shifted out on the right are lost and zeros are inserted on the left.

For example, take the 8-bit binary number 00110100 (decimal 52).

Performing one logical right shift moves bits one place right, inserts zero on the left, and discards the rightmost bit.

• Original: 00110100 (decimal 52)
• After 1 right shift: 00011010 (decimal 26)
• Calculation: 52 ÷ 2 = 26 (integer division)
• Multiple right shifts divide by 2 for each shift, discarding remainders (e.g., two shifts divide by 4).

When bits are shifted out of the 8-bit register, they are lost permanently. This can cause significant changes in the number's value, especially if the lost bits contain important information.

For example, shifting 11110000 (decimal 240) left by one bit results in 11100000 (decimal 224) after discarding the leftmost bit. The expected multiplication by 2 would be 480, which cannot be represented in 8 bits, so overflow occurs and the value wraps around incorrectly.

Similarly, right shifts discard the least significant bits, which means fractional parts are lost during division, resulting in integer division with truncation.

• Loss of bits can cause overflow or loss of precision.
• 8-bit registers can only represent values 0 to 255; exceeding this causes incorrect results.
• Right shifts perform integer division, losing fractional parts.
• Always consider register size limits when shifting.

Logical shifts can be performed multiple times in succession. Each shift multiplies or divides the number by 2, so multiple shifts multiply or divide by powers of two.

For example, shifting 00000011 (decimal 3) left by 3 bits:

After 1 shift: 00000110 (6) = 3 × 2¹, no bit loss; 6 ≤ 255, valid result. After 2 shifts: 00001100 (12) = 3 × 2², still valid. After 3 shifts: 00011000 (24) = 3 × 2³, still valid.

• Multiple shifts multiply/divide by 2ⁿ, where n is the number of shifts.
• Check for bit loss or overflow after each shift.
• Use binary arithmetic to verify results.
• Example: shifting 00000011 left 3 times results in 00011000 (decimal 24).

Computers represent numbers in binary, but to handle both positive and negative integers, a special system is needed. Two's complement is the most common method for representing signed integers in binary form. It allows a single binary system to encode positive and negative numbers, enabling straightforward arithmetic operations such as addition and subtraction without separate logic for signs.

In an 8-bit system, each number is stored in a sequence of 8 bits (binary digits), where the leftmost bit (most significant bit) indicates the sign: 0 for positive, 1 for negative. Two's complement encoding ensures that arithmetic operations work correctly across positive and negative values.

• Two's complement uses 8 bits to represent integers.
• The most significant bit (MSB) is the sign bit: 0 means positive, 1 means negative.
• It allows addition and subtraction without separate sign handling.

With 8 bits, two's complement can represent integers from -128 to +127. This range arises because one bit is reserved for the sign, and the remaining bits represent the magnitude.

The smallest number is -128, represented as 10000000 in binary.

The largest number is +127, represented as 01111111 in binary.

• Range: -128 to +127 for 8-bit two's complement.
• Negative numbers have MSB = 1; positive numbers have MSB = 0.
• Zero is represented as 00000000.

For positive integers (including zero), conversion to two's complement is straightforward: convert the number to binary normally and ensure it fits in 8 bits by adding leading zeros if necessary.

Example: Convert +18 to 8-bit two's complement binary.

Step 1: Convert 18 to binary: 10010 (which is 5 bits). Step 2: Add leading zeros to make 8 bits: 00010010. Result: 00010010 represents +18 in two's complement.

• Positive numbers are represented as standard binary.
• Pad with leading zeros to fill 8 bits.
• Example: +18 → 00010010.

To convert a negative integer to two's complement:

1. Find the binary representation of its absolute value in 8 bits.

2. Invert all bits (change 0 to 1 and 1 to 0). 3. Add 1 to the inverted binary number. This process produces the two's complement representation of the negative number, allowing computers to perform arithmetic correctly using the same addition circuitry as for positive numbers. Example: Convert -18 to 8-bit two's complement binary. Step 1: Absolute value of -18 is 18 → 00010010. Step 2: Invert bits: 11101101. Step 3: Add 1: 11101101 + 1 = 11101110. Result: 11101110 represents -18 in two's complement.

• Invert bits of absolute value's binary.
• Add 1 to the inverted bits.
• Example: -18 → 11101110.

To convert an 8-bit two's complement binary number back to denary:

If the MSB is 0, convert the binary directly to denary as a positive number.

If the MSB is 1, the number is negative: 1. Invert all bits. 2. Add 1 to the inverted bits. 3. Convert the result to denary and add a negative sign. Example: Convert 11101110 to denary. MSB is 1, so number is negative. Invert bits: 00010001. Add 1: 00010001 + 1 = 00010010. Convert to denary: 18. Result: -18.

• If MSB=0, convert directly to positive denary.
• If MSB=1, invert bits, add 1, convert to denary, then negate.
• Example: 11101110 → -18.

Two's complement simplifies hardware design because addition and subtraction can be performed using the same binary addition circuits for both positive and negative numbers. There is no need for separate subtraction logic or sign handling.

It also avoids the problem of having two representations for zero, which occurs in other signed number systems like sign-magnitude.

This efficiency makes two's complement the standard method for signed integer representation in almost all modern computer systems.

• Enables uniform addition and subtraction circuitry.
• Eliminates dual zero representations.
• Simplifies computer arithmetic and logic design.