Spaces:
Running
Running
File size: 5,274 Bytes
6a86ad5 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 |
import os
USE_SYMENGINE = os.getenv('USE_SYMENGINE', '0')
USE_SYMENGINE = USE_SYMENGINE.lower() in ('1', 't', 'true') # type: ignore
if USE_SYMENGINE:
from symengine import (Symbol, Integer, sympify as sympify_symengine, S,
SympifyError, exp, log, gamma, sqrt, I, E, pi, Matrix,
sin, cos, tan, cot, csc, sec, asin, acos, atan, acot, acsc, asec,
sinh, cosh, tanh, coth, asinh, acosh, atanh, acoth,
lambdify, symarray, diff, zeros, eye, diag, ones,
expand, Function, symbols, var, Add, Mul, Derivative,
ImmutableMatrix, MatrixBase, Rational, Basic)
from symengine.lib.symengine_wrapper import gcd as igcd
from symengine import AppliedUndef
def sympify(a, *, strict=False):
"""
Notes
=====
SymEngine's ``sympify`` does not accept keyword arguments and is
therefore not compatible with SymPy's ``sympify`` with ``strict=True``
(which ensures that only the types for which an explicit conversion has
been defined are converted). This wrapper adds an addiotional parameter
``strict`` (with default ``False``) that will raise a ``SympifyError``
if ``strict=True`` and the argument passed to the parameter ``a`` is a
string.
See Also
========
sympify: Converts an arbitrary expression to a type that can be used
inside SymPy.
"""
# The parameter ``a`` is used for this function to keep compatibility
# with the SymEngine docstring.
if strict and isinstance(a, str):
raise SympifyError(a)
return sympify_symengine(a)
# Keep the SymEngine docstring and append the additional "Notes" and "See
# Also" sections. Replacement of spaces is required to correctly format the
# indentation of the combined docstring.
sympify.__doc__ = (
sympify_symengine.__doc__
+ sympify.__doc__.replace(' ', ' ') # type: ignore
)
else:
from sympy.core.add import Add
from sympy.core.basic import Basic
from sympy.core.function import (diff, Function, AppliedUndef,
expand, Derivative)
from sympy.core.mul import Mul
from sympy.core.intfunc import igcd
from sympy.core.numbers import pi, I, Integer, Rational, E
from sympy.core.singleton import S
from sympy.core.symbol import Symbol, var, symbols
from sympy.core.sympify import SympifyError, sympify
from sympy.functions.elementary.exponential import log, exp
from sympy.functions.elementary.hyperbolic import (coth, sinh,
acosh, acoth, tanh, asinh, atanh, cosh)
from sympy.functions.elementary.miscellaneous import sqrt
from sympy.functions.elementary.trigonometric import (csc,
asec, cos, atan, sec, acot, asin, tan, sin, cot, acsc, acos)
from sympy.functions.special.gamma_functions import gamma
from sympy.matrices.dense import (eye, zeros, diag, Matrix,
ones, symarray)
from sympy.matrices.immutable import ImmutableMatrix
from sympy.matrices.matrixbase import MatrixBase
from sympy.utilities.lambdify import lambdify
#
# XXX: Handling of immutable and mutable matrices in SymEngine is inconsistent
# with SymPy's matrix classes in at least SymEngine version 0.7.0. Until that
# is fixed the function below is needed for consistent behaviour when
# attempting to simplify a matrix.
#
# Expected behaviour of a SymPy mutable/immutable matrix .simplify() method:
#
# Matrix.simplify() : works in place, returns None
# ImmutableMatrix.simplify() : returns a simplified copy
#
# In SymEngine both mutable and immutable matrices simplify in place and return
# None. This is inconsistent with the matrix being "immutable" and also the
# returned None leads to problems in the mechanics module.
#
# The simplify function should not be used because simplify(M) sympifies the
# matrix M and the SymEngine matrices all sympify to SymPy matrices. If we want
# to work with SymEngine matrices then we need to use their .simplify() method
# but that method does not work correctly with immutable matrices.
#
# The _simplify_matrix function can be removed when the SymEngine bug is fixed.
# Since this should be a temporary problem we do not make this function part of
# the public API.
#
# SymEngine issue: https://github.com/symengine/symengine.py/issues/363
#
def _simplify_matrix(M):
"""Return a simplified copy of the matrix M"""
if not isinstance(M, (Matrix, ImmutableMatrix)):
raise TypeError("The matrix M must be an instance of Matrix or ImmutableMatrix")
Mnew = M.as_mutable() # makes a copy if mutable
Mnew.simplify()
if isinstance(M, ImmutableMatrix):
Mnew = Mnew.as_immutable()
return Mnew
__all__ = [
'Symbol', 'Integer', 'sympify', 'S', 'SympifyError', 'exp', 'log',
'gamma', 'sqrt', 'I', 'E', 'pi', 'Matrix', 'sin', 'cos', 'tan', 'cot',
'csc', 'sec', 'asin', 'acos', 'atan', 'acot', 'acsc', 'asec', 'sinh',
'cosh', 'tanh', 'coth', 'asinh', 'acosh', 'atanh', 'acoth', 'lambdify',
'symarray', 'diff', 'zeros', 'eye', 'diag', 'ones', 'expand', 'Function',
'symbols', 'var', 'Add', 'Mul', 'Derivative', 'ImmutableMatrix',
'MatrixBase', 'Rational', 'Basic', 'igcd', 'AppliedUndef',
]
|