* Added new operator semantics.

* Added some messy exams for new operator semantics.

* All operators are now strictly following the semantics we all know from
  C/C++.  I.e. e1+e2=42; is now impossible and other such stuff.  For all
  remaining errors (i.e. ++e1 = e1+1;) the compiler alone is to blame...

- Remved obsolete remainders of preprocessor symbol NO_NAMESPACE_GINAC.

* Methods of class ex which do absolutely nothing than type dispatch should
  be inlined for obvious reasons.

* Updated Cint status.

Changes needed for compilation with -DDO_GINAC_ASSERT:
* basic.cpp: if needed, #include <typeinfo>,
* mul.h: mul::print() needed a default for 2nd arg.
Hey, Cebix, could you please have a look at the assertions of type
basis.return_type()==return_types::commutative in power.cpp ctors?
Watch out, though: they are not just bogus because of the rule
(x*y)^2 -> x^2*y^2 in power::eval().

- symbols can have a LaTeX name, e.g. symbol s("s", "\\sigma");
- LaTeX output of indexed objects and tensors is much nicer
- simplify_indexed() can do arbitrary contractions in Dirac gamma strings
- constructing expressions like
    (x * dirac_ONE() + dirac_ONE()) * dirac_gamma(mu)
  resulted in an exception because mul::simplify_ncmul() wasn't implemented
  (maybe afrink didn't anticipate that an implementation would really be
  needed...)

- more clifford checks
- archive checks has a symbol with a LaTeX name

documentation and grammar updates

* add::coeff(): don't epvector::reserve() more terms than we'll actually
  need and don't epvector::push_back() all those _ex0()'s into coeffseq.

* Fix incompatibilities with recent versions of libreadline by having
  configure find out the version and then doing ugly things with #ifdef.

* Fix incompatibilities with recent versions of libreadline by having
  configure find out the version and then doing ugly things with #ifdef.
* config.*: updates from upstream.

* Just for the record: this is what has been used for building.

- dirac_trace() handles arbitrary expressions (even unexpanded), including
  gamma5
- implemented color_trace()
- eps0123() creates a 4-dimensional epsilon tensor without checking the
  indices (so they may be D-dimensional); this may become a different class
  soon, but for now all the implemented properties of the standard epsilon
  tensor also apply to eps0123

added more trace checks

dirac_trace() can handle arbitrary gamma strings without gamma5. The only
remaining unimplemented case is now Tr[gamma5 S_2n]

added more trace checks

* Minor packaging fixes.
* Pushing towards version 0.8.2-1.

* Cint fix.  It looks like the hacks are going to go away really soon,
  after some recent work by Masaharu.

* Example: Don't confuse users with _ex0().

* Push towards 0.8.2.

- added get_representation_label()
- clifford contractions honor repr. label
- first implementation of dirac_trace(), works with 0..3 clifford objects

added first trace check

\18* class matrix: solve() doesn't call algorithms redundantly any more and
  inverse() falls back to solve() which works in more general cases.

* class matrix: solve() doesn't call algorithms redundantly any more and
  inverse() falls back to solve() which works in more general cases.

- degree(), ldegree(), coeff(), lcoeff(), tcoeff() and collect() work with
  non-symbols as the second argument
- collect_distributed() produces result in distributed form (second argument
  should be a list of symbols)

- color/clifford objects have representation label to distinguish elements
  of different algebras; objects with different labels commute with each
  other
- dirac_one() -> dirac_ONE()
- added gamma5 clifford objects which is constructed by dirac_gamma5()
- clifford::simplify_ncmul() anticommutes gamma5's to the front and removes
  squares of gamma5
- the argument to collect() can be a list of objects in which case the
  result is either a recursively collected polynomial, or a polynomial in
  a distributed form with terms like coeff*x1^e1*...*xn^en, as specified by
  the second argument to collect(). For example (ginsh):
    > f=a*x-x+a*x*y+x*y+a*x*y^2-2*x*y^2+y^2;
    a*x+y*a*x+y^2*a*x+y^2-x+y*x-2*y^2*x
    > collect(f,x);
    (-1+y+y^2*a+y*a+a-2*y^2)*x+y^2
    > collect(f,y);
    a*x-x+y^2*(1+a*x-2*x)+y*(a*x+x)
    > collect(f,[x,y]);
    (-1+y*(1+a)+y^2*(-2+a)+a)*x+y^2
    > collect(f,[y,x]);
    (-1+a)*x+y*(1+a)*x+(1+(-2+a)*x)*y^2
    > collect_distributed(f,[x,y]);
    (-1+a)*x+y^2*(-2+a)*x+y*(1+a)*x+y^2

- dirac_one() -> dirac_ONE()
- more clifford checks

documentation update

* fixed some mindboggling tremendous superhuge gigantic #*@$&! memory leaks.

* color.cpp: remove duplicated default args.
* numeric.cpp: insert some missing cln:: namespace decls.
  Why did this ever work?
* structure.cpp, structure.h: adjust to the new print scheme.

* Now this four-package split-up is gonna get in.  Promised.

* Finalization for 0.8.1.

* Documented print_latex.

* Don't print '*' in LaTeX mode.

* Still some std:: missing...

* Added example about series expansion.

* basic::collec() never worked correctly on non-polynomials till now.
  We simply correct for the missing terms, which makes it at least
  algebraically correct (suggested by Pearu Peterson).
* Added support to print out LaTeX-style, based on some work by Stefan
  Weinzierl:
  - print.h: added a class print_latex().
  - function.pl: added function_options::latex_name() because there was
    no good way of setting that name before.
  - inifncs*.cpp: use it.
  - *.cpp: switch to see if print_context is actually print_latex and
    then change the style.
* Fixed some stupid bugs in sections that were #define'd away for gcc-2.95.

* INSTALL: adjusted Cint status.
* document change in .collect().

* Preparing for 0.8.1.

* Removed obsolete exponent marker in float output example.

* add::print() shouldn't put parens around overall_coeff.

* Remove bogus counter in sqrfree_yun().

archive property example uses propinfovector

added basic::get_precedence()

* introduced typedef propinfovector in order to please Cint.

adapted to change symbol::getname() -> symbol::get_name()

added functions to retrieve the properties stored in archive objects
outside of unarchive(), for printing or debugging purposes

- updated to reflect the extended possibilities of subs(), (l)degree(),
  (l/t)coeff() and collect()
- added examples for specialized expression output by tree-traversal and
  with the aid of archives

documentation update

- renamed
    function::getserial() -> function::get_serial()
    symbol::setname() -> symbol::set_name()
    symbol::getname() -> symbol::get_name()
  for consistency (since the interface has changed anyway)
- added pseries::get_var() and pseries::get_point()

added function::get_name() to return a function's print name

something like 2/3*a is no longer printed as (2/3)*a

updated with respect to new print() method

printtree() -> print(print_tree())

- replaced the various print*() member functions by a single print() that
  takes a print_context object that determines the output formatting; this
  should make it easier to add more output types
- print_tree output of indexed objects looks better

added check for archiving system

documentation update

subs() performs "syntactic substitution" as in Maple; you can substitute
any object by any other object (even numerics) but only when the object
subs() is called on exactly matches an object on the left-hand side of the
substitution list; expairseq still doesn't substitute its numeric coefficients
so substituting numerics will not replace them in all occurences (this
shouldn't matter, though)

documentation update

- subs() can be used to substitute functions, tensors and indexed objects
- op(0) of an idx object returns the index value; a nice side-effect of
  this is that idx'es no longer all have the same hash value
- added checks for clifford class

- subs() can be used to substitute functions, tensors and indexed objects
- op(0) of an idx object returns the index value; a nice side-effect of
  this is that idx'es no longer all have the same hash value

documentation update

degree(), ldegree(), coeff(), tcoeff(), lcoeff() and collect() work with
functions (you can collect by powers of sin(x) etc.)

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