passagemath-cliquer 10.6.32__cp314-cp314t-musllinux_1_2_x86_64.whl

passagemath_cliquer-10.6.32.dist-info/METADATA

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: passagemath-cliquer
+Version: 10.6.32
+Summary: passagemath: Finding cliques in graphs with cliquer
+Author-email: The Sage Developers <sage-support@googlegroups.com>
+Maintainer: Matthias Köppe, passagemath contributors
+License-Expression: GPL-2.0-or-later
+Project-URL: release notes, https://github.com/passagemath/passagemath/releases
+Project-URL: repo (upstream), https://github.com/sagemath/sage
+Project-URL: repo, https://github.com/passagemath/passagemath
+Project-URL: documentation, https://passagemath.org/docs/latest
+Project-URL: homepage (upstream), https://www.sagemath.org
+Project-URL: discourse, https://passagemath.discourse.group
+Project-URL: tracker (upstream), https://github.com/sagemath/sage/issues
+Project-URL: tracker, https://github.com/passagemath/passagemath/issues
+Classifier: Development Status :: 6 - Mature
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: <3.15,>=3.10
+Description-Content-Type: text/x-rst
+Provides-Extra: test
+Requires-Dist: passagemath-graphs; extra == "test"
+Requires-Dist: passagemath-repl; extra == "test"
+
+===============================================================================
+passagemath: Finding cliques in graphs with cliquer
+===============================================================================
+
+`passagemath <https://github.com/passagemath/passagemath>`__ is open
+source mathematical software in Python, released under the GNU General
+Public Licence GPLv2+.
+
+It is a fork of `SageMath <https://www.sagemath.org/>`__, which has been
+developed 2005-2025 under the motto “Creating a Viable Open Source
+Alternative to Magma, Maple, Mathematica, and MATLAB”.
+
+The passagemath fork uses the motto "Creating a Free Passage Between the
+Scientific Python Ecosystem and Mathematical Software Communities."
+It was created in October 2024 with the following goals:
+
+-  providing modularized installation with pip,
+-  establishing first-class membership in the scientific Python
+   ecosystem,
+-  giving `clear attribution of upstream
+   projects <https://groups.google.com/g/sage-devel/c/6HO1HEtL1Fs/m/G002rPGpAAAJ>`__,
+-  providing independently usable Python interfaces to upstream
+   libraries,
+-  offering `platform portability and integration testing
+   services <https://github.com/passagemath/passagemath/issues/704>`__
+   to upstream projects,
+-  inviting collaborations with upstream projects,
+-  `building a professional, respectful, inclusive
+   community <https://groups.google.com/g/sage-devel/c/xBzaINHWwUQ>`__,
+-  `empowering Sage users to participate in the scientific Python ecosystem
+   <https://github.com/passagemath/passagemath/issues/248>`__ by publishing packages,
+-  developing a port to `Pyodide <https://pyodide.org/en/stable/>`__ for
+   serverless deployment with Javascript,
+-  developing a native Windows port.
+
+`Full documentation <https://passagemath.org/docs/latest/html/en/index.html>`__ is
+available online.
+
+passagemath attempts to support and provides binary wheels suitable for
+all major Linux distributions and recent versions of macOS.
+
+Binary wheels for native Windows (x86_64) are are available for a subset of
+the passagemath distributions. Use of the full functionality of passagemath
+on Windows currently requires the use of Windows Subsystem for Linux (WSL)
+or virtualization.
+
+The supported Python versions in the passagemath 10.6.x series are 3.10.x-3.13.x.
+
+
+About this pip-installable distribution package
+-----------------------------------------------
+
+This pip-installable distribution ``passagemath-cliquer`` provides an interface
+to `cliquer <https://users.aalto.fi/~pat/cliquer.html>`_, an exact branch-and-bound
+algorithm for finding cliques in an arbitrary weighted graph by Patric Östergård.
+
+
+What is included
+----------------
+
+* `Cython interface to cliquer <https://passagemath.org/docs/latest/html/en/reference/graphs/sage/graphs/cliquer.html>`_
+
+
+Examples
+--------
+
+::
+
+   $ pipx run --pip-args="--prefer-binary" --spec "passagemath-cliquer[test]" ipython
+
+   In [1]: from sage.all__sagemath_cliquer import *
+
+   In [2]: from sage.graphs.cliquer import max_clique
+
+   In [3]: C = graphs.PetersenGraph(); max_clique(C)
+   Out[3]: [7, 9]

passagemath_cliquer-10.6.32.dist-info/RECORD

@@ -0,0 +1,10 @@
+passagemath_cliquer.libs/libcliquer-c696efef.so.1.0.21,sha256=COT0CWjr0I9CI9yUwoiWLFnteviFivzfqX7ljbhwHXI,143049
+sage/all__sagemath_cliquer.py,sha256=jBej4FzxkgjVdTK_hCm3u9rgoYX3_PAHa2mZXK8KvUM,107
+sage/graphs/all__sagemath_cliquer.py,sha256=Rby8pG2esTxBpJcnmT0FiU_RsBsT_mzMEXds-AjXrUI,46
+sage/graphs/cliquer.cpython-314t-x86_64-linux-musl.so,sha256=amSDBULbgH62IY8El9izQhQ0yByu0HmsuHk398CCGiw,722673
+sage/graphs/cliquer.pxd,sha256=NTJnYsne4hPSF65aG6CayHmkTJ3NwEJkngGTV3M7uQ0,654
+sage/graphs/cliquer.pyx,sha256=H2IMZxZu8xeKynaefRM6_8zzCu-w4TVAtcrwp-07Z_U,9640
+passagemath_cliquer-10.6.32.dist-info/METADATA,sha256=-iyLt_HaSz2DKoGLEbdqa8XEXawCu4y3KOSlyfdDhGk,4831
+passagemath_cliquer-10.6.32.dist-info/WHEEL,sha256=zXoM281zyz8wppofreMuq3eZjd9HP4BgZS1rfYnrpIs,113
+passagemath_cliquer-10.6.32.dist-info/top_level.txt,sha256=Kmzulf9WsphADFQuqgvdy5mvTLDj_V2zkFHU2s3UXos,6
+passagemath_cliquer-10.6.32.dist-info/RECORD,,

passagemath_cliquer-10.6.32.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp314-cp314t-musllinux_1_2_x86_64
+

passagemath_cliquer-10.6.32.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+
+sage

sage/all__sagemath_cliquer.py

@@ -0,0 +1,4 @@
+# sage_setup: distribution = sagemath-cliquer
+# delvewheel: patch
+
+from sage.all__sagemath_graphs import *

sage/graphs/all__sagemath_cliquer.py

@@ -0,0 +1 @@
+# sage_setup: distribution = sagemath-cliquer

sage/graphs/cliquer.pxd

@@ -0,0 +1,19 @@
+# sage_setup: distribution = sagemath-cliquer
+# distutils: libraries = cliquer
+
+cdef extern from "cliquer/graph.h":
+    ctypedef struct graph_t
+
+    cdef graph_t * graph_new(int n)
+    cdef void graph_print(graph_t *g)
+    cdef void graph_free(graph_t *g)
+    cdef void GRAPH_ADD_EDGE(graph_t *g, int, int)
+
+cdef extern from "cliquer/cliquer.h":
+    struct clique_options
+
+    bint clique_print_time(intlevel, int i, int n, int max, double cputime, double realtime, clique_options *opts)
+
+cdef extern from "cliquer/reorder.h":
+    cdef int *reorder_by_greedy_coloring(graph_t *g, bint weighted)
+    cdef int *reorder_by_degree(graph_t *g, bint weighted)

sage/graphs/cliquer.pyx

@@ -0,0 +1,331 @@
+# sage_setup: distribution = sagemath-cliquer
+# cython: binding=True
+r"""
+Interface with Cliquer (clique-related problems)
+
+This module defines functions based on Cliquer, an exact
+branch-and-bound algorithm developed by Patric R. J. Ostergard and
+written by Sampo Niskanen.
+
+AUTHORS:
+
+- Nathann Cohen (2009-08-14): Initial version
+
+- Jeroen Demeyer (2011-05-06): Make cliquer interruptible (:issue:`11252`)
+
+- Nico Van Cleemput (2013-05-27): Handle the empty graph (:issue:`14525`)
+
+REFERENCE:
+
+[NO2003]_
+
+Methods
+-------
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2009 Nathann Cohen <nathann.cohen@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#  as published by the Free Software Foundation; either version 2 of
+#  the License, or (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from cysignals.memory cimport sig_free
+from cysignals.signals cimport sig_on, sig_off
+
+
+cdef extern from "cliquer/cl.c":
+    cdef int sage_clique_max(graph_t *g, int ** list_of_vertices)
+    cdef int sage_all_clique_max(graph_t *g, int ** list_of_vertices)
+    cdef int sage_clique_number(graph_t *g)
+    cdef int sage_find_all_clique(graph_t *g, int ** list_of_vertices, int min_size, int max_size)
+
+
+def max_clique(graph):
+    """
+    Return the vertex set of a maximum complete subgraph.
+
+    .. NOTE::
+
+        Currently only implemented for undirected graphs. Use
+        :meth:`~sage.graphs.digraph.DiGraph.to_undirected` to convert a digraph
+        to an undirected graph.
+
+    EXAMPLES::
+
+          sage: C = graphs.PetersenGraph()
+          sage: from sage.graphs.cliquer import max_clique
+          sage: max_clique(C)
+          [7, 9]
+
+    TESTS::
+
+        sage: g = Graph()
+        sage: g.clique_maximum()
+        []
+    """
+    if not graph.order():
+        return []
+
+    cdef int i
+    cdef list int_to_vertex = list(graph)
+    cdef dict vertex_to_int = {v: i for i, v in enumerate(int_to_vertex)}
+
+    cdef graph_t* g = graph_new(graph.order())
+    for u, v in graph.edge_iterator(labels=None):
+        GRAPH_ADD_EDGE(g, vertex_to_int[u], vertex_to_int[v])
+
+    cdef int* list_of_vertices
+    cdef int size
+    sig_on()
+    size = sage_clique_max(g, &list_of_vertices)
+    sig_off()
+    cdef list b = [int_to_vertex[list_of_vertices[i]] for i in range(size)]
+
+    sig_free(list_of_vertices)
+    graph_free(g)
+    return b
+
+
+# computes all the maximum clique of a graph and return its list
+
+def all_max_clique(graph):
+    """
+    Return the vertex sets of *ALL* the maximum complete subgraphs.
+
+    Returns the list of all maximum cliques, with each clique represented by a
+    list of vertices. A clique is an induced complete subgraph, and a maximum
+    clique is one of maximal order.
+
+    .. NOTE::
+
+        Currently only implemented for undirected graphs. Use
+        :meth:`~sage.graphs.digraph.DiGraph.to_undirected` to convert a digraph
+        to an undirected graph.
+
+    ALGORITHM:
+
+    This function is based on Cliquer [NO2003]_.
+
+    EXAMPLES::
+
+        sage: graphs.ChvatalGraph().cliques_maximum() # indirect doctest
+        [[0, 1], [0, 4], [0, 6], [0, 9], [1, 2], [1, 5], [1, 7], [2, 3],
+         [2, 6], [2, 8], [3, 4], [3, 7], [3, 9], [4, 5], [4, 8], [5, 10],
+         [5, 11], [6, 10], [6, 11], [7, 8], [7, 11], [8, 10], [9, 10], [9, 11]]
+        sage: G = Graph({0:[1,2,3], 1:[2], 3:[0,1]})
+        sage: G.show(figsize=[2,2])                                                     # needs sage.plot
+        sage: G.cliques_maximum()
+        [[0, 1, 2], [0, 1, 3]]
+        sage: C = graphs.PetersenGraph()
+        sage: C.cliques_maximum()
+        [[0, 1], [0, 4], [0, 5], [1, 2], [1, 6], [2, 3], [2, 7], [3, 4],
+         [3, 8], [4, 9], [5, 7], [5, 8], [6, 8], [6, 9], [7, 9]]
+        sage: C = Graph('DJ{')
+        sage: C.cliques_maximum()
+        [[1, 2, 3, 4]]
+
+    TESTS::
+
+        sage: g = Graph()
+        sage: g.cliques_maximum()
+        [[]]
+    """
+    if not graph.order():
+        return [[]]
+
+    cdef int i
+    cdef list int_to_vertex = list(graph)
+    cdef dict vertex_to_int = {v: i for i, v in enumerate(int_to_vertex)}
+
+    cdef graph_t* g = graph_new(graph.order())
+    for u, v in graph.edge_iterator(labels=None):
+        GRAPH_ADD_EDGE(g, vertex_to_int[u], vertex_to_int[v])
+
+    cdef int* list_of_vertices
+    cdef int size
+    sig_on()
+    size = sage_all_clique_max(g, &list_of_vertices)
+    sig_off()
+    cdef list b = []
+    cdef list c = []
+    for i in range(size):
+        if list_of_vertices[i] != -1:
+            c.append(int_to_vertex[list_of_vertices[i]])
+        else:
+            b.append(c)
+            c = []
+
+    sig_free(list_of_vertices)
+    graph_free(g)
+
+    return sorted(b)
+
+
+def all_cliques(graph, min_size=0, max_size=0):
+    r"""
+    Iterator over the cliques in ``graph``.
+
+    A clique is an induced complete subgraph. This method is an iterator over
+    all the cliques with size in between ``min_size`` and ``max_size``. By
+    default, this method returns only maximum cliques. Each yielded clique is
+    represented by a list of vertices.
+
+    .. NOTE::
+
+        Currently only implemented for undirected graphs. Use
+        :meth:`~sage.graphs.digraph.DiGraph.to_undirected` to convert a digraph
+        to an undirected graph.
+
+    INPUT:
+
+    - ``min_size`` -- integer (default: 0); minimum size of reported cliques.
+      When set to 0 (default), this method searches for maximum cliques. In such
+      case, parameter ``max_size`` must also be set to 0.
+
+    - ``max_size`` -- integer (default: 0); maximum size of reported cliques.
+      When set to 0 (default), the maximum size of the cliques is unbounded.
+      When ``min_size`` is set to 0, this parameter must be set to 0.
+
+    ALGORITHM:
+
+    This function is based on Cliquer [NO2003]_.
+
+    EXAMPLES::
+
+        sage: G = graphs.CompleteGraph(5)
+        sage: list(sage.graphs.cliquer.all_cliques(G))
+        [[0, 1, 2, 3, 4]]
+        sage: list(sage.graphs.cliquer.all_cliques(G, 2, 3))
+        [[3, 4],
+         [2, 3],
+         [2, 3, 4],
+         [2, 4],
+         [1, 2],
+         [1, 2, 3],
+         [1, 2, 4],
+         [1, 3],
+         [1, 3, 4],
+         [1, 4],
+         [0, 1],
+         [0, 1, 2],
+         [0, 1, 3],
+         [0, 1, 4],
+         [0, 2],
+         [0, 2, 3],
+         [0, 2, 4],
+         [0, 3],
+         [0, 3, 4],
+         [0, 4]]
+        sage: G.delete_edge([1,3])
+        sage: list(sage.graphs.cliquer.all_cliques(G))
+        [[0, 2, 3, 4], [0, 1, 2, 4]]
+
+    TESTS::
+
+        sage: G = graphs.CompleteGraph(3)
+        sage: list(sage.graphs.cliquer.all_cliques(G, 2, 3))
+        [[1, 2], [0, 1], [0, 1, 2], [0, 2]]
+
+        sage: G = graphs.EmptyGraph()
+        sage: list(sage.graphs.cliquer.all_cliques(G, 2, 3))
+        []
+
+        sage: G = Graph([(0, 1), (0, 1)], multiedges=True)
+        sage: list(sage.graphs.cliquer.all_cliques(G, 2, 2))
+        [[0, 1]]
+
+        sage: list(sage.graphs.cliquer.all_cliques(G, 0, 2))
+        Traceback (most recent call last):
+        ...
+        ValueError: max_size > 0 is incompatible with min_size == 0
+
+    .. TODO::
+
+        Use the re-entrant functionality of Cliquer [NO2003]_ to avoid storing
+        all cliques.
+    """
+    if not min_size and max_size > 0:
+        raise ValueError("max_size > 0 is incompatible with min_size == 0")
+    if not graph:
+        return
+
+    cdef int i
+    cdef list int_to_vertex = list(graph)
+    cdef dict vertex_to_int = {v: i for i, v in enumerate(int_to_vertex)}
+
+    cdef graph_t* g = graph_new(graph.order())
+    for u, v in graph.edge_iterator(labels=None):
+        GRAPH_ADD_EDGE(g, vertex_to_int[u], vertex_to_int[v])
+
+    cdef int* list_of_vertices
+    cdef int size = 0
+    cdef list c
+    try:
+        try:
+            sig_on()
+            size = sage_find_all_clique(g, &list_of_vertices, min_size, max_size)
+            sig_off()
+        finally:
+            graph_free(g)
+        c = []
+        for i in range(size):
+            if list_of_vertices[i] != -1:
+                c.append(int_to_vertex[list_of_vertices[i]])
+            else:
+                yield c
+                c = []
+    finally:
+        if list_of_vertices:
+            # We free ``list_of_vertices``,
+            # but only if previous computations weren't interrupted before
+            # allocating memory for ``list_of_vertices``.
+            sig_free(list_of_vertices)
+
+
+# computes the clique number of a graph
+
+def clique_number(graph):
+    """
+    Return the size of the largest clique of the graph (clique number).
+
+    .. NOTE::
+
+        Currently only implemented for undirected graphs. Use
+        :meth:`~sage.graphs.digraph.DiGraph.to_undirected` to convert a digraph
+        to an undirected graph.
+
+    EXAMPLES::
+
+        sage: C = Graph('DJ{')
+        sage: C.clique_number()
+        4
+        sage: G = Graph({0:[1,2,3], 1:[2], 3:[0,1]})
+        sage: G.show(figsize=[2,2])                                                     # needs sage.plot
+        sage: G.clique_number()
+        3
+
+    TESTS::
+
+        sage: g = Graph()
+        sage: g.clique_number()
+        0
+    """
+    if not graph.order():
+        return 0
+
+    cdef int i
+    cdef dict vertex_to_int = {v: i for i, v in enumerate(graph)}
+
+    cdef graph_t* g = graph_new(graph.order())
+    for u, v in graph.edge_iterator(labels=None):
+        GRAPH_ADD_EDGE(g, vertex_to_int[u], vertex_to_int[v])
+
+    cdef int c
+    sig_on()
+    c = sage_clique_number(g)
+    graph_free(g)
+    sig_off()
+    return c