def test_totatives(z):
assert isinstance(Integer(z).totatives, set)
if z <= 0:
assert not Integer(z).totatives
else:
assert Integer(z).totatives == {x for x in range(1, z + 1)
if Integer.gcd(z, x) == 1}
def test_primalidad(n, k):
two = Integer("2")
one = Integer("1")
zero = Integer("0")
if (n.equals(two)):
return "PRIMO"
elif (n.is_even() or n.is_power()):
return "COMPUESTO"
else:
a = []
for i in range(0, k):
a.append(random.randint(1, n.to_int() - 1))
b = []
for a_i in a:
integer_ai = Integer(str(a_i))
gcd_i = integer_ai.gcd(n)
if (gcd_i.greater_than(one)):
return "COMPUESTO"
else:
exponent = n.substract(one).divide(two)[0]
b_i = integer_ai.exp_mod(exponent, n)
b.append(b_i)
neg = 0
for b_i in b:
if (b_i.add(one).module(n).equals(zero)):
neg += 1
elif (not b_i.substract(one).module(n).equals(zero)):
return "COMPUESTO"
if (neg == 0):
print("-------------break 4-------------------")
return "COMPUESTO"
else:
return "PRIMO"
def test_is_mersenne_prime(z):
if z <= 0:
assert not Integer(z).is_mersenne_prime
else:
if math.log(z+1, 2).is_integer() and is_prime(z):
assert Integer(z).is_mersenne_prime
else:
assert not Integer(z).is_mersenne_prime
def test_factorial(z):
if z < 0:
with pt.raises(ValueError):
Integer(z).factorial
elif z == 0:
assert Integer(z).factorial == 1
else:
assert Integer(z).factorial == math.factorial(z)
def test_tau(z):
if z <= 0:
assert Integer(z).tau == 0
elif z == 1:
assert Integer(z).tau == 1
else:
Z = Integer(z)
assert Z.tau == reduce(operator.mul,
(z + 1 for z in Z.decomposition.values()))
def test_goldbach_partitions(z):
expected = set()
if z % 2:
assert Integer(z).goldbach_partitions == expected
else:
expected = set(filter(lambda x: is_prime(x[0]) and is_prime(x[1]),
zip(range(z//2+1),
(z - x for x in range(z//2+1)))))
assert Integer(z).goldbach_partitions == expected
def test_euler_totient(z):
# Euler's product formula
if z < 0:
assert not Integer(z).euler_totient
else:
assert Integer(z).euler_totient == \
int(reduce(operator.mul,
((1 - 1. / k) for k in Integer(z).decomposition.keys()),
z))
def test_divisors(z):
# Using itertools, take Integer.decomposition and get every
# combination of key ** value for every key and every 0, ..., value
# THIS IS A SUFFICIENCY PROOF, BUT NOT NECESSESITY PROOF
assert all(z % f == 0 for f in Integer(z).divisors)
# THIS IS A COPOUT: COPYING THE LOGIC OF THE PROPERTY
assert Integer(z).divisors == {x for x in range(1, z//2 + 1)
if z % x == 0}
def test_is_mersenne(z):
if z <= 0:
assert not Integer(z).is_mersenne
# this breaks due to is_power_of not being implemented for negatives
# with pt.raises(NotImplementedError):
# Integer(z).is_mersenne
else:
if math.log(z+1, 2).is_integer():
assert Integer(z).is_mersenne
else:
assert not Integer(z).is_mersenne
def test_is_perfect_power(z, k):
if k <= 0:
with pt.raises(ValueError):
Integer(z).is_perfect_power(k)
elif k == 1:
assert Integer(z).is_perfect_power(k)
else:
if (z ** (1/k)).is_integer():
assert Integer(z).is_perfect_power(k)
else:
assert not Integer(z).is_perfect_power(k)
def test_is_squarefree(z):
Z = Integer(z)
if z < 1:
assert not Z.is_squarefree
elif z == 1:
assert Z.is_squarefree
else:
squares_up_to_z = (i for i in range(2, z+1)
if Integer(i).is_perfect_power(2))
if any(z % i == 0 for i in squares_up_to_z):
assert not Z.is_squarefree
else:
assert Z.is_squarefree
def __add__(self, oth):
'''Сложение рациональных чисел, Гусева Екатерина'''
a = Rational(str(self))
b = Rational(str(oth))
# n_den - НОК знаменателей
n_den = a.denom.lcm(b.denom)
# Коэффицент на который домножаем первый числитель
a_k = n_den // a.denom
# Коэффициент на который домножжаем второй числитель
b_k = n_den // b.denom
# Умножаем коэффициенты и числители, знаменатель - НОК
n_num = a.numer * Integer(str(a_k)) + b.numer * Integer(str(b_k))
# Возвращаем <object Rational>
return Rational(str(n_num) + '/' + str(n_den))
def test_nearest_prime(z):
def generate_primes_before_n(n):
p = generate_primes()
largest_so_far = next(p)
while largest_so_far < n:
yield largest_so_far
largest_so_far = next(p)
def generate_primes_after_n(n):
p = generate_primes()
largest_so_far = next(p)
while largest_so_far < n:
largest_so_far = next(p)
yield largest_so_far
while True:
yield next(p)
np = Integer(z).nearest_prime
if z <= 0:
assert np == (2,)
elif is_prime(z):
assert np == (z,)
else:
closest_before_z = max(generate_primes_before_n(z))
closest_after_z = next(generate_primes_after_n(z))
if abs(z - closest_before_z) == abs(z - closest_after_z):
assert np == (closest_before_z, closest_after_z)
else:
assert np == (min(closest_after_z, closest_before_z,
key=lambda n, z=z: abs(z-n)),)
def zeta(self, n=2):
"""
Return a primitive `n`-th root of unity.
INPUT:
- ``n`` - an integer (default: 2)
OUTPUT: a complex `n`-th root of unity.
EXAMPLES::
sage: C = ComplexField()
sage: C.zeta(2)
-1.00000000000000
sage: C.zeta(5)
0.309016994374947 + 0.951056516295154*I
"""
from integer import Integer
n = Integer(n)
if n == 1:
x = self(1)
elif n == 2:
x = self(-1)
elif n >= 3:
# Use De Moivre
# e^(2*pi*i/n) = cos(2pi/n) + i *sin(2pi/n)
RR = self._real_field()
pi = RR.pi()
z = 2 * pi / n
x = complex_number.ComplexNumber(self, z.cos(), z.sin())
x._set_multiplicative_order(n)
return x
def zeta(self, n=2):
"""
Return a primitive `n`-th root of unity.
INPUT:
- ``n`` - an integer (default: 2)
OUTPUT: a complex n-th root of unity.
"""
from integer import Integer
n = Integer(n)
if n == 1:
x = self(1)
elif n == 2:
x = self(-1)
elif n >= 3:
# Use De Moivre
# e^(2*pi*i/n) = cos(2pi/n) + i *sin(2pi/n)
RR = self._real_field()
pi = RR.pi()
z = 2*pi/n
x = complex_number.ComplexNumber(self, z.cos(), z.sin())
x._set_multiplicative_order( n )
return x
def toi(self):
'''Преобразование в целое рационального, Васильев Максим'''
self.red()
# Если знаменатель после сокращения равен 1 - то число целое
if self.denom == Natural('1'):
# Возвращаем <object Integer>
return Integer(str(self.numer))
return self
def __init__(self, str):
'''Конструктор рационального числа, Васильев Максим'''
# self.numer - хранит числитель (numerator), self.denom
# хранит знаменатель (denominant), числа вводятся в виде
# num/den
a = str.split('/')
self.numer = Integer(a[0])
self.denom = Natural(a[1])
def turn(self):
'''Получение вида 1/x - для дроби, Васильев Максим'''
# Числитель становится знаменателем
# Знаменатель числителем
n_den = Natural(str(self.numer.abs()))
n_num = Integer(str(self.denom))
n_num.negative = self.numer.negative
# Возвращаем <object Rational>
return Rational(str(n_num) + '/' + str(n_den))
def save(n, prob_type, num_objs, obj_1_name, obj_2_name, obj_3_name,
obj_1_goal, obj_2_goal, obj_3_goal, enc_type, gene_size,
min_value, max_value):
if None in (n, prob_type, num_objs, min_value, max_value):
raise PreventUpdate
elif num_objs == 1 and None in (obj_1_name, obj_1_goal):
raise PreventUpdate
elif num_objs == 2 and None in (obj_1_name, obj_1_goal, obj_2_name,
obj_2_goal):
raise PreventUpdate
elif num_objs == 3 and None in (obj_1_name, obj_1_goal, obj_2_name,
obj_2_goal, obj_3_name, obj_3_goal):
raise PreventUpdate
elif gene_size is not None and gene_size < 0:
raise PreventUpdate
elif min_value is not None and min_value >= max_value:
raise PreventUpdate
elif max_value is not None and max_value <= min_value:
raise PreventUpdate
if prob_type == 'sing-obj':
configs.params['prob_type'] = Single(configs.params)
else:
configs.params['prob_type'] = Multi(configs.params)
configs.params['num_objs'] = num_objs
configs.params['objs'], configs.params['obj_names'] = [], []
dirs, names = [obj_1_goal, obj_2_goal,
obj_3_goal], [obj_1_name, obj_2_name, obj_3_name]
for i in range(configs.params['num_objs']):
if dirs[i] == 'min':
configs.params['objs'].append(min)
else:
configs.params['objs'].append(max)
configs.params['obj_names'].append(names[i])
if enc_type == 'perm':
configs.params['enc_name'] = 'Permutation'
configs.params['enc_type'] = Perm(configs.params)
elif enc_type == 'binary':
configs.params['enc_name'] = 'Binary String'
configs.params['enc_type'] = Binary(configs.params)
elif enc_type == 'int':
configs.params['enc_name'] = 'Integer String'
configs.params['enc_type'] = Integer(configs.params)
elif enc_type == 'real':
configs.params['enc_name'] = 'Real-Valued String'
configs.params['enc_type'] = Real(configs.params)
configs.params['gene_size'] = gene_size
configs.params['enc_type'].params['min_value'] = min_value
configs.params['enc_type'].params['max_value'] = max_value
return 'Saved'
def get_tuples(file_dir):
f = open(file_dir, "r")
read = f.read().split(", ")
f.close()
tests = []
for i in range(0, len(read), 2):
elem = read[i].rstrip()
if (i + 1 < len(read)):
k = read[i + 1].rstrip()
tests.append((Integer(elem), int(k)))
else:
print("The file does not match (odd quantity of numbers)")
exit(0)
return tests
def test_division(z1, z2):
if z2 == 0:
with pt.raises(ZeroDivisionError):
Integer(z1) / z2
with pt.raises(ZeroDivisionError):
z1 / Integer(z2)
else:
assert (z1 / z2) == (Integer(z1) / Integer(z2)) == \
(z1 / Integer(z2)) == (Integer(z1) / z2)
def test_is_power_of(z, n):
if z < 0:
with pt.raises(NotImplementedError):
Integer(z).is_power_of(n)
elif z == 0:
assert not Integer(z).is_power_of(n)
elif z == 1:
assert Integer(z).is_power_of(n)
else:
if n < 0:
with pt.raises(ValueError):
Integer(z).is_power_of(n)
elif n == 0:
assert not Integer(z).is_power_of(n)
elif n == 1:
assert not Integer(z).is_power_of(n)
else:
f = math.log(z, n)
if f.is_integer():
assert Integer(z).is_power_of(n)
else:
assert not Integer(z).is_power_of(n)
def zeta(self, n=2):
r"""
Return a primitive `n`-th root of unity.
.. TODO::
Implement :class:`ComplexIntervalFieldElement` multiplicative order
and set this output to have multiplicative order ``n``.
INPUT:
- ``n`` -- an integer (default: 2)
OUTPUT:
A complex `n`-th root of unity.
EXAMPLES::
sage: CIF.zeta(2)
-1
sage: CIF.zeta(5)
0.309016994374948? + 0.9510565162951536?*I
"""
from integer import Integer
n = Integer(n)
if n == 1:
x = self(1)
elif n == 2:
x = self(-1)
elif n >= 3:
# Use De Moivre
# e^(2*pi*i/n) = cos(2pi/n) + i *sin(2pi/n)
RR = self._real_field()
pi = RR.pi()
z = 2 * pi / n
x = complex_interval.ComplexIntervalFieldElement(
self, z.cos(), z.sin())
# Uncomment after implemented
#x._set_multiplicative_order( n )
return x
def create_request(student_id, course_id):
student = session.query(Student).filter(
Student.id == student_id).one_or_none()
if student is None:
return 'The student doesn`t exist', 400
course = session.query(Course).filter(Course.id == course_id).one_or_none()
if course is None:
return 'The course doesn`t exist', 400
if auth.current_user() != student.email:
return 'You don`t have a permission to create request!', 401
if course.student_number > 5:
return 'You can not join this course', 500
request_schema = RequestSchema()
temp_id = Integer(str(student_id) + str(course_id))
data = {
'id': temp_id,
'status': 'placed',
'student_id': student_id,
'course_id': course_id,
}
if not session.query(Request).filter(
Request.id == temp_id).one_or_none() is None:
return 'This request has been sent earlier. Wait for approving', 400
try:
request_course = request_schema.load(data)
except ValidationError as err:
return err.messages, 400
session.add(request_course)
session.commit()
return 'Request has been sent'
def sum(a, b):
a1 = Integer(str(a))
b1 = Integer(str(b))
text = a + " / " + b + " = " + str(a1 // b1)
return text
for tupla in tests:
res = test_primalidad(tupla[0], tupla[1])
results.append(res)
write_results(results, "output.txt")
print("Done.\n")
else:
print("You must enter a file name")
elif (user_input == 2):
user_input = input("Enter the number you want to know if is prime: ")
n_raw = user_input.rstrip()
user_input = input("Enter the quantity of random numbers you want: ")
k_raw = user_input.rstrip()
if (n_raw != "" and k_raw != ""):
print("Calculating...")
n = Integer(n_raw)
k = int(k_raw)
print(test_primalidad(n, k) + "\n")
else:
print("You must enter both numbers")
elif (user_input == 3):
print("Exiting...")
exit = True
else:
print("You must select a valid option")
def sum(a, b):
a1 = Integer(str(a))
b1 = Integer(str(b))
text = a + " ** " + b + " = " + str(a1 ** b1)
return text
def sum(a, b):
a1 = Integer(str(a))
b1 = Integer(str(b))
text = a + " = (" + b + ") * (" + str(a1//b1) + ") +" + str(a1%b1)
return text
def division(a):
a1 = Integer(str(a))
text = a + "=" + str(Integer.ferma(a1))
return text
def division(a):
a1 = Integer(str(a))
text = "sqrt(" + a + ")=" + str(Integer.sqrt(a1))
return text
