Spaces.hpp

Go to the documentation of this file.

 
//                Copyright Oliver J. Rosten 2024.                //
// Distributed under the GNU GENERAL PUBLIC LICENSE, Version 3.0. //
//    (See accompanying file LICENSE.md or copy at                //
//          https://www.gnu.org/licenses/gpl-3.0.en.html)         //
 
#pragma once
 
#include "sequoia/Core/ContainerUtilities/ArrayUtilities.hpp"
#include "sequoia/Core/Meta/Concepts.hpp"
#include "sequoia/Core/Meta/TypeAlgorithms.hpp"
#include "sequoia/PlatformSpecific/Preprocessor.hpp"
 
#include <algorithm>
#include <cmath>
#include <concepts>
#include <complex>
#include <format>
#include <ranges>
#include <span>
 
namespace sequoia::maths
{
  template<class T>
  inline constexpr bool is_addable_v{
    requires(T& t) {
      { t += t } -> std::same_as<T&>;
      { t + t }  -> std::convertible_to<T>;
    }
  };
 
  template<class T>
  inline constexpr bool is_subtractable_v{
    requires(T& t) {
      { t -= t } -> std::same_as<T&>;
      { t - t }  -> std::convertible_to<T>;
    }
  };
 
  template<class T>
  inline constexpr bool is_multiplicable_v{
    requires(T& t) {
      { t *= t } -> std::same_as<T&>;
      { t * t }  -> std::convertible_to<T>;
    }
  };
 
  template<class T>
  inline constexpr bool is_divisible_v{
    requires(T& t) {
      { t /= t } -> std::same_as<T&>;
      { t / t }  -> std::convertible_to<T>;
    }
  };
 
  template<class T>
  struct weakly_abelian_group_under_addition : std::false_type {};
 
  template<class T>
  using weakly_abelian_group_under_addition_t = typename weakly_abelian_group_under_addition<T>::type;
  
  template<class T>
  inline constexpr bool weakly_abelian_group_under_addition_v{weakly_abelian_group_under_addition<T>::value};
 
  template<arithmetic T>
  struct weakly_abelian_group_under_addition<T> : std::true_type {};
 
  template<std::floating_point T>
  struct weakly_abelian_group_under_addition<std::complex<T>> : std::true_type {};
 
  template<class T>
  struct weakly_abelian_group_under_multiplication : std::false_type {};
 
  template<class T>
  using weakly_abelian_group_under_multiplication_t = typename weakly_abelian_group_under_multiplication<T>::type;
 
  template<class T>
  inline constexpr bool weakly_abelian_group_under_multiplication_v{weakly_abelian_group_under_multiplication<T>::value};
 
  template<std::floating_point T>
  struct weakly_abelian_group_under_multiplication<T> : std::true_type {};
 
  template<std::floating_point T>
  struct weakly_abelian_group_under_multiplication<std::complex<T>> : std::true_type {};
 
  template<>
  struct weakly_abelian_group_under_multiplication<bool> : std::true_type {};
  
  template<class T>
  struct multiplication_weakly_distributive_over_addition : std::true_type {};
 
  template<class T>
  using multiplication_weakly_distributive_over_addition_t = typename multiplication_weakly_distributive_over_addition<T>::type;
 
  template<class T>
  inline constexpr bool multiplication_weakly_distributive_over_addition_v{multiplication_weakly_distributive_over_addition<T>::value};
 
  template<class T>
  concept weak_commutative_ring 
    =    std::regular<T>
      && weakly_abelian_group_under_addition_v<T>
      && multiplication_weakly_distributive_over_addition_v<T>
      && is_addable_v<T>
      && is_subtractable_v<T>
      && is_multiplicable_v<T>;
 
  template<class T>
  concept weak_field = weak_commutative_ring<T> && weakly_abelian_group_under_multiplication_v<T> && is_divisible_v<T>;
 
  template<class T>
  inline constexpr bool has_commutative_ring_type_v{
    requires { 
      typename T::commutative_ring_type;
      requires weak_commutative_ring<typename T::commutative_ring_type>;
    }
  };
 
  template<class T>
  inline constexpr bool has_field_type_v{
    requires { 
      typename T::field_type;
      requires weak_field<typename T::field_type>;
    }
  };
 
  template<class T>
  inline constexpr bool defines_commutative_ring_v{has_commutative_ring_type_v<T> || has_field_type_v<T>};
 
  template<class T>
  inline constexpr bool defines_field_v{
        has_field_type_v<T>
    || requires { 
          typename T::commutative_ring_type;
          requires weak_field<typename T::commutative_ring_type>;
        }
  };
 
  template<class T>
  inline constexpr bool has_dimension_v{
    requires { { T::dimension } -> std::convertible_to<std::size_t>; }
  };
 
  template<class T>
  inline constexpr bool has_set_type_v{
    requires { typename T::set_type; }
  };
 
  template<class T>
  inline constexpr bool identifies_as_convex_space_v{
     requires {
      typename T::is_convex_space;
      requires std::convertible_to<typename T::is_convex_space, std::true_type>;
    }
  };
 
  template<class T>
  inline constexpr bool identifies_as_affine_space_v{
     requires {
      typename T::is_affine_space;
      requires std::convertible_to<typename T::is_affine_space, std::true_type>;
    }
  };
 
  template<class T>
  inline constexpr bool identifies_as_free_module_v{
    requires {
      typename T::is_free_module;
      requires std::convertible_to<typename T::is_free_module, std::true_type>;
    }
  };
 
  template<class T>
  inline constexpr bool identifies_as_vector_space_v{
    requires {
      typename T::is_vector_space;
      requires std::convertible_to<typename T::is_vector_space, std::true_type>;
    }
  };
  
  template<class T>
  concept free_module = has_set_type_v<T> && has_dimension_v<T> && defines_commutative_ring_v<T> && (identifies_as_free_module_v<T> || identifies_as_vector_space_v<T>);
 
  template<class T>
  concept vector_space = free_module<T> && defines_field_v<T>;
 
  template<class T>
  inline constexpr bool has_vector_space_type_v{
    requires {
      typename T::vector_space_type;
      requires vector_space<typename T::vector_space_type>;
    }
  };
 
  template<class T>
  inline constexpr bool has_free_module_type_v{
    requires {
      typename T::free_module_type;
      requires free_module<typename T::free_module_type>;
    }
  };
 
  template<class T>
  concept convex_space
    =    free_module<T>
      || (    has_set_type_v<T>
          && (has_vector_space_type_v<T> || has_free_module_type_v<T>)
          && (identifies_as_convex_space_v<T> || identifies_as_affine_space_v<T>));
 
  template<class T>
  concept affine_space = vector_space<T> || (convex_space<T> && identifies_as_affine_space_v<T>);
  
  template<class T>
  struct is_free_module : std::integral_constant<bool, free_module<T>> {};
 
  template<convex_space ConvexSpace>
  struct free_module_type_of;
 
  template<convex_space ConvexSpace>
    requires identifies_as_free_module_v<ConvexSpace> || identifies_as_vector_space_v<ConvexSpace>
  struct free_module_type_of<ConvexSpace>
  {
    using type = ConvexSpace;
  };
 
  template<convex_space ConvexSpace>
    requires (!identifies_as_free_module_v<ConvexSpace> && !identifies_as_vector_space_v<ConvexSpace>) && has_free_module_type_v<ConvexSpace>
  struct free_module_type_of<ConvexSpace>
  {
    using type = ConvexSpace::free_module_type;
  };
 
  template<convex_space ConvexSpace>
    requires (!identifies_as_free_module_v<ConvexSpace> && !identifies_as_vector_space_v<ConvexSpace>) && has_vector_space_type_v<ConvexSpace>
  struct free_module_type_of<ConvexSpace>
  {
    using type = ConvexSpace::vector_space_type;
  };
 
  template<convex_space ConvexSpace>
  using free_module_type_of_t = free_module_type_of<ConvexSpace>::type;
  
  template<convex_space ConvexSpace>
  struct commutative_ring_type_of
  {
    using type = free_module_type_of_t<ConvexSpace>::commutative_ring_type;
  };
 
  template<convex_space ConvexSpace>
    requires vector_space<free_module_type_of_t<ConvexSpace>> && has_field_type_v<free_module_type_of_t<ConvexSpace>>
  struct commutative_ring_type_of<ConvexSpace>
  {
    using type = free_module_type_of_t<ConvexSpace>::field_type;
  };
 
  template<convex_space ConvexSpace>
  using commutative_ring_type_of_t = commutative_ring_type_of<ConvexSpace>::type;
 
  template<convex_space ConvexSpace>
  using space_value_type = commutative_ring_type_of_t<ConvexSpace>;
 
  template<convex_space ConvexSpace>
  inline constexpr std::size_t dimension_of{free_module_type_of_t<ConvexSpace>::dimension};
 
  template<class B>
  concept basis = has_free_module_type_v<B> || has_vector_space_type_v<B>;
 
  template<class B, class M>
  concept basis_for = basis<B> && (    requires { requires std::is_same_v<typename B::free_module_type, M> ; }
                                    || requires { requires std::is_same_v<typename B::vector_space_type, M>; });
 
  template<class V, class ConvexSpace>
  inline constexpr bool validator_for_single_value{
       (dimension_of<ConvexSpace> == 1)
    && requires(V& v, const space_value_type<ConvexSpace>& val) { { v(val) } -> std::convertible_to<decltype(val)>; }
  };
 
  template<class V, class ConvexSpace>
  inline constexpr bool validator_for_array{
    requires (V& v, const std::array<space_value_type<ConvexSpace>, dimension_of<ConvexSpace>>& values) {
      { v(values) } -> std::convertible_to<decltype(values)>;
    }
  };
 
  template<class V, class ConvexSpace>
  concept validator_for =
       convex_space<ConvexSpace>
    && std::default_initializable<V>
    && std::constructible_from<V, V>
    && (validator_for_single_value<V, ConvexSpace> || validator_for_array<V, ConvexSpace>);
 
  template<class T>
  struct is_identity_validator : std::false_type {};
 
  template<class T>
  using is_identity_validator_t = is_identity_validator<T>::type;
 
  template<class T>
  inline constexpr bool is_identity_validator_v{is_identity_validator<T>::value};
 
  template<>
  struct is_identity_validator<std::identity> : std::true_type {};
 
  struct half_line_validator
  {
    template<arithmetic T>
    [[nodiscard]]
    constexpr T operator()(const T val) const
    {
      if(val < T{}) throw std::domain_error{std::format("Value {} less than zero", val)};
 
      return val;
    }
 
    template<arithmetic T>
      requires std::is_unsigned_v<T>
    [[nodiscard]]
    constexpr T operator()(const T val) const
    {
      return val;
    }
  };
 
  template<class T>
  struct defines_half_line : std::false_type {};
 
  template<class T>
  using defines_half_line_t = typename defines_half_line<T>::type;
 
  template<class T>
  inline constexpr bool defines_half_line_v{defines_half_line<T>::value};
 
  template<>
  struct defines_half_line<half_line_validator> : std::true_type {};
 
  template<class... Ts>
  struct direct_product
  {
  };
 
  template<weak_commutative_ring... Rs>
  inline constexpr bool has_common_ring_v{
    ((weak_field<Rs> && ...) || (!weak_field<Rs> && ...)) && requires { typename std::common_type<Rs...>::type; }
  };
 
  template<free_module... Ts>
    requires (sizeof...(Ts) >= 1) && has_common_ring_v<commutative_ring_type_of_t<Ts>...>
  struct direct_product<Ts...>
  {
    using set_type              = direct_product<typename Ts::set_type...>;
    using commutative_ring_type = std::common_type_t<commutative_ring_type_of_t<Ts>...>;
    using is_free_module        = std::true_type;
    constexpr static std::size_t dimension{(Ts::dimension + ...)};
  };
 
  template<affine_space... Ts>
    requires (sizeof...(Ts) >= 1) && (!free_module<Ts> && ...)
  struct direct_product<Ts...>
  {
    using set_type         = direct_product<typename Ts::set_type...>;
    using free_module_type = direct_product<free_module_type_of_t<Ts>...>;
    using is_affine_space  = std::true_type;
  };
 
  template<convex_space... Ts>
    requires (sizeof...(Ts) >= 1)
          && ((!affine_space<Ts> && ...) || ((free_module<Ts> || ...) && (!free_module<Ts> || ...)))
  struct direct_product<Ts...>
  {
    using set_type         = direct_product<typename Ts::set_type...>;
    using free_module_type = direct_product<free_module_type_of_t<Ts>...>;
    using is_convex_space  = std::true_type;
  };
 
  template<class T>
  struct is_direct_product : std::false_type {};
 
  template<class... Ts>
  struct is_direct_product<direct_product<Ts...>> : std::true_type {};
 
  template<class T>
  using is_direct_product_t = is_direct_product<T>::type;
 
  template<class T>
  inline constexpr bool is_direct_product_v = is_direct_product<T>::value;
 
  namespace sets
  {
    template<convex_space From, class To>
    struct convex_functionals
    {
    };
 
    template<vector_space From, class To>
    struct linear_functionals
    {
    };
  }
 
  template<class>
  struct dual;
 
  template<convex_space C>
    requires (!affine_space<C>)
  struct dual<C>
  {
    using set_type         = sets::convex_functionals<C, commutative_ring_type_of_t<C>>;
    using free_module_type = dual<free_module_type_of_t<C>>;
    using is_convex_space  = std::true_type;
  };
 
  template<affine_space A>
    requires (!vector_space<A>)
  struct dual<A>
  {
    using set_type         = sets::convex_functionals<A, commutative_ring_type_of_t<A>>;
    using free_module_type = dual<free_module_type_of_t<A>>;
    using is_affine_space  = std::true_type;
  };
 
  template<vector_space V>
  struct dual<V>
  {    
    using field_type      = commutative_ring_type_of_t<V>;
    using set_type        = sets::linear_functionals<V, field_type>;
    using is_vector_space = std::true_type;
    constexpr static auto dimension{V::dimension};
  };
 
  template<class T>
  struct is_dual : std::false_type {};
 
  template<class T>
  struct is_dual<dual<T>> : std::true_type {};
 
  template<class T>
  using is_dual_t = is_dual<T>::type;
 
  template<class T>
  inline constexpr bool is_dual_v{is_dual<T>::value};
 
  template<class>
  struct dual_of;
 
  template<class T>
  using dual_of_t = dual_of<T>::type;
 
  template<class T>
  struct dual_of {
    using type = dual<T>;
  };
 
  template<class T>
    requires (!convex_space<T>) || (convex_space<T> && weak_field<commutative_ring_type_of_t<T>>)
  struct dual_of<dual<T>> {
    using type = T;
  };
 
  struct distinguished_origin {};
 
  template<
    convex_space ConvexSpace,
    basis_for<free_module_type_of_t<ConvexSpace>> Basis,
    class Origin,
    validator_for<ConvexSpace> Validator
  >
  class coordinates;
 
  template<affine_space AffineSpace, basis_for<free_module_type_of_t<AffineSpace>> Basis, class Origin>
  using affine_coordinates = coordinates<AffineSpace, Basis, Origin, std::identity>;
 
  template<vector_space VectorSpace, basis_for<free_module_type_of_t<VectorSpace>> Basis>
  using vector_coordinates = affine_coordinates<VectorSpace, Basis, distinguished_origin>;
 
  template<free_module FreeModule, basis_for<free_module_type_of_t<FreeModule>> Basis>
  using free_module_coordinates = coordinates<FreeModule, Basis, distinguished_origin, std::identity>;
  
  template<
    convex_space ConvexSpace,
    basis_for<free_module_type_of_t<ConvexSpace>> Basis,
    class Origin,
    validator_for<ConvexSpace> Validator,
    class DisplacementCoordinates=free_module_coordinates<free_module_type_of_t<ConvexSpace>, Basis>
  >
  class coordinates_base
  {
  public:
    using convex_space_type             = ConvexSpace;   
    using basis_type                    = Basis;
    using validator_type                = Validator;
    using origin_type                   = Origin;
    using set_type                      = ConvexSpace::set_type;
    using free_module_type              = free_module_type_of_t<ConvexSpace>;
    using commutative_ring_type         = commutative_ring_type_of_t<ConvexSpace>;
    using value_type                    = commutative_ring_type;
    using displacement_coordinates_type = DisplacementCoordinates;
 
    constexpr static bool has_distinguished_origin{std::is_same_v<Origin, distinguished_origin>};
    constexpr static bool has_identity_validator{is_identity_validator_v<Validator>};
    constexpr static bool has_freely_mutable_components{has_identity_validator && has_distinguished_origin};
    constexpr static std::size_t dimension{free_module_type::dimension};
    constexpr static std::size_t D{dimension};
 
    constexpr coordinates_base() noexcept = default;
 
    constexpr explicit coordinates_base(std::span<const value_type, D> vals) noexcept(has_identity_validator)
      : m_Values{validate(vals, m_Validator)}
    {}
 
    template<class... Ts>
      requires (D > 1) && (std::convertible_to<Ts, value_type> && ...)
    constexpr explicit(sizeof...(Ts) == 1) coordinates_base(Ts... ts) noexcept(has_identity_validator)
      : m_Values{m_Validator(std::array<value_type, D>{ts...})}
    {}
 
    template<class T>
      requires (D == 1) && (std::convertible_to<T, value_type>)
    constexpr explicit coordinates_base(T val) noexcept(has_identity_validator)
      : m_Values{m_Validator(val)}
    {}
 
    template<class Self>
    constexpr Self& operator+=(this Self& self, const displacement_coordinates_type& v) noexcept(has_identity_validator)
    {
      self.apply_to_each_element(v.values(), [](value_type& lhs, value_type rhs){ lhs += rhs; });
      return self;
    }
 
    template<class Self>
      requires has_distinguished_origin && (!std::is_same_v<coordinates_base, displacement_coordinates_type>)
    constexpr Self& operator+=(this Self& self, const coordinates_base& v) noexcept(has_identity_validator)
    {
      self.apply_to_each_element(v.values(), [](value_type& lhs, value_type rhs){ lhs += rhs; });
      return self;
    }
 
    template<class Self>
    constexpr Self& operator-=(this Self& self, const displacement_coordinates_type& v) noexcept(has_identity_validator)
    {
      self.apply_to_each_element(v.values(), [](value_type& lhs, value_type rhs){ lhs -= rhs; });
      return self;
    }
 
    template<class Self>
    constexpr Self& operator*=(this Self& self, value_type u) noexcept(has_identity_validator)
      requires has_distinguished_origin
    {
      self.for_each_element([u](value_type& x) { return x *= u; });
      return self;
    }
 
    template<class Self>
    constexpr Self& operator/=(this Self& self, value_type u)
      requires vector_space<free_module_type> && has_distinguished_origin
    {
      self.for_each_element([u](value_type& x) { return x /= u; });
      return self;
    }
 
    template<class Self>
    [[nodiscard]]
    constexpr Self operator+(this const Self& self) noexcept
    {
      return self;
    }
 
    template<class Self>
      requires    std::constructible_from<Self, std::span<const value_type, D>>
               && has_distinguished_origin
               && (!std::is_unsigned_v<value_type>)
    [[nodiscard]]
    constexpr Self operator-(this const Self& self) noexcept(has_identity_validator)
    {
      return Self{utilities::to_array(self.values(), [](value_type t) { return -t; })};
    }
 
    template<class Derived>
      requires std::is_base_of_v<coordinates_base, Derived>
            && (!std::is_same_v<Derived, displacement_coordinates_type>)
            && std::constructible_from<typename Derived::displacement_coordinates_type, std::span<const value_type, D>>
    [[nodiscard]]
    friend constexpr typename Derived::displacement_coordinates_type operator-(const Derived& lhs, const Derived& rhs) noexcept(has_identity_validator)
    {
      return[&] <std::size_t... Is>(std::index_sequence<Is...>) {
        return typename Derived::displacement_coordinates_type{(lhs.values()[Is] - rhs.values()[Is])...};
      }(std::make_index_sequence<D>{});
    }
 
    template<class Derived>
      requires std::is_base_of_v<coordinates_base, Derived>
    [[nodiscard]]
    friend constexpr Derived operator+(Derived c, const displacement_coordinates_type& v) noexcept(has_identity_validator) { return c += v; }
 
    template<class Derived>
    requires std::is_base_of_v<coordinates_base, Derived> && (!std::is_same_v<Derived, displacement_coordinates_type>)
    [[nodiscard]]
    friend constexpr Derived operator+(const displacement_coordinates_type& v, Derived c) noexcept(has_identity_validator)
    {
      return c += v;
    }
  
    template<class Derived>
      requires std::is_base_of_v<coordinates_base, Derived> && (!std::is_same_v<Derived, displacement_coordinates_type>) && has_distinguished_origin 
    [[nodiscard]]
    friend constexpr Derived operator+(Derived c, const Derived& v) noexcept(has_identity_validator)
    {
      return c += v;
    }
 
    template<class Derived>
      requires std::is_base_of_v<coordinates_base, Derived>
    [[nodiscard]]
    friend constexpr Derived operator-(Derived c, const displacement_coordinates_type& v) noexcept(has_identity_validator)
    {
      return c -= v;
    }
 
    template<class Derived>
      requires std::is_base_of_v<coordinates_base, Derived> && has_distinguished_origin
    [[nodiscard]]
    friend constexpr Derived operator*(Derived v, value_type u) noexcept(has_identity_validator)
    {
      return v *= u;
    }
 
    template<class Derived>
      requires std::is_base_of_v<coordinates_base, Derived> && has_distinguished_origin
    [[nodiscard]]
    friend constexpr Derived operator*(value_type u, Derived v) noexcept(has_identity_validator)
    {
      return v * u;
    }
 
    template<class Derived>
      requires std::is_base_of_v<coordinates_base, Derived> && vector_space<free_module_type> && has_distinguished_origin
    [[nodiscard]]
    friend constexpr Derived operator/(Derived v, value_type u)
    {
      return v /= u;
    }
 
    [[nodiscard]]
    constexpr const validator_type& validator() const noexcept { return m_Validator; }
 
    [[nodiscard]]
    constexpr std::span<const value_type, D> values() const noexcept { return m_Values; }
 
    [[nodiscard]]
    constexpr std::span<value_type, D> values() noexcept requires has_freely_mutable_components { return m_Values; }
 
    [[nodiscard]]
    constexpr const value_type& value() const noexcept requires (D == 1) { return m_Values[0]; }
 
    [[nodiscard]]
    constexpr value_type& value() noexcept requires (D == 1) && has_freely_mutable_components { return m_Values[0]; }
 
    [[nodiscard]]
    constexpr explicit operator bool() const noexcept requires (D == 1) && std::convertible_to<value_type, bool>
    {
      return m_Values[0];
    }
 
    [[nodiscard]]
    constexpr value_type operator[](std::size_t i) const { return m_Values[i]; }
 
    [[nodiscard]]
    constexpr value_type& operator[](std::size_t i) requires has_freely_mutable_components { return m_Values[i]; }
 
    [[nodiscard]]
    constexpr auto begin() const noexcept { return m_Values.begin(); }
 
    [[nodiscard]]
    constexpr auto end() const noexcept { return m_Values.end(); }
 
    [[nodiscard]]
    constexpr auto rbegin() const noexcept { return m_Values.rbegin(); }
 
    [[nodiscard]]
    constexpr auto rend() const noexcept { return m_Values.rend(); }
 
    [[nodiscard]]
    constexpr auto cbegin() const noexcept { return begin(); }
 
    [[nodiscard]]
    constexpr auto cend() const noexcept { return end(); }
 
    [[nodiscard]]
    constexpr auto crbegin() const noexcept { return rbegin(); }
 
    [[nodiscard]]
    constexpr auto crend() const noexcept { return rend(); }
 
    [[nodiscard]]
    constexpr auto begin() noexcept requires has_freely_mutable_components { return m_Values.begin(); }
 
    [[nodiscard]]
    constexpr auto end() noexcept requires has_freely_mutable_components { return m_Values.end(); }
 
    [[nodiscard]]
    constexpr auto rbegin() noexcept requires has_freely_mutable_components { return m_Values.rbegin(); }
 
    [[nodiscard]]
    constexpr auto rend() noexcept requires has_freely_mutable_components { return m_Values.rend(); }
 
 
    [[nodiscard]]
    friend constexpr bool operator==(const coordinates_base& lhs, const coordinates_base& rhs) noexcept { return lhs.m_Values == rhs.m_Values; }
 
    [[nodiscard]]
    friend constexpr auto operator<=>(const coordinates_base& lhs, const coordinates_base& rhs) noexcept
      requires (D == 1) && std::totally_ordered<value_type>
    {
      return lhs.value() <=> rhs.value();
    }
  protected:
    coordinates_base(const coordinates_base&)     = default;
    coordinates_base(coordinates_base&&) noexcept = default;
 
    coordinates_base& operator=(const coordinates_base&)     = default;
    coordinates_base& operator=(coordinates_base&&) noexcept = default;
 
    ~coordinates_base() = default;
    
    template<class Self, class Fn>
      requires std::invocable<Fn, value_type&, value_type>
    constexpr void apply_to_each_element(this Self& self, std::span<const value_type, D> rhs, Fn f)
    {
      if constexpr(has_identity_validator)
      {
        std::ranges::for_each(std::views::zip(self.m_Values, rhs), [&f](auto&& z){ f(std::get<0>(z), std::get<1>(z)); });
      }
      else
      {
        auto tmp{self.m_Values};
        std::ranges::for_each(std::views::zip(tmp, rhs), [&f](auto&& z){ f(std::get<0>(z), std::get<1>(z)); });
        self.m_Values = validate(tmp, self.m_Validator);
      }
    }
 
    template<class Self, class Fn>
      requires std::invocable<Fn, value_type&>
    constexpr void for_each_element(this Self& self, Fn f)
    {
      if constexpr(has_identity_validator)
      {
        std::ranges::for_each(self.values(), f);
      }
      else
      {
        auto tmp{self.m_Values};
        std::ranges::for_each(tmp, f);
        self.m_Values = validate(tmp, self.m_Validator);
      }
    }
  private:
    SEQUOIA_NO_UNIQUE_ADDRESS validator_type m_Validator;
    std::array<value_type, D> m_Values{};
 
    [[nodiscard]]
    static std::array<value_type, D> validate(std::span<const value_type, D> vals, Validator& validator)
    {
      return validate(utilities::to_array(vals), validator);
    }
 
    [[nodiscard]]
    static std::array<value_type, D> validate(std::array<value_type, D> vals, Validator& validator)
    {
      if constexpr(validator_for_array<Validator, ConvexSpace>)
        return validator(vals);
      else
        return {validator(vals.front())};
    }
  };
 
  template<convex_space ConvexSpace, basis_for<free_module_type_of_t<ConvexSpace>> Basis, class Origin, validator_for<ConvexSpace> Validator>
  class coordinates final : public coordinates_base<ConvexSpace, Basis, Origin, Validator>
  {
  public:
    using coordinates_base<ConvexSpace, Basis, Origin, Validator>::coordinates_base;
  };
 
  namespace sets
  {
    template<std::size_t D>
    struct Z
    {
      constexpr static std::size_t dimension{D};
    };
 
    template<std::size_t D>
    struct N_0
    {
      constexpr static std::size_t dimension{D};
    };
 
    template<std::size_t D>
    struct R
    {
      constexpr static std::size_t dimension{D};
    };
 
 
    template<std::size_t D>
    struct orthant
    {
      constexpr static std::size_t dimension{D};
    };
 
    template<std::size_t D>
    struct C
    {
      constexpr static std::size_t dimension{D};
    };
  }
 
  template<class B>
  inline constexpr bool is_orthonormal_basis_v{
    requires {
      typename B::orthonormal;
      requires std::same_as<typename B::orthonormal, std::true_type>;
    }
  };
 
  template<vector_space V>
  struct arbitary_basis {};
 
  template<vector_space V>
  inline constexpr bool has_norm_v{
    requires (const vector_coordinates<V, arbitary_basis<V>>& v) {
      { norm(v) } -> std::convertible_to<typename V::field_type>;
    }
  };
 
  template<vector_space V>
  inline constexpr bool has_inner_product_v{
    requires (const vector_coordinates<V, arbitary_basis<V>>& v) {
      { inner_product(v, v) } -> std::convertible_to<typename V::field_type>;
    }
  };
 
  template<class V>
  concept normed_vector_space = vector_space<V> && has_norm_v<V>;
 
  template<class V>
  concept inner_product_space = vector_space<V> && has_inner_product_v<V>;
 
  struct mathematical_arena {};
 
  template<std::floating_point T, std::size_t D, class Arena=mathematical_arena>
  struct euclidean_vector_space
  {
    using set_type        = sets::R<D>;
    using field_type      = T;
    using is_vector_space = std::true_type;
    using arena_type      = Arena;
    constexpr static std::size_t dimension{D};
 
    template<basis Basis>
      requires is_orthonormal_basis_v<Basis>
    [[nodiscard]]
    friend constexpr field_type inner_product(const vector_coordinates<euclidean_vector_space, Basis>& v, const vector_coordinates<euclidean_vector_space, Basis>& w)
    {
      return std::ranges::fold_left(std::views::zip(v.values(), w.values()), field_type{}, [](field_type f, const auto& z){ return f + std::get<0>(z) * std::get<1>(z); });
    }
 
    template<basis Basis>
      requires is_orthonormal_basis_v<Basis>
    [[nodiscard]]
    friend constexpr field_type dot(const vector_coordinates<euclidean_vector_space, Basis>& v, const vector_coordinates<euclidean_vector_space, Basis>& w)
    {
      return inner_product(v, w);
    }
 
    template<basis Basis>
      requires is_orthonormal_basis_v<Basis>
    [[nodiscard]]
    friend constexpr field_type norm(const vector_coordinates<euclidean_vector_space, Basis>& v)
    {
      if constexpr(D == 1)
      {
        return std::abs(v.value());
      }
      else
      {
        return std::sqrt(inner_product(v, v));
      }
    }
  };
 
  template<std::floating_point T, std::size_t D, class Arena=mathematical_arena>
  struct euclidean_affine_space
  {
    using set_type          = sets::R<D>;
    using vector_space_type = euclidean_vector_space<T, D, Arena>;
    using is_affine_space   = std::true_type;
    using arena_type        = Arena;
  };
 
  template<std::floating_point T, class Arena=mathematical_arena>
  struct euclidean_half_space
  {
    using set_type          = sets::orthant<1>;
    using vector_space_type = euclidean_vector_space<T, 1>;
    using is_convex_space   = std::true_type;
    using arena_type        = Arena;
  };
 
  template<std::floating_point T, std::size_t D, basis Basis, class Origin, class Arena=mathematical_arena>
  using euclidean_affine_coordinates = affine_coordinates<euclidean_affine_space<T, D, Arena>, Basis, Origin>;
 
  template<std::floating_point T, std::size_t D, basis Basis, class Arena=mathematical_arena>
  using euclidean_vector_coordinates = vector_coordinates<euclidean_vector_space<T, D, Arena>, Basis>;
 
  template<free_module M>
  struct canonical_right_handed_basis
  {
    using free_module_type = M;
  };
 
  template<free_module M>
  struct dual_of<canonical_right_handed_basis<M>>
  {
    using type = canonical_right_handed_basis<dual_of_t<M>>;
  };
 
  template<free_module M>
  struct dual_of<canonical_right_handed_basis<dual<M>>>
  {
    using type = canonical_right_handed_basis<M>;
  };   
 
  template<std::floating_point T, std::size_t D, class Arena=mathematical_arena>
  using vec_coords = euclidean_vector_coordinates<T, D, canonical_right_handed_basis<euclidean_vector_space<T, D, Arena>>, Arena>;
}