Homework_line_algebra

public class Main {
    public static void main(String[] args){
        int[][] firstMatrix = {{5},{8},{9}};
        int[][] secondMatrix = {{2,3,4}};
        int[][] thirdMatrix = {{2,3,5},{7,8,11}};
        int[][] forthMatrix = {{6,7,4},{5,8,1}};

        show2DArray(thirdMatrix);
        System.out.println("=====================");
        show2DArray(forthMatrix);

        System.out.println("=====================");
        show2DArray(twoMatrixesMultiplication(firstMatrix, secondMatrix));
        System.out.println("=====================");
        show2DArray(twoMatrixesAddition(thirdMatrix,forthMatrix));
        System.out.println("=====================");
        show2DArray(matrixAndIntMultiplication(thirdMatrix,-1));
        System.out.println("=====================");
        show2DArray(twoMatrixesSubtraction(thirdMatrix,forthMatrix));
    }

    public static boolean isMultiplicationPossible(int[][] firstMatrix, int[][] secondMatrix){
        if(firstMatrix[0].length==secondMatrix.length){
            return true;
        }
        return false;
    }

    //умножение двух матриц
    public static int[][] twoMatrixesMultiplication(int[][] firstMatrix, int[][] secondMatrix){
        int[][] multiplicatedResult;
        int[][] buffer=transposition(secondMatrix);
        if(isMultiplicationPossible(firstMatrix, secondMatrix)){
            multiplicatedResult=new int[firstMatrix.length][secondMatrix[0].length];
            for(int i=0;i<multiplicatedResult.length;i++){
                for(int j=0;j<multiplicatedResult[0].length;j++){
                    multiplicatedResult[i][j]=sumOfTwoArrays(firstMatrix[i], buffer[j]);
                }
            }
            return multiplicatedResult;
        }
        else{
            multiplicatedResult=new int[0][0];
            System.out.println("Охрана отмена, умножать нельзя");
            return multiplicatedResult;
        }
    }

    //умножение матрицы на число
    public static int[][] matrixAndIntMultiplication(int[][] matrix, int num){
        int[][] multiplicatedResult = new int[matrix.length][matrix[0].length];
        for(int i=0;i<matrix.length;i++){
            for(int j=0;j<matrix[0].length;j++){
                multiplicatedResult[i][j]=matrix[i][j]*num;
            }
        }
        return multiplicatedResult;
    }

    public static boolean isAdditionPossible(int[][] firstMatrix, int[][] secondMatrix){
        if(firstMatrix.length==secondMatrix.length && firstMatrix[0].length==secondMatrix[0].length){
            return true;
        }
        return false;
    }

    //сложение двух матриц
    public static int[][] twoMatrixesAddition(int[][] firstMatrix, int[][] secondMatrix){
        int[][] sumOfTwoMatrixes;
        if(isAdditionPossible(firstMatrix,secondMatrix)){
            sumOfTwoMatrixes = new int[firstMatrix.length][firstMatrix[0].length];
            for(int i=0;i<firstMatrix.length;i++){
                for(int j=0;j<firstMatrix[0].length;j++){
                    sumOfTwoMatrixes[i][j]=firstMatrix[i][j]+secondMatrix[i][j];
                }
            }
            return sumOfTwoMatrixes;
        }
        else {
            System.out.println("Охрана отмена, складывать нельзя");
            sumOfTwoMatrixes = new int[0][0];
            return sumOfTwoMatrixes;
        }
    }

    public static int sumOfTwoArrays(int[] row, int[] column){
        int sum=0;
        for(int i=0;i<row.length;i++){
            sum+=row[i]*column[i];
        }
        return sum;
    }

    //вычитание двух матриц
    public static int[][] twoMatrixesSubtraction(int[][] firstMatrix, int[][] secondMatrix){
        return twoMatrixesAddition(firstMatrix, matrixAndIntMultiplication(secondMatrix,-1));
    }

    //транспонирование
    public static int[][] transposition(int[][] toTranspond){
        int[][] transponded=new int[toTranspond[0].length][toTranspond.length];
        for(int i=0;i<toTranspond.length;i++){
            for(int j=0;j<toTranspond[0].length;j++){
                transponded[j][i]=toTranspond[i][j];
            }
        }
        return transponded;
    }

    //вывод матрицы
    public static void show2DArray(int[][] array){
        for(int i=0;i<array.length;i++){
            for(int j=0;j<array[0].length;j++){
                System.out.print(array[i][j]+" ");
            }
            System.out.println();
        }
    }
}