在 Sympy 中使用 lambdify 将具有复指数的表达式转换为 function

Question

I have a Sympy expression of the form

exp =  0.5*y1**2 + 2*y1*y2 + 2.5*x5**2 + 5.0*x6**2 - 25.0*exp(2.0*I*x4)*exp(1.0*I*x5) - 25.0*exp(2.0*I*x4) + 100.0 - 25.0*exp(-2.0*I*x4) - 25.0*exp(-2.0*I*x4)*exp(-1.0*I*x5)

I would like to convert the above expression to a function using the variables as arguments. Further, the parameters take sparse scipy csc matrices as input in place of the variables. So, I used the following to convert it into a function.

func = lambdify((y1,y2,x4,x5,x6),exp,"scipy")

Though, this function is generated without any error the function does not work with csc sparse matrices. It gives the following error:

from scipy import sparse
a = sparse.identity(12000,format="csc")
func(a,a,a,a,a) # just to test the output
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
~/.local/lib/python3.9/site-packages/scipy/sparse/base.py in __getattr__(self, attr)
    686         else:
--> 687             raise AttributeError(attr + " not found")
    688 

AttributeError: exp not found

The above exception was the direct cause of the following exception:

TypeError                                 Traceback (most recent call last)
<ipython-input-321-ee4555e1ca2e> in <module>
      1 a = sparse.identity(21,format="csc")
----> 2 func(a,a)

<lambdifygenerated-23> in _lambdifygenerated(x2, n2)
      1 def _lambdifygenerated(x2, n2):
----> 2     return (0.125*n2**2 - 25.0*exp(2.0*1j*x2) - 25.0*exp(-2.0*1j*x2))

~/.local/lib/python3.9/site-packages/scipy/_lib/deprecation.py in call(*args, **kwargs)
     18             warnings.warn(msg, category=DeprecationWarning,
     19                           stacklevel=stacklevel)
---> 20             return fun(*args, **kwargs)
     21         call.__doc__ = msg
     22         return call

TypeError: loop of ufunc does not support argument 0 of type csc_matrix which has no callable exp method

Which shows that the exponent of a sparse matrix is not defined. So, I tried to replace the exp(I*x1) with a separate variable and then use that as a parameter. But, when I use subs, I get the following result.

$exp.subs(exp(I*x4),e4)
0.5*y1**2 + 2*y1*y2 + 2.5*x5**2 + 5.0*x6**2 - 25.0*e4**2.0*exp(1.0*I*x5) - 25.0*e4**2.0 + 100.0 - 25.0/e4**2.0 - 25.0/e4**2.0*exp(-1.0*I*x5)

The problem with the above result is that the negative powers of the exponential are replaced with variable e4 in the denominator. So, a lambdify version of the same does not work with matrices as the operation of division for a matrix is undefined. I tried to use replace to replace the terms of the form exp(1.0*I*x5) and exp(-1.0*I*x5) separately, but this does not work well with terms such as exp(2.0*I*x5) .

Can anything be done to work around this situation? Any help will be appreciated.

Edit: Some part of the above answer is modified to include a reproducible example. Also, I am using square matrices with complex numbers, whose size can be much larger, like 12000 x 12000.

Thanks!

Answer 1

np.exp cannot work on a sparse matrix:

In [64]: from scipy import sparse
In [65]: M = sparse.random(10,10,.2, 'csc')
In [66]: np.exp(M)
Traceback (most recent call last):
  File "/usr/local/lib/python3.8/dist-packages/scipy/sparse/base.py", line 687, in __getattr__
    raise AttributeError(attr + " not found")
AttributeError: exp not found

The above exception was the direct cause of the following exception:
Traceback (most recent call last):
  File "<ipython-input-66-1b6c717c2aff>", line 1, in <module>
    np.exp(M)
TypeError: loop of ufunc does not support argument 0 of type csc_matrix which has no callable exp method

np.exp , like many numpy functions, turns non-array arguments into arrays first:

In [67]: np.array(M)
Out[67]: 
array(<10x10 sparse matrix of type '<class 'numpy.float64'>'
    with 20 stored elements in Compressed Sparse Column format>, dtype=object)

But that naive conversion just produces a 0d object dtpe array, without changing the sparse matrix. In turn it tries to use a non-existent exp method.

Properly converting the sparse matrix to a (dense) array does work:

np.exp(M.A)

producing an array result. You don't loose anything by switching to dense arrays, since exp(0) is 1.

Use help(f) (or ipython f? ) to see the function's doc (and code), eg:

Created with lambdify. Signature:

func(x, y)

Expression:

0.5*x**2 + 25.0*exp(2*I*x)

Source code:

def _lambdifygenerated(x, y):
    return (0.5*x**2 + 25.0*exp(2*1j*x))

np.expm1(M) also works, because M.expm1() is defined.

Since exp(0) is 1, doing exp on a sparse matrix would produce an array with 1's where the original had 0s, ie a non-sparse array. expm1 on the other hand preserves sparsity, in effect it can apply the function to all non-zero elements, ignoring the (default) 0s.

In sum, change your x4 and x5 to dense arrays, and it should run.

Answer 2

I was able to make it work by editing the globals dictionary used by the lambdify function. This function describes the functions which replace the mathematical functions used in a sympy expression. Since the problem here is with the operator of exp , it can be replaced by expm from scipy using the following command. The resultant function is now able to take csc sparse matrices as input.

f = lambdify((symbols("v2,x2")),exp.expand(), [{'exp':scipy.linalg.expm},"scipy"])

Hope this helps anyone else facing a similar problem!