class Tempo:
"""
tempo: the tempo value, relative to the referent
referent: the value for which tempo is given. 1=quarter note, 1/2=8th note
"""
tempo: F
referent: F = F(1)
@property
def quarterTempo(self) -> F:
return F(1)/self.referent*self.tempo
def test_mixed_comparisons(self):
test_values = [
float('-inf'),
D('-1e425000000'), -1e+308,
F(-22, 7), -3.14, -2, 0.0, 1e-320, True,
F('1.2'),
D('1.3'),
float('1.4'),
F(275807, 195025),
D('1.414213562373095048801688724'),
F(114243, 80782),
F(473596569, 84615), 7e+200,
D('infinity')
]
for i, first in enumerate(test_values):
for second in test_values[i + 1:]:
self.assertLess(first, second)
self.assertLessEqual(first, second)
self.assertGreater(second, first)
self.assertGreaterEqual(second, first)
def test_rational_unop(self):
''' test unary operators on constructible instances
representing rationals '''
from constructible import Constructible
from fractions import Fraction as F
from operator import pos, neg
for op in (pos, neg):
with self.subTest(op=op):
for a in [
F(1, 2),
F(-1, 2),
F(12, 25),
F(4, 3), 7, 0, -10,
F(0)
]:
result = op(Constructible(a))
self.assertEqual(result.a, op(a))
self.assertFalse(result.b)
self.assertFalse(result.field)
def test_binary_floats(self):
self.check_equal_hash(0.0, -0.0)
self.check_equal_hash(0.0, D(0))
self.check_equal_hash(-0.0, D(0))
self.check_equal_hash(-0.0, D('-0.0'))
self.check_equal_hash(0.0, F(0))
self.check_equal_hash(float('inf'), D('inf'))
self.check_equal_hash(float('-inf'), D('-inf'))
for _ in range(1000):
x = random.random() * math.exp(random.random() * 200.0 - 100.0)
self.check_equal_hash(x, D.from_float(x))
self.check_equal_hash(x, F.from_float(x))
def legendrePn(n, x):
"""
Legendre polynomials.
"""
from pyranha.math import factorial
from fractions import Fraction as F
temp = 0
for k in range(0, int(n / 2) + 1):
temp = temp + (-1)**k * F(
factorial(2 * (n - k)), 2**n * factorial(k) * factorial(n - k) *
factorial(n - 2 * k)) * x**(n - 2 * k)
return temp
def __rsub__(self, o: object) -> ABSqrtC:
if isinstance(o, ABSqrtC):
radical = o.get_common_radical(self)
return ABSqrtC(o._add - self._add, o._factor - self._factor,
radical)
if isinstance(o, _NumTypes):
return ABSqrtC(
(o if isinstance(o, F) else F(o)) - self._add,
-self._factor,
self._radical,
)
return NotImplemented
def sample_distribution(N: int):
histories = itertools.product(DIRECTIONS, repeat=N)
p_single = F(1, len(DIRECTIONS)**N)
final_distribution = collections.defaultdict(F)
for history in histories:
time_function = {-(i + 1): h for (i, h) in enumerate(history)}
outcome = monte_carlo_exact(time_function)
final_distribution[outcome] += p_single
assert sum(final_distribution.values()) == 1
return dict(final_distribution)
def solution():
f = F(1, 2)
iteration_no = 1
cnt = 0
while iteration_no < 1000:
n = f.numerator
d = f.denominator
if len(str(n + d)) > len(str(d)):
cnt += 1
f = 1 / (2 + f)
iteration_no += 1
return cnt
def solve_rows(k, i, row_sum, partial_sum):
if i == cols:
if k == 0: # 2
return F(1, 2) == partial_sum + F(row_sum, primes_exp[0])
if row_sum % primes_exp[k] == 0:
return solve_rows(k - 1, 0, 0,
partial_sum + row_sum // primes_exp[k])
return 0
if mat[k][i] == 0:
return solve_rows(k, i + 1, row_sum, partial_sum)
if res[i] != -1:
return solve_rows(k, i + 1, row_sum + mat[k][i] * res[i],
partial_sum)
count = 0
res[i] = 0
count += solve_rows(k, i + 1, row_sum, partial_sum)
res[i] = 1
count += solve_rows(k, i + 1, row_sum + mat[k][i], partial_sum)
res[i] = -1
return count
def V(self, phi, j):
ans = P(0)
Phi_p = numpy.exp(-phi[0].coef[0] * sqrt(2. / 3))
s = F(2 * int(numpy.sign(phi[0].coef[1])), 3)
if j == 2:
ans = ans + 1
if j >= 2 - s:
ans = ans - 2 * Phi_p * BellC(-sqrt(2. / 3) * phi, j - (2 - s))
if j >= 2 - 2 * s:
ans = ans + Phi_p**2 * BellC(-2 * sqrt(2. / 3) * phi, j -
(2 - 2 * s))
return ans * self.L**4
def __mul__(self, o: object) -> ABSqrtC:
if isinstance(o, ABSqrtC):
radical = self.get_common_radical(o)
return ABSqrtC(
self._add * o._add + self._factor * o._factor * radical,
self._add * o._factor + self._factor * o._add,
radical,
)
if isinstance(o, _NumTypes):
f_o = o if isinstance(o, F) else F(o)
return ABSqrtC(self._add * f_o, self._factor * f_o, self._radical)
return NotImplemented
def __rmul__(self, o: object) -> ABSqrtC:
if isinstance(o, ABSqrtC):
radical = o.get_common_radical(self)
return ABSqrtC(
o._add * self._add + o._factor * self._factor * radical,
o._add * self._factor + o._factor * self._add,
radical,
)
if isinstance(o, _NumTypes):
f_o = o if isinstance(o, F) else F(o)
return ABSqrtC(f_o * self._add, f_o * self._factor, self._radical)
return NotImplemented
def BellC(x, j):
""" Defines the complete ordinary Bell polynomial recursively. """
indices = [i for i in x.j() if F(i) <= j]
indices = [(p, q) for p, q in nloop(indices, 2) if p != 0 and p + q == j]
if indices:
s = sum(p / j * BellC(x, q) * x[p] for p, q in indices if x[p] != P(0))
if s == 0:
return P(0.)
else:
return s
else:
return P(1)
def __sub__(self, o: object) -> ABSqrtC:
if isinstance(o, ABSqrtC):
radical = self.get_common_radical(o)
return ABSqrtC(self._add - o._add, self._factor - o._factor,
radical)
if isinstance(o, _NumTypes):
return ABSqrtC(
self._add - (o if isinstance(o, F) else F(o)),
self._factor,
self._radical,
)
return NotImplemented
def test_integers(self):
for i in range(-1000, 1000):
self.check_equal_hash(i, float(i))
self.check_equal_hash(i, D(i))
self.check_equal_hash(i, F(i))
for i in range(100):
n = 2**i - 1
if n == int(float(n)):
self.check_equal_hash(n, float(n))
self.check_equal_hash(-n, -float(n))
self.check_equal_hash(n, D(n))
self.check_equal_hash(n, F(n))
self.check_equal_hash(-n, D(-n))
self.check_equal_hash(-n, F(-n))
n = 2**i
self.check_equal_hash(n, float(n))
self.check_equal_hash(-n, -float(n))
self.check_equal_hash(n, D(n))
self.check_equal_hash(n, F(n))
self.check_equal_hash(-n, D(-n))
self.check_equal_hash(-n, F(-n))
for _ in range(1000):
e = random.randrange(300)
n = random.randrange(-10**e, 10**e)
self.check_equal_hash(n, D(n))
self.check_equal_hash(n, F(n))
if n == int(float(n)):
self.check_equal_hash(n, float(n))
def me(self, reverse = False):
'''
return the R.E.F(row echelon form, in french m.e.) of the matrix'''
i, j = 0, 0
me = self.copy()
while i < len(me[0]) and j < len(me)-1:
found_non_zero = False
for o in range(j, len(me)): #find a non-zero pivot, replace the current line.
if me[o][i] != 0 and found_non_zero == False:
me[j], me[o] = me[o], me[j]
found_non_zero = True
if found_non_zero:
me[j] = [F(elem, me[j][i]) for elem in me[j]] #current pivot line: me[j]
for k in range(j+1, len(me)):
#modifier tous les entrees au-desous du pivot a zero.
tmp_line = []
for q in range(len(me[k])):
tmp_line.append(me[k][q]-me[k][i]*me[j][q])
me[k] = tmp_line
i += 1
j += 1
else:
i += 1
for line in me:
i = 0
while i < len(line) and line[i] == 0:
i += 1
if i < len(line) and line[i] != 1:
coe = line[i]
for p in range(len(line)):
line[p] = F(line[p], coe)
if reverse == True:
me = me[::-1]
return Matrix(*me)
def sin_f(e, M, order):
"""
Celestial mechanics classical expansion of sinf.
"""
from pyranha.math import sin
from fractions import Fraction as F
temp = 0
for k in range(1, order + 2):
temp = temp + (besselJ(k - 1, k * e, order) -
besselJ(k + 1, k * e, order)) * sin(k * M)
temp = temp * binomial_exp(1, -e**2, F(1, 2), int(order / 2))
return temp.transform(
lambda t: (t[0].filter(lambda u: u[1].degree(['e']) <= order), t[1]))
def test_complex(self):
# comparisons with complex are special: equality and inequality
# comparisons should always succeed, but order comparisons should
# raise TypeError.
z = 1.0 + 0j
w = -3.14 + 2.7j
for v in 1, 1.0, F(1), D(1), complex(1):
self.assertEqual(z, v)
self.assertEqual(v, z)
for v in 2, 2.0, F(2), D(2), complex(2):
self.assertNotEqual(z, v)
self.assertNotEqual(v, z)
self.assertNotEqual(w, v)
self.assertNotEqual(v, w)
for v in (1, 1.0, F(1), D(1), complex(1), 2, 2.0, F(2), D(2),
complex(2), w):
for op in operator.le, operator.lt, operator.ge, operator.gt:
self.assertRaises(TypeError, op, z, v)
self.assertRaises(TypeError, op, v, z)
def gauss(A):
n = len(A)
for i in range(n):
maxEl = abs(A[i][i])
maxRow = i
for k in range(i + 1, n):
if abs(A[k][i]) > maxEl:
maxEl = abs(A[k][i])
maxRow = k
for k in range(i, n + 1):
A[maxRow][k], A[i][k] = A[i][k], A[maxRow][k]
for k in range(i + 1, n):
c = F(-A[k][i], A[i][i])
for j in range(i, n + 1):
if i == j: A[k][j] = F(0, 1)
else: A[k][j] += c * A[i][j]
x = [0] * n
for i in range(n - 1, -1, -1):
x[i] = F(A[i][n], A[i][i])
for k in range(i - 1, -1, -1):
A[k][n] -= A[k][i] * x[i]
return x
def test_equal(self):
'''
hash of multiple representations of the same value must be equal
'''
from constructible import sqrt
from fractions import Fraction as F
for a, b in [(sqrt(2), 2 / sqrt(2)), (sqrt(2), 1 / sqrt(F(1, 2))),
(sqrt(2) + sqrt(3), sqrt(3) + sqrt(2))]:
with self.subTest(a=a, b=b):
self.assertEqual(a, b, 'precondition for this test')
self.assertEqual(hash(a), hash(b),
'%s == %s, but hash is different' % (a, b))
def result():
f = F(*map(int, n(str).split('/')))
if f == 1:
return 1
g = 41
for i in range(1, 41):
f *= 2
if f.numerator >= f.denominator and i < g:
g = i
if f.denominator != 1:
return 'impossible'
else:
return g
def test_durbin_recurrence_rational():
# Test the reference using external and hand-calculated values.
cdf = ks_unif_durbin_recurrence_rational
small = lambda sp: (slow and sp < 40) or sp < 20
for sp, st, pr in oconnor_values:
if small(sp):
assert abs(cdf(sp, F.from_float(st)) - pr) / pr <= F('.5e-4')
for sp, st, pr in brown_values:
if small(sp):
assert abs(cdf(sp, F.from_float(st)) - pr) / pr <= F('.5e-5')
for sp, st, pr in simard_values:
if small(sp):
assert abs(cdf(sp, F.from_float(st)) - pr) / pr <= F('.5e-13')
for sp, st, pr in marsaglia_values:
if small(sp):
assert abs(cdf(sp, F.from_float(st)) - pr) / pr <= F('.5e-13')
for sp, st, pr in exact_values:
if small(sp):
# Reference is supposed to compute an exact result, with
# inaccuracies resulting only from the limited precison
# of the stored test values.
assert cdf(sp, st) == pr
def test_unify_types_to_custom_type(self):
class MyNumber(object):
def __init__(self, x):
if isinstance(x, MyNumber):
self.x = x.x
else:
self.x = int(x)
l = [1, F(2), MyNumber(3)]
u = util.unify_types(l)
for i in u:
self.assertIsInstance(i, MyNumber)
self.assertEqual([i.x for i in u], [1, 2, 3])
def test_data_contained(self): # internal data representation
self.assertEqual(
self.rhythm_dur.sequence,
[F(1, 4),
F(1, 4),
F(1, 16),
F(1, 8),
F(1, 8),
F(1, 16),
F(1, 8)])
self.assertTrue(self.rhythm_dur[1].rest)
self.assertEqual(self.rhythm_dur[2].accent, 2)
def __truediv__(self, o: object) -> ABSqrtC:
if isinstance(o, ABSqrtC):
radical = self.get_common_radical(o)
return ABSqrtC(
(self._add * o._add - self._factor * o._factor * radical) /
o._conjugate_product,
(self._factor * o._add - self._add * o._factor) /
o._conjugate_product,
radical,
)
if isinstance(o, _NumTypes):
f_o = o if isinstance(o, F) else F(o)
return ABSqrtC(self._add / f_o, self._factor / f_o, self._radical)
return NotImplemented
def test_resource_create_pieces(self):
''' test that we can create n pieces of the cake '''
keys = ['red', 'blue', 'green', 'yellow', 'orange', 'purple']
vals = dict((k, F(1,1)) for k in keys)
cake = CollectionResource(keys)
user = CollectionPreference('mark', vals)
pieces = create_equal_pieces(user, cake, 3)
actual = [
CollectionResource(['red', 'blue']),
CollectionResource(['green', 'yellow']),
CollectionResource(['orange', 'purple'])
]
for this,that in zip(pieces, actual):
self.assertEqual(this.value, that.value)
def test_add(self):
t1 = ABSqrtC(2, 0, 1)
t2 = ABSqrtC(3, -5, 7)
t3 = ABSqrtC(3, 5, 7)
t4 = ABSqrtC(3, 10, 7)
t5 = ABSqrtC(3, 5, 11)
with pytest.raises(ValueError):
t2 + t5
assert t1 + t3 == ABSqrtC(5, 5, 7)
assert t2 + t3 == ABSqrtC(6, 0, 1)
assert t2 + t4 == ABSqrtC(6, 5, 7)
assert t3 + 1 == t3 + D(1) == t3 + F(1) == t3 + "1" == ABSqrtC(4, 5, 7)
def sol():
gre = F(0,1)
les = float('inf')
for i in range(n-1):
a, b = mol[i]
c, d = mol[i+1]
if b == d:
if a >= c: les = -float('inf')
continue
rat = F(a-c, d-b)
if d-b > 0: gre = max(gre, rat)
else: les = min(les, rat)
if les <= gre:
return -1, -1
# print(gre, les)
if les != float('inf'):
rat = simplest_between(gre, les)
ansy, ansx = rat.numerator, rat.denominator
else:
ansx = 1
ansy = int(gre) + 1
return ansx, ansy
def test_resource_clone(self):
''' test that the resource clone works correctly '''
keys = ['red', 'blue', 'green', 'yellow', 'orange']
vals = dict((k, F(1,1)) for k in keys)
cake = CollectionResource(keys)
user = CollectionPreference('mark', vals)
copy = cake.clone()
self.assertEqual(str(cake), str(copy))
self.assertEqual(repr(cake), repr(copy))
self.assertEqual(5, cake.actual_value(),)
self.assertEqual(cake.actual_value(), copy.actual_value())
self.assertEqual(CollectionResource('a'), CollectionResource(['a']))
def calc_oowp(N, games, owp):
oowp = {}
for team1 in xrange(N):
oowp_ = F()
n_opponents = 0
for team2 in xrange(N):
if team1 == team2:
continue
team1_result = games.get((team1, team2), None)
if team1_result is not None:
n_opponents += 1
oowp_ += owp[team2]
oowp[team1] = oowp_ / n_opponents
return oowp
