marvin_VecOps.h

Go to the documentation of this file.

// ========================================================================================================
//  _______ _______ ______ ___ ___ _______ _______
// |   |   |   _   |   __ \   |   |_     _|    |  |
// |       |       |      <   |   |_|   |_|       |
// |__|_|__|___|___|___|__|\_____/|_______|__|____|
//
// This file is part of the Marvin open source library and is licensed under the terms of the MIT License.
//
// ========================================================================================================
#ifndef MARVIN_SIMDOPS_H
#define MARVIN_SIMDOPS_H
#include <marvin/library/marvin_Concepts.h>
#include <marvin/library/marvin_Literals.h>
#include <type_traits>
#include <cstring>
#include <cassert>
namespace marvin::math::vecops {

    template <FloatType T>
    void add(T* lhs, const T* rhs, size_t size) noexcept;
    template <FloatType T>
    void add(T* arr, T scalar, size_t size) noexcept;
    template <FloatArrayLike T>
    void add(T& lhs, T& rhs) noexcept {
        assert(lhs.size() == rhs.size());
        add(lhs.data(), rhs.data(), lhs.size());
    }

    template <FloatArrayLike T>
    void add(T& arr, typename T::value_type scalar) noexcept {
        add(arr.data(), scalar, arr.size());
    }

    template <FloatType T>
    void subtract(T* lhs, const T* rhs, size_t size) noexcept;
    template <FloatType T>
    void subtract(T* arr, T scalar, size_t size) noexcept;

    template <FloatArrayLike T>
    requires std::is_floating_point_v<typename T::value_type>
    void subtract(T& lhs, const T& rhs) noexcept {
        assert(lhs.size() == rhs.size());
        subtract(lhs.data(), rhs.data(), lhs.size());
    }

    template <FloatArrayLike T>
    void subtract(T& arr, typename T::value_type scalar) noexcept {
        subtract(arr.data(), scalar, arr.size());
    }

    template <FloatType T>
    void multiply(T* lhs, const T* rhs, size_t size) noexcept;

    template <FloatType T>
    void multiply(T* arr, T scalar, size_t size) noexcept;

    template <FloatArrayLike T>
    void multiply(T& lhs, const T& rhs) noexcept {
        assert(lhs.size() == rhs.size());
        multiply(lhs.data(), rhs.data(), lhs.size());
    }

    template <FloatArrayLike T>
    void multiply(T& arr, typename T::value_type scalar) noexcept {
        multiply(arr.data(), scalar, arr.size());
    }

    template <FloatType T>
    void divide(T* lhs, const T* rhs, size_t size) noexcept;

    template <FloatType T>
    void divide(T* arr, T scalar, size_t size) noexcept;

    template <FloatArrayLike T>
    void divide(T& lhs, const T& rhs) noexcept {
        assert(lhs.size() == rhs.size());
        divide(lhs.data(), rhs.data(), lhs.size());
    }

    template <FloatArrayLike T>
    void divide(T& arr, typename T::value_type scalar) noexcept {
        divide(arr.data(), scalar, arr.size());
    }

    template <NumericType T>
    void copy(T* lhs, const T* rhs, size_t size) noexcept {
        std::memcpy(lhs, rhs, sizeof(T) * size);
    }
 

    template <ArrayLike T>
    void copy(T& lhs, const T& rhs) noexcept {
        assert(lhs.size() == rhs.size());
        copy(lhs.data(), rhs.data(), lhs.size());
    }
} // namespace marvin::math::vecops
#endif