def sweep(self, wireFrameProjection, frame, lines,
color=[0, 0, 255], sweepThick=5, fullsweepFrame=104):
# calculate sweep angle
halfcycle = fullsweepFrame / 2
position = (frame % fullsweepFrame)
if position > halfcycle:
position = fullsweepFrame - position
sweep = position / halfcycle
allY = [n * 32 for n in range(int(self.projectedY / 32))]
# calculate the wireframe positions
nlanes = len(lines) - 1
leftPolynomial = np.poly1d(lines[0].currentFit)
rightPolynomial = np.poly1d(lines[nlanes].currentFit)
# scanning sweep
polySweepDiff = np.polysub(
lines[nlanes].currentFit,
lines[0].currentFit) * sweep
sweepPoly = np.polyadd(leftPolynomial, polySweepDiff)
allX = sweepPoly(allY)
XYPolyline = np.column_stack((allX, allY)).astype(np.int32)
cv2.polylines(wireFrameProjection, [XYPolyline], 0, color, sweepThick)
sweepLane = 0
for i in range(nlanes):
leftLine = np.poly1d(lines[i].currentFit)
rightLine = np.poly1d(lines[i+1].currentFit)
if (leftLine([self.projectedY])[0] <
sweepPoly([self.projectedY])[0] and
sweepPoly([self.projectedY])[0] <
rightLine([self.projectedY])[0]):
sweepLane = i
return sweepLane
def residue(b,a,tol=1e-3,rtype='avg'):
"""Compute partial-fraction expansion of b(s) / a(s).
If M = len(b) and N = len(a)
b(s) b[0] s**(M-1) + b[1] s**(M-2) + ... + b[M-1]
H(s) = ------ = ----------------------------------------------
a(s) a[0] s**(N-1) + a[1] s**(N-2) + ... + a[N-1]
r[0] r[1] r[-1]
= -------- + -------- + ... + --------- + k(s)
(s-p[0]) (s-p[1]) (s-p[-1])
If there are any repeated roots (closer than tol), then the partial
fraction expansion has terms like
r[i] r[i+1] r[i+n-1]
-------- + ----------- + ... + -----------
(s-p[i]) (s-p[i])**2 (s-p[i])**n
See also: invres, poly, polyval, unique_roots
"""
b,a = map(asarray,(b,a))
k,b = polydiv(b,a)
p = roots(a)
r = p*0.0
pout, mult = unique_roots(p,tol=tol,rtype=rtype)
p = []
for n in range(len(pout)):
p.extend([pout[n]]*mult[n])
p = asarray(p)
# Compute the residue from the general formula
indx = 0
for n in range(len(pout)):
bn = b.copy()
pn = []
for l in range(len(pout)):
if l != n:
pn.extend([pout[l]]*mult[l])
an = atleast_1d(poly(pn))
# bn(s) / an(s) is (s-po[n])**Nn * b(s) / a(s) where Nn is
# multiplicity of pole at po[n]
sig = mult[n]
for m in range(sig,0,-1):
if sig > m:
# compute next derivative of bn(s) / an(s)
term1 = polymul(polyder(bn,1),an)
term2 = polymul(bn,polyder(an,1))
bn = polysub(term1,term2)
an = polymul(an,an)
r[indx+m-1] = polyval(bn,pout[n]) / polyval(an,pout[n]) \
/ factorial(sig-m)
indx += sig
return r, p, k
def createPolyFitRight(self, curImgFtr, leftLane,
faint=1.0, resized=False):
# create new right line polynomial
polyDiff = np.polysub(leftLane.lines[leftLane.right].currentFit,
leftLane.lines[leftLane.left].currentFit)
self.currentFit = np.polyadd(
leftLane.lines[leftLane.right].currentFit, polyDiff)
polynomial = np.poly1d(self.currentFit)
self.allY = leftLane.lines[leftLane.right].allY
self.currentX = polynomial(self.allY)
self.allX = self.currentX
if len(self.allY) > 75:
# We need to increase our pixel count by 2 to get to 100%
# confidence and maintain the current pixel count to keep
# the line detection
self.confidence_based = len(self.allY) * 2
self.confidence = len(self.allY) / self.confidence_based
self.detected = True
# create linepoly
xy1 = np.column_stack(
(self.currentX + self.maskDelta, self.allY))
xy1 = xy1.astype(np.int32)
xy2 = np.column_stack(
(self.currentX - self.maskDelta, self.allY))
xy2 = xy2.astype(np.int32)
self.linePoly = np.concatenate((xy1, xy2[::-1]), axis=0)
# create mask
self.linemask = np.zeros_like(self.linemask)
cv2.fillConvexPoly(self.linemask, self.linePoly, 64)
# Add the point at the bottom.
allY = np.append(self.allY, self.projectedY - 1)
allX = polynomial(allY)
self.XYPolyline = np.column_stack((allX, allY))
self.XYPolyline = self.XYPolyline.astype(np.int32)
# create the accumulator
self.bestFit = self.currentFit
# classify the line
# print("classifying the right line",self.side)
self.getLineStats(
curImgFtr.getRoadProjection(), faint=faint, resized=resized)
# set bottom of line
x = polynomial([self.projectedY - 1])
self.pixelBasePos = x[0]
def __sub__(self, other):
"""An operator overload for subtracting two terms with ``-``."""
if isinstance(other, Polynomial) and self.transform == other.transform:
return Polynomial(coefficients=numpy.polysub(self.coefficients, other.coefficients),
transform=self.transform)
elif isinstance(other, Constant):
if len(self.coefficients): # pylint: disable=len-as-condition; coefficients might be a NumPy array, where __nonzero__ is not equivalent to len(.)
coefficients = list(self.coefficients)
coefficients[-1] -= other.value
return Polynomial(coefficients=coefficients, transform=self.transform)
else:
return -other
else:
return super().__sub__(other)
def updatePolyFitRight(self, leftLane):
# update new right line polynomial
polyDiff = np.polysub(leftLane.lines[leftLane.right].currentFit,
leftLane.lines[leftLane.left].currentFit)
self.currentFit = np.polyadd(
leftLane.lines[leftLane.right].currentFit, polyDiff)
polynomial = np.poly1d(self.currentFit)
self.allY = leftLane.lines[leftLane.right].allY
self.currentX = polynomial(self.allY)
self.allX = self.currentX
if len(self.allY) > 150:
# We need to increase our pixel count by 2 to get to 100%
# confidence and maintain the current pixel count to keep
# the line detection
self.confidence = len(self.allY) / self.confidence_based
if self.confidence > 0.5:
self.detected = True
if self.confidence > 1.0:
self.confidence = 1.0
else:
self.detected = False
# create linepoly
xy1 = np.column_stack(
(self.currentX + self.maskDelta, self.allY)).astype(np.int32)
xy2 = np.column_stack(
(self.currentX - self.maskDelta, self.allY)).astype(np.int32)
self.linePoly = np.concatenate((xy1, xy2[::-1]), axis=0)
# create mask
self.linemask = np.zeros_like(self.linemask)
cv2.fillConvexPoly(self.linemask, self.linePoly, 64)
# Add the point at the bottom.
allY = np.append(self.allY, self.projectedY - 1)
allX = polynomial(allY)
self.XYPolyline = np.column_stack((allX, allY)).astype(np.int32)
# create the accumulator
self.bestFit = self.currentFit
def wireframe(self, wireFrameProjection, frame, mainLane,
color=[255, 255, 255], wireThick=1,
sweepThick=5, fullsweepFrame=26):
# calculate the wireframe positions
nlanes = len(mainLane.lines) - 1
leftPolynomial = np.poly1d(mainLane.lines[0].currentFit)
roadleftPolynomial = np.poly1d(
mainLane.lines[mainLane.left].currentFit)
roadrightPolynomial = np.poly1d(
mainLane.lines[mainLane.right].currentFit)
rightPolynomial = np.poly1d(mainLane.lines[nlanes].currentFit)
delta = (frame * 32) % 128
squares = []
# horizontal lines
for i in range(int(self.projectedY / 128)):
y1 = 128 * i + delta
x1 = leftPolynomial([y1])
x2 = roadleftPolynomial([y1])
x3 = roadrightPolynomial([y1])
x4 = rightPolynomial([y1])
cv2.line(wireFrameProjection, (x1, y1),
(x4, y1), color, wireThick * 3)
squares.append(((x2, y1), (x3, y1)))
# vertical lines
allY = [n * 32 for n in range(int(self.projectedY / 32))]
polyDiff = np.polysub(mainLane.lines[nlanes].currentFit,
mainLane.lines[0].currentFit) / (nlanes * 2)
curPoly = leftPolynomial
for i in range(nlanes * 2):
allX = curPoly(allY)
XYPolyline = np.column_stack((allX, allY)).astype(np.int32)
cv2.polylines(wireFrameProjection, [
XYPolyline], 0, color, int(wireThick / 4))
curPoly = np.polyadd(curPoly, polyDiff)
return squares
def stability_margins(sysdata, returnall=False, epsw=0.0):
"""Calculate stability margins and associated crossover frequencies.
Parameters
----------
sysdata: LTI system or (mag, phase, omega) sequence
sys : LTI system
Linear SISO system
mag, phase, omega : sequence of array_like
Arrays of magnitudes (absolute values, not dB), phases (degrees),
and corresponding frequencies. Crossover frequencies returned are
in the same units as those in `omega` (e.g., rad/sec or Hz).
returnall: bool, optional
If true, return all margins found. If False (default), return only the
minimum stability margins. For frequency data or FRD systems, only
margins in the given frequency region can be found and returned.
epsw: float, optional
Frequencies below this value (default 0.0) are considered static gain,
and not returned as margin.
Returns
-------
gm: float or array_like
Gain margin
pm: float or array_loke
Phase margin
sm: float or array_like
Stability margin, the minimum distance from the Nyquist plot to -1
wg: float or array_like
Frequency for gain margin (at phase crossover, phase = -180 degrees)
wp: float or array_like
Frequency for phase margin (at gain crossover, gain = 1)
ws: float or array_like
Frequency for stability margin (complex gain closest to -1)
"""
try:
if isinstance(sysdata, frdata.FRD):
sys = frdata.FRD(sysdata, smooth=True)
elif isinstance(sysdata, xferfcn.TransferFunction):
sys = sysdata
elif getattr(sysdata, '__iter__', False) and len(sysdata) == 3:
mag, phase, omega = sysdata
sys = frdata.FRD(mag * np.exp(1j * phase * math.pi / 180),
omega,
smooth=True)
else:
sys = xferfcn._convertToTransferFunction(sysdata)
except Exception as e:
print(e)
raise ValueError("Margin sysdata must be either a linear system or "
"a 3-sequence of mag, phase, omega.")
# calculate gain of system
if isinstance(sys, xferfcn.TransferFunction):
# check for siso
if not issiso(sys):
raise ValueError("Can only do margins for SISO system")
# real and imaginary part polynomials in omega:
rnum, inum = _polyimsplit(sys.num[0][0])
rden, iden = _polyimsplit(sys.den[0][0])
# test (imaginary part of tf) == 0, for phase crossover/gain margins
test_w_180 = np.polyadd(np.polymul(inum, rden),
np.polymul(rnum, -iden))
w_180 = np.roots(test_w_180)
# first remove imaginary and negative frequencies, epsw removes the
# "0" frequency for type-2 systems
w_180 = np.real(w_180[(np.imag(w_180) == 0) * (w_180 >= epsw)])
# evaluate response at remaining frequencies, to test for phase 180 vs 0
with np.errstate(all='ignore'):
resp_w_180 = np.real(
np.polyval(sys.num[0][0], 1.j * w_180) /
np.polyval(sys.den[0][0], 1.j * w_180))
# only keep frequencies where the negative real axis is crossed
w_180 = w_180[np.real(resp_w_180) <= 0.0]
# and sort
w_180.sort()
# test magnitude is 1 for gain crossover/phase margins
test_wc = np.polysub(np.polyadd(_polysqr(rnum), _polysqr(inum)),
np.polyadd(_polysqr(rden), _polysqr(iden)))
wc = np.roots(test_wc)
wc = np.real(wc[(np.imag(wc) == 0) * (wc > epsw)])
wc.sort()
# stability margin was a bitch to elaborate, relies on magnitude to
# point -1, then take the derivative. Second derivative needs to be >0
# to have a minimum
test_wstabd = np.polyadd(_polysqr(rden), _polysqr(iden))
test_wstabn = np.polyadd(_polysqr(np.polyadd(rnum, rden)),
_polysqr(np.polyadd(inum, iden)))
test_wstab = np.polysub(
np.polymul(np.polyder(test_wstabn), test_wstabd),
np.polymul(np.polyder(test_wstabd), test_wstabn))
# find the solutions, for positive omega, and only real ones
wstab = np.roots(test_wstab)
wstab = np.real(wstab[(np.imag(wstab) == 0) * (np.real(wstab) >= 0)])
# and find the value of the 2nd derivative there, needs to be positive
wstabplus = np.polyval(np.polyder(test_wstab), wstab)
wstab = np.real(wstab[(np.imag(wstab) == 0) * (wstab > epsw) *
(wstabplus > 0.)])
wstab.sort()
else:
# a bit coarse, have the interpolated frd evaluated again
def mod(w):
"""to give the function to calculate |G(jw)| = 1"""
return np.abs(sys._evalfr(w)[0][0]) - 1
def arg(w):
"""function to calculate the phase angle at -180 deg"""
return np.angle(-sys._evalfr(w)[0][0])
def dstab(w):
"""function to calculate the distance from -1 point"""
return np.abs(sys._evalfr(w)[0][0] + 1.)
# Find all crossings, note that this depends on omega having
# a correct range
widx = np.where(np.diff(np.sign(mod(sys.omega))))[0]
wc = np.array([
sp.optimize.brentq(mod, sys.omega[i], sys.omega[i + 1])
for i in widx if i + 1 < len(sys.omega)
])
# find the phase crossings ang(H(jw) == -180
widx = np.where(np.diff(np.sign(arg(sys.omega))))[0]
widx = widx[np.real(sys._evalfr(sys.omega[widx])[0][0]) <= 0]
w_180 = np.array([
sp.optimize.brentq(arg, sys.omega[i], sys.omega[i + 1])
for i in widx if i + 1 < len(sys.omega)
])
# find all stab margins?
widx = np.where(np.diff(np.sign(np.diff(dstab(sys.omega)))))[0]
wstab = np.array([
sp.optimize.minimize_scalar(dstab,
bracket=(sys.omega[i],
sys.omega[i + 1])).x
for i in widx if i + 1 < len(sys.omega)
and np.diff(np.diff(dstab(sys.omega[i - 1:i + 2])))[0] > 0
])
wstab = wstab[(wstab >= sys.omega[0]) * (wstab <= sys.omega[-1])]
# margins, as iterables, converted frdata and xferfcn calculations to
# vector for this
with np.errstate(all='ignore'):
gain_w_180 = np.abs(sys._evalfr(w_180)[0][0])
GM = 1.0 / gain_w_180
SM = np.abs(sys._evalfr(wstab)[0][0] + 1)
PM = np.remainder(np.angle(sys._evalfr(wc)[0][0], deg=True), 360.0) - 180.0
if returnall:
return GM, PM, SM, w_180, wc, wstab
else:
if GM.shape[0] and not np.isinf(GM).all():
with np.errstate(all='ignore'):
gmidx = np.where(
np.abs(np.log(GM)) == np.min(np.abs(np.log(GM))))
else:
gmidx = -1
if PM.shape[0]:
pmidx = np.where(np.abs(PM) == np.amin(np.abs(PM)))[0]
return ((not gmidx != -1 and float('inf'))
or GM[gmidx][0], (not PM.shape[0] and float('inf'))
or PM[pmidx][0], (not SM.shape[0] and float('inf'))
or np.amin(SM), (not gmidx != -1 and float('nan'))
or w_180[gmidx][0], (not wc.shape[0] and float('nan'))
or wc[pmidx][0], (not wstab.shape[0] and float('nan'))
or wstab[SM == np.amin(SM)][0])
weights = np.hanning(N)
print("Weights", weights)
bhp = np.loadtxt('BHP.csv', delimiter=',', usecols=(6, ), unpack=True)
bhp_returns = np.diff(bhp) / bhp[:-1]
smooth_bhp = np.convolve(weights / weights.sum(), bhp_returns)[N - 1:-N + 1]
vale = np.loadtxt('VALE.csv', delimiter=',', usecols=(6, ), unpack=True)
vale_returns = np.diff(vale) / vale[:-1]
smooth_vale = np.convolve(weights / weights.sum(), vale_returns)[N - 1:-N + 1]
K = 8
t = np.arange(N - 1, len(bhp_returns))
poly_bhp = np.polyfit(t, smooth_bhp, K)
poly_vale = np.polyfit(t, smooth_vale, K)
poly_sub = np.polysub(poly_bhp, poly_vale)
xpoints = np.roots(poly_sub)
print("Intersection points", xpoints)
reals = np.isreal(xpoints)
print("Real number?", reals)
xpoints = np.select([reals], [xpoints])
xpoints = xpoints.real
print("Real intersection points", xpoints)
print("Sans 0s", np.trim_zeros(xpoints))
plt.plot(t, bhp_returns[N - 1:], lw=1.0, label='BHP returns')
plt.plot(t, smooth_bhp, lw=2.0, label='BHP smoothed')
plt.plot(t, vale_returns[N - 1:], '--', lw=1.0, label='VALE returns')
def residue(b, a, tol=1e-3, rtype='avg'):
"""
Compute partial-fraction expansion of b(s) / a(s).
If ``M = len(b)`` and ``N = len(a)``, then the partial-fraction
expansion H(s) is defined as::
b(s) b[0] s**(M-1) + b[1] s**(M-2) + ... + b[M-1]
H(s) = ------ = ----------------------------------------------
a(s) a[0] s**(N-1) + a[1] s**(N-2) + ... + a[N-1]
r[0] r[1] r[-1]
= -------- + -------- + ... + --------- + k(s)
(s-p[0]) (s-p[1]) (s-p[-1])
If there are any repeated roots (closer together than `tol`), then H(s)
has terms like::
r[i] r[i+1] r[i+n-1]
-------- + ----------- + ... + -----------
(s-p[i]) (s-p[i])**2 (s-p[i])**n
Returns
-------
r : ndarray
Residues.
p : ndarray
Poles.
k : ndarray
Coefficients of the direct polynomial term.
See Also
--------
invres, numpy.poly, unique_roots
"""
b, a = map(asarray, (b, a))
rscale = a[0]
k, b = polydiv(b, a)
p = roots(a)
r = p * 0.0
pout, mult = unique_roots(p, tol=tol, rtype=rtype)
p = []
for n in range(len(pout)):
p.extend([pout[n]] * mult[n])
p = asarray(p)
# Compute the residue from the general formula
indx = 0
for n in range(len(pout)):
bn = b.copy()
pn = []
for l in range(len(pout)):
if l != n:
pn.extend([pout[l]] * mult[l])
an = atleast_1d(poly(pn))
# bn(s) / an(s) is (s-po[n])**Nn * b(s) / a(s) where Nn is
# multiplicity of pole at po[n]
sig = mult[n]
for m in range(sig, 0, -1):
if sig > m:
# compute next derivative of bn(s) / an(s)
term1 = polymul(polyder(bn, 1), an)
term2 = polymul(bn, polyder(an, 1))
bn = polysub(term1, term2)
an = polymul(an, an)
r[indx + m - 1] = polyval(bn, pout[n]) / polyval(an, pout[n]) \
/ factorial(sig - m)
indx += sig
return r / rscale, p, k
mp.plot(dates[1:],vale_returns,color='red',label='vale returns',alpha=0.2)
#卷积降噪
kernel=np.hanning(8)
kernel/=kernel.sum()
bhp_convoloed=np.convolve(bhp_returns,kernel,'valid')
vale_convoloed=np.convolve(vale_returns,kernel,'valid')
mp.plot(dates[8:],bhp_convoloed,color='orange',label='bhp_convoloed',alpha=0.1)
mp.plot(dates[8:],vale_convoloed,color='m',label='vale_convoloed',alpha=0.1)
#多项式拟合，获取两项多项式系数
days=dates[8:].astype('M8[D]').astype('i4')
bhp_P=np.polyfit(days,bhp_convoloed,3)
bhp_val=np.polyval(bhp_P,days) #把days带入polyval
vale_P=np.polyfit(days,vale_convoloed,3)
vale_val=np.polyval(vale_P,days)
mp.plot(dates[8:],bhp_convoloed,color='gold',label='bhp_convoloed')
mp.plot(dates[8:],vale_convoloed,color='green',label='vale_convoloed')
#求两个多项式的焦点
diff_P=np.polysub(bhp_P,vale_P)
#求根
xs=np.roots(diff_P)
print(xs.astype('M8[D]'))
#添加图例
mp.legend()
mp.gcf().autofmt_xdate()
mp.show()
#Form X1o for n=even
Ee=np.copy(E)
Eo=np.copy(E)
Fe=np.copy(F)
Fo=np.copy(F)
for i in range(len(Ee)):
if i%2==0:
Eo[i]=0
Fo[i]=0
else:
Ee[i]=0
Fe[i]=0
Eo=Eo[1:]
Fo=Fo[1:]
X1On=np.polysub(Ee,Fe)
X1On = X1On[2:]
X1Od=np.polyadd(Eo,Fo)
#X1On=np.polysub(Ee,Fe)
#X1Od=np.polysub(Eo,Fo)
#sort and organize transmission zeros for finite poles for synthesis
#According SU p296, finite pole frequencies closest to the bandedge should
#be placed in the middle of the filter to avoid negative components.
bz = np.array([])
for u in range(2,m+1):
bz = np.append(bz, np.array([bS[2*u-1]]))
#bz = np.append(bz,np.inf)
tz=1/(np.sort(bz))
def compute(a1,a2,a3): multiAns = np.polymul(a1,a3) ans = np.polysub(a2,multiAns) ans = np.poly1d(ans) modPolynomial(ans) return ans
print "Weights", weights
bhp = numpy.loadtxt('BHP.csv', delimiter=',', usecols=(6,), unpack=True)
bhp_returns = numpy.diff(bhp) / bhp[ : -1]
smooth_bhp = numpy.convolve(weights/weights.sum(), bhp_returns)[N-1:-N+1]
vale = numpy.loadtxt('VALE.csv', delimiter=',', usecols=(6,), unpack=True)
vale_returns = numpy.diff(vale) / vale[ : -1]
smooth_vale = numpy.convolve(weights/weights.sum(), vale_returns)[N-1:-N+1]
K = int(sys.argv[1])
t = numpy.arange(N - 1, len(bhp_returns))
poly_bhp = numpy.polyfit(t, smooth_bhp, K)
poly_vale = numpy.polyfit(t, smooth_vale, K)
poly_sub = numpy.polysub(poly_bhp, poly_vale)
xpoints = numpy.roots(poly_sub)
print "Intersection points", xpoints
reals = numpy.isreal(xpoints)
print "Real number?", reals
xpoints = numpy.select([reals], [xpoints])
xpoints = xpoints.real
print "Real intersection points", xpoints
print "Sans 0s", numpy.trim_zeros(xpoints)
plot(t, bhp_returns[N-1:], lw=1.0)
plot(t, smooth_bhp, lw=2.0)
bhp = np.loadtxt('BHP.csv', delimiter=',', usecols=(6, ), unpack=True)
bhp_returns = np.diff(bhp) / bhp[:-1] #np.diff()计算数组差值
smooth_bhp = np.convolve(
weights / weights.sum(),
bhp_returns)[N - 1:-N + 1] #np.convolve()[n-1:-N+1]计算数组卷积长度为[N-1:]
vale = np.loadtxt('VALE.csv', delimiter=',', usecols=(6, ), unpack=True)
vale_returns = np.diff(vale) / vale[:-1]
smooth_vale = np.convolve(weights / weights.sum(), vale_returns)[N - 1:-N + 1]
K = int(sys.argv[1]) #拟合几次多项式
t = np.arange(N - 1, len(bhp_returns))
poly_bhp = np.polyfit(t, smooth_bhp, K) #np.plotfit()返回拟合多项式的系数
poly_vale = np.polyfit(t, smooth_vale, K)
poly_sub = np.polysub(poly_bhp, poly_vale) #np.plotsub()计算两个多项式的差构成的多项式
poly_sub_val = np.polyval(poly_sub, t)
poly_der = np.polyder(poly_bhp)
poly_der_val = np.polyval(poly_der, t)
xpoints = np.roots(poly_sub) #np.roots()计算多项式的根
print "Intersection points", xpoints
reals = np.isreal(xpoints) #np.isreal()判断多项式的根是否为实数,并返回布尔值
print "Real number?", reals
xpoints = np.select(
[reals], [xpoints]) #np.select([reals],[xpoints])将xpoints数组中实数值返回,虚数值返回0
xpoints = xpoints.real #返回数组中标签为实数的值
print "Real intersection points", xpoints
print "Sans 0s", np.trim_zeros(xpoints) #np.trim_zeros()去除一维数组中开头和末尾的0元素
smooth_tencent = np.convolve(weights, tencent_returns)[N-1:-N+1]
t=np.arange(N-1, len(bidu_returns))
plt.clf()
plt.plot(t, bidu_returns[N-1:], lw=1.0, label='bidu_returns')
plt.plot(t, smooth_bidu, lw=2.0, label='bidu_smooth')
plt.plot(t, tencent_returns[N-1:], lw=1.0, label='tencent_returns')
plt.plot(t, smooth_tencent, lw=2.0, label='tencent_smooth')
plt.legend(loc='upper left')
plt.savefig('images/hanning_smooth.png', format='png')
K=3
t=np.arange(N-1, len(tencent_returns))
poly_bidu = np.polyfit(t, smooth_bidu, K)
poly_tencent = np.polyfit(t, smooth_tencent, K)
poly_sub = np.polysub(poly_bidu, poly_tencent)
xpoints = np.roots(poly_sub)
print "Intersection points:", xpoints
reals = np.isreal(xpoints)
print "Real number?", reals
xpoints = np.select([reals], [xpoints])
xpoints = xpoints.real
print "Real intersection points", xpoints
print "Sans 0s", np.trim_zeros(xpoints)
E = np.polymul(E, [1, -1 * rt])
E = np.real(E)
#Form X1o for n=odd
Ee = np.copy(E)
Eo = np.copy(E)
Fe = np.copy(F)
Fo = np.copy(F)
for i in range(len(Ee)):
if i % 2 == 0:
Ee[i] = 0
Fe[i] = 0
else:
Eo[i] = 0
Fo[i] = 0
X1On = np.polysub(Ee, Fe)
X1Od = np.polyadd(Eo, Fo)
#sort and organize transmission zeros for finite poles for synthesis
#According SU p296, finite pole frequencies closest to the bandedge should
#be placed in the middle of the filter to avoid negative components.
tz = 1 / (np.sort(a[2:n:2]))
tzo = tz[::2]
tzo = np.append(tzo, np.sort(tz[1::2]))
#pad zeroes into tzo so the indices match SU
tzop = np.array([0])
for z in tzo:
tzop = np.append(tzop, [0, z])
#test for removal
bhp = np.convolve(bhp_returns, kernel, 'valid')
vale = np.convolve(vale_returns, kernel, 'valid')
#针对vale与bhp分别做多项式
days = dates[7:].astype('M8[D]').astype('int32')
P_vale = np.polyfit(days, vale, 3)
P_bhp = np.polyfit(days, bhp, 3)
y_vale = np.polyval(P_vale, days)
y_bhp = np.polyval(P_bhp, days)
mp.plot(dates[7:], y_vale, c="orangered", label="vale_convolved")
mp.plot(dates[7:], y_bhp, c="dodgerblue", label="bhp_convolved")
#求多个多项式的交点位置
P = np.polysub(P_vale, P_bhp)
xs = np.roots(P)
dates = np.floor(xs).astype('M8[D]')
print(dates)
mp.legend()
mp.gcf().autofmt_xdate()
mp.show()
mp.legend()
mp.gcf().autofmt_xdate()
mp.show()
def Extract(n, p, tzop, E, F, wc_p, cauer_type='a'):
cap_array = np.array([])
ind_array = np.array([])
omega_array = np.array([])
_, _, _, _, X1On, X1Od = X1O(E, F)
B_num = np.copy(X1Od)
B_den = np.copy(X1On)
#element extraction SU p306
index = 2
while index < n:
#shunt removal
BdivL_num = B_num[:
-1] #equivalent to B divided by lambda when constant term of B is 0
BdivL_num_eval = np.polyval(BdivL_num, 1j * tzop[index])
BdivL_den_eval = np.polyval(B_den, 1j * tzop[index])
c_shnt = BdivL_num_eval / BdivL_den_eval
#update component and frequency arrays
cap_array = np.append(cap_array, np.real(c_shnt))
ind_array = np.append(ind_array, [0])
omega_array = np.append(omega_array, [0])
#update polynomila B
Lc = np.array([np.real(c_shnt), 0]) #lambda*c(extracted)
B_num = np.polysub(B_num, np.polymul(Lc, B_den))
#series removal
temp_n = np.polymul(np.array([1, 0]), B_num)
temp_n = np.polydiv(temp_n, np.array([1, 0, tzop[index]**2]))[0]
temp_ne = np.polyval(temp_n, 1j * tzop[index])
temp_de = np.polyval(B_den, 1j * tzop[index])
c_srs = temp_ne / temp_de
#update component and frequency arrays
cap_array = np.append(cap_array, np.real(c_srs))
w = tzop[index]
omega_array = np.append(omega_array, [w])
l_srs = 1 / (w)**2 / (np.real(c_srs))
ind_array = np.append(ind_array, [l_srs])
#update polynomial B
temp1 = np.polymul(B_den, np.array([1, 0, tzop[index]**2]))
temp2 = np.polymul(B_num, np.array([1 / np.real(c_srs), 0]))
B_den = np.polysub(temp1, temp2)
B_num = np.polymul(B_num, np.array([1, 0, tzop[index]**2]))
index += 2
#shunt removal
BdivL_num = B_num[:-1] #B divided by lambda when constant term of B is 0
BdivL_num_eval = BdivL_num[0]
BdivL_den_eval = B_den[0]
c_shnt = BdivL_num_eval / BdivL_den_eval
#update component and frequency arrays
cap_array = np.append(cap_array, np.real(c_shnt))
ind_array = np.append(ind_array, [0])
omega_array = np.append(omega_array, [0])
#Lc = np.array([np.real(c_shnt), 0]) #lambda*c(extracted)
#B_num = np.polysub(B_num, np.polymul(Lc, B_den))
zout = 1
#For even order filters, extract series L by using X2O
if n % 2 == 0:
if cauer_type == 'b':
zout = (1 - p) / (1 + p)
#see table 4.4 page 129 in Zverev for X2O
_, _, _, _, X2On, X2Od = X2O(E, F)
l_srs = (X2On[0]) / (X2Od[0])
cap_array = np.append(cap_array, 0)
ind_array = np.append(ind_array, l_srs * zout)
omega_array = np.append(omega_array, [0])
#Denormalize component values and frequencies
cap_array = cap_array * wc_p
ind_array = ind_array * wc_p
omega_array = omega_array / wc_p
#Pad zeros so indices match those of SU
cap_array = np.insert(cap_array, 0, 0)
cap_array = np.append(cap_array, 0)
ind_array = np.insert(ind_array, 0, 0)
ind_array = np.append(ind_array, 0)
omega_array = np.insert(omega_array, 0, 0)
omega_array = np.append(omega_array, 0)
terms = np.array([1])
terms = np.append(terms, np.zeros(n))
terms = np.append(terms, zout)
return cap_array, ind_array, omega_array, terms
print "Weights", weights
bhp = np.loadtxt('BHP.csv', delimiter=',', usecols=(6,), unpack=True)
bhp_returns = np.diff(bhp) / bhp[ : -1]
smooth_bhp = np.convolve(weights/weights.sum(), bhp_returns)[N-1:-N+1]
vale = np.loadtxt('VALE.csv', delimiter=',', usecols=(6,), unpack=True)
vale_returns = np.diff(vale) / vale[ : -1]
smooth_vale = np.convolve(weights/weights.sum(), vale_returns)[N-1:-N+1]
K = int(sys.argv[1])
t = np.arange(N - 1, len(bhp_returns))
poly_bhp = np.polyfit(t, smooth_bhp, K)
poly_vale = np.polyfit(t, smooth_vale, K)
poly_sub = np.polysub(poly_bhp, poly_vale)
xpoints = np.roots(poly_sub)
print "Intersection points", xpoints
reals = np.isreal(xpoints)
print "Real number?", reals
xpoints = np.select([reals], [xpoints])
xpoints = xpoints.real
print "Real intersection points", xpoints
print "Sans 0s", np.trim_zeros(xpoints)
plot(t, bhp_returns[N-1:], lw=1.0)
plot(t, smooth_bhp, lw=2.0)
def __sub__(self, other):
return self.__class__(np.polysub(self.coeff, other.coeff))
bhp = numpy.loadtxt('BHP.csv', delimiter=',', usecols=(6, ), unpack=True)
bhp_returns = numpy.diff(bhp) / bhp[:-1]
smooth_bhp = numpy.convolve(weights / weights.sum(), bhp_returns)[N - 1:-N + 1]
vale = numpy.loadtxt('VALE.csv', delimiter=',', usecols=(6, ), unpack=True)
vale_returns = numpy.diff(vale) / vale[:-1]
smooth_vale = numpy.convolve(weights / weights.sum(),
vale_returns)[N - 1:-N + 1]
K = int(sys.argv[1])
t = numpy.arange(N - 1, len(bhp_returns))
poly_bhp = numpy.polyfit(t, smooth_bhp, K)
poly_vale = numpy.polyfit(t, smooth_vale, K)
poly_sub = numpy.polysub(poly_bhp, poly_vale)
xpoints = numpy.roots(poly_sub)
print "Intersection points", xpoints
reals = numpy.isreal(xpoints)
print "Real number?", reals
xpoints = numpy.select([reals], [xpoints])
xpoints = xpoints.real
print "Real intersection points", xpoints
print "Sans 0s", numpy.trim_zeros(xpoints)
plot(t, bhp_returns[N - 1:], lw=1.0)
plot(t, smooth_bhp, lw=2.0)
def FilterSub(f1, f2):
den = polymul(f1.get_den(), f2.get_den())
n1 = polymul(f1.get_num(), f2.get_den())
n2 = polymul(f1.get_den(), f2.get_num())
num = polysub(n1, n2)
return Filter(num, den)
def sub(self, u1, u2):
return self.adjust(np.polysub(u1, u2))
def stability_margins(sysdata, returnall=False, epsw=1e-8):
"""Calculate stability margins and associated crossover frequencies.
Parameters
----------
sysdata: LTI system or (mag, phase, omega) sequence
sys : LTI system
Linear SISO system
mag, phase, omega : sequence of array_like
Arrays of magnitudes (absolute values, not dB), phases (degrees),
and corresponding frequencies. Crossover frequencies returned are
in the same units as those in `omega` (e.g., rad/sec or Hz).
returnall: bool, optional
If true, return all margins found. If false (default), return only the
minimum stability margins. For frequency data or FRD systems, only one
margin is found and returned.
epsw: float, optional
Frequencies below this value (default 1e-8) are considered static gain,
and not returned as margin.
Returns
-------
gm: float or array_like
Gain margin
pm: float or array_loke
Phase margin
sm: float or array_like
Stability margin, the minimum distance from the Nyquist plot to -1
wg: float or array_like
Gain margin crossover frequency (where phase crosses -180 degrees)
wp: float or array_like
Phase margin crossover frequency (where gain crosses 0 dB)
ws: float or array_like
Stability margin frequency (where Nyquist plot is closest to -1)
"""
try:
if isinstance(sysdata, frdata.FRD):
sys = frdata.FRD(sysdata, smooth=True)
elif isinstance(sysdata, xferfcn.TransferFunction):
sys = sysdata
elif getattr(sysdata, '__iter__', False) and len(sysdata) == 3:
mag, phase, omega = sysdata
sys = frdata.FRD(mag * np.exp(1j * phase * np.pi/180),
omega, smooth=True)
else:
sys = xferfcn._convertToTransferFunction(sysdata)
except Exception as e:
print (e)
raise ValueError("Margin sysdata must be either a linear system or "
"a 3-sequence of mag, phase, omega.")
# calculate gain of system
if isinstance(sys, xferfcn.TransferFunction):
# check for siso
if not issiso(sys):
raise ValueError("Can only do margins for SISO system")
# real and imaginary part polynomials in omega:
rnum, inum = _polyimsplit(sys.num[0][0])
rden, iden = _polyimsplit(sys.den[0][0])
# test (imaginary part of tf) == 0, for phase crossover/gain margins
test_w_180 = np.polyadd(np.polymul(inum, rden), np.polymul(rnum, -iden))
w_180 = np.roots(test_w_180)
#print ('1:w_180', w_180)
# first remove imaginary and negative frequencies, epsw removes the
# "0" frequency for type-2 systems
w_180 = np.real(w_180[(np.imag(w_180) == 0) * (w_180 >= epsw)])
#print ('2:w_180', w_180)
# evaluate response at remaining frequencies, to test for phase 180 vs 0
resp_w_180 = np.real(np.polyval(sys.num[0][0], 1.j*w_180) /
np.polyval(sys.den[0][0], 1.j*w_180))
#print ('resp_w_180', resp_w_180)
# only keep frequencies where the negative real axis is crossed
w_180 = w_180[np.real(resp_w_180) < 0.0]
# and sort
w_180.sort()
#print ('3:w_180', w_180)
# test magnitude is 1 for gain crossover/phase margins
test_wc = np.polysub(np.polyadd(_polysqr(rnum), _polysqr(inum)),
np.polyadd(_polysqr(rden), _polysqr(iden)))
wc = np.roots(test_wc)
wc = np.real(wc[(np.imag(wc) == 0) * (wc > epsw)])
wc.sort()
# stability margin was a bitch to elaborate, relies on magnitude to
# point -1, then take the derivative. Second derivative needs to be >0
# to have a minimum
test_wstabd = np.polyadd(_polysqr(rden), _polysqr(iden))
test_wstabn = np.polyadd(_polysqr(np.polyadd(rnum,rden)),
_polysqr(np.polyadd(inum,iden)))
test_wstab = np.polysub(
np.polymul(np.polyder(test_wstabn),test_wstabd),
np.polymul(np.polyder(test_wstabd),test_wstabn))
# find the solutions, for positive omega, and only real ones
wstab = np.roots(test_wstab)
#print('wstabr', wstab)
wstab = np.real(wstab[(np.imag(wstab) == 0) *
(np.real(wstab) >= 0)])
#print('wstab', wstab)
# and find the value of the 2nd derivative there, needs to be positive
wstabplus = np.polyval(np.polyder(test_wstab), wstab)
#print('wstabplus', wstabplus)
wstab = np.real(wstab[(np.imag(wstab) == 0) * (wstab > epsw) *
(wstabplus > 0.)])
#print('wstab', wstab)
wstab.sort()
else:
# a bit coarse, have the interpolated frd evaluated again
def mod(w):
"""to give the function to calculate |G(jw)| = 1"""
return np.abs(sys.evalfr(w)[0][0]) - 1
def arg(w):
"""function to calculate the phase angle at -180 deg"""
return np.angle(-sys.evalfr(w)[0][0])
def dstab(w):
"""function to calculate the distance from -1 point"""
return np.abs(sys.evalfr(w)[0][0] + 1.)
# Find all crossings, note that this depends on omega having
# a correct range
widx = np.where(np.diff(np.sign(mod(sys.omega))))[0]
wc = np.array(
[ sp.optimize.brentq(mod, sys.omega[i], sys.omega[i+1])
for i in widx if i+1 < len(sys.omega)])
# find the phase crossings ang(H(jw) == -180
widx = np.where(np.diff(np.sign(arg(sys.omega))))[0]
#print('widx (180)', widx, sys.omega[widx])
#print('x', sys.evalfr(sys.omega[widx])[0][0])
widx = widx[np.real(sys.evalfr(sys.omega[widx])[0][0]) <= 0]
#print('widx (180,2)', widx)
w_180 = np.array(
[ sp.optimize.brentq(arg, sys.omega[i], sys.omega[i+1])
for i in widx if i+1 < len(sys.omega) ])
#print('x', sys.evalfr(w_180)[0][0])
#print('w_180', w_180)
# find all stab margins?
widx = np.where(np.diff(np.sign(np.diff(dstab(sys.omega)))))[0]
#print('widx', widx)
#print('wstabx', sys.omega[widx])
wstab = np.array([ sp.optimize.minimize_scalar(
dstab, bracket=(sys.omega[i], sys.omega[i+1])).x
for i in widx if i+1 < len(sys.omega) and
np.diff(np.diff(dstab(sys.omega[i-1:i+2])))[0] > 0 ])
#print('wstabf0', wstab)
wstab = wstab[(wstab >= sys.omega[0]) *
(wstab <= sys.omega[-1])]
#print ('wstabf', wstab)
# margins, as iterables, converted frdata and xferfcn calculations to
# vector for this
GM = 1/np.abs(sys.evalfr(w_180)[0][0])
SM = np.abs(sys.evalfr(wstab)[0][0]+1)
PM = np.angle(sys.evalfr(wc)[0][0], deg=True) + 180
if returnall:
return GM, PM, SM, w_180, wc, wstab
else:
return (
(GM.shape[0] or None) and np.amin(GM),
(PM.shape[0] or None) and np.amin(PM),
(SM.shape[0] or None) and np.amin(SM),
(w_180.shape[0] or None) and w_180[GM==np.amin(GM)][0],
(wc.shape[0] or None) and wc[PM==np.amin(PM)][0],
(wstab.shape[0] or None) and wstab[SM==np.amin(SM)][0])
def stability_margins(sysdata, deg=True, returnall=False, epsw=1e-10):
"""Calculate gain, phase and stability margins and associated
crossover frequencies.
Usage
-----
gm, pm, sm, wg, wp, ws = stability_margins(sysdata, deg=True,
returnall=False, epsw=1e-10)
Parameters
----------
sysdata: linsys or (mag, phase, omega) sequence
sys : linsys
Linear SISO system
mag, phase, omega : sequence of array_like
Input magnitude, phase, and frequencies (rad/sec) sequence from
bode frequency response data
deg=True: boolean
If true, all input and output phases in degrees, else in radians
returnall=False: boolean
If true, return all margins found. Note that for frequency data or
FRD systems, only one margin is found and returned.
epsw=1e-10: float
frequencies below this value are considered static gain, and not
returned as margin.
Returns
-------
gm, pm, sm, wg, wp, ws: float or array_like
Gain margin gm, phase margin pm, stability margin sm, and
associated crossover
frequencies wg, wp, and ws of SISO open-loop. If more than
one crossover frequency is detected, returns the lowest corresponding
margin.
When requesting all margins, the return values are array_like,
and all margins are returns for linear systems not equal to FRD
"""
try:
if isinstance(sysdata, frdata.FRD):
sys = frdata.FRD(sysdata, smooth=True)
elif isinstance(sysdata, xferfcn.TransferFunction):
sys = sysdata
elif getattr(sysdata, '__iter__', False) and len(sysdata) == 3:
mag, phase, omega = sysdata
sys = frdata.FRD(mag*np.exp((1j/360.)*phase), omega, smooth=True)
else:
sys = xferfcn._convertToTransferFunction(sysdata)
except Exception as e:
print (e)
raise ValueError("Margin sysdata must be either a linear system or "
"a 3-sequence of mag, phase, omega.")
# calculate gain of system
if isinstance(sys, xferfcn.TransferFunction):
# check for siso
if not issiso(sys):
raise ValueError("Can only do margins for SISO system")
# real and imaginary part polynomials in omega:
rnum, inum = _polyimsplit(sys.num[0][0])
rden, iden = _polyimsplit(sys.den[0][0])
# test imaginary part of tf == 0, for phase crossover/gain margins
test_w_180 = np.polyadd(np.polymul(inum, rden), np.polymul(rnum, -iden))
w_180 = np.roots(test_w_180)
# first remove imaginary and negative frequencies, epsw removes the
# "0" frequency for type-2 systems
w_180 = np.real(w_180[(np.imag(w_180) == 0) * (w_180 >= epsw)])
# evaluate response at remaining frequencies, to test for phase 180 vs 0
resp_w_180 = np.real(np.polyval(sys.num[0][0], 1.j*w_180) /
np.polyval(sys.den[0][0], 1.j*w_180))
# only keep frequencies where the negative real axis is crossed
w_180 = w_180[(resp_w_180 < 0.0)]
# and sort
w_180.sort()
# test magnitude is 1 for gain crossover/phase margins
test_wc = np.polysub(np.polyadd(_polysqr(rnum), _polysqr(inum)),
np.polyadd(_polysqr(rden), _polysqr(iden)))
wc = np.roots(test_wc)
wc = np.real(wc[(np.imag(wc) == 0) * (wc > epsw)])
wc.sort()
# stability margin was a bitch to elaborate, relies on magnitude to
# point -1, then take the derivative. Second derivative needs to be >0
# to have a minimum
test_wstabn = np.polyadd(_polysqr(rnum), _polysqr(inum))
test_wstabd = np.polyadd(_polysqr(np.polyadd(rnum,rden)),
_polysqr(np.polyadd(inum,iden)))
test_wstab = np.polysub(
np.polymul(np.polyder(test_wstabn),test_wstabd),
np.polymul(np.polyder(test_wstabd),test_wstabn))
# find the solutions
wstab = np.roots(test_wstab)
# and find the value of the 2nd derivative there, needs to be positive
wstabplus = np.polyval(np.polyder(test_wstab), wstab)
wstab = np.real(wstab[(np.imag(wstab) == 0) * (wstab > epsw) *
(np.abs(wstabplus) > 0.)])
wstab.sort()
else:
# a bit coarse, have the interpolated frd evaluated again
def mod(w):
"""to give the function to calculate |G(jw)| = 1"""
return [np.abs(sys.evalfr(w[0])[0][0]) - 1]
def arg(w):
"""function to calculate the phase angle at -180 deg"""
return [np.angle(sys.evalfr(w[0])[0][0]) + np.pi]
def dstab(w):
"""function to calculate the distance from -1 point"""
return np.abs(sys.evalfr(w[0])[0][0] + 1.)
# how to calculate the frequency at which |G(jw)| = 1
wc = np.array([sp.optimize.fsolve(mod, sys.omega[0])])[0]
w_180 = np.array([sp.optimize.fsolve(arg, sys.omega[0])])[0]
wstab = np.real(
np.array([sp.optimize.fmin(dstab, sys.omega[0], disp=0)])[0])
# margins, as iterables, converted frdata and xferfcn calculations to
# vector for this
PM = np.angle(sys.evalfr(wc)[0][0], deg=True) + 180
GM = 1/(np.abs(sys.evalfr(w_180)[0][0]))
SM = np.abs(sys.evalfr(wstab)[0][0]+1)
if returnall:
return GM, PM, SM, w_180, wc, wstab
else:
return (
(GM.shape[0] or None) and GM[0],
(PM.shape[0] or None) and PM[0],
(SM.shape[0] or None) and SM[0],
(w_180.shape[0] or None) and w_180[0],
(wc.shape[0] or None) and wc[0],
(wstab.shape[0] or None) and wstab[0])
def calc_c_s(r, q, k, p):
x_to_the_power_of_kp_minus_one = np.append([1], np.zeros(k*(p-1)))
r_tilde = np.polysub(r, x_to_the_power_of_kp_minus_one)
c, s = np.polydiv(r_tilde, q)
np.testing.assert_allclose(r_tilde, np.polyadd(np.polymul(q, c), s))
return c, s
qrvo_returns = np.diff(qrvo) / qrvo[:-1]
# smooth
smooth_avgo = np.convolve(weights / weights.sum(), avgo_returns)[N - 1:-N + 1]
smooth_qrvo = np.convolve(weights / weights.sum(), qrvo_returns)[N - 1:-N + 1]
t = np.arange(N - 1, len(avgo_returns))
plot(t, avgo_returns[N - 1:], lw=1.0)
plot(t, smooth_avgo, lw=2.0)
plot(t, qrvo_returns[N - 1:], lw=1.0)
plot(t, smooth_qrvo, lw=2.0)
show()
K = 3
poly_avgo = np.polyfit(t, smooth_avgo, K)
poly_qrvo = np.polyfit(t, smooth_qrvo, K)
poly_sub = np.polysub(poly_avgo, poly_qrvo)
xpoints = np.roots(poly_sub)
print("Intersection points {0}".format(xpoints))
reals = np.isreal(xpoints)
print("Real number? {0}".format(reals))
xpoints = np.select([reals], [xpoints])
xpoints = xpoints.real
print("Real intersection points {0}".format(xpoints))
print("Sans 0s {0}".format(np.trim_zeros(xpoints)))
mp.plot(dates[7:-1], Yang_Ming_Marine_SMT, linewidth=2, c='coral', label="Yang Ming Smoothing Lines")
# 找出數學多項式擬和公式，繪製擬和線
days = dates[7:-1].astype(int)
# 以多項式擬和三次方擬和
degree = 3
Eva_coefficient = np.polyfit(days, Eva_Marine_SMT, degree)
Ymg_coefficient = np.polyfit(days, Yang_Ming_Marine_SMT, degree)
Eva_poly_Fvalues = np.polyval(Eva_coefficient, days)
Ymg_poly_Fvalues = np.polyval(Ymg_coefficient, days)
# 以下為多項式擬和線繪製
mp.plot(dates[7:-1], Eva_poly_Fvalues, linewidth=5, c='green', label="Eva Marine Fitting Lines")
mp.plot(dates[7:-1], Ymg_poly_Fvalues, linewidth=5, c='coral', label="Yang Ming Fitting Lines")
# 找出兩條擬和線之交叉點
truning_points = np.polysub(Eva_poly_Fvalues, Ymg_poly_Fvalues) # 先求出之差
R_x = np.roots(truning_points) # 再求出交叉之根
R_y = np.polyval(Eva_coefficient, R_x) # 以根求出y
R_x = R_x.astype(int).astype('M8[D]')
#mp.scatter(R_x, R_y, marker="x", label="Turning Points")
# 設定格線繪製
ax = mp.gca()
# 設定x軸主要刻度(依據每周周一，不含周末)
ax.xaxis.set_major_locator(md.WeekdayLocator(byweekday=md.MONDAY))
# 設定x軸主要次刻度(依據天數)
ax.xaxis.set_minor_locator(md.DayLocator())
# 設定X軸主刻度顯示方式(日期/月份英文縮寫)
ax.xaxis.set_major_formatter(md.DateFormatter('%d-%b'))
mp.tick_params(labelsize=8)
mp.xticks(rotation=35)
#for n=even
E = np.array([1])
for root in np.roots(EnE):
if np.real(root) < 0:
#print(root)
E = np.polymul(E, np.array([1, -1*root]))
E = np.real(E)
#print(E)
#zout = (1-p)/(1+p)
zout = (1+p)/(1-p)
t = np.sqrt(1/zout)
pc = 2/(t+1/t)
MnM = np.polysub(EnE,(pc**2)*PnP)
M = np.array([1])
for root in np.roots(MnM):
if np.real(root) < 0:
#print(root)
M = np.polymul(M, np.array([1, -1*root]))
M = np.real(M)
X1On=np.polyadd(E,M)
X1Od=np.polysub(E,M)
#sort and organize transmission zeros for finite poles for synthesis
#According SU p296, finite pole frequencies closest to the bandedge should
#be placed in the middle of the filter to avoid negative components.
tzop=np.array([0,0,w2,0,w4])
print(numpy.poly([-1, 1, 1, 10]))
print(numpy.poly([1, 1]))
print(numpy.roots([1, 0, -1]))
print(numpy.polyint([1, 1, 1])) #find the integration
print(numpy.polyder([1, 1, 1, 1])) #find the derivative
print(numpy.polyval([1, -2, 0, 2], 4))
print(numpy.polyfit([0, 1, -1, 2, -2], [0, 1, 1, 4, 4],
2)) #fit the value with specific order
p1 = numpy.poly1d([1, 2])
p2 = numpy.poly1d([9, 5, 4])
print(p1)
print(p2)
print(numpy.polyadd(p1, p2))
print(numpy.polysub(p1, p2))
print(numpy.polymul(p1, p2))
print(numpy.polydiv(p1, p2))
#https://docs.scipy.org/doc/numpy/reference/routines.linalg.html
print(numpy.linalg.det([[1, 2], [2, 1]]))
vals, vecs = numpy.linalg.eig([[1, 2], [2, 1]])
print(vals)
print(vecs)
print(numpy.linalg.inv([[1, 2], [2, 1]]))
#sort two associated arraies
a = ['f', 'e', 'b', 'd', 'a']
b = list(range(0, len(a)))
aa = a
bb = b
if not issiso(sys):
raise ValueError("Can only do margins for SISO system")
# real and imaginary part polynomials in omega:
rnum, inum = _polyimsplit(sys.num[0][0])
rden, iden = _polyimsplit(sys.den[0][0])
# test imaginary part of tf == 0, for phase crossover/gain margins
test_w_180 = np.polyadd(np.polymul(inum, rden),
np.polymul(rnum, -iden))
w_180 = np.roots(test_w_180)
w_180 = np.real(w_180[(np.imag(w_180) == 0) * (w_180 > epsw)])
w_180.sort()
# test magnitude is 1 for gain crossover/phase margins
test_wc = np.polysub(np.polyadd(_polysqr(rnum), _polysqr(inum)),
np.polyadd(_polysqr(rden), _polysqr(iden)))
wc = np.roots(test_wc)
wc = np.real(wc[(np.imag(wc) == 0) * (wc > epsw)])
wc.sort()
# stability margin was a bitch to elaborate, relies on magnitude to
# point -1, then take the derivative. Second derivative needs to be >0
# to have a minimum
test_wstabn = np.polyadd(_polysqr(rnum), _polysqr(inum))
test_wstabd = np.polyadd(_polysqr(np.polyadd(rnum, rden)),
_polysqr(np.polyadd(inum, iden)))
test_wstab = np.polysub(
np.polymul(np.polyder(test_wstabn), test_wstabd),
np.polymul(np.polyder(test_wstabd), test_wstabn))
# find the solutions
bhp_returns = np.diff(bhp_closing_prices) / \
bhp_closing_prices[:-1]
vale_returns = np.diff(vale_closing_prices) / \
vale_closing_prices[:-1]
N = 8
weights = np.hanning(N)
weights / weights.sum()
bhp_smooth_returns = np.convolve(bhp_returns, weights, 'valid')
vale_smooth_returns = np.convolve(vale_returns, weights, 'valid')
days = dates[N - 1:-1].astype(int)
degree = 5
bhp_p = np.polyfit(days, bhp_smooth_returns, degree)
bhp_poly_returns = np.polyval(bhp_p, days)
vale_p = np.polyfit(days, vale_smooth_returns, degree)
vale_poly_returns = np.polyval(vale_p, days)
sub_p = np.polysub(bhp_p, vale_p)
roots = np.roots(sub_p)
reals = roots[np.isreal(roots)].real
inters = []
for real in reals:
if days[0] <= real and real <= days[-1]:
inters.append([real, np.polyval(bhp_p, real)])
inters = np.array(inters)
mp.figure(num='Smoothing Returns', facecolor='lightgray')
mp.title('Smoothing Returns', fontsize=20)
mp.xlabel('Date', fontsize=14)
mp.ylabel('Returns', fontsize=14)
ax = mp.gca()
ax.xaxis.set_major_locator(md.WeekdayLocator(byweekday=md.MO))
ax.xaxis.set_minor_locator(md.DayLocator())
ax.xaxis.set_major_formatter(md.DateFormatter('%d %b %Y'))
qrvo_returns = np.diff(qrvo)/qrvo[:-1]
# smooth
smooth_avgo = np.convolve(weights/weights.sum(), avgo_returns)[N-1:-N+1]
smooth_qrvo = np.convolve(weights/weights.sum(), qrvo_returns)[N-1:-N+1]
t = np.arange(N-1, len(avgo_returns))
plot(t, avgo_returns[N-1:], lw = 1.0)
plot(t, smooth_avgo, lw=2.0)
plot(t, qrvo_returns[N-1:], lw = 1.0)
plot(t, smooth_qrvo, lw = 2.0)
show()
K = 3
poly_avgo = np.polyfit(t, smooth_avgo, K)
poly_qrvo = np.polyfit(t, smooth_qrvo, K)
poly_sub = np.polysub(poly_avgo, poly_qrvo)
xpoints = np.roots(poly_sub)
print("Intersection points {0}".format(xpoints))
reals = np.isreal(xpoints)
print("Real number? {0}".format(reals))
xpoints = np.select([reals], [xpoints])
xpoints = xpoints.real
print("Real intersection points {0}".format(xpoints))
print("Sans 0s {0}".format(np.trim_zeros(xpoints)))
def residuez(b, a, tol=1e-3, rtype='avg'):
"""Compute partial-fraction expansion of b(z) / a(z).
If M = len(b) and N = len(a)
b(z) b[0] + b[1] z**(-1) + ... + b[M-1] z**(-M+1)
H(z) = ------ = ----------------------------------------------
a(z) a[0] + a[1] z**(-1) + ... + a[N-1] z**(-N+1)
r[0] r[-1]
= --------------- + ... + ---------------- + k[0] + k[1]z**(-1) ...
(1-p[0]z**(-1)) (1-p[-1]z**(-1))
If there are any repeated roots (closer than tol), then the partial
fraction expansion has terms like
r[i] r[i+1] r[i+n-1]
-------------- + ------------------ + ... + ------------------
(1-p[i]z**(-1)) (1-p[i]z**(-1))**2 (1-p[i]z**(-1))**n
See also
--------
invresz, poly, polyval, unique_roots
"""
b, a = map(asarray, (b, a))
gain = a[0]
brev, arev = b[::-1], a[::-1]
krev, brev = polydiv(brev, arev)
if krev == []:
k = []
else:
k = krev[::-1]
b = brev[::-1]
p = roots(a)
r = p * 0.0
pout, mult = unique_roots(p, tol=tol, rtype=rtype)
p = []
for n in range(len(pout)):
p.extend([pout[n]] * mult[n])
p = asarray(p)
# Compute the residue from the general formula (for discrete-time)
# the polynomial is in z**(-1) and the multiplication is by terms
# like this (1-p[i] z**(-1))**mult[i]. After differentiation,
# we must divide by (-p[i])**(m-k) as well as (m-k)!
indx = 0
for n in range(len(pout)):
bn = brev.copy()
pn = []
for l in range(len(pout)):
if l != n:
pn.extend([pout[l]] * mult[l])
an = atleast_1d(poly(pn))[::-1]
# bn(z) / an(z) is (1-po[n] z**(-1))**Nn * b(z) / a(z) where Nn is
# multiplicity of pole at po[n] and b(z) and a(z) are polynomials.
sig = mult[n]
for m in range(sig, 0, -1):
if sig > m:
# compute next derivative of bn(s) / an(s)
term1 = polymul(polyder(bn, 1), an)
term2 = polymul(bn, polyder(an, 1))
bn = polysub(term1, term2)
an = polymul(an, an)
r[indx + m -
1] = (polyval(bn, 1.0 / pout[n]) / polyval(an, 1.0 / pout[n]) /
factorial(sig - m) / (-pout[n])**(sig - m))
indx += sig
return r / gain, p, k
#for n=even
E = np.array([1])
for root in np.roots(EnE):
if np.real(root) < 0:
#print(root)
E = np.polymul(E, np.array([1, -1 * root]))
E = np.real(E)
#print(E)
#zout = (1-p)/(1+p)
zout = (1 + p) / (1 - p)
t = np.sqrt(1 / zout)
pc = 2 / (t + 1 / t)
MnM = np.polysub(EnE, (pc**2) * PnP)
M = np.array([1])
for root in np.roots(MnM):
if np.real(root) < 0:
#print(root)
M = np.polymul(M, np.array([1, -1 * root]))
M = np.real(M)
# #Form X1o for n=even
# Ee=np.copy(E)
# Eo=np.copy(E)
# Fe=np.copy(F)
# Fo=np.copy(F)
# for i in range(len(Ee)):
# if i%2==0:
# Eo[i]=0
def fly(self, point, isDebug):
global drone
begin, end = False, False #是否截止点
step, total = 0, len(point) - 1 #计算飞行步数，当前步数
print("预计飞行[%d]次航程" % total)
#起始向量，飞机头向下
startDirection = np.polyadd([0, 0], [0, 1])
if (len(point) > 0):
lastPoint = point[0]
for i in range(len(point)):
step += 1
p = point[i]
if p == lastPoint:
#第一步 连接ssid,飞机起飞，上升0.5m
begin = True
if (not isDebug):
if drone is None:
self.connect()
self.takeOff()
self.setSpeed()
# self.moveUp()
startVector = startDirection
toVector = np.polysub(point[i + 1], p)
rotate = self.cal_rotate(startVector, toVector)
distance = self.cal_distance(toVector)
cw_or_ccw = self.cal_cw_or_ccw(startVector, toVector)
elif p == point[len(point) - 1]:
#最后一步，降落
end = True
toVector = startDirection
startVector = np.polysub(p, point[i - 1])
rotate = self.cal_rotate(startVector, toVector)
cw_or_ccw = self.cal_cw_or_ccw(startVector, toVector)
distance = 0
else:
startVector = np.polysub(p, lastPoint)
toVector = np.polysub(point[i + 1], p)
rotate = self.cal_rotate(startVector, toVector)
distance = self.cal_distance(toVector)
cw_or_ccw = self.cal_cw_or_ccw(startVector, toVector)
pass
lastPoint = p
self.printRotateAndDistance(cw_or_ccw, distance, rotate, step,
total)
#实际飞行距离=像素坐标距离*比例尺
distance = distance * GlobalConfig.ratio()
print("[warning]actual fly distance:%f" % distance)
#debug模式不飞行
if not isDebug:
if cw_or_ccw > 0:
#顺时针
self.rotateCw(rotate)
else:
#逆时针
self.rotateCcw(rotate)
#前行
self.move_forward(distance)
if end:
self.land()
else:
#没有打点
print('no point error')
def _poly_iw_mag1_crossing(num_iw, den_iw, epsw):
# Return w where |H(iw)| == 1, |num(iw)| - |den(iw)| == 0
w = np.roots(np.polysub(_poly_iw_sqr(num_iw), _poly_iw_sqr(den_iw)))
w = np.real(w[np.isreal(w)])
w = w[w > epsw]
return w
def residue(b, a, tol=1e-3, rtype='avg'):
"""
Compute partial-fraction expansion of b(s) / a(s).
If ``M = len(b)`` and ``N = len(a)``, then the partial-fraction
expansion H(s) is defined as::
b(s) b[0] s**(M-1) + b[1] s**(M-2) + ... + b[M-1]
H(s) = ------ = ----------------------------------------------
a(s) a[0] s**(N-1) + a[1] s**(N-2) + ... + a[N-1]
r[0] r[1] r[-1]
= -------- + -------- + ... + --------- + k(s)
(s-p[0]) (s-p[1]) (s-p[-1])
If there are any repeated roots (closer together than `tol`), then H(s)
has terms like::
r[i] r[i+1] r[i+n-1]
-------- + ----------- + ... + -----------
(s-p[i]) (s-p[i])**2 (s-p[i])**n
Returns
-------
r : ndarray
Residues.
p : ndarray
Poles.
k : ndarray
Coefficients of the direct polynomial term.
See Also
--------
invres, numpy.poly, unique_roots
"""
b, a = map(asarray, (b, a))
rscale = a[0]
k, b = polydiv(b, a)
p = roots(a)
r = p * 0.0
pout, mult = unique_roots(p, tol=tol, rtype=rtype)
p = []
for n in range(len(pout)):
p.extend([pout[n]] * mult[n])
p = asarray(p)
# Compute the residue from the general formula
indx = 0
for n in range(len(pout)):
bn = b.copy()
pn = []
for l in range(len(pout)):
if l != n:
pn.extend([pout[l]] * mult[l])
an = atleast_1d(poly(pn))
# bn(s) / an(s) is (s-po[n])**Nn * b(s) / a(s) where Nn is
# multiplicity of pole at po[n]
sig = mult[n]
for m in range(sig, 0, -1):
if sig > m:
# compute next derivative of bn(s) / an(s)
term1 = polymul(polyder(bn, 1), an)
term2 = polymul(bn, polyder(an, 1))
bn = polysub(term1, term2)
an = polymul(an, an)
r[indx + m - 1] = polyval(bn, pout[n]) / polyval(an, pout[n]) \
/ factorial(sig - m)
indx += sig
return r / rscale, p, k
from numpy import polyadd, polysub
coeficientes_pol1 = [3, 2, -1] # Define o polinomio 3x**2 + 2x - 1\n"
coeficientes_pol2 = [4, -1, 3] # Define polinômio 4x**2 - x + 3\n"
# Adição de polinômios
resultado = polyadd(coeficientes_pol1, coeficientes_pol2)
print("Coeficientes do resultado da soma entre")
print(f"3x**2x - 2x -1 e 4x**2 - x + 3 é {resultado}")
# Subtração de polinômios
coeficientes_pol1 = [3, -2, -1] # Define o polinomio 3x**2 - 2x + 1\n",
coeficientes_pol2 = [-2, 0, 4] # Define polinômio -2x**2 + 4\n",
resultado = polysub(coeficientes_pol1, coeficientes_pol2)
print("Coeficientes do resultado da subtracao entre")
print(f"3x**2 - 2x + 1 e - 2x**2 + 4 é {resultado}")
def residuez(b,a,tol=1e-3,rtype='avg'):
"""Compute partial-fraction expansion of b(z) / a(z).
If M = len(b) and N = len(a)
b(z) b[0] + b[1] z**(-1) + ... + b[M-1] z**(-M+1)
H(z) = ------ = ----------------------------------------------
a(z) a[0] + a[1] z**(-1) + ... + a[N-1] z**(-N+1)
r[0] r[-1]
= --------------- + ... + ---------------- + k[0] + k[1]z**(-1) ...
(1-p[0]z**(-1)) (1-p[-1]z**(-1))
If there are any repeated roots (closer than tol), then the partial
fraction expansion has terms like
r[i] r[i+1] r[i+n-1]
-------------- + ------------------ + ... + ------------------
(1-p[i]z**(-1)) (1-p[i]z**(-1))**2 (1-p[i]z**(-1))**n
See also: invresz, poly, polyval, unique_roots
"""
b,a = map(asarray,(b,a))
gain = a[0]
brev, arev = b[::-1],a[::-1]
krev,brev = polydiv(brev,arev)
if krev == []:
k = []
else:
k = krev[::-1]
b = brev[::-1]
p = roots(a)
r = p*0.0
pout, mult = unique_roots(p,tol=tol,rtype=rtype)
p = []
for n in range(len(pout)):
p.extend([pout[n]]*mult[n])
p = asarray(p)
# Compute the residue from the general formula (for discrete-time)
# the polynomial is in z**(-1) and the multiplication is by terms
# like this (1-p[i] z**(-1))**mult[i]. After differentiation,
# we must divide by (-p[i])**(m-k) as well as (m-k)!
indx = 0
for n in range(len(pout)):
bn = brev.copy()
pn = []
for l in range(len(pout)):
if l != n:
pn.extend([pout[l]]*mult[l])
an = atleast_1d(poly(pn))[::-1]
# bn(z) / an(z) is (1-po[n] z**(-1))**Nn * b(z) / a(z) where Nn is
# multiplicity of pole at po[n] and b(z) and a(z) are polynomials.
sig = mult[n]
for m in range(sig,0,-1):
if sig > m:
# compute next derivative of bn(s) / an(s)
term1 = polymul(polyder(bn,1),an)
term2 = polymul(bn,polyder(an,1))
bn = polysub(term1,term2)
an = polymul(an,an)
r[indx+m-1] = polyval(bn,1.0/pout[n]) / polyval(an,1.0/pout[n]) \
/ factorial(sig-m) / (-pout[n])**(sig-m)
indx += sig
return r/gain, p, k
def __sub__(self, other):
return Polynomial(np.polysub(self.coefficients[::-1], other.coefficients[::-1])[::-1])
