unary_expr.hpp

Go to the documentation of this file.

//=======================================================================
// Copyright (c) 2014-2023 Baptiste Wicht
// Distributed under the terms of the MIT License.
// (See accompanying file LICENSE or copy at
//  http://opensource.org/licenses/MIT)
//=======================================================================

#pragma once

#include <random>
#include "etl/concepts_base.hpp"
namespace etl {

struct identity_op {
    static constexpr bool linear      = true; 
    static constexpr bool thread_safe = true; 

    template <vector_mode_t V>
    static constexpr bool vectorizable = true;

    template <typename E>
    static constexpr bool gpu_computable = false;

    static constexpr int complexity() {
        return 1;
    }
};

struct transform_op {
    static constexpr bool linear      = false; 
    static constexpr bool thread_safe = true;  

    template <vector_mode_t V>
    static constexpr bool vectorizable = false;

    template <typename Expr>
    static constexpr bool gpu_computable = Expr::gpu_computable;

    static constexpr int complexity() {
        return 1;
    }
};

template <typename Sub>
struct stateful_op {
    static constexpr bool linear      = Sub::linear;      
    static constexpr bool thread_safe = Sub::thread_safe; 

    using op = Sub; 

    template <vector_mode_t V>
    static constexpr bool vectorizable = Sub::template vectorizable<V>;

    template <typename E>
    static constexpr bool gpu_computable = Sub::template gpu_computable<E>;

    static constexpr int complexity() {
        return 1;
    }
};

template <typename T, expr_or_scalar<T> Expr, typename UnaryOp>
struct unary_expr final : value_testable<unary_expr<T, Expr, UnaryOp>>, dim_testable<unary_expr<T, Expr, UnaryOp>>, iterable<unary_expr<T, Expr, UnaryOp>> {
private:
    using this_type = unary_expr<T, Expr, UnaryOp>; 

    Expr value; 

    friend struct etl_traits<unary_expr>;
    friend struct optimizer<unary_expr>;
    friend struct optimizable<unary_expr>;
    friend struct transformer<unary_expr>;

public:
    using value_type        = T;                              
    using memory_type       = void;                           
    using const_memory_type = void;                           
    using expr_t            = Expr;                           
    using iterator          = etl::iterator<this_type>;       
    using const_iterator    = etl::iterator<const this_type>; 

    template <typename V = default_vec>
    using vec_type = typename V::template vec_type<T>;

    explicit unary_expr(Expr l) : value(std::forward<Expr>(l)) {
        //Nothing else to init
    }

    unary_expr(const unary_expr& rhs)     = default;
    unary_expr(unary_expr&& rhs) noexcept = default;

    //Expression are invariant
    unary_expr& operator=(const unary_expr& rhs) = delete;
    unary_expr& operator=(unary_expr&& rhs) = delete;

    value_type operator[](size_t i) const {
        return UnaryOp::apply(value[i]);
    }

    value_type read_flat(size_t i) const noexcept {
        return UnaryOp::apply(value.read_flat(i));
    }

    template <typename V = default_vec>
    vec_type<V> load(size_t i) const {
        return UnaryOp::template load<V>(value.template load<V>(i));
    }

    template <typename V = default_vec>
    vec_type<V> loadu(size_t i) const {
        return UnaryOp::template load<V>(value.template loadu<V>(i));
    }

    template <size_c... S>
    value_type operator()(S... args) const {
        return UnaryOp::apply(value(args...));
    }

    template <typename E>
    bool alias(const E& rhs) const noexcept {
        return value.alias(rhs);
    }

    template <typename Y>
    decltype(auto) gpu_compute_hint(Y& y) const {
        return UnaryOp::gpu_compute_hint(value, y);
    }

    template <typename Y>
    decltype(auto) gpu_compute(Y& y) const {
        return UnaryOp::gpu_compute(value, y);
    }

    // Assignment functions

    template <typename L>
    void assign_to(L&& lhs) const {
        std_assign_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_add_to(L&& lhs) const {
        std_add_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_sub_to(L&& lhs) const {
        std_sub_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_mul_to(L&& lhs) const {
        std_mul_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_div_to(L&& lhs) const {
        std_div_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_mod_to(L&& lhs) const {
        std_mod_evaluate(*this, std::forward<L>(lhs));
    }

    // Internals

    void visit(detail::evaluator_visitor& visitor) const {
        value.visit(visitor);
    }

    void ensure_cpu_up_to_date() const {
        // The sub value must be ensured
        value.ensure_cpu_up_to_date();
    }

    void ensure_gpu_up_to_date() const {
        // The sub value must be ensured
        value.ensure_gpu_up_to_date();
    }

    friend std::ostream& operator<<(std::ostream& os, const unary_expr& expr) {
        return os << UnaryOp::desc() << '(' << expr.value << ')';
    }
};

template <typename T, expr_or_scalar<T> Expr>
struct unary_expr<T, Expr, identity_op> : inplace_assignable<unary_expr<T, Expr, identity_op>>,
                                          assignable<unary_expr<T, Expr, identity_op>, T>,
                                          value_testable<unary_expr<T, Expr, identity_op>>,
                                          dim_testable<unary_expr<T, Expr, identity_op>>,
                                          iterable<unary_expr<T, Expr, identity_op>, is_dma<Expr>> {
private:
    Expr value;                 
    gpu_memory_handler<T> _gpu; 

    static constexpr bool dma = is_dma<Expr>; 

    static constexpr bool non_const_return_ref =
        std::is_lvalue_reference_v<decltype(value[0])> && !std::is_const_v<std::remove_reference_t<decltype(value[0])>>;

    static constexpr bool const_return_ref = std::is_lvalue_reference_v<decltype(value[0])>;

    friend struct etl_traits<unary_expr>;
    friend struct optimizer<unary_expr>;
    friend struct optimizable<unary_expr>;
    friend struct transformer<unary_expr>;

public:
    using this_type            = unary_expr<T, Expr, identity_op>;                                           
    using value_type           = T;                                                                          
    using assignable_base_type = assignable<this_type, value_type>;                                          
    using memory_type          = memory_t<Expr>;                                                             
    using const_memory_type    = const_memory_t<Expr>;                                                       
    using return_type          = std::conditional_t<non_const_return_ref, value_type&, value_type>;          
    using const_return_type    = std::conditional_t<const_return_ref, const value_type&, value_type>;        
    using expr_t               = Expr;                                                                       
    using iterator             = std::conditional_t<dma, value_type*, etl::iterator<this_type>>;             
    using const_iterator       = std::conditional_t<dma, const value_type*, etl::iterator<const this_type>>; 

    template <typename V = default_vec>
    using vec_type = typename V::template vec_type<value_type>;

    using assignable_base_type::operator=;

    explicit unary_expr(Expr l) noexcept : value(std::forward<Expr>(l)) {
        //Nothing to init
    }

    unary_expr(const unary_expr& rhs) = default;

    unary_expr(unary_expr&& rhs) noexcept = default;

    return_type operator[](size_t i) {
        return value[i];
    }

    const_return_type operator[](size_t i) const {
        return value[i];
    }

    value_type read_flat(size_t i) const noexcept {
        return value.read_flat(i);
    }

    template <typename V = default_vec>
    void store(vec_type<V> in, size_t i) noexcept {
        return value.template store<V>(in, i);
    }

    template <typename V = default_vec>
    void storeu(vec_type<V> in, size_t i) noexcept {
        return value.template storeu<V>(in, i);
    }

    template <typename V = default_vec>
    void stream(vec_type<V> in, size_t i) noexcept {
        return value.template stream<V>(in, i);
    }

    template <typename V = default_vec>
    ETL_STRONG_INLINE(vec_type<V>)
    load(size_t i) const noexcept {
        return value.template load<V>(i);
    }

    template <typename V = default_vec>
    ETL_STRONG_INLINE(vec_type<V>)
    loadu(size_t i) const noexcept {
        return value.template loadu<V>(i);
    }

    size_t& unsafe_dimension_access(size_t i) {
        return value.unsafe_dimension_access(i);
    }

    auto operator()(size_t i) requires sub_capable<this_type> {
        return sub(*this, i);
    }

    auto operator()(size_t i) const requires sub_capable<this_type> {
        return sub(*this, i);
    }

    auto slice(size_t first, size_t last) noexcept {
        return etl::slice(*this, first, last);
    }

    auto slice(size_t first, size_t last) const noexcept {
        return etl::slice(*this, first, last);
    }

    template <size_c... S>
    ETL_STRONG_INLINE(return_type)
    operator()(S... args) noexcept(noexcept(value(args...))) requires (sizeof...(S) == safe_dimensions<this_type>) {
        return value(args...);
    }

    template <size_c... S>
    ETL_STRONG_INLINE(const_return_type)
    operator()(S... args) const noexcept(noexcept(value(args...))) requires(sizeof...(S) == safe_dimensions<this_type>) {
        return value(args...);
    }

    template <typename E>
    bool alias(const E& rhs) const noexcept {
        if constexpr (all_dma<E, Expr>) {
            return memory_alias(memory_start(), memory_end(), rhs.memory_start(), rhs.memory_end());
        } else {
            return value.alias(rhs);
        }
    }

    memory_type memory_start() noexcept requires(etl_dma<Expr>) {
        return value.memory_start();
    }

    const_memory_type memory_start() const noexcept requires(etl_dma<Expr>) {
        return value.memory_start();
    }

    memory_type memory_end() noexcept requires(etl_dma<Expr>) {
        return value.memory_end();
    }

    const_memory_type memory_end() const noexcept requires(etl_dma<Expr>) {
        return value.memory_end();
    }

    template <size_t DD>
    static constexpr size_t dim() requires fast<this_type> {
        return etl_traits<this_type>::template dim<DD>();
    }

    template <size_t DD>
    size_t dim() const requires dyn<this_type> {
        return etl_traits<this_type>::dim(*this, DD);
    }

    template <size_t... I>
    std::array<size_t, decay_traits<this_type>::dimensions()> dim_array(std::index_sequence<I...>) const {
        return {{this->template dim<I>()...}};
    }

    // Assignment functions

    template <typename L>
    void assign_to(L&& lhs) const {
        std_assign_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_add_to(L&& lhs) const {
        std_add_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_sub_to(L&& lhs) const {
        std_sub_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_mul_to(L&& lhs) const {
        std_mul_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_div_to(L&& lhs) const {
        std_div_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_mod_to(L&& lhs) const {
        std_mod_evaluate(*this, std::forward<L>(lhs));
    }

    // Internals

    void visit(detail::evaluator_visitor& visitor) const {
        value.visit(visitor);
    }

    T* gpu_memory() const noexcept requires(etl_dma<Expr>) {
        return _gpu.gpu_memory();
    }

    void gpu_evict() const noexcept requires(etl_dma<Expr>) {
        _gpu.gpu_evict();
    }

    void invalidate_cpu() const noexcept requires(etl_dma<Expr>) {
        _gpu.invalidate_cpu();
    }

    void invalidate_gpu() const noexcept requires(etl_dma<Expr>) {
        _gpu.invalidate_gpu();
    }

    void validate_cpu() const noexcept requires(etl_dma<Expr>) {
        _gpu.validate_cpu();
    }

    void validate_gpu() const noexcept requires(etl_dma<Expr>) {
        _gpu.validate_gpu();
    }

    void ensure_gpu_allocated() const requires(etl_dma<Expr>) {
        _gpu.ensure_gpu_allocated(etl::size(value));
    }

    void ensure_gpu_up_to_date() const {
        if constexpr (is_dma<Expr>) {
            _gpu.ensure_gpu_up_to_date(memory_start(), etl::size(value));
        } else {
            value.ensure_gpu_up_to_date();
        }
    }

    void ensure_cpu_up_to_date() const {
        if constexpr (is_dma<Expr>) {
            _gpu.ensure_cpu_up_to_date(memory_start(), etl::size(value));
        } else {
            value.ensure_cpu_up_to_date();
        }
    }

    void gpu_copy_from(const T* gpu_memory) const requires(etl_dma<Expr>) {
        _gpu.gpu_copy_from(gpu_memory, etl::size(value));
    }

    bool is_cpu_up_to_date() const noexcept requires(etl_dma<Expr>) {
        return _gpu.is_cpu_up_to_date();
    }

    bool is_gpu_up_to_date() const noexcept requires(etl_dma<Expr>) {
        return _gpu.is_gpu_up_to_date();
    }

    friend std::ostream& operator<<(std::ostream& os, const unary_expr& expr) {
        return os << expr.value;
    }

private:
    void memory_set(const value_type& e) {
        if constexpr (is_dma<Expr>) {
            direct_fill(memory_start(), memory_end(), e);
        } else {
            for (size_t i = 0; i < size(*this); ++i) {
                (*this)[i] = e;
            }
        }
    }
};

template <typename T, typename Expr>
struct unary_expr<T, Expr, transform_op>
        : value_testable<unary_expr<T, Expr, transform_op>>, dim_testable<unary_expr<T, Expr, transform_op>>, iterable<unary_expr<T, Expr, transform_op>> {
private:
    using this_type = unary_expr<T, Expr, transform_op>; 

    Expr value; 

    friend struct etl_traits<unary_expr>;
    friend struct optimizer<unary_expr>;
    friend struct optimizable<unary_expr>;
    friend struct transformer<unary_expr>;

public:
    using value_type        = T;                              
    using memory_type       = void;                           
    using const_memory_type = void;                           
    using expr_t            = Expr;                           
    using iterator          = etl::iterator<this_type>;       
    using const_iterator    = etl::iterator<const this_type>; 

    explicit unary_expr(Expr l) : value(std::forward<Expr>(l)) {
        //Nothing else to init
    }

    unary_expr(const unary_expr& rhs)     = default;
    unary_expr(unary_expr&& rhs) noexcept = default;

    //Expression are invariant
    unary_expr& operator=(const unary_expr& e) = delete;
    unary_expr& operator=(unary_expr&& e) = delete;

    value_type operator[](size_t i) const {
        return value[i];
    }

    value_type read_flat(size_t i) const noexcept {
        return value.read_flat(i);
    }

    auto operator()(size_t i) const requires sub_capable<this_type> {
        return sub(*this, i);
    }

    template <size_c... S>
    value_type operator()(S... args) const requires(sizeof...(S) == safe_dimensions<this_type>) {
        return value(args...);
    }

    template <typename E>
    bool alias(const E& rhs) const noexcept {
        return value.alias(rhs);
    }

    template <typename Y>
    decltype(auto) gpu_compute_hint(Y& y) const {
        return value.gpu_compute_hint(y);
    }

    template <typename Y>
    decltype(auto) gpu_compute(Y& y) const {
        return value.gpu_compute(y);
    }

    // Assignment functions

    template <typename L>
    void assign_to(L&& lhs) const {
        std_assign_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_add_to(L&& lhs) const {
        std_add_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_sub_to(L&& lhs) const {
        std_sub_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_mul_to(L&& lhs) const {
        std_mul_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_div_to(L&& lhs) const {
        std_div_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_mod_to(L&& lhs) const {
        std_mod_evaluate(*this, std::forward<L>(lhs));
    }

    // Internals

    void visit(detail::evaluator_visitor& visitor) const {
        value.visit(visitor);
    }

    void ensure_cpu_up_to_date() const {
        // The sub value must be ensured
        value.ensure_cpu_up_to_date();
    }

    void ensure_gpu_up_to_date() const {
        // The sub value must be ensured
        value.ensure_gpu_up_to_date();
    }

    friend std::ostream& operator<<(std::ostream& os, const unary_expr& expr) {
        return os << expr.value;
    }
};

template <typename T, typename Expr, typename Op>
struct unary_expr<T, Expr, stateful_op<Op>> : value_testable<unary_expr<T, Expr, stateful_op<Op>>>,
                                              dim_testable<unary_expr<T, Expr, stateful_op<Op>>>,
                                              iterable<unary_expr<T, Expr, stateful_op<Op>>> {
private:
    using this_type = unary_expr<T, Expr, stateful_op<Op>>; 

    Expr value; 
    Op op;      

    friend struct etl_traits<unary_expr>;
    friend struct optimizer<unary_expr>;
    friend struct optimizable<unary_expr>;
    friend struct transformer<unary_expr>;

public:
    using value_type        = T;                              
    using memory_type       = void;                           
    using const_memory_type = void;                           
    using expr_t            = Expr;                           
    using iterator          = etl::iterator<this_type>;       
    using const_iterator    = etl::iterator<const this_type>; 

    template <typename V = default_vec>
    using vec_type = typename V::template vec_type<T>;

    template <typename... Args>
    explicit unary_expr(Expr l, Args&&... args) : value(std::forward<Expr>(l)), op(std::forward<Args>(args)...) {
        //Nothing else to init
    }

    unary_expr(const unary_expr& rhs)     = default;
    unary_expr(unary_expr&& rhs) noexcept = default;

    //Expression are invariant
    unary_expr& operator=(const unary_expr& e) = delete;
    unary_expr& operator=(unary_expr&& e) = delete;

    value_type operator[](size_t i) const {
        return op.apply(value[i]);
    }

    value_type read_flat(size_t i) const {
        return op.apply(value.read_flat(i));
    }

    template <typename V = default_vec>
    vec_type<V> load(size_t i) const {
        return op.template load<V>(value.template load<V>(i));
    }

    template <typename V = default_vec>
    vec_type<V> loadu(size_t i) const {
        return op.template load<V>(value.template loadu<V>(i));
    }

    template <typename Y>
    decltype(auto) gpu_compute_hint(Y& y) const {
        return op.gpu_compute_hint(value, y);
    }

    template <typename Y>
    decltype(auto) gpu_compute(Y& y) const {
        return op.gpu_compute(value, y);
    }

    template <size_c... S>
    value_type operator()(S... args) const requires(sizeof...(S) == safe_dimensions<this_type>) {
        return op.apply(value(args...));
    }

    template <typename E>
    bool alias(const E& rhs) const noexcept {
        return value.alias(rhs);
    }

    // Assignment functions

    template <typename L>
    void assign_to(L&& lhs) const {
        std_assign_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_add_to(L&& lhs) const {
        std_add_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_sub_to(L&& lhs) const {
        std_sub_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_mul_to(L&& lhs) const {
        std_mul_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_div_to(L&& lhs) const {
        std_div_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_mod_to(L&& lhs) const {
        std_mod_evaluate(*this, std::forward<L>(lhs));
    }

    // Internals

    void visit(detail::evaluator_visitor& visitor) const {
        value.visit(visitor);
    }

    void ensure_cpu_up_to_date() const {
        // The sub value must be ensured
        value.ensure_cpu_up_to_date();
    }

    void ensure_gpu_up_to_date() const {
        // The sub value must be ensured
        value.ensure_gpu_up_to_date();
    }

    friend std::ostream& operator<<(std::ostream& os, const unary_expr& expr) {
        return os << Op::desc() << '(' << expr.value << ')';
    }
};

template <typename T, typename Expr, typename UnaryOp>
struct etl_traits<etl::unary_expr<T, Expr, UnaryOp>> {
    using expr_t     = etl::unary_expr<T, Expr, UnaryOp>; 
    using sub_expr_t = std::decay_t<Expr>;                
    using sub_traits = etl_traits<sub_expr_t>;            
    using value_type = T;                                 

    static constexpr bool is_etl         = true;                
    static constexpr bool is_transformer = false;               
    static constexpr bool is_view        = false;               
    static constexpr bool is_magic_view  = false;               
    static constexpr bool is_fast        = sub_traits::is_fast; 
    static constexpr bool is_value       = false;               
    static constexpr bool is_direct =
        std::is_same_v<UnaryOp, identity_op> && sub_traits::is_direct;                    
    static constexpr bool is_linear      = sub_traits::is_linear && UnaryOp::linear;           
    static constexpr bool is_thread_safe = sub_traits::is_thread_safe && UnaryOp::thread_safe; 
    static constexpr bool is_generator   = sub_traits::is_generator;                           
    static constexpr bool is_temporary   = sub_traits::is_temporary;                           
    static constexpr bool is_padded      = is_linear && sub_traits::is_padded;                 
    static constexpr bool is_aligned     = is_linear && sub_traits::is_aligned;                
    static constexpr order storage_order = sub_traits::storage_order;                          

    static constexpr bool gpu_computable = is_gpu_computable<Expr> && UnaryOp::template gpu_computable<Expr> && (is_floating<Expr> || is_complex<Expr>);

    template <vector_mode_t V>
    static constexpr bool vectorizable = sub_traits::template vectorizable<V>&& UnaryOp::template vectorizable<V>;

    static size_t size(const expr_t& v) {
        return sub_traits::size(v.value);
    }

    static size_t dim(const expr_t& v, size_t d) {
        return sub_traits::dim(v.value, d);
    }

    static constexpr size_t size() {
        return sub_traits::size();
    }

    template <size_t D>
    static constexpr size_t dim() {
        return sub_traits::template dim<D>();
    }

    static constexpr size_t dimensions() {
        return sub_traits::dimensions();
    }

    static constexpr int complexity() noexcept {
        return UnaryOp::complexity() + sub_traits::complexity();
    }
};

} //end of namespace etl