• Java调用jama实现矩阵运算 线性代数java包,Jama的常用方法 2 详细记录 2.1 判定两个矩阵是否完全相同 利用的数学原理就是:矩阵的秩等于0的充分必要条件是这个矩阵是零矩阵。 行列如果相同,就...

    1 概述

    前段时间在搞一个工程,为了达到某个指标,和同事讨论竟然用到了矩阵的算法,越来越感觉矩阵的重要性了,这篇文章主要是某个工程开发过程中用到的算法,和android本身没有关系
    参考文章
    Java调用jama实现矩阵运算
    线性代数java包,Jama的常用方法
    jama的官方API

    2 详细记录

    2.1 判定两个矩阵是否完全相同

    利用的数学原理就是:矩阵的秩等于0的充分必要条件是这个矩阵是零矩阵。
    行列如果相同,就做减法

        public static boolean IsMatrixEqual(Matrix amatrix, Matrix bmatrix) {
            if(amatrix.getColumnDimension() == bmatrix.getColumnDimension() && amatrix.getRowDimension() == bmatrix.getRowDimension()) {
                Matrix minus_matrix = amatrix.minus(bmatrix);
                if (minus_matrix.rank() == 0) {
                    return true;
                }
                else
                    return false;
            }
            else
                return false;
        }
    

    demo

        double[][] vals = {{1.,2.,3},{4.,5.,6.},{7.,8.,10.}};
        Matrix A = new Matrix(vals);
    
        double[][] vals2 = {{1.,2.,3},{4.,5.,6.},{7.,8.,10.}};
        Matrix B = new Matrix(vals2);
        System.out.println(StackUtil.IsMatrixEqual(A,B));
    

    2.2 java 字符串处理

    2.2.1 统计字符串中某个字符的个数

    参考Java中判断某个String字符串是否包含特定字符串,并统计个数

    String res="AAAAABBAAA";
    String b="B";
    int count=
      (res.length()-res.replace(b,"").length())/b.length();
    

    2.2.2 将字符串进行分割,转化为矩阵

    (处理后可以用于机器学习的样本)

        public static Matrix CreateMatrixByStack(String[] str_array) {
            int row_dimension = str_array.length;
            int col_dimension = 0;
            System.out.println("row_dimension :" + row_dimension);
            List<Integer> colmu_index = new ArrayList<Integer>();
    
            for(int i = 0; i < str_array.length; i ++ ) {
                int colmu_index_len= str_array[i].length()-str_array[i].replace("X","").length() + 1;
                colmu_index.add(colmu_index_len);
                if(colmu_index_len > col_dimension) {
                    col_dimension = colmu_index_len;
                }
            }
            System.out.println("col_dimension: " + col_dimension);
    
            double[][] stack_val = new double[row_dimension][col_dimension];
    
            for(int i = 0; i < row_dimension; i++) {
                for(int j = 0; j < col_dimension; j++) {
                    if (j < colmu_index.get(i))
                        stack_val[i][j] = 1;
                    else
                        stack_val[i][j] = 0;
                }
            }
    
            return new Matrix(stack_val);
        }
    
    展开全文
  • 自己写的用JAVA矩阵的相关系数矩阵,初学习
  • Java-矩阵运算

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

    java

    矩阵运算

    在学习机器学习算法时,发现运用java 来实现有些算法代码时,会有很大困难,其中有一点就是 java 本身并没有矩阵运算的 api,所以进行要实现矩阵运算就尤其复杂,在知乎上得知 java 有一个非常强大的矩阵学习库UJMP(Universal Java Matrix Package),就去其官方网站学习了下,感觉非常棒,对其中自己比较常用的运算进行了测试。

    下载

    • 通过 maven
      这是下载UJMP最简单的方法了,你至少要下载ujmp-core这个jar 包,它包含最基础的矩阵类和线性代数函数。
    <dependency>
        <groupId>org.ujmp</groupId>
        <artifactId>ujmp-core</artifactId>
        <version>0.3.0</version>
    </dependency>

    其他的 jar 包你可以去官网查看。

    • 下载 jar 包
      如果你没有 maven,你可以下载ujmp-complete.jar,它包含了所有的 ujmp jar 包。

    快速入门

    import org.junit.Test;
    import org.ujmp.core.DenseMatrix;
    import org.ujmp.core.Matrix;
    
    /**
     * Created by lionel on 16/11/29.
     */
    public class MatrixTest {
        @Test
        public void test() {
            //创建4*4的 零矩阵
            Matrix dense = DenseMatrix.Factory.zeros(4, 4);
            System.out.println(dense);
            /*
            0.0000     0.0000     0.0000     0.0000
            0.0000     0.0000     0.0000     0.0000
            0.0000     0.0000     0.0000     0.0000
            0.0000     0.0000     0.0000     0.0000
            */
    
            //设置矩阵dense第三行第四列的元素为5.0
            dense.setAsDouble(5.0, 2, 3);
            //其他设置
            dense.setAsDouble(1.0, 0, 0);
            dense.setAsDouble(3.0, 1, 1);
            dense.setAsDouble(4.0, 2, 2);
            dense.setAsDouble(-2.0, 3, 3);
            dense.setAsDouble(-2.0, 1, 3);
            System.out.println(dense);
            /*
            1.0000     0.0000     0.0000     0.0000
            0.0000     3.0000     0.0000    -2.0000
            0.0000     0.0000     4.0000     5.0000
            0.0000     0.0000     0.0000    -2.0000
            */
    
            //矩阵dense的转置
            Matrix transpose = dense.transpose();
            System.out.println(transpose);
            /*
            1.0000     0.0000     0.0000     0.0000
            0.0000     3.0000     0.0000     0.0000
            0.0000     0.0000     4.0000     0.0000
            0.0000    -2.0000     5.0000    -2.0000
            */
    
            //矩阵dense与矩阵transpose相加
            System.out.println(dense.plus(transpose));
            /*
            2.0000     0.0000     0.0000     0.0000
            0.0000     6.0000     0.0000    -2.0000
            0.0000     0.0000     8.0000     5.0000
            0.0000    -2.0000     5.0000    -4.0000
             */
    
            //矩阵dense与矩阵transpose相减
            System.out.println(dense.minus(transpose));
            /*
            0.0000     0.0000     0.0000     0.0000
            0.0000     0.0000     0.0000    -2.0000
            0.0000     0.0000     0.0000     5.0000
            0.0000     2.0000    -5.0000     0.0000
            */
    
            //矩阵dense与矩阵transpose相乘
            Matrix matrixProduct = dense.mtimes(transpose);
            System.out.println(matrixProduct);
            /*
            1.0000     0.0000     0.0000     0.0000
            0.0000    13.0000   -10.0000     4.0000
            0.0000   -10.0000    41.0000   -10.0000
            0.0000     4.0000   -10.0000     4.0000
            */
    
            //矩阵dense 所有元素*2
            Matrix scaled = dense.times(2);
            System.out.println(scaled);
            /*
            2.0000     0.0000     0.0000     0.0000
            0.0000     6.0000     0.0000    -4.0000
            0.0000     0.0000     8.0000    10.0000
            0.0000     0.0000     0.0000    -4.0000
             */
    
            //矩阵 dense 的逆矩阵
            System.out.println(dense.inv());
            /*
            1.0000     0.0000     0.0000     0.0000
            0.0000     0.3333     0.0000    -0.3333
            0.0000     0.0000     0.2500     0.6250
           -0.0000    -0.0000    -0.0000    -0.5000
             */
    
            //生成4*4随机矩阵,元素值在01之间
            Matrix rand = Matrix.Factory.rand(4, 4);
            System.out.println(rand);
            /*
            0.5478     0.5100     0.7078     0.0600
            0.8316     0.4039     0.2553     0.0173
            0.4354     0.7132     0.7865     0.7006
            0.0394     0.4839     0.4374     0.6241
             */
    
            //生成4*4随机矩阵,元素值在-11之间
            Matrix randn = Matrix.Factory.randn(4, 4);
            System.out.println(randn);
            /*
            0.8655     0.6231    -0.4234     0.0802
            0.7217    -0.7399    -0.5692     0.6421
            -1.5557     0.4745     2.1110     1.5489
            -0.8520    -0.7722     0.9025    -0.4664
            */
    
            //产生2*3 元素值都为1.0000的矩阵
            Matrix ones = Matrix.Factory.ones(2, 3);
            System.out.println(ones);
            /*
            1.0000     1.0000     1.0000
            1.0000     1.0000     1.0000
             */
        }
    }
    展开全文
  • java数组矩阵乘法

    2020-05-28 23:33:52
    java 矩阵乘法 通俗易懂非常适合初学者学习和交流,对java进一步了解
  • Java实现矩阵相乘问题

    2019-07-15 20:50:24
    设M1和M2是两个n×n的矩阵,设计算法计算M1×M2 的乘积。 1.2实验目的 (1)提高应用蛮力法设计算法的技能; (2)深刻理解并掌握分治法的设计思想; (3)理解这样一个观点:用蛮力法设计的算法,一般来说,经过...

    1 问题描述
    1.1实验题目
    设M1和M2是两个n×n的矩阵,设计算法计算M1×M2 的乘积。

    1.2实验目的
    (1)提高应用蛮力法设计算法的技能;

    (2)深刻理解并掌握分治法的设计思想;
    
    (3)理解这样一个观点:用蛮力法设计的算法,一般来说,经过适度的努力后,都可以对其进行改进,以提高算法的效率。
    

    1.3实验要求
    (1)设计并实现用BF(Brute-Force,即蛮力法)方法求解矩阵相乘问题的算法;

    (2)设计并实现用DAC(Divide-And-Conquer,即分治法)方法求解矩阵相乘问题的算法;
    
    (3)以上两种算法的输入既可以手动输入,也可以自动生成;
    
    (4)对上述两个算法进行时间复杂性分析,并设计实验程序验证分析结果;
    
    (5)设计可供用户选择算法的交互式菜单(放在相应的主菜单下)。
    

    2 解决方案
    2.1 分治法原理简述
    分治法的设计思想是:将一个难以直接解决的大问题,分割成一些规模较小的相同问题,以便各个击破,分而治之。

    分治策略是:对于一个规模为n的问题,若该问题可以容易地解决(比如说规模n较小)则直接解决,否则将其分解为k个规模较小的子问题,这些子问题互相独立且与原问题形式相同,递归地解这些子问题,然后将各子问题的解合并得到原问题的解。这种算法设计策略叫做分治法。
    
    如果原问题可分割成k个子问题,1<k≤n ,且这些子问题都可解并可利用这些子问题的解求出原问题的解,那么这种分治法就是可行的。由分治法产生的子问题往往是原问题的较小模式,这就为使用递归技术提供了方便。在这种情况下,反复应用分治手段,可以使子问题与原问题类型一致而其规模却不断缩小,最终使子问题缩小到很容易直接求出其解。这自然导致递归过程的产生。分治与递归像一对孪生兄弟,经常同时应用在算法设计之中,并由此产生许多高效算法。
    
    分治法所能解决的问题一般具有以下几个特征:
    
    1. 该问题的规模缩小到一定的程度就可以容易地解决

    2. 该问题可以分解为若干个规模较小的相同问题,即该问题具有最优子结构性质。

    3. 利用该问题分解出的子问题的解可以合并为该问题的解;

    4. 该问题所分解出的各个子问题是相互独立的,即子问题之间不包含公共的子问题。

    2.2 分治法求解矩阵相乘原理
    首先了解一下传统计算矩阵相乘的原理:
    在这里插入图片描述
    在这里插入图片描述
    其次,看一下优化后的矩阵相乘法原理:
    在这里插入图片描述
    最后,看一下本文利用分治法求解矩阵相乘的原理(PS:本文求解其效率不是最高,主要是体验一下分治法,重点在于分治法):

    注意:使用分治法求解两个nxn阶矩阵相乘,其中n值为2的幂值,否则只能使用蛮力法计算。

    在这里插入图片描述
    在这里插入图片描述
    本文具体源码主要根据以上分块矩阵方法,先分块(即使用分治法),然后递归求解。

    2.3 具体实现源码

    package com.liuzhen.dac;
    
    public class Matrix {
        
        //初始化一个随机nxn阶矩阵
        public static int[][] initializationMatrix(int n){
            int[][] result = new int[n][n];
            for(int i = 0;i < n;i++){
                for(int j = 0;j < n;j++){
                    result[i][j] = (int)(Math.random()*10); //采用随机函数随机生成1~10之间的数
                }
            }            
            return result;            
        }
        
        //蛮力法求解两个nxn和nxn阶矩阵相乘
        public static int[][] BruteForce(int[][] p,int[][] q,int n){
            int[][] result = new int[n][n];
            for(int i=0;i<n;i++){
                for(int j=0;j<n;j++){
                    result[i][j] = 0;
                    for(int k=0;k<n;k++){
                        result[i][j] += p[i][k]*q[k][j];
                    }
                }
            }                
            return result;
        }
        
        //分治法求解两个nxn和nxn阶矩阵相乘
        public static int[][] DivideAndConquer(int[][] p,int[][] q,int n){
            int[][] result = new int[n][n];
            //当n为2时,返回矩阵相乘结果
            if(n == 2){
                result = BruteForce(p,q,n);            
                return result;
            }
            
            //当n大于3时,采用采用分治法,递归求最终结果
            if(n > 2){
                int m = n/2;
                
                int[][] p1 = QuarterMatrix(p,n,1);
                int[][] p2 = QuarterMatrix(p,n,2);
                int[][] p3 = QuarterMatrix(p,n,3);
                int[][] p4 = QuarterMatrix(p,n,4);
    //            System.out.println();
    //            System.out.print("矩阵p1值为:");
    //            PrintfMatrix(p1,m);
    //            System.out.println();
    //            System.out.print("矩阵p2值为:");
    //            PrintfMatrix(p2,m);
    //            System.out.println();
    //            System.out.print("矩阵p3值为:");
    //            PrintfMatrix(p3,m);
    //            System.out.println();
    //            System.out.print("矩阵p4值为:");
    //            PrintfMatrix(p4,m);
                
                int[][] q1 = QuarterMatrix(q,n,1);
                int[][] q2 = QuarterMatrix(q,n,2);
                int[][] q3 = QuarterMatrix(q,n,3);
                int[][] q4 = QuarterMatrix(q,n,4);
                
                int[][] result1 = QuarterMatrix(result,n,1);
                int[][] result2 = QuarterMatrix(result,n,2);
                int[][] result3 = QuarterMatrix(result,n,3);
                int[][] result4 = QuarterMatrix(result,n,4);
                
                
                result1 = AddMatrix(DivideAndConquer(p1,q1,m),DivideAndConquer(p2,q3,m),m);
                result2 = AddMatrix(DivideAndConquer(p1,q2,m),DivideAndConquer(p2,q4,m),m);
                result3 = AddMatrix(DivideAndConquer(p3,q1,m),DivideAndConquer(p4,q3,m),m);
                result4 = AddMatrix(DivideAndConquer(p3,q2,m),DivideAndConquer(p4,q4,m),m);
                
                
                result = TogetherMatrix(result1,result2,result3,result4,m);
            }
            return result;
        }
        
        //获取矩阵的四分之一,并决定返回哪一个四分之一
        public static int[][] QuarterMatrix(int[][] p,int n,int number){
            int rows = n/2;   //行数减半
            int cols = n/2;   //列数减半
            int[][] result = new int[rows][cols];
            switch(number){
               case 1 :
               {
                  // result = new int[rows][cols];
                   for(int i=0;i<rows;i++){
                       for(int j=0;j<cols;j++){
                           result[i][j] = p[i][j];
                       }
                   }
                   break;
               }
                
               case 2 :
               {
                  // result = new int[rows][n-cols];
                   for(int i=0;i<rows;i++){
                       for(int j=0;j<n-cols;j++){
                           result[i][j] = p[i][j+cols];
                       }
                   }
                   break;
               }
               
               case 3 :
               {
                  // result = new int[n-rows][cols];
                   for(int i=0;i<n-rows;i++){
                       for(int j=0;j<cols;j++){
                           result[i][j] = p[i+rows][j];
                       }
                   }
                   break;
               }
               
               case 4 :
               {
                  // result = new int[n-rows][n-cols];
                   for(int i=0;i<n-rows;i++){
                       for(int j=0;j<n-cols;j++){
                           result[i][j] = p[i+rows][j+cols];
                       }
                   }
                   break;
               }
               
               default:
                   break;
            }
            
            return result;
         }
        
        //把均分为四分之一的矩阵,聚合成一个矩阵,其中矩阵a,b,c,d分别对应原完整矩阵的四分中1、2、3、4
        public static int[][] TogetherMatrix(int[][] a,int[][] b,int[][] c,int[][] d,int n){
            int[][] result = new int[2*n][2*n];
            for(int i=0;i<2*n;i++){
                for(int j=0;j<2*n;j++){
                    if(i<n){
                        if(j<n){
                            result[i][j] = a[i][j];
                        }
                        else
                            result[i][j] = b[i][j-n];
                    }
                    else{
                        if(j<n){
                            result[i][j] = c[i-n][j];
                        }
                        else{
                            result[i][j] = d[i-n][j-n];
                        }
                    }
                }
            }
            
            return result;
        }
        
        
        //求两个矩阵相加结果
        public static int[][] AddMatrix(int[][] p,int[][] q,int n){
            int[][] result = new int[n][n];
            for(int i=0;i<n;i++){
                for(int j=0;j<n;j++){
                    result[i][j] = p[i][j]+q[i][j];
                }
            }
            return result;
        }
        
        //控制台输出矩阵
        public static void PrintfMatrix(int[][] matrix,int n){
            for(int i=0;i<n;i++){
                System.out.println();
                for(int j=0;j<n;j++){
                    System.out.print("\t");
                    System.out.print(matrix[i][j]);
                }
            }
            
        }
        
        public static void main(String args[]){
            int[][] p = initializationMatrix(8);
            int[][] q = initializationMatrix(8);
            System.out.print("矩阵p初始化值为:");
            PrintfMatrix(p,8);
            System.out.println();
            System.out.print("矩阵q初始化值为:");
            PrintfMatrix(q,8);
            
            int[][] bf_result = BruteForce(p,q,8);
            System.out.println();
            System.out.print("蛮力法计算矩阵p*q结果为:");
            PrintfMatrix(bf_result,8);
        
            int[][] dac_result = DivideAndConquer(p,q,8);
            System.out.println();
            System.out.print("分治法计算矩阵p*q结果为:");
            PrintfMatrix(dac_result,8);
        }
    
    }
    

    2.4 运算结果截图
    在这里插入图片描述

    展开全文
  • Java实现矩阵的乘法

    2020-05-16 20:05:18
    矩阵乘法 先点赞,后观看,养成好习惯! import java.util.Scanner; public class text11 { //矩阵相乘的方法 public static void multiplyMatrix(int matrix1[][],int matrix2[][]) { //矩阵相乘的条件:前一...

    矩阵乘法

    点赞,后观看,养成好习惯!

    import java.util.Scanner;
    
    public class text11 {
    	//矩阵相乘的方法
        public static void  multiplyMatrix(int matrix1[][],int matrix2[][]) {
            //矩阵相乘的条件:前一矩阵的列数等于后一矩阵的行数
            if (matrix1.length != matrix2[0].length)
                System.out.println("输入的矩阵不符合矩阵相乘条件!");
    
            int line_length = matrix1.length;
            int list_length = matrix2[0].length;
            int[][] multiply = new int[line_length][list_length];
            //相乘
            for (int i = 0; i < line_length; i++) {
                for (int j = 0; j < list_length; j++) {
                    for (int k = 0; k < matrix2.length; k++) {
                        multiply[i][j] += matrix1[j][k] + matrix2[k][j];
                    }
                }
            }
            //输出相乘的结果
            for (int i = 0; i < line_length; i++) {
                for (int j = 0; j < list_length; j++) {
                    System.out.print(multiply[i][j] + " ");
                }
                System.out.print("\n");
            }
        }
    		//程序入口
        public static void main(String[] args) {
        	//输入矩阵的维度
            Scanner in = new Scanner(System.in);
            System.out.println("矩阵的维度为:\n" + "矩阵一:\n" + "行:");
            int line_1_length = in.nextInt();
            System.out.println("列:");
            int list_1_length = in.nextInt();
            System.out.println("矩阵二:\n" + "行:");
            int line_2_length = in.nextInt();
            System.out.println("列:");
            int list_2_length = in.nextInt();
    
            int[][] a = new int[line_1_length][list_1_length];
            int[][] b = new int[line_2_length][list_2_length];
    
            System.out.println("请输入矩阵:" + "\n矩阵一:");
            for (int i = 0; i < line_1_length; i++) {
                for (int j = 0; j < list_1_length; j++) {
                    a[i][j] = in.nextInt();
                }
            }
            System.out.println("矩阵二:\n");
            for (int i = 0; i < line_2_length; i++) {
                for (int j = 0; j < list_2_length; j++) {
                    b[i][j] = in.nextInt();
                }
            }
            multiplyMatrix(a,b);
        }
    }
    
    

    以上…
    觉得有帮助的话,记得点赞、收藏

    加关注o

    展开全文
  • JAVA矩阵包JAMA学习

    2016-09-14 17:56:48
    原文链接:JAMA:Java矩阵包 API文档链接:线性代数Java包 JAMA jama是一个非常好用的java的线性代数软件包。适用于日常编程可能碰到的各种矩阵运算问题,提供了一个优雅的简便的解决方案。 jama:java 矩阵包...

    原文链接:JAMA:Java矩阵包

    API文档链接:线性代数Java包 JAMA

    jama是一个非常好用的java的线性代数软件包。适用于日常编程可能碰到的各种矩阵运算问题,提供了一个优雅的简便的解决方案。

    jama:java 矩阵包

    背景

    jama是一个基本的线性代数java包,它提供了实数非稀疏矩阵类,程序员可构造操控这些类。对于经常使用到矩阵运算的码农来说,即使不精通线性代数也没有关系,因为jama包提供的功能已经够用,调用方便,使用自然,而且易于理解。Jama包意欲称为java的标准矩阵包,这一标准计划将提交给Java Grande论坛,转而交给sun公司。java矩阵类的潜在竞争对手包括Mathworks公司和国家标准化管理委员会(NIST)实现的矩阵类,我们发布这一版本,以广收评议。将来jama的新版本不一定和现在的版本兼容。

    NIST和马里兰大学曾开发过一个类似的矩阵包:Jampack,这两个包的出现,出于用户对矩阵的不同实现需求。Jama基于单个矩阵类,是一个严格的面向对象的框架,而Jampack的方案更为开放,便于用户的扩展。对一般用户而言,这两个包只是在矩阵操作的语法层面上有所差别。我们希望你有时间同时了解一下这两个矩阵包,一定会受益匪浅。

    功能:

    jama由如下6个类组成: Matrix,CholeskyDecomposition, LUDecomposition, QRDecomposition, SingularValueDecomposition and EigenvalueDecomposition

    Matrix类提供了基本的线性代数数值运算的功能,不同的构造函数可以构造双精度和浮点精度的二维数组,而不同的gets和
    sets方法可以返回子矩阵和矩阵元素。基本的算术运算包括矩阵相加,矩阵相乘,矩阵范式以及基于矩阵元素的算术运算。打印矩阵的函数也包括在内。

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

    • 对称正定矩阵的Cholesky分解
    • 矩阵的LU分解(高斯消元)
    • 矩阵的QR分解
    • 对称和非对称方阵的特征向量值分解
    • 矩阵的奇异值分解

    目前jama只支持实数矩阵。将来可能会加入复数矩阵的支持。现在暂不实现复数矩阵,主要是由于现在还没有太多这方面的需求,故先不冒重新设计而带来的复杂风险。

    Jama的设计其实是一种纯面向对象的易用性和高性能计算需求之间的折中。

     

    JAMA功能汇总

    对象操作

    构造函数  
    set 方法  
    get 方法 
    拷贝方法
    克隆方法
    矩阵元素级别的操作 矩阵加法
    矩阵减法
    矩阵乘法
    放大缩小
    元素乘法  
    元素除法
    求反
    倒置  
    范式
    矩阵分解

    Cholesky  
    LU  
    QR  
    SVD  
    对称矩阵的特征值
    非对称矩阵的特征值

    线性方程求解

    非奇异系统
    最小二乘

    矩阵相关的数学量

    条件数  
    行列式
    矩阵秩  
    求逆
    伪逆

     

    使用范例 下面的例子求解了一个线性方程Ax = b,矩阵规模为 3 * 3,最后算出了残差的范式。

              double[][] array = {{1.,2.,3},{4.,5.,6.},{7.,8.,10.}}; 
          Matrix A = new Matrix(array); 
          Matrix b = Matrix.random(3,1); 
          Matrix x = A.solve(b); 
          Matrix Residual = A.times(x).minus(b); 
          double rnorm = Residual.normInf();

    参考实现. 

    本网站下载的jama实现只能作为参考实现。它本质上还是一个教学性质的软件包。其中的算法类于于Wilkinson和Reinsch的手册中的内容,比如在EISPACK,LINPACK和MATLAB中使用的算法。Matrices类的内部数据存储为java的基本数组类型(比如,double[][]),代码可读性强,易于理解。虽然对于中小型的数据规模,我们的程序足够快速,但我们还是非常希望软件商和java虚拟机能够针对特征环境做一些优化。

    未涵盖的内容

    jama不是一个完整的线性代数运算库,比如我们就没有提供特征结构的矩阵类(比如带状矩阵,稀疏矩阵等),也没有实现更多的特定矩阵分解类(比如Shur,泛特征值分解等)。复数矩阵也不在其内。忽略这些实现并不是我们的本意。我们希望未来的本版中可以提供其中的一些功能(比如复数矩阵)。我们设计的宗旨是,不封死将来针对其他扩展功能的路。

    最后,jama也不是一个通用的数组类,相反,它主要关注于与矩阵数值计算相关的数学运算。所以其中并没有任何关于数组的操作,比如对矩阵各个元素求sine,exp,log,或者变形矩阵之类的操作。这些操作在很多应用中很有用,在一个单独的array类中提供显然最好。

    矩阵包1.0.2版

    早期保本




    jama是一个基本的线性代数java包,它提供了实数非稀疏矩阵类,程序员可构造操控这些类。对于经常使用到矩阵运算的码农来说,即使不精通线性代数也没有关系,因为jama包提供的功能已经够用,调用方便,使用自然,而且易于理解。

           JAMA功能汇总

    Jama.Matrix
           对象操作
                构造函数  
                set 方法    set(int i, int j, double s) 
                get 方法  get(int i, int j)  getArray()
                拷贝方法 copy() 
               克隆方法 clone()

    矩阵元素级别的操作

          矩阵加法 plus(Matrix B) 
           矩阵减法  minus(Matrix B)
           矩阵乘法 times(Matrix B)
            放大缩小
           元素乘法  arrayTimesEquals(Matrix B) 
            元素除法 arrayLeftDivide(Matrix B) 
           求反 uminus() 
           倒置   transpose() 
           范式 norm()

    矩阵分解

          Cholesky   chol()
           LU  lu() 

           QR   qr()

              SVD   svd()
             对称矩阵的特征值  eig()

           非对称矩阵的特征值 eig()

    线性方程求解

               非奇异系统
               最小二乘    solve(Matrix B)

    矩阵相关的数学量

              条件数   cond() 
              行列式 det() 
              矩阵秩  rank() 
             求逆 inverse()

              伪逆 inverse()

    展开全文
  • 转载请注明出处: 转载自 Thinkgamer的CSDN博客:blog.csdn.net/gamer_gyt ... 第一此介绍稀疏矩阵是在数据结构学习时,然后当时并没有多么用心的去学习它,因为,感觉它在实际应用中很少遇见,直
  • Java实现稀疏矩阵

    2019-09-05 20:02:24
    笔者最近在学习数据结构与算法,现在我想总结一下稀疏矩阵Java实现。 一、什么是稀疏矩阵 自我理解:我们有一些数据中,有效数据占据所有数据的比例小,这个时候,用一个较大的存储空间存储这部分数据会浪费空间...
  • 前一篇博客没有提及如何计算两个矩阵之和,由于全是以代码来说明,所以便专门写一博客进行讲解。我是Java小白,如果说错了,欢迎各位大佬指点。 如何计算两个矩阵之和 先举个例子(两个3*3矩阵之和) public ...
  • math3中的矩阵操作 演示结果本文作者:合肥工业大学 管理学院 钱洋 email:1563178220@qq.com 内容可能有不到之处,欢迎交流。 未经本人允许禁止转载。下面是本文博客的另一个地址,该网站是师兄弄得一个专门做机器...
  • 简介在编写算法时,经常会遇到矩阵的运算,在java中,我之前介绍了,如何使用math3来做矩阵的相关运算。该博客的地址为: https://blog.csdn.net/qy20115549/article/details/54604264之前,我主要是使
  • Java矩阵类库

    2019-02-22 21:31:34
    java 有一个非常强大的矩阵学习库UJMP(Universal Java Matrix Package),就去其官方网站学习了下,感觉非常棒,对其中自己比较常用的运算进行了测试。 下载 通过 maven  这是下载UJMP最简单的方法了,你至少要下载...
  • import java.util.Scanner; //邻接矩阵(图) public class MyGraph { int MAX_SIZE = 100; // 定义一个一维数组存储顶点 final static int INFINITE = Integer.MAX_VALUE; char[] vex; // 定义二维数组存储边 ...
  • 矩阵转置 定义: 矩阵转置的定义:设m×n矩阵[插图]把矩阵A的行换成同序数的列,得到的n×m矩阵称为矩阵A的转置矩阵,记为AT,即 对应代码git地址
  • 给定一个 n x n 矩阵,其中每行和每列元素均按升序排序,找到矩阵中第k小的元素。 请注意,它是排序后的第k小元素,而不是第k个元素。 示例: matrix = [ [ 1, 5, 9], [10, 11, 13], [12, 13, 15] ], k = 8, 返回 ...
  • 现在重新开始好好写一下这段时间学习算法的代码实现。算法来源是b站的BV1E4411H73v.因为教学是java实现的,所以跟着老师用java的算法实现,虽然工作中用的是c#,就当做新学一门语言吧。 稀疏矩阵矩阵中,若...
  • java实现矩阵快速幂算法
1 2 3 4 5 ... 20
收藏数 27,259
精华内容 10,903
热门标签
关键字:

java学习矩阵