def test_modified(self):
a = exponential
c = modified_equation(a)
n = 10
self.assertEqual(c(empty_tree), 0)
computed = list(c(tree) for tree in islice(tree_generator(), 0, n))
expected = [1] + [0] * (n - 1)
self.assertEqual(computed, expected)
def test_memoization(self):
"""
Performing a split has an influence on
the modified equation computation?
"""
tmp = UnorderedTree(Forest([leaf]))
t = UnorderedTree(Forest([tmp, leaf]))
split(t)
a = exponential
c = modified_equation(a)
c
def test_avf(self):
max_order = 5
a = AVF
b = modified_equation(a)
result1 = convergence_order(a)
self.assertEqual(2, result1)
result2 = symplectic_up_to_order(a)
self.assertEqual(2, result2)
result3 = conjugate_to_symplectic(a)
self.assertEqual(4, result3)
result4 = symmetric_up_to_order(a, max_order)
self.assertEqual(max_order, result4)
result5 = energy_preserving_upto_order(b, max_order)
self.assertEqual(max_order, result5) # = energy preserving
def test_exp_explicit_euler(self):
a = RKeuler.phi()
alpha_1 = log(a)
a_1 = exp(alpha_1)
result = equal_up_to_order(a, a_1, self.max_order)
self.assertEqual(self.max_order, result)
alpha_2 = modified_equation(a)
result = equal_up_to_order(alpha_1, alpha_2, self.max_order)
self.assertEqual(self.max_order, result)
a_2 = exp(alpha_2)
result = equal_up_to_order(a, a_2, self.max_order)
self.assertEqual(self.max_order, result)
def conjugate_to_symplectic(a, max_order=float("inf"),
quadratic_vectorfield=False):
'''Checks to what order a character ``a`` is conjugate to symplectic.
'''
conv_order = convergence_order(a) # Known minimum.
# Methods of order 2 are always conjugate to symplectic up to order 3:
first_order_checked = conv_order + 1 + (conv_order == 2)
max_order = min(max_order, 2*conv_order)
orders = range(first_order_checked, max_order+1)
_alpha = modified_equation(a, quadratic_vectorfield)
def alpha(u, v):
return _alpha(u.butcher_product(v)) - _alpha(v.butcher_product(u))
for order in orders:
if symmetric_up_to_order(a, order) == order and order % 2 == 0:
continue
A = conjugate_symplecticity_matrix(order)
b = np.asarray(
[alpha(u, v) for u, v in tree_pairs_of_order(order, sort=True)],
dtype=np.float64)
if not_in_colspan(A, b):
return order - 1
return max_order
def test_RKcashKarp(self):
a = RKcashKarp.phi()
b = modified_equation(a)
result = energy_preserving_upto_order(b)
self.assertEqual(5, result) # = order
def test_RKlobattoIIIB4(self):
a = RKlobattoIIIB4.phi()
b = modified_equation(a)
result = energy_preserving_upto_order(b)
self.assertEqual(4, result) # = order
def test_rk38(self):
a = RK38rule.phi()
b = modified_equation(a)
result = energy_preserving_upto_order(b)
self.assertEqual(4, result) # = order
def test_runge2(self):
a = RKrunge2.phi()
b = modified_equation(a)
result = energy_preserving_upto_order(b)
self.assertEqual(2, result) # = order
def test_implicit_trapezoidal(self):
a = RKimplicitTrapezoidal.phi()
b = modified_equation(a)
result = energy_preserving_upto_order(b)
self.assertEqual(2, result) # = order
def test_implicit_midpoint(self):
a = RKimplicitMidpoint.phi()
b = modified_equation(a)
result = energy_preserving_upto_order(b)
self.assertEqual(2, result) # = order
def test_implicit_euler(self):
a = RKimplicitEuler.phi()
b = modified_equation(a)
result = energy_preserving_upto_order(b)
self.assertEqual(1, result) # = order
def test_exact(self):
max_order = 5
a = exponential
b = modified_equation(a)
result = energy_preserving_upto_order(b, max_order)
self.assertEqual(max_order, result)
def test(self):
modified = modified_equation(exponential)
result = equal_up_to_order(modified, unit_field, 8)
self.assertEqual(8, result)
def test_hamiltonian(self):
max_order = 7
euler = RKeuler.phi()
self.assertEqual(
hamiltonian_up_to_order(modified_equation(euler), max_order),
1) # ==order
self.assertEqual(
subspace_hamiltonian_up_to_order(modified_equation(euler),
max_order), 1) # ==order
impl_euler = RKimplicitEuler.phi()
self.assertEqual(
hamiltonian_up_to_order(modified_equation(impl_euler), max_order),
1) # ==order
self.assertEqual(
subspace_hamiltonian_up_to_order(modified_equation(impl_euler),
max_order), 1) # ==order
midpoint = RKmidpoint.phi()
self.assertEqual(
hamiltonian_up_to_order(modified_equation(midpoint), max_order),
2) # ==order
self.assertEqual(
subspace_hamiltonian_up_to_order(modified_equation(midpoint),
max_order), 2) # ==order
impl_midpoint = RKimplicitMidpoint.phi()
self.assertEqual(
hamiltonian_up_to_order(modified_equation(impl_midpoint),
max_order), max_order)
# hamiltonian
self.assertEqual(
subspace_hamiltonian_up_to_order(modified_equation(impl_midpoint),
max_order), max_order)
# hamiltonian
impl_trap = RKimplicitTrapezoidal.phi()
self.assertEqual(
hamiltonian_up_to_order(modified_equation(impl_trap), max_order),
2) # ==order
self.assertEqual(
subspace_hamiltonian_up_to_order(modified_equation(impl_trap),
max_order), 2) # ==order
runge2 = RKrunge2.phi()
self.assertEqual(
hamiltonian_up_to_order(modified_equation(runge2), max_order),
2) # ==order
self.assertEqual(
subspace_hamiltonian_up_to_order(modified_equation(runge2),
max_order), 2) # ==order
runge1 = RKrunge1.phi()
self.assertEqual(
hamiltonian_up_to_order(modified_equation(runge1), max_order),
3) # ==order
self.assertEqual(
subspace_hamiltonian_up_to_order(modified_equation(runge1),
max_order), 3) # ==order
rk4 = RK4.phi()
self.assertEqual(
hamiltonian_up_to_order(modified_equation(rk4), max_order),
4) # ==order
self.assertEqual(
subspace_hamiltonian_up_to_order(modified_equation(rk4),
max_order), 4) # ==order
rk38 = RK38rule.phi()
self.assertEqual(
hamiltonian_up_to_order(modified_equation(rk38), max_order),
4) # ==order
self.assertEqual(
subspace_hamiltonian_up_to_order(modified_equation(rk38),
max_order), 4) # ==order
lobattoIIIA4 = RKlobattoIIIA4.phi()
self.assertEqual(
hamiltonian_up_to_order(modified_equation(lobattoIIIA4),
max_order), 4) # ==order
self.assertEqual(
subspace_hamiltonian_up_to_order(modified_equation(lobattoIIIA4),
max_order), 4) # ==order
lobattoIIIB4 = RKlobattoIIIB4.phi()
self.assertEqual(
hamiltonian_up_to_order(modified_equation(lobattoIIIB4),
max_order), 4) # ==order
self.assertEqual(
subspace_hamiltonian_up_to_order(modified_equation(lobattoIIIB4),
max_order), 4) # ==order
cashKarp = RKcashKarp.phi()
self.assertEqual(
hamiltonian_up_to_order(modified_equation(cashKarp), max_order),
5) # ==order
self.assertEqual(
subspace_hamiltonian_up_to_order(modified_equation(cashKarp),
max_order), 5) # ==order
# exponential
self.assertEqual(
hamiltonian_up_to_order(modified_equation(exponential), max_order),
max_order)
# hamiltonian
self.assertEqual(
subspace_hamiltonian_up_to_order(modified_equation(exponential),
max_order), max_order)
# hamiltonian
runge1 = RKrunge1.phi()
self.assertEqual(
hamiltonian_up_to_order(modified_equation(runge1), max_order),
3) # == order + 1
self.assertEqual(
subspace_hamiltonian_up_to_order(modified_equation(runge1),
max_order), 3) # == order + 1