2020/3/3

Calculator.java

@@ -0,0 +1,53 @@
+public class Calculator {
+
+    public double[][] plus(Juzhen m,Juzhen n){
+        double[][] c=new double[20][20];
+        for(int i=0;i<m.row;i++)
+            for(int j=0;j<m.column;j++)
+            {
+                c[i][j]=m.a[i][j]+n.a[i][j];
+            }
+        return c;
+    }
+    public double[][] minus(Juzhen m,Juzhen n){
+        double[][] c=new double[20][20];
+        for(int i=0;i<m.row;i++)
+            for(int j=0;j<m.column;j++)
+            {
+                c[i][j]=m.a[i][j]-n.a[i][j];
+            }
+        return c;
+    }
+    public double[][] multiply(Juzhen m,Juzhen n){
+        double[][] result = new double[20][20];
+        for(int r = 0;r < m.row;r++){
+            for(int col = 0;col < n.column;col++){
+                double num = 0;
+                for(int i = 0;i <m.column;i++){
+                    num+=m.a[r][i]*n.a[i][col];
+                }
+
+                result[r][col]=num;
+            }
+        }
+        return result;
+
+    }
+    public double[][] power(Juzhen a,int n){
+        double [][] c=new double[20][20];
+        Juzhen b=new Juzhen(a.row,a.column);
+        b.setA(a.a);
+        for(int i=1;i<n;i++)
+        {
+            c=multiply(b,a);
+            b.setA(c);
+        }
+        return c;
+    }
+
+
+
+
+}
+
+

Eye.java

@@ -0,0 +1,17 @@
+public class Eye extends Juzhen {
+    public Eye(int row,int column){
+        super(row,column);
+    }
+    public void makeEye(double[][] a){
+        for(int i=0;i<row;i++)
+            for(int j=0;j<column;j++)
+            {
+                a[i][j]=0;
+            }
+        for(int i=0;i<row;i++)
+        {
+            a[i][i]=1;
+        }
+    }
+
+}

Gauss.java

@@ -0,0 +1,155 @@
+public class Gauss {
+
+
+        // 高斯消元法
+        public double[] Leave(double[][] arr,int row,int column) {
+
+            double[] result = solution(arr);
+            for (int i = 0; i < arr.length; i++) {
+                result[i] = arr[i][arr[0].length - 1];
+            }
+
+            System.out.println("结果如下：");
+            printArr(arr,row,column);
+
+            for (double f : result) {
+                System.out.print(f + " ");
+            }
+            return result;
+        }
+
+        /*
+         * 结果在行列式中 所以 列式比行数多1
+         */
+        public double[] solution(double[][] arr) {
+            int row = arr.length; // 行数
+            int col = arr[0].length; // 列数
+//		System.out.println("row = " + row + " col = " + col);
+            double[] result = new double[row]; // 有多少个方程就有多少个未知数， 所以结果的个数为 行数
+
+            for (int i = 0; i < row; i++) {
+                int maxRow = SelectIndex(arr, i);
+
+                // 寻找最大行、交换
+                if (maxRow != i) {
+                    swapRow(arr, i, maxRow);
+                }
+
+                // 归一化 当前行 每一个元素都除以当前 arr[i][i] 上的元素，归一化
+                double divNum = arr[i][i];
+                for (int k = i; k < col; k++) { // 当前行 的每一列元素都除以这个数
+                    arr[i][k] /= divNum;
+                }
+
+                // 用这个1， 消去下面所有行的数
+                arr = elimination(arr, i);
+
+            }
+
+//		System.out.println("回代啦");
+            // 回代 从最后一行开始
+            backProgram(arr);
+
+            return result;
+        }
+
+        /*
+         * 从最后一行回代，得到结果
+         */
+        public double[][] backProgram(double[][] arr) {
+
+            int row = arr.length; // 行
+            int col = arr[0].length; // 列
+            for (int i = row - 1; i >= 0; i--) {
+                for (int j = i - 1; j >= 0; j--) {
+//				System.out.println("arr[" + j + "][" + (col - 1) + "] = " + arr[j][col - 1]);
+//				System.out.println("arr[" + j + "][" + i + "] = " + arr[j][i]);
+//				System.out.println("arr[" + i + "][" + i + "] = " + arr[i][i]);
+//				System.out.println("arr[" + j + "][" + i + "] * arr[" + i + "][" + (col - 1) + "] = "
+//						+ arr[j][i] * arr[i][col - 1]);
+//				printArr(arr);
+                    arr[j][col - 1] -= arr[j][i] * arr[i][col - 1];
+                    arr[j][i] = 0;
+
+//				printArr(arr);
+                }
+
+            }
+
+            return arr;
+        }
+
+        /*
+         * 用当前行消去下面的所有元素
+         */
+        public double[][] elimination(double[][] arr, int i) {
+            int row = arr.length;
+            int col = arr[0].length;
+            double subNum;
+            for (int k = i + 1; k < row; k++) { // i行消去下面的行
+                subNum = arr[k][i];
+                for (int j = i; j < col; j++) {
+                    arr[k][j] -= (arr[i][j] * subNum);
+                }
+            }
+
+            return arr;
+        }
+
+        /*
+         * arr 为行列式 i行，j列 寻找 i -> row 这些行中 j列上最大的元素 并返回该行的下标
+         */
+        public int SelectIndex(double[][] arr, int j) {
+            int row = arr.length;
+            int index = j;
+
+            // 寻找 j列中最大的元素的下标
+            for (int k = j; k < row; k++) {
+                if (Math.abs(arr[k][j]) > Math.abs(arr[index][j])) {
+                    index = k;
+                }
+            }
+
+            return index;
+        }
+
+        /*
+         * 交换 i, j 两行上的所有元素
+         */
+        public double[][] swapRow(double[][] arr, int i, int j) {
+            int col = arr[0].length; // 行列式的列数
+            double tmp;
+
+            for (int k = 0; k < col; k++) {
+                tmp = arr[i][k];
+                arr[i][k] = arr[j][k];
+                arr[j][k] = tmp;
+            }
+
+            return arr;
+        }
+
+        public void printArr(double arr[][],int row,int column) {
+            for (int i = 0; i < row; i++) {
+                for (int j = 0; j < column; j++) {
+                    System.out.print(arr[i][j] + "   ");
+                }
+                System.out.println();
+            }
+            System.out.println();
+        }
+
+        /*public static void main(String[] args) {
+            float arr[][] = { { 2, 3, 11, 5, 2 }, { 1, 1, 5, 2, 1 }, { 2, 1, 3, 2, -3 }, { 1, 1, 3, 3, -3 } };
+
+
+            Gauss gauss = new Gauss();
+            System.out.println("高斯消元求解前：");
+            gauss.printArr(arr);
+            gauss.Gauss(arr);
+
+        }*/
+
+
+
+}

Juzhen.java

@@ -0,0 +1,55 @@
+public class Juzhen {
+    double[][] a=new double [20][20];
+    int row;
+    int column;
+    Juzhen(int row,int column)
+    {
+        this.row=row;
+        this.column=column;
+    }
+    public int getRow() {
+        return row;
+    }
+
+    public void setRow(int row) {
+        this.row = row;
+    }
+
+    public int getColumn() {
+        return column;
+    }
+
+    public void setColumn(int column) {
+        this.column = column;
+    }
+
+//    public void Note(){
+//        System.out.println("This is my Matrix Class which max range is 20");
+//    }
+
+    public double[][] getA() {
+        return a;
+    }
+
+    public void setA(double[][] a) {
+        this.a = a;
+    }
+
+    public void show(){
+        for(int i=0;i<row;i++)
+            for(int j=0;j<column;j++)
+            {
+                System.out.printf("%f ",a[i][j]);
+                if(j==column-1) System.out.printf("\n");
+            }
+    }
+
+
+
+
+
+
+
+
+
+}

Main.java

@@ -0,0 +1,82 @@
+import java.util.Scanner;
+
+public class Main {
+    public static void main(String[] args) {
+        Scanner in=new Scanner(System.in);
+        System.out.println("矩阵计算器——加减乘");
+        while(true)
+        {
+            System.out.println("输入第一个行、列：(小于20，下同)");
+            int row=in.nextInt();
+            int column=in.nextInt();
+            System.out.println("输入第二个行、列：");
+            int row1=in.nextInt();
+            int column1=in.nextInt();
+            Juzhen m=new Juzhen(row,column);
+            Juzhen n=new Juzhen(row1,column1);
+            System.out.println("现在输入两个行、列小于20的矩阵：");
+            System.out.println("求幂默认选择第一个矩阵");
+            //TODO:System.out.println("高斯消元法默认选择第一个矩阵");
+            double[][] temp=new double[20][20];
+            for(int i=0;i<row;i++)
+                for(int j=0;j<column;j++)
+                {
+                    temp[i][j]=in.nextInt();
+                }
+            m.setA(temp);
+            System.out.println("矩阵A输入完毕");
+            double[][] temp1=new double[20][20];
+            for(int i=0;i<row1;i++)
+                for(int j=0;j<column1;j++)
+                {
+                    temp1[i][j]=in.nextInt();
+                }
+            n.setA(temp1);
+            System.out.println("矩阵B输入完毕");
+            System.out.println("选择功能：1加法，2减法，3乘法，4求幂，5消元(暂不可用)");
+            Calculator cr=new Calculator();
+            int ch=in.nextInt();
+            switch(ch)
+            {
+                case 1:
+                    double[][] result1=cr.plus(m,n);
+                    Juzhen r1=new Juzhen(row,column);
+                    r1.setA(result1);
+                    r1.show();
+                    break;
+                case 2:
+                    double[][] result2=cr.minus(m,n);
+                    Juzhen r2=new Juzhen(row,column);
+                    r2.setA(result2);
+                    r2.show();
+                    break;
+                case 3:
+                    double[][] result3=cr.multiply(m,n);
+                    Juzhen r3=new Juzhen(row,column1);
+                    r3.setA(result3);
+                    r3.show();
+                    break;
+                case 4:
+                    System.out.println("输入幂次");
+                    int p=in.nextInt();
+                    double[][] result4=cr.power(m,p);
+                    Juzhen r4=new Juzhen(row,column);
+                    r4.setA(result4);
+                    r4.show();
+                    break;
+                case 5:
+                    Gauss g=new Gauss();
+                    g.Leave(m.a,m.row,m.column);
+                    break;
+                default:
+                    System.out.println("输入无效");
+            }
+            System.out.println("退出按0，继续使用按其他任意字符");
+            int exit=in.nextInt();
+            if(exit==0) break;
+        }
+
+
+
+    }
+}

MatrixMine.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>