symengine 0.9.2__cp39-cp39-macosx_11_0_arm64.whl → 0.11.0__cp39-cp39-macosx_11_0_arm64.whl

symengine/lib/symengine_wrapper.pxd

@@ -6,8 +6,6 @@ from libcpp.vector cimport vector
 from libcpp.string cimport string
 from libcpp cimport bool as cppbool
 
-include "config.pxi"
-
 cdef class Basic(object):
     cdef rcp_const_basic thisptr
 
@@ -60,27 +58,20 @@ cdef class LambdaComplexDouble(_Lambdify):
     cdef _init(self, symengine.vec_basic& args_, symengine.vec_basic& outs_, cppbool cse)
     cpdef unsafe_complex(self, double complex[::1] inp, double complex[::1] out, int inp_offset=*, int out_offset=*)
 
-IF HAVE_SYMENGINE_LLVM:
-    cdef class _LLVMLambdify(_Lambdify):
-        cdef int opt_level
-
-    cdef class LLVMDouble(_LLVMLambdify):
-        cdef vector[symengine.LLVMDoubleVisitor] lambda_double
-        cdef _init(self, symengine.vec_basic& args_, symengine.vec_basic& outs_, cppbool cse)
-        cdef _load(self, const string &s)
-        cpdef unsafe_real(self, double[::1] inp, double[::1] out, int inp_offset=*, int out_offset=*)
-        cpdef as_scipy_low_level_callable(self)
-        cpdef as_ctypes(self)
-
-    cdef class LLVMFloat(_LLVMLambdify):
-        cdef vector[symengine.LLVMFloatVisitor] lambda_double
-        cdef _init(self, symengine.vec_basic& args_, symengine.vec_basic& outs_, cppbool cse)
-        cdef _load(self, const string &s)
-        cpdef unsafe_real(self, float[::1] inp, float[::1] out, int inp_offset=*, int out_offset=*)
-
-    IF HAVE_SYMENGINE_LLVM_LONG_DOUBLE:
-        cdef class LLVMLongDouble(_LLVMLambdify):
-            cdef vector[symengine.LLVMLongDoubleVisitor] lambda_double
-            cdef _init(self, symengine.vec_basic& args_, symengine.vec_basic& outs_, cppbool cse)
-            cdef _load(self, const string &s)
-            cpdef unsafe_real(self, long double[::1] inp, long double[::1] out, int inp_offset=*, int out_offset=*)
+cdef class _LLVMLambdify(_Lambdify):
+    cdef int opt_level
+
+cdef class LLVMDouble(_LLVMLambdify):
+    cdef vector[symengine.LLVMDoubleVisitor] lambda_double
+    cdef _init(self, symengine.vec_basic& args_, symengine.vec_basic& outs_, cppbool cse)
+    cdef _load(self, const string &s)
+    cpdef unsafe_real(self, double[::1] inp, double[::1] out, int inp_offset=*, int out_offset=*)
+    cpdef as_scipy_low_level_callable(self)
+    cpdef as_ctypes(self)
+
+cdef class LLVMFloat(_LLVMLambdify):
+    cdef vector[symengine.LLVMFloatVisitor] lambda_double
+    cdef _init(self, symengine.vec_basic& args_, symengine.vec_basic& outs_, cppbool cse)
+    cdef _load(self, const string &s)
+    cpdef unsafe_real(self, float[::1] inp, float[::1] out, int inp_offset=*, int out_offset=*)
+

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

@@ -1,7 +1,7 @@
 import os
 import sys
 
-if sys.version_info >= (3, 8, 0) and sys.platform == 'win32' \
+if sys.platform == 'win32' \
        and 'SYMENGINE_PY_ADD_PATH_TO_SEARCH_DIRS' in os.environ:
     for directory in os.environ['PATH'].split(';'):
         if os.path.isdir(directory):
@@ -26,7 +26,7 @@ from .lib.symengine_wrapper import (
     Gt, Lt, And, Or, Not, Nand, Nor, Xor, Xnor, perfect_power, integer_nthroot,
     isprime, sqrt_mod, Expr, cse, count_ops, ccode, Piecewise, Contains, Interval, FiniteSet,
     linsolve,
-    FunctionSymbol as AppliedUndef,
+    FunctionSymbol,
     golden_ratio as GoldenRatio,
     catalan as Catalan,
     eulergamma as EulerGamma,
@@ -37,6 +37,7 @@ from .functions import *
 from .printing import init_printing
 
 
+AppliedUndef = FunctionSymbol  # an alias
 EmptySet = wrapper.S.EmptySet
 UniversalSet = wrapper.S.UniversalSet
 Reals = wrapper.S.Reals
@@ -55,9 +56,14 @@ if have_numpy:
 
     def lambdify(args, exprs, **kwargs):
         return Lambdify(args, *exprs, **kwargs)
+else:
+    def __getattr__(name):
+        if name == 'lambdify':
+            raise AttributeError("Cannot import numpy, which is required for `lambdify` to work")
+        raise AttributeError(f"module 'symengine' has no attribute '{name}'")
 
 
-__version__ = "0.9.2"
+__version__ = "0.11.0"
 
 
 # To not expose internals

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

@@ -4,7 +4,7 @@ class CCodePrinter:
 
     def doprint(self, expr, assign_to=None):
         if not isinstance(assign_to, (Basic, type(None), str)):
-            raise TypeError("{0} cannot assign to object of type {1}".format(
+            raise TypeError("{} cannot assign to object of type {}".format(
                     type(self).__name__, type(assign_to)))
 
         expr = sympify(expr)
@@ -15,11 +15,11 @@ class CCodePrinter:
 
         assign_to = str(assign_to)
         if not expr.is_Matrix:
-            return "{} = {};".format(assign_to, ccode(expr))
+            return f"{assign_to} = {ccode(expr)};"
 
         code_lines = []
         for i, element in enumerate(expr):
-            code_line = '{}[{}] = {};'.format(assign_to, i, element)
+            code_line = f'{assign_to}[{i}] = {element};'
             code_lines.append(code_line)
         return '\n'.join(code_lines)
 

symengine-0.11.0.data/purelib/symengine/test_utilities.py

@@ -0,0 +1,95 @@
+import sys
+
+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:
+        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)
+
+

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

@@ -1,7 +1,7 @@
-from symengine.utilities import raises
+from symengine.test_utilities import raises
 
 from symengine import (Symbol, Integer, Add, Mul, Pow, Rational, sqrt,
-    symbols, S, I, count_ops)
+    symbols, S, I, count_ops, floor)
 
 
 def test_arit1():
@@ -133,27 +133,27 @@ def test_args():
     y = Symbol("y")
     assert (x**2).args == (x, 2)
     assert (x**2 + 5).args == (5, x**2)
-    assert set((x**2 + 2*x*y + 5).args) == set((x**2, 2*x*y, Integer(5)))
+    assert set((x**2 + 2*x*y + 5).args) == {x**2, 2*x*y, Integer(5)}
     assert (2*x**2).args == (2, x**2)
-    assert set((2*x**2*y).args) == set((Integer(2), x**2, y))
+    assert set((2*x**2*y).args) == {Integer(2), x**2, y}
 
 
 def test_atoms():
     x = Symbol("x")
     y = Symbol("y")
     z = Symbol("z")
-    assert (x**2).atoms() == set([x])
-    assert (x**2).atoms(Symbol) == set([x])
-    assert (x ** y + z).atoms() == set([x, y, z])
-    assert (x**y + z).atoms(Symbol) == set([x, y, z])
+    assert (x**2).atoms() == {x}
+    assert (x**2).atoms(Symbol) == {x}
+    assert (x ** y + z).atoms() == {x, y, z}
+    assert (x**y + z).atoms(Symbol) == {x, y, z}
 
 
 def test_free_symbols():
     x = Symbol("x")
     y = Symbol("y")
     z = Symbol("z")
-    assert (x**2).free_symbols == set([x])
-    assert (x**y + z).free_symbols == set([x, y, z])
+    assert (x**2).free_symbols == {x}
+    assert (x**y + z).free_symbols == {x, y, z}
 
 
 def test_as_numer_denom():
@@ -165,12 +165,23 @@ def test_as_numer_denom():
     assert x == Integer(-5)
     assert y == Integer(1)
 
+
+def test_floor():
+    exprs = [Symbol("x"), Symbol("y"), Integer(2), Rational(-3, 5), Integer(-3)]
+
+    for x in exprs:
+        for y in exprs:
+            assert x // y == floor(x / y)
+            assert x == y * (x // y) + x % y
+
+
 def test_as_real_imag():
     x, y = (5 + 6 * I).as_real_imag()
 
     assert x == 5
     assert y == 6
 
+
 def test_from_args():
     x = Symbol("x")
     y = Symbol("y")

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

@@ -0,0 +1,17 @@
+from symengine import cse, sqrt, symbols
+
+def test_cse_single():
+    x, y, x0 = symbols("x, y, x0")
+    e = pow(x + y, 2) + sqrt(x + y)
+    substs, reduced = cse([e])
+    assert substs == [(x0, x + y)]
+    assert reduced == [sqrt(x0) + x0**2]
+
+
+def test_multiple_expressions():
+    w, x, y, z, x0 = symbols("w, x, y, z, x0")
+    e1 = (x + y)*z
+    e2 = (x + y)*w
+    substs, reduced = cse([e1, e2])
+    assert substs == [(x0, x + y)]
+    assert reduced == [x0*z, x0*w]

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

@@ -1,4 +1,4 @@
-from symengine.utilities import raises
+from symengine.test_utilities import raises
 
 from symengine import symbols, DictBasic, sin, Integer
 
@@ -18,11 +18,11 @@ def test_DictBasic():
     assert d[2*z] == x
     if 2*z not in d:
         assert False
-    assert set(d.items()) == set([(2*z, x), (x, Integer(2)), (y, z)])
+    assert set(d.items()) == {(2*z, x), (x, Integer(2)), (y, z)}
 
     del d[x]
-    assert set(d.keys()) == set([2*z, y])
-    assert set(d.values()) == set([x, z])
+    assert set(d.keys()) == {2*z, y}
+    assert set(d.values()) == {x, z}
 
     e = y + sin(2*z)
     assert e.subs(d) == z + sin(x)

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

@@ -1,4 +1,4 @@
-from symengine.utilities import raises
+from symengine.test_utilities import raises
 from symengine import (Symbol, sin, cos, Integer, Add, I, RealDouble, ComplexDouble, sqrt)
 
 from unittest.case import SkipTest
@@ -16,7 +16,7 @@ def test_eval_double2():
     x = Symbol("x")
     e = sin(x)**2 + sqrt(2)
     raises(RuntimeError, lambda: e.n(real=True))
-    assert abs(e.n() - x**2 - 1.414) < 1e-3
+    assert abs(e.n() - sin(x)**2.0 - 1.414) < 1e-3
 
 def test_n():
     x = Symbol("x")

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

@@ -0,0 +1,28 @@
+from symengine import Symbol, Integer, oo
+from symengine.test_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
+
+
+def test_as_powers_dict():
+    x = Symbol('x')
+    y = Symbol('y')
+
+    assert (2*x**y).as_powers_dict() == {2: 1, x: y}
+    assert (2*x**2*y**3).as_powers_dict() == {2: 1, x: 2, y: 3}
+    assert (-oo).as_powers_dict() == {Integer(-1): 1, oo: 1}
+    assert (x**y).as_powers_dict() == {x: y}
+    assert ((1/Integer(2))**y).as_powers_dict() == {Integer(2): -y}
+    assert (x*(1/Integer(2))**y).as_powers_dict() == {x: Integer(1), Integer(2): -y}
+    assert (2**y).as_powers_dict() == {2: y}
+    assert (2**-y).as_powers_dict() == {2: -y}

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

@@ -5,7 +5,7 @@ from symengine import (
     loggamma, beta, polygamma, digamma, trigamma, sign, floor, ceiling, conjugate,
     nan, Float, UnevaluatedExpr
 )
-from symengine.utilities import raises
+from symengine.test_utilities import raises
 
 import unittest
 
@@ -85,6 +85,7 @@ def test_derivative():
     assert s.variables == (x,)
 
     fxy = Function("f")(x, y)
+    assert (1+fxy).has(fxy)
     g = Derivative(Function("f")(x, y), x, 2, y, 1)
     assert g == fxy.diff(x, x, y)
     assert g == fxy.diff(y, 1, x, 2)

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

@@ -1,17 +1,12 @@
-# -*- coding: utf-8 -*-
-from __future__ import (absolute_import, division, print_function)
-
-
 import array
 import cmath
 from functools import reduce
 import itertools
 from operator import mul
 import math
-import sys
 
 import symengine as se
-from symengine.utilities import raises
+from symengine.test_utilities import raises
 from symengine import have_numpy
 import unittest
 from unittest.case import SkipTest

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

@@ -1,4 +1,4 @@
-from symengine.utilities import raises
+from symengine.test_utilities import raises
 from symengine.lib.symengine_wrapper import (true, false, Eq, Ne, Ge, Gt, Le, Lt, Symbol,
                                             I, And, Or, Not, Nand, Nor, Xor, Xnor, Piecewise,
                                             Contains, Interval, FiniteSet, oo, log)
@@ -44,6 +44,7 @@ def test_And():
     assert And(True, False) == false
     assert And(False, False) == false
     assert And(True, True, True) == true
+    raises(TypeError, lambda: x < y and y < 1)
 
 
 def test_Or():
@@ -54,6 +55,7 @@ def test_Or():
     assert Or(True, False) == true
     assert Or(False, False) == false
     assert Or(True, False, False) == true
+    raises(TypeError, lambda: x < y or y < 1)
 
 
 def test_Nor():
@@ -116,4 +118,4 @@ def test_Contains():
     assert Contains(x, Interval(1, 1)) != false
     assert Contains(oo, Interval(-oo, oo)) == false
     assert Contains(-oo, Interval(-oo, oo)) == false
-    
+

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

@@ -2,14 +2,24 @@ from symengine import symbols, init_printing
 from symengine.lib.symengine_wrapper import (DenseMatrix, Symbol, Integer,
     Rational, function_symbol, I, NonSquareMatrixError, ShapeError, zeros,
     ones, eye, ImmutableMatrix)
-from symengine.utilities import raises
+from symengine.test_utilities import raises
+import unittest
 
 
 try:
     import numpy as np
-    HAVE_NUMPY = True
+    have_numpy = True
 except ImportError:
-    HAVE_NUMPY = False
+    have_numpy = False
+    
+try:
+    import sympy
+    from sympy.core.cache import clear_cache
+    import atexit
+    atexit.register(clear_cache)
+    have_sympy = True
+except ImportError:
+    have_sympy = False
 
 
 def test_init():
@@ -520,10 +530,8 @@ def test_reshape():
     assert C != A
 
 
-# @pytest.mark.skipif(not HAVE_NUMPY, reason='requires numpy')
+@unittest.skipIf(not have_numpy, 'requires numpy')
 def test_dump_real():
-    if not HAVE_NUMPY:  # nosetests work-around
-        return
     ref = [1, 2, 3, 4]
     A = DenseMatrix(2, 2, ref)
     out = np.empty(4)
@@ -531,10 +539,9 @@ def test_dump_real():
     assert np.allclose(out, ref)
 
 
-# @pytest.mark.skipif(not HAVE_NUMPY, reason='requires numpy')
+
+@unittest.skipIf(not have_numpy, 'requires numpy')
 def test_dump_complex():
-    if not HAVE_NUMPY:  # nosetests work-around
-        return
     ref = [1j, 2j, 3j, 4j]
     A = DenseMatrix(2, 2, ref)
     out = np.empty(4, dtype=np.complex128)
@@ -721,7 +728,7 @@ def test_atoms():
     a = Symbol("a")
     b = Symbol("b")
     X = DenseMatrix([[a, 2], [b, 4]])
-    assert X.atoms(Symbol) == set([a, b])
+    assert X.atoms(Symbol) == {a, b}
 
 
 def test_LUdecomp():
@@ -741,3 +748,8 @@ def test_repr_latex():
     latex_string = testmat._repr_latex_()
     assert isinstance(latex_string, str)
     init_printing(False)
+
+@unittest.skipIf(not have_sympy, "SymPy not installed")
+def test_simplify():
+    A = ImmutableMatrix([1])
+    assert type(A.simplify()) == type(A)

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

@@ -1,4 +1,4 @@
-from symengine.utilities import raises
+from symengine.test_utilities import raises
 
 from symengine.lib.symengine_wrapper import (isprime, nextprime, gcd,
     lcm, gcd_ext, mod, quotient, quotient_mod, mod_inverse, crt, fibonacci,

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

@@ -1,4 +1,4 @@
-from symengine.utilities import raises
+from symengine.test_utilities import raises
 
 from symengine import Integer, I, S, Symbol, pi, Rational
 from symengine.lib.symengine_wrapper import (perfect_power, is_square, integer_nthroot)

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()))