Example #1
0
 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)
Example #2
0
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)
Example #3
0
    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
Example #4
0
 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)
Example #5
0
 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))
Example #6
0
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']
Example #7
0
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']
Example #8
0
 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))
Example #9
0
 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)
Example #10
0
 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)
Example #11
0
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"]
Example #12
0
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')
Example #13
0
 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)
Example #14
0
 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)
Example #15
0
    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})
Example #16
0
 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
Example #17
0
 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
Example #18
0
 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)
Example #19
0
 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)"
Example #20
0
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)']
Example #21
0
 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)
Example #22
0
 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
Example #24
0
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)
Example #25
0
    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())
Example #26
0
 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)
Example #27
0
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)']
Example #28
0
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)"]
Example #29
0
 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 + '}'
Example #30
0
def test_printing():
    for c in (
            LatexPrinter,
            LatexPrinter(),
            MathMLContentPrinter,
            MathMLPresentationPrinter,
            PrettyPrinter,
            prettyForm,
            stringPict,
            stringPict("a"),
            Printer,
            Printer(),
            PythonPrinter,
            PythonPrinter(),
    ):
        check(c)
Example #31
0
    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)
Example #32
0
 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 + '}'
Example #33
0
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
Example #34
0
 def _print_Abs(self, *args, **kw):
     res = LatexPrinter._print_Abs(self, *args, **kw)
     return res.replace(r'\lvert', r'|').replace(r'\rvert', r'|')
Example #35
0
 def _sympy_latex(expr, **settings):
     '''            
     Deal with the case where there are no context-specific 
     settings.
     '''
     return LatexPrinter(settings).doprint(expr)
Example #36
0
 def doprint(self, expr):
     expr = self._convert_Decim(expr)
     tex = LatexPrinter.doprint(self, expr)
     return tex.replace(r'\operatorname{', r'\mathrm{')
Example #37
0
    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)
Example #38
0
 def _print_Abs(self, *args, **kw):
     res = LatexPrinter._print_Abs(self, *args, **kw)
     return res.replace(r"\lvert", r"|").replace(r"\rvert", r"|")
Example #39
0
#!/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

Example #40
0
 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)
Example #41
0
    def __init__(self, settings=None):
        self._enable_fourier_args = settings.pop('enable_fourier_args', True)

        LatexPrinterSympy.__init__(self, settings=settings)
Example #42
0
 def doprint(self, expr):
     tex = SLP.doprint(self,expr)
     return r"%s" % tex
Example #43
0
 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)"
Example #44
0
 def doprint(self, expr):
     ##expr = expr.subs(Float(1), S.One)
     tex = LatexPrinter.doprint(self, expr)
     return tex.replace(r'\operatorname{', r'\mathrm{')
Example #45
0
 def doprint(self, expr):
     tex = LatexPrinter.doprint(self, expr)
     return tex.replace(r'\operatorname{', r'\mathrm{')
Example #46
0
def disp_latex(expr, **settings):
    return LatexPrinter(settings).doprint(expr).replace('$$', '$$\displaystyle', 1)