Quanternions

Quanternions — Quaternions algebra and mapping to matrix

Synopsis

#define             NC_QUATERNION_MEMCPY                (a,
                                                         b)
#define             NC_QUATERNION_NEW
#define             NC_QUATERNION_NEW_I
#define             NC_QUATERNION_NORM                  (q)
#define             NC_QUATERNION_SET_0                 (q)
#define             NC_QUATERNION_SET_I                 (q)
#define             NC_TRIVEC_DOT                       (a,
                                                         b)
#define             NC_TRIVEC_MEMCPY                    (a,
                                                         b)
#define             NC_TRIVEC_NEW
#define             NC_TRIVEC_NORM                      (a)
#define             NC_TRIVEC_NORMALIZE                 (a)
#define             NC_TRIVEC_SCALE                     (a,
                                                         b)
#define             NC_TRIVEC_SET_0                     (v)
struct              NcQ;
struct              NcTriVector;
void                nc_quaternion_conjugate             (NcQ *q);
void                nc_quaternion_conjugate_q_mul       (NcQ *q,
                                                         NcQ *u,
                                                         NcQ *res);
void                nc_quaternion_conjugate_u_mul       (NcQ *q,
                                                         NcQ *u,
                                                         NcQ *res);
void                nc_quaternion_free                  (NcQ *q);
void                nc_quaternion_inv_rotate            (NcQ *q,
                                                         NcTriVector v);
void                nc_quaternion_lmul                  (NcQ *q,
                                                         NcQ *u);
void                nc_quaternion_mul                   (NcQ *q,
                                                         NcQ *u,
                                                         NcQ *res);
NcQ *               nc_quaternion_new                   ();
NcQ *               nc_quaternion_new_from_data         (gdouble x,
                                                         gdouble y,
                                                         gdouble z,
                                                         gdouble theta);
NcQ *               nc_quaternion_new_from_vector       (NcTriVector v);
void                nc_quaternion_normalize             (NcQ *q);
void                nc_quaternion_rmul                  (NcQ *q,
                                                         NcQ *u);
void                nc_quaternion_rotate                (NcQ *q,
                                                         NcTriVector v);
void                nc_quaternion_set_from_data         (NcQ *q,
                                                         gdouble x,
                                                         gdouble y,
                                                         gdouble z,
                                                         gdouble theta);
void                nc_quaternion_set_random            (NcQ *q);

Description

FIXME

Details

NC_QUATERNION_MEMCPY()

#define NC_QUATERNION_MEMCPY(a,b) memcpy (a, b, sizeof(NcQ))

NC_QUATERNION_NEW

#define NC_QUATERNION_NEW {0.0, {{0.0, 0.0, 0.0}}}

NC_QUATERNION_NEW_I

#define NC_QUATERNION_NEW_I {1.0, {{0.0, 0.0, 0.0}}}

NC_QUATERNION_NORM()

#define             NC_QUATERNION_NORM(q)

NC_QUATERNION_SET_0()

#define             NC_QUATERNION_SET_0(q)

NC_QUATERNION_SET_I()

#define             NC_QUATERNION_SET_I(q)

NC_TRIVEC_DOT()

#define NC_TRIVEC_DOT(a, b) ((a).c[0]*(b).c[0] + (a).c[1]*(b).c[1] + (a).c[2]*(b).c[2])

NC_TRIVEC_MEMCPY()

#define NC_TRIVEC_MEMCPY(a, b) memcpy (&(a), &(b), sizeof (NcTriVector))

NC_TRIVEC_NEW

#define NC_TRIVEC_NEW {{0.0, 0.0, 0.0}}

NC_TRIVEC_NORM()

#define NC_TRIVEC_NORM(a) sqrt((a).c[0]*(a).c[0] + (a).c[1]*(a).c[1] + (a).c[2]*(a).c[2])

NC_TRIVEC_NORMALIZE()

#define NC_TRIVEC_NORMALIZE(a) NC_TRIVEC_SCALE(a, 1.0/NC_TRIVEC_NORM(a))

NC_TRIVEC_SCALE()

#define             NC_TRIVEC_SCALE(a, b)

NC_TRIVEC_SET_0()

#define NC_TRIVEC_SET_0(v) memset(&(v), 0, sizeof(NcTriVector))

struct NcQ

struct NcQ {
};

FIXME


struct NcTriVector

struct NcTriVector {
};

FIXME


nc_quaternion_conjugate ()

void                nc_quaternion_conjugate             (NcQ *q);

nc_quaternion_conjugate_q_mul ()

void                nc_quaternion_conjugate_q_mul       (NcQ *q,
                                                         NcQ *u,
                                                         NcQ *res);

nc_quaternion_conjugate_u_mul ()

void                nc_quaternion_conjugate_u_mul       (NcQ *q,
                                                         NcQ *u,
                                                         NcQ *res);

nc_quaternion_free ()

void                nc_quaternion_free                  (NcQ *q);

FIXME

q :

a NcQ

nc_quaternion_inv_rotate ()

void                nc_quaternion_inv_rotate            (NcQ *q,
                                                         NcTriVector v);

nc_quaternion_lmul ()

void                nc_quaternion_lmul                  (NcQ *q,
                                                         NcQ *u);

nc_quaternion_mul ()

void                nc_quaternion_mul                   (NcQ *q,
                                                         NcQ *u,
                                                         NcQ *res);

nc_quaternion_new ()

NcQ *               nc_quaternion_new                   ();

FIXME

Returns :

FIXME

nc_quaternion_new_from_data ()

NcQ *               nc_quaternion_new_from_data         (gdouble x,
                                                         gdouble y,
                                                         gdouble z,
                                                         gdouble theta);

FIXME

x :

FIXME

y :

FIXME

z :

FIXME

theta :

FIXME

Returns :

FIXME

nc_quaternion_new_from_vector ()

NcQ *               nc_quaternion_new_from_vector       (NcTriVector v);

FIXME

v :

a NcTriVector

Returns :

FIXME

nc_quaternion_normalize ()

void                nc_quaternion_normalize             (NcQ *q);

nc_quaternion_rmul ()

void                nc_quaternion_rmul                  (NcQ *q,
                                                         NcQ *u);

nc_quaternion_rotate ()

void                nc_quaternion_rotate                (NcQ *q,
                                                         NcTriVector v);

nc_quaternion_set_from_data ()

void                nc_quaternion_set_from_data         (NcQ *q,
                                                         gdouble x,
                                                         gdouble y,
                                                         gdouble z,
                                                         gdouble theta);

nc_quaternion_set_random ()

void                nc_quaternion_set_random            (NcQ *q);