def test_plan():
assert devise_plan(Hyper_Function([0], ()),
Hyper_Function([0], ()), z) == []
with raises(ValueError):
devise_plan(Hyper_Function([1], ()), Hyper_Function((), ()), z)
with raises(ValueError):
devise_plan(Hyper_Function([2], [1]), Hyper_Function([2], [2]), z)
with raises(ValueError):
devise_plan(Hyper_Function([2], []), Hyper_Function([S("1/2")], []), z)
# We cannot use pi/(10000 + n) because polys is insanely slow.
a1, a2, b1 = (randcplx(n) for n in range(3))
b1 += 2*I
h = hyper([a1, a2], [b1], z)
h2 = hyper((a1 + 1, a2), [b1], z)
assert tn(apply_operators(h,
devise_plan(Hyper_Function((a1 + 1, a2), [b1]),
Hyper_Function((a1, a2), [b1]), z), op),
h2, z)
h2 = hyper((a1 + 1, a2 - 1), [b1], z)
assert tn(apply_operators(h,
devise_plan(Hyper_Function((a1 + 1, a2 - 1), [b1]),
Hyper_Function((a1, a2), [b1]), z), op),
h2, z)
def test_plan():
assert devise_plan(Hyper_Function([0], ()),
Hyper_Function([0], ()), z) == []
with raises(ValueError):
devise_plan(Hyper_Function([1], ()), Hyper_Function((), ()), z)
with raises(ValueError):
devise_plan(Hyper_Function([2], [1]), Hyper_Function([2], [2]), z)
with raises(ValueError):
devise_plan(Hyper_Function([2], []), Hyper_Function([S("1/2")], []), z)
# We cannot use pi/(10000 + n) because polys is insanely slow.
a1, a2, b1 = map(lambda n: randcplx(n), range(3))
b1 += 2*I
h = hyper([a1, a2], [b1], z)
h2 = hyper((a1 + 1, a2), [b1], z)
assert tn(apply_operators(h,
devise_plan(Hyper_Function((a1 + 1, a2), [b1]),
Hyper_Function((a1, a2), [b1]), z), op),
h2, z)
h2 = hyper((a1 + 1, a2 - 1), [b1], z)
assert tn(apply_operators(h,
devise_plan(Hyper_Function((a1 + 1, a2 - 1), [b1]),
Hyper_Function((a1, a2), [b1]), z), op),
h2, z)
def test_plan():
assert devise_plan(IndexPair([0], ()), IndexPair([0], ()), z) == []
raises(ValueError, 'devise_plan(IndexPair([1], ()), IndexPair((), ()), z)')
raises(ValueError,
'devise_plan(IndexPair([2], [1]), IndexPair([2], [2]), z)')
raises(KeyError,
'devise_plan(IndexPair([2], []), IndexPair([S("1/2")], []), z)')
# We cannot use pi/(10000 + n) because polys is insanely slow.
a1, a2, b1 = map(lambda n: randcplx(n), range(3))
b1 += 2 * I
h = hyper([a1, a2], [b1], z)
h2 = hyper((a1 + 1, a2), [b1], z)
assert tn(
apply_operators(
h,
devise_plan(IndexPair((a1 + 1, a2), [b1]), IndexPair(
(a1, a2), [b1]), z), op), h2, z)
h2 = hyper((a1 + 1, a2 - 1), [b1], z)
assert tn(
apply_operators(
h,
devise_plan(IndexPair((a1 + 1, a2 - 1), [b1]),
IndexPair((a1, a2), [b1]), z), op), h2, z)
def test_plan_derivatives():
a1, a2, a3 = 1, 2, S('1/2')
b1, b2 = 3, S('5/2')
h = Hyper_Function((a1, a2, a3), (b1, b2))
h2 = Hyper_Function((a1 + 1, a2 + 1, a3 + 2), (b1 + 1, b2 + 1))
ops = devise_plan(h2, h, z)
f = Formula(h, z, h(z), [])
deriv = make_derivative_operator(f.M, z)
assert tn((apply_operators(f.C, ops, deriv)*f.B)[0], h2(z), z)
h2 = Hyper_Function((a1, a2 - 1, a3 - 2), (b1 - 1, b2 - 1))
ops = devise_plan(h2, h, z)
assert tn((apply_operators(f.C, ops, deriv)*f.B)[0], h2(z), z)
def test_plan_derivatives():
a1, a2, a3 = 1, 2, S('1/2')
b1, b2 = 3, S('5/2')
h = Hyper_Function((a1, a2, a3), (b1, b2))
h2 = Hyper_Function((a1 + 1, a2 + 1, a3 + 2), (b1 + 1, b2 + 1))
ops = devise_plan(h2, h, z)
f = Formula(h, z, h(z), [])
deriv = make_derivative_operator(f.M, z)
assert tn((apply_operators(f.C, ops, deriv)*f.B)[0], h2(z), z)
h2 = Hyper_Function((a1, a2 - 1, a3 - 2), (b1 - 1, b2 - 1))
ops = devise_plan(h2, h, z)
assert tn((apply_operators(f.C, ops, deriv)*f.B)[0], h2(z), z)
def test_plan_derivatives():
a1, a2, a3 = 1, 2, S("1/2")
b1, b2 = 3, S("5/2")
h = hyper((a1, a2, a3), (b1, b2), z)
h2 = hyper((a1 + 1, a2 + 1, a3 + 2), (b1 + 1, b2 + 1), z)
ops = devise_plan(IndexPair((a1 + 1, a2 + 1, a3 + 2), (b1 + 1, b2 + 1)), IndexPair((a1, a2, a3), (b1, b2)), z)
f = Formula((a1, a2, a3), (b1, b2), z, h, [])
deriv = make_derivative_operator(f.M, z)
assert tn((apply_operators(f.C, ops, deriv) * f.B)[0], h2, z)
h2 = hyper((a1, a2 - 1, a3 - 2), (b1 - 1, b2 - 1), z)
ops = devise_plan(IndexPair((a1, a2 - 1, a3 - 2), (b1 - 1, b2 - 1)), IndexPair((a1, a2, a3), (b1, b2)), z)
assert tn((apply_operators(f.C, ops, deriv) * f.B)[0], h2, z)
def test_plan_derivatives():
a1, a2, a3 = 1, 2, S('1/2')
b1, b2 = 3, S('5/2')
h = hyper((a1, a2, a3), (b1, b2), z)
h2 = hyper((a1 + 1, a2 + 1, a3 + 2), (b1 + 1, b2 + 1), z)
ops = devise_plan(IndexPair((a1 + 1, a2 + 1, a3 + 2), (b1 + 1, b2 + 1)),
IndexPair((a1, a2, a3), (b1, b2)), z)
f = Formula((a1, a2, a3), (b1, b2), z, h, [])
deriv = make_derivative_operator(f.M, z)
assert tn((apply_operators(f.C, ops, deriv)*f.B)[0], h2, z)
h2 = hyper((a1, a2 - 1, a3 - 2), (b1 - 1, b2 - 1), z)
ops = devise_plan(IndexPair((a1, a2 - 1, a3 - 2), (b1 - 1, b2 - 1)),
IndexPair((a1, a2, a3), (b1, b2)), z)
assert tn((apply_operators(f.C, ops, deriv)*f.B)[0], h2, z)
def test_meijerg():
# carefully set up the parameters.
# NOTE: this used to fail sometimes. I believe it is fixed, but if you
# hit an inexplicable test failure here, please let me know the seed.
a1, a2 = map(lambda n: randcplx() - 5*I - n*I, range(2))
b1, b2 = map(lambda n: randcplx() + 5*I + n*I, range(2))
b3, b4, b5, a3, a4, a5 = map(lambda n: randcplx(), range(6))
g = meijerg([a1], [a3, a4], [b1], [b3, b4], z)
assert ReduceOrder.meijer_minus(3, 4) is None
assert ReduceOrder.meijer_plus(4, 3) is None
g2 = meijerg([a1, a2], [a3, a4], [b1], [b3, b4, a2], z)
assert tn(ReduceOrder.meijer_plus(a2, a2).apply(g, op), g2, z)
g2 = meijerg([a1, a2], [a3, a4], [b1], [b3, b4, a2 + 1], z)
assert tn(ReduceOrder.meijer_plus(a2, a2 + 1).apply(g, op), g2, z)
g2 = meijerg([a1, a2 - 1], [a3, a4], [b1], [b3, b4, a2 + 2], z)
assert tn(ReduceOrder.meijer_plus(a2 - 1, a2 + 2).apply(g, op), g2, z)
g2 = meijerg([a1], [a3, a4, b2 - 1], [b1, b2 + 2], [b3, b4], z)
assert tn(ReduceOrder.meijer_minus(b2 + 2, b2 - 1).apply(g, op), g2, z, tol=1e-6)
# test several-step reduction
an = [a1, a2]
bq = [b3, b4, a2 + 1]
ap = [a3, a4, b2 - 1]
bm = [b1, b2 + 1]
niq, ops = reduce_order_meijer(IndexQuadruple(an, ap, bm, bq))
assert niq.an == (a1,)
assert set(niq.ap) == set([a3, a4])
assert niq.bm == (b1,)
assert set(niq.bq) == set([b3, b4])
assert tn(apply_operators(g, ops, op), meijerg(an, ap, bm, bq, z), z)
def test_plan():
assert devise_plan(IndexPair([0], ()), IndexPair([0], ()), z) == []
raises(ValueError, "devise_plan(IndexPair([1], ()), IndexPair((), ()), z)")
raises(ValueError, "devise_plan(IndexPair([2], [1]), IndexPair([2], [2]), z)")
raises(KeyError, 'devise_plan(IndexPair([2], []), IndexPair([S("1/2")], []), z)')
# We cannot use pi/(10000 + n) because polys is insanely slow.
a1, a2, b1 = map(lambda n: randcplx(n), range(3))
b1 += 2 * I
h = hyper([a1, a2], [b1], z)
h2 = hyper((a1 + 1, a2), [b1], z)
assert tn(apply_operators(h, devise_plan(IndexPair((a1 + 1, a2), [b1]), IndexPair((a1, a2), [b1]), z), op), h2, z)
h2 = hyper((a1 + 1, a2 - 1), [b1], z)
assert tn(
apply_operators(h, devise_plan(IndexPair((a1 + 1, a2 - 1), [b1]), IndexPair((a1, a2), [b1]), z), op), h2, z
)
def test_plan():
assert devise_plan(IndexPair([0], ()), IndexPair([0], ()), z) == []
raises(ValueError, 'devise_plan(IndexPair([1], ()), IndexPair((), ()), z)')
raises(ValueError, 'devise_plan(IndexPair([2], [1]), IndexPair([2], [2]), z)')
raises(KeyError,
'devise_plan(IndexPair([2], []), IndexPair([S("1/2")], []), z)')
a1, a2, b1 = map(lambda _: randcplx(), range(3))
b1 += 2*I
h = hyper([a1], [b1], z)
h2 = hyper((a1 + 1, a2), [b1], z)
tn(apply_operators(h, devise_plan(IndexPair((a1 + 1, a2), [b1]),
IndexPair((a1, a2), [b1]), z), op),
h2, z)
h2 = hyper((a1 + 1, a2 - 1), [b1], z)
tn(apply_operators(h, devise_plan(IndexPair((a1 + 1, a2 - 1), [b1]),
IndexPair((a1, a2), [b1]), z), op),
h2, z)
def test_reduction_operators():
a1, a2, b1 = map(lambda n: randcplx(n), range(3))
h = hyper([a1], [b1], z)
assert ReduceOrder(2, 0) is None
assert ReduceOrder(2, -1) is None
assert ReduceOrder(1, S('1/2')) is None
h2 = hyper((a1, a2), (b1, a2), z)
assert tn(ReduceOrder(a2, a2).apply(h, op), h2, z)
h2 = hyper((a1, a2 + 1), (b1, a2), z)
assert tn(ReduceOrder(a2 + 1, a2).apply(h, op), h2, z)
h2 = hyper((a2 + 4, a1), (b1, a2), z)
assert tn(ReduceOrder(a2 + 4, a2).apply(h, op), h2, z)
# test several step order reduction
ap = (a2 + 4, a1, b1 + 1)
bq = (a2, b1, b1)
func, ops = reduce_order(Hyper_Function(ap, bq))
assert func.ap == (a1,)
assert func.bq == (b1,)
assert tn(apply_operators(h, ops, op), hyper(ap, bq, z), z)
def test_reduction_operators():
a1, a2, b1 = map(lambda n: randcplx(n), range(3))
h = hyper([a1], [b1], z)
assert ReduceOrder(2, 0) is None
assert ReduceOrder(2, -1) is None
assert ReduceOrder(1, S('1/2')) is None
h2 = hyper((a1, a2), (b1, a2), z)
assert tn(ReduceOrder(a2, a2).apply(h, op), h2, z)
h2 = hyper((a1, a2 + 1), (b1, a2), z)
assert tn(ReduceOrder(a2 + 1, a2).apply(h, op), h2, z)
h2 = hyper((a2 + 4, a1), (b1, a2), z)
assert tn(ReduceOrder(a2 + 4, a2).apply(h, op), h2, z)
# test several step order reduction
ap = (a2 + 4, a1, b1 + 1)
bq = (a2, b1, b1)
nip, ops = reduce_order(IndexPair(ap, bq))
assert nip.ap == (a1,)
assert nip.bq == (b1,)
assert tn(apply_operators(h, ops, op), hyper(ap, bq, z), z)
def test_reduction_operators():
a1, a2, b1 = (randcplx(n) for n in range(3))
h = hyper([a1], [b1], z)
assert ReduceOrder(2, 0) is None
assert ReduceOrder(2, -1) is None
assert ReduceOrder(1, S('1/2')) is None
h2 = hyper((a1, a2), (b1, a2), z)
assert tn(ReduceOrder(a2, a2).apply(h, op), h2, z)
h2 = hyper((a1, a2 + 1), (b1, a2), z)
assert tn(ReduceOrder(a2 + 1, a2).apply(h, op), h2, z)
h2 = hyper((a2 + 4, a1), (b1, a2), z)
assert tn(ReduceOrder(a2 + 4, a2).apply(h, op), h2, z)
# test several step order reduction
ap = (a2 + 4, a1, b1 + 1)
bq = (a2, b1, b1)
func, ops = reduce_order(Hyper_Function(ap, bq))
assert func.ap == (a1,)
assert func.bq == (b1,)
assert tn(apply_operators(h, ops, op), hyper(ap, bq, z), z)
