symengine 0.14.0__cp313-cp313t-win_amd64.whl

symengine/lib/symengine_wrapper.pxd

@@ -0,0 +1,78 @@
+#cython: language_level=3
+
+cimport symengine
+from symengine cimport RCP, map_basic_basic, rcp_const_basic
+from libcpp.memory cimport unique_ptr
+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 unique_ptr[symengine.LambdaRealDoubleVisitor] lambda_visitor
+    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 unique_ptr[symengine.LambdaComplexDoubleVisitor] lambda_visitor
+    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 unique_ptr[symengine.LLVMDoubleVisitor] lambda_visitor
+    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 unique_ptr[symengine.LLVMFloatVisitor] lambda_visitor
+    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-0.14.0.data/purelib/symengine/__init__.py

@@ -0,0 +1,79 @@
+import os
+import sys
+
+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):
+            os.add_dll_directory(directory)
+
+del os, sys
+
+import symengine.lib.symengine_wrapper as wrapper
+
+from .lib.symengine_wrapper import (
+    have_mpfr, have_mpc, have_flint, have_piranha, have_llvm, have_llvm_long_double,
+    I, E, pi, oo, zoo, nan, Symbol, Dummy, S, sympify, SympifyError,
+    Integer, Rational, Float, Number, RealNumber, RealDouble, ComplexDouble,
+    add, Add, Mul, Pow, function_symbol,
+    Max, Min, DenseMatrix, Matrix,
+    ImmutableMatrix, ImmutableDenseMatrix, MutableDenseMatrix,
+    MatrixBase, Basic, DictBasic, symarray, series, diff, zeros,
+    eye, diag, ones, Derivative, Subs, expand, has_symbol,
+    UndefFunction, Function, UnevaluatedExpr, latex,
+    have_numpy, true, false, Equality, Unequality, GreaterThan,
+    LessThan, StrictGreaterThan, StrictLessThan, Eq, Ne, Ge, Le,
+    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,
+    golden_ratio as GoldenRatio,
+    catalan as Catalan,
+    eulergamma as EulerGamma,
+    unicode
+)
+from .utilities import var, symbols
+from .functions import *
+from .printing import init_printing
+
+
+AppliedUndef = FunctionSymbol  # an alias
+EmptySet = wrapper.S.EmptySet
+UniversalSet = wrapper.S.UniversalSet
+Reals = wrapper.S.Reals
+Integers = wrapper.S.Integers
+Rationals = wrapper.S.Rationals
+
+
+if have_mpfr:
+    from .lib.symengine_wrapper import RealMPFR
+
+if have_mpc:
+    from .lib.symengine_wrapper import ComplexMPC
+
+if have_numpy:
+    from .lib.symengine_wrapper import (Lambdify, LambdifyCSE)
+
+    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.14.0"
+
+
+# To not expose internals
+del lib.symengine_wrapper
+del lib
+del wrapper
+
+
+def test():
+    import pytest
+    import os
+    return not pytest.cmdline.main(
+        [os.path.dirname(os.path.abspath(__file__))])

symengine-0.14.0.data/purelib/symengine/functions.py

@@ -0,0 +1,10 @@
+from .lib.symengine_wrapper import (sin, cos, tan, cot, csc, sec,
+    asin, acos, atan, acot, acsc, asec,
+    sinh, cosh, tanh, coth, sech, csch,
+    asinh, acosh, atanh, acoth, asech, acsch,
+    gamma, log, atan2, sqrt, exp, Abs,
+    LambertW, zeta, dirichlet_eta,
+    KroneckerDelta, LeviCivita, erf, erfc,
+    lowergamma, uppergamma, loggamma, beta,
+    polygamma, sign, floor, ceiling, 
+    conjugate, digamma, trigamma)

symengine-0.14.0.data/purelib/symengine/printing.py

@@ -0,0 +1,33 @@
+from .lib.symengine_wrapper import ccode, sympify, Basic, repr_latex as _repr_latex
+
+class CCodePrinter:
+
+    def doprint(self, expr, assign_to=None):
+        if not isinstance(assign_to, (Basic, type(None), str)):
+            raise TypeError("{} cannot assign to object of type {}".format(
+                    type(self).__name__, type(assign_to)))
+
+        expr = sympify(expr)
+        if not assign_to:
+            if expr.is_Matrix:
+                raise RuntimeError("Matrices need a assign_to parameter")
+            return ccode(expr)
+
+        assign_to = str(assign_to)
+        if not expr.is_Matrix:
+            return f"{assign_to} = {ccode(expr)};"
+
+        code_lines = []
+        for i, element in enumerate(expr):
+            code_line = f'{assign_to}[{i}] = {element};'
+            code_lines.append(code_line)
+        return '\n'.join(code_lines)
+
+
+def init_printing(pretty_print=True, use_latex=True):
+    if pretty_print:
+        if not use_latex:
+            raise RuntimeError("Only latex is supported for pretty printing")
+        _repr_latex[0] = True
+    else:
+        _repr_latex[0] = False

symengine-0.14.0.data/purelib/symengine/sympy_compat.py

@@ -0,0 +1,4 @@
+import warnings
+warnings.warn("sympy_compat module is deprecated. Use `import symengine` instead", DeprecationWarning,
+              stacklevel=2)
+from symengine import *

symengine-0.14.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-0.14.0.data/purelib/symengine/tests/test_arit.py

@@ -0,0 +1,261 @@
+from symengine.test_utilities import raises
+
+from symengine import (Symbol, Integer, Add, Mul, Pow, Rational, sqrt,
+    symbols, S, I, count_ops, floor)
+
+
+def test_arit1():
+    x = Symbol("x")
+    y = Symbol("y")
+    e = x + y
+    e = x * y
+    e = Integer(2)*x
+    e = 2*x
+    e = x + 1
+    e = 1 + x
+
+
+def test_arit2():
+    x = Symbol("x")
+    y = Symbol("y")
+    assert x+x == Integer(2) * x
+    assert x+x != Integer(3) * x
+    assert x+y == y+x
+    assert x+x == 2*x
+    assert x+x == x*2
+    assert x+x+x == 3*x
+    assert x+y+x+x == 3*x+y
+
+    assert not x+x == 3*x
+    assert not x+x != 2*x
+
+
+def test_arit3():
+    x = Symbol("x")
+    y = Symbol("y")
+    raises(TypeError, lambda: ("x"*x))
+
+
+def test_arit4():
+    x = Symbol("x")
+    y = Symbol("y")
+    assert x*x == x**2
+    assert x*y == y*x
+    assert x*x*x == x**3
+    assert x*y*x*x == x**3*y
+
+
+def test_arit5():
+    x = Symbol("x")
+    y = Symbol("y")
+    e = (x+y)**2
+    f = e.expand()
+    assert e == (x+y)**2
+    assert e != x**2 + 2*x*y + y**2
+    assert isinstance(e, Pow)
+    assert f == x**2 + 2*x*y + y**2
+    assert isinstance(f, Add)
+
+
+def test_arit6():
+    x = Symbol("x")
+    y = Symbol("y")
+    e = x + y
+    assert str(e) == "x + y" or "y + x"
+    e = x * y
+    assert str(e) == "x*y" or "y*x"
+    e = Integer(2)*x
+    assert str(e) == "2*x"
+    e = 2*x
+    assert str(e) == "2*x"
+
+
+def test_arit7():
+    x = Symbol("x")
+    y = Symbol("y")
+    assert x - x == 0
+    assert x - y != y - x
+    assert 2*x - x == x
+    assert 3*x - x == 2*x
+
+    assert 2*x*y - x*y == x*y
+
+
+def test_arit8():
+    x = Symbol("x")
+    y = Symbol("y")
+    z = Symbol("z")
+    assert x**y * x**x == x**(x+y)
+    assert x**y * x**x * x**z == x**(x+y+z)
+    assert x**y - x**y == 0
+
+    assert x**2 / x == x
+    assert y*x**2 / (x*y) == x
+    assert (2 * x**3 * y**2 * z)**3 / 8 == x**9 * y**6 * z**3
+    assert (2*y**(-2*x**2)) * (3*y**(2*x**2)) == 6
+
+
+def test_unary():
+    x = Symbol("x")
+    assert -x == 0 - x
+    assert +x == x
+
+
+def test_expand1():
+    x = Symbol("x")
+    y = Symbol("y")
+    z = Symbol("z")
+    assert ((2*x+y)**2).expand() == 4*x**2 + 4*x*y + y**2
+    assert (x**2)**3 == x**6
+    assert ((2*x**2+3*y)**2).expand() == 4*x**4 + 12*x**2*y + 9*y**2
+    assert ((2*x/3+y/4)**2).expand() == 4*x**2/9 + x*y/3 + y**2/16
+
+
+def test_arit9():
+    x = Symbol("x")
+    y = Symbol("y")
+    assert 1/x == 1/x
+    assert 1/x != 1/y
+
+
+def test_expand2():
+    x = Symbol("x")
+    y = Symbol("y")
+    z = Symbol("z")
+    assert ((1/(y*z) - y*z)*y*z).expand() == 1-(y*z)**2
+    assert (2*(x + 2*(y + z))).expand(deep=False) == 2*x + 4*(y+z)
+    ex = x + 2*(y + z)
+    assert ex.expand(deep=False) == ex
+
+
+def test_expand3():
+    x = Symbol("x")
+    y = Symbol("y")
+    assert ((1/(x*y) - x*y+2)*(1+x*y)).expand() == 3 + 1/(x*y) + x*y - (x*y)**2
+
+
+def test_args():
+    x = Symbol("x")
+    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) == {x**2, 2*x*y, Integer(5)}
+    assert (2*x**2).args == (2, x**2)
+    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() == {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 == {x}
+    assert (x**y + z).free_symbols == {x, y, z}
+
+
+def test_as_numer_denom():
+    x, y = Rational(17, 26).as_numer_denom()
+    assert x == Integer(17)
+    assert y == Integer(26)
+
+    x, y = Integer(-5).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")
+    
+    assert Add._from_args([]) == 0
+    assert Add._from_args([x]) == x
+    assert Add._from_args([x, y]) == x + y
+
+    assert Mul._from_args([]) == 1
+    assert Mul._from_args([x]) == x
+    assert Mul._from_args([x, y]) == x * y
+
+
+def test_make_args():
+    x = Symbol("x")
+    y = Symbol("y")
+    z = Symbol("z")
+
+    assert Add.make_args(x) == (x,)
+    assert Mul.make_args(x) == (x,)
+
+    assert Add.make_args(x*y*z) == (x*y*z,)
+    assert Mul.make_args(x*y*z) == (x*y*z).args
+
+    assert Add.make_args(x + y + z) == (x + y + z).args
+    assert Mul.make_args(x + y + z) == (x + y + z,)
+
+    assert Add.make_args((x + y)**z) == ((x + y)**z,)
+    assert Mul.make_args((x + y)**z) == ((x + y)**z,)
+
+
+def test_Pow_base_exp():
+    x = Symbol("x")
+    y = Symbol("y")
+    e = Pow(x + y, 2)
+    assert isinstance(e, Pow)
+    assert e.exp == 2
+    assert e.base == x + y
+
+    assert sqrt(x - 1).as_base_exp() == (x - 1, Rational(1, 2))
+
+
+def test_copy():
+    b = Symbol("b")
+    a = b.copy()
+    assert a is b
+    assert type(a) == type(b)
+
+
+def test_special_constants():
+    assert S.Zero == Integer(0)
+    assert S.One == Integer(1)
+    assert S.NegativeOne == Integer(-1)
+    assert S.Half == Rational(1, 2)
+
+
+def test_bool():
+    x = Symbol('x')
+    if (x**2).args[1] > 0:
+        assert True
+    if (x**2).args[1] < 0:
+        assert False
+
+
+def test_count_ops():
+    x, y = symbols("x, y")
+    assert count_ops(x+y) == 1
+    assert count_ops((x+y, x*y)) == 2
+    assert count_ops([[x**y], [x+y-1]]) == 3
+    assert count_ops(x+y, x*y) == 2
+

symengine-0.14.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-0.14.0.data/purelib/symengine/tests/test_dict_basic.py

@@ -0,0 +1,28 @@
+from symengine.test_utilities import raises
+
+from symengine import symbols, DictBasic, sin, Integer
+
+
+def test_DictBasic():
+    x, y, z = symbols("x y z")
+    d = DictBasic({x: 2, y: z})
+
+    assert str(d) == "{x: 2, y: z}" or str(d) == "{y: z, x: 2}"
+    assert d[x] == 2
+
+    raises(KeyError, lambda: d[2*z])
+    if 2*z in d:
+        assert False
+
+    d[2*z] = x
+    assert d[2*z] == x
+    if 2*z not in d:
+        assert False
+    assert set(d.items()) == {(2*z, x), (x, Integer(2)), (y, z)}
+
+    del d[x]
+    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-0.14.0.data/purelib/symengine/tests/test_eval.py

@@ -0,0 +1,67 @@
+from symengine.test_utilities import raises
+from symengine import (Symbol, sin, cos, Integer, Add, I, RealDouble, ComplexDouble, sqrt)
+
+from unittest.case import SkipTest
+
+def test_eval_double1():
+    x = Symbol("x")
+    y = Symbol("y")
+    e = sin(x)**2 + cos(x)**2
+    e = e.subs(x, 7)
+    assert abs(e.n(real=True) - 1) < 1e-9
+    assert abs(e.n() - 1) < 1e-9
+
+
+def test_eval_double2():
+    x = Symbol("x")
+    e = sin(x)**2 + sqrt(2)
+    raises(RuntimeError, lambda: e.n(real=True))
+    assert abs(e.n() - sin(x)**2.0 - 1.414) < 1e-3
+
+def test_n():
+    x = Symbol("x")
+    raises(RuntimeError, lambda: x.n(real=True))
+    assert x.n() == x + 0.0
+
+    x = 2 + I
+    raises(RuntimeError, lambda: (x.n(real=True)))
+
+    x = sqrt(Integer(4))
+    y = RealDouble(2.0)
+    assert x.n(real=True) == y
+
+    x = 1 + 2*I
+    y = 1.0 + 2.0*I
+    assert x.n() == y
+
+
+def test_n_mpfr():
+    x = sqrt(Integer(2))
+    try:
+        from symengine import RealMPFR
+        y = RealMPFR('1.41421356237309504880169', 75)
+        assert x.n(75, real=True) == y
+    except ImportError:
+        raises(ValueError, lambda: (x.n(75, real=True)))
+        raises(ValueError, lambda: (x.n(75)))
+        raise SkipTest("No MPFR support")
+
+
+def test_n_mpc():
+    x = sqrt(Integer(2)) + 3*I
+    try:
+        from symengine import ComplexMPC
+        y = ComplexMPC('1.41421356237309504880169', '3.0', 75)
+        assert x.n(75) == y
+    except ImportError:
+        raises(Exception, lambda: (x.n(75, real=True)))
+        raises(ValueError, lambda: (x.n(75, real=False)))
+        raises(ValueError, lambda: (x.n(75)))
+        raise SkipTest("No MPC support")
+
+
+def test_rel():
+    x = Symbol("x")
+    y = Symbol("y")
+    ex = (x + y < x)
+    assert repr(ex) == "x + y < x"