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

symengine/lib/symengine_wrapper.pxd

@@ -1,86 +1,77 @@
-#cython: language_level=3
-
-cimport symengine
-from symengine cimport RCP, map_basic_basic, rcp_const_basic
-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
-
-cdef class MatrixBase(object):
-    cdef symengine.MatrixBase* thisptr
-
-cdef class PyFunctionClass(object):
-    cdef RCP[const symengine.PyFunctionClass] thisptr
-
-cdef class PyModule(object):
-    cdef RCP[const symengine.PyModule] thisptr
-
-cdef class _DictBasic(object):
-    cdef map_basic_basic c
-
-cdef class DictBasicIter(object):
-    cdef map_basic_basic.iterator begin
-    cdef map_basic_basic.iterator end
-    cdef init(self, map_basic_basic.iterator begin, map_basic_basic.iterator end)
-
-cdef object c2py(rcp_const_basic o)
-
-cdef class _Lambdify(object):
-    cdef size_t args_size, tot_out_size
-    cdef list out_shapes
-    cdef readonly bint real
-    cdef readonly size_t n_exprs
-    cdef public str order
-    cdef vector[int] accum_out_sizes
-    cdef object numpy_dtype
-
-    cdef _init(self, symengine.vec_basic& args_, symengine.vec_basic& outs_, cppbool cse)
-    cdef _load(self, const string &s)
-    cpdef eval_real(self, inp, out)
-    cpdef eval_complex(self, inp, out)
-    cpdef unsafe_eval(sef, inp, out, unsigned nbroadcast=*)
-
-cdef class LambdaDouble(_Lambdify):
-    cdef vector[symengine.LambdaRealDoubleVisitor] lambda_double
-    cdef _init(self, symengine.vec_basic& args_, symengine.vec_basic& outs_, cppbool cse)
-    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)
-    cpdef unsafe_real(self,
-                      double[::1] inp, double[::1] out,
-                      int inp_offset=*, int out_offset=*)
-
-cdef class LambdaComplexDouble(_Lambdify):
-    cdef vector[symengine.LambdaComplexDoubleVisitor] lambda_double
-    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=*)
+#cython: language_level=3
+
+cimport symengine
+from symengine cimport RCP, map_basic_basic, rcp_const_basic
+from libcpp.vector cimport vector
+from libcpp.string cimport string
+from libcpp cimport bool as cppbool
+
+cdef class Basic(object):
+    cdef rcp_const_basic thisptr
+
+cdef class MatrixBase(object):
+    cdef symengine.MatrixBase* thisptr
+
+cdef class PyFunctionClass(object):
+    cdef RCP[const symengine.PyFunctionClass] thisptr
+
+cdef class PyModule(object):
+    cdef RCP[const symengine.PyModule] thisptr
+
+cdef class _DictBasic(object):
+    cdef map_basic_basic c
+
+cdef class DictBasicIter(object):
+    cdef map_basic_basic.iterator begin
+    cdef map_basic_basic.iterator end
+    cdef init(self, map_basic_basic.iterator begin, map_basic_basic.iterator end)
+
+cdef object c2py(rcp_const_basic o)
+
+cdef class _Lambdify(object):
+    cdef size_t args_size, tot_out_size
+    cdef list out_shapes
+    cdef readonly bint real
+    cdef readonly size_t n_exprs
+    cdef public str order
+    cdef vector[int] accum_out_sizes
+    cdef object numpy_dtype
+
+    cdef _init(self, symengine.vec_basic& args_, symengine.vec_basic& outs_, cppbool cse)
+    cdef _load(self, const string &s)
+    cpdef eval_real(self, inp, out)
+    cpdef eval_complex(self, inp, out)
+    cpdef unsafe_eval(sef, inp, out, unsigned nbroadcast=*)
+
+cdef class LambdaDouble(_Lambdify):
+    cdef vector[symengine.LambdaRealDoubleVisitor] lambda_double
+    cdef _init(self, symengine.vec_basic& args_, symengine.vec_basic& outs_, cppbool cse)
+    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)
+    cpdef unsafe_real(self,
+                      double[::1] inp, double[::1] out,
+                      int inp_offset=*, int out_offset=*)
+
+cdef class LambdaComplexDouble(_Lambdify):
+    cdef vector[symengine.LambdaComplexDoubleVisitor] lambda_double
+    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=*)
+
+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)