symengine 0.9.2__cp38-cp38-win_amd64.whl → 0.11.0__cp38-cp38-win_amd64.whl

symengine-0.11.0.data/purelib/symengine/tests/test_pickling.py

@@ -0,0 +1,59 @@
+from symengine import symbols, sin, sinh, have_numpy, have_llvm, cos, Symbol
+from symengine.test_utilities import raises
+import pickle
+import unittest
+
+
+def test_basic():
+    x, y, z = symbols('x y z')
+    expr = sin(cos(x + y)/z)**2
+    s = pickle.dumps(expr)
+    expr2 = pickle.loads(s)
+    assert expr == expr2
+
+
+class MySymbolBase(Symbol):
+    def __init__(self, name, attr):
+        super().__init__(name=name)
+        self.attr = attr
+
+    def __eq__(self, other):
+        if not isinstance(other, MySymbolBase):
+            return False
+        return self.name == other.name and self.attr == other.attr
+
+
+class MySymbol(MySymbolBase):
+    def __reduce__(self):
+        return (self.__class__, (self.name, self.attr))
+
+
+def test_pysymbol():
+    a = MySymbol("hello", attr=1)
+    b = pickle.loads(pickle.dumps(a + 2)) - 2
+    try:
+        assert a == b
+    finally:
+        a._unsafe_reset()
+        b._unsafe_reset()
+
+    a = MySymbolBase("hello", attr=1)
+    try:
+        raises(NotImplementedError, lambda: pickle.dumps(a))
+        raises(NotImplementedError, lambda: pickle.dumps(a + 2))
+    finally:
+        a._unsafe_reset()
+
+
+@unittest.skipUnless(have_llvm, "No LLVM support")
+@unittest.skipUnless(have_numpy, "Numpy not installed")
+def test_llvm_double():
+    import numpy as np
+    from symengine import Lambdify
+    args = x, y, z = symbols('x y z')
+    expr = sin(sinh(x+y) + z)
+    l = Lambdify(args, expr, cse=True, backend='llvm')
+    ss = pickle.dumps(l)
+    ll = pickle.loads(ss)
+    inp = [1, 2, 3]
+    assert np.allclose(l(inp), ll(inp))

{symengine → symengine-0.11.0.data/purelib/symengine}/tests/test_printing.py

@@ -1,5 +1,5 @@
 from symengine import (ccode, unicode, Symbol, sqrt, Pow, Max, sin, Integer, MutableDenseMatrix)
-from symengine.utilities import raises
+from symengine.test_utilities import raises
 from symengine.printing import CCodePrinter, init_printing
 
 def test_ccode():

{symengine → symengine-0.11.0.data/purelib/symengine}/tests/test_series_expansion.py

@@ -1,4 +1,4 @@
-from symengine.utilities import raises
+from symengine.test_utilities import raises
 from symengine.lib.symengine_wrapper import (series, have_piranha, have_flint,
     Symbol, Integer, sin, cos, exp, sqrt, E)
 

{symengine → symengine-0.11.0.data/purelib/symengine}/tests/test_sets.py

@@ -1,4 +1,4 @@
-from symengine.utilities import raises
+from symengine.test_utilities import raises
 from symengine.lib.symengine_wrapper import (Interval, EmptySet, UniversalSet,
     FiniteSet, Union, Complement, ImageSet, ConditionSet, Reals, Rationals,
     Integers, And, Or, oo, Symbol, true, Ge, Eq, Gt)

{symengine → symengine-0.11.0.data/purelib/symengine}/tests/test_solve.py

@@ -1,4 +1,4 @@
-from symengine.utilities import raises
+from symengine.test_utilities import raises
 from symengine import (Interval, EmptySet, FiniteSet, I, oo, Eq, Symbol,
     linsolve)
 from symengine.lib.symengine_wrapper import solve

{symengine → symengine-0.11.0.data/purelib/symengine}/tests/test_subs.py

@@ -1,6 +1,6 @@
 import unittest
 
-from symengine.utilities import raises
+from symengine.test_utilities import raises
 from symengine import Symbol, sin, cos, sqrt, Add, function_symbol, have_numpy
 
 

{symengine → symengine-0.11.0.data/purelib/symengine}/tests/test_symbol.py

@@ -1,5 +1,5 @@
 from symengine import Symbol, symbols, symarray, has_symbol, Dummy
-from symengine.utilities import raises
+from symengine.test_utilities import raises
 import unittest
 import platform
 
@@ -48,7 +48,7 @@ def test_symbols():
 
     assert symbols(('x', 'y', 'z')) == (x, y, z)
     assert symbols(['x', 'y', 'z']) == [x, y, z]
-    assert symbols(set(['x', 'y', 'z'])) == set([x, y, z])
+    assert symbols({'x', 'y', 'z'}) == {x, y, z}
 
     raises(ValueError, lambda: symbols(''))
     raises(ValueError, lambda: symbols(','))
@@ -104,13 +104,13 @@ def test_symbols():
     assert sym('a0:4') == '(a0, a1, a2, a3)'
     assert sym('a2:4,b1:3') == '(a2, a3, b1, b2)'
     assert sym('a1(2:4)') == '(a12, a13)'
-    assert sym(('a0:2.0:2')) == '(a0.0, a0.1, a1.0, a1.1)'
-    assert sym(('aa:cz')) == '(aaz, abz, acz)'
+    assert sym('a0:2.0:2') == '(a0.0, a0.1, a1.0, a1.1)'
+    assert sym('aa:cz') == '(aaz, abz, acz)'
     assert sym('aa:c0:2') == '(aa0, aa1, ab0, ab1, ac0, ac1)'
     assert sym('aa:ba:b') == '(aaa, aab, aba, abb)'
     assert sym('a:3b') == '(a0b, a1b, a2b)'
     assert sym('a-1:3b') == '(a-1b, a-2b)'
-    assert sym('a:2\,:2' + chr(0)) == '(a0,0%s, a0,1%s, a1,0%s, a1,1%s)' % (
+    assert sym(r'a:2\,:2' + chr(0)) == '(a0,0%s, a0,1%s, a1,0%s, a1,1%s)' % (
         (chr(0),)*4)
     assert sym('x(:a:3)') == '(x(a0), x(a1), x(a2))'
     assert sym('x(:c):1') == '(xa0, xb0, xc0)'

{symengine → symengine-0.11.0.data/purelib/symengine}/tests/test_sympify.py

@@ -1,4 +1,4 @@
-from symengine.utilities import raises
+from symengine.test_utilities import raises
 
 from symengine import (Symbol, Integer, sympify, SympifyError, true, false, pi, nan, oo,
                        zoo, E, I, GoldenRatio, Catalan, Rational, sqrt, Eq)
@@ -44,7 +44,7 @@ def test_S():
 
 
 def test_sympify_error1a():
-    class Test(object):
+    class Test:
         pass
     raises(SympifyError, lambda: sympify(Test()))
 

{symengine → symengine-0.11.0.data/purelib/symengine}/tests/test_sympy_compat.py

@@ -1,7 +1,7 @@
 from symengine.sympy_compat import (Integer, Rational, S, Basic, Add, Mul,
     Pow, symbols, Symbol, log, sin, cos, sech, csch, zeros, atan2, nan, Number, Float,
     Min, Max, RealDouble, have_mpfr, Abs)
-from symengine.utilities import raises
+from symengine.test_utilities import raises
 
 
 def test_Integer():
@@ -183,7 +183,7 @@ def test_subclass_symbol():
             return Symbol.__new__(cls, name)
 
         def __init__(self, name, extra_attribute):
-            super(Wrapper, self).__init__(name)
+            super().__init__(name)
             self.extra_attribute = extra_attribute
 
     # Instantiate the subclass

{symengine → symengine-0.11.0.data/purelib/symengine}/tests/test_sympy_conv.py

@@ -2,8 +2,8 @@ from symengine import (Symbol, Integer, sympify, SympifyError, log,
         function_symbol, I, E, pi, oo, zoo, nan, true, false,
         exp, gamma, have_mpfr, have_mpc, DenseMatrix, sin, cos, tan, cot,
         csc, sec, asin, acos, atan, acot, acsc, asec, sinh, cosh, tanh, coth,
-        asinh, acosh, atanh, acoth, Add, Mul, Pow, diff, GoldenRatio,
-        Catalan, EulerGamma, UnevaluatedExpr)
+        asinh, acosh, atanh, acoth, atan2, Add, Mul, Pow, diff, GoldenRatio,
+        Catalan, EulerGamma, UnevaluatedExpr, RealDouble)
 from symengine.lib.symengine_wrapper import (Subs, Derivative, RealMPFR,
         ComplexMPC, PyNumber, Function, LambertW, zeta, dirichlet_eta,
         KroneckerDelta, LeviCivita, erf, erfc, lowergamma, uppergamma,
@@ -171,6 +171,7 @@ def test_conv7():
     assert acot(x/3) == acot(sympy.Symbol("x") / 3)
     assert acsc(x/3) == acsc(sympy.Symbol("x") / 3)
     assert asec(x/3) == asec(sympy.Symbol("x") / 3)
+    assert atan2(x/3, y) == atan2(sympy.Symbol("x") / 3, sympy.Symbol("y"))
 
     assert sin(x/3)._sympy_() == sympy.sin(sympy.Symbol("x") / 3)
     assert sin(x/3)._sympy_() != sympy.cos(sympy.Symbol("x") / 3)
@@ -185,6 +186,22 @@ def test_conv7():
     assert acot(x/3)._sympy_() == sympy.acot(sympy.Symbol("x") / 3)
     assert acsc(x/3)._sympy_() == sympy.acsc(sympy.Symbol("x") / 3)
     assert asec(x/3)._sympy_() == sympy.asec(sympy.Symbol("x") / 3)
+    assert atan2(x/3, y)._sympy_() == sympy.atan2(sympy.Symbol("x") / 3, sympy.Symbol("y"))
+
+    assert sympy.sympify(sin(x/3)) == sympy.sin(sympy.Symbol("x") / 3)
+    assert sympy.sympify(sin(x/3)) != sympy.cos(sympy.Symbol("x") / 3)
+    assert sympy.sympify(cos(x/3)) == sympy.cos(sympy.Symbol("x") / 3)
+    assert sympy.sympify(tan(x/3)) == sympy.tan(sympy.Symbol("x") / 3)
+    assert sympy.sympify(cot(x/3)) == sympy.cot(sympy.Symbol("x") / 3)
+    assert sympy.sympify(csc(x/3)) == sympy.csc(sympy.Symbol("x") / 3)
+    assert sympy.sympify(sec(x/3)) == sympy.sec(sympy.Symbol("x") / 3)
+    assert sympy.sympify(asin(x/3)) == sympy.asin(sympy.Symbol("x") / 3)
+    assert sympy.sympify(acos(x/3)) == sympy.acos(sympy.Symbol("x") / 3)
+    assert sympy.sympify(atan(x/3)) == sympy.atan(sympy.Symbol("x") / 3)
+    assert sympy.sympify(acot(x/3)) == sympy.acot(sympy.Symbol("x") / 3)
+    assert sympy.sympify(acsc(x/3)) == sympy.acsc(sympy.Symbol("x") / 3)
+    assert sympy.sympify(asec(x/3)) == sympy.asec(sympy.Symbol("x") / 3)
+    assert sympy.sympify(atan2(x/3, y)) == sympy.atan2(sympy.Symbol("x") / 3, sympy.Symbol("y"))
 
 
 @unittest.skipIf(not have_sympy, "SymPy not installed")
@@ -204,6 +221,7 @@ def test_conv7b():
     assert sympify(sympy.acot(x/3)) == acot(Symbol("x") / 3)
     assert sympify(sympy.acsc(x/3)) == acsc(Symbol("x") / 3)
     assert sympify(sympy.asec(x/3)) == asec(Symbol("x") / 3)
+    assert sympify(sympy.atan2(x/3, y)) == atan2(Symbol("x") / 3, Symbol("y"))
 
 
 @unittest.skipIf(not have_sympy, "SymPy not installed")
@@ -515,7 +533,7 @@ def test_zeta():
     e1 = sympy.zeta(sympy.Symbol("x"), sympy.Symbol("y"))
     e2 = zeta(x, y)
     assert sympify(e1) == e2
-    assert e2._sympy_() == e1   
+    assert e2._sympy_() == e1
 
 
 @unittest.skipIf(not have_sympy, "SymPy not installed")
@@ -796,3 +814,22 @@ def test_construct_dense_matrix():
     B = DenseMatrix(A)
     assert B.shape == (2, 2)
     assert list(B) == [1, 2, 3, 5]
+
+
+@unittest.skipIf(not have_sympy, "SymPy not installed")
+def test_conv_doubles():
+    f = 4.347249999999999
+    a = sympify(f)
+    assert isinstance(a, RealDouble)
+    assert sympify(a._sympy_()) == a
+    assert float(a) == f
+    assert float(a._sympy_()) == f
+
+def test_conv_large_integers():
+    a = Integer(10)**10000
+    # check that convert to python int does not throw
+    b = int(a)
+    # check that convert to sympy int does not throw
+    if have_sympy:
+        c = a._sympy_()
+        d = sympify(c)

{symengine → symengine-0.11.0.data/purelib/symengine}/tests/test_var.py

@@ -1,7 +1,7 @@
 # Tests for var are in their own file, because var pollutes global namespace.
 
 from symengine import Symbol, var
-from symengine.utilities import raises
+from symengine.test_utilities import raises
 # make z1 with call-depth = 1
 
 

{symengine → symengine-0.11.0.data/purelib/symengine}/utilities.py

@@ -241,99 +241,6 @@ def var(names, **args):
     return syms
 
 
-try:
-    import py
-    from py.test import skip, raises
-    USE_PYTEST = getattr(sys, '_running_pytest', False)
-except ImportError:
-    USE_PYTEST = False
-
-if not USE_PYTEST:
-    def raises(expectedException, code=None):
-        """
-        Tests that ``code`` raises the exception ``expectedException``.
-
-        ``code`` may be a callable, such as a lambda expression or function
-        name.
-
-        If ``code`` is not given or None, ``raises`` will return a context
-        manager for use in ``with`` statements; the code to execute then
-        comes from the scope of the ``with``.
-
-        ``raises()`` does nothing if the callable raises the expected
-        exception, otherwise it raises an AssertionError.
-
-        Examples
-        ========
-
-        >>> from symengine.pytest import raises
-
-        >>> raises(ZeroDivisionError, lambda: 1/0)
-        >>> raises(ZeroDivisionError, lambda: 1/2)
-        Traceback (most recent call last):
-        ...
-        AssertionError: DID NOT RAISE
-
-        >>> with raises(ZeroDivisionError):
-        ...     n = 1/0
-        >>> with raises(ZeroDivisionError):
-        ...     n = 1/2
-        Traceback (most recent call last):
-        ...
-        AssertionError: DID NOT RAISE
-
-        Note that you cannot test multiple statements via
-        ``with raises``:
-
-        >>> with raises(ZeroDivisionError):
-        ...     n = 1/0    # will execute and raise, aborting the ``with``
-        ...     n = 9999/0 # never executed
-
-        This is just what ``with`` is supposed to do: abort the
-        contained statement sequence at the first exception and let
-        the context manager deal with the exception.
-
-        To test multiple statements, you'll need a separate ``with``
-        for each:
-
-        >>> with raises(ZeroDivisionError):
-        ...     n = 1/0    # will execute and raise
-        >>> with raises(ZeroDivisionError):
-        ...     n = 9999/0 # will also execute and raise
-
-        """
-        if code is None:
-            return RaisesContext(expectedException)
-        elif callable(code):
-            try:
-                code()
-            except expectedException:
-                return
-            raise AssertionError("DID NOT RAISE")
-        elif isinstance(code, str):
-            raise TypeError(
-                '\'raises(xxx, "code")\' has been phased out; '
-                'change \'raises(xxx, "expression")\' '
-                'to \'raises(xxx, lambda: expression)\', '
-                '\'raises(xxx, "statement")\' '
-                'to \'with raises(xxx): statement\'')
-        else:
-            raise TypeError(
-                'raises() expects a callable for the 2nd argument.')
-
-    class RaisesContext(object):
-        def __init__(self, expectedException):
-            self.expectedException = expectedException
-
-        def __enter__(self):
-            return None
-
-        def __exit__(self, exc_type, exc_value, traceback):
-            if exc_type is None:
-                raise AssertionError("DID NOT RAISE")
-            return issubclass(exc_type, self.expectedException)
-
-
 class NotIterable:
     """
     Use this as mixin when creating a class which is not supposed to return

{symengine-0.9.2.dist-info → symengine-0.11.0.dist-info}/AUTHORS

@@ -34,3 +34,4 @@ Michał Górny <mgorny@gentoo.org>
 Garming Sam <garming@catalyst.net.nz>
 Pieter Eendebak <pieter.eendebak@gmail.com>
 Ayush Kumar <ayushk7102@gmail.com>
+Christian Clauss <cclauss@me.com>

{symengine-0.9.2.dist-info → symengine-0.11.0.dist-info}/METADATA

@@ -1,33 +1,31 @@
-Metadata-Version: 2.1
-Name: symengine
-Version: 0.9.2
-Summary: Python library providing wrappers to SymEngine
-Home-page: https://github.com/symengine/symengine.py
-Author: SymEngine development team
-Author-email: symengine@googlegroups.com
-License: MIT
-Platform: UNKNOWN
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Topic :: Scientific/Engineering
-Classifier: Topic :: Scientific/Engineering :: Mathematics
-Classifier: Topic :: Scientific/Engineering :: Physics
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Requires-Python: >=3.7,<4
-License-File: LICENSE
-License-File: AUTHORS
-
-
-SymEngine is a standalone fast C++ symbolic manipulation library.
-Optional thin Python wrappers (SymEngine) allow easy usage from Python and
-integration with SymPy and Sage.
-
-See https://github.com/symengine/symengine.py for information about License
-and dependencies of wheels
-
-
-
+Metadata-Version: 2.1
+Name: symengine
+Version: 0.11.0
+Summary: Python library providing wrappers to SymEngine
+Home-page: https://github.com/symengine/symengine.py
+Author: SymEngine development team
+Author-email: symengine@googlegroups.com
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8,<4
+License-File: LICENSE
+License-File: AUTHORS
+
+
+SymEngine is a standalone fast C++ symbolic manipulation library.
+Optional thin Python wrappers (SymEngine) allow easy usage from Python and
+integration with SymPy and Sage.
+
+See https://github.com/symengine/symengine.py for information about License
+and dependencies of wheels
+

symengine-0.11.0.dist-info/RECORD

@@ -0,0 +1,49 @@
+symengine/lib/flint-17.dll,sha256=1dVCVFCzpRWLZfEEAxTIoM3fphsZZlMni_LE2lNWqyY,7675904
+symengine/lib/mpc.dll,sha256=evUU326S9KR7-BJpgtMyUFG_nvh0Cpm7-pXxryNEvGo,99328
+symengine/lib/mpfr.dll,sha256=9BF4BLf8tOXwdCt0dc1AWdqwx8FTd5xn5zFbZkHu5eg,515584
+symengine/lib/mpir.dll,sha256=CNkBuXqYfdIwI-9Cc9JvxuD_f83c26a2453AV5Ma-ZQ,612352
+symengine/lib/pthreadVSE2.dll,sha256=c4c6nbKPnbnWCLy_UL8Ffcuo9Q12CLZkOG2snbtFPEE,58368
+symengine/lib/pywrapper.h,sha256=5FeCXvth1dlnftGzPNYvSiUTcEl0eXCutJOZ5QgdVbg,8503
+symengine/lib/symengine.pxd,sha256=60hdRcCRKWBqu44EGyJlGLcj4_qlzMxZQTZQuxXJmqw,44443
+symengine/lib/symengine_wrapper.cp38-win_amd64.lib,sha256=VlP8yJi0T1wnybOZMNYW1IW3Xo44FQZrjBHmpuhx28o,5602
+symengine/lib/symengine_wrapper.cp38-win_amd64.pyd,sha256=6kmNGgC4JNSvU3NKYJ7aNlmBE3xRzj4mgh9RqA-MBTI,30286848
+symengine/lib/symengine_wrapper.pxd,sha256=pUDxGIiIiymJ-wIr5PQJjfqE-KZUC78wI5AUR55LImY,2986
+symengine/lib/zlib.dll,sha256=vden14yC8r1TlXchB_W_2_uSt8ToNsw9eLy1TfSBXsU,89088
+symengine/lib/zstd.dll,sha256=Mjzh_dBxp--uWtchXWrZgckM7SjvipFdh22vphJdF_g,651264
+symengine-0.11.0.data/purelib/symengine/functions.py,sha256=LNfGb-yI6aXo9BszdmJWfFjZhQFCSYF44fXGMDhLwb8,425
+symengine-0.11.0.data/purelib/symengine/printing.py,sha256=BKOTrj3voT6enkYZYvimM32ibVcBdLNVF4eIgIjHHW8,1115
+symengine-0.11.0.data/purelib/symengine/sympy_compat.py,sha256=pmISwghw-gwE3yM-cpJ2gYWyzO43GQrFVAzeDCLeFRM,171
+symengine-0.11.0.data/purelib/symengine/test_utilities.py,sha256=Pk8RHape9EeGatC3nUE5M-IJoL-U3_WHRS6TdRVWg6g,3086
+symengine-0.11.0.data/purelib/symengine/utilities.py,sha256=bn22sbLtKRQVR_G17O4-iO3K7Bo2kOvRZnkjl7IPrR8,9604
+symengine-0.11.0.data/purelib/symengine/__init__.py,sha256=jivdJwZbwFHgTBg2eOLWPa2kGAvyTp_VOhhWWuaksx4,2403
+symengine-0.11.0.data/purelib/symengine/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+symengine-0.11.0.data/purelib/symengine/tests/test_arit.py,sha256=poIp4bb1pAnLCt0EvJL1B_m7Ap0wVJlHSi1IvlEjxik,5611
+symengine-0.11.0.data/purelib/symengine/tests/test_cse.py,sha256=9SMfCrdQ7ZDoTkbcOk28UhXD2ZDFFbDFiAxOjWM5Ofk,469
+symengine-0.11.0.data/purelib/symengine/tests/test_dict_basic.py,sha256=ger2sexbuua1tAxc3JfXlXGrnG2iRAThxGLc01j3jGc,640
+symengine-0.11.0.data/purelib/symengine/tests/test_eval.py,sha256=xIPgDolURXLoc7qehkYKdr8F4reNz5b-Gy9ptJcTbCc,1743
+symengine-0.11.0.data/purelib/symengine/tests/test_expr.py,sha256=pjkUfuLSXQtAQv110uiF0hJJyw_8i3XXU2A-q51GHl0,1037
+symengine-0.11.0.data/purelib/symengine/tests/test_functions.py,sha256=bBJYHB3mtOh82oTA3NMHZumCJoKqWmiAnTN1j19CIIA,11297
+symengine-0.11.0.data/purelib/symengine/tests/test_lambdify.py,sha256=06jS9ivhHnTlLSHOClU5YO-9zTTHQGomA85D-lauPQo,29318
+symengine-0.11.0.data/purelib/symengine/tests/test_logic.py,sha256=j6cUwRw4GXEroWPxbQnJASrSKLew8MXIWvNF0BSVxYQ,3441
+symengine-0.11.0.data/purelib/symengine/tests/test_matrices.py,sha256=JNzb4pyuiSX6A5IkrMwHUfvIFDH3nBdfdzOnHtKH6tc,20620
+symengine-0.11.0.data/purelib/symengine/tests/test_ntheory.py,sha256=jMjJVc1pomRDOWXRqqhQTHHUE-npOki4KxKMvWg6m1k,6312
+symengine-0.11.0.data/purelib/symengine/tests/test_number.py,sha256=F3WIKwBwfWdyHaY7cu9yOtTm4AaGPO71s256tQih3dA,5041
+symengine-0.11.0.data/purelib/symengine/tests/test_pickling.py,sha256=lkRqJkkmg8Cot9ng2WnoVkVQH_LyeOtqx-SZorqZLj0,1562
+symengine-0.11.0.data/purelib/symengine/tests/test_printing.py,sha256=9_t5rlV1NQUZvolvFKiuuCtpwjS_6hb8FBMXkoGKV-o,1286
+symengine-0.11.0.data/purelib/symengine/tests/test_sage.py,sha256=kp_UzeS6vuIlLIc6f3PnykdBMNVKP8k2lZppsX29aOI,5400
+symengine-0.11.0.data/purelib/symengine/tests/test_series_expansion.py,sha256=GfgoubMmPB30nasMB6t9JR-5uVg3xYOk9oAWDr0DWYY,741
+symengine-0.11.0.data/purelib/symengine/tests/test_sets.py,sha256=QWcZHWlK5pD5SZrF72uhYZjhYXm4fbmV5OzrQwqYeYQ,4177
+symengine-0.11.0.data/purelib/symengine/tests/test_solve.py,sha256=MnAdXm3ZyX09FnQixaMNDG7vqMX-rr46U9UF5BpBZoY,935
+symengine-0.11.0.data/purelib/symengine/tests/test_subs.py,sha256=e4o1vadTucwfqgPJkVH9HZqdmMCDUkvbWbzKWNAm24g,1681
+symengine-0.11.0.data/purelib/symengine/tests/test_symbol.py,sha256=5ARwhVtox-fH5kSBgM8JuPbUJK4BJ3HCUo-LiVf39To,5296
+symengine-0.11.0.data/purelib/symengine/tests/test_sympify.py,sha256=yL8JRRdnocswCHQM0S38KDbLB_6VwgZJl3R_HB1M-v4,1868
+symengine-0.11.0.data/purelib/symengine/tests/test_sympy_compat.py,sha256=T24NXeFuStVKvzfZU4HL26RxXkH_2CHCBvdpJsWOd8s,4959
+symengine-0.11.0.data/purelib/symengine/tests/test_sympy_conv.py,sha256=uR_6ThIEyDSq-dbrlE8x52eC3wbdnij0tLbEokLqF04,27637
+symengine-0.11.0.data/purelib/symengine/tests/test_var.py,sha256=q-6R2GVi9AF5eD16jiy_kks2xH4ReUqudZ_S-Zf7O90,1286
+symengine-0.11.0.data/purelib/symengine/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+symengine-0.11.0.dist-info/AUTHORS,sha256=lU0uh2rx9y7oPdDIHVn6UPhKr-C6XViL8sOdYm3DbAM,1553
+symengine-0.11.0.dist-info/LICENSE,sha256=G8qShIi9pC5Eyg0nX_rm672s0L7EATun_ePvfjw0PV4,22201
+symengine-0.11.0.dist-info/METADATA,sha256=Yq6xDwgLDmuH1DuELrsUzcTmZNxZNLawlp6SAqRYDxE,1186
+symengine-0.11.0.dist-info/RECORD,,
+symengine-0.11.0.dist-info/top_level.txt,sha256=ASxf76lo8f1n_6UL_Z5t27oeMUmkRSMzTAtYdzc1ZM8,10
+symengine-0.11.0.dist-info/WHEEL,sha256=F0Sy4cJpUFRte6B8tVdzEjn2lJG_nQtLehByM-2DED0,100

{symengine-0.9.2.dist-info → symengine-0.11.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.37.1)
+Generator: bdist_wheel (0.41.3)
 Root-Is-Purelib: false
 Tag: cp38-cp38-win_amd64
 

symengine-0.11.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+symengine

symengine/lib/config.pxi

@@ -1,6 +0,0 @@
-DEF HAVE_SYMENGINE_MPFR = True
-DEF HAVE_SYMENGINE_MPC = True
-DEF HAVE_SYMENGINE_PIRANHA = False
-DEF HAVE_SYMENGINE_FLINT = True
-DEF HAVE_SYMENGINE_LLVM = True
-DEF HAVE_SYMENGINE_LLVM_LONG_DOUBLE = False

symengine/tests/test_expr.py

@@ -1,14 +0,0 @@
-from symengine import Add, Mul, Symbol, Integer
-from symengine.utilities import raises
-
-
-def test_as_coefficients_dict():
-    x = Symbol('x')
-    y = Symbol('y')
-    check = [x, y, x*y, Integer(1)]
-    assert [(3*x + 2*x + y + 3).as_coefficients_dict()[i] for i in check] == \
-        [5, 1, 0, 3]
-    assert [(3*x*y).as_coefficients_dict()[i] for i in check] == \
-        [0, 0, 3, 0]
-    assert (3.0*x*y).as_coefficients_dict()[3.0*x*y] == 0
-    assert (3.0*x*y).as_coefficients_dict()[x*y] == 3.0