diff --git a/Makefile b/Makefile index 012a5e1..5a8b826 100644 --- a/Makefile +++ b/Makefile @@ -2,8 +2,10 @@ all: test -test: +build: g++ -Wall -pedantic tests/run.cpp -o tests/SparseMatrix-tests + +test: build ./tests/SparseMatrix-tests.exe debug: diff --git a/README.md b/README.md index b99ff10..16e16e9 100644 --- a/README.md +++ b/README.md @@ -5,15 +5,6 @@ C++ implementation of sparse matrix using [CRS format](http://netlib.org/linalg/ [![Buy me a Coffee](https://www.paypalobjects.com/en_US/i/btn/btn_donate_LG.gif)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=KWQJ7VTXZMZLS) -## Installation - -To use this library simply include the implementation file: - -```cpp -#include "/src/SparseMatrix/SparseMatrix.cpp" -``` - - ## Usage ### Creation @@ -21,11 +12,11 @@ To use this library simply include the implementation file: SparseMatrix comes as a template class, so we have to specify the element type. ```cpp -SparseMatrix matrix(3); // 3×3 matrix of integers -SparseMatrix matrix2(4, 5); // 4×5 matrix - 4 rows, 5 columns +SparseMatrix::SparseMatrix matrix(3); // 3×3 matrix of integers +SparseMatrix::SparseMatrix matrix2(4, 5); // 4×5 matrix - 4 rows, 5 columns -SparseMatrix matrix3(matrix); // copy constructor -SparseMatrix matrix4 = matrix2; // deep copy assignment +SparseMatrix::SparseMatrix matrix3(matrix); // copy constructor +SparseMatrix::SparseMatrix matrix4 = matrix2; // deep copy assignment ``` All values are now equal to `()`, which for type `int` is `0`. @@ -52,10 +43,10 @@ SparseMatrix is implemented as an immutable object - all operations create new m Number of columns in the matrix has to be the same as the size of the vector, otherwise `InvalidDimensionsException` is thrown. ```cpp -SparseMatrix mat(4, 5); -vector vec(5, 2); +SparseMatrix::SparseMatrix mat(4, 5); +std::vector vec(5, 2); -vector result; +std::vector result; result = mat.multiply(vec); // method result = mat * vec; // operator ``` @@ -65,10 +56,10 @@ result = mat * vec; // operator Number of columns in the left matrix must be same as number of rows in the right matrix, otherwise `InvalidDimensionsException` is thrown. ```cpp -SparseMatrix matrixA(2, 3); -SparseMatrix matrixB(3, 4); +SparseMatrix::SparseMatrix matrixA(2, 3); +SparseMatrix::SparseMatrix matrixB(3, 4); -SparseMatrix product; // will be of size 2×4 +SparseMatrix::SparseMatrix product; // will be of size 2×4 product = matrixA.multiply(matrixB); // method product = matrixA * matrixB; // operator ``` @@ -78,14 +69,14 @@ product = matrixA * matrixB; // operator You can also add and subtract matrices together. Both matrices has to have same dimentions, otherwise `InvalidDimensionsException` is thrown. ```cpp -SparseMatrix matrixA(4, 7); -SparseMatrix matrixB(4, 7); +SparseMatrix::SparseMatrix matrixA(4, 7); +SparseMatrix::SparseMatrix matrixB(4, 7); -SparseMatrix sum; +SparseMatrix::SparseMatrix sum; sum = matrixA.add(matrixB); // method sum = matrixA + matrixB; // operator -SparseMatrix diff; +SparseMatrix::SparseMatrix diff; diff = matrixA.subtract(matrixB); // method diff = matrixA - matrixB; // operator ``` @@ -93,8 +84,8 @@ diff = matrixA - matrixB; // operator #### Matrix-Matrix comparison ```cpp -SparseMatrix matrixA(3); -SparseMatrix matrixB(3); +SparseMatrix::SparseMatrix matrixA(3); +SparseMatrix::SparseMatrix matrixB(3); bool areSame = matrixA == matrixB; // true ``` @@ -113,7 +104,7 @@ int cols = matrix.getColumnCount(); Basic output streaming is implemented. Note that output operator must be implemented for the element type as well. ```cpp -SparseMatrix matrix(3, 4); +SparseMatrix::SparseMatrix matrix(3, 4); matrix.set(2, 1, 1); matrix.set(7, 1, 3); matrix.set(4, 2, 2); @@ -142,7 +133,7 @@ Make sure your type implements: * product `operator *` * output `operator <<` to be able to nicely output the matrix -You can see a simple custom element example in [the tests](tests/cases/custom-type.h). +You can see a simple custom element example in [the tests](tests/cases/custom-type.cpp). ----------- diff --git a/src/SparseMatrix/SparseMatrix.cpp b/src/SparseMatrix/SparseMatrix.cpp index b3d6e00..c0f4726 100644 --- a/src/SparseMatrix/SparseMatrix.cpp +++ b/src/SparseMatrix/SparseMatrix.cpp @@ -11,370 +11,373 @@ #include "exceptions.h" #include "SparseMatrix.h" -using namespace std; - -// === CREATION ============================================== - -template -SparseMatrix::SparseMatrix(int n) +namespace SparseMatrix { - this->construct(n, n); -} + // === CREATION ============================================== -template -SparseMatrix::SparseMatrix(int rows, int columns) -{ - this->construct(rows, columns); -} + template + SparseMatrix::SparseMatrix(int n) + { + this->construct(n, n); + } -template -SparseMatrix::SparseMatrix(const SparseMatrix & matrix) -{ - this->deepCopy(matrix); -} + template + SparseMatrix::SparseMatrix(int rows, int columns) + { + this->construct(rows, columns); + } -template -SparseMatrix & SparseMatrix::operator = (const SparseMatrix & matrix) -{ - if (&matrix != this) { - this->destruct(); + template + SparseMatrix::SparseMatrix(const SparseMatrix & matrix) + { this->deepCopy(matrix); } - return *this; -} - -template -void SparseMatrix::deepCopy(const SparseMatrix & matrix) -{ - this->m = matrix.m; - this->n = matrix.n; - this->rows = new vector(*(matrix.rows)); + template + SparseMatrix & SparseMatrix::operator = (const SparseMatrix & matrix) + { + if (&matrix != this) { + this->destruct(); + this->deepCopy(matrix); + } - if (matrix.vals != NULL) { - this->cols = new vector(*(matrix.cols)); - this->vals = new vector(*(matrix.vals)); + return *this; } -} -template -SparseMatrix::~SparseMatrix(void) -{ - this->destruct(); -} + template + void SparseMatrix::deepCopy(const SparseMatrix & matrix) + { + this->m = matrix.m; + this->n = matrix.n; + this->rows = new std::vector(*(matrix.rows)); + if (matrix.vals != NULL) { + this->cols = new std::vector(*(matrix.cols)); + this->vals = new std::vector(*(matrix.vals)); + } + } -template -void SparseMatrix::construct(int rows, int columns) -{ - if (rows < 1 || columns < 1) { - throw InvalidDimensionsException("Matrix dimensions cannot be zero or negative."); + + template + SparseMatrix::~SparseMatrix(void) + { + this->destruct(); } - this->m = rows; - this->n = columns; - this->vals = NULL; - this->cols = NULL; - this->rows = new vector(rows + 1, 1); -} + template + void SparseMatrix::construct(int rows, int columns) + { + if (rows < 1 || columns < 1) { + throw InvalidDimensionsException("Matrix dimensions cannot be zero or negative."); + } + this->m = rows; + this->n = columns; -template -void SparseMatrix::destruct(void) -{ - if (this->vals != NULL) { - delete this->vals; - delete this->cols; + this->vals = NULL; + this->cols = NULL; + this->rows = new std::vector(rows + 1, 1); } - delete this->rows; -} + template + void SparseMatrix::destruct(void) + { + if (this->vals != NULL) { + delete this->vals; + delete this->cols; + } -// === GETTERS / SETTERS ============================================== + delete this->rows; + } -template -int SparseMatrix::getRowCount(void) const -{ - return this->m; -} + // === GETTERS / SETTERS ============================================== + + template + int SparseMatrix::getRowCount(void) const + { + return this->m; + } -template -int SparseMatrix::getColumnCount(void) const -{ - return this->n; -} + template + int SparseMatrix::getColumnCount(void) const + { + return this->n; + } -// === VALUES ============================================== -template -T SparseMatrix::get(int row, int col) const -{ - this->validateCoordinates(row, col); + // === VALUES ============================================== - int currCol; + template + T SparseMatrix::get(int row, int col) const + { + this->validateCoordinates(row, col); - for (int pos = (*(this->rows))[row - 1] - 1; pos < (*(this->rows))[row] - 1; ++pos) { - currCol = (*(this->cols))[pos]; + int currCol; - if (currCol == col) { - return (*(this->vals))[pos]; + for (int pos = (*(this->rows))[row - 1] - 1; pos < (*(this->rows))[row] - 1; ++pos) { + currCol = (*(this->cols))[pos]; - } else if (currCol > col) { - break; + if (currCol == col) { + return (*(this->vals))[pos]; + + } else if (currCol > col) { + break; + } } + + return T(); } - return T(); -} + template + SparseMatrix & SparseMatrix::set(T val, int row, int col) + { + this->validateCoordinates(row, col); -template -SparseMatrix & SparseMatrix::set(T val, int row, int col) -{ - this->validateCoordinates(row, col); + int pos = (*(this->rows))[row - 1] - 1; + int currCol = 0; - int pos = (*(this->rows))[row - 1] - 1; - int currCol = 0; + for (; pos < (*(this->rows))[row] - 1; pos++) { + currCol = (*(this->cols))[pos]; - for (; pos < (*(this->rows))[row] - 1; pos++) { - currCol = (*(this->cols))[pos]; - - if (currCol >= col) { - break; + if (currCol >= col) { + break; + } } - } - if (currCol != col) { - if (!(val == T())) { - this->insert(pos, row, col, val); - } + if (currCol != col) { + if (!(val == T())) { + this->insert(pos, row, col, val); + } + + } else if (val == T()) { + this->remove(pos, row); - } else if (val == T()) { - this->remove(pos, row); + } else { + (*(this->vals))[pos] = val; + } - } else { - (*(this->vals))[pos] = val; + return *this; } - return *this; -} + // === OPERATIONS ============================================== -// === OPERATIONS ============================================== + template + std::vector SparseMatrix::multiply(const std::vector & x) const + { + if (this->n != (int) x.size()) { + throw InvalidDimensionsException("Cannot multiply: Matrix column count and vector size don't match."); + } -template -vector SparseMatrix::multiply(const vector & x) const -{ - if (this->n != (int) x.size()) { - throw InvalidDimensionsException("Cannot multiply: Matrix column count and vector size don't match."); - } + std::vector result(this->m, T()); - vector result(this->m, T()); + if (this->vals != NULL) { // only if any value set + for (int i = 0; i < this->m; i++) { + T sum = T(); + for (int j = (*(this->rows))[i]; j < (*(this->rows))[i + 1]; j++) { + sum = sum + (*(this->vals))[j - 1] * x[(*(this->cols))[j - 1] - 1]; + } - if (this->vals != NULL) { // only if any value set - for (int i = 0; i < this->m; i++) { - T sum = T(); - for (int j = (*(this->rows))[i]; j < (*(this->rows))[i + 1]; j++) { - sum = sum + (*(this->vals))[j - 1] * x[(*(this->cols))[j - 1] - 1]; + result[i] = sum; } - - result[i] = sum; } + + return result; } - return result; -} + template + std::vector SparseMatrix::operator * (const std::vector & x) const + { + return this->multiply(x); + } -template -vector SparseMatrix::operator * (const vector & x) const -{ - return this->multiply(x); -} + template + SparseMatrix SparseMatrix::multiply(const SparseMatrix & m) const + { + if (this->n != m.m) { + throw InvalidDimensionsException("Cannot multiply: Left matrix column count and right matrix row count don't match."); + } -template -SparseMatrix SparseMatrix::multiply(const SparseMatrix & m) const -{ - if (this->n != m.m) { - throw InvalidDimensionsException("Cannot multiply: Left matrix column count and right matrix row count don't match."); - } + SparseMatrix result(this->m, m.n); - SparseMatrix result(this->m, m.n); + T a; - T a; + // TODO: more efficient? + // @see http://www.math.tamu.edu/~srobertp/Courses/Math639_2014_Sp/CRSDescription/CRSStuff.pdf - // TODO: more efficient? - // @see http://www.math.tamu.edu/~srobertp/Courses/Math639_2014_Sp/CRSDescription/CRSStuff.pdf + for (int i = 1; i <= this->m; i++) { + for (int j = 1; j <= m.n; j++) { + a = T(); - for (int i = 1; i <= this->m; i++) { - for (int j = 1; j <= m.n; j++) { - a = T(); + for (int k = 1; k <= this->n; k++) { + a = a + this->get(i, k) * m.get(k, j); + } - for (int k = 1; k <= this->n; k++) { - a = a + this->get(i, k) * m.get(k, j); + result.set(a, i, j); } - - result.set(a, i, j); } - } - return result; -} + return result; + } -template -SparseMatrix SparseMatrix::operator * (const SparseMatrix & m) const -{ - return this->multiply(m); -} + template + SparseMatrix SparseMatrix::operator * (const SparseMatrix & m) const + { + return this->multiply(m); + } -template -SparseMatrix SparseMatrix::add(const SparseMatrix & m) const -{ - if (this->m != m.m || this->n != m.n) { - throw InvalidDimensionsException("Cannot add: matrices dimensions don't match."); - } + template + SparseMatrix SparseMatrix::add(const SparseMatrix & m) const + { + if (this->m != m.m || this->n != m.n) { + throw InvalidDimensionsException("Cannot add: matrices dimensions don't match."); + } - SparseMatrix result(this->m, this->n); + SparseMatrix result(this->m, this->n); - // TODO: more efficient? - // @see http://www.math.tamu.edu/~srobertp/Courses/Math639_2014_Sp/CRSDescription/CRSStuff.pdf + // TODO: more efficient? + // @see http://www.math.tamu.edu/~srobertp/Courses/Math639_2014_Sp/CRSDescription/CRSStuff.pdf - for (int i = 1; i <= this->m; i++) { - for (int j = 1; j <= this->n; j++) { - result.set(this->get(i, j) + m.get(i, j), i, j); + for (int i = 1; i <= this->m; i++) { + for (int j = 1; j <= this->n; j++) { + result.set(this->get(i, j) + m.get(i, j), i, j); + } } - } - return result; -} + return result; + } -template -SparseMatrix SparseMatrix::operator + (const SparseMatrix & m) const -{ - return this->add(m); -} + template + SparseMatrix SparseMatrix::operator + (const SparseMatrix & m) const + { + return this->add(m); + } -template -SparseMatrix SparseMatrix::subtract(const SparseMatrix & m) const -{ - if (this->m != m.m || this->n != m.n) { - throw InvalidDimensionsException("Cannot subtract: matrices dimensions don't match."); - } + template + SparseMatrix SparseMatrix::subtract(const SparseMatrix & m) const + { + if (this->m != m.m || this->n != m.n) { + throw InvalidDimensionsException("Cannot subtract: matrices dimensions don't match."); + } - SparseMatrix result(this->m, this->n); + SparseMatrix result(this->m, this->n); - // TODO: more efficient? - // @see http://www.math.tamu.edu/~srobertp/Courses/Math639_2014_Sp/CRSDescription/CRSStuff.pdf + // TODO: more efficient? + // @see http://www.math.tamu.edu/~srobertp/Courses/Math639_2014_Sp/CRSDescription/CRSStuff.pdf - for (int i = 1; i <= this->m; i++) { - for (int j = 1; j <= this->n; j++) { - result.set(this->get(i, j) - m.get(i, j), i, j); + for (int i = 1; i <= this->m; i++) { + for (int j = 1; j <= this->n; j++) { + result.set(this->get(i, j) - m.get(i, j), i, j); + } } - } - return result; -} + return result; + } -template -SparseMatrix SparseMatrix::operator - (const SparseMatrix & m) const -{ - return this->subtract(m); -} + template + SparseMatrix SparseMatrix::operator - (const SparseMatrix & m) const + { + return this->subtract(m); + } -// === HELPERS / VALIDATORS ============================================== + // === HELPERS / VALIDATORS ============================================== -template -void SparseMatrix::validateCoordinates(int row, int col) const -{ - if (row < 1 || col < 1 || row > this->m || col > this->n) { - throw InvalidCoordinatesException("Coordinates out of range."); + template + void SparseMatrix::validateCoordinates(int row, int col) const + { + if (row < 1 || col < 1 || row > this->m || col > this->n) { + throw InvalidCoordinatesException("Coordinates out of range."); + } } -} -template -void SparseMatrix::insert(int index, int row, int col, T val) -{ - if (this->vals == NULL) { - this->vals = new vector(1, val); - this->cols = new vector(1, col); + template + void SparseMatrix::insert(int index, int row, int col, T val) + { + if (this->vals == NULL) { + this->vals = new std::vector(1, val); + this->cols = new std::vector(1, col); - } else { - this->vals->insert(this->vals->begin() + index, val); - this->cols->insert(this->cols->begin() + index, col); - } + } else { + this->vals->insert(this->vals->begin() + index, val); + this->cols->insert(this->cols->begin() + index, col); + } - for (int i = row; i <= this->m; i++) { - (*(this->rows))[i] += 1; + for (int i = row; i <= this->m; i++) { + (*(this->rows))[i] += 1; + } } -} -template -void SparseMatrix::remove(int index, int row) -{ - this->vals->erase(this->vals->begin() + index); - this->cols->erase(this->cols->begin() + index); + template + void SparseMatrix::remove(int index, int row) + { + this->vals->erase(this->vals->begin() + index); + this->cols->erase(this->cols->begin() + index); - for (int i = row; i <= this->m; i++) { - (*(this->rows))[i] -= 1; + for (int i = row; i <= this->m; i++) { + (*(this->rows))[i] -= 1; + } } -} -// === FRIEND FUNCTIONS ========================================= + // === FRIEND FUNCTIONS ========================================= -template -bool operator == (const SparseMatrix & a, const SparseMatrix & b) -{ - return ((a.vals == NULL && b.vals == NULL) - || (a.vals != NULL && b.vals != NULL && *(a.vals) == *(b.vals))) - && ((a.cols == NULL && b.cols == NULL) - || (a.cols != NULL && b.cols != NULL && *(a.cols) == *(b.cols))) - && *(a.rows) == *(b.rows); -} + template + bool operator == (const SparseMatrix & a, const SparseMatrix & b) + { + return ((a.vals == NULL && b.vals == NULL) + || (a.vals != NULL && b.vals != NULL && *(a.vals) == *(b.vals))) + && ((a.cols == NULL && b.cols == NULL) + || (a.cols != NULL && b.cols != NULL && *(a.cols) == *(b.cols))) + && *(a.rows) == *(b.rows); + } -template -bool operator != (const SparseMatrix & a, const SparseMatrix & b) -{ - return !(a == b); -} + template + bool operator != (const SparseMatrix & a, const SparseMatrix & b) + { + return !(a == b); + } -template -ostream & operator << (ostream & os, const SparseMatrix & matrix) -{ - for (int i = 1; i <= matrix.m; i++) { - for (int j = 1; j <= matrix.n; j++) { - if (j != 1) { - os << " "; + template + std::ostream & operator << (std::ostream & os, const SparseMatrix & matrix) + { + for (int i = 1; i <= matrix.m; i++) { + for (int j = 1; j <= matrix.n; j++) { + if (j != 1) { + os << " "; + } + + os << matrix.get(i, j); } - os << matrix.get(i, j); + if (i < matrix.m) { + os << std::endl; + } } - if (i < matrix.m) { - os << endl; - } + return os; } - return os; } diff --git a/src/SparseMatrix/SparseMatrix.h b/src/SparseMatrix/SparseMatrix.h index bce1769..2eb6300 100644 --- a/src/SparseMatrix/SparseMatrix.h +++ b/src/SparseMatrix/SparseMatrix.h @@ -13,82 +13,85 @@ #include #include - using namespace std; - - template - class SparseMatrix + namespace SparseMatrix { - public: + template + class SparseMatrix + { + + public: + + // === CREATION ============================================== - // === CREATION ============================================== + SparseMatrix(int n); // square matrix n×n + SparseMatrix(int rows, int columns); // general matrix - SparseMatrix(int n); // square matrix n×n - SparseMatrix(int rows, int columns); // general matrix + SparseMatrix(const SparseMatrix & m); // copy constructor + SparseMatrix & operator = (const SparseMatrix & m); - SparseMatrix(const SparseMatrix & m); // copy constructor - SparseMatrix & operator = (const SparseMatrix & m); + ~SparseMatrix(void); - ~SparseMatrix(void); + // === GETTERS / SETTERS ============================================== - // === GETTERS / SETTERS ============================================== + int getRowCount(void) const; + int getColumnCount(void) const; - int getRowCount(void) const; - int getColumnCount(void) const; + // === VALUES ============================================== - // === VALUES ============================================== + T get(int row, int col) const; + SparseMatrix & set(T val, int row, int col); - T get(int row, int col) const; - SparseMatrix & set(T val, int row, int col); + // === OPERATIONS ============================================== - // === OPERATIONS ============================================== + std::vector multiply(const std::vector & x) const; + std::vector operator * (const std::vector & x) const; - vector multiply(const vector & x) const; - vector operator * (const vector & x) const; + SparseMatrix multiply(const SparseMatrix & m) const; + SparseMatrix operator * (const SparseMatrix & m) const; - SparseMatrix multiply(const SparseMatrix & m) const; - SparseMatrix operator * (const SparseMatrix & m) const; + SparseMatrix add(const SparseMatrix & m) const; + SparseMatrix operator + (const SparseMatrix & m) const; - SparseMatrix add(const SparseMatrix & m) const; - SparseMatrix operator + (const SparseMatrix & m) const; + SparseMatrix subtract(const SparseMatrix & m) const; + SparseMatrix operator - (const SparseMatrix & m) const; - SparseMatrix subtract(const SparseMatrix & m) const; - SparseMatrix operator - (const SparseMatrix & m) const; + // === FRIEND FUNCTIONS ========================================= - // === FRIEND FUNCTIONS ========================================= + template + friend bool operator == (const SparseMatrix & a, const SparseMatrix & b); - template - friend bool operator == (const SparseMatrix & a, const SparseMatrix & b); + template + friend bool operator != (const SparseMatrix & a, const SparseMatrix & b); - template - friend bool operator != (const SparseMatrix & a, const SparseMatrix & b); + template + friend std::ostream & operator << (std::ostream & os, const SparseMatrix & matrix); - template - friend ostream & operator << (ostream & os, const SparseMatrix & matrix); + protected: - protected: + int m, n; - int m, n; + std::vector * vals; + std::vector * rows, * cols; - vector * vals; - vector * rows, * cols; + // === HELPERS / VALIDATORS ============================================== - // === HELPERS / VALIDATORS ============================================== + void construct(int m, int n); + void destruct(void); + void deepCopy(const SparseMatrix & m); + void validateCoordinates(int row, int col) const; + void insert(int index, int row, int col, T val); + void remove(int index, int row); - void construct(int m, int n); - void destruct(void); - void deepCopy(const SparseMatrix & m); - void validateCoordinates(int row, int col) const; - void insert(int index, int row, int col, T val); - void remove(int index, int row); + }; - }; + } #endif diff --git a/src/SparseMatrix/exceptions.h b/src/SparseMatrix/exceptions.h index c05663a..5489e58 100644 --- a/src/SparseMatrix/exceptions.h +++ b/src/SparseMatrix/exceptions.h @@ -12,54 +12,57 @@ #include - using namespace std; - - class Exception : public exception + namespace SparseMatrix { - public: + class Exception : public std::exception + { - explicit Exception(const string & message) : exception(), message(message) - {} + public: + explicit Exception(const std::string & message) : exception(), message(message) + {} - virtual ~Exception(void) throw () - {} + virtual ~Exception(void) throw () + {} - inline string getMessage(void) const - { - return this->message; - } + inline std::string getMessage(void) const + { + return this->message; + } - protected: - string message; + protected: - }; + std::string message; + }; - class InvalidDimensionsException : public Exception - { - public: + class InvalidDimensionsException : public Exception + { - InvalidDimensionsException(const string & message) : Exception(message) - {} + public: - }; + InvalidDimensionsException(const std::string & message) : Exception(message) + {} + }; - class InvalidCoordinatesException : public Exception - { - public: + class InvalidCoordinatesException : public Exception + { + + public: + + InvalidCoordinatesException(const std::string & message) : Exception(message) + {} - InvalidCoordinatesException(const string & message) : Exception(message) - {} + }; - }; + } -#endif \ No newline at end of file +#endif diff --git a/tests/cases/addition.h b/tests/cases/addition.cpp similarity index 57% rename from tests/cases/addition.h rename to tests/cases/addition.cpp index 9573b09..d67ba1f 100644 --- a/tests/cases/addition.h +++ b/tests/cases/addition.cpp @@ -12,81 +12,81 @@ void _additionFail1(void) { - SparseMatrix a(3, 4), b(3, 5); + SparseMatrix::SparseMatrix a(3, 4), b(3, 5); a.add(b); } void testAdditionFail1(void) { - cout << "add() fail #1..." << flush; + std::cout << "add() fail #1..." << std::flush; assertException("InvalidDimensionsException", _additionFail1); - cout << " OK" << endl; + std::cout << " OK" << std::endl; } void _additionFail2(void) { - SparseMatrix a(3, 4), b(4, 4); + SparseMatrix::SparseMatrix a(3, 4), b(4, 4); a.add(b); } void testAdditionFail2(void) { - cout << "add() fail #2..." << flush; + std::cout << "add() fail #2..." << std::flush; assertException("InvalidDimensionsException", _additionFail2); - cout << " OK" << endl; + std::cout << " OK" << std::endl; } void _additionFail3(void) { - SparseMatrix a(3, 4), b(4, 5); + SparseMatrix::SparseMatrix a(3, 4), b(4, 5); a.add(b); } void testAdditionFail3(void) { - cout << "add() fail #3..." << flush; + std::cout << "add() fail #3..." << std::flush; assertException("InvalidDimensionsException", _additionFail3); - cout << " OK" << endl; + std::cout << " OK" << std::endl; } void testAddition(void) { for (int N = 0; N < 5e3; N++) { - cout << "\rmatrices addition... #" << N + 1 << flush; + std::cout << "\rmatrices addition... #" << N + 1 << std::flush; // generate random matrices int rows = rand() % 16 + 1; int cols = rand() % 16 + 1; - vector > classicMatrixA = generateRandomMatrix(rows, cols); + std::vector > classicMatrixA = generateRandomMatrix(rows, cols); SparseMatrixMock sparseMatrixA = SparseMatrixMock::fromVectors(classicMatrixA); - vector > classicMatrixB = generateRandomMatrix(rows, cols); + std::vector > classicMatrixB = generateRandomMatrix(rows, cols); SparseMatrixMock sparseMatrixB = SparseMatrixMock::fromVectors(classicMatrixB); // calculate result manually - vector > manualResult = addMatrices(classicMatrixA, classicMatrixB); + std::vector > manualResult = addMatrices(classicMatrixA, classicMatrixB); // method - assertEquals, vector > >( + assertEquals, std::vector > >( sparseMatrixA.add(sparseMatrixB), manualResult, "Incorrect matrices addition" ); // operator - assertEquals, vector > >( + assertEquals, std::vector > >( sparseMatrixA + sparseMatrixB, manualResult, "Incorrect matrices addition (operator +)" ); } - cout << " OK" << endl; + std::cout << " OK" << std::endl; } diff --git a/tests/cases/constructor.h b/tests/cases/constructor.cpp similarity index 61% rename from tests/cases/constructor.h rename to tests/cases/constructor.cpp index 687be14..3101f6b 100644 --- a/tests/cases/constructor.h +++ b/tests/cases/constructor.cpp @@ -12,55 +12,55 @@ void _constructorFail1(void) { - SparseMatrix(0); + SparseMatrix::SparseMatrix(0); } void testConstructorFail1(void) { - cout << "constructor fail #1..." << flush; + std::cout << "constructor fail #1..." << std::flush; assertException("InvalidDimensionsException", _constructorFail1); - cout << " OK" << endl; + std::cout << " OK" << std::endl; } void _constructorFail2(void) { - SparseMatrix(0, 1); + SparseMatrix::SparseMatrix(0, 1); } void testConstructorFail2(void) { - cout << "constructor fail #2..." << flush; + std::cout << "constructor fail #2..." << std::flush; assertException("InvalidDimensionsException", _constructorFail2); - cout << " OK" << endl; + std::cout << " OK" << std::endl; } void _constructorFail3(void) { - SparseMatrix(1, 0); + SparseMatrix::SparseMatrix(1, 0); } void testConstructorFail3(void) { - cout << "constructor fail #3..." << flush; + std::cout << "constructor fail #3..." << std::flush; assertException("InvalidDimensionsException", _constructorFail3); - cout << " OK" << endl; + std::cout << " OK" << std::endl; } void _constructorFail4(void) { - SparseMatrix(0, 0); + SparseMatrix::SparseMatrix(0, 0); } void testConstructorFail4(void) { - cout << "constructor fail #4..." << flush; + std::cout << "constructor fail #4..." << std::flush; assertException("InvalidDimensionsException", _constructorFail4); - cout << " OK" << endl; + std::cout << " OK" << std::endl; } diff --git a/tests/cases/crs-format.h b/tests/cases/crs-format.cpp similarity index 62% rename from tests/cases/crs-format.h rename to tests/cases/crs-format.cpp index ea9a8b9..a1d3347 100644 --- a/tests/cases/crs-format.h +++ b/tests/cases/crs-format.cpp @@ -12,7 +12,7 @@ void testInternalStorage(void) { - cout << "internal storage..." << flush; + std::cout << "internal storage..." << std::flush; /* "Standard" matrix @@ -35,14 +35,14 @@ void testInternalStorage(void) .set(3, 3, 3) .set(2, 3, 4); - vector rowPointers1; + std::vector rowPointers1; rowPointers1.push_back(1); rowPointers1.push_back(4); rowPointers1.push_back(6); rowPointers1.push_back(8); - assertEquals >(rowPointers1, *(m1.getRowPointers()), "Incorrect internal row pointers"); + assertEquals >(rowPointers1, *(m1.getRowPointers()), "Incorrect internal row pointers"); - vector columnPointers1; + std::vector columnPointers1; columnPointers1.push_back(1); columnPointers1.push_back(3); columnPointers1.push_back(4); @@ -50,9 +50,9 @@ void testInternalStorage(void) columnPointers1.push_back(2); columnPointers1.push_back(3); columnPointers1.push_back(4); - assertEquals >(columnPointers1, *(m1.getColumnPointers()), "Incorrect internal column pointers"); + assertEquals >(columnPointers1, *(m1.getColumnPointers()), "Incorrect internal column pointers"); - vector values1; + std::vector values1; values1.push_back(1); values1.push_back(4); values1.push_back(5); @@ -60,7 +60,7 @@ void testInternalStorage(void) values1.push_back(-1); values1.push_back(3); values1.push_back(2); - assertEquals >(values1, *(m1.getValues()), "Incorrect internal values storage"); + assertEquals >(values1, *(m1.getValues()), "Incorrect internal values storage"); /* @@ -82,28 +82,28 @@ void testInternalStorage(void) . set(1, 3, 2) . set(4, 3, 4); - vector rowPointers2; + std::vector rowPointers2; rowPointers2.push_back(1); rowPointers2.push_back(3); rowPointers2.push_back(3); rowPointers2.push_back(6); - assertEquals >(rowPointers2, *(m2.getRowPointers()), "Incorrect internal row pointers"); + assertEquals >(rowPointers2, *(m2.getRowPointers()), "Incorrect internal row pointers"); - vector columnPointers2; + std::vector columnPointers2; columnPointers2.push_back(1); columnPointers2.push_back(4); columnPointers2.push_back(1); columnPointers2.push_back(2); columnPointers2.push_back(4); - assertEquals >(columnPointers2, *(m2.getColumnPointers()), "Incorrect internal column pointers"); + assertEquals >(columnPointers2, *(m2.getColumnPointers()), "Incorrect internal column pointers"); - vector values2; + std::vector values2; values2.push_back(10); values2.push_back(2); values2.push_back(3); values2.push_back(1); values2.push_back(4); - assertEquals >(values2, *(m2.getValues()), "Incorrect internal values storage"); + assertEquals >(values2, *(m2.getValues()), "Incorrect internal values storage"); /* @@ -118,30 +118,30 @@ void testInternalStorage(void) SparseMatrixMock m3 = m2; m3.set(5, 2, 2); - vector rowPointers3; + std::vector rowPointers3; rowPointers3.push_back(1); rowPointers3.push_back(3); rowPointers3.push_back(4); rowPointers3.push_back(7); - assertEquals >(rowPointers3, *(m3.getRowPointers()), "Incorrect internal row pointers"); + assertEquals >(rowPointers3, *(m3.getRowPointers()), "Incorrect internal row pointers"); - vector columnPointers3; + std::vector columnPointers3; columnPointers3.push_back(1); columnPointers3.push_back(4); columnPointers3.push_back(2); columnPointers3.push_back(1); columnPointers3.push_back(2); columnPointers3.push_back(4); - assertEquals >(columnPointers3, *(m3.getColumnPointers()), "Incorrect internal column pointers"); + assertEquals >(columnPointers3, *(m3.getColumnPointers()), "Incorrect internal column pointers"); - vector values3; + std::vector values3; values3.push_back(10); values3.push_back(2); values3.push_back(5); values3.push_back(3); values3.push_back(1); values3.push_back(4); - assertEquals >(values3, *(m3.getValues()), "Incorrect internal values storage"); + assertEquals >(values3, *(m3.getValues()), "Incorrect internal values storage"); /* Previous matrix with removed the only non-zero element on 2nd row (should be equal to 2nd matrix) @@ -155,9 +155,9 @@ void testInternalStorage(void) SparseMatrixMock m4 = m3; m4.set(0, 2, 2); - assertEquals >(rowPointers2, *(m4.getRowPointers()), "Incorrect internal row pointers"); - assertEquals >(columnPointers2, *(m4.getColumnPointers()), "Incorrect internal column pointers"); - assertEquals >(values2, *(m4.getValues()), "Incorrect internal values storage"); + assertEquals >(rowPointers2, *(m4.getRowPointers()), "Incorrect internal row pointers"); + assertEquals >(columnPointers2, *(m4.getColumnPointers()), "Incorrect internal column pointers"); + assertEquals >(values2, *(m4.getValues()), "Incorrect internal values storage"); - cout << " OK" << endl; + std::cout << " OK" << std::endl; } diff --git a/tests/cases/custom-type.h b/tests/cases/custom-type.cpp similarity index 75% rename from tests/cases/custom-type.h rename to tests/cases/custom-type.cpp index f37060b..33b8959 100644 --- a/tests/cases/custom-type.h +++ b/tests/cases/custom-type.cpp @@ -7,16 +7,15 @@ */ #include +#include #include #include "../inc/testslib.h" #include "../inc/SparseMatrixMock.h" -using namespace std; - -string joinStrings(const string & a, const string & b) +std::string joinStrings(const std::string & a, const std::string & b) { - string c = a; + std::string c = a; if (a.length() && b.length()) { c += " "; @@ -38,7 +37,7 @@ struct person {} - person(const string & f, const string & l) : firstname(f), lastname(l) + person(const std::string & f, const std::string & l) : firstname(f), lastname(l) {} @@ -70,12 +69,12 @@ struct person } - string firstname, lastname; + std::string firstname, lastname; }; -ostream & operator << (ostream & os, const person & p) +std::ostream & operator << (std::ostream & os, const person & p) { os << p.firstname << ", " << p.lastname; return os; @@ -84,32 +83,32 @@ ostream & operator << (ostream & os, const person & p) void testElementTypes(void) { - cout << "custom element types..." << flush; + std::cout << "custom element types..." << std::flush; // addition - SparseMatrix a(4, 5); + SparseMatrix::SparseMatrix a(4, 5); a.set(person("John", "Doe"), 3, 2); - SparseMatrix b(4, 5); + SparseMatrix::SparseMatrix b(4, 5); b.set(person("Foo", "Bar"), 3, 2); - SparseMatrix sum = a.add(b); + SparseMatrix::SparseMatrix sum = a.add(b); assertEquals(person("John Foo", "Doe Bar"), sum.get(3, 2)); // subtraction - SparseMatrix diff = a.subtract(b); + SparseMatrix::SparseMatrix diff = a.subtract(b); assertEquals(person("Bar", "Doe"), diff.get(3, 2)); // matrix-matrix multiplication - SparseMatrix c(5, 3); + SparseMatrix::SparseMatrix c(5, 3); c.set(person("Foo", "Bar"), 2, 3); - SparseMatrix product = a.multiply(c); + SparseMatrix::SparseMatrix product = a.multiply(c); for (int i = 1, rows = product.getRowCount(); i <= rows; i++) { for (int j = 1, cols = product.getColumnCount(); j <= cols; j++) { @@ -127,18 +126,18 @@ void testElementTypes(void) // vector-matrix multiplication - vector people; + std::vector people; people.push_back(person("John", "Doe")); people.push_back(person("Foo", "Bar")); people.push_back(person("Willy", "Wonka")); people.push_back(person("Jon", "Snow")); people.push_back(person("Bridget", "Johnes")); - vector result = a.multiply(people); + std::vector result = a.multiply(people); assertEquals(person(), result[0]); assertEquals(person(), result[1]); assertEquals(person("John Bar", "Doe Foo"), result[2]); assertEquals(person(), result[3]); - cout << " OK" << endl; + std::cout << " OK" << std::endl; } diff --git a/tests/cases/multiplication.h b/tests/cases/multiplication.cpp similarity index 52% rename from tests/cases/multiplication.h rename to tests/cases/multiplication.cpp index fdcfce1..dca5e18 100644 --- a/tests/cases/multiplication.h +++ b/tests/cases/multiplication.cpp @@ -12,96 +12,96 @@ void _multiplicationFail1(void) { - SparseMatrix m(3, 4); - vector x(3, 1); + SparseMatrix::SparseMatrix m(3, 4); + std::vector x(3, 1); m.multiply(x); } void testMultiplicationFail1(void) { - cout << "multiply() fail #1..." << flush; + std::cout << "multiply() fail #1..." << std::flush; assertException("InvalidDimensionsException", _multiplicationFail1); - cout << " OK" << endl; + std::cout << " OK" << std::endl; } void _multiplicationFail2(void) { - SparseMatrix a(3, 4), b(5, 6); + SparseMatrix::SparseMatrix a(3, 4), b(5, 6); a.multiply(b); } void testMultiplicationFail2(void) { - cout << "multiply() fail #2..." << flush; + std::cout << "multiply() fail #2..." << std::flush; assertException("InvalidDimensionsException", _multiplicationFail2); - cout << " OK" << endl; + std::cout << " OK" << std::endl; } void testVectorMultiplication(void) { for (int N = 0; N < 5e3; N++) { - cout << "\rvector multiplication... #" << N + 1 << flush; + std::cout << "\rvector multiplication... #" << N + 1 << std::flush; // generate random vector and matrix int rows = rand() % 16 + 1; int cols = rand() % 16 + 1; - vector vec = generateRandomVector(cols); + std::vector vec = generateRandomVector(cols); - vector > classicMatrix = generateRandomMatrix(rows, cols); + std::vector > classicMatrix = generateRandomMatrix(rows, cols); SparseMatrixMock sparseMatrix = SparseMatrixMock::fromVectors(classicMatrix); // calculate result manually - vector manualResult = multiplyMatrixByVector(classicMatrix, vec); + std::vector manualResult = multiplyMatrixByVector(classicMatrix, vec); // method - assertEquals >(manualResult, sparseMatrix.multiply(vec), "Incorrect vector multiplication"); + assertEquals >(manualResult, sparseMatrix.multiply(vec), "Incorrect vector multiplication"); // operator - assertEquals >(manualResult, sparseMatrix * vec, "Incorrect vector multiplication (operator *)"); + assertEquals >(manualResult, sparseMatrix * vec, "Incorrect vector multiplication (operator *)"); } - cout << " OK" << endl; + std::cout << " OK" << std::endl; } void testMatricesMultiplication(void) { for (int N = 0; N < 5e3; N++) { - cout << "\rmatrices multiplication... #" << N + 1 << flush; + std::cout << "\rmatrices multiplication... #" << N + 1 << std::flush; // generate random matrices int rowsA = rand() % 16 + 1; int colsArowsB = rand() % 16 + 1; int colsB = rand() % 16 + 1; - vector > classicMatrixA = generateRandomMatrix(rowsA, colsArowsB); + std::vector