工程计算-矩阵范数

import org.ujmp.core.Matrix;

import java.util.Scanner;

/**
 * @author Janus
 * @creator 2020-03-11-9:59
 */
public class Norm {
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        int row=scanner.nextInt();
        int column=scanner.nextInt();
        double[][] matrix1=new double[row][column];
        InputMatrix(matrix1,scanner);
        System.out.printf("矩阵的F-范数: %+.6f\n",MatrixNormF(matrix1));
        System.out.printf("矩阵的1-范数: %+.6f\n",MatrixNorm1(matrix1));
        System.out.printf("矩阵的2-范数: %+.6f\n",MatrixNorm2(matrix1));
        System.out.printf("矩阵的∞-范数: %+.6f\n",MatrixNormInf(matrix1));
    }

    public static void InputMatrix(double[][] matrix, Scanner scanner){
        for(int i=0;i<matrix.length;++i){
            for(int j=0;j<matrix[0].length;++j){
                matrix[i][j]=scanner.nextDouble();
            }
        }
    }

    public static double Norm1(double[] vec) {
        double sum = 0.0;
        for (double temp : vec) {
            sum += Math.abs(temp);
        }
        return sum;
    }

    public static double Norm2(double[] vec) {
        double sum = 0.0;
        for (double temp : vec) {
            sum += temp * temp;
        }
        sum = Math.sqrt(sum);
        return sum;
    }

    public static double NormInf(double[] vec) {
        double maxValue = Double.MIN_VALUE;
        for (double temp : vec) {
            maxValue = Double.max(maxValue, temp);
        }
        return maxValue;
    }

    public static double NormP(double[] vec, double p) {
        if (p < 1) {
            System.err.printf("Err: P<1\n");
            return -1;
        }
        double sum = 0.0;
        for (double temp : vec) {
            sum += Math.pow(temp, p);
        }
        sum = Math.pow(sum, 1 / p);
        return sum;
    }

    public static double MatrixNorm1(double[][] matrix) {
        double maxValue=Double.MIN_VALUE;
        double sum;
        for (int i=0;i<matrix[0].length;++i){
            sum=0.0;
            for(int j=0;j<matrix.length;++j){
                sum+=Math.abs(matrix[j][i]);
            }
            maxValue=Double.max(maxValue,sum);
        }
        return maxValue;
    }
    public static double MatrixNorm2(double[][] matrix){
        Matrix dense=Matrix.Factory.zeros(matrix.length, matrix[0].length);
        for(int i=0;i<matrix.length;++i){
            for(int j=0;j<matrix[0].length;++j){
                dense.setAsDouble(matrix[i][j],i,j);
            }
        }
//        System.out.print(dense);
        Matrix[] eigenValueDecompostion = (dense.mtimes(dense.transpose())).eig();
        double[][] eigMatrix=eigenValueDecompostion[1].toDoubleArray();
        double maxEig=Double.MIN_VALUE;
        for(int i=0;i<matrix.length;++i){
            maxEig=Double.max(maxEig,eigMatrix[i][i]);
        }

        return Math.sqrt(maxEig);
    }
    public static double MatrixNormInf(double[][] matrix){
        double maxValue = Double.MIN_VALUE;
        for (double[] temp : matrix) {
            maxValue = Double.max(maxValue, Norm1(temp));
        }
        return maxValue;
    }
    public static double MatrixNormF(double[][] matrix){
        double sum=0.0;
        for(double[] temp1:matrix){
            for(double temp2:temp1){
                sum+=Math.pow(temp2,2);
            }
        }
        return Math.sqrt(sum);
    }
}