def demo_kalman_voltimeter(): """ Examples -------- >>> demo_kalman_voltimeter() >>> plt.close() """ V0 = 12 h = np.atleast_2d(1) # voltimeter measure the voltage itself q = 1e-9 # variance of process noise as the car operates r = 0.05**2 # variance of measurement error b = 0 # no system input u = 0 # no system input filt = Kalman(R=r, A=1, Q=q, H=h, B=b) # Generate random voltages and watch the filter operate. n = 50 truth = np.random.randn(n) * np.sqrt(q) + V0 z = truth + np.random.randn(n) * np.sqrt(r) # measurement x = np.zeros(n) for i, zi in enumerate(z): x[i] = filt(zi, u) # perform a Kalman filter iteration _hz = plt.plot(z, 'r.', label='observations') # a-posteriori state estimates: _hx = plt.plot(x, 'b-', label='Kalman output') _ht = plt.plot(truth, 'g-', label='true voltage') plt.legend() plt.title('Automobile Voltimeter Example')
def test_kalman(): V0 = 12 h = np.atleast_2d(1) # voltimeter measure the voltage itself q = 1e-9 # variance of process noise as the car operates r = 0.05 ** 2 # variance of measurement error b = 0 # no system input u = 0 # no system input filt = Kalman(R=r, A=1, Q=q, H=h, B=b) # Generate random voltages and watch the filter operate. n = 50 truth = np.random.randn(n) * np.sqrt(q) + V0 z = truth + np.random.randn(n) * np.sqrt(r) # measurement x = np.zeros(n) for i, zi in enumerate(z): x[i] = filt(zi, u) # perform a Kalman filter iteration _hz = plt.plot(z, 'r.', label='observations') # a-posteriori state estimates: _hx = plt.plot(x, 'b-', label='Kalman output') _ht = plt.plot(truth, 'g-', label='true voltage') plt.legend() plt.title('Automobile Voltimeter Example') plt.show('hold')
def kde_demo4(N=50): """Demonstrate that the improved Sheather-Jones plug-in (hisj) is superior for 1D multimodal distributions KDEDEMO4 shows that the improved Sheather-Jones plug-in smoothing is a better compared to normal reference rules (in this case the hns) Examples -------- >>> kde_demo4() """ data = np.hstack((st.norm.rvs(loc=5, scale=1, size=(N,)), st.norm.rvs(loc=-5, scale=1, size=(N,)))) # x = np.linspace(1.5e-3, 5, 55) kde = KDE(data, kernel=Kernel('gauss', 'hns')) f = kde(output='plot', title='Ordinary KDE', plotflag=1) kde1 = KDE(data, kernel=Kernel('gauss', 'hisj')) f1 = kde1(output='plot', label='Ordinary KDE', plotflag=1) plt.figure(0) f.plot('r', label='hns={0}'.format(kde.hs)) # plt.figure(2) f1.plot('b', label='hisj={0}'.format(kde1.hs)) x = np.linspace(-9, 9) plt.plot(x, (st.norm.pdf(x, loc=-5, scale=1) + st.norm.pdf(x, loc=5, scale=1)) / 2, 'k:', label='True density') plt.legend()
def kde_demo5(N=500): """Demonstrate that the improved Sheather-Jones plug-in (hisj) is superior for 2D multimodal distributions KDEDEMO5 shows that the improved Sheather-Jones plug-in smoothing is better compared to normal reference rules (in this case the hns) Examples -------- >>> kde_demo5() """ data = np.hstack((st.norm.rvs(loc=5, scale=1, size=(2, N,)), st.norm.rvs(loc=-5, scale=1, size=(2, N,)))) kde = KDE(data, kernel=Kernel('gauss', 'hns')) f = kde(output='plot', plotflag=1, title='Ordinary KDE, hns={0:s}'.format(str(list(kde.hs)))) kde1 = KDE(data, kernel=Kernel('gauss', 'hisj')) f1 = kde1(output='plot', plotflag=1, title='Ordinary KDE, hisj={0:s}'.format(str(list(kde1.hs)))) plt.figure(0) plt.clf() f.plot() plt.plot(data[0], data[1], '.') plt.figure(1) plt.clf() f1.plot() plt.plot(data[0], data[1], '.')
def kde_demo2(): """Demonstrate the difference between transformation- and ordinary-KDE. KDEDEMO2 shows that the transformation KDE is a better estimate for Rayleigh distributed data around 0 than the ordinary KDE. Examples -------- >>> kde_demo2() """ data = st.rayleigh.rvs(scale=1, size=300) x = np.linspace(1.5e-2, 5, 55) kde = KDE(data) f = kde(output='plot', title='Ordinary KDE (hs={0:})'.format(kde.hs)) plt.figure(0) f.plot() plt.plot(x, st.rayleigh.pdf(x, scale=1), ':') # plotnorm((data).^(L2)) # gives a straight line => L2 = 0.5 reasonable hs = Kernel('gauss').get_smoothing(data**0.5) tkde = TKDE(data, hs=hs, L2=0.5) ft = tkde(x, output='plot', title='Transformation KDE (hs={0:})'.format(tkde.tkde.hs)) plt.figure(1) ft.plot() plt.plot(x, st.rayleigh.pdf(x, scale=1), ':') plt.figure(0)
def kde_demo3(): """Demonstrate the difference between transformation and ordinary-KDE in 2D KDEDEMO3 shows that the transformation KDE is a better estimate for Rayleigh distributed data around 0 than the ordinary KDE. Examples -------- >>> kde_demo3() """ data = st.rayleigh.rvs(scale=1, size=(2, 300)) # x = np.linspace(1.5e-3, 5, 55) kde = KDE(data) f = kde(output='plot', title='Ordinary KDE', plotflag=1) plt.figure(0) f.plot() plt.plot(data[0], data[1], '.') # plotnorm((data).^(L2)) % gives a straight line => L2 = 0.5 reasonable hs = Kernel('gauss').get_smoothing(data**0.5) tkde = TKDE(data, hs=hs, L2=0.5) ft = tkde.eval_grid_fast( output='plot', title='Transformation KDE', plotflag=1) plt.figure(1) ft.plot() plt.plot(data[0], data[1], '.') plt.figure(0)
def test_smooth(): t = np.linspace(-4, 4, 500) y = np.exp(-t ** 2) + np.random.normal(0, 0.05, t.shape) n = 11 ysg = SavitzkyGolay(n, degree=1, diff_order=0)(y) plt.plot(t, y, t, ysg, '--') plt.show('hold')
def demo_kalman_sine(): """Kalman Filter demonstration with sine signal. Examples -------- >>> demo_kalman_sine() >>> plt.close() """ sd = 0.5 dt = 0.1 w = 1 T = np.arange(0, 30 + dt / 2, dt) n = len(T) X = 3 * np.sin(w * T) Y = X + sd * np.random.randn(n) ''' Initialize KF to values x = 0 dx/dt = 0 with great uncertainty in derivative ''' M = np.zeros((2, 1)) P = np.diag([0.1, 2]) R = sd**2 H = np.atleast_2d([1, 0]) q = 0.1 F = np.atleast_2d([[0, 1], [0, 0]]) A, Q = lti_disc(F, L=None, Q=np.diag([0, q]), dt=dt) # Track and animate m = M.shape[0] _MM = np.zeros((m, n)) _PP = np.zeros((m, m, n)) '''In this demonstration we estimate a stationary sine signal from noisy measurements by using the classical Kalman filter.' ''' filt = Kalman(R=R, x=M, P=P, A=A, Q=Q, H=H, B=0) # Generate random voltages and watch the filter operate. # n = 50 # truth = np.random.randn(n) * np.sqrt(q) + V0 # z = truth + np.random.randn(n) * np.sqrt(r) # measurement truth = X z = Y x = np.zeros((n, m)) for i, zi in enumerate(z): x[i] = np.ravel(filt(zi, u=0)) _hz = plt.plot(z, 'r.', label='observations') # a-posteriori state estimates: _hx = plt.plot(x[:, 0], 'b-', label='Kalman output') _ht = plt.plot(truth, 'g-', label='true voltage') plt.legend() plt.title('Automobile Voltimeter Example')
def demo_smoothn_on_cardioid(): """ Examples -------- >>> demo_smoothn_on_cardioid() >>> plt.close() """ x, y, x0, y0 = _cardioid() z = smoothn(x + 1j * y, robust=False) plt.plot(x0, y0, 'y', x, y, 'r.', np.real(z), np.imag(z), 'k', linewidth=2)
def demo_savitzky_on_exponential(): """ Examples -------- >>> demo_savitzky_on_exponential() >>> plt.close() """ t = np.linspace(-4, 4, 500) y = np.exp(-t**2) + np.random.normal(0, 0.05, np.shape(t)) n = 11 ysg = SavitzkyGolay(n, degree=1, diff_order=0)(y) plt.plot(t, y, t, ysg, '--')
def test_smoothn_1d(): x = np.linspace(0, 100, 2 ** 8) y = np.cos(x / 10) + (x / 50) ** 2 + np.random.randn(x.size) / 10 y[np.r_[70, 75, 80]] = np.array([5.5, 5, 6]) z = smoothn(y) # Regular smoothing zr = smoothn(y, robust=True) # Robust smoothing plt.subplot(121), unused_h = plt.plot(x, y, 'r.', x, z, 'k', linewidth=2) plt.title('Regular smoothing') plt.subplot(122) plt.plot(x, y, 'r.', x, zr, 'k', linewidth=2) plt.title('Robust smoothing') plt.show('hold')
def test_kalman_sine(): """Kalman Filter demonstration with sine signal.""" sd = 1. dt = 0.1 w = 1 T = np.arange(0, 30 + dt / 2, dt) n = len(T) X = np.sin(w * T) Y = X + sd * np.random.randn(n) ''' Initialize KF to values x = 0 dx/dt = 0 with great uncertainty in derivative ''' M = np.zeros((2, 1)) P = np.diag([0.1, 2]) R = sd ** 2 H = np.atleast_2d([1, 0]) q = 0.1 F = np.atleast_2d([[0, 1], [0, 0]]) A, Q = lti_disc(F, L=None, Q=np.diag([0, q]), dt=dt) # Track and animate m = M.shape[0] _MM = np.zeros((m, n)) _PP = np.zeros((m, m, n)) '''In this demonstration we estimate a stationary sine signal from noisy measurements by using the classical Kalman filter.' ''' filt = Kalman(R=R, x=M, P=P, A=A, Q=Q, H=H, B=0) # Generate random voltages and watch the filter operate. # n = 50 # truth = np.random.randn(n) * np.sqrt(q) + V0 # z = truth + np.random.randn(n) * np.sqrt(r) # measurement truth = X z = Y x = np.zeros((n, m)) for i, zi in enumerate(z): x[i] = filt(zi, u=0).ravel() _hz = plt.plot(z, 'r.', label='observations') # a-posteriori state estimates: _hx = plt.plot(x[:, 0], 'b-', label='Kalman output') _ht = plt.plot(truth, 'g-', label='true voltage') plt.legend() plt.title('Automobile Voltimeter Example') plt.show()
def test_smoothn_cardioid(): t = np.linspace(0, 2 * pi, 1000) cos = np.cos sin = np.sin randn = np.random.randn x0 = 2 * cos(t) * (1 - cos(t)) x = x0 + randn(t.size) * 0.1 y0 = 2 * sin(t) * (1 - cos(t)) y = y0 + randn(t.size) * 0.1 z = smoothn(x + 1j * y, robust=False) plt.plot(x0, y0, 'y', x, y, 'r.', z.real, z.imag, 'k', linewidth=2) plt.show('hold')
def kde_demo1(): """KDEDEMO1 Demonstrate the smoothing parameter impact on KDE. KDEDEMO1 shows the true density (dotted) compared to KDE based on 7 observations (solid) and their individual kernels (dashed) for 3 different values of the smoothing parameter, hs. Examples -------- >>> kde_demo1() """ x = np.linspace(-4, 4, 101) x0 = x / 2.0 data = np.random.normal(loc=0, scale=1.0, size=7) kernel = Kernel('gauss') hs = kernel.hns(data) h_vec = [hs / 2, hs, 2 * hs] for ix, h in enumerate(h_vec): plt.figure(ix) kde = KDE(data, hs=h, kernel=kernel) f2 = kde(x, output='plot', title='h_s = {0:2.2f}'.format(float(h)), ylab='Density') f2.plot('k-') plt.plot(x, st.norm.pdf(x, 0, 1), 'k:') n = len(data) plt.plot(data, np.zeros(data.shape), 'bx') y = kernel(x0) / (n * h * kernel.norm_factor(d=1, n=n)) for i in range(n): plt.plot(data[i] + x0 * h, y, 'b--') plt.plot([data[i], data[i]], [0, np.max(y)], 'b') plt.axis([min(x), max(x), 0, 0.5])
def demo_hodrick_on_cardioid(): """ Examples -------- >>> demo_hodrick_on_cardioid() >>> plt.close() """ x, y, x0, y0 = _cardioid() smooth = HodrickPrescott(w=20000) # smooth = HampelFilter(adaptive=50) xs, ys = smooth(x), smooth(y) plt.plot(x0, y0, 'y', x, y, 'r.', xs, ys, 'k', linewidth=2)
def plotecdf(self, symb1="r-", symb2="b."): """ Plot Empirical and fitted Cumulative Distribution Function The purpose of the plot is to graphically assess whether the data could come from the fitted distribution. If so the empirical CDF should resemble the model CDF. Other distribution types will introduce deviations in the plot. """ n = len(self.data) F = (arange(1, n + 1)) / n plotbackend.plot(self.data, F, symb2, self.data, self.cdf(self.data), symb1) plotbackend.xlabel("x") plotbackend.ylabel("F(x) (%s)" % self.dist.name) plotbackend.title("Empirical CDF plot")
def plotecdf(self, symb1='r-', symb2='b.'): ''' Plot Empirical and fitted Cumulative Distribution Function The purpose of the plot is to graphically assess whether the data could come from the fitted distribution. If so the empirical CDF should resemble the model CDF. Other distribution types will introduce deviations in the plot. ''' n = len(self.data) F = (arange(1, n + 1)) / n plotbackend.plot(self.data, F, symb2, self.data, self.cdf(self.data), symb1) plotbackend.xlabel('x') plotbackend.ylabel('F(x) (%s)' % self.dist.name) plotbackend.title('Empirical CDF plot')
def test_hodrick_cardioid(): t = np.linspace(0, 2 * np.pi, 1000) cos = np.cos sin = np.sin randn = np.random.randn x0 = 2 * cos(t) * (1 - cos(t)) x = x0 + randn(t.size) * 0.1 y0 = 2 * sin(t) * (1 - cos(t)) y = y0 + randn(t.size) * 0.1 smooth = HodrickPrescott(w=20000) # smooth = HampelFilter(adaptive=50) z = smooth(x) + 1j * smooth(y) plt.plot(x0, y0, 'y', x, y, 'r.', z.real, z.imag, 'k', linewidth=2) plt.show('hold')
def plotresq(self, symb1='r-', symb2='b.'): '''PLOTRESQ displays a residual quantile plot. The purpose of the plot is to graphically assess whether the data could come from the fitted distribution. If so the plot will be linear. Other distribution types will introduce curvature in the plot. ''' n = len(self.data) eprob = (arange(1, n + 1) - 0.5) / n y = self.ppf(eprob) y1 = self.data[[0, -1]] plotbackend.plot(self.data, y, symb2, y1, y1, symb1) plotbackend.xlabel('Empirical') plotbackend.ylabel('Model (%s)' % self.dist.name) plotbackend.title('Residual Quantile Plot') plotbackend.axis('tight') plotbackend.axis('equal')
def plotresq(self, symb1="r-", symb2="b."): """PLOTRESQ displays a residual quantile plot. The purpose of the plot is to graphically assess whether the data could come from the fitted distribution. If so the plot will be linear. Other distribution types will introduce curvature in the plot. """ n = len(self.data) eprob = (arange(1, n + 1) - 0.5) / n y = self.ppf(eprob) y1 = self.data[[0, -1]] plotbackend.plot(self.data, y, symb2, y1, y1, symb1) plotbackend.xlabel("Empirical") plotbackend.ylabel("Model (%s)" % self.dist.name) plotbackend.title("Residual Quantile Plot") plotbackend.axis("tight") plotbackend.axis("equal")
def plotepdf(self, symb1="r-", symb2="b-"): """Plot Empirical and fitted Probability Density Function The purpose of the plot is to graphically assess whether the data could come from the fitted distribution. If so the histogram should resemble the model density. Other distribution types will introduce deviations in the plot. """ x, pdf = self._get_empirical_pdf() ymax = pdf.max() # plotbackend.hist(self.data,normed=True,fill=False) plotbackend.plot(self.data, self.pdf(self.data), symb1, x, pdf, symb2) ax = list(plotbackend.axis()) ax[3] = min(ymax * 1.3, ax[3]) plotbackend.axis(ax) plotbackend.xlabel("x") plotbackend.ylabel("f(x) (%s)" % self.dist.name) plotbackend.title("Density plot")
def demo_smoothn_on_1d_cos(): """ Examples -------- >>> demo_smoothn_on_1d_cos() >>> plt.close() """ x = np.linspace(0, 100, 2**8) y = np.cos(x / 10) + (x / 50)**2 + np.random.randn(np.size(x)) / 10 y[np.r_[70, 75, 80]] = np.array([5.5, 5, 6]) z = smoothn(y) # Regular smoothing zr = smoothn(y, robust=True) # Robust smoothing _h0 = plt.subplot(121), _h = plt.plot(x, y, 'r.', x, z, 'k', linewidth=2) plt.title('Regular smoothing') plt.subplot(122) plt.plot(x, y, 'r.', x, zr, 'k', linewidth=2) plt.title('Robust smoothing')
def plotepdf(self, symb1='r-', symb2='b-'): '''Plot Empirical and fitted Probability Density Function The purpose of the plot is to graphically assess whether the data could come from the fitted distribution. If so the histogram should resemble the model density. Other distribution types will introduce deviations in the plot. ''' x, pdf = self._get_empirical_pdf() ymax = pdf.max() # plotbackend.hist(self.data,normed=True,fill=False) plotbackend.plot(self.data, self.pdf(self.data), symb1, x, pdf, symb2) ax = list(plotbackend.axis()) ax[3] = min(ymax * 1.3, ax[3]) plotbackend.axis(ax) plotbackend.xlabel('x') plotbackend.ylabel('f(x) (%s)' % self.dist.name) plotbackend.title('Density plot')
def plotresprb(self, symb1="r-", symb2="b."): """ PLOTRESPRB displays a residual probability plot. The purpose of the plot is to graphically assess whether the data could come from the fitted distribution. If so the plot will be linear. Other distribution types will introduce curvature in the plot. """ n = len(self.data) # ecdf = (0.5:n-0.5)/n; ecdf = arange(1, n + 1) / (n + 1) mcdf = self.cdf(self.data) p1 = [0, 1] plotbackend.plot(ecdf, mcdf, symb2, p1, p1, symb1) plotbackend.xlabel("Empirical") plotbackend.ylabel("Model (%s)" % self.dist.name) plotbackend.title("Residual Probability Plot") plotbackend.axis("equal") plotbackend.axis([0, 1, 0, 1])
def plotresprb(self, symb1='r-', symb2='b.'): ''' PLOTRESPRB displays a residual probability plot. The purpose of the plot is to graphically assess whether the data could come from the fitted distribution. If so the plot will be linear. Other distribution types will introduce curvature in the plot. ''' n = len(self.data) # ecdf = (0.5:n-0.5)/n; ecdf = arange(1, n + 1) / (n + 1) mcdf = self.cdf(self.data) p1 = [0, 1] plotbackend.plot(ecdf, mcdf, symb2, p1, p1, symb1) plotbackend.xlabel('Empirical') plotbackend.ylabel('Model (%s)' % self.dist.name) plotbackend.title('Residual Probability Plot') plotbackend.axis('equal') plotbackend.axis([0, 1, 0, 1])
def kreg_demo1(hs=None, fast=True, fun='hisj'): """Compare KRegression to KernelReg from statsmodels.nonparametric Examples -------- >>> kreg_demo1() """ N = 100 # ei = np.random.normal(loc=0, scale=0.075, size=(N,)) ei = np.array([ -0.08508516, 0.10462496, 0.07694448, -0.03080661, 0.05777525, 0.06096313, -0.16572389, 0.01838912, -0.06251845, -0.09186784, -0.04304887, -0.13365788, -0.0185279, -0.07289167, 0.02319097, 0.06887854, -0.08938374, -0.15181813, 0.03307712, 0.08523183, -0.0378058, -0.06312874, 0.01485772, 0.06307944, -0.0632959, 0.18963205, 0.0369126, -0.01485447, 0.04037722, 0.0085057, -0.06912903, 0.02073998, 0.1174351, 0.17599277, -0.06842139, 0.12587608, 0.07698113, -0.0032394, -0.12045792, -0.03132877, 0.05047314, 0.02013453, 0.04080741, 0.00158392, 0.10237899, -0.09069682, 0.09242174, -0.15445323, 0.09190278, 0.07138498, 0.03002497, 0.02495252, 0.01286942, 0.06449978, 0.03031802, 0.11754861, -0.02322272, 0.00455867, -0.02132251, 0.09119446, -0.03210086, -0.06509545, 0.07306443, 0.04330647, 0.078111, -0.04146907, 0.05705476, 0.02492201, -0.03200572, -0.02859788, -0.05893749, 0.00089538, 0.0432551, 0.04001474, 0.04888828, -0.17708392, 0.16478644, 0.1171006, 0.11664846, 0.01410477, -0.12458953, -0.11692081, 0.0413047, -0.09292439, -0.07042327, 0.14119701, -0.05114335, 0.04994696, -0.09520663, 0.04829406, -0.01603065, -0.1933216, 0.19352763, 0.11819496, 0.04567619, -0.08348306, 0.00812816, -0.00908206, 0.14528945, 0.02901065]) x = np.linspace(0, 1, N) va_1 = 0.3 ** 2 va_2 = 0.7 ** 2 y0 = np.exp(-x ** 2 / (2 * va_1)) + 1.3 * np.exp(-(x - 1) ** 2 / (2 * va_2)) y = y0 + ei kernel = Kernel('gauss', fun=fun) hopt = kernel.hisj(x) kreg = KRegression( x, y, p=0, hs=hs, kernel=kernel, xmin=-2 * hopt, xmax=1 + 2 * hopt) if fast: kreg.__call__ = kreg.eval_grid_fast f = kreg(x, output='plot', title='Kernel regression', plotflag=1) plt.figure(0) f.plot(label='p=0') kreg.p = 1 f1 = kreg(x, output='plot', title='Kernel regression', plotflag=1) f1.plot(label='p=1') # print(f1.data) plt.plot(x, y, '.', label='data') plt.plot(x, y0, 'k', label='True model') from statsmodels.nonparametric.kernel_regression import KernelReg kreg2 = KernelReg(y, x, ('c')) y2 = kreg2.fit(x) plt.plot(x, y2[0], 'm', label='statsmodel') plt.legend()
def demo_tide_filter(): """ Examples -------- >>> demo_tide_filter() >>> plt.close() """ # import statsmodels.api as sa import wafo.spectrum.models as sm sd = 10 Sj = sm.Jonswap(Hm0=4. * sd) S = Sj.tospecdata() q = (0.1 * sd)**2 # variance of process noise s the car operates r = (100 * sd)**2 # variance of measurement error b = 0 # no system input u = 0 # no system input from scipy.signal import butter, filtfilt, lfilter_zi # lfilter, freq_tide = 1. / (12 * 60 * 60) freq_wave = 1. / 10 freq_filt = freq_wave / 10 dt = 1. freq = 1. / dt fn = (freq / 2) P = 10 * np.diag([1, 0.01]) R = r H = np.atleast_2d([1, 0]) F = np.atleast_2d([[0, 1], [0, 0]]) A, Q = lti_disc(F, L=None, Q=np.diag([0, q]), dt=dt) t = np.arange(0, 60 * 12, 1. / freq) w = 2 * np.pi * freq # 1 Hz tide = 100 * np.sin(freq_tide * w * t + 2 * np.pi / 4) + 100 y = tide + S.sim(len(t), dt=1. / freq)[:, 1].ravel() # lowess = sa.nonparametric.lowess # y2 = lowess(y, t, frac=0.5)[:,1] filt = Kalman(R=R, x=np.array([[tide[0]], [0]]), P=P, A=A, Q=Q, H=H, B=b) filt2 = Kalman(R=R, x=np.array([[tide[0]], [0]]), P=P, A=A, Q=Q, H=H, B=b) # y = tide + 0.5 * np.sin(freq_wave * w * t) # Butterworth filter b, a = butter(9, (freq_filt / fn), btype='low') # y2 = [lowess(y[max(i-60,0):i + 1], t[max(i-60,0):i + 1], frac=.3)[-1,1] # for i in range(len(y))] # y2 = [lfilter(b, a, y[:i + 1])[i] for i in range(len(y))] # y3 = filtfilt(b, a, y[:16]).tolist() + [filtfilt(b, a, y[:i + 1])[i] # for i in range(16, len(y))] # y0 = medfilt(y, 41) _zi = lfilter_zi(b, a) # y2 = lfilter(b, a, y)#, zi=y[0]*zi) # standard filter y3 = filtfilt(b, a, y) # filter with phase shift correction y4 = [] y5 = [] for _i, j in enumerate(y): tmp = np.ravel(filt(j, u=u)) tmp = np.ravel(filt2(tmp[0], u=u)) # if i==0: # print(filt.x) # print(filt2.x) y4.append(tmp[0]) y5.append(tmp[1]) _y0 = medfilt(y4, 41) # print(filt.P) # plot plt.plot(t, y, 'r.-', linewidth=2, label='raw data') # plt.plot(t, y2, 'b.-', linewidth=2, label='lowess @ %g Hz' % freq_filt) # plt.plot(t, y2, 'b.-', linewidth=2, label='filter @ %g Hz' % freq_filt) plt.plot(t, y3, 'g.-', linewidth=2, label='filtfilt @ %g Hz' % freq_filt) plt.plot(t, y4, 'k.-', linewidth=2, label='kalman') # plt.plot(t, y5, 'k.', linewidth=2, label='kalman2') plt.plot(t, tide, 'y-', linewidth=2, label='True tide') plt.legend(frameon=False, fontsize=14) plt.xlabel("Time [s]") plt.ylabel("Amplitude")
def test_tide_filter(): # import statsmodels.api as sa import wafo.spectrum.models as sm sd = 10 Sj = sm.Jonswap(Hm0=4.*sd) S = Sj.tospecdata() q = (0.1 * sd) ** 2 # variance of process noise s the car operates r = (100 * sd) ** 2 # variance of measurement error b = 0 # no system input u = 0 # no system input from scipy.signal import butter, filtfilt, lfilter_zi # lfilter, freq_tide = 1. / (12 * 60 * 60) freq_wave = 1. / 10 freq_filt = freq_wave / 10 dt = 1. freq = 1. / dt fn = (freq / 2) P = 10 * np.diag([1, 0.01]) R = r H = np.atleast_2d([1, 0]) F = np.atleast_2d([[0, 1], [0, 0]]) A, Q = lti_disc(F, L=None, Q=np.diag([0, q]), dt=dt) t = np.arange(0, 60 * 12, 1. / freq) w = 2 * np.pi * freq # 1 Hz tide = 100 * np.sin(freq_tide * w * t + 2 * np.pi / 4) + 100 y = tide + S.sim(len(t), dt=1. / freq)[:, 1].ravel() # lowess = sa.nonparametric.lowess # y2 = lowess(y, t, frac=0.5)[:,1] filt = Kalman(R=R, x=np.array([[tide[0]], [0]]), P=P, A=A, Q=Q, H=H, B=b) filt2 = Kalman(R=R, x=np.array([[tide[0]], [0]]), P=P, A=A, Q=Q, H=H, B=b) # y = tide + 0.5 * np.sin(freq_wave * w * t) # Butterworth filter b, a = butter(9, (freq_filt / fn), btype='low') # y2 = [lowess(y[max(i-60,0):i + 1], t[max(i-60,0):i + 1], frac=.3)[-1,1] # for i in range(len(y))] # y2 = [lfilter(b, a, y[:i + 1])[i] for i in range(len(y))] # y3 = filtfilt(b, a, y[:16]).tolist() + [filtfilt(b, a, y[:i + 1])[i] # for i in range(16, len(y))] # y0 = medfilt(y, 41) _zi = lfilter_zi(b, a) # y2 = lfilter(b, a, y)#, zi=y[0]*zi) # standard filter y3 = filtfilt(b, a, y) # filter with phase shift correction y4 = [] y5 = [] for _i, j in enumerate(y): tmp = filt(j, u=u).ravel() tmp = filt2(tmp[0], u=u).ravel() # if i==0: # print(filt.x) # print(filt2.x) y4.append(tmp[0]) y5.append(tmp[1]) _y0 = medfilt(y4, 41) print(filt.P) # plot plt.plot(t, y, 'r.-', linewidth=2, label='raw data') # plt.plot(t, y2, 'b.-', linewidth=2, label='lowess @ %g Hz' % freq_filt) # plt.plot(t, y2, 'b.-', linewidth=2, label='filter @ %g Hz' % freq_filt) plt.plot(t, y3, 'g.-', linewidth=2, label='filtfilt @ %g Hz' % freq_filt) plt.plot(t, y4, 'k.-', linewidth=2, label='kalman') # plt.plot(t, y5, 'k.', linewidth=2, label='kalman2') plt.plot(t, tide, 'y-', linewidth=2, label='True tide') plt.legend(frameon=False, fontsize=14) plt.xlabel("Time [s]") plt.ylabel("Amplitude") plt.show('hold')
def plot_hampel(Y, YY, res): X = np.arange(len(YY)) plt.plot(X, Y, 'b.') # Original Data plt.plot(X, YY, 'r') # Hampel Filtered Data plt.plot(X, res['Y0'], 'b--') # Nominal Data plt.plot(X, res['LB'], 'r--') # Lower Bounds on Hampel Filter plt.plot(X, res['UB'], 'r--') # Upper Bounds on Hampel Filter i = res['outliers'] plt.plot(X[i], Y[i], 'ks') # Identified Outliers
def demo_savitzky_on_noisy_chirp(): """ Examples -------- >>> demo_savitzky_on_noisy_chirp() >>> plt.close() """ plt.figure(figsize=(7, 12)) # generate chirp signal tvec = np.arange(0, 6.28, .02) true_signal = np.sin(tvec * (2.0 + tvec)) true_d_signal = (2 + tvec) * np.cos(tvec * (2.0 + tvec)) # add noise to signal noise = np.random.normal(size=true_signal.shape) signal = true_signal + .15 * noise # plot signal plt.subplot(311) plt.plot(signal) plt.title('signal') # smooth and plot signal plt.subplot(312) savgol = SavitzkyGolay(n=8, degree=4) s_signal = savgol.smooth(signal) s2 = smoothn(signal, robust=True) plt.plot(s_signal) plt.plot(s2) plt.plot(true_signal, 'r--') plt.title('smoothed signal') # smooth derivative of signal and plot it plt.subplot(313) savgol1 = SavitzkyGolay(n=8, degree=1, diff_order=1) dt = tvec[1] - tvec[0] d_signal = savgol1.smooth(signal) / dt plt.plot(d_signal) plt.plot(true_d_signal, 'r--') plt.title('smoothed derivative of signal')
xx[:, 1] = ss.detrend(xx[:, 1]) ts = wo.mat2timeseries(xx) Tcrcr, ix = ts.wave_periods(vh=0, pdef='c2c', wdef='tw', rate=8) Tc, ixc = ts.wave_periods(vh=0, pdef='u2d', wdef='tw', rate=8) #! Histogram of crestperiod compared to the kernel density estimate #!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ import wafo.kdetools as wk plt.clf() print(Tc.mean()) print(Tc.max()) t = np.linspace(0.01, 8, 200) ftc = wk.TKDE(Tc, L2=0, inc=128) plt.plot(t, ftc.eval_grid(t), t, ftc.eval_grid_fast(t), '-.') wm.plot_histgrm(Tc, normed=True) plt.title('Kernel Density Estimates') plt.xlabel('Tc [s]') plt.axis([0, 8, 0, 0.5]) plt.show() #! Extreme waves - model check: the highest and steepest wave #!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ plt.clf() S, H = ts.wave_height_steepness(kind=0) indS = S.argmax() indH = H.argmax() ts.plot_sp_wave([indH, indS], 'k.') plt.show()
xx[:, 1] = ss.detrend(xx[:, 1]) ts = wo.mat2timeseries(xx) Tcrcr, ix = ts.wave_periods(vh=0, pdef='c2c', wdef='tw', rate=8) Tc, ixc = ts.wave_periods(vh=0, pdef='u2d', wdef='tw', rate=8) #! Histogram of crestperiod compared to the kernel density estimate #!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ import wafo.kdetools as wk plt.clf() print(Tc.mean()) print(Tc.max()) t = np.linspace(0.01,8,200); ftc = wk.TKDE(Tc, L2=0, inc=128) plt.plot(t,ftc.eval_grid(t), t, ftc.eval_grid_fast(t),'-.') wm.plot_histgrm(Tc, normed=True) plt.title('Kernel Density Estimates') plt.xlabel('Tc [s]') plt.axis([0, 8, 0, 0.5]) plt.show() #! Extreme waves - model check: the highest and steepest wave #!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ plt.clf() S, H = ts.wave_height_steepness(kind=0) indS = S.argmax() indH = H.argmax() ts.plot_sp_wave([indH, indS],'k.') plt.show()
def clencurt(fun, a, b, n0=5, trace=False, *args): ''' Numerical evaluation of an integral, Clenshaw-Curtis method. Parameters ---------- fun : callable a, b : array-like Lower and upper integration limit, respectively. n : integer defines number of evaluation points (default 5) Returns ------- Q = evaluated integral tol = Estimate of the approximation error Notes ----- CLENCURT approximates the integral of f(x) from a to b using an 2*n+1 points Clenshaw-Curtis formula. The error estimate is usually a conservative estimate of the approximation error. The integral is exact for polynomials of degree 2*n or less. Example ------- >>> import numpy as np >>> val,err = clencurt(np.exp,0,2) >>> abs(val-np.expm1(2))< err, err<1e-10 (array([ True], dtype=bool), array([ True], dtype=bool)) See also -------- simpson, gaussq References ---------- [1] Goodwin, E.T. (1961), "Modern Computing Methods", 2nd edition, New yourk: Philosophical Library, pp. 78--79 [2] Clenshaw, C.W. and Curtis, A.R. (1960), Numerische Matematik, Vol. 2, pp. 197--205 ''' #% make sure n is even n = 2 * n0 a, b = np.atleast_1d(a, b) a_shape = a.shape af = a.ravel() bf = b.ravel() Na = np.prod(a_shape) s = np.r_[0:n + 1] s2 = np.r_[0:n + 1:2] s2.shape = (-1, 1) x1 = np.cos(np.pi * s / n) x1.shape = (-1, 1) x = x1 * (bf - af) / 2. + (bf + af) / 2 if hasattr(fun, '__call__'): f = fun(x) else: x0 = np.flipud(fun[:, 0]) n = len(x0) - 1 if abs(x - x0) > 1e-8: raise ValueError('Input vector x must equal cos(pi*s/n)*(b-a)/2+(b+a)/2') f = np.flipud(fun[:, 1::]) if trace: plt.plot(x, f, '+') # using a Gauss-Lobatto variant, i.e., first and last # term f(a) and f(b) is multiplied with 0.5 f[0, :] = f[0, :] / 2 f[n, :] = f[n, :] / 2 ## % x = cos(pi*0:n/n) ## % f = f(x) ## % ## % N+1 ## % c(k) = (2/N) sum f''(n)*cos(pi*(2*k-2)*(n-1)/N), 1 <= k <= N/2+1. ## % n=1 fft = np.fft.fft tmp = np.real(fft(f[:n, :], axis=0)) c = 2 / n * (tmp[0:n / 2 + 1, :] + np.cos(np.pi * s2) * f[n, :]) ## % old call ## % c = 2/n * cos(s2*s'*pi/n) * f c[0, :] = c[0, :] / 2 c[n / 2, :] = c[n / 2, :] / 2 ## % alternative call ## % c = dct(f) c = c[0:n / 2 + 1, :] / ((s2 - 1) * (s2 + 1)) Q = (af - bf) * np.sum(c, axis=0) #Q = (a-b).*sum( c(1:n/2+1,:)./repmat((s2-1).*(s2+1),1,Na)) abserr = (bf - af) * np.abs(c[n / 2, :]) if Na > 1: abserr = np.reshape(abserr, a_shape) Q = np.reshape(Q, a_shape) return Q, abserr
#tp = dat2tp(xs); #rfc = tp2rfc(tp); #plot(rfc(:, 2), rfc(:, 1), '.') #wafostamp('', '(ER)') #hold off #disp('Block = 9'), pause(pstate) #! Section 1.4.5 Extreme value statistics #!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # Plot of yura87 data plt.clf() import wafo.data as wd xn = wd.yura87() #xn = load('yura87.dat'); plt.subplot(211) plt.plot(xn[::30, 0] / 3600, xn[::30, 1], '.') plt.title('Water level') plt.ylabel('(m)') #! Formation of 5 min maxima yura = xn[:85500, 1] yura = np.reshape(yura, (285, 300)).T maxyura = yura.max(axis=0) plt.subplot(212) plt.plot(xn[299:85500:300, 0] / 3600, maxyura, '.') plt.xlabel('Time (h)') plt.ylabel('(m)') plt.title('Maximum 5 min water level') plt.show() #! Estimation of GEV for yuramax
def _plot_final_trace(self): if self.trace > 0: plt.clf() plt.plot(np.hstack(self.x_trace), np.hstack(self.y_trace), '+')
def clencurt(fun, a, b, n=5, trace=False): """ Numerical evaluation of an integral, Clenshaw-Curtis method. Parameters ---------- fun : callable a, b : array-like Lower and upper integration limit, respectively. n : integer defines number of evaluation points (default 5) Returns ------- q_val = evaluated integral tol = Estimate of the approximation error Notes ----- CLENCURT approximates the integral of f(x) from a to b using an 2*n+1 points Clenshaw-Curtis formula. The error estimate is usually a conservative estimate of the approximation error. The integral is exact for polynomials of degree 2*n or less. Examples -------- >>> import numpy as np >>> val, err = clencurt(np.exp, 0, 2) >>> np.allclose(val, np.expm1(2)), err[0] < 1e-10 (True, True) See also -------- simpson, gaussq References ---------- [1] Goodwin, E.T. (1961), "Modern Computing Methods", 2nd edition, New yourk: Philosophical Library, pp. 78--79 [2] Clenshaw, C.W. and Curtis, A.R. (1960), Numerische Matematik, Vol. 2, pp. 197--205 """ # make sure n_2 is even n_2 = 2 * int(n) a, b = np.atleast_1d(a, b) a_shape = a.shape a = a.ravel() b = b.ravel() a_size = np.prod(a_shape) s = np.c_[0:n_2 + 1:1] s_2 = np.c_[0:n_2 + 1:2] x = np.cos(np.pi * s / n_2) * (b - a) / 2. + (b + a) / 2 if hasattr(fun, '__call__'): f = fun(x) else: x_0 = np.flipud(fun[:, 0]) n_2 = len(x_0) - 1 _assert( abs(x - x_0) <= 1e-8, 'Input vector x must equal cos(pi*s/n_2)*(b-a)/2+(b+a)/2') f = np.flipud(fun[:, 1::]) if trace: plt.plot(x, f, '+') # using a Gauss-Lobatto variant, i.e., first and last # term f(a) and f(b) is multiplied with 0.5 f[0, :] = f[0, :] / 2 f[n_2, :] = f[n_2, :] / 2 # x = cos(pi*0:n_2/n_2) # f = f(x) # # N+1 # c(k) = (2/N) sum f''(n)*cos(pi*(2*k-2)*(n-1)/N), 1 <= k <= N/2+1. # n=1 n = n_2 // 2 fft = np.fft.fft tmp = np.real(fft(f[:n_2, :], axis=0)) c = 2 / n_2 * (tmp[0:n + 1, :] + np.cos(np.pi * s_2) * f[n_2, :]) c[0, :] = c[0, :] / 2 c[n, :] = c[n, :] / 2 c = c[0:n + 1, :] / ((s_2 - 1) * (s_2 + 1)) q_val = (a - b) * np.sum(c, axis=0) abserr = (b - a) * np.abs(c[n, :]) if a_size > 1: abserr = np.reshape(abserr, a_shape) q_val = np.reshape(q_val, a_shape) return q_val, abserr
#wafostamp([],'(ER)') plt.show() #disp('Block = 3'),pause(pstate) ## # Return values in the Gumbel distribution plt.clf() T = np.r_[1:100000] sT = gum[0] - gum[1] * np.log(-np.log1p(-1./T)) plt.semilogx(T, sT) plt.hold(True) # ws.edf(Hs).plot() Nmax = len(Hs) N = np.r_[1:Nmax+1] plt.plot(Nmax/N, sorted(Hs, reverse=True), '.') plt.title('Return values in the Gumbel model') plt.xlabel('Return period') plt.ylabel('Return value') #wafostamp([],'(ER)') plt.show() #disp('Block = 4'),pause(pstate) ## Section 5.2 Generalized Pareto and Extreme Value distributions ## Section 5.2.1 Generalized Extreme Value distribution # Empirical distribution of significant wave-height with estimated # Generalized Extreme Value distribution, gev = ws.genextreme.fit2(Hs) gev.plotfitsummary() # wafostamp([],'(ER)')
def clencurt(fun, a, b, n0=5, trace=False, args=()): ''' Numerical evaluation of an integral, Clenshaw-Curtis method. Parameters ---------- fun : callable a, b : array-like Lower and upper integration limit, respectively. n : integer defines number of evaluation points (default 5) Returns ------- Q = evaluated integral tol = Estimate of the approximation error Notes ----- CLENCURT approximates the integral of f(x) from a to b using an 2*n+1 points Clenshaw-Curtis formula. The error estimate is usually a conservative estimate of the approximation error. The integral is exact for polynomials of degree 2*n or less. Example ------- >>> import numpy as np >>> val,err = clencurt(np.exp,0,2) >>> abs(val-np.expm1(2))< err, err<1e-10 (array([ True], dtype=bool), array([ True], dtype=bool)) See also -------- simpson, gaussq References ---------- [1] Goodwin, E.T. (1961), "Modern Computing Methods", 2nd edition, New yourk: Philosophical Library, pp. 78--79 [2] Clenshaw, C.W. and Curtis, A.R. (1960), Numerische Matematik, Vol. 2, pp. 197--205 ''' # make sure n is even n = 2 * n0 a, b = np.atleast_1d(a, b) a_shape = a.shape af = a.ravel() bf = b.ravel() Na = np.prod(a_shape) s = np.r_[0:n + 1] s2 = np.r_[0:n + 1:2] s2.shape = (-1, 1) x1 = np.cos(np.pi * s / n) x1.shape = (-1, 1) x = x1 * (bf - af) / 2. + (bf + af) / 2 if hasattr(fun, '__call__'): f = fun(x) else: x0 = np.flipud(fun[:, 0]) n = len(x0) - 1 if abs(x - x0) > 1e-8: raise ValueError( 'Input vector x must equal cos(pi*s/n)*(b-a)/2+(b+a)/2') f = np.flipud(fun[:, 1::]) if trace: plt.plot(x, f, '+') # using a Gauss-Lobatto variant, i.e., first and last # term f(a) and f(b) is multiplied with 0.5 f[0, :] = f[0, :] / 2 f[n, :] = f[n, :] / 2 # % x = cos(pi*0:n/n) # % f = f(x) # % # % N+1 # % c(k) = (2/N) sum f''(n)*cos(pi*(2*k-2)*(n-1)/N), 1 <= k <= N/2+1. # % n=1 fft = np.fft.fft tmp = np.real(fft(f[:n, :], axis=0)) c = 2 / n * (tmp[0:n / 2 + 1, :] + np.cos(np.pi * s2) * f[n, :]) # % old call # % c = 2/n * cos(s2*s'*pi/n) * f c[0, :] = c[0, :] / 2 c[n / 2, :] = c[n / 2, :] / 2 # % alternative call # % c = dct(f) c = c[0:n / 2 + 1, :] / ((s2 - 1) * (s2 + 1)) Q = (af - bf) * np.sum(c, axis=0) # Q = (a-b).*sum( c(1:n/2+1,:)./repmat((s2-1).*(s2+1),1,Na)) abserr = (bf - af) * np.abs(c[n / 2, :]) if Na > 1: abserr = np.reshape(abserr, a_shape) Q = np.reshape(Q, a_shape) return Q, abserr
def gaussq(fun, a, b, reltol=1e-3, abstol=1e-3, alpha=0, beta=0, wfun=1, trace=False, args=None): ''' Numerically evaluate integral, Gauss quadrature. Parameters ---------- fun : callable a,b : array-like lower and upper integration limits, respectively. reltol, abstol : real scalars, optional relative and absolute tolerance, respectively. (default reltol=abstool=1e-3). wfun : scalar integer, optional defining the weight function, p(x). (default wfun = 1) 1 : p(x) = 1 a =-1, b = 1 Gauss-Legendre 2 : p(x) = exp(-x^2) a =-inf, b = inf Hermite 3 : p(x) = x^alpha*exp(-x) a = 0, b = inf Laguerre 4 : p(x) = (x-a)^alpha*(b-x)^beta a =-1, b = 1 Jacobi 5 : p(x) = 1/sqrt((x-a)*(b-x)), a =-1, b = 1 Chebyshev 1'st kind 6 : p(x) = sqrt((x-a)*(b-x)), a =-1, b = 1 Chebyshev 2'nd kind 7 : p(x) = sqrt((x-a)/(b-x)), a = 0, b = 1 8 : p(x) = 1/sqrt(b-x), a = 0, b = 1 9 : p(x) = sqrt(b-x), a = 0, b = 1 trace : bool, optional If non-zero a point plot of the integrand (default False). gn : scalar integer number of base points to start the integration with (default 2). alpha, beta : real scalars, optional Shape parameters of Laguerre or Jacobi weight function (alpha,beta>-1) (default alpha=beta=0) Returns ------- val : ndarray evaluated integral err : ndarray error estimate, absolute tolerance abs(int-intold) Notes ----- GAUSSQ numerically evaluate integral using a Gauss quadrature. The Quadrature integrates a (2m-1)th order polynomial exactly and the integral is of the form b Int (p(x)* Fun(x)) dx a GAUSSQ is vectorized to accept integration limits A, B and coefficients P1,P2,...Pn, as matrices or scalars and the result is the common size of A, B and P1,P2,...,Pn. Examples --------- integration of x**2 from 0 to 2 and from 1 to 4 >>> from scitools import numpyutils as npt >>> A = [0, 1]; B = [2,4] >>> fun = npt.wrap2callable('x**2') >>> [val1,err1] = gaussq(fun,A,B) >>> val1 array([ 2.6666667, 21. ]) >>> err1 array([ 1.7763568e-15, 1.0658141e-14]) Integration of x^2*exp(-x) from zero to infinity: >>> fun2 = npt.wrap2callable('1') >>> val2, err2 = gaussq(fun2, 0, npt.inf, wfun=3, alpha=2) >>> val3, err3 = gaussq(lambda x: x**2,0, npt.inf, wfun=3, alpha=0) >>> val2, err2 (array([ 2.]), array([ 6.6613381e-15])) >>> val3, err3 (array([ 2.]), array([ 1.7763568e-15])) Integrate humps from 0 to 2 and from 1 to 4 >>> val4, err4 = gaussq(humps,A,B) See also -------- qrule gaussq2d ''' global _POINTS_AND_WEIGHTS max_iter = 11 gn = 2 if not hasattr(fun, '__call__'): raise ValueError('Function must be callable') A, B = np.atleast_1d(a, b) a_shape = np.atleast_1d(A.shape) b_shape = np.atleast_1d(B.shape) if np.prod(a_shape) == 1: # make sure the integration limits have correct size A = A * ones(b_shape) a_shape = b_shape elif np.prod(b_shape) == 1: B = B * ones(a_shape) elif any(a_shape != b_shape): raise ValueError('The integration limits must have equal size!') if args is None: num_parameters = 0 else: num_parameters = len(args) P0 = copy.deepcopy(args) isvector1 = zeros(num_parameters) nk = np.prod(a_shape) #% # of integrals we have to compute for ix in xrange(num_parameters): if is_numlike(P0[ix]): p0_shape = np.shape(P0[ix]) Np0 = np.prod(p0_shape) isvector1[ix] = (Np0 > 1) if isvector1[ix]: if nk == 1: a_shape = p0_shape nk = Np0 A = A * ones(a_shape) B = B * ones(a_shape) elif nk != Np0: raise ValueError('The input must have equal size!') P0[ix].shape = (-1, 1) # make sure it is a column k = np.arange(nk) val = zeros(nk) val_old = zeros(nk) abserr = zeros(nk) #setup mapping parameters A.shape = (-1, 1) B.shape = (-1, 1) jacob = (B - A) / 2 shift = 1 if wfun == 1:# Gauss-legendre dx = jacob elif wfun == 2 or wfun == 3: shift = 0 jacob = ones((nk, 1)) A = zeros((nk, 1)) dx = jacob elif wfun == 4: dx = jacob ** (alpha + beta + 1) elif wfun == 5: dx = ones((nk, 1)) elif wfun == 6: dx = jacob ** 2 elif wfun == 7: shift = 0 jacob = jacob * 2 dx = jacob elif wfun == 8: shift = 0 jacob = jacob * 2 dx = sqrt(jacob) elif wfun == 9: shift = 0 jacob = jacob * 2 dx = sqrt(jacob) ** 3 else: raise ValueError('unknown option') dx = dx.ravel() if trace: x_trace = [0, ]*max_iter y_trace = [0, ]*max_iter if num_parameters > 0: ix_vec, = np.where(isvector1) if len(ix_vec): P1 = copy.copy(P0) #% Break out of the iteration loop for three reasons: #% 1) the last update is very small (compared to int and compared to reltol) #% 2) There are more than 11 iterations. This should NEVER happen. for ix in xrange(max_iter): x_and_w = 'wfun%d_%d_%g_%g' % (wfun, gn, alpha, beta) if x_and_w in _POINTS_AND_WEIGHTS: xn, w = _POINTS_AND_WEIGHTS[x_and_w] else: xn, w = qrule(gn, wfun, alpha, beta) _POINTS_AND_WEIGHTS[x_and_w] = (xn, w) # calculate the x values x = (xn + shift) * jacob[k, :] + A[k, :] # calculate function values y=fun(x,p1,p2,....,pn) if num_parameters > 0: if len(ix_vec): #% Expand vector to the correct size for iy in ix_vec: P1[iy] = P0[iy][k, :] y = fun(x, **P1) else: y = fun(x, **P0) else: y = fun(x) val[k] = np.sum(w * y, axis=1) * dx[k] # do the integration sum(y.*w) if trace: x_trace.append(x.ravel()) y_trace.append(y.ravel()) hfig = plt.plot(x, y, 'r.') #hold on #drawnow,shg #if trace>1: # pause plt.setp(hfig, 'color', 'b') abserr[k] = abs(val_old[k] - val[k]) #absolute tolerance if ix > 1: k, = np.where(abserr > np.maximum(abs(reltol * val), abstol)) # abserr > abs(abstol))%indices to integrals which did not converge nk = len(k)# of integrals we have to compute again if nk : val_old[k] = val[k] else: break gn *= 2 #double the # of basepoints and weights else: if nk > 1: if (nk == np.prod(a_shape)): tmptxt = 'All integrals did not converge--singularities likely!' else: tmptxt = '%d integrals did not converge--singularities likely!' % (nk,) else: tmptxt = 'Integral did not converge--singularity likely!' warnings.warn(tmptxt) val.shape = a_shape # make sure int is the same size as the integration limits abserr.shape = a_shape if trace > 0: plt.clf() plt.plot(np.hstack(x_trace), np.hstack(y_trace), '+') return val, abserr
def _plot_trace(self, x, y): if self.trace: self.x_trace.append(x.ravel()) self.y_trace.append(y.ravel()) hfig = plt.plot(x, y, 'r.') plt.setp(hfig, 'color', 'b')
#wafostamp([],'(ER)') plt.show() #disp('Block = 3'),pause(pstate) ## # Return values in the Gumbel distribution plt.clf() T = np.r_[1:100000] sT = gum[0] - gum[1] * np.log(-np.log1p(-1. / T)) plt.semilogx(T, sT) plt.hold(True) # ws.edf(Hs).plot() Nmax = len(Hs) N = np.r_[1:Nmax + 1] plt.plot(Nmax / N, sorted(Hs, reverse=True), '.') plt.title('Return values in the Gumbel model') plt.xlabel('Return period') plt.ylabel('Return value') #wafostamp([],'(ER)') plt.show() #disp('Block = 4'),pause(pstate) ## Section 5.2 Generalized Pareto and Extreme Value distributions ## Section 5.2.1 Generalized Extreme Value distribution # Empirical distribution of significant wave-height with estimated # Generalized Extreme Value distribution, gev = ws.genextreme.fit2(Hs) gev.plotfitsummary() # wafostamp([],'(ER)')
# wafostamp([],'(ER)') plt.show(block=True) #disp('Block = 3'),pause(pstate) ## # Return values in the Gumbel distribution plt.clf() T = np.r_[2:100000] sT = gum[0] - gum[1] * np.log(-np.log1p(-1. / T)) plt.semilogx(T, sT) # ws.edf(Hs).plot() Nmax = len(Hs) N = np.r_[1:Nmax + 1] plt.plot(Nmax / N, sorted(Hs, reverse=True), '.') plt.title('Return values in the Gumbel model') plt.xlabel('Return period') plt.ylabel('Return value') # wafostamp([],'(ER)') plt.show(block=True) #disp('Block = 4'),pause(pstate) # Section 5.2 Generalized Pareto and Extreme Value distributions # Section 5.2.1 Generalized Extreme Value distribution # Empirical distribution of significant wave-height with estimated # Generalized Extreme Value distribution, gev = ws.genextreme.fit2(Hs) # gev.plotfitsummary()