矩阵类的C#代码
今天是国庆节，祝贺我们的祖国越来越昌盛！我把以前编写的矩阵类的C#代码贴出来与大家共享，有不对的地方多提宝贵意见哟。本贴如果转帖一定要注明出处呀！
namespace Maths
{
using System;
using System.Text;
using Maths.Statistic;
///
/// 这是一个实矩阵类，矩阵大小可更改
///
///
/// （1）矩阵的加、减、数乘和乘等运算；
/// （2）矩阵的转置运算；
/// （3）矩阵列向量的最大值与最小值；
/// （4）矩阵列向量的内积运算，范数；
/// （5）方阵的特征值与特征向量。
/// 在这个类中用到了LSMat类，它是一个矩阵数据文件存取类（自编自定义的数据文
/// 件格式，非常简单，ACSII码形式）。
/// 注：数学常数都用大写来表达
///
public class Matrix
{
private static int matrixnumber=0;
private int hashcode;
///
/// 存储矩阵数据的二维数组
///
internal protected double[,] Mat;
///
/// 矩阵实际的行数
///
private int row;
///
/// 矩阵实际的列数
///
private int col;
///
/// 获取矩阵行数的属性，用于获得矩阵的行数
///
public int Row
{
get
{
return this.row;
}
}
///
/// 获取矩阵列数的属性，用于获得矩阵的列数
///
public int Col
{
get
{
return this.col;
}
}
///
/// 重置矩阵的大小
///
///
/// 的数据自动保留，其余数据丢失或遭到破坏
public void ReSetRowAndCol(int newrow,int newcol)
{
if(newrow<=0||newcol<=0)
throw new MatrixException(".ReSetRowAndCol(int,int)>重置的行数或列数不是正整数");
Matrix.ChangeMat(ref this.Mat,ref this.row,ref this.col,newrow,newcol);
}
///
/// 恢复矩阵到目前最大的存储空间的大小
///
public void Revert()
{
this.row=this.Mat.GetLength(0);
this.col=this.Mat.GetLength(1);
}
///
/// 随机数类的静态实例
///
private static RandNumber rr=new RandNumber();
///
/// 数值计算的精度，默认值是1e-8
///
private static double Eps=1.0e-8;
///
/// 欧拉常数，是一个双精度常量
///
private const double Euler=0.57721566490153286060651;
///
/// 用于获得欧拉常数的公共静态属性，只读
///
public static double EULER
{
get
{
return Matrix.Euler;
}
}
///
/// 用于获得数值计算的精度的公共静态属性，可读写
///
public static double EPS
{
set
{
Eps=value;
}
get
{
return Eps;
}
}
///
/// 重新分配矩阵的存储空间
///
///
/// 注：对矩阵的存储空间进行检查，如果原二维数组能容纳新的变化，则
/// 保持原数组不变；否则，则按新的变化重新分配存储空间，并保留原数
/// 组中的值不变，返回。对新分配的部分初始化为零或者对新扩大的部分
/// 重新置零。
///
private static void ChangeMat(ref double[,] Mat,ref int row,ref int col,int newrow,int newcol)
{
int i=0,j=0; //循环变量
if(newrow<=Mat.GetLength(0)&&newcol<=Mat.GetLength(1))//原二维数组能满足新的要求
{
//对如下三种情况产生的对原二维数组的新扩大部分重新置零
if(newrow>row&&newcol>col)
{
for(i=row;i
for(j=col;j
}
else if(newrow>row&&newcol<=col)
{
for(i=row;i
}
else if(newrow<=row&&newcol>col)
{
for(j=col;j
}
}
else if(newrow>Mat.GetLength(0)&&newcol>Mat.GetLength(1))
//新行数和列数都大于当前二维数组的行数和列数
{
double[,] newMat=new double[newrow,newcol];
for(i=0;i
Mat=newMat;
}
else if(newrow>Mat.GetLength(0)&&newcol<=Mat.GetLength(1))
//新行数大于当前二维数组的行数但新列数不大于当前二维数组的列数
{
double[,] newMat=new double[newrow,newcol];
for(i=0;i
Mat=newMat;
}
else//新列数大于当前二维数组的列数但新行数不大于当前二维数组的行数
{
double[,] newMat=new double[newrow,newcol];
for(i=0;i
Mat=newMat;
}
row=newrow;//原矩阵行数重置为新行数
col=newcol;//原矩阵列数重置为新列数
}
///
/// 构造函数1：用于产生一个0行0列的矩阵
///
public Matrix()
{
Mat=new double[0,0];
this.col=this.row=0;
this.hashcode=Matrix.matrixnumber;
Matrix.matrixnumber++;
}
///
/// 构造函数2：用于产生一个指定行数和列数的矩阵，如果
/// 指定的行数和列数至少有一个非正数，则引发异常
///
/// 指定的行数
/// 指定的列数
public Matrix(int row,int col)
{
if(row<=0||col<=0) throw new MatrixException("");
Mat=new double[row,col];
this.row=row;
this.col=col;
this.hashcode=Matrix.matrixnumber;
Matrix.matrixnumber++;
}
///
/// 构造函数3：用于产生n阶方阵
///
/// 方阵的阶数
public Matrix(int n)
{
Mat=new double[n,n];
this.row=this.col=n;
this.hashcode=Matrix.matrixnumber;
Matrix.matrixnumber++;
}
///
/// 构造函数4：用于从数据文件的数据构造一个矩阵
///
/// 数据文件的绝对路径和名字或者当前目录下的文件名字
public Matrix(string DataFileName)
{
this.Mat=LSMat.LoadDoubleDataFile(DataFileName);
this.row=this.Mat.GetLength(0);
this.col=this.Mat.GetLength(1);
this.hashcode=Matrix.matrixnumber;
Matrix.matrixnumber++;
}
///
/// 判断两矩阵的每个元素是否相等
///
public static Matrix operator==(Matrix mat1,Matrix mat2)
{
if(mat1.Row!=mat2.Row||mat1.Col!=mat2.Col)
throw new MatrixException("在判断矩阵相等中两矩阵不同型");
Matrix mat=Matrix.Ones(mat1.Row,mat1.Col);
for(int i=0;i
mat.Mat[i,j]=0;
return mat;
}
///
/// 判断两矩阵的每个元素是否不相等
///
public static Matrix operator!=(Matrix mat1,Matrix mat2)
{
if(mat1.Row!=mat2.Row||mat1.Col!=mat2.Col)
throw new MatrixException("在判断矩阵相等中两矩阵不同型");
Matrix mat=Matrix.Zeros(mat1.Row,mat1.Col);
for(int i=0;i
mat.Mat[i,j]=1;
return mat;
}
///
/// 判断一个矩阵的每个元素是否与给定的数相等
///
public static Matrix operator==(Matrix mat,double v)
{
Matrix mat1=new Matrix(mat.Row,mat.Col);
for(int i=0;i
if(mat.Mat[i,j]!=v)
mat1.Mat[i,j]=0;
else
mat1.Mat[i,j]=1;
}
return mat1;
}
///
/// 判断一个矩阵的每个元素是否与给定的数不相等
///
public static Matrix operator!=(Matrix mat,double v)
{
Matrix mat1=new Matrix(mat.Row,mat.Col);
for(int i=0;i
if(mat.Mat[i,j]!=v)
mat1.Mat[i,j]=1;
else
mat1.Mat[i,j]=0;
}
return mat1;
}
///
/// 判断一个矩阵的每个元素是否与给定的数相等
///
public static Matrix operator==(double v,Matrix mat)
{
Matrix mat1=new Matrix(mat.Row,mat.Col);
for(int i=0;i
if(mat.Mat[i,j]!=v)
mat1.Mat[i,j]=0;
else
mat1.Mat[i,j]=1;
}
return mat1;
}
///
/// 判断一个矩阵的每个元素是否与给定的数不相等
///
public static Matrix operator!=(double v,Matrix mat)
{
Matrix mat1=new Matrix(mat.Row,mat.Col);
for(int i=0;i
if(mat.Mat[i,j]!=v)
mat1.Mat[i,j]=1;
else
mat1.Mat[i,j]=0;
}
return mat1;
}
///
/// 判断两个矩阵是否相等
///
public override bool Equals(object obj)
{
Matrix mat=(Matrix)obj;
if(this.Row!=mat.Row||this.Col!=mat.Col)
return false;
for(int i=0;i
return false;
return true;
}
///
/// 判断两个矩阵是否相等
///
public static new bool Equals(object obj1,object obj2)
{
Matrix mat=(Matrix)obj1;
return mat.Equals(obj2);
}
///
/// 获得矩阵的哈希码
///
public override int GetHashCode()
{
return this.hashcode;
}
///
/// 矩阵取反
///
public static Matrix operator!(Matrix mat)
{
Matrix mat1=new Matrix(mat.Row,mat.Col);
for(int i=0;i
if(mat.Mat[i,j]!=0) mat1.Mat[i,j]=0;
else mat1.Mat[i,j]=1;
}
return mat1;
}
///
/// 比较同型两矩阵的大小
///
public static Matrix operator>(Matrix mat1,Matrix mat2)
{
if(mat1.Row!=mat2.Row||mat1.Col!=mat2.Col)
throw new MatrixException("在大于比较中两矩阵不同型");
Matrix mat=new Matrix(mat1.Row,mat1.Col);
for(int i=0;i
if(mat1.Mat[i,j]>mat2.Mat[i,j])
mat.Mat[i,j]=1;
else
mat1.Mat[i,j]=0;
}
return mat;
}
///
/// 比较同型两矩阵的大小
///
public static Matrix operator<(Matrix mat1,Matrix mat2)
{
if(mat1.Row!=mat2.Row||mat1.Col!=mat2.Col)
throw new MatrixException("在小于比较中两矩阵不同型");
Matrix mat=new Matrix(mat1.Row,mat1.Col);
for(int i=0;i
if(mat1.Mat[i,j]
else
mat1.Mat[i,j]=0;
}
return mat;
}
///
/// 比较同型两矩阵的大小
///
public static Matrix operator<=(Matrix mat1,Matrix mat2)
{
if(mat1.Row!=mat2.Row||mat1.Col!=mat2.Col)
throw new MatrixException("在小于等于比较中两矩阵不同型");
Matrix mat=new Matrix(mat1.Row,mat1.Col);
for(int i=0;i
if(mat1.Mat[i,j]<=mat2.Mat[i,j])
mat.Mat[i,j]=1;
else
mat1.Mat[i,j]=0;
}
return mat;
}
///
/// 比较同型两矩阵的大小
///
public static Matrix operator>=(Matrix mat1,Matrix mat2)
{
if(mat1.Row!=mat2.Row||mat1.Col!=mat2.Col)
throw new MatrixException("在大于等于比较中两矩阵不同型");
Matrix mat=new Matrix(mat1.Row,mat1.Col);
for(int i=0;i
if(mat1.Mat[i,j]>=mat2.Mat[i,j])
mat.Mat[i,j]=1;
else
mat1.Mat[i,j]=0;
}
return mat;
}
//--------------------------
//从矩阵中获得元素
//--------------------------
///
/// 获得矩阵的指定的一行构成一个行矩阵
///
/// 指定的行，从0开始
public Matrix GetRow(int Rownum)
{
Matrix rowmat=new Matrix(1,this.Col);
for(int j=0;j
return rowmat;
}
///
/// 获得矩阵的指定的行构成相应的一个新矩阵
///
/// 指定行数构成的一个行矩阵
public Matrix GetRow(Matrix vecrow)
{
if(vecrow.row>1) throw new MatrixException(".GetRow(Matrix)>输入数据不是行向量");
Matrix newmat=new Matrix(vecrow.Col,this.Col);
for(int i=0;i
int vv=(int)vecrow[i];
for(int j=0;j
}
return newmat;
}
///
/// 获得矩阵的指定一列
///
/// 指定的列，从0开始
public Matrix GetCol(int Colnum)
{
Matrix colmat=new Matrix(this.Row,1);
for(int i=0;i
return colmat;
}
///
/// 获得矩阵的指定的列构成相应的一个新矩阵
///
/// 指定列数构成的一个行矩阵
public Matrix GetCol(Matrix veccol)
{
if(veccol.row>1) throw new MatrixException(".GetCol(Matrix)>输入数据不是行向量");
Matrix newmat=new Matrix(this.Row,veccol.Col);
for(int j=0;j
int vv=(int)veccol[j];
for(int i=0;i
}
return newmat;
}
///
/// 存取指定行指定列的矩阵元素或按行计数存取指定位置的元素
///
///
/// 对于存取指定行指定列的矩阵元素这种情况，就是一般的存和取。对于
/// 按行计数存取指定位置的元素的情况，
///
public double this[int rownum,int colnum]
{
get
{
if(colnum>=0) return this.Mat[rownum,colnum];
else
{
int j=rownum%this.Col;
int i=(rownum-j)/this.Col;
return this.Mat[i,j];
}
}
set
{
if(colnum>=0) this.Mat[rownum,colnum]=value;
else
{
int j=rownum%this.Col;
int i=(rownum-j)/this.Col;
this.Mat[i,j]=value;
}
}
}
///
/// 按列对矩阵的指定元素存取
///
public double this[int num]
{
get
{
int rown,coln;
if(num%this.Row==0)
{
coln=num/this.Row;
rown=0;
}
else
{
coln=num/this.Row;
rown=num-this.Row*coln;
}
return this.Mat[rown,coln];
}
set
{
int rown,coln;
if(num%this.Row==0)
{
coln=num/this.Row;
rown=0;
}
else
{
coln=num/this.Row;
rown=num-this.Row*coln;
}
this.Mat[rown,coln]=value;
}
}
///
/// 给矩阵的指定行赋一定值
///
/// 待赋数值
/// 被赋值行的行数，从0开始
public void SetRow(double Value,int Rownum)
{
for(int j=0;j
return;
}
///
/// 给矩阵的指定行赋一定值
///
/// 待赋数值
/// 被赋值行的行数构成的行矩阵
public void SetRow(double Value,Matrix Rownum)
{
if(Rownum.Row>1) throw new MatrixException(".SetRow(double,Matrix)>中的行数矩阵不是行矩阵");
for(int i=0;i
}
///
/// 给矩阵的指定行赋一个行矩阵
///
/// 待赋的矩阵
/// 被赋值行的行数，从0开始
///
/// 注：Rowmat不是行矩阵或者它的元素个数没有被赋值的矩阵的列数大，这都没有关系。这
/// 里采用了最灵活的方式，根据矩阵Rowmat中元素的个数和被赋值的矩阵的列数的情况，谁
/// 少按谁的来赋值，并且Rowmat按列来读数据。因此，本实现保证不会出现异常。显然，若
/// Rowmat按最标准的方式（它是一个行矩阵并且列数等于被赋值的矩阵的列数）输入，结果
/// 就是预期的。本实现方式既实现了对标准输入的支持，又体现了很大的灵活性。
///
public void SetRow(Matrix Rowmat,int Rownum)
{
if(Rowmat.Col*Rowmat.Row>=this.Col)
{
for(int j=0;j
}
else
{
for(int j=0;j
}
}
///
/// 给矩阵的指定行赋一个行矩阵
///
/// 待赋的矩阵
/// 被赋值行的行数构成的行矩阵
///
public void SetRow(Matrix Rowmat,Matrix Rownum)
{
if(Rownum.Row>1) throw new MatrixException(".SetRow(Matrix,Matrix)>中的行数矩阵不是行矩阵");
if(Rowmat.Col*Rowmat.Row>=this.Col)
{
for(int i=0;i
int vv=(int)Rownum[i];
for(int j=0;j
}
}
else
{
for(int i=0;i
int vv=(int)Rownum[i];
for(int j=0;j
}
}
}
///
/// 给矩阵的指定列赋一定值
///
/// 待赋数值
/// 被赋值列的行数，从0开始
public void SetCol(double Value,int Colnum)
{
for(int i=0;i
}
///
/// 给矩阵的指定列赋一定值
///
/// 待赋数值
/// 被赋值列的行数构成的行矩阵
public void SetCol(double Value,Matrix Colnum)
{
if(Colnum.Row>1) throw new MatrixException(".SetCol(double,Matrix)>中的列数构成的矩阵不是行矩阵");
for(int j=0;j
int vv=(int)Colnum[j];
for(int i=0;i
}
}
///
/// 给矩阵的指定列赋一个列矩阵
///
/// 待赋的矩阵
/// 被赋值列的列数，从0开始
///
public void SetCol(Matrix Colmat,int Colnum)
{
if(Colmat.Row*Colmat.Col>=this.Row)
{
for(int i=0;i
}
else
{
for(int i=0;i
}
}
///
/// 给矩阵的指定列赋一个列矩阵
///
/// 待赋的矩阵
/// 被赋值列的列数构成的行矩阵
///
public void SetCol(Matrix Colmat,Matrix Colnum)
{
if(Colnum.Row>1) throw new MatrixException(".SetCol(Matrix,Matrix)>中的列数构成的矩阵不是行矩阵");
if(Colmat.Row*Colmat.Col>=this.Row)
{
for(int j=0;j
int vv=(int)Colnum[j];
for(int i=0;i
}
}
else
{
for(int j=0;j
int vv=(int)Colnum[j];
for(int i=0;i
}
}
}
///
/// 在矩阵的（0，0）位置赋一个矩阵
///
/// 待赋的矩阵
///
public void Set(Matrix mat)
{
this.Set(mat,0,0);
}
///
/// 在矩阵的指定位置赋一个矩阵
///
/// 待赋的矩阵
/// 行位置
/// 列位置
///
/// 如果待赋的矩阵的左上角放置在指定位置后比原矩阵大，则舍去大的那部分
///
public void Set(Matrix mat,int rownum,int colnum)
{
int m,n;
if(rownum+mat.Row>this.Row) m=this.Row;
else m=rownum+mat.Row;
if(colnum+mat.Col>this.Col) n=this.Col;
else n=colnum+mat.Col;
for(int i=rownum;i
}
//----------------------------------------------------------
//矩阵数据类型的转换
//----------------------------------------------------------
///
/// 把double数隐式转换为矩阵
///
public static implicit operator Matrix(double Value)
{
Matrix mat=new Matrix(1,1);
mat.Mat[0,0]=Value;
return mat;
}
///
/// 把float数隐式转换为矩阵
///
public static implicit operator Matrix(float Value)
{
Matrix mat=new Matrix(1,1);
mat.Mat[0,0]=Value;
return mat;
}
///
/// 把ulong数隐式转换为矩阵
///
public static implicit operator Matrix(ulong Value)
{
Matrix mat=new Matrix(1,1);
mat.Mat[0,0]=Value;
return mat;
}
///
/// 把long数隐式转换为矩阵
///
public static implicit operator Matrix(long Value)
{
Matrix mat=new Matrix(1,1);
mat.Mat[0,0]=Value;
return mat;
}
///
/// 把uint数隐式转换为矩阵
///
public static implicit operator Matrix(uint Value)
{
Matrix mat=new Matrix(1,1);
mat.Mat[0,0]=Value;
return mat;
}
///
/// 把int数隐式转换为矩阵
///
public static implicit operator Matrix(int Value)
{
Matrix mat=new Matrix(1,1);
mat.Mat[0,0]=Value;
return mat;
}
///
/// 把ushort数隐式转换为矩阵
///
public static implicit operator Matrix(ushort Value)
{
Matrix mat=new Matrix(1,1);
mat.Mat[0,0]=Value;
return mat;
}
///
/// 把short数隐式转换为矩阵
///
public static implicit operator Matrix(short Value)
{
Matrix mat=new Matrix(1,1);
mat.Mat[0,0]=Value;
return mat;
}
///
/// 把byte数隐式转换为矩阵
///
public static implicit operator Matrix(byte Value)
{
Matrix mat=new Matrix(1,1);
mat.Mat[0,0]=Value;
return mat;
}
///
/// 把sbyte数隐式转换为矩阵
///
public static implicit operator Matrix(sbyte Value)
{
Matrix mat=new Matrix(1,1);
mat.Mat[0,0]=Value;
return mat;
}
///
/// 把bool数隐式转换为矩阵
///
public static implicit operator Matrix(bool Value)
{
Matrix mat=new Matrix(1,1);
if(Value) mat.Mat[0,0]=1;
else mat.Mat[0,0]=0;
return mat;
}
///
/// 把string数隐式转换为矩阵
///
public static implicit operator Matrix(string Value)
{
Matrix mat=new Matrix(1,1);
Maths.ValidateNum.Validate(Value,out Value);
if(Value.Length!=0) mat.Mat[0,0]=double.Parse(Value);
else mat.Mat[0,0]=0;
return mat;
}
///
/// 把矩阵显式转换为double数
///
public static explicit operator double(Matrix mat)
{
if(mat.Col*mat.Row==1)
return mat.Mat[0,0];
else
throw new MatrixException("矩阵不是1行1列");
}
///
/// 二维double型数组隐式转换为矩阵
///
/// 二维数组
///
public static implicit operator Matrix(double[,] mat2)
{
Matrix mat1=new Matrix(mat2.GetLength(0),mat2.GetLength(1));
for(int i=0;i
return mat1;
}
///
/// 二维float型数组隐式转换为矩阵
///
public static implicit operator Matrix(float[,] mat)
{
Matrix mat2=new Matrix(mat.GetLength(0),mat.GetLength(1));
for(int i=0;i
return mat2;
}
///
/// 二维ulong型数组隐式转换为矩阵
///
public static implicit operator Matrix(ulong[,] mat)
{
Matrix mat2=new Matrix(mat.GetLength(0),mat.GetLength(1));
for(int i=0;i
return mat2;
}
///
/// 二维long型数组隐式转换为矩阵
///
public static implicit operator Matrix(long[,] mat)
{
Matrix mat2=new Matrix(mat.GetLength(0),mat.GetLength(1));
for(int i=0;i
return mat2;
}
///
/// 二维uint型数组隐式转换为矩阵
///
public static implicit operator Matrix(uint[,] mat)
{
Matrix mat2=new Matrix(mat.GetLength(0),mat.GetLength(1));
for(int i=0;i
return mat2;
}
///
/// 二维int型数组隐式转换为矩阵
///
public static implicit operator Matrix(int[,] mat)
{
Matrix mat2=new Matrix(mat.GetLength(0),mat.GetLength(1));
for(int i=0;i
return mat2;
}
///
/// 二维ushort型数组隐式转换为矩阵
///
public static implicit operator Matrix(ushort[,] mat)
{
Matrix mat2=new Matrix(mat.GetLength(0),mat.GetLength(1));
for(int i=0;i
return mat2;
}
///
/// 二维short型数组隐式转换为矩阵
///
public static implicit operator Matrix(short[,] mat)
{
Matrix mat2=new Matrix(mat.GetLength(0),mat.GetLength(1));
for(int i=0;i
return mat2;
}
///
/// 二维byte型数组隐式转换为矩阵
///
public static implicit operator Matrix(byte[,] mat)
{
Matrix mat2=new Matrix(mat.GetLength(0),mat.GetLength(1));
for(int i=0;i
return mat2;
}
///
/// 二维sbyte型数组隐式转换为矩阵
///
public static implicit operator Matrix(sbyte[,] mat)
{
Matrix mat2=new Matrix(mat.GetLength(0),mat.GetLength(1));
for(int i=0;i
return mat2;
}
///
/// 二维bool型数组隐式转换为矩阵
///
public static implicit operator Matrix(bool[,] mat)
{
Matrix mat2=new Matrix(mat.GetLength(0),mat.GetLength(1));
for(int i=0;i
if(mat[i,j]) mat2.Mat[i,j]=1;
else mat2.Mat[i,j]=0;
}
return mat2;
}
///
/// 二维char型数组隐式转换为矩阵
///
public static implicit operator Matrix(char[,] mat)
{
Matrix mat2=new Matrix(mat.GetLength(0),mat.GetLength(1));
for(int i=0;i
return mat2;
}
///
/// 二维string型数组隐式转换为矩阵
///
public static implicit operator Matrix(string[,] mat)
{
Matrix mat2=new Matrix(mat.GetLength(0),mat.GetLength(1));
string str;
for(int i=0;i
ValidateNum.Validate(mat[i,j],out str);
if(str.Length!=0) mat2.Mat[i,j]=double.Parse(str);
else mat2.Mat[i,j]=0;
}
return mat2;
}
///
/// 一维double型数组隐式转换为列矩阵
///
public static implicit operator Matrix(double[] vec)
{
Matrix mat=new Matrix(vec.Length,1);
for(int i=0;i
return mat;
}
///
/// 一维float型数组隐式转换为列矩阵
///
public static implicit operator Matrix(float[] vec)
{
Matrix mat=new Matrix(vec.Length,1);
for(int i=0;i
return mat;
}
///
/// 一维ulong型数组隐式转换为列矩阵
///
public static implicit operator Matrix(ulong[] vec)
{
Matrix mat=new Matrix(vec.Length,1);
for(int i=0;i
return mat;
}
///
/// 一维long型数组隐式转换为列矩阵
///
public static implicit operator Matrix(long[] vec)
{
Matrix mat=new Matrix(vec.Length,1);
for(int i=0;i
return mat;
}
///
/// 一维uint型数组隐式转换为列矩阵
///
public static implicit operator Matrix(uint[] vec)
{
Matrix mat=new Matrix(vec.Length,1);
for(int i=0;i
return mat;
}
///
/// 一维int型数组隐式转换为列矩阵
///
public static implicit operator Matrix(int[] vec)
{
Matrix mat=new Matrix(vec.Length,1);
for(int i=0;i
return mat;
}
///
/// 一维ushort型数组隐式转换为列矩阵
///
public static implicit operator Matrix(ushort[] vec)
{
Matrix mat=new Matrix(vec.Length,1);
for(int i=0;i
return mat;
}
///
/// 一维short型数组隐式转换为列矩阵
///
public static implicit operator Matrix(short[] vec)
{
Matrix mat=new Matrix(vec.Length,1);
for(int i=0;i
return mat;
}
///
/// 一维byte型数组隐式转换为同长列矩阵
///
public static implicit operator Matrix(byte[] mat)
{
Matrix mat2=new Matrix(mat.Length,1);
for(int i=0;i
return mat2;
}
///
/// 一维sbyte型数组隐式转换为列矩阵
///
public static implicit operator Matrix(sbyte[] vec)
{
Matrix mat=new Matrix(vec.Length,1);
for(int i=0;i
return mat;
}
///
/// 一维bool型数组隐式转换为列矩阵
///
public static implicit operator Matrix(bool[] vec)
{
Matrix mat=new Matrix(vec.Length,1);
for(int i=0;i
if(vec[i]) mat.Mat[i,0]=1;
else mat.Mat[i,0]=0;
}
return mat;
}
///
/// 一维char型数组隐式转换为列矩阵
///
public static implicit operator Matrix(char[] vec)
{
Matrix mat=new Matrix(vec.Length,1);
for(int i=0;i
return mat;
}
///
/// 一维string型数组隐式转换为列矩阵
///
public static implicit operator Matrix(string[] vec)
{
Matrix mat=new Matrix(vec.Length,1);
string str;
for(int i=0;i
ValidateNum.Validate(vec[i],out str);
if(str.Length!=0) mat.Mat[i,0]=double.Parse(str);
else mat.Mat[i,0]=0;
}
return mat;
}
///
/// 矩阵显式转换为二维double型数组
///
/// 矩阵
///
public static explicit operator double[,](Matrix mat)
{
double[,] mat2=new double[mat.Row,mat.Col];
for(int i=0;i
return mat2;
}
///
/// 矩阵显式转换为二维float型数组
///
public static explicit operator float[,](Matrix mat)
{
float[,] mat2=new float[mat.Row,mat.Col];
for(int i=0;i
if((mat.Mat[i,j]>float.MaxValue)||(mat.Mat[i,j]
mat2[i,j]=(float)mat.Mat[i,j];
}
return mat2;
}
///
/// 矩阵显式转换为二维ulong型数组
///
public static explicit operator ulong[,](Matrix mat)
{
ulong[,] mat2=new ulong[mat.Row,mat.Col];
for(int i=0;i
if((mat.Mat[i,j]>ulong.MaxValue)||(mat.Mat[i,j]
mat2[i,j]=(ulong)mat.Mat[i,j];
}
return mat2;
}
///
/// 矩阵显式转换为二维long型数组
///
public static explicit operator long[,](Matrix mat)
{
long[,] mat2=new long[mat.Row,mat.Col];
for(int i=0;i
if((mat.Mat[i,j]>long.MaxValue)||(mat.Mat[i,j]
mat2[i,j]=(long)mat.Mat[i,j];
}
return mat2;
}
///
/// 矩阵显式转换为二维uint型数组
///
public static explicit operator uint[,](Matrix mat)
{
uint[,] mat2=new uint[mat.Row,mat.Col];
for(int i=0;i
if((mat.Mat[i,j]>uint.MaxValue)||(mat.Mat[i,j]
mat2[i,j]=(uint)mat.Mat[i,j];
}
return mat2;
}
///
/// 矩阵显式转换为二维int型数组
///
public static explicit operator int[,](Matrix mat)
{
int[,] mat2=new int[mat.Row,mat.Col];
for(int i=0;i
if((mat.Mat[i,j]>int.MaxValue)||(mat.Mat[i,j]
mat2[i,j]=(int)mat.Mat[i,j];
}
return mat2;
}
///
/// 矩阵显式转换为二维ushort型数组
///
public static explicit operator ushort[,](Matrix mat)
{
ushort[,] mat2=new ushort[mat.Row,mat.Col];
for(int i=0;i
if((mat.Mat[i,j]>ushort.MaxValue)||(mat.Mat[i,j]
mat2[i,j]=(ushort)mat.Mat[i,j];
}
return mat2;
}
///
/// 矩阵显式转换为二维short型数组
///
public static explicit operator short[,](Matrix mat)
{
short[,] mat2=new short[mat.Row,mat.Col];
for(int i=0;i
if((mat.Mat[i,j]>short.MaxValue)||(mat.Mat[i,j]
mat2[i,j]=(short)mat.Mat[i,j];
}
return mat2;
}
///
/// 矩阵显式转换为同型二维byte型数组
///
public static explicit operator byte[,](Matrix mat)
{
byte[,] mat2=new byte[mat.Row,mat.Col];
for(int i=0;i
if((mat.Mat[i,j]>=byte.MaxValue)||(mat.Mat[i,j]
mat2[i,j]=(byte)mat.Mat[i,j];
}
return mat2;
}
///
/// 矩阵显式转换为同型二维sbyte型数组
///
public static explicit operator sbyte[,](Matrix mat)
{
sbyte[,] mat2=new sbyte[mat.Row,mat.Col];
for(int i=0;i
if((mat.Mat[i,j]>=sbyte.MaxValue)||(mat.Mat[i,j]
mat2[i,j]=(sbyte)mat.Mat[i,j];
}
return mat2;
}
///
/// 矩阵显式转换为同型二维bool型数组
///
public static explicit operator bool[,](Matrix mat)
{
bool[,] mat2=new bool[mat.Row,mat.Col];
for(int i=0;i
if(mat.Mat[i,j]!=0) mat2[i,j]=true;
else mat2[i,j]=false;
}
return mat2;
}
///
/// 矩阵显式转换为同型二维char型数组
///
public static explicit operator char[,](Matrix mat)
{
char[,] mat2=new char[mat.Row,mat.Col];
for(int i=0;i
if((mat.Mat[i,j]>char.MaxValue)||(mat.Mat[i,j]
mat2[i,j]=(char)mat.Mat[i,j];
}
return mat2;
}
///
/// 矩阵显式转换为同型二维string型数组
///
public static explicit operator string[,](Matrix mat)
{
string[,] mat2=new string[mat.Row,mat.Col];
for(int i=0;i
return mat2;
}
///
/// 矩阵按列显式转换为一维double型数组
///
public static explicit operator double[](Matrix mat)
{
double[] vec=new double[mat.Row*mat.Col];
for(int j=0;j
return vec;
}
///
/// 矩阵按列显式转换为一维float型数组
///
public static explicit operator float[](Matrix mat)
{
float[] vec=new float[mat.Row*mat.Col];
for(int j=0;j
if((mat.Mat[i,j]>float.MaxValue)||(mat.Mat[i,j]
vec[i+j*mat.Row]=(float)mat.Mat[i,j];
}
return vec;
}
///
/// 矩阵按列显式转换为一维ulong型数组
///
public static explicit operator ulong[](Matrix mat)
{
ulong[] vec=new ulong[mat.Row*mat.Col];
for(int j=0;j
if((mat.Mat[i,j]>ulong.MaxValue)||(mat.Mat[i,j]
vec[i+j*mat.Row]=(ulong)mat.Mat[i,j];
}
return vec;
}
///
/// 矩阵按列显式转换为一维long型数组
///
public static explicit operator long[](Matrix mat)
{
long[] vec=new long[mat.Row*mat.Col];
for(int j=0;j
if((mat.Mat[i,j]>long.MaxValue)||(mat.Mat[i,j]
vec[i+j*mat.Row]=(long)mat.Mat[i,j];
}
return vec;
}
///
/// 矩阵按列显式转换为一维uint型数组
///
public static explicit operator uint[](Matrix mat)
{
uint[] vec=new uint[mat.Row*mat.Col];
for(int j=0;j
if((mat.Mat[i,j]>uint.MaxValue)||(mat.Mat[i,j]
vec[i+j*mat.Row]=(uint)mat.Mat[i,j];
}
return vec;
}
///
/// 矩阵按列显式转换为一维int型数组
///
public static explicit operator int[](Matrix mat)
{
int[] vec=new int[mat.Row*mat.Col];
for(int j=0;j
if((mat.Mat[i,j]>int.MaxValue)||(mat.Mat[i,j]
vec[i+j*mat.Row]=(int)mat.Mat[i,j];
}
return vec;
}
///
/// 矩阵按列显式转换为一维float型数组
///
public static explicit operator ushort[](Matrix mat)
{
ushort[] vec=new ushort[mat.Row*mat.Col];
for(int j=0;j
if((mat.Mat[i,j]>ushort.MaxValue)||(mat.Mat[i,j]
vec[i+j*mat.Row]=(ushort)mat.Mat[i,j];
}
return vec;
}
///
/// 矩阵按列显式转换为一维short型数组
///
public static explicit operator short[](Matrix mat)
{
short[] vec=new short[mat.Row*mat.Col];
for(int j=0;j
if((mat.Mat[i,j]>short.MaxValue)||(mat.Mat[i,j]
vec[i+j*mat.Row]=(short)mat.Mat[i,j];
}
return vec;
}
///
/// 矩阵按列显式转换为一维byte型数组
///
public static explicit operator byte[](Matrix mat)
{
byte[] vec=new byte[mat.Row*mat.Col];
for(int j=0;j
if((mat.Mat[i,j]>=256)||(mat.Mat[i,j]<0))
throw new MatrixException("double向byte转化时，double数不能在[0，255]范围外");
vec[i+j*mat.Row]=(byte)mat.Mat[i,j];
}
return vec;
}
///
/// 矩阵按列显式转换为一维sbyte型数组
///
public static explicit operator sbyte[](Matrix mat)
{
sbyte[] vec=new sbyte[mat.Row*mat.Col];
for(int j=0;j
if((mat.Mat[i,j]>sbyte.MaxValue)||(mat.Mat[i,j]
vec[i+j*mat.Row]=(sbyte)mat.Mat[i,j];
}
return vec;
}
///
/// 矩阵按列显式转换为一维bool型数组
///
public static explicit operator bool[](Matrix mat)
{
bool[] vec=new bool[mat.Row*mat.Col];
for(int j=0;j
if(mat.Mat[i,j]!=0) vec[i+j*mat.Row]=true;
else vec[i+j*mat.Row]=false;
}
return vec;
}
///
/// 矩阵按列显式转换为一维char型数组
///
public static explicit operator char[](Matrix mat)
{
char[] vec=new char[mat.Row*mat.Col];
for(int j=0;j
if((mat.Mat[i,j]>char.MaxValue)||(mat.Mat[i,j]
vec[i+j*mat.Row]=(char)mat.Mat[i,j];
}
return vec;
}
///
/// 矩阵按列显式转换为一维string型数组
///
public static explicit operator string[](Matrix mat)
{
string[] vec=new string[mat.Row*mat.Col];
for(int j=0;j
return vec;
}
///
/// 克隆矩阵
///
/// 被克隆矩阵
///
///
public static Matrix Clone(Matrix mat2)
{
Matrix mat1=new Matrix(mat2.Row,mat2.Col);
for(int i=0;i
return mat1;
}
//-----------------------------------------------------------------
//矩阵数据文件的存取
//-----------------------------------------------------------------
///
/// 存矩阵到文件中
///
/// 被存矩阵
///
public static void SaveToFile(Matrix datamat,string DataFileName)
{
LSMat.SaveDataFile(DataFileName,datamat.Mat,2);
}
///
/// 从数据文件取数据到矩阵
///
/// 数据文件名（含路径）
///
public static Matrix LoadFromFile(string DataFileName)
{
Matrix Data=new Matrix();
Data.Mat=LSMat.LoadDoubleDataFile(DataFileName);
Data.row=Data.Mat.GetLength(0);
Data.col=Data.Mat.GetLength(1);
return Data;
}
//-----------------------
//矩阵的基本运算
//-----------------------
///
/// 矩阵的转置
///
/// 被转置矩阵
///
public static Matrix Trans(Matrix A)
{
Matrix mat=new Matrix(A.Col,A.Row);
for(int i=0;i
return mat;
}
///
/// 矩阵沿逆时针旋转90度
///
/// 输入矩阵
///
public static Matrix Rot90(Matrix mat)
{
Matrix rotmat=Matrix.Zeros(mat.Col,mat.Row);
int col=mat.Col;
for(int i=0;i
return rotmat;
}
///
/// 上下交换矩阵元素
///
/// 输入矩阵
///
///
public static Matrix Flipud(Matrix mat)
{
Matrix matud=Matrix.Clone(mat);
int row=mat.Row;
for(int i=0;i
matud.Mat[row-i-1,j]=mat.Mat[i,j];
matud.Mat[i,j]=mat.Mat[row-i-1,j];
}
return matud;
}
///
/// 上下交换矩阵元素
///
public void Flipud()
{
double vv=0; //中间存储矩阵
for(int i=0;i
vv=this.Mat[i,j];
this.Mat[i,j]=this.Mat[this.Row-i-1,j];
this.Mat[this.Row-i-1,j]=vv;
}
}
///
/// 左右交换矩阵元素，返回一个新矩阵
///
/// 输入矩阵
///
///
public static Matrix Fliplr(Matrix mat)
{
Matrix matlr=Matrix.Clone(mat);
int col=mat.Col;
for(int j=0;j
matlr.Mat[i,col-j-1]=mat.Mat[i,j];
matlr.Mat[i,j]=mat.Mat[i,col-j-1];
}
return matlr;
}
///
/// 左右交换矩阵元素，不产生新矩阵
///
public void Fliplr()
{
double vv=0; //中间存储变量
for(int j=0;j
vv=this.Mat[i,j];
this.Mat[i,j]=this.Mat[i,this.Col-j-1];
this.Mat[i,this.Col-j-1]=vv;
}
}
///
/// 提取矩阵的下三角阵生成下三角阵
///
///
///
public static Matrix Tril(Matrix mat)
{
Matrix mat2=Matrix.Zeros(mat.Row,mat.Col);
for(int j=0;j
return mat2;
}
///
/// 提取矩阵的下三角阵生成下三角阵
///
///
///
///
public static Matrix Tril(Matrix mat,int k)
{
if(k>=(mat.Col-1))
return Matrix.Clone(mat);
if(k<=(-mat.Row))
return Matrix.Zeros(mat.Row,mat.Col);
Matrix mat2=Matrix.Zeros(mat.Row,mat.Col);
if(k>=0)
{
for(int j=0;j
for(int j=k;j
}
else
{
for(int j=0;j
}
return mat2;
}
///
/// 提取矩阵的上三角阵生成上三角阵
///
///
///
public static Matrix Triu(Matrix mat)
{
Matrix mat2=Matrix.Zeros(mat.Row,mat.Col);
for(int i=0;i
return mat2;
}
///
/// 提取矩阵的上三角阵生成上三角阵
///
///
///
public static Matrix Triu(Matrix mat,int k)
{
if(k>=mat.Col)
return Matrix.Zeros(mat.Row,mat.Col);
if(k<=(1-mat.Row))
return Matrix.Clone(mat);
Matrix mat2=Matrix.Zeros(mat.Row,mat.Col);
if(k>=0)
{
for(int i=0;i
}
else
{
for(int i=0;i<(-k);i++)
for(int j=0;j
for(int i=(-k);i
}
return mat2;
}
///
/// 清掉指定行
///
public static Matrix ClearRow(Matrix A,params int[] rowvec)
{
bool[] sign=new bool[A.Row];
for(int i=0;i
if(rowvec[i]>=A.Row||rowvec[i]<0)
throw new MatrixException("要清掉的第"+rowvec[i]+"行没有");
sign[rowvec[i]]=true;
}
int row=0;
for(int i=0;i
Matrix mat=new Matrix(row,A.Col);
row=0;
for(int i=0;i
if(!sign[i])
{
for(int j=0;j
row++;
}
}
return mat;
}
///
/// 清掉指定列
///
public static Matrix ClearCol(Matrix A,params int[] colvec)
{
bool[] sign=new bool[A.Col]; //用于标记矩阵的每一列是否要被清掉
for(int i=0;i
if(colvec[i]>=A.Row||colvec[i]<0)
throw new MatrixException("要清掉的第"+colvec[i]+"列没有");
sign[colvec[i]]=true;
}
int col=0; //清掉指定列后剩余的总列数，初始化为0
for(int i=0;i
Matrix mat=new Matrix(A.Row,col); //创建用于存储清掉指定列后矩阵
//下面为mat赋值
col=0; //初始化为0，代表新矩阵的当前行
for(int j=0;j
if(!sign[j])
{
for(int i=0;i
col++;
}
}
return mat;
}
///
/// 按列改变矩阵的行数和列数得到新矩阵
///
/// 原始矩阵
/// 新矩阵的行数
/// 新矩阵的列数
///
///
/// 在总元素数不变的前提下，改变矩阵的行数和列数。如果给的行
/// 数和列数的乘积大于原矩阵总元素数，那么返回原矩阵的一个拷贝。
///
public static Matrix ReshapeCol(Matrix mat,int m,int n)
{
if((m*n)<=(mat.Row*mat.Col))
{
Matrix mat2=Matrix.Zeros(m,n);
for(int i=0;i
return mat2;
}
else
return Matrix.Clone(mat);
}
///
/// 按列改变矩阵的行数和列数得到新型矩阵
///
///
/// 在总元素数不变的前提下，改变矩阵的行数和列数，并且按列重置元素。
///
public void ReshapeCol(int newRow,int newCol)
{
if(newRow*newCol<=this.Row*this.Col)
{
double[,] newMat=new double[newRow,newCol];
for(int j=0;j
this.Mat=newMat;
this.row=newRow;
this.col=newCol;
}
}
///
/// 按行改变矩阵的行数和列数得到新矩阵
///
/// 原始矩阵
/// 新矩阵的行数
/// 新矩阵的列数
///
///
/// 在总元素数不变的前提下，改变矩阵的行数和列数。如果给的行
/// 数和列数的乘积大于原矩阵总元素数，那么返回原矩阵的一个拷贝。
public static Matrix ReshapeRow(Matrix mat,int newRow,int newCol)
{
if(newRow*newCol<=mat.Row*mat.Col)
{
Matrix newmat=Matrix.Zeros(newRow,newCol);
for(int i=0;i
return newmat;
}
else
return Matrix.Clone(mat);
}
///
/// 按行改变矩阵的行数和列数得到新型矩阵
///
///
/// 在总元素数不变的前提下，改变矩阵的行数和列数，并且按行重置元素。
///
public void ReshapeRow(int newRow,int newCol)
{
if(newRow*newCol<=this.Row*this.Col)
{
double[,] newMat=new double[newRow,newCol];
for(int i=0;i
this.Mat=newMat;
this.row=newRow;
this.col=newCol;
}
}
///
/// 按行把矩阵拉直成行矩阵
///
public static Matrix StraightRow(Matrix mat)
{
Matrix newmat=new Matrix(1,mat.Row*mat.Col);
for(int i=0;i
return newmat;
}
///
/// 按列把矩阵拉直成列矩阵
///
public static Matrix StraightCol(Matrix mat)
{
Matrix newmat=new Matrix(mat.Row*mat.Col,1);
for(int j=0;j
return newmat;
}
///
/// 生成间隔为1的行矩阵
///
public static Matrix Colon(double a,double b)
{
if(a>b) throw new MatrixException(".Colon(int,int)>中的下界大于上界");
Matrix mat=new Matrix(1,(int)Math.Floor(b-a+1));
for(int i=0;i
return mat;
}
///
/// 生成指定间隔的行矩阵
///
public static Matrix Colon(double a,double b,double inc)
{
if(inc!=0)
{
if(inc>0)
{
if(a>b) throw new MatrixException(".Colon(double,double,double)>中的下界大于上届");
}
else
{
if(a
}
Matrix mat=new Matrix(1,(int)Math.Floor((b-a)/inc+1));
for(int i=0;i
return mat;
}
else throw new MatrixException(".Colon(double,double,double)>间隔为0");
}
///
/// 均匀生成指定的两个数之间指定数目的数字的行矩阵
///
/// 采样点个数
public static Matrix Linspace(double a,double b,int n)
{
if(n<=0) throw new MatrixException(".Linspace(double,double,int)>采样点个数非正");
return Matrix.Colon(a,b,(b-a)/(n-1));
}
///
/// 在设定总数的情况下，经“常用对数”采样生成行矩阵
///
public static Matrix Logspace(double a,double b,int n)
{
return 10^Matrix.Linspace(a,b,n);
}
///
/// 按行组合两个矩阵
///
/// 前矩阵
/// 后矩阵
/// 接着的任意个（没有也可）矩阵
///
public static Matrix CombineRow(Matrix mat1,Matrix mat2,params Matrix[] mat3)
{
int maxrow; //所有矩阵的行的最大值
int sumcol; //所有矩阵的列的和
//找出所有矩阵的行的最大值与所有矩阵的列的和
if(mat1.Row>mat2.Row) maxrow=mat1.Row;
else maxrow=mat2.Row;
sumcol=mat1.Col+mat2.Col;
for(int i=0;i
if(maxrow
}
//创建新矩阵
Matrix mat=Matrix.Zeros(maxrow,sumcol);
//构造新矩阵
for(int i=0;i
int n=mat1.Col;
for(int i=0;i
n+=mat2.Col;
for(int k=0;k
for(int i=0;i
n+=mat3[k].Col;
}
return mat;
}
///
/// 按列组合两个矩阵
///
/// 上矩阵
/// 下矩阵
/// 接着的任意个（没有也可）矩阵
///
///
public static Matrix CombineCol(Matrix mat1,Matrix mat2,params Matrix[] mat3)
{
int maxcol; //所有矩阵的列的最大值
int sumrow; //所有矩阵的行的和
//找出所有矩阵的列的最大值与所有矩阵的行的和
if(mat1.Col>mat2.Col) maxcol=mat1.Col;
else maxcol=mat2.Col;
sumrow=mat1.Row+mat2.Row;
for(int k=0;k
if(maxcol
}
//创建新矩阵
Matrix mat=Matrix.Zeros(sumrow,maxcol);
//构造新矩阵
for(int i=0;i
int m=mat1.Row;
for(int i=0;i
m+=mat2.Row;
for(int k=0;k
for(int i=0;i