tests: moved standard operations into functions

Author: uestla

tests/cases/addition.h

@@ -71,13 +71,7 @@ void testAddition(void)
 		SparseMatrixMock<int> sparseMatrixB = SparseMatrixMock<int>::fromVectors(classicMatrixB);
 
 		// calculate result manually
-		vector<vector<int> > manualResult(rows, vector<int>(cols, 0));
-
-		for (int i = 0; i < rows; i++) {
-			for (int j = 0; j < cols; j++) {
-				manualResult[i][j] += classicMatrixA[i][j] + classicMatrixB[i][j];
-			}
-		}
+		vector<vector<int> > manualResult = addMatrices(classicMatrixA, classicMatrixB);
 
 		// method
 		assertEquals<SparseMatrix<int>, vector<vector<int> > >(

tests/cases/multiplication.h

@@ -56,13 +56,7 @@ void testVectorMultiplication(void)
 		SparseMatrixMock<int> sparseMatrix = SparseMatrixMock<int>::fromVectors(classicMatrix);
 
 		// calculate result manually
-		vector<int> manualResult(rows, 0);
-
-		for (int i = 0; i < rows; i++) {
-			for (int j = 0; j < cols; j++) {
-				manualResult[i] += classicMatrix[i][j] * vec[j];
-			}
-		}
+		vector<int> manualResult = multiplyMatrixByVector(classicMatrix, vec);
 
 		// method
 		assertEquals<vector<int> >(manualResult, sparseMatrix.multiply(vec), "Incorrect vector multiplication");
@@ -92,17 +86,7 @@ void testMatricesMultiplication(void)
 		SparseMatrixMock<int> sparseMatrixB = SparseMatrixMock<int>::fromVectors(classicMatrixB);
 
 		// calculate result manually
-		vector<vector<int> > manualResult(rowsA, vector<int>(colsB, 0));
-
-		for (int i = 0; i < rowsA; i++) {
-			for (int j = 0; j < colsB; j++) {
-				manualResult[i][j] = 0;
-
-				for (int k = 0; k < colsArowsB; k++) { // rows in B
-					manualResult[i][j] += classicMatrixA[i][k] * classicMatrixB[k][j];
-				}
-			}
-		}
+		vector<vector<int> > manualResult = multiplyMatrices(classicMatrixA, classicMatrixB);
 
 		// method
 		assertEquals<SparseMatrix<int>, vector<vector<int> > >(

tests/cases/subtraction.h

@@ -71,13 +71,7 @@ void testSubtraction(void)
 		SparseMatrixMock<int> sparseMatrixB = SparseMatrixMock<int>::fromVectors(classicMatrixB);
 
 		// calculate result manually
-		vector<vector<int> > manualResult(rows, vector<int>(cols, 0));
-
-		for (int i = 0; i < rows; i++) {
-			for (int j = 0; j < cols; j++) {
-				manualResult[i][j] += classicMatrixA[i][j] - classicMatrixB[i][j];
-			}
-		}
+		vector<vector<int> > manualResult = subtractMatrices(classicMatrixA, classicMatrixB);
 
 		// method
 		assertEquals<SparseMatrix<int>, vector<vector<int> > >(

tests/inc/helpers.h

@@ -46,6 +46,85 @@
 	}
 
 
+	// === STANDARD OPERATIONS =========================================
+
+	template<typename T>
+	vector<vector<T> > addMatrices(const vector<vector<T> > & a, const vector<vector<T> > & b)
+	{
+		int rows = a.size();
+		int cols = a.front().size();
+
+		vector<vector<T> > result(rows, vector<int>(cols, 0));
+
+		for (int i = 0; i < rows; i++) {
+			for (int j = 0; j < cols; j++) {
+				result[i][j] = a[i][j] + b[i][j];
+			}
+		}
+
+		return result;
+	}
+
+
+	template<typename T>
+	vector<vector<T> > subtractMatrices(const vector<vector<T> > & a, const vector<vector<T> > & b)
+	{
+		int rows = a.size();
+		int cols = a.front().size();
+
+		vector<vector<T> > result(rows, vector<int>(cols, 0));
+
+		for (int i = 0; i < rows; i++) {
+			for (int j = 0; j < cols; j++) {
+				result[i][j] = a[i][j] - b[i][j];
+			}
+		}
+
+		return result;
+	}
+
+
+	template<typename T>
+	vector<T> multiplyMatrixByVector(const vector<vector<T> > & m, const vector<T> & v)
+	{
+		int rows = m.size();
+		int cols = v.size();
+
+		vector<T> result(rows, 0);
+
+		for (int i = 0; i < rows; i++) {
+			for (int j = 0; j < cols; j++) {
+				result[i] += m[i][j] * v[j];
+			}
+		}
+
+		return result;
+	}
+
+
+	template<typename T>
+	vector<vector<T> > multiplyMatrices(const vector<vector<T> > & a, const vector<vector<T> > & b)
+	{
+		int rowsA = a.size();
+		int colsA = a.front().size();
+		int colsB = b.front().size();
+
+		vector<vector<T> > result(rowsA, vector<int>(colsB, 0));
+
+		for (int i = 0; i < rowsA; i++) {
+			for (int j = 0; j < colsB; j++) {
+				result[i][j] = 0;
+
+				for (int k = 0; k < colsA; k++) {
+					result[i][j] += a[i][k] * b[k][j];
+				}
+			}
+		}
+
+		return result;
+	}
+
+
 	// === OUTPUT HELPERS =========================================
 
 	template<typename T>