checks.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

namespace etl {

template <typename LE, typename RE>
void validate_expression_impl([[maybe_unused]] const LE& lhs, [[maybe_unused]] const RE& rhs) noexcept {
    if constexpr (etl_traits<LE>::is_generator || etl_traits<RE>::is_generator) {
        // Nothing to test, generators are of infinite size
    } else if constexpr (all_etl_expr<LE, RE> && !all_fast<LE, RE>) {
        cpp_assert(etl::size(lhs) == etl::size(rhs), "Cannot perform element-wise operations on collections of different size");
    } else {
        static_assert(etl_traits<LE>::size() == etl_traits<RE>::size(), "Cannot perform element-wise operations on collections of different size");
    }
}

// In relaxed mode, the expressions are only validated when assigned
// This allows for batch_hint to works

#ifdef ETL_RELAXED
#define validate_expression(lhs, rhs) static_assert(all_etl_expr<decltype(lhs), decltype(rhs)>, "ETL functions are only made for ETL expressions ")
#else
#define validate_expression(lhs, rhs)                                                                              \
    static_assert(all_etl_expr<decltype(lhs), decltype(rhs)>, "ETL functions are only made for ETL expressions "); \
    validate_expression_impl(lhs, rhs)
#endif

template <etl_expr LE, typename RE>
void validate_assign([[maybe_unused]] const LE& lhs, [[maybe_unused]] const RE& rhs) {
    if constexpr (etl_traits<RE>::is_generator) {
        // Nothing to test, generators are of infinite size
    } else if constexpr (is_etl_expr<RE> && all_fast<LE, RE> && !is_wrapper_expr<RE>) {
        static_assert(etl_traits<LE>::size() == etl_traits<RE>::size(), "Cannot perform element-wise operations on collections of different size");
    } else if constexpr (!is_etl_expr<RE> && !is_wrapper_expr<RE>) {
        cpp_assert(etl::size(lhs) == rhs.size(), "Cannot perform element-wise operations on collections of different size");
    } else {
        cpp_assert(etl::size(lhs) == etl::size(rhs), "Cannot perform element-wise operations on collections of different size");
    }
}

template <etl_2d E>
void assert_square([[maybe_unused]] E&& expr) {
    if constexpr (is_fast<E>) {
        static_assert(decay_traits<E>::template dim<0>() == decay_traits<E>::template dim<1>(), "Function undefined for non-square matrix");
    } else {
        cpp_assert(etl::dim<0>(expr) == etl::dim<1>(expr), "Function undefined for non-square matrix");
    }
}

namespace detail {

template <size_t C1, size_t C2, dyn_2d E>
void validate_pmax_pooling_impl([[maybe_unused]] const E& e) {
    cpp_assert(etl::template dim<0>(e) % C1 == 0 && etl::template dim<1>(e) % C2 == 0, "Dimensions not divisible by the pooling ratio");
}

template <size_t C1, size_t C2, dyn_3d E>
void validate_pmax_pooling_impl([[maybe_unused]] const E& e) {
    cpp_assert(etl::template dim<1>(e) % C1 == 0 && etl::template dim<2>(e) % C2 == 0, "Dimensions not divisible by the pooling ratio");
}

template <size_t C1, size_t C2, dyn_4d E>
void validate_pmax_pooling_impl([[maybe_unused]] const E& e) {
    cpp_assert(etl::template dim<2>(e) % C1 == 0 && etl::template dim<3>(e) % C2 == 0, "Dimensions not divisible by the pooling ratio");
}

template <size_t C1, size_t C2, fast_2d E>
void validate_pmax_pooling_impl(const E& /*unused*/) {
    static_assert(etl_traits<E>::template dim<0>() % C1 == 0 && etl_traits<E>::template dim<1>() % C2 == 0, "Dimensions not divisible by the pooling ratio");
}

template <size_t C1, size_t C2, fast_3d E>
void validate_pmax_pooling_impl(const E& /*unused*/) {
    static_assert(etl_traits<E>::template dim<1>() % C1 == 0 && etl_traits<E>::template dim<2>() % C2 == 0, "Dimensions not divisible by the pooling ratio");
}

template <size_t C1, size_t C2, fast_4d E>
void validate_pmax_pooling_impl(const E& /*unused*/) {
    static_assert(etl_traits<E>::template dim<2>() % C1 == 0 && etl_traits<E>::template dim<3>() % C2 == 0, "Dimensions not divisible by the pooling ratio");
}

template <etl_2d E>
void validate_pmax_pooling_impl([[maybe_unused]] const E& e, [[maybe_unused]] size_t c1, [[maybe_unused]] size_t c2) {
    cpp_assert(etl::template dim<0>(e) % c1 == 0 && etl::template dim<1>(e) % c2 == 0, "Dimensions not divisible by the pooling ratio");
}

template <etl_3d E>
void validate_pmax_pooling_impl([[maybe_unused]] const E& e, [[maybe_unused]] size_t c1, [[maybe_unused]] size_t c2) {
    cpp_assert(etl::template dim<1>(e) % c1 == 0 && etl::template dim<2>(e) % c2 == 0, "Dimensions not divisible by the pooling ratio");
}

template <etl_4d E>
void validate_pmax_pooling_impl([[maybe_unused]] const E& e, [[maybe_unused]] size_t c1, [[maybe_unused]] size_t c2) {
    cpp_assert(etl::template dim<2>(e) % c1 == 0 && etl::template dim<3>(e) % c2 == 0, "Dimensions not divisible by the pooling ratio");
}

} //end of namespace detail

template <size_t C1, size_t C2, dimensions_between<2, 4> E>
void validate_pmax_pooling(const E& expr) {
    detail::validate_pmax_pooling_impl<C1, C2>(expr);
}

template <dimensions_between<2, 4> E>
void validate_pmax_pooling(const E& expr, size_t c1, size_t c2) {
    detail::validate_pmax_pooling_impl(expr, c1, c2);
}

} //end of namespace etl