marvin_Concepts.h

Go to the documentation of this file.

// ========================================================================================================
//  _______ _______ ______ ___ ___ _______ _______
// |   |   |   _   |   __ \   |   |_     _|    |  |
// |       |       |      <   |   |_|   |_|       |
// |__|_|__|___|___|___|__|\_____/|_______|__|____|
//
// This file is part of the Marvin open source library and is licensed under the terms of the MIT License.
//
// ========================================================================================================
 
#ifndef MARVIN_CONCEPTS_H
#define MARVIN_CONCEPTS_H
#include <iterator>
#include <type_traits>
#include <cstddef>
#include <complex>
#include <concepts>
#include <span>
#include <vector>
#include <random>
namespace marvin {

    template <class T>
    concept FloatType = std::is_floating_point_v<T>;
 
    template <class T>
    concept ComplexFloatType = std::same_as<T, std::complex<float>> || std::same_as<T, std::complex<double>>;
 
    template <class T>
    concept RealOrComplexFloatType = FloatType<T> || ComplexFloatType<T>;

    template <class T>
    concept NumericType = std::is_integral_v<T> || std::is_floating_point_v<T>;

    template <class T>
    concept FixedWidthSignedInteger = std::same_as<std::int8_t, T> ||
                                      std::same_as<std::int16_t, T> ||
                                      std::same_as<std::int32_t, T> ||
                                      std::same_as<std::int64_t, T>;
 

    template <class T>
    concept ArrayLike = requires(T a, size_t i) {
        typename T::value_type;
        typename T::iterator;
        requires std::contiguous_iterator<typename T::iterator>;
        requires !std::same_as<std::string, T>;
        { a.size() } -> std::same_as<size_t>;
        { a[i] } -> std::same_as<typename T::value_type&>;
        { a.data() } -> std::same_as<typename T::value_type*>;
    };

    template <class T>
    concept FloatArrayLike = requires {
        requires ArrayLike<T>;
        requires FloatType<typename T::value_type>;
    };

    template <class T>
    concept SmartPointerType = requires(T a) {
        typename T::element_type;
        a.get();
        a.reset();
        a.operator*();
        a.operator->();
    };
 

    template <size_t N>
    constexpr bool isPowerOfTwo() {
        if constexpr (N == 1) {
            return true;
        } else if constexpr (N == 0 || N % 2 != 0) {
            return false;
        } else {
            return isPowerOfTwo<N / 2>();
        }
    }
 
    template <class T>
    concept RandomEngineType = std::same_as<T, std::mt19937> || std::same_as<T, std::mt19937_64> ||
                               std::same_as<T, std::minstd_rand0> || std::same_as<T, std::minstd_rand> ||
                               std::same_as<T, std::ranlux24_base> || std::same_as<T, std::ranlux48_base>;
} // namespace marvin
#endif