Return to math.C CVS log

Up to [parser3project] / parser3 / src / classes

Annotation of parser3/src/classes/math.C, revision 1.4

1.1       parser      1: /** @file
                      2:        Parser: @b math parser class.
                      3: 
                      4:        Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
                      5: 
                      6:        Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
                      7: */
1.4     ! parser      8: static const char *RCSId="$Id: math.C,v 1.3 2001/07/07 16:38:01 parser Exp $"; 
1.1       parser      9: 
                     10: #include "pa_config_includes.h"
                     11: #include "pa_common.h"
                     12: #include "pa_vint.h"
1.2       parser     13: #include "pa_vmath.h"
1.1       parser     14: #include "pa_request.h"
                     15: 
                     16: // defines
                     17: 
1.3       parser     18: #define PI 3.1415926535
1.1       parser     19: #define MATH_CLASS_NAME "math"
                     20: 
                     21: // class
                     22: 
                     23: class MMath : public Methoded {
                     24: public:
                     25:        MMath(Pool& pool);
                     26: public: // Methoded
                     27:        bool used_directly() { return true; }
                     28: };
                     29: 
                     30: // methods
                     31: 
                     32: static void _random(Request& r, const String& method_name, MethodParams *params) {
                     33:        Pool& pool=r.pool();
                     34: 
1.3       parser     35:        Value& range=params->as_junction(0, "range must be expression");
1.1       parser     36:     uint max=(uint)r.process(range).as_double();
                     37:     if(max<=1)
                     38:                PTHROW(0, 0,
                     39:                        &method_name,
                     40:                        "bad range [0..%u]", max);
                     41:        
1.4     ! parser     42:        Value& result=*new(pool) VInt(pool, rand()%max);
        !            43:        result.set_name(method_name);
        !            44:        r.write_no_lang(result);
1.1       parser     45: }
                     46: 
                     47: 
                     48: typedef double (*math1_func_ptr)(double);
                     49: static double round(double param) { return floor(param+0.5); }
                     50: static double sign(double param) { return param > 0 ? 1 : ( param < 0 ? -1 : 0 ); }
1.3       parser     51: static double trunc(double param) { return param > 0? floor(param) : ceil(param); }
                     52: static double frac(double param) { return param-trunc(param); }
                     53: static double degrees(double param) { return param /PI *180; }
                     54: static double radians(double param) { return param /180 *PI; }
1.1       parser     55: 
                     56: static void math1(Request& r, 
                     57:                                  const String& method_name, MethodParams *params,
                     58:                                  math1_func_ptr func) {
                     59:        Pool& pool=r.pool();
1.3       parser     60:        Value& param=params->as_junction(0, "parameter must be expression");
1.1       parser     61: 
                     62:        Value& result=*new(pool) VDouble(pool, (*func)(r.process(param).as_double()));
                     63:        result.set_name(method_name);
                     64:        r.write_no_lang(result);
                     65: }
                     66: 
                     67: #define MATH1(name) \
                     68:        static void _##name(Request& r, const String& method_name, MethodParams *params) {\
                     69:                math1(r, method_name, params, &name);\
                     70:        }
                     71: #define MATH1P(name_parser, name_c) \
                     72:        static void _##name_parser(Request& r, const String& method_name, MethodParams *params) {\
                     73:                math1(r, method_name, params, &name_c);\
                     74:        }
                     75: MATH1(round);  MATH1(floor);   MATH1P(ceiling, ceil);
1.3       parser     76: MATH1(trunc);  MATH1(frac);
1.1       parser     77: MATH1P(abs, fabs);     MATH1(sign);
                     78: MATH1(exp);    MATH1(log);     
                     79: MATH1(sin);    MATH1(asin);    
                     80: MATH1(cos);    MATH1(acos);    
                     81: MATH1(tan);    MATH1(atan);
1.3       parser     82: MATH1(degrees);        MATH1(radians);
1.1       parser     83: MATH1(sqrt);
                     84: 
                     85: 
                     86: typedef double (*math2_func_ptr)(double, double);
                     87: static void math2(Request& r, 
                     88:                                  const String& method_name, MethodParams *params,
                     89:                                  math2_func_ptr func) {
                     90:        Pool& pool=r.pool();
1.3       parser     91:        Value& a=params->as_junction(0, "parameter must be expression");
                     92:        Value& b=params->as_junction(1, "parameter must be expression");
1.1       parser     93: 
                     94:        Value& result=*new(pool) VDouble(pool, (*func)(
                     95:                r.process(a).as_double(),
                     96:                r.process(b).as_double()));
                     97:        result.set_name(method_name);
                     98:        r.write_no_lang(result);
                     99: }
                    100: 
                    101: #define MATH2(name) \
                    102:        static void _##name(Request& r, const String& method_name, MethodParams *params) {\
                    103:                math2(r, method_name, params, &name);\
                    104:        }
                    105: MATH2(pow);
                    106: 
                    107: // constructor
                    108: 
                    109: MMath::MMath(Pool& apool) : Methoded(apool) {
                    110:        set_name(*NEW String(pool(), MATH_CLASS_NAME));
                    111: 
                    112: 
                    113:        // setting seed
                    114:        srand(getpid()+time(NULL));  rand();
                    115:        
                    116:        // ^FUNC(expr)  
                    117: #define ADD1(name) \
                    118:        add_native_method(#name, Method::CT_STATIC, _##name, 1, 1)
                    119: 
                    120:        ADD1(round);    ADD1(floor);    ADD1(ceiling);
1.3       parser    121:        ADD1(trunc);    ADD1(frac);
1.1       parser    122:        ADD1(abs);      ADD1(sign);
                    123:        ADD1(exp);      ADD1(log);      
                    124:        ADD1(sin);      ADD1(asin);     
                    125:        ADD1(cos);      ADD1(acos);     
                    126:        ADD1(tan);      ADD1(atan);
1.3       parser    127:        ADD1(degrees);  ADD1(radians);
1.1       parser    128:        ADD1(sqrt);
1.3       parser    129:        ADD1(random);
1.1       parser    130: 
                    131: #define ADD2(name) \
                    132:        add_native_method(#name, Method::CT_STATIC, _##name, 2, 2)
                    133: 
                    134:        // ^pow(x;y)
                    135:        ADD2(pow);
                    136: 
                    137: }
                    138: 
1.2       parser    139: // global variables
                    140: 
                    141: Methoded *math_base_class;
                    142: Hash *math_consts;
                    143: 
1.1       parser    144: // creator
                    145: 
                    146: Methoded *MMath_create(Pool& pool) {
1.2       parser    147:        math_consts=new(pool) Hash(pool);
                    148:        math_consts->put(
                    149:                *new(pool) String(pool, "PI"), 
1.3       parser    150:                new(pool) VDouble(pool, PI));
1.2       parser    151: 
                    152:        return math_base_class=new(pool) MMath(pool);
1.1       parser    153: }