0

I have this function and everything works until a and b both equal 1. When that happens the carry bit is going to 2 when its supposed to be only 0 or 1. Is my algorithm wrong for the carry bit
carry_bits |= ((a & mask) & (b & mask)) << 1u;

bool add7bits( unsigned int a, unsigned int b, unsigned int *carry_out, unsigned int     *overflow_out, unsigned int *sum_out)
{
if ( a > ( ( 1u << NUM_BITS ) - 1 ) )
{
    cout << "a value: " << a << " is too large" << endl;
    return false;
}
else if ( b > ( ( 1u << NUM_BITS ) - 1 ) )
{
    cout << "b value: " << b << " is too large" << endl;
    return false;
}
else
{
    unsigned int sum_bits = 0;
    unsigned int carry_bits = 0;
    // Use a mask to access the specific bits of interest
    unsigned int mask = 1u;

    // Handle rightmost bit as a half-adder (no carry input)
    // sum = a ^ b
    // c_out = a & b
    sum_bits |= ( a & mask) ^ ( b & mask);

    // The carry _out_ from this stage sets the carry in for the next,
    // that is, the next higher bit in the carry_bits value

    carry_bits |= ((a & mask) & (b & mask)) << 1u;

    // The remaining bits must be handled with the full adder logic. The last
    // adder in the chain's carry out becomes the carry output return
    // value of this function.
            mask = 1u << 1;

            sum_bits |= ((a & mask) ^ (b & mask) ^ carry_bits);
            carry_bits |= ((a & mask) & (b & mask)) << 1u; 

            mask = 1u << 2;
            sum_bits |= ((a & mask) ^ (b & mask) ^ carry_bits);
            carry_bits |= ((a & mask) & (b & mask)) << 1u;

            mask = 1u << 3;
            sum_bits |= ((a & mask) ^ (b & mask) ^ carry_bits);
            carry_bits |= ((a & mask) & (b & mask)) << 1u;

            mask = 1u << 4;
            sum_bits |= ((a & mask) ^ (b & mask) ^ carry_bits);
            carry_bits |= ((a & mask) & (b & mask)) << 1u;          

            mask = 1u << 5;
            sum_bits |= ((a & mask) ^ (b & mask) ^ carry_bits);
            carry_bits |= ((a & mask) & (b & mask)) << 1u;  
    // Handle bit 6 separately.
    mask = 1u << 6;
    sum_bits = ((a ^b) ^ carry_bits);
    carry_bits |= ((a & mask) & (b & mask)) << 1u;


// Determine the overflow by checking if a and b are both 1.
    bool overflow = false;
    if ((a & mask) & (b & mask))
        overflow = true;
    // ...
    //
 *sum_out = sum_bits;
 *carry_out = carry_bits;
 *overflow_out = overflow;
 cout << a << " + " << b << " = " << *sum_out << endl;;
 cout << "Carry: " << *carry_out << endl;
 cout << "Overflow: " << *overflow_out << endl;
    return true;
}
}
2
Contributors
1
Reply
12
Views
3 Years
Discussion Span
Last Post by Moschops
0

carry_bits |= ((a & mask) & (b & mask)) << 1u;

When a is 1, a & mask is 1, or in binary 00000001.
When b is 1, b & mask is 1, or in binary 00000001.

So ((a & mask) & (b & mask)) is00000001 & 00000001, which gives 00000001.

You then apply this:<< 1u which is left shifting 00000001, so you get 00000010, which is binary for 2.

That's why you get 2.

Edited by Moschops

This topic has been dead for over six months. Start a new discussion instead.
Have something to contribute to this discussion? Please be thoughtful, detailed and courteous, and be sure to adhere to our posting rules.