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);
    }
    static Matrix2D Identity() noexcept {…}


    Matrix2D() noexcept = default;


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


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


    explicit Matrix2D(Angle rotation, double scale = 1.0) noexcept
    {
      a11_ = (scale * Cos(rotation));  // NOLINT(cppcoreguidelines-prefer-member-initializer)
      a22_ = a11_;                     // NOLINT(cppcoreguidelines-prefer-member-initializer)
      a21_ = scale * Sin(rotation);    // NOLINT(cppcoreguidelines-prefer-member-initializer)
      a12_ = -a21_;                    // NOLINT(cppcoreguidelines-prefer-member-initializer)
    }
    explicit Matrix2D(Angle rotation, double scale = 1.0) noexcept {…}


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


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


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


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


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


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


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


    double A11() const noexcept
    {
      return a11_;
    }
    double A11() const noexcept {…}


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


    double A12() const noexcept
    {
      return a12_;
    }
    double A12() const noexcept {…}


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


    double A21() const noexcept
    {
      return a21_;
    }
    double A21() const noexcept {…}


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


    double A22() const noexcept
    {
      return a22_;
    }
    double A22() const noexcept {…}


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


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


    void Invert()
    {
      *this = Inverse();
    }
    void Invert() {…}


    Matrix2D Inverse()
    {
      if (std::fabs(Det()) < 1e-9)
        throw std::invalid_argument("matrix is not invertible");
 
      double det_1 = 1.0 / Det();
      return Matrix2D(a22_ * det_1, -a12_ * det_1, -a21_ * det_1, a11_ * det_1);
    }
    Matrix2D Inverse() {…}


    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 {…}


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


    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 {…}


    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 {…}


    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 Matrix2D &matrix) noexcept {…}


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


    Matrix2D &operator/=(const double &value) noexcept
    {
      a11_ /= value;
      a12_ /= value;
      a21_ /= value;
      a22_ /= value;
      return *this;
    }
    Matrix2D &operator/=(const double &value) noexcept {…}
 
  private:
    double a11_ = 0.0;
    double a12_ = 0.0;
    double a21_ = 0.0;
    double a22_ = 0.0;
  };
  class Matrix2D final {…};


  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) {…}


  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) {…}


  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 Matrix2D operator*(const Matrix2D &lhs, const Matrix2D &rhs) {…}


  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 Point2D<double> operator*(const Matrix2D &lhs, const Point2D<double> &rhs) {…}


  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 Matrix2D &lhs, const double &rhs) {…}


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


  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 Matrix2D &lhs, const double &rhs) {…}
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb