Java 矩阵算法工具

步骤1：

<!-- 矩阵工具 -->
<dependency><groupId>org.ejml</groupId><artifactId>ejml-all</artifactId><version>0.41</version>
</dependency>

步骤2：

创建一个2x4的空矩阵matrix
//创建一个2x4的空矩阵matrix（全部为0）
//    SimpleMatrix?(int numRows, int numCols)
//                      行数         列数
SimpleMatrix matrix0  = new SimpleMatrix(2,4);

通过数组创建矩阵
//通过二维数组创建矩阵
//可以理解成将数组变成相同结构的矩阵//1、以double型的二维数组构造相同结构的矩阵
//    SimpleMatrix?(double[][] data)
double[][] arrayDouble2 = new double[2][4];
SimpleMatrix matrixDouble2 = new SimpleMatrix(arrayDouble2);
System.out.println("matrixDouble2:\n"+matrixDouble2);//2、以float型的二维数组构造相同结构的矩阵
//    SimpleMatrix?(float[][] data)
double[][] arrayFloat2 = new double[2][4];
SimpleMatrix matrixFloat2 = new SimpleMatrix(arrayFloat2);
System.out.println("matrixFloat2:\n"+matrixFloat2);

//通过一维数组创建矩阵
//可以理解成将一维数组的数据按照每一行（每一列）的顺序填入给定大小的矩阵
/*  SimpleMatrix(int numRows, int numCols, boolean rowMajor, float/double[] data)行数          列数    true(按行) false(按列)  数据源
*/double[] arrayDouble1 = {1,2,3,4,5,7,8,9};//double也行//1.按照每一行填入数据
SimpleMatrix matrixDoubleRow = new SimpleMatrix(4,2,true,arrayDouble1);
System.out.println("matrixDoubleRow:\n"+matrixDoubleRow);//2.按照每一列填入数据
SimpleMatrix matrixDoubleCol = new SimpleMatrix(4,2,false,arrayDouble1);
System.out.println("matrixDoubleCol:\n"+matrixDoubleCol);/*   matrixDoubleRow: 4x2      matrixDoubleCol: 4x2[1,2]                     [1,5][3,4]                     [2,6][5,6]                     [3,7][7,8]                     [4,8]*/

矩阵的常用运算
先创建4x4的矩阵A和4x4的矩阵B，将矩阵A的所有元素都设置为1，将B的所有元素设置为2
//    void    fill?(double val)  将矩阵的所有元素都用val填充
//    如 matrix.fill(0.1)  表示将matrix的所有元素都设为0.1
SimpleMatrix matrixA = new SimpleMatrix(4,4);  //创建4x4的矩阵A
SimpleMatrix matrixB = new SimpleMatrix(4,4);  //创建4x4的矩阵B
matrixA.fill(1); //将A的所有元素设为1
matrixB.fill(2); //将B的所有元素设为2
System.out.println(matrixA);
System.out.println(matrixB);

2.1 矩阵加（减）法

/*  加、减法
T	plus(double b)            C = A + b      将矩阵A所有元素都加上b(如需减，则将b设为负)
T	plus(double beta, T B)    C = A + betaB  将B的所有元素都乘以beta，再让加上A(如需减，则将beta设置为负)
T	plus(T B)                 C = A + B      矩阵A加上矩阵B
T	minus(double b)	          C = A - b      将矩阵A所有元素都减去b
T	minus(T B)	              C = A - B      矩阵A加上矩阵B
*/
matrixC.fill(1);
matrixC = matrixA.plus(0.6);  //A的所有元素乘以0.6
System.out.println(matrixC);matrixC.fill(1);
matrixC = matrixA.plus(0.2,matrixB);  // A + 0.2*B
System.out.println(matrixC);matrixC.fill(1);
matrixC = matrixA.plus(matrixB);  // A + B
System.out.println(matrixC);matrixC.fill(1);
matrixC = matrixA.minus(6);  // A的所有元素减6
System.out.println(matrixC);matrixC.fill(1);
matrixC = matrixA.minus(matrixB);  // A - B
System.out.println(matrixC);

/*  乘法
1. 矩阵与矩阵相乘（行列式）T	mult(T B)               C = A * B    矩阵A与矩阵B相乘并返回
2. 数乘T	negative()              C = -A       矩阵A的所有元素乘以-1T	scale(double val)       C = val*A    矩阵A的所有元素乘以val
*/
matrixC = matrixA.mult(matrixB); // C = A * B
System.out.println(matrixC);matrixC = matrixA.negative();  // C = -A
System.out.println(matrixC);matrixC = matrixA.scale(9.99); // C = A*9.99
System.out.println(matrixC);

// 除法
//    T	divide(double val)      C = A/val    将矩阵A的所有元素都除以val
matrixC = matrixA.divide(50);  //C = A的所有元素都除以50所得的矩阵
System.out.println(matrixC);

/*  矩阵的转置
T	transpose()   返回给定矩阵的转置
*/
int val = 1;
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {matrixC.set(i, j, val);val++;
}
} //设置矩阵的值
System.out.println(matrixC);SimpleMatrix matrixC_transpose = matrixC.transpose(); //矩阵的转置
System.out.println(matrixC_transpose);

/*  矩阵的逆阵T	invert()            求可逆矩阵的逆阵T	pseudoInverse()     求摩尔彭若斯广义逆（对于可逆矩阵与上行方法一致）
*/
SimpleMatrix matrixD = new SimpleMatrix(4, 4);
for (int i = 0; i < 4; i++) {for (int j = 0; j < 4; j++) {if (i == j) {matrixD.set(i, j, i + 1);} else {matrixD.set(i, j, 0);}}
}
System.out.println("矩阵D:\n"+matrixD);SimpleMatrix D_invert = matrixD.invert();
System.out.println("矩阵D的逆阵:\n"+D_invert);SimpleMatrix D_pseudoInverse = matrixD.pseudoInverse();
System.out.println("矩阵D的广义逆阵:\n"+D_pseudoInverse);

//创建n阶单位矩阵  identity matrix
int n =7;
SimpleMatrix tempMatrix = new SimpleMatrix(n,1); //创建nx1的列向量
tempMatrix.fill(1); //所有元素置为1
SimpleMatrix I =  tempMatrix.diag();
//A.diag()方法，如果A是矩阵，则返回一个由该矩阵的对角线上的值组成的列向量
//             如果A是列向量，则将其扩展为一个矩阵，矩阵的对角线的值就是该列向量
System.out.println(I);

SimpleMatrix matrix = new SimpleMatrix(8,8);matrix.fill(4);     //将矩阵元素都设置为4
matrix.zero();      //将矩阵元素都设置为0
matrix.set(1,4,3);      //将第一行第四列元素设置为3
matrix.set(0,8);            //将第零个元素设置为8matrix.rows(1,2);           //获取矩阵的部分行，第一个数表示开始的那一行，第二个数表示结束那一行加一（这里表示获取第一行）
matrix.cols(2,8);           //获取矩阵的部分列，第一个数表示开始的那一列，第二个数表示结束那一列加一（这里表示获取第2,3,4,5,6,7行）
matrix.get(2,3);   //获取第二行第三个数
matrix.get(2);              //获取第二个元素matrix.copy();              //复制一个矩阵
matrix.createLike();        //创建一个与matrix相同行列数且元素相同的矩阵matrix.numRows();           //获取矩阵的行数
matrix.numCols();           //获取矩阵的列数
matrix.getNumElements();    //获取矩阵的元素个数（行数乘以列数）matrix.elementMaxAbs();     //获取矩阵中所有元素绝对值的最大值
matrix.elementMinAbs();     //获取矩阵中所有元素绝对值的最小值
matrix.elementSum();        //计算矩阵中所有元素的和matrix.normF();             //计算矩阵的二范数（所有元素平方和开根号，可以理解成向量的模）
matrix.determinant();       //计算矩阵行列数值（“乘”、“除”、“乘方”等等）
matrixC = matrixA.elementDiv(matrixB);   // 对应相除 C(i,j) = A(i,j) / B(i,j)
matrixC = matrixA.elementMult(matrixB);  // 对应相乘 C(i,j) = A(i,j) * B(i,j)
matrixC = matrixA.elementExp();          // C(i,j) = e 的 A(i,j)次方
matrixC = matrixA.elementLog();          // C(i,j) = ln(C(i,j))
matrixC = matrixA.elementPower(2);       // C(i,j) = A(i,j)^2 (对应元素的n次方)
matrixC = matrixA.elementPower(matrixB); // C(i,j) = A(i,j)^(B(i,j)) (对应元素的对应次方)

转数组：
double[] data = a2.getDDRM().data;

步骤3：测试代码

import org.ejml.simple.SimpleMatrix;
public class test {public static void main(String[] args) {//-------------------------------------------------------------------//创建一个2x4的矩阵matrix（全部为0）//    SimpleMatrix(int numRows, int numCols)//                      行数         列数SimpleMatrix matrix0 = new SimpleMatrix(2, 4);//-------------------------------------------------------------------//通过二维数组创建矩阵//可以理解成将数组变成相同结构的矩阵//1、以double型的二维数组构造相同结构的矩阵//    SimpleMatrix(double[][] data)double[][] arrayDouble2 = new double[2][4];SimpleMatrix matrixDouble2 = new SimpleMatrix(arrayDouble2);System.out.println("matrixDouble2:\n" + matrixDouble2);//2、以float型的二维数组构造相同结构的矩阵//    SimpleMatrix(float[][] data)double[][] arrayFloat2 = new double[2][4];SimpleMatrix matrixFloat2 = new SimpleMatrix(arrayFloat2);System.out.println("matrixFloat2:\n" + matrixFloat2);//---------------------------------------------------------------------//通过一维数组创建行列数//可以理解成将一维数组的数据按照每一行（每一列）的顺序填入给定大小的矩阵/*  SimpleMatrix(int numRows, int numCols, boolean rowMajor, float/double[] data)行数          列数    true(按行) false(按列)  数据源*/double[] arrayDouble1 = {1, 2, 3, 4, 5, 6, 7, 8, 9};//double也行//1.按照每一行填入数据SimpleMatrix matrixDoubleRow = new SimpleMatrix(4, 2, true, arrayDouble1);System.out.println("matrixDoubleRow:\n" + matrixDoubleRow);//2.按照每一列填入数据SimpleMatrix matrixDoubleCol = new SimpleMatrix(4, 2, false, arrayDouble1);System.out.println("matrixDoubleCol:\n" + matrixDoubleCol);/*   matrixDoubleRow: 4x2      matrixDoubleCol: 4x2[1,2]                     [1,5][3,4]                     [2,6][5,6]                     [3,7][7,8]                     [4,8]*///-------------------------------------------------------------------SimpleMatrix matrixA = new SimpleMatrix(4, 4);  //创建4x4的矩阵ASimpleMatrix matrixB = new SimpleMatrix(4, 4);  //创建4x4的矩阵BSimpleMatrix matrixC = new SimpleMatrix(4, 4);  //创建5x5的矩阵CmatrixA.fill(1); //将A的所有元素设为1matrixB.fill(2); //将B的所有元素设为2System.out.println(matrixA);System.out.println(matrixB);/*  加、减法T	plus(double b)            C = A + b      将矩阵A所有元素都加上b(如需减，则将b设为负)T	plus(double beta, T B)    C = A + betaB  将B的所有元素都乘以beta，再让加上A(如需减，则将beta设置为负)T	plus(T B)                 C = A + B      矩阵A加上矩阵BT	minus(double b)	          C = A - b      将矩阵A所有元素都减去bT	minus(T B)	              C = A - B      矩阵A加上矩阵B*/matrixC.fill(1);matrixC = matrixA.plus(0.6);  //A的所有元素乘以0.6System.out.println(matrixC);matrixC.fill(1);matrixC = matrixA.plus(0.2,matrixB);  // A + 0.2*BSystem.out.println(matrixC);matrixC.fill(1);matrixC = matrixA.plus(matrixB);  // A + BSystem.out.println(matrixC);matrixC.fill(1);matrixC = matrixA.minus(6);  // A的所有元素减6System.out.println(matrixC);matrixC.fill(1);matrixC = matrixA.minus(matrixB);  // A - BSystem.out.println(matrixC);/*  乘法1. 矩阵与矩阵相乘（行列式）T	mult(T B)               C = A * B    矩阵A与矩阵B相乘并返回2. 数乘T	negative()              C = -A       矩阵A的所有元素乘以-1T	scale(double val)       C = val*A    矩阵A的所有元素乘以val*/matrixC = matrixA.mult(matrixB); // C = A * BSystem.out.println(matrixC);matrixC = matrixA.negative();  // C = -ASystem.out.println(matrixC);matrixC = matrixA.scale(9.99); // C = A*9.99System.out.println(matrixC);/* 除法T	divide(double val)      C = A/val    将矩阵A的所有元素都除以val*/matrixC = matrixA.divide(50);  //C = A的所有元素都除以50所得的矩阵System.out.println(matrixC);/*  矩阵的转置T	transpose()   返回给定矩阵的转置*/int val = 1;for (int i = 0; i < 4; i++) {for (int j = 0; j < 4; j++) {matrixC.set(i, j, val);val++;}}System.out.println(matrixC);SimpleMatrix matrixC_transpose = matrixC.transpose();System.out.println(matrixC_transpose);/*  矩阵的逆阵T	invert()            求可逆矩阵的逆阵T	pseudoInverse()     求摩尔彭若斯广义逆（对于可逆矩阵与上行方法一致）*/SimpleMatrix matrixD = new SimpleMatrix(4, 4);for (int i = 0; i < 4; i++) {for (int j = 0; j < 4; j++) {if (i == j) {matrixD.set(i, j, i + 1);} else {matrixD.set(i, j, 0);}}}System.out.println("矩阵D:\n"+matrixD);SimpleMatrix D_invert = matrixD.invert();System.out.println("矩阵D的逆阵:\n"+D_invert);SimpleMatrix D_pseudoInverse = matrixD.pseudoInverse();System.out.println("矩阵D的广义逆阵:\n"+D_pseudoInverse);//---------------------------------------------------------------------//创建n阶单位矩阵  identity matrixint n =7;SimpleMatrix tempMatrix = new SimpleMatrix(n,1); //创建nx1的列向量tempMatrix.fill(1); //所有元素置为1SimpleMatrix I =  tempMatrix.diag();//A.diag()方法，如果A是矩阵，则返回一个由该矩阵的对角线上的值组成的列向量//             如果A是列向量，则将其扩展为一个矩阵，矩阵的对角线的值就是该列向量System.out.println(I);//---------------------------------------------------------------------SimpleMatrix matrix = new SimpleMatrix(8,8);matrix.fill(4);     //将矩阵元素都设置为4matrix.zero();      //将矩阵元素都设置为0matrix.set(1,4,3);      //将第一行第四列元素设置为3matrix.set(0,8);            //将第零个元素设置为8matrix.rows(1,2);           //获取矩阵的部分行，第一个数表示开始的那一行，第二个数表示结束那一行加一（这里表示获取第一行）matrix.cols(2,8);           //获取矩阵的部分列，第一个数表示开始的那一列，第二个数表示结束那一列加一（这里表示获取第2,3,4,5,6,7行）matrix.get(2,3);   //获取第二行第三个数matrix.get(2);              //获取第二个元素matrix.copy();              //复制一个矩阵matrix.createLike();        //创建一个与matrix相同行列数且元素相同的矩阵matrix.numRows();           //获取矩阵的行数matrix.numCols();           //获取矩阵的列数matrix.getNumElements();    //获取矩阵的元素个数（行数乘以列数）matrix.elementMaxAbs();     //获取矩阵中所有元素绝对值的最大值matrix.elementMinAbs();     //获取矩阵中所有元素绝对值的最小值matrix.elementSum();        //计算矩阵中所有元素的和matrix.normF();             //计算矩阵的二范数（所有元素平方和开根号，可以理解成向量的模）matrix.determinant();       //计算矩阵行列数值//---------------------------------------------------------------------matrixC = matrixA.elementDiv(matrixB);   // 对应相除 C(i,j) = A(i,j) / B(i,j)matrixC = matrixA.elementMult(matrixB);  // 对应相乘 C(i,j) = A(i,j) * B(i,j)matrixC = matrixA.elementExp();          // C(i,j) = e 的 A(i,j)次方matrixC = matrixA.elementLog();          // C(i,j) = ln(C(i,j))matrixC = matrixA.elementPower(2);       // C(i,j) = A(i,j)^2 (对应元素的n次方)matrixC = matrixA.elementPower(matrixB); // C(i,j) = A(i,j)^(B(i,j)) (对应元素的对应次方)}
}

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！