Return to trig.c CVS log

Up to [Research Unix] / researchv10dc / cmd / icon / pi / pil

Annotation of researchv10dc/cmd/icon/pi/pil/trig.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  *     TRIG
                      3:  *
                      4:  *     Trigonometric functions
                      5:  *
                      6:  *     Ralph E. Griswold and Stephen B. Wampler
                      7:  *
                      8:  *     Last modified 5/2/86 by Ralph E. Griswold
                      9:  *
                     10:  */
                     11: 
                     12: #include "../h/rt.h"
                     13: #include <errno.h>
                     14: 
                     15: int errno;
                     16: 
                     17: /*
                     18:  * sin(x), x in radians
                     19:  */
                     20: FncDcl(sin,1)
                     21:    {
                     22:    int t;
                     23:    union numeric r;
                     24:    double sin();
                     25:    
                     26:    if ((t = cvreal(&Arg1, &r)) == NULL) runerr(102, &Arg1);
                     27:    mkreal(sin(r.real),&Arg0);
                     28:    Return;
                     29:    }
                     30: 
                     31: /*
                     32:  * cos(x), x in radians
                     33:  */
                     34: FncDcl(cos,1)
                     35:    {
                     36:    int t;
                     37:    union numeric r;
                     38:    double cos();
                     39:    
                     40:    if ((t = cvreal(&Arg1, &r)) == NULL) runerr(102, &Arg1);
                     41:    mkreal(cos(r.real),&Arg0);
                     42:    Return;
                     43:    }
                     44: 
                     45: /*
                     46:  * tan(x), x in radians
                     47:  */
                     48: FncDcl(tan,1)
                     49:    {
                     50:    int t;
                     51:    double y;
                     52:    union numeric r;
                     53:    double tan();
                     54:    
                     55:    if ((t = cvreal(&Arg1, &r)) == NULL) runerr(102, &Arg1);
                     56:    y = tan(r.real);
                     57:    if (errno == ERANGE) runerr(252, NULL);
                     58:    mkreal(y,&Arg0);
                     59:    Return;
                     60:    }
                     61: 
                     62: /*
                     63:  * acos(x), x in radians
                     64:  */
                     65: FncDcl(acos,1)
                     66:    {
                     67:    int t;
                     68:    double y;
                     69:    union numeric r;
                     70:    double acos();
                     71:    
                     72:    if ((t = cvreal(&Arg1, &r)) == NULL) runerr(102, &Arg1);
                     73:    y = acos(r.real);
                     74:    if (errno == EDOM) runerr(251, NULL);
                     75:    mkreal(y,&Arg0);
                     76:    Return;
                     77:    }
                     78: 
                     79: /*
                     80:  * asin(x), x in radians
                     81:  */
                     82: FncDcl(asin,1)
                     83:    {
                     84:    int t;
                     85:    double y;
                     86:    union numeric r;
                     87:    double asin();
                     88:    
                     89:    if ((t = cvreal(&Arg1, &r)) == NULL) runerr(102, &Arg1);
                     90:    y = asin(r.real);
                     91:    if (errno == EDOM) runerr(251, NULL);
                     92:    mkreal(y,&Arg0);
                     93:    Return;
                     94:    }
                     95: 
                     96: /*
                     97:  * atan(x), x in radians
                     98:  */
                     99: FncDcl(atan,1)
                    100:    {
                    101:    int t;
                    102:    union numeric r;
                    103:    double atan();
                    104:    
                    105:    if ((t = cvreal(&Arg1, &r)) == NULL) runerr(102, &Arg1);
                    106:    mkreal(atan(r.real),&Arg0);
                    107:    Return;
                    108:    }
                    109: 
                    110: /*
                    111:  * atan2(x,y), x, y in radians
                    112:  */
                    113: FncDcl(atan2,2)
                    114:    {
                    115:    int t;
                    116:    union numeric r1, r2;
                    117:    double atan2();
                    118: 
                    119:    if ((t = cvreal(&Arg2, &r2)) == NULL) runerr(102, &Arg2);
                    120:    if ((t = cvreal(&Arg1, &r1)) == NULL) runerr(102, &Arg1);
                    121:    mkreal(atan2(r1.real,r2.real),&Arg0);
                    122:    Return;
                    123:    }
                    124: 
                    125: #define PI 3.14159
                    126: 
                    127: /*
                    128:  * dtor(x), x in degrees
                    129:  */
                    130: FncDcl(dtor,1)
                    131:    {
                    132:    union numeric r;
                    133: 
                    134:    if (cvreal(&Arg1, &r) == NULL) runerr(102, &Arg1);
                    135:    mkreal(r.real * PI / 180, &Arg0);
                    136:    Return;
                    137:    }
                    138: 
                    139: /*
                    140:  * rtod(x), x in radians
                    141:  */
                    142: FncDcl(rtod,1)
                    143:    {
                    144:    union numeric r;
                    145: 
                    146:    if (cvreal(&Arg1, &r) == NULL) runerr(102, &Arg1);
                    147:    mkreal(r.real * 180 / PI, &Arg0);
                    148:    Return;
                    149:    }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.