VectorMatrix.hpp

Go to the documentation of this file.

#pragma once
 
#include<iostream>
#include <algorithm>
#include <vector>
#include <stdexcept>
 
namespace LinearAlgebra{
    template <typename T>
    class VectorMatrix {
    private:
        int cols,rows;
        std::vector<std::vector<T>> matrix; // Матрица
    public:
        VectorMatrix(int rows, int cols):rows(rows), cols(cols){
            matrix.assign(rows,std::vector<T>(cols,0));
        };
        VectorMatrix(const std::vector<std::vector<T>>& v):matrix(v) {
            if (v.empty() || v[0].empty()) {
                throw std::invalid_argument("Matrix is empty");
            }
            rows = v.size();
            cols = matrix[0].size();
 
            validation();
        }
          VectorMatrix(std::vector<std::vector<T>>&& v)
      : matrix(std::move(v)) {
            if (matrix.empty() || matrix[0].empty()) throw std::invalid_argument("Matrix is empty");
            rows = static_cast<int>(matrix.size());
            cols = static_cast<int>(matrix[0].size());
            validation();
        }
        void validation() {
            for (const auto& row : matrix)
                if (static_cast<int>(row.size()) != cols) 
                    throw std::invalid_argument("All rows must have the same size");
        }
        VectorMatrix(): rows(0),cols(0){};
        ~VectorMatrix()=default;
 
        VectorMatrix<T> operator*(const VectorMatrix<T>& B) const;
 
        VectorMatrix<T> operator*(T number) const;
 
        T& operator()(int i,int j) {
            
            if(i < 0 || i >= rows || j < 0 || j >=cols) {
                throw std::out_of_range("Matrix index out of range");
            }
 
            return matrix[i][j]; 
        }
        const T& operator()(int i,int j) const { 
            if(i < 0 || i >= rows || j < 0 || j >=cols) {
                throw std::out_of_range("Matrix index out of range");
            }
            return matrix[i][j];
        }
 
        std::vector<T>& operator[](int i) {
        if (i < 0 || i >= rows)
            throw std::out_of_range("Row index out of range");
            return matrix[i];
        }
 
        const std::vector<T>& operator[](int i) const {
            if (i < 0 || i >= rows)
                throw std::out_of_range("Row index out of range");
            return matrix[i];
        }
 
        int getRows() const {return rows;}
 
        int getColumns() const {return cols;}
        
        const std::vector<std::vector<T>>& getMatrix()const {return matrix;}
        std::vector<std::vector<T>>& getMatrix() { return matrix; }
        
        VectorMatrix<T> operator!()const;
        template <typename U>
        friend std::ostream& operator<<(std::ostream& os, const VectorMatrix<U>& M);
        
    };
}
 
template <typename U>
std::ostream& operator<<(std::ostream& os,const LinearAlgebra::VectorMatrix<U>& M) {
    int rows = M.getRows();
    int cols = M.getColumns();
    for (int i = 0; i < rows; ++i){
        for (int j = 0; j < cols; ++j){
            os<<M(i,j)<<" ";
        }
        if(i != rows-1)
            os<<"\n";
    }
    return os;
}
 
template <typename T>
LinearAlgebra::VectorMatrix<T> LinearAlgebra::VectorMatrix<T>::operator!() const {
    VectorMatrix<T> result(cols,rows); 
    for (int i = 0; i < cols; i++){
        for (int j = 0; j < rows; j++){
            auto &Aij = (*this)(i,j);
            result(j,i) = Aij;
        }
    }
    return result;
};
 
template <typename T>
LinearAlgebra::VectorMatrix<T> LinearAlgebra::VectorMatrix<T>::operator*(T number) const {
 
    VectorMatrix<T> result(rows,cols);
 
    for (int i = 0; i < rows; i++){
        auto &Ri = result.matrix[i];
        for (int j = 0; j < cols; j++){
            auto &Aij = matrix[i][j];
            Ri[j] = Aij  * number;
        }
    }
    return result;
};
 
 
 
template <typename T>
LinearAlgebra::VectorMatrix<T> LinearAlgebra::VectorMatrix<T>::operator*(const VectorMatrix<T>& B) const {
    if(cols != B.getRows()) {
        throw std::invalid_argument("num columns A not equal num rows B");
    }
 
    int colsB = B.getColumns();
    VectorMatrix<T> result(rows,colsB);
    const int bs = 32;
 
    for (int i = 0; i < rows; i += bs) {
        for (int k = 0; k < this->cols; k += bs) {
            for (int j = 0; j < colsB; j += bs) {
 
                int i_end = std::min(i + bs, rows);
                int k_end = std::min(k + bs, this->cols);
                int j_end = std::min(j + bs, colsB);
 
                for (int ii = i; ii < i_end; ++ii) {
                    auto &Rii = result.matrix[ii];
                    auto &Aii = matrix[ii];
 
                    for (int kk = k; kk < k_end; ++kk) {
                        T a = T(Aii[kk]);
                        auto &Bkk = B[kk];
 
                        for (int jj = j; jj < j_end; ++jj) {
                            Rii[jj] += a * Bkk[jj];
                        }
                    }
                }
            }
        }
    }
 
    return result;
};