]> www.ginac.de Git - ginac.git/blobdiff - NEWS
* Make print_memfun_handler<T, C> const-correct (fixes build with gcc-4.0.2).
[ginac.git] / NEWS
diff --git a/NEWS b/NEWS
index dcf259c8acb0e0deae546dc200064601954a53e1..7f54472598530a029f5227a8433a058557fed8f1 100644 (file)
--- a/NEWS
+++ b/NEWS
 This file records noteworthy changes.
 
-1.2.0 (<insert date>)
+1.3.1 (04 May 2005)
+* integral() and eval_integ() can be used from ginsh.
+* Integrals can be series-expanded.
+* Fixed a library initialization problem.
+* GiNaC compiles from tarball even if lex/flex is missing.
+* Fixed bugs in canonicalize_clifford(), clifford_prime() and clifford_to_lst().
+* clifford_moebius_map(), remove_dirac_ONE() and LaTeX output of Clifford
+  objects now care about representation labels.
+* Fixed bug in gcd.
+* Better output for slashed expressions
+
+1.3.0 (19 October 2004)
+* 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. [V. Kisil]
+* Added some basic symbolic and numeric integration facilities. [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).
+
+1.2.4 (12 October 2004)
+* 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().
+
+1.2.3 (13 August 2004)
+* Added variants of dirac_trace() and color_trace() that take the trace over
+  more than one representation label by specifying a set or list of labels.
+* diracgamma::contract_with() uses Chisholm identities in 4 dimensions to
+  produce more compact results.
+* Fixed a bug in the series expansion of powers.
+* The --enable-html-doc and --enable-ps-doc configure options are gone.
+  Documentation in HTML, DVI, PostScript, and PDF formats is now built with
+  "make html", "make dvi", "make ps", and "make pdf", respectively. The only
+  documentation that gets built by default are the tutorial in .info format
+  and the manpages.
+
+1.2.2 (3 August 2004)
+* Added const_preorder_iterator and const_postorder_iterator classes (and
+  associated methods ex::pre/postorder_begin/end()) providing tree traversal
+  with iterators.
+* Fixed the LaTeX output of the varidx class.
+* Fixed bugs in series expansion and complex conjugation.
+* (p.i*p.i).get_free_indices() returns the correct result () instead of (.i).
+* Symbolic functions without any eval(), evalf() etc. functions now work
+  properly.
+* integer_content(), content(), and primpart() now also work for polynomials
+  with rational coefficients (calculating the LCM of coefficients'
+  denominators).
+* Added method matrix::rank().
+* Added function resultant().
+* Added integer_content() function to ginsh.
+
+1.2.1 (23 April 2004)
+* Fixed infinite recursion in atan2_evalf() and improved atan2_eval().
+* Added automatic evaluations for trigonometric functions with negative
+  arguments (e.g. sin(-2) -> -sin(2)).
+* Fixed a static initialization order goof-up.
+* Fixed various bugs in series expansion.
+
+1.2.0 (19 March 2004)
 * Added a structure<T> template class for the easy creation of user-defined
   algebraic classes.
-* Improved the speed of subs() and normal() by the use of maps instead of
-  lists.
-* Many internal reorganizations and optimizations.
+* Added support for (acyclic) visitors, to allow cleaner implementations of
+  algebraic algorithms.
+* Added a const_iterator class that can be used instead of op()/nops().
+* Completely revamped the implementation of expression output. It is now
+  possible to add new output formats, to change the behavior of predefined
+  formats at run-time, and to have different output styles for algebraic
+  functions.
+* Symbols can be made non-commutative.
+* Added a method ex::conjugate() and a function conjugate() for complex
+  conjugation. Symbols can be declared as real or complex-valued.
+* Improved the speed of subs(), normal(), to_rational() and to_polynomial()
+  by the use of maps instead of lists. The old forms
+    subs(const lst & ls, const lst & lr, unsigned options)
+    to_rational/to_polynomial(lst & repl)
+  are still available for compatibility, but using the new forms
+    subs(const exmap & m, unsigned options)
+    to_rational/to_polynomial(exmap & repl)
+  is more efficient, especially when the number of replacements is large.
+* quo(), rem(), prem(), sprem(), decomp_rational(), unit(), content(),
+  primpart() and matrix::charpoly() now take a "const ex &" instead of a
+  "const symbol &".
+* Redundant expressions (two ex pointing to different objects are found to be
+  equal in compare()) are now actively deleted/fused to conserve memory and
+  speed up subsequent comparisons. This behavior can be suppressed on a
+  per-object level with status_flags::not_shareable. Lists and matrices are
+  not shareable by default.
+* Lots of internal streamlining and optimizations.
 * Caveats for class implementors:
    - basic::copy() and basic::destroy() are gone; classes derived from
      basic can use the defaults for the assignment operator and copy
      constructor.
-   - basic::subs() and basic::normal() take an 'exmap &' instead of two
-     'lst &'.
+   - basic::subs(), basic::normal(), basic::to_rational() and
+     basic::to_polynomial() take 'exmap' objects instead of lists.
    - basic::subs() now descends into subexpressions (if accessible via
      nops()/op()/let_op()). If you have a custom implementation of subs()
      that calls basic::subs() after substituting subexpressions, this needs
      to be changed to a call to subs_one_level().
+   - lst::thislst() and exprseq::thisexprseq() renamed to thiscontainer().
+   - thiscontainer() and associated constructors now take a std::auto_ptr.
+   - Overloading basic::print() is now deprecated. You should use
+     print_func<>() class options instead.
+
+1.1.7 (11 March 2004)
+* Fixed a bug in canonicalize_clifford().
+* Series expansion now works predictably. All terms with the exponent of the
+  expansion variable smaller than the given order are calculated exactly. If
+  the series is not terminating, the Order function is (at least) of the given
+  order.
+
+1.1.6 (22 January 2004)
+* Added a function option "dummy()" which means "no options". This simplifies
+  the implementation of symbolic functions which are not to be further
+  evaluated.
+* Removed a bug in the numerical evaluation of Li() that caused the system
+  to hang for certain parameter combinations.
+* Fixed a bug in the calculation of hash values for indices that could lead
+  to wrong results or bogus error messages from simplify_indexed().
+* Fixed a bug in the evaluation of harmonic polylogarithms for complex
+  arguments with positive imaginary part.
+
+1.1.5 (5 November 2003)
+* Harmonic polylogarithms now numerically evaluate for arbitrary arguments
+  (parameter must still be positive integers).
+* The zeta function now can also be given a lst as a parameter in which case
+  it becomes a multiple zeta value. The use of mZeta is deprecated.
+* The order of parameters for the multiple polylogarithm has been corrected.
+* Documentation for the nested sums functions zeta, harmonic polylog, multiple
+  polylog, etc. has been added.
+
+1.1.4 (17 October 2003)
+* Lists and matrices can now be initialized from comma-separated lists of
+  expressions, like this:
+
+    lst l;
+    l = x, 2, y, x+y;
+
+    matrix M(3, 3);
+    M = x, y, 0,
+       -y, x, 0,
+        0, 0, 1;
+
+  This is both faster and produces much smaller code than the old constructors
+  lst(ex, ex, ...) and matrix(unsigned, unsigned, lst), especially in the case
+  of matrices, and is now the recommended way to create these objects.
+* The function mZeta now evaluates much faster for arbitrary parameters. The
+  harmonic and multiple polylogarithms evaluate considerably faster and check
+  for convergence. The order of parameters for the harmonic polylogarithm
+  has been corrected.
+
+1.1.3 (22 August 2003)
+* Added new symbolic functions for better integration with nestedsums:
+  (multiple) polylogarithm Li(), Nielsen's generalized polylogarithm S(),
+  harmonic polylogarithm H(), and multiple zeta value mZeta().
+* New exhashmap<T> template intended as a drop-in replacement for
+  std::map<ex, T, ex_is_less> using GiNaC's hashing algorithms.
+
+1.1.2 (11 August 2003)
+* Fixed a bug in the unarchiving of sums and products: terms were not
+  reordered in a canonical way.
+* Fixed a bug in normal()/numer_denom(): denominator was not made unit
+  normal if it was a simple number.
+* Improved the speed of subs() in some cases.
+
+1.1.1 (18 June 2003)
+* lst (and exprseq) provide iterators for read-only element access. For
+  sequential access this is one order faster than using op().
+* Implemented relational::subs() (this was done in 1.0.9 but inadvertently
+  omitted from the 1.1 branch).
+* pole_error and do_taylor are available to library users.
+* Added on-line help and Tab-completion for print(), iprint(), print_latex()
+  and print_csrc() in ginsh.
 
 1.1.0 (3 April 2003)
 * Removed deprecated macros is_ex_a, is_ex_exactly_a and friends for good.
@@ -185,8 +351,8 @@ This file records noteworthy changes.
 * Supplement some (now deprecated) macros by inlined template functions:
   - is_of_type(foo, type) -> is_a<type>(foo)
   - is_ex_of_type(foo, type) -> is_a<type>(foo)
-  - is_exaclty_of_type(foo, type) -> is_exaclty_a<type>(foo)
-  - is_ex_exaclty_of_type(foo, type) -> is_exaclty_a<type>(foo)
+  - is_exactly_of_type(foo, type) -> is_exactly_a<type>(foo)
+  - is_ex_exactly_of_type(foo, type) -> is_exactly_a<type>(foo)
   - ex_to_foobar(baz)  ->  ex_to<foobar>(baz)
 * rem(c, p[x], x) (c: numeric, p[x]: polynomial) erroneously returned p[x]
   instead of c.