查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基于数组的矩阵遍历与运算相关操作技巧。下面将详细介绍该算法的实现细节。 矩阵逆矩阵算法 矩阵逆矩阵算法是线性代数中的一种重要算法，用于计算矩阵的逆矩阵。...
对于大型矩阵运算，可能需要考虑使用高效的算法或库，如Apache Commons Math库，它可以提供更高级的矩阵操作功能。 以上就是关于Java实现矩阵基本运算的知识点详解，这些概念和操作是计算机科学，尤其是数值分析和...
Java作为一种广泛应用的编程语言，提供了多种实现矩阵运算的库。本资源“基于JAVA的矩阵运算JAR包”便是为了简化开发者进行矩阵运算而设计的。下面将详细阐述矩阵运算、JAR包以及与Java的相关性。 矩阵运算在数学上...
本篇将详细探讨"矩阵运算Matrix,java实现"这个主题，包括矩阵的基本概念、主要运算以及如何在Java中实现这些功能。 矩阵是由有序的数列构成的矩形阵列，通常用大写字母表示，如A、B等。每个数称为矩阵的元素，用a_...
Java实现时，可以使用库如Apache Commons Math，它提供了计算逆矩阵的功能。 5. **示例代码结构**： 一个简单的Java项目可能包含以下部分： - `Matrix`类：封装矩阵的基本操作，如初始化、加法、乘法、转置等。 ...
JAVA实现矩阵加减乘除求逆运算 矩阵运算是线性代数中的一种基本操作，包括矩阵加减乘除和求逆运算。JAVA语言可以实现这些运算操作，本文将详细介绍JAVA实现矩阵加减乘除求逆运算的方法。 矩阵加法是将两个矩阵相加...
在Java编程中，矩阵操作是线性代数中常见的任务，包括矩阵的转置、求逆和矩阵乘法。这些操作在科学计算、图像处理、机器学习等领域有着广泛的应用。...同时，对于大规模矩阵运算，使用专门的数值计算库会更有效率。
Java复数矩阵库JamPack是一个专门用于处理复数矩阵计算的高效工具，它为Java开发者提供了方便、快捷的复数矩阵运算功能。在数学和工程领域，复数矩阵的运算广泛应用，例如在信号处理、图像分析、物理模拟等多个场景...
Java矩阵运算库Jama是一个非常实用的工具，它为Java开发者提供了一套高效且易于使用的矩阵操作接口。这个库主要用于科学计算，特别是在处理线性代数问题时，如矩阵乘法、转置、求逆、特征值和特征向量等。Jama库的...
这个逆矩阵的存在性及其计算方法是理解线性系统和线性变换的关键。在这个场景中，"ConsoleApplication1"可能是一个包含C#、Java或C++等编程语言编写的源代码，用于实现矩阵求逆的算法。 矩阵求逆在很多领域都有应用...
在Java中，实现矩阵的广义逆通常涉及使用线性代数库，如Apache Commons Math库或者JAMA库。这些库提供了方便的接口和方法来处理矩阵运算，包括计算广义逆。以Apache Commons Math为例，我们可以按照以下步骤操作： ...
在Java实现矩阵运算时，可以创建一个Matrix类，包含二维数组作为矩阵元素，以及加法和乘法的方法。加法方法可以直接遍历两个矩阵的对应元素进行加法操作，而乘法方法需要三个嵌套循环：外层循环遍历结果矩阵的行，...
标题 "基于OpenCL的Java矩阵运算库.zip" 暗示了这个压缩包包含一个Java实现的库，用于利用OpenCL进行高效的矩阵运算。OpenCL（Open Computing Language）是一种开放标准，允许程序员编写并行计算代码，可以在各种...
总的来说，Java实现LU分解是一个涉及线性代数和数值计算的过程，需要对矩阵操作有深入理解。通过这个过程，我们可以为解决复杂的线性系统提供一个高效、可靠的工具。在实际工程中，可以结合Java的库，如Apache ...
在 Java 中，可以使用 Gauss-Jordan 消元法来实现逆矩阵的计算。 例如，以下代码计算一个 3x3 矩阵的逆矩阵： ```java public static int[][] inverseMatrix(int[][] matrix) { int[][] result = new int[3][3]; ...
在"矩阵包"中，可能包含了用特定编程语言（如Python、C++或Java）实现的矩阵运算函数，方便用户进行上述操作。这些函数通常会优化计算效率，确保数值稳定，并提供友好的接口供用户调用。例如，用户可以使用这些函数...
同时，Ejml还支持多种矩阵运算，如矩阵加法、减法、乘法、转置、求逆、求行列式、求特征值与特征向量等基本操作，以及更复杂的线性代数运算。 在性能方面，Ejml通过优化算法和内部数据结构，实现了高效的矩阵运算。...
在探讨“无穷嵌套矩阵运算在Matlab中的实现”这一主题时，文章首先介绍了无穷嵌套矩阵表示和运算的难点，并通过单元结构与逆分块矩阵的思想，解决了嵌套矩阵运算问题。以下将详细介绍这一过程中所涉及的关键技术点。...
5. **编程实现**：矩阵运算通常可以通过各种编程语言实现，如Python中的NumPy库、Java的Matrix Package、MATLAB等。这些库提供了方便的接口来执行矩阵运算，包括上述的加法、减法和转置，以及更复杂的乘法、求逆、求...
而"Java调用jama实现矩阵运算 - hjwang1的专栏 - CSDN博客.mhtml"可能是一个关于如何在Java项目中使用Jama的教程或示例代码，可以帮助初学者更好地理解和应用Jama包。 总的来说，Java Jama矩阵包是一个强大的工具，...