matrix_3d_h.hpp

#pragma once
 
#include "_cexports/c_core_3d.h"
 
#include "global.hpp"
 
#include "point_3d_h.hpp"
#include "matrix_3d.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  class Matrix3DH;


  inline Matrix3DH operator+(const Matrix3DH &lhs, const Matrix3DH &rhs);


  inline Matrix3DH operator-(const Matrix3DH &lhs, const Matrix3DH &rhs);


  class Matrix3DH final
  {
  public:

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


    Matrix3DH() noexcept = default;


    template <std::size_t N>
    Matrix3DH(const double (&list)[N]) noexcept  // NOLINT
    {
      static_assert(N == 16, "CVB: Matrix3D must have 16 elements");
      std::copy(std::begin(list), std::end(list), matrix_.data()->data());
    }
    Matrix3DH(const double (&list)[N]) noexcept  // NOLINT {…}


    explicit Matrix3DH(const Matrix3D &matrix) noexcept
    {
      *this = {{
          matrix[0][0],
          matrix[0][1],
          matrix[0][2],
          0.0,
          matrix[1][0],
          matrix[1][1],
          matrix[1][2],
          0.0,
          matrix[2][0],
          matrix[2][1],
          matrix[2][2],
          0.0,
          0.0,
          0.0,
          0.0,
          1.0,
      }};
    }
    explicit Matrix3DH(const Matrix3D &matrix) noexcept {…}


    const double *operator[](int row) const noexcept
    {
      return matrix_[row].data();  // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
    }
    const double *operator[](int row) const noexcept {…}


    double *operator[](int row) noexcept
    {
      return matrix_[row].data();  // NOLINT(cppcoreguidelines-pro-bounds-constant-array-index)
    }
    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 {…}


    bool operator==(const Matrix3DH &matrix) const noexcept
    {
      return matrix_ == matrix.matrix_;
    }
    bool operator==(const Matrix3DH &matrix) const noexcept {…}


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


    Matrix3DH &operator+=(const Matrix3DH &matrix) noexcept
    {
      *this = *this + matrix;
      return *this;
    }
    Matrix3DH &operator+=(const Matrix3DH &matrix) noexcept {…}


    Matrix3DH &operator-=(const Matrix3DH &matrix) noexcept
    {
      *this = *this - matrix;
      return *this;
    }
    Matrix3DH &operator-=(const Matrix3DH &matrix) noexcept {…}


    Matrix3DH &operator*=(const double &value) noexcept
    {
      for (auto &line : matrix_)
        for (auto &element : line)
          element *= value;
      return *this;
    }
    Matrix3DH &operator*=(const double &value) noexcept {…}


    Matrix3DH &operator/=(const double &value) noexcept
    {
      for (auto &line : matrix_)
        for (auto &element : line)
          element /= value;
      return *this;
    }
    Matrix3DH &operator/=(const double &value) noexcept {…}
 
  private:
    std::array<std::array<double, 4>, 4> matrix_{};
  };
  class Matrix3DH final {…};
 
  inline Matrix3DH operator+(const Matrix3DH &lhs, const Matrix3DH &rhs)
  {
    return {{
        lhs[0][0] + rhs[0][0],
        lhs[0][1] + rhs[0][1],
        lhs[0][2] + rhs[0][2],
        lhs[0][3] + rhs[0][3],
        lhs[1][0] + rhs[1][0],
        lhs[1][1] + rhs[1][1],
        lhs[1][2] + rhs[1][2],
        lhs[1][3] + rhs[1][3],
        lhs[2][0] + rhs[2][0],
        lhs[2][1] + rhs[2][1],
        lhs[2][2] + rhs[2][2],
        lhs[2][3] + rhs[2][3],
        lhs[3][0] + rhs[3][0],
        lhs[3][1] + rhs[3][1],
        lhs[3][2] + rhs[3][2],
        lhs[3][3] + rhs[3][3],
    }};
  }
  inline Matrix3DH operator+(const Matrix3DH &lhs, const Matrix3DH &rhs) {…}
 
  inline Matrix3DH operator-(const Matrix3DH &lhs, const Matrix3DH &rhs)
  {
    return {{
        lhs[0][0] - rhs[0][0],
        lhs[0][1] - rhs[0][1],
        lhs[0][2] - rhs[0][2],
        lhs[0][3] - rhs[0][3],
        lhs[1][0] - rhs[1][0],
        lhs[1][1] - rhs[1][1],
        lhs[1][2] - rhs[1][2],
        lhs[1][3] - rhs[1][3],
        lhs[2][0] - rhs[2][0],
        lhs[2][1] - rhs[2][1],
        lhs[2][2] - rhs[2][2],
        lhs[2][3] - rhs[2][3],
        lhs[3][0] - rhs[3][0],
        lhs[3][1] - rhs[3][1],
        lhs[3][2] - rhs[3][2],
        lhs[3][3] - rhs[3][3],
    }};
  }
  inline Matrix3DH operator-(const Matrix3DH &lhs, const Matrix3DH &rhs) {…}


  inline Point3DH<double> operator*(const Matrix3DH &lhs, const Point3DH<double> &rhs)
  {
    return {{
        lhs[0][0] * rhs[0] + lhs[0][1] * rhs[1] + lhs[0][2] * rhs[2] + lhs[0][3] * rhs[3],
        lhs[1][0] * rhs[0] + lhs[1][1] * rhs[1] + lhs[1][2] * rhs[2] + lhs[1][3] * rhs[3],
        lhs[2][0] * rhs[0] + lhs[2][1] * rhs[1] + lhs[2][2] * rhs[2] + lhs[2][3] * rhs[3],
        lhs[3][0] * rhs[0] + lhs[3][1] * rhs[1] + lhs[3][2] * rhs[2] + lhs[3][3] * rhs[3],
    }};
  }
  inline Point3DH<double> operator*(const Matrix3DH &lhs, const Point3DH<double> &rhs) {…}


  inline Matrix3DH operator*(const Matrix3DH &lhs, const double &rhs)
  {
    return {{
        lhs[0][0] * rhs,
        lhs[0][1] * rhs,
        lhs[0][2] * rhs,
        lhs[0][3] * rhs,
        lhs[1][0] * rhs,
        lhs[1][1] * rhs,
        lhs[1][2] * rhs,
        lhs[1][3] * rhs,
        lhs[2][0] * rhs,
        lhs[2][1] * rhs,
        lhs[2][2] * rhs,
        lhs[2][3] * rhs,
        lhs[3][0] * rhs,
        lhs[3][1] * rhs,
        lhs[3][2] * rhs,
        lhs[3][3] * rhs,
    }};
  }
  inline Matrix3DH operator*(const Matrix3DH &lhs, const double &rhs) {…}


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


  inline Matrix3DH operator/(const Matrix3DH &lhs, const double &rhs)
  {
    return {{lhs[0][0] / rhs, lhs[0][1] / rhs, lhs[0][2] / rhs, lhs[0][3] / rhs, lhs[1][0] / rhs, lhs[1][1] / rhs,
             lhs[1][2] / rhs, lhs[1][3] / rhs, lhs[2][0] / rhs, lhs[2][1] / rhs, lhs[2][2] / rhs, lhs[2][3] / rhs,
             lhs[3][0] / rhs, lhs[3][1] / rhs, lhs[3][2] / rhs, lhs[3][3] / rhs}};
  }
  inline Matrix3DH operator/(const Matrix3DH &lhs, const double &rhs) {…}
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb