no_vectorization.hpp

//=======================================================================
// 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 T>
struct no_intrinsic_traits {
    static constexpr bool vectorizable = false;      
    static constexpr size_t size       = 1;          
    static constexpr size_t alignment  = alignof(T); 

    using intrinsic_type = T; 
};

struct no_vec {
    template <typename T>
    using traits = no_intrinsic_traits<T>;

    template <typename T>
    using vec_type = typename traits<T>::intrinsic_type;

    template <typename F, typename M>
    static inline void storeu([[maybe_unused]] F* memory, [[maybe_unused]] M value) {}

    template <typename F, typename M>
    static inline void store([[maybe_unused]] F* memory, [[maybe_unused]] M value) {}

    template <typename F>
    static F load([[maybe_unused]] const F* memory) {
        return F();
    }

    template <typename F>
    static F loadu([[maybe_unused]] const F* memory) {
        return F();
    }

    template <typename F>
    static F set([[maybe_unused]] F value) {
        return F();
    }

    template <typename F>
    static F round_up([[maybe_unused]] F x) {
        return F();
    }

    template <typename M>
    static M add([[maybe_unused]] M lhs, [[maybe_unused]] M rhs) {
        return M();
    }

    template <typename M>
    static M sub([[maybe_unused]] M lhs, [[maybe_unused]] M rhs) {
        return M();
    }

    template <typename M>
    static M fmadd([[maybe_unused]] M a, [[maybe_unused]] M b, [[maybe_unused]] M c) {
        return M();
    }

    template <typename M>
    static M mul([[maybe_unused]] M lhs, [[maybe_unused]] M rhs) {
        return M();
    }

    template <typename M>
    static M div([[maybe_unused]] M lhs, [[maybe_unused]] M rhs) {
        return M();
    }

    template <typename M>
    static M max([[maybe_unused]] M lhs, [[maybe_unused]] M rhs) {
        return M();
    }

    template <typename M>
    static M min([[maybe_unused]] M lhs, [[maybe_unused]] M rhs) {
        return M();
    }

    template <typename M>
    static M sqrt([[maybe_unused]] M value) {
        return M();
    }

    template <typename M>
    static M minus([[maybe_unused]] M value) {
        return M();
    }

    template <typename M>
    static M hadd([[maybe_unused]] M value) {
        return M();
    }

    template <typename T>
    static T zero() {
        return T();
    }
};

} //end of namespace etl