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_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 __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 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_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 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 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 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 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.
"""
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 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 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 test_good6(self):
self.int = Integer.check_integer("00.5493840")
correct_int = 1
self.assertEqual(correct_int, self.int)
def test_good4(self):
self.int = Integer.check_integer("56.4792")
correct_int = 57
self.assertEqual(correct_int, self.int)
def test_good5(self):
self.int = Integer.check_integer("43.201947")
correct_int = 43
self.assertEqual(correct_int, self.int)
def division(a):
a1 = Integer(str(a))
text = "sqrt(" + a + ")=" + str(Integer.sqrt(a1))
return text
def test_middle3(self):
self.int = Integer.check_integer("43254.34981")
correct_int = 43254
self.assertEqual(correct_int, self.int)
def sum(a, b):
a1 = Integer(str(a))
b1 = Integer(str(b))
text = a + " = (" + b + ") * (" + str(a1//b1) + ") +" + 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")
# to create a binary file use: dd if=/dev/random of=file2.bin bs=1m count=200
host = sys.argv[1]
try:
port = int(sys.argv[2])
except StandardError:
port = 5006
address = (host,port)
BLOCK_SIZE = 1024
INDEX_SIZE = 8
buf = BLOCK_SIZE - INDEX_SIZE
# NO LONGER NEEDED BECAUSE THIS IS NOT SERIALIZED DATA - WE ARE NOT SENDING IT
# filename = sys.argv[2]
# example_message = "Start."
# client_socket.sendto(example_message, address)
integer_by = Integer(73)
integer_by.set(37)
data_by = integer_by
# data_by = [ { 'a':'A', 'b':2, 'c':3.0 } ]
# print 'DATA:',
# pprint.pprint(data_by)
data_string_by = pickle.dumps(data_by)
client_socket.sendto(data_string_by, address)
# print 'PICKLE:', data_string_by
client_socket.close()
def test_good7(self):
self.int = Integer.check_integer("0.14837")
correct_int = 0
self.assertEqual(correct_int, self.int)
def test_gcd(a, b):
assert Integer.gcd(a, b) == math.gcd(a, b)
class Rational:
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 __str__(self):
'''Строковое представление рационального числа, Васильев Максим'''
# Возвращает строку вида 'num/den'
return '{}/{}'.format(self.numer, self.denom)
def __neg__(self):
'''Умножение дроби на -1, Васильев Максим'''
# Меняем знак на противоположный у числителя
a = Rational(str(self))
a.numer = -a.numer
# Возвращаем <object Rational>
return a
def __gt__(self, oth):
'''Сравнение двух дробей, Васильев Максим'''
# Смотрим на знак разности двух дробей, если
# отрицательный, то дробь больше, иначе меньше
return (oth - self).numer.negative
def isZero(self):
'''Проверка дроби на ноль, Васильев Максим'''
# Проверяем знаменатель на ноль, уже имеющимся методом
return self.numer.isZero()
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 __sub__(self, oth):
'''Вычитание рациональных чисел, Васильев Максим'''
# Аналогично с целыми
# Возращаем <object Rational>
return self + -oth
def __mul__(self, oth):
'''Умножение рациональных чисел, Гусева Екатерина'''
# Умножаем числители и знаменатели и сокращаем их
# Возвращаем <object Rational>
return Rational(
str(self.numer * oth.numer) + '/' +
str(self.denom * oth.denom)).red()
def isInteger(self):
'''Проверка, является ли дробь - целым, Васильев Максим'''
# Проверяем делится ли числитель на знаменатель нацело,
# остаток от деления - 0
# Возвращаем <object Bool>
return (self.numer.ton() % self.denom).isZero()
def red(self):
'''Сокращение дроби, Гусева Екатерина'''
num = self.numer.ton()
den = self.denom
# Находим НОД числителя и знаменателя
gcd = num.gcd(den)
# Делим числитель и знаменатель на НОД
self.numer.digits = (num // gcd).digits
self.denom = den // gcd
# Возвращаем <object Rational>
return self
def abs(self):
self.numer.negative = False
return self
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 __truediv__(self, oth):
'''Деление рациональных, Васильев Максим'''
# Сводим деление к умножению на обратное
# Возвращаем <object Rational>
return self * oth.turn()
def isNegative(self):
'''Возвращает True если отрицательный, False если положительный'''
return self.numer.negative
def toContinued(self):
'''Дробь в непрерывную, Васильев Максим'''
a = Natural(str(self.numer.abs()))
b = Natural(str(self.denom))
res = ''
# Применяем алгоритм Евклида к дробям, записываем
# в res строку вида '1 2 3 4 5' где цифры - остатки
# от деления
while not a.isZero() and not b.isZero():
if a > b:
res += str(a // b) + ' '
a = a % b
else:
res += str(b // a) + ' '
b = b % a
# Вызываем функцию которая возвращает красивое представление
# непрерывной дроби
# Возвращает <object String>
return contForm(res)
def toi(self):
'''Преобразование в целое рационального, Васильев Максим'''
self.red()
# Если знаменатель после сокращения равен 1 - то число целое
if self.denom == Natural('1'):
# Возвращаем <object Integer>
return Integer(str(self.numer))
return self
def sum(a, b):
a1 = Integer(str(a))
b1 = Integer(str(b))
text = a + " ** " + b + " = " + str(a1 ** b1)
return text
def test_vgood8(self):
self.int = Integer.check_integer("1897000")
correct_int = 1897000
self.assertEqual(correct_int, self.int)
def setUp(self):
self.int = Integer.check_integer("")
def __new__(cls, v):
return Integer.__new__(cls, fix(v))
def test_vbad0(self):
self.int = Integer.check_integer("teoirfhjnhd .")
correct_int = 0
self.assertEqual(correct_int, self.int)
import pickle
#usage: python server.py (servername)
os.system('clear')
# Hard coded a list of servers & ports
SERVERS = {}
SERVERS["s1"] = ('localhost', 1000)
SERVERS["s2"] = ('localhost', 2000)
NUM_SERVERS = 2
# Dict of integers
DATA_LIB = {}
TOTAL_ORDERING = Integer('server_order')
COUNTER = Integer('meow')
COUNTER.set(0)
# Server name of this server
THIS_SERVER = sys.argv[1]
# The waiting queue for this server
# the key is the HOST,PORT of the client
# then it gives back an array: [jobNumber, remaining waiting servers, actual commands]
JOB_QUEUE = {}
# locks
lock = threading.Lock()
class ClientRequestHandler(SocketServer.BaseRequestHandler):
def handle(self):
def test_bad1(self):
self.int = Integer.check_integer("3.4e+14")
correct_int = 3
self.assertEqual(correct_int, self.int)
def test_bad2(self):
self.int = Integer.check_integer(" 543hui.340235")
correct_int = 543
self.assertEqual(correct_int, self.int)
def division(a):
a1 = Integer(str(a))
text = a + "=" + str(Integer.ferma(a1))
return text
