def sub_input():
"""Subtract a and b parameters"""
a = int(request.args["a"])
b = int(request.args["b"])
result = sub(a, b)
return f"<h1>{result}</h1>"
def search_sub():
""" same but subtracts the two numbers"""
a = int(request.args["a"])
b = int(request.args["b"])
return str(sub(a, b))
def sub_nums():
"""Subtract parameters a and b"""
a = int(request.args.get("a"))
b = int(request.args.get("b"))
result = sub(a, b)
return str(result)
def run_sub():
"""subtracts b from a"""
a = int(request.args.get("a"))
b = int(request.args.get("b"))
res = sub(a, b)
return str(res)
def subtraction():
'''Subtract b from a'''
a = int(request.args.get('a'))
b = int(request.args.get('b'))
result = sub(a, b)
return str(result)
def sub_request():
"""Handle GET request to subtract two numbers"""
a = int(request.args["a"])
b = int(request.args["b"])
result = sub(a, b)
return str(result)
def sub_params():
a = int(request.args.get('a'))
b = int(request.args.get('b'))
result = sub(a, b)
return str(result)
def subtract():
a = int(request.args.get('a'))
b = int(request.args.get('b'))
res = operations.sub(a, b)
return str(res)
def subtraction():
"""this function subtracts a and b,
and if a parameter is missing, the parameter is defaulted to 0"""
a = int(request.args.get("a", 0))
b = int(request.args.get("b", 0))
result = sub(a, b)
return f"<h1>subtracting: {result}</h1>"
def sub_nums():
"""Subtracts b from a"""
a = int(request.args.get("a"))
b = int(request.args.get("b"))
return (str(sub(a, b)))
def subtraction():
"""Subtracts a and b parameters"""
a = int(request.args.get("a"))
b = int(request.args.get("b"))
result = sub(a, b)
return str(result)
def sub_nums():
"""return the difference of a and b parameters"""
a = int(request.args.get("a"))
b = int(request.args.get("b"))
result = sub(a, b)
return str(result)
def sub_operation():
"""Handle get request and subtract b from a"""
a = int(request.args.get("a"))
b = int(request.args.get("b"))
return str(sub(a, b))
def run_sub():
'''subtract a from b'''
a = int(request.args.get("a"))
b = int(request.args.get("b"))
result = sub(a, b)
return str(result)
def to_sub():
"""subtract a and b params"""
a = int(request.args["a"])
b = int(request.args["b"])
result_sub = sub(a, b)
# DO WE ALWAYS HAVE TO STRING THE RESULTS???
return str(result_sub)
def get_sub():
"""
Subtracting b from a and returns result as the body.
"""
a = float(request.args["a"])
b = float(request.args["b"])
return str(operations.sub(a, b))
def sub_num():
'''
Subtract a and b
'''
a = int(request.args.get('a'))
b = int(request.args.get('b'))
result = sub(a, b)
return f"<h1>{a} - {b} is {result}</h1>"
def _subtract(a, b):
"""Calls sub() function from operations and returns the result."""
a = int(request.args.get("a"))
b = int(request.args.get("b"))
subtraction = sub(a, b)
html = f"<html><body><h1>{a} - {b} is...</h1><h3>{subtraction}</h3></body></html"
return html
def subtracting():
"""Substract b from a."""
a = int(request.args.get("a"))
b = int(request.args.get("b"))
result = sub(a, b)
return str(result)
def to_sub():
"""Substract a and b params."""
a = int(request.args.get('a'))
b = int(request.args.get('b'))
result = sub(a, b)
return str(result)
def sub():
'''It takes 2 parameters and subtracts them
>>> 4 - 5 = -1
'''
a = int(request.args.get("a"))
b = int(request.args.get('b'))
result = sub(a, b)
return str(result)
def sub_a_and_b():
"""handles subtraction functionality"""
try:
a = int(request.args['a'])
b = int(request.args['b'])
return str(operations.sub(a, b))
except Exception as e:
return f"{e}"
def do_sub():
"""subtract b from a"""
a = int(request.args.get("a"))
b = int(request.args.get("b"))
result = sub(a,b)
return str(result)
def do_sub():
"""Subtract and b parameters."""
a = int(request.args.get("a"))
b = int(request.args.get("b"))
result = sub(a, b)
return str(result)
def transform(self):
current_instruction = self.instructions.pop(-1)
if current_instruction == 'add':
self.valeur = add(self.valeur)
elif current_instruction == 'sub':
self.valeur = sub(self.valeur)
else:
raise Exception('Bro ton objet transformation est cassé')
self.historique.append(current_instruction)
def calc(operation):
a, b = int(request.args['a']), int(request.args['b'])
OPERATIONS = {
"add": add(a, b),
"sub": sub(a, b),
"mult": mult(a, b),
"div": div(a, b)
}
return str(OPERATIONS[operation])
def sub_query_string_options():
"""Handle GET: Subtract a and b and return result in body."""
a = int(request.args["a"])
b = int(request.args["b"])
result = op.sub(a, b)
return f"<h1>The subtraction of a and b is {result}!</h1>"
def subtract_nums():
"""Subtracts a and b"""
a = int(request.args["a"])
b = int(request.args["b"])
result = sub(a, b)
return f"{a} - {b} = {result}"
def math(operation):
a = float(request.args["a"])
b = float(request.args["b"])
operations_dict = {
'add': operations.add(a, b),
'sub': operations.sub(a, b),
'mult': operations.mult(a, b),
'div': operations.div(a, b)
}
return str(operations_dict[operation])
def math_funcs(oper):
a = int(request.args['a'])
b = int(request.args['b'])
ops = {
'add': operations.add(a, b),
'sub': operations.sub(a, b),
'mult': operations.mult(a, b),
'div': operations.div(a, b),
}
return str(ops[oper])
def candidate_set(self):
"""
Genrate a list of candidate set using the noisy
channel step 1 fact that each spelling mistake can
be corrected by making just one insertion, deletion,
substitution or transposition.
ALGORITHM
=========
Given an observation, say 'abck', an Insertion can be
made at n+1 positions. [a-z]abck, a[a-z]bck, ..., abck[a-z]
Substituition can be made in n ways. [a-zbck], ...
Deletion in n ways
Transposition in n ways
Use regex to match everything
@param None
@return dict with each key mapping to 0
"""
obs = self.obs
size = self.size
regexes = []
#iterate over list and generate regexes
for i in range(0, size+1):
regexes.append(operations.insert(obs, i, self.alphabets)) #insertion candidates
if(i<size):
regexes.append(operations.sub(obs, i, self.alphabets)) #substituition candidates
d = operations.delete(obs, i)
regexes.append(d)#deletion candidates
#send deletion to fallbacks as well
self.fallback.append(d)
regexes += operations.all_trans(obs) #transposition candidates
pattern = "|".join(regexes)
candidates = list( set( re.findall(pattern, self.words) ) ) #set removes duplicates
c_set = {}
[c_set.update({w:0}) for w in candidates]
return c_set
import operations as op x, y = 5, 10 print 'Using arguments:', x, y print 'Sum:', op.add(x, y) print 'Difference:', op.sub(arg1=x, arg2=y) print 'Difference again:', op.sub(arg2=x, arg1=y) x, y = 10.0, 0 print 'Using arguments:', x, y print 'Multiplication:', op.mul(x, x) print 'Division:', op.div(y, x) print 'Division:', op.div(x, y)
