matrix3x3.h

Go to the documentation of this file.

// Copyright (c) 2018 Doyub Kim
//
// I am making my contributions/submissions to this project solely in my
// personal capacity and am not conveying any rights to any intellectual
// property of any third parties.
 
#ifndef INCLUDE_JET_MATRIX3X3_H_
#define INCLUDE_JET_MATRIX3X3_H_
 
#include <jet/matrix.h>
#include <jet/vector3.h>
 
#include <array>
#include <limits>
 
namespace jet {
 
template <typename T>
class Matrix<T, 3, 3> {
 public:
    static_assert(std::is_floating_point<T>::value,
                  "Matrix only can be instantiated with floating point types");
 
    // MARK: Constructors
 
    Matrix();
 
    explicit Matrix(T s);
 
    Matrix(T m00, T m01, T m02, T m10, T m11, T m12, T m20, T m21, T m22);
 
    template <typename U>
    Matrix(const std::initializer_list<std::initializer_list<U>>& lst);
 
    Matrix(const Matrix& m);
 
    explicit Matrix(const T* arr);
 
    // MARK: Basic setters
 
    void set(T s);
 
    void set(T m00, T m01, T m02, T m10, T m11, T m12, T m20, T m21, T m22);
 
    template <typename U>
    void set(const std::initializer_list<std::initializer_list<U>>& lst);
 
    void set(const Matrix& m);
 
    void set(const T* arr);
 
    void setDiagonal(T s);
 
    void setOffDiagonal(T s);
 
    void setRow(size_t i, const Vector3<T>& row);
 
    void setColumn(size_t i, const Vector3<T>& col);
 
    // MARK: Basic getters
 
    bool isSimilar(const Matrix& m,
                   double tol = std::numeric_limits<double>::epsilon()) const;
 
    bool isSquare() const;
 
    size_t rows() const;
 
    size_t cols() const;
 
    T* data();
 
    const T* data() const;
 
    // MARK: Binary operator methods - new instance = this instance (+) input
    Matrix add(T s) const;
 
    Matrix add(const Matrix& m) const;
 
    Matrix sub(T s) const;
 
    Matrix sub(const Matrix& m) const;
 
    Matrix mul(T s) const;
 
    Vector3<T> mul(const Vector3<T>& v) const;
 
    Matrix mul(const Matrix& m) const;
 
    Matrix div(T s) const;
 
    // MARK: Binary operator methods - new instance = input (+) this instance
    Matrix radd(T s) const;
 
    Matrix radd(const Matrix& m) const;
 
    Matrix rsub(T s) const;
 
    Matrix rsub(const Matrix& m) const;
 
    Matrix rmul(T s) const;
 
    Matrix rmul(const Matrix& m) const;
 
    Matrix rdiv(T s) const;
 
    // MARK: Augmented operator methods - this instance (+)= input
    void iadd(T s);
 
    void iadd(const Matrix& m);
 
    void isub(T s);
 
    void isub(const Matrix& m);
 
    void imul(T s);
 
    void imul(const Matrix& m);
 
    void idiv(T s);
 
    // MARK: Modifiers
    void transpose();
 
    void invert();
 
    // MARK: Complex getters
    T sum() const;
 
    T avg() const;
 
    T min() const;
 
    T max() const;
 
    T absmin() const;
 
    T absmax() const;
 
    T trace() const;
 
    T determinant() const;
 
    Matrix diagonal() const;
 
    Matrix offDiagonal() const;
 
    Matrix strictLowerTri() const;
 
    Matrix strictUpperTri() const;
 
    Matrix lowerTri() const;
 
    Matrix upperTri() const;
 
    Matrix transposed() const;
 
    Matrix inverse() const;
 
    T frobeniusNorm() const;
 
    template <typename U>
    Matrix<U, 3, 3> castTo() const;
 
    // MARK: Setter operators
    Matrix& operator=(const Matrix& m);
 
    Matrix& operator+=(T s);
 
    Matrix& operator+=(const Matrix& m);
 
    Matrix& operator-=(T s);
 
    Matrix& operator-=(const Matrix& m);
 
    Matrix& operator*=(T s);
 
    Matrix& operator*=(const Matrix& m);
 
    Matrix& operator/=(T s);
 
    // MARK: Getter operators
    T& operator[](size_t i);
 
    const T& operator[](size_t i) const;
 
    T& operator()(size_t i, size_t j);
 
    const T& operator()(size_t i, size_t j) const;
 
    bool operator==(const Matrix& m) const;
 
    bool operator!=(const Matrix& m) const;
 
    // MARK: Helpers
    static Matrix makeZero();
 
    static Matrix makeIdentity();
 
    static Matrix makeScaleMatrix(T sx, T sy, T sz);
 
    static Matrix makeScaleMatrix(const Vector3<T>& s);
 
    static Matrix makeRotationMatrix(const Vector3<T>& axis, T rad);
 
 private:
    std::array<T, 9> _elements;
};
 
template <typename T>
using Matrix3x3 = Matrix<T, 3, 3>;
 
// Operator overloadings
template <typename T>
Matrix3x3<T> operator-(const Matrix3x3<T>& a);
 
template <typename T>
Matrix3x3<T> operator+(const Matrix3x3<T>& a, const Matrix3x3<T>& b);
 
template <typename T>
Matrix3x3<T> operator+(const Matrix3x3<T>& a, T b);
 
template <typename T>
Matrix3x3<T> operator+(T a, const Matrix3x3<T>& b);
 
template <typename T>
Matrix3x3<T> operator-(const Matrix3x3<T>& a, const Matrix3x3<T>& b);
 
template <typename T>
Matrix3x3<T> operator-(const Matrix3x3<T>& a, T b);
 
template <typename T>
Matrix3x3<T> operator-(T a, const Matrix3x3<T>& b);
 
template <typename T>
Matrix3x3<T> operator*(const Matrix3x3<T>& a, T b);
 
template <typename T>
Matrix3x3<T> operator*(T a, const Matrix3x3<T>& b);
 
template <typename T>
Vector3<T> operator*(const Matrix3x3<T>& a, const Vector3<T>& b);
 
template <typename T>
Matrix3x3<T> operator*(const Matrix3x3<T>& a, const Matrix3x3<T>& b);
 
template <typename T>
Matrix3x3<T> operator/(const Matrix3x3<T>& a, T b);
 
template <typename T>
Matrix3x3<T> operator/(T a, const Matrix3x3<T>& b);
 
typedef Matrix3x3<float> Matrix3x3F;
 
typedef Matrix3x3<double> Matrix3x3D;
 
}  // namespace jet
 
#include "detail/matrix3x3-inl.h"
 
#endif  // INCLUDE_JET_MATRIX3X3_H_