operators.hpp

Go to the documentation of this file.

 
#ifndef PLSSVM_DETAIL_OPERATORS_HPP_
#define PLSSVM_DETAIL_OPERATORS_HPP_
#pragma once
 
#include "plssvm/detail/assert.hpp"  // PLSSVM_ASSERT
 
#include <cmath>                     // std::fma
#include <vector>                    // std::vector
 
// clang-format off
#define PLSSVM_GENERATE_ARITHMETIC_OPERATION(Op)                                                      \
    template <typename T>                                                                             \
    inline std::vector<T> &operator Op##=(std::vector<T> &lhs, const std::vector<T> &rhs) {           \
        PLSSVM_ASSERT(lhs.size() == rhs.size(), "Sizes mismatch!: {} != {}", lhs.size(), rhs.size()); \
                                                                                                      \
        _Pragma("omp simd")                                                                           \
        for (typename std::vector<T>::size_type i = 0; i < lhs.size(); ++i) {                         \
            lhs[i] Op##= rhs[i];                                                                      \
        }                                                                                             \
        return lhs;                                                                                   \
    }                                                                                                 \
    template <typename T>                                                                             \
    [[nodiscard]] inline std::vector<T> operator Op(std::vector<T> lhs, const std::vector<T> &rhs) {  \
        return lhs Op##= rhs;                                                                         \
    }                                                                                                 \
    template <typename T>                                                                             \
    inline std::vector<T> &operator Op##=(std::vector<T> &lhs, const T rhs) {                         \
        _Pragma("omp simd")                                                                           \
        for (typename std::vector<T>::size_type i = 0; i < lhs.size(); ++i) {                         \
            lhs[i] Op##= rhs;                                                                         \
        }                                                                                             \
        return lhs;                                                                                   \
    }                                                                                                 \
    template <typename T>                                                                             \
    [[nodiscard]] inline std::vector<T> operator Op(std::vector<T> lhs, const T rhs) {                \
        return lhs Op##= rhs;                                                                         \
    }                                                                                                 \
    template <typename T>                                                                             \
    [[nodiscard]] inline std::vector<T> operator Op(const T lhs, std::vector<T> rhs) {                \
        _Pragma("omp simd")                                                                           \
        for (typename std::vector<T>::size_type i = 0; i < rhs.size(); ++i) {                         \
            rhs[i] = lhs Op rhs[i];                                                                   \
        }                                                                                             \
        return rhs;                                                                                   \
    }
// clang-format on
 
namespace plssvm::operators {
 
// define arithmetic operations +-*/ on std::vector
PLSSVM_GENERATE_ARITHMETIC_OPERATION(+)
PLSSVM_GENERATE_ARITHMETIC_OPERATION(-)
PLSSVM_GENERATE_ARITHMETIC_OPERATION(*)
PLSSVM_GENERATE_ARITHMETIC_OPERATION(/)
 
 
template <typename T>
struct transposed {
    const std::vector<T> &vec;
};
template <typename T>
transposed(const std::vector<T> &) -> transposed<T>;
 
template <typename T>
[[nodiscard]] inline T operator*(const transposed<T> &lhs, const std::vector<T> &rhs) {
    PLSSVM_ASSERT(lhs.vec.size() == rhs.size(), "Sizes mismatch!: {} != {}", lhs.vec.size(), rhs.size());
 
    T val{};
    for (typename std::vector<T>::size_type i = 0; i < lhs.vec.size(); ++i) {
        val = std::fma(lhs.vec[i], rhs[i], val);
    }
    return val;
}
 
template <typename T>
[[nodiscard]] inline T dot(const std::vector<T> &lhs, const std::vector<T> &rhs) {
    return transposed{ lhs } * rhs;
}
 
template <typename T>
[[nodiscard]] inline T sum(const std::vector<T> &vec) {
    T val{};
    #pragma omp simd reduction(+ : val)
    for (typename std::vector<T>::size_type i = 0; i < vec.size(); ++i) {
        val += vec[i];
    }
    return val;
}
 
template <typename T>
[[nodiscard]] inline T squared_euclidean_dist(const std::vector<T> &lhs, const std::vector<T> &rhs) {
    PLSSVM_ASSERT(lhs.size() == rhs.size(), "Sizes mismatch!: {} != {}", lhs.size(), rhs.size());
 
    T val{};
    for (typename std::vector<T>::size_type i = 0; i < lhs.size(); ++i) {
        const T diff = lhs[i] - rhs[i];
        val = std::fma(diff, diff, val);
    }
    return val;
}
 
template <typename T>
[[nodiscard]] inline constexpr T sign(const T x) {
    return x > T{ 0 } ? T{ +1 } : T{ -1 };
}
 
#undef PLSSVM_GENERATE_ARITHMETIC_OPERATION
 
}  // namespace plssvm::operators
 
#endif  // PLSSVM_DETAIL_OPERATORS_HPP_