| | from sympy.calculus.accumulationbounds import AccumBounds |
| | from sympy.concrete.summations import Sum |
| | from sympy.core.basic import Basic |
| | from sympy.core.containers import Tuple |
| | from sympy.core.function import Derivative, Lambda, diff, Function |
| | from sympy.core.numbers import (zoo, Float, Integer, I, oo, pi, E, |
| | Rational) |
| | from sympy.core.relational import Lt, Ge, Ne, Eq |
| | from sympy.core.singleton import S |
| | from sympy.core.symbol import symbols, Symbol |
| | from sympy.core.sympify import sympify |
| | from sympy.functions.combinatorial.factorials import (factorial2, |
| | binomial, factorial) |
| | from sympy.functions.combinatorial.numbers import (lucas, bell, |
| | catalan, euler, tribonacci, fibonacci, bernoulli, primenu, primeomega, |
| | totient, reduced_totient) |
| | from sympy.functions.elementary.complexes import re, im, conjugate, Abs |
| | from sympy.functions.elementary.exponential import exp, LambertW, log |
| | from sympy.functions.elementary.hyperbolic import (tanh, acoth, atanh, |
| | coth, asinh, acsch, asech, acosh, csch, sinh, cosh, sech) |
| | from sympy.functions.elementary.integers import ceiling, floor |
| | from sympy.functions.elementary.miscellaneous import Max, Min |
| | from sympy.functions.elementary.trigonometric import (csc, sec, tan, |
| | atan, sin, asec, cot, cos, acot, acsc, asin, acos) |
| | from sympy.functions.special.delta_functions import Heaviside |
| | from sympy.functions.special.elliptic_integrals import (elliptic_pi, |
| | elliptic_f, elliptic_k, elliptic_e) |
| | from sympy.functions.special.error_functions import (fresnelc, |
| | fresnels, Ei, expint) |
| | from sympy.functions.special.gamma_functions import (gamma, uppergamma, |
| | lowergamma) |
| | from sympy.functions.special.mathieu_functions import (mathieusprime, |
| | mathieus, mathieucprime, mathieuc) |
| | from sympy.functions.special.polynomials import (jacobi, chebyshevu, |
| | chebyshevt, hermite, assoc_legendre, gegenbauer, assoc_laguerre, |
| | legendre, laguerre) |
| | from sympy.functions.special.singularity_functions import SingularityFunction |
| | from sympy.functions.special.zeta_functions import (polylog, stieltjes, |
| | lerchphi, dirichlet_eta, zeta) |
| | from sympy.integrals.integrals import Integral |
| | from sympy.logic.boolalg import (Xor, Or, false, true, And, Equivalent, |
| | Implies, Not) |
| | from sympy.matrices.dense import Matrix |
| | from sympy.matrices.expressions.determinant import Determinant |
| | from sympy.matrices.expressions.matexpr import MatrixSymbol |
| | from sympy.physics.quantum import (ComplexSpace, FockSpace, hbar, |
| | HilbertSpace, Dagger) |
| | from sympy.printing.mathml import (MathMLPresentationPrinter, |
| | MathMLPrinter, MathMLContentPrinter, mathml) |
| | from sympy.series.limits import Limit |
| | from sympy.sets.contains import Contains |
| | from sympy.sets.fancysets import Range |
| | from sympy.sets.sets import (Interval, Union, SymmetricDifference, |
| | Complement, FiniteSet, Intersection, ProductSet) |
| | from sympy.stats.rv import RandomSymbol |
| | from sympy.tensor.indexed import IndexedBase |
| | from sympy.vector import (Divergence, CoordSys3D, Cross, Curl, Dot, |
| | Laplacian, Gradient) |
| | from sympy.testing.pytest import raises, XFAIL |
| |
|
| | x, y, z, a, b, c, d, e, n = symbols('x:z a:e n') |
| | mp = MathMLContentPrinter() |
| | mpp = MathMLPresentationPrinter() |
| |
|
| |
|
| | def test_mathml_printer(): |
| | m = MathMLPrinter() |
| | assert m.doprint(1+x) == mp.doprint(1+x) |
| |
|
| |
|
| | def test_content_printmethod(): |
| | assert mp.doprint(1 + x) == '<apply><plus/><ci>x</ci><cn>1</cn></apply>' |
| |
|
| |
|
| | def test_content_mathml_core(): |
| | mml_1 = mp._print(1 + x) |
| | assert mml_1.nodeName == 'apply' |
| | nodes = mml_1.childNodes |
| | assert len(nodes) == 3 |
| | assert nodes[0].nodeName == 'plus' |
| | assert nodes[0].hasChildNodes() is False |
| | assert nodes[0].nodeValue is None |
| | assert nodes[1].nodeName in ['cn', 'ci'] |
| | if nodes[1].nodeName == 'cn': |
| | assert nodes[1].childNodes[0].nodeValue == '1' |
| | assert nodes[2].childNodes[0].nodeValue == 'x' |
| | else: |
| | assert nodes[1].childNodes[0].nodeValue == 'x' |
| | assert nodes[2].childNodes[0].nodeValue == '1' |
| |
|
| | mml_2 = mp._print(x**2) |
| | assert mml_2.nodeName == 'apply' |
| | nodes = mml_2.childNodes |
| | assert nodes[1].childNodes[0].nodeValue == 'x' |
| | assert nodes[2].childNodes[0].nodeValue == '2' |
| |
|
| | mml_3 = mp._print(2*x) |
| | assert mml_3.nodeName == 'apply' |
| | nodes = mml_3.childNodes |
| | assert nodes[0].nodeName == 'times' |
| | assert nodes[1].childNodes[0].nodeValue == '2' |
| | assert nodes[2].childNodes[0].nodeValue == 'x' |
| |
|
| | mml = mp._print(Float(1.0, 2)*x) |
| | assert mml.nodeName == 'apply' |
| | nodes = mml.childNodes |
| | assert nodes[0].nodeName == 'times' |
| | assert nodes[1].childNodes[0].nodeValue == '1.0' |
| | assert nodes[2].childNodes[0].nodeValue == 'x' |
| |
|
| |
|
| | def test_content_mathml_functions(): |
| | mml_1 = mp._print(sin(x)) |
| | assert mml_1.nodeName == 'apply' |
| | assert mml_1.childNodes[0].nodeName == 'sin' |
| | assert mml_1.childNodes[1].nodeName == 'ci' |
| |
|
| | mml_2 = mp._print(diff(sin(x), x, evaluate=False)) |
| | assert mml_2.nodeName == 'apply' |
| | assert mml_2.childNodes[0].nodeName == 'diff' |
| | assert mml_2.childNodes[1].nodeName == 'bvar' |
| | assert mml_2.childNodes[1].childNodes[ |
| | 0].nodeName == 'ci' |
| |
|
| | mml_3 = mp._print(diff(cos(x*y), x, evaluate=False)) |
| | assert mml_3.nodeName == 'apply' |
| | assert mml_3.childNodes[0].nodeName == 'partialdiff' |
| | assert mml_3.childNodes[1].nodeName == 'bvar' |
| | assert mml_3.childNodes[1].childNodes[ |
| | 0].nodeName == 'ci' |
| |
|
| | mml_4 = mp._print(Lambda((x, y), x * y)) |
| | assert mml_4.nodeName == 'lambda' |
| | assert mml_4.childNodes[0].nodeName == 'bvar' |
| | assert mml_4.childNodes[0].childNodes[ |
| | 0].nodeName == 'ci' |
| | assert mml_4.childNodes[1].nodeName == 'bvar' |
| | assert mml_4.childNodes[1].childNodes[ |
| | 0].nodeName == 'ci' |
| | assert mml_4.childNodes[2].nodeName == 'apply' |
| |
|
| |
|
| | def test_content_mathml_limits(): |
| | |
| | lim_fun = sin(x)/x |
| | mml_1 = mp._print(Limit(lim_fun, x, 0)) |
| | assert mml_1.childNodes[0].nodeName == 'limit' |
| | assert mml_1.childNodes[1].nodeName == 'bvar' |
| | assert mml_1.childNodes[2].nodeName == 'lowlimit' |
| | assert mml_1.childNodes[3].toxml() == mp._print(lim_fun).toxml() |
| |
|
| |
|
| | def test_content_mathml_integrals(): |
| | integrand = x |
| | mml_1 = mp._print(Integral(integrand, (x, 0, 1))) |
| | assert mml_1.childNodes[0].nodeName == 'int' |
| | assert mml_1.childNodes[1].nodeName == 'bvar' |
| | assert mml_1.childNodes[2].nodeName == 'lowlimit' |
| | assert mml_1.childNodes[3].nodeName == 'uplimit' |
| | assert mml_1.childNodes[4].toxml() == mp._print(integrand).toxml() |
| |
|
| |
|
| | def test_content_mathml_matrices(): |
| | A = Matrix([1, 2, 3]) |
| | B = Matrix([[0, 5, 4], [2, 3, 1], [9, 7, 9]]) |
| | mll_1 = mp._print(A) |
| | assert mll_1.childNodes[0].nodeName == 'matrixrow' |
| | assert mll_1.childNodes[0].childNodes[0].nodeName == 'cn' |
| | assert mll_1.childNodes[0].childNodes[0].childNodes[0].nodeValue == '1' |
| | assert mll_1.childNodes[1].nodeName == 'matrixrow' |
| | assert mll_1.childNodes[1].childNodes[0].nodeName == 'cn' |
| | assert mll_1.childNodes[1].childNodes[0].childNodes[0].nodeValue == '2' |
| | assert mll_1.childNodes[2].nodeName == 'matrixrow' |
| | assert mll_1.childNodes[2].childNodes[0].nodeName == 'cn' |
| | assert mll_1.childNodes[2].childNodes[0].childNodes[0].nodeValue == '3' |
| | mll_2 = mp._print(B) |
| | assert mll_2.childNodes[0].nodeName == 'matrixrow' |
| | assert mll_2.childNodes[0].childNodes[0].nodeName == 'cn' |
| | assert mll_2.childNodes[0].childNodes[0].childNodes[0].nodeValue == '0' |
| | assert mll_2.childNodes[0].childNodes[1].nodeName == 'cn' |
| | assert mll_2.childNodes[0].childNodes[1].childNodes[0].nodeValue == '5' |
| | assert mll_2.childNodes[0].childNodes[2].nodeName == 'cn' |
| | assert mll_2.childNodes[0].childNodes[2].childNodes[0].nodeValue == '4' |
| | assert mll_2.childNodes[1].nodeName == 'matrixrow' |
| | assert mll_2.childNodes[1].childNodes[0].nodeName == 'cn' |
| | assert mll_2.childNodes[1].childNodes[0].childNodes[0].nodeValue == '2' |
| | assert mll_2.childNodes[1].childNodes[1].nodeName == 'cn' |
| | assert mll_2.childNodes[1].childNodes[1].childNodes[0].nodeValue == '3' |
| | assert mll_2.childNodes[1].childNodes[2].nodeName == 'cn' |
| | assert mll_2.childNodes[1].childNodes[2].childNodes[0].nodeValue == '1' |
| | assert mll_2.childNodes[2].nodeName == 'matrixrow' |
| | assert mll_2.childNodes[2].childNodes[0].nodeName == 'cn' |
| | assert mll_2.childNodes[2].childNodes[0].childNodes[0].nodeValue == '9' |
| | assert mll_2.childNodes[2].childNodes[1].nodeName == 'cn' |
| | assert mll_2.childNodes[2].childNodes[1].childNodes[0].nodeValue == '7' |
| | assert mll_2.childNodes[2].childNodes[2].nodeName == 'cn' |
| | assert mll_2.childNodes[2].childNodes[2].childNodes[0].nodeValue == '9' |
| |
|
| |
|
| | def test_content_mathml_sums(): |
| | summand = x |
| | mml_1 = mp._print(Sum(summand, (x, 1, 10))) |
| | assert mml_1.childNodes[0].nodeName == 'sum' |
| | assert mml_1.childNodes[1].nodeName == 'bvar' |
| | assert mml_1.childNodes[2].nodeName == 'lowlimit' |
| | assert mml_1.childNodes[3].nodeName == 'uplimit' |
| | assert mml_1.childNodes[4].toxml() == mp._print(summand).toxml() |
| |
|
| |
|
| | def test_content_mathml_tuples(): |
| | mml_1 = mp._print([2]) |
| | assert mml_1.nodeName == 'list' |
| | assert mml_1.childNodes[0].nodeName == 'cn' |
| | assert len(mml_1.childNodes) == 1 |
| |
|
| | mml_2 = mp._print([2, Integer(1)]) |
| | assert mml_2.nodeName == 'list' |
| | assert mml_2.childNodes[0].nodeName == 'cn' |
| | assert mml_2.childNodes[1].nodeName == 'cn' |
| | assert len(mml_2.childNodes) == 2 |
| |
|
| |
|
| | def test_content_mathml_add(): |
| | mml = mp._print(x**5 - x**4 + x) |
| | assert mml.childNodes[0].nodeName == 'plus' |
| | assert mml.childNodes[1].childNodes[0].nodeName == 'minus' |
| | assert mml.childNodes[1].childNodes[1].nodeName == 'apply' |
| |
|
| |
|
| | def test_content_mathml_Rational(): |
| | mml_1 = mp._print(Rational(1, 1)) |
| | """should just return a number""" |
| | assert mml_1.nodeName == 'cn' |
| |
|
| | mml_2 = mp._print(Rational(2, 5)) |
| | assert mml_2.childNodes[0].nodeName == 'divide' |
| |
|
| |
|
| | def test_content_mathml_constants(): |
| | mml = mp._print(I) |
| | assert mml.nodeName == 'imaginaryi' |
| |
|
| | mml = mp._print(E) |
| | assert mml.nodeName == 'exponentiale' |
| |
|
| | mml = mp._print(oo) |
| | assert mml.nodeName == 'infinity' |
| |
|
| | mml = mp._print(pi) |
| | assert mml.nodeName == 'pi' |
| |
|
| | assert mathml(hbar) == '<hbar/>' |
| | assert mathml(S.TribonacciConstant) == '<tribonacciconstant/>' |
| | assert mathml(S.GoldenRatio) == '<cn>φ</cn>' |
| | mml = mathml(S.EulerGamma) |
| | assert mml == '<eulergamma/>' |
| |
|
| | mml = mathml(S.EmptySet) |
| | assert mml == '<emptyset/>' |
| |
|
| | mml = mathml(S.true) |
| | assert mml == '<true/>' |
| |
|
| | mml = mathml(S.false) |
| | assert mml == '<false/>' |
| |
|
| | mml = mathml(S.NaN) |
| | assert mml == '<notanumber/>' |
| |
|
| |
|
| | def test_content_mathml_trig(): |
| | mml = mp._print(sin(x)) |
| | assert mml.childNodes[0].nodeName == 'sin' |
| |
|
| | mml = mp._print(cos(x)) |
| | assert mml.childNodes[0].nodeName == 'cos' |
| |
|
| | mml = mp._print(tan(x)) |
| | assert mml.childNodes[0].nodeName == 'tan' |
| |
|
| | mml = mp._print(cot(x)) |
| | assert mml.childNodes[0].nodeName == 'cot' |
| |
|
| | mml = mp._print(csc(x)) |
| | assert mml.childNodes[0].nodeName == 'csc' |
| |
|
| | mml = mp._print(sec(x)) |
| | assert mml.childNodes[0].nodeName == 'sec' |
| |
|
| | mml = mp._print(asin(x)) |
| | assert mml.childNodes[0].nodeName == 'arcsin' |
| |
|
| | mml = mp._print(acos(x)) |
| | assert mml.childNodes[0].nodeName == 'arccos' |
| |
|
| | mml = mp._print(atan(x)) |
| | assert mml.childNodes[0].nodeName == 'arctan' |
| |
|
| | mml = mp._print(acot(x)) |
| | assert mml.childNodes[0].nodeName == 'arccot' |
| |
|
| | mml = mp._print(acsc(x)) |
| | assert mml.childNodes[0].nodeName == 'arccsc' |
| |
|
| | mml = mp._print(asec(x)) |
| | assert mml.childNodes[0].nodeName == 'arcsec' |
| |
|
| | mml = mp._print(sinh(x)) |
| | assert mml.childNodes[0].nodeName == 'sinh' |
| |
|
| | mml = mp._print(cosh(x)) |
| | assert mml.childNodes[0].nodeName == 'cosh' |
| |
|
| | mml = mp._print(tanh(x)) |
| | assert mml.childNodes[0].nodeName == 'tanh' |
| |
|
| | mml = mp._print(coth(x)) |
| | assert mml.childNodes[0].nodeName == 'coth' |
| |
|
| | mml = mp._print(csch(x)) |
| | assert mml.childNodes[0].nodeName == 'csch' |
| |
|
| | mml = mp._print(sech(x)) |
| | assert mml.childNodes[0].nodeName == 'sech' |
| |
|
| | mml = mp._print(asinh(x)) |
| | assert mml.childNodes[0].nodeName == 'arcsinh' |
| |
|
| | mml = mp._print(atanh(x)) |
| | assert mml.childNodes[0].nodeName == 'arctanh' |
| |
|
| | mml = mp._print(acosh(x)) |
| | assert mml.childNodes[0].nodeName == 'arccosh' |
| |
|
| | mml = mp._print(acoth(x)) |
| | assert mml.childNodes[0].nodeName == 'arccoth' |
| |
|
| | mml = mp._print(acsch(x)) |
| | assert mml.childNodes[0].nodeName == 'arccsch' |
| |
|
| | mml = mp._print(asech(x)) |
| | assert mml.childNodes[0].nodeName == 'arcsech' |
| |
|
| |
|
| | def test_content_mathml_relational(): |
| | mml_1 = mp._print(Eq(x, 1)) |
| | assert mml_1.nodeName == 'apply' |
| | assert mml_1.childNodes[0].nodeName == 'eq' |
| | assert mml_1.childNodes[1].nodeName == 'ci' |
| | assert mml_1.childNodes[1].childNodes[0].nodeValue == 'x' |
| | assert mml_1.childNodes[2].nodeName == 'cn' |
| | assert mml_1.childNodes[2].childNodes[0].nodeValue == '1' |
| |
|
| | mml_2 = mp._print(Ne(1, x)) |
| | assert mml_2.nodeName == 'apply' |
| | assert mml_2.childNodes[0].nodeName == 'neq' |
| | assert mml_2.childNodes[1].nodeName == 'cn' |
| | assert mml_2.childNodes[1].childNodes[0].nodeValue == '1' |
| | assert mml_2.childNodes[2].nodeName == 'ci' |
| | assert mml_2.childNodes[2].childNodes[0].nodeValue == 'x' |
| |
|
| | mml_3 = mp._print(Ge(1, x)) |
| | assert mml_3.nodeName == 'apply' |
| | assert mml_3.childNodes[0].nodeName == 'geq' |
| | assert mml_3.childNodes[1].nodeName == 'cn' |
| | assert mml_3.childNodes[1].childNodes[0].nodeValue == '1' |
| | assert mml_3.childNodes[2].nodeName == 'ci' |
| | assert mml_3.childNodes[2].childNodes[0].nodeValue == 'x' |
| |
|
| | mml_4 = mp._print(Lt(1, x)) |
| | assert mml_4.nodeName == 'apply' |
| | assert mml_4.childNodes[0].nodeName == 'lt' |
| | assert mml_4.childNodes[1].nodeName == 'cn' |
| | assert mml_4.childNodes[1].childNodes[0].nodeValue == '1' |
| | assert mml_4.childNodes[2].nodeName == 'ci' |
| | assert mml_4.childNodes[2].childNodes[0].nodeValue == 'x' |
| |
|
| |
|
| | def test_content_symbol(): |
| | mml = mp._print(x) |
| | assert mml.nodeName == 'ci' |
| | assert mml.childNodes[0].nodeValue == 'x' |
| | del mml |
| |
|
| | mml = mp._print(Symbol("x^2")) |
| | assert mml.nodeName == 'ci' |
| | assert mml.childNodes[0].nodeName == 'mml:msup' |
| | assert mml.childNodes[0].childNodes[0].nodeName == 'mml:mi' |
| | assert mml.childNodes[0].childNodes[0].childNodes[0].nodeValue == 'x' |
| | assert mml.childNodes[0].childNodes[1].nodeName == 'mml:mi' |
| | assert mml.childNodes[0].childNodes[1].childNodes[0].nodeValue == '2' |
| | del mml |
| |
|
| | mml = mp._print(Symbol("x__2")) |
| | assert mml.nodeName == 'ci' |
| | assert mml.childNodes[0].nodeName == 'mml:msup' |
| | assert mml.childNodes[0].childNodes[0].nodeName == 'mml:mi' |
| | assert mml.childNodes[0].childNodes[0].childNodes[0].nodeValue == 'x' |
| | assert mml.childNodes[0].childNodes[1].nodeName == 'mml:mi' |
| | assert mml.childNodes[0].childNodes[1].childNodes[0].nodeValue == '2' |
| | del mml |
| |
|
| | mml = mp._print(Symbol("x_2")) |
| | assert mml.nodeName == 'ci' |
| | assert mml.childNodes[0].nodeName == 'mml:msub' |
| | assert mml.childNodes[0].childNodes[0].nodeName == 'mml:mi' |
| | assert mml.childNodes[0].childNodes[0].childNodes[0].nodeValue == 'x' |
| | assert mml.childNodes[0].childNodes[1].nodeName == 'mml:mi' |
| | assert mml.childNodes[0].childNodes[1].childNodes[0].nodeValue == '2' |
| | del mml |
| |
|
| | mml = mp._print(Symbol("x^3_2")) |
| | assert mml.nodeName == 'ci' |
| | assert mml.childNodes[0].nodeName == 'mml:msubsup' |
| | assert mml.childNodes[0].childNodes[0].nodeName == 'mml:mi' |
| | assert mml.childNodes[0].childNodes[0].childNodes[0].nodeValue == 'x' |
| | assert mml.childNodes[0].childNodes[1].nodeName == 'mml:mi' |
| | assert mml.childNodes[0].childNodes[1].childNodes[0].nodeValue == '2' |
| | assert mml.childNodes[0].childNodes[2].nodeName == 'mml:mi' |
| | assert mml.childNodes[0].childNodes[2].childNodes[0].nodeValue == '3' |
| | del mml |
| |
|
| | mml = mp._print(Symbol("x__3_2")) |
| | assert mml.nodeName == 'ci' |
| | assert mml.childNodes[0].nodeName == 'mml:msubsup' |
| | assert mml.childNodes[0].childNodes[0].nodeName == 'mml:mi' |
| | assert mml.childNodes[0].childNodes[0].childNodes[0].nodeValue == 'x' |
| | assert mml.childNodes[0].childNodes[1].nodeName == 'mml:mi' |
| | assert mml.childNodes[0].childNodes[1].childNodes[0].nodeValue == '2' |
| | assert mml.childNodes[0].childNodes[2].nodeName == 'mml:mi' |
| | assert mml.childNodes[0].childNodes[2].childNodes[0].nodeValue == '3' |
| | del mml |
| |
|
| | mml = mp._print(Symbol("x_2_a")) |
| | assert mml.nodeName == 'ci' |
| | assert mml.childNodes[0].nodeName == 'mml:msub' |
| | assert mml.childNodes[0].childNodes[0].nodeName == 'mml:mi' |
| | assert mml.childNodes[0].childNodes[0].childNodes[0].nodeValue == 'x' |
| | assert mml.childNodes[0].childNodes[1].nodeName == 'mml:mrow' |
| | assert mml.childNodes[0].childNodes[1].childNodes[0].nodeName == 'mml:mi' |
| | assert mml.childNodes[0].childNodes[1].childNodes[0].childNodes[ |
| | 0].nodeValue == '2' |
| | assert mml.childNodes[0].childNodes[1].childNodes[1].nodeName == 'mml:mo' |
| | assert mml.childNodes[0].childNodes[1].childNodes[1].childNodes[ |
| | 0].nodeValue == ' ' |
| | assert mml.childNodes[0].childNodes[1].childNodes[2].nodeName == 'mml:mi' |
| | assert mml.childNodes[0].childNodes[1].childNodes[2].childNodes[ |
| | 0].nodeValue == 'a' |
| | del mml |
| |
|
| | mml = mp._print(Symbol("x^2^a")) |
| | assert mml.nodeName == 'ci' |
| | assert mml.childNodes[0].nodeName == 'mml:msup' |
| | assert mml.childNodes[0].childNodes[0].nodeName == 'mml:mi' |
| | assert mml.childNodes[0].childNodes[0].childNodes[0].nodeValue == 'x' |
| | assert mml.childNodes[0].childNodes[1].nodeName == 'mml:mrow' |
| | assert mml.childNodes[0].childNodes[1].childNodes[0].nodeName == 'mml:mi' |
| | assert mml.childNodes[0].childNodes[1].childNodes[0].childNodes[ |
| | 0].nodeValue == '2' |
| | assert mml.childNodes[0].childNodes[1].childNodes[1].nodeName == 'mml:mo' |
| | assert mml.childNodes[0].childNodes[1].childNodes[1].childNodes[ |
| | 0].nodeValue == ' ' |
| | assert mml.childNodes[0].childNodes[1].childNodes[2].nodeName == 'mml:mi' |
| | assert mml.childNodes[0].childNodes[1].childNodes[2].childNodes[ |
| | 0].nodeValue == 'a' |
| | del mml |
| |
|
| | mml = mp._print(Symbol("x__2__a")) |
| | assert mml.nodeName == 'ci' |
| | assert mml.childNodes[0].nodeName == 'mml:msup' |
| | assert mml.childNodes[0].childNodes[0].nodeName == 'mml:mi' |
| | assert mml.childNodes[0].childNodes[0].childNodes[0].nodeValue == 'x' |
| | assert mml.childNodes[0].childNodes[1].nodeName == 'mml:mrow' |
| | assert mml.childNodes[0].childNodes[1].childNodes[0].nodeName == 'mml:mi' |
| | assert mml.childNodes[0].childNodes[1].childNodes[0].childNodes[ |
| | 0].nodeValue == '2' |
| | assert mml.childNodes[0].childNodes[1].childNodes[1].nodeName == 'mml:mo' |
| | assert mml.childNodes[0].childNodes[1].childNodes[1].childNodes[ |
| | 0].nodeValue == ' ' |
| | assert mml.childNodes[0].childNodes[1].childNodes[2].nodeName == 'mml:mi' |
| | assert mml.childNodes[0].childNodes[1].childNodes[2].childNodes[ |
| | 0].nodeValue == 'a' |
| | del mml |
| |
|
| |
|
| | def test_content_mathml_greek(): |
| | mml = mp._print(Symbol('alpha')) |
| | assert mml.nodeName == 'ci' |
| | assert mml.childNodes[0].nodeValue == '\N{GREEK SMALL LETTER ALPHA}' |
| |
|
| | assert mp.doprint(Symbol('alpha')) == '<ci>α</ci>' |
| | assert mp.doprint(Symbol('beta')) == '<ci>β</ci>' |
| | assert mp.doprint(Symbol('gamma')) == '<ci>γ</ci>' |
| | assert mp.doprint(Symbol('delta')) == '<ci>δ</ci>' |
| | assert mp.doprint(Symbol('epsilon')) == '<ci>ε</ci>' |
| | assert mp.doprint(Symbol('zeta')) == '<ci>ζ</ci>' |
| | assert mp.doprint(Symbol('eta')) == '<ci>η</ci>' |
| | assert mp.doprint(Symbol('theta')) == '<ci>θ</ci>' |
| | assert mp.doprint(Symbol('iota')) == '<ci>ι</ci>' |
| | assert mp.doprint(Symbol('kappa')) == '<ci>κ</ci>' |
| | assert mp.doprint(Symbol('lambda')) == '<ci>λ</ci>' |
| | assert mp.doprint(Symbol('mu')) == '<ci>μ</ci>' |
| | assert mp.doprint(Symbol('nu')) == '<ci>ν</ci>' |
| | assert mp.doprint(Symbol('xi')) == '<ci>ξ</ci>' |
| | assert mp.doprint(Symbol('omicron')) == '<ci>ο</ci>' |
| | assert mp.doprint(Symbol('pi')) == '<ci>π</ci>' |
| | assert mp.doprint(Symbol('rho')) == '<ci>ρ</ci>' |
| | assert mp.doprint(Symbol('varsigma')) == '<ci>ς</ci>' |
| | assert mp.doprint(Symbol('sigma')) == '<ci>σ</ci>' |
| | assert mp.doprint(Symbol('tau')) == '<ci>τ</ci>' |
| | assert mp.doprint(Symbol('upsilon')) == '<ci>υ</ci>' |
| | assert mp.doprint(Symbol('phi')) == '<ci>φ</ci>' |
| | assert mp.doprint(Symbol('chi')) == '<ci>χ</ci>' |
| | assert mp.doprint(Symbol('psi')) == '<ci>ψ</ci>' |
| | assert mp.doprint(Symbol('omega')) == '<ci>ω</ci>' |
| |
|
| | assert mp.doprint(Symbol('Alpha')) == '<ci>Α</ci>' |
| | assert mp.doprint(Symbol('Beta')) == '<ci>Β</ci>' |
| | assert mp.doprint(Symbol('Gamma')) == '<ci>Γ</ci>' |
| | assert mp.doprint(Symbol('Delta')) == '<ci>Δ</ci>' |
| | assert mp.doprint(Symbol('Epsilon')) == '<ci>Ε</ci>' |
| | assert mp.doprint(Symbol('Zeta')) == '<ci>Ζ</ci>' |
| | assert mp.doprint(Symbol('Eta')) == '<ci>Η</ci>' |
| | assert mp.doprint(Symbol('Theta')) == '<ci>Θ</ci>' |
| | assert mp.doprint(Symbol('Iota')) == '<ci>Ι</ci>' |
| | assert mp.doprint(Symbol('Kappa')) == '<ci>Κ</ci>' |
| | assert mp.doprint(Symbol('Lambda')) == '<ci>Λ</ci>' |
| | assert mp.doprint(Symbol('Mu')) == '<ci>Μ</ci>' |
| | assert mp.doprint(Symbol('Nu')) == '<ci>Ν</ci>' |
| | assert mp.doprint(Symbol('Xi')) == '<ci>Ξ</ci>' |
| | assert mp.doprint(Symbol('Omicron')) == '<ci>Ο</ci>' |
| | assert mp.doprint(Symbol('Pi')) == '<ci>Π</ci>' |
| | assert mp.doprint(Symbol('Rho')) == '<ci>Ρ</ci>' |
| | assert mp.doprint(Symbol('Sigma')) == '<ci>Σ</ci>' |
| | assert mp.doprint(Symbol('Tau')) == '<ci>Τ</ci>' |
| | assert mp.doprint(Symbol('Upsilon')) == '<ci>Υ</ci>' |
| | assert mp.doprint(Symbol('Phi')) == '<ci>Φ</ci>' |
| | assert mp.doprint(Symbol('Chi')) == '<ci>Χ</ci>' |
| | assert mp.doprint(Symbol('Psi')) == '<ci>Ψ</ci>' |
| | assert mp.doprint(Symbol('Omega')) == '<ci>Ω</ci>' |
| |
|
| |
|
| | def test_content_mathml_order(): |
| | expr = x**3 + x**2*y + 3*x*y**3 + y**4 |
| |
|
| | mp = MathMLContentPrinter({'order': 'lex'}) |
| | mml = mp._print(expr) |
| |
|
| | assert mml.childNodes[1].childNodes[0].nodeName == 'power' |
| | assert mml.childNodes[1].childNodes[1].childNodes[0].data == 'x' |
| | assert mml.childNodes[1].childNodes[2].childNodes[0].data == '3' |
| |
|
| | assert mml.childNodes[4].childNodes[0].nodeName == 'power' |
| | assert mml.childNodes[4].childNodes[1].childNodes[0].data == 'y' |
| | assert mml.childNodes[4].childNodes[2].childNodes[0].data == '4' |
| |
|
| | mp = MathMLContentPrinter({'order': 'rev-lex'}) |
| | mml = mp._print(expr) |
| |
|
| | assert mml.childNodes[1].childNodes[0].nodeName == 'power' |
| | assert mml.childNodes[1].childNodes[1].childNodes[0].data == 'y' |
| | assert mml.childNodes[1].childNodes[2].childNodes[0].data == '4' |
| |
|
| | assert mml.childNodes[4].childNodes[0].nodeName == 'power' |
| | assert mml.childNodes[4].childNodes[1].childNodes[0].data == 'x' |
| | assert mml.childNodes[4].childNodes[2].childNodes[0].data == '3' |
| |
|
| |
|
| | def test_content_settings(): |
| | raises(TypeError, lambda: mathml(x, method="garbage")) |
| |
|
| |
|
| | def test_content_mathml_logic(): |
| | assert mathml(And(x, y)) == '<apply><and/><ci>x</ci><ci>y</ci></apply>' |
| | assert mathml(Or(x, y)) == '<apply><or/><ci>x</ci><ci>y</ci></apply>' |
| | assert mathml(Xor(x, y)) == '<apply><xor/><ci>x</ci><ci>y</ci></apply>' |
| | assert mathml(Implies(x, y)) == '<apply><implies/><ci>x</ci><ci>y</ci></apply>' |
| | assert mathml(Not(x)) == '<apply><not/><ci>x</ci></apply>' |
| |
|
| |
|
| | def test_content_finite_sets(): |
| | assert mathml(FiniteSet(a)) == '<set><ci>a</ci></set>' |
| | assert mathml(FiniteSet(a, b)) == '<set><ci>a</ci><ci>b</ci></set>' |
| | assert mathml(FiniteSet(FiniteSet(a, b), c)) == \ |
| | '<set><ci>c</ci><set><ci>a</ci><ci>b</ci></set></set>' |
| |
|
| | A = FiniteSet(a) |
| | B = FiniteSet(b) |
| | C = FiniteSet(c) |
| | D = FiniteSet(d) |
| |
|
| | U1 = Union(A, B, evaluate=False) |
| | U2 = Union(C, D, evaluate=False) |
| | I1 = Intersection(A, B, evaluate=False) |
| | I2 = Intersection(C, D, evaluate=False) |
| | C1 = Complement(A, B, evaluate=False) |
| | C2 = Complement(C, D, evaluate=False) |
| | |
| | P1 = ProductSet(A, B) |
| | P2 = ProductSet(C, D) |
| |
|
| | assert mathml(U1) == \ |
| | '<apply><union/><set><ci>a</ci></set><set><ci>b</ci></set></apply>' |
| | assert mathml(I1) == \ |
| | '<apply><intersect/><set><ci>a</ci></set><set><ci>b</ci></set>' \ |
| | '</apply>' |
| | assert mathml(C1) == \ |
| | '<apply><setdiff/><set><ci>a</ci></set><set><ci>b</ci></set></apply>' |
| | assert mathml(P1) == \ |
| | '<apply><cartesianproduct/><set><ci>a</ci></set><set><ci>b</ci>' \ |
| | '</set></apply>' |
| |
|
| | assert mathml(Intersection(A, U2, evaluate=False)) == \ |
| | '<apply><intersect/><set><ci>a</ci></set><apply><union/><set>' \ |
| | '<ci>c</ci></set><set><ci>d</ci></set></apply></apply>' |
| | assert mathml(Intersection(U1, U2, evaluate=False)) == \ |
| | '<apply><intersect/><apply><union/><set><ci>a</ci></set><set>' \ |
| | '<ci>b</ci></set></apply><apply><union/><set><ci>c</ci></set>' \ |
| | '<set><ci>d</ci></set></apply></apply>' |
| |
|
| | |
| | assert mathml(Intersection(C1, C2, evaluate=False)) == \ |
| | '<apply><intersect/><apply><setdiff/><set><ci>a</ci></set><set>' \ |
| | '<ci>b</ci></set></apply><apply><setdiff/><set><ci>c</ci></set>' \ |
| | '<set><ci>d</ci></set></apply></apply>' |
| | assert mathml(Intersection(P1, P2, evaluate=False)) == \ |
| | '<apply><intersect/><apply><cartesianproduct/><set><ci>a</ci></set>' \ |
| | '<set><ci>b</ci></set></apply><apply><cartesianproduct/><set>' \ |
| | '<ci>c</ci></set><set><ci>d</ci></set></apply></apply>' |
| |
|
| | assert mathml(Union(A, I2, evaluate=False)) == \ |
| | '<apply><union/><set><ci>a</ci></set><apply><intersect/><set>' \ |
| | '<ci>c</ci></set><set><ci>d</ci></set></apply></apply>' |
| | assert mathml(Union(I1, I2, evaluate=False)) == \ |
| | '<apply><union/><apply><intersect/><set><ci>a</ci></set><set>' \ |
| | '<ci>b</ci></set></apply><apply><intersect/><set><ci>c</ci></set>' \ |
| | '<set><ci>d</ci></set></apply></apply>' |
| | assert mathml(Union(C1, C2, evaluate=False)) == \ |
| | '<apply><union/><apply><setdiff/><set><ci>a</ci></set><set>' \ |
| | '<ci>b</ci></set></apply><apply><setdiff/><set><ci>c</ci></set>' \ |
| | '<set><ci>d</ci></set></apply></apply>' |
| | assert mathml(Union(P1, P2, evaluate=False)) == \ |
| | '<apply><union/><apply><cartesianproduct/><set><ci>a</ci></set>' \ |
| | '<set><ci>b</ci></set></apply><apply><cartesianproduct/><set>' \ |
| | '<ci>c</ci></set><set><ci>d</ci></set></apply></apply>' |
| |
|
| | assert mathml(Complement(A, C2, evaluate=False)) == \ |
| | '<apply><setdiff/><set><ci>a</ci></set><apply><setdiff/><set>' \ |
| | '<ci>c</ci></set><set><ci>d</ci></set></apply></apply>' |
| | assert mathml(Complement(U1, U2, evaluate=False)) == \ |
| | '<apply><setdiff/><apply><union/><set><ci>a</ci></set><set>' \ |
| | '<ci>b</ci></set></apply><apply><union/><set><ci>c</ci></set>' \ |
| | '<set><ci>d</ci></set></apply></apply>' |
| | assert mathml(Complement(I1, I2, evaluate=False)) == \ |
| | '<apply><setdiff/><apply><intersect/><set><ci>a</ci></set><set>' \ |
| | '<ci>b</ci></set></apply><apply><intersect/><set><ci>c</ci></set>' \ |
| | '<set><ci>d</ci></set></apply></apply>' |
| | assert mathml(Complement(P1, P2, evaluate=False)) == \ |
| | '<apply><setdiff/><apply><cartesianproduct/><set><ci>a</ci></set>' \ |
| | '<set><ci>b</ci></set></apply><apply><cartesianproduct/><set>' \ |
| | '<ci>c</ci></set><set><ci>d</ci></set></apply></apply>' |
| |
|
| | assert mathml(ProductSet(A, P2)) == \ |
| | '<apply><cartesianproduct/><set><ci>a</ci></set>' \ |
| | '<apply><cartesianproduct/><set><ci>c</ci></set>' \ |
| | '<set><ci>d</ci></set></apply></apply>' |
| | assert mathml(ProductSet(U1, U2)) == \ |
| | '<apply><cartesianproduct/><apply><union/><set><ci>a</ci></set>' \ |
| | '<set><ci>b</ci></set></apply><apply><union/><set><ci>c</ci></set>' \ |
| | '<set><ci>d</ci></set></apply></apply>' |
| | assert mathml(ProductSet(I1, I2)) == \ |
| | '<apply><cartesianproduct/><apply><intersect/><set><ci>a</ci></set>' \ |
| | '<set><ci>b</ci></set></apply><apply><intersect/><set>' \ |
| | '<ci>c</ci></set><set><ci>d</ci></set></apply></apply>' |
| | assert mathml(ProductSet(C1, C2)) == \ |
| | '<apply><cartesianproduct/><apply><setdiff/><set><ci>a</ci></set>' \ |
| | '<set><ci>b</ci></set></apply><apply><setdiff/><set>' \ |
| | '<ci>c</ci></set><set><ci>d</ci></set></apply></apply>' |
| |
|
| |
|
| | def test_presentation_printmethod(): |
| | assert mpp.doprint(1 + x) == '<mrow><mi>x</mi><mo>+</mo><mn>1</mn></mrow>' |
| | assert mpp.doprint(x**2) == '<msup><mi>x</mi><mn>2</mn></msup>' |
| | assert mpp.doprint(x**-1) == '<mfrac><mn>1</mn><mi>x</mi></mfrac>' |
| | assert mpp.doprint(x**-2) == \ |
| | '<mfrac><mn>1</mn><msup><mi>x</mi><mn>2</mn></msup></mfrac>' |
| | assert mpp.doprint(2*x) == \ |
| | '<mrow><mn>2</mn><mo>⁢</mo><mi>x</mi></mrow>' |
| |
|
| |
|
| | def test_presentation_mathml_core(): |
| | mml_1 = mpp._print(1 + x) |
| | assert mml_1.nodeName == 'mrow' |
| | nodes = mml_1.childNodes |
| | assert len(nodes) == 3 |
| | assert nodes[0].nodeName in ['mi', 'mn'] |
| | assert nodes[1].nodeName == 'mo' |
| | if nodes[0].nodeName == 'mn': |
| | assert nodes[0].childNodes[0].nodeValue == '1' |
| | assert nodes[2].childNodes[0].nodeValue == 'x' |
| | else: |
| | assert nodes[0].childNodes[0].nodeValue == 'x' |
| | assert nodes[2].childNodes[0].nodeValue == '1' |
| |
|
| | mml_2 = mpp._print(x**2) |
| | assert mml_2.nodeName == 'msup' |
| | nodes = mml_2.childNodes |
| | assert nodes[0].childNodes[0].nodeValue == 'x' |
| | assert nodes[1].childNodes[0].nodeValue == '2' |
| |
|
| | mml_3 = mpp._print(2*x) |
| | assert mml_3.nodeName == 'mrow' |
| | nodes = mml_3.childNodes |
| | assert nodes[0].childNodes[0].nodeValue == '2' |
| | assert nodes[1].childNodes[0].nodeValue == '⁢' |
| | assert nodes[2].childNodes[0].nodeValue == 'x' |
| |
|
| | mml = mpp._print(Float(1.0, 2)*x) |
| | assert mml.nodeName == 'mrow' |
| | nodes = mml.childNodes |
| | assert nodes[0].childNodes[0].nodeValue == '1.0' |
| | assert nodes[1].childNodes[0].nodeValue == '⁢' |
| | assert nodes[2].childNodes[0].nodeValue == 'x' |
| |
|
| |
|
| | def test_presentation_mathml_functions(): |
| | mml_1 = mpp._print(sin(x)) |
| | assert mml_1.childNodes[0].childNodes[0 |
| | ].nodeValue == 'sin' |
| | assert mml_1.childNodes[1].childNodes[1 |
| | ].childNodes[0].nodeValue == 'x' |
| |
|
| | mml_2 = mpp._print(diff(sin(x), x, evaluate=False)) |
| | assert mml_2.nodeName == 'mrow' |
| | assert mml_2.childNodes[0].childNodes[0 |
| | ].childNodes[0].childNodes[0].nodeValue == 'ⅆ' |
| | assert mml_2.childNodes[1].childNodes[1 |
| | ].nodeName == 'mrow' |
| | assert mml_2.childNodes[0].childNodes[1 |
| | ].childNodes[0].childNodes[0].nodeValue == 'ⅆ' |
| |
|
| | mml_3 = mpp._print(diff(cos(x*y), x, evaluate=False)) |
| | assert mml_3.childNodes[0].nodeName == 'mfrac' |
| | assert mml_3.childNodes[0].childNodes[0 |
| | ].childNodes[0].childNodes[0].nodeValue == '∂' |
| | assert mml_3.childNodes[1].childNodes[0 |
| | ].childNodes[0].nodeValue == 'cos' |
| |
|
| |
|
| | def test_print_derivative(): |
| | f = Function('f') |
| | d = Derivative(f(x, y, z), x, z, x, z, z, y) |
| | assert mathml(d) == \ |
| | '<apply><partialdiff/><bvar><ci>y</ci><ci>z</ci><degree><cn>2</cn></degree><ci>x</ci><ci>z</ci><ci>x</ci></bvar><apply><f/><ci>x</ci><ci>y</ci><ci>z</ci></apply></apply>' |
| | assert mathml(d, printer='presentation') == \ |
| | '<mrow><mfrac><mrow><msup><mo>∂</mo><mn>6</mn></msup></mrow><mrow><mo>∂</mo><mi>y</mi><msup><mo>∂</mo><mn>2</mn></msup><mi>z</mi><mo>∂</mo><mi>x</mi><mo>∂</mo><mi>z</mi><mo>∂</mo><mi>x</mi></mrow></mfrac><mrow><mi>f</mi><mrow><mo>(</mo><mi>x</mi><mo>,</mo><mi>y</mi><mo>,</mo><mi>z</mi><mo>)</mo></mrow></mrow></mrow>' |
| |
|
| |
|
| | def test_presentation_mathml_limits(): |
| | lim_fun = sin(x)/x |
| | mml_1 = mpp._print(Limit(lim_fun, x, 0)) |
| | assert mml_1.childNodes[0].nodeName == 'munder' |
| | assert mml_1.childNodes[0].childNodes[0 |
| | ].childNodes[0].nodeValue == 'lim' |
| | assert mml_1.childNodes[0].childNodes[1 |
| | ].childNodes[0].childNodes[0 |
| | ].nodeValue == 'x' |
| | assert mml_1.childNodes[0].childNodes[1 |
| | ].childNodes[1].childNodes[0 |
| | ].nodeValue == '→' |
| | assert mml_1.childNodes[0].childNodes[1 |
| | ].childNodes[2].childNodes[0 |
| | ].nodeValue == '0' |
| |
|
| |
|
| | def test_presentation_mathml_integrals(): |
| | assert mpp.doprint(Integral(x, (x, 0, 1))) == \ |
| | '<mrow><msubsup><mo>∫</mo><mn>0</mn><mn>1</mn></msubsup>'\ |
| | '<mi>x</mi><mo>ⅆ</mo><mi>x</mi></mrow>' |
| | assert mpp.doprint(Integral(log(x), x)) == \ |
| | '<mrow><mo>∫</mo><mrow><mi>log</mi><mrow><mo>(</mo><mi>x</mi>' \ |
| | '<mo>)</mo></mrow></mrow><mo>ⅆ</mo><mi>x</mi></mrow>' |
| | assert mpp.doprint(Integral(x*y, x, y)) == \ |
| | '<mrow><mo>∬</mo><mrow><mi>x</mi><mo>⁢</mo>'\ |
| | '<mi>y</mi></mrow><mo>ⅆ</mo><mi>y</mi><mo>ⅆ</mo><mi>x</mi></mrow>' |
| | z, w = symbols('z w') |
| | assert mpp.doprint(Integral(x*y*z, x, y, z)) == \ |
| | '<mrow><mo>∭</mo><mrow><mi>x</mi><mo>⁢</mo>'\ |
| | '<mi>y</mi><mo>⁢</mo><mi>z</mi></mrow><mo>ⅆ</mo>'\ |
| | '<mi>z</mi><mo>ⅆ</mo><mi>y</mi><mo>ⅆ</mo><mi>x</mi></mrow>' |
| | assert mpp.doprint(Integral(x*y*z*w, x, y, z, w)) == \ |
| | '<mrow><mo>∫</mo><mo>∫</mo><mo>∫</mo>'\ |
| | '<mo>∫</mo><mrow><mi>w</mi><mo>⁢</mo>'\ |
| | '<mi>x</mi><mo>⁢</mo><mi>y</mi>'\ |
| | '<mo>⁢</mo><mi>z</mi></mrow><mo>ⅆ</mo><mi>w</mi>'\ |
| | '<mo>ⅆ</mo><mi>z</mi><mo>ⅆ</mo><mi>y</mi><mo>ⅆ</mo><mi>x</mi></mrow>' |
| | assert mpp.doprint(Integral(x, x, y, (z, 0, 1))) == \ |
| | '<mrow><msubsup><mo>∫</mo><mn>0</mn><mn>1</mn></msubsup>'\ |
| | '<mo>∫</mo><mo>∫</mo><mi>x</mi><mo>ⅆ</mo><mi>z</mi>'\ |
| | '<mo>ⅆ</mo><mi>y</mi><mo>ⅆ</mo><mi>x</mi></mrow>' |
| | assert mpp.doprint(Integral(x, (x, 0))) == \ |
| | '<mrow><msup><mo>∫</mo><mn>0</mn></msup><mi>x</mi><mo>ⅆ</mo>'\ |
| | '<mi>x</mi></mrow>' |
| |
|
| |
|
| | def test_presentation_mathml_matrices(): |
| | A = Matrix([1, 2, 3]) |
| | B = Matrix([[0, 5, 4], [2, 3, 1], [9, 7, 9]]) |
| | mll_1 = mpp._print(A) |
| | assert mll_1.childNodes[1].nodeName == 'mtable' |
| | assert mll_1.childNodes[1].childNodes[0].nodeName == 'mtr' |
| | assert len(mll_1.childNodes[1].childNodes) == 3 |
| | assert mll_1.childNodes[1].childNodes[0].childNodes[0].nodeName == 'mtd' |
| | assert len(mll_1.childNodes[1].childNodes[0].childNodes) == 1 |
| | assert mll_1.childNodes[1].childNodes[0].childNodes[0 |
| | ].childNodes[0].childNodes[0].nodeValue == '1' |
| | assert mll_1.childNodes[1].childNodes[1].childNodes[0 |
| | ].childNodes[0].childNodes[0].nodeValue == '2' |
| | assert mll_1.childNodes[1].childNodes[2].childNodes[0 |
| | ].childNodes[0].childNodes[0].nodeValue == '3' |
| | mll_2 = mpp._print(B) |
| | assert mll_2.childNodes[1].nodeName == 'mtable' |
| | assert mll_2.childNodes[1].childNodes[0].nodeName == 'mtr' |
| | assert len(mll_2.childNodes[1].childNodes) == 3 |
| | assert mll_2.childNodes[1].childNodes[0].childNodes[0].nodeName == 'mtd' |
| | assert len(mll_2.childNodes[1].childNodes[0].childNodes) == 3 |
| | assert mll_2.childNodes[1].childNodes[0].childNodes[0 |
| | ].childNodes[0].childNodes[0].nodeValue == '0' |
| | assert mll_2.childNodes[1].childNodes[0].childNodes[1 |
| | ].childNodes[0].childNodes[0].nodeValue == '5' |
| | assert mll_2.childNodes[1].childNodes[0].childNodes[2 |
| | ].childNodes[0].childNodes[0].nodeValue == '4' |
| | assert mll_2.childNodes[1].childNodes[1].childNodes[0 |
| | ].childNodes[0].childNodes[0].nodeValue == '2' |
| | assert mll_2.childNodes[1].childNodes[1].childNodes[1 |
| | ].childNodes[0].childNodes[0].nodeValue == '3' |
| | assert mll_2.childNodes[1].childNodes[1].childNodes[2 |
| | ].childNodes[0].childNodes[0].nodeValue == '1' |
| | assert mll_2.childNodes[1].childNodes[2].childNodes[0 |
| | ].childNodes[0].childNodes[0].nodeValue == '9' |
| | assert mll_2.childNodes[1].childNodes[2].childNodes[1 |
| | ].childNodes[0].childNodes[0].nodeValue == '7' |
| | assert mll_2.childNodes[1].childNodes[2].childNodes[2 |
| | ].childNodes[0].childNodes[0].nodeValue == '9' |
| |
|
| |
|
| | def test_presentation_mathml_sums(): |
| | mml_1 = mpp._print(Sum(x, (x, 1, 10))) |
| | assert mml_1.childNodes[0].nodeName == 'munderover' |
| | assert len(mml_1.childNodes[0].childNodes) == 3 |
| | assert mml_1.childNodes[0].childNodes[0].childNodes[0 |
| | ].nodeValue == '∑' |
| | assert len(mml_1.childNodes[0].childNodes[1].childNodes) == 3 |
| | assert mml_1.childNodes[0].childNodes[2].childNodes[0 |
| | ].nodeValue == '10' |
| | assert mml_1.childNodes[1].childNodes[0].nodeValue == 'x' |
| |
|
| | assert mpp.doprint(Sum(x, (x, 1, 10))) == \ |
| | '<mrow><munderover><mo>∑</mo><mrow><mi>x</mi><mo>=</mo><mn>1</mn></mrow><mn>10</mn></munderover><mi>x</mi></mrow>' |
| | assert mpp.doprint(Sum(x + y, (x, 1, 10))) == \ |
| | '<mrow><munderover><mo>∑</mo><mrow><mi>x</mi><mo>=</mo><mn>1</mn></mrow><mn>10</mn></munderover><mrow><mo>(</mo><mrow><mi>x</mi><mo>+</mo><mi>y</mi></mrow><mo>)</mo></mrow></mrow>' |
| |
|
| |
|
| | def test_presentation_mathml_add(): |
| | mml = mpp._print(x**5 - x**4 + x) |
| | assert len(mml.childNodes) == 5 |
| | assert mml.childNodes[0].childNodes[0].childNodes[0 |
| | ].nodeValue == 'x' |
| | assert mml.childNodes[0].childNodes[1].childNodes[0 |
| | ].nodeValue == '5' |
| | assert mml.childNodes[1].childNodes[0].nodeValue == '-' |
| | assert mml.childNodes[2].childNodes[0].childNodes[0 |
| | ].nodeValue == 'x' |
| | assert mml.childNodes[2].childNodes[1].childNodes[0 |
| | ].nodeValue == '4' |
| | assert mml.childNodes[3].childNodes[0].nodeValue == '+' |
| | assert mml.childNodes[4].childNodes[0].nodeValue == 'x' |
| |
|
| |
|
| | def test_presentation_mathml_Rational(): |
| | mml_1 = mpp._print(Rational(1, 1)) |
| | assert mml_1.nodeName == 'mn' |
| |
|
| | mml_2 = mpp._print(Rational(2, 5)) |
| | assert mml_2.nodeName == 'mfrac' |
| | assert mml_2.childNodes[0].childNodes[0].nodeValue == '2' |
| | assert mml_2.childNodes[1].childNodes[0].nodeValue == '5' |
| |
|
| |
|
| | def test_presentation_mathml_constants(): |
| | mml = mpp._print(I) |
| | assert mml.childNodes[0].nodeValue == 'ⅈ' |
| |
|
| | mml = mpp._print(E) |
| | assert mml.childNodes[0].nodeValue == 'ⅇ' |
| |
|
| | mml = mpp._print(oo) |
| | assert mml.childNodes[0].nodeValue == '∞' |
| |
|
| | mml = mpp._print(pi) |
| | assert mml.childNodes[0].nodeValue == 'π' |
| |
|
| | assert mathml(hbar, printer='presentation') == '<mi>ℏ</mi>' |
| | assert mathml(S.TribonacciConstant, printer='presentation' |
| | ) == '<mi>TribonacciConstant</mi>' |
| | assert mathml(S.EulerGamma, printer='presentation' |
| | ) == '<mi>γ</mi>' |
| | assert mathml(S.GoldenRatio, printer='presentation' |
| | ) == '<mi>Φ</mi>' |
| |
|
| | assert mathml(zoo, printer='presentation') == \ |
| | '<mover><mo>∞</mo><mo>~</mo></mover>' |
| |
|
| | assert mathml(S.NaN, printer='presentation') == '<mi>NaN</mi>' |
| |
|
| | def test_presentation_mathml_trig(): |
| | mml = mpp._print(sin(x)) |
| | assert mml.childNodes[0].childNodes[0].nodeValue == 'sin' |
| |
|
| | mml = mpp._print(cos(x)) |
| | assert mml.childNodes[0].childNodes[0].nodeValue == 'cos' |
| |
|
| | mml = mpp._print(tan(x)) |
| | assert mml.childNodes[0].childNodes[0].nodeValue == 'tan' |
| |
|
| | mml = mpp._print(asin(x)) |
| | assert mml.childNodes[0].childNodes[0].nodeValue == 'arcsin' |
| |
|
| | mml = mpp._print(acos(x)) |
| | assert mml.childNodes[0].childNodes[0].nodeValue == 'arccos' |
| |
|
| | mml = mpp._print(atan(x)) |
| | assert mml.childNodes[0].childNodes[0].nodeValue == 'arctan' |
| |
|
| | mml = mpp._print(sinh(x)) |
| | assert mml.childNodes[0].childNodes[0].nodeValue == 'sinh' |
| |
|
| | mml = mpp._print(cosh(x)) |
| | assert mml.childNodes[0].childNodes[0].nodeValue == 'cosh' |
| |
|
| | mml = mpp._print(tanh(x)) |
| | assert mml.childNodes[0].childNodes[0].nodeValue == 'tanh' |
| |
|
| | mml = mpp._print(asinh(x)) |
| | assert mml.childNodes[0].childNodes[0].nodeValue == 'arcsinh' |
| |
|
| | mml = mpp._print(atanh(x)) |
| | assert mml.childNodes[0].childNodes[0].nodeValue == 'arctanh' |
| |
|
| | mml = mpp._print(acosh(x)) |
| | assert mml.childNodes[0].childNodes[0].nodeValue == 'arccosh' |
| |
|
| |
|
| | def test_presentation_mathml_relational(): |
| | mml_1 = mpp._print(Eq(x, 1)) |
| | assert len(mml_1.childNodes) == 3 |
| | assert mml_1.childNodes[0].nodeName == 'mi' |
| | assert mml_1.childNodes[0].childNodes[0].nodeValue == 'x' |
| | assert mml_1.childNodes[1].nodeName == 'mo' |
| | assert mml_1.childNodes[1].childNodes[0].nodeValue == '=' |
| | assert mml_1.childNodes[2].nodeName == 'mn' |
| | assert mml_1.childNodes[2].childNodes[0].nodeValue == '1' |
| |
|
| | mml_2 = mpp._print(Ne(1, x)) |
| | assert len(mml_2.childNodes) == 3 |
| | assert mml_2.childNodes[0].nodeName == 'mn' |
| | assert mml_2.childNodes[0].childNodes[0].nodeValue == '1' |
| | assert mml_2.childNodes[1].nodeName == 'mo' |
| | assert mml_2.childNodes[1].childNodes[0].nodeValue == '≠' |
| | assert mml_2.childNodes[2].nodeName == 'mi' |
| | assert mml_2.childNodes[2].childNodes[0].nodeValue == 'x' |
| |
|
| | mml_3 = mpp._print(Ge(1, x)) |
| | assert len(mml_3.childNodes) == 3 |
| | assert mml_3.childNodes[0].nodeName == 'mn' |
| | assert mml_3.childNodes[0].childNodes[0].nodeValue == '1' |
| | assert mml_3.childNodes[1].nodeName == 'mo' |
| | assert mml_3.childNodes[1].childNodes[0].nodeValue == '≥' |
| | assert mml_3.childNodes[2].nodeName == 'mi' |
| | assert mml_3.childNodes[2].childNodes[0].nodeValue == 'x' |
| |
|
| | mml_4 = mpp._print(Lt(1, x)) |
| | assert len(mml_4.childNodes) == 3 |
| | assert mml_4.childNodes[0].nodeName == 'mn' |
| | assert mml_4.childNodes[0].childNodes[0].nodeValue == '1' |
| | assert mml_4.childNodes[1].nodeName == 'mo' |
| | assert mml_4.childNodes[1].childNodes[0].nodeValue == '<' |
| | assert mml_4.childNodes[2].nodeName == 'mi' |
| | assert mml_4.childNodes[2].childNodes[0].nodeValue == 'x' |
| |
|
| |
|
| | def test_presentation_symbol(): |
| | mml = mpp._print(x) |
| | assert mml.nodeName == 'mi' |
| | assert mml.childNodes[0].nodeValue == 'x' |
| | del mml |
| |
|
| | mml = mpp._print(Symbol("x^2")) |
| | assert mml.nodeName == 'msup' |
| | assert mml.childNodes[0].nodeName == 'mi' |
| | assert mml.childNodes[0].childNodes[0].nodeValue == 'x' |
| | assert mml.childNodes[1].nodeName == 'mi' |
| | assert mml.childNodes[1].childNodes[0].nodeValue == '2' |
| | del mml |
| |
|
| | mml = mpp._print(Symbol("x__2")) |
| | assert mml.nodeName == 'msup' |
| | assert mml.childNodes[0].nodeName == 'mi' |
| | assert mml.childNodes[0].childNodes[0].nodeValue == 'x' |
| | assert mml.childNodes[1].nodeName == 'mi' |
| | assert mml.childNodes[1].childNodes[0].nodeValue == '2' |
| | del mml |
| |
|
| | mml = mpp._print(Symbol("x_2")) |
| | assert mml.nodeName == 'msub' |
| | assert mml.childNodes[0].nodeName == 'mi' |
| | assert mml.childNodes[0].childNodes[0].nodeValue == 'x' |
| | assert mml.childNodes[1].nodeName == 'mi' |
| | assert mml.childNodes[1].childNodes[0].nodeValue == '2' |
| | del mml |
| |
|
| | mml = mpp._print(Symbol("x^3_2")) |
| | assert mml.nodeName == 'msubsup' |
| | assert mml.childNodes[0].nodeName == 'mi' |
| | assert mml.childNodes[0].childNodes[0].nodeValue == 'x' |
| | assert mml.childNodes[1].nodeName == 'mi' |
| | assert mml.childNodes[1].childNodes[0].nodeValue == '2' |
| | assert mml.childNodes[2].nodeName == 'mi' |
| | assert mml.childNodes[2].childNodes[0].nodeValue == '3' |
| | del mml |
| |
|
| | mml = mpp._print(Symbol("x__3_2")) |
| | assert mml.nodeName == 'msubsup' |
| | assert mml.childNodes[0].nodeName == 'mi' |
| | assert mml.childNodes[0].childNodes[0].nodeValue == 'x' |
| | assert mml.childNodes[1].nodeName == 'mi' |
| | assert mml.childNodes[1].childNodes[0].nodeValue == '2' |
| | assert mml.childNodes[2].nodeName == 'mi' |
| | assert mml.childNodes[2].childNodes[0].nodeValue == '3' |
| | del mml |
| |
|
| | mml = mpp._print(Symbol("x_2_a")) |
| | assert mml.nodeName == 'msub' |
| | assert mml.childNodes[0].nodeName == 'mi' |
| | assert mml.childNodes[0].childNodes[0].nodeValue == 'x' |
| | assert mml.childNodes[1].nodeName == 'mrow' |
| | assert mml.childNodes[1].childNodes[0].nodeName == 'mi' |
| | assert mml.childNodes[1].childNodes[0].childNodes[0].nodeValue == '2' |
| | assert mml.childNodes[1].childNodes[1].nodeName == 'mo' |
| | assert mml.childNodes[1].childNodes[1].childNodes[0].nodeValue == ' ' |
| | assert mml.childNodes[1].childNodes[2].nodeName == 'mi' |
| | assert mml.childNodes[1].childNodes[2].childNodes[0].nodeValue == 'a' |
| | del mml |
| |
|
| | mml = mpp._print(Symbol("x^2^a")) |
| | assert mml.nodeName == 'msup' |
| | assert mml.childNodes[0].nodeName == 'mi' |
| | assert mml.childNodes[0].childNodes[0].nodeValue == 'x' |
| | assert mml.childNodes[1].nodeName == 'mrow' |
| | assert mml.childNodes[1].childNodes[0].nodeName == 'mi' |
| | assert mml.childNodes[1].childNodes[0].childNodes[0].nodeValue == '2' |
| | assert mml.childNodes[1].childNodes[1].nodeName == 'mo' |
| | assert mml.childNodes[1].childNodes[1].childNodes[0].nodeValue == ' ' |
| | assert mml.childNodes[1].childNodes[2].nodeName == 'mi' |
| | assert mml.childNodes[1].childNodes[2].childNodes[0].nodeValue == 'a' |
| | del mml |
| |
|
| | mml = mpp._print(Symbol("x__2__a")) |
| | assert mml.nodeName == 'msup' |
| | assert mml.childNodes[0].nodeName == 'mi' |
| | assert mml.childNodes[0].childNodes[0].nodeValue == 'x' |
| | assert mml.childNodes[1].nodeName == 'mrow' |
| | assert mml.childNodes[1].childNodes[0].nodeName == 'mi' |
| | assert mml.childNodes[1].childNodes[0].childNodes[0].nodeValue == '2' |
| | assert mml.childNodes[1].childNodes[1].nodeName == 'mo' |
| | assert mml.childNodes[1].childNodes[1].childNodes[0].nodeValue == ' ' |
| | assert mml.childNodes[1].childNodes[2].nodeName == 'mi' |
| | assert mml.childNodes[1].childNodes[2].childNodes[0].nodeValue == 'a' |
| | del mml |
| |
|
| |
|
| | def test_presentation_mathml_greek(): |
| | mml = mpp._print(Symbol('alpha')) |
| | assert mml.nodeName == 'mi' |
| | assert mml.childNodes[0].nodeValue == '\N{GREEK SMALL LETTER ALPHA}' |
| |
|
| | assert mpp.doprint(Symbol('alpha')) == '<mi>α</mi>' |
| | assert mpp.doprint(Symbol('beta')) == '<mi>β</mi>' |
| | assert mpp.doprint(Symbol('gamma')) == '<mi>γ</mi>' |
| | assert mpp.doprint(Symbol('delta')) == '<mi>δ</mi>' |
| | assert mpp.doprint(Symbol('epsilon')) == '<mi>ε</mi>' |
| | assert mpp.doprint(Symbol('zeta')) == '<mi>ζ</mi>' |
| | assert mpp.doprint(Symbol('eta')) == '<mi>η</mi>' |
| | assert mpp.doprint(Symbol('theta')) == '<mi>θ</mi>' |
| | assert mpp.doprint(Symbol('iota')) == '<mi>ι</mi>' |
| | assert mpp.doprint(Symbol('kappa')) == '<mi>κ</mi>' |
| | assert mpp.doprint(Symbol('lambda')) == '<mi>λ</mi>' |
| | assert mpp.doprint(Symbol('mu')) == '<mi>μ</mi>' |
| | assert mpp.doprint(Symbol('nu')) == '<mi>ν</mi>' |
| | assert mpp.doprint(Symbol('xi')) == '<mi>ξ</mi>' |
| | assert mpp.doprint(Symbol('omicron')) == '<mi>ο</mi>' |
| | assert mpp.doprint(Symbol('pi')) == '<mi>π</mi>' |
| | assert mpp.doprint(Symbol('rho')) == '<mi>ρ</mi>' |
| | assert mpp.doprint(Symbol('varsigma')) == '<mi>ς</mi>' |
| | assert mpp.doprint(Symbol('sigma')) == '<mi>σ</mi>' |
| | assert mpp.doprint(Symbol('tau')) == '<mi>τ</mi>' |
| | assert mpp.doprint(Symbol('upsilon')) == '<mi>υ</mi>' |
| | assert mpp.doprint(Symbol('phi')) == '<mi>φ</mi>' |
| | assert mpp.doprint(Symbol('chi')) == '<mi>χ</mi>' |
| | assert mpp.doprint(Symbol('psi')) == '<mi>ψ</mi>' |
| | assert mpp.doprint(Symbol('omega')) == '<mi>ω</mi>' |
| |
|
| | assert mpp.doprint(Symbol('Alpha')) == '<mi>Α</mi>' |
| | assert mpp.doprint(Symbol('Beta')) == '<mi>Β</mi>' |
| | assert mpp.doprint(Symbol('Gamma')) == '<mi>Γ</mi>' |
| | assert mpp.doprint(Symbol('Delta')) == '<mi>Δ</mi>' |
| | assert mpp.doprint(Symbol('Epsilon')) == '<mi>Ε</mi>' |
| | assert mpp.doprint(Symbol('Zeta')) == '<mi>Ζ</mi>' |
| | assert mpp.doprint(Symbol('Eta')) == '<mi>Η</mi>' |
| | assert mpp.doprint(Symbol('Theta')) == '<mi>Θ</mi>' |
| | assert mpp.doprint(Symbol('Iota')) == '<mi>Ι</mi>' |
| | assert mpp.doprint(Symbol('Kappa')) == '<mi>Κ</mi>' |
| | assert mpp.doprint(Symbol('Lambda')) == '<mi>Λ</mi>' |
| | assert mpp.doprint(Symbol('Mu')) == '<mi>Μ</mi>' |
| | assert mpp.doprint(Symbol('Nu')) == '<mi>Ν</mi>' |
| | assert mpp.doprint(Symbol('Xi')) == '<mi>Ξ</mi>' |
| | assert mpp.doprint(Symbol('Omicron')) == '<mi>Ο</mi>' |
| | assert mpp.doprint(Symbol('Pi')) == '<mi>Π</mi>' |
| | assert mpp.doprint(Symbol('Rho')) == '<mi>Ρ</mi>' |
| | assert mpp.doprint(Symbol('Sigma')) == '<mi>Σ</mi>' |
| | assert mpp.doprint(Symbol('Tau')) == '<mi>Τ</mi>' |
| | assert mpp.doprint(Symbol('Upsilon')) == '<mi>Υ</mi>' |
| | assert mpp.doprint(Symbol('Phi')) == '<mi>Φ</mi>' |
| | assert mpp.doprint(Symbol('Chi')) == '<mi>Χ</mi>' |
| | assert mpp.doprint(Symbol('Psi')) == '<mi>Ψ</mi>' |
| | assert mpp.doprint(Symbol('Omega')) == '<mi>Ω</mi>' |
| |
|
| |
|
| | def test_presentation_mathml_order(): |
| | expr = x**3 + x**2*y + 3*x*y**3 + y**4 |
| |
|
| | mp = MathMLPresentationPrinter({'order': 'lex'}) |
| | mml = mp._print(expr) |
| | assert mml.childNodes[0].nodeName == 'msup' |
| | assert mml.childNodes[0].childNodes[0].childNodes[0].nodeValue == 'x' |
| | assert mml.childNodes[0].childNodes[1].childNodes[0].nodeValue == '3' |
| |
|
| | assert mml.childNodes[6].nodeName == 'msup' |
| | assert mml.childNodes[6].childNodes[0].childNodes[0].nodeValue == 'y' |
| | assert mml.childNodes[6].childNodes[1].childNodes[0].nodeValue == '4' |
| |
|
| | mp = MathMLPresentationPrinter({'order': 'rev-lex'}) |
| | mml = mp._print(expr) |
| |
|
| | assert mml.childNodes[0].nodeName == 'msup' |
| | assert mml.childNodes[0].childNodes[0].childNodes[0].nodeValue == 'y' |
| | assert mml.childNodes[0].childNodes[1].childNodes[0].nodeValue == '4' |
| |
|
| | assert mml.childNodes[6].nodeName == 'msup' |
| | assert mml.childNodes[6].childNodes[0].childNodes[0].nodeValue == 'x' |
| | assert mml.childNodes[6].childNodes[1].childNodes[0].nodeValue == '3' |
| |
|
| |
|
| | def test_print_intervals(): |
| | a = Symbol('a', real=True) |
| | assert mpp.doprint(Interval(0, a)) == \ |
| | '<mrow><mo>[</mo><mn>0</mn><mo>,</mo><mi>a</mi><mo>]</mo></mrow>' |
| | assert mpp.doprint(Interval(0, a, False, False)) == \ |
| | '<mrow><mo>[</mo><mn>0</mn><mo>,</mo><mi>a</mi><mo>]</mo></mrow>' |
| | assert mpp.doprint(Interval(0, a, True, False)) == \ |
| | '<mrow><mo>(</mo><mn>0</mn><mo>,</mo><mi>a</mi><mo>]</mo></mrow>' |
| | assert mpp.doprint(Interval(0, a, False, True)) == \ |
| | '<mrow><mo>[</mo><mn>0</mn><mo>,</mo><mi>a</mi><mo>)</mo></mrow>' |
| | assert mpp.doprint(Interval(0, a, True, True)) == \ |
| | '<mrow><mo>(</mo><mn>0</mn><mo>,</mo><mi>a</mi><mo>)</mo></mrow>' |
| |
|
| |
|
| | def test_print_tuples(): |
| | assert mpp.doprint(Tuple(0,)) == \ |
| | '<mrow><mo>(</mo><mn>0</mn><mo>)</mo></mrow>' |
| | assert mpp.doprint(Tuple(0, a)) == \ |
| | '<mrow><mo>(</mo><mn>0</mn><mo>,</mo><mi>a</mi><mo>)</mo></mrow>' |
| | assert mpp.doprint(Tuple(0, a, a)) == \ |
| | '<mrow><mo>(</mo><mn>0</mn><mo>,</mo><mi>a</mi><mo>,</mo><mi>a</mi><mo>)</mo></mrow>' |
| | assert mpp.doprint(Tuple(0, 1, 2, 3, 4)) == \ |
| | '<mrow><mo>(</mo><mn>0</mn><mo>,</mo><mn>1</mn><mo>,</mo><mn>2</mn><mo>,</mo><mn>3</mn><mo>,</mo><mn>4</mn><mo>)</mo></mrow>' |
| | assert mpp.doprint(Tuple(0, 1, Tuple(2, 3, 4))) == \ |
| | '<mrow><mo>(</mo><mn>0</mn><mo>,</mo><mn>1</mn><mo>,</mo><mrow><mo>(</mo><mn>2</mn><mo>,</mo><mn>3'\ |
| | '</mn><mo>,</mo><mn>4</mn><mo>)</mo></mrow><mo>)</mo></mrow>' |
| |
|
| |
|
| | def test_print_re_im(): |
| | assert mpp.doprint(re(x)) == \ |
| | '<mrow><mi>ℜ</mi><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>' |
| | assert mpp.doprint(im(x)) == \ |
| | '<mrow><mi>ℑ</mi><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>' |
| | assert mpp.doprint(re(x + 1, evaluate=False)) == \ |
| | '<mrow><mi>ℜ</mi><mrow><mo>(</mo><mrow><mi>x</mi><mo>+</mo><mn>1</mn></mrow><mo>)</mo></mrow></mrow>' |
| | assert mpp.doprint(im(x + 1, evaluate=False)) == \ |
| | '<mrow><mi>ℑ</mi><mrow><mo>(</mo><mrow><mi>x</mi><mo>+</mo><mn>1</mn></mrow><mo>)</mo></mrow></mrow>' |
| |
|
| |
|
| | def test_print_Abs(): |
| | assert mpp.doprint(Abs(x)) == \ |
| | '<mrow><mo>|</mo><mi>x</mi><mo>|</mo></mrow>' |
| | assert mpp.doprint(Abs(x + 1)) == \ |
| | '<mrow><mo>|</mo><mrow><mi>x</mi><mo>+</mo><mn>1</mn></mrow><mo>|</mo></mrow>' |
| |
|
| |
|
| | def test_print_Determinant(): |
| | assert mpp.doprint(Determinant(Matrix([[1, 2], [3, 4]]))) == \ |
| | '<mrow><mo>|</mo><mrow><mo>[</mo><mtable><mtr><mtd><mn>1</mn></mtd><mtd><mn>2</mn></mtd></mtr><mtr><mtd><mn>3</mn></mtd><mtd><mn>4</mn></mtd></mtr></mtable><mo>]</mo></mrow><mo>|</mo></mrow>' |
| |
|
| |
|
| | def test_presentation_settings(): |
| | raises(TypeError, lambda: mathml(x, printer='presentation', |
| | method="garbage")) |
| |
|
| |
|
| | def test_print_domains(): |
| | from sympy.sets import Integers, Naturals, Naturals0, Reals, Complexes |
| |
|
| | assert mpp.doprint(Complexes) == '<mi mathvariant="normal">ℂ</mi>' |
| | assert mpp.doprint(Integers) == '<mi mathvariant="normal">ℤ</mi>' |
| | assert mpp.doprint(Naturals) == '<mi mathvariant="normal">ℕ</mi>' |
| | assert mpp.doprint(Naturals0) == \ |
| | '<msub><mi mathvariant="normal">ℕ</mi><mn>0</mn></msub>' |
| | assert mpp.doprint(Reals) == '<mi mathvariant="normal">ℝ</mi>' |
| |
|
| |
|
| | def test_print_expression_with_minus(): |
| | assert mpp.doprint(-x) == '<mrow><mo>-</mo><mi>x</mi></mrow>' |
| | assert mpp.doprint(-x/y) == \ |
| | '<mrow><mo>-</mo><mfrac><mi>x</mi><mi>y</mi></mfrac></mrow>' |
| | assert mpp.doprint(-Rational(1, 2)) == \ |
| | '<mrow><mo>-</mo><mfrac><mn>1</mn><mn>2</mn></mfrac></mrow>' |
| |
|
| |
|
| | def test_print_AssocOp(): |
| | from sympy.core.operations import AssocOp |
| |
|
| | class TestAssocOp(AssocOp): |
| | identity = 0 |
| |
|
| | expr = TestAssocOp(1, 2) |
| | assert mpp.doprint(expr) == \ |
| | '<mrow><mi>testassocop</mi><mn>1</mn><mn>2</mn></mrow>' |
| |
|
| |
|
| | def test_print_basic(): |
| | expr = Basic(S(1), S(2)) |
| | assert mpp.doprint(expr) == \ |
| | '<mrow><mi>basic</mi><mrow><mo>(</mo><mn>1</mn><mo>,</mo><mn>2</mn><mo>)</mo></mrow></mrow>' |
| | assert mp.doprint(expr) == '<basic><cn>1</cn><cn>2</cn></basic>' |
| |
|
| |
|
| | def test_mat_delim_print(): |
| | expr = Matrix([[1, 2], [3, 4]]) |
| | assert mathml(expr, printer='presentation', mat_delim='[') == \ |
| | '<mrow><mo>[</mo><mtable><mtr><mtd><mn>1</mn></mtd><mtd>'\ |
| | '<mn>2</mn></mtd></mtr><mtr><mtd><mn>3</mn></mtd><mtd><mn>4</mn>'\ |
| | '</mtd></mtr></mtable><mo>]</mo></mrow>' |
| | assert mathml(expr, printer='presentation', mat_delim='(') == \ |
| | '<mrow><mo>(</mo><mtable><mtr><mtd><mn>1</mn></mtd><mtd><mn>2</mn></mtd>'\ |
| | '</mtr><mtr><mtd><mn>3</mn></mtd><mtd><mn>4</mn></mtd></mtr></mtable><mo>)</mo></mrow>' |
| | assert mathml(expr, printer='presentation', mat_delim='') == \ |
| | '<mtable><mtr><mtd><mn>1</mn></mtd><mtd><mn>2</mn></mtd></mtr><mtr>'\ |
| | '<mtd><mn>3</mn></mtd><mtd><mn>4</mn></mtd></mtr></mtable>' |
| |
|
| |
|
| | def test_ln_notation_print(): |
| | expr = log(x) |
| | assert mathml(expr, printer='presentation') == \ |
| | '<mrow><mi>log</mi><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>' |
| | assert mathml(expr, printer='presentation', ln_notation=False) == \ |
| | '<mrow><mi>log</mi><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>' |
| | assert mathml(expr, printer='presentation', ln_notation=True) == \ |
| | '<mrow><mi>ln</mi><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>' |
| |
|
| |
|
| | def test_mul_symbol_print(): |
| | expr = x * y |
| | assert mathml(expr, printer='presentation') == \ |
| | '<mrow><mi>x</mi><mo>⁢</mo><mi>y</mi></mrow>' |
| | assert mathml(expr, printer='presentation', mul_symbol=None) == \ |
| | '<mrow><mi>x</mi><mo>⁢</mo><mi>y</mi></mrow>' |
| | assert mathml(expr, printer='presentation', mul_symbol='dot') == \ |
| | '<mrow><mi>x</mi><mo>·</mo><mi>y</mi></mrow>' |
| | assert mathml(expr, printer='presentation', mul_symbol='ldot') == \ |
| | '<mrow><mi>x</mi><mo>․</mo><mi>y</mi></mrow>' |
| | assert mathml(expr, printer='presentation', mul_symbol='times') == \ |
| | '<mrow><mi>x</mi><mo>×</mo><mi>y</mi></mrow>' |
| |
|
| |
|
| | def test_print_lerchphi(): |
| | assert mpp.doprint(lerchphi(1, 2, 3)) == \ |
| | '<mrow><mi>Φ</mi><mrow><mo>(</mo><mn>1</mn><mo>,</mo><mn>2</mn><mo>,</mo><mn>3</mn><mo>)</mo></mrow></mrow>' |
| |
|
| |
|
| | def test_print_polylog(): |
| | assert mp.doprint(polylog(x, y)) == \ |
| | '<apply><polylog/><ci>x</ci><ci>y</ci></apply>' |
| | assert mpp.doprint(polylog(x, y)) == \ |
| | '<mrow><msub><mi>Li</mi><mi>x</mi></msub><mrow><mo>(</mo><mi>y</mi><mo>)</mo></mrow></mrow>' |
| |
|
| |
|
| | def test_print_set_frozenset(): |
| | f = frozenset({1, 5, 3}) |
| | assert mpp.doprint(f) == \ |
| | '<mrow><mo>{</mo><mn>1</mn><mo>,</mo><mn>3</mn><mo>,</mo><mn>5</mn><mo>}</mo></mrow>' |
| | s = set({1, 2, 3}) |
| | assert mpp.doprint(s) == \ |
| | '<mrow><mo>{</mo><mn>1</mn><mo>,</mo><mn>2</mn><mo>,</mo><mn>3</mn><mo>}</mo></mrow>' |
| |
|
| |
|
| | def test_print_FiniteSet(): |
| | f1 = FiniteSet(x, 1, 3) |
| | assert mpp.doprint(f1) == \ |
| | '<mrow><mo>{</mo><mn>1</mn><mo>,</mo><mn>3</mn><mo>,</mo><mi>x</mi><mo>}</mo></mrow>' |
| |
|
| |
|
| | def test_print_LambertW(): |
| | assert mpp.doprint(LambertW(x)) == '<mrow><mi>W</mi><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>' |
| | assert mpp.doprint(LambertW(x, y)) == '<mrow><mi>W</mi><mrow><mo>(</mo><mi>x</mi><mo>,</mo><mi>y</mi><mo>)</mo></mrow></mrow>' |
| |
|
| |
|
| | def test_print_EmptySet(): |
| | assert mpp.doprint(S.EmptySet) == '<mo>∅</mo>' |
| |
|
| |
|
| | def test_print_UniversalSet(): |
| | assert mpp.doprint(S.UniversalSet) == '<mo>𝕌</mo>' |
| |
|
| |
|
| | def test_print_spaces(): |
| | assert mpp.doprint(HilbertSpace()) == '<mi>ℋ</mi>' |
| | assert mpp.doprint(ComplexSpace(2)) == '<msup>𝒞<mn>2</mn></msup>' |
| | assert mpp.doprint(FockSpace()) == '<mi>ℱ</mi>' |
| |
|
| |
|
| | def test_print_constants(): |
| | assert mpp.doprint(hbar) == '<mi>ℏ</mi>' |
| | assert mpp.doprint(S.TribonacciConstant) == '<mi>TribonacciConstant</mi>' |
| | assert mpp.doprint(S.GoldenRatio) == '<mi>Φ</mi>' |
| | assert mpp.doprint(S.EulerGamma) == '<mi>γ</mi>' |
| |
|
| |
|
| | def test_print_Contains(): |
| | assert mpp.doprint(Contains(x, S.Naturals)) == \ |
| | '<mrow><mi>x</mi><mo>∈</mo><mi mathvariant="normal">ℕ</mi></mrow>' |
| |
|
| |
|
| | def test_print_Dagger(): |
| | x = symbols('x', commutative=False) |
| | assert mpp.doprint(Dagger(x)) == '<msup><mi>x</mi>†</msup>' |
| |
|
| |
|
| | def test_print_SetOp(): |
| | f1 = FiniteSet(x, 1, 3) |
| | f2 = FiniteSet(y, 2, 4) |
| |
|
| | prntr = lambda x: mathml(x, printer='presentation') |
| |
|
| | assert prntr(Union(f1, f2, evaluate=False)) == \ |
| | '<mrow><mrow><mo>{</mo><mn>1</mn><mo>,</mo><mn>3</mn><mo>,</mo><mi>x</mi>'\ |
| | '<mo>}</mo></mrow><mo>∪</mo><mrow><mo>{</mo><mn>2</mn><mo>,</mo>'\ |
| | '<mn>4</mn><mo>,</mo><mi>y</mi><mo>}</mo></mrow></mrow>' |
| | assert prntr(Intersection(f1, f2, evaluate=False)) == \ |
| | '<mrow><mrow><mo>{</mo><mn>1</mn><mo>,</mo><mn>3</mn><mo>,</mo><mi>x</mi>'\ |
| | '<mo>}</mo></mrow><mo>∩</mo><mrow><mo>{</mo><mn>2</mn>'\ |
| | '<mo>,</mo><mn>4</mn><mo>,</mo><mi>y</mi><mo>}</mo></mrow></mrow>' |
| | assert prntr(Complement(f1, f2, evaluate=False)) == \ |
| | '<mrow><mrow><mo>{</mo><mn>1</mn><mo>,</mo><mn>3</mn><mo>,</mo><mi>x</mi>'\ |
| | '<mo>}</mo></mrow><mo>∖</mo><mrow><mo>{</mo><mn>2</mn>'\ |
| | '<mo>,</mo><mn>4</mn><mo>,</mo><mi>y</mi><mo>}</mo></mrow></mrow>' |
| | assert prntr(SymmetricDifference(f1, f2, evaluate=False)) == \ |
| | '<mrow><mrow><mo>{</mo><mn>1</mn><mo>,</mo><mn>3</mn><mo>,</mo><mi>x</mi>'\ |
| | '<mo>}</mo></mrow><mo>∆</mo><mrow><mo>{</mo><mn>2</mn>'\ |
| | '<mo>,</mo><mn>4</mn><mo>,</mo><mi>y</mi><mo>}</mo></mrow></mrow>' |
| |
|
| | A = FiniteSet(a) |
| | C = FiniteSet(c) |
| | D = FiniteSet(d) |
| |
|
| | U1 = Union(C, D, evaluate=False) |
| | I1 = Intersection(C, D, evaluate=False) |
| | C1 = Complement(C, D, evaluate=False) |
| | D1 = SymmetricDifference(C, D, evaluate=False) |
| | |
| | P1 = ProductSet(C, D) |
| |
|
| | assert prntr(Union(A, I1, evaluate=False)) == \ |
| | '<mrow><mrow><mo>{</mo><mi>a</mi><mo>}</mo></mrow>' \ |
| | '<mo>∪</mo><mrow><mo>(</mo><mrow><mrow><mo>{</mo>' \ |
| | '<mi>c</mi><mo>}</mo></mrow><mo>∩</mo><mrow><mo>{</mo>' \ |
| | '<mi>d</mi><mo>}</mo></mrow></mrow><mo>)</mo></mrow></mrow>' |
| | assert prntr(Intersection(A, C1, evaluate=False)) == \ |
| | '<mrow><mrow><mo>{</mo><mi>a</mi><mo>}</mo></mrow>' \ |
| | '<mo>∩</mo><mrow><mo>(</mo><mrow><mrow><mo>{</mo>' \ |
| | '<mi>c</mi><mo>}</mo></mrow><mo>∖</mo><mrow><mo>{</mo>' \ |
| | '<mi>d</mi><mo>}</mo></mrow></mrow><mo>)</mo></mrow></mrow>' |
| | assert prntr(Complement(A, D1, evaluate=False)) == \ |
| | '<mrow><mrow><mo>{</mo><mi>a</mi><mo>}</mo></mrow>' \ |
| | '<mo>∖</mo><mrow><mo>(</mo><mrow><mrow><mo>{</mo>' \ |
| | '<mi>c</mi><mo>}</mo></mrow><mo>∆</mo><mrow><mo>{</mo>' \ |
| | '<mi>d</mi><mo>}</mo></mrow></mrow><mo>)</mo></mrow></mrow>' |
| | assert prntr(SymmetricDifference(A, P1, evaluate=False)) == \ |
| | '<mrow><mrow><mo>{</mo><mi>a</mi><mo>}</mo></mrow>' \ |
| | '<mo>∆</mo><mrow><mo>(</mo><mrow><mrow><mo>{</mo>' \ |
| | '<mi>c</mi><mo>}</mo></mrow><mo>×</mo><mrow><mo>{</mo>' \ |
| | '<mi>d</mi><mo>}</mo></mrow></mrow><mo>)</mo></mrow></mrow>' |
| | assert prntr(ProductSet(A, U1)) == \ |
| | '<mrow><mrow><mo>{</mo><mi>a</mi><mo>}</mo></mrow>' \ |
| | '<mo>×</mo><mrow><mo>(</mo><mrow><mrow><mo>{</mo>' \ |
| | '<mi>c</mi><mo>}</mo></mrow><mo>∪</mo><mrow><mo>{</mo>' \ |
| | '<mi>d</mi><mo>}</mo></mrow></mrow><mo>)</mo></mrow></mrow>' |
| |
|
| |
|
| | def test_print_logic(): |
| | assert mpp.doprint(And(x, y)) == \ |
| | '<mrow><mi>x</mi><mo>∧</mo><mi>y</mi></mrow>' |
| | assert mpp.doprint(Or(x, y)) == \ |
| | '<mrow><mi>x</mi><mo>∨</mo><mi>y</mi></mrow>' |
| | assert mpp.doprint(Xor(x, y)) == \ |
| | '<mrow><mi>x</mi><mo>⊻</mo><mi>y</mi></mrow>' |
| | assert mpp.doprint(Implies(x, y)) == \ |
| | '<mrow><mi>x</mi><mo>⇒</mo><mi>y</mi></mrow>' |
| | assert mpp.doprint(Equivalent(x, y)) == \ |
| | '<mrow><mi>x</mi><mo>⇔</mo><mi>y</mi></mrow>' |
| |
|
| | assert mpp.doprint(And(Eq(x, y), x > 4)) == \ |
| | '<mrow><mrow><mi>x</mi><mo>=</mo><mi>y</mi></mrow><mo>∧</mo>'\ |
| | '<mrow><mi>x</mi><mo>></mo><mn>4</mn></mrow></mrow>' |
| | assert mpp.doprint(And(Eq(x, 3), y < 3, x > y + 1)) == \ |
| | '<mrow><mrow><mi>x</mi><mo>=</mo><mn>3</mn></mrow><mo>∧</mo>'\ |
| | '<mrow><mi>x</mi><mo>></mo><mrow><mi>y</mi><mo>+</mo><mn>1</mn></mrow>'\ |
| | '</mrow><mo>∧</mo><mrow><mi>y</mi><mo><</mo><mn>3</mn></mrow></mrow>' |
| | assert mpp.doprint(Or(Eq(x, y), x > 4)) == \ |
| | '<mrow><mrow><mi>x</mi><mo>=</mo><mi>y</mi></mrow><mo>∨</mo>'\ |
| | '<mrow><mi>x</mi><mo>></mo><mn>4</mn></mrow></mrow>' |
| | assert mpp.doprint(And(Eq(x, 3), Or(y < 3, x > y + 1))) == \ |
| | '<mrow><mrow><mi>x</mi><mo>=</mo><mn>3</mn></mrow>'\ |
| | '<mo>∧</mo><mrow><mo>(</mo><mrow><mrow><mi>x</mi><mo>></mo><mrow>'\ |
| | '<mi>y</mi><mo>+</mo><mn>1</mn></mrow></mrow><mo>∨</mo><mrow>'\ |
| | '<mi>y</mi><mo><</mo><mn>3</mn></mrow></mrow><mo>)</mo></mrow></mrow>' |
| |
|
| | assert mpp.doprint(Not(x)) == '<mrow><mo>¬</mo><mi>x</mi></mrow>' |
| | assert mpp.doprint(Not(And(x, y))) == \ |
| | '<mrow><mo>¬</mo><mrow><mo>(</mo><mrow><mi>x</mi><mo>∧</mo><mi>y</mi></mrow><mo>)</mo></mrow></mrow>' |
| |
|
| |
|
| | def test_root_notation_print(): |
| | assert mathml(x**(S.One/3), printer='presentation') == \ |
| | '<mroot><mi>x</mi><mn>3</mn></mroot>' |
| | assert mathml(x**(S.One/3), printer='presentation', root_notation=False) ==\ |
| | '<msup><mi>x</mi><mfrac><mn>1</mn><mn>3</mn></mfrac></msup>' |
| | assert mathml(x**(S.One/3), printer='content') == \ |
| | '<apply><root/><degree><cn>3</cn></degree><ci>x</ci></apply>' |
| | assert mathml(x**(S.One/3), printer='content', root_notation=False) == \ |
| | '<apply><power/><ci>x</ci><apply><divide/><cn>1</cn><cn>3</cn></apply></apply>' |
| | assert mathml(x**(Rational(-1, 3)), printer='presentation') == \ |
| | '<mfrac><mn>1</mn><mroot><mi>x</mi><mn>3</mn></mroot></mfrac>' |
| | assert mathml(x**(Rational(-1, 3)), printer='presentation', root_notation=False) \ |
| | == '<mfrac><mn>1</mn><msup><mi>x</mi><mfrac><mn>1</mn><mn>3</mn></mfrac></msup></mfrac>' |
| |
|
| |
|
| | def test_fold_frac_powers_print(): |
| | expr = x ** Rational(5, 2) |
| | assert mathml(expr, printer='presentation') == \ |
| | '<msup><mi>x</mi><mfrac><mn>5</mn><mn>2</mn></mfrac></msup>' |
| | assert mathml(expr, printer='presentation', fold_frac_powers=True) == \ |
| | '<msup><mi>x</mi><mfrac bevelled="true"><mn>5</mn><mn>2</mn></mfrac></msup>' |
| | assert mathml(expr, printer='presentation', fold_frac_powers=False) == \ |
| | '<msup><mi>x</mi><mfrac><mn>5</mn><mn>2</mn></mfrac></msup>' |
| |
|
| |
|
| | def test_fold_short_frac_print(): |
| | expr = Rational(2, 5) |
| | assert mathml(expr, printer='presentation') == \ |
| | '<mfrac><mn>2</mn><mn>5</mn></mfrac>' |
| | assert mathml(expr, printer='presentation', fold_short_frac=True) == \ |
| | '<mfrac bevelled="true"><mn>2</mn><mn>5</mn></mfrac>' |
| | assert mathml(expr, printer='presentation', fold_short_frac=False) == \ |
| | '<mfrac><mn>2</mn><mn>5</mn></mfrac>' |
| |
|
| |
|
| | def test_print_factorials(): |
| | assert mpp.doprint(factorial(x)) == '<mrow><mi>x</mi><mo>!</mo></mrow>' |
| | assert mpp.doprint(factorial(x + 1)) == \ |
| | '<mrow><mrow><mo>(</mo><mrow><mi>x</mi><mo>+</mo><mn>1</mn></mrow><mo>)</mo></mrow><mo>!</mo></mrow>' |
| | assert mpp.doprint(factorial2(x)) == '<mrow><mi>x</mi><mo>!!</mo></mrow>' |
| | assert mpp.doprint(factorial2(x + 1)) == \ |
| | '<mrow><mrow><mo>(</mo><mrow><mi>x</mi><mo>+</mo><mn>1</mn></mrow><mo>)</mo></mrow><mo>!!</mo></mrow>' |
| | assert mpp.doprint(binomial(x, y)) == \ |
| | '<mrow><mo>(</mo><mfrac linethickness="0"><mi>x</mi><mi>y</mi></mfrac><mo>)</mo></mrow>' |
| | assert mpp.doprint(binomial(4, x + y)) == \ |
| | '<mrow><mo>(</mo><mfrac linethickness="0"><mn>4</mn><mrow><mi>x</mi>'\ |
| | '<mo>+</mo><mi>y</mi></mrow></mfrac><mo>)</mo></mrow>' |
| |
|
| |
|
| | def test_print_floor(): |
| | expr = floor(x) |
| | assert mathml(expr, printer='presentation') == \ |
| | '<mrow><mo>⌊</mo><mi>x</mi><mo>⌋</mo></mrow>' |
| |
|
| |
|
| | def test_print_ceiling(): |
| | expr = ceiling(x) |
| | assert mathml(expr, printer='presentation') == \ |
| | '<mrow><mo>⌈</mo><mi>x</mi><mo>⌉</mo></mrow>' |
| |
|
| |
|
| | def test_print_Lambda(): |
| | expr = Lambda(x, x+1) |
| | assert mathml(expr, printer='presentation') == \ |
| | '<mrow><mo>(</mo><mi>x</mi><mo>↦</mo><mrow><mi>x</mi><mo>+</mo><mn>1</mn></mrow><mo>)</mo></mrow>' |
| | expr = Lambda((x, y), x + y) |
| | assert mathml(expr, printer='presentation') == \ |
| | '<mrow><mo>(</mo><mrow><mo>(</mo><mi>x</mi><mo>,</mo><mi>y</mi><mo>)</mo></mrow><mo>↦</mo><mrow><mi>x</mi><mo>+</mo><mi>y</mi></mrow><mo>)</mo></mrow>' |
| |
|
| |
|
| | def test_print_conjugate(): |
| | assert mpp.doprint(conjugate(x)) == \ |
| | '<menclose notation="top"><mi>x</mi></menclose>' |
| | assert mpp.doprint(conjugate(x + 1)) == \ |
| | '<mrow><menclose notation="top"><mi>x</mi></menclose><mo>+</mo><mn>1</mn></mrow>' |
| |
|
| |
|
| | def test_print_AccumBounds(): |
| | a = Symbol('a', real=True) |
| | assert mpp.doprint(AccumBounds(0, 1)) == '<mrow><mo>⟨</mo><mn>0</mn><mo>,</mo><mn>1</mn><mo>⟩</mo></mrow>' |
| | assert mpp.doprint(AccumBounds(0, a)) == '<mrow><mo>⟨</mo><mn>0</mn><mo>,</mo><mi>a</mi><mo>⟩</mo></mrow>' |
| | assert mpp.doprint(AccumBounds(a + 1, a + 2)) == '<mrow><mo>⟨</mo><mrow><mi>a</mi><mo>+</mo><mn>1</mn></mrow><mo>,</mo><mrow><mi>a</mi><mo>+</mo><mn>2</mn></mrow><mo>⟩</mo></mrow>' |
| |
|
| |
|
| | def test_print_Float(): |
| | assert mpp.doprint(Float(1e100)) == '<mrow><mn>1.0</mn><mo>·</mo><msup><mn>10</mn><mn>100</mn></msup></mrow>' |
| | assert mpp.doprint(Float(1e-100)) == '<mrow><mn>1.0</mn><mo>·</mo><msup><mn>10</mn><mn>-100</mn></msup></mrow>' |
| | assert mpp.doprint(Float(-1e100)) == '<mrow><mn>-1.0</mn><mo>·</mo><msup><mn>10</mn><mn>100</mn></msup></mrow>' |
| | assert mpp.doprint(Float(1.0*oo)) == '<mi>∞</mi>' |
| | assert mpp.doprint(Float(-1.0*oo)) == '<mrow><mo>-</mo><mi>∞</mi></mrow>' |
| |
|
| |
|
| | def test_print_different_functions(): |
| | assert mpp.doprint(gamma(x)) == '<mrow><mi>Γ</mi><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>' |
| | assert mpp.doprint(lowergamma(x, y)) == '<mrow><mi>γ</mi><mrow><mo>(</mo><mi>x</mi><mo>,</mo><mi>y</mi><mo>)</mo></mrow></mrow>' |
| | assert mpp.doprint(uppergamma(x, y)) == '<mrow><mi>Γ</mi><mrow><mo>(</mo><mi>x</mi><mo>,</mo><mi>y</mi><mo>)</mo></mrow></mrow>' |
| | assert mpp.doprint(zeta(x)) == '<mrow><mi>ζ</mi><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>' |
| | assert mpp.doprint(zeta(x, y)) == '<mrow><mi>ζ</mi><mrow><mo>(</mo><mi>x</mi><mo>,</mo><mi>y</mi><mo>)</mo></mrow></mrow>' |
| | assert mpp.doprint(dirichlet_eta(x)) == '<mrow><mi>η</mi><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>' |
| | assert mpp.doprint(elliptic_k(x)) == '<mrow><mi>Κ</mi><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>' |
| | assert mpp.doprint(totient(x)) == '<mrow><mi>ϕ</mi><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>' |
| | assert mpp.doprint(reduced_totient(x)) == '<mrow><mi>λ</mi><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>' |
| | assert mpp.doprint(primenu(x)) == '<mrow><mi>ν</mi><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>' |
| | assert mpp.doprint(primeomega(x)) == '<mrow><mi>Ω</mi><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>' |
| | assert mpp.doprint(fresnels(x)) == '<mrow><mi>S</mi><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>' |
| | assert mpp.doprint(fresnelc(x)) == '<mrow><mi>C</mi><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>' |
| | assert mpp.doprint(Heaviside(x)) == '<mrow><mi>Θ</mi><mrow><mo>(</mo><mi>x</mi><mo>,</mo><mfrac><mn>1</mn><mn>2</mn></mfrac><mo>)</mo></mrow></mrow>' |
| |
|
| |
|
| | def test_mathml_builtins(): |
| | assert mpp.doprint(None) == '<mi>None</mi>' |
| | assert mpp.doprint(true) == '<mi>True</mi>' |
| | assert mpp.doprint(false) == '<mi>False</mi>' |
| |
|
| |
|
| | def test_mathml_Range(): |
| | assert mpp.doprint(Range(1, 51)) == \ |
| | '<mrow><mo>{</mo><mn>1</mn><mo>,</mo><mn>2</mn><mo>,</mo><mi>…</mi><mo>,</mo><mn>50</mn><mo>}</mo></mrow>' |
| | assert mpp.doprint(Range(1, 4)) == \ |
| | '<mrow><mo>{</mo><mn>1</mn><mo>,</mo><mn>2</mn><mo>,</mo><mn>3</mn><mo>}</mo></mrow>' |
| | assert mpp.doprint(Range(0, 3, 1)) == \ |
| | '<mrow><mo>{</mo><mn>0</mn><mo>,</mo><mn>1</mn><mo>,</mo><mn>2</mn><mo>}</mo></mrow>' |
| | assert mpp.doprint(Range(0, 30, 1)) == \ |
| | '<mrow><mo>{</mo><mn>0</mn><mo>,</mo><mn>1</mn><mo>,</mo><mi>…</mi><mo>,</mo><mn>29</mn><mo>}</mo></mrow>' |
| | assert mpp.doprint(Range(30, 1, -1)) == \ |
| | '<mrow><mo>{</mo><mn>30</mn><mo>,</mo><mn>29</mn><mo>,</mo><mi>…</mi><mo>,</mo><mn>2</mn><mo>}</mo></mrow>' |
| | assert mpp.doprint(Range(0, oo, 2)) == \ |
| | '<mrow><mo>{</mo><mn>0</mn><mo>,</mo><mn>2</mn><mo>,</mo><mi>…</mi><mo>}</mo></mrow>' |
| | assert mpp.doprint(Range(oo, -2, -2)) == \ |
| | '<mrow><mo>{</mo><mi>…</mi><mo>,</mo><mn>2</mn><mo>,</mo><mn>0</mn><mo>}</mo></mrow>' |
| | assert mpp.doprint(Range(-2, -oo, -1)) == \ |
| | '<mrow><mo>{</mo><mn>-2</mn><mo>,</mo><mn>-3</mn><mo>,</mo><mi>…</mi><mo>}</mo></mrow>' |
| |
|
| |
|
| | def test_print_exp(): |
| | assert mpp.doprint(exp(x)) == \ |
| | '<msup><mi>ⅇ</mi><mi>x</mi></msup>' |
| | assert mpp.doprint(exp(1) + exp(2)) == \ |
| | '<mrow><mi>ⅇ</mi><mo>+</mo><msup><mi>ⅇ</mi><mn>2</mn></msup></mrow>' |
| |
|
| |
|
| | def test_print_MinMax(): |
| | assert mpp.doprint(Min(x, y)) == \ |
| | '<mrow><mo>min</mo><mrow><mo>(</mo><mi>x</mi><mo>,</mo><mi>y</mi><mo>)</mo></mrow></mrow>' |
| | assert mpp.doprint(Min(x, 2, x**3)) == \ |
| | '<mrow><mo>min</mo><mrow><mo>(</mo><mn>2</mn><mo>,</mo><mi>x</mi><mo>,</mo><msup><mi>x</mi><mn>3</mn></msup><mo>)</mo></mrow></mrow>' |
| | assert mpp.doprint(Max(x, y)) == \ |
| | '<mrow><mo>max</mo><mrow><mo>(</mo><mi>x</mi><mo>,</mo><mi>y</mi><mo>)</mo></mrow></mrow>' |
| | assert mpp.doprint(Max(x, 2, x**3)) == \ |
| | '<mrow><mo>max</mo><mrow><mo>(</mo><mn>2</mn><mo>,</mo><mi>x</mi><mo>,</mo><msup><mi>x</mi><mn>3</mn></msup><mo>)</mo></mrow></mrow>' |
| |
|
| |
|
| | def test_mathml_presentation_numbers(): |
| | n = Symbol('n') |
| | assert mathml(catalan(n), printer='presentation') == \ |
| | '<msub><mi>C</mi><mi>n</mi></msub>' |
| | assert mathml(bernoulli(n), printer='presentation') == \ |
| | '<msub><mi>B</mi><mi>n</mi></msub>' |
| | assert mathml(bell(n), printer='presentation') == \ |
| | '<msub><mi>B</mi><mi>n</mi></msub>' |
| | assert mathml(euler(n), printer='presentation') == \ |
| | '<msub><mi>E</mi><mi>n</mi></msub>' |
| | assert mathml(fibonacci(n), printer='presentation') == \ |
| | '<msub><mi>F</mi><mi>n</mi></msub>' |
| | assert mathml(lucas(n), printer='presentation') == \ |
| | '<msub><mi>L</mi><mi>n</mi></msub>' |
| | assert mathml(tribonacci(n), printer='presentation') == \ |
| | '<msub><mi>T</mi><mi>n</mi></msub>' |
| | assert mathml(bernoulli(n, x), printer='presentation') == \ |
| | mathml(bell(n, x), printer='presentation') == \ |
| | '<mrow><msub><mi>B</mi><mi>n</mi></msub><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>' |
| | assert mathml(euler(n, x), printer='presentation') == \ |
| | '<mrow><msub><mi>E</mi><mi>n</mi></msub><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>' |
| | assert mathml(fibonacci(n, x), printer='presentation') == \ |
| | '<mrow><msub><mi>F</mi><mi>n</mi></msub><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>' |
| | assert mathml(tribonacci(n, x), printer='presentation') == \ |
| | '<mrow><msub><mi>T</mi><mi>n</mi></msub><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>' |
| |
|
| |
|
| | def test_mathml_presentation_mathieu(): |
| | assert mathml(mathieuc(x, y, z), printer='presentation') == \ |
| | '<mrow><mi>C</mi><mrow><mo>(</mo><mi>x</mi><mo>,</mo><mi>y</mi><mo>,</mo><mi>z</mi><mo>)</mo></mrow></mrow>' |
| | assert mathml(mathieus(x, y, z), printer='presentation') == \ |
| | '<mrow><mi>S</mi><mrow><mo>(</mo><mi>x</mi><mo>,</mo><mi>y</mi><mo>,</mo><mi>z</mi><mo>)</mo></mrow></mrow>' |
| | assert mathml(mathieucprime(x, y, z), printer='presentation') == \ |
| | '<mrow><mi>C′</mi><mrow><mo>(</mo><mi>x</mi><mo>,</mo><mi>y</mi><mo>,</mo><mi>z</mi><mo>)</mo></mrow></mrow>' |
| | assert mathml(mathieusprime(x, y, z), printer='presentation') == \ |
| | '<mrow><mi>S′</mi><mrow><mo>(</mo><mi>x</mi><mo>,</mo><mi>y</mi><mo>,</mo><mi>z</mi><mo>)</mo></mrow></mrow>' |
| |
|
| |
|
| | def test_mathml_presentation_stieltjes(): |
| | assert mathml(stieltjes(n), printer='presentation') == \ |
| | '<msub><mi>γ</mi><mi>n</mi></msub>' |
| | assert mathml(stieltjes(n, x), printer='presentation') == \ |
| | '<mrow><msub><mi>γ</mi><mi>n</mi></msub><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>' |
| |
|
| |
|
| | def test_print_matrix_symbol(): |
| | A = MatrixSymbol('A', 1, 2) |
| | assert mpp.doprint(A) == '<mi>A</mi>' |
| | assert mp.doprint(A) == '<ci>A</ci>' |
| | assert mathml(A, printer='presentation', mat_symbol_style="bold") == \ |
| | '<mi mathvariant="bold">A</mi>' |
| | |
| | assert mathml(A, mat_symbol_style="bold") == '<ci>A</ci>' |
| |
|
| |
|
| | def test_print_hadamard(): |
| | from sympy.matrices.expressions import HadamardProduct |
| | from sympy.matrices.expressions import Transpose |
| |
|
| | X = MatrixSymbol('X', 2, 2) |
| | Y = MatrixSymbol('Y', 2, 2) |
| |
|
| | assert mathml(HadamardProduct(X, Y*Y), printer="presentation") == \ |
| | '<mrow>' \ |
| | '<mi>X</mi>' \ |
| | '<mo>∘</mo>' \ |
| | '<msup><mi>Y</mi><mn>2</mn></msup>' \ |
| | '</mrow>' |
| |
|
| | assert mathml(HadamardProduct(X, Y)*Y, printer="presentation") == \ |
| | '<mrow>' \ |
| | '<mrow><mo>(</mo>' \ |
| | '<mrow><mi>X</mi><mo>∘</mo><mi>Y</mi></mrow>' \ |
| | '<mo>)</mo></mrow>' \ |
| | '<mo>⁢</mo><mi>Y</mi>' \ |
| | '</mrow>' |
| |
|
| | assert mathml(HadamardProduct(X, Y, Y), printer="presentation") == \ |
| | '<mrow>' \ |
| | '<mi>X</mi><mo>∘</mo>' \ |
| | '<mi>Y</mi><mo>∘</mo>' \ |
| | '<mi>Y</mi>' \ |
| | '</mrow>' |
| |
|
| | assert mathml( |
| | Transpose(HadamardProduct(X, Y)), printer="presentation") == \ |
| | '<msup>' \ |
| | '<mrow><mo>(</mo>' \ |
| | '<mrow><mi>X</mi><mo>∘</mo><mi>Y</mi></mrow>' \ |
| | '<mo>)</mo></mrow>' \ |
| | '<mo>T</mo>' \ |
| | '</msup>' |
| |
|
| |
|
| | def test_print_random_symbol(): |
| | R = RandomSymbol(Symbol('R')) |
| | assert mpp.doprint(R) == '<mi>R</mi>' |
| | assert mp.doprint(R) == '<ci>R</ci>' |
| |
|
| |
|
| | def test_print_IndexedBase(): |
| | assert mathml(IndexedBase(a)[b], printer='presentation') == \ |
| | '<msub><mi>a</mi><mi>b</mi></msub>' |
| | assert mathml(IndexedBase(a)[b, c, d], printer='presentation') == \ |
| | '<msub><mi>a</mi><mrow><mo>(</mo><mi>b</mi><mo>,</mo><mi>c</mi><mo>,</mo><mi>d</mi><mo>)</mo></mrow></msub>' |
| | assert mathml(IndexedBase(a)[b]*IndexedBase(c)[d]*IndexedBase(e), |
| | printer='presentation') == \ |
| | '<mrow><msub><mi>a</mi><mi>b</mi></msub><mo>⁢'\ |
| | '</mo><msub><mi>c</mi><mi>d</mi></msub><mo>⁢</mo><mi>e</mi></mrow>' |
| |
|
| |
|
| | def test_print_Indexed(): |
| | assert mathml(IndexedBase(a), printer='presentation') == '<mi>a</mi>' |
| | assert mathml(IndexedBase(a/b), printer='presentation') == \ |
| | '<mrow><mfrac><mi>a</mi><mi>b</mi></mfrac></mrow>' |
| | assert mathml(IndexedBase((a, b)), printer='presentation') == \ |
| | '<mrow><mo>(</mo><mi>a</mi><mo>,</mo><mi>b</mi><mo>)</mo></mrow>' |
| |
|
| | def test_print_MatrixElement(): |
| | i, j = symbols('i j') |
| | A = MatrixSymbol('A', i, j) |
| | assert mathml(A[0,0],printer = 'presentation') == \ |
| | '<msub><mi>A</mi><mrow><mn>0</mn><mo>,</mo><mn>0</mn></mrow></msub>' |
| | assert mathml(A[i,j], printer = 'presentation') == \ |
| | '<msub><mi>A</mi><mrow><mi>i</mi><mo>,</mo><mi>j</mi></mrow></msub>' |
| | assert mathml(A[i*j,0], printer = 'presentation') == \ |
| | '<msub><mi>A</mi><mrow><mrow><mi>i</mi><mo>⁢</mo><mi>j</mi></mrow><mo>,</mo><mn>0</mn></mrow></msub>' |
| |
|
| |
|
| | def test_print_Vector(): |
| | ACS = CoordSys3D('A') |
| | assert mathml(Cross(ACS.i, ACS.j*ACS.x*3 + ACS.k), printer='presentation') == \ |
| | '<mrow><msub><mover><mi mathvariant="bold">i</mi><mo>^</mo></mover>'\ |
| | '<mi mathvariant="bold">A</mi></msub><mo>×</mo><mrow><mo>(</mo><mrow>'\ |
| | '<mrow><mo>(</mo><mrow><mn>3</mn><mo>⁢</mo><msub>'\ |
| | '<mi mathvariant="bold">x</mi><mi mathvariant="bold">A</mi></msub>'\ |
| | '</mrow><mo>)</mo></mrow><mo>⁢</mo><msub><mover>'\ |
| | '<mi mathvariant="bold">j</mi><mo>^</mo></mover>'\ |
| | '<mi mathvariant="bold">A</mi></msub><mo>+</mo><msub><mover>'\ |
| | '<mi mathvariant="bold">k</mi><mo>^</mo></mover><mi mathvariant="bold">'\ |
| | 'A</mi></msub></mrow><mo>)</mo></mrow></mrow>' |
| | assert mathml(Cross(ACS.i, ACS.j), printer='presentation') == \ |
| | '<mrow><msub><mover><mi mathvariant="bold">i</mi><mo>^</mo></mover>'\ |
| | '<mi mathvariant="bold">A</mi></msub><mo>×</mo><msub><mover>'\ |
| | '<mi mathvariant="bold">j</mi><mo>^</mo></mover>'\ |
| | '<mi mathvariant="bold">A</mi></msub></mrow>' |
| | assert mathml(x*Cross(ACS.i, ACS.j), printer='presentation') == \ |
| | '<mrow><mi>x</mi><mo>⁢</mo><mrow><mo>(</mo><mrow><msub><mover>'\ |
| | '<mi mathvariant="bold">i</mi><mo>^</mo></mover>'\ |
| | '<mi mathvariant="bold">A</mi></msub><mo>×</mo><msub><mover>'\ |
| | '<mi mathvariant="bold">j</mi><mo>^</mo></mover>'\ |
| | '<mi mathvariant="bold">A</mi></msub></mrow><mo>)</mo></mrow></mrow>' |
| | assert mathml(Cross(x*ACS.i, ACS.j), printer='presentation') == \ |
| | '<mrow><mo>-</mo><mrow><msub><mover><mi mathvariant="bold">j</mi>'\ |
| | '<mo>^</mo></mover><mi mathvariant="bold">A</mi></msub>'\ |
| | '<mo>×</mo><mrow><mo>(</mo><mrow><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow>'\ |
| | '<mo>⁢</mo><msub><mover><mi mathvariant="bold">i</mi>'\ |
| | '<mo>^</mo></mover><mi mathvariant="bold">A</mi></msub></mrow>'\ |
| | '<mo>)</mo></mrow></mrow></mrow>' |
| | assert mathml(Curl(3*ACS.x*ACS.j), printer='presentation') == \ |
| | '<mrow><mo>∇</mo><mo>×</mo><mrow><mo>(</mo><mrow><mrow><mo>(</mo>'\ |
| | '<mrow><mn>3</mn><mo>⁢</mo><msub><mi mathvariant="bold">x</mi>'\ |
| | '<mi mathvariant="bold">A</mi></msub></mrow><mo>)</mo></mrow><mo>⁢</mo>'\ |
| | '<msub><mover><mi mathvariant="bold">j</mi><mo>^</mo></mover>'\ |
| | '<mi mathvariant="bold">A</mi></msub></mrow><mo>)</mo></mrow></mrow>' |
| | assert mathml(Curl(3*x*ACS.x*ACS.j), printer='presentation') == \ |
| | '<mrow><mo>∇</mo><mo>×</mo><mrow><mo>(</mo><mrow><mrow><mo>(</mo><mrow>'\ |
| | '<mn>3</mn><mo>⁢</mo><msub><mi mathvariant="bold">x'\ |
| | '</mi><mi mathvariant="bold">A</mi></msub><mo>⁢</mo>'\ |
| | '<mi>x</mi></mrow><mo>)</mo></mrow><mo>⁢</mo><msub><mover>'\ |
| | '<mi mathvariant="bold">j</mi><mo>^</mo></mover>'\ |
| | '<mi mathvariant="bold">A</mi></msub></mrow><mo>)</mo></mrow></mrow>' |
| | assert mathml(x*Curl(3*ACS.x*ACS.j), printer='presentation') == \ |
| | '<mrow><mi>x</mi><mo>⁢</mo><mrow><mo>(</mo><mrow><mo>∇</mo>'\ |
| | '<mo>×</mo><mrow><mo>(</mo><mrow><mrow><mo>(</mo><mrow><mn>3</mn>'\ |
| | '<mo>⁢</mo><msub><mi mathvariant="bold">x</mi>'\ |
| | '<mi mathvariant="bold">A</mi></msub></mrow><mo>)</mo></mrow>'\ |
| | '<mo>⁢</mo><msub><mover><mi mathvariant="bold">j</mi>'\ |
| | '<mo>^</mo></mover><mi mathvariant="bold">A</mi></msub></mrow><mo>)</mo>'\ |
| | '</mrow></mrow><mo>)</mo></mrow></mrow>' |
| | assert mathml(Curl(3*x*ACS.x*ACS.j + ACS.i), printer='presentation') == \ |
| | '<mrow><mo>∇</mo><mo>×</mo><mrow><mo>(</mo><mrow><msub><mover>'\ |
| | '<mi mathvariant="bold">i</mi><mo>^</mo></mover>'\ |
| | '<mi mathvariant="bold">A</mi></msub><mo>+</mo><mrow><mo>(</mo><mrow>'\ |
| | '<mn>3</mn><mo>⁢</mo><msub><mi mathvariant="bold">x'\ |
| | '</mi><mi mathvariant="bold">A</mi></msub><mo>⁢</mo>'\ |
| | '<mi>x</mi></mrow><mo>)</mo></mrow><mo>⁢</mo><msub><mover>'\ |
| | '<mi mathvariant="bold">j</mi><mo>^</mo></mover>'\ |
| | '<mi mathvariant="bold">A</mi></msub></mrow><mo>)</mo></mrow></mrow>' |
| | assert mathml(Divergence(3*ACS.x*ACS.j), printer='presentation') == \ |
| | '<mrow><mo>∇</mo><mo>·</mo><mrow><mo>(</mo><mrow><mrow><mo>(</mo>'\ |
| | '<mrow><mn>3</mn><mo>⁢</mo><msub><mi mathvariant="bold">x'\ |
| | '</mi><mi mathvariant="bold">A</mi></msub></mrow><mo>)</mo></mrow>'\ |
| | '<mo>⁢</mo><msub><mover><mi mathvariant="bold">j</mi>'\ |
| | '<mo>^</mo></mover><mi mathvariant="bold">A</mi></msub></mrow><mo>)</mo></mrow></mrow>' |
| | assert mathml(x*Divergence(3*ACS.x*ACS.j), printer='presentation') == \ |
| | '<mrow><mi>x</mi><mo>⁢</mo><mrow><mo>(</mo><mrow><mo>∇</mo>'\ |
| | '<mo>·</mo><mrow><mo>(</mo><mrow><mrow><mo>(</mo><mrow><mn>3</mn>'\ |
| | '<mo>⁢</mo><msub><mi mathvariant="bold">x</mi>'\ |
| | '<mi mathvariant="bold">A</mi></msub></mrow><mo>)</mo></mrow>'\ |
| | '<mo>⁢</mo><msub><mover><mi mathvariant="bold">j</mi>'\ |
| | '<mo>^</mo></mover><mi mathvariant="bold">A</mi></msub></mrow>'\ |
| | '<mo>)</mo></mrow></mrow><mo>)</mo></mrow></mrow>' |
| | assert mathml(Divergence(3*x*ACS.x*ACS.j + ACS.i), printer='presentation') == \ |
| | '<mrow><mo>∇</mo><mo>·</mo><mrow><mo>(</mo><mrow><msub><mover>'\ |
| | '<mi mathvariant="bold">i</mi><mo>^</mo></mover>'\ |
| | '<mi mathvariant="bold">A</mi></msub><mo>+</mo><mrow><mo>(</mo><mrow>'\ |
| | '<mn>3</mn><mo>⁢</mo><msub>'\ |
| | '<mi mathvariant="bold">x</mi><mi mathvariant="bold">A</mi></msub>'\ |
| | '<mo>⁢</mo><mi>x</mi></mrow><mo>)</mo></mrow>'\ |
| | '<mo>⁢</mo><msub><mover><mi mathvariant="bold">j</mi>'\ |
| | '<mo>^</mo></mover><mi mathvariant="bold">A</mi></msub></mrow>'\ |
| | '<mo>)</mo></mrow></mrow>' |
| | assert mathml(Dot(ACS.i, ACS.j*ACS.x*3+ACS.k), printer='presentation') == \ |
| | '<mrow><msub><mover><mi mathvariant="bold">i</mi><mo>^</mo></mover>'\ |
| | '<mi mathvariant="bold">A</mi></msub><mo>·</mo><mrow><mo>(</mo><mrow>'\ |
| | '<mrow><mo>(</mo><mrow><mn>3</mn><mo>⁢</mo><msub>'\ |
| | '<mi mathvariant="bold">x</mi><mi mathvariant="bold">A</mi></msub>'\ |
| | '</mrow><mo>)</mo></mrow><mo>⁢</mo><msub><mover>'\ |
| | '<mi mathvariant="bold">j</mi><mo>^</mo></mover>'\ |
| | '<mi mathvariant="bold">A</mi></msub><mo>+</mo><msub><mover>'\ |
| | '<mi mathvariant="bold">k</mi><mo>^</mo></mover>'\ |
| | '<mi mathvariant="bold">A</mi></msub></mrow><mo>)</mo></mrow></mrow>' |
| | assert mathml(Dot(ACS.i, ACS.j), printer='presentation') == \ |
| | '<mrow><msub><mover><mi mathvariant="bold">i</mi><mo>^</mo></mover>'\ |
| | '<mi mathvariant="bold">A</mi></msub><mo>·</mo><msub><mover>'\ |
| | '<mi mathvariant="bold">j</mi><mo>^</mo></mover>'\ |
| | '<mi mathvariant="bold">A</mi></msub></mrow>' |
| | assert mathml(Dot(x*ACS.i, ACS.j), printer='presentation') == \ |
| | '<mrow><msub><mover><mi mathvariant="bold">j</mi><mo>^</mo></mover>'\ |
| | '<mi mathvariant="bold">A</mi></msub><mo>·</mo><mrow><mo>(</mo><mrow>'\ |
| | '<mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow><mo>⁢</mo><msub><mover>'\ |
| | '<mi mathvariant="bold">i</mi><mo>^</mo></mover>'\ |
| | '<mi mathvariant="bold">A</mi></msub></mrow><mo>)</mo></mrow></mrow>' |
| | assert mathml(x*Dot(ACS.i, ACS.j), printer='presentation') == \ |
| | '<mrow><mi>x</mi><mo>⁢</mo><mrow><mo>(</mo><mrow><msub><mover>'\ |
| | '<mi mathvariant="bold">i</mi><mo>^</mo></mover>'\ |
| | '<mi mathvariant="bold">A</mi></msub><mo>·</mo><msub><mover>'\ |
| | '<mi mathvariant="bold">j</mi><mo>^</mo></mover>'\ |
| | '<mi mathvariant="bold">A</mi></msub></mrow><mo>)</mo></mrow></mrow>' |
| | assert mathml(Gradient(ACS.x), printer='presentation') == \ |
| | '<mrow><mo>∇</mo><msub><mi mathvariant="bold">x</mi>'\ |
| | '<mi mathvariant="bold">A</mi></msub></mrow>' |
| | assert mathml(Gradient(ACS.x + 3*ACS.y), printer='presentation') == \ |
| | '<mrow><mo>∇</mo><mrow><mo>(</mo><mrow><msub><mi mathvariant="bold">'\ |
| | 'x</mi><mi mathvariant="bold">A</mi></msub><mo>+</mo><mrow><mn>3</mn>'\ |
| | '<mo>⁢</mo><msub><mi mathvariant="bold">y</mi>'\ |
| | '<mi mathvariant="bold">A</mi></msub></mrow></mrow><mo>)</mo></mrow></mrow>' |
| | assert mathml(x*Gradient(ACS.x), printer='presentation') == \ |
| | '<mrow><mi>x</mi><mo>⁢</mo><mrow><mo>(</mo><mrow><mo>∇</mo>'\ |
| | '<msub><mi mathvariant="bold">x</mi><mi mathvariant="bold">A</mi>'\ |
| | '</msub></mrow><mo>)</mo></mrow></mrow>' |
| | assert mathml(Gradient(x*ACS.x), printer='presentation') == \ |
| | '<mrow><mo>∇</mo><mrow><mo>(</mo><mrow><msub><mi mathvariant="bold">'\ |
| | 'x</mi><mi mathvariant="bold">A</mi></msub><mo>⁢</mo>'\ |
| | '<mi>x</mi></mrow><mo>)</mo></mrow></mrow>' |
| | assert mathml(Cross(ACS.z, ACS.x), printer='presentation') == \ |
| | '<mrow><mo>-</mo><mrow><msub><mi mathvariant="bold">x</mi>'\ |
| | '<mi mathvariant="bold">A</mi></msub><mo>×</mo><msub>'\ |
| | '<mi mathvariant="bold">z</mi><mi mathvariant="bold">A</mi></msub></mrow></mrow>' |
| | assert mathml(Laplacian(ACS.x), printer='presentation') == \ |
| | '<mrow><mo>∆</mo><msub><mi mathvariant="bold">x</mi>'\ |
| | '<mi mathvariant="bold">A</mi></msub></mrow>' |
| | assert mathml(Laplacian(ACS.x + 3*ACS.y), printer='presentation') == \ |
| | '<mrow><mo>∆</mo><mrow><mo>(</mo><mrow><msub><mi mathvariant="bold">'\ |
| | 'x</mi><mi mathvariant="bold">A</mi></msub><mo>+</mo><mrow><mn>3</mn>'\ |
| | '<mo>⁢</mo><msub><mi mathvariant="bold">y</mi>'\ |
| | '<mi mathvariant="bold">A</mi></msub></mrow></mrow><mo>)</mo></mrow></mrow>' |
| | assert mathml(x*Laplacian(ACS.x), printer='presentation') == \ |
| | '<mrow><mi>x</mi><mo>⁢</mo><mrow><mo>(</mo><mrow><mo>∆</mo>'\ |
| | '<msub><mi mathvariant="bold">x</mi><mi mathvariant="bold">A</mi>'\ |
| | '</msub></mrow><mo>)</mo></mrow></mrow>' |
| | assert mathml(Laplacian(x*ACS.x), printer='presentation') == \ |
| | '<mrow><mo>∆</mo><mrow><mo>(</mo><mrow><msub><mi mathvariant="bold">'\ |
| | 'x</mi><mi mathvariant="bold">A</mi></msub><mo>⁢</mo>'\ |
| | '<mi>x</mi></mrow><mo>)</mo></mrow></mrow>' |
| |
|
| | @XFAIL |
| | def test_vector_cross_xfail(): |
| | ACS = CoordSys3D('A') |
| | assert mathml(Cross(ACS.x, ACS.z) + Cross(ACS.z, ACS.x), printer='presentation') == \ |
| | '<mover><mi mathvariant="bold">0</mi><mo>^</mo></mover>' |
| |
|
| | def test_print_elliptic_f(): |
| | assert mathml(elliptic_f(x, y), printer = 'presentation') == \ |
| | '<mrow><mi>𝖥</mi><mrow><mo>(</mo><mi>x</mi><mo>|</mo><mi>y</mi><mo>)</mo></mrow></mrow>' |
| | assert mathml(elliptic_f(x/y, y), printer = 'presentation') == \ |
| | '<mrow><mi>𝖥</mi><mrow><mo>(</mo><mrow><mfrac><mi>x</mi><mi>y</mi></mfrac></mrow><mo>|</mo><mi>y</mi><mo>)</mo></mrow></mrow>' |
| |
|
| | def test_print_elliptic_e(): |
| | assert mathml(elliptic_e(x), printer = 'presentation') == \ |
| | '<mrow><mi>𝖤</mi><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>' |
| | assert mathml(elliptic_e(x, y), printer = 'presentation') == \ |
| | '<mrow><mi>𝖤</mi><mrow><mo>(</mo><mi>x</mi><mo>|</mo><mi>y</mi><mo>)</mo></mrow></mrow>' |
| |
|
| | def test_print_elliptic_pi(): |
| | assert mathml(elliptic_pi(x, y), printer = 'presentation') == \ |
| | '<mrow><mi>𝛱</mi><mrow><mo>(</mo><mi>x</mi><mo>|</mo><mi>y</mi><mo>)</mo></mrow></mrow>' |
| | assert mathml(elliptic_pi(x, y, z), printer = 'presentation') == \ |
| | '<mrow><mi>𝛱</mi><mrow><mo>(</mo><mi>x</mi><mo>;</mo><mi>y</mi><mo>|</mo><mi>z</mi><mo>)</mo></mrow></mrow>' |
| |
|
| | def test_print_Ei(): |
| | assert mathml(Ei(x), printer = 'presentation') == \ |
| | '<mrow><mi>Ei</mi><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>' |
| | assert mathml(Ei(x**y), printer = 'presentation') == \ |
| | '<mrow><mi>Ei</mi><mrow><mo>(</mo><msup><mi>x</mi><mi>y</mi></msup><mo>)</mo></mrow></mrow>' |
| |
|
| | def test_print_expint(): |
| | assert mathml(expint(x, y), printer = 'presentation') == \ |
| | '<mrow><msub><mo>E</mo><mi>x</mi></msub><mrow><mo>(</mo><mi>y</mi><mo>)</mo></mrow></mrow>' |
| | assert mathml(expint(IndexedBase(x)[1], IndexedBase(x)[2]), printer = 'presentation') == \ |
| | '<mrow><msub><mo>E</mo><msub><mi>x</mi><mn>1</mn></msub></msub><mrow><mo>(</mo><msub><mi>x</mi><mn>2</mn></msub><mo>)</mo></mrow></mrow>' |
| |
|
| | def test_print_jacobi(): |
| | assert mathml(jacobi(n, a, b, x), printer = 'presentation') == \ |
| | '<mrow><msubsup><mo>P</mo><mi>n</mi><mrow><mo>(</mo><mi>a</mi><mo>,</mo><mi>b</mi><mo>)</mo></mrow></msubsup><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>' |
| |
|
| | def test_print_gegenbauer(): |
| | assert mathml(gegenbauer(n, a, x), printer = 'presentation') == \ |
| | '<mrow><msubsup><mo>C</mo><mi>n</mi><mrow><mo>(</mo><mi>a</mi><mo>)</mo></mrow></msubsup><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>' |
| |
|
| | def test_print_chebyshevt(): |
| | assert mathml(chebyshevt(n, x), printer = 'presentation') == \ |
| | '<mrow><msub><mo>T</mo><mi>n</mi></msub><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>' |
| |
|
| | def test_print_chebyshevu(): |
| | assert mathml(chebyshevu(n, x), printer = 'presentation') == \ |
| | '<mrow><msub><mo>U</mo><mi>n</mi></msub><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>' |
| |
|
| | def test_print_legendre(): |
| | assert mathml(legendre(n, x), printer = 'presentation') == \ |
| | '<mrow><msub><mo>P</mo><mi>n</mi></msub><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>' |
| |
|
| | def test_print_assoc_legendre(): |
| | assert mathml(assoc_legendre(n, a, x), printer = 'presentation') == \ |
| | '<mrow><msubsup><mo>P</mo><mi>n</mi><mrow><mo>(</mo><mi>a</mi><mo>)</mo></mrow></msubsup><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>' |
| |
|
| | def test_print_laguerre(): |
| | assert mathml(laguerre(n, x), printer = 'presentation') == \ |
| | '<mrow><msub><mo>L</mo><mi>n</mi></msub><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>' |
| |
|
| | def test_print_assoc_laguerre(): |
| | assert mathml(assoc_laguerre(n, a, x), printer = 'presentation') == \ |
| | '<mrow><msubsup><mo>L</mo><mi>n</mi><mrow><mo>(</mo><mi>a</mi><mo>)</mo></mrow></msubsup><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>' |
| |
|
| | def test_print_hermite(): |
| | assert mathml(hermite(n, x), printer = 'presentation') == \ |
| | '<mrow><msub><mo>H</mo><mi>n</mi></msub><mrow><mo>(</mo><mi>x</mi><mo>)</mo></mrow></mrow>' |
| |
|
| | def test_mathml_SingularityFunction(): |
| | assert mathml(SingularityFunction(x, 4, 5), printer='presentation') == \ |
| | '<msup><mrow><mo>⟨</mo><mrow><mi>x</mi><mo>-</mo><mn>4</mn></mrow><mo>⟩</mo></mrow><mn>5</mn></msup>' |
| | assert mathml(SingularityFunction(x, -3, 4), printer='presentation') == \ |
| | '<msup><mrow><mo>⟨</mo><mrow><mi>x</mi><mo>+</mo><mn>3</mn></mrow><mo>⟩</mo></mrow><mn>4</mn></msup>' |
| | assert mathml(SingularityFunction(x, 0, 4), printer='presentation') == \ |
| | '<msup><mrow><mo>⟨</mo><mi>x</mi><mo>⟩</mo></mrow><mn>4</mn></msup>' |
| | assert mathml(SingularityFunction(x, a, n), printer='presentation') == \ |
| | '<msup><mrow><mo>⟨</mo><mrow><mrow><mo>-</mo><mi>a</mi></mrow><mo>+</mo><mi>x</mi></mrow><mo>⟩</mo></mrow><mi>n</mi></msup>' |
| | assert mathml(SingularityFunction(x, 4, -2), printer='presentation') == \ |
| | '<msup><mrow><mo>⟨</mo><mrow><mi>x</mi><mo>-</mo><mn>4</mn></mrow><mo>⟩</mo></mrow><mn>-2</mn></msup>' |
| | assert mathml(SingularityFunction(x, 4, -1), printer='presentation') == \ |
| | '<msup><mrow><mo>⟨</mo><mrow><mi>x</mi><mo>-</mo><mn>4</mn></mrow><mo>⟩</mo></mrow><mn>-1</mn></msup>' |
| |
|
| |
|
| | def test_mathml_matrix_functions(): |
| | from sympy.matrices import Adjoint, Inverse, Transpose |
| | X = MatrixSymbol('X', 2, 2) |
| | Y = MatrixSymbol('Y', 2, 2) |
| | assert mathml(Adjoint(X), printer='presentation') == \ |
| | '<msup><mi>X</mi><mo>†</mo></msup>' |
| | assert mathml(Adjoint(X + Y), printer='presentation') == \ |
| | '<msup><mrow><mo>(</mo><mrow><mi>X</mi><mo>+</mo><mi>Y</mi></mrow><mo>)</mo></mrow><mo>†</mo></msup>' |
| | assert mathml(Adjoint(X) + Adjoint(Y), printer='presentation') == \ |
| | '<mrow><msup><mi>X</mi><mo>†</mo></msup><mo>+</mo><msup>' \ |
| | '<mi>Y</mi><mo>†</mo></msup></mrow>' |
| | assert mathml(Adjoint(X*Y), printer='presentation') == \ |
| | '<msup><mrow><mo>(</mo><mrow><mi>X</mi><mo>⁢</mo>' \ |
| | '<mi>Y</mi></mrow><mo>)</mo></mrow><mo>†</mo></msup>' |
| | assert mathml(Adjoint(Y)*Adjoint(X), printer='presentation') == \ |
| | '<mrow><msup><mi>Y</mi><mo>†</mo></msup><mo>⁢' \ |
| | '</mo><msup><mi>X</mi><mo>†</mo></msup></mrow>' |
| | assert mathml(Adjoint(X**2), printer='presentation') == \ |
| | '<msup><mrow><mo>(</mo><msup><mi>X</mi><mn>2</mn></msup><mo>)</mo></mrow><mo>†</mo></msup>' |
| | assert mathml(Adjoint(X)**2, printer='presentation') == \ |
| | '<msup><mrow><mo>(</mo><msup><mi>X</mi><mo>†</mo></msup><mo>)</mo></mrow><mn>2</mn></msup>' |
| | assert mathml(Adjoint(Inverse(X)), printer='presentation') == \ |
| | '<msup><mrow><mo>(</mo><msup><mi>X</mi><mn>-1</mn></msup><mo>)</mo></mrow><mo>†</mo></msup>' |
| | assert mathml(Inverse(Adjoint(X)), printer='presentation') == \ |
| | '<msup><mrow><mo>(</mo><msup><mi>X</mi><mo>†</mo></msup><mo>)</mo></mrow><mn>-1</mn></msup>' |
| | assert mathml(Adjoint(Transpose(X)), printer='presentation') == \ |
| | '<msup><mrow><mo>(</mo><msup><mi>X</mi><mo>T</mo></msup><mo>)</mo></mrow><mo>†</mo></msup>' |
| | assert mathml(Transpose(Adjoint(X)), printer='presentation') == \ |
| | '<msup><mrow><mo>(</mo><msup><mi>X</mi><mo>†</mo></msup><mo>)</mo></mrow><mo>T</mo></msup>' |
| | assert mathml(Transpose(Adjoint(X) + Y), printer='presentation') == \ |
| | '<msup><mrow><mo>(</mo><mrow><msup><mi>X</mi><mo>†</mo></msup>' \ |
| | '<mo>+</mo><mi>Y</mi></mrow><mo>)</mo></mrow><mo>T</mo></msup>' |
| | assert mathml(Transpose(X), printer='presentation') == \ |
| | '<msup><mi>X</mi><mo>T</mo></msup>' |
| | assert mathml(Transpose(X + Y), printer='presentation') == \ |
| | '<msup><mrow><mo>(</mo><mrow><mi>X</mi><mo>+</mo><mi>Y</mi></mrow><mo>)</mo></mrow><mo>T</mo></msup>' |
| |
|
| |
|
| | def test_mathml_special_matrices(): |
| | from sympy.matrices import Identity, ZeroMatrix, OneMatrix |
| | assert mathml(Identity(4), printer='presentation') == '<mi>𝕀</mi>' |
| | assert mathml(ZeroMatrix(2, 2), printer='presentation') == '<mn>𝟘</mn>' |
| | assert mathml(OneMatrix(2, 2), printer='presentation') == '<mn>𝟙</mn>' |
| |
|
| | def test_mathml_piecewise(): |
| | from sympy.functions.elementary.piecewise import Piecewise |
| | |
| | assert mathml(Piecewise((x, x <= 1), (x**2, True))) == \ |
| | '<piecewise><piece><ci>x</ci><apply><leq/><ci>x</ci><cn>1</cn></apply></piece><otherwise><apply><power/><ci>x</ci><cn>2</cn></apply></otherwise></piecewise>' |
| |
|
| | raises(ValueError, lambda: mathml(Piecewise((x, x <= 1)))) |
| |
|
| |
|
| | def test_issue_17857(): |
| | assert mathml(Range(-oo, oo), printer='presentation') == \ |
| | '<mrow><mo>{</mo><mi>…</mi><mo>,</mo><mn>-1</mn><mo>,</mo><mn>0</mn><mo>,</mo><mn>1</mn><mo>,</mo><mi>…</mi><mo>}</mo></mrow>' |
| | assert mathml(Range(oo, -oo, -1), printer='presentation') == \ |
| | '<mrow><mo>{</mo><mi>…</mi><mo>,</mo><mn>1</mn><mo>,</mo><mn>0</mn><mo>,</mo><mn>-1</mn><mo>,</mo><mi>…</mi><mo>}</mo></mrow>' |
| |
|
| |
|
| | def test_float_roundtrip(): |
| | x = sympify(0.8975979010256552) |
| | y = float(mp.doprint(x).strip('</cn>')) |
| | assert x == y |
| |
|
| |
|
| | def test_content_mathml_disable_split_super_sub(): |
| | mp = MathMLContentPrinter() |
| | assert mp.doprint(Symbol('u_b')) == '<ci><mml:msub><mml:mi>u</mml:mi><mml:mi>b</mml:mi></mml:msub></ci>' |
| | mp = MathMLContentPrinter({'disable_split_super_sub': False}) |
| | assert mp.doprint(Symbol('u_b')) == '<ci><mml:msub><mml:mi>u</mml:mi><mml:mi>b</mml:mi></mml:msub></ci>' |
| | mp = MathMLContentPrinter({'disable_split_super_sub': True}) |
| | assert mp.doprint(Symbol('u_b')) == '<ci>u_b</ci>' |
| |
|
| | def test_presentation_mathml_disable_split_super_sub(): |
| | mpp = MathMLPresentationPrinter() |
| | assert mpp.doprint(Symbol('u_b')) == '<msub><mi>u</mi><mi>b</mi></msub>' |
| | mpp = MathMLPresentationPrinter({'disable_split_super_sub': False}) |
| | assert mpp.doprint(Symbol('u_b')) == '<msub><mi>u</mi><mi>b</mi></msub>' |
| | mpp = MathMLPresentationPrinter({'disable_split_super_sub': True}) |
| | assert mpp.doprint(Symbol('u_b')) == '<mi>u_b</mi>' |
| |
|
