Box.hpp

Go to the documentation of this file.

#pragma once
#include "Utility/General.hpp" 
#include "Chains.hpp" 
#include "ChangeBasis.hpp"
 
 
namespace mackey {
 
    namespace implementation_details{
        //SFINAE aliases
 
        template<typename T>
        using is_rank = std::enable_if_t<std::is_same<T, row_vector_t<T>>::value, int>;
 
        template<typename T>
        using is_vector_rank = std::enable_if_t<std::is_same<T, std::vector<row_vector_t<typename T::value_type>>>::value, int>;
 
        template<typename T>
        using is_arrow = std::enable_if_t<std::is_same<T, arrow_t<T>>::value, int>;
 
        template<typename T>
        using is_chains = std::enable_if_t<std::is_same<T, chains_t<T>>::value, int>;
 
        template<typename T>
        using is_junction = std::enable_if_t<std::is_same<T, junction_t<T>>::value, int>;
 
        template<typename T, bool>
        struct optional_base;
 
        template<typename T>
        struct optional_base<T, 0> {};
 
        template<typename T>
        struct optional_base<T, 1> { T _optional; };
    }
 
    template<typename _output_t, typename _optional_t = void> 
    class Tensor : implementation_details::optional_base<_optional_t, !std::is_same<_optional_t, void>::value> {
    public:
        _output_t& tensor();
 
        auto& optional();
 
        const _output_t& tensor() const;
 
        const auto& optional() const;
 
        template<typename _input_t>
        Tensor(const _input_t& A, const _input_t& B, int i= -1);
 
    private:
        static constexpr bool optional_exists = !std::is_same<_optional_t, void>::value;
 
        _output_t _tensor;
 
        //The tensor product of the ranks of A,B is the rank of A tensor B
        //Here: _input_t=rank_t, _output_t=rank_t, _optional_t is void, i=-1
        template<typename _input_t, typename implementation_details::is_rank<_input_t> = 0>
        void tensor(const _input_t&, const _input_t&, int = -1);
 
        //The tensor product of the ranks of A_*,B_* at location i is the rank of (A_* tensor B_*)_i
        //Here: _input_t=std::vector<rank_t>, _output_t=rank_t, _optional_t is std::vector<int64_t> or void, i= location
        template<typename _input_t, typename implementation_details::is_vector_rank<_input_t> = 0, typename S = _output_t, typename implementation_details::is_rank<S> = 0>
        void tensor(const _input_t&, const _input_t&, int = -1);
 
        //The tensor product of the ranks of A_*,B_* is the rank of A_* tensor B_*
        //Here: _input_t=std::vector<rank_t>, _output_t=std::vector<rank_t>, _optional_t is void, i=-1
        template<typename _input_t, typename T = _output_t, typename S = _output_t, typename implementation_details::is_vector_rank<T> = 0, typename implementation_details::is_vector_rank<S> = 0>
        void tensor(const _input_t&, const _input_t&, int = -1);
 
        //The tensor product of the Chains A_*,B_* at location i is the arrow (A_* tensor B_*)_i
        //Here: _input_t=Chains<rank_t,diff_t>, _output_t=Arrow<rank_t,diff_t>, _optional_t is std::vector<int64_t> or void, i= location
        template<typename _input_t, typename T = _output_t, typename implementation_details::is_arrow<T> = 0>
        void tensor(const _input_t&, const _input_t&, int = -1);
 
        //The tensor product of the Chains A_*,B_* up to location i is the Chains (A_* tensor B_*)_* for *<=i
        //Here: _input_t=Chains<rank_t,diff_t>, _output_t=Chains<rank_t,diff_t>, _optional_t is std::vector<std::vector<int64_t>> or void, i= location or -1 (if the whole tensor is desired)
        template<typename _input_t, typename T = _output_t, typename implementation_details::is_chains<T> = 0>
        void tensor(const _input_t&, const _input_t&, int = -1);
 
        //The tensor product of the Chains A_*,B_* at location i as the Junction (A_* tensor B_*)_i->(A_* tensor B_*)_{i-1}
        //Here: _input_t=Chains<rank_t,diff_t>, _output_t=Junction<rank_t,diff_t>, _optional_t is std::vector<int64_t> or void, i= location
        template<typename _input_t, typename T = _output_t, typename implementation_details::is_junction<T> = 0>
        void tensor(const _input_t&, const _input_t&, int = -1);
 
    };
}
#include "impl/Box.ipp"