查java实现逆矩阵转换的代码，居然没怎么发现，想偷懒一下也不行。关于矩阵基本运算 ：加 减 乘，转置矩阵，相当简单，能看见不少别人写的，但是就是没看见逆矩阵，不爽。
自己实现了下逆矩阵功能，可以是任意的n阶矩阵。
因为对矩阵很陌生，从0开始到最后实现，每一步的思考代码都有体现，所以代码就很有思考的逻辑性。
实现分了两步：<最原始的公式>
A的逆矩阵=A*/|A|;
1:求A*
2:求|A|
伴随矩阵A* 实现，要用到代数余子式。实现还是比较简单
/**
* 1
* 求解代数余子式 输入：原始矩阵+行+列 现实中真正的行和列数目
*/
public static float[][] getDY(float[][] data, int h, int v) {
int H = data.length;
int V = data[0].length;
float[][] newData = new float[H - 1][V - 1];
for (int i = 0; i < newData.length; i++) {
if (i < h - 1) {
for (int j = 0; j < newData[i].length; j++) {
if (j < v - 1) {
newData[i][j] = data[i][j];
} else {
newData[i][j] = data[i][j + 1];
}
}
} else {
for (int j = 0; j < newData[i].length; j++) {
if (j < v - 1) {
newData[i][j] = data[i + 1][j];
} else {
newData[i][j] = data[i + 1][j + 1];
}
}
}
}
// System.out.println("---------------------代数余子式测试.---------------------------------");
// for(int i=0;i<newData.length;i++){
// for(int j=0;j<newData[i].length;j++){
// System.out.print("newData["+i+"]"+"["+j+"]="+newData[i][j]+" ");
// }
//
// System.out.println();
// }
return newData;
}
写完这个代数余子式后就是计算它的行列式的值。
计算行列式是按照行和列展开，肯定是有递归的意思。但是由于和平时写的不太一样，循环太多，弄不清位置，就依次实现2阶，3阶，4阶，5阶行列式，并做了测试，用了归纳法找到了正确的实现位置。
2阶
/**
* 2
* 求2阶行列式的数值
* @param data
* @return
*/
public static float getHL2(float[][] data) {
// data 必须是2*2 的数组
float num1 = data[0][0] * data[1][1];
float num2 = -data[0][1] * data[1][0];
return num1 + num2;
}
3阶
/**
* 求3阶行列式的数值
*
* @param data
* @return
*/
public static float getHL3(float[][] data) {
float num1 = data[0][0] * getHL2(getDY(data, 1, 1));
float num2 = -data[0][1] * getHL2(getDY(data, 1, 2));
float num3 = data[0][2] * getHL2(getDY(data, 1, 3));
// System.out.println("---->"+num1);
// System.out.println("---->"+num2);
// System.out.println("---->"+num3);
System.out.println("3阶行列式的数值是：----->" + (num1 + num2 + num3));
return num1 + num2 + num3;
}
4阶
/**
* 求4阶行列式的数值
*
* @param data
* @return
*/
public static float getHL4(float[][] data) {
float num1 = data[0][0] * getHL3(getDY(data, 1, 1));
float num2 = -data[0][1] * getHL3(getDY(data, 1, 2));
float num3 = data[0][2] * getHL3(getDY(data, 1, 3));
float num4 = -data[0][3] * getHL3(getDY(data, 1, 4));
// System.out.println("--------->"+num1);
// System.out.println("--------->"+num2);
// System.out.println("--------->"+num3);
// System.out.println("--------->"+num4);
// System.out.println("4阶行列式的数值------->"+(num1+num2+num3+num4));
return num1 + num2 + num3 + num4;
}
5阶
/**
* 求5阶行列式的数值
*/
public static float getHL5(float[][] data) {
float num1 = data[0][0] * getHL4(getDY(data, 1, 1));
float num2 = -data[0][1] * getHL4(getDY(data, 1, 2));
float num3 = data[0][2] * getHL4(getDY(data, 1, 3));
float num4 = -data[0][3] * getHL4(getDY(data, 1, 4));
float num5 = data[0][4] * getHL4(getDY(data, 1, 5));
System.out.println("5 阶行列式的数值是： ------->"
+ (num1 + num2 + num3 + num4 + num5));
return num1 + num2 + num3 + num4 + num5;
}
最终的归纳是：
/**
* 求解行列式的模----------->最终的总结归纳
*
* @param data
* @return
*/
public static float getHL(float[][] data) {
// 终止条件
if (data.length == 2) {
return data[0][0] * data[1][1] - data[0][1] * data[1][0];
}
float total = 0;
// 根据data 得到行列式的行数和列数
int num = data.length;
// 创建一个大小为num 的数组存放对应的展开行中元素求的的值
float[] nums = new float[num];
for (int i = 0; i < num; i++) {
if (i % 2 == 0) {
nums[i] = data[0][i] * getHL(getDY(data, 1, i + 1));
} else {
nums[i] = -data[0][i] * getHL(getDY(data, 1, i + 1));
}
}
for (int i = 0; i < num; i++) {
total += nums[i];
}
System.out.println("total=" + total);
return total;
}
上面用到的是归纳。
实现了行列式求值还没完，下面才是求逆矩阵：
/**
* 求解3阶矩阵的逆矩阵
* @param data
* @return
*/
public static float[][] getN3(float[][] data) {
// 先是求出整个行列式的数值|A|
float A = getHL3(data);
float[][] newData = new float[3][3];
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
float num;
if ((i + j) % 2 == 0) {// i+j 是偶数 实际是(i+1)+(j+1)
num = getHL2(getDY(data, i + 1, j + 1));
} else {
num = -getHL2(getDY(data, i + 1, j + 1));
}
System.out.println("num=" + num);
newData[i][j] = num / A;
}
}
// 再转制
newData = getA_T(newData);
// 打印
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
System.out.print("newData[" + i + "][" + j + "]= "
+ newData[i][j] + " ");
}
System.out.println();
}
return newData;
}
最终的结果是：
/**
* 求解逆矩阵------>z最后的总结和归纳
*
* @param data
* @return
*/
public static float[][] getN(float[][] data) {
// 先是求出行列式的模|data|
float A = getHL(data);
// 创建一个等容量的逆矩阵
float[][] newData = new float[data.length][data.length];
for (int i = 0; i < data.length; i++) {
for (int j = 0; j < data.length; j++) {
float num;
if ((i + j) % 2 == 0) {
num = getHL(getDY(data, i + 1, j + 1));
} else {
num = -getHL(getDY(data, i + 1, j + 1));
}
newData[i][j] = num / A;
}
}
// 转置 代数余子式转制
newData = getA_T(newData);
// 打印
for (int i = 0; i < data.length; i++) {
for (int j = 0; j < data.length; j++) {
System.out.print("newData[" + i + "][" + j + "]= "
+ newData[i][j] + " ");
}
System.out.println();
}
return newData;
}
会用到转置矩阵，代码较为简单：
/**
* 取得转置矩阵
* @param A
* @return
*/
public static float[][] getA_T(float[][] A) {
int h = A.length;
int v = A[0].length;
// 创建和A行和列相反的转置矩阵
float[][] A_T = new float[v][h];
// 根据A取得转置矩阵A_T
for (int i = 0; i < v; i++) {
for (int j = 0; j < h; j++) {
A_T[j][i] = A[i][j];
}
}
System.out.println("取得转置矩阵 wanbi........");
return A_T;
}
下面是自己的测试：
/**
* @param args
*/
public static void main(String[] args) {
MartrixTest t = new MartrixTest();
// t.getDY(data6, 2, 3);
// getHL3(data3);
// getHL4(data4);
// getHL5(data5);
// getN3(data3);
// getHL(data5);
getN(data3);
}
static float[][] data6 = { { 1, 2, 3, 4, 5, 6 },
{ 1, 2, 3, 4, 5, 6 },
{ 3, 4, 3, 2, 2, 1 },
{ 1, 2, 3, 4, 5, 6 },
{ 1, 2, 3, 4, 5, 6 },
{ 1, 2, 3, 4, 5, 6 },
};
static float[][] data5 = { { 1, 2, 3, 4, 5 },
{ 2, 3, 4, 5, 1 },
{ 3, 4, 5, 1, 2 },
{ 4, 5, 1, 2, 3 },
{ 5, 1, 2, 3, 4 },
};
static float[][] data4 = { { 1, 0, -1, 2 },
{ -2, 1, 3, 1 },
{ 0, 2, 0, -2 },
{ 1, 3, 4, -2 },
};
static float[][] data3 = { {1,2,-1 },
{3,1,0 },
{-1,-1,-2 }, };
测试了5阶的，结果和课本例题其他解法结果相同。把摄影测量的图像处理原理和矩阵都学了下，搞了2天还是蛮爽的。
分享到：
相关推荐
本文主要介绍了Java实现的求逆矩阵算法，涉及java基于数组的矩阵遍历与运算相关操作技巧。下面将详细介绍该算法的实现细节。 矩阵逆矩阵算法 矩阵逆矩阵算法是线性代数中的一种重要算法，用于计算矩阵的逆矩阵。...
该程序实现了Java的基本运算： 1.矩阵的相加。 2.矩阵的相减。 3.矩阵于数的相乘。 4.矩阵于矩阵的相乘。 5.矩阵的求秩。 6.矩阵的求逆（能求2阶以上的）。 7.矩阵的转秩。
本篇将详细探讨"矩阵运算Matrix,java实现"这个主题，包括矩阵的基本概念、主要运算以及如何在Java中实现这些功能。 矩阵是由有序的数列构成的矩形阵列，通常用大写字母表示，如A、B等。每个数称为矩阵的元素，用a_...
JAVA实现矩阵加减乘除求逆运算 矩阵运算是线性代数中的一种基本操作，包括矩阵加减乘除和求逆运算。JAVA语言可以实现这些运算操作，本文将详细介绍JAVA实现矩阵加减乘除求逆运算的方法。 矩阵加法是将两个矩阵相加...
在Java中，实现矩阵的广义逆通常涉及使用线性代数库，如Apache Commons Math库或者JAMA库。这些库提供了方便的接口和方法来处理矩阵运算，包括计算广义逆。以Apache Commons Math为例，我们可以按照以下步骤操作： ...
在 Java 中，可以使用 Gauss-Jordan 消元法来实现逆矩阵的计算。 例如，以下代码计算一个 3x3 矩阵的逆矩阵： ```java public static int[][] inverseMatrix(int[][] matrix) { int[][] result = new int[3][3]; ...
总的来说，Java实现LU分解是一个涉及线性代数和数值计算的过程，需要对矩阵操作有深入理解。通过这个过程，我们可以为解决复杂的线性系统提供一个高效、可靠的工具。在实际工程中，可以结合Java的库，如Apache ...
Java矩阵计算器是一个基于图形用户界面(GUI)的应用程序，用于执行矩阵运算，如加法、减法、乘法以及求逆等。它使用了Java编程语言，并且结合了事件监听器机制，尤其是`ActionListener`，来处理用户的交互操作。这个...
对于更复杂的矩阵运算，如乘法、求逆、求行列式等，可以扩展这个类以添加更多的方法。同时，为了提高代码的可读性和可维护性，可以考虑将一些功能提取为私有辅助方法，或者使用更先进的设计模式。此外，为了适应大...
通过理解以上知识点，并结合提供的文件" Hill"，你可以编写出一个简单的希尔密码Java实现，这个实现可以作为学习密码学和矩阵运算的一个实例。在实际应用中，为了提高安全性，通常会结合其他更现代的加密算法。
在IT领域，尤其是在数值计算和线性代数中，矩阵是一个至关重要的概念。逆矩阵是矩阵理论中的核心...在编程实现时，选择合适的数据结构和算法，以及处理好浮点数运算的精度问题，是实现高效且准确的逆矩阵计算的关键。
在这个项目中，作者使用Java实现了曲线和直线的拟合功能。 在Java中，曲线拟合通常涉及到数值分析和线性代数的知识。首先，我们需要理解数据点的坐标，这些点可以表示为`(x, y)`对，其中`x`是自变量，`y`是因变量。...
Java作为一个多用途的编程语言，也提供了处理矩阵运算的库，比如VecMath。VecMath是Java 3D的一部分，它提供了一系列用于向量和矩阵操作的类，方便开发者进行三维图形渲染和数学计算。 VecMath库的核心类之一就是`...
在JAMA库中，SVD的实现可以帮助开发者进行复杂的矩阵运算，如求逆、特征值、特征向量、最小二乘解等。 SVD的数学表达式为：对于一个m×n的矩阵A，可以分解为A = UΣV^T，其中U是m×m的单位正交矩阵，Σ是一个m×n的...
总之，这个`Matrix`类是Java实现矩阵运算的一个简单实例，它包含了基本的矩阵初始化、访问、以及一些基本的矩阵操作。通过扩展这个类，可以构建更复杂的矩阵计算库，适用于各种科学计算和数据分析任务。
随着对Java和线性代数的深入学习，你将能够处理更复杂的矩阵运算，如逆矩阵、特征值、解线性方程组等。同时，这个基础也将为学习其他编程语言的矩阵运算打下坚实的基础。在实际项目中，你可能还会接触到如Apache ...
本文将主要介绍Java实现按照顺时针或逆时针方向输出数字矩阵的功能，涉及Java基于数组遍历、运算的矩阵操作技巧。 Java实现按照顺时针或逆时针方向输出数字矩阵的功能示例代码中，主要使用了二维数组来存储矩阵，...
6. **解密运算**：如果需要解密，先计算加密矩阵的逆矩阵，然后用这个逆矩阵与密文矩阵相乘，得到明文矩阵，再转换回明文字符串。 在Java代码中，可以使用`ArrayList`存储字母表，`int[][]`表示矩阵，`BigInteger`...
《计算器+矩阵运算+马拉松管理系统：MFC技术的综合应用》 在计算机科学与信息技术领域，开发具有实用性的软件系统是提升技术能力的重要途径。在这个短学期的实验项目中，我们构建了一个集计算器、矩阵运算和马拉松...