JamesFlare/CSCI-1200
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

add solution for hw 5

Browse Source
This commit is contained in:
JamesFlare1212
2025-03-12 10:00:49 -04:00
parent c20ce7c2c3
commit 903e76ef1f
6 changed files with 772 additions and 326 deletions
Download Patch File Download Diff File Expand all files Collapse all files

186
hws/matrix_class/matrix_main.cpp
View File

@@ -198,124 +198,96 @@ void SimpleTest(){ //well behaved getrow/read after
//Write your own test cases here
void StudentTest() {
//Test transpose
Matrix m(2, 3, 0);
m.set(0, 0, 1);
m.set(0, 1, 2);
m.set(0, 2, 3);
m.set(1, 0, 4);
m.set(1, 1, 5);
m.set(1, 2, 6);
m.transpose();
assert(m.num_rows() == 3);
assert(m.num_cols() == 2);
double val;
m.get(0, 0, val);
assert(double_compare(val, 1.0));
m.get(0, 1, val);
assert(double_compare(val, 4.0));
m.get(1, 0, val);
assert(double_compare(val, 2.0));
m.get(2, 1, val);
assert(double_compare(val, 6.0));
// Test 1: Transpose a non-square matrix.
Matrix m(2, 3, 1.0);
m.set(0, 0, 1.0); m.set(0, 1, 2.0); m.set(0, 2, 3.0);
m.set(1, 0, 4.0); m.set(1, 1, 5.0); m.set(1, 2, 6.0);
m.transpose(); // Now m should be 3 x 2.
assert(m.num_rows() == 3 && m.num_cols() == 2);
m.get(0, 0, val); assert(val == 1.0);
m.get(0, 1, val); assert(val == 4.0);
m.get(1, 0, val); assert(val == 2.0);
m.get(1, 1, val); assert(val == 5.0);
m.get(2, 0, val); assert(val == 3.0);
m.get(2, 1, val); assert(val == 6.0);
//Test quarter with odd dimensions
Matrix q(5, 5, 1);
Matrix* quarters = q.quarter();
assert(quarters != nullptr);
//each quadrant should be 3x3 (ceiling: (5+1)/2 == 3)
assert(quarters[0].num_rows() == 3);
assert(quarters[0].num_cols() == 3);
assert(quarters[1].num_rows() == 3);
assert(quarters[1].num_cols() == 3);
assert(quarters[2].num_rows() == 3);
assert(quarters[2].num_cols() == 3);
assert(quarters[3].num_rows() == 3);
assert(quarters[3].num_cols() == 3);
//verify that the quadrants hold the expected values.
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
quarters[0].get(i, j, val);
assert(double_compare(val, 1.0));
quarters[1].get(i, j, val);
assert(double_compare(val, 1.0));
quarters[2].get(i, j, val);
assert(double_compare(val, 1.0));
quarters[3].get(i, j, val);
assert(double_compare(val, 1.0));
// Test 2: Multiply matrix by a coefficient.
Matrix m2(2, 2, 2.0);
m2.multiply_by_coefficient(3.0);
m2.get(0, 0, val); assert(val == 6.0);
m2.get(1, 1, val); assert(val == 6.0);
// Test 3: get_col() functionality.
Matrix m3(3, 3, 0.0);
int counter = 1;
for (unsigned int i = 0; i < 3; i++) {
for (unsigned int j = 0; j < 3; j++) {
m3.set(i, j, counter++);
}
}
delete[] quarters;
double* col1 = m3.get_col(1);
// Expecting column 1 to be: 2, 5, 8.
assert(col1[0] == 2);
assert(col1[1] == 5);
assert(col1[2] == 8);
delete [] col1;
//Test add and subtract
Matrix a(2, 2, 2);
Matrix b(2, 2, 3);
assert(a.add(b)); // Now a is all 5's.
double v;
a.get(0, 0, v);
assert(double_compare(v, 5.0));
assert(a.subtract(b)); // Now a is back to all 2's.
a.get(0, 0, v);
assert(double_compare(v, 2.0));
// Test 4: swap_row().
Matrix m4(2, 3, 0.0);
m4.set(0, 0, 1); m4.set(0, 1, 2); m4.set(0, 2, 3);
m4.set(1, 0, 4); m4.set(1, 1, 5); m4.set(1, 2, 6);
m4.swap_row(0, 1);
m4.get(0, 0, val); assert(val == 4);
m4.get(1, 0, val); assert(val == 1);
//Test multiply by coefficient
a.multiply_by_coefficient(2.5); //Now a is all 5's (2*2.5).
a.get(0, 0, v);
assert(double_compare(v, 5.0));
// Test 5: subtract().
Matrix m5(2, 2, 10.0);
Matrix m6(2, 2, 3.0);
bool success = m5.subtract(m6);
assert(success);
m5.get(0, 0, val); assert(val == 7.0);
//Test get_row
double* row = a.get_row(0);
assert(row != nullptr);
assert(double_compare(row[0], 5.0));
assert(double_compare(row[1], 5.0));
delete[] row;
// Test 6: quarter() on an even-dimensioned matrix.
Matrix m7(4, 4, 0.0);
counter = 1;
for (unsigned int i = 0; i < 4; i++) {
for (unsigned int j = 0; j < 4; j++) {
m7.set(i, j, counter++);
}
}
Matrix* quads = m7.quarter();
// For a 4 x 4 matrix, quadrant size should be (4+1)/2 = 2 (integer division)
assert(quads[0].num_rows() == 2 && quads[0].num_cols() == 2);
// Upper Left quadrant should be:
// [ 1 2 ]
// [ 5 6 ]
quads[0].get(0, 0, val); assert(val == 1);
quads[0].get(0, 1, val); assert(val == 2);
quads[0].get(1, 0, val); assert(val == 5);
quads[0].get(1, 1, val); assert(val == 6);
delete [] quads;
// Test get_col
double* col = a.get_col(1);
assert(col != nullptr);
assert(double_compare(col[0], 5.0));
assert(double_compare(col[1], 5.0));
delete[] col;
// Test 7: clear() method.
Matrix m8(3, 3, 9.0);
m8.clear();
assert(m8.num_rows() == 0 && m8.num_cols() == 0);
//Test clear
a.clear();
assert(a.num_rows() == 0 && a.num_cols() == 0);
// Test 8: Self-assignment.
Matrix m9(2, 2, 7.0);
m9 = m9;
m9.get(0, 0, val); assert(val == 7.0);
//Test swap_row
Matrix s(3, 2, 0);
s.set(0, 0, 1); s.set(0, 1, 2);
s.set(1, 0, 3); s.set(1, 1, 4);
s.set(2, 0, 5); s.set(2, 1, 6);
//swap row 0 and row 2
assert(s.swap_row(0, 2));
s.get(0, 0, val);
assert(double_compare(val, 5.0));
s.get(0, 1, val);
assert(double_compare(val, 6.0));
s.get(2, 0, val);
assert(double_compare(val, 1.0));
s.get(2, 1, val);
assert(double_compare(val, 2.0));
//invalid swap should return false.
assert(!s.swap_row(0, 3));
// Test 9: Binary add() with mismatched dimensions.
Matrix m10(2, 3, 1.0);
Matrix m11(3, 2, 1.0);
bool res = m10.add(m11);
assert(res == false);
//Test copy constructor and assignment operator.
Matrix orig(2, 3, 7);
Matrix copy(orig); // Using copy constructor.
Matrix assign;
assign = orig; // Using assignment operator.
//change orig to ensure copy and assign remain unchanged.
orig.set(0, 0, 10);
orig.get(0, 0, val);
assert(double_compare(val, 10.0));
copy.get(0, 0, val);
assert(double_compare(val, 7.0));
assign.get(0, 0, val);
assert(double_compare(val, 7.0));
//Test out-of-bound get and set
assert(!orig.get(5, 5, val));
assert(!orig.set(5, 5, 3.0));
// Test 10: Binary subtract() with mismatched dimensions.
res = m10.subtract(m11);
assert(res == false);
}