def _print_Mul(self, expr):
args = expr.args
if args[-1] is I:
if len(args) == 2 and args[0] == -1:
return LatexPrinter._print_Mul(self, expr)
return '%s %s' % (self._print(Mul(*args[:-1])), self._print(I))
return LatexPrinter._print_Mul(self, expr)
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 _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 _print_Mul(self, expr):
args = expr.args
if args[-1] is I:
if len(args) == 2 and args[0] == -1:
return LatexPrinter._print_Mul(self, expr)
return "%s %s" % (self._print(Mul(*args[:-1])), self._print(I))
return LatexPrinter._print_Mul(self, 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_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 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 __init__(self, profile=None):
_profile = {
"mat_str": "pmatrix",
"mat_delim": "",
"mode": "inline",
}
if profile is not None:
_profile.update(profile)
LatexPrinter.__init__(self, _profile)
def __init__(self, profile = None):
_profile = {
"mat_str" : "pmatrix",
"mat_delim" : "",
"mode": "inline",
}
if profile is not None:
_profile.update(profile)
LatexPrinter.__init__(self, _profile)
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 Fmt(obj, fmt=0):
if isinstance(obj, (list, tuple, dict)):
n = len(obj)
if isinstance(obj, list):
ldelim = '['
rdelim = ']'
elif isinstance(obj, dict):
ldelim = r'\{'
rdelim = r'\}'
else:
ldelim = '('
rdelim = ')'
if fmt == 1:
latex_str = r' \left ' + ldelim + r' \begin{array}{' + n * 'c' + '} '
for cell in obj:
if isinstance(obj, dict):
#cell.title = None
latex_cell = latex(cell) + ' : ' + latex(obj[cell])
else:
#title = cell.title
#cell.title = None
latex_cell = latex(cell)
latex_cell = latex_cell.replace('\n', ' ')
latex_str += latex_cell + ', & '
#cell.title = title
latex_str = latex_str[:-4]
latex_str += r'\\ \end{array} \right ' + rdelim + ' \n'
else:
latex_str = ''
i = 1
for cell in obj:
#title = cell.title
#cell.title = None
latex_cell = latex(cell)
latex_cell = latex_cell.replace('\n', ' ')
#cell.title = title
if i == 1:
latex_str += r'\begin{array}{c} \left ' + ldelim + r' ' + latex_cell + r', \right. \\ '
elif i == n:
latex_str += r' \left. ' + latex_cell + r'\right ' + rdelim + r' \\ \end{array}'
else:
latex_str += r' ' + latex_cell + r', \\'
i += 1
if isinteractive(): # For Ipython notebook
latex_str = r'\begin{equation*} ' + latex_str + r'\end{equation*}'
return latex_str
else:
return latex_str
elif isinstance(obj, int):
LatexPrinter.set_global_settings(galgebra_mv_fmt=obj)
return
else:
raise TypeError(str(type(obj)) + ' not allowed arg type in Fmt')
def __init__(self, settings):
defaults = {
"decimales": 18,
"mat_str": "pmatrix",
"mat_delim": "",
"mode": "inline",
"fold_frac_powers": False,
"fold_short_frac": False,
}
self._default_settings.update(defaults)
LatexPrinter.__init__(self, settings)
def __init__(self, settings):
defaults = {'decimales': 18,
'mode_scientifique': False,
'decimales_sci': 2,
"mat_str" : "pmatrix",
"mat_delim" : "",
"mode": "inline",
"fold_frac_powers": False,
"fold_short_frac": False,
}
self._default_settings.update(defaults)
LatexPrinter.__init__(self, settings)
def __init__(self, LatexExport, symbDic, sort=False, cType=None, baseAdd=False, baseMul=False, incrementInds=False):
self.latex = LatexExport
self.sort = sort
self.cType = cType
self.baseAdd = baseAdd
self.baseMul = baseMul
self.incrementInds = incrementInds
self.dic = symbDic
LatexPrinter.__init__(self, {'symbol_names': symbDic})
def _print_Float(self, expr):
if self._settings['mode_scientifique']:
# Gestion de l'écriture scientifique.
n = int(floor(log(expr, 10)))
s = LatexPrinter._print_Float(self, self._float_evalf(expr*10**-n))
return r"%s \times 10^{%s}" % (s, n)
s = LatexPrinter._print_Float(self, self._float_evalf(expr))
if s.startswith(r'1.0 \times '): # sympy 0.7.3
return s[11:]
elif s.startswith(r'1.0 \cdot '): # sympy 0.7.5
return s[10:]
elif r'\times' not in s:
# Ne pas supprimer un zéro de la puissance !
s = s.rstrip('0').rstrip('.')
return s
def _print_Float(self, expr):
s = LatexPrinter._print_Float(self, expr)
if "e" in s:
nombre, exposant = s.split("e")
return nombre + "\\times 10^{" + exposant.lstrip("+") + "}"
else:
return s
def parenthesize(self, item, level, strict=False):
item_latex = self._print(item)
if item_latex.startswith(r"\dot") or item_latex.startswith(
r"\ddot") or item_latex.startswith(r"\dddot"):
return self._print(item)
else:
return LatexPrinter.parenthesize(self, item, level, strict)
def _latex(self, printer: LatexPrinter, *args: Any) -> str:
s, *_ = self.args
s = printer._print(s)
subscript = _indices_to_subscript(_determine_indices(s))
name = (R"\rho^\mathrm{c}" +
subscript if self._name is None else self._name)
return Rf"{name}\left({s}\right)"
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 _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 doprint(self, expr):
# #if isinstance(expr,)'
print expr
#tex = SLP().doprint(expr)
tex = SLP.doprint(self, expr)
print tex
#tex = self.doprint( expr)
return r"%s" % tex
def doprint(self, expr):
# #if isinstance(expr,)'
print expr
#tex = SLP().doprint(expr)
tex = SLP.doprint(self,expr)
print tex
#tex = self.doprint( expr)
return r"%s" % tex
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 _print_Float(self, expr):
# If not finite we use parent printer
if expr.is_zero:
return "0"
if not expr.is_finite:
return _LatexPrinter._print_Float(self, expr)
return self._number_to_latex(expr.evalf())
def _latex(self, printer: LatexPrinter, *args: Any) -> str:
if all(
map(lambda i: isinstance(i, (sp.Symbol, ArraySymbol)), self.terms)
):
names = set(map(_strip_subscript_superscript, self.terms))
if len(names) == 1:
name = next(iter(names))
subscript = "".join(map(_get_subscript, self.terms))
return f"{{{name}}}_{{{subscript}}}"
return printer._print_ArraySum(self)
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_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 _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_printing():
for c in (
LatexPrinter,
LatexPrinter(),
MathMLContentPrinter,
MathMLPresentationPrinter,
PrettyPrinter,
prettyForm,
stringPict,
stringPict("a"),
Printer,
Printer(),
PythonPrinter,
PythonPrinter(),
):
check(c)
def _print_Function(self, expr, exp=None):
'''
For ite() only
'''
func = expr.func.__name__
args = [ str(self._print(arg)) for arg in expr.args ]
if func == 'ite':
return """\\begin{cases}
%(then_code)s \qquad \\text{if} \quad %(if_code)s \\\\
%(else_code)s \qquad \\text{otherwise.}
\end{cases}""" % {'if_code': args[0], 'then_code': args[1], 'else_code': args[2]}
elif func in ['positive', 'pos']:
return "\left(" + str(self._print(args[0])) + "\\right)^+"
elif func in ['negative', 'neg']:
return "(" + str(self._print(args[0])) + ")^-"
return LatexPrinter._print_Function(self, expr, exp)
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 _print_Abs(self, *args, **kw):
res = LatexPrinter._print_Abs(self, *args, **kw)
return res.replace(r'\lvert', r'|').replace(r'\rvert', r'|')
def _sympy_latex(expr, **settings):
'''
Deal with the case where there are no context-specific
settings.
'''
return LatexPrinter(settings).doprint(expr)
def doprint(self, expr):
expr = self._convert_Decim(expr)
tex = LatexPrinter.doprint(self, expr)
return tex.replace(r'\operatorname{', r'\mathrm{')
def _print_Function(self, expr, *args, **kwargs):
if isinstance(expr, _AppliedUndef):
return self._print_Symbol(sp.Symbol(expr.func.__name__))
return expr.func.__name__
return _LatexPrinter._print_Function(self, expr, *args, **kwargs)
def _print_Abs(self, *args, **kw):
res = LatexPrinter._print_Abs(self, *args, **kw)
return res.replace(r"\lvert", r"|").replace(r"\rvert", r"|")
#!/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 parenthesize(self, item, level, strict=False):
item_latex = self._print(item)
if item_latex.startswith(r"\dot") or item_latex.startswith(r"\ddot") or item_latex.startswith(r"\dddot"):
return self._print(item)
else:
return LatexPrinter.parenthesize(self, item, level, strict)
def __init__(self, settings=None):
self._enable_fourier_args = settings.pop('enable_fourier_args', True)
LatexPrinterSympy.__init__(self, settings=settings)
def doprint(self, expr):
tex = SLP.doprint(self,expr)
return r"%s" % tex
def _latex(self, printer: LatexPrinter, *args: Any) -> str:
s, _, width, *_ = self.args
s = printer._print(s)
subscript = _indices_to_subscript(_determine_indices(width))
name = Rf"\Gamma{subscript}" if self._name is None else self._name
return Rf"{name}\left({s}\right)"
def doprint(self, expr):
##expr = expr.subs(Float(1), S.One)
tex = LatexPrinter.doprint(self, expr)
return tex.replace(r'\operatorname{', r'\mathrm{')
def doprint(self, expr):
tex = LatexPrinter.doprint(self, expr)
return tex.replace(r'\operatorname{', r'\mathrm{')
def disp_latex(expr, **settings):
return LatexPrinter(settings).doprint(expr).replace('$$', '$$\displaystyle', 1)
