Return to cos.c CVS log

Up to [Research Unix] / researchv9 / jtools / src / sunlib

Annotation of researchv9/jtools/src/sunlib/cos.c, revision 1.1.1.1

1.1       root        1: static
                      2: short costab[91]={
                      3:        1024,   1024,   1023,   1023,   1022,
                      4:        1020,   1018,   1016,   1014,   1011,
                      5:        1008,   1005,   1002,   998,    994,
                      6:        989,    984,    979,    974,    968,
                      7:        962,    956,    949,    943,    935,
                      8:        928,    920,    912,    904,    896,
                      9:        887,    878,    868,    859,    849,
                     10:        839,    828,    818,    807,    796,
                     11:        784,    773,    761,    749,    737,
                     12:        724,    711,    698,    685,    672,
                     13:        658,    644,    630,    616,    602,
                     14:        587,    573,    558,    543,    527,
                     15:        512,    496,    481,    465,    449,
                     16:        433,    416,    400,    384,    367,
                     17:        350,    333,    316,    299,    282,
                     18:        265,    248,    230,    213,    195,
                     19:        178,    160,    143,    125,    107,
                     20:        89,     71,     54,     36,     18,
                     21:        0,
                     22: };
                     23: cos (x)
                     24: register x;
                     25: {
                     26:        x %= 360;
                     27:        if(x<0)
                     28:                x+=360;
                     29:        if(x<=180)
                     30:                return(x<90? costab[x] : -costab[180-x]);
                     31:        return(x<180+90? -costab[x-180] : costab[360-x]);
                     32: }
                     33: 
                     34: sin (x)
                     35: register x;
                     36: {
                     37:        return(cos(x-90));
                     38: }
                     39: 
                     40: static
                     41: qatan2 (x, y)
                     42: register x, y;
                     43: {
                     44:        if(x<y)
                     45:                return(90-(45*((long)x)/y));
                     46:        if(y==0)
                     47:                return(0);
                     48:        return(45*((long)y)/x);
                     49: }
                     50: 
                     51: atan2 (xx, yy){
                     52:        register x, y;
                     53:        x = abs(xx);
                     54:        y = abs(yy);
                     55:        if(xx>=0 && yy>=0)
                     56:                return(qatan2(x, y));
                     57:        if(xx<0 && yy<=0)
                     58:                return(180+qatan2(x, y));
                     59:        if(xx<0 && yy>0)
                     60:                return(180-qatan2(x, y));
                     61:        return(360-qatan2(x, y));
                     62: }
                     63: 
                     64: norm (x,y,z)
                     65: {
                     66:        return (sqrt(x*x + y*y + z*z));
                     67: }
                     68: 
                     69: sqrtryz (x,y,z)
                     70: {
                     71:        register long sumsq;
                     72: 
                     73:        sumsq = x*x - y*y - z*z;
                     74:        if(sumsq <= 0)
                     75:                return 0;
                     76:        return(sqrt(sumsq));
                     77: }
                     78: 
                     79: #define MAXROOT 0xb504
                     80: sqrt (x)
                     81: register long x;
                     82: {
                     83:        register long high = MAXROOT;
                     84:        register long low = 0;
                     85:        register long current = MAXROOT/2;
                     86:        if(x <= 0)
                     87:                return 0;
                     88:        if(x >= MAXROOT*MAXROOT)
                     89:                return(MAXROOT);
                     90:        while(high>low+1){
                     91:                if(current*current==x)
                     92:                        return (current);
                     93:                if(current*current>x)
                     94:                        high=current;
                     95:                else
                     96:                        low=current;
                     97:                current=(high+low)>>1;
                     98:        }
                     99:        return(current);
                    100: }

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