/******************************************************************
             24-786   GEOMETRIC MODELING   SPRING 98
                  Carnegie Mellon University   
          MACRO DEFINITIONS FOR VECTORS AND ROTATIONS
*******************************************************************/

#define X               (0)
#define Y               (1)
#define Z               (2)

#define Abs(s)                ((s)>0? (s): -(s))
#define Max(a,b)              ((a)>(b)? (a):(b))
#define Min(a,b)              ((a)<(b)? (a):(b))
#define Max3(a,b,c)           (((a)>(b))&&((a)>(c))? (a):((b)>(c)? (b):(c)))
#define Min3(a,b,c)           (((a)<(b))&&((a)<(c()? (a):((b)<(c)? (b):(c)))

#define VecLis(v)             (v)[X], (v)[Y], (v)[Z]
#define VecLis2(v)            (v)[X], (v)[Y]
#define RotLis(t)             \
(t)[0][0],(t)[0][1],(t)[0][2], \
(t)[1][0],(t)[1][1],(t)[1][2], \
(t)[2][0],(t)[2][1],(t)[2][2]

#define VecVecDot(v1,v2)         (((v1)[X]*(v2)[X])+((v1)[Y]*(v2)[Y])+((v1)[Z]*(v2)[Z]))
#define VecVecDot2(v1,v2)        (((v1)[X]*(v2)[X])+((v1)[Y]*(v2)[Y]))

#define VecNrm(v)             sqrt(VecVecDot((v),(v)))
#define VecNrm2(v)            sqrt(VecVecDot2((v),(v)))

#define	VecVecDstSqr(v1,v2)	\
(((v1)[X]-(v2)[X])*((v1)[X]-(v2)[X])+	\
 ((v1)[Y]-(v2)[Y])*((v1)[Y]-(v2)[Y])+	\
 ((v1)[Z]-(v2)[Z])*((v1)[Z]-(v2)[Z]))

#define VecVecDst(v1,v2)      sqrt(VecVecDstSqr(v1,v2))

#define	VecVecDstSqr2(v1,v2)	\
(((v1)[X]-(v2)[X])*((v1)[X]-(v2)[X])+	\
 ((v1)[Y]-(v2)[Y])*((v1)[Y]-(v2)[Y]))

#define VecVecDst2(v1,v2)     sqrt(VecVecDstSqr2(v1,v2))

#define VecVecVecCrs(v1,v2,v3)	\
((v1)[X] = (v2)[Y]*(v3)[Z]-(v2)[Z]*(v3)[Y],	\
 (v1)[Y] = (v2)[Z]*(v3)[X]-(v2)[X]*(v3)[Z],	\
 (v1)[Z] = (v2)[X]*(v3)[Y]-(v2)[Y]*(v3)[X]	\
)

#define VecOpScl(v,op,s)      \
((v)[X] op (s), \
 (v)[Y] op (s), \
 (v)[Z] op (s)  \
)
#define VecOpScl2(v,op,s)     \
((v)[X] op (s), \
 (v)[Y] op (s)  \
)

#define VecOpLis(v,op,a,b,c)  \
((v)[X] op (a), \
 (v)[Y] op (b), \
 (v)[Z] op (c)  \
)
#define VecOpLis2(v,op,a,b)   \
((v)[X] op (a), \
 (v)[Y] op (b)  \
)

#define VecOpVec(v1,op,v2)    \
((v1)[X] op (v2)[X], \
 (v1)[Y] op (v2)[Y], \
 (v1)[Z] op (v2)[Z]  \
)
#define VecOpVec2(v1,op,v2)   \
((v1)[X] op (v2)[X], \
 (v1)[Y] op (v2)[Y]  \
)

#define VecOpVecOpVec(v1,op1,v2,op2,v3)         \
(v1[X] op1 v2[X] op2 v3[X], \
 v1[Y] op1 v2[Y] op2 v3[Y], \
 v1[Z] op1 v2[Z] op2 v3[Z]  \
)
#define VecOpVecOpVec2(v1,op1,v2,op2,v3)        \
((v1)[X] op1 (v2)[X] op2 (v3)[X], \
 (v1)[Y] op1 (v2)[Y] op2 (v3)[Y]  \
)

#define IniRot(r)             \
((r)[0][0] = 1.0, (r)[0][1] = 0.0, (r)[0][2] = 0.0,  \
 (r)[1][0] = 0.0, (r)[1][1] = 1.0, (r)[1][2] = 0.0,  \
 (r)[2][0] = 0.0, (r)[2][1] = 0.0, (r)[2][2] = 1.0   \
)
#define IniRot2(r)             \
((r)[0][0] = 1.0, (r)[0][1] = 0.0,  \
 (r)[1][0] = 0.0, (r)[1][1] = 1.0   \
)

#define InvRot(r1,r2)         \
((r1)[0][0] = (r2)[0][0], (r1)[0][1] = (r2)[1][0], (r1)[0][2] = (r2)[2][0], \
 (r1)[1][0] = (r2)[0][1], (r1)[1][1] = (r2)[1][1], (r1)[1][2] = (r2)[2][1], \
 (r1)[2][0] = (r2)[0][2], (r1)[2][1] = (r2)[1][2], (r1)[2][2] = (r2)[2][2]  \
)
#define InvRot2(r1,r2)         \
((r1)[0][0] = (r2)[0][0], (r1)[0][1] = (r2)[1][0], \
 (r1)[1][0] = (r2)[0][1], (r1)[1][1] = (r2)[1][1]  \
)

#define VecOpRotVec(v1,op,r,v2)             \
((v1)[X] op (r)[0][0]*(v2)[X] + (r)[0][1]*(v2)[Y] +  (r)[0][2]*(v2)[Z], \
 (v1)[Y] op (r)[1][0]*(v2)[X] + (r)[1][1]*(v2)[Y] +  (r)[1][2]*(v2)[Z], \
 (v1)[Z] op (r)[2][0]*(v2)[X] + (r)[2][1]*(v2)[Y] +  (r)[2][2]*(v2)[Z]  \
)
#define VecOpRotVec2(v1,op,r,v2)             \
((v1)[X] op (r)[0][0]*(v2)[X] + (r)[0][1]*(v2)[Y], \
 (v1)[Y] op (r)[1][0]*(v2)[X] + (r)[1][1]*(v2)[Y]  \
)

#define SetRot(r,v1,v2,v3)    \
((r)[0][0] = (v1)[X], (r)[0][1] = (v1)[Y], (r)[0][2] = (v1)[Z],  \
 (r)[1][0] = (v2)[X], (r)[1][1] = (v2)[Y], (r)[1][2] = (v2)[Z],  \
 (r)[2][0] = (v3)[X], (r)[2][1] = (v3)[Y], (r)[2][2] = (v3)[Z]   \
)
#define SetRot2(r,v1,v2,v3)    \
((r)[0][0] = (v1)[X], (r)[0][1] = (v1)[Y],  \
 (r)[1][0] = (v2)[X], (r)[1][1] = (v2)[Y]   \
)

#define DetRot(r) \
(- (r)[0][2]*(r)[1][1]*(r)[2][0] + (r)[0][1]*(r)[1][2]*(r)[2][0] \
 + (r)[0][2]*(r)[1][0]*(r)[2][1] - (r)[0][0]*(r)[1][2]*(r)[2][1] \
 - (r)[0][1]*(r)[1][0]*(r)[2][2] + (r)[0][0]*(r)[1][1]*(r)[2][2] \
)
#define DetRot2(r)           ((r)[0][0]*(r)[1][1] - (r)[0][1]*(r)[1][0])