def evaluate(self, type):
if self.numlines > 0:
if type.lower() == 'solve':
equations = list(map(lambda x: re.sub('\\n', '', x), list(self.lines.values())))
prior = parse_latex(r'{}'.format(equations[0]))
check = True
for i in range(1, len(equations)):
posterior = parse_latex(r'{}'.format(equations[i]))
if not check_eq_equality(prior, posterior):
print('Fail at line "{}"'.format(equations[i]))
check = False
break
prior = posterior
if check:
print('Correct')
elif type.lower() == 'reduce':
expressions = list(map(lambda x: re.sub('\\n', '', x), list(self.lines.values())))
prior = parse_latex(r'{}'.format(expressions[0]))
check = True
for i in range(1, len(expressions)):
posterior = parse_latex(r'{}'.format(expressions[i]))
if not check_expr_equality(prior, posterior):
print('Fail at line "{}"'.format(expressions[i]))
check = False
break
prior = posterior
if check:
print('Correct')
else:
print('Question type cannot be evaluated')
else:
print('No equation to evaluate.')
def createLine(s):
s=conv(s)
t=[]
if s.find("\\frac")==-1:
if s.find("=")==-1:
t=parse_expr(s)
if checkPointNum(t)==1:
d=checkSlopePoint(t)
line=Line(Point(d['point']),slope=float(d['slope']))
return line
elif checkPointNum(t)==2:
p1,p2=Point(*t[0]),Point(*t[1])
line=Line(p1,p2)
return line
else:
return Line(parse_latex(s))
else :
l=s.find("\\frac")
h=s.find("}",s.find("}")+1,len(s)-1)
slope=float(parse_latex(s[l:h+1]))
s.replace(s[l:h+1],"")
l=s.find("(")
h=s.find(")")
point=Point(parse_expr(s[l:h+1]))
return Line(point,slope=slope)
def func(file_path):
image_uri = "data:image/jpg;base64," + \
base64.b64encode(open(file_path, "rb").read()).decode()
r = requests.post("https://api.mathpix.com/v3/latex",
data=json.dumps({
'src':
image_uri,
'formats': ['latex_normal', 'latex_simplified'],
'ocr': ['math']
}),
headers={
"app_id": "madhavgoyal_live_com",
"app_key": '691af155706c16392cff',
"Content-type": "application/json"
})
a = json.loads(r.text)['latex_normal']
print(a) #this will give the result
print(parse_expr(str(parse_latex(a))))
dict["result"] = a ######
dict["latex1"] = parse_expr(str(parse_latex(a))) ########
# b=str(dict["latex1"])
# b=b[9:-1]
# x = Symbol('x')
# print(integrate(eval(b)))
return dict ############
def latex_to_limit(latex_limit):
"""
------------------------------------------------------------------
latex_to_limit: Breaks the latex limit into sympy objects.
------------------------------------------------------------------
Parameters:
latex_limit: latex string
Returns:
function, x0 and direction (in that order).
------------------------------------------------------------------
"""
# split latex limit into different parts (except the limit since we already know what it is
str_function = latex_limit.split("}", 1)[1].split("=")[0][1:]
str_approaching = latex_limit.split("\\to")[1].split("}")[0][1:].split("^")
# check if x0 is approaching infinity
inf_dict = {"\\infty": sm.oo, "-\\infty": - sm.oo}
if "\\infty" in str_approaching[0]:
x0 = inf_dict[str_approaching[0]]
else:
x0 = parse_latex(str_approaching[0])
# check which side the limit is on
if len(str_approaching) > 1:
direction = str_approaching[1]
else:
direction = "+-"
return parse_latex(str_function), x0, direction
def test_issue_20762():
antlr4 = import_module("antlr4")
if not antlr4:
skip('antlr not installed.')
# Make sure pycode removes curly braces from subscripted variables
expr = parse_latex(r'a_b \cdot b')
assert pycode(expr) == 'a_b*b'
expr = parse_latex(r'a_{11} \cdot b')
assert pycode(expr) == 'a_11*b'
def parse_rhs(rhs, is_latex, local_dict=None):
parsed = dict()
if is_latex:
if local_dict is not None:
expr = parse_latex(rhs).subs(local_dict)
else:
expr = parse_latex(rhs)
else:
expr = parse_expr(rhs).subs(local_dict)
return expr
def insert_bound_eq_latex(latex_expr):
"""
------------------------------------------------------------------
insert_bound_eq_latex: Converts the latex triple inequality into
functions.
------------------------------------------------------------------
Parameters:
latex_expr: latex string
Returns:
f1, f2, f3 such that f1 <= f2 <= f3
------------------------------------------------------------------
"""
latex_split = latex_expr.split("\\leq")
return parse_latex(latex_split[0]), parse_latex(latex_split[1]), parse_latex(latex_split[2])
def preProceessBinomisl(s):
temp = s.split("^")
power = float(parse_latex(conv(temp[1])))
var = getVar(getTree(temp[0]))
temp[0] = str(parse_latex(conv(temp[0][2:-1])))
print(temp[0])
if temp[0].find("*") == -1:
print(s)
temp[0] = temp[0].replace(var, "1 " + var)
print(temp[0])
if int(power) == power:
expr = "(" + temp[0] + ")^{" + str(int(power)) + "}"
else:
expr = "(" + temp[0] + ")^{" + str(power) + "}"
print(expr)
return expr, power, var
def map_answers_to_latex(latexData):
numberData = {}
for variable in latexData:
numberData[variable] = parse_latex(latexData[variable])
return numberData
def process_upload():
print('Received POST: ')
jsonData = request.get_json()
print(jsonData['eq'])
print(jsonData['ans']['x'])
expr = parse_latex(jsonData['eq'])
answerMap = map_answers_to_latex(jsonData['ans'])
computationResult = expr.evalf(subs=answerMap)
print(f'Computation result: {computationResult}')
substitutionResult = expr.subs([('x', jsonData['ans']['x'])])
print(f'Substitution result: {substitutionResult}')
# if(computationResult.is_integer):
# result = computationResult
# else:
# result = float('{:.4f}'.format(computationResult))
# print(f'Result: {result == 0.0}')
# return str(result == 0.0), HTTPStatus.OK
return str(False), HTTPStatus.OK
def test_latex_parser():
inputs = {
"x" : x,
"1.234": 1.234,
"-34": -34,
"-8": -8,
"-7/24": (-7/24),
"x + y": (x + y),
"xy": (x*y),
"2x^3": (2*(x**3)),
"(x+y)^4": (x+y)**4,
"\\frac{x}{y}": (x/y),
"\\begin{matrix} 1 & 2 \\\\ 3 & 4 \\end{matrix}": Matrix([ [1,2], [3,4] ]),
"\\left[ \\begin{matrix} 1 & 2 \\\\ 3 & 4 \\end{matrix} \\right]": Matrix([ [1,2], [3,4] ]),
"( x+ y) (z + w) ": ((x+y)*(z+w)),
"\\sqrt[y] 2": root(2, y),
"\\sqrt 2x": sqrt(2)*x,
#"x + z\\pi = y": Eq(x+z*pi, y),
"\\int x \mathrm{d}x": integrate(x, x),
"\\sum^n_{i=1} 2i \\;\\; + 1": (Sum(2*i, (i, 1, n)).doit() + 1)
}
for text, result in inputs.items():
#print(text + " >>> ")
#print(str(parse_latex(text)) + "\n")
assert parse_latex(text) == result
def preProcess(s):
s = conv(s)
e = str(parse_latex(r"{}".format(s))).split("Integral")[1][1:-1]
l = []
l.append(e[0:-3])
l.append(e[-1:])
return l
def parse_tex(tex):
tex = tex.replace('D(', c_deriv)
latex = parse_latex(tex)
latex = latex.subs({sp.Symbol('pi'): sp.pi})
latex = latex.subs({sp.Symbol('e'): sp.exp(1)})
return latex
def on_add_clicked(self):
equationLE = self.window.findChild(QLineEdit, 'EquationLE')
descriptionLE = self.window.findChild(QLineEdit, 'DescriptionLE')
try:
origin = self.compartment_list[self.origin_combobox.currentIndex()]
except IndexError:
origin = None
try:
end = self.compartment_list[
self.destination_combobox.currentIndex()]
except IndexError:
end = None
if origin == end and origin is None: # Both are None
QMessageBox.critical(self.window, "Error",
"Origin and End cannot be Birth and Death")
return
elif origin == end: # Both are the same but not None
QMessageBox.critical(self.window, "Error",
"Origin and End cannot be the same")
return
new_variable = Variable(equation=parse_latex(str(
equationLE.text())).simplify(),
origin=origin,
end=end,
description=str(descriptionLE.text()))
self.add_variable.emit(new_variable)
self.window.destroy()
def limitPreprocess(s):
#s=s.split("\to")
#s=s[0]+"\\to"+s[1]
s = conv(s)
ds = str(parse_latex(s)).split("Limit")[1][1:-1]
a = ds.split(", ")
if (len(a) >= 3):
#t=a[0]
sym = symbols(a[-2])
if a[-1] == "oo" or a[-1] == "-oo":
lim = symbols(a[-1])
else:
lim = int(a[-1])
eqn = ", ".join(a[:-2])
elif (len(a) < 3):
sym = symbols("x")
lim = symbols("oo")
eqn = "x"
else:
b = a[:-2]
eqn = ", ".join(b)
sym = symbols(a[-2])
if a[-1] == "oo" or a[-1] == "-oo":
lim = symbols(a[-1])
else:
lim = int(a[-1])
return eqn, sym, lim
def my_form_json():
"""
Get Values for the identifiers
Return Calculated result
"""
try:
result = json.loads(request.data.decode('utf8'))
formula = result['formula']
del result['formula']
identifiers_dict = result
# slice off identifier names for calculation
symbolvalue = {}
for identifier in identifiers_dict.items():
try:
symbol = identifier[0].split(" (")[0]
value = identifier[1]
symbolvalue[symbol] = value
except:
pass
# remove displaystyle
formula = formula.replace("\\displaystyle", "")
# formula parsing and calculation
seprator = getidentifiers.formuladivision(formula)
if seprator is not None:
lhs, rhs = getlhsrhs(formula, seprator)
f = parse_latex(rhs)
f1 = parse_latex(lhs)
latexlhs = sympify(f1)
l = sympify(f)
# print(l)
#symbolvalue = makeidentifier(identifier, identifiers_dict)
value = l.evalf(subs=symbolvalue)
return ("%s %s %.2e" % (latexlhs, seprator, value))
else:
l = sympify(formula)
value = l.evalf(subs=identifiers_dict)
return ("%.2e" % value)
except Exception:
return ("System is not able to find the result.")
def make_sympy_expr(formula, is_latex):
if isinstance(formula, str) and is_latex:
clean_formula = clean_latex(formula)
sympy_expr = parse_latex(clean_formula)
sympy_expr = sympy_expr.subs(simplify(parse_expr("e")),
parse_expr("exp(1)"))
sympy_expr = sympy_expr.xreplace(
{parse_latex("\\ln(x)"): parse_expr('log(x,E)')})
elif is_sympy_exp(formula):
sympy_expr = formula
elif isinstance(formula, str):
sympy_expr = parse_expr(formula)
else:
raise (Exception(
"error while trying to create an Expression, unsuported formula type"
+ str(formula)))
return sympy_expr
def tien_xu_ly_pt(formula):
'''
input:(str) formula is a equation
output:(str) formuala is made normalize
+ "pt": formula is latex (ex: 3*x^{2} + 2*x + 4 = 0)
+ "key": the element of formula (ex: 3*x^{2}|+|2*x|+|4|=|0)
impliment: convert
+ r'\\left':'',
+ r'\\right':'',
+ r'\\,': '',
+ remove space in the first and last statement
+ remove [';', ',', '.'] in the last statement
+ I expected one of these: ')' : remove '(' in the first statement
'''
char_r = {r'\\,': '', r'&&': ''}
for ch in char_r.keys():
formula = re.sub(ch, char_r[ch], formula)
# xóa các ký tự thừa ở cuối ( endchar ) và đầu (startchar) chuỗi
endchar = r'([\;]|[\,]|[\.]|[\=]|[\>]|[\<]|[\\]|[\(]|[\{]|[:]|\\leq|\\geq|\n|\\n)*$'
startchar = r'^([\;]|[\,]|[\.]|[\=]|[\>]|[\<]|[\}]|[\)]|[:]|\\leq|\\geq|\n|\\n)*'
formula = regex.sub(startchar, '', formula)
formula = regex.sub(endchar, '', formula)
formula = regex.sub(r'[\\]+', r'\\', formula)
# check error of formuala
a = ''
try:
f = parse_latex(formula)
# check lỗi cho trường hợp công thức không bắt duoc
except Exception as e:
a = e.args[0]
a = a.replace("')'", ")")
a = a.replace("'='", "=")
a = a.split('\n')
if a != '':
if (a[0] == "I expected one of these: )") or (a[0]
== "missing ) at ="):
if formula.startswith('('):
formula = formula[1:]
else:
return []
parse_latex(formula)
return formula
def predict(image_path):
# bounding box on given image and sort the symbols by x and y
test_symbol_list = boundingBox.createSymbol(image_path)
test_symbol_list = sorted(test_symbol_list, key=operator.itemgetter(2, 3))
pre_symbol_list = []
model = load_model(
'C:/Users/VIDUSHI/Desktop/python_frameworks/django assign/capstone/myApp/spnet.hdf5'
)
# for each symbol image in image list
for i in range(len(test_symbol_list)):
test_symbol = test_symbol_list[i]
# prepare the each symbol image into standard size
eroded = preprocess(test_symbol[0])
# predict
img2 = cv2.merge((eroded, eroded, eroded))
# cv2.imshow('dila', img2)
# cv2.waitKey(0)
# cv2.destroyAllWindows()
im = img2.reshape(1, 45, 45, 3)
result = model.predict_classes(im, batch_size=32)
# analysis for dot pattern
if test_symbol[1] != "dot":
predict_result = sy[result[0]]
else:
predict_result = "dot"
test_symbol = (test_symbol[0], predict_result, test_symbol[2],
test_symbol[3], test_symbol[4], test_symbol[5])
test_symbol_list[i] = test_symbol
# combine potential part in equation
updated_symbol_list = pf.update(image_path, test_symbol_list)
# for each result in result list add it into return list
for s in updated_symbol_list:
pre_symbol = SymPred(s[1], s[2], s[3], s[4], s[5])
pre_symbol_list.append(pre_symbol)
# predict the latex expression of equation
equation = pf.toLatex(updated_symbol_list)
# print(str(parse_latex(equation)))
# print(parse_expr(str(parse_latex(equation))))
# out put the result
head, tail = os.path.split(image_path)
res = ImgPred(tail, pre_symbol_list, equation)
res1 = res.func()
print(res1)
dict["ans"] = parse_expr(str(parse_latex(equation)))
return dict
def parse_rhs(rhs, is_latex, local_dict):
"""parse the right-hand-side of an equation
subsititute variables from local_dict where available
"""
if is_latex:
expr = parse_latex(rhs).subs(local_dict)
else:
expr = parse_expr(rhs).subs(local_dict)
return expr
def solveEqn(s):
#expr=parse_latex(r"{}".format(s))
e = conv(s)
e = parse_latex(e)
p = getVar(getTree(s))
n = symbols('n')
sol = str(solveset(e, p)).replace('_', '')
l = latex(eval(sol), symbol_names={'n': n})
d = {"solution": str(sol), 'latex': l}
return d
def integrar(params, pregunta):
# print('pregunta', pregunta)
# f_pregunta = pregunta.replace("\\(", "" )
# f_pregunta = f_pregunta.replace("\\)", "" )
# f_pregunta = f_pregunta.replace("\\int", "" )
# f_pregunta = f_pregunta.replace("dx", "" )
# print("pregunta", f_pregunta)
# return " \\( "+ str(latex(integrate( parse_latex(f_pregunta), x ))) + "\\)"
return " \\( "+ str(latex(integrate( parse_latex(r"x^2"), x ))) + "\\)"
def parse_latex_equation(string):
notneeded = [
r"\left", r"\right", r"\big", r"\Big", r"\bigg", r"\Bigg", r"\middle",
r"\,", r"\:", r"\;"
]
for i in notneeded:
string = string.replace(i, "")
"""if "=" in string:
return sympy.Eq(*map(parse_latex_equation, string.split("=", 1)))"""
return parse_latex(string)
def ldePreprocess(s):
s=conv(s)
expr1=parse_latex(s)
expr=str(expr1)
x=expr.find("Derivative")
x=x+len('Derivative')
s=expr[x:x+9][1:-1].split(", ")
func=symbols(s[0][0],cls=Function)
x=symbols(s[1])
return expr1,func,x
def get_latex_from_json(json_filename='data.json'):
with open(json_filename) as json_file:
dat = json.load(json_file)
failed_latex = {}
for expr_id, expr_dict in dat['expressions'].items():
try:
out_no_print = parse_latex(expr_dict['latex']);
except Exception as er:
failed_latex[expr_id] = expr_dict['latex']
#print('expr ID =', expr_id)
#print(er)
return failed_latex
def fseriesExpansion(s):
s1 = conv(s)
expr = parse_latex(s1)
var = getVar(getTree(s))
fs = fourier_series(expr, (symbols(var), -pi, pi))
F = ""
for i in range(0, 3):
if i < 2:
F = F + str(fs[i]) + " + "
else:
F = F + str(fs[i])
return F, var
def parse_expr(solution: str) -> Expr:
"""
Parse string with solution
:param solution string in latex form
:return: expr
"""
try:
expression = sympify(solution)
except SympifyError:
return parse_latex(solution)
else:
return expression
def accept(self):
# functions.calculateFunction(self.lineEdit.text())
# functions.plot()
# Define the variable and the function to approximate
# text = str(self.lineEdit.text())
# self.print_to_text_field("Evaluating [" + text + "]")
# Need
# reset values on clearing
try:
text = pl.parse_latex(self.lineEdit.text())
assert text is not None, "Function should not be empty\n"
except AssertionError as error:
# Output expected AssertionErrors.
self.print_to_text_field("Function should not be empty\n")
return
except Exception as exception:
# Output unexpected Exceptions.
self.print_to_text_field("Function is improperly formatted\n")
return
to_num = int(self.spinBox.text())
from_num = int(self.spinBox_2.text())
try:
by_num = int(self.lineEdit_3.text())
assert by_num is not None, "By number should at least be 1\n"
except AssertionError as error:
# Output expected AssertionErrors.
self.print_to_text_field("By number should at least be 1\n")
return
try:
x_off = int(self.lineEdit_2.text())
assert x_off is not None, "X-Off number should at least be 0\n"
except AssertionError as error:
# Output expected AssertionErrors.
self.print_to_text_field("By number should at least be 0\n")
return
try:
iterations = int(self.spinBox_3.text())
assert iterations > 0, "Must have at least 1 iteration\n"
except AssertionError as error:
# Output expected AssertionErrors.
self.print_to_text_field("Must have at least 1 iteration\n")
return
string = f'Running Taylor Series on {text} by {by_num} over the range of {from_num} to {to_num} ' \
f'for {iterations} iterations\n'
self.print_to_text_field(string)
self.plot(text, x_off, iterations, by_num, from_num, to_num)
def insert_expr_latex(latex_expr):
"""
------------------------------------------------------------------
insert_expr_latex: Splits into inequality sign and function.
------------------------------------------------------------------
Parameters:
latex_expr: latex string
Returns:
inequality sign, latex function.
------------------------------------------------------------------
"""
latex_split = latex_expr.split(' ', 1)
return latex_split[0], parse_latex(latex_split[1])
def submit(request):
if 'indefinida' in request.META.get('HTTP_REFERER'):
request.session['eq'] = str(
parse_latex(request.POST['eq'].replace('\\left', '').replace(
'\\right', '').replace('e', 'E')))
request.session['tipo'] = "indefinida"
return redirect('view')
if request.method == 'POST':
request.session['eq'] = str(
parse_latex(request.POST['eq'].replace('\\left', '').replace(
'\\right', '').replace('e', 'E')))
request.session['eql'] = request.POST['eq']
request.session['a'] = request.POST['a']
request.session['b'] = request.POST['b']
request.session['metodo'] = request.POST['metodo']
request.session['particiones'] = request.POST['particiones']
request.session['tipo'] = request.POST['tipo']
if request.session['tipo'] == "doble":
request.session['c'] = request.POST['c']
request.session['d'] = request.POST['d']
return redirect('view')
def integrate_latex(self, f):
expr = parse_latex(f)
for var_name, variable in self.env.variables.items():
expr = expr.subs(sp.Symbol(var_name), variable)
for func_name, function in self.env.functions.items():
expr = expr.subs(sp.Function(func_name), function)
for coeff_name, coefficient in self.env.coefficients.items():
expr = expr.subs(sp.Symbol(coeff_name), coefficient)
return self.integrate_sympy(expr)
def test_no_import():
from sympy.parsing.latex import parse_latex
with pytest.ignore_warnings(UserWarning):
with pytest.raises(ImportError):
parse_latex('1 + 1')
def test_parseable():
from sympy.parsing.latex import parse_latex
for latex_str, sympy_expr in GOOD_PAIRS:
assert parse_latex(latex_str) == sympy_expr
def test_no_import():
from sympy.parsing.latex import parse_latex
with pytest.raises(ImportError):
parse_latex('1 + 1')
def test_failing_not_parseable():
from sympy.parsing.latex import parse_latex
for latex_str in FAILING_BAD_STRINGS:
print("'{}' SHOULD NOT PARSE, BUT DID: {}".format(
latex_str, parse_latex(latex_str)))
def test_failing_not_parseable():
from sympy.parsing.latex import parse_latex, LaTeXParsingError
for latex_str in FAILING_BAD_STRINGS:
with raises(LaTeXParsingError):
parse_latex(latex_str)
def test_failing_parseable():
from sympy.parsing.latex import parse_latex
for latex_str, sympy_expr in FAILING_PAIRS:
with pytest.raises(Exception):
assert parse_latex(latex_str) == sympy_expr
def test_not_parseable():
from sympy.parsing.latex import parse_latex, LaTeXParsingError
for latex_str in BAD_STRINGS:
with pytest.raises(LaTeXParsingError):
print("'{}' SHOULD NOT PARSE, BUT DID: {}".format(
latex_str, parse_latex(latex_str)))
