Return to arith.c CVS log

Up to [Research Unix] / researchv10no / libj

Annotation of researchv10no/libj/arith.c, revision 1.1.1.1

1.1       root        1: #include "jerq.h"
                      2: /* These routines are NOT portable, but they are fast. */
                      3: 
                      4: Point
                      5: add(a, b)
                      6:        Point a, b;
                      7: {
                      8:        register short *ap= &a.x, *bp= &b.x;
                      9:        *ap++ += *bp++;
                     10:        *ap += *bp;
                     11:        return a;
                     12: }
                     13: 
                     14: Point
                     15: sub(a, b)
                     16:        Point a, b;
                     17: {
                     18:        register short *ap= &a.x, *bp= &b.x;
                     19:        *ap++ -= *bp++;
                     20:        *ap -= *bp;
                     21:        return a;
                     22: }
                     23: 
                     24: Rectangle
                     25: inset(r,n)
                     26:        Rectangle r;
                     27:        register n;
                     28: {
                     29:        register short *rp= &r.origin.x;
                     30:        *rp++ += n;
                     31:        *rp++ += n;
                     32:        *rp++ -= n;
                     33:        *rp   -= n;
                     34:        return r;
                     35: }
                     36: 
                     37: Point
                     38: div(a, b)
                     39:        Point a;
                     40:        register b;
                     41: {
                     42:        register short *ap= &a.x;
                     43:        *(ap++)/=b;
                     44:        *ap/=b;
                     45:        return a;
                     46: }
                     47: 
                     48: Point
                     49: mul(a, b)
                     50:        Point a;
                     51:        register b;
                     52: {
                     53:        register short *ap= &a.x;       
                     54:        *(ap++)*=b;
                     55:        *ap*=b;
                     56:        return a;
                     57: }
                     58: 
                     59: Rectangle
                     60: rsubp(r, p)
                     61:        Rectangle r;
                     62:        Point p;
                     63: {
                     64:        register short *rp= &r.origin.x, *pp= &p.x;
                     65:        *rp++ -= *pp++;
                     66:        *rp++ -= *pp--;
                     67:        *rp++ -= *pp++;
                     68:        *rp   -= *pp;
                     69:        return r;
                     70: }
                     71: 
                     72: Rectangle
                     73: raddp(r, p)
                     74:        Rectangle r;
                     75:        Point p;
                     76: {
                     77:        register short *rp= &r.origin.x, *pp= &p.x;
                     78:        *rp++ += *pp++;
                     79:        *rp++ += *pp--;
                     80:        *rp++ += *pp++;
                     81:        *rp   += *pp;
                     82:        return r;
                     83: }
                     84: 
                     85: eqpt(p, q)
                     86:        Point p, q;
                     87: {
                     88:        register long *pp=(long *)&p, *qq=(long *)&q;
                     89:        return *pp==*qq;
                     90: }
                     91: eqrect(r, s)
                     92:        Rectangle r, s;
                     93: {
                     94:        register long *rr=(long *)&r, *ss=(long *)&s;
                     95:        return *rr++==*ss++ && *rr==*ss;
                     96: }

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