Add files using upload-large-folder tool

mplug_owl2/lib/python3.10/site-packages/sympy/matrices/benchmarks/bench_matrix.py

@@ -0,0 +1,21 @@
+from sympy.core.numbers import Integer
+from sympy.matrices.dense import (eye, zeros)
+
+i3 = Integer(3)
+M = eye(100)
+
+
+def timeit_Matrix__getitem_ii():
+    M[3, 3]
+
+
+def timeit_Matrix__getitem_II():
+    M[i3, i3]
+
+
+def timeit_Matrix__getslice():
+    M[:, :]
+
+
+def timeit_Matrix_zeronm():
+    zeros(100, 100)

mplug_owl2/lib/python3.10/site-packages/sympy/unify/__init__.py

@@ -0,0 +1,15 @@
+""" Unification in SymPy
+
+See sympy.unify.core docstring for algorithmic details
+
+See http://matthewrocklin.com/blog/work/2012/11/01/Unification/ for discussion
+"""
+
+from .usympy import unify, rebuild
+from .rewrite import rewriterule
+
+__all__ = [
+    'unify', 'rebuild',
+
+    'rewriterule',
+]

mplug_owl2/lib/python3.10/site-packages/sympy/unify/core.py

@@ -0,0 +1,234 @@
+""" Generic Unification algorithm for expression trees with lists of children
+
+This implementation is a direct translation of
+
+Artificial Intelligence: A Modern Approach by Stuart Russel and Peter Norvig
+Second edition, section 9.2, page 276
+
+It is modified in the following ways:
+
+1.  We allow associative and commutative Compound expressions. This results in
+    combinatorial blowup.
+2.  We explore the tree lazily.
+3.  We provide generic interfaces to symbolic algebra libraries in Python.
+
+A more traditional version can be found here
+http://aima.cs.berkeley.edu/python/logic.html
+"""
+
+from sympy.utilities.iterables import kbins
+
+class Compound:
+    """ A little class to represent an interior node in the tree
+
+    This is analogous to SymPy.Basic for non-Atoms
+    """
+    def __init__(self, op, args):
+        self.op = op
+        self.args = args
+
+    def __eq__(self, other):
+        return (type(self) is type(other) and self.op == other.op and
+                self.args == other.args)
+
+    def __hash__(self):
+        return hash((type(self), self.op, self.args))
+
+    def __str__(self):
+        return "%s[%s]" % (str(self.op), ', '.join(map(str, self.args)))
+
+class Variable:
+    """ A Wild token """
+    def __init__(self, arg):
+        self.arg = arg
+
+    def __eq__(self, other):
+        return type(self) is type(other) and self.arg == other.arg
+
+    def __hash__(self):
+        return hash((type(self), self.arg))
+
+    def __str__(self):
+        return "Variable(%s)" % str(self.arg)
+
+class CondVariable:
+    """ A wild token that matches conditionally.
+
+    arg   - a wild token.
+    valid - an additional constraining function on a match.
+    """
+    def __init__(self, arg, valid):
+        self.arg = arg
+        self.valid = valid
+
+    def __eq__(self, other):
+        return (type(self) is type(other) and
+                self.arg == other.arg and
+                self.valid == other.valid)
+
+    def __hash__(self):
+        return hash((type(self), self.arg, self.valid))
+
+    def __str__(self):
+        return "CondVariable(%s)" % str(self.arg)
+
+def unify(x, y, s=None, **fns):
+    """ Unify two expressions.
+
+    Parameters
+    ==========
+
+        x, y - expression trees containing leaves, Compounds and Variables.
+        s    - a mapping of variables to subtrees.
+
+    Returns
+    =======
+
+        lazy sequence of mappings {Variable: subtree}
+
+    Examples
+    ========
+
+    >>> from sympy.unify.core import unify, Compound, Variable
+    >>> expr    = Compound("Add", ("x", "y"))
+    >>> pattern = Compound("Add", ("x", Variable("a")))
+    >>> next(unify(expr, pattern, {}))
+    {Variable(a): 'y'}
+    """
+    s = s or {}
+
+    if x == y:
+        yield s
+    elif isinstance(x, (Variable, CondVariable)):
+        yield from unify_var(x, y, s, **fns)
+    elif isinstance(y, (Variable, CondVariable)):
+        yield from unify_var(y, x, s, **fns)
+    elif isinstance(x, Compound) and isinstance(y, Compound):
+        is_commutative = fns.get('is_commutative', lambda x: False)
+        is_associative = fns.get('is_associative', lambda x: False)
+        for sop in unify(x.op, y.op, s, **fns):
+            if is_associative(x) and is_associative(y):
+                a, b = (x, y) if len(x.args) < len(y.args) else (y, x)
+                if is_commutative(x) and is_commutative(y):
+                    combs = allcombinations(a.args, b.args, 'commutative')
+                else:
+                    combs = allcombinations(a.args, b.args, 'associative')
+                for aaargs, bbargs in combs:
+                    aa = [unpack(Compound(a.op, arg)) for arg in aaargs]
+                    bb = [unpack(Compound(b.op, arg)) for arg in bbargs]
+                    yield from unify(aa, bb, sop, **fns)
+            elif len(x.args) == len(y.args):
+                yield from unify(x.args, y.args, sop, **fns)
+
+    elif is_args(x) and is_args(y) and len(x) == len(y):
+        if len(x) == 0:
+            yield s
+        else:
+            for shead in unify(x[0], y[0], s, **fns):
+                yield from unify(x[1:], y[1:], shead, **fns)
+
+def unify_var(var, x, s, **fns):
+    if var in s:
+        yield from unify(s[var], x, s, **fns)
+    elif occur_check(var, x):
+        pass
+    elif isinstance(var, CondVariable) and var.valid(x):
+        yield assoc(s, var, x)
+    elif isinstance(var, Variable):
+        yield assoc(s, var, x)
+
+def occur_check(var, x):
+    """ var occurs in subtree owned by x? """
+    if var == x:
+        return True
+    elif isinstance(x, Compound):
+        return occur_check(var, x.args)
+    elif is_args(x):
+        if any(occur_check(var, xi) for xi in x): return True
+    return False
+
+def assoc(d, key, val):
+    """ Return copy of d with key associated to val """
+    d = d.copy()
+    d[key] = val
+    return d
+
+def is_args(x):
+    """ Is x a traditional iterable? """
+    return type(x) in (tuple, list, set)
+
+def unpack(x):
+    if isinstance(x, Compound) and len(x.args) == 1:
+        return x.args[0]
+    else:
+        return x
+
+def allcombinations(A, B, ordered):
+    """
+    Restructure A and B to have the same number of elements.
+
+    Parameters
+    ==========
+
+    ordered must be either 'commutative' or 'associative'.
+
+    A and B can be rearranged so that the larger of the two lists is
+    reorganized into smaller sublists.
+
+    Examples
+    ========
+
+    >>> from sympy.unify.core import allcombinations
+    >>> for x in allcombinations((1, 2, 3), (5, 6), 'associative'): print(x)
+    (((1,), (2, 3)), ((5,), (6,)))
+    (((1, 2), (3,)), ((5,), (6,)))
+
+    >>> for x in allcombinations((1, 2, 3), (5, 6), 'commutative'): print(x)
+        (((1,), (2, 3)), ((5,), (6,)))
+        (((1, 2), (3,)), ((5,), (6,)))
+        (((1,), (3, 2)), ((5,), (6,)))
+        (((1, 3), (2,)), ((5,), (6,)))
+        (((2,), (1, 3)), ((5,), (6,)))
+        (((2, 1), (3,)), ((5,), (6,)))
+        (((2,), (3, 1)), ((5,), (6,)))
+        (((2, 3), (1,)), ((5,), (6,)))
+        (((3,), (1, 2)), ((5,), (6,)))
+        (((3, 1), (2,)), ((5,), (6,)))
+        (((3,), (2, 1)), ((5,), (6,)))
+        (((3, 2), (1,)), ((5,), (6,)))
+    """
+
+    if ordered == "commutative":
+        ordered = 11
+    if ordered == "associative":
+        ordered = None
+    sm, bg = (A, B) if len(A) < len(B) else (B, A)
+    for part in kbins(list(range(len(bg))), len(sm), ordered=ordered):
+        if bg == B:
+            yield tuple((a,) for a in A), partition(B, part)
+        else:
+            yield partition(A, part), tuple((b,) for b in B)
+
+def partition(it, part):
+    """ Partition a tuple/list into pieces defined by indices.
+
+    Examples
+    ========
+
+    >>> from sympy.unify.core import partition
+    >>> partition((10, 20, 30, 40), [[0, 1, 2], [3]])
+    ((10, 20, 30), (40,))
+    """
+    return type(it)([index(it, ind) for ind in part])
+
+def index(it, ind):
+    """ Fancy indexing into an indexable iterable (tuple, list).
+
+    Examples
+    ========
+
+    >>> from sympy.unify.core import index
+    >>> index([10, 20, 30], (1, 2, 0))
+    [20, 30, 10]
+    """
+    return type(it)([it[i] for i in ind])

mplug_owl2/lib/python3.10/site-packages/sympy/unify/rewrite.py

@@ -0,0 +1,55 @@
+""" Functions to support rewriting of SymPy expressions """
+
+from sympy.core.expr import Expr
+from sympy.assumptions import ask
+from sympy.strategies.tools import subs
+from sympy.unify.usympy import rebuild, unify
+
+def rewriterule(source, target, variables=(), condition=None, assume=None):
+    """ Rewrite rule.
+
+    Transform expressions that match source into expressions that match target
+    treating all ``variables`` as wilds.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import w, x, y, z
+    >>> from sympy.unify.rewrite import rewriterule
+    >>> from sympy import default_sort_key
+    >>> rl = rewriterule(x + y, x**y, [x, y])
+    >>> sorted(rl(z + 3), key=default_sort_key)
+    [3**z, z**3]
+
+    Use ``condition`` to specify additional requirements.  Inputs are taken in
+    the same order as is found in variables.
+
+    >>> rl = rewriterule(x + y, x**y, [x, y], lambda x, y: x.is_integer)
+    >>> list(rl(z + 3))
+    [3**z]
+
+    Use ``assume`` to specify additional requirements using new assumptions.
+
+    >>> from sympy.assumptions import Q
+    >>> rl = rewriterule(x + y, x**y, [x, y], assume=Q.integer(x))
+    >>> list(rl(z + 3))
+    [3**z]
+
+    Assumptions for the local context are provided at rule runtime
+
+    >>> list(rl(w + z, Q.integer(z)))
+    [z**w]
+    """
+
+    def rewrite_rl(expr, assumptions=True):
+        for match in unify(source, expr, {}, variables=variables):
+            if (condition and
+                not condition(*[match.get(var, var) for var in variables])):
+                continue
+            if (assume and not ask(assume.xreplace(match), assumptions)):
+                continue
+            expr2 = subs(match)(target)
+            if isinstance(expr2, Expr):
+                expr2 = rebuild(expr2)
+            yield expr2
+    return rewrite_rl

mplug_owl2/lib/python3.10/site-packages/sympy/unify/tests/test_unify.py

@@ -0,0 +1,88 @@
+from sympy.unify.core import Compound, Variable, CondVariable, allcombinations
+from sympy.unify import core
+
+a,b,c = 'a', 'b', 'c'
+w,x,y,z = map(Variable, 'wxyz')
+
+C = Compound
+
+def is_associative(x):
+    return isinstance(x, Compound) and (x.op in ('Add', 'Mul', 'CAdd', 'CMul'))
+def is_commutative(x):
+    return isinstance(x, Compound) and (x.op in ('CAdd', 'CMul'))
+
+
+def unify(a, b, s={}):
+    return core.unify(a, b, s=s, is_associative=is_associative,
+                          is_commutative=is_commutative)
+
+def test_basic():
+    assert list(unify(a, x, {})) == [{x: a}]
+    assert list(unify(a, x, {x: 10})) == []
+    assert list(unify(1, x, {})) == [{x: 1}]
+    assert list(unify(a, a, {})) == [{}]
+    assert list(unify((w, x), (y, z), {})) == [{w: y, x: z}]
+    assert list(unify(x, (a, b), {})) == [{x: (a, b)}]
+
+    assert list(unify((a, b), (x, x), {})) == []
+    assert list(unify((y, z), (x, x), {}))!= []
+    assert list(unify((a, (b, c)), (a, (x, y)), {})) == [{x: b, y: c}]
+
+def test_ops():
+    assert list(unify(C('Add', (a,b,c)), C('Add', (a,x,y)), {})) == \
+            [{x:b, y:c}]
+    assert list(unify(C('Add', (C('Mul', (1,2)), b,c)), C('Add', (x,y,c)), {})) == \
+            [{x: C('Mul', (1,2)), y:b}]
+
+def test_associative():
+    c1 = C('Add', (1,2,3))
+    c2 = C('Add', (x,y))
+    assert tuple(unify(c1, c2, {})) == ({x: 1, y: C('Add', (2, 3))},
+                                         {x: C('Add', (1, 2)), y: 3})
+
+def test_commutative():
+    c1 = C('CAdd', (1,2,3))
+    c2 = C('CAdd', (x,y))
+    result = list(unify(c1, c2, {}))
+    assert  {x: 1, y: C('CAdd', (2, 3))} in result
+    assert ({x: 2, y: C('CAdd', (1, 3))} in result or
+            {x: 2, y: C('CAdd', (3, 1))} in result)
+
+def _test_combinations_assoc():
+    assert set(allcombinations((1,2,3), (a,b), True)) == \
+        {(((1, 2), (3,)), (a, b)), (((1,), (2, 3)), (a, b))}
+
+def _test_combinations_comm():
+    assert set(allcombinations((1,2,3), (a,b), None)) == \
+        {(((1,), (2, 3)), ('a', 'b')), (((2,), (3, 1)), ('a', 'b')),
+             (((3,), (1, 2)), ('a', 'b')), (((1, 2), (3,)), ('a', 'b')),
+             (((2, 3), (1,)), ('a', 'b')), (((3, 1), (2,)), ('a', 'b'))}
+
+def test_allcombinations():
+    assert set(allcombinations((1,2), (1,2), 'commutative')) ==\
+        {(((1,),(2,)), ((1,),(2,))), (((1,),(2,)), ((2,),(1,)))}
+
+
+def test_commutativity():
+    c1 = Compound('CAdd', (a, b))
+    c2 = Compound('CAdd', (x, y))
+    assert is_commutative(c1) and is_commutative(c2)
+    assert len(list(unify(c1, c2, {}))) == 2
+
+
+def test_CondVariable():
+    expr = C('CAdd', (1, 2))
+    x = Variable('x')
+    y = CondVariable('y', lambda a: a % 2 == 0)
+    z = CondVariable('z', lambda a: a > 3)
+    pattern = C('CAdd', (x, y))
+    assert list(unify(expr, pattern, {})) == \
+            [{x: 1, y: 2}]
+
+    z = CondVariable('z', lambda a: a > 3)
+    pattern = C('CAdd', (z, y))
+
+    assert list(unify(expr, pattern, {})) == []
+
+def test_defaultdict():
+    assert next(unify(Variable('x'), 'foo')) == {Variable('x'): 'foo'}

mplug_owl2/lib/python3.10/site-packages/sympy/unify/usympy.py

@@ -0,0 +1,124 @@
+""" SymPy interface to Unification engine
+
+See sympy.unify for module level docstring
+See sympy.unify.core for algorithmic docstring """
+
+from sympy.core import Basic, Add, Mul, Pow
+from sympy.core.operations import AssocOp, LatticeOp
+from sympy.matrices import MatAdd, MatMul, MatrixExpr
+from sympy.sets.sets import Union, Intersection, FiniteSet
+from sympy.unify.core import Compound, Variable, CondVariable
+from sympy.unify import core
+
+basic_new_legal = [MatrixExpr]
+eval_false_legal = [AssocOp, Pow, FiniteSet]
+illegal = [LatticeOp]
+
+def sympy_associative(op):
+    assoc_ops = (AssocOp, MatAdd, MatMul, Union, Intersection, FiniteSet)
+    return any(issubclass(op, aop) for aop in assoc_ops)
+
+def sympy_commutative(op):
+    comm_ops = (Add, MatAdd, Union, Intersection, FiniteSet)
+    return any(issubclass(op, cop) for cop in comm_ops)
+
+def is_associative(x):
+    return isinstance(x, Compound) and sympy_associative(x.op)
+
+def is_commutative(x):
+    if not isinstance(x, Compound):
+        return False
+    if sympy_commutative(x.op):
+        return True
+    if issubclass(x.op, Mul):
+        return all(construct(arg).is_commutative for arg in x.args)
+
+def mk_matchtype(typ):
+    def matchtype(x):
+        return (isinstance(x, typ) or
+                isinstance(x, Compound) and issubclass(x.op, typ))
+    return matchtype
+
+def deconstruct(s, variables=()):
+    """ Turn a SymPy object into a Compound """
+    if s in variables:
+        return Variable(s)
+    if isinstance(s, (Variable, CondVariable)):
+        return s
+    if not isinstance(s, Basic) or s.is_Atom:
+        return s
+    return Compound(s.__class__,
+                    tuple(deconstruct(arg, variables) for arg in s.args))
+
+def construct(t):
+    """ Turn a Compound into a SymPy object """
+    if isinstance(t, (Variable, CondVariable)):
+        return t.arg
+    if not isinstance(t, Compound):
+        return t
+    if any(issubclass(t.op, cls) for cls in eval_false_legal):
+        return t.op(*map(construct, t.args), evaluate=False)
+    elif any(issubclass(t.op, cls) for cls in basic_new_legal):
+        return Basic.__new__(t.op, *map(construct, t.args))
+    else:
+        return t.op(*map(construct, t.args))
+
+def rebuild(s):
+    """ Rebuild a SymPy expression.
+
+    This removes harm caused by Expr-Rules interactions.
+    """
+    return construct(deconstruct(s))
+
+def unify(x, y, s=None, variables=(), **kwargs):
+    """ Structural unification of two expressions/patterns.
+
+    Examples
+    ========
+
+    >>> from sympy.unify.usympy import unify
+    >>> from sympy import Basic, S
+    >>> from sympy.abc import x, y, z, p, q
+
+    >>> next(unify(Basic(S(1), S(2)), Basic(S(1), x), variables=[x]))
+    {x: 2}
+
+    >>> expr = 2*x + y + z
+    >>> pattern = 2*p + q
+    >>> next(unify(expr, pattern, {}, variables=(p, q)))
+    {p: x, q: y + z}
+
+    Unification supports commutative and associative matching
+
+    >>> expr = x + y + z
+    >>> pattern = p + q
+    >>> len(list(unify(expr, pattern, {}, variables=(p, q))))
+    12
+
+    Symbols not indicated to be variables are treated as literal,
+    else they are wild-like and match anything in a sub-expression.
+
+    >>> expr = x*y*z + 3
+    >>> pattern = x*y + 3
+    >>> next(unify(expr, pattern, {}, variables=[x, y]))
+    {x: y, y: x*z}
+
+    The x and y of the pattern above were in a Mul and matched factors
+    in the Mul of expr. Here, a single symbol matches an entire term:
+
+    >>> expr = x*y + 3
+    >>> pattern = p + 3
+    >>> next(unify(expr, pattern, {}, variables=[p]))
+    {p: x*y}
+
+    """
+    decons = lambda x: deconstruct(x, variables)
+    s = s or {}
+    s = {decons(k): decons(v) for k, v in s.items()}
+
+    ds = core.unify(decons(x), decons(y), s,
+                                     is_associative=is_associative,
+                                     is_commutative=is_commutative,
+                                     **kwargs)
+    for d in ds:
+        yield {construct(k): construct(v) for k, v in d.items()}