get partition properties in C interface

include/mtkahypar.h

@@ -407,17 +407,44 @@ MT_KAHYPAR_API mt_kahypar_status_t mt_kahypar_write_partition_to_file(const mt_k
 // ####################### Partitioning Results #######################
 
 // edge and pin iterators?? (+ num pins)
-// node degree, node weight, edge weight, edge source, edge target
+// edge source, edge target
+// compute block weights
 
-// "num_blocks"
-// "block_weight"
-// "block_id", "Block to which the corresponding node is assigned"
-// "fixed_vertex_block" "Block to which the node is fixed (-1 if not fixed)"
-// "num_incident_cut_edges" "Number of incident cut hyperedges of the corresponding node"
-// "num_pins_in_block", pinCountInPart
-// "connectivity"
+/**
+ * Number of blocks of the partition.
+ */
+MT_KAHYPAR_API mt_kahypar_partition_id_t mt_kahypar_num_blocks(const mt_kahypar_partitioned_hypergraph_t partitioned_hg);
 
-// compute block weights
+/**
+ * Weight of the corresponding block.
+ */
+MT_KAHYPAR_API mt_kahypar_hypernode_weight_t mt_kahypar_block_weight(const mt_kahypar_partitioned_hypergraph_t partitioned_hg,
+                                                                     const mt_kahypar_partition_id_t block);
+
+/**
+ * Block to which the corresponding hypernode is assigned.
+ */
+MT_KAHYPAR_API mt_kahypar_partition_id_t mt_kahypar_block_id(const mt_kahypar_partitioned_hypergraph_t partitioned_hg,
+                                                             const mt_kahypar_hypernode_id_t node);
+
+/**
+ * Number of incident cut hyperedges of the corresponding node.
+ */
+MT_KAHYPAR_API mt_kahypar_hyperedge_id_t mt_kahypar_num_incident_cut_hyperedges(const mt_kahypar_partitioned_hypergraph_t partitioned_hg,
+                                                                                const mt_kahypar_hypernode_id_t node);
+
+/**
+ * Number of distinct blocks to which the pins of the corresponding hyperedge are assigned.
+ */
+MT_KAHYPAR_API mt_kahypar_partition_id_t mt_kahypar_connectivity(const mt_kahypar_partitioned_hypergraph_t partitioned_hg,
+                                                                 const mt_kahypar_hyperedge_id_t edge);
+
+/**
+ * Number of pins assigned to the corresponding block in the given hyperedge.
+ */
+MT_KAHYPAR_API mt_kahypar_hypernode_id_t mt_kahypar_num_pins_in_block(const mt_kahypar_partitioned_hypergraph_t partitioned_hg,
+                                                                      const mt_kahypar_hyperedge_id_t edge,
+                                                                      const mt_kahypar_partition_id_t block);
 
 /**
  * Extracts a partition from a partitioned (hyper)graph. The size of the provided array must be at least the number of nodes.

lib/mtkahypar.cpp

@@ -563,6 +563,37 @@ mt_kahypar_status_t mt_kahypar_write_partition_to_file(const mt_kahypar_partitio
   }
 }
 
+
+mt_kahypar_partition_id_t mt_kahypar_num_blocks(const mt_kahypar_partitioned_hypergraph_t partitioned_hg) {
+  return lib::num_blocks<false>(partitioned_hg);
+}
+
+mt_kahypar_hypernode_weight_t mt_kahypar_block_weight(const mt_kahypar_partitioned_hypergraph_t partitioned_hg,
+                                                       const mt_kahypar_partition_id_t block) {
+  return lib::block_weight<false>(partitioned_hg, block);
+}
+
+mt_kahypar_partition_id_t mt_kahypar_block_id(const mt_kahypar_partitioned_hypergraph_t partitioned_hg,
+                                              const mt_kahypar_hypernode_id_t node) {
+  return lib::block_id<false>(partitioned_hg, node);
+}
+
+mt_kahypar_hyperedge_id_t mt_kahypar_num_incident_cut_hyperedges(const mt_kahypar_partitioned_hypergraph_t partitioned_hg,
+                                                                 const mt_kahypar_hypernode_id_t node)  {
+  return lib::num_incident_cut_edges<false>(partitioned_hg, node);
+}
+
+mt_kahypar_partition_id_t mt_kahypar_connectivity(const mt_kahypar_partitioned_hypergraph_t partitioned_hg,
+                                                  const mt_kahypar_hyperedge_id_t edge) {
+  return lib::connectivity<false>(partitioned_hg, edge);
+}
+
+mt_kahypar_hypernode_id_t mt_kahypar_num_pins_in_block(const mt_kahypar_partitioned_hypergraph_t partitioned_hg,
+                                                       const mt_kahypar_hyperedge_id_t edge,
+                                                       const mt_kahypar_partition_id_t block) {
+  return lib::num_pins_in_block<false>(partitioned_hg, edge, block);
+}
+
 void mt_kahypar_get_partition(const mt_kahypar_partitioned_hypergraph_t partitioned_hg, mt_kahypar_partition_id_t* partition) {
   lib::get_partition<false>(partitioned_hg, partition);
 }

python/module.cpp

@@ -597,7 +597,7 @@ Construct a partitioned hypergraph from this hypergraph.
   // ####################### Partitioned Hypergraph #######################
 
   phg_class
-    .def("num_blocks", &lib::num_blocks<true>, "Number of blocks")
+    .def("num_blocks", &lib::num_blocks<true>, "Number of blocks of the partition")
     .def("block_weight", &lib::block_weight<true>,
       "Weight of the corresponding block", py::arg("block"))
     .def("block_id", &lib::block_id<true>,
@@ -621,7 +621,7 @@ Construct a partitioned hypergraph from this hypergraph.
     .def("connectivity", &lib::connectivity<true>,
       "Number of distinct blocks to which the pins of the corresponding hyperedge are assigned", py::arg("hyperedge"))
     .def("num_pins_in_block", &lib::num_pins_in_block<true>,
-      "Number of nodes part of the corresponding block in the given hyperedge", py::arg("hyperedge"), py::arg("block_id"))
+      "Number of pins assigned to the corresponding block in the given hyperedge", py::arg("hyperedge"), py::arg("block_id"))
     .def("imbalance", &lib::imbalance<true>,
       "Computes the imbalance of the partition", py::arg("context"))
     .def("cut", &lib::cut<true>,

tests/interface/interface_test.cc

@@ -477,6 +477,61 @@ namespace mt_kahypar {
     mt_kahypar_free_partitioned_hypergraph(partitioned_hg_2);
   }
 
+  TEST(MtKaHyPar, ReportsPropertiesOfHypergraphPartition) {
+    mt_kahypar_error_t error;
+    mt_kahypar_context_t* context = mt_kahypar_context_from_preset(DEFAULT);
+    const mt_kahypar_hypernode_id_t num_vertices = 7;
+    const mt_kahypar_hyperedge_id_t num_hyperedges = 4;
+
+    std::unique_ptr<size_t[]> hyperedge_indices = std::make_unique<size_t[]>(5);
+    hyperedge_indices[0] = 0; hyperedge_indices[1] = 2; hyperedge_indices[2] = 6;
+    hyperedge_indices[3] = 9; hyperedge_indices[4] = 12;
+
+    std::unique_ptr<mt_kahypar_hyperedge_id_t[]> hyperedges = std::make_unique<mt_kahypar_hyperedge_id_t[]>(12);
+    hyperedges[0] = 0;  hyperedges[1] = 2;                                        // Hyperedge 0
+    hyperedges[2] = 0;  hyperedges[3] = 1; hyperedges[4] = 3;  hyperedges[5] = 4; // Hyperedge 1
+    hyperedges[6] = 3;  hyperedges[7] = 4; hyperedges[8] = 6;                     // Hyperedge 2
+    hyperedges[9] = 2; hyperedges[10] = 5; hyperedges[11] = 6;                    // Hyperedge 3
+
+    mt_kahypar_hypergraph_t hypergraph = mt_kahypar_create_hypergraph(
+      context, num_vertices, num_hyperedges, hyperedge_indices.get(), hyperedges.get(), nullptr, nullptr, &error);
+
+    std::unique_ptr<mt_kahypar_partition_id_t[]> partition = std::make_unique<mt_kahypar_partition_id_t[]>(7);
+    partition[0] = 0; partition[1] = 0; partition[2] = 0;
+    partition[3] = 1; partition[4] = 1; partition[5] = 1; partition[6] = 1;
+
+    mt_kahypar_partitioned_hypergraph_t partitioned_hg =
+      mt_kahypar_create_partitioned_hypergraph(hypergraph, context, 2, partition.get());
+
+    ASSERT_EQ(2, mt_kahypar_km1(partitioned_hg));
+    ASSERT_EQ(2, mt_kahypar_num_blocks(partitioned_hg));
+    ASSERT_EQ(3, mt_kahypar_block_weight(partitioned_hg, 0));
+    ASSERT_EQ(4, mt_kahypar_block_weight(partitioned_hg, 1));
+    for ( mt_kahypar_hypernode_id_t hn = 0; hn < 7; ++hn ) {
+      ASSERT_EQ(partition[hn], mt_kahypar_block_id(partitioned_hg, hn));
+    }
+
+    ASSERT_EQ(1, mt_kahypar_num_incident_cut_hyperedges(partitioned_hg, 0));
+    ASSERT_EQ(1, mt_kahypar_num_incident_cut_hyperedges(partitioned_hg, 6));
+
+    ASSERT_EQ(1, mt_kahypar_connectivity(partitioned_hg, 0));
+    ASSERT_EQ(2, mt_kahypar_connectivity(partitioned_hg, 1));
+    ASSERT_EQ(1, mt_kahypar_connectivity(partitioned_hg, 2));
+    ASSERT_EQ(2, mt_kahypar_connectivity(partitioned_hg, 3));
+
+    ASSERT_EQ(2, mt_kahypar_num_pins_in_block(partitioned_hg, 0, 0));
+    ASSERT_EQ(0, mt_kahypar_num_pins_in_block(partitioned_hg, 0, 1));
+    ASSERT_EQ(2, mt_kahypar_num_pins_in_block(partitioned_hg, 1, 0));
+    ASSERT_EQ(2, mt_kahypar_num_pins_in_block(partitioned_hg, 1, 1));
+    ASSERT_EQ(0, mt_kahypar_num_pins_in_block(partitioned_hg, 2, 0));
+    ASSERT_EQ(3, mt_kahypar_num_pins_in_block(partitioned_hg, 2, 1));
+    ASSERT_EQ(1, mt_kahypar_num_pins_in_block(partitioned_hg, 3, 0));
+    ASSERT_EQ(2, mt_kahypar_num_pins_in_block(partitioned_hg, 3, 1));
+
+    mt_kahypar_free_hypergraph(hypergraph);
+    mt_kahypar_free_partitioned_hypergraph(partitioned_hg);
+  }
+
   TEST(MtKaHyPar, WritesAndLoadsGraphPartitionFile) {
     mt_kahypar_error_t error;
     mt_kahypar_context_t* context = mt_kahypar_context_from_preset(DEFAULT);