matrix_2d.hpp

#pragma once

#include "global.hpp"

#include "angle.hpp"
#include "point_2d.hpp"

namespace Cvb
{

CVB_BEGIN_INLINE_NS

class Matrix2D final
{
  public:


    static Matrix2D Identity() noexcept
    {
      return Matrix2D(1.0, 0.0, 0.0, 1.0);
    }


    Matrix2D() noexcept = default;


    template<std::size_t N>
    Matrix2D(const double(&list)[N]) noexcept
    {
      static_assert(N == 4, "CVB: Matrix2D must have 4 elements");
      std::copy(std::begin(list), std::end(list), &a11_);
    }


    Matrix2D(double a11, double a12, double a21, double a22) noexcept
      : a11_(a11)
      , a12_(a12)
      , a21_(a21)
      , a22_(a22)
    {
    }


    Matrix2D(Angle rotation, double scale = 1.0) noexcept
    {
      a11_ = (scale * Cos(rotation));
      a22_ = a11_;
      a21_ = scale * Sin(rotation);
      a12_ = -a21_;
    }



    Matrix2D(double scale) noexcept
      : Matrix2D(scale, scale)
    {
    }


    Matrix2D(double scaleX, double scaleY) noexcept
      : Matrix2D(scaleX, 0.0, scaleY, 0.0)
    {
    }


    Matrix2D(Cvb::Point2D<double> column1, Cvb::Point2D<double> column2) noexcept
      : Matrix2D(column1.X(), column2.X(), column1.Y(), column2.Y())
    {
    }



    const double* operator[](int row) const noexcept
    {

      return &((&a11_)[row << 1]);
    }


    double* operator[](int row) noexcept
    {
      return &((&a11_)[row << 1]);
    }



    const double& At(int row, int column) const noexcept
    {
      return (*this)[row][column];
    }


    double& At(int row, int column) noexcept
    {
      return (*this)[row][column];
    }



    double A11() const noexcept
    {
      return a11_;
    }


    void SetA11(double a11) noexcept
    {
      a11_ = a11;
    }


    double A12() const noexcept
    {
      return a12_;
    }


    void SetA12(double a12) noexcept
    {
      a12_ = a12;
    }


    double A21() const noexcept
    {
      return a21_;
    }


    void SetA21(double a21) noexcept
    {
      a21_ = a21;
    }


    double A22() const noexcept
    {
      return a22_;
    }


    void SetA22(double a22) noexcept
    {
      a22_ = a22;
    }


    double Det() const noexcept
    {
      return a11_ * a22_ - a21_ * a12_;
    }



    void Invert()
    {
      double det_1 = 1.0 / Det();
      *this = Matrix2D(a22_ * det_1, -a12_ * det_1, -a21_ * det_1, a11_ * det_1);
    }


    bool operator==(const Matrix2D& matrix) const noexcept
    {
      return a11_ == matrix.a11_
        && a12_ == matrix.a12_
        && a21_ == matrix.a21_
        && a22_ == matrix.a22_;
    }


    bool operator!=(const Matrix2D& matrix) const noexcept
    {
      return !(*this == matrix);
    }


    Matrix2D& operator +=(const Matrix2D & matrix) noexcept
    {
      a11_ += matrix.a11_;
      a12_ += matrix.a12_;
      a21_ += matrix.a21_;
      a22_ += matrix.a22_;
      return *this;
    }


    Matrix2D& operator -=(const Matrix2D & matrix) noexcept
    {
      a11_ -= matrix.a11_;
      a12_ -= matrix.a12_;
      a21_ -= matrix.a21_;
      a22_ -= matrix.a22_;
      return *this;
    }


    Matrix2D& operator *=(const Matrix2D & matrix) noexcept
    {
      *this = Matrix2D(a11_ * matrix.a11_ + a12_ * matrix.a21_,
        a11_ * matrix.a12_ + a12_ * matrix.a22_,
        a21_ * matrix.a11_ + a22_ * matrix.a21_,
        a21_ * matrix.a12_ + a22_ * matrix.a22_);
      return *this;
    }


    Matrix2D& operator *=(const double & value) noexcept
    {
      a11_ *= value;
      a12_ *= value;
      a21_ *= value;
      a22_ *= value;
      return *this;
    }


    Matrix2D& operator /=(const double & value) noexcept
    {
      a11_ /= value;
      a12_ /= value;
      a21_ /= value;
      a22_ /= value;
      return *this;
    }



  private:

    double a11_ = 0.0;
    double a12_ = 0.0;
    double a21_ = 0.0;
    double a22_ = 0.0;
};




inline Matrix2D operator+(const Matrix2D & lhs, const Matrix2D & rhs)
{
  return Matrix2D(lhs.A11() + rhs.A11(), lhs.A12() + rhs.A12(), lhs.A21() + rhs.A21(), lhs.A22() + rhs.A22());
}


inline Matrix2D operator-(const Matrix2D & lhs, const Matrix2D & rhs)
{
  return Matrix2D(lhs.A11() - rhs.A11(), lhs.A12() - rhs.A12(), lhs.A21() - rhs.A21(), lhs.A22() - rhs.A22());
}


inline Matrix2D operator*(const Matrix2D & lhs, const Matrix2D & rhs)
{
  return Matrix2D(lhs.A11() * rhs.A11() + lhs.A12() * rhs.A21(),
    lhs.A11() * rhs.A12() + lhs.A12() * rhs.A22(),
    lhs.A21() * rhs.A11() + lhs.A22() * rhs.A21(),
    lhs.A21() * rhs.A12() + lhs.A22() * rhs.A22());
}


inline Point2D<double> operator*(const Matrix2D & lhs, const Point2D<double> & rhs)
{
  return Point2D<double>(lhs.A11() * rhs.X() + lhs.A12() * rhs.Y(), lhs.A21() * rhs.X() + lhs.A22() * rhs.Y());
}


inline Matrix2D operator*(const Matrix2D & lhs, const double & rhs)
{
  return Matrix2D(lhs.A11() * rhs, lhs.A12() * rhs, lhs.A21() * rhs, lhs.A22() * rhs);
}


inline Matrix2D operator*(const double & lhs, const Matrix2D & rhs)
{
  return rhs * lhs;
}


inline Matrix2D operator/(const Matrix2D & lhs, const double & rhs)
{
  return Matrix2D(lhs.A11() / rhs, lhs.A12() / rhs, lhs.A21() / rhs, lhs.A22() / rhs);
}






CVB_END_INLINE_NS

}