def _print_Derivative(self, der_expr):
from sympy.physics.vector.functions import dynamicsymbols
# make sure it is in the right form
der_expr = der_expr.doit()
if not isinstance(der_expr, Derivative):
return r"\left(%s\right)" % self.doprint(der_expr)
# check if expr is a dynamicsymbol
t = dynamicsymbols._t
expr = der_expr.expr
red = expr.atoms(AppliedUndef)
syms = der_expr.variables
test1 = not all([True for i in red if i.free_symbols == {t}])
test2 = not all([(t == i) for i in syms])
if test1 or test2:
return LatexPrinter().doprint(der_expr)
# done checking
dots = len(syms)
base = self._print_Function(expr)
base_split = base.split('_', 1)
base = base_split[0]
if dots == 1:
base = r"\dot{%s}" % base
elif dots == 2:
base = r"\ddot{%s}" % base
elif dots == 3:
base = r"\dddot{%s}" % base
elif dots == 4:
base = r"\ddddot{%s}" % base
else: # Fallback to standard printing
return LatexPrinter().doprint(der_expr)
if len(base_split) is not 1:
base += '_' + base_split[1]
return base
def save_equation(solutions, index, context):
"""
(list, str) -> None
Saving solution into onec of the following formats:
- LaTex
- MathML
- MathJax
"""
#equation_name = os.path.basename(py_file_name)[:-3]
equation_name = context['MapppingCSVToLatex']['TargetNamePrefix']['value']
# creating the folder for tex file
create_directory(equation_name)
if context['OutputType'] == 'latex':
printer = LatexPrinter()
extension = '.tex'
elif context['OutputType'] == 'mathml':
printer = MathMLPrinter()
extension = '.html'
elif context['OutputType'] == 'mathjax':
printer = LatexPrinter()
extension = '.html'
else:
print '[e] UNKNOWN type of output, set "latex", "mathml" or "mathjax"'
return
_file_name = '{0}/{1}{2}'.format(equation_name, equation_name + '-' + str(adjust_number(index)), extension)
save_file(_file_name, to_template(solutions, context, printer))
print '[i] {0} saved into "{1}"'.format(context['OutputType'], _file_name)
def _sympy_latex(expr, **settings):
'''
Deal with the case where all settings are identical, and thus
the settings are really only being used to set defaults,
rather than context-specific behavior.
Check for empty settings, so as to avoid deepcopy
'''
if not settings:
return LatexPrinter(
self._sympy_latex_settings['display']).doprint(expr)
else:
final_settings = copy.deepcopy(
self._sympy_latex_settings['display'])
final_settings.update(settings)
return LatexPrinter(final_settings).doprint(expr)
def _repr_html_(self):
from sympy.printing.latex import LatexPrinter
from sympy.physics.vector import vlatex
lp = LatexPrinter()
x = vlatex(self.loop.x)
y = vlatex(self.loop.y)
return lp.doprint(r"$$ \begin{bmatrix} {%s} \\ {%s} \end{bmatrix} $$" %
(x, y))
def test_printing():
for c in (LatexPrinter, LatexPrinter(), MathMLPrinter,
PrettyPrinter, prettyForm, stringPict, stringPict("a"), Printer,
Printer(), PythonPrinter, PythonPrinter()):
#FIXME-py3k: sympy/printing/printer.py", line 220, in order
#FIXME-py3k: return self._settings['order']
#FIXME-py3k: KeyError: 'order'
check(c)
def test_matAdd():
from sympy import MatrixSymbol
from sympy.printing.latex import LatexPrinter
C = MatrixSymbol('C', 5, 5)
B = MatrixSymbol('B', 5, 5)
l = LatexPrinter()
assert l._print_MatAdd(C - 2 * B) in ['- 2 B + C', '+ C - 2 B']
assert l._print_MatAdd(C + 2 * B) in ['+ 2 B + C', '+ C + 2 B']
def _repr_html_(self):
from sympy.printing.latex import LatexPrinter
from sympy.physics.vector import vlatex
lp = LatexPrinter()
x = vlatex(self.x)
y = vlatex(self.y)
# return lp.doprint("$$ \\langle {0}, \\\\ {1} \\rangle $$".format(x,y))
return lp.doprint(r"$$ \begin{bmatrix} {%s} \\ {%s} \end{bmatrix} $$" %
(x, y))
def _sympy_latex(expr, **settings):
'''
Deal with the case where only 'display' has different settings.
This should be the most common case.
'''
if not settings:
display = LatexPrinter(
self._sympy_latex_settings['display']).doprint(expr)
text = LatexPrinter(
self._sympy_latex_settings['text']).doprint(expr)
else:
display_settings = copy.deepcopy(
self._sympy_latex_settings['display'])
display_settings.update(settings)
display = LatexPrinter(display_settings).doprint(expr)
text_settings = copy.deepcopy(
self._sympy_latex_settings['text'])
text_settings.update(settings)
text = LatexPrinter(text_settings).doprint(expr)
if display == text:
return display
else:
return r'\mathchoice{' + display + '}{' + text + '}{' + text + '}{' + text + '}'
def test_matMul():
from sympy import MatrixSymbol
from sympy.printing.latex import LatexPrinter
A = MatrixSymbol('A', 5, 5)
B = MatrixSymbol('B', 5, 5)
x = Symbol('x')
l = LatexPrinter()
assert l._print_MatMul(2*A) == '2 A'
assert l._print_MatMul(2*x*A) == '2 x A'
assert l._print_MatMul(-2*A) == '-2 A'
assert l._print_MatMul(1.5*A) == '1.5 A'
assert l._print_MatMul(sqrt(2)*A) == r'\sqrt{2} A'
assert l._print_MatMul(-sqrt(2)*A) == r'- \sqrt{2} A'
assert l._print_MatMul(2*sqrt(2)*x*A) == r'2 \sqrt{2} x A'
assert l._print_MatMul(-2*A*(A + 2*B)) in [r'-2 A \left(A + 2 B\right)',
r'-2 A \left(2 B + A\right)']
def test_printing():
for c in (
LatexPrinter,
LatexPrinter(),
MathMLContentPrinter,
MathMLPresentationPrinter,
PrettyPrinter,
prettyForm,
stringPict,
stringPict("a"),
Printer,
Printer(),
PythonPrinter,
PythonPrinter(),
):
check(c)
def _sympy_latex(expr, **settings):
'''
If all attempts at simplification fail, create the most
general interface.
The main disadvantage here is that LatexPrinter is invoked
four times and we must create many temporary variables.
'''
if not settings:
display = LatexPrinter(
self._sympy_latex_settings['display']).doprint(expr)
text = LatexPrinter(
self._sympy_latex_settings['text']).doprint(expr)
script = LatexPrinter(
self._sympy_latex_settings['script']).doprint(expr)
scriptscript = LatexPrinter(
self._sympy_latex_settings['scriptscript']).doprint(
expr)
else:
display_settings = copy.deepcopy(
self._sympy_latex_settings['display'])
display_settings.update(settings)
display = LatexPrinter(display_settings).doprint(expr)
text_settings = copy.deepcopy(
self._sympy_latex_settings['text'])
text_settings.update(settings)
text = LatexPrinter(text_settings).doprint(expr)
script_settings = copy.deepcopy(
self._sympy_latex_settings['script'])
script_settings.update(settings)
script = LatexPrinter(script_settings).doprint(expr)
scriptscript_settings = copy.deepcopy(
self._sympy_latex_settings['scripscript'])
scriptscript_settings.update(settings)
scriptscript = LatexPrinter(scriptscript_settings).doprint(
expr)
if display == text and display == script and display == scriptscript:
return display
else:
return r'\mathchoice{' + display + '}{' + text + '}{' + script + '}{' + scriptscript + '}'
def test_derivative_basic():
d = diff
op1, op2, op3 = DiffOperator(), DiffOperator(target=x), DiffOperator(
target=x, superscript=1)
d1, d2, d3 = Diff(t), Diff(t, target=x), Diff(t, target=x, superscript=1)
printer = LatexPrinter()
assert all('\\partial' in l._latex(printer)
for l in (op1, op2, op3, d1, d2, d3))
dx, dy = DiffOperator(target=x), DiffOperator(target=y)
diff_term = (dx + dy)**2 + 1
diff_term = diff_term.expand()
assert diff_term == dx**2 + 2 * dx * dy + dy**2 + 1
assert DiffOperator.apply(
diff_term, t) == d(t, x, x) + 2 * d(t, x, y) + d(t, y, y) + t
assert ps.fd.Diff(0) == 0
expr = ps.fd.diff(ps.fd.diff(x, 0, 0), 1, 1)
assert expr.get_arg_recursive() == x
assert expr.change_arg_recursive(y).get_arg_recursive() == y
def _sympy_latex(expr, **settings):
'''
Deal with the case where there are no context-specific
settings.
'''
return LatexPrinter(settings).doprint(expr)
#!/bin/env python3
import argparse
import os
from pathlib import Path
import sys
import sympy as sp
import traceback
from sympy.printing.latex import LatexPrinter
latex = LatexPrinter(settings={'mat_delim': '('}).doprint
#project_root = Path('{}/glvis'.format(os.environ['WORK']))
#doc_root = project_root.joinpath('doc', 'note')
doc_root = Path('.')
def doit(f):
try:
f()
except:
traceback.print_exc()
return f
def symfunc(f):
name = f.__name__
setattr(gsym, 'f' + name, name)
return f
def disp_latex(expr, **settings):
return LatexPrinter(settings).doprint(expr).replace('$$', '$$\displaystyle', 1)
