blas_expression_template_traits.h

Go to the documentation of this file.

/*
 * Blas_Expression_Traits.h
 *
 *  Created on: Oct 10, 2019
 *      Author: joseph
 */

#ifndef BLACKCATTENSORS_TENSORS_EXPRS_BLAS_EXPRESSION_TRAITS_H_
#define BLACKCATTENSORS_TENSORS_EXPRS_BLAS_EXPRESSION_TRAITS_H_

#include "expression_template_traits.h"
#include "array.h"
#include "array_kernel_array.h"
#include "array_scalar_constant.h"
#include "tree_evaluator.h"
#include "tree_evaluator_optimizer.h"

namespace bc {
namespace tensors {
namespace exprs {
namespace detail {

template<class T>
struct remove_scalar_mul {
    using type = T;
    using scalar_type = bc::traits::conditional_detected_t<
            query_value_type, T, T>*;

    static T rm(T expression) {
        return expression;
    }

    static scalar_type get_scalar(const T& expression) {
        return nullptr;
    };
};

template<class lv, class rv>
struct remove_scalar_mul<Bin_Op<oper::Scalar_Mul, lv, rv>> {
    using type = std::conditional_t<lv::tensor_dim == 0, rv, lv>;
    using scalar_type = std::conditional_t<lv::tensor_dim == 0, lv ,rv>;

    static type rm(Bin_Op<oper::Scalar_Mul, lv, rv> expression) {
        return bc::traits::constexpr_ternary<lv::tensor_dim==0>(
                [&]() { return expression.right; },
                [&]() { return expression.left;  }
        );
    }

    static scalar_type get_scalar(
            Bin_Op<oper::Scalar_Mul, lv, rv> expression) {
        return bc::traits::constexpr_ternary<lv::tensor_dim==0>(
                [&]() { return expression.left; },
                [&]() { return expression.right;  }
        );
    }

};

template<class T>
struct remove_transpose {
    using type = T;
    static T rm(T expression) {
        return expression;
    }
};
template<class Array, class SystemTag>
struct remove_transpose<Un_Op<oper::transpose<SystemTag>, Array>> {
    using type = Array;

    static type rm(
            Un_Op<oper::transpose<SystemTag>, Array> expression) {
        return expression.array;
    }
};

template<class Array, class SystemTag, class Rv>
struct remove_transpose<
        Bin_Op<
            oper::Scalar_Mul,
            Un_Op<oper::transpose<SystemTag>,
            Array>,
            Rv>>
{
    using type = Array;

    static type rm(
            Bin_Op<
                    oper::Scalar_Mul,
                    Un_Op<oper::transpose<SystemTag>,
                    Array>,
                    Rv> expression) {
        return expression.left.array;
    }
};

template<class Array, class SystemTag, class Lv>
struct remove_transpose<
        Bin_Op<
                oper::Scalar_Mul,
                Lv,
                Un_Op<oper::transpose<SystemTag>,
                Array>>>
{
    using type = Array;

    static type rm(
            Bin_Op<
                    oper::Scalar_Mul,
                    Lv,
                    Un_Op<oper::transpose<SystemTag>,
                    Array>> expression) {
        return expression.right.array;
    }
};

} //end of ns detail


namespace blas_expression_parser {
template<class SystemTag>
struct Blas_Expression_Parser;
}

template<class T>
struct blas_expression_traits:
        expression_traits<T> {

    using requires_greedy_evaluation = bc::traits::conditional_detected_t<
             detail::query_requires_greedy_evaluation, T, std::false_type>;

    using remove_scalar_mul_type    = typename detail::remove_scalar_mul<T>::type;
    using remove_transpose_type     = typename detail::remove_transpose<T>::type;
    using remove_blas_features_type = typename detail::remove_transpose<remove_scalar_mul_type>::type;
    using scalar_multiplier_type    = typename detail::remove_scalar_mul<T>::scalar_type;
    using value_type                = typename T::value_type;

    using is_scalar_multiplied = bc::traits::truth_type<
            !std::is_same<remove_scalar_mul_type, T>::value>;

    using is_transposed = bc::traits::truth_type<
            !std::is_same<remove_transpose_type,  T>::value>;

    static remove_transpose_type remove_transpose(T expression) {
        return detail::remove_transpose<T>::rm(expression);
    }

    static remove_scalar_mul_type remove_scalar_mul(T expression) {
        return detail::remove_scalar_mul<T>::rm(expression);
    }

    static remove_blas_features_type remove_blas_modifiers(T expression) {
        return detail::remove_transpose<remove_scalar_mul_type>::rm(
                remove_scalar_mul(expression));
    }

    //If an expression with a scalar,
    //returns the scalar,
    //else returns a nullpointer of the valuetype == to T::value_type
    static auto get_scalar(const T& expression)
        -> decltype(detail::remove_scalar_mul<T>::get_scalar(expression)) {
        return detail::remove_scalar_mul<T>::get_scalar(expression);
    }

    template<int Alpha, int Beta, class Stream>
    static auto parse_expression(Stream stream, T expression) {
        using system_tag = typename T::system_tag;
        return blas_expression_parser::Blas_Expression_Parser<system_tag>::
                template parse_expression<Alpha, Beta>(
                    stream, expression.left, expression.right);
    }

    template<class Stream, class Contents>
    static void post_parse_expression_evaluation(Stream stream, Contents contents) {
        using system_tag = typename T::system_tag;
        blas_expression_parser::Blas_Expression_Parser<system_tag>::
                template post_parse_expression_evaluation(stream, contents);
    }
};


}
}
}

#include "blas_expression_parser/blas_expression_parser.h"

#endif /* BLAS_EXPRESSION_TRAITS_H_ */