def test_diff_pow0(self):
for eg in self.examples:
p = SparsePowers(eg)
for var in xrange(len(eg)):
coeff0, q0 = p.diff_pow(var, 0)
self.assertEquals(coeff0, 1.0)
self.assertEquals(q0, p)
def test_mul(self):
lengths = 50
cases = 20
bits = 25
max_val = int((1<<bits)-1)/2
for length in xrange(lengths):
for case in xrange(cases):
pt = rand_int_tuple(length, max_val)
p = SparsePowers(pt)
qt = rand_int_tuple(length, max_val)
q = SparsePowers(qt)
rt = tuple([a+b for a,b in zip(pt, qt)])
r = SparsePowers(rt)
self.assertEquals(p*q, r)
z = SparsePowers((0,)*length)
self.assertEquals(p*z, p)
self.assertEquals(q*z, q)
self.assertEquals(z*p, p)
self.assertEquals(z*q, q)
d = {}
for i, po in enumerate(rt):
if po > 0:
d[i] = po
self.assertEquals(repr(p*q),
'SparsePowers(%d, %s)'%(length,
repr(d)))
def test_to_tuple(self):
for i in xrange(50):
t = rand_int_tuple(40, 14)
m = SparsePowers(t)
tt = m.to_tuple()
self.assert_(type(tt) == tuple)
self.assert_(t == tt)
def test_call_all_zero(self):
for eg in self.examples:
p = SparsePowers(eg)
zero = (0.0,)*len(eg)
if p.degree()==0:
self.assertEquals(p(zero), 1.0)
else:
self.assertEquals(p(zero), 0.0)
def test_diff_pow_coeff(self):
m = SparsePowers()
for i in xrange(10):
c, d = m.diff_pow(0, i)
if i == 0:
self.assertEquals(c, 1)
else:
self.assertEquals(c, 0)
def test_diff_pow1(self):
for eg in self.examples:
p = SparsePowers(eg)
for var in xrange(len(eg)):
coeff, q = p.diff(var)
coeff1, q1 = p.diff_pow(var, 1)
self.assertEquals(coeff1, coeff)
self.assertEquals(q1, q)
def test_call_wrong_len(self):
for eg in self.examples:
p = SparsePowers(eg)
for l in xrange(0, len(eg)*2):
x = rand_int_tuple(l, 10)
if not l==len(eg):
self.assertRaises(IndexError, p.__call__, x)
def test_dict(self):
t = (1, 2, 3)
p = SparsePowers(t)
d = {}
d[p] = -99.0
self.assert_(d.has_key(p))
self.assert_(d[p] == -99.0)
def test_diff(self):
for eg in self.examples:
p = SparsePowers(eg)
for var in xrange(len(eg)):
coeff, q = p.diff(var)
self.assertEquals(coeff, eg[var])
msg = ('d(%d)[%s]'%(var, repr(eg)))+' -> '+repr(q)
for j in xrange(len(eg)):
if j==var:
if eg[j]==0:
self.assertEquals(coeff, 0.0, msg)
else:
self.assertEquals(q[j], eg[j]-1, msg)
self.assertEquals(coeff, eg[j], msg)
else:
if eg[var] != 0:
self.assertEquals(q[j], eg[j], msg)
def test_repr(self):
for eg in self.examples:
p = SparsePowers(eg)
d = {}
for i, po in enumerate(eg):
if po > 0:
d[i] = po
self.assertEquals(repr(p), 'SparsePowers(%d, %s)'%(len(eg), d))
def test_call_any_zero(self):
"""any monomial (no coeff) evaluated at (1.0,)*len gives 1.0"""
for eg in self.examples:
p = SparsePowers(eg)
for var in range(len(eg)):
x = [float(i+1) for i in rand_int_tuple(len(eg), 3)]
x[var] = 0.0
if p[var]==0:
self.assert_(not p(x)==0.0)
else:
self.assertEquals(p(x), 0.0)
def test_call_negative_counts(self):
for eg in self.examples:
p = SparsePowers(eg)
deg = sum(eg)
neg = sum([1 for i in eg if i%2])%2
eno = (-1.0,)*len(eg)
r = p(eno)
if deg==0:
self.assert_(r==1.0)
if neg:
self.assert_(r==-1.0)
else:
self.assert_(r==1.0)
def test_diff_pow(self):
for eg in self.examples:
p = SparsePowers(eg)
for var in xrange(len(eg)):
coeff0, q0 = p.diff_pow(var, 0)
self.assertEquals(coeff0, 1.0)
self.assertEquals(q0, p)
coeff, q = p.diff(var)
coeff1, q1 = p.diff_pow(var, 1)
self.assertEquals(coeff1, coeff)
self.assertEquals(q1, q)
for pow in xrange(5):
coeff, q = p.diff_pow(var, pow)
cop = p.copy()
c = 1.0
for i in xrange(pow):
co, cop = cop.diff(var)
c *= co
self.assertEquals(cop, q)
err = abs(coeff - c)
self.assert_(err < 1.0e-12, err)
def test_less_equal_self(self):
for eg in self.examples:
p = SparsePowers(eg)
self.assert_(p<=p)
def test_not_eq(self):
t = ()
p = SparsePowers(t)
self.assert_(not (TuplePowers((1,)) == p))
def test_pows(self):
p = SparsePowers((1,))
for i in xrange(10):
self.assertEquals(p**i, SparsePowers((i,)))
def test_diff_powers(self):
m = SparsePowers()
c, d = m.diff(0)
self.assertEquals(repr(d), 'SparsePowers(1, {})')
def test_bad_index(self):
for i in xrange(1, 10):
m = SparsePowers()
self.assertRaises(IndexError, m.diff, i)
def test_degree(self):
for eg in self.examples:
p = SparsePowers(eg)
self.assertEquals(p.degree(), sum(eg))
def test_number_of_variables(self):
for eg in self.examples:
p = SparsePowers(eg)
self.assertEquals(p.number_of_variables(), len(eg))
def test_degree(self):
m = SparsePowers()
self.assertEquals(m.degree(), 0)
def test_negative_index(self):
for i in xrange(-10, 0):
m = SparsePowers()
self.assertRaises(IndexError, m.diff, i)
def test_greater_equal_self(self):
for eg in self.examples:
p = SparsePowers(eg)
self.assert_(p>=p)
def test_negative_pow(self):
for i in xrange(-10, 0):
m = SparsePowers()
self.assertRaises(ValueError, m.__pow__, i)
def test_diff_coeff(self):
m = SparsePowers()
c, d = m.diff(0)
self.assertEquals(c, 0)
def test_diff_pow_powers(self):
m = SparsePowers()
for i in xrange(10):
c, d = m.diff_pow(0, i)
self.assertEquals(repr(d), 'SparsePowers(1, {})')
def test_not_greater_self(self):
for eg in self.examples:
p = SparsePowers(eg)
self.assert_(not (p>p))
def test_empty(self):
t = ()
m = TuplePowers(t)
p = SparsePowers(t)
self.assert_(t == p)
self.assert_(m == p)
def test_not_less_self(self):
for eg in self.examples:
p = SparsePowers(eg)
self.assert_(not (p<p))
def test_example(self):
t = (1, 2, 3)
m = TuplePowers(t)
p = SparsePowers(t)
self.assert_(t == p)
self.assert_(m == p)
def test_not_not_equal_self(self):
for eg in self.examples:
p = SparsePowers(eg)
self.assert_(not (p!=p))
def test_empty(self):
t = ()
p = SparsePowers(t)
self.assert_(t == p)
def test_equal_other_same(self):
for eg in self.examples:
p = SparsePowers(eg)
self.assertEquals(p, SparsePowers(eg))