make algorithm parametrized by matrix type

Gluttton · Gluttton · commit b0e13e887d3d · 2021-11-24T23:41:01.000+02:00
Try to go deeper and be more generic... Now the algorithm does not depend on the base matrix class. Issue: saebyn#25 Signed-off-by: Gluttton <gluttton@ukr.net>
diff --git a/benchmarks/test.cpp b/benchmarks/test.cpp
@@ -32,7 +32,7 @@ class MunkresFixture : public celero::TestFixture
 
 BASELINE_F (Munkres, Solve, MunkresFixture, 5000, 1)
 {
-    munkres_cpp::Munkres<MUNKRES_CPP_VALUE_TYPE> munkres (matrix);
+    munkres_cpp::Munkres<MUNKRES_CPP_VALUE_TYPE, munkres_cpp::MUNKRES_CPP_MATRIX_TYPE> munkres (matrix);
 }
 
 
diff --git a/examples/example_01.cpp b/examples/example_01.cpp
@@ -20,6 +20,7 @@
 
 // The easiest way to start with munkres-cpp.
 #include <munkres-cpp/munkres.h>
+#include <munkres-cpp/matrix.h>
 #include <cstdlib>
 
 int main (int /*argc*/, char * /*argv*/[])
@@ -35,7 +36,7 @@ int main (int /*argc*/, char * /*argv*/[])
     // Input data must be positive and well defined (no NaN or infinity).
 
     // Next you need create the problem solver and pass data to it.
-    munkres_cpp::Munkres<int> solver (data);
+    munkres_cpp::Munkres<int, munkres_cpp::Matrix> solver (data);
 
     // Now the matrix contains the solution of the problem.
     // Zero value represents selected values.
diff --git a/examples/example_02.cpp b/examples/example_02.cpp
@@ -20,6 +20,7 @@
 
 // Easy way to start with munkres-cpp.
 #include <munkres-cpp/munkres.h>
+#include <munkres-cpp/matrix.h>
 #include <munkres-cpp/utils.h>
 #include <cstdlib>
 
@@ -39,7 +40,7 @@ int main (int /*argc*/, char * /*argv*/[])
     // of the input data you should use it.
     if (munkres_cpp::is_data_valid (data) ) {
         // Next you need to create the problem solver and pass data to it.
-        munkres_cpp::Munkres<int> solver (data);
+        munkres_cpp::Munkres<int, munkres_cpp::Matrix> solver (data);
 
         // Now the matrix contains the solution.
         // Zero value represents selected values.
diff --git a/examples/example_03.cpp b/examples/example_03.cpp
@@ -38,7 +38,7 @@ int main (int /*argc*/, char * /*argv*/[])
     // Don't forget! You are responsible for correctness of the input data.
 
     // Create the solver and pass data to it.
-    munkres_cpp::Munkres<double> solver (data);
+    munkres_cpp::Munkres<double, munkres_cpp::matrix_boost> solver (data);
 
     // Now the matrix contains the solution.
 
diff --git a/examples/example_04.cpp b/examples/example_04.cpp
@@ -37,37 +37,56 @@ template<class T>
 class matrix_boost_adapter : public munkres_cpp::matrix_base<T>
 {
     public:
-        matrix_boost_adapter (boost::numeric::ublas::matrix<T> & data)
-            : data {data}
+        matrix_boost_adapter (boost::numeric::ublas::matrix<T> * data = nullptr)
+            : data        {data}
+            , is_own_data {false}
         {
+            if (!data) {
+                data = new boost::numeric::ublas::matrix<T>;
+                is_own_data = true;
+            }
+        }
+
+        matrix_boost_adapter (size_t rows, size_t columns)
+            : data        {new boost::numeric::ublas::matrix<T> (rows, columns, 0)}
+            , is_own_data {true}
+        {
+        }
+
+        ~matrix_boost_adapter () override
+        {
+            if (is_own_data) {
+                delete data;
+            }
         }
 
         const T & operator () (const size_t row, const size_t column) const override
         {
-            return data (row, column);
+            return data->operator () (row, column);
         };
 
         T & operator () (const size_t row, const size_t column) override
         {
-            return data (row, column);
+            return data->operator () (row, column);
         }
 
         size_t columns () const override
         {
-            return data.size2 ();
+            return data->size2 ();
         }
 
         size_t rows () const override
         {
-            return data.size1 ();
+            return data->size1 ();
         }
 
-        void resize (size_t, size_t, T) override
+        void resize (size_t, size_t, T/* value = T (0) */) override
         {
         }
 
     private:
-        boost::numeric::ublas::matrix<T> & data;
+        boost::numeric::ublas::matrix<T> * data;
+        bool is_own_data;
 };
 
 int main (int /*argc*/, char * /*argv*/[])
@@ -80,10 +99,10 @@ int main (int /*argc*/, char * /*argv*/[])
     // Don't forget! You are responsible for correctness of the input data.
 
     // Create data adapter and pass your container to it.
-    matrix_boost_adapter<double> adapter (data);
+    matrix_boost_adapter<double> adapter (& data);
 
     // Create the solver and pass data to it.
-    munkres_cpp::Munkres<double> solver (adapter);
+    munkres_cpp::Munkres<double, matrix_boost_adapter> solver (adapter);
 
     // Now the matrix contains the solution.
 
diff --git a/examples/example_05.cpp b/examples/example_05.cpp
@@ -40,7 +40,7 @@ class matrix_boost_adapter : public munkres_cpp::matrix_base<T>, boost::numeric:
 {
     public:
         matrix_boost_adapter (const size_t rows, const size_t columns)
-            : boost::numeric::ublas::matrix<T>::matrix (rows, columns)
+            : boost::numeric::ublas::matrix<T>::matrix (rows, columns, 0)
         {
         }
 
@@ -114,7 +114,7 @@ int main (int /*argc*/, char * /*argv*/[])
     // of the input data you should use it.
     if (munkres_cpp::is_data_valid (data) ) {
         // Next you need create the problem solver and pass data to it.
-        munkres_cpp::Munkres<float> solver (data);
+        munkres_cpp::Munkres<float, matrix_boost_adapter> solver (data);
 
         // Now the matrix contains the solution.
         // Zero value represents selected values.
diff --git a/examples/example_06.cpp b/examples/example_06.cpp
@@ -26,18 +26,19 @@
 #include <ctime>
 
 #include <munkres-cpp/munkres.h>
+#include <munkres-cpp/adapters/matrix_boost.h>
 
 int main (int argc, char * argv[])
 {
-    int nrows = 101;
-    int ncols = 101;
+    int nrows = 10;
+    int ncols = 10;
 
     if (argc == 3) {
         nrows = atoi (argv[1]);
         ncols = atoi (argv[2]);
     }
 
-    munkres_cpp::Matrix<double> matrix (nrows, ncols);
+    munkres_cpp::matrix_boost<double> matrix (nrows, ncols);
 
     srandom ( time (nullptr) ); // Seed random number generator.
 
@@ -59,7 +60,7 @@ int main (int argc, char * argv[])
     std::cout << std::endl;
 
     // Apply Munkres algorithm to matrix.
-    munkres_cpp::Munkres<double> m (matrix);
+    munkres_cpp::Munkres<double, munkres_cpp::matrix_boost> m (matrix);
 
     // Display solved matrix.
     for (int row = 0; row < nrows; row++) {
diff --git a/src/munkres-cpp/adapters/matrix_armadillo.h b/src/munkres-cpp/adapters/matrix_armadillo.h
@@ -35,6 +35,7 @@ class matrix_armadillo : public matrix_base<T>, public arma::Mat<T>
         matrix_armadillo (size_t rows, size_t columns)
             : arma::Mat<T>::Mat (rows, columns)
         {
+            std::fill (matrix_base<T>::begin (), matrix_base<T>::end (), T (0) );
         }
 
         matrix_armadillo (const arma::Mat<T> & other)
@@ -94,6 +95,11 @@ class matrix_armadillo : public matrix_base<T>, public arma::Mat<T>
                 }
             }
         }
+
+        bool is_zero (size_t row, size_t column) const
+        {
+            return matrix_base<T>::is_zero (row, column);
+        }
 };
 
 }// namespace munkres_cpp
diff --git a/src/munkres-cpp/adapters/matrix_boost.h b/src/munkres-cpp/adapters/matrix_boost.h
@@ -32,6 +32,7 @@ class matrix_boost : public matrix_base<T>, public boost::numeric::ublas::matrix
         matrix_boost (size_t rows, size_t columns)
             : boost::numeric::ublas::matrix<T>::matrix (rows, columns)
         {
+            std::fill (matrix_base<T>::begin (), matrix_base<T>::end (), T (0) );
         }
 
         matrix_boost (const boost::numeric::ublas::matrix<T> & other)
diff --git a/src/munkres-cpp/adapters/matrix_eigen.h b/src/munkres-cpp/adapters/matrix_eigen.h
@@ -32,6 +32,7 @@ class matrix_eigen : public matrix_base<T>, public Eigen::Matrix<T, Eigen::Dynam
         matrix_eigen (size_t rows, size_t columns)
             : Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>::Matrix (rows, columns)
         {
+            std::fill (matrix_base<T>::begin (), matrix_base<T>::end (), T (0) );
         }
 
         matrix_eigen (const Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> & other)
diff --git a/src/munkres-cpp/adapters/matrix_opencv.h b/src/munkres-cpp/adapters/matrix_opencv.h
@@ -36,6 +36,7 @@ class matrix_opencv : public matrix_base<T>, public cv::Mat_<T>
         matrix_opencv (size_t rows, size_t columns)
             : cv::Mat_<T>::Mat_ (rows, columns, cv::DataType<T>::type)
         {
+            std::fill (matrix_base<T>::begin (), matrix_base<T>::end (), T (0) );
         }
 
         matrix_opencv (const matrix_opencv<T> & other)
diff --git a/src/munkres-cpp/munkres.h b/src/munkres-cpp/munkres.h
@@ -19,7 +19,6 @@
 #if !defined(_MUNKRES_H_)
 #define _MUNKRES_H_
 
-#include "munkres-cpp/matrix.h"
 #include <forward_list>
 #include <algorithm>
 
@@ -28,11 +27,11 @@
 namespace munkres_cpp
 {
 
-template<typename T>
+template<typename T, template <typename> class M>
 class Munkres
 {
     public:
-        Munkres (matrix_base<T> &);
+        Munkres (M<T> &);
 
     private:
         Munkres (const Munkres &) = delete;
@@ -46,8 +45,8 @@ class Munkres
         int step6 ();
 
         const size_t size;
-        matrix_base<T> & matrix;
-        Matrix<char> mask_matrix;
+        M<T> & matrix;
+        M<char> mask_matrix;
         bool * const row_mask;
         bool * const col_mask;
         size_t saverow;
@@ -62,8 +61,8 @@ class Munkres
 
 
 
-template<typename T>
-void minimize_along_direction (matrix_base<T> & matrix, bool over_columns)
+template<typename T, template <typename> class M>
+void minimize_along_direction (M<T> & matrix, bool over_columns)
 {
     // Look for a minimum value to subtract from all values along the "outer" direction.
     size_t i, j = 0, size = matrix.rows ();
@@ -85,8 +84,8 @@ void minimize_along_direction (matrix_base<T> & matrix, bool over_columns)
 
 
 
-template<typename T>
-bool Munkres<T>::find_uncovered_in_matrix (size_t & row, size_t & col) const
+template<typename T, template <typename> class M>
+bool Munkres<T, M>::find_uncovered_in_matrix (size_t & row, size_t & col) const
 {
     for (col = 0; col < size; col++)
         if (!col_mask[col])
@@ -100,8 +99,8 @@ bool Munkres<T>::find_uncovered_in_matrix (size_t & row, size_t & col) const
 
 
 
-template<typename T>
-int Munkres<T>::step1 ()
+template<typename T, template <typename> class M>
+int Munkres<T, M>::step1 ()
 {
     for (size_t row = 0; row < size; row++) {
         for (size_t col = 0; col < size; col++) {
@@ -123,8 +122,8 @@ int Munkres<T>::step1 ()
 
 
 
-template<typename T>
-int Munkres<T>::step2 ()
+template<typename T, template <typename> class M>
+int Munkres<T, M>::step2 ()
 {
     size_t covercount = 0;
 
@@ -140,8 +139,8 @@ int Munkres<T>::step2 ()
 
 
 
-template<typename T>
-int Munkres<T>::step3 ()
+template<typename T, template <typename> class M>
+int Munkres<T, M>::step3 ()
 {
     // Main Zero Search
     // 1. Find an uncovered Z in the distance matrix and prime it. If no such zero exists, go to Step 5
@@ -164,8 +163,8 @@ int Munkres<T>::step3 ()
 
 
 
-template<typename T>
-int Munkres<T>::step4 ()
+template<typename T, template <typename> class M>
+int Munkres<T, M>::step4 ()
 {
     // Seq contains pairs of row/column values where we have found
     // either a star or a prime that is part of the ``alternating sequence``.
@@ -212,8 +211,8 @@ int Munkres<T>::step4 ()
 
 
 
-template<typename T>
-int Munkres<T>::step5 ()
+template<typename T, template <typename> class M>
+int Munkres<T, M>::step5 ()
 {
     // New Zero Manufactures
     // 1. Let h be the smallest uncovered entry in the (modified) distance matrix.
@@ -249,8 +248,8 @@ int Munkres<T>::step5 ()
 //
 // Assignments are remaining 0 values
 // (extra 0 values are replaced with 1)
-template<typename T>
-Munkres<T>::Munkres (matrix_base<T> & matrix)
+template<typename T, template <typename> class M>
+Munkres<T, M>::Munkres (M<T> & matrix)
     : size {std::max (matrix.rows (), matrix.columns () )}
     , matrix {matrix}
     , mask_matrix {size, size}
diff --git a/src/munkres-cpp/utils.h b/src/munkres-cpp/utils.h
@@ -1,17 +1,17 @@
 #if !defined(__MUNKRES_CPP_UTILS_H__)
 #define __MUNKRES_CPP_UTILS_H__
 
-#include "munkres-cpp/matrix_base.h"
 #include <algorithm>
+#include <cmath>
 
 
 
 namespace munkres_cpp
 {
 
-template<typename T>
+template<typename T, template <typename> class M>
 typename std::enable_if<std::is_floating_point<T>::value>::type
-replace_infinites (matrix_base<T> & matrix)
+replace_infinites (M<T> & matrix)
 {
     std::replace_if (matrix.begin (), matrix.end (), [](const T & v){return std::isinf (v);}, std::numeric_limits<T>::max () );
 }
@@ -41,14 +41,14 @@ is_data_invalid (const T & value)
 
 
 
-template<typename T>
-typename std::enable_if<std::is_unsigned<T>::value, bool>::type is_data_valid (const matrix_base<T> &)
+template<typename T, template <typename> class M>
+typename std::enable_if<std::is_unsigned<T>::value, bool>::type is_data_valid (const M<T> &)
 {
     return true;
 }
 
-template<typename T>
-typename std::enable_if<std::is_signed<T>::value, bool>::type is_data_valid (const matrix_base<T> & matrix)
+template<typename T, template <typename> class M>
+typename std::enable_if<std::is_signed<T>::value, bool>::type is_data_valid (const M<T> & matrix)
 {
     return !std::any_of (matrix.begin (), matrix.end (), [](const T & v){return is_data_invalid<T> (v);});
 }
diff --git a/tests/matrix_test.cpp b/tests/matrix_test.cpp
diff --git a/tests/matrix_test.h b/tests/matrix_test.h
diff --git a/tests/munkres_test.cpp b/tests/munkres_test.cpp
diff --git a/tests/utils_test.cpp b/tests/utils_test.cpp

Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ class MunkresFixture : public celero::TestFixture`
`32`	`32`
`33`	`33`	`BASELINE_F (Munkres, Solve, MunkresFixture, 5000, 1)`
`34`	`34`	`{`
`35`		`- munkres_cpp::Munkres<MUNKRES_CPP_VALUE_TYPE> munkres (matrix);`
	`35`	`+ munkres_cpp::Munkres<MUNKRES_CPP_VALUE_TYPE, munkres_cpp::MUNKRES_CPP_MATRIX_TYPE> munkres (matrix);`
`36`	`36`	`}`
`37`	`37`
`38`	`38`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ class matrix_boost_adapter : public munkres_cpp::matrix_base<T>, boost::numeric:`
`40`	`40`	`{`
`41`	`41`	`public:`
`42`	`42`	`matrix_boost_adapter (const size_t rows, const size_t columns)`
`43`		`- : boost::numeric::ublas::matrix<T>::matrix (rows, columns)`
	`43`	`+ : boost::numeric::ublas::matrix<T>::matrix (rows, columns, 0)`
`44`	`44`	`{`
`45`	`45`	`}`
`46`	`46`
`@@ -114,7 +114,7 @@ int main (int /argc/, char * /argv/[])`
`114`	`114`	`// of the input data you should use it.`
`115`	`115`	`if (munkres_cpp::is_data_valid (data) ) {`
`116`	`116`	`// Next you need create the problem solver and pass data to it.`
`117`		`- munkres_cpp::Munkres<float> solver (data);`
	`117`	`+ munkres_cpp::Munkres<float, matrix_boost_adapter> solver (data);`
`118`	`118`
`119`	`119`	`// Now the matrix contains the solution.`
`120`	`120`	`// Zero value represents selected values.`
Original file line number	Diff line number	Diff line change
`@@ -35,6 +35,7 @@ class matrix_armadillo : public matrix_base<T>, public arma::Mat<T>`
`35`	`35`	`matrix_armadillo (size_t rows, size_t columns)`
`36`	`36`	`: arma::Mat<T>::Mat (rows, columns)`
`37`	`37`	`{`
	`38`	`+ std::fill (matrix_base<T>::begin (), matrix_base<T>::end (), T (0) );`
`38`	`39`	`}`
`39`	`40`
`40`	`41`	`matrix_armadillo (const arma::Mat<T> & other)`
`@@ -94,6 +95,11 @@ class matrix_armadillo : public matrix_base<T>, public arma::Mat<T>`
`94`	`95`	`}`
`95`	`96`	`}`
`96`	`97`	`}`
	`98`	`+`
	`99`	`+ bool is_zero (size_t row, size_t column) const`
	`100`	`+ {`
	`101`	`+ return matrix_base<T>::is_zero (row, column);`
	`102`	`+ }`
`97`	`103`	`};`
`98`	`104`
`99`	`105`	`}// namespace munkres_cpp`
Original file line number	Diff line number	Diff line change
`@@ -32,6 +32,7 @@ class matrix_boost : public matrix_base<T>, public boost::numeric::ublas::matrix`
`32`	`32`	`matrix_boost (size_t rows, size_t columns)`
`33`	`33`	`: boost::numeric::ublas::matrix<T>::matrix (rows, columns)`
`34`	`34`	`{`
	`35`	`+ std::fill (matrix_base<T>::begin (), matrix_base<T>::end (), T (0) );`
`35`	`36`	`}`
`36`	`37`
`37`	`38`	`matrix_boost (const boost::numeric::ublas::matrix<T> & other)`
Original file line number	Diff line number	Diff line change
`@@ -32,6 +32,7 @@ class matrix_eigen : public matrix_base<T>, public Eigen::Matrix<T, Eigen::Dynam`
`32`	`32`	`matrix_eigen (size_t rows, size_t columns)`
`33`	`33`	`: Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>::Matrix (rows, columns)`
`34`	`34`	`{`
	`35`	`+ std::fill (matrix_base<T>::begin (), matrix_base<T>::end (), T (0) );`
`35`	`36`	`}`
`36`	`37`
`37`	`38`	`matrix_eigen (const Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> & other)`
Original file line number	Diff line number	Diff line change
`@@ -36,6 +36,7 @@ class matrix_opencv : public matrix_base<T>, public cv::Mat_<T>`
`36`	`36`	`matrix_opencv (size_t rows, size_t columns)`
`37`	`37`	`: cv::Mat_<T>::Mat_ (rows, columns, cv::DataType<T>::type)`
`38`	`38`	`{`
	`39`	`+ std::fill (matrix_base<T>::begin (), matrix_base<T>::end (), T (0) );`
`39`	`40`	`}`
`40`	`41`
`41`	`42`	`matrix_opencv (const matrix_opencv<T> & other)`
Original file line number	Diff line number	Diff line change
`@@ -1,17 +1,17 @@`
`1`	`1`	`#if !defined(__MUNKRES_CPP_UTILS_H__)`
`2`	`2`	`#define __MUNKRES_CPP_UTILS_H__`
`3`	`3`
`4`		`-#include "munkres-cpp/matrix_base.h"`
`5`	`4`	`#include <algorithm>`
	`5`	`+#include <cmath>`
`6`	`6`
`7`	`7`
`8`	`8`
`9`	`9`	`namespace munkres_cpp`
`10`	`10`	`{`
`11`	`11`
`12`		`-template<typename T>`
	`12`	`+template<typename T, template <typename> class M>`
`13`	`13`	`typename std::enable_if<std::is_floating_point<T>::value>::type`
`14`		`-replace_infinites (matrix_base<T> & matrix)`
	`14`	`+replace_infinites (M<T> & matrix)`
`15`	`15`	`{`
`16`	`16`	`std::replace_if (matrix.begin (), matrix.end (), [](const T & v){return std::isinf (v);}, std::numeric_limits<T>::max () );`
`17`	`17`	`}`
`@@ -41,14 +41,14 @@ is_data_invalid (const T & value)`
`41`	`41`
`42`	`42`
`43`	`43`
`44`		`-template<typename T>`
`45`		`-typename std::enable_if<std::is_unsigned<T>::value, bool>::type is_data_valid (const matrix_base<T> &)`
	`44`	`+template<typename T, template <typename> class M>`
	`45`	`+typename std::enable_if<std::is_unsigned<T>::value, bool>::type is_data_valid (const M<T> &)`
`46`	`46`	`{`
`47`	`47`	`return true;`
`48`	`48`	`}`
`49`	`49`
`50`		`-template<typename T>`
`51`		`-typename std::enable_if<std::is_signed<T>::value, bool>::type is_data_valid (const matrix_base<T> & matrix)`
	`50`	`+template<typename T, template <typename> class M>`
	`51`	`+typename std::enable_if<std::is_signed<T>::value, bool>::type is_data_valid (const M<T> & matrix)`
`52`	`52`	`{`
`53`	`53`	`return !std::any_of (matrix.begin (), matrix.end (), [](const T & v){return is_data_invalid<T> (v);});`
`54`	`54`	`}`