Размер матрицы

#ifndef VECTOR_HPP
#define VECTOR_HPP
 
#include <cstdlib>
 
namespace my
{
    class vector
    {
 
    public:
 
        vector(size_t size = 0);
        vector(double val, size_t size);
        vector(const vector& rhs);
        ~vector();
 
        void resize(size_t size); // Изменить размер вектора
        size_t size() const; // Размер вектора
 
        vector& operator = (const vector& rhs);
        double& operator [] (size_t index); // Доступ по индексу
 
        // Умножение на число (с обоих сторон)
        vector operator * (double val) const;
        friend vector operator * (double val, const vector& rhs);
 
        // Деление на число
        vector operator / (double val) const;
 
        double operator * (const vector& rhs) const; // Скалярное произведение
        vector operator + (const vector& rhs) const; // Сложение векторов
        vector operator - (const vector& rhs) const; // Вычитание векторов
 
        // Сравнение векторов
        bool operator == (const vector& rhs) const;
        bool operator != (const vector& rhs) const;
 
    private:
 
        size_t  m_nSize;
        double* m_pdVec;
    };
}
#endif // VECTOR_HPP

#include "vector.hpp"
 
#include <stdexcept>
 
namespace my
{
    vector::vector(size_t size)
        : m_nSize(size)
    {
        if(size)
            m_pdVec = new double[m_nSize]();
        else
            m_pdVec = NULL;
    }
 
    vector::vector(double val, size_t size)
        : m_nSize(size)
    {
        if(m_nSize)
        {
            m_pdVec = new double[m_nSize];
            for(size_t i = 0; i < m_nSize; ++i)
                m_pdVec[i] = val;
        }
        else
            m_pdVec = NULL;
    }
 
    vector::vector(const vector& rhs)
        : m_nSize(rhs.m_nSize)
    {
        if(m_nSize)
        {
            m_pdVec = new double[m_nSize];
            for(size_t i = 0; i < m_nSize; ++i)
                m_pdVec[i] = rhs.m_pdVec[i];
        }
        else
            m_pdVec = NULL;
    }
 
    vector::~vector()
    {
        if(m_nSize)
            delete[] m_pdVec;
    }
 
    void vector::resize(size_t size)
    {
        if(m_nSize == size)
            return;
        if(m_nSize)
            delete[] m_pdVec;
        m_nSize = size;
        m_pdVec = new double[m_nSize]();
    }
 
    size_t vector::size() const
    {
        return m_nSize;
    }
 
    vector& vector::operator = (const vector& rhs)
    {
        this->resize(rhs.m_nSize);
        for(size_t i = 0; i < m_nSize; ++i)
            m_pdVec[i] = rhs.m_pdVec[i];
        return *this;
    }
 
    double& vector::operator [] (size_t index)
    {
        if(index >= m_nSize)
            throw(std::out_of_range("Vector: the index is out of range"));
        return m_pdVec[index];
    }
 
    vector vector::operator * (double val) const
    {
        vector temp(m_nSize);
        for(size_t i = 0; i < m_nSize; ++i)
            temp.m_pdVec[i] = m_pdVec[i] * val;
        return temp;
    }
 
    vector operator * (double val, const vector& rhs)
    {
        vector temp(rhs.m_nSize);
        for(size_t i = 0; i < rhs.m_nSize; ++i)
            temp.m_pdVec[i] = rhs.m_pdVec[i] * val;
        return temp;
    }
 
    vector vector::operator / (double val) const
    {
        if(!val)
            throw(std::domain_error("Vector: dividing by zero"));
        vector temp(m_nSize);
        for(size_t i = 0; i < m_nSize; ++i)
            temp.m_pdVec[i] = m_pdVec[i] / val;
        return temp;
    }
 
    double vector::operator * (const vector& rhs) const
    {
        if(m_nSize != rhs.m_nSize)
            throw(std::domain_error("Vector: incorrect dimensions"));
        double retval = 0;
        for(size_t i = 0; i < m_nSize; ++i)
            retval += m_pdVec[i] * rhs.m_pdVec[i];
        return retval;
    }
 
    vector vector::operator + (const vector& rhs) const
    {
        if(m_nSize != rhs.m_nSize)
            throw(std::domain_error("Vector: incorrect dimensions"));
        vector temp(m_nSize);
        for(size_t i = 0; i < m_nSize; ++i)
            temp.m_pdVec[i] = m_pdVec[i] + rhs.m_pdVec[i];
        return temp;
    }
 
    vector vector::operator - (const vector& rhs) const
    {
        if(m_nSize != rhs.m_nSize)
            throw(std::domain_error("Vector: incorrect dimensions"));
        vector temp(m_nSize);
        for(size_t i = 0; i < m_nSize; ++i)
            temp.m_pdVec[i] = m_pdVec[i] - rhs.m_pdVec[i];
        return temp;
    }
 
    bool vector::operator == (const vector& rhs) const
    {
        if(m_nSize != rhs.m_nSize)
            return false;
        for(size_t i = 0; i < m_nSize; ++i)
            if(m_pdVec[i] != rhs.m_pdVec[i])
                return false;
        return true;
    }
 
    bool vector::operator != (const vector& rhs) const
    {
        return !(*this == rhs);
    }
}

#ifndef MATRIX_HPP
#define MATRIX_HPP
 
#include "vector.hpp"
 
namespace my
{
    class matrix
    {
 
    public:
 
        matrix(size_t row, size_t col);
        matrix(double val, size_t row, size_t col);
        matrix(const matrix& rhs);
        ~matrix();
 
        void resize(size_t row, size_t col); // Изменить размер матрицы
        size_t rows() const; // Число строк
        size_t cols() const; // Число столбцов
 
        // Единичная и нулевая матрицы заданных размеров
        matrix E(size_t row, size_t col) const;
        matrix O(size_t row, size_t col) const;
 
        // Транспонирование матрицы
        matrix transpose() const;
 
        matrix& operator = (const matrix& rhs);
        vector& operator [] (size_t index); // Доступ по индексу
 
        // Умножение на число (с обоих сторон)
        matrix operator * (double val) const;
        friend matrix operator * (double val, const matrix& rhs);
 
        // Деление на число
        matrix operator / (double val) const;
 
        // Умножение на матрицы на вектор
        vector operator * (const vector& vec) const;
 
        // Умножение матриц
        matrix operator * (const matrix& rhs) const;
 
        // Возведение матрицы в степень (только для квадратных матриц!)
        matrix pow(size_t exp) const;
 
        // Сложение и вычитание матриц
        matrix operator + (const matrix& rhs) const;
        matrix operator - (const matrix& rhs) const;
 
        // Сравнение матриц
        bool operator == (const matrix& rhs) const;
        bool operator != (const matrix& rhs) const;
 
        //double determinant() const; // Определитель
        //matrix invertible() const; // Обратная матрица
 
    private:
 
        // "Быстрое" возведение в степень
        matrix fastpow(const matrix& base, size_t exp) const;
 
        size_t  m_nRow;
        size_t  m_nCol;
        vector* m_pvMatrix;
    };
}
 
#endif // MATRIX_HPP

#include "matrix.hpp"
 
#include <stdexcept>
 
namespace my
{
    matrix::matrix(size_t row, size_t col)
        : m_nRow(row), m_nCol(col)
    {
        if(m_nRow)
        {
            m_pvMatrix = new vector[m_nRow];
            for(size_t i = 0; i < m_nRow; ++i)
                m_pvMatrix[i] = vector(m_nCol);
        }
        else
            m_pvMatrix = NULL;
    }
 
    matrix::matrix(double val, size_t row, size_t col)
        : m_nRow(row), m_nCol(col)
    {
        if(m_nRow)
        {
            m_pvMatrix = new vector[m_nRow];
            for(size_t i = 0; i < m_nRow; ++i)
                m_pvMatrix[i] = vector(val, m_nCol);
        }
        else
            m_pvMatrix = NULL;
    }
 
    matrix::matrix(const matrix &rhs)
        : m_nRow(rhs.m_nRow), m_nCol(rhs.m_nCol)
    {
        if(m_nRow)
        {
            m_pvMatrix = new vector[m_nRow];
            for(size_t i = 0; i < m_nRow; ++i)
                m_pvMatrix[i] = rhs.m_pvMatrix[i];
        }
        else
            m_pvMatrix = NULL;
    }
 
    matrix::~matrix()
    {
        if(m_nRow)
            delete[] m_pvMatrix;
    }
 
    void matrix::resize(size_t row, size_t col)
    {
        if(row != m_nRow)
        {
            if(m_nRow)
                delete[] m_pvMatrix;
            m_nRow = row;
            m_pvMatrix = new vector[m_nRow];
        }
        for(size_t i = 0; i < m_nRow; ++i)
            m_pvMatrix[i].resize(col);
    }
 
    size_t matrix::rows() const
    {
        return m_nRow;
    }
 
    size_t matrix::cols() const
    {
        return m_nCol;
    }
 
    matrix matrix::E(size_t row, size_t col) const
    {
        matrix temp(row, col);
        for(size_t i = 0; i < row; ++i)
            temp.m_pvMatrix[i][i] = 1;
        return temp;
    }
 
    matrix matrix::O(size_t row, size_t col) const
    {
        return matrix(row, col);
    }
 
    matrix matrix::transpose() const
    {
        matrix temp(m_nCol, m_nRow);
        for(size_t i = 0; i < m_nRow; ++i)
            for(size_t j = 0; j < m_nCol; ++j)
                temp.m_pvMatrix[j][i] = m_pvMatrix[i][j];
        return temp;
    }
 
    matrix& matrix::operator = (const matrix& rhs)
    {
        this->resize(rhs.m_nRow, rhs.m_nCol);
        for(size_t i = 0; i < m_nRow; ++i)
            m_pvMatrix[i] = rhs.m_pvMatrix[i];
        return *this;
    }
 
    vector& matrix::operator [] (size_t index)
    {
        if(index >= m_nRow)
            throw(std::out_of_range("Matrix: the index is out of range"));
        return m_pvMatrix[index];
    }
 
    matrix matrix::operator * (double val) const
    {
        matrix temp(m_nRow, m_nCol);
        for(size_t i = 0; i < m_nRow; ++i)
            temp.m_pvMatrix[i] = m_pvMatrix[i] * val;
        return temp;
    }
 
    matrix operator * (double val, const matrix& rhs)
    {
        matrix temp(rhs.m_nRow, rhs.m_nCol);
        for(size_t i = 0; i < temp.m_nRow; ++i)
            temp.m_pvMatrix[i] = rhs.m_pvMatrix[i] * val;
        return temp;
    }
 
    matrix matrix::operator / (double val) const
    {
        if(!val)
            throw(std::domain_error("Matrix: dividing by zero"));
        matrix temp(m_nRow, m_nCol);
        for(size_t i = 0; i < m_nRow; ++i)
            temp.m_pvMatrix[i] = m_pvMatrix[i] / val;
        return temp;
    }
 
    vector matrix::operator * (const vector& vec) const
    {
        if(m_nCol != vec.size())
            throw(std::domain_error("Matrix: incorrect dimensions"));
        vector temp(m_nRow);
        for(size_t i = 0; i < m_nRow; ++i)
            temp[i] = m_pvMatrix[i] * vec;
        return temp;
    }
 
    matrix matrix::operator * (const matrix& rhs) const
    {
        if(m_nCol != rhs.m_nRow)
            throw(std::domain_error("Matrix: incorrect dimensions"));
        matrix ret(m_nRow, rhs.m_nCol);
        matrix temp = rhs.transpose();
        for(size_t i = 0; i < m_nRow; ++i)
            for(size_t j = 0; j < rhs.m_nCol; ++j)
                ret.m_pvMatrix[i][j] = m_pvMatrix[i] * temp.m_pvMatrix[j];
        return ret;
    }
 
    matrix matrix::pow(size_t exp) const
    {
        if(m_nRow != m_nCol)
            throw(std::domain_error("Matrix: not square matrix"));
        return fastpow((*this), exp);
    }
 
    matrix matrix::fastpow(const matrix& base, size_t exp) const
    {
        if(!exp)
            return matrix::E(m_nRow, m_nCol);
        if(exp & 1)
            return base * fastpow(base, --exp);
        return fastpow(base, (exp / 2)) * fastpow(base, (exp / 2));
    }
 
    matrix matrix::operator + (const matrix& rhs) const
    {
        if((m_nRow != rhs.m_nRow) || (m_nCol != rhs.m_nCol))
            throw(std::domain_error("Matrix: incorrect dimensions"));
        matrix temp(m_nRow, m_nCol);
        for(size_t i = 0; i < m_nRow; ++i)
            temp.m_pvMatrix[i] = m_pvMatrix[i] + rhs.m_pvMatrix[i];
        return temp;
    }
 
    matrix matrix::operator - (const matrix& rhs) const
    {
        if((m_nRow != rhs.m_nRow) || (m_nCol != rhs.m_nCol))
            throw(std::domain_error("Matrix: incorrect dimensions"));
        matrix temp(m_nRow, m_nCol);
        for(size_t i = 0; i < m_nRow; ++i)
            temp.m_pvMatrix[i] = m_pvMatrix[i] - rhs.m_pvMatrix[i];
        return temp;
    }
 
    bool matrix::operator == (const matrix& rhs) const
    {
        if((m_nRow != rhs.m_nRow) || (m_nCol != rhs.m_nCol))
            return false;
        for(size_t i = 0; i < m_nRow; ++i)
            if(m_pvMatrix[i] != rhs.m_pvMatrix[i])
                return false;
        return true;
    }
 
    bool matrix::operator != (const matrix& rhs) const
    {
        return !(*this == rhs);
    }
}

#include <iostream>
#include <cstdlib>
#include <iomanip>
 
#include "matrix.hpp"
#include "vector.hpp"
 
#define boolDebug(EXP) std::cout << std::boolalpha << #EXP " : " \
    << (EXP) << std::endl
 
void printM(my::matrix& m, const char* name)
{
    std::cout << "Matrix \'" << name << "\':" << std::endl;
    for(size_t i = 0; i < m.rows(); ++i, std::cout << std::endl)
        for(size_t j = 0; j < m.cols(); ++j)
            std::cout << std::left << std::setw(8) << m[i][j];
}
 
void initM(my::matrix& m)
{
    for(size_t i = 0; i < m.rows(); ++i)
        for(size_t j = 0; j < m.cols(); ++j)
            m[i][j] = i + j + i * j;
}
 
int main()
{
    try
    {
        my::matrix m32(3, 2);
        initM(m32);
        printM(m32, "m32");
        my::matrix m23(2, 3);
        initM(m23);
        printM(m23, "m23");
        boolDebug(m23 == m32);
        boolDebug(m23 == m32.transpose());
        my::matrix m33 = m32 * m23;
        printM(m33, "m33");
        my::matrix check(3, 3);
        for(size_t i = 0, di = 1, dj = 2;
            i < check.rows(); ++i, di += 2, dj += 5)
            for(size_t j = 0, val = di; j < check.cols(); ++j, val += dj)
                check[i][j] = val;
        printM(check, "check");
        boolDebug(m33 == check);
        my::matrix m22(2, 2);
        initM(m22);
        printM(m22, "m22");
        my::matrix m22_pow5 = m22.pow(5);
        my::matrix pow5_check = m22 * m22 * m22 * m22 * m22;
        printM(pow5_check, "(m22)^5_check");
        printM(m22_pow5, "(m22)^5");
        boolDebug(m22_pow5 == pow5_check);
        my::matrix m22_plus = m22 + m22_pow5;
        my::matrix m22_minus = m22 - m22_pow5;
        printM(m22_plus, "m22_plus");
        printM(m22_minus, "m22_minus");
        my::matrix E33 = m22.E(3, 3);
        my::matrix E33_check = m33 * E33;
        printM(E33_check, "E33_check");
        boolDebug(m33 == E33_check);
    }
    catch(std::exception& e)
    {
        std::cerr << e.what() << std::endl;
        return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;
}