步骤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的所有元素乘以-1
T 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); //将第零个元素设置为8
matrix.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的矩阵A
SimpleMatrix matrixB = new SimpleMatrix(4, 4); //创建4x4的矩阵B
SimpleMatrix matrixC = new SimpleMatrix(4, 4); //创建5x5的矩阵C
matrixA.fill(1); //将A的所有元素设为1
matrixB.fill(2); //将B的所有元素设为2
System.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加上矩阵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的所有元素乘以-1
T 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); //将第零个元素设置为8
matrix.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)) (对应元素的对应次方)
}
}
扫一扫
904
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
