ArrayTraits.hpp

#pragma once
 
#include <type_traits>
 
#include <stratax/containers/Matrix.hpp>
#include <stratax/containers/Tensor.hpp>
#include <stratax/containers/Vector.hpp>
 
namespace stratax::core {
 
template<typename A, typename T>
struct RebindArray;
 
template<typename From, typename To>
struct RebindArray<container::Vector<From>, To>
{
    using type = container::Vector<To>;
};
 
template<typename From, typename To>
struct RebindArray<container::Matrix<From>, To>
{
    using type = container::Matrix<To>;
};
 
template<typename From, typename To>
struct RebindArray<container::Tensor<From>, To>
{
    using type = container::Tensor<To>;
};
 
template<typename A, typename T>
using rebind_array_t =
    typename RebindArray<
        std::remove_cvref_t<A>,
        std::remove_cvref_t<T>
    >::type;
 
template<typename L, typename R, typename T>
struct PromoteArray;
 
template<typename LValue, typename RValue, typename T>
struct PromoteArray<
    container::Vector<LValue>,
    container::Vector<RValue>,
    T>
{
    using type = container::Vector<T>;
};
 
template<typename LValue, typename RValue, typename T>
struct PromoteArray<
    container::Matrix<LValue>,
    container::Matrix<RValue>,
    T>
{
    using type = container::Matrix<T>;
};
 
template<typename LValue, typename RValue, typename T>
struct PromoteArray<
    container::Tensor<LValue>,
    container::Tensor<RValue>,
    T>
{
    using type = container::Tensor<T>;
};
 
template<typename LValue, typename RValue, typename T>
struct PromoteArray<
    container::Vector<LValue>,
    container::Matrix<RValue>,
    T>
{
    using type = container::Tensor<T>;
};
 
template<typename LValue, typename RValue, typename T>
struct PromoteArray<
    container::Matrix<LValue>,
    container::Vector<RValue>,
    T>
{
    using type = container::Tensor<T>;
};
 
template<typename LValue, typename RValue, typename T>
struct PromoteArray<
    container::Vector<LValue>,
    container::Tensor<RValue>,
    T>
{
    using type = container::Tensor<T>;
};
 
template<typename LValue, typename RValue, typename T>
struct PromoteArray<
    container::Tensor<LValue>,
    container::Vector<RValue>,
    T>
{
    using type = container::Tensor<T>;
};
 
template<typename LValue, typename RValue, typename T>
struct PromoteArray<
    container::Matrix<LValue>,
    container::Tensor<RValue>,
    T>
{
    using type = container::Tensor<T>;
};
 
template<typename LValue, typename RValue, typename T>
struct PromoteArray<
    container::Tensor<LValue>,
    container::Matrix<RValue>,
    T>
{
    using type = container::Tensor<T>;
};
 
template<typename L, typename R, typename T>
using promote_array_t =
    typename PromoteArray<
        std::remove_cvref_t<L>,
        std::remove_cvref_t<R>,
        std::remove_cvref_t<T>
    >::type;
 
} // namespace stratax::core