- GiNaC-devel - ginac.de

Patch for get_dummy_indices
by Vladimir Kisil 18 Nov '04

18 Nov '04

# Dear All, Presently the method get_dummy_indices() has a non-intuitive behaviour that it forgets about variance of indices and return all of them dotted. This is illustrated by the test included after the signature. This can be altered in many they and include a patch to idx.cpp which uses a sorting rule indifferent to variance of indices. If this patch is applied than a small simplification to clifford.cpp can be done as well. Best wishes, Vladimir -- Vladimir V. Kisil email: kisilv(a)maths.leeds.ac.uk -- www: http://maths.leeds.ac.uk/~kisilv/ ##include <iostream> ##include <ginac/ginac.h> using namespace std; using namespace GiNaC; int main() { varidx mu(symbol("mu"), 4); varidx nu(symbol("nu"), 4, true); symbol A("A"); symbol B("B"); ex e = indexed(A, nu, mu); ex e1 = indexed(B, nu.toggle_variance(), mu.toggle_variance()); lst rl = lst(mu, nu); cout << rl << endl; // -> {~mu,.nu} exvector ind_vec = ex_to<indexed>(e).get_dummy_indices(ex_to<indexed>(e1)); for (exvector::const_iterator it = ind_vec.begin(); it != ind_vec.end(); it++) { cout << ex_to<varidx>(*it) << endl; // -> .nu .mu } return 0; } #

2 3

Patch for get_dummy_indices
by Vladimir Kisil 08 Nov '04

08 Nov '04

Dear All, Presently the method get_dummy_indices() has a non-intuitive behaviour that it forgets about variance of indices and return all of them dotted. This is illustrated by the test: #include <iostream> #include <ginac/ginac.h> using namespace std; using namespace GiNaC; int main() { varidx mu(symbol("mu"), 4); varidx nu(symbol("nu"), 4, true); symbol A("A"); symbol B("B"); ex e = indexed(A, nu, mu); ex e1 = indexed(B, nu.toggle_variance(), mu.toggle_variance()); lst rl = lst(mu, nu); cout << rl << endl; // -> {~mu,.nu} exvector ind_vec = ex_to<indexed>(e).get_dummy_indices(ex_to<indexed>(e1)); for (exvector::const_iterator it = ind_vec.begin(); it != ind_vec.end(); it++) { cout << ex_to<varidx>(*it) << endl; // -> .nu .mu } return 0; } This can be altered in many they and include a patch to idx.cpp which uses a sorting rule indifferent to variance of indices. If this patch is applied than a small simplification to clifford.cpp can be done as well. With this patches my program seems to run 1.5% faster as well ;-) Best wishes, Vladimir -- Vladimir V. Kisil email: kisilv(a)maths.leeds.ac.uk -- www: http://maths.leeds.ac.uk/~kisilv/ Index: ginac/clifford.cpp =================================================================== RCS file: /home/cvs/GiNaC/ginac/clifford.cpp,v retrieving revision 1.82 diff -r1.82 clifford.cpp 1114c1114 < S = S * e.op(j).subs(lst(ex_to<varidx>(*it) == ival, ex_to<varidx>(*it).toggle_variance() == ival), subs_options::no_pattern); --- > S = S * e.op(j).subs(lst(ex_to<varidx>(*it) == ival), subs_options::no_pattern); Index: ginac/idx.cpp =================================================================== RCS file: /home/cvs/GiNaC/ginac/idx.cpp,v retrieving revision 1.62 diff -r1.62 idx.cpp 508a509,519 > // Auxiliary comparison which does not mind the variance of indices > struct idx_is_less : public std::binary_function<ex, ex, bool> { > bool operator() (const ex &lh, const ex &rh) const { > if (is_a<varidx>(lh)) > return (lh.compare(rh) < 0) && > (lh.compare(ex_to<varidx>(rh).toggle_variance()) < 0); > else > return lh.compare(rh) < 0; > } > }; > 528c539 < shaker_sort(v.begin(), v.end(), ex_is_less(), ex_swap()); --- > shaker_sort(v.begin(), v.end(), idx_is_less(), ex_swap());

1 0

CLN 1.1.9 released
by Richard B. Kreckel 04 Nov '04

04 Nov '04

Good evening, It is my pleasure to announce the release of CLN 1.1.9. This is a maintenance release without any funky new features or any incompatibilities whatsoever. There is no reason for an immediate upgrade if you have been lucky with CLN 1.1.8. To quote NEWS file: Algorithmic changes ------------------- * Input of numbers in bases 2, 4, 8, 16 and 32 is now done in linear bit complexity as opposed to O(N^2). Useful for all kinds of persistency. Implementation changes ---------------------- * Fixed several bugs in the integer input and output routines that could be blamed for random crashes in the following cases: output in base 32 for quite large numbers, input in base 2 for fixnums and input in base 3 for fixnums on a 64 bit target. * Fixed crash when radix specifiers were used in input streams. * Speed up on x86_64 and ia64 by adding some inline assembly. Other changes ------------- * Fixes for compilation on MacOS X and little endian Mips. You may download the source tarball via anonymous FTP from <ftp://ftpthep.physik.uni-mainz.de/pub/gnu/cln-1.1.9.tar.bz2>. Happy hacking -richy. -- Richard B. Kreckel <http://www.ginac.de/~kreckel/>

1 0

patch for series expansion of integral.
by Chris Dams 29 Oct '04

29 Oct '04

Dear GiNaCers, Here's a patch. Find out below why you want this patch ;-). The integral class has a .derivative() method, so in principle integrals can be series expanded. However, if somewhere deep down in the integrant a sum with a lot of terms occurs, the same kind of problems that have troubled the series expansion of powers, happen again. Basically we get expression explosion. To solve this I wrote an integral::series() method. While doing this I discovered several bugs/undesirable features, namely (1) When requesting terms of a pseries via pseries::op(), the order term looks like O(1)^n instead of O(x^n). This looks strange and different from the output that one gets from printing the entire series. (2) Since pseries does not have a let_op() method for understandable reasons, eval_integ() does not work for a power series. I have added a new method pseries::eval_integ() to solve this. (3) When trying to find coefficients and exponents of power series, using pseries::op() is not convenient and not efficient. This returns a multiplication of the coefficient with a power that the user then may attempt to extract the coefficient and the exponent from... To make this easier, I added pseries::coeffop() and pseries::exponop() methods. (4) pseries::mul_series() does not know that zero times a power series is zero. (5) If pseries::power_const() discovers that the user is expanding to such a low degree that only the order term needs to be returned, GiNaC sometimes tries to save memory by allocating a negative amount of bytes in order to store a negative number of terms in it. Best, Chris

2 1

GiNaC 1.3.0
by Jens Vollinga 25 Oct '04

25 Oct '04

Hi, GiNaC 1.3.0 is out and available. The changes are: - No funny announcements anymore. - The Clifford classes have been generalized to allow working with Clifford algebras generated by arbitrary symmetric tensors or matrices. Also, a lot of new functions for Clifford algebras have been added, including automorphisms and Moebius transformations. [Contribution by V. Kisil] - Added some basic symbolic and numeric integration facilities. [Contribution by C. Dams] - The multiple polylogarithm Li() now evaluates numerically for arbitrary arguments. - New functions G(a,y) and G(a,s,y) added (another notation for multiple polylogarithms). As always, this release can be downloaded from ftp://ftpthep.physik.uni-mainz.de/pub/GiNaC/ Enjoy, Jens

3 4

canonicalise_clifford for matrices?
by Vladimir V. Kisil 18 Oct '04

18 Oct '04

Dear All, I would like that canonicalise_clifford(), clifford_prime() and remove_dirac_ONE() can handle matrices and lists (recursing into each entry). I applied a patch for that (ignoring re-identified lines from canonicalise_clifford()). Best, Vladimir -- Vladimir V. Kisil email: kisilv(a)maths.leeds.ac.uk -- www: http://maths.leeds.ac.uk/~kisilv/ --- GiNaC/ginac/clifford.cpp 2004-10-15 14:12:02.000000000 +0100 +++ clifford.cpp 2004-10-16 21:59:58.000000000 +0100 @@ -939,6 +939,12 @@ ex canonicalize_clifford(const ex & e) { + pointer_to_map_function fcn(canonicalize_clifford); + + if (is_a<matrix>(e) // || is_a<pseries>(e) || is_a<integral>(e) + || is_a<lst>(e)) { + return e.map(fcn); + } else { // Scan for any ncmul objects exmap srl; ex aux = e.to_rational(srl); @@ -990,6 +996,7 @@ } } return aux.subs(srl, subs_options::no_pattern).simplify_indexed(); + } } ex clifford_prime(const ex & e) @@ -997,9 +1004,8 @@ pointer_to_map_function fcn(clifford_prime); if (is_a<clifford>(e) && is_a<cliffordunit>(e.op(0))) { return -e; - } else if (is_a<add>(e)) { - return e.map(fcn); - } else if (is_a<ncmul>(e)) { + } else if (is_a<add>(e) || is_a<ncmul>(e) // || is_a<pseries>(e) || is_a<integral>(e) + || is_a<matrix>(e) || is_a<lst>(e)) { return e.map(fcn); } else if (is_a<power>(e)) { return pow(clifford_prime(e.op(0)), e.op(1)); @@ -1012,11 +1018,8 @@ pointer_to_map_function fcn(remove_dirac_ONE); if (is_a<clifford>(e) && is_a<diracone>(e.op(0))) { return 1; - } else if (is_a<add>(e)) { - return e.map(fcn); - } else if (is_a<ncmul>(e)) { - return e.map(fcn); - } else if (is_a<mul>(e)) { + } else if (is_a<add>(e) || is_a<ncmul>(e) || is_a<mul>(e) // || is_a<pseries>(e) || is_a<integral>(e) + || is_a<matrix>(e) || is_a<lst>(e)) { return e.map(fcn); } else if (is_a<power>(e)) { return pow(remove_dirac_ONE(e.op(0)), e.op(1));

2 1

Clifford update
by Vladimir Kisil 15 Oct '04

15 Oct '04

Dear All, In extension my yesterday post. I propose to include in clifford.cpp the second form of clifford_moebius_map() which takes whole matrix M rather then its four elements as a parameter. The cumulative patch for ginac.texi, clifford.h and clifford.cpp is included. Best wishes, Vladimir -- Vladimir V. Kisil email: kisilv(a)maths.leeds.ac.uk -- www: http://maths.leeds.ac.uk/~kisilv/ I am sending once more patch to clifford.cpp. Now it closes all bugs which I was aware of in clifford_to_lst(). It also add some more flexibility to parameters of clifford_moebius_map(). I think that it will be nice if clifford_to_lst() can handle integrals and power series as well, but this requires some more includes to clifford.cpp. If there is no objection against it please uncomment this line in the patch: if (is_a<add>(e) || is_a<lst>(e) // || is_a<pseries>(e) || is_a<integral>(e) (and add includes by hands). I also finally wrote an addition to tutorial. This is my first experience with Texinfo, please feel free to edit it as you wish. Best wishes, Vladimir Index: doc/tutorial/ginac.texi =================================================================== RCS file: /home/cvs/GiNaC/doc/tutorial/ginac.texi,v retrieving revision 1.156 diff -r1.156 ginac.texi 2985a2986,2990 > > Clifford algebras are supported in two flavours: Dirac gamma > matrices (more physical) and generic Clifford algebras (more > mathematical). > 2987,2990c2992,2997 < Clifford algebra elements (also called Dirac gamma matrices, although GiNaC < doesn't treat them as matrices) are designated as @samp{gamma~mu} and satisfy < @samp{gamma~mu*gamma~nu + gamma~nu*gamma~mu = 2*eta~mu~nu} where @samp{eta~mu~nu} < is the Minkowski metric tensor. Dirac gammas are constructed by the function --- > @subsubsection Dirac gamma matrices > Dirac gamma matrices (note that GiNaC doesn't treat them > as matrices) are designated as @samp{gamma~mu} and satisfy > @samp{gamma~mu*gamma~nu + gamma~nu*gamma~mu = 2*eta~mu~nu} where > @samp{eta~mu~nu} is the Minkowski metric tensor. Dirac gammas are > constructed by the function 3161a3169,3321 > > @cindex @code{clifford_unit()} > @subsubsection A generic Clifford algebra > > A generic Clifford algebra, i.e. @math{2^n} dimensional algebra with > generators @samp{e~k} satisfying the identities > @samp{e~i e~j+e~j e~i = B(i, j)} for some symmetric matrix (@code{metric}) > @math{B(i, j)}. Such generators are created by the function > > @example > ex clifford_unit(const ex & mu, const ex & metr, unsigned char rl = 0); > @end example > > where @code{mu} should be @code{varidx} class object indexing the > generators, @code{metr} defines the metric @math{B(i, j)} and can be > represented by square @code{matrix}, @code{tensormetric} or @code{indexed} class > object, optional parameter @code{rl} allows to distinguish different > Clifford algebras (which will commute each other). Note that the call > @code{clifford_unit(mu, minkmetric())} creates something very close to > @code{dirac_gamma(mu)}. The method @code{clifford::get_metric()} returns > metric defining this Clifford number. > > Individual generators of a Clifford algebra can be accessed in several > ways. For example > > @example > @{ > ... > varidx nu(symbol(``nu''), 3); > matrix M(3, 3) = 1, 0, 0, > 0, -1, 0, > 0, 0, 0; > ex e = clifford_unit(nu, M); > ex e0 = e.subs(nu == 0); > ex e1 = e.subs(nu == 1); > ex e2 = e.subs(nu == 2); > ... > @} > @end example > > will produce three generators of a Clifford algebra with properties > @code{pow(e0, 2) = 1}, @code{pow(e1, 2) = -1} and @code{pow(e2, 2) = 0}. > > @cindex @code{lst_to_clifford()} > A similar effect can be achieved from the function > > @example > ex lst_to_clifford(const ex & v, const ex & mu, const ex & metr, unsigned char rl = 0); > @end example > > which converts a list or vector @code{v}@samp{ = (v~0, v~1, ..., v~n)} into > the Clifford number @samp{v~0 e.0+v~1 e.1+... + v~n e.n} with @samp{e.k} > being created by @code{clifford_unit(mu, metr, rl)}. The previous code > may be rewritten with help of @code{lst_to_clifford()} as follows > > @example > @{ > ... > varidx nu(symbol(``nu''), 3); > matrix M(3, 3) = 1, 0, 0, > 0, -1, 0, > 0, 0, 0; > ex e0 = lst_to_clifford(lst(1, 0, 0), nu, M); > ex e1 = lst_to_clifford(lst(0, 1, 0), nu, M); > ex e2 = lst_to_clifford(lst(0, 0, 1), nu, M); > ... > @} > @end example > > @cindex @code{clifford_to_lst()} > There is the inverse function > > @example > lst clifford_to_lst(const ex & e, const ex & c, bool algebraic = true); > @end example > > which took an expression @code{e} and tries to find such a list > @code{v}@samp{ = (v~0, v~1, ..., v~n)} that @samp{e = v~0c.0 + v~1c.1 + ... > + v~nc.n} with respect to given Clifford units @code{c} and none of > @samp{v~k} contains the Clifford units @code{c} (of course, this > may be impossible). This function can use an @code{algebraic} method > (default) or a symbolic one. In @code{algebraic} method @samp{v~k} are calculated as > @samp{(e c.k + c.k e)/pow(c.k, 2)}. If @samp{pow(c.k, 2) = 0} for some @samp{k} > then the method will be automatically changed to symbolic. The same effect > is obtained by the assignment (@code{algebraic = false}) in the procedure call. > > @cindex @code{clifford_prime()} > @cindex @code{clifford_star()} > @cindex @code{clifford_bar()} > There are several functions for (anti-)automorphisms of Clifford algebras: > > @example > ex clifford_prime(const ex & e) > inline ex clifford_star(const ex & e) @{ return e.conjugate(); @} > inline ex clifford_bar(const ex & e) @{ return clifford_prime(e.conjugate()); @} > @end example > > The automorphism of a Clifford algebra @code{clifford_prime()} simply > changes signs of all Clifford units in the expression. The reversion > of a Clifford algebra @code{clifford_star()} coincides with > @code{conjugate()} method and effectively reverses the order of Clifford > units in any product. Finally the main anti-automorphism > of a Clifford algebra @code{clifford_bar()} is the composition of two > previous, i.e. makes the reversion and changes signs of all Clifford units > in a product. Names for this functions corresponds to notations > @math{e'}, @math{e^*} and @math{\bar{e}} used in Clifford algebra > textbooks. > > @cindex @code{clifford_norm()} > The function > > @example > ex clifford_norm(const ex & e); > @end example > > @cindex @code{clifford_inverse()} > calculates the norm of Clifford number from the expression > @math{||e||^2 = e\bar{e}}. The inverse of a Clifford expression is returned > by the function > > @example > ex clifford_inverse(const ex & e); > @end example > > which calculates it as @math{e^{-1} = e/||e||^2}. If @math{||e|| = 0} then an > exception is raised. > > @cindex @code{remove_dirac_ONE()} > If a Clifford number happens to be a factor of > @code{dirac_ONE()} then we can convert it to a ``real'' (non-Clifford) > expression by the function > > @example > ex remove_dirac_ONE(const ex & e); > @end example > > @cindex @code{canonicalize_clifford()} > The function @code{canonicalize_clifford()} works for a > generic Clifford algebra in a similar way as for Dirac gammas. > > The last provided function is > > @cindex @code{clifford_moebius_map()} > @example > ex clifford_moebius_map(const ex & a, const ex & b, const ex & c, const ex & d, const ex & v, const ex & G); > @end example > > It takes a list or vector @code{v} and makes the Moebius > (conformal or linear-fractional) transformation @samp{v -> > (av+b)/(cv+d)} defined by the matrix @samp{[[a, b], [c, d]]}. The last > parameter @code{G} define the metric of the surrounding > (pseudo-)Euclidean space. The returned value of this function is a list > of components of the resulting vector. Index: ginac/clifford.h =================================================================== RCS file: /home/cvs/GiNaC/ginac/clifford.h,v retrieving revision 1.52 diff -r1.52 clifford.h 319a320,327 > > /** The second form of Moebius transformations defined by a 2x2 Clifford matrix M > * This function took the transformation matrix M as a single entity. > * > * @param M the defining matrix > * @param v Vector to be transformed > * @param G Metric of the surrounding space */ > ex clifford_moebius_map(const ex & M, const ex & v, const ex & G); Index: ginac/clifford.cpp =================================================================== RCS file: /home/cvs/GiNaC/ginac/clifford.cpp,v retrieving revision 1.80 diff -r1.80 clifford.cpp 1080a1081 > int ival = ex_to<numeric>(ex_to<varidx>(c.op(1)).get_value()).to_int(); 1082c1083,1084 < if (is_a<add>(e)) --- > if (is_a<add>(e) || is_a<lst>(e) // || is_a<pseries>(e) || is_a<integral>(e) > || is_a<matrix>(e)) 1086d1087 < int ival = ex_to<numeric>(ex_to<varidx>(c.op(1)).get_value()).to_int(); 1095a1097,1100 > bool same_value_index, found_dummy; > same_value_index = ( ex_to<varidx>(e.op(ind).op(1)).is_numeric() > && (ival == ex_to<numeric>(ex_to<varidx>(e.op(ind).op(1)).get_value()).to_int()) ); > found_dummy = same_value_index; 1097,1105c1102,1103 < if (j != ind) { < exvector ind_vec = ex_to<indexed>(e.op(j)).get_dummy_indices(ex_to<indexed>(e.op(ind))); < if (ind_vec.size() > 0) { < exvector::const_iterator it = ind_vec.begin(), itend = ind_vec.end(); < while (it != itend) { < S = S * e.op(j).subs(lst(ex_to<varidx>(*it) == ival, ex_to<varidx>(*it).toggle_variance() == ival), subs_options::no_pattern); < it++; < } < } else --- > if (j != ind) > if (same_value_index) 1107,1108c1105,1117 < } < return S; --- > else { > exvector ind_vec = ex_to<indexed>(e.op(j)).get_dummy_indices(ex_to<indexed>(e.op(ind))); > if (ind_vec.size() > 0) { > found_dummy = true; > exvector::const_iterator it = ind_vec.begin(), itend = ind_vec.end(); > while (it != itend) { > S = S * e.op(j).subs(lst(ex_to<varidx>(*it) == ival, ex_to<varidx>(*it).toggle_variance() == ival), subs_options::no_pattern); > it++; > } > } else > S = S * e.op(j); > } > return (found_dummy? S : 0); 1113c1122,1128 < else --- > else if (is_a<clifford>(e) && ex_to<clifford>(e).same_metric(c)) > if ( ex_to<varidx>(e.op(1)).is_numeric() && > (ival != ex_to<numeric>(ex_to<varidx>(e.op(1)).get_value()).to_int()) ) > return 0; > else > return 1; > else 1115d1129 < 1150c1164,1166 < D = ex_to<varidx>(G.op(1)); --- > D = ex_to<varidx>(G.op(1)).get_dim(); > else if (is_a<matrix>(G)) > D = ex_to<matrix>(G).rows(); 1152c1168 < throw(std::invalid_argument("metric should be an indexed object")); --- > throw(std::invalid_argument("metric should be an indexed object or matrix")); 1154c1170 < varidx mu ((new symbol)->setflag(status_flags::dynallocated), ex_to<varidx>(D).get_dim()); --- > varidx mu ((new symbol)->setflag(status_flags::dynallocated), D); 1158a1175 > 1163a1181,1190 > > ex clifford_moebius_map(const ex & M, const ex & v, const ex & G) > { > if (is_a<matrix>(M)) > return clifford_moebius_map(ex_to<matrix>(M)(0,0), ex_to<matrix>(M)(0,1), > ex_to<matrix>(M)(1,0), ex_to<matrix>(M)(1,1), v, G); > else > throw(std::invalid_argument("parameter M should be a matrix")); > } >

2 1

clifford.cpp and ginac.texi patch
by Vladimir Kisil 14 Oct '04

14 Oct '04

Dear All, I am sending once more patch to clifford.cpp. Now it closes all bugs which I was aware of in clifford_to_lst(). It also add some more flexibility to parameters of clifford_moebius_map(). I think that it will be nice if clifford_to_lst() can handle integrals and power series as well, but this requires some more includes to clifford.cpp. If there is no objection against it please uncomment this line in the patch: if (is_a<add>(e) || is_a<lst>(e) // || is_a<pseries>(e) || is_a<integral>(e) (and add includes by hands). I also finally wrote an addition to tutorial. This is my first experience with Texinfo, please feel free to edit it as you wish. Best wishes, Vladimir -- Vladimir V. Kisil email: kisilv(a)maths.leeds.ac.uk -- www: http://maths.leeds.ac.uk/~kisilv/ Index: doc/tutorial/ginac.texi =================================================================== RCS file: /home/cvs/GiNaC/doc/tutorial/ginac.texi,v retrieving revision 1.156 diff -r1.156 ginac.texi 2985a2986,2990 > > Clifford algebras are supported in two flavours: Dirac gamma > matrices (more physical) and generic Clifford algebras (more > mathematical). > 2987,2990c2992,2997 < Clifford algebra elements (also called Dirac gamma matrices, although GiNaC < doesn't treat them as matrices) are designated as @samp{gamma~mu} and satisfy < @samp{gamma~mu*gamma~nu + gamma~nu*gamma~mu = 2*eta~mu~nu} where @samp{eta~mu~nu} < is the Minkowski metric tensor. Dirac gammas are constructed by the function --- > @subsubsection Dirac gamma matrices > Dirac gamma matrices (note that GiNaC doesn't treat them > as matrices) are designated as @samp{gamma~mu} and satisfy > @samp{gamma~mu*gamma~nu + gamma~nu*gamma~mu = 2*eta~mu~nu} where > @samp{eta~mu~nu} is the Minkowski metric tensor. Dirac gammas are > constructed by the function 3161a3169,3321 > > @cindex @code{clifford_unit()} > @subsubsection A generic Clifford algebra > > A generic Clifford algebra, i.e. @math{2^n} dimensional algebra with > generators @samp{e~k} satisfying the identities > @samp{e~i e~j+e~j e~i = B(i, j)} for some symmetric matrix (@code{metric}) > @math{B(i, j)}. Such generators are created by the function > > @example > ex clifford_unit(const ex & mu, const ex & metr, unsigned char rl = 0); > @end example > > where @code{mu} should be @code{varidx} class object indexing the > generators, @code{metr} defines the metric @math{B(i, j)} and can be > represented by square @code{matrix}, @code{tensormetric} or @code{indexed} class > object, optional parameter @code{rl} allows to distinguish different > Clifford algebras (which will commute each other). Note that the call > @code{clifford_unit(mu, minkmetric())} creates something very close to > @code{dirac_gamma(mu)}. The method @code{clifford::get_metric()} returns > metric defining this Clifford number. > > Individual generators of a Clifford algebra can be accessed in several > ways. For example > > @example > @{ > ... > varidx nu(symbol(``nu''), 3); > matrix M(3, 3) = 1, 0, 0, > 0, -1, 0, > 0, 0, 0; > ex e = clifford_unit(nu, M); > ex e0 = e.subs(nu == 0); > ex e1 = e.subs(nu == 1); > ex e2 = e.subs(nu == 2); > ... > @} > @end example > > will produce three generators of a Clifford algebra with properties > @code{pow(e0, 2) = 1}, @code{pow(e1, 2) = -1} and @code{pow(e2, 2) = 0}. > > @cindex @code{lst_to_clifford()} > A similar effect can be achieved from the function > > @example > ex lst_to_clifford(const ex & v, const ex & mu, const ex & metr, unsigned char rl = 0); > @end example > > which converts a list or vector @code{v}@samp{ = (v~0, v~1, ..., v~n)} into > the Clifford number @samp{v~0 e.0+v~1 e.1+... + v~n e.n} with @samp{e.k} > being created by @code{clifford_unit(mu, metr, rl)}. The previous code > may be rewritten with help of @code{lst_to_clifford()} as follows > > @example > @{ > ... > varidx nu(symbol(``nu''), 3); > matrix M(3, 3) = 1, 0, 0, > 0, -1, 0, > 0, 0, 0; > ex e0 = lst_to_clifford(lst(1, 0, 0), nu, M); > ex e1 = lst_to_clifford(lst(0, 1, 0), nu, M); > ex e2 = lst_to_clifford(lst(0, 0, 1), nu, M); > ... > @} > @end example > > @cindex @code{clifford_to_lst()} > There is the inverse function > > @example > lst clifford_to_lst(const ex & e, const ex & c, bool algebraic = true); > @end example > > which took an expression @code{e} and tries to find such a list > @code{v}@samp{ = (v~0, v~1, ..., v~n)} that @samp{e = v~0c.0 + v~1c.1 + ... > + v~nc.n} with respect to given Clifford units @code{c} and none of > @samp{v~k} contains the Clifford units @code{c} (of course, this > may be impossible). This function can use an @code{algebraic} method > (default) or a symbolic one. In @code{algebraic} method @samp{v~k} are calculated as > @samp{(e c.k + c.k e)/pow(c.k, 2)}. If @samp{pow(c.k, 2) = 0} for some @samp{k} > then the method will be automatically changed to symbolic. The same effect > is obtained by the assignment (@code{algebraic = false}) in the procedure call. > > @cindex @code{clifford_prime()} > @cindex @code{clifford_star()} > @cindex @code{clifford_bar()} > There are several functions for (anti-)automorphisms of Clifford algebras: > > @example > ex clifford_prime(const ex & e) > inline ex clifford_star(const ex & e) @{ return e.conjugate(); @} > inline ex clifford_bar(const ex & e) @{ return clifford_prime(e.conjugate()); @} > @end example > > The automorphism of a Clifford algebra @code{clifford_prime()} simply > changes signs of all Clifford units in the expression. The reversion > of a Clifford algebra @code{clifford_star()} coincides with > @code{conjugate()} method and effectively reverses the order of Clifford > units in any product. Finally the main anti-automorphism > of a Clifford algebra @code{clifford_bar()} is the composition of two > previous, i.e. makes the reversion and changes signs of all Clifford units > in a product. Names for this functions corresponds to notations > @math{e'}, @math{e^*} and @math{\bar{e}} used in Clifford algebra > textbooks. > > @cindex @code{clifford_norm()} > The function > > @example > ex clifford_norm(const ex & e); > @end example > > @cindex @code{clifford_inverse()} > calculates the norm of Clifford number from the expression > @math{||e||^2 = e\bar{e}}. The inverse of a Clifford expression is returned > by the function > > @example > ex clifford_inverse(const ex & e); > @end example > > which calculates it as @math{e^{-1} = e/||e||^2}. If @math{||e|| = 0} then an > exception is raised. > > @cindex @code{remove_dirac_ONE()} > If a Clifford number happens to be a factor of > @code{dirac_ONE()} then we can convert it to a ``real'' (non-Clifford) > expression by the function > > @example > ex remove_dirac_ONE(const ex & e); > @end example > > @cindex @code{canonicalize_clifford()} > The function @code{canonicalize_clifford()} works for a > generic Clifford algebra in a similar way as for Dirac gammas. > > The last provided function is > > @cindex @code{clifford_moebius_map()} > @example > ex clifford_moebius_map(const ex & a, const ex & b, const ex & c, const ex & d, const ex & v, const ex & G); > @end example > > It takes a list or vector @code{v} and makes the Moebius > (conformal or linear-fractional) transformation @samp{v -> > (av+b)/(cv+d)} defined by the matrix @samp{[[a, b], [c, d]]}. The last > parameter @code{G} define the metric of the surrounding > (pseudo-)Euclidean space. The returned value of this function is a list > of components of the resulting vector. Index: ginac/clifford.cpp =================================================================== RCS file: /home/cvs/GiNaC/ginac/clifford.cpp,v retrieving revision 1.80 diff -r1.80 clifford.cpp 1080a1081 > int ival = ex_to<numeric>(ex_to<varidx>(c.op(1)).get_value()).to_int(); 1082c1083,1084 < if (is_a<add>(e)) --- > if (is_a<add>(e) || is_a<lst>(e) // || is_a<pseries>(e) || is_a<integral>(e) > || is_a<matrix>(e)) 1086d1087 < int ival = ex_to<numeric>(ex_to<varidx>(c.op(1)).get_value()).to_int(); 1095a1097,1100 > bool same_value_index, found_dummy; > same_value_index = ( ex_to<varidx>(e.op(ind).op(1)).is_numeric() > && (ival == ex_to<numeric>(ex_to<varidx>(e.op(ind).op(1)).get_value()).to_int()) ); > found_dummy = same_value_index; 1097,1105c1102,1103 < if (j != ind) { < exvector ind_vec = ex_to<indexed>(e.op(j)).get_dummy_indices(ex_to<indexed>(e.op(ind))); < if (ind_vec.size() > 0) { < exvector::const_iterator it = ind_vec.begin(), itend = ind_vec.end(); < while (it != itend) { < S = S * e.op(j).subs(lst(ex_to<varidx>(*it) == ival, ex_to<varidx>(*it).toggle_variance() == ival), subs_options::no_pattern); < it++; < } < } else --- > if (j != ind) > if (same_value_index) 1107,1108c1105,1117 < } < return S; --- > else { > exvector ind_vec = ex_to<indexed>(e.op(j)).get_dummy_indices(ex_to<indexed>(e.op(ind))); > if (ind_vec.size() > 0) { > found_dummy = true; > exvector::const_iterator it = ind_vec.begin(), itend = ind_vec.end(); > while (it != itend) { > S = S * e.op(j).subs(lst(ex_to<varidx>(*it) == ival, ex_to<varidx>(*it).toggle_variance() == ival), subs_options::no_pattern); > it++; > } > } else > S = S * e.op(j); > } > return (found_dummy? S : 0); 1113c1122,1128 < else --- > else if (is_a<clifford>(e)) > if ( ex_to<varidx>(e.op(1)).is_numeric() && > (ival != ex_to<numeric>(ex_to<varidx>(e.op(1)).get_value()).to_int()) ) > return 0; > else > return 1; > else 1115d1129 < 1150c1164,1166 < D = ex_to<varidx>(G.op(1)); --- > D = ex_to<varidx>(G.op(1)).get_dim(); > else if (is_a<matrix>(G)) > D = ex_to<matrix>(G).rows(); 1152c1168 < throw(std::invalid_argument("metric should be an indexed object")); --- > throw(std::invalid_argument("metric should be an indexed object or matrix")); 1154c1170 < varidx mu ((new symbol)->setflag(status_flags::dynallocated), ex_to<varidx>(D).get_dim()); --- > varidx mu ((new symbol)->setflag(status_flags::dynallocated), D); 1157a1174 >

1 0

GiNaC 1.2.4
by Jens Vollinga 12 Oct '04

12 Oct '04

Hi, GiNaC 1.2.4 is out and available. The changes are: - Added ex::unitcontprim() to compute the unit, content, and primitive parts of a polynomial in one go. - binomial(n, k) evaluates for non-integer arguments n. - Li(2,x) now evaluates for +-I. - Optimized Li(2,x). - Fixed bug in Li(n,x) (if Li(2,x) was calculated with high precision the enlargement of the look-up table caused a segmentation fault). - Fixed another bug in the series expansion of powers, and a bug in power::info(). As always, this release can be downloaded from ftp://ftpthep.physik.uni-mainz.de/pub/GiNaC/ Enjoy, Jens

1 0

clifford patches
by Vladimir Kisil 12 Oct '04

12 Oct '04

Dear All, I wish to propose a further patches for clifford.cpp and clifford.h. Its make: 1. Fixes a nasty behaviour when a simplification creates nested indexed objects like (eta.psi.xi).nu.mu. 2. Contains two new functions described in the clifford.h. Hope they will be useful, at least I employ them to create some graphics of conformal maps already. 3. Other bits are small improvements and spaces fixed. Some comments: 1. I set the default method in clifford_to_lst() to be algebraic since its more mathematically transparent, but it seems to be by almost twice slower than non-algebraic one. Thus moebius() use non-algebraic approach for speed. 2. I found that GiNaC always return expression ex_to<varidx>(*it) as ".mu" even if in fact it is "~mu". Thus I used the substitution argument like lst(ex_to<varidx>(*it) == ival, ex_to<varidx>(*it).toggle_variance() == ival) instead of a simple expression ex_to<varidx>(*it) == ival Probably this would be better to change to the expected behaviour. Best wishes, Vladimir -- Vladimir V. Kisil email: kisilv(a)maths.leeds.ac.uk -- www: http://maths.leeds.ac.uk/~kisilv/ Index: ginac/clifford.h =================================================================== RCS file: /home/cvs/GiNaC/ginac/clifford.h,v retrieving revision 1.51 diff -r1.51 clifford.h 278c278 < ex delete_ONE(const ex &e); --- > ex delete_ONE(const ex & e); 294a295,318 > /** An inverse function to lst_to_clifford(). For given Clifford vector extracts > * its components with respect to given Clifford unit. Obtained components may > * contain Clifford units with a different metric. Extraction is based on > * the algebraic formula (e * c.i + c.i * e)/ pow(e.i, 2) for non-degenerate cases > * (i.e. neither pow(e.i, 2) = 0). > * > * @param e Clifford expresion to be decomposed into components > * @param c Clifford unit defining the metric for splitting (should have numeric dimension of indices) > * @param algebraic Use algebraic or symbolic algorythm for extractions */ > lst clifford_to_lst(const ex & e, const ex & c, bool algebraic=true); > > /** Calculations of Moebius transformations (conformal map) defined by a 2x2 Clifford matrix > * (a b\\c d) in linear spaces with arbitrary signature. The expression is > * (a * x + b)/(c * x + d), where x is a vector buid from list v with metric G. > * (see Jan Cnops. An introduction to {D}irac operators on manifolds, v.24 of > * Progress in Mathematical Physics. Birkhauser Boston Inc., Boston, MA, 2002.) > * > * @param a (1,1) entry of the defining matrix > * @param b (1,2) entry of the defining matrix > * @param c (2,1) entry of the defining matrix > * @param d (2,2) entry of the defining matrix > * @param v Vector to be transformed > * @param G Metric of the surrounding space */ > ex moebius(const ex & a, const ex & b, const ex & c, const ex & d, const ex & v, const ex & G); Index: ginac/clifford.cpp =================================================================== RCS file: /home/cvs/GiNaC/ginac/clifford.cpp,v retrieving revision 1.79 diff -r1.79 clifford.cpp 680c680,685 < return clifford(unit, mu, metr, rl); --- > if (is_a<indexed>(metr)) > return clifford(unit, mu, metr.op(0), rl); > else if(is_a<tensmetric>(metr) || is_a<matrix>(metr)) > return clifford(unit, mu, metr, rl); > else > throw(std::invalid_argument("metric for Clifford unit must be of type indexed, tensormetric or matrix")); 990c995 < ex clifford_prime(const ex &e) --- > ex clifford_prime(const ex & e) 1005c1010 < ex delete_ONE(const ex &e) --- > ex delete_ONE(const ex & e) 1022c1027 < ex clifford_norm(const ex &e) --- > ex clifford_norm(const ex & e) 1024c1029 < return sqrt(delete_ONE((e * clifford_bar(e)).simplify_indexed())); --- > return sqrt(delete_ONE(canonicalize_clifford(e * clifford_bar(e)).simplify_indexed())); 1027c1032 < ex clifford_inverse(const ex &e) --- > ex clifford_inverse(const ex & e) 1031a1037,1038 > else > throw(std::invalid_argument("Cannot find inverse of Clifford number with zero norm!")); 1068a1076,1159 > /** Auxiliary structure to define a function for striping one Clifford unit > * from vectors. Used in clifford_to_lst(). */ > ex get_clifford_comp(const ex & e, const ex & c) > { > pointer_to_map_function_1arg<const ex &> fcn(get_clifford_comp, c); > > if (is_a<add>(e)) > return e.map(fcn); > else if (is_a<ncmul>(e) || is_a<mul>(e)) { > //find a Clifford unit with the same metric, delete it and substitute its index > int ival = ex_to<numeric>(ex_to<varidx>(c.op(1)).get_value()).to_int(); > size_t ind = e.nops() + 1; > for (size_t j = 0; j < e.nops(); j++) > if (is_a<clifford>(e.op(j)) && ex_to<clifford>(c).same_metric(e.op(j))) > if (ind > e.nops()) > ind = j; > else > throw(std::invalid_argument("Expression is a Clifford multi-vector")); > if (ind < e.nops()) { > ex S = 1; > for(size_t j=0; j < e.nops(); j++) > if (j != ind) { > exvector ind_vec = ex_to<indexed>(e.op(j)).get_dummy_indices(ex_to<indexed>(e.op(ind))); > if (ind_vec.size() > 0) { > exvector::const_iterator it = ind_vec.begin(), itend = ind_vec.end(); > while (it != itend) { > S = S * e.op(j).subs(lst(ex_to<varidx>(*it) == ival, ex_to<varidx>(*it).toggle_variance() == ival), subs_options::no_pattern); > it++; > } > } else > S = S * e.op(j); > } > return S; > } else > throw(std::invalid_argument("Expression is not a Clifford vector to the given units")); > } else { > throw(std::invalid_argument("Expression is not handlable as a Clifford vector")); > } > } > > > lst clifford_to_lst (const ex & e, const ex & c, bool algebraic) > { > GINAC_ASSERT(is_a<clifford>(c)); > varidx mu = ex_to<varidx>(c.op(1)); > if (! mu.is_dim_numeric()) > throw(std::invalid_argument("Index should have a numeric dimension")); > unsigned int D = ex_to<numeric>(mu.get_dim()).to_int(); > > if (algebraic) // check if algebraic method is applicable > for (unsigned int i = 0; i < D; i++) > if (pow(c.subs(mu == i), 2) == 0) > algebraic = false; > lst V; > if (algebraic) > for (unsigned int i = 0; i < D; i++) > V.append(delete_ONE(simplify_indexed(canonicalize_clifford(e * c.subs(mu == i) + c.subs(mu == i) * e))/(2*pow(c.subs(mu == i), 2)))); > else { > ex e1 = canonicalize_clifford(e); > for (unsigned int i = 0; i < D; i++) > V.append(get_clifford_comp(e1, c.subs(c.op(1) == i))); > } > return V; > } > > > ex moebius(const ex & a, const ex & b, const ex & c, const ex & d, const ex & v, const ex & G) > { > ex x, D; > if (is_a<indexed>(G)) > D = ex_to<varidx>(G.op(1)); > else > throw(std::invalid_argument("metric should be an indexed object")); > > varidx mu ((new symbol)->setflag(status_flags::dynallocated), ex_to<varidx>(D).get_dim()); > > if (! is_a<matrix>(v) && ! is_a<lst>(v)) > throw(std::invalid_argument("parameter v should be either vector or list")); > > x = lst_to_clifford(v, mu, G); > ex e = simplify_indexed(canonicalize_clifford((a * x + b) * clifford_inverse(c * x + d))); > ex cu = clifford_unit(mu, G); > return clifford_to_lst(e, cu, false); > }

2 2