passagemath-polyhedra 10.6.31rc3__cp314-cp314-macosx_13_0_arm64.whl

sage/numerical/backends/interactivelp_backend_test.py

@@ -0,0 +1,12 @@
+# sage_setup: distribution = sagemath-polyhedra
+import pytest
+from sage.numerical.backends.generic_backend_test import GenericBackendTests
+from sage.numerical.backends.generic_backend import GenericBackend
+from sage.numerical.mip import MixedIntegerLinearProgram
+
+
+class TestInteractiveLPBackend(GenericBackendTests):
+
+    @pytest.fixture
+    def backend(self) -> GenericBackend:
+        return MixedIntegerLinearProgram(solver='InteractiveLP').get_backend()

sage/numerical/backends/logging_backend.py

@@ -0,0 +1,391 @@
+# sage_setup: distribution = sagemath-polyhedra
+r"""
+Logging Backend
+
+It records, for debugging and unit testing purposes, all calls to
+backend methods in one of three ways.
+
+See :class:`LoggingBackendFactory` for more information.
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2016 Matthias Koeppe <mkoeppe@math.ucdavis.edu>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License 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 sage.numerical.backends.generic_backend import GenericBackend
+
+
+def _format_function_call(fn_name, *v, **k):
+    """
+    Return a Python function call as a string.
+
+    EXAMPLES::
+
+        sage: from sage.numerical.backends.logging_backend import _format_function_call
+        sage: _format_function_call('foo', 17, hellooooo='goodbyeeee')
+        "foo(17, hellooooo='goodbyeeee')"
+    """
+    args = [repr(a) for a in v] + ["%s=%r" % (arg, val) for arg, val in k.items()]
+    return "{}({})".format(fn_name, ", ".join(args))
+
+
+def _make_wrapper(backend, attr):
+    """
+    Return a wrapper for the backend method named by ``attr`` that does the logging.
+
+    Documentation and other metadata is copied from the `backend` method named ``attr``.
+
+    EXAMPLES::
+
+        sage: from sage.numerical.backends.generic_backend import get_solver
+        sage: from sage.numerical.backends.logging_backend import _make_wrapper, LoggingBackend
+        sage: backend = get_solver(solver='GLPK')
+        sage: w = _make_wrapper(backend, 'ncols')
+        sage: logging_backend = LoggingBackend(backend)
+        sage: w(logging_backend)
+        # p.ncols()
+        # result: 0
+        0
+    """
+    def m(self, *args, **kwdargs):
+        funcall = _format_function_call("p." + attr, *args, **kwdargs)
+        a = getattr(self._backend, attr)
+        if self._printing:
+            print("# {}".format(funcall))
+        if self._doctest:
+            self._doctest.write("        sage: {}\n".format(funcall))
+        try:
+            result = a(*args, **kwdargs)
+        except Exception as e:
+            if self._printing:
+                print("# exception: {}".format(e))
+            if self._doctest:
+                self._doctest.write("        Traceback (most recent call last):\n"
+                                    "        ...\n"
+                                    "        MIPSolverException: {}\n".format(e))
+            if self._test_method:
+                self._test_method.write(("        with tester.assertRaises({}) as cm:\n" +
+                                         "            {}\n").format(type(e).__name__, funcall))
+            raise
+        else:
+            if self._printing:
+                print("# result: {}".format(result))
+            if self._doctest:
+                self._doctest.write("        {}\n".format(result))
+            if self._test_method:
+                if result is None:
+                    self._test_method.write("        tester.assertIsNone({})\n".format(funcall))
+                elif type(result) is float:
+                    # TODO: by default assertAlmostEqual does 7 decimal places (not significant digits)
+                    # better perhaps to compute an appropriate 'places' or 'delta' parameter from result.
+                    self._test_method.write("        tester.assertAlmostEqual({}, {})\n".format(funcall, result))
+                else:
+                    self._test_method.write("        tester.assertEqual({}, {})\n".format(funcall, result))
+        return result
+    from functools import update_wrapper
+    update_wrapper(m, getattr(backend, attr))
+    return m
+
+
+class LoggingBackend(GenericBackend):
+    """
+    See :class:`LoggingBackendFactory` for documentation.
+
+    EXAMPLES::
+
+        sage: import sage.numerical.backends.logging_backend
+        sage: from sage.numerical.backends.logging_backend import LoggingBackend
+        sage: from sage.numerical.backends.generic_backend import get_solver
+        sage: b = get_solver(solver = "GLPK")
+        sage: lb = LoggingBackend(backend=b)
+        sage: lb.add_variable(obj=42, name='Helloooooo')
+        # p.add_variable(obj=42, name='Helloooooo')
+        # result: 0
+        0
+        sage: lb.add_variable(obj=1789)
+        # p.add_variable(obj=1789)
+        # result: 1
+        1
+
+    .. :no-undoc-members:
+    """
+
+    def __init__(self, backend, printing=True, doctest=None, test_method=None,
+                 base_ring=None):
+        """
+        See :class:`LoggingBackendFactory` for documentation.
+
+        EXAMPLES::
+
+            sage: import sage.numerical.backends.logging_backend
+            sage: from sage.numerical.backends.logging_backend import LoggingBackend
+            sage: from sage.numerical.backends.generic_backend import get_solver
+            sage: b = get_solver(solver = "GLPK")
+            sage: lb = LoggingBackend(backend=b)
+        """
+        self._backend = backend
+        self._printing = printing
+        self._doctest = doctest
+        self._test_method = test_method
+        self._base_ring = base_ring
+
+    def __getattr__(self, attr):
+        """
+        Look up an attribute in the instance.
+
+        It is provided to dynamically create delegating methods for all methods of
+        the backend that are not part of the :class:`GenericBackend` interface,
+        from which :class:`LoggingBackend` inherits.
+
+        EXAMPLES::
+
+            sage: import sage.numerical.backends.logging_backend
+            sage: from sage.numerical.backends.logging_backend import LoggingBackend
+            sage: from sage.numerical.backends.generic_backend import get_solver
+            sage: b = get_solver(solver = "GLPK")
+            sage: lb = LoggingBackend(backend=b)
+            sage: lb.print_ranges
+            <bound method ...>
+        """
+        _a = getattr(self._backend, attr)
+        if callable(_a):
+            # make a bound method
+            import types
+            _mm = types.MethodType(_make_wrapper(self._backend, attr), self)
+            # cache it
+            setattr(self, attr, _mm)
+            return _mm
+        else:
+            return _a
+
+    def base_ring(self):
+        """
+        Return the base ring.
+
+        The backend's base ring can be overridden.  It is best to run
+        the tests with GLPK and override the base ring to ``QQ``.  Then
+        default input to backend methods, prepared by
+        :class:`MixedIntegerLinearProgram`, depends on the base ring.
+        This way input will be rational and so suitable for both exact
+        and inexact methods; whereas output will be float and will thus
+        trigger :func:`assertAlmostEqual` tests.
+
+        EXAMPLES::
+
+            sage: import sage.numerical.backends.logging_backend
+            sage: from sage.numerical.backends.logging_backend import LoggingBackend
+            sage: from sage.numerical.backends.generic_backend import get_solver
+            sage: b = get_solver(solver = "GLPK")
+            sage: lb = LoggingBackend(backend=b)
+            sage: lb.base_ring()
+            Real Double Field
+            sage: from sage.rings.rational_field import QQ
+            sage: lb = LoggingBackend(backend=b, base_ring=QQ)
+            sage: lb.base_ring()
+            Rational Field
+        """
+        if self._base_ring is not None:
+            return self._base_ring
+        else:
+            return self._backend.base_ring()
+
+
+# Override all methods that we inherited from GenericBackend
+# by delegating methods
+def _override_attr(attr):
+    """
+    Override a method by a delegating method.
+    """
+    a = getattr(LoggingBackend, attr)
+    if callable(a):
+        m = _make_wrapper(GenericBackend(), attr)
+        setattr(LoggingBackend, attr, m)
+
+
+for attr in dir(LoggingBackend):
+    if not attr.startswith("_") and attr not in ("zero", "base_ring"):
+        _override_attr(attr)
+
+test_method_template = \
+r'''
+    @classmethod
+    def _test_{name}(cls, tester=None, **options):
+        """
+        Run tests on ...
+
+        TESTS::
+
+            SAGE: from sage.numerical.backends.generic_backend import GenericBackend
+            SAGE: p = GenericBackend()
+            SAGE: p._test_{name}()
+            Traceback (most recent call last):
+            ...
+            NotImplementedError
+        """
+        p = cls()                         # fresh instance of the backend
+        if tester is None:
+            tester = p._tester(**options)
+'''.replace("SAGE:", "sage:") # so that the above test does not get picked up by the doctester
+
+from sage.rings.rational_field import QQ
+
+
+def LoggingBackendFactory(solver=None, printing=True, doctest_file=None, test_method_file=None,
+                          test_method=None, base_ring=QQ):
+    """
+    Factory that constructs a :class:`LoggingBackend` for debugging and testing.
+
+    An instance of it can be passed as the solver argument of
+    :func:`sage.numerical.backends.generic_backend.get_solver` and
+    :class:`MixedIntegerLinearProgram`.
+
+    EXAMPLES:
+
+    Assume that we have the following function that does some
+    computation using :class:`MixedIntegerLinearProgram` (or MIP
+    backend methods), and suppose we have observed that it works with
+    the GLPK backend, but not with the COIN backend::
+
+        sage: def compute_something(solver='GLPK'):
+        ....:     from sage.numerical.mip import MIPSolverException
+        ....:     mip = MixedIntegerLinearProgram(solver=solver)
+        ....:     lb = mip.get_backend()
+        ....:     lb.add_variable(obj=42, name='Helloooooo')
+        ....:     lb.add_variable(obj=1789)
+        ....:     try:
+        ....:         lb.solve()
+        ....:     except MIPSolverException:
+        ....:         return 4711
+        ....:     else:
+        ....:         return 91
+
+    We can investigate what the backend methods are doing by running a
+    :class:`LoggingBackend` in its in-terminal logging mode::
+
+        sage: import sage.numerical.backends.logging_backend
+        sage: from sage.numerical.backends.logging_backend import LoggingBackendFactory
+        sage: compute_something(solver = LoggingBackendFactory(solver='GLPK'))
+        # p = get_solver(solver='GLPK')
+        # p.add_variable(obj=42, name='Helloooooo')
+        # result: 0
+        # p.add_variable(obj=1789)
+        # result: 1
+        # p.solve()
+        # exception: GLPK: The LP (relaxation) problem has no dual feasible solution
+        4711
+
+    By replacing 'GLPK' by 'COIN' above, we can then compare the two
+    logs and see where they differ.
+
+    Imagine that we have now fixed the bug in the COIN backend, and we
+    want to add a doctest that documents this fact.  We do not want to
+    call ``compute_something`` in the doctest, but rather just have a
+    sequence of calls to backend methods.
+
+    We can have the doctest autogenerated by running a
+    :class:`LoggingBackend` in its doctest-writing mode::
+
+        sage: fname = tmp_filename()
+        sage: compute_something(solver = LoggingBackendFactory(solver='GLPK', printing=False,
+        ....:                                                  doctest_file=fname))
+        4711
+        sage: with open(fname) as f:
+        ....:     for line in f.readlines(): _ = sys.stdout.write('|{}'.format(line))
+        |        sage: p = get_solver(solver='GLPK')
+        |        sage: p.add_variable(obj=42, name='Helloooooo')
+        |        0
+        |        sage: p.add_variable(obj=1789)
+        |        1
+        |        sage: p.solve()
+        |        Traceback (most recent call last):
+        |        ...
+        |        MIPSolverException: GLPK: The LP (relaxation) problem has no dual feasible solution
+
+    We then copy from the generated file and paste into the source
+    code of the COIN backend.
+
+    If this test seems valuable enough that all backends should be
+    tested against it, we should create a test method instead of a
+    docstring.
+
+    We can have the test method autogenerated by running a
+    :class:`LoggingBackend` in its test-method-writing mode::
+
+        sage: fname = tmp_filename()
+        sage: compute_something(solver= LoggingBackendFactory(solver='GLPK', printing=False,
+        ....:                                                 test_method_file=fname,
+        ....:                                                 test_method='something'))
+        4711
+        sage: with open(fname) as f:
+        ....:     for line in f.readlines(): _ = sys.stdout.write('|{}'.format(line))
+        |
+        |    @classmethod
+        |    def _test_something(cls, tester=None, **options):
+        |        ...
+        |        Run tests on ...
+        |
+        |        TESTS::
+        |
+        |            sage: from sage.numerical.backends.generic_backend import GenericBackend
+        |            sage: p = GenericBackend()
+        |            sage: p._test_something()
+        |            Traceback (most recent call last):
+        |            ...
+        |            NotImplementedError
+        |        ...
+        |        p = cls()                         # fresh instance of the backend
+        |        if tester is None:
+        |            tester = p._tester(**options)
+        |        tester.assertEqual(p.add_variable(obj=42, name='Helloooooo'), 0)
+        |        tester.assertEqual(p.add_variable(obj=1789), 1)
+        |        with tester.assertRaises(MIPSolverException) as cm:
+        |            p.solve()
+
+    We then copy from the generated file and paste into the source
+    code of the generic backend, where all test methods are defined.
+
+    If ``test_method_file`` is not provided, a default output file name
+    will be computed from ``test_method``.
+    """
+
+    if test_method is not None:
+        if test_method_file is None:
+            # Construct output file name from method name.
+            test_method_file = "test_{}.py".format(test_method)
+    else:
+        test_method = 'CHANGE'
+        # Will have to be edited by user in generated file.
+
+    if doctest_file is not None:
+        doctest = open(doctest_file, "w", 1)  # line-buffered
+    else:
+        doctest = None
+    if test_method_file is not None:
+        test_method_output = open(test_method_file, "w", 1)  # line-buffered
+    else:
+        test_method_output = None
+
+    def logging_solver(**kwds):
+        """
+        Create an instance of :class:`LoggingBackend`.
+        """
+        construct = "p = {}".format(_format_function_call('get_solver', solver=solver, **kwds))
+        if printing:
+            print("# {}".format(construct))
+        if doctest is not None:
+            doctest.write("        sage: {}\n".format(construct))
+        if test_method_output is not None:
+            test_method_output.write(test_method_template.format(name=test_method))
+        from sage.numerical.backends.generic_backend import get_solver
+        return LoggingBackend(backend=get_solver(solver=solver, **kwds),
+                              printing=printing, doctest=doctest, test_method=test_method_output,
+                              base_ring=base_ring)
+
+    return logging_solver

sage/numerical/backends/matrix_sdp_backend.pxd

@@ -0,0 +1,15 @@
+# sage_setup: distribution = sagemath-polyhedra
+from sage.numerical.backends.generic_sdp_backend cimport GenericSDPBackend
+
+
+cdef class MatrixSDPBackend(GenericSDPBackend):
+
+    cdef list objective_function
+    cdef list coeffs_matrix
+    cdef bint is_maximize
+
+    cdef list row_name_var
+    cdef list col_name_var
+    cdef str name
+
+    cdef object _base_ring