GiNaC News & Announcements:ginsh recurses into other assigned symbols (again).
polynomial(x)^n for small and large n.
ginsh evaluate line-by-line in non-interactive mode.
binomial(n, k) with negative integer n, k.
sqrfree_parfrac().
series_to_poly() can be used from ginsh.
power::to_polynomial() for posint exponents.
power::subs() in some special cases.
relational objects.
modular_form_kernel::series() includes an Order term.
relational::canonical() and improve conversion of
relational to Boolean (it now works on many simple symbolic cases).
ex::operator[].
evalf() their arguments before doing
own evalf().
H_evalf() and in evaluation of iterated integrals.
factor() and in expand().
collect_common_factors() for hidden zero arguments.
pseries::evalf(), broken since 1.7.0.
H_evalf().
mul::series() about asymptotic order term.
cl_N code generation for small negative integers.
matrix::solve().
lsolve(eqns, vars).
matrix::rank(solve_algo).
G_do_hoelder with real x values which are not cl_R.
matrix::solve() work with hidden (non-normal) zeros.
symbol::get_TeX_name().
GINAC_DECLARE_REGISTERED_CLASS() work outside namespace GiNaC.
basic::subs(), visible in classes which don't override it.
Li_projection.
cliffor_bar() and clifford_star().
clifford_to_lst().
auto', 'nullptr', 'constexpr', range-based for loops, the contextual keyword 'override', static 'noexcept' operator, etc.
container<>, lst and nested initializer lists ctor for class matrix.
discardable' hack and std::auto_ptr<T> for good.
dynallocate<T>(args...) helper functions obsolete manual allocation on the heap and setting the dynallocated status flag.
bind2nd, etc.) and replaced them with lambdas.
level' argument of all .eval() methods. This has become possible by ensuring that add::eval() and mul::eval() evaluate their own structure without compromise (this was not guaranteed before). If all ex are evaluated, any object which is an aggregate of such ex will only ever have to evaluate itself, obsoleting the need for recursing.
level' arguments of all .evalf() and .normal() methods. They were modeled after the .eval() methods.
relational::rhs() and lhs() nonvirtual.
power::info(info_flags::real).
fderivative::derivatives() method.
info_flags::algebraic.
ex::to_rational(lst) and ex::to_polynomial(lst).
$LIBEXECDIR now, not in $BINDIR.
sqrfree(), normal(), numer(), and denom().
add::eval().
pow(+(...),2).expand() where the sum contained roots of rationals.
pow(+(...),n).expand() where n>2.
pow(+(...),2).expand() where the sum contained roots of rationals.
info(info_flags::nonnegative).
power::expand() (x*p)^c -> x^c * p^c, if p>0.
normal() where nested functions occur multiple times.
abs(), imag_part(), real_part().
abs(z)^(2n) -> z^n * conjugate(z)^n.
expand_options::expand_transcendental. GiNaC will apply additional
rules when expanding expressions if this option is specified, i.e.log(a*b) -> log(a) + log(b)exp(a + b) -> exp(a)*exp(b)
expand() and info() now.
x^{-1})^c -> x^{-c} for positive c.
abs(x)^n -> x^n if x is real
and n is even.
power::info(): power with a real base and even exponent
reports that it's non-negative.
expairseq::match() bug:> match(sin(y)*exp(b)+sin(x)*exp(a), sin($0)*exp(a)+exp(b)*sin($1))FAIL
power::is_polynomial() and mul::is_polynomial()
computation.
factor_univariate correctly handles polynomials over rationals
(no segfaults any more).
factor_multivariate due to incorrect
handling of polynomials having a leading coefficient being a sum with a
non-trivial integer content.
log(1-x) in numeric evaluation of classical
polylogarithm.
numeric::info(info_flags::nonnegative) correctly handles complex
numbers with non-zero imaginary part.
GiNaC::lst again.
subs_options::no_index_renaming was ignored).
ginsh using gcc 4.6.
fsolve() and improved its numerical algorithm.
power::eval().
add:eval() (real_part() had returned wrong results).
symbol::get_name().
is_polynomial().
simplify_indexed() algorithm.
power::series() can handle now more expressions with singularities in the exponent.
conjugate() methods to functions cosh, sinh, tanh.
conjugate() for user-defined functions to avoid
wrong evaluations. A user-defined conjugate_func must now be explicitly registered.
degree_vector() utility function.
pgcd()).
atan2() (division by zero error for atan2(x,0) if x is a negative and composite term).
info_flags::negative and info_flags::negint.
mul::info() and add::info() support for numeric
info_flags return_type_info().
gcd() now allows the user to override (some of the) heuristics.
sqrfree().
lsolve() of systems containing non-numeric coefficients.
Li/G that caused imaginary parts of the arguments to be ignored.
function more consistent with respect to ncmul::eval().
power::is_polynomial.
heur_gcd() so it can handle rational polynomials.
Digits) has been changed.
Li and zeta.
coerce() standard compliant.
lsolve() of systems containing non-numeric coefficients.
ginac_yylex().
mul::eval() and power::eval().
info(info_flags::has_indices) now works for sums and products.
mul::expand().
ginac_yylex().
mul::eval() and power::eval().
info(info_flags::has_indices) now works for sums and products.
rtt from class symbol.
is_polynomial() method.
real_part() and imag_part() methods.
matrix::is_zero_matrix() method.
evalm() method to pseries class.
atan2(y,x) branch cut correction.
Li/G.
info_flags::expanded added.
pow().
power.
S() (infinite loop), H() and zeta() (wrong results).
power::eval().
collect_common_factors.
tensor::replace_contr_index().
fderivative::match_same_type(), expairseq::match(), expand_dummy_sum(), and expairseq::map().
-x instead of -1.0*x.
.has().
collect_common_factors also works with negative powers of common factors now.
H() that caused an infinite recursion for arguments around +-I.
adaptivesimpson() precision-aware.
Li and S around x==0.
fsolve() numerical univariate real-valued function solver.
sub_matrix() and reduced_matrix().
ERLANGEN, Germany, October 6, 2005 - The GiNaC/CLN hackers, the leading providers of advanced mathematical software solutions for research and industrial applications, are proud to announce that their system scored second in the “Many Digits” Friendly Competition, held 3rd and 4th October at the Radboud University in Nijmegen, The Netherlands. Although Richard Kreckel, former vice president of GiNaC's PR department has retired into industry, he was available to compete against the world's finest exact real arithmetic hackers.
“It was a thrilling experience” said Richard Kreckel at a meeting with press. “I basically started hacking on the competition problems Monday morning and stopped only an hour before our turn at the competition Tuesday afternoon. Little sleep compensated only by beer, coffee and lots of caffeinated peppermints. It was quite similar to those release parties at University.”
Maybe it wasn't enough caffeine, though. The winner at the competition was the MPFR team headed by Paul Zimmermann. Says Richard Kreckel: “Well, they certainly cut some corners. They discovered, coded and tested closed-form solutions for hard iterative problems, thus being better than anybody else by orders of magnitude. Their winning is well-deserved. Congratulations!” Other competing systems were iRRAM, Wolfram's Mathematica, Maple, RealLib, COMP, Few Digits and Bignum.
Although only provisional rankings have been published so far, ground-shaking changes in the results are not expected. The “Many Digits” Friendly Competition was of purely numerical nature: none of the 24 competition problems called for symbolic manipulations. Hence, it really was a measure of CLN's numerical power, rather than GiNaC's symbolic flexibility. Bruno Haible, the original author of the CLN library could not be reached for a statement. It is assumed that he is busy hunting down bugs in several dozen GNU software packages at the same time. He has all the time. After all, he has retired to industry, too.
collect_common_factors now works with powers.
integral() and eval_integ() can be used from ginsh.
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.
gcd().
Li() now evaluates numerically for arbitrary arguments.
G(a,y) and G(a,s,y) added (another notation for multiple polylogarithms).
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.
Li(2,x).
Li(n,x) (if Li(2,x) was calculated with high precision the enlargement of the look-up table caused a segmentation fault).
power::info().
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.
--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.
const_preorder_iterator and const_postorder_iterator classes (and associated methods ex::pre/postorder_begin/end()) providing tree traversal with iterators.
varidx class.
(p.i*p.i).get_free_indices() returns the correct result () instead of (.i).
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).
matrix::rank().
resultant().
integer_content() function to ginsh.
atan2_evalf() and improved atan2_eval().
sin(-2) -> -sin(2)).
structure<T> template class for the easy creation of user-defined algebraic classes.
const_iterator class that can be used instead of op()/nops().
ex::conjugate() and a function conjugate() for complex conjugation. Symbols can be declared as real or complex-valued.
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) and to_rational/to_polynomial(lst & repl) are still available for compatibility, but using the new forms subs(const exmap & m, unsigned options) and 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 &.
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.
basic::copy() and basic::destroy() are gone; classes derived from basic can use the defaults for the assignment operator and copy constructor.
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.
basic::print() is now deprecated. You should use print_func<>() class options instead.
canonicalize_clifford().
dummy() which means “no options”. This simplifies the implementation of symbolic functions which are not to be further evaluated.
Li() that caused the system to hang for certain parameter combinations.
simplify_indexed().
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.
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.
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.
Li(), Nielsen's generalized polylogarithm S(), harmonic polylogarithm H(), and multiple zeta value mZeta().
exhashmap<T> template intended as a drop-in replacement for std::map<ex, T, ex_is_less> using GiNaC's hashing algorithms.
normal()/numer_denom(): denominator was not made unit normal if it was a simple number.
subs() in some cases.
lst (and exprseq) provide iterators for read-only element access. For sequential access this is one order faster than using op().
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.
print(), iprint(), print_latex() and print_csrc() in ginsh.
dflt, latex, python, python_repr, tree, csrc, csrc_float, csrc_double, csrc_cl_N, index_dimensions and no_index_dimensions to control the output format. Calling basic::print() directly is now deprecated.
subs() accepts an optional options argument. The option subs_option::subs_algebraic enables “smart” substitutions in products and powers.
scalar_products mechanism allows the specification of an index dimension.
ex::to_polynomial().
is_ex_a, is_ex_exactly_a and friends for good.
dirac_gamma6/7().
basic::subs(): third argument changed from bool to unsigned
basic::unarchive(): const removed from second argument
basic::let_op() should only be implemented if write access to subexpressions is desired
simplify_ncmul() renamed to eval_ncmul()
simplified_ncmul() renamed to hold_ncmul()
nonsimplified_ncmul() renamed to reeval_ncmul()
complex<> template or cln::complex()), rational numbers use cl_RA() in the CLN output, and small integers are printed in a more compact format (e.g. 2.0 instead of 2.0000000e+00).
function_options::set_return_type() and function_options::do_not_evalf_params() now actually work.
dirac_gammaL/R(), which can be used instead of dirac_gamma6/7() but are single objects, to allow for a more compact notation of Dirac strings.
symbolic_matrix() for the convenient creation of matrices filled with symbols.
collect_common_factors() which collects common factors from the terms of sums.
simplify_indexed() converts gamma~mu*p.mu to p\.
power::expand() that could produce invalid expressions.
print_latex() and print_csrc() to ginsh.
sprem() function is now public.
indexed objects are now parenthesized correctly in LaTeX output.
idx and tensor classes.
canonicalize() (antisymmetric canonicalization of an already sorted list containing two or more equal objects failed to return 0).
simplify_indexed() now raises/lowers dummy indices to canonicalize the index variance. This allows some simplifications that weren't possible before, like eps~a.b~c~d*X.a*X~b -> 0 and X.a~a-X~a.a -> 0.
relational::subs().
simplify_ncmul() for clifford objects.
expand() methods.
matrix::pow(n) for n==0 and added helper functions to create unit matrices ex unit_matrix(unsigned, unsigned).
(x+1).subs(x==x-1) now returns the correct result x instead of x-1.l)degree(s), coeff(s, n) and collect(s) were extended to accept expressions of any class (except add/mul/ncmul/numeric) for “s”. They should even work if “s” is a power object, as long as the exponent is non-integer, but with some limitations. For example, you can collect(a*2^x+b*2^x,2^x) to get (a+b)*2^x, but degree(2^(3*x), 2^x) yields 0 instead of 3).
expand().
quo() would call vector::reserve() with a negative argument.
sqrt(), which is also used in the output.
divide(a,b,q) only modifies q if the division succeeds; also divide(a,b,a) works now.
power::degree() and power::ldegree() throw an exception when encountering a non-integer exponent.
sqrfree() handles a few more cases now.
relational supports real canonical ordering now.
ginsh.
MAINZ, Germany, November 6, 2001 - The GiNaC hackers, the leading providers of advanced mathematical software solutions for research and industrial applications, loudly announce the availability of GiNaC version 1.0.
GiNaC stands for “GiNaC is not a CAS”, i.e. not a Computer Algebra System. This is reminiscent to the term GNU, which stands for “GNU is not Unix”, yet GNU systems widely define Unix today. It is a C++ class-library that allows certain common symbolic manipulations to be expressed directly in that language.
“This release is going to change a whole lot of things” says Richard Kreckel, vice president of GiNaC's PR department. “Competing closed-source systems like Mathematica and Maple must be considered obsolete now and will surely soon fall into oblivion -- Macsyma already has.” Asked whether GiNaC can really compete with all the fancy features and gimmicks found in those systems he replied: “Hey, there is always room for version 2.0 and the next generation!”
Alexander Frink, vice president of GiNaC's sales department, could not be reached for a statement. He was reckoned to be busy encashing donations from millions of joyous users overwhelmed with enthusiasm. GiNaC is free software and licensed under the GNU general public license (GPL).
“Having a truly scalable symbolic system is going to solve many of todays problems” says Christian Bauer, vice president of the research and development department. “Applications range from pure maths and physics over geological surveys, long-term stock options and weather forecasts to such fields as wine-making and Japanese cuisine.” The newly released version 1.0 contains “absolutely no significant changes relative to the last version whatsoever” according to Bauer. Asked how he sees further development he crypticly proclaimed “We are simply going to do what we did with the Macintosh: We emulate all other systems, including their bugs.”
Instructions how to download and install GiNaC on a computer system can be found at
<https://www.ginac.de/Download.html>.
Also, it comes pre-bundled with several distributions of the popular
Linux operating system as well as with FreeBSD. Because of this
dominant position on the consumers' computer desktops the US
department of justice (DOJ) is considering filing an antitrust
law-suit. “Okay, Microsoft got away with this practice, but we are
not going to tolerate imitators”, said DOJ attorney general John
Ashcroft at a meeting with press.
Germany's foreign minister Joschka Fischer delayed his trip to meet Palestinian president Jassir Arafat to stop in Mainz and congratulate the GiNaC folks for their release on behalf of Germany's chancellor Gerhard Schroeder. IT-industry friendly Mr. Schroeder was said to be busy “getting the beast installed” on his PC. “This new release is going to have a tremendous impact on global stability” Mr. Fischer said. “We have observed how politicians and suspected terrorists alike have become addicted to GiNaC and been converted to coding machines -- in a noble sense. Wherever they find a PC they start emitting mesmeric steams and then the miracle of code generation happens.”
evalf() that prevented things like 2^Pi being computed.
lsolve() accepts algorithmic hint as parameter.
simplify_indexed() is better at detecting expressions that vanish for symmetry reasons.
numeric are not explicit any more. All built-in callers for pseudofunctions are now templated and default to ex arguments which relaxes the need for explicit ctors.
find()
remove_first(), remove_last(), sort(), unique() for objects of class lst
symmetrize_cyclic()
decomp_rational()
symmetry objects that is constructed with the sy_none(), sy_symm(), sy_anti() and sy_cycl() functions. The symmetry of a function with respect to its arguments can also be defined (this is currently only used for the Beta function).
map() to take a function object instead of a function pointer. This allows passing an arbitrary number of additional state to the function being called.
color_trace(), dirac_trace(), diff(), expand(), evalf() and normal() work better with container classes, e.g. using color_trace() on a relation will take the trace on both sides, using diff() on a matrix differentiates every element etc.
diff() works properly with non-commutative products and indexed objects.
expand_function_args for expand().
is_of_type(foo, type) -> is_a<type>(foo)
is_ex_of_type(foo, type) -> is_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.
ginsh, lists are now delimited by { } braces, and matrices are delimited by single [ ] brackets.
simplify_indexed() renames dummy indices so, e.g., a.i*a.i+a.j*a.j gets
simplified to 2*a.i*a.i (or 2*a.j*a.j).
canonicalize_clifford() (helpful when comparing expressions containing Dirac matrices)
symmetrize() and antisymmetrize()
numer_denom() (return numerator and denominator in one call)
map() (apply function to subexpressions)
evalm() (evaluate sums, products and integer powers of matrices)
match() for performing pattern matching. subs() and has() also accept patterns as arguments. A pattern can be any expression, optionally containing wildcard objects. These are constructed with the call wild() and are denoted as $0, $1 etc. in the output and in ginsh.
cint subdirectory, ginaccint is a separate package now due to packaging considerations.
color and clifford classes are functional and documented.spinidx class for dotted/undotted indices.spinor_metric()).symbol s("s", "\\sigma");degree(), ldegree(), coeff(), lcoeff(), tcoeff()
and collect() work with non-symbols as the second argument in ginsh.
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().
.normal()).
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() can nowbe used with constants, functions and indexed expressions as well, so you can use it to collect by powers of Pi or sin(x), or to find the coefficient of gamma~0.x^2 or x+y won't work;
gamma~0 in p.mu*gamma~mu should be p.0 but is returned as 0;
coeff(), tcoeff(), lcoeff() or collect() on elements of noncommutative products might return wrong or surprising results.
subs((a+b)^2,a+b==3) and
get 9, but subs(a+b+c,a+b==3) doesn't do
anything.subs(expr, 2==4)) will not replace then in all occurences; in general, you shouldn't substitute numerics, though.
simplify_indexed(): contraction of symmetric and antisymmetric tensors is zero.
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, such as LaTeX output, which is based on work by Stefan
Weinzierl.
unarchive() (for printing or debugging purposes).
.collect() on non-polynomials is now algebraically correct.
indexed class and two types of indices: idx for
simple indices and varidx for indices with variance. There
are predefined delta, epsilon and metric tensors, and a function
simplify_indexed() that performs canonicalization and dummy
index summations. Matrix objects can be indexed for doing simple
linear algebra.
expand_indexed to expand() to
perform expansion of indexed objects like (a+b).i -> a.i + b.i.
get_indices() to get_free_indices(),
which no longer returns dummy indices and checks the consistency of
indices in sums.
sqrfree() factorization fixed and improved syntactically.
subs() works on matrices.
diag_matrix().
expand().
operator% for objects of class ncmul has gone. Use
operator* now for that case too, which is much more natural.
MAINZ, Germany, February 25, 2001 (ap) - The GiNaC group, the leading provider of advanced mathematical software solutions for research and industrial applications, is proud to announce that its system passes what is known as the Fermat Test one. The test is to simplify a large rational function in twelve symbolic variables to zero. That rational function arises in computer image analysis in conjunction with a solution to the “Recognition Problem for Six Lines”: From a three-dimensional object, six lines are extracted and from those six lines, nine three-dimensional invariants are computed as a kind of signature. Given a two-dimensional picture of some possibly different object from an arbitrary perspective the question is whether the two objects are the same. Up until now, the simplification of the rational functions arising there could only be performed by Robert H. Lewis' system Fermat, a special-purpose system designed for polynomial arithmetic. The test was hence put up as a challenge for other systems.
A smaller version of this test is known as test N from a suite of benchmarks published by Michael Wester and Robert Lewis on a number of Computer Algebra Systems. Robert Lewis comments: “test N on the test suite is the smaller or ‘reduced problem’” and “[it] comes from the paper mentioned on my web page that I wrote with Peter Stiller, ‘Solving the recognition problem for six lines using the Dixon resultant,’ Mathematics and Computers in Simulation 49 (1999) 205-219.”
“When we saw that the smaller test can be done in 15 minutes on a commodity PC running our system we had to try the full sized problem.” says Richard Kreckel, vice president of GiNaC's PR department. “We found that without having to resort to any tricks it runs through in about three hours and a half using approximately 500MB of memory.” And Christian Bauer, vice president of the research and development department, adds “Now let's open the champagne!”
normal() handles large sums of fractions better and normalizes the exponent
of power expressions.
expand() always expands the exponent and transforms x^(a+b) -> x^a*x^b.
numeric doesn't use an indirect pointer to the actual representation
any more. This is a speedup.
mul::expand() was reengineered to not allocate temporary excess memory.
(l)degree() and
coeff(). Using these functions on an expression containing such powers used
to fail with an internal error message. The side-effect is that collect()
can be used on expressions which are not polynomials.
ginac-config script.
numeric from char* honors Digits.
matrix. Some redundant
(and poor) implementations of elimination schemes were thrown out.
The code is now highly orthogonal, more flexible and much more efficient.
add::normal(), heur_gcd(),
sr_gcd() and Order_eval().
Cint, there is no progress: the current version 5.14.44 (released by CERN today) is somewhat broken, see the file INSTALL.
ginac/flags.h and ginac/matrix.h.
Li2) now has floating point evaluation, derivative and a proper series expansion.
std' cleanly disentangled, as demanded by ISO/EIC 14882-1998(E).
lsolve()-bugfix and documentation updates.
ginaccint.bin is now launched by a binary executable
instead of by a script. This allows us to write #!-scripts. A small test
suite for GiNaC-cint was added, because after the last release some very nasty
(and now fixed) problems were detected.
ginaccint may now link
dynamically against libginac, even with the namespace
switched on (i.e. the library need not be build twice any more). The
required version of Cint is now 5.14.38. Several minor bugfixes where
release 0.6.0 had some problems at installation.
f(x).series(x,p[,o]) -> f(x).series(x==p,o)
series(f(x),x,p[,o]) -> series(f(x),x==p,o)
gamma() -> tgamma() (The true Gamma function, there is now also
log(tgamma()), called lgamma(), in accord with ISO/IEC 9899:1999.)
EulerGamma -> Euler
#include'ing ginac.h defines the preprocessor symbols GINACLIB_MAJOR_VERSION,
GINACLIB_MINOR_VERSION, and GINACLIB_MICRO_VERSION with the respective GiNaC
library version numbers.
ex e("2*x+y", lst(x, y));
ex::to_rational() provides a way to extend the domain of functions like
gcd() and divide() that only work on polynomials or rational functions (the
good old ex::subs() method reverses this process)
diff() on a function that has no derivative defined
returns the inert derivative function Derivative.
.evalf() was changed for powers, series and so
on: It doesn't harm any exponents now, which leads to fewer surprises.
Also, the checks were completely restructured into three parts: 1)
exams (small regression tests with predefined input), 2)
checks (some coherence checks with random input) and 3)
timings (benchmarking but also for coherence).
autoheader installed and run it.
info_flags::rational doesn't return true for complex extensions any more -
use info_flags::crational for the old behaviour. info_flags::integer and
info_flags::cinteger work similarly, the same holds for types like
info_flags::rational_polynomial and so on.