mat2.h

Go to the documentation of this file.

#pragma once
 
#include "../vec/vec2.h"
 
template<class T>
struct mat2 {
public:
  T values[2][2];
 
  mat2() {
    // clang-format off
        values[0][0] = static_cast<T>(0); values[0][1] = static_cast<T>(0);
        values[1][0] = static_cast<T>(0); values[1][1] = static_cast<T>(0); // clang-format on
  }
 
  mat2(const T& _a, const T& _b, const T& _c, const T& _d) {
    // clang-format off
        values[0][0] = _a; values[0][1] = _b;
        values[1][0] = _c; values[1][1] = _d; // clang-format on
  }
 
  mat2(const vec2<T>& A, const vec2<T>& B) {
    // clang-format off
        values[0][0] = A.x; values[0][1] = B.x;
        values[1][0] = A.y; values[1][1] = B.y; // clang-format on
  }
 
  ~mat2() = default;
 
  static inline mat2<T> Unit() {
    return mat2<T>(static_cast<T>(1), static_cast<T>(0), static_cast<T>(0), static_cast<T>(1));
  }
 
  inline mat2<T> Transpose() { return mat2<T>(values[0][0], values[1][0], values[0][1], values[1][1]); }
 
  inline bool IsSymmetric() { return values[1][0] == values[0][1]; }
  inline float Determinant() { return values[0][0] * values[1][1] - values[0][1] * values[1][0]; }
 
  inline mat2<T> Inverse() const {
    return mat2<T>(values[1][1], -values[0][1], -values[1][0], values[0][0])
           * static_cast<T>(1 / (values[0][0] * values[1][1] - values[0][1] * values[1][0]));
  }
 
  friend mat2<T> operator+(mat2<T> lhs, const mat2<T>& rhs) { return lhs += rhs; }
 
  friend mat2<T> operator-(mat2<T> lhs, const mat2<T>& rhs) { return lhs -= rhs; }
 
  friend mat2<T> operator*(mat2<T> lhs, const T& rhs) { return lhs *= rhs; }
 
  friend vec2<T> operator*(mat2<T> lhs, const vec2<T>& rhs) {
    return vec2<T>(lhs[0][0] * rhs.x + lhs[0][1] * rhs.y, lhs[1][0] * rhs.x + lhs[1][1] * rhs.y);
  }
 
  friend mat2<T> operator*(mat2<T> lhs, const mat2<T>& rhs) { return lhs *= rhs; }
 
  friend mat2<T> operator/(mat2<T> lhs, const T& rhs) { return lhs /= rhs; }
 
  /* compound assignment */
  mat2<T>& operator+=(const mat2<T>& rhs) {
    // clang-format off
        values[0][0] += rhs[0][0]; values[0][1] += rhs[0][1];
        values[1][0] += rhs[1][0]; values[1][1] += rhs[1][1]; // clang-format on
    return *this;
  }
 
  mat2<T>& operator-=(const mat2<T>& rhs) {
    // clang-format off
        values[0][0] -= rhs[0][0]; values[0][1] -= rhs[0][1];
        values[1][0] -= rhs[1][0]; values[1][1] -= rhs[1][1]; // clang-format on
    return *this;
  }
 
  mat2<T>& operator*=(const mat2<T>& rhs) {
    // clang-format off
        T _a = values[0][0], _b = values[0][1],
          _c = values[1][0], _d = values[1][1];
        values[0][0] = _a * rhs[0][0] + _b * rhs[1][0]; values[0][1] = _a * rhs[0][1] + _b * rhs[1][1];
        values[1][0] = _c * rhs[0][0] + _d * rhs[1][0]; values[1][1] = _c * rhs[0][1] + _d * rhs[1][1]; // clang-format on
    return *this;
  }
 
  mat2<T>& operator*=(const T& rhs) {
    // clang-format off
        values[0][0] *= rhs; values[0][1] *= rhs;
        values[1][0] *= rhs; values[1][1] *= rhs; // clang-format on
    return *this;
  }
 
  mat2<T>& operator/=(const T& rhs) {
    // clang-format off
        values[0][0] /= rhs; values[0][1] /= rhs;
        values[1][0] /= rhs; values[1][1] /= rhs; // clang-format on
    return *this;
  }
 
  /* Member access */
  T* operator[](const int& index) { return values[index]; }
  const T* operator[](const int& index) const { return values[index]; }
 
  /* stream operators */
  template<class U>
  friend std::ostream& operator<<(std::ostream&, const mat2<U>&);
};
 
template<class U>
std::ostream& operator<<(std::ostream& out, const mat2<U>& mat) {
  out.precision(17);
  out << "[\n\t" << mat[0][0] << ", " << mat[0][1] << ";\n\t" << mat[1][0] << ", " << mat[1][1] << "\n]\n";
  return out;
}