tensor.hpp

Go to the documentation of this file.

#pragma once
 
#include <initializer_list>
#include <iostream>
#include <tuple>
#include <vector>
#include <xtensor/containers/xarray.hpp>
#include <xtensor/core/xmath.hpp>
#include <xtensor/generators/xrandom.hpp>
#include <xtensor/io/xio.hpp>
#include <xtensor/reducers/xreducer.hpp>
#include <xtensor/views/xview.hpp>
#include <xtensor/core/xshape.hpp>
 
namespace utils {
    template<typename T>
    class Tensor {
    public:
        Tensor() : data_(xt::xarray<T>::from_shape({0})), rows_(0), cols_(0) {}
 
        explicit Tensor(const std::vector<size_t>& shape);
 
        Tensor(size_t rows, size_t cols);
 
        Tensor(const std::vector<size_t>& shape, T value);
 
        Tensor(size_t rows, size_t cols, T value);
 
        Tensor(std::initializer_list<std::initializer_list<T>> list);
 
        explicit Tensor(const xt::xarray<T>& data);
 
        template<typename U>
        friend std::ostream &operator<<(std::ostream &os, const Tensor<U> &tensor);
        template<typename U>
        friend Tensor<U> dot(const Tensor<U> &a, const Tensor<U> &b);
        template<typename U>
        friend U sum(const Tensor<U> &tensor);
        template<typename U>
        friend U mean(const Tensor<U> &tensor);
 
        template<typename... Args>
        T &operator()(Args... indices);
 
        template<typename... Args>
        const T &operator()(Args... indices) const;
 
        T &at(size_t row, size_t col);
 
        const T &at(size_t row, size_t col) const;
 
        Tensor operator+(const Tensor &other) const;
 
        Tensor operator-(const Tensor &other) const;
 
        Tensor operator*(const Tensor &other) const;
 
        Tensor matmul(const Tensor &other) const;
 
        Tensor operator*(T scalar) const;
 
        Tensor transpose() const;
 
        Tensor transpose(const std::vector<size_t>& axes) const;
 
        Tensor reshape(const std::vector<size_t>& new_shape) const;
 
        Tensor reshape(size_t new_rows, size_t new_cols) const;
 
        Tensor view(const std::vector<size_t>& new_shape) const;
 
        Tensor squeeze(int axis = -1) const;
 
        Tensor unsqueeze(size_t axis) const;
 
        T determinant() const;
 
        Tensor inverse() const;
 
        auto eigenvalues() const;
 
        [[nodiscard]] size_t rows() const { return rows_; }
 
        [[nodiscard]] size_t cols() const { return cols_; }
 
        [[nodiscard]] size_t size() const { return rows_ * cols_; }
 
        [[nodiscard]] std::tuple<size_t, size_t> shape() const { return {rows_, cols_}; }
 
        static Tensor zeros(const std::vector<size_t>& shape);
 
        static Tensor zeros(size_t rows, size_t cols);
 
        static Tensor ones(const std::vector<size_t>& shape);
 
        static Tensor ones(size_t rows, size_t cols);
 
        static Tensor full(const std::vector<size_t>& shape, T value);
 
        static Tensor identity(size_t size);
 
        static Tensor random(const std::vector<size_t>& shape);
 
        static Tensor random(const std::vector<size_t>& shape, T min, T max);
 
        static Tensor random(size_t rows, size_t cols);
 
        static Tensor random(size_t rows, size_t cols, T min, T max);
 
        static Tensor from_array(const xt::xarray<T>& array);
 
        xt::xarray<T> &data() { return data_; }
 
        const xt::xarray<T> &data() const { return data_; }
 
    private:
        xt::xarray<T> data_;
 
        size_t rows_, cols_;
    };
 
    // Template method implementations
    template<typename T>
    template<typename... Args>
    T& Tensor<T>::operator()(Args... indices) {
        return data_(indices...);
    }
 
    template<typename T>
    template<typename... Args>
    const T& Tensor<T>::operator()(Args... indices) const {
        return data_(indices...);
    }
 
    template<typename T>
    std::ostream &operator<<(std::ostream &os, const Tensor<T> &tensor);
 
    template<typename T>
    Tensor<T> dot(const Tensor<T> &a, const Tensor<T> &b);
 
    template<typename T>
    T sum(const Tensor<T> &tensor);
 
    template<typename T>
    T mean(const Tensor<T> &tensor);
 
    using TensorF = Tensor<float>;
 
    using TensorD = Tensor<double>;
 
    using MatrixF = Tensor<float>;
 
    using MatrixD = Tensor<double>;
 
} // namespace utils