Home | Blog | Wiki | About

These are purely combinatory circuits.

No clock involved.

Single bit adders

Half adder

A	B	Sum	Carry
0	0	0	0
0	1	1	0
1	0	1	0
1	1	0	1

• Sum = A XOR B
• Carry = AB

Full adder

A	B	Cᵢₙ	Sum	Cₒᵤₜ
0	0	0	0	0
0	0	1	1	0
0	1	0	1	0
0	1	1	0	1
1	0	0	1	0
1	0	1	0	1
1	1	0	0	1
1	1	1	1	1

• Sum = A XOR B XOR Cᵢₙ
• Cₒᵤₜ = Cᵢₙ(A XOR B) + AB

Multi-bit adders

An n-bit adder is made using n 1-bit full adders.

Ripple carry adder

Carry-out of i-th full adder is given as the carry-in of the i+1-st full adder.

The carry signal 'ripples' through the full adders.

• Simple design
• Slower (since each full adder must wait for the carry out from the previous full adder before starting work).

To add n-bit numbers, we need n stages of full adders.

• cinᵢ: Carry-in of i-the full adder
• coutᵢ: Carry-out of i-the full adder

cout of previous full adder becomes cin of next full adder. ie, cinᵢ₊₁ = coutᵢ

Time required for addition in a ripple carry adder = propagation delay of the carry to ripple through the different stage of the overall adder.

The first carry value (which should be part of input) is sometimes called forced carry. And the last carry value (which is part of output) is also known as overflow carry.

aₙ₋₁ bₙ₋₁   coutₙ₋₁     a₁  b₁   cout₀    a₀  b₀ cin₀
  |  |  +-----+          |  |  +-----+     |  |  |        
  |  |  V     |          |  |  |     |     |  |  |        
+---------+   ^        +---------+   ^   +---------+    
|         |   ...      |         |   |   |         |    
|  FAn-1  |    ...     |   FA1   |   |   |   FA0   |    
|         |     ...    |         |   |   |         |
+---------+       ^    +---------+   ^   +---------+    
   |   |          |       |   |      |      |   |        
   V   V          +-------+   V      +------+   V        
       sₙ₋₁         cout₁     s₁       cout₀    s₀
coutₙ₋₁

Output would be calculate like:

sᵢ    = aᵢ ⊕ bᵢ ⊕ cinᵢ
coutᵢ = aᵢ.bᵢ + bᵢ.cinᵢ + aᵢ.cinᵢ

Look ahead carry adder

• An improvement over ripple carry adder.
• aka CLA (Carry Look-ahead Adder)
• carry values calculated parallelly.

Use formula to calculate the value of carry outs faster??

dᵢ = aᵢ.bᵢ
tᵢ = aᵢ ⊕ bᵢ

coutᵢ = dᵢ + tᵢ.cinᵢ
sᵢ    = aᵢ ⊕ bᵢ ⊕ cinᵢ

Carry save adder

Instead of delaying execution by waiting for every previous full adder's carry out to be calculated, we store (ie, 'save') the carry-out of every full adder.

The actual result is calculated by applying the effect all carry out values at the end.

Single bit subtractors

Half subtractor

A	B	D	Borrow
0	0	0	0
0	1	1	1
1	0	1	0
1	1	0	0

• Difference = D = A XOR B
• Borrow = B = A'B

Full subtractor

A	B	Bᵢₙ	D	Bₒᵤₜ
0	0	0	0	0
0	0	1	1	1
0	1	0	1	1
0	1	1	0	1
1	0	0	1	0
1	0	1	0	0
1	1	0	0	0
1	1	1	1	1

• Difference = D = A XOR B XOR Bᵢₙ
• Borrow out = Bₒᵤₜ = A'C + A'B + BC

A \ BC
   \ 00  01  11  10
    +---+---+---+---+
  0 |   | 1 | 1 | 1 |
    +---+---+---+---+
  1 |   |   | 1 |   |
    +---+---+---+---+

K-map for Bout (with C=Bₒᵤₜ)