TensorFunc.h

Go to the documentation of this file.

#ifndef TENSORFUNC_H
#define TENSORFUNC_H
#pragma once
 
#include "txeo/Matrix.h"
#include "txeo/Tensor.h"
#include "txeo/types.h"
 
#include <cstddef>
#include <functional>
#include <stdexcept>
#include <vector>
 
namespace txeo {
enum class NormalizationType;
 
template <typename T>
class TensorFunc {
  public:
    TensorFunc(const TensorFunc &) = delete;
    TensorFunc(TensorFunc &&) = delete;
    TensorFunc &operator=(const TensorFunc &) = default;
    TensorFunc &operator=(TensorFunc &&) = delete;
    ~TensorFunc() = default;
 
    static txeo::Tensor<T> power_elem(const txeo::Tensor<T> &tensor, const T &exponent);
 
    static txeo::Tensor<T> &power_elem_by(txeo::Tensor<T> &tensor, const T &exponent);
 
    static txeo::Tensor<T> square(const txeo::Tensor<T> &tensor);
 
    static txeo::Tensor<T> &square_by(txeo::Tensor<T> &tensor);
 
    static txeo::Tensor<T> sqrt(const txeo::Tensor<T> &tensor);
 
    static txeo::Tensor<T> &sqrt_by(txeo::Tensor<T> &tensor);
 
    static txeo::Tensor<T> abs(const txeo::Tensor<T> &tensor);
 
    static txeo::Tensor<T> &abs_by(txeo::Tensor<T> &tensor);
 
    static txeo::Tensor<T> permute(const txeo::Tensor<T> &tensor, const std::vector<size_t> &axes);
 
    static txeo::Tensor<T> &permute_by(txeo::Tensor<T> &tensor, const std::vector<size_t> &axes);
 
    static txeo::Tensor<T> &normalize_by(txeo::Tensor<T> &tensor, size_t axis,
                                         txeo::NormalizationType type);
 
    static txeo::Tensor<T> normalize(const txeo::Tensor<T> &tensor, size_t axis,
                                     txeo::NormalizationType type);
 
    static std::vector<std::function<T(const T &)>>
    make_normalize_functions(const txeo::Tensor<T> &tensor, size_t axis,
                             txeo::NormalizationType type);
 
    static Tensor<T> &normalize_by(txeo::Tensor<T> &tensor, txeo::NormalizationType type);
 
    static txeo::Tensor<T> normalize(const txeo::Tensor<T> &tensor, txeo::NormalizationType type);
 
    static std::function<T(const T &)> make_normalize_function(const txeo::Tensor<T> &tensor,
                                                               txeo::NormalizationType type);
 
    static txeo::Matrix<T> transpose(const txeo::Matrix<T> &matrix);
 
    static txeo::Matrix<T> &transpose_by(txeo::Matrix<T> &matrix);
 
    static txeo::Matrix<T> compute_gram_matrix(const txeo::Matrix<T> &matrix);
 
  private:
    TensorFunc() = default;
 
    static void
    axis_func(txeo::Tensor<T> &tensor, size_t axis,
              std::function<void(const std::vector<T> &, const std::vector<T *> &)> func);
    static std::vector<std::function<T(const T &)>>
    new_axis_func(const txeo::Tensor<T> &tensor, size_t axis,
                  std::function<void(const std::vector<T> &, T &, T &)> func);
 
    static void min_max_normalize(const std::vector<T> &values, const std::vector<T *> &adresses);
    static void z_score_normalize(const std::vector<T> &values, const std::vector<T *> &adresses);
 
    static void new_min_max_normalize(const std::vector<T> &values,
                                      const std::vector<T *> &adresses, T &subtractor,
                                      T &denominator);
    static void new_z_score_normalize(const std::vector<T> &values,
                                      const std::vector<T *> &adresses, T &subtractor,
                                      T &denominator);
 
    static void min_max_normalize(const txeo::Tensor<T> &tensor, T &subtractor, T &denominator);
    static void z_score_normalize(const txeo::Tensor<T> &tensor, T &subtractor, T &denominator);
 
    static void min_max_subtractor_denominator(const std::vector<T> &values, T &subtractor,
                                               T &denominator);
 
    static void z_score_subtractor_denominator(const std::vector<T> &values, T &subtractor,
                                               T &denominator);
};
 
class TensorFuncError : public std::runtime_error {
  public:
    using std::runtime_error::runtime_error;
};
 
} // namespace txeo
 
#endif