Matrix.h

Go to the documentation of this file.

#ifndef MATRIX_H
#define MATRIX_H
 
#include "CNum/DataStructs/Matrix/IndexMask.h"
#include "CNum/DataStructs/Matrix/BinaryMask.h"
#include "CNum/Multithreading/ThreadPool.h"
#include "CNum/DataStructs/Views/StrideView.h"
 
#include <iostream>
#include <vector>
#include <atomic>
#include <memory>
#include <functional>
#include <cmath>
#include <future>
#include <span>
#include <cstring>
#include <stdexcept>
#include <string>
 
namespace CNum::DataStructs {
  enum Dim: uint8_t {
    ROW,
    COL
  };
 
  class IndexMask;
  class BinaryMask;
  
  /**
   * @class Matrix
   * @brief 2d array abstraction
   *
   * Used for storing 2d, tabular data. Used in conjuction with CNum ML models
   * and linear algebra operations
   * @tparam T The type of the data stored
   */
  template <typename T>
  class Matrix {
  private:
    ::std::unique_ptr<T[]> _data;
    size_t _cols;
    size_t _rows;

    Matrix<T> element_wise(T val, ::std::function< void(T &, T) > func) const noexcept;

    /// @brief Move Logic
    void move(Matrix<T> &&other) noexcept;


    void copy(const Matrix<T> &other) noexcept;


    // Data must be aligned to the cache-line size to avoid false sharing
    static void par_execute(uint8_t num_threads,
                size_t total_el,
                ::std::function< void(size_t) > callback);
  
  public:
    Matrix(size_t rows = 0, size_t cols = 0, ::std::unique_ptr<T[]> ptr = nullptr);

    Matrix(const Matrix &other) noexcept;

    Matrix<T> &operator=(const Matrix &other) noexcept;

    Matrix(Matrix &&other) noexcept;

    /// @brief Move Assignment
    Matrix<T> &operator=(Matrix &&other) noexcept;

    ~Matrix();

    Matrix<T> operator*(const Matrix &other) const;

    Matrix<T> operator*(T scale_factor) const noexcept;

    T dot(const Matrix<T> &other) const;

    Matrix<T> operator+(const Matrix &other) const;

    Matrix<T> operator+(T a) const noexcept;

    /// @param other The matrix to subtract
    /// @return The resultant matrix
    Matrix<T> operator-(const Matrix &other) const;

    Matrix<T> operator-(T a) const noexcept;

    Matrix<T> abs() const;

    Matrix<T> squared() const;

    Matrix<T> standardize() const;

    T sum() const;

    T mean() const;

    T std() const;

    T get(size_t row, size_t col) const;

    Matrix<T> get(Dim d, size_t idx) const;

    CNum::DataStructs::Views::StrideView<T> get_col_view(size_t idx) const;

    ::std::span<T> get_row_view(size_t idx) const;

    T operator[](size_t idx) const;

    Matrix<T> operator[](const BinaryMask &bin_mask) const;

    Matrix<T> operator[](const IndexMask &idx_mask) const noexcept;

    /// @param idx_mask The mask containing the column indeces to preserve
    /// @return The masked matrix
    Matrix<T> col_wise_mask_application(const IndexMask &idx_mask) const noexcept;

    BinaryMask operator<(T val) const;
    
    BinaryMask operator<=(T val) const;
    
    /// @return The resultant binary mask
    BinaryMask operator>(T val) const;
    
    BinaryMask operator>=(T val) const;
    
    BinaryMask operator==(T val) const;
    
    BinaryMask operator!=(T val) const;

    /// @return An index mask with the sorting order
    IndexMask argsort(bool descending = false) const;

    Matrix<T> transpose() const noexcept;


    static Matrix<T> init_const(size_t rows, size_t cols, T val);

    static Matrix<T> identity(size_t dim);

    /// @return The merged matrix
    static Matrix<T> join_cols(::std::vector< Matrix<T> > &cols);

    static Matrix<T> combine_vertically(::std::vector< Matrix<T> > &matrices, size_t total_rows);

    size_t get_rows() const;

    size_t get_cols() const;

    const T *begin() const;

    const T *end() const;

    /// @return Raw pointer
    T *begin();
    T *end();

    size_t size() const;

    ::std::unique_ptr<T[]> &&move_ptr();

    void print_matrix() const;
 
  
  };
 
#include "Matrix.tpp"
};
 
#endif