expression_builder.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 implementations
#include "etl/impl/dot.hpp"
#include "etl/impl/sum.hpp"
#include "etl/impl/norm.hpp"

#include "etl/builder/binary_expression_builder.hpp"
#include "etl/builder/wrapper_expression_builder.hpp"
#include "etl/builder/view_expression_builder.hpp"

namespace etl {

// Apply an unary expression on an ETL expression (vector,matrix,binary,unary)

template <typename E>
auto operator-(E&& value) {
    return detail::unary_helper<E, minus_unary_op>{std::forward<E>(value)};
}

template <typename E>
auto operator+(E&& value) {
    return detail::unary_helper<E, plus_unary_op>{std::forward<E>(value)};
}

template <etl_expr E>
auto abs(E&& value) {
    return detail::unary_helper<E, abs_unary_op>{std::forward<E>(value)};
}

template <etl_expr L, typename R>
auto max(L&& lhs, R&& rhs) {
    using return_type = detail::left_binary_helper_op_scalar<L, R, max_binary_op<detail::wrap_scalar_value_t<L>, detail::wrap_scalar_value_t<L>>>;
    return return_type{detail::wrap_scalar(lhs), detail::smart_wrap_scalar<L>(rhs)};
}

template <etl_expr L, typename R>
auto min(L&& lhs, R&& rhs) {
    using return_type = detail::left_binary_helper_op_scalar<L, R, min_binary_op<detail::wrap_scalar_value_t<L>, detail::wrap_scalar_value_t<L>>>;   
    return return_type{detail::wrap_scalar(lhs), detail::smart_wrap_scalar<L>(rhs)};
}

template <etl_expr E>
auto floor(E&& value) {
    return detail::unary_helper<E, floor_unary_op>{std::forward<E>(value)};
}

template <etl_expr E>
auto ceil(E&& value) {
    return detail::unary_helper<E, ceil_unary_op>{std::forward<E>(value)};
}

template <etl_expr E, arithmetic T>
auto clip(E&& value, T min, T max) {
    return detail::make_stateful_unary_expr<E, clip_scalar_op<value_t<E>, value_t<E>>>(std::forward<E>(value), value_t<E>(min), value_t<E>(max));
}

template <etl_expr E, arithmetic T>
auto pow(E&& value, T v) {
    return detail::left_binary_helper_op<E, scalar<value_t<E>>, pow_binary_op<value_t<E>, value_t<E>>>{std::forward<E>(value), scalar<value_t<E>>(v)};
}

template <etl_expr E>
auto pow_int(E&& value, size_t v) {
    return detail::left_binary_helper_op<E, scalar<size_t>, integer_pow_binary_op<value_t<E>, size_t>>{std::forward<E>(value), scalar<size_t>(v)};
}

template <etl_expr E, arithmetic T>
auto pow_precise(E&& value, T v) {
    return detail::left_binary_helper_op<E, scalar<value_t<E>>, precise_pow_binary_op<value_t<E>, value_t<E>>>{std::forward<E>(value), scalar<value_t<E>>(v)};
}

template <etl_expr E, arithmetic T>
auto one_if(E&& value, T v) {
    return detail::left_binary_helper_op<E, scalar<value_t<E>>, one_if_binary_op<value_t<E>, value_t<E>>>{std::forward<E>(value), scalar<value_t<E>>(v)};
}

template <etl_expr E>
auto one_if_max(E&& value) {
    return detail::left_binary_helper_op<E, scalar<value_t<E>>, one_if_binary_op<value_t<E>, value_t<E>>>{value, scalar<value_t<E>>(max(value))};
}

template <etl_complex_expr E>
auto real(E&& value) {
    return unary_expr<typename value_t<E>::value_type, detail::build_type<E>, real_unary_op<value_t<E>>>{std::forward<E>(value)};
}

template <etl_complex_expr E>
auto imag(E&& value) {
    return unary_expr<typename value_t<E>::value_type, detail::build_type<E>, imag_unary_op<value_t<E>>>{std::forward<E>(value)};
}

template <etl_complex_expr E>
auto conj(E&& value) {
    return unary_expr<value_t<E>, detail::build_type<E>, conj_unary_op<value_t<E>>>{std::forward<E>(value)};
}

template <etl_expr E>
auto uniform_noise(E&& value) {
    return detail::unary_helper<E, uniform_noise_unary_op>{std::forward<E>(value)};
}

template <etl_expr E, typename G>
auto uniform_noise(G& g, E&& value) {
    return detail::make_stateful_unary_expr<E, uniform_noise_unary_g_op<G, value_t<E>>>(std::forward<E>(value), g);
}

template <etl_expr E>
auto normal_noise(E&& value) {
    return detail::unary_helper<E, normal_noise_unary_op>{std::forward<E>(value)};
}

template <etl_expr E, typename G>
auto normal_noise(G& g, E&& value) {
    return detail::make_stateful_unary_expr<E, normal_noise_unary_g_op<G, value_t<E>>>(std::forward<E>(value), g);
}

template <etl_expr E>
auto logistic_noise(E&& value) {
    return detail::unary_helper<E, logistic_noise_unary_op>{std::forward<E>(value)};
}

template <etl_expr E, typename G>
auto logistic_noise(G& g, E&& value) {
    return detail::make_stateful_unary_expr<E, logistic_noise_unary_g_op<G, value_t<E>>>(std::forward<E>(value), g);
}

template <etl_expr E>
auto state_logistic_noise(E&& value) {
    return detail::make_stateful_unary_expr<E, state_logistic_noise_unary_op<value_t<E>>>(std::forward<E>(value));
}

template <etl_expr E>
auto state_logistic_noise(E&& value, const std::shared_ptr<void*> & states) {
    return detail::make_stateful_unary_expr<E, state_logistic_noise_unary_op<value_t<E>>>(std::forward<E>(value), states);
}

template <typename G, etl_expr E>
auto state_logistic_noise(G& g, E&& value) {
    return detail::make_stateful_unary_expr<E, state_logistic_noise_unary_g_op<G, value_t<E>>>(std::forward<E>(value), g);
}

template <etl_expr E, typename G>
auto state_logistic_noise(G& g, E&& value, const std::shared_ptr<void*> & states) {
    return detail::make_stateful_unary_expr<E, state_logistic_noise_unary_g_op<G, value_t<E>>>(std::forward<E>(value), g, states);
}

template <etl_expr E, arithmetic T>
auto ranged_noise(E&& value, T v) {
    return detail::left_binary_helper_op<E, scalar<value_t<E>>, ranged_noise_binary_op<value_t<E>, value_t<E>>>{std::forward<E>(value), scalar<value_t<E>>(v)};
}

// Apply a stable transformation

template <size_t D1, size_t... D, etl_expr E>
auto rep(E&& value) {
    return unary_expr<value_t<E>, rep_r_transformer<detail::build_type<E>, D1, D...>, transform_op>{rep_r_transformer<detail::build_type<E>, D1, D...>(std::forward<E>(value))};
}

template <size_t D1, size_t... D, etl_expr E>
auto rep_r(E&& value) {
    return unary_expr<value_t<E>, rep_r_transformer<detail::build_type<E>, D1, D...>, transform_op>{rep_r_transformer<detail::build_type<E>, D1, D...>(std::forward<E>(value))};
}

template <size_t D1, size_t... D, etl_expr E>
auto rep_l(E&& value) {
    return unary_expr<value_t<E>, rep_l_transformer<detail::build_type<E>, D1, D...>, transform_op>{rep_l_transformer<detail::build_type<E>, D1, D...>(std::forward<E>(value))};
}

template <typename... D, etl_expr E>
auto rep(E&& value, size_t d1, D... d) {
    return unary_expr<value_t<E>, dyn_rep_r_transformer<detail::build_type<E>, 1 + sizeof...(D)>, transform_op>{
        dyn_rep_r_transformer<detail::build_type<E>, 1 + sizeof...(D)>(std::forward<E>(value), {{d1, static_cast<size_t>(d)...}})};
}

template <typename... D, etl_expr E>
auto rep_r(E&& value, size_t d1, D... d) {
    return unary_expr<value_t<E>, dyn_rep_r_transformer<detail::build_type<E>, 1 + sizeof...(D)>, transform_op>{
        dyn_rep_r_transformer<detail::build_type<E>, 1 + sizeof...(D)>(std::forward<E>(value), {{d1, static_cast<size_t>(d)...}})};
}

template <typename... D, etl_expr E>
auto rep_l(E&& value, size_t d1, D... d) {
    return unary_expr<value_t<E>, dyn_rep_l_transformer<detail::build_type<E>, 1 + sizeof...(D)>, transform_op>{
        dyn_rep_l_transformer<detail::build_type<E>, 1 + sizeof...(D)>(std::forward<E>(value), {{d1, static_cast<size_t>(d)...}})};
}

template <etl_expr E>
auto argmax(E&& value) {
    if constexpr (decay_traits<E>::dimensions() > 1) {
        return detail::make_transform_expr<E, argmax_transformer>(std::forward<E>(value));
    } else {
        return max_index(std::forward<E>(value));
    }
}

template <etl_expr E>
auto argmin(E&& value) {
    if constexpr (decay_traits<E>::dimensions() > 1) {
        return detail::make_transform_expr<E, argmin_transformer>(std::forward<E>(value));
    } else {
        return min_index(std::forward<E>(value));
    }
}

template <matrix E>
auto sum_r(E&& value) {
    return detail::make_transform_expr<E, sum_r_transformer>(std::forward<E>(value));
}

template <matrix E>
auto sum_l(E&& value) {
    return detail::make_transform_expr<E, sum_l_transformer>(std::forward<E>(value));
}

template <matrix E>
auto mean_r(E&& value) {
    return detail::make_transform_expr<E, mean_r_transformer>(std::forward<E>(value));
}

template <matrix E>
auto mean_l(E&& value) {
    return detail::make_transform_expr<E, mean_l_transformer>(std::forward<E>(value));
}

template <etl_2d E>
auto one_if_max_sub(const E& value) {
    return detail::make_transform_expr<E, one_if_max_sub_transformer>(value);
}

template <mat_or_vec E>
auto hflip(const E& value) {
    return detail::make_transform_expr<E, hflip_transformer>(value);
}

template <mat_or_vec E>
auto vflip(const E& value) {
    return detail::make_transform_expr<E, vflip_transformer>(value);
}

template <mat_or_vec E>
auto fflip(const E& value) {
    return detail::make_transform_expr<E, fflip_transformer>(value);
}

template <mat_or_vec E>
auto transpose(const E& value) {
    return transpose_expr<detail::build_type<E>>{value};
}

template <etl_expr E>
auto trans(const E& value) {
    return transpose(value);
}

template <etl_expr E>
auto conj_transpose(const E& value) {
    return conj(transpose(value));
}

template <etl_expr E>
auto ctrans(const E& value) {
    return conj(transpose(value));
}

template <deep_mat E>
auto transpose_front(const E& value) {
    return transpose_front_expr<detail::build_type<E>>{value};
}

template <typename A>
value_t<A> norm(const A& a) {
    return detail::norm_impl::apply(a);
}

// TODO: Ideally we would like to be able to use a.dot(b) and
// a.cross(b). Unfortunately, this would require one of these options:
// * A new CRTP class, increasing the compilation time overhead
// * Adding the dot template function in each expression

template <typename A, typename B>
value_t<A> dot(const A& a, const B& b) {
    validate_expression(a, b);
    return detail::dot_impl::apply(a, b);
}

template <etl_1d A, etl_1d B>
etl::fast_vector<value_t<A>, 3> cross(const A& a, const B& b) {
    if constexpr (all_fast<A, B>) {
        static_assert(etl::decay_traits<A>::size() == 3, "Cross product is only valid for 1D vectors of size 3");
        static_assert(etl::decay_traits<B>::size() == 3, "Cross product is only valid for 1D vectors of size 3");
    } else {
        cpp_assert(etl::decay_traits<A>::size(a) == 3, "Cross product is only valid for 1D vectors of size 3");
        cpp_assert(etl::decay_traits<B>::size(b) == 3, "Cross product is only valid for 1D vectors of size 3");
    }

    return {a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]};
}

template <etl_expr E>
value_t<E> sum(E&& values) {
    //Reduction force evaluation
    force(values);

    return detail::sum_impl::apply(values);
}

template <etl_expr E>
value_t<E> asum(E&& values) {
    //Reduction force evaluation
    force(values);

    return detail::asum_impl::apply(values);
}

template <etl_expr E>
value_t<E> mean(E&& values) {
    return sum(values) / static_cast<value_t<E>>(etl::size(values));
}

template <etl_expr E>
value_t<E> amean(E&& values) {
    return asum(values) / static_cast<value_t<E>>(etl::size(values));
}

template <etl_expr E>
value_t<E> stddev(E&& values) {
    auto mean = etl::mean(values);

    double std = 0.0;
    for (auto value : values) {
        std += (value - mean) * (value - mean);
    }

    return static_cast<value_t<E>>(std::sqrt(std / static_cast<double>(etl::size(values))));
}

template <etl_expr E>
value_t<E> stddev(E&& values, value_t<E> mean) {
    double std = 0.0;
    for (auto value : values) {
        std += (value - mean) * (value - mean);
    }

    return static_cast<value_t<E>>(std::sqrt(std / static_cast<double>(etl::size(values))));
}

namespace detail {

template <typename E>
using value_return_t =
    std::conditional_t<decay_traits<E>::is_value,
                       std::conditional_t<std::is_lvalue_reference_v<E>,
                                          std::conditional_t<std::is_const_v<std::remove_reference_t<E>>, const value_t<E>&, value_t<E>&>,
                                          value_t<E>>,
                       value_t<E>>;

} //end of namespace detail

template <etl_expr E>
size_t max_index(E&& values) {
    //Reduction force evaluation
    force(values);

    size_t m = 0;

    for (size_t i = 1; i < etl::size(values); ++i) {
        if (values[i] > values[m]) {
            m = i;
        }
    }

    return m;
}

template <etl_expr E>
detail::value_return_t<E> max(E&& values) {
    auto m = max_index(values);
    return values[m];
}

template <etl_expr E>
size_t min_index(E&& values) {
    //Reduction force evaluation
    force(values);

    size_t m = 0;

    for (size_t i = 1; i < etl::size(values); ++i) {
        if (values[i] < values[m]) {
            m = i;
        }
    }

    return m;
}

template <etl_expr E>
detail::value_return_t<E> min(E&& values) {
    auto m = min_index(values);
    return values[m];
}

// Generate data

template <typename T = double>
auto normal_generator(T mean = 0.0, T stddev = 1.0) {
    return generator_expr<normal_generator_op<T>>{mean, stddev};
}

template <typename T = double, typename G>
auto normal_generator(G& g, T mean = 0.0, T stddev = 1.0) {
    return generator_expr<normal_generator_g_op<G, T>>{g, mean, stddev};
}

template <typename T = double>
auto truncated_normal_generator(T mean = 0.0, T stddev = 1.0) {
    return generator_expr<truncated_normal_generator_op<T>>{mean, stddev};
}

template <typename T = double, typename G>
auto truncated_normal_generator(G& g, T mean = 0.0, T stddev = 1.0) {
    return generator_expr<truncated_normal_generator_g_op<G, T>>{g, mean, stddev};
}

template <typename T = double>
auto uniform_generator(T start, T end) {
    return generator_expr<uniform_generator_op<T>>{start, end};
}

template <typename T = double, typename G>
auto uniform_generator(G& g, T start, T end) {
    return generator_expr<uniform_generator_g_op<G, T>>{g, start, end};
}

template <typename T = double>
auto sequence_generator(T current = 0) {
    return generator_expr<sequence_generator_op<T>>{current};
}

template <typename T = float>
auto dropout_mask(T probability) {
    return generator_expr<dropout_mask_generator_op<T>>{probability};
}

template <typename T = float, typename G>
auto dropout_mask(G& g, T probability) {
    return generator_expr<dropout_mask_generator_g_op<G, T>>{g, probability};
}

template <typename T = float>
auto state_dropout_mask(T probability) {
    return generator_expr<state_dropout_mask_generator_op<T>>{probability};
}

template <typename T = float, typename G>
auto state_dropout_mask(G& g, T probability) {
    return generator_expr<state_dropout_mask_generator_g_op<G, T>>{g, probability};
}

template <typename T = float>
auto inverted_dropout_mask(T probability) {
    return generator_expr<inverted_dropout_mask_generator_op<T>>{probability};
}

template <typename T = float, typename G>
auto state_inverted_dropout_mask(G& g, T probability) {
    return generator_expr<state_inverted_dropout_mask_generator_g_op<G, T>>{g, probability};
}

template <typename T = float>
auto state_inverted_dropout_mask(T probability) {
    return generator_expr<state_inverted_dropout_mask_generator_op<T>>{probability};
}

template <typename T = float, typename G>
auto inverted_dropout_mask(G& g, T probability) {
    return generator_expr<inverted_dropout_mask_generator_g_op<G, T>>{g, probability};
}

template <etl_expr Expr>
decltype(auto) operator*(Expr&& expr) {
    force(expr);
    return std::forward<Expr>(expr);
}

} //end of namespace etl

#include "etl/builder/function_expression_builder.hpp"