class Expression(Serializable):
def __init__(self, ex: str):
ex = str(ex)
self._string = ex
self._expression = Parser().parse(ex.replace('**', '^'))
@property
def string(self):
return self._string
def variables(self):
return self._expression.variables()
def evaluate(self, parameters):
if USE_NUMEXPR:
return numexpr.evaluate(self._string, global_dict={}, local_dict=parameters)
else:
return self._expression.evaluate(parameters)
def get_serialization_data(self, serializer: 'Serializer'):
return dict(type='Expression', expression=self._string)
@staticmethod
def deserialize(serializer: 'Serializer', **kwargs):
return Expression(kwargs['expression'])
@property
def identifier(self):
return None
class Expression(Serializable):
def __init__(self, ex: str) -> None:
self.__string = str(ex) # type: str
self.__expression = Parser().parse(ex.replace("**", "^")) # type: py_expression_eval.Expression
@property
def string(self) -> str:
return self.__string
def variables(self) -> Iterable[str]:
return self.__expression.variables()
def evaluate(self, **kwargs) -> float:
if USE_NUMEXPR:
return numexpr.evaluate(self.__string, global_dict={}, local_dict=kwargs)
else:
return self.__expression.evaluate(kwargs)
def get_serialization_data(self, serializer: "Serializer") -> Dict[str, Any]:
return dict(type="Expression", expression=self.__string)
@staticmethod
def deserialize(serializer: "Serializer", **kwargs) -> Serializable:
return Expression(kwargs["expression"])
@property
def identifier(self) -> Optional[str]:
return None
def update_index_by_variable_name_appearing_in_formula(index_by_variable_name, formula):
parser_formula = Parser()
try:
expr = parser_formula.parse(formula)
except Exception, e:
print formula
raise(e)
def update_index_by_variable_name_appearing_in_formula(index_by_variable_name, formula):
parser_formula = Parser()
expr = parser_formula.parse(formula)
formula_variables = expr.variables()
components = dict(
(formula_variable, {'code': formula_variable}) for formula_variable in formula_variables
)
index_by_variable_name.update(components)
return index_by_variable_name
def __init__(self): self.stdscr = curses.initscr() self.WIDTH = curses.COLS self.HEIGHT = curses.LINES # dont write on screen and dont wait for enter curses.noecho() curses.cbreak() curses.curs_set(False) # no blinking curses.start_color() # colors # epic keys self.stdscr.keypad(True) self.stdscr = curses.newwin(self.HEIGHT-1,self.WIDTH,0,0) self.bottom = curses.newwin(1,self.WIDTH,self.HEIGHT-1,0) self.bar(default_items) curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_BLACK) if curses.has_colors(): curses.init_pair(2, curses.COLOR_RED, curses.COLOR_BLACK) curses.init_pair(3, curses.COLOR_YELLOW, curses.COLOR_BLACK) curses.init_pair(4, curses.COLOR_GREEN, curses.COLOR_BLACK) curses.init_pair(5, curses.COLOR_CYAN, curses.COLOR_BLACK) self.grapher = Grapher(self.stdscr,self.WIDTH,self.HEIGHT) self.painter = Painter(self.stdscr,self.WIDTH,self.HEIGHT) self.parser = Parser() self.command_hist = [] self.command_indx = -1
def eval_cost(self, var_value):
"""
The eval_cost method calculates the value of the cost formula for a given var_value:
WARNING: the variable in the function MUST be f.
>>> Edge(1, 2, 3, '5+5*f').eval_cost(5.0)
30.0
>>> Edge(1, 2, 3, '5+5*t').eval_cost(5.0)
Traceback (most recent call last):
...
Exception: undefined variable: t
"""
parser = Parser()
exp = parser.parse(self.cost_formula)
#Hardcoded variable 'f'
return exp.evaluate({'f': var_value})
class TestExpressions(unittest.TestCase):
def setUp(self):
self.parser = Parser()
self.goal_functions = [self.get_goal_function('x^2 + y ^ 3'),
self.get_goal_function('sin(e)*x*y + e*y')]
self.answers = [['((x^2.0)+(y^3.0))', '(x^2.0)+(y^3.0)', True],
['(((0.410781290503*x)*y)+(2.71828182846*y))',
'((sin(e)*x)*y)+(e*y)',
True]]
self.goal_err_functions = [self.get_goal_function('x^2 + z'),
self.get_goal_function('x + a + y')]
def get_goal_function(self, expression):
gf = GoalFunction()
gf.__expression = self.parser.parse(expression)
gf.__fetch_function_name()
return gf
def testExpressionValidation(self):
for (gf, answers) in zip(self.goal_functions, self.answers):
expr, validates, val_error = ExpressionValidator(gf.expression).validate()
self.assertEqual(answers[0], expr.toString())
self.assertEqual(answers[1], gf.get_function_name())
self.assertTrue(validates)
def testExpressionFailure(self):
for gf in self.goal_err_functions:
expr, validates, val_error = ExpressionValidator(gf.__expression).validate()
self.assertFalse(validates)
def calculateEdgesTravelTimesNew(self, stringOfActions):
"""
New Version
THIS IS THE NEW EVALUATE FUNCTION(THE ONE ABOVE IS NOT USED ANYMORE)
EACH EDGE OF THE NETWORK HAS ITS OWN COST FUNCTION NOW.
"""
edges_travel_times = {}
#Get the flow of that edge
linkOccupancy = self.driversPerLink(stringOfActions)
#For each edge
for edge in self.Eo:
p = Parser()
exp = p.parse(edge.cost_formula)
#Evaluates the cost of that edge with a given flow (i.e. edge.eval_cost(flow))
edges_travel_times[edge.start + "|" + edge.end] = \
edge.eval_cost(linkOccupancy[edge.start + "|" + edge.end])
return edges_travel_times
def _evaluate(self):
expression = str(self.get_argument('expression'))
operands = self.get_operands()
parser = Parser()
try:
return parser.parse(expression).evaluate(operands)
except TypeError:
msg = "Type Error expression {} with operands {}"
raise ValueError(msg.format(expression, operands))
except ZeroDivisionError:
msg = "Zero division for expression {} with operands {}"
logging.warn(msg.format(expression, operands))
return float('NaN')
except Exception as e:
msg = u"PyExpression error: {} for expression '{}' with opers: {}"
logging.warn(msg.format(e, expression, operands))
raise
def __check_formula_simple(self, formula_name, formula, list_of_variables): msg = "" variables_to_remove = [] #list of unused variables # get the list of terms p = Parser() list_of_terms = p.parse(formula).variables() # check consistency of the variables for v in list_of_variables: if v not in list_of_terms: variables_to_remove.append(v) #return "Variable '%s' is not part of the function!" % v print "WARNING: Variable '%s' is not part of function %s's formula!" % (v, formula_name) return msg, variables_to_remove, list_of_terms
def setUp(self):
self.parser = Parser()
self.goal_functions = [self.get_goal_function('x^2 + y ^ 3'),
self.get_goal_function('sin(e)*x*y + e*y')]
self.answers = [['((x^2.0)+(y^3.0))', '(x^2.0)+(y^3.0)', True],
['(((0.410781290503*x)*y)+(2.71828182846*y))',
'((sin(e)*x)*y)+(e*y)',
True]]
self.goal_err_functions = [self.get_goal_function('x^2 + z'),
self.get_goal_function('x + a + y')]
class GoalFunction:
""" Class which holds a goal function to optimize """
def __init__(self, initial_function=None):
self.console_logger = ConsoleLogger.get_instance() # get logger
self.console_logger.log("Goal function initializing...", LoggerLevel.DEBUG)
self.__expression = "" # function expression
self.__function_name = "" # function simple name
self.__variables = ['x', 'y'] # variables in function
self.__parser = Parser() # function parser
self.__correctly_parsed = True # whether the function was correctly parsed
self.set_goal_function("x ^ 4 * (y + 1) ^ 2 + y ^ 4 * (x + 1) ^ 2") # set some default function
if initial_function: # if to constructor was passed function
self.set_goal_function(initial_function) # try to set it
self.console_logger.log("Goal function initialized", LoggerLevel.DEBUG)
def __fetch_function_name(self):
self.__function_name = self.__expression.simplify({}).toString()[1:-1]
self.console_logger.log("function fetched to: " + self.get_function_name(), LoggerLevel.ADDITIONAL)
def get_function_name(self):
return self.__function_name
def get_expression(self):
return self.__expression
def is_correctly_parsed(self):
return self.__correctly_parsed
def set_goal_function(self, function):
"""sets goal function
If function is not correctly set it returns false,
if it is correctly set itt returns true
"""
try:
function = function.lower() # convert input to lower case
expression = self.__parser.parse(function) # try to parse expression
validator = ExpressionValidator(expression, self.__variables) # get expression validator
expression, validates, validation_error = validator.validate() # expression validation
if not validates:
self.console_logger.log("function is not validating", LoggerLevel.ERROR)
self.console_logger.log(validation_error, LoggerLevel.ERROR)
print validation_error
raise Exception()
self.__expression = expression
self.__fetch_function_name() # fetch simple name from function
self.console_logger.log("function: " + self.get_expression().toString(), LoggerLevel.ADDITIONAL)
self.__correctly_parsed = True
return True
except Exception:
self.__correctly_parsed = False
return False
def __init__(self, initial_function=None):
self.console_logger = ConsoleLogger.get_instance() # get logger
self.console_logger.log("Goal function initializing...", LoggerLevel.DEBUG)
self.__expression = "" # function expression
self.__function_name = "" # function simple name
self.__variables = ['x', 'y'] # variables in function
self.__parser = Parser() # function parser
self.__correctly_parsed = True # whether the function was correctly parsed
self.set_goal_function("x ^ 4 * (y + 1) ^ 2 + y ^ 4 * (x + 1) ^ 2") # set some default function
if initial_function: # if to constructor was passed function
self.set_goal_function(initial_function) # try to set it
self.console_logger.log("Goal function initialized", LoggerLevel.DEBUG)
def setUp(self):
self.parser = Parser()
make_expr = lambda string, start, stop, num_of_val1, num_of_val2: \
[self.parser.parse(string), [start, start],
[stop, stop], [num_of_val1, num_of_val2]]
self.expressions = [make_expr('x^2 + y^3', -4., 4., 801, 701),
make_expr('y^2*sin(x) + 2*y^4', -4., 4., 1001, 901)]
self.tests_values = [[[-2., -2.], [1., 2.5], [-1.5, 0]],
[[1., 1.], [-1.5, 2.5]]]
self.answers_values = [[[-4.0], [16.625], [2.25]],
[[2.841], [71.89]]]
self.tests_gradient = [[[-2., -2.], [0., -1.5]],
[[1.3, -0.5], [-0.5, 1]]]
self.answers_gradient = [[[-4., 12.], [0., 6.75]],
[[0.0669, -1.9635], [0.8776, 7.0411]]]
self.tests_hessian = [[[-2., 1.5]],
[[-2, 1.5]]]
self.answers_hessian = [[[2., 0, 0, 9.]],
[[2.046, -1.248, -1.248, 52.181]]]
def test_custom_functions(self):
parser = Parser()
def testFunction0():
return 13
def testFunction1(a):
return 2*a+9
def testFunction2(a,b):
return 2*a+3*b
# zero argument functions don't currently work
# self.assertEqual(parser
# .parse('testFunction()')
# .evaluate({"testFunction":testFunction0}),13)
self.assertExactEqual(parser
.parse('testFunction(x)')
.evaluate({"x":2,"testFunction":testFunction1}),13)
self.assertExactEqual(parser
.parse('testFunction(x , y)')
.evaluate({"x":2,"y":3,"testFunction":testFunction2}),13)
# Add some "built-in" functions
def mean(*xs):
return sum(xs) / len(xs)
parser.functions['mean'] = mean
def counter(initial):
class nonlocals:
x = initial
def count(increment):
nonlocals.x += increment
return nonlocals.x
return count
parser.functions['count'] = counter(0)
self.assertEqual(parser.parse("mean(xs)").variables(), ["xs"])
self.assertEqual(parser.parse("mean(xs)").symbols(), ["mean", "xs"])
self.assertEqual(parser.evaluate("mean(xs)", variables={"xs": [1, 2, 3]}), 2)
self.assertExactEqual(parser.evaluate("count(inc)", variables={"inc": 5}), 5)
self.assertExactEqual(parser.evaluate("count(inc)", variables={"inc": 5}), 10)
class ParserTestCase(unittest.TestCase):
def setUp(self):
self.parser = Parser()
def test_parser(self):
parser = Parser()
#parser and variables
self.assertEqual(parser.parse('lulu(x,y)').variables(), ['lulu','x','y'])
#evaluate
self.assertEqual(parser.parse('2 * 3').evaluate({}), 6)
self.assertEqual(parser.parse('2 ^ x').evaluate({'x': 3}), 8)
self.assertEqual(parser.parse('2 * x + 1').evaluate({'x': 3}), 7)
self.assertEqual(parser.parse('2 + 3 * x').evaluate({'x': 4}), 14)
self.assertEqual(parser.parse('(2 + 3) * x').evaluate({'x': 4}), 20)
self.assertEqual(parser.parse('2-3^x').evaluate({'x': 4}), -79)
self.assertEqual(parser.parse('-2-3^x').evaluate({'x': 4}), -83)
self.assertEqual(parser.parse('-3^x').evaluate({'x': 4}), -81)
self.assertEqual(parser.parse('(-3)^x').evaluate({'x': 4}), 81)
self.assertEqual(parser.parse('2*x + y').evaluate({'x': 4, 'y': 1}), 9)
self.assertEqual(parser.parse("x||y").evaluate({'x': 'hello ', 'y': 'world'}), 'hello world')
self.assertEqual(parser.parse("'x'||'y'").evaluate({}), 'xy')
self.assertEqual(parser.parse("'x'=='x'").evaluate({}), True)
self.assertEqual(parser.parse("(a+b)==c").evaluate({'a': 1, 'b': 2, 'c': 3}), True)
self.assertEqual(parser.parse("(a+b)!=c").evaluate({'a': 1, 'b': 2, 'c': 3}), False)
self.assertEqual(parser.parse("(a^2-b^2)==((a+b)*(a-b))").evaluate({'a': 4859, 'b': 13150}), True)
self.assertEqual(parser.parse("(a^2-b^2+1)==((a+b)*(a-b))").evaluate({'a': 4859, 'b': 13150}), False)
#functions
self.assertEqual(parser.parse('pyt(2 , 0)').evaluate({}),2)
self.assertEqual(parser.parse("concat('Hello',' ','world')").evaluate({}),'Hello world')
#external function
self.assertEqual(parser.parse('testFunction(x , y)').evaluate({"x":2,"y":3,"testFunction":testFunction}),13)
# test substitute
expr = parser.parse('2 * x + 1')
expr2 = expr.substitute('x', '4 * x') # ((2*(4*x))+1)
self.assertEqual(expr2.evaluate({'x': 3}), 25)
# test simplify
expr = parser.parse('x * (y * atan(1))').simplify({'y': 4})
self.assertIn('x*3.141592', expr.toString())
self.assertEqual(expr.evaluate({'x': 2}), 6.283185307179586)
# test toString with string constant
expr = parser.parse("'a'=='b'")
self.assertIn("'a'=='b'",expr.toString())
expr = parser.parse("concat('a\n','\n','\rb')=='a\n\n\rb'")
self.assertEqual(expr.evaluate({}),True)
#test toString with an external function
expr=parser.parse("myExtFn(a,b,c,1.51,'ok')")
self.assertEqual(expr.substitute("a",'first').toString(),"myExtFn(first,b,c,1.51,'ok')")
# test variables
expr = parser.parse('x * (y * atan(1))')
self.assertEqual(expr.variables(), ['x', 'y'])
self.assertEqual(expr.simplify({'y': 4}).variables(), ['x'])
def test_consts(self):
# self.assertEqual(self.parser.parse("PI ").variables(), [""])
self.assertEqual(self.parser.parse("PI").variables(), [])
self.assertEqual(self.parser.parse("PI ").variables(), [])
self.assertEqual(self.parser.parse("E ").variables(), [])
self.assertEqual(self.parser.parse(" E").variables(), [])
self.assertEqual(self.parser.parse("E").variables(), [])
self.assertEqual(self.parser.parse("E+1").variables(), [])
self.assertEqual(self.parser.parse("E / 1").variables(), [])
self.assertEqual(self.parser.parse("sin(PI)+E").variables(), [])
def test_parsing_e_and_pi(self):
self.assertEqual(self.parser.parse('Pie').variables(), ["Pie"])
self.assertEqual(self.parser.parse('PIe').variables(), ["PIe"])
self.assertEqual(self.parser.parse('Eval').variables(), ["Eval"])
self.assertEqual(self.parser.parse('Eval1').variables(), ["Eval1"])
self.assertEqual(self.parser.parse('EPI').variables(), ["EPI"])
self.assertEqual(self.parser.parse('PIE').variables(), ["PIE"])
self.assertEqual(self.parser.parse('Engage').variables(), ["Engage"])
self.assertEqual(self.parser.parse('Engage * PIE').variables(), ["Engage", "PIE"])
self.assertEqual(self.parser.parse('Engage_').variables(), ["Engage_"])
self.assertEqual(self.parser.parse('Engage1').variables(), ["Engage1"])
self.assertEqual(self.parser.parse('E1').variables(), ["E1"])
self.assertEqual(self.parser.parse('PI2').variables(), ["PI2"])
self.assertEqual(self.parser.parse('(E1 + PI)').variables(), ["E1"])
self.assertEqual(self.parser.parse('E1_').variables(), ["E1_"])
self.assertEqual(self.parser.parse('E_').variables(), ["E_"])
def test_evaluating_consts(self):
self.assertEqual(self.parser.evaluate("Engage1", variables={"Engage1": 2}), 2)
self.assertEqual(self.parser.evaluate("Engage1 + 1", variables={"Engage1": 1}), 2)
def setUp(self):
self.parser = Parser()
xtau = "%f + tau * %f" % (self.current_point[0][0], dk[0][0])
ytau = "%f + tau * %f" % (self.current_point[1][0], dk[1][0])
expression = self.expression.substitute(
'x', xtau) # put it into an expression
expression = expression.substitute('y', ytau)
expression = expression.simplify(
{}) # simplify that it can be converted to string
# self.console_logger.log("optimization in direction:\n" + expr.toString(), LoggerLevel.NORMAL)
fun = lambda tau: expression.evaluate({'tau': tau}
) # make it a function
res = minimize_scalar(fun, tol=0.01) # minimize using brent method
tau = res.x # get the value of tau
self.console_logger.log("value of tau: " + str(tau),
LoggerLevel.ADDITIONAL)
return tau
# return 1
if __name__ == "__main__":
from py_expression_eval import Parser
parser = Parser()
expr = parser.parse('x^2 + y^3')
na = NewtonAlgorithm(expr,
start=[-6., -6.],
stop=[6., 6.],
num_of_values=[1001, 1001],
debug=True)
na.set_starting_point([0, 0.5])
na.set_max_nr_of_iterations(4)
na.compute_algorithm()
def test_decimals(self):
parser = Parser()
self.assertExactEqual(
parser.parse(".1").evaluate({}),
parser.parse("0.1").evaluate({}))
self.assertExactEqual(
parser.parse(".1*.2").evaluate({}),
parser.parse("0.1*0.2").evaluate({}))
self.assertExactEqual(parser.parse(".5^3").evaluate({}), float(0.125))
self.assertExactEqual(parser.parse("16^.5").evaluate({}), 4.0)
self.assertExactEqual(parser.parse(".5**3").evaluate({}), float(0.125))
self.assertExactEqual(parser.parse("16**.5").evaluate({}), 4.0)
self.assertExactEqual(parser.parse("8300*.8").evaluate({}), 6640.0)
self.assertExactEqual(parser.parse("1E3*2.0").evaluate({}), 2000.0)
self.assertExactEqual(parser.parse("-1e3*2.0").evaluate({}), -2000.0)
self.assertExactEqual(
parser.parse("-1E3*2.E2").evaluate({}), -200000.0)
with self.assertRaises(ValueError):
parser.parse("..5").evaluate({})
from py_expression_eval import Parser
import refdata.DataValue as DV
from pprint import pformat
parser = Parser()
# x=parser.parse('2 * 3').evaluate({})
# print(x)
# x=parser.parse('2 * 3.0').evaluate({})
# print(x)
# x=parser.parse('2 * x').evaluate({'x': 7})
# print(x)
# x=parser.parse('2 * x').evaluate({'x': 7.0})
# print(x)
# x=parser.parse('g /mL*mL').simplify({}).toString()
# print(x)
x = DV.DataValue('3.0000 g')
y = DV.DataValue('6.000 g')
v = DV.DataValue('3.00 mL')
print(x, y)
z = parser.parse('y/v').evaluate({'y': y, 'x': x, 'v': v})
print(z)
def falsepositionres(request):
import math
from py_expression_eval import Parser
#xi=float(input("Ingrese límite inferior: "))
#xs=float(input("Ingrese límite superior: "))
#niter=float(input("Ingrese número de iteraciones: "))
#tol=float(input("Ingrese tolerancia: "))
#func=str(input("Ingrese la función: "))
xi = request.POST.get('xi', None)
xs = request.POST.get('xs', None)
niter = request.POST.get('iter', None)
tol = request.POST.get('tol', None)
func = request.POST.get('func', None)
xi = float(xi)
xs = float(xs)
niter = int(niter)
tol = float(tol)
t = PrettyTable(['Iterations', 'xi', 'xm', 'xs', 'f(xm)', 'Error'])
t.border = False
t.header = False
parser = Parser()
#fmelo = "{:f}".format(f)
yi = parser.parse(func).evaluate({'x': xi})
ys = parser.parse(func).evaluate({'x': xs})
if yi == 0:
print("{} es una raíz".format(xs))
else:
if (yi * ys) < 0:
xm = xi - ((yi * (xs - xi)) / (ys - yi))
cont = 1
ym = parser.parse(func).evaluate({'x': xm})
error = tol + 1
print("| Iteración | xi | xm | xs | f(xm) | E |")
print(" | ", cont, " | ", xi, " | ", xm, " | ", xs, " | ", ym,
" | ", error, " | ")
t.add_row([
" | " + str(cont) + " | ",
str(xi) + " | ",
str(xm) + " | ",
str(xs) + " | ",
str(ym) + " | ",
str(error) + " | "
])
while error > tol and ym != 0 and cont < niter:
if yi * ym < 0:
xs = xm
ys = ym
else:
xi = xm
yi = ym
xaux = xm
xm = xi - ((yi * (xs - xi)) / (ys - yi))
ym = parser.parse(func).evaluate({'x': xm})
error = abs(xm - xaux)
cont = cont + 1
print(" | ", cont, " | ", xi, " | ", xm, " | ", xs, " | ", ym,
" | ", error, " | ")
t.add_row([
" | " + str(cont) + " | ",
str(xi) + " | ",
str(xm) + " | ",
str(xs) + " | ",
str(ym) + " | ",
str(error) + " | "
])
if ym == 0:
print("{} es una raiz".format(xm))
else:
print("The interval is inappropriate")
context5 = {'vec': t}
return render(request, "falsepositionres.html", context5)
def IncrementalSearchRes(request):
#x0=float(input("Ingrese valor inicial: "))
x0 = request.POST.get('x0', float)
#delta=float(input("Ingrese valor delta de x: "))
delta = request.POST.get('delt', float)
#niter=float(input("Ingrese número de iteraciones: "))
niter = request.POST.get('iter', int)
#func=str(input("Ingrese la función: "))
func = request.POST.get('func', str)
x0 = float(x0)
delta = float(delta)
niter = int(niter)
#t2 = PrettyTable(['iterations','x0','f(x)', 'message'])
#t2.border = False
t = PrettyTable(['iterations', 'x0', 'f(x)', 'message'])
t.border = False
t.header = False
parser = Parser()
f = parser.parse(func).evaluate({'x': x0})
fmelo = "{:f}".format(f)
if f == 0:
print("EL valor inicial ingresado es una raiz")
else:
x1 = x0 + delta
cont = 0
fx1 = parser.parse(func).evaluate({'x': x1})
print("| Iteración | x | f(x) |")
print(" | ", cont, " | ", x0, " | ", fmelo, " | ")
#context = {'iter':cont, 'x0':x0, 'fx':fmelo}
t.add_row([
" | " + str(cont) + " | ",
str(x0) + " | ",
str(fmelo) + " | ", ' '
])
#tmelo = str(t).replace('|',' ').replace('+',' ')
while cont < niter:
x0 = x1
f = fx1
x1 = x0 + delta
fx1 = parser.parse(func).evaluate({'x': x1})
fmelo = "{:f}".format(f)
cont = cont + 1
#context = {'iter':cont, 'x0':x0, 'fx':fmelo}
if fx1 == 0:
print("x1 is a root")
else:
if f * fx1 < 0:
print(" | ", cont, " | ", x0, " | ", fmelo, " | ",
" There is a root between", x0, " ", x1)
t.add_row([
" | " + str(cont) + " | ",
str(x0) + " | ",
str(fmelo) + " | ", 'There is a root between' + ' ' +
str(x0) + ' and ' + str(x1)
])
#tmelo = str(t).replace('|',' ').replace('+',' ')
#context = {'iter':cont, 'x0':x0, 'fx':fmelo}
else:
print(" | ", cont, " | ", x0, " | ", fmelo, " | ")
t.add_row([
" | " + str(cont) + " | ",
str(x0) + " | ",
str(fmelo) + " | ", ' '
])
#tmelo = str(t).replace('|',' ').replace('+',' ')
#context = {'iter':cont, 'x0':x0, 'fx':fmelo}
print(t)
#k = t.from_html_one
context = {'vec': t}
#context2 = {'enca':t2}
return render(request, "IncrementalSearchRes.html", context)
def BiseccionRes(request):
#xi=float(input("Ingrese límite inferior: "))
xi = request.POST.get('xi', None)
#xs=float(input("Ingrese límite superior: "))
xs = request.POST.get('xs', None)
#niter=float(input("Ingrese número de iteraciones: "))
tol = request.POST.get('tol', None)
niter = request.POST.get('iter', None)
#tol=float(input("Ingrese tolerancia: "))
#func=str(input("Ingrese la función: "))
func = request.POST.get('func', None)
uno = float(1)
xi = float(xi)
xs = float(xs)
niter = int(niter)
tol = float(tol)
t = PrettyTable(['iterations', 'xi', 'xm', 'xs', 'f(x)', 'Error'])
t.border = False
t.header = False
parser = Parser()
fxi = parser.parse(func).evaluate({'x': xi})
fxs = parser.parse(func).evaluate({'x': xs})
xm = (xs + xi) / 2
fxm = parser.parse(func).evaluate({'x': xm})
ximelo = "{:f}".format(xi)
xsmelo = "{:f}".format(xs)
xmmelo = "{:f}".format(xm)
fxmmelo = "{:e}".format(fxm)
print(" | ", " Iterations ", " | ", " xi ", " | ", " xm ", " | ", " xs ",
" | ", " fx ", " | ", " error (E) ", " | ")
print(" | ", "1", " | ", ximelo, " | ", xmmelo, " | ", xsmelo, " | ",
fxmmelo, " | ", " | ")
t.add_row([
" | " + str(1) + " | ",
str(ximelo) + " | ",
str(xmmelo) + " | ",
str(xsmelo) + " | ",
str(fxmmelo) + " | ", " | "
])
if fxi == 0:
print("The value {} is a root".format(xi))
else:
if fxs == 0:
print("The value {} is a root".format(xs))
else:
if (fxi * fxs) < 0:
xm = (xi + xs) / 2
fxm = parser.parse(func).evaluate({'x': xm})
cont = 1
error = (tol) + uno
while error > tol and fxm != 0 and cont < niter:
if (fxi * fxm) < 0:
xs = xm
fxs = fxm
else:
xi = xm
fxi = fxm
xaux = xm
xm = (xi + xs) / 2
fxm = parser.parse(func).evaluate({'x': xm})
error = abs(xm - xaux)
cont = cont + 1
ximelo = "{:f}".format(xi)
xsmelo = "{:f}".format(xs)
xmmelo = "{:f}".format(xm)
fxmmelo = "{:e}".format(fxm)
errmelo = "{:e}".format(error)
print(" | ", cont, " | ", ximelo, " | ", xmmelo, " | ",
xsmelo, " | ", fxmmelo, " | ", errmelo, " | ")
t.add_row([
" | " + str(cont) + " | ",
str(ximelo) + " | ",
str(xmmelo) + " | ",
str(xsmelo) + " | ",
str(fxmmelo) + " | ",
str(errmelo) + " | ",
])
if fxm == 0:
print("The value {} is a root".format(xmmelo))
else:
if error < tol:
print(
"{} is an aproximation of a root with {} tolerance"
.format(xmmelo, errmelo))
else:
print(
"The method fails in {} iterations".format(niter))
else:
print("The interval is inappropriate")
context2 = {'vec': t}
return render(request, "biseccionres.html", context2)
async def _calc(self, ctx, *args):
if len(args) == 0:
return await self.bot.send_help(ctx)
args = ' '.join(args)
args = args.replace('pi', 'PI')
args = args.replace('Pi', 'PI')
args = args.replace('pI', 'PI')
args = args.replace('π', 'PI')
try:
parser = Parser()
resultado = parser.parse(args).evaluate({})
if isinstance(resultado,
bool): # se o resultado veio como True ou False
resultado = convert_to_string(resultado)
except OverflowError:
resultado = '∞'
except ZeroDivisionError:
resultado = '∞'
except Exception as exception:
if 'unexpected' in exception.args[0]:
await ctx.reply(
f'Parece que há um erro de digitação!\n```{args}```{self.bot.emoji("ah_nao")}'
)
return
elif 'undefined variable' in exception.args[0]:
variavel_desconhecida = exception.args[0][exception.args[0].
find(':') + 2:]
await ctx.reply(
f'Desculpe, mas eu não sei o que é ``{variavel_desconhecida}`` {self.bot.emoji("sad")}'
)
return
elif 'unknown character' in exception.args[0]:
await ctx.reply(
f'Desculpe, mas você digitou algum caracter que eu não conheço. {self.bot.emoji("sad")}'
)
return
elif 'unmatched "()"' in exception.args[0]:
await ctx.reply(
f'Pare que você esqueceu de abrir ou fechar algum parêntese! {self.bot.emoji("ah_nao")}'
)
return
elif ('parity' in exception.args[0]) or isinstance(
exception, TypeError):
await ctx.reply(
'Não consigo resolver está operação, verifique se você digitou tudo certo!'
)
return
elif ('IndexError' in str(
exception.__class__)) or ('math domain error'
in exception.args[0]):
await ctx.reply(
f'Estamos em {datetime.now().year}, mas ainda não sou capaz de resolver isso.'
)
return
else:
if self.bot.maintenance_mode:
raise exception
else:
return await ctx.reply(
f'{self.bot.emoji("sad")} Ocorreu um erro na hora de executar este comando,'
+
f' por favor informe este erro ao meu criador\n```{exception.args[0]}```'
)
if len(str(resultado)) >= 400:
await ctx.reply(
'O resultado desta operação é tão grande que não consigo enviar a resposta!'
+ f'\n{self.bot.emoji("sad")}')
return
embed = discord.Embed(
title=f'{self.bot.emoji("calculator")} Calculadora:',
colour=discord.Colour.random(),
timestamp=datetime.utcnow())
embed.add_field(name=f'Calculo:', value=f'```{args}```', inline=False)
embed.add_field(name=f'Resposta:',
value=f'```{prettify_number(resultado)}```',
inline=False)
embed.set_footer(text=f'{ctx.author}',
icon_url=f'{ctx.author.avatar_url}')
await ctx.reply(embed=embed, mention_author=False)
def test_parser(self):
parser = Parser()
#parser and variables
self.assertEqual(parser.parse('pow(x,y)').variables(), ['x','y'])
self.assertEqual(parser.parse('pow(x,y)').symbols(), ['pow','x','y'])
#checking if '"a b"' could be a variable (using it in sql)
self.assertEqual(parser.parse('"a b"*2').evaluate({'"a b"':2}),4)
#evaluate
self.assertExactEqual(parser.parse('1').evaluate({}), 1)
self.assertExactEqual(parser.parse('a').evaluate({'a': 2}), 2)
self.assertExactEqual(parser.parse('2 * 3').evaluate({}), 6)
self.assertExactEqual(parser.parse(u'2 \u2219 3').evaluate({}), 6)
self.assertExactEqual(parser.parse(u'2 \u2022 3').evaluate({}), 6)
self.assertExactEqual(parser.parse('2 ^ x').evaluate({'x': 3}), 8.0)
self.assertExactEqual(parser.parse('2 ** x').evaluate({'x': 3}), 8.0)
self.assertExactEqual(parser.parse('-1.E2 ** x + 2.0E2').evaluate({'x': 1}), 100.0)
self.assertEqual(parser.parse('x < 3').evaluate({'x': 3}), False)
self.assertEqual(parser.parse('x < 3').evaluate({'x': 2}), True)
self.assertEqual(parser.parse('x <= 3').evaluate({'x': 3}), True)
self.assertEqual(parser.parse('x <= 3').evaluate({'x': 4}), False)
self.assertEqual(parser.parse('x > 3').evaluate({'x': 4}), True)
self.assertEqual(parser.parse('x >= 3').evaluate({'x': 3}), True)
self.assertExactEqual(parser.parse('2 * x + 1').evaluate({'x': 3}), 7)
self.assertExactEqual(parser.parse('2 + 3 * x').evaluate({'x': 4}), 14)
self.assertExactEqual(parser.parse('(2 + 3) * x').evaluate({'x': 4}), 20)
self.assertExactEqual(parser.parse('2-3^x').evaluate({'x': 4}), -79.0)
self.assertExactEqual(parser.parse('-2-3^x').evaluate({'x': 4}), -83.0)
self.assertExactEqual(parser.parse('-3^x').evaluate({'x': 4}), -81.0)
self.assertExactEqual(parser.parse('(-3)^x').evaluate({'x': 4}), 81.0)
self.assertExactEqual(parser.parse('2-3**x').evaluate({'x': 4}), -79.0)
self.assertExactEqual(parser.parse('-2-3**x').evaluate({'x': 4}), -83.0)
self.assertExactEqual(parser.parse('-3**x').evaluate({'x': 4}), -81.0)
self.assertExactEqual(parser.parse('(-3)**x').evaluate({'x': 4}), 81.0)
self.assertExactEqual(parser.parse('2*x + y').evaluate({'x': 4, 'y': 1}), 9)
self.assertEqual(parser.parse("x||y").evaluate({'x': 'hello ', 'y': 'world'}), 'hello world')
self.assertEqual(parser.parse("'x'||'y'").evaluate({}), 'xy')
self.assertEqual(parser.parse("'x'=='x'").evaluate({}), True)
self.assertEqual(parser.parse("(a+b)==c").evaluate({'a': 1, 'b': 2, 'c': 3}), True)
self.assertEqual(parser.parse("(a+b)!=c").evaluate({'a': 1, 'b': 2, 'c': 3}), False)
self.assertEqual(parser.parse("(a^2-b^2)==((a+b)*(a-b))").evaluate({'a': 4859, 'b': 13150}), True)
self.assertEqual(parser.parse("(a^2-b^2+1)==((a+b)*(a-b))").evaluate({'a': 4859, 'b': 13150}), False)
self.assertEqual(parser.parse("(a**2-b**2)==((a+b)*(a-b))").evaluate({'a': 4859, 'b': 13150}), True)
self.assertEqual(parser.parse("(a**2-b**2+1)==((a+b)*(a-b))").evaluate({'a': 4859, 'b': 13150}), False)
self.assertExactEqual(parser.parse("x/((x+y))").simplify({}).evaluate({'x':1, 'y':1}), 0.5)
self.assertExactEqual(parser.parse('origin+2.0').evaluate({'origin': 1.0}), 3.0)
#functions
self.assertExactEqual(parser.parse('pyt(2 , 0)').evaluate({}), 2.0)
self.assertEqual(parser.parse("concat('Hello',' ','world')").evaluate({}),'Hello world')
self.assertExactEqual(parser.parse('if(a>b,5,6)').evaluate({'a':8,'b':3}),5)
self.assertExactEqual(parser.parse('if(a,b,c)').evaluate({'a':None,'b':1,'c':3}),3)
#log with base or natural log
self.assertExactEqual(parser.parse('log(16,2)').evaluate({}), 4.0)
self.assertExactEqual(parser.parse('log(E^100)').evaluate({}), 100.0)
self.assertExactEqual(parser.parse('log(E**100)').evaluate({}), 100.0)
# test substitute
expr = parser.parse('2 * x + 1')
expr2 = expr.substitute('x', '4 * x') # ((2*(4*x))+1)
self.assertExactEqual(expr2.evaluate({'x': 3}), 25)
# test simplify
expr = parser.parse('x * (y * atan(1))').simplify({'y': 4})
self.assertIn('x*3.141592', expr.toString())
self.assertExactEqual(expr.evaluate({'x': 2}), 6.283185307179586)
# test toString with string constant
expr = parser.parse("'a'=='b'")
self.assertIn("'a'=='b'",expr.toString())
self.assertIn("'a'=='b'", "%s" % expr)
expr = parser.parse("concat('a\n','\n','\rb')=='a\n\n\rb'")
self.assertEqual(expr.evaluate({}),True)
expr = parser.parse("a==''")
self.assertEqual(expr.evaluate({'a':''}),True)
#test toString with an external function
expr=parser.parse("myExtFn(a,b,c,1.51,'ok')")
self.assertEqual(expr.substitute("a",'first').toString(),"myExtFn(first,b,c,1.51,'ok')")
# test variables
expr = parser.parse('x * (y * atan(1))')
self.assertEqual(expr.variables(), ['x', 'y'])
self.assertEqual(expr.simplify({'y': 4}).variables(), ['x'])
# list operations
self.assertEqual(parser.parse('a, 3').evaluate({'a': [1, 2]}), [1, 2, 3])
def test_decimals(self):
parser = Parser()
self.assertExactEqual(parser.parse(".1").evaluate({}), parser.parse("0.1").evaluate({}))
self.assertExactEqual(parser.parse(".1*.2").evaluate({}), parser.parse("0.1*0.2").evaluate({}))
self.assertExactEqual(parser.parse(".5^3").evaluate({}), float(0.125))
self.assertExactEqual(parser.parse("16^.5").evaluate({}), 4.0)
self.assertExactEqual(parser.parse(".5**3").evaluate({}), float(0.125))
self.assertExactEqual(parser.parse("16**.5").evaluate({}), 4.0)
self.assertExactEqual(parser.parse("8300*.8").evaluate({}), 6640.0)
self.assertExactEqual(parser.parse("1E3*2.0").evaluate({}), 2000.0)
self.assertExactEqual(parser.parse("-1e3*2.0").evaluate({}), -2000.0)
self.assertExactEqual(parser.parse("-1E3*2.E2").evaluate({}), -200000.0)
with self.assertRaises(ValueError):
parser.parse("..5").evaluate({})
class ParserTestCase(unittest.TestCase):
def setUp(self):
self.parser = Parser()
def assertExactEqual(self, a, b):
self.assertEqual(type(a), type(b))
self.assertEqual(a, b)
def test_parser(self):
parser = Parser()
#parser and variables
self.assertEqual(parser.parse('pow(x,y)').variables(), ['x','y'])
self.assertEqual(parser.parse('pow(x,y)').symbols(), ['pow','x','y'])
#checking if '"a b"' could be a variable (using it in sql)
self.assertEqual(parser.parse('"a b"*2').evaluate({'"a b"':2}),4)
#evaluate
self.assertExactEqual(parser.parse('1').evaluate({}), 1)
self.assertExactEqual(parser.parse('a').evaluate({'a': 2}), 2)
self.assertExactEqual(parser.parse('2 * 3').evaluate({}), 6)
self.assertExactEqual(parser.parse(u'2 \u2219 3').evaluate({}), 6)
self.assertExactEqual(parser.parse(u'2 \u2022 3').evaluate({}), 6)
self.assertExactEqual(parser.parse('2 ^ x').evaluate({'x': 3}), 8.0)
self.assertExactEqual(parser.parse('2 ** x').evaluate({'x': 3}), 8.0)
self.assertExactEqual(parser.parse('-1.E2 ** x + 2.0E2').evaluate({'x': 1}), 100.0)
self.assertEqual(parser.parse('x < 3').evaluate({'x': 3}), False)
self.assertEqual(parser.parse('x < 3').evaluate({'x': 2}), True)
self.assertEqual(parser.parse('x <= 3').evaluate({'x': 3}), True)
self.assertEqual(parser.parse('x <= 3').evaluate({'x': 4}), False)
self.assertEqual(parser.parse('x > 3').evaluate({'x': 4}), True)
self.assertEqual(parser.parse('x >= 3').evaluate({'x': 3}), True)
self.assertExactEqual(parser.parse('2 * x + 1').evaluate({'x': 3}), 7)
self.assertExactEqual(parser.parse('2 + 3 * x').evaluate({'x': 4}), 14)
self.assertExactEqual(parser.parse('(2 + 3) * x').evaluate({'x': 4}), 20)
self.assertExactEqual(parser.parse('2-3^x').evaluate({'x': 4}), -79.0)
self.assertExactEqual(parser.parse('-2-3^x').evaluate({'x': 4}), -83.0)
self.assertExactEqual(parser.parse('-3^x').evaluate({'x': 4}), -81.0)
self.assertExactEqual(parser.parse('(-3)^x').evaluate({'x': 4}), 81.0)
self.assertExactEqual(parser.parse('2-3**x').evaluate({'x': 4}), -79.0)
self.assertExactEqual(parser.parse('-2-3**x').evaluate({'x': 4}), -83.0)
self.assertExactEqual(parser.parse('-3**x').evaluate({'x': 4}), -81.0)
self.assertExactEqual(parser.parse('(-3)**x').evaluate({'x': 4}), 81.0)
self.assertExactEqual(parser.parse('2*x + y').evaluate({'x': 4, 'y': 1}), 9)
self.assertEqual(parser.parse("x||y").evaluate({'x': 'hello ', 'y': 'world'}), 'hello world')
self.assertEqual(parser.parse("'x'||'y'").evaluate({}), 'xy')
self.assertEqual(parser.parse("'x'=='x'").evaluate({}), True)
self.assertEqual(parser.parse("(a+b)==c").evaluate({'a': 1, 'b': 2, 'c': 3}), True)
self.assertEqual(parser.parse("(a+b)!=c").evaluate({'a': 1, 'b': 2, 'c': 3}), False)
self.assertEqual(parser.parse("(a^2-b^2)==((a+b)*(a-b))").evaluate({'a': 4859, 'b': 13150}), True)
self.assertEqual(parser.parse("(a^2-b^2+1)==((a+b)*(a-b))").evaluate({'a': 4859, 'b': 13150}), False)
self.assertEqual(parser.parse("(a**2-b**2)==((a+b)*(a-b))").evaluate({'a': 4859, 'b': 13150}), True)
self.assertEqual(parser.parse("(a**2-b**2+1)==((a+b)*(a-b))").evaluate({'a': 4859, 'b': 13150}), False)
self.assertExactEqual(parser.parse("x/((x+y))").simplify({}).evaluate({'x':1, 'y':1}), 0.5)
self.assertExactEqual(parser.parse('origin+2.0').evaluate({'origin': 1.0}), 3.0)
#functions
self.assertExactEqual(parser.parse('pyt(2 , 0)').evaluate({}), 2.0)
self.assertEqual(parser.parse("concat('Hello',' ','world')").evaluate({}),'Hello world')
self.assertExactEqual(parser.parse('if(a>b,5,6)').evaluate({'a':8,'b':3}),5)
self.assertExactEqual(parser.parse('if(a,b,c)').evaluate({'a':None,'b':1,'c':3}),3)
#log with base or natural log
self.assertExactEqual(parser.parse('log(16,2)').evaluate({}), 4.0)
self.assertExactEqual(parser.parse('log(E^100)').evaluate({}), 100.0)
self.assertExactEqual(parser.parse('log(E**100)').evaluate({}), 100.0)
# test substitute
expr = parser.parse('2 * x + 1')
expr2 = expr.substitute('x', '4 * x') # ((2*(4*x))+1)
self.assertExactEqual(expr2.evaluate({'x': 3}), 25)
# test simplify
expr = parser.parse('x * (y * atan(1))').simplify({'y': 4})
self.assertIn('x*3.141592', expr.toString())
self.assertExactEqual(expr.evaluate({'x': 2}), 6.283185307179586)
# test toString with string constant
expr = parser.parse("'a'=='b'")
self.assertIn("'a'=='b'",expr.toString())
self.assertIn("'a'=='b'", "%s" % expr)
expr = parser.parse("concat('a\n','\n','\rb')=='a\n\n\rb'")
self.assertEqual(expr.evaluate({}),True)
expr = parser.parse("a==''")
self.assertEqual(expr.evaluate({'a':''}),True)
#test toString with an external function
expr=parser.parse("myExtFn(a,b,c,1.51,'ok')")
self.assertEqual(expr.substitute("a",'first').toString(),"myExtFn(first,b,c,1.51,'ok')")
# test variables
expr = parser.parse('x * (y * atan(1))')
self.assertEqual(expr.variables(), ['x', 'y'])
self.assertEqual(expr.simplify({'y': 4}).variables(), ['x'])
# list operations
self.assertEqual(parser.parse('a, 3').evaluate({'a': [1, 2]}), [1, 2, 3])
def test_consts(self):
# self.assertEqual(self.parser.parse("PI ").variables(), [""])
self.assertEqual(self.parser.parse("PI").variables(), [])
self.assertEqual(self.parser.parse("PI ").variables(), [])
self.assertEqual(self.parser.parse("E ").variables(), [])
self.assertEqual(self.parser.parse(" E").variables(), [])
self.assertEqual(self.parser.parse("E").variables(), [])
self.assertEqual(self.parser.parse("E+1").variables(), [])
self.assertEqual(self.parser.parse("E / 1").variables(), [])
self.assertEqual(self.parser.parse("sin(PI)+E").variables(), [])
def test_parsing_e_and_pi(self):
self.assertEqual(self.parser.parse('Pie').variables(), ["Pie"])
self.assertEqual(self.parser.parse('PIe').variables(), ["PIe"])
self.assertEqual(self.parser.parse('Eval').variables(), ["Eval"])
self.assertEqual(self.parser.parse('Eval1').variables(), ["Eval1"])
self.assertEqual(self.parser.parse('EPI').variables(), ["EPI"])
self.assertEqual(self.parser.parse('PIE').variables(), ["PIE"])
self.assertEqual(self.parser.parse('Engage').variables(), ["Engage"])
self.assertEqual(self.parser.parse('Engage * PIE').variables(), ["Engage", "PIE"])
self.assertEqual(self.parser.parse('Engage_').variables(), ["Engage_"])
self.assertEqual(self.parser.parse('Engage1').variables(), ["Engage1"])
self.assertEqual(self.parser.parse('E1').variables(), ["E1"])
self.assertEqual(self.parser.parse('PI2').variables(), ["PI2"])
self.assertEqual(self.parser.parse('(E1 + PI)').variables(), ["E1"])
self.assertEqual(self.parser.parse('E1_').variables(), ["E1_"])
self.assertEqual(self.parser.parse('E_').variables(), ["E_"])
def test_evaluating_consts(self):
self.assertExactEqual(self.parser.evaluate("Engage1", variables={"Engage1": 2}), 2)
self.assertExactEqual(self.parser.evaluate("Engage1 + 1", variables={"Engage1": 1}), 2)
def test_custom_functions(self):
parser = Parser()
def testFunction0():
return 13
def testFunction1(a):
return 2*a+9
def testFunction2(a,b):
return 2*a+3*b
# zero argument functions don't currently work
# self.assertEqual(parser
# .parse('testFunction()')
# .evaluate({"testFunction":testFunction0}),13)
self.assertExactEqual(parser
.parse('testFunction(x)')
.evaluate({"x":2,"testFunction":testFunction1}),13)
self.assertExactEqual(parser
.parse('testFunction(x , y)')
.evaluate({"x":2,"y":3,"testFunction":testFunction2}),13)
# Add some "built-in" functions
def mean(*xs):
return sum(xs) / len(xs)
parser.functions['mean'] = mean
def counter(initial):
class nonlocals:
x = initial
def count(increment):
nonlocals.x += increment
return nonlocals.x
return count
parser.functions['count'] = counter(0)
self.assertEqual(parser.parse("mean(xs)").variables(), ["xs"])
self.assertEqual(parser.parse("mean(xs)").symbols(), ["mean", "xs"])
self.assertEqual(parser.evaluate("mean(xs)", variables={"xs": [1, 2, 3]}), 2)
self.assertExactEqual(parser.evaluate("count(inc)", variables={"inc": 5}), 5)
self.assertExactEqual(parser.evaluate("count(inc)", variables={"inc": 5}), 10)
def test_decimals(self):
parser = Parser()
self.assertExactEqual(parser.parse(".1").evaluate({}), parser.parse("0.1").evaluate({}))
self.assertExactEqual(parser.parse(".1*.2").evaluate({}), parser.parse("0.1*0.2").evaluate({}))
self.assertExactEqual(parser.parse(".5^3").evaluate({}), float(0.125))
self.assertExactEqual(parser.parse("16^.5").evaluate({}), 4.0)
self.assertExactEqual(parser.parse(".5**3").evaluate({}), float(0.125))
self.assertExactEqual(parser.parse("16**.5").evaluate({}), 4.0)
self.assertExactEqual(parser.parse("8300*.8").evaluate({}), 6640.0)
self.assertExactEqual(parser.parse("1E3*2.0").evaluate({}), 2000.0)
self.assertExactEqual(parser.parse("-1e3*2.0").evaluate({}), -2000.0)
self.assertExactEqual(parser.parse("-1E3*2.E2").evaluate({}), -200000.0)
with self.assertRaises(ValueError):
parser.parse("..5").evaluate({})
def test_parser(self):
parser = Parser()
#parser and variables
self.assertEqual(parser.parse('lulu(x,y)').variables(), ['lulu','x','y'])
#evaluate
self.assertEqual(parser.parse('2 * 3').evaluate({}), 6)
self.assertEqual(parser.parse('2 ^ x').evaluate({'x': 3}), 8)
self.assertEqual(parser.parse('2 * x + 1').evaluate({'x': 3}), 7)
self.assertEqual(parser.parse('2 + 3 * x').evaluate({'x': 4}), 14)
self.assertEqual(parser.parse('(2 + 3) * x').evaluate({'x': 4}), 20)
self.assertEqual(parser.parse('2-3^x').evaluate({'x': 4}), -79)
self.assertEqual(parser.parse('-2-3^x').evaluate({'x': 4}), -83)
self.assertEqual(parser.parse('-3^x').evaluate({'x': 4}), -81)
self.assertEqual(parser.parse('(-3)^x').evaluate({'x': 4}), 81)
self.assertEqual(parser.parse('2*x + y').evaluate({'x': 4, 'y': 1}), 9)
self.assertEqual(parser.parse("x||y").evaluate({'x': 'hello ', 'y': 'world'}), 'hello world')
self.assertEqual(parser.parse("'x'||'y'").evaluate({}), 'xy')
self.assertEqual(parser.parse("'x'=='x'").evaluate({}), True)
self.assertEqual(parser.parse("(a+b)==c").evaluate({'a': 1, 'b': 2, 'c': 3}), True)
self.assertEqual(parser.parse("(a+b)!=c").evaluate({'a': 1, 'b': 2, 'c': 3}), False)
self.assertEqual(parser.parse("(a^2-b^2)==((a+b)*(a-b))").evaluate({'a': 4859, 'b': 13150}), True)
self.assertEqual(parser.parse("(a^2-b^2+1)==((a+b)*(a-b))").evaluate({'a': 4859, 'b': 13150}), False)
#functions
self.assertEqual(parser.parse('pyt(2 , 0)').evaluate({}),2)
self.assertEqual(parser.parse("concat('Hello',' ','world')").evaluate({}),'Hello world')
#external function
self.assertEqual(parser.parse('testFunction(x , y)').evaluate({"x":2,"y":3,"testFunction":testFunction}),13)
# test substitute
expr = parser.parse('2 * x + 1')
expr2 = expr.substitute('x', '4 * x') # ((2*(4*x))+1)
self.assertEqual(expr2.evaluate({'x': 3}), 25)
# test simplify
expr = parser.parse('x * (y * atan(1))').simplify({'y': 4})
self.assertIn('x*3.141592', expr.toString())
self.assertEqual(expr.evaluate({'x': 2}), 6.283185307179586)
# test toString with string constant
expr = parser.parse("'a'=='b'")
self.assertIn("'a'=='b'",expr.toString())
expr = parser.parse("concat('a\n','\n','\rb')=='a\n\n\rb'")
self.assertEqual(expr.evaluate({}),True)
#test toString with an external function
expr=parser.parse("myExtFn(a,b,c,1.51,'ok')")
self.assertEqual(expr.substitute("a",'first').toString(),"myExtFn(first,b,c,1.51,'ok')")
# test variables
expr = parser.parse('x * (y * atan(1))')
self.assertEqual(expr.variables(), ['x', 'y'])
self.assertEqual(expr.simplify({'y': 4}).variables(), ['x'])
def __init__(self):
self.delta = -1.0
self.y_values = []
self.evaluate = Parser()
def newtonres(request):
import math
from py_expression_eval import Parser
x0 = request.POST.get('x0', None)
niter = request.POST.get('iter', None)
tol = request.POST.get('tol', None)
func = request.POST.get('func', None)
fprim = request.POST.get('fprim', None)
x0 = float(x0)
niter = int(niter)
tol = float(tol)
t = PrettyTable(['iterations', 'xi', 'f(x)', 'Error'])
t.border = False
t.header = False
parser = Parser()
fx = parser.parse(func).evaluate({'x': x0})
derif = parser.parse(fprim).evaluate({'x': x0})
cont = 0
error = tol + 1
x0melo = "{:f}".format(x0)
fximelo = "{:e}".format(fx)
print(" | ", " Iter ", " | ", " xi ", " | ", " f(xi) ", " | ",
" error (E) ", " | ")
print(" | ", cont, " | ", x0melo, " | ", fximelo, " | ",
" | ")
t.add_row([
" | " + str(cont) + " | ",
str(x0melo) + " | ",
str(fximelo) + " | ", " | "
])
while error > tol and fx != 0 and derif != 0 and cont < niter:
x1 = x0 - (fx / derif)
fx = parser.parse(func).evaluate({'x': x1})
derif = parser.parse(fprim).evaluate({'x': x1})
error = abs(x1 - x0)
x0 = x1
cont = cont + 1
x0melo = "{:f}".format(x0)
fximelo = "{:e}".format(fx)
errmelo = "{:e}".format(error)
print(" | ", cont, " | ", x0melo, " | ", fximelo, " | ", errmelo,
" | ")
t.add_row([
" | " + str(cont) + " | ",
str(x0melo) + " | ",
str(fximelo) + " | ",
str(errmelo) + " | "
])
if fx == 0:
print("{} es una raiz".format(x0))
else:
if error < tol:
print("{} es una aproximación a una raíz con una tolerancia de {}".
format(x1, error))
else:
if derif == 0:
print("{} es una posible raíz múltiple".format(x1))
else:
print("El método fracasó en {} de iteraciones".format(niter))
context3 = {'vec': t}
return render(request, "newtonres.html", context3)
def test_parser(self):
parser = Parser()
self.assertEqual(parser.parse('2 * 3').evaluate({}), 6)
self.assertEqual(parser.parse('2 ^ x').evaluate({'x': 3}), 8)
self.assertEqual(parser.parse('2 * x + 1').evaluate({'x': 3}), 7)
self.assertEqual(parser.parse('2 + 3 * x').evaluate({'x': 4}), 14)
self.assertEqual(parser.parse('(2 + 3) * x').evaluate({'x': 4}), 20)
self.assertEqual(parser.parse('2-3^x').evaluate({'x': 4}), -79)
self.assertEqual(parser.parse('-2-3^x').evaluate({'x': 4}), -83)
self.assertEqual(parser.parse('-3^x').evaluate({'x': 4}), -81)
self.assertEqual(parser.parse('(-3)^x').evaluate({'x': 4}), 81)
self.assertEqual(parser.parse('2*x + y').evaluate({'x': 4, 'y': 1}), 9)
# test substitute
expr = parser.parse('2 * x + 1')
expr2 = expr.substitute('x', '4 * x') # ((2*(4*x))+1)
self.assertEqual(expr2.evaluate({'x': 3}), 25)
# test simplify
expr = parser.parse('x * (y * atan(1))').simplify({'y': 4})
self.assertIn('x*3.141592', expr.toString())
self.assertEqual(expr.evaluate({'x': 2}), 6.283185307179586)
# test variables
expr = parser.parse('x * (y * atan(1))')
self.assertEqual(expr.variables(), ['x', 'y'])
self.assertEqual(expr.simplify({'y': 4}).variables(), ['x'])
def secantres(request):
import math
from py_expression_eval import Parser
#x0=float(input("Ingrese límite inferior: "))
x0 = request.POST.get('x0', None)
#x1=float(input("Ingrese límite superior: "))
x1 = request.POST.get('x1', None)
#niter=float(input("Ingrese número de iteraciones: "))
niter = request.POST.get('iter', None)
#tol=float(input("Ingrese tolerancia: "))
tol = request.POST.get('tol', None)
#func=str(input("Ingrese la función: "))
func = request.POST.get('func', None)
x0 = float(x0)
x1 = float(x1)
niter = int(niter)
tol = float(tol)
t = PrettyTable(['iterations', 'xi', 'f(x)', 'Error'])
t.border = False
t.header = False
parser = Parser()
fx0 = parser.parse(func).evaluate({'x': x0})
if fx0 == 0:
print("{} es raíz".format(x0))
else:
fx1 = parser.parse(func).evaluate({'x': x1})
cont = 1
error = tol + 1
x0melo = "{:f}".format(x0)
fximelo = "{:e}".format(fx0)
x1melo = "{:f}".format(x1)
fx2melo = "{:e}".format(fx1)
print(" | ", " Iter ", " | ", " xi ", " | ", " f(xi) ",
" | ", " error (E) ", " | ")
print(" | ", "0", " | ", x0melo, " | ", fximelo, " | ",
" | ")
t.add_row([
" | " + str(0) + " | ",
str(x0melo) + " | ",
str(fximelo) + " | ", " | "
])
print(" | ", "1", " | ", x1melo, " | ", fx2melo, " | ",
" | ")
t.add_row([
" | " + str(1) + " | ",
str(x0melo) + " | ",
str(fximelo) + " | ", " | "
])
while error > tol and fx1 != 0 and (fx1 - fx0) != 0 and cont < niter:
fx0 = parser.parse(func).evaluate({'x': x0})
fx1 = parser.parse(func).evaluate({'x': x1})
x2 = x1 - fx1 * (x1 - x0) / (fx1 - fx0)
fx2 = parser.parse(func).evaluate({'x': x2})
error = abs(x2 - x1)
cont = cont + 1
x0melo = "{:f}".format(x2)
fximelo = "{:e}".format(fx2)
errmelo = "{:e}".format(error)
print(" | ", cont, " | ", x0melo, " | ", fximelo, " | ",
errmelo, " | ")
t.add_row([
" | " + str(cont) + " | ",
str(x0melo) + " | ",
str(fximelo) + " | ",
str(errmelo) + " | "
])
x0 = x1
x1 = x2
if fx1 == 0:
print("{} es una raiz".format(x1))
else:
if error < tol:
print("{} es aproximación a una raiz con una tolerancia de {}".
format(x1, error))
else:
if (fx1 - fx0) == 0:
print("Hay una posible raíz múltiple")
else:
print("El método fracasó en {} iteraciones".format(niter))
context4 = {'vec': t}
return render(request, "secantres.html", context4)
def generate_graph(self, graph_file, print_edges = False, flow = 0):
"""
Reads the .net file and return it's infos.
The infos are:
function(s)
node(s)
arc(s)
edge(s)
od(s)
It should be following the specification from:
https://wiki.inf.ufrgs.br/Network_files_specification
It returns a list of vertices(V), a list of edges(E) and a list of OD(ODlist)
Tests:
>>> Experiment(8, './networks/OW10_1/OW10_1.net', 1, 'OW').\
generate_graph('./networks/OW10_1/OW10_1.net') #doctest:+NORMALIZE_WHITESPACE
(['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M'], ['A-B', 'B-A', 'A-C', \
'C-A', 'A-D', 'D-A', 'B-D', 'D-B', 'B-E', 'E-B', 'C-D', 'D-C', 'C-F', 'F-C', 'C-G', 'G-C',\
'D-E', 'E-D', 'D-G', 'G-D', 'D-H', 'H-D', 'E-H', 'H-E', 'F-G', 'G-F', 'F-I', 'I-F', 'G-H',\
'H-G', 'G-J', 'J-G', 'G-K', 'K-G', 'H-K', 'K-H', 'I-J', 'J-I', 'I-L', 'L-I', 'J-K', 'K-J',\
'J-L', 'L-J', 'J-M', 'M-J', 'K-M', 'M-K'], [('A', 'L', 600), ('A', 'M', 400),\
('B', 'L', 300), ('B', 'M', 400)])
In order: The vertice list, edge list and the OD list.
Vertices -> ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M']
Edges -> ['A-B', 'B-A', 'A-C', 'C-A', 'A-D', 'D-A', 'B-D', 'D-B', 'B-E', 'E-B', 'C-D',
'D-C', 'C-F', 'F-C', 'C-G', 'G-C', 'D-E', 'E-D', 'D-G', 'G-D', 'D-H', 'H-D',
'E-H', 'H-E', 'F-G', 'G-F', 'F-I', 'I-F', 'G-H', 'H-G', 'G-J', 'J-G', 'G-K',
'K-G', 'H-K', 'K-H', 'I-J', 'J-I', 'I-L', 'L-I', 'J-K', 'K-J', 'J-L', 'L-J',
'J-M', 'M-J', 'K-M', 'M-K']
OD -> [('A', 'L', 600), ('A', 'M', 400), ('B', 'L', 300), ('B', 'M', 400)]
"""
vertices = []
edges = []
functions = {}
od_list = []
for line in open(graph_file, 'r'):
taglist = string.split(line)
if taglist[0] == 'function':
variables = []
variables = taglist[2].replace("(", "")
variables = variables.replace(")", "")
variables = variables.split(",")
functions[taglist[1]] = [taglist[3], variables]
elif taglist[0] == 'node':
vertices.append(Node(taglist[1]))
elif taglist[0] == 'dedge' or taglist[0] == 'edge':
constants = []
cost_formula = ""
freeflow_cost = 0
constant_acc = 0
if len(taglist) > 5:
i = 5
while i <= (len(taglist) - 1):
constants.append(taglist[i])
i += 1
parser = Parser()
##[4] is function name.[0] is expression
exp = parser.parse(functions[taglist[4]][0])
LV = exp.variables()
buffer_LV = []
for l in LV:
if l not in functions[taglist[4]][1]:
constant_acc += 1
buffer_LV.append(l)
#check if the formula has any parameters(variables)
flag = False
for v in functions[taglist[4]][1]:
if v in LV:
flag = True
buffer_dic = {}
i = 0
for index in range(constant_acc):
buffer_dic[buffer_LV[index]] = float(constants[index])
i = 1
if not flag:
freeflow_cost = exp.evaluate(buffer_dic)
cost_formula = str(freeflow_cost)
elif is_number(functions[taglist[4]][0]):
freeflow_cost = float(functions[taglist[4]][0])
cost_fomula = functions[taglist[4]][0]
else:
exp = exp.simplify(buffer_dic)
cost_formula = exp.toString()
exp = Parser()
cost_formula2 = "(" + cost_formula + ") + flow"
exp = exp.parse(cost_formula2)
freeflow_cost = exp.evaluate({'f': 0, 'flow': flow}) # Hardcoded
edges.append(Edge(taglist[2], taglist[3],
freeflow_cost, cost_formula))
if taglist[0] == 'edge':
edges.append(Edge(taglist[3], taglist[2],
freeflow_cost, cost_formula))
else:
cost_formula = ""
freeflow_cost = 0
parser = Parser()
if is_number(functions[taglist[4]][0]):
cost_formula = functions[taglist[4]][0]
freeflow_cost = float(functions[taglist[4]][0])
else:
exp = parser.parse(functions[taglist[4]][0])
cost_formula = exp.toString()
cost_formula2 = "(" + cost_formula + ") + flow"
exp = exp.parse(cost_formula2)
freeflow_cost = exp.evaluate({'f': 0, 'flow': flow}) # hardcoded
edges.append(Edge(taglist[2], taglist[3],
freeflow_cost, cost_formula))
edges.append(Edge(taglist[3], taglist[2],
freeflow_cost, cost_formula))
elif taglist[0] == 'od':
od_list.append((taglist[2], taglist[3], int(taglist[4])))
'''
Print edges but there are too many lines to be printed!!
'''
if print_edges:
for e in edges:
print("Edge " + str(e.start) + "-"
+ str(e.end) + " has length: " + str(e.length))
return vertices, edges, od_list
class Plotter():
def __init__(self):
self.parser = Parser()
self.functions = {}
self.fInfo = {}
self.info = {
"label": "function",
"data": False,
"color": "b",
"x": np.linspace(-5.0, 5.0, 501),
"y": None,
"xLabel": 'x label',
"yLabel": 'y label',
"xyLabelTrue": False,
"title": "Plotter result",
"legend": True
}
def check(self, expr):
try:
e = self.parser.parse(expr)
except Exception as e:
print(e)
return None
return e
def add(self, f, **exInfo):
expression = self.check(f)
if expression is not None:
self.functions[f] = expression
else:
print("parser: can't add the function " + f)
return
if exInfo:
self.fInfo[f] = exInfo
else:
info = self.info.copy()
info['label'] = f
self.fInfo[f] = info
def delete(self, f):
if f in self.functions:
self.functions.pop(f)
def clear(self):
plt.cla()
def setY(self, f, x):
if x:
y = []
for i in self.fInfo[f]['x']:
try:
y.append(self.functions[f].evaluate({x: i}))
except ValueError as e:
y.append(np.nan)
self.fInfo[f]['y'] = np.array(y)
else:
v = self.functions[f].evaluate({})
self.fInfo[f]['y'] = np.array(len(self.fInfo[f]['x']) * [v])
def findArg(self, d):
count = 0
j = 0
for i in d:
if len(i) == 1 and (i not in ['e', 'E']):
count += 1
j = i
return {'count': count, 'x': False or j}
def setText(self, F):
if F["xyLabelTrue"]:
plt.xlabel(F["xlabel"])
plt.ylabel(F["ylabel"])
plt.title(F["title"])
def plotF(self, f):
if f not in self.functions:
return
symbols = self.findArg(self.functions[f].symbols())
if symbols['count'] > 1:
raise Exception('too much arguments of function' + f)
elif symbols['x'] == f and len(f) > 1:
raise Exception("plotF: error input, the function " + f)
F = self.fInfo[f]
self.setText(F)
try:
self.setY(f, symbols['x'])
if symbols['x']:
F['y'][:-1][np.abs(np.diff(F['y'])) > 0.6] = np.nan
plt.plot(F['x'], F['y'], label=F['label'])
except Exception as e:
print("evaluate: " + f + " doesn't evaluate")
print(e)
def plot(self, f=None, legend=False):
if f in self.functions.keys():
self.plotF(f)
else:
for f in self.functions:
self.plotF(f)
if legend:
plt.legend()
plt.ylim(-5, 5)
plt.savefig('plot' + '.png')
# plt.show()
def deleteAll(self):
self.clear()
self.functions.clear()
self.fInfo.clear()
def test_plot():
from py_expression_eval import Parser
parser = Parser()
expr = parser.parse('x^2 + y^2')
plotter = Plotter(expr, expr.toString())
plotter.plot_function_in_3D()
class math:
def __init__(self):
self.parser = Parser()
def transform(self, spec, value):
return self.parser.parse(spec).evaluate({'x': value})
import numpy as np
import matplotlib.pyplot as plt
from matplotlib import cm
from py_expression_eval import Parser
parser = Parser()
class F(object):
"""
Find zeroes of an arbitrary function f(x)
methods:
* Bisection(a,b)
* Regula Falsi(a,b)
* Secant(x0,x1)
* Newton(x0)
"""
def __init__(self,f_expr, max_iter=100):
self.max_iter = max_iter - 1
self.sols = [0]
self.f_raw = parser.parse(f_expr)
self.tol = 0.1
@property
def sol(self):
return self.sols[-1]
@property
def num_iter(self):
return len(self.sols)
def f(self, x):
return self.f_raw.evaluate({'x': x})
def __init__(self):
self.parser = Parser()
class ParserTestCase(unittest.TestCase):
def setUp(self):
self.parser = Parser()
def assertExactEqual(self, a, b):
self.assertEqual(type(a), type(b))
self.assertEqual(a, b)
def test_parser(self):
parser = Parser()
# parser and variables
self.assertEqual(parser.parse('pow(x,y)').variables(), ['x', 'y'])
self.assertEqual(parser.parse('pow(x,y)').symbols(), ['pow', 'x', 'y'])
# but '"a b"' can *not* be used as a variable
self.assertEqual(
parser.parse('"a b"*2').evaluate({'"a b"': 2}), "a ba b")
# unless parse configured to allow double quoted variables (i.e. allow multi-word vars)
parser2 = Parser(
string_literal_quotes=("'")) # only single, not double!
self.assertEqual(parser2.parse('"a b"*2').evaluate({'"a b"': 2}), 4)
# evaluate
self.assertExactEqual(parser.parse('1').evaluate({}), 1)
self.assertExactEqual(parser.parse('a').evaluate({'a': 2}), 2)
self.assertExactEqual(parser.parse('2 * 3').evaluate({}), 6)
self.assertExactEqual(parser.parse(u'2 \u2219 3').evaluate({}), 6)
self.assertExactEqual(parser.parse(u'2 \u2022 3').evaluate({}), 6)
self.assertExactEqual(parser.parse('2 ^ x').evaluate({'x': 3}), 8)
self.assertExactEqual(parser.parse('2 ** x').evaluate({'x': 3}), 8)
self.assertExactEqual(
parser.parse('-1.E2 ** x + 2.0E2').evaluate({'x': 1}), 100.0)
self.assertEqual(parser.parse('x < 3').evaluate({'x': 3}), False)
self.assertEqual(parser.parse('x < 3').evaluate({'x': 2}), True)
self.assertEqual(parser.parse('x <= 3').evaluate({'x': 3}), True)
self.assertEqual(parser.parse('x <= 3').evaluate({'x': 4}), False)
self.assertEqual(parser.parse('x > 3').evaluate({'x': 4}), True)
self.assertEqual(parser.parse('x >= 3').evaluate({'x': 3}), True)
self.assertExactEqual(parser.parse('2 * x + 1').evaluate({'x': 3}), 7)
self.assertExactEqual(parser.parse('2 + 3 * x').evaluate({'x': 4}), 14)
self.assertExactEqual(
parser.parse('(2 + 3) * x').evaluate({'x': 4}), 20)
self.assertExactEqual(
parser.parse('2-3.0^x').evaluate({'x': 4}), -79.0)
self.assertExactEqual(
parser.parse('-2-3.0^x').evaluate({'x': 4}), -83.0)
self.assertExactEqual(parser.parse('-3^x').evaluate({'x': 4}), -81)
self.assertExactEqual(parser.parse('(-3)^x').evaluate({'x': 4}), 81)
self.assertExactEqual(parser.parse('2-3**x').evaluate({'x': 4}), -79)
self.assertExactEqual(parser.parse('-2-3**x').evaluate({'x': 4}), -83)
self.assertExactEqual(
parser.parse('-3.0**x').evaluate({'x': 4}), -81.0)
self.assertExactEqual(
parser.parse('(-3.0)**x').evaluate({'x': 4}), 81.0)
self.assertExactEqual(
parser.parse('2*x + y').evaluate({
'x': 4,
'y': 1
}), 9)
self.assertEqual(
parser.parse("x||y").evaluate({
'x': 'hello ',
'y': 'world'
}), 'hello world')
self.assertEqual(parser.parse("'x'||'y'").evaluate({}), 'xy')
self.assertEqual(parser.parse("'x'=='x'").evaluate({}), True)
self.assertEqual(
parser.parse("(a+b)==c").evaluate({
'a': 1,
'b': 2,
'c': 3
}), True)
self.assertEqual(
parser.parse("(a+b)!=c").evaluate({
'a': 1,
'b': 2,
'c': 3
}), False)
self.assertEqual(
parser.parse("(a^2-b^2)==((a+b)*(a-b))").evaluate({
'a': 4859,
'b': 13150
}), True)
self.assertEqual(
parser.parse("(a^2-b^2+1)==((a+b)*(a-b))").evaluate({
'a': 4859,
'b': 13150
}), False)
self.assertEqual(
parser.parse("(a**2-b**2)==((a+b)*(a-b))").evaluate({
'a': 4859,
'b': 13150
}), True)
self.assertEqual(
parser.parse("(a**2-b**2+1)==((a+b)*(a-b))").evaluate({
'a': 4859,
'b': 13150
}), False)
self.assertExactEqual(
parser.parse("x/((x+y))").simplify({}).evaluate({
'x': 1,
'y': 1
}), 0.5)
self.assertExactEqual(
parser.parse('origin+2.0').evaluate({'origin': 1.0}), 3.0)
# logical expressions
self.assertExactEqual(
parser.parse('a and b').evaluate({
'a': True,
'b': False
}), False)
self.assertExactEqual(
parser.parse('a and not b').evaluate({
'a': True,
'b': False
}), True)
self.assertExactEqual(
parser.parse('a or b').evaluate({
'a': True,
'b': False
}), True)
self.assertExactEqual(
parser.parse('a xor b').evaluate({
'a': True,
'b': True
}), False)
# check precedents: AND should evaluate before OR
self.assertExactEqual(
parser.parse('a or b and not a').evaluate({
'a': True,
'b': False
}), True)
# in operations
self.assertExactEqual(
parser.parse('"ab" in ("ab", "cd")').evaluate({}), True)
self.assertExactEqual(
parser.parse('"ee" in ("ab", "cd")').evaluate({}), False)
self.assertExactEqual(
parser.parse('1 in (1, 2, 3)').evaluate({}), True)
self.assertExactEqual(
parser.parse('"ab" in ("ab", "cd") and 1 in (1,2,3)').evaluate({}),
True)
self.assertExactEqual(
parser.parse('"word" in "word in sentence"').evaluate({}), True)
# functions
self.assertExactEqual(parser.parse('pyt(2 , 0)').evaluate({}), 2.0)
self.assertEqual(
parser.parse("concat('Hello',' ','world')").evaluate({}),
'Hello world')
self.assertExactEqual(
parser.parse('if(a>b,5,6)').evaluate({
'a': 8,
'b': 3
}), 5)
self.assertExactEqual(
parser.parse('if(a,b,c)').evaluate({
'a': None,
'b': 1,
'c': 3
}), 3)
self.assertExactEqual(
parser.parse('if(random(1)>1,1,0)').evaluate({}), 0)
# log with base or natural log
self.assertExactEqual(parser.parse('log(16,2)').evaluate({}), 4.0)
self.assertExactEqual(parser.parse('log(E^100)').evaluate({}), 100.0)
self.assertExactEqual(parser.parse('log(E**100)').evaluate({}), 100.0)
# test substitute
expr = parser.parse('2 * x + 1')
expr2 = expr.substitute('x', '4 * x') # ((2*(4*x))+1)
self.assertExactEqual(expr2.evaluate({'x': 3}), 25)
# test simplify
expr = parser.parse('x * (y * atan(1))').simplify({'y': 4})
self.assertIn('x*3.141592', expr.toString())
self.assertExactEqual(expr.evaluate({'x': 2}), 6.283185307179586)
# test toString with string constant
expr = parser.parse("'a'=='b'")
self.assertIn("'a'=='b'", expr.toString())
self.assertIn("'a'=='b'", "%s" % expr)
expr = parser.parse("concat('a\n','\n','\rb')=='a\n\n\rb'")
self.assertEqual(expr.evaluate({}), True)
expr = parser.parse("a==''")
self.assertEqual(expr.evaluate({'a': ''}), True)
# test toString with an external function
expr = parser.parse("myExtFn(a,b,c,1.51,'ok')")
self.assertEqual(
expr.substitute("a", 'first').toString(),
"myExtFn(first,b,c,1.51,'ok')")
# test variables
expr = parser.parse('x * (y * atan(1))')
self.assertEqual(expr.variables(), ['x', 'y'])
self.assertEqual(expr.simplify({'y': 4}).variables(), ['x'])
# list operations
self.assertEqual(
parser.parse('a, 3').evaluate({'a': [1, 2]}), [1, 2, 3])
def test_consts(self):
# self.assertEqual(self.parser.parse("PI ").variables(), [""])
self.assertEqual(self.parser.parse("PI").variables(), [])
self.assertEqual(self.parser.parse("PI ").variables(), [])
self.assertEqual(self.parser.parse("E ").variables(), [])
self.assertEqual(self.parser.parse(" E").variables(), [])
self.assertEqual(self.parser.parse("E").variables(), [])
self.assertEqual(self.parser.parse("E+1").variables(), [])
self.assertEqual(self.parser.parse("E / 1").variables(), [])
self.assertEqual(self.parser.parse("sin(PI)+E").variables(), [])
def test_parsing_e_and_pi(self):
self.assertEqual(self.parser.parse('Pie').variables(), ["Pie"])
self.assertEqual(self.parser.parse('PIe').variables(), ["PIe"])
self.assertEqual(self.parser.parse('Eval').variables(), ["Eval"])
self.assertEqual(self.parser.parse('Eval1').variables(), ["Eval1"])
self.assertEqual(self.parser.parse('EPI').variables(), ["EPI"])
self.assertEqual(self.parser.parse('PIE').variables(), ["PIE"])
self.assertEqual(self.parser.parse('Engage').variables(), ["Engage"])
self.assertEqual(
self.parser.parse('Engage * PIE').variables(), ["Engage", "PIE"])
self.assertEqual(self.parser.parse('Engage_').variables(), ["Engage_"])
self.assertEqual(self.parser.parse('Engage1').variables(), ["Engage1"])
self.assertEqual(self.parser.parse('E1').variables(), ["E1"])
self.assertEqual(self.parser.parse('PI2').variables(), ["PI2"])
self.assertEqual(self.parser.parse('(E1 + PI)').variables(), ["E1"])
self.assertEqual(self.parser.parse('E1_').variables(), ["E1_"])
self.assertEqual(self.parser.parse('E_').variables(), ["E_"])
def test_evaluating_consts(self):
self.assertExactEqual(
self.parser.evaluate("Engage1", variables={"Engage1": 2}), 2)
self.assertExactEqual(
self.parser.evaluate("Engage1 + 1", variables={"Engage1": 1}), 2)
def test_custom_functions(self):
parser = Parser()
def testFunction0():
return 13
def testFunction1(a):
return 2 * a + 9
def testFunction2(a, b):
return 2 * a + 3 * b
# zero argument functions don't currently work
# self.assertEqual(parser
# .parse('testFunction()')
# .evaluate({"testFunction":testFunction0}),13)
self.assertExactEqual(
parser.parse('testFunction(x)').evaluate({
"x":
2,
"testFunction":
testFunction1
}), 13)
self.assertExactEqual(
parser.parse('testFunction(x , y)').evaluate({
"x":
2,
"y":
3,
"testFunction":
testFunction2
}), 13)
# Add some "built-in" functions
def mean(*xs):
return sum(xs) / len(xs)
parser.functions['mean'] = mean
def counter(initial):
class nonlocals:
x = initial
def count(increment):
nonlocals.x += increment
return nonlocals.x
return count
parser.functions['count'] = counter(0)
self.assertEqual(parser.parse("mean(xs)").variables(), ["xs"])
self.assertEqual(parser.parse("mean(xs)").symbols(), ["mean", "xs"])
self.assertEqual(
parser.evaluate("mean(xs)", variables={"xs": [1, 2, 3]}), 2)
self.assertExactEqual(
parser.evaluate("count(num)", variables={"num": 5}), 5)
self.assertExactEqual(
parser.evaluate("count(num)", variables={"num": 5}), 10)
def test_custom_functions_with_inline_strings(self):
parser = Parser()
expr = parser.parse("func(1, \"func(2, 4)\")")
self.assertEqual(expr.variables(), ['func'])
expr = parser.parse("func(1, 'func(2, 4)')")
self.assertEqual(expr.variables(), ['func'])
parser2 = Parser(string_literal_quotes=("'"))
expr = parser2.parse("func(1, \"func(2, 4)\")")
self.assertEqual(expr.variables(), ['func', "\"func(2, 4)\""])
expr = parser2.parse("func(1, 'func(2, 4)')")
self.assertEqual(expr.variables(), ['func'])
def test_custom_functions_substitute_strings(self):
def func(var, str):
if str == "custom text":
return 1
if str == "foo":
return 2
return 0
parser = Parser()
expr = parser.parse("func(1, \"custom text\")")
self.assertEqual(expr.evaluate({"func": func}), 1)
parser = Parser(string_literal_quotes=("'"))
expr = parser.parse("func(1, \"custom text\")")
self.assertEqual(
expr.evaluate({
"func": func,
"\"custom text\"": "foo"
}), 2)
def test_decimals(self):
parser = Parser()
self.assertExactEqual(
parser.parse(".1").evaluate({}),
parser.parse("0.1").evaluate({}))
self.assertExactEqual(
parser.parse(".1*.2").evaluate({}),
parser.parse("0.1*0.2").evaluate({}))
self.assertExactEqual(parser.parse(".5^3").evaluate({}), float(0.125))
self.assertExactEqual(parser.parse("16^.5").evaluate({}), 4.0)
self.assertExactEqual(parser.parse(".5**3").evaluate({}), float(0.125))
self.assertExactEqual(parser.parse("16**.5").evaluate({}), 4.0)
self.assertExactEqual(parser.parse("8300*.8").evaluate({}), 6640.0)
self.assertExactEqual(parser.parse("1E3*2.0").evaluate({}), 2000.0)
self.assertExactEqual(parser.parse("-1e3*2.0").evaluate({}), -2000.0)
self.assertExactEqual(
parser.parse("-1E3*2.E2").evaluate({}), -200000.0)
with self.assertRaises(ValueError):
parser.parse("..5").evaluate({})
def test_to_string(self):
parser = Parser()
self.assertEqual(
parser.parse("-12 * a + -2").toString(), '(((-12)*a)+(-2))')
__version__ = "1.2.0"
load_dotenv(dotenv_path=bot_dir /
".env") # Added path to support older versions of python-dotenv
config = ConfigParser()
config.read("brainbot.ini")
tell_me_to_cooldown = Cooldown(
config.getint("cooldowns", "tell_me_to", fallback=200))
topic_cooldown = Cooldown(config.getint("cooldowns", "topic", fallback=100))
repeat_cooldown = Cooldown(config.getint("cooldowns", "repeat", fallback=45))
phon_cooldown = Cooldown(config.getint("cooldowns", "phon", fallback=45))
math_parser = Parser()
topic_engine = TopicGenerator()
translator = Translator()
# Wrap in async function to use async context manager
async def main():
# Log into Ryver with regular username/password
async with Ryver(getenv("RYVER_ORG"), getenv("RYVER_USER"),
getenv("RYVER_PASS")) as ryver:
console.log(
f"Connected to {ryver.org} Ryver org as user {getenv('RYVER_USER')}"
)
# Save the bot chat to compare with all incoming messages
await ryver.load_chats()
def calculate_hessian(self):
self.gxy, self.gxx = np.gradient(self.gx, self.dy, self.dx)
self.gyy, self.gyx = np.gradient(self.gy, self.dy, self.dx)
def get_gradient_at_id(self, id_x, id_y):
return self.gx[id_y][id_x], self.gy[id_y][id_x]
def get_hessian_at_id(self, id_x, id_y):
return self.gxx[id_y][id_x], self.gxy[id_y][id_x],\
self.gyx[id_y][id_x], self.gyy[id_y][id_x]
if __name__ == "__main__":
from py_expression_eval import Parser
parser = Parser()
expr = parser.parse('x^2 + y^3*x')
ga = GradientAlgorithm(expr, [-4., -4.], [4., 4.], [801, 801])
print "---------------------------"
print "Gradient: "
print ga.get_gradient_at(-2., -1.)
print ga.get_gradient_as_array_at(-2., -1.)
print "---------------------------"
print "Hessian: "
print ga.get_hessian_at(-2., -1.)
print ga.get_hessian_as_array_at(-2., -1.)
print "---------------------------"
print "Gradient: "
print ga.get_gradient_at(1.2, 0.6)
print ga.get_gradient_as_array_at(1.2, 0.6)
print "---------------------------"
def test_parser(self):
parser = Parser()
self.assertEqual(parser.parse('2 * 3').evaluate({}), 6)
self.assertEqual(parser.parse('2 ^ x').evaluate({'x': 3}), 8)
self.assertEqual(parser.parse('2 * x + 1').evaluate({'x': 3}), 7)
self.assertEqual(parser.parse('2 + 3 * x').evaluate({'x': 4}), 14)
self.assertEqual(parser.parse('(2 + 3) * x').evaluate({'x': 4}), 20)
self.assertEqual(parser.parse('2-3^x').evaluate({'x': 4}), -79)
self.assertEqual(parser.parse('-2-3^x').evaluate({'x': 4}), -83)
self.assertEqual(parser.parse('-3^x').evaluate({'x': 4}), -81)
self.assertEqual(parser.parse('(-3)^x').evaluate({'x': 4}), 81)
self.assertEqual(parser.parse('2*x + y').evaluate({'x': 4, 'y': 1}), 9)
# test substitute
expr = parser.parse('2 * x + 1')
expr2 = expr.substitute('x', '4 * x') # ((2*(4*x))+1)
self.assertEqual(expr2.evaluate({'x': 3}), 25)
# test simplify
expr = parser.parse('x * (y * atan(1))').simplify({'y': 4})
self.assertIn('x*3.141592', expr.toString())
self.assertEqual(expr.evaluate({'x': 2}), 6.283185307179586)
# test variables
expr = parser.parse('x * (y * atan(1))')
self.assertEqual(expr.variables(), ['x', 'y'])
self.assertEqual(expr.simplify({'y': 4}).variables(), ['x'])
def setUp(self):
self.parser = Parser()
def preprocess(question, equation):
"""
Returns preprocessed version of question and equation
"""
# handle %'s
question = question.replace('%', ' % ')
# handle fractions
parser = Parser()
fractions = re.findall('\(\d+\)/\(\d+\)', question)
fractions = np.append(fractions, re.findall('\(\d+/\d+\)', question))
for i, fraction in enumerate(fractions):
#question = question.replace(fraction, str(sys.maxsize - i))
#equation = equation.replace(fraction, str(sys.maxsize - i))
question = question.replace(
fraction, str(parser.evaluate(fraction, variables=None)))
equation = equation.replace(
fraction, str(parser.evaluate(fraction, variables=None)))
# handle numbers with units
question = re.sub(r'(\d+)([A-z]{1,2})', r'\1 \2', question)
# seperate equation at operators
print('equation (before):', equation)
equation = equation.replace('[', ' ( ')
equation = equation.replace(']', ' ) ')
equation = equation.replace('+', ' + ')
equation = equation.replace('+', ' + ')
equation = equation.replace('-', ' - ')
equation = equation.replace('*', ' * ')
equation = equation.replace('/', ' / ')
equation = equation.replace('(', ' ( ')
equation = equation.replace(')', ' ) ')
equation = equation.replace('=', ' = ')
equation = equation.replace('^', ' ^ ')
# reduce %'s
equation = equation.replace('%', ' / 100 ')
# Preprocess Question
question = question.split()
question = np.append(['null', 'null', 'null'], question)
question = np.append(question, ['null', 'null', 'null'])
numbers = np.array([token for token in question
if isFloat(token)]) # or float(token) == 2)])
_, indices = np.unique(numbers, return_index=True)
numbers = numbers[np.sort(indices)]
equation = np.array([token.strip() for token in equation.split(' ')])
examples = []
print('equation:', equation)
for i, number in enumerate(numbers):
index = np.where(question == number)[0][0]
src = question[index - 3:index + 4]
src = ' '.join(src)
if number.strip() in equation:
examples = np.append(examples, [src + '\t' + 'yes'])
print('example:', src + '\t' + 'yes')
else:
examples = np.append(examples, [src + '\t' + 'no'])
print('example:', src + '\t' + 'no')
return examples
def get_or_construct_value(df, variable_name = None, index_by_variable = None, years = None, fill_value = numpy.NaN,
verbose = False):
"""
Returns the DateFrame (1 column) of the value of economic variable(s) for years of interest.
Years are set to the index of the DataFrame.
Parameters
----------
df : DataFrame
DataFrame generated by get_comptes_nationaux_data(year)
variable : string or dictionary
Variable to get or to construct (by applying formula).
index_by_variable : dictionary
Contains all economic variables indexes and formula. Variables appearing in formula of variable should be
listed in index_by_variable.
years : list of integers
Years of interest
Example
--------
>>> table_cn = get_comptes_nationaux_data(2013)
>>> index_by_variable = {
... 'Interets_verses_par_rdm': {
... 'code': 'D41',
... 'institution': 'S2',
... 'ressources': False,
... 'description': ''
... },
... 'Dividendes_verses_par_rdm_D42': {
... 'code': 'D42',
... 'institution': 'S2',
... 'ressources': False,
... 'description': ''
... },
... 'Dividendes_verses_par_rdm_D43': {
... 'code': 'D43',
... 'institution': 'S2',
... 'ressources': False,
... 'description': ''
... },
... 'Revenus_propriete_verses_par_rdm': {
... 'code': 'D44',
... 'institution': 'S2',
... 'ressources': False,
... 'description': ''
... },
... 'Interets_dividendes_verses_par_rdm': {
... 'code': None,
... 'institution': 'S2',
... 'ressources': False,
... 'description': 'Interets et dividendes verses par RDM, nets',
... 'formula': 'Interets_verses_par_rdm + Dividendes_verses_par_rdm_D42 + Dividendes_verses_par_rdm_D43 + Revenus_propriete_verses_par_rdm'
... }
... }
>>> computed_variable_vector, computed_variable_formula = get_or_construct(
... df, 'Interets_dividendes_nets_verses_par_rdm', index_by_variable
... )
Returns a tuple, where the first element is a DataFrame (with a single column) for years 1949 to 2013 of the value
of the sum of the four variables, and the second element is the formula 'Interets_verses_par_rdm +
Dividendes_verses_par_rdm_D42 + Dividendes_verses_par_rdm_D43 + Revenus_propriete_verses_par_rdm'
"""
assert df is not None
assert variable_name is not None
assert years is not None
df = df.copy()
if index_by_variable is None:
index_by_variable = {
variable_name: {'code': variable_name}
}
variable = index_by_variable.get(variable_name, None)
assert variable is not None, "{} not found".format(variable_name)
formula = variable.get('formula')
dico_value = dict()
entry_df = look_up(df, variable, years)
index = None
if not entry_df.empty:
result_data_frame = entry_df[['value', 'year']].copy()
result_data_frame.drop_duplicates(inplace = True)
result_data_frame.rename(columns = dict(value = variable_name))
result_data_frame.set_index('year', inplace = True, verify_integrity = True)
result_data_frame.sort_index(inplace = True)
final_formula = variable_name
# For formulas that are not real formulas but that are actually a mapping
elif (not formula) and entry_df.empty:
result_data_frame = pandas.DataFrame(data = [fill_value] * len(years), index = years)
final_formula = ''
else:
# When formula is a list of dictionnaries with start and end years
if isinstance(formula, list):
result_data_frame = pandas.DataFrame()
for individual_formula in formula:
assert individual_formula['start'] or individual_formula['end']
start = individual_formula.get('start', None)
end = individual_formula.get('end', None)
local_index_by_variable = copy.deepcopy(index_by_variable)
local_index_by_variable[variable_name]['formula'] = individual_formula['formula']
actual_years = list(set(range(
max(start, min(years)) if (start is not None) else min(years),
min(end + 1, max(years) + 1) if (end is not None) else (max(years) + 1),
)))
variable_value, final_formula = get_or_construct_value(
df, variable_name, local_index_by_variable, actual_years, fill_value = fill_value)
if variable_value.empty:
variable_value = pandas.DataFrame({variable_name: [fill_value]}, index = actual_years)
variable_value.index.name = 'year'
result_data_frame = pandas.concat((result_data_frame, variable_value))
return result_data_frame, 'formula changes accross time'
parser_formula = Parser()
try:
expr = parser_formula.parse(formula)
except Exception as e:
log.info('Got the following error when evaluation formula: \n {}'.format(formula))
raise(e)
variables = expr.variables()
for component in variables:
if verbose:
log.error('Component {} of the formula'.format(component))
log.error(pretty_printer(index_by_variable))
variable_value, variable_formula = get_or_construct_value(
df, component, index_by_variable, years, fill_value = fill_value)
if verbose:
log.info(variable_value)
if index is None:
index = variable_value.index
assert len(variable_value.index) == len(variable_value.index.unique()), \
"Component {} does not have a single valued index.\n The following values {} are duplicated".format(
component, variable_value.index[variable_value.index.duplicated()])
# else:
# equality_index_test = (
# numpy.sort(index.unique()) != numpy.sort(variable_value.index.unique())
# )
# try:
# reindexing_condition = equality_index_test.any()
# except AttributeError:
# reindexing_condition = equality_index_test
# if reindexing_condition:
# log.info('index differs {} vs {} after getting {}'.format(
# index, variable_value.index, component))
# index = index.union(variable_value.index)
# log.info('Will be using union index {}'.format(index))
#
formula_with_parenthesis = '(' + variable_formula + ')' # TODO needs a nicer formula output
final_formula = formula.replace(component, formula_with_parenthesis)
dico_value[component] = variable_value
formula_modified = formula.replace("^", "**")
for component, variable_value in dico_value.iteritems(): # Reindexing
if variable_value.empty: # Dealing with completely absent variable
log.info('Variable {} is completely missing'.format(component))
variable_value = pandas.DataFrame({component: [fill_value]}, index = index)
dico_value[component] = variable_value.reindex(index = years, fill_value = fill_value).values.squeeze()
data = eval(formula_modified, dico_value)
# assert data is not None
# assert index is not None
try:
result_data_frame = pandas.DataFrame(
data = {variable_name: data},
index = years,
)
result_data_frame.index.name = 'year'
except Exception, e:
log.error('FAILED')
log.error(variable_name)
log.error('data')
log.error(data)
log.error('index')
log.error(index)
raise(e)
def regresionPolinomial(datos_funcion, grado_polinomio):
if grado_polinomio < 0:
raise GradoPolinomioInvalidoExcepcion
matriz_polinomio = [[0 for j in range(0, grado_polinomio + 1)]
for i in range(0, grado_polinomio + 1)]
terminos_independientes = [[0] for i in range(0, grado_polinomio + 1)]
for n in range(0, grado_polinomio + 1):
sumatoria_potencia_x = 0
sumatoria_y_x = 0
for i in range(0, len(datos_funcion)):
potencia_x = pow(datos_funcion[i][0], n)
sumatoria_potencia_x = sumatoria_potencia_x + potencia_x
sumatoria_y_x = sumatoria_y_x + (datos_funcion[i][1] * potencia_x)
terminos_independientes[n][0] = sumatoria_y_x
for i in range(0, n + 1):
matriz_polinomio[i][n - i] = sumatoria_potencia_x
for n in range(grado_polinomio + 1, 2 * grado_polinomio + 1):
sumatoria_potencia_x = 0
for i in range(0, len(datos_funcion)):
potencia_x = pow(datos_funcion[i][0], n)
sumatoria_potencia_x = sumatoria_potencia_x + potencia_x
for i in range(n - grado_polinomio, grado_polinomio + 1):
matriz_polinomio[i][n - i] = sumatoria_potencia_x
#Resuelve el SEL de los coeficientes del polinomio.
factorizacion_LU = doolittle(matriz_polinomio, terminos_independientes,
0.0005)
solucion_Y = sustitucionHaciaAdelante(factorizacion_LU[0],
terminos_independientes)
coeficientes_polinomio = sustitucionHaciaAtras(factorizacion_LU[1],
solucion_Y)
expresion_polinomio = ""
#Genera la cadena que contiene al polinomio.
#Término independiente del polinomio, si es que hay.
if abs(coeficientes_polinomio[0][0]) >= 0.00001:
if coeficientes_polinomio[0][0] < 0:
expresion_polinomio = expresion_polinomio + " - " + str(
-coeficientes_polinomio[0][0])
if coeficientes_polinomio[0][0] > 0:
expresion_polinomio = expresion_polinomio + " + " + str(
coeficientes_polinomio[0][0])
#Resto de los términos del polinomio, no concatena a la expresión los términos que
#son nulos.
for i in range(1, len(coeficientes_polinomio)):
if abs(coeficientes_polinomio[i][0]) > 0.00001:
if coeficientes_polinomio[i][0] < 0:
if coeficientes_polinomio[i][0] == -1:
expresion_polinomio = expresion_polinomio + " - "
else:
expresion_polinomio = expresion_polinomio + " - " + str(
-coeficientes_polinomio[i][0])
if coeficientes_polinomio[i][0] > 0:
if coeficientes_polinomio[i][0] == 1:
expresion_polinomio = expresion_polinomio + " + "
else:
expresion_polinomio = expresion_polinomio + " + " + str(
coeficientes_polinomio[i][0])
expresion_polinomio = expresion_polinomio + "*x^" + str(i)
parseador_polinomio = Parser()
funcion_polinomio = parseador_polinomio.parse(expresion_polinomio)
return expresion_polinomio, funcion_polinomio
def __init__(self, s):
self.parser = Parser()
self.s = s
self.expr = self.parser.parse(s)
class TestOptimizationAlgorithm(unittest.TestCase):
def setUp(self):
self.parser = Parser()
make_expr = lambda string, start, stop, num_of_val1, num_of_val2: \
[self.parser.parse(string), [start, start],
[stop, stop], [num_of_val1, num_of_val2]]
self.expressions = [
make_expr('x^2 + y^3', -4., 4., 801, 701),
make_expr('y^2*sin(x) + 2*y^4', -4., 4., 1001, 901)
]
self.tests_values = [[[-2., -2.], [1., 2.5], [-1.5, 0]],
[[1., 1.], [-1.5, 2.5]]]
self.answers_values = [[[-4.0], [16.625], [2.25]], [[2.841], [71.89]]]
self.tests_gradient = [[[-2., -2.], [0., -1.5]],
[[1.3, -0.5], [-0.5, 1]]]
self.answers_gradient = [[[-4., 12.], [0., 6.75]],
[[0.0669, -1.9635], [0.8776, 7.0411]]]
self.tests_hessian = [[[-2., 1.5]], [[-2, 1.5]]]
self.answers_hessian = [[[2., 0, 0, 9.]],
[[2.046, -1.248, -1.248, 52.181]]]
def testValues(self):
for i in range(self.expressions.__len__()):
self.opt_alg = OptimizationAlgorithm(*self.expressions[i])
for (test, answer) in zip(self.tests_values[i],
self.answers_values[i]):
self.assertAlmostEqual(answer,
self.opt_alg.value_at(*test),
delta=0.1)
def testGradient(self):
for i in range(self.expressions.__len__()):
self.grad_alg = GradientAlgorithm(*self.expressions[i])
for (test, answer) in zip(self.tests_gradient[i],
self.answers_gradient[i]):
gx, gy = self.grad_alg.get_gradient_at(*test)
self.assertAlmostEqual(answer[0], gx, delta=0.1)
self.assertAlmostEqual(answer[1], gy, delta=0.1)
def testGradientArray(self):
for i in range(self.expressions.__len__()):
self.grad_alg = GradientAlgorithm(*self.expressions[i])
for (test, answer) in zip(self.tests_gradient[i],
self.answers_gradient[i]):
grad = self.grad_alg.get_gradient_as_array_at(*test)
self.assertAlmostEqual(answer[0], grad[0][0], delta=0.1)
self.assertAlmostEqual(answer[1], grad[1][0], delta=0.2)
def testHessian(self):
for i in range(self.expressions.__len__()):
self.grad_alg = GradientAlgorithm(*self.expressions[i])
for (test, answer) in zip(self.tests_hessian[i],
self.answers_hessian[i]):
gxx, gxy, gyx, gyy = self.grad_alg.get_hessian_at(*test)
self.assertAlmostEquals(answer[0], gxx, delta=0.1)
self.assertAlmostEquals(answer[1], gxy, delta=0.1)
self.assertAlmostEquals(answer[2], gyx, delta=0.1)
self.assertAlmostEquals(answer[3], gyy, delta=0.1)
def testHessianArray(self):
for i in range(self.expressions.__len__()):
self.grad_alg = GradientAlgorithm(*self.expressions[i])
for (test, answer) in zip(self.tests_hessian[i],
self.answers_hessian[i]):
hessian = self.grad_alg.get_hessian_as_array_at(*test)
self.assertAlmostEquals(answer[0], hessian[0][0], delta=0.1)
self.assertAlmostEquals(answer[1], hessian[0][1], delta=0.1)
self.assertAlmostEquals(answer[2], hessian[1][0], delta=0.1)
self.assertAlmostEquals(answer[3], hessian[1][1], delta=0.1)
def __init__(self, ex: str):
ex = str(ex)
self._string = ex
self._expression = Parser().parse(ex.replace('**', '^'))
def test_decimals(self):
parser = Parser()
self.assertEqual(parser.parse(".1").evaluate({}), parser.parse("0.1").evaluate({}))
self.assertEqual(parser.parse(".1*.2").evaluate({}), parser.parse("0.1*0.2").evaluate({}))
self.assertEqual(parser.parse(".5^3").evaluate({}), float(0.125))
self.assertEqual(parser.parse("16^.5").evaluate({}), 4)
self.assertEqual(parser.parse("8300*.8").evaluate({}), 6640)
with self.assertRaises(ValueError):
parser.parse("..5").evaluate({})
class Curse():
def __init__(self):
self.stdscr = curses.initscr()
self.WIDTH = curses.COLS
self.HEIGHT = curses.LINES
# dont write on screen and dont wait for enter
curses.noecho()
curses.cbreak()
curses.curs_set(False) # no blinking
curses.start_color() # colors
# epic keys
self.stdscr.keypad(True)
self.stdscr = curses.newwin(self.HEIGHT-1,self.WIDTH,0,0)
self.bottom = curses.newwin(1,self.WIDTH,self.HEIGHT-1,0)
self.bar(default_items)
curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_BLACK)
if curses.has_colors():
curses.init_pair(2, curses.COLOR_RED, curses.COLOR_BLACK)
curses.init_pair(3, curses.COLOR_YELLOW, curses.COLOR_BLACK)
curses.init_pair(4, curses.COLOR_GREEN, curses.COLOR_BLACK)
curses.init_pair(5, curses.COLOR_CYAN, curses.COLOR_BLACK)
self.grapher = Grapher(self.stdscr,self.WIDTH,self.HEIGHT)
self.painter = Painter(self.stdscr,self.WIDTH,self.HEIGHT)
self.parser = Parser()
self.command_hist = []
self.command_indx = -1
def clear(self):
self.stdscr.clear()
self.stdscr.refresh()
def quit(self):
# kill it
curses.nocbreak()
self.stdscr.keypad(False)
curses.echo()
curses.endwin()
def test(self):
self.clear()
self.stdscr.addstr(0,0,'\nthis screen is {} wide and {} tall'.format(self.WIDTH,self.HEIGHT))
if curses.has_colors():
self.stdscr.addstr('\nthis screen should support color')
for i in range(1,6):
self.stdscr.addstr('\n' + str(i) , curses.color_pair(i))
else:
self.stdscr.addstr('\nthis screen does not support color')
self.stdscr.refresh()
def bar(self,items):
def make_el(msg):
l = len(msg)
if l < 7: msg += ' '*(7-l)
self.bottom.addstr(msg[0].upper(),curses.A_STANDOUT)
self.bottom.addstr(msg[1:6].lower() + ' ')
self.bottom.clear()
self.bottom.move(0,1)
# to-do enforce max amount of menu elements disp ... if more :^)
for msg in items[1:]:
make_el(msg)
self.bottom.move(0,self.WIDTH-len(items[0])-1)
self.bottom.addstr(items[0].upper(),curses.A_BOLD)
self.bottom.refresh()
def prompt(self,text,cond=lambda x: x):
while True:
self.bottom.clear()
self.bottom.move(0,1)
self.bottom.addstr(text)
curses.curs_set(True)
curses.echo()
s = self.bottom.getstr(0,len(text)+2)
if cond(s):
curses.noecho()
curses.curs_set(False)
return s
def func_prompt(self,text="f(x) = "):
self.bottom.clear()
self.bottom.move(0,1)
self.bottom.addstr(text)
curses.curs_set(True)
curses.echo()
while True:
fx = self.bottom.getstr(0,len(text)+2).decode(encoding="utf-8")
if fx == 'q':
return None
self.command_hist.append(fx)
self.command_indx += 1
try:
expr = self.parser.parse(fx)
if expr.variables() == ['x']:
curses.noecho()
curses.curs_set(False)
return expr
except:
for _ in range(2):
self.bottom.clear()
self.bottom.move(0,1)
self.bottom.addstr('TRY AGAIN ',curses.A_STANDOUT)
self.bottom.refresh()
time.sleep(.1)
self.bottom.clear()
self.bottom.move(0,1)
self.bottom.addstr('TRY AGAIN ')
time.sleep(.1)
self.bottom.refresh()
def func_hist(self,up_down): # 0 is up, 1 is down
print(no)
def graph(self):
self.stdscr.clear()
self.bar(graph_menu)
self.grapher.border()
while True:
c = self.stdscr.getch()
if c == ord('g'):
self.grapher.border()
#elif c == ord('t'):
# #self.grapher.plot([0,1,2,3,4,5,6,7,8,9,10,11],[0,1,2,3,4,5,6,7,8,9,10,11],col=2)
# xs = [x for x in range(0,self.WIDTH)]
# ys = [x**2//(self.WIDTH**2//self.HEIGHT+1) for x in xs]
# self.grapher.plot(xs,ys,col=3)
elif c == ord('f'):
fx = self.func_prompt()
self.bar(graph_menu)
if fx is not None:
# graph the function
xs = [x for x in range(0,self.WIDTH)]
ys = [int(fx.evaluate({'x': x})) for x in xs]
self.grapher.plot(xs,ys,col=4)
elif c == ord('c'):
self.clear()
self.grapher.border()
elif c == ord('q'):
#self.clear()
self.bottom.clear()
self.bar(default_items)
break
elif c == curses.KEY_UP:
# go up
if self.command_indx < len(self.command_hist) and self.command_indx >= 0:
self.bottom.addstr(self.command_hist[self.command_indx])
self.command_indx -= 1
elif c == curses.KEY_DOWN:
# go down
self.command_indx += 1
if self.command_indx < len(self.command_hist):
self.bottom.addstr(self.command_hist[self.command_indx])
def draw(self):
#self.stdscr.clear()
self.bottom.clear()
self.bar(draw_menu)
while True:
c = self.stdscr.getch()
if c == ord('l'):
p1 = int(self.prompt('x1?',self.painter.isint))
p2 = int(self.prompt('y1?',self.painter.isint))
p3 = int(self.prompt('x2?',self.painter.isint))
p4 = int(self.prompt('y2?',self.painter.isint))
ch = self.prompt('paint?',lambda x: True)
if ch:
self.painter.line(p2,p1,p4,p3,ch[0])
else:
self.painter.line(p2,p1,p4,p3)
self.bar(draw_menu)
elif c == ord('v'):
p1 = int(self.prompt('x?',self.painter.isint))
p2 = int(self.prompt('y?',self.painter.isint))
l = int(self.prompt('length?',self.painter.isint))
self.painter.v_line(p2,p1,l)
self.bar(draw_menu)
elif c == ord('h'):
p1 = int(self.prompt('x?',self.painter.isint))
p2 = int(self.prompt('y?',self.painter.isint))
l = int(self.prompt('length?',self.painter.isint))
self.painter.h_line(p2,p1,l)
self.bar(draw_menu)
elif c == ord('b'):
p1 = int(self.prompt('x1?',self.painter.isint))
p2 = int(self.prompt('y1?',self.painter.isint))
w = int(self.prompt('w?',self.painter.isint))
h = int(self.prompt('h?',self.painter.isint))
self.painter.box(p2,p1,h,w)
self.bar(draw_menu)
elif c == ord('c'):
self.clear()
elif c == ord('q'):
self.bottom.clear()
self.bar(default_items)
break
class ParserTestCase(unittest.TestCase):
def setUp(self):
self.parser = Parser()
def test_parser(self):
parser = Parser()
#parser and variables
self.assertEqual(parser.parse('pow(x,y)').variables(), ['x','y'])
self.assertEqual(parser.parse('pow(x,y)').symbols(), ['pow','x','y'])
#checking if '"a b"' could be a variable (using it in sql)
self.assertEqual(parser.parse('"a b"*2').evaluate({'"a b"':2}),4)
#evaluate
self.assertEqual(parser.parse('1').evaluate({}), 1)
self.assertEqual(parser.parse('a').evaluate({'a': 2}), 2)
self.assertEqual(parser.parse('2 * 3').evaluate({}), 6)
self.assertEqual(parser.parse(u'2 \u2219 3').evaluate({}), 6)
self.assertEqual(parser.parse(u'2 \u2022 3').evaluate({}), 6)
self.assertEqual(parser.parse('2 ^ x').evaluate({'x': 3}), 8)
self.assertEqual(parser.parse('x < 3').evaluate({'x': 3}), False)
self.assertEqual(parser.parse('x < 3').evaluate({'x': 2}), True)
self.assertEqual(parser.parse('x <= 3').evaluate({'x': 3}), True)
self.assertEqual(parser.parse('x <= 3').evaluate({'x': 4}), False)
self.assertEqual(parser.parse('x > 3').evaluate({'x': 4}), True)
self.assertEqual(parser.parse('x >= 3').evaluate({'x': 3}), True)
self.assertEqual(parser.parse('2 * x + 1').evaluate({'x': 3}), 7)
self.assertEqual(parser.parse('2 + 3 * x').evaluate({'x': 4}), 14)
self.assertEqual(parser.parse('(2 + 3) * x').evaluate({'x': 4}), 20)
self.assertEqual(parser.parse('2-3^x').evaluate({'x': 4}), -79)
self.assertEqual(parser.parse('-2-3^x').evaluate({'x': 4}), -83)
self.assertEqual(parser.parse('-3^x').evaluate({'x': 4}), -81)
self.assertEqual(parser.parse('(-3)^x').evaluate({'x': 4}), 81)
self.assertEqual(parser.parse('2*x + y').evaluate({'x': 4, 'y': 1}), 9)
self.assertEqual(parser.parse("x||y").evaluate({'x': 'hello ', 'y': 'world'}), 'hello world')
self.assertEqual(parser.parse("'x'||'y'").evaluate({}), 'xy')
self.assertEqual(parser.parse("'x'=='x'").evaluate({}), True)
self.assertEqual(parser.parse("(a+b)==c").evaluate({'a': 1, 'b': 2, 'c': 3}), True)
self.assertEqual(parser.parse("(a+b)!=c").evaluate({'a': 1, 'b': 2, 'c': 3}), False)
self.assertEqual(parser.parse("(a^2-b^2)==((a+b)*(a-b))").evaluate({'a': 4859, 'b': 13150}), True)
self.assertEqual(parser.parse("(a^2-b^2+1)==((a+b)*(a-b))").evaluate({'a': 4859, 'b': 13150}), False)
self.assertEqual(parser.parse("x/((x+y))").simplify({}).evaluate({'x':1, 'y':1}), 0.5)
#functions
self.assertEqual(parser.parse('pyt(2 , 0)').evaluate({}),2)
self.assertEqual(parser.parse("concat('Hello',' ','world')").evaluate({}),'Hello world')
self.assertEqual(parser.parse('if(a>b,5,6)').evaluate({'a':8,'b':3}),5)
self.assertEqual(parser.parse('if(a,b,c)').evaluate({'a':None,'b':1,'c':3}),3)
# test substitute
expr = parser.parse('2 * x + 1')
expr2 = expr.substitute('x', '4 * x') # ((2*(4*x))+1)
self.assertEqual(expr2.evaluate({'x': 3}), 25)
# test simplify
expr = parser.parse('x * (y * atan(1))').simplify({'y': 4})
self.assertIn('x*3.141592', expr.toString())
self.assertEqual(expr.evaluate({'x': 2}), 6.283185307179586)
# test toString with string constant
expr = parser.parse("'a'=='b'")
self.assertIn("'a'=='b'",expr.toString())
self.assertIn("'a'=='b'", "%s" % expr)
expr = parser.parse("concat('a\n','\n','\rb')=='a\n\n\rb'")
self.assertEqual(expr.evaluate({}),True)
expr = parser.parse("a==''")
self.assertEqual(expr.evaluate({'a':''}),True)
#test toString with an external function
expr=parser.parse("myExtFn(a,b,c,1.51,'ok')")
self.assertEqual(expr.substitute("a",'first').toString(),"myExtFn(first,b,c,1.51,'ok')")
# test variables
expr = parser.parse('x * (y * atan(1))')
self.assertEqual(expr.variables(), ['x', 'y'])
self.assertEqual(expr.simplify({'y': 4}).variables(), ['x'])
# list operations
self.assertEqual(parser.parse('a, 3').evaluate({'a': [1, 2]}), [1, 2, 3])
def test_consts(self):
# self.assertEqual(self.parser.parse("PI ").variables(), [""])
self.assertEqual(self.parser.parse("PI").variables(), [])
self.assertEqual(self.parser.parse("PI ").variables(), [])
self.assertEqual(self.parser.parse("E ").variables(), [])
self.assertEqual(self.parser.parse(" E").variables(), [])
self.assertEqual(self.parser.parse("E").variables(), [])
self.assertEqual(self.parser.parse("E+1").variables(), [])
self.assertEqual(self.parser.parse("E / 1").variables(), [])
self.assertEqual(self.parser.parse("sin(PI)+E").variables(), [])
def test_parsing_e_and_pi(self):
self.assertEqual(self.parser.parse('Pie').variables(), ["Pie"])
self.assertEqual(self.parser.parse('PIe').variables(), ["PIe"])
self.assertEqual(self.parser.parse('Eval').variables(), ["Eval"])
self.assertEqual(self.parser.parse('Eval1').variables(), ["Eval1"])
self.assertEqual(self.parser.parse('EPI').variables(), ["EPI"])
self.assertEqual(self.parser.parse('PIE').variables(), ["PIE"])
self.assertEqual(self.parser.parse('Engage').variables(), ["Engage"])
self.assertEqual(self.parser.parse('Engage * PIE').variables(), ["Engage", "PIE"])
self.assertEqual(self.parser.parse('Engage_').variables(), ["Engage_"])
self.assertEqual(self.parser.parse('Engage1').variables(), ["Engage1"])
self.assertEqual(self.parser.parse('E1').variables(), ["E1"])
self.assertEqual(self.parser.parse('PI2').variables(), ["PI2"])
self.assertEqual(self.parser.parse('(E1 + PI)').variables(), ["E1"])
self.assertEqual(self.parser.parse('E1_').variables(), ["E1_"])
self.assertEqual(self.parser.parse('E_').variables(), ["E_"])
def test_evaluating_consts(self):
self.assertEqual(self.parser.evaluate("Engage1", variables={"Engage1": 2}), 2)
self.assertEqual(self.parser.evaluate("Engage1 + 1", variables={"Engage1": 1}), 2)
def test_custom_functions(self):
parser = Parser()
def testFunction0():
return 13
def testFunction1(a):
return 2*a+9
def testFunction2(a,b):
return 2*a+3*b
# zero argument functions don't currently work
# self.assertEqual(parser
# .parse('testFunction()')
# .evaluate({"testFunction":testFunction0}),13)
self.assertEqual(parser
.parse('testFunction(x)')
.evaluate({"x":2,"testFunction":testFunction1}),13)
self.assertEqual(parser
.parse('testFunction(x , y)')
.evaluate({"x":2,"y":3,"testFunction":testFunction2}),13)
# Add some "built-in" functions
def mean(*xs):
return sum(xs) / len(xs)
parser.functions['mean'] = mean
def counter(initial):
class nonlocals:
x = initial
def count(increment):
nonlocals.x += increment
return nonlocals.x
return count
parser.functions['count'] = counter(0)
self.assertEqual(parser.parse("mean(xs)").variables(), ["xs"])
self.assertEqual(parser.parse("mean(xs)").symbols(), ["mean", "xs"])
self.assertEqual(parser.evaluate("mean(xs)", variables={"xs": [1, 2, 3]}), 2)
self.assertEqual(parser.evaluate("count(inc)", variables={"inc": 5}), 5)
self.assertEqual(parser.evaluate("count(inc)", variables={"inc": 5}), 10)
def test_decimals(self):
parser = Parser()
self.assertEqual(parser.parse(".1").evaluate({}), parser.parse("0.1").evaluate({}))
self.assertEqual(parser.parse(".1*.2").evaluate({}), parser.parse("0.1*0.2").evaluate({}))
self.assertEqual(parser.parse(".5^3").evaluate({}), float(0.125))
self.assertEqual(parser.parse("16^.5").evaluate({}), 4)
self.assertEqual(parser.parse("8300*.8").evaluate({}), 6640)
with self.assertRaises(ValueError):
parser.parse("..5").evaluate({})
def test_custom_functions(self):
parser = Parser()
def testFunction0():
return 13
def testFunction1(a):
return 2 * a + 9
def testFunction2(a, b):
return 2 * a + 3 * b
# zero argument functions don't currently work
# self.assertEqual(parser
# .parse('testFunction()')
# .evaluate({"testFunction":testFunction0}),13)
self.assertExactEqual(
parser.parse('testFunction(x)').evaluate({
"x":
2,
"testFunction":
testFunction1
}), 13)
self.assertExactEqual(
parser.parse('testFunction(x , y)').evaluate({
"x":
2,
"y":
3,
"testFunction":
testFunction2
}), 13)
# Add some "built-in" functions
def mean(*xs):
return sum(xs) / len(xs)
parser.functions['mean'] = mean
def counter(initial):
class nonlocals:
x = initial
def count(increment):
nonlocals.x += increment
return nonlocals.x
return count
parser.functions['count'] = counter(0)
self.assertEqual(parser.parse("mean(xs)").variables(), ["xs"])
self.assertEqual(parser.parse("mean(xs)").symbols(), ["mean", "xs"])
self.assertEqual(
parser.evaluate("mean(xs)", variables={"xs": [1, 2, 3]}), 2)
self.assertExactEqual(
parser.evaluate("count(inc)", variables={"inc": 5}), 5)
self.assertExactEqual(
parser.evaluate("count(inc)", variables={"inc": 5}), 10)
if self.stepNumber == 0 or self.lastStep6 == True:
self.step8i(parameters)
elif self.c<self.m1*self.c0:
self.step6(parameters)
else:
self.step8i(parameters)
else:
self.c = self.c0
self.step6(parameters)
self.currentPos = localMinPosition
self.funResult = nextFunResult
self.stepNumber += 1
self.switchMoveDirection(self.getNewE())
if __name__ == '__main__':
parser = Parser()
functionStr = "(x1-2)^2+(x1-x2^2)^2"
g=["x1+x2-2", "2*x1^2-x2"]
x0 = [-10, 1.3]
function = parser.parse(functionStr)
cg = GaussSeidel(function, [parser.parse(gi) for gi in g], x0, 100, 10e-5, 3000)
pos = cg.getLowestPos()
print("final pos: ", [round(x, 3) for x in pos], 'f(x):', function.evaluate(dict(zip(sorted(function.variables()), pos))))
print("g(x): ", [parser.parse(gi).evaluate(dict(zip(sorted(function.variables()), pos))) for gi in g])
# if len(function.variables()) < 3:
# plot(cg)
# to gowno powinno byc wyodrebnione ale mi sie nie chce
data = OrderedDict()
data.update({"Sheet 1": cg.finalMatrix})
def __init__(self, ex: str) -> None:
self.__string = str(ex) # type: str
self.__expression = Parser().parse(ex.replace("**", "^")) # type: py_expression_eval.Expression
def test_parser(self):
parser = Parser()
#parser and variables
self.assertEqual(
parser.parse('lulu(x,y)').variables(), ['lulu', 'x', 'y'])
#checking if '"a b"' could be a variable (using it in sql)
self.assertEqual(parser.parse('"a b"*2').evaluate({'"a b"': 2}), 4)
#evaluate
self.assertEqual(parser.parse('1').evaluate({}), 1)
self.assertEqual(parser.parse('a').evaluate({'a': 2}), 2)
self.assertEqual(parser.parse('2 * 3').evaluate({}), 6)
self.assertEqual(parser.parse(u'2 \u2219 3').evaluate({}), 6)
self.assertEqual(parser.parse(u'2 \u2022 3').evaluate({}), 6)
self.assertEqual(parser.parse('2 ^ x').evaluate({'x': 3}), 8)
self.assertEqual(parser.parse('x < 3').evaluate({'x': 3}), False)
self.assertEqual(parser.parse('x < 3').evaluate({'x': 2}), True)
self.assertEqual(parser.parse('x <= 3').evaluate({'x': 3}), True)
self.assertEqual(parser.parse('x <= 3').evaluate({'x': 4}), False)
self.assertEqual(parser.parse('x > 3').evaluate({'x': 4}), True)
self.assertEqual(parser.parse('x >= 3').evaluate({'x': 3}), True)
self.assertEqual(parser.parse('2 * x + 1').evaluate({'x': 3}), 7)
self.assertEqual(parser.parse('2 + 3 * x').evaluate({'x': 4}), 14)
self.assertEqual(parser.parse('(2 + 3) * x').evaluate({'x': 4}), 20)
self.assertEqual(parser.parse('2-3^x').evaluate({'x': 4}), -79)
self.assertEqual(parser.parse('-2-3^x').evaluate({'x': 4}), -83)
self.assertEqual(parser.parse('-3^x').evaluate({'x': 4}), -81)
self.assertEqual(parser.parse('(-3)^x').evaluate({'x': 4}), 81)
self.assertEqual(parser.parse('2*x + y').evaluate({'x': 4, 'y': 1}), 9)
self.assertEqual(
parser.parse("x||y").evaluate({
'x': 'hello ',
'y': 'world'
}), 'hello world')
self.assertEqual(parser.parse("'x'||'y'").evaluate({}), 'xy')
self.assertEqual(parser.parse("'x'=='x'").evaluate({}), True)
self.assertEqual(
parser.parse("(a+b)==c").evaluate({
'a': 1,
'b': 2,
'c': 3
}), True)
self.assertEqual(
parser.parse("(a+b)!=c").evaluate({
'a': 1,
'b': 2,
'c': 3
}), False)
self.assertEqual(
parser.parse("(a^2-b^2)==((a+b)*(a-b))").evaluate({
'a': 4859,
'b': 13150
}), True)
self.assertEqual(
parser.parse("(a^2-b^2+1)==((a+b)*(a-b))").evaluate({
'a': 4859,
'b': 13150
}), False)
self.assertEqual(
parser.parse("x/((x+y))").simplify({}).evaluate({
'x': 1,
'y': 1
}), 0.5)
#functions
self.assertEqual(parser.parse('pyt(2 , 0)').evaluate({}), 2)
self.assertEqual(
parser.parse("concat('Hello',' ','world')").evaluate({}),
'Hello world')
self.assertEqual(
parser.parse('if(a>b,5,6)').evaluate({
'a': 8,
'b': 3
}), 5)
self.assertEqual(
parser.parse('if(a,b,c)').evaluate({
'a': None,
'b': 1,
'c': 3
}), 3)
#external function
self.assertEqual(
parser.parse('testFunction(x , y)').evaluate({
"x":
2,
"y":
3,
"testFunction":
testFunction
}), 13)
# test substitute
expr = parser.parse('2 * x + 1')
expr2 = expr.substitute('x', '4 * x') # ((2*(4*x))+1)
self.assertEqual(expr2.evaluate({'x': 3}), 25)
# test simplify
expr = parser.parse('x * (y * atan(1))').simplify({'y': 4})
self.assertIn('x*3.141592', expr.toString())
self.assertEqual(expr.evaluate({'x': 2}), 6.283185307179586)
# test toString with string constant
expr = parser.parse("'a'=='b'")
self.assertIn("'a'=='b'", expr.toString())
expr = parser.parse("concat('a\n','\n','\rb')=='a\n\n\rb'")
self.assertEqual(expr.evaluate({}), True)
expr = parser.parse("a==''")
self.assertEqual(expr.evaluate({'a': ''}), True)
#test toString with an external function
expr = parser.parse("myExtFn(a,b,c,1.51,'ok')")
self.assertEqual(
expr.substitute("a", 'first').toString(),
"myExtFn(first,b,c,1.51,'ok')")
# test variables
expr = parser.parse('x * (y * atan(1))')
self.assertEqual(expr.variables(), ['x', 'y'])
self.assertEqual(expr.simplify({'y': 4}).variables(), ['x'])
# list operations
self.assertEqual(
parser.parse('a, 3').evaluate({'a': [1, 2]}), [1, 2, 3])
def generateNetwork(network_file_name):
V = [] # vertices
E = [] # edges
F = {} # cost functions
OD = [] # OD pairs
lineid = 0
for line in open(network_file_name, 'r'):
lineid += 1
# ignore \n
line = line.rstrip()
# ignore comments
hash_pos = line.find('#')
if hash_pos > -1:
line = line[:hash_pos]
# split the line
taglist = line.split()
if len(taglist) == 0:
continue
if taglist[0] == 'function':
# process the params
params = taglist[2][1:-1].split(',')
if len(params) > 1:
raise Exception('Cost functions with more than one parameter are not yet acceptable! (parameters defined: %s)' % str(params)[1:-1])
# process the function
expr = taglist[3]
function = Parser().parse(expr)
# handle the case where the parameter is not in the formula
# (this needs to be handled because py-expression-eval does
# not allows simplifying all variables of an expression)
if taglist[1] not in function.variables():
expr = '%s+%s-%s' % (taglist[3], params[0], params[0])
function = Parser().parse(expr)
# process the constants
constants = function.variables()
if params[0] in constants: # the parameter must be ignored
constants.remove(params[0])
# store the function
F[taglist[1]] = [params[0], constants, expr]
elif taglist[0] == 'node':
V.append(Node(taglist[1]))
elif taglist[0] == 'dedge' or taglist[0] == 'edge': # dedge is a directed edge
# process the function
func_tuple = F[taglist[4]] # get the corresponding function
param_values = dict(zip(func_tuple[1], map(float, taglist[5:]))) # associate constants and values specified in the line (in order of occurrence)
function = Parser().parse(func_tuple[2]) # create the function
function = function.simplify(param_values) # replace constants
# create the edge(s)
E.append(Edge(taglist[1], taglist[2], taglist[3], function, func_tuple[0]))
if taglist[0] == 'edge':
E.append(Edge('%s-%s'%(taglist[3], taglist[2]), taglist[3], taglist[2], function, func_tuple[0]))
elif taglist[0] == 'od':
OD.append(taglist[1])
else:
raise Exception('Network file does not comply with the specification! (line %d: "%s")' % (lineid, line))
return V, E, OD
def generateGraph(graph_file):
V = [] # vertices
E = [] # edges
F = {} # cost functions
OD = [] # OD pairs
lineid = 0
for line in open(graph_file, 'r'):
lineid += 1
# ignore \n
line = line.rstrip()
# ignore comments
hash_pos = line.find('#')
if hash_pos > -1:
line = line[:hash_pos]
# split the line
taglist = line.split()
if len(taglist) == 0:
continue
if taglist[0] == 'function':
# process the params
params = taglist[2][1:-1].split(',')
if len(params) > 1:
raise Exception(
'Cost functions with more than one parameter are not yet acceptable! (parameters defined: %s)'
% str(params)[1:-1])
# process the function
function = Parser().parse(taglist[3])
# process the constants
constants = function.variables()
if params[0] in constants: # the parameter must be ignored
constants.remove(params[0])
# store the function
F[taglist[1]] = [params[0], constants, function]
elif taglist[0] == 'node':
V.append(Node(taglist[1]))
elif taglist[0] == 'dedge' or taglist[
0] == 'edge': # dedge is a directed edge
# process the cost
function = F[taglist[4]] # get the corresponding function
param_values = dict(
zip(function[1], map(float, taglist[5:]))
) # associate constants and values specified in the line (in order of occurrence)
param_values[function[0]] = 0.0 # add the parameter with value 0
cost = function[2].evaluate(param_values) # calculate the cost
# create the edge(s)
E.append(Edge(taglist[1], taglist[2], taglist[3], cost))
if taglist[0] == 'edge':
E.append(Edge(taglist[1], taglist[3], taglist[2], cost))
elif taglist[0] == 'od':
OD.append(taglist[1])
else:
raise Exception(
'Network file does not comply with the specification! (line %d: "%s")'
% (lineid, line))
return V, E, OD
def generateGraph(graph_file, flow=0.0):
"""
Generates the graph from a text file following the specifications(available @
http://wiki.inf.ufrgs.br/network_files_specification).
In:
graph_file:String = Path to the network(graph) file.
flow:Float = Value to sum the cost of the edges.
Out:
V:List = List of vertices or nodes of the graph.
E:List = List of the edges of the graph.
OD:List = List of the OD pairs in the network.
"""
V = [] # vertices
E = [] # edges
F = {} # cost functions
OD = [] # OD pairs
lineid = 0
for line in open(graph_file, 'r'):
lineid += 1
# ignore \n
line = line.rstrip()
# ignore comments
hash_pos = line.find('#')
if hash_pos > -1:
line = line[:hash_pos]
# split the line
taglist = line.split()
if len(taglist) == 0:
continue
if taglist[0] == 'function':
# process the params
params = taglist[2][1:-1].split(',')
if len(params) > 1:
raise Exception('Cost functions with more than one parameter are not yet'\
'acceptable! (parameters defined: %s)' % str(params)[1:-1])
# process the function
function = Parser().parse(taglist[3])
# process the constants
constants = function.variables()
if params[0] in constants: # the parameter must be ignored
constants.remove(params[0])
# store the function
F[taglist[1]] = [params[0], constants, function]
elif taglist[0] == 'node':
V.append(Node(taglist[1]))
elif taglist[0] == 'dedge' or taglist[0] == 'edge': # dedge is a directed edge
# process the cost
function = F[taglist[4]] # get the corresponding function
# associate constants and values specified in the line (in order of occurrence)
param_values = dict(zip(function[1], map(float, taglist[5:])))
param_values[function[0]] = flow # set the function's parameter with the flow value
cost = function[2].evaluate(param_values) # calculate the cost
# create the edge(s)
E.append(Edge(taglist[1], taglist[2], taglist[3], cost))
if taglist[0] == 'edge':
E.append(Edge('%s-%s'%(taglist[3], taglist[2]), taglist[3], taglist[2], cost))
elif taglist[0] == 'od':
OD.append(taglist[1])
else:
raise Exception('Network file does not comply with the specification!'\
'(line %d: "%s")' % (lineid, line))
return V, E, OD
class CalculateDelta:
"""
This class is responsible for all our calculations. It is able to
determine an Individual's fitness by finding the difference between
the supplied training data and the values the expression produces.
"""
def __init__(self):
self.delta = -1.0
self.y_values = []
self.evaluate = Parser()
def __str__(self):
return "Delta: " + str(self.delta) + "\nY Values: " + str(
self.y_values)
def calculate_delta(self, expression, x_data, y_data):
"""
Evaluates the expression first and sees if it is worth finding the
Individuals fitness. If there are any divide by zero errors, no
fitness will be calculated.
:param expression: The Individual we want to find the fitness for
:param x_data: training data
:param y_data: training data
:return:
"""
if self._eval_x_data(expression, x_data):
self._eval_y_data(y_data)
def _eval_x_data(self, expression, x_data):
"""
Plugs in all the x training data to see if we have any divide by
zero errors. If we do, return false because this expression is
not worth finding the fitness
:param expression: The Individual we want to find the fitness for
:param x_data: training data
:return:
"""
self.y_values = []
for x_value in x_data:
try:
self.y_values.append(
self.evaluate.parse(expression).evaluate({'x': x_value}))
except ZeroDivisionError:
self.y_values = []
return False
return True
def _eval_y_data(self, y_data):
"""
If we have no divide by zero errors, find how this expression differs
from our training data
:param y_data: training data
"""
self.delta = 0.0
for i in range(len(y_data)):
self.delta += math.fabs(y_data[i] - self.y_values[i])
