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.add(PM_CARTESIAN v1, PM_CARTESIAN v2)
           
static PM_CYLINDRICAL Posemath.add(PM_CYLINDRICAL c1, PM_CYLINDRICAL c2)
           
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_CARTESIAN v1, PM_CARTESIAN v2)
           
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.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 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_CARTESIAN v)
           
static double Posemath.mag(PM_CYLINDRICAL v1)
           
static double Posemath.mag(PM_QUATERNION q)
           
static PM_CARTESIAN Posemath.multiply(double d, PM_CARTESIAN v)
           
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_CARTESIAN Posemath.multiply(PM_CARTESIAN v, double d)
           
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)
           
static int Posemath.pmCartCartAdd(PmCartesian v1, PmCartesian v2, PmCartesian vout)
           
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 double Posemath.pmCartCartDot(PmCartesian v1, PmCartesian v2)
           
static int Posemath.pmCartCartProj(PmCartesian v1, PmCartesian v2, PmCartesian vout)
           
static int Posemath.pmCartCartSub(PmCartesian v1, PmCartesian v2, PmCartesian vout)
           
static int Posemath.pmCartCylConvert(PmCartesian v, PmCylindrical c)
           
static int Posemath.pmCartInv(PmCartesian v1, PmCartesian vout)
           
static boolean Posemath.pmCartIsNorm(PmCartesian v)
           
static double Posemath.pmCartMag(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.pmCartScalMult(PmCartesian v1, double d, PmCartesian vout)
           
static int Posemath.pmCartSphConvert(PmCartesian v, PmSpherical s)
           
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.pmCylCartConvert(PmCylindrical c, PmCartesian v)
           
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.pmCylSphConvert(PmCylindrical c, PmSpherical s)
           
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)
           
protected static void Posemath.pmPrintError(java.lang.String str, int new_errno)
           
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)
           
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)
           
static int Posemath.pmRotNorm(PmRotationVector r, PmRotationVector rout)
           
static int Posemath.pmRotQuatConvert(PmRotationVector r, PmQuaternion q)
           
static int Posemath.pmRotRpyConvert(PmRotationVector r, PmRpy rpy)
           
static int Posemath.pmRotScalDiv(PmRotationVector r, double s, PmRotationVector rout)
           
static int Posemath.pmRotScalMult(PmRotationVector r, double s, PmRotationVector rout)
           
static int Posemath.pmRotZyxConvert(PmRotationVector r, PmEulerZyx zyx)
           
static int Posemath.pmRotZyzConvert(PmRotationVector r, PmEulerZyz zyz)
           
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 int Posemath.pmSphCartConvert(PmSpherical s, PmCartesian v)
           
static int Posemath.pmSphCylConvert(PmSpherical s, PmCylindrical c)
           
static double Posemath.pmSq(double x)
           
static double Posemath.pmSqrt(double x)
           
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_CARTESIAN Posemath.subtract(PM_CARTESIAN v1, PM_CARTESIAN v2)
           
static PM_CYLINDRICAL Posemath.subtract(PM_CYLINDRICAL c1, PM_CYLINDRICAL c2)
           
static PM_CARTESIAN Posemath.toCart(PM_CYLINDRICAL v)
           
static PM_CARTESIAN Posemath.toCart(PM_SPHERICAL v)
           
static PM_CYLINDRICAL Posemath.toCyl(PM_CARTESIAN v)
           
static PM_CYLINDRICAL Posemath.toCyl(PM_SPHERICAL s)
           
static PM_HOMOGENEOUS Posemath.toHom(PM_POSE p)
           
static PM_ROTATION_MATRIX Posemath.toMat(PM_QUATERNION v)
           
static PM_ROTATION_MATRIX Posemath.toMat(PM_ROTATION_VECTOR v)
           
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)
           
static PM_QUATERNION Posemath.toQuat(PM_RPY v)
           
static PM_ROTATION_VECTOR Posemath.toRot(PM_QUATERNION v)
           
static PM_RPY Posemath.toRpy(PM_QUATERNION v)
           
static PM_SPHERICAL Posemath.toSph(PM_CARTESIAN v)
           
static PM_SPHERICAL Posemath.toSph(PM_CYLINDRICAL c)
           
 

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_EULER_ZYX(PM_ROTATION_VECTOR rv)
           
PM_EULER_ZYZ(PM_ROTATION_VECTOR rv)
           
PM_POSE(double tranx, double trany, double tranz, double rots, double rotx, double roty, double rotz)
           
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_RPY(PM_ROTATION_VECTOR rv)
           
PmPose(double tranx, double trany, double tranz, double rots, double rotx, double roty, double rotz)
           
PmQuaternion(double starts, double startx, double startz, double starty)
           
PmRotationVector(double starts, double startx, double starty, double startz)