3.[C++] 不新不好的矩阵运算类2024-02-08

4.[C++] 关于矩阵运算类的历史残次品记录2024-02-08 5.[C++] 基于字符串的高精度容器 3.02024-02-15 6.[C++] 封装树状数组2024-02-18 7.[C++] 封装了个...滑动窗口2024-02-21 8.[C++] 对拍模板2024-02-22 9.[C++] Rander2024-05-22 10.[namespace hdk] StringAddition_InFix2024-06-10 11.[namespace hdk] ordered_vector2024-07-04 12.[namespace hdk] Balanced_tree 整合2024-07-09 13.[namespace hdk] 向量 direct_vector2024-07-13 14.[namespace hdk] 64位 bitset2024-07-22 15.[namespace hdk] diff.h2024-07-25 16.[namespace hdk] modint2024-09-13

Updated : 彻底修好了(乐)

成员变量

int n 矩阵行
int m 矩阵列
int mod 运算关于mod取模
bool ifmod 若mod为0则为0，否则为1. 主要用于加快运行速度.
unsigned long long mat 矩阵

成员函数

void clear() 清空所有成员变量
void setmod(int x) 设置mod的值为x
void resize(int nsize,int msize) 设置矩阵尺寸
void fill(int x) 把矩阵全部元素填充为x
void fill(int x,int startn,int endn,int startm,int endm) 填充区间[(startn,startm),(endn,endm)]
void fillmain(int x) 把主对角线填充为x
void fillsec(int x) 把副对角线填充为x
void opposite() 把全部元素取相反数
void packed_clear(int nsize,int msize,int filln,int mod) 组合初始化，相当于前四个成员函数加和.
void packed_clear(vector<vector>,int mod=0) 用嵌套 vector 进行组合初始化
void input() 输入尺寸与矩阵
void input(int nsize,int msize) 输入指定尺寸的矩阵
void inputn(int nsize) 输入列尺寸，并输入指定行尺寸的矩阵
void inputm(int msize) 输入行尺寸，并输入指定列尺寸的矩阵
void print() 输出矩阵

重载运算符

双矩阵运算符

Operator ' + ' 矩阵加法
Operator ' - ' 矩阵减法
Operator ' * ' 矩阵乘法
Operator ' == ' 矩阵比较

矩阵-数值运算符

Operator ' ^ ' 矩阵乘方
Operator ' | ' 矩阵快速幂
Operator ' * ' 矩阵数乘

代码

/* _MATRIX_H_ */
#ifndef HDK
#define HDK 0
#endif
#ifndef matrix_h
#define matrix_h 0
#endif
#include<iostream>
#include<vector>
template<typename T,int maxlen>
class matrix{
	private:
		int n,m,mod;
		bool ifmod;
		T mat[maxlen+1][maxlen+1];
	public:
		int get_n(){
			return n;
		}
		int get_m(){
			return m;
		}
		int get_mod(){
			return mod;
		}
		T& get_matrix(int x,int y){
			return mat[x][y];
		}
		T* operator[](int x){
			return mat[x];
		}
		void clear(){
			for(int i=1;i<=n;++i){
				for(int j=1;j<=m;++j){
					mat[i][j]=0;
				}
			}
			n=0;
			m=0;
			ifmod=false;
			mod=0;
		}
		void setmod(int x){
			if(x==0){
				ifmod=false;
			}
			else{
				ifmod=true;
			}
			mod=x;
		}
		void resize(int nsize,int msize){
			n=nsize;
			m=msize;
		}
		void fillmain(int x){
			for(int i=1;i<=n;++i){
				mat[i][i]=x;
			}
		}
		void fillsec(int x){
			for(int i=1;i<=n;++i){
				mat[i][n-i+1]=x;
			}
		}
		void fill(int x){
			for(int i=1;i<=n;++i){
				for(int j=1;j<=m;++j){
					mat[i][j]=x;
				}
			}
		}
		void fill(int x,int startn,int endn,int startm,int endm){
			for(int i=startn;i<=endn;++i){
				for(int j=startm;j<=endm;++j){
					mat[i][j]=x;
				}
			}
		}
		void opposite(){
			for(int i=1;i<=n;++i){
				for(int j=1;j<=m;++j){
					mat[i][j]*=-1;
				}
			}
		}
		void fill(std::vector<std::vector<T>> x){
			for(int i=0;i<=(int)x.size()-1;++i){
				for(int j=0;j<=(int)x[i].size()-1;++j){
					mat[i+1][j+1]=x[i][j];
				}
			}
		}
		void packed_clear(std::vector<std::vector<T>> x,int mod=0){
			resize(x.size(),x.front().size());
			fill(x);
			setmod(mod);
		}
		void packed_clear(int nsize,int msize,int filln=0,int mod=0){
			clear();
			resize(nsize,msize);
			setmod(mod);
			fill(filln);
		}
		void input(){
			std::cin>>n>>m;
			for(int i=1;i<=n;++i){
				for(int j=1;j<=m;++j){
					std::cin>>mat[i][j];
				}
			}
		}
		void inputn(int nsize){
			n=nsize;
			std::cin>>m;
			for(int i=1;i<=n;++i){
				for(int j=1;j<=m;++j){
					std::cin>>mat[i][j];
				}
			}
		}
		void inputm(int msize){
			m=msize;
			std::cin>>n;
			for(int i=1;i<=n;++i){
				for(int j=1;j<=m;++j){
					std::cin>>mat[i][j];
				}
			}
		}
		void input(int nsize,int msize){
			n=nsize;
			m=msize;
			for(int i=1;i<=n;++i){
				for(int j=1;j<=m;++j){
					std::cin>>mat[i][j];
				}
			}
		}
		void print(){
			for(int i=1;i<=n;++i){
				for(int j=1;j<=m;++j){
					std::cout<<mat[i][j]<<" ";
				}
				std::cout<<std::endl;
			}
		}
		matrix operator *(const matrix &A)const{
			matrix p;
			p.packed_clear(n,A.m,0,mod);
			for(int i=1;i<=n;++i){
				for(int j=1;j<=A.m;++j){
					for(int k=1;k<=m;++k){
						if(ifmod){
							p.mat[i][j]+=(mat[i][k]*A.mat[k][j])%mod;
							p.mat[i][j]%=mod;
						}
						else{
							p.mat[i][j]+=mat[i][k]*A.mat[k][j];
						}
					}
				}
			}
			return p;
		}
		matrix operator +(const matrix &A)const{
			matrix p;
			p.packed_clear(n,m,0,mod);
			for(int i=1;i<=n;++i){
				for(int j=1;j<=m;++j){
					if(ifmod){
						p.mat[i][j]=(mat[i][j]+A.mat[i][j])%mod;
					}
					else{
						p.mat[i][j]=mat[i][j]+A.mat[i][j];
					}
				}
			}
			return p;
		}
		matrix operator -(const matrix &A)const{
			matrix p;
			p.packed_clear(n,m,0,mod);
			for(int i=1;i<=n;++i){
				for(int j=1;j<=m;++j){
					if(ifmod){
						p.mat[i][j]=(mat[i][j]-A.mat[i][j])%mod;
					}
					else{
						p.mat[i][j]=mat[i][j]-A.mat[i][j];
					}
				}
			}
			return p;
		}
		matrix operator ^(const long long times)const{
			matrix p;
			p.packed_clear(n,m,1,mod);
			for(int i=1;i<=times;++i){
				p=p*(*this);
			}
			return p;
		}
		matrix operator |(long long times)const{
			matrix base,p;
			p.packed_clear(n,m,0,mod);
			base.packed_clear(n,m,0,mod);
			base=(*this);
			p.fillmain(1);
			if(times<=0){
				return p;
			}
			while(times){
				if(times&1){
					p=p*base;
				}
				base=base*base;
				times>>=1;
			}
			return p;
		}
		matrix operator *(const int x)const{
			matrix p;
			p.packed_clear(n,m,0,mod);
			for(int i=1;i<=n;++i){
				for(int j=1;j<=m;++j){
					if(ifmod){
						p.mat[i][j]=(mat[i][j]*x)%mod;
					}
					else{
						p.mat[i][j]=mat[i][j]*x;
					}
				}
			}
			return p;
		}
		bool operator ==(matrix<T,maxlen>A){
			for(int i=1;i<=n;++i){
				for(int j=1;j<=m;++j){
					if(mat[i][j]!=A[i][j]) return false;
				}
			}
			return true;
		}
};
/*--NAMESPACE HDK::MATRIX  MATRIX_H_--*/