在C 4byte浮动ieee754中没有运算符的乘法和除法

2019年7月21日 210次阅读

我需要一些帮助来编程.

我必须编写一个程序,它可以在没有操作符的情况下进行分频和乘法,并且包含IEEE 754标准.我只能使用, – ,否定和逻辑运算.需要从文件中读取数字和运算符.

到目前为止,我得到了这个,但它没有正常工作.

#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>

float mult(float a, float b) {
    float i = 0;
    float c = 0;
    while (i < b) {
        c = c + a;
        i++;
    }
    return c;
}


//this will be needed to divide
float product=1,multiplier=2,a=1;
int steps=0;
void divCore(float number, float divideBy,float lastDivison)
{
    steps++;
    if(number - divideBy < 
        return;
    else
    {
        lastDivison = divideBy;
        divideBy *= multiplier;
        if(number >= divideBy)
        {
            product *= multiplier;
            divCore(number,divideBy,lastDivison);
        }
        else
        {
            a *= 0.5;
            multiplier = 1 + a;
            divCore(number,lastDivison,lastDivison);
        }
    }
}
//its an other function for division ,you use this in main
float Divide(float numerator, float denominator)
{
    //init data
    int neg=(numerator<0)?-1:1;
    neg*=(denominator<0)?-1:1;
    product = 1;
    multiplier = 2;
    a = 1;
    steps =0;
    divCore(abs(numerator),abs(denominator),0);
    return product*neg;
}

int main()
{
    float i,j;
    char c[2];
    FILE *in=fopen("input.txt","r");
    fscanf(in,"%f",&i);
    fscanf(in,"%s",c);
    fscanf(in,"%f",&j);
    if(strcmp(c,"*")==0){
        float a = mult(i,j);
        printf("%f\n", a);
    }
    if(strcmp(c,"/")==0){
        float a2 = Divide(i,j);
        printf("%f\n", a2);
    }

    getchar();
    getchar();
}

文件看起来像这样(我认为数字不算)：

0x0000C942
*
0x0000C942

最佳答案 只是为了好玩(所以不要请求downvote).此代码遵守任务中提供的规则;-) ie.不使用C除法(/)或乘法(*)运算符：

float mult(float a, float b)
{
    float m;

    _asm
    {
        fld a
        fld b
        fmul
        fstp m
    }

    return m;
}

float div(float numerator, float denominator)
{
    float d;

    _asm
    {
        fld numerator
        fld denominator
        fdiv
        fstp d
    }

    return d;
}

因为这里没有人提供解决方案是乘法(仅标准化)：

float mul(float a, float b)
{
    // for normalized floats only

    unsigned int a_bits = *((unsigned int*)&a);
    unsigned int b_bits = *((unsigned int*)&b);

    // hints (* means 'any value')
    // ------------------------------------
    // sign | exp_bits | coeff_bits | value
    // ------------------------------------
    //   0  |    0     |     0      | +0.0
    //   1  |    0     |     0      | -0.0
    // ------------------------------------
    //   *  |    0     |    !0      | we'll not handle denormalized here
    //   *  |0x01-0xFE |     *      | (-1)^s * 1.coeff * 2^(exp_val-127)
    // ------------------------------------
    //   0  |   0xFF   |     0      | +Inf  0x7F800000
    //   1  |   0xFF   |     0      | -Inf  0xFF800000
    // ------------------------------------
    //   *  |   0xFF   |    !0      | NaN  for example 0x7FFFFFFF (8388607 NaN representations)
    // ------------------------------------

    // if bits 0..30 are 0 (ie. both exp and coeff bits are all 0)
    // then our number is zero and multiplication result is zero
    if ( ((a_bits << 1) == 0) || ((b_bits << 1) == 0)) // << 1 clears sign bit
    {
        return 0.0;
    }

    int a_exp_bits = (a_bits >> 23) & 0xFF;
    int b_exp_bits = (b_bits >> 23) & 0xFF;

    // when exp bits are 0xFF = value may be +-Inf or Nan so result is NaN too
    if ( (a_exp_bits == 0xF) || (b_exp_bits == 0xF))
    {
        unsigned int NaN = ~(1 << 31); // this is one of 8388607 NaN representations
        return *((float*)&NaN);
    }

    int a_exp_val = a_exp_bits - 127;
    int b_exp_val = b_exp_bits - 127;

    int a_coeff_bits = a_bits & ((1 << 24) - 1);
    int b_coeff_bits = b_bits & ((1 << 24) - 1);

    // let's multiply
    unsigned long long a24 = (unsigned long long)a_coeff_bits | (1LL << 23); // add implicit 24th bit
    unsigned long long b24 = (unsigned long long)b_coeff_bits | (1LL << 23); // add implicit 24th bit

    unsigned long long c = 0;

    // perform regular multiplication
    for(int bit = 0; bit < 24; bit++)
    {
        if (a24 & (1LL<<bit))
        {
            c += b24 << bit;
        }
    }

    // result can be 47 or 48 bit wide ie (and have 46th or 47th bit set)
    // shift coefficient/significand to the right place
    if (c & (1LL << 47))
    {
        c >>= 47 - 23;
    }
    else if (c & (1LL << 46))
    {
        c >>= 46 - 23;
    }

    c &= ~(1<<23); // clear 24th bit (implicitly stored)

    int c_exp_val = a_exp_val + b_exp_val + 1;
    if ((c_exp_val >= 0xff) || (c_exp_val <= 0))
    {
        // ble - NaN?
    }

    int c_exp_bits = ((c_exp_val + 127) & 0xFF) << 23;
    int c_sign_bit = (a_bits & (1<<31)) ^ ((b_bits & (1<<31)));

    int ret = c_sign_bit | c_exp_bits | (int)c; 

    return *((float*)&ret);
}

不完美,但似乎做了这个工作.

点赞