May 2006 - GiNaC-devel

Class container vs. the holy standard?
by Richard B. Kreckel 05 Aug '06

05 Aug '06

Hi, Triggered by Debian bug #362220 [0] I submitted GCC bug report #27178 [1] only to be told that container.h made use of a GCC extension that will have been removed from GCC in the upcoming 4.2.0 release [2]. Basically, where we were simply writing this: template <template <class> class> class container; typedef container<std::list> lst; we now have to write the more cumbersome: template <template <class, class> class> class container; typedef container<std::list> lst; This is because std::list has two template parameters, the element type and the allocator type. Ugh. It's ugly, because the intent was clearly to not bother the user with implementation details like the allocator. From the user's perspective, the intent is to express "container of T", never mind what type of container. I've attached a patch against CVS GiNaC-1.3 that converts all places flaged as errors in GCC 4.2 20060415 (experimental) to: template <template <class T, class = std::allocator<T> > class> class X; typedef X<std::list> lst; This is ugly as sin, because I don't think that we really wanted to express "STL-container of T", as the changed code now appears to imply. Any suggestions? -richy. [0] <http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=362220> [1] <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=27178> [2] <http://gcc.gnu.org/gcc-4.2/changes.html>, first bullet under C++ -- Richard B. Kreckel <http://www.ginac.de/~kreckel/>

5 12

Positive symbols/constants.
by Chris Dams 25 May '06

25 May '06

Dear all, I introduced domain::positive to indicate that a symbol or constant is positive. If it is we have abs(p) -> p real_part(log(p)) -> log(p) imag_part(log(p)) -> 0 Furthermore, for general x, I introduced abs(abs(x)) -> abs(x). Best wishes, Chris

1 0

Extending clifford.cpp
by Vladimir Kisil 24 May '06

24 May '06

Dear All, I discovered recently that it is not easy to create a Clifford unit in the Euclidean space with symbolic dimension. The natural attempt was to supply -tensdelta as the metric, however when GiNaC wrap it into an indexed object it automatically put minus outside of it. Then the result is of type mul, not indexed, as was previously assumed in clifford.cpp. Summing up: the previous assumption that metric of clifford units can and should be always an indexed object is rather restrictive. Fortunately, it was not difficult to patch clifford.cpp to work without this assumption. I include the patch as well as extend the exam_clifford.cpp to check such cases as well. I also add a word into the tutorial about this new possibility. Best wishes, Vladimir -- Vladimir V. Kisil email: kisilv(a)maths.leeds.ac.uk -- www: http://maths.leeds.ac.uk/~kisilv/ /home/amsta/kisilv/GiNaC Index: doc/tutorial/ginac.texi =================================================================== RCS file: /home/cvs/GiNaC/doc/tutorial/ginac.texi,v retrieving revision 1.186 diff -u -r1.186 ginac.texi --- doc/tutorial/ginac.texi 16 May 2006 15:27:20 -0000 1.186 +++ doc/tutorial/ginac.texi 19 May 2006 15:41:41 -0000 @@ -3307,7 +3307,11 @@ @code{idx} as well. Parameter @code{metr} defines the metric @math{M(i, j)} and can be represented by a square @code{matrix}, @code{tensormetric} or @code{indexed} class -object. Optional parameter @code{rl} allows to distinguish different +object. In fact, any expression either with two free indices or without +indices at all is admitted as @code{metr}. In the later case an @code{indexed} +object with two newly created indices with @code{metr} as its +@code{op(0)} will be used. +Optional parameter @code{rl} allows to distinguish different Clifford algebras, which will commute with each other. The last optional parameter @code{anticommuting} defines if the anticommuting assumption (i.e. Index: ginac/clifford.cpp =================================================================== RCS file: /home/cvs/GiNaC/ginac/clifford.cpp,v retrieving revision 1.96 diff -u -r1.96 clifford.cpp --- ginac/clifford.cpp 16 May 2006 15:27:21 -0000 1.96 +++ ginac/clifford.cpp 19 May 2006 15:41:41 -0000 @@ -158,29 +158,39 @@ if (is_a<indexed>(metric)) { if (symmetrised && !(ex_to<symmetry>(ex_to<indexed>(metric).get_symmetry()).has_symmetry())) { if (is_a<matrix>(metric.op(0))) { - return indexed((ex_to<matrix>(metric.op(0)).add(ex_to<matrix>(metric.op(0)).transpose())).mul(numeric(1,2)), + return indexed((ex_to<matrix>(metric.op(0)).add(ex_to<matrix>(metric.op(0)).transpose())).mul(numeric(1, 2)), symmetric2(), i, j); } else { return simplify_indexed(indexed(metric.op(0)*_ex1_2, i, j) + indexed(metric.op(0)*_ex1_2, j, i)); } } else { - //return indexed(metric.op(0), ex_to<symmetry>(ex_to<indexed>(metric).get_symmetry()), i, j); return metric.subs(lst(metric.op(1) == i, metric.op(2) == j), subs_options::no_pattern); } } else { - // should not really happen since all constructors but clifford() make the metric an indexed object - return indexed(metric, i, j); + exvector indices = metric.get_free_indices(); + if (symmetrised) + return _ex1_2*simplify_indexed(metric.subs(lst(indices[0] == i, indices[1] == j), subs_options::no_pattern) + + metric.subs(lst(indices[0] == j, indices[1] == i), subs_options::no_pattern)); + else + return metric.subs(lst(indices[0] == i, indices[1] == j), subs_options::no_pattern); } } bool clifford::same_metric(const ex & other) const { - if (is_a<clifford>(other)) { - return same_metric(ex_to<clifford>(other).get_metric()); - } else if (is_a<indexed>(other)) { - return get_metric(other.op(1), other.op(2)).is_equal(other); - } else - return false; + ex metr; + if (is_a<clifford>(other)) + metr = ex_to<clifford>(other).get_metric(); + else + metr = other; + + if (is_a<indexed>(metr)) + return metr.op(0).is_equal(get_metric().op(0)); + else { + exvector indices = metr.get_free_indices(); + return (indices.size() == 2) + && simplify_indexed(get_metric(indices[0], indices[1])-metr).is_zero(); + } } ////////// @@ -436,7 +446,7 @@ && ex_to<varidx>(c.op(1)) == ex_to<indexed>(v[i]).get_indices()[1]) || (ex_to<varidx>(c.op(1)).toggle_variance() == ex_to<indexed>(v[i]).get_indices()[0] && ex_to<varidx>(c.op(1)).toggle_variance() == ex_to<indexed>(v[i]).get_indices()[1]))) { - return i; // the index of the found + return i; // the index of the found term } } return -1; //nothing found @@ -758,17 +768,10 @@ if (ex_to<idx>(mu).is_symbolic() && !is_a<varidx>(mu)) throw(std::invalid_argument("clifford_unit(): symbolic index of Clifford unit must be of type varidx (not idx)")); - if (is_a<indexed>(metr)) { - exvector indices = ex_to<indexed>(metr).get_indices(); - if ((indices.size() == 2) && is_a<varidx>(indices[0]) && is_a<varidx>(indices[1])) { - return clifford(unit, mu, metr, rl, anticommuting); - } else { - throw(std::invalid_argument("clifford_unit(): metric for Clifford unit must be indexed exactly by two indices of same type as the given index")); - } - } else if (is_a<tensor>(metr)) { - static varidx xi((new symbol)->setflag(status_flags::dynallocated), ex_to<varidx>(mu).get_dim()), - chi((new symbol)->setflag(status_flags::dynallocated), ex_to<varidx>(mu).get_dim()); - return clifford(unit, mu, indexed(metr, xi, chi), rl, anticommuting); + exvector indices = metr.get_free_indices(); + + if ((indices.size() == 2) && is_a<varidx>(indices[0]) && is_a<varidx>(indices[1])) { + return clifford(unit, mu, metr, rl, anticommuting); } else if (is_a<matrix>(metr)) { matrix M = ex_to<matrix>(metr); unsigned n = M.rows(); @@ -792,9 +795,12 @@ } else { throw(std::invalid_argument("clifford_unit(): metric for Clifford unit must be a square matrix with the same dimensions as index")); } - } else { - throw(std::invalid_argument("clifford_unit(): metric for Clifford unit must be of type indexed, tensor or matrix")); - } + } else if (indices.size() == 0) { // a tensor or other expression without indices + static varidx xi((new symbol)->setflag(status_flags::dynallocated), ex_to<varidx>(mu).get_dim()), + chi((new symbol)->setflag(status_flags::dynallocated), ex_to<varidx>(mu).get_dim()); + return clifford(unit, mu, indexed(metr, xi, chi), rl, anticommuting); + } else + throw(std::invalid_argument("clifford_unit(): metric for Clifford unit must be of type tensor, matrix or an expression with two free indices")); } ex dirac_gamma(const ex & mu, unsigned char rl) Index: check/exam_clifford.cpp =================================================================== RCS file: /home/cvs/GiNaC/check/exam_clifford.cpp,v retrieving revision 1.29 diff -u -r1.29 exam_clifford.cpp --- check/exam_clifford.cpp 19 Jan 2006 16:37:16 -0000 1.29 +++ check/exam_clifford.cpp 19 May 2006 15:41:41 -0000 @@ -457,13 +457,10 @@ varidx mu(symbol("mu"), dim), nu(symbol("nu"), dim), rho(symbol("rho"), dim), psi(symbol("psi"),dim), lam(symbol("lambda"), dim), xi(symbol("xi"), dim); - ex e, G_base; - - if (is_a<indexed>(G)) - G_base = G.op(0); - else - G_base = G; - + ex e; + clifford unit = ex_to<clifford>(clifford_unit(mu, G)); + ex scalar = unit.get_metric(varidx(0, dim), varidx(0, dim)); + e = dirac_ONE() * dirac_ONE(); result += check_equal(e, dirac_ONE()); @@ -472,25 +469,25 @@ e = clifford_unit(varidx(2, dim), G) * clifford_unit(varidx(1, dim), G) * clifford_unit(varidx(1, dim), G) * clifford_unit(varidx(2, dim), G); - result += check_equal(e, dirac_ONE()); + result += check_equal(e, dirac_ONE()*pow(scalar, 2)); e = clifford_unit(mu, G) * clifford_unit(nu, G) * clifford_unit(nu.toggle_variance(), G) * clifford_unit(mu.toggle_variance(), G); - result += check_equal_simplify(e, pow(dim, 2) * dirac_ONE()); + result += check_equal_simplify(e, pow(dim*scalar, 2) * dirac_ONE()); e = clifford_unit(mu, G) * clifford_unit(nu, G) * clifford_unit(mu.toggle_variance(), G) * clifford_unit(nu.toggle_variance(), G); - result += check_equal_simplify(e, 2*dim*dirac_ONE() - pow(dim, 2)*dirac_ONE()); + result += check_equal_simplify(e, (2*dim - pow(dim, 2))*pow(scalar,2)*dirac_ONE()); e = clifford_unit(nu.toggle_variance(), G) * clifford_unit(rho.toggle_variance(), G) * clifford_unit(mu, G) * clifford_unit(rho, G) * clifford_unit(nu, G); e = e.simplify_indexed().collect(clifford_unit(mu, G)); - result += check_equal(e, pow(2 - dim, 2).expand() * clifford_unit(mu, G)); + result += check_equal(e, pow(scalar*(dim-2), 2).expand() * clifford_unit(mu, G)); // canonicalize_clifford() checks, only for symmetric metrics if (ex_to<symmetry>(ex_to<indexed>(ex_to<clifford>(clifford_unit(mu, G)).get_metric()).get_symmetry()).has_symmetry()) { e = clifford_unit(mu, G) * clifford_unit(nu, G) + clifford_unit(nu, G) * clifford_unit(mu, G); - result += check_equal(canonicalize_clifford(e), 2*dirac_ONE()*indexed(G_base, sy_symm(), nu, mu)); + result += check_equal(canonicalize_clifford(e), 2*dirac_ONE()*unit.get_metric(nu, mu)); e = (clifford_unit(mu, G) * clifford_unit(nu, G) * clifford_unit(lam, G) + clifford_unit(nu, G) * clifford_unit(lam, G) * clifford_unit(mu, G) @@ -498,14 +495,14 @@ - clifford_unit(nu, G) * clifford_unit(mu, G) * clifford_unit(lam, G) - clifford_unit(lam, G) * clifford_unit(nu, G) * clifford_unit(mu, G) - clifford_unit(mu, G) * clifford_unit(lam, G) * clifford_unit(nu, G)) / 6 - + indexed(G_base, sy_symm(), mu, nu) * clifford_unit(lam, G) - - indexed(G_base, sy_symm(), mu, lam) * clifford_unit(nu, G) - + indexed(G_base, sy_symm(), nu, lam) * clifford_unit(mu, G) + + unit.get_metric(mu, nu) * clifford_unit(lam, G) + - unit.get_metric(mu, lam) * clifford_unit(nu, G) + + unit.get_metric(nu, lam) * clifford_unit(mu, G) - clifford_unit(mu, G) * clifford_unit(nu, G) * clifford_unit(lam, G); result += check_equal(canonicalize_clifford(e), 0); } else { e = clifford_unit(mu, G) * clifford_unit(nu, G) + clifford_unit(nu, G) * clifford_unit(mu, G); - result += check_equal(canonicalize_clifford(e), dirac_ONE()*(indexed(G_base, mu, nu) + indexed(G_base, nu, mu))); + result += check_equal(canonicalize_clifford(e), dirac_ONE()*(unit.get_metric(mu, nu) + unit.get_metric(nu, mu))); e = (clifford_unit(mu, G) * clifford_unit(nu, G) * clifford_unit(lam, G) + clifford_unit(nu, G) * clifford_unit(lam, G) * clifford_unit(mu, G) @@ -513,9 +510,9 @@ - clifford_unit(nu, G) * clifford_unit(mu, G) * clifford_unit(lam, G) - clifford_unit(lam, G) * clifford_unit(nu, G) * clifford_unit(mu, G) - clifford_unit(mu, G) * clifford_unit(lam, G) * clifford_unit(nu, G)) / 6 - + half * (indexed(G_base, mu, nu) + indexed(G_base, nu, mu)) * clifford_unit(lam, G) - - half * (indexed(G_base, mu, lam) + indexed(G_base, lam, mu)) * clifford_unit(nu, G) - + half * (indexed(G_base, nu, lam) + indexed(G_base, lam, nu)) * clifford_unit(mu, G) + + half * (unit.get_metric(mu, nu) + unit.get_metric(nu, mu)) * clifford_unit(lam, G) + - half * (unit.get_metric(mu, lam) + unit.get_metric(lam, mu)) * clifford_unit(nu, G) + + half * (unit.get_metric(nu, lam) + unit.get_metric(lam, nu)) * clifford_unit(mu, G) - clifford_unit(mu, G) * clifford_unit(nu, G) * clifford_unit(lam, G); result += check_equal(canonicalize_clifford(e), 0); } @@ -580,8 +577,13 @@ result += clifford_check7(minkmetric(), dim); cout << '.' << flush; varidx chi(symbol("chi"), dim), xi(symbol("xi"), dim); + result += clifford_check7(delta_tensor(xi, chi), dim); cout << '.' << flush; + result += clifford_check7(lorentz_g(xi, chi), dim); cout << '.' << flush; + result += clifford_check7(indexed(-2*minkmetric(), sy_symm(), xi, chi), dim); cout << '.' << flush; + result += clifford_check7(-2*delta_tensor(xi, chi), dim); cout << '.' << flush; + if (!result) { cout << " passed " << endl; clog << "(no output)" << endl;

2 1

Lst test in clifford.cpp
by Vladimir Kisil 15 May '06

15 May '06

Dear All, I propose to change all test for an argument type lst as follows: is_a<lst>(e) --> e.info(info_flags::list) The former tests fail with lst created by boostPython (e.g. pyGiNaC) and the later are passed. I did the change in clifford.cpp and wondering if it should be applied everywhere. The included patch is cumulative from my previous two messages. Best wishes, Vladimir -- Vladimir V. Kisil email: kisilv(a)maths.leeds.ac.uk -- www: http://maths.leeds.ac.uk/~kisilv/ /home/amsta/kisilv/GiNaC Index: debian/changelog =================================================================== RCS file: /home/cvs/GiNaC/debian/changelog,v retrieving revision 1.36 diff -u -r1.36 changelog --- debian/changelog 20 Apr 2006 22:59:39 -0000 1.36 +++ debian/changelog 10 May 2006 12:16:15 -0000 @@ -3,7 +3,7 @@ * New upstream release; binary incompatible, so it's libginac1.4 now. * debian/*: Streamlining by Peter Eisentraut <petere(a)debian.org>. - -- Richard Kreckel <kreckel(a)ginac.de> <DATE> + -- Richard Kreckel <kreckel(a)ginac.de> Mon, 17 Apr 2006 22:25:48 +0200 ginac (1.3.4-1) unstable; urgency=low Index: doc/tutorial/ginac.texi =================================================================== RCS file: /home/cvs/GiNaC/doc/tutorial/ginac.texi,v retrieving revision 1.185 diff -u -r1.185 ginac.texi --- doc/tutorial/ginac.texi 22 Apr 2006 15:42:57 -0000 1.185 +++ doc/tutorial/ginac.texi 10 May 2006 12:16:15 -0000 @@ -2053,6 +2053,12 @@ @} @end example +@cindex @code{is_zero_matrix()} +The method @code{matrix::is_zero_matrix()} returns @code{true} only if +all entries of the matrix are zeros. There is also method +@code{ex::is_zero_matrix()} which returns @code{true} only if the +expression is zero or a zero matrix. + @cindex @code{transpose()} There are three ways to do arithmetic with matrices. The first (and most direct one) is to use the methods provided by the @code{matrix} class: @@ -3545,9 +3551,10 @@ the matrix @samp{M = [[a, b], [c, d]]}. The parameter @code{G} defines the metric of the surrounding (pseudo-)Euclidean space. This can be an indexed object, tensormetric, matrix or a Clifford unit, in the later -case the optional parameters @code{rl} and @code{anticommuting} are ignored -even if supplied. The returned value of this function is a list of -components of the resulting vector. +case the optional parameters @code{rl} and @code{anticommuting} are +ignored even if supplied. Depending from the type of @code{v} the +returned value of this function is either a vector or a list holding vector's +components. @cindex @code{clifford_max_label()} Finally the function @@ -4097,7 +4104,8 @@ @end example for checking whether one expression is equal to another, or equal to zero, -respectively. +respectively. See also the method @code{ex::is_zero_matrix()}, +@pxref{Matrices}. @subsection Ordering expressions Index: ginac/clifford.cpp =================================================================== RCS file: /home/cvs/GiNaC/ginac/clifford.cpp,v retrieving revision 1.95 diff -u -r1.95 clifford.cpp --- ginac/clifford.cpp 22 Feb 2006 14:52:07 -0000 1.95 +++ ginac/clifford.cpp 10 May 2006 12:16:15 -0000 @@ -1053,7 +1053,7 @@ pointer_to_map_function fcn(canonicalize_clifford); if (is_a<matrix>(e_) // || is_a<pseries>(e) || is_a<integral>(e) - || is_a<lst>(e_)) { + || e_.info(info_flags::list)) { return e_.map(fcn); } else { ex e=simplify_indexed(e_); @@ -1120,7 +1120,7 @@ if (is_a<clifford>(e) && is_a<cliffordunit>(e.op(0))) { return -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)) { + || is_a<matrix>(e) || e.info(info_flags::list)) { return e.map(fcn); } else if (is_a<power>(e)) { return pow(clifford_prime(e.op(0)), e.op(1)); @@ -1145,7 +1145,7 @@ else throw(std::invalid_argument("remove_dirac_ONE(): expression is a non-scalar Clifford number!")); } else if (is_a<add>(e1) || is_a<ncmul>(e1) || is_a<mul>(e1) - || is_a<matrix>(e1) || is_a<lst>(e1)) { + || is_a<matrix>(e1) || e1.info(info_flags::list)) { if (options & 3) // is a child or was already expanded return e1.map(fcn); else @@ -1227,8 +1227,8 @@ else throw(std::invalid_argument("lst_to_clifford(): dimensions of vector and clifford unit mismatch")); } else - throw(std::invalid_argument("lst_to_clifford(): first argument should be a vector vector")); - } else if (is_a<lst>(v)) { + throw(std::invalid_argument("lst_to_clifford(): first argument should be a vector (nx1 or 1xn matrix)")); + } else if (v.info(info_flags::list)) { if (dim == ex_to<lst>(v).nops()) return indexed(matrix(dim, 1, ex_to<lst>(v)), ex_to<varidx>(mu).toggle_variance()) * e; else @@ -1246,7 +1246,7 @@ pointer_to_map_function_1arg<const ex &> fcn(get_clifford_comp, c); int ival = ex_to<numeric>(ex_to<varidx>(c.op(1)).get_value()).to_int(); - if (is_a<add>(e) || is_a<lst>(e) // || is_a<pseries>(e) || is_a<integral>(e) + if (is_a<add>(e) || e.info(info_flags::list) // || is_a<pseries>(e) || is_a<integral>(e) || is_a<matrix>(e)) return e.map(fcn); else if (is_a<ncmul>(e) || is_a<mul>(e)) { @@ -1335,7 +1335,7 @@ { ex x, D, cu; - if (! is_a<matrix>(v) && ! is_a<lst>(v)) + if (! is_a<matrix>(v) && ! v.info(info_flags::list)) throw(std::invalid_argument("clifford_moebius_map(): parameter v should be either vector or list")); if (is_a<clifford>(G)) { @@ -1352,8 +1352,8 @@ } x = lst_to_clifford(v, cu); - ex e = simplify_indexed(canonicalize_clifford((a * x + b) * clifford_inverse(c * x + d))); - return clifford_to_lst(e, cu, false); + ex e = clifford_to_lst(simplify_indexed(canonicalize_clifford((a * x + b) * clifford_inverse(c * x + d))), cu, false); + return (is_a<matrix>(v) ? matrix(ex_to<matrix>(v).rows(), ex_to<matrix>(v).cols(), ex_to<lst>(e)) : e); } ex clifford_moebius_map(const ex & M, const ex & v, const ex & G, unsigned char rl, bool anticommuting) Index: ginac/ex.h =================================================================== RCS file: /home/cvs/GiNaC/ginac/ex.h,v retrieving revision 1.87 diff -u -r1.87 ex.h --- ginac/ex.h 21 Apr 2006 12:16:01 -0000 1.87 +++ ginac/ex.h 10 May 2006 12:16:15 -0000 @@ -205,6 +205,7 @@ int compare(const ex & other) const; bool is_equal(const ex & other) const; bool is_zero() const { extern const ex _ex0; return is_equal(_ex0); } + bool is_zero_matrix() const; // symmetry ex symmetrize() const; Index: ginac/ex.cpp =================================================================== RCS file: /home/cvs/GiNaC/ginac/ex.cpp,v retrieving revision 1.60 diff -u -r1.60 ex.cpp --- ginac/ex.cpp 27 Mar 2006 15:13:22 -0000 1.60 +++ ginac/ex.cpp 10 May 2006 12:16:16 -0000 @@ -28,6 +28,7 @@ #include "mul.h" #include "ncmul.h" #include "numeric.h" +#include "matrix.h" #include "power.h" #include "lst.h" #include "relational.h" @@ -254,6 +255,17 @@ return bp->is_polynomial(vars); } +/** Check whether expression is zero or zero matrix. */ +bool ex::is_zero_matrix() const +{ + if (is_zero()) + return true; + else { + ex e = evalm(); + return is_a<matrix>(e) && ex_to<matrix>(e).is_zero_matrix(); + } +} + // private /** Make this ex writable (if more than one ex handle the same basic) by Index: ginac/matrix.h =================================================================== RCS file: /home/cvs/GiNaC/ginac/matrix.h,v retrieving revision 1.71 diff -u -r1.71 matrix.h --- ginac/matrix.h 21 Apr 2006 12:16:01 -0000 1.71 +++ ginac/matrix.h 10 May 2006 12:16:16 -0000 @@ -151,6 +151,7 @@ matrix solve(const matrix & vars, const matrix & rhs, unsigned algo = solve_algo::automatic) const; unsigned rank() const; + bool is_zero_matrix() const; protected: ex determinant_minor() const; int gauss_elimination(const bool det = false); Index: ginac/matrix.cpp =================================================================== RCS file: /home/cvs/GiNaC/ginac/matrix.cpp,v retrieving revision 1.108 diff -u -r1.108 matrix.cpp --- ginac/matrix.cpp 21 Apr 2006 12:16:01 -0000 1.108 +++ ginac/matrix.cpp 10 May 2006 12:16:16 -0000 @@ -1527,6 +1527,16 @@ return k; } +/** Function to check that all elements of the matrix are zero. + */ +bool matrix::is_zero_matrix() const +{ + bool result = true; + for (exvector::const_iterator i=m.begin(); i!=m.end(); ++i) + result = result && (*i).is_zero(); + return result; +} + ex lst_to_matrix(const lst & l) { lst::const_iterator itr, itc;

2 3

map_functions out of methods.
by Chris Dams 09 May '06

09 May '06

Dear all, At the moment a map_function can be made out of a function. Sometimes, however, it is also useful to be able to do this out of a member function. For this purpose I added the necesary classes to ex.h. Best, Chris

1 0