euclid_plane_measure.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "euclid_plane.hpp"
// #include "fractions.hpp"
 
namespace fun {
 
    template <typename K>
        requires Integral<K>
    constexpr auto quad1(const K& x1, const K& z1, const K& x2, const K& z2) {
        return sq(Fraction<K>(x1, z1) - Fraction<K>(x2, z2));
    }
 
    template <typename K>
    // requires (!Integral<K>)
    constexpr auto quad1(const K& x1, const K& z1, const K& x2, const K& z2) {
        return sq(x1 / z1 - x2 / z2);
    }
 
    template <ProjectivePlaneCoord2 Point>
    constexpr auto quadrance(const Point& a1, const Point& a2) {
        return quad1(a1[0], a1[2], a2[0], a2[2]) + quad1(a1[1], a1[2], a2[1], a2[2]);
    }
 
    template <typename... Args> constexpr auto quadrance_copy(const Args&... args) {
        return std::make_tuple(quadrance(args.first, args.second)...);
    }
 
    // ProjectivePlane2 { Line }
    // constexpr auto sbase(const Line &l1, const Line &l2, const Integer &d) {
    //     return Fraction(d, omgB(l1, l1)) * Fraction(d, omgB(l2, l2));
    // }
 
    template <ProjectivePlaneCoord2 Line, typename T>
    constexpr auto sbase(const Line& l1, const Line& l2, const T& d) {
        using K = Value_type<Line>;
        if constexpr (Integral<K>) {
            return Fraction<K>(d, dot1(l1, l1)) * Fraction<K>(d, dot1(l2, l2));
        } else {
            return (d * d) / (dot1(l1, l1) * dot1(l2, l2));
        }
    }
 
    template <ProjectivePlaneCoord2 Line> constexpr auto spread(const Line& l1, const Line& l2) {
        return sbase(l1, l2, cross2(l1, l2));
    }
 
    template <ProjectivePlaneCoord2 Point>
    constexpr auto tri_quadrance(const Triple<Point>& triangle) {
        const auto& [a_1, a_2, a_3] = triangle;
        return std::array{quadrance(a_2, a_3), quadrance(a_1, a_3), quadrance(a_1, a_2)};
    }
 
    template <ProjectivePlaneCoord2 Line>
    constexpr auto tri_spread(const Triple<Line>& trilateral) {
        const auto& [a_1, a_2, a_3] = trilateral;
        return std::array{spread(a_2, a_3), spread(a_1, a_3), spread(a_1, a_2)};
    }
 
    template <ProjectivePlaneCoord2 Line> constexpr auto cross_s(const Line& l1, const Line& l2) {
        return sbase(l1, l2, dot1(l1, l2));
    }
 
}  // namespace fun