more tests

Author: raphael-s-steiner

tests/sparse_matrix_impl.cpp

@@ -24,12 +24,24 @@ limitations under the License.
 #    include <iostream>
 #    include <vector>
 
+#    include "osp/auxiliary/io/general_file_reader.hpp"
+#    include "osp/auxiliary/io/hdag_graph_file_reader.hpp"
 #    include "osp/graph_algorithms/directed_graph_path_util.hpp"
 #    include "osp/graph_algorithms/directed_graph_util.hpp"
+#    include "osp/graph_implementations/adj_list_impl/compact_sparse_graph.hpp"
 #    include "osp/graph_implementations/eigen_matrix_adapter/sparse_matrix.hpp"
+#    include "test_graphs.hpp"
+// #include "osp/graph_implementations/adj_list_impl/computational_dag_edge_idx_vector_impl.hpp"
+#    include "osp/graph_implementations/adj_list_impl/computational_dag_vector_impl.hpp"
 
 using namespace osp;
 
+using SmCsr = Eigen::SparseMatrix<double, Eigen::RowMajor, int32_t>;
+using SmCsc = Eigen::SparseMatrix<double, Eigen::ColMajor, int32_t>;
+using Triplet = Eigen::Triplet<double>;
+
+using VImpl1 = CDagVertexImpl<std::size_t, unsigned, unsigned, unsigned, unsigned>;
+
 BOOST_AUTO_TEST_CASE(TestSparseMatrixAdapter1) {
     /*
 
@@ -57,9 +69,6 @@ BOOST_AUTO_TEST_CASE(TestSparseMatrixAdapter1) {
       6 | 0.0  10.0  11.0     0     0  12.0     0
 
     */
-    using SmCsr = Eigen::SparseMatrix<double, Eigen::RowMajor, int32_t>;
-    using SmCsc = Eigen::SparseMatrix<double, Eigen::ColMajor, int32_t>;
-    using Triplet = Eigen::Triplet<double>;
     const int size = 7;
     std::vector<Triplet> triplets;
 
@@ -178,4 +187,109 @@ BOOST_AUTO_TEST_CASE(TestSparseMatrixAdapter1) {
     BOOST_CHECK_EQUAL(count, 11);
 }
 
+BOOST_AUTO_TEST_CASE(TestSparseMatrixAdapter2) {
+    std::vector<std::string> filenamesGraph = TestMTXGraphs();
+
+    // Getting root git directory
+    std::filesystem::path cwd = std::filesystem::current_path();
+    std::cout << cwd << std::endl;
+    while ((!cwd.empty()) && (cwd.filename() != "OneStopParallel")) {
+        cwd = cwd.parent_path();
+        std::cout << cwd << std::endl;
+    }
+
+    for (auto &filenameGraph : filenamesGraph) {
+        std::string nameGraph = filenameGraph.substr(filenameGraph.find_last_of("/\\") + 1);
+        nameGraph = nameGraph.substr(0, nameGraph.find_last_of("."));
+
+        std::cout << "Graph: " << nameGraph << std::endl;
+
+        ComputationalDagVectorImpl<VImpl1> graph1;
+
+        const bool statusGraph = file_reader::ReadGraph((cwd / filenameGraph).string(), graph1);
+
+        BOOST_CHECK(statusGraph);
+        if (!statusGraph) {
+            std::cout << "Reading files failed." << std::endl;
+        }
+
+        CompactSparseGraph<true, true, true, true, true> graph2(graph1);
+
+        std::vector<Triplet> triplets;
+        // Diagonal entries
+        for (const auto &vert : graph1.Vertices()) {
+            triplets.emplace_back(vert, vert, 1.0);
+        }
+
+        // Below Diagonal
+        for (const auto &vert : graph1.Vertices()) {
+            for (const auto &child : graph1.Children(vert)) {
+                triplets.emplace_back(child, vert, 2.0);
+            }
+        }
+
+        const int32_t nVert = static_cast<int32_t>(graph1.NumVertices());
+        SmCsr lCsr(nVert, nVert);
+        lCsr.setFromTriplets(triplets.begin(), triplets.end());
+        SmCsc lCsc{};
+        lCsc = lCsr;
+
+        SparseMatrixImp<int32_t> graph;
+        graph.SetCsr(&lCsr);
+        graph.SetCsc(&lCsc);
+
+        BOOST_CHECK_EQUAL(static_cast<std::size_t>(graph.NumVertices()), graph1.NumVertices());
+        BOOST_CHECK_EQUAL(static_cast<std::size_t>(graph.NumVertices()), graph2.NumVertices());
+
+        BOOST_CHECK_EQUAL(static_cast<std::size_t>(graph.NumEdges()), graph1.NumEdges());
+        BOOST_CHECK_EQUAL(static_cast<std::size_t>(graph.NumEdges()), graph2.NumEdges());
+
+        for (const auto &vert : graph2.Vertices()) {
+            auto chldren = graph.Children(vert);
+            auto chldren2 = graph2.Children(vert);
+            auto it = chldren.begin();
+            auto it2 = chldren2.begin();
+            auto end = chldren.end();
+            auto end2 = chldren2.end();
+
+            std::size_t cntr = 0;
+            while ((it != end) && (it2 != end2)) {
+                BOOST_CHECK_EQUAL(*it, *it2);
+
+                ++cntr;
+                ++it;
+                ++it2;
+            }
+            BOOST_CHECK_EQUAL(cntr, graph.OutDegree(vert));
+            BOOST_CHECK_EQUAL(cntr, graph1.OutDegree(vert));
+            BOOST_CHECK_EQUAL(cntr, graph2.OutDegree(vert));
+            BOOST_CHECK(it == end);
+            BOOST_CHECK(it2 == end2);
+        }
+
+        for (const auto &vert : graph2.Vertices()) {
+            auto parents = graph.Parents(vert);
+            auto parents2 = graph2.Parents(vert);
+            auto it = parents.begin();
+            auto it2 = parents2.begin();
+            auto end = parents.end();
+            auto end2 = parents2.end();
+
+            std::size_t cntr = 0;
+            while ((it != end) && (it2 != end2)) {
+                BOOST_CHECK_EQUAL(*it, *it2);
+
+                ++cntr;
+                ++it;
+                ++it2;
+            }
+            BOOST_CHECK_EQUAL(cntr, graph.InDegree(vert));
+            BOOST_CHECK_EQUAL(cntr, graph1.InDegree(vert));
+            BOOST_CHECK_EQUAL(cntr, graph2.InDegree(vert));
+            BOOST_CHECK(it == end);
+            BOOST_CHECK(it2 == end2);
+        }
+    }
+}
+
 #endif

tests/test_graphs.hpp

@@ -57,6 +57,18 @@ std::vector<std::string> TestGraphs() {
             "data/spaa/tiny/instance_CG_N3_K1_nzP0d5.hdag"};
 }
 
+std::vector<std::string> TestMTXGraphs() {
+    return {"data/mtx_tests/ErdosRenyi_100_1k_A.mtx",
+            "data/mtx_tests/ErdosRenyi_200_5k_A.mtx",
+            "data/mtx_tests/ErdosRenyi_2k_14k_A.mtx",
+            "data/mtx_tests/ErdosRenyi_500_8k_A.mtx",
+            "data/mtx_tests/ErdosRenyi_8_19_A.mtx",
+            "data/mtx_tests/RandomBand_p40_b30_2k_23k_A.mtx",
+            "data/mtx_tests/RandomBand_p70_b12_500_4k_A.mtx",
+            "data/mtx_tests/RandomBand_p80_b14_200_2k_A.mtx",
+            "data/mtx_tests/RandomBand_p80_b5_100_419_A.mtx"};
+}
+
 /**
  * @brief Constructs a DAG with multiple identical, parallel pipelines.
  *