pg_object.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <cstdint>
 
// #include "common_concepts.h"
#include "pg_plane.hpp"
 
constexpr auto dot(const std::array<int64_t, 3>& pt_a, const std::array<int64_t, 3>& pt_b)
    -> int64_t {
    return pt_a[0] * pt_b[0] + pt_a[1] * pt_b[1] + pt_a[2] * pt_b[2];
}
 
constexpr auto cross(const std::array<int64_t, 3>& pt_a, const std::array<int64_t, 3>& pt_b)
    -> std::array<int64_t, 3> {
    return {
        pt_a[1] * pt_b[2] - pt_a[2] * pt_b[1],
        pt_a[2] * pt_b[0] - pt_a[0] * pt_b[2],
        pt_a[0] * pt_b[1] - pt_a[1] * pt_b[0],
    };
}
 
constexpr auto plckr(const int64_t& lambda, const std::array<int64_t, 3>& pt_p, const int64_t& mu,
                     const std::array<int64_t, 3>& pt_q) -> std::array<int64_t, 3> {
    return {
        lambda * pt_p[0] + mu * pt_q[0],
        lambda * pt_p[1] + mu * pt_q[1],
        lambda * pt_p[2] + mu * pt_q[2],
    };
}
 
namespace fun {
 
    template <Ring _K, typename Self, typename DualType> struct pg_object {
        using Dual = DualType;
        using value_type = _K;
 
        std::array<_K, 3> coord;
 
        constexpr explicit pg_object(std::array<_K, 3> coord) : coord{std::move(coord)} {}
 
        constexpr pg_object(const _K& x, const _K& y, const _K& z) : coord{{x, y, z}} {}
 
        friend constexpr auto operator==(const Self& lhs, const Self& rhs) -> bool {
            return &lhs == &rhs
                   || (lhs.coord[1] * rhs.coord[2] == lhs.coord[2] * rhs.coord[1]
                       && lhs.coord[2] * rhs.coord[0] == lhs.coord[0] * rhs.coord[2]
                       && lhs.coord[0] * rhs.coord[1] == lhs.coord[1] * rhs.coord[0]);
        }
 
        friend constexpr auto operator!=(const Self& lhs, const Self& rhs) -> bool {
            return !(lhs == rhs);
        }
 
        friend constexpr auto operator*(const Self& lhs, const Self& rhs) -> DualType {
            return DualType{::cross(lhs.coord, rhs.coord)};
        }
 
        constexpr auto aux() const -> DualType { return DualType{this->coord}; }
 
        constexpr auto dot(const DualType& other) const -> _K {
            return this->coord[0] * other.coord[0] + this->coord[1] * other.coord[1]
                   + this->coord[2] * other.coord[2];
        }
 
        constexpr auto incident(const DualType& other) const -> bool {
            return this->dot(other) == _K(0);
        }
 
        static constexpr auto parametrize(const _K& lambda_val, const Self& pt_p, const _K& mu_val,
                                          const Self& pt_q) -> Self {
            return Self{::plckr(lambda_val, pt_p.coord, mu_val, pt_q.coord)};
        }
    };
 
}  // namespace fun
 
template <typename Point, typename Line> struct PgObject {
    using Dual = Line;
 
    std::array<int64_t, 3> coord;
 
    constexpr explicit PgObject(std::array<int64_t, 3> coord) : coord{std::move(coord)} {}
 
    friend constexpr auto operator==(const Point& lhs, const Point& rhs) -> bool {
        return &lhs == &rhs ? true
                            : lhs.coord[1] * rhs.coord[2] == lhs.coord[2] * rhs.coord[1]
                                  && lhs.coord[2] * rhs.coord[0] == lhs.coord[0] * rhs.coord[2]
                                  && lhs.coord[0] * rhs.coord[1] == lhs.coord[1] * rhs.coord[0];
    }
 
    friend constexpr auto operator!=(const Point& lhs, const Point& rhs) -> bool {
        return !(lhs == rhs);
    }
 
    constexpr auto aux() const -> Line { return Line{this->coord}; }
 
    constexpr auto dot(const Line& other) const -> int64_t {
        return ::dot(this->coord, other.coord);
    }
 
    static constexpr auto parametrize(const int64_t& lambda_val, const Point& pt_p,
                                      const int64_t& mu_val, const Point& pt_q) -> Point {
        return Point{::plckr(lambda_val, pt_p.coord, mu_val, pt_q.coord)};
    }
 
    constexpr auto incident(const Line& other) const -> bool { return this->dot(other) == 0; }
 
    constexpr auto meet(const Point& rhs) const -> Line {
        return Line{::cross(this->coord, rhs.coord)};
    }
};
 
class PgPoint;
class PgLine;
 
class PgPoint : public PgObject<PgPoint, PgLine> {
  public:
    constexpr explicit PgPoint(std::array<int64_t, 3> coord)
        : PgObject<PgPoint, PgLine>{std::move(coord)} {}
};
 
class PgLine : public PgObject<PgLine, PgPoint> {
  public:
    constexpr explicit PgLine(std::array<int64_t, 3> coord)
        : PgObject<PgLine, PgPoint>{std::move(coord)} {}
};