passagemath-repl 10.5.1__py3-none-any.whl

sage/misc/benchmark.py

@@ -0,0 +1,221 @@
+# sage_setup: distribution = sagemath-repl
+# sage.doctest: needs sage.all
+"Benchmarks"
+
+from sage.misc.misc import cputime
+
+from sage.all import *
+
+
+def benchmark(n=-1):
+    """
+    Run a well-chosen range of Sage commands and record the time it
+    takes for each to run.
+
+    INPUT:
+
+    - ``n`` -- integer (default: -1); the benchmark number; the default
+      of -1 runs all the benchmarks
+
+    OUTPUT:
+
+        list -- summary of timings for each benchmark.
+        int -- if n == -1, also return the total time
+
+    EXAMPLES::
+
+        sage: from sage.misc.benchmark import *
+        sage: _ = benchmark()
+        Running benchmark 0
+        Benchmark 0: Factor the following polynomial over
+            the rational numbers: (x^97+19*x+1)*(x^103-19*x^97+14)*(x^100-1)
+        Time: ... seconds
+        Running benchmark 1
+        Find the Mordell-Weil group of the elliptic curve 5077A using mwrank
+        Time: ... seconds
+        Running benchmark 2
+        Some basic arithmetic with very large Integer numbers: '3^1000001 * 19^100001
+        Time: ... seconds
+        Running benchmark 3
+        Some basic arithmetic with very large Rational numbers: '(2/3)^100001 * (17/19)^100001
+        Time: ... seconds
+        Running benchmark 4
+        Rational polynomial arithmetic using Sage. Compute (x^29+17*x-5)^200.
+        Time: ... seconds
+        Running benchmark 5
+        Rational polynomial arithmetic using Sage. Compute (x^19 - 18*x + 1)^50 one hundred times.
+        Time: ... seconds
+        Running benchmark 6
+        Compute the p-division polynomials of y^2 = x^3 + 37*x - 997 for primes p < 40.
+        Time: ... seconds
+        Running benchmark 7
+        Compute the Mordell-Weil group of y^2 = x^3 + 37*x - 997.
+        Time: ... seconds
+        Running benchmark 8
+    """
+
+    if isinstance(n, list):
+        t = cputime()
+        v = [benchmark(m) for m in n]
+        return v, cputime(t)
+
+    if n != -1:
+        print("Running benchmark {}".format(n))
+        try:
+            desc, t = eval("bench{}()".format(n))
+        except NameError:
+            raise RuntimeError("no benchmark {}".format(n))
+        print(desc)
+        print("Time: {} seconds".format(t))
+        return (n, t, desc)
+
+    t = cputime()
+    m = 0
+    v = []
+    while True:
+        try:
+            v.append(benchmark(m))
+            m += 1
+        except RuntimeError:
+            break
+    return v, cputime(t)
+
+
+def bench0():
+    """
+    Run a benchmark.
+
+    BENCHMARK::
+
+        sage: from sage.misc.benchmark import *
+        sage: print(bench0()[0])
+        Benchmark 0: Factor the following polynomial over
+            the rational numbers: (x^97+19*x+1)*(x^103-19*x^97+14)*(x^100-1)
+    """
+    desc = """Benchmark 0: Factor the following polynomial over
+    the rational numbers: (x^97+19*x+1)*(x^103-19*x^97+14)*(x^100-1)"""
+    x = polygen(QQ, "x")
+    f = (x**97+19*x+1)*(x**103-19*x**97+14)*(x**100-1)
+    t = cputime()
+    F = f.factor()
+    return (desc, cputime(t))
+
+
+def bench1():
+    """
+    Run a benchmark.
+
+    BENCHMARK::
+
+        sage: from sage.misc.benchmark import *
+        sage: print(bench1()[0])
+        Find the Mordell-Weil group of the elliptic curve 5077A using mwrank
+    """
+    desc = """Find the Mordell-Weil group of the elliptic curve 5077A using mwrank"""
+    E = mwrank_EllipticCurve([0, 0, 1, -7, 6])
+    t = cputime()
+    g = E.gens()
+    return (desc, cputime(t))
+
+
+def bench2():
+    """
+    Run a benchmark.
+
+    BENCHMARK::
+
+        sage: from sage.misc.benchmark import *
+        sage: print(bench2()[0])
+        Some basic arithmetic with very large Integer numbers: '3^1000001 * 19^100001
+    """
+    desc = """Some basic arithmetic with very large Integer numbers: '3^1000001 * 19^100001"""
+    t = cputime()
+    a = ZZ(3)**1000001 * ZZ(19)**100001
+    return (desc, cputime(t))
+
+
+def bench3():
+    """
+    Run a benchmark.
+
+    BENCHMARK::
+
+        sage: from sage.misc.benchmark import *
+        sage: print(bench3()[0])
+        Some basic arithmetic with very large Rational numbers: '(2/3)^100001 * (17/19)^100001
+    """
+    desc = """Some basic arithmetic with very large Rational numbers: '(2/3)^100001 * (17/19)^100001"""
+    t = cputime()
+    a = QQ((2, 3))**100001 * QQ((17, 19))**100001
+    return (desc, cputime(t))
+
+
+def bench4():
+    """
+    Run a benchmark.
+
+    BENCHMARK::
+
+        sage: from sage.misc.benchmark import *
+        sage: print(bench4()[0])
+        Rational polynomial arithmetic using Sage. Compute (x^29+17*x-5)^200.
+    """
+    desc = """Rational polynomial arithmetic using Sage. Compute (x^29+17*x-5)^200."""
+    x = PolynomialRing(QQ, 'x').gen()
+    t = cputime()
+    f = x**29 + 17*x-5
+    a = f**200
+    return (desc, cputime(t))
+
+
+def bench5():
+    """
+    Run a benchmark.
+
+    BENCHMARK::
+
+        sage: from sage.misc.benchmark import *
+        sage: print(bench5()[0])
+        Rational polynomial arithmetic using Sage. Compute (x^19 - 18*x + 1)^50 one hundred times.
+    """
+    desc = """Rational polynomial arithmetic using Sage. Compute (x^19 - 18*x + 1)^50 one hundred times."""
+    x = PolynomialRing(QQ, 'x').gen()
+    t = cputime()
+    f = x**19 - 18*x + 1
+    w = [f**50 for _ in range(100)]
+    return (desc, cputime(t))
+
+
+def bench6():
+    """
+    Run a benchmark.
+
+    BENCHMARK::
+
+        sage: from sage.misc.benchmark import *
+        sage: print(bench6()[0])
+        Compute the p-division polynomials of y^2 = x^3 + 37*x - 997 for primes p < 40.
+    """
+    desc = """Compute the p-division polynomials of y^2 = x^3 + 37*x - 997 for primes p < 40."""
+    E = EllipticCurve([0, 0, 0, 37, -997])
+    t = cputime()
+    for p in [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]:
+        f = E.division_polynomial(p)
+    return (desc, cputime(t))
+
+
+def bench7():
+    """
+    Run a benchmark.
+
+    BENCHMARK::
+
+        sage: from sage.misc.benchmark import *
+        sage: print(bench7()[0])
+        Compute the Mordell-Weil group of y^2 = x^3 + 37*x - 997.
+    """
+    desc = """Compute the Mordell-Weil group of y^2 = x^3 + 37*x - 997."""
+    E = EllipticCurve([0, 0, 0, 37, -997])
+    t = cputime()
+    G = E.gens()
+    return (desc, cputime(t))

sage/misc/classgraph.py

@@ -0,0 +1,134 @@
+# sage_setup: distribution = sagemath-repl
+# sage.doctest: needs sage.graphs
+r"""
+Class inheritance graphs
+"""
+# ****************************************************************************
+#  Copyright (C) 2007 William Stein <wstein@math.ucsd.edu>
+#                2011 Nicolas M. Thiery <nthiery at users.sf.net>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  https://www.gnu.org/licenses/
+# *****************************************************************************
+
+import inspect
+
+
+def class_graph(top, depth=5, name_filter=None, classes=None, as_graph=True):
+    """
+    Return the class inheritance graph of a module, class, or object.
+
+    INPUT:
+
+    - ``top`` -- the module, class, or object to start with (e.g. ``sage``,
+      ``Integer``, ``3``)
+    - ``depth`` -- maximal recursion depth within submodules (default: 5)
+    - ``name_filter`` -- e.g. 'sage.rings' to only consider classes in
+      :mod:`sage.rings`
+    - ``classes`` -- (optional) dictionary to be filled in (it is also returned)
+    - ``as_graph`` -- boolean (default: ``True``)
+
+    OUTPUT:
+
+    An oriented graph, with class names as vertices, and an edge
+    from each class to each of its bases.
+
+    EXAMPLES:
+
+    We construct the inheritance graph of the classes within a given module::
+
+        sage: # needs sage.rings.padics
+        sage: from sage.rings.polynomial.padics import polynomial_padic_capped_relative_dense, polynomial_padic_flat
+        sage: G = class_graph(sage.rings.polynomial.padics); G
+        Digraph on 6 vertices
+        sage: G.vertices(sort=True)
+        ['Polynomial',
+         'Polynomial_generic_cdv',
+         'Polynomial_generic_dense',
+         'Polynomial_padic',
+         'Polynomial_padic_capped_relative_dense',
+         'Polynomial_padic_flat']
+        sage: G.edges(sort=True, labels=False)
+        [('Polynomial_padic', 'Polynomial'),
+         ('Polynomial_padic_capped_relative_dense', 'Polynomial_generic_cdv'),
+         ('Polynomial_padic_capped_relative_dense', 'Polynomial_padic'),
+         ('Polynomial_padic_flat', 'Polynomial_generic_dense'),
+         ('Polynomial_padic_flat', 'Polynomial_padic')]
+
+    We construct the inheritance graph of a given class::
+
+        sage: class_graph(Parent).edges(sort=True, labels=False)
+        [('CategoryObject', 'SageObject'), ('Parent', 'CategoryObject'), ('SageObject', 'object')]
+
+    We construct the inheritance graph of the class of an object::
+
+        sage: class_graph([1,2,3]).edges(sort=True, labels=False)
+        [('list', 'object')]
+
+    .. warning:: the output of ``class_graph`` used to be a dictionary
+       mapping each class name to the list of names of its bases. This
+       can be emulated by setting the option ``as_graph`` to ``False``::
+
+        sage: # needs sage.rings.padics
+        sage: import sage.rings.polynomial.padics
+        sage: class_graph(sage.rings.polynomial.padics, depth=2, as_graph=False)
+        {'Polynomial_padic': ['Polynomial'],
+         'Polynomial_padic_capped_relative_dense': ['Polynomial_generic_cdv',
+          'Polynomial_padic'],
+         'Polynomial_padic_flat': ['Polynomial_generic_dense', 'Polynomial_padic']}
+
+    .. NOTE:: the ``classes`` and ``as_graph`` options are mostly
+       intended for internal recursive use.
+
+    .. NOTE:: ``class_graph`` does not yet handle nested classes
+
+    TESTS::
+
+        sage: G = class_graph(sage.rings.polynomial.padics, depth=2); G                 # needs sage.rings.padics
+        Digraph on 6 vertices
+    """
+    # This function descends recursively down the submodules of the
+    # top module (if ``top`` is a module) and then down the hierarchy
+    # of classes. Along the way, the result is stored in the "global"
+    # dictionary ``classes`` which associates to each class the list
+    # of its bases.
+
+    # Termination
+    if depth < 0:
+        return classes
+
+    # (first recursive call)
+    if classes is None:
+        classes = {}
+
+    # Build the list ``children`` of submodules (resp. base classes)
+    # of ``top`` the function will recurse through
+    if inspect.ismodule(top):
+        if top.__name__.endswith('.all'):  # Ignore sage.rings.all and friends
+            return classes
+        if name_filter is None:
+            name_filter = top.__name__
+        children = [item for item in top.__dict__.values()
+                    if inspect.ismodule(item) or inspect.isclass(item)]
+        depth -= 1
+    elif inspect.isclass(top):
+        if name_filter is None:
+            name_filter = ""
+        if not top.__module__.startswith(name_filter):
+            return classes
+        children = top.__bases__
+        classes[top.__name__] = [e.__name__ for e in children]
+    else:  # top is a plain Python object; inspect its class
+        children = [top.__class__]
+
+    # Recurse
+    for child in children:
+        class_graph(child, depth=depth, name_filter=name_filter,
+                    classes=classes, as_graph=False)
+
+    # (first recursive call): construct the graph
+    if as_graph:
+        from sage.graphs.digraph import DiGraph
+        return DiGraph(classes)
+    else:
+        return classes

sage/misc/copying.py

@@ -0,0 +1,22 @@
+# sage_setup: distribution = sagemath-repl
+"License"
+
+import os
+from sage.misc import pager
+
+from sage.env import SAGE_ROOT
+
+
+class License:
+    def __call__(self):
+        pager.pager()(str(self))
+
+    def __repr__(self):
+        return "Type license() to see the full license text."
+
+    def __str__(self):
+        with open(os.path.join(SAGE_ROOT, 'COPYING.txt')) as f:
+            return f.read()
+
+
+license = License()