VcstMath.h

Go to the documentation of this file.

/*******************************************************************************
 *
 * NAME:  VcstMath.h
 *
 * DESCRIPTION: This is the header file for the VcstMath object class.
 *
 * Adapted directly from the IDPS file ProCmnMath.h published
 * by Raytheon Company.
 *
 *******************************************************************************/
 
#ifndef VcstMath_h
#define VcstMath_h
 
#include <math.h>
#include <VcstCmnConsts.h>
 
class VcstMath {
public:
 
    static double calculateMag(const double aVector[VEC_SIZE]);
 
    static double calcQuatMag(const double aQuat[QUAT_SIZE]);
 
    static void calculateCross(const double aUvector[VEC_SIZE],
            const double aVvector[VEC_SIZE], double anOutVector[VEC_SIZE]);
 
    static double calculateDot(const double aUvector[VEC_SIZE],
            const double aVvector[VEC_SIZE]);
 
    static double calculateDotQuat(const double aUquat[QUAT_SIZE],
            const double aVquat[QUAT_SIZE]);
 
    static void applyScalar(const double aScalar, double aVector[VEC_SIZE]);
 
    static void applyScalarQuat(const double aScalar, double aQuat[QUAT_SIZE]);
 
    static void conjugateQuat(const double aQuat[QUAT_SIZE],
            double outQuat[QUAT_SIZE]);
 
    static void quatMultiply(const double q1[QUAT_SIZE],
            const double q2[QUAT_SIZE], double outQuat[QUAT_SIZE]);
 
    static void quatMultiplyMatrix(const double q1[QUAT_SIZE],
            const double q2[QUAT_SIZE], double outQuat[QUAT_SIZE]);
 
    static void matrixMultiply(const double aM1[VEC_SIZE][VEC_SIZE],
            const double aM2[VEC_SIZE][VEC_SIZE],
            double outMatrix[VEC_SIZE][VEC_SIZE]);
 
    static void matrixMultiply(const int dimM, const int dimN, const int dimP,
            const double *aMByN, const double *aNByP, double *outMatrix);
 
    static void transposeMatrix(const double inMatrix[VEC_SIZE][VEC_SIZE],
            double outMatrix[VEC_SIZE][VEC_SIZE]);
 
    static void transposeQuat(const double inQuat[QUAT_SIZE],
            double outQuat[QUAT_SIZE]);
 
    static void printMatrixCOut(const double aMatrix[VEC_SIZE][VEC_SIZE]);
 
    static void printVectorCOut(const double aVector[VEC_SIZE]);
 
    static void printQuaternionCOut(const double aQuat[QUAT_SIZE]);
 
    static void matrixVectorProduct(const double aMatrix[VEC_SIZE][VEC_SIZE],
            const double aVector[VEC_SIZE], double outVec[VEC_SIZE]);
 
    static void calculateUnitVector(const double aVector[VEC_SIZE],
            double unitVector[VEC_SIZE]);
 
    static void normalizeQuat(double aQuat[QUAT_SIZE]);
 
    static void inverseMatrix(const double matA[VEC_SIZE][VEC_SIZE],
            double matR[VEC_SIZE][VEC_SIZE]);
 
    static void rotationMatrix(const double angle, const short axis,
            double outMatrix[VEC_SIZE][VEC_SIZE]);
 
    static double calculateDeterminant(const double matA[VEC_SIZE][VEC_SIZE]);
 
    static void cofactorMatrix(const double matA[VEC_SIZE][VEC_SIZE],
            double cof[VEC_SIZE][VEC_SIZE]);
 
};
 
#endif