BRL-CAD: Matrix/Vector/Quaternion Math

sqrt( \
        ((a)[X]-(b)[X])*((a)[X]-(b)[X]) + \
        ((a)[Y]-(b)[Y])*((a)[Y]-(b)[Y]) + \
        ((a)[Z]-(b)[Z])*((a)[Z]-(b)[Z]) )

{ \
                        (m)[MDX] = (x); \
                        (m)[MDY] = (y); \
                        (m)[MDZ] = (z); }

{ \
                        (_v)[X] = (_m)[MDX]; \
                        (_v)[Y] = (_m)[MDY]; \
                        (_v)[Z] = (_m)[MDZ]; }

{ \
                        (_v)[X] = -(_m)[MDX]; \
                        (_v)[Y] = -(_m)[MDY]; \
                        (_v)[Z] = -(_m)[MDZ]; }

{ \
        (_m)[MSX] = _x; \
        (_m)[MSY] = _y; \
        (_m)[MSZ] = _z; }

{\
        (_m)[MSX] = (_v)[X]; \
        (_m)[MSY] = (_v)[Y]; \
        (_m)[MSZ] = (_v)[Z]; }

{ \
        (m)[0] = (m)[1] = (m)[2] = (m)[3] = \
        (m)[4] = (m)[5] = (m)[6] = (m)[7] = \
        (m)[8] = (m)[9] = (m)[10] = (m)[11] = \
        (m)[12] = (m)[13] = (m)[14] = (m)[15] = 0.0;}

{\
        (m)[1] = (m)[2] = (m)[3] = (m)[4] =\
        (m)[6] = (m)[7] = (m)[8] = (m)[9] = \
        (m)[11] = (m)[12] = (m)[13] = (m)[14] = 0.0;\
        (m)[0] = (m)[5] = (m)[10] = (m)[15] = 1.0;}

{ \
        (d)[0] = (s)[0];\
        (d)[1] = (s)[1];\
        (d)[2] = (s)[2];\
        (d)[3] = (s)[3];\
        (d)[4] = (s)[4];\
        (d)[5] = (s)[5];\
        (d)[6] = (s)[6];\
        (d)[7] = (s)[7];\
        (d)[8] = (s)[8];\
        (d)[9] = (s)[9];\
        (d)[10] = (s)[10];\
        (d)[11] = (s)[11];\
        (d)[12] = (s)[12];\
        (d)[13] = (s)[13];\
        (d)[14] = (s)[14];\
        (d)[15] = (s)[15]; }

{ \
                        (a)[X] = (b);\
                        (a)[Y] = (c);\
                        (a)[Z] = (d); }

{\
        register int _j;\
        for (_j=0; _j<n; _j++) v[_j]=(s);}

{ \
                        (a)[X] = (b)[X];\
                        (a)[Y] = (b)[Y];\
                        (a)[Z] = (b)[Z]; }

{ register int _vmove; \
        for(_vmove = 0; _vmove < (n); _vmove++) \
                (a)[_vmove] = (b)[_vmove]; \
        }

{ \
                        (a)[X] = (b)[X];\
                        (a)[Y] = (b)[Y];\
                        (a)[Z] = (b)[Z];\
                        (a)[W] = (b)[W]; }

{ \
                        (a)[X] = (b)[X];\
                        (a)[Y] = (b)[Y]; }

{ \
                        (a)[X] = -(b)[X]; \
                        (a)[Y] = -(b)[Y]; \
                        (a)[Z] = -(b)[Z]; }

{ \
                        (a)[X] = -(b)[X]; \
                        (a)[Y] = -(b)[Y]; \
                        (a)[Z] = -(b)[Z]; \
                        (a)[W] = -(b)[W]; }

{ \
                        (a)[X] = (b)[X] + (c)[X];\
                        (a)[Y] = (b)[Y] + (c)[Y];\
                        (a)[Z] = (b)[Z] + (c)[Z]; }

{ register int _vadd2; \
        for(_vadd2 = 0; _vadd2 < (n); _vadd2++) \
                (a)[_vadd2] = (b)[_vadd2] + (c)[_vadd2]; \
        }

{ \
                        (a)[X] = (b)[X] + (c)[X];\
                        (a)[Y] = (b)[Y] + (c)[Y];}

{ \
                        (a)[X] = (b)[X] - (c)[X];\
                        (a)[Y] = (b)[Y] - (c)[Y];\
                        (a)[Z] = (b)[Z] - (c)[Z]; }

{ register int _vsub2; \
        for(_vsub2 = 0; _vsub2 < (n); _vsub2++) \
                (a)[_vsub2] = (b)[_vsub2] - (c)[_vsub2]; \
        }

{ \
                        (a)[X] = (b)[X] - (c)[X];\
                        (a)[Y] = (b)[Y] - (c)[Y];}

{ \
                        (a)[X] = (b)[X] - (c)[X] - (d)[X];\
                        (a)[Y] = (b)[Y] - (c)[Y] - (d)[Y];\
                        (a)[Z] = (b)[Z] - (c)[Z] - (d)[Z]; }

{ register int _vsub3; \
        for(_vsub3 = 0; _vsub3 < (n); _vsub3++) \
                (a)[_vsub3] = (b)[_vsub3] - (c)[_vsub3] - (d)[_vsub3]; \
        }

{ \
                        (a)[X] = (b)[X] + (c)[X] + (d)[X];\
                        (a)[Y] = (b)[Y] + (c)[Y] + (d)[Y];\
                        (a)[Z] = (b)[Z] + (c)[Z] + (d)[Z]; }

{ register int _vadd3; \
        for(_vadd3 = 0; _vadd3 < (n); _vadd3++) \
                (a)[_vadd3] = (b)[_vadd3] + (c)[_vadd3] + (d)[_vadd3]; \
        }

{ \
                        (a)[X] = (b)[X] + (c)[X] + (d)[X] + (e)[X];\
                        (a)[Y] = (b)[Y] + (c)[Y] + (d)[Y] + (e)[Y];\
                        (a)[Z] = (b)[Z] + (c)[Z] + (d)[Z] + (e)[Z]; }

{ register int _vadd4; \
        for(_vadd4 = 0; _vadd4 < (n); _vadd4++) \
                (a)[_vadd4] = (b)[_vadd4] + (c)[_vadd4] + (d)[_vadd4] + (e)[_vadd4];\
        }

{ \
                        (a)[X] = (b)[X] * (c);\
                        (a)[Y] = (b)[Y] * (c);\
                        (a)[Z] = (b)[Z] * (c); }

{ \
                        (a)[X] = (b)[X] * (c);\
                        (a)[Y] = (b)[Y] * (c);\
                        (a)[Z] = (b)[Z] * (c);\
                        (a)[W] = (b)[W] * (c); }

{ register int _vscale; \
        for(_vscale = 0; _vscale < (n); _vscale++) \
                (a)[_vscale] = (b)[_vscale] * (c); \
        }

{ \
                        (a)[X] = (b)[X] * (c);\
                        (a)[Y] = (b)[Y] * (c); }

{ \
        register double _f = MAGSQ(a); \
        if ( ! NEAR_ZERO( _f-1.0, VUNITIZE_TOL ) ) { \
                _f = sqrt( _f ); \
                if( _f < VDIVIDE_TOL ) { VSETALL( (a), 0.0 ); } else { \
                        _f = 1.0/_f; \
                        (a)[X] *= _f; (a)[Y] *= _f; (a)[Z] *= _f; \
                } \
        } \
}

{ \
                        register double _f; _f = MAGNITUDE(a); \
                        if( _f < VDIVIDE_TOL ) return(ret); \
                        _f = 1.0/_f; \
                        (a)[X] *= _f; (a)[Y] *= _f; (a)[Z] *= _f; }

{ \
                                        (o)[X] = ((a)[X] + (b)[X]) * (s); \
                                        (o)[Y] = ((a)[Y] + (b)[Y]) * (s); \
                                        (o)[Z] = ((a)[Z] + (b)[Z]) * (s); }

{ register int _vadd2scale; \
        for( _vadd2scale = 0; _vadd2scale < (n); _vadd2scale++ ) \
                (o)[_vadd2scale] = ((a)[_vadd2scale] + (b)[_vadd2scale]) * (s); \
        }

{ \
                                        (o)[X] = ((a)[X] - (b)[X]) * (s); \
                                        (o)[Y] = ((a)[Y] - (b)[Y]) * (s); \
                                        (o)[Z] = ((a)[Z] - (b)[Z]) * (s); }

{ register int _vsub2scale; \
        for( _vsub2scale = 0; _vsub2scale < (n); _vsub2scale++ ) \
                (o)[_vsub2scale] = ((a)[_vsub2scale] - (b)[_vsub2scale]) * (s); \
        }

{\
        (o)[X] = (a) * (b)[X] + (c) * (d)[X] + (e) * (f)[X];\
        (o)[Y] = (a) * (b)[Y] + (c) * (d)[Y] + (e) * (f)[Y];\
        (o)[Z] = (a) * (b)[Z] + (c) * (d)[Z] + (e) * (f)[Z];}

{\
        { register int _vcomb3; \
        for(_vcomb3 = 0; _vcomb3 < (n); _vcomb3++) \
                (o)[_vcomb3] = (a) * (b)[_vcomb3] + (c) * (d)[_vcomb3] + (e) * (f)[_vcomb3]; \
        } }

{\
        (o)[X] = (a) * (b)[X] + (c) * (d)[X];\
        (o)[Y] = (a) * (b)[Y] + (c) * (d)[Y];\
        (o)[Z] = (a) * (b)[Z] + (c) * (d)[Z];}

{\
        { register int _vcomb2; \
        for(_vcomb2 = 0; _vcomb2 < (n); _vcomb2++) \
                (o)[_vcomb2] = (a) * (b)[_vcomb2] + (c) * (d)[_vcomb2]; \
        } }

{ \
        (a)[X] = (b)[X] + (c)*(d)[X] + (e)*(f)[X] + (g)*(h)[X] + (i)*(j)[X];\
        (a)[Y] = (b)[Y] + (c)*(d)[Y] + (e)*(f)[Y] + (g)*(h)[Y] + (i)*(j)[Y];\
        (a)[Z] = (b)[Z] + (c)*(d)[Z] + (e)*(f)[Z] + (g)*(h)[Z] + (i)*(j)[Z]; }

{ \
        (a)[X] = (b)[X] + (c)*(d)[X] + (e)*(f)[X] + (g)*(h)[X];\
        (a)[Y] = (b)[Y] + (c)*(d)[Y] + (e)*(f)[Y] + (g)*(h)[Y];\
        (a)[Z] = (b)[Z] + (c)*(d)[Z] + (e)*(f)[Z] + (g)*(h)[Z]; }

{ \
        (a)[X] = (b)[X] + (c) * (d)[X] + (e) * (f)[X];\
        (a)[Y] = (b)[Y] + (c) * (d)[Y] + (e) * (f)[Y];\
        (a)[Z] = (b)[Z] + (c) * (d)[Z] + (e) * (f)[Z]; }

{ register int _vjoin2; \
        for(_vjoin2 = 0; _vjoin2 < (n); _vjoin2++) \
                (a)[_vjoin2] = (b)[_vjoin2] + (c) * (d)[_vjoin2] + (e) * (f)[_vjoin2]; \
        }

{ \
        (a)[X] = (b)[X] + (c) * (d)[X];\
        (a)[Y] = (b)[Y] + (c) * (d)[Y];\
        (a)[Z] = (b)[Z] + (c) * (d)[Z]; }

{ register int _vjoin1; \
        for(_vjoin1 = 0; _vjoin1 < (n); _vjoin1++) \
                (a)[_vjoin1] = (b)[_vjoin1] + (c) * (d)[_vjoin1]; \
        }

{ \
                        (a)[X] = (b)[X] + (c) * (d)[X]; \
                        (a)[Y] = (b)[Y] + (c) * (d)[Y]; \
                        (a)[Z] = (b)[Z] + (c) * (d)[Z]; \
                        (a)[W] = (b)[W] + (c) * (d)[W]; }

{ \
                        (a)[X] = (b)[X] + (c) * (d)[X];\
                        (a)[Y] = (b)[Y] + (c) * (d)[Y]; }

{ \
        (a)[X] = (b) * (c)[X] + (d) * (e)[X];\
        (a)[Y] = (b) * (c)[Y] + (d) * (e)[Y];\
        (a)[Z] = (b) * (c)[Z] + (d) * (e)[Z]; }

{ register int _vblend2; \
        for(_vblend2 = 0; _vblend2 < (n); _vblend2++) \
                (a)[_vblend2] = (b) * (c)[_vblend2] + (d) * (e)[_vblend2]; \
        }

{ \
                        (a)[X] = (b)[Y] * (c)[Z] - (b)[Z] * (c)[Y];\
                        (a)[Y] = (b)[Z] * (c)[X] - (b)[X] * (c)[Z];\
                        (a)[Z] = (b)[X] * (c)[Y] - (b)[Y] * (c)[X]; }

( \
        ((_pt2)[X] - (_pt)[X]) * (_vec)[X] + \
        ((_pt2)[Y] - (_pt)[Y]) * (_vec)[Y] + \
        ((_pt2)[Z] - (_pt)[Z]) * (_vec)[Z] )

{ \
        (a)[X] = (b)[X] * (c)[X];\
        (a)[Y] = (b)[Y] * (c)[Y];\
        (a)[Z] = (b)[Z] * (c)[Z]; }

{ \
        (a)[X] = (b)[X] * (c)[X] * (d)[X];\
        (a)[Y] = (b)[Y] * (c)[Y] * (d)[Y];\
        (a)[Z] = (b)[Z] * (c)[Z] * (d)[Z]; }

{ \
        (a)[0] = (b)[0] / (c)[0];\
        (a)[1] = (b)[1] / (c)[1];\
        (a)[2] = (b)[2] / (c)[2]; }

{ \
        if( (_dir)[X] < -SQRT_SMALL_FASTF || (_dir)[X] > SQRT_SMALL_FASTF )  { \
                (_inv)[X]=1.0/(_dir)[X]; \
        } else { \
                (_dir)[X] = 0.0; \
                (_inv)[X] = INFINITY; \
        } \
        if( (_dir)[Y] < -SQRT_SMALL_FASTF || (_dir)[Y] > SQRT_SMALL_FASTF )  { \
                (_inv)[Y]=1.0/(_dir)[Y]; \
        } else { \
                (_dir)[Y] = 0.0; \
                (_inv)[Y] = INFINITY; \
        } \
        if( (_dir)[Z] < -SQRT_SMALL_FASTF || (_dir)[Z] > SQRT_SMALL_FASTF )  { \
                (_inv)[Z]=1.0/(_dir)[Z]; \
        } else { \
                (_dir)[Z] = 0.0; \
                (_inv)[Z] = INFINITY; \
        } \
    }

{ \
        (o)[X] = (mat)[X]*(vec)[X]+(mat)[Y]*(vec)[Y] + (mat)[ 2]*(vec)[Z]; \
        (o)[Y] = (mat)[4]*(vec)[X]+(mat)[5]*(vec)[Y] + (mat)[ 6]*(vec)[Z]; \
        (o)[Z] = (mat)[8]*(vec)[X]+(mat)[9]*(vec)[Y] + (mat)[10]*(vec)[Z]; }

{ \
        (o)[X] = (i)[X]*(m)[X] + (i)[Y]*(m)[4] + (i)[Z]*(m)[8]; \
        (o)[Y] = (i)[X]*(m)[1] + (i)[Y]*(m)[5] + (i)[Z]*(m)[9]; \
        (o)[Z] = (i)[X]*(m)[2] + (i)[Y]*(m)[6] + (i)[Z]*(m)[10]; }

{ \
        (o)[X] = (mat)[0]*(vec)[X] + (mat)[Y]*(vec)[Y]; \
        (o)[Y] = (mat)[4]*(vec)[X] + (mat)[5]*(vec)[Y]; \
        (o)[Z] = (mat)[8]*(vec)[X] + (mat)[9]*(vec)[Y]; }

{ \
        (o)[X] = (i)[X]*(m)[0] + (i)[Y]*(m)[4]; \
        (o)[Y] = (i)[X]*(m)[1] + (i)[Y]*(m)[5]; \
        (o)[Z] = (i)[X]*(m)[2] + (i)[Y]*(m)[6]; }

{ register double _f; \
        _f = 1.0/((m)[12]*(i)[X] + (m)[13]*(i)[Y] + (m)[14]*(i)[Z] + (m)[15]);\
        (o)[X]=((m)[0]*(i)[X] + (m)[1]*(i)[Y] + (m)[ 2]*(i)[Z] + (m)[3]) * _f;\
        (o)[Y]=((m)[4]*(i)[X] + (m)[5]*(i)[Y] + (m)[ 6]*(i)[Z] + (m)[7]) * _f;\
        (o)[Z]=((m)[8]*(i)[X] + (m)[9]*(i)[Y] + (m)[10]*(i)[Z] + (m)[11])* _f;}

{ register double _f; \
        _f = 1.0/((i)[X]*(m)[3] + (i)[Y]*(m)[7] + (i)[Z]*(m)[11] + (m)[15]);\
        (o)[X]=((i)[X]*(m)[0] + (i)[Y]*(m)[4] + (i)[Z]*(m)[8] + (m)[12]) * _f;\
        (o)[Y]=((i)[X]*(m)[1] + (i)[Y]*(m)[5] + (i)[Z]*(m)[9] + (m)[13]) * _f;\
        (o)[Z]=((i)[X]*(m)[2] + (i)[Y]*(m)[6] + (i)[Z]*(m)[10] + (m)[14])* _f;}

{ \
        (o)[X]=(m)[ 0]*(i)[X] + (m)[ 1]*(i)[Y] + (m)[ 2]*(i)[Z] + (m)[ 3]*(i)[H];\
        (o)[Y]=(m)[ 4]*(i)[X] + (m)[ 5]*(i)[Y] + (m)[ 6]*(i)[Z] + (m)[ 7]*(i)[H];\
        (o)[Z]=(m)[ 8]*(i)[X] + (m)[ 9]*(i)[Y] + (m)[10]*(i)[Z] + (m)[11]*(i)[H];\
        (o)[H]=(m)[12]*(i)[X] + (m)[13]*(i)[Y] + (m)[14]*(i)[Z] + (m)[15]*(i)[H]; }

{ register double _f;   _f = 1.0/((m)[15]);\
        (o)[X] = ((m)[0]*(i)[X] + (m)[1]*(i)[Y] + (m)[ 2]*(i)[Z]) * _f; \
        (o)[Y] = ((m)[4]*(i)[X] + (m)[5]*(i)[Y] + (m)[ 6]*(i)[Z]) * _f; \
        (o)[Z] = ((m)[8]*(i)[X] + (m)[9]*(i)[Y] + (m)[10]*(i)[Z]) * _f; }

{ register double _f;   _f = 1.0/((m)[15]); \
        (o)[X] = ((i)[X]*(m)[0] + (i)[Y]*(m)[4] + (i)[Z]*(m)[8]) * _f; \
        (o)[Y] = ((i)[X]*(m)[1] + (i)[Y]*(m)[5] + (i)[Z]*(m)[9]) * _f; \
        (o)[Z] = ((i)[X]*(m)[2] + (i)[Y]*(m)[6] + (i)[Z]*(m)[10]) * _f; }

{ register double _f;   _f = 1.0/((m)[15]); \
        (o)[X] = ((i)[X]*(m)[0] + (i)[Y]*(m)[4]) * _f; \
        (o)[Y] = ((i)[X]*(m)[1] + (i)[Y]*(m)[5]) * _f; \
        (o)[Z] = ((i)[X]*(m)[2] + (i)[Y]*(m)[6]) * _f; }

( \
        NEAR_ZERO( (a)[X]-(b)[X], tol ) && \
        NEAR_ZERO( (a)[Y]-(b)[Y], tol ) && \
        NEAR_ZERO( (a)[Z]-(b)[Z], tol ) )

( \
        NEAR_ZERO(v[X],tol) && NEAR_ZERO(v[Y],tol) && NEAR_ZERO(v[Z],tol)  )

{ \
        (a)[X] = (b)[X] / (b)[H];\
        (a)[Y] = (b)[Y] / (b)[H];\
        (a)[Z] = (b)[Z] / (b)[H]; }

{ \
        register fastf_t _rot = (r) * 0.5; \
        QSET(q, x, y, z, cos(_rot)); \
        VUNITIZE(q); \
        _rot = sin(_rot); /* _rot is really just a temp variable now */ \
        VSCALE(q, q, _rot ); }

{ \
        register fastf_t _rot = (r) * 0.5; \
        VMOVE(q, v); \
        VUNITIZE(q); \
        (q)[W] = cos(_rot); \
        _rot = sin(_rot); /* _rot is really just a temp variable now */ \
        VSCALE(q, q, _rot ); }

{ \
                        (a)[X] = (b);\
                        (a)[Y] = (c);\
                        (a)[Z] = (d);\
                        (a)[W] = (e); }

{ \
                        (a)[X] = (b)[X];\
                        (a)[Y] = (b)[Y];\
                        (a)[Z] = (b)[Z];\
                        (a)[W] = (b)[W]; }

{ \
                        (a)[X] = (b)[X] + (c)[X];\
                        (a)[Y] = (b)[Y] + (c)[Y];\
                        (a)[Z] = (b)[Z] + (c)[Z];\
                        (a)[W] = (b)[W] + (c)[W]; }

{ \
                        (a)[X] = (b)[X] - (c)[X];\
                        (a)[Y] = (b)[Y] - (c)[Y];\
                        (a)[Z] = (b)[Z] - (c)[Z];\
                        (a)[W] = (b)[W] - (c)[W]; }

{ \
                        (a)[X] = (b)[X] * (c);\
                        (a)[Y] = (b)[Y] * (c);\
                        (a)[Z] = (b)[Z] * (c);\
                        (a)[W] = (b)[W] * (c); }

{register double _f; _f = QMAGNITUDE(a); \
                        if( _f < VDIVIDE_TOL ) _f = 0.0; else _f = 1.0/_f; \
                        (a)[X] *= _f; (a)[Y] *= _f; (a)[Z] *= _f; (a)[W] *= _f; }

( (a)[X]*(a)[X] + (a)[Y]*(a)[Y] \
                        + (a)[Z]*(a)[Z] + (a)[W]*(a)[W] )

( (a)[X]*(b)[X] + (a)[Y]*(b)[Y] \
                        + (a)[Z]*(b)[Z] + (a)[W]*(b)[W] )

{ \
    (a)[W] = (b)[W]*(c)[W] - (b)[X]*(c)[X] - (b)[Y]*(c)[Y] - (b)[Z]*(c)[Z]; \
    (a)[X] = (b)[W]*(c)[X] + (b)[X]*(c)[W] + (b)[Y]*(c)[Z] - (b)[Z]*(c)[Y]; \
    (a)[Y] = (b)[W]*(c)[Y] + (b)[Y]*(c)[W] + (b)[Z]*(c)[X] - (b)[X]*(c)[Z]; \
    (a)[Z] = (b)[W]*(c)[Z] + (b)[Z]*(c)[W] + (b)[X]*(c)[Y] - (b)[Y]*(c)[X]; }

{ \
        (a)[X] = -(b)[X]; \
        (a)[Y] = -(b)[Y]; \
        (a)[Z] = -(b)[Z]; \
        (a)[W] =  (b)[W]; }

{ register double _f = QMAGSQ(b); \
        if( _f < VDIVIDE_TOL ) _f = 0.0; else _f = 1.0/_f; \
        (a)[X] = -(b)[X] * _f; \
        (a)[Y] = -(b)[Y] * _f; \
        (a)[Z] = -(b)[Z] * _f; \
        (a)[W] =  (b)[W] * _f; }

{ \
        (a)[X] = (b) * (c)[X] + (d) * (e)[X];\
        (a)[Y] = (b) * (c)[Y] + (d) * (e)[Y];\
        (a)[Z] = (b) * (c)[Z] + (d) * (e)[Z];\
        (a)[W] = (b) * (c)[W] + (d) * (e)[W]; }

( (_l1)[X] > (_h2)[X] || (_l1)[Y] > (_h2)[Y] || (_l1)[Z] > (_h2)[Z] || \
        (_l2)[X] > (_h1)[X] || (_l2)[Y] > (_h1)[Y] || (_l2)[Z] > (_h1)[Z] )

(! ((_l1)[X] > (_h2)[X] || (_l1)[Y] > (_h2)[Y] || (_l1)[Z] > (_h2)[Z] || \
        (_l2)[X] > (_h1)[X] || (_l2)[Y] > (_h1)[Y] || (_l2)[Z] > (_h1)[Z]) )

(! ((_l1)[X] > (_h2)[X] + (_t)->dist || \
        (_l1)[Y] > (_h2)[Y] + (_t)->dist || \
        (_l1)[Z] > (_h2)[Z] + (_t)->dist || \
        (_l2)[X] > (_h1)[X] + (_t)->dist || \
        (_l2)[Y] > (_h1)[Y] + (_t)->dist || \
        (_l2)[Z] > (_h1)[Z] + (_t)->dist ) )

( \
        (_pt)[X] >= (_lo)[X] && (_pt)[X] <= (_hi)[X] && \
        (_pt)[Y] >= (_lo)[Y] && (_pt)[Y] <= (_hi)[Y] && \
        (_pt)[Z] >= (_lo)[Z] && (_pt)[Z] <= (_hi)[Z]  )

( \
        (_pt)[X] >= (_lo)[X]-(_t)->dist && (_pt)[X] <= (_hi)[X]+(_t)->dist && \
        (_pt)[Y] >= (_lo)[Y]-(_t)->dist && (_pt)[Y] <= (_hi)[Y]+(_t)->dist && \
        (_pt)[Z] >= (_lo)[Z]-(_t)->dist && (_pt)[Z] <= (_hi)[Z]+(_t)->dist  )

( \
        (_lo1)[X] >= (_lo2)[X] && (_hi1)[X] <= (_hi2)[X] && \
        (_lo1)[Y] >= (_lo2)[Y] && (_hi1)[Y] <= (_hi2)[Y] && \
        (_lo1)[Z] >= (_lo2)[Z] && (_hi1)[Z] <= (_hi2)[Z] )

Matrix/Vector/Quaternion Math
[libbn (numerical functions)]

Files

Defines

Typedefs

Functions

Define Documentation

Typedef Documentation

Function Documentation


Files
file	vmath.h
	vector/matrix math
file	mat.c
	4 x 4 Matrix manipulation functions...
file	qmath.c
	Quaternion math routines.
Defines
#define	VMATH_H seen
#define	M_E 2.7182818284590452354
#define	M_LOG2E 1.4426950408889634074
#define	M_LOG10E 0.43429448190325182765
#define	M_LN2 0.69314718055994530942
#define	M_LN10 2.30258509299404568402
#define	M_PI 3.14159265358979323846
#define	M_PI_2 1.57079632679489661923
#define	M_PI_4 0.78539816339744830962
#define	M_1_PI 0.31830988618379067154
#define	M_2_PI 0.63661977236758134308
#define	M_2_SQRTPI 1.12837916709551257390
#define	M_SQRT2 1.41421356237309504880
#define	M_SQRT1_2 0.70710678118654752440
#define	M_SQRT2_DIV2 0.70710678118654752440
#define	PI M_PI
#define	VDIVIDE_TOL ( 1.0e-20 )
#define	VUNITIZE_TOL ( 1.0e-15 )
#define	ELEMENTS_PER_VECT 3
	# of fastf_t's per vect_t
#define	ELEMENTS_PER_PT 3
#define	HVECT_LEN 4
	# of fastf_t's per hvect_t
#define	HPT_LEN 4
#define	ELEMENTS_PER_PLANE 4
	# of fastf_t's per plane_t
#define	ELEMENTS_PER_MAT (4*4)
#define	quat_t hvect_t
	4-element quaternion
#define	NEAR_ZERO(val, epsilon) ( ((val) > -epsilon) && ((val) < epsilon) )
#define	CLAMP(_v, _l, _h) if ((_v) < (_l)) _v = _l; else if ((_v) > (_h)) _v = _h
#define	DIST_PT_PLANE(_pt, _pl) (VDOT(_pt, _pl) - (_pl)[H])
	Compute distance from a point to a plane.
#define	DIST_PT_PT(a, b)
	Compute distance between two points.
#define	X 0
#define	Y 1
#define	Z 2
#define	H 3
#define	W H
#define	MDX 3
#define	MDY 7
#define	MDZ 11
#define	MAT_DELTAS(m, x, y, z)
	set translation values of 4x4 matrix with x, y, z values
#define	MAT_DELTAS_VEC(_m, _v) MAT_DELTAS(_m, (_v)[X], (_v)[Y], (_v)[Z] )
	set translation values of 4x4 matrix from a vector
#define	MAT_DELTAS_VEC_NEG(_m, _v) MAT_DELTAS(_m,-(_v)[X],-(_v)[Y],-(_v)[Z] )
	set translation values of 4x4 matrix from a reversed vector
#define	MAT_DELTAS_GET(_v, _m)
	get translation values of 4x4 matrix to a vector
#define	MAT_DELTAS_GET_NEG(_v, _m)
	get translation values of 4x4 matrix to a vector, reversed
#define	MSX 0
#define	MSY 5
#define	MSZ 10
#define	MSA 15
#define	MAT_SCALE(_m, _x, _y, _z)
	set scale of 4x4 matrix from xyz
#define	MAT_SCALE_VEC(_m, _v)
	set scale of 4x4 matrix from vector
#define	MAT_SCALE_ALL(_m, _s) (_m)[MSA] = (_s)
	set uniform scale of 4x4 matrix from scalar
#define	MAT_ZERO(m)
	zero a matrix
#define	MAT_IDN(m)
	set matrix to identity
#define	MAT_COPY(d, s)
	copy a matrix
#define	VSET(a, b, c, d)
	Set vector at `a' to have coordinates `b', `c', `d'.
#define	VSETALL(a, s) { (a)[X] = (a)[Y] = (a)[Z] = (s); }
	Set all elements of vector to same scalar value.
#define	VSETALLN(v, s, n)
	Set all elements of N-vector to same scalar value.
#define	VMOVE(a, b)
	Transfer vector at `b' to vector at `a'.
#define	VMOVEN(a, b, n)
	Transfer vector of length `n' at `b' to vector at `a'.
#define	HMOVE(a, b)
	Move a homogeneous 4-tuple.
#define	V2MOVE(a, b)
	move a 2D vector. This naming convention seems better than the VMOVE_2D version below
#define	VREVERSE(a, b)
	Reverse the direction of vector b and store it in a.
#define	HREVERSE(a, b)
	Same as VREVERSE, but for a 4-tuple. Also useful on plane_t objects.
#define	VADD2(a, b, c)
	Add vectors at `b' and `c', store result at `a'.
#define	VADD2N(a, b, c, n)
	Add vectors of length `n' at `b' and `c', store result at `a'.
#define	V2ADD2(a, b, c)
#define	VSUB2(a, b, c)
	Subtract vector at `c' from vector at `b', store result at `a'.
#define	VSUB2N(a, b, c, n)
	Subtract `n' length vector at `c' from vector at `b', store result at `a'.
#define	V2SUB2(a, b, c)
#define	VSUB3(a, b, c, d)
	Vectors: A = B - C - D.
#define	VSUB3N(a, b, c, d, n)
	Vectors: A = B - C - D for vectors of length `n'.
#define	VADD3(a, b, c, d)
	Add 3 vectors at `b', `c', and `d', store result at `a'.
#define	VADD3N(a, b, c, d, n)
	Add 3 vectors of length `n' at `b', `c', and `d', store result at `a'.
#define	VADD4(a, b, c, d, e)
	Add 4 vectors at `b', `c', `d', and `e', store result at `a'.
#define	VADD4N(a, b, c, d, e, n)
	Add 4 `n' length vectors at `b', `c', `d', and `e', store result at `a'.
#define	VSCALE(a, b, c)
	Scale vector at `b' by scalar `c', store result at `a'.
#define	HSCALE(a, b, c)
#define	VSCALEN(a, b, c, n)
	Scale vector of length `n' at `b' by scalar `c', store result at `a'.
#define	V2SCALE(a, b, c)
#define	VUNITIZE(a)
	Normalize vector `a' to be a unit vector.
#define	VUNITIZE_RET(a, ret)
	If vector magnitude is too small, return an error code.
#define	VADD2SCALE(o, a, b, s)
	Find the sum of two points, and scale the result. Often used to find the midpoint.
#define	VADD2SCALEN(o, a, b, n)
#define	VSUB2SCALE(o, a, b, s)
	Find the difference between two points, and scale result. Often used to compute bounding sphere radius given rpp points.
#define	VSUB2SCALEN(o, a, b, n)
#define	VCOMB3(o, a, b, c, d, e, f)
	Combine together several vectors, scaled by a scalar.
#define	VCOMB3N(o, a, b, c, d, e, f, n)
#define	VCOMB2(o, a, b, c, d)
#define	VCOMB2N(o, a, b, c, d, n)
#define	VJOIN4(a, b, c, d, e, f, g, h, i, j)
#define	VJOIN3(a, b, c, d, e, f, g, h)
#define	VJOIN2(a, b, c, d, e, f)
	Compose vector at `a' of: Vector at `b' plus scalar `c' times vector at `d' plus scalar `e' times vector at `f'.
#define	VJOIN2N(a, b, c, d, e, f, n)
#define	VJOIN1(a, b, c, d)
#define	VJOIN1N(a, b, c, d, n)
#define	HJOIN1(a, b, c, d)
#define	V2JOIN1(a, b, c, d)
#define	VBLEND2(a, b, c, d, e)
	Blend into vector `a' scalar `b' times vector at `c' plus scalar `d' times vector at `e'.
#define	VBLEND2N(a, b, c, d, e, n)
#define	MAGSQ(a) ( (a)[X](a)[X] + (a)[Y](a)[Y] + (a)[Z]*(a)[Z] )
	Return scalar magnitude squared of vector at `a'.
#define	MAG2SQ(a) ( (a)[X](a)[X] + (a)[Y](a)[Y] )
#define	MAGNITUDE(a) sqrt( MAGSQ( a ) )
	Return scalar magnitude of vector at `a'.
#define	VCROSS(a, b, c)
	Store cross product of vectors at `b' and `c' in vector at `a'. Note that the "right hand rule" applies: If closing your right hand goes from `b' to `c', then your thumb points in the direction of the cross product.
#define	VDOT(a, b) ( (a)[X](b)[X] + (a)[Y](b)[Y] + (a)[Z]*(b)[Z] )
	Compute dot product of vectors at `a' and `b'.
#define	V2DOT(a, b) ( (a)[X](b)[X] + (a)[Y](b)[Y] )
#define	VSUB2DOT(_pt2, _pt, _vec)
	Subtract two points to make a vector, dot with another vector.
#define	V2ARGS(a) (a)[X], (a)[Y]
	Turn a vector into comma-separated list of elements, for subroutine args.
#define	V3ARGS(a) (a)[X], (a)[Y], (a)[Z]
#define	V4ARGS(a) (a)[X], (a)[Y], (a)[Z], (a)[W]
#define	V2INTCLAMPARGS(a) INTCLAMP((a)[X]), INTCLAMP((a)[Y])
	integer clamped versions of the previous arg macros
#define	V3INTCLAMPARGS(a) INTCLAMP((a)[X]), INTCLAMP((a)[Y]), INTCLAMP((a)[Z])
	integer clamped versions of the previous arg macros
#define	V4INTCLAMPARGS(a) INTCLAMP((a)[X]), INTCLAMP((a)[Y]), INTCLAMP((a)[Z]), INTCLAMP((a)[W])
	integer clamped versions of the previous arg macros
#define	V2PRINT(a, b) (void)fprintf(stderr,"%s (%g, %g)\n", a, V2ARGS(b) );
	Print vector name and components on stderr.
#define	VPRINT(a, b) (void)fprintf(stderr,"%s (%g, %g, %g)\n", a, V3ARGS(b) );
#define	HPRINT(a, b) (void)fprintf(stderr,"%s (%g, %g, %g, %g)\n", a, V4ARGS(b) );
#define	V2INTCLAMPPRINT(a, b) (void)fprintf(stderr,"%s (%g, %g)\n", a, V2INTCLAMPARGS(b) );
	integer clamped versions of the previous print macros
#define	VINTCLAMPPRINT(a, b) (void)fprintf(stderr,"%s (%g, %g, %g)\n", a, V3INTCLAMPARGS(b) );
#define	HINTCLAMPPRINT(a, b) (void)fprintf(stderr,"%s (%g, %g, %g, %g)\n", a, V4INTCLAMPARGS(b) );
#define	INTCLAMP(_a) ( NEAR_ZERO((_a) - rint(_a), VUNITIZE_TOL) ? rint(_a) : (_a) )
#define	VELMUL(a, b, c)
	Vector element multiplication. Really: diagonal matrix X vect.
#define	VELMUL3(a, b, c, d)
#define	VELDIV(a, b, c)
	Similar to VELMUL.
#define	VINVDIR(_inv, _dir)
	Given a direction vector, compute the inverses of each element. When division by zero would have occured, mark inverse as INFINITY.
#define	MAT3X3VEC(o, mat, vec)
	Apply the 3x3 part of a mat_t to a 3-tuple. This rotates a vector without scaling it (changing its length).
#define	VEC3X3MAT(o, i, m)
	Multiply a 3-tuple by the 3x3 part of a mat_t.
#define	MAT3X2VEC(o, mat, vec)
	Apply the 3x3 part of a mat_t to a 2-tuple (Z part=0).
#define	VEC2X3MAT(o, i, m)
	Multiply a 2-tuple (Z=0) by the 3x3 part of a mat_t.
#define	MAT4X3PNT(o, m, i)
	Apply a 4x4 matrix to a 3-tuple which is an absolute Point in space.
#define	PNT3X4MAT(o, i, m)
	Multiply an Absolute 3-Point by a full 4x4 matrix.
#define	MAT4X4PNT(o, m, i)
	Multiply an Absolute hvect_t 4-Point by a full 4x4 matrix.
#define	MAT4X3VEC(o, m, i)
	Apply a 4x4 matrix to a 3-tuple which is a relative Vector in space This macro can scale the length of the vector if [15] != 1.0.
#define	MAT4XSCALOR(o, m, i) {(o) = (i) / (m)[15];}
#define	VEC3X4MAT(o, i, m)
	Multiply a Relative 3-Vector by most of a 4x4 matrix.
#define	VEC2X4MAT(o, i, m)
	Multiply a Relative 2-Vector by most of a 4x4 matrix.
#define	BN_VEC_NON_UNIT_LEN(_vec) (fabs(MAGSQ(_vec)) < 0.0001 \|\| fabs(fabs(MAGSQ(_vec))-1) > 0.0001)
	Test a vector for non-unit length.
#define	VEQUAL(a, b) ((a)[X]==(b)[X] && (a)[Y]==(b)[Y] && (a)[Z]==(b)[Z])
	Compare two vectors for EXACT equality. Use carefully.
#define	VAPPROXEQUAL(a, b, tol)
	Compare two vectors for approximate equality, within the specified absolute tolerance.
#define	VNEAR_ZERO(v, tol)
	Test for all elements of `v' being smaller than `tol'.
#define	V_MIN(r, s) if( (s) < (r) ) r = (s)
	Macros to update min and max X,Y,Z values to contain a point.
#define	V_MAX(r, s) if( (s) > (r) ) r = (s)
#define	VMIN(r, s) { V_MIN((r)[X],(s)[X]); V_MIN((r)[Y],(s)[Y]); V_MIN((r)[Z],(s)[Z]); }
#define	VMAX(r, s) { V_MAX((r)[X],(s)[X]); V_MAX((r)[Y],(s)[Y]); V_MAX((r)[Z],(s)[Z]); }
#define	VMINMAX(min, max, pt) { VMIN( (min), (pt) ); VMAX( (max), (pt) ); }
#define	HDIVIDE(a, b)
	Divide out homogeneous parameter from hvect_t, creating vect_t.
#define	VADD2_2D(a, b, c) V2ADD2(a,b,c)
	Some 2-D versions of the 3-D macros given above.
#define	VSUB2_2D(a, b, c) V2SUB2(a,b,c)
#define	MAGSQ_2D(a) MAG2SQ(a)
#define	VDOT_2D(a, b) V2DOT(a,b)
#define	VMOVE_2D(a, b) V2MOVE(a,b)
#define	VSCALE_2D(a, b, c) V2SCALE(a,b,c)
#define	VJOIN1_2D(a, b, c, d) V2JOIN1(a,b,c,d)
#define	QUAT_FROM_ROT(q, r, x, y, z)
	Quaternion math definitions.Create Quaternion from Vector and Rotation about vector.
#define	QUAT_FROM_VROT(q, r, v)
#define	QUAT_FROM_VROT_DEG(q, r, v) QUAT_FROM_VROT(q, ((r)*(M_PI/180.0)), v)
#define	QUAT_FROM_ROT_DEG(q, r, x, y, z) QUAT_FROM_ROT(q, ((r)*(M_PI/180.0)), x, y, z)
#define	QSET(a, b, c, d, e)
	Set quaternion at `a' to have coordinates `b', `c', `d', `e'.
#define	QMOVE(a, b)
	Transfer quaternion at `b' to quaternion at `a'.
#define	QADD2(a, b, c)
	Add quaternions at `b' and `c', store result at `a'.
#define	QSUB2(a, b, c)
	Subtract quaternion at `c' from quaternion at `b', store result at `a'.
#define	QSCALE(a, b, c)
	Scale quaternion at `b' by scalar `c', store result at `a'.
#define	QUNITIZE(a)
	Normalize quaternion 'a' to be a unit quaternion.
#define	QMAGSQ(a)
	Return scalar magnitude squared of quaternion at `a'.
#define	QMAGNITUDE(a) sqrt( QMAGSQ( a ) )
	Return scalar magnitude of quaternion at `a'.
#define	QDOT(a, b)
	Compute dot product of quaternions at `a' and `b'.
#define	QMUL(a, b, c)
	Compute quaternion product a = b * c a[W] = b[W]*c[W] - VDOT(b,c); VCROSS( temp, b, c ); VJOIN2( a, temp, b[W], c, c[W], b );.
#define	QCONJUGATE(a, b)
	Conjugate quaternion.
#define	QINVERSE(a, b)
	Multiplicative inverse quaternion.
#define	QBLEND2(a, b, c, d, e)
	Blend into quaternion `a' scalar `b' times quaternion at `c' plus scalar `d' times quaternion at `e'.
#define	V3RPP_DISJOINT(_l1, _h1, _l2, _h2)
	Macros for dealing with 3-D "extents" represented as axis-aligned right parallelpipeds (RPPs). This is stored as two points: a min point, and a max point. RPP 1 is defined by lo1, hi1, RPP 2 by lo2, hi2. Compare two extents represented as RPPs. If they are disjoint, return true.
#define	V3RPP_OVERLAP(_l1, _h1, _l2, _h2)
	Compare two extents represented as RPPs. If they overlap, return true.
#define	V3RPP_OVERLAP_TOL(_l1, _h1, _l2, _h2, _t)
	If two extents overlap within distance tolerance, return true.
#define	V3PT_IN_RPP(_pt, _lo, _hi)
	Is the point within or on the boundary of the RPP?
#define	V3PT_IN_RPP_TOL(_pt, _lo, _hi, _t)
	Within the distance tolerance, is the point within the RPP?
#define	V3RPP1_IN_RPP2(_lo1, _hi1, _lo2, _hi2)
	Determine if one bounding box is within another. Also returns true if the boxes are the same.
#define	PI 3.14159265358979323264
#define	RTODEG (180.0/PI)
Typedefs
typedef fastf_t	mat_t [ELEMENTS_PER_MAT]
	4x4 matrix
typedef fastf_t *	matp_t
typedef fastf_t	vect_t [ELEMENTS_PER_VECT]
	3-tuple vector
typedef fastf_t *	vectp_t
typedef fastf_t	point_t [ELEMENTS_PER_PT]
	3-tuple point
typedef fastf_t *	pointp_t
typedef fastf_t	point2d_t [2]
typedef fastf_t	hvect_t [HVECT_LEN]
	4-tuple vector
typedef fastf_t	hpoint_t [HPT_LEN]
	4-tuple point
typedef fastf_t	plane_t [ELEMENTS_PER_PLANE]
	Definition of a plane equation.
Functions
void	quat_mat2quat (hvect_t quat, const mat_t mat)
void	quat_quat2mat (mat_t mat, const hvect_t quat)
double	quat_distance (const hvect_t q1, const hvect_t q2)
void	quat_double (hvect_t qout, const hvect_t q1, const hvect_t q2)
void	quat_bisect (hvect_t qout, const hvect_t q1, const hvect_t q2)
void	quat_slerp (hvect_t qout, const hvect_t q1, const hvect_t q2, double f)
void	quat_sberp (hvect_t qout, const hvect_t q1, const hvect_t qa, const hvect_t qb, const hvect_t q2, double f)
void	quat_make_nearest (hvect_t q1, const hvect_t q2)
void	quat_print (const char *title, const hvect_t quat)
void	quat_exp (hvect_t out, const hvect_t in)
void	quat_log (hvect_t out, const hvect_t in)
void	quat_mat2quat (register fastf_t quat, register const fastf_t mat)
	Convert Matrix to Quaternion.
void	quat_quat2mat (register fastf_t mat, register const fastf_t quat)
	Convert Quaternion to Matrix.
double	quat_distance (const fastf_t q1, const fastf_t q2)
	Gives the euclidean distance between two quaternions.
void	quat_double (fastf_t qout, const fastf_t q1, const fastf_t *q2)
	Gives the quaternion point representing twice the rotation from q1 to q2. Needed for patching Bezier curves together. A rather poor name admittedly.
void	quat_bisect (fastf_t qout, const fastf_t q1, const fastf_t *q2)
	Gives the bisector of quaternions q1 and q2. (Could be done with quat_slerp and factor 0.5) [I believe they must be unit quaternions this to work].
void	quat_slerp (fastf_t qout, const fastf_t q1, const fastf_t *q2, double f)
	Do Spherical Linear Interpolation between two unit quaternions by the given factor.
void	quat_sberp (fastf_t qout, const fastf_t q1, const fastf_t qa, const fastf_t qb, const fastf_t *q2, double f)
	Spherical Bezier Interpolate between four quaternions by amount f. These are intended to be used as start and stop quaternions along with two control quaternions chosen to match spline segments with first order continuity.
void	quat_make_nearest (fastf_t q1, const fastf_t q2)
	Set the quaternion q1 to the quaternion which yields the smallest rotation from q2 (of the two versions of q1 which produce the same orientation).
void	quat_print (const char title, const fastf_t quat)
void	quat_exp (fastf_t out, const fastf_t in)
	Exponentiate a quaternion, assuming that the scalar part is 0. Code by Ken Shoemake.
void	quat_log (fastf_t out, const fastf_t in)
	Take the natural logarithm of a unit quaternion. Code by Ken Shoemake.

Matrix/Vector/Quaternion Math [libbn (numerical functions)]

Files

Defines

Typedefs

Functions

Define Documentation

Typedef Documentation

Function Documentation

Matrix/Vector/Quaternion Math
[libbn (numerical functions)]