simplify_indexed() will re-expand the expression and re-run the
simplification if a contraction in a product resulted in a factor that
is a sum or a product itself; so e.g. gamma~mu*gamma~nu*gamma.nu*gamma.mu
will return dim^2*ONE without having to run simplify_indexed() twice

* removed some obsolete stuff.

degree(), ldegree(), coeff(), lcoeff(), tcoeff() and collect() can now
be used with constants and indexed expressions as well, so you can use
it to collect by powers of Pi or find the coefficient of gamma~0.
Limitations:
 - it only works with symbols, constants and indexed expressions;
   trying to find the coefficient of, e.g., "x^2" or "x+y" won't work
 - it does not know about dummy index summations; the coefficient of
   gamma~0 in p.mu*gamma~mu should be p.0 but is returned as 0
 - using the functions on elements of noncommutative products might
   return wrong or surprising results

the unsigned number 128 was stored incorrectly (0x80 instead of 0x80 0x01)

- added Clifford contractions:
   gamma~mu*gamma~alpha*gamma~beta*gamma.mu
   gamma~mu*gamma~alpha*gamma~beta*gamma~delta*gamma.mu
- detection of free indices of the complete product in
  simplify_indexed_product() could go wrong if contractions resulted in
  composite expressions

- dummy index recognition in products was flawed: A.i.i*B.j.j would be
  treated as a scalar product of A and B, A.j.j.i.i*B.k.l would be 0
  if A was symmetric and B antisymmetric etc.
- removed redundant code for handling d.akl*f.akl contraction; this is
  handled by simplify_indexed() itself since it is a contraction of a
  symmetric with an antisymmetric tensor

added checks for bugs in GiNaC 0.8.0

added checks for color objects

- added Clifford algebra unity element
- superfluous unity elements are removed from Clifford and color strings
- added Clifford contractions:
    gamma~mu*gamma.mu
    gamma~mu*gamma~alpha*gamma.mu
- added color contractions:
    d.aac
    d.abc*d.abc
    d.akl*d.bkl
    d.abc*f.abc
    d.akl*f.bkl
    f.abc*f.abc
    f.akl*f.bkl
- delta tensor and color structure constants can be evaluated numerically
- color_T(), color_d() and color_f() check their arguments
- added a couple of utility functions to idx.*
- simplify_indexed() doesn't crash any more when used on expressions containing
  noncommutative products

- introduced macros to shorten the source files
- added exam_color()

skeleton implementation of new color class

restored deleted files

- added skeleton implementation of color and clifford classes (don't bother
  trying it, it doesn't work yet)
- some macros in utils.h (DEFAULT_*) provide shorthands for implementing
  many required class member functions

contraction of symmetric with antisymmetric tensor over more than one index
is zero

added check for contraction of epsilon with symmetric tensor

* Documented sqrfree.

* Date inserted.

* Tidied some old crap.

fixed memory leaks in lst_to_matrix() and diag_matrix()

lst_to_matrix() takes a "lst &" instead of an "ex &"

- simplify_indexed() simplifies c*(M).i.j -> (M').i.j (c: numeric, M: matrix)
  with M'=c*M
- new member function matrix::mul(const numeric &other) to multiply matrix
  with scalar
- lst_to_matrix() takes a "lst &" instead of an "ex &"
- added constructor of matrix from flat list
- added function diag_matrix() to construct matrix from list of diagonal
  elements

simplify_indexed() recognizes linear combinations of matrices with numeric
coefficients

used new diag_matrix() and matrix from lst constructor

documentation update

* Eliminated overloaded operator% for noncommunistic objects for good.
  End of story.  There was just too much risk involved in somebody not
  caring enough whether there are noncommutatating objects inside
  expressions to be multiplied and it could potentially end up in people
  using operator% instead of operator* all the time, just to be safe.
  In any case, it was our firm believe that noncommutatividity is a
  property of the class objects belong to and hence of the objects and
  not at all of the sign to symbol the object (as Maple, Reduce and others
  want to make us believe).  Finally we found out how to code operator*
  so that it handles both cases without any performance loss.  It couldn't
  be less intrusive!  There is no measurable performance degradation.
  (Except perhaps for the tgamma-expansion which seems to show some 3%
  loss while others mysteriously become somewhat faster -- my brain is
  melting.)  Enough, now...

* configure.in, cint/run_exams.cpp, cint/ginaccint.cpp: adjusted the
  --with-cint logic so ginaccint may run without a preset $CINTSYSDIR
  (in case of a clean system-wide installation as opposed to the tool-
  centric installation).  cint/Makefile.makecint generation does not
  yet work in this case, makecint needs a tiny upstream bugfix.

* INSTALL: reflect Cint status.
* configure.in, cint/run_exams.cpp, cint/ginaccint.cpp: adjusted the
  --with-cint logic so ginaccint may run without a preset $CINTSYSDIR
  (in case of a clean system-wide installation as opposed to the tool-
  centric installation).  cint/Makefile.makecint generation does not
  yet work in this case, makecint needs a tiny upstream bugfix.

sums of indexed matrices are now possible

added another relativistic electrodynamics check (energy density and Poynting
vector)

bumped version number to 0.8.0

* tensdelta is an atomic class.

- the tensor returned by metric_tensor() is symmetric
- (c*x)~mu with c being a number automatically gets converted to c*x~mu

the tensor returned by metric_tensor() is symmetric

* Adjusted to current class shuffling.

added tutorial section about indexed objects

an indexed "0" is just a plain "0"

* Exam some simple square free factorizations.

* added missing std::

* add missing std::.

added checks involving epsilon tensor

added predefined epsilon tensor

documentation update

* ex.h: add docu.
* normal.cpp: make sqrfree_yun() static.
* basic.cpp (compare): slightly clarify syntax.

fix stupid memory problem.

normal.cpp, normal.h: Fix Yun's algorithm (there was a mistake in Geddes et
al.) for square-free factorization.  Also change the syntax to allow for
square-free factoring in a recursive way in Q[X].  This is an example how it
works in Z[x,y,z] in ginsh:
> ?sqrfree
sqrfree(expression [, symbol-list]) - square-free factorization of a polynomial
> sqrfree(expand((x+y)*(x+y+z)^2*(y-z)^3));
(x+y)*(-x-y-z)^2*(y^3+3*y*z^2-3*y^2*z-z^3)
> sqrfree(expand((x+y)*(x+y+z)^2*(y-z)^3),[y]);
(x+y)*(y-z)^3*(x+y+z)^2
> sqrfree(expand((x+y)*(x+y+z)^2*(y-z)^3),[z]);
(x+y)*(y-z)^3*(x+y+z)^2
> sqrfree(expand((x+y)*(x+y+z)^2*(y-z)^3),[x]);
(x+y)*(-x-y-z)^2*(y^3+3*y*z^2-3*y^2*z-z^3)
> sqrfree(expand((x+y)*(x+y+z)^2*(y-z)^3),[x,y]);
(x+y)*(-x-y-z)^2*(y^3+3*y*z^2-3*y^2*z-z^3)
> sqrfree(expand((x+y)*(x+y+z)^2*(y-z)^3),[x,y,z]);
(x+y)*(-x-y-z)^2*(y^3+3*y*z^2-3*y^2*z-z^3)
> sqrfree(expand((x+y)*(x+y+z)^2*(y-z)^3),[v]);
3*x*y^5+3*x^2*y^4+x^3*y^3+y^6-y*z^5-2*y^4*z^2+y^2*z^4-y^5*z+2*y^3*z^3-3*x^3*y^2*z+3*x^3*y*z^2-5*x*y^4*z-x*y*z^4+3*x^2*y*z^3+6*x*y^2*z^3+3*x^2*y^2*z^2-2*x*y^3*z^2-7*x^2*y^3*z-x^3*z^3-2*x^2*z^4-x*z^5

fixed major memory leak in mul::expand()

- lcm_of_coefficients_denominators(1/2+x^10) returned 1024 instead of 2 and
  multiply_lcm() on that expression barfed
- contract_with() now takes two exvector::iterators and and exvector; this
  makes it possible to look for more contractions in the implementation

- revamped indexed objects
- subs() works on matrices

added checks for new indexed objects

documentation update

removed obsolete files

* New funny timing added: compute an antipode in Yukawa theory.

* ginac/pseries.cpp (pseries::compare_same_type): optimized.

* This is a deliberately silly commit.

* Really make those macros work...

updated to "autogen.sh Professional"

* ginac/registrar.h: dtor is inlined now.
* ginac/basic.h, ginac/ex.h: removed INLINE_FOO_CONSTRUCTORS and hand-inlined
  stuff instead, since the macros turned out to get in the way while
  fine-tuning the inlining.
* ginac/utils.h: if 'long long' works, use that one for computing the hash
  value instead of floating point tricks.  2 Reasons: on Intel the assembler
  is terrible and slow otherwise, 'long long' will appear in C++ anyways when
  they adapt to the C99 standard.
* Several other small performance tweaks.
* ginac/constant.cpp: (constant::calchash()) implement, caring for serial.
* ginac/function.pl (function::calchash()): implement, caring for serial.
* ginac/expairseq.cpp: honor coeff's hash value.
* ginac/pseries.cpp: (pseries::power_const()) fix problems with zero pseries.
* Added several pounds of in-source documentation in doxygen style.

* Tweak around problem with unexpanded GINAC_DECLARE_REGISTER_CLASS macros.

* Prepare for landing of version 0.7.3.

* Macro deobfuscation.

* some longish timings are now disabled by default.
* check/time_lw_M2.cpp: new timing (defaults to disabled)
* check/time_lw_N.cpp: new timing (defaults to disabled)

* prepare for landing of version 0.7.3.

when there are multiple variables with the same maximum degree, the one with
the least number of terms in the leading coefficient is chosen as the main
variable in GCD computations

"return" statement was missing in yyerror()

building in separate directory didn't work

- g~mu_mu contraction returns Dim for general Lorentz indices and Dim-dimP
  for orthogonal-only indices

documentation update

added a section about adding new algebraic classes to GiNaC

Fix two leaks in class pseries, where zero terms could have been created.

is_(ex_)(exactly_)of_type: macros fixed, simplfied and documented.

pseries::expand(): do not generate zero terms.
pseries::print(): print trivial case, too.
others: documentation updates.

Fix typos.

Minor fixes.

Reflect version number 0.7.2 and update Cint status.

GINAC_DECLARE_REGISTERED_CLASS declares duplicate() and compare_same_type(),
GINAC_IMPLEMENT_REGISTERED_CLASS implements duplicate()

the destructor, copy constructor, and assignment operator (which were the
same for all subclasses of basic, with very few exceptions) are now included
in the GINAC_IMPLEMENT_REGISTERED_CLASS macro; the GINAC_DECLARE_REGISTERED_CLASS
macro also defines these (and other common) member functions

disabled the exam because the lortensor API is going to change soon

add two checks that power::series did wrong so far.

pseries::power_const: fix a critical bug that led to wrong computations.
power::series: better handling of divergent basis cases.

removed the "some_*" and "typeid_*" definitions since we are using our own
RTTI for quite some time now

Adapted to new version 1.2.5.

added missing thisexprseq() to clifford class

- added documentation to the indexed, color, lortensor and clifford classes
- moved Dim() function from lortensor.cpp to lorentzidx.cpp
- moved append_exvector_to_exvector() from color.cpp to utils.cpp
- some cleanups in the lortensor and clifford classes

- added documentation for the idx, coloridx and lorentzidx classes
- idx_intersect() works correctly when indices appear multiple times
- g~mu_mu = D-2 (instead of D-dim(P))

Hope this works now.

More file cleanups

trancendental function branch-point sanity

ChangeLog: mention cvs log (must be non-empty for Debian)
INSTALL: update cint-status
configure.in, NEWS: Prepare for release

Explain the branch-cut conventions in some more detail.

Added correct series expansion for atan and atanh.

Fixed most bugs with building Debian packages.

- throw at atan()'s poles.

documentation update

list of completion work break characters set correctly

normal() applied to a power expression also normalizes the exponent

expand() always expands the exponent and transforms x^(a+b) -> x^a*x^b

added a check that expand(x^((a+b)^2-a^2-b^2-2*a*b)) -> 1

updated changes

- Lewis-Wester tests D and E now benchmark the time to expand the
  rational function.  Just assembling it is boring...

- gcd() and lcm() always checked the second argument, even when check_args
  was false
- add::normal() handles large expressions (that collapse to much smaller ones)
  better