CMaths.h
Go to the documentation of this file.
1 //==============================================================================
2 /*
3  Software License Agreement (BSD License)
4  Copyright (c) 2003-2016, CHAI3D.
5  (www.chai3d.org)
6 
7  All rights reserved.
8 
9  Redistribution and use in source and binary forms, with or without
10  modification, are permitted provided that the following conditions
11  are met:
12 
13  * Redistributions of source code must retain the above copyright
14  notice, this list of conditions and the following disclaimer.
15 
16  * Redistributions in binary form must reproduce the above
17  copyright notice, this list of conditions and the following
18  disclaimer in the documentation and/or other materials provided
19  with the distribution.
20 
21  * Neither the name of CHAI3D nor the names of its contributors may
22  be used to endorse or promote products derived from this software
23  without specific prior written permission.
24 
25  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
26  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
27  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
28  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
29  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
30  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
31  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
32  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
33  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
35  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36  POSSIBILITY OF SUCH DAMAGE.
37 
38  \author <http://www.chai3d.org>
39  \author Francois Conti
40  \version 3.2.0 $Rev: 2163 $
41 */
42 //==============================================================================
43 
44 //------------------------------------------------------------------------------
45 #ifndef CMathsH
46 #define CMathsH
47 //------------------------------------------------------------------------------
48 #include "math/CTransform.h"
49 #include <math.h>
50 //------------------------------------------------------------------------------
51 
52 //------------------------------------------------------------------------------
53 namespace chai3d {
54 //------------------------------------------------------------------------------
55 
56 //==============================================================================
64 //==============================================================================
65 
66 //------------------------------------------------------------------------------
70 //------------------------------------------------------------------------------
71 
73 
74 //==============================================================================
91 //==============================================================================
92 inline bool cCheckBit(const unsigned int& a_value, const unsigned int& a_bitPosition)
93 {
94  if ((a_value & (1<<a_bitPosition)) > 0)
95  {
96  return (true);
97  }
98  else
99  {
100  return (false);
101  }
102 }
103 
104 
105 //==============================================================================
125 //==============================================================================
126 inline unsigned int cSetBit(const unsigned int& a_data, const unsigned int& a_bitPosition, const bool a_value)
127 {
128  if (a_value)
129  {
130  return (a_data | (1<<a_bitPosition));
131  }
132  else
133  {
134  return (a_data & !(1<<a_bitPosition));
135  }
136 }
137 
138 
139 //==============================================================================
152 //==============================================================================
153 inline bool cZero(const double& a_value)
154 {
155  return ((a_value < C_TINY) && (a_value > -C_TINY));
156 }
157 
158 
159 //==============================================================================
172 //==============================================================================
173 template<class T> inline T cAbs(const T& a_value)
174 {
175  return (a_value >= 0 ? a_value : -a_value);
176 }
177 
178 
179 //==============================================================================
191 //==============================================================================
192 template<class T> inline double cSign(const T& a_value)
193 {
194  if (a_value < 0)
195  {
196  return (-1);
197  }
198  else
199  {
200  return (1);
201  }
202 }
203 
204 
205 //==============================================================================
219 //==============================================================================
220 template<class T> inline T cMax(const T& a_value1,
221  const T& a_value2)
222 {
223  return (a_value1 >= a_value2 ? a_value1 : a_value2);
224 }
225 
226 
227 //==============================================================================
241 //==============================================================================
242 template<class T> inline T cMin(const T& a_value1,
243  const T& a_value2)
244 {
245  return (a_value1 <= a_value2 ? a_value1 : a_value2);
246 }
247 
248 
249 //==============================================================================
264 //==============================================================================
265 template<class T> inline T cMax3(const T& a_value1,
266  const T& a_value2,
267  const T& a_value3)
268 {
269  return (cMax(a_value1, cMax(a_value2, a_value3)));
270 }
271 
272 
273 //==============================================================================
288 //==============================================================================
289 template<class T> inline T cMin3(const T& a_value1,
290  const T& a_value2,
291  const T& a_value3)
292 {
293  return (cMin(a_value1, cMin(a_value2, a_value3)));
294 }
295 
296 
297 //==============================================================================
308 //==============================================================================
309 template<class T> inline void cSwap(T& a_value1,
310  T& a_value2)
311 {
312  T value = a_value1;
313  a_value1 = a_value2;
314  a_value2 = value;
315 }
316 
317 
318 //==============================================================================
337 //==============================================================================
338 template<class T> inline T cLerp(const double& a_level,
339  const T& a_value1,
340  const T& a_value2)
341 {
342  return (a_value2 * a_level + a_value1 * (1 - a_level));
343 }
344 
345 
346 //==============================================================================
361 //==============================================================================
362 template<class T> inline T cClamp(const T& a_value,
363  const T& a_low,
364  const T& a_high)
365 {
366  if (a_value < a_low) return a_low;
367  else if (a_value > a_high) return a_high;
368  else return a_value;
369 }
370 
371 
372 //==============================================================================
385 //==============================================================================
386 template<class T> inline T cClamp0(const T& a_value)
387 {
388  return cMax<T>(0, a_value);
389 }
390 
391 
392 //==============================================================================
405 //==============================================================================
406 inline double cClamp01(const double& a_value)
407 {
408  return (cClamp(a_value, 0.0, 1.0));
409 }
410 
411 
412 //==============================================================================
428 //==============================================================================
429 template<class T, class V> inline bool cContains(const T& a_value,
430  const V& a_low,
431  const V& a_high)
432 {
433  return ((a_value >= a_low) && (a_value <= a_high));
434 }
435 
436 
437 //==============================================================================
453 //==============================================================================
454 inline double cSqr(const double& a_value)
455 {
456  return(a_value*a_value);
457 }
458 
459 
460 //==============================================================================
473 //==============================================================================
474 inline double cSqrt(const double& a_value)
475 {
476  return(sqrt(a_value));
477 }
478 
479 
480 //==============================================================================
492 //==============================================================================
493 inline double cCbrt(const double& a_value)
494 {
495  return (pow(a_value, 1.0/3.0));
496 }
497 
498 
499 //==============================================================================
512 //==============================================================================
513 inline double cCosDeg(const double& a_angleDeg)
514 {
515  return (cos(a_angleDeg * C_DEG2RAD));
516 }
517 
518 
519 //==============================================================================
532 //==============================================================================
533 inline double cSinDeg(const double& a_angleDeg)
534 {
535  return (sin(a_angleDeg * C_DEG2RAD));
536 }
537 
538 
539 //==============================================================================
552 //==============================================================================
553 inline double cTanDeg(const double& a_angleDeg)
554 {
555  return (tan(a_angleDeg * C_DEG2RAD));
556 }
557 
558 
559 //==============================================================================
572 //==============================================================================
573 inline double cCosRad(const double& a_angleRad)
574 {
575  return (cos(a_angleRad));
576 }
577 
578 
579 //==============================================================================
592 //==============================================================================
593 inline double cSinRad(const double& a_angleRad)
594 {
595  return (sin(a_angleRad));
596 }
597 
598 
599 //==============================================================================
612 //==============================================================================
613 inline double cTanRad(const double& a_angleRad)
614 {
615  return (tan(a_angleRad));
616 }
617 
618 
619 //==============================================================================
632 //==============================================================================
633 inline double cDegToRad(const double& a_angleDeg)
634 {
635  return (a_angleDeg * C_DEG2RAD);
636 }
637 
638 
639 //==============================================================================
652 //==============================================================================
653 inline double cRadToDeg(const double& a_angleRad)
654 {
655  return (a_angleRad * C_RAD2DEG);
656 }
657 
658 
659 //==============================================================================
672 //==============================================================================
673 inline int cNumDigits(int a_value)
674 {
675  int digits = 0;
676 
677  if (a_value == 0) { return (1); }
678 
679  double value = (double)(abs(a_value));
680  while (value >= 1.0)
681  {
682  value /= 10;
683  digits++;
684  }
685  return (digits);
686 }
687 
688 
689 //==============================================================================
707 //==============================================================================
708 inline cVector3d cAdd(const cVector3d& a_vector1,
709  const cVector3d& a_vector2)
710 {
711  return cVector3d(
712  a_vector1(0)+a_vector2(0),
713  a_vector1(1)+a_vector2(1),
714  a_vector1(2)+a_vector2(2));
715 }
716 
717 
718 //==============================================================================
738 //==============================================================================
739 inline cVector3d cAdd(const cVector3d& a_vector1,
740  const cVector3d& a_vector2,
741  const cVector3d& a_vector3)
742 {
743  return cVector3d(
744  a_vector1(0) +a_vector2(0) +a_vector3(0) ,
745  a_vector1(1) +a_vector2(1) +a_vector3(1) ,
746  a_vector1(2) +a_vector2(2) +a_vector3(2) );
747 }
748 
749 
750 //==============================================================================
768 //==============================================================================
769 inline cVector3d cSub(const cVector3d& a_vector1,
770  const cVector3d& a_vector2)
771 {
772  return cVector3d(
773  a_vector1(0) -a_vector2(0) ,
774  a_vector1(1) -a_vector2(1) ,
775  a_vector1(2) -a_vector2(2) );
776 }
777 
778 
779 //==============================================================================
796 //==============================================================================
797 inline cVector3d cNegate(const cVector3d& a_vector)
798 {
799  return cVector3d(-a_vector(0),
800  -a_vector(1),
801  -a_vector(2));
802 }
803 
804 
805 //==============================================================================
823 //==============================================================================
824 inline cVector3d cMul(const double& a_value,
825  const cVector3d& a_vector)
826 {
827  return cVector3d(a_vector(0) *a_value,
828  a_vector(1) *a_value,
829  a_vector(2) *a_value);
830 }
831 
832 
833 //==============================================================================
851 //==============================================================================
852 inline cVector3d cDiv(const double& a_value,
853  const cVector3d& a_vector)
854 {
855  double factor = 1.0 / a_value;
856  return (cVector3d(factor * a_vector(0),
857  factor * a_vector(1),
858  factor * a_vector(2)));
859 }
860 
861 
862 //==============================================================================
880 //==============================================================================
881 inline cVector3d cCross(const cVector3d& a_vector1,
882  const cVector3d& a_vector2)
883 {
884  cVector3d result;
885  a_vector1.crossr(a_vector2, result);
886  return (result);
887 }
888 
889 
890 //==============================================================================
908 //==============================================================================
909 inline double cDot(const cVector3d& a_vector1,
910  const cVector3d& a_vector2)
911 {
912  return(a_vector1.dot(a_vector2));
913 }
914 
915 
916 //==============================================================================
929 //==============================================================================
930 inline cVector3d cNormalize(const cVector3d& a_vector)
931 {
932  cVector3d result;
933  a_vector.normalizer(result);
934  return (result);
935 }
936 
937 
938 //==============================================================================
952 //==============================================================================
953 inline double cDistance(const cVector3d& a_point1,
954  const cVector3d& a_point2)
955 {
956  return ( a_point1.distance(a_point2) );
957 }
958 
959 
960 //==============================================================================
974 //==============================================================================
975 inline double cDistanceSq(const cVector3d& a_point1,
976  const cVector3d& a_point2)
977 {
978  return ( a_point1.distancesq(a_point2) );
979 }
980 
981 
982 //==============================================================================
1005 //==============================================================================
1006 bool inline cEqualPoints(const cVector3d& a_point1,
1007  const cVector3d& a_point2,
1008  const double a_epsilon = C_SMALL)
1009 {
1010  // accelerated path for exact equality
1011  if (a_epsilon == 0.0)
1012  {
1013  if ((a_point1(0) == a_point2(0)) && (a_point1(1) == a_point2(1)) && (a_point1(2) == a_point2(2)))
1014  {
1015  return (true);
1016  }
1017  else
1018  {
1019  return (false);
1020  }
1021  }
1022 
1023  if ((fabs(a_point1(0) - a_point2(0)) < a_epsilon) &&
1024  (fabs(a_point1(1) - a_point2(1)) < a_epsilon) &&
1025  (fabs(a_point1(2) - a_point2(2)) < a_epsilon))
1026  {
1027  return (true);
1028  }
1029  else
1030  {
1031  return (false);
1032  }
1033 }
1034 
1035 
1036 //==============================================================================
1046 //==============================================================================
1048 {
1049  cMatrix3d result;
1050  result.identity();
1051  return (result);
1052 }
1053 
1054 
1055 //==============================================================================
1072 //==============================================================================
1073 inline cMatrix3d cAdd(const cMatrix3d& a_matrix1,
1074  const cMatrix3d& a_matrix2)
1075 {
1076  cMatrix3d result;
1077  a_matrix1.addr(a_matrix2, result);
1078  return (result);
1079 }
1080 
1081 
1082 //==============================================================================
1100 //==============================================================================
1101 inline cMatrix3d cSub(const cMatrix3d& a_matrix1,
1102  const cMatrix3d& a_matrix2)
1103 {
1104  cMatrix3d result;
1105  a_matrix1.subr(a_matrix2, result);
1106  return (result);
1107 }
1108 
1109 
1110 //==============================================================================
1137 //==============================================================================
1138 inline cMatrix3d cRotEulerRad(const double& a_angleRad1,
1139  const double& a_angleRad2,
1140  const double& a_angleRad3,
1141  const cEulerOrder a_eulerOrder,
1142  const bool a_useIntrinsicEulerModel = true)
1143 {
1144  // create matrix
1145  cMatrix3d rot;
1146  if (a_useIntrinsicEulerModel)
1147  rot.setIntrinsicEulerRotationRad(a_angleRad1, a_angleRad2, a_angleRad3, a_eulerOrder);
1148  else
1149  rot.setExtrinsicEulerRotationRad(a_angleRad1, a_angleRad2, a_angleRad3, a_eulerOrder);
1150 
1151  // return result
1152  return (rot);
1153 }
1154 
1155 
1156 //==============================================================================
1183 //==============================================================================
1184 inline cMatrix3d cRotEulerDeg(const double& a_angleDeg1,
1185  const double& a_angleDeg2,
1186  const double& a_angleDeg3,
1187  const cEulerOrder a_eulerOrder,
1188  const bool a_useIntrinsicEulerModel = true)
1189 {
1190  // create matrix
1191  cMatrix3d rot;
1192  if (a_useIntrinsicEulerModel)
1193  rot.setExtrinsicEulerRotationDeg(a_angleDeg1, a_angleDeg2, a_angleDeg3, a_eulerOrder);
1194  else
1195  rot.setExtrinsicEulerRotationDeg(a_angleDeg1, a_angleDeg2, a_angleDeg3, a_eulerOrder);
1196 
1197  // return result
1198  return (rot);
1199 }
1200 
1201 
1202 //==============================================================================
1220 //==============================================================================
1221 inline cMatrix3d cRotAxisAngleRad(const double& a_axisX,
1222  const double& a_axisY,
1223  const double& a_axisZ,
1224  const double& a_angleRad)
1225 {
1226  // create matrix
1227  cMatrix3d rot;
1228  rot.setAxisAngleRotationRad(a_axisX,
1229  a_axisY,
1230  a_axisZ,
1231  a_angleRad);
1232 
1233  // return result
1234  return (rot);
1235 }
1236 
1237 
1238 //==============================================================================
1256 //==============================================================================
1257 inline cMatrix3d cRotAxisAngleDeg(const double& a_axisX,
1258  const double& a_axisY,
1259  const double& a_axisZ,
1260  const double& a_angleDeg)
1261 {
1262  // create matrix
1263  cMatrix3d rot;
1264  rot.setAxisAngleRotationDeg(a_axisX,
1265  a_axisY,
1266  a_axisZ,
1267  a_angleDeg);
1268 
1269  // return result
1270  return (rot);
1271 }
1272 
1273 
1274 //==============================================================================
1292 //==============================================================================
1293 inline cMatrix3d cMul(const cMatrix3d& a_matrix1,
1294  const cMatrix3d& a_matrix2)
1295 {
1296  cMatrix3d result;
1297  a_matrix1.mulr(a_matrix2, result);
1298  return (result);
1299 }
1300 
1301 
1302 //==============================================================================
1317 //==============================================================================
1318 inline cVector3d cMul(const cMatrix3d& a_matrix,
1319  const cVector3d& a_vector)
1320 {
1321  cVector3d result;
1322  a_matrix.mulr(a_vector, result);
1323  return(result);
1324 }
1325 
1326 
1327 //==============================================================================
1340 //==============================================================================
1341 inline cMatrix3d cTranspose(const cMatrix3d& a_matrix)
1342 {
1343  cMatrix3d result;
1344  a_matrix.transr(result);
1345  return(result);
1346 }
1347 
1348 
1349 //==============================================================================
1362 //==============================================================================
1363 inline cMatrix3d cInverse(const cMatrix3d& a_matrix)
1364 {
1365  cMatrix3d result;
1366  a_matrix.invertr(result);
1367  return(result);
1368 }
1369 
1370 
1371 //==============================================================================
1385 //==============================================================================
1386 inline double cAngle(const cVector3d& a_vector1,
1387  const cVector3d& a_vector2)
1388 {
1389  // compute length of vectors
1390  double n1 = a_vector1.length();
1391  double n2 = a_vector2.length();
1392  double val = n1 * n2;
1393 
1394  // check if lengths of vectors are not zero
1395  if (fabs(val) < C_SMALL)
1396  {
1397  return (0.0);
1398  }
1399 
1400  // compute angle
1401  double result = a_vector1.dot(a_vector2)/(val);
1402  if (result > 1.0) { result = 1.0; }
1403  else if (result < -1.0) { result = -1.0; }
1404 
1405  return(acos(result));
1406 }
1407 
1408 
1409 //==============================================================================
1423 //==============================================================================
1424 inline double cCosAngle(const cVector3d& a_vector1,
1425  const cVector3d& a_vector2)
1426 {
1427  // compute length of vectors
1428  double n1 = a_vector1.length();
1429  double n2 = a_vector2.length();
1430  double val = n1 * n2;
1431 
1432  // check if lengths of vectors are not zero
1433  if (fabs(val) < C_SMALL)
1434  {
1435  return (0.0);
1436  }
1437 
1438  // compute angle
1439  return(a_vector1.dot(a_vector2)/(val));
1440 }
1441 
1443 
1444 //------------------------------------------------------------------------------
1445 } // namespace chai3d
1446 //------------------------------------------------------------------------------
1447 
1448 //------------------------------------------------------------------------------
1449 #endif // CMathsH
1450 //------------------------------------------------------------------------------
This class implements a 3D vector.
Definition: CVector3d.h:88
double cRadToDeg(const double &a_angleRad)
This function converts an angle from radians to degrees.
Definition: CMaths.h:653
void setExtrinsicEulerRotationDeg(const double &a_angle1, const double &a_angle2, const double &a_angle3, const cEulerOrder a_eulerOrder)
This method builds a rotation matrix from an Euler angle representation.
Definition: CMatrix3d.h:1411
bool setAxisAngleRotationRad(const cVector3d &a_axis, const double &a_angleRad)
This method builds a rotation matrix from an axis-angle representation.
Definition: CMatrix3d.h:1211
const double C_SMALL
Small value near zero.
Definition: CConstants.h:103
double cCosDeg(const double &a_angleDeg)
Compute the cosine of an angle defined in degrees.
Definition: CMaths.h:513
bool cEqualPoints(const cVector3d &a_point1, const cVector3d &a_point2, const double a_epsilon=C_SMALL)
This function determines whether two vectors are equal (i.e. represent the same point).
Definition: CMaths.h:1006
bool setAxisAngleRotationDeg(const cVector3d &a_axis, const double &a_angleDeg)
This method builds a rotation matrix from an axis-angle representation.
Definition: CMatrix3d.h:1260
void mulr(const cMatrix3d &a_matrix, cMatrix3d &a_result) const
This function computes the multiplication of this matrix with another.
Definition: CMatrix3d.h:922
T cLerp(const double &a_level, const T &a_value1, const T &a_value2)
This function computes a linear interpolation between two values.
Definition: CMaths.h:338
double distance(const cVector3d &a_vector) const
This method computes the distance between two points.
Definition: CVector3d.h:1146
double cDistance(const cVector3d &a_point1, const cVector3d &a_point2)
This function computes the Euclidean distance between two points.
Definition: CMaths.h:953
const double C_RAD2DEG
Conversion from radians to degrees.
Definition: CConstants.h:97
double distancesq(const cVector3d &a_vector) const
This method computes the squared value distance between two points.
Definition: CVector3d.h:1172
cMatrix3d cRotAxisAngleRad(const double &a_axisX, const double &a_axisY, const double &a_axisZ, const double &a_angleRad)
This function builds a rotation matrix from an axis-angle representation.
Definition: CMaths.h:1221
int cNumDigits(int a_value)
This function computes the number of digits that compose a given integer.
Definition: CMaths.h:673
void crossr(const cVector3d &a_vector, cVector3d &a_result) const
This method computes the cross product.
Definition: CVector3d.h:975
double cCosAngle(const cVector3d &a_vector1, const cVector3d &a_vector2)
This function computes the cosine of the angle between two vectors.
Definition: CMaths.h:1424
cVector3d cAdd(const cVector3d &a_vector1, const cVector3d &a_vector2)
This function computes the addition of two vectors.
Definition: CMaths.h:708
double cTanRad(const double &a_angleRad)
This function computes the tangent of an angle defined in radians.
Definition: CMaths.h:613
cMatrix3d cInverse(const cMatrix3d &a_matrix)
This function computes the inverse of a matrix.
Definition: CMaths.h:1363
double cCosRad(const double &a_angleRad)
This function computes the cosine of an angle defined in radians.
Definition: CMaths.h:573
unsigned int cSetBit(const unsigned int &a_data, const unsigned int &a_bitPosition, const bool a_value)
This function sets the value of a specified bit of an unsigned integer.
Definition: CMaths.h:126
void normalizer(cVector3d &a_result) const
This method normalizes this vector to length 1.
Definition: CVector3d.h:1086
double length() const
This method computes the Euclidean norm of this vector.
Definition: CVector3d.h:1015
cVector3d cSub(const cVector3d &a_vector1, const cVector3d &a_vector2)
This function computes the subtraction of two vectors.
Definition: CMaths.h:769
double cSinRad(const double &a_angleRad)
This function computes the sine of an angle defined in radians.
Definition: CMaths.h:593
cMatrix3d cRotAxisAngleDeg(const double &a_axisX, const double &a_axisY, const double &a_axisZ, const double &a_angleDeg)
This function builds a rotation matrix from an axis-angle representation.
Definition: CMaths.h:1257
double cCbrt(const double &a_value)
This function computes the cubic root of a scalar.
Definition: CMaths.h:493
double cDegToRad(const double &a_angleDeg)
This function converts an angle from degrees to radians.
Definition: CMaths.h:633
double cDistanceSq(const cVector3d &a_point1, const cVector3d &a_point2)
This function computes the squared distance between two points.
Definition: CMaths.h:975
cVector3d cDiv(const double &a_value, const cVector3d &a_vector)
This function computes the division of a vector by a scalar.
Definition: CMaths.h:852
const double C_DEG2RAD
Conversion from degrees to radians.
Definition: CConstants.h:94
T cMin3(const T &a_value1, const T &a_value2, const T &a_value3)
This function computes the minimum value between three values.
Definition: CMaths.h:289
This class implements a 3D matrix.
Definition: CMatrix3d.h:97
double cTanDeg(const double &a_angleDeg)
This function computes the tangent of an angle defined in degrees.
Definition: CMaths.h:553
cMatrix3d cRotEulerRad(const double &a_angleRad1, const double &a_angleRad2, const double &a_angleRad3, const cEulerOrder a_eulerOrder, const bool a_useIntrinsicEulerModel=true)
This function builds a rotation matrix from a set of Euler angles defined in radians.
Definition: CMaths.h:1138
cVector3d cMul(const double &a_value, const cVector3d &a_vector)
This function computes the multiplication of a vector by a scalar.
Definition: CMaths.h:824
double cDot(const cVector3d &a_vector1, const cVector3d &a_vector2)
This function computes the dot product between two vectors.
Definition: CMaths.h:909
Implements a transformation matrix.
const double C_TINY
Smallest value near zero for a double.
Definition: CConstants.h:100
void cSwap(T &a_value1, T &a_value2)
This function swaps two elements.
Definition: CMaths.h:309
cMatrix3d cIdentity3d(void)
This function return a 3x3 identity matrix.
Definition: CMaths.h:1047
cVector3d cNormalize(const cVector3d &a_vector)
This function computes the normalized vector.
Definition: CMaths.h:930
T cMax3(const T &a_value1, const T &a_value2, const T &a_value3)
This function computes the maximum value between three values.
Definition: CMaths.h:265
cMatrix3d cRotEulerDeg(const double &a_angleDeg1, const double &a_angleDeg2, const double &a_angleDeg3, const cEulerOrder a_eulerOrder, const bool a_useIntrinsicEulerModel=true)
This function builds a rotation matrix from a set of Euler angles defined in degrees.
Definition: CMaths.h:1184
double cSign(const T &a_value)
This function computes the sign of a value.
Definition: CMaths.h:192
cEulerOrder
Definition: CMatrix3d.h:57
double cSqr(const double &a_value)
This function computes the square of a scalar.
Definition: CMaths.h:454
T cAbs(const T &a_value)
This function computes an absolute value.
Definition: CMaths.h:173
bool cCheckBit(const unsigned int &a_value, const unsigned int &a_bitPosition)
This function checks if a given bit is enabled.
Definition: CMaths.h:92
bool cContains(const T &a_value, const V &a_low, const V &a_high)
This function checks whether a value is within a specified range.
Definition: CMaths.h:429
void setExtrinsicEulerRotationRad(const double &a_angle1, const double &a_angle2, const double &a_angle3, const cEulerOrder a_eulerOrder)
This method builds a rotation matrix from an Euler angle representation.
Definition: CMatrix3d.h:1337
T cClamp0(const T &a_value)
This function clamps a value to a value ranged between 0 and infinity.
Definition: CMaths.h:386
double cSinDeg(const double &a_angleDeg)
This function computes the sine of an angle defined in degrees.
Definition: CMaths.h:533
cMatrix3d cTranspose(const cMatrix3d &a_matrix)
This function computes the transpose of a matrix.
Definition: CMaths.h:1341
T cMin(const T &a_value1, const T &a_value2)
This function computes the minimum value between two values.
Definition: CMaths.h:242
bool invertr(cMatrix3d &a_result) const
This method computes the inverse of this matrix.
Definition: CMatrix3d.h:1132
cVector3d cNegate(const cVector3d &a_vector)
This function computes the negated vector.
Definition: CMaths.h:797
T cClamp(const T &a_value, const T &a_low, const T &a_high)
This function clamps a value to a specified range.
Definition: CMaths.h:362
double cClamp01(const double &a_value)
This function clamps a value to a value ranged between 0.0 and 1.0.
Definition: CMaths.h:406
cVector3d cCross(const cVector3d &a_vector1, const cVector3d &a_vector2)
This function computes the cross product between two vectors.
Definition: CMaths.h:881
double dot(const cVector3d &a_vector) const
This method computes the dot product between this vector and another.
Definition: CVector3d.h:998
Definition: CAudioBuffer.cpp:56
void identity()
This method builds an identity matrix.
Definition: CMatrix3d.h:325
double cAngle(const cVector3d &a_vector1, const cVector3d &a_vector2)
This function computes the angle in radians between two vectors.
Definition: CMaths.h:1386
bool cZero(const double &a_value)
This function checks if a value is equal to or almost near zero.
Definition: CMaths.h:153
void setIntrinsicEulerRotationRad(const double &a_angle1, const double &a_angle2, const double &a_angle3, const cEulerOrder a_eulerOrder)
This method builds a rotation matrix from an Euler angle representation.
Definition: CMatrix3d.h:1439
void subr(const cMatrix3d &a_matrix, cMatrix3d &a_result) const
This method computes the subtraction of this matrix with another.
Definition: CMatrix3d.h:850
void addr(const cMatrix3d &a_matrix, cMatrix3d &a_result) const
This method computes the addition of this matrix with another.
Definition: CMatrix3d.h:785
double cSqrt(const double &a_value)
This function computes the square root of a scalar.
Definition: CMaths.h:474
T cMax(const T &a_value1, const T &a_value2)
This function computes the maximum value between two values.
Definition: CMaths.h:220
void transr(cMatrix3d &a_result) const
This method computes the transpose of this matrix.
Definition: CMatrix3d.h:1049