def paduavals2coefs(f): m = len(f) n = int(round(-1.5 + np.sqrt(.25 + 2 * m))) x = padua_points(n) idx = _find_m(n) w = 0 * x[0] + 1. / (n * (n + 1)) idx1 = np.all(np.abs(x) == 1, axis=0) w[idx1] = .5 * w[idx1] idx2 = np.all(np.abs(x) != 1, axis=0) w[idx2] = 2 * w[idx2] G = np.zeros(idx.max() + 1) G[idx] = 4 * w * f use_dct = 100 < n if use_dct: C = np.rot90(dct(dct(G.T).T)) # , axis=1) else: t1 = np.r_[0:n + 1].reshape(-1, 1) Tn1 = np.cos(t1 * t1.T * np.pi / n) t2 = np.r_[0:n + 2].reshape(-1, 1) Tn2 = np.cos(t2 * t2.T * np.pi / (n + 1)) C = np.dot(Tn2, np.dot(G, Tn1)) C[0] = .5 * C[0] C[:, 1] = .5 * C[:, 1] C[0, -1] = .5 * C[0, -1] del C[-1] # Take upper-left triangular part: return np.fliplr(np.triu(np.fliplr(C)))
def paduavals2coefs(f): useFFTwhenNisMoreThan = 100 m = len(f) n = int(round(-1.5 + np.sqrt(.25 + 2 * m))) x = padua_points(n) idx = _find_m(n) w = 0 * x[0] + 1. / (n * (n + 1)) idx1 = np.all(np.abs(x) == 1, axis=0) w[idx1] = .5 * w[idx1] idx2 = np.all(np.abs(x) != 1, axis=0) w[idx2] = 2 * w[idx2] G = np.zeros(idx.max() + 1) G[idx] = 4 * w * f if (n < useFFTwhenNisMoreThan): t1 = np.r_[0:n + 1].reshape(-1, 1) Tn1 = np.cos(t1 * t1.T * np.pi / n) t2 = np.r_[0:n + 2].reshape(-1, 1) Tn2 = np.cos(t2 * t2.T * np.pi / (n + 1)) C = np.dot(Tn2, np.dot(G, Tn1)) else: # dct = @(c) chebtech2.coeffs2vals(c); C = np.rot90(dct(dct(G.T).T)) #, axis=1) C[0] = .5 * C[0] C[:, 1] = .5 * C[:, 1] C[0, -1] = .5 * C[0, -1] del C[-1] # Take upper-left triangular part: return np.fliplr(np.triu(np.fliplr(C)))
def test_dct_and_dctn(self): a = np.arange(12).reshape((3, -1)) y = wd.dct(a) x = wd.idct(y) assert_array_almost_equal(x, a) yn = wd.dctn(a) # , shape=(10,), axes=(1,)) xn = wd.idctn(yn) # , axes=(1,)) assert_array_almost_equal(xn, a)
def hisj(self, data, inc=512, L=7): ''' HISJ Improved Sheather-Jones estimate of smoothing parameter. Unlike many other implementations, this one is immune to problems caused by multimodal densities with widely separated modes. The estimation does not deteriorate for multimodal densities, because it do not assume a parametric model for the data. Parameters ---------- data - a vector of data from which the density estimate is constructed inc - the number of mesh points used in the uniform discretization Returns ------- bandwidth - the optimal bandwidth References ---------- Z. I. Botev, J. F. Grotowski, and D. P. Kroese (2010) "Kernel density estimation via diffusion" Annals of Statistics, Volume 38, Number 5, pages 2916-2957. ''' A = np.atleast_2d(data) d, n = A.shape ste_constant = self.kernel.get_ste_constant(n) ax1, bx1 = self._get_grid_limits(A) ste_constant2 = _GAUSS_KERNEL.get_ste_constant(n) def fixed_point(t, N, I, a2): ''' this implements the function t-zeta*gamma^[L](t)''' prod = np.prod # L = 7 logI = np.log(I) def fun(s, time): return (2 * pi ** (2 * s) * (a2 * exp(s * logI - I * pi ** 2 * time)).sum()) f = fun(L, t) for s in range(L - 1, 1, -1): K0 = prod(np.r_[1:2 * s:2]) / sqrt(2 * pi) const = (1 + (1. / 2) ** (s + 1. / 2)) / 3 time = (2 * const * K0 / N / f) ** (2. / (3 + 2 * s)) f = fun(s, time) return t - (2 * N * sqrt(pi) * f) ** (-2. / 5) h = np.empty(d) for dim in range(d): ax, bx = ax1[dim], bx1[dim] xa = np.linspace(ax, bx, inc) R = bx - ax c = gridcount(A[dim], xa) N = len(set(A[dim])) a = dct(c / len(A[dim]), norm=None) # now compute the optimal bandwidth^2 using the referenced method I = np.asfarray(np.arange(1, inc)) ** 2 a2 = (a[1:] / 2) ** 2 x = np.linspace(0, 0.1, 150) ai = x[0] bi = x[1] f0 = fixed_point(ai, N, I, a2) for xi in x[1:]: bi = xi f1 = fixed_point(bi, N, I, a2) if f1 * f0 <= 0: # print('ai = %g, bi = %g' % (ai,bi)) break else: ai = xi # use fzero to solve the equation t=zeta*gamma^[5](t) try: t_star = optimize.brentq(lambda t: fixed_point(t, N, I, a2), a=ai, b=bi) except Exception as err: t_star = 0.28 * N ** (-2. / 5) warnings.warn('Failure in obtaining smoothing parameter' ' ({})'.format(str(err))) # smooth the discrete cosine transform of initial data using t_star # a_t = a*exp(-np.arange(inc)**2*pi**2*t_star/2) # now apply the inverse discrete cosine transform # density = idct(a_t)/R; # take the rescaling of the data into account bandwidth = sqrt(t_star) * R # Kernel other than Gaussian scale bandwidth h[dim] = bandwidth * (ste_constant / ste_constant2) ** (1.0 / 5) # end for dim loop return h