Concepts.hpp

Go to the documentation of this file.

#pragma once
 
#include <concepts>
#include <complex>
#include <type_traits>
 
#include "Types.hpp"
 
namespace stratax::core::concept_detail {

template<typename T>
using clean_t = std::remove_cvref_t<T>;
 
template<typename T, typename... Candidates>
concept SameAsAny =
    (std::same_as<clean_t<T>, Candidates> || ...);
 
template<typename T>
concept CharacterLike =
    SameAsAny<
        T,
        char,
        signed char,
        unsigned char,
        wchar_t,
        char8_t,
        char16_t,
        char32_t>;
 
template<typename T>
concept BoolLike =
    std::same_as<clean_t<T>, bool>;
 
template<typename T>
concept SupportedComplex =
    SameAsAny<
        T,
        std::complex<float>,
        std::complex<double>,
        std::complex<long double>>;
 
}

template<typename T>
concept Integral =
    std::integral<stratax::core::concept_detail::clean_t<T>> &&
    !stratax::core::concept_detail::BoolLike<T> &&
    !stratax::core::concept_detail::CharacterLike<T>;

template<typename T>
concept Integer =
    Integral<T>;

template<typename T>
concept SignedInteger =
    Integral<T> &&
    std::signed_integral<stratax::core::concept_detail::clean_t<T>>;

template<typename T>
concept UnsignedInteger =
    Integral<T> &&
    std::unsigned_integral<stratax::core::concept_detail::clean_t<T>>;

template<typename T>
concept Floating =
    std::floating_point<stratax::core::concept_detail::clean_t<T>>;

template<typename T>
concept Float =
    Floating<T>;

template<typename T>
concept Arithmetic =
    Integral<T> ||
    Floating<T>;

template<typename T>
concept Real =
    Arithmetic<T>;

template<typename T>
concept Complex =
    stratax::core::concept_detail::SupportedComplex<T>;

template<typename T>
concept Numeric =
    Arithmetic<T> ||
    Complex<T>;

template<typename T>
concept Scalar =
    Numeric<T>;
 
namespace stratax::container {
 
template<typename T>
requires Numeric<T>
class Vector;
 
template<typename T>
requires Numeric<T>
class Matrix;
 
template<typename T>
requires Numeric<T>
class Tensor;
 
}

template<typename T>
struct is_array : std::false_type {};
 
template<typename T>
requires Numeric<T>
struct is_array<stratax::container::Vector<T>> : std::true_type {};
 
template<typename T>
requires Numeric<T>
struct is_array<stratax::container::Matrix<T>> : std::true_type {};
 
template<typename T>
requires Numeric<T>
struct is_array<stratax::container::Tensor<T>> : std::true_type {};
 
template<typename T>
concept Array =
    is_array<stratax::core::concept_detail::clean_t<T>>::value;

template<typename T>
concept NDarray =
requires(stratax::core::concept_detail::clean_t<T>& a)
{
    a.shape();
    a.size();
 
    a.begin();
    a.end();
};