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/Maths/Algebra/Ratio.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<class>
  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<class T>
  using free_module_type_of_t = free_module_type_of<T>::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<free_module V>
  inline constexpr bool has_admits_canonical_basis_v{
    requires{
      typename V::admits_canonical_basis;
    }
  };
 
  template<free_module M>
  struct admits_canonical_basis : std::false_type {};
 
  template<free_module M>
    requires has_admits_canonical_basis_v<M> && std::convertible_to<typename M::admits_canonical_basis, std::true_type>
  struct admits_canonical_basis<M> : std::true_type {};
 
  template<free_module M>
  using admits_canonical_basis_t = admits_canonical_basis<M>::type;
 
  template<free_module M>
  inline constexpr bool admits_canonical_basis_v{admits_canonical_basis<M>::value};
 
  template<class T>
  inline constexpr bool identifies_as_basis_v{
     requires {
      typename T::is_basis;
      requires std::convertible_to<typename T::is_basis, std::true_type>;
    }
  };
  
  template<class B>
  concept basis = identifies_as_basis_v<B> && (has_free_module_type_v<B> || has_vector_space_type_v<B>);
 
  template<basis B>
    requires has_free_module_type_v<B>
  struct free_module_type_of<B>
  {
    using type = B::free_module_type;
  };
 
  template<basis B>
    requires has_vector_space_type_v<B>
  struct free_module_type_of<B>
  {
    using type = B::vector_space_type;
  };
 
  template<class T>
  inline constexpr bool has_isomorphism_type_v{
    requires { typename T::isomorphism_type; }
  };
 
  struct identity_isomorphism {};
 
  template<basis B>
  struct basis_isomorphism_type_of;
  
  template<basis B>
    requires admits_canonical_basis_v<free_module_type_of_t<B>>
  struct basis_isomorphism_type_of<B>
  {
    using type = identity_isomorphism;
  };
 
  template<basis B>
  using basis_isomorphism_type_of_t = basis_isomorphism_type_of<B>::type;
 
  template<basis B>
    requires (!admits_canonical_basis_v<free_module_type_of_t<B>>) && has_isomorphism_type_v<B>
  struct basis_isomorphism_type_of<B>
  {
    using type = B::isomorphism_type;
  };
 
  template<class B, class M>
  concept basis_for
    =    basis<B>
      && (admits_canonical_basis_v<free_module_type_of_t<B>> || has_isomorphism_type_v<B>)
      && requires { requires std::is_same_v<free_module_type_of_t<B>, 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 defines_identity_validator : std::false_type {};
 
  template<class T>
  using defines_identity_validator_t = defines_identity_validator<T>::type;
 
  template<class T>
  inline constexpr bool defines_identity_validator_v{defines_identity_validator<T>::value};
 
  template<>
  struct defines_identity_validator<std::identity> : std::true_type {};
 
  struct half_line_validator
  {
    template<arithmetic T>
    constexpr T operator()(const T val) const
    {
      if(val < T{}) throw std::domain_error{std::format("Domain error: attempting to use a value of {} for a semi-positive quantity", val)};
 
      return val;
    }
 
    template<arithmetic T>
      requires std::is_unsigned_v<T>
    [[nodiscard]]
    constexpr T operator()(const T val) const
    {
      return val;
    }
  };
 
  template<std::floating_point T, T Lower, T Upper=std::numeric_limits<T>::infinity()>
    requires (Upper > Lower)
  struct interval_validator
  {
    constexpr static T lower{Lower}, upper{Upper};
    
    template<std::floating_point U>
      requires (sizeof(U) <= sizeof(T))
    constexpr U operator()(const U val) const
    {
      if constexpr(Lower > -std::numeric_limits<T>::infinity())
      {
        if(const auto ulower{static_cast<U>(Lower)}; val < ulower)
          throw std::domain_error{std::format("interval_validator: invoked with {}, but values should be >= {} ", val, ulower)};
      }
 
      if constexpr(Upper < std::numeric_limits<T>::infinity())
      {
        if(const auto uUpper{static_cast<U>(Upper)}; val > uUpper)
          throw std::domain_error{std::format("interval_validator: invoked with {}, but values should be <= {} ", val, uUpper)};
      }
 
      return val;
    }
 
    template<std::floating_point U, std::size_t D>
      requires (sizeof(U) <= sizeof(T))
    constexpr const std::array<U, D>&  operator()(const std::array<U, D>& vals) const
    {
      for(const auto v : vals)
        (*this)(v);
      
      return vals;
    }
  };
 
  template<class T>
  struct is_interval_validator : std::false_type {};
 
  template<class T>
  using is_interval_validator_t = is_interval_validator<T>::type;
 
  template<class T>
  inline constexpr bool is_interval_validator_v{is_interval_validator<T>::value};
 
  template<std::floating_point T, T Lower, T Upper>
  struct is_interval_validator<interval_validator<T, Lower, Upper>> : std::true_type {};
 
  template<class T>
  struct defines_half_line_validator : std::false_type {};
 
  template<class T>
  using defines_half_line_validator_t = typename defines_half_line_validator<T>::type;
 
  template<class T>
  inline constexpr bool defines_half_line_validator_v{defines_half_line_validator<T>::value};
 
  template<>
  struct defines_half_line_validator<half_line_validator> : std::true_type {};
 
  template<std::floating_point T, T Lower, T Upper>
  struct defines_half_line_validator<interval_validator<T, Lower, Upper>>
    : std::bool_constant<(Lower == T{}) && (Upper == std::numeric_limits<T>::infinity())>
  {};
 
  template<std::floating_point T, T Lower, T Upper>
  struct defines_identity_validator<interval_validator<T, Lower, Upper>>
    : std::bool_constant<(Lower == -std::numeric_limits<T>::infinity()) && (Upper == std::numeric_limits<T>::infinity())>
  {};
 
  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;
 
  template<class T>
  struct direct_product_cardinality;
 
  template<class T>
  inline constexpr std::size_t direct_product_cardinality_v{direct_product_cardinality<T>::value};
 
  template<class... Ts>
  struct direct_product_cardinality<direct_product<Ts...>>
  {
    constexpr static auto value{sizeof...(Ts)};
  };
 
  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;
  };
  
  template<convex_space C>
  struct is_non_negative_orthant : std::false_type
  {};
 
  template<convex_space C>
  using is_non_negative_orthant_t = is_non_negative_orthant<C>::type;
 
  template<convex_space C>
  inline constexpr bool is_non_negative_orthant_v{is_non_negative_orthant<C>::value};
 
  template<convex_space Space>
  inline constexpr bool has_non_negative_orthant_type_v{
    requires {
      typename Space::non_negative_orthant;
    }
  };
 
  template<convex_space C>
      requires has_non_negative_orthant_type_v<C> && std::convertible_to<typename C::non_negative_orthant, std::true_type>
  struct is_non_negative_orthant<C> : std::true_type
  {
    static_assert(!affine_space<C>);
  };
  
  template<convex_space C>
  struct is_non_negative_orthant<dual<C>> : is_non_negative_orthant<C>
  {
  };
  
 
  template<convex_space Space>
  inline constexpr bool has_distinguished_origin_type_v{
    requires {
      typename Space::distinguished_origin;
    }
  };
  
  template<convex_space Space>
  struct has_distinguished_origin : std::false_type
  {};
  
  template<convex_space Space>
  using has_distinguished_origin_t = has_distinguished_origin<Space>::type;
 
  template<convex_space Space>
  inline constexpr bool has_distinguished_origin_v{has_distinguished_origin<Space>::value};
 
  template<convex_space Space>
    requires has_distinguished_origin_type_v<Space> && std::convertible_to<typename Space::distinguished_origin, std::true_type>
  struct has_distinguished_origin<Space> : std::true_type
  {
  };
 
  template<convex_space Space>
    requires (!has_distinguished_origin_type_v<Space>) && is_non_negative_orthant_v<Space>
  struct has_distinguished_origin<Space> : std::true_type
  {
  };
 
  template<free_module Space>
  struct has_distinguished_origin<Space> : std::true_type
  {};
 
  template<affine_space Space>
    requires (!free_module<Space>)
  struct has_distinguished_origin<Space> : std::false_type
  {};
 
  template<convex_space Space>
  struct has_distinguished_origin<dual<Space>> : has_distinguished_origin<Space>
  {
  };
 
  template<
    convex_space ConvexSpace,
    basis_for<free_module_type_of_t<ConvexSpace>> Basis,
    class... Ts
  >
  class coordinates;
 
  template<affine_space AffineSpace, basis_for<free_module_type_of_t<AffineSpace>> Basis, class Origin>
  using affine_coordinates = coordinates<AffineSpace, Basis, Origin>;
 
  template<vector_space VectorSpace, basis_for<free_module_type_of_t<VectorSpace>> Basis>
  using vector_coordinates = coordinates<VectorSpace, Basis>;
 
  template<free_module FreeModule, basis_for<free_module_type_of_t<FreeModule>> Basis>
  using free_module_coordinates = coordinates<FreeModule, Basis>;
  
  namespace impl
  {
    template<basis B, class Rep, class...>
    struct is_units_terminated_pack : std::false_type {};
 
    template<basis B, class Rep, class... Args, std::size_t... Is>
      requires (sizeof...(Args) == sizeof...(Is) + 1)
            && std::same_as<std::tuple_element_t<sizeof...(Is), std::tuple<Args...>>, basis_isomorphism_type_of_t<B>>
            && (std::same_as<std::tuple_element_t<Is, std::tuple<Args...>>, Rep> && ...)
    struct is_units_terminated_pack<B, Rep, std::tuple<Args...>, std::index_sequence<Is...>> : std::true_type
    {
    };
  }
 
  template<basis B, class Rep, class... Args>
  struct is_units_terminated_pack : std::false_type
  {};
  
  template<basis B, class Rep, class... Args>
    requires (sizeof...(Args) > 1)
  struct is_units_terminated_pack<B, Rep, Args...>
    : impl::is_units_terminated_pack<B, Rep, std::tuple<Args...>, std::make_index_sequence<sizeof...(Args) - 1>>
  {};
 
  template<basis B, class Rep, class... Args>
  inline constexpr bool is_units_terminated_pack_v{is_units_terminated_pack<B, Rep, Args...>::value};
  
  template<
    convex_space ConvexSpace,
    basis_for<free_module_type_of_t<ConvexSpace>> Basis,
    validator_for<ConvexSpace> Validator,
    class DisplacementCoordinates=free_module_coordinates<free_module_type_of_t<ConvexSpace>, Basis>
  >
  class coordinates_base
  {
  public:
    using space_type                    = ConvexSpace;   
    using basis_type                    = Basis;
    using validator_type                = Validator;
    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;
    using basis_isomorphism_type        = basis_isomorphism_type_of_t<Basis>;
 
    // TO DO: improve conventions
    constexpr static bool has_distinguished_origin{has_distinguished_origin_v<ConvexSpace>};
    constexpr static bool has_identity_validator{defines_identity_validator_v<Validator>};
    constexpr static bool has_freely_mutable_components{has_identity_validator && has_distinguished_origin};
    constexpr static bool admits_canonical_basis{admits_canonical_basis_v<free_module_type>};
    
    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)
      requires admits_canonical_basis
      : coordinates_base{vals, basis_isomorphism_type{}}
    {}
 
    constexpr coordinates_base(std::span<const value_type, D> vals, basis_isomorphism_type) noexcept(has_identity_validator)
      : m_Values{validate(vals, m_Validator)}
    {}
 
    template<class... Ts>
      requires admits_canonical_basis && (D > 1) && (std::convertible_to<Ts, value_type> && ...)
    constexpr explicit(sizeof...(Ts) == 1) coordinates_base(Ts... ts) noexcept(has_identity_validator)
      : coordinates_base{ts..., basis_isomorphism_type{}}
    {}
 
    template<class... Ts>
      requires (D > 1) && (sizeof...(Ts) > 1) && is_units_terminated_pack_v<basis_type, value_type, Ts...>
    constexpr coordinates_base(Ts... ts) noexcept(has_identity_validator)
      : coordinates_base{std::make_index_sequence<sizeof...(Ts) - 1>{}, std::tuple{ts...}}
    {}
 
    constexpr explicit coordinates_base(value_type val) noexcept(has_identity_validator)      
      requires admits_canonical_basis && (D == 1)
      : coordinates_base{val, basis_isomorphism_type{}}
    {}
 
    constexpr coordinates_base(value_type val, basis_isomorphism_type) noexcept(has_identity_validator)
      : m_Values{m_Validator(val)}
    {}
 
    template<class Self>
      requires (!std::same_as<Self, coordinates_base>)
    constexpr Self& operator+=(this Self& self, const displacement_coordinates_type& v) noexcept(has_identity_validator)
    {
      return self = (self + v);
    }
 
    template<class Self>
      requires    (!std::same_as<Self, coordinates_base>)
               && has_distinguished_origin
               && (!std::same_as<coordinates_base, displacement_coordinates_type>)
    constexpr Self& operator+=(this Self& self, const coordinates_base& v) noexcept(has_identity_validator)
    {
      return self = (self + v);
    }
 
    template<class Self>
      requires (!std::same_as<Self, coordinates_base>) 
    constexpr Self& operator-=(this Self& self, const displacement_coordinates_type& v) noexcept(has_identity_validator)
    {
       return self = (self - v);
    }
 
    template<class Self>
      requires (!std::same_as<Self, coordinates_base>) && has_distinguished_origin
    constexpr Self& operator*=(this Self& self, value_type u) noexcept(has_identity_validator)
    {
      return self = (self * u);
    }
 
    template<class Self>
      requires (!std::same_as<Self, coordinates_base>)  && has_distinguished_origin
    constexpr Self& operator*=(this Self& self, std::span<const value_type, D> u) noexcept(has_identity_validator)
    {
      return self = (self * u);
    }
 
    template<class Self>
      requires (!std::same_as<Self, coordinates_base>)  && vector_space<free_module_type>
    constexpr Self& operator/=(this Self& self, value_type u)
    {
      return self = (self / u);
    }
 
    template<class Self>
      requires (!std::same_as<Self, coordinates_base>) && vector_space<free_module_type>
    constexpr Self& operator/=(this Self& self, std::span<const value_type, D> u)
    {
      return self = (self / u);
    }
 
    template<class Self>
      requires (!std::same_as<Self, coordinates_base>) 
    [[nodiscard]]
    constexpr Self operator+(this const Self& self) noexcept
    {
      return self;
    }
 
    template<class Self>
      requires (!std::same_as<Self, coordinates_base>) 
            && has_distinguished_origin
            && (!is_non_negative_orthant_v<space_type>)
            && (!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; }), basis_isomorphism_type{}};
    }
 
    template<class Derived>
      requires std::derived_from<Derived, coordinates_base>
            && (!std::same_as<Derived, displacement_coordinates_type>)
    [[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])..., basis_isomorphism_type{}};
      }(std::make_index_sequence<D>{});
    }
 
    template<class Derived>
      requires std::derived_from<Derived, coordinates_base>
    [[nodiscard]]
    friend constexpr Derived operator+(Derived c, const displacement_coordinates_type& v) noexcept(has_identity_validator)
    {
      return c.apply_to_each_element(v.values(), [](value_type& lhs, value_type rhs){ lhs += rhs; });
    }
 
    template<class Derived>
      requires std::derived_from<Derived, coordinates_base>  && (!std::same_as<Derived, displacement_coordinates_type>)
    [[nodiscard]]
    friend constexpr Derived operator+(const displacement_coordinates_type& v, Derived c) noexcept(has_identity_validator)
    {
      return v + c;
    }
  
    template<class Derived>
      requires    std::derived_from<Derived, coordinates_base>
               && (!std::same_as<Derived, displacement_coordinates_type>)
               && has_distinguished_origin 
    [[nodiscard]]
    friend constexpr Derived operator+(Derived c, const Derived& v) noexcept(has_identity_validator)
    {
      return c.apply_to_each_element(v.values(), [](value_type& lhs, value_type rhs){ lhs += rhs; });
    }
 
    template<class Derived>
      requires std::derived_from<Derived, coordinates_base>
    [[nodiscard]]
    friend constexpr Derived operator-(Derived c, const displacement_coordinates_type& v) noexcept(has_identity_validator)
    {
      return c.apply_to_each_element(v.values(), [](value_type& lhs, value_type rhs){ lhs -= rhs; });
    }
 
    template<class Derived>
      requires std::derived_from<Derived, coordinates_base> && has_distinguished_origin
    [[nodiscard]]
    friend constexpr Derived operator*(Derived v, value_type u) noexcept(has_identity_validator)
    {
      return v.for_each_element([u](value_type& x) { return x *= u; });
    }
 
    template<class Derived>
      requires std::derived_from<Derived, coordinates_base> && 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::derived_from<Derived, coordinates_base> && has_distinguished_origin
    [[nodiscard]]
    friend constexpr Derived operator*(Derived c, std::span<const value_type, D> u) noexcept(has_identity_validator)
    {
      return c.apply_to_each_element(u, [](value_type& lhs, value_type rhs){ lhs *= rhs; });
    }
    
    template<class Derived>
      requires std::derived_from<Derived, coordinates_base> && has_distinguished_origin
    [[nodiscard]]
    friend constexpr Derived operator*(std::span<const value_type, D> u, Derived c) noexcept(has_identity_validator)
    {
      return c * u;
    }
 
    template<class Derived>
      requires std::derived_from<Derived, coordinates_base> && vector_space<free_module_type> && has_distinguished_origin
    [[nodiscard]]
    friend constexpr Derived operator/(Derived v, value_type u)
    {
      return v.for_each_element([u](value_type& x) { return x /= u; });
    }
 
    template<class Derived>
      requires std::derived_from<Derived, coordinates_base> && has_distinguished_origin
    [[nodiscard]]
    friend constexpr Derived operator/(Derived c, std::span<const value_type, D> u) noexcept(has_identity_validator)
    {
      return c.apply_to_each_element(u, [](value_type& lhs, value_type rhs){ lhs /= rhs; });
    }
 
    [[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 Self&& 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);
      }
 
      return std::forward<Self>(self);
    }
 
    template<class Self, class Fn>
      requires std::invocable<Fn, value_type&>
    constexpr Self& 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);
      }
 
      return self;
    }
  private:
    SEQUOIA_NO_UNIQUE_ADDRESS validator_type m_Validator;
    std::array<value_type, D> m_Values{};
 
    template<std::size_t... Is, class... Args> 
    constexpr coordinates_base(std::index_sequence<Is...>, const std::tuple<Args...>& args)
      : m_Values{m_Validator(std::array<value_type, D>{std::get<Is>(args)...})}
    {}
    
    [[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<ConvexSpace, Basis, Origin, Validator> final
    : public coordinates_base<ConvexSpace, Basis, Validator>
  {
  public:
    using origin_type = Origin;
 
    using coordinates_base<ConvexSpace, Basis, Validator>::coordinates_base;
  };
 
  template<convex_space ConvexSpace, basis_for<free_module_type_of_t<ConvexSpace>> Basis, validator_for<ConvexSpace> Validator>
    requires has_distinguished_origin_v<ConvexSpace>
  class coordinates<ConvexSpace, Basis, Validator> final
    : public coordinates_base<ConvexSpace, Basis, Validator>
  {
  public:
    using coordinates_base<ConvexSpace, Basis, Validator>::coordinates_base;
  };
 
  template<affine_space AffineSpace, basis_for<free_module_type_of_t<AffineSpace>> Basis, class Origin>
    requires (!free_module<AffineSpace>)
  class coordinates<AffineSpace, Basis, Origin> final
    : public coordinates_base<AffineSpace, Basis, std::identity>
  {
  public:
    using origin_type = Origin;
    
    using coordinates_base<AffineSpace, Basis, std::identity>::coordinates_base;
  };
 
  template<free_module M, basis_for<free_module_type_of_t<M>> Basis>    
  class coordinates<M, Basis> final
    : public coordinates_base<M, Basis, std::identity>
  {
  public:
    using coordinates_base<M, Basis, std::identity>::coordinates_base;
  };
 
  template<class From, class To>
  struct coordinate_transformation
  {
  };
 
  template<class From, class To>
  inline constexpr bool has_coordinate_transformation_v{
    requires (const From& f){
      { std::declval<coordinate_transformation<From, To>>()(f) } -> std::convertible_to<To>;
    }
  };
 
  template<class From, class To>
  inline constexpr bool has_noexcept_coordinate_transformation_v{
       has_coordinate_transformation_v<From, To>
    && requires (const From& f){
         requires noexcept(std::declval<coordinate_transformation<From, To>>()(f));
    }
  };
 
  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>;
 
  // TO DO: reconsider whether this is necessary
  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;
    using admits_canonical_basis = std::true_type;
    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, Arena>;
    using is_convex_space      = std::true_type;
    using arena_type           = Arena;
    using distinguished_origin = std::true_type;
    using non_negative_orthant = std::true_type;
  };
 
  template<class T>
  inline constexpr bool has_arena_type_v{
    requires { typename T::arena_type;}
  };
 
  template<class T>
  struct arena_type_of;
 
  template<class T>
  using arena_type_of_t = arena_type_of<T>::type;
 
  template<class T>
    requires has_arena_type_v<T>
  struct arena_type_of<T>
  {
    using type = T::arena_type;
  };
 
  template<convex_space T>
    requires (!has_arena_type_v<dual<T>>)
  struct arena_type_of<dual<T>>
  {
    using type = arena_type_of_t<T>;
  };
 
  template<convex_space... Ts>
    requires (!has_arena_type_v<direct_product<Ts...>>)
  struct arena_type_of<direct_product<Ts...>>
  {
    using type = std::common_type_t<arena_type_of_t<Ts>...>;
  };
  
  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 is_basis         = std::true_type;
    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<class T>
  struct dilatation;
 
  template<auto Num, auto Den>
  struct dilatation<ratio<Num, Den>>
  {
    using ratio_type = ratio<Num, Den>;
  };
 
  template<std::intmax_t Num, std::intmax_t Den>
  struct dilatation<std::ratio<Num, Den>>
  {
    using ratio_type = std::ratio<Num, Den>;
  };
  
  template<class...>
  struct orthogonal_similarity_transformation;
 
  template<class Ratio> // TO DO: reflections and rotations
  struct orthogonal_similarity_transformation<dilatation<Ratio>>
  {
    using dilatation_type = dilatation<Ratio>;
  };
 
  template<class...>
  struct orthogonal_basis;
 
  template<free_module M, class Ratio, basis_for<M> ReferenceBasis>
  struct orthogonal_basis<M, orthogonal_similarity_transformation<dilatation<Ratio>>, ReferenceBasis>
  {
    using reference_basis_type = ReferenceBasis;
    using is_basis             = std::true_type;
    using free_module_type     = 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>;
}