初始化项目，由ModelHub XC社区提供模型
Model: nv-community/Nemotron-Cascade-8B Source: Original Platform
This commit is contained in:
ModelHub XC
678
evaluation/eval/tools/code_verifier_utils.py
Normal file
678
evaluation/eval/tools/code_verifier_utils.py
Normal file
@@ -0,0 +1,678 @@
|
||||
import ast
|
||||
import json
|
||||
import sys
|
||||
import faulthandler
|
||||
import platform
|
||||
import re
|
||||
# used for debugging to time steps
|
||||
from datetime import datetime
|
||||
import os
|
||||
# to run the solution files we're using a timing based approach
|
||||
import signal
|
||||
import time
|
||||
import numpy as np
|
||||
|
||||
from io import StringIO
|
||||
|
||||
# used for testing the code that reads from input
|
||||
from unittest.mock import patch, mock_open
|
||||
|
||||
# from pyext import RuntimeModule
|
||||
from types import ModuleType
|
||||
|
||||
from enum import Enum
|
||||
from decimal import Decimal
|
||||
import time
|
||||
from typing import List
|
||||
|
||||
import_string = "import sys\nsys.setrecursionlimit(1 << 25)\nsys.set_int_max_str_digits(1 << 25)\nimport time\nimport re\nimport bisect\nimport itertools\nfrom itertools import accumulate, product, permutations, combinations\nimport collections\nfrom collections import Counter, OrderedDict, deque, defaultdict, ChainMap\nfrom functools import lru_cache\nimport math\nfrom math import sqrt, sin, cos, tan, ceil, fabs, floor, gcd, exp, log, log2\nimport fractions\nfrom typing import List, Tuple\nimport numpy as np\nimport random\nimport heapq\nfrom heapq import *\n"
|
||||
|
||||
def convert_python_literal_to_json(s):
|
||||
obj = ast.literal_eval(s)
|
||||
return json.dumps(obj)
|
||||
|
||||
def convert_python_literal(arg_str):
|
||||
s = arg_str.strip()
|
||||
# If the whole string starts with '[' and ends with ']', assume it's one literal
|
||||
# and force it to be treated as a single-element tuple by adding a trailing comma.
|
||||
if s.startswith('[') and s.endswith(']'):
|
||||
wrapped_str = f"({arg_str},)"
|
||||
else:
|
||||
wrapped_str = f"({arg_str})"
|
||||
|
||||
try:
|
||||
parsed_tuple = ast.literal_eval(wrapped_str)
|
||||
except Exception as e:
|
||||
raise ValueError(f"Error parsing argument string: {arg_str}") from e
|
||||
return list(parsed_tuple)
|
||||
|
||||
def post_process_code(code):
|
||||
code = code.split("</code>")[0]
|
||||
code = code.replace("```python", "")
|
||||
code = code.split("```")[0]
|
||||
code = code.replace("<code>", "")
|
||||
return code
|
||||
|
||||
def extract_functions(code_str):
|
||||
tree = ast.parse(code_str)
|
||||
extracted = []
|
||||
|
||||
# Iterate over top-level nodes in the module.
|
||||
for node in tree.body:
|
||||
# Check for import statements.
|
||||
if isinstance(node, (ast.Import, ast.ImportFrom, ast.Assign)):
|
||||
code_segment = ast.get_source_segment(code_str, node)
|
||||
extracted.append(code_segment)
|
||||
# Check for top-level function definitions.
|
||||
elif isinstance(node, ast.FunctionDef):
|
||||
code_segment = ast.get_source_segment(code_str, node)
|
||||
extracted.append(code_segment)
|
||||
# Check for class definitions.
|
||||
elif isinstance(node, ast.ClassDef):
|
||||
code_segment = ast.get_source_segment(code_str, node)
|
||||
extracted.append(code_segment)
|
||||
|
||||
return extracted
|
||||
|
||||
PATTERN = re.compile(
|
||||
r"(?ms)^```python(?:\w+)?\n" # opener at start of a line
|
||||
r"(?P<code>(?:(?!^```python).)*?)" # content that never starts a new ###python
|
||||
r"^\s*```\s*$" # closer '###' on its own line
|
||||
)
|
||||
|
||||
def has_code(response):
|
||||
matches = list(PATTERN.finditer(response))
|
||||
return matches[-1].group("code") if matches else None
|
||||
|
||||
def truncatefn(s, length=300):
|
||||
if isinstance(s, str):
|
||||
pass
|
||||
else:
|
||||
s = str(s)
|
||||
if len(s) <= length:
|
||||
return s
|
||||
|
||||
return s[: length // 2] + "...(truncated) ..." + s[-length // 2 :]
|
||||
|
||||
|
||||
class CODE_TYPE(Enum):
|
||||
call_based = 0
|
||||
standard_input = 1
|
||||
|
||||
|
||||
# stuff for setting up signal timer
|
||||
class TimeoutException(Exception):
|
||||
pass
|
||||
|
||||
|
||||
def timeout_handler(signum, frame):
|
||||
print("timeout occured: alarm went off")
|
||||
raise TimeoutException
|
||||
|
||||
|
||||
# used to capture stdout as a list
|
||||
# from https://stackoverflow.com/a/16571630/6416660
|
||||
# alternative use redirect_stdout() from contextlib
|
||||
class Capturing(list):
|
||||
def __enter__(self):
|
||||
self._stdout = sys.stdout
|
||||
sys.stdout = self._stringio = StringIO()
|
||||
# Make closing the StringIO a no-op
|
||||
self._stringio.close = lambda x: 1
|
||||
return self
|
||||
|
||||
def __exit__(self, *args):
|
||||
self.append(self._stringio.getvalue())
|
||||
del self._stringio # free up some memory
|
||||
sys.stdout = self._stdout
|
||||
|
||||
|
||||
def clean_if_name(code: str) -> str:
|
||||
try:
|
||||
astree = ast.parse(code)
|
||||
last_block = astree.body[-1]
|
||||
if isinstance(last_block, ast.If):
|
||||
condition = last_block.test
|
||||
if ast.unparse(condition).strip() == "__name__ == '__main__'":
|
||||
code = (
|
||||
ast.unparse(astree.body[:-1]) + "\n" + ast.unparse(last_block.body) # type: ignore
|
||||
)
|
||||
except:
|
||||
pass
|
||||
|
||||
return code
|
||||
|
||||
|
||||
def make_function(code: str) -> str:
|
||||
try:
|
||||
import_stmts = []
|
||||
all_other_stmts = []
|
||||
astree = ast.parse(code)
|
||||
for stmt in astree.body:
|
||||
if isinstance(stmt, (ast.Import, ast.ImportFrom)):
|
||||
import_stmts.append(stmt)
|
||||
else:
|
||||
all_other_stmts.append(stmt)
|
||||
|
||||
function_ast = ast.FunctionDef(
|
||||
name="wrapped_function",
|
||||
args=ast.arguments(
|
||||
posonlyargs=[], args=[], kwonlyargs=[], kw_defaults=[], defaults=[]
|
||||
),
|
||||
body=all_other_stmts,
|
||||
decorator_list=[],
|
||||
lineno=-1,
|
||||
)
|
||||
main_code = (
|
||||
import_string
|
||||
+ "\n"
|
||||
+ ast.unparse(import_stmts) # type: ignore
|
||||
+ "\n"
|
||||
+ ast.unparse(function_ast) # type: ignore
|
||||
)
|
||||
return main_code
|
||||
except Exception as e:
|
||||
return code
|
||||
|
||||
|
||||
def call_method(method, inputs):
|
||||
|
||||
if isinstance(inputs, list):
|
||||
inputs = "\n".join(inputs)
|
||||
|
||||
inputs_line_iterator = iter(inputs.split("\n"))
|
||||
|
||||
@patch("builtins.open", mock_open(read_data=inputs))
|
||||
@patch("sys.stdin", StringIO(inputs))
|
||||
@patch("sys.stdin.readline", lambda *args: next(inputs_line_iterator))
|
||||
@patch("sys.stdin.readlines", lambda *args: inputs.split("\n"))
|
||||
@patch("sys.stdin.read", lambda *args: inputs)
|
||||
def _inner_call_method(_method):
|
||||
try:
|
||||
return _method()
|
||||
except SystemExit as e:
|
||||
pass
|
||||
finally:
|
||||
pass
|
||||
|
||||
return _inner_call_method(method)
|
||||
|
||||
|
||||
def get_function(compiled_sol, fn_name: str): # type: ignore
|
||||
try:
|
||||
assert hasattr(compiled_sol, fn_name)
|
||||
return getattr(compiled_sol, fn_name)
|
||||
except Exception as e:
|
||||
return
|
||||
|
||||
|
||||
def compile_code(code: str, timeout: int):
|
||||
signal.alarm(timeout)
|
||||
try:
|
||||
tmp_sol = ModuleType("tmp_sol", "")
|
||||
exec(code, tmp_sol.__dict__)
|
||||
if "class Solution" in code:
|
||||
# leetcode wraps solutions in `Solution`
|
||||
# this is a hack to check if it is leetcode solution or not
|
||||
# currently livecodebench only supports LeetCode but
|
||||
# else condition allows future extensibility to other platforms
|
||||
compiled_sol = tmp_sol.Solution()
|
||||
else:
|
||||
# do nothing in the other case since function is accesible
|
||||
compiled_sol = tmp_sol
|
||||
|
||||
assert compiled_sol is not None
|
||||
finally:
|
||||
signal.alarm(0)
|
||||
|
||||
return compiled_sol
|
||||
|
||||
|
||||
# def convert_line_to_decimals(line: str) -> tuple[bool, List[Float]]:
|
||||
def convert_line_to_decimals(line: str):
|
||||
try:
|
||||
decimal_line = [float(elem) for elem in line.split()]
|
||||
except:
|
||||
return False, []
|
||||
return True, decimal_line
|
||||
|
||||
|
||||
def get_stripped_lines(val: str):
|
||||
## you don't want empty lines to add empty list after splitlines!
|
||||
val = val.strip()
|
||||
|
||||
return [val_line.strip() for val_line in val.split("\n")]
|
||||
|
||||
|
||||
def grade_call_based(
|
||||
code: str, all_inputs: list, all_outputs: list, fn_name: str, timeout: int
|
||||
):
|
||||
|
||||
# call-based clean up logic
|
||||
# need to wrap in try-catch logic after to catch the correct errors, but for now this is fine.
|
||||
base_code = import_string + "\n\n" + code + '\n\n'
|
||||
|
||||
if "class Solution" in code:
|
||||
base_code += 'def run_main_code(self):\n'
|
||||
else:
|
||||
base_code += 'def run_main_code():\n'
|
||||
|
||||
all_inputs = [
|
||||
inputs.replace("\n", ",") for inputs in all_inputs
|
||||
]
|
||||
|
||||
triggered = False
|
||||
|
||||
try:
|
||||
all_outputs = [json.loads(output) for output in all_outputs]
|
||||
triggered = True
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
if not triggered:
|
||||
try:
|
||||
all_outputs = [
|
||||
json.loads(convert_python_literal_to_json(outputs)) for outputs in all_outputs
|
||||
]
|
||||
triggered = True
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
if not triggered:
|
||||
all_outputs = [
|
||||
convert_python_literal(outputs) for outputs in all_outputs
|
||||
]
|
||||
|
||||
total_execution = 0
|
||||
all_results = []
|
||||
for idx, (gt_inp, gt_out) in enumerate(zip(all_inputs, all_outputs)):
|
||||
code = base_code
|
||||
if 'class Solution' in code:
|
||||
code += f" return self.{fn_name}({gt_inp})\nSolution.run_main_code = run_main_code\n"
|
||||
else:
|
||||
code += f" return {fn_name}({gt_inp})\n"
|
||||
|
||||
compiled_sol = compile_code(code, timeout)
|
||||
if compiled_sol is None:
|
||||
return
|
||||
|
||||
method = get_function(compiled_sol, "run_main_code")
|
||||
|
||||
if method is None:
|
||||
return
|
||||
|
||||
signal.alarm(timeout)
|
||||
faulthandler.enable()
|
||||
try:
|
||||
# can lock here so time is useful
|
||||
start = time.time()
|
||||
prediction = method()
|
||||
total_execution += time.time() - start
|
||||
signal.alarm(0)
|
||||
|
||||
# don't penalize model if it produces tuples instead of lists
|
||||
# ground truth sequences are not tuples
|
||||
if isinstance(prediction, tuple):
|
||||
prediction = list(prediction)
|
||||
|
||||
tmp_result = prediction == gt_out
|
||||
|
||||
try:
|
||||
tmp_result = tmp_result or (json.dumps(prediction) == json.dumps(gt_out))
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
try:
|
||||
tmp_result = tmp_result or (np.allclose(float(prediction), float(gt_out)))
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
if isinstance(prediction, list):
|
||||
try:
|
||||
if len(prediction) == len(gt_out):
|
||||
all_matched = True
|
||||
for i in range(len(prediction)):
|
||||
if np.allclose(float(prediction[i]), float(gt_out[i])) == False:
|
||||
all_matched = False
|
||||
break
|
||||
tmp_result = tmp.result or all_matched
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
|
||||
# handle floating point comparisons
|
||||
|
||||
all_results.append(tmp_result)
|
||||
|
||||
if not tmp_result:
|
||||
return all_results, {
|
||||
"inputs": truncatefn(gt_inp),
|
||||
"output": truncatefn(prediction),
|
||||
"expected": truncatefn(gt_out),
|
||||
"error_code": -2,
|
||||
"error_message": "Wrong Answer",
|
||||
}
|
||||
except Exception as e:
|
||||
signal.alarm(0)
|
||||
if "timeoutexception" in repr(e).lower():
|
||||
all_results.append(-3)
|
||||
return all_results, {
|
||||
"error": repr(e),
|
||||
"error_code": -3,
|
||||
"error_message": "Time Limit Exceeded",
|
||||
"inputs": truncatefn(gt_inp),
|
||||
"expected": truncatefn(gt_out),
|
||||
}
|
||||
else:
|
||||
all_results.append(-4)
|
||||
return all_results, {
|
||||
"error": repr(e),
|
||||
"error_code": -4,
|
||||
"error_message": "Runtime Error",
|
||||
"inputs": truncatefn(gt_inp),
|
||||
"expected": truncatefn(gt_out),
|
||||
}
|
||||
|
||||
finally:
|
||||
signal.alarm(0)
|
||||
faulthandler.disable()
|
||||
|
||||
return all_results, {"execution time": total_execution}
|
||||
|
||||
|
||||
def grade_stdio(
|
||||
code: str,
|
||||
all_inputs: list,
|
||||
all_outputs: list,
|
||||
timeout: int,
|
||||
):
|
||||
## runtime doesn't interact well with __name__ == '__main__'
|
||||
code = clean_if_name(code)
|
||||
|
||||
## we wrap the given code inside another function
|
||||
code = make_function(code)
|
||||
|
||||
compiled_sol = compile_code(code, timeout)
|
||||
|
||||
if compiled_sol is None:
|
||||
return
|
||||
|
||||
method = get_function(compiled_sol, "wrapped_function")
|
||||
|
||||
if method is None:
|
||||
return
|
||||
|
||||
all_results = []
|
||||
total_execution_time = 0
|
||||
for idx, (gt_inp, gt_out) in enumerate(zip(all_inputs, all_outputs)):
|
||||
signal.alarm(timeout)
|
||||
faulthandler.enable()
|
||||
|
||||
signal.alarm(timeout)
|
||||
with Capturing() as captured_output:
|
||||
try:
|
||||
start = time.time()
|
||||
call_method(method, gt_inp)
|
||||
total_execution_time += time.time() - start
|
||||
# reset the alarm
|
||||
signal.alarm(0)
|
||||
except Exception as e:
|
||||
signal.alarm(0)
|
||||
if "timeoutexception" in repr(e).lower():
|
||||
all_results.append(-3)
|
||||
return all_results, {
|
||||
"error": repr(e),
|
||||
"error_code": -3,
|
||||
"error_message": "Time Limit Exceeded",
|
||||
"inputs": truncatefn(gt_inp),
|
||||
"expected": truncatefn(gt_out),
|
||||
}
|
||||
else:
|
||||
all_results.append(-4)
|
||||
return all_results, {
|
||||
"error": repr(e),
|
||||
"error_code": -4,
|
||||
"error_message": "Runtime Error",
|
||||
"inputs": truncatefn(gt_inp),
|
||||
"expected": truncatefn(gt_out),
|
||||
}
|
||||
|
||||
finally:
|
||||
signal.alarm(0)
|
||||
faulthandler.disable()
|
||||
|
||||
prediction = captured_output[0]
|
||||
|
||||
stripped_prediction_lines = get_stripped_lines(prediction)
|
||||
stripped_gt_out_lines = get_stripped_lines(gt_out)
|
||||
|
||||
## WA happens in multiple circumstances
|
||||
## so cache the return to make it clean!
|
||||
WA_send_args = {
|
||||
"inputs": truncatefn(gt_inp),
|
||||
"output": truncatefn(prediction),
|
||||
"expected": truncatefn(gt_out),
|
||||
"error_code": -2,
|
||||
}
|
||||
|
||||
if len(stripped_prediction_lines) != len(stripped_gt_out_lines):
|
||||
all_results.append(-2)
|
||||
WA_send_args["error_message"] = "Wrong answer: mismatched output length"
|
||||
return all_results, WA_send_args
|
||||
|
||||
for output_line_idx, (
|
||||
stripped_prediction_line,
|
||||
stripped_gt_out_line,
|
||||
) in enumerate(zip(stripped_prediction_lines, stripped_gt_out_lines)):
|
||||
WA_send_args["error_message"] = (
|
||||
f"Wrong answer at {output_line_idx=}: {truncatefn(stripped_prediction_line)} != {truncatefn(stripped_gt_out_line)}"
|
||||
)
|
||||
## CASE 1: exact match
|
||||
if stripped_prediction_line == stripped_gt_out_line:
|
||||
continue
|
||||
|
||||
## CASE 2: element-wise comparision
|
||||
## if there are floating elements
|
||||
## use `decimal` library for good floating point comparision
|
||||
## otherwise gotcha: np.isclose(50000000000000000, 50000000000000001) = True
|
||||
## note that we should always be able to convert to decimals
|
||||
|
||||
success, decimal_prediction_line = convert_line_to_decimals(
|
||||
stripped_prediction_line
|
||||
)
|
||||
|
||||
if not success:
|
||||
all_results.append(-2)
|
||||
return all_results, WA_send_args
|
||||
|
||||
success, decimal_gtout_line = convert_line_to_decimals(stripped_gt_out_line)
|
||||
|
||||
if not success:
|
||||
all_results.append(-2)
|
||||
return all_results, WA_send_args
|
||||
|
||||
if decimal_prediction_line == decimal_gtout_line:
|
||||
continue
|
||||
|
||||
ok = False
|
||||
try:
|
||||
if len(decimal_prediction_line) == len(decimal_gtout_line) and np.allclose(decimal_prediction_line, decimal_gtout_line):
|
||||
ok = True
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
if ok:
|
||||
continue
|
||||
all_results.append(-2)
|
||||
return all_results, WA_send_args
|
||||
all_results.append(True)
|
||||
|
||||
return all_results, {"execution time": total_execution_time}
|
||||
|
||||
|
||||
def run_test(problem_to_check, debug=False, timeout=6):
|
||||
"""
|
||||
if test(generated_code) is not None it'll try to run the code.
|
||||
otherwise it'll just return an input and output pair.
|
||||
"""
|
||||
signal.signal(signal.SIGALRM, timeout_handler)
|
||||
# Disable functionalities that can make destructive changes to the test.
|
||||
# max memory is set to 4GB
|
||||
reliability_guard()
|
||||
|
||||
generation = problem_to_check['generation']
|
||||
|
||||
generation = has_code(generation)
|
||||
|
||||
if generation is None:
|
||||
return [-1], "No code found."
|
||||
|
||||
if debug:
|
||||
print(f"start = {datetime.now().time()}")
|
||||
|
||||
if problem_to_check['starter_code'] == '':
|
||||
which_type = CODE_TYPE.standard_input # Standard input
|
||||
method_name = None
|
||||
else:
|
||||
starter = problem_to_check['starter_code']
|
||||
which_type = CODE_TYPE.call_based # Call-based
|
||||
method_name = problem_to_check['starter_code']
|
||||
|
||||
generation = post_process_code(generation).replace("\t", " ").replace('if __name__ == "__main__":', 'if True:').replace("if __name__ == '__main__':", 'if True:')
|
||||
|
||||
inputs, outputs = [], []
|
||||
for in_out in problem_to_check['input_output']:
|
||||
if os.path.exists(in_out['input']): # File based
|
||||
with open(in_out['input'], 'r', encoding='utf-8') as f:
|
||||
inputs.append(f.read().strip())
|
||||
with open(in_out['output'], 'r', encoding='utf-8') as f:
|
||||
outputs.append(f.read().strip())
|
||||
else: # plain-text based
|
||||
inputs.append(in_out['input'])
|
||||
outputs.append(in_out['output'])
|
||||
|
||||
assert(len(inputs) == len(outputs))
|
||||
|
||||
if debug:
|
||||
print(f"loaded {len(inputs)} Input-Output pairs = {datetime.now().time()}")
|
||||
|
||||
results = []
|
||||
if debug:
|
||||
print(f"loading test code = {datetime.now().time()}")
|
||||
|
||||
if which_type == CODE_TYPE.call_based:
|
||||
signal.alarm(timeout)
|
||||
try:
|
||||
results, metadata = grade_call_based(
|
||||
code=generation,
|
||||
all_inputs=inputs,
|
||||
all_outputs=outputs,
|
||||
fn_name=method_name,
|
||||
timeout=timeout,
|
||||
)
|
||||
return results, metadata
|
||||
except Exception as e:
|
||||
return [-4], f"Call-based Error as {e}"
|
||||
finally:
|
||||
signal.alarm(0)
|
||||
|
||||
elif which_type == CODE_TYPE.standard_input:
|
||||
signal.alarm(timeout)
|
||||
try:
|
||||
results, metadata = grade_stdio(
|
||||
code=generation,
|
||||
all_inputs=inputs,
|
||||
all_outputs=outputs,
|
||||
timeout=timeout,
|
||||
)
|
||||
return results, metadata
|
||||
except Exception as e:
|
||||
return [-4], f"Stdin-based Error as {e}"
|
||||
finally:
|
||||
signal.alarm(0)
|
||||
|
||||
|
||||
def reliability_guard(maximum_memory_bytes=None):
|
||||
"""
|
||||
This disables various destructive functions and prevents the generated code
|
||||
from interfering with the test (e.g. fork bomb, killing other processes,
|
||||
removing filesystem files, etc.)
|
||||
WARNING
|
||||
This function is NOT a security sandbox. Untrusted code, including, model-
|
||||
generated code, should not be blindly executed outside of one. See the
|
||||
Codex paper for more information about OpenAI's code sandbox, and proceed
|
||||
with caution.
|
||||
"""
|
||||
|
||||
if maximum_memory_bytes is not None:
|
||||
import resource
|
||||
|
||||
resource.setrlimit(
|
||||
resource.RLIMIT_AS, (maximum_memory_bytes, maximum_memory_bytes)
|
||||
)
|
||||
resource.setrlimit(
|
||||
resource.RLIMIT_DATA, (maximum_memory_bytes, maximum_memory_bytes)
|
||||
)
|
||||
if not platform.uname().system == "Darwin":
|
||||
resource.setrlimit(
|
||||
resource.RLIMIT_STACK, (maximum_memory_bytes, maximum_memory_bytes)
|
||||
)
|
||||
|
||||
faulthandler.disable()
|
||||
|
||||
import builtins
|
||||
|
||||
# builtins.exit = None
|
||||
builtins.quit = None
|
||||
|
||||
import os
|
||||
|
||||
os.environ["OMP_NUM_THREADS"] = "1"
|
||||
|
||||
os.kill = None
|
||||
os.system = None
|
||||
os.putenv = None
|
||||
os.remove = None
|
||||
os.removedirs = None
|
||||
os.rmdir = None
|
||||
os.fchdir = None
|
||||
os.setuid = None
|
||||
os.fork = None
|
||||
os.forkpty = None
|
||||
os.killpg = None
|
||||
os.rename = None
|
||||
os.renames = None
|
||||
os.truncate = None
|
||||
os.replace = None
|
||||
os.unlink = None
|
||||
os.fchmod = None
|
||||
os.fchown = None
|
||||
os.chmod = None
|
||||
os.chown = None
|
||||
os.chroot = None
|
||||
os.fchdir = None
|
||||
os.lchflags = None
|
||||
os.lchmod = None
|
||||
os.lchown = None
|
||||
os.getcwd = None
|
||||
os.chdir = None
|
||||
|
||||
import shutil
|
||||
|
||||
shutil.rmtree = None
|
||||
shutil.move = None
|
||||
shutil.chown = None
|
||||
|
||||
import subprocess
|
||||
|
||||
subprocess.Popen = None # type: ignore
|
||||
|
||||
__builtins__["help"] = None
|
||||
|
||||
import sys
|
||||
|
||||
sys.modules["ipdb"] = None
|
||||
sys.modules["joblib"] = None
|
||||
sys.modules["resource"] = None
|
||||
sys.modules["psutil"] = None
|
||||
sys.modules["tkinter"] = None
|
||||
395
evaluation/eval/tools/grader.py
Normal file
395
evaluation/eval/tools/grader.py
Normal file
@@ -0,0 +1,395 @@
|
||||
"""
|
||||
This logic is largely copied from the Hendrycks' MATH release (math_equivalence), and borrowed from:
|
||||
- https://github.com/microsoft/ProphetNet/tree/master/CRITIC
|
||||
- https://github.com/openai/prm800k
|
||||
- https://github.com/microsoft/ToRA/blob/main/src/eval/grader.py
|
||||
- https://github.com/deepseek-ai/DeepSeek-Math/blob/main/evaluation/eval/eval_utils.py
|
||||
"""
|
||||
|
||||
import re
|
||||
import regex
|
||||
import multiprocessing
|
||||
from math import isclose
|
||||
from typing import Union
|
||||
from collections import defaultdict
|
||||
|
||||
from sympy import simplify, N
|
||||
from sympy.parsing.sympy_parser import parse_expr
|
||||
from sympy.parsing.latex import parse_latex
|
||||
from .latex2sympy.latex2sympy2 import latex2sympy
|
||||
|
||||
# from .parser import choice_answer_clean, strip_string
|
||||
# from parser import choice_answer_clean
|
||||
|
||||
|
||||
def choice_answer_clean(pred: str):
|
||||
pred = pred.strip("\n").rstrip(".").rstrip("/").strip(" ").lstrip(":")
|
||||
# Clean the answer based on the dataset
|
||||
tmp = re.findall(r"\b(A|B|C|D|E)\b", pred.upper())
|
||||
if tmp:
|
||||
pred = tmp
|
||||
else:
|
||||
pred = [pred.strip().strip(".")]
|
||||
pred = pred[-1]
|
||||
# Remove the period at the end, again!
|
||||
pred = pred.rstrip(".").rstrip("/")
|
||||
return pred
|
||||
|
||||
|
||||
def parse_digits(num):
|
||||
num = regex.sub(",", "", str(num))
|
||||
try:
|
||||
return float(num)
|
||||
except:
|
||||
if num.endswith("%"):
|
||||
num = num[:-1]
|
||||
if num.endswith("\\"):
|
||||
num = num[:-1]
|
||||
try:
|
||||
return float(num) / 100
|
||||
except:
|
||||
pass
|
||||
return None
|
||||
|
||||
|
||||
def is_digit(num):
|
||||
# paired with parse_digits
|
||||
return parse_digits(num) is not None
|
||||
|
||||
|
||||
def str_to_pmatrix(input_str):
|
||||
input_str = input_str.strip()
|
||||
matrix_str = re.findall(r"\{.*,.*\}", input_str)
|
||||
pmatrix_list = []
|
||||
|
||||
for m in matrix_str:
|
||||
m = m.strip("{}")
|
||||
pmatrix = r"\begin{pmatrix}" + m.replace(",", "\\") + r"\end{pmatrix}"
|
||||
pmatrix_list.append(pmatrix)
|
||||
|
||||
return ", ".join(pmatrix_list)
|
||||
|
||||
|
||||
def math_equal(
|
||||
prediction: Union[bool, float, str],
|
||||
reference: Union[float, str],
|
||||
include_percentage: bool = True,
|
||||
is_close: bool = True,
|
||||
timeout: bool = False,
|
||||
) -> bool:
|
||||
"""
|
||||
Exact match of math if and only if:
|
||||
1. numerical equal: both can convert to float and are equal
|
||||
2. symbolic equal: both can convert to sympy expression and are equal
|
||||
"""
|
||||
# print("Judge:", prediction, reference)
|
||||
if prediction is None or reference is None:
|
||||
return False
|
||||
if str(prediction.strip().lower()) == str(reference.strip().lower()):
|
||||
return True
|
||||
if (
|
||||
reference in ["A", "B", "C", "D", "E"]
|
||||
and choice_answer_clean(prediction) == reference
|
||||
):
|
||||
return True
|
||||
|
||||
try: # 1. numerical equal
|
||||
if is_digit(prediction) and is_digit(reference):
|
||||
prediction = parse_digits(prediction)
|
||||
reference = parse_digits(reference)
|
||||
# number questions
|
||||
if include_percentage:
|
||||
gt_result = [reference / 100, reference, reference * 100]
|
||||
else:
|
||||
gt_result = [reference]
|
||||
for item in gt_result:
|
||||
try:
|
||||
if is_close:
|
||||
if numeric_equal(prediction, item):
|
||||
return True
|
||||
else:
|
||||
if item == prediction:
|
||||
return True
|
||||
except Exception:
|
||||
continue
|
||||
return False
|
||||
except:
|
||||
pass
|
||||
|
||||
if not prediction and prediction not in [0, False]:
|
||||
return False
|
||||
|
||||
# 2. symbolic equal
|
||||
reference = str(reference).strip()
|
||||
prediction = str(prediction).strip()
|
||||
|
||||
## pmatrix (amps)
|
||||
if "pmatrix" in prediction and not "pmatrix" in reference:
|
||||
reference = str_to_pmatrix(reference)
|
||||
|
||||
## deal with [], (), {}
|
||||
pred_str, ref_str = prediction, reference
|
||||
if (
|
||||
prediction.startswith("[")
|
||||
and prediction.endswith("]")
|
||||
and not reference.startswith("(")
|
||||
) or (
|
||||
prediction.startswith("(")
|
||||
and prediction.endswith(")")
|
||||
and not reference.startswith("[")
|
||||
):
|
||||
pred_str = pred_str.strip("[]()")
|
||||
ref_str = ref_str.strip("[]()")
|
||||
for s in ["{", "}", "(", ")"]:
|
||||
ref_str = ref_str.replace(s, "")
|
||||
pred_str = pred_str.replace(s, "")
|
||||
if pred_str.lower() == ref_str.lower():
|
||||
return True
|
||||
|
||||
## [a, b] vs. [c, d], return a==c and b==d
|
||||
if (
|
||||
regex.match(r"(\(|\[).+(\)|\])", prediction) is not None
|
||||
and regex.match(r"(\(|\[).+(\)|\])", reference) is not None
|
||||
):
|
||||
pred_parts = prediction[1:-1].split(",")
|
||||
ref_parts = reference[1:-1].split(",")
|
||||
if len(pred_parts) == len(ref_parts):
|
||||
if all(
|
||||
[
|
||||
math_equal(
|
||||
pred_parts[i], ref_parts[i], include_percentage, is_close
|
||||
)
|
||||
for i in range(len(pred_parts))
|
||||
]
|
||||
):
|
||||
return True
|
||||
if (
|
||||
(
|
||||
prediction.startswith("\\begin{pmatrix}")
|
||||
or prediction.startswith("\\begin{bmatrix}")
|
||||
)
|
||||
and (
|
||||
prediction.endswith("\\end{pmatrix}")
|
||||
or prediction.endswith("\\end{bmatrix}")
|
||||
)
|
||||
and (
|
||||
reference.startswith("\\begin{pmatrix}")
|
||||
or reference.startswith("\\begin{bmatrix}")
|
||||
)
|
||||
and (
|
||||
reference.endswith("\\end{pmatrix}") or reference.endswith("\\end{bmatrix}")
|
||||
)
|
||||
):
|
||||
pred_lines = [
|
||||
line.strip()
|
||||
for line in prediction[
|
||||
len("\\begin{pmatrix}") : -len("\\end{pmatrix}")
|
||||
].split("\\\\")
|
||||
if line.strip()
|
||||
]
|
||||
ref_lines = [
|
||||
line.strip()
|
||||
for line in reference[
|
||||
len("\\begin{pmatrix}") : -len("\\end{pmatrix}")
|
||||
].split("\\\\")
|
||||
if line.strip()
|
||||
]
|
||||
matched = True
|
||||
if len(pred_lines) == len(ref_lines):
|
||||
for pred_line, ref_line in zip(pred_lines, ref_lines):
|
||||
pred_parts = pred_line.split("&")
|
||||
ref_parts = ref_line.split("&")
|
||||
if len(pred_parts) == len(ref_parts):
|
||||
if not all(
|
||||
[
|
||||
math_equal(
|
||||
pred_parts[i],
|
||||
ref_parts[i],
|
||||
include_percentage,
|
||||
is_close,
|
||||
)
|
||||
for i in range(len(pred_parts))
|
||||
]
|
||||
):
|
||||
matched = False
|
||||
break
|
||||
else:
|
||||
matched = False
|
||||
if not matched:
|
||||
break
|
||||
else:
|
||||
matched = False
|
||||
if matched:
|
||||
return True
|
||||
|
||||
if prediction.count("=") == 1 and reference.count("=") == 1:
|
||||
pred = prediction.split("=")
|
||||
pred = f"{pred[0].strip()} - ({pred[1].strip()})"
|
||||
ref = reference.split("=")
|
||||
ref = f"{ref[0].strip()} - ({ref[1].strip()})"
|
||||
if symbolic_equal(pred, ref) or symbolic_equal(f"-({pred})", ref):
|
||||
return True
|
||||
elif (
|
||||
prediction.count("=") == 1
|
||||
and len(prediction.split("=")[0].strip()) <= 2
|
||||
and "=" not in reference
|
||||
):
|
||||
if math_equal(
|
||||
prediction.split("=")[1], reference, include_percentage, is_close
|
||||
):
|
||||
return True
|
||||
elif (
|
||||
reference.count("=") == 1
|
||||
and len(reference.split("=")[0].strip()) <= 2
|
||||
and "=" not in prediction
|
||||
):
|
||||
if math_equal(
|
||||
prediction, reference.split("=")[1], include_percentage, is_close
|
||||
):
|
||||
return True
|
||||
|
||||
# symbolic equal with sympy
|
||||
if timeout:
|
||||
if call_with_timeout(symbolic_equal_process, prediction, reference):
|
||||
return True
|
||||
else:
|
||||
if symbolic_equal(prediction, reference):
|
||||
return True
|
||||
|
||||
return False
|
||||
|
||||
|
||||
def math_equal_process(param):
|
||||
return math_equal(param[-2], param[-1])
|
||||
|
||||
|
||||
def numeric_equal(prediction: float, reference: float):
|
||||
# Note that relative tolerance has significant impact
|
||||
# on the result of the synthesized GSM-Hard dataset
|
||||
# if reference.is_integer():
|
||||
# return isclose(reference, round(prediction), abs_tol=1e-4)
|
||||
# else:
|
||||
# prediction = round(prediction, len(str(reference).split(".")[-1]))
|
||||
return isclose(reference, prediction, rel_tol=1e-4)
|
||||
|
||||
|
||||
def symbolic_equal(a, b):
|
||||
def _parse(s):
|
||||
for f in [parse_latex, parse_expr, latex2sympy]:
|
||||
try:
|
||||
return f(s.replace("\\\\", "\\"))
|
||||
except:
|
||||
try:
|
||||
return f(s)
|
||||
except:
|
||||
pass
|
||||
return s
|
||||
|
||||
a = _parse(a)
|
||||
b = _parse(b)
|
||||
|
||||
# direct equal
|
||||
try:
|
||||
if str(a) == str(b) or a == b:
|
||||
return True
|
||||
except:
|
||||
pass
|
||||
|
||||
# simplify equal
|
||||
try:
|
||||
if a.equals(b) or simplify(a - b) == 0:
|
||||
return True
|
||||
except:
|
||||
pass
|
||||
|
||||
# equation equal
|
||||
try:
|
||||
if (abs(a.lhs - a.rhs)).equals(abs(b.lhs - b.rhs)):
|
||||
return True
|
||||
except:
|
||||
pass
|
||||
|
||||
try:
|
||||
if numeric_equal(float(N(a)), float(N(b))):
|
||||
return True
|
||||
except:
|
||||
pass
|
||||
|
||||
# matrix
|
||||
try:
|
||||
# if a and b are matrix
|
||||
if a.shape == b.shape:
|
||||
_a = a.applyfunc(lambda x: round(x, 3))
|
||||
_b = b.applyfunc(lambda x: round(x, 3))
|
||||
if _a.equals(_b):
|
||||
return True
|
||||
except:
|
||||
pass
|
||||
|
||||
return False
|
||||
|
||||
|
||||
def symbolic_equal_process(a, b, output_queue):
|
||||
result = symbolic_equal(a, b)
|
||||
output_queue.put(result)
|
||||
|
||||
|
||||
def call_with_timeout(func, *args, timeout=1, **kwargs):
|
||||
output_queue = multiprocessing.Queue()
|
||||
process_args = args + (output_queue,)
|
||||
process = multiprocessing.Process(target=func, args=process_args, kwargs=kwargs)
|
||||
process.start()
|
||||
process.join(timeout)
|
||||
|
||||
if process.is_alive():
|
||||
process.terminate()
|
||||
process.join()
|
||||
return False
|
||||
|
||||
return output_queue.get()
|
||||
|
||||
def _test_math_equal():
|
||||
# print(math_equal("0.0833333333333333", "\\frac{1}{12}"))
|
||||
# print(math_equal("(1,4.5)", "(1,\\frac{9}{2})"))
|
||||
# print(math_equal("\\frac{x}{7}+\\frac{2}{7}", "\\frac{x+2}{7}", timeout=True))
|
||||
# print(math_equal("\\sec^2(y)", "\\tan^2(y)+1", timeout=True))
|
||||
# print(math_equal("\\begin{pmatrix}-\\frac{7}{4}&-2\\\\4&\\frac{1}{4}\\end{pmatrix}", "(\\begin{pmatrix}-\\frac{7}{4}&-2\\\\4&\\frac{1}{4}\\\\\\end{pmatrix})", timeout=True))
|
||||
|
||||
# pred = '\\begin{pmatrix}\\frac{1}{3x^{2/3}}&0&0\\\\0&1&0\\\\-\\sin(x)&0&0\\end{pmatrix}'
|
||||
# gt = '(\\begin{pmatrix}\\frac{1}{3\\sqrt[3]{x}^2}&0&0\\\\0&1&0\\\\-\\sin(x)&0&0\\\\\\end{pmatrix})'
|
||||
|
||||
# pred= '-\\frac{8x^2}{9(x^2-2)^{5/3}}+\\frac{2}{3(x^2-2)^{2/3}}'
|
||||
# gt= '-\\frac{2(x^2+6)}{9(x^2-2)\\sqrt[3]{x^2-2}^2}'
|
||||
|
||||
# pred = '-34x-45y+20z-100=0'
|
||||
# gt = '34x+45y-20z+100=0'
|
||||
|
||||
# pred = '\\frac{100}{3}'
|
||||
# gt = '33.3'
|
||||
|
||||
# pred = '\\begin{pmatrix}0.290243531202435\\\\0.196008371385084\\\\-0.186381278538813\\end{pmatrix}'
|
||||
# gt = '(\\begin{pmatrix}0.29\\\\0.196\\\\-0.186\\\\\\end{pmatrix})'
|
||||
|
||||
# pred = '\\frac{\\sqrt{\\sqrt{11}+\\sqrt{194}}}{2\\sqrt{33}+15}'
|
||||
# gt = '\\frac{\\sqrt{\\sqrt{11}+\\sqrt{194}}}{15+2\\sqrt{33}}'
|
||||
|
||||
# pred = '(+5)(b+2)'
|
||||
# gt = '(a+5)(b+2)'
|
||||
|
||||
# pred = '\\frac{1+\\sqrt{5}}{2}'
|
||||
# gt = '2'
|
||||
|
||||
# pred = '\\frac{34}{16}+\\frac{\\sqrt{1358}}{16}', gt = '4'
|
||||
# pred = '1', gt = '1\\\\sqrt{19}'
|
||||
|
||||
# pred = "(0.6,2.6667]"
|
||||
# gt = "(\\frac{3}{5},\\frac{8}{3}]"
|
||||
|
||||
gt = "x+2n+1"
|
||||
pred = "x+1"
|
||||
|
||||
print(math_equal(pred, gt, timeout=True))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
_test_math_equal()
|
||||
21
evaluation/eval/tools/latex2sympy/LICENSE.txt
Normal file
21
evaluation/eval/tools/latex2sympy/LICENSE.txt
Normal file
@@ -0,0 +1,21 @@
|
||||
The MIT License (MIT)
|
||||
|
||||
Copyright 2016, latex2sympy
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
638
evaluation/eval/tools/latex2sympy/PS.g4
Normal file
638
evaluation/eval/tools/latex2sympy/PS.g4
Normal file
@@ -0,0 +1,638 @@
|
||||
grammar PS;
|
||||
|
||||
options {
|
||||
language=Python2;
|
||||
}
|
||||
|
||||
WS: [ \t\r\n]+ -> skip;
|
||||
DOLLAR_SIGN: '\\$' -> skip;
|
||||
|
||||
ADD: '+';
|
||||
SUB: '-';
|
||||
MUL: '*';
|
||||
DIV: '/' | '\\over';
|
||||
|
||||
L_PAREN: '(';
|
||||
R_PAREN: ')';
|
||||
L_GROUP: '\\lgroup';
|
||||
R_GROUP: '\\rgroup';
|
||||
L_BRACE: '{';
|
||||
R_BRACE: '}';
|
||||
L_BRACE_VISUAL: '\\{';
|
||||
R_BRACE_VISUAL: '\\}';
|
||||
L_BRACE_CMD: '\\lbrace';
|
||||
R_BRACE_CMD: '\\rbrace';
|
||||
L_BRACKET: '[';
|
||||
R_BRACKET: ']';
|
||||
L_BRACK: '\\lbrack';
|
||||
R_BRACK: '\\rbrack';
|
||||
|
||||
BAR: '|';
|
||||
L_VERT: '\\lvert';
|
||||
R_VERT: '\\rvert';
|
||||
VERT: '\\vert';
|
||||
|
||||
NORM: '\\|';
|
||||
|
||||
L_FLOOR: '\\lfloor';
|
||||
R_FLOOR: '\\rfloor';
|
||||
LL_CORNER: '\\llcorner';
|
||||
LR_CORNER: '\\lrcorner';
|
||||
|
||||
L_CEIL: '\\lceil';
|
||||
R_CEIL: '\\rceil';
|
||||
UL_CORNER: '\\ulcorner';
|
||||
UR_CORNER: '\\urcorner';
|
||||
|
||||
L_LEFT: '\\left';
|
||||
R_RIGHT: '\\right';
|
||||
ML_LEFT: '\\mleft';
|
||||
MR_RIGHT: '\\mright';
|
||||
|
||||
//functions
|
||||
FUNC_LIM: '\\lim';
|
||||
LIM_APPROACH_SYM: '\\to' | '\\rightarrow' | '\\Rightarrow' | '\\longrightarrow' | '\\Longrightarrow';
|
||||
FUNC_INT: '\\int';
|
||||
FUNC_SUM: '\\sum';
|
||||
FUNC_PROD: '\\prod';
|
||||
|
||||
FUNC_LOG: '\\log';
|
||||
FUNC_LN: '\\ln';
|
||||
FUNC_EXP: '\\exp';
|
||||
FUNC_SIN: '\\sin';
|
||||
FUNC_COS: '\\cos';
|
||||
FUNC_TAN: '\\tan';
|
||||
FUNC_CSC: '\\csc';
|
||||
FUNC_SEC: '\\sec';
|
||||
FUNC_COT: '\\cot';
|
||||
|
||||
FUNC_ARCSIN: '\\arcsin';
|
||||
FUNC_ARCCOS: '\\arccos';
|
||||
FUNC_ARCTAN: '\\arctan';
|
||||
FUNC_ARCCSC: '\\arccsc';
|
||||
FUNC_ARCSEC: '\\arcsec';
|
||||
FUNC_ARCCOT: '\\arccot';
|
||||
|
||||
FUNC_SINH: '\\sinh';
|
||||
FUNC_COSH: '\\cosh';
|
||||
FUNC_TANH: '\\tanh';
|
||||
FUNC_ARSINH: '\\arsinh';
|
||||
FUNC_ARCOSH: '\\arcosh';
|
||||
FUNC_ARTANH: '\\artanh';
|
||||
FUNC_ARCSINH: '\\arcsinh';
|
||||
FUNC_ARCCOSH: '\\arccosh';
|
||||
FUNC_ARCTANH: '\\arctanh';
|
||||
|
||||
FUNC_ARSINH_NAME: 'arsinh';
|
||||
FUNC_ARCSINH_NAME: 'arcsinh';
|
||||
FUNC_ARCOSH_NAME: 'arcosh';
|
||||
FUNC_ARCCOSH_NAME: 'arccosh';
|
||||
FUNC_ARTANH_NAME: 'artanh';
|
||||
FUNC_ARCTANH_NAME: 'arctanh';
|
||||
FUNC_GCD_NAME: 'gcd';
|
||||
FUNC_LCM_NAME: 'lcm';
|
||||
FUNC_FLOOR_NAME: 'floor';
|
||||
FUNC_CEIL_NAME: 'ceil';
|
||||
|
||||
FUNC_SQRT: '\\sqrt';
|
||||
FUNC_GCD: '\\gcd';
|
||||
FUNC_LCM: '\\lcm';
|
||||
FUNC_FLOOR: '\\floor';
|
||||
FUNC_CEIL: '\\ceil';
|
||||
FUNC_MAX: '\\max';
|
||||
FUNC_MIN: '\\min';
|
||||
|
||||
FUNC_DET: '\\det';
|
||||
|
||||
FUNC_EYE_NAME: 'eye';
|
||||
FUNC_ZEROS_NAME: 'zeros';
|
||||
FUNC_ONES_NAME: 'ones';
|
||||
FUNC_COLS_NAME: 'cols';
|
||||
FUNC_ROWS_NAME: 'rows';
|
||||
FUNC_DIAG_NAME: 'diag';
|
||||
FUNC_NORM_NAME: 'norm';
|
||||
FUNC_RANK_NAME: 'rank';
|
||||
FUNC_TRACE_NAME: 'trace' | 'tr';
|
||||
FUNC_RREF_NAME: 'rref';
|
||||
FUNC_HSTACK_NAME: 'hstack';
|
||||
FUNC_VSTACK_NAME: 'vstack';
|
||||
FUNC_ORTHOGONALIZE_NAME: 'orth' | 'ortho' | 'orthogonal' | 'orthogonalize';
|
||||
FUNC_NULLSPACE_NAME: 'nullspace';
|
||||
FUNC_DIAGONALIZE_NAME: 'eig' | 'eigen' | 'diagonalize';
|
||||
FUNC_EIGENVALS_NAME: 'eigenvals' | 'eigenvalues';
|
||||
FUNC_EIGENVECTORS_NAME: 'eigenvects' | 'eigenvectors';
|
||||
FUNC_SVD_NAME: 'svd' | 'SVD';
|
||||
|
||||
//commands
|
||||
CMD_TIMES: '\\times';
|
||||
CMD_CDOT: '\\cdot';
|
||||
CMD_DIV: '\\div';
|
||||
CMD_FRAC: '\\frac';
|
||||
CMD_BINOM: '\\binom' | '\\tbinom' | '\\dbinom';
|
||||
CMD_CHOOSE: '\\choose';
|
||||
CMD_MOD: '\\mod';
|
||||
|
||||
CMD_MATHIT: '\\mathit';
|
||||
|
||||
CMD_OPERATORNAME: '\\operatorname';
|
||||
|
||||
//matrix test
|
||||
MATRIX_TYPE_MATRIX: 'matrix';
|
||||
MATRIX_TYPE_PMATRIX: 'pmatrix';
|
||||
MATRIX_TYPE_BMATRIX: 'bmatrix';
|
||||
MATRIX_TYPE_DET: 'vmatrix';
|
||||
MATRIX_TYPES: MATRIX_TYPE_MATRIX | MATRIX_TYPE_PMATRIX | MATRIX_TYPE_BMATRIX;
|
||||
CMD_MATRIX_START: '\\begin' L_BRACE MATRIX_TYPES R_BRACE;
|
||||
CMD_MATRIX_END: '\\end' L_BRACE MATRIX_TYPES R_BRACE;
|
||||
CMD_DET_START: '\\begin' L_BRACE MATRIX_TYPE_DET R_BRACE;
|
||||
CMD_DET_END: '\\end' L_BRACE MATRIX_TYPE_DET R_BRACE;
|
||||
MATRIX_DEL_COL: '&';
|
||||
MATRIX_DEL_ROW: '\\\\';
|
||||
|
||||
UNDERSCORE: '_';
|
||||
CARET: '^';
|
||||
COLON: ':';
|
||||
SEMICOLON: ';';
|
||||
COMMA: ',';
|
||||
PERIOD: '.';
|
||||
|
||||
fragment WS_CHAR: [ \t\r\n];
|
||||
DIFFERENTIAL: 'd' WS_CHAR*? ([a-zA-Z] | '\\' [a-zA-Z]+);
|
||||
|
||||
EXP_E: 'e' | '\\exponentialE';
|
||||
E_NOTATION_E: 'E';
|
||||
LETTER_NO_E: [a-df-zA-DF-Z]; // exclude e for exponential function and e notation
|
||||
fragment LETTER: [a-zA-Z];
|
||||
fragment DIGIT: [0-9];
|
||||
|
||||
MATRIX_XRIGHTARROW: '\\xrightarrow' | '\\xRightarrow';
|
||||
TRANSFORM_EXCHANGE: '<->' | '<=>' | '\\leftrightarrow' | '\\Leftrightarrow';
|
||||
|
||||
NUMBER:
|
||||
DIGIT+ (COMMA DIGIT DIGIT DIGIT)*
|
||||
| DIGIT* (COMMA DIGIT DIGIT DIGIT)* PERIOD DIGIT+;
|
||||
|
||||
E_NOTATION: NUMBER E_NOTATION_E (SUB | ADD)? DIGIT+;
|
||||
|
||||
IN: '\\in';
|
||||
ASSIGNMENT: '=';
|
||||
EQUAL: '==' | '\\equiv';
|
||||
LT: '<';
|
||||
LTE: '\\leq' | '\\le' | '\\leqslant';
|
||||
GT: '>';
|
||||
GTE: '\\geq' | '\\ge' | '\\geqslant';
|
||||
UNEQUAL: '!=' | '!==' | '\\ne' | '\\neq' | '\\not\\equiv';
|
||||
|
||||
BANG: '!';
|
||||
|
||||
fragment PERCENT_SIGN: '\\%';
|
||||
PERCENT_NUMBER: NUMBER PERCENT_SIGN;
|
||||
|
||||
//Excludes some letters for use as e.g. constants in SYMBOL
|
||||
fragment GREEK_LETTER:
|
||||
'\\char"000391' | //Alpha
|
||||
'\\alpha' |
|
||||
'\\char"000392' | //Beta
|
||||
'\\beta' |
|
||||
'\\Gamma' |
|
||||
'\\gamma' |
|
||||
'\\Delta' |
|
||||
'\\delta' |
|
||||
'\\char"000190' | //Epsilon
|
||||
'\\epsilon' |
|
||||
'\\varepsilon' |
|
||||
'\\char"000396' | //Zeta
|
||||
'\\zeta' |
|
||||
'\\char"000397' | //Eta
|
||||
'\\eta' |
|
||||
'\\Theta' |
|
||||
'\\theta' |
|
||||
'\\vartheta' |
|
||||
'\\char"000399' | //Iota
|
||||
'\\iota' |
|
||||
'\\char"00039A' | //Kappa
|
||||
'\\kappa' |
|
||||
'\\Lambda' |
|
||||
'\\lambda' |
|
||||
'\\char"00039C' | //Mu
|
||||
'\\mu' |
|
||||
'\\char"00039D' | //Nu
|
||||
'\\nu' |
|
||||
'\\Xi' |
|
||||
'\\xi' |
|
||||
'\\char"00039F' | //Omicron
|
||||
'\\omicron' |
|
||||
'\\Pi' |
|
||||
'\\varpi' |
|
||||
'\\char"0003A1' | //Rho
|
||||
'\\rho' |
|
||||
'\\varrho' |
|
||||
'\\Sigma' |
|
||||
'\\sigma' |
|
||||
'\\varsigma' |
|
||||
'\\char"0003A4' | //Tau
|
||||
'\\tau' |
|
||||
'\\Upsilon' |
|
||||
'\\upsilon' |
|
||||
'\\Phi' |
|
||||
'\\phi' |
|
||||
'\\varphi' |
|
||||
'\\char"0003A7' | //Chi
|
||||
'\\chi' |
|
||||
'\\Psi' |
|
||||
'\\psi' |
|
||||
'\\Omega' |
|
||||
'\\omega';
|
||||
|
||||
GREEK_CMD: GREEK_LETTER [ ]?;
|
||||
|
||||
fragment OTHER_SYMBOL:
|
||||
'\\Bbbk' |
|
||||
'\\wp' |
|
||||
'\\nabla' |
|
||||
'\\bigstar' |
|
||||
'\\angle' |
|
||||
'\\nexists' |
|
||||
'\\diagdown' |
|
||||
'\\measuredangle' |
|
||||
'\\eth' |
|
||||
'\\emptyset' |
|
||||
'\\diagup' |
|
||||
'\\sphericalangle' |
|
||||
'\\clubsuit' |
|
||||
'\\varnothing' |
|
||||
'\\Diamond' |
|
||||
'\\complement' |
|
||||
'\\diamondsuit' |
|
||||
'\\imath' |
|
||||
'\\Finv' |
|
||||
'\\triangledown' |
|
||||
'\\heartsuit' |
|
||||
'\\jmath' |
|
||||
'\\Game' |
|
||||
'\\triangle' |
|
||||
'\\spadesuit' |
|
||||
'\\ell' |
|
||||
'\\hbar' |
|
||||
'\\vartriangle' |
|
||||
'\\hslash' |
|
||||
'\\blacklozenge' |
|
||||
'\\lozenge' |
|
||||
'\\blacksquare' |
|
||||
'\\mho' |
|
||||
'\\blacktriangle' |
|
||||
'\\sharp' |
|
||||
'\\prime' |
|
||||
'\\Im' |
|
||||
'\\flat' |
|
||||
'\\square' |
|
||||
'\\backprime' |
|
||||
'\\Re' |
|
||||
'\\natural' |
|
||||
'\\surd' |
|
||||
'\\circledS';
|
||||
OTHER_SYMBOL_CMD: OTHER_SYMBOL [ ]?;
|
||||
|
||||
fragment PI: '\\pi';
|
||||
fragment INFTY_CMD: '\\infty';
|
||||
fragment PARTIAL_CMD: '\\partial';
|
||||
fragment INFTY: INFTY_CMD | DOLLAR_SIGN INFTY_CMD | INFTY_CMD PERCENT_SIGN;
|
||||
fragment EMPTYSET: '\\emptyset';
|
||||
SYMBOL: PI | PARTIAL_CMD | INFTY | EMPTYSET;
|
||||
|
||||
fragment VARIABLE_CMD: '\\variable';
|
||||
fragment VARIABLE_SYMBOL: (GREEK_CMD | OTHER_SYMBOL_CMD | LETTER | DIGIT)+ (UNDERSCORE ((L_BRACE (GREEK_CMD | OTHER_SYMBOL_CMD | LETTER | DIGIT | COMMA)+ R_BRACE) | (GREEK_CMD | OTHER_SYMBOL_CMD | LETTER | DIGIT)))?;
|
||||
VARIABLE: VARIABLE_CMD L_BRACE VARIABLE_SYMBOL R_BRACE PERCENT_SIGN?;
|
||||
|
||||
//collection of accents
|
||||
accent_symbol:
|
||||
'\\acute' |
|
||||
'\\bar' |
|
||||
'\\overline' |
|
||||
'\\breve' |
|
||||
'\\check' |
|
||||
'\\widecheck' |
|
||||
'\\dot' |
|
||||
'\\ddot' |
|
||||
'\\grave' |
|
||||
'\\hat' |
|
||||
'\\tilde' |
|
||||
'\\widetilde' |
|
||||
'\\vec' |
|
||||
'\\overrightarrow' |
|
||||
'\\bm' |
|
||||
'\\boldsymbol' |
|
||||
'\\text' |
|
||||
'\\textit' |
|
||||
'\\mathbb' |
|
||||
'\\mathbin' |
|
||||
'\\mathbf' |
|
||||
'\\mathcal' |
|
||||
'\\mathclap' |
|
||||
'\\mathclose' |
|
||||
'\\mathellipsis' |
|
||||
'\\mathfrak' |
|
||||
'\\mathinner' |
|
||||
'\\mathit' |
|
||||
'\\mathnormal' |
|
||||
'\\mathop' |
|
||||
'\\mathopen' |
|
||||
'\\mathord' |
|
||||
'\\mathpunct' |
|
||||
'\\mathrel' |
|
||||
'\\mathring' |
|
||||
'\\mathrlap' |
|
||||
'\\mathrm' |
|
||||
'\\mathscr' |
|
||||
'\\mathsf' |
|
||||
'\\mathsterling' |
|
||||
'\\mathtt';
|
||||
|
||||
math: relation | relation_list;
|
||||
|
||||
transpose: '^T' | '^{T}' | '^{\\top}' | '\'';
|
||||
|
||||
transform_atom: LETTER_NO_E UNDERSCORE (NUMBER | L_BRACE NUMBER R_BRACE);
|
||||
transform_scale: (expr | group | ADD | SUB) transform_atom;
|
||||
transform_swap: transform_atom TRANSFORM_EXCHANGE transform_atom;
|
||||
transform_assignment: transform_atom transform_scale;
|
||||
elementary_transform: transform_assignment | transform_scale | transform_swap;
|
||||
elementary_transforms: elementary_transform (COMMA elementary_transform)*;
|
||||
|
||||
matrix:
|
||||
CMD_MATRIX_START
|
||||
matrix_row (MATRIX_DEL_ROW matrix_row)* MATRIX_DEL_ROW?
|
||||
CMD_MATRIX_END
|
||||
(MATRIX_XRIGHTARROW (L_BRACKET elementary_transforms R_BRACKET)? L_BRACE elementary_transforms R_BRACE)?;
|
||||
|
||||
det:
|
||||
CMD_DET_START
|
||||
matrix_row (MATRIX_DEL_ROW matrix_row)* MATRIX_DEL_ROW?
|
||||
CMD_DET_END;
|
||||
|
||||
matrix_row:
|
||||
expr (MATRIX_DEL_COL expr)*;
|
||||
|
||||
relation:
|
||||
relation (IN | ASSIGNMENT | EQUAL | LT | LTE | GT | GTE | UNEQUAL) relation
|
||||
| expr;
|
||||
|
||||
relation_list:
|
||||
relation_list_content
|
||||
| L_BRACKET relation_list_content R_BRACKET
|
||||
| L_BRACE relation_list_content R_BRACE
|
||||
| L_BRACE_VISUAL relation_list_content R_BRACE_VISUAL
|
||||
| L_LEFT L_BRACKET relation_list_content R_RIGHT R_BRACKET
|
||||
| L_LEFT L_BRACE_VISUAL relation_list_content R_RIGHT R_BRACE_VISUAL
|
||||
| ML_LEFT L_BRACKET relation_list_content MR_RIGHT R_BRACKET
|
||||
| ML_LEFT L_BRACE_VISUAL relation_list_content MR_RIGHT R_BRACE_VISUAL;
|
||||
|
||||
relation_list_content:
|
||||
relation COMMA relation (COMMA relation)*
|
||||
| relation SEMICOLON relation (SEMICOLON relation)*;
|
||||
|
||||
equality:
|
||||
expr (EQUAL | ASSIGNMENT) expr;
|
||||
|
||||
expr: additive;
|
||||
|
||||
additive:
|
||||
additive (ADD | SUB) additive
|
||||
| mp;
|
||||
|
||||
// mult part
|
||||
mp:
|
||||
mp (MUL | CMD_TIMES | CMD_CDOT | DIV | CMD_DIV | COLON | CMD_MOD) mp
|
||||
| unary;
|
||||
|
||||
mp_nofunc:
|
||||
mp_nofunc (MUL | CMD_TIMES | CMD_CDOT | DIV | CMD_DIV | COLON | CMD_MOD) mp_nofunc
|
||||
| unary_nofunc;
|
||||
|
||||
unary:
|
||||
(ADD | SUB) unary
|
||||
| postfix+;
|
||||
|
||||
unary_nofunc:
|
||||
(ADD | SUB) unary_nofunc
|
||||
| postfix postfix_nofunc*;
|
||||
|
||||
postfix: exp postfix_op*;
|
||||
postfix_nofunc: exp_nofunc postfix_op*;
|
||||
postfix_op: BANG | eval_at | transpose;
|
||||
|
||||
eval_at:
|
||||
BAR (eval_at_sup | eval_at_sub | eval_at_sup eval_at_sub);
|
||||
|
||||
eval_at_sub:
|
||||
UNDERSCORE L_BRACE
|
||||
(expr | equality)
|
||||
R_BRACE;
|
||||
|
||||
eval_at_sup:
|
||||
CARET L_BRACE
|
||||
(expr | equality)
|
||||
R_BRACE;
|
||||
|
||||
exp:
|
||||
exp CARET (atom | L_BRACE expr R_BRACE) subexpr?
|
||||
| comp;
|
||||
|
||||
exp_nofunc:
|
||||
exp_nofunc CARET (atom | L_BRACE expr R_BRACE) subexpr?
|
||||
| comp_nofunc;
|
||||
|
||||
comp:
|
||||
group
|
||||
| norm_group
|
||||
| abs_group
|
||||
| floor_group
|
||||
| ceil_group
|
||||
| func
|
||||
| atom
|
||||
| frac
|
||||
| binom
|
||||
| matrix
|
||||
| det;
|
||||
|
||||
comp_nofunc:
|
||||
group
|
||||
| norm_group
|
||||
| abs_group
|
||||
| floor_group
|
||||
| ceil_group
|
||||
| atom
|
||||
| frac
|
||||
| binom
|
||||
| matrix
|
||||
| det;
|
||||
|
||||
group:
|
||||
L_PAREN expr R_PAREN
|
||||
| L_GROUP expr R_GROUP
|
||||
| L_BRACE expr R_BRACE
|
||||
| L_BRACE_VISUAL expr R_BRACE_VISUAL
|
||||
| L_BRACE_CMD expr R_BRACE_CMD
|
||||
| L_BRACKET expr R_BRACKET
|
||||
| L_BRACK expr R_BRACK
|
||||
| L_LEFT L_PAREN expr R_RIGHT R_PAREN
|
||||
| L_LEFT L_GROUP expr R_RIGHT R_GROUP
|
||||
| L_LEFT L_BRACE expr R_RIGHT R_BRACE
|
||||
| L_LEFT L_BRACE_VISUAL expr R_RIGHT R_BRACE_VISUAL
|
||||
| L_LEFT L_BRACE_CMD expr R_RIGHT R_BRACE_CMD
|
||||
| L_LEFT L_BRACKET expr R_RIGHT R_BRACKET
|
||||
| L_LEFT L_BRACK expr R_RIGHT R_BRACK
|
||||
| ML_LEFT L_PAREN expr MR_RIGHT R_PAREN
|
||||
| ML_LEFT L_GROUP expr MR_RIGHT R_GROUP
|
||||
| ML_LEFT L_BRACE expr MR_RIGHT R_BRACE
|
||||
| ML_LEFT L_BRACE_VISUAL expr MR_RIGHT R_BRACE_VISUAL
|
||||
| ML_LEFT L_BRACE_CMD expr MR_RIGHT R_BRACE_CMD
|
||||
| ML_LEFT L_BRACKET expr MR_RIGHT R_BRACKET
|
||||
| ML_LEFT L_BRACK expr MR_RIGHT R_BRACK;
|
||||
|
||||
|
||||
norm_group:
|
||||
NORM expr NORM
|
||||
| L_LEFT NORM expr R_RIGHT NORM
|
||||
| ML_LEFT NORM expr MR_RIGHT NORM;
|
||||
|
||||
|
||||
abs_group:
|
||||
BAR expr BAR
|
||||
| L_VERT expr R_VERT
|
||||
| VERT expr VERT
|
||||
| L_LEFT BAR expr R_RIGHT BAR
|
||||
| L_LEFT L_VERT expr R_RIGHT R_VERT
|
||||
| L_LEFT VERT expr R_RIGHT VERT
|
||||
| ML_LEFT BAR expr MR_RIGHT BAR
|
||||
| ML_LEFT L_VERT expr MR_RIGHT R_VERT
|
||||
| ML_LEFT VERT expr MR_RIGHT VERT;
|
||||
|
||||
|
||||
floor_group:
|
||||
L_FLOOR expr R_FLOOR
|
||||
| LL_CORNER expr LR_CORNER
|
||||
| L_LEFT L_FLOOR expr R_RIGHT R_FLOOR
|
||||
| L_LEFT LL_CORNER expr R_RIGHT LR_CORNER
|
||||
| ML_LEFT L_FLOOR expr MR_RIGHT R_FLOOR
|
||||
| ML_LEFT LL_CORNER expr MR_RIGHT LR_CORNER;
|
||||
|
||||
|
||||
ceil_group:
|
||||
L_CEIL expr R_CEIL
|
||||
| UL_CORNER expr UR_CORNER
|
||||
| L_LEFT L_CEIL expr R_RIGHT R_CEIL
|
||||
| L_LEFT UL_CORNER expr R_RIGHT UR_CORNER
|
||||
| ML_LEFT L_CEIL expr MR_RIGHT R_CEIL
|
||||
| ML_LEFT UL_CORNER expr MR_RIGHT UR_CORNER;
|
||||
|
||||
|
||||
//indicate an accent
|
||||
accent:
|
||||
accent_symbol
|
||||
L_BRACE base=expr R_BRACE;
|
||||
|
||||
atom_expr_no_supexpr: (LETTER_NO_E | GREEK_CMD | OTHER_SYMBOL_CMD | accent) subexpr?;
|
||||
atom_expr: (LETTER_NO_E | GREEK_CMD | OTHER_SYMBOL_CMD | accent) (supexpr subexpr | subexpr supexpr | subexpr | supexpr)?;
|
||||
atom: atom_expr | SYMBOL | NUMBER | PERCENT_NUMBER | E_NOTATION | DIFFERENTIAL | mathit | VARIABLE;
|
||||
|
||||
mathit: CMD_MATHIT L_BRACE mathit_text R_BRACE;
|
||||
mathit_text: (LETTER_NO_E | E_NOTATION_E | EXP_E)+;
|
||||
|
||||
frac:
|
||||
CMD_FRAC L_BRACE
|
||||
upper=expr
|
||||
R_BRACE L_BRACE
|
||||
lower=expr
|
||||
R_BRACE;
|
||||
|
||||
//a binomial expression
|
||||
binom:
|
||||
L_BRACE upper=expr CMD_CHOOSE lower=expr R_BRACE
|
||||
| CMD_BINOM L_BRACE upper=expr R_BRACE L_BRACE lower=expr R_BRACE;
|
||||
|
||||
func_normal_functions_single_arg:
|
||||
FUNC_LOG | FUNC_LN | FUNC_EXP
|
||||
| FUNC_SIN | FUNC_COS | FUNC_TAN
|
||||
| FUNC_CSC | FUNC_SEC | FUNC_COT
|
||||
| FUNC_ARCSIN | FUNC_ARCCOS | FUNC_ARCTAN
|
||||
| FUNC_ARCCSC | FUNC_ARCSEC | FUNC_ARCCOT
|
||||
| FUNC_SINH | FUNC_COSH | FUNC_TANH
|
||||
| FUNC_ARSINH | FUNC_ARCOSH | FUNC_ARTANH
|
||||
| FUNC_ARCSINH | FUNC_ARCCOSH | FUNC_ARCTANH
|
||||
| FUNC_FLOOR | FUNC_CEIL | FUNC_DET;
|
||||
|
||||
func_normal_functions_multi_arg:
|
||||
FUNC_GCD | FUNC_LCM | FUNC_MAX | FUNC_MIN;
|
||||
|
||||
func_operator_names_single_arg:
|
||||
FUNC_ARSINH_NAME | FUNC_ARCOSH_NAME | FUNC_ARTANH_NAME
|
||||
| FUNC_ARCSINH_NAME | FUNC_ARCCOSH_NAME | FUNC_ARCTANH_NAME
|
||||
| FUNC_FLOOR_NAME | FUNC_CEIL_NAME | FUNC_EYE_NAME | FUNC_RANK_NAME | FUNC_TRACE_NAME
|
||||
| FUNC_RREF_NAME | FUNC_NULLSPACE_NAME | FUNC_DIAGONALIZE_NAME | FUNC_NORM_NAME
|
||||
| FUNC_EIGENVALS_NAME | FUNC_EIGENVECTORS_NAME | FUNC_SVD_NAME | FUNC_COLS_NAME | FUNC_ROWS_NAME;
|
||||
|
||||
func_operator_names_multi_arg:
|
||||
FUNC_GCD_NAME | FUNC_LCM_NAME | FUNC_ZEROS_NAME | FUNC_ORTHOGONALIZE_NAME
|
||||
| FUNC_ONES_NAME | FUNC_DIAG_NAME | FUNC_HSTACK_NAME | FUNC_VSTACK_NAME;
|
||||
|
||||
func_normal_single_arg:
|
||||
(func_normal_functions_single_arg)
|
||||
|
|
||||
(CMD_OPERATORNAME L_BRACE func_operator_name=func_operator_names_single_arg R_BRACE);
|
||||
|
||||
func_normal_multi_arg:
|
||||
(func_normal_functions_multi_arg)
|
||||
|
|
||||
(CMD_OPERATORNAME L_BRACE func_operator_name=func_operator_names_multi_arg R_BRACE);
|
||||
|
||||
func:
|
||||
func_normal_single_arg
|
||||
(subexpr? supexpr? | supexpr? subexpr?)
|
||||
(L_LEFT? L_PAREN func_single_arg R_RIGHT? R_PAREN | ML_LEFT? L_PAREN func_single_arg MR_RIGHT? R_PAREN | func_single_arg_noparens)
|
||||
|
||||
| func_normal_multi_arg
|
||||
(subexpr? supexpr? | supexpr? subexpr?)
|
||||
(L_LEFT? L_PAREN func_multi_arg R_RIGHT? R_PAREN | ML_LEFT? L_PAREN func_multi_arg MR_RIGHT? R_PAREN | func_multi_arg_noparens)
|
||||
|
||||
| atom_expr_no_supexpr supexpr?
|
||||
L_LEFT? (L_PAREN | L_BRACKET) func_common_args (R_PAREN | R_BRACKET) R_RIGHT?
|
||||
| atom_expr_no_supexpr supexpr?
|
||||
L_BRACE L_LEFT? (L_PAREN | L_BRACKET) func_common_args (R_PAREN | R_BRACKET) R_RIGHT? R_BRACE
|
||||
|
||||
| FUNC_INT
|
||||
(subexpr supexpr | supexpr subexpr | (UNDERSCORE L_BRACE R_BRACE) (CARET L_BRACE R_BRACE) | (CARET L_BRACE R_BRACE) (UNDERSCORE L_BRACE R_BRACE) )?
|
||||
(additive? DIFFERENTIAL | frac | additive)
|
||||
|
||||
| FUNC_SQRT
|
||||
(L_BRACKET root=expr R_BRACKET)?
|
||||
L_BRACE base=expr R_BRACE
|
||||
|
||||
| (FUNC_SUM | FUNC_PROD)
|
||||
(subeq supexpr | supexpr subeq)
|
||||
mp
|
||||
| FUNC_LIM limit_sub mp
|
||||
| EXP_E supexpr?; //Exponential function e^x
|
||||
|
||||
args: (expr ',' args) | expr;
|
||||
|
||||
func_common_args: atom | (expr ',') | (expr ',' args);
|
||||
|
||||
limit_sub:
|
||||
UNDERSCORE L_BRACE
|
||||
(LETTER_NO_E | GREEK_CMD | OTHER_SYMBOL_CMD)
|
||||
LIM_APPROACH_SYM
|
||||
expr (CARET L_BRACE (ADD | SUB) R_BRACE)?
|
||||
R_BRACE;
|
||||
|
||||
func_single_arg: expr;
|
||||
func_single_arg_noparens: mp_nofunc;
|
||||
|
||||
func_multi_arg: expr | (expr ',' func_multi_arg);
|
||||
func_multi_arg_noparens: mp_nofunc;
|
||||
|
||||
subexpr: UNDERSCORE (atom | L_BRACE (expr | args) R_BRACE);
|
||||
supexpr: CARET (atom | L_BRACE expr R_BRACE);
|
||||
|
||||
subeq: UNDERSCORE L_BRACE equality R_BRACE;
|
||||
supeq: UNDERSCORE L_BRACE equality R_BRACE;
|
||||
196
evaluation/eval/tools/latex2sympy/README.md
Normal file
196
evaluation/eval/tools/latex2sympy/README.md
Normal file
@@ -0,0 +1,196 @@
|
||||
|
||||
|
||||
# [latex2sympy2](https://github.com/OrangeX4/latex2sympy)
|
||||
|
||||
## About
|
||||
|
||||
`latex2sympy2` parses **LaTeX math expressions** and converts it into the equivalent **SymPy form**. The latex2sympy2 is adapted from [augustt198/latex2sympy](https://github.com/augustt198/latex2sympy) and [purdue-tlt / latex2sympy](https://github.com/purdue-tlt/latex2sympy).
|
||||
|
||||
This project is a part of a VS Code extension called [Latex Sympy Calculator](https://marketplace.visualstudio.com/items?itemName=OrangeX4.latex-sympy-calculator). It is designed for providing people writing in latex or markdown a ability to calculate something when writing math expression.
|
||||
|
||||
[ANTLR](http://www.antlr.org/) is used to generate the parser.
|
||||
|
||||
## Features
|
||||
|
||||
* **Arithmetic:** Add (+), Sub (-), Dot Mul (·), Cross Mul (×), Frac (/), Power (^), Abs (|x|), Sqrt (√), etc...
|
||||
* **Alphabet:** a - z, A - Z, α - ω, Subscript (x_1), Accent Bar(ā), etc...
|
||||
* **Common Functions:** gcd, lcm, floor, ceil, max, min, log, ln, exp, sin, cos, tan, csc, sec, cot, arcsin, sinh, arsinh, etc...
|
||||
* **Funcion Symbol:** f(x), f(x-1,), g(x,y), etc...
|
||||
* **Calculous:** Limit ($lim_{n\to\infty}$), Derivation ($\frac{d}{dx}(x^2+x)$), Integration ($\int xdx$), etc...
|
||||
* **Linear Algebra:** Matrix, Determinant, Transpose, Inverse, Elementary Transformation, etc...
|
||||
* **Other:** Binomial...
|
||||
|
||||
**NOTICE:** It will do some irreversible calculations when converting determinants, transposed matrixes and elementary transformations...
|
||||
|
||||
## Installation
|
||||
|
||||
```
|
||||
pip install latex2sympy2
|
||||
```
|
||||
|
||||
**Requirements:** `sympy` and `antlr4-python3-runtime` packages.
|
||||
|
||||
## Usage
|
||||
|
||||
### Basic
|
||||
|
||||
In Python:
|
||||
|
||||
```python
|
||||
from latex2sympy2 import latex2sympy, latex2latex
|
||||
|
||||
tex = r"\frac{d}{dx}(x^{2}+x)"
|
||||
# Or you can use '\mathrm{d}' to replace 'd'
|
||||
latex2sympy(tex)
|
||||
# => "Derivative(x**2 + x, x)"
|
||||
latex2latex(tex)
|
||||
# => "2 x + 1"
|
||||
```
|
||||
|
||||
### Examples
|
||||
|
||||
|LaTeX|Converted SymPy|Calculated Latex|
|
||||
|-----|-----|---------------|
|
||||
|`x^{3}` $x^{3}$| `x**3`|`x^{3}` $x^{3}$|
|
||||
|`\frac{d}{dx} tx` $\frac{d}{dx}tx$|`Derivative(x*t, x)`|`t` $t$|
|
||||
|`\sum_{i = 1}^{n} i` $\sum_{i = 1}^{n} i$|`Sum(i, (i, 1, n))`|`\frac{n \left(n + 1\right)}{2}` $\frac{n \left(n + 1\right)}{2}$|
|
||||
|`\int_{a}^{b} \frac{dt}{t}`|`Integral(1/t, (t, a, b))`|`-\log{(a)} + \log{(b)}` $-\log{(a)} + \log{(b)}$|
|
||||
|`(2x^3 - x + z)|_{x=3}` $(2x^3 - x + z)\|_{x=3}$|`z + 51`| `z + 51` $z + 51$ |
|
||||
|
||||
If you want to read the math formula, you can click [GitNotes](https://notes.orangex4.cool/?git=github&github=OrangeX4/latex2sympy).
|
||||
|
||||
### Solve Equation
|
||||
|
||||
``` latex
|
||||
# Before
|
||||
x + y = 1
|
||||
|
||||
# After
|
||||
[ y = 1 - x, \ x = 1 - y]
|
||||
```
|
||||
|
||||
### Eval At
|
||||
|
||||
``` latex
|
||||
# Before
|
||||
(x+2)|_{x=y+1}
|
||||
|
||||
# After
|
||||
y + 3
|
||||
```
|
||||
|
||||
### Matrix
|
||||
|
||||
#### Identity matrix
|
||||
|
||||
```
|
||||
tex = r"\bm{I}_3"
|
||||
latex2sympy(tex)
|
||||
# => "Matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]])"
|
||||
```
|
||||
|
||||
#### Determinant
|
||||
|
||||
``` python
|
||||
from latex2sympy2 import latex2sympy
|
||||
|
||||
tex = r"\begin{vmatrix} x & 0 & 0 \\ 0 & x & 0 \\ 0 & 0 & x \end{vmatrix}"
|
||||
latex2sympy(tex)
|
||||
# => "x^{3}"
|
||||
```
|
||||
|
||||
#### Transpose
|
||||
|
||||
``` python
|
||||
from latex2sympy2 import latex2sympy
|
||||
|
||||
tex = r"\begin{pmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \\ 7 & 8 & 9 \end{pmatrix}^T"
|
||||
# Or you can use "\begin{pmatrix}1&2&3\\4&5&6\\7&8&9\end{pmatrix}'"
|
||||
latex2sympy(tex)
|
||||
# => "Matrix([[1, 4, 7], [2, 5, 8], [3, 6, 9]])"
|
||||
```
|
||||
|
||||
#### Elementary Transformation
|
||||
|
||||
``` python
|
||||
from latex2sympy2 import latex2sympy
|
||||
|
||||
matrix = r'''
|
||||
\begin{pmatrix}
|
||||
1 & 2 & 3 \\
|
||||
4 & 5 & 6 \\
|
||||
7 & 8 & 9 \\
|
||||
\end{pmatrix}
|
||||
'''
|
||||
|
||||
# Scale the row with grammar "\xrightarrow{kr_n}"
|
||||
tex = matrix + r'\xrightarrow{3r_1}'
|
||||
latex2sympy(tex)
|
||||
# => "Matrix([[3, 6, 9], [4, 5, 6], [7, 8, 9]])"
|
||||
|
||||
# Swap the cols with grammar "\xrightarrow{c_1<=>c_2}"
|
||||
# Of course, you can use "\leftrightarrow" to replace "<=>"
|
||||
tex = matrix + r'\xrightarrow{c_1<=>c_2}'
|
||||
latex2sympy(tex)
|
||||
# => "Matrix([[2, 1, 3], [5, 4, 6], [8, 7, 9]])"
|
||||
|
||||
# Scale the second row and add it to the first row
|
||||
# with grammar "\xrightarrow{r_1+kr_2}"
|
||||
tex = matrix + r'\xrightarrow{r_1+kr_2}'
|
||||
latex2sympy(tex)
|
||||
# => "Matrix([[4*k + 1, 5*k + 2, 6*k + 3], [4, 5, 6], [7, 8, 9]])"
|
||||
|
||||
# You can compose the transform with comma ","
|
||||
# and grammar "\xrightarrow[4r_3]{2r_1, 3r_2}"
|
||||
# Remember the priority of "{}" is higher than "[]"
|
||||
tex = matrix + r'\xrightarrow[4r_3]{2r_1, 3r_2}'
|
||||
latex2sympy(tex)
|
||||
# => "Matrix([[2, 4, 6], [12, 15, 18], [28, 32, 36]])"
|
||||
```
|
||||
|
||||
### Variances
|
||||
|
||||
``` python
|
||||
from latex2sympy2 import latex2sympy, variances, var, set_variances
|
||||
|
||||
# Assign x a value of 1
|
||||
latex2sympy(r"x = 1")
|
||||
|
||||
# Assign x a matrix symbol with dimension of n x m
|
||||
latex2sympy(r"x \in \mathbb{R}^{n \times m}")
|
||||
|
||||
# Calculate x + y
|
||||
latex2sympy(r"x + y")
|
||||
# => "y + 1"
|
||||
|
||||
# Get all variances
|
||||
print(variances)
|
||||
# => "{x: 1}"
|
||||
|
||||
# Get variance of "x"
|
||||
print(var["x"])
|
||||
# => "1"
|
||||
|
||||
# Reset all variances
|
||||
set_variances({})
|
||||
latex2sympy(r"x + y")
|
||||
# => "x + y"
|
||||
```
|
||||
|
||||
### Complex Number Support
|
||||
|
||||
``` python
|
||||
from latex2sympy2 import set_real
|
||||
|
||||
set_real(False)
|
||||
```
|
||||
|
||||
|
||||
## Contributing
|
||||
|
||||
If you want to add a new grammar, you can fork the code from [OrangeX4/latex2sympy](https://github.com/OrangeX4/latex2sympy).
|
||||
|
||||
* To modify parser grammar, view the existing structure in `PS.g4`.
|
||||
* To modify the action associated with each grammar, look into `latex2sympy.py`.
|
||||
|
||||
Contributors are welcome! Feel free to open a pull request or an issue.
|
||||
0
evaluation/eval/tools/latex2sympy/__init__.py
Normal file
0
evaluation/eval/tools/latex2sympy/__init__.py
Normal file
@@ -0,0 +1,3 @@
|
||||
version https://git-lfs.github.com/spec/v1
|
||||
oid sha256:62975e192b4af2622b72b5f0131553ee3cbce97f76dc2a41632dcc55e25473e1
|
||||
size 3547867
|
||||
50
evaluation/eval/tools/latex2sympy/asciimath_printer.py
Normal file
50
evaluation/eval/tools/latex2sympy/asciimath_printer.py
Normal file
@@ -0,0 +1,50 @@
|
||||
from sympy.printing.str import StrPrinter
|
||||
from sympy.core import S
|
||||
|
||||
class AsciiMathPrinter(StrPrinter):
|
||||
|
||||
def _print_Limit(self, expr):
|
||||
e, z = expr.args
|
||||
|
||||
return "lim_(%s -> %s) %s" % (self._print(z), self._print(z), self._print(e))
|
||||
|
||||
def _print_Integral(self, expr):
|
||||
e, lims = expr.args
|
||||
if len(lims) > 1:
|
||||
return "int_(%s)^(%s) %s d%s" % (self._print(lims[1]), self._print(lims[2]), self._print(e), self._print(lims[0]))
|
||||
else:
|
||||
return "int %s d%s" % (self._print(e), self._print(lims))
|
||||
|
||||
def _print_Sum(self, expr):
|
||||
e, lims = expr.args
|
||||
return "sum_(%s = %s)^(%s) %s" % (self._print(lims[0]), self._print(lims[1]), self._print(lims[2]), self._print(e))
|
||||
|
||||
def _print_Product(self, expr):
|
||||
e, lims = expr.args
|
||||
return "prod_(%s = %s)^(%s) %s" % (self._print(lims[0]), self._print(lims[1]), self._print(lims[2]), self._print(e))
|
||||
|
||||
def _print_factorial(self, expr):
|
||||
return "%s!" % self._print(expr.args[0])
|
||||
|
||||
def _print_Derivative(self, expr):
|
||||
e = expr.args[0]
|
||||
wrt = expr.args[1]
|
||||
return "d/d%s %s" % (self._print(wrt), self._print(e))
|
||||
|
||||
def _print_Abs(self, expr):
|
||||
return "|%s|" % self._print(expr.args[0])
|
||||
|
||||
def _print_Equality(self, expr):
|
||||
return "%s = %s" % (self._print(expr.args[0]), self._print(expr.args[1]))
|
||||
|
||||
def _print_Pow(self, expr):
|
||||
b = self._print(expr.base)
|
||||
if expr.exp is S.Half:
|
||||
return "sqrt(%s)" % b
|
||||
|
||||
if -expr.exp is S.Half:
|
||||
return "1/sqrt(%s)" % b
|
||||
if expr.exp is -S.One:
|
||||
return "1/%s" % b
|
||||
|
||||
return "%s^(%s)" % (b, self._print(expr.exp))
|
||||
152
evaluation/eval/tools/latex2sympy/description.txt
Normal file
152
evaluation/eval/tools/latex2sympy/description.txt
Normal file
@@ -0,0 +1,152 @@
|
||||
latex2sympy2: https://github.com/OrangeX4/latex2sympy
|
||||
|
||||
About
|
||||
|
||||
`latex2sympy2` parses **LaTeX math expressions** and converts it into the equivalent **SymPy form**. The latex2sympy2 is adapted from [augustt198/latex2sympy](https://github.com/augustt198/latex2sympy) and [purdue-tlt / latex2sympy](https://github.com/purdue-tlt/latex2sympy).
|
||||
|
||||
[ANTLR](http://www.antlr.org/) is used to generate the parser.
|
||||
|
||||
Features
|
||||
|
||||
* **Arithmetic:** Add (+), Sub (-), Dot Mul (·), Cross Mul (×), Frac (/), Power (^), Abs (|x|), Sqrt (√), etc...
|
||||
* **Alphabet:** a - z, A - Z, α - ω, Subscript (x_1), Accent Bar(ā), etc...
|
||||
* **Common Functions:** gcd, lcm, floor, ceil, max, min, log, ln, exp, sin, cos, tan, csc, sec, cot, arcsin, sinh, arsinh, etc...
|
||||
* **Calculous:** Limit ($lim_{n\to\infty}$), Derivation ($\frac{d}{dx}(x^2+x)$), Integration ($\int xdx$), etc...
|
||||
* **Linear Algebra:** Matrix, Determinant, Transpose, Inverse, Elementary Transformation, etc...
|
||||
* **Other:** Binomial...
|
||||
|
||||
**NOTICE:** It will do some irreversible calculations when converting determinants, transposed matrixes and elementary transformations...
|
||||
|
||||
Installation
|
||||
|
||||
```
|
||||
pip install latex2sympy2
|
||||
```
|
||||
|
||||
**Requirements:** `sympy` and `antlr4-python3-runtime` packages.
|
||||
|
||||
Usage
|
||||
|
||||
Basic
|
||||
|
||||
In Python:
|
||||
|
||||
```python
|
||||
from latex2sympy2 import latex2sympy, latex2latex
|
||||
|
||||
tex = r"\frac{d}{dx}(x^{2}+x)"
|
||||
# Or you can use '\mathrm{d}' to replace 'd'
|
||||
latex2sympy(tex)
|
||||
# => "Derivative(x**2 + x, x)"
|
||||
latex2latex(tex)
|
||||
# => "2 x + 1"
|
||||
```
|
||||
|
||||
Examples
|
||||
|
||||
|LaTeX|Converted SymPy|Calculated Latex|
|
||||
|-----|-----|---------------|
|
||||
|`x^{3}` $x^{3}$| `x**3`|`x^{3}` $x^{3}$|
|
||||
|`\frac{d}{dx} tx` $\frac{d}{dx}tx$|`Derivative(x*t, x)`|`t` $t$|
|
||||
|`\sum_{i = 1}^{n} i` $\sum_{i = 1}^{n} i$|`Sum(i, (i, 1, n))`|`\frac{n \left(n + 1\right)}{2}` $\frac{n \left(n + 1\right)}{2}$|
|
||||
|`\int_{a}^{b} \frac{dt}{t}`|`Integral(1/t, (t, a, b))`|`-\log{(a)} + \log{(b)}` $-\log{(a)} + \log{(b)}$|
|
||||
|`(2x^3 - x + z)|_{x=3}` $(2x^3 - x + z)\|_{x=3}$|`z + 51`| `z + 51` $z + 51$ |
|
||||
|
||||
If you want to read the math formula, you can click [GitNotes](https://notes.orangex4.cool/?git=github&github=OrangeX4/latex2sympy).
|
||||
|
||||
Matrix
|
||||
|
||||
Determinant
|
||||
|
||||
``` python
|
||||
from latex2sympy2 import latex2sympy
|
||||
|
||||
tex = r"\begin{vmatrix} x & 0 & 0 \\ 0 & x & 0 \\ 0 & 0 & x \end{vmatrix}"
|
||||
latex2sympy(tex)
|
||||
# => "x^{3}"
|
||||
```
|
||||
|
||||
Transpose
|
||||
|
||||
``` python
|
||||
from latex2sympy2 import latex2sympy
|
||||
|
||||
tex = r"\begin{pmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \\ 7 & 8 & 9 \end{pmatrix}^T"
|
||||
# Or you can use "\begin{pmatrix}1&2&3\\4&5&6\\7&8&9\end{pmatrix}'"
|
||||
latex2sympy(tex)
|
||||
# => "Matrix([[1, 4, 7], [2, 5, 8], [3, 6, 9]])"
|
||||
```
|
||||
|
||||
Elementary Transformation
|
||||
|
||||
``` python
|
||||
from latex2sympy2 import latex2sympy
|
||||
|
||||
matrix = r'''
|
||||
\begin{pmatrix}
|
||||
1 & 2 & 3 \\
|
||||
4 & 5 & 6 \\
|
||||
7 & 8 & 9 \\
|
||||
\end{pmatrix}
|
||||
'''
|
||||
|
||||
# Scale the row with grammar "\xrightarrow{kr_n}"
|
||||
tex = matrix + r'\xrightarrow{3r_1}'
|
||||
latex2sympy(tex)
|
||||
# => "Matrix([[3, 6, 9], [4, 5, 6], [7, 8, 9]])"
|
||||
|
||||
# Swap the cols with grammar "\xrightarrow{c_1<=>c_2}"
|
||||
# Of course, you can use "\leftrightarrow" to replace "<=>"
|
||||
tex = matrix + r'\xrightarrow{c_1<=>c_2}'
|
||||
latex2sympy(tex)
|
||||
# => "Matrix([[2, 1, 3], [5, 4, 6], [8, 7, 9]])"
|
||||
|
||||
# Scale the second row and add it to the first row
|
||||
# with grammar "\xrightarrow{r_1+kr_2}"
|
||||
tex = matrix + r'\xrightarrow{r_1+kr_2}'
|
||||
latex2sympy(tex)
|
||||
# => "Matrix([[4*k + 1, 5*k + 2, 6*k + 3], [4, 5, 6], [7, 8, 9]])"
|
||||
|
||||
# You can compose the transform with comma ","
|
||||
# and grammar "\xrightarrow[4r_3]{2r_1, 3r_2}"
|
||||
# Remember the priority of "{}" is higher than "[]"
|
||||
tex = matrix + r'\xrightarrow[4r_3]{2r_1, 3r_2}'
|
||||
latex2sympy(tex)
|
||||
# => "Matrix([[2, 4, 6], [12, 15, 18], [28, 32, 36]])"
|
||||
```
|
||||
|
||||
Variances
|
||||
|
||||
``` python
|
||||
from latex2sympy2 import latex2sympy, variances, var, set_variances
|
||||
|
||||
# Assign x a value of 1
|
||||
latex2sympy(r"x = 1")
|
||||
|
||||
# Calculate x + y
|
||||
latex2sympy(r"x + y")
|
||||
# => "y + 1"
|
||||
|
||||
# Get all variances
|
||||
print(variances)
|
||||
# => "{x: 1}"
|
||||
|
||||
# Get variance of "x"
|
||||
print(var["x"])
|
||||
# => "1"
|
||||
|
||||
# Reset all variances
|
||||
set_variances({})
|
||||
latex2sympy(r"x + y")
|
||||
# => "x + y"
|
||||
```
|
||||
|
||||
|
||||
Contributing
|
||||
|
||||
If you want to add a new grammar, you can fork the code from [OrangeX4/latex2sympy](https://github.com/OrangeX4/latex2sympy).
|
||||
|
||||
* To modify parser grammar, view the existing structure in `PS.g4`.
|
||||
* To modify the action associated with each grammar, look into `latex2sympy.py`.
|
||||
|
||||
Contributors are welcome! Feel free to open a pull request or an issue.
|
||||
8
evaluation/eval/tools/latex2sympy/dev-requirements.in
Normal file
8
evaluation/eval/tools/latex2sympy/dev-requirements.in
Normal file
@@ -0,0 +1,8 @@
|
||||
-r requirements.txt
|
||||
# Development
|
||||
pip-tools
|
||||
pytest
|
||||
pytest-cov
|
||||
pycodestyle
|
||||
autopep8
|
||||
-e .
|
||||
60
evaluation/eval/tools/latex2sympy/dev-requirements.txt
Normal file
60
evaluation/eval/tools/latex2sympy/dev-requirements.txt
Normal file
@@ -0,0 +1,60 @@
|
||||
#
|
||||
# This file is autogenerated by pip-compile with Python 3.10
|
||||
# by the following command:
|
||||
#
|
||||
# pip-compile dev-requirements.in
|
||||
#
|
||||
# via -r dev-requirements.in
|
||||
antlr4-python3-runtime==4.11.1
|
||||
# via
|
||||
# -r requirements.txt
|
||||
# latex2sympy2
|
||||
atomicwrites==1.3.0
|
||||
# via pytest
|
||||
attrs==19.3.0
|
||||
# via pytest
|
||||
autopep8==1.4.4
|
||||
# via -r dev-requirements.in
|
||||
click==7.0
|
||||
# via pip-tools
|
||||
coverage==4.5.4
|
||||
# via pytest-cov
|
||||
more-itertools==7.2.0
|
||||
# via pytest
|
||||
mpmath==1.3.0
|
||||
# via
|
||||
# -r requirements.txt
|
||||
# sympy
|
||||
packaging==19.2
|
||||
# via pytest
|
||||
pip-tools==4.2.0
|
||||
# via -r dev-requirements.in
|
||||
pluggy==0.13.0
|
||||
# via pytest
|
||||
py==1.8.0
|
||||
# via pytest
|
||||
pycodestyle==2.5.0
|
||||
# via
|
||||
# -r dev-requirements.in
|
||||
# autopep8
|
||||
pyparsing==2.4.4
|
||||
# via packaging
|
||||
pytest==5.2.2
|
||||
# via
|
||||
# -r dev-requirements.in
|
||||
# pytest-cov
|
||||
pytest-cov==2.8.1
|
||||
# via -r dev-requirements.in
|
||||
six==1.13.0
|
||||
# via
|
||||
# packaging
|
||||
# pip-tools
|
||||
sympy==1.12
|
||||
# via
|
||||
# -r requirements.txt
|
||||
# latex2sympy2
|
||||
wcwidth==0.1.7
|
||||
# via pytest
|
||||
|
||||
# THIS MUST BE MAINTAINED AS-IS
|
||||
-e .
|
||||
462
evaluation/eval/tools/latex2sympy/gen/PS.interp
Normal file
462
evaluation/eval/tools/latex2sympy/gen/PS.interp
Normal file
File diff suppressed because one or more lines are too long
357
evaluation/eval/tools/latex2sympy/gen/PS.tokens
Normal file
357
evaluation/eval/tools/latex2sympy/gen/PS.tokens
Normal file
@@ -0,0 +1,357 @@
|
||||
T__0=1
|
||||
T__1=2
|
||||
T__2=3
|
||||
T__3=4
|
||||
T__4=5
|
||||
T__5=6
|
||||
T__6=7
|
||||
T__7=8
|
||||
T__8=9
|
||||
T__9=10
|
||||
T__10=11
|
||||
T__11=12
|
||||
T__12=13
|
||||
T__13=14
|
||||
T__14=15
|
||||
T__15=16
|
||||
T__16=17
|
||||
T__17=18
|
||||
T__18=19
|
||||
T__19=20
|
||||
T__20=21
|
||||
T__21=22
|
||||
T__22=23
|
||||
T__23=24
|
||||
T__24=25
|
||||
T__25=26
|
||||
T__26=27
|
||||
T__27=28
|
||||
T__28=29
|
||||
T__29=30
|
||||
T__30=31
|
||||
T__31=32
|
||||
T__32=33
|
||||
T__33=34
|
||||
T__34=35
|
||||
T__35=36
|
||||
T__36=37
|
||||
T__37=38
|
||||
T__38=39
|
||||
T__39=40
|
||||
T__40=41
|
||||
T__41=42
|
||||
T__42=43
|
||||
T__43=44
|
||||
WS=45
|
||||
DOLLAR_SIGN=46
|
||||
ADD=47
|
||||
SUB=48
|
||||
MUL=49
|
||||
DIV=50
|
||||
L_PAREN=51
|
||||
R_PAREN=52
|
||||
L_GROUP=53
|
||||
R_GROUP=54
|
||||
L_BRACE=55
|
||||
R_BRACE=56
|
||||
L_BRACE_VISUAL=57
|
||||
R_BRACE_VISUAL=58
|
||||
L_BRACE_CMD=59
|
||||
R_BRACE_CMD=60
|
||||
L_BRACKET=61
|
||||
R_BRACKET=62
|
||||
L_BRACK=63
|
||||
R_BRACK=64
|
||||
BAR=65
|
||||
L_VERT=66
|
||||
R_VERT=67
|
||||
VERT=68
|
||||
NORM=69
|
||||
L_FLOOR=70
|
||||
R_FLOOR=71
|
||||
LL_CORNER=72
|
||||
LR_CORNER=73
|
||||
L_CEIL=74
|
||||
R_CEIL=75
|
||||
UL_CORNER=76
|
||||
UR_CORNER=77
|
||||
L_LEFT=78
|
||||
R_RIGHT=79
|
||||
ML_LEFT=80
|
||||
MR_RIGHT=81
|
||||
FUNC_LIM=82
|
||||
LIM_APPROACH_SYM=83
|
||||
FUNC_INT=84
|
||||
FUNC_SUM=85
|
||||
FUNC_PROD=86
|
||||
FUNC_LOG=87
|
||||
FUNC_LN=88
|
||||
FUNC_EXP=89
|
||||
FUNC_SIN=90
|
||||
FUNC_COS=91
|
||||
FUNC_TAN=92
|
||||
FUNC_CSC=93
|
||||
FUNC_SEC=94
|
||||
FUNC_COT=95
|
||||
FUNC_ARCSIN=96
|
||||
FUNC_ARCCOS=97
|
||||
FUNC_ARCTAN=98
|
||||
FUNC_ARCCSC=99
|
||||
FUNC_ARCSEC=100
|
||||
FUNC_ARCCOT=101
|
||||
FUNC_SINH=102
|
||||
FUNC_COSH=103
|
||||
FUNC_TANH=104
|
||||
FUNC_ARSINH=105
|
||||
FUNC_ARCOSH=106
|
||||
FUNC_ARTANH=107
|
||||
FUNC_ARCSINH=108
|
||||
FUNC_ARCCOSH=109
|
||||
FUNC_ARCTANH=110
|
||||
FUNC_ARSINH_NAME=111
|
||||
FUNC_ARCSINH_NAME=112
|
||||
FUNC_ARCOSH_NAME=113
|
||||
FUNC_ARCCOSH_NAME=114
|
||||
FUNC_ARTANH_NAME=115
|
||||
FUNC_ARCTANH_NAME=116
|
||||
FUNC_GCD_NAME=117
|
||||
FUNC_LCM_NAME=118
|
||||
FUNC_FLOOR_NAME=119
|
||||
FUNC_CEIL_NAME=120
|
||||
FUNC_SQRT=121
|
||||
FUNC_GCD=122
|
||||
FUNC_LCM=123
|
||||
FUNC_FLOOR=124
|
||||
FUNC_CEIL=125
|
||||
FUNC_MAX=126
|
||||
FUNC_MIN=127
|
||||
FUNC_DET=128
|
||||
FUNC_EYE_NAME=129
|
||||
FUNC_ZEROS_NAME=130
|
||||
FUNC_ONES_NAME=131
|
||||
FUNC_COLS_NAME=132
|
||||
FUNC_ROWS_NAME=133
|
||||
FUNC_DIAG_NAME=134
|
||||
FUNC_NORM_NAME=135
|
||||
FUNC_RANK_NAME=136
|
||||
FUNC_TRACE_NAME=137
|
||||
FUNC_RREF_NAME=138
|
||||
FUNC_HSTACK_NAME=139
|
||||
FUNC_VSTACK_NAME=140
|
||||
FUNC_ORTHOGONALIZE_NAME=141
|
||||
FUNC_NULLSPACE_NAME=142
|
||||
FUNC_DIAGONALIZE_NAME=143
|
||||
FUNC_EIGENVALS_NAME=144
|
||||
FUNC_EIGENVECTORS_NAME=145
|
||||
FUNC_SVD_NAME=146
|
||||
CMD_TIMES=147
|
||||
CMD_CDOT=148
|
||||
CMD_DIV=149
|
||||
CMD_FRAC=150
|
||||
CMD_BINOM=151
|
||||
CMD_CHOOSE=152
|
||||
CMD_MOD=153
|
||||
CMD_MATHIT=154
|
||||
CMD_OPERATORNAME=155
|
||||
MATRIX_TYPE_MATRIX=156
|
||||
MATRIX_TYPE_PMATRIX=157
|
||||
MATRIX_TYPE_BMATRIX=158
|
||||
MATRIX_TYPE_DET=159
|
||||
MATRIX_TYPES=160
|
||||
CMD_MATRIX_START=161
|
||||
CMD_MATRIX_END=162
|
||||
CMD_DET_START=163
|
||||
CMD_DET_END=164
|
||||
MATRIX_DEL_COL=165
|
||||
MATRIX_DEL_ROW=166
|
||||
UNDERSCORE=167
|
||||
CARET=168
|
||||
COLON=169
|
||||
SEMICOLON=170
|
||||
COMMA=171
|
||||
PERIOD=172
|
||||
DIFFERENTIAL=173
|
||||
EXP_E=174
|
||||
E_NOTATION_E=175
|
||||
LETTER_NO_E=176
|
||||
MATRIX_XRIGHTARROW=177
|
||||
TRANSFORM_EXCHANGE=178
|
||||
NUMBER=179
|
||||
E_NOTATION=180
|
||||
IN=181
|
||||
ASSIGNMENT=182
|
||||
EQUAL=183
|
||||
LT=184
|
||||
LTE=185
|
||||
GT=186
|
||||
GTE=187
|
||||
UNEQUAL=188
|
||||
BANG=189
|
||||
PERCENT_NUMBER=190
|
||||
GREEK_CMD=191
|
||||
OTHER_SYMBOL_CMD=192
|
||||
SYMBOL=193
|
||||
VARIABLE=194
|
||||
'\\acute'=1
|
||||
'\\bar'=2
|
||||
'\\overline'=3
|
||||
'\\breve'=4
|
||||
'\\check'=5
|
||||
'\\widecheck'=6
|
||||
'\\dot'=7
|
||||
'\\ddot'=8
|
||||
'\\grave'=9
|
||||
'\\hat'=10
|
||||
'\\tilde'=11
|
||||
'\\widetilde'=12
|
||||
'\\vec'=13
|
||||
'\\overrightarrow'=14
|
||||
'\\bm'=15
|
||||
'\\boldsymbol'=16
|
||||
'\\text'=17
|
||||
'\\textit'=18
|
||||
'\\mathbb'=19
|
||||
'\\mathbin'=20
|
||||
'\\mathbf'=21
|
||||
'\\mathcal'=22
|
||||
'\\mathclap'=23
|
||||
'\\mathclose'=24
|
||||
'\\mathellipsis'=25
|
||||
'\\mathfrak'=26
|
||||
'\\mathinner'=27
|
||||
'\\mathnormal'=28
|
||||
'\\mathop'=29
|
||||
'\\mathopen'=30
|
||||
'\\mathord'=31
|
||||
'\\mathpunct'=32
|
||||
'\\mathrel'=33
|
||||
'\\mathring'=34
|
||||
'\\mathrlap'=35
|
||||
'\\mathrm'=36
|
||||
'\\mathscr'=37
|
||||
'\\mathsf'=38
|
||||
'\\mathsterling'=39
|
||||
'\\mathtt'=40
|
||||
'^T'=41
|
||||
'^{T}'=42
|
||||
'^{\\top}'=43
|
||||
'\''=44
|
||||
'\\$'=46
|
||||
'+'=47
|
||||
'-'=48
|
||||
'*'=49
|
||||
'('=51
|
||||
')'=52
|
||||
'\\lgroup'=53
|
||||
'\\rgroup'=54
|
||||
'{'=55
|
||||
'}'=56
|
||||
'\\{'=57
|
||||
'\\}'=58
|
||||
'\\lbrace'=59
|
||||
'\\rbrace'=60
|
||||
'['=61
|
||||
']'=62
|
||||
'\\lbrack'=63
|
||||
'\\rbrack'=64
|
||||
'|'=65
|
||||
'\\lvert'=66
|
||||
'\\rvert'=67
|
||||
'\\vert'=68
|
||||
'\\|'=69
|
||||
'\\lfloor'=70
|
||||
'\\rfloor'=71
|
||||
'\\llcorner'=72
|
||||
'\\lrcorner'=73
|
||||
'\\lceil'=74
|
||||
'\\rceil'=75
|
||||
'\\ulcorner'=76
|
||||
'\\urcorner'=77
|
||||
'\\left'=78
|
||||
'\\right'=79
|
||||
'\\mleft'=80
|
||||
'\\mright'=81
|
||||
'\\lim'=82
|
||||
'\\int'=84
|
||||
'\\sum'=85
|
||||
'\\prod'=86
|
||||
'\\log'=87
|
||||
'\\ln'=88
|
||||
'\\exp'=89
|
||||
'\\sin'=90
|
||||
'\\cos'=91
|
||||
'\\tan'=92
|
||||
'\\csc'=93
|
||||
'\\sec'=94
|
||||
'\\cot'=95
|
||||
'\\arcsin'=96
|
||||
'\\arccos'=97
|
||||
'\\arctan'=98
|
||||
'\\arccsc'=99
|
||||
'\\arcsec'=100
|
||||
'\\arccot'=101
|
||||
'\\sinh'=102
|
||||
'\\cosh'=103
|
||||
'\\tanh'=104
|
||||
'\\arsinh'=105
|
||||
'\\arcosh'=106
|
||||
'\\artanh'=107
|
||||
'\\arcsinh'=108
|
||||
'\\arccosh'=109
|
||||
'\\arctanh'=110
|
||||
'arsinh'=111
|
||||
'arcsinh'=112
|
||||
'arcosh'=113
|
||||
'arccosh'=114
|
||||
'artanh'=115
|
||||
'arctanh'=116
|
||||
'gcd'=117
|
||||
'lcm'=118
|
||||
'floor'=119
|
||||
'ceil'=120
|
||||
'\\sqrt'=121
|
||||
'\\gcd'=122
|
||||
'\\lcm'=123
|
||||
'\\floor'=124
|
||||
'\\ceil'=125
|
||||
'\\max'=126
|
||||
'\\min'=127
|
||||
'\\det'=128
|
||||
'eye'=129
|
||||
'zeros'=130
|
||||
'ones'=131
|
||||
'cols'=132
|
||||
'rows'=133
|
||||
'diag'=134
|
||||
'norm'=135
|
||||
'rank'=136
|
||||
'rref'=138
|
||||
'hstack'=139
|
||||
'vstack'=140
|
||||
'nullspace'=142
|
||||
'\\times'=147
|
||||
'\\cdot'=148
|
||||
'\\div'=149
|
||||
'\\frac'=150
|
||||
'\\choose'=152
|
||||
'\\mod'=153
|
||||
'\\mathit'=154
|
||||
'\\operatorname'=155
|
||||
'matrix'=156
|
||||
'pmatrix'=157
|
||||
'bmatrix'=158
|
||||
'vmatrix'=159
|
||||
'&'=165
|
||||
'\\\\'=166
|
||||
'_'=167
|
||||
'^'=168
|
||||
':'=169
|
||||
';'=170
|
||||
','=171
|
||||
'.'=172
|
||||
'E'=175
|
||||
'\\in'=181
|
||||
'='=182
|
||||
'<'=184
|
||||
'>'=186
|
||||
'!'=189
|
||||
612
evaluation/eval/tools/latex2sympy/gen/PSLexer.interp
Normal file
612
evaluation/eval/tools/latex2sympy/gen/PSLexer.interp
Normal file
File diff suppressed because one or more lines are too long
1446
evaluation/eval/tools/latex2sympy/gen/PSLexer.py
Normal file
1446
evaluation/eval/tools/latex2sympy/gen/PSLexer.py
Normal file
File diff suppressed because it is too large
Load Diff
357
evaluation/eval/tools/latex2sympy/gen/PSLexer.tokens
Normal file
357
evaluation/eval/tools/latex2sympy/gen/PSLexer.tokens
Normal file
@@ -0,0 +1,357 @@
|
||||
T__0=1
|
||||
T__1=2
|
||||
T__2=3
|
||||
T__3=4
|
||||
T__4=5
|
||||
T__5=6
|
||||
T__6=7
|
||||
T__7=8
|
||||
T__8=9
|
||||
T__9=10
|
||||
T__10=11
|
||||
T__11=12
|
||||
T__12=13
|
||||
T__13=14
|
||||
T__14=15
|
||||
T__15=16
|
||||
T__16=17
|
||||
T__17=18
|
||||
T__18=19
|
||||
T__19=20
|
||||
T__20=21
|
||||
T__21=22
|
||||
T__22=23
|
||||
T__23=24
|
||||
T__24=25
|
||||
T__25=26
|
||||
T__26=27
|
||||
T__27=28
|
||||
T__28=29
|
||||
T__29=30
|
||||
T__30=31
|
||||
T__31=32
|
||||
T__32=33
|
||||
T__33=34
|
||||
T__34=35
|
||||
T__35=36
|
||||
T__36=37
|
||||
T__37=38
|
||||
T__38=39
|
||||
T__39=40
|
||||
T__40=41
|
||||
T__41=42
|
||||
T__42=43
|
||||
T__43=44
|
||||
WS=45
|
||||
DOLLAR_SIGN=46
|
||||
ADD=47
|
||||
SUB=48
|
||||
MUL=49
|
||||
DIV=50
|
||||
L_PAREN=51
|
||||
R_PAREN=52
|
||||
L_GROUP=53
|
||||
R_GROUP=54
|
||||
L_BRACE=55
|
||||
R_BRACE=56
|
||||
L_BRACE_VISUAL=57
|
||||
R_BRACE_VISUAL=58
|
||||
L_BRACE_CMD=59
|
||||
R_BRACE_CMD=60
|
||||
L_BRACKET=61
|
||||
R_BRACKET=62
|
||||
L_BRACK=63
|
||||
R_BRACK=64
|
||||
BAR=65
|
||||
L_VERT=66
|
||||
R_VERT=67
|
||||
VERT=68
|
||||
NORM=69
|
||||
L_FLOOR=70
|
||||
R_FLOOR=71
|
||||
LL_CORNER=72
|
||||
LR_CORNER=73
|
||||
L_CEIL=74
|
||||
R_CEIL=75
|
||||
UL_CORNER=76
|
||||
UR_CORNER=77
|
||||
L_LEFT=78
|
||||
R_RIGHT=79
|
||||
ML_LEFT=80
|
||||
MR_RIGHT=81
|
||||
FUNC_LIM=82
|
||||
LIM_APPROACH_SYM=83
|
||||
FUNC_INT=84
|
||||
FUNC_SUM=85
|
||||
FUNC_PROD=86
|
||||
FUNC_LOG=87
|
||||
FUNC_LN=88
|
||||
FUNC_EXP=89
|
||||
FUNC_SIN=90
|
||||
FUNC_COS=91
|
||||
FUNC_TAN=92
|
||||
FUNC_CSC=93
|
||||
FUNC_SEC=94
|
||||
FUNC_COT=95
|
||||
FUNC_ARCSIN=96
|
||||
FUNC_ARCCOS=97
|
||||
FUNC_ARCTAN=98
|
||||
FUNC_ARCCSC=99
|
||||
FUNC_ARCSEC=100
|
||||
FUNC_ARCCOT=101
|
||||
FUNC_SINH=102
|
||||
FUNC_COSH=103
|
||||
FUNC_TANH=104
|
||||
FUNC_ARSINH=105
|
||||
FUNC_ARCOSH=106
|
||||
FUNC_ARTANH=107
|
||||
FUNC_ARCSINH=108
|
||||
FUNC_ARCCOSH=109
|
||||
FUNC_ARCTANH=110
|
||||
FUNC_ARSINH_NAME=111
|
||||
FUNC_ARCSINH_NAME=112
|
||||
FUNC_ARCOSH_NAME=113
|
||||
FUNC_ARCCOSH_NAME=114
|
||||
FUNC_ARTANH_NAME=115
|
||||
FUNC_ARCTANH_NAME=116
|
||||
FUNC_GCD_NAME=117
|
||||
FUNC_LCM_NAME=118
|
||||
FUNC_FLOOR_NAME=119
|
||||
FUNC_CEIL_NAME=120
|
||||
FUNC_SQRT=121
|
||||
FUNC_GCD=122
|
||||
FUNC_LCM=123
|
||||
FUNC_FLOOR=124
|
||||
FUNC_CEIL=125
|
||||
FUNC_MAX=126
|
||||
FUNC_MIN=127
|
||||
FUNC_DET=128
|
||||
FUNC_EYE_NAME=129
|
||||
FUNC_ZEROS_NAME=130
|
||||
FUNC_ONES_NAME=131
|
||||
FUNC_COLS_NAME=132
|
||||
FUNC_ROWS_NAME=133
|
||||
FUNC_DIAG_NAME=134
|
||||
FUNC_NORM_NAME=135
|
||||
FUNC_RANK_NAME=136
|
||||
FUNC_TRACE_NAME=137
|
||||
FUNC_RREF_NAME=138
|
||||
FUNC_HSTACK_NAME=139
|
||||
FUNC_VSTACK_NAME=140
|
||||
FUNC_ORTHOGONALIZE_NAME=141
|
||||
FUNC_NULLSPACE_NAME=142
|
||||
FUNC_DIAGONALIZE_NAME=143
|
||||
FUNC_EIGENVALS_NAME=144
|
||||
FUNC_EIGENVECTORS_NAME=145
|
||||
FUNC_SVD_NAME=146
|
||||
CMD_TIMES=147
|
||||
CMD_CDOT=148
|
||||
CMD_DIV=149
|
||||
CMD_FRAC=150
|
||||
CMD_BINOM=151
|
||||
CMD_CHOOSE=152
|
||||
CMD_MOD=153
|
||||
CMD_MATHIT=154
|
||||
CMD_OPERATORNAME=155
|
||||
MATRIX_TYPE_MATRIX=156
|
||||
MATRIX_TYPE_PMATRIX=157
|
||||
MATRIX_TYPE_BMATRIX=158
|
||||
MATRIX_TYPE_DET=159
|
||||
MATRIX_TYPES=160
|
||||
CMD_MATRIX_START=161
|
||||
CMD_MATRIX_END=162
|
||||
CMD_DET_START=163
|
||||
CMD_DET_END=164
|
||||
MATRIX_DEL_COL=165
|
||||
MATRIX_DEL_ROW=166
|
||||
UNDERSCORE=167
|
||||
CARET=168
|
||||
COLON=169
|
||||
SEMICOLON=170
|
||||
COMMA=171
|
||||
PERIOD=172
|
||||
DIFFERENTIAL=173
|
||||
EXP_E=174
|
||||
E_NOTATION_E=175
|
||||
LETTER_NO_E=176
|
||||
MATRIX_XRIGHTARROW=177
|
||||
TRANSFORM_EXCHANGE=178
|
||||
NUMBER=179
|
||||
E_NOTATION=180
|
||||
IN=181
|
||||
ASSIGNMENT=182
|
||||
EQUAL=183
|
||||
LT=184
|
||||
LTE=185
|
||||
GT=186
|
||||
GTE=187
|
||||
UNEQUAL=188
|
||||
BANG=189
|
||||
PERCENT_NUMBER=190
|
||||
GREEK_CMD=191
|
||||
OTHER_SYMBOL_CMD=192
|
||||
SYMBOL=193
|
||||
VARIABLE=194
|
||||
'\\acute'=1
|
||||
'\\bar'=2
|
||||
'\\overline'=3
|
||||
'\\breve'=4
|
||||
'\\check'=5
|
||||
'\\widecheck'=6
|
||||
'\\dot'=7
|
||||
'\\ddot'=8
|
||||
'\\grave'=9
|
||||
'\\hat'=10
|
||||
'\\tilde'=11
|
||||
'\\widetilde'=12
|
||||
'\\vec'=13
|
||||
'\\overrightarrow'=14
|
||||
'\\bm'=15
|
||||
'\\boldsymbol'=16
|
||||
'\\text'=17
|
||||
'\\textit'=18
|
||||
'\\mathbb'=19
|
||||
'\\mathbin'=20
|
||||
'\\mathbf'=21
|
||||
'\\mathcal'=22
|
||||
'\\mathclap'=23
|
||||
'\\mathclose'=24
|
||||
'\\mathellipsis'=25
|
||||
'\\mathfrak'=26
|
||||
'\\mathinner'=27
|
||||
'\\mathnormal'=28
|
||||
'\\mathop'=29
|
||||
'\\mathopen'=30
|
||||
'\\mathord'=31
|
||||
'\\mathpunct'=32
|
||||
'\\mathrel'=33
|
||||
'\\mathring'=34
|
||||
'\\mathrlap'=35
|
||||
'\\mathrm'=36
|
||||
'\\mathscr'=37
|
||||
'\\mathsf'=38
|
||||
'\\mathsterling'=39
|
||||
'\\mathtt'=40
|
||||
'^T'=41
|
||||
'^{T}'=42
|
||||
'^{\\top}'=43
|
||||
'\''=44
|
||||
'\\$'=46
|
||||
'+'=47
|
||||
'-'=48
|
||||
'*'=49
|
||||
'('=51
|
||||
')'=52
|
||||
'\\lgroup'=53
|
||||
'\\rgroup'=54
|
||||
'{'=55
|
||||
'}'=56
|
||||
'\\{'=57
|
||||
'\\}'=58
|
||||
'\\lbrace'=59
|
||||
'\\rbrace'=60
|
||||
'['=61
|
||||
']'=62
|
||||
'\\lbrack'=63
|
||||
'\\rbrack'=64
|
||||
'|'=65
|
||||
'\\lvert'=66
|
||||
'\\rvert'=67
|
||||
'\\vert'=68
|
||||
'\\|'=69
|
||||
'\\lfloor'=70
|
||||
'\\rfloor'=71
|
||||
'\\llcorner'=72
|
||||
'\\lrcorner'=73
|
||||
'\\lceil'=74
|
||||
'\\rceil'=75
|
||||
'\\ulcorner'=76
|
||||
'\\urcorner'=77
|
||||
'\\left'=78
|
||||
'\\right'=79
|
||||
'\\mleft'=80
|
||||
'\\mright'=81
|
||||
'\\lim'=82
|
||||
'\\int'=84
|
||||
'\\sum'=85
|
||||
'\\prod'=86
|
||||
'\\log'=87
|
||||
'\\ln'=88
|
||||
'\\exp'=89
|
||||
'\\sin'=90
|
||||
'\\cos'=91
|
||||
'\\tan'=92
|
||||
'\\csc'=93
|
||||
'\\sec'=94
|
||||
'\\cot'=95
|
||||
'\\arcsin'=96
|
||||
'\\arccos'=97
|
||||
'\\arctan'=98
|
||||
'\\arccsc'=99
|
||||
'\\arcsec'=100
|
||||
'\\arccot'=101
|
||||
'\\sinh'=102
|
||||
'\\cosh'=103
|
||||
'\\tanh'=104
|
||||
'\\arsinh'=105
|
||||
'\\arcosh'=106
|
||||
'\\artanh'=107
|
||||
'\\arcsinh'=108
|
||||
'\\arccosh'=109
|
||||
'\\arctanh'=110
|
||||
'arsinh'=111
|
||||
'arcsinh'=112
|
||||
'arcosh'=113
|
||||
'arccosh'=114
|
||||
'artanh'=115
|
||||
'arctanh'=116
|
||||
'gcd'=117
|
||||
'lcm'=118
|
||||
'floor'=119
|
||||
'ceil'=120
|
||||
'\\sqrt'=121
|
||||
'\\gcd'=122
|
||||
'\\lcm'=123
|
||||
'\\floor'=124
|
||||
'\\ceil'=125
|
||||
'\\max'=126
|
||||
'\\min'=127
|
||||
'\\det'=128
|
||||
'eye'=129
|
||||
'zeros'=130
|
||||
'ones'=131
|
||||
'cols'=132
|
||||
'rows'=133
|
||||
'diag'=134
|
||||
'norm'=135
|
||||
'rank'=136
|
||||
'rref'=138
|
||||
'hstack'=139
|
||||
'vstack'=140
|
||||
'nullspace'=142
|
||||
'\\times'=147
|
||||
'\\cdot'=148
|
||||
'\\div'=149
|
||||
'\\frac'=150
|
||||
'\\choose'=152
|
||||
'\\mod'=153
|
||||
'\\mathit'=154
|
||||
'\\operatorname'=155
|
||||
'matrix'=156
|
||||
'pmatrix'=157
|
||||
'bmatrix'=158
|
||||
'vmatrix'=159
|
||||
'&'=165
|
||||
'\\\\'=166
|
||||
'_'=167
|
||||
'^'=168
|
||||
':'=169
|
||||
';'=170
|
||||
','=171
|
||||
'.'=172
|
||||
'E'=175
|
||||
'\\in'=181
|
||||
'='=182
|
||||
'<'=184
|
||||
'>'=186
|
||||
'!'=189
|
||||
573
evaluation/eval/tools/latex2sympy/gen/PSListener.py
Normal file
573
evaluation/eval/tools/latex2sympy/gen/PSListener.py
Normal file
@@ -0,0 +1,573 @@
|
||||
# Generated from PS.g4 by ANTLR 4.11.1
|
||||
from antlr4 import *
|
||||
|
||||
# This class defines a complete listener for a parse tree produced by PSParser.
|
||||
|
||||
|
||||
class PSListener(ParseTreeListener):
|
||||
|
||||
# Enter a parse tree produced by PSParser#accent_symbol.
|
||||
def enterAccent_symbol(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#accent_symbol.
|
||||
def exitAccent_symbol(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#math.
|
||||
|
||||
def enterMath(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#math.
|
||||
def exitMath(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#transpose.
|
||||
|
||||
def enterTranspose(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#transpose.
|
||||
def exitTranspose(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#transform_atom.
|
||||
|
||||
def enterTransform_atom(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#transform_atom.
|
||||
def exitTransform_atom(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#transform_scale.
|
||||
|
||||
def enterTransform_scale(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#transform_scale.
|
||||
def exitTransform_scale(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#transform_swap.
|
||||
|
||||
def enterTransform_swap(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#transform_swap.
|
||||
def exitTransform_swap(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#transform_assignment.
|
||||
|
||||
def enterTransform_assignment(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#transform_assignment.
|
||||
def exitTransform_assignment(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#elementary_transform.
|
||||
|
||||
def enterElementary_transform(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#elementary_transform.
|
||||
def exitElementary_transform(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#elementary_transforms.
|
||||
|
||||
def enterElementary_transforms(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#elementary_transforms.
|
||||
def exitElementary_transforms(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#matrix.
|
||||
|
||||
def enterMatrix(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#matrix.
|
||||
def exitMatrix(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#det.
|
||||
|
||||
def enterDet(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#det.
|
||||
def exitDet(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#matrix_row.
|
||||
|
||||
def enterMatrix_row(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#matrix_row.
|
||||
def exitMatrix_row(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#relation.
|
||||
|
||||
def enterRelation(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#relation.
|
||||
def exitRelation(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#relation_list.
|
||||
|
||||
def enterRelation_list(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#relation_list.
|
||||
def exitRelation_list(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#relation_list_content.
|
||||
|
||||
def enterRelation_list_content(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#relation_list_content.
|
||||
def exitRelation_list_content(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#equality.
|
||||
|
||||
def enterEquality(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#equality.
|
||||
def exitEquality(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#expr.
|
||||
|
||||
def enterExpr(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#expr.
|
||||
def exitExpr(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#additive.
|
||||
|
||||
def enterAdditive(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#additive.
|
||||
def exitAdditive(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#mp.
|
||||
|
||||
def enterMp(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#mp.
|
||||
def exitMp(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#mp_nofunc.
|
||||
|
||||
def enterMp_nofunc(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#mp_nofunc.
|
||||
def exitMp_nofunc(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#unary.
|
||||
|
||||
def enterUnary(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#unary.
|
||||
def exitUnary(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#unary_nofunc.
|
||||
|
||||
def enterUnary_nofunc(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#unary_nofunc.
|
||||
def exitUnary_nofunc(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#postfix.
|
||||
|
||||
def enterPostfix(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#postfix.
|
||||
def exitPostfix(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#postfix_nofunc.
|
||||
|
||||
def enterPostfix_nofunc(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#postfix_nofunc.
|
||||
def exitPostfix_nofunc(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#postfix_op.
|
||||
|
||||
def enterPostfix_op(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#postfix_op.
|
||||
def exitPostfix_op(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#eval_at.
|
||||
|
||||
def enterEval_at(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#eval_at.
|
||||
def exitEval_at(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#eval_at_sub.
|
||||
|
||||
def enterEval_at_sub(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#eval_at_sub.
|
||||
def exitEval_at_sub(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#eval_at_sup.
|
||||
|
||||
def enterEval_at_sup(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#eval_at_sup.
|
||||
def exitEval_at_sup(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#exp.
|
||||
|
||||
def enterExp(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#exp.
|
||||
def exitExp(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#exp_nofunc.
|
||||
|
||||
def enterExp_nofunc(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#exp_nofunc.
|
||||
def exitExp_nofunc(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#comp.
|
||||
|
||||
def enterComp(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#comp.
|
||||
def exitComp(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#comp_nofunc.
|
||||
|
||||
def enterComp_nofunc(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#comp_nofunc.
|
||||
def exitComp_nofunc(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#group.
|
||||
|
||||
def enterGroup(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#group.
|
||||
def exitGroup(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#norm_group.
|
||||
|
||||
def enterNorm_group(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#norm_group.
|
||||
def exitNorm_group(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#abs_group.
|
||||
|
||||
def enterAbs_group(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#abs_group.
|
||||
def exitAbs_group(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#floor_group.
|
||||
|
||||
def enterFloor_group(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#floor_group.
|
||||
def exitFloor_group(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#ceil_group.
|
||||
|
||||
def enterCeil_group(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#ceil_group.
|
||||
def exitCeil_group(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#accent.
|
||||
|
||||
def enterAccent(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#accent.
|
||||
def exitAccent(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#atom_expr_no_supexpr.
|
||||
|
||||
def enterAtom_expr_no_supexpr(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#atom_expr_no_supexpr.
|
||||
def exitAtom_expr_no_supexpr(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#atom_expr.
|
||||
|
||||
def enterAtom_expr(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#atom_expr.
|
||||
def exitAtom_expr(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#atom.
|
||||
|
||||
def enterAtom(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#atom.
|
||||
def exitAtom(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#mathit.
|
||||
|
||||
def enterMathit(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#mathit.
|
||||
def exitMathit(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#mathit_text.
|
||||
|
||||
def enterMathit_text(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#mathit_text.
|
||||
def exitMathit_text(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#frac.
|
||||
|
||||
def enterFrac(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#frac.
|
||||
def exitFrac(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#binom.
|
||||
|
||||
def enterBinom(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#binom.
|
||||
def exitBinom(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#func_normal_functions_single_arg.
|
||||
|
||||
def enterFunc_normal_functions_single_arg(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#func_normal_functions_single_arg.
|
||||
def exitFunc_normal_functions_single_arg(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#func_normal_functions_multi_arg.
|
||||
|
||||
def enterFunc_normal_functions_multi_arg(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#func_normal_functions_multi_arg.
|
||||
def exitFunc_normal_functions_multi_arg(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#func_operator_names_single_arg.
|
||||
|
||||
def enterFunc_operator_names_single_arg(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#func_operator_names_single_arg.
|
||||
def exitFunc_operator_names_single_arg(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#func_operator_names_multi_arg.
|
||||
|
||||
def enterFunc_operator_names_multi_arg(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#func_operator_names_multi_arg.
|
||||
def exitFunc_operator_names_multi_arg(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#func_normal_single_arg.
|
||||
|
||||
def enterFunc_normal_single_arg(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#func_normal_single_arg.
|
||||
def exitFunc_normal_single_arg(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#func_normal_multi_arg.
|
||||
|
||||
def enterFunc_normal_multi_arg(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#func_normal_multi_arg.
|
||||
def exitFunc_normal_multi_arg(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#func.
|
||||
|
||||
def enterFunc(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#func.
|
||||
def exitFunc(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#args.
|
||||
|
||||
def enterArgs(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#args.
|
||||
def exitArgs(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#func_common_args.
|
||||
|
||||
def enterFunc_common_args(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#func_common_args.
|
||||
def exitFunc_common_args(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#limit_sub.
|
||||
|
||||
def enterLimit_sub(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#limit_sub.
|
||||
def exitLimit_sub(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#func_single_arg.
|
||||
|
||||
def enterFunc_single_arg(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#func_single_arg.
|
||||
def exitFunc_single_arg(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#func_single_arg_noparens.
|
||||
|
||||
def enterFunc_single_arg_noparens(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#func_single_arg_noparens.
|
||||
def exitFunc_single_arg_noparens(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#func_multi_arg.
|
||||
|
||||
def enterFunc_multi_arg(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#func_multi_arg.
|
||||
def exitFunc_multi_arg(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#func_multi_arg_noparens.
|
||||
|
||||
def enterFunc_multi_arg_noparens(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#func_multi_arg_noparens.
|
||||
def exitFunc_multi_arg_noparens(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#subexpr.
|
||||
|
||||
def enterSubexpr(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#subexpr.
|
||||
def exitSubexpr(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#supexpr.
|
||||
|
||||
def enterSupexpr(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#supexpr.
|
||||
def exitSupexpr(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#subeq.
|
||||
|
||||
def enterSubeq(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#subeq.
|
||||
def exitSubeq(self, ctx):
|
||||
pass
|
||||
|
||||
# Enter a parse tree produced by PSParser#supeq.
|
||||
|
||||
def enterSupeq(self, ctx):
|
||||
pass
|
||||
|
||||
# Exit a parse tree produced by PSParser#supeq.
|
||||
def exitSupeq(self, ctx):
|
||||
pass
|
||||
6486
evaluation/eval/tools/latex2sympy/gen/PSParser.py
Normal file
6486
evaluation/eval/tools/latex2sympy/gen/PSParser.py
Normal file
File diff suppressed because it is too large
Load Diff
0
evaluation/eval/tools/latex2sympy/gen/__init__.py
Normal file
0
evaluation/eval/tools/latex2sympy/gen/__init__.py
Normal file
BIN
evaluation/eval/tools/latex2sympy/icon.png
Normal file
BIN
evaluation/eval/tools/latex2sympy/icon.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 12 KiB |
1162
evaluation/eval/tools/latex2sympy/latex2sympy2.py
Normal file
1162
evaluation/eval/tools/latex2sympy/latex2sympy2.py
Normal file
File diff suppressed because it is too large
Load Diff
2
evaluation/eval/tools/latex2sympy/requirements.in
Normal file
2
evaluation/eval/tools/latex2sympy/requirements.in
Normal file
@@ -0,0 +1,2 @@
|
||||
sympy
|
||||
antlr4-python3-runtime
|
||||
12
evaluation/eval/tools/latex2sympy/requirements.txt
Normal file
12
evaluation/eval/tools/latex2sympy/requirements.txt
Normal file
@@ -0,0 +1,12 @@
|
||||
#
|
||||
# This file is autogenerated by pip-compile with Python 3.10
|
||||
# by the following command:
|
||||
#
|
||||
# pip-compile requirements.in
|
||||
#
|
||||
antlr4-python3-runtime==4.11.1
|
||||
# via -r requirements.in
|
||||
mpmath==1.3.0
|
||||
# via sympy
|
||||
sympy==1.12
|
||||
# via -r requirements.in
|
||||
@@ -0,0 +1,10 @@
|
||||
from latex2sympy import process_sympy
|
||||
import sys
|
||||
sys.path.append("..")
|
||||
|
||||
# latex = "2\\begin{pmatrix}1&1&1\\\\0&1&1\\\\0&0&1\\end{pmatrix}\\begin{pmatrix}1&1&1\\\\0&1&1\\\\0&0&1\\end{pmatrix}"
|
||||
latex = "\\frac{a^{2} \\left(3 \\pi - 4 \\sin{\\left(\\pi \\right)} + \\frac{\\sin{\\left(2 \\pi \\right)}}{2}\\right)}{2}"
|
||||
math = process_sympy(latex)
|
||||
|
||||
print(type(math))
|
||||
print("latex: %s to math: %s" % (latex, math))
|
||||
19
evaluation/eval/tools/latex2sympy/sandbox/linalg_span.py
Normal file
19
evaluation/eval/tools/latex2sympy/sandbox/linalg_span.py
Normal file
@@ -0,0 +1,19 @@
|
||||
from latex2sympy import process_sympy
|
||||
import sys
|
||||
sys.path.append("..")
|
||||
|
||||
latex = "\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix}"
|
||||
math = process_sympy(latex)
|
||||
print("latex: %s to math: %s" % (latex, math))
|
||||
|
||||
latex = "\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix},\\begin{pmatrix}4\\\\3\\\\1\\end{pmatrix}"
|
||||
math = process_sympy(latex)
|
||||
print("latex: %s to math: %s" % (latex, math))
|
||||
|
||||
latex = "[\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix},\\begin{pmatrix}4\\\\3\\\\1\\end{pmatrix}]"
|
||||
math = process_sympy(latex)
|
||||
print("latex: %s to math: %s" % (latex, math))
|
||||
|
||||
latex = "\\left\\{\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix},\\begin{pmatrix}4\\\\3\\\\1\\end{pmatrix}\\right\\}"
|
||||
math = process_sympy(latex)
|
||||
print("latex: %s to math: %s" % (latex, math))
|
||||
46
evaluation/eval/tools/latex2sympy/sandbox/matrix.py
Normal file
46
evaluation/eval/tools/latex2sympy/sandbox/matrix.py
Normal file
@@ -0,0 +1,46 @@
|
||||
from latex2sympy import process_sympy
|
||||
from sympy import *
|
||||
import sys
|
||||
sys.path.append("..")
|
||||
|
||||
theta = Symbol('theta', real=True)
|
||||
|
||||
latex = "\\begin{matrix}1&2\\\\3&4\\end{matrix}"
|
||||
math = process_sympy(latex)
|
||||
print("latex: %s to math: %s" % (latex, math))
|
||||
|
||||
latex = "\\begin{matrix}1&2\\\\3&4\\\\5&6\\end{matrix}"
|
||||
math = process_sympy(latex)
|
||||
print("latex: %s to math: %s" % (latex, math))
|
||||
|
||||
latex = "\\begin{matrix}1&2&3\\\\4&5&6\\\\7&8&9\\end{matrix}"
|
||||
math = process_sympy(latex)
|
||||
print("latex: %s to math: %s" % (latex, math))
|
||||
|
||||
latex = "\\begin{matrix}x^1&x^2&x^3\\\\y^1&y^2&y^3\\\\z^1&z^2&z^3\\end{matrix}"
|
||||
math = process_sympy(latex)
|
||||
print("latex: %s to math: %s" % (latex, math))
|
||||
|
||||
latex = "\\begin{matrix}x\\\\y\\end{matrix}"
|
||||
math = process_sympy(latex)
|
||||
print("latex: %s to math: %s" % (latex, math))
|
||||
|
||||
latex = "2\\cdot\\begin{matrix}x\\\\y\\end{matrix}"
|
||||
math = process_sympy(latex)
|
||||
print("latex: %s to math: %s" % (latex, math))
|
||||
|
||||
latex = "2\\cdot\\begin{matrix}x\\\\y\\end{matrix} + \\begin{matrix}2\\\\3\\end{matrix}"
|
||||
math = process_sympy(latex)
|
||||
print("latex: %s to math: %s" % (latex, math))
|
||||
|
||||
latex = "-2\\begin{matrix}1&2\\\\3&4\\end{matrix}"
|
||||
math = process_sympy(latex)
|
||||
print("latex: %s to math: %s" % (latex, math))
|
||||
|
||||
latex = "2\\cdot\\theta\\begin{matrix}x\\\\y\\end{matrix} + \\begin{matrix}2\\\\3\\end{matrix}"
|
||||
math = process_sympy(latex)
|
||||
print("latex: %s to math: %s" % (latex, math))
|
||||
|
||||
latex = "\\theta\\begin{matrix}1\\\\3\\end{matrix} - \\begin{matrix}-1\\\\2\\end{matrix}"
|
||||
math = process_sympy(latex)
|
||||
print("latex: %s to math: %s" % (latex, math))
|
||||
@@ -0,0 +1,65 @@
|
||||
from latex2sympy import process_sympy
|
||||
from sympy import *
|
||||
import sys
|
||||
import hashlib
|
||||
import time
|
||||
|
||||
sys.path.append("..")
|
||||
|
||||
|
||||
M = Matrix([[1, 2], [3, 4]])
|
||||
v = Matrix([1, 2])
|
||||
|
||||
# sub settings
|
||||
sub_settings_symbols = {}
|
||||
sub_settings_symbols[Symbol('M' + hashlib.md5('M'.encode()).hexdigest(), real=True)] = M
|
||||
sub_settings_symbols[Symbol('v' + hashlib.md5('v'.encode()).hexdigest(), real=True)] = v
|
||||
|
||||
|
||||
# one parameters
|
||||
latex = "\\begin{matrix}1&2\\\\3&4\\end{matrix}\\cdot[!v!]"
|
||||
equation_sympy_check = MatMul(M, Symbol('v' + hashlib.md5('v'.encode()).hexdigest(), real=True))
|
||||
equation_sympy_subs_check = MatMul(M, v)
|
||||
# placeholders
|
||||
equation_sympy = process_sympy(latex)
|
||||
print('latex = %s' % latex)
|
||||
print('equation_sympy = %s' % equation_sympy)
|
||||
print('equation_sympy_check = %s' % equation_sympy_check)
|
||||
print('equation_sympy = %s' % (srepr(equation_sympy)))
|
||||
|
||||
equation_sympy_subs = equation_sympy.subs(sub_settings_symbols, evaluate=False)
|
||||
print('equation_sympy_subs = %s' % equation_sympy_subs)
|
||||
print('equation_sympy_subs_check = %s' % equation_sympy_subs_check)
|
||||
|
||||
|
||||
# two parameters
|
||||
|
||||
# sub settings
|
||||
print('')
|
||||
print('============== Two Parameters -> M*v = Matrix*Vector =============')
|
||||
sub_settings_symbols = {}
|
||||
sub_settings_symbols[Symbol('M' + hashlib.md5('M'.encode()).hexdigest(), commutative=False)] = M
|
||||
sub_settings_symbols[Symbol('v' + hashlib.md5('v'.encode()).hexdigest(), commutative=False)] = v
|
||||
|
||||
latex = "[!M!]\\cdot[!v!]"
|
||||
math_check = Mul(Symbol('M' + hashlib.md5('M'.encode()).hexdigest(), commutative=False), Symbol('v' + hashlib.md5('v'.encode()).hexdigest(), commutative=False))
|
||||
# placeholders
|
||||
equation_sympy = process_sympy(latex)
|
||||
print(latex)
|
||||
print(math_check)
|
||||
print(equation_sympy)
|
||||
print(srepr(equation_sympy))
|
||||
|
||||
# performance
|
||||
t0 = time.time()
|
||||
|
||||
# process_sympy and substitute at the same time
|
||||
# Only needed for linalg input
|
||||
placeholder_values = {'M': M, 'v': v}
|
||||
equation_sympy_subs = process_sympy(latex, variable_values=placeholder_values)
|
||||
|
||||
t1 = time.time()
|
||||
print('equation with substituted placeholders = %s' % (str(equation_sympy_subs)))
|
||||
print('time to process to sympy with placeholders = %s s' % (t1 - t0))
|
||||
print('')
|
||||
print('============== Two Parameters -> M*v = Matrix*Vector =============')
|
||||
23
evaluation/eval/tools/latex2sympy/sandbox/sandbox.py
Normal file
23
evaluation/eval/tools/latex2sympy/sandbox/sandbox.py
Normal file
@@ -0,0 +1,23 @@
|
||||
from sympy import *
|
||||
from latex2sympy import process_sympy
|
||||
|
||||
|
||||
# latex = '\\variable{a}^{\\variable{b}}'
|
||||
# variables = {'a': process_sympy('658.95998'), 'b': process_sympy('185083.8060')}
|
||||
# c_ans_expr = process_sympy(latex, variables)
|
||||
# print(c_ans_expr)
|
||||
# print(srepr(c_ans_expr))
|
||||
# c_ans = c_ans_expr.doit(deep=False).evalf(chop=True)
|
||||
# print(c_ans)
|
||||
# print(srepr(c_ans))
|
||||
|
||||
|
||||
# numeric_responses = ['1', '1.0', '-1', '-1.0', '.5', '-.5', '3x10^3', '3E3', '3,000x10^{-3}', '0.5E-1', '\\frac{1}{3}', '(5\\times 3)^3', '\\sin(1)']
|
||||
# for latex in numeric_responses:
|
||||
# parsed = process_sympy(latex)
|
||||
# print('latex: ', latex)
|
||||
# print('sympy: ', parsed)
|
||||
# print('is_number: ', parsed.is_number)
|
||||
# print('is_Number: ', parsed.is_Number)
|
||||
# print('srepr: ', srepr(parsed))
|
||||
# print('-----------------------------------------------------')
|
||||
@@ -0,0 +1,75 @@
|
||||
from sympy import *
|
||||
from latex2sympy import process_sympy
|
||||
|
||||
|
||||
#
|
||||
# Equality Testing
|
||||
#
|
||||
|
||||
answer_sets = [
|
||||
{
|
||||
'correct_answer': '(x-y)(x+2y)',
|
||||
'student_answers': [
|
||||
'x^2+xy-2y^2',
|
||||
'(x-y)(x+2y)',
|
||||
'(x+2y)(x-y)',
|
||||
'(2\\times y+x)(-y+x)',
|
||||
'(y\\cdot 2+x)(-y+x)'
|
||||
]
|
||||
},
|
||||
{
|
||||
'correct_answer': '2\\pi \\variable{r}^2',
|
||||
'student_answers': [
|
||||
'2\\pi \\variable{r}^2',
|
||||
'\\pi 2\\variable{r}^2',
|
||||
'2\\times \\pi \\times \\variable{r}^2',
|
||||
'2\\pi \\variable{r} \\times \\variable{r}'
|
||||
]
|
||||
},
|
||||
{
|
||||
'correct_answer': '2x - 3y',
|
||||
'student_answers': [
|
||||
'-3y + 2x'
|
||||
]
|
||||
},
|
||||
{
|
||||
'correct_answer': 'x\\times x',
|
||||
'student_answers': [
|
||||
'x\\times x',
|
||||
'x\\cdot x',
|
||||
'x^2',
|
||||
'(\\sqrt{x})^{4}'
|
||||
]
|
||||
},
|
||||
{
|
||||
'correct_answer': '23e^{-1\\times \\sqrt{t^2}}',
|
||||
'student_answers': [
|
||||
'23e^{-t}'
|
||||
]
|
||||
},
|
||||
{
|
||||
'correct_answer': 'a=x^2+1',
|
||||
'student_answers': [
|
||||
'x^2+1=a'
|
||||
]
|
||||
}
|
||||
]
|
||||
|
||||
for answer_set in answer_sets:
|
||||
correct_answer = answer_set['correct_answer']
|
||||
correct_answer_parsed = process_sympy(answer_set['correct_answer'])
|
||||
for student_answer in answer_set['student_answers']:
|
||||
student_answer_parsed = process_sympy(student_answer)
|
||||
print('correct_answer (c): ', correct_answer, correct_answer_parsed)
|
||||
print('student_answer (a): ', student_answer, student_answer_parsed)
|
||||
print('')
|
||||
print('Expression Tree (srepr(c) == srepr(a)) =>', srepr(correct_answer_parsed) == srepr(student_answer_parsed))
|
||||
print('srepr(c) =>', srepr(correct_answer_parsed))
|
||||
print('srepr(a) =>', srepr(student_answer_parsed))
|
||||
print('')
|
||||
# print('Structural (c == a) =>', correct_answer_parsed == student_answer_parsed)
|
||||
print('Symbolic (simplify(c - s) == 0) =>', simplify(correct_answer_parsed - student_answer_parsed) == 0)
|
||||
print('simplified =>', simplify(correct_answer_parsed - student_answer_parsed))
|
||||
print('')
|
||||
print('Numeric Substitution (c.equals(s)) =>', correct_answer_parsed.equals(student_answer_parsed))
|
||||
print('-----------------------------------------------------')
|
||||
51
evaluation/eval/tools/latex2sympy/sandbox/sectan.py
Normal file
51
evaluation/eval/tools/latex2sympy/sandbox/sectan.py
Normal file
@@ -0,0 +1,51 @@
|
||||
from sympy import *
|
||||
import sys
|
||||
sys.path.append("..")
|
||||
|
||||
# # x^2\cdot \left(3\cdot \tan \left([!a!]\cdot x+[!c!]\right)+[!a!]\cdot x\left(\sec \left([!a!]\cdot x+[!c!]\right)\right)^2\right)
|
||||
# latex1 = "x^2\\cdot \\left(3\\cdot \\tan \\left(2\\cdot x+5\\right)+2\\cdot x\\left(\\sec \\left(2\\cdot x+5\\right)\\right)^2\\right)"
|
||||
# math1 = process_sympy(latex1)
|
||||
# print("latex: %s to math: %s" %(latex1,math1))
|
||||
#
|
||||
# latex2 = "x^2\\cdot \\left(3\\cdot \\tan \\left(2\\cdot x+5\\right)+2\\cdot x\\left(\\sec \\left(2\\cdot x+5\\right)^2\\right)\\right)"
|
||||
# math2 = process_sympy(latex2)
|
||||
# print("latex: %s to math: %s" %(latex2,math2))
|
||||
#
|
||||
# latex3 = "x^2\\cdot \\left(3\\cdot \\tan \\left(2\\cdot x+5\\right)+2\\cdot x\\left(1+\\tan \\left(2\\cdot x+5\\right)^2\\right)\\right)"
|
||||
# math3 = process_sympy(latex3)
|
||||
# print("latex: %s to math: %s" %(latex3,math3))
|
||||
#
|
||||
# print(simplify(math1 - math2))
|
||||
# print(simplify(math1 - math3))
|
||||
|
||||
#
|
||||
# latex1 = "\\sec^2(2\\cdot x+5)"
|
||||
# math1 = process_sympy(latex1)
|
||||
# print("latex: %s to math: %s" %(latex1,math1))
|
||||
#
|
||||
# latex2 = "1+\\tan^2(2\\cdot x+5)"
|
||||
# math2 = process_sympy(latex2)
|
||||
# print("latex: %s to math: %s" %(latex2,math2))
|
||||
# print(simplify(math1 - math2))
|
||||
|
||||
|
||||
x = Symbol('x', real=True)
|
||||
y = Symbol('y', real=True)
|
||||
|
||||
# BUG: 1 + tan^2(x+1) should be == sec^2(x+1) but isnt
|
||||
lhs = (1 + (tan(x + 1))**2)
|
||||
rhs = (sec(x + 1))**2
|
||||
eq = lhs - rhs
|
||||
print(simplify(lhs))
|
||||
print(simplify(rhs))
|
||||
print(simplify(eq))
|
||||
print(simplify(lhs) == simplify(rhs))
|
||||
|
||||
# 1 + tan^2(x) == sec^2(x) but isnt
|
||||
lhs = (1 + (tan(x))**2)
|
||||
rhs = (sec(x))**2
|
||||
eq = lhs - rhs
|
||||
print(simplify(lhs))
|
||||
print(simplify(rhs))
|
||||
print(simplify(eq))
|
||||
print(simplify(lhs) == simplify(rhs))
|
||||
75
evaluation/eval/tools/latex2sympy/sandbox/vector.py
Normal file
75
evaluation/eval/tools/latex2sympy/sandbox/vector.py
Normal file
@@ -0,0 +1,75 @@
|
||||
import numpy as np
|
||||
from sympy import *
|
||||
import sys
|
||||
sys.path.append("..")
|
||||
|
||||
# row column matrix = vector
|
||||
v = [1, 2, 3]
|
||||
|
||||
# single column matrix = vector
|
||||
m = Matrix([1, 2, 3])
|
||||
print(m[:, 0])
|
||||
|
||||
# a three row and 2 column matrix
|
||||
m = Matrix([[1, 2], [3, 4], [5, 6]])
|
||||
print(m[:, 0])
|
||||
|
||||
# determinant of lin indp system != 0
|
||||
m = Matrix([[1, 1], [1, 2]])
|
||||
print(m.det())
|
||||
|
||||
# determinant of lin dep system = 0
|
||||
m = Matrix([[1, 1], [2, 2]])
|
||||
print(m.det())
|
||||
|
||||
# determinant of lin dep system = 0
|
||||
x = Symbol('x')
|
||||
y = Symbol('y')
|
||||
m = Matrix([[x, y], [x, y]])
|
||||
print(m.det())
|
||||
# Reduced Row-Echelon Form
|
||||
_, ind = m.rref()
|
||||
print(len(ind))
|
||||
|
||||
# determinant of lin dep system != 0
|
||||
m = Matrix([[x, y], [y, x]])
|
||||
print(m.det())
|
||||
# Reduced Row-Echelon Form
|
||||
_, ind = m.rref()
|
||||
print(len(ind))
|
||||
|
||||
# determinant of lin dep system != 0
|
||||
# Reduced Row-Echelon Form
|
||||
m = Matrix([[x, x, y], [y, y, y]])
|
||||
_, ind = m.rref()
|
||||
# Reduced Row-Echelon Form
|
||||
print(len(ind))
|
||||
|
||||
#==================#
|
||||
#===== Numpy ======#
|
||||
#==================#
|
||||
# http://kitchingroup.cheme.cmu.edu/blog/2013/03/01/Determining-linear-independence-of-a-set-of-vectors/
|
||||
# Lin Indp of set of numerical vectors
|
||||
TOLERANCE = 1e-14
|
||||
v1 = [6, 0, 3, 1, 4, 2]
|
||||
v2 = [0, -1, 2, 7, 0, 5]
|
||||
v3 = [12, 3, 0, -19, 8, -11]
|
||||
|
||||
A = np.row_stack([v1, v2, v3])
|
||||
|
||||
U, s, V = np.linalg.svd(A)
|
||||
print(s)
|
||||
print(np.sum(s > TOLERANCE))
|
||||
|
||||
v1 = [1, 1]
|
||||
v2 = [4, 4]
|
||||
|
||||
A = np.row_stack([v1, v2])
|
||||
U, s, V = np.linalg.svd(A)
|
||||
print(s)
|
||||
print(np.sum(s > TOLERANCE))
|
||||
|
||||
|
||||
latex = "\\begin{matrix}1&2\\\\3&4\\end{matrix}"
|
||||
# math = process_sympy(latex)
|
||||
print("latex: %s to math: %s" % (latex, 1))
|
||||
9
evaluation/eval/tools/latex2sympy/scripts/compile.sh
Normal file
9
evaluation/eval/tools/latex2sympy/scripts/compile.sh
Normal file
@@ -0,0 +1,9 @@
|
||||
#!/bin/sh
|
||||
|
||||
# Get relative path of the root directory of the project
|
||||
rdir=`git rev-parse --git-dir`
|
||||
rel_path="$(dirname "$rdir")"
|
||||
# Change to that path and run the file
|
||||
cd $rel_path
|
||||
|
||||
java -jar antlr-4.11.1-complete.jar PS.g4 -o gen
|
||||
3
evaluation/eval/tools/latex2sympy/scripts/coverage-ci.sh
Normal file
3
evaluation/eval/tools/latex2sympy/scripts/coverage-ci.sh
Normal file
@@ -0,0 +1,3 @@
|
||||
#!/bin/sh
|
||||
|
||||
pytest --doctest-modules --junitxml=junit/test-results.xml --cov-report=xml --cov-config=.coveragerc --cov=latex2sympy tests
|
||||
23
evaluation/eval/tools/latex2sympy/scripts/coverage.sh
Normal file
23
evaluation/eval/tools/latex2sympy/scripts/coverage.sh
Normal file
@@ -0,0 +1,23 @@
|
||||
#!/bin/sh
|
||||
|
||||
# Get relative path of the root directory of the project
|
||||
rdir=`git rev-parse --git-dir`
|
||||
rel_path="$(dirname "$rdir")"
|
||||
# Change to that path and run the file
|
||||
cd $rel_path
|
||||
|
||||
# Activate virtual environment
|
||||
echo "activating venv..."
|
||||
if test -f .env/bin/activate
|
||||
then source .env/bin/activate && echo "venv activate (bin)"
|
||||
elif test -f .env/Scripts/activate
|
||||
then source .env/Scripts/activate && echo "venv activated (Scripts)"
|
||||
else exit 1
|
||||
fi
|
||||
|
||||
# Run unit test coverage
|
||||
echo "starting coverage..."
|
||||
if pytest --doctest-modules --cov-report=html --cov-config=.coveragerc --cov=latex2sympy tests
|
||||
then echo "coverage finished"
|
||||
else exit 1
|
||||
fi
|
||||
28
evaluation/eval/tools/latex2sympy/scripts/pre-commit
Normal file
28
evaluation/eval/tools/latex2sympy/scripts/pre-commit
Normal file
@@ -0,0 +1,28 @@
|
||||
#!/bin/sh
|
||||
|
||||
# Get relative path of the root directory of the project
|
||||
rdir=`git rev-parse --git-dir`
|
||||
rel_path="$(dirname "$rdir")"
|
||||
|
||||
# Change to that path and run the file
|
||||
cd $rel_path
|
||||
|
||||
echo "pre-commit hook started..."
|
||||
|
||||
# Activate virtual environment
|
||||
echo "activating venv..."
|
||||
if test -f .env/bin/activate
|
||||
then source .env/bin/activate && echo "venv activated."
|
||||
elif test -f .env/Scripts/activate
|
||||
then source .env/Scripts/activate && echo "venv activated."
|
||||
else exit 1
|
||||
fi
|
||||
|
||||
# Run auto formatting on all staged python files, then add those changes
|
||||
echo "auto-formatting code..."
|
||||
if autopep8 --in-place `git diff --name-status --cached | grep '.py' | awk 'match($1, "A|M"){print $2}'` && git add `git diff --name-status --cached | grep '.py' | awk 'match($1, "A|M"){print $2}'`
|
||||
then echo "code was auto-formatted."
|
||||
else echo "no code was auto-formatted."
|
||||
fi
|
||||
|
||||
exit 0
|
||||
28
evaluation/eval/tools/latex2sympy/scripts/pre-push
Normal file
28
evaluation/eval/tools/latex2sympy/scripts/pre-push
Normal file
@@ -0,0 +1,28 @@
|
||||
#!/bin/sh
|
||||
|
||||
# Get relative path of the root directory of the project
|
||||
rdir=`git rev-parse --git-dir`
|
||||
rel_path="$(dirname "$rdir")"
|
||||
|
||||
# Change to that path and run the file
|
||||
cd $rel_path
|
||||
|
||||
echo "pre-push hook started..."
|
||||
|
||||
# Activate virtual environment
|
||||
echo "activating venv..."
|
||||
if test -f .env/bin/activate
|
||||
then source .env/bin/activate && echo "venv activated."
|
||||
elif test -f .env/Scripts/activate
|
||||
then source .env/Scripts/activate && echo "venv activated."
|
||||
else exit 1
|
||||
fi
|
||||
|
||||
# Run unit tests
|
||||
echo "starting tests..."
|
||||
# if pytest tests
|
||||
# then echo "tests finished."
|
||||
# else exit 1
|
||||
# fi
|
||||
|
||||
exit 0
|
||||
3
evaluation/eval/tools/latex2sympy/scripts/publish.sh
Normal file
3
evaluation/eval/tools/latex2sympy/scripts/publish.sh
Normal file
@@ -0,0 +1,3 @@
|
||||
rm ./dist/*
|
||||
python3 setup.py bdist_wheel
|
||||
twine upload dist/*
|
||||
3
evaluation/eval/tools/latex2sympy/scripts/setup-hooks.sh
Normal file
3
evaluation/eval/tools/latex2sympy/scripts/setup-hooks.sh
Normal file
@@ -0,0 +1,3 @@
|
||||
#!/bin/sh
|
||||
cp scripts/pre-push .git/hooks/
|
||||
cp scripts/pre-commit .git/hooks/
|
||||
42
evaluation/eval/tools/latex2sympy/scripts/setup.sh
Normal file
42
evaluation/eval/tools/latex2sympy/scripts/setup.sh
Normal file
@@ -0,0 +1,42 @@
|
||||
#!/bin/sh
|
||||
|
||||
# Get relative path of the root directory of the project
|
||||
rdir=`git rev-parse --git-dir`
|
||||
rel_path="$(dirname "$rdir")"
|
||||
# Change to that path and run the file
|
||||
cd $rel_path
|
||||
|
||||
echo "creating venv..."
|
||||
if test -d .env
|
||||
then echo "venv exists"
|
||||
else python3 -m venv .env && echo "venv created"
|
||||
fi
|
||||
|
||||
echo ''
|
||||
# Activate virtual environment
|
||||
echo "activating venv..."
|
||||
if test -f .env/bin/activate
|
||||
then source .env/bin/activate && echo "venv activate (bin)"
|
||||
elif test -f .env/Scripts/activate
|
||||
then source .env/Scripts/activate && echo "venv activated (Scripts)"
|
||||
else exit 1
|
||||
fi
|
||||
|
||||
echo ''
|
||||
echo "installing requirements..."
|
||||
if pip install -r dev-requirements.txt
|
||||
then echo "requirements installed"
|
||||
else exit 1
|
||||
fi
|
||||
|
||||
echo ''
|
||||
echo "compiling parser..."
|
||||
sh scripts/compile.sh
|
||||
echo "parser compiled"
|
||||
|
||||
echo ''
|
||||
echo "setup git hooks..."
|
||||
sh scripts/setup-hooks.sh
|
||||
echo "git hooks setup"
|
||||
|
||||
exit 0
|
||||
31
evaluation/eval/tools/latex2sympy/scripts/test.sh
Normal file
31
evaluation/eval/tools/latex2sympy/scripts/test.sh
Normal file
@@ -0,0 +1,31 @@
|
||||
#!/bin/sh
|
||||
|
||||
# Get relative path of the root directory of the project
|
||||
rdir=`git rev-parse --git-dir`
|
||||
rel_path="$(dirname "$rdir")"
|
||||
# Change to that path and run the file
|
||||
cd $rel_path
|
||||
|
||||
# Activate virtual environment
|
||||
echo "activating venv..."
|
||||
if test -f .env/bin/activate
|
||||
then source .env/bin/activate && echo "venv activate (bin)"
|
||||
elif test -f .env/Scripts/activate
|
||||
then source .env/Scripts/activate && echo "venv activated (Scripts)"
|
||||
else exit 1
|
||||
fi
|
||||
|
||||
echo ''
|
||||
echo "compiling parser..."
|
||||
sh scripts/compile.sh
|
||||
echo "parser compiled"
|
||||
|
||||
echo ''
|
||||
# Run unit tests
|
||||
echo "starting tests..."
|
||||
if pytest tests
|
||||
then echo "tests finished"
|
||||
else exit 1
|
||||
fi
|
||||
|
||||
exit 0
|
||||
3
evaluation/eval/tools/latex2sympy/setup.cfg
Normal file
3
evaluation/eval/tools/latex2sympy/setup.cfg
Normal file
@@ -0,0 +1,3 @@
|
||||
[pycodestyle]
|
||||
max-line-length = 120
|
||||
ignore = E501
|
||||
45
evaluation/eval/tools/latex2sympy/setup.py
Normal file
45
evaluation/eval/tools/latex2sympy/setup.py
Normal file
@@ -0,0 +1,45 @@
|
||||
from setuptools import setup, find_packages
|
||||
from codecs import open
|
||||
from os import path
|
||||
here = path.abspath(path.dirname(__file__))
|
||||
|
||||
|
||||
setup(
|
||||
name="latex2sympy2",
|
||||
version="1.9.0",
|
||||
description='Convert latex to sympy with ANTLR and support Matrix, Linear Algebra and CAS functions.',
|
||||
long_description_content_type='text/markdown',
|
||||
long_description=open(path.join(here, "README.md"), encoding='utf-8').read(),
|
||||
# The project's main homepage.
|
||||
url='https://github.com/ZubinGou/latex2sympy',
|
||||
# Author details
|
||||
author='ZubinGou',
|
||||
author_email='zebgou@gmail.com',
|
||||
# Choose your license
|
||||
license='MIT',
|
||||
classifiers=[
|
||||
'Development Status :: 4 - Beta',
|
||||
'Intended Audience :: Developers',
|
||||
'Intended Audience :: Education',
|
||||
'Intended Audience :: Science/Research',
|
||||
'License :: OSI Approved :: MIT License',
|
||||
'Topic :: Education',
|
||||
'Topic :: Scientific/Engineering :: Mathematics',
|
||||
'Topic :: Software Development :: Compilers',
|
||||
'Topic :: Text Processing :: Markup :: LaTeX',
|
||||
'Topic :: Text Processing :: Markup :: Markdown',
|
||||
'Programming Language :: Python :: 3',
|
||||
'Programming Language :: Python :: 3.3',
|
||||
'Programming Language :: Python :: 3.4',
|
||||
'Programming Language :: Python :: 3.5',
|
||||
'Programming Language :: Python :: 3.6',
|
||||
'Programming Language :: Python :: 3.7',
|
||||
'Programming Language :: Python :: 3.8',
|
||||
],
|
||||
packages=find_packages(exclude=('tests')),
|
||||
py_modules=['asciimath_printer', 'latex2sympy2'],
|
||||
install_requires=[
|
||||
'sympy>=1.4',
|
||||
'antlr4-python3-runtime==4.11.1'
|
||||
],
|
||||
)
|
||||
0
evaluation/eval/tools/latex2sympy/tests/__init__.py
Normal file
0
evaluation/eval/tools/latex2sympy/tests/__init__.py
Normal file
19
evaluation/eval/tools/latex2sympy/tests/abs_test.py
Normal file
19
evaluation/eval/tools/latex2sympy/tests/abs_test.py
Normal file
@@ -0,0 +1,19 @@
|
||||
from .context import assert_equal, get_simple_examples
|
||||
import pytest
|
||||
from sympy import Abs
|
||||
|
||||
examples = get_simple_examples(Abs)
|
||||
|
||||
delimiter_pairs = {
|
||||
'|': '|',
|
||||
'\\vert': '\\vert',
|
||||
'\\lvert': '\\rvert'
|
||||
}
|
||||
|
||||
|
||||
@pytest.mark.parametrize('input, output, symbolically', examples)
|
||||
def test_abs(input, output, symbolically):
|
||||
for left, right in delimiter_pairs.items():
|
||||
assert_equal("{left}{input}{right}".format(left=left, right=right, input=input), output, symbolically=symbolically)
|
||||
assert_equal("\\left{left}{input}\\right{right}".format(left=left, right=right, input=input), output, symbolically=symbolically)
|
||||
assert_equal("\\mleft{left}{input}\\mright{right}".format(left=left, right=right, input=input), output, symbolically=symbolically)
|
||||
70
evaluation/eval/tools/latex2sympy/tests/all_bad_test.py
Normal file
70
evaluation/eval/tools/latex2sympy/tests/all_bad_test.py
Normal file
@@ -0,0 +1,70 @@
|
||||
from .context import assert_equal, process_sympy
|
||||
import pytest
|
||||
|
||||
|
||||
def pytest_generate_tests(metafunc):
|
||||
metafunc.parametrize('s', metafunc.cls.BAD_STRINGS)
|
||||
|
||||
|
||||
class TestAllBad(object):
|
||||
# These bad latex strings should raise an exception when parsed
|
||||
BAD_STRINGS = [
|
||||
"(",
|
||||
")",
|
||||
# "a / b /",
|
||||
"\\frac{d}{dx}",
|
||||
"(\\frac{d}{dx})"
|
||||
"\\sqrt{}",
|
||||
"\\sqrt",
|
||||
"{",
|
||||
"}",
|
||||
# "1.1.1",
|
||||
"\\mathit{TEST}"
|
||||
"\\frac{2}{}",
|
||||
"\\frac{}{2}",
|
||||
"\\int",
|
||||
# "1 +",
|
||||
# "a +",
|
||||
"!",
|
||||
"!0",
|
||||
"_",
|
||||
"^",
|
||||
# "a // b",
|
||||
# "a \\cdot \\cdot b",
|
||||
# "a \\div \\div b",
|
||||
"a\\mod \\begin{matrix}b\\end{matrix}"
|
||||
"|",
|
||||
"||x|",
|
||||
"\\lfloor x",
|
||||
"\\lfloor a \\rceil",
|
||||
"\\operatorname{floor}(12.3, 123.4)",
|
||||
"()",
|
||||
"((((((((((((((((()))))))))))))))))",
|
||||
"-",
|
||||
"\\frac{d}{dx} + \\frac{d}{dt}",
|
||||
# "f()",
|
||||
# "f(,",
|
||||
# "f(x,,y)",
|
||||
# "f(x,y,",
|
||||
"\\sin^x",
|
||||
"\\cos^2",
|
||||
# "\\cos 1 \\cos",
|
||||
# "\\gcd(3)",
|
||||
# "\\lcm(2)",
|
||||
"@", "#", "$", "%", "&", "*",
|
||||
"\\",
|
||||
"~",
|
||||
"\\frac{(2 + x}{1 - x)}",
|
||||
"\\lim_{\\pi \\to 3} a",
|
||||
# because mix of COMMA and SEMICOLON
|
||||
"\\left\\{\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix},\\begin{pmatrix}4\\\\3\\\\1\\end{pmatrix};\\begin{pmatrix}1\\\\1\\\\1\\end{pmatrix}\\right\\}",
|
||||
# percentages without numbers before-hand
|
||||
"a\\%",
|
||||
"\\%100",
|
||||
# dollar signs without numbers after
|
||||
"\\$"
|
||||
]
|
||||
|
||||
def test_bad_string(self, s):
|
||||
with pytest.raises(Exception):
|
||||
process_sympy(s)
|
||||
284
evaluation/eval/tools/latex2sympy/tests/all_good_test.py
Normal file
284
evaluation/eval/tools/latex2sympy/tests/all_good_test.py
Normal file
@@ -0,0 +1,284 @@
|
||||
from .context import assert_equal, process_sympy, _Add, _Mul, _Pow
|
||||
import pytest
|
||||
import hashlib
|
||||
from sympy import (
|
||||
E, I, oo, pi, sqrt, root, Symbol, Add, Mul, Pow, Abs, factorial, log, Eq, Ne, S, Rational, Integer, UnevaluatedExpr,
|
||||
sin, cos, tan, sinh, cosh, tanh, asin, acos, atan, asinh, acosh, atanh,
|
||||
csc, sec, Sum, Product, Limit, Integral, Derivative,
|
||||
LessThan, StrictLessThan, GreaterThan, StrictGreaterThan,
|
||||
exp, binomial, Matrix, MatMul, MatAdd,
|
||||
Mod, gcd, lcm, floor, ceiling, Max, Min
|
||||
)
|
||||
|
||||
x = Symbol('x', real=True)
|
||||
y = Symbol('y', real=True)
|
||||
z = Symbol('z', real=True)
|
||||
a = Symbol('a', real=True)
|
||||
b = Symbol('b', real=True)
|
||||
c = Symbol('c', real=True)
|
||||
f = Symbol('f', real=True)
|
||||
t = Symbol('t', real=True)
|
||||
k = Symbol('k', real=True)
|
||||
n = Symbol('n', real=True)
|
||||
theta = Symbol('theta', real=True)
|
||||
|
||||
# shorthand definitions
|
||||
|
||||
|
||||
def _Abs(a):
|
||||
return Abs(a, evaluate=False)
|
||||
|
||||
|
||||
def _factorial(a):
|
||||
return factorial(a, evaluate=False)
|
||||
|
||||
|
||||
def _log(a, b):
|
||||
return log(a, b, evaluate=False)
|
||||
|
||||
|
||||
def pytest_generate_tests(metafunc):
|
||||
metafunc.parametrize('s, eq', metafunc.cls.GOOD_PAIRS)
|
||||
|
||||
|
||||
class TestAllGood(object):
|
||||
# These latex strings should parse to the corresponding SymPy expression
|
||||
GOOD_PAIRS = [
|
||||
("0", 0),
|
||||
("1", 1),
|
||||
("-3.14", -3.14),
|
||||
("5-3", _Add(5, -3)),
|
||||
("(-7.13)(1.5)", _Mul(Rational('-7.13'), Rational('1.5'))),
|
||||
("\\left(-7.13\\right)\\left(1.5\\right)", _Mul(Rational('-7.13'), Rational('1.5'))),
|
||||
("x", x),
|
||||
("2x", 2 * x),
|
||||
("x^2", x**2),
|
||||
("x^{3 + 1}", x**_Add(3, 1)),
|
||||
("x^{\\left\\{3 + 1\\right\\}}", x**_Add(3, 1)),
|
||||
("-3y + 2x", _Add(_Mul(2, x), Mul(-1, 3, y, evaluate=False))),
|
||||
("-c", -c),
|
||||
("a \\cdot b", a * b),
|
||||
("a / b", a / b),
|
||||
("a \\div b", a / b),
|
||||
("a + b", a + b),
|
||||
("a + b - a", Add(a, b, _Mul(-1, a), evaluate=False)),
|
||||
("a^2 + b^2 = c^2", Eq(a**2 + b**2, c**2)),
|
||||
("a^2 + b^2 != 2c^2", Ne(a**2 + b**2, 2 * c**2)),
|
||||
("a\\mod b", Mod(a, b)),
|
||||
("\\sin \\theta", sin(theta)),
|
||||
("\\sin(\\theta)", sin(theta)),
|
||||
("\\sin\\left(\\theta\\right)", sin(theta)),
|
||||
("\\sin^{-1} a", asin(a)),
|
||||
("\\sin a \\cos b", _Mul(sin(a), cos(b))),
|
||||
("\\sin \\cos \\theta", sin(cos(theta))),
|
||||
("\\sin(\\cos \\theta)", sin(cos(theta))),
|
||||
("\\arcsin(a)", asin(a)),
|
||||
("\\arccos(a)", acos(a)),
|
||||
("\\arctan(a)", atan(a)),
|
||||
("\\sinh(a)", sinh(a)),
|
||||
("\\cosh(a)", cosh(a)),
|
||||
("\\tanh(a)", tanh(a)),
|
||||
("\\sinh^{-1}(a)", asinh(a)),
|
||||
("\\cosh^{-1}(a)", acosh(a)),
|
||||
("\\tanh^{-1}(a)", atanh(a)),
|
||||
("\\arcsinh(a)", asinh(a)),
|
||||
("\\arccosh(a)", acosh(a)),
|
||||
("\\arctanh(a)", atanh(a)),
|
||||
("\\arsinh(a)", asinh(a)),
|
||||
("\\arcosh(a)", acosh(a)),
|
||||
("\\artanh(a)", atanh(a)),
|
||||
("\\operatorname{arcsinh}(a)", asinh(a)),
|
||||
("\\operatorname{arccosh}(a)", acosh(a)),
|
||||
("\\operatorname{arctanh}(a)", atanh(a)),
|
||||
("\\operatorname{arsinh}(a)", asinh(a)),
|
||||
("\\operatorname{arcosh}(a)", acosh(a)),
|
||||
("\\operatorname{artanh}(a)", atanh(a)),
|
||||
("\\operatorname{gcd}(a, b)", UnevaluatedExpr(gcd(a, b))),
|
||||
("\\operatorname{lcm}(a, b)", UnevaluatedExpr(lcm(a, b))),
|
||||
("\\operatorname{gcd}(a,b)", UnevaluatedExpr(gcd(a, b))),
|
||||
("\\operatorname{lcm}(a,b)", UnevaluatedExpr(lcm(a, b))),
|
||||
("\\operatorname{floor}(a)", floor(a)),
|
||||
("\\operatorname{ceil}(b)", ceiling(b)),
|
||||
("\\cos^2(x)", cos(x)**2),
|
||||
("\\cos(x)^2", cos(x)**2),
|
||||
("\\gcd(a, b)", UnevaluatedExpr(gcd(a, b))),
|
||||
("\\lcm(a, b)", UnevaluatedExpr(lcm(a, b))),
|
||||
("\\gcd(a,b)", UnevaluatedExpr(gcd(a, b))),
|
||||
("\\lcm(a,b)", UnevaluatedExpr(lcm(a, b))),
|
||||
("\\floor(a)", floor(a)),
|
||||
("\\ceil(b)", ceiling(b)),
|
||||
("\\max(a, b)", Max(a, b)),
|
||||
("\\min(a, b)", Min(a, b)),
|
||||
("\\frac{a}{b}", a / b),
|
||||
("\\frac{a + b}{c}", _Mul(a + b, _Pow(c, -1))),
|
||||
("\\frac{7}{3}", _Mul(7, _Pow(3, -1))),
|
||||
("(\\csc x)(\\sec y)", csc(x) * sec(y)),
|
||||
("\\lim_{x \\to 3} a", Limit(a, x, 3)),
|
||||
("\\lim_{x \\rightarrow 3} a", Limit(a, x, 3)),
|
||||
("\\lim_{x \\Rightarrow 3} a", Limit(a, x, 3)),
|
||||
("\\lim_{x \\longrightarrow 3} a", Limit(a, x, 3)),
|
||||
("\\lim_{x \\Longrightarrow 3} a", Limit(a, x, 3)),
|
||||
("\\lim_{x \\to 3^{+}} a", Limit(a, x, 3, dir='+')),
|
||||
("\\lim_{x \\to 3^{-}} a", Limit(a, x, 3, dir='-')),
|
||||
("\\infty", oo),
|
||||
("\\infty\\%", oo),
|
||||
("\\$\\infty", oo),
|
||||
("-\\infty", -oo),
|
||||
("-\\infty\\%", -oo),
|
||||
("-\\$\\infty", -oo),
|
||||
("\\lim_{x \\to \\infty} \\frac{1}{x}", Limit(_Mul(1, _Pow(x, -1)), x, oo)),
|
||||
("\\frac{d}{dx} x", Derivative(x, x)),
|
||||
("\\frac{d}{dt} x", Derivative(x, t)),
|
||||
# ("f(x)", f(x)),
|
||||
# ("f(x, y)", f(x, y)),
|
||||
# ("f(x, y, z)", f(x, y, z)),
|
||||
# ("\\frac{d f(x)}{dx}", Derivative(f(x), x)),
|
||||
# ("\\frac{d\\theta(x)}{dx}", Derivative(theta(x), x)),
|
||||
("|x|", _Abs(x)),
|
||||
("\\left|x\\right|", _Abs(x)),
|
||||
("||x||", _Abs(Abs(x))),
|
||||
("|x||y|", _Abs(x) * _Abs(y)),
|
||||
("||x||y||", _Abs(_Abs(x) * _Abs(y))),
|
||||
("\\lfloor x\\rfloor", floor(x)),
|
||||
("\\lceil y\\rceil", ceiling(y)),
|
||||
("\\pi^{|xy|}", pi**_Abs(x * y)),
|
||||
("\\frac{\\pi}{3}", _Mul(pi, _Pow(3, -1))),
|
||||
("\\sin{\\frac{\\pi}{2}}", sin(_Mul(pi, _Pow(2, -1)), evaluate=False)),
|
||||
("a+bI", a + I * b),
|
||||
("e^{I\\pi}", -1),
|
||||
("\\int x dx", Integral(x, x)),
|
||||
("\\int x d\\theta", Integral(x, theta)),
|
||||
("\\int (x^2 - y)dx", Integral(x**2 - y, x)),
|
||||
("\\int x + a dx", Integral(_Add(x, a), x)),
|
||||
("\\int da", Integral(1, a)),
|
||||
("\\int_0^7 dx", Integral(1, (x, 0, 7))),
|
||||
("\\int_a^b x dx", Integral(x, (x, a, b))),
|
||||
("\\int^b_a x dx", Integral(x, (x, a, b))),
|
||||
("\\int_{a}^b x dx", Integral(x, (x, a, b))),
|
||||
("\\int^{b}_a x dx", Integral(x, (x, a, b))),
|
||||
("\\int_{a}^{b} x dx", Integral(x, (x, a, b))),
|
||||
("\\int_{ }^{}x dx", Integral(x, x)),
|
||||
("\\int^{ }_{ }x dx", Integral(x, x)),
|
||||
("\\int^{b}_{a} x dx", Integral(x, (x, a, b))),
|
||||
# ("\\int_{f(a)}^{f(b)} f(z) dz", Integral(f(z), (z, f(a), f(b)))),
|
||||
("\\int (x+a)", Integral(_Add(x, a), x)),
|
||||
("\\int a + b + c dx", Integral(Add(a, b, c, evaluate=False), x)),
|
||||
("\\int \\frac{dz}{z}", Integral(Pow(z, -1), z)),
|
||||
("\\int \\frac{3 dz}{z}", Integral(3 * Pow(z, -1), z)),
|
||||
("\\int \\frac{1}{x} dx", Integral(Pow(x, -1), x)),
|
||||
("\\int \\frac{1}{a} + \\frac{1}{b} dx", Integral(_Add(_Pow(a, -1), Pow(b, -1)), x)),
|
||||
("\\int \\frac{3 \\cdot d\\theta}{\\theta}", Integral(3 * _Pow(theta, -1), theta)),
|
||||
("\\int \\frac{1}{x} + 1 dx", Integral(_Add(_Pow(x, -1), 1), x)),
|
||||
("x_0", Symbol('x_0', real=True)),
|
||||
("x_{1}", Symbol('x_1', real=True)),
|
||||
("x_a", Symbol('x_a', real=True)),
|
||||
("x_{b}", Symbol('x_b', real=True)),
|
||||
("h_\\theta", Symbol('h_{\\theta}', real=True)),
|
||||
("h_\\theta ", Symbol('h_{\\theta}', real=True)),
|
||||
("h_{\\theta}", Symbol('h_{\\theta}', real=True)),
|
||||
# ("h_{\\theta}(x_0, x_1)", Symbol('h_{theta}', real=True)(Symbol('x_{0}', real=True), Symbol('x_{1}', real=True))),
|
||||
("x!", _factorial(x)),
|
||||
("100!", _factorial(100)),
|
||||
("\\theta!", _factorial(theta)),
|
||||
("(x + 1)!", _factorial(_Add(x, 1))),
|
||||
("\\left(x + 1\\right)!", _factorial(_Add(x, 1))),
|
||||
("(x!)!", _factorial(_factorial(x))),
|
||||
("x!!!", _factorial(_factorial(_factorial(x)))),
|
||||
("5!7!", _Mul(_factorial(5), _factorial(7))),
|
||||
("\\sqrt{x}", sqrt(x)),
|
||||
("\\sqrt{x + b}", sqrt(_Add(x, b))),
|
||||
("\\sqrt[3]{\\sin x}", root(sin(x), 3)),
|
||||
("\\sqrt[y]{\\sin x}", root(sin(x), y)),
|
||||
("\\sqrt[\\theta]{\\sin x}", root(sin(x), theta)),
|
||||
("x < y", StrictLessThan(x, y)),
|
||||
("x \\leq y", LessThan(x, y)),
|
||||
("x > y", StrictGreaterThan(x, y)),
|
||||
("x \\geq y", GreaterThan(x, y)),
|
||||
("\\sum_{k = 1}^{3} c", Sum(c, (k, 1, 3))),
|
||||
("\\sum_{k = 1}^3 c", Sum(c, (k, 1, 3))),
|
||||
("\\sum^{3}_{k = 1} c", Sum(c, (k, 1, 3))),
|
||||
("\\sum^3_{k = 1} c", Sum(c, (k, 1, 3))),
|
||||
("\\sum_{k = 1}^{10} k^2", Sum(k**2, (k, 1, 10))),
|
||||
("\\sum_{n = 0}^{\\infty} \\frac{1}{n!}", Sum(_Pow(_factorial(n), -1), (n, 0, oo))),
|
||||
("\\prod_{a = b}^{c} x", Product(x, (a, b, c))),
|
||||
("\\prod_{a = b}^c x", Product(x, (a, b, c))),
|
||||
("\\prod^{c}_{a = b} x", Product(x, (a, b, c))),
|
||||
("\\prod^c_{a = b} x", Product(x, (a, b, c))),
|
||||
("\\ln x", _log(x, E)),
|
||||
("\\ln xy", _log(x * y, E)),
|
||||
("\\log x", _log(x, 10)),
|
||||
("\\log xy", _log(x * y, 10)),
|
||||
# ("\\log_2 x", _log(x, 2)),
|
||||
("\\log_{2} x", _log(x, 2)),
|
||||
# ("\\log_a x", _log(x, a)),
|
||||
("\\log_{a} x", _log(x, a)),
|
||||
("\\log_{11} x", _log(x, 11)),
|
||||
("\\log_{a^2} x", _log(x, _Pow(a, 2))),
|
||||
("[x]", x),
|
||||
("[a + b]", _Add(a, b)),
|
||||
("\\frac{d}{dx} [ \\tan x ]", Derivative(tan(x), x)),
|
||||
("2\\overline{x}", 2 * Symbol('xbar', real=True)),
|
||||
("2\\overline{x}_n", 2 * Symbol('xbar_n', real=True)),
|
||||
("\\frac{x}{\\overline{x}_n}", x / Symbol('xbar_n', real=True)),
|
||||
("\\frac{\\sin(x)}{\\overline{x}_n}", sin(Symbol('x', real=True)) / Symbol('xbar_n', real=True)),
|
||||
("2\\bar{x}", 2 * Symbol('xbar', real=True)),
|
||||
("2\\bar{x}_n", 2 * Symbol('xbar_n', real=True)),
|
||||
("\\sin\\left(\\theta\\right) \\cdot4", sin(theta) * 4),
|
||||
("\\ln\\left(\\theta\\right)", _log(theta, E)),
|
||||
("\\ln\\left(x-\\theta\\right)", _log(x - theta, E)),
|
||||
("\\ln\\left(\\left(x-\\theta\\right)\\right)", _log(x - theta, E)),
|
||||
("\\ln\\left(\\left[x-\\theta\\right]\\right)", _log(x - theta, E)),
|
||||
("\\ln\\left(\\left\\{x-\\theta\\right\\}\\right)", _log(x - theta, E)),
|
||||
("\\ln\\left(\\left|x-\\theta\\right|\\right)", _log(_Abs(x - theta), E)),
|
||||
("\\frac{1}{2}xy(x+y)", Mul(_Pow(2, -1), x, y, (x + y), evaluate=False)),
|
||||
("\\frac{1}{2}\\theta(x+y)", Mul(_Pow(2, -1), theta, (x + y), evaluate=False)),
|
||||
("1-f(x)", 1 - f * x),
|
||||
|
||||
("\\begin{matrix}1&2\\\\3&4\\end{matrix}", Matrix([[1, 2], [3, 4]])),
|
||||
("\\begin{matrix}x&x^2\\\\\\sqrt{x}&x\\end{matrix}", Matrix([[x, x**2], [_Pow(x, S.Half), x]])),
|
||||
("\\begin{matrix}\\sqrt{x}\\\\\\sin(\\theta)\\end{matrix}", Matrix([_Pow(x, S.Half), sin(theta)])),
|
||||
("\\begin{pmatrix}1&2\\\\3&4\\end{pmatrix}", Matrix([[1, 2], [3, 4]])),
|
||||
("\\begin{bmatrix}1&2\\\\3&4\\end{bmatrix}", Matrix([[1, 2], [3, 4]])),
|
||||
|
||||
# scientific notation
|
||||
("2.5\\times 10^2", 250),
|
||||
("1,500\\times 10^{-1}", 150),
|
||||
|
||||
# e notation
|
||||
("2.5E2", 250),
|
||||
("1,500E-1", 150),
|
||||
|
||||
# multiplication without cmd
|
||||
("2x2y", Mul(2, x, 2, y, evaluate=False)),
|
||||
("2x2", Mul(2, x, 2, evaluate=False)),
|
||||
("x2", x * 2),
|
||||
|
||||
# lin alg processing
|
||||
("\\theta\\begin{matrix}1&2\\\\3&4\\end{matrix}", MatMul(theta, Matrix([[1, 2], [3, 4]]), evaluate=False)),
|
||||
("\\theta\\begin{matrix}1\\\\3\\end{matrix} - \\begin{matrix}-1\\\\2\\end{matrix}", MatAdd(MatMul(theta, Matrix([[1], [3]]), evaluate=False), MatMul(-1, Matrix([[-1], [2]]), evaluate=False), evaluate=False)),
|
||||
("\\theta\\begin{matrix}1&0\\\\0&1\\end{matrix}*\\begin{matrix}3\\\\-2\\end{matrix}", MatMul(theta, Matrix([[1, 0], [0, 1]]), Matrix([3, -2]), evaluate=False)),
|
||||
("\\frac{1}{9}\\theta\\begin{matrix}1&2\\\\3&4\\end{matrix}", MatMul(Pow(9, -1, evaluate=False), theta, Matrix([[1, 2], [3, 4]]), evaluate=False)),
|
||||
("\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix},\\begin{pmatrix}4\\\\3\\\\1\\end{pmatrix}", [Matrix([1, 2, 3]), Matrix([4, 3, 1])]),
|
||||
("\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix};\\begin{pmatrix}4\\\\3\\\\1\\end{pmatrix}", [Matrix([1, 2, 3]), Matrix([4, 3, 1])]),
|
||||
("\\left\\{\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix},\\begin{pmatrix}4\\\\3\\\\1\\end{pmatrix}\\right\\}", [Matrix([1, 2, 3]), Matrix([4, 3, 1])]),
|
||||
("\\left\\{\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix},\\begin{pmatrix}4\\\\3\\\\1\\end{pmatrix},\\begin{pmatrix}1\\\\1\\\\1\\end{pmatrix}\\right\\}", [Matrix([1, 2, 3]), Matrix([4, 3, 1]), Matrix([1, 1, 1])]),
|
||||
("\\left\\{\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix}\\right\\}", Matrix([1, 2, 3])),
|
||||
("\\left{\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix}\\right}", Matrix([1, 2, 3])),
|
||||
("{\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix}}", Matrix([1, 2, 3])),
|
||||
|
||||
# us dollars
|
||||
("\\$1,000.00", 1000),
|
||||
("\\$543.21", 543.21),
|
||||
("\\$0.009", 0.009),
|
||||
|
||||
# percentages
|
||||
("100\\%", 1),
|
||||
("1.5\\%", 0.015),
|
||||
("0.05\\%", 0.0005),
|
||||
|
||||
# empty set
|
||||
("\\emptyset", S.EmptySet)
|
||||
]
|
||||
|
||||
def test_good_pair(self, s, eq):
|
||||
assert_equal(s, eq)
|
||||
58
evaluation/eval/tools/latex2sympy/tests/atom_expr_test.py
Normal file
58
evaluation/eval/tools/latex2sympy/tests/atom_expr_test.py
Normal file
@@ -0,0 +1,58 @@
|
||||
from .context import assert_equal
|
||||
import pytest
|
||||
from sympy import Symbol, Integer, Pow
|
||||
|
||||
# label, text, symbol_text
|
||||
symbols = [
|
||||
('letter', 'x', 'x'),
|
||||
('greek letter', '\\lambda', 'lambda'),
|
||||
('greek letter w/ space', '\\alpha ', 'alpha'),
|
||||
('accented letter', '\\overline{x}', 'xbar')
|
||||
]
|
||||
|
||||
subscripts = [
|
||||
('2'),
|
||||
('{23}'),
|
||||
('i'),
|
||||
('{ij}'),
|
||||
('{i,j}'),
|
||||
('{good}'),
|
||||
('{x^2}')
|
||||
]
|
||||
|
||||
examples = []
|
||||
for symbol in symbols:
|
||||
for subscript in subscripts:
|
||||
examples.append(tuple(list(symbol) + [subscript]))
|
||||
|
||||
|
||||
@pytest.mark.parametrize('label, text, symbol_text, subscript', examples)
|
||||
def test_with_supexpr(label, text, symbol_text, subscript):
|
||||
assert_equal(text + '^2', Pow(Symbol(symbol_text, real=True), Integer(2)))
|
||||
|
||||
|
||||
@pytest.mark.parametrize('label, text, symbol_text, subscript', examples)
|
||||
def test_with_subexpr(label, text, symbol_text, subscript):
|
||||
assert_equal(text + '_' + subscript, Symbol(symbol_text + '_' + subscript, real=True))
|
||||
|
||||
|
||||
@pytest.mark.parametrize('label, text, symbol_text, subscript', examples)
|
||||
def test_with_subexpr_before_supexpr(label, text, symbol_text, subscript):
|
||||
assert_equal(text + '_' + subscript + '^2', Pow(Symbol(symbol_text + '_' + subscript, real=True), Integer(2)))
|
||||
|
||||
|
||||
@pytest.mark.parametrize('label, text, symbol_text, subscript', examples)
|
||||
def test_with_subexpr_before_supexpr_with_braces(label, text, symbol_text, subscript):
|
||||
wrapped_subscript = subscript if '{' in subscript else '{' + subscript + '}'
|
||||
assert_equal(text + '_' + wrapped_subscript + '^{2}', Pow(Symbol(symbol_text + '_' + subscript, real=True), Integer(2)))
|
||||
|
||||
|
||||
@pytest.mark.parametrize('label, text, symbol_text, subscript', examples)
|
||||
def test_with_supexpr_before_subexpr(label, text, symbol_text, subscript):
|
||||
assert_equal(text + '^2_' + subscript, Pow(Symbol(symbol_text + '_' + subscript, real=True), Integer(2)))
|
||||
|
||||
|
||||
@pytest.mark.parametrize('label, text, symbol_text, subscript', examples)
|
||||
def test_with_supexpr_before_subexpr_with_braces(label, text, symbol_text, subscript):
|
||||
wrapped_subscript = subscript if '{' in subscript else '{' + subscript + '}'
|
||||
assert_equal(text + '^{2}_' + wrapped_subscript, Pow(Symbol(symbol_text + '_' + subscript, real=True), Integer(2)))
|
||||
36
evaluation/eval/tools/latex2sympy/tests/binomial_test.py
Normal file
36
evaluation/eval/tools/latex2sympy/tests/binomial_test.py
Normal file
@@ -0,0 +1,36 @@
|
||||
from .context import assert_equal, _Add, _Mul, _Pow
|
||||
import pytest
|
||||
from sympy import binomial, Symbol
|
||||
|
||||
x = Symbol('x', real=True)
|
||||
y = Symbol('y', real=True)
|
||||
theta = Symbol('theta', real=True)
|
||||
gamma = Symbol('gamma', real=True)
|
||||
|
||||
|
||||
def test_binomial_numeric():
|
||||
assert_equal("\\binom{16}{2}", binomial(16, 2))
|
||||
|
||||
|
||||
def test_binomial_symbols():
|
||||
assert_equal("\\binom{x}{y}", binomial(x, y))
|
||||
|
||||
|
||||
def test_binomial_greek_symbols():
|
||||
assert_equal("\\binom{\\theta}{\\gamma}", binomial(theta, gamma))
|
||||
|
||||
|
||||
def test_binomial_expr():
|
||||
assert_equal("\\binom{16+2}{\\frac{4}{2}}", binomial(_Add(16, 2), _Mul(4, _Pow(2, -1)), evaluate=False))
|
||||
|
||||
|
||||
def test_choose_numeric():
|
||||
assert_equal("\\choose{16}{2}", binomial(16, 2))
|
||||
|
||||
|
||||
def test_choose_symbols():
|
||||
assert_equal("\\choose{x}{y}", binomial(x, y))
|
||||
|
||||
|
||||
def test_choose_greek_symbols():
|
||||
assert_equal("\\choose{\\theta}{\\gamma}", binomial(theta, gamma))
|
||||
29
evaluation/eval/tools/latex2sympy/tests/ceil_test.py
Normal file
29
evaluation/eval/tools/latex2sympy/tests/ceil_test.py
Normal file
@@ -0,0 +1,29 @@
|
||||
from .context import assert_equal, get_simple_examples
|
||||
import pytest
|
||||
from sympy import ceiling
|
||||
|
||||
examples = get_simple_examples(ceiling)
|
||||
|
||||
|
||||
@pytest.mark.parametrize('input, output, symbolically', examples)
|
||||
def test_ceil_func(input, output, symbolically):
|
||||
assert_equal("\\ceil({input})".format(input=input), output, symbolically=symbolically)
|
||||
|
||||
|
||||
@pytest.mark.parametrize('input, output, symbolically', examples)
|
||||
def test_ceil_operatorname(input, output, symbolically):
|
||||
assert_equal("\\operatorname{{ceil}}({input})".format(input=input), output, symbolically=symbolically)
|
||||
|
||||
|
||||
@pytest.mark.parametrize('input, output, symbolically', examples)
|
||||
def test_ceil_cmd(input, output, symbolically):
|
||||
assert_equal("\\lceil {input}\\rceil".format(input=input), output, symbolically=symbolically)
|
||||
assert_equal("\\left\\lceil {input}\\right\\rceil".format(input=input), output, symbolically=symbolically)
|
||||
assert_equal("\\mleft\\lceil {input}\\mright\\rceil".format(input=input), output, symbolically=symbolically)
|
||||
|
||||
|
||||
@pytest.mark.parametrize('input, output, symbolically', examples)
|
||||
def test_ceil_corners(input, output, symbolically):
|
||||
assert_equal("\\ulcorner {input}\\urcorner".format(input=input), output, symbolically=symbolically)
|
||||
assert_equal("\\left\\ulcorner {input}\\right\\urcorner".format(input=input), output, symbolically=symbolically)
|
||||
assert_equal("\\mleft\\ulcorner {input}\\mright\\urcorner".format(input=input), output, symbolically=symbolically)
|
||||
21
evaluation/eval/tools/latex2sympy/tests/complex_test.py
Normal file
21
evaluation/eval/tools/latex2sympy/tests/complex_test.py
Normal file
@@ -0,0 +1,21 @@
|
||||
from .context import assert_equal
|
||||
import pytest
|
||||
from sympy import Sum, I, Symbol, Integer
|
||||
|
||||
a = Symbol('a', real=True)
|
||||
b = Symbol('b', real=True)
|
||||
i = Symbol('i', real=True)
|
||||
n = Symbol('n', real=True)
|
||||
x = Symbol('x', real=True)
|
||||
|
||||
|
||||
def test_complex():
|
||||
assert_equal("a+Ib", a + I * b)
|
||||
|
||||
|
||||
def test_complex_e():
|
||||
assert_equal("e^{I\\pi}", Integer(-1))
|
||||
|
||||
|
||||
def test_complex_sum():
|
||||
assert_equal("\\sum_{i=0}^{n} i \\cdot x", Sum(i * x, (i, 0, n)))
|
||||
84
evaluation/eval/tools/latex2sympy/tests/context.py
Normal file
84
evaluation/eval/tools/latex2sympy/tests/context.py
Normal file
@@ -0,0 +1,84 @@
|
||||
from sympy import simplify, srepr, Add, Mul, Pow, Rational, pi, sqrt, Symbol
|
||||
from latex2sympy.latex2sympy2 import latex2sympy as process_sympy
|
||||
import sys
|
||||
import os
|
||||
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
|
||||
|
||||
x = Symbol('x', real=True)
|
||||
y = Symbol('y', real=True)
|
||||
|
||||
# shorthand definitions
|
||||
|
||||
|
||||
def _Add(a, b):
|
||||
return Add(a, b, evaluate=False)
|
||||
|
||||
|
||||
def _Mul(a, b):
|
||||
return Mul(a, b, evaluate=False)
|
||||
|
||||
|
||||
def _Pow(a, b):
|
||||
return Pow(a, b, evaluate=False)
|
||||
|
||||
|
||||
def get_simple_examples(func):
|
||||
'''
|
||||
Returns an array of tuples, containing the string `input`, sympy `output` using the provided sympy `func`, and `symbolically` boolean
|
||||
for calling `compare`.
|
||||
'''
|
||||
return [
|
||||
("1.1", func(1.1), False),
|
||||
("6.9", func(6.9), False),
|
||||
("3.5", func(3.5), False),
|
||||
("8", func(8), False),
|
||||
("0", func(0), False),
|
||||
("290348E32", func(Rational('290348E32')), False),
|
||||
("1237.293894239480234", func(Rational('1237.293894239480234')), False),
|
||||
("8623.4592104E-2", func(Rational('8623.4592104E-2')), False),
|
||||
("\\pi ", func(pi), False),
|
||||
("\\sqrt{100}", func(sqrt(100)), False),
|
||||
("12,123.4", func(Rational('12123.4')), False),
|
||||
("-9.4", func(-9.4), False),
|
||||
("-35.9825", func(-35.9825), False),
|
||||
("-\\sqrt{5}", func(-sqrt(5)), False),
|
||||
("-324E-3", func(Rational('-324E-3')), False),
|
||||
("-0.23", func(-0.23), False),
|
||||
("\\frac{1}{2}", func(Rational('1/2')), False),
|
||||
("\\frac{6}{2}", func(Rational('6/2')), False),
|
||||
("\\frac{9}{5}", func(Rational('9/5')), False),
|
||||
("\\frac{-42}{6}", func(Rational('-42/6')), False),
|
||||
("-\\frac{325}{3}", func(Rational('-325/3')), False),
|
||||
("\\frac{\\pi }{2}", func(pi / 2), False),
|
||||
("(1+6)/3", func(Rational(1 + 6, 3)), False),
|
||||
("1+6/3", func(1 + Rational('6/3')), False),
|
||||
("7*4/5", func(7 * 4 / 5), False),
|
||||
("15-2.3", func(15 - Rational('2.3')), False),
|
||||
("x", func(x), True),
|
||||
("x + y", func(x + y), True),
|
||||
("\\frac{9x}{4}", func(9 * x / 4), True),
|
||||
("y\\pi", func(y * pi), True),
|
||||
("2y-y-y", func(2 * y - y - y), True)
|
||||
]
|
||||
|
||||
|
||||
def compare(actual, expected, symbolically=False):
|
||||
if symbolically:
|
||||
assert simplify(actual - expected) == 0
|
||||
else:
|
||||
actual_exp_tree = srepr(actual)
|
||||
expected_exp_tree = srepr(expected)
|
||||
try:
|
||||
assert actual_exp_tree == expected_exp_tree
|
||||
except Exception:
|
||||
if isinstance(actual, int) or isinstance(actual, float) or actual.is_number and isinstance(expected, int) or isinstance(expected, float) or expected.is_number:
|
||||
assert actual == expected or actual - expected == 0 or simplify(actual - expected) == 0
|
||||
else:
|
||||
print('expected_exp_tree = ', expected_exp_tree)
|
||||
print('actual exp tree = ', actual_exp_tree)
|
||||
raise
|
||||
|
||||
|
||||
def assert_equal(latex, expr, variable_values={}, symbolically=False):
|
||||
parsed = process_sympy(latex, variable_values)
|
||||
compare(parsed, expr, symbolically)
|
||||
57
evaluation/eval/tools/latex2sympy/tests/exp_test.py
Normal file
57
evaluation/eval/tools/latex2sympy/tests/exp_test.py
Normal file
@@ -0,0 +1,57 @@
|
||||
from .context import assert_equal
|
||||
import pytest
|
||||
from sympy import exp, sin, Symbol, E
|
||||
|
||||
x = Symbol('x', real=True)
|
||||
y = Symbol('y', real=True)
|
||||
|
||||
|
||||
def test_exp_letter():
|
||||
assert_equal("e", E)
|
||||
assert_equal("e", exp(1))
|
||||
|
||||
|
||||
def test_exp_func():
|
||||
assert_equal("\\exp(3)", exp(3))
|
||||
|
||||
|
||||
def test_exp_func_no_delim():
|
||||
assert_equal("\\exp3", exp(3))
|
||||
|
||||
|
||||
def test_exp_command_symbol():
|
||||
assert_equal("\\exponentialE", E)
|
||||
assert_equal("\\exponentialE", exp(1))
|
||||
|
||||
|
||||
def test_exp_command_symbol_expression():
|
||||
assert_equal("\\exponentialE^{3}", exp(3))
|
||||
|
||||
|
||||
def test_exp_command_symbol_multiplied():
|
||||
'''
|
||||
\\exponentialE is NOT a function, so using the following notation equates to multiplication
|
||||
'''
|
||||
assert_equal("\\exponentialE (3)", E * 3)
|
||||
assert_equal("\\exponentialE \\left( 3\\right)", E * 3)
|
||||
assert_equal("\\exponentialE \\times 3", E * 3)
|
||||
|
||||
|
||||
def test_exp_numeric():
|
||||
assert_equal("e^3", exp(3))
|
||||
|
||||
|
||||
def test_exp_symbol():
|
||||
assert_equal("e^x", exp(x))
|
||||
|
||||
|
||||
def test_exp_symbol_expr():
|
||||
assert_equal("e^{x+y}", exp(x + y))
|
||||
|
||||
|
||||
def test_exp_symbol_expr_group():
|
||||
assert_equal("e^{(x+y)}", exp(x + y))
|
||||
|
||||
|
||||
def test_exp_expr():
|
||||
assert_equal("\\sin(x)*e^x", sin(x) * exp(x))
|
||||
29
evaluation/eval/tools/latex2sympy/tests/floor_test.py
Normal file
29
evaluation/eval/tools/latex2sympy/tests/floor_test.py
Normal file
@@ -0,0 +1,29 @@
|
||||
from .context import assert_equal, get_simple_examples
|
||||
import pytest
|
||||
from sympy import floor
|
||||
|
||||
examples = get_simple_examples(floor)
|
||||
|
||||
|
||||
@pytest.mark.parametrize('input, output, symbolically', examples)
|
||||
def test_floor_func(input, output, symbolically):
|
||||
assert_equal("\\floor({input})".format(input=input), output, symbolically=symbolically)
|
||||
|
||||
|
||||
@pytest.mark.parametrize('input, output, symbolically', examples)
|
||||
def test_floor_operatorname(input, output, symbolically):
|
||||
assert_equal("\\operatorname{{floor}}({input})".format(input=input), output, symbolically=symbolically)
|
||||
|
||||
|
||||
@pytest.mark.parametrize('input, output, symbolically', examples)
|
||||
def test_floor_cmd(input, output, symbolically):
|
||||
assert_equal("\\lfloor {input}\\rfloor".format(input=input), output, symbolically=symbolically)
|
||||
assert_equal("\\left\\lfloor {input}\\right\\rfloor".format(input=input), output, symbolically=symbolically)
|
||||
assert_equal("\\mleft\\lfloor {input}\\mright\\rfloor".format(input=input), output, symbolically=symbolically)
|
||||
|
||||
|
||||
@pytest.mark.parametrize('input, output, symbolically', examples)
|
||||
def test_floor_corners(input, output, symbolically):
|
||||
assert_equal("\\llcorner {input}\\lrcorner".format(input=input), output, symbolically=symbolically)
|
||||
assert_equal("\\left\\llcorner {input}\\right\\lrcorner".format(input=input), output, symbolically=symbolically)
|
||||
assert_equal("\\mleft\\llcorner {input}\\mright\\lrcorner".format(input=input), output, symbolically=symbolically)
|
||||
161
evaluation/eval/tools/latex2sympy/tests/gcd_test.py
Normal file
161
evaluation/eval/tools/latex2sympy/tests/gcd_test.py
Normal file
@@ -0,0 +1,161 @@
|
||||
from .context import assert_equal
|
||||
import pytest
|
||||
from sympy import Symbol, Rational, UnevaluatedExpr, gcd, igcd, sqrt, pi
|
||||
|
||||
x = Symbol('x', real=True)
|
||||
y = Symbol('y', real=True)
|
||||
z = Symbol('z', real=True)
|
||||
|
||||
|
||||
def test_gcd_usual():
|
||||
assert_equal("\\gcd(18, 3)", gcd(18, 3))
|
||||
assert_equal("\\gcd(3, 18)", gcd(3, 18))
|
||||
assert_equal("\\gcd(2, 2)", gcd(2, 2))
|
||||
assert_equal("\\gcd(0, 21)", UnevaluatedExpr(gcd(0, 21)))
|
||||
assert_equal("\\gcd(21, 0)", UnevaluatedExpr(gcd(21, 0)))
|
||||
assert_equal("\\gcd(0, 0)", UnevaluatedExpr(gcd(0, 0)))
|
||||
assert_equal("\\gcd(6128, 24)", gcd(6128, 24))
|
||||
assert_equal("\\gcd(24, 6128)", gcd(24, 6128))
|
||||
assert_equal("\\gcd(1E20, 1000000)", gcd(Rational('1E20'), 1000000))
|
||||
assert_equal("\\gcd(128*10^32, 1)", gcd(Rational('128E32'), 1))
|
||||
|
||||
assert_equal("\\operatorname{gcd}(18, 3)", gcd(18, 3))
|
||||
assert_equal("\\operatorname{gcd}(3, 18)", gcd(3, 18))
|
||||
assert_equal("\\operatorname{gcd}(2, 2)", gcd(2, 2))
|
||||
assert_equal("\\operatorname{gcd}(0, 21)", UnevaluatedExpr(gcd(0, 21)))
|
||||
assert_equal("\\operatorname{gcd}(21, 0)", UnevaluatedExpr(gcd(21, 0)))
|
||||
assert_equal("\\operatorname{gcd}(0, 0)", UnevaluatedExpr(gcd(0, 0)))
|
||||
assert_equal("\\operatorname{gcd}(6128, 24)", gcd(6128, 24))
|
||||
assert_equal("\\operatorname{gcd}(24, 6128)", gcd(24, 6128))
|
||||
assert_equal("\\operatorname{gcd}(1E20, 1000000)", gcd(Rational('1E20'), 1000000))
|
||||
assert_equal("\\operatorname{gcd}(128*10^32, 1)", gcd(Rational('128E32'), 1))
|
||||
|
||||
|
||||
def test_gcd_negative():
|
||||
assert_equal("\\gcd(-12, 4)", gcd(-12, 4))
|
||||
assert_equal("\\gcd(219, -9)", gcd(219, -9))
|
||||
assert_equal("\\gcd(-8, -64)", gcd(-8, -64))
|
||||
assert_equal("\\gcd(-5, -5)", gcd(-5, -5))
|
||||
assert_equal("\\gcd(-1, 182033)", gcd(-1, 182033))
|
||||
assert_equal("\\gcd(25, -6125)", gcd(25, -6125))
|
||||
assert_equal("\\gcd(243, -2.9543127E21)", gcd(243, Rational('-2.9543127E21')))
|
||||
|
||||
assert_equal("\\operatorname{gcd}(-12, 4)", gcd(-12, 4))
|
||||
assert_equal("\\operatorname{gcd}(219, -9)", gcd(219, -9))
|
||||
assert_equal("\\operatorname{gcd}(-8, -64)", gcd(-8, -64))
|
||||
assert_equal("\\operatorname{gcd}(-5, -5)", gcd(-5, -5))
|
||||
assert_equal("\\operatorname{gcd}(-1, 182033)", gcd(-1, 182033))
|
||||
assert_equal("\\operatorname{gcd}(25, -6125)", gcd(25, -6125))
|
||||
assert_equal("\\operatorname{gcd}(243, -2.9543127E21)", gcd(243, Rational('-2.9543127E21')))
|
||||
|
||||
|
||||
def test_gcd_float():
|
||||
assert_equal("\\gcd(2.4, 3.6)", gcd(Rational('2.4'), Rational('3.6')))
|
||||
assert_equal("\\gcd(3.6, 2.4)", gcd(Rational('3.6'), Rational('2.4')))
|
||||
assert_equal("\\gcd(\\pi, 3)", gcd(pi, 3))
|
||||
assert_equal("\\gcd(618, 1.5)", gcd(618, Rational('1.5')))
|
||||
assert_equal("\\gcd(-1.5, 618)", gcd(Rational('-1.5'), 618))
|
||||
assert_equal("\\gcd(0.42, 2)", gcd(Rational('0.42'), 2))
|
||||
assert_equal("\\gcd(1.43E-13, 21)", gcd(Rational('1.43E-13'), 21))
|
||||
assert_equal("\\gcd(21, -143E-13)", gcd(21, Rational('-143E-13')))
|
||||
assert_equal("\\gcd(9.80655, 9.80655)", gcd(Rational('9.80655'), Rational('9.80655')))
|
||||
assert_equal("\\gcd(0.0000923423, -8341.234802909)", gcd(Rational('0.0000923423'), Rational('-8341.234802909')))
|
||||
assert_equal("\\gcd(\\sqrt{5}, \\sqrt{2})", gcd(sqrt(5), sqrt(2)))
|
||||
|
||||
assert_equal("\\operatorname{gcd}(2.4, 3.6)", gcd(Rational('2.4'), Rational('3.6')))
|
||||
assert_equal("\\operatorname{gcd}(3.6, 2.4)", gcd(Rational('3.6'), Rational('2.4')))
|
||||
assert_equal("\\operatorname{gcd}(\\pi, 3)", gcd(pi, 3))
|
||||
assert_equal("\\operatorname{gcd}(618, 1.5)", gcd(618, Rational('1.5')))
|
||||
assert_equal("\\operatorname{gcd}(-1.5, 618)", gcd(Rational('-1.5'), 618))
|
||||
assert_equal("\\operatorname{gcd}(0.42, 2)", gcd(Rational('0.42'), 2))
|
||||
assert_equal("\\operatorname{gcd}(1.43E-13, 21)", gcd(Rational('1.43E-13'), 21))
|
||||
assert_equal("\\operatorname{gcd}(21, -143E-13)", gcd(21, Rational('-143E-13')))
|
||||
assert_equal("\\operatorname{gcd}(9.80655, 9.80655)", gcd(Rational('9.80655'), Rational('9.80655')))
|
||||
assert_equal("\\operatorname{gcd}(0.0000923423, -8341.234802909)", gcd(Rational('0.0000923423'), Rational('-8341.234802909')))
|
||||
assert_equal("\\operatorname{gcd}(\\sqrt{5}, \\sqrt{2})", gcd(sqrt(5), sqrt(2)))
|
||||
|
||||
|
||||
def test_gcd_fraction():
|
||||
assert_equal("\\gcd(1/2, 3)", gcd(Rational('1/2'), 3))
|
||||
assert_equal("\\gcd(3, 1/2)", gcd(3, Rational('1/2')))
|
||||
assert_equal("\\gcd(6/2, 3)", gcd(Rational('6/2'), 3))
|
||||
assert_equal("\\gcd(1/10, 1/10)", gcd(Rational('1/10'), Rational('1/10')))
|
||||
assert_equal("\\gcd(42, 42/6)", gcd(42, Rational('42/6')))
|
||||
assert_equal("\\gcd(10000000/10, 10000)", gcd(Rational('10000000/10'), 10000))
|
||||
|
||||
assert_equal("\\operatorname{gcd}(1/2, 3)", gcd(Rational('1/2'), 3))
|
||||
assert_equal("\\operatorname{gcd}(3, 1/2)", gcd(3, Rational('1/2')))
|
||||
assert_equal("\\operatorname{gcd}(6/2, 3)", gcd(Rational('6/2'), 3))
|
||||
assert_equal("\\operatorname{gcd}(1/10, 1/10)", gcd(Rational('1/10'), Rational('1/10')))
|
||||
assert_equal("\\operatorname{gcd}(42, 42/6)", gcd(42, Rational('42/6')))
|
||||
assert_equal("\\operatorname{gcd}(10000000/10, 10000)", gcd(Rational('10000000/10'), 10000))
|
||||
|
||||
|
||||
def test_gcd_expr():
|
||||
assert_equal("\\gcd(1+1, 8)", gcd(1 + 1, 8))
|
||||
assert_equal("920*\\gcd(9, 12*4/2)", 920 * gcd(9, 12 * Rational('4/2')))
|
||||
assert_equal("\\gcd(32-128, 10)*22", gcd(32 - 128, 10) * 22)
|
||||
assert_equal("\\sqrt{\\gcd(1.25E24, 1E12)}", sqrt(gcd(Rational('1.25E24'), Rational('1E12'))))
|
||||
assert_equal("\\gcd(92.0, 000+2)", gcd(Rational('92.0'), 000 + 2))
|
||||
|
||||
assert_equal("\\operatorname{gcd}(1+1, 8)", gcd(1 + 1, 8))
|
||||
assert_equal("920*\\operatorname{gcd}(9, 12*4/2)", 920 * gcd(9, 12 * Rational('4/2')))
|
||||
assert_equal("\\operatorname{gcd}(32-128, 10)*22", gcd(32 - 128, 10) * 22)
|
||||
assert_equal("\\sqrt{\\operatorname{gcd}(1.25E24, 1E12)}", sqrt(gcd(Rational('1.25E24'), Rational('1E12'))))
|
||||
assert_equal("\\operatorname{gcd}(92.0, 000+2)", gcd(Rational('92.0'), 000 + 2))
|
||||
|
||||
|
||||
def test_gcd_symbol():
|
||||
assert_equal("\\gcd(x, y)", gcd(x, y), symbolically=True)
|
||||
assert_equal("\\gcd(y, -x)", gcd(y, -x), symbolically=True)
|
||||
assert_equal("\\gcd(2y, x)", gcd(2 * y, x), symbolically=True)
|
||||
assert_equal("\\gcd(125, 50x)", gcd(125, 50 * x), symbolically=True)
|
||||
assert_equal("\\gcd(x + 76, \\sqrt{x} * 4)", gcd(x + 76, sqrt(x) * 4), symbolically=True)
|
||||
assert_equal("\\gcd(y, y)", gcd(y, y), symbolically=True)
|
||||
assert_equal("y + \\gcd(0.4x, 8/3) / 2", y + gcd(Rational('0.4') * x, Rational('8/3')) / 2, symbolically=True)
|
||||
assert_equal("6.673E-11 * (\\gcd(8.85418782E-12, 9x) + 4) / 8y", Rational('6.673E-11') * (gcd(Rational('8.85418782E-12'), 9 * x) + 4) / (8 * y), symbolically=True)
|
||||
|
||||
assert_equal("\\operatorname{gcd}(x, y)", gcd(x, y), symbolically=True)
|
||||
assert_equal("\\operatorname{gcd}(y, -x)", gcd(y, -x), symbolically=True)
|
||||
assert_equal("\\operatorname{gcd}(2y, x)", gcd(2 * y, x), symbolically=True)
|
||||
assert_equal("\\operatorname{gcd}(125, 50x)", gcd(125, 50 * x), symbolically=True)
|
||||
assert_equal("\\operatorname{gcd}(x + 76, \\sqrt{x} * 4)", gcd(x + 76, sqrt(x) * 4), symbolically=True)
|
||||
assert_equal("\\operatorname{gcd}(y, y)", gcd(y, y), symbolically=True)
|
||||
assert_equal("y + \\operatorname{gcd}(0.4x, 8/3) / 2", y + gcd(Rational('0.4') * x, Rational('8/3')) / 2, symbolically=True)
|
||||
assert_equal("6.673E-11 * (\\operatorname{gcd}(8.85418782E-12, 9x) + 4) / 8y", Rational('6.673E-11') * (gcd(Rational('8.85418782E-12'), 9 * x) + 4) / (8 * y), symbolically=True)
|
||||
|
||||
|
||||
def test_multiple_parameters():
|
||||
assert_equal("\\gcd(830,450)", gcd(830, 450))
|
||||
assert_equal("\\gcd(6,321,429)", igcd(6, 321, 429))
|
||||
assert_equal("\\gcd(14,2324)", gcd(14, 2324))
|
||||
assert_equal("\\gcd(3, 6, 2)", igcd(3, 6, 2))
|
||||
assert_equal("\\gcd(144, 2988, 37116)", igcd(144, 2988, 37116))
|
||||
assert_equal("\\gcd(144,2988, 37116,18, 72)", igcd(144, 2988, 37116, 18, 72))
|
||||
assert_equal("\\gcd(144, 2988, 37116, 18, 72, 12, 6)", igcd(144, 2988, 37116, 18, 72, 12, 6))
|
||||
assert_equal("\\gcd(32)", gcd(32, 32))
|
||||
assert_equal("\\gcd(-8, 4,-2)", gcd(-8, gcd(4, -2)))
|
||||
assert_equal("\\gcd(x, y,z)", gcd(x, gcd(y, z)), symbolically=True)
|
||||
assert_equal("\\gcd(6*4,48, 3)", igcd(6 * 4, 48, 3))
|
||||
assert_equal("\\gcd(6*4,48,3)", igcd(6 * 4, 48, 3))
|
||||
assert_equal("\\gcd(2.4,3.6, 0.6)", gcd(Rational('2.4'), gcd(Rational('3.6'), Rational('0.6'))))
|
||||
assert_equal("\\gcd(2.4,3.6,0.6)", gcd(Rational('2.4'), gcd(Rational('3.6'), Rational('0.6'))))
|
||||
assert_equal("\\gcd(\\sqrt{3},\\sqrt{2}, \\sqrt{100})", gcd(sqrt(3), gcd(sqrt(2), sqrt(100))))
|
||||
assert_equal("\\gcd(1E12, 1E6,1E3, 10)", igcd(Rational('1E12'), Rational('1E6'), Rational('1E3'), 10))
|
||||
|
||||
assert_equal("\\operatorname{gcd}(830,450)", gcd(830, 450))
|
||||
assert_equal("\\operatorname{gcd}(6,321,429)", igcd(6, 321, 429))
|
||||
assert_equal("\\operatorname{gcd}(14,2324)", gcd(14, 2324))
|
||||
assert_equal("\\operatorname{gcd}(3, 6, 2)", igcd(3, 6, 2))
|
||||
assert_equal("\\operatorname{gcd}(144, 2988, 37116)", igcd(144, 2988, 37116))
|
||||
assert_equal("\\operatorname{gcd}(144,2988, 37116,18, 72)", igcd(144, 2988, 37116, 18, 72))
|
||||
assert_equal("\\operatorname{gcd}(144, 2988, 37116, 18, 72, 12, 6)", igcd(144, 2988, 37116, 18, 72, 12, 6))
|
||||
assert_equal("\\operatorname{gcd}(32)", gcd(32, 32))
|
||||
assert_equal("\\operatorname{gcd}(-8, 4,-2)", gcd(-8, gcd(4, -2)))
|
||||
assert_equal("\\operatorname{gcd}(x, y,z)", gcd(x, gcd(y, z)), symbolically=True)
|
||||
assert_equal("\\operatorname{gcd}(6*4,48, 3)", igcd(6 * 4, 48, 3))
|
||||
assert_equal("\\operatorname{gcd}(6*4,48,3)", igcd(6 * 4, 48, 3))
|
||||
assert_equal("\\operatorname{gcd}(2.4,3.6, 0.6)", gcd(Rational('2.4'), gcd(Rational('3.6'), Rational('0.6'))))
|
||||
assert_equal("\\operatorname{gcd}(2.4,3.6,0.6)", gcd(Rational('2.4'), gcd(Rational('3.6'), Rational('0.6'))))
|
||||
assert_equal("\\operatorname{gcd}(\\sqrt{3},\\sqrt{2}, \\sqrt{100})", gcd(sqrt(3), gcd(sqrt(2), sqrt(100))))
|
||||
assert_equal("\\operatorname{gcd}(1E12, 1E6,1E3, 10)", igcd(Rational('1E12'), Rational('1E6'), Rational('1E3'), 10))
|
||||
19
evaluation/eval/tools/latex2sympy/tests/greek_test.py
Normal file
19
evaluation/eval/tools/latex2sympy/tests/greek_test.py
Normal file
@@ -0,0 +1,19 @@
|
||||
from .context import assert_equal
|
||||
import pytest
|
||||
from sympy import Symbol
|
||||
|
||||
epsilon_upper = Symbol('char"000190', real=True)
|
||||
epsilon_lower = Symbol('epsilon', real=True)
|
||||
varepsilon = Symbol('varepsilon', real=True)
|
||||
|
||||
|
||||
def test_greek_epsilon():
|
||||
assert_equal("\\epsilon", epsilon_lower)
|
||||
|
||||
|
||||
def test_greek_epsilon_upper():
|
||||
assert_equal('\\char"000190', epsilon_upper)
|
||||
|
||||
|
||||
def test_greek_varepsilon():
|
||||
assert_equal('\\varepsilon', varepsilon)
|
||||
52
evaluation/eval/tools/latex2sympy/tests/grouping_test.py
Normal file
52
evaluation/eval/tools/latex2sympy/tests/grouping_test.py
Normal file
@@ -0,0 +1,52 @@
|
||||
from .context import assert_equal, _Pow, _Add, _Mul
|
||||
import pytest
|
||||
from sympy import Integral, sin, Symbol, Mul, Integer, Pow
|
||||
from latex2sympy.latex2sympy2 import latex2sympy as process_sympy
|
||||
|
||||
a = Symbol('a', real=True)
|
||||
b = Symbol('b', real=True)
|
||||
x = Symbol('x', real=True)
|
||||
theta = Symbol('theta', real=True)
|
||||
|
||||
|
||||
func_arg_examples = [
|
||||
('\\int ', 'x dx', Integral(x, x)),
|
||||
('\\sin', '\\theta ', sin(theta))
|
||||
]
|
||||
|
||||
example_groups = [
|
||||
('1+2', '3-4', _Mul(_Add(1, 2), _Add(3, _Mul(-1, 4))))
|
||||
]
|
||||
|
||||
modifiable_delimiter_pairs = {
|
||||
'(': ')',
|
||||
'\\lgroup': '\\rgroup',
|
||||
'\\{': '\\}',
|
||||
'\\lbrace': '\\rbrace',
|
||||
'[': ']',
|
||||
'\\lbrack': '\\rbrack',
|
||||
}
|
||||
|
||||
|
||||
@pytest.mark.parametrize('func, args, output', func_arg_examples)
|
||||
def test_func_arg_groupings(func, args, output):
|
||||
# none
|
||||
assert_equal("{func} {args}".format(func=func, args=args), output)
|
||||
# normal brace (not modifiable)
|
||||
assert_equal("{func}{{{args}}}".format(func=func, args=args), output)
|
||||
# rest of delimiters, with modifications
|
||||
for left, right in modifiable_delimiter_pairs.items():
|
||||
assert_equal("{func}{left}{args}{right}".format(left=left, right=right, func=func, args=args), output)
|
||||
assert_equal("{func}\\left{left}{args}\\right{right}".format(left=left, right=right, func=func, args=args), output)
|
||||
assert_equal("{func}\\mleft{left}{args}\\mright{right}".format(left=left, right=right, func=func, args=args), output)
|
||||
|
||||
|
||||
@pytest.mark.parametrize('group1, group2, output', example_groups)
|
||||
def test_delimiter_groupings(group1, group2, output):
|
||||
# normal brace (not modifiable)
|
||||
assert_equal("{{{group1}}}{{{group2}}}".format(group1=group1, group2=group2), output)
|
||||
# rest of delimiters, with modifications
|
||||
for left, right in modifiable_delimiter_pairs.items():
|
||||
assert_equal("{left}{group1}{right}{left}{group2}{right}".format(left=left, right=right, group1=group1, group2=group2), output)
|
||||
assert_equal("\\left{left}{group1}\\right{right}\\left{left}{group2}\\right{right}".format(left=left, right=right, group1=group1, group2=group2), output)
|
||||
assert_equal("\\mleft{left}{group1}\\mright{right}\\mleft{left}{group2}\\mright{right}".format(left=left, right=right, group1=group1, group2=group2), output)
|
||||
161
evaluation/eval/tools/latex2sympy/tests/lcm_test.py
Normal file
161
evaluation/eval/tools/latex2sympy/tests/lcm_test.py
Normal file
@@ -0,0 +1,161 @@
|
||||
from .context import assert_equal
|
||||
import pytest
|
||||
from sympy import Symbol, Rational, UnevaluatedExpr, lcm, ilcm, sqrt, pi
|
||||
|
||||
x = Symbol('x', real=True)
|
||||
y = Symbol('y', real=True)
|
||||
z = Symbol('z', real=True)
|
||||
|
||||
|
||||
def test_lcm_usual():
|
||||
assert_equal("\\lcm(6, 4)", lcm(6, 4))
|
||||
assert_equal("\\lcm(4, 6)", lcm(4, 6))
|
||||
assert_equal("\\lcm(2, 2)", lcm(2, 2))
|
||||
assert_equal("\\lcm(0, 21)", UnevaluatedExpr(lcm(0, 21)))
|
||||
assert_equal("\\lcm(21, 0)", UnevaluatedExpr(lcm(21, 0)))
|
||||
assert_equal("\\lcm(0, 0)", UnevaluatedExpr(lcm(0, 0)))
|
||||
assert_equal("\\lcm(9, 21)", lcm(9, 21))
|
||||
assert_equal("\\lcm(6128, 24)", lcm(6128, 24))
|
||||
assert_equal("\\lcm(24, 6128)", lcm(24, 6128))
|
||||
assert_equal("\\lcm(1E20, 1000000)", lcm(Rational('1E20'), 1000000))
|
||||
assert_equal("\\lcm(128*10^32, 1)", lcm(Rational('128E32'), 1))
|
||||
|
||||
assert_equal("\\operatorname{lcm}(6, 4)", lcm(6, 4))
|
||||
assert_equal("\\operatorname{lcm}(4, 6)", lcm(4, 6))
|
||||
assert_equal("\\operatorname{lcm}(2, 2)", lcm(2, 2))
|
||||
assert_equal("\\operatorname{lcm}(0, 21)", UnevaluatedExpr(lcm(0, 21)))
|
||||
assert_equal("\\operatorname{lcm}(21, 0)", UnevaluatedExpr(lcm(21, 0)))
|
||||
assert_equal("\\operatorname{lcm}(0, 0)", UnevaluatedExpr(lcm(0, 0)))
|
||||
assert_equal("\\operatorname{lcm}(9, 21)", lcm(9, 21))
|
||||
assert_equal("\\operatorname{lcm}(6128, 24)", lcm(6128, 24))
|
||||
assert_equal("\\operatorname{lcm}(24, 6128)", lcm(24, 6128))
|
||||
assert_equal("\\operatorname{lcm}(1E20, 1000000)", lcm(Rational('1E20'), 1000000))
|
||||
assert_equal("\\operatorname{lcm}(128*10^32, 1)", lcm(Rational('128E32'), 1))
|
||||
|
||||
|
||||
def test_lcm_negative():
|
||||
assert_equal("\\lcm(-12, 4)", lcm(-12, 4))
|
||||
assert_equal("\\lcm(219, -9)", lcm(219, -9))
|
||||
assert_equal("\\lcm(-8, -12)", lcm(-8, -12))
|
||||
assert_equal("\\lcm(-5, -5)", lcm(-5, -5))
|
||||
assert_equal("\\lcm(-1, 182033)", lcm(-1, 182033))
|
||||
assert_equal("\\lcm(25, -30)", lcm(25, -30))
|
||||
assert_equal("\\lcm(243, -2.9543127E21)", lcm(243, Rational('-2.9543127E21')))
|
||||
|
||||
assert_equal("\\operatorname{lcm}(-12, 4)", lcm(-12, 4))
|
||||
assert_equal("\\operatorname{lcm}(219, -9)", lcm(219, -9))
|
||||
assert_equal("\\operatorname{lcm}(-8, -12)", lcm(-8, -12))
|
||||
assert_equal("\\operatorname{lcm}(-5, -5)", lcm(-5, -5))
|
||||
assert_equal("\\operatorname{lcm}(-1, 182033)", lcm(-1, 182033))
|
||||
assert_equal("\\operatorname{lcm}(25, -30)", lcm(25, -30))
|
||||
assert_equal("\\operatorname{lcm}(243, -2.9543127E21)", lcm(243, Rational('-2.9543127E21')))
|
||||
|
||||
|
||||
def test_lcm_float():
|
||||
assert_equal("\\lcm(2.4, 3.6)", lcm(Rational('2.4'), Rational('3.6')))
|
||||
assert_equal("\\lcm(3.6, 2.4)", lcm(Rational('3.6'), Rational('2.4')))
|
||||
assert_equal("\\lcm(\\pi, 3)", lcm(pi, 3))
|
||||
assert_equal("\\lcm(618, 1.5)", lcm(618, Rational('1.5')))
|
||||
assert_equal("\\lcm(-1.5, 618)", lcm(Rational('-1.5'), 618))
|
||||
assert_equal("\\lcm(0.42, 2)", lcm(Rational('0.42'), 2))
|
||||
assert_equal("\\lcm(1.43E-13, 21)", lcm(Rational('1.43E-13'), 21))
|
||||
assert_equal("\\lcm(21, -143E-13)", lcm(21, Rational('-143E-13')))
|
||||
assert_equal("\\lcm(9.80655, 9.80655)", lcm(Rational('9.80655'), Rational('9.80655')))
|
||||
assert_equal("\\lcm(0.0000923423, -8341.234802909)", lcm(Rational('0.0000923423'), Rational('-8341.234802909')))
|
||||
assert_equal("\\lcm(\\sqrt{5}, \\sqrt{2})", lcm(sqrt(5), sqrt(2)))
|
||||
|
||||
assert_equal("\\operatorname{lcm}(2.4, 3.6)", lcm(Rational('2.4'), Rational('3.6')))
|
||||
assert_equal("\\operatorname{lcm}(3.6, 2.4)", lcm(Rational('3.6'), Rational('2.4')))
|
||||
assert_equal("\\operatorname{lcm}(\\pi, 3)", lcm(pi, 3))
|
||||
assert_equal("\\operatorname{lcm}(618, 1.5)", lcm(618, Rational('1.5')))
|
||||
assert_equal("\\operatorname{lcm}(-1.5, 618)", lcm(Rational('-1.5'), 618))
|
||||
assert_equal("\\operatorname{lcm}(0.42, 2)", lcm(Rational('0.42'), 2))
|
||||
assert_equal("\\operatorname{lcm}(1.43E-13, 21)", lcm(Rational('1.43E-13'), 21))
|
||||
assert_equal("\\operatorname{lcm}(21, -143E-13)", lcm(21, Rational('-143E-13')))
|
||||
assert_equal("\\operatorname{lcm}(9.80655, 9.80655)", lcm(Rational('9.80655'), Rational('9.80655')))
|
||||
assert_equal("\\operatorname{lcm}(0.0000923423, -8341.234802909)", lcm(Rational('0.0000923423'), Rational('-8341.234802909')))
|
||||
assert_equal("\\operatorname{lcm}(\\sqrt{5}, \\sqrt{2})", lcm(sqrt(5), sqrt(2)))
|
||||
|
||||
|
||||
def test_lcm_fraction():
|
||||
assert_equal("\\lcm(1/2, 3)", lcm(Rational('1/2'), 3))
|
||||
assert_equal("\\lcm(3, 1/2)", lcm(3, Rational('1/2')))
|
||||
assert_equal("\\lcm(6/2, 3)", lcm(Rational('6/2'), 3))
|
||||
assert_equal("\\lcm(1/10, 1/10)", lcm(Rational('1/10'), Rational('1/10')))
|
||||
assert_equal("\\lcm(42, 42/6)", lcm(42, Rational('42/6')))
|
||||
assert_equal("\\lcm(10000000/10, 10000)", lcm(Rational('10000000/10'), 10000))
|
||||
|
||||
assert_equal("\\operatorname{lcm}(1/2, 3)", lcm(Rational('1/2'), 3))
|
||||
assert_equal("\\operatorname{lcm}(3, 1/2)", lcm(3, Rational('1/2')))
|
||||
assert_equal("\\operatorname{lcm}(6/2, 3)", lcm(Rational('6/2'), 3))
|
||||
assert_equal("\\operatorname{lcm}(1/10, 1/10)", lcm(Rational('1/10'), Rational('1/10')))
|
||||
assert_equal("\\operatorname{lcm}(42, 42/6)", lcm(42, Rational('42/6')))
|
||||
assert_equal("\\operatorname{lcm}(10000000/10, 10000)", lcm(Rational('10000000/10'), 10000))
|
||||
|
||||
|
||||
def test_lcm_expr():
|
||||
assert_equal("\\lcm(1+1, 8)", lcm(1 + 1, 8))
|
||||
assert_equal("920*\\lcm(9, 12*4/2)", 920 * lcm(9, 12 * Rational('4/2')))
|
||||
assert_equal("\\lcm(32-128, 10)*22", lcm(32 - 128, 10) * 22)
|
||||
assert_equal("\\sqrt{\\lcm(1.25E24, 1E12)}", sqrt(lcm(Rational('1.25E24'), Rational('1E12'))))
|
||||
assert_equal("\\lcm(92.0, 000+2)", lcm(Rational('92.0'), 000 + 2))
|
||||
|
||||
assert_equal("\\operatorname{lcm}(1+1, 8)", lcm(1 + 1, 8))
|
||||
assert_equal("920*\\operatorname{lcm}(9, 12*4/2)", 920 * lcm(9, 12 * Rational('4/2')))
|
||||
assert_equal("\\operatorname{lcm}(32-128, 10)*22", lcm(32 - 128, 10) * 22)
|
||||
assert_equal("\\sqrt{\\operatorname{lcm}(1.25E24, 1E12)}", sqrt(lcm(Rational('1.25E24'), Rational('1E12'))))
|
||||
assert_equal("\\operatorname{lcm}(92.0, 000+2)", lcm(Rational('92.0'), 000 + 2))
|
||||
|
||||
|
||||
def test_lcm_symbol():
|
||||
assert_equal("\\lcm(x, y)", lcm(x, y), symbolically=True)
|
||||
assert_equal("\\lcm(y, -x)", lcm(y, -x), symbolically=True)
|
||||
assert_equal("\\lcm(2y, x)", lcm(2 * y, x), symbolically=True)
|
||||
assert_equal("\\lcm(125, 50x)", lcm(125, 50 * x), symbolically=True)
|
||||
assert_equal("\\lcm(x + 76, \\sqrt{x} * 4)", lcm(x + 76, sqrt(x) * 4), symbolically=True)
|
||||
assert_equal("\\lcm(y, y)", lcm(y, y), symbolically=True)
|
||||
assert_equal("y + \\lcm(0.4x, 8/3) / 2", y + lcm(Rational('0.4') * x, Rational('8/3')) / 2, symbolically=True)
|
||||
assert_equal("6.673E-11 * (\\lcm(8.85418782E-12, 9x) + 4) / 8y", Rational('6.673E-11') * (lcm(Rational('8.85418782E-12'), 9 * x) + 4) / (8 * y), symbolically=True)
|
||||
|
||||
assert_equal("\\operatorname{lcm}(x, y)", lcm(x, y), symbolically=True)
|
||||
assert_equal("\\operatorname{lcm}(y, -x)", lcm(y, -x), symbolically=True)
|
||||
assert_equal("\\operatorname{lcm}(2y, x)", lcm(2 * y, x), symbolically=True)
|
||||
assert_equal("\\operatorname{lcm}(125, 50x)", lcm(125, 50 * x), symbolically=True)
|
||||
assert_equal("\\operatorname{lcm}(x + 76, \\sqrt{x} * 4)", lcm(x + 76, sqrt(x) * 4), symbolically=True)
|
||||
assert_equal("\\operatorname{lcm}(y, y)", lcm(y, y), symbolically=True)
|
||||
assert_equal("y + \\operatorname{lcm}(0.4x, 8/3) / 2", y + lcm(Rational('0.4') * x, Rational('8/3')) / 2, symbolically=True)
|
||||
assert_equal("6.673E-11 * (\\operatorname{lcm}(8.85418782E-12, 9x) + 4) / 8y", Rational('6.673E-11') * (lcm(Rational('8.85418782E-12'), 9 * x) + 4) / (8 * y), symbolically=True)
|
||||
|
||||
|
||||
def test_multiple_parameters():
|
||||
assert_equal("\\lcm(830,450)", lcm(830, 450))
|
||||
assert_equal("\\lcm(6,321,429)", ilcm(6, 321, 429))
|
||||
assert_equal("\\lcm(14,2324)", lcm(14, 2324))
|
||||
assert_equal("\\lcm(3, 6, 2)", ilcm(3, 6, 2))
|
||||
assert_equal("\\lcm(8, 9, 21)", ilcm(8, 9, 21))
|
||||
assert_equal("\\lcm(144, 2988, 37116)", ilcm(144, 2988, 37116))
|
||||
assert_equal("\\lcm(144,2988,37116,18,72)", ilcm(144, 2988, 37116, 18, 72))
|
||||
assert_equal("\\lcm(144, 2988, 37116, 18, 72, 12, 6)", ilcm(144, 2988, 37116, 18, 72, 12, 6))
|
||||
assert_equal("\\lcm(32)", lcm(32, 32))
|
||||
assert_equal("\\lcm(-8, 4, -2)", lcm(-8, lcm(4, -2)))
|
||||
assert_equal("\\lcm(x, y, z)", lcm(x, lcm(y, z)), symbolically=True)
|
||||
assert_equal("\\lcm(6*4, 48, 3)", ilcm(6 * 4, 48, 3))
|
||||
assert_equal("\\lcm(2.4, 3.6, 0.6)", lcm(Rational('2.4'), lcm(Rational('3.6'), Rational('0.6'))))
|
||||
assert_equal("\\lcm(\\sqrt{3}, \\sqrt{2},\\sqrt{100})", lcm(sqrt(3), lcm(sqrt(2), sqrt(100))))
|
||||
assert_equal("\\lcm(1E12, 1E6, 1E3, 10)", ilcm(Rational('1E12'), Rational('1E6'), Rational('1E3'), 10))
|
||||
|
||||
assert_equal("\\operatorname{lcm}(830,450)", lcm(830, 450))
|
||||
assert_equal("\\operatorname{lcm}(6,321,429)", ilcm(6, 321, 429))
|
||||
assert_equal("\\operatorname{lcm}(14,2324)", lcm(14, 2324))
|
||||
assert_equal("\\operatorname{lcm}(3, 6, 2)", ilcm(3, 6, 2))
|
||||
assert_equal("\\operatorname{lcm}(8, 9, 21)", ilcm(8, 9, 21))
|
||||
assert_equal("\\operatorname{lcm}(144, 2988, 37116)", ilcm(144, 2988, 37116))
|
||||
assert_equal("\\operatorname{lcm}(144,2988,37116,18,72)", ilcm(144, 2988, 37116, 18, 72))
|
||||
assert_equal("\\operatorname{lcm}(144, 2988, 37116, 18, 72, 12, 6)", ilcm(144, 2988, 37116, 18, 72, 12, 6))
|
||||
assert_equal("\\operatorname{lcm}(32)", lcm(32, 32))
|
||||
assert_equal("\\operatorname{lcm}(-8, 4, -2)", lcm(-8, lcm(4, -2)))
|
||||
assert_equal("\\operatorname{lcm}(x, y, z)", lcm(x, lcm(y, z)), symbolically=True)
|
||||
assert_equal("\\operatorname{lcm}(6*4,48, 3)", ilcm(6 * 4, 48, 3))
|
||||
assert_equal("\\operatorname{lcm}(2.4, 3.6,0.6)", lcm(Rational('2.4'), lcm(Rational('3.6'), Rational('0.6'))))
|
||||
assert_equal("\\operatorname{lcm}(\\sqrt{3}, \\sqrt{2},\\sqrt{100})", lcm(sqrt(3), lcm(sqrt(2), sqrt(100))))
|
||||
assert_equal("\\operatorname{lcm}(1E12,1E6, 1E3, 10)", ilcm(Rational('1E12'), Rational('1E6'), Rational('1E3'), 10))
|
||||
@@ -0,0 +1,9 @@
|
||||
from .context import assert_equal
|
||||
import pytest
|
||||
from sympy import sin, Symbol
|
||||
|
||||
x = Symbol('x', real=True)
|
||||
|
||||
|
||||
def test_left_right_cdot():
|
||||
assert_equal("\\sin\\left(x\\right)\\cdot x", sin(x) * x)
|
||||
15
evaluation/eval/tools/latex2sympy/tests/linalg_test.py
Normal file
15
evaluation/eval/tools/latex2sympy/tests/linalg_test.py
Normal file
@@ -0,0 +1,15 @@
|
||||
from .context import assert_equal
|
||||
import pytest
|
||||
from sympy import MatMul, Matrix
|
||||
|
||||
|
||||
def test_linalg_placeholder():
|
||||
assert_equal("\\begin{pmatrix}1&2\\\\3&4\\end{pmatrix}\\cdot\\variable{v}", MatMul(Matrix([[1, 2], [3, 4]]), Matrix([1, 2])), {'v': Matrix([1, 2])})
|
||||
|
||||
|
||||
def test_linalg_placeholder_multiple():
|
||||
assert_equal("\\variable{M}\\cdot\\variable{v}", MatMul(Matrix([[1, 2], [3, 4]]), Matrix([1, 2])), {'M': Matrix([[1, 2], [3, 4]]), 'v': Matrix([1, 2])})
|
||||
|
||||
|
||||
def test_linalg_placeholder_multiple_mul():
|
||||
assert_equal("\\begin{pmatrix}3&-1\\end{pmatrix}\\cdot\\variable{M}\\cdot\\variable{v}", MatMul(Matrix([[3, -1]]), Matrix([[1, 2], [3, 4]]), Matrix([1, 2])), {'M': Matrix([[1, 2], [3, 4]]), 'v': Matrix([1, 2])})
|
||||
79
evaluation/eval/tools/latex2sympy/tests/max_test.py
Normal file
79
evaluation/eval/tools/latex2sympy/tests/max_test.py
Normal file
@@ -0,0 +1,79 @@
|
||||
from .context import assert_equal
|
||||
import pytest
|
||||
from sympy import Symbol, Rational, Float, Max, sqrt, exp, pi, nsimplify
|
||||
|
||||
x = Symbol('x', real=True)
|
||||
y = Symbol('y', real=True)
|
||||
z = Symbol('z', real=True)
|
||||
|
||||
|
||||
def test_max_usual():
|
||||
assert_equal("\\max(1, 5)", Max(1, 5))
|
||||
assert_equal("\\max(12, 4)", Max(12, 4))
|
||||
assert_equal("\\max(109, 120)", Max(109, 120))
|
||||
assert_equal("\\max(3, 3)", Max(3, 3))
|
||||
assert_equal("\\max(0, 0)", Max(0, 0))
|
||||
assert_equal("\\max(1)", Max(1))
|
||||
assert_equal("\\max(1092198374, 290348E32)", Max(1092198374, Rational('290348E32')))
|
||||
assert_equal("\\max(5, 2, 17, 4)", Max(5, 2, 17, 4))
|
||||
|
||||
|
||||
def test_max_negative():
|
||||
assert_equal("\\max(-9, 4)", Max(-9, 4))
|
||||
assert_equal("\\max(4, -9)", Max(4, -9))
|
||||
assert_equal("\\max(-7)", Max(-7))
|
||||
assert_equal("\\max(-2, -2)", Max(-2, -2))
|
||||
assert_equal("\\max(-324E-3, -58)", Max(Rational('-324E-3'), -58))
|
||||
assert_equal("\\max(-1, 0, 1, -37, 42)", Max(-1, 0, 1, -37, 42))
|
||||
|
||||
|
||||
def test_max_float():
|
||||
assert_equal("\\max(\\pi, 3)", Max(pi, 3))
|
||||
assert_equal("\\max(1234.56789, 1234.5678901)", Max(Rational('1234.56789'), Rational('1234.5678901')))
|
||||
assert_equal("\\max(12.4, 9.5)", Max(12.4, 9.5))
|
||||
assert_equal("\\max(6, 6.2)", Max(6, 6.2))
|
||||
assert_equal("\\max(-98.7)", Max(-98.7))
|
||||
assert_equal("\\max(7.1, 9)", Max(7.1, 9))
|
||||
assert_equal("\\max(-21E-12, 0.00005)", Max(nsimplify(Rational('-21E-12')), Rational('0.00005')), symbolically=True)
|
||||
assert_equal("\\max(\\sqrt{3}, 0, 1)", Max(sqrt(3), 0, 1))
|
||||
|
||||
|
||||
def test_max_fraction():
|
||||
assert_equal("\\max(1/2, 1/4)", Max(Rational('1/2'), Rational('1/4')))
|
||||
assert_equal("\\max(6/2, 3)", Max(Rational('6/2'), 3))
|
||||
assert_equal("\\max(2/4, 1/2)", Max(Rational('2/4'), Rational('1/2')))
|
||||
assert_equal("\\max(-12/5, 6.4)", Max(Rational('-12/5'), Rational('6.4')))
|
||||
assert_equal("\\max(1/10)", Max(Rational('1/10')))
|
||||
assert_equal("\\max(1.5, \\pi/2)", Max(Rational('1.5'), pi / 2, evaluate=False))
|
||||
assert_equal("\\max(-4/3, -2/1, 0/9, -3)", Max(Rational('-4/3'), Rational('-2/1'), Rational('0/9'), -3))
|
||||
|
||||
|
||||
def test_max_expr():
|
||||
assert_equal("\\max((1+6)/3, 7)", Max(Rational(1 + 6, 3), 7))
|
||||
assert_equal("\\max(58*9)", Max(58 * 9))
|
||||
assert_equal("\\max(1+6/3, -5)", Max(1 + Rational('6/3'), -5))
|
||||
assert_equal("\\max(7*4/5, 092) * 2", Max(7 * 4 / 5, 92) * 2)
|
||||
assert_equal("38+\\max(13, 15-2.3)", 38 + Max(13, 15 - Rational('2.3')))
|
||||
assert_equal("\\sqrt{\\max(99.9999999999999, 100)}", sqrt(Max(Rational('99.9999999999999'), 100)))
|
||||
assert_equal("\\max(274/(5+2), \\exp(12.4), 1.4E2)", Max(Rational(274, 5 + 2), exp(Rational('12.4')), Rational('1.4E2')))
|
||||
|
||||
|
||||
def test_max_symbol():
|
||||
assert_equal("\\max(x)", Max(x), symbolically=True)
|
||||
assert_equal("\\max(x, y)", Max(x, y), symbolically=True)
|
||||
assert_equal("\\max(y, x)", Max(y, x), symbolically=True)
|
||||
assert_equal("\\max(x+y, y+x)", Max(x + y, y + x), symbolically=True)
|
||||
assert_equal("\\max(9x/4, z)", Max(9 * x / 4, z), symbolically=True)
|
||||
assert_equal("\\max(y\\pi, 9)", Max(y * pi, 9), symbolically=True)
|
||||
assert_equal("\\max(2y-y, y + 1)", Max(2 * y - y, y + 1), symbolically=True)
|
||||
assert_equal("\\max(z, y, x)", Max(z, y, x), symbolically=True)
|
||||
|
||||
|
||||
def test_max_multiarg():
|
||||
assert_equal("\\max(1,2)", Max(1, 2))
|
||||
assert_equal("\\max(9,876,543)", Max(9, 876, 543))
|
||||
assert_equal("\\max(x, y,z)", Max(x, y, z), symbolically=True)
|
||||
assert_equal("\\max(5.8,7.4, 2.2,-10)", Max(Rational('5.8'), Rational('7.4'), Rational('2.2'), -10))
|
||||
assert_equal("\\max(\\pi,12E2,84,\\sqrt{5},12/5)", Max(pi, Rational('12E2'), 84, sqrt(5), Rational('12/5')))
|
||||
assert_equal("\\max(823,51)", Max(823, 51))
|
||||
assert_equal("\\max(72*4,23, 9)", Max(72 * 4, 23, 9))
|
||||
79
evaluation/eval/tools/latex2sympy/tests/min_test.py
Normal file
79
evaluation/eval/tools/latex2sympy/tests/min_test.py
Normal file
@@ -0,0 +1,79 @@
|
||||
from .context import assert_equal
|
||||
import pytest
|
||||
from sympy import Symbol, Rational, Float, Min, sqrt, exp, pi, nsimplify
|
||||
|
||||
x = Symbol('x', real=True)
|
||||
y = Symbol('y', real=True)
|
||||
z = Symbol('z', real=True)
|
||||
|
||||
|
||||
def test_min_usual():
|
||||
assert_equal("\\min(1, 5)", Min(1, 5))
|
||||
assert_equal("\\min(12, 4)", Min(12, 4))
|
||||
assert_equal("\\min(109, 120)", Min(109, 120))
|
||||
assert_equal("\\min(3, 3)", Min(3, 3))
|
||||
assert_equal("\\min(0, 0)", Min(0, 0))
|
||||
assert_equal("\\min(1)", Min(1))
|
||||
assert_equal("\\min(1092198374, 290348E32)", Min(1092198374, Rational('290348E32')))
|
||||
assert_equal("\\min(5, 2, 17, 4)", Min(5, 2, 17, 4))
|
||||
|
||||
|
||||
def test_min_negative():
|
||||
assert_equal("\\min(-9, 4)", Min(-9, 4))
|
||||
assert_equal("\\min(4, -9)", Min(4, -9))
|
||||
assert_equal("\\min(-7)", Min(-7))
|
||||
assert_equal("\\min(-2, -2)", Min(-2, -2))
|
||||
assert_equal("\\min(-324E-3, -58)", Min(Rational('-324E-3'), -58))
|
||||
assert_equal("\\min(-1, 0, 1, -37, 42)", Min(-1, 0, 1, -37, 42))
|
||||
|
||||
|
||||
def test_min_float():
|
||||
assert_equal("\\min(\\pi, 3)", Min(pi, 3))
|
||||
assert_equal("\\min(1234.56789, 1234.5678901)", Min(Rational('1234.56789'), Rational('1234.5678901')))
|
||||
assert_equal("\\min(12.4, 9.5)", Min(12.4, 9.5))
|
||||
assert_equal("\\min(6, 6.2)", Min(6, 6.2))
|
||||
assert_equal("\\min(-98.7)", Min(-98.7))
|
||||
assert_equal("\\min(7.1, 9)", Min(7.1, 9))
|
||||
assert_equal("\\min(-21E-12, 0.00005)", Min(nsimplify(Rational('-21E-12')), Rational('0.00005')), symbolically=True)
|
||||
assert_equal("\\min(\\sqrt{3}, 0, 1)", Min(sqrt(3), 0, 1))
|
||||
|
||||
|
||||
def test_min_fraction():
|
||||
assert_equal("\\min(1/2, 1/4)", Min(Rational('1/2'), Rational('1/4')))
|
||||
assert_equal("\\min(6/2, 3)", Min(Rational('6/2'), 3))
|
||||
assert_equal("\\min(2/4, 1/2)", Min(Rational('2/4'), Rational('1/2')))
|
||||
assert_equal("\\min(-12/5, 6.4)", Min(Rational('-12/5'), Rational('6.4')))
|
||||
assert_equal("\\min(1/10)", Min(Rational('1/10')))
|
||||
assert_equal("\\min(1.5, \\pi/2)", Min(Rational('1.5'), pi / 2, evaluate=False))
|
||||
assert_equal("\\min(-4/3, -2/1, 0/9, -3)", Min(Rational('-4/3'), Rational('-2/1'), Rational('0/9'), -3))
|
||||
|
||||
|
||||
def test_min_expr():
|
||||
assert_equal("\\min((1+6)/3, 7)", Min(Rational(1 + 6, 3), 7))
|
||||
assert_equal("\\min(58*9)", Min(58 * 9))
|
||||
assert_equal("\\min(1+6/3, -5)", Min(1 + Rational('6/3'), -5))
|
||||
assert_equal("\\min(7*4/5, 092) * 2", Min(7 * 4 / 5, 92) * 2)
|
||||
assert_equal("38+\\min(13, 15-2.3)", 38 + Min(13, 15 - Rational('2.3')))
|
||||
assert_equal("\\sqrt{\\min(99.9999999999999, 100)}", sqrt(Min(Rational('99.9999999999999'), 100)))
|
||||
assert_equal("\\min(274/(5+2), \\exp(12.4), 1.4E2)", Min(Rational(274, 5 + 2), exp(Rational('12.4')), Rational('1.4E2')))
|
||||
|
||||
|
||||
def test_min_symbol():
|
||||
assert_equal("\\min(x)", Min(x), symbolically=True)
|
||||
assert_equal("\\min(x, y)", Min(x, y), symbolically=True)
|
||||
assert_equal("\\min(y, x)", Min(y, x), symbolically=True)
|
||||
assert_equal("\\min(x+y, y+x)", Min(x + y, y + x), symbolically=True)
|
||||
assert_equal("\\min(9x/4, z)", Min(9 * x / 4, z), symbolically=True)
|
||||
assert_equal("\\min(y\\pi, 9)", Min(y * pi, 9), symbolically=True)
|
||||
assert_equal("\\min(2y-y, y + 1)", Min(2 * y - y, y + 1), symbolically=True)
|
||||
assert_equal("\\min(z, y, x)", Min(z, y, x), symbolically=True)
|
||||
|
||||
|
||||
def test_min_multiarg():
|
||||
assert_equal("\\min(1,2)", Min(1, 2))
|
||||
assert_equal("\\min(9,876,543)", Min(9, 876, 543))
|
||||
assert_equal("\\min(x, y,z)", Min(x, y, z), symbolically=True)
|
||||
assert_equal("\\min(5.8,7.4, 2.2,-10)", Min(Rational('5.8'), Rational('7.4'), Rational('2.2'), -10))
|
||||
assert_equal("\\min(\\pi,12E2,84,\\sqrt{5},12/5)", Min(pi, Rational('12E2'), 84, sqrt(5), Rational('12/5')))
|
||||
assert_equal("\\min(823,51)", Min(823, 51))
|
||||
assert_equal("\\min(72*4,23, 9)", Min(72 * 4, 23, 9))
|
||||
70
evaluation/eval/tools/latex2sympy/tests/mod_test.py
Normal file
70
evaluation/eval/tools/latex2sympy/tests/mod_test.py
Normal file
@@ -0,0 +1,70 @@
|
||||
from .context import assert_equal
|
||||
import pytest
|
||||
from sympy import Symbol, Rational, Mod, sqrt, nsimplify, pi, GoldenRatio
|
||||
from sympy.physics.units import hbar
|
||||
|
||||
x = Symbol('x', real=True)
|
||||
y = Symbol('y', real=True)
|
||||
|
||||
|
||||
def test_mod_usual():
|
||||
assert_equal("128\\mod 3", Mod(128, 3))
|
||||
assert_equal("7\\mod 128", Mod(7, 128))
|
||||
assert_equal("5\\mod 10", Mod(5, 10))
|
||||
assert_equal("5\\mod 5", Mod(5, 5))
|
||||
assert_equal("3\\mod 2", Mod(3, 2))
|
||||
assert_equal("0 \\mod 6", Mod(0, 6))
|
||||
assert_equal("6109\\mod 28", Mod(6109, 28))
|
||||
assert_equal("4000000000\\mod 28791", Mod(4000000000, 28791))
|
||||
assert_equal("128*10^300\\mod 876123", Mod(Rational('128E300'), 876123))
|
||||
assert_equal("876,123\\mod 128E300)", Mod(876123, Rational('128E300')))
|
||||
|
||||
|
||||
def test_mod_negative():
|
||||
assert_equal("-1\\mod 2", Mod(-1, 2))
|
||||
assert_equal("-3\\mod 3", Mod(-3, 3))
|
||||
assert_equal("-12\\mod -12", Mod(-12, -12))
|
||||
assert_equal("-128\\mod 4", Mod(-128, 4))
|
||||
assert_equal("9\\mod -213", Mod(9, -213))
|
||||
assert_equal("123123\\mod -541", Mod(123123, -541))
|
||||
assert_equal("-123123\\mod 541", Mod(-123123, 541))
|
||||
assert_equal("-97E34\\mod 7", Mod(Rational('-97E34'), 7))
|
||||
|
||||
|
||||
def test_mod_fraction():
|
||||
assert_equal("1/2\\mod 3", Mod(Rational(1, 2), 3))
|
||||
assert_equal("6/2\\mod 3", Mod(Rational(6, 2), 3))
|
||||
assert_equal("-14/2\\mod 5", Mod(Rational(-14, 2), 5))
|
||||
assert_equal("123\\mod (42/6)", Mod(123, Rational(42, 6)))
|
||||
assert_equal("431\\mod (2/123)", Mod(431, Rational(2, 123)))
|
||||
assert_equal("5/5\\mod (5/5)", Mod(Rational(5, 5), Rational(5, 5)))
|
||||
assert_equal("849/-21\\mod (092/2)", Mod(Rational(849, -21), Rational(92, 2)))
|
||||
assert_equal("13*10^9\\mod (21/-2)", Mod(13E9, Rational(21, -2)))
|
||||
|
||||
|
||||
def test_mod_float():
|
||||
assert_equal("0.41\\mod 2", Mod(Rational('0.41'), 2))
|
||||
assert_equal("143E-13\\mod 21", Mod(Rational('143E-13'), 21))
|
||||
assert_equal("-9.80665\\mod 9.80665", Mod(-9.80665, 9.80665))
|
||||
assert_equal("0.0000923423\\mod -8341.234802909", nsimplify(Mod(0.0000923423, -8341.234802909)))
|
||||
assert_equal("\\sqrt{5}\\mod \\sqrt{2}", Mod(sqrt(5), sqrt(2)))
|
||||
assert_equal("987\\mod \\pi", Mod(987, pi))
|
||||
assert_equal("\\pi\\mod ((1+\\sqrt{5})/2)", Mod(pi, nsimplify(GoldenRatio)), symbolically=True)
|
||||
assert_equal("1234\\mod 1E-29", Mod(1234, Rational('1E-29'), evaluate=False))
|
||||
|
||||
|
||||
def test_mod_expr():
|
||||
assert_equal("1+1\\mod 2", 1 + Mod(1, 2))
|
||||
assert_equal("876123\\mod 128\\times 10^300", Mod(876123, 128) * 1E300)
|
||||
assert_equal("141\\mod 9/3", Rational(Mod(141, 9) / 3))
|
||||
assert_equal("872 / (12\\mod 9 * 4) * 2", Rational(2 * 872, (Mod(12, 9) * 4)))
|
||||
assert_equal("1E-32 * (1E29\\mod 74)", Rational('1E-32') * Mod(Rational('1E29'), 74))
|
||||
assert_equal("299,792,458\\mod 9.81", Mod(299792458, Rational('9.81')))
|
||||
|
||||
|
||||
def test_mod_symbol():
|
||||
assert_equal("x\\mod y", Mod(x, y))
|
||||
assert_equal("2x\\mod y", Mod(2 * x, y))
|
||||
assert_equal("y + 3\\mod 2 / 4", y + Rational(Mod(3, 2), 4), symbolically=True)
|
||||
assert_equal("0.5x * 2 + \\sqrt{x}\\mod 8y", 0.5 * x * 2 + Mod(sqrt(x), 8 * y), symbolically=True)
|
||||
assert_equal("6.673E-11 * ((8.85418782E-12\\mod 9x) + 4) / 2y", Rational('6.673E-11') * (Mod(Rational('8.85418782E-12'), 9 * x) + 4) / (2 * y), symbolically=True)
|
||||
9
evaluation/eval/tools/latex2sympy/tests/overline_test.py
Normal file
9
evaluation/eval/tools/latex2sympy/tests/overline_test.py
Normal file
@@ -0,0 +1,9 @@
|
||||
from .context import assert_equal
|
||||
import pytest
|
||||
from sympy import sin, Symbol
|
||||
|
||||
x = Symbol('x', real=True)
|
||||
|
||||
|
||||
def test_overline():
|
||||
assert_equal("\\frac{\\sin(x)}{\\overline{x}_n}", sin(x) / Symbol('xbar_n', real=True))
|
||||
15
evaluation/eval/tools/latex2sympy/tests/pi_test.py
Normal file
15
evaluation/eval/tools/latex2sympy/tests/pi_test.py
Normal file
@@ -0,0 +1,15 @@
|
||||
from .context import assert_equal, _Mul, _Pow
|
||||
import pytest
|
||||
from sympy import pi, Symbol, acos, cos
|
||||
|
||||
|
||||
def test_pi_frac():
|
||||
assert_equal("\\frac{\\pi}{3}", _Mul(pi, _Pow(3, -1)))
|
||||
|
||||
|
||||
def test_pi_nested():
|
||||
assert_equal("\\arccos{\\cos{\\frac{\\pi}{3}}}", acos(cos(_Mul(pi, _Pow(3, -1)), evaluate=False), evaluate=False))
|
||||
|
||||
|
||||
def test_pi_arccos():
|
||||
assert_equal("\\arccos{-1}", pi, symbolically=True)
|
||||
21
evaluation/eval/tools/latex2sympy/tests/trig_test.py
Normal file
21
evaluation/eval/tools/latex2sympy/tests/trig_test.py
Normal file
@@ -0,0 +1,21 @@
|
||||
from .context import assert_equal
|
||||
import pytest
|
||||
from sympy import asinh, Symbol
|
||||
|
||||
# x = Symbol('x', real=True);
|
||||
|
||||
# latex = "\\sinh(x)"
|
||||
# math = process_sympy(latex)
|
||||
# print("latex: %s to math: %s" %(latex,math))
|
||||
#
|
||||
# latex = "\\arcsinh(x)"
|
||||
# math = process_sympy(latex)
|
||||
# print("latex: %s to math: %s" %(latex,math))
|
||||
#
|
||||
# latex = "\\arsinh(x)"
|
||||
# math = process_sympy(latex)
|
||||
# print("latex: %s to math: %s" %(latex,math))
|
||||
|
||||
|
||||
def test_arcsinh():
|
||||
assert_equal("\\operatorname{arcsinh}\\left(1\\right)", asinh(1, evaluate=False))
|
||||
92
evaluation/eval/tools/latex2sympy/tests/variable_test.py
Normal file
92
evaluation/eval/tools/latex2sympy/tests/variable_test.py
Normal file
@@ -0,0 +1,92 @@
|
||||
from .context import assert_equal
|
||||
import pytest
|
||||
import hashlib
|
||||
from sympy import UnevaluatedExpr, Symbol, Mul, Pow, Max, Min, gcd, lcm, floor, ceiling
|
||||
|
||||
x = Symbol('x', real=True)
|
||||
y = Symbol('y', real=True)
|
||||
|
||||
|
||||
def test_variable_letter():
|
||||
assert_equal("\\variable{x}", Symbol('x' + hashlib.md5('x'.encode()).hexdigest(), real=True))
|
||||
|
||||
|
||||
def test_variable_digit():
|
||||
assert_equal("\\variable{1}", Symbol('1' + hashlib.md5('1'.encode()).hexdigest(), real=True))
|
||||
|
||||
|
||||
def test_variable_letter_subscript():
|
||||
assert_equal("\\variable{x_y}", Symbol('x_y' + hashlib.md5('x_y'.encode()).hexdigest(), real=True))
|
||||
|
||||
|
||||
def test_variable_letter_comma_subscript():
|
||||
assert_equal("\\variable{x_{i,j}}", Symbol('x_{i,j}' + hashlib.md5('x_{i,j}'.encode()).hexdigest(), real=True))
|
||||
|
||||
|
||||
def test_variable_digit_subscript():
|
||||
assert_equal("\\variable{x_1}", Symbol('x_1' + hashlib.md5('x_1'.encode()).hexdigest(), real=True))
|
||||
|
||||
|
||||
def test_variable_after_subscript_required():
|
||||
with pytest.raises(Exception):
|
||||
assert_equal("\\variable{x_}", Symbol('x_' + hashlib.md5('x_'.encode()).hexdigest(), real=True))
|
||||
|
||||
|
||||
def test_variable_before_subscript_required():
|
||||
with pytest.raises(Exception):
|
||||
assert_equal("\\variable{_x}", Symbol('_x' + hashlib.md5('_x'.encode()).hexdigest(), real=True))
|
||||
|
||||
|
||||
def test_variable_bad_name():
|
||||
with pytest.raises(Exception):
|
||||
assert_equal("\\variable{\\sin xy}", None)
|
||||
|
||||
|
||||
def test_variable_in_expr():
|
||||
assert_equal("4\\cdot\\variable{x}", 4 * Symbol('x' + hashlib.md5('x'.encode()).hexdigest(), real=True))
|
||||
|
||||
|
||||
def test_variable_greek_letter():
|
||||
assert_equal("\\variable{\\alpha }\\alpha", Symbol('\\alpha ' + hashlib.md5('\\alpha '.encode()).hexdigest(), real=True) * Symbol('alpha', real=True))
|
||||
|
||||
|
||||
def test_variable_greek_letter_subscript():
|
||||
assert_equal("\\variable{\\alpha _{\\beta }}\\alpha ", Symbol('\\alpha _{\\beta }' + hashlib.md5('\\alpha _{\\beta }'.encode()).hexdigest(), real=True) * Symbol('alpha', real=True))
|
||||
|
||||
|
||||
def test_variable_bad_unbraced_long_subscript():
|
||||
with pytest.raises(Exception):
|
||||
assert_equal("\\variable{x_yz}", None)
|
||||
|
||||
|
||||
def test_variable_bad_unbraced_long_complex_subscript():
|
||||
with pytest.raises(Exception):
|
||||
assert_equal("\\variable{x\\beta 10_y\\alpha 20}", None)
|
||||
|
||||
|
||||
def test_variable_braced_subscript():
|
||||
assert_equal("\\variable{x\\beta 10_{y\\alpha 20}}", Symbol('x\\beta 10_{y\\alpha 20}' + hashlib.md5('x\\beta 10_{y\\alpha 20}'.encode()).hexdigest(), real=True))
|
||||
|
||||
|
||||
def test_variable_complex_expr():
|
||||
assert_equal("4\\cdot\\variable{value1}\\frac{\\variable{value_2}}{\\variable{a}}\\cdot x^2", 4 * Symbol('value1' + hashlib.md5('value1'.encode()).hexdigest(), real=True) * Symbol('value_2' + hashlib.md5('value_2'.encode()).hexdigest(), real=True) / Symbol('a' + hashlib.md5('a'.encode()).hexdigest(), real=True) * x**2)
|
||||
|
||||
|
||||
def test_variable_dollars():
|
||||
assert_equal("\\$\\variable{x}", Symbol('x' + hashlib.md5('x'.encode()).hexdigest(), real=True))
|
||||
|
||||
|
||||
def test_variable_percentage():
|
||||
assert_equal("\\variable{x}\\%", Mul(Symbol('x' + hashlib.md5('x'.encode()).hexdigest(), real=True), Pow(100, -1, evaluate=False), evaluate=False))
|
||||
|
||||
|
||||
def test_variable_single_arg_func():
|
||||
assert_equal("\\floor(\\variable{x})", floor(Symbol('x' + hashlib.md5('x'.encode()).hexdigest(), real=True)))
|
||||
assert_equal("\\ceil(\\variable{x})", ceiling(Symbol('x' + hashlib.md5('x'.encode()).hexdigest(), real=True)))
|
||||
|
||||
|
||||
def test_variable_multi_arg_func():
|
||||
assert_equal("\\gcd(\\variable{x}, \\variable{y})", UnevaluatedExpr(gcd(Symbol('x' + hashlib.md5('x'.encode()).hexdigest(), real=True), Symbol('y' + hashlib.md5('y'.encode()).hexdigest(), real=True))))
|
||||
assert_equal("\\lcm(\\variable{x}, \\variable{y})", UnevaluatedExpr(lcm(Symbol('x' + hashlib.md5('x'.encode()).hexdigest(), real=True), Symbol('y' + hashlib.md5('y'.encode()).hexdigest(), real=True))))
|
||||
assert_equal("\\max(\\variable{x}, \\variable{y})", Max(Symbol('x' + hashlib.md5('x'.encode()).hexdigest(), real=True), Symbol('y' + hashlib.md5('y'.encode()).hexdigest(), real=True), evaluate=False))
|
||||
assert_equal("\\min(\\variable{x}, \\variable{y})", Min(Symbol('x' + hashlib.md5('x'.encode()).hexdigest(), real=True), Symbol('y' + hashlib.md5('y'.encode()).hexdigest(), real=True), evaluate=False))
|
||||
Reference in New Issue
Block a user