精华内容
下载资源
问答
  • java矩阵运算包jama使用总结
    千次阅读
    2019-06-20 20:49:44

    一 、创建矩阵对象

    (1)创建空矩阵对象

    int n  = 3;
    int m = 4;
    double[][] a = new double[n][m];
    Matrix matrix = new Matrix(a);
    

    n :矩阵的行数, m: 矩阵的列数

    (2) 根据已有数组进行创建

        public static Matrix list2Matrix(ArrayList<ArrayList<Integer>> arr){
            int n = arr.size();  //矩阵的行数
            int m = arr.get(0).size();   //矩阵的列数
            double[][] a = new double[n][m];
            Matrix matrix = new Matrix(a);    //初始化矩阵
            for(int i = 0; i < n; i++){
                for(int j = 0; j < m; j++){
                    matrix.set(i,j,arr.get(i).get(j));  //为矩阵赋值
                }
    
            }
    
            return matrix;
        }
    

    二、 对矩阵进行操作

    (1)获取矩阵行(列)数

    int row_num = matrix.getRowDimension()			//获取
    更多相关内容
  • [Java] 实现矩阵运算

    2021-01-06 18:15:47
    * 实现矩阵运算 * * @author Regino * class Matrix: * - height(): return no. of rows(行数) * - width(): return no. of columns(列数) * - add(Matrix target), multiply(double target): Linear ...
  • 基于JAVA矩阵运算JAR包,方便数据运算的操作
  • java中的矩阵运算

    千次阅读 2021-01-12 10:41:40
    java开发过程中,有时候遇到矩阵运算,就特别麻烦,没有特别好的接口可以直接调用,对于简单的矩阵加、减、乘、除等基本操作,可以自己去写。但是遇到大型的矩阵的求逆以及其他复杂的操作,建议使用第三方的jar包...

    在java开发过程中,有时候遇到矩阵运算,就特别麻烦,没有特别好的接口可以直接调用,对于简单的矩阵加、减、乘、除等基本操作,可以自己去写。但是遇到大型的矩阵的求逆以及其他复杂的操作,建议使用第三方的jar包,比如math3以及常见的jama包。
    1、矩阵的简单操作
    1、单位矩阵

    //单位矩阵
    public static double[][] formUnitMatrix(int dimen) {
            double [][]temp = new double[dimen][dimen];
            for(int i = 0;i< dimen ;i++){
                for(int j= 0;j< dimen;j++){
                    if(i==j)
                        temp[i][j]=1;
                    else
                        temp[i][j]=0;
                }
            }
            return temp;
        }
     
    

    2、矩阵的转置

       /*
        利用java实现矩阵的乘法和转置以及求逆矩阵
         */
        //转置,必须行列都一样
        public static double [][] matrixTransposition( double [][] changedMatrix){
            int colums = changedMatrix.length;
            double targetMatrix [][] = new double[colums][colums];
            for(int i = 0; i< colums ;i++){
                for(int j = 0; j< colums; j++){
                    targetMatrix[i][j] = changedMatrix[j][i];
                }
            }
            return targetMatrix;
        }
    
    

    3、矩阵的乘法

        //矩阵的乘法,前一个列数与后一个行数相同
        public static  double[][] matrixMultiply(double[][] previousMatrix , double [][] laterMatrix){
            if(previousMatrix[0].length!= laterMatrix.length){
                return null;
            }
            int lines = previousMatrix.length;   //新的行数
            int colums = laterMatrix[0].length;  //列数
            int commonLines = laterMatrix.length;  //前一个的列数与后一个的行数
            double[][] targetMatrix = new double[lines][colums];
            for(int i = 0; i < lines ; i++){
                for(int j = 0; j< colums ;j++){
                    BigDecimal sum = BigDecimal.valueOf(0.0);
                    for(int k = 0 ;k < commonLines ;k++){
                        sum = sum.add(BigDecimal.valueOf(previousMatrix[i][k]).multiply(BigDecimal.valueOf(laterMatrix[k][j])));
                    }
                    targetMatrix[i][j] = sum.doubleValue();
                }
            }
            return targetMatrix;
        }
    

    4、伴随矩阵以及矩阵求逆

    //  根据位置,求得伴随矩阵
        public static double [][] companionMatrix(double [][] matrix ,int line ,int column){
            int lines = matrix.length;
            int columns = matrix[0].length;
            double [][] targetMarix = new double[lines-1][columns-1];
            int dx=0;
            for(int i=0;i < lines ;++i){
                if(i!=line){
                    int dy=0;
                    for (int j=0;j < columns ;++j){
                        if (j!=column){
                            targetMarix[dx][dy++] = matrix[i][j];
                        }
                    }
                    ++dx;
                }
            }
            return targetMarix;
        }
       //根据伴随矩阵,求解逆矩阵
        public static double[][] matrixInv(double[][] solveMatrix){
            //行数与列数必须相等
            if (solveMatrix.length!=solveMatrix[0].length)
                return null;
            int lines = solveMatrix.length;
            int columns = solveMatrix[0].length;
            double A = matrixValues(solveMatrix);
            double[][] targetMatrix =new double[lines][columns];
            for(int i=0;i < lines;++i){
                for (int j=0;j< columns ;++j){
                    double[][] temp= companionMatrix(solveMatrix,i,j);
                    targetMatrix[j][i]=BigDecimal.valueOf(matrixValues(temp)).divide(BigDecimal.valueOf(A),40,BigDecimal.ROUND_DOWN).doubleValue() * Math.pow(-1,i+j);
                }
            }
            return targetMatrix;
        }
    

    4、求解行列式的值-----四阶

      //求矩阵的行列式,我们可以求解四次的
        public static double matrixValues(double [][] solvMatrix){
            if(solvMatrix.length!= solvMatrix[0].length)
                return 0.;
            if (solvMatrix.length==1)
                return solvMatrix[0][0];
            else if (solvMatrix.length==2)
                return matrix2Det(solvMatrix);
            else if (solvMatrix.length==3)
                return matrix3Det(solvMatrix);
            else {    //可以求解四次的
                double sum = 0.0;
                for (int i = 0; i < 4; i++) {
                    sum += Math.pow(-1, i + 2) * solvMatrix[0][i] * matrix3Det(companionMatrix(solvMatrix, 0, i));
                }
                return sum;
            }
        }
        
        //求解三阶的行列式值
        public static double matrix3Det(double[][] solvMatrix) {
            if(solvMatrix.length!=solvMatrix[0].length){
                return 0.;
            }
            double [][] A0 = companionMatrix(solvMatrix,0,0);
            double [][] A1 = companionMatrix(solvMatrix,0,1);
            double [][] A2 = companionMatrix(solvMatrix,0,2);
            BigDecimal Part1 = BigDecimal.valueOf(solvMatrix[0][0]).multiply(BigDecimal.valueOf(matrix2Det(A0)));
            BigDecimal Part2 = BigDecimal.valueOf(solvMatrix[0][1]).multiply(BigDecimal.valueOf(matrix2Det(A1)));
            BigDecimal Part3 = BigDecimal.valueOf(solvMatrix[0][2]).multiply(BigDecimal.valueOf(matrix2Det(A2)));
            BigDecimal part1_2 = Part1.subtract(Part2);
            BigDecimal final_result = part1_2.add(Part3);
            return final_result.doubleValue();
        }
        //求解2阶的行列式值
        public static double matrix2Det(double[][] solvMatrix) {
            BigDecimal first = BigDecimal.valueOf(solvMatrix[0][0]).multiply(BigDecimal.valueOf(solvMatrix[1][1]));
            BigDecimal second = BigDecimal.valueOf(solvMatrix[0][1]).multiply(BigDecimal.valueOf(solvMatrix[1][0]));
            return first.subtract(second).doubleValue();
        }
    
    展开全文
  • Java如何实现矩阵运算

    千次阅读 2020-06-02 18:32:03
    矩阵运算Java实现 简介Java实现两个矩阵相乘,并输出新的矩阵的值。 蓝桥杯算法——矩阵乘法,Java实现。 输入两个矩阵,分别是m*s,s*n大小。输出两个矩阵相乘的结果。 输入格式  第一行,空格隔开的三个正整数m...

    矩阵简介

    矩阵加、减法

    矩阵加法比较简单,就是相同位置的数字加一下。
    在这里插入图片描述
    减法类似,比较简单,略。

    矩阵乘法

    矩阵乘以常数

    矩阵乘以一个常数,就是所有位置都乘以这个数(也比较简单)。
    在这里插入图片描述

    矩阵乘以矩阵

    矩阵乘以矩阵就有些复杂了
    在这里插入图片描述

    计算原则

    第一个矩阵第一行的每个数字(2和1),各自乘以第二个矩阵第一列对应位置的数字(1和1),然后将乘积相加( 2 x 1 + 1 x 1),得到结果矩阵左上角的那个值3。依此类推,详细请参考下图:
    在这里插入图片描述
    这两个矩阵是A(22)和B(22)的,如果两个矩阵的规模不一样,该怎么解决?其实原理还是一样的。

    假设矩阵A、B分别是ms,sn大小的,矩阵C是AB相乘的结果。矩阵C应该是m行n列,其中C(i,j)等于矩阵A第i行行向量与矩阵B第j列列向量的内积。

    以蓝桥杯的算法题——矩阵乘法举例。

    蓝桥杯算法题

    资源限制
    时间限制:1.0s 内存限制:512.0MB
    问题描述
      输入两个矩阵,分别是ms,sn大小。输出两个矩阵相乘的结果。
    输入格式
      第一行,空格隔开的三个正整数m,s,n(均不超过200)。
      接下来m行,每行s个空格隔开的整数,表示矩阵A(i,j)。
      接下来s行,每行n个空格隔开的整数,表示矩阵B(i,j)。
    输出格式
      m行,每行n个空格隔开的整数,输出相乘後的矩阵C(i,j)的值。
    样例输入
    2 3 2
    1 0 -1
    1 1 -3
    0 3
    1 2
    3 1
    样例输出
    -3 2
    -8 2

    提示
    矩阵C应该是m行n列,其中C(i,j)等于矩阵A第i行行向量与矩阵B第j列列向量的内积。
    例如样例中C(1,1)=(1,0,-1)(0,1,3) = 1 * 0 +01+(-1)*3=-3

    Java实现矩阵乘法

    	public static void main ( String[] args ) {
            //输入
            Scanner sc = new Scanner(System.in);
            int m = sc.nextInt();
            int s = sc.nextInt();
            int n = sc.nextInt();
            int[][] arrA = new int[m][s];
            int[][] arrB = new int[s][n];
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < s; j++) {
                    arrA[i][j] = sc.nextInt();
                }
            }
            for (int i = 0; i < s; i++) {
                for (int j = 0; j < n; j++) {
                    arrB[i][j] = sc.nextInt();
                }
            }
            //算法
            int[][] arrC = new int[m][n];
            //矩阵A的m行
            for (int i = 0; i < m; i++) {
            	//矩阵B的n列
                for (int j = 0; j < n; j++) {
                	//矩阵A的行与矩阵B的列相乘求和(k的值与矩阵A的行与矩阵B的列相等)
                    for (int k = 0; k < s; k++) {
                        arrC[i][j] += arrA[i][k] * arrB[k][j];
                    }
                }
            }
            //输出
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < n; j++) {
                    System.out.print(arrC[i][j] + " ");
                }
                System.out.println();
            }
        }
    

    分析

    无论两个矩阵规模是否相等,实现矩阵乘法的关键点就在于上边代码的第三层循环的处理,需要保证每一行与每一列相乘。

    //矩阵A的行与矩阵B的列相乘求和(k的值与矩阵A的行与矩阵B的列相等)
    for (int k = 0; k < s; k++) {
       arrC[i][j] += arrA[i][k] * arrB[k][j];
    }
    
    展开全文
  • java矩阵运算包,用于矩阵的运算,比如矩阵相乘、转置等,Jama.jar及其API使用手册
  • Java矩阵运算,jama包

    千次阅读 2015-05-03 10:40:59
    Jama是一个基本的线性代数java包。包括一个基本的Matrix类和5...基本的算术运算包括矩阵相加,矩阵相乘,矩阵范式以及基于矩阵元素的算术运算。打印矩阵的函数也包括在内。 矩阵的五大分解,涉及一对或三元组,排列向量

    Jama是一个基本的线性代数java包。包括一个基本的Matrix类和5个矩阵分解类。

    Matrix类提供了基本的线性代数数值运算的功能,不同的构造函数可以构造双精度和浮点精度的二维数组,而不同的gets和sets方法可以返回子矩阵和矩阵元素。

    基本的算术运算包括矩阵相加,矩阵相乘,矩阵范式以及基于矩阵元素的算术运算。打印矩阵的函数也包括在内。

    矩阵的五大分解,涉及一对或三元组,排列向量矩阵等,对应于jama的5个矩阵分解类。这些分解类可由Matrix类访问,可以求解线性方程组,求解方阵行列式,求逆和其他矩阵运算。这些分解类如下:

    1、对称正定矩阵的Cholesky分解

    2、矩阵的LU分解(高斯消元)

    3、矩阵的QR分解

    4、对称和非对称方阵的特征向量值分解

    5、矩阵的奇异值分解   

    jama功能汇总如下图


    使用举例(首先要引入Jama.1.0.3.jar):

    import Jama.Matrix;
    
    public class Matrix_Test {
    	
    	public static void main(String[] args) {
    		double[][] a = {
    				{1,1,0},
    				{0,1,0},
    				{0,0,1}
    		};
    		
    		//利用二维数组创建矩阵
    		Matrix matrix = new Matrix(a);
    		
    		//打印矩阵,第一个参数是每一列的宽度,第二个参数是保留的小数点位数
    		matrix.print(3, 2);
    		
    		//求矩阵的逆
    		matrix.inverse().print(3,2);
    		
    		//求矩阵的转置
    		matrix.transpose().print(3,2);
    		
    		//矩阵乘法
    		matrix.transpose().times(matrix).print(3,2);
    	}
    }


    参考文献:

    jama jar包下载地址:http://math.nist.gov/javanumerics/jama/

    官方文档地址:http://math.nist.gov/javanumerics/jama/doc/

    JAMA:java矩阵包:http://article.yeeyan.org/view/49656/40905

    展开全文
  • 该程序实现了Java的基本运算: 1.矩阵的相加。 2.矩阵的相减。 3.矩阵于数的相乘。 4.矩阵矩阵的相乘。 5.矩阵的求秩。 6.矩阵的求逆(能求2阶以上的)。 7.矩阵的转秩。 代码运行结果: 源码下载: ...
  • Java开发机器学习算法的时候,经常用到矩阵运算,我们可以调用Jama包来完成矩阵运算。Jama包下载地址:https://dl.pandaidea.com/jarfiles/j/Jama/Jama-1.0.2.jar.zip新建一个工程和类,导入Jama的jar包(右击,build...
  • Java-矩阵运算

    万次阅读 2016-11-29 21:55:57
    java矩阵运算在学习机器学习算法时,发现运用java 来实现有些算法代码时,会有很大困难,其中有一点就是 java 本身并没有矩阵运算的 api,所以进行要实现矩阵运算就尤其复杂,在知乎上得知 java 有一个非常强大的...
  • java 矩阵运算

    2021-03-22 16:14:19
    首先需要引入包Jama-1.0.2.jar这个包下封装的对矩阵运算的方法,包括矩阵的加减乘除逆运算等package test;import Jama.Matrix;public class Test {public static void main(String[] args) {//创建2个二维数组double...
  • 在查阅相关资料,经过一番折腾后,我了解到一个名为Efficient Java Matrix Library(EJML,高效矩阵运算包)的第三方库,并将其运用到了我的一个机器学习实验代码中(为什么不用python,我也不知道)。现在对我所...
  • Java调用jama实现矩阵运算一、jama简介Jama是一个基本的线性代数java包。包括一个基本的Matrix类和5个矩阵分解类。Matrix类提供了基本的线性代数数值运算的功能,不同的构造函数可以构造双精度和浮点精度的二维数组...
  • Java实现矩阵运算

    万次阅读 2019-01-25 17:01:37
    Java实现矩阵运算前言代码例子 前言 Matlab中简单的矩阵运算,想要自己实现的话还要花一番功夫。 矩阵运算的原理就不多解释了,忘记朋友们可以回头翻翻课本。 代码 public class MatrixCalculate { //矩阵加法 C=A+...
  • Java矩阵库Jama

    2021-09-27 22:28:27
    适用于日常编程可能碰到的各种矩阵运算问题,提供了一个优雅的简便的解决方案。 官网链接:JAMA: Java Matrix Package (nist.gov) 原本只是搬砖式的项目工程到后半部分就卡壳了,没有合适的算法来支撑,在经过各种...
  • 我们正在计算某种其运行时间受矩阵运算约束的东西。(如果感兴趣,请在下面提供一些详细信息。)这种经历提示了以下问题:人们是否对使用Java库进行矩阵数学运算(例如,乘法,逆运算等)有经验?例如:JAMACOLTApache ...
  • java中的高效矩阵运算包Ejml的使用

    万次阅读 热门讨论 2018-04-16 10:16:34
    简介在编写算法时,经常会遇到矩阵运算,在java中,我之前介绍了,如何使用math3来做矩阵的相关运算。该博客的地址为: https://blog.csdn.net/qy20115549/article/details/54604264之前,我主要是使
  • import java.util.Scanner; public class MainClass { public static Scanner sc=new Scanner(System.in); public static void main(String[] args) { int rowCount,colCount; System.out.println("输入矩阵行列...
  • 使用java对基本的矩阵运算进行了实现,并与matlab执行结果进行了比较
  • 举例说明如下 二:矩阵的乘法规则:矩阵的乘法要求两个矩阵符合A(mx k), B( k x n)即矩阵A的列数与矩阵B的行数相等,否则无法完成矩阵运算。举例说明如下: Java代码如下:package pet.shop; public class ...
  • 在数学中,矩阵(Matrix)是一个按照长方阵列排列的复数或实数集合[1],最早来自于方程组的系数及常数所构成...将矩阵分解为简单矩阵的组合可以在理论和实际应用上简化矩阵运算。对一些应用广泛而形式特殊的矩阵,...
  • Java语言实现的矩阵的基本运算)程序的机泵功能是实现简单的:矩阵的加法乘法
  • [Java] Matrix 实现矩阵运算

    千次阅读 2020-02-17 19:57:13
    本文介绍了 [Java] Matrix 实现矩阵运算的应用案例。。。
  • Java中的矩阵运算

    2021-04-08 07:03:14
    Java中的一组静态方法,在涉及矩阵的所有数学计算中都至关重要
  • 矩阵运算 1.矩阵加法 2.矩阵减法 3.矩阵乘法 4.矩阵转置 2.Java实现 0.前言 本篇文章主要总结了矩阵的常见运算,以及Java中利用二维数组进行运算的实现 1.矩阵运算 1.矩阵加法 运算前提:多个矩阵的行数和列数相同,...
  • matlab之矩阵运算

    2022-01-03 19:27:02
    matlab之矩阵运算
  • Java矩阵计算库UJMP

    千次阅读 2020-03-19 11:45:23
    UJMP Universal Java Matrix Package

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 23,768
精华内容 9,507
关键字:

java矩阵运算

java 订阅
友情链接: IRJET-V5I3221.rar