LinearAlgebra.h

Go to the documentation of this file.

#ifndef LinearAlgebra_h
#define LinearAlgebra_h
/* SPDX-License-Identifier: CC0-1.0 */
// std library
#include <iostream>
 
// boost library
#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/vector_sparse.hpp>
#include <boost/numeric/ublas/io.hpp>
 
// Qt Library
#include <QDebug>
#include <QPair>
 
// Prevent Boost from outputing debug information to
// standard error when throwing exceptions.
#define BOOST_UBLAS_NO_STD_CERR
 
namespace Isis {
  class Angle;
  class Distance;
  class Latitude;
  class Longitude;
  class LinearAlgebra {
    public:
      typedef boost::numeric::ublas::matrix<double> Matrix;
      typedef boost::numeric::ublas::symmetric_matrix<double, boost::numeric::ublas::upper> SymmetricMatrix;
      typedef boost::numeric::ublas::symmetric_matrix<double, boost::numeric::ublas::upper> MatrixUpperTriangular;
      typedef boost::numeric::ublas::vector<double> Vector;
       typedef boost::numeric::ublas::compressed_vector<double> VectorCompressed;
 
      // define AxisAngle and EulerAngle
      typedef QPair<Vector, Angle> AxisAngle;
      typedef QPair<Angle, int> EulerAngle;
 
      // check type of matrix/vector
      static bool isIdentity(const Matrix &matrix);
      static bool isOrthogonal(const Matrix &matrix);
      static bool isRotationMatrix(const Matrix &matrix);
      static bool isZero(const Matrix &matrix);
      static bool isZero(const Vector &vector);
      static bool isEmpty(const Vector &vector);
      static bool isUnit(const Vector &vector);
 
      // create special matrices
      static Matrix identity(int size);
      static Matrix transpose(const Matrix &matrix);
      static Matrix inverse(const Matrix &matrix);
      static Matrix pseudoinverse(const Matrix &matrix);
      static Matrix zeroMatrix(int rows, int columns);
      static Vector zeroVector(int size);
 
      //
      static double determinant(const Matrix &matrix);
 
      // magnitude/norm based calculations
      static Vector normalize(const Vector &vector);
      static double magnitude(const Vector &vector);
      static double absoluteMaximum(const Vector &vector);
 
      // arithmetic operations
      static Matrix multiply(const Matrix &matrix1, const Matrix &matrix2);
      static Vector multiply(const Matrix &matrix, const Vector &vector);
      static Vector multiply(double scalar, const Vector &vector);
      static Matrix multiply(double scalar, const Matrix &matrix);
      static Vector add(const Vector &vector1, const Vector &vector2);
      static Vector subtract(const Vector &vector1, const Vector &vector2);
 
      // vector products
      static Vector crossProduct(const Vector &vector1, const Vector &vector2);
      static Vector normalizedCrossProduct(const Vector &vector1, const Vector &vector2);
      static Matrix outerProduct(const Vector &vector1, const Vector &vector2);
      static double dotProduct(const Vector &vector1, const Vector &vector2);
      static double innerProduct(const Vector &vector1, const Vector &vector2);
 
      // vector movements (projections, rotations)
      static Vector project(const Vector &vector1, const Vector &vector2);
      static Vector rotate(const Vector &vector, const Vector &axis, Angle angle);
 
      //
      static Vector perpendicular(const Vector &vector1, const Vector &vector2);
 
      // converters
      static AxisAngle toAxisAngle(const Matrix &rotationMatrix);//raxisa
      static Matrix toMatrix(const AxisAngle &axisAngle); // axisar
      static Matrix toMatrix(const Vector &axis, Angle angle); // axisar
 
      static QList<EulerAngle> toEulerAngles(const Matrix &rotationMatrix, const QList<int> axes);// m2eul
      static Matrix toMatrix(const QList<EulerAngle> &eulerAngles); // eul2m
      static Matrix toMatrix(const EulerAngle &angle3, const EulerAngle &angle2, const EulerAngle &angle1); // eul2m
 
      static Vector toQuaternion(const Matrix &rotationMatrix);// m2q
      static Matrix toMatrix(const Vector &quaternion);// q2m
 
      //Matrix row/col to vector and vector to row/columns
      static void setRow(Matrix &matrix, const Vector &vector, int rowIndex);
      static void setColumn(Matrix &matrix, const Vector &vector, int columnIndex);
      static Vector row(const Matrix &matrix, int rowIndex);
      static Vector column(const Matrix &matrix, int columnIndex);
 
      static void setVec3(Vector *v, double v0, double v1, double v2);
      static void setVec4(Vector *v, double v0, double v1, double v2, double v3);
      static Vector vector(double v0, double v1, double v2);
      static Vector vector(double v0, double v1, double v2, double v3);
 
      static Vector subVector(const Vector &v, int start, int size);
 
      // No need to implement the std::cout operator<< since this is already
      // done in boost/numeric/ublas/io.hpp, which is included above
      // The print format for a size 3 vector is
      // [3] (1, 2, 3)
      //
      // friend ostream &operator<<(ostream &os, LinearAlgebra::Vector &vector);
 
    protected:
      LinearAlgebra();
      ~LinearAlgebra();
 
    private:
  };
 
  // these must be declared outside of the class (at the end since they must be
  // declared after the typedefs)
  QDebug operator<<(QDebug dbg, const LinearAlgebra::Vector &vector);
  QDebug operator<<(QDebug dbg, const LinearAlgebra::Matrix &matrix);
  QString toString(const LinearAlgebra::Vector &vector, int precision=15);
};
 
#endif