Dual and dual quaternion functions

Macros
#define	DualAdd(a, b, c)
#define	DualBlend(d1, d2, b, d)
#define	DualCompare(x, y)   DualCompCompare (x, ==, y)
#define	DualCompCompare(x, op, y)   ((x).r op (y).r) && ((x).e op (y).e)
#define	DualConj(a, b)
#define	DualExpand(d)   (d).r, (d).e
#define	DualIsUnit(a)   (((a).r - 1) * ((a).r - 1) < 1e-6 && (a).e * (a).e < 1e-6)
#define	DualIsZero(a)   ((a).r == 0 && (a).e == 0)
#define	DualMult(a, b, c)
#define	DualMultAdd(a, s, b, c)
#define	DualMultSub(a, s, b, c)
#define	DualNegate(a, b)
#define	DualNorm(a)   ((a).r)
#define	DualQuatAdd(a, b, c)
#define	DualQuatBlend(dq1, dq2, b, dq)
#define	DualQuatCompare(x, y)   DualQuatCompCompare (x, ==, y)
#define	DualQuatCompCompare(x, op, y)
#define	DualQuatConjE(a, b)
#define	DualQuatConjQ(a, b)
#define	DualQuatConjQE(a, b)
#define	DualQuatExpand(dq)   QuatExpand ((dq).q0.q), QuatExpand ((dq).qe.q)
#define	DualQuatIsZero(a)   (QuatIsZero ((a).q0.q) && QuatIsZero ((a).qe.q))
#define	DualQuatMult(a, b, c)
#define	DualQuatMultAdd(a, s, b, c)
#define	DualQuatMultSub(a, s, b, c)
#define	DualQuatNegate(a, b)
#define	DualQuatNorm(a, b)
#define	DualQuatRotTrans(rot, trans, dq)
#define	DualQuatScale(a, b, c)
#define	DualQuatSetVect(vec, a)
#define	DualQuatSubtract(a, b, c)
#define	DualQuatZero(a)
#define	DualScale(a, b, c)
#define	DualSet(ar, ae, a)
#define	DualSubtract(a, b, c)
#define	DualZero(a)

Detailed Description

Macro Definition Documentation

#define DualAdd	(		a,
			b,
			c
	)

Value:

do { \
        (c).r = (a).r + (b).r; \
        (c).e = (a).e + (b).e; \
    } while (0)

#define DualBlend	(		d1,
			d2,
			b,
			d
	)

Value:

do { \
        (d).r = (d1).r * (1 - (b)) + (d2).r * (b); \
        (d).e = (d1).e * (1 - (b)) + (d2).e * (b); \
    } while (0)

#define DualCompare	(		x,
			y
	)		DualCompCompare (x, ==, y)

#define DualCompCompare	(		x,
			op,
			y
	)		((x).r op (y).r) && ((x).e op (y).e)

#define DualConj	(		a,
			b
	)

Value:

do { \
        (b).r = (a).r; \
        (b).e = -(a).e; \
    } while (0)

#define DualExpand

(

d

)

(d).r, (d).e

#define DualIsUnit

(

a

)

(((a).r - 1) * ((a).r - 1) < 1e-6 && (a).e * (a).e < 1e-6)

#define DualIsZero

(

a

)

((a).r == 0 && (a).e == 0)

#define DualMult	(		a,
			b,
			c
	)

Value:

do { \
        (c).e = (a).r * (b).e + (a).e * (b).r; \
        (c).r = (a).r * (b).r; \
    } while (0)

#define DualMultAdd	(		a,
			s,
			b,
			c
	)

Value:

do { \
        (c).r = (a).r + (s) * (b).r; \
        (c).e = (a).e + (s) * (b).e; \
    } while (0)

#define DualMultSub	(		a,
			s,
			b,
			c
	)

Value:

do { \
        (c).r = (a).r - (s) * (b).r; \
        (c).e = (a).e - (s) * (b).e; \
    } while (0)

#define DualNegate	(		a,
			b
	)

Value:

do { \
        (b).r = -(a).r; \
        (b).e = -(a).e; \
    } while (0)

#define DualNorm

(

a

)

((a).r)

#define DualQuatAdd	(		a,
			b,
			c
	)

Value:

do { \
		QuatAdd ((a).q0.q, (b).q0.q, (c).q0.q); \
		QuatAdd ((a).qe.q, (b).qe.q, (c).qe.q); \
    } while (0)

#define DualQuatBlend	(		dq1,
			dq2,
			b,
			dq
	)

Value:

do { \
		QuatBlend ((dq1).q0.q, (dq2).q0.q, (b), (dq).q0.q); \
		QuatBlend ((dq1).qe.q, (dq2).qe.q, (b), (dq).qe.q); \
    } while (0)

#define DualQuatCompare	(		x,
			y
	)		DualQuatCompCompare (x, ==, y)

#define DualQuatCompCompare	(		x,
			op,
			y
	)

Value:

(QuatCompCompare ((x).q0.q, op, (y).q0.q) \
     &&QuatCompCompare ((x).qe.q, op, (y).qe.q))

#define DualQuatConjE	(		a,
			b
	)

Value:

do { \
        (b).q0 = (a).q0; \
		QuatNegate ((a).qe.q, (b).qe.q); \
    } while (0)

#define DualQuatConjQ	(		a,
			b
	)

Value:

do { \
		QuatConj ((a).q0.q, (b).q0.q); \
		QuatConj ((a).qe.q, (b).qe.q); \
    } while (0)

#define DualQuatConjQE	(		a,
			b
	)

Value:

do { \
		QuatConj ((a).q0.q, (b).q0.q); \
        (b).qe.sv.s = -(a).qe.sv.s; \
		VectorCopy ((a).qe.sv.v, (b).qe.sv.v); \
    } while (0)

#define DualQuatExpand

(

dq

)

QuatExpand ((dq).q0.q), QuatExpand ((dq).qe.q)

#define DualQuatIsZero

(

a

)

(QuatIsZero ((a).q0.q) && QuatIsZero ((a).qe.q))

#define DualQuatMult	(		a,
			b,
			c
	)

Value:

do { \
        Quat_t      t; \
		QuatMult ((a).q0.q, (b).qe.q, t.q); \
		QuatMult ((a).qe.q, (b).q0.q, (c).qe.q); \
		QuatAdd (t.q, (c).qe.q, (c).qe.q); \
		QuatMult ((a).q0.q, (b).q0.q, (c).q0.q); \
    } while (0);

#define DualQuatMultAdd	(		a,
			s,
			b,
			c
	)

Value:

do { \
		QuatMultAdd ((a).q0.q, s, (b).q0.q, (c).q0.q); \
		QuatMultAdd ((a).qe.q, s, (b).qe.q, (c).qe.q); \
    } while (0)

#define DualQuatMultSub	(		a,
			s,
			b,
			c
	)

Value:

do { \
		QuatMultSub ((a).q0.q, s, (b).q0.q, (c).q0.q); \
		QuatMultSub ((a).qe.q, s, (b).qe.q, (c).qe.q); \
    } while (0)

#define DualQuatNegate	(		a,
			b
	)

Value:

do { \
		QuatNegate ((a).q0.q, (b).q0.q); \
		QuatNegate ((a).qe.q, (b).qe.q); \
    } while (0)

#define DualQuatNorm	(		a,
			b
	)

Value:

do { \
        (b).r = QuatLength ((a).q0.q); \
        (b).e = 2 * QDotProduct ((a).q0.q, (a).qe.q); \
    } while (0)

#define DualQuatRotTrans	(		rot,
			trans,
			dq
	)

Value:

do { \
		QuatCopy (rot, (dq).q0.q); \
        (dq).qe.sv.s = 0; \
        VectorScale (trans, 0.5, (dq).qe.sv.v); \
		QuatMult ((dq).qe.q, (dq).q0.q, (dq).qe.q); \
    } while (0)

#define DualQuatScale	(		a,
			b,
			c
	)

Value:

do { \
        QuatSub ((a).q0.q, (b), (c).q0.q); \
        QuatSub ((a).qe.q, (b), (c).qe.q); \
    } while (0)

#define DualQuatSetVect	(		vec,
			a
	)

Value:

do { \
        (a).q0.sv.s = 1; \
        VectorZero ((a).q0.sv.v); \
        (a).qe.sv.s = 0; \
        VectorCopy (vec, (a).qe.sv.v); \
    } while (0)

#define DualQuatSubtract	(		a,
			b,
			c
	)

Value:

do { \
        QuatSub ((a).q0.q, (b).q0.q, (c).q0.q); \
        QuatSub ((a).qe.q, (b).qe.q, (c).qe.q); \
    } while (0)

#define DualQuatZero

(

a

)

Value:

do { \
		QuatZero ((a).q0.q); \
		QuatZero ((a).qe.q); \
    } while (0)

#define DualScale	(		a,
			b,
			c
	)

Value:

do { \
        (c).r = (a).r * (b); \
        (c).e = (a).e * (b); \
    } while (0)

#define DualSet	(		ar,
			ae,
			a
	)

Value:

do { \
        (a).ar = r; \
        (a).er = r; \
    } while (0)

#define DualSubtract	(		a,
			b,
			c
	)

Value:

do { \
        (c).r = (a).r - (b).r; \
        (c).e = (a).e - (b).e; \
    } while (0)

#define DualZero

(

a

)

Value:

do { \
        (a).e = (a).r = 0; \
    } while (0)