inplace_assignable.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 "etl/impl/transpose.hpp"
#include "etl/impl/fft.hpp"

namespace etl {

template <typename D>
struct inplace_assignable {
    using derived_t = D; 

    derived_t& as_derived() noexcept {
        return *static_cast<derived_t*>(this);
    }

    template <typename E>
    derived_t& scale_inplace(E&& e) {
        as_derived() *= e;

        return as_derived();
    }

    derived_t& fflip_inplace() requires(mat_or_vec<derived_t>) {
        if constexpr (is_2d<derived_t>) {
            as_derived().ensure_cpu_up_to_date();

            std::reverse(as_derived().begin(), as_derived().end());
        }

        return as_derived();
    }

    derived_t& deep_fflip_inplace() {
        decltype(auto) mat = as_derived();

        if constexpr (is_3d<D>) {
            for (size_t i = 0; i < etl::dim<0>(mat); ++i) {
                mat(i).fflip_inplace();
            }
        } else {
            for (size_t i = 0; i < etl::dim<0>(mat); ++i) {
                mat(i).deep_fflip_inplace();
            }
        }

        return mat;
    }

    derived_t& deep_transpose_inplace() {
        decltype(auto) mat = as_derived();

        if constexpr (is_dyn_matrix<derived_t>) {
            if constexpr (is_3d<derived_t>) {
                for (size_t i = 0; i < etl::dim<0>(mat); ++i) {
                    mat(i).direct_transpose_inplace();
                }
            } else {
                for (size_t i = 0; i < etl::dim<0>(mat); ++i) {
                    mat(i).direct_deep_transpose_inplace();
                }
            }

            static constexpr size_t d = etl_traits<derived_t>::dimensions();

            using std::swap;
            swap(mat.unsafe_dimension_access(d - 1), mat.unsafe_dimension_access(d - 2));
        } else {
            if constexpr (is_3d<derived_t>) {
                for (size_t i = 0; i < etl::dim<0>(mat); ++i) {
                    mat(i).transpose_inplace();
                }
            } else {
                for (size_t i = 0; i < etl::dim<0>(mat); ++i) {
                    mat(i).deep_transpose_inplace();
                }
            }
        }

        return mat;
    }

    derived_t& direct_deep_transpose_inplace() {
        decltype(auto) mat = as_derived();

        if constexpr (is_3d<derived_t>) {
            for (size_t i = 0; i < etl::dim<0>(mat); ++i) {
                mat(i).direct_transpose_inplace();
            }
        } else {
            for (size_t i = 0; i < etl::dim<0>(mat); ++i) {
                mat(i).direct_deep_transpose_inplace();
            }
        }

        return mat;
    }

    derived_t& transpose_inplace() requires(etl_2d<derived_t>) {
        decltype(auto) mat = as_derived();

        if constexpr (is_dyn_matrix<derived_t>) {
            if (etl::dim<0>(mat) == etl::dim<1>(mat)) {
                detail::inplace_square_transpose::apply(mat);
            } else {
                detail::inplace_rectangular_transpose::apply(mat);

                using std::swap;
                swap(mat.unsafe_dimension_access(0), mat.unsafe_dimension_access(1));
            }
        } else {
            cpp_assert(etl::dim<0>(mat) == etl::dim<1>(mat), "Only square fast matrices can be tranposed inplace");

            detail::inplace_square_transpose::apply(mat);
        }

        return mat;
    }

    derived_t& direct_transpose_inplace() requires(etl_2d<derived_t>) {
        decltype(auto) mat = as_derived();

        if (etl::dim<0>(mat) == etl::dim<1>(mat)) {
            detail::inplace_square_transpose::apply(mat);
        } else {
            detail::inplace_rectangular_transpose::apply(mat);
        }

        return mat;
    }

    derived_t& fft_inplace() requires(etl_1d<derived_t> && etl_complex_expr<derived_t>) {
        decltype(auto) mat = as_derived();

        detail::inplace_fft1_impl::apply(mat);

        return mat;
    }

    derived_t& fft_many_inplace() requires(matrix<derived_t> && etl_complex_expr<derived_t>) {
        decltype(auto) mat = as_derived();

        detail::inplace_fft1_many_impl::apply(mat);

        return mat;
    }

    derived_t& ifft_inplace() requires(etl_1d<derived_t> && etl_complex_expr<derived_t>) {
        decltype(auto) mat = as_derived();

        detail::inplace_ifft1_impl::apply(mat);

        return mat;
    }

    derived_t& ifft_many_inplace() requires(matrix<derived_t> && etl_complex_expr<derived_t>) {
        decltype(auto) mat = as_derived();

        detail::inplace_ifft1_many_impl::apply(mat);

        return mat;
    }

    derived_t& fft2_inplace() requires(etl_2d<derived_t> && etl_complex_expr<derived_t>) {
        decltype(auto) mat = as_derived();

        detail::inplace_fft2_impl::apply(mat);

        return mat;
    }

    derived_t& fft2_many_inplace() requires(deep_mat<derived_t> && etl_complex_expr<derived_t>) {
        decltype(auto) mat = as_derived();

        detail::inplace_fft2_many_impl::apply(mat);

        return mat;
    }

    derived_t& ifft2_inplace() requires(etl_2d<derived_t> && etl_complex_expr<derived_t>) {
        decltype(auto) mat = as_derived();

        detail::inplace_ifft2_impl::apply(mat);

        return mat;
    }

    derived_t& ifft2_many_inplace() requires(deep_mat<derived_t> && etl_complex_expr<derived_t>) {
        decltype(auto) mat = as_derived();

        detail::inplace_ifft2_many_impl::apply(mat);

        return mat;
    }
};

} //end of namespace etl