From d660ca06e794804293157c8acfa7fd57f12e911c Mon Sep 17 00:00:00 2001 From: Baptiste Wicht Date: Fri, 24 Apr 2015 16:26:37 +0200 Subject: [PATCH] Merge stable_transform and unary --- include/etl/etl.hpp | 1 - include/etl/evaluator.hpp | 12 +-- include/etl/fast_expr.hpp | 20 ++--- include/etl/stable_transform_expr.hpp | 109 -------------------------- include/etl/traits.hpp | 42 +--------- 5 files changed, 12 insertions(+), 172 deletions(-) delete mode 100644 include/etl/stable_transform_expr.hpp diff --git a/include/etl/etl.hpp b/include/etl/etl.hpp index 30ec4dfbe..2de220257 100644 --- a/include/etl/etl.hpp +++ b/include/etl/etl.hpp @@ -19,7 +19,6 @@ // The expressions #include "binary_expr.hpp" #include "unary_expr.hpp" -#include "stable_transform_expr.hpp" #include "generator_expr.hpp" #include "temporary_expr.hpp" diff --git a/include/etl/evaluator.hpp b/include/etl/evaluator.hpp index 16a48be78..5834b882e 100644 --- a/include/etl/evaluator.hpp +++ b/include/etl/evaluator.hpp @@ -21,11 +21,6 @@ struct temporary_allocator_static_visitor { (*this)(v.value()); } - template - void operator()(etl::stable_transform_expr& v) const { - (*this)(v.value()); - } - template void operator()(etl::binary_expr& v) const { (*this)(v.lhs()); @@ -55,7 +50,7 @@ struct temporary_allocator_static_visitor { void operator()(T& transformer) const { (*this)(transformer.value()); } - + template void operator()(const generator_expr&) const { //Leaf @@ -85,11 +80,6 @@ struct evaluator_static_visitor { (*this)(v.value()); } - template - void operator()(etl::stable_transform_expr& v) const { - (*this)(v.value()); - } - template void operator()(etl::binary_expr& v) const { (*this)(v.lhs()); diff --git a/include/etl/fast_expr.hpp b/include/etl/fast_expr.hpp index 232440f1f..cf05e5ff7 100644 --- a/include/etl/fast_expr.hpp +++ b/include/etl/fast_expr.hpp @@ -50,10 +50,10 @@ template using virtual_helper = unary_expr; template class OP> -using stable_transform_helper = stable_transform_expr, OP>>; +using stable_transform_helper = unary_expr, OP>, virtual_op>; template class OP> -using stable_transform_binary_helper = stable_transform_expr, OP, build_type>>; +using stable_transform_binary_helper = unary_expr, OP, build_type>, virtual_op>; template class OP> using temporary_binary_helper = temporary_binary_expr, build_type, build_type, OP>, void>; @@ -467,37 +467,37 @@ auto magic() -> virtual_helper> { //{{{ Apply a stable transformation template::value)> -auto rep(E&& value) -> stable_transform_expr, rep_r_transformer, D1, D...>> { +auto rep(E&& value) -> unary_expr, rep_r_transformer, D1, D...>, virtual_op> { static_assert(etl_traits>::dimensions() == 1, "Can only use rep on vector"); return {rep_r_transformer, D1, D...>(value)}; } template::value)> -auto rep_r(E&& value) -> stable_transform_expr, rep_r_transformer, D1, D...>> { +auto rep_r(E&& value) -> unary_expr, rep_r_transformer, D1, D...>, virtual_op> { static_assert(etl_traits>::dimensions() == 1, "Can only use rep on vector"); return {rep_r_transformer, D1, D...>(value)}; } template::value)> -auto rep_l(E&& value) -> stable_transform_expr, rep_l_transformer, D1, D...>> { +auto rep_l(E&& value) -> unary_expr, rep_l_transformer, D1, D...>, virtual_op> { static_assert(etl_traits>::dimensions() == 1, "Can only use rep on vector"); return {rep_l_transformer, D1, D...>(value)}; } template::value && cpp::all_convertible_to::value)> -auto rep(E&& value, std::size_t d1, D... d) -> stable_transform_expr, dyn_rep_r_transformer, 1 + sizeof...(D)>> { +auto rep(E&& value, std::size_t d1, D... d) -> unary_expr, dyn_rep_r_transformer, 1 + sizeof...(D)>, virtual_op> { static_assert(etl_traits>::dimensions() == 1, "Can only use rep on vector"); return {dyn_rep_r_transformer, 1 + sizeof...(D)>(value, {{d1, static_cast(d)...}})}; } template::value && cpp::all_convertible_to::value)> -auto rep_r(E&& value, std::size_t d1, D... d) -> stable_transform_expr, dyn_rep_r_transformer, 1 + sizeof...(D)>> { +auto rep_r(E&& value, std::size_t d1, D... d) -> unary_expr, dyn_rep_r_transformer, 1 + sizeof...(D)>, virtual_op> { static_assert(etl_traits>::dimensions() == 1, "Can only use rep on vector"); return {dyn_rep_r_transformer, 1 + sizeof...(D)>(value, {{d1, static_cast(d)...}})}; } template::value && cpp::all_convertible_to::value)> -auto rep_l(E&& value, std::size_t d1, D... d) -> stable_transform_expr, dyn_rep_l_transformer, 1 + sizeof...(D)>> { +auto rep_l(E&& value, std::size_t d1, D... d) -> unary_expr, dyn_rep_l_transformer, 1 + sizeof...(D)>, virtual_op> { static_assert(etl_traits>::dimensions() == 1, "Can only use rep on vector"); return {dyn_rep_l_transformer, 1 + sizeof...(D)>(value, {{d1, static_cast(d)...}})}; } @@ -555,14 +555,14 @@ auto transpose(const E& value) -> stable_transform_helper::value> = cpp::detail::dummy> -auto p_max_pool_h(E&& value) -> stable_transform_expr, p_max_pool_h_transformer, C1, C2>> { +auto p_max_pool_h(E&& value) -> unary_expr, p_max_pool_h_transformer, C1, C2>, virtual_op> { static_assert(etl_traits>::dimensions() == 2 || etl_traits>::dimensions() == 3, "Max pool is only implemented for 2D and 3D"); return {p_max_pool_h_transformer, C1, C2>(value)}; } template::value> = cpp::detail::dummy> -auto p_max_pool_p(E&& value) -> stable_transform_expr, p_max_pool_p_transformer, C1, C2>> { +auto p_max_pool_p(E&& value) -> unary_expr, p_max_pool_p_transformer, C1, C2>, virtual_op> { static_assert(etl_traits>::dimensions() == 2 || etl_traits>::dimensions() == 3, "Max pool is only implemented for 2D and 3D"); return {p_max_pool_p_transformer, C1, C2>(value)}; diff --git a/include/etl/stable_transform_expr.hpp b/include/etl/stable_transform_expr.hpp deleted file mode 100644 index d633b7dc8..000000000 --- a/include/etl/stable_transform_expr.hpp +++ /dev/null @@ -1,109 +0,0 @@ -//======================================================================= -// Copyright (c) 2014-2015 Baptiste Wicht -// Distributed under the terms of the MIT License. -// (See accompanying file LICENSE or copy at -// http://opensource.org/licenses/MIT) -//======================================================================= - -#ifndef ETL_STABLE_TRANSFORM_EXPR_HPP -#define ETL_STABLE_TRANSFORM_EXPR_HPP - -#include //For stream support - -#include "traits_lite.hpp" -#include "iterator.hpp" - -#include "comparable.hpp" -#include "iterable.hpp" - -namespace etl { - -//TODO Check if this could not be merged with unary_expr - -template -class stable_transform_expr final : comparable>, iterable> { -private: - static_assert(is_etl_expr::value, "Only ETL expressions can be used in stable_transform_expr"); - - using this_type = stable_transform_expr; - - Expr _value; - -public: - using value_type = T; - using expr_type = Expr; - using memory_type = void; - using const_memory_type = void; - - //Cannot be constructed with no args - stable_transform_expr() = delete; - - //Construct a new expression - stable_transform_expr(Expr l) : _value(std::forward(l)){ - //Nothing else to init - } - - stable_transform_expr(const stable_transform_expr& e) : _value(e._value) { - //Nothing else to init - } - - stable_transform_expr(stable_transform_expr&& e) : _value(e._value) { - //Nothing else to init - } - - //Expression are invariant - stable_transform_expr& operator=(const stable_transform_expr&) = delete; - stable_transform_expr& operator=(stable_transform_expr&&) = delete; - - //Accessors - - std::add_lvalue_reference_t value() noexcept { - return _value; - } - - cpp::add_const_lvalue_t value() const noexcept { - return _value; - } - - //Apply the expression - - value_type operator[](std::size_t i) const { - return value()[i]; - } - - template - std::enable_if_t::value, value_type> operator()(S... args) const { - static_assert(cpp::all_convertible_to::value, "Invalid size types"); - - return value()(args...); - } - - template::value > 1), cpp::enable_if_u = cpp::detail::dummy> - auto operator()(std::size_t i){ - return sub(*this, i); - } - - template::value > 1), cpp::enable_if_u = cpp::detail::dummy> - auto operator()(std::size_t i) const { - return sub(*this, i); - } - - iterator begin() const noexcept { - return {*this, 0}; - } - - iterator end() const noexcept { - return {*this, size(*this)}; - } -}; - -template -std::ostream& operator<<(std::ostream& os, const stable_transform_expr& expr){ - return os << expr.value(); -} - -//}}} - -} //end of namespace etl - -#endif diff --git a/include/etl/traits.hpp b/include/etl/traits.hpp index 8b6cb6f15..023d3ca5e 100644 --- a/include/etl/traits.hpp +++ b/include/etl/traits.hpp @@ -31,9 +31,6 @@ using is_binary_expr = cpp::is_specialization_of; template> using is_generator_expr = cpp::is_specialization_of; -template> -using is_stable_transform_expr = cpp::is_specialization_of; - template> using is_temporary_binary_expr = cpp::is_specialization_of; @@ -79,7 +76,6 @@ struct is_etl_expr : cpp::bool_constant_c, is_binary_expr, is_temporary_binary_expr, - is_stable_transform_expr, is_generator_expr, is_transformer, is_view, is_transformer, is_magic_view @@ -91,8 +87,7 @@ struct is_copy_expr : cpp::bool_constant_c, is_unary_expr, is_binary_expr, - is_temporary_binary_expr, - is_stable_transform_expr + is_temporary_binary_expr >> {}; template @@ -214,41 +209,6 @@ struct etl_traits> { } }; -/*! - * \brief Specialization (un)stable_transform_expr - */ -template -struct etl_traits::value>> { - using expr_t = std::decay_t; - using sub_expr_t = std::decay_t; - - static constexpr const bool is_fast = etl_traits::is_fast; - static constexpr const bool is_value = false; - static constexpr const bool is_generator = etl_traits::is_generator; - - static std::size_t size(const expr_t& v){ - return etl_traits::size(v.value()); - } - - static std::size_t dim(const expr_t& v, std::size_t d){ - return etl_traits::dim(v.value(), d); - } - - template = cpp::detail::dummy> - static constexpr std::size_t size(){ - return etl_traits::size(); - } - - template - static constexpr std::size_t dim(){ - return etl_traits::template dim(); - } - - static constexpr std::size_t dimensions(){ - return etl_traits::dimensions(); - } -}; - /*! * \brief Specialization generator_expr */