pg_common.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <tuple>
 
#include "common_concepts.h"
 
namespace fun {
 
    template <Ring _K> auto cross0(const std::array<_K, 3>& v_a, const std::array<_K, 3>& v_b)
        -> _K {
        return v_a[1] * v_b[2] - v_b[1] * v_a[2];
    }
 
    template <Ring _K> auto cross1(const std::array<_K, 3>& v_a, const std::array<_K, 3>& v_b)
        -> _K {
        return v_a[0] * v_b[2] - v_b[0] * v_a[2];
    }
 
    template <Ring _K> auto cross2(const std::array<_K, 3>& v_a, const std::array<_K, 3>& v_b)
        -> _K {
        return v_a[0] * v_b[1] - v_b[0] * v_a[1];
    }
 
    template <typename Point>
        requires Ring<Value_type<Point>>
    auto cross(const Point& v_a, const Point& v_b) -> std::array<Value_type<Point>, 3> {
        return {cross0(v_a, v_b), -cross1(v_a, v_b), cross2(v_a, v_b)};
    }
 
    template <Ring _K> auto dot_c(const std::array<_K, 3>& v_a, const std::array<_K, 3>& v_b)
        -> _K {
        const auto& [x1, y1, z1] = v_a;
        const auto& [x2, y2, z2] = v_b;
        return x1 * x2 + y1 * y2 + z1 * z2;
    }
 
    template <Ring _T, Ring _K> auto plucker_c(const _T& lambda_val, const std::array<_K, 3>& v_a,
                                               const _T& mu_val, const std::array<_K, 3>& v_b)
        -> std::array<_K, 3> {
        const auto& [x1, y1, z1] = v_a;
        const auto& [x2, y2, z2] = v_b;
        return {lambda_val * x1 + mu_val * x2, lambda_val * y1 + mu_val * y2,
                lambda_val * z1 + mu_val * z2};
    }
 
    template <Ring _K> auto dot1(const std::array<_K, 3>& v_a, const std::array<_K, 3>& v_b) -> _K {
        return v_a[0] * v_b[0] + v_a[1] * v_b[1];
    }
 
    template <Ring _K> auto dot2(const std::array<_K, 3>& v_a, const std::array<_K, 3>& v_b) -> _K {
        return v_a[0] * v_b[0] + v_a[2] * v_b[2];
    }
 
    template <typename T> constexpr auto sq(const T& a) { return a * a; }
 
    template <typename Value, typename Point>
        requires Ring<Value>
    constexpr auto parametrize(const Value& lambda_val, const Point& pt_p, const Value& mu_val,
                               const Point& pt_q) -> Point {
        return Point::parametrize(lambda_val, pt_p, mu_val, pt_q);
    }
 
}  // namespace fun