矩阵C++实现

最新推荐文章于 2023-12-09 18:27:54 发布
最新推荐文章于 2023-12-09 18:27:54 发布
阅读量627 收藏
点赞数
分类专栏： c/c++基础

#ifndef __MATRIX_H__
#define __MATRIX_H__

#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <string>

using std::vector;
using std::string;
using std::cout;
using std::cin;
using std::istream;
using std::ostream;

// 任意类型矩阵类
template <typename Object>
class MATRIX
{
public:
 explicit MATRIX() : array( 0 ) {}

 MATRIX( int rows, int cols):array( rows )
 {
  for( int i = 0; i < rows; ++i )
  {
   array[i].resize( cols );
  }
 }

 MATRIX( const MATRIX<Object>& m ){ *this = m;}

 void resize( int rows, int cols );           // 改变当前矩阵大小
 bool push_back( const vector<Object>& v );   // 在矩阵末尾添加一行数据
 void swap_row( int row1, int row2 );         // 将换两行的数据

 int  rows() const{ return array.size(); }
 int  cols() const { return rows() ? (array[0].size()) : 0; }
 bool empty() const { return rows() == 0; }        // 是否为空
 bool square() const { return (!(empty()) && rows() == cols()); }  // 是否为方阵
 
 
 const vector<Object>& operator[](int row) const { return array[row]; } //[]操作符重载
 vector<Object>& operator[](int row){ return array[row]; }
 
protected:
 vector< vector<Object> > array;
};

// 改变当前矩阵大小
template <typename Object>
void MATRIX<Object>::resize( int rows, int cols )
{
 int rs = this->rows();
 int cs = this->cols();

 if ( rows == rs && cols == cs )
 {
  return;
 }
 else if ( rows == rs && cols != cs )
 {
  for ( int i = 0; i < rows; ++i )
  {
   array[i].resize( cols );
  }
 }
 else if ( rows != rs && cols == cs )
 {
  array.resize( rows );
  for ( int i = rs; i < rows; ++i )
  {
   array[i].resize( cols );
  }
 }
 else
 {
  array.resize( rows );
  for ( int i = 0; i < rows; ++i )
  {
   array[i].resize( cols );
  }
 }
}

// 在矩阵末尾添加一行
template <typename Object>
bool MATRIX<Object>::push_back( const vector<Object>& v )
{
 if ( rows() == 0 || cols() == (int)v.size() )
 {
  array.push_back( v );
 }
 else
 {
  return false;
 }

 return true;
}

// 将换两行
template <typename Object>
void MATRIX<Object>::swap_row( int row1, int row2 )
{
 if ( row1 != row2 && row1 >=0 &&
  row1 < rows() && row2 >= 0 && row2 < rows() )
 {
  vector<Object>& v1 = array[row1];
  vector<Object>& v2 = array[row2];
  vector<Object> tmp = v1;
  v1 = v2;
  v2 = tmp;
 }
}

// 矩阵转置
template <typename Object>
const MATRIX<Object> trans( const MATRIX<Object>& m )
{
 MATRIX<Object> ret;
 if ( m.empty() ) return ret;

 int row = m.cols();
 int col = m.rows();
 ret.resize( row, col );

 for ( int i = 0; i < row; ++i )
 {
  for ( int j = 0; j < col; ++j )
  {
   ret[i][j] = m[j][i];
  }
 }

 return ret;
}

//
// double类型矩阵类，用于科学计算
// 继承自MATRIX类
// 实现常用操作符重载，并实现计算矩阵的行列式、逆以及LU分解
class Matrix:public MATRIX<double>
{
public:
 Matrix():MATRIX<double>(){}
 Matrix( int c, int r ):MATRIX<double>(c,r){}
 Matrix( const Matrix& m){ *this  = m; }

 const Matrix& operator+=( const Matrix& m );
 const Matrix& operator-=( const Matrix& m );
 const Matrix& operator*=( const Matrix& m );
 const Matrix& operator/=( const Matrix& m );
};

bool  operator==( const Matrix& lhs, const Matrix& rhs );        // 重载操作符==
bool  operator!=( const Matrix& lhs, const Matrix& rhs );        // 重载操作符!=
const Matrix operator+( const Matrix& lhs, const Matrix& rhs );  // 重载操作符+
const Matrix operator-( const Matrix& lhs, const Matrix& rhs );  // 重载操作符-
const Matrix operator*( const Matrix& lhs, const Matrix& rhs );  // 重载操作符*
const Matrix operator/( const Matrix& lhs, const Matrix& rhs );  // 重载操作符/
const double det( const Matrix& m );                             // 计算行列式
const double det( const Matrix& m, int start, int end );         // 计算子矩阵行列式
const Matrix abs( const Matrix& m );                             // 计算所有元素的绝对值
const double max( const Matrix& m );                             // 所有元素的最大值
const double max( const Matrix& m, int& row, int& col);          // 所有元素中的最大值及其下标
const double min( const Matrix& m );                             // 所有元素的最小值
const double min( const Matrix& m, int& row, int& col);          // 所有元素的最小值及其下标
const Matrix trans( const Matrix& m );                           // 返回转置矩阵
const Matrix submatrix(const Matrix& m,int rb,int re,int cb,int ce);  // 返回子矩阵
const Matrix inverse( const Matrix& m );                         // 计算逆矩阵
const Matrix LU( const Matrix& m );                              // 计算方阵的LU分解
const Matrix readMatrix( istream& in = std::cin );               // 从指定输入流读入矩阵
const Matrix readMatrix( string file );                          // 从文本文件读入矩阵
const Matrix loadMatrix( string file );                          // 从二进制文件读取矩阵
void  printMatrix( const Matrix& m, ostream& out = std::cout );  // 从指定输出流打印矩阵
void  printMatrix( const Matrix& m, string file);                // 将矩阵输出到文本文件
void  saveMatrix( const Matrix& m, string file);                 // 将矩阵保存为二进制文件

#endif

Matrix.cpp文件

#include "Matrix.h"

#include <iomanip>  //用于设置输出格式

using std::ifstream;
using std::ofstream;
using std::istringstream;
using std::cerr;
using std::endl;

const Matrix& Matrix::operator+=( const Matrix& m )
{
 if ( rows() != m.rows() || rows() != m.cols() )
 {
  return *this;
 }

 int r = rows();
 int c = cols();

 for ( int i = 0; i < r; ++i )
 {
  for ( int j = 0; j < c; ++j )
  {
   array[i][j] += m[i][j];
  }
 }

 return *this;
}


const Matrix& Matrix::operator-=( const Matrix& m )
{
 if ( rows() != m.rows() || cols() != m.cols() )
 {
  return *this;
 }

 int r = rows();
 int c = cols();

 for ( int i = 0; i < r; ++i )
 {
  for ( int j = 0; j < c; ++j )
  {
   array[i][j] -= m[i][j];
  }
 }

 return *this;
}

const Matrix& Matrix::operator*=( const Matrix& m )
{
 if ( cols() != m.rows() || !m.square() )
 {
  return *this;
 }

 Matrix ret( rows(), cols() );

 int r = rows();
 int c = cols();

 for ( int i = 0; i < r; ++i )
 {
  for ( int j = 0; j < c; ++j )
  {
   double sum = 0.0;
   for ( int k = 0; k < c; ++k )
   {
    sum += array[i][k] * m[k][j];
   }
   ret[i][j] = sum;
  }
 }

 *this = ret;
 return *this;
}

const Matrix& Matrix::operator/=( const Matrix& m )
{
 Matrix tmp = inverse( m );
 return operator*=( tmp );
}


bool operator==( const Matrix& lhs, const Matrix& rhs )
{
 if ( lhs.rows() != rhs.rows() || lhs.cols() != rhs.cols() )
 {
  return false;
 }

 for ( int i = 0; i < lhs.rows(); ++i )
 {
  for ( int j = 0; j < lhs.cols(); ++j )
  {
   if ( rhs[i][j] != rhs[i][j] )
   {
    return false;
   }
  }
 }

 return true;
}

bool operator!=( const Matrix& lhs, const Matrix& rhs )
{
 return !( lhs == rhs );
}

const Matrix operator+( const Matrix& lhs, const Matrix& rhs )
{
 Matrix m;
 if ( lhs.rows() != rhs.rows() || lhs.cols() != rhs.cols() )
 {
  return m;
 }

 m = lhs;
 m += rhs;

 return m;
}

const Matrix operator-( const Matrix& lhs, const Matrix& rhs )
{
 Matrix m;
 if ( lhs.rows() != rhs.rows() || lhs.cols() != rhs.cols() )
 {
  return m;
 }

 m = lhs;
 m -= rhs;

 return m;
}

const Matrix operator*( const Matrix& lhs, const Matrix& rhs )
{
 Matrix m;
 if ( lhs.cols() != rhs.rows() )
 {
  return m;
 }

 m.resize( lhs.rows(), rhs.cols() );

 int r = m.rows();
 int c = m.cols();
 int K = lhs.cols();

 for ( int i = 0; i < r; ++i )
 {
  for ( int j = 0; j < c; ++j )
  {
   double sum = 0.0;
   for ( int k = 0; k < K; ++k )
   {
    sum += lhs[i][k] * rhs[k][j];
   }
   m[i][j] = sum;
  }
 }

 return m;
}

const Matrix operator/( const Matrix& lhs, const Matrix& rhs )
{
 Matrix tmp = inverse( rhs );
 Matrix m;

 if ( tmp.empty() )
 {
  return m;
 }

 return m = lhs * tmp;
}

inline static double LxAbs( double d )
{
 return (d>=0)?(d):(-d);
}

inline
static bool isSignRev( const vector<double>& v )
{
 int p = 0;
 int sum = 0;
 int n = (int)v.size();

 for ( int i = 0; i < n; ++i )
 {
  p = (int)v[i];
  if ( p >= 0 )
  {
   sum += p + i;
  }
 }

 if ( sum % 2 == 0 ) // 如果是偶数，说明不变号
 {
  return false;
 }
 return true;
}

// 计算方阵行列式
const double det( const Matrix& m )
{
 double ret = 0.0;

 if ( m.empty() || !m.square() ) return ret;

 Matrix N = LU( m );

 if ( N.empty() ) return ret;

 ret = 1.0;
 for ( int i = 0; i < N.cols(); ++ i )
 {
  ret *= N[i][i];
 }

 if ( isSignRev( N[N.rows()-1] ))
 {
  return -ret;
 }

 return ret;
}

// 计算矩阵指定子方阵的行列式
const double det( const Matrix& m, int start, int end )
{
 return det( submatrix(m, start, end, start, end) );
}


// 计算矩阵转置
const Matrix trans( const Matrix& m )
{
 Matrix ret;
 if ( m.empty() ) return ret;

 int r = m.cols();
 int c = m.rows();

 ret.resize(r, c);
 for ( int i = 0; i < r; ++i )
 {
  for ( int j = 0; j < c; ++j )
  {
   ret[i][j] = m[j][i];
  }
 }

 return ret;
}

// 计算逆矩阵
const Matrix  inverse( const Matrix& m )
{
 Matrix ret;

 if ( m.empty() || !m.square() )
 {
  return ret;
 }

 int n = m.rows();

 ret.resize( n, n );
 Matrix A(m);

 for ( int i = 0; i < n; ++i ) ret[i][i] = 1.0;

 for ( int j = 0; j < n; ++j )  //每一列
 {
  int p = j;
  double maxV = LxAbs(A[j][j]);
  for ( int i = j+1; i < n; ++i )  // 找到第j列中元素绝对值最大行
  {
   if ( maxV < LxAbs(A[i][j]) )
   {
    p = i;
    maxV = LxAbs(A[i][j]);
   }
  }

  if ( maxV < 1e-20 )
  {
   ret.resize(0,0);
   return ret;
  }

  if ( j!= p )
  {
   A.swap_row( j, p );
   ret.swap_row( j, p );
  }
  
  double d = A[j][j];
  for ( int i = j; i < n; ++i ) A[j][i] /= d;
  for ( int i = 0; i < n; ++i ) ret[j][i] /= d;

  for ( int i = 0; i < n; ++i )
  {
   if ( i != j )
   {
    double q = A[i][j];
    for ( int k = j; k < n; ++k )
    {
     A [i][k] -= q * A[j][k];
    }
    for ( int k = 0; k < n; ++k )
    {
     ret[i][k] -= q * ret[j][k];
    }
   }
  }
 }

 return ret;
}

// 计算绝对值
const Matrix abs( const Matrix& m )
{
 Matrix ret;

 if( m.empty() )
 {
  return ret;
 }

 int r = m.rows();
 int c = m.cols();
 ret.resize( r, c );

 for ( int i = 0; i < r; ++i )
 {
  for ( int j = 0; j < c; ++j )
  {
   double t = m[i][j];
   if ( t < 0 ) ret[i][j] = -t;
   else ret[i][j] = t;
  }
 }

 return ret;
}

// 返回矩阵所有元素的最大值
const double max( const Matrix& m )
{
 if ( m.empty() ) return 0.;
 
 double ret = m[0][0];
 int r = m.rows();
 int c = m.cols();

 for ( int i = 0; i < r; ++i )
 {
  for ( int j = 0; j < c; ++j )
  {
   if ( m[i][j] > ret ) ret = m[i][j];
  }
 }
 return ret;
}

// 计算矩阵最大值，并返回该元素的引用
const double max( const Matrix& m, int& row, int& col )
{
 if ( m.empty() ) return 0.;

 double ret = m[0][0];
 row = 0;
 col = 0;

 int r = m.rows();
 int c = m.cols();

 for ( int i = 0; i < r; ++i )
 {
  for ( int j = 0; j < c; ++j )
  {
   if ( m[i][j] > ret )
   {
    ret = m[i][j];
    row = i;
    col = j;
   }
  }
 }
 return ret;
}

// 计算矩阵所有元素最小值
const double min( const Matrix& m )
{
 if ( m.empty() ) return 0.;

 double ret = m[0][0];
 int r = m.rows();
 int c = m.cols();

 for ( int i = 0; i < r; ++i )
 {
  for ( int j = 0; j < c; ++j )
  {
   if ( m[i][j] > ret ) ret = m[i][j];
  }
 }

 return ret;
}

// 计算矩阵最小值，并返回该元素的引用
const double min( const Matrix& m, int& row, int& col)
{
 if ( m.empty() ) return 0.;

 double ret = m[0][0];
 row = 0;
 col = 0;
 int r = m.rows();
 int c = m.cols();

 for ( int i = 0; i < r; ++i )
 {
  for ( int j = 0; j < c; ++j )
  {
   if ( m[i][j] > ret )
   {
    ret = m[i][j];
    row = i;
    col = j;
   }
  }
 }

 return ret;
}

// 取矩阵中指定位置的子矩阵
const Matrix submatrix(const Matrix& m,int rb,int re,int cb,int ce)
{
 Matrix ret;
 if ( m.empty() ) return ret;

 if ( rb < 0 || re >= m.rows() || rb > re ) return ret;
 if ( cb < 0 || ce >= m.cols() || cb > ce ) return ret;

 ret.resize( re-rb+1, ce-cb+1 );

 for ( int i = rb; i <= re; ++i )
 {
  for ( int j = cb; j <= ce; ++j )
  {
   ret[i-rb][j-cb] = m[i][j];
  }
 }

 return ret;
}


inline static
int max_idx( const Matrix& m, int k, int n )
{
 int p = k;
 for ( int i = k+1; i < n; ++i )
 {
  if ( LxAbs(m[p][k]) < LxAbs(m[i][k]) )
  {
   p = i;
  }
 }
 return p;
}

// 计算方阵 M 的 LU 分解
// 其中L为对角线元素全为1的下三角阵，U为对角元素依赖M的上三角阵
// 使得 M = LU
// 返回矩阵下三角部分存储L(对角元素除外)，上三角部分存储U(包括对角线元素)
const Matrix LU( const Matrix& m )
{
 Matrix ret;

 if ( m.empty() || !m.square() ) return ret;

 int n = m.rows();
 ret.resize( n+1, n );

 for ( int i = 0; i < n; ++i )
 {
  ret[n][i] = -1.0;
 }

 for ( int i = 0; i < n; ++i )
 {
  for ( int j = 0; j < n; ++j )
  {
   ret[i][j] = m[i][j];
  }
 }

 for ( int k = 0; k < n-1; ++k )
 {
  int p = max_idx( ret, k, n );
  if ( p != k )              // 进行行交换
  {
   ret.swap_row( k, p );
   ret[n][k] = (double)p; // 记录将换信息
  }

  if ( ret[k][k] == 0.0 )
  {
   cout << "ERROR: " << endl;
   ret.resize(0,0);
   return ret;
  }

  for ( int i = k+1; i < n; ++i )
  {
   ret[i][k] /= ret[k][k];
   for ( int j = k+1; j < n; ++j )
   {
    ret[i][j] -= ret[i][k] * ret[k][j];
   }
  }
 }

 return ret;
}

//---------------------------------------------------
//                      读取和打印
//---------------------------------------------------
// 从输入流读取矩阵
const Matrix readMatrix( istream& in )
{
 Matrix M;
 string str;
 double b;
 vector<double> v;

 while( getline( in, str )  )
 {
  for ( string::size_type i = 0; i < str.size(); ++i )
  {
   if ( str[i] == ',' || str[i] == ';')
   {
    str[i] = ' ';
   }
   else if ( str[i] != '.' && (str[i] < '0' || str[i] > '9')
    && str[i] != ' ' && str[i] != '\t' && str[i] != '-')
   {
    M.resize(0,0);
    return M;
   }
  }

  istringstream sstream(str);
  v.resize(0);

  while ( sstream >> b )
  {
   v.push_back(b);
  }
  if ( v.size() == 0 )
  {
   continue;
  }
  if ( !M.push_back( v ) )
  {
   M.resize( 0, 0 );
   return M;
  }
 }

 return M;
}

// 从文本文件读入矩阵
const Matrix readMatrix( string file )
{
 ifstream fin( file.c_str() );
 Matrix M;

 if ( !fin )
 {
  cerr << "Error: open file " << file << " failed." << endl;
  return M;
 }

 M = readMatrix( fin );
 fin.close();

 return M;
}

// 将矩阵输出到指定输出流
void printMatrix( const Matrix& m, ostream& out )
{
 if ( m.empty() )
 {
  return;
 }

 int r = m.rows();
 int c = m.cols();

 int n = 0;              // 数据小数点前最大位数
 double maxV = max(abs(m));
 while( maxV >= 1.0 )
 {
  maxV /= 10;
  ++n;
 }
 if ( n == 0 ) n = 1;    // 如果最大数绝对值小于1，这小数点前位数为1，为数字0
 int pre = 4;            // 小数点后数据位数
 int wid = n + pre + 3;  // 控制字符宽度=n+pre+符号位+小数点位

 out<<std::showpoint;
 out<<std::setiosflags(std::ios::fixed);
 out<<std::setprecision( pre );
 for ( int i = 0; i < r; ++i )
 {
  for ( int j = 0; j < c; ++j )
  {
   out<<std::setw(wid) << m[i][j];
  }
  out << endl;
 }

 out<<std::setprecision(6);
 out<<std::noshowpoint;
}

// 将矩阵打印到指定文件
void printMatrix( const Matrix& m, string file )
{
 ofstream fout( file.c_str() );
 if ( !fout ) return;

 printMatrix( m, fout );
 fout.close();
}

// 将矩阵数据存为二进制文件
void saveMatrix( const Matrix& m, string file )
{
 if ( m.empty() ) return;

 ofstream fout(file.c_str(), std::ios_base::out|std::ios::binary );
 if ( !fout ) return;

 int r = m.rows();
 int c = m.cols();
 char Flag[12] = "MATRIX_DATA";
 fout.write( (char*)&Flag, sizeof(Flag) );
 fout.write( (char*)&r, sizeof(r) );
 fout.write( (char*)&c, sizeof(c) );

 for ( int i = 0; i < r; ++i )
 {
  for ( int j = 0; j < c; ++j )
  {
   double t = m[i][j];
   fout.write( (char*)&t, sizeof(t) );
  }
 }

 fout.close();
}

// 从二进制文件load矩阵
const Matrix loadMatrix( string file )
{
 Matrix m;

 ifstream fin( file.c_str(), std::ios_base::in|std::ios::binary );
 if ( !fin ) return m;

 char Flag[12];
 fin.read((char*)&Flag, sizeof(Flag));

 string str( Flag );
 if ( str != "MATRIX_DATA" )
 {
  return m;
 }

 int r, c;
 fin.read( (char*)&r, sizeof(r) );
 fin.read( (char*)&c, sizeof(c) );

 if ( r <=0 || c <=0 ) return m;

 m.resize( r, c );
 double t;

 for ( int i = 0; i < r; ++i )
 {
  for ( int j = 0; j < c; ++j )
  {
   fin.read( (char*)&t, sizeof(t) );
   m[i][j] = t;
  }
 }

 return m;
}

本文来自http://blog.csdn.net/yangalbert/article/details/7388419#

monaso
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ FFTW3的fftw_plan_dft_r2c_2d()和Eigen::MatrixXd的傅里叶正变换
yanxun098的博客
06-09 3006
Eigen::MatrixXd和fftw3的fftw_plan_dft_r2c_2d()的傅里叶正变换
协方差矩阵C++实现
11-07
协方差矩阵是一种统计工具，用于衡量两个或多个随机变量之间的相互...以上就是使用C++实现协方差矩阵的基本过程。通过理解协方差的统计意义，结合C++编程技巧，你可以创建一个能够处理各种数据集的协方差矩阵计算程序。
Eigen矩阵在矩阵后添加矩阵(不使用中间矩阵)和删除矩阵前部分矩阵(删除矩阵前面几列)操作，
weixin_44365021的博客
11-10 1899
1.首先是矩阵的定义和初始化 //定义 test1、test2都会动态矩阵 Matrix<qint16, Dynamic, Dynamic> test1,test2; //设定矩阵 test1、test2的行列数 test1.resize(4,6); test2.resize(4,3); //矩阵初始化 int i,j; for ( i=0 ; i<test1.rows(); i++ ) { for ( j=0 ; j<test1.cols() ; j++) {
opencv 二维mat矩阵增加一行
诺有缸的高飞鸟的博客
04-28 2857
目录opencv 二维mat矩阵增加一行用途代码输出结果参考完 opencv 二维mat矩阵增加一行 用途 有时候需要让矩阵增加一行，遇上的实例是我想把求得的仿射矩阵(2x3)变成一个透视变换矩阵(3x3)方便后面的运算，只需要增加{0,0,1}到最后一行就可以了；实际上透视变换矩阵的最后一行是{0,0,1}时，就是一个仿射变换 代码 #include <opencv2/opencv.hpp> #include <iostream> using namespace cv; us
XJOI 9552 矩阵游戏C++题解
LBZ的博客
09-09 310
小明最近沉迷于一个矩阵游戏，游戏规则是：给定一个数字矩阵。该矩阵行和列相同，对于第i行，你需要将第i行的最小值（若出现相同的，选择列号较小的）和第i列的最大值（若出现相同的，选择行号较小的）交换，然后将第i行的数从小到大排序。要求输出最后的矩阵。第1行为一个整数n（不超过100），表示矩阵的行列数。接下来n行，每行n个整数。
c++矩阵——超实用的数据结构
yzc_qiuse的博客
12-09 4566
矩阵是一个二维的数学结构，由行和列组成。在C++中，我们可以使用数组或者向量来表示矩阵。矩阵广泛应用于线性代数、图像处理、机器学习等领域。C++中的矩阵是一个重要的数学概念，在各种领域都有广泛的应用。我们可以使用数组或者向量来表示矩阵，并进行各种运算，如加法、减法、乘法和转置等。熟练掌握矩阵的表示和运算，对于理解和解决实际问题非常有帮助。今天的文章就到这里啦，三连必回qwq！
稀疏矩阵c++实现
03-14
本代码是系数矩阵的c++实现，在数据结构中，有很多的数据结构，比如树，栈，队列，图，数组，链表等，而矩阵就是其中的一个简单应用。
搜索矩阵C++实现：二分查找Z形查找
最新发布
12-17
这个问题来源于一个C++实现的场景，涉及到矩阵操作、二分查找以及Z形查找等核心概念。 首先，我们要理解题目给出的矩阵特性：每一行的元素从左到右是升序排列的，每一列的元素从上到下也是升序排列的。这样的矩阵...
广义逆矩阵 C++实现
03-07
本主题将围绕“广义逆矩阵的C++实现”进行深入探讨。 广义逆矩阵，通常用\( A^+ \)表示，是矩阵\( A \)的一个解算子，满足以下条件： \[ AA^+A = A \] \[ A^+AA^+ = A^+ \] 对于方阵，如果它是可逆的，那么广义逆...
螺旋矩阵 C++实现
10-28
1 2 3 4 5 6…………………………………………………………
和矩阵相关的头文件matrix.h
12-17
调试C++程序时，提示not such file"matrix.h"时，只需要在头文件中新建一个matrix.h文件，将本文档中的内容复制过去即可
MatrixXd 简单处理程序
明道士
07-04 4440
原文地址：https://www.cnblogs.com/VVingerfly/p/8037490.html #include <iostream> #include <vector> #include <Eigen/Dense> using namespace std; using namespace Eigen; void array2eigenM...
Eigen的简单使用（转）
hscoder的博客
08-25 3495
Eigen是可以用来进行线性代数、矩阵、向量操作等运算的C++库，它里面包含了很多算法。它的License是MPL2。它支持多平台。 Eigen采用源码的方式提供给用户使用，在使用时只需要包含Eigen的头文件即可进行使用。之所以采用这种方式，是因为Eigen采用模板方式实现，由于模板函数不支持分离编译，所以只能提供源码而不是动态库的方式供用户使用。 矩阵的定义：Eigen中关于矩阵
矩阵基本运算（C++）
qq_41696018的博客
08-11 2万+
闲着没事，将以前利用C++实现的矩阵各种运算整理了一下，分享一下，矩阵运算包括： 1、二维矩阵创建6、两矩阵上下叠加 2、两矩阵相加 7、矩阵左右叠加 3、两矩阵相减 8、矩阵转置 4、两矩阵相乘 ...
C++项目练手：矩阵类的功能实现
weixin_51958878的博客
06-13 3430
C++项目练手：矩阵类的功能实现 C++课程设计：矩阵类的相关功能实现 矩阵简述： 实数矩阵是由一个按照长方阵列排列的实数集合。除数据外，两个实数矩阵可以进行加法和乘法运算，一个矩阵也可以和一个实数相乘，得到一个新的矩阵，请基于抽象出的矩阵的属性和方法，定义和实现一个矩阵类，并编写主函数，测试矩阵对象的构造和测试。 功能实现要求： 在缺省情况下，构造一个4*4的数据全为0的矩阵 可以按给定的行数和列数，构造一个值为全0的矩阵 可以使用给定的矩阵构造一个新的矩阵（定义并使用拷贝构造函数） 可以获取矩阵中的给
C++11标准|用C++写一个矩阵(包含了如何用cmake构建一个工程)
Rolandxxx的博客
08-02 4337
1.改进版2的矩阵乘法是很慢的，相比matlab差了至少1w倍，我们可以采取以下方式提速，cpu的并行指令，gpu的并行计算，但这些技术都太深入了。因为改进版2的矩阵乘法有三层for循环，版本1的k在最内层，版本2的i在最内层，版本3的j在最内层，用版本3时就可以实现缓存优化，对程序效率有所提高。3.在Matrix的成员函数里重载了()符号，函数名就是operator()，如A是Matrix类的对象，重载后就可以这样用，A.operator()(2,1) = 77等效于A(2, 1) = 77。
C++(数据结构与算法):14---矩阵介绍
董哥的黑板报
11-26 1934
一、矩阵介绍 一个矩m*b的矩阵是一个m行、n列的表，如下图所示： m和n是矩阵的维数 矩阵与二维数组不同，矩阵的索引从1开始 二、矩阵的运算 矩阵最常见的操作是：矩阵转置、矩阵相加、矩阵相乘 矩阵转置 一个m*n的矩阵M转置之后是一个n*m的矩阵，它们的关系是： 矩阵相加 两个矩阵仅当维数相同（行数、列数分别相同）时才可以相加 两个m*n的矩阵A和B相加之后是一个m*n...
C/C++实现矩阵各种运算
热门推荐
ACE的博客
12-23 5万+
程序很简单，重要的是二维指针的动态分配内存 type **Matrix ;//row为行,col为列 Matrix=(type **) malloc(row*sizeof(type *)) ; for(int i=0; i&lt;row; i++) Matrix[i] = (type *)malloc(col * sizeof(type )); 类似数组a[2][...
C++实现两个矩阵相乘
cxcbupt
04-29 3万+
#include using namespace std; #define SIZE_M 2 #define SIZE_N 3 #define SIZE_S 4 int main(){ int matrix_a[SIZE_M] [SIZE_N]={{1,2,3},{4,5,6}};//a矩阵2X3 int matrix_b[SIZE_N] [SIZE_S]={{1,2,3,4},{5,6,
二次型矩阵相乘可逆矩阵C++实现
05-30
以下是C++代码实现二次型矩阵相乘可逆矩阵： ```cpp #include #include #include using namespace std; const int MAXN=105; const double eps=1e-8; int n; double a[MAXN][MAXN],b[MAXN][MAXN],c[MAXN][MAXN],d...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值