c++矩阵运算

优化了一些算法

#pragma once

#include <iostream>

#include <iomanip>

#include <string>

#define OVERFLOWED 1E-12

class Matrix

{

public:

    Matrix(int m, int n);             //构建一个m*n的全零矩阵

    Matrix(int n);                 //构建一个n*n的单位矩阵

    Matrix(const Matrix &);         //拷贝构造函数，深拷贝

    Matrix(double* items, int m, int n);//根据数组拷贝一个矩阵

    ~Matrix();

    static Matrix FromFile(std::string file);

    int getRowNum() const;                //返回矩阵的行数

    int getColNum() const;                //返回矩阵的列数

    Matrix Trans() const;                //将矩阵转置

    double get(int i, int j) const;            //返回矩阵第i行j列元素

    void set(int i, int j, double val);        //设置矩阵第i行j列元素

    Matrix operator +(const Matrix &m);         //两个矩阵相加

    Matrix operator -(const Matrix &m);         //两个矩阵相减

    Matrix operator *(const Matrix &m);         //两个矩阵相乘

    Matrix operator *(const double f);         //矩阵乘以常数

    Matrix& operator=(const Matrix& m);

    Matrix Inverse();

    friend std::ostream& operator <<(std::ostream &os, const Matrix &m);

private:

    double *item;        //指向矩阵首元素

    int rowNum;        //矩阵行数

    int colNum;        //矩阵列数

private:

    //矩阵初等行变换

    //如果j=-1,则对i扩大multiply倍

    //如果j在取值范围内，则将第i行扩大multiply倍加到j行

    void RowSwap(int i, int j, double multiply);

    //交换两行

    void RowSwap(int i, int j);

    void FlowOver();

};

#include "Matrix.h"

#include <vector>

#include <cmath>

#include <fstream>

#include <sstream>

using namespace std;

Matrix::Matrix(int m, int n)

{

    if (m <  || n < )

    {

        cout << "矩阵大小不能为负\n";

        return;

    }

    rowNum = m;

    colNum = n;

    item = new double[m*n];

    for (int i = ; i < m*n; i++)

    {

        item[i] = ;

    }

}

//也可用二维数组初始化

Matrix::Matrix(double* items, int m, int n)

{

    rowNum = m;

    colNum = n;

    item = new double[m*n];

    for (int i = ; i < colNum*rowNum; i++)

    {

        item[i] = items[i];

    }

}

Matrix::Matrix(int n)

{

    rowNum = colNum = n;

    item = new double[n*n];

    for (int i = ; i < n; i++)

    {

        for (int j = ; j < n; j++)

        {

            if (i == j)

                set(i, j, 1.0);

            else

                set(i, j, );

        }

    }

}

Matrix::Matrix(const Matrix &M)

{

    colNum = M.colNum;

    rowNum = M.rowNum;

    //这里不能对指针直接赋值,复制对求逆、转置等操作会影响原矩阵

    item = new double[colNum*rowNum];

    for (int i = ; i < colNum*rowNum; i++)

    {

        item[i] = M.item[i];

    }

}

Matrix& Matrix::operator=(const Matrix & M)

{

    colNum = M.colNum;

    rowNum = M.rowNum;

    if (item != nullptr) delete[] item;

    item = new double[colNum*rowNum];

    for (int i = ; i < colNum*rowNum; i++)

    {

        item[i] = M.item[i];

    }

    return *this;

}

Matrix Matrix::FromFile(std::string file)

{

    ifstream read(file);

    if (!read.is_open())

    {

        cout << "Matrix::未能打开文件\n";

    }

    int rows = ;

    string line;

    vector<double> nums;

    while (getline(read, line))

    {

        istringstream record(line);

        double num = 0.0;

        while (record >> num)  nums.push_back(num);

        rows++;

    }

    return Matrix(&(*nums.begin()), rows, nums.size() / rows);

}

Matrix::~Matrix()

{

    delete[] item;

}

double Matrix::get(int i, int j) const

{

    return item[i*colNum + j];

}

void Matrix::set(int i, int j, double value)

{

    item[i*colNum + j] = value;

}

void Matrix::RowSwap(int i, int j, double multiply)

{

    if (j == -)

    {

        for (int k = ; k < colNum; k++)

        {

            set(i, k, multiply*get(i, k));

        }

    }

    else

    {

        for (int k = ; k < colNum; k++)

        {

            set(j, k, multiply*get(i, k) + get(j, k));

        }

    }

}

void Matrix::RowSwap(int i, int j)

{

    Matrix _copy = *this;

    for (int k = ; k < colNum; k++)

    {

        double swap = _copy.get(j, k);

        set(j, k, _copy.get(i, k));

        set(i, k, swap);

    }

}

Matrix Matrix::Trans() const

{

    Matrix _copy = *this;

    _copy.rowNum = this->colNum;

    _copy.colNum = this->rowNum;

    for (int i = ; i < _copy.rowNum; i++)

    {

        for (int j = ; j < _copy.colNum; j++)

        {

            _copy.set(i, j, get(j, i));

        }

    }

    return _copy;

}

int Matrix::getRowNum() const

{

    return rowNum;

}

int Matrix::getColNum() const

{

    return colNum;

}

ostream& operator <<(ostream &os, const Matrix &m)

{

    for (int i = ; i < m.rowNum; i++)

    {

        for (int j = ; j < m.colNum; j++)

            os << std::setw() << std::fixed << std::setprecision() << m.get(i, j) << " ";

        os << "\n";

    }

    os.flush();

    return os;

}

Matrix Matrix::operator +(const Matrix &m)

{

    if (m.colNum != colNum || m.rowNum != rowNum) return *this;

    Matrix _copy = *this;

    for (int i = ; i < rowNum; i++)

    {

        for (int j = ; j < colNum; j++)

        {

            _copy.set(i, j, get(i, j) + m.get(i, j));

        }

    }

    return _copy;

}

Matrix Matrix::operator -(const Matrix &m)

{

    if (m.colNum != colNum || m.rowNum != rowNum) return *this;

    Matrix _copy = *this;

    for (int i = ; i < rowNum; i++)

    {

        for (int j = ; j < colNum; j++)

        {

            _copy.set(i, j, get(i, j) - m.get(i, j));

        }

    }

    return _copy;

}

Matrix Matrix::operator *(const double f)

{

    Matrix _copy = *this;

    for (int i = ; i < rowNum; i++)

    {

        for (int j = ; j < colNum; j++)

        {

            _copy.set(i, j, get(i, j)*f);

        }

    }

    return _copy;

}

Matrix Matrix::operator *(const Matrix &m)

{

    if (colNum != m.rowNum)

    {

        cout << "无法相乘！";

        return *this;

    }

    Matrix _copy(rowNum, m.getColNum());

    for (int i = ; i < rowNum; i++)

    {

        for (int j = ; j < m.colNum; j++)

        {

            double sum = ;

            for (int k = ; k < m.rowNum; k++)

            {

                sum += get(i, k)*m.get(k, j);

            }

            _copy.set(i, j, sum);

        }

    }

    return _copy;

}

Matrix Matrix::Inverse()

{

    Matrix _copy = *this;

    //变换结果

    Matrix result(colNum);

    if (colNum != rowNum)

    {

        cout << "矩阵不可逆！" << endl;

        return *this;

    }

    for (int i = ; i < rowNum; i++)

    {

        int MaxRow = i;

        //首先找到第i列的绝对值最大的数，并将该行和第i行互换

        double max = abs(_copy.get(i, i));

        for (int j = i; j < colNum; j++)

        {

            if (abs(_copy.get(j, i))>max)

            {

                max = abs(_copy.get(j, i));

                MaxRow = j;

            }

        }

        //交换j，i两行

        if (MaxRow != i)

        {

            result.RowSwap(i, MaxRow);

            _copy.RowSwap(i, MaxRow);

        }

        //将第i行做初等行变换，将第一个非0元素化为1

        double r = 1.0 / _copy.get(i, i);

        _copy.RowSwap(i, -, r);

        result.RowSwap(i, -, r);

        //消元

        for (int j = ; j < rowNum; j++)

        {

            if (j == i) continue;

            r = -_copy.get(j, i);

            _copy.RowSwap(i, j, r);

            result.RowSwap(i, j, r);

        }

    }

    //result.FlowOver();

    return result;

}

void Matrix::FlowOver()

{

    for (int i = ; i < rowNum;i++)

    {

        for (int j = ; j < colNum;j++)

        {

            if (abs(get(i, j)) <= OVERFLOWED) set(i, j, );

        }

    }

}

巴特西

c++矩阵运算

最新文章

热门文章