matrixutils.h

Go to the documentation of this file.

#ifndef ION_MATH_MATRIXUTILS_H_
#define ION_MATH_MATRIXUTILS_H_


#include "ion/math/matrix.h"
#include "ion/math/utils.h"
#include "ion/math/vector.h"

namespace ion {
namespace math {




namespace internal {

template <int Dimension, typename T, typename VectorType>
VectorType MultiplyMatrixAndVector(const Matrix<Dimension, T>& m,
                                   const VectorType& v) {
  VectorType result = VectorType::Zero();
  for (int row = 0; row < Dimension; ++row) {
    for (int col = 0; col < Dimension; ++col)
      result[row] += m(row, col) * v[col];
  }
  return result;
}

}  // namespace internal




template <int Dimension, typename T>
Matrix<Dimension, T> Transpose(const Matrix<Dimension, T>& m) {
  Matrix<Dimension, T> result;
  for (int row = 0; row < Dimension; ++row) {
    for (int col = 0; col < Dimension; ++col)
      result(row, col) = m(col, row);
  }
  return result;
}

template <int Dimension, typename T>
inline Vector<Dimension, T> operator*(const Matrix<Dimension, T>& m,
                                      const Vector<Dimension, T>& v) {
  return internal::MultiplyMatrixAndVector(m, v);
}

template <int Dimension, typename T>
inline Point<Dimension, T> operator*(const Matrix<Dimension, T>& m,
                                     const Point<Dimension, T>& p) {
  return internal::MultiplyMatrixAndVector(m, p);
}

template <int Dimension, typename T>
Vector<Dimension, T> Row(const Matrix<Dimension, T>& m, int row) {
  Vector<Dimension, T> result;
  for (int col = 0; col < Dimension; ++col)
    result[col] = m(row, col);
  return result;
}

template <int Dimension, typename T>
Vector<Dimension, T> Column(const Matrix<Dimension, T>& m, int col) {
  Vector<Dimension, T> result;
  for (int row = 0; row < Dimension; ++row)
    result[row] = m(row, col);
  return result;
}

template <int Dimension, typename T> ION_API
T Determinant(const Matrix<Dimension, T>& m);

template <int Dimension, typename T> ION_API
Matrix<Dimension, T> CofactorMatrix(const Matrix<Dimension, T>& m);

template <int Dimension, typename T> ION_API
Matrix<Dimension, T> AdjugateWithDeterminant(
    const Matrix<Dimension, T>& m, T* determinant);

template <int Dimension, typename T>
Matrix<Dimension, T> Adjugate(const Matrix<Dimension, T>& m) {
  return AdjugateWithDeterminant<Dimension, T>(m, static_cast<T*>(NULL));
}

template <int Dimension, typename T> ION_API
Matrix<Dimension, T> InverseWithDeterminant(
    const Matrix<Dimension, T>& m, T* determinant);

template <int Dimension, typename T>
inline Matrix<Dimension, T> Inverse(const Matrix<Dimension, T>& m) {
  return InverseWithDeterminant<Dimension, T>(m, static_cast<T*>(NULL));
}

template <int Dimension, typename T>
static bool MatricesAlmostEqual(const Matrix<Dimension, T>& m0,
                                const Matrix<Dimension, T>& m1, T tolerance) {
  for (int row = 0; row < Dimension; ++row) {
    for (int col = 0; col < Dimension; ++col) {
      if (Abs(m0(row, col) - m1(row, col)) > tolerance)
        return false;
    }
  }
  return true;
}

template <int Dimension, typename T>
bool MatrixAlmostOrthogonal(const Matrix<Dimension, T>& m, T tolerance);

template <typename T>
inline static void ScaleTranslationComponent(Matrix<4, T>* matrix, T scale) {
  (*matrix)(0, 3) *= scale;
  (*matrix)(1, 3) *= scale;
  (*matrix)(2, 3) *= scale;
}

}  // namespace math
}  // namespace ion

#endif  // ION_MATH_MATRIXUTILS_H_