Return to rhflib1.c CVS log

Up to [Research Unix] / researchv10no / cmd / PDP11 / fpp

Annotation of researchv10no/cmd/PDP11/fpp/rhflib1.c, revision 1.1.1.1

1.1       root        1: /* floating point utility operations for software-float */
                      2: 
                      3: extern float _fsign; /* 0100000L for norgen, 020000000000L for unix */
                      4: extern long _fsign2; /* same constant, different type */
                      5: extern float _one; /* the constant 1.0 */
                      6: long _funmin(f)
                      7: long f;
                      8: {
                      9: if(f)return(f^_fsign2); else return(0L);
                     10: }
                     11: 
                     12: float _funplus(f)
                     13: float f;
                     14: {
                     15: return(f);
                     16: }
                     17: 
                     18: float _finc1(pf)
                     19: float *pf;
                     20: {
                     21: return(*pf= *pf+_one);
                     22: }
                     23: 
                     24: float _fdec1(pf)
                     25: float *pf;
                     26: {
                     27: return(*pf= *pf-_one);
                     28: }
                     29: 
                     30: float _finc2(pf)
                     31: float *pf;
                     32: {
                     33: float temp;
                     34: temp= *pf;
                     35: *pf= *pf+_one;
                     36: return(temp);
                     37: }
                     38: 
                     39: float _fdec2(pf)
                     40: float *pf;
                     41: {
                     42: float temp;
                     43: temp= *pf;
                     44: *pf = *pf-_one;
                     45: return(temp);
                     46: }
                     47: 
                     48: float _fmod(b,a)
                     49: float b,a;
                     50: {
                     51: return(a-((long)(a/b))*b);
                     52: }
                     53: 
                     54: float _feqpl(b,pa)
                     55: float b,*pa;
                     56: {
                     57: return(*pa= *pa+b);
                     58: }
                     59: 
                     60: float _feqmi(b,pa)
                     61: float b,*pa;
                     62: {
                     63: return(*pa= *pa-b);
                     64: }
                     65: 
                     66: float _feqmu(b,pa)
                     67: float b,*pa;
                     68: {
                     69: return(*pa= *pa*b);
                     70: }
                     71: 
                     72: float _feqdv(b,pa)
                     73: float b,*pa;
                     74: {
                     75: return(*pa= *pa/b);
                     76: }
                     77: 
                     78: float _feqan(b,pa)
                     79: float b,*pa;
                     80: {
                     81: return(*pa= *pa&b);
                     82: }
                     83: 
                     84: float _feqer(b,pa)
                     85: float b,*pa;
                     86: {
                     87: return(*pa= *pa^b);
                     88: }
                     89: 
                     90: float _feqmo(b,pa)
                     91: float b,*pa;
                     92: {
                     93: return(*pa= *pa%b);
                     94: }
                     95: 
                     96: float _feqor(b,pa)
                     97: float b,*pa;
                     98: {
                     99: return(*pa= *pa|b);
                    100: }
                    101: 
                    102: float _feqsr(b,pa)
                    103: float b,*pa;
                    104: {
                    105: return(*pa= *pa>>b);
                    106: }
                    107: 
                    108: float _feqsl(b,pa)
                    109: float b,*pa;
                    110: {
                    111: return(*pa= *pa<<b);
                    112: }
                    113: 
                    114: int _fgt(b,a)
                    115: float b,a;
                    116: {
                    117: float temp;
                    118: if(temp=a-b)return((temp&_fsign)==0.0);
                    119: return(0);
                    120: }
                    121: 
                    122: int _fge(b,a)
                    123: float b,a;
                    124: {
                    125: return(((a-b)&_fsign)==0.0);
                    126: }
                    127: 
                    128: int _fle(b,a)
                    129: float b,a;
                    130: {
                    131: float temp;
                    132: if(temp=a-b)return((temp&_fsign)==_fsign);
                    133: return(1);
                    134: }
                    135: int _flt(b,a)
                    136: float b,a;
                    137: {
                    138: return(((a-b)&_fsign)==_fsign);
                    139: }

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