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)))