Prepare for next release 1.8.8.

SONAME change because the parser's reader_func has changed.

[BUGFIX] calchhash(): work around broken RTTI on MacOS.

Use workaround from 0256e2fe48a0 also if __APPLE__ is defined.

[BUGFIX] Fix crash in parser.

Relying on aligned functions is non-portable.

Reported by Diego Conti <diego.conti@unipi.it>.

[DOC] Fix some TeXinfo warnings.

Happy New Year!

Avoid internal use of designated initializer...

...which is a C++20 feature. This fixes MSVC build.

Reported by Igor Machado <igor.machado@gmail.com>.

Finalize 1.8.7 release.

Update NEWS.

Add evaluation of Order(x)^e -> Order(x^e) for positive integer e.

Fix series of positive powers of polynomials.

Before calling pseries::power_const(), make sure the basis series has
sufficient terms. In particular, do not shrink the order of expansion
- only grow it.

Fix various hairy problems in pseries::power_const() when a polynomial
is raised to a positive integer power.

(The special cases here can actually also be computed by Taylor
expansion but the fixes should be more general.)

Also add test cases.

Thanks to Vitaly Magerya <vmagerya@gmail.com> for reporting this.

[PATCH] Make ginsh evaluate line-by-line in non-interactive mode.

When used interactively ginsh consumes the input line-by-line, so
if a complete expression is entered it is enough to end the line
to get an evaluated result. In the non-interative mode (i.e. if
the input is not a tty) the input is consumed in blocks, making
it impossible to use ginsh as a subprocess.

This patch makes the non-interactive mode reuse the same line
parsing logic as the interactive mode (without readline), but skips
printing the "> " prompt, preserving the backward compatibility.

Fix GiNaC's internal parsing of expressions.

...with explicit signs in multiplications and in exponents. Also fix
nested exponentiation. Add exams compatible with ginsh's parsing.

[PATCH] Resolve ambiguous overload.

It confuses MinGW compiler on Windows from Qt suit.

Signed-off-by: Vladimir V. Kisil <V.Kisilv@leeds.ac.uk>

[DOC] Fix a typo.

[DOC] Fix build of reference.pdf.

This is obnoxious: It is 2023, the ≥ character is in Unicode since
1993, and UTF-8 is ubiquitous. Yet, pdfLaTeX balks at this.

Maybe the right fix would be to switch to LuaLaTeX. Alas, that doesn't
seem to have reached the necessary maturity yet:
<https://tug.org/pipermail/luatex/2023-February/007799.html>

[DOC] Fix some Doxygen references.

Revert "Work around Tex Live 2012 versus doxygen problem."

The bug seems to have disappeared many years ago, at least since
Debian 9 Stretch (ca. 2017).

This reverts commit af3801eb5e40bb3717bf207470252172a0af2559.

[build] Fix a typo in configure.ac.

Finalize 1.8.6 release.

Fix numeric binomial(n, k) for integer n<0 and k≤n...

...by instead returning binomial(n, n-k).

Suggested by Marko Riedel <riedelmo@mathematik.uni-stuttgart.de>.

[PATCH] Fix wrong numeric info on transcendental functions.

Although expression like cos(numeric(1, 2)) is not a symbolic, it
neither is numeric in the sense of CLN library. Without this patch
GiNaC crashes on expressions like cos(cos(ex(1)/ex(2))).

Thanks to Weng Zhanyang <cosine@pcbcos.xyz> for reporting this.

Finalize 1.8.5 release.

Happy New Year!

Minor refactoring in factor.cpp.

- Substitute the misnamed expt_pos(a,q) with the more specialized
  expt_pos_Q(w,a,q,r) function, for use by distinct_degree_factor().
- Rework canonicalize function and change semantics of its hint
  argument to be more natural.
- Use the hint argument of canonicalize() in rem().
- Add some documenting comments.

Some more minor optimizations in factor.cpp.

This isn't changing much, but once I've seen a missed opportunity, it
keeps catching the eye and then it's hard to resist.  :-)

Fix internal next_prime(n) function.

This helper function was doing wild things when called the wrong way.
E.g. it would allocate obscene amounts of memory and run for ages when
called with an argument that has never been returned by it before.

In the context where it's being used so far this is not a problem. But
it's better to make it foolproof and spare a new user some possible
despair and distress.

Prefer CLN left shift operations over multiplications in factor().

Change some internal lst to exvector in factor.cpp...

...in places where c[i] is more readable than c.op(i) or the insidious
c.let_op(i) notation.

[BUGFIX] Fix corner cases of factor_multivariate().

In some rare cases, factor() failed with what looks like an endless
loop trying evaluation homomorphisms with ever increasing moduli (or
maybe it just took eons to complete).

Whether this happened depended on which symbol was left unevaluated
for univariate factorization. As a workaround for this problem, we now
apply the evaluation homomorphism for each symbol in a round-robin
mode until one of them succeeds.

This somewhat speeds up factorization of multivariate polynomials
even in those cases where the old implementation terminated in time.

Thanks to Vitaly Magerya <vmagerya@gmail.com> for reporting this.

Refactor internal calc_bound() routines.

Reduce them to computation of absolute values of the polynomial's roots
and document that this is known as Landau's inequality. The multiplication
with a power of two is done by the caller.

Also remove the internal fallback computation using the maxcoeff since
this cannot happen. (In the worst case, there is only one non-zero
coefficient 'a'. Then we compute sqrt(a^2) which is not smaller than a.
Otherwise, we compute sqrt(a^2 + x) > a.)

Remove own definition of enable_if<B, T> in favor of...

...the definition provided by <type_traits> since C++11.

[DEBUG] Make some debug output operators compile in factor.cpp...

...for the case when somebody actually #defines DEBUGFACTOR. The operators
must be in the same anonymous namespace in which umodpoly, upoly and upvec
are typedef'ed. (I'm not really sure I understand why but that's what GCC
and CLang are convinced of.)

Optimize some use of CLN's expt_pos() function in factor().

(Not that it's slow or mattered much, but why waste cycles?)

Really finalize 1.8.4 release.

Fix SONAME screw-up in last commit.

Finalize 1.8.4 release.

Also update helper scripts from savannah.gnu.org.

Fix -Wsign-compare warnings in new code.

Fix checks for sqrfree_parfrac().

Make sqrfree_parfrac() work in the general case and make it supported.

[PATCH] Implement info methods for transcendent functions.

Here only easy answers are sought, which can be decided on
info tests of the functions arguments. From such coarse viepoint
functions are grouped into several classes and the respective
routines can be shared.

[C++17] Convert std::mem_fun_ref_t to std::mem_fn...

...because it has been deprecated in C++11.

[C++17] Don't inherit from std::iterator...

...because this has been deprecated. See LWG2438.

[TESTS] Fix node::operator< in time_antipode.cpp.

Reported by Yuri Gribov <tetra2005@gmail.com>.

Finalize 1.8.3 release.

Fix power::subs() in some special cases.

In some cases, after subs'ing in basis and exponent, an extra
substitution was performed. This could lead to messed-up final results
because, e.g. substituting x==1/x in 1/x evaluated to x, but then
another substitution x==1/x was performed.

Reported by Feng Feng <f.feng@outlook.com>.

Work around a compiler bug on MSVC.

The two 'reg_info' declarations introduced in f271f67d2f turned out
to confuse MSVC: It thinks that these declarations are definitions
and then complains about a missing default ctor (error C2512) and
about duplicate definitions later in the .cpp files (error C2766).

But the standard says in [temp.expl.spec] §13:
An explicit specialization of a static data member of a template or
an explicit specialization of a static  data member template is a
definition if the declaration includes an initializer; otherwise, it
is a declaration. [Note: The definition of a static data member of a
template that requires default-initialization must use a braced-init-
list:
    template<> X Q<int>::x;     // declaration
    template<> X Q<int>::x ();  // error: declares a function
    template<> X Q<int>::x { }; // definition
--end note]
There is no initializer at lst.h:35 and at exprseq.h:35. Hence, this
is merely a declaration and the compiler's error message is wrong.
Let's work around by #ifndef'ing the two lines for silly MSVC.

Fix some compiler warnings.

[DOC] Add "series_to_poly" to ginsh man page.

[DOC] Fix g++ argument order in tutorial example.

[DOC] Replace obsolete @inforef with @xref command.

[DOC] Fix typo in series_to_poly() documentation.

Add "series_to_poly" to ginsh.

exam_inifcns_nstdsums.cpp: prec set to 10*pow(10,-Digits) in inifcns_test_HLi to avoid sporadic make check failure.

Fix power::to_polynomial() for posint exponents.

This makes things like pow(x+1/x,2).to_polynomial(repl) actually
produce (x+sym)^2 with sym==1/x in repl, as it should.

Reported by Feng Feng <f.feng@outlook.com>.

Finalize 1.8.2 release.

Oh, and Happy New Year!

Fix relational::compare_same_type.

A hash collision was needed to elicit this bug because basic::compare
returns early without calling compare_same_type if hashes differ.

Reported by Feng Feng <f.feng@outlook.com>.

Update and clean up autoconf template files.

This is needed for compatibility with newer autoconf:
* Removed macro GINAC_STD_CXX_HEADERS (we use AX_CXX_COMPILE_STDCXX).
* Updated m4/* files from upstream.
* Ran autoupdate on acinclude.m4 and configure.ac.

Tested successfully with autoconf 1.69 and 1.71.

Minor bug fix for the class modular_form_kernel: Ensure that the series-method includes an order term.

Finalize 1.8.1 release.

Add method relational::canonical().

It returns an equivalent relation with the zero right-hand side.

[BUGFIX] Fix a bug in normal() method.

Any function was confused with an exponent of the same argument
during a normalisation of an expression.

Example: normal(cos(x)/exp(x)) often returned 1 for realsymbol x.

Bug fix in modular_form_kernel::is_numeric and modular_form_kernel::Laurent_series: Call the correct method to compute the series expansion.

This bug has been reported by Christoph Dlapa.

Bug fix in the routine H_evalf (a minus sign should not be forgotten).

This bug was reported by Bin Zhou.

Add simple exam test for releational objects.

Smarter relational to Boolean conversion.

If a relational contains symbolic entries we look to ex::info
to decide whether it can be converted to true value.

[PATCH] Improve normalisation of negative exponents.

If an expression contains exponents with opposite signs,
then the respective symbolic substitutions need to be properly
attributed to numerator/denominator slots.

Add exam for ex::collect().

[PATCH] Make ex::operator[] const dispatch to basic::operator[] const.

It turned out that ex::operator[] const dispatched to non-const
basic::operator[] because
* member variable ex::bp is non-const and
* ptr<T>::operator*() returns a non-const T &.

As a result, indexing failed for multiply referenced objects.

Thanks to Vitaly Magerya <vmagerya@gmail.com> for reporting this.

G_do_hoelder: fix bug related to comparing a float with a rational number in CLN.

This bug has been reported by Simone Zoia.

Fix misleading comment in last commit.

Avoid "instantiation of variable 'reg_info' required..." warning.

With -Wundefined-var-template (on by default), CLang++ warns that
no definition for the static 'reg_info' member variable is available.

bugfix: function: always pass evalf'ed arguments to evalf_funcp

GiNaC passes unevaluted arguments to a function with evalf_funcp
taking an exvector. Fixed that, and added a test case

Avoid multiple definitions of `lst::info` (MinGW compile fix)

[55/59] Linking CXX shared library bin/libginac.dll
FAILED: bin/libginac.dll ginac/libginac.dll.a
[skipped long list of object files]
/usr/bin/x86_64-w64-mingw32-ld: ginac/CMakeFiles/ginac.dir/lst.cpp.obj: in function `GiNaC::ptr<GiNaC::basic>::~ptr()':
/home/asheplyakov/work/sw/ginac/_build_w64/../ginac/container.h:150: multiple definition of `GiNaC::container<std::__cxx11::list>::info(unsigned int) const'; ginac/CMakeFiles/ginac.dir/integration_kernel.cpp.obj:/home/asheplyakov/work/sw/ginac/_build_w64/../ginac/container.h:116: first defined here

integration_kernel.cpp makes use of GiNaC::lst without including the `lst.h`
header. That's possible since there's a typedef in `registrar.h` (included
by virtually all GiNaC sources) and a defintion in `container.h` (included
via `add.h` -> `expairseq.h` -> `indexed.h` -> `exprseq.h`), so the compiler
can instantiate container<std::list>. However the explicit specialization
of `lst::info` is not available (in integration_kernel.cpp). This violates
17.8.3.6 [templ.expl.spec] which demands

If a template, a member template or a member of a class template is
explicitly specialized then that specialization shall be declared before
the first use of that specialization that would cause an implicit
instantiation to take place, in every translation unit in which such
a use occurs; no diagnostic is required. If the program does not provide
a definition for an explicit specialization and either the specialization
is used ina way that would cause an implicit instantiation to take place
or the member is a virtual member function, the program is ill-formed,
no diagnostic required.

On ELF platforms libginac appears to link just fine despite having two
instantiations of `lst::info` since the of them (in `integration_kernel.o`)
is a weak symbol:

$ find ginac -type f -name '*.o' | xargs -n 1 nm --print-file-name --defined | c++filt | grep -e 'list>::info('
ginac/CMakeFiles/ginac.dir/integration_kernel.cpp.o:0000000000000000 W GiNaC::container<std::__cxx11::list>::info(unsigned int) const
ginac/CMakeFiles/ginac.dir/lst.cpp.o:0000000000000000 T GiNaC::container<std::__cxx11::list>::info(unsigned int) const

so the linker discards the wrong instantiation of `lst::info` method.
However on MinGW there are no weak symbols (in ELF sense):

$ find ginac -type f -name '*.obj' | xargs -n 1 x86_64-w64-mingw32-nm --print-file-name --defined | c++filt | grep -e 'list>::info('
ginac/CMakeFiles/ginac.dir/lst.cpp.obj:0000000000000010 T GiNaC::container<std::__cxx11::list>::info(unsigned int) const
ginac/CMakeFiles/ginac.dir/integration_kernel.cpp.obj:0000000000000000 T GiNaC::container<std::__cxx11::list>::info(unsigned int) const

Hence the above multiple definition error.

To avoid the problem #include "lst.h" (so explicit specialization is available).
While at it explicitly instantiate lst::info method in lst.cpp

A better solution would be to remove declaration of lst from registrar.h,
but that's too disruptive since GiNaC uses lst a lot: subs, unarchive, etc.

Fix minimum CLN version for pkg-config.

Happy New Year!

Update some references.

Avoid 'variable uninitialized when used within its own initialization' warning.

Initialize the static flyweight ex objects with the pointeed numeric
objects instead of using self-assignment. This is 100% equivalent to
before: The objects have already been initialized by the library_init
ctor so all the static object's ctor does is increment the pointeed
object's refcount.

According to the resolution of C++ core language defect 363 the warning is
incorrect because it is allowed to pass a reference to the object, see
<https://wg21.link/cwg363>. Incrementing the bp's refcount is okay too,
because the pointee numeric object has been fully initialized by the
library_init ctor. However, the compiler can hardly know this, so CLang++
issues a warning.

build: Fix CMake install for info file.

It seams like CMake does not know any variable named ${SHARE_INSTALL_PREFIX}.

Finalize 1.8.0 release.

Clarify types of test suite files.

Replaced dummy reference by correct reference.

Rename test suite files...

...to match any of the three types:
exam*   test result for specific input (like a pupil's exam)
check*  test coherence of results among each other, for random input
time*   measure run-time

All tests are still there, but maybe elsewhere:
* rename match_bug.cpp => exam_match.cpp
* rename heur_gcd_bug.cpp => exam_heur_gcd.cpp
* rename bugme_chinrem_gcd.cpp => exam_chinrem_gcd.cpp
* rename parser_bugs.cpp => exam_parser.cpp
* rename exam_cra.cpp => check_cra.cpp
* include numeric_archive.cpp => exam_archive.cpp
* include pgcd_infinite_loop.cpp => exam_pgcd.cpp
* include pgcd_relatively_prime_bug.cpp => exam_pgcd.cpp

These two have been deleted, since memory leaks are best looked for
using tools on real programs on a regular basis (they were also not
automatically executed):
* delete parser_memleak.cpp
* delete mul_eval_memleak.cpp

Reset GINAC_LT_AGE to bump SONAME.

Vladimir's last changes affected virtual functions and vtbl changes usually
require a new library version.

[PATCH 3/3] Stronger normalisation method for powers.

Now normalisation method try to express powers with the same base
as monomials of some dummy variables. This allows to make cancellations
of the sort:
(x-1)/(sqrt(x)-1)  ->  sqrt(x)+1

Signed-off-by: Vladimir V. Kisil <V.Kisilv@leeds.ac.uk>

[PATCH 2/3] Make a stronger normalisation for expressions with exponents.

If several exponents have arguments different by a rational number
factors they are replaced by monomials of the same variable.

Signed-off-by: Vladimir V. Kisil <V.Kisilv@leeds.ac.uk>

[PATCH 1/3] Automatic evaluation of (e^t)^s = e^(ts).

If it safe to evaluate (e^t)^s = e^(ts) at least in two cases:

a) t and s are reals, the respective formula can be found in
any analysis textbook.

b) if s is an integer, then the ambiguity of t up to the term 2*Pi*k
does not cause a different value.

Signed-off-by: Vladimir V. Kisil <kisilv@maths.leeds.ac.uk>

Update AUTHORS file more.

Set version, soname ahead of release.

Update AUTHORS file...

...to be more complete and remove authors' names from manpages in favor
of a reference to the web site.

Remove deprecated initialization via overloaded comma operator.

This feature has been marked as deprecated since 1.7.0. There's been more
than four years to switch to initializer lists. Let's hope people have
modified their code since.

Added new routines for the numerical evaluation of iterated integrals like
elliptic multiple polylogarithms or iterated integrals of modular forms.

Changes to be committed:
modified:   check/CMakeLists.txt
modified:   check/Makefile.am
new file:   check/exam_inifcns_elliptic.cpp
modified:   doc/tutorial/ginac.texi
modified:   ginac/CMakeLists.txt
modified:   ginac/Makefile.am
modified:   ginac/ginac.h
modified:   ginac/inifcns.h
new file:   ginac/inifcns_elliptic.cpp
new file:   ginac/integration_kernel.cpp
new file:   ginac/integration_kernel.h
new file:   ginac/utils_multi_iterator.h
modified:   ginsh/ginsh_parser.ypp

Remove executable file attribute from last Python script.

They are all invoked by ${PYTHON} and lack a shebang line since 8a4e28dc81.

build: use bundled CLN if available

So one can unpack CLN tarball (or clone CLN git repository) and compile
both CLN and GiNaC in one pass:

git clone git://ginac.de/ginac.git
cd ginac
git clone git://www.ginac.de/cln.git
mkdir build && cd build
cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo .. && make

Use "modern" CMake facilities to manage includes and libs

* Use target_link_libraries to specify dependencies (include paths,
  compiler options, etc)

* Export targets and provide `ginac-config.cmake` so the following
  `CMakeLists.txt` is enough to build a program using GiNaC:

    cmake_minimum_required(VERSION 3.1)
    project(foo)
    find_package(ginac REQUIRED)
    add_executable(foo foo.cpp)
    target_link_libraries(foo PRIVATE ginac::ginac)

* GiNaC can be included as a (CMake) subproject. One can put GiNaC
  sources (either from git or a tarball) into a subdirectory (say,
  `ginac`) and use the following CMakeLists.txt to build everything:

    cmake_minimum_required(VERSION 3.1)
    project(foo)
    add_subdirectory(ginac)
    add_executable(foo foo.cpp)
    target_link_libraries(foo PRIVATE ginac::ginac)

build: windows: enable automatic imports by default

For now there are no dllexport/dllimport markings in GiNaC and CLN, so
export all symbols when building GiNaC DLL, and enable automatic imports
when linking with it. Note: this works with GNU linker only.

build: CMake: made it easier to run tests in parallel

As of now `make -jN check` executes test suite sequentially
(although it builds test executables in parallel). This takes
a bit too long, so it would be nice to run tests in parallel.
`ctest -jN` or `make test ARGS=-jN` runs tests concurrently,
however it does not build test executables, instead it fails
if any test binary is missing.

Also `test` target is a bit special and it's impossible to add
dependencies to it, see
https://gitlab.kitware.com/cmake/cmake/issues/8438

To work around the problem define `test_suite` target which
builds the tests suite without running it, so one can both
compile and run tests in parallel

make -j8 test_suite
make test ARGS=-j8

Made it easier to run tests on windows

Put executables and DLLs into the `bin` subdirectory so the system
can locate GiNaC (and CLN) DLLs without extra configuration.

numeric.cpp, archive.cpp: don't include config.h

config.h is necessary for excompiler only, the rest of the library
is pretty portable. Not including dynamically generated headers
saves compilation time due to more (c)cache hits.

Build example programs to avoid breaking them on API changes

build: fixed `ginac-excompiler` installation with CMake

build: accept both python 3 and python 2

This makes building GiNaC a bit easier for users of "old" distributions
where python 3 is not installed by default (Ubuntu 16.04), or even not
available (CentOS 7).

Scripts themselves work just fine with python 2.7 and python 3.x, so
only minor changes to CMakeLists.txt are required (autotools scripts
already handle python2/3)