commit dd654512eaaf6d7aedfd2f6b6e147b047d594ea2
parent 3082b352ba7c3a6ce03bf9979092e5f26946dcac
Author: d.levin256@gmail.com <d.levin256@gmail.com>
Date: Wed, 9 Nov 2016 09:46:58 +0300
Rename expression to expression_base
Diffstat:
7 files changed, 53 insertions(+), 51 deletions(-)
diff --git a/include/kfr/base/basic_expressions.hpp b/include/kfr/base/basic_expressions.hpp
@@ -36,10 +36,10 @@ namespace internal
{
template <typename To, typename E>
-struct expression_convert : expression<E>
+struct expression_convert : expression_base<E>
{
using value_type = To;
- CMT_INLINE expression_convert(E&& expr) noexcept : expression<E>(std::forward<E>(expr)) {}
+ CMT_INLINE expression_convert(E&& expr) noexcept : expression_base<E>(std::forward<E>(expr)) {}
template <size_t N>
CMT_INLINE vec<To, N> operator()(cinput_t input, size_t index, vec_t<To, N>) const
@@ -191,12 +191,12 @@ namespace internal
{
template <typename E1>
-struct expression_slice : expression<E1>
+struct expression_slice : expression_base<E1>
{
using value_type = value_type_of<E1>;
using T = value_type;
expression_slice(E1&& e1, size_t start, size_t size)
- : expression<E1>(std::forward<E1>(e1)), start(start),
+ : expression_base<E1>(std::forward<E1>(e1)), start(start),
new_size(size_min(size, size_sub(std::get<0>(this->args).size(), start)))
{
}
@@ -211,11 +211,11 @@ struct expression_slice : expression<E1>
};
template <typename E1>
-struct expression_reverse : expression<E1>
+struct expression_reverse : expression_base<E1>
{
using value_type = value_type_of<E1>;
using T = value_type;
- expression_reverse(E1&& e1) : expression<E1>(std::forward<E1>(e1)), expr_size(e1.size()) {}
+ expression_reverse(E1&& e1) : expression_base<E1>(std::forward<E1>(e1)), expr_size(e1.size()) {}
template <size_t N>
CMT_INLINE vec<T, N> operator()(cinput_t cinput, size_t index, vec_t<T, N> y) const
{
@@ -287,10 +287,10 @@ struct expression_linspace<T, true> : input_expression
};
template <typename... E>
-struct expression_sequence : expression<E...>
+struct expression_sequence : expression_base<E...>
{
public:
- using base = expression<E...>;
+ using base = expression_base<E...>;
using value_type = common_type<value_type_of<E>...>;
using T = value_type;
@@ -338,12 +338,12 @@ protected:
};
template <typename Fn, typename E>
-struct expression_adjacent : expression<E>
+struct expression_adjacent : expression_base<E>
{
using value_type = value_type_of<E>;
using T = value_type;
- expression_adjacent(Fn&& fn, E&& e) : expression<E>(std::forward<E>(e)), fn(std::forward<Fn>(fn)) {}
+ expression_adjacent(Fn&& fn, E&& e) : expression_base<E>(std::forward<E>(e)), fn(std::forward<Fn>(fn)) {}
template <size_t N>
vec<T, N> operator()(cinput_t cinput, size_t index, vec_t<T, N>) const
@@ -413,14 +413,14 @@ CMT_INLINE internal::expression_adjacent<Fn, E1> adjacent(Fn&& fn, E1&& e1)
namespace internal
{
template <typename E>
-struct expression_padded : expression<E>
+struct expression_padded : expression_base<E>
{
using value_type = value_type_of<E>;
CMT_INLINE constexpr static size_t size() noexcept { return infinite_size; }
expression_padded(value_type fill_value, E&& e)
- : expression<E>(std::forward<E>(e)), fill_value(fill_value), input_size(e.size())
+ : expression_base<E>(std::forward<E>(e)), fill_value(fill_value), input_size(e.size())
{
}
@@ -484,15 +484,15 @@ private:
};
template <typename... E>
-struct expression_pack : expression<E...>
+struct expression_pack : expression_base<E...>
{
constexpr static size_t count = sizeof...(E);
- expression_pack(E&&... e) : expression<E...>(std::forward<E>(e)...) {}
+ expression_pack(E&&... e) : expression_base<E...>(std::forward<E>(e)...) {}
using value_type = vec<common_type<value_type_of<E>...>, count>;
using T = value_type;
- using expression<E...>::size;
+ using expression_base<E...>::size;
template <size_t N>
CMT_INLINE vec<T, N> operator()(cinput_t cinput, size_t index, vec_t<T, N> y) const
@@ -502,17 +502,17 @@ struct expression_pack : expression<E...>
};
template <typename... E>
-struct expression_unpack : private expression<E...>, output_expression
+struct expression_unpack : private expression_base<E...>, output_expression
{
- using expression<E...>::begin_block;
- using expression<E...>::end_block;
+ using expression_base<E...>::begin_block;
+ using expression_base<E...>::end_block;
using output_expression::begin_block;
using output_expression::end_block;
constexpr static size_t count = sizeof...(E);
- expression_unpack(E&&... e) : expression<E...>(std::forward<E>(e)...) {}
+ expression_unpack(E&&... e) : expression_base<E...>(std::forward<E>(e)...) {}
- using expression<E...>::size;
+ using expression_base<E...>::size;
template <typename U, size_t N>
CMT_INLINE void operator()(coutput_t coutput, size_t index, const vec<vec<U, count>, N>& x)
diff --git a/include/kfr/base/expression.hpp b/include/kfr/base/expression.hpp
@@ -256,13 +256,13 @@ namespace internal
{
template <typename... Args>
-struct expression : input_expression
+struct expression_base : input_expression
{
CMT_INLINE constexpr size_t size() const noexcept { return size_impl(indicesfor_t<Args...>()); }
constexpr static size_t count = sizeof...(Args);
- expression() = delete;
- constexpr expression(Args&&... args) noexcept : args(std::forward<Args>(args)...) {}
+ expression_base() = delete;
+ constexpr expression_base(Args&&... args) noexcept : args(std::forward<Args>(args)...) {}
CMT_INLINE void begin_block(cinput_t cinput, size_t size) const
{
@@ -364,19 +364,19 @@ template <typename T>
using arg = typename internal::arg_impl<decay<T>, T>::type;
template <typename Fn, typename... Args>
-struct expression_function : expression<arg<Args>...>
+struct expression_function : expression_base<arg<Args>...>
{
using value_type =
subtype<decltype(std::declval<Fn>()(std::declval<vec<value_type_of<arg<Args>>, 1>>()...))>;
using T = value_type;
expression_function(Fn&& fn, arg<Args>&&... args) noexcept
- : expression<arg<Args>...>(std::forward<arg<Args>>(args)...),
+ : expression_base<arg<Args>...>(std::forward<arg<Args>>(args)...),
fn(std::forward<Fn>(fn))
{
}
expression_function(const Fn& fn, arg<Args>&&... args) noexcept
- : expression<arg<Args>...>(std::forward<arg<Args>>(args)...),
+ : expression_base<arg<Args>...>(std::forward<arg<Args>>(args)...),
fn(fn)
{
}
diff --git a/include/kfr/dft/convolution.hpp b/include/kfr/dft/convolution.hpp
@@ -86,6 +86,5 @@ CMT_FUNC univector<T> autocorrelate(const univector<T, Tag1>& src)
result = result.slice(result.size() / 2);
return result;
}
-
}
CMT_PRAGMA_GNU(GCC diagnostic pop)
diff --git a/include/kfr/dsp/biquad.hpp b/include/kfr/dsp/biquad.hpp
@@ -137,12 +137,12 @@ struct biquad_block
};
template <size_t filters, typename T, typename E1, KFR_ARCH_DEP>
-struct expression_biquads : public expression<E1>
+struct expression_biquads : public expression_base<E1>
{
using value_type = T;
expression_biquads(const biquad_block<T, filters>& bq, E1&& e1)
- : expression<E1>(std::forward<E1>(e1)), bq(bq)
+ : expression_base<E1>(std::forward<E1>(e1)), bq(bq)
{
}
template <size_t width>
@@ -173,12 +173,12 @@ struct expression_biquads : public expression<E1>
};
template <size_t filters, typename T, typename E1, KFR_ARCH_DEP>
-struct expression_biquads_zl : expression<E1>
+struct expression_biquads_zl : expression_base<E1>
{
using value_type = T;
expression_biquads_zl(const biquad_block<T, filters>& bq, E1&& e1)
- : expression<E1>(std::forward<E1>(e1)), bq(bq), block_end(0)
+ : expression_base<E1>(std::forward<E1>(e1)), bq(bq), block_end(0)
{
}
diff --git a/include/kfr/dsp/delay.hpp b/include/kfr/dsp/delay.hpp
@@ -34,11 +34,11 @@ namespace kfr
namespace internal
{
template <size_t delay, typename E>
-struct expression_delay : expression<E>
+struct expression_delay : expression_base<E>
{
using value_type = value_type_of<E>;
using T = value_type;
- using expression<E>::expression;
+ using expression_base<E>::expression_base;
template <size_t N, KFR_ENABLE_IF(N <= delay)>
vec<T, N> operator()(cinput_t cinput, size_t index, vec_t<T, N>) const
@@ -75,11 +75,11 @@ struct expression_delay : expression<E>
};
template <typename E>
-struct expression_delay<1, E> : expression<E>
+struct expression_delay<1, E> : expression_base<E>
{
using value_type = value_type_of<E>;
using T = value_type;
- using expression<E>::expression;
+ using expression_base<E>::expression_base;
template <size_t N>
vec<T, N> operator()(cinput_t cinput, size_t index, vec_t<T, N>) const
diff --git a/include/kfr/dsp/fir.hpp b/include/kfr/dsp/fir.hpp
@@ -91,12 +91,12 @@ struct state_holder<T, true>
};
template <size_t tapcount, typename T, typename E1, bool stateless = false, KFR_ARCH_DEP>
-struct expression_short_fir : expression<E1>
+struct expression_short_fir : expression_base<E1>
{
using value_type = T;
expression_short_fir(E1&& e1, const short_fir_state<tapcount, T>& state)
- : expression<E1>(std::forward<E1>(e1)), state(state)
+ : expression_base<E1>(std::forward<E1>(e1)), state(state)
{
}
template <size_t N>
@@ -116,10 +116,13 @@ struct expression_short_fir : expression<E1>
};
template <typename T, typename E1, bool stateless = false, KFR_ARCH_DEP>
-struct expression_fir : expression<E1>
+struct expression_fir : expression_base<E1>
{
using value_type = T;
- expression_fir(E1&& e1, const fir_state<T>& state) : expression<E1>(std::forward<E1>(e1)), state(state) {}
+ expression_fir(E1&& e1, const fir_state<T>& state)
+ : expression_base<E1>(std::forward<E1>(e1)), state(state)
+ {
+ }
template <size_t N>
CMT_INLINE vec<T, N> operator()(cinput_t cinput, size_t index, vec_t<T, N> x) const
diff --git a/include/kfr/dsp/sample_rate_conversion.hpp b/include/kfr/dsp/sample_rate_conversion.hpp
@@ -208,13 +208,13 @@ template <size_t factor, size_t offset, typename E>
struct expression_downsample;
template <typename E>
-struct expression_upsample<2, E> : expression<E>
+struct expression_upsample<2, E> : expression_base<E>
{
- using expression<E>::expression;
+ using expression_base<E>::expression_base;
using value_type = value_type_of<E>;
using T = value_type;
- size_t size() const noexcept { return expression<E>::size() * 2; }
+ size_t size() const noexcept { return expression_base<E>::size() * 2; }
template <size_t N>
vec<T, N> operator()(cinput_t cinput, size_t index, vec_t<T, N>) const
@@ -232,13 +232,13 @@ struct expression_upsample<2, E> : expression<E>
};
template <typename E>
-struct expression_upsample<4, E> : expression<E>
+struct expression_upsample<4, E> : expression_base<E>
{
- using expression<E>::expression;
+ using expression_base<E>::expression_base;
using value_type = value_type_of<E>;
using T = value_type;
- size_t size() const noexcept { return expression<E>::size() * 4; }
+ size_t size() const noexcept { return expression_base<E>::size() * 4; }
template <size_t N>
vec<T, N> operator()(cinput_t cinput, size_t index, vec_t<T, N>) const
@@ -269,13 +269,13 @@ struct expression_upsample<4, E> : expression<E>
};
template <typename E, size_t offset>
-struct expression_downsample<2, offset, E> : expression<E>
+struct expression_downsample<2, offset, E> : expression_base<E>
{
- using expression<E>::expression;
+ using expression_base<E>::expression_base;
using value_type = value_type_of<E>;
using T = value_type;
- size_t size() const noexcept { return expression<E>::size() / 2; }
+ size_t size() const noexcept { return expression_base<E>::size() / 2; }
template <size_t N>
vec<T, N> operator()(cinput_t cinput, size_t index, vec_t<T, N>) const
@@ -286,13 +286,13 @@ struct expression_downsample<2, offset, E> : expression<E>
};
template <typename E, size_t offset>
-struct expression_downsample<4, offset, E> : expression<E>
+struct expression_downsample<4, offset, E> : expression_base<E>
{
- using expression<E>::expression;
+ using expression_base<E>::expression_base;
using value_type = value_type_of<E>;
using T = value_type;
- size_t size() const noexcept { return expression<E>::size() / 4; }
+ size_t size() const noexcept { return expression_base<E>::size() / 4; }
template <size_t N>
vec<T, N> operator()(cinput_t cinput, size_t index, vec_t<T, N>) const
