def test_integ(self) : p = self.p2.integ() assert_almost_equal(p.coef, ch.chebint([1,2,3], 1, 0, scl=.5)) p = self.p2.integ(1, 1) assert_almost_equal(p.coef, ch.chebint([1,2,3], 1, 1, scl=.5)) p = self.p2.integ(2, [1, 2]) assert_almost_equal(p.coef, ch.chebint([1,2,3], 2, [1,2], scl=.5))
def test_integ(self) : p = self.p2.integ() assert_almost_equal(p.coef, ch.chebint([1,2,3], 1, 0, scl=.5)) p = self.p2.integ(lbnd=0) assert_almost_equal(p(0), 0) p = self.p2.integ(1, 1) assert_almost_equal(p.coef, ch.chebint([1,2,3], 1, 1, scl=.5)) p = self.p2.integ(2, [1, 2]) assert_almost_equal(p.coef, ch.chebint([1,2,3], 2, [1,2], scl=.5))
def _cdf(self, x, *args): """ Return CDF of the polynom function """ coeffs = np.array([c[0] for c in args]) coeffs = coeffs / coeffs.sum(axis=0) coeffs = chebyshev.chebint(coeffs) cdf_not_scaled = chebyshev.chebval(x, coeffs) + x + 1 - chebyshev.chebval(-1, coeffs) integral_coeffs = chebyshev.chebint(coeffs) scale = chebyshev.chebval(1, coeffs) + 2 - chebyshev.chebval(-1, coeffs) cdf = np.where(x < -1.0, 0.0, np.where(x > 1.0, 1.0, cdf_not_scaled / scale)) return cdf
def chebcdf(pdf, lower_bd, upper_bd, eps=10**(-15)): """Get Chebyshev approximation of the CDF. Parameters ---------- pdf : function, float -> float The probability density function (not necessarily normalized). Must take floats or ints as input, and return floats as an output. lower_bd : float Lower bound of the support of the pdf. This parameter allows one to manually establish cutoffs for the density. upper_bd : float Upper bound of the support of the pdf. eps: float Error tolerance of Chebyshev polynomial fit of PDF. Returns ------- cdf : function The cumulative density function of the (normalized version of the) provided pdf. The function cdf() takes an iterable of floats or doubles as an argument, and returns an iterable of floats of the same length. """ if not (np.isfinite(lower_bd) and np.isfinite(upper_bd)): raise ValueError('Bounds must be finite.') if not lower_bd < upper_bd: raise ValueError('Lower bound must be less than upper bound.') x,coeffs = adaptive_chebfit(pdf, lower_bd, upper_bd, eps) int_coeffs = chebint(coeffs) # offset and scale so that it goes from 0 to 1, i.e. is a true CDF. offset = chebval(lower_bd, int_coeffs) scale = chebval(upper_bd, int_coeffs) - chebval(lower_bd, int_coeffs) cdf = lambda x: (chebval(x,int_coeffs) - offset) / scale return cdf
def C1(n): """ integral related to first order finite Larmor radius effect """ c1 = poly2cheb([0, 0, 0, 0, -1.5, 0, 2]) c2 = nthpoly(2 * n) kernel = chebmul(c1, c2) cint = chebint(kernel) return chebval(1, cint)
def C0(n): """ integral related to zero'th order finite Larmor radius effect """ c1 = poly2cheb([0, 1, 0, -2]) c2 = nthpoly(2 * n) kernel = chebmul(c1, c2) cint = chebint(kernel) return chebval(1, cint)
def test_chebder(self) : # check exceptions assert_raises(ValueError, ch.chebder, [0], -1) # check that zeroth deriviative does nothing for i in range(5) : tgt = [1] + [0]*i res = ch.chebder(tgt, m=0) assert_equal(trim(res), trim(tgt)) # check that derivation is the inverse of integration for i in range(5) : for j in range(2,5) : tgt = [1] + [0]*i res = ch.chebder(ch.chebint(tgt, m=j), m=j) assert_almost_equal(trim(res), trim(tgt)) # check derivation with scaling for i in range(5) : for j in range(2,5) : tgt = [1] + [0]*i res = ch.chebder(ch.chebint(tgt, m=j, scl=2), m=j, scl=.5) assert_almost_equal(trim(res), trim(tgt))
def test_chebder(self): # check exceptions assert_raises(ValueError, ch.chebder, [0], -1) # check that zeroth deriviative does nothing for i in range(5): tgt = [1] + [0] * i res = ch.chebder(tgt, m=0) assert_equal(trim(res), trim(tgt)) # check that derivation is the inverse of integration for i in range(5): for j in range(2, 5): tgt = [1] + [0] * i res = ch.chebder(ch.chebint(tgt, m=j), m=j) assert_almost_equal(trim(res), trim(tgt)) # check derivation with scaling for i in range(5): for j in range(2, 5): tgt = [1] + [0] * i res = ch.chebder(ch.chebint(tgt, m=j, scl=2), m=j, scl=.5) assert_almost_equal(trim(res), trim(tgt))
def _pdf(self, x, *args): """ Return PDF of the polynom function """ # TODO Fix support for large args coeffs = np.array([c[0] for c in args]) coeffs = coeffs / coeffs.sum(axis=0) # +1 so that the pdf is always positive pdf_not_normed = chebyshev.chebval(x, coeffs) + 1 integral_coeffs = chebyshev.chebint(coeffs) norm = chebyshev.chebval(1, integral_coeffs) - chebyshev.chebval(-1, integral_coeffs) + 2 pdf = np.where(np.abs(x) > 1.0, 0.0, pdf_not_normed / norm) return pdf
def test_chebint_axis(self): # check that axis keyword works c2d = np.random.random((3, 4)) tgt = np.vstack([cheb.chebint(c) for c in c2d.T]).T res = cheb.chebint(c2d, axis=0) assert_almost_equal(res, tgt) tgt = np.vstack([cheb.chebint(c) for c in c2d]) res = cheb.chebint(c2d, axis=1) assert_almost_equal(res, tgt) tgt = np.vstack([cheb.chebint(c, k=3) for c in c2d]) res = cheb.chebint(c2d, k=3, axis=1) assert_almost_equal(res, tgt)
def test_chebint(self) : # check exceptions assert_raises(ValueError, cheb.chebint, [0], .5) assert_raises(ValueError, cheb.chebint, [0], -1) assert_raises(ValueError, cheb.chebint, [0], 1, [0,0]) # test integration of zero polynomial for i in range(2, 5): k = [0]*(i - 2) + [1] res = cheb.chebint([0], m=i, k=k) assert_almost_equal(res, [0, 1]) # check single integration with integration constant for i in range(5) : scl = i + 1 pol = [0]*i + [1] tgt = [i] + [0]*i + [1/scl] chebpol = cheb.poly2cheb(pol) chebint = cheb.chebint(chebpol, m=1, k=[i]) res = cheb.cheb2poly(chebint) assert_almost_equal(trim(res), trim(tgt)) # check single integration with integration constant and lbnd for i in range(5) : scl = i + 1 pol = [0]*i + [1] chebpol = cheb.poly2cheb(pol) chebint = cheb.chebint(chebpol, m=1, k=[i], lbnd=-1) assert_almost_equal(cheb.chebval(-1, chebint), i) # check single integration with integration constant and scaling for i in range(5) : scl = i + 1 pol = [0]*i + [1] tgt = [i] + [0]*i + [2/scl] chebpol = cheb.poly2cheb(pol) chebint = cheb.chebint(chebpol, m=1, k=[i], scl=2) res = cheb.cheb2poly(chebint) assert_almost_equal(trim(res), trim(tgt)) # check multiple integrations with default k for i in range(5) : for j in range(2,5) : pol = [0]*i + [1] tgt = pol[:] for k in range(j) : tgt = cheb.chebint(tgt, m=1) res = cheb.chebint(pol, m=j) assert_almost_equal(trim(res), trim(tgt)) # check multiple integrations with defined k for i in range(5) : for j in range(2,5) : pol = [0]*i + [1] tgt = pol[:] for k in range(j) : tgt = cheb.chebint(tgt, m=1, k=[k]) res = cheb.chebint(pol, m=j, k=list(range(j))) assert_almost_equal(trim(res), trim(tgt)) # check multiple integrations with lbnd for i in range(5) : for j in range(2,5) : pol = [0]*i + [1] tgt = pol[:] for k in range(j) : tgt = cheb.chebint(tgt, m=1, k=[k], lbnd=-1) res = cheb.chebint(pol, m=j, k=list(range(j)), lbnd=-1) assert_almost_equal(trim(res), trim(tgt)) # check multiple integrations with scaling for i in range(5) : for j in range(2,5) : pol = [0]*i + [1] tgt = pol[:] for k in range(j) : tgt = cheb.chebint(tgt, m=1, k=[k], scl=2) res = cheb.chebint(pol, m=j, k=list(range(j)), scl=2) assert_almost_equal(trim(res), trim(tgt))
def test_chebint(self): # check exceptions assert_raises(ValueError, cheb.chebint, [0], .5) assert_raises(ValueError, cheb.chebint, [0], -1) assert_raises(ValueError, cheb.chebint, [0], 1, [0, 0]) # test integration of zero polynomial for i in range(2, 5): k = [0]*(i - 2) + [1] res = cheb.chebint([0], m=i, k=k) assert_almost_equal(res, [0, 1]) # check single integration with integration constant for i in range(5): scl = i + 1 pol = [0]*i + [1] tgt = [i] + [0]*i + [1/scl] chebpol = cheb.poly2cheb(pol) chebint = cheb.chebint(chebpol, m=1, k=[i]) res = cheb.cheb2poly(chebint) assert_almost_equal(trim(res), trim(tgt)) # check single integration with integration constant and lbnd for i in range(5): scl = i + 1 pol = [0]*i + [1] chebpol = cheb.poly2cheb(pol) chebint = cheb.chebint(chebpol, m=1, k=[i], lbnd=-1) assert_almost_equal(cheb.chebval(-1, chebint), i) # check single integration with integration constant and scaling for i in range(5): scl = i + 1 pol = [0]*i + [1] tgt = [i] + [0]*i + [2/scl] chebpol = cheb.poly2cheb(pol) chebint = cheb.chebint(chebpol, m=1, k=[i], scl=2) res = cheb.cheb2poly(chebint) assert_almost_equal(trim(res), trim(tgt)) # check multiple integrations with default k for i in range(5): for j in range(2, 5): pol = [0]*i + [1] tgt = pol[:] for k in range(j): tgt = cheb.chebint(tgt, m=1) res = cheb.chebint(pol, m=j) assert_almost_equal(trim(res), trim(tgt)) # check multiple integrations with defined k for i in range(5): for j in range(2, 5): pol = [0]*i + [1] tgt = pol[:] for k in range(j): tgt = cheb.chebint(tgt, m=1, k=[k]) res = cheb.chebint(pol, m=j, k=list(range(j))) assert_almost_equal(trim(res), trim(tgt)) # check multiple integrations with lbnd for i in range(5): for j in range(2, 5): pol = [0]*i + [1] tgt = pol[:] for k in range(j): tgt = cheb.chebint(tgt, m=1, k=[k], lbnd=-1) res = cheb.chebint(pol, m=j, k=list(range(j)), lbnd=-1) assert_almost_equal(trim(res), trim(tgt)) # check multiple integrations with scaling for i in range(5): for j in range(2, 5): pol = [0]*i + [1] tgt = pol[:] for k in range(j): tgt = cheb.chebint(tgt, m=1, k=[k], scl=2) res = cheb.chebint(pol, m=j, k=list(range(j)), scl=2) assert_almost_equal(trim(res), trim(tgt))
if __name__ == '__main__': Ny = 201 Ly = 1. # ys = Ly * np.linspace(0, 1, Ny) # ys = Ly * (1 - np.cos(.5*np.pi*np.linspace(0,1,Ny))) ys = cb.chebpts2(Ny) # D1, D2, I2 = Schemes.compact6(ys) # D1, D2, I2 = Schemes.center2(ys) D1, D2, I1 = Schemes.cheb(ys) # us = np.sin(2*np.pi*ys) * np.cos(np.pi*ys**2) us = (ys - ys[0]) * (ys[-1] - ys) print(cb.chebval(ys, cb.chebint(cb.chebfit(ys, us, len(ys)-1), lbnd=ys[0]))[-1]) print(np.diag(I1) @ us * (ys[-1]-ys[0])) Schemes.check(ys, us, D1, D2)
def chebint(cs, m=1, k=[], lbnd=0, scl=1): from numpy.polynomial.chebyshev import chebint return chebint(cs, m, k, lbnd, scl)
def indefInt(A, s=1): return np_cheb.chebint(A, scl=s)