Java Implementation Need ASAP .......PLS /** * A Matrix has two dimensions: rows
ID: 3753591 • Letter: J
Question
Java Implementation Need ASAP .......PLS
/**
*
A Matrix has two dimensions: rows and columns. Each cell in the matrix
* stores an integer value, and it can be uniquely identified via
* a row number and a column number.
* Row numbers start with 0 and column numbers start with 0.
*
For simplicity, you can assume that all row and column numbers passed by
* users are valid.
*/
public class Matrix {
/*
* You must use this attribute 'imp' to implement
* the various methods of the Matrix class.
* Do not change any parts of this attribute declaration.
*/
int[][] imp;
/**
*
Initialize a 1-by-1 matrix with default values.
*
See TestMatrix class for how this method can be used.
*/
public Matrix() {
imp = new int[1][1];
}
/**
*
Initialize a 'nor'-by-'noc' matrix, where each cell
*
See TestMatrix class for how this method can be used.
* stores the default integer value 0.
* @param nor Number of rows
* @param noc Number of columns
*/
public Matrix(int nor, int noc) {
/* Your Task */
}
/**
*
Initialize a 'nor'-by-'noc' matrix, where each cell
*
See TestMatrix class for how this method can be used.
* stores the default integer value 'v'.
* @param nor Number of rows
* @param noc Number of columns
* @param v Default value for each cell
*/
public Matrix(int nor, int noc, int v) {
/* Your Task */
}
/**
*
Get the number of rows in this matrix.
*
See TestMatrix class for how this method can be used.
* @return Number of rows
*/
public int getNumberOfRows() {
/* Your Task */
return 0;
}
/**
*
Get the number of columns in this matrix.
*
See TestMatrix class for how this method can be used.
* @return Number of columns
*/
public int getNumberOfColumns() {
/* Your Task */
return 0;
}
/**
*
Get the value stored at cell ('r', 'c').
*
You can assume that 'r' and 'c' are valid - no error checking is needed.
*
See TestMatrix class for how this method can be used.
* @param r Row number
* @param c Column number
* @return Value stored at cell ('r', 'c')
*/
public int get(int r, int c) {
/* Your Task */
return 0;
}
/**
*
Store value 'v' in cell ('r', 'c').
*
You can assume that 'r' and 'c' are valid - no error checking is needed.
*
See TestMatrix class for how this method can be used.
* @param r Row number
* @param c Column number
* @param v Value to be stored
*/
public void set(int r, int c, int v) {
/* Your Task */
}
/**
*
Replace values of row 'r' by a the new row 'nr'.
*
You can assume the length of 'nr' equals the number of columns of this matrix -
* no error checking is needed for this.
*
See TestMatrix class for how this method can be used.
* @param r Row number
* @param nr A new row (as an array of integers)
*/
public void setRow(int r, int[] nr) {
/* Your Task */
}
/**
*
Replace values of column 'c' by a the new column 'nc'.
*
You can assume the length of 'nc' equals the number of rows of this matrix -
* no error checking is needed for this.
*
See TestMatrix class for how this method can be used.
* @param c Column number
* @param nc A new column (as an array of integers)
*/
public void setColumn(int c, int[] nc) {
/* Your Task */
}
/**
*
Return a copy of contents stored in row 'r'.
*
You can assume that 'r' is valid - no error checking is needed.
*
See TestMatrix class for how this method can be used.
* @param r Row number
* @return A new array whose contents correspond to those of row 'r'.
*/
public int[] getRow(int r) {
/* Your Task */
return null;
}
/**
*
Return a copy of contents stored in column 'c'.
*
You can assume that 'c' is valid - no error checking is needed.
*
See TestMatrix class for how this method can be used.
* @param c Column number
* @return A new array whose contents correspond to those of column 'c'.
*/
public int[] getColumn(int c) {
/* Your Task */
return null;
}
/**
*
Rotate the matrix by 90 degrees.
*
The old 1st row becomes the new last column,
* the old 2nd row becomes the new 2nd last column, and so on.
*
Hint: attribute 'imp' should be reassigned to a new matrix.
*
See TestMatrix class for how this method can be used.
*/
public void rotateClockwise() {
/* Your Task */
}
/**
*
Shift this matrix to the left by one column.
*
The old 2nd column becomes the new 1st column,
* the old 3rd column becomes the new 2nd column, ...,
* the old 1st column becomes the new last column.
*
See TestMatrix class for how this method can be used.
*/
public void shiftLeft() {
/* Your Task */
}
/**
*
Shift this matrix up by one row.
*
The old 2nd row becomes the new 1st row,
* the old 3rd row becomes the new 2nd row, ...,
* the old 1st row becomes the new last row.
*
See TestMatrix class for how this method can be used.
*/
public void shiftUp() {
/* Your Task */
}
}
***********************************BELOW IS THE TEST CLASS***************************************************************************
***********************************BELOW IS THE TEST CLASS***************************************************************************
import static org.junit.Assert.*;
import java.util.Arrays;
import org.junit.FixMethodOrder;
import org.junit.Test;
import org.junit.runners.MethodSorters;
@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class TestMatrix {
@Test
public void test01_MatrixConstructor_1() {
Matrix m = new Matrix();
assertEquals("1 row 2D array", 1, m.imp.length);
assertEquals("1 column 2D array", 1, m.imp[0].length);
}
@Test
public void test02_MatrixConstructor_2() {
Matrix m = new Matrix(3, 4);
assertEquals("3 row 2D array", 3, m.imp.length);
for(int r = 0; r < 3; r ++) {
assertEquals("4 columns on row " + r + " in 2D array", 4, m.imp[r].length);
}
}
@Test
public void test03_MatrixConstructor_3() {
Matrix m = new Matrix(3, 4, 5);
assertEquals("3 row 2D array", 3, m.imp.length);
for(int r = 0; r < 3; r ++) {
assertEquals("4 columns on row " + r + " in 2D array", 4, m.imp[r].length);
for(int c = 0; c < 4; c ++) {
assertEquals("wrong value on cell (" + r + ", " + c + ") in 2D array", 5, m.imp[r][c]);
assertEquals("wrong value on cell (" + r + ", " + c + ") in matrix", 5, m.get(r, c));
}
}
}
@Test
public void test04_getNumberOfRows() {
Matrix m = new Matrix();
assertEquals("1 row matrix", 1, m.getNumberOfRows());
}
@Test
public void test05_getNumberOfRows() {
Matrix m = new Matrix(3, 4);
assertEquals("3 row matrix", 3, m.getNumberOfRows());
}
@Test
public void test06_getNumberOfRows() {
Matrix m = new Matrix(3, 4, 5);
assertEquals("3 row matrix", 3, m.getNumberOfRows());
}
@Test
public void test07_getNumberOfColumns() {
Matrix m = new Matrix();
assertEquals("1 column matrix", 1, m.getNumberOfColumns());
}
@Test
public void test08_getNumberOfColumns() {
Matrix m = new Matrix(3, 4);
assertEquals("4 column matrix", 4, m.getNumberOfColumns());
}
@Test
public void test09_getNumberOfColumns() {
Matrix m = new Matrix(3, 4, 5);
assertEquals("4 column matrix", 4, m.getNumberOfColumns());
}
@Test
public void test10_get() {
Matrix m = new Matrix();
m.imp = new int[4][2];
for (int c = 0; c < 2; c++) {
for (int r = 0; r < 4; r++) {
m.imp[r][c] = (r + 1) * (c + 1);
}
}
for (int c = 0; c < 2; c++) {
for (int r = 0; r < 4; r++) {
int exp = (r + 1) * (c + 1);
String err = String.format("get(%d, %d) failed ", r, c);
assertEquals(err, exp, m.get(r, c));
}
}
}
@Test
public void test11_set() {
Matrix m = new Matrix();
m.imp = new int[4][2];
for (int c = 0; c < 2; c++) {
for (int r = 0; r < 4; r++) {
m.set(r, c, (r + 10) * (c - 100));
}
}
for (int c = 0; c < 2; c++) {
for (int r = 0; r < 4; r++) {
int exp = (r + 10) * (c - 100);
String err = String.format("set(%d, %d, %d) failed ", r, c, exp);
assertEquals(err, exp, m.imp[r][c]);
}
}
}
@Test
public void test12_GetRow() {
Matrix m = new Matrix(3, 4);
int[] row0 = {13, 4 , 7 , 10};
int[] row1 = {2 , 14, 8 , 11};
int[] row2 = {3 , 6 , 15, 12};
m.imp[0] = Arrays.copyOf(row0, 4);
m.imp[1] = Arrays.copyOf(row1, 4);
m.imp[2] = Arrays.copyOf(row2, 4);
assertTrue("getRow should return a new array", m.getRow(0) != m.imp[0]);
assertTrue("getRow should return a new array", m.getRow(1) != m.imp[1]);
assertTrue("getRow should return a new array", m.getRow(2) != m.imp[2]);
assertArrayEquals("getRow returned the wrong array ", row0, m.getRow(0));
assertArrayEquals("getRow returned the wrong array ", row1, m.getRow(1));
assertArrayEquals("getRow returned the wrong array ", row2, m.getRow(2));
}
@Test
public void test13_GetColumn() {
Matrix m = new Matrix(3, 4);
int[] nr0 = {13 , 2 , 3 , 4 };
int[] nr1 = {5 , 14 , 7 , 8 };
int[] nr2 = {9 , 10, 15, 12};
m.imp[0] = Arrays.copyOf(nr0, 4);
m.imp[1] = Arrays.copyOf(nr1, 4);
m.imp[2] = Arrays.copyOf(nr2, 4);
int[] col0 = {13, 5 , 9 };
int[] col1 = {2 , 14, 10};
int[] col2 = {3 , 7 , 15};
int[] col3 = {4 , 8 , 12};
assertArrayEquals("getColumn returned the wrong array ", col0, m.getColumn(0));
assertArrayEquals("getColumn returned the wrong array ", col1, m.getColumn(1));
assertArrayEquals("getColumn returned the wrong array ", col2, m.getColumn(2));
assertArrayEquals("getColumn returned the wrong array ", col3, m.getColumn(3));
}
@Test
public void test14_setRow() {
Matrix m = new Matrix();
int[] q = {99};
m.setRow(0, q);
assertNotSame("setRow should copy elements into the matrix",
m.imp[0], q);
assertEquals("setRow failed to set the elements of row 0 correctly",
99, m.imp[0][0]);
}
@Test
public void test15_setRow() {
Matrix m = new Matrix(3, 4);
int[] nr0 = {13 , 2 , 3 , 4 };
int[] nr1 = {5 , 14 , 7 , 8 };
int[] nr2 = {9 , 10, 15, 12};
m.imp[0] = Arrays.copyOf(nr0, 4);
m.imp[1] = Arrays.copyOf(nr1, 4);
m.imp[2] = Arrays.copyOf(nr2, 4);
int[] q = {100, 99, 98, -1};
for (int r = 0; r < 3; r++) {
m.setRow(r, q);
assertNotSame("setRow should copy elements into the matrix",
m.imp[r], q);
assertArrayEquals(q, m.imp[r]);
}
}
@Test
public void test16_setColumn() {
Matrix m = new Matrix();
int[] q = {99};
m.setColumn(0, q);
assertNotSame("setColumn should copy elements into the matrix",
m.imp[0], q);
assertEquals("setColumn failed to set the elements of column 0 correctly",
99, m.imp[0][0]);
}
@Test
public void test17_setColumn() {
Matrix m = new Matrix(3, 4);
int[] nr0 = {13 , 2 , 3 , 4 };
int[] nr1 = {5 , 14 , 7 , 8 };
int[] nr2 = {9 , 10, 15, 12};
m.imp[0] = Arrays.copyOf(nr0, 4);
m.imp[1] = Arrays.copyOf(nr1, 4);
m.imp[2] = Arrays.copyOf(nr2, 4);
int[] q = {100, 99, -1};
for (int c = 0; c < 4; c++) {
int[] exp = {q[0], q[1], q[2]};
m.setColumn(c, q);
int[] theCol = {m.imp[0][c], m.imp[1][c], m.imp[2][c]};
assertArrayEquals("setColumn failed to set the elements of a column correctly",
exp, theCol);
}
}
@Test
public void test18_RotateClockwise() {
Matrix m1 = new Matrix(3, 4);
int[] nr0 = {1 , 2 , 3 , 4 };
int[] nr1 = {5 , 6 , 7 , 8 };
int[] nr2 = {9 , 10, 11, 12};
m1.setRow(0, nr0);
m1.setRow(1, nr1);
m1.setRow(2, nr2);
int[] nc0 = {9, 10, 11, 12};
int[] nc1 = {5, 6 , 7 , 8 };
int[] nc2 = {1, 2 , 3 , 4 };
int[] nr0_ = {12, 11 , 10 , 9 };
int[] nr1_ = {8 , 7 , 6 , 5 };
int[] nr2_ = {4 , 3 , 2 , 1 };
m1.rotateClockwise();
assertArrayEquals(nc0, m1.getColumn(0));
assertArrayEquals(nc1, m1.getColumn(1));
assertArrayEquals(nc2, m1.getColumn(2));
m1.rotateClockwise();
assertArrayEquals(nr0_, m1.getRow(0));
assertArrayEquals(nr1_, m1.getRow(1));
assertArrayEquals(nr2_, m1.getRow(2));
}
@Test
public void test19_ShiftLeft() {
Matrix m1 = new Matrix(3, 4);
int[] nr0 = {1 , 2 , 3 , 4 };
int[] nr1 = {5 , 6 , 7 , 8 };
int[] nr2 = {9 , 10, 11, 12};
m1.setRow(0, nr0);
m1.setRow(1, nr1);
m1.setRow(2, nr2);
int[] nr0_ = {2 , 3 , 4 , 1};
int[] nr1_ = {6 , 7 , 8 , 5};
int[] nr2_ = {10, 11, 12, 9};
int[] nr0__ = {3 , 4 , 1, 2 };
int[] nr1__ = {7 , 8 , 5, 6 };
int[] nr2__ = {11, 12, 9, 10};
m1.shiftLeft();
assertArrayEquals(nr0_, m1.imp[0]);
assertArrayEquals(nr1_, m1.imp[1]);
assertArrayEquals(nr2_, m1.imp[2]);
assertArrayEquals(nr0_, m1.getRow(0));
assertArrayEquals(nr1_, m1.getRow(1));
assertArrayEquals(nr2_, m1.getRow(2));
m1.shiftLeft();
assertArrayEquals(nr0__, m1.imp[0]);
assertArrayEquals(nr1__, m1.imp[1]);
assertArrayEquals(nr2__, m1.imp[2]);
assertArrayEquals(nr0__, m1.getRow(0));
assertArrayEquals(nr1__, m1.getRow(1));
assertArrayEquals(nr2__, m1.getRow(2));
}
@Test
public void test20_ShiftUp() {
Matrix m1 = new Matrix(3, 4);
int[] nr0 = {1 , 2 , 3 , 4 };
int[] nr1 = {5 , 6 , 7 , 8 };
int[] nr2 = {9 , 10, 11, 12};
m1.setRow(0, nr0);
m1.setRow(1, nr1);
m1.setRow(2, nr2);
m1.shiftUp();
assertArrayEquals(nr1, m1.imp[0]);
assertArrayEquals(nr2, m1.imp[1]);
assertArrayEquals(nr0, m1.imp[2]);
assertArrayEquals(nr1, m1.getRow(0));
assertArrayEquals(nr2, m1.getRow(1));
assertArrayEquals(nr0, m1.getRow(2));
m1.shiftUp();
assertArrayEquals(nr2, m1.imp[0]);
assertArrayEquals(nr0, m1.imp[1]);
assertArrayEquals(nr1, m1.imp[2]);
assertArrayEquals(nr2, m1.getRow(0));
assertArrayEquals(nr0, m1.getRow(1));
assertArrayEquals(nr1, m1.getRow(2));
}
}
Explanation / Answer
Please find the code below of Matrix.java.
Matrix.java
**************************
/**
*
A Matrix has two dimensions: rows and columns. Each cell in the matrix
* stores an integer value, and it can be uniquely identified via
* a row number and a column number.
* Row numbers start with 0 and column numbers start with 0.
*
For simplicity, you can assume that all row and column numbers passed by
* users are valid.
*/
public class Matrix {
/*
* You must use this attribute 'imp' to implement
* the various methods of the Matrix class.
* Do not change any parts of this attribute declaration.
*/
int[][] imp;
/**
*
Initialize a 1-by-1 matrix with default values.
*
See TestMatrix class for how this method can be used.
*/
public Matrix() {
imp = new int[1][1];
}
/**
*
Initialize a 'nor'-by-'noc' matrix, where each cell
*
See TestMatrix class for how this method can be used.
* stores the default integer value 0.
* @param nor Number of rows
* @param noc Number of columns
*/
public Matrix(int nor, int noc) {
imp = new int[nor][noc];
}
/**
*
Initialize a 'nor'-by-'noc' matrix, where each cell
*
See TestMatrix class for how this method can be used.
* stores the default integer value 'v'.
* @param nor Number of rows
* @param noc Number of columns
* @param v Default value for each cell
*/
public Matrix(int nor, int noc, int v) {
imp = new int[nor][noc];
for(int i=0; i<nor; i++) {
for(int j=0; j<noc; j++) {
imp[i][j] = v;
}
}
}
/**
*
Get the number of rows in this matrix.
*
See TestMatrix class for how this method can be used.
* @return Number of rows
*/
public int getNumberOfRows() {
return imp.length;
}
/**
*
Get the number of columns in this matrix.
*
See TestMatrix class for how this method can be used.
* @return Number of columns
*/
public int getNumberOfColumns() {
return imp[0].length;
}
/**
*
Get the value stored at cell ('r', 'c').
*
You can assume that 'r' and 'c' are valid - no error checking is needed.
*
See TestMatrix class for how this method can be used.
* @param r Row number
* @param c Column number
* @return Value stored at cell ('r', 'c')
*/
public int get(int r, int c) {
return imp[r][c];
}
/**
*
Store value 'v' in cell ('r', 'c').
*
You can assume that 'r' and 'c' are valid - no error checking is needed.
*
See TestMatrix class for how this method can be used.
* @param r Row number
* @param c Column number
* @param v Value to be stored
*/
public void set(int r, int c, int v) {
imp[r][c] = v;
}
/**
*
Replace values of row 'r' by a the new row 'nr'.
*
You can assume the length of 'nr' equals the number of columns of this matrix -
* no error checking is needed for this.
*
See TestMatrix class for how this method can be used.
* @param r Row number
* @param nr A new row (as an array of integers)
*/
public void setRow(int r, int[] nr) {
for (int i=0; i<nr.length; i++) {
imp[r][i] = nr[i];
}
}
/**
*
Replace values of column 'c' by a the new column 'nc'.
*
You can assume the length of 'nc' equals the number of rows of this matrix -
* no error checking is needed for this.
*
See TestMatrix class for how this method can be used.
* @param c Column number
* @param nc A new column (as an array of integers)
*/
public void setColumn(int c, int[] nc) {
for (int i=0; i<nc.length; i++) {
imp[i][c] = nc[i];
}
}
/**
*
Return a copy of contents stored in row 'r'.
*
You can assume that 'r' is valid - no error checking is needed.
*
See TestMatrix class for how this method can be used.
* @param r Row number
* @return A new array whose contents correspond to those of row 'r'.
*/
public int[] getRow(int r) {
int res[] = new int[imp[0].length];
for(int i=0; i<imp[0].length; i++) {
res[i] = imp[r][i];
}
return res;
}
/**
*
Return a copy of contents stored in column 'c'.
*
You can assume that 'c' is valid - no error checking is needed.
*
See TestMatrix class for how this method can be used.
* @param c Column number
* @return A new array whose contents correspond to those of column 'c'.
*/
public int[] getColumn(int c) {
int res[] = new int[imp.length];
for(int i=0; i<imp.length; i++) {
res[i] = imp[i][c];
}
return res;
}
/**
*
Rotate the matrix by 90 degrees.
*
The old 1st row becomes the new last column,
* the old 2nd row becomes the new 2nd last column, and so on.
*
Hint: attribute 'imp' should be reassigned to a new matrix.
*
See TestMatrix class for how this method can be used.
*/
public void rotateClockwise() {
int n = imp.length;
int m = imp[0].length;
int [][] output = new int [m][n];
for (int i=0; i<n; i++) {
for (int j=0;j<m; j++)
output [j][n-1-i] = imp[i][j];
}
imp = output;
}
/**
*
Shift this matrix to the left by one column.
*
The old 2nd column becomes the new 1st column,
* the old 3rd column becomes the new 2nd column, ...,
* the old 1st column becomes the new last column.
*
See TestMatrix class for how this method can be used.
*/
public void shiftLeft() {
int temp[] = getColumn(0);
for(int i=0; i<imp.length; i++) {
for(int j=0; j<imp[0].length-1; j++) {
imp[i][j] = imp[i][j+1];
}
}
for(int i=0; i<temp.length; i++) {
imp[i][imp[0].length - 1] = temp[i];
}
}
/**
*
Shift this matrix up by one row.
*
The old 2nd row becomes the new 1st row,
* the old 3rd row becomes the new 2nd row, ...,
* the old 1st row becomes the new last row.
*
See TestMatrix class for how this method can be used.
*/
public void shiftUp() {
int temp[] = getRow(0);
for(int i=0; i<imp.length-1; i++) {
for(int j=0; j<imp[0].length; j++) {
imp[i][j] = imp[i+1][j];
}
}
for(int i=0; i<temp.length; i++) {
imp[imp.length - 1][i] = temp[i];
}
}
}
Related Questions
drjack9650@gmail.com
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.