MAKE THE FOLLOWING PROGRAM PARALLEL IN JAVA LANGUAGE..... (*******make it so tha

Question

MAKE THE FOLLOWING PROGRAM PARALLEL IN JAVA LANGUAGE.....

(*******make it so that every operation uses as many thread as there are elements in the output matrix.******)

import java.util.Random;

final public class Matrix
{
private final int numberOfRows;
private final int numberOfColumns;
private final int [][] myElements;

//populate
void populate()
{
Random rand= new Random();
for (int i=0; i< numberOfRows; i+=1)
{
for (int j=0; j< numberOfColumns; j+=1)
{
myElements [i][j]= rand.nextInt(9)+1;
}
}
}

// Constructor numberOfRows, numberOfColumns matrix of 0
public Matrix(int numberOfRows, int numberOfColumns)
{
this.numberOfRows=numberOfRows;
   this.numberOfColumns=numberOfColumns;
myElements= new int [numberOfRows][numberOfColumns];
}

//creating matrix based on double array
Matrix (int [][] myElements)
{
numberOfRows= myElements.length;
numberOfColumns=myElements[0].length;
this.myElements= myElements.clone();

}

private Matrix(Matrix One)
{
this(One.myElements);
}

//Extra since I populate it in the beginning first, but thought I should leave it for you to look at
public static Matrix random(int numberOfRows, int numberOfColumns)
{
  
Random rand = new Random();
Matrix Matrix(numberOfRows, numberOfColumns);
for (int i=0; i< numberOfRows;i+= 1)
for (int j=0; j< numberOfColumns; j+=1)
One.myElements[i][j]= rand.nextInt(9)+1 ;
return One;
}

//identity Matrix
public static Matrix theIdentity(int numberOfColumns)
{
Matrix Two= new Matrix(numberOfColumns,numberOfColumns);
for (int i=0; i Two.myElements[i][i] = 1;
return Two;
}

   //swapping rows between i and j
private void nowSwap(int i, int j)
{
int[] tempory= myElements[i];
myElements[i]= myElements[j];
myElements[j]=tempory;

}

//make and retun
public Matrix trans()
{
Matrix Matrix(numberOfRows,numberOfColumns);
for (int i=0; i< numberOfRows; i+=1)
for(int j=0; j< numberOfColumns; j+=1)
One.myElements[j][i]=this.myElements[i][j];
return One;
}

//Matrix plus A+B=c

public Matrix Plus(Matrix B)
{
Matrix A= this;
if(B.numberOfRows != A.numberOfRows || B.numberOfColumns != A.numberOfColumns) throw new RuntimeException ("Illegal Matrix");
Matrix C= new Matrix (numberOfRows, numberOfColumns);
for (int i= 0; i for (int j=0; j< numberOfColumns; j+=1)
C.myElements[i][j]= A.myElements[i][j] + B.myElements[i][j];
return C;
}

// Matrix Subtraction A-B=C
public Matrix Minus(Matrix B)
{
Matrix A= this;
if (B.numberOfRows != A.numberOfColumns || B.numberOfColumns != A.numberOfRows) throw new RuntimeException ("Illegal matrix");
Matrix C= new Matrix (numberOfRows, numberOfColumns);
for (int i=0; i< numberOfRows; i+=1)
for (int j=0; j< numberOfColumns; j+=1)
C.myElements[i][j]= A.myElements[i][j] - B.myElements [i][j];
return C;
}

//Matrix multiplication C= A*B
public Matrix Multiplication(Matrix B)
{
Matrix A= this;
if (A.numberOfColumns != B.numberOfRows) throw new RuntimeException ("Illegal Matrix");
Matrix C= new Matrix (A.numberOfRows, B.numberOfColumns);
for(int i=0; i < C.numberOfRows; i+=1)
for (int j=0; j < C.numberOfColumns; j+=1)
for(int k=0; k < A.numberOfColumns; k+=1)
C.myElements [i][j] += (A.myElements [i][k] * B.myElements [k][j]);
return C;
}

//A=B !???
public boolean equalsOrNot(Matrix B)
{
Matrix A= this;
if (B.numberOfRows != A.numberOfRows || B.numberOfColumns != A.numberOfColumns) throw new RuntimeException ("Illegal Matrix");
   for (int i=0; i < numberOfRows; i+=1)
for (int j=0; j < numberOfColumns; j+=1)
if (A.myElements [i][j] != B.myElements [i][j]) return false;
return true;
}

// When A is squared
public Matrix sqMhs (Matrix mhs)
{
if(numberOfRows != numberOfColumns || mhs.numberOfRows != mhs.numberOfColumns || mhs.numberOfColumns ==1)
throw new RuntimeException ("Illegal matrix");

// creating copies
Matrix A= new Matrix (this);
Matrix M= new Matrix(mhs);

//eliminating with partial pivotting

for (int i=0; i < numberOfColumns; i+=1)
{
int maximum= i; //will swap when pivot in row is found
for (int j= i + 1; j< numberOfColumns; j+=1)
{
if (Math.abs(A.myElements[j][i]) > Math.abs(A.myElements[maximum][i]))
maximum= j;
A.nowSwap(i, maximum);
M.nowSwap(i, maximum);
if (A.myElements[i][j] == 0) throw new RuntimeException ("Singular Matrix!");
}
for (int j= i + 1; j < numberOfColumns; j+=1)
M.myElements[j][0] -= M.myElements[i][0] * A.myElements[j][i] / A.myElements[i][i];

//pivot with A
for (int j= i + 1; j < numberOfColumns; j+=1)
{
int mn = A.myElements[j][i] / A.myElements[i][i];
for (int k= i+1; k < numberOfColumns; k+=1)
{
A.myElements[j][k] -= A.myElements[i][k] * mn;
}
A.myElements[j][i]= 0;

}
}
//substitute

Matrix r= new Matrix(numberOfColumns, 1);
for (int j= numberOfColumns - 1; j >= 0; j--)
{
int t= 0;
for (int k = j +1; k < numberOfColumns; k++)
t += A.myElements[j][k] * r.myElements[k][0];
r.myElements[j][0] = (M.myElements[j][0] - t) / A.myElements[j][j];
}
return r;

}
public void show(){
for(int i=0;i for(int j=0;j System.out.print(this.myElements[i][j]+" ");
}
System.out.println();
}
}


/**********************************************************************/

//Main and test cases

public static void main(String args[])
{
int [][] integer= { {1,2,3 }, {4,5,6 }, {9,1,3}};
Matrix L = new Matrix (integer);
L.show();
System.out.println();

Matrix A= Matrix.random(5, 5);
A.show();
System.out.println();

A.nowSwap (1, 2);
A.show();
System.out.println();

Matrix B= A.trans();
B.show();
System.out.println();

Matrix C= Matrix.theIdentity(5);
C.show();
System.out.println();

A.Plus(B).show();
System.out.println();

B.Multiplication(A).show();
System.out.println();
System.out.println(A.Multiplication(B).equals(B.Multiplication(A)));
System.out.println();

Matrix M= Matrix.random(5, 1);
M.show();
System.out.println();

A.Multiplication(C).show();

}

}// End Matrix

Explanation / Answer

public class MatrixParallel22 extends Thread{ final static int noThreads = 2 ; public static void main(String args[]) throws Exception{ //get the start time long startTime = System.currentTimeMillis(); MatrixParallel [] threads = new MatrixParallel [noThreads] ; for(int me = 0 ; me

Related Questions

Navigate

• Browse (All)
• Browse M
• Subjects

---

---

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.