Vector.h

Go to the documentation of this file.

#ifndef VECTOR_H
#define VECTOR_H
#pragma once
 
#include "txeo/Tensor.h"
#include "txeo/TensorShape.h"
#include "txeo/types.h"
 
#include <cstddef>
#include <initializer_list>
#include <stdexcept>
#include <utility>
#include <vector>
 
namespace txeo {
 
namespace detail {
class TensorHelper;
}
 
enum class NormalizationType;
template <typename T>
class Predictor;
template <typename T>
class TensorAgg;
template <typename T>
class TensorFunc;
template <typename T>
class TensorOp;
template <typename T>
class TensorPart;
 
template <typename T>
class Vector : public txeo::Tensor<T> {
  public:
    explicit Vector();
    ~Vector() = default;
 
    Vector(const Vector &Vector) : txeo::Tensor<T>{Vector} {};
    Vector(Vector &&Vector) noexcept : txeo::Tensor<T>{std::move(Vector)} {};
 
    Vector &operator=(const Vector &Vector) {
      txeo::Tensor<T>::operator=(Vector);
      return *this;
    };
 
    Vector &operator=(Vector &&Vector) noexcept {
      txeo::Tensor<T>::operator=(std::move(Vector));
      return *this;
    };
 
    explicit Vector(size_t dim) : txeo::Tensor<T>{txeo::TensorShape({dim})} {};
 
    explicit Vector(size_t dim, const T &fill_value) : txeo::Tensor<T>({dim}, fill_value) {};
 
    explicit Vector(size_t dim, const std::vector<T> &values) : txeo::Tensor<T>({dim}, values) {};
 
    explicit Vector(size_t dim, const std::initializer_list<T> &values)
        : txeo::Tensor<T>({dim}, std::vector<T>(values)) {};
 
    explicit Vector(const std::initializer_list<T> &values)
        : txeo::Tensor<T>({values.size()}, std::vector<T>(values)) {};
 
    explicit Vector(txeo::Tensor<T> &&tensor);
 
    void normalize(txeo::NormalizationType type);
 
    void reshape(const txeo::TensorShape &shape);
 
    void reshape(const std::vector<size_t> &shape) { this->reshape(txeo::TensorShape(shape)); };
 
    void reshape(const std::initializer_list<size_t> &shape) {
      this->reshape(std::vector<size_t>(shape));
    };
 
    [[nodiscard]] size_t size() const { return this->dim(); }
 
    static Vector<T> to_vector(txeo::Tensor<T> &&tensor);
 
    static Vector<T> to_vector(const txeo::Tensor<T> &tensor);
 
    static txeo::Tensor<T> to_tensor(Vector<T> &&vector);
 
    static txeo::Tensor<T> to_tensor(const Vector<T> &vector);
 
    template <typename U>
    friend txeo::Vector<U> operator+(const txeo::Vector<U> &left, const txeo::Vector<U> &right);
 
    template <typename U>
    friend txeo::Vector<U> operator+(const txeo::Vector<U> &left, const U &right);
 
    template <typename U>
    friend txeo::Vector<U> operator-(const txeo::Vector<U> &left, const txeo::Vector<U> &right);
 
    template <typename U>
    friend txeo::Vector<U> operator-(const txeo::Vector<U> &left, const U &right);
 
    template <typename U>
    friend txeo::Vector<U> operator-(const U &left, const txeo::Vector<U> &right);
 
    template <typename U>
    friend txeo::Vector<U> operator*(const txeo::Vector<U> &vector, const U &scalar);
 
    template <typename U>
    friend txeo::Vector<U> operator*(const U &scalar, const txeo::Vector<U> &vector);
 
    template <typename U>
    friend txeo::Vector<U> operator/(const txeo::Vector<U> &left, const U &right);
 
    template <typename U>
    friend txeo::Vector<U> operator/(const U &left, const txeo::Vector<U> &right);
 
  private:
    friend class txeo::Predictor<T>;
    friend class txeo::TensorAgg<T>;
    friend class txeo::TensorPart<T>;
    friend class txeo::TensorOp<T>;
    friend class txeo::TensorFunc<T>;
    friend class txeo::detail::TensorHelper;
};
 
class VectorError : public std::runtime_error {
  public:
    using std::runtime_error::runtime_error;
};
 
} // namespace txeo
 
#endif