命名空间:matrix
定义类:Matrix
方法:
public Matrix(int mm, int nn)
定义矩阵A:
Matrix A=new Matrix(int mm, int nn);
public double read(int i, int j)
获取Aij:
A.read(i,j);
public int write(int i, int j, double val)
将数据b写入Aij:
A.read(i,j,b);
释放矩阵:
public void freeMatrix()
A.freeMatrix();
方法:
//C = A + B
//成功返回1,失败返回-1
public int add(ref Matrix A, ref Matrix B, ref Matrix C)
//C = A - B
//成功返回1,失败返回-1
public int subtract(ref Matrix A, ref Matrix B, ref Matrix C)
//C = A * B
//成功返回1,失败返回-1
public int multiply(ref Matrix A, ref Matrix B, ref Matrix C)
//行列式的值,只能计算2 * 2,3 * 3
//失败返回-31415,成功返回值
public double det(ref Matrix A)
//求转置矩阵,B = AT
//成功返回1,失败返回-1
public int transpos(ref Matrix A, ref Matrix B)
//求逆矩阵,B = A^(-1)
//成功返回1,失败返回-1
public int inverse(ref Matrix A, ref Matrix B)
//矩阵输出//
public string Out(ref Matrix A)
//矩阵格式化输出//
public string Outt(ref Matrix A, string format)
//矩阵一维数组赋值//
public void Fuzhi( ref Matrix A , double[] arr)
//方阵行列式值//
public double Det(ref Matrix A)
//矩阵的伴随矩阵//
public void Accompany(ref Matrix A, ref Matrix B)
//伴随矩阵法求矩阵的逆//
public void Inverse(ref Matrix A, ref Matrix B)
//矩阵相等//
public void Equal(ref Matrix A, ref Matrix B)
//C = A + B
//成功返回1,失败返回-1
A.add(ref Matrix A, ref Matrix B, ref Matrix C);
//C = A - B
//成功返回1,失败返回-1
A.subtract(ref Matrix A, ref Matrix B, ref Matrix C)
//C = A * B
//成功返回1,失败返回-1
A.multiply(ref Matrix A, ref Matrix B, ref Matrix C)
//行列式的值,只能计算2 * 2,3 * 3
//失败返回-31415,成功返回值
A.det(ref Matrix A)
//求转置矩阵,B = AT
//成功返回1,失败返回-1
A.transpos(ref Matrix A, ref Matrix B)
//求逆矩阵,B = A^(-1)
//成功返回1,失败返回-1
A.inverse(ref Matrix A, ref Matrix B)
//矩阵输出//
A.Out(ref Matrix A)
//矩阵6位小数输出//
A.Outt(ref Matrix A)
//矩阵一维数组赋值//
A.Fuzhi( ref Matrix A , double[] arr)
//方阵行列式值//
A.Det(ref Matrix A)
//矩阵格式化输出//
public string Outt(ref Matrix A, string format)
A.Outt(ref Matrix A, string format);
//矩阵的伴随矩阵//
public void Accompany(ref Matrix A, ref Matrix B)
A.Accompany(ref Matrix A, ref Matrix B);
//伴随矩阵法求矩阵的逆//
public void Inverse(ref Matrix A, ref Matrix B)
A.Inverse(ref Matrix A, ref Matrix B);
//矩阵相等//
public void Equal(ref Matrix A, ref Matrix B)
A.Equal(ref Matrix A, ref Matrix B);
格式说明符说明 示例 输出
C 货币 2.5.ToString(“C”) ¥2.50
D 十进制数 25.ToString(“D5”) 00025
E 科学型 25000.ToString(“E”) 2.500000E+005
F 固定点 25.ToString(“F2”) 25.00
G 常规 2.5.ToString(“G”) 2.5
N 数字 2500000.ToString(“N”) 2,500,000.00
X 十六进制 255.ToString(“X”) FF
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace matrix
{
//矩阵数据结构
//二维矩阵
public class Matrix
{
public int m;
public int n;
public double[] arr;
//初始化
public Matrix()
{
m = 0;
n = 0;
}
public Matrix(int mm, int nn)
{
m = mm;
n = nn;
arr = new double[m * n];
}
//设置m
public void set_mn(int mm, int nn)
{
m = mm;
n = nn;
}
//设置m
public void set_m(int mm)
{
m = mm;
}
//设置n
public void set_n(int nn)
{
n = nn;
}
//初始化
public void initMatrix()
{
arr = new double[m * n];
}
//释放
public void freeMatrix()
{
//delete [] arr;
}
//读取i,j坐标的数据
//失败返回-31415,成功返回值
public double read(int i, int j)
{
if (i >= m || j >= n)
{
return -31415;
}
//return *(arr + i * n + j);
return arr[i * n + j];
}
//写入i,j坐标的数据
//失败返回-1,成功返回1
public int write(int i, int j, double val)
{
if (i >= m || j >= n)
{
return -1;
}
arr[i * n + j] = val;
return 1;
}
//二维运算类
//初始化
//C = A + B
//成功返回1,失败返回-1
public int add(ref Matrix A, ref Matrix B, ref Matrix C)
{
int i = 0;
int j = 0;
//判断是否可以运算
if (A.m != B.m || A.n != B.n ||
A.m != C.m || A.n != C.n)
{
return -1;
}
//运算
for (i = 0; i < C.m; i++)
{
for (j = 0; j < C.n; j++)
{
C.write(i, j, A.read(i, j) + B.read(i, j));
}
}
return 1;
}
//C = A - B
//成功返回1,失败返回-1
public int subtract(ref Matrix A, ref Matrix B, ref Matrix C)
{
int i = 0;
int j = 0;
//判断是否可以运算
if (A.m != B.m || A.n != B.n ||
A.m != C.m || A.n != C.n)
{
return -1;
}
//运算
for (i = 0; i < C.m; i++)
{
for (j = 0; j < C.n; j++)
{
C.write(i, j, A.read(i, j) - B.read(i, j));
}
}
return 1;
}
//C = A * B
//成功返回1,失败返回-1
public int multiply(ref Matrix A, ref Matrix B, ref Matrix C)
{
int i = 0;
int j = 0;
int k = 0;
double temp = 0;
//判断是否可以运算
if (A.m != C.m || B.n != C.n ||
A.n != B.m)
{
return -1;
}
//运算
for (i = 0; i < C.m; i++)
{
for (j = 0; j < C.n; j++)
{
temp = 0;
for (k = 0; k < A.n; k++)
{
temp += A.read(i, k) * B.read(k, j);
}
C.write(i, j, temp);
}
}
return 1;
}
//行列式的值,只能计算2 * 2,3 * 3
//失败返回-31415,成功返回值
public double det(ref Matrix A)
{
double value = 0;
//判断是否可以运算
if (A.m != A.n || (A.m != 2 && A.m != 3))
{
return -31415;
}
//运算
if (A.m == 2)
{
value = A.read(0, 0) * A.read(1, 1) - A.read(0, 1) * A.read(1, 0);
}
else
{
value = A.read(0, 0) * A.read(1, 1) * A.read(2, 2) +
A.read(0, 1) * A.read(1, 2) * A.read(2, 0) +
A.read(0, 2) * A.read(1, 0) * A.read(2, 1) -
A.read(0, 0) * A.read(1, 2) * A.read(2, 1) -
A.read(0, 1) * A.read(1, 0) * A.read(2, 2) -
A.read(0, 2) * A.read(1, 1) * A.read(2, 0);
}
return value;
}
//求转置矩阵,B = AT
//成功返回1,失败返回-1
public int transpos(ref Matrix A, ref Matrix B)
{
int i = 0;
int j = 0;
//判断是否可以运算
if (A.m != B.n || A.n != B.m)
{
return -1;
}
//运算
for (i = 0; i < B.m; i++)
{
for (j = 0; j < B.n; j++)
{
B.write(i, j, A.read(j, i));
}
}
return 1;
}
//求逆矩阵,B = A^(-1)
//成功返回1,失败返回-1
public int inverse(ref Matrix A, ref Matrix B)
{
int i = 0;
int j = 0;
int k = 0;
Matrix m = new Matrix(A.m, 2 * A.m);
double temp = 0;
double b = 0;
//判断是否可以运算
if (A.m != A.n || B.m != B.n || A.m != B.m)
{
return -1;
}
/*
//如果是2维或者3维求行列式判断是否可逆
if (A.m == 2 || A.m == 3)
{
if (det(A) == 0)
{
return -1;
}
}
*/
//增广矩阵m = A | B初始化
m.initMatrix();
for (i = 0; i < m.m; i++)
{
for (j = 0; j < m.n; j++)
{
if (j <= A.n - 1)
{
m.write(i, j, A.read(i, j));
}
else
{
if (i == j - A.n)
{
m.write(i, j, 1);
}
else
{
m.write(i, j, 0);
}
}
}
}
//高斯消元
//变换下三角
for (k = 0; k < m.m - 1; k++)
{
//如果坐标为k,k的数为0,则行变换
if (m.read(k, k) == 0)
{
for (i = k + 1; i < m.m; i++)
{
if (m.read(i, k) != 0)
{
break;
}
}
if (i >= m.m)
{
return -1;
}
else
{
//交换行
for (j = 0; j < m.n; j++)
{
temp = m.read(k, j);
m.write(k, j, m.read(k + 1, j));
m.write(k + 1, j, temp);
}
}
}
//消元
for (i = k + 1; i < m.m; i++)
{
//获得倍数
b = m.read(i, k) / m.read(k, k);
//行变换
for (j = 0; j < m.n; j++)
{
temp = m.read(i, j) - b * m.read(k, j);
m.write(i, j, temp);
}
}
}
//变换上三角
for (k = m.m - 1; k > 0; k--)
{
//如果坐标为k,k的数为0,则行变换
if (m.read(k, k) == 0)
{
for (i = k + 1; i < m.m; i++)
{
if (m.read(i, k) != 0)
{
break;
}
}
if (i >= m.m)
{
return -1;
}
else
{
//交换行
for (j = 0; j < m.n; j++)
{
temp = m.read(k, j);
m.write(k, j, m.read(k + 1, j));
m.write(k + 1, j, temp);
}
}
}
//消元
for (i = k - 1; i >= 0; i--)
{
//获得倍数
b = m.read(i, k) / m.read(k, k);
//行变换
for (j = 0; j < m.n; j++)
{
temp = m.read(i, j) - b * m.read(k, j);
m.write(i, j, temp);
}
}
}
//将左边方阵化为单位矩阵
for (i = 0; i < m.m; i++)
{
if (m.read(i, i) != 1)
{
//获得倍数
b = 1 / m.read(i, i);
//行变换
for (j = 0; j < m.n; j++)
{
temp = m.read(i, j) * b;
m.write(i, j, temp);
}
}
}
//求得逆矩阵
for (i = 0; i < B.m; i++)
{
for (j = 0; j < B.m; j++)
{
B.write(i, j, m.read(i, j + m.m));
}
}
//释放增广矩阵
m.freeMatrix();
return 1;
}
//矩阵输出//
public string Out(ref Matrix A)
{
string s = null;
int i, j;
for (i = 0; i < A.m; i++)
{
for (j = 0; j < A.n; j++)
s += A.read(i, j).ToString() + " ";
s += "\r\n";
}
return s;
}
public string Outt(ref Matrix A, string format)
{
string s = null, m = null;
m = "{" + "0:" + format + "}";
int i, j;
for (i = 0; i < A.m; i++)
{
for (j = 0; j < A.n; j++)
s += A.read(i, j).ToString(format) + " ";
s += "\r\n";
}
return s;
}
public void Fuzhi(ref Matrix A, double[] arr)
{
int i, j, k = 0;
for (i = 0; i < A.m; i++)
{
for (j = 0; j < A.n; j++)
A.write(i, j, arr[k++]);
}
}
public void Accompany(ref Matrix A, ref Matrix B)
{
int m = 0; int n = 0;
Matrix Q = new Matrix(A.m - 1, A.n - 1);//用于求伴随矩阵过程中过渡矩阵//
//Matrix_Calc C = new Matrix_Calc();
for (int i = 0; i < A.m; i++)
for (int j = 0; j < A.n; j++)//遍历矩阵A中元素//
{
for (int p = 0; p < A.m - 1; p++)
{
for (int q = 0; q < A.n - 1; q++)//写入过渡矩阵//
{
if (m == i)
m++;
if (n == j)
n++;
Q.write(p, q, A.read(m, n++));
}
n = 0;
m++;
}
// Console.Write("\r\n {0} \r\n",C.Out(ref Q));//验证过渡矩阵结果是否正确//
m = 0; n = 0;
B.write(i, j, Math.Pow(-1.0, Convert.ToDouble(i + j)) * Q.Det(ref Q));
}
// Console.Write("\r\n {0} \r\n", C.Out(ref B));//验证伴随矩阵结果是否正确//
}
public void Inverse(ref Matrix A, ref Matrix B)
{
//Matrix_Calc Q = new Matrix_Calc();
Matrix C = new Matrix(A.m, A.n);
C.Accompany(ref A, ref C);
for (int i = 0; i < A.m; i++)
for (int j = 0; j < A.n; j++)
B.write(i, j, C.read(i, j) / C.Det(ref A));
// Console.Write("{0}", C.Out(ref B));//验证逆阵结果
}
public void Equal(ref Matrix A, ref Matrix B)
{
for (int i = 0; i < A.m; i++)
for (int j = 0; j < A.n; j++)
B.write(i, j, A.read(i, j));
}
public double Det(ref Matrix A)
{
Matrix R = new Matrix(A.m, A.n);
R.Equal(ref A, ref R);
// string s = null;
double f = 0.0;
int j, n = 0;
double B, D;
double[] huanhangi = new double[A.n];//定义一个交换行的中间数组//
double[] huanhangj = new double[A.n];//定义一个交换行的中间数组//
n = A.m;
for (j = 0; j < n - 1; j++)
{
if (A.read(j, j) == 0)
{
for (int i = j; i < A.m;)
{
if (A.read(i, j) == 0)
i++;//往下找不为零的元素
if (A.read(i, j) != 0)
{
for (int l = 0; l < A.n; l++)
{
huanhangi[l] = A.read(i, l);
huanhangj[l] = A.read(j, l);
A.write(j, l, huanhangi[l]);
A.write(i, l, huanhangj[l]);
//交换第i行和第j行//
// Console.Write("换行i:{0} ", huanhangi[l]);
// Console.Write("换行j:{0} ", huanhangj[l]);
f++;//记录交换多少次//
}
break;
} //如果第i行不为零,则交换i,j两行//
if (i == A.m)
return 0;//如果以下都为零则行列式为零//
}
}
int k = j + 1; int m = j;//行变换元素之间对应关系
for (; k < n; k++)
{
D = A.read(k, j) / A.read(j, j);
for (; m < n; m++)
{
//Matrix_Calc C = new Matrix_Calc();
// String S = null; //初始化对象
B = A.read(k, m) - A.read(j, m) * D;
A.write(k, m, B);
// Console.Write("\r\n {0} \r\n", A.Out(ref A));//观察矩阵运行变化
// Console.Write("\r\n {0} {1} {2} \r\n", j, k, m); //观察变量是否符合要求
}
m = j;//注意如果不重新置m,k内循环将不会继续
}
k = j + 1;//同上原理
}
double result = 1;
for (int Q = 0; Q < A.n; Q++)
result *= Math.Pow(-1.0, f) * A.read(Q, Q);
R.Equal(ref R, ref A);//将A变回原来形式//
return result;
}
public void Shangsanjiao(ref Matrix A)
{
int j, n = 0;
double C, D;
double[] huanhangi = new double[A.n];//定义一个交换行的中间数组//
double[] huanhangj = new double[A.n];//定义一个交换行的中间数组//
n = A.m;
for (j = 0; j < n - 1; j++)
{
if (A.read(j, j) == 0)
{
for (int i = j; i < A.m;)
{
if (A.read(i, j) == 0)
i++;//往下找不为零的元素
if (A.read(i, j) != 0)
{
for (int l = 0; l < A.n; l++)
{
huanhangi[l] = A.read(i, l);
huanhangj[l] = A.read(j, l);
A.write(j, l, huanhangi[l]);
A.write(i, l, huanhangj[l]);
//交换第i行和第j行//
// Console.Write("换行i:{0} ", huanhangi[l]);
// Console.Write("换行j:{0} ", huanhangj[l]);
}
break;
} //如果第i行不为零,则交换i,j两行//
if (i == A.m)
j++;//如果以下都为零则行列式为零//
}
}
int k = j + 1; int m = j;//行变换元素之间对应关系
for (; k < n; k++)
{
D = A.read(k, j) / A.read(j, j);
for (; m < n; m++)
{
//Matrix_Calc C = new Matrix_Calc();
// String S = null; //初始化对象
C = A.read(k, m) - A.read(j, m) * D;
A.write(k, m, C);
// Console.Write("\r\n {0} \r\n", C.Out(ref A));//观察矩阵运行变化
// Console.Write("\r\n {0} {1} {2} \r\n", j, k, m); //观察变量是否符合要求
}
m = j;//注意如果不重新置m,k内循环将不会继续
}
k = j + 1;//同上原理
}
}
}
}