Python pychebfun.Chebfun类代码示例

 def test_interp_values(self):
     """
     Instanciate Chebfun from interpolation values.
     """
     p2 = Chebfun(self.p.values())
     npt.assert_almost_equal(self.p.coefficients(), p2.coefficients())
     tools.assert_close(self.p, p2)

 def test_prune(self):
     N = 10
     coeffs = np.array([1.]+N*[0])
     c0 = Chebfun.from_coeff(coeffs)
     npt.assert_allclose(c0.coefficients(), [1.])
     c1 = Chebfun.from_coeff(coeffs, prune=False)
     npt.assert_allclose(c1.coefficients(), coeffs)

 def test_add(self):
     s = Chebfun.from_function(np.sin)
     c = Chebfun.from_function(np.cos)
     r = c + s
     def expected(x):
         return np.sin(x) + np.cos(x)
     tools.assert_close(r, expected)

 def test_diff_one(self):
     """
     Derivative of Chebfun(1) close to zero
     """
     one = Chebfun(1.)
     zero = one.differentiate()
     npt.assert_allclose(tools.Zero(tools.xs), 0.)

 def test_truncate(self, N=17):
     """
     Check that the Chebyshev coefficients are properly truncated.
     """
     small = Chebfun.from_function(tools.f, N=N)
     new = Chebfun.from_function(small)
     self.assertEqual(new.size(), small.size(),)

 def test_real_imag(self):
     datar = np.random.rand(10)
     datai = np.random.rand(10)
     cc = Chebfun.from_data(datar + 1j*datai)
     cr = Chebfun.from_data(datar)
     ci = Chebfun.from_data(datai)
     tools.assert_close(np.real(cc), cr)
     tools.assert_close(np.imag(cc), ci)

 def test_runge(self):
     """
     Test some of the capabilities of operator overloading.
     """
     r = Chebfun.from_function(runge)
     x = Chebfun.basis(1)
     rr = 1./(1+25*x**2)
     tools.assert_close(r, rr, rtol=1e-13)

 def test_scalarvectormult(self):
     """
     Possible to multiply scalar with vector chebfun.
     """
     v = Chebfun.from_function(segment)
     s = np.sin(Chebfun.identity())
     m = s * v
     tools.assert_close(m[0], s*v[0])

 def test_slice(self):
     """
     Test slicing: f[0] should return the first component.
     """
     s = Chebfun.from_function(segment)
     tools.assert_close(s[0], Chebfun.identity())
     tools.assert_close(s[1], Chebfun(0.))
     tools.assert_close(s[:], s)

def a(p, order):
    if p > 0:
        return Chebfun.from_function(lambda x: sqrt(2)* np.sin(p*x)/p,[0,pi])\
                      .differentiate(order)
    else:
        if order == 1:
            return Chebfun.from_function(lambda x: np.ones_like(x), [0, pi])
        else:
            return Chebfun.from_function(lambda x: np.zeros_like(x), [0, pi])

 def test_sum(self):
     """
     Integral of chebfun of x**2 on [-1,1] is 2/3
     """
     p = Chebfun.from_function(Quad)
     i = p.sum()
     npt.assert_array_almost_equal(i,2/3)

 def test_highdiff(self):
     """
     Higher order derivatives of exp(x)
     """
     e = Chebfun.from_function(lambda x:np.exp(x))
     e4 = e.differentiate(4)
     tools.assert_close(e4, e)

 def test_diffquad(self):
     """
     Derivative of Chebfun(x**2/2) is close to identity function
     """
     self.p = .5*Chebfun.from_function(Quad)
     X = self.p.differentiate()
     tools.assert_close(X, lambda x:x)

 def test_nonzero(self):
     """
     nonzero is True for Chebfun(f) and False for Chebfun(0)
     """
     self.assertTrue(self.p)
     mp = Chebfun.from_function(tools.Zero)
     self.assertFalse(mp)

 def test_basis(self, n=4):
     """
     Tn(cos(t)) = cos(nt)
     """
     Tn = Chebfun.basis(n)
     ts = np.linspace(0, 2*np.pi, 100)
     npt.assert_allclose(Tn(np.cos(ts)), np.cos(n*ts))