scalar.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 <concepts>
namespace etl {

template <typename T>
struct scalar {
    using value_type = T; 

    template <typename V = default_vec>
    using vec_type = typename V::template vec_type<T>;

    const T value; 

    explicit constexpr scalar(T v) : value(v) {}

    template <std::convertible_to<T> C>
    explicit constexpr scalar(C c) : value(static_cast<T>(c)) {}

    constexpr T operator[](size_t d) const noexcept {
        return (void)d, value;
    }

    constexpr T read_flat(size_t d) const noexcept {
        return (void)d, value;
    }

    template <typename V = default_vec>
    vec_type<V> load(size_t d) const noexcept {
        return (void)d, V::set(value);
    }

    template <typename V = default_vec>
    vec_type<V> loadu(size_t d) const noexcept {
        return (void)d, V::set(value);
    }

    template <size_c... S>
    constexpr T operator()(__attribute__((unused)) S... args) const noexcept {
        return value;
    }

    template <typename E>
    constexpr bool alias(const E& /*rhs*/) const noexcept {
        return false;
    }

    // Assignment functions

    template <typename L>
    void assign_to(L&& lhs) const {
        std_assign_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_add_to(L&& lhs) const {
        std_add_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_sub_to(L&& lhs) const {
        std_sub_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_mul_to(L&& lhs) const {
        std_mul_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_div_to(L&& lhs) const {
        std_div_evaluate(*this, std::forward<L>(lhs));
    }

    template <typename L>
    void assign_mod_to(L&& lhs) const {
        std_mod_evaluate(*this, std::forward<L>(lhs));
    }

    // Internals

    template <typename V>
    void visit([[maybe_unused]] V&& visitor) const {}

    template <typename Y>
    decltype(auto) gpu_compute_hint([[maybe_unused]] Y& y) const {
        // TODO Maybe make a full vector with the hint

        gpu_dyn_matrix_impl<T, order::RowMajor, 1> t1;

        t1.resize_scalar();
        t1.ensure_gpu_allocated();

#ifdef ETL_CUDA
        cuda_check(cudaMemcpy(t1.gpu_memory(), &value, 1 * sizeof(T), cudaMemcpyHostToDevice));
#endif

        return t1;
    }

    template <typename Y>
    decltype(auto) gpu_compute(Y& y) const {
        y.ensure_gpu_allocated();

#ifdef ETL_CUDA
        cuda_check(cudaMemcpy(y.gpu_memory(), &value, etl::size(y) * sizeof(T), cudaMemcpyHostToDevice));
#endif

        return y;
    }

    void ensure_cpu_up_to_date() const {
        // Nothing to ensure
    }

    void ensure_gpu_up_to_date() const {
        // Nothing to ensure
    }

    friend std::ostream& operator<<(std::ostream& os, const scalar& s) {
        return os << s.value;
    }
};

template <typename T>
struct etl_traits<etl::scalar<T>> {
    using value_type = T; 

    static constexpr bool is_etl         = true;                                 
    static constexpr bool is_transformer = false;                                
    static constexpr bool is_view        = false;                                
    static constexpr bool is_magic_view  = false;                                
    static constexpr bool is_fast        = true;                                 
    static constexpr bool is_value       = false;                                
    static constexpr bool is_direct      = false;                                
    static constexpr bool is_linear      = true;                                 
    static constexpr bool is_thread_safe = true;                                 
    static constexpr bool is_generator   = true;                                 
    static constexpr bool is_temporary   = false;                                
    static constexpr bool is_padded      = true;                                 
    static constexpr bool is_aligned     = true;                                 
    static constexpr bool gpu_computable = is_gpu_t<value_type> && cuda_enabled; 
    static constexpr order storage_order = order::RowMajor;                      

    template <vector_mode_t VV>
    static constexpr bool vectorizable = true;

    static constexpr size_t size() {
        return 0;
    }

    static constexpr size_t dimensions() {
        return 0;
    }

    static constexpr int complexity() noexcept {
        return 4;
    }
};

} //end of namespace etl