Matrix.h

Go to the documentation of this file.

#ifndef MATRIX_H
#define MATRIX_H
#pragma once
 
#include "txeo/Tensor.h"
#include "txeo/TensorShape.h"
#include "txeo/Vector.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;
 
template <typename T>
class Matrix : public txeo::Tensor<T> {
  public:
    explicit Matrix();
    ~Matrix() = default;
 
    Matrix(const Matrix &matrix) : txeo::Tensor<T>{matrix} {};
    Matrix(Matrix &&matrix) noexcept : txeo::Tensor<T>{std::move(matrix)} {};
 
    Matrix &operator=(const Matrix &matrix) {
      txeo::Tensor<T>::operator=(matrix);
      return *this;
    };
 
    Matrix &operator=(Matrix &&matrix) noexcept {
      txeo::Tensor<T>::operator=(std::move(matrix));
      return *this;
    };
 
    explicit Matrix(size_t row_size, size_t col_size)
        : txeo::Tensor<T>{txeo::TensorShape({row_size, col_size})} {};
 
    explicit Matrix(size_t row_size, size_t col_size, const T &fill_value)
        : txeo::Tensor<T>({row_size, col_size}, fill_value) {};
 
    explicit Matrix(size_t row_size, size_t col_size, const std::vector<T> &values)
        : txeo::Tensor<T>({row_size, col_size}, values) {};
 
    explicit Matrix(size_t row_size, size_t col_size, const std::initializer_list<T> &values)
        : txeo::Tensor<T>({row_size, col_size}, std::vector<T>(values)) {};
 
    explicit Matrix(const std::initializer_list<std::initializer_list<T>> &values)
        : txeo::Tensor<T>(values) {};
 
    explicit Matrix(txeo::Tensor<T> &&tensor);
 
    [[nodiscard]] size_t size() const { return txeo::Tensor<T>::dim(); };
 
    [[nodiscard]] size_t row_size() const { return this->shape().axis_dim(0); };
 
    [[nodiscard]] size_t col_size() const { return this->shape().axis_dim(1); };
 
    void normalize_columns(txeo::NormalizationType type);
 
    void normalize_rows(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));
    };
 
    Matrix<T> &transpose();
 
    Matrix<T> dot(const Matrix<T> &matrix) const;
 
    Tensor<T> dot(const txeo::Vector<T> &vector) const;
 
    Matrix<T> clone() const;
 
    static Matrix<T> to_matrix(txeo::Tensor<T> &&tensor);
 
    static Matrix<T> to_matrix(const txeo::Tensor<T> &tensor);
 
    static txeo::Tensor<T> to_tensor(Matrix<T> &&matrix);
 
    static txeo::Tensor<T> to_tensor(const Matrix<T> &matrix);
 
    template <typename U>
    friend Matrix<U> operator+(const Matrix<U> &left, const Matrix<U> &right);
 
    template <typename U>
    friend Matrix<U> operator+(const Matrix<U> &left, const U &right);
 
    template <typename U>
    friend Matrix<U> operator-(const Matrix<U> &left, const Matrix<U> &right);
 
    template <typename U>
    friend Matrix<U> operator-(const Matrix<U> &left, const U &right);
 
    template <typename U>
    friend Matrix<U> operator-(const U &left, const Matrix<U> &right);
 
    template <typename U>
    friend Matrix<U> operator*(const Matrix<U> &matrix, const U &scalar);
 
    template <typename U>
    friend Matrix<U> operator*(const U &scalar, const Matrix<U> &matrix);
 
    template <typename U>
    friend Matrix<U> operator/(const Matrix<U> &left, const U &right);
 
    template <typename U>
    friend Matrix<U> operator/(const U &left, const Matrix<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 MatrixError : public std::runtime_error {
  public:
    using std::runtime_error::runtime_error;
};
 
} // namespace txeo
#endif