def reduce_sl2z(self, inverse=False):
if self.imag_sgn() <= 0:
raise ValueError("not in the upper half-plane")
# todo: use numerical code in arb to improve performance
tau = self
a, b, c, d = fmpz(1), fmpz(0), fmpz(0), fmpz(1)
half = alg(1) / 2
minus_half = -half
while 1:
x = tau.real
if x < minus_half or x >= half:
n = (x + half).floor().fmpz()
tau -= n
a -= n * c
b -= n * d
else:
v = abs(tau)
if v < 1 or (v == 1 and x > 0):
tau = -1 / tau
a, b, c, d = -c, -d, a, b
else:
break
if inverse:
a, b, c, d = d, -b, -c, a
if c < 0 or (c == 0 and d < 0):
a = -a
b = -b
c = -c
d = -d
return tau, (a, b, c, d)
def generate_keys(bit_length=1024, e=65537):
p = fmpz(number.getPrime(bit_length))
q = fmpz(number.getPrime(bit_length))
n = p * q
# Carmichael's totient function, which is the same as Euler's in this case.
l = fmpz(lcm(p - 1, q - 1))
public_key = (n, e)
d = inverse(e, l)
private_key = (n, d)
return (p, q, n, l, e, d, public_key, private_key)
def test_fmpz_mat():
M = flint.fmpz_mat
a = M(2, 3, [1, 2, 3, 4, 5, 6])
b = M(2, 3, [4, 5, 6, 7, 8, 9])
assert a == a
assert a == M(a)
assert a != b
assert a.nrows() == 2
assert a.ncols() == 3
assert a.entries() == [1, 2, 3, 4, 5, 6]
assert a.table() == [[1, 2, 3], [4, 5, 6]]
assert (a + b).entries() == [5, 7, 9, 11, 13, 15]
assert raises(a.det, ValueError)
assert +a == a
assert -a == M(2, 3, [-1, -2, -3, -4, -5, -6])
c = M(2, 2, [1, 2, 3, 4])
assert c.det() == -2
assert raises(lambda: a + c, ValueError)
assert (a * 3).entries() == [3, 6, 9, 12, 15, 18]
assert (3 * a).entries() == [3, 6, 9, 12, 15, 18]
assert (a * long(3)).entries() == [3, 6, 9, 12, 15, 18]
assert (long(3) * a).entries() == [3, 6, 9, 12, 15, 18]
assert (a * flint.fmpz(3)).entries() == [3, 6, 9, 12, 15, 18]
assert (flint.fmpz(3) * a).entries() == [3, 6, 9, 12, 15, 18]
assert M.randrank(5, 7, 3, 10).rank() == 3
A = M.randbits(5, 3, 2)
B = M.randtest(3, 7, 3)
C = M.randtest(7, 2, 4)
assert A * (B * C) == (A * B) * C
assert bool(M(2, 2, [0, 0, 0, 0])) == False
assert bool(M(2, 2, [0, 0, 0, 1])) == True
ctx.pretty = False
assert repr(M(2, 2, [1, 2, 3, 4])) == 'fmpz_mat(2, 2, [1, 2, 3, 4])'
ctx.pretty = True
assert str(M(2, 2, [1, 2, 3, 4])) == '[1, 2]\n[3, 4]'
assert M(1, 2, [3, 4]) * flint.fmpq(1, 3) == flint.fmpq_mat(
1, 2, [1, flint.fmpq(4, 3)])
assert flint.fmpq(1, 3) * M(1, 2, [3, 4]) == flint.fmpq_mat(
1, 2, [1, flint.fmpq(4, 3)])
assert M(1, 2, [3, 4]) / 3 == flint.fmpq_mat(1, 2, [1, flint.fmpq(4, 3)])
assert M(2, 2,
[1, 2, 3, 4
]).inv().det() == flint.fmpq(1) / M(2, 2, [1, 2, 3, 4]).det()
assert M(2, 2, [1, 2, 3, 4]).inv().inv() == M(2, 2, [1, 2, 3, 4])
assert raises(lambda: M.randrank(4, 3, 4, 1), ValueError)
assert raises(lambda: M.randrank(3, 4, 4, 1), ValueError)
assert M(1, 1, [3])**5 == M(1, 1, [3**5])
assert raises(lambda: M(1, 2)**3, ValueError)
assert raises(lambda: M(1, 1)**M(1, 1), TypeError)
assert raises(lambda: 1**M(1, 1), TypeError)
assert raises(lambda: M([1]), TypeError)
assert raises(lambda: M([[1], [2, 3]]), ValueError)
assert M([[1, 2, 3], [4, 5, 6]]) == M(2, 3, [1, 2, 3, 4, 5, 6])
def gaussian_integer(a, b):
if b == 0:
return alg(a)
a = fmpz(a)
b = fmpz(b)
orig = ctx.prec
ctx.prec = 64
try:
z = acb(a, b)
finally:
ctx.prec = orig
res = alg(_minpoly=fmpz_poly([a**2 + b**2, -2 * a, 1]), _enclosure=z)
return res
def test_nmod_mat():
M = flint.nmod_mat
G = flint.nmod
Z = flint.fmpz_mat
a = M(2, 3, [1, 2, 3, 4, 5, 6], 17)
b = M(2, 3, [4, 5, 6, 7, 8, 9], 17)
assert a == a
assert a == M(a)
assert a != b
assert a.nrows() == 2
assert a.ncols() == 3
assert a.entries() == [G(x, 17) for x in [1, 2, 3, 4, 5, 6]]
assert a.table() == [[G(x, 17) for x in [1, 2, 3]],
[G(x, 17) for x in [4, 5, 6]]]
assert (a + b).entries() == [G(x, 17) for x in [5, 7, 9, 11, 13, 15]]
assert raises(a.det, ValueError)
assert +a == a
assert -a == M(2, 3, [-1, -2, -3, -4, -5, -6], 17)
c = M(2, 2, [1, 2, 3, 4], 17)
assert c.det() == G(-2, 17)
assert raises(lambda: a + c, ValueError)
assert (a * 3).entries() == [G(x, 17) for x in [3, 6, 9, 12, 15, 18]]
assert (3 * a).entries() == [G(x, 17) for x in [3, 6, 9, 12, 15, 18]]
assert (a * long(3)).entries() == [G(x, 17) for x in [3, 6, 9, 12, 15, 18]]
assert (long(3) * a).entries() == [G(x, 17) for x in [3, 6, 9, 12, 15, 18]]
assert (a * flint.fmpz(3)).entries() == [
G(x, 17) for x in [3, 6, 9, 12, 15, 18]
]
assert (flint.fmpz(3) *
a).entries() == [G(x, 17) for x in [3, 6, 9, 12, 15, 18]]
assert M(2, 2, [1, 1, 2, 2], 17).rank() == 1
A = M(5, 3, Z.randbits(5, 3, 5).entries(), 17)
B = M(3, 7, Z.randtest(3, 7, 5).entries(), 17)
C = M(7, 2, Z.randtest(7, 2, 5).entries(), 17)
assert A * (B * C) == (A * B) * C
assert bool(M(2, 2, [0, 0, 0, 0], 17)) == False
assert bool(M(2, 2, [0, 0, 0, 1], 17)) == True
ctx.pretty = False
assert repr(M(2, 2, [1, 2, 3, 4],
17)) == 'nmod_mat(2, 2, [1, 2, 3, 4], 17)'
ctx.pretty = True
assert str(M(2, 2, [1, 2, 3, 4], 17)) == '[1, 2]\n[3, 4]'
assert M(1, 2, [3, 4], 17) / 3 == M(1, 2, [3, 4], 17) * (~G(3, 17))
assert M(2, 2, [1, 2, 3, 4],
17).inv().det() == ~(M(2, 2, [1, 2, 3, 4], 17).det())
assert M(2, 2, [1, 2, 3, 4], 17).inv().inv() == M(2, 2, [1, 2, 3, 4], 17)
assert M(2, 2, [0, 1, 2, 3], 17) * M(2, 2, [2, 3, 4, 5], 17) == M(
2, 2, [4, 5, 16, 4], 17)
assert raises(lambda: M([1], 5), TypeError)
assert raises(lambda: M([[1], [2, 3]], 5), ValueError)
assert M([[1, 2, 3], [4, 5, 6]], 5) == M(2, 3, [1, 2, 3, 4, 5, 6], 5)
def array_int_to_fmpz(arr):
"""
**Description:**
Converts a numpy array with 64-bit integer entries to fmpz entries.
**Arguments:**
- `arr` *(array_like)*: A numpy array with 64-bit integer entries.
**Returns:**
*(numpy.ndarray)* A numpy array with fmpz entries.
**Example:**
We convert an integer array to an fmpz array.
```python {3}
from cytools.utils import array_int_to_fmpz
arr = [[1,0,0],[0,2,0],[0,0,3]]
array_int_to_fmpz(arr)
# array([[1, 0, 0],
# [0, 2, 0],
# [0, 0, 3]], dtype=object)
```
"""
in_arr = np.array(arr, dtype=int)
out_arr = np.empty(in_arr.shape, dtype=object)
for i in range(len(in_arr.flat)):
out_arr.flat[i] = fmpz(int(in_arr.flat[i]))
return out_arr
def bit_pow_mod_n(b, m, n):
acc = nmod(1, n)
z = nmod(b, n)
while m:
if m & 1: # check the least significant bit
acc *= z
z *= z
m >>= 1 # the bit shift
return fmpz(acc)
def main():
''' Driver function '''
minimum = 15499 / 94744
denom = 2 * 3 * 5 * 7 * 11 * 13 * 17 * 19 * 23
proper = denom - 1
while int(fmpz.euler_phi(fmpz(denom))) / proper >= minimum:
denom += 1
proper += 1
print(denom)
def test_fmpz_mat():
M = flint.fmpz_mat
a = M(2,3,[1,2,3,4,5,6])
b = M(2,3,[4,5,6,7,8,9])
assert a == a
assert a == M(a)
assert a != b
assert a.nrows() == 2
assert a.ncols() == 3
assert a.entries() == [1,2,3,4,5,6]
assert a.table() == [[1,2,3],[4,5,6]]
assert (a + b).entries() == [5,7,9,11,13,15]
assert raises(a.det, ValueError)
assert +a == a
assert -a == M(2,3,[-1,-2,-3,-4,-5,-6])
c = M(2,2,[1,2,3,4])
assert c.det() == -2
assert raises(lambda: a + c, ValueError)
assert (a * 3).entries() == [3,6,9,12,15,18]
assert (3 * a).entries() == [3,6,9,12,15,18]
assert (a * 3L).entries() == [3,6,9,12,15,18]
assert (3L * a).entries() == [3,6,9,12,15,18]
assert (a * flint.fmpz(3)).entries() == [3,6,9,12,15,18]
assert (flint.fmpz(3) * a).entries() == [3,6,9,12,15,18]
assert M.randrank(5,7,3,10).rank() == 3
A = M.randbits(5,3,2)
B = M.randtest(3,7,3)
C = M.randtest(7,2,4)
assert A*(B*C) == (A*B)*C
assert bool(M(2,2,[0,0,0,0])) == False
assert bool(M(2,2,[0,0,0,1])) == True
assert repr(M(2,2,[1,2,3,4])) == 'fmpz_mat(2, 2, [1, 2, 3, 4])'
assert str(M(2,2,[1,2,3,4])) == '[1, 2]\n[3, 4]'
assert M(1,2,[3,4]) * flint.fmpq(1,3) == flint.fmpq_mat(1, 2, [1, flint.fmpq(4,3)])
assert flint.fmpq(1,3) * M(1,2,[3,4]) == flint.fmpq_mat(1, 2, [1, flint.fmpq(4,3)])
assert M(1,2,[3,4]) / 3 == flint.fmpq_mat(1, 2, [1, flint.fmpq(4,3)])
assert (~M(2,2,[1,2,3,4])).det() == flint.fmpq(1) / M(2,2,[1,2,3,4]).det()
assert ~~M(2,2,[1,2,3,4]) == M(2,2,[1,2,3,4])
assert raises(lambda: M.randrank(4,3,4,1), ValueError)
assert raises(lambda: M.randrank(3,4,4,1), ValueError)
assert M(1,1,[3]) ** 5 == M(1,1,[3**5])
assert raises(lambda: M(1,2) ** 3, ValueError)
assert raises(lambda: M(1,1) ** M(1,1), TypeError)
assert raises(lambda: 1 ** M(1,1), TypeError)
def test_fmpq():
Q = flint.fmpq
assert Q() == Q(0)
assert Q(0) != Q(1)
assert Q(0) == 0
assert 0 == Q(0)
assert Q(2) != 1
assert 1 != Q(2)
assert Q(1, 2) != 1
assert Q(2, 3) == Q(flint.fmpz(2), long(3))
assert Q(-2, -4) == Q(1, 2)
assert bool(Q(0)) == False
assert bool(Q(1)) == True
assert Q(1, 3) + Q(2, 3) == 1
assert Q(1, 3) - Q(2, 3) == Q(-1, 3)
assert Q(1, 3) * Q(2, 3) == Q(2, 9)
assert Q(1, 3) + 2 == Q(7, 3)
assert 2 + Q(1, 3) == Q(7, 3)
assert Q(1, 3) - 2 == Q(-5, 3)
assert 2 - Q(1, 3) == Q(5, 3)
assert Q(1, 3) * 2 == Q(2, 3)
assert 2 * Q(1, 3) == Q(2, 3)
assert Q(2, 3) / Q(4, 5) == Q(5, 6)
assert Q(2, 3) / 5 == Q(2, 15)
assert Q(2, 3) / flint.fmpz(5) == Q(2, 15)
assert 5 / Q(2, 3) == Q(15, 2)
assert flint.fmpz(5) / Q(2, 3) == Q(15, 2)
assert operator.truediv(Q(2, 3), 5) == Q(2, 15)
ctx.pretty = False
assert repr(Q(-2, 3)) == "fmpq(-2,3)"
ctx.pretty = True
assert str(Q(-2, 3)) == "-2/3"
assert Q(2, 3).p == Q(2, 3).numer() == 2
assert Q(2, 3).q == Q(2, 3).denom() == 3
assert +Q(5, 7) == Q(5, 7)
assert -Q(5, 7) == Q(-5, 7)
assert -Q(-5, 7) == Q(5, 7)
assert abs(Q(5, 7)) == Q(5, 7)
assert abs(-Q(5, 7)) == Q(5, 7)
assert raises(lambda: Q(1, 0), ZeroDivisionError)
assert raises(lambda: Q(1, 2) / Q(0), ZeroDivisionError)
assert raises(lambda: Q(1, 2) / 0, ZeroDivisionError)
def test_fmpq():
Q = flint.fmpq
assert Q() == Q(0)
assert Q(0) != Q(1)
assert Q(0) == 0
assert 0 == Q(0)
assert Q(2) != 1
assert 1 != Q(2)
assert Q(1,2) != 1
assert Q(2,3) == Q(flint.fmpz(2),3L)
assert Q(-2,-4) == Q(1,2)
assert bool(Q(0)) == False
assert bool(Q(1)) == True
assert Q(1,3) + Q(2,3) == 1
assert Q(1,3) - Q(2,3) == Q(-1,3)
assert Q(1,3) * Q(2,3) == Q(2,9)
assert Q(1,3) + 2 == Q(7,3)
assert 2 + Q(1,3) == Q(7,3)
assert Q(1,3) - 2 == Q(-5,3)
assert 2 - Q(1,3) == Q(5,3)
assert Q(1,3) * 2 == Q(2,3)
assert 2 * Q(1,3) == Q(2,3)
assert Q(2,3) / Q(4,5) == Q(5,6)
assert Q(2,3) / 5 == Q(2,15)
assert Q(2,3) / flint.fmpz(5) == Q(2,15)
assert 5 / Q(2,3) == Q(15,2)
assert flint.fmpz(5) / Q(2,3) == Q(15,2)
assert operator.truediv(Q(2,3), 5) == Q(2,15)
assert repr(Q(-2,3)) == "fmpq(-2,3)"
assert str(Q(-2,3)) == "-2/3"
assert Q(2,3).p == Q(2,3).numer() == 2
assert Q(2,3).q == Q(2,3).denom() == 3
assert +Q(5,7) == Q(5,7)
assert -Q(5,7) == Q(-5,7)
assert -Q(-5,7) == Q(5,7)
assert abs(Q(5,7)) == Q(5,7)
assert abs(-Q(5,7)) == Q(5,7)
assert raises(lambda: Q(1,0), ZeroDivisionError)
assert raises(lambda: Q(1,2) / Q(0), ZeroDivisionError)
assert raises(lambda: Q(1,2) / 0, ZeroDivisionError)
def test_nmod_mat():
M = flint.nmod_mat
G = flint.nmod
Z = flint.fmpz_mat
a = M(2,3,[1,2,3,4,5,6],17)
b = M(2,3,[4,5,6,7,8,9],17)
assert a == a
assert a == M(a)
assert a != b
assert a.nrows() == 2
assert a.ncols() == 3
assert a.entries() == [G(x,17) for x in [1,2,3,4,5,6]]
assert a.table() == [[G(x,17) for x in [1,2,3]], [G(x,17) for x in [4,5,6]]]
assert (a + b).entries() == [G(x,17) for x in [5,7,9,11,13,15]]
assert raises(a.det, ValueError)
assert +a == a
assert -a == M(2,3,[-1,-2,-3,-4,-5,-6],17)
c = M(2,2,[1,2,3,4],17)
assert c.det() == G(-2,17)
assert raises(lambda: a + c, ValueError)
assert (a * 3).entries() == [G(x,17) for x in [3,6,9,12,15,18]]
assert (3 * a).entries() == [G(x,17) for x in [3,6,9,12,15,18]]
assert (a * 3L).entries() == [G(x,17) for x in [3,6,9,12,15,18]]
assert (3L * a).entries() == [G(x,17) for x in [3,6,9,12,15,18]]
assert (a * flint.fmpz(3)).entries() == [G(x,17) for x in [3,6,9,12,15,18]]
assert (flint.fmpz(3) * a).entries() == [G(x,17) for x in [3,6,9,12,15,18]]
assert M(2,2,[1,1,2,2],17).rank() == 1
A = M(5,3,Z.randbits(5,3,5).entries(),17)
B = M(3,7,Z.randtest(3,7,5).entries(),17)
C = M(7,2,Z.randtest(7,2,5).entries(),17)
assert A*(B*C) == (A*B)*C
assert bool(M(2,2,[0,0,0,0],17)) == False
assert bool(M(2,2,[0,0,0,1],17)) == True
assert repr(M(2,2,[1,2,3,4],17)) == 'nmod_mat(2, 2, [1L, 2L, 3L, 4L], 17)'
assert str(M(2,2,[1,2,3,4],17)) == '[1, 2]\n[3, 4]'
assert M(1,2,[3,4],17) / 3 == M(1,2,[3,4],17) * (~G(3,17))
assert (~M(2,2,[1,2,3,4], 17)).det() == ~(M(2,2,[1,2,3,4], 17).det())
assert ~~M(2,2,[1,2,3,4], 17) == M(2,2,[1,2,3,4], 17)
assert M(2,2,[0,1,2,3],17) * M(2, 2, [2,3,4,5], 17) == M(2,2,[4,5,16,4],17)
def prime_chain_length(prime, chain_lengths):
''' Returns the length of the chain of numbers produced by iterating
Euler's totient function starting with 'prime' and ending with 1. Some
chain lengths are saved in 'chain_lengths' '''
prev = prime
cur = prime - 1
chain = [prev]
length = 2
while cur != 1:
if chain_lengths[cur]:
length = len(chain) + chain_lengths[cur]
break
chain += [cur]
prev = cur
cur = fmpz.euler_phi(fmpz(prev))
length += 1
for i, n in enumerate(chain):
chain_lengths[n] = length - i
return length
def inverse(a, n):
if gcd(a, n) == 1:
return fmpz(rinv_helper(n, a) % n)
else:
return "a is not invertible in Z/nZ"
def test_fmpz():
assert flint.fmpz() == flint.fmpz(0)
L = [0, 1, 2, 3, 2**31-1, 2**31, 2**63-1, 2**63, 2**64-1, 2**64]
L += [-x for x in L]
for s in L:
for t in L:
for ltype in (flint.fmpz, int, long):
for rtype in (flint.fmpz, int, long):
assert ltype(s) + rtype(t) == s + t
assert ltype(s) - rtype(t) == s - t
assert ltype(s) * rtype(t) == s * t
if t == 0:
assert raises(lambda: ltype(s) // rtype(t), ZeroDivisionError)
assert raises(lambda: ltype(s) % rtype(t), ZeroDivisionError)
assert raises(lambda: divmod(ltype(s), rtype(t)), ZeroDivisionError)
else:
assert ltype(s) // rtype(t) == s // t
assert ltype(s) % rtype(t) == s % t
assert divmod(ltype(s), rtype(t)) == divmod(s, t)
assert (ltype(s) == rtype(t)) == (s == t)
assert (ltype(s) != rtype(t)) == (s != t)
assert (ltype(s) < rtype(t)) == (s < t)
assert (ltype(s) <= rtype(t)) == (s <= t)
assert (ltype(s) > rtype(t)) == (s > t)
assert (ltype(s) >= rtype(t)) == (s >= t)
if 0 <= t < 10:
assert (ltype(s) ** rtype(t)) == (s ** t)
assert +flint.fmpz(0) == 0
assert +flint.fmpz(1) == 1
assert +flint.fmpz(-1) == -1
assert -flint.fmpz(0) == 0
assert -flint.fmpz(1) == -1
assert -flint.fmpz(-1) == 1
assert abs(flint.fmpz(0)) == 0
assert abs(flint.fmpz(1)) == 1
assert abs(flint.fmpz(-1)) == 1
assert int(flint.fmpz(2)) == 2
assert isinstance(int(flint.fmpz(2)), int)
assert long(flint.fmpz(2)) == 2
assert isinstance(long(flint.fmpz(2)), long)
assert repr(flint.fmpz(0)) == "fmpz(0)"
assert repr(flint.fmpz(-27)) == "fmpz(-27)"
assert bool(flint.fmpz(0)) == False
assert bool(flint.fmpz(1)) == True
def as_quadratic(self, factor_limit=2**64):
"""
Assuming that *self* has degree 1 or 2, returns (*a*, *b*, *c*)
where *a* and *b* are *fmpq* rational numbers and *c* is a *fmpz*
integer, such that *self* equals `a + b \sqrt{c}`.
The integer *c* will not be a perfect square, but might not be
squarefree since ensuring this property requires integer factorization.
If *|c|* is initially smaller than *factor_limit*, it will be
completely factored into its squarefree part (with the square content
moved to *b*); otherwise, only a partial factorization will be performed.
>>> alg(-23).as_quadratic()
(-23, 0, 0)
>>> (2 + alg.i() / 3).as_quadratic()
(2, 1/3, -1)
>>> x = (alg(5)/2 + alg(24).sqrt())**5
>>> x.as_quadratic()
(353525/32, 36341/8, 6)
>>> x == alg(353525)/32 + alg(36341)/8 * alg(6).sqrt()
True
>>> alg(3 * 29**2 * (10**20+39)**2).sqrt().as_quadratic()
(0, 2900000000000000001131, 3)
>>> x = alg(3 * (10**10+1)**3 * (10**15+1)**2).sqrt()
>>> a, b, c = x.as_quadratic()
>>> (a, b, c)
(0, 39340116598834051, 1938429316132524961593868203)
>>> x == a + b*alg(c).sqrt()
True
>>> a, b, c = x.as_quadratic(factor_limit=10**50)
>>> (a, b, c)
(0, 10000000001000010000000001, 30000000003)
>>> x == a + b*alg(c).sqrt()
True
"""
poly = self._minpoly
if poly.degree() == 1:
return (self.fmpq(), fmpq(), fmpz())
if poly.degree() != 2:
raise ValueError
c, b, a = list(self.minpoly())
D = b**2 - 4 * a * c
Dsqrt = alg(D).sqrt()
x = (-b + Dsqrt) / (2 * a)
if self == x:
bsign = 1
else:
x = (-b - Dsqrt) / (2 * a)
bsign = -1
a, b, c = fmpq(-b) / (2 * a), fmpq(bsign, 2 * a), D
if abs(c) >= 4:
if abs(c) < factor_limit:
fac = c.factor()
else:
fac = c.factor(trial_limit=1000)
# todo: the partial factoring in flint is wonky;
# it should at least do a perfect power test or single-word
# factorisation of the last factor
if 1:
rem, reme = fac[-1]
if rem < factor_limit:
fac = fac[:-1] + [(pp, ee * reme)
for (pp, ee) in rem.factor()]
elif rem.is_perfect_power():
for e in range(64, 1, -1):
p = rem.root(e)
if p**e == rem:
if p < factor_limit:
fac2 = rem.factor()
fac = fac[:-1]
for (p, f) in fac2:
fac.append((p, e * f * reme))
else:
fac = fac[:-1] + [(p, e * reme)]
break
check = 1
for p, e in fac:
check *= p**e
# assert check == abs(c)
square = fmpz(1)
squarefree = fmpz(1)
for p, e in fac:
if e % 2 == 0:
square *= p**(e // 2)
else:
square *= p**(e // 2)
squarefree *= p
if c < 0:
squarefree = -squarefree
b *= square
c = squarefree
# assert self == alg(a) + alg(b) * alg(c).sqrt()
return a, b, c
def test_fmpz_poly():
Z = flint.fmpz_poly
assert Z() == Z([])
assert Z() == Z([0])
assert Z() == Z([0, flint.fmpz(0), 0])
assert Z() == Z([0, 0, 0])
assert Z() != Z([1])
assert Z([1]) == Z([1])
assert Z([1]) == Z([flint.fmpz(1)])
assert Z(Z([1, 2])) == Z([1, 2])
for ztype in [int, long, flint.fmpz]:
assert Z([1, 2, 3]) + ztype(5) == Z([6, 2, 3])
assert ztype(5) + Z([1, 2, 3]) == Z([6, 2, 3])
assert Z([1, 2, 3]) - ztype(5) == Z([-4, 2, 3])
assert ztype(5) - Z([1, 2, 3]) == Z([4, -2, -3])
assert Z([1, 2, 3]) * ztype(5) == Z([5, 10, 15])
assert ztype(5) * Z([1, 2, 3]) == Z([5, 10, 15])
assert Z([11, 6, 2]) // ztype(5) == Z([2, 1])
assert ztype(5) // Z([-2]) == Z([-3])
assert ztype(5) // Z([1, 2]) == 0
assert Z([11, 6, 2]) % ztype(5) == Z([1, 1, 2])
assert ztype(5) % Z([-2]) == Z([-1])
assert ztype(5) % Z([1, 2]) == 5
assert Z([1, 2, 3])**ztype(0) == 1
assert Z([1, 2, 3])**ztype(1) == Z([1, 2, 3])
assert Z([1, 2, 3])**ztype(2) == Z([1, 4, 10, 12, 9])
assert +Z([1, 2]) == Z([1, 2])
assert -Z([1, 2]) == Z([-1, -2])
assert raises(lambda: Z([1, 2, 3])**-1, (OverflowError, ValueError))
assert raises(lambda: Z([1, 2, 3])**Z([1, 2]), TypeError)
assert raises(lambda: Z([1, 2]) // Z([]), ZeroDivisionError)
assert raises(lambda: Z([]) // Z([]), ZeroDivisionError)
assert raises(lambda: Z([1, 2]) % Z([]), ZeroDivisionError)
assert raises(lambda: divmod(Z([1, 2]), Z([])), ZeroDivisionError)
assert Z([]).degree() == -1
assert Z([]).length() == 0
p = Z([1, 2])
assert p.length() == 2
assert p.degree() == 1
assert p[0] == 1
assert p[1] == 2
assert p[2] == 0
assert p[-1] == 0
assert raises(lambda: p.__setitem__(-1, 1), ValueError)
p[0] = 3
assert p[0] == 3
p[4] = 7
assert p.degree() == 4
assert p[4] == 7
assert p[3] == 0
p[4] = 0
assert p.degree() == 1
assert p.coeffs() == [3, 2]
assert Z([]).coeffs() == []
assert bool(Z([])) == False
assert bool(Z([1])) == True
ctx.pretty = False
assert repr(Z([1, 2])) == "fmpz_poly([1, 2])"
ctx.pretty = True
assert str(Z([1, 2])) == "2*x + 1"
p = Z([3, 4, 5])
assert p(2) == 31
assert p(flint.fmpq(2, 3)) == flint.fmpq(71, 9)
assert p(Z([1, -1])) == Z([12, -14, 5])
assert p(flint.fmpq_poly([2, 3], 5)) == flint.fmpq_poly([27, 24, 9], 5)
assert p(flint.arb("1.1")).overlaps(flint.arb("13.45"))
assert p(flint.acb("1.1", "1.2")).overlaps(flint.acb("6.25", "18.00"))
def enclosure(self, pretty=False):
if self.degree() == 1:
c0 = self._minpoly[0]
c1 = self._minpoly[1]
return arb(c0) / (-c1)
elif pretty:
z = self.enclosure()
re = z.real
im = z.imag
# detect zero real/imag part
if z.real.contains(0):
if self.real_sgn() == 0:
re = arb(0)
if z.imag.contains(0):
if self.imag_sgn() == 0:
im = arb(0)
# detect exact (dyadic) real/imag parts
# fixme: extracting real and imag parts and checking if
# they are exact can be slow at high degree; this is a workaround
# until that operation can be improved
scale = fmpz(2)**max(10, ctx.prec - 20)
if not re.is_exact() and (re * scale).unique_fmpz() is not None:
n = (re * scale).unique_fmpz()
b = self - fmpq(n, scale)
if b.real_sgn() == 0:
re = arb(fmpq(n, scale))
if not im.is_exact() and (im * scale).unique_fmpz() is not None:
n = (im * scale).unique_fmpz()
b = self - fmpq(n, scale) * alg.i()
if b.imag_sgn() == 0:
im = arb(fmpq(n, scale))
if im == 0:
return arb(re)
else:
return acb(re, im)
else:
orig_prec = ctx.prec
x = self._enclosure
if x.rel_accuracy_bits() >= orig_prec - 2:
return x
# Try interval newton refinement
f = self._minpoly
g = self._minpoly.derivative()
try:
ctx.prec = max(x.rel_accuracy_bits(), 32) + 10
for step in range(40):
ctx.prec *= 2
if ctx.prec > 1000000:
raise ValueError("excessive precision")
# print("root-refinement prec", ctx.prec)
# print(x.mid().str(10), x.rad().str(10))
xmid = x.mid()
y = xmid - f(xmid) / g(x)
if y.rel_accuracy_bits() >= 1.1 * orig_prec:
self._enclosure = y
return y
if y.rel_accuracy_bits() < 1.5 * x.rel_accuracy_bits() + 1:
# print("refinement failed -- recomputing roots")
roots = self._minpoly.roots()
near = [r for (r, mult) in roots if acb(r).overlaps(x)]
if len(near) == 1:
y = near[0]
if y.rel_accuracy_bits() >= 1.1 * orig_prec:
self._enclosure = y
return y
x = y
raise ValueError("root refinement did not converge")
finally:
ctx.prec = orig_prec
def test_fmpz():
assert flint.fmpz() == flint.fmpz(0)
L = [0, 1, 2, 3, 2**31 - 1, 2**31, 2**63 - 1, 2**63, 2**64 - 1, 2**64]
L += [-x for x in L]
for s in L:
for t in L:
for ltype in (flint.fmpz, int, long):
for rtype in (flint.fmpz, int, long):
assert ltype(s) + rtype(t) == s + t
assert ltype(s) - rtype(t) == s - t
assert ltype(s) * rtype(t) == s * t
if t == 0:
assert raises(lambda: ltype(s) // rtype(t),
ZeroDivisionError)
assert raises(lambda: ltype(s) % rtype(t),
ZeroDivisionError)
assert raises(lambda: divmod(ltype(s), rtype(t)),
ZeroDivisionError)
else:
assert ltype(s) // rtype(t) == s // t
assert ltype(s) % rtype(t) == s % t
assert divmod(ltype(s), rtype(t)) == divmod(s, t)
assert (ltype(s) == rtype(t)) == (s == t)
assert (ltype(s) != rtype(t)) == (s != t)
assert (ltype(s) < rtype(t)) == (s < t)
assert (ltype(s) <= rtype(t)) == (s <= t)
assert (ltype(s) > rtype(t)) == (s > t)
assert (ltype(s) >= rtype(t)) == (s >= t)
if 0 <= t < 10:
assert (ltype(s)**rtype(t)) == (s**t)
assert +flint.fmpz(0) == 0
assert +flint.fmpz(1) == 1
assert +flint.fmpz(-1) == -1
assert -flint.fmpz(0) == 0
assert -flint.fmpz(1) == -1
assert -flint.fmpz(-1) == 1
assert abs(flint.fmpz(0)) == 0
assert abs(flint.fmpz(1)) == 1
assert abs(flint.fmpz(-1)) == 1
assert int(flint.fmpz(2)) == 2
assert isinstance(int(flint.fmpz(2)), int)
assert long(flint.fmpz(2)) == 2
assert isinstance(long(flint.fmpz(2)), long)
ctx.pretty = False
assert repr(flint.fmpz(0)) == "fmpz(0)"
assert repr(flint.fmpz(-27)) == "fmpz(-27)"
ctx.pretty = True
assert repr(flint.fmpz(0)) == "0"
assert repr(flint.fmpz(-27)) == "-27"
assert bool(flint.fmpz(0)) == False
assert bool(flint.fmpz(1)) == True
def main():
''' The sum of totient values up to n gives the number of reduced proper
fractions with denominator less than or equal to n '''
print(sum(fmpz.euler_phi(fmpz(x)) for x in range(2, 10**6+1)))
def test_fmpz_poly():
Z = flint.fmpz_poly
assert Z() == Z([])
assert Z() == Z([0])
assert Z() == Z([0,flint.fmpz(0),0])
assert Z() == Z([0,0L,0])
assert Z() != Z([1])
assert Z([1]) == Z([1L])
assert Z([1]) == Z([flint.fmpz(1)])
assert Z(Z([1,2])) == Z([1,2])
for ztype in [int, long, flint.fmpz]:
assert Z([1,2,3]) + ztype(5) == Z([6,2,3])
assert ztype(5) + Z([1,2,3]) == Z([6,2,3])
assert Z([1,2,3]) - ztype(5) == Z([-4,2,3])
assert ztype(5) - Z([1,2,3]) == Z([4,-2,-3])
assert Z([1,2,3]) * ztype(5) == Z([5,10,15])
assert ztype(5) * Z([1,2,3]) == Z([5,10,15])
assert Z([11,6,2]) // ztype(5) == Z([2,1])
assert ztype(5) // Z([-2]) == Z([-3])
assert ztype(5) // Z([1,2]) == 0
assert Z([11,6,2]) % ztype(5) == Z([1,1,2])
assert ztype(5) % Z([-2]) == Z([-1])
assert ztype(5) % Z([1,2]) == 5
assert Z([1,2,3]) ** ztype(0) == 1
assert Z([1,2,3]) ** ztype(1) == Z([1,2,3])
assert Z([1,2,3]) ** ztype(2) == Z([1,4,10,12,9])
assert +Z([1,2]) == Z([1,2])
assert -Z([1,2]) == Z([-1,-2])
assert raises(lambda: Z([1,2,3]) ** -1, (OverflowError, ValueError))
assert raises(lambda: Z([1,2,3]) ** Z([1,2]), TypeError)
assert raises(lambda: Z([1,2]) // Z([]), ZeroDivisionError)
assert raises(lambda: Z([]) // Z([]), ZeroDivisionError)
assert raises(lambda: Z([1,2]) % Z([]), ZeroDivisionError)
assert raises(lambda: divmod(Z([1,2]), Z([])), ZeroDivisionError)
assert Z([]).degree() == -1
assert Z([]).length() == 0
p = Z([1,2])
assert p.length() == 2
assert p.degree() == 1
assert p[0] == 1
assert p[1] == 2
assert p[2] == 0
assert p[-1] == 0
assert raises(lambda: p.__setitem__(-1, 1), ValueError)
p[0] = 3
assert p[0] == 3
p[4] = 7
assert p.degree() == 4
assert p[4] == 7
assert p[3] == 0
p[4] = 0
assert p.degree() == 1
assert p.coeffs() == [3,2]
assert Z([]).coeffs() == []
assert bool(Z([])) == False
assert bool(Z([1])) == True
assert repr(Z([1,2])) == "fmpz_poly([1, 2])"
assert str(Z([1,2])) == "2*x+1"
p = Z([3,4,5])
assert p(2) == 31
assert p(flint.fmpq(2,3)) == flint.fmpq(71,9)
assert p(Z([1,-1])) == Z([12,-14,5])
assert p(flint.fmpq_poly([2,3],5)) == flint.fmpq_poly([27,24,9],5)
def string2int(s):
# return int.from_bytes(s.encode("utf-8"), byteorder = "big")
return fmpz(number.bytes_to_long(s.encode("utf-8")))
