1.2.3 Binary Arithmetic

Computers use binary arithmetic as their fundamental way of performing arithmetic operations because digital electronic circuits inherently operate in binary (base-2) rather than in decimal (base-10) like humans do. In binary arithmetic, there are only two digits: 0 and 1.

Main Idea

Binary arithmetic is the method of performing mathematical operations—addition, subtraction, multiplication, and division—using only the binary digits 0 and 1. The rules are similar to decimal arithmetic, but simpler because there are only two digits. When the result of adding two bits exceeds 1, a carry is generated to the next higher bit position. When subtracting a larger bit from a smaller bit, a borrow is taken from the next higher bit position.

Core Concept

Basic Arithmetic Operations: Computers perform addition, subtraction, multiplication, and division in binary just like in decimal, but with binary digits (bits) instead of decimal digits.

The key difference from decimal arithmetic is that in binary:

• There are only two digits: 0 and 1.
• The base is 2, not 10.
• A carry is generated when the sum of bits equals or exceeds 2.
• A borrow is needed when subtracting a larger bit from a smaller bit.

Detailed Explanation

Binary Addition

Binary addition is performed much like decimal addition, but with only two possible digits: 0 and 1.

When adding two binary digits (bits), the possible outcomes are:

0 + 0 = 0

0 + 1 = 1

1 + 0 = 1

1 + 1 = 10 (carry 1 to the next higher bit)

Example 1: 10010 + 111

\beginarrayr 10010 → 18 (Decimal) \\ + 111 → +7 (Decimal) \\ \hline 11001 → 25 \endarray

Example 2: 11101010 + 10011011

\beginarrayr 11101010 \\ + 10011011 \\ \hline 110000101 \endarray

Hint: To verify your answer, you can convert the binary number to decimal and perform decimal arithmetic.

Binary Subtraction

Binary subtraction is performed much like decimal subtraction, but with only two possible digits: 0 and 1.

Borrowing is used when subtracting a larger number from a smaller one.

0 - 0 = 0

1 - 0 = 1

1 - 1 = 0

0 - 1 = 1 with borrowing (borrow 1 from the next higher bit)

Example 1: 10110 - 101

\beginarrayr 10110 \\ - 101 \\ \hline 10001 \endarray

Example 2: 11000101 - 101111

\beginarrayr 11000101 \\ - 101111 \\ \hline 10010110 \endarray

Intermediate Level

At the intermediate level, you should understand why carries and borrows happen.

Why carry? In binary, the largest single digit is 1. So when you add 1 + 1, the result is 2, which cannot be written as a single binary digit. Instead, you write 0 and carry 1 to the next column (which represents 2¹ = 2).

Why borrow? When you need to subtract 1 from 0, you cannot do it directly. So you borrow 1 from the next higher bit. That borrowed 1 is worth 2 in the current column (just like borrowing 1 from the tens column in decimal gives you 10 in the units column). After borrowing, 0 becomes 10 (binary), and 10 - 1 = 1.

Example: Verify with decimal

10010₂ = 18₁₀\) \(111₂ = 7₁₀\) \(18 + 7 = 25₁₀ = 11001₂

This confirms that binary addition works correctly.

Important Points

• - Binary addition follows four basic rules.
• - 1 + 1 = 10 in binary (0 with a carry of 1).
• - Binary subtraction follows four basic rules.
• - Borrowing is needed when subtracting 1 from 0.
• - A carry or borrow propagates to the next higher bit.
• - Binary arithmetic is the foundation of all computer calculations.
• - You can verify binary results by converting to decimal.

Remember

• - 1 + 1 = 10 (carry 1).
• - 0 - 1 = 1 with borrow.
• - Carries and borrows move to the next higher bit (left).
• - Always start from the rightmost bit (LSB) when adding or subtracting.
• - Binary arithmetic rules are simpler than decimal because there are only two digits.

Common Mistakes

• - Forgetting the carry when 1 + 1 occurs.
• - Forgetting the borrow when subtracting 1 from 0.
• - Adding or subtracting from the wrong side (must start from the right).
• - Confusing binary arithmetic with decimal arithmetic (e.g., writing 2 instead of 10).
• - Not aligning numbers properly by their least significant bits.
• - Forgetting that a carry can propagate through multiple columns.

Quick Revision

• Binary addition: 0+0=0, 0+1=1, 1+0=1, 1+1=10.
• Binary subtraction: 0-0=0, 1-0=1, 1-1=0, 0-1=1 (borrow).
• Carries and borrows propagate to the next higher bit.
• Always start from the LSB (rightmost bit).
• Verify results by converting to decimal.

60-Second Revision

• Binary arithmetic uses only 0 and 1.
• Addition: 1+1=10 (carry 1).
• Subtraction: 0-1=1 (borrow 1).
• Start from the rightmost bit.
• Carry/borrow moves left to the next higher bit.
• Warning: Don't write 2 in binary; 1+1 is written as 10.