Esempio n. 1
0
int main(void)
{
    //int i = sin90[1];
    int z;
    int a = 10, b = 5, c;
    //_Fract fr;
    //fr = 0.6;
    unsigned int i = 0xFFFF;
    float y = 0.5;
    unsigned int x;
    x = (unsigned int)(y * i);
    x++;
    z = MPY(10000, 5000);
    x++;
    c = __builtin_mulss(a, b);
    c = a * b;
    return z;

}
Esempio n. 2
0
FLOAT                      /*{ ret - fmod(x)}*/
_fmodf(
    FLOAT x,               /*{ (i) - numerator }*/
    FLOAT y                /*{ (i) - denominator }*/
)
{
    FLOAT x_abs, y_abs, y_1, y_2;
    FLOAT val, val_int;
    FLOAT remainder;
    LONG *lyPtr = (LONG *)&y_1;

    /*{ if y == 0 and x/y = +-INF for |x| > 0, return 0.0 }*/
    /*{ if y == 0 and x/y = undefined for x = 0, return 0.0 }*/
    if (y == (FLOAT)0.0)
    {
        return (FLOAT)0.0;
    }

    /*{ x_abs = |x| }*/
    /*{ y_abs = |y| }*/
    x_abs = x;
    if (x < (FLOAT)0.0)
    {
        x_abs = -x_abs;
    }
    y_abs = y;
    if (y < (FLOAT)0.0)
    {
        y_abs = -y_abs;
    }
    if (x_abs < y_abs)
    {
        return x;
    }
    
    /*{ val_int = integer part of x_abs/y_abs }*/
    val = DIV(x_abs, y_abs);
    modff(val, &val_int);

    /* 
     * val_int = integer part of (x_abs / y_abs) 
     * the floating point remainder is simply sign(x)*(x_abs - val_int * y_abs)
     */

    /*{ y_1 = upper bits of y }*/
    y_1 = y_abs;
    *lyPtr = *lyPtr & 0xfffff000;
    /*{ y_2 = y - y_1 }*/
    y_2 = y_abs - y_1;


    /*{ remainder = x_abs - val_int * y_abs (using higher precision )}*/
    /*{!INDENT}*/
    /*{ remainder = x_abs - (val_int * y_1) }*/
    /*{ remainder = remainder - (val_int * y_2) }*/
    remainder = SUB(x_abs, MPY(val_int, y_1));
    remainder = SUB(remainder, MPY(val_int, y_2));
    /*{!OUTDENT}*/

    /* { if remainder < 0.0, then a rounding error has occurred }*/
    if (remainder < (FLOAT)0.0)
    {
        /* rounding error occurred */

        /*{ val_int-- }*/
        val_int = SUB(val_int, 1.0);
        /*{ re-compute remainder }*/
        remainder = SUB(x_abs, MPY(val_int, y_1));
        remainder = SUB(remainder, MPY(val_int, y_2));
    }


    /*{ if x < 0, remainder = -remainder }*/
    if (x < (FLOAT)0.0)
    {
        remainder = -remainder;
    }

    /*{ return remainder }*/
    return remainder;
}
Esempio n. 3
0
FLOAT                                /*{ ret - tanh(x) }*/
_tanhf(
    FLOAT x                          /*{ (i) - value to do tanhf on }*/
)
{
    FLOAT f, g, xnum, xden;
    FLOAT result;
    FLOAT sign = 1.0;

    /*{ f = |x| }*/
    f = x;
    /*{ sign = 1 }*/
    /*{ if x < 0, sign = -sign }*/
    if (x < (FLOAT)0.0)
    {
        f = -f;
        sign = -sign;
    }

    /*{ if f > TANH_BIGNUM, return sign }*/
    if (f > (FLOAT)TANH_BIGNUM)
    {
        return sign;
    }

    /*{ if f > ln(3)/2 }*/
    if (f > (FLOAT)LN3_2)
    {
        /*{ result = 1 - 2/(exp(2f) + 1) }*/
        result = ADD(f, f);
        result = expf(result);
        result = ADD(1.0, result);
        result = DIV(2.0, result);
        result = SUB(1.0, result);
    }
    /*{ else f <= ln(3)/2 }*/
    else
    {
        /*{ if f < EPS, return x }*/
        if (f < (FLOAT)FLT_EPSILON)
        {
            result = x;
            return result;
        }

        /*{ g = f * f }*/
        g = MPY(f, f);

        /*{ R(g) = g * P(g)/Q(g) }*/
        /*{!INDENT}*/
        /*{ P(g) = p1 * g + p0 }*/
        xnum = MPY(TANHP_COEF1, g);
        xnum = ADD(xnum, TANHP_COEF0);

        /*{ Q(g) = (g + q1) * g + q0 }*/
        xden = ADD(TANHQ_COEF1, g);
        xden = MPY(xden, g);
        xden = ADD(xden, TANHQ_COEF0);
        /*{!OUTDENT}*/

        /*{ result = f + f * R(g) }*/
        result = DIV(xnum, xden);
        result = MPY(result, g);
        result = MPY(result, f);
        result = ADD(result, f);

    }

    /*{ if sign < 0, result = -result }*/
    if (sign < (FLOAT)0.0)
    {
        result = -result;
    }

    /*{ return result }*/
    return result;
}