def test_spinors():
p1 = Symbol('p1', real=True)
p2 = Symbol('p2', real=True)
p3 = Symbol('p3', real=True)
M = Symbol('M', real=True)
p0 = sqrt(p1**2+p2**2+p3**2+M**2)
dct = {var:uniform(1.,100.) for var in [p1,p2,p3,M]}
# Check normalization of spinors: u*ubar = +2M, v*vbar = -2M
assert(evaluate((uminus(p0,p1,p2,p3,'a')*uminusbar(p0,p1,p2,p3,'a') )._array[0].subs(dct)) - 2.0*M.subs(dct) < 1.e-11)
assert(evaluate((vminus(p0,p1,p2,p3,'a')*vminusbar(p0,p1,p2,p3,'a') )._array[0].subs(dct)) + 2.0*M.subs(dct) < 1.e-11)
assert(evaluate((uplus (p0,p1,p2,p3,'a')*uplusbar (p0,p1,p2,p3,'a') )._array[0].subs(dct)) - 2.0*M.subs(dct) < 1.e-11)
assert(evaluate((vplus (p0,p1,p2,p3,'a')*vplusbar (p0,p1,p2,p3,'a') )._array[0].subs(dct)) + 2.0*M.subs(dct) < 1.e-11)
# Check if spinors satisfy Dirac's equation
dop_u = dirac_op([p0,p1,p2,p3], +M, 'a', 'b')
dop_v = dirac_op([p0,p1,p2,p3], -M, 'a', 'b')
d1 = dop_u *(uplus (p0,p1,p2,p3,'b'))
d2 = dop_u *(uminus (p0,p1,p2,p3,'b'))
d3 = dop_v *(vplus (p0,p1,p2,p3,'b'))
d4 = dop_v *(vminus (p0,p1,p2,p3,'b'))
for i in range(4):
assert(Abs(evaluate(d1._array[i]._array[0].subs(dct))) < 1.e-11)
assert(Abs(evaluate(d2._array[i]._array[0].subs(dct))) < 1.e-11)
assert(Abs(evaluate(d3._array[i]._array[0].subs(dct))) < 1.e-11)
assert(Abs(evaluate(d4._array[i]._array[0].subs(dct))) < 1.e-11)
def str2expr(s, local_dict={}):
"""
Convert a latex string into a mathematical expression.
>>> str2expr("x+3+2x")
x + 2*x + 3
>>> str2expr("2^3")
2**3
>>> str2expr("sin 2pi")
sin(2*pi)
>>> str2expr("3!")
factorial(3)
"""
pattern = re.compile(r'\\frac\s*{(.*)}{(.*)}')
s = pattern.sub(r"(\1)/(\2)", s)
s = s.replace("\\times", "*")
s = s.replace("\left", "")
s = s.replace("\right", "")
s = s.replace('\\', "")
s = s.replace("{", "(")
s = s.replace("}", ")")
transformations = prs.standard_transformations + (
prs.implicit_multiplication_application, prs.convert_xor)
with sp.evaluate(False):
return prs.parse_expr(s,
local_dict=local_dict,
transformations=transformations,
evaluate=False)
def calculate(math_string, x):
sinA = sympy.sin(30)
print(sinA)
result = sympy.evaluate(x + sinA + 4)
print(sinA)
result = (sympy.pi + sympy.exp(1)).evalf()
print(result)
x = 4
print((x + sinA).evalf())
def convert2decim(expr, prec=None):
if not isinstance(expr, Basic):
return expr
dico = {}
for a in expr.atoms():
if a.is_Rational:
dico[a] = Decim(a, prec=prec)
with evaluate(False):
return expr.subs(dico)
def test_hill_function_dwdx():
"""Kinetic laws with Hill functions, may lead to NaNs in the Jacobian
if involved states are zero if not properly arranged symbolically.
Test that what we are applying the right sympy simplification."""
w = sp.Matrix([[sp.sympify('Pow(x1, p1) / (Pow(x1, p1) + a)')]])
dwdx = w.diff(sp.Symbol('x1'))
# Verify that without simplification we fail
with pytest.raises(ZeroDivisionError):
with sp.evaluate(False):
res = dwdx.subs({'x1': 0.0})
_ = str(res)
# Test that powsimp does the job
dwdx = dwdx.applyfunc(lambda x: sp.powsimp(x, deep=True))
with sp.evaluate(False):
res = dwdx.subs({'x1': 0.0})
_ = str(res)
def generate(self):
x, y, z = symbols('x y z')
a, b, c, d, e, f = symbols('a b c d e f')
substitutions, eqn, LQ = [], None, None
if self.difficulty == 1:
eqn, LQ = random.choice([
(a * (b * x + c), r'{a}({b}x+{c})'),
(a / d * (b * x + c), r'\frac{{ {a} }}{{ {d} }} ({b}x+{c})'),
(d + a * (b * x - c), r'{d}+{a}({b}x-{c})'),
(d + a * (b * x - c / e),
r'{d}+{a}({b}x-\frac{{ {c} }}{{ {e} }})'),
(-a * (b * x + c * y), r'-{a}({b}x+{c}y)'),
(d - a * (-b * x + c * y), r'{d}-{a}(-{b}x+{c}y)'),
(a * x * (b * y + c * z), r'{a}x({b}y+{c}z)'),
])
substitutions = [
(a, random.randint(2, 10)),
(b, random.randint(2, 7)),
(c, random.randint(2, 10)),
(d, random.randint(2, 7)),
(e, random.randint(2, 10)),
]
elif self.difficulty == 2:
eqn, LQ = random.choice([
((a * x + b) * (c * x + d), r'({a}x+{b})({c}x+{d})'),
((a / e * x + b) * (c * x + d),
r'(\frac{{ {a}x }}{{ {e} }}+{b})({c}x+{d})'),
((-a * x + b) * (c * x - d),
random.choice(
[r'(-{a}x+{b})({c}x-{d})', r'({c}x-{d})(-{a}x+{b})'])),
((a * y + b * x) * (c * y + d + e * z),
r'({a}y+{b}x)({c}y+{d}+{e}z)'),
])
substitutions = [
(a, random.randint(2, 7)),
(b, random.randint(2, 10)),
(c, random.randint(2, 7)),
(d, random.randint(2, 10)),
(e, random.randint(2, 5)),
]
for old, new in substitutions:
with evaluate(False):
eqn = eqn.replace(old, new)
soln = expand(eqn)
a = substitutions[0][1]
b = substitutions[1][1]
c = substitutions[2][1]
d = substitutions[3][1]
e = substitutions[4][1]
Q = getPretty(eqn)
A = getPretty(soln)
LQ = '$\displaystyle {}$'.format(LQ.format(a=a, b=b, c=c, d=d, e=e))
LA = '$\displaystyle {}$'.format(latex(soln))
return Q, A, LQ, LA
def get_deviation(f, dct, ignoreset=set()):
# {sumbol:(value, deviation)}
sdct = dict((s, Symbol('sigma_' + str(s))) for s in dct)
sdct2 = dict((sdct[s], dct[s][1]) for s in dct)
res = sqrt(
sum([(diff(f, s) * sdct[s])**2 for s in dct if s not in ignoreset]))
res = simplify(res)
vls = dict((s, dct[s][0]) for s in dct)
vls.update(sdct2)
with evaluate(False):
step = res.subs(vls)
return res, step, res.subs(vls)
def __get_fraction_term(self, var):
""" Generates a random term with the form "t/d" where t is a random parentesis term generated by __get_parentesis_term and d is a random number.
Args:
var: Variable to use in the term.
Returns:
A SymPy expression with the form "t/d".
"""
num = self.__get_parentesis_term(var)
den = get_random_number(range_list(1, self.maxcoef))
with sympy.evaluate(False):
return (num) / (den)
def define_steps(self, replacements):
# print the base equation, then
# print the base equation with variable substitution, then
# print the solution
expr2 = self.expr
for _from, _to in replacements:
with evaluate(False):
expr2 = expr2.replace(_from,_to)
expr3 = self.expr
for _from, _to in replacements:
expr3 = expr3.subs(_from,_to)
return self.expr, expr2, expr3
def test_polvecs():
# Outgoing gluon mom
k1 = Symbol('k1', real=True)
k2 = Symbol('k2', real=True)
k3 = Symbol('k3', real=True)
k0 = sqrt(k1**2+k2**2+k3**2)
k = tensor1d([k0,k1,k2,k3], 'nu')
# Outgoing gluon reference mom
g1 = Symbol('g1', real=True)
g2 = Symbol('g2', real=True)
g3 = Symbol('g3', real=True)
g0 = sqrt(g1**2+g2**2+g3**2)
dct = {var:uniform(1.,100.) for var in [k1,k2,k3,g1,g2,g3]}
em = epsilonminus(k0,k1,k2,k3, 'mu', g0, g1, g2, g3)
ep = epsilonplus (k0,k1,k2,k3, 'mu', g0, g1, g2, g3)
# Test transversality wrt. gluon momentum
assert(Abs(evaluate((em*mink_metric('mu','nu')*k)._array[0].subs(dct))) < 1.e-11)
assert(Abs(evaluate((ep*mink_metric('mu','nu')*k)._array[0].subs(dct))) < 1.e-11)
# Test complex conjugation relation between two helicity states
for el in (em-conjugate_tensor1d(ep)).elements():
assert(Abs(evaluate(el._array[0].subs(dct))) < 1.e-11)
# Test the completeness relation: t and s should be equal
t = ep*conjugate_tensor1d(epsilonplus (k0,k1,k2,k3, 'nu', g0, g1, g2, g3))
t += em*conjugate_tensor1d(epsilonminus(k0,k1,k2,k3, 'nu', g0, g1, g2, g3))
s = -mink_metric('mu','nu')
s += (tensor1d([k0,k1,k2,k3],'mu')*tensor1d([g0,g1,g2,g3],'nu')+tensor1d([k0,k1,k2,k3],'nu')*tensor1d([g0,g1,g2,g3],'mu'))/(tensor1d([k0,k1,k2,k3],'nu')*mink_metric('mu','nu')*tensor1d([g0,g1,g2,g3],'mu'))
for el in (t-s).elements():
assert(Abs(evaluate(el._array[0].subs(dct))) < 1.e-11)
def print_with_deviation(f, dct, ignoreset=set(), notebook=True):
dct3 = {}
for name in ignoreset:
dct3[name] = dct[name][0]
f = simplify(f.subs(dct3))
dev = get_deviation(f, dct, ignoreset)
dct2 = dict((s, dct[s][0]) for s in dct)
rnd = rounding(float(f.subs(dct2)), float(dev[2]))
with evaluate(False):
rnd = (rnd[0], f.subs(dct2), rnd[1])
res = latex(dev[0]) + '=' + latex(dev[1]) + '={}'.format(dev[2]) + r'\\' +\
latex(f) + '= {} = {} \\pm {}'.format(rnd[1], rnd[0], rnd[2])
if notebook:
return res
print('$$' + res + '$$')
def to_sympy(
self,
simplify: Optional[bool] = True,
) -> List["sympy_expr.Expr"]:
"""Compile the function(s) represented by the graph to a SymPy expression.
Generates one SymPy expression for each output node.
Parameters
----------
simplify : boolean, optional
Whether to simplify the expression using SymPy's
simplify() method. Defaults to True.
Returns
----------
List[sympy.core.expr.Expr]
List of SymPy expressions.
"""
if not sympy_available:
raise ModuleNotFoundError(
"No module named 'sympy' (extra requirement)")
self._format_output_str_of_all_nodes()
sympy_exprs = []
for output_node in self.output_nodes:
# replace all input-variable strings with sympy-compatible symbol
# strings (i.e., x[0] -> x_0)
s = output_node.output_str
for input_node in self.input_nodes:
s = s.replace(
input_node.output_str,
input_node.output_str.replace("[", "_").replace("]", ""))
s = self._fill_parameter_values(s)
# to get an expression that reflects the computational graph,
# sympy should not automatically simplify the expression
with sympy.evaluate(False):
sympy_exprs.append(sympy.sympify(s))
if not simplify:
return sympy_exprs
else: # simplify expression if desired
for i, expr in enumerate(sympy_exprs):
sympy_exprs[i] = expr.simplify()
return sympy_exprs
def test_realnumber_field():
x = sympy.Symbol("x")
with sympy.evaluate(False):
test.real = "x"
assert test.real == x
test.real = "1 / (x + 1)"
assert test.real == 1 / (x + 1)
assert "error" not in Foo.real.validate(5)
with pytest.raises(TypeError):
test.real = False
with pytest.raises(ValueError):
test.real = "/"
def c_filter(item):
if isinstance(item, sp.Atom):
return item
with evaluate(False):
rtn = item.__class__(*map(c_filter, item.args))
# powers of 2 and 3 should just be shown as x*x*x in C; it's faster to skip the function call
if item.__class__ == Pow and item.args[1] == 2:
rtn = item.args[0] * item.args[0]
elif item.__class__ == Pow and item.args[1] == 3:
rtn = item.args[0] * item.args[0] * item.args[0]
if item.__class__ == Pow and item.args[1] == -2:
rtn = 1 / (item.args[0] * item.args[0])
elif item.__class__ == Pow and item.args[1] == -3:
rtn = 1 / (item.args[0] * item.args[0] * item.args[0])
return rtn
def get_inter_poly(self):
N = len(self.dt[0])
x = symbols('x')
expr = self.dt[1][0]
count = 1
for i in range(2, N+1):
with evaluate(False):
next_expr = 1
for j in range(count):
next_expr = next_expr * (x - self.dt[0][j])
next_expr = next_expr * self.dt[i][0]
expr = expr + next_expr
count += 1
self.inter_poly = expr
return expr
def test_parse():
x = Symbol("x")
with evaluate(False):
assert parse("5 x + 3") == 5 * x + 3
assert parse("sqrt x") == sqrt(x)
assert parse("sqrt 2x") == sqrt(2 * x)
assert parse("4 + 3") == Add(4, 3, evaluate=False)
with pytest.raises(TypeError):
parse({})
with pytest.raises(ValueError):
parse("sin (")
with pytest.raises(ValueError):
parse("3 *")
with pytest.raises(ValueError):
parse("5 =")
def create_quiz(self,
formula,
call,
reverse=False,
filt=None,
domain=None,
evaluate=True):
# expects to parse expression from string and calculate:
# problem_expr as sympy object (expr or eq)
# answer_expr as sympy object of the same type
#formula can be either string or tuple of strings
if isinstance(formula, str): f = formula
else: f = reduce(lambda x, y: x + y, formula)
free_variables = sorted(set(n for n in f if n in 'abcdefghijkl'))
if domain is None:
domain = [self.domain for n in range(len(free_variables))]
#else: expected to be list of lists
choice = list(itertools.product(*domain))
if filt is not None:
choice = list(filter(lambda x: filt(*x), choice))
if isinstance(formula, str):
e = [parse_all(formula, transformations=transformations)]
else:
e = [
parse_all(f, transformations=transformations) for f in formula
]
for n in random.sample(choice, self.size):
N = random.randint(0, len(e) - 1)
if not (evaluate):
with sp.evaluate(False):
problem_expr = e[N].subs(dict(zip(free_variables, n)))
else:
problem_expr = e[N].subs(dict(zip(free_variables, n)))
answer_expr = call(problem_expr)
# print(sp.latex(problem_expr))
# print(sp.latex(answer_expr))
self.quiz.add(Question(problem_expr, answer_expr))
if reverse: self.quiz.flip()
def try_pl(request, pl=None, warning=None):
with evaluate(False):
exercise = request.session.get('exercise', None)
success = None
feedback = None
if pl:
messages.success(request,
"Le PL <b>" + pl.name + "</b> a bien été chargé.")
messages.warning(request, warning)
messages.error(
request,
"Attention, ceci est une session de test, les réponses ne seront pas enregistrer après la fermeture de la fenêtre (Pensez à copier/coller)."
)
if not exercise:
pl_dic = pl.json
exercise = PythonBuilderTest(pl_dic).get_exercise()
else:
exercise = ExerciseTest(exercise)
if request.method == 'GET' or request.method == 'POST':
status = None
try:
status = json.loads(request.body.decode())
except:
pass
if status and status['requested_action'] == 'submit':
success, feedback = exercise.evaluate(status['inputs'])
if (success):
feedback_type = "success"
else:
feedback_type = "failed"
return HttpResponse(json.dumps({
'feedback_type': feedback_type,
'feedback': feedback
}),
content_type='application/json')
request.session['exercise'] = exercise.dic
return HttpResponse(exercise.render(request, feedback, success))
def test_equation_field():
x, y = sympy.symbols("x y")
with sympy.evaluate(False):
test.equation = "3 * x + 5 = 4"
assert test.equation == sympy.Eq(3 * x + 5, 4)
test.equation = "3 * x + 5"
assert test.equation == sympy.Eq(3 * x + 5, 0)
test.equation = 3 * x + 5
assert test.equation == sympy.Eq(3 * x + 5, 0)
test.equation = "2 x + 3 y = y = x + y"
assert test.equation == (sympy.Eq(2 * x + 3 * y, y), sympy.Eq(y, x + y))
# If evaluate=True, Eq(1 / x) is False
test.equation = "1 / x"
assert test.equation == sympy.Eq(1 / x, 0)
with pytest.raises(TypeError):
test.equation = False
with pytest.raises(ValueError):
test.equation = "3 x = **"
def generate(self):
a, b, c, d, e, f = symbols('a b c d e f')
if self.difficulty == 1:
expr = random.choice([
a/b + c/d,
])
substitutions = [
(a, random.randint(1, 7)),
(b, random.randint(2, 7)),
(c, random.randint(1, 7)),
(d, random.randint(2, 7)),
]
for old, new in substitutions:
with evaluate(False):
expr = expr.replace(old, new)
soln = simplify(expr)
Q = getPretty(expr)
A = getPretty(soln)
LQ = '$\displaystyle {}$'.format(latex(expr))
LA = '$\displaystyle {}$'.format(latex(soln))
return Q, A, LQ, LA
elif self.difficulty == 2:
expr = random.choice([
a/b + c/d,
a/b + c,
a + c/d,
])
substitutions = [
(a, random.randint(1, 10)),
(b, random.randint(2, 7)),
(c, random.randint(1, 10)),
(d, random.randint(2, 7)),
]
for old, new in substitutions:
with evaluate(False):
expr = expr.replace(old, new)
soln = simplify(expr)
Q = getPretty(expr)
A = getPretty(soln)
LQ = '$\displaystyle {}$'.format(latex(expr))
LA = '$\displaystyle {}$'.format(latex(soln))
return Q, A, LQ, LA
elif self.difficulty == 3:
expr = random.choice([
a/b - c/d,
-a/b + c/d,
])
substitutions = [
(a, random.randint(1, 7)),
(b, random.randint(2, 7)),
(c, random.randint(1, 7)),
(d, random.randint(2, 7)),
]
for old, new in substitutions:
with evaluate(False):
expr = expr.replace(old, new)
soln = simplify(expr)
Q = getPretty(expr)
A = getPretty(soln)
LQ = '$\displaystyle {}$'.format(latex(expr))
LA = '$\displaystyle {}$'.format(latex(soln))
return Q, A, LQ, LA
elif self.difficulty == 4:
expr = random.choice([
a/b - c/d,
a/b - c,
a - c/d,
])
substitutions = [
(a, random.randint(1, 10)),
(b, random.randint(2, 7)),
(c, random.randint(1, 10)),
(d, random.randint(2, 7)),
]
for old, new in substitutions:
with evaluate(False):
expr = expr.replace(old, new)
soln = simplify(expr)
Q = getPretty(expr)
A = getPretty(soln)
LQ = '$\displaystyle {}$'.format(latex(expr))
LA = '$\displaystyle {}$'.format(latex(soln))
return Q, A, LQ, LA
elif self.difficulty == 5:
expr = random.choice([
a/b + c/d,
a/b + c,
a + c/d,
a/b - c/d,
a/b - c,
a - c/d,
])
substitutions = [
(a, random.randint(1, 10)),
(b, random.randint(2, 10)),
(c, random.randint(1, 10)),
(d, random.randint(2, 10)),
]
for old, new in substitutions:
with evaluate(False):
expr = expr.replace(old, new)
soln = simplify(expr)
Q = getPretty(expr)
A = getPretty(soln)
LQ = '$\displaystyle {}$'.format(latex(expr))
LA = '$\displaystyle {}$'.format(latex(soln))
return Q, A, LQ, LA
def tosympy(self): #uses plain text
if self.plain != '' and self.sympy is None:
with sp.evaluate(False):
self.sympy = parse_all(self.get_plain(),
transformations=transformations)
def generate(self):
x = symbols('x')
a, b, c, d, e, f = symbols('a b c d e f')
substitutions, eqn, LQ = [], None, None
if self.difficulty == 1:
eqn, LQ = random.choice([
(Eq(x * (x + a), 0), r'x(x+{a}) = 0'),
(Eq(x * (x + a / b), 0), r'x(x+\frac{{{a}}}{{{b}}}) = 0'),
(Eq(x * (x - a), 0), r'x(x-{a}) = 0'),
(Eq(a * x * (x + b), 0), r'{a}x(x+{b}) = 0'),
(Eq(a * x * (x - b), 0), r'{a}x(x-{b}) = 0'),
(Eq(a * x * (x - b / c),
0), r'{a}x(x-\frac{{{b}}}{{{c}}}) = 0'),
])
substitutions = [
(a, random.randint(2, 10)),
(b, random.randint(1, 10)),
(c, random.randint(1, 10)),
(d, random.randint(1, 10)),
]
elif self.difficulty == 2:
eqn, LQ = random.choice([
(Eq((x + a) * (x + b), 0), r'(x+{a})(x+{b}) = 0'),
(Eq((x + a) * (x - b), 0),
random.choice([r'(x+{a})(x-{b}) = 0',
r'(x-{b})(x+{a}) = 0'])),
])
substitutions = [
(a, random.randint(1, 10)),
(b, random.randint(1, 10)),
(c, random.randint(1, 10)),
(d, random.randint(1, 10)),
]
elif self.difficulty == 3:
eqn, LQ = random.choice([
(Eq((a * x + b) * (x + b), 0),
random.choice(
[r'({a}x+{b})(x+{b}) = 0', r'(x+{b})({a}x+{b}) = 0'])),
(Eq((a * x - b) * (x - b), 0),
random.choice(
[r'({a}x-{b})(x-{b}) = 0', r'(x-{b})({a}x-{b}) = 0'])),
(Eq((a * x + b) * (c * x - d), 0),
random.choice([
r'({a}x+{b})({c}x-{d}) = 0', r'({c}x-{d})({a}x+{b}) = 0'
])),
])
substitutions = [
(a, random.randint(2, 10)),
(b, random.randint(1, 10)),
(c, random.randint(2, 10)),
(d, random.randint(1, 10)),
]
for old, new in substitutions:
with evaluate(False):
eqn = eqn.replace(old, new)
try:
soln = solve(eqn, x)[0], solve(eqn, x)[1]
except IndexError:
# no solution
soln = 'No solution'
a = substitutions[0][1]
b = substitutions[1][1]
c = substitutions[2][1]
d = substitutions[3][1]
Q = getPretty(eqn)
A = getPretty(soln)
LQ = '$\displaystyle {}$'.format(LQ.format(a=a, b=b, c=c, d=d))
LA = '$\displaystyle x={}, \ {}$'.format(soln[0], soln[1])
return Q, A, LQ, LA
def _LaTeX_helper(expr, local_dict, global_dict, evalf):
if expr.strip() == "": return expr
try:
if evalf == 2 or type(evalf) == bool and evalf == True:
if QtWidgets.QApplication.instance(
).optionWindow.cb_D_NoEvalFile.isChecked():
print("True")
expr = expr.replace("evalf", "", 1)
rtnexpr = parse_expr(expr,
evaluate=True,
local_dict=local_dict,
global_dict=global_dict)
rtnexpr = sympy.latex(rtnexpr)
elif evalf == 1 or type(evalf) == bool and evalf == False:
if QtWidgets.QApplication.instance(
).optionWindow.cb_D_NoEvalFile.isChecked():
print("False")
rtnexpr = parse_expr(expr,
evaluate=False,
local_dict=local_dict,
global_dict=global_dict)
rtnexpr = sympy.latex(rtnexpr)
try:
if parse_expr(
expr, local_dict=local_dict, global_dict=global_dict
) - sympy.parsing.latex.parse_latex(rtnexpr) != 0:
rtnexpr = parse_expr(expr,
evaluate=True,
local_dict=local_dict,
global_dict=global_dict)
rtnexpr = sympy.latex(rtnexpr)
except common_exceptions:
rtnexpr = parse_expr(expr,
evaluate=True,
local_dict=local_dict,
global_dict=global_dict)
rtnexpr = sympy.latex(rtnexpr)
elif not QtWidgets.QApplication.instance(
).optionWindow.cb_D_NoEvalFile.isChecked():
rtnexpr = parse_expr(expr,
evaluate=False,
local_dict=local_dict,
global_dict=global_dict)
rtnexpr = sympy.latex(rtnexpr)
else:
try:
if QtWidgets.QApplication.instance(
).optionWindow.cb_D_NoEvalFile.isChecked():
print("File")
Path = os.path.dirname(__file__)
#if platform.system() == 'Windows':
# Path += r"\NoEvalParse.py"
#elif platform.system() == 'Linux':
# Path += r"/NoEvalParse.py"
Path = os.path.join(Path, "NoEvalParse.py")
rtnexpr = subprocess.check_output(
[sys.executable, Path,
expr]) #, local_dict]) # IMPROVE: Make local_dict work
rtnexpr = rtnexpr.decode("utf8")
sympy.evaluate(True)
except common_exceptions:
ExceptionOutput(sys.exc_info())
if QtWidgets.QApplication.instance(
).optionWindow.cb_D_NoEvalFile.isChecked():
print("Failed-->False")
sympy.evaluate(True)
rtnexpr = parse_expr(expr,
evaluate=False,
local_dict=local_dict)
rtnexpr = sympy.latex(rtnexpr)
try:
if parse_expr(
expr, local_dict=local_dict
) - sympy.parsing.latex.parse_latex(rtnexpr) != 0:
rtnexpr = parse_expr(expr,
evaluate=True,
local_dict=local_dict)
rtnexpr = sympy.latex(rtnexpr)
except common_exceptions:
rtnexpr = parse_expr(expr,
evaluate=True,
local_dict=local_dict)
rtnexpr = sympy.latex(rtnexpr)
except common_exceptions:
ExceptionOutput(sys.exc_info())
if "=" in expr:
if QtWidgets.QApplication.instance(
).optionWindow.cb_D_NoEvalFile.isChecked():
print("Failed--> = detected --> Special Treatment")
try:
rtnexpr = parse_expr(expr,
evaluate=True,
local_dict=local_dict)
rtnexpr = sympy.latex(rtnexpr)
try:
if parse_expr(
expr, local_dict=local_dict
) - sympy.parsing.latex.parse_latex(rtnexpr) != 0:
rtnexpr = parse_expr(expr,
evaluate=True,
local_dict=local_dict)
rtnexpr = sympy.latex(rtnexpr)
except common_exceptions:
rtnexpr = parse_expr(expr,
evaluate=True,
local_dict=local_dict)
rtnexpr = sympy.latex(rtnexpr)
except:
eq = expr.split("=", 1)
c = eq[0].rsplit("(", 1) + eq[1].split(")", 1)
rtnexpr = sympy.latex(parse_expr(c[0],evaluate=False,local_dict=local_dict,global_dict=global_dict)) + "(" + \
sympy.latex(parse_expr(c[1],evaluate=False,local_dict=local_dict,global_dict=global_dict)) + "=" + \
sympy.latex(parse_expr(c[2],evaluate=False,local_dict=local_dict,global_dict=global_dict)) + ")"
if len(c) == 4:
if c[3].strip() != "":
rtnexpr += sympy.latex(
parse_expr(c[3],
evaluate=False,
local_dict=local_dict,
global_dict=global_dict))
else:
if QtWidgets.QApplication.instance(
).optionWindow.cb_D_NoEvalFile.isChecked():
print("Failed-->True")
sympy.evaluate(True)
rtnexpr = parse_expr(expr, evaluate=True, local_dict=local_dict)
rtnexpr = sympy.latex(rtnexpr)
try:
if parse_expr(
expr, local_dict=local_dict
) - sympy.parsing.latex.parse_latex(rtnexpr) != 0:
rtnexpr = parse_expr(expr,
evaluate=True,
local_dict=local_dict)
rtnexpr = sympy.latex(rtnexpr)
except common_exceptions:
rtnexpr = parse_expr(expr,
evaluate=True,
local_dict=local_dict)
rtnexpr = sympy.latex(rtnexpr)
return rtnexpr
import re
import sympy
from sympy.parsing.sympy_parser import parse_expr
from sympy import Matrix, linsolve
common_exceptions = (TypeError, SyntaxError, sympy.SympifyError,
sympy.parsing.sympy_parser.TokenError, re.error,
AttributeError, ValueError, NotImplementedError,
Exception, RuntimeError, ImportError)
if __name__ == "__main__":
sympy.init_printing()
if len(sys.argv) == 2:
my_str_o = decode(sys.argv[1], 'unicode_escape')
try:
with sympy.evaluate(False):
my_str = parse_expr(my_str_o, evaluate=False)
my_str = sympy.latex(my_str)
except common_exceptions:
# The following may look weird but it totally is!!! It does not work in any other way...
with sympy.evaluate(True):
my_str = parse_expr(my_str_o, evaluate=True)
my_str = sympy.latex(my_str)
my_str = parse_expr(my_str_o, evaluate=False)
try:
my_str = sympy.latex(my_str)
except common_exceptions:
with sympy.evaluate(True):
my_str = parse_expr(my_str_o, evaluate=False)
my_str = sympy.latex(my_str)
# alternatively you transform it to a bytes obj and
def generate(self):
x = symbols('x')
a, b, c, d, e, f = symbols('a b c d e f')
if self.difficulty == 1:
eqn = random.choice([
Eq(x + a, b),
Eq(x - a, b),
Eq(a * x, b),
Eq(x / a, b),
])
eqn = eqn.subs([
(a, random.randint(2, 10)),
(b, random.randint(0, 10)),
])
soln = Eq(x, solve(eqn, x)[0])
Q = getPretty(eqn)
A = getPretty(soln)
LQ = '$\displaystyle {}$'.format(latex(eqn))
LA = '$\displaystyle {}$'.format(latex(soln))
return Q, A, LQ, LA
elif self.difficulty == 2:
eqn = random.choice([
Eq(a * x + b, c),
Eq(a * x + b / d, c),
Eq(a * x - b, c),
Eq(a * x - b / d, c),
Eq(x / a + b, c),
Eq(x / a - b, c),
])
# todo flip sides of equations randomly
eqn = eqn.subs([
(a, random.randint(2, 10)),
(b, random.randint(1, 10)),
(c, random.randint(0, 10)),
(d, random.randint(2, 7)),
])
# todo my own function that uses try/except to find no solutions
soln = Eq(x, solve(eqn, x)[0])
# todo Q, A = getPretty(eqn, soln)
# todo LQ, LA = getLatex(eqn, soln)
Q = getPretty(eqn)
A = getPretty(soln)
LQ = '$\displaystyle {}$'.format(latex(eqn))
LA = '$\displaystyle {}$'.format(latex(soln))
return Q, A, LQ, LA
elif self.difficulty == 3:
eqn = random.choice([
Eq(a * x + b + c * x, d),
Eq(a * x + b, d + c * x),
])
substitutions = [
(a, randIntExcept(-10, 10)),
(b, randIntExcept(-10, 10)),
(c, randIntExcept(-10, 10)),
(d, randIntExcept(-10, 10)),
]
for old, new in substitutions:
with evaluate(False):
eqn = eqn.replace(old, new)
try:
soln = Eq(x, solve(eqn, x)[0])
except IndexError:
# no solution - lines are parallel
soln = 'No solution'
Q = getPretty(eqn)
A = getPretty(soln)
LQ = '$\displaystyle {}$'.format(latex(eqn))
LA = '$\displaystyle {}$'.format(latex(soln))
return Q, A, LQ, LA
elif self.difficulty == 4:
eqn = random.choice([
Eq(a * x + b + c * x, d + e * x),
])
substitutions = [
(a, randIntExcept(-10, 10)),
(b, randIntExcept(-10, 10)),
(c, randIntExcept(-10, 10)),
(d, randIntExcept(-10, 10)),
(e, randIntExcept(-10, 10)),
]
for old, new in substitutions:
with evaluate(False):
eqn = eqn.replace(old, new)
try:
soln = Eq(x, solve(eqn, x)[0])
except IndexError:
# no solution - lines are parallel
soln = 'No solution'
Q = getPretty(eqn)
A = getPretty(soln)
LQ = '$\displaystyle {}$'.format(latex(eqn))
LA = '$\displaystyle {}$'.format(latex(soln))
return Q, A, LQ, LA
def run(self, dag):
"""Translate an input DAGCircuit to the target basis.
Args:
dag (DAGCircuit): input dag
Raises:
TranspilerError: if the target basis cannot be reached
Returns:
DAGCircuit: translated circuit.
"""
if self._target_basis is None:
return dag
# Names of instructions assumed to supported by any backend.
basic_instrs = ['measure', 'reset', 'barrier', 'snapshot', 'delay']
target_basis = set(self._target_basis).union(basic_instrs)
source_basis = set()
for node in dag.op_nodes():
if not dag.has_calibration_for(node):
source_basis.add((node.name, node.op.num_qubits))
logger.info(
'Begin BasisTranslator from source basis %s to target '
'basis %s.', source_basis, target_basis)
# Search for a path from source to target basis.
search_start_time = time.time()
basis_transforms = _basis_search(self._equiv_lib, source_basis,
target_basis, _basis_heuristic)
search_end_time = time.time()
logger.info('Basis translation path search completed in %.3fs.',
search_end_time - search_start_time)
if basis_transforms is None:
raise TranspilerError(
'Unable to map source basis {} to target basis {} '
'over library {}.'.format(source_basis, target_basis,
self._equiv_lib))
# Compose found path into a set of instruction substitution rules.
compose_start_time = time.time()
instr_map = _compose_transforms(basis_transforms, source_basis, dag)
compose_end_time = time.time()
logger.info('Basis translation paths composed in %.3fs.',
compose_end_time - compose_start_time)
# Replace source instructions with target translations.
replace_start_time = time.time()
for node in dag.op_nodes():
if node.name in target_basis:
continue
if dag.has_calibration_for(node):
continue
if (node.op.name, node.op.num_qubits) in instr_map:
target_params, target_dag = instr_map[node.op.name,
node.op.num_qubits]
if len(node.op.params) != len(target_params):
raise TranspilerError(
'Translation num_params not equal to op num_params.'
'Op: {} {} Translation: {}\n{}'.format(
node.op.params, node.op.name, target_params,
target_dag))
if node.op.params:
# Convert target to circ and back to assign_parameters, since
# DAGCircuits won't have a ParameterTable.
from qiskit.converters import dag_to_circuit, circuit_to_dag
target_circuit = dag_to_circuit(target_dag)
target_circuit.assign_parameters(dict(
zip_longest(target_params, node.op.params)),
inplace=True)
bound_target_dag = circuit_to_dag(target_circuit)
else:
bound_target_dag = target_dag
if (len(bound_target_dag.op_nodes()) == 1
and len(bound_target_dag.op_nodes()[0].qargs) == len(
node.qargs)):
dag_op = bound_target_dag.op_nodes()[0].op
# dag_op may be the same instance as other ops in the dag,
# so if there is a condition, need to copy
if node.op.condition:
dag_op = dag_op.copy()
dag.substitute_node(node, dag_op, inplace=True)
if bound_target_dag.global_phase:
from sympy import evaluate
with evaluate(False):
dag.global_phase += bound_target_dag.global_phase
else:
dag.substitute_node_with_dag(node, bound_target_dag)
else:
raise TranspilerError('BasisTranslator did not map {}.'.format(
node.name))
replace_end_time = time.time()
logger.info('Basis translation instructions replaced in %.3fs.',
replace_end_time - replace_start_time)
return dag
def generate(self):
a, b, c, d, e, f = symbols('a b c d e f')
substitutions, expr, LQ = [], None, None
if self.difficulty == 1:
expr, LQ = random.choice([
(a/b * c/d, r'\frac{{{a}}}{{{b}}} \times \frac{{{c}}}{{{d}}}')
])
substitutions = [
(a, random.randint(1, 7)),
(b, random.randint(2, 7)),
(c, random.randint(1, 7)),
(d, random.randint(2, 7)),
]
elif self.difficulty == 2:
expr, LQ = random.choice([
(a/b * c/d, r'\frac{{{a}}}{{{b}}} \times \frac{{{c}}}{{{d}}}'),
(a/b * c, r'\frac{{{a}}}{{{b}}} \times {c}'),
(a * c/d, r'{a} \times \frac{{{c}}}{{{d}}}'),
])
substitutions = [
(a, random.randint(1, 10)),
(b, random.randint(2, 7)),
(c, random.randint(1, 10)),
(d, random.randint(2, 7)),
]
elif self.difficulty == 3:
expr, LQ = random.choice([
((a/b) / (c/d), r'\frac{{{a}}}{{{b}}} \div \frac{{{c}}}{{{d}}}'),
(-(a/b) / (c/d), r'-\frac{{{a}}}{{{b}}} \div \frac{{{c}}}{{{d}}}'),
])
substitutions = [
(a, random.randint(1, 7)),
(b, random.randint(2, 7)),
(c, random.randint(1, 7)),
(d, random.randint(2, 7)),
]
elif self.difficulty == 4:
expr, LQ = random.choice([
((a/b) / (c/d), r'\frac{{{a}}}{{{b}}} \div \frac{{{c}}}{{{d}}}'),
((a/b) / c, r'\frac{{{a}}}{{{b}}} \div {c}'),
(a / (c/d), r'{a} \div \frac{{{c}}}{{{d}}}'),
])
substitutions = [
(a, random.randint(1, 10)),
(b, random.randint(2, 7)),
(c, random.randint(1, 10)),
(d, random.randint(2, 7)),
]
elif self.difficulty == 5:
expr, LQ = random.choice([
(a/b * c/d, r'\frac{{{a}}}{{{b}}} \times \frac{{{c}}}{{{d}}}'),
(a/b * c, r'\frac{{{a}}}{{{b}}} \times {c}'),
(a * c/d, r'{a} \times \frac{{{c}}}{{{d}}}'),
((a/b) / (c/d), r'\frac{{{a}}}{{{b}}} \div \frac{{{c}}}{{{d}}}'),
((a/b) / c, r'\frac{{{a}}}{{{b}}} \div {c}'),
(a / (c/d), r'{a} \div \frac{{{c}}}{{{d}}}'),
])
substitutions = [
(a, random.randint(1, 10)),
(b, random.randint(2, 10)),
(c, random.randint(1, 10)),
(d, random.randint(2, 10)),
]
assert len(substitutions) > 0
for old, new in substitutions:
with evaluate(False):
expr = expr.replace(old, new)
a = substitutions[0][1]
b = substitutions[1][1]
c = substitutions[2][1]
d = substitutions[3][1]
soln = simplify(expr)
Q = getPretty(expr)
A = getPretty(soln)
LQ = '$\displaystyle {}$'.format(LQ.format(a=a, b=b, c=c, d=d))
LA = '$\displaystyle {}$'.format(latex(soln))
return Q, A, LQ, LA
def test_default_values():
form = CustomForm(required="Hello")
assert form.required == "Hello"
with sympy.evaluate(False):
assert form.equation == sympy.Eq(sympy.Symbol("x")**3, 0)
def react(self, x, master=None):
if x=='OK':
if self.state == 'active': #if self.problem is None:
self.compile = False
self.specialform = Specialform()
if self.winner.field.grid_info(): self.winner.field.grid_remove()
if self.loser.field.grid_info(): self.loser.field.grid_remove()
if self.unclear.field.grid_info(): self.unclear.field.grid_remove()
try:
self.question = self.quiz.next()
#print(self.question.problem, self.question.answer)
self.problem.update(Symform(self.question.problem))
except StopIteration:
if not(self.iteration_stopped):
write('register.txt', self.kwargs['type'],
tuple(datetime.now().timetuple())[1:5],
round(time.time() - self.inception_time), self.score)
self.iteration_stopped = True
if self.score >= 9:
self.finals_photo = ImageTk.PhotoImage(self.finals_image1)
self.level = Level(self, self.tasks)
elif self.score >= 7: self.finals_photo = ImageTk.PhotoImage(self.finals_image2)
else: self.finals_photo = ImageTk.PhotoImage(self.finals_image3)
self.finals_field = Label(master, image=self.finals_photo)
self.finals_field.grid(row=1, column=6, rowspan=2, sticky="nsew")
self.problem.update(Symform(''))
self.answer.update(Symform(''))
else:
self.symform = Symform('')
self.state = 'not active'
self.timer.reset()
else:
if self.specialform.state == 2: #COPYPASTING
self.specialform.state = 0
self.superbutton.button.configure(bg='#007f7f', text='·/·', relief='raised')
with sp.evaluate(False):
self.compile = True
self.symform.add(
f'{self.specialform.symform1.get_plain()}/{self.specialform.symform2.get_plain()}')
try:
self.symform.tosympy()
except Exception as e:
print('Exception: can''t convert input form to sympy expression')
self.unclear.field.grid(row=1, column=6, rowspan=2, sticky="nsew")
else:
print(f'input converted to: {self.symform.get_sympy()}, correct input: {self.question.answer}')
if self.is_equal(self.symform.get_sympy(), self.question.answer):
self.score += 1
self.answer.check(True)
self.winner.field.grid(row=1, column=6, rowspan=2, sticky="nsew")
self.starpacket.credit(True)
else:
self.answer.check(False, symform = Symform(self.question.answer))
self.loser.field.grid(row=1, column=6, rowspan=2, sticky="nsew")
self.starpacket.credit(False)
self.state = 'active'
elif x=='back':
self.symform.rewind()
elif x=='²':
self.symform.add('^2')
elif x=='·/·':
#self.symform.plain += r'\frac{\cdot}{\dots}' #???
if self.specialform.state == 0:
self.specialform.state = 1
self.superbutton.button.configure(bg='orange', text='▯/·', relief='groove')
#self.symform.add(x)
elif self.specialform.state == 1:
self.specialform.state = 2
self.superbutton.button.configure(bg='green', text='·/▯', relief='groove')
elif self.specialform.state == 2:
self.specialform.state = 0
self.superbutton.button.configure(bg='#007f7f', text='·/·', relief='raised')
'''self.specialform.symform1.tosympy()
self.specialform.symform2.tosympy()
nom = self.specialform.symform1.get_sympy()
denom = self.specialform.symform2.get_sympy()'''
with sp.evaluate(False):
self.compile = True
self.symform.add(f'{self.specialform.symform1.get_plain()}/{self.specialform.symform2.get_plain()}')
else:
if self.specialform.state != 0:
self.specialform.add(x)
else:
self.symform.add(x)
if self.state == 'not active':
try:
if self.specialform.state == 0:
self.answer.update(self.symform, compile=self.compile)
elif self.specialform.state == 1:
if self.specialform.symform1.get_plain()=='':
specplain = r'\frac{\ }{\ }'
else:
specplain = r'\frac{' + self.specialform.symform1.get_plain()+r'}{\ }'
self.answer.update(Symform(self.symform.plain + specplain), compile=False)
elif self.specialform.state == 2:
if self.specialform.symform1.get_plain() == '':
self.specialform.state = 1
self.superbutton.button.configure(bg='orange', text='▯/·', relief='groove')
raise ValueError
if self.specialform.symform2.get_plain() == '':
specplain = r'\frac{' + self.specialform.symform1.get_plain() + r'}{\ }'
else:
specplain = r'\frac{' + self.specialform.symform1.get_plain() + r'}{'+\
self.specialform.symform2.get_plain()+r'}'
self.answer.update(Symform(self.symform.plain + specplain), compile=False)
except ValueError:
print('Exception: cant display your input:', self.symform.plain)
self.unclear.field.grid(row=1, column=6, rowspan=2, sticky="nsew")
self.symform.plain = ''
def generate(self):
x = symbols('x')
a, b, c, d, e, f = symbols('a b c d e f')
substitutions, eqn, LQ = [], None, None
# HCF
if self.difficulty == 1:
expr = expand(random.choice([
x * (x + a),
x * (x - a),
]))
if random.random() < 0.3:
expr *= b
if random.random() < 0.3:
expr *= -1
eqn = Eq(expr, 0)
substitutions = [
(a, random.randint(2, 10)),
(b, random.randint(2, 10)),
(c, random.randint(2, 10)),
(d, random.randint(1, 10)),
]
# Cross
elif self.difficulty == 2:
expr = expand(
random.choice([
(x + a) * (x + b),
(x - a) * (x + b),
(x + a) * (x - b),
(x - a) * (x - b),
]))
if random.random() < 0.5:
expr *= c
eqn = Eq(expr, 0)
substitutions = [
(a, random.randint(2, 10)),
(b, random.randint(1, 6)),
(c, random.randint(2, 5)),
(d, random.randint(1, 10)),
]
# DOPS
elif self.difficulty == 3:
expr = expand(
random.choice([
(x + a) * (x - a),
(a * x + b) * (a * x - b),
]))
if random.random() < 0.3:
expr *= c
eqn = Eq(expr, 0)
substitutions = [
(a, random.randint(2, 10)),
(b, random.randint(1, 10)),
(c, random.randint(2, 5)),
(d, random.randint(1, 10)),
]
# Non-monic
elif self.difficulty == 4:
expr = expand(
random.choice([
(a * x + b) * (x + d),
(a * x + b) * (c * x + d),
]))
if random.random() < 0.3:
expr *= a
eqn = Eq(expr, 0)
substitutions = [
(a, random.randint(2, 4)),
(b, random.randint(2, 10)),
(c, random.randint(2, 5)),
(d, random.randint(2, 5)),
]
for old, new in substitutions:
with evaluate(True):
eqn = eqn.replace(old, new)
try:
soln = solve(eqn, x)[0], solve(eqn, x)[1]
except IndexError:
# no solution
soln = 'No solution'
a = substitutions[0][1]
b = substitutions[1][1]
c = substitutions[2][1]
d = substitutions[3][1]
Q = getPretty(eqn)
A = getPretty(soln)
LQ = '$\displaystyle {}$'.format(latex(eqn))
LA = '$\displaystyle x={}, \ {}$'.format(soln[0], soln[1])
return Q, A, LQ, LA
