All Packages  Class Hierarchy  This Package  Previous  Next  Index

Class rcs.posemath.Posemath

java.lang.Object
   |
   +----rcs.posemath.Posemath

public class Posemath
extends Object

Variable Index

 o CART_FUZZ
 o DBL_MAX
 o debug_on
 o DOUBLE_FUZZ
 o DOUBLECP_FUZZ
 o E_EPSILON
 o PI
 o PI_2
 o PI_4
 o PM_2_PI
 o PM_DIV_ERR
 o PM_ERR
 o PM_IMPL_ERR
 o PM_NORM_ERR
 o PM_PI
 o PM_PI_2
 o PM_PI_4
 o PM_PRINT_ERROR
 o PM_X
 o PM_Y
 o PM_Z
 o pmErrno
 o Q_FUZZ
 o QS_FUZZ
 o QSIN_FUZZ
 o RPY_P_FUZZ
 o RS_FUZZ
 o SINGULAR_EPSILON
 o SQRT_FUZZ
 o UNIT_QUAT_FUZZ
 o UNIT_SC_FUZZ
 o UNIT_VEC_FUZZ
 o V_FUZZ
 o ZYX_Y_FUZZ
 o ZYZ_Y_FUZZ

Constructor Index

 o Posemath()

Method Index

 o add(PM_CARTESIAN, PM_CARTESIAN)
 o add(PM_CYLINDRICAL, PM_CYLINDRICAL)
 o cross(PM_CARTESIAN, PM_CARTESIAN)
 o cross(PM_CYLINDRICAL, PM_CYLINDRICAL)
 o disp(PM_CARTESIAN, PM_CARTESIAN)
 o divide(PM_CARTESIAN, double)
 o divide(PM_CYLINDRICAL, double)
 o divide(PM_QUATERNION, double)
 o divide(PM_ROTATION_VECTOR, double)
 o dot(PM_CARTESIAN, PM_CARTESIAN)
 o dot(PM_CYLINDRICAL, PM_CYLINDRICAL)
 o inv(PM_CARTESIAN)
 o inv(PM_CYLINDRICAL)
 o inv(PM_HOMOGENEOUS)
 o inv(PM_POSE)
 o inv(PM_QUATERNION)
 o IS_FUZZ(double, double)
 o isNorm(PM_CARTESIAN)
 o isNorm(PM_CYLINDRICAL)
 o isNorm(PM_QUATERNION)
 o isNorm(PM_ROTATION_MATRIX)
 o isNorm(PM_ROTATION_VECTOR)
 o mag(PM_CARTESIAN)
 o mag(PM_CYLINDRICAL)
 o mag(PM_QUATERNION)
 o multiply(double, PM_CARTESIAN)
 o multiply(double, PM_CYLINDRICAL)
 o multiply(double, PM_QUATERNION)
 o multiply(double, PM_ROTATION_VECTOR)
 o multiply(PM_CARTESIAN, double)
 o multiply(PM_CYLINDRICAL, double)
 o multiply(PM_POSE, PM_CARTESIAN)
 o multiply(PM_POSE, PM_POSE)
 o multiply(PM_QUATERNION, double)
 o multiply(PM_QUATERNION, PM_CARTESIAN)
 o multiply(PM_QUATERNION, PM_QUATERNION)
 o multiply(PM_ROTATION_MATRIX, PM_CARTESIAN)
 o multiply(PM_ROTATION_MATRIX, PM_ROTATION_MATRIX)
 o multiply(PM_ROTATION_VECTOR, double)
 o neg(PM_CARTESIAN)
 o neg(PM_CYLINDRICAL)
 o norm(PM_CARTESIAN)
 o norm(PM_CYLINDRICAL)
 o norm(PM_QUATERNION)
 o norm(PM_ROTATION_VECTOR)
 o pmAxisAngleQuatConvert(int, double, PmQuaternion)
 o pmCartCartAdd(PmCartesian, PmCartesian, PmCartesian)
 o pmCartCartCompare(PmCartesian, PmCartesian)
 o pmCartCartCross(PmCartesian, PmCartesian, PmCartesian)
 o pmCartCartDisp(PmCartesian, PmCartesian)
 o pmCartCartDot(PmCartesian, PmCartesian)
 o pmCartCartProj(PmCartesian, PmCartesian, PmCartesian)
 o pmCartCartSub(PmCartesian, PmCartesian, PmCartesian)
 o pmCartCylConvert(PmCartesian, PmCylindrical)
 o pmCartInv(PmCartesian, PmCartesian)
 o pmCartIsNorm(PmCartesian)
 o pmCartMag(PmCartesian)
 o pmCartNeg(PmCartesian, PmCartesian)
 o pmCartNorm(PmCartesian, PmCartesian)
 o pmCartPlaneProj(PmCartesian, PmCartesian, PmCartesian)
 o pmCartScalDiv(PmCartesian, double, PmCartesian)
 o pmCartScalMult(PmCartesian, double, PmCartesian)
 o pmCartSphConvert(PmCartesian, PmSpherical)
 o pmCircleInit(PmCircle, PmPose, PmPose, PmCartesian, PmCartesian, int)
 o pmCirclePoint(PmCircle, double, PmPose)
 o pmClose(double, double, double)
 o pmCylCartConvert(PmCylindrical, PmCartesian)
 o pmCylCylAdd(PmCylindrical, PmCylindrical, PmCylindrical)
 o pmCylCylCompare(PmCylindrical, PmCylindrical)
 o pmCylCylCross(PmCylindrical, PmCylindrical, PmCylindrical)
 o pmCylCylDot(PmCylindrical, PmCylindrical)
 o pmCylCylSub(PmCylindrical, PmCylindrical, PmCylindrical)
 o pmCylInv(PmCylindrical, PmCylindrical)
 o pmCylIsNorm(PmCylindrical)
 o pmCylMag(PmCylindrical)
 o pmCylNeg(PmCylindrical, PmCylindrical)
 o pmCylNorm(PmCylindrical, PmCylindrical)
 o pmCylScalDiv(PmCylindrical, double, PmCylindrical)
 o pmCylScalMult(PmCylindrical, double, PmCylindrical)
 o pmCylSphConvert(PmCylindrical, PmSpherical)
 o pmHomInv(PmHomogeneous, PmHomogeneous)
 o pmHomPoseConvert(PmHomogeneous, PmPose)
 o pmLineInit(PmLine, PmPose, PmPose)
 o pmLinePoint(PmLine, double, PmPose)
 o pmMatCartMult(PmRotationMatrix, PmCartesian, PmCartesian)
 o pmMatInv(PmRotationMatrix, PmRotationMatrix)
 o pmMatIsNorm(PmRotationMatrix)
 o pmMatMatMult(PmRotationMatrix, PmRotationMatrix, PmRotationMatrix)
 o pmMatNorm(PmRotationMatrix, PmRotationMatrix)
 o pmMatQuatConvert(PmRotationMatrix, PmQuaternion)
 o pmMatRotConvert(PmRotationMatrix, PmRotationVector)
 o pmMatRpyConvert(PmRotationMatrix, PmRpy)
 o pmMatZyxConvert(PmRotationMatrix, PmEulerZyx)
 o pmMatZyzConvert(PmRotationMatrix, PmEulerZyz)
 o pmPoseCartMult(PmPose, PmCartesian, PmCartesian)
 o pmPoseHomConvert(PmPose, PmHomogeneous)
 o pmPoseInv(PmPose, PmPose)
 o pmPosePoseCompare(PmPose, PmPose)
 o pmPosePoseMult(PmPose, PmPose, PmPose)
 o pmPrintError(String, int)
 o pmQuatAxisAngleMult(PmQuaternion, int, double)
 o pmQuatAxisAngleMult(PmQuaternion, int, double, PmQuaternion)
 o pmQuatCartMult(PmQuaternion, PmCartesian, PmCartesian)
 o pmQuatInv(PmQuaternion, PmQuaternion)
 o pmQuatIsNorm(PmQuaternion)
 o pmQuatMag(PmQuaternion)
 o pmQuatMatConvert(PmQuaternion, PmRotationMatrix)
 o pmQuatNorm(PmQuaternion, PmQuaternion)
 o pmQuatQuatCompare(PmQuaternion, PmQuaternion)
 o pmQuatQuatMult(PmQuaternion, PmQuaternion, PmQuaternion)
 o pmQuatRotConvert(PmQuaternion, PmRotationVector)
 o pmQuatRpyConvert(PmQuaternion, PmRpy)
 o pmQuatScalDiv(PmQuaternion, double, PmQuaternion)
 o pmQuatScalMult(PmQuaternion, double, PmQuaternion)
 o pmQuatZyxConvert(PmQuaternion, PmEulerZyx)
 o pmQuatZyzConvert(PmQuaternion, PmEulerZyz)
 o pmRotIsNorm(PmRotationVector)
 o pmRotMatConvert(PmRotationVector, PmRotationMatrix)
 o pmRotNorm(PmRotationVector, PmRotationVector)
 o pmRotQuatConvert(PmRotationVector, PmQuaternion)
 o pmRotRpyConvert(PmRotationVector, PmRpy)
 o pmRotScalDiv(PmRotationVector, double, PmRotationVector)
 o pmRotScalMult(PmRotationVector, double, PmRotationVector)
 o pmRotZyxConvert(PmRotationVector, PmEulerZyx)
 o pmRotZyzConvert(PmRotationVector, PmEulerZyz)
 o pmRpyMatConvert(PmRpy, PmRotationMatrix)
 o pmRpyQuatConvert(PmRpy, PmQuaternion)
 o pmRpyRotConvert(PmRpy, PmRotationVector)
 o pmRpyZyxConvert(PmRpy, PmEulerZyx)
 o pmRpyZyzConvert(PmRpy, PmEulerZyz)
 o pmSphCartConvert(PmSpherical, PmCartesian)
 o pmSphCylConvert(PmSpherical, PmCylindrical)
 o pmSq(double)
 o pmSqrt(double)
 o pmZyxMatConvert(PmEulerZyx, PmRotationMatrix)
 o pmZyxQuatConvert(PmEulerZyx, PmQuaternion)
 o pmZyxRotConvert(PmEulerZyx, PmRotationVector)
 o pmZyxRpyConvert(PmEulerZyx, PmRpy)
 o pmZyxZyzConvert(PmEulerZyx, PmEulerZyz)
 o pmZyzMatConvert(PmEulerZyz, PmRotationMatrix)
 o pmZyzQuatConvert(PmEulerZyz, PmQuaternion)
 o pmZyzRotConvert(PmEulerZyz, PmRotationVector)
 o pmZyzRpyConvert(PmEulerZyz, PmRpy)
 o proj(PM_CARTESIAN, PM_CARTESIAN)
 o subtract(PM_CARTESIAN, PM_CARTESIAN)
 o subtract(PM_CYLINDRICAL, PM_CYLINDRICAL)
 o toCart(PM_CYLINDRICAL)
 o toCart(PM_SPHERICAL)
 o toCyl(PM_CARTESIAN)
 o toCyl(PM_SPHERICAL)
 o toHom(PM_POSE)
 o toMat(PM_QUATERNION)
 o toMat(PM_ROTATION_VECTOR)
 o toQuat(PM_EULER_ZYX)
 o toQuat(PM_EULER_ZYZ)
 o toQuat(PM_ROTATION_MATRIX)
 o toQuat(PM_ROTATION_VECTOR)
 o toQuat(PM_RPY)
 o toRot(PM_QUATERNION)
 o toSph(PM_CARTESIAN)
 o toSph(PM_CYLINDRICAL)

Variables

 o pmErrno
 public static int pmErrno
 o PM_PRINT_ERROR
 public static boolean PM_PRINT_ERROR
 o debug_on
 public static boolean debug_on
 o CART_FUZZ
 public static final double CART_FUZZ
 o DOUBLECP_FUZZ
 public static final double DOUBLECP_FUZZ
 o DOUBLE_FUZZ
 public static final double DOUBLE_FUZZ
 o E_EPSILON
 public static final double E_EPSILON
 o PM_2_PI
 public static final double PM_2_PI
 o PM_DIV_ERR
 public static final int PM_DIV_ERR
 o PM_ERR
 public static final int PM_ERR
 o PM_IMPL_ERR
 public static final int PM_IMPL_ERR
 o PM_NORM_ERR
 public static final int PM_NORM_ERR
 o PM_PI
 public static final double PM_PI
 o PM_PI_2
 public static final double PM_PI_2
 o PM_PI_4
 public static final double PM_PI_4
 o QSIN_FUZZ
 public static final double QSIN_FUZZ
 o QS_FUZZ
 public static final double QS_FUZZ
 o Q_FUZZ
 public static final double Q_FUZZ
 o RPY_P_FUZZ
 public static final double RPY_P_FUZZ
 o RS_FUZZ
 public static final double RS_FUZZ
 o SINGULAR_EPSILON
 public static final double SINGULAR_EPSILON
 o SQRT_FUZZ
 public static final double SQRT_FUZZ
 o UNIT_QUAT_FUZZ
 public static final double UNIT_QUAT_FUZZ
 o UNIT_SC_FUZZ
 public static final double UNIT_SC_FUZZ
 o UNIT_VEC_FUZZ
 public static final double UNIT_VEC_FUZZ
 o V_FUZZ
 public static final double V_FUZZ
 o ZYX_Y_FUZZ
 public static final double ZYX_Y_FUZZ
 o ZYZ_Y_FUZZ
 public static final double ZYZ_Y_FUZZ
 o DBL_MAX
 public static final double DBL_MAX
 o PI
 public static final double PI
 o PI_2
 public static final double PI_2
 o PI_4
 public static final double PI_4
 o PM_X
 public static final int PM_X
 o PM_Y
 public static final int PM_Y
 o PM_Z
 public static final int PM_Z

Constructors

 o Posemath
 public Posemath()

Methods

 o pmPrintError
 protected static void pmPrintError(String str,
                                    int new_errno) throws PmException
 o IS_FUZZ
 public static boolean IS_FUZZ(double a,
                               double fuzz) throws PmException
 o pmSqrt
 public static double pmSqrt(double x) throws PmException
 o pmSq
 public static double pmSq(double x) throws PmException
 o pmClose
 public static boolean pmClose(double a,
                               double b,
                               double eps)
 o toCyl
 public static PM_CYLINDRICAL toCyl(PM_CARTESIAN v) throws PmException
 o pmCartCylConvert
 public static int pmCartCylConvert(PmCartesian v,
                                    PmCylindrical c) throws PmException
 o toSph
 public static PM_SPHERICAL toSph(PM_CARTESIAN v) throws PmException
 o pmCartSphConvert
 public static int pmCartSphConvert(PmCartesian v,
                                    PmSpherical s) throws PmException
 o toCart
 public static PM_CARTESIAN toCart(PM_SPHERICAL v) throws PmException
 o pmSphCartConvert
 public static int pmSphCartConvert(PmSpherical s,
                                    PmCartesian v) throws PmException
 o toCyl
 public static PM_CYLINDRICAL toCyl(PM_SPHERICAL s) throws PmException
 o pmSphCylConvert
 public static int pmSphCylConvert(PmSpherical s,
                                   PmCylindrical c) throws PmException
 o toCart
 public static PM_CARTESIAN toCart(PM_CYLINDRICAL v) throws PmException
 o pmCylCartConvert
 public static int pmCylCartConvert(PmCylindrical c,
                                    PmCartesian v) throws PmException
 o toSph
 public static PM_SPHERICAL toSph(PM_CYLINDRICAL c) throws PmException
 o pmCylSphConvert
 public static int pmCylSphConvert(PmCylindrical c,
                                   PmSpherical s) throws PmException
 o pmAxisAngleQuatConvert
 public static int pmAxisAngleQuatConvert(int axis,
                                          double a,
                                          PmQuaternion q) throws PmException
 o toQuat
 public static PM_QUATERNION toQuat(PM_ROTATION_VECTOR v) throws PmException
 o pmRotQuatConvert
 public static int pmRotQuatConvert(PmRotationVector r,
                                    PmQuaternion q) throws PmException
 o toMat
 public static PM_ROTATION_MATRIX toMat(PM_ROTATION_VECTOR v) throws PmException
 o pmRotMatConvert
 public static int pmRotMatConvert(PmRotationVector r,
                                   PmRotationMatrix m) throws PmException
 o pmRotZyzConvert
 public static int pmRotZyzConvert(PmRotationVector r,
                                   PmEulerZyz zyz) throws PmException
 o pmRotZyxConvert
 public static int pmRotZyxConvert(PmRotationVector r,
                                   PmEulerZyx zyx) throws PmException
 o pmRotRpyConvert
 public static int pmRotRpyConvert(PmRotationVector r,
                                   PmRpy rpy) throws PmException
 o toRot
 public static PM_ROTATION_VECTOR toRot(PM_QUATERNION v) throws PmException
 o pmQuatRotConvert
 public static int pmQuatRotConvert(PmQuaternion q,
                                    PmRotationVector r) throws PmException
 o toMat
 public static PM_ROTATION_MATRIX toMat(PM_QUATERNION v) throws PmException
 o pmQuatMatConvert
 public static int pmQuatMatConvert(PmQuaternion q,
                                    PmRotationMatrix m) throws PmException
 o pmQuatZyzConvert
 public static int pmQuatZyzConvert(PmQuaternion q,
                                    PmEulerZyz zyz) throws PmException
 o pmQuatZyxConvert
 public static int pmQuatZyxConvert(PmQuaternion q,
                                    PmEulerZyx zyx) throws PmException
 o pmQuatRpyConvert
 public static int pmQuatRpyConvert(PmQuaternion q,
                                    PmRpy rpy) throws PmException
 o pmMatRotConvert
 public static int pmMatRotConvert(PmRotationMatrix m,
                                   PmRotationVector r) throws PmException
 o toQuat
 public static PM_QUATERNION toQuat(PM_ROTATION_MATRIX m) throws PmException
 o pmMatQuatConvert
 public static int pmMatQuatConvert(PmRotationMatrix m,
                                    PmQuaternion q) throws PmException
 o pmMatZyzConvert
 public static int pmMatZyzConvert(PmRotationMatrix m,
                                   PmEulerZyz zyz) throws PmException
 o pmMatZyxConvert
 public static int pmMatZyxConvert(PmRotationMatrix m,
                                   PmEulerZyx zyx) throws PmException
 o pmMatRpyConvert
 public static int pmMatRpyConvert(PmRotationMatrix m,
                                   PmRpy rpy) throws PmException
 o pmZyzRotConvert
 public static int pmZyzRotConvert(PmEulerZyz zyz,
                                   PmRotationVector r) throws PmException
 o toQuat
 public static PM_QUATERNION toQuat(PM_EULER_ZYZ v) throws PmException
 o pmZyzQuatConvert
 public static int pmZyzQuatConvert(PmEulerZyz zyz,
                                    PmQuaternion q) throws PmException
 o pmZyzMatConvert
 public static int pmZyzMatConvert(PmEulerZyz zyz,
                                   PmRotationMatrix m) throws PmException
 o pmZyzRpyConvert
 public static int pmZyzRpyConvert(PmEulerZyz zyz,
                                   PmRpy rpy) throws PmException
 o pmZyxRotConvert
 public static int pmZyxRotConvert(PmEulerZyx zyx,
                                   PmRotationVector r) throws PmException
 o toQuat
 public static PM_QUATERNION toQuat(PM_EULER_ZYX v) throws PmException
 o pmZyxQuatConvert
 public static int pmZyxQuatConvert(PmEulerZyx zyx,
                                    PmQuaternion q) throws PmException
 o pmZyxMatConvert
 public static int pmZyxMatConvert(PmEulerZyx zyx,
                                   PmRotationMatrix m) throws PmException
 o pmZyxZyzConvert
 public static int pmZyxZyzConvert(PmEulerZyx zyx,
                                   PmEulerZyz zyz) throws PmException
 o pmZyxRpyConvert
 public static int pmZyxRpyConvert(PmEulerZyx zyx,
                                   PmRpy rpy) throws PmException
 o pmRpyRotConvert
 public static int pmRpyRotConvert(PmRpy rpy,
                                   PmRotationVector r) throws PmException
 o toQuat
 public static PM_QUATERNION toQuat(PM_RPY v) throws PmException
 o pmRpyQuatConvert
 public static int pmRpyQuatConvert(PmRpy rpy,
                                    PmQuaternion q) throws PmException
 o pmRpyMatConvert
 public static int pmRpyMatConvert(PmRpy rpy,
                                   PmRotationMatrix m) throws PmException
 o pmRpyZyzConvert
 public static int pmRpyZyzConvert(PmRpy rpy,
                                   PmEulerZyz zyz) throws PmException
 o pmRpyZyxConvert
 public static int pmRpyZyxConvert(PmRpy rpy,
                                   PmEulerZyx zyx) throws PmException
 o toHom
 public static PM_HOMOGENEOUS toHom(PM_POSE p) throws PmException
 o pmPoseHomConvert
 public static int pmPoseHomConvert(PmPose p,
                                    PmHomogeneous h) throws PmException
 o pmHomPoseConvert
 public static int pmHomPoseConvert(PmHomogeneous h,
                                    PmPose p) throws PmException
 o pmCartCartCompare
 public static boolean pmCartCartCompare(PmCartesian v1,
                                         PmCartesian v2) throws PmException
 o dot
 public static double dot(PM_CARTESIAN v1,
                          PM_CARTESIAN v2) throws PmException
 o pmCartCartDot
 public static double pmCartCartDot(PmCartesian v1,
                                    PmCartesian v2) throws PmException
 o cross
 public static PM_CARTESIAN cross(PM_CARTESIAN v1,
                                  PM_CARTESIAN v2) throws PmException
 o pmCartCartCross
 public static int pmCartCartCross(PmCartesian v1,
                                   PmCartesian v2,
                                   PmCartesian vout) throws PmException
 o mag
 public static double mag(PM_CARTESIAN v) throws PmException
 o pmCartMag
 public static double pmCartMag(PmCartesian v) throws PmException
 o disp
 public static double disp(PM_CARTESIAN v1,
                           PM_CARTESIAN v2) throws PmException
 o pmCartCartDisp
 public static double pmCartCartDisp(PmCartesian v1,
                                     PmCartesian v2) throws PmException
 o add
 public static PM_CARTESIAN add(PM_CARTESIAN v1,
                                PM_CARTESIAN v2) throws PmException
 o pmCartCartAdd
 public static int pmCartCartAdd(PmCartesian v1,
                                 PmCartesian v2,
                                 PmCartesian vout) throws PmException
 o subtract
 public static PM_CARTESIAN subtract(PM_CARTESIAN v1,
                                     PM_CARTESIAN v2) throws PmException
 o pmCartCartSub
 public static int pmCartCartSub(PmCartesian v1,
                                 PmCartesian v2,
                                 PmCartesian vout) throws PmException
 o multiply
 public static PM_CARTESIAN multiply(double d,
                                     PM_CARTESIAN v) throws PmException
 o multiply
 public static PM_CARTESIAN multiply(PM_CARTESIAN v,
                                     double d) throws PmException
 o pmCartScalMult
 public static int pmCartScalMult(PmCartesian v1,
                                  double d,
                                  PmCartesian vout) throws PmException
 o divide
 public static PM_CARTESIAN divide(PM_CARTESIAN v,
                                   double d) throws PmException
 o pmCartScalDiv
 public static int pmCartScalDiv(PmCartesian v1,
                                 double d,
                                 PmCartesian vout) throws PmException
 o neg
 public static PM_CARTESIAN neg(PM_CARTESIAN v) throws PmException
 o pmCartNeg
 public static int pmCartNeg(PmCartesian v1,
                             PmCartesian vout) throws PmException
 o inv
 public static PM_CARTESIAN inv(PM_CARTESIAN v) throws PmException
 o pmCartInv
 public static int pmCartInv(PmCartesian v1,
                             PmCartesian vout) throws PmException
 o norm
 public static PM_CARTESIAN norm(PM_CARTESIAN v) throws PmException
 o pmCartNorm
 public static int pmCartNorm(PmCartesian v,
                              PmCartesian vout) throws PmException
 o isNorm
 public static boolean isNorm(PM_CARTESIAN v) throws PmException
 o pmCartIsNorm
 public static boolean pmCartIsNorm(PmCartesian v) throws PmException
 o proj
 public static PM_CARTESIAN proj(PM_CARTESIAN v1,
                                 PM_CARTESIAN v2) throws PmException
 o pmCartCartProj
 public static int pmCartCartProj(PmCartesian v1,
                                  PmCartesian v2,
                                  PmCartesian vout) throws PmException
 o pmCartPlaneProj
 public static int pmCartPlaneProj(PmCartesian v,
                                   PmCartesian normal,
                                   PmCartesian vout) throws PmException
 o add
 public static PM_CYLINDRICAL add(PM_CYLINDRICAL c1,
                                  PM_CYLINDRICAL c2) throws PmException
 o pmCylCylAdd
 public static int pmCylCylAdd(PmCylindrical c1,
                               PmCylindrical c2,
                               PmCylindrical cout) throws PmException
 o subtract
 public static PM_CYLINDRICAL subtract(PM_CYLINDRICAL c1,
                                       PM_CYLINDRICAL c2) throws PmException
 o pmCylCylSub
 public static int pmCylCylSub(PmCylindrical c1,
                               PmCylindrical c2,
                               PmCylindrical cout) throws PmException
 o multiply
 public static PM_CYLINDRICAL multiply(double d,
                                       PM_CYLINDRICAL c) throws PmException
 o multiply
 public static PM_CYLINDRICAL multiply(PM_CYLINDRICAL c,
                                       double d) throws PmException
 o pmCylScalMult
 public static int pmCylScalMult(PmCylindrical v1,
                                 double d,
                                 PmCylindrical vout) throws PmException
 o divide
 public static PM_CYLINDRICAL divide(PM_CYLINDRICAL c,
                                     double d) throws PmException
 o pmCylScalDiv
 public static int pmCylScalDiv(PmCylindrical v1,
                                double d,
                                PmCylindrical vout) throws PmException
 o pmCylCylCompare
 public static boolean pmCylCylCompare(PmCylindrical v1,
                                       PmCylindrical v2) throws PmException
 o dot
 public static double dot(PM_CYLINDRICAL v1,
                          PM_CYLINDRICAL v2) throws PmException
 o pmCylCylDot
 public static double pmCylCylDot(PmCylindrical c1,
                                  PmCylindrical c2) throws PmException
 o mag
 public static double mag(PM_CYLINDRICAL v1) throws PmException
 o pmCylMag
 public static double pmCylMag(PmCylindrical c) throws PmException
 o cross
 public static PM_CYLINDRICAL cross(PM_CYLINDRICAL v1,
                                    PM_CYLINDRICAL v2) throws PmException
 o pmCylCylCross
 public static int pmCylCylCross(PmCylindrical c1,
                                 PmCylindrical c2,
                                 PmCylindrical cout) throws PmException
 o neg
 public static PM_CYLINDRICAL neg(PM_CYLINDRICAL v) throws PmException
 o pmCylNeg
 public static int pmCylNeg(PmCylindrical v1,
                            PmCylindrical vout) throws PmException
 o norm
 public static PM_CYLINDRICAL norm(PM_CYLINDRICAL v) throws PmException
 o pmCylNorm
 public static int pmCylNorm(PmCylindrical v,
                             PmCylindrical vout) throws PmException
 o inv
 public static PM_CYLINDRICAL inv(PM_CYLINDRICAL v) throws PmException
 o pmCylInv
 public static int pmCylInv(PmCylindrical v,
                            PmCylindrical vout) throws PmException
 o isNorm
 public static boolean isNorm(PM_CYLINDRICAL v) throws PmException
 o pmCylIsNorm
 public static boolean pmCylIsNorm(PmCylindrical v) throws PmException
 o pmQuatAxisAngleMult
 public static PmQuaternion pmQuatAxisAngleMult(PmQuaternion q,
                                                int axis,
                                                double angle) throws PmException
 o pmQuatAxisAngleMult
 public static int pmQuatAxisAngleMult(PmQuaternion q,
                                       int axis,
                                       double angle,
                                       PmQuaternion pq) throws PmException
 o multiply
 public static PM_ROTATION_VECTOR multiply(PM_ROTATION_VECTOR r,
                                           double s) throws PmException
 o multiply
 public static PmRotationVector multiply(double s,
                                         PM_ROTATION_VECTOR r) throws PmException
 o pmRotScalMult
 public static int pmRotScalMult(PmRotationVector r,
                                 double s,
                                 PmRotationVector rout) throws PmException
 o divide
 public static PM_ROTATION_VECTOR divide(PM_ROTATION_VECTOR r,
                                         double s) throws PmException
 o pmRotScalDiv
 public static int pmRotScalDiv(PmRotationVector r,
                                double s,
                                PmRotationVector rout) throws PmException
 o isNorm
 public static boolean isNorm(PM_ROTATION_VECTOR r) throws PmException
 o pmRotIsNorm
 public static boolean pmRotIsNorm(PmRotationVector r) throws PmException
 o norm
 public static PM_ROTATION_VECTOR norm(PM_ROTATION_VECTOR r) throws PmException
 o pmRotNorm
 public static int pmRotNorm(PmRotationVector r,
                             PmRotationVector rout) throws PmException
 o pmMatNorm
 public static int pmMatNorm(PmRotationMatrix m,
                             PmRotationMatrix mout) throws PmException
 o isNorm
 public static boolean isNorm(PM_ROTATION_MATRIX m) throws PmException
 o pmMatIsNorm
 public static boolean pmMatIsNorm(PmRotationMatrix m) throws PmException
 o pmMatInv
 public static int pmMatInv(PmRotationMatrix m,
                            PmRotationMatrix mout) throws PmException
 o multiply
 public static PM_CARTESIAN multiply(PM_ROTATION_MATRIX m,
                                     PM_CARTESIAN v) throws PmException
 o pmMatCartMult
 public static int pmMatCartMult(PmRotationMatrix m,
                                 PmCartesian v,
                                 PmCartesian vout) throws PmException
 o multiply
 public static PM_ROTATION_MATRIX multiply(PM_ROTATION_MATRIX m1,
                                           PM_ROTATION_MATRIX m2) throws PmException
 o pmMatMatMult
 public static int pmMatMatMult(PmRotationMatrix m1,
                                PmRotationMatrix m2,
                                PmRotationMatrix mout) throws PmException
 o pmQuatQuatCompare
 public static boolean pmQuatQuatCompare(PmQuaternion q1,
                                         PmQuaternion q2) throws PmException
 o mag
 public static double mag(PM_QUATERNION q) throws PmException
 o pmQuatMag
 public static double pmQuatMag(PmQuaternion q) throws PmException
 o norm
 public static PM_QUATERNION norm(PM_QUATERNION q1) throws PmException
 o pmQuatNorm
 public static int pmQuatNorm(PmQuaternion q1,
                              PmQuaternion qout) throws PmException
 o inv
 public static PM_QUATERNION inv(PM_QUATERNION q1) throws PmException
 o pmQuatInv
 public static int pmQuatInv(PmQuaternion q1,
                             PmQuaternion qout) throws PmException
 o isNorm
 public static boolean isNorm(PM_QUATERNION q1) throws PmException
 o pmQuatIsNorm
 public static boolean pmQuatIsNorm(PmQuaternion q1) throws PmException
 o multiply
 public static PM_QUATERNION multiply(PM_QUATERNION q,
                                      double s) throws PmException
 o multiply
 public static PM_QUATERNION multiply(double s,
                                      PM_QUATERNION q) throws PmException
 o pmQuatScalMult
 public static int pmQuatScalMult(PmQuaternion q,
                                  double s,
                                  PmQuaternion qout) throws PmException
 o divide
 public static PM_QUATERNION divide(PM_QUATERNION q,
                                    double s) throws PmException
 o pmQuatScalDiv
 public static int pmQuatScalDiv(PmQuaternion q,
                                 double s,
                                 PmQuaternion qout) throws PmException
 o multiply
 public static PM_QUATERNION multiply(PM_QUATERNION q1,
                                      PM_QUATERNION q2) throws PmException
 o pmQuatQuatMult
 public static int pmQuatQuatMult(PmQuaternion q1,
                                  PmQuaternion q2,
                                  PmQuaternion qout) throws PmException
 o multiply
 public static PM_CARTESIAN multiply(PM_QUATERNION q1,
                                     PM_CARTESIAN v2) throws PmException
 o pmQuatCartMult
 public static int pmQuatCartMult(PmQuaternion q1,
                                  PmCartesian v2,
                                  PmCartesian vout) throws PmException
 o pmPosePoseCompare
 public static boolean pmPosePoseCompare(PmPose p1,
                                         PmPose p2) throws PmException
 o inv
 public static PM_POSE inv(PM_POSE p) throws PmException
 o pmPoseInv
 public static int pmPoseInv(PmPose p1,
                             PmPose p2) throws PmException
 o multiply
 public static PM_CARTESIAN multiply(PM_POSE p1,
                                     PM_CARTESIAN v2) throws PmException
 o pmPoseCartMult
 public static int pmPoseCartMult(PmPose p1,
                                  PmCartesian v2,
                                  PmCartesian vout) throws PmException
 o multiply
 public static PM_POSE multiply(PM_POSE p1,
                                PM_POSE p2) throws PmException
 o pmPosePoseMult
 public static int pmPosePoseMult(PmPose p1,
                                  PmPose p2,
                                  PmPose pout) throws PmException
 o inv
 public static PM_HOMOGENEOUS inv(PM_HOMOGENEOUS h) throws PmException
 o pmHomInv
 public static int pmHomInv(PmHomogeneous h1,
                            PmHomogeneous h2) throws PmException
 o pmLineInit
 public static int pmLineInit(PmLine line,
                              PmPose start,
                              PmPose end) throws PmException
 o pmLinePoint
 public static int pmLinePoint(PmLine line,
                               double len,
                               PmPose point) throws PmException
 o pmCircleInit
 public static int pmCircleInit(PmCircle circle,
                                PmPose start,
                                PmPose end,
                                PmCartesian center,
                                PmCartesian normal,
                                int turn) throws PmException
 o pmCirclePoint
 public static int pmCirclePoint(PmCircle circle,
                                 double angle,
                                 PmPose point) throws PmException

All Packages  Class Hierarchy  This Package  Previous  Next  Index