matrix2x2.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_MATRIX2X2_H_
#define INCLUDE_JET_MATRIX2X2_H_
 
#include <jet/matrix.h>
#include <jet/vector2.h>
 
#include <array>
#include <limits>
 
namespace jet {
 
template <typename T>
class Matrix<T, 2, 2> {
 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 m10, T m11);
 
    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 m10, T m11);
 
    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 Vector2<T>& row);
 
    void setColumn(size_t i, const Vector2<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;
 
    Vector2<T> mul(const Vector2<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, 2, 2> 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);
 
    static Matrix makeScaleMatrix(const Vector2<T>& s);
 
    static Matrix makeRotationMatrix(const T& rad);
 
 private:
    std::array<T, 4> _elements;
};
 
template <typename T>
using Matrix2x2 = Matrix<T, 2, 2>;
 
// MARK: Operator overloadings
template <typename T>
Matrix2x2<T> operator-(const Matrix2x2<T>& a);
 
template <typename T>
Matrix2x2<T> operator+(const Matrix2x2<T>& a, const Matrix2x2<T>& b);
 
template <typename T>
Matrix2x2<T> operator+(const Matrix2x2<T>& a, const T& b);
 
template <typename T>
Matrix2x2<T> operator+(const T& a, const Matrix2x2<T>& b);
 
template <typename T>
Matrix2x2<T> operator-(const Matrix2x2<T>& a, const Matrix2x2<T>& b);
 
template <typename T>
Matrix2x2<T> operator-(const Matrix2x2<T>& a, T b);
 
template <typename T>
Matrix2x2<T> operator-(T a, const Matrix2x2<T>& b);
 
template <typename T>
Matrix2x2<T> operator*(const Matrix2x2<T>& a, T b);
 
template <typename T>
Matrix2x2<T> operator*(T a, const Matrix2x2<T>& b);
 
template <typename T>
Vector2<T> operator*(const Matrix2x2<T>& a, const Vector2<T>& b);
 
template <typename T>
Matrix2x2<T> operator*(const Matrix2x2<T>& a, const Matrix2x2<T>& b);
 
template <typename T>
Matrix2x2<T> operator/(const Matrix2x2<T>& a, T b);
 
template <typename T>
Matrix2x2<T> operator/(const T& a, const Matrix2x2<T>& b);
 
typedef Matrix2x2<float> Matrix2x2F;
 
typedef Matrix2x2<double> Matrix2x2D;
 
}  // namespace jet
 
#include "detail/matrix2x2-inl.h"
 
#endif  // INCLUDE_JET_MATRIX2X2_H_