def test_powers_differing_by_unity_induce_sum(self):
norm = self.normalizer
c = 0.5
for mon in [Polynomial.Monomial((1, 2, 3, 4, 5, 6)),
Polynomial.Monomial((1, 2, 1, 2, 1, 2)),
Polynomial.Monomial((0, 1, 0, 1, 0, 1))]:
rem = Polynomial(6)
rem += c*mon
gen = norm.solve_homological_eqn(rem)
coeff = -c/sum(self.freqs)
expected = Polynomial(6)+coeff*mon
self.assert_((gen - expected).l1_norm() < 1.0e-15, (gen, expected))
def _ith_term(self, i):
if i > 0:
sign = 1 - (i % 2) * 2
powers = [
0,
] * self.n_vars
powers[self.index] = i
m = Polynomial.Monomial(tuple(powers))
return self._ith_coeff(i) * m
else:
return Polynomial(self.n_vars)
def test_equal_powers_raises_zero_division_error(self):
"""Equal powers on any canonically-conjugate pair should at
the very least raise a zero-division error."""
rem = 0.5*Polynomial.Monomial((1, 1, 0, 0, 0, 0))
try:
gen = self.normalizer.solve_homological_eqn(rem)
except ZeroDivisionError:
pass
else:
assert 0, 'equal powers in homological equation should raise'
def test_diagonal_part(self):
dof = 3
terms = {
Powers((2, 2, 0, 0, 0, 0)): -0.3,
Powers((1, 1, 0, 0, 0, 0)): 0.33,
Powers((0, 0, 3, 3, 0, 0)): 7.2,
Powers((0, 0, 0, 0, 1, 1)): 7.12
}
g = Polynomial(2 * dof, terms=terms)
alg = LieAlgebra(dof)
self.assert_(alg.diagonal_part_of_polynomial(g) == g)
h = 0.54 * Polynomial.Monomial((2, 0, 1, 0, 0, 0))
g += h
self.assert_(alg.diagonal_part_of_polynomial(g) + h == g)
def _ith_term(self, i):
if i % 2:
powers = [
0,
] * self.n_vars
powers[self.index] = i
if i % 4 == 3:
sign = -1
else:
sign = 1
return (float(sign) / float(factorial(i))) * Polynomial.Monomial(
tuple(powers))
else:
return Polynomial(self.n_vars)
def read_ascii_polynomial(istream, is_xxpp_format, order=None):
"""
Read a polynomial from an input stream in ASCII format.
@param istream: an iterable of input lines (e.g. file-like),
@param is_xxpp_format: a boolean to specify whether the input file
is in the old (Mathematica) format where all configuration
coordinates come first, following by all the momenta, rather than
the new even-odd format.
@param order: reorder the degrees of freedom on the fly
@return: polynomial.
Note: this needs to be refactored; the xxpp logic belongs in a
lie algebra of one sort or another.
"""
line = istream.next()
n_vars = int(line)
assert n_vars >= 0
line = istream.next()
n_monomials = int(line)
assert n_monomials >= 0
p = Polynomial(n_vars)
for i in xrange(n_monomials):
line = istream.next()
elts = line.split(' ')
elts = elts[:n_vars] + [' '.join(elts[n_vars:])]
assert len(elts) == n_vars + 1
powers_list = [int(e) for e in elts[:-1]]
if is_xxpp_format:
powers_list = xxpp_to_xpxp(powers_list)
if order != None:
powers_list = reorder_dof(powers_list, order)
powers = tuple(powers_list)
coeff = complex(elts[-1])
m = coeff * Polynomial.Monomial(powers)
assert not p.has_term(Powers(powers))
p += m
return p
def test_example(self):
ring = PolynomialRing(3)
p0 = Polynomial(3)
p0 += Polynomial.Monomial((0,0,0))
assert ring.grade(p0) == 0
p1 = Polynomial(3)
p1 += Polynomial.Monomial((0,1,0))
p1 += Polynomial.Monomial((0,0,1))
assert ring.grade(p1) == 1
p2 = Polynomial(3)
p2 += Polynomial.Monomial((0,2,0))
p2 += Polynomial.Monomial((0,1,1))
p2 += Polynomial.Monomial((1,0,1))
assert ring.grade(p2) == 2
p3 = Polynomial(3)
p3 += Polynomial.Monomial((3,0,0))
p3 += Polynomial.Monomial((0,1,2))
assert ring.grade(p3) == 3
iso = IsogradeInnerTaylorCoeffs(ring, 0)
p_sum = iso.list_to_poly([1*p0, 1*p1, 2*p2, 6*p3])
self.assert_(ring.isograde(p_sum, 0) == p0)
self.assert_(ring.isograde(p_sum, 1) == p1)
self.assert_(ring.isograde(p_sum, 2) == p2)
self.assert_(ring.isograde(p_sum, 3) == p3)
def _read_dense_sexp_polynomial(self, istream, n_vars, n_monomials):
"""
Read a polynomial in the dense powers format, where each
monomial is listed as n_vars integers representing
non-negative powers, followed by a coefficient.
"""
p = self.ring.zero()
for i in xrange(n_monomials):
line = istream.next()
sinner = SExprIO.strip_braces(line)
elts = SExprIO.elts(sinner)
spowers = SExprIO.strip_braces(' '.join(elts[:n_vars]))
scoeff = SExprIO.strip_braces(''.join(elts[n_vars:]))+'j'
epowers = SExprIO.elts(spowers)
assert len(epowers) == n_vars
powers = tuple([int(e) for e in epowers])
coeff = complex(scoeff)
m = coeff*Polynomial.Monomial(powers)
assert not p.has_term(Powers(powers))
p += m
return p
def coordinate_monomial(self, i, pow=1):
pows = [
0,
] * self.n_vars()
pows[i] = pow
return Polynomial.Monomial(tuple(pows))
def monomial(self, powers, coeff=1.0):
assert len(powers) == self.n_vars()
return Polynomial.Monomial(powers, coeff)
