Main Page   Class Hierarchy   Alphabetical List   Data Structures   File List   Data Fields   Globals  

posemath.cc File Reference

#include "posemath.h"

Include dependency graph for posemath.cc:

Include dependency graph

Go to the source code of this file.

Functions

double dot (PM_CARTESIAN v1, PM_CARTESIAN v2)
PM_CARTESIAN cross (PM_CARTESIAN v1, PM_CARTESIAN v2)
PM_CARTESIAN unit (PM_CARTESIAN v)
PM_QUATERNION norm (PM_QUATERNION q)
PM_ROTATION_VECTOR norm (PM_ROTATION_VECTOR r)
PM_ROTATION_MATRIX norm (PM_ROTATION_MATRIX m)
int isNorm (PM_CARTESIAN v)
int isNorm (PM_QUATERNION q)
int isNorm (PM_ROTATION_VECTOR r)
int isNorm (PM_ROTATION_MATRIX m)
double mag (PM_CARTESIAN v)
double disp (PM_CARTESIAN v1, PM_CARTESIAN v2)
PM_CARTESIAN inv (PM_CARTESIAN v)
PM_ROTATION_MATRIX inv (PM_ROTATION_MATRIX m)
PM_QUATERNION inv (PM_QUATERNION q)
PM_POSE inv (PM_POSE p)
PM_HOMOGENEOUS inv (PM_HOMOGENEOUS h)
PM_CARTESIAN proj (PM_CARTESIAN v1, PM_CARTESIAN v2)
PM_CARTESIAN operator+ (PM_CARTESIAN v)
PM_CARTESIAN operator- (PM_CARTESIAN v)
PM_QUATERNION operator+ (PM_QUATERNION q)
PM_QUATERNION operator- (PM_QUATERNION q)
PM_POSE operator+ (PM_POSE p)
PM_POSE operator- (PM_POSE p)
int operator== (PM_CARTESIAN v1, PM_CARTESIAN v2)
int operator== (PM_QUATERNION q1, PM_QUATERNION q2)
int operator== (PM_POSE p1, PM_POSE p2)
int operator!= (PM_CARTESIAN v1, PM_CARTESIAN v2)
int operator!= (PM_QUATERNION q1, PM_QUATERNION q2)
int operator!= (PM_POSE p1, PM_POSE p2)
PM_CARTESIAN operator+ (PM_CARTESIAN v1, PM_CARTESIAN v2)
PM_CARTESIAN operator- (PM_CARTESIAN v1, PM_CARTESIAN v2)
PM_CARTESIAN operator * (PM_CARTESIAN v, double s)
PM_CARTESIAN operator * (double s, PM_CARTESIAN v)
PM_CARTESIAN operator/ (PM_CARTESIAN v, double s)
PM_QUATERNION operator * (double s, PM_QUATERNION q)
PM_QUATERNION operator * (PM_QUATERNION q, double s)
PM_QUATERNION operator/ (PM_QUATERNION q, double s)
PM_CARTESIAN operator * (PM_QUATERNION q, PM_CARTESIAN v)
PM_QUATERNION operator * (PM_QUATERNION q1, PM_QUATERNION q2)
PM_ROTATION_MATRIX operator * (PM_ROTATION_MATRIX m1, PM_ROTATION_MATRIX m2)
PM_POSE operator * (PM_POSE p1, PM_POSE p2)
PM_CARTESIAN operator * (PM_POSE p, PM_CARTESIAN v)

Variables

double noElement = 0.0
PM_CARTESIAN * noCart = 0

Function Documentation

double dot (  PM_CARTESIAN    v1,
PM_CARTESIAN    v2
) 
 

Definition at line 957 of file posemath.cc.

Referenced by testCart(), and testCyl(). 

00958 {
00959   double d;
00960   PmCartesian _v1, _v2;
00961 
00962   toCart(v1, &_v1);
00963   toCart(v2, &_v2);
00964 
00965   pmCartCartDot(_v1, _v2, &d);
00966 
00967   return d;
00968 }

PM_CARTESIAN cross (  PM_CARTESIAN    v1,
PM_CARTESIAN    v2
) 
 

Definition at line 972 of file posemath.cc.

Referenced by testCart(), and testCyl(). 

00973 {
00974   PM_CARTESIAN ret;
00975   PmCartesian _v1, _v2;
00976 
00977   toCart(v1, &_v1);
00978   toCart(v2, &_v2);
00979 
00980   pmCartCartCross(_v1, _v2, &_v1);
00981 
00982   toCart(_v1, &ret);
00983 
00984   return ret;
00985 }

PM_CARTESIAN unit (  PM_CARTESIAN    v ) 
 

Definition at line 990 of file posemath.cc.

Referenced by testCart(). 

00991 {
00992   PM_CARTESIAN vout;
00993   PmCartesian _v;
00994 
00995   toCart(v, &_v);
00996 
00997   pmCartUnit(_v, &_v);
00998 
00999   toCart(_v, &vout);
01000 
01001   return vout;
01002 }

PM_QUATERNION norm (  PM_QUATERNION    q ) 
 

Definition at line 1023 of file posemath.cc.

01024 {
01025   PM_QUATERNION qout;
01026   PmQuaternion _q;
01027 
01028   toQuat(q, &_q);
01029   pmQuatNorm(_q, &_q);
01030 
01031   toQuat(_q, &qout);
01032 
01033   return qout;
01034 }

PM_ROTATION_VECTOR norm (  PM_ROTATION_VECTOR    r ) 
 

Definition at line 1036 of file posemath.cc.

01037 {
01038   PM_ROTATION_VECTOR rout;
01039   PmRotationVector _r;
01040 
01041   toRot(r, &_r);
01042 
01043   pmRotNorm(_r, &_r);
01044 
01045   toRot(_r, &rout);
01046 
01047   return rout;
01048 }

PM_ROTATION_MATRIX norm (  PM_ROTATION_MATRIX    m ) 
 

Definition at line 1050 of file posemath.cc.

Referenced by testPrint(), and testQuat(). 

01051 {
01052   PM_ROTATION_MATRIX mout;
01053   PmRotationMatrix _m;
01054 
01055   toMat(m, &_m);
01056 
01057   pmMatNorm(_m, &_m);
01058 
01059   toMat(_m, &mout);
01060 
01061   return mout;
01062 }

int isNorm (  PM_CARTESIAN    v ) 
 

Definition at line 1066 of file posemath.cc.

01067 {
01068   PmCartesian _v;
01069 
01070   toCart(v, &_v);
01071 
01072   return pmCartIsNorm(_v);
01073 }

int isNorm (  PM_QUATERNION    q ) 
 

Definition at line 1075 of file posemath.cc.

01076 {
01077   PmQuaternion _q;
01078 
01079   toQuat(q, &_q);
01080 
01081   return pmQuatIsNorm(_q);
01082 }

int isNorm (  PM_ROTATION_VECTOR    r ) 
 

Definition at line 1084 of file posemath.cc.

01085 {
01086   PmRotationVector _r;
01087 
01088   toRot(r, &_r);
01089 
01090   return pmRotIsNorm(_r);
01091 }

int isNorm (  PM_ROTATION_MATRIX    m ) 
 

Definition at line 1093 of file posemath.cc.

Referenced by testQuat(). 

01094 {
01095   PmRotationMatrix _m;
01096 
01097   toMat(m, &_m);
01098 
01099   return pmMatIsNorm(_m);
01100 }

double mag (  PM_CARTESIAN    v ) 
 

Definition at line 1104 of file posemath.cc.

Referenced by testCart(), and testCyl(). 

01105 {
01106   double ret;
01107   PmCartesian _v;
01108 
01109   toCart(v, &_v);
01110 
01111   pmCartMag(_v, &ret);
01112 
01113   return ret;
01114 }

double disp (  PM_CARTESIAN    v1,
PM_CARTESIAN    v2
) 
 

Definition at line 1118 of file posemath.cc.

Referenced by testCart(). 

01119 {
01120   double ret;
01121   PmCartesian _v1, _v2;
01122 
01123   toCart(v1, &_v1);
01124   toCart(v2, &_v2);
01125 
01126   pmCartCartDisp(_v1, _v2, &ret);
01127 
01128   return ret;
01129 }

PM_CARTESIAN inv (  PM_CARTESIAN    v ) 
 

Definition at line 1133 of file posemath.cc.

01134 {
01135   PM_CARTESIAN ret;
01136   PmCartesian _v;
01137 
01138   toCart(v, &_v);
01139 
01140   pmCartInv(_v, &_v);
01141 
01142   toCart(_v, &ret);
01143 
01144   return ret;
01145 }

PM_ROTATION_MATRIX inv (  PM_ROTATION_MATRIX    m ) 
 

Definition at line 1147 of file posemath.cc.

01148 {
01149   PM_ROTATION_MATRIX ret;
01150   PmRotationMatrix _m;
01151 
01152   toMat(m, &_m);
01153 
01154   pmMatInv(_m, &_m);
01155 
01156   toMat(_m, &ret);
01157 
01158   return ret;
01159 }

PM_QUATERNION inv (  PM_QUATERNION    q ) 
 

Definition at line 1161 of file posemath.cc.

01162 {
01163   PM_QUATERNION ret;
01164   PmQuaternion _q;
01165 
01166   toQuat(q, &_q);
01167 
01168   pmQuatInv(_q, &_q);
01169 
01170   toQuat(_q, &ret);
01171 
01172   return ret;
01173 }

PM_POSE inv (  PM_POSE    p ) 
 

Definition at line 1175 of file posemath.cc.

01176 {
01177   PM_POSE ret;
01178   PmPose _p;
01179 
01180   toPose(p, &_p);
01181 
01182   pmPoseInv(_p, &_p);
01183 
01184   toPose(_p, &ret);
01185 
01186   return ret;
01187 }

PM_HOMOGENEOUS inv (  PM_HOMOGENEOUS    h ) 
 

Definition at line 1189 of file posemath.cc.

Referenced by testCart(), testCyl(), and testQuat(). 

01190 {
01191   PM_HOMOGENEOUS ret;
01192   PmHomogeneous _h;
01193 
01194   toHom(h, &_h);
01195 
01196   pmHomInv(_h, &_h);
01197 
01198   toHom(_h, &ret);
01199 
01200   return ret;
01201 }

PM_CARTESIAN proj (  PM_CARTESIAN    v1,
PM_CARTESIAN    v2
) 
 

Definition at line 1205 of file posemath.cc.

01206 {
01207   PM_CARTESIAN ret;
01208   PmCartesian _v1, _v2;
01209 
01210   toCart(v1, &_v1);
01211   toCart(v2, &_v2);
01212 
01213   pmCartCartProj(_v1, _v2, &_v1);
01214 
01215   toCart(_v1, &ret);
01216 
01217   return ret;
01218 }

PM_CARTESIAN operator+ (  PM_CARTESIAN    v ) 
 

Definition at line 1222 of file posemath.cc.

01223 {
01224   return v;
01225 }

PM_CARTESIAN operator- (  PM_CARTESIAN    v ) 
 

Definition at line 1227 of file posemath.cc.

01228 {
01229   PM_CARTESIAN ret;
01230 
01231   ret.x = -v.x;
01232   ret.y = -v.y;
01233   ret.z = -v.z;
01234 
01235   return ret;
01236 }

PM_QUATERNION operator+ (  PM_QUATERNION    q ) 
 

Definition at line 1238 of file posemath.cc.

01239 {
01240   return q;
01241 }

PM_QUATERNION operator- (  PM_QUATERNION    q ) 
 

Definition at line 1243 of file posemath.cc.

01244 {
01245   PM_QUATERNION ret;
01246   PmQuaternion _q;
01247 
01248   toQuat(q, &_q);
01249 
01250   pmQuatInv(_q, &_q);
01251 
01252   toQuat(_q, &ret);
01253 
01254   return ret;
01255 }

PM_POSE operator+ (  PM_POSE    p ) 
 

Definition at line 1257 of file posemath.cc.

01258 {
01259   return p;
01260 }

PM_POSE operator- (  PM_POSE    p ) 
 

Definition at line 1262 of file posemath.cc.

01263 {
01264   PM_POSE ret;
01265   PmPose _p;
01266 
01267   toPose(p, &_p);
01268 
01269   pmPoseInv(_p, &_p);
01270 
01271   toPose(_p, &ret);
01272 
01273   return ret;
01274 }

int operator== (  PM_CARTESIAN    v1,
PM_CARTESIAN    v2
) 
 

Definition at line 1276 of file posemath.cc.

01277 {
01278   PmCartesian _v1, _v2;
01279 
01280   toCart(v1, &_v1);
01281   toCart(v2, &_v2);
01282 
01283   return pmCartCartCompare(_v1, _v2);
01284 }

int operator== (  PM_QUATERNION    q1,
PM_QUATERNION    q2
) 
 

Definition at line 1286 of file posemath.cc.

01287 {
01288   PmQuaternion _q1, _q2;
01289 
01290   toQuat(q1, &_q1);
01291   toQuat(q2, &_q2);
01292 
01293   return pmQuatQuatCompare(_q1, _q2);
01294 }

int operator== (  PM_POSE    p1,
PM_POSE    p2
) 
 

Definition at line 1296 of file posemath.cc.

01297 {
01298   PmPose _p1, _p2;
01299 
01300   toPose(p1, &_p1);
01301   toPose(p2, &_p2);
01302 
01303   return pmPosePoseCompare(_p1, _p2);
01304 }

int operator!= (  PM_CARTESIAN    v1,
PM_CARTESIAN    v2
) 
 

Definition at line 1306 of file posemath.cc.

01307 {
01308   PmCartesian _v1, _v2;
01309 
01310   toCart(v1, &_v1);
01311   toCart(v2, &_v2);
01312 
01313   return ! pmCartCartCompare(_v1, _v2);
01314 }

int operator!= (  PM_QUATERNION    q1,
PM_QUATERNION    q2
) 
 

Definition at line 1316 of file posemath.cc.

01317 {
01318   PmQuaternion _q1, _q2;
01319 
01320   toQuat(q1, &_q1);
01321   toQuat(q2, &_q2);
01322 
01323   return ! pmQuatQuatCompare(_q1, _q2);
01324 }

int operator!= (  PM_POSE    p1,
PM_POSE    p2
) 
 

Definition at line 1326 of file posemath.cc.

01327 {
01328   PmPose _p1, _p2;
01329 
01330   toPose(p1, &_p1);
01331   toPose(p2, &_p2);
01332 
01333   return ! pmPosePoseCompare(_p1, _p2);
01334 }

PM_CARTESIAN operator+ (  PM_CARTESIAN    v1,
PM_CARTESIAN    v2
) 
 

Definition at line 1336 of file posemath.cc.

01337 {
01338   PM_CARTESIAN ret;
01339 
01340   ret.x = v1.x + v2.x;
01341   ret.y = v1.y + v2.y;
01342   ret.z = v1.z + v2.z;
01343 
01344   return ret;
01345 }

PM_CARTESIAN operator- (  PM_CARTESIAN    v1,
PM_CARTESIAN    v2
) 
 

Definition at line 1347 of file posemath.cc.

01348 {
01349   PM_CARTESIAN ret;
01350 
01351   ret.x = v1.x - v2.x;
01352   ret.y = v1.y - v2.y;
01353   ret.z = v1.z - v2.z;
01354 
01355   return ret;
01356 }

PM_CARTESIAN operator * (  PM_CARTESIAN    v,
double    s
) 
 

Definition at line 1358 of file posemath.cc.

01359 {
01360   PM_CARTESIAN ret;
01361 
01362   ret.x = v.x * s;
01363   ret.y = v.y * s;
01364   ret.z = v.z * s;
01365 
01366   return ret;
01367 }

PM_CARTESIAN operator * (  double    s,
PM_CARTESIAN    v
) 
 

Definition at line 1369 of file posemath.cc.

01370 {
01371   PM_CARTESIAN ret;
01372 
01373   ret.x = v.x * s;
01374   ret.y = v.y * s;
01375   ret.z = v.z * s;
01376 
01377   return ret;
01378 }

PM_CARTESIAN operator/ (  PM_CARTESIAN    v,
double    s
) 
 

Definition at line 1380 of file posemath.cc.

01381 {
01382   PM_CARTESIAN ret;
01383 
01384 #ifdef PM_DEBUG
01385   if (s == 0.0)
01386   {
01387 #ifdef PM_PRINT_ERROR
01388     pmPrintError("PM_CARTESIAN::operator / : divide by 0\n");
01389 #endif
01390     pmErrno = PM_DIV_ERR;
01391     return ret;
01392   }
01393 #endif
01394 
01395   ret.x = v.x / s;
01396   ret.y = v.y / s;
01397   ret.z = v.z / s;
01398 
01399   return ret;
01400 }

PM_QUATERNION operator * (  double    s,
PM_QUATERNION    q
) 
 

Definition at line 1402 of file posemath.cc.

01403 {
01404   PM_QUATERNION qout;
01405   PmQuaternion _q;
01406 
01407   toQuat(q, &_q);
01408 
01409   pmQuatScalMult(_q, s, &_q);
01410 
01411   toQuat(_q, &qout);
01412 
01413   return qout;
01414 }

PM_QUATERNION operator * (  PM_QUATERNION    q,
double    s
) 
 

Definition at line 1416 of file posemath.cc.

01417 {
01418   PM_QUATERNION qout;
01419   PmQuaternion _q;
01420 
01421   toQuat(q, &_q);
01422 
01423   pmQuatScalMult(_q, s, &_q);
01424 
01425   toQuat(_q, &qout);
01426 
01427   return qout;
01428 }

PM_QUATERNION operator/ (  PM_QUATERNION    q,
double    s
) 
 

Definition at line 1430 of file posemath.cc.

01431 {
01432   PM_QUATERNION qout;
01433   PmQuaternion _q;
01434 
01435   toQuat(q, &_q);
01436 
01437 #ifdef PM_DEBUG
01438   if (s == 0.0)
01439   {
01440 #ifdef PM_PRINT_ERROR
01441     pmPrintError("Divide by 0 in operator /\n");
01442 #endif
01443     pmErrno = PM_NORM_ERR;
01444 
01445 #if 0
01446  // g++/gcc versions 2.8.x and 2.9.x
01447   // will complain that the call to PM_QUATERNION(PM_QUATERNION) is
01448   // ambigous. (2.7.x and some others allow it)
01449   return qout = PM_QUATERNION((double) 0, (double)0, (double)0, (double)0);
01450 #else
01451 
01452   PmQuaternion quat;
01453 
01454   quat.s = 0;
01455   quat.x = 0;
01456   quat.y = 0;
01457   quat.z = 0;
01458 
01459   pmQuatNorm(quat, &quat);
01460 
01461   qout.s = quat.s;
01462   qout.x = quat.x;
01463   qout.y = quat.y;
01464   qout.z = quat.z;
01465   return qout;
01466 #endif
01467 
01468   }
01469 #endif
01470 
01471   pmQuatScalMult(_q, 1.0 / s, &_q);
01472   toQuat(_q, &qout);
01473 
01474   pmErrno = 0;
01475   return qout;
01476 }

PM_CARTESIAN operator * (  PM_QUATERNION    q,
PM_CARTESIAN    v
) 
 

Definition at line 1478 of file posemath.cc.

01479 {
01480   PM_CARTESIAN vout;
01481   PmQuaternion _q;
01482   PmCartesian _v;
01483 
01484   toQuat(q, &_q);
01485   toCart(v, &_v);
01486 
01487   pmQuatCartMult(_q, _v, &_v);
01488 
01489   toCart(_v, &vout);
01490 
01491   return vout;
01492 }

PM_QUATERNION operator * (  PM_QUATERNION    q1,
PM_QUATERNION    q2
) 
 

Definition at line 1494 of file posemath.cc.

01495 {
01496   PM_QUATERNION ret;
01497   PmQuaternion _q1, _q2;
01498 
01499   toQuat(q1, &_q1);
01500   toQuat(q2, &_q2);
01501 
01502   pmQuatQuatMult(_q1, _q2, &_q1);
01503 
01504   toQuat(_q1, &ret);
01505 
01506   return ret;
01507 }

PM_ROTATION_MATRIX operator * (  PM_ROTATION_MATRIX    m1,
PM_ROTATION_MATRIX    m2
) 
 

Definition at line 1509 of file posemath.cc.

01510 {
01511   PM_ROTATION_MATRIX ret;
01512   PmRotationMatrix _m1, _m2;
01513 
01514   toMat(m1, &_m1);
01515   toMat(m2, &_m2);
01516 
01517   pmMatMatMult(_m1, _m2, &_m1);
01518 
01519   toMat(_m1, &ret);
01520 
01521   return ret;
01522 }

PM_POSE operator * (  PM_POSE    p1,
PM_POSE    p2
) 
 

Definition at line 1524 of file posemath.cc.

01525 {
01526   PM_POSE ret;
01527   PmPose _p1, _p2;
01528 
01529   toPose(p1, &_p1);
01530   toPose(p2, &_p2);
01531 
01532   pmPosePoseMult(_p1, _p2, &_p1);
01533 
01534   toPose(_p1, &ret);
01535 
01536   return ret;
01537 }

PM_CARTESIAN operator * (  PM_POSE    p,
PM_CARTESIAN    v
) 
 

Definition at line 1539 of file posemath.cc.

01540 {
01541   PM_CARTESIAN ret;
01542   PmPose _p;
01543   PmCartesian _v;
01544 
01545   toPose(p, &_p);
01546   toCart(v, &_v);
01547 
01548   pmPoseCartMult(_p, _v, &_v);
01549 
01550   toCart(_v, &ret);
01551 
01552   return ret;
01553 }

Variable Documentation

double noElement = 0.0 [static]
 

Definition at line 30 of file posemath.cc.

PM_CARTESIAN* noCart = 0 [static]
 

Definition at line 31 of file posemath.cc.

Generated on Sun Dec 2 15:57:29 2001 for rcslib by doxygen1.2.11.1 written by Dimitri van Heesch, © 1997-2001