exprinit.c

数学表达式计算和解析 用c语言编写的,内含有例.速度较快

    EXPRTYPE d1;

    EXPR_REQUIRECOUNT(1);

    EXPR_EVALNODE(0, d1);

    EXPR_CLEARMATHERR();

    *val = ceil(d1);

    EXPR_CHECKMATHERR();

    return EXPR_ERROR_NOERROR;
    }

/* floor */
EXPR_FUNCTIONSOLVER(__expr_floor)
    {
    int err;
    EXPRTYPE d1;

    EXPR_REQUIRECOUNT(1);

    EXPR_EVALNODE(0, d1);

    EXPR_CLEARMATHERR();

    *val = floor(d1);

    EXPR_CHECKMATHERR();

    return EXPR_ERROR_NOERROR;
    }


/* Random functions */

/* rand */
EXPR_FUNCTIONSOLVER(__expr_rand)
    {
    EXPR_REQUIRECOUNT(0);

    EXPR_CLEARMATHERR();

    *val = (EXPRTYPE)rand() / (EXPRTYPE)(RAND_MAX + 1);

    EXPR_CHECKMATHERR();

    return EXPR_ERROR_NOERROR;
    }

/* random */
EXPR_FUNCTIONSOLVER(__expr_random)
    {
    int err;
    EXPRTYPE d1, d2;
    EXPRTYPE diff, rval;

    EXPR_REQUIRECOUNT(2);

    EXPR_EVALNODE(0, d1);
    EXPR_EVALNODE(1, d2);

    EXPR_CLEARMATHERR();
    
    diff = d2 - d1;

    rval = (EXPRTYPE)rand() / (EXPRTYPE)(RAND_MAX);

    *val = (rval * diff) + d1;

    EXPR_CHECKMATHERR();

    return EXPR_ERROR_NOERROR;
    }

/* randomize */
EXPR_FUNCTIONSOLVER(__expr_randomize)
    {
    EXPR_REQUIRECOUNT(0);

    EXPR_CLEARMATHERR();

    srand((clock() + 1024) * time(NULL));

    EXPR_CHECKMATHERR();

    return EXPR_ERROR_NOERROR;
    }

/* srand */
EXPR_FUNCTIONSOLVER(__expr_srand)
    {
    int err;
    EXPRTYPE d1;

    EXPR_REQUIRECOUNT(1);

    EXPR_EVALNODE(0, d1);

    EXPR_CLEARMATHERR();

    srand((unsigned int)(d1 * 32767.0));

    EXPR_CHECKMATHERR();

    return EXPR_ERROR_NOERROR;
    }

/* Conversion functions */

/* convert radians to degrees */
EXPR_FUNCTIONSOLVER(__expr_deg)
    {
    int err;
    EXPRTYPE d1;

    EXPR_REQUIRECOUNT(1);

    EXPR_EVALNODE(0, d1);

    *val = (180.0 / M_PI) * d1;

    return EXPR_ERROR_NOERROR;
    }

/* convert degrees to radians */
EXPR_FUNCTIONSOLVER(__expr_rad)
    {
    int err;
    EXPRTYPE d1;

    EXPR_REQUIRECOUNT(1);

    EXPR_EVALNODE(0, d1);

    *val = (M_PI / 180.0) * d1;

    return EXPR_ERROR_NOERROR;
    }

/* Rectangular to polar radius */
EXPR_FUNCTIONSOLVER(__expr_recttopolr)
    {
    int err;
    EXPRTYPE dx, dy;

    EXPR_REQUIRECOUNT(2);

    EXPR_EVALNODE(0, dx);
    EXPR_EVALNODE(1, dy);

    EXPR_CLEARMATHERR();

    *val = sqrt((dx * dx) + (dy * dy));

    EXPR_CHECKMATHERR();

    return EXPR_ERROR_NOERROR;
    }

/* Rectangular to polar angle */
EXPR_FUNCTIONSOLVER(__expr_recttopola)
    {
    int err;
    EXPRTYPE dx, dy;
    EXPRTYPE tmp;

    EXPR_REQUIRECOUNT(2);

    EXPR_EVALNODE(0, dx);
    EXPR_EVALNODE(1, dy);

    EXPR_CLEARMATHERR();

    tmp = atan2(dy, dx);

    EXPR_CHECKMATHERR();

    /* atan2 automatically checks quadrant and returns -PI to PI */

    /* Convert to 0.0 to 2 * PI */
    if(tmp < 0.0)
        *val = tmp + (2.0 * M_PI);
    else
        *val = tmp;

    return EXPR_ERROR_NOERROR;
    }

/* Convert polar to rect. x */
EXPR_FUNCTIONSOLVER(__expr_poltorectx)
    {
    int err;
    EXPRTYPE dr, da;

    EXPR_REQUIRECOUNT(2);

    EXPR_EVALNODE(0, dr);
    EXPR_EVALNODE(1, da);

    EXPR_CLEARMATHERR();

    *val = dr * cos(da);

    EXPR_CHECKMATHERR();

    return EXPR_ERROR_NOERROR;
    }

/* Convert polar to rect. y */
EXPR_FUNCTIONSOLVER(__expr_poltorecty)
    {
    int err;
    EXPRTYPE dr, da;

    EXPR_REQUIRECOUNT(2);

    EXPR_EVALNODE(0, dr);
    EXPR_EVALNODE(1, da);

    EXPR_CLEARMATHERR();

    *val = dr * sin(da);

    EXPR_CHECKMATHERR();

    return EXPR_ERROR_NOERROR;
    }

/* Comparison functions */

/* if */
EXPR_FUNCTIONSOLVER(__expr_if)
    {
    int err;
    EXPRTYPE cond, res;

    EXPR_REQUIRECOUNT(3);

    EXPR_EVALNODE(0, cond);

    if(cond != 0.0) /* Condition is not false (true) */
        {
        EXPR_EVALNODE(1, res);
        }
    else /* Condition is false */
        {
        EXPR_EVALNODE(2, res);
        }

    *val = res;

    return EXPR_ERROR_NOERROR;
    }

/* select */
EXPR_FUNCTIONSOLVER(__expr_select)
    {
    int err;
    EXPRTYPE cond, res;

    EXPR_REQUIRECOUNTRANGE(3,4);

    EXPR_EVALNODE(0, cond);

    if(cond < 0.0) /* negative, use the first result*/
        {
        EXPR_EVALNODE(1, res);
        }
    else if(cond == 0.0) /* zero, use second result */
        {
        EXPR_EVALNODE(2, res);
        }
    else if(cond > 0.0) /* positive */
        {
        if(count == 3) /* Use second result */
            {
            EXPR_EVALNODE(2, res);
            }
        else /* count == 4, use third result */
            {
            EXPR_EVALNODE(3, res);
            }
        }

    *val = res;

    return EXPR_ERROR_NOERROR;
    }

/* equality */
EXPR_FUNCTIONSOLVER(__expr_equal)
    {
    int err;
    EXPRTYPE d1, d2;

    EXPR_REQUIRECOUNT(2);

    EXPR_EVALNODE(0, d1);
    EXPR_EVALNODE(1, d2);

    *val = (d1 == d2) ? 1.0 : 0.0;

    return EXPR_ERROR_NOERROR;
    }

/* above */
EXPR_FUNCTIONSOLVER(__expr_above)
    {
    int err;
    EXPRTYPE d1, d2;

    EXPR_REQUIRECOUNT(2);

    EXPR_EVALNODE(0, d1);
    EXPR_EVALNODE(1, d2);

    *val = (d1 > d2) ? 1.0 : 0.0;

    return EXPR_ERROR_NOERROR;
    }

/* below */
EXPR_FUNCTIONSOLVER(__expr_below)
    {
    int err;
    EXPRTYPE d1, d2;

    EXPR_REQUIRECOUNT(2);

    EXPR_EVALNODE(0, d1);
    EXPR_EVALNODE(1, d2);

    *val = (d1 < d2) ? 1.0 : 0.0;

    return EXPR_ERROR_NOERROR;
    }

/* More complex functions */

/* Average */
EXPR_FUNCTIONSOLVER(__expr_avg)
    {
    int err, pos;
    EXPRTYPE d1, total;

    EXPR_REQUIRECOUNTMIN(1);

    total = 0.0;

    for(pos = 0; pos < count; pos++)
        {
        EXPR_EVALNODE(pos, d1);

        total = total + d1;
        }

    *val = total / (EXPRTYPE)count;

    return EXPR_ERROR_NOERROR;
    }

/* Clip */
EXPR_FUNCTIONSOLVER(__expr_clip)
    {
    int err;
    EXPRTYPE d1, dmin, dmax;


    EXPR_REQUIRECOUNT(3);

    EXPR_EVALNODE(0, d1);
    EXPR_EVALNODE(1, dmin);
    EXPR_EVALNODE(2, dmax);

    if(d1 < dmin)
        *val = dmin;
    else if(d1 > dmax)
        *val = dmax;
    else
        *val = d1;

    return EXPR_ERROR_NOERROR;
    }

/* Clamp */
EXPR_FUNCTIONSOLVER(__expr_clamp)
    {
    int err;
    EXPRTYPE d1, dmin, dmax;
    EXPRTYPE tmp;

    EXPR_REQUIRECOUNT(3);

    EXPR_EVALNODE(0, d1);
    EXPR_EVALNODE(1, dmin);
    EXPR_EVALNODE(2, dmax);

    EXPR_CLEARMATHERR();

    tmp = fmod(d1 - dmin, dmax - dmin);

    if(tmp < 0.0)
        *val = tmp + dmax;
    else
        *val = tmp + dmin;

    EXPR_CHECKMATHERR();

    return EXPR_ERROR_NOERROR;
    }

/* PntChange */
EXPR_FUNCTIONSOLVER(__expr_pntchange)
    {
    int err;
    EXPRTYPE s1old, s2old, s1new, s2new, pnt;
    EXPRTYPE odiff, ndiff, perc;

    EXPR_REQUIRECOUNT(5);

    EXPR_EVALNODE(0, s1old);
    EXPR_EVALNODE(1, s2old);
    EXPR_EVALNODE(2, s1new);
    EXPR_EVALNODE(3, s2new);
    EXPR_EVALNODE(4, pnt);

    /* Side orders don't matter as long as side 1 and 2 are the same
       sides in the old and new positions.  IE.  -1..1 to 0..479 for x
       and -1..1 to 479..0 for y */

    odiff = s2old - s1old;
    ndiff = s2new - s1new;

    if(odiff == 0.0)
        return EXPR_ERROR_OUTOFRANGE;

    perc = (pnt - s1old) / odiff;

    *val = s1new + (perc * ndiff);

    return EXPR_ERROR_NOERROR;
    }

/* Poly */
EXPR_FUNCTIONSOLVER(__expr_poly)
    {
    int err, pos;
    EXPRTYPE dx;
    EXPRTYPE d1;
    EXPRTYPE total, curpow;

    EXPR_REQUIRECOUNTMIN(2);

    EXPR_EVALNODE(0, dx); /* The x value */

    EXPR_CLEARMATHERR();


    /* current power */
    curpow = (EXPRTYPE)count - 2.0;
    total = 0.0;

    for(pos = 1; pos < count; pos++)
        {
        EXPR_EVALNODE(pos, d1);

        total = total + (d1 * pow(dx, curpow));
        curpow = curpow - 1.0;

        EXPR_CHECKMATHERR();
        }

    *val = total;

    return EXPR_ERROR_NOERROR;
    }

/* Logic functions */

/* And */
EXPR_FUNCTIONSOLVER(__expr_and)
    {
    int err;
    EXPRTYPE d1, d2;

    EXPR_REQUIRECOUNT(2);

    EXPR_EVALNODE(0, d1);
    EXPR_EVALNODE(1, d2);

    /* neither may be 0.0 or it is false */
    if(d1 == 0.0 || d2 == 0.0)
        *val = 0.0;
    else
        *val = 1.0;

    return EXPR_ERROR_NOERROR;
    }

/* Or */
EXPR_FUNCTIONSOLVER(__expr_or)
    {
    int err;
    EXPRTYPE d1, d2;

    EXPR_REQUIRECOUNT(2);

    EXPR_EVALNODE(0, d1);
    EXPR_EVALNODE(1, d2);

    /* if any are true, the result is true */
    if(d1 != 0.0 || d2 != 0.0)
        *val = 1.0;
    else
        *val = 0.0;

    return EXPR_ERROR_NOERROR;
    }


/* Not */
EXPR_FUNCTIONSOLVER(__expr_not)
    {
    int err;
    EXPRTYPE d1;

    EXPR_REQUIRECOUNT(1);

    EXPR_EVALNODE(0, d1);

    if(d1 != 0.0) /* Just reverse it */
        *val = 0.0;
    else
        *val = 1.0;

    return EXPR_ERROR_NOERROR;
    }

/* Other functions */

/* A 'for' like function */
EXPR_FUNCTIONSOLVER(__expr_for)
    {
    int err;
    int pos;
    EXPRTYPE test;
    EXPRTYPE tmp;
    EXPRTYPE res;

    /* Need at least 4 arguments */
    EXPR_REQUIRECOUNTMIN(4);

    /* Evaluate initialization */
    EXPR_EVALNODE(0, tmp);

    /* Evaluate test */
    EXPR_EVALNODE(1, test);

    while(test != 0.0)
        {
        /* Evaluate action nodes (3+) */
        for(pos = 3; pos < count; pos++)
            {
            EXPR_EVALNODE(pos, res);
            }

        /* Evaluate incrementation */
        EXPR_EVALNODE(2, tmp);

        /* Evaluate test */
        EXPR_EVALNODE(1, test);

        /*
            We could be an infinite loop if test is never false, so
            check for the break;
        */
        EXPR_CHECKBREAK();

        }

    /* Return result */
    *val = res;

    return EXPR_ERROR_NOERROR;
    }

/* Treat 'many' subexpressions as a single item (function) */
EXPR_FUNCTIONSOLVER(__expr_many)
    {
    int err;
    int pos;
    EXPRTYPE tmp;

    EXPR_REQUIRECOUNTMIN(1);

    for(pos = 0; pos < count; pos++)
        {
        EXPR_EVALNODE(pos, tmp);
        }

    *val = tmp;

    return EXPR_ERROR_NOERROR;
    }