Uses of Class
rcs.posemath.PmException

Packages that use PmException
rcs.posemath   
 

Uses of PmException in rcs.posemath
 

Methods in rcs.posemath that throw PmException
static PM_CARTESIAN Posemath.cross(PM_CARTESIAN v1, PM_CARTESIAN v2)
           
static PM_CYLINDRICAL Posemath.cross(PM_CYLINDRICAL v1, PM_CYLINDRICAL v2)
           
static double Posemath.disp(PM_CARTESIAN v1, PM_CARTESIAN v2)
           
static PM_CARTESIAN Posemath.divide(PM_CARTESIAN v, double d)
           
static PM_CYLINDRICAL Posemath.divide(PM_CYLINDRICAL c, double d)
           
static PM_QUATERNION Posemath.divide(PM_QUATERNION q, double s)
           
static PM_ROTATION_VECTOR Posemath.divide(PM_ROTATION_VECTOR r, double s)
           
static double Posemath.dot(PM_CYLINDRICAL v1, PM_CYLINDRICAL v2)
           
 boolean PmCartesian.equals(PmCartesian v)
           
 boolean PmCylindrical.equals(PmCartesian v)
           
 boolean PmCartesian.equals(PmCylindrical c)
           
 boolean PmCylindrical.equals(PmCylindrical c)
           
 boolean PmPose.equals(PmHomogeneous h)
           
 boolean PmPose.equals(PmPose p)
           
 boolean PmQuaternion.equals(PmQuaternion pq)
           
 boolean PmQuaternion.equals(PmRotationMatrix prm)
           
 boolean PmQuaternion.equals(PmRotationVector prv)
           
 boolean PmCartesian.equals(PmSpherical s)
           
 boolean PmCylindrical.equals(PmSpherical s)
           
static PM_CARTESIAN Posemath.intersection(PM_LINE l1, PM_LINE l2)
           
static PM_CARTESIAN Posemath.inv(PM_CARTESIAN v)
           
static PM_CYLINDRICAL Posemath.inv(PM_CYLINDRICAL v)
           
static PM_HOMOGENEOUS Posemath.inv(PM_HOMOGENEOUS h)
           
static PM_POSE Posemath.inv(PM_POSE p)
           
static PM_QUATERNION Posemath.inv(PM_QUATERNION q1)
           
static PM_XYA Posemath.inv(PM_XYA p)
           
static boolean Posemath.IS_FUZZ(double a, double fuzz)
           
static boolean Posemath.isNorm(PM_CARTESIAN v)
           
static boolean Posemath.isNorm(PM_CYLINDRICAL v)
           
static boolean Posemath.isNorm(PM_QUATERNION q1)
           
static boolean Posemath.isNorm(PM_ROTATION_MATRIX m)
           
static boolean Posemath.isNorm(PM_ROTATION_VECTOR r)
           
static double Posemath.mag(PM_CYLINDRICAL v1)
           
static double Posemath.mag(PM_QUATERNION q)
           
static PM_CYLINDRICAL Posemath.multiply(double d, PM_CYLINDRICAL c)
           
static PM_QUATERNION Posemath.multiply(double s, PM_QUATERNION q)
           
static PmRotationVector Posemath.multiply(double s, PM_ROTATION_VECTOR r)
           
static PM_CYLINDRICAL Posemath.multiply(PM_CYLINDRICAL c, double d)
           
static PM_CARTESIAN Posemath.multiply(PM_POSE p1, PM_CARTESIAN v2)
           
static PM_POSE Posemath.multiply(PM_POSE p1, PM_POSE p2)
           
static PM_QUATERNION Posemath.multiply(PM_QUATERNION q, double s)
           
static PM_CARTESIAN Posemath.multiply(PM_QUATERNION q1, PM_CARTESIAN v2)
           
static PM_QUATERNION Posemath.multiply(PM_QUATERNION q1, PM_QUATERNION q2)
           
static PM_CARTESIAN Posemath.multiply(PM_ROTATION_MATRIX m, PM_CARTESIAN v)
           
static PM_ROTATION_MATRIX Posemath.multiply(PM_ROTATION_MATRIX m1, PM_ROTATION_MATRIX m2)
           
static PM_ROTATION_VECTOR Posemath.multiply(PM_ROTATION_VECTOR r, double s)
           
static PM_CARTESIAN Posemath.neg(PM_CARTESIAN v)
           
static PM_CYLINDRICAL Posemath.neg(PM_CYLINDRICAL v)
           
static PM_CARTESIAN Posemath.norm(PM_CARTESIAN v)
           
static PM_CYLINDRICAL Posemath.norm(PM_CYLINDRICAL v)
           
static PM_QUATERNION Posemath.norm(PM_QUATERNION q1)
           
static PM_ROTATION_VECTOR Posemath.norm(PM_ROTATION_VECTOR r)
           
static int Posemath.pmAxisAngleQuatConvert(int axis, double a, PmQuaternion q)
          Store a quaternion based on a single rotation about an axis
static boolean Posemath.pmCartCartCompare(PmCartesian v1, PmCartesian v2)
           
static int Posemath.pmCartCartCross(PmCartesian v1, PmCartesian v2, PmCartesian vout)
           
static double Posemath.pmCartCartDisp(PmCartesian v1, PmCartesian v2)
           
static int Posemath.pmCartCartProj(PmCartesian v1, PmCartesian v2, PmCartesian vout)
           
static int Posemath.pmCartInv(PmCartesian v1, PmCartesian vout)
           
static boolean Posemath.pmCartIsNorm(PmCartesian v)
           
static int Posemath.pmCartNeg(PmCartesian v1, PmCartesian vout)
           
static int Posemath.pmCartNorm(PmCartesian v, PmCartesian vout)
           
static int Posemath.pmCartPlaneProj(PmCartesian v, PmCartesian normal, PmCartesian vout)
           
static int Posemath.pmCartScalDiv(PmCartesian v1, double d, PmCartesian vout)
           
static int Posemath.pmCircleInit(PmCircle circle, PmPose start, PmPose end, PmCartesian center, PmCartesian normal, int turn)
           
static int Posemath.pmCirclePoint(PmCircle circle, double angle, PmPose point)
           
static int Posemath.pmCylCylAdd(PmCylindrical c1, PmCylindrical c2, PmCylindrical cout)
           
static boolean Posemath.pmCylCylCompare(PmCylindrical v1, PmCylindrical v2)
           
static int Posemath.pmCylCylCross(PmCylindrical c1, PmCylindrical c2, PmCylindrical cout)
           
static double Posemath.pmCylCylDot(PmCylindrical c1, PmCylindrical c2)
           
static int Posemath.pmCylCylSub(PmCylindrical c1, PmCylindrical c2, PmCylindrical cout)
           
static int Posemath.pmCylInv(PmCylindrical c, PmCylindrical cout)
           
static boolean Posemath.pmCylIsNorm(PmCylindrical v)
           
static double Posemath.pmCylMag(PmCylindrical c)
           
static int Posemath.pmCylNeg(PmCylindrical v1, PmCylindrical vout)
           
static int Posemath.pmCylNorm(PmCylindrical v, PmCylindrical vout)
           
static int Posemath.pmCylScalDiv(PmCylindrical v1, double d, PmCylindrical vout)
           
static int Posemath.pmCylScalMult(PmCylindrical v1, double d, PmCylindrical vout)
           
static int Posemath.pmHomInv(PmHomogeneous h1, PmHomogeneous h2)
           
static int Posemath.pmHomPoseConvert(PmHomogeneous h, PmPose p)
           
static int Posemath.pmLineInit(PmLine line, PmPose start, PmPose end)
           
static int Posemath.pmLinePoint(PmLine line, double len, PmPose point)
           
static int Posemath.pmMatCartMult(PmRotationMatrix m, PmCartesian v, PmCartesian vout)
           
static int Posemath.pmMatInv(PmRotationMatrix m, PmRotationMatrix mout)
           
static boolean Posemath.pmMatIsNorm(PmRotationMatrix m)
           
static int Posemath.pmMatMatMult(PmRotationMatrix m1, PmRotationMatrix m2, PmRotationMatrix mout)
           
static int Posemath.pmMatNorm(PmRotationMatrix m, PmRotationMatrix mout)
           
static int Posemath.pmMatQuatConvert(PmRotationMatrix m, PmQuaternion q)
           
static int Posemath.pmMatRotConvert(PmRotationMatrix m, PmRotationVector r)
           
static int Posemath.pmMatRpyConvert(PmRotationMatrix m, PmRpy rpy)
           
static int Posemath.pmMatZyxConvert(PmRotationMatrix m, PmEulerZyx zyx)
           
static int Posemath.pmMatZyzConvert(PmRotationMatrix m, PmEulerZyz zyz)
           
static int Posemath.pmPoseCartMult(PmPose p1, PmCartesian v2, PmCartesian vout)
           
static int Posemath.pmPoseHomConvert(PmPose p, PmHomogeneous h)
           
static int Posemath.pmPoseInv(PmPose p1, PmPose p2)
           
static boolean Posemath.pmPosePoseCompare(PmPose p1, PmPose p2)
           
static int Posemath.pmPosePoseMult(PmPose p1, PmPose p2, PmPose pout)
           
static PmQuaternion Posemath.pmQuatAxisAngleMult(PmQuaternion q, int axis, double angle)
           
static int Posemath.pmQuatAxisAngleMult(PmQuaternion q, int axis, double angle, PmQuaternion pq)
           
static int Posemath.pmQuatCartMult(PmQuaternion q1, PmCartesian v2, PmCartesian vout)
           
static int Posemath.pmQuatInv(PmQuaternion q1, PmQuaternion qout)
           
static boolean Posemath.pmQuatIsNorm(PmQuaternion q1)
           
static double Posemath.pmQuatMag(PmQuaternion q)
           
static int Posemath.pmQuatMatConvert(PmQuaternion q, PmRotationMatrix m)
           
static int Posemath.pmQuatNorm(PmQuaternion q1, PmQuaternion qout)
           
static boolean Posemath.pmQuatQuatCompare(PmQuaternion q1, PmQuaternion q2)
           
static int Posemath.pmQuatQuatMult(PmQuaternion q1, PmQuaternion q2, PmQuaternion qout)
           
static int Posemath.pmQuatRotConvert(PmQuaternion q, PmRotationVector r)
          Convert a quaternion to a rotation vector
static int Posemath.pmQuatRpyConvert(PmQuaternion q, PmRpy rpy)
           
static int Posemath.pmQuatScalDiv(PmQuaternion q, double s, PmQuaternion qout)
           
static int Posemath.pmQuatScalMult(PmQuaternion q, double s, PmQuaternion qout)
           
static int Posemath.pmQuatZyxConvert(PmQuaternion q, PmEulerZyx zyx)
           
static int Posemath.pmQuatZyzConvert(PmQuaternion q, PmEulerZyz zyz)
           
static boolean Posemath.pmRotIsNorm(PmRotationVector r)
           
static int Posemath.pmRotMatConvert(PmRotationVector r, PmRotationMatrix m)
          Convert a rotation vector to a rotation matrix.
static int Posemath.pmRotNorm(PmRotationVector r, PmRotationVector rout)
           
static int Posemath.pmRotQuatConvert(PmRotationVector r, PmQuaternion q)
          Convert a rotation vector to a quaternion
static int Posemath.pmRotScalDiv(PmRotationVector r, double s, PmRotationVector rout)
           
static int Posemath.pmRotScalMult(PmRotationVector r, double s, PmRotationVector rout)
           
static int Posemath.pmRpyMatConvert(PmRpy rpy, PmRotationMatrix m)
           
static int Posemath.pmRpyQuatConvert(PmRpy rpy, PmQuaternion q)
           
static int Posemath.pmRpyRotConvert(PmRpy rpy, PmRotationVector r)
           
static int Posemath.pmRpyZyxConvert(PmRpy rpy, PmEulerZyx zyx)
           
static int Posemath.pmRpyZyzConvert(PmRpy rpy, PmEulerZyz zyz)
           
static double Posemath.pmSqrt(double x)
          Square root function that adds some extra checks similiar to the C++ pmSqrt() primarily only exists for converting C++ apps.
static int Posemath.pmZyxMatConvert(PmEulerZyx zyx, PmRotationMatrix m)
           
static int Posemath.pmZyxQuatConvert(PmEulerZyx zyx, PmQuaternion q)
           
static int Posemath.pmZyxRotConvert(PmEulerZyx zyx, PmRotationVector r)
           
static int Posemath.pmZyxRpyConvert(PmEulerZyx zyx, PmRpy rpy)
           
static int Posemath.pmZyxZyzConvert(PmEulerZyx zyx, PmEulerZyz zyz)
           
static int Posemath.pmZyzMatConvert(PmEulerZyz zyz, PmRotationMatrix m)
           
static int Posemath.pmZyzQuatConvert(PmEulerZyz zyz, PmQuaternion q)
           
static int Posemath.pmZyzRotConvert(PmEulerZyz zyz, PmRotationVector r)
           
static int Posemath.pmZyzRpyConvert(PmEulerZyz zyz, PmRpy rpy)
           
static PM_CARTESIAN Posemath.proj(PM_CARTESIAN v1, PM_CARTESIAN v2)
           
static PM_HOMOGENEOUS Posemath.toHom(PM_POSE p)
           
static PM_ROTATION_MATRIX Posemath.toMat(PM_QUATERNION v)
          Convert a quaternion to a rotation matrix.
static PM_ROTATION_MATRIX Posemath.toMat(PM_ROTATION_VECTOR v)
          Convert rotation vector to rotation matrix
static PM_QUATERNION Posemath.toQuat(PM_EULER_ZYX v)
           
static PM_QUATERNION Posemath.toQuat(PM_EULER_ZYZ v)
           
static PM_QUATERNION Posemath.toQuat(PM_ROTATION_MATRIX m)
           
static PM_QUATERNION Posemath.toQuat(PM_ROTATION_VECTOR v)
          Convert a rotation vector to a quaternion
static PM_QUATERNION Posemath.toQuat(PM_RPY v)
           
static PM_ROTATION_VECTOR Posemath.toRot(PM_QUATERNION v)
          Convert quaternion to a rotation vector
static PM_RPY Posemath.toRpy(PM_QUATERNION v)
           
 

Constructors in rcs.posemath that throw PmException
PM_CARTESIAN(PM_CYLINDRICAL c)
           
PM_CYLINDRICAL(double starttheta, double startr, double startz)
           
PM_CYLINDRICAL(PM_CARTESIAN v)
           
PM_POSE(double tranx, double trany, double tranz, double rots, double rotx, double roty, double rotz)
           
PM_POSE(PM_XYA xya)
           
PM_POSE(PmCartesian starttran, PmRpy startrpy)
           
PM_QUATERNION(double starts, double startx, double starty, double startz)
           
PM_QUATERNION(PM_ROTATION_VECTOR rv)
           
PM_ROTATION_MATRIX(PM_ROTATION_VECTOR rv)
           
PM_ROTATION_VECTOR(double starts, double startx, double starty, double startz)
           
PM_XYA(PM_POSE p)
           
PM_XYA(PmPose p)
           
PmPose(double tranx, double trany, double tranz, double rots, double rotx, double roty, double rotz)
           
PmPose(PmCartesian starttran, PmRpy startrpy)
           
PmQuaternion(double starts, double startx, double startz, double starty)
           
PmQuaternion(PmRpy rpy)
           
PmRotationVector(double starts, double startx, double starty, double startz)