ginac.doc (version 0.4.65, Fri Apr 27 13:52:54 2001)
index
/usr/opt/Python2.1/lib/python2.1/site-packages/ginac/doc/__init__.py

PyGiNaC class documentation.

 
Package Contents
            
__init__
ddd
doctest

 
Classes
            
ex
test_01_ex
test_02_symbol
test_03_numeric
test_04_lst
test_05_add
test_06_mul
test_07_power
test_08_inifcns
test_09_function
test_10_relational
test_11_seq
test_12_constant
test_13_matrix
test_14_pseries
test_15_ncmul

 
class ex
       
  
__add__(self, other)
__cmp__(self, other)
Return `numeric(self-other).csgn()'.
If `self-other' is not ex(numeric), ValueError is raised
about indeterminate result.
__coerce__(self, other)
Return tuple (self, ex(other)).
__complex__(self)
`self' must be ex(numeric).
__delitem__(self, index)
`self' must be ex(lst) [not implemented].
__div__(self, other)
__float__(self)
`self' must be ex(numeric).
__getitem__(self, index)
__init__(self, *args)
ex() - return numeric('0')
ex(obj) - if n is ...
  ... Python number or string, return `number(obj)'.
  ... sequence, return `lst(obj)'. ex() function is applied to
      all items of the sequence `obj'.
ex(ex(...)) -> ex(...)
__int__(self)
`self' must be ex(numeric).
__len__(self)
For ex(matrix), return number of rows.
For ex(numeric|symbol|constant), raise NotImplementedError.
For other ex objects, return nops().
__lshift__(self, other)
ex(pseries)<<int(other) - Return a new pseries object with the powers
shifted by degree `other'.
__mul__(self, other)
__neg__(self)
__nonzero__(self)
`self' must be ex(relational)|ex(numeric)
__pos__(self)
__pow__(self, other, m=None)
__repr__(self)
Return reproducible string representation of an ex object.
__setitem__(self, index, other)
__str__(self)
Return pretty-print string representation of an ex object.
__sub__(self, other)
charpoly(self, sym)
Characteristic Polynomial.
Following mathematica notation the characteristic polynomial of a
matrix M is defined as the determiant of `(M - sym * 1)' where 1
stands for the unit matrix of the same dimension as M. Note that
some CASs define it with a sign inside the determinant which gives
rise to an overall sign if the dimension is odd. This method
returns the characteristic polynomial collected in powers of
`sym' as a new expression.
`sym' must be a ex(symbol)|string.
coeff(self, sym, n=1)
Return coefficient of degree `n' in expressin `sym'.
`sym' must be an ex object.
collect(self, sym)
Sort expression in terms of powers of `sym'.
cols(self)
Get number of columns.
content(self, sym)
Compute content part (= unit normal GCD of all coefficients) of a
multivariate polynomial in Z[x].  The product of unit part, content
part, and primitive part is the polynomial itself.
`sym' must be an ex(symbol) object.
degree(self, sym)
Return degree of highest power in expression `sym'.
`sym' must be an ex object.
denom(self)
Return denominator of an expression.
If the expression is not of the normal form "numerator/denominator",
it is first converted to this form and then the denominator is returned.
determinant(self, algo='automatic')
Determinant of a square matrix.
If all the elements of the matrix are elements of an integral
domain the determinant is also in that integral domain and the
result is expanded only. If one or more elements are from a
quotient field the determinant is usually also in that quotient
field and the result is normalized before it is returned. This
implies that the determinant of the symbolic 2x2 matrix
[[a/(a-b),1],[b/(a-b),1]] is returned as unity. (In this respect,
it behaves like MapleV and unlike Mathematica.)
 
Option algo:
  'automatic' - let the system choose  
  'gauss'     - Gauss elimiation
  'divfree'   - Division-free elimination
  'laplace'   - Laplace (or minor) elimination
  'bareiss'   - Bareiss fraction-free elimination
diff(self, sym, nth=1)
Compute partial derivative of an expression.
`sym' must be an ex(symbol) object.
eval(self, level=0)
Perform automatic non-interruptive symbolic evaluation on expression.
evalf(self, level=0)
Evaluate object numerically.
expand(self, options=0)
Expand expression.
options:
  1 - expand trigonometric,
  2 - expand indexed.
get_name(self)
Return the name of a symbol|function.
get_point(self)
Get the expansion point.
`self' must be ex(pseries).
get_var(self)
Get the expansion variable.
`self' must be ex(pseries).
has(self, other)
Check if object contains any occurrences of `other'.
`other' must be an ex object.
imag(self)
Return imaginary part.
`self' must be ex(numeric).
integer_content(self)
Compute the integer content (= GCD of all numeric coefficients) of
an expanded polynomial.
inverse(self)
Inverse of a square matrix.
is_add(self)
Check if object is add.
is_cinteger(self)
Check if complex integer.
is_compatible_to(self, other)
Check if object is compatible pseries to pseries `other'
(i.e., expansion variable and point are the same).
is_constant(self)
Check if object is constant.
is_crational(self)
Check if complex rational.
is_equal(self, obj)
Test for equality.
This is only a quick test, meaning objects should be in the same
domain. You might have to .expand(), .normal() objects first,
depending on the domain of your computation, to get a more reliable
answer.
is_even(self)
Check if even integer.
is_function(self)
Check if object is function.
is_integer(self)
Check if integer.
is_lst(self)
Check if object is lst.
is_matrix(self)
Check if object is matrix.
is_mul(self)
Check if object is ncmul.
is_negative(self)
Check if negative number.
is_nonneg_integer(self)
Check if nonnegative integer.
is_numeric(self)
Check if object is numeric.
is_odd(self)
Check if odd integer.
is_pos_integer(self)
Check if positive integer.
is_positive(self)
Check if positive number.
is_power(self)
Check if object is power.
is_prime(self)
Check if integer prime.
is_pseries(self)
Check if object is pseries.
is_rational(self)
Check if rational.
is_real(self)
Check if real.
is_relational(self)
Check if object is relational.
is_symbol(self)
Check if object is symbol.
is_terminating(self)
Check if object is terminating pseries (i.e., without Order term).
is_zero(self)
Test for zero.
lcoeff(self, sym)
Return `coeff(sym, degree(sym))'.
ldegree(self, sym)
Return degree of lowest power in expression `sym'.
`sym' must be an ex object.
lhs(self)
Left hand side of relational expression.
nops(self)
Return number of operands/members.
normal(self, level=0)
Normalization of rational functions.
 
This function converts an expression to its normal form
"numerator/denominator", where numerator and denominator are
(relatively prime) polynomials. Any subexpressions which are not
rational functions (like non-rational numbers, non-integer powers or
functions like sin(), cos() etc.) are replaced by temporary symbols
which are re-substituted by the (normalized) subexpressions before
normal() returns (this way, any expression can be treated as a
rational function). normal() is applied recursively to arguments of
functions etc.
level - maximum depth of recursion.
numer(self)
Return numerator of an expression.
If the expression is not of the normal form "numerator/denominator",
it is first converted to this form and then the numerator is returned.
op(self, i)
Return operand/member at position `i'.
primpart(self, sym, cont=None)
Compute primitive part (using the content part `cont' for efficiency
if given) of a multivariate polynomial in Z[x].  The product of unit
part, content part, and primitive part is the polynomial itself.
`sym' must be an ex(symbol) object.
real(self)
Return real part.
`self' must be ex(numeric).
rhs(self)
Right hand side of relational expression.
rows(self)
Get number of rows.
series(self, rel, order, options=0)
Compute the truncated series expansion of an expression.
Return an expression containing an object ex(pseries) to
represent the series. If the series does not terminate within the
given truncation order, the last term of the series will be an order
term.
rel - expansion relation, lhs holds variable and rhs holds point.
order - truncation order of series calculations.
options = 1 -  suppress branchcut.
`rel' must be an ex(relational) object or a 2-sequence.
set_name(self, s)
Set the name of a symbol to `s'.
solve(self, vars, rhs, algo='automatic')
Solve a linear system consisting of a m x n matrix and
a m x p right hand side by applying an elimination scheme to the
augmented matrix.
vars - n x p matrix, all elements must be symbols
rhs  - m x p matrix
Option algo:
  automatic - let the system choose  
  gauss     - Gauss elimiation
  divfree   - Division-free elimination
  bareiss   - Bareiss fraction-free elimination
Return n x p solution matrix.
subs(self, *args)
Substitute objects in an expression (syntactic substitution) and
return the result as a new expression (that is already evaluated).
 
subs(e) - `e' must be ex(relational)|ex(lst(relational,...)).
subs(ls,lr) - `ls',`lr' are ex(lst)|ex
swap(self, other)
Swap efficiently the contents of two expressions.
`other' must be an ex object.
tcoeff(self, sym)
Return `coeff(sym, ldegree(sym))'.
to_poly(self, no_order=0)
Convert the pseries object to an ordinary polynomial.
If no_order, then discard higher order terms.
`self' must be ex(pseries).
to_rational(self, repl_lst)
Rationalization of non-rational functions.
 
This function converts a general expression to a rational polynomial
by replacing all non-rational subexpressions (like non-rational
numbers, non-integer powers or functions like sin(), cos() etc.) to
temporary symbols. This makes it possible to use functions like
gcd() and divide() on non-rational functions by applying
to_rational() on the arguments, calling the desired function and
re-substituting the temporary symbols in the result. To make the
last step possible, all temporary symbols and their associated
expressions are collected in the list specified by the `repl_lst'
parameter in the form {symbol == expression}, ready to be passed as
an argument to ex.subs().
 
`repl_lst' must be an ex(lst) object. It collects a GiNaC list of all
temporary symbols and their replacements.
trace(self)
Trace of a square matrix.        
The result is normalized if it is in some quotient field and
expanded only otherwise. This implies that the trace of the
symbolic 2x2 matrix [[a/(a-b),x],[y,b/(b-a)]] is recognized to be
unity.
Return the sum of diagonal elements.
transpose(self)
Return transposed matrix.
unit(self, sym)
Compute unit part (= sign of leading coefficient) of a multivariate
polynomial in Z[x].  The product of unit part, content part, and
primitive part is the polynomial itself.
`sym' must be an ex(symbol) object.

 
class test_01_ex
     
Ex
--
>>> from ginac import ex,symbol,numeric
 
To create ex object from Python objects:
>>> ex()
numeric('0')
>>> ex(symbol('a'))
symbol('a')
>>> ex(3)
numeric('3')
>>> ex('3/4')
numeric('3/4')
>>> ex([])
lst([])
>>> ex([2,'5/4',symbol('g'),ex()])
lst([numeric('2'), numeric('5/4'), symbol('g'), numeric('0')])
>>> ex([[]])
lst([lst([])])
>>> ex([1,[symbol('c')]])
lst([numeric('1'), lst([symbol('c')])])
>>> ex({})
Traceback (most recent call last):
...
TypeError: ex_from_ref() argument must be number|string|ex|sequence (got <type 'dictionary'>)
 
Swap expressions:
>>> from ginac import swap
>>> a,b = symbol('a'),numeric('2/3')
>>> a.swap(b)
>>> a
numeric('2/3')
>>> b
symbol('a')
>>> a.swap(2)
Traceback (most recent call last):
...
TypeError: int
>>> swap(a,b)
>>> a,b
(symbol('a'), numeric('2/3'))
>>> swap(2,a)
Traceback (most recent call last):
...
TypeError: int
 
Operations with expressions:
>>> +b
numeric('2/3')
>>> -b
numeric('-2/3')
>>> a+b
add([symbol('a'), numeric('2/3')])
>>> a+1
add([symbol('a'), numeric('1')])
>>> b+2
numeric('8/3')
>>> 2+b
numeric('8/3')
>>> a+a
mul([symbol('a'), numeric('2')])
>>> a-a
numeric('0')
>>> a*a
power(symbol('a'), numeric('2'))
>>> a**5
power(symbol('a'), numeric('5'))
 
Expanding expressions:
>>> from ginac import expand
>>> e=(a+b)**2
>>> e
power(add([symbol('a'), numeric('2/3')]), numeric('2'))
>>> e.expand()
add([power(symbol('a'), numeric('2')), mul([symbol('a'), numeric('4/3')]), numeric('4/9')])
>>> e.expand(1)
add([power(symbol('a'), numeric('2')), mul([symbol('a'), numeric('4/3')]), numeric('4/9')])
>>> expand(e)
add([power(symbol('a'), numeric('2')), mul([symbol('a'), numeric('4/3')]), numeric('4/9')])
 
Pretty-printing:
>>> print a+b
2/3 + a
>>> print a*b
2/3 * a
>>> print a**b
a ** (2/3)
>>> print a-b
-2/3 + a
>>> print b-a
2/3 - a
>>> print -a
-a
>>> print (1+a) / a
(1 + a) / a
 
Accesing operants/members in ex objects:
>>> from ginac import nops,op
>>> e
power(add([symbol('a'), numeric('2/3')]), numeric('2'))
>>> e.nops(), nops(e)
(2, 2)
>>> e.op(0), op(e,0)
(add([symbol('a'), numeric('2/3')]), add([symbol('a'), numeric('2/3')]))
>>> e.op(1), op(e,1)
(numeric('2'), numeric('2'))
>>> e.op(-1)
Traceback (most recent call last):
...
IndexError: ex.op(-1) index out of range ([0...1])
>>> e.op(2)
Traceback (most recent call last):
...
IndexError: ex.op(2) index out of range ([0...1])
>>> a.nops()
0
>>> a.op(0)
Traceback (most recent call last):
...
IndexError: ex.op(0) index out of range ([0...-1])
 
Information about operants/members:
>>> from ginac import has
>>> e.has(a), has(e,a)
(1, 1)
>>> e.has(symbol()), has(e,symbol())
(0, 0)
>>> has(e,e)
1
 
Polynomial stuff:
>>> from ginac import degree,ldegree,coeff,lcoeff,tcoeff
>>> x,y=symbol('x'),symbol('y')
>>> p = 2*x**2 + x*y
>>> print p
y * x + 2 * x ** 2
>>> p.ldegree(x),p.degree(x)
(1, 2)
>>> p.ldegree(y),p.degree(y)
(0, 1)
>>> ldegree(p,x),degree(p,x)
(1, 2)
>>> print p.coeff(x,0)
0
>>> print p.coeff(x,1)
y
>>> print p.coeff(x,2)
2
>>> print p.coeff(x,10)
0
>>> print p.lcoeff(x)
2
>>> print p.tcoeff(x)
y
>>> print lcoeff(p, x), tcoeff(p, x)
2 y
>>> print coeff(p,x), coeff(p,y)
y x
>>> from ginac import numer,denom
>>> print p/x**2
(y * x + 2 * x ** 2) / x ** 2
>>> print numer(p/x**2), denom(p/x**2)
y + 2 * x x
>>> print (p/x**2).numer(), (p/x**2).denom()
y + 2 * x x
>>> r = -2*p/3+x
>>> print r.unit(x)
-1
>>> print r.content(x)
1
>>> print r.primpart(x)
2/3 * y * x + 4/3 * x ** 2 - x
>>> print r.primpart(x,1)
2/3 * y * x + 4/3 * x ** 2 - x
>>> print (30*r).integer_content()
10
 
Functions for rational functions:
>>> from ginac import normal
>>> print normal(x+1/x)
(1 + x ** 2) / x
>>> print normal(x+1/x,2)
x ** (-1) + x
>>> from ginac import lst,sin,to_rational
>>> l = lst()
>>> e = x+1/sin(x+1)
>>> print e.to_rational(l)
symbol8 ** (-1) + x
>>> l
lst([relational(symbol('symbol8'), sin(add([symbol('x'), numeric('1')])))])
>>> print l
[symbol8 == sin(1 + x)]
>>> l = lst()
>>> print to_rational(sin(x+1)+1/sin(x+1),l)
symbol9 + symbol9 ** (-1)
>>> print l
[symbol9 == sin(1 + x)]
>>> from ginac import collect
>>> print collect(2*x-x*sin(x),x)
x * (2 - sin(x))
>>> print (2*x-x*sin(x)).collect(x)
x * (2 - sin(x))
 
Evaluation of expressions:
>>> from ginac import eval,evalf
>>> e = sin(2*x/3)/3
>>> print e
1/3 * sin(2/3 * x)
>>> print e.evalf()
0.33333333333333333334 * sin(0.6666666666666666667 * x)
>>> print evalf(e)
0.33333333333333333334 * sin(0.6666666666666666667 * x)
>>> print e.evalf(2)
0.33333333333333333334 * sin(2/3 * x)
>>> print evalf(e,2)
0.33333333333333333334 * sin(2/3 * x)
 
Differentiation:
>>> from ginac import diff
>>> e = (sin(2*x)+x**2)/2
>>> print e.diff(x)
cos(2 * x) + x
>>> print diff(e,x)
cos(2 * x) + x
>>> print diff(e,x,3)
-4 * cos(2 * x)
>>> diff(e,1+x)
Traceback (most recent call last):
...
TypeError: symbol from_python() argument must be (string|ex(symbol)) (got ex(add))
 
Power series:
>>> from ginac import series
>>> print sin(x).series((x,0),5)
1 * x + (-1/6) * x ** 3 + Order(x ** 5)
>>> print series(sin(x)/x,(x,0),4)
1 + (-1/6) * x ** 2 + Order(x ** 3)
 
Substitution:
>>> from ginac import subs
>>> print sin(x).subs(x,x**2)
sin(x ** 2)
>>> print subs(sin(x),x,x**2)
sin(x ** 2)
>>> y = symbol('y')
>>> print subs(sin(x+y),[x,y],[x**2,x*y])
sin(y * x + x ** 2)
 
Auxiliary functions:
>>> from ginac import lhs,rhs
>>> rhs(x)
Traceback (most recent call last):
...
TypeError: ex.rhs() can be used only for ex(relational).
>>> lhs(x)
Traceback (most recent call last):
...
TypeError: ex.lhs() can be used only for ex(relational).
>>> x.rhs()
Traceback (most recent call last):
...
TypeError: ex.rhs() can be used only for ex(relational).
>>> (1+x).is_equal(x+1)
1
>>> (1+x).is_equal(x-1)
0
>>> (1+x).is_equal({})
0
>>> from ginac import is_zero
>>> is_zero(x), x.is_zero()
(0, 0)
>>> is_zero(x-x), (x-x).is_zero()
(1, 1)
>>> is_zero(0),is_zero(0.0),is_zero(34),is_zero({})
(1, 1, 0, 0)
>>> print numer(3), denom(3)
3 1
>>> print numer(3.3), denom(3.3)
3.2999999999999998224 1
 
  

 
class test_02_symbol
     
Symbol
------
 
>>> from ginac import symbol,ex,is_symbol
 
To create a dummy symbol (it will have a name of the form `symbol\d+'):
>>> print repr(symbol())[:14]
symbol('symbol
 
To create a named symbol:
>>> symbol('name')
symbol('name')
 
Note that symbol applied to a symbol does nothing:
>>> symbol(symbol('aa'))
symbol('aa')
 
But when applied to a any other object than string or symbol,
an exception is raised:
>>> symbol(2)
Traceback (most recent call last):
...
TypeError: symbol from_python() argument must be (string|ex(symbol)) (got <type 'int'>)
 
Use .is_symbol() method to check whether an object is symbol or not:
>>> a = symbol()
>>> b = ex()
>>> a.is_symbol(),b.is_symbol()
(1, 0)
 
There is also a function for that:
>>> is_symbol(a), is_symbol([])
(1, 0)
 
To get the name of a symbol:
>>> a = symbol('abc')
>>> a.get_name()
'abc'
 
To set a new name to an existing symbol:
>>> a.set_name('foo')
>>> a
symbol('foo')
>>> a.get_name()
'foo'
 
  

 
class test_03_numeric
     
Numeric
-------
 
>>> from ginac import numeric,symbol,is_numeric,I
 
To construct numeric from Python objects:
>>> numeric(3)
numeric('3')
>>> numeric(1.5)
numeric('1.5')
>>> numeric(1+2j)
numeric('1.0+2.0*I')
>>> numeric('2/6')
numeric('1/3')
>>> numeric(numeric('2/5'))
numeric('2/5')
>>> numeric(2,7)
numeric('2/7')
>>> numeric()
numeric('0')
>>> 2*I+3
numeric('3+2*I')
 
But it fails for other objects like lists, etc.:
>>> numeric([2])
Traceback (most recent call last):
...
TypeError: numeric from_python() argument must be (number|string|ex(numeric)) (got <type 'list'>)
 
To check whether an expression is numeric:
>>> a,b=symbol(),numeric(2,3)
>>> a.is_numeric(),b.is_numeric()
(0, 1)
>>> is_numeric(b), is_numeric([])
(1, 0)
 
Auxiliary functions (and methods):
>>> from ginac import is_positive, is_integer, is_pos_integer,is_nonneg_integer
>>> map(is_positive,[1,-1,numeric(2),ex(-1),symbol(),[]])
[1, 0, 1, 0, 0, 0]
>>> from ginac import is_even, is_odd, is_prime, is_rational, is_real
>>> from ginac import is_cinteger, is_crational,is_negative
>>> from ginac import real,imag
>>> print int(numeric(23)),float(numeric(2.3))
23 2.3
 
Functions:
>>> from ginac import doublefactorial, bernoulli, fibonacci, isqrt,mod
>>> from ginac import gcd,lcm,irem,iquo
 
Precision:
>>> from ginac import set_Digits,get_Digits
 
  

 
class test_04_lst
     
Lst
------
 
Create GiNaC list from Python objects:
>>> from ginac import lst,is_lst, numeric
>>> lst()
lst([])
>>> lst([])
lst([])
>>> lst(2)
lst([numeric('2')])
>>> lst([2,[]])
lst([numeric('2'), lst([])])
>>> lst(lst([2,3]))
lst([numeric('2'), numeric('3')])
 
Check if object is lst:
>>> is_lst(lst()), is_lst([])
(1, 0)
>>> lst().is_lst(), numeric().is_lst()
(1, 0)
 
Slicing:
>>> a = lst(range(6))
>>> print a[1]
1
>>> print a[1:4]
[1, 2, 3]
>>> print a[5:1:-1]
[5, 4, 3, 2]
 
Modifying in-place:
>>> a[1] = 11
>>> a[3:] = [33,44,55]
>>> print a
[0, 11, 2, 33, 44, 55]
 
  

 
class test_05_add
     
Add
---
 
>>> from ginac import add,symbol,numeric,ex,is_add,is_numeric
>>> c = add(symbol('a'),numeric(3,4))
>>> c
add([symbol('a'), numeric('3/4')])
>>> c.is_add(), ex().is_add()
(1, 0)
>>> d = add(3,4)
>>> d
numeric('7')
>>> is_numeric(d), is_add(d), is_add({})
(1, 0, 0)
>>> add([])
numeric('0')
>>> add(3)
numeric('3')
>>> add([symbol('a'), numeric('3/4')])
add([symbol('a'), numeric('3/4')])
>>> add()
numeric('0')
>>> add({})
Traceback (most recent call last):
...
TypeError: ex_from_ref() argument must be number|string|ex|sequence (got <type 'dictionary'>)
 
  

 
class test_06_mul
     
Mul
---
 
>>> from ginac import mul,symbol,numeric,ex,is_mul,is_numeric
>>> c = mul(symbol('a'),numeric(3,4))
>>> c
mul([symbol('a'), numeric('3/4')])
>>> c.is_mul(), ex().is_mul()
(1, 0)
>>> d = mul(3,4)
>>> d
numeric('12')
>>> is_numeric(d), is_mul(d), is_mul({})
(1, 0, 0)
>>> mul([])
numeric('1')
>>> mul(3)
numeric('3')
>>> mul([symbol('a'), numeric('3/4')])
mul([symbol('a'), numeric('3/4')])
>>> mul()
numeric('1')
>>> mul({})
Traceback (most recent call last):
...
TypeError: ex_from_ref() argument must be number|string|ex|sequence (got <type 'dictionary'>)
 
  

 
class test_07_power
     
Power
------
 
>>> from ginac import power,symbol,is_power
>>> power(2,3)
numeric('8')
>>> power(symbol('a'),2)
power(symbol('a'), numeric('2'))
>>> power(symbol('a'),0)
numeric('1')
>>> p = power(symbol('a'),symbol('b'))
>>> p.is_power(), symbol().is_power()
(1, 0)
>>> is_power(p), is_power(1)
(1, 0)
>>> from ginac import sqrt
>>> print sqrt(-1)
I
>>> print sqrt(symbol('aa'))
sqrt(aa)
 
  

 
class test_08_inifcns
     
Functions
---------
 
>>> from ginac import abs,csgn,sin,cos,tan,exp,log,asin,acos,atan,atan2
>>> from ginac import sinh,cosh,tanh,asinh,acosh,atanh
>>> from ginac import Li2,Li3,zeta,lgamma,tgamma,psi
>>> from ginac import factorial,binomial,Order,Derivative
>>> from ginac import lsolve,symbol,lst,subs
>>> s = [symbol('a'),symbol('b'),symbol('c')]
>>> eqns = [s[0]+2*s[1]+3,s[1]-3*s[2]-5]
>>> print lst(eqns)
[3 + 2 * b + a, -5 - 3 * c + b]
>>> print lsolve(eqns,s)
[a == -13 - 6 * c, b == 5 + 3 * c, c == c]
>>> print lsolve(eqns,s[:2])
[a == -13 - 6 * c, b == 5 + 3 * c]
>>> print lsolve(eqns,s[1:])
[b == -3/2 - 1/2 * a, c == -13/6 - 1/6 * a]
>>> sol = lsolve(eqns,s)
>>> print subs(eqns, sol)
[0, 0]
 
  

 
class test_09_function
     
Function
------
 
To create a GiNaC function, use build_function:
>>> from ginac import build_function
 
To make a function with zero parameters:
>>> foo = build_function('foo')
>>> foo()
foo()
>>> print foo()
foo()
 
To make a function with one parameter:
>>> foo = build_function('foo',nofargs=1)
>>> foo(3)
foo(numeric('3'))
>>> print foo(3)
foo(3)
 
etc. Maximum number of parameters is 12:
>>> bar = build_function('bar',nofargs=12)
>>> print bar(1,2,3,4,5,6,7,8,9,0,1,2)
bar(1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2)
>>> bar2 = build_function('bar2',nofargs=13)
Traceback (most recent call last):
...
NotImplementedError: _build_function() first argument must be less than 12
 
An exception is raised, when function is used with the wrong
number of parameters:
>>> foo(3,4)
Traceback (most recent call last):
...
TypeError: function foo() takes exactly 1 argument (2 given)
 
For automatic evaluation use user-defined evaluation function:
>>> from ginac import numeric
>>> def gun_eval(x):
...     if x.is_negative(): return 0
...     return gun(x,hold=1)
>>> gun = build_function('gun',eval_f=gun_eval)
>>> print gun(-1), gun(3)
0 gun(3)
 
Important:
Note the use of the `hold' keyword which stops futher automatic
evaluation of the function. You **MUST** use it when no more
evaluation is desired. Otherwise the evaluation function is called
recursively until something nasty happens (recursion depth is
reached, out of memory error,...).
 
Similary, you can submit functions for numerical evaluation (evalf_f,
must take nofargs arguments), for derivative (derivative_f, must take
nofargs+1 arguments), and for series expansion (series_f, must take
nofargs+3 arguments). For example,
>>> def sun_derivative(x,i):
...     # return derivative in respect to the i-th parameter.
...     assert int(i)==0
...     if x.is_negative(): return 0
...     return x*sun(x)
>>> sun = build_function('sun', derivative_f=sun_derivative)
>>> print sun(3)
sun(3)
>>> from ginac import symbol
>>> z = symbol('z')
>>> print sun(z).diff(z)
z * sun(z)
>>> print sun(z).diff(z,2)
z ** 2 * sun(z) + sun(z)
 
Note that build_function is able to determine the number of parameters
automatically from the given functions eval_f, evalf_f, derivative_f, series_f.
But in some occasions it is impossible. Therefore, giving the nofargs explicitly
is always recommended.
 
Auxiliary functions:
>>> from ginac import is_function, sin
>>> is_function(sin(2))
1
>>> sin(2).get_name()
'sin'
 
  

 
class test_10_relational
     
Relational
------
 
>>> from ginac import relational
>>> print relational(2,3)
2 == 3
>>> print relational(2,3,'==')
2 == 3
>>> print relational(2,3,'!=')
2 != 3
>>> print relational(2,3,'<')
2 < 3
>>> print relational(2,3,'<=')
2 <= 3
>>> print relational(2,3,'>')
2 > 3
>>> print relational(2,3,'>=')
2 >= 3
>>> relational(2,3,'aaaa')
Traceback (most recent call last):
...
TypeError: relational::operators from_python() argument must be (string: == | != | < | <= | > | >=) (got <type 'string'>)
>>> relational(2,3,'==')
relational(numeric('2'), numeric('3'))
>>> relational(2,3,'!=')
relational(numeric('2'), numeric('3'), '!=')
>>> relational(2,3,'<')
relational(numeric('2'), numeric('3'), '<')
>>> relational(2,3,'<=')
relational(numeric('2'), numeric('3'), '<=')
>>> relational(2,3,'>')
relational(numeric('2'), numeric('3'), '>')
>>> relational(2,3,'>=')
relational(numeric('2'), numeric('3'), '>=')
>>> relational(relational(2,3))
relational(numeric('2'), numeric('3'))
>>> print relational((2,3))
2 == 3
>>> print relational((2,3,'>'))
2 > 3
>>> from ginac import rhs,lhs,symbol
>>> print lhs(relational ((2,3)))
2
>>> print rhs(relational ((2,3)))
3
>>> print relational ((2,3)).lhs()
2
>>> print relational ((2,3)).rhs()
3
>>> lhs(symbol())
Traceback (most recent call last):
...
TypeError: ex.lhs() can be used only for ex(relational).
>>> not relational(2,3)
1
>>> not relational(2,2)
0
>>> from ginac import is_relational,numeric
>>> is_relational(2), is_relational(relational(2,3))
(0, 1)
>>> numeric().is_relational(), relational(2,3).is_relational()
(0, 1)
 
>>> a = relational(2,3)
>>> print a
2 == 3
>>> a[0] = 4
>>> print a
4 == 3
 
  

 
class test_11_seq
     
Seq
---
 
  

 
class test_12_constant
     
Constant
------
 
>>> from ginac import constant, is_constant,numeric
>>> a=constant('a')
>>> a.is_constant(),numeric(2).is_constant()
(1, 0)
>>> a
constant('a')
>>> print a
a
>>> b = constant('b',1.5)
>>> print b, b.evalf()
b 1.5
>>> def c_eval():
...     return numeric(2)/3
>>> c = constant('c',c_eval)
>>> print c, c.evalf()
c 0.6666666666666666667
>>> from ginac import Pi, Euler, Catalan
>>> Pi
constant('Pi')
>>> print Pi
Pi
>>> print Pi.evalf(), Euler.evalf(), Catalan.evalf()
3.1415926535897932385 0.5772156649015328606 0.91596559417721901505
 
  

 
class test_13_matrix
     
Matrix
------
 
>>> from ginac import matrix,is_matrix,numeric
 
Column vector:
>>> print matrix([1,2])
[[1],
 [2]]
 
Row vector:
>>> print matrix([[1,2]])
[[1, 2]]
 
Matrix:
>>> a = matrix([[1,2],[3,4]])
>>> print a
[[1, 2],
 [3, 4]]
>>> a
matrix([[numeric('1'), numeric('2')],
        [numeric('3'), numeric('4')]])
 
Take a row:
>>> print a[1]
[[3, 4]]
 
Take a column:
>>> print a[:,1]
[[2],
 [4]]
 
Take an element:
>>> print a[0,1]
2
 
Auxiliary functions:
>>> a.is_matrix(),is_matrix(a),numeric().is_matrix(),is_matrix(numeric())
(1, 1, 0, 0)
 
Matrix constructors:
>>> print matrix(2,3)
[[0, 0, 0],
 [0, 0, 0]]
>>> print matrix(2,3,range(6))
[[0, 1, 2],
 [3, 4, 5]]
>>> print matrix(2,3,[1,2,3])
[[1, 2, 3],
 [0, 0, 0]]
 
Slicing:
>>> a = matrix(3,4,range(12))
>>> print a
[[0, 1, 2, 3],
 [4, 5, 6, 7],
 [8, 9, 10, 11]]
>>> print a[1:]
[[4, 5, 6, 7],
 [8, 9, 10, 11]]
>>> print a[:,1:]
[[1, 2, 3],
 [5, 6, 7],
 [9, 10, 11]]
>>> print a[0:2, 1:3]
[[1, 2],
 [5, 6]]
>>> print a[:,::-1]
[[3, 2, 1, 0],
 [7, 6, 5, 4],
 [11, 10, 9, 8]]
>>> print a[:,::2]
[[0, 2],
 [4, 6],
 [8, 10]]
>>> print a[1,1:-1]
[[5, 6]]
 
Modifying in-place:
>>> a = matrix(3,3)
>>> a[1,1] = 8        # middle element
>>> a[-1] = [3,2,1]   # last row
>>> a[:,-1] = [5,4,1] # last column
>>> print a
[[0, 0, 5],
 [0, 8, 4],
 [3, 2, 1]]
>>> a = matrix(4,4)   # 4x4 matrix of zeros
>>> a[1:3,1:3] = [[1,2],[3,4]]
>>> print a
[[0, 0, 0, 0],
 [0, 1, 2, 0],
 [0, 3, 4, 0],
 [0, 0, 0, 0]]
 
Functions:
>>> from ginac import rows, cols, transpose
>>> rows(a), cols(a), a.rows(), a.cols()
(4, 4, 4, 4)
>>> print transpose(a)
[[0, 0, 0, 0],
 [0, 1, 3, 0],
 [0, 2, 4, 0],
 [0, 0, 0, 0]]
>>> print a.transpose()
[[0, 0, 0, 0],
 [0, 1, 3, 0],
 [0, 2, 4, 0],
 [0, 0, 0, 0]]
 
>>> from ginac import determinant,trace,inverse,charpoly
>>> a = matrix(2,2,[1,2,3,4])
>>> print a
[[1, 2],
 [3, 4]]
>>> print a.determinant(), a.determinant('gauss')
-2 -2
>>> print determinant(a), determinant(a,'divfree')
-2 -2
>>> print a.trace(), trace(a)
5 5
>>> print a.inverse()
[[-2, 1],
 [3/2, -1/2]]
>>> print a*inverse(a)
[[1, 0],
 [0, 1]]
>>> print charpoly(a,'lambda')
-2 - 5 * lambda + lambda ** 2
>>> from ginac import symbol
>>> print a.charpoly(symbol('lambda'))
-2 - 5 * lambda + lambda ** 2
>>> syms = [symbol('a1'),symbol('a2')]
>>> print a.solve(syms,[5,-6])
[[-16],
 [21/2]]
>>> print a*a.solve(syms,[5,-6])
[[5],
 [-6]]
 
>>> from ginac import diag_matrix
>>> print diag_matrix([1,2,3])
[[1, 0, 0],
 [0, 2, 0],
 [0, 0, 3]]
 
  

 
class test_14_pseries
     
Power Series
------
 
>>> from ginac import is_pseries,pseries
>>> from ginac import is_terminating, is_compatible_to
>>> from ginac import symbol,series
>>> x = symbol('x')
>>> e = x**5 + 2*x**4 + 3*x**3 + 4*x**2 + 5 * x + 6
>>> p1 = series(e,(x,0),3)
>>> print p1
6 + 5 * x + 4 * x ** 2 + Order(x ** 3)
>>> p2 = series(e,(x,1),3)
>>> print p2
21 + 35 * (-1 + x) + 35 * (-1 + x) ** 2 + Order((-1 + x) ** 3)
>>> from ginac import sin
>>> p = series(sin(x),(x,0),5)
>>> p.is_pseries(), is_pseries(p), x.is_pseries(), is_pseries({})
(1, 1, 0, 0)
>>> p.is_compatible_to(p1), is_compatible_to(p, p1)
(1, 1)
>>> print p
1 * x + (-1/6) * x ** 3 + Order(x ** 5)
>>> print p + p1
6 + 6 * x + 4 * x ** 2 + Order(x ** 3)
>>> print p1 - p
6 + 4 * x + 4 * x ** 2 + Order(x ** 3)
>>> print p * p1
6 * x + 5 * x ** 2 + 3 * x ** 3 + Order(x ** 4)
>>> from ginac import Order
>>> r = pseries((x,0),[(3,-1),(2,2),(Order(1),3)])
>>> print r
3 * x ** (-1) + 2 * x ** 2 + Order(x ** 3)
>>> print r * p
3 + (-1/2) * x ** 2 + 2 * x ** 3 + Order(x ** 4)
>>> from ginac import series_to_poly
>>> print p.to_poly()
-1/6 * x ** 3 + Order(x ** 5) + x
>>> print p.to_poly(1)
-1/6 * x ** 3 + x
>>> print series_to_poly(p)
-1/6 * x ** 3 + Order(x ** 5) + x
>>> print r << 5   # shift powers by degree = 5
3 * x ** 4 + 2 * x ** 7 + Order(x ** 8)
 
>>> p=series(x,(x,1),2)
>>> print p
1 + 1 * (-1 + x)
>>> print p*x
1 + 2 * (-1 + x) + 1 * (-1 + x) ** 2
>>> print p ** 4
1 + 4 * (-1 + x) + 6 * (-1 + x) ** 2 + 4 * (-1 + x) ** 3 + Order((-1 + x) ** 4)
>>> print pow(p,4,2)
1 + 4 * (-1 + x) + Order((-1 + x) ** 2)
 
  

 
class test_15_ncmul
     
Non-commutative multiplication
------------------------------
 
>>> from ginac import is_ncmul,ncmul
 
  

 
Functions
            
Derivative(f, l)
Inert partial differentiation operator.
Li2(x)
Dilogarithm.
Li3(x)
Trilogarithm.
Order(x)
Order term function (for truncated power series).
_build_function(nofargs, name, texname=None, eval=None, evalf=None, derivative=None, series=None)
Build GiNaC function with Python eval,evalf,derivative,series
callback functions.          
Return the serial number of constructed function.
Used internally. See build_function().
_function(ser, hold, seq)
Return image of a function with serial number `ser' and
arguments `seq'. Last item in `seq' must be ex(pyfunc) object.
Used internally.
_pyfunc(ser)
Return ex(pyfunc) holding serial number `ser'.
Used internally.
abs(x)
Absolute value.
acos(x)
Inverse cosine (arc cosine).
acosh(x)
Inverse hyperbolic Cosine (area hyperbolic cosine).
add(*args)
add() - return numeric('0').
add(l,r) - add two expressions.
  If `l' and/or `r' are Python objects, an attempt is made to convert
  them to ex objects.
add(seq) - sum of expressions in a sequence `seq'.
add(add(...)) -> add(...)
asin(x)
Inverse sine (arc sine).
asinh(x)
Inverse hyperbolic Sine (area hyperbolic sine).
atan(x)
Inverse tangent (arc tangent).
atan2(x, y)
Inverse tangent with two arguments.
atanh(x)
Inverse hyperbolic Tangent (area hyperbolic tangent).
bernoulli(n)
`n' must be integer.
binomial(n, k)
Binomial function.
build_function(name, texname=None, eval_f=None, evalf_f=None, derivative_f=None, series_f=None, nofargs=None)
Construct symbolic function with a name `name'.
 
Optional arguments:
texname      - LaTeX string;
nofargs      - the number of arguments to a function (if not specified,
               build_function tries to establish `nofargs' from functions `eval',
               `evalf', `derivative', `series'. If that fails, 12 is set.);
eval_f       - eval_f(*args) is used for automatic non-interruptive symbolic
               evaluation;
evalf_f      - evalf_f(*args) is used for numeric evaluation;
derivative_f - derivative_f(*args,i) is used for computing
               the 1st derivative with respect to `i'-th argument (i>=0);
series_f     - series_f(*args,rel,order,opts = 0) is used for computing
               the truncated series expansion around a point `rhs(rel)'
               with respect to variable `lhs(rel)'. `order' is the truncation
               order.
charpoly(m, sym)
Characteristic Polynomial.
Following mathematica notation the characteristic polynomial of a
matrix M is defined as the determiant of `(M - sym * 1)' where 1
stands for the unit matrix of the same dimension as M. Note that
some CASs define it with a sign inside the determinant which gives
rise to an overall sign if the dimension is odd. This method
returns the characteristic polynomial collected in powers of
`sym' as a new expression.
`sym' must be a ex(symbol)|string.
coeff(expr, sym, n=1)
Return coefficient of degree `n' in expressin `sym' of `expr'.
Both `expr' and `sym' must be ex objects.
collect(expr, sym)
Sort expression `expr' in terms of powers of `sym'.
cols(m)
Get number of columns.
constant(name, value=None)
constant(name) - return new constant with a `name'.
constant(name, value) - return new constant with a `name' and `value'.
  `value' must be number.
constant(name, func) - return new constant with a `name' and evaluation
  function `func'. `func' must be callable with 0 arguments and return
  the value of the constant.
constant(constant(...)) -> constant(...)
cos(x)
Cosine.
cosh(x)
Hyperbolic Cosine.
csgn(x)
Complex sign.
degree(expr, sym)
Return degree of highest power in expression `sym' of `expr'.
Both `expr' and `sym' must be ex objects.
denom(expr)
Return denominator of an expression.
If the expression is not of the normal form "numerator/denominator",
it is first converted to this form and then the denominator is returned.
`expr' must be an ex object.
determinant(m, algo='automatic')
Determinant of a square matrix.
If all the elements of the matrix are elements of an integral
domain the determinant is also in that integral domain and the
result is expanded only. If one or more elements are from a
quotient field the determinant is usually also in that quotient
field and the result is normalized before it is returned. This
implies that the determinant of the symbolic 2x2 matrix
[[a/(a-b),1],[b/(a-b),1]] is returned as unity. (In this respect,
it behaves like MapleV and unlike Mathematica.)
 
Option algo:
  'automatic' - let the system choose  
  'gauss'     - Gauss elimiation
  'divfree'   - Division-free elimination
  'laplace'   - Laplace (or minor) elimination
  'bareiss'   - Bareiss fraction-free elimination
diag_matrix(seq)
Return a new matrix with a diagonal `seq'.
diff(expr, sym, nth=1)
Compute partial derivative of an expression `expr'.
`expr' must be an ex object.
`sym' must be an ex(symbol) object.
doublefactorial(n)
`n' must be integer.
eval(expr, level=0)
Perform automatic non-interruptive symbolic evaluation on `expr'.
`expr' must be an ex object.
evalf(expr, level=0)
Evaluate `expr' numerically.
`expr' must be an ex object.
exp(x)
Exponential function.
expand(expr, options=0)
Expand expression `expr'.
`expr' must be an ex object.
options:
  1 - expand trigonometric,
  2 - expand indexed.
factorial(x)
Factorial function.
fibonacci(n)
`n' must be integer.
gcd(n, m)
`n' and `m' must be integers.
get_Digits()
Return the number of decimal digits.
has(expr, other)
Check if `expr' contains any occurrences of `other'.
Both `expr' and `other' must be ex objects.
imag(expr)
Return imaginary part.
`expr' must be number.
inverse(m)
Inverse of a square matrix.
iquo(n, m, k=None)
`n' and `m' must be integers. `k' must be ex(numeric).
irem(n, m, k=None)
`n' and `m' must be integers. `k' must be ex(numeric).
is_add(obj)
Check if `obj' is add.
is_cinteger(obj)
Check if complex integer.
is_compatible_to(obj, other)
Check if `obj' is compatible pseries to pseries `other'
(i.e., expansion variable and point are the same).
is_constant(obj)
Check if `obj' is constant.
is_crational(obj)
Check if complex rational.
is_even(obj)
Check if even integer.
is_function(obj)
Check if `obj' is function.
is_integer(obj)
Check if integer.
is_lst(obj)
Check if `obj' is lst.
is_matrix(obj)
Check if `obj' is matrix.
is_mul(obj)
Check if `obj' is mul.
is_ncmul(obj)
Check if `obj' is ncmul.
is_nonneg_integer(obj)
Check if nonnegative integer.
is_numeric(obj)
Check if `obj' is numeric.
is_odd(obj)
Check if odd integer.
is_pos_integer(obj)
Check if positive integer.
is_positive(obj)
Check if negative number.
is_power(obj)
Check if `obj' is power.
is_prime(obj)
Check if integer prime.
is_pseries(obj)
Check if `obj' is pseries.
is_rational(obj)
Check if rational.
is_real(obj)
Check if real.
is_relational(obj)
Check if `obj' is relational.
is_symbol(obj)
Check if `obj' is symbol.
is_terminating(obj)
Check if `obj' is terminating pseries (i.e., without Order term).
is_zero(expr)
Test for zero.
`expr' must be an ex object.
isqrt(n)
`n' must be integer.
lcm(n, m)
`n' and `m' must be integers.
lcoeff(expr, sym)
Return `coeff(expr, sym, degree(expr, sym))'.
ldegree(expr, sym)
Return degree of lowest power in expression `sym' of `expr'.
Both `expr' and `sym' must be ex objects.
lgamma(x)
Gamma-function.
lhs(expr)
Left hand side of relational expression `expr'.
log(x)
Natural logarithm.
lsolve(eqns, syms)
Solve linear system.
eqns - list of expressions or/and ex(relational) objects.
syms - list of symbols.
Return solution as a GiNaC list of ex(relational) objects.
If sol = lsolve(eqns,syms), then subs(eqns, sol) returns list of zeros.
lst(seq=[])
Return GiNaC list of expressions.
lst(lst(...)) -> lst(...)
matrix(*args)
matrix(seq) - construct matrix from a 1- or 2-sequence `seq'.
  If `seq' is 1-sequence, then returned matrix is formed as a column matrix.
matrix(r,c) - construct r x c matrix filled with zeros.
matrix(r,c,seq) - construct r x c matrix filled with elements in a flat
  sequence `seq'
matrix(matrix(...)) -> matrix(...)
mod(n, m)
`n' and `m' must be integers.
mul(*args)
mul() - return numeric('1').
mul([]) - return numeric('1').
mul(l,r) - multiply two expressions.
  If `l' and/or `r' are Python objects, they are converted to ex objects.
mul(seq) - product of expressions in a sequence `seq'.
mul(mul(...)) -> mul(...)
ncmul(*args)
ncmul() - return numeric('1').
ncmul([]) - return numeric('1').
ncmul(l,r) - multiply two expressions.
  If `l' and/or `r' are Python objects, they are converted to ex objects.
ncmul(seq) - product of expressions in a sequence `seq'.
ncmul(ncmul(...)) -> ncmul(...)
nops(expr)
Return number of operands/members in `expr'.
expr must be an ex object.
normal(expr, level=0)
Normalization of rational functions.
 
This function converts an expression to its normal form
"numerator/denominator", where numerator and denominator are
(relatively prime) polynomials. Any subexpressions which are not
rational functions (like non-rational numbers, non-integer powers or
functions like sin(), cos() etc.) are replaced by temporary symbols
which are re-substituted by the (normalized) subexpressions before
normal() returns (this way, any expression can be treated as a
rational function). normal() is applied recursively to arguments of
functions etc.
level - maximum depth of recursion.
numer(expr)
Return numerator of an expression.
If the expression is not of the normal form "numerator/denominator",
it is first converted to this form and then the numerator is
returned.  `expr' must be an ex object.
numeric(*args)
numeric() - return numeric('0')
numeric(i) - construct numeric from Python int `i'
numeric(f) - construct numeric from Python float `f'
numeric(c) - construct numeric from Python complex `c'
numeric(s) - construct numeric from Python string `s'
numeric(n,d) - construct numeric as numeric(n)/numeric(d)
numeric(numeric(...)) -> numeric(...)
op(expr, i)
Return `expr' operand/member at position `i'.
expr must be an ex object.
power(base, exponent)
Power base ** exponent.
power(power(...)) -> power(...)
pseries(rel, seq)
Return power series.
rel - holds an expansion variable and an expansion point
      (as a 2-sequence|ex(relational)).
seq - holds pairs of coefficients and exponents.
For example,
  pseries((x,x0),[(a,-1),(b,2),(Order(1),5)])
corresponds to power series
  a / (x-x0) + b * (x-x0) ** 2 + Order((x-x0) ** 5)
 
pseries(pseries(...)) -> pseries(...)
psi(x, nth=0)
Psi-function (aka digamma-function) and its derivatives.
real(expr)
Return real part.
`expr' must be number.
relational(*args)
relational(l,r) - logical relation `l == r'.
relational(l,r,'!=') - logical relation `l != r'.
relational(l,r,'<') - logical relation `l < r'.
relational(l,r,'<=') - logical relation `l <= r'.
relational(l,r,'>') - logical relation `l > r'.
relational(l,r,'>=') - logical relation `l >= r'.
relational(relational(...)) -> relational(...)
relational(2-seq) - logical relation `seq[0] == seq[1]'.
relational(3-seq) - logical relation `seq[0] seq[2] seq[1]'.
rhs(expr)
Right hand side of relational expression `expr'.
rows(m)
Get number of rows.
series(expr, rel, order, options=0)
Compute the truncated series expansion of an expression `expr'.
Return an expression containing an object ex(pseries) to
represent the series. If the series does not terminate within the
given truncation order, the last term of the series will be an order
term.
rel - expansion relation, lhs holds variable and rhs holds point.
order - truncation order of series calculations.
options = 1 -  suppress branchcut.
`expr' must be an ex object.
`rel' must be an ex(relational) object or a 2-sequence.
series_to_poly(expr, no_order=1)
Convert the pseries object to an ordinary polynomial.
If no_order, then discard higher order terms.
`expr' must be ex(pseries).
set_Digits(prec=17)
Set the number of decimal digits.
sin(x)
Sine.
sinh(x)
Hyperbolic Sine.
sqrt(x)
Square root.
subs(expr, *args)
Substitute objects in an expression `expr' (syntactic substitution)
and return the result as a new expression (that is already evaluated).
 
subs(expr, e) - `e' must be ex(relational)|ex(lst(relational,...)).
subs(expr, ls, lr) - `ls, lr' are lists of symbols and their
  replacements, respectively.
swap(expr, other)
Swap efficiently the contents of two expressions.
Both `expr' and `other' must be ex objects.
symbol(name=r'symbol\d+')
symbol() - create symbol with a name of the form `symbol\d+'.
symbol('name') - create symbol with a name 'name'.
symbol(symbol(...)) -> symbol(...)
tan(x)
Tangent.
tanh(x)
Hyperbolic Tangent.
tcoeff(expr, sym)
Return `coeff(expr, sym, ldegree(expr, sym))'.
tgamma(x)
Gamma-function.
to_rational(expr, repl_lst)
Rationalization of non-rational functions.
 
This function converts a general expression `expr' to a rational
polynomial by replacing all non-rational subexpressions (like
non-rational numbers, non-integer powers or functions like sin(),
cos() etc.) to temporary symbols. This makes it possible to use
functions like gcd() and divide() on non-rational functions by
applying to_rational() on the arguments, calling the desired
function and re-substituting the temporary symbols in the result. To
make the last step possible, all temporary symbols and their
associated expressions are collected in the list specified by the
`repl_lst' parameter in the form {symbol == expression}, ready to be
passed as an argument to ex.subs().
 
`expr' must be an ex object. `repl_lst' must be an ex(lst) object.
It collects a GiNaC list of all temporary symbols and their replacements.
trace(m)
Trace of a square matrix.        
The result is normalized if it is in some quotient field and
expanded only otherwise. This implies that the trace of the
symbolic 2x2 matrix [[a/(a-b),x],[y,b/(b-a)]] is recognized to be
unity.
Return the sum of diagonal elements.
transpose(m)
Return transposed matrix.
zeta(x, nth=0)
Riemann's Zeta-function and its derivatives.

 
Data
             __author__ = 'Pearu Peterson <pearu@cens.ioc.ee>'
__credits__ = 'GiNaC group (www.ginac.de), for the GiNaC librar...plified in exposing GiNaC C++ classes to Python.\n'
__date__ = 'Fri Apr 27 13:52:54 2001'
__file__ = '/usr/opt/Python2.1/lib/python2.1/site-packages/ginac/doc/__init__.pyc'
__name__ = 'ginac.doc'
__path__ = ['/usr/opt/Python2.1/lib/python2.1/site-packages/ginac/doc']
__version__ = '0.4.65'

 
Author
             Pearu Peterson <pearu@cens.ioc.ee>

 
Credits
             GiNaC group (www.ginac.de), for the GiNaC library.
Boost.Python group (www.boost.org), for BPL that considerably
simplified in exposing GiNaC C++ classes to Python.