src/geometry/2d/r2/class/vector-2d.hpp

• View this file on GitHub
• Last update: 2023-07-30 00:54:52+09:00
• Include: #include "src/geometry/2d/r2/class/vector-2d.hpp"

Depends on

• rep 構造体 (src/cpp-template/header/rep.hpp)
• size alias (src/cpp-template/header/size-alias.hpp)
• src/geometry/2d/common/class/vector-2d.hpp
• src/geometry/common/class/column-vector.hpp
• src/geometry/common/class/internal/matrix.hpp

Code

#pragma once

#include "src/geometry/2d/common/class/vector-2d.hpp"

#include <type_traits>

namespace luz::geometry::r2 {

  template < class R >
  class Vector2d: public luz::geometry::common::Vector2d< R > {
    static_assert(std::is_floating_point< R >::value);

   public:
    Vector2d() = default;

    bool operator==(const Vector2d &rhs) const {
      // TODO
      return false;
    }
  };

} // namespace luz::geometry::r2

#line 2 "src/geometry/2d/r2/class/vector-2d.hpp"

#line 2 "src/geometry/2d/common/class/vector-2d.hpp"

#line 2 "src/geometry/common/class/column-vector.hpp"

#line 2 "src/cpp-template/header/size-alias.hpp"

#include <cstddef>

namespace luz {

  using isize = std::ptrdiff_t;
  using usize = std::size_t;

} // namespace luz
#line 2 "src/geometry/common/class/internal/matrix.hpp"

#line 2 "src/cpp-template/header/rep.hpp"

#line 4 "src/cpp-template/header/rep.hpp"

#include <algorithm>

namespace luz {

  struct rep {
    struct itr {
      usize i;
      constexpr itr(const usize i) noexcept: i(i) {}
      void operator++() noexcept {
        ++i;
      }
      constexpr usize operator*() const noexcept {
        return i;
      }
      constexpr bool operator!=(const itr x) const noexcept {
        return i != x.i;
      }
    };
    const itr f, l;
    constexpr rep(const usize f, const usize l) noexcept
        : f(std::min(f, l)),
          l(l) {}
    constexpr auto begin() const noexcept {
      return f;
    }
    constexpr auto end() const noexcept {
      return l;
    }
  };

  struct rrep {
    struct itr {
      usize i;
      constexpr itr(const usize i) noexcept: i(i) {}
      void operator++() noexcept {
        --i;
      }
      constexpr usize operator*() const noexcept {
        return i;
      }
      constexpr bool operator!=(const itr x) const noexcept {
        return i != x.i;
      }
    };
    const itr f, l;
    constexpr rrep(const usize f, const usize l) noexcept
        : f(l - 1),
          l(std::min(f, l) - 1) {}
    constexpr auto begin() const noexcept {
      return f;
    }
    constexpr auto end() const noexcept {
      return l;
    }
  };

} // namespace luz
#line 5 "src/geometry/common/class/internal/matrix.hpp"

#include <cassert>
#include <vector>

namespace luz::geometry::common::internal {

  template < usize r, usize c, class T >
  class Mat {
    static constexpr usize n = r * c;

   protected:
    std::vector< T > as;

   public:
    using value_type = T;

    Mat(): as(n) {}

    T &at(const usize, const usize);
    const T &at(const usize, const usize) const;

    Mat operator+() const;
    Mat operator-() const;

    Mat &operator+=(const Mat &);
    Mat &operator-=(const Mat &);
    Mat operator+(const Mat &) const;
    Mat operator-(const Mat &) const;

    Mat &operator*=(const T &);
    Mat &operator/=(const T &);
    Mat operator*(const T &) const;
    Mat operator/(const T &) const;

    bool operator==(const Mat &) const;
    bool operator!=(const Mat &) const;

    // Implement (scalar) * (Matrix)
    friend Mat operator*(const T &scalar, const Mat< r, c, T > &mat) {
      return Mat< r, c, T >(mat) *= scalar;
    }
  };

  template < usize r, usize c, class T >
  T &Mat< r, c, T >::at(const usize i, const usize j) {
    assert(i < r and j < c);
    return as[i * c + j];
  }
  template < usize r, usize c, class T >
  const T &Mat< r, c, T >::at(const usize i, const usize j) const {
    assert(i < r and j < c);
    return as[i * c + j];
  }

  template < usize r, usize c, class T >
  Mat< r, c, T > Mat< r, c, T >::operator+() const {
    return *this;
  }
  template < usize r, usize c, class T >
  Mat< r, c, T > Mat< r, c, T >::operator-() const {
    return Mat() - *this;
  }

  template < usize r, usize c, class T >
  Mat< r, c, T > &Mat< r, c, T >::operator+=(
      const Mat< r, c, T > &rhs) {
    for (usize i: rep(0, n)) as[i] += rhs.as[i];
    return *this;
  }
  template < usize r, usize c, class T >
  Mat< r, c, T > &Mat< r, c, T >::operator-=(
      const Mat< r, c, T > &rhs) {
    for (usize i: rep(0, n)) as[i] -= rhs.as[i];
    return *this;
  }
  template < usize r, usize c, class T >
  Mat< r, c, T > Mat< r, c, T >::operator+(
      const Mat< r, c, T > &rhs) const {
    return Mat(*this) += rhs;
  }
  template < usize r, usize c, class T >
  Mat< r, c, T > Mat< r, c, T >::operator-(
      const Mat< r, c, T > &rhs) const {
    return Mat(*this) -= rhs;
  }

  template < usize r, usize c, class T >
  Mat< r, c, T > &Mat< r, c, T >::operator*=(const T &scalar) {
    for (T &a: as) a *= scalar;
    return *this;
  }
  template < usize r, usize c, class T >
  Mat< r, c, T > &Mat< r, c, T >::operator/=(const T &scalar) {
    for (T &a: as) a /= scalar;
    return *this;
  }
  template < usize r, usize c, class T >
  Mat< r, c, T > Mat< r, c, T >::operator*(const T &scalar) const {
    return Mat(*this) *= scalar;
  }
  template < usize r, usize c, class T >
  Mat< r, c, T > Mat< r, c, T >::operator/(const T &scalar) const {
    return Mat(*this) /= scalar;
  }

  template < usize r, usize c, class T >
  bool Mat< r, c, T >::operator==(const Mat &rhs) const {
    return as == rhs.as;
  }
  template < usize r, usize c, class T >
  bool Mat< r, c, T >::operator!=(const Mat &rhs) const {
    return as != rhs.as;
  }

} // namespace luz::geometry::common::internal
#line 5 "src/geometry/common/class/column-vector.hpp"

namespace luz::geometry::common {

  template < usize d, class T >
  class ColumnVector: public internal::Mat< d, 1, T > {
    using internal_mat = internal::Mat< d, 1, T >;

   public:
    using internal::Mat< d, 1, T >::Mat;

    ColumnVector(const internal_mat &mat): internal_mat::Mat(mat) {}

    T norm() const {
      T result{};
      for (T a: this->as) result += a * a;
      return result;
    }
  };

} // namespace luz::geometry::common
#line 4 "src/geometry/2d/common/class/vector-2d.hpp"

namespace luz::geometry::common {

  template < class T >
  class Vector2d: public ColumnVector< 2, T > {
    using c_vec = ColumnVector< 2, T >;

   public:
    Vector2d(const c_vec &vec): c_vec::ColumnVector(vec) {}
    Vector2d(const T x_, const T y_) {
      x() = x_;
      y() = y_;
    }

    const T &x() const {
      return this->as[0];
    }
    const T &y() const {
      return this->as[1];
    }

    T &x() {
      return this->as[0];
    }
    T &y() {
      return this->as[1];
    }
  };

} // namespace luz::geometry::common
#line 4 "src/geometry/2d/r2/class/vector-2d.hpp"

#include <type_traits>

namespace luz::geometry::r2 {

  template < class R >
  class Vector2d: public luz::geometry::common::Vector2d< R > {
    static_assert(std::is_floating_point< R >::value);

   public:
    Vector2d() = default;

    bool operator==(const Vector2d &rhs) const {
      // TODO
      return false;
    }
  };

} // namespace luz::geometry::r2

Back to top page