doc/demo0_2.rst

   1 .. -*- rest -*-
   2
   3 ==========================
   4 SympyCore Release 0.2 Demo
   5 ==========================
   6
   7 :Authors:
   8   Pearu Peterson
   9
  10 :Created:
  11   February 2008
  12
  13 :Website: http://sympycore.googlecode.com/
  14
  15 :Version: sympycore 0.2-svn.
  16    Other versions: `0.1`__.
  17
  18 __ http://sympycore.googlecode.com/svn-history/r818/trunk/doc/html/demo0_1.html
  19
  20 .. sidebar:: Table of contents
  21
  22     .. contents::
  23         :depth: 2
  24         :local:
  25
  26 Getting started
  27 ===============
  28
  29 This document gives a short overview of SympyCore basic features. For
  30 more information see the `SympyCore User's Guide`__.
  31
  32 __ http://sympycore.googlecode.com/svn/trunk/doc/html/userguide.html
  33
  34 To use the ``sympycore`` package from Python, one must import it:
  35
  36 >>> from sympycore import *
  37
  38 Constructing symbolic expressions
  39 =================================
  40
  41 Generally speaking, symbolic expressions consist of symbols and
  42 operation between them. To create symbolic expressions using
  43 SympyCore, one can either create symbol objects and perform operations
  44 between them:
  45
  46 >>> x = Symbol('x')
  47 >>> y = Symbol('y')
  48 >>> z = Symbol('z')
  49 >>> x + y
  50 Calculus('x + y')
  51
  52 or one can use symbolic expression parser to construct symbolic
  53 expressions from a string:
  54
  55 >>> Calculus('x + y')
  56 Calculus('x + y')
  57
  58 SympyCore converts symbolic expressions to a canonical form that is
  59 efficient for further manipulations and are also often obvious
  60 simplifications that users may expect:
  61
  62 >>> x + x
  63 Calculus('2*x')
  64
  65 >>> x - x
  66 Calculus('0')
  67
  68 General symbolic arithmetic expressions are instances of the Calculus
  69 class. Using the ``print`` statement (or ``str()``) hides this information:
  70
  71 >>> print x + y
  72 x + y
  73
  74 Manipulations with symbolic expressions
  75 =======================================
  76
  77 The most obvious manipulation task applied to symbolic expressions, is
  78 substitution -- replacing a sub-expression of a given expression with a
  79 new expression. For example,
  80
  81 >>> expr = x + y
  82 >>> print expr.subs(y, sin(x))
  83 x + sin(x)
  84
  85 Other tasks include accessing parts of symbolic expressions:
  86
  87 >>> sorted(expr.args)
  88 [Calculus('x'), Calculus('y')]
  89
  90 and constructing new expressions:
  91
  92 >>> print Mul(*expr.args)
  93 x*y
  94
  95 An important presumption for implementing various algorithms is pattern
  96 matching. Pattern matching means that given a pattern expression, the
  97 pattern match method should first decide whether an expression can be
  98 expressed in a form that the pattern defines, and second. it should
  99 return information what sub-expression parts correspond to the pattern
 100 sub-expressions. For example, given a pattern
 101
 102 >>> w = Symbol('w')
 103 >>> pattern = x * w ** 3
 104
 105 where symbol ``w`` is assumed to match any sub-expression, then expressions
 106
 107 >>> expr1 = x*sin(y)**3
 108 >>> expr2 = x*(x+y)**3
 109
 110 do match the given pattern:
 111
 112 >>> d1 = expr1.match(pattern, w)
 113 >>> print d1
 114 {Calculus('w'): Calculus('sin(y)')}
 115
 116 >>> d2 = expr2.match(pattern, w)
 117 >>> print d2
 118 {Calculus('w'): Calculus('x + y')}
 119
 120 The result of ``match`` method, when the match is found, is a dictionary
 121 with the property
 122
 123 >>> pattern.subs(d1.items())==expr1
 124 True
 125 >>> pattern.subs(d2.items())==expr2
 126 True
 127
 128 If no match is found, then the ``match`` returns ``None``:
 129
 130 >>> print (y*x**2).match(pattern, w)
 131 None
 132
 133 Transformation methods
 134 ======================
 135
 136 The most common transformation task is expansion of sub-expressions by
 137 opening parenthesis:
 138
 139 >>> expr = (x+y)*z
 140 >>> print expr
 141 z*(x + y)
 142 >>> print expr.expand()
 143 x*z + y*z
 144
 145 In general, the ``expand`` method expands products of sums and
 146 integer powers of sums:
 147
 148 >>> expr = (x+y)*(1+x)**3
 149 >>> print expr.expand()
 150 x + y + x**4 + 3*x**2 + 3*x**3 + 3*x*y + 3*y*x**2 + y*x**3
 151
 152 Arithmetic methods
 153 ==================
 154
 155 SympyCore provides exact rational and complex numbers:
 156
 157 >>> Calculus('3/12')
 158 Calculus('1/4')
 159 >>> print (2 + 3*I/4)**4
 160 721/256 + 165/8*I
 161
 162 Fractional powers of integers are evaluated to simpler
 163 expressions when possible:
 164
 165 >>> Calculus('8**(1/3)')
 166 Calculus('2')
 167 >>> Calculus('243**(1/5)')
 168 Calculus('3')
 169
 170 SympyCore supports converting symbolic expressions with exact numbers
 171 such as integers and rational numbers to expressions with arbitrary
 172 precision floating-point numbers:
 173
 174 >>> expr = 2*pi + E**x
 175 >>> print expr
 176 E**x + 2*pi
 177 >>> print expr.evalf(5)
 178 6.2832 + 2.7183**x
 179 >>> print expr.evalf(25)
 180 6.283185307179586476925287 + 2.718281828459045235360287**x
 181
 182 Calculus methods
 183 ================
 184
 185 SympyCore provides methods to differentiate symbolic expressions:
 186
 187 >>> expr = x+sin(x*y)*x
 188 >>> print expr.diff(x)
 189 1 + sin(x*y) + x*y*cos(x*y)
 190
 191 as well as integrate symbolic expression representing polynomials:
 192
 193 >>> expr = x + 3*z*x**2
 194 >>> print expr.integrate(x)
 195 1/2*x**2 + z*x**3
 196 >>> print expr.integrate((x, 2, y))
 197 1/2*y**2 + z*(y**3 - 8) - 2
 198
 199 SympyCore implements the elementary functions ``exp``, ``log``,
 200 ``sqrt``, ``cos``, ``sin``, ``tan``, ``cot``, and simplifies
 201 their values in basic cases:
 202
 203 >>> print log(10000,10)
 204 4
 205 >>> print sin(5*pi/6)
 206 1/2
 207 >>> print cos(x+pi/2)
 208 -sin(x)
 209
 210 Polynomial rings
 211 ================
 212
 213 SympyCore provides efficient ways to represent univariate and
 214 multivariate polynomials. Currently there are two representation
 215 supported. The first one is suitable for univariate dense polynomials:
 216
 217 >>> poly1 = UnivariatePolynomial([2,0,3,4])
 218 >>> poly2 = UnivariatePolynomial([0,1,0,5,6])
 219 >>> poly1
 220 2 + 3*x**2 + 4*x**3
 221 >>> poly2
 222 x + 5*x**3 + 6*x**4
 223 >>> poly1 + poly2
 224 2 + x + 3*x**2 + 9*x**3 + 6*x**4
 225
 226 And the other representation is suitable for multivariate sparse
 227 polynomials:
 228
 229 >>> P = PolynomialRing[(x,y)]
 230 >>> poly1 = P({(1,2):7, (300,4):5})
 231 >>> poly2 = P({(3,4):-7, (2,500):12})
 232 >>> poly1
 233 PolynomialRing[(x, y), Calculus]('5*x**300*y**4 + 7*x*y**2')
 234 >>> print poly2
 235 ((-7))*x**3*y**4 + 12*x**2*y**500
 236 >>> print poly1 + poly2
 237 5*x**300*y**4 + ((-7))*x**3*y**4 + 12*x**2*y**500 + 7*x*y**2
 238
 239 Here the ``PolynomialRing[symbols, Algebra]`` represents a factory of
 240 a polynomial ring over ``Algebra`` with ``symbols``.
 241
 242 Matrix rings
 243 ============
 244
 245 SympyCore supports representing rectangular matrix ring elements using
 246 similar idea of ring factory:
 247
 248 >>> M = MatrixRing[(3,4)]
 249 >>> matrix = M({(1,2):x+y, (0,0):x+z})
 250 >>> print matrix
 251  x + z  0      0  0
 252      0  0  x + y  0
 253      0  0      0  0
 254
 255 Note that matrices are mutable in SympyCore and indexes start from 0:
 256
 257 >>> matrix[1,0] = 5
 258 >>> print matrix
 259  x + z  0      0  0
 260      5  0  x + y  0
 261      0  0      0  0
 262
 263 SympyCore provides ``SquareMatrix`` and ``PermutationMatrix``
 264 factories for convenience:
 265
 266 >>> SqM = SquareMatrix[3]
 267 >>> m = SqM({(0,0): 1, (2,1): 3, (2,2):6, (1,2):-2, (2,0): -1})
 268 >>> print m
 269   1  0   0
 270   0  0  -2
 271  -1  3   6
 272 >>> print PermutationMatrix[4]([2,1,3,0])
 273  0  0  1  0
 274  0  1  0  0
 275  0  0  0  1
 276  1  0  0  0
 277
 278 One can perform LU factorization on any rectangular matrix:
 279
 280 >>> p, l, u = m.lu()
 281 >>> print p
 282  1  0  0
 283  0  0  1
 284  0  1  0
 285 >>> print l
 286   1  0  0
 287  -1  1  0
 288   0  0  1
 289
 290 >>> print u
 291  1  0   0
 292  0  3   6
 293  0  0  -2
 294
 295 The ``*`` denotes matrix multiplication:
 296
 297 >>> print p * l * u == m
 298 True
 299
 300 SympyCore supports computing inverses of square
 301 matrices:
 302
 303 >>> print m.inv()
 304    1     0    0
 305  1/3     1  1/3
 306    0  -1/2    0
 307
 308 >>> m.inv() * m == SqM.one
 309 True
 310
 311 Physical units
 312 ==============
 313
 314 SympyCore has a basic support for dealing with symbolic expressions with
 315 units:
 316
 317 >>> mass1 = 5 * kilogram
 318 >>> mass2 = x * kilogram
 319 >>> print mass1 + mass2
 320 (5 + x)*kg