def test_det(self):
m = self.make_random([[1., 0.1], [0.1, 2.]])
detm = linalg.det(m)
self.assertTrue(gv.equivalent(detm, m[0,0] * m[1,1] - m[0,1] * m[1,0]))
m = self.make_random([[1.0,2.,3.],[0,4,5], [0,0,6]])
self.assertTrue(gv.equivalent(linalg.det(m), m[0, 0] * m[1, 1] * m[2, 2]))
s, logdet = linalg.slogdet(m)
self.assertTrue(gv.equivalent(s * gv.exp(logdet), linalg.det(m)))
def test_solve(self):
m = self.make_random([[1., 0.1], [0.2, 2.]])
b = self.make_random([3., 4.])
x = linalg.solve(m, b)
self.assertTrue(gv.equivalent(m.dot(x), b))
m = self.make_random([[1., 0.1], [0.2, 2.]])
b = self.make_random([[3., 1., 0.], [4., 2., 1.]])
x = linalg.solve(m, b)
self.assertTrue(gv.equivalent(m.dot(x), b))
def test_solve(self):
m = self.make_random([[1., 0.1], [0.2, 2.]])
b = self.make_random([3., 4.])
x = linalg.solve(m, b)
self.assertTrue(gv.equivalent(m.dot(x), b))
m = self.make_random([[1., 0.1], [0.2, 2.]])
b = self.make_random([[3., 1., 0.], [4., 2., 1.]])
x = linalg.solve(m, b)
self.assertTrue(gv.equivalent(m.dot(x), b))
def test_copy(self):
global b,bkeys,bvalues,bslices,bbuf
b = gv.BufferDict(b, buf=b.buf * gv.gvar('2(1)'))
c = copy.copy(b)
self.assertTrue(gv.equivalent(b, c))
c['vector'] *= -1
self.assertEqual(c['vector'].tolist(), (-b['vector']).tolist())
c = copy.deepcopy(b)
self.assertTrue(gv.equivalent(b, c))
c['vector'] *= -1
self.assertEqual(c['vector'].tolist(), (-b['vector']).tolist())
def test_eigvalsh(self):
" linalg.eigvalsh(a) "
# just eigenvalues
m = gv.gvar([['2.1(1)', '0(0)'], ['0(0)', '0.5(3)']])
th = 0.92
cth = numpy.cos(th)
sth = numpy.sin(th)
u = numpy.array([[cth, sth], [-sth, cth]])
mrot = u.T.dot(m.dot(u))
val = linalg.eigvalsh(mrot)
self.assertTrue(gv.equivalent(val[0], m[1, 1]))
self.assertTrue(gv.equivalent(val[1], m[0, 0]))
def test_eigvalsh(self):
m = gv.gvar([['2.1(1)', '0(0)'], ['0(0)', '0.5(3)']])
th = 0.92
cth = numpy.cos(th)
sth = numpy.sin(th)
u = numpy.array([[cth, sth], [-sth, cth]])
mrot = u.T.dot(m.dot(u))
val = linalg.eigvalsh(mrot)
self.assertTrue(gv.equivalent(val[0], m[1, 1]))
self.assertTrue(gv.equivalent(val[1], m[0, 0]))
val, vec = linalg.eigvalsh(mrot, eigvec=True)
np.testing.assert_allclose(
gv.mean(mrot).dot(vec[:, 0]), val[0].mean * vec[:, 0])
np.testing.assert_allclose(
gv.mean(mrot).dot(vec[:, 1]), val[1].mean * vec[:, 1])
def test_integral_gvar(self):
def f(x, a=gvar(1, 1)):
return a * 3 * x**2
ans = ode.integral(f, (1, 2), tol=1e-10)
self.assertAlmostEqual(ans.mean, 7)
self.assertAlmostEqual(ans.sdev, 7)
a = gvar(1, 1)
def f(x, a=a):
return a * numpy.array([[1.], [2 * x], [3 * x**2]])
ans = ode.integral(f, (1, 2))
self.assert_arraysclose(mean(ans), [[1], [3], [7]])
self.assert_arraysclose(sdev(ans), [[1], [3], [7]])
def f(x, a=a):
return dict(a=a, b=[2 * a * x, 3 * a * x**2])
ans = ode.integral(f, (1, 2))
self.assertAlmostEqual(ans['a'].mean, 1.)
self.assert_arraysclose(mean(ans['b']), [3, 7])
self.assertAlmostEqual(ans['a'].sdev, 1.)
self.assert_arraysclose(sdev(ans['b']), [3, 7])
self.assertTrue(
gv.equivalent(ans,
dict(a=a, b=[3 * a, 7 * a]),
rtol=1e-6,
atol=1e-6))
def test_eigvalsh(self):
m = gv.gvar([['2.1(1)', '0(0)'], ['0(0)', '0.5(3)']])
th = 0.92
cth = numpy.cos(th)
sth = numpy.sin(th)
u = numpy.array([[cth, sth], [-sth, cth]])
mrot = u.T.dot(m.dot(u))
val = linalg.eigvalsh(mrot)
self.assertTrue(gv.equivalent(val[0], m[1, 1]))
self.assertTrue(gv.equivalent(val[1], m[0, 0]))
val, vec = linalg.eigvalsh(mrot, eigvec=True)
np.testing.assert_allclose(
gv.mean(mrot).dot(vec[:, 0]), val[0].mean * vec[:, 0]
)
np.testing.assert_allclose(
gv.mean(mrot).dot(vec[:, 1]), val[1].mean * vec[:, 1]
)
def test_eigh(self):
" linalg.eigh(a) "
m = gv.gvar([['2.0000001(1)', '0(0)', '0(0)'],
['0(0)', '2.0(3)', '0(0)'], ['0(0)', '0(0)', '5.0(2)']])
th = 0.92
cth = numpy.cos(th) * gv.gvar('1.0(1)')
sth = numpy.sin(th) * gv.gvar('1.0(1)')
u = numpy.array([[cth, sth], [-sth, cth]])
mrot = np.array(m)
mrot[:2, :2] = u.T.dot(m[:2, :2].dot(u))
mrot[-2:, -2:] = u.T.dot(mrot[-2:, -2:].dot(u))
val, vec = linalg.eigh(mrot)
self.assertTrue(gv.equivalent(mrot.dot(vec[:, 0]), val[0] * vec[:, 0]))
self.assertTrue(gv.equivalent(mrot.dot(vec[:, 1]), val[1] * vec[:, 1]))
# test against numpy
valnp, vecnp = np.linalg.eigh(gv.mean(mrot))
np.testing.assert_allclose(valnp, gv.mean(val))
np.testing.assert_allclose(vecnp, gv.mean(vec))
def test_gvar_scalar(self):
# exponential with errors
gam = gv.gvar('1.0(1)')
def f(x, y):
return gam * y
odeint = ode.Integrator(deriv=f, h=1, tol=1e-10)
y0 = gv.gvar('1.0(1)')
y1 = odeint(y0, (0, 2))
exact = y0 * np.exp(gam * 2)
self.assertAlmostEqual((y1 / exact).mean, 1.)
self.assertGreater(1e-8, (y1 / exact).sdev)
self.assertTrue(
gv.equivalent(odeint(y1, (2, 0)), y0, rtol=1e-6, atol=1e-6)
)
def test_inv(self):
m = self.make_random([[1., 0.1], [0.1, 2.]])
one = gv.gvar([['1(0)', '0(0)'], ['0(0)', '1(0)']])
invm = linalg.inv(m)
self.assertTrue(gv.equivalent(linalg.inv(invm), m))
for mm in [invm.dot(m), m.dot(invm)]:
np.testing.assert_allclose(gv.mean(mm), [[1, 0], [0, 1]],
rtol=1e-10,
atol=1e-10)
np.testing.assert_allclose(gv.sdev(mm), [[0, 0], [0, 0]],
rtol=1e-10,
atol=1e-10)
p = linalg.det(m) * linalg.det(invm)
self.assertAlmostEqual(p.mean, 1.)
self.assertGreater(1e-10, p.sdev)
def test_inv(self):
m = self.make_random([[1., 0.1], [0.1, 2.]])
one = gv.gvar([['1(0)', '0(0)'], ['0(0)', '1(0)']])
invm = linalg.inv(m)
self.assertTrue(gv.equivalent(linalg.inv(invm), m))
for mm in [invm.dot(m), m.dot(invm)]:
np.testing.assert_allclose(
gv.mean(mm), [[1, 0], [0, 1]], rtol=1e-10, atol=1e-10
)
np.testing.assert_allclose(
gv.sdev(mm), [[0, 0], [0, 0]], rtol=1e-10, atol=1e-10
)
p = linalg.det(m) * linalg.det(invm)
self.assertAlmostEqual(p.mean, 1.)
self.assertGreater(1e-10, p.sdev)
def test_svd(self):
" linalg.svd(a) "
def reassemble(u, s, vT):
ans = 0
for i in range(len(s)):
ans += u[:, i][:, None] * s[i] * vT[i, :][None, :]
return ans
aa = np.array([[1., 2., 3.], [2.5, 4., 5.], [3., 5., 6.]])
aa = self.make_random(aa)
for a in [aa, aa[:, :2], aa[:2, :], aa[:, :1], aa[:1, :]]:
u, s, vT = linalg.svd(a)
self.assertTrue(gv.equivalent(reassemble(u, s, vT), a))
# test against numpy
unp, snp, vTnp = np.linalg.svd(gv.mean(a), full_matrices=False)
np.testing.assert_allclose(unp, gv.mean(u))
np.testing.assert_allclose(vTnp, gv.mean(vT))
np.testing.assert_allclose(snp, gv.mean(s))
def test_gvar_dict(self):
# harmonic oscillator with dictionaries and errors
w2 = gv.gvar('1.00(2)')
w = w2 ** 0.5
def f(x, y):
deriv = {}
deriv['y'] = y['dydx']
deriv['dydx'] = -w2 * y['y']
return deriv
odeint = ode.DictIntegrator(deriv=f, h=1, tol=1e-10)
x0 = 0
y0 = dict(y=numpy.sin(w*x0), dydx=w * numpy.cos(w*x0))
x1 = 10
y1 = odeint(y0, (x0,x1))
exact = dict(y=numpy.sin(w * x1), dydx=w * numpy.cos(w * x1))
self.assert_gvclose(y1, exact)
self.assertTrue(
gv.equivalent(odeint(y1, (x1, x0)), y0, rtol=1e-6, atol=1e-6)
)
def test_integral_gvar(self):
def f(x, a=gvar(1,1)):
return a * 3 * x**2
ans = ode.integral(f, (1,2), tol=1e-10)
self.assertAlmostEqual(ans.mean, 7)
self.assertAlmostEqual(ans.sdev, 7)
a = gvar(1, 1)
def f(x, a=a):
return a * numpy.array([[1.], [2 * x], [3 * x**2]])
ans = ode.integral(f, (1, 2))
self.assert_arraysclose(mean(ans), [[1], [3], [7]])
self.assert_arraysclose(sdev(ans), [[1], [3], [7]])
def f(x, a=a):
return dict(a=a, b=[2 * a * x, 3 * a * x**2])
ans = ode.integral(f, (1, 2))
self.assertAlmostEqual(ans['a'].mean, 1.)
self.assert_arraysclose(mean(ans['b']), [3, 7])
self.assertAlmostEqual(ans['a'].sdev, 1.)
self.assert_arraysclose(sdev(ans['b']), [3, 7])
self.assertTrue(gv.equivalent(
ans,
dict(a=a, b=[3 * a, 7 * a]),
rtol=1e-6, atol=1e-6)
)
