How to simulate a 4-bit binary adder in C - c

Question

My professor assigned the class to write a C program to simulate a 32-bit adder using basic adders. I know a 32-bit adder is made up of 8 X 4-bit adders. However, I am unsure even how to simulate a 4-bit adder in C. I need to implement a 4-bit binary ripple carry adder, a 4-bit binary look-ahead carry generator, and a 4-bit look-ahead carry adder. From the truth table of a full adder and a Karnaugh map, I obtained the functions of the Sum and Carry Out outputs. For Sum I received A xor B xor Carry In. For the Carry out function, I received (A*B) + (Carry in(A xor B)). Now I am unsure where to go. I'm pretty sure I need to manipulate the integers at the bit level using bitwise operators (I have basic knowledge of bitwise operators although I have never implemented them outside of paper and pencil).
How do I break the integers up to obtain the A, B and Carry In inputs for the functions? How do I obtain the Sum and Carry Out outputs? How do I string the full adders together to obtain a 4-bit adder?
Thank you for the help!

Answer 1

Well, for a simple solution, we can take a half adder and full adder circuit diagram and abstract it a bit. From Wikipedia:
Half Adder:
Full Adder:
#include<stdio.h>
typedef char bit;
bit carry = 0;
bit halfadd( bit A, bit B ){
carry = A & B;
return A ^ B;
}
bit fulladd( bit A, bit B ){
bit xor = A ^ B;
bit ret = carry ^ xor;
carry = (carry & xor) | (A & B);
return ret;
}
void fillNum( int num, bit *array ){
int i;
for( i = 0; i < 32; ++ i ){
array[i] = ( num >> i ) & 1;
}
}
int main(){
bit num1[32] = {0}, num2[32] = {0};
int A = 64620926, B = 1531529858;
fillNum( A, num1 );
fillNum( B, num2 );
int r = 0;
bit tmp = halfadd( num1[0], num2[0] );
putchar( tmp ? '1' : '0' );
r = tmp;
int i;
for( i = 1; i < 32; ++i ){
tmp = fulladd( num1[i], num2[i] );
r += tmp << i;
putchar( tmp ? '1' : '0' );
}
putchar( carry ? '1' : '0' );
printf("\n%d\n\n%d + %d = %d", r, A, B, A+B);
return 0;
}
That will output the added value with the LSB first, but it demonstrates the basic principal. This works according to Ideone. Just apply a similar approach to handling logic circuitry when simulating 4 bit adders.
If you don't want to read the integers to an array first, you can always use
#define GETBIT(num,bit)((num>>bit)&1)
For safety, you can put it in to a function call if you want

Answer 2

If I were doing this, I would simulate a 4 bit adder with a Lookup Table. In this case it would be a 256 entry table that could be setup like a 16 x 16 array of values.
unsigned short outputs[16][16];
multOut = outputs[inA][inB];
You will have to initialize your array, but that should be pretty simple.
Use the 5th bit of each value in the array as your carry out bit.

Answer 3

To start you will need to break your larger integers into individual bits. This will depend on the endianess of your system (whether numbers are stored most, or least significant bit first). An array of bit masks would help. Assuming big endian,
int bit[]={
1<<0, //least significant bit
1<<1,
1<<2,
1<<3
};
So then to get the first bit of a number you would do
leastSignificantBitOfA = A&bit[0];
From there you could either use some shared array to store outputs or maybe make a simple structure like:
struct fullAdderReturn{
int sum;
int carryOut;
}
struct fullAdderReturn oneBitAdder(int a, int b, int carryIn)
{
struct fullAdderReturn output;
output.sum = a&b;
output.carryOut = (a&b) | (a&carryIn) | (b&carryIn);
return output;
}
I put together a simple 2-bit ripple adder here http://ideone.com/NRoQMS hopefully it gives you some ideas .