Changes in release 2.3.0+latte-patches-2013-08-09:

 * Fix for name lookup rule changes (gcc 4.7.3)
   (patch from Dimitrii Pasechnik).

Changes in release 2.3.0+latte-patches (2011):

 * Fix for "precondition_error" (gcc 4.3)

Changes in release 2.3.0:
 * several resource leak fixes provided by Martin Ettl
 * added a number of declarations that used to exist as friend decalrations only
 * properly initialize members of galois_field_rep (reported by Grant Atoyan)
 * fix input of bigfloats with leading zeros

Changes in release 2.2.1-pre1:
 * Refer to post by Grant Atoyan (2007-04-07)

Changes in release 2.2.0:
 
 * bigint input operator does no longer set failbit if it encounters EOF at
   the end of a number
 * fixed operator/(T a, bigrational const& b) for T != bigrational and a == 0.
 * fixed elliptic_curve<gf_element>::isomorphism_type(bigint&,
                                                      bigint&,
                                                      point< gf_element >&,
                                                      point< gf_element >&,
                                                      bool)
 * fixed HNF documentation.
 * fixed friend class declaration for param_desc.
 * Several bugfixes and cleanups in the MPQS and Lanczos code of
   single_factor<bigint>. (If the changes prove to be stable then
   rational_factorization will delegate all MPQS calls to
   single_factor<bigint> in further LiDIA releases.)
 * fixed build files for use with autoconf 2.59 / automake 1.9.6.
 * avoid fragile test of \pdfoutput in doc/{color.graphics}.cfg and use
   typearea.sty rather than geometry.sty due to a broken geometry.sty shipped
   with SuSE 10.0's teTeX 3.0.
 * fixed rational_factorization::compose() to prune really all factors with
   exponent 0.
 * many further small fixes...


Changes in release 2.1.3:

This is a bugfix release only. It fixes an off-by-one error
in src/linear_algebra/crt_and_prime_handling.cc that could cause your
applications to crash.


Changes in release 2.1.2:

This is a bugfix release only. It resolves two issues:
 * Depending on the arithmetic kernel chosen with the configure parameter
   `--with-arithmetic' and the status flags of the input stream,
   operator>>(istream&, bigint&) could fail to correctly parse the number 0.

   The code for bigint-I/O will eventually be simplified and thus be made more
   robust. But since the 2.1.x release series is reserved for bugfixes only,
   such changes will only appear in a future 2.2 release.

 * The member function isomorphism_type() in class 
   elliptic_curve< gf_element > produced inreliable results. Many thanks to
   Volker Mueller for providing a bugfix!



Changes in release 2.1.1:

This is a bugfix release only. It corrects a bug in the new prime_proof code
that breaks LiDIA on some platforms due to a missing #include statement. It
also works around a problem with g++ 2.95.2 that's caused by this compiler's
non standard conformant handling of the ::std namespace.



Changes in release 2.1

This release consolidates the patches (mostly bugfixes) that accumulated since
LiDIA 2.1pre7. The only modifications to existing interfaces were in:
 * LiDIA/rational_factorization.h: 
     bool qs_build_factors(const bigint & N, bigint & kN,	
                           unsigned int index, int *FB);
   became
     bool qs_build_factors(const bigint & N, const bigint & kN,
                           unsigned int index, int *FB);

 * LiDIA/base/sf_bigint.h:
     bool qs_build_factors(factorization< bigint > &, const bigint &, 
                           bigint &, int *FB);
   became
     bool qs_build_factors(factorization< bigint > &, const bigint &,
                           const bigint &, int *FB);

New interface:
 * There's a new class isstream that wraps either std::istringstream or - if
   the former is not available on the target platform - the deprecated
   std::istrstream. It's there mostly for internal use, but it may serve you
   as well. Refer to LiDIA/isstream.h for more info.

 * There's a new class prime_proof in the GEC package, submitted by Jochen
   Hechler. Please refer to the manual for any details. 

Other changes:
 * Only static libraries are built by default. Configure with
   "--enabled-shared" if you need shared objects.

 * configure does not require you to specify --prefix any more.

 * operator<<(ostream&, bigint const&) and operator>>(istream&, bigint&)
   support the format flags std::ios::hex, std::ios::dec, and std::ios::oct as
   well as std::ios::showpos.

 * Many, many bugfixes.

Please refer to the release notes
(http://www.informatik.tu-darmstadt.de/TI/LiDIA/RELEASE-2.1) for an exhaustive
list of changes.


Changes in release 2.1pre7

*** Bug fixes:

**  Fixed a bug in the implementation of 
    divide(udigit&, udigit, udigit, udigit) in gmp/udigit_interface.h
    and cln/udigit_interface.h that caused stack corruption on Alpha
    machines.

**  Fixed missing object identifiers in
    operator/=(field_polynomial<T>&, ...) 

**  All necessary template instantiations are generated again, even
    if compiled with gcc 2.95.2.

**  Fixed a configuration bug in osstream.h


*** Technical changes:

**  LiDIA can now be built with STLport. (The fact that LiDIA is
    compiled without implicit template instantiation made this fail
    with previous releases.)




Changes in release 2.1pre6

*** Added functionality:

**  Added GEC package for generating cryptographically strong elliptic
    curves. Note that this package comes with additional 18MB of data
    files.

**  Plus additional 12MB of ECO data files (used by GEC)

**  LiDIA offers rudimentary support for error handling by
    throwing exceptions. This feature can be switched on or off when
    configuring the library.

*** Technical changes:

**  LiDIA can now be built in both shared and static library variants
    by means of GNU Libtool.  Unfortunately, this requires significantly
    more harddisk space than earlier releases.  See README for details.

**  Developer goodies (due to Automake): Support for VPATH builds,
    automatic dependency tracking, "make tags", and other useful targets

*** Bug fixes:

**  Manual can be generated in PDF again

**  Redundant `extern "C"' block removed that caused compiler errors
    in gmp.h when building LiDIA with GMP arithmetic.

**  bigmod::operator - (const bigmod &) fixed

**  Timer class now consistently uses millisecond units

**  Missing special case in HNF computation added.

**  Many changes to make the code conform to the C++ standard, in
    particular with respect to templates as well as friend declarations.

**  Many more...



Changes in release 2.1pre5

*** improved template instantiation:

**  template instantiation with user defined types requires merely the
    inclusion of the appropriate source file from include/LiDIA/instantiate

*** Bug fixes:

**  the installation process doesn't use cp -R to recursively install
    directory trees

**  the configure script has been fixed to properly detect some POSIX
    features

**  severe bug in class bigfloat fixed

**  severe bug in class group computation code fixed

**  other bug fixes




Changes in release 2.1pre4

*** longlong.h is not longer supported for GNU MP and CLN.  Instead, the
    low-level interface of GNU MP is used (in order to use CLN, it must be
    built on top of GNU MP).  Thus LiDIA can be built out of the box,
    without copying any unsupported header files.  Moreover, all problems
    regarding longlong.h have disappeared.

*** several bug fixes

*** some minor improvements




Changes in release 2.1pre3

*** LiDIA has got its own name space "LiDIA".  This is enabled by default.
    To disable, configure with option --disable-namespaces (we strongly
    discourage doing this).

*** LiDIA can be compiled with GCC-3.0.  Almost all deprecated C++ features
    have been removed/replaced.

*** All templates classes that are used internally are truly instantiated
    explicitely.  The section for template instantiation in the manual has
    been rewritten.

*** The class interfaces of some simple classes (bigint, bigfloat, bigmod,
    etc.) have been improved.  Confer the manual.

*** Almost all examples can be built, now.

*** Several bug fixes




Changes in release 2.1pre2

*** The EC point counting package has been integrated into LiDIA.  This
    package contains the Schoof-Elkies-Atkin (SEA) algorithm for counting
    the rational points of elliptic curves over GF(p) and GF(2^n).

*** minor bug fixes




Changes in release 2.1pre1

*** The EC point counting package is free for non-commercial use now.
    See COPYING.  The package will be incorporated into the LiDIA tree.


*** LiDIA can be configured by `configure'.  See the README for configure
    options.  Installation capabilities for MS Windows will be
    provided with the next pre-release.


*** Previous releases of LiDIA contained the multi-precision arithmetic as
    an integral part of the LiDIA library.  This has changed:

    BEGINNING WITH THIS RELEASE, THE MULTI-PRECISION ARITHMETIC IS NEITHER
    SHIPPED WITH LiDIA, NOR WILL IT BE ENROLLED INTO THE LiDIA LIBRAY.

    That is, a suitable multi-precision arithmetic library must be installed
    on your system, BEFORE you configure LiDIA.  Suitable libraries are

    - GNU MP, available from http://www.swox.com/gmp/ or http://www.gnu.org/
    - cln, available from http://clisp.cons.org/~haible/packages-cln.html
    - piologie, available from HiPiLib, see
    - http://www.hipilib.de/piologie.htm libI, available from
    - http://www.informatik.tu-darmstadt.de/TI/LiDIA/

    freelip (as it is not available as a real library) is not longer
    supported.

    In order to build an executable that uses LiDIA, you must link the
    multi-precision library to your executable.  That is, a link statement
    must look like

	g++ <your objs> -o <your executable> -L/usr/local -lLiDIA -lgmp
    

*** In order to compile LiDIA, your C++ compiler MUST support some ISO C++
    features.  These are:

    - type bool
    - inlining
    - mutable class members
    - explicit constructors
    - C++ style casts (i.e. static_cast<...> and const_cast<...>)
    - explicit template instantiation by ISO C++
    - template specialization by ISO C++ (template <>)
    - ISO C++ headers, such as <iostream>, <fstream>, <string>, but also
      <cstdlib>, <cstdio>, etc. 

    Moreover, LiDIA makes use of some basic classes from the C++ standard
    library, such as fstream, string.

    If your compiler fails to support one of the above items, you should
    upgrade.  Sorry for inconvenience, but thats what a standard is for.

    However, LiDIA still doesn't make use of exceptions and run-time type
    information.


*** The former bigint member functions `and', `or', `xor', and `not' have
    been renamed to `bitwise_and', `bitwise_or', `bitwise_xor', and
    `bitwise_not' to avoid conflicts with the corresponding ISO C++ key
    words.


*** Calls to the multi-precision arithmetic are now inlined by default.


*** The LiDIA manual has been improved in terms of layout and consistency.
    Only DVI and PostScript is currently supported, HTML is currently not
    supported.  Beginning with this releasem, Unix manual pages are not
    supported.


*** Bugfixes and improvements, especially in the EC package.
