libQuat
Loading...
Searching...
No Matches
libquat.h
Go to the documentation of this file.
1/**
2 * @addtogroup quaternions Library for 3D Vectors & Quaternions
3 * @{
4 * @file
5 * @brief Library that provides data types for 3D vectors and quaternions,
6 * inter-conversions and related operations.
7 * @version @LIBQUAT_VERSION_MAJOR@.@LIBQUAT_VERSION_MINOR@
8 * @author Krishna Vedala
9 */
10
11#ifndef __LIBQUAT_H_
12#define __LIBQUAT_H_
13
14#if BUILDING_LIBQUAT && HAVE_VISIBILITY
15#define LIBQUAT_DLL_EXPORTED __attribute__((__visibility__("default")))
16#elif BUILDING_LIBQUAT && defined _MSC_VER
17#define LIBQUAT_DLL_EXPORTED __declspec(dllexport)
18#elif defined _MSC_VER
19#define LIBQUAT_DLL_EXPORTED __declspec(dllimport)
20#else
21#define LIBQUAT_DLL_EXPORTED
22#endif
23
24#define LIBQUAT_EPSILON \
25 1e-9 /**< Minimum recognizable value. Any value less than this is \
26 considered to be @f$=0@f$ */
27
28#ifdef __cplusplus
29#include <iostream>
30extern "C" {
31#endif
32
33/**
34 * @addtogroup errors Error module
35 * @{
36 */
37/** Library return types indicating different error types. */
38typedef enum {
39 LIBQUAT_OK = 0, /**< No error */
40 LIBQUAT_BAD_VERSION, /**< header and library version do not match */
41 LIBQUAT_DIV_BY_ZERO, /**< Division by zero */
43
44/**
45 * Obtain descriptive string message for a #libquat_err type error code.
46 * @param[in] err_code error code from the library api calls
47 * @return error description string
48 */
49LIBQUAT_DLL_EXPORTED const char *err_to_str(libquat_err err_code);
50
51/**
52 * Function to check the version number of the library with the header.
53 * @param[in] major_ver provide major version as input
54 * @return error of type #libquat_err
55 */
56LIBQUAT_DLL_EXPORTED libquat_err libquat_version_check(const char major_ver);
57/** @} */
58
59/**
60 * @addtogroup vec_3d 3D Vector operations
61 * @{
62 */
63/** 3D vector type */
64typedef struct vec_3d_ {
65 float x; /**< X co-ordinate */
66 float y; /**< Y co-ordinate */
67 float z; /**< Z co-ordinate */
69/** @} */
70
71/**
72 * @addtogroup matrix Matrix operations
73 * @{
74 */
75/** A 3x3 Matrix type definition */
76typedef struct mat_3x3_ {
77 union { /**< 3 element row 1 */
78 float row1[3];
79 vec_3d vec1;
80 };
81 union { /**< 3 element row 2 */
82 float row2[3];
83 vec_3d vec2;
84 };
85 union { /**< 3 element row 3 */
86 float row3[3];
87 vec_3d vec3;
88 };
90/** @} */
91
92/**
93 * @addtogroup vec_3d 3D Vector operations
94 * @{
95 */
96/**
97 * Obtain the dot product of two 3D vectors.
98 * @f[
99 * \vec{a}\cdot\vec{b}=a_xb_x + a_yb_y + a_zb_z
100 * @f]
101 * @param[in] a first vector
102 * @param[in] b second vector
103 * @returns resulting dot product
104 */
105LIBQUAT_DLL_EXPORTED float dot_prod(const vec_3d *a, const vec_3d *b);
106
107/**
108 * Subtract one vector from another. @f[
109 * \vec{c}=\vec{a}-\vec{b}=\left(a_x-b_x\right)\hat{i}+
110 * \left(a_y-b_y\right)\hat{j}+\left(a_z-b_z\right)\hat{k}@f]
111 * @param[in] a vector to subtract from
112 * @param[in] b vector to subtract
113 * @returns resultant vector
114 */
115LIBQUAT_DLL_EXPORTED vec_3d vector_sub(const vec_3d *a, const vec_3d *b);
116
117/**
118 * Add one vector to another. @f[
119 * \vec{c}=\vec{a}+\vec{b}=\left(a_x+b_x\right)\hat{i}+
120 * \left(a_y+b_y\right)\hat{j}+\left(a_z+b_z\right)\hat{k}@f]
121 * @param[in] a vector to add to
122 * @param[in] b vector to add
123 * @returns resultant vector
124 */
125LIBQUAT_DLL_EXPORTED vec_3d vector_add(const vec_3d *a, const vec_3d *b);
126
127/**
128 * Compute the vector product of two 3d vectors.
129 * @f[\begin{align*}
130 * \vec{a}\times\vec{b} &= \begin{vmatrix}
131 * \hat{i} & \hat{j} & \hat{k}\\
132 * a_x & a_y & a_z\\
133 * b_x & b_y & b_z
134 * \end{vmatrix}\\
135 * &= \left(a_yb_z-b_ya_z\right)\hat{i} - \left(a_xb_z-b_xa_z\right)\hat{j}
136 * + \left(a_xb_y-b_xa_y\right)\hat{k} \end{align*}
137 * @f]
138 * @param[in] a first vector @f$\vec{a}@f$
139 * @param[in] b second vector @f$\vec{b}@f$
140 * @returns resultant vector @f$\vec{o}=\vec{a}\times\vec{b}@f$
141 */
142LIBQUAT_DLL_EXPORTED vec_3d vector_prod(const vec_3d *a, const vec_3d *b);
143
144/**
145 * Print formatted vector on stdout.
146 * @param[in] a vector to print
147 * @param[in] name name of the vector
148 * @returns formatted vector for printing
149 */
150LIBQUAT_DLL_EXPORTED LIBQUAT_DLL_EXPORTED const char *print_vector(
151 const vec_3d *a, const char *name);
152
153/**
154 * Compute the norm a vector.
155 * @f[\lVert\vec{a}\rVert = \sqrt{\vec{a}\cdot\vec{a}} @f]
156 * @param[in] a input vector
157 * @returns norm of the given vector
158 */
159LIBQUAT_DLL_EXPORTED float vector_norm(const vec_3d *a);
160
161/**
162 * Obtain unit vector in the same direction as given vector.
163 * @f[\hat{a}=\frac{\vec{a}}{\lVert\vec{a}\rVert}@f]
164 * @param[in] a input vector
165 * @returns unit vector in the direction of @f$\vec{a}@f$
166 */
167LIBQUAT_DLL_EXPORTED vec_3d unit_vec(const vec_3d *a);
168
169/**
170 * The cross product of vectors can be represented as a matrix
171 * multiplication operation. This function obtains the `3x3` matrix
172 * of the cross-product operator from the first vector.
173 * @f[\begin{align*}
174 * \left(\vec{a}\times\right)\vec{b} &= \tilde{A}_a\vec{b}\\
175 * \tilde{A}_a &=
176 * \begin{bmatrix}0&-a_z&a_y\\a_z&0&-a_x\\-a_y&a_x&0\end{bmatrix}
177 * \end{align*}@f]
178 * @param[in] a input vector
179 * @returns the `3x3` matrix for the cross product operator
180 * @f$\left(\vec{a}\times\right)@f$
181 */
182LIBQUAT_DLL_EXPORTED mat_3x3 get_cross_matrix(const vec_3d *a);
183
184/** @} */
185
186/** @addtogroup quats 3D Quaternion operations
187 * @{
188 */
189/** a Quaternion type represented using a scalar \f$w\f$ or \f$q_0\f$ and a
190 * 3D vector \f$\left(q_1,q_2,q_3\right)\f$
191 */
192typedef struct quaternion_ {
193 union {
194 float w; /**< real part of quaternion */
195 float q0; /**< real part of quaternion */
196 };
197 /**< dual part of quaternion */
198 union {
199 vec_3d dual; /**< can be a 3D vector */
200 /** or individual values */
201 struct {
202 float q1, q2, q3;
203 };
204 };
206
207/** 3D Euler or Tait-Bryan angles (in radian) */
208typedef struct euler_ {
209 union {
210 float roll; /**< or bank \f$\phi\f$ = rotation about X axis */
211 float bank; /**< or roll \f$\phi\f$ = rotation about X axis */
212 };
213 union {
214 float pitch; /**< or elevation \f$\theta\f$ = rotation about Y axis */
215 float elevation; /**< or pitch \f$\theta\f$ = rotation about Y axis */
216 };
217 union {
218 float yaw; /**< or heading \f$\psi\f$ = rotation about Z axis */
219 float heading; /**< or yaw \f$\psi\f$ = rotation about Z axis */
220 };
222
223/**
224 * Function to convert given Euler angles to a quaternion.
225 * \f{eqnarray*}{
226 * q_{0} & =
227 * &\cos\left(\frac{\phi}{2}\right)\cos\left(\frac{\theta}{2}\right)\cos\left(\frac{\psi}{2}\right)
228 * +
229 * \sin\left(\frac{\phi}{2}\right)\sin\left(\frac{\theta}{2}\right)\sin\left(\frac{\psi}{2}\right)\\
230 * q_{1} & =
231 * &\sin\left(\frac{\phi}{2}\right)\cos\left(\frac{\theta}{2}\right)\cos\left(\frac{\psi}{2}\right)
232 * -
233 * \cos\left(\frac{\phi}{2}\right)\sin\left(\frac{\theta}{2}\right)\sin\left(\frac{\psi}{2}\right)\\
234 * q_{2} & =
235 * &\cos\left(\frac{\phi}{2}\right)\sin\left(\frac{\theta}{2}\right)\cos\left(\frac{\psi}{2}\right)
236 * +
237 * \sin\left(\frac{\phi}{2}\right)\cos\left(\frac{\theta}{2}\right)\sin\left(\frac{\psi}{2}\right)\\
238 * q_{3} & =
239 * &\cos\left(\frac{\phi}{2}\right)\cos\left(\frac{\theta}{2}\right)\sin\left(\frac{\psi}{2}\right)
240 * -
241 * \sin\left(\frac{\phi}{2}\right)\sin\left(\frac{\theta}{2}\right)\cos\left(\frac{\psi}{2}\right)\\
242 * \f}
243 *
244 * @param [in] in_euler input Euler angles instance
245 * @returns converted quaternion
246 */
247LIBQUAT_DLL_EXPORTED quaternion quat_from_euler(const euler *in_euler);
248
249/**
250 * Function to convert given quaternion to Euler angles.
251 * \f{eqnarray*}{
252 * \phi & = &
253 * \tan^{-1}\left[\frac{2\left(q_0q_1+q_2q_3\right)}{1-2\left(q_1^2+q_2^2\right)}\right]\\
254 * \theta & =
255 * &-\sin^{-1}\left[2\left(q_0q_2-q_3q_1\right)\right]\\
256 * \psi & = &
257 * \tan^{-1}\left[\frac{2\left(q_0q_3+q_1q_2\right)}{1-2\left(q_2^2+q_3^2\right)}\right]\\
258 * \f}
259 *
260 * @param [in] in_quat input quaternion instance
261 * @returns converted euler angles
262 */
263LIBQUAT_DLL_EXPORTED euler euler_from_quat(const quaternion *in_quat);
264
265/**
266 * Function to multiply two quaternions.
267 * \f{eqnarray*}{
268 * \mathbf{c} & = & \mathbf{a}\otimes\mathbf{b}\\
269 * & = & \begin{bmatrix}a_{0} & a_{1} & a_{2} &
270 * a_{3}\end{bmatrix}\otimes\begin{bmatrix}b_{0} & b_{1} & b_{2} &
271 * b_{3}\end{bmatrix}\\
272 * & = &
273 * \begin{bmatrix}
274 * a_{0}b_{0}-a_{1}b_{1}-a_{2}b_{2}-a_{3}b_{3}\\
275 * a_{0}b_{1}+a_{1}b_{0}+a_{2}b_{3}-a_{3}b_{2}\\
276 * a_{0}b_{2}-a_{1}b_{3}+a_{2}b_{0}+a_{3}b_{1}\\
277 * a_{0}b_{3}+a_{1}b_{2}-a_{2}b_{1}+a_{3}b_{0}
278 * \end{bmatrix}^{T}
279 * \f}
280 *
281 * @param [in] in_quat1 first input quaternion instance
282 * @param [in] in_quat2 second input quaternion instance
283 * @returns resultant quaternion
284 */
285LIBQUAT_DLL_EXPORTED quaternion quaternion_multiply(const quaternion *in_quat1,
286 const quaternion *in_quat2);
287
288/**
289 * Function to add two quaternions.
290 *
291 * @param [in] in_quat1 first input quaternion instance
292 * @param [in] in_quat2 second input quaternion instance
293 * @returns resultant quaternion
294 */
295LIBQUAT_DLL_EXPORTED quaternion quaternion_add(const quaternion *in_quat1,
296 const quaternion *in_quat2);
297
298/**
299 * Function to subtract two quaternions.
300 *
301 * @param [in] in_quat1 first input quaternion instance
302 * @param [in] in_quat2 second input quaternion instance
303 * @returns resultant quaternion
304 */
305LIBQUAT_DLL_EXPORTED quaternion quaternion_sub(const quaternion *in_quat1,
306 const quaternion *in_quat2);
307
308/**
309 * @brief Get conjugate of a quaternion. The conjugate is defined as:
310 * \f[
311 * \mathbf{A}^* = q_0- i \vec{q}
312 * \f]
313 *
314 * @param in_quat1 input quaternion
315 * @return conjugate of the input quaternion
316 */
317LIBQUAT_DLL_EXPORTED quaternion get_conjugate(const quaternion *in_quat1);
318
319/**
320 * @brief Get inverse of a quaternion. The inverse is defined as:
321 * \f[
322 * \mathbf{A}^{-1} = \frac{\mathbf{A}^*}{\left\lVert\mathbf{A}\right\rVert}
323 * \f]
324 *
325 * @param in_quat1 input quaternion
326 * @return inverse of the input quaternion if exists
327 * @returns NULL quaternion if inverse does not exist
328 */
329LIBQUAT_DLL_EXPORTED quaternion get_inverse(const quaternion *in_quat1);
330
331/** @} */
332
333/** @addtogroup dual_quats 3D Dual-Quaternion operations
334 * @{
335 */
336/** a dual quaternion type */
337typedef struct dual_quat_ {
338 quaternion real; /**< real part of dual quaternion */
339 quaternion dual; /**< dual part of dual quaternion */
341
342/** @} */
343
344#ifdef __cplusplus
345}
346
347/**
348 * @addtogroup vec_3d 3D Vector operations
349 * @{
350 */
351
352/**
353 * Subtract one vector from another.
354 * @f[
355 * \vec{c}=\vec{a}-\vec{b}=\left(a_x-b_x\right)\hat{i}+
356 * \left(a_y-b_y\right)\hat{j}+\left(a_z-b_z\right)\hat{k}
357 * @f]
358 * @param[in] a vector to subtract from
359 * @param[in] b vector to subtract
360 * @returns resultant vector
361 */
362LIBQUAT_DLL_EXPORTED vec_3d operator-(const vec_3d &a, const vec_3d &b);
363
364/**
365 * Unary negation operator.
366 * @f[
367 * -\vec{a}=(-a_x)\hat{i}+ (-a_y)\hat{j} + (-a_z)\hat{k}
368 * @f]
369 * @param[in] a vector to negate
370 * @returns resultant vector
371 */
372LIBQUAT_DLL_EXPORTED vec_3d operator-(const vec_3d &a);
373
374/**
375 * Add one vector to another.
376 * @f[
377 * \vec{c}=\vec{a}-\vec{b}=\left(a_x-b_x\right)\hat{i}+
378 * \left(a_y-b_y\right)\hat{j}+\left(a_z-b_z\right)\hat{k}
379 * @f]
380 * @param[in] a first vector to add
381 * @param[in] b second vector to add
382 * @returns resultant vector
383 */
384LIBQUAT_DLL_EXPORTED vec_3d operator+(const vec_3d &a, const vec_3d &b);
385
386/**
387 * Obtain the dot product of two 3D vectors.
388 * @f[
389 * \vec{a}\cdot\vec{b}=a_xb_x + a_yb_y + a_zb_z
390 * @f]
391 * @param[in] a first vector
392 * @param[in] b second vector
393 * @returns resulting dot product
394 */
395LIBQUAT_DLL_EXPORTED float operator*(const vec_3d &a, const vec_3d &b);
396
397/**
398 * Scalar multiplication of a 3D vector.
399 * @f[
400 * a\cdot\vec{b}=a\cdot b_x\hat{i} + a\cdot b_y \hat{j} + a\cdot b_z\hat{k}
401 * @f]
402 * @param[in] a pre-multiplying scalar
403 * @param[in] b second vector
404 * @returns resulting dot product
405 */
406LIBQUAT_DLL_EXPORTED vec_3d operator*(const float a, const vec_3d &b);
407
408/**
409 * Scalar multiplication of a 3D vector.
410 * @f[
411 * \vec{a}\cdot b=a_x\cdot b\hat{i} + a_y\cdot b\hat{j} + a_z\cdot b\hat{k}
412 * @f]
413 * @param[in] a first vector
414 * @param[in] b post-multiplying scalar
415 * @returns resulting dot product
416 */
417LIBQUAT_DLL_EXPORTED vec_3d operator*(const vec_3d &a, const float b);
418
419/**
420 * Scalar division of a 3D vector.
421 * @param[in] a vector to divide
422 * @param[in] b scalar divisor
423 * @returns resulting quotient
424 */
425LIBQUAT_DLL_EXPORTED vec_3d operator/(const vec_3d &a, const float b);
426
427/**
428 * Compute the vector product of two 3d vectors.
429 * @f[\begin{align*}
430 * \vec{a}\times\vec{b} &= \begin{vmatrix}
431 * \hat{i} & \hat{j} & \hat{k}\\
432 * a_x & a_y & a_z\\
433 * b_x & b_y & b_z
434 * \end{vmatrix}\\
435 * &= \left(a_yb_z-b_ya_z\right)\hat{i} - \left(a_xb_z-b_xa_z\right)\hat{j}
436 * + \left(a_xb_y-b_xa_y\right)\hat{k} \end{align*}
437 * @f]
438 * @param[in] a first vector @f$\vec{a}@f$
439 * @param[in] b second vector @f$\vec{b}@f$
440 * @returns resultant vector @f$\vec{o}=\vec{a}\times\vec{b}@f$
441 */
442LIBQUAT_DLL_EXPORTED vec_3d operator^(const vec_3d &a, const vec_3d &b);
443
444/**
445 * Compute the norm a vector.
446 * @f[\lVert\vec{a}\rVert = \sqrt{\vec{a}\cdot\vec{a}} @f]
447 * @param[in] a input vector
448 * @returns n norm of the given vector
449 */
450LIBQUAT_DLL_EXPORTED float operator~(const vec_3d &a);
451
452/**
453 * operator to print a vec_3d instance.
454 * @param out std::ostream stream to print output to
455 * @param v vector to print
456 * @returns formatted stream
457 */
458LIBQUAT_DLL_EXPORTED std::ostream &operator<<(std::ostream &out,
459 vec_3d const &v);
460/**
461 * operator to print a vec_3d instance.
462 * @param out std::ostream stream to print output to
463 * @param v vector to print
464 * @returns formatted stream
465 */
466LIBQUAT_DLL_EXPORTED std::ostream &operator<<(std::ostream &out,
467 quaternion const &v);
468
469/** @} */
470
471/** @addtogroup quats 3D Quaternion operations
472 * @{
473 */
474
475/**
476 * Function to add two quaternions.
477 *
478 * @param [in] in_quat1 first input quaternion instance
479 * @param [in] in_quat2 second input quaternion instance
480 * @returns resultant quaternion
481 */
482LIBQUAT_DLL_EXPORTED quaternion operator+(const quaternion &in_quat1,
483 const quaternion &in_quat2);
484
485/**
486 * Function to subtract two quaternions.
487 *
488 * @param [in] in_quat1 quaternion to subtract from
489 * @param [in] in_quat2 quaternion to subtract
490 * @returns resultant quaternion
491 */
492LIBQUAT_DLL_EXPORTED quaternion operator-(const quaternion &in_quat1,
493 const quaternion &in_quat2);
494
495/**
496 * Function to multiply two quaternions.
497 * \f{eqnarray*}{
498 * \mathbf{c} & = & \mathbf{a}\otimes\mathbf{b}\\
499 * & = & \begin{bmatrix}a_{0} & a_{1} & a_{2} &
500 * a_{3}\end{bmatrix}\otimes\begin{bmatrix}b_{0} & b_{1} & b_{2} &
501 * b_{3}\end{bmatrix}\\
502 * & = &
503 * \begin{bmatrix}
504 * a_{0}b_{0}-a_{1}b_{1}-a_{2}b_{2}-a_{3}b_{3}\\
505 * a_{0}b_{1}+a_{1}b_{0}+a_{2}b_{3}-a_{3}b_{2}\\
506 * a_{0}b_{2}-a_{1}b_{3}+a_{2}b_{0}+a_{3}b_{1}\\
507 * a_{0}b_{3}+a_{1}b_{2}-a_{2}b_{1}+a_{3}b_{0}
508 * \end{bmatrix}^{T}
509 * \f}
510 *
511 * @param [in] in_quat1 first input quaternion instance
512 * @param [in] in_quat2 second input quaternion instance
513 * @returns resultant quaternion
514 */
515LIBQUAT_DLL_EXPORTED quaternion operator*(const quaternion &in_quat1,
516 const quaternion &in_quat2);
517
518/**
519 * Scalar multiplication of a 3D quaternion.
520 * @param[in] a pre-multiplying scalar
521 * @param[in] b second quaternion
522 * @returns resulting dot product
523 */
524LIBQUAT_DLL_EXPORTED quaternion operator*(const float a, const quaternion &b);
525
526/**
527 * Scalar multiplication of a 3D quaternion.
528 * @param[in] a pre-multiplying quaternion
529 * @param[in] b post-multiplying scalar
530 * @returns resulting product
531 */
532LIBQUAT_DLL_EXPORTED quaternion operator*(const quaternion &a, const float b);
533
534/**
535 * Scalar division of a 3D quaternion.
536 * @param[in] a quaternion to divide
537 * @param[in] b scalar divisor
538 * @returns resulting quotient
539 */
540LIBQUAT_DLL_EXPORTED quaternion operator/(const quaternion &a, const float b);
541
542/**
543 * @brief Get conjugate of a quaternion. The conjugate is defined as:
544 * \f[
545 * \mathbf{A}^* = q_0- i \vec{q}
546 * \f]
547 *
548 * @param in_quat1 input quaternion
549 * @return conjugate of the input quaternion
550 */
551LIBQUAT_DLL_EXPORTED quaternion operator!(const quaternion &in_quat1);
552
553/**
554 * Compute the norm a quaternion.
555 * @f[
556 * \lVert A\rVert = \sqrt{q_0^2 + \vec{a}\cdot\vec{a}}
557 * @f]
558 * @param[in] a input vector
559 * @returns n norm of the given vector
560 */
561LIBQUAT_DLL_EXPORTED float operator~(const quaternion &a);
562
563/**
564 * @brief Get inverse of a quaternion. The inverse is defined as:
565 * \f[
566 * \mathbf{A}^{-1} = \frac{\mathbf{A}^*}{\left\lVert\mathbf{A}\right\rVert}
567 * \f]
568 * @param[in] a input quaternion
569 * @returns resultant quaternion
570 */
571LIBQUAT_DLL_EXPORTED quaternion operator+(const quaternion &a);
572/** @} */
573
574#endif
575
576#endif // __LIBQUAT_H_
577
578/** @} */
struct dual_quat_ dual_quat
libquat_err
Definition: libquat.h:38
LIBQUAT_DLL_EXPORTED libquat_err libquat_version_check(const char major_ver)
Definition: libquat_err.c:28
LIBQUAT_DLL_EXPORTED const char * err_to_str(libquat_err err_code)
Definition: libquat_err.c:15
@ LIBQUAT_OK
Definition: libquat.h:39
@ LIBQUAT_DIV_BY_ZERO
Definition: libquat.h:41
@ LIBQUAT_BAD_VERSION
Definition: libquat.h:40
struct mat_3x3_ mat_3x3
LIBQUAT_DLL_EXPORTED quaternion quaternion_multiply(const quaternion *in_quat1, const quaternion *in_quat2)
Definition: libquat_quat.cpp:109
LIBQUAT_DLL_EXPORTED quaternion get_conjugate(const quaternion *in_quat1)
Get conjugate of a quaternion. The conjugate is defined as:
Definition: libquat_quat.cpp:131
LIBQUAT_DLL_EXPORTED quaternion quat_from_euler(const euler *in_euler)
Definition: libquat_quat.cpp:16
LIBQUAT_DLL_EXPORTED quaternion quaternion_sub(const quaternion *in_quat1, const quaternion *in_quat2)
Definition: libquat_quat.cpp:169
LIBQUAT_DLL_EXPORTED euler euler_from_quat(const quaternion *in_quat)
Definition: libquat_quat.cpp:40
struct euler_ euler
LIBQUAT_DLL_EXPORTED quaternion get_inverse(const quaternion *in_quat1)
Get inverse of a quaternion. The inverse is defined as:
Definition: libquat_quat.cpp:198
struct quaternion_ quaternion
LIBQUAT_DLL_EXPORTED quaternion quaternion_add(const quaternion *in_quat1, const quaternion *in_quat2)
Definition: libquat_quat.cpp:149
LIBQUAT_DLL_EXPORTED quaternion operator!(const quaternion &in_quat1)
Get conjugate of a quaternion. The conjugate is defined as:
Definition: libquat_quat.cpp:120
LIBQUAT_DLL_EXPORTED mat_3x3 get_cross_matrix(const vec_3d *a)
Definition: libquat_vec.cpp:162
LIBQUAT_DLL_EXPORTED vec_3d operator/(const vec_3d &a, const float b)
Definition: libquat_vec.cpp:86
LIBQUAT_DLL_EXPORTED vec_3d operator+(const vec_3d &a, const vec_3d &b)
Definition: libquat_vec.cpp:38
LIBQUAT_DLL_EXPORTED float vector_norm(const vec_3d *a)
Definition: libquat_vec.cpp:141
LIBQUAT_DLL_EXPORTED float operator*(const vec_3d &a, const vec_3d &b)
Definition: libquat_vec.cpp:53
LIBQUAT_DLL_EXPORTED vec_3d vector_prod(const vec_3d *a, const vec_3d *b)
Definition: libquat_vec.cpp:106
LIBQUAT_DLL_EXPORTED vec_3d vector_add(const vec_3d *a, const vec_3d *b)
Definition: libquat_vec.cpp:51
LIBQUAT_DLL_EXPORTED float operator~(const vec_3d &a)
Definition: libquat_vec.cpp:130
LIBQUAT_DLL_EXPORTED float dot_prod(const vec_3d *a, const vec_3d *b)
Definition: libquat_vec.cpp:84
LIBQUAT_DLL_EXPORTED std::ostream & operator<<(std::ostream &out, vec_3d const &v)
Definition: libquat_vec.cpp:108
LIBQUAT_DLL_EXPORTED LIBQUAT_DLL_EXPORTED const char * print_vector(const vec_3d *a, const char *name)
Definition: libquat_vec.cpp:123
LIBQUAT_DLL_EXPORTED vec_3d operator^(const vec_3d &a, const vec_3d &b)
Definition: libquat_vec.cpp:96
LIBQUAT_DLL_EXPORTED vec_3d unit_vec(const vec_3d *a)
Definition: libquat_vec.cpp:143
LIBQUAT_DLL_EXPORTED vec_3d vector_sub(const vec_3d *a, const vec_3d *b)
Definition: libquat_vec.cpp:36
struct vec_3d_ vec_3d
LIBQUAT_DLL_EXPORTED vec_3d operator-(const vec_3d &a, const vec_3d &b)
Definition: libquat_vec.cpp:23
Definition: libquat.h:337
quaternion dual
Definition: libquat.h:339
quaternion real
Definition: libquat.h:338
Definition: libquat.h:208
float bank
Definition: libquat.h:211
float roll
Definition: libquat.h:210
float heading
Definition: libquat.h:219
float pitch
Definition: libquat.h:214
float yaw
Definition: libquat.h:218
float elevation
Definition: libquat.h:215
Definition: libquat.h:76
float row3[3]
Definition: libquat.h:86
float row2[3]
Definition: libquat.h:82
float row1[3]
Definition: libquat.h:78
Definition: libquat.h:192
float q0
Definition: libquat.h:195
vec_3d dual
Definition: libquat.h:199
float w
Definition: libquat.h:194
Definition: libquat.h:64
float z
Definition: libquat.h:67
float x
Definition: libquat.h:65
float y
Definition: libquat.h:66