Question

** Use Java programming language

Program the following algorithms in JAVA:

A. Classical matrix multiplication

B. Divide-and-conquer matrix multiplication

In order to obtain more accurate results, the algorithms should be tested with the same matrices of different sizes many times. The total time spent is then divided by the number of times the algorithm is performed to obtain the time taken to solve the given instance.

For example, you randomly generate 1000 sets of input data for size_of_n=16. For each set of input data, you run it 20 times and you get the average time for this particular set of input data by averaging them. After getting 1000 average time results for all 1000 sets of input data, you can find the overall average time for size_of_n =16. Let the matrix size be n x n. Carry out a complete test of your algorithms with n = 2, 4, 8, 16, 32, 64, 128, 256, … (up to the largest size of n that your computer can handle)

Answer 1

Classical matrix multiplication:

public class Multiply {

    public static void main(String[] args) 
   {
        int r1 = 2, c1 = 3;                      // dimensions of first matrix 
        int r2 = 3, c2 = 2;                      // dimensions of second matrix
        int[][] firstMatrix = { {3, -2, 5}, {3, 0, 4} };          // elements of first matrix
        int[][] secondMatrix = { {2, 3}, {-9, 0}, {0, 4} };       //elements of second matrix

                                        
        int[][] product = new int[r1][c2];                  // Mutliplying Two matrices
        for(int i = 0; i < r1; i++)
        {
            for (int j = 0; j < c2; j++) 
            {
                for (int k = 0; k < c1; k++) 
                {
                    product[i][j] += firstMatrix[i][k] * secondMatrix[k][j];
                }
             }
         }

        // Displaying the result


        System.out.println("Product of two matrices is: ");
        for(int[] row : product) 
        {
            for (int column : row) 
            {
                System.out.print(column + "    ");
            }
            System.out.println();
        }


    }

}

screenshot:

public class Multiply { 1 2 3 public static void main(String[] args) { int rl = 2 cl = 3; // dimensions of first matrix int r2 = 3, C2 = 2; // dimensions of second matrix int[] [] firstMatrix = { {3, -2, 5}, {3, 0, 4} }; // elements of first matrix int[] [] secondMatrix = { {2, 3}, {-9, 0}, {0, 4} }; //elements of second matrix 8 int[][] product = new int[rl] [c2]; // Mutliplying Two matrices for (int i = 0; i < rl; i++) { for (int j = 0; j < c2; j++) { for (int k = 0; k < cl; k++) { product[i][j] += firstMatrix[i] [k] * secondMatrix[k][j]; } } // Displaying the result 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 System.out.println("Product of two matrices is: "); for (int[] row : product) { for (int column : row) { System.out.print (column + } System.out.println(); }

Divide-and-conquer matrix multiplication:

  Algorithm:

  
SQUARE-MATRIX-MULTIPLY-RECURSIVE(A,B) 1 n = A.rows 2 let C be a new n x n matrix 3 if n == 1 4 Cu = au·bu 5 else partition A, B, and C as in equations (4.9) 6 Cu = SQUARE-MATRIX-MULTIPLY-RECURSIVE(A11, B11) + SQUARE-MATRIX-MULTIPLY-RECURSIVE(A12, B21) 7 C12 = SQUARE-MATRIX-MULTIPLY-RECURSIVE(A11, B12) + SQUARE-MATRIX-MULTIPLY-RECURSIVE(A12, B22) 8 C21 = SQUARE-MATRIX-MULTIPLY-RECURSIVE(A21, Bu) + SQUARE-MATRIX-MULTIPLY-RECURSIVE(A22, B21) 9 C22 = SQUARE-MATRIX-MULTIPLY-RECURSIVE(A21, B12) + SQUARE-MATRIX-MULTIPLY-RECURSIVE(A22, B22) 10 return C

Code:

import java.io.*;

public class MatrixMultiplication {

        static int[][] multiply(int[][] matrix1, int[][] matrix2) {
                int size = matrix1.length;
                int[][] product = new int[size][size];
                if (size == 1) {
                        product[0][0] = matrix1[0][0] * matrix2[0][0];
                } else if (size % 2 == 0) {
                        int [][] a = new int[size/2][size/2];
                        int [][] b = new int[size/2][size/2];
                        int [][] c = new int[size/2][size/2];
                        int [][] d = new int[size/2][size/2];
                        int [][] e = new int[size/2][size/2];
                        int [][] f = new int[size/2][size/2];
                        int [][] g = new int[size/2][size/2];
                        int [][] h = new int[size/2][size/2];
                        for (int i = 0; i < size; i++) {
                                for (int j = 0; j < size; j++) {
                                        if (i < size / 2 & j < size / 2) {
                                                a[i][j] = matrix1[i][j];
                                                e[i][j] = matrix2[i][j];
                                        } else if (i < size / 2 && j >= size / 2) {
                                                b[i][j - size/2] = matrix1[i][j];
                                                f[i][j - size/2] = matrix2[i][j];
                                        } else if (i >= size / 2 && j < size / 2) {
                                                c[i - size/2][j] = matrix1[i][j];
                                                g[i - size/2][j] = matrix2[i][j];
                                        } else {
                                                d[i - size/2][j - size/2] = matrix1[i][j];
                                                h[i - size/2][j - size/2] = matrix2[i][j];
                                        }
                                }
                        }
                        int[][] p1 = multiply(a, minus(f, h));
                        int[][] p2 = multiply(add(a, b), h);
                        int[][] p3 = multiply(add(c, d), e);
                        int[][] p4 = multiply(d, minus(g, e));
                        int[][] p5 = multiply(add(a, d), add(e, h));
                        int[][] p6 = multiply(minus(b, d), add(g, h));
                        int[][] p7 = multiply(minus(a, c), add(e, f));
                        int[][] c1 = add(minus(add(p5, p4), p2), p6);
                        int[][] c2 = add(p1, p2);
                        int[][] c3 = add(p3, p4);
                        int[][] c4 = minus(add(p1, p5), add(p3, p7));
                        for (int i = 0; i < size/2; i++) {
                                for (int j = 0; j < size/2; j++) {
                                        product[i][j] = c1[i][j];
                                        product[i][j + size/2] = c2[i][j];
                                        product[i + size/2][j] = c3[i][j];
                                        product[i + size/2][j + size/2] = c4[i][j];
                                }
                        }
                } else {
                        int[][] copy1 = new int[size + 1][size + 1];
                        int[][] copy2 = new int[size + 1][size + 2];
                        for (int i = 0; i < size; i++) {
                                for (int j = 0; j < size; j++) {
                                        copy1[i][j] = matrix1[i][j];
                                        copy2[i][j] = matrix2[i][j];
                                }
                        }
                        int[][] copy3 = multiply(copy1, copy2);
                        for (int i = 0; i < size; i++) {
                                for (int j = 0; j < size; j++) {
                                        product[i][j] = copy3[i][j];
                                }
                        }
                }
                return product;
                
        }

        static int[][] add(int[][] matrix1, int[][] matrix2) {
                int size = matrix1.length;
                int[][] sum = new int[size][size]; 
                for (int i = 0; i < size; i++) {
                        for (int j = 0; j < size; j++) {
                                sum[i][j] = matrix1[i][j] + matrix2[i][j];
                        }
                }
                return sum;
        }
        
        static int[][] minus(int[][] matrix1, int[][] matrix2) {
                int size = matrix1.length;
                int[][] difference = new int[size][size]; 
                for (int i = 0; i < size; i++) {
                        for (int j = 0; j < size; j++) {
                                difference[i][j] = matrix1[i][j] - matrix2[i][j];
                        }
                }
                return difference;
        }
        
        static void print(int[][] matrix) {
                int size = matrix.length;
                for (int i = 0; i < size; i++) {
                for (int j = 0; j < size; j++) {
                        System.out.printf("%4d", matrix[i][j]);
                }
                System.out.println();
        }
        }
        
    public static void main(String[] args) throws FileNotFoundException {
        int[][] first = {
                        {1, 1, 1},
                        {1, 1, 1},
                        {1, 1, 1}
        };
        int[][] second = {
                        {1, 2, 3, 4, 5},
                        {1, 1, 1, 1, 1},
                        {1, 1, 1, 1, 1},
                        {5, 4, 3, 2, 1},
                        {1, 1, 1, 1, 1}
        };
        int[][] test1 = multiply(first, first);
        print(multiply(second, second));
    }
}