如何在Python中获得复指数函数的实部或虚部

Question

我特别使用 Jupyter。例如，从方程 e^2+j 中，我怎样才能将它分为实部 (e²) 和虚部 (e^j )? 我试过了： exp(complex(2,1)).real 然而，随之而来的错误是：'Mul' 对象没有属性'real'。 另一种解决方案可能是实现欧拉公式以将其分离为 cos(2)+j·sin(1) 但到目前为止没有成功。通常问题是当复数出现在幂位置而不是通常的格式 (2+j) 时。如果有人对此事有任何想法，将不胜感激！

更适合我的问题的重要编辑：

在我的情况下，我拥有的复杂方程是通过 dsolve() 获得的二阶微分方程。对于 nympy 中存在的 exp() 元素，这是一个有效的解决方案，它与任意方程不同。然而，我的方程只是上面的一个关于它的复杂性

我包含我的代码：

import scipy as sp
from sympy import*
import sympy as syp
from scipy.integrate import odeint

t, z, w, C2=symbols('t, z, w, C2')
x=Function('x')
eq=x(t).diff(t,2)+2*z*w*x(t).diff(t,1)+w**2*x(t)
sol=dsolve(eq,x(t),ics={x(0):0,x(t).diff(t,1).subs(t,0):2*C2*w*sqrt(z**2-1)})

接下来我想替换 z,w 参数以拟合我的数据，然后使用循环创建一个数组，该数组采用数值解来绘制它们。我尝试了以下方法：

for i in range(1000):
    step.append(i)
numdata=[]
for i in range(1000):
    numdata.append(N(sol.rhs.subs(t,i).subs(w,10).subs(z,0.001)))

但是这不起作用，因为sol 是一个复杂的函数。在这段漫长的旅程之后，我试图找到（我生命的意义）分离这种功能的真实部分和想象部分的方法。 谢谢你一直陪着我，不管结果如何，你都是英雄。

Answer 1

我认为出现此问题是因为您尝试将from numpy import * 与from sympy import * 一起使用

因为 numpy 和 sympy 都有自己的 exp 定义。错误告诉您 Mul 对象没有 exp 方法，因为解释器现在混淆了 sympy 和 numpy 方法。

因此我建议改为这样做 -

import numpy as np
import sympy as sp

Reference here

之后你可以简单地做 -

np.exp(complex(2,1)).imag
#Output - 6.217676312367968

np.exp(complex(2,1)).real
#Output - 3.992324048441272

np.exp(complex(2,1))
#Output - (3.992324048441272+6.217676312367968j)

---

编辑：由于您从 sympy dsolve() 获得输出，您可以尝试使用替代形式的

e^(a+ib) = e^acos(b) + ie^asin(b)

c = complex(2,1)

complex(sp.exp(c.real)*sp.cos(c.imag), sp.exp(c.real)*sp.sin(c.imag))
#Output - (3.992324048441272+6.217676312367968j)

sp.exp(c.real)*sp.cos(c.imag)
#Output - 3.992324048441272

sp.exp(c.real)*sp.sin(c.imag)
#Output - 6.217676312367968

---

编辑2：你可以lambdify你的函数，然后求解得到真实和想象的部分。

expp = lambdify([(t,z,w,C2)],sol.rhs)
expp((1,complex(4,3),4,6))
#output - (4.234414847842685+1.053014400461299j)

expp((1,complex(4,3),4,6)).real
#output - 4.234414847842685

expp((1,complex(4,3),4,6)).imag
#output - 1.053014400461299

Answer 2

sympy 具有re 和im 功能：

In [113]: exp(complex(2,1))                                                                          
Out[113]: 
                  1.0⋅ⅈ
7.38905609893065⋅ℯ     

In [114]: re(exp(complex(2,1)))                                                                      
Out[114]: 3.99232404844127

In [115]: im(exp(complex(2,1)))                                                                      
Out[115]: 6.21767631236797

In [116]: exp(complex(2,1)).evalf()                                                                  
Out[116]: 3.99232404844127 + 6.21767631236797⋅ⅈ

.real 和.imag 是numpy 数组（和复杂的python 数字）的属性（可能实现为属性）。

进一步探索sympy：

In [152]: expand(exp(y),complex=True)                                                                
Out[152]: 
   re(y)               re(y)           
ⅈ⋅ℯ     ⋅sin(im(y)) + ℯ     ⋅cos(im(y))

In [153]: expand(exp(complex(2,1)),complex=True)                                                     
Out[153]: 3.99232404844127 + 6.21767631236797⋅ⅈ

---

你的sol：

In [157]: sol                                                                                        
Out[157]: 
                 ⎛        ________⎞           ⎛        ________⎞
                 ⎜       ╱  2     ⎟           ⎜       ╱  2     ⎟
             t⋅w⋅⎝-z - ╲╱  z  - 1 ⎠       t⋅w⋅⎝-z + ╲╱  z  - 1 ⎠
x(t) = - C₂⋅ℯ                       + C₂⋅ℯ                      

In [181]: f1 = sol.rhs.subs({w:10, z:0.001,C2:1})                                                    

In [182]: f1                                                                                         
Out[182]: 
   10⋅t⋅(-0.001 - 0.999999499999875⋅ⅈ)    10⋅t⋅(-0.001 + 0.999999499999875⋅ⅈ)
- ℯ                                    + ℯ                                   

制作numpy 兼容函数：

In [187]: f = lambdify(t, f1)                                                                        

In [188]: print(f.__doc__)                                                                           
Created with lambdify. Signature:

func(t)

Expression:

-exp(10*t*(-0.001 - 0.999999499999875*I)) + exp(10*t*(-0.001 +...

Source code:

def _lambdifygenerated(t):
    return (-exp(10*t*(-0.001 - 0.999999499999875*1j)) + exp(10*t*(-0.001 + 0.999999499999875*1j)))


Imported modules:

在一个值范围内评估它：

In [189]: f(np.arange(10))                                                                           
Out[189]: 
array([0.+0.j        , 0.-1.07720771j, 0.+1.78972745j, 0.-1.91766624j,
       0.+1.43181934j, 0.-0.49920326j, 0.-0.57406585j, 0.+1.44310044j,
       0.-1.83494157j, 0.+1.63413971j])

只有 sympy 的值相同：

In [199]: [im(f1.evalf(subs={t:i})) for i in range(10)]                                              
Out[199]: 
[0, -1.0772077135423, 1.78972744700845, -1.9176662437755, 1.43181934232583, -0.499203257243971, -0.
574065847629935, 1.44310044143674, -1.83494157235822, 1.63413971490123]