kernel_function_types.hpp

Go to the documentation of this file.

 
#ifndef PLSSVM_KERNEL_FUNCTION_TYPES_HPP_
#define PLSSVM_KERNEL_FUNCTION_TYPES_HPP_
#pragma once
 
#include "plssvm/detail/assert.hpp"          // PLSSVM_ASSERT
#include "plssvm/detail/operators.hpp"       // dot product, plssvm::squared_euclidean_dist
#include "plssvm/detail/type_traits.hpp"     // plssvm::detail::always_false_v
#include "plssvm/detail/utility.hpp"         // plssvm::detail::get
#include "plssvm/exceptions/exceptions.hpp"  // plssvm::unsupported_kernel_type_exception
 
#include <cmath>                             // std::pow, std::exp, std::fma
#include <iosfwd>                            // forward declare std::ostream and std::istream
#include <vector>                            // std::vector
 
namespace plssvm {
 
enum class kernel_function_type {
    linear = 0,
    polynomial = 1,
    rbf = 2
};
 
std::ostream &operator<<(std::ostream &out, kernel_function_type kernel);
 
[[nodiscard]] std::string_view kernel_function_type_to_math_string(kernel_function_type kernel) noexcept;
 
std::istream &operator>>(std::istream &in, kernel_function_type &kernel);
 
template <kernel_function_type kernel, typename real_type, typename... Args>
[[nodiscard]] inline real_type kernel_function(const std::vector<real_type> &xi, const std::vector<real_type> &xj, Args &&...args) {
    using namespace plssvm::operators;
 
    PLSSVM_ASSERT(xi.size() == xj.size(), "Sizes mismatch!: {} != {}", xi.size(), xj.size());
 
    if constexpr (kernel == kernel_function_type::linear) {
        static_assert(sizeof...(args) == 0, "Illegal number of additional parameters! Must be 0.");
        return transposed{ xi } * xj;
    } else if constexpr (kernel == kernel_function_type::polynomial) {
        static_assert(sizeof...(args) == 3, "Illegal number of additional parameters! Must be 3.");
        const auto degree = static_cast<real_type>(detail::get<0>(args...));
        const auto gamma = static_cast<real_type>(detail::get<1>(args...));
        const auto coef0 = static_cast<real_type>(detail::get<2>(args...));
        return std::pow(std::fma(gamma, (transposed<real_type>{ xi } * xj), coef0), degree);
    } else if constexpr (kernel == kernel_function_type::rbf) {
        static_assert(sizeof...(args) == 1, "Illegal number of additional parameters! Must be 1.");
        const auto gamma = static_cast<real_type>(detail::get<0>(args...));
        return std::exp(-gamma * squared_euclidean_dist(xi, xj));
    } else {
        static_assert(detail::always_false_v<real_type>, "Unknown kernel type!");
    }
}
 
// forward declare parameter class
namespace detail {
template <typename>
struct parameter;
}
 
template <typename real_type>
[[nodiscard]] real_type kernel_function(const std::vector<real_type> &xi, const std::vector<real_type> &xj, const detail::parameter<real_type> &params);
 
}  // namespace plssvm
 
#endif  // PLSSVM_KERNEL_FUNCTION_TYPES_HPP_