Fixed lots of bugs in factor_multivariate().

factor_univariate() takes now the content of the polynomial into accout when
choosing a prime. It also returns the chosen prime. This supports the
factor_multivariate() code.

Polynomials are expanded before calling factor_sqrfree(). This avoids problems
with some input polynomials.

Added static qualifiers to all hidden functions.

Fixed a bug in squarefree(). Some polynomials were erroneously classified as
square free (e.g. x^prime+1).

Fixed a bug in multivar_diophant() causing  sporadically an infinite loop.

Improved lifting bound code.

Univariate lifting can now use a cache for the modular factors. At the moment,
this gives no measurable speed gain.

Added modular square free factorization.
Completed distinct degree factorization.
Univariate polynomial factorization uses now upoly.
Merged class Partition and function split into class factor_partition.

Stupid error: did the revert on the wrong branch (master instead of ginac_1-4).

Revert "Revert "[portability] GiNaC::compile_ex works on OpenBSD now.""

This reverts commit a6854a8a0f1e5db722320f5d7ccb9097053500cf.

Revert "[portability] GiNaC::compile_ex works on OpenBSD now."

This reverts commit 375a7aa1f13fa6061c278eb2c2447fd91521b45d.

Univariate Hensel lifting now uses upoly.
Changed q_matrix code.

Equip ginac-examples.texi with directory entry for info.

[portability] GiNaC::compile_ex works on OpenBSD now.

* acinclude.m4: check for dlopen() in libdl and in libc itself.

Thanks to Paul Irofti for a bug report and a suggestion.

[build] Set correct rpath for linking with CLN...

... so users won't get 'error while loading shared libraries: no such file
or directory'. Also embed rpath into pkg-config meta data, so

g++ `pkg-config --cflags --libs ginac` foo.cc

actually works without any additional effort from the user side.

[bugfix] integer_cra: check if arguments contain at least 2 moduli

While at it, also fix exam_cra so it does not produce pointless inputs.

exam_cra: explicitly #include <limits>. This should make g++ 4.3 happy.

Changed debugging facilities in factor.cpp.

Fixed some minor spelling errors.

Changed code from using cl_UP_MI to using umodpoly. The cl_UP_MI interface was
inconvenient to use and caused several very difficult bugs (some were still
unresolved before changing to umodpoly!).

Fixed severe bug in multivariate factorization. The condition that all modular
factors should be relatively prime in the base ring was violated. This caused
the factorization sometimes to go into an infinite loop.

Added code for distinct degree factorization.

tutorial: simplify the instructions on writing extension classes.

Don't mention (un)archiving while describing the `mystring' class
(the minimalistic extension class), so readers have less chances to get
confused.

Don't force every algebraic class to implement archiving/unarchiving.

So people who don't use (un)archiving don't need to bother with it.

tutorial: don't mention custom RTTI any more (as it does not exist).

symbol: make get_domain() a virtual method, remove symbol::domain.

This cuts yet another 4 bytes from GiNaC::symbol. While at it, fix a memory
leak in ginsh.

symbol: don't bother to set TeX name if user did not specified one.

Same for the usual name. As a result we use less memory (and the output
is exactly the same).

symbol: remove return_type_tinfo() and return_type() (shrink symbol by 8 bytes)

Bloating symbol to the state sizeof(symbol) == 64 is not appreciated at all.
If someone needs/wants non-commutative symbols or other fancy stuff, please
derive from class symbol and do whatever you want.

Wipe out remnants of custom RTTI.

Custom RTTI considered harmful, final part.

registered_class_info: use typeid() instead of tinfo_static.

(Custom RTTI considered harmful, part 5).

Since custom RTTI is going to be removed, registered_class_info needs to be
re-organazied. Now tinfo_key is a (const) pointer to std::type_info.

A better return_type_tinfo() mechanism.

return_type_tinfo() is used in order to distingish between non-commutative
objects of different type. However, often it's necessary to distingish
between non-commutative objects of the same type, for example, between
gamma matrices with different representation label. return_type_tinfo()
does not provide any clean way to do that. Hence, introduce return_type_t
type which holds representation label along with type information, and
use it for return_type_tinfo().

calchash(): use type_info::name() instead of tinfo().

Custom RTTI considered harmful, part 4.

The hash value of the object of different types should be different whenever
possible. Hence calcash() needs a unique per type number. Previously we used
tinfo_key for this. typeinfo::name() (a *pointer* to implementation dependent
string) is also unique for each class, so it's just as good as tinfo() is.

indexed::eval: use standard C++ RTTI.

Custom RTTI considered harmful, part 3.

basic, expairseq: use standard C++ RTTI in compare(), is_equal(), match(), etc.

Custom RTTI considered harmful, part 2.

* basic.cpp: use standard C++ RTTI in compare(), is_equal(), operator=(),
  match().
* expairseq.cpp: use standard C++ RTTI in match(), make_flat(),
  construct_from_2_ex().

is_exactly_a: use typeid() to check the type of expression.

Custom RTTI considered harmful, part 1.

Custom run time type information (RTTI) system implemented in GiNaC have
several serious drawbacks, such as

1. It makes writing GiNaC classes unnecessary cumbersome.
2. It wastes sizeof(void *) bytes per object, for small objects like
   symbol, numeric, etc. this overhead is considerable.

It turns out that GiNaC's RTTI is not any faster than the standard one
(at least on GNU/Linux and Solaris with GNU C++ library and compiler).
So, GiNaC RTTI have no reasons to exit any more.

ptr.h: use unsigned int to store reference counts (in order to save memory).

We'll hardly ever get more than 2^32 references to the same object. So using
size_t to store reference count only wastes 4 bytes per object (on 64-bit
architecture). Use unsigned int instead.

Rewritten heuristic and PRS GCD for univariate polynomials, added benchmark.

Using a better data structure for univariate polynomials makes GCD 10 -- 300
times faster (and less memory hungry).

polynomial: introduce a helper function to divide polynomial by ring element.

mod_gcd: naive hack to chose a 'good' prime (to speed up gcd computation).

[bugfix] remainder_in_ring: using exact division is plain wrong.

[bugfix] normalize_in_ring: don't set the leading coefficient to 1.

The coefficient ring is not a field, so the leading coefficient don't
have to be 1.

[trivial] excompiler.cpp: shut up some silly compiler warnings.

GCC warns about 'comparison between signed and unsigned integer expressions'.
In this case such comparison is harmless, but still it's a bit annoying.

Merge branch 'master' of git://ffmssmsc.jinr.ru:443/varg/ginac

Replaced class UniPoly by cl_UP_MI.

- Added options argument to factor(). Added flag factor_options::all that lets
  factor() act on all polynomial subexpressions.
- Added more comments.

Implemented modular GCD algorithm for univariate polynomials.

Wipe out the old (bison/flex generated) parser.

Bison generated parser has a number of problems:

1. Bad performance. Parsing a sum seems to be O(N^{2 + a}) (a > 0).
   For example, parsing a sum (actually, a univariate polynomial) of 32768
   terms takes about 90 sec. on my box, parsing a sum of 10^6 terms takes
   "eternity".
2. The user is expected to provide list of all symbols in the expression.
   Often this is very annoying (and useless), sometimes it is not possible
   at all.
3. Parser is not reentrant (bison *can* produce reentrant parsers, but that
   won't solve other problems).
4. Parser is difficult to extend.

Since the new parser handles almost everything (useful) as the old one, let's
remove the latter.

check: time_parser.cpp: don't run the same benchmark twice.

Since ex(const string&, lst&) ctor uses the new parser now comparing its
performance (and result) with one of direct invocation of the parser is
pointless.

Document the new parser, provide an example.

Use the new parser in the ex(const string&, lst&) ctor.

Note: this is certainly not the optimal way to use the parser. It's provided
for backward compatibility only.

Parser can parse (some) floating point numbers now.

parser: add necessary checks to operator() to stop accepting nonsense.

Since the parser is recursive parse_* methods (in particular,
parse_binop_rhs()) does NOT check if the last unparsed token is valid.
Thus parse_expression() stops if it encounters an unknown token. That's
why parser::operator() needs to make sure nothing is left in the input
stream.

[bugfix] parser::parse_literal_expr(): don't forget to consume the token...

... so parser won't process it twice (and get either spurious error or
wrong result).

[bugfix]: parser::parse_unary_expr() parses '-a-b' correctly now.

Also added regression test.

ginac.h: include parser.hpp

parser: change order of the constructor optional arguments.

Functions/methods having multiple optional arguments are not very convenient
to use in C++ (to put it mildly). Shuffle parser ctor arguments so not so
frequently used argument is the last one.

parser: allow read/write access to symbol table and strictness.

Intended usage:

parser reader;
ifstream input_file1, input_file2;
// read the first file...
ex e1 = reader(input_file1);
// ... add extra entry into the symbol table used by parser
symbol x;
parser.get_syms()["x"] = x;
// Disable the parser to introduce new symbols, e.g. to ensure the expression
// in input_file2 contains the same symbols as e1 (read from input_file1).
parser.strict = true;
ex e2;
try {
e2 = reader(input_file2);
} catch (...) {
abort();
}

parser: map input strings onto arbitrary expressions (not only symbols).

So it's possible to make abbreviations, e.g.

symbol x;
symtab table;
table["x"] = x + log(x) + 1;
parser reader(table);
ex e = reader("1 + x^2 + 5*x^3");

[BUGFIX] parser.hpp: fix include guard so the header is actually usable.

[nitpick] power::expand_add(): don't use int instead of std::size_t.

This shuts a few 'comparison between signed and unsigned integer expressions'
warnings.

[nitpick] inifcns_nstdsums: don't use int instead of std::size_t.

This shuts up quite a number of 'comparison between signed and unsigned
integer expressions'  warnings.

[nitpick] don't use int instead of std::size_t.

This shuts up (some of) 'comparison between signed and unsigned integer
expressions'  warnings.

G_numeric: use cl_N and int to manipulate numbers (instead of ex).

Convert helper functions G_do_hoelder and G_do_trafo in the same manner,
update all call sites. This should speed up numerical calculation of
multiple polylogarithms a little bit, and reduce the memory usage.

G_numeric: put convergence/acceleration transofrmations into helper functions.

This is simple code move, everything else should be considered a bug.
The helper functions (as well as G_numeric itself) will be improved by
subsequent patches.

match() (find()): use exmap (exset) to store matched subexpressions.

There's no need to re-invent associative arrays and wrap them into
a GiNaC class.

expairseq::match(): remove the code which works around basic::match bug.

basic::match() used to have side effects in a case of a failed match. As
a result of that bug exparsed::match did not work correctly in some cases,
see [1] for more details. These false negatives were worked around by [2].
Now that match() has no unwanted side effects [3] we don't need any work
arounds any more.

Just in a case add a regression test (from [1]).

[1] http://www.ginac.de/pipermail/ginac-devel/2006-April/000942.html
[2] Commit 73f0ce4cf8d91f073f35a45443f5fbe886921c5c ("Fixed bugs in ::match").
[3] Commit 192ed7390b7b2b705ad100e3db0a92eedd2b20ad ("match: don't modify
    subexpression list if expression doesn't match the pattern.").

Fixed various bugs in multivariate factorization.

Merge branch 'master' of git://ffmssmsc.jinr.ru:443/varg/ginac

Bug fix related to the usage of int instead of cl_I.

Updated NEWS.

build: shut up automake warnings, don't use GNU make extensions.

Not that I really care about non-GNU makes, but those warnings are a bit
annoying and can hide useful ones.

build: put (almost) all auto* tools scripts into the config directory.

So I can just rm -rf it to clean up the repository.

Allow user to disable GiNaC::compile_ex (e.g. for security reasons).

configure takes --{disable,enable}-excompiler argument now. It can be
used to disable GiNaC::compile_ex (default is to enable it).

acinclude.m4:
GINAC_EXCOMPILER: new macro. Checks for libdl, allows user to disable
GiNaC::compile_ex. Also it doesn't bother to check for libdl on MinGW.

configure.ac: use GINAC_EXCOMPILER to check for libdl.

configure: run important checks first (and bail out if something is missing).

Don't bother to check for optional stuff if CLN and/or standard C++ headers
are missing.

configure: don't bother to run checks which can be done at the compile time.

Don't check for sizeof of various types, this can be done at the compile time.
GCC optimizes away these checks, so the actual code is the same.

utils.h: use <stdint.h> (if available) instead of reinventing it.

The argument of golden_ratio_hash() is as an integer of the same size as
a void* pointer. Unfortunately ISO C++ 98 does not provide suitable typedef.
Hence

* use <stdint.h> if available and define p_int to uintptr_t. Note: AC_PROG_CC
  already checks for this header, so no extra checks are necessary.
* as a fallback define p_int to be unsigned long, this works on most systems
  I know of (the only exception is woe64).

While at it, stop including "config.h" unconditionally.

configure: don't check for sizeof(long double), we don't use it.

build: faster check for standard C++ headers.

Include them all into a test program and check if it compiles (in order to reduce
the run time of the `configure' script).

build: don't run any ${host} binaries while checking for readline.

Now GiNaC (to be more precise, ginsh) can be easily cross compiled.
However, ancient versions of readline (<= 4.2) are not supported any more.

don't mention CVS any more, describe how to install from git.

match: don't modify subexpression list if expression doesn't match the pattern.

As of now the match() method modifies the list of matched subexpressions
(its second argument) even if the expression in question does not match
the pattern. Thus, this simple program

 #include <ginac/ginac.h>
 #include <iostream>
using namespace GiNaC;

int main(int argc, char** argv)
{
symbol x;
ex e = pow(x, 5);
ex pattern = pow(wild(), -1);
lst repl;
bool test = e.match(pattern, repl);
std::cout << "repl = " << repl << std::endl;
}

prints

repl = {x}

Such behaviour is a bit unexpected. Sometimes it confuses even GiNaC
developers, see e.g.
http://www.ginac.de/pipermail/ginac-devel/2006-April/000942.html

Hence this patch. Now the above program prints

repl = {}

as expected.

[BUGFIX] Reclaiming the memory allocated for static objects *is* necessary.

GiNaC allocates memory for static objects (i.e. flyweights, remember tables,
etc), but doesn't free it. This is OK if the program lifetime matches libginac
lifetime, since the OS will reclaim that memory anyway.
However, if the program lifetime is different from that of libginac, this
turns into a memory leak. This happens if someone dlopen's libginac.so, and
dlclose's it later on (read: if someone uses GiNaC via scripting language
bindings).

symbol::autoname_prefix(): there's no need for dynamical memory allocation.
remember_table::remember_tables(): likewise.
function::registered_functions(): likewise.
lib_init::~lib_init(): if library usage count drops to 0, reclaim the memory
                       allocated for flyweights.

symbol: get rid of assign/unassign (for performance and other reasons).

* symbol::eval() is trivial now, so compiler can inline it in some cases.
* symbol takes less memory.
* no functionality is lost (as C++ has associative arrays).

ginsh: use exmap for storing assigned symbols.

C++ already have associative arrays, there's no need to re-invent them.

multiple zeta values: make crandall_Y_loop helper function reentrant.

* Move crB and crG variables into initcX function (the only user of these
  variables).
* Pass crX coefficients to crandall_Y_loop instead of using a global variable.
* While at it make crandall_Y_loop and initcX functions static.

multiple zeta values: make crandall_Z helper function reentrant.

Pass the f_kj coefficients as an arguments to crandall_Z and calc_f
functions instead of using global variables.

parser: improve error reporting a little bit.

Introduce class 'parse_error' (which contain some info about location of
the error) and throw it on parse errors.

N.B.: the actual info is a bit inaccurate because lexer doesn't track
the location properly yet.

lexer: when switching to another output stream, clean last read character.

Otherwise we prepend to the current stream the last character read from
the previous stream, which is obviously incorrect.

Fixed bug in unvariate factorization. Bound for lifting was using a ordinary
int instead of a cl_I.

Added missing code for multivariate factorization.

Fixed bug. G() ignored the imaginary parts of the arguments.

Added internal code for multivariate factorization.

gcd_pf_pow_pow: deobfuscate a little bit (no functional changes).

Use

if (foo)
return bar();
return baz();

instead of

if (foo) {
return bar();
} else {
return baz();
}

This makes the code a little bit more readable.

gcd_pf_pow: get rid of duplicate code.

This function (which helps gcd() handle partially factored expressions)
contained two copies of the same code. Remove one redundant copy.

introduce gcd_pf_pow_pow: gcd helper to handle partially factored expressions.

gcd_pf_pow_pow handles the case when both arguments of gcd() are powers.

N.B. the actual code moved from gcd_pf_pow, no functional changes.

gcd_pf_{pow, mul}: don't check if the arguments are polynomials.

These functions gets called only from gcd(), which does this check
on its own.

gcd_pf_mul: get rid of duplicate code.

This function (which helps gcd() handle partially factored expressions)
contained two copies of the same code. Remove one redundant copy.

gcd(): allow user to override (some of) heuristics.

GiNaC tries to avoid expanding expressions while computing GCDs and applies
a number of heuristics. Usually this improves performance, but in some cases
it doesn't. Allow user to switch off heuristics.

Part 5:

* gcd(): don't use heuristic GCD algorithm if gcd_options::no_heur_gcd
  flag is set.
* gcd(): don't handle partially factored expressions in a special way
  if gcd_options::no_part_factored flag is set.

refactor gcd() a little bit (no functional changes).

GiNaC tries to avoid expanding expressions while computing GCDs and applies
a number of heuristics. Usually this improves performance, but in some cases
it doesn't. Allow user to switch off heuristics.

Part 4:

refactor gcd() a little bit, so subsequent patch(es) won't be so big and ugly.

introduce gcd_pf_mul: gcd helper to handle partially factored expressions.

GiNaC tries to avoid expanding expressions while computing GCDs and applies
a number of heuristics. Usually this improves performance, but in some cases
it doesn't. Allow user to switch off heuristics.

Part 3:

Move the code handling products from gcd() into a separate function. This
is *really* only code move, everything else should be considered a bug.

introduce gcd_pf_pow: gcd helper to handle partially factored expressions.

GiNaC tries to avoid expanding expressions while computing GCDs and applies
a number of heuristics. Usually this improves performance, but in some cases
it doesn't. Allow user to switch off heuristics.

Part 2:

Move the code handling powers from gcd() into a separate function. This
is *really* only code move, everything else should be considered a bug.

gcd: allow user to override (some of) heuristics.

GiNaC tries to avoid expanding expressions while computing GCDs and applies
a number of heuristics. Usually this improves performance, but in some cases
it doesn't. Allow user to switch off heuristics.

Part 1:

* add new (optional) argument to gcd() to control its behaviour.
* introduce gcd_options structure.

N.B. No actual code changes so far, the actual handling of newly introduced
options is the subject of further patches.

inifscn_nstdsums: make functions handling Li/G transformations reentrant.

Explicitly pass the dummy symbols instead of using a global variable.
As a side effect, the code is more clear now (that's a bit subjective, but
anyway).

Bail out if both autogen and autogen'erated file(s) are missing.

This makes the error message(s) more helpful.

Faster, better (recursive descent) expression parser.

Ouch, it fails to compile. Here is a correct version:

From: Alexei Sheplyakov <varg@theor.jinr.ru>
Date: Tue, 19 Aug 2008 21:50:03 +0400
Subject: [PATCH] Faster, better (recursive descent) expression parser.

bison generated parser has a number of problems:

1. Bad performance. Parsing a sum seems to be O(N^{2 + a}) (a > 0) [1].
   For example, parsing a sum (actually, a univariate polynomial) of 32768
   terms takes about 90 sec. on my box, parsing a sum of 10^6 terms takes
   "eternity".
2. The user is expected to provide list of all symbols in the expression.
   Often this is very annoying (and useless).
3. Parser is not reentrant (bison *can* produce reentrant parsers, but that
   won't solve other problems).
4. Parser is difficult to extend.

Hence the new parser.

Features:

1. Parsing large sums and products is O(N).
2. Parser is reentrant (well, almost).
3. It's possible to insert (shell style) comments inside the expressions.
4. matrices, lists, FAIL are NOT handled. Yes, this *is* a feature :-)

Limitations:

1. Error handling is a bit terse: on error exception is thrown, and that's it.
2. Binary, octal, and hexadecimal numbers can not be parsed (yet).
3. Tensors, noncommutative products, etc. can not be parsed.

Other notes:

1. ex ctor still uses the old parser.
2. ginsh still uses the old parser.

[1] Mesured by this script (requires gnuplot):

make_expression_string ()
{
printf "1 + x"
local n=2
while test $n -le $1; do
printf " + %s*x^%s" $n $n
n=$(expr $n + 1)
done
}

single_test ()
{
printf "$1 \t"
( printf "time("; make_expression_string $1; printf ");" ) | \
ginsh | sed -e 's/s$//'
}

benchmark ()
{
local N=$1
while test $N -le $2; do
single_test $N
N=$(expr $N \* 2)
done

}

gnuplot_header ()
{
  echo "set logscale xy"
echo "set xlabel 'degree (# of terms)'"
echo "set ylabel 'time, sec.'"
echo "set xrange [${1}:${2}]"
echo "plot '-' using 1:2 with lines title '1+x+2*x^2+...+n*x^n'"
}

gnuplot_footer ()
{
echo "e"
}

benchmark_and_plot ()
{
( gnuplot_header $1 $2
  benchmark $1 $2 | tee $3.txt
  gnuplot_footer ) | \
gnuplot -persist '-'
}

N_ini=${1:-1024}
N_fin=${2:-32768}
out_base=${3:-parser_benchmark}

benchmark_and_plot $N_ini $N_fin $out_base

Daily bugfix in the polynomial factorization (code didn't catch polynomial "x"
and cln::sqrt conversion was buggy).

Fixed bug in the Q matrix calculation and the univariate factorization function.