def __add__(self, right):
Fraction._validate_arithmetic(right, {Fraction, int}, '+',
type_as_str(self), type_as_str(right))
if type(right) == int:
right = Fraction(right)
return Fraction((self.num * right.denom) + (self.denom * right.num),
self.denom * right.denom)
def __delitem__(self,index):
if type(index) != int:
raise TypeError('Index must be type int. Type {} given.'.format(type_as_str(type(index))))
if index < 0:
raise TypeError('Index must be greater than 0. {} < 0.'.format(type_as_str(index)))
if index in self.terms.keys():
del self.terms[index]
def __init__(self, x, y):
assert type(x) is int, 'Point.__init__: x(' + str(
x) + ') is not an int(' + type_as_str(x) + ')'
assert type(y) is int, 'Point.__init__: y(' + str(
y) + ') is not an int(' + type_as_str(y) + ')'
self.x = x
self.y = y
def __mul__(self, right):
if type(right) not in [int, float, Sparse_Matrix]:
raise TypeError('unsupported operand type(s) for +' + ': \'' +
type_as_str(self) + '\' and \'' +
type_as_str(right) + '\'')
if type(self) is Sparse_Matrix and type(right) is Sparse_Matrix:
if self.cols != right.rows:
raise AssertionError("Size of two Sparse_Matrix are not equal")
nm = Sparse_Matrix(self.rows, right.cols)
for index in range(self.rows):
for indexs in range(right.cols):
num = self.row(index)
nums = right.col(indexs)
xs = 0
xy = None
if len(num) > len(nums):
xy = num
else:
xy = nums
for x in range(len(xy)):
xs += num[x] * nums[x]
nm[index, indexs] = xs
return nm
if type(right) in [int, float]:
nm = Sparse_Matrix(self.rows, self.cols)
for index in range(self.rows):
for indexs in range(self.cols):
fr = self.matrix.get((index, indexs), 0) * right
nm[index, indexs] = fr
return nm
def __gt__(self, right):
Fraction._validate_relational(right, {Fraction, int}, '>',
type_as_str(right))
if type_as_str(right) == "int":
return self.num > self.denom * right
elif type_as_str(right) == "fraction.Fraction":
return self.num * right.denom > right.num * self.denom
def __rmul__(self, left):
Fraction._validate_arithmetic(left, {Fraction, int}, '*',
type_as_str(left), 'Fraction')
if type_as_str(left) == "int":
return Fraction(self.num * left, self.denom)
elif type_as_str(left) == "fraction.Fraction":
return Fraction(self.num * left.num, self.denom * left.denom)
def error_message():
if type(annot) is type:
return "AssertionError: " + repr(param) + " failed annotation check(wrong type): value = " + repr(value[param]) + \
"\n was type " + type_as_str(value[param]) + " ...should be type " + str(annot.__name__) + "\n" + ''.join(check_history_list)
else:
return "AssertionError: " + repr(param) + " failed annotation check(wrong type): value = " + repr(value[param]) + \
"\n was type " + type_as_str(value[param]) + " ...should be type " + str(type(annot).__name__) + "\n" + ''.join(check_history_list)
def __mul__(self, right):
Fraction._validate_arithmetic(right, {Fraction, int}, '*', 'Fraction',
type_as_str(right))
if type_as_str(right) == "int":
return Fraction(self.num * right, self.denom)
elif type_as_str(right) == "fraction.Fraction":
return Fraction(self.num * right.num, self.denom * right.denom)
def __radd__(self,left):
answer = Poly()
if 'Poly' not in type_as_str(self) or type_as_str(left) not in ['int', 'float']\
and 'Poly' not in type_as_str(left):
raise TypeError('Operands must be of type Poly and Poly or int or float')
elif 'Poly' in type_as_str(self) and 'Poly' in type_as_str(left):
for power in self.terms:
answer._add_term(self.terms[power], power)
for power in left.terms:
if power in answer.terms:
answer.terms[power] += left.terms[power]
else:
answer._add_term(left.terms[power], power)
else:
for power in self.terms:
answer._add_term(self.terms[power], power)
if 0 in answer.terms:
answer.terms[0] += left
else:
answer._add_term(left,0)
return answer
def __gt__(self,right):
if type(right) == DictList:
return set(self.items()) > set(DictList.items(right))
elif type(right) == dict:
return set(self.items()) > set((x,y) for x,y in right.items())
else:
raise TypeError("unorderable types: " +type_as_str(self)+"() and "+type_as_str(right)+"()")
def _validate_addsub(l,r,op):
Dimensional._validate_relational(l,r,op)
if type(l) in [int,float] and r['d'] != (0,0,0):
raise DimensionError('incompatible dimensions for '+op+
': \''+type_as_str(l)+'\' and \''+str(r['d'])+'\'')
if type(r) in [int,float] and l['d'] != (0,0,0):
raise DimensionError('incompatible dimensions for '+op+
': \''+str(l['d'])+'\' and \''+type_as_str(r)+'\'')
def __add__(self, right):
if type(right) != type(self):
raise TypeError('unsupported operand type(s) for +' + ': \'' +
type_as_str(self) + '\' and \'' +
type_as_str(right) + '\'')
new_coords = [(x + y)
for x, y in zip(self.coordinates, right.coordinates)]
return Point(new_coords[0], new_coords[1], new_coords[2])
def __add__(self, right):
n_list = []
if type(right) is not Bag:
raise TypeError('unsupported operand type(s) for +' + ': \'' +
type_as_str(self) + '\' and \'' +
type_as_str(right) + '\'')
n_list.extend(self.__item_list)
n_list.extend(right.__item_list)
return Bag(n_list)
def check_list(type_item):
assert isinstance(value, type_item),error_message(error = 'incorrect type')
if len(annot) == 1:
for i in range(len(value)):
self.check(param, annot[0], value[i], check_history + '\n' + type_as_str((annot)) + str([i]) + 'check: '+str(annot[0]))
elif len(annot) > 1:
assert len(annot) == len(value), error_message( error = 'wrong number')
for i in range(len(annot)):
self.check(param, annot[i], value[i], check_history + '\n' + type_as_str((annot)) + str([i]) + 'check: '+str(annot[i]))
def __rtruediv__(self, left):
Fraction._validate_arithmetic(left, {Fraction, int}, '/',
type_as_str(left), 'Fraction')
if type_as_str(left) == "int":
if left == 0:
raise ZeroDivisionError
return Fraction(self.denom * left, self.num)
elif type_as_str(left) == "fraction.Fraction":
return Fraction(self.denom * left.num, self.num * left.denom)
def __truediv__(self, right):
Fraction._validate_arithmetic(right, {Fraction, int}, '/', 'Fraction',
type_as_str(right))
if type_as_str(right) == "int":
if right == 0:
raise ZeroDivisionError
return Fraction(self.num, self.denom * right)
elif type_as_str(right) == "fraction.Fraction":
return Fraction(self.num * right.denom, self.denom * right.num)
def __pow__(self,right):
if type(right) is not int:
raise TypeError('unsupported operand type(s) for **'+
': \''+type_as_str(self)+'\' and \''+type_as_str(right)+'\'')
mult = (self if right >= 0 else 1/self)
answer = Interval(1.,1.)
for _ in range(abs(right)):
answer *= mult
return answer
def _validate_addsub(l, r, op):
Dimensional._validate_relational(l, r, op)
if type(l) in [int, float] and r['d'] != (0, 0, 0):
raise DimensionError('incompatible dimensions for ' + op + ': \'' +
type_as_str(l) + '\' and \'' + str(r['d']) +
'\'')
if type(r) in [int, float] and l['d'] != (0, 0, 0):
raise DimensionError('incompatible dimensions for ' + op + ': \'' +
str(l['d']) + '\' and \'' + type_as_str(r) +
'\'')
def __call__(self,arg):
num = 0
if type_as_str(arg) != 'int' and type_as_str(arg) != 'float':
raise TypeError
else:
for i in self.terms.keys():
newnum = arg**i
newnum = newnum * self.terms[i]
num += newnum
return num
def _validate_bags(self, right, op):
if type(right) is not Bag:
raise TypeError(
"unsupported operand type(s) for "
+ op
+ ": '"
+ type_as_str(self)
+ "' and '"
+ type_as_str(right)
+ "'"
)
def correct(self,tuples):
if type_as_str(tuples[0]) != 'int' and type_as_str(tuples[0]) != 'float':
raise AssertionError('Poly.__init__: illegal Coeff in ' + str(tuples))
elif type_as_str(tuples[1]) != 'int':
raise AssertionError('Poly.__init__: illegal power in ' + str(tuples))
elif (int(tuples[1]) < 0):
raise AssertionError('Poly.__init__: illegal power in ' + str(tuples))
else:
if tuples[0] == 0:
return False
return True
def check_sequence(kind, kind_text):
assert isinstance(value, kind), 'Wrong whole type: ' + type_as_str(value) + '... should be ' + kind_text
if len(annot) == 1:
i = 0
for v in value:
self.check(param,annot[0],v,check_history+kind_text+'['+str(i)+'] check: '+str(annot[0])+'\n')
i += 1
else:
assert len(annot) == len(value), 'Different length of value and annot!'
for v,k in zip(value, annot):
assert isinstance(v, k), 'Wrong single type: ' + type_as_str(v) + '... should be ' + str(k)
def __rsub__(self, left):
if type(left) not in [int, float, Sparse_Matrix]:
raise TypeError('unsupported operand type(s) for +' + ': \'' +
type_as_str(self) + '\' and \'' +
type_as_str(left) + '\'')
if type(left) in [int, float]:
nm = Sparse_Matrix(self.rows, self.cols)
for index in range(self.rows):
for indexs in range(self.cols):
fr = self.matrix.get((index, indexs), 0) - left
nm[index, indexs] = fr
return nm
def check_list_tup(t):
assert isinstance(value,t), repr(param)+" failed annotation check(wrong type): value = "+repr(value)+\
"\n was type "+type_as_str(value)+" ...should be type "+str(t)+"\n"+check_history
if len(annot) == 1:
for v in value:
self.check(param, annot[0], v, check_history+type_as_str(value)+"["+str(value.index(v))+"] check: "+str(annot[0])+"\n")
else:
assert len(annot) == len(value), repr(param)+" failed annotation check(wrong number of elements): value = "+repr(value)+\
"\n annotation had "+str(len(annot))+" elements"+str(annot)+"\n"+check_history
for a,v in zip(annot,value):
self.check(param, a, v, check_history+type_as_str(value)+"["+str(value.index(v))+"] check: "+str(annot.index(a))+"\n")
def __gt__(self, right):
keys_self = self._all_keys()
if type(right) is DictList:
keys_right = right._all_keys()
elif type(right) is dict:
keys_right = {k for k in right}
else:
raise TypeError('DictList.__gt__: incompatible type for left(' +
type_as_str(self) + ') and right(' +
type_as_str(right) + ')')
return keys_self > keys_right and all(
(self[a] == right[a] for a in keys_right))
def __lt__(self, right):
if type(right) in (int, float):
return math.sqrt(sum([value**2
for value in self.coordinates])) < right
elif type(right) is type(self):
return math.sqrt(sum(
[value**2 for value in self.coordinates])) < math.sqrt(
sum([value**2 for value in right.coordinates]))
else:
raise TypeError('unsupported operand type(s) for <' + ': \'' +
type_as_str(self) + '\' and \'' +
type_as_str(right) + '\'')
def _add_term(self,c,p):
if type(c) not in (int, float):
raise TypeError('Coefficient must be int or float, not type {}.'.format(type_as_str(type(c))))
if type(p) != int:
raise TypeError('Power must be type int. Type {} given.'.format(type_as_str(type(p))))
if p < 0:
raise TypeError('Power must be greater than 0. {} < 0.'.format(type_as_str(p)))
if p not in self.terms.keys():
self.terms[p] = c
if p in self.terms.keys():
self.terms[p] = c
if self.terms[p] == 0:
del self.terms[p]
def check_set():
assert isinstance(value, type(annot)), \
generic_assert.format(repr(param), repr(value),
type_as_str(value), type_as_str(annot)) +'\n' + check_history
assert len(annot) == 1, \
f"{repr(param)} annotation inconsistency: {type_as_str(annot)} should have 1 value but had {len(annot)}\n\
annotation = {annot}\n" + check_history
for v in value:
annot_v = list(annot)[0]
self.check(
param, annot_v, v, check_history +
f'{type_as_str(annot)} value check: {annot_v}')
def __pow__(self,right):
if type(right) is int or (type(right) is Dimensional and type(right['value']) is int and right['d'] == (0,0,0)):
# if Dimensional._get_value(right) > 0:
return Dimensional(self.value ** Dimensional._get_value(right),
*(x * Dimensional._get_value(right) for x in self['d']))
# else:
# return 1/Dimensional(self.value ** abs(Dimensional._get_value(right)),
# *(x * abs(Dimensional._get_value(right)) for x in self['d']))
if type(right) is not Dimensional:
raise TypeError('unsupported operand type(s) for **'
': \''+type_as_str(self)+'\' and \''+type_as_str(right)+'\'')
else:
raise DimensionError('incompatible dimensions for ** (2nd operand must be 0,0,0'
': \''+str(self['d'])+'\' and \''+str(right['d'])+'\'')
def batch_self_check(file_name,seperator='-->',show_exception_message=False):
print('Starting batch_self_check')
check_num, correct_count, wrong_count, wrong = 0, 0, 0, []
for line in open(file_name):
line = line.rstrip()
check_num += 1
try:
# #
if line[0] == '#':
print(line)
continue
kind,to_compute,correct = line.split(seperator)
# Command
if kind =='c':
exec(to_compute)
correct_count += 1
# Query/Expressions
elif kind == 'e':
computed = str(eval(to_compute))
if correct != '':
if computed == correct:
correct_count += 1
else:
wrong_count += 1
wrong.append(check_num)
print(check_num,'Error:',to_compute,'->',computed,'but should ->',correct)
# Exception expected
elif kind == '^':
try:
exec(to_compute)
wrong_count += 1
wrong.append(check_num)
print(check_num,'Error:',to_compute,'should have raised exception:', to_compute)
except Exception as exc:
if any([isinstance(exc,eval(e)) for e in correct.split(',')]):
correct_count += 1
if show_exception_message:
print(' Correct exception('+type_as_str(exc)+'); message:',exc)
else:
wrong_count += 1
wrong.append(check_num)
print(check_num,'Error: Incorrect exception('+type_as_str(exc)+'); message:',exc)
except Exception:
wrong_count += 1
wrong.append(check_num)
print(check_num,'Error:',to_compute,'raised exception')
traceback.print_exc()
print('\nDone batch_self_check:',correct_count,'correct;',wrong_count,'incorrect\n')
print('Failed checks:',wrong)
def _add_term(self,c,p):
if type_as_str(c) not in ["int",'float']:
raise TypeError("{} is not int or float".format(str(c)))
elif type_as_str(p) != 'int':
raise TypeError("{} is not an int".format(str(p)))
elif p < 0:
raise TypeError("{} is < 0".format(str(p)))
elif p not in self.terms and c != 0:
self.terms[p] = c
elif p in self.terms:
if self.terms[p] + c == 0:
self.terms.pop(c)
else:
self.terms[p] += c
def _add_term(self,c,p):
if type(c) not in [int,float]:
raise TypeError('unsupported type for polynomial coefficient:' + type_as_str(c))
if type(p) is not int:
raise TypeError('unsupported type for polynomial power:' + type_as_str(p))
if p < 0:
raise TypeError('given power was less than 0: ' + str(p))
if p not in self.terms and c != 0:
self.terms[p] = c
elif p in self.terms:
test_value = self.terms[p] + c
if test_value == 0:
self.terms.pop(p)
else:
self.terms[p] = test_value
def __init__(self,*terms):
# __str__ uses the name self.terms for the dictionary of terms
# So __init__ should build this dictionary from terms
''' coefficient, power '''
self.terms = {}
history_list = []
for key, val in terms:
assert type_as_str(key) in {'int','float'}
assert type_as_str(val) == 'int'
assert val >= 0
if key != 0:
history_list.append(val)
assert history_list.count(val) <= 1
if key != 0:
self.terms[val] = key
def __init__(self, num=0, denom=1):
assert (type(num), type(denom)) == (int, int), (
'Rational.__init__, unsopported parameter types (num: ' +
type_as_str(num) + ') and (denom: ' + type_as_str(denom) + ')')
assert denom != 0, 'Rational.__init__, denom cannot be equal to 0 '
if num == 0:
self.num = 0
self.denom = 1
else:
self.num = num // self._gcd(abs(num), abs(denom))
self.denom = denom // self._gcd(abs(num), abs(denom))
if self.denom < 0:
self.num *= -1
self.denom *= -1
def __rmul__(self, left):
Fraction._validate_arithmetic(left, {Fraction, int}, '*', 'Fraction',
type_as_str(left))
if type(left) is Fraction:
return Fraction(self.num * left.num, self.denom * left.denom)
elif type(left) is int:
return Fraction(self.num * left, self.denom)
def __eq__(self,right):
if type(right) == Poly:
return self.__repr__() == right.__repr__()
elif type(right) in (int, float):
return self.__len__() == 0 and self.terms[0] == right
else:
raise TypeError('Cannot compare type Poly to type {}'.format(type_as_str(right)))
def __delitem__(self,index):
if type_as_str(index) != 'int':
raise TypeError("{} is not an int".format(str(index)))
elif index < 0:
raise TypeError("{} is < 0".format(str(index)))
if index in self.terms:
self.terms.pop(index)
def __delitem__(self,index):
if type(index) != int:
raise TypeError('Power must be of type int; type {} given.'.format(type_as_str(index)))
if index < 0:
raise TypeError('Power must be greater than 0.')
if index in self.terms:
del self.terms[index]
def __check_annotation__(self, check, param, value, text_history):
assert isinstance(value, Bag), repr(param)+" failed annotation check(wrong type): value ="+repr(value)+\
"\n was type "+type_as_str(value)+" ...should be type Bag\n"+text_history
for a in self.counts:
pass
for v in value.counts:
check(param, a, v, text_history+"Bag value check: "+str(a)+"\n")
def check_set_fset(t):
assert isinstance(value,t), repr(param)+" failed annotation check(wrong type): value = "+repr(value)+\
"\n was type "+type_as_str(value)+" ...should be type "+str(t)+"\n"+check_history
assert len(annot) == 1, repr(param)+" annotation inconsistency: "+str(t)+" should have 1 value but had "+str(len(annot))+\
"\n annotation = "+str(annot)
for v in value:
self.check(param, type(v), v, check_history+str(t)+" value check: "+str(annot))
def check_tuple():
if type(annot) is tuple and isinstance(value, tuple) == False:
raise AssertionError(
"'{a}' failed annotation check(wrong type): value = {v} was type {w} ...should be type tuple"
.format(a=str(param), v=str(value), w=type_as_str(value)))
if len(annot) > 1:
if len(value) != len(annot):
raise AssertionError(
"'{a}' failed annotation check(wrong number of elements): value = {v} annotation had {l}elements {e}"
.format(a=str(param),
v=str(value),
l=str(len(annot)),
e=str(annot)))
counter = 0
if len(annot) == 1:
for i in value:
check_history = "list[{a}] check: {b}".format(a=counter,
b=annot)
self.check(param, annot[0], i, check_history)
counter = 0
if len(annot) > 1:
for i in value:
check_history = "list[{a}] check: {b}".format(
a=counter, b=annot[counter])
self.check(param, annot[counter], i, check_history)
counter += 1
def __pow__(self, right):
if type(right) is not int:
raise TypeError('unsupported operand type(s) for +' + ': \'' +
type_as_str(self) + '\' and \'' +
type_as_str(right) + '\'')
if right < 1:
raise AssertionError('number must be greater than 0')
if self.cols != self.rows:
raise AssertionError(
'Sparse_Matrix must be square(rows and columns must be equal)')
nm = Sparse_Matrix(self.rows, self.cols)
for idex in range(nm.rows):
for indexs in range(nm.cols):
power = int(self.matrix.get((idex, indexs), 0))**int(right)
nm[idex, indexs] = power
return nm
def __mul__(self,right):
if type(right) is Poly:
pass
elif type_as_str(right) in ['int','float']:
pass
else:
raise TypeError("{} is not Polynomial, int, or float".format(str(right)))
def __lt__(self,right):
if type(right) is Point:
return math.sqrt(self.x**2 + self.y**2) < math.sqrt(right.x**2+right.y**2)
if type(right) is int or type(right) is float:
return math.sqrt(self.x**2 + self.y**2) < right
else:
raise TypeError('Point.__lt__: right('+str(right)+') int or float('+type_as_str(right)+')')
def _add_term(self,c,p):
if type_as_str(c) not in ['int', 'float']:
raise AssertionError('Coefficient value must be of type int or float')
elif type_as_str(p) != 'int' or p < 0:
raise AssertionError('Power must be an int with value greater than or equal to 0')
elif p not in self.terms and c != 0:
self.terms[p] = c
elif p in self.terms:
self.terms[p] += c
if self.terms[p] == 0:
self.terms.pop(p)
def __getitem__(self, index):
if type(index) in (int, str):
if index in (0, 'x'):
return self.x
elif index in (1, 'y'):
return self.y
elif index in (2, 'z'):
return self.z
else:
raise IndexError(type_as_str(self) + 'index out of range')
elif type(index) is float:
raise IndexError(type_as_str(self) + 'index out of range')
else:
raise TypeError('unsupported operand type(s) for __getitem__' +
': \'' + type_as_str(self) + '\' and \'' +
type_as_str(index) + '\'')
def __sub__(self, right):
Rational._validate_arithmetic(right, {Rational, int}, '-', 'Rational',
type_as_str(right))
if type(right) is int:
right = Rational(right)
return Rational((self.num * right.denom - right.num * self.denom),
(self.denom * right.denom))
def __rsub__(self, left):
Rational._validate_arithmetic(left, {Rational, int}, '-', 'Rational',
type_as_str(left))
if type(left) is int:
left = Rational(left)
return Rational((left.num * self.denom - self.num * left.denom),
(self.denom * left.denom))
def __pow__(self, right):
Fraction._validate_arithmetic(right, [int], '**', 'Fraction',
type_as_str(right))
if right >= 0:
return Fraction(self.num**right, self.denom**right)
else:
return Fraction(self.denom**-right, self.num**-right)
def __add__(self, right):
Fraction._validate_arithmetic(right, [Fraction, int], '+', 'Fraction',
type_as_str(right))
if type(right) is int:
right = Fraction(right)
return Fraction(self.num * right.denom + right.num * self.denom,
self.denom * right.denom)
def __getitem__(self,index):
if type_as_str(index) != 'int':
raise TypeError("{} is not an int".format(str(index)))
elif index < 0:
raise TypeError("{} is < 0".format(str(index)))
elif index not in self.terms:
return 0
return self.terms[index]
def __getitem__(self,index):
if type_as_str(index) != 'int' or int(index) < 0:
raise TypeError('Poly.__getitem__: illegal index')
if index in self.terms.keys():
return self.terms[index]
else:
return 0
def __rmul__(self,left):
answer = Poly()
if 'Poly' not in type_as_str(self) or type_as_str(left) not in ['int', 'float']\
and 'Poly' not in type_as_str(left):
raise TypeError('Operands must be of type Poly and Poly or int or float')
elif 'Poly' in type_as_str(self) and 'Poly' in type_as_str(left):
pass
else:
for power in self.terms:
answer._add_term(self.terms[power] * left, power)
return answer
def check_dict():
assert isinstance(value,dict), repr(param)+" failed annotation check(wrong type): value = "+repr(value)+\
"\n was type "+type_as_str(value)+" ...should be type dict\n"+check_history
assert len(annot) == 1, repr(param)+" annotation inconsistency: dict should have 1 item but had "+str(len(annot))+\
"\n annotation = "+str(annot)
for k,v in value.items():
self.check(param, list(annot.keys())[0], k, check_history+"dict key check: "+str(list(annot.keys())[0])+"\n")
self.check(param, list(annot.values())[0], v, check_history+"dict value check: "+str(list(annot.values())[0])+"\n")
def __rmul__(self,left):
if type(left) in (int, float):
result = Poly()
for p, c in self.terms.items():
result._add_term(c * left, p)
return result
else:
raise TypeError('Cannot multiply type {} to type Poly'.format(type_as_str(left)))
def __delitem__(self,index):
if type(index) is not int:
raise TypeError('unsupported type for __delitem__ :' + type_as_str(index))
if index < 0:
raise TypeError('given power was less than 0: ' + str(index))
if index not in self.terms:
pass
else:
self.terms.pop(index)
