commit 0f77ea17d22f28e80351a5b4985c5948b4f0c6f8 parent e0199eab4ac465129068dbeff7b94ce6d722b4d3 Author: [email protected] <[email protected]> Date: Wed, 2 Nov 2022 08:28:20 +0000 Rename pointer -> handle Diffstat:
24 files changed, 540 insertions(+), 547 deletions(-)
diff --git a/docs/docs/fir.md b/docs/docs/fir.md @@ -4,7 +4,7 @@ ```c++ linenums="1" // Initialize window function -expression_pointer<fbase> kaiser = to_pointer(window_kaiser(taps.size(), 3.0)); +expression_handle<fbase> kaiser = to_handle(window_kaiser(taps.size(), 3.0)); // Initialize taps univector<float, 7> taps; @@ -85,4 +85,4 @@ filter.apply(output, input); See also [Filter class definition](auto/filter.md) -[See also a gallery with results of applying various FIR filters](fir_gallery.md) -\ No newline at end of file +[See also a gallery with results of applying various FIR filters](fir_gallery.md) diff --git a/docs/docs/fir_gallery.md b/docs/docs/fir_gallery.md @@ -5,7 +5,7 @@ Code ```c++ linenums="1" univector<fbase, 127> taps127; -expression_pointer<fbase> kaiser = to_pointer(window_kaiser(taps127.size(), 3.0)); +expression_handle<fbase> kaiser = to_handle(window_kaiser(taps127.size(), 3.0)); // Fill taps127 with the band pass FIR filter coefficients using kaiser window and cutoff=0.2 and 0.4 fir_bandpass(taps127, 0.2, 0.4, kaiser, true); @@ -22,7 +22,7 @@ Result Code ```c++ linenums="1" univector<fbase, 127> taps127; -expression_pointer<fbase> kaiser = to_pointer(window_kaiser(taps127.size(), 3.0)); +expression_handle<fbase> kaiser = to_handle(window_kaiser(taps127.size(), 3.0)); // Fill taps127 with the band stop FIR filter coefficients using kaiser window and cutoff=0.2 and 0.4 fir_bandstop(taps127, 0.2, 0.4, kaiser, true); @@ -39,7 +39,7 @@ Result Code ```c++ linenums="1" univector<fbase, 127> taps127; -expression_pointer<fbase> kaiser = to_pointer(window_kaiser(taps127.size(), 3.0)); +expression_handle<fbase> kaiser = to_handle(window_kaiser(taps127.size(), 3.0)); // Fill taps127 with the high pass FIR filter coefficients using kaiser window and cutoff=0.2 fir_highpass(taps127, 0.2, kaiser, true); @@ -56,7 +56,7 @@ Result Code ```c++ linenums="1" univector<fbase, 8191> taps8191; -expression_pointer<fbase> blackman_harris = to_pointer(window_blackman_harris(taps8191.size())); +expression_handle<fbase> blackman_harris = to_handle(window_blackman_harris(taps8191.size())); // Fill taps8191 with the low pass FIR filter coefficients using blackman harris window and cutoff=0.15 fir_lowpass(taps8191, 0.15, blackman_harris, true); @@ -77,7 +77,7 @@ Result Code ```c++ linenums="1" univector<fbase, 15> taps15; -expression_pointer<fbase> hann = to_pointer(window_hann(taps15.size())); +expression_handle<fbase> hann = to_handle(window_hann(taps15.size())); // Fill taps15 with the low pass FIR filter coefficients using hann window and cutoff=0.15 fir_lowpass(taps15, 0.15, hann, true); @@ -95,7 +95,7 @@ Code ```c++ linenums="1" univector<fbase, 127> taps127; -expression_pointer<fbase> kaiser = to_pointer(window_kaiser(taps127.size(), 3.0)); +expression_handle<fbase> kaiser = to_handle(window_kaiser(taps127.size(), 3.0)); // Fill taps127 with the low pass FIR filter coefficients using kaiser window and cutoff=0.2 fir_lowpass(taps127, 0.2, kaiser, true); @@ -110,7 +110,7 @@ Result ```c++ linenums="1" univector<fbase, 127> taps127; -expression_pointer<fbase> kaiser = to_pointer(window_kaiser(taps127.size(), 3.0)); +expression_handle<fbase> kaiser = to_handle(window_kaiser(taps127.size(), 3.0)); fir_bandstop(taps127, 0.2, 0.4, kaiser, true); // Initialize FIR filter with float input/output and fbase taps filter_fir<fbase, float> fir_filter(taps127); @@ -130,7 +130,7 @@ Result ```c++ linenums="1" univector<fbase, 127> taps127; -expression_pointer<fbase> kaiser = to_pointer(window_kaiser(taps127.size(), 3.0)); +expression_handle<fbase> kaiser = to_handle(window_kaiser(taps127.size(), 3.0)); fir_bandpass(taps127, 0.2, 0.4, kaiser, true); // Initialize FIR filter with float input/output and fbase taps filter_fir<fbase, float> fir_filter(taps127); @@ -144,4 +144,4 @@ plot_save("filtered_noise2", filtered_noise2, "title='Filtered noise 2', div_by_ ``` Result - -\ No newline at end of file + diff --git a/examples/ccv.cpp b/examples/ccv.cpp @@ -21,7 +21,7 @@ int main() // low-pass filter univector<fbase, 1023> taps127; - expression_pointer<fbase> kaiser = to_pointer(window_kaiser(taps127.size(), 3.0)); + expression_handle<fbase> kaiser = to_handle(window_kaiser(taps127.size(), 3.0)); fir_lowpass(taps127, 0.2, kaiser, true); // Create filters. diff --git a/examples/fir.cpp b/examples/fir.cpp @@ -34,11 +34,11 @@ int main() univector<fbase, 8191> taps8191; // Prepare window functions (only expression saved here, not data) - expression_pointer<fbase> hann = to_pointer(window_hann(taps15.size())); + expression_handle<fbase> hann = to_handle(window_hann(taps15.size())); - expression_pointer<fbase> kaiser = to_pointer(window_kaiser(taps127.size(), 3.0)); + expression_handle<fbase> kaiser = to_handle(window_kaiser(taps127.size(), 3.0)); - expression_pointer<fbase> blackman_harris = to_pointer(window_blackman_harris(taps8191.size())); + expression_handle<fbase> blackman_harris = to_handle(window_blackman_harris(taps8191.size())); // Fill taps15 with the low pass FIR filter coefficients using hann window and cutoff=0.15 fir_lowpass(taps15, 0.15, hann, true); @@ -102,8 +102,7 @@ int main() // -------------------------------------------------------------------------------------- // Prepare 10000 samples of white noise - univector<float> noise = - truncate(gen_random_range(random_init(1, 2, 3, 4), -1.f, +1.f), 10000); + univector<float> noise = truncate(gen_random_range(random_init(1, 2, 3, 4), -1.f, +1.f), 10000); // Apply band stop filter univector<float> filtered_noise = fir(noise, taps127); diff --git a/include/kfr/base.hpp b/include/kfr/base.hpp @@ -30,9 +30,9 @@ #include "base/filter.hpp" #include "base/fraction.hpp" #include "base/generators.hpp" +#include "base/handle.hpp" #include "base/math_expressions.hpp" #include "base/memory.hpp" -#include "base/pointer.hpp" #include "base/random.hpp" #include "base/random_bits.hpp" #include "base/reduce.hpp" diff --git a/include/kfr/base/filter.hpp b/include/kfr/base/filter.hpp @@ -27,7 +27,7 @@ #include "basic_expressions.hpp" #include "expression.hpp" -#include "pointer.hpp" +#include "handle.hpp" #include "univector.hpp" namespace kfr @@ -78,12 +78,12 @@ public: void apply(T* dest, const T* src, size_t size) { process_buffer(dest, src, size); } template <univector_tag Tag> - void apply(univector<T, Tag>& dest, const expression_pointer<T, 1>& src) + void apply(univector<T, Tag>& dest, const expression_handle<T, 1>& src) { process_expression(dest.data(), src, size_min(dest.size(), src.size())); } - void apply(T* dest, const expression_pointer<T, 1>& src, size_t size) + void apply(T* dest, const expression_handle<T, 1>& src, size_t size) { process_expression(dest, src, size_min(size, src.size())); } @@ -91,39 +91,39 @@ public: template <univector_tag Tag, typename Expr, KFR_ENABLE_IF(is_input_expression<Expr>)> void apply(univector<T, Tag>& dest, const Expr& src) { - process_expression(dest.data(), to_pointer(src), size_min(dest.size(), src.size())); + process_expression(dest.data(), to_handle(src), size_min(dest.size(), src.size())); } template <typename Expr, KFR_ENABLE_IF(is_input_expression<Expr>)> void apply(T* dest, const Expr& src, size_t size) { - process_expression(dest, to_pointer(src), size_min(size, src.size())); + process_expression(dest, to_handle(src), size_min(size, src.size())); } protected: - virtual void process_buffer(T* dest, const T* src, size_t size) = 0; - virtual void process_expression(T* dest, const expression_pointer<T, 1>& src, size_t size) = 0; + virtual void process_buffer(T* dest, const T* src, size_t size) = 0; + virtual void process_expression(T* dest, const expression_handle<T, 1>& src, size_t size) = 0; }; template <typename T> class expression_filter : public filter<T> { public: - explicit expression_filter(expression_pointer<T, 1> filter_expr) : filter_expr(std::move(filter_expr)) {} + explicit expression_filter(expression_handle<T, 1> filter_expr) : filter_expr(std::move(filter_expr)) {} protected: void process_buffer(T* dest, const T* src, size_t size) override { - substitute(filter_expr, to_pointer(make_univector(src, size))); + substitute(filter_expr, to_handle(make_univector(src, size))); process(make_univector(dest, size), filter_expr, shape<1>(0), shape<1>(size)); } - void process_expression(T* dest, const expression_pointer<T, 1>& src, size_t size) override + void process_expression(T* dest, const expression_handle<T, 1>& src, size_t size) override { substitute(filter_expr, src); process(make_univector(dest, size), filter_expr, shape<1>(0), shape<1>(size)); } - expression_pointer<T, 1> filter_expr; + expression_handle<T, 1> filter_expr; }; inline namespace CMT_ARCH_NAME @@ -133,13 +133,13 @@ inline namespace CMT_ARCH_NAME template <typename E, typename T = expression_value_type<E>> KFR_INTRINSIC expression_filter<T> to_filter(E&& e) { - return expression_filter<T>(to_pointer(std::move(e))); + return expression_filter<T>(to_handle(std::move(e))); } } // namespace CMT_ARCH_NAME /// @brief Converts expression with placeholder to filter. Placeholder and filter must have the same type template <typename T, typename E> -KFR_INTRINSIC expression_filter<T> to_filter(expression_pointer<T, 1>&& e) +KFR_INTRINSIC expression_filter<T> to_filter(expression_handle<T, 1>&& e) { return expression_filter<T>(std::move(e)); } diff --git a/include/kfr/base/handle.hpp b/include/kfr/base/handle.hpp @@ -0,0 +1,407 @@ +/** @addtogroup expressions + * @{ + */ +/* + Copyright (C) 2016-2022 Fractalium Ltd (https://www.kfrlib.com) + This file is part of KFR + + KFR is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 2 of the License, or + (at your option) any later version. + + KFR is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with KFR. + + If GPL is not suitable for your project, you must purchase a commercial license to use KFR. + Buying a commercial license is mandatory as soon as you develop commercial activities without + disclosing the source code of your own applications. + See https://www.kfrlib.com for details. + */ +#pragma once + +#include "../simd/vec.hpp" +#include "basic_expressions.hpp" +#include <memory> + +namespace kfr +{ + +template <typename T, index_t Dims> +struct expression_handle; + +template <typename T> +constexpr size_t maximum_expression_width = vector_width_for<T, cpu_t::highest> * 2; + +template <typename T, template <T...> typename Tpl, typename Pack> +struct expand_cvals; + +template <typename T, template <T...> typename Tpl, T... vals> +struct expand_cvals<T, Tpl, cvals_t<T, vals...>> +{ + using type = Tpl<vals...>; +}; + +inline namespace CMT_ARCH_NAME +{ + +namespace internal +{ + +template <typename Expression, typename T, index_t Dims, size_t key = 0> +KFR_INTRINSIC bool invoke_substitute(Expression& expr, expression_handle<T, Dims> new_handle, + csize_t<key> = {}); +} +} // namespace CMT_ARCH_NAME + +template <typename T, index_t Dims> +struct expression_vtable +{ + constexpr static const size_t Nsizes = 1 + ilog2(maximum_expression_width<T>); + constexpr static const size_t Nmax = 1 << Nsizes; + + using func_get = void (*)(void*, shape<Dims>, T*); + using func_set = void (*)(void*, shape<Dims>, const T*); + using func_shapeof = void (*)(void*, shape<Dims>&); + using func_substitute = bool (*)(void*, expression_handle<T, Dims>); + using func_pass = void (*)(void*, shape<Dims>, shape<Dims>); + + func_shapeof fn_shapeof; + func_substitute fn_substitute; + func_pass fn_begin_pass; + func_pass fn_end_pass; + std::array<std::array<func_get, Nsizes>, Dims> fn_get_elements; + std::array<std::array<func_set, Nsizes>, Dims> fn_set_elements; + + template <typename Expression> + KFR_MEM_INTRINSIC expression_vtable(ctype_t<Expression> t) + { + fn_shapeof = &static_shapeof<Expression>; + fn_substitute = &static_substitute<Expression>; + fn_begin_pass = &static_begin_pass<Expression>; + fn_end_pass = &static_end_pass<Expression>; + cforeach(csizeseq<Nsizes>, + [&](auto size_) CMT_INLINE_LAMBDA + { + cforeach(csizeseq<Dims>, + [&](auto axis_) CMT_INLINE_LAMBDA + { + constexpr size_t size = decltype(size_)::value; + constexpr size_t axis = decltype(axis_)::value; + fn_get_elements[axis][size] = + &static_get_elements<Expression, 1 << size, axis>; + fn_set_elements[axis][size] = + &static_set_elements<Expression, 1 << size, axis>; + }); + }); + } + + template <typename Expression, size_t N, index_t VecAxis> + static void static_get_elements(void* instance, shape<Dims> index, T* dest) + { + if constexpr (is_input_expression<Expression>) + { + write(dest, get_elements(*static_cast<Expression*>(instance), index, axis_params_v<VecAxis, N>)); + } + else + { + } + } + template <typename Expression, size_t N, index_t VecAxis> + static void static_set_elements(void* instance, shape<Dims> index, const T* src) + { + if constexpr (is_output_expression<Expression>) + { + set_elements(*static_cast<Expression*>(instance), index, axis_params_v<VecAxis, N>, read<N>(src)); + } + else + { + } + } + template <typename Expression> + static void static_shapeof(void* instance, shape<Dims>& result) + { + result = expression_traits<Expression>::shapeof(*static_cast<Expression*>(instance)); + } + template <typename Expression> + static bool static_substitute(void* instance, expression_handle<T, Dims> ptr) + { + return internal::invoke_substitute(*static_cast<Expression*>(instance), std::move(ptr)); + } + template <typename Expression> + static void static_begin_pass(void* instance, shape<Dims> start, shape<Dims> stop) + { + begin_pass(*static_cast<Expression*>(instance), start, stop); + } + template <typename Expression> + static void static_end_pass(void* instance, shape<Dims> start, shape<Dims> stop) + { + end_pass(*static_cast<Expression*>(instance), start, stop); + } +}; + +struct expression_resource +{ + virtual ~expression_resource() {} + virtual void* instance() { return nullptr; } +}; + +template <typename E> +struct expression_resource_impl : expression_resource +{ + expression_resource_impl(E&& e) CMT_NOEXCEPT : e(std::move(e)) {} + virtual ~expression_resource_impl() {} + KFR_INTRINSIC virtual void* instance() override final { return &e; } + +public: +#ifdef __cpp_aligned_new + static void operator delete(void* p, std::align_val_t al) noexcept { details::aligned_release(p); } +#endif + +private: + E e; +}; + +template <typename E> +KFR_INTRINSIC std::shared_ptr<expression_resource> make_resource(E&& e) +{ + using T = expression_resource_impl<decay<E>>; + return std::static_pointer_cast<expression_resource>(std::shared_ptr<T>( + new (aligned_allocate<T>()) T(std::move(e)), [](T* pi) { aligned_deallocate<T>(pi); })); +} + +template <typename T, index_t Dims = 1> +struct expression_handle +{ + void* instance; + const expression_vtable<T, Dims>* vtable; + std::shared_ptr<expression_resource> resource; + + expression_handle() CMT_NOEXCEPT : instance(nullptr), vtable(nullptr) {} + expression_handle(const void* instance, const expression_vtable<T, Dims>* vtable, + std::shared_ptr<expression_resource> resource = nullptr) + : instance(const_cast<void*>(instance)), vtable(vtable), resource(std::move(resource)) + { + } + + explicit operator bool() const { return instance != nullptr; } + + bool substitute(expression_handle<T, Dims> new_handle) + { + return vtable->fn_substitute(instance, std::move(new_handle)); + } +}; + +template <typename T, index_t Dims> +struct expression_traits<expression_handle<T, Dims>> : expression_traits_defaults +{ + using value_type = T; + constexpr static size_t dims = Dims; + constexpr static shape<dims> shapeof(const expression_handle<T, Dims>& self) + { + shape<dims> result; + self.vtable->fn_shapeof(self.instance, result); + return result; + } + constexpr static shape<dims> shapeof() { return shape<dims>(undefined_size); } + + constexpr static inline bool random_access = false; +}; + +inline namespace CMT_ARCH_NAME +{ + +template <typename T, index_t NDims> +KFR_INTRINSIC void begin_pass(const expression_handle<T, NDims>& self, shape<NDims> start, shape<NDims> stop) +{ + self.vtable->fn_begin_pass(self.instance, start, stop); +} +template <typename T, index_t NDims> +KFR_INTRINSIC void end_pass(const expression_handle<T, NDims>& self, shape<NDims> start, shape<NDims> stop) +{ + self.vtable->fn_end_pass(self.instance, start, stop); +} + +template <typename T, index_t NDims, index_t Axis, size_t N> +KFR_INTRINSIC vec<T, N> get_elements(const expression_handle<T, NDims>& self, const shape<NDims>& index, + const axis_params<Axis, N>& sh) +{ + static_assert(is_poweroftwo(N) && N >= 1); + if constexpr (N > expression_vtable<T, NDims>::Nmax) + { + constexpr size_t Nhalf = N / 2; + return concat(get_elements(self, index, axis_params_v<Axis, Nhalf>), + get_elements(self, index.add_at(Axis, Nhalf), axis_params_v<Axis, Nhalf>)); + } + else + { + portable_vec<T, N> result; + self.vtable->fn_get_elements[Axis][ilog2(N)](self.instance, index, result.elem); + return result; + } +} + +template <typename T, index_t NDims, index_t Axis, size_t N> +KFR_INTRINSIC void set_elements(const expression_handle<T, NDims>& self, const shape<NDims>& index, + const axis_params<Axis, N>& sh, const identity<vec<T, N>>& value) +{ + static_assert(is_poweroftwo(N) && N >= 1); + if constexpr (N > expression_vtable<T, NDims>::Nmax) + { + constexpr size_t Nhalf = N / 2; + set_elements(self, index, axis_params_v<Axis, Nhalf>, slice<0, Nhalf>(value)); + set_elements(self, index.add_at(Axis, Nhalf), axis_params_v<Axis, Nhalf>, slice<Nhalf, Nhalf>(value)); + } + else + { + self.vtable->fn_set_elements[Axis][ilog2(N)](self.instance, index, &value.front()); + } +} +} // namespace CMT_ARCH_NAME + +inline namespace CMT_ARCH_NAME +{ + +namespace internal +{ + +template <typename T, index_t Dims, typename E> +KFR_INTRINSIC expression_vtable<T, Dims>* make_expression_vtable() +{ + static expression_vtable<T, Dims> vtable{ ctype_t<decay<E>>{} }; + return &vtable; +} +} // namespace internal + +} // namespace CMT_ARCH_NAME + +/** @brief Converts the given expression into an opaque object. + * This overload takes reference to the expression. + * @warning Use with caution with local variables. + */ +template <typename E, typename T = expression_value_type<E>, index_t Dims = expression_dims<E>> +KFR_INTRINSIC expression_handle<T, Dims> to_handle(E& expr) +{ + return expression_handle<T>(std::addressof(expr), internal::make_expression_vtable<T, Dims, E>()); +} + +/** @brief Converts the given expression into an opaque object. + * This overload takes ownership of the expression (Move semantics). + * @note Use std::move to force use of this overload. + */ +template <typename E, typename T = expression_value_type<E>, index_t Dims = expression_dims<E>> +KFR_INTRINSIC expression_handle<T, Dims> to_handle(E&& expr) +{ + std::shared_ptr<expression_resource> ptr = make_resource(std::move(expr)); + void* instance = ptr->instance(); + return expression_handle<T, Dims>(instance, internal::make_expression_vtable<T, Dims, E>(), + std::move(ptr)); +} + +template <typename T, index_t Dims = 1, size_t Key = 0> +struct expression_placeholder +{ +public: + using value_type = T; + expression_placeholder() CMT_NOEXCEPT = default; + expression_handle<T, Dims> handle; +}; + +template <typename T, index_t Dims, size_t Key> +struct expression_traits<expression_placeholder<T, Dims, Key>> : public expression_traits_defaults +{ + using value_type = T; + constexpr static size_t dims = Dims; + constexpr static shape<dims> shapeof(const expression_placeholder<T, Dims, Key>& self) + { + return self.handle ? ::kfr::shapeof(self.handle) : shape<dims>(infinite_size); + } + constexpr static shape<dims> shapeof() { return shape<dims>(undefined_size); } +}; + +inline namespace CMT_ARCH_NAME +{ + +template <typename T, index_t Dims, size_t Key, index_t VecAxis, size_t N> +KFR_INTRINSIC vec<T, N> get_elements(const expression_placeholder<T, Dims, Key>& self, shape<Dims> index, + axis_params<VecAxis, N> sh) +{ + return self.handle ? get_elements(self.handle, index, sh) : 0; +} +} // namespace CMT_ARCH_NAME + +template <typename T, index_t Dims = 1, size_t Key = 0> +KFR_INTRINSIC expression_placeholder<T, Dims, Key> placeholder(csize_t<Key> = csize_t<Key>{}) +{ + return expression_placeholder<T, Dims, Key>(); +} + +template <typename... Args> +KFR_INTRINSIC bool substitute(const internal_generic::anything&, Args&&...) +{ + return false; +} + +inline namespace CMT_ARCH_NAME +{ +namespace internal +{ +template <typename... Args, typename T, index_t Dims, size_t Key, size_t... indices> +KFR_INTRINSIC bool substitute_helper(expression_with_arguments<Args...>& expr, + expression_handle<T, Dims> new_handle, csize_t<Key>, + csizes_t<indices...>); +} +} // namespace CMT_ARCH_NAME + +template <typename T, index_t Dims, size_t Key = 0> +KFR_INTRINSIC bool substitute(expression_placeholder<T, Dims, Key>& expr, + expression_handle<T, Dims> new_handle, csize_t<Key> = csize_t<Key>{}) +{ + expr.handle = std::move(new_handle); + return true; +} + +template <typename... Args, typename T, index_t Dims, size_t Key = 0> +KFR_INTRINSIC bool substitute(expression_with_arguments<Args...>& expr, expression_handle<T, Dims> new_handle, + csize_t<Key> = csize_t<Key>{}) +{ + return internal::substitute_helper(expr, std::move(new_handle), csize_t<Key>{}, indicesfor_t<Args...>{}); +} + +template <typename T, index_t Dims, size_t Key = 0> +KFR_INTRINSIC bool substitute(expression_handle<T, Dims>& expr, expression_handle<T, Dims> new_handle, + csize_t<Key> = csize_t<Key>{}) +{ + static_assert(Key == 0, "expression_handle supports only Key = 0"); + return expr.substitute(std::move(new_handle)); +} + +inline namespace CMT_ARCH_NAME +{ +namespace internal +{ + +template <typename... Args, typename T, index_t Dims, size_t Key, size_t... indices> +KFR_INTRINSIC bool substitute_helper(expression_with_arguments<Args...>& expr, + expression_handle<T, Dims> new_handle, csize_t<Key>, + csizes_t<indices...>) +{ + return (substitute(std::get<indices>(expr.args), std::move(new_handle), csize_t<Key>()) || ...); +} + +template <typename Expression, typename T, index_t Dims, size_t Key> +KFR_INTRINSIC bool invoke_substitute(Expression& expr, expression_handle<T, Dims> new_handle, csize_t<Key>) +{ + return kfr::substitute(expr, std::move(new_handle), csize_t<Key>{}); +} + +} // namespace internal + +} // namespace CMT_ARCH_NAME + +} // namespace kfr diff --git a/include/kfr/base/pointer.hpp b/include/kfr/base/pointer.hpp @@ -1,407 +0,0 @@ -/** @addtogroup expressions - * @{ - */ -/* - Copyright (C) 2016-2022 Fractalium Ltd (https://www.kfrlib.com) - This file is part of KFR - - KFR is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 2 of the License, or - (at your option) any later version. - - KFR is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with KFR. - - If GPL is not suitable for your project, you must purchase a commercial license to use KFR. - Buying a commercial license is mandatory as soon as you develop commercial activities without - disclosing the source code of your own applications. - See https://www.kfrlib.com for details. - */ -#pragma once - -#include "../simd/vec.hpp" -#include "basic_expressions.hpp" -#include <memory> - -namespace kfr -{ - -template <typename T, index_t Dims> -struct expression_pointer; - -template <typename T> -constexpr size_t maximum_expression_width = vector_width_for<T, cpu_t::highest> * 2; - -template <typename T, template <T...> typename Tpl, typename Pack> -struct expand_cvals; - -template <typename T, template <T...> typename Tpl, T... vals> -struct expand_cvals<T, Tpl, cvals_t<T, vals...>> -{ - using type = Tpl<vals...>; -}; - -inline namespace CMT_ARCH_NAME -{ - -namespace internal -{ - -template <typename Expression, typename T, index_t Dims, size_t key = 0> -KFR_INTRINSIC bool invoke_substitute(Expression& expr, expression_pointer<T, Dims> new_pointer, - csize_t<key> = {}); -} -} // namespace CMT_ARCH_NAME - -template <typename T, index_t Dims> -struct expression_vtable -{ - constexpr static const size_t Nsizes = 1 + ilog2(maximum_expression_width<T>); - constexpr static const size_t Nmax = 1 << Nsizes; - - using func_get = void (*)(void*, shape<Dims>, T*); - using func_set = void (*)(void*, shape<Dims>, const T*); - using func_shapeof = void (*)(void*, shape<Dims>&); - using func_substitute = bool (*)(void*, expression_pointer<T, Dims>); - using func_pass = void (*)(void*, shape<Dims>, shape<Dims>); - - func_shapeof fn_shapeof; - func_substitute fn_substitute; - func_pass fn_begin_pass; - func_pass fn_end_pass; - std::array<std::array<func_get, Nsizes>, Dims> fn_get_elements; - std::array<std::array<func_set, Nsizes>, Dims> fn_set_elements; - - template <typename Expression> - KFR_MEM_INTRINSIC expression_vtable(ctype_t<Expression> t) - { - fn_shapeof = &static_shapeof<Expression>; - fn_substitute = &static_substitute<Expression>; - fn_begin_pass = &static_begin_pass<Expression>; - fn_end_pass = &static_end_pass<Expression>; - cforeach(csizeseq<Nsizes>, - [&](auto size_) CMT_INLINE_LAMBDA - { - cforeach(csizeseq<Dims>, - [&](auto axis_) CMT_INLINE_LAMBDA - { - constexpr size_t size = decltype(size_)::value; - constexpr size_t axis = decltype(axis_)::value; - fn_get_elements[axis][size] = - &static_get_elements<Expression, 1 << size, axis>; - fn_set_elements[axis][size] = - &static_set_elements<Expression, 1 << size, axis>; - }); - }); - } - - template <typename Expression, size_t N, index_t VecAxis> - static void static_get_elements(void* instance, shape<Dims> index, T* dest) - { - if constexpr (is_input_expression<Expression>) - { - write(dest, get_elements(*static_cast<Expression*>(instance), index, axis_params_v<VecAxis, N>)); - } - else - { - } - } - template <typename Expression, size_t N, index_t VecAxis> - static void static_set_elements(void* instance, shape<Dims> index, const T* src) - { - if constexpr (is_output_expression<Expression>) - { - set_elements(*static_cast<Expression*>(instance), index, axis_params_v<VecAxis, N>, read<N>(src)); - } - else - { - } - } - template <typename Expression> - static void static_shapeof(void* instance, shape<Dims>& result) - { - result = expression_traits<Expression>::shapeof(*static_cast<Expression*>(instance)); - } - template <typename Expression> - static bool static_substitute(void* instance, expression_pointer<T, Dims> ptr) - { - return internal::invoke_substitute(*static_cast<Expression*>(instance), std::move(ptr)); - } - template <typename Expression> - static void static_begin_pass(void* instance, shape<Dims> start, shape<Dims> stop) - { - begin_pass(*static_cast<Expression*>(instance), start, stop); - } - template <typename Expression> - static void static_end_pass(void* instance, shape<Dims> start, shape<Dims> stop) - { - end_pass(*static_cast<Expression*>(instance), start, stop); - } -}; - -struct expression_resource -{ - virtual ~expression_resource() {} - virtual void* instance() { return nullptr; } -}; - -template <typename E> -struct expression_resource_impl : expression_resource -{ - expression_resource_impl(E&& e) CMT_NOEXCEPT : e(std::move(e)) {} - virtual ~expression_resource_impl() {} - KFR_INTRINSIC virtual void* instance() override final { return &e; } - -public: -#ifdef __cpp_aligned_new - static void operator delete(void* p, std::align_val_t al) noexcept { details::aligned_release(p); } -#endif - -private: - E e; -}; - -template <typename E> -KFR_INTRINSIC std::shared_ptr<expression_resource> make_resource(E&& e) -{ - using T = expression_resource_impl<decay<E>>; - return std::static_pointer_cast<expression_resource>(std::shared_ptr<T>( - new (aligned_allocate<T>()) T(std::move(e)), [](T* pi) { aligned_deallocate<T>(pi); })); -} - -template <typename T, index_t Dims = 1> -struct expression_pointer -{ - void* instance; - const expression_vtable<T, Dims>* vtable; - std::shared_ptr<expression_resource> resource; - - expression_pointer() CMT_NOEXCEPT : instance(nullptr), vtable(nullptr) {} - expression_pointer(const void* instance, const expression_vtable<T, Dims>* vtable, - std::shared_ptr<expression_resource> resource = nullptr) - : instance(const_cast<void*>(instance)), vtable(vtable), resource(std::move(resource)) - { - } - - explicit operator bool() const { return instance != nullptr; } - - bool substitute(expression_pointer<T, Dims> new_pointer) - { - return vtable->fn_substitute(instance, std::move(new_pointer)); - } -}; - -template <typename T, index_t Dims> -struct expression_traits<expression_pointer<T, Dims>> : expression_traits_defaults -{ - using value_type = T; - constexpr static size_t dims = Dims; - constexpr static shape<dims> shapeof(const expression_pointer<T, Dims>& self) - { - shape<dims> result; - self.vtable->fn_shapeof(self.instance, result); - return result; - } - constexpr static shape<dims> shapeof() { return shape<dims>(undefined_size); } - - constexpr static inline bool random_access = false; -}; - -inline namespace CMT_ARCH_NAME -{ - -template <typename T, index_t NDims> -KFR_INTRINSIC void begin_pass(const expression_pointer<T, NDims>& self, shape<NDims> start, shape<NDims> stop) -{ - self.vtable->fn_begin_pass(self.instance, start, stop); -} -template <typename T, index_t NDims> -KFR_INTRINSIC void end_pass(const expression_pointer<T, NDims>& self, shape<NDims> start, shape<NDims> stop) -{ - self.vtable->fn_end_pass(self.instance, start, stop); -} - -template <typename T, index_t NDims, index_t Axis, size_t N> -KFR_INTRINSIC vec<T, N> get_elements(const expression_pointer<T, NDims>& self, const shape<NDims>& index, - const axis_params<Axis, N>& sh) -{ - static_assert(is_poweroftwo(N) && N >= 1); - if constexpr (N > expression_vtable<T, NDims>::Nmax) - { - constexpr size_t Nhalf = N / 2; - return concat(get_elements(self, index, axis_params_v<Axis, Nhalf>), - get_elements(self, index.add_at(Axis, Nhalf), axis_params_v<Axis, Nhalf>)); - } - else - { - portable_vec<T, N> result; - self.vtable->fn_get_elements[Axis][ilog2(N)](self.instance, index, result.elem); - return result; - } -} - -template <typename T, index_t NDims, index_t Axis, size_t N> -KFR_INTRINSIC void set_elements(const expression_pointer<T, NDims>& self, const shape<NDims>& index, - const axis_params<Axis, N>& sh, const identity<vec<T, N>>& value) -{ - static_assert(is_poweroftwo(N) && N >= 1); - if constexpr (N > expression_vtable<T, NDims>::Nmax) - { - constexpr size_t Nhalf = N / 2; - set_elements(self, index, axis_params_v<Axis, Nhalf>, slice<0, Nhalf>(value)); - set_elements(self, index.add_at(Axis, Nhalf), axis_params_v<Axis, Nhalf>, slice<Nhalf, Nhalf>(value)); - } - else - { - self.vtable->fn_set_elements[Axis][ilog2(N)](self.instance, index, &value.front()); - } -} -} // namespace CMT_ARCH_NAME - -inline namespace CMT_ARCH_NAME -{ - -namespace internal -{ - -template <typename T, index_t Dims, typename E> -KFR_INTRINSIC expression_vtable<T, Dims>* make_expression_vtable() -{ - static expression_vtable<T, Dims> vtable{ ctype_t<decay<E>>{} }; - return &vtable; -} -} // namespace internal - -} // namespace CMT_ARCH_NAME - -/** @brief Converts the given expression into an opaque object. - * This overload takes reference to the expression. - * @warning Use with caution with local variables. - */ -template <typename E, typename T = expression_value_type<E>, index_t Dims = expression_dims<E>> -KFR_INTRINSIC expression_pointer<T, Dims> to_pointer(E& expr) -{ - return expression_pointer<T>(std::addressof(expr), internal::make_expression_vtable<T, Dims, E>()); -} - -/** @brief Converts the given expression into an opaque object. - * This overload takes ownership of the expression (Move semantics). - * @note Use std::move to force use of this overload. - */ -template <typename E, typename T = expression_value_type<E>, index_t Dims = expression_dims<E>> -KFR_INTRINSIC expression_pointer<T, Dims> to_pointer(E&& expr) -{ - std::shared_ptr<expression_resource> ptr = make_resource(std::move(expr)); - void* instance = ptr->instance(); - return expression_pointer<T, Dims>(instance, internal::make_expression_vtable<T, Dims, E>(), - std::move(ptr)); -} - -template <typename T, index_t Dims = 1, size_t Key = 0> -struct expression_placeholder -{ -public: - using value_type = T; - expression_placeholder() CMT_NOEXCEPT = default; - expression_pointer<T, Dims> pointer; -}; - -template <typename T, index_t Dims, size_t Key> -struct expression_traits<expression_placeholder<T, Dims, Key>> : public expression_traits_defaults -{ - using value_type = T; - constexpr static size_t dims = Dims; - constexpr static shape<dims> shapeof(const expression_placeholder<T, Dims, Key>& self) - { - return self.pointer ? ::kfr::shapeof(self.pointer) : shape<dims>(infinite_size); - } - constexpr static shape<dims> shapeof() { return shape<dims>(undefined_size); } -}; - -inline namespace CMT_ARCH_NAME -{ - -template <typename T, index_t Dims, size_t Key, index_t VecAxis, size_t N> -KFR_INTRINSIC vec<T, N> get_elements(const expression_placeholder<T, Dims, Key>& self, shape<Dims> index, - axis_params<VecAxis, N> sh) -{ - return self.pointer ? get_elements(self.pointer, index, sh) : 0; -} -} // namespace CMT_ARCH_NAME - -template <typename T, index_t Dims = 1, size_t Key = 0> -KFR_INTRINSIC expression_placeholder<T, Dims, Key> placeholder(csize_t<Key> = csize_t<Key>{}) -{ - return expression_placeholder<T, Dims, Key>(); -} - -template <typename... Args> -KFR_INTRINSIC bool substitute(const internal_generic::anything&, Args&&...) -{ - return false; -} - -inline namespace CMT_ARCH_NAME -{ -namespace internal -{ -template <typename... Args, typename T, index_t Dims, size_t Key, size_t... indices> -KFR_INTRINSIC bool substitute_helper(expression_with_arguments<Args...>& expr, - expression_pointer<T, Dims> new_pointer, csize_t<Key>, - csizes_t<indices...>); -} -} // namespace CMT_ARCH_NAME - -template <typename T, index_t Dims, size_t Key = 0> -KFR_INTRINSIC bool substitute(expression_placeholder<T, Dims, Key>& expr, - expression_pointer<T, Dims> new_pointer, csize_t<Key> = csize_t<Key>{}) -{ - expr.pointer = std::move(new_pointer); - return true; -} - -template <typename... Args, typename T, index_t Dims, size_t Key = 0> -KFR_INTRINSIC bool substitute(expression_with_arguments<Args...>& expr, - expression_pointer<T, Dims> new_pointer, csize_t<Key> = csize_t<Key>{}) -{ - return internal::substitute_helper(expr, std::move(new_pointer), csize_t<Key>{}, indicesfor_t<Args...>{}); -} - -template <typename T, index_t Dims, size_t Key = 0> -KFR_INTRINSIC bool substitute(expression_pointer<T, Dims>& expr, expression_pointer<T, Dims> new_pointer, - csize_t<Key> = csize_t<Key>{}) -{ - static_assert(Key == 0, "expression_pointer supports only Key = 0"); - return expr.substitute(std::move(new_pointer)); -} - -inline namespace CMT_ARCH_NAME -{ -namespace internal -{ - -template <typename... Args, typename T, index_t Dims, size_t Key, size_t... indices> -KFR_INTRINSIC bool substitute_helper(expression_with_arguments<Args...>& expr, - expression_pointer<T, Dims> new_pointer, csize_t<Key>, - csizes_t<indices...>) -{ - return (substitute(std::get<indices>(expr.args), std::move(new_pointer), csize_t<Key>()) || ...); -} - -template <typename Expression, typename T, index_t Dims, size_t Key> -KFR_INTRINSIC bool invoke_substitute(Expression& expr, expression_pointer<T, Dims> new_pointer, csize_t<Key>) -{ - return kfr::substitute(expr, std::move(new_pointer), csize_t<Key>{}); -} - -} // namespace internal - -} // namespace CMT_ARCH_NAME - -} // namespace kfr diff --git a/include/kfr/base/reduce.hpp b/include/kfr/base/reduce.hpp @@ -30,8 +30,8 @@ #include "../simd/min_max.hpp" #include "../simd/operators.hpp" #include "../simd/vec.hpp" -#include "simd_expressions.hpp" #include "basic_expressions.hpp" +#include "simd_expressions.hpp" namespace kfr { diff --git a/include/kfr/dft/convolution.hpp b/include/kfr/dft/convolution.hpp @@ -109,7 +109,7 @@ public: size_t input_block_size() const { return block_size; } protected: - void process_expression(T* dest, const expression_pointer<T>& src, size_t size) final + void process_expression(T* dest, const expression_handle<T>& src, size_t size) final { univector<T> input = truncate(src, size); process_buffer(dest, input.data(), input.size()); diff --git a/include/kfr/dsp/biquad.hpp b/include/kfr/dsp/biquad.hpp @@ -26,7 +26,7 @@ #pragma once #include "../base/filter.hpp" -#include "../base/pointer.hpp" +#include "../base/handle.hpp" #include "../simd/impl/function.hpp" #include "../simd/operators.hpp" #include "../simd/vec.hpp" @@ -305,7 +305,7 @@ KFR_FUNCTION expression_biquads<filters, T, E1> biquad(const biquad_params<T> (& * @note This implementation has zero latency */ template <size_t maxfiltercount = 4, typename T, typename E1> -KFR_FUNCTION expression_pointer<T, 1> biquad(const biquad_params<T>* bq, size_t count, E1&& e1) +KFR_FUNCTION expression_handle<T, 1> biquad(const biquad_params<T>* bq, size_t count, E1&& e1) { constexpr csizes_t<1, 2, 4, 8, 16, 32, 64> sizes; return cswitch( @@ -313,14 +313,14 @@ KFR_FUNCTION expression_pointer<T, 1> biquad(const biquad_params<T>* bq, size_t [&](auto x) { constexpr size_t filters = x; - return to_pointer(expression_biquads<filters, T, E1>(biquad_block<T, filters>(bq, count), - std::forward<E1>(e1))); + return to_handle(expression_biquads<filters, T, E1>(biquad_block<T, filters>(bq, count), + std::forward<E1>(e1))); }, - [&] { return to_pointer(fixshape(zeros<T>(), fixed_shape<infinite_size>)); }); + [&] { return to_handle(fixshape(zeros<T>(), fixed_shape<infinite_size>)); }); } template <size_t maxfiltercount = 4, typename T, typename E1> -KFR_FUNCTION expression_pointer<T, 1> biquad(const std::vector<biquad_params<T>>& bq, E1&& e1) +KFR_FUNCTION expression_handle<T, 1> biquad(const std::vector<biquad_params<T>>& bq, E1&& e1) { return biquad<maxfiltercount>(bq.data(), bq.size(), std::forward<E1>(e1)); } diff --git a/include/kfr/dsp/ebu.hpp b/include/kfr/dsp/ebu.hpp @@ -184,13 +184,13 @@ private: }; template <typename T> -KFR_INTRINSIC expression_pointer<T, 1> make_kfilter(int samplerate) +KFR_INTRINSIC expression_handle<T, 1> make_kfilter(int samplerate) { const biquad_params<T> bq[] = { biquad_highshelf(T(1681.81 / samplerate), T(+4.0)), biquad_highpass(T(38.1106678246655 / samplerate), T(0.5)).normalized_all() }; - return to_pointer(biquad(bq, placeholder<T>())); + return to_handle(biquad(bq, placeholder<T>())); } template <typename T> @@ -232,7 +232,7 @@ public: void process_packet(const T* src) { - substitute(m_kfilter, to_pointer(make_univector(src, m_packet_size) * m_input_gain)); + substitute(m_kfilter, to_handle(make_univector(src, m_packet_size) * m_input_gain)); const T filtered_sum_of_squares = sumsqr(truncate(m_kfilter, m_packet_size)); m_short_sum_of_squares.ringbuf_write(m_short_sum_of_squares_cursor, filtered_sum_of_squares); @@ -245,7 +245,7 @@ private: const Speaker m_speaker; const T m_input_gain; const size_t m_packet_size; - expression_pointer<T, 1> m_kfilter; + expression_handle<T, 1> m_kfilter; univector<T> m_short_sum_of_squares; univector<T> m_momentary_sum_of_squares; T m_output_energy_gain; diff --git a/include/kfr/dsp/fir.hpp b/include/kfr/dsp/fir.hpp @@ -298,7 +298,7 @@ protected: { make_univector(dest, size) = fir(state, make_univector(src, size)); } - void process_expression(U* dest, const expression_pointer<U, 1>& src, size_t size) final + void process_expression(U* dest, const expression_handle<U, 1>& src, size_t size) final { make_univector(dest, size) = fir(state, src); } diff --git a/include/kfr/dsp/fir_design.hpp b/include/kfr/dsp/fir_design.hpp @@ -36,7 +36,7 @@ inline namespace CMT_ARCH_NAME namespace internal { template <typename T> -void fir_lowpass(univector_ref<T> taps, T cutoff, const expression_pointer<T>& window, bool normalize = true) +void fir_lowpass(univector_ref<T> taps, T cutoff, const expression_handle<T>& window, bool normalize = true) { const T scale = 2.0 * cutoff; taps = bind_expression(fn::sinc(), symmlinspace<T>((taps.size() - 1) * cutoff * c_pi<T>, taps.size())) * @@ -52,11 +52,10 @@ void fir_lowpass(univector_ref<T> taps, T cutoff, const expression_pointer<T>& w } } template <typename T> -void fir_highpass(univector_ref<T> taps, T cutoff, const expression_pointer<T>& window, bool normalize = true) +void fir_highpass(univector_ref<T> taps, T cutoff, const expression_handle<T>& window, bool normalize = true) { const T scale = 2.0 * -cutoff; - taps = bind_expression(fn::sinc(), - symmlinspace<T>((taps.size() - 1) * cutoff * c_pi<T>, taps.size())) * + taps = bind_expression(fn::sinc(), symmlinspace<T>((taps.size() - 1) * cutoff * c_pi<T>, taps.size())) * scale * window; if (is_odd(taps.size())) @@ -70,7 +69,7 @@ void fir_highpass(univector_ref<T> taps, T cutoff, const expression_pointer<T>& } template <typename T> -void fir_bandpass(univector_ref<T> taps, T frequency1, T frequency2, const expression_pointer<T>& window, +void fir_bandpass(univector_ref<T> taps, T frequency1, T frequency2, const expression_handle<T>& window, bool normalize = true) { const T scale1 = 2.0 * frequency1; @@ -94,7 +93,7 @@ void fir_bandpass(univector_ref<T> taps, T frequency1, T frequency2, const expre } template <typename T> -void fir_bandstop(univector_ref<T> taps, T frequency1, T frequency2, const expression_pointer<T>& window, +void fir_bandstop(univector_ref<T> taps, T frequency1, T frequency2, const expression_handle<T>& window, bool normalize = true) { const T scale1 = 2.0 * frequency1; @@ -131,7 +130,7 @@ KFR_I_FN_FULL(fir_bandstop, internal::fir_bandstop) */ template <typename T, univector_tag Tag> KFR_INTRINSIC void fir_lowpass(univector<T, Tag>& taps, identity<T> cutoff, - const expression_pointer<T>& window, bool normalize = true) + const expression_handle<T>& window, bool normalize = true) { return internal::fir_lowpass(taps.slice(), cutoff, window, normalize); } @@ -145,7 +144,7 @@ KFR_INTRINSIC void fir_lowpass(univector<T, Tag>& taps, identity<T> cutoff, */ template <typename T, univector_tag Tag> KFR_INTRINSIC void fir_highpass(univector<T, Tag>& taps, identity<T> cutoff, - const expression_pointer<T>& window, bool normalize = true) + const expression_handle<T>& window, bool normalize = true) { return internal::fir_highpass(taps.slice(), cutoff, window, normalize); } @@ -160,7 +159,7 @@ KFR_INTRINSIC void fir_highpass(univector<T, Tag>& taps, identity<T> cutoff, */ template <typename T, univector_tag Tag> KFR_INTRINSIC void fir_bandpass(univector<T, Tag>& taps, identity<T> frequency1, identity<T> frequency2, - const expression_pointer<T>& window, bool normalize = true) + const expression_handle<T>& window, bool normalize = true) { return internal::fir_bandpass(taps.slice(), frequency1, frequency2, window, normalize); } @@ -175,7 +174,7 @@ KFR_INTRINSIC void fir_bandpass(univector<T, Tag>& taps, identity<T> frequency1, */ template <typename T, univector_tag Tag> KFR_INTRINSIC void fir_bandstop(univector<T, Tag>& taps, identity<T> frequency1, identity<T> frequency2, - const expression_pointer<T>& window, bool normalize = true) + const expression_handle<T>& window, bool normalize = true) { return internal::fir_bandstop(taps.slice(), frequency1, frequency2, window, normalize); } @@ -185,7 +184,7 @@ KFR_INTRINSIC void fir_bandstop(univector<T, Tag>& taps, identity<T> frequency1, */ template <typename T> KFR_INTRINSIC void fir_lowpass(const univector_ref<T>& taps, identity<T> cutoff, - const expression_pointer<T>& window, bool normalize = true) + const expression_handle<T>& window, bool normalize = true) { return internal::fir_lowpass(taps, cutoff, window, normalize); } @@ -195,7 +194,7 @@ KFR_INTRINSIC void fir_lowpass(const univector_ref<T>& taps, identity<T> cutoff, */ template <typename T> KFR_INTRINSIC void fir_highpass(const univector_ref<T>& taps, identity<T> cutoff, - const expression_pointer<T>& window, bool normalize = true) + const expression_handle<T>& window, bool normalize = true) { return internal::fir_highpass(taps, cutoff, window, normalize); } @@ -205,7 +204,7 @@ KFR_INTRINSIC void fir_highpass(const univector_ref<T>& taps, identity<T> cutoff */ template <typename T> KFR_INTRINSIC void fir_bandpass(const univector_ref<T>& taps, identity<T> frequency1, identity<T> frequency2, - const expression_pointer<T>& window, bool normalize = true) + const expression_handle<T>& window, bool normalize = true) { return internal::fir_bandpass(taps, frequency1, frequency2, window, normalize); } @@ -215,7 +214,7 @@ KFR_INTRINSIC void fir_bandpass(const univector_ref<T>& taps, identity<T> freque */ template <typename T> KFR_INTRINSIC void fir_bandstop(const univector_ref<T>& taps, identity<T> frequency1, identity<T> frequency2, - const expression_pointer<T>& window, bool normalize = true) + const expression_handle<T>& window, bool normalize = true) { return internal::fir_bandstop(taps, frequency1, frequency2, window, normalize); } diff --git a/include/kfr/dsp/iir_design.hpp b/include/kfr/dsp/iir_design.hpp @@ -26,7 +26,7 @@ #pragma once #include "../base/filter.hpp" -#include "../base/pointer.hpp" +#include "../base/handle.hpp" #include "../math/hyperbolic.hpp" #include "../simd/complex.hpp" #include "../simd/impl/function.hpp" diff --git a/include/kfr/dsp/window.hpp b/include/kfr/dsp/window.hpp @@ -25,7 +25,7 @@ */ #pragma once -#include "../base/pointer.hpp" +#include "../base/handle.hpp" #include "../math/log_exp.hpp" #include "../math/modzerobessel.hpp" #include "../math/sin_cos.hpp" @@ -562,9 +562,9 @@ CMT_NOINLINE window_expr window(size_t size, cval_t<window_type, type>, identity } template <typename T = fbase> -CMT_NOINLINE expression_pointer<T> window(size_t size, window_type type, identity<T> win_param, - window_symmetry symmetry = window_symmetry::symmetric, - ctype_t<T> = ctype_t<T>()) +CMT_NOINLINE expression_handle<T> window(size_t size, window_type type, identity<T> win_param, + window_symmetry symmetry = window_symmetry::symmetric, + ctype_t<T> = ctype_t<T>()) { return cswitch( cvals_t<window_type, window_type::rectangular, window_type::triangular, window_type::bartlett, @@ -575,9 +575,9 @@ CMT_NOINLINE expression_pointer<T> window(size_t size, window_type type, identit [size, win_param, symmetry](auto win) { constexpr window_type window = val_of(decltype(win)()); - return to_pointer(typename window_by_type<window>::template type<T>(size, win_param, symmetry)); + return to_handle(typename window_by_type<window>::template type<T>(size, win_param, symmetry)); }, - fn_generic::returns<expression_pointer<T>>()); + fn_generic::returns<expression_handle<T>>()); } } // namespace CMT_ARCH_NAME } // namespace kfr diff --git a/include/kfr/simd/impl/function.hpp b/include/kfr/simd/impl/function.hpp @@ -38,7 +38,7 @@ inline namespace CMT_ARCH_NAME template <typename T, size_t N, KFR_ENABLE_IF(!is_f_class<T>)> \ KFR_INTRINSIC vec<flt_type<T>, N> fn(const vec<T, N>& a) CMT_NOEXCEPT \ { \ - return intrinsics::fn(promoteto<flt_type<T>>(a)); \ + return intrinsics::fn(promoteto<flt_type<T>>(a)); \ } #define KFR_HANDLE_SCALAR(fn) \ diff --git a/include/kfr/simd/impl/operators.hpp b/include/kfr/simd/impl/operators.hpp @@ -54,31 +54,31 @@ namespace intrinsics KFR_ENABLE_IF(is_simd_type<C>)> \ KFR_INTRINSIC vec<vec<C, N1>, N2> fn(const vec<vec<T1, N1>, N2>& x, const vec<vec<T2, N1>, N2>& y) \ { \ - return fn(broadcastto<C>(x.flatten()), broadcastto<C>(y.flatten())).v; \ + return fn(broadcastto<C>(x.flatten()), broadcastto<C>(y.flatten())).v; \ } \ template <typename T1, typename T2, size_t N1, size_t N2, typename C = common_type<T1, T2>, \ KFR_ENABLE_IF(is_simd_type<C>)> \ KFR_INTRINSIC vec<vec<C, N1>, N2> fn(const vec<vec<T1, N1>, N2>& x, const T2& y) \ { \ - return fn(broadcastto<C>(x.flatten()), broadcastto<C>(y)).v; \ + return fn(broadcastto<C>(x.flatten()), broadcastto<C>(y)).v; \ } \ template <typename T1, typename T2, size_t N1, size_t N2, typename C = common_type<T1, T2>, \ KFR_ENABLE_IF(is_simd_type<C>)> \ KFR_INTRINSIC vec<vec<C, N1>, N2> fn(const vec<vec<T1, N1>, N2>& x, const vec<T2, N1>& y) \ { \ - return fn(broadcastto<C>(x.flatten()), repeat<N2>(broadcastto<C>(y.flatten()))).v; \ + return fn(broadcastto<C>(x.flatten()), repeat<N2>(broadcastto<C>(y.flatten()))).v; \ } \ template <typename T1, typename T2, size_t N1, size_t N2, typename C = common_type<T1, T2>, \ KFR_ENABLE_IF(is_simd_type<C>)> \ KFR_INTRINSIC vec<vec<C, N1>, N2> fn(const T1& x, const vec<vec<T2, N1>, N2>& y) \ { \ - return fn(broadcastto<C>(x), broadcastto<C>(y.flatten())).v; \ + return fn(broadcastto<C>(x), broadcastto<C>(y.flatten())).v; \ } \ template <typename T1, typename T2, size_t N1, size_t N2, typename C = common_type<T1, T2>, \ KFR_ENABLE_IF(is_simd_type<C>)> \ KFR_INTRINSIC vec<vec<C, N1>, N2> fn(const vec<T1, N1>& x, const vec<vec<T2, N1>, N2>& y) \ { \ - return fn(repeat<N2>(broadcastto<C>(x.flatten())), broadcastto<C>(y.flatten())).v; \ + return fn(repeat<N2>(broadcastto<C>(x.flatten())), broadcastto<C>(y.flatten())).v; \ } KFR_VECVEC_OP1(neg) diff --git a/sources.cmake b/sources.cmake @@ -26,9 +26,9 @@ set( ${PROJECT_SOURCE_DIR}/include/kfr/base/filter.hpp ${PROJECT_SOURCE_DIR}/include/kfr/base/fraction.hpp ${PROJECT_SOURCE_DIR}/include/kfr/base/generators.hpp + ${PROJECT_SOURCE_DIR}/include/kfr/base/handle.hpp ${PROJECT_SOURCE_DIR}/include/kfr/base/math_expressions.hpp ${PROJECT_SOURCE_DIR}/include/kfr/base/memory.hpp - ${PROJECT_SOURCE_DIR}/include/kfr/base/pointer.hpp ${PROJECT_SOURCE_DIR}/include/kfr/base/random.hpp ${PROJECT_SOURCE_DIR}/include/kfr/base/random_bits.hpp ${PROJECT_SOURCE_DIR}/include/kfr/base/reduce.hpp @@ -244,9 +244,9 @@ set( ${PROJECT_SOURCE_DIR}/include/kfr/base/filter.hpp ${PROJECT_SOURCE_DIR}/include/kfr/base/fraction.hpp ${PROJECT_SOURCE_DIR}/include/kfr/base/generators.hpp + ${PROJECT_SOURCE_DIR}/include/kfr/base/handle.hpp ${PROJECT_SOURCE_DIR}/include/kfr/base/math_expressions.hpp ${PROJECT_SOURCE_DIR}/include/kfr/base/memory.hpp - ${PROJECT_SOURCE_DIR}/include/kfr/base/pointer.hpp ${PROJECT_SOURCE_DIR}/include/kfr/base/random.hpp ${PROJECT_SOURCE_DIR}/include/kfr/base/random_bits.hpp ${PROJECT_SOURCE_DIR}/include/kfr/base/reduce.hpp @@ -335,9 +335,9 @@ set( ${PROJECT_SOURCE_DIR}/include/kfr/base/filter.hpp ${PROJECT_SOURCE_DIR}/include/kfr/base/fraction.hpp ${PROJECT_SOURCE_DIR}/include/kfr/base/generators.hpp + ${PROJECT_SOURCE_DIR}/include/kfr/base/handle.hpp ${PROJECT_SOURCE_DIR}/include/kfr/base/math_expressions.hpp ${PROJECT_SOURCE_DIR}/include/kfr/base/memory.hpp - ${PROJECT_SOURCE_DIR}/include/kfr/base/pointer.hpp ${PROJECT_SOURCE_DIR}/include/kfr/base/random.hpp ${PROJECT_SOURCE_DIR}/include/kfr/base/random_bits.hpp ${PROJECT_SOURCE_DIR}/include/kfr/base/reduce.hpp @@ -496,7 +496,7 @@ set( ${PROJECT_SOURCE_DIR}/tests/unit/base/conversion.cpp ${PROJECT_SOURCE_DIR}/tests/unit/base/fraction.cpp ${PROJECT_SOURCE_DIR}/tests/unit/base/generators.cpp - ${PROJECT_SOURCE_DIR}/tests/unit/base/pointer.cpp + ${PROJECT_SOURCE_DIR}/tests/unit/base/handle.cpp ${PROJECT_SOURCE_DIR}/tests/unit/base/random.cpp ${PROJECT_SOURCE_DIR}/tests/unit/base/reduce.cpp ${PROJECT_SOURCE_DIR}/tests/unit/base/shape.cpp diff --git a/tests/dsp_test.cpp b/tests/dsp_test.cpp @@ -77,7 +77,7 @@ TEST(phasor) template <typename E, typename T, size_t size> void test_ir(E&& e, const univector<T, size>& test_vector) { - substitute(e, to_pointer(unitimpulse<T>())); + substitute(e, to_handle(unitimpulse<T>())); const univector<T, size> ir = e; println(absmaxof(ir - test_vector)); } diff --git a/tests/unit/base/basic_expressions.cpp b/tests/unit/base/basic_expressions.cpp @@ -133,10 +133,7 @@ TEST(assign_expression) CHECK_EXPRESSION(b, { 1000, 1010, 1020, 1030, 1040, 1050, 1060, 1070, 1080, 1090 }); } -TEST(trace) -{ - render(trace(counter()), 44); -} +TEST(trace) { render(trace(counter()), 44); } } // namespace CMT_ARCH_NAME } // namespace kfr diff --git a/tests/unit/base/handle.cpp b/tests/unit/base/handle.cpp @@ -0,0 +1,57 @@ +/** + * KFR (http://kfrlib.com) + * Copyright (C) 2016-2022 Fractalium Ltd + * See LICENSE.txt for details + */ + +#include <kfr/base/generators.hpp> +#include <kfr/base/handle.hpp> +#include <kfr/base/simd_expressions.hpp> +#include <kfr/base/univector.hpp> +#include <kfr/io/tostring.hpp> + +namespace kfr +{ +inline namespace CMT_ARCH_NAME +{ +TEST(to_handle) +{ + auto e1 = to_handle(counter<float>()); + + CHECK_EXPRESSION(e1, infinite_size, [](size_t i) { return static_cast<float>(i); }); + + auto e2 = to_handle(gen_linear(0.f, 1.f)); + + CHECK_EXPRESSION(e2, infinite_size, [](size_t i) { return static_cast<float>(i); }); +} + +TEST(test_arg_replace) +{ + univector<float, 10> v1 = counter(); + univector<float, 10> v2 = -counter(); + auto e1 = to_handle(v1) * 10; + std::get<0>(e1.args) = to_handle(v2); + + CHECK_EXPRESSION(e1, 10, [](size_t i) { return i * -10.0; }); +} + +TEST(placeholders) +{ + auto expr1 = placeholder<float>(); + CHECK_EXPRESSION(expr1, infinite_size, [](size_t) { return 0.f; }); + auto expr2 = 100 * placeholder<float>(); + CHECK_EXPRESSION(expr2, infinite_size, [](size_t) { return 0.f; }); + substitute(expr2, to_handle(counter<float>())); + CHECK_EXPRESSION(expr2, infinite_size, [](size_t i) { return 100.f * i; }); +} + +TEST(placeholders_handle) +{ + expression_handle<float> expr = to_handle(10 * placeholder<float>()); + CHECK_EXPRESSION(expr, infinite_size, [](size_t) { return 0.f; }); + substitute(expr, to_handle(counter<float>())); + CHECK_EXPRESSION(expr, infinite_size, [](size_t i) { return 10.f * i; }); +} + +} // namespace CMT_ARCH_NAME +} // namespace kfr diff --git a/tests/unit/base/pointer.cpp b/tests/unit/base/pointer.cpp @@ -1,57 +0,0 @@ -/** - * KFR (http://kfrlib.com) - * Copyright (C) 2016-2022 Fractalium Ltd - * See LICENSE.txt for details - */ - -#include <kfr/base/pointer.hpp> -#include <kfr/base/simd_expressions.hpp> -#include <kfr/base/univector.hpp> -#include <kfr/base/generators.hpp> -#include <kfr/io/tostring.hpp> - -namespace kfr -{ -inline namespace CMT_ARCH_NAME -{ -TEST(to_pointer) -{ - auto e1 = to_pointer(counter<float>()); - - CHECK_EXPRESSION(e1, infinite_size, [](size_t i) { return static_cast<float>(i); }); - - auto e2 = to_pointer(gen_linear(0.f, 1.f)); - - CHECK_EXPRESSION(e2, infinite_size, [](size_t i) { return static_cast<float>(i); }); -} - -TEST(test_arg_replace) -{ - univector<float, 10> v1 = counter(); - univector<float, 10> v2 = -counter(); - auto e1 = to_pointer(v1) * 10; - std::get<0>(e1.args) = to_pointer(v2); - - CHECK_EXPRESSION(e1, 10, [](size_t i) { return i * -10.0; }); -} - -TEST(placeholders) -{ - auto expr1 = placeholder<float>(); - CHECK_EXPRESSION(expr1, infinite_size, [](size_t) { return 0.f; }); - auto expr2 = 100 * placeholder<float>(); - CHECK_EXPRESSION(expr2, infinite_size, [](size_t) { return 0.f; }); - substitute(expr2, to_pointer(counter<float>())); - CHECK_EXPRESSION(expr2, infinite_size, [](size_t i) { return 100.f * i; }); -} - -TEST(placeholders_pointer) -{ - expression_pointer<float> expr = to_pointer(10 * placeholder<float>()); - CHECK_EXPRESSION(expr, infinite_size, [](size_t) { return 0.f; }); - substitute(expr, to_pointer(counter<float>())); - CHECK_EXPRESSION(expr, infinite_size, [](size_t i) { return 10.f * i; }); -} - -} // namespace CMT_ARCH_NAME -} // namespace kfr diff --git a/tests/unit/base/shape.cpp b/tests/unit/base/shape.cpp @@ -52,7 +52,7 @@ TEST(shape_broadcast) CHECK(common_shape(shape{}, shape{ 0 }) == shape{ 0 }); CHECK(common_shape(shape{}, shape{ 0, 0 }) == shape{ 0, 0 }); CHECK(common_shape(shape{ 0 }, shape{ 0, 0 }) == shape{ 0, 0 }); - + CHECK(common_shape<true>(shape{}, shape{ 0 }) == shape{ 0 }); CHECK(common_shape<true>(shape{}, shape{ 0, 0 }) == shape{ 0, 0 }); CHECK(common_shape<true>(shape{ 0 }, shape{ 0, 0 }) == shape{ 0, 0 });