MyMathLib系列(矩阵算法-二)
MyMathLib系列(矩阵算法--2)
矩阵相关的算法比较多，也是比较重要的，而且算法之间的性能差异确实比较大，初等变换法求逆比古典法求逆快不是一点点。矩阵的计算量和数值其实都是比较大的，特别是20阶以上，我在机器上最多只搞到40阶，随机产生的矩阵，很容易就爆掉decimal和double类型。
另外，这里使用了操作符重载，后面的一元符号运算也用到了操作符重载，后面如果有时间，我会将这些算法利用这些特性统一起来，本来它们的计算就应该是统一的。特别是符号运算。如果符号运算搞完，还可以试试自动命题证明玩玩。
好了，上矩阵的菜（有点长，但基本都调试过，至少书上的题都能正确计算出来!）：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace MyMathLib
{
/// <summary>
/// 矩阵及相关算法.
/// </summary>
public class TMatrix
{
private int _Rank = -1;
public bool IsZero { get; private set; }
public bool IsUnit { get; private set; }
private double[][] _Elements;
public double[,] Elements
{
get
{
var theElements = new double[RowCount, ColCount];
for (int i = 0; i < RowCount; i++)
{
for (int j = 0; j < ColCount; j++)
{
theElements[i, j] = _Elements[i][j];
}
}
return theElements;
}
}
public int ColCount { get; private set; }
public int RowCount { get; private set; }
/// <summary>
/// 构造Row行,Col列矩阵，并用InitValue初始化。
/// </summary>
/// <param name="Row">矩阵行数</param>
/// <param name="Col">矩阵列数</param>
/// <param name="InitValue">初始值</param>
public TMatrix(int Row, int Col, double InitValue = 0)
{
IsZero = InitValue == 0;
IsUnit = true;
this.RowCount = Row;
this.ColCount = Col;
_Elements = new double[this.RowCount][];
for (int i = 0; i < Row; i++)
{
_Elements[i] = new double[this.ColCount];
for (int j = 0; j < this.ColCount; j++)
{
_Elements[i][j] = InitValue;
if (Row == Col)
{
if (i == j)
{
if (InitValue != 1)
{
IsUnit = false;
}
}
else
{
if (InitValue != 0)
{
IsUnit = false;
}
}
}
else
{
IsUnit = false;
}
}
}
}
/// <summary>
/// 构造Row行,Row列方阵.并用InitValue初始化
/// </summary>
/// <param name="Row">方阵行列数</param>
/// <param name="OnlyInitDiagonal">仅初始化对角线</param>
public TMatrix(int Row, double InitValue = 0, bool OnlyInitDiagonal = false)
{
IsZero = InitValue == 0;
IsUnit = (InitValue == 1 && OnlyInitDiagonal);
this.RowCount = Row;
this.ColCount = Row;
_Elements = new double[this.RowCount][];
for (int i = 0; i < Row; i++)
{
_Elements[i] = new double[this.ColCount];
if (OnlyInitDiagonal)
{
_Elements[i][i] = InitValue;
}
else
{
for (int j = 0; j < this.ColCount; j++)
{
_Elements[i][j] = InitValue;
}
}
}
}
public TMatrix(double[][] InitElements)
{
if (InitElements == null)
{
throw new Exception("矩阵不能为空!");
}
IsZero = true;
IsUnit = true;
_Elements = InitElements;
RowCount = _Elements.Length;
ColCount = _Elements[0].Length;
for (int i = 0; i < RowCount; i++)
{
for (int j = 0; j < this.ColCount; j++)
{
if (_Elements[i][j] != 0)
{
IsZero = false;
}
if (RowCount == ColCount)
{
if (i == j)
{
if (_Elements[i][j] != 1)
{
IsUnit = false;
}
}
else
{
if (_Elements[i][j] != 0)
{
IsUnit = false;
}
}
}
else
{
IsUnit = false;
}
}
}
}
public TMatrix(double[,] InitElements)
{
if (InitElements == null)
{
throw new Exception("矩阵不能为空!");
}
IsZero = true;
IsUnit = true;
RowCount = InitElements.GetLength(0);
ColCount = InitElements.GetLength(1);
_Elements = new double[RowCount][];
for (int i = 0; i < RowCount; i++)
{
_Elements[i] = new double[ColCount];
for (int j = 0; j < ColCount; j++)
{
this[i, j] = InitElements[i, j];
}
}
}
public double this[int i, int j]
{
get
{
return _Elements[i][j];
}
set
{
if (value != 0)
{
this.IsZero = false;
}
if (Math.Round(value,8) != 1)
{
this.IsUnit = false;
}
else
{
if (i != j)
{
this.IsUnit = false;
}
}
_Elements[i][j] = value;
}
}
public double[] this[int i]
{
get
{
return _Elements[i];
}
}
public double[] this[int i, bool GetCol]
{
get
{
double[] theResult = new double[RowCount];
for (int k = 0; k < RowCount; k++)
{
theResult[k] = _Elements[k][i];
}
return theResult;
}
}
public void SwapRow(int i, int j)
{
if (i != j)
{
double[] theTemp = _Elements[i];
_Elements[i] = _Elements[j];
_Elements[j] = theTemp;
}
}
public void SwapCol(int i, int j)
{
if (i != j)
{
for (int k = 0; k < RowCount; k++)
{
double theTemp = _Elements[k][j];
_Elements[k][j] = _Elements[k][i];
_Elements[k][i] = theTemp;
}
}
}
public bool IsSquareMatrix
{
get
{
return this.ColCount == this.RowCount;
}
}
public void CopyFrom(TMatrix A)
{
if (A.RowCount != this.RowCount || A.ColCount != this.ColCount)
{
throw new Exception("不是同型矩阵不能拷贝!");
}
for (int i = 0; i < A.RowCount; i++)
{
for (int j = 0; j < A.ColCount; j++)
{
this[i, j] = A[i, j];
}
}
}
#region 初等变换
/// <summary>
/// 行初等变换1：交换两行.
/// </summary>
/// <param name="i"></param>
/// <param name="j"></param>
private void EleTransRow1(int i, int j)
{
SwapRow(i, j);
}
/// <summary>
/// 行初等变换2：用一个非零数乘以一行.
/// </summary>
/// <param name="RowIndex">行号</param>
/// <param name="Multiplier">乘数，不能为零</param>
private void EleTransRow2(int RowIndex, double Multiplier)
{
if (Multiplier == 1)
{
return;
}
if (Multiplier != 0)
{
for (int j = 0; j < ColCount; j++)
{
this[RowIndex, j] = this[RowIndex, j] * Multiplier;
}
}
}
/// <summary>
/// 行初等变换3：行1减行2
/// </summary>
/// <param name="Row1">行号1</param>
/// <param name="Row2">行号2</param>
private void EleTransRow3(int Row1, int Row2, double Multiplier)
{
for (int j = 0; j < ColCount; j++)
{
this[Row1, j] = this[Row1, j] - this[Row2, j] * Multiplier;
}
}
/// <summary>
/// 行初等变换4：行1 * 系数1 - 行2 * 系数2
/// </summary>
/// <param name="Row1">行号</param>
/// <param name="M1">乘数1，不能为零</param>
/// <param name="M2">乘数2，不能为零</param>
private void EleTransRow4(int Row1, int Row2,double M1,double M2)
{
for (int j = 0; j < ColCount; j++)
{
this[Row1, j] = this[Row1, j] * M1 - this[Row2, j] * M2;
}
}
/// <summary>
/// 列初等变换1：交换两列.
/// </summary>
/// <param name="i"></param>
/// <param name="j"></param>
public void EleTransCol1(int i, int j)
{
SwapCol(i, j);
}
/// <summary>
/// 列初等变换2：用一个非零数乘以一列.
/// </summary>
/// <param name="ColIndex">列号</param>
/// <param name="Multiplier">乘数，不能为零</param>
public void EleTransCol2(int ColIndex, double Multiplier)
{
if (Multiplier != 0)
{
for (int j = 0; j < RowCount; j++)
{
this[j, ColIndex] = this[j, ColIndex] * Multiplier;
}
}
}
/// <summary>
/// 列初等变换3：列1减列2
/// </summary>
/// <param name="Row1">列号1</param>
/// <param name="Row2">列号2</param>
public void EleTransCol3(int Col1, int Col2, double Multiplier)
{
for (int j = 0; j < RowCount; j++)
{
this[j, Col1] = this[j, Col1] - this[j, Col2] * Multiplier;
}
}
/// <summary>
/// 列初等变换4：列1 * 系数1 - 列2 * 系数2
/// </summary>
/// <param name="Col1">列号</param>
/// <param name="Col2">列号2</param>
/// <param name="M1">乘数1，不能为零</param>
/// <param name="M2">乘数2，不能为零</param>
public void EleTransCol4(int Col1, int Col2, double M1, double M2)
{
for (int j = 0; j < RowCount; j++)
{
this[j, Col1] = this[j, Col1] * M1 - this[j, Col2] * M2;
}
}
#endregion
/// <summary>
/// 矩阵消元,转换成阶梯矩阵
/// 本算法也可以用来求矩阵的秩.
/// 仅用行初等变换.
/// </summary>
public void TransToEchelonMatrix(List<TransformItem> TransformRecords)
{
//从第1列到第theE列进行变换.
//最大非0行,用以标记进行变换到现在，可以继续进行处理的最小行号.
var theNoZeroIndex = 0;
for (int i = 0; i < this.ColCount; i++)
{
var theR = -1;
for (int j = theNoZeroIndex; j < this.RowCount; j++)
{
if (this[j, i] != 0)
{
theR = j;
break;
}
}
if (theR >= 0)
{
//将找到非零元素行交换到当前行.
TransformRecords.Add(TransformItem.CreateEleTransRow1(theR, theNoZeroIndex));
EleTransRow1(theR, theNoZeroIndex);
//将大于当前行的列初等变换为0
var theM1 = this[theNoZeroIndex, i];
for (int k = theNoZeroIndex + 1; k < this.RowCount; k++)
{
var theRate = Math.Round(this[k, i] / theM1,ConstDef.Decimals);
TransformRecords.Add(TransformItem.CreateEleTransRow4(k, theNoZeroIndex, 1, theRate));
EleTransRow4(k, theNoZeroIndex, 1, theRate);
}
theNoZeroIndex++;
}
}
}
/// <summary>
/// 变换成标准形.方法很简单：先用行初等变换，尽量消元，然后用列初等变换，尽量消元.
/// 但在这里会同时用到行列的初等变换.这里采用变换函数，如果为了效率，其实可以将初等
/// 变换代码直接写到函数里。
/// </summary>
public List<TransformItem> TransToStandardForm()
{
var theTransList = new List<TransformItem>();
//从第i=1行开始，使得[i,i]不等于0，然后将剩余的i行,i列的元素通过初等变换变成0.
//如果[i,i]无法获得非零元素则变换终止.
for (int i = 0; i < this.RowCount; i++)
{
//如果[i,i]等于0，则进行行交换直到到交换到[i,i]变为非零元素,
//如果没找到，就找列，如果都没找到，则终止
var theRow = -1;
var theCol = -1;
//在行>i,列>i的所有元素中找到一个非零值，如果找到，就进行初等变换
//如果没找到，则说明完成标准型转换.
var theFind = false;
for (int r = i; r < this.RowCount; r++)
{
for (int c = i; c < this.ColCount; c++)
{
if (this[r, c] != 0)
{
theRow = r;
theCol = c;
theFind = true;
break;
}
}
if (theFind)
{
break;
}
}
if (theFind)
{
//先做行变换，再做列变换，目的是将找到的非零元素交换到当前位置.
//行初等变换1,
theTransList.Add(TransformItem.CreateEleTransRow1(i, theRow));
EleTransRow1(i, theRow);
//列初等变换
theTransList.Add(TransformItem.CreateEleTransCol1(i, theCol));
EleTransCol1(i, theCol);
//将[i,i] 变为1
double theMultipler = Math.Round((double)1 / this[i, i], ConstDef.Decimals);
//行初等变换2(这里采用列也是一样，是等价的)
theTransList.Add(TransformItem.CreateEleTransRow2(i, theMultipler));
EleTransRow2(i, theMultipler);
//将i行上>i的列上的其它元素变换成0
for (int c = i + 1; c < this.ColCount; c++)
{
var theM2 = this[i,c];
//c=c*1-i*theM2,这个函数其实是综合了几个初等变换.
theTransList.Add(TransformItem.CreateEleTransCol4(c, i,1, theM2));
EleTransCol4(c, i, 1, theM2);
}
//将i列上>i的行上的其它元素变换成0
for (int r = i + 1; r < this.RowCount; r++)
{
var theM2 = this[r, i];
//c=c*1-i*theM2,这个函数其实是综合了几个初等变换.
theTransList.Add(TransformItem.CreateEleTransRow4(r, i,1,theM2));
EleTransRow4(r, i, 1, theM2);
}
}
else
{
break;
}
}
return theTransList;
}
/// <summary>
/// 变换成标准形:这里仅采用行变换.但需要注意的是这里如果不是满秩矩阵，
/// 得到的就不一定是标准型.这个转换主要用于求矩阵的逆.
/// </summary>
/// <returns>变换过程记录.</returns>
public List<TransformItem> TransToStandardForm2()
{
var theTransfromRecords = new List<TransformItem>();
//先把矩阵转换成上三角矩阵。
TransToEchelonMatrix(theTransfromRecords);
//然后从最后一列开始，第1行开始变换为0.
for (int j = this.ColCount - 1; j >= 0; j--)
{
//从下到上找到第1个非0行，作为基准行(减少行)
//因为矩阵的下半部分全为0,则开始找的位置在对角线上开始.
int theR = -1;
int theStartIndex = Math.Min(j,this.RowCount-1);
for (int i = theStartIndex; i >= 0; i--)
{
if (this[i, j] != 0)
{
theR = i;
break;
}
}
//如果找到基准行，则开始变换，利用减去基准行*一个系数来消除第0到thR-1行的元素
if (theR >= 0)
{
for (int i = 0; i < theR; i++)
{
var theRate = Math.Round(this[i, j] / this[theR, j], ConstDef.Decimals);
theTransfromRecords.Add(TransformItem.CreateEleTransRow4(i, theR, 1, theRate));
EleTransRow4(i, theR, 1, theRate);
}
}
}
//将对角线上的元素化为1
var theMinRC = Math.Min(this.ColCount, this.RowCount);
for (int i = 0; i < theMinRC; i++)
{
if (this[i, i] != 0)
{
var theRate = Math.Round((double)1.0 / this[i, i], ConstDef.Decimals);
EleTransRow2(i, theRate);
theTransfromRecords.Add(TransformItem.CreateEleTransRow2(i, theRate));
}
}
return theTransfromRecords;
}
/// <summary>
/// 对矩阵按照TransformItems里的变换做变换
/// </summary>
/// <param name="TransformItems">变换集合</param>
public void DoTransform(List<TransformItem> TransformItems)
{
if (TransformItems == null)
{
return;
}
for (int i = 0; i < TransformItems.Count; i++)
{
var theTransItem = TransformItems[i];
switch (theTransItem.RowOrCol)
{
case TransRowOrCol.Row:
switch (theTransItem.TransMethod)
{
case BasicTransMethod.Swap:
EleTransRow1(theTransItem.i, theTransItem.j);
break;
case BasicTransMethod.Multipler:
EleTransRow2(theTransItem.i, theTransItem.M1);
break;
case BasicTransMethod.CoPlus1:
EleTransRow3(theTransItem.i, theTransItem.j, theTransItem.M1);
break;
case BasicTransMethod.CoPlus2:
EleTransRow4(theTransItem.i, theTransItem.j,theTransItem.M1,theTransItem.M2);
break;
}
break;
case TransRowOrCol.Col:
switch (theTransItem.TransMethod)
{
case BasicTransMethod.Swap:
EleTransCol1(theTransItem.i, theTransItem.j);
break;
case BasicTransMethod.Multipler:
EleTransCol2(theTransItem.i, theTransItem.M1);
break;
case BasicTransMethod.CoPlus1:
EleTransCol3(theTransItem.i, theTransItem.j, theTransItem.M1);
break;
case BasicTransMethod.CoPlus2:
EleTransCol4(theTransItem.i, theTransItem.j, theTransItem.M1, theTransItem.M2);
break;
}
break;
}
}
}
public TMatrix Clone()
{
var theA = new TMatrix(this.RowCount, this.ColCount);
for (int i = 0; i < theA.RowCount; i++)
{
for (int j = 0; j < theA.ColCount; j++)
{
theA[i, j] = this[i, j];
}
}
return theA;
}
public static TMatrix NewZeroMatrix(int Row, int Col)
{
return new TMatrix(Row, Col, 0);
}
public static TMatrix NewSquareMatrix(int n)
{
return new TMatrix(n, 1, true);
}
/// <summary>
/// 转置矩阵
/// </summary>
/// <param name="A">矩阵</param>
/// <returns>转置矩阵</returns>
public static TMatrix Transposition(TMatrix A)
{
var theRetM = new TMatrix(A.ColCount, A.RowCount);
for (int i = 0; i < A.RowCount; i++)
{
for (int j = 0; j < A.ColCount; j++)
{
theRetM[j, i] = A[i, j];
}
}
return theRetM;
}
public static TMatrix SwapRow(TMatrix A, int i, int j)
{
var theA = A.Clone();
theA.SwapRow(i, j);
return theA;
}
public static TMatrix SwapCol(TMatrix A, int i, int j)
{
var theA = A.Clone();
theA.SwapCol(i, j);
return theA;
}
public static TMatrix operator +(TMatrix A, TMatrix B)
{
if (A.RowCount != B.RowCount || A.ColCount != B.ColCount)
{
throw new Exception("不是同型矩阵不能相加!");
}
double[][] theResult = new double[A.RowCount][];
for (int i = 0; i < A.RowCount; i++)
{
theResult[i] = new double[A.ColCount];
for (int j = 0; j < A.ColCount; j++)
{
theResult[i][j] = A[i, j] + B[i, j];
}
}
return new TMatrix(theResult);
}
public static TMatrix operator -(TMatrix A)
{
var theA = new TMatrix(A.RowCount, A.ColCount);
for (int i = 0; i < A.RowCount; i++)
{
for (int j = 0; j < A.ColCount; j++)
{
theA[i, j] = 0 - A[i, j];
}
}
return theA;
}
public static TMatrix operator -(TMatrix A, TMatrix B)
{
if (A.RowCount != B.RowCount || A.ColCount != B.ColCount)
{
throw new Exception("不是同型矩阵，不能相减");
}
var theA = new TMatrix(A.RowCount, A.ColCount);
for (int i = 0; i < A.RowCount; i++)
{
for (int j = 0; j < A.ColCount; j++)
{
theA[i, j] = A[i, j] - B[i, j];
}
}
return theA;
}
public static TMatrix operator *(double K, TMatrix A)
{
if (A.IsZero)
{
return TMatrix.NewZeroMatrix(A.RowCount, A.ColCount);
}
var theA = new TMatrix(A.RowCount, A.ColCount);
for (int i = 0; i < A.RowCount; i++)
{
for (int j = 0; j < A.ColCount; j++)
{
theA[i, j] = K * A[i, j];
}
}
return theA;
}
public static TMatrix operator *(decimal K, TMatrix A)
{
return K * A;
}
public static TMatrix operator *(TMatrix A, double K)
{
return K * A;
}
public static TMatrix operator *(TMatrix A, TMatrix B)
{
if (A.ColCount != B.RowCount)
{
throw new Exception("A的列数不等于B的行数，不能相乘！");
}
if (A.IsZero)
{
return TMatrix.NewZeroMatrix(A.RowCount, B.ColCount);
}
if (A.IsUnit)
{
return B.Clone();
}
if (B.IsUnit)
{
return A.Clone();
}
double[][] theResult = new double[A.RowCount][];
for (int i = 0; i < A.RowCount; i++)
{
theResult[i] = new double[B.ColCount];
for (int j = 0; j < B.ColCount; j++)
{
theResult[i][j] = 0;
for (int k = 0; k < A.ColCount; k++)
{
theResult[i][j] += A[i, k] * B[k, j];
}
}
}
return new TMatrix(theResult);
}
public static TMatrix operator ^(TMatrix A, int K)
{
if (A.IsSquareMatrix)
{
if (A.IsUnit)
{
return A.Clone();
}
if (A.IsZero)
{
return TMatrix.NewZeroMatrix(A.RowCount, A.ColCount);
}
if (K == 0)
{
return TMatrix.NewSquareMatrix(A.RowCount);
}
if (K == 1)
{
return A.Clone();
}
var theA = A;
if (K < 0)
{
theA = GetInverseMatrix(A);
}
var theRet = theA;
for (int i = 1; i < K; K++)
{
theRet = theRet * theA;
}
return theRet;
}
throw new Exception("只有方阵才能做幂运算!");
}
public static bool operator ==(TMatrix A, TMatrix B)
{
if (A.RowCount != B.RowCount || A.ColCount != B.ColCount)
{
throw new Exception("不是同型矩阵，不能比较");
}
if (A.IsUnit && B.IsUnit || A.IsZero && B.IsZero)
{
return true;
}
for (int i = 0; i < A.RowCount; i++)
{
for (int j = 0; j < A.ColCount; j++)
{
if (A[i, j] != B[i, j])
{
return false;
}
}
}
return true;
}
public static bool operator !=(TMatrix A, TMatrix B)
{
if (A.RowCount != B.RowCount || A.ColCount != B.ColCount)
{
throw new Exception("不是同型矩阵，不能比较");
}
if (A.IsUnit && B.IsUnit || A.IsZero && B.IsZero)
{
return false;
}
for (int i = 0; i < A.RowCount; i++)
{
for (int j = 0; j < A.ColCount; j++)
{
if (A[i, j] != B[i, j])
{
return true;
}
}
}
return true;
}
/// <summary>
/// 初等变换法求矩阵A的逆.
/// </summary>
/// <param name="A"></param>
/// <returns></returns>
public static TMatrix GetInverseMatrix(TMatrix A)
{
var theA = A.Clone();
var theTransItems = theA.TransToStandardForm2();
var theE = new TMatrix(theA.RowCount, 1, true);
theE.DoTransform(theTransItems);
return theE;
}
/// <summary>
/// 古典法求逆矩阵
/// </summary>
/// <param name="A">方阵</param>
/// <returns></returns>
public static TMatrix GetInverseMatrix2(TMatrix A)
{
if (A.RowCount != A.ColCount)
{
throw new Exception("次函数仅支持方阵!");
}
//计算其行列式的值
var theValOfA = LinearAlgebra.CalcDeterminant(A.Elements);
if (theValOfA == 0)
{
throw new Exception("不可逆！");
}
if (A.RowCount == 1)
{
return new TMatrix(1, 1, Math.Round((double)1.0 / theValOfA,ConstDef.Decimals));
}
//求伴随矩阵
//var theAdjoint = new TMatrix(A.RowCount);
var theAElements = A.Elements;
var theMElements = new double[A.RowCount, A.ColCount];
for (int i = 0; i < A.RowCount; i++)
{
for (int j = 0; j < A.ColCount; j++)
{
var theMij = LinearAlgebra.GetDeterminantMij(theAElements, i + 1, j + 1);
var theSign = LinearAlgebra.CalcDeterMijSign(i+1, j+1);
var theValOfAij = theSign * LinearAlgebra.CalcDeterminant(theMij);
//注意这里.弄反了，结果就是逆矩阵的转置矩阵.
theMElements[j, i] = theValOfAij;
}
}
//计算伴随矩阵结果.
return (Math.Round((double)1.0 / theValOfA,ConstDef.Decimals)) * (new TMatrix(theMElements));
}
/// <summary>
/// 获取矩阵的秩.
/// </summary>
/// <returns></returns>
public int GetRank()
{
if (_Rank < 0)
{
var theA = this.Clone();
theA.TransToStandardForm();
_Rank = GetRank(theA);
}
return _Rank;
}
public static int GetRank(TMatrix StdForm)
{
int theRank = 0;
for (int i = 0; i < StdForm.ColCount && i < StdForm.RowCount; i++)
{
if (StdForm[i, i] == 1)
{
theRank++;
continue;
}
}
return theRank;
}
/// <summary>
/// 是否是标量矩阵
/// </summary>
public bool IsScalarMatrix
{
get
{
if (this.RowCount != this.ColCount)
{
return false;
}
var theScalar = _Elements[0][0];
for (int i = 0; i < this.RowCount; i++)
{
for (int j = 0; j < this.ColCount; j++)
{
if (i != j)
{
if (_Elements[i][j] != 0)
{
return false;
}
}
else
{
if (_Elements[i][i] != theScalar)
{
return false;
}
}
}
}
return true;
}
}
/// <summary>
/// 对角矩阵 非对角线上的元素全部为0方阵
/// </summary>
public bool IsDiagonalMatrix
{
get
{
if (this.RowCount != this.ColCount)
{
return false;
}
for (int i = 0; i < this.RowCount; i++)
{
for (int j = 0; j < this.ColCount; j++)
{
if (i != j)
{
if (_Elements[i][j] != 0)
{
return false;
}
}
}
}
return true;
}
}
/// <summary>
/// 上三角矩阵
/// </summary>
public bool IsUpperTriangularMatrix
{
get
{
if (this.RowCount != this.ColCount)
{
return false;
}
for (int i = 0; i < this.ColCount; i++)
{
for (int j = i + 1; j < this.RowCount; j++)
{
if (_Elements[j][i] != 0)
{
return false;
}
}
}
return true;
}
}
/// <summary>
/// 下三角矩阵
/// </summary>
public bool IsLowerTriangularMatrix
{
get
{
if (this.RowCount != this.ColCount)
{
return false;
}
for (int i = 0; i < this.ColCount; i++)
{
for (int j = 0; j < i; j++)
{
if (_Elements[j][i] != 0)
{
return false;
}
}
}
return true;
}
}
/// <summary>
/// 对称矩阵Aij=Aij.
/// </summary>
public bool IsSymmetricMatrix
{
get
{
if (this.RowCount != this.ColCount)
{
return false;
}
for (int i = 0; i < this.RowCount; i++)
{
for (int j = 0; j < this.ColCount; j++)
{
if (_Elements[j][i] != _Elements[i][j])
{
return false;
}
}
}
return true;
}
}
/// <summary>
/// 反对称矩阵Aij=-Aji.注意其对角线元素为0.
/// </summary>
public bool IsAntisymmetricMatrix
{
get
{
if (this.RowCount != this.ColCount)
{
return false;
}
for (int i = 0; i < this.RowCount; i++)
{
for (int j = 0; j < this.ColCount; j++)
{
if (i == j)
{
if (_Elements[j][i] != 0)
{
return false;
}
}
else
{
if (_Elements[j][i] != -_Elements[i][j])
{
return false;
}
}
}
}
return true;
}
}
/// <summary>
/// 正交矩阵A*t(A)=E.
/// </summary>
public bool IsOrthogonalMatrix
{
get
{
if (this.RowCount != this.ColCount)
{
return false;
}
var theA = this.Clone();
var theAt = Transposition(theA);
var theRet = theA * theAt;
return theRet.IsUnit;
}
}
/// <summary>
/// 零幂矩阵(A^k=O)。
/// |A|==0
/// </summary>
public bool IsZeroPowerMatrix
{
get
{
if (this.RowCount != this.ColCount)
{
return false;
}
var theVal = LinearAlgebra.CalcDeterminant(this.Elements);
return theVal == 0;
}
}
}
}