Java进阶(四十九)实现矩阵秩的求解-转置-行列式-逆矩阵操作_矩阵求秩代码

最新推荐文章于 2024-07-20 03:20:39 发布

m0_60666452

最新推荐文章于 2024-07-20 03:20:39 发布

阅读量466

点赞数 20

分类专栏： 2024年程序员学习文章标签： java 矩阵开发语言

本文链接：https://blog.csdn.net/m0_60666452/article/details/138039376

版权

2024年程序员学习专栏收录该内容

295 篇文章 2 订阅

订阅专栏

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Web前端全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上前端开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024c （备注前端）

正文

return newData;
}

/**
* 求解行列式的模
*
* @param data
* @return float
*/
public static double getHL(double[][] data) {

// 终止条件
if (data.length == 2) {
return data[0][0] * data[1][1] - data[0][1] * data[1][0];
}

if (data.length == 1) {
return data[0][0];
}

double total = 0;
// 根据data 得到行列式的行数和列数
int num = data.length;
// 创建一个大小为num 的数组存放对应的展开行中元素求的的值
double[] nums = new double[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;
}

/**
* 取得转置矩阵
* @param A
* @return float[][]
*/
public static double[][] getA_T(double[][] A) {
int h = A.length;
int v = A[0].length;
// 创建和A行和列相反的转置矩阵
double[][] A_T = new double[v][h];
// 根据A取得转置矩阵A_T
for (int i = 0; i < h; i++) {
for (int j = 0; j < v; j++) {
A_T[j][i] = A[i][j];
}
}
// System.out.println(“取得转置矩阵 wanbi…”);
return A_T;
}

/**
* 求解逆矩阵
*
* @param data
* @return
*/
public static double[][] getReverseMatrix(double[][] data) {

// 1.求出行列式的模|data|
double m = getHL(data);

// 若行列式的值为0，则表明逆矩阵不存在
if(Arith.compareTo(m, 0) == 0){
System.out.println(“----------------行列式的模为0，逆矩阵不存在-----------------”);
return null;
}

if(m == 0){

}

System.out.println(“行列式:” + m);

// 创建一个等容量的逆矩阵
double[][] newData = new double[data.length][data.length];

for (int i = 0; i < data.length; i++) {
for (int j = 0; j < data.length; j++) {
double 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 / m;
}
}

// 2.转置代数余子式
newData = getA_T(newData);

// 打印
System.out.println(“逆矩阵：”);
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 Matrix 矩阵
* @param error_
* @param List
* @return
*/
public static int Rank(double[][] Matrix, int error_, int List)
{
int n = List;
int m = Matrix.length ;
int i = 0;
int j = 0;
int i1, j1;
double temp1;

if(m > n)
{
i = m;
m = n;
n = i;
i = 1;
}

m -= 1;
n -= 1;

double[][]temp = new double[m+1][n+1];

if(i == 0)
{
for(i = 0; i <= m; i++)
{
for(j = 0; j <= n; j++)
{
temp[i][j] = Matrix[i][j];
}
}
} else
{
for(i = 0; i <= m; i++)
{
for(j = 0; j <= n; j++)
{
temp[i][j] = Matrix[j][i];
}
}
}

if(m == 0)
{
i = 0;
while(i <= n)
{
if(Matrix[0][i] != 0)
{
return 1;
}
i += 1;
}
return 0;
}

double error0;
if(error_ == -1)
{
error0 = Math.pow(0.1, 10);
}
else
{
error0 = Math.pow(0.1, error_);
}

i = 0;

while(i <= m)
{
j = 0;
while(j <= n)
{
if(temp[i][j] != 0)
{
error0 *= temp[i][j];
i = m;
break;
}
j += 1;
}
i += 1;
}

double error1;
for(i = 0; i <= m; i++)
{
j = 0;
while(j <= n)
{
if(temp[i][j] != 0)
{
break;
}
j += 1;
}

if(j <= n)
{
i1 = 0;
while(i1 <= m)
{
if(temp[i1][j] != 0 && i1 != i)
{
temp1 = temp[i][j]/temp[i1][j];
error1 = Math.abs((temp[i][j] - temp[i1][j]*temp1))*100;
error1 += error0;
for(j1 = 0; j1 <= n; j1++)

最后

你要问前端开发难不难，我就得说计算机领域里常说的一句话，这句话就是『难的不会，会的不难』，对于不熟悉某领域技术的人来说，因为不了解所以产生神秘感，神秘感就会让人感觉很难，也就是『难的不会』；当学会这项技术之后，知道什么什么技术能做到什么做不到，只是做起来花多少时间的问题而已，没啥难的，所以就是『会的不难』。

我特地针对初学者整理一套前端学习资料

前端路线图