Printing System

See the Printing section in Tutorial for introduction into printing.

This guide documents the printing system in SymPy and how it works internally.

Printer Class

Printing subsystem driver

SymPy’s printing system works the following way: Any expression can be passed to a designated Printer who then is responsible to return an adequate representation of that expression.

The basic concept is the following:
  1. Let the object print itself if it knows how.
  2. Take the best fitting method defined in the printer.
  3. As fall-back use the emptyPrinter method for the printer.

Some more information how the single concepts work and who should use which:

  1. The object prints itself

    This was the original way of doing printing in sympy. Every class had its own latex, mathml, str and repr methods, but it turned out that it is hard to produce a high quality printer, if all the methods are spread out that far. Therefor all printing code was combined into the different printers, which works great for built-in sympy objects, but not that good for user defined classes where it is inconvenient to patch the printers.

    Nevertheless, to get a fitting representation, the printers look for a specific method in every object, that will be called if it’s available and is then responsible for the representation. The name of that method depends on the specific printer and is defined under Printer.printmethod.

  2. Take the best fitting method defined in the printer.

    The printer loops through expr classes (class + its bases), and tries to dispatch the work to _print_<EXPR_CLASS>

    e.g., suppose we have the following class hierarchy:

        Basic
    |
    Atom
    |
    Number
    |
Rational

    then, for expr=Rational(...), in order to dispatch, we will try calling printer methods as shown in the figure below:

    p._print(expr)
|
|-- p._print_Rational(expr)
|
|-- p._print_Number(expr)
|
|-- p._print_Atom(expr)
|
`-- p._print_Basic(expr)

    if ._print_Rational method exists in the printer, then it is called, and the result is returned back.

    otherwise, we proceed with trying Rational bases in the inheritance order.

  3. As fall-back use the emptyPrinter method for the printer.

    As fall-back self.emptyPrinter will be called with the expression. If not defined in the Printer subclass this will be the same as str(expr).

The main class responsible for printing is Printer (see also its source code):

class sympy.printing.printer.Printer(settings=None)[source]

Generic printer

Its job is to provide infrastructure for implementing new printers easily.

Basically, if you want to implement a printer, all you have to do is:

  1. Subclass Printer.

  2. Define Printer.printmethod in your subclass. If a object has a method with that name, this method will be used for printing.

  3. In your subclass, define _print_<CLASS> methods

    For each class you want to provide printing to, define an appropriate method how to do it. For example if you want a class FOO to be printed in its own way, define _print_FOO:

    def _print_FOO(self, e):
    ...

    this should return how FOO instance e is printed

    Also, if BAR is a subclass of FOO, _print_FOO(bar) will be called for instance of BAR, if no _print_BAR is provided. Thus, usually, we don’t need to provide printing routines for every class we want to support – only generic routine has to be provided for a set of classes.

    A good example for this are functions - for example PrettyPrinter only defines _print_Function, and there is no _print_sin, _print_tan, etc...

    On the other hand, a good printer will probably have to define separate routines for Symbol, Atom, Number, Integral, Limit, etc...

  4. If convenient, override self.emptyPrinter

    This callable will be called to obtain printing result as a last resort, that is when no appropriate print method was found for an expression.

Examples of overloading StrPrinter:

from sympy import Basic, Function, Symbol
from sympy.printing.str import StrPrinter

class CustomStrPrinter(StrPrinter):
    """
    Examples of how to customize the StrPrinter for both a SymPy class and a
    user defined class subclassed from the SymPy Basic class.
    """

    def _print_Derivative(self, expr):
        """
        Custom printing of the SymPy Derivative class.

        Instead of:

        D(x(t), t) or D(x(t), t, t)

        We will print:

        x'     or     x''

        In this example, expr.args == (x(t), t), and expr.args[0] == x(t), and
        expr.args[0].func == x
        """
        return str(expr.args[0].func) + "'"*len(expr.args[1:])

    def _print_MyClass(self, expr):
        """
        Print the characters of MyClass.s alternatively lower case and upper
        case
        """
        s = ""
        i = 0
        for char in expr.s:
            if i % 2 == 0:
                s += char.lower()
            else:
                s += char.upper()
            i += 1
        return s

# Override the __str__ method of to use CustromStrPrinter
Basic.__str__ = lambda self: CustomStrPrinter().doprint(self)
# Demonstration of CustomStrPrinter:
t = Symbol('t')
x = Function('x')(t)
dxdt = x.diff(t)            # dxdt is a Derivative instance
d2xdt2 = dxdt.diff(t)       # dxdt2 is a Derivative instance
ex = MyClass('I like both lowercase and upper case')

print dxdt
print d2xdt2
print ex

The output of the above code is:

x'
x''
i lIkE BoTh lOwErCaSe aNd uPpEr cAsE

By overriding Basic.__str__, we can customize the printing of anything that is subclassed from Basic.

Attributes

printmethod  
printmethod = None
_print(expr, *args, **kwargs)[source]

Internal dispatcher

Tries the following concepts to print an expression:
  1. Let the object print itself if it knows how.
  2. Take the best fitting method defined in the printer.
  3. As fall-back use the emptyPrinter method for the printer.
doprint(expr)[source]

Returns printer’s representation for expr (as a string)

classmethod set_global_settings(**settings)[source]

Set system-wide printing settings.

PrettyPrinter Class

The pretty printing subsystem is implemented in sympy.printing.pretty.pretty by the PrettyPrinter class deriving from Printer. It relies on the modules sympy.printing.pretty.stringPict, and sympy.printing.pretty.pretty_symbology for rendering nice-looking formulas.

The module stringPict provides a base class stringPict and a derived class prettyForm that ease the creation and manipulation of formulas that span across multiple lines.

The module pretty_symbology provides primitives to construct 2D shapes (hline, vline, etc) together with a technique to use unicode automatically when possible.

class sympy.printing.pretty.pretty.PrettyPrinter(settings=None)[source]

Printer, which converts an expression into 2D ASCII-art figure.

printmethod = '_pretty'
sympy.printing.pretty.pretty.pretty(expr, **settings)[source]

Returns a string containing the prettified form of expr.

For information on keyword arguments see pretty_print function.

sympy.printing.pretty.pretty.pretty_print(expr, **settings)[source]

Prints expr in pretty form.

pprint is just a shortcut for this function.

Parameters:

expr : expression

the expression to print

wrap_line : bool, optional

line wrapping enabled/disabled, defaults to True

num_columns : int or None, optional

number of columns before line breaking (default to None which reads the terminal width), useful when using SymPy without terminal.

use_unicode : bool or None, optional

use unicode characters, such as the Greek letter pi instead of the string pi.

full_prec : bool or string, optional

use full precision. Default to “auto”

order : bool or string, optional

set to ‘none’ for long expressions if slow; default is None

use_unicode_sqrt_char : bool, optional

use compact single-character square root symbol (when unambiguous); default is True.

CCodePrinter

This class implements C code printing (i.e. it converts Python expressions to strings of C code).

Usage:

>>> from sympy.printing import print_ccode
>>> from sympy.functions import sin, cos, Abs
>>> from sympy.abc import x
>>> print_ccode(sin(x)**2 + cos(x)**2)
pow(sin(x), 2) + pow(cos(x), 2)
>>> print_ccode(2*x + cos(x), assign_to="result")
result = 2*x + cos(x);
>>> print_ccode(Abs(x**2))
fabs(pow(x, 2))
sympy.printing.ccode.known_functions = {'sinh': 'sinh', 'asin': 'asin', 'cos': 'cos', 'log': 'log', 'atan': 'atan', 'tanh': 'tanh', 'acos': 'acos', 'atanh': 'atanh', 'asinh': 'asinh', 'cosh': 'cosh', 'atan2': 'atan2', 'erf': 'erf', 'Abs': [(<function <lambda> at 0x7eff7aafcb18>, 'fabs')], 'floor': 'floor', 'exp': 'exp', 'acosh': 'acosh', 'tan': 'tan', 'ceiling': 'ceil', 'sin': 'sin', 'gamma': 'tgamma'}
class sympy.printing.ccode.CCodePrinter(settings={})[source]

A printer to convert python expressions to strings of c code

printmethod = '_ccode'
indent_code(code)[source]

Accepts a string of code or a list of code lines

sympy.printing.ccode.ccode(expr, assign_to=None, **settings)[source]

Converts an expr to a string of c code

Parameters:

expr : Expr

A sympy expression to be converted.

assign_to : optional

When given, the argument is used as the name of the variable to which the expression is assigned. Can be a string, Symbol, MatrixSymbol, or Indexed type. This is helpful in case of line-wrapping, or for expressions that generate multi-line statements.

precision : integer, optional

The precision for numbers such as pi [default=15].

user_functions : dict, optional

A dictionary where the keys are string representations of either FunctionClass or UndefinedFunction instances and the values are their desired C string representations. Alternatively, the dictionary value can be a list of tuples i.e. [(argument_test, cfunction_string)]. See below for examples.

dereference : iterable, optional

An iterable of symbols that should be dereferenced in the printed code expression. These would be values passed by address to the function. For example, if dereference=[a], the resulting code would print (*a) instead of a.

human : bool, optional

If True, the result is a single string that may contain some constant declarations for the number symbols. If False, the same information is returned in a tuple of (symbols_to_declare, not_supported_functions, code_text). [default=True].

contract: bool, optional

If True, Indexed instances are assumed to obey tensor contraction rules and the corresponding nested loops over indices are generated. Setting contract=False will not generate loops, instead the user is responsible to provide values for the indices in the code. [default=True].

Examples

>>> from sympy import ccode, symbols, Rational, sin, ceiling, Abs, Function
>>> x, tau = symbols("x, tau")
>>> ccode((2*tau)**Rational(7, 2))
'8*sqrt(2)*pow(tau, 7.0L/2.0L)'
>>> ccode(sin(x), assign_to="s")
's = sin(x);'

Simple custom printing can be defined for certain types by passing a dictionary of {“type” : “function”} to the user_functions kwarg. Alternatively, the dictionary value can be a list of tuples i.e. [(argument_test, cfunction_string)].

>>> custom_functions = {
...   "ceiling": "CEIL",
...   "Abs": [(lambda x: not x.is_integer, "fabs"),
...           (lambda x: x.is_integer, "ABS")],
...   "func": "f"
... }
>>> func = Function('func')
>>> ccode(func(Abs(x) + ceiling(x)), user_functions=custom_functions)
'f(fabs(x) + CEIL(x))'

Piecewise expressions are converted into conditionals. If an assign_to variable is provided an if statement is created, otherwise the ternary operator is used. Note that if the Piecewise lacks a default term, represented by (expr, True) then an error will be thrown. This is to prevent generating an expression that may not evaluate to anything.

>>> from sympy import Piecewise
>>> expr = Piecewise((x + 1, x > 0), (x, True))
>>> print(ccode(expr, tau))
if (x > 0) {
tau = x + 1;
}
else {
tau = x;
}

Support for loops is provided through Indexed types. With contract=True these expressions will be turned into loops, whereas contract=False will just print the assignment expression that should be looped over:

>>> from sympy import Eq, IndexedBase, Idx
>>> len_y = 5
>>> y = IndexedBase('y', shape=(len_y,))
>>> t = IndexedBase('t', shape=(len_y,))
>>> Dy = IndexedBase('Dy', shape=(len_y-1,))
>>> i = Idx('i', len_y-1)
>>> e=Eq(Dy[i], (y[i+1]-y[i])/(t[i+1]-t[i]))
>>> ccode(e.rhs, assign_to=e.lhs, contract=False)
'Dy[i] = (y[i + 1] - y[i])/(t[i + 1] - t[i]);'

Matrices are also supported, but a MatrixSymbol of the same dimensions must be provided to assign_to. Note that any expression that can be generated normally can also exist inside a Matrix:

>>> from sympy import Matrix, MatrixSymbol
>>> mat = Matrix([x**2, Piecewise((x + 1, x > 0), (x, True)), sin(x)])
>>> A = MatrixSymbol('A', 3, 1)
>>> print(ccode(mat, A))
A[0] = pow(x, 2);
if (x > 0) {
   A[1] = x + 1;
}
else {
   A[1] = x;
}
A[2] = sin(x);
sympy.printing.ccode.print_ccode(expr, **settings)[source]

Prints C representation of the given expression.

Fortran Printing

The fcode function translates a sympy expression into Fortran code. The main purpose is to take away the burden of manually translating long mathematical expressions. Therefore the resulting expression should also require no (or very little) manual tweaking to make it compilable. The optional arguments of fcode can be used to fine-tune the behavior of fcode in such a way that manual changes in the result are no longer needed.

sympy.printing.fcode.fcode(expr, assign_to=None, **settings)[source]

Converts an expr to a string of c code

Parameters:

expr : Expr

A sympy expression to be converted.

assign_to : optional

When given, the argument is used as the name of the variable to which the expression is assigned. Can be a string, Symbol, MatrixSymbol, or Indexed type. This is helpful in case of line-wrapping, or for expressions that generate multi-line statements.

precision : integer, optional

The precision for numbers such as pi [default=15].

user_functions : dict, optional

A dictionary where keys are FunctionClass instances and values are their string representations. Alternatively, the dictionary value can be a list of tuples i.e. [(argument_test, cfunction_string)]. See below for examples.

human : bool, optional

If True, the result is a single string that may contain some constant declarations for the number symbols. If False, the same information is returned in a tuple of (symbols_to_declare, not_supported_functions, code_text). [default=True].

contract: bool, optional

If True, Indexed instances are assumed to obey tensor contraction rules and the corresponding nested loops over indices are generated. Setting contract=False will not generate loops, instead the user is responsible to provide values for the indices in the code. [default=True].

source_format : optional

The source format can be either ‘fixed’ or ‘free’. [default=’fixed’]

standard : integer, optional

The Fortran standard to be followed. This is specified as an integer. Acceptable standards are 66, 77, 90, 95, 2003, and 2008. Default is 77. Note that currently the only distinction internally is between standards before 95, and those 95 and after. This may change later as more features are added.

Examples

>>> from sympy import fcode, symbols, Rational, sin, ceiling, floor
>>> x, tau = symbols("x, tau")
>>> fcode((2*tau)**Rational(7, 2))
'      8*sqrt(2.0d0)*tau**(7.0d0/2.0d0)'
>>> fcode(sin(x), assign_to="s")
'      s = sin(x)'

Custom printing can be defined for certain types by passing a dictionary of “type” : “function” to the user_functions kwarg. Alternatively, the dictionary value can be a list of tuples i.e. [(argument_test, cfunction_string)].

>>> custom_functions = {
...   "ceiling": "CEIL",
...   "floor": [(lambda x: not x.is_integer, "FLOOR1"),
...             (lambda x: x.is_integer, "FLOOR2")]
... }
>>> fcode(floor(x) + ceiling(x), user_functions=custom_functions)
'      CEIL(x) + FLOOR1(x)'

Piecewise expressions are converted into conditionals. If an assign_to variable is provided an if statement is created, otherwise the ternary operator is used. Note that if the Piecewise lacks a default term, represented by (expr, True) then an error will be thrown. This is to prevent generating an expression that may not evaluate to anything.

>>> from sympy import Piecewise
>>> expr = Piecewise((x + 1, x > 0), (x, True))
>>> print(fcode(expr, tau))
      if (x > 0) then
         tau = x + 1
      else
         tau = x
      end if

Support for loops is provided through Indexed types. With contract=True these expressions will be turned into loops, whereas contract=False will just print the assignment expression that should be looped over:

>>> from sympy import Eq, IndexedBase, Idx
>>> len_y = 5
>>> y = IndexedBase('y', shape=(len_y,))
>>> t = IndexedBase('t', shape=(len_y,))
>>> Dy = IndexedBase('Dy', shape=(len_y-1,))
>>> i = Idx('i', len_y-1)
>>> e=Eq(Dy[i], (y[i+1]-y[i])/(t[i+1]-t[i]))
>>> fcode(e.rhs, assign_to=e.lhs, contract=False)
'      Dy(i) = (y(i + 1) - y(i))/(t(i + 1) - t(i))'

Matrices are also supported, but a MatrixSymbol of the same dimensions must be provided to assign_to. Note that any expression that can be generated normally can also exist inside a Matrix:

>>> from sympy import Matrix, MatrixSymbol
>>> mat = Matrix([x**2, Piecewise((x + 1, x > 0), (x, True)), sin(x)])
>>> A = MatrixSymbol('A', 3, 1)
>>> print(fcode(mat, A))
      A(1, 1) = x**2
         if (x > 0) then
      A(2, 1) = x + 1
         else
      A(2, 1) = x
         end if
      A(3, 1) = sin(x)
sympy.printing.fcode.print_fcode(expr, **settings)[source]

Prints the Fortran representation of the given expression.

See fcode for the meaning of the optional arguments.

class sympy.printing.fcode.FCodePrinter(settings={})[source]

A printer to convert sympy expressions to strings of Fortran code

printmethod = '_fcode'
indent_code(code)[source]

Accepts a string of code or a list of code lines

Two basic examples:

>>> from sympy import *
>>> x = symbols("x")
>>> fcode(sqrt(1-x**2))
'      sqrt(-x**2 + 1)'
>>> fcode((3 + 4*I)/(1 - conjugate(x)))
'      (cmplx(3,4))/(-conjg(x) + 1)'

An example where line wrapping is required:

>>> expr = sqrt(1-x**2).series(x,n=20).removeO()
>>> print(fcode(expr))
      -715.0d0/65536.0d0*x**18 - 429.0d0/32768.0d0*x**16 - 33.0d0/
     @ 2048.0d0*x**14 - 21.0d0/1024.0d0*x**12 - 7.0d0/256.0d0*x**10 -
     @ 5.0d0/128.0d0*x**8 - 1.0d0/16.0d0*x**6 - 1.0d0/8.0d0*x**4 - 1.0d0
     @ /2.0d0*x**2 + 1

In case of line wrapping, it is handy to include the assignment so that lines are wrapped properly when the assignment part is added.

>>> print(fcode(expr, assign_to="var"))
      var = -715.0d0/65536.0d0*x**18 - 429.0d0/32768.0d0*x**16 - 33.0d0/
     @ 2048.0d0*x**14 - 21.0d0/1024.0d0*x**12 - 7.0d0/256.0d0*x**10 -
     @ 5.0d0/128.0d0*x**8 - 1.0d0/16.0d0*x**6 - 1.0d0/8.0d0*x**4 - 1.0d0
     @ /2.0d0*x**2 + 1

For piecewise functions, the assign_to option is mandatory:

>>> print(fcode(Piecewise((x,x<1),(x**2,True)), assign_to="var"))
      if (x < 1) then
        var = x
      else
        var = x**2
      end if

Note that by default only top-level piecewise functions are supported due to the lack of a conditional operator in Fortran 77. Inline conditionals can be supported using the merge function introduced in Fortran 95 by setting of the kwarg standard=95:

>>> print(fcode(Piecewise((x,x<1),(x**2,True)), standard=95))
      merge(x, x**2, x < 1)

Loops are generated if there are Indexed objects in the expression. This also requires use of the assign_to option.

>>> A, B = map(IndexedBase, ['A', 'B'])
>>> m = Symbol('m', integer=True)
>>> i = Idx('i', m)
>>> print(fcode(2*B[i], assign_to=A[i]))
    do i = 1, m
        A(i) = 2*B(i)
    end do

Repeated indices in an expression with Indexed objects are interpreted as summation. For instance, code for the trace of a matrix can be generated with

>>> print(fcode(A[i, i], assign_to=x))
      x = 0
      do i = 1, m
          x = x + A(i, i)
      end do

By default, number symbols such as pi and E are detected and defined as Fortran parameters. The precision of the constants can be tuned with the precision argument. Parameter definitions are easily avoided using the N function.

>>> print(fcode(x - pi**2 - E))
      parameter (E = 2.71828182845905d0)
      parameter (pi = 3.14159265358979d0)
      x - pi**2 - E
>>> print(fcode(x - pi**2 - E, precision=25))
      parameter (E = 2.718281828459045235360287d0)
      parameter (pi = 3.141592653589793238462643d0)
      x - pi**2 - E
>>> print(fcode(N(x - pi**2, 25)))
      x - 9.869604401089358618834491d0

When some functions are not part of the Fortran standard, it might be desirable to introduce the names of user-defined functions in the Fortran expression.

>>> print(fcode(1 - gamma(x)**2, user_functions={'gamma': 'mygamma'}))
      -mygamma(x)**2 + 1

However, when the user_functions argument is not provided, fcode attempts to use a reasonable default and adds a comment to inform the user of the issue.

>>> print(fcode(1 - gamma(x)**2))
C     Not supported in Fortran:
C     gamma
      -gamma(x)**2 + 1

By default the output is human readable code, ready for copy and paste. With the option human=False, the return value is suitable for post-processing with source code generators that write routines with multiple instructions. The return value is a three-tuple containing: (i) a set of number symbols that must be defined as ‘Fortran parameters’, (ii) a list functions that can not be translated in pure Fortran and (iii) a string of Fortran code. A few examples:

>>> fcode(1 - gamma(x)**2, human=False)
(set(), set([gamma(x)]), '      -gamma(x)**2 + 1')
>>> fcode(1 - sin(x)**2, human=False)
(set(), set(), '      -sin(x)**2 + 1')
>>> fcode(x - pi**2, human=False)
(set([(pi, '3.14159265358979d0')]), set(), '      x - pi**2')

Mathematica code printing

sympy.printing.mathematica.known_functions = {'sinh': [(<function <lambda> at 0x7eff7aaa36e0>, 'Sinh')], 'asin': [(<function <lambda> at 0x7eff7aaa3578>, 'ArcSin')], 'cos': [(<function <lambda> at 0x7eff7aaa3410>, 'Cos')], 'atanh': [(<function <lambda> at 0x7eff7aaa3aa0>, 'ArcTanh')], 'acoth': [(<function <lambda> at 0x7eff7aaa3b18>, 'ArcCoth')], 'log': [(<function <lambda> at 0x7eff7aaa3320>, 'Log')], 'atan': [(<function <lambda> at 0x7eff7aaa3668>, 'ArcTan')], 'tanh': [(<function <lambda> at 0x7eff7aaa37d0>, 'Tanh')], 'acos': [(<function <lambda> at 0x7eff7aaa35f0>, 'ArcCos')], 'csch': [(<function <lambda> at 0x7eff7aaa3938>, 'Csch')], 'asinh': [(<function <lambda> at 0x7eff7aaa39b0>, 'ArcSinh')], 'cosh': [(<function <lambda> at 0x7eff7aaa3758>, 'Cosh')], 'exp': [(<function <lambda> at 0x7eff7aaa32a8>, 'Exp')], 'sech': [(<function <lambda> at 0x7eff7aaa38c0>, 'Sech')], 'acosh': [(<function <lambda> at 0x7eff7aaa3a28>, 'ArcCosh')], 'asech': [(<function <lambda> at 0x7eff7aaa3b90>, 'ArcSech')], 'tan': [(<function <lambda> at 0x7eff7aaa3488>, 'Tan')], 'sin': [(<function <lambda> at 0x7eff7aaa3398>, 'Sin')], 'coth': [(<function <lambda> at 0x7eff7aaa3848>, 'Coth')], 'cot': [(<function <lambda> at 0x7eff7aaa3500>, 'Cot')]}
class sympy.printing.mathematica.MCodePrinter(settings={})[source]

A printer to convert python expressions to strings of the Wolfram’s Mathematica code

printmethod = '_mcode'
doprint(expr)

Returns printer’s representation for expr (as a string)

sympy.printing.mathematica.mathematica_code(expr, **settings)[source]

Converts an expr to a string of the Wolfram Mathematica code

Examples

>>> from sympy import mathematica_code as mcode, symbols, sin
>>> x = symbols('x')
>>> mcode(sin(x).series(x).removeO())
'(1/120)*x^5 - 1/6*x^3 + x'

Javascript Code printing

sympy.printing.jscode.known_functions = {'ceiling': 'Math.ceil', 'atan': 'Math.atan', 'sign': 'Math.sign', 'Abs': 'Math.abs', 'tan': 'Math.tan', 'asin': 'Math.asin', 'cos': 'Math.cos', 'log': 'Math.log', 'floor': 'Math.floor', 'atan2': 'Math.atan2', 'exp': 'Math.exp', 'acos': 'Math.acos', 'sin': 'Math.sin'}
class sympy.printing.jscode.JavascriptCodePrinter(settings={})[source]

“A Printer to convert python expressions to strings of javascript code

printmethod = '_javascript'
indent_code(code)[source]

Accepts a string of code or a list of code lines

sympy.printing.jscode.jscode(expr, assign_to=None, **settings)[source]

Converts an expr to a string of javascript code

Parameters:

expr : Expr

A sympy expression to be converted.

assign_to : optional

When given, the argument is used as the name of the variable to which the expression is assigned. Can be a string, Symbol, MatrixSymbol, or Indexed type. This is helpful in case of line-wrapping, or for expressions that generate multi-line statements.

precision : integer, optional

The precision for numbers such as pi [default=15].

user_functions : dict, optional

A dictionary where keys are FunctionClass instances and values are their string representations. Alternatively, the dictionary value can be a list of tuples i.e. [(argument_test, js_function_string)]. See below for examples.

human : bool, optional

If True, the result is a single string that may contain some constant declarations for the number symbols. If False, the same information is returned in a tuple of (symbols_to_declare, not_supported_functions, code_text). [default=True].

contract: bool, optional

If True, Indexed instances are assumed to obey tensor contraction rules and the corresponding nested loops over indices are generated. Setting contract=False will not generate loops, instead the user is responsible to provide values for the indices in the code. [default=True].

Examples

>>> from sympy import jscode, symbols, Rational, sin, ceiling, Abs
>>> x, tau = symbols("x, tau")
>>> jscode((2*tau)**Rational(7, 2))
'8*Math.sqrt(2)*Math.pow(tau, 7/2)'
>>> jscode(sin(x), assign_to="s")
's = Math.sin(x);'

Custom printing can be defined for certain types by passing a dictionary of “type” : “function” to the user_functions kwarg. Alternatively, the dictionary value can be a list of tuples i.e. [(argument_test, js_function_string)].

>>> custom_functions = {
...   "ceiling": "CEIL",
...   "Abs": [(lambda x: not x.is_integer, "fabs"),
...           (lambda x: x.is_integer, "ABS")]
... }
>>> jscode(Abs(x) + ceiling(x), user_functions=custom_functions)
'fabs(x) + CEIL(x)'

Piecewise expressions are converted into conditionals. If an assign_to variable is provided an if statement is created, otherwise the ternary operator is used. Note that if the Piecewise lacks a default term, represented by (expr, True) then an error will be thrown. This is to prevent generating an expression that may not evaluate to anything.

>>> from sympy import Piecewise
>>> expr = Piecewise((x + 1, x > 0), (x, True))
>>> print(jscode(expr, tau))
if (x > 0) {
   tau = x + 1;
}
else {
   tau = x;
}

Support for loops is provided through Indexed types. With contract=True these expressions will be turned into loops, whereas contract=False will just print the assignment expression that should be looped over:

>>> from sympy import Eq, IndexedBase, Idx
>>> len_y = 5
>>> y = IndexedBase('y', shape=(len_y,))
>>> t = IndexedBase('t', shape=(len_y,))
>>> Dy = IndexedBase('Dy', shape=(len_y-1,))
>>> i = Idx('i', len_y-1)
>>> e=Eq(Dy[i], (y[i+1]-y[i])/(t[i+1]-t[i]))
>>> jscode(e.rhs, assign_to=e.lhs, contract=False)
'Dy[i] = (y[i + 1] - y[i])/(t[i + 1] - t[i]);'

Matrices are also supported, but a MatrixSymbol of the same dimensions must be provided to assign_to. Note that any expression that can be generated normally can also exist inside a Matrix:

>>> from sympy import Matrix, MatrixSymbol
>>> mat = Matrix([x**2, Piecewise((x + 1, x > 0), (x, True)), sin(x)])
>>> A = MatrixSymbol('A', 3, 1)
>>> print(jscode(mat, A))
A[0] = Math.pow(x, 2);
if (x > 0) {
   A[1] = x + 1;
}
else {
   A[1] = x;
}
A[2] = Math.sin(x);

Julia code printing

sympy.printing.julia.known_fcns_src1 = ['sin', 'cos', 'tan', 'cot', 'sec', 'csc', 'asin', 'acos', 'atan', 'acot', 'asec', 'acsc', 'sinh', 'cosh', 'tanh', 'coth', 'sech', 'csch', 'asinh', 'acosh', 'atanh', 'acoth', 'asech', 'sinc', 'atan2', 'sign', 'floor', 'log', 'exp', 'cbrt', 'sqrt', 'erf', 'erfc', 'erfi', 'factorial', 'gamma', 'digamma', 'trigamma', 'polygamma', 'beta', 'airyai', 'airyaiprime', 'airybi', 'airybiprime', 'besselj', 'bessely', 'besseli', 'besselk', 'erfinv', 'erfcinv']

list() -> new empty list list(iterable) -> new list initialized from iterable’s items

sympy.printing.julia.known_fcns_src2 = {'ceiling': 'ceil', 'hankel1': 'hankelh1', 'hankel2': 'hankelh2', 're': 'real', 'Abs': 'abs', 'im': 'imag', 'conjugate': 'conj'}
class sympy.printing.julia.JuliaCodePrinter(settings={})[source]

A printer to convert expressions to strings of Julia code.

printmethod = '_julia'
indent_code(code)[source]

Accepts a string of code or a list of code lines

sympy.printing.julia.julia_code(expr, assign_to=None, **settings)[source]

Converts \(expr\) to a string of Julia code.

Parameters:

expr : Expr

A sympy expression to be converted.

assign_to : optional

When given, the argument is used as the name of the variable to which the expression is assigned. Can be a string, Symbol, MatrixSymbol, or Indexed type. This can be helpful for expressions that generate multi-line statements.

precision : integer, optional

The precision for numbers such as pi [default=16].

user_functions : dict, optional

A dictionary where keys are FunctionClass instances and values are their string representations. Alternatively, the dictionary value can be a list of tuples i.e. [(argument_test, cfunction_string)]. See below for examples.

human : bool, optional

If True, the result is a single string that may contain some constant declarations for the number symbols. If False, the same information is returned in a tuple of (symbols_to_declare, not_supported_functions, code_text). [default=True].

contract: bool, optional

If True, Indexed instances are assumed to obey tensor contraction rules and the corresponding nested loops over indices are generated. Setting contract=False will not generate loops, instead the user is responsible to provide values for the indices in the code. [default=True].

inline: bool, optional

If True, we try to create single-statement code instead of multiple statements. [default=True].

Examples

>>> from sympy import julia_code, symbols, sin, pi
>>> x = symbols('x')
>>> julia_code(sin(x).series(x).removeO())
'x.^5/120 - x.^3/6 + x'

>>> from sympy import Rational, ceiling, Abs
>>> x, y, tau = symbols("x, y, tau")
>>> julia_code((2*tau)**Rational(7, 2))
'8*sqrt(2)*tau.^(7/2)'

Note that element-wise (Hadamard) operations are used by default between symbols. This is because its possible in Julia to write “vectorized” code. It is harmless if the values are scalars.

>>> julia_code(sin(pi*x*y), assign_to="s")
's = sin(pi*x.*y)'

If you need a matrix product “*” or matrix power “^”, you can specify the symbol as a MatrixSymbol.

>>> from sympy import Symbol, MatrixSymbol
>>> n = Symbol('n', integer=True, positive=True)
>>> A = MatrixSymbol('A', n, n)
>>> julia_code(3*pi*A**3)
'(3*pi)*A^3'

This class uses several rules to decide which symbol to use a product. Pure numbers use “*”, Symbols use ”.*” and MatrixSymbols use “*”. A HadamardProduct can be used to specify componentwise multiplication ”.*” of two MatrixSymbols. There is currently there is no easy way to specify scalar symbols, so sometimes the code might have some minor cosmetic issues. For example, suppose x and y are scalars and A is a Matrix, then while a human programmer might write “(x^2*y)*A^3”, we generate:

>>> julia_code(x**2*y*A**3)
'(x.^2.*y)*A^3'

Matrices are supported using Julia inline notation. When using assign_to with matrices, the name can be specified either as a string or as a MatrixSymbol. The dimenions must align in the latter case.

>>> from sympy import Matrix, MatrixSymbol
>>> mat = Matrix([[x**2, sin(x), ceiling(x)]])
>>> julia_code(mat, assign_to='A')
'A = [x.^2 sin(x) ceil(x)]'

Piecewise expressions are implemented with logical masking by default. Alternatively, you can pass “inline=False” to use if-else conditionals. Note that if the Piecewise lacks a default term, represented by (expr, True) then an error will be thrown. This is to prevent generating an expression that may not evaluate to anything.

>>> from sympy import Piecewise
>>> pw = Piecewise((x + 1, x > 0), (x, True))
>>> julia_code(pw, assign_to=tau)
'tau = ((x > 0) ? (x + 1) : (x))'

Note that any expression that can be generated normally can also exist inside a Matrix:

>>> mat = Matrix([[x**2, pw, sin(x)]])
>>> julia_code(mat, assign_to='A')
'A = [x.^2 ((x > 0) ? (x + 1) : (x)) sin(x)]'

Custom printing can be defined for certain types by passing a dictionary of “type” : “function” to the user_functions kwarg. Alternatively, the dictionary value can be a list of tuples i.e., [(argument_test, cfunction_string)]. This can be used to call a custom Julia function.

>>> from sympy import Function
>>> f = Function('f')
>>> g = Function('g')
>>> custom_functions = {
...   "f": "existing_julia_fcn",
...   "g": [(lambda x: x.is_Matrix, "my_mat_fcn"),
...         (lambda x: not x.is_Matrix, "my_fcn")]
... }
>>> mat = Matrix([[1, x]])
>>> julia_code(f(x) + g(x) + g(mat), user_functions=custom_functions)
'existing_julia_fcn(x) + my_fcn(x) + my_mat_fcn([1 x])'

Support for loops is provided through Indexed types. With contract=True these expressions will be turned into loops, whereas contract=False will just print the assignment expression that should be looped over:

>>> from sympy import Eq, IndexedBase, Idx, ccode
>>> len_y = 5
>>> y = IndexedBase('y', shape=(len_y,))
>>> t = IndexedBase('t', shape=(len_y,))
>>> Dy = IndexedBase('Dy', shape=(len_y-1,))
>>> i = Idx('i', len_y-1)
>>> e = Eq(Dy[i], (y[i+1]-y[i])/(t[i+1]-t[i]))
>>> julia_code(e.rhs, assign_to=e.lhs, contract=False)
'Dy[i] = (y[i + 1] - y[i])./(t[i + 1] - t[i])'

Octave (and Matlab) Code printing

sympy.printing.octave.known_fcns_src1 = ['sin', 'cos', 'tan', 'asin', 'acos', 'atan', 'atan2', 'sinh', 'cosh', 'tanh', 'asinh', 'acosh', 'atanh', 'log', 'exp', 'erf', 'gamma', 'sign', 'floor', 'csc', 'sec', 'cot', 'coth', 'acot', 'acoth', 'erfc', 'besselj', 'bessely', 'besseli', 'besselk', 'erfinv', 'erfcinv', 'factorial']

list() -> new empty list list(iterable) -> new list initialized from iterable’s items

sympy.printing.octave.known_fcns_src2 = {'ceiling': 'ceil', 'Abs': 'abs', 'DiracDelta': 'dirac', 'Heaviside': 'heaviside', 'conjugate': 'conj'}
class sympy.printing.octave.OctaveCodePrinter(settings={})[source]

A printer to convert expressions to strings of Octave/Matlab code.

printmethod = '_octave'
indent_code(code)[source]

Accepts a string of code or a list of code lines

sympy.printing.octave.octave_code(expr, assign_to=None, **settings)[source]

Converts \(expr\) to a string of Octave (or Matlab) code.

The string uses a subset of the Octave language for Matlab compatibility.

Parameters:

expr : Expr

A sympy expression to be converted.

assign_to : optional

When given, the argument is used as the name of the variable to which the expression is assigned. Can be a string, Symbol, MatrixSymbol, or Indexed type. This can be helpful for expressions that generate multi-line statements.

precision : integer, optional

The precision for numbers such as pi [default=16].

user_functions : dict, optional

A dictionary where keys are FunctionClass instances and values are their string representations. Alternatively, the dictionary value can be a list of tuples i.e. [(argument_test, cfunction_string)]. See below for examples.

human : bool, optional

If True, the result is a single string that may contain some constant declarations for the number symbols. If False, the same information is returned in a tuple of (symbols_to_declare, not_supported_functions, code_text). [default=True].

contract: bool, optional

If True, Indexed instances are assumed to obey tensor contraction rules and the corresponding nested loops over indices are generated. Setting contract=False will not generate loops, instead the user is responsible to provide values for the indices in the code. [default=True].

inline: bool, optional

If True, we try to create single-statement code instead of multiple statements. [default=True].

Examples

>>> from sympy import octave_code, symbols, sin, pi
>>> x = symbols('x')
>>> octave_code(sin(x).series(x).removeO())
'x.^5/120 - x.^3/6 + x'

>>> from sympy import Rational, ceiling, Abs
>>> x, y, tau = symbols("x, y, tau")
>>> octave_code((2*tau)**Rational(7, 2))
'8*sqrt(2)*tau.^(7/2)'

Note that element-wise (Hadamard) operations are used by default between symbols. This is because its very common in Octave to write “vectorized” code. It is harmless if the values are scalars.

>>> octave_code(sin(pi*x*y), assign_to="s")
's = sin(pi*x.*y);'

If you need a matrix product “*” or matrix power “^”, you can specify the symbol as a MatrixSymbol.

>>> from sympy import Symbol, MatrixSymbol
>>> n = Symbol('n', integer=True, positive=True)
>>> A = MatrixSymbol('A', n, n)
>>> octave_code(3*pi*A**3)
'(3*pi)*A^3'

This class uses several rules to decide which symbol to use a product. Pure numbers use “*”, Symbols use ”.*” and MatrixSymbols use “*”. A HadamardProduct can be used to specify componentwise multiplication ”.*” of two MatrixSymbols. There is currently there is no easy way to specify scalar symbols, so sometimes the code might have some minor cosmetic issues. For example, suppose x and y are scalars and A is a Matrix, then while a human programmer might write “(x^2*y)*A^3”, we generate:

>>> octave_code(x**2*y*A**3)
'(x.^2.*y)*A^3'

Matrices are supported using Octave inline notation. When using assign_to with matrices, the name can be specified either as a string or as a MatrixSymbol. The dimenions must align in the latter case.

>>> from sympy import Matrix, MatrixSymbol
>>> mat = Matrix([[x**2, sin(x), ceiling(x)]])
>>> octave_code(mat, assign_to='A')
'A = [x.^2 sin(x) ceil(x)];'

Piecewise expressions are implemented with logical masking by default. Alternatively, you can pass “inline=False” to use if-else conditionals. Note that if the Piecewise lacks a default term, represented by (expr, True) then an error will be thrown. This is to prevent generating an expression that may not evaluate to anything.

>>> from sympy import Piecewise
>>> pw = Piecewise((x + 1, x > 0), (x, True))
>>> octave_code(pw, assign_to=tau)
'tau = ((x > 0).*(x + 1) + (~(x > 0)).*(x));'

Note that any expression that can be generated normally can also exist inside a Matrix:

>>> mat = Matrix([[x**2, pw, sin(x)]])
>>> octave_code(mat, assign_to='A')
'A = [x.^2 ((x > 0).*(x + 1) + (~(x > 0)).*(x)) sin(x)];'

Custom printing can be defined for certain types by passing a dictionary of “type” : “function” to the user_functions kwarg. Alternatively, the dictionary value can be a list of tuples i.e., [(argument_test, cfunction_string)]. This can be used to call a custom Octave function.

>>> from sympy import Function
>>> f = Function('f')
>>> g = Function('g')
>>> custom_functions = {
...   "f": "existing_octave_fcn",
...   "g": [(lambda x: x.is_Matrix, "my_mat_fcn"),
...         (lambda x: not x.is_Matrix, "my_fcn")]
... }
>>> mat = Matrix([[1, x]])
>>> octave_code(f(x) + g(x) + g(mat), user_functions=custom_functions)
'existing_octave_fcn(x) + my_fcn(x) + my_mat_fcn([1 x])'

Support for loops is provided through Indexed types. With contract=True these expressions will be turned into loops, whereas contract=False will just print the assignment expression that should be looped over:

>>> from sympy import Eq, IndexedBase, Idx, ccode
>>> len_y = 5
>>> y = IndexedBase('y', shape=(len_y,))
>>> t = IndexedBase('t', shape=(len_y,))
>>> Dy = IndexedBase('Dy', shape=(len_y-1,))
>>> i = Idx('i', len_y-1)
>>> e = Eq(Dy[i], (y[i+1]-y[i])/(t[i+1]-t[i]))
>>> octave_code(e.rhs, assign_to=e.lhs, contract=False)
'Dy(i) = (y(i + 1) - y(i))./(t(i + 1) - t(i));'

Theano Code printing

class sympy.printing.theanocode.TheanoPrinter(*args, **kwargs)[source]

Code printer for Theano computations

printmethod = '_theano'
doprint(expr, **kwargs)[source]

Returns printer’s representation for expr (as a string)

sympy.printing.theanocode.theano_function(inputs, outputs, dtypes={}, cache=None, **kwargs)[source]

Create Theano function from SymPy expressions

Gtk

You can print to a grkmathview widget using the function print_gtk located in sympy.printing.gtk (it requires to have installed gtkmatmatview and libgtkmathview-bin in some systems).

GtkMathView accepts MathML, so this rendering depends on the MathML representation of the expression.

Usage:

from sympy import *
print_gtk(x**2 + 2*exp(x**3))
sympy.printing.gtk.print_gtk(x, start_viewer=True)[source]

Print to Gtkmathview, a gtk widget capable of rendering MathML.

Needs libgtkmathview-bin

LambdaPrinter

This classes implements printing to strings that can be used by the sympy.utilities.lambdify.lambdify() function.

class sympy.printing.lambdarepr.LambdaPrinter(settings=None)[source]

This printer converts expressions into strings that can be used by lambdify.

printmethod = '_sympystr'
sympy.printing.lambdarepr.lambdarepr(expr, **settings)[source]

Returns a string usable for lambdifying.

LatexPrinter

This class implements LaTeX printing. See sympy.printing.latex.

sympy.printing.latex.accepted_latex_functions = ['arcsin', 'arccos', 'arctan', 'sin', 'cos', 'tan', 'sinh', 'cosh', 'tanh', 'sqrt', 'ln', 'log', 'sec', 'csc', 'cot', 'coth', 're', 'im', 'frac', 'root', 'arg']

list() -> new empty list list(iterable) -> new list initialized from iterable’s items

class sympy.printing.latex.LatexPrinter(settings=None)[source]
printmethod = '_latex'
sympy.printing.latex.latex(expr, **settings)[source]

Convert the given expression to LaTeX representation.

>>> from sympy import latex, pi, sin, asin, Integral, Matrix, Rational
>>> from sympy.abc import x, y, mu, r, tau

>>> print(latex((2*tau)**Rational(7,2)))
8 \sqrt{2} \tau^{\frac{7}{2}}

Not using a print statement for printing, results in double backslashes for latex commands since that’s the way Python escapes backslashes in strings.

>>> latex((2*tau)**Rational(7,2))
'8 \\sqrt{2} \\tau^{\\frac{7}{2}}'

order: Any of the supported monomial orderings (currently “lex”, “grlex”, or “grevlex”), “old”, and “none”. This parameter does nothing for Mul objects. Setting order to “old” uses the compatibility ordering for Add defined in Printer. For very large expressions, set the ‘order’ keyword to ‘none’ if speed is a concern.

mode: Specifies how the generated code will be delimited. ‘mode’ can be one of ‘plain’, ‘inline’, ‘equation’ or ‘equation*’. If ‘mode’ is set to ‘plain’, then the resulting code will not be delimited at all (this is the default). If ‘mode’ is set to ‘inline’ then inline LaTeX $ $ will be used. If ‘mode’ is set to ‘equation’ or ‘equation*’, the resulting code will be enclosed in the ‘equation’ or ‘equation*’ environment (remember to import ‘amsmath’ for ‘equation*’), unless the ‘itex’ option is set. In the latter case, the $$ $$ syntax is used.

>>> print(latex((2*mu)**Rational(7,2), mode='plain'))
8 \sqrt{2} \mu^{\frac{7}{2}}

>>> print(latex((2*tau)**Rational(7,2), mode='inline'))
$8 \sqrt{2} \tau^{\frac{7}{2}}$

>>> print(latex((2*mu)**Rational(7,2), mode='equation*'))
\begin{equation*}8 \sqrt{2} \mu^{\frac{7}{2}}\end{equation*}

>>> print(latex((2*mu)**Rational(7,2), mode='equation'))
\begin{equation}8 \sqrt{2} \mu^{\frac{7}{2}}\end{equation}

itex: Specifies if itex-specific syntax is used, including emitting $$ $$.

>>> print(latex((2*mu)**Rational(7,2), mode='equation', itex=True))
$$8 \sqrt{2} \mu^{\frac{7}{2}}$$

fold_frac_powers: Emit “^{p/q}” instead of “^{frac{p}{q}}” for fractional powers.

>>> print(latex((2*tau)**Rational(7,2), fold_frac_powers=True))
8 \sqrt{2} \tau^{7/2}

fold_func_brackets: Fold function brackets where applicable.

>>> print(latex((2*tau)**sin(Rational(7,2))))
\left(2 \tau\right)^{\sin{\left (\frac{7}{2} \right )}}
>>> print(latex((2*tau)**sin(Rational(7,2)), fold_func_brackets = True))
\left(2 \tau\right)^{\sin {\frac{7}{2}}}

fold_short_frac: Emit “p / q” instead of “frac{p}{q}” when the denominator is simple enough (at most two terms and no powers). The default value is \(True\) for inline mode, False otherwise.

>>> print(latex(3*x**2/y))
\frac{3 x^{2}}{y}
>>> print(latex(3*x**2/y, fold_short_frac=True))
3 x^{2} / y

long_frac_ratio: The allowed ratio of the width of the numerator to the width of the denominator before we start breaking off long fractions. The default value is 2.

>>> print(latex(Integral(r, r)/2/pi, long_frac_ratio=2))
\frac{\int r\, dr}{2 \pi}
>>> print(latex(Integral(r, r)/2/pi, long_frac_ratio=0))
\frac{1}{2 \pi} \int r\, dr

mul_symbol: The symbol to use for multiplication. Can be one of None, “ldot”, “dot”, or “times”.

>>> print(latex((2*tau)**sin(Rational(7,2)), mul_symbol="times"))
\left(2 \times \tau\right)^{\sin{\left (\frac{7}{2} \right )}}

inv_trig_style: How inverse trig functions should be displayed. Can be one of “abbreviated”, “full”, or “power”. Defaults to “abbreviated”.

>>> print(latex(asin(Rational(7,2))))
\operatorname{asin}{\left (\frac{7}{2} \right )}
>>> print(latex(asin(Rational(7,2)), inv_trig_style="full"))
\arcsin{\left (\frac{7}{2} \right )}
>>> print(latex(asin(Rational(7,2)), inv_trig_style="power"))
\sin^{-1}{\left (\frac{7}{2} \right )}

mat_str: Which matrix environment string to emit. “smallmatrix”, “matrix”, “array”, etc. Defaults to “smallmatrix” for inline mode, “matrix” for matrices of no more than 10 columns, and “array” otherwise.

>>> print(latex(Matrix(2, 1, [x, y])))
\left[\begin{matrix}x\\y\end{matrix}\right]

>>> print(latex(Matrix(2, 1, [x, y]), mat_str = "array"))
\left[\begin{array}{c}x\\y\end{array}\right]

mat_delim: The delimiter to wrap around matrices. Can be one of “[”, “(”, or the empty string. Defaults to “[”.

>>> print(latex(Matrix(2, 1, [x, y]), mat_delim="("))
\left(\begin{matrix}x\\y\end{matrix}\right)

symbol_names: Dictionary of symbols and the custom strings they should be emitted as.

>>> print(latex(x**2, symbol_names={x:'x_i'}))
x_i^{2}

latex also supports the builtin container types list, tuple, and dictionary.

>>> print(latex([2/x, y], mode='inline'))
$\left [ 2 / x, \quad y\right ]$
sympy.printing.latex.print_latex(expr, **settings)[source]

Prints LaTeX representation of the given expression.

MathMLPrinter

This class is responsible for MathML printing. See sympy.printing.mathml.

More info on mathml content: http://www.w3.org/TR/MathML2/chapter4.html

class sympy.printing.mathml.MathMLPrinter(settings=None)[source]

Prints an expression to the MathML markup language

Whenever possible tries to use Content markup and not Presentation markup.

References: http://www.w3.org/TR/MathML2/

printmethod = '_mathml'
doprint(expr)[source]

Prints the expression as MathML.

mathml_tag(e)[source]

Returns the MathML tag for an expression.

sympy.printing.mathml.mathml(expr, **settings)[source]

Returns the MathML representation of expr

sympy.printing.mathml.print_mathml(expr, **settings)[source]

Prints a pretty representation of the MathML code for expr

Examples

>>> ##
>>> from sympy.printing.mathml import print_mathml
>>> from sympy.abc import x
>>> print_mathml(x+1) 
<apply>
    <plus/>
    <ci>x</ci>
    <cn>1</cn>
</apply>

PythonPrinter

This class implements Python printing. Usage:

>>> from sympy import print_python, sin
>>> from sympy.abc import x

>>> print_python(5*x**3 + sin(x))
x = Symbol('x')
e = 5*x**3 + sin(x)

srepr

This printer generates executable code. This code satisfies the identity eval(srepr(expr)) == expr.

srepr() gives more low level textual output than repr()

Example:

>>> repr(5*x**3 + sin(x))
'5*x**3 + sin(x)'

>>> srepr(5*x**3 + sin(x))
"Add(Mul(Integer(5), Pow(Symbol('x'), Integer(3))), sin(Symbol('x')))"

srepr() gives the repr form, which is what repr() would normally give but for SymPy we don’t actually use srepr() for __repr__ because it’s is so verbose, it is unlikely that anyone would want it called by default. Another reason is that lists call repr on their elements, like print([a, b, c]) calls repr(a), repr(b), repr(c). So if we used srepr for `` __repr__`` any list with SymPy objects would include the srepr form, even if we used str() or print().

class sympy.printing.repr.ReprPrinter(settings=None)[source]
printmethod = '_sympyrepr'
emptyPrinter(expr)[source]

The fallback printer.

reprify(args, sep)[source]

Prints each item in \(args\) and joins them with \(sep\).

sympy.printing.repr.srepr(expr, **settings)[source]

return expr in repr form

StrPrinter

This module generates readable representations of SymPy expressions.

class sympy.printing.str.StrPrinter(settings=None)[source]
printmethod = '_sympystr'
sympy.printing.str.sstrrepr(expr, **settings)[source]

return expr in mixed str/repr form

i.e. strings are returned in repr form with quotes, and everything else is returned in str form.

This function could be useful for hooking into sys.displayhook

Tree Printing

The functions in this module create a representation of an expression as a tree.

sympy.printing.tree.pprint_nodes(subtrees)[source]

Prettyprints systems of nodes.

Examples

>>> from sympy.printing.tree import pprint_nodes
>>> print(pprint_nodes(["a", "b1\nb2", "c"]))
+-a
+-b1
| b2
+-c
sympy.printing.tree.print_node(node)[source]

Returns information about the “node”.

This includes class name, string representation and assumptions.

sympy.printing.tree.tree(node)[source]

Returns a tree representation of “node” as a string.

It uses print_node() together with pprint_nodes() on node.args recursively.

See also: print_tree()

sympy.printing.tree.print_tree(node)[source]

Prints a tree representation of “node”.

Examples

>>> from sympy.printing import print_tree
>>> from sympy import Symbol
>>> x = Symbol('x', odd=True)
>>> y = Symbol('y', even=True)
>>> print_tree(y**x)
Pow: y**x
+-Symbol: y
| algebraic: True
| commutative: True
| complex: True
| even: True
| hermitian: True
| imaginary: False
| integer: True
| irrational: False
| noninteger: False
| odd: False
| rational: True
| real: True
| transcendental: False
+-Symbol: x
  algebraic: True
  commutative: True
  complex: True
  even: False
  hermitian: True
  imaginary: False
  integer: True
  irrational: False
  noninteger: False
  nonzero: True
  odd: True
  rational: True
  real: True
  transcendental: False
  zero: False

See also: tree()

Preview

A useful function is preview:

sympy.printing.preview.preview(expr, output='png', viewer=None, euler=True, packages=(), filename=None, outputbuffer=None, preamble=None, dvioptions=None, outputTexFile=None, **latex_settings)[source]

View expression or LaTeX markup in PNG, DVI, PostScript or PDF form.

If the expr argument is an expression, it will be exported to LaTeX and then compiled using the available TeX distribution. The first argument, ‘expr’, may also be a LaTeX string. The function will then run the appropriate viewer for the given output format or use the user defined one. By default png output is generated.

By default pretty Euler fonts are used for typesetting (they were used to typeset the well known “Concrete Mathematics” book). For that to work, you need the ‘eulervm.sty’ LaTeX style (in Debian/Ubuntu, install the texlive-fonts-extra package). If you prefer default AMS fonts or your system lacks ‘eulervm’ LaTeX package then unset the ‘euler’ keyword argument.

To use viewer auto-detection, lets say for ‘png’ output, issue

>>> from sympy import symbols, preview, Symbol
>>> x, y = symbols("x,y")

>>> preview(x + y, output='png')

This will choose ‘pyglet’ by default. To select a different one, do

>>> preview(x + y, output='png', viewer='gimp')

The ‘png’ format is considered special. For all other formats the rules are slightly different. As an example we will take ‘dvi’ output format. If you would run

>>> preview(x + y, output='dvi')

then ‘view’ will look for available ‘dvi’ viewers on your system (predefined in the function, so it will try evince, first, then kdvi and xdvi). If nothing is found you will need to set the viewer explicitly.

>>> preview(x + y, output='dvi', viewer='superior-dvi-viewer')

This will skip auto-detection and will run user specified ‘superior-dvi-viewer’. If ‘view’ fails to find it on your system it will gracefully raise an exception.

You may also enter ‘file’ for the viewer argument. Doing so will cause this function to return a file object in read-only mode, if ‘filename’ is unset. However, if it was set, then ‘preview’ writes the genereted file to this filename instead.

There is also support for writing to a BytesIO like object, which needs to be passed to the ‘outputbuffer’ argument.

>>> from io import BytesIO
>>> obj = BytesIO()
>>> preview(x + y, output='png', viewer='BytesIO',
...         outputbuffer=obj)

The LaTeX preamble can be customized by setting the ‘preamble’ keyword argument. This can be used, e.g., to set a different font size, use a custom documentclass or import certain set of LaTeX packages.

>>> preamble = "\\documentclass[10pt]{article}\n" \
...            "\\usepackage{amsmath,amsfonts}\\begin{document}"
>>> preview(x + y, output='png', preamble=preamble)

If the value of ‘output’ is different from ‘dvi’ then command line options can be set (‘dvioptions’ argument) for the execution of the ‘dvi’+output conversion tool. These options have to be in the form of a list of strings (see subprocess.Popen).

Additional keyword args will be passed to the latex call, e.g., the symbol_names flag.

>>> phidd = Symbol('phidd')
>>> preview(phidd, symbol_names={phidd:r'\ddot{\varphi}'})

For post-processing the generated TeX File can be written to a file by passing the desired filename to the ‘outputTexFile’ keyword argument. To write the TeX code to a file named “sample.tex” and run the default png viewer to display the resulting bitmap, do

>>> preview(x + y, outputTexFile="sample.tex")

Implementation - Helper Classes/Functions

sympy.printing.conventions.split_super_sub(text)[source]

Split a symbol name into a name, superscripts and subscripts

The first part of the symbol name is considered to be its actual ‘name’, followed by super- and subscripts. Each superscript is preceded with a “^” character or by “__”. Each subscript is preceded by a “_” character. The three return values are the actual name, a list with superscripts and a list with subscripts.

>>> from sympy.printing.conventions import split_super_sub
>>> split_super_sub('a_x^1')
('a', ['1'], ['x'])
>>> split_super_sub('var_sub1__sup_sub2')
('var', ['sup'], ['sub1', 'sub2'])

CodePrinter

This class is a base class for other classes that implement code-printing functionality, and additionally lists a number of functions that cannot be easily translated to C or Fortran.

class sympy.printing.codeprinter.Assignment[source]

Represents variable assignment for code generation.

Parameters:

lhs : Expr

Sympy object representing the lhs of the expression. These should be singular objects, such as one would use in writing code. Notable types include Symbol, MatrixSymbol, MatrixElement, and Indexed. Types that subclass these types are also supported.

rhs : Expr

Sympy object representing the rhs of the expression. This can be any type, provided its shape corresponds to that of the lhs. For example, a Matrix type can be assigned to MatrixSymbol, but not to Symbol, as the dimensions will not align.

Examples

>>> from sympy import symbols, MatrixSymbol, Matrix
>>> from sympy.printing.codeprinter import Assignment
>>> x, y, z = symbols('x, y, z')
>>> Assignment(x, y)
Assignment(x, y)
>>> Assignment(x, 0)
Assignment(x, 0)
>>> A = MatrixSymbol('A', 1, 3)
>>> mat = Matrix([x, y, z]).T
>>> Assignment(A, mat)
Assignment(A, Matrix([[x, y, z]]))
>>> Assignment(A[0, 1], x)
Assignment(A[0, 1], x)
class sympy.printing.codeprinter.CodePrinter(settings=None)[source]

The base class for code-printing subclasses.

printmethod = '_sympystr'
exception sympy.printing.codeprinter.AssignmentError[source]

Raised if an assignment variable for a loop is missing.

Precedence

sympy.printing.precedence.PRECEDENCE = {'Xor': 10, 'Add': 40, 'Relational': 35, 'Mul': 50, 'Or': 20, 'Lambda': 1, 'And': 30, 'Pow': 60, 'Func': 70, 'Atom': 1000, 'Not': 100}

Default precedence values for some basic types.

sympy.printing.precedence.PRECEDENCE_VALUES = {'And': 30, 'Function': 70, 'Xor': 10, 'Sub': 40, 'Pow': 60, 'Equivalent': 10, 'MatMul': 50, 'MatPow': 60, 'Add': 40, 'MatAdd': 40, 'Relational': 35, 'Not': 100, 'Implies': 10, 'HadamardProduct': 50, 'Or': 20, 'NegativeInfinity': 40}

A dictionary assigning precedence values to certain classes. These values are treated like they were inherited, so not every single class has to be named here.

sympy.printing.precedence.PRECEDENCE_FUNCTIONS = {'FracElement': <function precedence_FracElement at 0x7eff7ab638c0>, 'PolyElement': <function precedence_PolyElement at 0x7eff7ab63848>, 'Float': <function precedence_Float at 0x7eff7ab637d0>, 'Rational': <function precedence_Rational at 0x7eff7ab636e0>, 'Mul': <function precedence_Mul at 0x7eff7ab63668>, 'Integer': <function precedence_Integer at 0x7eff7ab63758>}

Sometimes it’s not enough to assign a fixed precedence value to a class. Then a function can be inserted in this dictionary that takes an instance of this class as argument and returns the appropriate precedence value.

sympy.printing.precedence.precedence(item)[source]

Returns the precedence of a given object.

Pretty-Printing Implementation Helpers

sympy.printing.pretty.pretty_symbology.U(name)[source]

unicode character by name or None if not found

sympy.printing.pretty.pretty_symbology.pretty_use_unicode(flag=None)[source]

Set whether pretty-printer should use unicode by default

sympy.printing.pretty.pretty_symbology.pretty_try_use_unicode()[source]

See if unicode output is available and leverage it if possible

sympy.printing.pretty.pretty_symbology.xstr(*args)[source]

call str or unicode depending on current mode

The following two functions return the Unicode version of the inputted Greek letter.

sympy.printing.pretty.pretty_symbology.g(l)
sympy.printing.pretty.pretty_symbology.G(l)
sympy.printing.pretty.pretty_symbology.greek_letters = ['alpha', 'beta', 'gamma', 'delta', 'epsilon', 'zeta', 'eta', 'theta', 'iota', 'kappa', 'lamda', 'mu', 'nu', 'xi', 'omicron', 'pi', 'rho', 'sigma', 'tau', 'upsilon', 'phi', 'chi', 'psi', 'omega']

list() -> new empty list list(iterable) -> new list initialized from iterable’s items

sympy.printing.pretty.pretty_symbology.digit_2txt = {'1': 'ONE', '0': 'ZERO', '3': 'THREE', '2': 'TWO', '5': 'FIVE', '4': 'FOUR', '7': 'SEVEN', '6': 'SIX', '9': 'NINE', '8': 'EIGHT'}
sympy.printing.pretty.pretty_symbology.symb_2txt = {'int': 'INTEGRAL', '{}': 'CURLY BRACKET', '[': 'LEFT SQUARE BRACKET', ']': 'RIGHT SQUARE BRACKET', ')': 'RIGHT PARENTHESIS', '(': 'LEFT PARENTHESIS', 'sum': 'SUMMATION', '=': 'EQUALS SIGN', '-': 'MINUS', '{': 'LEFT CURLY BRACKET', '}': 'RIGHT CURLY BRACKET', '+': 'PLUS SIGN'}

The following functions return the Unicode subscript/superscript version of the character.

sympy.printing.pretty.pretty_symbology.sub = {')': u'\u208e', 'chi': u'\u1d6a', '+': u'\u208a', '-': u'\u208b', '1': u'\u2081', '0': u'\u2080', '3': u'\u2083', '2': u'\u2082', '5': u'\u2085', '4': u'\u2084', '7': u'\u2087', '6': u'\u2086', '9': u'\u2089', '8': u'\u2088', '=': u'\u208c', 'phi': u'\u1d69', 'beta': u'\u1d66', 'rho': u'\u1d68', '(': u'\u208d', 'a': u'\u2090', 'e': u'\u2091', 'i': u'\u1d62', 'h': None, 'k': None, 'm': None, 'l': None, 'o': u'\u2092', 'n': None, 'p': None, 's': None, 'r': u'\u1d63', 'u': u'\u1d64', 't': None, 'v': u'\u1d65', 'x': u'\u2093', 'gamma': u'\u1d67'}
sympy.printing.pretty.pretty_symbology.sup = {')': u'\u207e', 'i': u'\u2071', '(': u'\u207d', '+': u'\u207a', '-': u'\u207b', 'n': u'\u207f', '1': u'\xb9', '0': u'\u2070', '3': u'\xb3', '2': u'\xb2', '5': u'\u2075', '4': u'\u2074', '7': u'\u2077', '6': u'\u2076', '9': u'\u2079', '8': u'\u2078', '=': u'\u207c'}

The following functions return Unicode vertical objects.

sympy.printing.pretty.pretty_symbology.xobj(symb, length)[source]

Construct spatial object of given length.

return: [] of equal-length strings

sympy.printing.pretty.pretty_symbology.vobj(symb, height)[source]

Construct vertical object of a given height

see: xobj

sympy.printing.pretty.pretty_symbology.hobj(symb, width)[source]

Construct horizontal object of a given width

see: xobj

The following constants are for rendering roots and fractions.

sympy.printing.pretty.pretty_symbology.root = {2: u'\u221a', 3: u'\u221b', 4: u'\u221c'}
sympy.printing.pretty.pretty_symbology.VF(txt)
sympy.printing.pretty.pretty_symbology.frac = {(1, 3): u'\u2153', (5, 6): u'\u215a', (1, 4): u'\xbc', (2, 3): u'\u2154', (2, 5): u'\u2156', (5, 8): u'\u215d', (3, 5): u'\u2157', (1, 2): u'\xbd', (7, 8): u'\u215e', (3, 8): u'\u215c', (1, 5): u'\u2155', (1, 8): u'\u215b', (4, 5): u'\u2158', (1, 6): u'\u2159', (3, 4): u'\xbe'}

The following constants/functions are for rendering atoms and symbols.

sympy.printing.pretty.pretty_symbology.xsym(sym)[source]

get symbology for a ‘character’

sympy.printing.pretty.pretty_symbology.atoms_table = {'Integers': u'\u2124', 'NegativeInfinity': u'-\u221e', 'Union': u'\u222a', 'Exp1': u'\u212f', 'EmptySet': u'\u2205', 'Naturals0': u'\u2115\u2080', 'Reals': u'\u211d', 'Pi': u'\u03c0', 'ImaginaryUnit': u'\u2148', 'SymmetricDifference': u'\u2206', 'Infinity': u'\u221e', 'Complexes': u'\u2102', 'Naturals': u'\u2115', 'Ring': u'\u2218', 'Intersection': u'\u2229'}
sympy.printing.pretty.pretty_symbology.pretty_atom(atom_name, default=None)[source]

return pretty representation of an atom

sympy.printing.pretty.pretty_symbology.pretty_symbol(symb_name)[source]

return pretty representation of a symbol

sympy.printing.pretty.pretty_symbology.annotated(letter)[source]

Return a stylised drawing of the letter letter, together with information on how to put annotations (super- and subscripts to the left and to the right) on it.

See pretty.py functions _print_meijerg, _print_hyper on how to use this information.

Prettyprinter by Jurjen Bos. (I hate spammers: mail me at pietjepuk314 at the reverse of ku.oc.oohay). All objects have a method that create a “stringPict”, that can be used in the str method for pretty printing.

Updates by Jason Gedge (email <my last name> at cs mun ca)
  • terminal_string() method
  • minor fixes and changes (mostly to prettyForm)
TODO:
  • Allow left/center/right alignment options for above/below and top/center/bottom alignment options for left/right
class sympy.printing.pretty.stringpict.stringPict(s, baseline=0)[source]

An ASCII picture. The pictures are represented as a list of equal length strings.

above(*args)[source]

Put pictures above this picture. Returns string, baseline arguments for stringPict. Baseline is baseline of bottom picture.

below(*args)[source]

Put pictures under this picture. Returns string, baseline arguments for stringPict. Baseline is baseline of top picture

Examples

>>> from sympy.printing.pretty.stringpict import stringPict
>>> print(stringPict("x+3").below(
...       stringPict.LINE, '3')[0]) 
x+3
---
 3
height()[source]

The height of the picture in characters.

left(*args)[source]

Put pictures (left to right) at left. Returns string, baseline arguments for stringPict.

leftslash()[source]

Precede object by a slash of the proper size.

static next(*args)[source]

Put a string of stringPicts next to each other. Returns string, baseline arguments for stringPict.

parens(left='(', right=')', ifascii_nougly=False)[source]

Put parentheses around self. Returns string, baseline arguments for stringPict.

left or right can be None or empty string which means ‘no paren from that side’

render(*args, **kwargs)[source]

Return the string form of self.

Unless the argument line_break is set to False, it will break the expression in a form that can be printed on the terminal without being broken up.

right(*args)[source]

Put pictures next to this one. Returns string, baseline arguments for stringPict. (Multiline) strings are allowed, and are given a baseline of 0.

Examples

>>> from sympy.printing.pretty.stringpict import stringPict
>>> print(stringPict("10").right(" + ",stringPict("1\r-\r2",1))[0])
     1
10 + -
     2
root(n=None)[source]

Produce a nice root symbol. Produces ugly results for big n inserts.

static stack(*args)[source]

Put pictures on top of each other, from top to bottom. Returns string, baseline arguments for stringPict. The baseline is the baseline of the second picture. Everything is centered. Baseline is the baseline of the second picture. Strings are allowed. The special value stringPict.LINE is a row of ‘-‘ extended to the width.

terminal_width()[source]

Return the terminal width if possible, otherwise return 0.

width()[source]

The width of the picture in characters.

class sympy.printing.pretty.stringpict.prettyForm(s, baseline=0, binding=0, unicode=None)[source]

Extension of the stringPict class that knows about basic math applications, optimizing double minus signs.

“Binding” is interpreted as follows:

ATOM this is an atom: never needs to be parenthesized
FUNC this is a function application: parenthesize if added (?)
DIV  this is a division: make wider division if divided
POW  this is a power: only parenthesize if exponent
MUL  this is a multiplication: parenthesize if powered
ADD  this is an addition: parenthesize if multiplied or powered
NEG  this is a negative number: optimize if added, parenthesize if
     multiplied or powered
OPEN this is an open object: parenthesize if added, multiplied, or
     powered (example: Piecewise)
static apply(function, *args)[source]

Functions of one or more variables.

dotprint

sympy.printing.dot.dotprint(expr, styles=[(<class 'sympy.core.basic.Basic'>, {'color': 'blue', 'shape': 'ellipse'}), (<class 'sympy.core.expr.Expr'>, {'color': 'black'})], atom=<function <lambda>>, maxdepth=None, repeat=True, labelfunc=<type 'str'>, **kwargs)[source]

DOT description of a SymPy expression tree

Options are

styles: Styles for different classes. The default is:

[(Basic, {'color': 'blue', 'shape': 'ellipse'}),
(Expr, {'color': 'black'})]``
atom: Function used to determine if an arg is an atom. The default is
lambda x: not isinstance(x, Basic). Another good choice is lambda x: not x.args.

maxdepth: The maximum depth. The default is None, meaning no limit.

repeat: Whether to different nodes for separate common subexpressions.
The default is True. For example, for x + x*y with repeat=True, it will have two nodes for x and with repeat=False, it will have one (warning: even if it appears twice in the same object, like Pow(x, x), it will still only appear only once. Hence, with repeat=False, the number of arrows out of an object might not equal the number of args it has).
labelfunc: How to label leaf nodes. The default is str. Another
good option is srepr. For example with str, the leaf nodes of x + 1 are labeled, x and 1. With srepr, they are labeled Symbol('x') and Integer(1).

Additional keyword arguments are included as styles for the graph.

Examples

>>> from sympy.printing.dot import dotprint
>>> from sympy.abc import x
>>> print(dotprint(x+2)) 
digraph{

# Graph style
"ordering"="out"
"rankdir"="TD"

#########
# Nodes #
#########

"Add(Integer(2), Symbol(x))_()" ["color"="black", "label"="Add", "shape"="ellipse"];
"Integer(2)_(0,)" ["color"="black", "label"="2", "shape"="ellipse"];
"Symbol(x)_(1,)" ["color"="black", "label"="x", "shape"="ellipse"];

#########
# Edges #
#########

"Add(Integer(2), Symbol(x))_()" -> "Integer(2)_(0,)";
"Add(Integer(2), Symbol(x))_()" -> "Symbol(x)_(1,)";
}