Question

HELP PLZ:

USE JAVA:

Make a matrix in java so that every operation uses as many thread as there are elements in the output matrix. The point of this project is parallel programming.

Answer 1

package parallelmatrix;
import java.util.*;
import java.util.concurrent.*;

public class PMatrix
{
public static void main (String arg[]) throws Exception
{
int dataA[][] = new int[][]
{
{1, 2,5},
{3, 4,6},
{8, 9,10}
};
  
int dataB[][] = new int[][]
{
{1, 2, 3},
{4, 5, 6},
{5, 8, 7}
};
  
ExecutorService executor = Executors.newFixedThreadPool(3);
  
Matrix Amat = new Matrix (dataA);
Matrix Bmat = new Matrix (dataB);
System.out.println(Amat.multiply(Bmat));
  
executor.shutdown();
}

static class Matrix
{
private static final int THREAD_COUNT = 3;
  
private int rCount, cCount, data[][];
  
public Matrix (int data[][])
{
this.data = data;
this.rCount = data.length;
this.cCount = data[0].length;
}
  
public Matrix multiply (Matrix m)
{
ExecutorService executor = Executors.newFixedThreadPool(THREAD_COUNT);
  
try
{
if (this.cCount != m.rCount)
throw new IllegalArgumentException ("Matrix col count does not match argument's row count. cCount=" + this.cCount + " rCount=" + m.rCount);

List<Task> listFrag = Matrix.getTasks(this, m);
List<Future<Integer>> listResult = executor.invokeAll(listFrag);

int data[][] = new int [this.rCount][m.cCount];
for (int i = 0; i < this.rCount; ++i)
for (int j = 0; j < m.cCount; ++j)
data[i][j] = listResult.get(i*m.cCount + j).get();

return new Matrix (data);
}
catch (Exception e)
{
executor.shutdown();
}
return null;
}
  
public static List<Task> getTasks (Matrix Amat, Matrix Bmat)
{
List<Task> listFrag = new ArrayList<> ();
for (int i = 0; i < Amat.rCount; ++i)
for (int j = 0; j < Bmat.cCount; ++j)
listFrag.add(new Task (Amat, Bmat, i, j));
return listFrag;
}
  
public String toString ()
{
StringBuilder builder = new StringBuilder ();
for (int i = 0; i < rCount; ++i)
{
for (int j = 0; j < cCount; ++j)
builder.append(String.format(" %3d ", data[i][j]));
builder.append("\n");
};
return builder.toString();
}
}
  
static class Task implements Callable<Integer>
{
int rowId, colId;
  
Matrix Amat, Bmat;
  
public Task (Matrix Amat, Matrix Bmat, int rowId, int colId)
{
this.rowId = rowId;
this.colId = colId;
this.Amat = Amat;
this.Bmat = Bmat;
}

@Override
public Integer call() throws Exception
{
String mesg = String.format("A[%d] * B[%d]", rowId, colId);
System.out.println("Started Task "+mesg);
int product = 0;
for (int i = 0; i < Amat.cCount; ++i)
product = product + Amat.data[rowId][i] * Bmat.data[i][colId];
System.out.println("Finished Task. " + mesg + " = " + product);
return product;
}
  
}
}

*************OUTPUT

Started Task A[0] * B[2]
Started Task A[0] * B[0]
Started Task A[0] * B[1]
Finished Task. A[0] * B[1] = 52
Finished Task. A[0] * B[0] = 34
Started Task A[1] * B[0]
Finished Task. A[1] * B[0] = 49
Started Task A[1] * B[2]
Finished Task. A[1] * B[2] = 75
Started Task A[1] * B[1]
Finished Task. A[0] * B[2] = 50
Finished Task. A[1] * B[1] = 74
Started Task A[2] * B[1]
Finished Task. A[2] * B[1] = 141
Started Task A[2] * B[0]
Finished Task. A[2] * B[0] = 94
Started Task A[2] * B[2]
Finished Task. A[2] * B[2] = 148
34 52 50
49 74 75
94 141 148