Return to arith.c CVS log

Up to [Research Unix] / researchv9 / jerq / src / lib / j

Annotation of researchv9/jerq/src/lib/j/arith.c, revision 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.