updated for new behaviour of dirac_slash() and epsilon tensor

[ginac.git] / doc / tutorial / ginac.texi

diff --git a/doc/tutorial/ginac.texi b/doc/tutorial/ginac.texi
index 330e079a5a3f51c9ecc95b714eadfe961481369d..e93bb6c65b3ef2f88fb46b316935ffdfd987e7c9 100644 (file)
--- a/doc/tutorial/ginac.texi
+++ b/doc/tutorial/ginac.texi
@@ -1871,6 +1871,8 @@ that performs some more expensive operations:
 @item it (symbolically) calculates all possible dummy index summations/contractions
   with the predefined tensors (this will be explained in more detail in the
   next section)
+@item it detects contractions that vanish for symmetry reasons, for example
+  the contraction of a symmetric and a totally antisymmetric tensor
 @item as a special case of dummy index summation, it can replace scalar products
   of two tensors with a user-defined value
 @end itemize
@@ -2072,7 +2074,27 @@ The first two functions create an epsilon tensor in 2 or 3 Euclidean
 dimensions, the last function creates an epsilon tensor in a 4-dimensional
 Minkowski space (the last @code{bool} argument specifies whether the metric
 has negative or positive signature, as in the case of the Minkowski metric
-tensor).
+tensor):
+
+@example
+@{
+    varidx mu(symbol("mu"), 4), nu(symbol("nu"), 4), rho(symbol("rho"), 4),
+           sig(symbol("sig"), 4), lam(symbol("lam"), 4), bet(symbol("bet"), 4);
+    e = lorentz_eps(mu, nu, rho, sig) *
+        lorentz_eps(mu.toggle_variance(), nu.toggle_variance(), lam, bet);
+    cout << simplify_indexed(e) << endl;
+     // -> 2*eta~bet~rho*eta~sig~lam-2*eta~sig~bet*eta~rho~lam
+
+    idx i(symbol("i"), 3), j(symbol("j"), 3), k(symbol("k"), 3);
+    symbol A("A"), B("B");
+    e = epsilon_tensor(i, j, k) * indexed(A, j) * indexed(B, k);
+    cout << simplify_indexed(e) << endl;
+     // -> -B.k*A.j*eps.i.k.j
+    e = epsilon_tensor(i, j, k) * indexed(A, j) * indexed(A, k);
+    cout << simplify_indexed(e) << endl;
+     // -> 0
+@}
+@end example
 
 @subsection Linear algebra
 
@@ -2299,8 +2321,10 @@ Finally, the function
 ex dirac_slash(const ex & e, const ex & dim, unsigned char rl = 0);
 @end example
 
-creates a term of the form @samp{e.mu gamma~mu} with a new and unique index
-whose dimension is given by the @code{dim} argument.
+creates a term that represents a contraction of @samp{e} with the Dirac
+Lorentz vector (it behaves like a term of the form @samp{e.mu gamma~mu}
+with a unique index whose dimension is given by the @code{dim} argument).
+Such slashed expressions are printed with a trailing backslash, e.g. @samp{e\}.
 
 In products of dirac gammas, superfluous unity elements are automatically
 removed, squares are replaced by their values and @samp{gamma5} is
@@ -2315,13 +2339,12 @@ contractions in gamma strings, for example
     ex e = dirac_gamma(mu) * dirac_slash(a, D)
          * dirac_gamma(mu.toggle_variance());
     cout << e << endl;
-     // -> (gamma~mu*gamma~symbol10*gamma.mu)*a.symbol10
+     // -> gamma~mu*a\*gamma.mu
     e = e.simplify_indexed();
     cout << e << endl;
-     // -> -gamma~symbol10*a.symbol10*D+2*gamma~symbol10*a.symbol10
+     // -> -D*a\+2*a\
     cout << e.subs(D == 4) << endl;
-     // -> -2*gamma~symbol10*a.symbol10
-     // [ == -2 * dirac_slash(a, D) ]
+     // -> -2*a\
     ...
 @}
 @end example
@@ -3201,6 +3224,42 @@ This function object could then be used like this:
 @}
 @end example
 
+Here is another example for you to meditate over. It removes quadratic
+terms in a variable from an expanded polynomial:
+
+@example
+struct map_rem_quad : public map_function @{
+    ex var;
+    map_rem_quad(const ex & var_) : var(var_) @{@}
+
+    ex operator()(const ex & e)
+    @{
+        if (is_a<add>(e) || is_a<mul>(e))
+           return e.map(*this);
+        else if (is_a<power>(e) && e.op(0).is_equal(var) && e.op(1).info(info_flags::even))
+            return 0;
+        else
+            return e;
+    @}
+@};
+
+...
+
+@{
+    symbol x("x"), y("y");
+
+    ex e;
+    for (int i=0; i<8; i++)
+        e += pow(x, i) * pow(y, 8-i) * (i+1);
+    cout << e << endl;
+     // -> 4*y^5*x^3+5*y^4*x^4+8*y*x^7+7*y^2*x^6+2*y^7*x+6*y^3*x^5+3*y^6*x^2+y^8
+
+    map_rem_quad rem_quad(x);
+    cout << rem_quad(e) << endl;
+     // -> 4*y^5*x^3+8*y*x^7+2*y^7*x+6*y^3*x^5+y^8
+@}
+@end example
+
 @command{ginsh} offers a slightly different implementation of @code{map()}
 that allows applying algebraic functions to operands. The second argument
 to @code{map()} is an expression containing the wildcard @samp{$0} which
@@ -4401,7 +4460,10 @@ function that does so, in this case the one in class @code{numeric}:
 @example
 static ex cos_evalf(const ex & x)
 @{
-    return cos(ex_to<numeric>(x));
+    if (is_a<numeric>(x))
+        return cos(ex_to<numeric>(x));
+    else
+        return cos(x).hold();
 @}
 @end example
 
@@ -5566,6 +5628,10 @@ and George Labahn, ISBN 0-7923-9259-0, 1992, Kluwer Academic Publishers, Norwell
 J.H. Davenport, Y. Siret, and E. Tournier, ISBN 0-12-204230-1, 1988, 
 Academic Press, London
 
+@item
+@cite{The Art of Computer Programming, Vol 2: Seminumerical Algorithms},
+D.E. Knuth, ISBN 0-201-89684-2, 1998, Addison Wesley
+
 @item
 @cite{The Role of gamma5 in Dimensional Regularization}, D. Kreimer, hep-ph/9401354