Python Numpy/Scipy求解带有积分的模拟方程组

我尝试使用numpy和scipy来解决以下两个方程：

P(z) = sgn(-cos(np.pi*D1) + cos(5*z)) * sgn(-cos(np.pi*D2) + cos(6*z))

1. 0 = 2/2pi ∫ P(z,D1,D2) * cos(5z) dz + z/L

2. 0 = 2/2pi ∫ P(z,D1,D2) * cos(6z) dz - z/L

对于

D1

和

D2

（积分限值为0->2pi）

我的代码是：

def equations(p, z):
    D1, D2 = p
    period = 2*np.pi

    P1 = lambda zz, D1, D2: \
            np.sign(-np.cos(np.pi*D1) + np.cos(6.*zz)) * \
            np.sign(-np.cos(np.pi*D2) + np.cos(5.*zz)) * \
            np.cos(6.*zz)
    P2 = lambda zz, D1, D2: \
            np.sign(-np.cos(np.pi*D1) + np.cos(6.*zz)) * \
            np.sign(-np.cos(np.pi*D2) + np.cos(5.*zz)) * \
            np.cos(5.*zz)

    eq1 = 2./period * integrate.quad(P1, 0., period, args=(D1,D2), epsabs=0.01)[0] + z
    eq2 = 2./period * integrate.quad(P2, 0., period, args=(D1,D2), epsabs=0.01)[0] - z
    return (eq1, eq2)


z = np.arange(0., 1000., 0.01)

N = int(len(z))

D1 = np.empty([N])
D2 = np.empty([N])
for i in range(N):
    D1[i], D2[i] = fsolve(equations, x0=(0.5, 0.5), args=z[i])

print D1, D2

不幸的是，它似乎没有收敛。我对数值方法知之甚少，希望有人能帮我一把

多谢各位

顺便说一句，我也在尝试以下应该是等效的方法：

import numpy as np
from scipy.optimize import fsolve
from scipy import integrate
from scipy import signal

def equations(p, z):
    D1, D2 = p
    period = 2.*np.pi

    K12 = 1./L * z
    K32 = -1./L * z + 1.

    P1 = lambda zz, D1, D2: \
            signal.square(6.*zz, duty=D1) * \
            signal.square(5.*zz, duty=D2) * \
            np.cos(6.*zz)
    P2 = lambda zz, D1, D2: \
            signal.square(6.*zz, duty=D1) * \
            signal.square(5.*zz, duty=D2) * \
            np.cos(5.*zz)

    eq1 = 2./period * integrate.quad(P1, 0., period, args=(D1,D2))[0] + K12
    eq2 = 2./period * integrate.quad(P2, 0., period, args=(D1,D2))[0] - K32

    return (eq1, eq2)


h = 0.01
L = 10.
z = np.arange(0., L, h)

N = int(len(z))

D1 = np.empty([N])
D2 = np.empty([N])
for i in range(N):
    D1[i], D2[i] = fsolve(equations, x0=(0.5, 0.5), args=z[i])
    print
    print z[i]
    print ("%0.8f,%0.8f" % (D1[i], D2[i]))
    print

PSS： 我实现了你写的东西（我想我理解！），做得很好。非常感谢。不幸的是，我在这个领域没有太多的技能，也不知道如何做出合适的猜测，所以我只猜0.5（我还在最初的猜测中添加了少量的噪声，以尝试改进它）。我得到的结果似乎有数字错误，我不知道为什么，我希望你能给我指出正确的方向。基本上，我做了一次FFT扫描（对每个dutycycle变化做了一次FFT，并查看了5处的频率分量，如下图所示），发现线性部分（z/L）有点参差不齐

PSS： 谢谢你，我注意到了你建议的一些技巧。我试着复制了你的第二张图，因为它看起来非常有用。为此，我将D1（D2）固定并扫描D2（D1），并对各种z值执行此操作

fmin

并非总能找到正确的最小值（取决于初始猜测），因此我对

fmin

进行了初步猜测，直到找到正确答案。我得到了与你相似的答案。（我认为这是正确的？）

另外，我想说的是，您可能想给我您的联系方式，因为这个解决方案是为我的问题找到解决方案的一个步骤（我是一个做研究的学生），我肯定会在使用此代码的任何论文中感谢您

#!/usr/bin/env python

import numpy as np
from scipy.optimize import fsolve
from scipy import integrate
from scipy import optimize
from scipy import signal


######################################################
######################################################

altsigns = np.ones(50)
altsigns[1::2] = -1

def get_breaks(x, y, a, b):
    sa = np.arange(0, 2*a, 2)
    sb = np.arange(0, 2*b, 2)

    zx  = (( x + sa) % (2*a))*np.pi/a
    zx2 = ((-x + sa) % (2*a))*np.pi/a
    zy  = (( y + sb) % (2*b))*np.pi/b
    zy2 = ((-y + sb) % (2*b))*np.pi/b

    zi = np.r_[np.sort(np.hstack((zx, zx2, zy, zy2))), 2*np.pi]
    if zi[0]:
        zi = np.r_[0, zi]
    return zi

def integrals(x, y, a, b):
    zi = get_breaks(x % 1., y % 1., a, b)
    sins = np.vstack((np.sin(b*zi), np.sin(a*zi)))
    return (altsigns[:zi.size-1]*(sins[:,1:] - sins[:,:-1])).sum(1) / np.array((b, a))

def equation1(p, z, d2):
    D2 = d2

    D1 = p
    I1, _ = integrals(D1, D2, deltaK1, deltaK2)

    eq1 = 1. / np.pi * I1 + z
    return abs(eq1)

def equation2(p, z, d1):
    D1 = d1

    D2 = p
    _, I2 = integrals(D1, D2, deltaK1, deltaK2)

    eq2 = 1. / np.pi * I2 - z + 1
    return abs(eq2)

######################################################
######################################################

z = [0.2, 0.4, 0.6, 0.8, 1.0]#np.arange(0., 1., 0.1)
step = 0.05

deltaK1 = 5.
deltaK2 = 6.

f = open('data.dat', 'w')

D = np.arange(0.0, 1.0, step)
D1eq1 = np.empty([len(D)])
D2eq2 = np.empty([len(D)])
D1eq1Err = np.empty([len(D)])
D2eq2Err = np.empty([len(D)])
for n in z:
    for i in range(len(D)):
        # Fix D2 and solve for D1.
        for guessD1 in np.arange(0.,1.,0.1):
            D2 = D
            tempD1 = optimize.fmin(equation1, guessD1, args=(n, D2[i]), disp=False, xtol=1e-8, ftol=1e-8, full_output=True)
            if tempD1[1] < 1.e-6:
                D1eq1Err[i] = tempD1[1]
                D1eq1[i] = tempD1[0][0]
                break
            else:
                D1eq1Err[i] = -1.
                D1eq1[i] = -1.

        # Fix D1 and solve for D2.
        for guessD2 in np.arange(0.,1.,0.1):
            D1 = D
            tempD2 = optimize.fmin(equation2, guessD2, args=(n, D1[i]), disp=False, xtol=1e-8, ftol=1e-8, full_output=True)
            if tempD2[1] < 1.e-6:
                D2eq2Err[i] = tempD2[1]
                D2eq2[i] = tempD2[0][0]
                break
            else:
                D2eq2Err[i] = -2.
                D2eq2[i] = -2.

    for i in range(len(D)):
        f.write('%0.8f,%0.8f,%0.8f,%0.8f,%0.8f\n' %(D[i], D1eq1[i], D2eq2[i], D1eq1Err[i], D2eq2Err[i]))
    f.write('\n\n')
f.close()

#/usr/bin/env python
将numpy作为np导入
从scipy.optimize导入fsolve
从scipy导入集成
从scipy导入优化
从scipy输入信号
######################################################
######################################################
altsigns=np.ones（50）
altsigns[1:：2]=-1
def get_中断（x、y、a、b）：
sa=np.arange（0,2*a,2）
sb=np.arange（0,2*b,2）
zx=（（x+sa）%（2*a））*np.pi/a
zx2=（-x+sa）%（2*a））*np.pi/a
zy=（（y+sb）%（2*b））*np.pi/b
zy2=（-y+sb）%（2*b））*np.pi/b
zi=np.r_u2;[np.sort（np.hstack（（zx，zx2，zy，zy2））），2*np.pi]
如果zi[0]：
zi=np.r_u0[0，zi]
归子
def积分（x，y，a，b）：
zi=获取中断（x%1,y%1,a,b）
sins=np.vstack（（np.sin（b*zi），np.sin（a*zi）））
返回（altsigns[：zi.size-1]*（sins[：，1:]-sins[：，：-1]）。和（1）/np.数组（（b，a））
def方程1（p、z、d2）：
D2=D2
D1=p
I1，u=积分（D1，D2，deltaK1，deltaK2）
eq1=1./np.pi*I1+z
返回abs（eq1）
def方程2（p、z、d1）：
D1=D1
D2=p
_，I2=积分（D1，D2，deltaK1，deltaK2）
eq2=1./np.pi*I2-z+1
返回abs（eq2）
######################################################
######################################################
z=[0.2,0.4,0.6,0.8,1.0]#np.arange（0,1,0.1）
阶跃=0.05
deltaK1=5。
deltaK2=6。
f=打开（'data.dat'，'w'）
D=np.arange（0.0，1.0，步长）
D1eq1=np.空（[len（D）]）
D2eq2=np.空（[len（D）]）
D1eq1Err=np.空（[len（D）]）
D2eq2Err=np.空（[len（D）]）
对于z中的n：
对于范围内的i（len（D））：
#修复D2并求解D1。
对于np.arange（0,1,0.1）中的猜测1：
D2=D
tempD1=optimize.fmin（等式1，猜测1，参数=（n，D2[i]），disp=False，xtol=1e-8，ftol=1e-8，完整输出=True）
如果tempD1[1]<1.e-6：
D1eq1Err[i]=tempD1[1]
D1eq1[i]=tempD1[0][0]
打破
其他：
D1eq1Err[i]=-1。
D1eq1[i]=-1。
#修复D1并求解D2。
对于np.arange（0,1,0.1）中的猜测2：
D1=D
tempD2=optimize.fmin（等式2，猜测d2，参数=（n，D1[i]），disp=False，xtol=1e-8，ftol=1e-8，完整输出=True）
如果tempD2[1]<1.e-6：
D2eq2Err[i]=tempD2[1]
D2eq2[i]=tempD2[0][0]
打破
其他：
D2eq2Err[i]=-2。
D2eq2[i]=-2。
对于范围内的i（len（D））：
f、 写入（“%0.8f、%0.8f、%0.8f、%0.8f、%0.8f、%0.8f\n%”（D[i]、D1eq1[i]、D2eq2[i]、D1eq1Err[i]、D2eq2Err[i]））
f、 写入（'\n\n'）
f、 关闭（）

这是一个非常不适定的问题。让我们回顾一下您正在尝试做的事情：

• 你想解决100000个优化问题
• 每个优化问题都是二维的，因此您需要O（10000）个函数评估（估计一维优化问题的O（100）个函数评估）
• 每个函数的求值取决于两个数值积分的求值
• 被积函数包含跳跃，即它们是0次连续可微的
• 被积函数是由周期函数组成的，因此它们有多个极小值和极大值

所以你要走到一个非常艰难的时期。此外，即使在被积函数中所有小于1的因子都被1取代的最乐观估计中，积分也只能取

-2*pi

和

2*pi

之间的值。比实际情况要少得多。因此，您已经可以看到，您只有一个解决问题的机会

I1 - z = 0
I2 + z = 0

对于极少量的z。因此，尝试将z=1000设置为

z
没有意义

我几乎可以肯定，这不是你需要解决的问题。（我无法想象在什么情况下会出现这样的问题。这似乎是傅里叶系数计算中的一个奇怪的扭曲…）但如果你坚持，最好的办法是先处理内部循环

正如您所注意到的，积分的数值计算会有很大的误差。这是由于
sg引入的跳跃
altsigns = np.ones(50)
altsigns[1::2] = -1

def get_breaks(x, y, a, b):
    sa = np.arange(0, 2*a, 2)
    sb = np.arange(0, 2*b, 2)

    zx  = (( x + sa) % (2*a))*np.pi/a
    zx2 = ((-x + sa) % (2*a))*np.pi/a
    zy  = (( y + sb) % (2*b))*np.pi/b
    zy2 = ((-y + sb) % (2*b))*np.pi/b

    zi = np.r_[np.sort(np.hstack((zx, zx2, zy, zy2))), 2*pi]
    if zi[0]:
        zi = np.r_[0, zi]
    return zi

def integrals(x, y, a, b):
    zi = get_breaks(x % 1., y % 1., a, b)
    sins = np.vstack((np.sin(b*zi), np.sin(a*zi)))
    return (altsigns[:zi.size-1]*(sins[:,1:] - sins[:,:-1])).sum(1) / np.array((b, a))

def equations2(p, z):
    x, y = p
    I1, I2 = integrals(x, y, 6., 5.)

    fact = 1. / pi
    eq1 = fact * I1 + z
    eq2 = fact * I2 - z
    return eq1, eq2

def norm2(p, z):
    eq1, eq2 = equations2(p, z)
    return eq1**2 + eq2**2  # this has the minimum when eq1 == eq2 == 0

z = 0.25

res = fmin(norm2, (0.25, 0.25), args=(z,), xtol=1e-8, ftol=1e-8)
print res
# -> [ 0.3972  0.5988]

print equations2(res, z)
# -> (-2.7285737558280232e-09, -2.4748670890417657e-09)

import numpy as np
from numpy import sin, cos, sign, pi, arange, sort, concatenate
from scipy.optimize import fmin

a = 6.0
b = 5.0

def P(z, x, y):
    return sign((cos(a*z) - cos(pi*x)) * (cos(b*z) - cos(pi*y)))

def P1(z, x, y):
    return P(z, x, y) * cos(b*z)

def P2(z, x, y):
    return P(z, x, y) * cos(a*z)

altsigns = np.ones(50)
altsigns[1::2] = -1

twopi = 2*pi
pi_a = pi/a
da = 2*pi_a
pi_b = pi/b
db = 2*pi_b
lim = np.array([0., twopi])

def get_breaks(x, y):
    zx  = arange(x*pi_a, twopi, da)
    zx2 = arange((2-x)*pi_a, twopi, da)
    zy  = arange(y*pi_b, twopi, db)
    zy2 = arange((2-y)*pi_b, twopi, db)
    zi = sort(concatenate((lim, zx, zx2, zy, zy2)))
    return zi

ba = np.array((b, a))[:,None]
fact = np.array((1. / b, 1. / a))

def integrals(x, y):
    zi = get_breaks(x % 1., y % 1.)
    sins = sin(ba*zi)
    return fact * (altsigns[:zi.size-1]*(sins[:,1:] - sins[:,:-1])).sum(1)

def equations2(p, z):
    x, y = p
    I1, I2 = integrals(x, y)

    fact = 1. / pi
    eq1 = fact * I1 + z
    eq2 = fact * I2 - z
    return eq1, eq2

def norm2(p, z):
    eq1, eq2 = equations2(p, z)
    return eq1**2 + eq2**2

def eval_integrals(Nx=100, Ny=101):
    x = np.arange(Nx) / float(Nx)
    y = np.arange(Ny) / float(Ny)
    I = np.zeros((Nx, Ny, 2))
    for i in xrange(Nx):
        xi = x[i]
        Ii = I[i]
        for j in xrange(Ny):
            Ii[j] = integrals(xi, y[j])
    return x, y, I

def solve(z, start=(0.25, 0.25)):
    N = len(z)
    res = np.zeros((N, 2))
    res.fill(np.nan)

    for i in xrange(N):
        if i < 100:
            prev = start
        prev = fmin(norm2, prev, args=(z[i],), xtol=1e-8, ftol=1e-8)
        if norm2(prev, z[i]) < 1e-7:
            res[i] = prev
        else:
            break
    return res


#x, y, I = eval_integrals(Nx=1000, Ny=1001)

#zlvl = np.arange(0.2, 1.2, 0.2)
#contour(x, y, -I[:,:,0].T/pi, zlvl)
#contour(x, y,  I[:,:,1].T/pi, zlvl)

N = 1000
z = np.linspace(0., 1., N)
res = np.zeros((N, 2, 2))

res[:,0,:] = solve(z, (0.25, 0.25))
res[:,1,:] = solve(z, (0.05, 0.95))