简单实用的基于Java的矩阵类
java的矩阵运算
java的矩阵运算（最新版）目录1.矩阵运算的概述2.Java 中矩阵的表示方法3.Java 中的矩阵运算4.矩阵运算的实际应用正文【1.矩阵运算的概述】矩阵运算是线性代数中的一个重要概念，它在科学计算、数据处理以及图像处理等领域有着广泛的应用。
矩阵运算主要包括矩阵的加法、减法、乘法、转置等操作。
【2.Java 中矩阵的表示方法】在 Java 中，矩阵可以通过数组来表示。
一个 m 行 n 列的矩阵可以用一个 m 行 n 列的二维数组来表示。
例如，一个 3 行 3 列的矩阵可以用以下方式表示：```javaint[][] matrix = {{1, 2, 3},{4, 5, 6},{7, 8, 9}};```【3.Java 中的矩阵运算】在 Java 中，矩阵的运算方法主要包括以下几种：（1）矩阵加法：两个矩阵相加，对应位置的元素相加。
```javaint[][] matrix1 = {{1, 2, 3},{4, 5, 6},{7, 8, 9}};int[][] matrix2 = {{9, 8, 7},{6, 5, 4},{3, 2, 1}};int[][] result = addMatrices(matrix1, matrix2);```（2）矩阵减法：两个矩阵相减，对应位置的元素相减。
```javaint[][] result = subtractMatrices(matrix1, matrix2);```（3）矩阵乘法：两个矩阵相乘，需要满足矩阵 1 的列数等于矩阵 2 的行数。
乘法结果是一个新的矩阵，其中每个元素是矩阵 1 对应行与矩阵 2 对应列元素的乘积之和。
```javaint[][] matrix1 = {{1, 2, 3},{4, 5, 6}};int[][] matrix2 = {{7, 8},{9, 10},{11, 12}};int[][] result = multiplyMatrices(matrix1, matrix2);```（4）矩阵转置：将一个矩阵的行和列互换，得到一个新的矩阵。
java里matrix的实现类方法
java里matrix的实现类方法
在Java中，矩阵是一种常用的数据结构，用于表示和处理二维数组。
在实现类中，我们可以使用不同的方法来操作和处理矩阵。
一种常用的方法是创建一个矩阵类，并在其中实现各种操作方法。
这些方法可
以包括以下内容：
1. 矩阵的创建：可以通过构造函数或静态工厂方法创建一个新的矩阵对象。
可
以考虑使用二维数组或动态数组来存储矩阵的元素。
2. 矩阵的基本操作：包括获取矩阵的行数和列数、获取指定位置上的元素值、
设置指定位置上的元素值等。
3. 矩阵的运算：可以实现各种矩阵运算方法，比如矩阵相加、矩阵相乘、矩阵
转置等。
这些方法可以根据需要进行重载，以支持不同的矩阵尺寸和数据类型。
4. 矩阵的变换：可以实现矩阵的平移、旋转、缩放等变换方法。
这些方法可以
根据需求选择不同的算法和数学库来实现。
5. 矩阵的操作：可以实现一些常见的矩阵操作方法，比如矩阵求逆、求行列式、求特征值等。
这些方法可能需要使用数学库或实现相关的算法。
在实现矩阵类方法时，需要考虑到性能和代码可读性。
可以使用合适的数据结
构和算法来提高矩阵操作的效率，同时使用清晰的命名和注释来使代码易于理解和维护。
总之，通过在Java中实现矩阵的方法，我们可以方便地创建、操作和处理矩阵。
这样的实现可以提供丰富的功能和灵活性，使我们能够更好地处理和分析二维数组数据。
JAVA蛇形矩阵的两种实现方法
蛇形矩阵的两种实现方法(java版本)看到一个关于蛇形矩阵的帖子，想了下如何一行一行打印，无须建立二维数组存储。
基本思想如下：把这个输出的二维数组从外到里分解为多层每层都是一个正方形的边从外到里称为1,2,3...层对于一个指定维数(行＝列)的二维数组，其中某个位置的元素(x,y)首先根据x,y计算出这个位置所在的层数，然后根据层数计算出这层左上角元素的值，(这个元素的位置必然是(层数-1,层数-1))最后根据x,y计算出它相当于本层左上角元素的偏移量，二者相加，就是(x,y)的值.下面附上代码，欢迎大家拍砖。
程序比较粗糙，主要是算法实现，1.public class SnakeMatrix {2.//存储结果的二维数组3.private int[][] data;4.//二维数组的维数5.private int index;6.//0 右１下２左３上7.private int direct;8.public static void main(String[]args){9. SnakeMatrix s = new SnakeMatrix(10);10. s.print();11. }12.public SnakeMatrix(int i){13.if(i<1){14. System.out.println("参数错误");15. System.exit(0);16. }17. index = i;18. data = new int[i][i];19.for(int j=0;j<i;j++){20.for(int k=0;k<i;k++){21. data[j][k] = 0;22. }23. }24. direct = 0;25.//manageData();26. manageDataByMath();27.28. }29./**30. * 直接根据二维数组的x,y值来计算这个位置的元素值31. * 一圈为一层，从外到内分别为１，２，３...层32. * 首先得到这个位置元素的层数33. * 然后计算这层左上角元素的值34. * 再计算出这个位置(x,y)相对于左上角元素的偏移量35. * 二者相加，就是这个位置的元素值36. */37.public void manageDataByMath(){38.for(int i=0;i<index;i++){39.for(int j=0;j<index;j++){40. data[i][j] = getDataByPosition(i,j);41. }42. }43.44. }45./**46. * 数组被分为四个部分，47. * 只看左上部分，48. * (x,y)位置x,y的较小值就标明了这个位置的层数49. * 其他三个部分与左上部分是对称的50. * 映射一下关系就行了51. * @param i52. * @param j53. * @return55.public int getLevByPosition(int i,int j){56.int mid = (int)index/2;57.int tempi,tempj;58.if((i+1)>mid){59. tempi = index-i-1;60. }else{61. tempi = i;62. }63.if((j+1)>mid){64. tempj = index-j-1;65. }else{66. tempj = j;67. }68.if(tempi<tempj) return tempi+1;69.return tempj+1;70. }71./**72. * 计算本层左上角的元素值73. * @param i74. * @param j75. * @return76. */77.public int getDataByPosition(int i,int j){78.int lev = getLevByPosition(i,j);79.//每一层左上角第一个元素的值80.int startIndex = 0;81.//计算这个值82.for(int temp=1;temp<lev;temp++){83. startIndex +=((index-2*temp)*4+4);84. }85.return startIndex+getAdd(i,j,lev)+1;86. }87./**88. * 得到偏移量89. * @param i90. * @param j91. * @param lev92. * @return93. */94.public int getAdd(int i,int j,int lev){95.int add = 0;96.//每一层的边长97.int levEdge = index-2*(lev-1);99.if(i+1 == (index-(lev-1))){100.//这一层的倒数第一行101. add = 2*levEdge-1+(index-lev-1-j);102. }else if(i+1 == lev){103.//这一层的第一行104. add = j-lev+1;105. }else{//中间行106.if(j>((int)index/2)){107. add = levEdge + i-lev;108. }else{109. add = levEdge + levEdge-2 +levEdge+(index-lev-i-1); 110. }111. }112.return add;113. }114.private void changeDirect(){115. direct = (direct+1)%4;116. }117.//根据前进方向(direct)判断前方的二维数组元素是否没有赋值118.private boolean check(int j,int k){119.if(direct ==0){120.if((k+1)==index){121.return false;122. }else if(data[j][k+1]!=0){123.return false;124. }125. }else if(direct == 1){126.if((j+1)==index){127.return false;128. }else if(data[j+1][k]!=0){129.return false;130. }131. }else if(direct == 2){132.if(k==0){133.return false;134. }else if(data[j][k-1]!=0){135.return false;136. }137. }else{138.if(j==0){139.return false;140. }else if(data[j-1][k]!=0){141.return false;142. }143. }144.return true;145. }146./**147. * 直接根据蛇形的前进方向一个一个置二维数组的值148. */149.public void manageData(){150.int j = 0;151.int k = 0;152. data[j][k] = 1;153.for(int i=2;i<index*index+1;i++){154.//判断能否合法赋值155.while(!check(j,k)){156. changeDirect();157. }158.if(direct == 0){159. k++;160. }else if(direct == 1){161. j++;162. }else if(direct == 2){163. k--;164. }else{165. j--;166. }167. data[j][k] = i;168. }169.170. }171.//仅供参考，数据大了会连在一起172.public void print(){173.for(int i = 0;i<index;i++){174.for(int j = 0;j<index;j++){175.if(data[i][j]<10){176. System.out.print(" "+data[i][j]); 177. }else if(data[i][j]>99){178. System.out.print(" "+data[i][j]); 179. }180.else{181. System.out.print(" "+data[i][j]); 182. }183. }184. System.out.println();185. }186. } 187.188.}。
Java_lab2
实验二Java数组实验内容1.使用二维数组实现Matrix(矩阵)。
a)定义Matrix(矩阵)类，要求如下：i.变量：matrix(int型二维数组)，row(行数)，column(列数)；ii.方法：实现两个矩阵的加、减、乘法，所有方法将返回操作后的结果矩阵。
(两个矩阵的乘法：一个m×n的矩阵a（m,n)左乘一个n×p的矩阵b（n,p)，会得到一个m×p的矩阵c（m,p)。
矩阵的行数和列数自定。
）iii.构造函数自行定义。
b)编写主类，测试Matrix类。
包括：构建对象，测试每一个方法，并将测试结果输出到屏幕上。
c)这一条不作要求。
如果需要从键盘读入并给元素赋值，以下为参考代码：import java.io.*; //此语句必须添加到类定义的前面，导入I/O包……public void initiate1() throws IOException{ //从键盘读入0－9的个位数char ch;String s = "";for(int i=0; i<row ; i++){for(int j=0; j<column; j++){while((ch = (char)System.in.read())!= '\r'){ //读入一个chars = String.valueOf(ch); //将char转换成String}matrix[i][j]= Integer.parseInt(s); //将String转换成int}}}public void initiate2() throws IOException{ //从键盘读入多位数byte[] ba = new byte[10];for(int i=0; i<row ; i++){for(int j=0; j<column; j++){System.out.println("请输入元素值: "); //提示语句int length = System.in.read(ba); //从键盘读入一个字节数组,回车结尾String s = new String(ba, 0, length-2); //构建String对象，回车占两个字节matrix[i][j]= Integer.parseInt(s); //将s转换成int赋值。
数据结构学习----矩阵（Java实现）
数据结构学习----矩阵（Java实现）矩阵类：package com.clarck.datastructure.matrix;/*** 矩阵类** @author clarck**/public class Matrix {/*** 存储矩阵元素的⼆维数组*/private int element[][];/*** 构造m*n零矩阵* @param m* @param n*/public Matrix(int m, int n) {//若m或n为负数，Java将抛出负数组长度异常NegativeArrayExceptionthis.element = new int[m][n];}/*** 深拷贝* @param mat*/public Matrix(Matrix mat) {this(mat.element.length, mat.element[0].length, mat.element);}/*** 构造n*n零矩阵* @param n*/public Matrix(int n) {this(n, n);}/*** 返回当前矩阵与mat相加后的矩阵，不改变当前矩阵，=this+mat，各对应元素相加* @param mat* @return*/public Matrix plus(Matrix mat) {Matrix matc = new Matrix(this); //深拷贝matc.add(mat);return matc; //返回对象引⽤}/*** 构造m*n矩阵，由mat提供元素* @param m* @param n* @param mat*/public Matrix(int m, int n, int mat[][]) {this(m, n);for (int i = 0; i < mat.length && i < m; i++) {for (int j = 0; j < mat[i].length && j < n; j++) {this.element[i][j] = mat[i][j];}}}/*** 返回矩阵第i⾏，第j列元素值 O(1)* @param i* @param j* @return*/public int get(int i, int j) {//若i，j下标越界，Java将抛出数组下标越界异常ArrayIndexOutOfBoundsExceptionreturn this.element[i][j];}/*** 设置矩阵第i⾏第j列的元素值为value O(1)* @param i* @param j* @param value*/public void set(int i, int j, int value) {this.element[i][j] = value;}/*** 返回矩阵所有元素的描述字符串，⾏主序遍历*/@Overridepublic String toString() {String str = " 矩阵 " + this.getClass().getSimpleName() + " (" + this.element.length + " * " + this.element[0].length + ") :\n";for (int i = 0; i < this.element.length; i++) {for (int j = 0; j < this.element[i].length; j++) {str += String.format("%4d", this.element[i][j]);}str += "\n";}return str;}/*** 当前矩阵与mat矩阵相加，this += mat, 各对应元素相加;改变当前矩阵* @param mat*/public void add(Matrix mat) {if (this.element.length != mat.element.length ||this.element[0].length != mat.element[0].length)throw new IllegalArgumentException("两个矩阵阶数不同，不能相加");for (int i = 0; i < this.element.length; i++) {for (int j = 0; j < this.element[i].length; j++) {this.element[i][j] += mat.element[i][j];}}}/*** ⽐较两个同阶矩阵是否相等*/public boolean equals(Object obj) {if (this == obj)return true;if (!(obj instanceof Matrix))return false;Matrix mat = (Matrix) obj;if (this.element.length != mat.element.length|| this.element[0].length != mat.element[0].length)return false;for (int i = 0; i < this.element.length; i++)for (int j = 0; j < this.element[i].length; j++)if (this.element[i][j] != mat.element[i][j])return false;return true;}/*** 返回当前矩阵的转置矩阵* @return*/public Matrix transpose() {//构造零矩阵Matrix trans = new Matrix(this.element[0].length, this.element.length);for (int i = 0; i < this.element.length; i++)for (int j = 0; j < this.element[i].length; j++)trans.element[j][i] = this.element[i][j];return trans;}/*** 判断当前矩阵是否为上三⾓矩阵* @return*/public boolean isUpTriangular() {if (this.element.length != this.element[0].length)return false;for (int i = 0; i < this.element.length; i++)for (int j = 0; j < i; j++)//下三⾓元素为0if (this.element[i][j] != 0)return false;return true;}/*** 判断当前矩阵是否为下三⾓矩阵* @return*/public boolean isDownTriangular() {if (this.element.length != this.element[0].length)return false;for (int i = 0; i < this.element.length; i++)for (int j = i; j < this.element.length; j++)//上三⾓元素为0if (this.element[i][j] != 0)return false;return true;}/*** 判断当前矩阵是否为对称矩阵* @return*/public boolean isSymmetric() {if (this.element.length != this.element[0].length)return false;for (int i = 0; i < this.element.length; i++)for (int j = 0; j < this.element[i].length; j++)if (this.element[i][j] != this.element[j][i])return false;return true;}}测试类：package com.clarck.datastructure.matrix;public class Matrix_test {public static void main(String args[]) {int m1[][] = {{1,2,3}, {4,5,6,7,8}, {9,10,11}};//矩阵对象，初值不⾜时⾃动补0,忽略多余元素Matrix mata = new Matrix(3,4,m1);System.out.println("A" + mata.toString());Matrix matb = new Matrix(3, 4);matb.set(0, 0, 1);matb.set(1, 1, 1);matb.set(2, 2, 1);System.out.println("B" + matb.toString());Matrix matc = mata.plus(matb);System.out.println("C=A+B" + matc.toString());mata.add(matb);System.out.println("A+=B" + mata.toString());System.out.println("C.equals(A) ?" + matc.equals(mata));System.out.println("A的转置矩阵" + mata.transpose().toString()); System.out.println("B的转置矩阵" + matb.transpose().toString()); System.out.println("A是上三⾓矩阵" + mata.isUpTriangular());int m2[][] = {{1,2,3,4}, {0,5,6,7}, {0,0,8,9}};Matrix mate = new Matrix(4, 4, m2);System.out.println("E" + mate.toString());System.out.println("E是上三⾓矩阵?" + mate.isUpTriangular()); System.out.println("A是下三⾓矩阵?" + mata.isDownTriangular());int m3[][] = {{1},{1,2},{0,4},{5,6,7}};Matrix matf = new Matrix(4, 4, m3);System.out.println("F" + matf.toString());System.out.println("F是下三⾓矩阵?" + matf.isDownTriangular()); System.out.println("A是对称矩阵?" + mata.isSymmetric());int m4[][] = {{1,2,3,4},{2},{3},{4}};Matrix matg = new Matrix(4, 4, m4);System.out.println("G" + matg.toString());System.out.println("G是对称矩阵?" + matg.isSymmetric());}}测试结果如下：A 矩阵 Matrix (3 * 4) :1 2 3 04 5 6 79 10 11 0B 矩阵 Matrix (3 * 4) :1 0 0 00 1 0 00 0 1 0C=A+B 矩阵 Matrix (3 * 4) :2 23 04 6 6 79 10 12 0A+=B 矩阵 Matrix (3 * 4) :2 23 04 6 6 79 10 12 0C.equals(A) ?trueA的转置矩阵矩阵 Matrix (4 * 3) : 2 4 92 6 103 6 120 7 0B的转置矩阵矩阵 Matrix (4 * 3) : 1 0 00 1 00 0 10 0 0A是上三⾓矩阵falseE 矩阵 Matrix (4 * 4) :1 2 3 40 5 6 70 0 8 90 0 0 0E是上三⾓矩阵?trueA是下三⾓矩阵?falseF 矩阵 Matrix (4 * 4) :1 0 0 01 2 0 00 4 0 05 6 7 0F是下三⾓矩阵?falseA是对称矩阵?falseG 矩阵 Matrix (4 * 4) :1 2 3 42 0 0 03 0 0 04 0 0 0G是对称矩阵?true。
Java小议蛇形矩阵
Java小议蛇形矩阵
描述: 蛇形矩阵是由1开始的自然数依次排列成的一个矩阵上三角形。
输入正整数n（n
不大于100）输出，输出一个n行n列的蛇形矩阵。
例如5行5列蛇形矩阵输出为：
类似于前面的输出螺旋矩阵的方法，每一次在数组中填写新的数字都有一个方向，与输出螺旋数组不同的是不是简单的上下左右四个方向，这里涉及到右，下，右上，左下四个方向，针对每步操作都需要想好对应的处理方法，如：
1- 向右上位置填写元素的时候可能会碰到行<0或者是列 >= n，如果行小于0,那么接下来就需要向右填写元素，列大于等于n，那么很明显接下来就要向下填写元素。
2- 向下添加元素时，也会碰到一些情况，例如行 >= n了，表示添加到最后一行了，此时需要向右移动，另外在第一列和最后一列向下添加元素情况也不一样，在第一列向下添加元素后，接下来应该向右上添加元素，在最后一列向下添加元素后接下来应该向左下添加元素。
向左下和向右填写元素与这类似。
参考代码如下：
更多干货笔记关注微信公众号 : 老九学堂。
算法设计JAVA矩阵连乘
算法设计JAVA矩阵连乘矩阵连乘问题是一个经典的动态规划问题。
给定一系列的矩阵，我们的目标是找到一个最优的括号表达式，使得矩阵连乘的计算次数最少。
假设有n个矩阵，这些矩阵的维度顺序可以表示为一个数组p，其中第i个矩阵的维度为p[i-1] x p[i]。
我们可以使用一个二维数组dp来保存子问题的最优解，其中dp[i][j]表示矩阵i到j之间的最小计算次数。
初始化时，将dp[i][i]的值设为0，因为单独一个矩阵的计算次数为0。
接下来，我们需要遍历所有可能的区间长度l，从2开始直到n，因为最小区间只有两个矩阵。
对于每个区间长度，我们需要遍历所有可能的起点i，并计算以i为起点、长度为l的区间的最小计算次数。
具体算法如下：```javapublic class MatrixChainMultiplicationpublic static int matrixChainOrder(int[] p)int n = p.length - 1;int[][] dp = new int[n+1][n+1];//初始化单个矩阵的计算次数为0for (int i = 1; i <= n; i++)dp[i][i] = 0;}//遍历所有可能的区间长度for (int len = 2; len <= n; len++)//遍历所有可能的起点for (int i = 1; i <= n - len + 1; i++)int j = i + len - 1;dp[i][j] = Integer.MAX_VALUE;//遍历所有可能的分割点k，计算最小计算次数for (int k = i; k < j; k++)int cost = dp[i][k] + dp[k+1][j] + p[i-1]*p[k]*p[j]; if (cost < dp[i][j])dp[i][j] = cost;}}}}return dp[1][n];}public static void main(String[] args)int[] p = {10, 20, 30, 40, 30};int minCost = matrixChainOrder(p);System.out.println("最小计算次数为：" + minCost);}```这个算法的时间复杂度为O(n^3)，空间复杂度为O(n^2)。
[Java]编写自己的Matrix矩阵类
![[Java]编写自己的Matrix矩阵类](https://img.taocdn.com/s3/m/3b22775668eae009581b6bd97f1922791688be11.png)
[Java]编写⾃⼰的Matrix矩阵类⽤java实现⼀个简单的矩阵类，可以实现简单的矩阵计算功能。
class Matrix1.向量点乘public static double dot(double[] x,double[] y)2.矩阵和向量之积public static double[] mult(double[][] a,double[] x)3.向量和矩阵之积public static double[] mult(double[] y,double[][] a)4.矩阵和矩阵之积public static double[][] mult(double[][] a,double[][] b)5.转置矩阵public static double[][] transpose(double[][] a)6.打印向量public static void printVector(double[] a)7.打印矩阵public static void printMatrix(double[][] a)package com.xiaff;public class Matrix {//向量点乘public static double dot(double[] x,double[] y) {int lengthX=x.length;int lengthY=y.length;if(lengthX!=lengthY){System.out.println("Cannot Dot Product!");return 0.0;}double answer=0.0;for(int i=0;i<lengthX;i++){answer+=x[i]*y[i];}return answer;}//矩阵和向量之积public static double[] mult(double[][] a,double[] x){int rowA=a.length;int columnA=a[0].length;int rowX=x.length;if(columnA!=rowX){System.out.println("Cannot multiply them!");return x;}double[] answer=new double[rowA];for(int i=0;i<rowA;i++){for(int j=0;j<columnA;j++){answer[i]+=a[i][j]*x[j];}}return answer;}//向量和矩阵之积public static double[] mult(double[] y,double[][] a){ int rowA=a.length;int columnA=a[0].length;int columnY=y.length;if(columnY!=rowA){System.out.println("Cannot multiply them!"); return y;}double[] answer=new double[rowA];for(int i=0;i<columnA;i++){for(int j=0;j<columnY;j++){answer[i]+=y[j]*a[j][i];}}return answer;}//矩阵和矩阵之积public static double[][] mult(double[][] a,double[][] b){ int rowA=a.length;int rowB=b.length;int columnA=a[0].length;int columnB=b[0].length;if(columnA!=rowB){System.out.println("Cannot multiply them!"); return a;}double[][] c=new double[rowA][columnB];for (int i = 0; i < rowA; i++) {for (int j = 0; j < columnB; j++) {for (int k = 0; k < columnA; k++)c[i][j] += a[i][k] * b[k][j];}}return c;}//转置矩阵public static double[][] transpose(double[][] a){int row=a.length;int column=a[0].length;if(row!=column){System.out.println("Cannot transpose it!");return a;}double[][] b=new double[row][column];for(int i=0;i<row;i++){for(int j=0;j<column;j++){b[i][j]=a[j][i];}}return b;}//打印向量public static void printVector(double[] a){for(double i:a){System.out.print(i+" ");}System.out.println();}//打印矩阵public static void printMatrix(double[][] a){for(double[] row:a){for(double i:row)System.out.print(i+" ");System.out.println();}}}版权声明：本⽂为博主原创⽂章，未经博主允许不得转载。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
imat.mat[j][k] -= imat.mat[i][k] * t;
}
}
}
}
for (int i = 0; i < rw; i++)
if (jmat.mat[i][i] != 1) {
double t = jmat.mat[i][i];
简单实用的Java矩阵基本操作。包括新建、打印、加、减、乘、转置、求逆运算。
import java.util.Random;
public class Matrix {
public int row;
public int rank;
public double[][] mat;
public Matrix(int a, int b) {
return c;
}
public Matrix Invs() {
int rw = row, rk = rank;
Matrix imat = new Matrix(rw, rk);
Matrix jmat = new Matrix(rw, rk);
for (int i = 0; i < rw; i++)
}
return c;
}
public Matrix Multiply(Matrix a) {
Matrix c = new Matrix(row, a.rank);
if (rank == a.row) {
for (int i = 0; i < c.row; i++)
for (int j = 0; j < c.rank; j++) {
}
System.out.println();
}
public Matrix Plus(Matrix a) {
Matrix c=new Matrix(row,rank);
if (a.row == row && a.rank == rank) {
for (int i = 0; i < row; i++)
for (int j = 0; j < rank; j++)
for (int j = 0; j < rw; j++)
jmat.mat[i][j] = mat[i][j];
for (int i = 0; i < rw; i++)
for (int j = 0; j < rw; j++)
imat.mat[i][j] = 0;
for (int i = 0; i < rw; i++)
for (int j = 0;j < rw; j++) {
jmat.mat[i][j] = jmat.mat[i][j] / t;
imat.mat[i][j] = imat.mat[i][j] / t;
}
}
return imat;
}
}
c.mat[i][j] = mat[i][j] + a.mat[i][j];
} else {
System.out.println("matrixAdd error!");
}
return c;
}
public Matrix Minus(Matrix a) {
Matrix c=new Matrix(row,rank);
double sum = 0;
for (int k = 0; k < rank; k++)
sum += mat[i][k] * a.mat[k][j];
c.mat[i][j] = sum;
}
} else {
System.out.println("matrix Multiply errors!");
}
return c;
}
public Matrix Trans() {
Matrix c = new Matrix(rank,row);
for (int i = 0; i < c.row; i++)
for (int j = 0; j < c.rank; j++)
c.mat[i][j] = mat[j][i];
imat.mat[i][i] = 1;
for (int i = 0; i < rw; i++) {
for (int j = 0; j < rw; j++) {
if (i != j) {
double t = jmat.mat[j][i] / jmat.mat[i][i];
for (int k = 0; k < rw; k++) {
if (a.row == row && a.rank == rank) {
for (int i = 0; i <row; i++)
for (int j = 0; j <rank; j++)
c.mat[i][j] = mat[i][j] - a.mat[i][j];
} else {
System.out.println("matrixMinus error!");
}
public void Output() {
System.out.println("Matrix=:");
for (int i = 0; i < row; i++) {
for (int j = 0; j < rank; j++)
System.out.print(mat[i][j] + " ");
System.out.println();
row = a;
rank = b;
mat = new double[row][rank];
}
public void New(){
Random rand=new Random();
for (int i = 0; i < row; i++)
for (int j = 0; j < rank; j++)
mat[i][j]=rand.nextInt(100);