def page_rank_calcualtor(vector, matrix):
old_vector = vector
new_vector = [Fraction() for x in range(len(vector))]
while True:
vector_index = 0
for matrix_row in matrix:
multiplication_sum = Fraction()
index = 0
for number in matrix_row:
multiplication_sum = multiplication_sum.__add__(
old_vector[index].__mul__(number))
index += 1
multiplication_sum = multiplication_sum.__mul__(Fraction(8, 10))
multiplication_sum = multiplication_sum.__add__(
Fraction(2, 10).__truediv__(Fraction(len(vector), 1)))
new_vector[vector_index] = multiplication_sum
vector_index += 1
# Comparing old and new vectors
min_difference = sys.maxsize
for index in range(len(new_vector)):
diff = abs(old_vector[index] - new_vector[index])
if diff < min_difference:
min_difference = diff
old_vector = [new_vector[x] for x in range(len(new_vector))]
if min_difference < 0.00001:
break
return new_vector
class TestFraction(unittest.TestCase):
def setUp(self):
self.fraction = Fraction(3, 4)
def test_smallest_denom(self):
self.assertEqual(self.fraction.smallest_denom(self.fraction.numerator,
self.fraction.denominator), 12)
def test_fraction_init(self):
self.assertEqual(self.fraction.numerator, 3)
self.assertEqual(self.fraction.denominator, 4)
def test_fraction_str(self):
self.assertEqual(str(self.fraction), "3 / 4")
def test_fraction_eq(self):
fraction2 = Fraction(3, 4)
fraction3 = Fraction(4, 5)
self.assertNotEqual(self.fraction, fraction3)
self.assertEqual(self.fraction, fraction2)
def test_fraction_mul(self):
fraction2 = Fraction(6, 7)
self.assertEqual(self.fraction.__mul__(fraction2), Fraction(9, 14))
def test_fraction_add(self):
fraction2 = Fraction(6, 7)
self.assertEqual(self.fraction.__add__(fraction2), Fraction(45, 28))
def test_fraction_sub(self):
fraction2 = Fraction(6, 7)
self.assertEqual(self.fraction.__sub__(fraction2), Fraction(-3, 28))
def main():
while True:
try:
num1 = float(input(" Enter the num1: "))
break
except:
print("Invalid input!")
while True:
try:
den1 = float(input(" Enter the den1: "))
if den1 == 0:
raise ZeroDivisionError
break
except:
print("Invalid input!")
while True:
try:
num2 = float(input(" Enter the num2: "))
break
except:
print("Invalid input!")
while True:
try:
den2 = float(input(" Enter the den2: "))
if den2 == 0:
raise ZeroDivisionError
break
except:
print("Invalid input!")
f1 = Fraction(num1,den1)
f2 = Fraction(num2,den2)
user = input("enter your choice: \n 1:add \n 2:sub \n 3:divide \n 4:__mul__ \n 5:compare \n ")
if user == "1":
print(f1.__add__(f2))
#break
elif user == "2":
print(f1.__sub__(f2))
#break
elif user == "3":
print(f1.__truediv__(f2))
#break
elif user == "4":
print(f1.__mul__(f2))
#break
elif user == "5":
print(f1.__eq__(f2))
#break
else:
print("Invalid input, pls try again\n")
def __add__(a,b):
f = Fraction.__add__(a,b)
return NotImplemented if f is NotImplemented else Quarters(f)
def __add__(self, other):
f = Fraction.__add__(self, other)
return PFraction(f)
class F(Fraction):
'''
Classe que representa um numero fracionario, extendendo fractions.Fraction, e implentando a lógica o "M grande"
'''
def __init__(self,n,m=Fraction(0)):
self.fraction = Fraction(n)
self.m = Fraction(m)
def __repr__(self):
"""repr(self)"""
return str(float(self.fraction)) if self.m == 0 else str(float(self.fraction)) + ' + (' + str(float(self.m)) + '*M)'
def __str__(self):
"""str(self)"""
return str(float(self.fraction)) if self.m == 0 else str(float(self.fraction)) + ' + (' + str(float(self.m)) + '*M)'
def __eq__(self, f):
"""a == b"""
if type(f) is not type(self):
f = F(f)
return self.fraction.__eq__(f.fraction) and self.m.__eq__(f.m)
def __add__(self, f):
"""a + b"""
if type(f) is not type(self):
f = F(f)
return F(self.fraction.__add__(f.fraction),self.m.__add__(f.m))
def ___sub__(self, f):
"""a - b"""
if type(f) is not type(self):
f = F(f)
return F(self.fraction.__sub__(f.fraction),self.m.___sub__(f.m))
def __mul__(self, f):
"""a * b"""
if type(f) is not type(self):
f = F(f)
if f.m == 0:
return F(self.fraction.__mul__(f.fraction))
else:
return F(self.fraction.__mul__(f.fraction),self.m.__mul__(f.m))
def __div__(self, f):
"""a / b"""
if type(f) is not type(self):
f = F(f)
if f.m == 0:
return F(self.fraction.__div__(f.fraction))
else:
return F(self.fraction.__div__(f.fraction),self.m.__div__(f.m))
def __lt__(self, f):
"""a < b"""
if type(f) is not type(self):
f = F(f)
if self.m == f.m:
return self.fraction.__lt__(f.fraction)
else:
return self.m.__lt__(f.m)
def __gt__(self, f):
"""a > b"""
if type(f) is not type(self):
f = F(f)
if self.m == f.m:
return self.fraction.__gt__(f.fraction)
else:
return self.m.__gt__(f.m)
def __le__(self, f):
"""a <= b"""
if type(f) is not type(self):
f = F(f)
if self.m == f.m:
return self.fraction.__le__(f.fraction)
else:
return self.m.__le__(f.m)
def __ge__(self, f):
"""a >= b"""
if type(f) is not type(self):
f = F(f)
if self.m == f.m:
return self.fraction.__ge__(f.fraction)
else:
return self.m.__ge__(f.m)
import mysql.connector
from fractions import Fraction
mydb = mysql.connector.connect(
host = "localhost"
user = "******"
password = "******"
)
print(mydb)
f = Fraction(3, 4)
f1 = Fraction(1, 2)
add = f.__add__(f1)
sub = f.__sub__(f1)
mul = f.__mul__(f1)
div = f.__truediv__(f1)
print(add, sub, mul, div)
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sat Apr 4 14:25:57 2020
@author: manuel
"""
from fractions import Fraction
#a)
f = Fraction(1, 2)
f1 = Fraction(8, 10)
print(f + f1)
print(
f.__add__(f1)) #object fraction as an argument. returns a fraction object
#b
f2 = Fraction(8, 10)
print(f1.__eq__(f2))
print(f1 == f2)
#c
print(f1) #note that the function is simplified
print(f1.__neg__())
print(-f1)
#d
print(f1.__gt__(f))
print(f1 > f)
class Angle:
"""Class of Mathematic Angle
> designed especially for angle in the format of DMS(Degree, Minute and Second)
> immutable object
> guarantee `0 <= degrees < 360`
`deg` (int): degree of the angle in the format of DMS;
`min` (int): minute of the angle in the format of DMS;
`sec` (float): second of the angle in the format of DMS;
`degrees` (float): degree of the angle in the format of ONLY degree;
`rad` (float): rad of the angle in the format of radians;
`atan2` (float, float): (x, y) of the angle in the format of 2D-vector;
"""
__deg: Fraction = Fraction(0)
def __init__(self, a: "Angle"):
self.__deg = Fraction(a.to_degrees() if isinstance(a, Angle) else a)
self.__adjust()
@classmethod
def from_dms(cls, deg: float, min: float = 0, sec: float = 0) -> "Angle":
"""Factory Method for Degree, Minute and Second
"""
return cls.from_degrees(degrees=Fraction(deg) + Fraction(min) / 60 +
Fraction(sec) / 3600)
@classmethod
def from_degrees(cls, degrees: float) -> "Angle":
"""Factory Method for ONLY Degree
"""
return cls(degrees)
@classmethod
def from_rad(cls, rad: float) -> "Angle":
"""Factory Method for Radian
"""
return cls.from_degrees(degrees=math.degrees(Fraction(rad)))
@classmethod
def from_atan2(cls, x: float, y: float) -> "Angle":
"""Factory Method for (x, y)
"""
return cls.from_rad(rad=math.atan2(Fraction(y), Fraction(x)))
@classmethod
def from_fmt_str(cls,
angle_str: str,
fmt: str = "aaa°bbb′ccc″") -> "Angle":
"""Factory Method for Formatted String
`aaa` is deg(int), `bbb` is minute(int), `ccc` is sec(float), `DDD` is only deg(float),
`RRR` is radian(float), `XXX` is horizontal ordinate(float), `YYY` is vertical ordinate(float).
> default: fmt = "aaa°bbb′ccc″"`
Eg.
>>> angle = Angle.from_fmt_str(angle_str="2°4′6″")
>>> angle.get_deg(), angle.get_min(), angle.get_sec()
2, 4, 6.0
>>> angle = Angle.from_fmt_str(angle_str="1D2M3S", fmt="aaaDbbbMcccS")
>>> angle.get_deg(), angle.get_min(), angle.get_sec()
1, 2, 3.0
>>> Angle.from_fmt_str(angle_str="1deg", fmt="DDDdeg").to_degrees()
1.0
>>> Angle.from_fmt_str(angle_str="1.57rad", fmt="RRRrad").to_rad()
1.57
>>> angle = Angle.from_fmt_str(angle_str="1.2, 3.4", fmt="XXX, YYY")
>>> angle.to_atan2()
1.2, 3.4
"""
import re
digit_pattern = "(-?\d+\.?\d*e?-?\d*?)"
# DMS
if fmt.find("aaa") >= 0 and fmt.find("bbb") >= 0 and fmt.find(
"ccc") >= 0:
pattern = (fmt.replace("aaa", digit_pattern, 1).replace(
"bbb", digit_pattern, 1).replace("ccc", digit_pattern, 1))
matched = re.match(pattern, angle_str)
if matched:
return cls.from_dms(deg=matched.group(1),
min=matched.group(2),
sec=matched.group(3))
# Degree
elif fmt.find("DDD") >= 0:
pattern = fmt.replace("DDD", digit_pattern, 1)
matched = re.match(pattern, angle_str)
if matched:
return cls.from_degrees(float(matched.group(1)))
# Radian
elif fmt.find("RRR") >= 0:
pattern = fmt.replace("RRR", digit_pattern, 1)
matched = re.match(pattern, angle_str)
if matched:
return cls.from_rad(float(matched.group(1)))
# (x, y)
elif fmt.find("XXX") >= 0 and fmt.find("YYY") >= 0:
pattern = fmt.replace("XXX", digit_pattern,
1).replace("YYY", digit_pattern, 1)
matched = re.match(pattern, angle_str)
if matched:
return cls.from_atan2(x=matched.group(1), y=matched.group(2))
raise Exception("Invalid fmt!")
return None
def __adjust(self):
"""Adjust the Format of the Angle, Satisfy: `0 <= __deg < 360`
"""
while self.__deg < 0:
self.__deg += 360
while self.__deg >= 360:
self.__deg -= 360
def get_deg(self) -> int:
"""Get deg in the fmt of DMS
"""
return int(float(self.__deg))
def get_min(self) -> int:
"""Get minute in the fmt of DMS
"""
return int((self.__deg - Fraction(self.get_deg())) * Fraction(60))
def get_sec(self) -> float:
"""Get sec in the fmt of DMS
"""
angle_min = self.__deg * 60
return float((angle_min - int(angle_min)) * 60)
def __add__(self, other: "Angle"):
"""(+)Calculate the sum of self and angle
"""
return self.from_degrees(self.__deg.__add__(other.__deg))
def __sub__(self, other: "Angle"):
"""(-)Calculate the difference of self(minuend) and angle(subtrahend)
"""
return self.from_degrees(self.__deg.__sub__(other.__deg))
def __mul__(self, n: float):
"""(*)Calculate the product of self and angle
"""
return self.from_degrees(self.__deg.__mul__(Fraction(n)))
def __truediv__(self, n: float):
"""(/)Calculate the true quotient of self(dividend) and angle(divisor)
"""
return self.from_degrees(self.__deg.__truediv__(Fraction(n)))
def __floordiv__(self, n: float):
"""(//)Calculate the floor quotient of self(dividend) and angle(divisor)
"""
return self.from_degrees(self.__deg.__floordiv__(Fraction(n)))
def __mod__(self, other: "Angle"):
"""(%)Calculate the remainder of self(dividend) and angle(divisor)
"""
return self.from_degrees(self.__deg.__mod__(other.__deg))
def __cmp__(self, other: "Angle"):
"""compare two angles
negative if self < other;
zero if self == other;
positive if self > other;
"""
return self.__deg - other.__deg
def __eq__(self, other: "Angle"):
"""==
"""
return self.__cmp__(other) == 0
def __ne__(self, other: "Angle"):
"""!=
"""
return self.__cmp__(other) != 0
def __le__(self, other: "Angle"):
"""\<=
"""
return self.__cmp__(other) <= 0
def __lt__(self, other: "Angle"):
"""\<
"""
return self.__cmp__(other) < 0
def __ge__(self, other: "Angle"):
"""\>=
"""
return self.__cmp__(other) >= 0
def __gt__(self, other: "Angle"):
"""\>
"""
return self.__cmp__(other) > 0
def __str__(self) -> str:
"""Convert angle into string(" " as interval)
"""
return "{:d} {:d} {:.2f}".format(self.get_deg(), self.get_min(),
self.get_sec())
def __hash__(self) -> int:
"""hash(self)
"""
return self.__deg.__hash__()
def to_degrees(self) -> float:
"""Convert angle into degrees(only deg(float) without minute & sec)
"""
return float(self.__deg)
def to_rad(self) -> float:
"""Convert angle into radians(float)
"""
return math.radians(self.to_degrees())
def to_atan2(self, x: float = None, y: float = None) -> (float, float):
"""Convert angle into `(x', y')` by `(x, y)`.
When one of x, y is None, calculate the value of the other one(if not None) that satisfies `y / x = tan`.
When both of x, y is Nones, returns (x', y') that satisfies `x'^2 + y'^2 = 1`, that is, `x' = cos, y' = sin`
When both of x, y is not None, return themselves if they are a coordinates of the valid ones, or raise Exception.
Eg.
>>> angle = Angle(deg=45)
>>> angle.to_atan2(x=1.0)
(1.0, 1.0)
>>> angle.to_atan2(y=2.0)
(2.0, 2.0)
>>> angle.to_atan2()
(0.707, 0.707)
"""
# base: tan = y / x
# default: x = cos, y = sin
if x is None and y is None:
return self.cos(), self.sin()
# calculate x by y
elif x is None:
return y / self.tan(), y # x = y / tan
# calculate y by x
elif y is None:
return x, x * self.tan() # y = x * tan
# x, y are both not None and valid
elif math.isclose(y / x, self.tan()):
return x, y # return themselves if checked
raise Exception("Invalid x,y pair!")
def to_fmt_str(self, fmt: str = "aaa°bbb′ccc″", decimal: int = 2) -> str:
"""Convert angle into string of fmt
`aaa` is deg(int), `bbb` is minute(int), `ccc` is sec(float), `DDD` is only deg(float),
`RRR` is radian(float), `XXX` is horizontal ordinate(float), `YYY` is vertical ordinate(float).
> default: fmt = "aaa°bbb′ccc″"`, decimal = 2
Eg.
>>> angle = Angle(45)
>>> angle.to_fmt_str()
2°4′6″
>>> angle.to_fmt_str(fmt="aaaDbbbMcccS")
3D5M7S
>>> angle.to_fmt_str(fmt="aaa bbb ccc")
1 4 9
>>> angle.to_fmt_str(fmt="DDDD")
123D
>>> angle.to_fmt_str(fmt="RRRrad")
1.99rad
>>> angle.to_fmt_str(fmt="XXX, YYY")
0.5, 0.87
"""
# DMS
if fmt.find("aaa") >= 0 and fmt.find("bbb") >= 0 and fmt.find(
"ccc") >= 0:
return (fmt.replace("aaa", str(self.get_deg()), 1) # deg
.replace("bbb", str(self.get_min()), 1) # minute
.replace("ccc",
("{:.%df}" % decimal).format(self.get_sec()),
1) # sec
)
# Degree
elif fmt.find("DDD") >= 0:
return fmt.replace("DDD",
("{:.%df}" % decimal).format(self.to_degrees()),
1)
# Radian
elif fmt.find("RRR") >= 0:
return fmt.replace("RRR",
("{:.%df}" % decimal).format(self.to_rad()), 1)
# (x, y)
elif fmt.find("XXX") >= 0 and fmt.find("YYY") >= 0:
x_y_pair = self.to_atan2() # get the tuple of (x, y)
return fmt.replace(
"XXX", ("{:.%df}" % decimal).format(x_y_pair[0])).replace(
"YYY", ("{:.%df}" % decimal).format(x_y_pair[1]))
raise Exception("Invalid fmt!")
def sin(self) -> float:
"""sinθ
"""
return math.sin(self.to_rad())
def cos(self) -> float:
"""cosθ
"""
return math.cos(self.to_rad())
def tan(self) -> float:
"""tanθ
"""
return math.tan(self.to_rad())
def is_zero_angle(self) -> bool:
"""Judge if it is zero angle, that is, 0°
"""
return math.isclose(self.to_degrees(), 0)
def is_acute_angle(self) -> bool:
"""Judge if it is acute angle(0°, 90°)
"""
return 0 < self.to_degrees() < 90
def is_right_angle(self) -> bool:
"""Judge if it is right angle, that is, 90°
"""
return math.isclose(self.to_degrees(), 90)
def is_obtuse_angle(self) -> bool:
"""Judge if it is obtuse angle(90°, 180°)
"""
return 90 < self.to_degrees() < 180
def is_minor_angle(self) -> bool:
"""Judge if it is minor angle(0°, 180°)
"""
return 0 < self.to_degrees() < 180
def is_straight_angle(self) -> bool:
"""Judge if it is right angle, that is, 180°
"""
return math.isclose(self.to_degrees(), 180)
def is_major_angle(self) -> bool:
"""Judge if it is major angle(180°, 360°)
"""
return 180 < self.to_degrees() < 360
def is_complementary_angle_with(self, other: "Angle") -> bool:
"""Judge if they are complementary angles
"""
return math.isclose((self + other).to_degrees(), 90)
def is_supplementary_angle_with(self, other: "Angle") -> bool:
"""Judge if they are supplementary angles
"""
return math.isclose((self + other).to_degrees(), 180)
class F(Fraction):
'''
Classe que representa um numero fracionario, extendendo fractions.Fraction
'''
def __init__(self, n, m=Fraction(0)):
self.fraction = Fraction(n)
self.m = Fraction(m)
def __repr__(self):
"""repr(self)"""
return str(float(self.fraction)) if self.m == 0 else str(
float(self.fraction)) + ' + (' + str(float(self.m)) + '*M)'
def __str__(self):
"""str(self)"""
return str(float(self.fraction)) if self.m == 0 else str(
float(self.fraction)) + ' + (' + str(float(self.m)) + '*M)'
def __eq__(self, f):
"""a == b"""
if type(f) is not type(self):
f = F(f)
return self.fraction.__eq__(f.fraction) and self.m.__eq__(f.m)
def __add__(self, f):
"""a + b"""
if type(f) is not type(self):
f = F(f)
return F(self.fraction.__add__(f.fraction), self.m.__add__(f.m))
def ___sub__(self, f):
"""a - b"""
if type(f) is not type(self):
f = F(f)
return F(self.fraction.__sub__(f.fraction), self.m.___sub__(f.m))
def __mul__(self, f):
"""a * b"""
if type(f) is not type(self):
f = F(f)
if f.m == 0:
return F(self.fraction.__mul__(f.fraction))
else:
return F(self.fraction.__mul__(f.fraction), self.m.__mul__(f.m))
def __div__(self, f):
"""a / b"""
if type(f) is not type(self):
f = F(f)
if f.m == 0:
return F(self.fraction.__div__(f.fraction))
else:
return F(self.fraction.__div__(f.fraction), self.m.__div__(f.m))
def __lt__(self, f):
"""a < b"""
if type(f) is not type(self):
f = F(f)
if self.m == f.m:
return self.fraction.__lt__(f.fraction)
else:
return self.m.__lt__(f.m)
def __gt__(self, f):
"""a > b"""
if type(f) is not type(self):
f = F(f)
if self.m == f.m:
return self.fraction.__gt__(f.fraction)
else:
return self.m.__gt__(f.m)
def __le__(self, f):
"""a <= b"""
if type(f) is not type(self):
f = F(f)
if self.m == f.m:
return self.fraction.__le__(f.fraction)
else:
return self.m.__le__(f.m)
def __ge__(self, f):
"""a >= b"""
if type(f) is not type(self):
f = F(f)
if self.m == f.m:
return self.fraction.__ge__(f.fraction)
else:
return self.m.__ge__(f.m)
