def fixedlenTester(fun, subinterval, n):
ff = Bndfun.initfun_fixedlen(fun, subinterval, n)
def tester(self):
self.assertEquals(ff.size, n)
return tester
def test_simplify(self):
interval = Interval(-2, 1)
ff = Bndfun.initfun_fixedlen(self.f, interval, 1000)
gg = ff.simplify()
self.assertEqual(gg.size, standard_chop(ff.onefun.coeffs))
self.assertEqual(infnorm(ff.coeffs[:gg.size] - gg.coeffs), 0)
self.assertEqual(ff.interval, gg.interval)
def test_simplify(self):
interval = Interval(-2,1)
ff = Bndfun.initfun_fixedlen(self.f, interval, 1000)
gg = ff.simplify()
self.assertEqual(gg.size, standard_chop(ff.onefun.coeffs))
self.assertEqual(infnorm(ff.coeffs[:gg.size]-gg.coeffs), 0)
self.assertEqual(ff.interval, gg.interval)
def setUp(self):
f = lambda x: sin(1 * x) + 5e-1 * cos(10 * x) + 5e-3 * sin(100 * x)
u = lambda x: np.exp(2 * np.pi * 1j * x)
subinterval = Interval(-6, 10)
self.f0 = Bndfun.initfun_fixedlen(f, subinterval, 1000)
self.f1 = Bndfun.initfun_adaptive(f, subinterval)
self.f2 = Bndfun.initfun_adaptive(u, Interval(-1, 1))
def derivativeTester(fun, ifn, interval, tol):
subinterval = Interval(*interval)
ff = Bndfun.initfun_adaptive(fun, subinterval)
gg = Bndfun.initfun_fixedlen(ifn, subinterval, max(ff.size-1,1))
def tester(self):
absdiff = infnorm(ff.diff().coeffs - gg.coeffs)
self.assertLessEqual(absdiff, tol)
return tester
def derivativeTester(fun, ifn, interval, tol):
subinterval = Interval(*interval)
ff = Bndfun.initfun_adaptive(fun, subinterval)
gg = Bndfun.initfun_fixedlen(ifn, subinterval, max(ff.size-1,1))
def tester(self):
absdiff = infnorm(ff.diff().coeffs - gg.coeffs)
self.assertLessEqual(absdiff, tol)
return tester
def indefiniteIntegralTester(fun, ifn, interval, tol):
subinterval = Interval(*interval)
ff = Bndfun.initfun_adaptive(fun, subinterval)
gg = Bndfun.initfun_fixedlen(ifn, subinterval, ff.size+1)
coeffs = gg.coeffs
coeffs[0] = coeffs[0] - ifn(array([interval[0]]))
def tester(self):
absdiff = infnorm(ff.cumsum().coeffs - coeffs)
self.assertLessEqual(absdiff, tol)
return tester
def test_translate(self):
c = -1
shifted_interval = self.ff.interval + c
gg = self.ff.translate(c)
hh = Bndfun.initfun_fixedlen(lambda x: self.ff(x - c),
shifted_interval, gg.size)
yk = shifted_interval(np.linspace(-1, 1, 100))
self.assertEqual(gg.interval, hh.interval)
self.assertLessEqual(infnorm(gg.coeffs - hh.coeffs), 2e1 * eps)
self.assertLessEqual(infnorm(gg(yk) - hh(yk)), 1e2 * eps)
def indefiniteIntegralTester(fun, ifn, interval, tol):
subinterval = Interval(*interval)
ff = Bndfun.initfun_adaptive(fun, subinterval)
gg = Bndfun.initfun_fixedlen(ifn, subinterval, ff.size+1)
coeffs = gg.coeffs
coeffs[0] = coeffs[0] - ifn(np.array([interval[0]]))
def tester(self):
absdiff = infnorm(ff.cumsum().coeffs - coeffs)
self.assertLessEqual(absdiff, tol)
return tester
def initfun_fixedlen(cls, f, n, domain=None):
nn = np.array(n)
if nn.size < 2:
funs = generate_funs(domain, Bndfun.initfun_fixedlen, {
'f': f,
'n': n
})
else:
domain = Domain(domain if domain is not None else prefs.domain)
if not nn.size == domain.size - 1: raise BadFunLengthArgument
funs = []
for interval, length in zip(domain.intervals, nn):
funs.append(Bndfun.initfun_fixedlen(f, interval, length))
return cls(funs)
def initfun_fixedlen(cls, f, n, domain=DefaultPrefs.domain):
domain = np.array(domain)
nn = np.array(n)
if nn.size == 1:
nn = nn * np.ones(domain.size - 1)
elif nn.size > 1:
if nn.size != domain.size - 1:
raise BadFunLengthArgument
if domain.size < 2:
raise BadDomainArgument
funs = np.array([])
intervals = zip(domain[:-1], domain[1:])
for interval, length in zip(intervals, nn):
interval = Interval(*interval)
fun = Bndfun.initfun_fixedlen(f, interval, length)
funs = np.append(funs, fun)
return cls(funs)
def initfun_fixedlen(cls, f, n, domain=DefaultPrefs.domain):
domain = np.array(domain)
nn = np.array(n)
if nn.size == 1:
nn = nn * np.ones(domain.size-1)
elif nn.size > 1:
if nn.size != domain.size - 1:
raise BadFunLengthArgument
if domain.size < 2:
raise BadDomainArgument
funs = np.array([])
intervals = zip(domain[:-1], domain[1:])
for interval, length in zip(intervals, nn):
interval = Interval(*interval)
fun = Bndfun.initfun_fixedlen(f, interval, length)
funs = np.append(funs, fun)
return cls(funs)
def setUp(self):
f = lambda x: sin(1 * x) + 5e-1 * cos(10 * x) + 5e-3 * sin(100 * x)
subinterval = Interval(-6, 10)
self.f0 = Bndfun.initfun_fixedlen(f, subinterval, 1000)
self.f1 = Bndfun.initfun_adaptive(f, subinterval)
def fixedlenTester(fun, subinterval, n):
ff = Bndfun.initfun_fixedlen(fun, subinterval, n)
def tester(self):
self.assertEquals(ff.size, n)
return tester
def setUp(self):
f = lambda x: sin(1*x) + 5e-1*cos(10*x) + 5e-3*sin(100*x)
subinterval = Interval(-6, 10)
self.f0 = Bndfun.initfun_fixedlen(f, subinterval, 1000)
self.f1 = Bndfun.initfun_adaptive(f, subinterval)
