rcs.posemath
Class Posemath

java.lang.Object
  extended by rcs.posemath.Posemath

public class Posemath
extends java.lang.Object


Field Summary
static double CART_FUZZ
           
static double DBL_MAX
           
static boolean debug_on
           
static double DOUBLE_FUZZ
           
static double DOUBLECP_FUZZ
           
static double E_EPSILON
           
static double PI
           
static double PI_2
           
static double PI_4
           
static double PM_2_PI
           
static int PM_DIV_ERR
           
static int PM_ERR
           
static int PM_IMPL_ERR
           
static int PM_NORM_ERR
           
static double PM_PI
           
static double PM_PI_2
           
static double PM_PI_4
           
static boolean PM_PRINT_ERROR
           
static int PM_X
           
static int PM_Y
           
static int PM_Z
           
static int pmErrno
           
static double Q_FUZZ
           
static double QS_FUZZ
           
static double QSIN_FUZZ
           
static double RPY_P_FUZZ
           
static double RS_FUZZ
           
static double SINGULAR_EPSILON
           
static double SQRT_FUZZ
           
static double UNIT_QUAT_FUZZ
           
static double UNIT_SC_FUZZ
           
static double UNIT_VEC_FUZZ
           
static double V_FUZZ
           
static double ZYX_Y_FUZZ
           
static double ZYZ_Y_FUZZ
           
 
Constructor Summary
Posemath()
           
 
Method Summary
static PM_CARTESIAN add(PM_CARTESIAN v1, PM_CARTESIAN v2)
           
static PM_CYLINDRICAL add(PM_CYLINDRICAL c1, PM_CYLINDRICAL c2)
           
static PM_CARTESIAN cross(PM_CARTESIAN v1, PM_CARTESIAN v2)
           
static PM_CYLINDRICAL cross(PM_CYLINDRICAL v1, PM_CYLINDRICAL v2)
           
static double disp(PM_CARTESIAN v1, PM_CARTESIAN v2)
           
static PM_CARTESIAN divide(PM_CARTESIAN v, double d)
           
static PM_CYLINDRICAL divide(PM_CYLINDRICAL c, double d)
           
static PM_QUATERNION divide(PM_QUATERNION q, double s)
           
static PM_ROTATION_VECTOR divide(PM_ROTATION_VECTOR r, double s)
           
static double dot(PM_CARTESIAN v1, PM_CARTESIAN v2)
           
static double dot(PM_CYLINDRICAL v1, PM_CYLINDRICAL v2)
           
static PM_CARTESIAN inv(PM_CARTESIAN v)
           
static PM_CYLINDRICAL inv(PM_CYLINDRICAL v)
           
static PM_HOMOGENEOUS inv(PM_HOMOGENEOUS h)
           
static PM_POSE inv(PM_POSE p)
           
static PM_QUATERNION inv(PM_QUATERNION q1)
           
static boolean IS_FUZZ(double a, double fuzz)
           
static boolean isNorm(PM_CARTESIAN v)
           
static boolean isNorm(PM_CYLINDRICAL v)
           
static boolean isNorm(PM_QUATERNION q1)
           
static boolean isNorm(PM_ROTATION_MATRIX m)
           
static boolean isNorm(PM_ROTATION_VECTOR r)
           
static double mag(PM_CARTESIAN v)
           
static double mag(PM_CYLINDRICAL v1)
           
static double mag(PM_QUATERNION q)
           
static PM_CARTESIAN multiply(double d, PM_CARTESIAN v)
           
static PM_CYLINDRICAL multiply(double d, PM_CYLINDRICAL c)
           
static PM_QUATERNION multiply(double s, PM_QUATERNION q)
           
static PmRotationVector multiply(double s, PM_ROTATION_VECTOR r)
           
static PM_CARTESIAN multiply(PM_CARTESIAN v, double d)
           
static PM_CYLINDRICAL multiply(PM_CYLINDRICAL c, double d)
           
static PM_CARTESIAN multiply(PM_POSE p1, PM_CARTESIAN v2)
           
static PM_POSE multiply(PM_POSE p1, PM_POSE p2)
           
static PM_QUATERNION multiply(PM_QUATERNION q, double s)
           
static PM_CARTESIAN multiply(PM_QUATERNION q1, PM_CARTESIAN v2)
           
static PM_QUATERNION multiply(PM_QUATERNION q1, PM_QUATERNION q2)
           
static PM_CARTESIAN multiply(PM_ROTATION_MATRIX m, PM_CARTESIAN v)
           
static PM_ROTATION_MATRIX multiply(PM_ROTATION_MATRIX m1, PM_ROTATION_MATRIX m2)
           
static PM_ROTATION_VECTOR multiply(PM_ROTATION_VECTOR r, double s)
           
static PM_CARTESIAN neg(PM_CARTESIAN v)
           
static PM_CYLINDRICAL neg(PM_CYLINDRICAL v)
           
static PM_CARTESIAN norm(PM_CARTESIAN v)
           
static PM_CYLINDRICAL norm(PM_CYLINDRICAL v)
           
static PM_QUATERNION norm(PM_QUATERNION q1)
           
static PM_ROTATION_VECTOR norm(PM_ROTATION_VECTOR r)
           
static int pmAxisAngleQuatConvert(int axis, double a, PmQuaternion q)
           
static int pmCartCartAdd(PmCartesian v1, PmCartesian v2, PmCartesian vout)
           
static boolean pmCartCartCompare(PmCartesian v1, PmCartesian v2)
           
static int pmCartCartCross(PmCartesian v1, PmCartesian v2, PmCartesian vout)
           
static double pmCartCartDisp(PmCartesian v1, PmCartesian v2)
           
static double pmCartCartDot(PmCartesian v1, PmCartesian v2)
           
static int pmCartCartProj(PmCartesian v1, PmCartesian v2, PmCartesian vout)
           
static int pmCartCartSub(PmCartesian v1, PmCartesian v2, PmCartesian vout)
           
static int pmCartCylConvert(PmCartesian v, PmCylindrical c)
           
static int pmCartInv(PmCartesian v1, PmCartesian vout)
           
static boolean pmCartIsNorm(PmCartesian v)
           
static double pmCartMag(PmCartesian v)
           
static int pmCartNeg(PmCartesian v1, PmCartesian vout)
           
static int pmCartNorm(PmCartesian v, PmCartesian vout)
           
static int pmCartPlaneProj(PmCartesian v, PmCartesian normal, PmCartesian vout)
           
static int pmCartScalDiv(PmCartesian v1, double d, PmCartesian vout)
           
static int pmCartScalMult(PmCartesian v1, double d, PmCartesian vout)
           
static int pmCartSphConvert(PmCartesian v, PmSpherical s)
           
static int pmCircleInit(PmCircle circle, PmPose start, PmPose end, PmCartesian center, PmCartesian normal, int turn)
           
static int pmCirclePoint(PmCircle circle, double angle, PmPose point)
           
static boolean pmClose(double a, double b, double eps)
           
static int pmCylCartConvert(PmCylindrical c, PmCartesian v)
           
static int pmCylCylAdd(PmCylindrical c1, PmCylindrical c2, PmCylindrical cout)
           
static boolean pmCylCylCompare(PmCylindrical v1, PmCylindrical v2)
           
static int pmCylCylCross(PmCylindrical c1, PmCylindrical c2, PmCylindrical cout)
           
static double pmCylCylDot(PmCylindrical c1, PmCylindrical c2)
           
static int pmCylCylSub(PmCylindrical c1, PmCylindrical c2, PmCylindrical cout)
           
static int pmCylInv(PmCylindrical c, PmCylindrical cout)
           
static boolean pmCylIsNorm(PmCylindrical v)
           
static double pmCylMag(PmCylindrical c)
           
static int pmCylNeg(PmCylindrical v1, PmCylindrical vout)
           
static int pmCylNorm(PmCylindrical v, PmCylindrical vout)
           
static int pmCylScalDiv(PmCylindrical v1, double d, PmCylindrical vout)
           
static int pmCylScalMult(PmCylindrical v1, double d, PmCylindrical vout)
           
static int pmCylSphConvert(PmCylindrical c, PmSpherical s)
           
static int pmHomInv(PmHomogeneous h1, PmHomogeneous h2)
           
static int pmHomPoseConvert(PmHomogeneous h, PmPose p)
           
static int pmLineInit(PmLine line, PmPose start, PmPose end)
           
static int pmLinePoint(PmLine line, double len, PmPose point)
           
static int pmMatCartMult(PmRotationMatrix m, PmCartesian v, PmCartesian vout)
           
static int pmMatInv(PmRotationMatrix m, PmRotationMatrix mout)
           
static boolean pmMatIsNorm(PmRotationMatrix m)
           
static int pmMatMatMult(PmRotationMatrix m1, PmRotationMatrix m2, PmRotationMatrix mout)
           
static int pmMatNorm(PmRotationMatrix m, PmRotationMatrix mout)
           
static int pmMatQuatConvert(PmRotationMatrix m, PmQuaternion q)
           
static int pmMatRotConvert(PmRotationMatrix m, PmRotationVector r)
           
static int pmMatRpyConvert(PmRotationMatrix m, PmRpy rpy)
           
static int pmMatZyxConvert(PmRotationMatrix m, PmEulerZyx zyx)
           
static int pmMatZyzConvert(PmRotationMatrix m, PmEulerZyz zyz)
           
static int pmPoseCartMult(PmPose p1, PmCartesian v2, PmCartesian vout)
           
static int pmPoseHomConvert(PmPose p, PmHomogeneous h)
           
static int pmPoseInv(PmPose p1, PmPose p2)
           
static boolean pmPosePoseCompare(PmPose p1, PmPose p2)
           
static int pmPosePoseMult(PmPose p1, PmPose p2, PmPose pout)
           
protected static void pmPrintError(java.lang.String str, int new_errno)
           
static PmQuaternion pmQuatAxisAngleMult(PmQuaternion q, int axis, double angle)
           
static int pmQuatAxisAngleMult(PmQuaternion q, int axis, double angle, PmQuaternion pq)
           
static int pmQuatCartMult(PmQuaternion q1, PmCartesian v2, PmCartesian vout)
           
static int pmQuatInv(PmQuaternion q1, PmQuaternion qout)
           
static boolean pmQuatIsNorm(PmQuaternion q1)
           
static double pmQuatMag(PmQuaternion q)
           
static int pmQuatMatConvert(PmQuaternion q, PmRotationMatrix m)
           
static int pmQuatNorm(PmQuaternion q1, PmQuaternion qout)
           
static boolean pmQuatQuatCompare(PmQuaternion q1, PmQuaternion q2)
           
static int pmQuatQuatMult(PmQuaternion q1, PmQuaternion q2, PmQuaternion qout)
           
static int pmQuatRotConvert(PmQuaternion q, PmRotationVector r)
           
static int pmQuatRpyConvert(PmQuaternion q, PmRpy rpy)
           
static int pmQuatScalDiv(PmQuaternion q, double s, PmQuaternion qout)
           
static int pmQuatScalMult(PmQuaternion q, double s, PmQuaternion qout)
           
static int pmQuatZyxConvert(PmQuaternion q, PmEulerZyx zyx)
           
static int pmQuatZyzConvert(PmQuaternion q, PmEulerZyz zyz)
           
static boolean pmRotIsNorm(PmRotationVector r)
           
static int pmRotMatConvert(PmRotationVector r, PmRotationMatrix m)
           
static int pmRotNorm(PmRotationVector r, PmRotationVector rout)
           
static int pmRotQuatConvert(PmRotationVector r, PmQuaternion q)
           
static int pmRotRpyConvert(PmRotationVector r, PmRpy rpy)
           
static int pmRotScalDiv(PmRotationVector r, double s, PmRotationVector rout)
           
static int pmRotScalMult(PmRotationVector r, double s, PmRotationVector rout)
           
static int pmRotZyxConvert(PmRotationVector r, PmEulerZyx zyx)
           
static int pmRotZyzConvert(PmRotationVector r, PmEulerZyz zyz)
           
static int pmRpyMatConvert(PmRpy rpy, PmRotationMatrix m)
           
static int pmRpyQuatConvert(PmRpy rpy, PmQuaternion q)
           
static int pmRpyRotConvert(PmRpy rpy, PmRotationVector r)
           
static int pmRpyZyxConvert(PmRpy rpy, PmEulerZyx zyx)
           
static int pmRpyZyzConvert(PmRpy rpy, PmEulerZyz zyz)
           
static int pmSphCartConvert(PmSpherical s, PmCartesian v)
           
static int pmSphCylConvert(PmSpherical s, PmCylindrical c)
           
static double pmSq(double x)
           
static double pmSqrt(double x)
           
static int pmZyxMatConvert(PmEulerZyx zyx, PmRotationMatrix m)
           
static int pmZyxQuatConvert(PmEulerZyx zyx, PmQuaternion q)
           
static int pmZyxRotConvert(PmEulerZyx zyx, PmRotationVector r)
           
static int pmZyxRpyConvert(PmEulerZyx zyx, PmRpy rpy)
           
static int pmZyxZyzConvert(PmEulerZyx zyx, PmEulerZyz zyz)
           
static int pmZyzMatConvert(PmEulerZyz zyz, PmRotationMatrix m)
           
static int pmZyzQuatConvert(PmEulerZyz zyz, PmQuaternion q)
           
static int pmZyzRotConvert(PmEulerZyz zyz, PmRotationVector r)
           
static int pmZyzRpyConvert(PmEulerZyz zyz, PmRpy rpy)
           
static PM_CARTESIAN proj(PM_CARTESIAN v1, PM_CARTESIAN v2)
           
static PM_CARTESIAN subtract(PM_CARTESIAN v1, PM_CARTESIAN v2)
           
static PM_CYLINDRICAL subtract(PM_CYLINDRICAL c1, PM_CYLINDRICAL c2)
           
static PM_CARTESIAN toCart(PM_CYLINDRICAL v)
           
static PM_CARTESIAN toCart(PM_SPHERICAL v)
           
static PM_CYLINDRICAL toCyl(PM_CARTESIAN v)
           
static PM_CYLINDRICAL toCyl(PM_SPHERICAL s)
           
static PM_HOMOGENEOUS toHom(PM_POSE p)
           
static PM_ROTATION_MATRIX toMat(PM_QUATERNION v)
           
static PM_ROTATION_MATRIX toMat(PM_ROTATION_VECTOR v)
           
static PM_QUATERNION toQuat(PM_EULER_ZYX v)
           
static PM_QUATERNION toQuat(PM_EULER_ZYZ v)
           
static PM_QUATERNION toQuat(PM_ROTATION_MATRIX m)
           
static PM_QUATERNION toQuat(PM_ROTATION_VECTOR v)
           
static PM_QUATERNION toQuat(PM_RPY v)
           
static PM_ROTATION_VECTOR toRot(PM_QUATERNION v)
           
static PM_RPY toRpy(PM_QUATERNION v)
           
static PM_SPHERICAL toSph(PM_CARTESIAN v)
           
static PM_SPHERICAL toSph(PM_CYLINDRICAL c)
           
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

pmErrno

public static int pmErrno

PM_PRINT_ERROR

public static boolean PM_PRINT_ERROR

debug_on

public static boolean debug_on

CART_FUZZ

public static final double CART_FUZZ
See Also:
Constant Field Values

DOUBLECP_FUZZ

public static final double DOUBLECP_FUZZ
See Also:
Constant Field Values

DOUBLE_FUZZ

public static final double DOUBLE_FUZZ
See Also:
Constant Field Values

E_EPSILON

public static final double E_EPSILON
See Also:
Constant Field Values

PM_2_PI

public static final double PM_2_PI
See Also:
Constant Field Values

PM_DIV_ERR

public static final int PM_DIV_ERR
See Also:
Constant Field Values

PM_ERR

public static final int PM_ERR
See Also:
Constant Field Values

PM_IMPL_ERR

public static final int PM_IMPL_ERR
See Also:
Constant Field Values

PM_NORM_ERR

public static final int PM_NORM_ERR
See Also:
Constant Field Values

PM_PI

public static final double PM_PI
See Also:
Constant Field Values

PM_PI_2

public static final double PM_PI_2
See Also:
Constant Field Values

PM_PI_4

public static final double PM_PI_4
See Also:
Constant Field Values

QSIN_FUZZ

public static final double QSIN_FUZZ
See Also:
Constant Field Values

QS_FUZZ

public static final double QS_FUZZ
See Also:
Constant Field Values

Q_FUZZ

public static final double Q_FUZZ
See Also:
Constant Field Values

RPY_P_FUZZ

public static final double RPY_P_FUZZ
See Also:
Constant Field Values

RS_FUZZ

public static final double RS_FUZZ
See Also:
Constant Field Values

SINGULAR_EPSILON

public static final double SINGULAR_EPSILON
See Also:
Constant Field Values

SQRT_FUZZ

public static final double SQRT_FUZZ
See Also:
Constant Field Values

UNIT_QUAT_FUZZ

public static final double UNIT_QUAT_FUZZ
See Also:
Constant Field Values

UNIT_SC_FUZZ

public static final double UNIT_SC_FUZZ
See Also:
Constant Field Values

UNIT_VEC_FUZZ

public static final double UNIT_VEC_FUZZ
See Also:
Constant Field Values

V_FUZZ

public static final double V_FUZZ
See Also:
Constant Field Values

ZYX_Y_FUZZ

public static final double ZYX_Y_FUZZ
See Also:
Constant Field Values

ZYZ_Y_FUZZ

public static final double ZYZ_Y_FUZZ
See Also:
Constant Field Values

DBL_MAX

public static final double DBL_MAX
See Also:
Constant Field Values

PI

public static final double PI
See Also:
Constant Field Values

PI_2

public static final double PI_2
See Also:
Constant Field Values

PI_4

public static final double PI_4
See Also:
Constant Field Values

PM_X

public static final int PM_X
See Also:
Constant Field Values

PM_Y

public static final int PM_Y
See Also:
Constant Field Values

PM_Z

public static final int PM_Z
See Also:
Constant Field Values
Constructor Detail

Posemath

public Posemath()
Method Detail

pmPrintError

protected static void pmPrintError(java.lang.String str,
                                   int new_errno)
                            throws PmException
Throws:
PmException

IS_FUZZ

public static boolean IS_FUZZ(double a,
                              double fuzz)
                       throws PmException
Throws:
PmException

pmSqrt

public static double pmSqrt(double x)
                     throws PmException
Throws:
PmException

pmSq

public static double pmSq(double x)
                   throws PmException
Throws:
PmException

pmClose

public static boolean pmClose(double a,
                              double b,
                              double eps)

toCyl

public static PM_CYLINDRICAL toCyl(PM_CARTESIAN v)
                            throws PmException
Throws:
PmException

pmCartCylConvert

public static int pmCartCylConvert(PmCartesian v,
                                   PmCylindrical c)
                            throws PmException
Throws:
PmException

toSph

public static PM_SPHERICAL toSph(PM_CARTESIAN v)
                          throws PmException
Throws:
PmException

pmCartSphConvert

public static int pmCartSphConvert(PmCartesian v,
                                   PmSpherical s)
                            throws PmException
Throws:
PmException

toCart

public static PM_CARTESIAN toCart(PM_SPHERICAL v)
                           throws PmException
Throws:
PmException

pmSphCartConvert

public static int pmSphCartConvert(PmSpherical s,
                                   PmCartesian v)
                            throws PmException
Throws:
PmException

toCyl

public static PM_CYLINDRICAL toCyl(PM_SPHERICAL s)
                            throws PmException
Throws:
PmException

pmSphCylConvert

public static int pmSphCylConvert(PmSpherical s,
                                  PmCylindrical c)
                           throws PmException
Throws:
PmException

toCart

public static PM_CARTESIAN toCart(PM_CYLINDRICAL v)
                           throws PmException
Throws:
PmException

pmCylCartConvert

public static int pmCylCartConvert(PmCylindrical c,
                                   PmCartesian v)
                            throws PmException
Throws:
PmException

toSph

public static PM_SPHERICAL toSph(PM_CYLINDRICAL c)
                          throws PmException
Throws:
PmException

pmCylSphConvert

public static int pmCylSphConvert(PmCylindrical c,
                                  PmSpherical s)
                           throws PmException
Throws:
PmException

pmAxisAngleQuatConvert

public static int pmAxisAngleQuatConvert(int axis,
                                         double a,
                                         PmQuaternion q)
                                  throws PmException
Throws:
PmException

toQuat

public static PM_QUATERNION toQuat(PM_ROTATION_VECTOR v)
                            throws PmException
Throws:
PmException

pmRotQuatConvert

public static int pmRotQuatConvert(PmRotationVector r,
                                   PmQuaternion q)
                            throws PmException
Throws:
PmException

toMat

public static PM_ROTATION_MATRIX toMat(PM_ROTATION_VECTOR v)
                                throws PmException
Throws:
PmException

pmRotMatConvert

public static int pmRotMatConvert(PmRotationVector r,
                                  PmRotationMatrix m)
                           throws PmException
Throws:
PmException

pmRotZyzConvert

public static int pmRotZyzConvert(PmRotationVector r,
                                  PmEulerZyz zyz)
                           throws PmException
Throws:
PmException

pmRotZyxConvert

public static int pmRotZyxConvert(PmRotationVector r,
                                  PmEulerZyx zyx)
                           throws PmException
Throws:
PmException

pmRotRpyConvert

public static int pmRotRpyConvert(PmRotationVector r,
                                  PmRpy rpy)
                           throws PmException
Throws:
PmException

toRot

public static PM_ROTATION_VECTOR toRot(PM_QUATERNION v)
                                throws PmException
Throws:
PmException

pmQuatRotConvert

public static int pmQuatRotConvert(PmQuaternion q,
                                   PmRotationVector r)
                            throws PmException
Throws:
PmException

toMat

public static PM_ROTATION_MATRIX toMat(PM_QUATERNION v)
                                throws PmException
Throws:
PmException

pmQuatMatConvert

public static int pmQuatMatConvert(PmQuaternion q,
                                   PmRotationMatrix m)
                            throws PmException
Throws:
PmException

pmQuatZyzConvert

public static int pmQuatZyzConvert(PmQuaternion q,
                                   PmEulerZyz zyz)
                            throws PmException
Throws:
PmException

pmQuatZyxConvert

public static int pmQuatZyxConvert(PmQuaternion q,
                                   PmEulerZyx zyx)
                            throws PmException
Throws:
PmException

toRpy

public static PM_RPY toRpy(PM_QUATERNION v)
                    throws PmException
Throws:
PmException

pmQuatRpyConvert

public static int pmQuatRpyConvert(PmQuaternion q,
                                   PmRpy rpy)
                            throws PmException
Throws:
PmException

pmMatRotConvert

public static int pmMatRotConvert(PmRotationMatrix m,
                                  PmRotationVector r)
                           throws PmException
Throws:
PmException

toQuat

public static PM_QUATERNION toQuat(PM_ROTATION_MATRIX m)
                            throws PmException
Throws:
PmException

pmMatQuatConvert

public static int pmMatQuatConvert(PmRotationMatrix m,
                                   PmQuaternion q)
                            throws PmException
Throws:
PmException

pmMatZyzConvert

public static int pmMatZyzConvert(PmRotationMatrix m,
                                  PmEulerZyz zyz)
                           throws PmException
Throws:
PmException

pmMatZyxConvert

public static int pmMatZyxConvert(PmRotationMatrix m,
                                  PmEulerZyx zyx)
                           throws PmException
Throws:
PmException

pmMatRpyConvert

public static int pmMatRpyConvert(PmRotationMatrix m,
                                  PmRpy rpy)
                           throws PmException
Throws:
PmException

pmZyzRotConvert

public static int pmZyzRotConvert(PmEulerZyz zyz,
                                  PmRotationVector r)
                           throws PmException
Throws:
PmException

toQuat

public static PM_QUATERNION toQuat(PM_EULER_ZYZ v)
                            throws PmException
Throws:
PmException

pmZyzQuatConvert

public static int pmZyzQuatConvert(PmEulerZyz zyz,
                                   PmQuaternion q)
                            throws PmException
Throws:
PmException

pmZyzMatConvert

public static int pmZyzMatConvert(PmEulerZyz zyz,
                                  PmRotationMatrix m)
                           throws PmException
Throws:
PmException

pmZyzRpyConvert

public static int pmZyzRpyConvert(PmEulerZyz zyz,
                                  PmRpy rpy)
                           throws PmException
Throws:
PmException

pmZyxRotConvert

public static int pmZyxRotConvert(PmEulerZyx zyx,
                                  PmRotationVector r)
                           throws PmException
Throws:
PmException

toQuat

public static PM_QUATERNION toQuat(PM_EULER_ZYX v)
                            throws PmException
Throws:
PmException

pmZyxQuatConvert

public static int pmZyxQuatConvert(PmEulerZyx zyx,
                                   PmQuaternion q)
                            throws PmException
Throws:
PmException

pmZyxMatConvert

public static int pmZyxMatConvert(PmEulerZyx zyx,
                                  PmRotationMatrix m)
                           throws PmException
Throws:
PmException

pmZyxZyzConvert

public static int pmZyxZyzConvert(PmEulerZyx zyx,
                                  PmEulerZyz zyz)
                           throws PmException
Throws:
PmException

pmZyxRpyConvert

public static int pmZyxRpyConvert(PmEulerZyx zyx,
                                  PmRpy rpy)
                           throws PmException
Throws:
PmException

pmRpyRotConvert

public static int pmRpyRotConvert(PmRpy rpy,
                                  PmRotationVector r)
                           throws PmException
Throws:
PmException

toQuat

public static PM_QUATERNION toQuat(PM_RPY v)
                            throws PmException
Throws:
PmException

pmRpyQuatConvert

public static int pmRpyQuatConvert(PmRpy rpy,
                                   PmQuaternion q)
                            throws PmException
Throws:
PmException

pmRpyMatConvert

public static int pmRpyMatConvert(PmRpy rpy,
                                  PmRotationMatrix m)
                           throws PmException
Throws:
PmException

pmRpyZyzConvert

public static int pmRpyZyzConvert(PmRpy rpy,
                                  PmEulerZyz zyz)
                           throws PmException
Throws:
PmException

pmRpyZyxConvert

public static int pmRpyZyxConvert(PmRpy rpy,
                                  PmEulerZyx zyx)
                           throws PmException
Throws:
PmException

toHom

public static PM_HOMOGENEOUS toHom(PM_POSE p)
                            throws PmException
Throws:
PmException

pmPoseHomConvert

public static int pmPoseHomConvert(PmPose p,
                                   PmHomogeneous h)
                            throws PmException
Throws:
PmException

pmHomPoseConvert

public static int pmHomPoseConvert(PmHomogeneous h,
                                   PmPose p)
                            throws PmException
Throws:
PmException

pmCartCartCompare

public static boolean pmCartCartCompare(PmCartesian v1,
                                        PmCartesian v2)
                                 throws PmException
Throws:
PmException

dot

public static double dot(PM_CARTESIAN v1,
                         PM_CARTESIAN v2)
                  throws PmException
Throws:
PmException

pmCartCartDot

public static double pmCartCartDot(PmCartesian v1,
                                   PmCartesian v2)
                            throws PmException
Throws:
PmException

cross

public static PM_CARTESIAN cross(PM_CARTESIAN v1,
                                 PM_CARTESIAN v2)
                          throws PmException
Throws:
PmException

pmCartCartCross

public static int pmCartCartCross(PmCartesian v1,
                                  PmCartesian v2,
                                  PmCartesian vout)
                           throws PmException
Throws:
PmException

mag

public static double mag(PM_CARTESIAN v)
                  throws PmException
Throws:
PmException

pmCartMag

public static double pmCartMag(PmCartesian v)
                        throws PmException
Throws:
PmException

disp

public static double disp(PM_CARTESIAN v1,
                          PM_CARTESIAN v2)
                   throws PmException
Throws:
PmException

pmCartCartDisp

public static double pmCartCartDisp(PmCartesian v1,
                                    PmCartesian v2)
                             throws PmException
Throws:
PmException

add

public static PM_CARTESIAN add(PM_CARTESIAN v1,
                               PM_CARTESIAN v2)
                        throws PmException
Throws:
PmException

pmCartCartAdd

public static int pmCartCartAdd(PmCartesian v1,
                                PmCartesian v2,
                                PmCartesian vout)
                         throws PmException
Throws:
PmException

subtract

public static PM_CARTESIAN subtract(PM_CARTESIAN v1,
                                    PM_CARTESIAN v2)
                             throws PmException
Throws:
PmException

pmCartCartSub

public static int pmCartCartSub(PmCartesian v1,
                                PmCartesian v2,
                                PmCartesian vout)
                         throws PmException
Throws:
PmException

multiply

public static PM_CARTESIAN multiply(double d,
                                    PM_CARTESIAN v)
                             throws PmException
Throws:
PmException

multiply

public static PM_CARTESIAN multiply(PM_CARTESIAN v,
                                    double d)
                             throws PmException
Throws:
PmException

pmCartScalMult

public static int pmCartScalMult(PmCartesian v1,
                                 double d,
                                 PmCartesian vout)
                          throws PmException
Throws:
PmException

divide

public static PM_CARTESIAN divide(PM_CARTESIAN v,
                                  double d)
                           throws PmException
Throws:
PmException

pmCartScalDiv

public static int pmCartScalDiv(PmCartesian v1,
                                double d,
                                PmCartesian vout)
                         throws PmException
Throws:
PmException

neg

public static PM_CARTESIAN neg(PM_CARTESIAN v)
                        throws PmException
Throws:
PmException

pmCartNeg

public static int pmCartNeg(PmCartesian v1,
                            PmCartesian vout)
                     throws PmException
Throws:
PmException

inv

public static PM_CARTESIAN inv(PM_CARTESIAN v)
                        throws PmException
Throws:
PmException

pmCartInv

public static int pmCartInv(PmCartesian v1,
                            PmCartesian vout)
                     throws PmException
Throws:
PmException

norm

public static PM_CARTESIAN norm(PM_CARTESIAN v)
                         throws PmException
Throws:
PmException

pmCartNorm

public static int pmCartNorm(PmCartesian v,
                             PmCartesian vout)
                      throws PmException
Throws:
PmException

isNorm

public static boolean isNorm(PM_CARTESIAN v)
                      throws PmException
Throws:
PmException

pmCartIsNorm

public static boolean pmCartIsNorm(PmCartesian v)
                            throws PmException
Throws:
PmException

proj

public static PM_CARTESIAN proj(PM_CARTESIAN v1,
                                PM_CARTESIAN v2)
                         throws PmException
Throws:
PmException

pmCartCartProj

public static int pmCartCartProj(PmCartesian v1,
                                 PmCartesian v2,
                                 PmCartesian vout)
                          throws PmException
Throws:
PmException

pmCartPlaneProj

public static int pmCartPlaneProj(PmCartesian v,
                                  PmCartesian normal,
                                  PmCartesian vout)
                           throws PmException
Throws:
PmException

add

public static PM_CYLINDRICAL add(PM_CYLINDRICAL c1,
                                 PM_CYLINDRICAL c2)
                          throws PmException
Throws:
PmException

pmCylCylAdd

public static int pmCylCylAdd(PmCylindrical c1,
                              PmCylindrical c2,
                              PmCylindrical cout)
                       throws PmException
Throws:
PmException

subtract

public static PM_CYLINDRICAL subtract(PM_CYLINDRICAL c1,
                                      PM_CYLINDRICAL c2)
                               throws PmException
Throws:
PmException

pmCylCylSub

public static int pmCylCylSub(PmCylindrical c1,
                              PmCylindrical c2,
                              PmCylindrical cout)
                       throws PmException
Throws:
PmException

multiply

public static PM_CYLINDRICAL multiply(double d,
                                      PM_CYLINDRICAL c)
                               throws PmException
Throws:
PmException

multiply

public static PM_CYLINDRICAL multiply(PM_CYLINDRICAL c,
                                      double d)
                               throws PmException
Throws:
PmException

pmCylScalMult

public static int pmCylScalMult(PmCylindrical v1,
                                double d,
                                PmCylindrical vout)
                         throws PmException
Throws:
PmException

divide

public static PM_CYLINDRICAL divide(PM_CYLINDRICAL c,
                                    double d)
                             throws PmException
Throws:
PmException

pmCylScalDiv

public static int pmCylScalDiv(PmCylindrical v1,
                               double d,
                               PmCylindrical vout)
                        throws PmException
Throws:
PmException

pmCylCylCompare

public static boolean pmCylCylCompare(PmCylindrical v1,
                                      PmCylindrical v2)
                               throws PmException
Throws:
PmException

dot

public static double dot(PM_CYLINDRICAL v1,
                         PM_CYLINDRICAL v2)
                  throws PmException
Throws:
PmException

pmCylCylDot

public static double pmCylCylDot(PmCylindrical c1,
                                 PmCylindrical c2)
                          throws PmException
Throws:
PmException

mag

public static double mag(PM_CYLINDRICAL v1)
                  throws PmException
Throws:
PmException

pmCylMag

public static double pmCylMag(PmCylindrical c)
                       throws PmException
Throws:
PmException

cross

public static PM_CYLINDRICAL cross(PM_CYLINDRICAL v1,
                                   PM_CYLINDRICAL v2)
                            throws PmException
Throws:
PmException

pmCylCylCross

public static int pmCylCylCross(PmCylindrical c1,
                                PmCylindrical c2,
                                PmCylindrical cout)
                         throws PmException
Throws:
PmException

neg

public static PM_CYLINDRICAL neg(PM_CYLINDRICAL v)
                          throws PmException
Throws:
PmException

pmCylNeg

public static int pmCylNeg(PmCylindrical v1,
                           PmCylindrical vout)
                    throws PmException
Throws:
PmException

norm

public static PM_CYLINDRICAL norm(PM_CYLINDRICAL v)
                           throws PmException
Throws:
PmException

pmCylNorm

public static int pmCylNorm(PmCylindrical v,
                            PmCylindrical vout)
                     throws PmException
Throws:
PmException

inv

public static PM_CYLINDRICAL inv(PM_CYLINDRICAL v)
                          throws PmException
Throws:
PmException

pmCylInv

public static int pmCylInv(PmCylindrical c,
                           PmCylindrical cout)
                    throws PmException
Throws:
PmException

isNorm

public static boolean isNorm(PM_CYLINDRICAL v)
                      throws PmException
Throws:
PmException

pmCylIsNorm

public static boolean pmCylIsNorm(PmCylindrical v)
                           throws PmException
Throws:
PmException

pmQuatAxisAngleMult

public static PmQuaternion pmQuatAxisAngleMult(PmQuaternion q,
                                               int axis,
                                               double angle)
                                        throws PmException
Throws:
PmException

pmQuatAxisAngleMult

public static int pmQuatAxisAngleMult(PmQuaternion q,
                                      int axis,
                                      double angle,
                                      PmQuaternion pq)
                               throws PmException
Throws:
PmException

multiply

public static PM_ROTATION_VECTOR multiply(PM_ROTATION_VECTOR r,
                                          double s)
                                   throws PmException
Throws:
PmException

multiply

public static PmRotationVector multiply(double s,
                                        PM_ROTATION_VECTOR r)
                                 throws PmException
Throws:
PmException

pmRotScalMult

public static int pmRotScalMult(PmRotationVector r,
                                double s,
                                PmRotationVector rout)
                         throws PmException
Throws:
PmException

divide

public static PM_ROTATION_VECTOR divide(PM_ROTATION_VECTOR r,
                                        double s)
                                 throws PmException
Throws:
PmException

pmRotScalDiv

public static int pmRotScalDiv(PmRotationVector r,
                               double s,
                               PmRotationVector rout)
                        throws PmException
Throws:
PmException

isNorm

public static boolean isNorm(PM_ROTATION_VECTOR r)
                      throws PmException
Throws:
PmException

pmRotIsNorm

public static boolean pmRotIsNorm(PmRotationVector r)
                           throws PmException
Throws:
PmException

norm

public static PM_ROTATION_VECTOR norm(PM_ROTATION_VECTOR r)
                               throws PmException
Throws:
PmException

pmRotNorm

public static int pmRotNorm(PmRotationVector r,
                            PmRotationVector rout)
                     throws PmException
Throws:
PmException

pmMatNorm

public static int pmMatNorm(PmRotationMatrix m,
                            PmRotationMatrix mout)
                     throws PmException
Throws:
PmException

isNorm

public static boolean isNorm(PM_ROTATION_MATRIX m)
                      throws PmException
Throws:
PmException

pmMatIsNorm

public static boolean pmMatIsNorm(PmRotationMatrix m)
                           throws PmException
Throws:
PmException

pmMatInv

public static int pmMatInv(PmRotationMatrix m,
                           PmRotationMatrix mout)
                    throws PmException
Throws:
PmException

multiply

public static PM_CARTESIAN multiply(PM_ROTATION_MATRIX m,
                                    PM_CARTESIAN v)
                             throws PmException
Throws:
PmException

pmMatCartMult

public static int pmMatCartMult(PmRotationMatrix m,
                                PmCartesian v,
                                PmCartesian vout)
                         throws PmException
Throws:
PmException

multiply

public static PM_ROTATION_MATRIX multiply(PM_ROTATION_MATRIX m1,
                                          PM_ROTATION_MATRIX m2)
                                   throws PmException
Throws:
PmException

pmMatMatMult

public static int pmMatMatMult(PmRotationMatrix m1,
                               PmRotationMatrix m2,
                               PmRotationMatrix mout)
                        throws PmException
Throws:
PmException

pmQuatQuatCompare

public static boolean pmQuatQuatCompare(PmQuaternion q1,
                                        PmQuaternion q2)
                                 throws PmException
Throws:
PmException

mag

public static double mag(PM_QUATERNION q)
                  throws PmException
Throws:
PmException

pmQuatMag

public static double pmQuatMag(PmQuaternion q)
                        throws PmException
Throws:
PmException

norm

public static PM_QUATERNION norm(PM_QUATERNION q1)
                          throws PmException
Throws:
PmException

pmQuatNorm

public static int pmQuatNorm(PmQuaternion q1,
                             PmQuaternion qout)
                      throws PmException
Throws:
PmException

inv

public static PM_QUATERNION inv(PM_QUATERNION q1)
                         throws PmException
Throws:
PmException

pmQuatInv

public static int pmQuatInv(PmQuaternion q1,
                            PmQuaternion qout)
                     throws PmException
Throws:
PmException

isNorm

public static boolean isNorm(PM_QUATERNION q1)
                      throws PmException
Throws:
PmException

pmQuatIsNorm

public static boolean pmQuatIsNorm(PmQuaternion q1)
                            throws PmException
Throws:
PmException

multiply

public static PM_QUATERNION multiply(PM_QUATERNION q,
                                     double s)
                              throws PmException
Throws:
PmException

multiply

public static PM_QUATERNION multiply(double s,
                                     PM_QUATERNION q)
                              throws PmException
Throws:
PmException

pmQuatScalMult

public static int pmQuatScalMult(PmQuaternion q,
                                 double s,
                                 PmQuaternion qout)
                          throws PmException
Throws:
PmException

divide

public static PM_QUATERNION divide(PM_QUATERNION q,
                                   double s)
                            throws PmException
Throws:
PmException

pmQuatScalDiv

public static int pmQuatScalDiv(PmQuaternion q,
                                double s,
                                PmQuaternion qout)
                         throws PmException
Throws:
PmException

multiply

public static PM_QUATERNION multiply(PM_QUATERNION q1,
                                     PM_QUATERNION q2)
                              throws PmException
Throws:
PmException

pmQuatQuatMult

public static int pmQuatQuatMult(PmQuaternion q1,
                                 PmQuaternion q2,
                                 PmQuaternion qout)
                          throws PmException
Throws:
PmException

multiply

public static PM_CARTESIAN multiply(PM_QUATERNION q1,
                                    PM_CARTESIAN v2)
                             throws PmException
Throws:
PmException

pmQuatCartMult

public static int pmQuatCartMult(PmQuaternion q1,
                                 PmCartesian v2,
                                 PmCartesian vout)
                          throws PmException
Throws:
PmException

pmPosePoseCompare

public static boolean pmPosePoseCompare(PmPose p1,
                                        PmPose p2)
                                 throws PmException
Throws:
PmException

inv

public static PM_POSE inv(PM_POSE p)
                   throws PmException
Throws:
PmException

pmPoseInv

public static int pmPoseInv(PmPose p1,
                            PmPose p2)
                     throws PmException
Throws:
PmException

multiply

public static PM_CARTESIAN multiply(PM_POSE p1,
                                    PM_CARTESIAN v2)
                             throws PmException
Throws:
PmException

pmPoseCartMult

public static int pmPoseCartMult(PmPose p1,
                                 PmCartesian v2,
                                 PmCartesian vout)
                          throws PmException
Throws:
PmException

multiply

public static PM_POSE multiply(PM_POSE p1,
                               PM_POSE p2)
                        throws PmException
Throws:
PmException

pmPosePoseMult

public static int pmPosePoseMult(PmPose p1,
                                 PmPose p2,
                                 PmPose pout)
                          throws PmException
Throws:
PmException

inv

public static PM_HOMOGENEOUS inv(PM_HOMOGENEOUS h)
                          throws PmException
Throws:
PmException

pmHomInv

public static int pmHomInv(PmHomogeneous h1,
                           PmHomogeneous h2)
                    throws PmException
Throws:
PmException

pmLineInit

public static int pmLineInit(PmLine line,
                             PmPose start,
                             PmPose end)
                      throws PmException
Throws:
PmException

pmLinePoint

public static int pmLinePoint(PmLine line,
                              double len,
                              PmPose point)
                       throws PmException
Throws:
PmException

pmCircleInit

public static int pmCircleInit(PmCircle circle,
                               PmPose start,
                               PmPose end,
                               PmCartesian center,
                               PmCartesian normal,
                               int turn)
                        throws PmException
Throws:
PmException

pmCirclePoint

public static int pmCirclePoint(PmCircle circle,
                                double angle,
                                PmPose point)
                         throws PmException
Throws:
PmException