chore: updated igraph core, added compatibility alias for the allowed_edge_types argument of rewire()

Author: ntamas

src/_igraph/graphobject.c

@@ -3563,24 +3563,22 @@ PyObject *igraphmodule_Graph_SBM(PyTypeObject * type,
 {
   igraphmodule_GraphObject *self;
   igraph_t g;
-  Py_ssize_t n;
   PyObject *block_sizes_o, *pref_matrix_o;
   PyObject *directed_o = Py_False;
   PyObject *loops_o = Py_False;
+  PyObject *multiple_o = Py_False;
   igraph_matrix_t pref_matrix;
   igraph_vector_int_t block_sizes;
 
-  static char *kwlist[] = { "n", "pref_matrix", "block_sizes", "directed",
-    "loops", NULL };
+  static char *kwlist[] = { "pref_matrix", "block_sizes", "directed",
+    "loops", "multiple", NULL };
 
-  if (!PyArg_ParseTupleAndKeywords(args, kwds, "nOO|OO", kwlist,
-                                   &n, &pref_matrix_o,
+  if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO|OOO", kwlist,
+                                   &pref_matrix_o,
                                    &block_sizes_o,
-                                   &directed_o, &loops_o))
+                                   &directed_o, &loops_o, &multiple_o))
     return NULL;
 
-  CHECK_SSIZE_T_RANGE(n, "vertex count");
-
   if (igraphmodule_PyObject_to_matrix_t(pref_matrix_o, &pref_matrix, "pref_matrix")) {
     return NULL;
   }
@@ -3590,7 +3588,7 @@ PyObject *igraphmodule_Graph_SBM(PyTypeObject * type,
     return NULL;
   }
 
-  if (igraph_sbm_game(&g, n, &pref_matrix, &block_sizes, PyObject_IsTrue(directed_o), PyObject_IsTrue(loops_o))) {
+  if (igraph_sbm_game(&g, &pref_matrix, &block_sizes, PyObject_IsTrue(directed_o), PyObject_IsTrue(loops_o), PyObject_IsTrue(multiple_o))) {
     igraphmodule_handle_igraph_error();
     igraph_matrix_destroy(&pref_matrix);
     igraph_vector_int_destroy(&block_sizes);
@@ -14760,13 +14758,15 @@ struct PyMethodDef igraphmodule_Graph_methods[] = {
    "vertex pair is evaluated and an edge is created between them with a\n"
    "probability depending on the types of the vertices involved. The\n"
    "probabilities are taken from the preference matrix.\n\n"
-   "@param n: the number of vertices in the graph\n"
    "@param pref_matrix: matrix giving the connection probabilities for\n"
-   "  different vertex types.\n"
+   "  different vertex types (when C{multiple} = C{False}) or the expected\n"
+   "  number of edges between a vertex pair (when C{multiple} = C{True}).\n"
    "@param block_sizes: list giving the number of vertices in each block; must\n"
    "  sum up to I{n}.\n"
    "@param directed: whether to generate a directed graph.\n"
-   "@param loops: whether loop edges are allowed.\n"},
+   "@param loops: whether loop edges are allowed.\n"
+   "@param multiple: whether multiple edges are allowed.\n"
+  },
 
   // interface to igraph_star
   {"Star", (PyCFunction) igraphmodule_Graph_Star,
@@ -16279,18 +16279,11 @@ struct PyMethodDef igraphmodule_Graph_methods[] = {
   },
 
   /* interface to igraph_rewire */
-  {"rewire", (PyCFunction) igraphmodule_Graph_rewire,
+  {"_rewire", (PyCFunction) igraphmodule_Graph_rewire,
    METH_VARARGS | METH_KEYWORDS,
-   "rewire(n=None, allowed_edge_types=\"simple\")\n--\n\n"
-   "Randomly rewires the graph while preserving the degree distribution.\n\n"
-   "The rewiring is done \"in-place\", so the original graph will be modified.\n"
-   "If you want to preserve the original graph, use the L{copy} method before\n"
-   "rewiring.\n\n"
-   "@param n: the number of rewiring trials. The default is 10 times the number\n"
-   "  of edges.\n"
-   "@param allowed_edge_types: the rewiring algorithm to use. It can either be C{\"simple\"} or\n"
-   "  C{\"loops\"}; the former does not create or destroy loop edges while the\n"
-   "  latter does.\n"},
+   "_rewire(n=None, allowed_edge_types=\"simple\")\n--\n\n"
+   "Internal function, undocumented.\n\n"
+   "@see: Graph.rewire()\n\n"},
 
   /* interface to igraph_rewire_edges */
   {"rewire_edges", (PyCFunction) igraphmodule_Graph_rewire_edges,

src/igraph/__init__.py

@@ -239,6 +239,7 @@
     intersection,
     operator_method_registry as _operator_method_registry,
 )
+from igraph.rewiring import _rewire
 from igraph.seq import EdgeSeq, VertexSeq, _add_proxy_methods
 from igraph.statistics import (
     FittedPowerLaw,
@@ -632,6 +633,7 @@ def es(self):
     disjoint_union = _operator_method_registry["disjoint_union"]
     union = _operator_method_registry["union"]
     intersection = _operator_method_registry["intersection"]
+    rewire = _rewire
 
     #############################################
     # Adjacency/incidence
@@ -1152,6 +1154,7 @@ def write(graph, filename, *args, **kwds):
     _cohesive_blocks,
     _connected_components,
     _add_proxy_methods,
+    _rewire,
 )
 
 # Re-export from _igraph for API docs
@@ -1267,8 +1270,6 @@ def write(graph, filename, *args, **kwds):
     "GET_ADJACENCY_UPPER",
     "IN",
     "OUT",
-    "REWIRING_SIMPLE",
-    "REWIRING_SIMPLE_LOOPS",
     "STAR_IN",
     "STAR_MUTUAL",
     "STAR_OUT",

src/igraph/rewiring.py

@@ -0,0 +1,25 @@
+from igraph._igraph import GraphBase
+
+from .utils import deprecated
+
+__all__ = ("_rewire", )
+
+
+def _rewire(graph, n=None, allowed_edge_types="simple", *, mode=None):
+    """Randomly rewires the graph while preserving the degree distribution.
+
+    The rewiring is done \"in-place\", so the original graph will be modified.
+    If you want to preserve the original graph, use the L{copy} method before
+    rewiring.
+
+    @param n: the number of rewiring trials. The default is 10 times the number
+        of edges.
+    @param allowed_edge_types: the rewiring algorithm to use. It can either be
+        C{"simple"} or C{"loops"}; the former does not create or destroy
+        loop edges while the latter does.
+    """
+    if mode is not None:
+        deprecated("The 'mode' keyword argument is deprecated, use 'allowed_edge_types' instead")
+        allowed_edge_types = mode
+
+    return GraphBase._rewire(graph, n, allowed_edge_types)

tests/test_generators.py

@@ -429,9 +429,8 @@ def testLattice(self):
 
     def testSBM(self):
         pref_matrix = [[0.5, 0, 0], [0, 0, 0.5], [0, 0.5, 0]]
-        n = 60
         types = [20, 20, 20]
-        g = Graph.SBM(n, pref_matrix, types)
+        g = Graph.SBM(pref_matrix, types)
 
         # Simple smoke tests for the expected structure of the graph
         self.assertTrue(g.is_simple())
@@ -441,21 +440,19 @@ def testSBM(self):
         self.assertTrue(not any(e.source // 20 == e.target // 20 for e in g2.es))
 
         # Check loops argument
-        g = Graph.SBM(n, pref_matrix, types, loops=True)
+        g = Graph.SBM(pref_matrix, types, loops=True)
         self.assertFalse(g.is_simple())
         self.assertTrue(sum(g.is_loop()) > 0)
 
         # Check directedness
-        g = Graph.SBM(n, pref_matrix, types, directed=True)
+        g = Graph.SBM(pref_matrix, types, directed=True)
         self.assertTrue(g.is_directed())
         self.assertTrue(sum(g.is_mutual()) < g.ecount())
         self.assertTrue(sum(g.is_loop()) == 0)
 
         # Check error conditions
-        self.assertRaises(ValueError, Graph.SBM, -1, pref_matrix, types)
-        self.assertRaises(InternalError, Graph.SBM, 61, pref_matrix, types)
         pref_matrix[0][1] = 0.7
-        self.assertRaises(InternalError, Graph.SBM, 60, pref_matrix, types)
+        self.assertRaises(InternalError, Graph.SBM, pref_matrix, types)
 
     def testTriangularLattice(self):
         g = Graph.Triangular_Lattice([2, 2])