添加 IEEE-754 格式的正数和负数

Question

My problem seems to be pretty simple: I wrote a program that manually adds floating point numbers together. This program has certain restrictions. (such as no iostream or use of any unary operators), so that is the reason for the lack of those things. As for the problem, the program seems to function correctly when adding two positive floats (1.5 + 1.5 = 3.0, for example), but when adding two negative numbers (10.0 + -5.0) I get very wacky numbers. Here is the code:

#include <cstdio>
#define BIAS32 127

struct Real
{
    //sign bit
    int sign;
    //UNBIASED exponent
    long exponent;
    //Fraction including implied 1. at bit index 23
    unsigned long fraction;
};

Real Decode(int float_value);
int Encode(Real real_value);
Real Normalize(Real value);
Real Add(Real left, Real right);
unsigned long Add(unsigned long leftop, unsigned long rightop);
unsigned long Multiply(unsigned long leftop, unsigned long rightop);
void alignExponents(Real* left, Real* right);
bool is_neg(Real real);
int Twos(int op);

int main(int argc, char* argv[])
{
    int left, right;
    char op;
    int value;
    Real rLeft, rRight, result;
    if (argc < 4) {
        printf("Usage: %s <left> <op> <right>\n", argv[0]);
        return -1;
    }
    sscanf(argv[1], "%f", (float*)&left);
    sscanf(argv[2], "%c", &op);
    sscanf(argv[3], "%f", (float*)&right);
    rLeft = Decode(left);
    rRight = Decode(right);

    if (op == '+') {
        result = Add(rLeft, rRight);
    }
    else {
        printf("Unknown operator '%c'\n", op);
        return -2;
    }
    value = Encode(result);
    printf("%.3f %c %.3f = %.3f (0x%08x)\n",
        *((float*)&left),
        op,
        *((float*)&right),
        *((float*)&value),
        value
    );
    return 0;
}

Real Decode(int float_value)
{             // Test sign bit of float_value - Test exponent bits of float_value & apply bias - Test mantissa bits of float_value
    Real result{ float_value >> 31 & 1 ? 1 : 0, ((long)Add(float_value >> 23 & 0xFF, -BIAS32)), (unsigned long)float_value & 0x7FFFFF };
    return result;
};
    
int Encode(Real real_value)
{
    int x = 0;
    x |= real_value.fraction; // Set the fraction bits of x 
    x |= real_value.sign << 31; // Set the sign bits of x
    x |= Add(real_value.exponent, BIAS32) << 23; // Set the exponent bits of x
    return x;
}

Real Normalize(Real value)
{
    if (is_neg(value))
    {
        value.fraction = Twos(value.fraction);
    }
    unsigned int i = 0;
    while (i < 9)
    {
        if ((value.fraction >> Add(23, i)) & 1) // If there are set bits past the mantissa section
        {
            value.fraction >>= 1; // shift mantissa right by 1
            value.exponent = Add(value.exponent, 1); // increment exponent to accomodate for shift
        }
        i = Add(i, 1);
    }
    return value;
}

Real Add(Real left, Real right)
{
    Real a = left, b = right;
    alignExponents(&a, &b); // Aligns exponents of both operands
    unsigned long sum = Add(a.fraction, b.fraction);
    Real result = Normalize({ a.sign, a.exponent, sum }); // Normalize result if need be
    return result;
}

unsigned long Add(unsigned long leftop, unsigned long rightop)
{
    unsigned long sum = 0, test = 1; // sum initialized to 0, test created to compare bits
    while (test) // while test is not 0
    {
        if (leftop & test) // if the digit being tested is 1
        {
            if (sum & test) sum ^= test << 1; // if the sum tests to 1, carry a bit over
            sum ^= test;
        }
        if (rightop & test)
        {
            if (sum & test) sum ^= test << 1;
            sum ^= test;
        }
        test <<= 1;
    }
    return sum;
}

void alignExponents(Real* a, Real* b)
{
    if (a->exponent != b->exponent) // If the exponents are not equal
    {
        if (a->exponent > b->exponent)
        {
            int disp = a->exponent - b->exponent; // number of shifts needed based on difference between two exponents
            b->fraction |= 1 << 23; // sets the implicit bit for shifting
            b->exponent = a->exponent; // sets exponents equal to each other
            b->fraction >>= disp; // mantissa is shifted over to accomodate for the increase in power
            return;
        }
        int disp = b->exponent - a->exponent;
        a->fraction |= 1 << 23;
        a->exponent = b->exponent;
        a->fraction >>= disp;
        return;
    }
    return;
}

bool is_neg(Real real)
{
    if (real.sign) return true;
    return false;
}

int Twos(int op)
{
    return Add(~op, -1); // NOT the operand and add 1 to it
}

On top of that, I just tested the values 10.5 + 5.5 and got a 24.0, so there appears to be even more wrong with this than I initially thought. I've been working on this for days and would love some help/advice.

Answer 1

Here is some help/advice. Now that you have worked on some of the code, I suggest going back and reworking your data structure. The declaration of such a crucial data structure would benefit from a lot more comments, making sure you know exactly what each field means.

For example, the implicit bit is not always 1. It is zero if the exponent is zero. That should be dealt with in your Encode and Decode functions. For the rest of your code, it is just a significand bit and should not have any special handling.

When you start thinking about rounding, you will find you often need more than 23 bits in an intermediate result.

Making the significand of negative numbers 2's complement will create a problem of having the same information stored two ways. You will have both a sign bit as though doing sign-and-magnitude and have the sign encoded in the signed integer signficand. Keeping them consistent will be a mess. Whatever you decide about how Real will store negative numbers, document it and keep it consistent throughout.

If I were implementing this I would start by defining Real very, very carefully. I would then decide what operations I wanted to be able to do on Real, and write functions to do them. If you get those right each function will be relatively simple.