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