Skip to main content

​
UnitParser

class UnitParser:
Class for handling unit parsing and manipulation operations.

​
init

def __init__(self):

​
_load_sympy_units

def _load_sympy_units():
Returns: Dict[str, Any]: Dictionary mapping unit names to their corresponding sympy Quantity objects.

​
_add_si_prefixes

def _add_si_prefixes(self):
Add SI prefixed units (like km, MHz, etc.) to the allowed units.

​
parse_unit

def parse_unit(self, unit_str: str):
Parse a unit string into a SymPy expression using the appropriate method. Parameters:
  • unit_str (str): The unit string to parse.
Returns: Optional[Any]: SymPy expression representing the unit, or None if parsing fails or the unit is dimensionless.

​
parse_unit_with_latex

def parse_unit_with_latex(self, unit_str: str):
Parse a unit string using SymPy’s LaTeX parser. Parameters:
  • unit_str (str): The unit string in LaTeX format.
Returns: Any: SymPy expression representing the unit, or the original string if parsing fails.

​
detect_scaling_factor

def detect_scaling_factor(self, unit_expr: Any):
Detect a scaling factor in the unit expression. Parameters:
  • unit_expr (Any): The unit expression.
Returns: Tuple[Union[int, float, Any], Any]: Tuple of scale factor and base unit.

​
preprocess_unit_string

def preprocess_unit_string(unit_str: str):
Preprocess a unit string to replace ’^’ with ’**’ for exponentiation. Parameters:
  • unit_str (str): The unit string to preprocess.
Returns: str: Preprocessed unit string.

​
unit_is_none

def unit_is_none(unit_str: Optional[str]):
Check if a unit string represents ‘no unit’ or is empty. Parameters:
  • unit_str (Optional[str]): The unit string to check.
Returns: bool: True if the unit is None or represents ‘no unit’.

​
extract_value_and_unit

def extract_value_and_unit(expr: Any):
Extract numerical value and unit components from a SymPy expression. Parameters:
  • expr (Any): SymPy expression with units.
Returns: Tuple[Union[int, float, Any], Any]: Numerical value and unit expression.

​
detect_unit_args

def detect_unit_args(unit_expr: Any):
Extract the base units from a composite SymPy unit expression. Parameters:
  • unit_expr (Any): SymPy expression representing a composite unit.
Returns: List[Any]: List of SymPy base unit components.

​
PhysicsSolutionComparator

class PhysicsSolutionComparator:
Class for compare solutions and reference answers that contains value and units. Parameters:
  • solution (str): The output from running the solution code.
  • reference_answer (str): The reference answer to compare against.
  • float_tolerance (Optional[float], optional): The tolerance for floating point comparisons. (default: :obj:None)

​
init

def __init__(
    self,
    solution: str,
    reference_answer: str,
    float_tolerance: Optional[float] = None
):

​
_split_value_unit

def _split_value_unit(s: str):
Split a string into value and unit components. Handles LaTeX-style units enclosed in dollar signs. Parameters:
  • s (str): The input string.
Returns: Tuple[str, str]: Tuple of (value, unit) as strings.

​
_clean_answer

def _clean_answer(raw_answer: str):
Clean a raw answer string by removing LaTeX formatting. Parameters:
  • raw_answer (str): The raw answer string potentially containing LaTeX formatting.
Returns: str: The cleaned answer string without LaTeX formatting.

​
_parse_expression

def _parse_expression(expr: Any):
Parse an expression into a SymPy expression. Parameters:
  • expr (Any): Expression to parse, can be a string, number, or other type.
Returns: Any: Parsed SymPy expression.

​
_is_number

def _is_number(s: Any):
Check if a value can be converted to a number. Parameters:
  • s (Any): Value to check.
Returns: bool: True if the value can be converted to a number.

​
_detect_tolerance

def _detect_tolerance(default_tolerance: float, value: str):

​
_convert_units

def _convert_units(self):
Convert the solution units to match gt units

​
verify_unit

def verify_unit(sol_unit_expr: Any, gt_unit_expr: Any):

​
compare_solution_to_reference

def compare_solution_to_reference(self):
Returns: VerificationResult with comparison status.

​
_get_value_unit_pairs

def _get_value_unit_pairs(self):

​
_compare_numeric_values

def _compare_numeric_values(self):
Compare numerical values, with unit conversion if needed.

​
_compare_symbolic_values

def _compare_symbolic_values(self):
Compare symbolic expressions for equivalence.

​
PhysicsVerifier

class PhysicsVerifier(PythonVerifier):
The PhysicsVerifier inherits PythonVerifier and makes it able to compare and convert units. Parameters:
  • extractor (Optional[BaseExtractor]): The extractor to use for extracting code from messages. (default: :obj:None)
  • timeout (Optional[float]): The timeout for code execution in seconds. (default: :obj:30.0)
  • required_packages (Optional[List[str]]): The required packages for code execution. (default: :obj:None)
  • float_tolerance (Optional[float]): The relative tolerance used to compare numerical values. (default: :obj:None) **kwargs: Additional keyword arguments to pass to the parent class.

​
init

def __init__(
    self,
    extractor: Optional[BaseExtractor] = None,
    timeout: Optional[float] = 30.0,
    required_packages: Optional[List[str]] = None,
    float_tolerance: Optional[float] = None,
    **kwargs
):