Compiler Explorer

Source code

// module;

// #include "cpp2util.h"

// export module jegp.utilities;

// import std;

#define TYPE(...) typename __VA_ARGS__
#define OPERATOR_VALUE_TYPE operator ValueType

export template<auto V> using constant = std::integral_constant<decltype(V),V>;

template<typename T, typename U> concept value_trait_for = // clang-format off
 requires(U const& u) {
 { T::value } -> std::same_as<decltype(u)>;
}; // clang-format on

template<typename Trait, typename ValueType, typename BaseCharacteristic> concept base_characteristic_of_impl = 
 std::addressof(Trait::value) == std::addressof(BaseCharacteristic::value) && 
 std::same_as<TYPE(Trait::value_type),TYPE(BaseCharacteristic::value_type)> && 
 std::same_as<TYPE(Trait::type),TYPE(BaseCharacteristic::type)> && 
 (&Trait::OPERATOR_VALUE_TYPE == &BaseCharacteristic::OPERATOR_VALUE_TYPE) && 
 &Trait::operator() == &BaseCharacteristic::operator();

export template<typename T, template <typename> class Trait, typename ValueType> concept base_characteristic_of = 
 std::default_initializable<Trait<T>> && //
 std::copy_constructible<Trait<T>> && //
 value_trait_for<Trait<T>,ValueType> && //
 std::derived_from<Trait<T>,constant<Trait<T>::value>> && 
 base_characteristic_of_impl<Trait<T>,ValueType,constant<Trait<T>::value>>;

export template<typename T, template <typename> class U> concept distinguished_value_trait_in = value_trait_for<U<T>,T>;

// module;

// #include "cpp2util.h"

// export module jegp.numbers;

// import jegp.utilities;
// import std;

#define STATIC_CONSTEXPR_AUTO static constexpr auto
#define CONSTEXPR constexpr std::type_identity_t
#define POST_INC(x) x++
#define POST_DEC(x) x--

template <typename T> class inferred_number_zero {};
template <typename T> class inferred_number_one {};
template<typename T> class inferred_number_difference {};

export template<typename T> using number_difference_t = number_difference<T>::type;
 export template <typename T> using number_scalar_t = number_scalar<T>::type;

export template<typename T> concept is_inferred_number = std::regular<number_scalar_t<T>>;

template<typename T> class is_number: public std::bool_constant<is_inferred_number<T>> {

};
template<typename T> class is_complex_number: public std::false_type {

};
template<typename T> class number_zero: public inferred_number_zero<T> {

};
template<typename T> class number_one: public inferred_number_one<T> {

};
template<typename T> class number_difference: public inferred_number_difference<T> {

};
template<typename T> class number_scalar {};

export template<typename T> 
CPP2_REQUIRES (base_characteristic_of<T,is_number,bool>)
extern bool const is_number_v;
export template<typename T> 
CPP2_REQUIRES (base_characteristic_of<T,is_complex_number,bool>)
extern bool const is_complex_number_v;

export template<typename T> 
CPP2_REQUIRES (distinguished_value_trait_in<T,number_zero>)
extern T const number_zero_v;
export template <typename T> 
CPP2_REQUIRES (distinguished_value_trait_in<T,number_one>)
 extern T const number_one_v;

export template<typename T> concept number = is_number_v<T> && std::regular<T>;

export template<typename T> concept ordered_number = number<T> && std::totally_ordered<T>;

export template<typename T> concept number_line = // clang-format off
 ordered_number<T> && 
 requires(T& v) {
 number_one_v<number_difference_t<T>>;
 { ++v } -> std::same_as<decltype(v)>;
 { --v } -> std::same_as<decltype(v)>;
 { POST_INC(v) } -> std::same_as<T>;
 { POST_DEC(v) } -> std::same_as<T>;
}; // clang-format on

template<typename T, typename U> concept addition_with = // clang-format off
 number<T> && 
 number && 
 requires(T const& c, U const& d) {
 { c + d } -> std::common_with<T>;
 { d + c } -> std::common_with<T>;
}; // clang-format on

template<typename T, typename U> concept compound_addition_with = // clang-format off
 addition_with<T,U> && 
 requires(T& l, U const& d) {
 { l += d } -> std::same_as<decltype(l)>;
}; // clang-format on

template<typename T, typename U> concept subtraction_with = // clang-format off
 addition_with<T,U> && 
 requires(T const& c, U const& d) {
 { c - d } -> std::common_with<T>;
}; // clang-format on

template<typename T, typename U> concept compound_subtraction_with = // clang-format off
 subtraction_with<T,U> && 
 compound_addition_with<T,U> && 
 requires(T& l, U const& d) {
 { l -= d } -> std::same_as<decltype(l)>;
}; // clang-format on

template<typename T, typename U, typename V> concept multiplication_with = // clang-format off
 number<T> && 
 number && 
 number<V> && 
 requires(T const& c, U const& u) {
 { (c * u) } -> std::common_with<V>;
}; // clang-format on

template<typename T, typename U> concept compound_multiplication_with = // clang-format off
 multiplication_with<T,U,T> && 
 requires(T& l, U const& u) {
 { l *= u } -> std::same_as<decltype(l)>;
}; // clang-format on

template<typename T, typename U> concept division_with = // clang-format off
 multiplication_with<T,U,T> && 
 multiplication_with<U,T,T> && 
 requires(T const& c, U const& u) {
 { c / u } -> std::common_with<T>;
}; // clang-format on

template<typename T, typename U> concept compound_division_with = // clang-format off
 division_with<T,U> && 
 compound_multiplication_with<T,U> && 
 requires(T& l, U const& u) {
 { l /= u } -> std::same_as<decltype(l)>;
}; // clang-format on

export template<typename T, typename U> concept modulo_with = // clang-format off
 number<T> && 
 number && 
 requires(T const& c, U const& u) {
 { (c % u) } -> std::common_with<T>;
}; // clang-format on

export template<typename T, typename U> concept compound_modulo_with = // clang-format off
 modulo_with<T,U> && 
 requires(T& l, U const& u) {
 { l %= u } -> std::same_as<decltype(l)>;
}; // clang-format on

export template<typename T, typename U> concept modulus_for = modulo_with<U,T>; 
export template<typename T, typename U> concept compound_modulus_for = compound_modulo_with<U,T>;

export template<typename T> concept negative = // clang-format off
 compound_addition_with<T,T> && 
 requires(T const& c) {
 number_zero_v<T>;
 { -c } -> std::common_with<T>;
}; // clang-format on

template<typename T> concept inverse = // clang-format off
 compound_multiplication_with<T,T> && 
 requires(T const& c) {
 { number_one_v<T> / c } -> std::common_with<T>;
}; // clang-format on

export template<typename T, typename U> concept point_space_for = // clang-format off
 subtraction_with<T,U> && 
 negative && 
 requires(T const& c) {
 { c - c } -> std::same_as<number_difference_t<T>>;
 { c - c } -> std::common_with;
}; // clang-format on

export template<typename T, typename U> concept compound_point_space_for = point_space_for<T,U> && compound_subtraction_with<T,U>; 
export template<typename T> concept point_space = compound_point_space_for<T,number_difference_t<T>>;

export template <typename T, typename U> concept vector_space_for = point_space_for<U,T>; 
export template<typename T, typename U> concept compound_vector_space_for = compound_point_space_for<U,T>;

template<typename T> concept weak_scalar = std::common_with<T,number_difference_t<T>> && point_space<T> && negative<T>;

template<typename T, typename U> concept scales_with = 
 std::common_with<U,number_scalar_t<T>> && weak_scalar && multiplication_with<T,U,T> && inverse; 
template<typename T, typename U> concept compound_scales_with = scales_with<T,U> && compound_multiplication_with<T,U>;

export template<typename T, typename U> concept scalar_for = scales_with<U,T>; 
 export template<typename T, typename U> concept field_for = scalar_for<T,U> && division_with<U,T>; 
export template<typename T, typename U> concept compound_scalar_for = compound_scales_with<U,T>; 
export template <typename T, typename U> concept compound_field_for = compound_scalar_for<T,U> && compound_division_with<U,T>;

export template<typename T> concept vector_space = point_space<T> && compound_scales_with<T,number_scalar_t<T>>; 
export template<typename T> concept f_vector_space = vector_space<T> && compound_division_with<T,number_scalar_t<T>>;

export template<typename T> concept field_number = f_vector_space<T> && compound_scales_with<T,T>;

export template<typename T> concept field_number_line = field_number<T> && number_line<T>;

export template<typename T> concept scalar_number = field_number<T> && (field_number_line<T> || is_complex_number_v<T>);

// export vector_space: <T> concept =
// negative<T> && multiplication_with<number_scalar_t<T>, T, T> && inverse<number_scalar_t<T>>;
// clang-format off
template <typename T> class is_number< T const> : public is_number<T> { };
template<typename T, typename U> class is_number<std::chrono::time_point<T,U>>: public std::true_type {};
template<> class is_number <std::chrono::day> : public std::true_type { };
template<> class is_number <std::chrono::month> : public std::true_type { };
template<> class is_number <std::chrono::year> : public std::true_type { };
template<> class is_number <std::chrono::weekday> : public std::true_type { };
template<> class is_number <std::chrono::year_month> : public std::true_type { };

template <typename T> class is_complex_number<T const>: public is_complex_number<T> {};
template<typename T> class is_complex_number<std::complex<T>>: public std::true_type {};

template<typename T> concept inferable_identities = std::common_with<T,number_difference_t<T>> && std::constructible_from<T,int>; 
template<typename T> class number_zero<T const>: public number_zero<T> {};
template<typename T> class number_one<T const>: public number_one<T> {};
template<typename T> requires( inferable_identities<T> )
class inferred_number_zero<T> {public: STATIC_CONSTEXPR_AUTO value {T(0)}; }; template<typename T> requires( inferable_identities<T> )
class inferred_number_one<T> {public: STATIC_CONSTEXPR_AUTO value {T(1)}; }; 
template<typename T> class number_difference<T const>: public number_difference<T> {};
template<typename T> requires( requires(T const& c) {c - c; 
} )class inferred_number_difference<T>: public std::type_identity<decltype(*cpp2::assert_not_null(std::declval<T const*>()) - *cpp2::assert_not_null(std::declval<T const*>()))> {
};

template <typename T> class number_scalar<T const> : public number_scalar<T> { };
template <typename T> requires( std::integral<T> )
class number_scalar<T>: public std::type_identity<T> {};template<typename T> requires( std::floating_point<T> )
class number_scalar<T>: public std::type_identity<T> {};template<typename T> class number_scalar<std::complex<T>>: public std::type_identity<T> {};
template <typename T, typename U> class number_scalar<std::chrono::duration<T,U>>: public std::type_identity<T> {};
// clang-format on

// module;

// #include "cpp2util.h"

// export module jegp.quantities:concepts;

// import std;

#define TYPE(...) typename __VA_ARGS__

export template<typename T> concept name = std::derived_from<T,TYPE(T::named_quantity)>; 
 export template<typename T> concept unit = std::derived_from<T,TYPE(T::named_unit)>; 
 export template<typename T> concept origin = std::derived_from<T,TYPE(T::point_origin)>;

// module;

// #include "cpp2util.h"

// export module jegp.quantities;

// export import :concepts; // Workaround <https://github.com/hsutter/cppfront/issues/406#issuecomment-1658596145>.
// import jegp.numbers;
// import jegp.utilities;
// import std;

#define STATIC_CONSTEXPR_AUTO static constexpr auto
#define TYPE(...) typename __VA_ARGS__
#define QTY_NAME_MEM_TYPE [[no_unique_address]] name_type
#define QTY_UNIT_MEM_TYPE [[no_unique_address]] unit_type
#define QTY_ORIGIN_MEM_TYPE [[no_unique_address]] origin_type
#define POST_INC(x) x++
#define POST_DEC(x) x--

template<typename Name, typename Unit, typename Number> requires( name<Name> && unit<Unit> && vector_space<Number> )
class vector {public: using name_type = Name;
 public: using unit_type = Unit;
 public: using number_type = Number;

public: QTY_NAME_MEM_TYPE name; 
    public: number_type number; 
    public: QTY_UNIT_MEM_TYPE unit;

public: template<typename OtherNumber> [[nodiscard]] auto operator==(vector<Name,Unit,OtherNumber> const& other) const& -> bool
CPP2_REQUIRES (std::equality_comparable_with<Number,OtherNumber>)
 ;
 
 public: template<typename OtherNumber> [[nodiscard]] auto operator<=>(vector<Name,Unit,OtherNumber> const& other) const& -> auto
CPP2_REQUIRES (std::three_way_comparable_with<Number,OtherNumber>)
 ;

public: [[nodiscard]] auto operator++() & -> vector&
CPP2_REQUIRES (number_line<Number>)
 ;

public: [[nodiscard]] auto operator--() & -> vector&
CPP2_REQUIRES (number_line<Number>)
 ;

public: [[nodiscard]] auto operator++([[maybe_unused]] cpp2::in<int> param2) & -> vector
CPP2_REQUIRES (number_line<Number>)
 ;
 public: [[nodiscard]] auto operator--([[maybe_unused]] cpp2::in<int> param2) & -> vector
CPP2_REQUIRES (number_line<Number>)
 ;

public: template<typename OtherNumber> auto operator+=(vector<Name,Unit,OtherNumber> const& r) & -> vector&
CPP2_REQUIRES (compound_vector_space_for<OtherNumber,Number>)
 ;

public: template<typename OtherNumber> auto operator-=(vector<Name,Unit,OtherNumber> const& r) & -> vector&
CPP2_REQUIRES (compound_vector_space_for<OtherNumber,Number>)
 ;

public: template<typename OtherNumber> [[nodiscard]] auto operator+(vector<Name,Unit,OtherNumber> const& r) const& -> auto
CPP2_REQUIRES (vector_space_for<OtherNumber,Number>)
 ;
 
 public: template<typename OtherNumber> [[nodiscard]] auto operator-(vector<Name,Unit,OtherNumber> const& r) const& -> auto
CPP2_REQUIRES (vector_space_for<OtherNumber,Number>)
 ;

public: [[nodiscard]] auto operator-() const& -> auto;

public: template<typename OtherNumber> auto operator*=(OtherNumber const& r) & -> vector&
CPP2_REQUIRES (compound_scalar_for<OtherNumber,Number>)
 ;

public: template<typename OtherNumber> auto operator/=(OtherNumber const& r) & -> vector&
CPP2_REQUIRES (compound_field_for<OtherNumber,Number>)
 ;

public: template<typename OtherNumber> auto operator%=(OtherNumber const& r) & -> vector&
CPP2_REQUIRES (compound_modulus_for<OtherNumber,Number>)
 ;

public: template<typename OtherNumber> auto operator%=(vector<Name,Unit,OtherNumber> const& r) & -> vector&
CPP2_REQUIRES (compound_modulus_for<OtherNumber,Number>)
 ;

public: template<typename OtherNumber> [[nodiscard]] auto operator/(vector<Name,Unit,OtherNumber> const& r) const& -> one::vector<decltype(number / r.number)>
CPP2_REQUIRES (std::common_with<OtherNumber,Number>)
 ;
 
 public: template<typename OtherNumber> [[nodiscard]] auto operator/(OtherNumber const& r) const& -> auto
CPP2_REQUIRES (field_for<OtherNumber,Number>)
 ;
 
 public: template<typename OtherNumber> [[nodiscard]] auto operator%(OtherNumber const& r) const& -> auto
CPP2_REQUIRES (modulus_for<OtherNumber,Number>)
 ;
 
 public: template<typename OtherNumber> [[nodiscard]] auto operator%(vector<Name,Unit,OtherNumber> const& r) const& -> auto
CPP2_REQUIRES (modulus_for<OtherNumber,Number>)
 ;

public: template<typename OtherNumber> [[nodiscard]] auto operator*(OtherNumber const& r) const& -> auto
CPP2_REQUIRES (scalar_for<OtherNumber,Number>)
 ;
 
 };
 export template<typename Name, typename Unit, typename Number, typename OtherNumber> [[nodiscard]] auto operator*(OtherNumber const& l, vector<Name,Unit,Number> const& r) -> auto
CPP2_REQUIRES (scalar_for<OtherNumber,Number>)
 ;

template<typename Origin, typename Name, typename Unit, typename Number> 
 requires( origin<Origin> && name<Name> && unit<Unit> && point_space<Number> )
 class point {public: using origin_type = Origin;
 public: using vector_type = vector<Name,Unit,Number>;

public: QTY_ORIGIN_MEM_TYPE origin; 
    public: vector_type offset;

public: template<typename OtherNumber> [[nodiscard]] auto operator==(point<Origin,Name,Unit,OtherNumber> const& other) const& -> bool
CPP2_REQUIRES (std::equality_comparable_with<Number,OtherNumber>)
 ;
 
 public: template<typename OtherNumber> [[nodiscard]] auto operator<=>(point<Origin,Name,Unit,OtherNumber> const& other) const& -> auto
CPP2_REQUIRES (std::three_way_comparable_with<Number,OtherNumber>)
 ;

public: [[nodiscard]] auto operator++() & -> point&
CPP2_REQUIRES (number_line<vector_type>)
 ;

public: [[nodiscard]] auto operator--() & -> point&
CPP2_REQUIRES (number_line<vector_type>)
 ;

public: [[nodiscard]] auto operator++([[maybe_unused]] cpp2::in<int> param2) & -> point
CPP2_REQUIRES (number_line<vector_type>)
 ;
 public: [[nodiscard]] auto operator--([[maybe_unused]] cpp2::in<int> param2) & -> point
CPP2_REQUIRES (number_line<vector_type>)
 ;

public: template<typename OtherVectorType> auto operator+=(OtherVectorType const& r) & -> point&
CPP2_REQUIRES (compound_vector_space_for<OtherVectorType,vector_type>)
 ;

public: template<typename OtherVectorType> auto operator-=(OtherVectorType const& r) & -> point&
CPP2_REQUIRES (compound_vector_space_for<OtherVectorType,vector_type>)
 ;

public: template<typename OtherNumber> [[nodiscard]] auto operator-(point<Origin,Name,Unit,OtherNumber> const& r) const& -> auto
CPP2_REQUIRES (vector_space_for<OtherNumber,Number>)
 ;
 
 public: template<typename OtherVectorType> [[nodiscard]] auto operator-(OtherVectorType const& r) const& -> auto
CPP2_REQUIRES (vector_space_for<OtherVectorType,vector_type>)
 ;

public: template<typename OtherVectorType> [[nodiscard]] auto operator+(OtherVectorType const& r) const& -> auto
CPP2_REQUIRES (vector_space_for<OtherVectorType,vector_type>)
 ;
 
 };
 export template<typename Origin, typename Name, typename Unit, typename Number, typename OtherNumber> [[nodiscard]] auto operator+(
 vector<Name,Unit,OtherNumber> const& l, 
 point<Origin,Name,Unit,Number> const& r) -> auto
CPP2_REQUIRES (vector_space_for<OtherNumber,Number>)
 ;