Merge pull request #512 from edx/peterb/formula-preview
Calc module changes: previewing and <formulaequationinput> To see individual commits, see tag peterb/formula-preview/presquash
This commit is contained in:
Peter Baratta
@@ -4,129 +4,105 @@ Parser and evaluator for FormulaResponse and NumericalResponse
|
||||
Uses pyparsing to parse. Main function as of now is evaluator().
|
||||
"""
|
||||
|
||||
import copy
|
||||
import math
|
||||
import operator
|
||||
import re
|
||||
|
||||
import numbers
|
||||
import numpy
|
||||
import scipy.constants
|
||||
import calcfunctions
|
||||
|
||||
# have numpy raise errors on functions outside its domain
|
||||
# Have numpy ignore errors on functions outside its domain.
|
||||
# See http://docs.scipy.org/doc/numpy/reference/generated/numpy.seterr.html
|
||||
# TODO worry about thread safety/changing a global setting
|
||||
numpy.seterr(all='ignore') # Also: 'ignore', 'warn' (default), 'raise'
|
||||
|
||||
from pyparsing import (Word, nums, Literal,
|
||||
ZeroOrMore, MatchFirst,
|
||||
Optional, Forward,
|
||||
CaselessLiteral,
|
||||
stringEnd, Suppress, Combine)
|
||||
from pyparsing import (
|
||||
Word, Literal, CaselessLiteral, ZeroOrMore, MatchFirst, Optional, Forward,
|
||||
Group, ParseResults, stringEnd, Suppress, Combine, alphas, nums, alphanums
|
||||
)
|
||||
|
||||
DEFAULT_FUNCTIONS = {'sin': numpy.sin,
|
||||
'cos': numpy.cos,
|
||||
'tan': numpy.tan,
|
||||
'sec': calcfunctions.sec,
|
||||
'csc': calcfunctions.csc,
|
||||
'cot': calcfunctions.cot,
|
||||
'sqrt': numpy.sqrt,
|
||||
'log10': numpy.log10,
|
||||
'log2': numpy.log2,
|
||||
'ln': numpy.log,
|
||||
'exp': numpy.exp,
|
||||
'arccos': numpy.arccos,
|
||||
'arcsin': numpy.arcsin,
|
||||
'arctan': numpy.arctan,
|
||||
'arcsec': calcfunctions.arcsec,
|
||||
'arccsc': calcfunctions.arccsc,
|
||||
'arccot': calcfunctions.arccot,
|
||||
'abs': numpy.abs,
|
||||
'fact': math.factorial,
|
||||
'factorial': math.factorial,
|
||||
'sinh': numpy.sinh,
|
||||
'cosh': numpy.cosh,
|
||||
'tanh': numpy.tanh,
|
||||
'sech': calcfunctions.sech,
|
||||
'csch': calcfunctions.csch,
|
||||
'coth': calcfunctions.coth,
|
||||
'arcsinh': numpy.arcsinh,
|
||||
'arccosh': numpy.arccosh,
|
||||
'arctanh': numpy.arctanh,
|
||||
'arcsech': calcfunctions.arcsech,
|
||||
'arccsch': calcfunctions.arccsch,
|
||||
'arccoth': calcfunctions.arccoth
|
||||
}
|
||||
DEFAULT_VARIABLES = {'i': numpy.complex(0, 1),
|
||||
'j': numpy.complex(0, 1),
|
||||
'e': numpy.e,
|
||||
'pi': numpy.pi,
|
||||
'k': scipy.constants.k,
|
||||
'c': scipy.constants.c,
|
||||
'T': 298.15,
|
||||
'q': scipy.constants.e
|
||||
}
|
||||
DEFAULT_FUNCTIONS = {
|
||||
'sin': numpy.sin,
|
||||
'cos': numpy.cos,
|
||||
'tan': numpy.tan,
|
||||
'sec': calcfunctions.sec,
|
||||
'csc': calcfunctions.csc,
|
||||
'cot': calcfunctions.cot,
|
||||
'sqrt': numpy.sqrt,
|
||||
'log10': numpy.log10,
|
||||
'log2': numpy.log2,
|
||||
'ln': numpy.log,
|
||||
'exp': numpy.exp,
|
||||
'arccos': numpy.arccos,
|
||||
'arcsin': numpy.arcsin,
|
||||
'arctan': numpy.arctan,
|
||||
'arcsec': calcfunctions.arcsec,
|
||||
'arccsc': calcfunctions.arccsc,
|
||||
'arccot': calcfunctions.arccot,
|
||||
'abs': numpy.abs,
|
||||
'fact': math.factorial,
|
||||
'factorial': math.factorial,
|
||||
'sinh': numpy.sinh,
|
||||
'cosh': numpy.cosh,
|
||||
'tanh': numpy.tanh,
|
||||
'sech': calcfunctions.sech,
|
||||
'csch': calcfunctions.csch,
|
||||
'coth': calcfunctions.coth,
|
||||
'arcsinh': numpy.arcsinh,
|
||||
'arccosh': numpy.arccosh,
|
||||
'arctanh': numpy.arctanh,
|
||||
'arcsech': calcfunctions.arcsech,
|
||||
'arccsch': calcfunctions.arccsch,
|
||||
'arccoth': calcfunctions.arccoth
|
||||
}
|
||||
DEFAULT_VARIABLES = {
|
||||
'i': numpy.complex(0, 1),
|
||||
'j': numpy.complex(0, 1),
|
||||
'e': numpy.e,
|
||||
'pi': numpy.pi,
|
||||
'k': scipy.constants.k, # Boltzmann: 1.3806488e-23 (Joules/Kelvin)
|
||||
'c': scipy.constants.c, # Light Speed: 2.998e8 (m/s)
|
||||
'T': 298.15, # 0 deg C = T Kelvin
|
||||
'q': scipy.constants.e # Fund. Charge: 1.602176565e-19 (Coulombs)
|
||||
}
|
||||
|
||||
# We eliminated the following extreme suffixes:
|
||||
# P (1e15), E (1e18), Z (1e21), Y (1e24),
|
||||
# f (1e-15), a (1e-18), z (1e-21), y (1e-24)
|
||||
# since they're rarely used, and potentially
|
||||
# confusing. They may also conflict with variables if we ever allow e.g.
|
||||
# 5R instead of 5*R
|
||||
SUFFIXES = {'%': 0.01, 'k': 1e3, 'M': 1e6, 'G': 1e9, 'T': 1e12,
|
||||
'c': 1e-2, 'm': 1e-3, 'u': 1e-6, 'n': 1e-9, 'p': 1e-12}
|
||||
# P (1e15), E (1e18), Z (1e21), Y (1e24),
|
||||
# f (1e-15), a (1e-18), z (1e-21), y (1e-24)
|
||||
# since they're rarely used, and potentially confusing.
|
||||
# They may also conflict with variables if we ever allow e.g.
|
||||
# 5R instead of 5*R
|
||||
SUFFIXES = {
|
||||
'%': 0.01, 'k': 1e3, 'M': 1e6, 'G': 1e9, 'T': 1e12,
|
||||
'c': 1e-2, 'm': 1e-3, 'u': 1e-6, 'n': 1e-9, 'p': 1e-12
|
||||
}
|
||||
|
||||
|
||||
class UndefinedVariable(Exception):
|
||||
"""
|
||||
Used to indicate the student input of a variable, which was unused by the
|
||||
instructor.
|
||||
Indicate when a student inputs a variable which was not expected.
|
||||
"""
|
||||
pass
|
||||
|
||||
|
||||
def check_variables(string, variables):
|
||||
"""
|
||||
Confirm the only variables in string are defined.
|
||||
|
||||
Otherwise, raise an UndefinedVariable containing all bad variables.
|
||||
|
||||
Pyparsing uses a left-to-right parser, which makes a more
|
||||
elegant approach pretty hopeless.
|
||||
"""
|
||||
general_whitespace = re.compile('[^\\w]+') # TODO consider non-ascii
|
||||
# List of all alnums in string
|
||||
possible_variables = re.split(general_whitespace, string)
|
||||
bad_variables = []
|
||||
for var in possible_variables:
|
||||
if len(var) == 0:
|
||||
continue
|
||||
if var[0].isdigit(): # Skip things that begin with numbers
|
||||
continue
|
||||
if var not in variables:
|
||||
bad_variables.append(var)
|
||||
if len(bad_variables) > 0:
|
||||
raise UndefinedVariable(' '.join(bad_variables))
|
||||
|
||||
|
||||
def lower_dict(input_dict):
|
||||
"""
|
||||
takes each key in the dict and makes it lowercase, still mapping to the
|
||||
same value.
|
||||
Convert all keys in a dictionary to lowercase; keep their original values.
|
||||
|
||||
keep in mind that it is possible (but not useful?) to define different
|
||||
Keep in mind that it is possible (but not useful?) to define different
|
||||
variables that have the same lowercase representation. It would be hard to
|
||||
tell which is used in the final dict and which isn't.
|
||||
"""
|
||||
return {k.lower(): v for k, v in input_dict.iteritems()}
|
||||
|
||||
|
||||
# The following few functions define parse actions, which are run on lists of
|
||||
# results from each parse component. They convert the strings and (previously
|
||||
# The following few functions define evaluation actions, which are run on lists
|
||||
# of results from each parse component. They convert the strings and (previously
|
||||
# calculated) numbers into the number that component represents.
|
||||
|
||||
def super_float(text):
|
||||
"""
|
||||
Like float, but with si extensions. 1k goes to 1000
|
||||
Like float, but with SI extensions. 1k goes to 1000.
|
||||
"""
|
||||
if text[-1] in SUFFIXES:
|
||||
return float(text[:-1]) * SUFFIXES[text[-1]]
|
||||
@@ -134,168 +110,314 @@ def super_float(text):
|
||||
return float(text)
|
||||
|
||||
|
||||
def number_parse_action(parse_result):
|
||||
def eval_number(parse_result):
|
||||
"""
|
||||
Create a float out of its string parts
|
||||
Create a float out of its string parts.
|
||||
|
||||
e.g. [ '7', '.', '13' ] -> [ 7.13 ]
|
||||
Calls super_float above
|
||||
e.g. [ '7.13', 'e', '3' ] -> 7130
|
||||
Calls super_float above.
|
||||
"""
|
||||
return super_float("".join(parse_result))
|
||||
|
||||
|
||||
def exp_parse_action(parse_result):
|
||||
def eval_atom(parse_result):
|
||||
"""
|
||||
Take a list of numbers and exponentiate them, right to left
|
||||
Return the value wrapped by the atom.
|
||||
|
||||
e.g. [ 3, 2, 3 ] (which is 3^2^3 = 3^(2^3)) -> 6561
|
||||
In the case of parenthesis, ignore them.
|
||||
"""
|
||||
# pyparsing.ParseResults doesn't play well with reverse()
|
||||
parse_result = reversed(parse_result)
|
||||
# the result of an exponentiation is called a power
|
||||
# Find first number in the list
|
||||
result = next(k for k in parse_result if isinstance(k, numbers.Number))
|
||||
return result
|
||||
|
||||
|
||||
def eval_power(parse_result):
|
||||
"""
|
||||
Take a list of numbers and exponentiate them, right to left.
|
||||
|
||||
e.g. [ 2, 3, 2 ] -> 2^3^2 = 2^(3^2) -> 512
|
||||
(not to be interpreted (2^3)^2 = 64)
|
||||
"""
|
||||
# `reduce` will go from left to right; reverse the list.
|
||||
parse_result = reversed(
|
||||
[k for k in parse_result
|
||||
if isinstance(k, numbers.Number)] # Ignore the '^' marks.
|
||||
)
|
||||
# Having reversed it, raise `b` to the power of `a`.
|
||||
power = reduce(lambda a, b: b ** a, parse_result)
|
||||
return power
|
||||
|
||||
|
||||
def parallel(parse_result):
|
||||
def eval_parallel(parse_result):
|
||||
"""
|
||||
Compute numbers according to the parallel resistors operator
|
||||
Compute numbers according to the parallel resistors operator.
|
||||
|
||||
BTW it is commutative. Its formula is given by
|
||||
out = 1 / (1/in1 + 1/in2 + ...)
|
||||
e.g. [ 1, 2 ] => 2/3
|
||||
e.g. [ 1, 2 ] -> 2/3
|
||||
|
||||
Return NaN if there is a zero among the inputs
|
||||
Return NaN if there is a zero among the inputs.
|
||||
"""
|
||||
# convert from pyparsing.ParseResults, which doesn't support '0 in parse_result'
|
||||
parse_result = parse_result.asList()
|
||||
if len(parse_result) == 1:
|
||||
return parse_result[0]
|
||||
if 0 in parse_result:
|
||||
return float('nan')
|
||||
reciprocals = [1. / e for e in parse_result]
|
||||
reciprocals = [1. / e for e in parse_result
|
||||
if isinstance(e, numbers.Number)]
|
||||
return 1. / sum(reciprocals)
|
||||
|
||||
|
||||
def sum_parse_action(parse_result):
|
||||
def eval_sum(parse_result):
|
||||
"""
|
||||
Add the inputs
|
||||
Add the inputs, keeping in mind their sign.
|
||||
|
||||
[ 1, '+', 2, '-', 3 ] -> 0
|
||||
|
||||
Allow a leading + or -
|
||||
Allow a leading + or -.
|
||||
"""
|
||||
total = 0.0
|
||||
current_op = operator.add
|
||||
for token in parse_result:
|
||||
if token is '+':
|
||||
if token == '+':
|
||||
current_op = operator.add
|
||||
elif token is '-':
|
||||
elif token == '-':
|
||||
current_op = operator.sub
|
||||
else:
|
||||
total = current_op(total, token)
|
||||
return total
|
||||
|
||||
|
||||
def prod_parse_action(parse_result):
|
||||
def eval_product(parse_result):
|
||||
"""
|
||||
Multiply the inputs
|
||||
Multiply the inputs.
|
||||
|
||||
[ 1, '*', 2, '/', 3 ] => 0.66
|
||||
[ 1, '*', 2, '/', 3 ] -> 0.66
|
||||
"""
|
||||
prod = 1.0
|
||||
current_op = operator.mul
|
||||
for token in parse_result:
|
||||
if token is '*':
|
||||
if token == '*':
|
||||
current_op = operator.mul
|
||||
elif token is '/':
|
||||
elif token == '/':
|
||||
current_op = operator.truediv
|
||||
else:
|
||||
prod = current_op(prod, token)
|
||||
return prod
|
||||
|
||||
|
||||
def evaluator(variables, functions, string, cs=False):
|
||||
def add_defaults(variables, functions, case_sensitive):
|
||||
"""
|
||||
Evaluate an expression. Variables are passed as a dictionary
|
||||
from string to value. Unary functions are passed as a dictionary
|
||||
from string to function. Variables must be floats.
|
||||
cs: Case sensitive
|
||||
|
||||
Create dictionaries with both the default and user-defined variables.
|
||||
"""
|
||||
|
||||
all_variables = copy.copy(DEFAULT_VARIABLES)
|
||||
all_functions = copy.copy(DEFAULT_FUNCTIONS)
|
||||
all_variables = dict(DEFAULT_VARIABLES)
|
||||
all_functions = dict(DEFAULT_FUNCTIONS)
|
||||
all_variables.update(variables)
|
||||
all_functions.update(functions)
|
||||
|
||||
if not cs:
|
||||
string_cs = string.lower()
|
||||
all_functions = lower_dict(all_functions)
|
||||
if not case_sensitive:
|
||||
all_variables = lower_dict(all_variables)
|
||||
CasedLiteral = CaselessLiteral
|
||||
else:
|
||||
string_cs = string
|
||||
CasedLiteral = Literal
|
||||
all_functions = lower_dict(all_functions)
|
||||
|
||||
check_variables(string_cs, set(all_variables.keys() + all_functions.keys()))
|
||||
return (all_variables, all_functions)
|
||||
|
||||
if string.strip() == "":
|
||||
|
||||
def evaluator(variables, functions, math_expr, case_sensitive=False):
|
||||
"""
|
||||
Evaluate an expression; that is, take a string of math and return a float.
|
||||
|
||||
-Variables are passed as a dictionary from string to value. They must be
|
||||
python numbers.
|
||||
-Unary functions are passed as a dictionary from string to function.
|
||||
"""
|
||||
# No need to go further.
|
||||
if math_expr.strip() == "":
|
||||
return float('nan')
|
||||
|
||||
# SI suffixes and percent
|
||||
number_suffix = MatchFirst([Literal(k) for k in SUFFIXES.keys()])
|
||||
plus_minus = Literal('+') | Literal('-')
|
||||
times_div = Literal('*') | Literal('/')
|
||||
# Parse the tree.
|
||||
math_interpreter = ParseAugmenter(math_expr, case_sensitive)
|
||||
math_interpreter.parse_algebra()
|
||||
|
||||
number_part = Word(nums)
|
||||
# Get our variables together.
|
||||
all_variables, all_functions = add_defaults(variables, functions, case_sensitive)
|
||||
|
||||
# 0.33 or 7 or .34 or 16.
|
||||
inner_number = (number_part + Optional("." + Optional(number_part))) | ("." + number_part)
|
||||
# by default pyparsing allows spaces between tokens--Combine prevents that
|
||||
inner_number = Combine(inner_number)
|
||||
# ...and check them
|
||||
math_interpreter.check_variables(all_variables, all_functions)
|
||||
|
||||
# 0.33k or -17
|
||||
number = (inner_number
|
||||
+ Optional(CaselessLiteral("E") + Optional(plus_minus) + number_part)
|
||||
+ Optional(number_suffix))
|
||||
number.setParseAction(number_parse_action) # Convert to number
|
||||
# Create a recursion to evaluate the tree.
|
||||
if case_sensitive:
|
||||
casify = lambda x: x
|
||||
else:
|
||||
casify = lambda x: x.lower() # Lowercase for case insens.
|
||||
|
||||
# Predefine recursive variables
|
||||
expr = Forward()
|
||||
evaluate_actions = {
|
||||
'number': eval_number,
|
||||
'variable': lambda x: all_variables[casify(x[0])],
|
||||
'function': lambda x: all_functions[casify(x[0])](x[1]),
|
||||
'atom': eval_atom,
|
||||
'power': eval_power,
|
||||
'parallel': eval_parallel,
|
||||
'product': eval_product,
|
||||
'sum': eval_sum
|
||||
}
|
||||
|
||||
# Handle variables passed in.
|
||||
# E.g. if we have {'R':0.5}, we make the substitution.
|
||||
# We sort the list so that var names (like "e2") match before
|
||||
# mathematical constants (like "e"). This is kind of a hack.
|
||||
all_variables_keys = sorted(all_variables.keys(), key=len, reverse=True)
|
||||
varnames = MatchFirst([CasedLiteral(k) for k in all_variables_keys])
|
||||
varnames.setParseAction(
|
||||
lambda x: [all_variables[k] for k in x]
|
||||
)
|
||||
return math_interpreter.reduce_tree(evaluate_actions)
|
||||
|
||||
# if all_variables were empty, then pyparsing wants
|
||||
# varnames = NoMatch()
|
||||
# this is not the case, as all_variables contains the defaults
|
||||
|
||||
# Same thing for functions.
|
||||
all_functions_keys = sorted(all_functions.keys(), key=len, reverse=True)
|
||||
funcnames = MatchFirst([CasedLiteral(k) for k in all_functions_keys])
|
||||
function = funcnames + Suppress("(") + expr + Suppress(")")
|
||||
function.setParseAction(
|
||||
lambda x: [all_functions[x[0]](x[1])]
|
||||
)
|
||||
class ParseAugmenter(object):
|
||||
"""
|
||||
Holds the data for a particular parse.
|
||||
|
||||
atom = number | function | varnames | Suppress("(") + expr + Suppress(")")
|
||||
Retains the `math_expr` and `case_sensitive` so they needn't be passed
|
||||
around method to method.
|
||||
Eventually holds the parse tree and sets of variables as well.
|
||||
"""
|
||||
def __init__(self, math_expr, case_sensitive=False):
|
||||
"""
|
||||
Create the ParseAugmenter for a given math expression string.
|
||||
|
||||
# Do the following in the correct order to preserve order of operation
|
||||
pow_term = atom + ZeroOrMore(Suppress("^") + atom)
|
||||
pow_term.setParseAction(exp_parse_action) # 7^6
|
||||
par_term = pow_term + ZeroOrMore(Suppress('||') + pow_term) # 5k || 4k
|
||||
par_term.setParseAction(parallel)
|
||||
prod_term = par_term + ZeroOrMore(times_div + par_term) # 7 * 5 / 4 - 3
|
||||
prod_term.setParseAction(prod_parse_action)
|
||||
sum_term = Optional(plus_minus) + prod_term + ZeroOrMore(plus_minus + prod_term) # -5 + 4 - 3
|
||||
sum_term.setParseAction(sum_parse_action)
|
||||
expr << sum_term # finish the recursion
|
||||
return (expr + stringEnd).parseString(string)[0]
|
||||
Do the parsing later, when called like `OBJ.parse_algebra()`.
|
||||
"""
|
||||
self.case_sensitive = case_sensitive
|
||||
self.math_expr = math_expr
|
||||
self.tree = None
|
||||
self.variables_used = set()
|
||||
self.functions_used = set()
|
||||
|
||||
def vpa(tokens):
|
||||
"""
|
||||
When a variable is recognized, store it in `variables_used`.
|
||||
"""
|
||||
varname = tokens[0][0]
|
||||
self.variables_used.add(varname)
|
||||
|
||||
def fpa(tokens):
|
||||
"""
|
||||
When a function is recognized, store it in `functions_used`.
|
||||
"""
|
||||
varname = tokens[0][0]
|
||||
self.functions_used.add(varname)
|
||||
|
||||
self.variable_parse_action = vpa
|
||||
self.function_parse_action = fpa
|
||||
|
||||
def parse_algebra(self):
|
||||
"""
|
||||
Parse an algebraic expression into a tree.
|
||||
|
||||
Store a `pyparsing.ParseResult` in `self.tree` with proper groupings to
|
||||
reflect parenthesis and order of operations. Leave all operators in the
|
||||
tree and do not parse any strings of numbers into their float versions.
|
||||
|
||||
Adding the groups and result names makes the `repr()` of the result
|
||||
really gross. For debugging, use something like
|
||||
print OBJ.tree.asXML()
|
||||
"""
|
||||
# 0.33 or 7 or .34 or 16.
|
||||
number_part = Word(nums)
|
||||
inner_number = (number_part + Optional("." + Optional(number_part))) | ("." + number_part)
|
||||
# pyparsing allows spaces between tokens--`Combine` prevents that.
|
||||
inner_number = Combine(inner_number)
|
||||
|
||||
# SI suffixes and percent.
|
||||
number_suffix = MatchFirst(Literal(k) for k in SUFFIXES.keys())
|
||||
|
||||
# 0.33k or 17
|
||||
plus_minus = Literal('+') | Literal('-')
|
||||
number = Group(
|
||||
Optional(plus_minus) +
|
||||
inner_number +
|
||||
Optional(CaselessLiteral("E") + Optional(plus_minus) + number_part) +
|
||||
Optional(number_suffix)
|
||||
)
|
||||
number = number("number")
|
||||
|
||||
# Predefine recursive variables.
|
||||
expr = Forward()
|
||||
|
||||
# Handle variables passed in. They must start with letters/underscores
|
||||
# and may contain numbers afterward.
|
||||
inner_varname = Word(alphas + "_", alphanums + "_")
|
||||
varname = Group(inner_varname)("variable")
|
||||
varname.setParseAction(self.variable_parse_action)
|
||||
|
||||
# Same thing for functions.
|
||||
function = Group(inner_varname + Suppress("(") + expr + Suppress(")"))("function")
|
||||
function.setParseAction(self.function_parse_action)
|
||||
|
||||
atom = number | function | varname | "(" + expr + ")"
|
||||
atom = Group(atom)("atom")
|
||||
|
||||
# Do the following in the correct order to preserve order of operation.
|
||||
pow_term = atom + ZeroOrMore("^" + atom)
|
||||
pow_term = Group(pow_term)("power")
|
||||
|
||||
par_term = pow_term + ZeroOrMore('||' + pow_term) # 5k || 4k
|
||||
par_term = Group(par_term)("parallel")
|
||||
|
||||
prod_term = par_term + ZeroOrMore((Literal('*') | Literal('/')) + par_term) # 7 * 5 / 4
|
||||
prod_term = Group(prod_term)("product")
|
||||
|
||||
sum_term = Optional(plus_minus) + prod_term + ZeroOrMore(plus_minus + prod_term) # -5 + 4 - 3
|
||||
sum_term = Group(sum_term)("sum")
|
||||
|
||||
# Finish the recursion.
|
||||
expr << sum_term # pylint: disable=W0104
|
||||
self.tree = (expr + stringEnd).parseString(self.math_expr)[0]
|
||||
|
||||
def reduce_tree(self, handle_actions, terminal_converter=None):
|
||||
"""
|
||||
Call `handle_actions` recursively on `self.tree` and return result.
|
||||
|
||||
`handle_actions` is a dictionary of node names (e.g. 'product', 'sum',
|
||||
etc&) to functions. These functions are of the following form:
|
||||
-input: a list of processed child nodes. If it includes any terminal
|
||||
nodes in the list, they will be given as their processed forms also.
|
||||
-output: whatever to be passed to the level higher, and what to
|
||||
return for the final node.
|
||||
`terminal_converter` is a function that takes in a token and returns a
|
||||
processed form. The default of `None` just leaves them as strings.
|
||||
"""
|
||||
def handle_node(node):
|
||||
"""
|
||||
Return the result representing the node, using recursion.
|
||||
|
||||
Call the appropriate `handle_action` for this node. As its inputs,
|
||||
feed it the output of `handle_node` for each child node.
|
||||
"""
|
||||
if not isinstance(node, ParseResults):
|
||||
# Then treat it as a terminal node.
|
||||
if terminal_converter is None:
|
||||
return node
|
||||
else:
|
||||
return terminal_converter(node)
|
||||
|
||||
node_name = node.getName()
|
||||
if node_name not in handle_actions: # pragma: no cover
|
||||
raise Exception(u"Unknown branch name '{}'".format(node_name))
|
||||
|
||||
action = handle_actions[node_name]
|
||||
handled_kids = [handle_node(k) for k in node]
|
||||
return action(handled_kids)
|
||||
|
||||
# Find the value of the entire tree.
|
||||
return handle_node(self.tree)
|
||||
|
||||
def check_variables(self, valid_variables, valid_functions):
|
||||
"""
|
||||
Confirm that all the variables used in the tree are valid/defined.
|
||||
|
||||
Otherwise, raise an UndefinedVariable containing all bad variables.
|
||||
"""
|
||||
if self.case_sensitive:
|
||||
casify = lambda x: x
|
||||
else:
|
||||
casify = lambda x: x.lower() # Lowercase for case insens.
|
||||
|
||||
# Test if casify(X) is valid, but return the actual bad input (i.e. X)
|
||||
bad_vars = set(var for var in self.variables_used
|
||||
if casify(var) not in valid_variables)
|
||||
bad_vars.update(func for func in self.functions_used
|
||||
if casify(func) not in valid_functions)
|
||||
|
||||
if bad_vars:
|
||||
raise UndefinedVariable(' '.join(sorted(bad_vars)))
|
||||
|
||||
390
common/lib/calc/preview.py
Normal file
390
common/lib/calc/preview.py
Normal file
@@ -0,0 +1,390 @@
|
||||
"""
|
||||
Provide a `latex_preview` method similar in syntax to `evaluator`.
|
||||
|
||||
That is, given a math string, parse it and render each branch of the result,
|
||||
always returning valid latex.
|
||||
|
||||
Because intermediate values of the render contain more data than simply the
|
||||
string of latex, store it in a custom class `LatexRendered`.
|
||||
"""
|
||||
|
||||
from calc import ParseAugmenter, DEFAULT_VARIABLES, DEFAULT_FUNCTIONS, SUFFIXES
|
||||
|
||||
|
||||
class LatexRendered(object):
|
||||
"""
|
||||
Data structure to hold a typeset representation of some math.
|
||||
|
||||
Fields:
|
||||
-`latex` is a generated, valid latex string (as if it were standalone).
|
||||
-`sans_parens` is usually the same as `latex` except without the outermost
|
||||
parens (if applicable).
|
||||
-`tall` is a boolean representing if the latex has any elements extending
|
||||
above or below a normal height, specifically things of the form 'a^b' and
|
||||
'\frac{a}{b}'. This affects the height of wrapping parenthesis.
|
||||
"""
|
||||
def __init__(self, latex, parens=None, tall=False):
|
||||
"""
|
||||
Instantiate with the latex representing the math.
|
||||
|
||||
Optionally include parenthesis to wrap around it and the height.
|
||||
`parens` must be one of '(', '[' or '{'.
|
||||
`tall` is a boolean (see note above).
|
||||
"""
|
||||
self.latex = latex
|
||||
self.sans_parens = latex
|
||||
self.tall = tall
|
||||
|
||||
# Generate parens and overwrite `self.latex`.
|
||||
if parens is not None:
|
||||
left_parens = parens
|
||||
if left_parens == '{':
|
||||
left_parens = r'\{'
|
||||
|
||||
pairs = {'(': ')',
|
||||
'[': ']',
|
||||
r'\{': r'\}'}
|
||||
if left_parens not in pairs:
|
||||
raise Exception(
|
||||
u"Unknown parenthesis '{}': coder error".format(left_parens)
|
||||
)
|
||||
right_parens = pairs[left_parens]
|
||||
|
||||
if self.tall:
|
||||
left_parens = r"\left" + left_parens
|
||||
right_parens = r"\right" + right_parens
|
||||
|
||||
self.latex = u"{left}{expr}{right}".format(
|
||||
left=left_parens,
|
||||
expr=latex,
|
||||
right=right_parens
|
||||
)
|
||||
|
||||
def __repr__(self): # pragma: no cover
|
||||
"""
|
||||
Give a sensible representation of the object.
|
||||
|
||||
If `sans_parens` is different, include both.
|
||||
If `tall` then have '<[]>' around the code, otherwise '<>'.
|
||||
"""
|
||||
if self.latex == self.sans_parens:
|
||||
latex_repr = u'"{}"'.format(self.latex)
|
||||
else:
|
||||
latex_repr = u'"{}" or "{}"'.format(self.latex, self.sans_parens)
|
||||
|
||||
if self.tall:
|
||||
wrap = u'<[{}]>'
|
||||
else:
|
||||
wrap = u'<{}>'
|
||||
|
||||
return wrap.format(latex_repr)
|
||||
|
||||
|
||||
def render_number(children):
|
||||
"""
|
||||
Combine the elements forming the number, escaping the suffix if needed.
|
||||
"""
|
||||
children_latex = [k.latex for k in children]
|
||||
|
||||
suffix = ""
|
||||
if children_latex[-1] in SUFFIXES:
|
||||
suffix = children_latex.pop()
|
||||
suffix = ur"\text{{{s}}}".format(s=suffix)
|
||||
|
||||
# Exponential notation-- the "E" splits the mantissa and exponent
|
||||
if "E" in children_latex:
|
||||
pos = children_latex.index("E")
|
||||
mantissa = "".join(children_latex[:pos])
|
||||
exponent = "".join(children_latex[pos + 1:])
|
||||
latex = ur"{m}\!\times\!10^{{{e}}}{s}".format(
|
||||
m=mantissa, e=exponent, s=suffix
|
||||
)
|
||||
return LatexRendered(latex, tall=True)
|
||||
else:
|
||||
easy_number = "".join(children_latex)
|
||||
return LatexRendered(easy_number + suffix)
|
||||
|
||||
|
||||
def enrich_varname(varname):
|
||||
"""
|
||||
Prepend a backslash if we're given a greek character.
|
||||
"""
|
||||
greek = ("alpha beta gamma delta epsilon varepsilon zeta eta theta "
|
||||
"vartheta iota kappa lambda mu nu xi pi rho sigma tau upsilon "
|
||||
"phi varphi chi psi omega").split()
|
||||
|
||||
if varname in greek:
|
||||
return ur"\{letter}".format(letter=varname)
|
||||
else:
|
||||
return varname.replace("_", r"\_")
|
||||
|
||||
|
||||
def variable_closure(variables, casify):
|
||||
"""
|
||||
Wrap `render_variable` so it knows the variables allowed.
|
||||
"""
|
||||
def render_variable(children):
|
||||
"""
|
||||
Replace greek letters, otherwise escape the variable names.
|
||||
"""
|
||||
varname = children[0].latex
|
||||
if casify(varname) not in variables:
|
||||
pass # TODO turn unknown variable red or give some kind of error
|
||||
|
||||
first, _, second = varname.partition("_")
|
||||
|
||||
if second:
|
||||
# Then 'a_b' must become 'a_{b}'
|
||||
varname = ur"{a}_{{{b}}}".format(
|
||||
a=enrich_varname(first),
|
||||
b=enrich_varname(second)
|
||||
)
|
||||
else:
|
||||
varname = enrich_varname(varname)
|
||||
|
||||
return LatexRendered(varname) # .replace("_", r"\_"))
|
||||
return render_variable
|
||||
|
||||
|
||||
def function_closure(functions, casify):
|
||||
"""
|
||||
Wrap `render_function` so it knows the functions allowed.
|
||||
"""
|
||||
def render_function(children):
|
||||
"""
|
||||
Escape function names and give proper formatting to exceptions.
|
||||
|
||||
The exceptions being 'sqrt', 'log2', and 'log10' as of now.
|
||||
"""
|
||||
fname = children[0].latex
|
||||
if casify(fname) not in functions:
|
||||
pass # TODO turn unknown function red or give some kind of error
|
||||
|
||||
# Wrap the input of the function with parens or braces.
|
||||
inner = children[1].latex
|
||||
if fname == "sqrt":
|
||||
inner = u"{{{expr}}}".format(expr=inner)
|
||||
else:
|
||||
if children[1].tall:
|
||||
inner = ur"\left({expr}\right)".format(expr=inner)
|
||||
else:
|
||||
inner = u"({expr})".format(expr=inner)
|
||||
|
||||
# Correctly format the name of the function.
|
||||
if fname == "sqrt":
|
||||
fname = ur"\sqrt"
|
||||
elif fname == "log10":
|
||||
fname = ur"\log_{10}"
|
||||
elif fname == "log2":
|
||||
fname = ur"\log_2"
|
||||
else:
|
||||
fname = ur"\text{{{fname}}}".format(fname=fname)
|
||||
|
||||
# Put it together.
|
||||
latex = fname + inner
|
||||
return LatexRendered(latex, tall=children[1].tall)
|
||||
# Return the function within the closure.
|
||||
return render_function
|
||||
|
||||
|
||||
def render_power(children):
|
||||
"""
|
||||
Combine powers so that the latex is wrapped in curly braces correctly.
|
||||
|
||||
Also, if you have 'a^(b+c)' don't include that last set of parens:
|
||||
'a^{b+c}' is correct, whereas 'a^{(b+c)}' is extraneous.
|
||||
"""
|
||||
if len(children) == 1:
|
||||
return children[0]
|
||||
|
||||
children_latex = [k.latex for k in children if k.latex != "^"]
|
||||
children_latex[-1] = children[-1].sans_parens
|
||||
|
||||
raise_power = lambda x, y: u"{}^{{{}}}".format(y, x)
|
||||
latex = reduce(raise_power, reversed(children_latex))
|
||||
return LatexRendered(latex, tall=True)
|
||||
|
||||
|
||||
def render_parallel(children):
|
||||
"""
|
||||
Simply join the child nodes with a double vertical line.
|
||||
"""
|
||||
if len(children) == 1:
|
||||
return children[0]
|
||||
|
||||
children_latex = [k.latex for k in children if k.latex != "||"]
|
||||
latex = r"\|".join(children_latex)
|
||||
tall = any(k.tall for k in children)
|
||||
return LatexRendered(latex, tall=tall)
|
||||
|
||||
|
||||
def render_frac(numerator, denominator):
|
||||
r"""
|
||||
Given a list of elements in the numerator and denominator, return a '\frac'
|
||||
|
||||
Avoid parens if they are unnecessary (i.e. the only thing in that part).
|
||||
"""
|
||||
if len(numerator) == 1:
|
||||
num_latex = numerator[0].sans_parens
|
||||
else:
|
||||
num_latex = r"\cdot ".join(k.latex for k in numerator)
|
||||
|
||||
if len(denominator) == 1:
|
||||
den_latex = denominator[0].sans_parens
|
||||
else:
|
||||
den_latex = r"\cdot ".join(k.latex for k in denominator)
|
||||
|
||||
latex = ur"\frac{{{num}}}{{{den}}}".format(num=num_latex, den=den_latex)
|
||||
return latex
|
||||
|
||||
|
||||
def render_product(children):
|
||||
r"""
|
||||
Format products and division nicely.
|
||||
|
||||
Group bunches of adjacent, equal operators. Every time it switches from
|
||||
denominator to the next numerator, call `render_frac`. Join these groupings
|
||||
together with '\cdot's, ending on a numerator if needed.
|
||||
|
||||
Examples: (`children` is formed indirectly by the string on the left)
|
||||
'a*b' -> 'a\cdot b'
|
||||
'a/b' -> '\frac{a}{b}'
|
||||
'a*b/c/d' -> '\frac{a\cdot b}{c\cdot d}'
|
||||
'a/b*c/d*e' -> '\frac{a}{b}\cdot \frac{c}{d}\cdot e'
|
||||
"""
|
||||
if len(children) == 1:
|
||||
return children[0]
|
||||
|
||||
position = "numerator" # or denominator
|
||||
fraction_mode_ever = False
|
||||
numerator = []
|
||||
denominator = []
|
||||
latex = ""
|
||||
|
||||
for kid in children:
|
||||
if position == "numerator":
|
||||
if kid.latex == "*":
|
||||
pass # Don't explicitly add the '\cdot' yet.
|
||||
elif kid.latex == "/":
|
||||
# Switch to denominator mode.
|
||||
fraction_mode_ever = True
|
||||
position = "denominator"
|
||||
else:
|
||||
numerator.append(kid)
|
||||
else:
|
||||
if kid.latex == "*":
|
||||
# Switch back to numerator mode.
|
||||
# First, render the current fraction and add it to the latex.
|
||||
latex += render_frac(numerator, denominator) + r"\cdot "
|
||||
|
||||
# Reset back to beginning state
|
||||
position = "numerator"
|
||||
numerator = []
|
||||
denominator = []
|
||||
elif kid.latex == "/":
|
||||
pass # Don't explicitly add a '\frac' yet.
|
||||
else:
|
||||
denominator.append(kid)
|
||||
|
||||
# Add the fraction/numerator that we ended on.
|
||||
if position == "denominator":
|
||||
latex += render_frac(numerator, denominator)
|
||||
else:
|
||||
# We ended on a numerator--act like normal multiplication.
|
||||
num_latex = r"\cdot ".join(k.latex for k in numerator)
|
||||
latex += num_latex
|
||||
|
||||
tall = fraction_mode_ever or any(k.tall for k in children)
|
||||
return LatexRendered(latex, tall=tall)
|
||||
|
||||
|
||||
def render_sum(children):
|
||||
"""
|
||||
Concatenate elements, including the operators.
|
||||
"""
|
||||
if len(children) == 1:
|
||||
return children[0]
|
||||
|
||||
children_latex = [k.latex for k in children]
|
||||
latex = "".join(children_latex)
|
||||
tall = any(k.tall for k in children)
|
||||
return LatexRendered(latex, tall=tall)
|
||||
|
||||
|
||||
def render_atom(children):
|
||||
"""
|
||||
Properly handle parens, otherwise this is trivial.
|
||||
"""
|
||||
if len(children) == 3:
|
||||
return LatexRendered(
|
||||
children[1].latex,
|
||||
parens=children[0].latex,
|
||||
tall=children[1].tall
|
||||
)
|
||||
else:
|
||||
return children[0]
|
||||
|
||||
|
||||
def add_defaults(var, fun, case_sensitive=False):
|
||||
"""
|
||||
Create sets with both the default and user-defined variables.
|
||||
|
||||
Compare to calc.add_defaults
|
||||
"""
|
||||
var_items = set(DEFAULT_VARIABLES)
|
||||
fun_items = set(DEFAULT_FUNCTIONS)
|
||||
|
||||
var_items.update(var)
|
||||
fun_items.update(fun)
|
||||
|
||||
if not case_sensitive:
|
||||
var_items = set(k.lower() for k in var_items)
|
||||
fun_items = set(k.lower() for k in fun_items)
|
||||
|
||||
return var_items, fun_items
|
||||
|
||||
|
||||
def latex_preview(math_expr, variables=(), functions=(), case_sensitive=False):
|
||||
"""
|
||||
Convert `math_expr` into latex, guaranteeing its parse-ability.
|
||||
|
||||
Analagous to `evaluator`.
|
||||
"""
|
||||
# No need to go further
|
||||
if math_expr.strip() == "":
|
||||
return ""
|
||||
|
||||
# Parse tree
|
||||
latex_interpreter = ParseAugmenter(math_expr, case_sensitive)
|
||||
latex_interpreter.parse_algebra()
|
||||
|
||||
# Get our variables together.
|
||||
variables, functions = add_defaults(variables, functions, case_sensitive)
|
||||
|
||||
# Create a recursion to evaluate the tree.
|
||||
if case_sensitive:
|
||||
casify = lambda x: x
|
||||
else:
|
||||
casify = lambda x: x.lower() # Lowercase for case insens.
|
||||
|
||||
render_actions = {
|
||||
'number': render_number,
|
||||
'variable': variable_closure(variables, casify),
|
||||
'function': function_closure(functions, casify),
|
||||
'atom': render_atom,
|
||||
'power': render_power,
|
||||
'parallel': render_parallel,
|
||||
'product': render_product,
|
||||
'sum': render_sum
|
||||
}
|
||||
|
||||
backslash = "\\"
|
||||
wrap_escaped_strings = lambda s: LatexRendered(
|
||||
s.replace(backslash, backslash * 2)
|
||||
)
|
||||
|
||||
output = latex_interpreter.reduce_tree(
|
||||
render_actions,
|
||||
terminal_converter=wrap_escaped_strings
|
||||
)
|
||||
return output.latex
|
||||
@@ -14,7 +14,7 @@ class EvaluatorTest(unittest.TestCase):
|
||||
Go through all functionalities as specifically as possible--
|
||||
work from number input to functions and complex expressions
|
||||
Also test custom variable substitutions (i.e.
|
||||
`evaluator({'x':3.0},{}, '3*x')`
|
||||
`evaluator({'x':3.0}, {}, '3*x')`
|
||||
gives 9.0) and more.
|
||||
"""
|
||||
|
||||
@@ -41,37 +41,40 @@ class EvaluatorTest(unittest.TestCase):
|
||||
"""
|
||||
The string '.' should not evaluate to anything.
|
||||
"""
|
||||
self.assertRaises(ParseException, calc.evaluator, {}, {}, '.')
|
||||
self.assertRaises(ParseException, calc.evaluator, {}, {}, '1+.')
|
||||
with self.assertRaises(ParseException):
|
||||
calc.evaluator({}, {}, '.')
|
||||
with self.assertRaises(ParseException):
|
||||
calc.evaluator({}, {}, '1+.')
|
||||
|
||||
def test_trailing_period(self):
|
||||
"""
|
||||
Test that things like '4.' will be 4 and not throw an error
|
||||
"""
|
||||
try:
|
||||
self.assertEqual(4.0, calc.evaluator({}, {}, '4.'))
|
||||
except ParseException:
|
||||
self.fail("'4.' is a valid input, but threw an exception")
|
||||
self.assertEqual(4.0, calc.evaluator({}, {}, '4.'))
|
||||
|
||||
def test_exponential_answer(self):
|
||||
"""
|
||||
Test for correct interpretation of scientific notation
|
||||
"""
|
||||
answer = 50
|
||||
correct_responses = ["50", "50.0", "5e1", "5e+1",
|
||||
"50e0", "50.0e0", "500e-1"]
|
||||
correct_responses = [
|
||||
"50", "50.0", "5e1", "5e+1",
|
||||
"50e0", "50.0e0", "500e-1"
|
||||
]
|
||||
incorrect_responses = ["", "3.9", "4.1", "0", "5.01e1"]
|
||||
|
||||
for input_str in correct_responses:
|
||||
result = calc.evaluator({}, {}, input_str)
|
||||
fail_msg = "Expected '{0}' to equal {1}".format(
|
||||
input_str, answer)
|
||||
input_str, answer
|
||||
)
|
||||
self.assertEqual(answer, result, msg=fail_msg)
|
||||
|
||||
for input_str in incorrect_responses:
|
||||
result = calc.evaluator({}, {}, input_str)
|
||||
fail_msg = "Expected '{0}' to not equal {1}".format(
|
||||
input_str, answer)
|
||||
input_str, answer
|
||||
)
|
||||
self.assertNotEqual(answer, result, msg=fail_msg)
|
||||
|
||||
def test_si_suffix(self):
|
||||
@@ -80,17 +83,21 @@ class EvaluatorTest(unittest.TestCase):
|
||||
|
||||
For instance 'k' stand for 'kilo-' so '1k' should be 1,000
|
||||
"""
|
||||
test_mapping = [('4.2%', 0.042), ('2.25k', 2250), ('8.3M', 8300000),
|
||||
('9.9G', 9.9e9), ('1.2T', 1.2e12), ('7.4c', 0.074),
|
||||
('5.4m', 0.0054), ('8.7u', 0.0000087),
|
||||
('5.6n', 5.6e-9), ('4.2p', 4.2e-12)]
|
||||
test_mapping = [
|
||||
('4.2%', 0.042), ('2.25k', 2250), ('8.3M', 8300000),
|
||||
('9.9G', 9.9e9), ('1.2T', 1.2e12), ('7.4c', 0.074),
|
||||
('5.4m', 0.0054), ('8.7u', 0.0000087),
|
||||
('5.6n', 5.6e-9), ('4.2p', 4.2e-12)
|
||||
]
|
||||
|
||||
for (expr, answer) in test_mapping:
|
||||
tolerance = answer * 1e-6 # Make rel. tolerance, because of floats
|
||||
fail_msg = "Failure in testing suffix '{0}': '{1}' was not {2}"
|
||||
fail_msg = fail_msg.format(expr[-1], expr, answer)
|
||||
self.assertAlmostEqual(calc.evaluator({}, {}, expr), answer,
|
||||
delta=tolerance, msg=fail_msg)
|
||||
self.assertAlmostEqual(
|
||||
calc.evaluator({}, {}, expr), answer,
|
||||
delta=tolerance, msg=fail_msg
|
||||
)
|
||||
|
||||
def test_operator_sanity(self):
|
||||
"""
|
||||
@@ -104,19 +111,20 @@ class EvaluatorTest(unittest.TestCase):
|
||||
input_str = "{0} {1} {2}".format(var1, operator, var2)
|
||||
result = calc.evaluator({}, {}, input_str)
|
||||
fail_msg = "Failed on operator '{0}': '{1}' was not {2}".format(
|
||||
operator, input_str, answer)
|
||||
operator, input_str, answer
|
||||
)
|
||||
self.assertEqual(answer, result, msg=fail_msg)
|
||||
|
||||
def test_raises_zero_division_err(self):
|
||||
"""
|
||||
Ensure division by zero gives an error
|
||||
"""
|
||||
self.assertRaises(ZeroDivisionError, calc.evaluator,
|
||||
{}, {}, '1/0')
|
||||
self.assertRaises(ZeroDivisionError, calc.evaluator,
|
||||
{}, {}, '1/0.0')
|
||||
self.assertRaises(ZeroDivisionError, calc.evaluator,
|
||||
{'x': 0.0}, {}, '1/x')
|
||||
with self.assertRaises(ZeroDivisionError):
|
||||
calc.evaluator({}, {}, '1/0')
|
||||
with self.assertRaises(ZeroDivisionError):
|
||||
calc.evaluator({}, {}, '1/0.0')
|
||||
with self.assertRaises(ZeroDivisionError):
|
||||
calc.evaluator({'x': 0.0}, {}, '1/x')
|
||||
|
||||
def test_parallel_resistors(self):
|
||||
"""
|
||||
@@ -153,7 +161,8 @@ class EvaluatorTest(unittest.TestCase):
|
||||
input_str = "{0}({1})".format(fname, arg)
|
||||
result = calc.evaluator({}, {}, input_str)
|
||||
fail_msg = "Failed on function {0}: '{1}' was not {2}".format(
|
||||
fname, input_str, val)
|
||||
fname, input_str, val
|
||||
)
|
||||
self.assertAlmostEqual(val, result, delta=tolerance, msg=fail_msg)
|
||||
|
||||
def test_trig_functions(self):
|
||||
@@ -303,21 +312,29 @@ class EvaluatorTest(unittest.TestCase):
|
||||
"""
|
||||
|
||||
# Test sqrt
|
||||
self.assert_function_values('sqrt',
|
||||
[0, 1, 2, 1024], # -1
|
||||
[0, 1, 1.414, 32]) # 1j
|
||||
self.assert_function_values(
|
||||
'sqrt',
|
||||
[0, 1, 2, 1024], # -1
|
||||
[0, 1, 1.414, 32] # 1j
|
||||
)
|
||||
# sqrt(-1) is NAN not j (!!).
|
||||
|
||||
# Test logs
|
||||
self.assert_function_values('log10',
|
||||
[0.1, 1, 3.162, 1000000, '1+j'],
|
||||
[-1, 0, 0.5, 6, 0.151 + 0.341j])
|
||||
self.assert_function_values('log2',
|
||||
[0.5, 1, 1.414, 1024, '1+j'],
|
||||
[-1, 0, 0.5, 10, 0.5 + 1.133j])
|
||||
self.assert_function_values('ln',
|
||||
[0.368, 1, 1.649, 2.718, 42, '1+j'],
|
||||
[-1, 0, 0.5, 1, 3.738, 0.347 + 0.785j])
|
||||
self.assert_function_values(
|
||||
'log10',
|
||||
[0.1, 1, 3.162, 1000000, '1+j'],
|
||||
[-1, 0, 0.5, 6, 0.151 + 0.341j]
|
||||
)
|
||||
self.assert_function_values(
|
||||
'log2',
|
||||
[0.5, 1, 1.414, 1024, '1+j'],
|
||||
[-1, 0, 0.5, 10, 0.5 + 1.133j]
|
||||
)
|
||||
self.assert_function_values(
|
||||
'ln',
|
||||
[0.368, 1, 1.649, 2.718, 42, '1+j'],
|
||||
[-1, 0, 0.5, 1, 3.738, 0.347 + 0.785j]
|
||||
)
|
||||
|
||||
# Test abs
|
||||
self.assert_function_values('abs', [-1, 0, 1, 'j'], [1, 0, 1, 1])
|
||||
@@ -341,26 +358,28 @@ class EvaluatorTest(unittest.TestCase):
|
||||
"""
|
||||
|
||||
# Of the form ('expr', python value, tolerance (or None for exact))
|
||||
default_variables = [('j', 1j, None),
|
||||
('e', 2.7183, 1e-3),
|
||||
('pi', 3.1416, 1e-3),
|
||||
# c = speed of light
|
||||
('c', 2.998e8, 1e5),
|
||||
# 0 deg C = T Kelvin
|
||||
('T', 298.15, 0.01),
|
||||
# Note k = scipy.constants.k = 1.3806488e-23
|
||||
('k', 1.3806488e-23, 1e-26),
|
||||
# Note q = scipy.constants.e = 1.602176565e-19
|
||||
('q', 1.602176565e-19, 1e-22)]
|
||||
default_variables = [
|
||||
('i', 1j, None),
|
||||
('j', 1j, None),
|
||||
('e', 2.7183, 1e-4),
|
||||
('pi', 3.1416, 1e-4),
|
||||
('k', 1.3806488e-23, 1e-26), # Boltzmann constant (Joules/Kelvin)
|
||||
('c', 2.998e8, 1e5), # Light Speed in (m/s)
|
||||
('T', 298.15, 0.01), # 0 deg C = T Kelvin
|
||||
('q', 1.602176565e-19, 1e-22) # Fund. Charge (Coulombs)
|
||||
]
|
||||
for (variable, value, tolerance) in default_variables:
|
||||
fail_msg = "Failed on constant '{0}', not within bounds".format(
|
||||
variable)
|
||||
variable
|
||||
)
|
||||
result = calc.evaluator({}, {}, variable)
|
||||
if tolerance is None:
|
||||
self.assertEqual(value, result, msg=fail_msg)
|
||||
else:
|
||||
self.assertAlmostEqual(value, result,
|
||||
delta=tolerance, msg=fail_msg)
|
||||
self.assertAlmostEqual(
|
||||
value, result,
|
||||
delta=tolerance, msg=fail_msg
|
||||
)
|
||||
|
||||
def test_complex_expression(self):
|
||||
"""
|
||||
@@ -370,21 +389,51 @@ class EvaluatorTest(unittest.TestCase):
|
||||
self.assertAlmostEqual(
|
||||
calc.evaluator({}, {}, "(2^2+1.0)/sqrt(5e0)*5-1"),
|
||||
10.180,
|
||||
delta=1e-3)
|
||||
|
||||
delta=1e-3
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
calc.evaluator({}, {}, "1+1/(1+1/(1+1/(1+1)))"),
|
||||
1.6,
|
||||
delta=1e-3)
|
||||
delta=1e-3
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
calc.evaluator({}, {}, "10||sin(7+5)"),
|
||||
-0.567, delta=0.01)
|
||||
self.assertAlmostEqual(calc.evaluator({}, {}, "sin(e)"),
|
||||
0.41, delta=0.01)
|
||||
self.assertAlmostEqual(calc.evaluator({}, {}, "k*T/q"),
|
||||
0.025, delta=1e-3)
|
||||
self.assertAlmostEqual(calc.evaluator({}, {}, "e^(j*pi)"),
|
||||
-1, delta=1e-5)
|
||||
-0.567, delta=0.01
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
calc.evaluator({}, {}, "sin(e)"),
|
||||
0.41, delta=0.01
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
calc.evaluator({}, {}, "k*T/q"),
|
||||
0.025, delta=1e-3
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
calc.evaluator({}, {}, "e^(j*pi)"),
|
||||
-1, delta=1e-5
|
||||
)
|
||||
|
||||
def test_explicit_sci_notation(self):
|
||||
"""
|
||||
Expressions like 1.6*10^-3 (not 1.6e-3) it should evaluate.
|
||||
"""
|
||||
self.assertEqual(
|
||||
calc.evaluator({}, {}, "-1.6*10^-3"),
|
||||
-0.0016
|
||||
)
|
||||
self.assertEqual(
|
||||
calc.evaluator({}, {}, "-1.6*10^(-3)"),
|
||||
-0.0016
|
||||
)
|
||||
|
||||
self.assertEqual(
|
||||
calc.evaluator({}, {}, "-1.6*10^3"),
|
||||
-1600
|
||||
)
|
||||
self.assertEqual(
|
||||
calc.evaluator({}, {}, "-1.6*10^(3)"),
|
||||
-1600
|
||||
)
|
||||
|
||||
def test_simple_vars(self):
|
||||
"""
|
||||
@@ -404,19 +453,24 @@ class EvaluatorTest(unittest.TestCase):
|
||||
self.assertEqual(calc.evaluator(variables, {}, 'loooooong'), 6.4)
|
||||
|
||||
# Test a simple equation
|
||||
self.assertAlmostEqual(calc.evaluator(variables, {}, '3*x-y'),
|
||||
21.25, delta=0.01) # = 3 * 9.72 - 7.91
|
||||
self.assertAlmostEqual(calc.evaluator(variables, {}, 'x*y'),
|
||||
76.89, delta=0.01)
|
||||
self.assertAlmostEqual(
|
||||
calc.evaluator(variables, {}, '3*x-y'),
|
||||
21.25, delta=0.01 # = 3 * 9.72 - 7.91
|
||||
)
|
||||
self.assertAlmostEqual(
|
||||
calc.evaluator(variables, {}, 'x*y'),
|
||||
76.89, delta=0.01
|
||||
)
|
||||
|
||||
self.assertEqual(calc.evaluator({'x': 9.72, 'y': 7.91}, {}, "13"), 13)
|
||||
self.assertEqual(calc.evaluator(variables, {}, "13"), 13)
|
||||
self.assertEqual(
|
||||
calc.evaluator({
|
||||
'a': 2.2997471478310274, 'k': 9, 'm': 8,
|
||||
'x': 0.66009498411213041},
|
||||
{}, "5"),
|
||||
5)
|
||||
calc.evaluator(
|
||||
{'a': 2.2997471478310274, 'k': 9, 'm': 8, 'x': 0.6600949841121},
|
||||
{}, "5"
|
||||
),
|
||||
5
|
||||
)
|
||||
|
||||
def test_variable_case_sensitivity(self):
|
||||
"""
|
||||
@@ -424,15 +478,21 @@ class EvaluatorTest(unittest.TestCase):
|
||||
"""
|
||||
self.assertEqual(
|
||||
calc.evaluator({'R1': 2.0, 'R3': 4.0}, {}, "r1*r3"),
|
||||
8.0)
|
||||
8.0
|
||||
)
|
||||
|
||||
variables = {'t': 1.0}
|
||||
self.assertEqual(calc.evaluator(variables, {}, "t"), 1.0)
|
||||
self.assertEqual(calc.evaluator(variables, {}, "T"), 1.0)
|
||||
self.assertEqual(calc.evaluator(variables, {}, "t", cs=True), 1.0)
|
||||
self.assertEqual(
|
||||
calc.evaluator(variables, {}, "t", case_sensitive=True),
|
||||
1.0
|
||||
)
|
||||
# Recall 'T' is a default constant, with value 298.15
|
||||
self.assertAlmostEqual(calc.evaluator(variables, {}, "T", cs=True),
|
||||
298, delta=0.2)
|
||||
self.assertAlmostEqual(
|
||||
calc.evaluator(variables, {}, "T", case_sensitive=True),
|
||||
298, delta=0.2
|
||||
)
|
||||
|
||||
def test_simple_funcs(self):
|
||||
"""
|
||||
@@ -445,22 +505,41 @@ class EvaluatorTest(unittest.TestCase):
|
||||
self.assertEqual(calc.evaluator(variables, functions, 'id(x)'), 4.712)
|
||||
|
||||
functions.update({'f': numpy.sin})
|
||||
self.assertAlmostEqual(calc.evaluator(variables, functions, 'f(x)'),
|
||||
-1, delta=1e-3)
|
||||
self.assertAlmostEqual(
|
||||
calc.evaluator(variables, functions, 'f(x)'),
|
||||
-1, delta=1e-3
|
||||
)
|
||||
|
||||
def test_function_case_sensitivity(self):
|
||||
def test_function_case_insensitive(self):
|
||||
"""
|
||||
Test the case sensitivity of functions
|
||||
Test case insensitive evaluation
|
||||
|
||||
Normal functions with some capitals should be fine
|
||||
"""
|
||||
functions = {'f': lambda x: x,
|
||||
'F': lambda x: x + 1}
|
||||
# Test case insensitive evaluation
|
||||
# Both evaulations should call the same function
|
||||
self.assertEqual(calc.evaluator({}, functions, 'f(6)'),
|
||||
calc.evaluator({}, functions, 'F(6)'))
|
||||
# Test case sensitive evaluation
|
||||
self.assertNotEqual(calc.evaluator({}, functions, 'f(6)', cs=True),
|
||||
calc.evaluator({}, functions, 'F(6)', cs=True))
|
||||
self.assertAlmostEqual(
|
||||
-0.28,
|
||||
calc.evaluator({}, {}, 'SiN(6)', case_sensitive=False),
|
||||
delta=1e-3
|
||||
)
|
||||
|
||||
def test_function_case_sensitive(self):
|
||||
"""
|
||||
Test case sensitive evaluation
|
||||
|
||||
Incorrectly capitilized should fail
|
||||
Also, it should pick the correct version of a function.
|
||||
"""
|
||||
with self.assertRaisesRegexp(calc.UndefinedVariable, 'SiN'):
|
||||
calc.evaluator({}, {}, 'SiN(6)', case_sensitive=True)
|
||||
|
||||
# With case sensitive turned on, it should pick the right function
|
||||
functions = {'f': lambda x: x, 'F': lambda x: x + 1}
|
||||
self.assertEqual(
|
||||
calc.evaluator({}, functions, 'f(6)', case_sensitive=True), 6
|
||||
)
|
||||
self.assertEqual(
|
||||
calc.evaluator({}, functions, 'F(6)', case_sensitive=True), 7
|
||||
)
|
||||
|
||||
def test_undefined_vars(self):
|
||||
"""
|
||||
@@ -468,9 +547,9 @@ class EvaluatorTest(unittest.TestCase):
|
||||
"""
|
||||
variables = {'R1': 2.0, 'R3': 4.0}
|
||||
|
||||
self.assertRaises(calc.UndefinedVariable, calc.evaluator,
|
||||
{}, {}, "5+7 QWSEKO")
|
||||
self.assertRaises(calc.UndefinedVariable, calc.evaluator,
|
||||
{'r1': 5}, {}, "r1+r2")
|
||||
self.assertRaises(calc.UndefinedVariable, calc.evaluator,
|
||||
variables, {}, "r1*r3", cs=True)
|
||||
with self.assertRaisesRegexp(calc.UndefinedVariable, 'QWSEKO'):
|
||||
calc.evaluator({}, {}, "5+7*QWSEKO")
|
||||
with self.assertRaisesRegexp(calc.UndefinedVariable, 'r2'):
|
||||
calc.evaluator({'r1': 5}, {}, "r1+r2")
|
||||
with self.assertRaisesRegexp(calc.UndefinedVariable, 'r1 r3'):
|
||||
calc.evaluator(variables, {}, "r1*r3", case_sensitive=True)
|
||||
|
||||
251
common/lib/calc/tests/test_preview.py
Normal file
251
common/lib/calc/tests/test_preview.py
Normal file
@@ -0,0 +1,251 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
Unit tests for preview.py
|
||||
"""
|
||||
|
||||
import unittest
|
||||
import preview
|
||||
import pyparsing
|
||||
|
||||
|
||||
class LatexRenderedTest(unittest.TestCase):
|
||||
"""
|
||||
Test the initializing code for LatexRendered.
|
||||
|
||||
Specifically that it stores the correct data and handles parens well.
|
||||
"""
|
||||
def test_simple(self):
|
||||
"""
|
||||
Test that the data values are stored without changing.
|
||||
"""
|
||||
math = 'x^2'
|
||||
obj = preview.LatexRendered(math, tall=True)
|
||||
self.assertEquals(obj.latex, math)
|
||||
self.assertEquals(obj.sans_parens, math)
|
||||
self.assertEquals(obj.tall, True)
|
||||
|
||||
def _each_parens(self, with_parens, math, parens, tall=False):
|
||||
"""
|
||||
Helper method to test the way parens are wrapped.
|
||||
"""
|
||||
obj = preview.LatexRendered(math, parens=parens, tall=tall)
|
||||
self.assertEquals(obj.latex, with_parens)
|
||||
self.assertEquals(obj.sans_parens, math)
|
||||
self.assertEquals(obj.tall, tall)
|
||||
|
||||
def test_parens(self):
|
||||
""" Test curvy parens. """
|
||||
self._each_parens('(x+y)', 'x+y', '(')
|
||||
|
||||
def test_brackets(self):
|
||||
""" Test brackets. """
|
||||
self._each_parens('[x+y]', 'x+y', '[')
|
||||
|
||||
def test_squiggles(self):
|
||||
""" Test curly braces. """
|
||||
self._each_parens(r'\{x+y\}', 'x+y', '{')
|
||||
|
||||
def test_parens_tall(self):
|
||||
""" Test curvy parens with the tall parameter. """
|
||||
self._each_parens(r'\left(x^y\right)', 'x^y', '(', tall=True)
|
||||
|
||||
def test_brackets_tall(self):
|
||||
""" Test brackets, also tall. """
|
||||
self._each_parens(r'\left[x^y\right]', 'x^y', '[', tall=True)
|
||||
|
||||
def test_squiggles_tall(self):
|
||||
""" Test tall curly braces. """
|
||||
self._each_parens(r'\left\{x^y\right\}', 'x^y', '{', tall=True)
|
||||
|
||||
def test_bad_parens(self):
|
||||
""" Check that we get an error with invalid parens. """
|
||||
with self.assertRaisesRegexp(Exception, 'Unknown parenthesis'):
|
||||
preview.LatexRendered('x^2', parens='not parens')
|
||||
|
||||
|
||||
class LatexPreviewTest(unittest.TestCase):
|
||||
"""
|
||||
Run integrative tests for `latex_preview`.
|
||||
|
||||
All functionality was tested `RenderMethodsTest`, but see if it combines
|
||||
all together correctly.
|
||||
"""
|
||||
def test_no_input(self):
|
||||
"""
|
||||
With no input (including just whitespace), see that no error is thrown.
|
||||
"""
|
||||
self.assertEquals('', preview.latex_preview(''))
|
||||
self.assertEquals('', preview.latex_preview(' '))
|
||||
self.assertEquals('', preview.latex_preview(' \t '))
|
||||
|
||||
def test_number_simple(self):
|
||||
""" Simple numbers should pass through. """
|
||||
self.assertEquals(preview.latex_preview('3.1415'), '3.1415')
|
||||
|
||||
def test_number_suffix(self):
|
||||
""" Suffixes should be escaped. """
|
||||
self.assertEquals(preview.latex_preview('1.618k'), r'1.618\text{k}')
|
||||
|
||||
def test_number_sci_notation(self):
|
||||
""" Numbers with scientific notation should display nicely """
|
||||
self.assertEquals(
|
||||
preview.latex_preview('6.0221413E+23'),
|
||||
r'6.0221413\!\times\!10^{+23}'
|
||||
)
|
||||
self.assertEquals(
|
||||
preview.latex_preview('-6.0221413E+23'),
|
||||
r'-6.0221413\!\times\!10^{+23}'
|
||||
)
|
||||
|
||||
def test_number_sci_notation_suffix(self):
|
||||
""" Test numbers with both of these. """
|
||||
self.assertEquals(
|
||||
preview.latex_preview('6.0221413E+23k'),
|
||||
r'6.0221413\!\times\!10^{+23}\text{k}'
|
||||
)
|
||||
self.assertEquals(
|
||||
preview.latex_preview('-6.0221413E+23k'),
|
||||
r'-6.0221413\!\times\!10^{+23}\text{k}'
|
||||
)
|
||||
|
||||
def test_variable_simple(self):
|
||||
""" Simple valid variables should pass through. """
|
||||
self.assertEquals(preview.latex_preview('x', variables=['x']), 'x')
|
||||
|
||||
def test_greek(self):
|
||||
""" Variable names that are greek should be formatted accordingly. """
|
||||
self.assertEquals(preview.latex_preview('pi'), r'\pi')
|
||||
|
||||
def test_variable_subscript(self):
|
||||
""" Things like 'epsilon_max' should display nicely """
|
||||
self.assertEquals(
|
||||
preview.latex_preview('epsilon_max', variables=['epsilon_max']),
|
||||
r'\epsilon_{max}'
|
||||
)
|
||||
|
||||
def test_function_simple(self):
|
||||
""" Valid function names should be escaped. """
|
||||
self.assertEquals(
|
||||
preview.latex_preview('f(3)', functions=['f']),
|
||||
r'\text{f}(3)'
|
||||
)
|
||||
|
||||
def test_function_tall(self):
|
||||
r""" Functions surrounding a tall element should have \left, \right """
|
||||
self.assertEquals(
|
||||
preview.latex_preview('f(3^2)', functions=['f']),
|
||||
r'\text{f}\left(3^{2}\right)'
|
||||
)
|
||||
|
||||
def test_function_sqrt(self):
|
||||
""" Sqrt function should be handled specially. """
|
||||
self.assertEquals(preview.latex_preview('sqrt(3)'), r'\sqrt{3}')
|
||||
|
||||
def test_function_log10(self):
|
||||
""" log10 function should be handled specially. """
|
||||
self.assertEquals(preview.latex_preview('log10(3)'), r'\log_{10}(3)')
|
||||
|
||||
def test_function_log2(self):
|
||||
""" log2 function should be handled specially. """
|
||||
self.assertEquals(preview.latex_preview('log2(3)'), r'\log_2(3)')
|
||||
|
||||
def test_power_simple(self):
|
||||
""" Powers should wrap the elements with braces correctly. """
|
||||
self.assertEquals(preview.latex_preview('2^3^4'), '2^{3^{4}}')
|
||||
|
||||
def test_power_parens(self):
|
||||
""" Powers should ignore the parenthesis of the last math. """
|
||||
self.assertEquals(preview.latex_preview('2^3^(4+5)'), '2^{3^{4+5}}')
|
||||
|
||||
def test_parallel(self):
|
||||
r""" Parallel items should combine with '\|'. """
|
||||
self.assertEquals(preview.latex_preview('2||3'), r'2\|3')
|
||||
|
||||
def test_product_mult_only(self):
|
||||
r""" Simple products should combine with a '\cdot'. """
|
||||
self.assertEquals(preview.latex_preview('2*3'), r'2\cdot 3')
|
||||
|
||||
def test_product_big_frac(self):
|
||||
""" Division should combine with '\frac'. """
|
||||
self.assertEquals(
|
||||
preview.latex_preview('2*3/4/5'),
|
||||
r'\frac{2\cdot 3}{4\cdot 5}'
|
||||
)
|
||||
|
||||
def test_product_single_frac(self):
|
||||
""" Division should ignore parens if they are extraneous. """
|
||||
self.assertEquals(
|
||||
preview.latex_preview('(2+3)/(4+5)'),
|
||||
r'\frac{2+3}{4+5}'
|
||||
)
|
||||
|
||||
def test_product_keep_going(self):
|
||||
"""
|
||||
Complex products/quotients should split into many '\frac's when needed.
|
||||
"""
|
||||
self.assertEquals(
|
||||
preview.latex_preview('2/3*4/5*6'),
|
||||
r'\frac{2}{3}\cdot \frac{4}{5}\cdot 6'
|
||||
)
|
||||
|
||||
def test_sum(self):
|
||||
""" Sums should combine its elements. """
|
||||
# Use 'x' as the first term (instead of, say, '1'), so it can't be
|
||||
# interpreted as a negative number.
|
||||
self.assertEquals(
|
||||
preview.latex_preview('-x+2-3+4', variables=['x']),
|
||||
'-x+2-3+4'
|
||||
)
|
||||
|
||||
def test_sum_tall(self):
|
||||
""" A complicated expression should not hide the tallness. """
|
||||
self.assertEquals(
|
||||
preview.latex_preview('(2+3^2)'),
|
||||
r'\left(2+3^{2}\right)'
|
||||
)
|
||||
|
||||
def test_complicated(self):
|
||||
"""
|
||||
Given complicated input, ensure that exactly the correct string is made.
|
||||
"""
|
||||
self.assertEquals(
|
||||
preview.latex_preview('11*f(x)+x^2*(3||4)/sqrt(pi)'),
|
||||
r'11\cdot \text{f}(x)+\frac{x^{2}\cdot (3\|4)}{\sqrt{\pi}}'
|
||||
)
|
||||
|
||||
self.assertEquals(
|
||||
preview.latex_preview('log10(1+3/4/Cos(x^2)*(x+1))',
|
||||
case_sensitive=True),
|
||||
(r'\log_{10}\left(1+\frac{3}{4\cdot \text{Cos}\left(x^{2}\right)}'
|
||||
r'\cdot (x+1)\right)')
|
||||
)
|
||||
|
||||
def test_syntax_errors(self):
|
||||
"""
|
||||
Test a lot of math strings that give syntax errors
|
||||
|
||||
Rather than have a lot of self.assertRaises, make a loop and keep track
|
||||
of those that do not throw a `ParseException`, and assert at the end.
|
||||
"""
|
||||
bad_math_list = [
|
||||
'11+',
|
||||
'11*',
|
||||
'f((x)',
|
||||
'sqrt(x^)',
|
||||
'3f(x)', # Not 3*f(x)
|
||||
'3|4',
|
||||
'3|||4'
|
||||
]
|
||||
bad_exceptions = {}
|
||||
for math in bad_math_list:
|
||||
try:
|
||||
preview.latex_preview(math)
|
||||
except pyparsing.ParseException:
|
||||
pass # This is what we were expecting. (not excepting :P)
|
||||
except Exception as error: # pragma: no cover
|
||||
bad_exceptions[math] = error
|
||||
else: # pragma: no cover
|
||||
# If there is no exception thrown, this is a problem
|
||||
bad_exceptions[math] = None
|
||||
|
||||
self.assertEquals({}, bad_exceptions)
|
||||
@@ -16,6 +16,8 @@ Module containing the problem elements which render into input objects
|
||||
- crystallography
|
||||
- vsepr_input
|
||||
- drag_and_drop
|
||||
- formulaequationinput
|
||||
- chemicalequationinput
|
||||
|
||||
These are matched by *.html files templates/*.html which are mako templates with the
|
||||
actual html.
|
||||
@@ -47,6 +49,7 @@ import pyparsing
|
||||
|
||||
from .registry import TagRegistry
|
||||
from chem import chemcalc
|
||||
from preview import latex_preview
|
||||
import xqueue_interface
|
||||
from datetime import datetime
|
||||
|
||||
@@ -531,7 +534,7 @@ class TextLine(InputTypeBase):
|
||||
is used e.g. for embedding simulations turned into questions.
|
||||
|
||||
Example:
|
||||
<texline math="1" trailing_text="m/s" />
|
||||
<textline math="1" trailing_text="m/s" />
|
||||
|
||||
This example will render out a text line with a math preview and the text 'm/s'
|
||||
after the end of the text line.
|
||||
@@ -1037,15 +1040,16 @@ class ChemicalEquationInput(InputTypeBase):
|
||||
|
||||
result = {'preview': '',
|
||||
'error': ''}
|
||||
formula = data['formula']
|
||||
if formula is None:
|
||||
try:
|
||||
formula = data['formula']
|
||||
except KeyError:
|
||||
result['error'] = "No formula specified."
|
||||
return result
|
||||
|
||||
try:
|
||||
result['preview'] = chemcalc.render_to_html(formula)
|
||||
except pyparsing.ParseException as p:
|
||||
result['error'] = "Couldn't parse formula: {0}".format(p)
|
||||
result['error'] = u"Couldn't parse formula: {0}".format(p.msg)
|
||||
except Exception:
|
||||
# this is unexpected, so log
|
||||
log.warning(
|
||||
@@ -1056,6 +1060,98 @@ class ChemicalEquationInput(InputTypeBase):
|
||||
|
||||
registry.register(ChemicalEquationInput)
|
||||
|
||||
#-------------------------------------------------------------------------
|
||||
|
||||
|
||||
class FormulaEquationInput(InputTypeBase):
|
||||
"""
|
||||
An input type for entering formula equations. Supports live preview.
|
||||
|
||||
Example:
|
||||
|
||||
<formulaequationinput size="50"/>
|
||||
|
||||
options: size -- width of the textbox.
|
||||
"""
|
||||
|
||||
template = "formulaequationinput.html"
|
||||
tags = ['formulaequationinput']
|
||||
|
||||
@classmethod
|
||||
def get_attributes(cls):
|
||||
"""
|
||||
Can set size of text field.
|
||||
"""
|
||||
return [Attribute('size', '20'), ]
|
||||
|
||||
def _extra_context(self):
|
||||
"""
|
||||
TODO (vshnayder): Get rid of 'previewer' once we have a standard way of requiring js to be loaded.
|
||||
"""
|
||||
# `reported_status` is basically `status`, except we say 'unanswered'
|
||||
reported_status = ''
|
||||
if self.status == 'unsubmitted':
|
||||
reported_status = 'unanswered'
|
||||
elif self.status in ('correct', 'incorrect', 'incomplete'):
|
||||
reported_status = self.status
|
||||
|
||||
return {
|
||||
'previewer': '/static/js/capa/src/formula_equation_preview.js',
|
||||
'reported_status': reported_status
|
||||
}
|
||||
|
||||
def handle_ajax(self, dispatch, get):
|
||||
'''
|
||||
Since we only have formcalc preview this input, check to see if it
|
||||
matches the corresponding dispatch and send it through if it does
|
||||
'''
|
||||
if dispatch == 'preview_formcalc':
|
||||
return self.preview_formcalc(get)
|
||||
return {}
|
||||
|
||||
def preview_formcalc(self, get):
|
||||
"""
|
||||
Render an preview of a formula or equation. `get` should
|
||||
contain a key 'formula' with a math expression.
|
||||
|
||||
Returns a json dictionary:
|
||||
{
|
||||
'preview' : '<some latex>' or ''
|
||||
'error' : 'the-error' or ''
|
||||
'request_start' : <time sent with request>
|
||||
}
|
||||
"""
|
||||
|
||||
result = {'preview': '',
|
||||
'error': ''}
|
||||
|
||||
try:
|
||||
formula = get['formula']
|
||||
except KeyError:
|
||||
result['error'] = "No formula specified."
|
||||
return result
|
||||
|
||||
result['request_start'] = int(get.get('request_start', 0))
|
||||
|
||||
try:
|
||||
# TODO add references to valid variables and functions
|
||||
# At some point, we might want to mark invalid variables as red
|
||||
# or something, and this is where we would need to pass those in.
|
||||
result['preview'] = latex_preview(formula)
|
||||
except pyparsing.ParseException as err:
|
||||
result['error'] = "Sorry, couldn't parse formula"
|
||||
result['formula'] = formula
|
||||
except Exception:
|
||||
# this is unexpected, so log
|
||||
log.warning(
|
||||
"Error while previewing formula", exc_info=True
|
||||
)
|
||||
result['error'] = "Error while rendering preview"
|
||||
|
||||
return result
|
||||
|
||||
registry.register(FormulaEquationInput)
|
||||
|
||||
#-----------------------------------------------------------------------------
|
||||
|
||||
|
||||
|
||||
@@ -822,7 +822,7 @@ class NumericalResponse(LoncapaResponse):
|
||||
|
||||
response_tag = 'numericalresponse'
|
||||
hint_tag = 'numericalhint'
|
||||
allowed_inputfields = ['textline']
|
||||
allowed_inputfields = ['textline', 'formulaequationinput']
|
||||
required_attributes = ['answer']
|
||||
max_inputfields = 1
|
||||
|
||||
@@ -837,11 +837,6 @@ class NumericalResponse(LoncapaResponse):
|
||||
self.tolerance = contextualize_text(self.tolerance_xml, context)
|
||||
except IndexError: # xpath found an empty list, so (...)[0] is the error
|
||||
self.tolerance = '0'
|
||||
try:
|
||||
self.answer_id = xml.xpath('//*[@id=$id]//textline/@id',
|
||||
id=xml.get('id'))[0]
|
||||
except IndexError: # Same as above
|
||||
self.answer_id = None
|
||||
|
||||
def get_score(self, student_answers):
|
||||
'''Grade a numeric response '''
|
||||
@@ -936,7 +931,7 @@ class CustomResponse(LoncapaResponse):
|
||||
'chemicalequationinput', 'vsepr_input',
|
||||
'drag_and_drop_input', 'editamoleculeinput',
|
||||
'designprotein2dinput', 'editageneinput',
|
||||
'annotationinput', 'jsinput']
|
||||
'annotationinput', 'jsinput', 'formulaequationinput']
|
||||
|
||||
def setup_response(self):
|
||||
xml = self.xml
|
||||
@@ -1692,7 +1687,7 @@ class FormulaResponse(LoncapaResponse):
|
||||
|
||||
response_tag = 'formularesponse'
|
||||
hint_tag = 'formulahint'
|
||||
allowed_inputfields = ['textline']
|
||||
allowed_inputfields = ['textline', 'formulaequationinput']
|
||||
required_attributes = ['answer', 'samples']
|
||||
max_inputfields = 1
|
||||
|
||||
@@ -1737,7 +1732,7 @@ class FormulaResponse(LoncapaResponse):
|
||||
samples.split('@')[1].split('#')[0].split(':')))
|
||||
|
||||
ranges = dict(zip(variables, sranges))
|
||||
for i in range(numsamples):
|
||||
for _ in range(numsamples):
|
||||
instructor_variables = self.strip_dict(dict(self.context))
|
||||
student_variables = dict()
|
||||
# ranges give numerical ranges for testing
|
||||
@@ -1748,38 +1743,58 @@ class FormulaResponse(LoncapaResponse):
|
||||
student_variables[str(var)] = value
|
||||
# log.debug('formula: instructor_vars=%s, expected=%s' %
|
||||
# (instructor_variables,expected))
|
||||
instructor_result = evaluator(instructor_variables, dict(),
|
||||
expected, cs=self.case_sensitive)
|
||||
|
||||
# Call `evaluator` on the instructor's answer and get a number
|
||||
instructor_result = evaluator(
|
||||
instructor_variables, dict(),
|
||||
expected, case_sensitive=self.case_sensitive
|
||||
)
|
||||
try:
|
||||
# log.debug('formula: student_vars=%s, given=%s' %
|
||||
# (student_variables,given))
|
||||
student_result = evaluator(student_variables,
|
||||
dict(),
|
||||
given,
|
||||
cs=self.case_sensitive)
|
||||
|
||||
# Call `evaluator` on the student's answer; look for exceptions
|
||||
student_result = evaluator(
|
||||
student_variables,
|
||||
dict(),
|
||||
given,
|
||||
case_sensitive=self.case_sensitive
|
||||
)
|
||||
except UndefinedVariable as uv:
|
||||
log.debug(
|
||||
'formularesponse: undefined variable in given=%s' % given)
|
||||
'formularesponse: undefined variable in given=%s',
|
||||
given
|
||||
)
|
||||
raise StudentInputError(
|
||||
"Invalid input: " + uv.message + " not permitted in answer")
|
||||
"Invalid input: " + uv.message + " not permitted in answer"
|
||||
)
|
||||
except ValueError as ve:
|
||||
if 'factorial' in ve.message:
|
||||
# This is thrown when fact() or factorial() is used in a formularesponse answer
|
||||
# that tests on negative and/or non-integer inputs
|
||||
# ve.message will be: `factorial() only accepts integral values` or `factorial() not defined for negative values`
|
||||
# ve.message will be: `factorial() only accepts integral values` or
|
||||
# `factorial() not defined for negative values`
|
||||
log.debug(
|
||||
'formularesponse: factorial function used in response that tests negative and/or non-integer inputs. given={0}'.format(given))
|
||||
('formularesponse: factorial function used in response '
|
||||
'that tests negative and/or non-integer inputs. '
|
||||
'given={0}').format(given)
|
||||
)
|
||||
raise StudentInputError(
|
||||
"factorial function not permitted in answer for this problem. Provided answer was: {0}".format(given))
|
||||
("factorial function not permitted in answer "
|
||||
"for this problem. Provided answer was: "
|
||||
"{0}").format(cgi.escape(given))
|
||||
)
|
||||
# If non-factorial related ValueError thrown, handle it the same as any other Exception
|
||||
log.debug('formularesponse: error {0} in formula'.format(ve))
|
||||
raise StudentInputError("Invalid input: Could not parse '%s' as a formula" %
|
||||
cgi.escape(given))
|
||||
except Exception as err:
|
||||
# traceback.print_exc()
|
||||
log.debug('formularesponse: error %s in formula' % err)
|
||||
log.debug('formularesponse: error %s in formula', err)
|
||||
raise StudentInputError("Invalid input: Could not parse '%s' as a formula" %
|
||||
cgi.escape(given))
|
||||
|
||||
# No errors in student's response--actually test for correctness
|
||||
if not compare_with_tolerance(student_result, instructor_result, self.tolerance):
|
||||
return "incorrect"
|
||||
return "correct"
|
||||
|
||||
20
common/lib/capa/capa/templates/formulaequationinput.html
Normal file
20
common/lib/capa/capa/templates/formulaequationinput.html
Normal file
@@ -0,0 +1,20 @@
|
||||
<section id="formulaequationinput_${id}" class="formulaequationinput">
|
||||
<div class="${reported_status}" id="status_${id}">
|
||||
<input type="text" name="input_${id}" id="input_${id}"
|
||||
data-input-id="${id}" value="${value|h}"
|
||||
% if size:
|
||||
size="${size}"
|
||||
% endif
|
||||
/>
|
||||
|
||||
<p class="status">${reported_status}</p>
|
||||
|
||||
<div id="input_${id}_preview" class="equation">
|
||||
\[\]
|
||||
<img src="/static/images/spinner.gif" class="loading"/>
|
||||
</div>
|
||||
<p id="answer_${id}" class="answer"></p>
|
||||
</div>
|
||||
|
||||
<div class="script_placeholder" data-src="${previewer}"/>
|
||||
</section>
|
||||
@@ -448,6 +448,32 @@ class TextlineTemplateTest(TemplateTestCase):
|
||||
self.assert_has_text(xml, xpath, self.context['msg'])
|
||||
|
||||
|
||||
class FormulaEquationInputTemplateTest(TemplateTestCase):
|
||||
"""
|
||||
Test make template for `<formulaequationinput>`s.
|
||||
"""
|
||||
TEMPLATE_NAME = 'formulaequationinput.html'
|
||||
|
||||
def setUp(self):
|
||||
self.context = {
|
||||
'id': 2,
|
||||
'value': 'PREFILLED_VALUE',
|
||||
'status': 'unsubmitted',
|
||||
'previewer': 'file.js',
|
||||
'reported_status': 'REPORTED_STATUS',
|
||||
}
|
||||
super(FormulaEquationInputTemplateTest, self).setUp()
|
||||
|
||||
def test_no_size(self):
|
||||
xml = self.render_to_xml(self.context)
|
||||
self.assert_no_xpath(xml, "//input[@size]", self.context)
|
||||
|
||||
def test_size(self):
|
||||
self.context['size'] = '40'
|
||||
xml = self.render_to_xml(self.context)
|
||||
|
||||
self.assert_has_xpath(xml, "//input[@size='40']", self.context)
|
||||
|
||||
class AnnotationInputTemplateTest(TemplateTestCase):
|
||||
"""
|
||||
Test mako template for `<annotationinput>` input.
|
||||
|
||||
@@ -1,3 +1,4 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
Tests of input types.
|
||||
|
||||
@@ -23,7 +24,8 @@ import xml.sax.saxutils as saxutils
|
||||
|
||||
from . import test_system
|
||||
from capa import inputtypes
|
||||
from mock import ANY
|
||||
from mock import ANY, patch
|
||||
from pyparsing import ParseException
|
||||
|
||||
# just a handy shortcut
|
||||
lookup_tag = inputtypes.registry.get_class_for_tag
|
||||
@@ -47,7 +49,7 @@ class OptionInputTest(unittest.TestCase):
|
||||
'status': 'answered'}
|
||||
option_input = lookup_tag('optioninput')(test_system(), element, state)
|
||||
|
||||
context = option_input._get_render_context()
|
||||
context = option_input._get_render_context() # pylint: disable=W0212
|
||||
|
||||
expected = {'value': 'Down',
|
||||
'options': [('Up', 'Up'), ('Down', 'Down')],
|
||||
@@ -94,7 +96,7 @@ class ChoiceGroupTest(unittest.TestCase):
|
||||
|
||||
the_input = lookup_tag(tag)(test_system(), element, state)
|
||||
|
||||
context = the_input._get_render_context()
|
||||
context = the_input._get_render_context() # pylint: disable=W0212
|
||||
|
||||
expected = {'id': 'sky_input',
|
||||
'value': 'foil3',
|
||||
@@ -144,7 +146,7 @@ class JavascriptInputTest(unittest.TestCase):
|
||||
state = {'value': '3', }
|
||||
the_input = lookup_tag('javascriptinput')(test_system(), element, state)
|
||||
|
||||
context = the_input._get_render_context()
|
||||
context = the_input._get_render_context() # pylint: disable=W0212
|
||||
|
||||
expected = {'id': 'prob_1_2',
|
||||
'status': 'unanswered',
|
||||
@@ -172,7 +174,7 @@ class TextLineTest(unittest.TestCase):
|
||||
state = {'value': 'BumbleBee', }
|
||||
the_input = lookup_tag('textline')(test_system(), element, state)
|
||||
|
||||
context = the_input._get_render_context()
|
||||
context = the_input._get_render_context() # pylint: disable=W0212
|
||||
|
||||
expected = {'id': 'prob_1_2',
|
||||
'value': 'BumbleBee',
|
||||
@@ -200,7 +202,7 @@ class TextLineTest(unittest.TestCase):
|
||||
state = {'value': 'BumbleBee', }
|
||||
the_input = lookup_tag('textline')(test_system(), element, state)
|
||||
|
||||
context = the_input._get_render_context()
|
||||
context = the_input._get_render_context() # pylint: disable=W0212
|
||||
|
||||
expected = {'id': 'prob_1_2',
|
||||
'value': 'BumbleBee',
|
||||
@@ -238,7 +240,7 @@ class TextLineTest(unittest.TestCase):
|
||||
state = {'value': 'BumbleBee', }
|
||||
the_input = lookup_tag('textline')(test_system(), element, state)
|
||||
|
||||
context = the_input._get_render_context()
|
||||
context = the_input._get_render_context() # pylint: disable=W0212
|
||||
|
||||
expected = {'id': 'prob_1_2',
|
||||
'value': 'BumbleBee',
|
||||
@@ -276,7 +278,7 @@ class FileSubmissionTest(unittest.TestCase):
|
||||
input_class = lookup_tag('filesubmission')
|
||||
the_input = input_class(test_system(), element, state)
|
||||
|
||||
context = the_input._get_render_context()
|
||||
context = the_input._get_render_context() # pylint: disable=W0212
|
||||
|
||||
expected = {'id': 'prob_1_2',
|
||||
'status': 'queued',
|
||||
@@ -321,7 +323,7 @@ class CodeInputTest(unittest.TestCase):
|
||||
input_class = lookup_tag('codeinput')
|
||||
the_input = input_class(test_system(), element, state)
|
||||
|
||||
context = the_input._get_render_context()
|
||||
context = the_input._get_render_context() # pylint: disable=W0212
|
||||
|
||||
expected = {'id': 'prob_1_2',
|
||||
'value': 'print "good evening"',
|
||||
@@ -371,7 +373,7 @@ class MatlabTest(unittest.TestCase):
|
||||
self.the_input = self.input_class(test_system(), elt, state)
|
||||
|
||||
def test_rendering(self):
|
||||
context = self.the_input._get_render_context()
|
||||
context = self.the_input._get_render_context() # pylint: disable=W0212
|
||||
|
||||
expected = {'id': 'prob_1_2',
|
||||
'value': 'print "good evening"',
|
||||
@@ -397,7 +399,7 @@ class MatlabTest(unittest.TestCase):
|
||||
elt = etree.fromstring(self.xml)
|
||||
|
||||
the_input = self.input_class(test_system(), elt, state)
|
||||
context = the_input._get_render_context()
|
||||
context = the_input._get_render_context() # pylint: disable=W0212
|
||||
|
||||
expected = {'id': 'prob_1_2',
|
||||
'value': 'print "good evening"',
|
||||
@@ -424,7 +426,7 @@ class MatlabTest(unittest.TestCase):
|
||||
elt = etree.fromstring(self.xml)
|
||||
|
||||
the_input = self.input_class(test_system(), elt, state)
|
||||
context = the_input._get_render_context()
|
||||
context = the_input._get_render_context() # pylint: disable=W0212
|
||||
expected = {'id': 'prob_1_2',
|
||||
'value': 'print "good evening"',
|
||||
'status': status,
|
||||
@@ -449,7 +451,7 @@ class MatlabTest(unittest.TestCase):
|
||||
elt = etree.fromstring(self.xml)
|
||||
|
||||
the_input = self.input_class(test_system(), elt, state)
|
||||
context = the_input._get_render_context()
|
||||
context = the_input._get_render_context() # pylint: disable=W0212
|
||||
expected = {'id': 'prob_1_2',
|
||||
'value': 'print "good evening"',
|
||||
'status': 'queued',
|
||||
@@ -554,7 +556,7 @@ class SchematicTest(unittest.TestCase):
|
||||
|
||||
the_input = lookup_tag('schematic')(test_system(), element, state)
|
||||
|
||||
context = the_input._get_render_context()
|
||||
context = the_input._get_render_context() # pylint: disable=W0212
|
||||
|
||||
expected = {'id': 'prob_1_2',
|
||||
'value': value,
|
||||
@@ -593,7 +595,7 @@ class ImageInputTest(unittest.TestCase):
|
||||
|
||||
the_input = lookup_tag('imageinput')(test_system(), element, state)
|
||||
|
||||
context = the_input._get_render_context()
|
||||
context = the_input._get_render_context() # pylint: disable=W0212
|
||||
|
||||
expected = {'id': 'prob_1_2',
|
||||
'value': value,
|
||||
@@ -644,7 +646,7 @@ class CrystallographyTest(unittest.TestCase):
|
||||
|
||||
the_input = lookup_tag('crystallography')(test_system(), element, state)
|
||||
|
||||
context = the_input._get_render_context()
|
||||
context = the_input._get_render_context() # pylint: disable=W0212
|
||||
|
||||
expected = {'id': 'prob_1_2',
|
||||
'value': value,
|
||||
@@ -682,7 +684,7 @@ class VseprTest(unittest.TestCase):
|
||||
|
||||
the_input = lookup_tag('vsepr_input')(test_system(), element, state)
|
||||
|
||||
context = the_input._get_render_context()
|
||||
context = the_input._get_render_context() # pylint: disable=W0212
|
||||
|
||||
expected = {'id': 'prob_1_2',
|
||||
'value': value,
|
||||
@@ -711,7 +713,7 @@ class ChemicalEquationTest(unittest.TestCase):
|
||||
|
||||
def test_rendering(self):
|
||||
''' Verify that the render context matches the expected render context'''
|
||||
context = self.the_input._get_render_context()
|
||||
context = self.the_input._get_render_context() # pylint: disable=W0212
|
||||
|
||||
expected = {'id': 'prob_1_2',
|
||||
'value': 'H2OYeah',
|
||||
@@ -727,10 +729,168 @@ class ChemicalEquationTest(unittest.TestCase):
|
||||
data = {'formula': "H"}
|
||||
response = self.the_input.handle_ajax("preview_chemcalc", data)
|
||||
|
||||
self.assertTrue('preview' in response)
|
||||
self.assertIn('preview', response)
|
||||
self.assertNotEqual(response['preview'], '')
|
||||
self.assertEqual(response['error'], "")
|
||||
|
||||
def test_ajax_bad_method(self):
|
||||
"""
|
||||
With a bad dispatch, we shouldn't recieve anything
|
||||
"""
|
||||
response = self.the_input.handle_ajax("obviously_not_real", {})
|
||||
self.assertEqual(response, {})
|
||||
|
||||
def test_ajax_no_formula(self):
|
||||
"""
|
||||
When we ask for a formula rendering, there should be an error if no formula
|
||||
"""
|
||||
response = self.the_input.handle_ajax("preview_chemcalc", {})
|
||||
self.assertIn('error', response)
|
||||
self.assertEqual(response['error'], "No formula specified.")
|
||||
|
||||
def test_ajax_parse_err(self):
|
||||
"""
|
||||
With parse errors, ChemicalEquationInput should give an error message
|
||||
"""
|
||||
# Simulate answering a problem that raises the exception
|
||||
with patch('capa.inputtypes.chemcalc.render_to_html') as mock_render:
|
||||
mock_render.side_effect = ParseException(u"ȧƈƈḗƞŧḗḓ ŧḗẋŧ ƒǿř ŧḗşŧīƞɠ")
|
||||
response = self.the_input.handle_ajax(
|
||||
"preview_chemcalc",
|
||||
{'formula': 'H2O + invalid chemistry'}
|
||||
)
|
||||
|
||||
self.assertIn('error', response)
|
||||
self.assertTrue("Couldn't parse formula" in response['error'])
|
||||
|
||||
@patch('capa.inputtypes.log')
|
||||
def test_ajax_other_err(self, mock_log):
|
||||
"""
|
||||
With other errors, test that ChemicalEquationInput also logs it
|
||||
"""
|
||||
with patch('capa.inputtypes.chemcalc.render_to_html') as mock_render:
|
||||
mock_render.side_effect = Exception()
|
||||
response = self.the_input.handle_ajax(
|
||||
"preview_chemcalc",
|
||||
{'formula': 'H2O + superterrible chemistry'}
|
||||
)
|
||||
mock_log.warning.assert_called_once_with(
|
||||
"Error while previewing chemical formula", exc_info=True
|
||||
)
|
||||
self.assertIn('error', response)
|
||||
self.assertEqual(response['error'], "Error while rendering preview")
|
||||
|
||||
|
||||
class FormulaEquationTest(unittest.TestCase):
|
||||
"""
|
||||
Check that formula equation inputs work.
|
||||
"""
|
||||
def setUp(self):
|
||||
self.size = "42"
|
||||
xml_str = """<formulaequationinput id="prob_1_2" size="{size}"/>""".format(size=self.size)
|
||||
|
||||
element = etree.fromstring(xml_str)
|
||||
|
||||
state = {'value': 'x^2+1/2'}
|
||||
self.the_input = lookup_tag('formulaequationinput')(test_system(), element, state)
|
||||
|
||||
def test_rendering(self):
|
||||
"""
|
||||
Verify that the render context matches the expected render context
|
||||
"""
|
||||
context = self.the_input._get_render_context() # pylint: disable=W0212
|
||||
|
||||
expected = {
|
||||
'id': 'prob_1_2',
|
||||
'value': 'x^2+1/2',
|
||||
'status': 'unanswered',
|
||||
'reported_status': '',
|
||||
'msg': '',
|
||||
'size': self.size,
|
||||
'previewer': '/static/js/capa/src/formula_equation_preview.js',
|
||||
}
|
||||
self.assertEqual(context, expected)
|
||||
|
||||
def test_rendering_reported_status(self):
|
||||
"""
|
||||
Verify that the 'reported status' matches expectations.
|
||||
"""
|
||||
test_values = {
|
||||
'': '', # Default
|
||||
'unsubmitted': 'unanswered',
|
||||
'correct': 'correct',
|
||||
'incorrect': 'incorrect',
|
||||
'incomplete': 'incomplete',
|
||||
'not a status': ''
|
||||
}
|
||||
|
||||
for self_status, reported_status in test_values.iteritems():
|
||||
self.the_input.status = self_status
|
||||
context = self.the_input._get_render_context() # pylint: disable=W0212
|
||||
self.assertEqual(context['reported_status'], reported_status)
|
||||
|
||||
def test_formcalc_ajax_sucess(self):
|
||||
"""
|
||||
Verify that using the correct dispatch and valid data produces a valid response
|
||||
"""
|
||||
data = {'formula': "x^2+1/2", 'request_start': 0}
|
||||
response = self.the_input.handle_ajax("preview_formcalc", data)
|
||||
|
||||
self.assertIn('preview', response)
|
||||
self.assertNotEqual(response['preview'], '')
|
||||
self.assertEqual(response['error'], "")
|
||||
self.assertEqual(response['request_start'], data['request_start'])
|
||||
|
||||
def test_ajax_bad_method(self):
|
||||
"""
|
||||
With a bad dispatch, we shouldn't recieve anything
|
||||
"""
|
||||
response = self.the_input.handle_ajax("obviously_not_real", {})
|
||||
self.assertEqual(response, {})
|
||||
|
||||
def test_ajax_no_formula(self):
|
||||
"""
|
||||
When we ask for a formula rendering, there should be an error if no formula
|
||||
"""
|
||||
response = self.the_input.handle_ajax(
|
||||
"preview_formcalc",
|
||||
{'request_start': 1, }
|
||||
)
|
||||
self.assertIn('error', response)
|
||||
self.assertEqual(response['error'], "No formula specified.")
|
||||
|
||||
def test_ajax_parse_err(self):
|
||||
"""
|
||||
With parse errors, FormulaEquationInput should give an error message
|
||||
"""
|
||||
# Simulate answering a problem that raises the exception
|
||||
with patch('capa.inputtypes.latex_preview') as mock_preview:
|
||||
mock_preview.side_effect = ParseException("Oopsie")
|
||||
response = self.the_input.handle_ajax(
|
||||
"preview_formcalc",
|
||||
{'formula': 'x^2+1/2', 'request_start': 1, }
|
||||
)
|
||||
|
||||
self.assertIn('error', response)
|
||||
self.assertEqual(response['error'], "Sorry, couldn't parse formula")
|
||||
|
||||
@patch('capa.inputtypes.log')
|
||||
def test_ajax_other_err(self, mock_log):
|
||||
"""
|
||||
With other errors, test that FormulaEquationInput also logs it
|
||||
"""
|
||||
with patch('capa.inputtypes.latex_preview') as mock_preview:
|
||||
mock_preview.side_effect = Exception()
|
||||
response = self.the_input.handle_ajax(
|
||||
"preview_formcalc",
|
||||
{'formula': 'x^2+1/2', 'request_start': 1, }
|
||||
)
|
||||
mock_log.warning.assert_called_once_with(
|
||||
"Error while previewing formula", exc_info=True
|
||||
)
|
||||
self.assertIn('error', response)
|
||||
self.assertEqual(response['error'], "Error while rendering preview")
|
||||
|
||||
|
||||
class DragAndDropTest(unittest.TestCase):
|
||||
'''
|
||||
@@ -784,7 +944,7 @@ class DragAndDropTest(unittest.TestCase):
|
||||
|
||||
the_input = lookup_tag('drag_and_drop_input')(test_system(), element, state)
|
||||
|
||||
context = the_input._get_render_context()
|
||||
context = the_input._get_render_context() # pylint: disable=W0212
|
||||
expected = {'id': 'prob_1_2',
|
||||
'value': value,
|
||||
'status': 'unsubmitted',
|
||||
@@ -833,7 +993,7 @@ class AnnotationInputTest(unittest.TestCase):
|
||||
|
||||
the_input = lookup_tag(tag)(test_system(), element, state)
|
||||
|
||||
context = the_input._get_render_context()
|
||||
context = the_input._get_render_context() # pylint: disable=W0212
|
||||
|
||||
expected = {
|
||||
'id': 'annotation_input',
|
||||
@@ -920,7 +1080,7 @@ class TestChoiceText(unittest.TestCase):
|
||||
}
|
||||
expected.update(state)
|
||||
the_input = lookup_tag(tag)(test_system(), element, state)
|
||||
context = the_input._get_render_context()
|
||||
context = the_input._get_render_context() # pylint: disable=W0212
|
||||
self.assertEqual(context, expected)
|
||||
|
||||
def test_radiotextgroup(self):
|
||||
|
||||
@@ -32,7 +32,7 @@ $wrongans</tt> to see a hint.</p>
|
||||
|
||||
<formularesponse samples="x@-5:5#11" id="11" answer="$answer">
|
||||
<responseparam description="Numerical Tolerance" type="tolerance" default="0.001" name="tol" />
|
||||
<text>y = <textline size="25" /></text>
|
||||
<text>y = <formulaequationinput size="25" /></text>
|
||||
<hintgroup>
|
||||
<formulahint samples="x@-5:5#11" answer="$wrongans" name="inversegrad">
|
||||
</formulahint>
|
||||
|
||||
@@ -173,7 +173,7 @@ section.problem {
|
||||
}
|
||||
}
|
||||
|
||||
&.incorrect, &.ui-icon-close {
|
||||
&.incorrect, &.incomplete, &.ui-icon-close {
|
||||
p.status {
|
||||
@include inline-block();
|
||||
background: url('../images/incorrect-icon.png') center center no-repeat;
|
||||
@@ -214,6 +214,16 @@ section.problem {
|
||||
clear: both;
|
||||
margin-top: 3px;
|
||||
|
||||
.MathJax_Display {
|
||||
display: inline-block;
|
||||
width: auto;
|
||||
}
|
||||
|
||||
img.loading {
|
||||
display: inline-block;
|
||||
padding-left: 10px;
|
||||
}
|
||||
|
||||
span {
|
||||
margin-bottom: 0;
|
||||
|
||||
@@ -265,7 +275,7 @@ section.problem {
|
||||
width: 25px;
|
||||
}
|
||||
|
||||
&.incorrect, &.ui-icon-close {
|
||||
&.incorrect, &.incomplete, &.ui-icon-close {
|
||||
@include inline-block();
|
||||
background: url('../images/incorrect-icon.png') center center no-repeat;
|
||||
height: 20px;
|
||||
|
||||
@@ -121,18 +121,18 @@ describe 'MarkdownEditingDescriptor', ->
|
||||
<p>Enter the numerical value of Pi:</p>
|
||||
<numericalresponse answer="3.14159">
|
||||
<responseparam type="tolerance" default=".02" />
|
||||
<textline />
|
||||
<formulaequationinput />
|
||||
</numericalresponse>
|
||||
|
||||
<p>Enter the approximate value of 502*9:</p>
|
||||
<numericalresponse answer="4518">
|
||||
<responseparam type="tolerance" default="15%" />
|
||||
<textline />
|
||||
<formulaequationinput />
|
||||
</numericalresponse>
|
||||
|
||||
<p>Enter the number of fingers on a human hand:</p>
|
||||
<numericalresponse answer="5">
|
||||
<textline />
|
||||
<formulaequationinput />
|
||||
</numericalresponse>
|
||||
|
||||
<solution>
|
||||
@@ -157,7 +157,7 @@ describe 'MarkdownEditingDescriptor', ->
|
||||
<p>Enter 0 with a tolerance:</p>
|
||||
<numericalresponse answer="0">
|
||||
<responseparam type="tolerance" default=".02" />
|
||||
<textline />
|
||||
<formulaequationinput />
|
||||
</numericalresponse>
|
||||
|
||||
|
||||
|
||||
@@ -239,7 +239,7 @@ class @MarkdownEditingDescriptor extends XModule.Descriptor
|
||||
} else {
|
||||
string = '<numericalresponse answer="' + floatValue + '">\n';
|
||||
}
|
||||
string += ' <textline />\n';
|
||||
string += ' <formulaequationinput />\n';
|
||||
string += '</numericalresponse>\n\n';
|
||||
} else {
|
||||
string = '<stringresponse answer="' + p + '" type="ci">\n <textline size="20"/>\n</stringresponse>\n\n';
|
||||
|
||||
@@ -24,15 +24,15 @@ data: |
|
||||
</script>
|
||||
<p>Give an equation for the relativistic energy of an object with mass m. Explicitly indicate multiplication with a <tt>*</tt> symbol.</p>
|
||||
<formularesponse type="cs" samples="m,c@1,2:3,4#10" answer="m*c^2">
|
||||
<responseparam type="tolerance" default="0.00001"/>
|
||||
<br/><text>E =</text> <textline size="40" math="1" />
|
||||
<responseparam type="tolerance" default="0.00001"/>
|
||||
<br/><text>E =</text> <formulaequationinput size="40" />
|
||||
</formularesponse>
|
||||
|
||||
<p>The answer to this question is (R_1*R_2)/R_3. </p>
|
||||
|
||||
<formularesponse type="ci" samples="R_1,R_2,R_3@1,2,3:3,4,5#10" answer="$VoVi">
|
||||
<responseparam type="tolerance" default="0.00001"/>
|
||||
<textline size="40" math="1" />
|
||||
<formulaequationinput size="40" />
|
||||
</formularesponse>
|
||||
<solution>
|
||||
<div class="detailed-solution">
|
||||
|
||||
@@ -119,9 +119,8 @@ data: |
|
||||
<p>
|
||||
<p style="display:inline">Energy saved = </p>
|
||||
<numericalresponse inline="1" answer="0.52">
|
||||
<textline inline="1">
|
||||
<responseparam description="Numerical Tolerance" type="tolerance" default="0.02" name="tol"/>
|
||||
</textline>
|
||||
<responseparam description="Numerical Tolerance" type="tolerance" default="0.02" name="tol"/>
|
||||
<formulaequationinput/>
|
||||
</numericalresponse>
|
||||
<p style="display:inline"> EJ/year</p>
|
||||
</p>
|
||||
|
||||
@@ -47,19 +47,19 @@ data: |
|
||||
<p>Enter the numerical value of Pi:
|
||||
<numericalresponse answer="3.14159">
|
||||
<responseparam type="tolerance" default=".02" />
|
||||
<textline />
|
||||
<formulaequationinput />
|
||||
</numericalresponse>
|
||||
</p>
|
||||
<p>Enter the approximate value of 502*9:
|
||||
<numericalresponse answer="$computed_response">
|
||||
<responseparam type="tolerance" default="15%"/>
|
||||
<textline />
|
||||
<formulaequationinput />
|
||||
</numericalresponse>
|
||||
</p>
|
||||
|
||||
<p>Enter the number of fingers on a human hand:
|
||||
<numericalresponse answer="5">
|
||||
<textline />
|
||||
<formulaequationinput />
|
||||
</numericalresponse>
|
||||
</p>
|
||||
<solution>
|
||||
|
||||
@@ -71,51 +71,6 @@ class ModelsTest(unittest.TestCase):
|
||||
vc_str = "<class 'xmodule.video_module.VideoDescriptor'>"
|
||||
self.assertEqual(str(vc), vc_str)
|
||||
|
||||
def test_calc(self):
|
||||
variables = {'R1': 2.0, 'R3': 4.0}
|
||||
functions = {'sin': numpy.sin, 'cos': numpy.cos}
|
||||
|
||||
self.assertTrue(abs(calc.evaluator(variables, functions, "10000||sin(7+5)+0.5356")) < 0.01)
|
||||
self.assertEqual(calc.evaluator({'R1': 2.0, 'R3': 4.0}, {}, "13"), 13)
|
||||
self.assertEqual(calc.evaluator(variables, functions, "13"), 13)
|
||||
self.assertEqual(calc.evaluator({'a': 2.2997471478310274, 'k': 9, 'm': 8, 'x': 0.66009498411213041}, {}, "5"), 5)
|
||||
self.assertEqual(calc.evaluator({}, {}, "-1"), -1)
|
||||
self.assertEqual(calc.evaluator({}, {}, "-0.33"), -.33)
|
||||
self.assertEqual(calc.evaluator({}, {}, "-.33"), -.33)
|
||||
self.assertEqual(calc.evaluator(variables, functions, "R1*R3"), 8.0)
|
||||
self.assertTrue(abs(calc.evaluator(variables, functions, "sin(e)-0.41")) < 0.01)
|
||||
self.assertTrue(abs(calc.evaluator(variables, functions, "k*T/q-0.025")) < 0.001)
|
||||
self.assertTrue(abs(calc.evaluator(variables, functions, "e^(j*pi)") + 1) < 0.00001)
|
||||
self.assertTrue(abs(calc.evaluator(variables, functions, "j||1") - 0.5 - 0.5j) < 0.00001)
|
||||
variables['t'] = 1.0
|
||||
# Use self.assertAlmostEqual here...
|
||||
self.assertTrue(abs(calc.evaluator(variables, functions, "t") - 1.0) < 0.00001)
|
||||
self.assertTrue(abs(calc.evaluator(variables, functions, "T") - 1.0) < 0.00001)
|
||||
self.assertTrue(abs(calc.evaluator(variables, functions, "t", cs=True) - 1.0) < 0.00001)
|
||||
self.assertTrue(abs(calc.evaluator(variables, functions, "T", cs=True) - 298) < 0.2)
|
||||
# Use self.assertRaises here...
|
||||
exception_happened = False
|
||||
try:
|
||||
calc.evaluator({}, {}, "5+7 QWSEKO")
|
||||
except:
|
||||
exception_happened = True
|
||||
self.assertTrue(exception_happened)
|
||||
|
||||
try:
|
||||
calc.evaluator({'r1': 5}, {}, "r1+r2")
|
||||
except calc.UndefinedVariable:
|
||||
pass
|
||||
|
||||
self.assertEqual(calc.evaluator(variables, functions, "r1*r3"), 8.0)
|
||||
|
||||
exception_happened = False
|
||||
try:
|
||||
calc.evaluator(variables, functions, "r1*r3", cs=True)
|
||||
except:
|
||||
exception_happened = True
|
||||
self.assertTrue(exception_happened)
|
||||
|
||||
|
||||
class PostData(object):
|
||||
"""Class which emulate postdata."""
|
||||
def __init__(self, dict_data):
|
||||
|
||||
@@ -28,7 +28,7 @@ class CHModuleFactory(object):
|
||||
<p>The answer is correct if it is within a specified numerical tolerance of the expected answer.</p>
|
||||
<p>Enter the number of fingers on a human hand:</p>
|
||||
<numericalresponse answer="5">
|
||||
<textline/>
|
||||
<formulaequationinput/>
|
||||
</numericalresponse>
|
||||
<solution>
|
||||
<div class="detailed-solution">
|
||||
@@ -114,7 +114,7 @@ class VerticalWithModulesFactory(object):
|
||||
<problem display_name="Numerical Input" markdown=" " rerandomize="never" showanswer="finished">
|
||||
<p>Test numerical problem.</p>
|
||||
<numericalresponse answer="5">
|
||||
<textline/>
|
||||
<formulaequationinput/>
|
||||
</numericalresponse>
|
||||
<solution>
|
||||
<div class="detailed-solution">
|
||||
@@ -129,7 +129,7 @@ class VerticalWithModulesFactory(object):
|
||||
<problem display_name="Numerical Input" markdown=" " rerandomize="never" showanswer="finished">
|
||||
<p>Another test numerical problem.</p>
|
||||
<numericalresponse answer="5">
|
||||
<textline/>
|
||||
<formulaequationinput/>
|
||||
</numericalresponse>
|
||||
<solution>
|
||||
<div class="detailed-solution">
|
||||
|
||||
379
common/static/js/capa/spec/formula_equation_preview_spec.js
Normal file
379
common/static/js/capa/spec/formula_equation_preview_spec.js
Normal file
@@ -0,0 +1,379 @@
|
||||
function callPeriodicallyUntil(block, delay, condition, i) { // i is optional
|
||||
i = i || 0;
|
||||
block(i);
|
||||
waits(delay);
|
||||
runs(function () {
|
||||
if (!condition()) {
|
||||
callPeriodicallyUntil(block, delay, condition, i + 1);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
describe("Formula Equation Preview", function () {
|
||||
beforeEach(function () {
|
||||
// Simulate an environment conducive to a FormulaEquationInput
|
||||
var $fixture = this.$fixture = $('\
|
||||
<section class="problems-wrapper" data-url="THE_URL">\
|
||||
<section class="formulaequationinput">\
|
||||
<input type="text" id="input_THE_ID" data-input-id="THE_ID"\
|
||||
value="prefilled_value"/>\
|
||||
<div id="input_THE_ID_preview" class="equation">\
|
||||
\[\]\
|
||||
<img class="loading" style="visibility:hidden"/>\
|
||||
</div>\
|
||||
</section>\
|
||||
</section>');
|
||||
|
||||
// Modify $ for the test to search the fixture.
|
||||
var old$find = this.old$find = $.find;
|
||||
$.find = function () {
|
||||
// Given the default context, swap it out for the fixture.
|
||||
if (arguments[1] == document) {
|
||||
arguments[1] = $fixture[0];
|
||||
}
|
||||
|
||||
// Call old function.
|
||||
return old$find.apply(this, arguments);
|
||||
}
|
||||
$.find.matchesSelector = old$find.matchesSelector;
|
||||
|
||||
this.oldDGEBI = document.getElementById;
|
||||
document.getElementById = function (id) {
|
||||
return $("*#" + id)[0] || null;
|
||||
};
|
||||
|
||||
// Catch the AJAX requests
|
||||
var ajaxTimes = this.ajaxTimes = [];
|
||||
this.oldProblem = window.Problem;
|
||||
|
||||
window.Problem = {};
|
||||
Problem.inputAjax = jasmine.createSpy('Problem.inputAjax')
|
||||
.andCallFake(function () {
|
||||
ajaxTimes.push(Date.now());
|
||||
});
|
||||
|
||||
// Spy on MathJax
|
||||
this.jax = 'OUTPUT_JAX';
|
||||
this.oldMathJax = window.MathJax;
|
||||
|
||||
window.MathJax = {Hub: {}};
|
||||
MathJax.Hub.getAllJax = jasmine.createSpy('MathJax.Hub.getAllJax')
|
||||
.andReturn([this.jax]);
|
||||
MathJax.Hub.Queue = jasmine.createSpy('MathJax.Hub.Queue');
|
||||
});
|
||||
|
||||
it('(the test) should be able to swap out the behavior of $', function () {
|
||||
// This was a pain to write, make sure it doesn't get screwed up.
|
||||
|
||||
// Find the DOM element using DOM methods.
|
||||
var legitInput = this.$fixture[0].getElementsByTagName("input")[0];
|
||||
|
||||
// Use the (modified) jQuery.
|
||||
var jqueryInput = $('.formulaequationinput input');
|
||||
var byIdInput = $("#input_THE_ID");
|
||||
|
||||
expect(jqueryInput[0]).toEqual(legitInput);
|
||||
expect(byIdInput[0]).toEqual(legitInput);
|
||||
});
|
||||
|
||||
describe('Ajax requests', function () {
|
||||
it('has an initial request with the correct parameters', function () {
|
||||
formulaEquationPreview.enable();
|
||||
|
||||
expect(MathJax.Hub.Queue).toHaveBeenCalled();
|
||||
// Do what Queue would've done--call the function.
|
||||
var args = MathJax.Hub.Queue.mostRecentCall.args;
|
||||
args[1].call(args[0]);
|
||||
|
||||
// This part may be asynchronous, so wait.
|
||||
waitsFor(function () {
|
||||
return Problem.inputAjax.wasCalled;
|
||||
}, "AJAX never called initially", 1000);
|
||||
|
||||
runs(function () {
|
||||
expect(Problem.inputAjax.callCount).toEqual(1);
|
||||
|
||||
// Use `.toEqual` rather than `.toHaveBeenCalledWith`
|
||||
// since it supports `jasmine.any`.
|
||||
expect(Problem.inputAjax.mostRecentCall.args).toEqual([
|
||||
"THE_URL",
|
||||
"THE_ID",
|
||||
"preview_formcalc",
|
||||
{formula: "prefilled_value",
|
||||
request_start: jasmine.any(Number)},
|
||||
jasmine.any(Function)
|
||||
]);
|
||||
});
|
||||
});
|
||||
|
||||
it('makes a request on user input', function () {
|
||||
formulaEquationPreview.enable();
|
||||
$('#input_THE_ID').val('user_input').trigger('input');
|
||||
|
||||
// This part is probably asynchronous
|
||||
waitsFor(function () {
|
||||
return Problem.inputAjax.wasCalled;
|
||||
}, "AJAX never called on user input", 1000);
|
||||
|
||||
runs(function () {
|
||||
expect(Problem.inputAjax.mostRecentCall.args[3].formula
|
||||
).toEqual('user_input');
|
||||
});
|
||||
});
|
||||
|
||||
it("shouldn't be requested for empty input", function () {
|
||||
formulaEquationPreview.enable();
|
||||
MathJax.Hub.Queue.reset();
|
||||
|
||||
// When we make an input of '',
|
||||
$('#input_THE_ID').val('').trigger('input');
|
||||
|
||||
// Either it makes a request or jumps straight into displaying ''.
|
||||
waitsFor(function () {
|
||||
// (Short circuit if `inputAjax` is indeed called)
|
||||
return Problem.inputAjax.wasCalled ||
|
||||
MathJax.Hub.Queue.wasCalled;
|
||||
}, "AJAX never called on user input", 1000);
|
||||
|
||||
runs(function () {
|
||||
// Expect the request not to have been called.
|
||||
expect(Problem.inputAjax).not.toHaveBeenCalled();
|
||||
});
|
||||
});
|
||||
|
||||
it('should limit the number of requests per second', function () {
|
||||
formulaEquationPreview.enable();
|
||||
|
||||
var minDelay = formulaEquationPreview.minDelay;
|
||||
var end = Date.now() + minDelay * 1.1;
|
||||
var step = 10; // ms
|
||||
|
||||
var $input = $('#input_THE_ID');
|
||||
var value;
|
||||
function inputAnother(iter) {
|
||||
value = "math input " + iter;
|
||||
$input.val(value).trigger('input');
|
||||
}
|
||||
|
||||
callPeriodicallyUntil(inputAnother, step, function () {
|
||||
return Date.now() > end; // Stop when we get to `end`.
|
||||
});
|
||||
|
||||
waitsFor(function () {
|
||||
return Problem.inputAjax.wasCalled &&
|
||||
Problem.inputAjax.mostRecentCall.args[3].formula == value;
|
||||
}, "AJAX never called with final value from input", 1000);
|
||||
|
||||
runs(function () {
|
||||
// There should be 2 or 3 calls (depending on leading edge).
|
||||
expect(Problem.inputAjax.callCount).not.toBeGreaterThan(3);
|
||||
|
||||
// The calls should happen approximately `minDelay` apart.
|
||||
for (var i =1; i < this.ajaxTimes.length; i ++) {
|
||||
var diff = this.ajaxTimes[i] - this.ajaxTimes[i - 1];
|
||||
expect(diff).toBeGreaterThan(minDelay - 10);
|
||||
}
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("Visible results (icon and mathjax)", function () {
|
||||
it('should display a loading icon when requests are open', function () {
|
||||
formulaEquationPreview.enable();
|
||||
var $img = $("img.loading");
|
||||
expect($img.css('visibility')).toEqual('hidden');
|
||||
|
||||
$("#input_THE_ID").val("different").trigger('input');
|
||||
expect($img.css('visibility')).toEqual('visible');
|
||||
|
||||
// Don't let it fail later.
|
||||
waitsFor(function () {
|
||||
return Problem.inputAjax.wasCalled;
|
||||
});
|
||||
});
|
||||
|
||||
it('should update MathJax and loading icon on callback', function () {
|
||||
formulaEquationPreview.enable();
|
||||
$('#input_THE_ID').val('user_input').trigger('input');
|
||||
|
||||
waitsFor(function () {
|
||||
return Problem.inputAjax.wasCalled;
|
||||
}, "AJAX never called initially", 1000);
|
||||
|
||||
runs(function () {
|
||||
var args = Problem.inputAjax.mostRecentCall.args;
|
||||
var callback = args[4];
|
||||
callback({
|
||||
preview: 'THE_FORMULA',
|
||||
request_start: args[3].request_start
|
||||
});
|
||||
|
||||
// The only request returned--it should hide the loading icon.
|
||||
expect($("img.loading").css('visibility')).toEqual('hidden');
|
||||
|
||||
// We should look in the preview div for the MathJax.
|
||||
var previewDiv = $("div")[0];
|
||||
expect(MathJax.Hub.getAllJax).toHaveBeenCalledWith(previewDiv);
|
||||
|
||||
// Refresh the MathJax.
|
||||
expect(MathJax.Hub.Queue).toHaveBeenCalledWith(
|
||||
['Text', this.jax, 'THE_FORMULA'],
|
||||
['Reprocess', this.jax]
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
it('should display errors from the server well', function () {
|
||||
var $img = $("img.loading");
|
||||
formulaEquationPreview.enable();
|
||||
MathJax.Hub.Queue.reset();
|
||||
$("#input_THE_ID").val("different").trigger('input');
|
||||
|
||||
waitsFor(function () {
|
||||
return Problem.inputAjax.wasCalled;
|
||||
}, "AJAX never called initially", 1000);
|
||||
|
||||
runs(function () {
|
||||
var args = Problem.inputAjax.mostRecentCall.args;
|
||||
var callback = args[4];
|
||||
callback({
|
||||
error: 'OOPSIE',
|
||||
request_start: args[3].request_start
|
||||
});
|
||||
expect(MathJax.Hub.Queue).not.toHaveBeenCalled();
|
||||
expect($img.css('visibility')).toEqual('visible');
|
||||
});
|
||||
|
||||
var errorDelay = formulaEquationPreview.errorDelay * 1.1;
|
||||
waitsFor(function () {
|
||||
return MathJax.Hub.Queue.wasCalled;
|
||||
}, "Error message never displayed", 2000);
|
||||
|
||||
runs(function () {
|
||||
// Refresh the MathJax.
|
||||
expect(MathJax.Hub.Queue).toHaveBeenCalledWith(
|
||||
['Text', this.jax, '\\text{OOPSIE}'],
|
||||
['Reprocess', this.jax]
|
||||
);
|
||||
expect($img.css('visibility')).toEqual('hidden');
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('Multiple callbacks', function () {
|
||||
beforeEach(function () {
|
||||
formulaEquationPreview.enable();
|
||||
MathJax.Hub.Queue.reset();
|
||||
$('#input_THE_ID').val('different').trigger('input');
|
||||
|
||||
waitsFor(function () {
|
||||
return Problem.inputAjax.wasCalled;
|
||||
});
|
||||
|
||||
runs(function () {
|
||||
$("#input_THE_ID").val("different2").trigger('input');
|
||||
});
|
||||
|
||||
waitsFor(function () {
|
||||
return Problem.inputAjax.callCount > 1;
|
||||
});
|
||||
|
||||
runs(function () {
|
||||
var args = Problem.inputAjax.argsForCall;
|
||||
var response0 = {
|
||||
preview: 'THE_FORMULA_0',
|
||||
request_start: args[0][3].request_start
|
||||
};
|
||||
var response1 = {
|
||||
preview: 'THE_FORMULA_1',
|
||||
request_start: args[1][3].request_start
|
||||
};
|
||||
|
||||
this.callbacks = [args[0][4], args[1][4]];
|
||||
this.responses = [response0, response1];
|
||||
});
|
||||
});
|
||||
|
||||
it('should update requests sequentially', function () {
|
||||
var $img = $("img.loading");
|
||||
|
||||
expect($img.css('visibility')).toEqual('visible');
|
||||
|
||||
this.callbacks[0](this.responses[0]);
|
||||
expect(MathJax.Hub.Queue).toHaveBeenCalledWith(
|
||||
['Text', this.jax, 'THE_FORMULA_0'],
|
||||
['Reprocess', this.jax]
|
||||
);
|
||||
expect($img.css('visibility')).toEqual('visible');
|
||||
|
||||
this.callbacks[1](this.responses[1]);
|
||||
expect(MathJax.Hub.Queue).toHaveBeenCalledWith(
|
||||
['Text', this.jax, 'THE_FORMULA_1'],
|
||||
['Reprocess', this.jax]
|
||||
);
|
||||
expect($img.css('visibility')).toEqual('hidden')
|
||||
});
|
||||
|
||||
it("shouldn't display outdated information", function () {
|
||||
var $img = $("img.loading");
|
||||
|
||||
expect($img.css('visibility')).toEqual('visible');
|
||||
|
||||
// Switch the order (1 returns before 0)
|
||||
this.callbacks[1](this.responses[1]);
|
||||
expect(MathJax.Hub.Queue).toHaveBeenCalledWith(
|
||||
['Text', this.jax, 'THE_FORMULA_1'],
|
||||
['Reprocess', this.jax]
|
||||
);
|
||||
expect($img.css('visibility')).toEqual('hidden')
|
||||
|
||||
MathJax.Hub.Queue.reset();
|
||||
this.callbacks[0](this.responses[0]);
|
||||
expect(MathJax.Hub.Queue).not.toHaveBeenCalled();
|
||||
expect($img.css('visibility')).toEqual('hidden')
|
||||
});
|
||||
|
||||
it("shouldn't show an error if the responses are close together",
|
||||
function () {
|
||||
this.callbacks[0]({
|
||||
error: 'OOPSIE',
|
||||
request_start: this.responses[0].request_start
|
||||
});
|
||||
expect(MathJax.Hub.Queue).not.toHaveBeenCalled();
|
||||
// Error message waiting to be displayed
|
||||
|
||||
this.callbacks[1](this.responses[1]);
|
||||
expect(MathJax.Hub.Queue).toHaveBeenCalledWith(
|
||||
['Text', this.jax, 'THE_FORMULA_1'],
|
||||
['Reprocess', this.jax]
|
||||
);
|
||||
|
||||
// Make sure that it doesn't indeed show up later
|
||||
MathJax.Hub.Queue.reset();
|
||||
var errorDelay = formulaEquationPreview.errorDelay * 1.1;
|
||||
waits(errorDelay);
|
||||
|
||||
runs(function () {
|
||||
expect(MathJax.Hub.Queue).not.toHaveBeenCalled();
|
||||
})
|
||||
});
|
||||
});
|
||||
|
||||
afterEach(function () {
|
||||
// Return jQuery
|
||||
$.find = this.old$find;
|
||||
document.getElementById = this.oldDGEBI;
|
||||
|
||||
// Return Problem
|
||||
Problem = this.oldProblem;
|
||||
if (Problem === undefined) {
|
||||
delete Problem;
|
||||
}
|
||||
|
||||
// Return MathJax
|
||||
MathJax = this.oldMathJax;
|
||||
if (MathJax === undefined) {
|
||||
delete MathJax;
|
||||
}
|
||||
});
|
||||
});
|
||||
@@ -1,4 +1,4 @@
|
||||
describe("A jsinput has:", function () {
|
||||
xdescribe("A jsinput has:", function () {
|
||||
|
||||
beforeEach(function () {
|
||||
$('#fixture').remove();
|
||||
161
common/static/js/capa/src/formula_equation_preview.js
Normal file
161
common/static/js/capa/src/formula_equation_preview.js
Normal file
@@ -0,0 +1,161 @@
|
||||
var formulaEquationPreview = {
|
||||
minDelay: 300, // Minimum time between requests sent out.
|
||||
errorDelay: 1500 // Wait time before showing error (prevent frustration).
|
||||
};
|
||||
|
||||
/** Setup the FormulaEquationInputs and associated javascript code. */
|
||||
formulaEquationPreview.enable = function () {
|
||||
|
||||
/**
|
||||
* Accumulate all the variables and attach event handlers.
|
||||
* This includes rate-limiting `sendRequest` and creating a closure for
|
||||
* its callback.
|
||||
*/
|
||||
function setupInput() {
|
||||
var $this = $(this); // cache the jQuery object
|
||||
|
||||
var $preview = $("#" + this.id + "_preview");
|
||||
var inputData = {
|
||||
// These are the mutable values
|
||||
|
||||
lastSent: 0,
|
||||
isWaitingForRequest: false,
|
||||
requestVisible: 0,
|
||||
errorDelayTimeout: null,
|
||||
|
||||
// The following don't change
|
||||
|
||||
// Find the URL from the closest parent problems-wrapper.
|
||||
url: $this.closest('.problems-wrapper').data('url'),
|
||||
// Grab the input id from the input.
|
||||
inputId: $this.data('input-id'),
|
||||
|
||||
// Store the DOM/MathJax elements in which visible output occurs.
|
||||
$preview: $preview,
|
||||
// Note: sometimes MathJax hasn't finished loading yet.
|
||||
jax: MathJax.Hub.getAllJax($preview[0])[0],
|
||||
$img: $preview.find("img.loading"),
|
||||
|
||||
requestCallback: null // Fill it in in a bit.
|
||||
};
|
||||
|
||||
// Give callback access to `inputData` (fill in first parameter).
|
||||
inputData.requestCallback = _.partial(updatePage, inputData);
|
||||
|
||||
// Limit `sendRequest` and have it show the loading icon.
|
||||
var throttledRequest = _.throttle(
|
||||
sendRequest,
|
||||
formulaEquationPreview.minDelay,
|
||||
{leading: false}
|
||||
);
|
||||
// The following acts as a closure of `inputData`.
|
||||
var initializeRequest = function () {
|
||||
// Show the loading icon.
|
||||
inputData.$img.css('visibility', 'visible');
|
||||
|
||||
inputData.isWaitingForRequest = true;
|
||||
throttledRequest(inputData, this.value);
|
||||
};
|
||||
|
||||
$this.on("input", initializeRequest);
|
||||
// send an initial
|
||||
MathJax.Hub.Queue(this, initializeRequest);
|
||||
}
|
||||
|
||||
/**
|
||||
* Fire off a request for a preview of the current value.
|
||||
* Also send along the time it was sent, and store that locally.
|
||||
*/
|
||||
function sendRequest(inputData, formula) {
|
||||
// Save the time.
|
||||
var now = Date.now();
|
||||
inputData.lastSent = now;
|
||||
// We're sending it.
|
||||
inputData.isWaitingForRequest = false;
|
||||
|
||||
if (formula) {
|
||||
// Send the request.
|
||||
Problem.inputAjax(
|
||||
inputData.url,
|
||||
inputData.inputId,
|
||||
'preview_formcalc',
|
||||
{"formula" : formula, "request_start" : now},
|
||||
inputData.requestCallback
|
||||
);
|
||||
// ).fail(function () {
|
||||
// // This is run when ajax call fails.
|
||||
// // Have an error message and other stuff here?
|
||||
// inputData.$img.css('visibility', 'hidden');
|
||||
// }); */
|
||||
}
|
||||
else {
|
||||
inputData.requestCallback({
|
||||
preview: '',
|
||||
request_start: now
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Respond to the preview request if need be.
|
||||
* Stop if it is outdated (i.e. a later request arrived back earlier)
|
||||
* Otherwise:
|
||||
* -Refresh the MathJax
|
||||
* -Stop the loading icon if this is the most recent request
|
||||
* -Save which request is visible
|
||||
*/
|
||||
function updatePage(inputData, response) {
|
||||
var requestStart = response['request_start'];
|
||||
if (requestStart == inputData.lastSent &&
|
||||
!inputData.isWaitingForRequest) {
|
||||
// Disable icon.
|
||||
inputData.$img.css('visibility', 'hidden');
|
||||
}
|
||||
|
||||
if (requestStart <= inputData.requestVisible) {
|
||||
// This is an old request.
|
||||
return;
|
||||
}
|
||||
|
||||
// Save the value of the last response displayed.
|
||||
inputData.requestVisible = requestStart;
|
||||
|
||||
// Prevent an old error message from showing.
|
||||
if (inputData.errorWaitTimeout != null) {
|
||||
window.clearTimeout(inputData.errorWaitTimeout);
|
||||
}
|
||||
|
||||
function display(latex) {
|
||||
// Load jax if it failed before.
|
||||
if (!inputData.jax) {
|
||||
results = MathJax.Hub.getAllJax(inputData.$preview[0]);
|
||||
if (!results.length) {
|
||||
console.log("Unable to find MathJax to display");
|
||||
return;
|
||||
}
|
||||
inputData.jax = results[0];
|
||||
}
|
||||
|
||||
// Set the text as the latex code, and then update the MathJax.
|
||||
MathJax.Hub.Queue(
|
||||
['Text', inputData.jax, latex],
|
||||
['Reprocess', inputData.jax]
|
||||
);
|
||||
}
|
||||
|
||||
if (response.error) {
|
||||
inputData.$img.css('visibility', 'visible');
|
||||
inputData.errorWaitTimeout = window.setTimeout(function () {
|
||||
display("\\text{" + response.error + "}");
|
||||
inputData.$img.css('visibility', 'hidden');
|
||||
}, formulaEquationPreview.errorDelay);
|
||||
} else {
|
||||
display(response.preview);
|
||||
}
|
||||
}
|
||||
|
||||
// Invoke the setup method.
|
||||
$('.formulaequationinput input').each(setupInput);
|
||||
};
|
||||
|
||||
formulaEquationPreview.enable();
|
||||
@@ -328,6 +328,12 @@ expected answer.
|
||||
The expected answer can be specified explicitly or precomputed by a Python
|
||||
script.
|
||||
|
||||
Accepted input types include ``<formulaequationinput />`` and ``<textline />``.
|
||||
However, the math display on ``<textline math="1" />`` uses a different parser
|
||||
and has different capabilities than the response type--this may lead to student
|
||||
confusion. For this reason, we strongly urge using ``<formulaequationinput />``
|
||||
only, and the examples below show its use.
|
||||
|
||||
Sample Problem:
|
||||
|
||||
.. image:: ../Images/image292.png
|
||||
@@ -343,14 +349,14 @@ Sample Problem:
|
||||
|
||||
<p>What base is the decimal numeral system in?
|
||||
<numericalresponse answer="10">
|
||||
<textline />
|
||||
<formulaequationinput />
|
||||
</numericalresponse>
|
||||
</p>
|
||||
|
||||
<p>What is the value of the standard gravity constant <i>g</i>, measured in m/s<sup>2</sup>? Give your answer to at least two decimal places.
|
||||
<numericalresponse answer="9.80665">
|
||||
<responseparam type="tolerance" default="0.01" />
|
||||
<textline />
|
||||
<formulaequationinput />
|
||||
</numericalresponse>
|
||||
</p>
|
||||
|
||||
@@ -362,7 +368,7 @@ Sample Problem:
|
||||
<p>What is the distance in the plane between the points (pi, 0) and (0, e)? You can type math.
|
||||
<numericalresponse answer="$computed_response">
|
||||
<responseparam type="tolerance" default="0.0001" />
|
||||
<textline math="1" />
|
||||
<formulaequationinput />
|
||||
</numericalresponse>
|
||||
</p>
|
||||
<solution>
|
||||
@@ -391,7 +397,7 @@ Exact values
|
||||
<problem>
|
||||
|
||||
<numericalresponse answer="10">
|
||||
<textline />
|
||||
<formulaequationinput />
|
||||
</numericalresponse>
|
||||
|
||||
<solution>
|
||||
@@ -409,7 +415,7 @@ Answers with decimal precision
|
||||
|
||||
<numericalresponse answer="9.80665">
|
||||
<responseparam type="tolerance" default="0.01" />
|
||||
<textline />
|
||||
<formulaequationinput />
|
||||
</numericalresponse>
|
||||
|
||||
<solution>
|
||||
@@ -427,25 +433,7 @@ Answers with percentage precision
|
||||
|
||||
<numericalresponse answer="100">
|
||||
<responseparam type="tolerance" default="10%" />
|
||||
<textline />
|
||||
</numericalresponse>
|
||||
|
||||
<solution>
|
||||
<div class="detailed-solution">
|
||||
|
||||
</div>
|
||||
</solution>
|
||||
</problem>
|
||||
|
||||
Answers with a live math interpretation popup display
|
||||
|
||||
.. code-block:: xml
|
||||
|
||||
<problem>
|
||||
|
||||
<numericalresponse answer="3.14159">
|
||||
<responseparam type="tolerance" default="0.00001" />
|
||||
<textline math="1" />
|
||||
<formulaequationinput />
|
||||
</numericalresponse>
|
||||
|
||||
<solution>
|
||||
@@ -468,7 +456,7 @@ Answers with scripts
|
||||
|
||||
<numericalresponse answer="$computed_response">
|
||||
<responseparam type="tolerance" default="0.0001" />
|
||||
<textline math="1" />
|
||||
<formulaequationinput />
|
||||
</numericalresponse>
|
||||
|
||||
<solution>
|
||||
@@ -479,7 +467,7 @@ Answers with scripts
|
||||
</problem>
|
||||
|
||||
|
||||
XML Attribute Information
|
||||
**XML Attribute Information**
|
||||
|
||||
<script>
|
||||
|
||||
@@ -490,15 +478,103 @@ XML Attribute Information
|
||||
|
||||
.. image:: ../Images/numericalresponse2.png
|
||||
|
||||
Children may include ``<formulaequationinput/>``.
|
||||
|
||||
<responseparam>
|
||||
|
||||
.. image:: ../Images/numericalresponse4.png
|
||||
|
||||
<textline>
|
||||
<formulaequationinput/>
|
||||
|
||||
========= ============================================= =====
|
||||
Attribute Description Notes
|
||||
========= ============================================= =====
|
||||
size (optional) defines the size (i.e. the width)
|
||||
of the input box displayed to students for
|
||||
typing their math expression.
|
||||
========= ============================================= =====
|
||||
|
||||
<textline> (While <textline /> is supported, its use is extremely discouraged. We urge usage of <formulaequationinput />. See the opening paragraphs of the Numerical Response section for more information.)
|
||||
|
||||
.. image:: ../Images/numericalresponse5.png
|
||||
|
||||
|
||||
Math Expression Syntax
|
||||
----------------------
|
||||
|
||||
In NumericalResponses, the student's input may be more complicated than a
|
||||
simple number. Expressions like ``sqrt(3)`` and even ``1+e^(sin(pi/2)+2*i)``
|
||||
are valid, and evaluate to 1.73 and -0.13 + 2.47i, respectively.
|
||||
|
||||
A summary of the syntax follows:
|
||||
|
||||
Numbers
|
||||
~~~~~~~
|
||||
|
||||
Accepted number types:
|
||||
|
||||
- Integers: '2520'
|
||||
- Normal floats: '3.14'
|
||||
- With no integer part: '.98'
|
||||
- Scientific notation: '1.2e-2' (=0.012)
|
||||
- More s.n.: '-4.4e+5' = '-4.4e5' (=-440,000)
|
||||
- Appending SI suffixes: '2.25k' (=2,250). The full list:
|
||||
|
||||
====== ========== ===============
|
||||
Suffix Stands for One of these is
|
||||
====== ========== ===============
|
||||
% percent 0.01 = 1e-2
|
||||
k kilo 1000 = 1e3
|
||||
M mega 1e6
|
||||
G giga 1e9
|
||||
T tera 1e12
|
||||
c centi 0.01 = 1e-2
|
||||
m milli 0.001 = 1e-3
|
||||
u micro 1e-6
|
||||
n nano 1e-9
|
||||
p pico 1e-12
|
||||
====== ========== ===============
|
||||
|
||||
The largest possible number handled currently is exactly the largest float
|
||||
possible (in the Python language). This number is 1.7977e+308. Any expression
|
||||
containing larger values will not evaluate correctly, so it's best to avoid
|
||||
this situation.
|
||||
|
||||
Default Constants
|
||||
~~~~~~~~~~~~~~~~~
|
||||
|
||||
Simple and commonly used mathematical/scientific constants are included by
|
||||
default. These include:
|
||||
|
||||
- ``i`` and ``j`` as ``sqrt(-1)``
|
||||
- ``e`` as Euler's number (2.718...)
|
||||
- ``pi``
|
||||
- ``k``: the Boltzmann constant (~1.38e-23 in Joules/Kelvin)
|
||||
- ``c``: the speed of light in m/s (2.998e8)
|
||||
- ``T``: the positive difference between 0K and 0°C (285.15)
|
||||
- ``q``: the fundamental charge (~1.602e-19 Coloumbs)
|
||||
|
||||
Operators and Functions
|
||||
~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
As expected, the normal operators apply (with normal order of operations):
|
||||
``+ - * / ^``. Also provided is a special "parallel resistors" operator given
|
||||
by ``||``. For example, an input of ``1 || 2`` would represent the resistance
|
||||
of a pair of parallel resistors (of resistance 1 and 2 ohms), evaluating to 2/3
|
||||
(ohms).
|
||||
|
||||
At the time of writing, factorials written in the form '3!' are invalid, but there is a workaround. Students can specify ``fact(3)`` or ``factorial(3)`` to
|
||||
access the factorial function.
|
||||
|
||||
The default included functions are the following:
|
||||
|
||||
- Trig functions: sin, cos, tan, sec, csc, cot
|
||||
- Their inverses: arcsin, arccos, arctan, arcsec, arccsc, arccot
|
||||
- Other common functions: sqrt, log10, log2, ln, exp, abs
|
||||
- Factorial: ``fact(3)`` or ``factorial(3)`` are valid. However, you must take
|
||||
care to only input integers. For example, ``fact(1.5)`` would fail.
|
||||
- Hyperbolic trig functions and their inverses: sinh, cosh, tanh, sech, csch, coth, arcsinh, arccosh, arctanh, arcsech, arccsch, arccoth
|
||||
|
||||
.. raw:: latex
|
||||
|
||||
\newpage %
|
||||
@@ -513,6 +589,13 @@ mathematical expression from the student and evaluates the input for equivalence
|
||||
to a mathematical expression provided by the grader. Correctness is based on
|
||||
numerical sampling of the symbolic expressions.
|
||||
|
||||
The syntax of the answers is shared with that of the Numerical Response,
|
||||
including default variables and functions. The difference between the two
|
||||
response types is that the Formula Response grader may specify unknown
|
||||
variables. The student's response is compared against the instructor's
|
||||
response, with the unknown variable(s) sampled at random values, as specified
|
||||
by the problem author.
|
||||
|
||||
The answer is correct if both the student-provided response and the grader's
|
||||
mathematical expression are equivalent to specified numerical tolerance, over a
|
||||
specified range of values for each variable.
|
||||
@@ -522,6 +605,15 @@ an extra burden on the problem author to specify the allowed variables in the
|
||||
expression and the numerical ranges over which the variables must be sampled in
|
||||
order to test for correctness.
|
||||
|
||||
A further note about the variables: when the following Greek letters are typed
|
||||
out, an appropriate character is substituted:
|
||||
|
||||
``alpha beta gamma delta epsilon varepsilon zeta eta theta vartheta iota
|
||||
kappa lambda mu nu xi pi rho sigma tau upsilon phi varphi chi psi omega``
|
||||
|
||||
Note: ``epsilon`` is the lunate version, whereas ``varepsilon`` looks like a
|
||||
backward 3.
|
||||
|
||||
Sample Problem:
|
||||
|
||||
.. image:: ../Images/image293.png
|
||||
@@ -538,26 +630,32 @@ Sample Problem:
|
||||
<p>Write an expression for the product of R_1, R_2, and the inverse of R_3.</p>
|
||||
<formularesponse type="ci" samples="R_1,R_2,R_3@1,2,3:3,4,5#10" answer="$VoVi">
|
||||
<responseparam type="tolerance" default="0.00001"/>
|
||||
<textline size="40" math="1" />
|
||||
<formulaequationinput size="40" />
|
||||
</formularesponse>
|
||||
|
||||
<p>Let <i>c</i> denote the speed of light. What is the relativistic energy <i>E</i> of an object of mass <i>m</i>?</p>
|
||||
<script type="loncapa/python">
|
||||
VoVi = "(R_1*R_2)/R_3"
|
||||
</script>
|
||||
<formularesponse type="cs" samples="m,c@1,2:3,4#10" answer="m*c^2">
|
||||
<formularesponse type="cs" samples="m,c@1,2:3,4#10" answer="m*c^2">
|
||||
<responseparam type="tolerance" default="0.00001"/>
|
||||
<text><i>E</i> =</text> <textline size="40" math="1" />
|
||||
</formularesponse>
|
||||
<text><i>E</i> =</text> <formulaequationinput size="40"/>
|
||||
</formularesponse>
|
||||
|
||||
<p>Let <i>x</i> be a variable, and let <i>n</i> be an arbitrary constant. What is the derivative of <i>x<sup>n</sup></i>?</p>
|
||||
<script type="loncapa/python">
|
||||
derivative = "n*x^(n-1)"
|
||||
</script>
|
||||
<formularesponse type="ci" samples="x,n@1,2:3,4#10" answer="$derivative">
|
||||
<responseparam type="tolerance" default="0.00001"/>
|
||||
<textline size="40" math="1" />
|
||||
</formularesponse>
|
||||
<formularesponse type="ci" samples="x,n@1,2:3,4#10" answer="$derivative">
|
||||
<responseparam type="tolerance" default="0.00001"/>
|
||||
<formulaequationinput size="40" />
|
||||
</formularesponse>
|
||||
|
||||
<!-- Example problem specifying only one variable -->
|
||||
<formularesponse type="ci" samples="x@1,9#10" answer="x**2 - x + 4">
|
||||
<responseparam type="tolerance" default="0.00001"/>
|
||||
<formulaequationinput size="40" />
|
||||
</formularesponse>
|
||||
|
||||
<solution>
|
||||
<div class="detailed-solution">
|
||||
@@ -568,24 +666,6 @@ Sample Problem:
|
||||
</div>
|
||||
</solution>
|
||||
</problem>
|
||||
Template
|
||||
<problem>
|
||||
|
||||
<script type="loncapa/python">
|
||||
answer_value = "n*x^(n-1)"
|
||||
</script>
|
||||
<formularesponse type="ci" samples="x,n@1,2:3,4#10" answer="$answer_value">
|
||||
<responseparam type="tolerance" default="0.00001"/>
|
||||
<textline size="40" math="1" />
|
||||
</formularesponse>
|
||||
|
||||
<solution>
|
||||
<div class="detailed-solution">
|
||||
|
||||
</div>
|
||||
</solution>
|
||||
</problem>
|
||||
|
||||
|
||||
XML Attribute Information
|
||||
|
||||
@@ -600,11 +680,26 @@ XML Attribute Information
|
||||
|
||||
.. image:: ../Images/formularesponse3.png
|
||||
|
||||
Children may include ``<formulaequationinput/>``.
|
||||
|
||||
If you do not need to specify any samples, you should look into the use of the
|
||||
Numerical Response input type, as it provides all the capabilities of Formula
|
||||
Response without the need to specify any unknown variables.
|
||||
|
||||
<responseparam>
|
||||
|
||||
|
||||
.. image:: ../Images/formularesponse6.png
|
||||
|
||||
<formulaequationinput/>
|
||||
|
||||
========= ============================================= =====
|
||||
Attribute Description Notes
|
||||
========= ============================================= =====
|
||||
size (optional) defines the size (i.e. the width)
|
||||
of the input box displayed to students for
|
||||
typing their math expression.
|
||||
========= ============================================= =====
|
||||
|
||||
.. raw:: latex
|
||||
|
||||
@@ -825,7 +920,6 @@ Sample Problem:
|
||||
<endouttext/>
|
||||
</problem>
|
||||
|
||||
h
|
||||
.. raw:: latex
|
||||
|
||||
\newpage %
|
||||
|
||||
@@ -0,0 +1,47 @@
|
||||
Formula Equation Input
|
||||
######################
|
||||
|
||||
Tag: ``<formulaequationinput />``
|
||||
|
||||
The formula equation input is a math input type used with Numerical and Formula
|
||||
responses only. It is not to be used with Symoblic Response. It is comparable
|
||||
to a ``<textline math="1"/>`` but with a different means to display the math.
|
||||
It lets the platform validate the student's input as she types.
|
||||
|
||||
This is achieved by periodically sending the typed expression and requesting
|
||||
its preview from the LMS. It parses the expression (using the same parser as
|
||||
the parser it uses to eventually evaluate the response for grading), and sends
|
||||
back an OK'd copy.
|
||||
|
||||
The basic appearance is that of a textbox with a preview box below it. The
|
||||
student types in math (see note below for syntax), and a typeset preview
|
||||
appears below it. Even complicated math expressions may be entered in.
|
||||
|
||||
For more information about the syntax, look in the course author's
|
||||
documentation, under Appendix E, the section about Numerical Responses.
|
||||
|
||||
Format
|
||||
******
|
||||
|
||||
The XML is rather simple, it is a ``<formulaequationinput />`` tag with an
|
||||
optional ``size`` attribute, which defines the size (i.e. the width) of the
|
||||
input box displayed to students for typing their math expression. Unlike
|
||||
``<textline />``, there is no ``math`` attribute and adding such will have no
|
||||
effect.
|
||||
|
||||
To see an example of the input type in context:
|
||||
|
||||
.. code-block:: xml
|
||||
|
||||
<problem>
|
||||
<p>What base is the decimal numeral system in?</p>
|
||||
<numericalresponse answer="10">
|
||||
<formulaequationinput />
|
||||
</numericalresponse>
|
||||
|
||||
<p>Write an expression for the product of R_1, R_2, and the inverse of R_3.</p>
|
||||
<formularesponse type="ci" samples="R_1,R_2,R_3@1,2,3:3,4,5#10" answer="R_1*R_2/R_3">
|
||||
<responseparam type="tolerance" default="0.00001"/>
|
||||
<formulaequationinput size="40" />
|
||||
</formularesponse>
|
||||
</problem>
|
||||
@@ -30,6 +30,7 @@ Specific Problem Types
|
||||
course_data_formats/custom_response.rst
|
||||
course_data_formats/symbolic_response.rst
|
||||
course_data_formats/jsinput.rst
|
||||
course_data_formats/formula_equation_input.rst
|
||||
|
||||
|
||||
Internal Data Formats
|
||||
|
||||
@@ -121,6 +121,7 @@ end
|
||||
|
||||
static_js_dirs = Dir["common/lib/*"].select{|lib| File.directory?(lib)}
|
||||
static_js_dirs << 'common/static/coffee'
|
||||
static_js_dirs << 'common/static/js'
|
||||
static_js_dirs.select!{|lib| !Dir["#{lib}/**/spec"].empty?}
|
||||
|
||||
static_js_dirs.each do |dir|
|
||||
|
||||
Reference in New Issue
Block a user