doc/src/tutorial.txt

   1 .. _tutorial:
   2
   3 ========
   4 Tutorial
   5 ========
   6
   7 .. role:: input(strong)
   8
   9 Introduction
  10 ============
  11
  12 SymPy is a Python library for symbolic mathematics. It aims to become a
  13 full-featured computer algebra system (CAS) while keeping the code as simple as
  14 possible in order to be comprehensible and easily extensible.  SymPy is written
  15 entirely in Python and does not require any external libraries.
  16
  17 This tutorial gives an overview and introduction to SymPy.
  18 Read this to have an idea what SymPy can do for you (and how) and if you want
  19 to know more, read the
  20 :ref:`SymPy User's Guide <guide>`,
  21 :ref:`SymPy Modules Reference <module-docs>`.
  22 or the `sources
  23 <http://hg.sympy.org/sympy/file/tip>`_ directly.
  24
  25 First Steps with SymPy
  26 ======================
  27
  28 The easiest way to download it is to go to
  29 http://code.google.com/p/sympy/ and
  30 download the latest tarball from the Featured Downloads:
  31
  32 .. image:: figures/featured-downloads.png
  33
  34 Unpack it:
  35
  36 .. parsed-literal::
  37
  38     $ :input:`tar xzf sympy-0.5.12.tar.gz`
  39
  40 and try it from a Python intepreter:
  41
  42 .. parsed-literal::
  43
  44     $ :input:`cd sympy-0.5.12`
  45     $ :input:`python`
  46     Python 2.4.4 (#2, Jan  3 2008, 13:36:28)
  47     [GCC 4.2.3 20071123 (prerelease) (Debian 4.2.2-4)] on linux2
  48     Type "help", "copyright", "credits" or "license" for more information.
  49     >>> :input:`from sympy import Symbol, cos`
  50     >>> :input:`x = Symbol("x")`
  51     >>> :input:`(1/cos(x)).series(x, 0, 10)`
  52     1 + (1/2)*x**2 + (5/24)*x**4 + (61/720)*x**6 + (277/8064)*x**8 + O(x**10)
  53
  54 You can use SymPy as shown above and this is indeed the recommended way if you
  55 use it in your program. You can also install it using ``./setup.py install`` as
  56 any other Python module, or just install a package in your favourite Linux
  57 distribution, e.g.:
  58
  59 .. topic:: Installing SymPy in Debian
  60
  61   .. parsed-literal::
  62
  63     $ :input:`sudo apt-get install python-sympy`
  64     Reading package lists... Done
  65     Building dependency tree
  66     Reading state information... Done
  67     The following NEW packages will be installed:
  68       python-sympy
  69     0 upgraded, 1 newly installed, 0 to remove and 18 not upgraded.
  70     Need to get 991kB of archives.
  71     After this operation, 5976kB of additional disk space will be used.
  72     Get:1 http://ftp.cz.debian.org unstable/main python-sympy 0.5.12-1 [991kB]
  73     Fetched 991kB in 2s (361kB/s)
  74     Selecting previously deselected package python-sympy.
  75     (Reading database ... 232619 files and directories currently installed.)
  76     Unpacking python-sympy (from .../python-sympy_0.5.12-1_all.deb) ...
  77     Setting up python-sympy (0.5.12-1) ...
  78
  79
  80 For other means how to install SymPy, consult the  Downloads_ tab on the
  81 SymPy's webpage.
  82
  83 .. _Downloads: http://code.google.com/p/sympy/wiki/DownloadInstallation?tm=2
  84
  85
  86 isympy Console
  87 --------------
  88
  89 For experimenting with new features, or when figuring out how to do things, you
  90 can use our special wrapper around IPython called ``isympy`` (located in
  91 ``bin/isympy`` if you are running from the source directory) which is just a
  92 standard python shell that has already imported the relevant sympy modules and
  93 defined the symbols x, y, z and some other things:
  94
  95 .. parsed-literal::
  96
  97     $ :input:`cd sympy-0.5.12`
  98     $ :input:`bin/isympy`
  99     Python 2.4.4 console for SymPy 0.5.12-hg. These commands were executed:
 100     >>> from __future__ import division
 101     >>> from sympy import *
 102     >>> x, y, z = symbols('xyz')
 103     >>> k, m, n = symbols('kmn', integer=True)
 104     >>> f = Function("f")
 105
 106     Documentation can be found at http://sympy.org/
 107
 108
 109     In [1]: :input:`(1/cos(x)).series(x, 0, 10)`
 110     Out[1]:
 111          2      4       6        8
 112         x    5*x    61*x    277*x
 113     1 + ── + ──── + ───── + ────── + O(x**10)
 114         2     24     720     8064
 115
 116 .. note::
 117
 118     Commands entered by you are bold. Thus what we did in 3 lines in a regular
 119     Python interpeter can be done in 1 line in isympy.
 120
 121
 122 Using SymPy as a calculator
 123 ---------------------------
 124
 125 Sympy has three built-in numeric types: Real, Rational and Integer.
 126
 127 The Rational class represents a rational number as a pair of two Integers: the numerator and the denominator, so Rational(1,2) represents 1/2, Rational(5,2) 5/2 and so on.
 128
 129 ::
 130
 131     >>> from sympy import *
 132     >>> a = Rational(1,2)
 133
 134     >>> a
 135     1/2
 136
 137     >>> a*2
 138     1
 139
 140     >>> Rational(2)**50/Rational(10)**50
 141     1/88817841970012523233890533447265625
 142
 143
 144 proceed with caution while working with python int's since they truncate
 145 integer division, and that's why::
 146
 147    >>> 1/2
 148    0
 149
 150    >>> 1.0/2
 151    0.5
 152
 153 You can however do::
 154
 155   >>> from __future__ import division
 156
 157   >>> 1/2 #doctest: +SKIP
 158   0.5
 159
 160 True division is going to be standard in python3k and ``isympy`` does that too.
 161
 162 We also have some special constants, like e and pi, that are treated as symbols
 163 (1+pi won't evaluate to something numeric, rather it will remain as 1+pi), and
 164 have arbitrary precission::
 165
 166     >>> pi**2
 167     pi**2
 168
 169     >>> pi.evalf()
 170     3.141592653589793238462643383
 171
 172     >>> (pi+exp(1)).evalf()
 173     5.859874482049203234066343309
 174
 175 as you see, evalf evaluates the expression to a floating-point number
 176
 177 There is also a class representing mathematical infinity, called ``oo``::
 178
 179     >>> oo > 99999
 180     True
 181     >>> oo + 1
 182     oo
 183
 184 Symbols
 185 -------
 186
 187 In contrast to other Computer Algebra Systems, in SymPy you have to declare
 188 symbolic variables explicitly::
 189
 190     >>> from sympy import *
 191     >>> x = Symbol('x')
 192     >>> y = Symbol('y')
 193
 194 Then you can play with them::
 195
 196     >>> x+y+x-y
 197     2*x
 198
 199     >>> (x+y)**2
 200     (x+y)**2
 201
 202     >>> ((x+y)**2).expand()
 203     2*x*y+x**2+y**2
 204
 205 And substitute them for other symbols or numbers using ``subs(old, new)``::
 206
 207     >>> ((x+y)**2).subs(x, 1)
 208     (1+y)**2
 209
 210     >>> ((x+y)**2).subs(x, y)
 211     4*y**2
 212
 213 Algebra
 214 =======
 215
 216 For partial fraction decomposition, use ``apart(expr, x)``::
 217
 218     In [1]: 1/( (x+2)*(x+1) )
 219     Out[1]:
 220            1
 221     ───────────────
 222     (2 + x)*(1 + x)
 223
 224     In [2]: apart(1/( (x+2)*(x+1) ), x)
 225     Out[2]:
 226       1       1
 227     ───── - ─────
 228     1 + x   2 + x
 229
 230     In [3]: (x+1)/(x-1)
 231     Out[3]:
 232     -(1 + x)
 233     ────────
 234      1 - x
 235
 236     In [4]: apart((x+1)/(x-1), x)
 237     Out[4]:
 238           2
 239     1 - ─────
 240         1 - x
 241
 242 To combine things back together, use ``together(expr, x)``::
 243
 244     In [7]: together(1/x + 1/y + 1/z)
 245     Out[7]:
 246     x*y + x*z + y*z
 247     ───────────────
 248          x*y*z
 249
 250     In [8]: together(apart((x+1)/(x-1), x), x)
 251     Out[8]:
 252     -1 - x
 253     ──────
 254     1 - x
 255
 256     In [9]: together(apart(1/( (x+2)*(x+1) ), x), x)
 257     Out[9]:
 258            1
 259     ───────────────
 260     (2 + x)*(1 + x)
 261
 262
 263 .. index:: calculus
 264
 265 Calculus
 266 ========
 267
 268 .. index:: limits
 269
 270 Limits
 271 ------
 272
 273 Limits are easy to use in sympy, they follow the syntax limit(function,
 274 variable, point), so to compute the limit of f(x) as x -> 0, you would issue
 275 limit(f, x, 0)::
 276
 277    >>> from sympy import *
 278    >>> x=Symbol("x")
 279    >>> limit(sin(x)/x, x, 0)
 280    1
 281
 282 you can also calculate the limit at infinity::
 283
 284    >>> limit(x, x, oo)
 285    oo
 286
 287    >>> limit(1/x, x, oo)
 288    0
 289
 290    >>> limit(x**x, x, 0)
 291    1
 292
 293 for some non-trivial examples on limits, you can read the test file
 294 `test_demidovich.py
 295 <http://hg.sympy.org/sympy/file/tip/sympy/series/tests/test_demidovich.py>`_
 296
 297 .. index:: differentiation, diff
 298
 299 Differentiation
 300 ---------------
 301
 302 You can differentiate any SymPy expression using ``diff(func, var)``. Examples::
 303
 304     >>> from sympy import *
 305     >>> x = Symbol('x')
 306     >>> diff(sin(x), x)
 307     cos(x)
 308     >>> diff(sin(2*x), x)
 309     2*cos(2*x)
 310
 311     >>> diff(tan(x), x)
 312     cos(x)**(-2)
 313
 314 You can check, that it is correct by::
 315
 316     >>> limit((tan(x+y)-tan(x))/y, y, 0)
 317     cos(x)**(-2)
 318
 319 Higher derivatives can be calculated using the ``diff(func, var, n)`` method::
 320
 321     >>> diff(sin(2*x), x, 1)
 322     2*cos(2*x)
 323
 324     >>> diff(sin(2*x), x, 2)
 325     -4*sin(2*x)
 326
 327     >>> diff(sin(2*x), x, 3)
 328     -8*cos(2*x)
 329
 330
 331 .. index::
 332     single: series expansion
 333     single: expansion; series
 334
 335 Series expansion
 336 ----------------
 337
 338 Use ``.series(var, point, order)``::
 339
 340     >>> from sympy import *
 341     >>> x = Symbol('x')
 342     >>> cos(x).series(x, 0, 10)
 343     1 - 1/2*x**2 + (1/24)*x**4 - 1/720*x**6 + (1/40320)*x**8 + O(x**10)
 344     >>> (1/cos(x)).series(x, 0, 10)
 345     1 + (1/2)*x**2 + (5/24)*x**4 + (61/720)*x**6 + (277/8064)*x**8 + O(x**10)
 346
 347 Another simple example::
 348
 349     from sympy import Integral, Symbol, pprint
 350
 351     x = Symbol("x")
 352     y = Symbol("y")
 353
 354     e = 1/(x + y)
 355     s = e.series(x, 0, 5)
 356
 357     print(s)
 358     pprint(s)
 359
 360 That should print the following after the execution::
 361
 362     1/y + x**2*y**(-3) + x**4*y**(-5) - x*y**(-2) - x**3*y**(-4) + O(x**5)
 363          2    4         3
 364     1   x    x    x    x
 365     ─ + ── + ── - ── - ── + O(x**5)
 366     y    3    5    2    4
 367         y    y    y    y
 368
 369 .. index:: integration
 370
 371 Integration
 372 -----------
 373
 374 SymPy has support for indefinite and definite integration of transcendental
 375 elementary and special functions via `integrate()` facility, which uses
 376 powerful extended Risch-Norman algorithm and some heuristics and pattern
 377 matching::
 378
 379     >>> from sympy import *
 380     >>> x, y = symbols('xy')
 381
 382 You can integrate elementary functions::
 383
 384     >>> integrate(6*x**5, x)
 385     x**6
 386     >>> integrate(sin(x), x)
 387     -cos(x)
 388     >>> integrate(log(x), x)
 389     x*log(x) - x
 390     >>> integrate(2*x + sinh(x), x)
 391     x**2 + cosh(x)
 392
 393 Also special functions are handled easily::
 394
 395     >>> integrate(exp(-x**2)*erf(x), x)
 396     (1/4)*pi**(1/2)*erf(x)**2
 397
 398 It is possible to compute definite integral::
 399
 400     >>> integrate(x**3, (x, -1, 1))
 401     0
 402     >>> integrate(sin(x), (x, 0, pi/2))
 403     1
 404     >>> integrate(cos(x), (x, -pi/2, pi/2))
 405     2
 406
 407 Also improper integrals are supported as well::
 408
 409     >>> integrate(exp(-x), (x, 0, oo))
 410     1
 411     >>> integrate(log(x), (x, 0, 1))
 412     -1
 413
 414 .. index::
 415     single: complex numbers
 416     single: expansion; complex
 417
 418 Complex numbers
 419 ---------------
 420
 421 ::
 422
 423     >>> from sympy import Symbol, exp, I
 424     >>> x = Symbol("x")
 425     >>> exp(I*x).expand()
 426     exp(I*x)
 427     >>> exp(I*x).expand(complex=True)
 428     1/exp(im(x))*cos(re(x)) + I/exp(im(x))*sin(re(x))
 429     >>> x = Symbol("x", real=True)
 430     >>> exp(I*x).expand(complex=True)
 431     I*sin(x) + cos(x)
 432
 433 Functions
 434 ---------
 435
 436 **trigonometric**::
 437
 438     In [1]: sin(x+y).expand(trig=True)
 439     Out[1]: cos(x)*sin(y) + cos(y)*sin(x)
 440
 441     In [2]: cos(x+y).expand(trig=True)
 442     Out[2]: cos(x)*cos(y) - sin(x)*sin(y)
 443
 444     In [3]: sin(I*x)
 445     Out[3]: ⅈ*sinh(x)
 446
 447     In [4]: sinh(I*x)
 448     Out[4]: ⅈ*sin(x)
 449
 450     In [5]: asinh(I)
 451     Out[5]:
 452     π*ⅈ
 453     ───
 454      2
 455
 456     In [6]: asinh(I*x)
 457     Out[6]: ⅈ*asin(x)
 458
 459     In [15]: sin(x).series(x, 0, 10)
 460     Out[15]:
 461          3     5     7       9
 462         x     x     x       x
 463     x - ── + ─── - ──── + ────── + O(x**10)
 464         6    120   5040   362880
 465
 466     In [16]: sinh(x).series(x, 0, 10)
 467     Out[16]:
 468          3     5     7       9
 469         x     x     x       x
 470     x + ── + ─── + ──── + ────── + O(x**10)
 471         6    120   5040   362880
 472
 473     In [17]: asin(x).series(x, 0, 10)
 474     Out[17]:
 475          3      5      7       9
 476         x    3*x    5*x    35*x
 477     x + ── + ──── + ──── + ───── + O(x**10)
 478         6     40    112     1152
 479
 480     In [18]: asinh(x).series(x, 0, 10)
 481     Out[18]:
 482          3      5      7       9
 483         x    3*x    5*x    35*x
 484     x - ── + ──── - ──── + ───── + O(x**10)
 485         6     40    112     1152
 486
 487
 488 **spherical harmonics**::
 489
 490     In [1]: from sympy.abc import theta, phi
 491
 492     In [2]: Ylm(1, 0, theta, phi)
 493     Out[2]:
 494       ⎽⎽⎽
 495     ╲╱ 3 *cos(θ)
 496     ────────────
 497           ⎽⎽⎽
 498       2*╲╱ π
 499
 500     In [3]: Ylm(1, 1, theta, phi)
 501     Out[3]:
 502        ⎽⎽⎽           ⅈ*φ
 503     -╲╱ 6 *│sin(θ)│*ℯ
 504     ────────────────────
 505               ⎽⎽⎽
 506           4*╲╱ π
 507
 508     In [4]: Ylm(2, 1, theta, phi)
 509     Out[4]:
 510        ⎽⎽⎽⎽                  ⅈ*φ
 511     -╲╱ 30 *│sin(θ)│*cos(θ)*ℯ
 512     ────────────────────────────
 513                   ⎽⎽⎽
 514               4*╲╱ π
 515
 516 **factorials and gamma function**::
 517
 518     In [1]: x = Symbol("x")
 519
 520     In [2]: y = Symbol("y", integer=True)
 521
 522     In [3]: factorial(x)
 523     Out[3]: Γ(1 + x)
 524
 525     In [4]: factorial(y)
 526     Out[4]: y!
 527
 528     In [5]: factorial(x).series(x, 0, 3)
 529     Out[5]:
 530                         2           2    2  2
 531                        x *EulerGamma    π *x
 532     1 - x*EulerGamma + ────────────── + ───── + O(x**3)
 533                              2            12
 534
 535 **zeta function**::
 536
 537     In [18]: zeta(4, x)
 538     Out[18]: ζ(4, x)
 539
 540     In [19]: zeta(4, 1)
 541     Out[19]:
 542      4
 543     π
 544     ──
 545     90
 546
 547     In [20]: zeta(4, 2)
 548     Out[20]:
 549           4
 550          π
 551     -1 + ──
 552          90
 553
 554     In [21]: zeta(4, 3)
 555     Out[21]:
 556             4
 557       17   π
 558     - ── + ──
 559       16   90
 560
 561
 562 **polynomials**::
 563
 564     In [1]: chebyshevt(2, x)
 565     Out[1]:
 566             2
 567     -1 + 2*x
 568
 569     In [2]: chebyshevt(4, x)
 570     Out[2]:
 571            2      4
 572     1 - 8*x  + 8*x
 573
 574     In [3]: legendre(2, x)
 575     Out[3]:
 576               2
 577            3*x
 578     -1/2 + ────
 579             2
 580
 581     In [4]: legendre(8, x)
 582     Out[4]:
 583                2         4         6         8
 584      35   315*x    3465*x    3003*x    6435*x
 585     ─── - ────── + ─────── - ─────── + ───────
 586     128     32        64        32       128
 587
 588     In [5]: assoc_legendre(2, 1, x)
 589     Out[5]:
 590             ⎽⎽⎽⎽⎽⎽⎽⎽
 591            ╱      2
 592     -3*x*╲╱  1 - x
 593
 594     In [6]: assoc_legendre(2, 2, x)
 595     Out[6]:
 596            2
 597     3 - 3*x
 598
 599     In [7]: hermite(3, x)
 600     Out[7]:
 601                3
 602     -12*x + 8*x
 603
 604
 605 .. index:: equations; differential, diff, dsolve
 606
 607 Differential Equations
 608 ----------------------
 609
 610 In ``isympy``::
 611
 612     In [4]: f(x).diff(x, x) + f(x)
 613     Out[4]:
 614        2
 615       d
 616     ─────(f(x)) + f(x)
 617     dx dx
 618
 619     In [5]: dsolve(f(x).diff(x, x) + f(x), f(x))
 620     Out[5]: C₁*sin(x) + C₂*cos(x)
 621
 622
 623 .. index:: equations; algebraic, solve
 624
 625 Algebraic equations
 626 -------------------
 627
 628 In ``isympy``::
 629
 630     In [7]: solve(x**4 - 1, x)
 631     Out[7]: [ⅈ, 1, -1, -ⅈ]
 632
 633     In [8]: solve([x + 5*y - 2, -3*x + 6*y - 15], [x, y])
 634     Out[8]: {y: 1, x: -3}
 635
 636
 637 .. index:: linear algebra
 638
 639 Linear Algebra
 640 ==============
 641
 642 .. index:: Matrix
 643
 644 Matrices
 645 --------
 646
 647 Matrices are created as instances from the Matrix class::
 648
 649     >>> from sympy import Matrix
 650     >>> Matrix([[1,0], [0,1]])
 651     [1 0]
 652     [0 1]
 653
 654 you can also put Symbols in it::
 655
 656     >>> x = Symbol('x')
 657     >>> y = Symbol('y')
 658     >>> A = Matrix([[1,x], [y,1]])
 659     >>> A #doctest: +NORMALIZE_WHITESPACE
 660     [1 x]
 661     [y 1]
 662
 663     >>> A**2 #doctest: +NORMALIZE_WHITESPACE
 664     [1+x*y 2*x]
 665     [2*y 1+x*y]
 666
 667     >>> 1
 668     1
 669
 670 For more information an examples with Matrices, see the LinearAlgebraTutorial.
 671
 672 .. index:: pattern matching, match, Wild, WildFunction
 673
 674 Pattern matching
 675 ================
 676
 677 Use the ``.match()`` method, along with the ``Wild`` class, to perform pattern
 678 matching on expressions. The method will return a dictionary with the required
 679 substitutions, as follows::
 680
 681     >>> from sympy import *
 682     >>> x = Symbol('x')
 683     >>> p = Wild('p')
 684     >>> q = Wild('q')
 685     >>> (5*x**2 + 3*x).match(p*x**2 + q*x)
 686     {p_: 5, q_: 3}
 687
 688     >>> (x**2).match(p*x**q)
 689     {p_: 1, q_: 2}
 690
 691 If the match is unsuccessful, it returns ``None``::
 692
 693     >>> print (x+1).match(p**x)
 694     None
 695
 696 One can also make use of the `WildFunction` class to perform
 697 more specific matches with functions and their arguments::
 698
 699     >>> f = WildFunction('f', nofargs=1)
 700     >>> (5*cos(x)).match(p*f)
 701     {p_: 5, f_: cos(x)}
 702     >>> (cos(3*x)).match(f(p*x))
 703     {p_: 3, f_: cos}
 704     >>> g = WildFunction('g', nofargs=2)
 705     >>> (5*cos(x)).match(p*g)
 706     None
 707
 708 One can also use the exclude parameter of the ``Wild`` class to ensure that
 709 certain things do not show up in the result::
 710
 711     >>> x = Symbol('x')
 712     >>> p = Wild('p', exclude=[1,x])
 713     >>> print (x+1).match(x+p) # 1 is excluded
 714     None
 715     >>> print (x+1).match(p+1) # x is excluded
 716     None
 717     >>> print (x+1).match(x+2+p) # -1 is not excluded
 718     {p_: -1}
 719
 720 .. _printing-tutorial:
 721
 722 Printing
 723 ========
 724
 725 There are many ways how expressions can be printed.
 726
 727 **Standard**
 728
 729 This is what ``str(expression)`` returns and it looks like this:
 730
 731     >>> from sympy import Integral
 732     >>> from sympy.abc import x
 733     >>> print x**2
 734     x**2
 735     >>> print 1/x
 736     1/x
 737     >>> print Integral(x**2, x)
 738     Integral(x**2, x)
 739     >>>
 740
 741
 742 **Pretty printing**
 743
 744 This is a nice ascii-art printing produced by a ``pprint`` function:
 745
 746     >>> from sympy import Integral, pprint
 747     >>> from sympy.abc import x
 748     >>> pprint(x**2)
 749      2
 750     x
 751     >>> pprint(1/x)
 752     1
 753     ─
 754     x
 755     >>> pprint(Integral(x**2, x))
 756     ⌠
 757     ⎮  2
 758     ⎮ x  dx
 759     ⌡
 760     >>>
 761
 762 See also the wiki `Pretty Printing
 763 <http://wiki.sympy.org/wiki/Pretty_Printing>`_ for more examples of a nice
 764 unicode printing.
 765
 766 Tip: To make the pretty printing default in the python interpreter, use::
 767
 768     $ python
 769     Python 2.5.2 (r252:60911, Jun 25 2008, 17:58:32)
 770     [GCC 4.3.1] on linux2
 771     Type "help", "copyright", "credits" or "license" for more information.
 772     >>> from sympy import *
 773     >>> import sys
 774     >>> sys.displayhook = pprint
 775     >>> var("x")
 776     x
 777     >>> x**3/3
 778      3
 779     x
 780     ──
 781     3
 782     >>> Integral(x**2, x)
 783     ⌠
 784     ⎮  2
 785     ⎮ x  dx
 786     ⌡
 787
 788
 789
 790 **Python printing**
 791
 792     >>> from sympy.printing.python import print_python
 793     >>> from sympy import Integral
 794     >>> from sympy.abc import x
 795     >>> print_python(x**2)
 796     x = Symbol('x')
 797     e = x**2
 798     >>> print_python(1/x)
 799     x = Symbol('x')
 800     e = 1/x
 801     >>> print_python(Integral(x**2, x))
 802     x = Symbol('x')
 803     e = Integral(x**2, x)
 804     >>>
 805
 806 **LaTeX printing**
 807
 808     >>> from sympy import Integral, latex
 809     >>> from sympy.abc import x
 810     >>> latex(x**2)
 811     '${x}^{2}$'
 812     >>> latex(1/x)
 813     '${x}^{-1}$'
 814     >>> latex(Integral(x**2, x))
 815     '$\\int {x}^{2}\\,dx$'
 816     >>>
 817
 818 **MathML**
 819
 820 ::
 821
 822     >>> from sympy.printing.mathml import print_mathml
 823     >>> from sympy import Integral, latex
 824     >>> from sympy.abc import x
 825     >>> print_mathml(x**2)
 826     <apply>
 827         <power/>
 828         <ci>
 829             x
 830         </ci>
 831         <cn>
 832             2
 833         </cn>
 834     </apply>
 835
 836     >>> print_mathml(1/x)
 837     <apply>
 838         <power/>
 839         <ci>
 840             x
 841         </ci>
 842         <cn>
 843             -1
 844         </cn>
 845     </apply>
 846
 847     >>>
 848
 849 **Pyglet**
 850
 851     >>> from sympy import Integral, pngview
 852     >>> from sympy.abc import x
 853     >>> pngview(Integral(x**2, x))
 854
 855 And a pyglet window with the LaTeX rendered expression will popup:
 856
 857 .. image:: pics/pngview1.png
 858
 859 Notes
 860 -----
 861
 862 ``isympy`` calls ``pprint`` automatically, so that's why you see pretty
 863 printing by default.
 864
 865 Note that there is also a printing module available, ``sympy.printing``.  Other
 866 printing methods available trough this module are:
 867
 868 * ``pretty(expr)``, ``pretty_print(expr)``, ``pprint(expr)``: Return or print, respectively, a pretty representation of ``expr``. This is the same as the second level of representation described above.
 869
 870 * ``latex(expr)``, ``print_latex(expr)``: Return or print, respectively, a `LaTeX <http://www.latex-project.org/>`_  representation of ``expr``
 871
 872 * ``mathml(expr)``, ``print_mathml(expr)``: Return or print, respectively, a `MathML <http://www.w3.org/Math/>`_ representation of ``expr``.
 873
 874 * ``print_gtk(expr)``: Print ``expr`` to `Gtkmathview <http://helm.cs.unibo.it/mml-widget/>`_, a GTK widget that displays MathML code. The `Gtkmathview <http://helm.cs.unibo.it/mml-widget/>`_ program is required.
 875
 876 Further documentation
 877 =====================
 878
 879 Now it's time to learn more about SymPy. Go through the
 880 :ref:`SymPy User's Guide <guide>` and
 881 :ref:`SymPy Modules Reference <module-docs>`.
 882
 883 Be sure to also browse our public `wiki.sympy.org <http://wiki.sympy.org/>`_,
 884 that contains a lot of useful examples, tutorials, cookbooks that we and our
 885 users contributed and we encourage you to edit it.