Matrix.h

#ifndef MATRIX_H
#define MATRIX_H

#include <iostream>
#include <vector>
#include <random>

class Matrix{
public:
    std::vector<double> data;
    int num_of_rows;
    int num_of_cols;

    // constructor
    Matrix(int num_of_rows=0, int num_of_cols=0): num_of_rows(num_of_rows), num_of_cols(num_of_cols){
        this->data.resize(num_of_cols*num_of_rows, 0.0);
    }

    // copy constructor
    Matrix(const Matrix &mat){
        this->num_of_rows = mat.num_of_rows;
        this->num_of_cols = mat.num_of_cols;
        this->data = mat.data;
    }

    // random init
    Matrix randomize(double min=-1, double max=1){
        std::random_device rd;
        std::mt19937 gen(rd());
        std::uniform_real_distribution<> dis(min, max);
        for (int i=0; i<this->num_of_cols*this->num_of_rows; i++){
            this->data[i] = dis(gen);
        }
        return *this;
    }

    // indexing
    double& at(int row, int col){
        return  data.at(row*this->num_of_cols + col);
    }

    // transpose
    Matrix transpose(){
        Matrix new_mat(this->num_of_cols, this->num_of_rows);
        for(int i=0; i<this->num_of_rows; i++){
            for(int j=0; j<this->num_of_cols; j++){
                new_mat.at(j, i) = this->at(i, j);
            }
        }
        return new_mat;
    }

    // print matrix
    void print(){
        std::cout << "[";
        for(int i=0; i<this->num_of_rows; i++){
            for(int j=0; j<this->num_of_cols; j++){
                if(i!=0 and j==0){
                    std::cout << " ";
                }
                std::cout << this->at(i, j);
                if(j != this->num_of_cols-1){
                    std::cout << ", ";
                }
            }
            if(i != this->num_of_rows-1){
                std::cout << std::endl;
            }
        }
        std::cout << "]" << std::endl;
    }

    // Dot product 
    Matrix dot_product(Matrix mat2){
        if(this->num_of_cols != mat2.num_of_rows){
            throw "Matrix Dimensions mismatch error ";
        }
        Matrix res_mat(this->num_of_rows, mat2.num_of_cols);
        for(int i=0; i<this->num_of_rows; i++){
            for(int j=0; j<res_mat.num_of_cols; j++){ 
                double e = 0;
                for (int k=0; k<mat2.num_of_rows; k++){
                    e += this->at(i, k)*mat2.at(k, j);
                }
                res_mat.at(i, j) = e;
            }
        }
        return res_mat;
    }

    // scaler multiply
    Matrix operator*(double coficient){
        Matrix res_mat(*this);
        for(int i=0; i<this->num_of_rows; i++){
            for(int j=0; j<this->num_of_cols; j++){
                res_mat.at(i, j) = this->at(i, j) * coficient;
            }
        }
        return res_mat;
    }

    // vector element-wise multiply
    Matrix operator*(Matrix mat2){
        if(this->num_of_cols!=mat2.num_of_cols or this->num_of_rows!=mat2.num_of_rows){
            throw "Matrix Dimensions mismatch error ";
        }
        Matrix res_mat(*this);
        for(int i=0; i<this->num_of_rows; i++){
            for(int j=0; j<this->num_of_cols; j++){
                res_mat.at(i, j) = this->at(i, j) * mat2.at(i, j);
            }
        }
        return res_mat;
    }

    // addition
    Matrix operator+(Matrix mat2){
        if(this->num_of_cols!=mat2.num_of_cols or this->num_of_rows!=mat2.num_of_rows){
            throw "Matrix Dimensions mismatch error ";
        }
        Matrix res_mat(*this);
        for(int i=0; i<this->num_of_rows; i++){
            for(int j=0; j<this->num_of_cols; j++){
                res_mat.at(i, j) = this->at(i, j) + mat2.at(i, j);
            }
        }
        return res_mat;
    }

    // subtract
    Matrix operator-(Matrix mat2){
        if(this->num_of_cols!=mat2.num_of_cols or this->num_of_rows!=mat2.num_of_rows){
            throw "Matrix Dimensions mismatch error ";
        }
        Matrix res_mat(*this);
        for(int i=0; i<this->num_of_rows; i++){
            for(int j=0; j<this->num_of_cols; j++){
                res_mat.at(i, j) = this->at(i, j) - mat2.at(i, j);
            }
        }
        return res_mat;
    }

    // element operator
    Matrix apply(double (*function)(double)){
        Matrix res_mat(*this);
        for(int i=0; i<this->num_of_rows; i++){
            for(int j=0; j<this->num_of_cols; j++){
                res_mat.at(i, j) = function(this->at(i, j));
            }
        }
        return res_mat;
    }
};

#endif