pointless) bivariate polynomial with some large coefficients:
@example
+#include <iostream>
#include <ginac/ginac.h>
using namespace std;
using namespace GiNaC;
generates Hermite polynomials in a specified free variable.
@example
+#include <iostream>
#include <ginac/ginac.h>
using namespace std;
using namespace GiNaC;
[[1,1],[2,-1]]
> A+2*M;
[[1,1],[2,-1]]+2*[[1,3],[-3,2]]
-> evalm(");
+> evalm(%);
[[3,7],[-4,3]]
+> B = [ [0, 0, a], [b, 1, -b], [-1/a, 0, 0] ];
+> evalm(B^(2^12345));
+[[1,0,0],[0,1,0],[0,0,1]]
@end example
Multivariate polynomials and rational functions may be expanded,
> series(tgamma(x),x==0,3);
x^(-1)-Euler+(1/12*Pi^2+1/2*Euler^2)*x+
(-1/3*zeta(3)-1/12*Pi^2*Euler-1/6*Euler^3)*x^2+Order(x^3)
-> evalf(");
+> evalf(%);
x^(-1)-0.5772156649015328606+(0.9890559953279725555)*x
-(0.90747907608088628905)*x^2+Order(x^3)
> series(tgamma(2*sin(x)-2),x==Pi/2,6);
-Euler-1/12+Order((x-1/2*Pi)^3)
@end example
-Here we have made use of the @command{ginsh}-command @code{"} to pop the
+Here we have made use of the @command{ginsh}-command @code{%} to pop the
previously evaluated element from @command{ginsh}'s internal stack.
If you ever wanted to convert units in C or C++ and found this is
In order to install GiNaC on your system, some prerequisites need to be
met. First of all, you need to have a C++-compiler adhering to the
-ANSI-standard @cite{ISO/IEC 14882:1998(E)}. We used @acronym{GCC} for
-development so if you have a different compiler you are on your own.
-For the configuration to succeed you need a Posix compliant shell
-installed in @file{/bin/sh}, GNU @command{bash} is fine. Perl is needed
-by the built process as well, since some of the source files are
-automatically generated by Perl scripts. Last but not least, Bruno
-Haible's library @acronym{CLN} is extensively used and needs to be
-installed on your system. Please get it either from
-@uref{ftp://ftp.santafe.edu/pub/gnu/}, from
+ANSI-standard @cite{ISO/IEC 14882:1998(E)}. We used GCC for development
+so if you have a different compiler you are on your own. For the
+configuration to succeed you need a Posix compliant shell installed in
+@file{/bin/sh}, GNU @command{bash} is fine. Perl is needed by the built
+process as well, since some of the source files are automatically
+generated by Perl scripts. Last but not least, Bruno Haible's library
+CLN is extensively used and needs to be installed on your system.
+Please get it either from @uref{ftp://ftp.santafe.edu/pub/gnu/}, from
@uref{ftp://ftpthep.physik.uni-mainz.de/pub/gnu/, GiNaC's FTP site} or
from @uref{ftp://ftp.ilog.fr/pub/Users/haible/gnu/, Bruno Haible's FTP
site} (it is covered by GPL) and install it prior to trying to install
environment variable, like optimization, debugging information and
warning levels. If omitted, it defaults to @option{-g
-O2}.@footnote{The @command{configure} script is itself generated from
-the file @file{configure.in}. It is only distributed in packaged
+the file @file{configure.ac}. It is only distributed in packaged
releases of GiNaC. If you got the naked sources, e.g. from CVS, you
must generate @command{configure} along with the various
-@file{Makefile.in} by using the @command{autogen.sh} script.}
+@file{Makefile.in} by using the @command{autogen.sh} script. This will
+require a fair amount of support from your local toolchain, though.}
The whole process is illustrated in the following two
examples. (Substitute @command{setenv @var{VARIABLE} @var{value}} for
@end example
And here is a configuration for a private static GiNaC library with
-several components sitting in custom places (site-wide @acronym{GCC} and
-private @acronym{CLN}). The compiler is persuaded to be picky and full
-assertions and debugging information are switched on:
+several components sitting in custom places (site-wide GCC and private
+CLN). The compiler is persuaded to be picky and full assertions and
+debugging information are switched on:
@example
$ export CXX=/usr/local/gnu/bin/c++
@cindex CLN
@cindex rational
@cindex fraction
-For storing numerical things, GiNaC uses Bruno Haible's library
-@acronym{CLN}. The classes therein serve as foundation classes for
-GiNaC. @acronym{CLN} stands for Class Library for Numbers or
-alternatively for Common Lisp Numbers. In order to find out more about
-@acronym{CLN}'s internals the reader is refered to the documentation of
-that library. @inforef{Introduction, , cln}, for more
-information. Suffice to say that it is by itself build on top of another
-library, the GNU Multiple Precision library @acronym{GMP}, which is an
+For storing numerical things, GiNaC uses Bruno Haible's library CLN.
+The classes therein serve as foundation classes for GiNaC. CLN stands
+for Class Library for Numbers or alternatively for Common Lisp Numbers.
+In order to find out more about CLN's internals the reader is refered to
+the documentation of that library. @inforef{Introduction, , cln}, for
+more information. Suffice to say that it is by itself build on top of
+another library, the GNU Multiple Precision library GMP, which is an
extremely fast library for arbitrary long integers and rationals as well
as arbitrary precision floating point numbers. It is very commonly used
-by several popular cryptographic applications. @acronym{CLN} extends
-@acronym{GMP} by several useful things: First, it introduces the complex
-number field over either reals (i.e. floating point numbers with
-arbitrary precision) or rationals. Second, it automatically converts
-rationals to integers if the denominator is unity and complex numbers to
-real numbers if the imaginary part vanishes and also correctly treats
-algebraic functions. Third it provides good implementations of
-state-of-the-art algorithms for all trigonometric and hyperbolic
-functions as well as for calculation of some useful constants.
+by several popular cryptographic applications. CLN extends GMP by
+several useful things: First, it introduces the complex number field
+over either reals (i.e. floating point numbers with arbitrary precision)
+or rationals. Second, it automatically converts rationals to integers
+if the denominator is unity and complex numbers to real numbers if the
+imaginary part vanishes and also correctly treats algebraic functions.
+Third it provides good implementations of state-of-the-art algorithms
+for all trigonometric and hyperbolic functions as well as for
+calculation of some useful constants.
The user can construct an object of class @code{numeric} in several
ways. The following example shows the four most important constructors.
integers, construction from C-float and construction from a string:
@example
+#include <iostream>
#include <ginac/ginac.h>
using namespace GiNaC;
digits:
@example
+#include <iostream>
#include <ginac/ginac.h>
using namespace std;
using namespace GiNaC;
some multiple of its denominator and test what comes out:
@example
+#include <iostream>
#include <ginac/ginac.h>
using namespace std;
using namespace GiNaC;
holds a rational number represented as integer numerator and integer
denominator. When multiplied by 10, the denominator becomes unity and
the result is automatically converted to a pure integer again.
-Internally, the underlying @acronym{CLN} is responsible for this
-behavior and we refer the reader to @acronym{CLN}'s documentation.
-Suffice to say that the same behavior applies to complex numbers as
-well as return values of certain functions. Complex numbers are
-automatically converted to real numbers if the imaginary part becomes
-zero. The full set of tests that can be applied is listed in the
-following table.
+Internally, the underlying CLN is responsible for this behavior and we
+refer the reader to CLN's documentation. Suffice to say that
+the same behavior applies to complex numbers as well as return values of
+certain functions. Complex numbers are automatically converted to real
+numbers if the imaginary part becomes zero. The full set of tests that
+can be applied is listed in the following table.
@cartouche
@multitable @columnfractions .30 .70
A simple example shall illustrate the concepts:
@example
+#include <iostream>
#include <ginac/ginac.h>
using namespace std;
using namespace GiNaC;
(Note the absence of "x".)
> expand((sin(x)+sin(y))*(a+b));
sin(y)*a+sin(x)*b+sin(x)*a+sin(y)*b
-> find(",sin($1));
+> find(%,sin($1));
@{sin(y),sin(x)@}
@end example
@}
@end example
-Here is another example for you to meditate over. It removes quadratic
+Here is another example for you to meditate over. It removes quadratic
terms in a variable from an expanded polynomial:
@example
@{
if (is_a<add>(e) || is_a<mul>(e))
return e.map(*this);
- else if (is_a<power>(e) && e.op(0).is_equal(var) && e.op(1).info(info_flags::even))
+ else if (is_a<power>(e) &&
+ e.op(0).is_equal(var) && e.op(1).info(info_flags::even))
return 0;
else
return e;
polynomial is analyzed:
@example
-#include <ginac/ginac.h>
-using namespace std;
-using namespace GiNaC;
-
-int main()
@{
symbol x("x"), y("y");
ex PolyInp = 4*pow(x,3)*y + 5*x*pow(y,2) + 3*y
@code{.to_rational()}, described below.
This means that both expressions @code{t1} and @code{t2} are indeed
-simplified in this little program:
+simplified in this little code snippet:
@example
-#include <ginac/ginac.h>
-using namespace GiNaC;
-
-int main()
@{
symbol x("x");
ex t1 = (pow(x,2) + 2*x + 1)/(x + 1);
the derivatives of all the monomials:
@example
-#include <ginac/ginac.h>
-using namespace GiNaC;
-
-int main()
@{
symbol x("x"), y("y"), z("z");
ex P = pow(x, 5) + pow(x, 2) + y;
- cout << P.diff(x,2) << endl; // 20*x^3 + 2
+ cout << P.diff(x,2) << endl;
+ // -> 20*x^3 + 2
cout << P.diff(y) << endl; // 1
+ // -> 1
cout << P.diff(z) << endl; // 0
+ // -> 0
@}
@end example
generally. This ought to be fixed. However, doing numerical
computations with GiNaC's quite abstract classes is doomed to be
inefficient. For this purpose, the underlying foundation classes
-provided by @acronym{CLN} are much better suited.
+provided by CLN are much better suited.
@node Symbolic functions, Adding classes, What does not belong into GiNaC, Extending GiNaC
windows into GiNaC have been implemented and many more are possible: the
tiny @command{ginsh} that is part of the distribution exposes GiNaC's
types to a command line and second, as a more consistent approach, an
-interactive interface to the @acronym{Cint} C++ interpreter has been put
-together (called @acronym{GiNaC-cint}) that allows an interactive
-scripting interface consistent with the C++ language.
+interactive interface to the Cint C++ interpreter has been put together
+(called GiNaC-cint) that allows an interactive scripting interface
+consistent with the C++ language. It is available from the usual GiNaC
+FTP-site.
@item
seamless integration: it is somewhere between difficult and impossible
portability: While the GiNaC library itself is designed to avoid any
platform dependent features (it should compile on any ANSI compliant C++
compiler), the currently used version of the CLN library (fast large
-integer and arbitrary precision arithmetics) can be compiled only on
-systems with a recently new C++ compiler from the GNU Compiler
-Collection (@acronym{GCC}).@footnote{This is because CLN uses
-PROVIDE/REQUIRE like macros to let the compiler gather all static
-initializations, which works for GNU C++ only.} GiNaC uses recent
-language features like explicit constructors, mutable members, RTTI,
-@code{dynamic_cast}s and STL, so ANSI compliance is meant literally.
-Recent @acronym{GCC} versions starting at 2.95, although itself not yet
-ANSI compliant, support all needed features.
+integer and arbitrary precision arithmetics) can only by compiled
+without hassle on systems with the C++ compiler from the GNU Compiler
+Collection (GCC).@footnote{This is because CLN uses PROVIDE/REQUIRE like
+macros to let the compiler gather all static initializations, which
+works for GNU C++ only. Feel free to contact the authors in case you
+really believe that you need to use a different compiler. We have
+occasionally used other compilers and may be able to give you advice.}
+GiNaC uses recent language features like explicit constructors, mutable
+members, RTTI, @code{dynamic_cast}s and STL, so ANSI compliance is meant
+literally. Recent GCC versions starting at 2.95.3, although itself not
+yet ANSI compliant, support all needed features.
@end itemize
as you try to change the second. Consider the simple sequence of code:
@example
+#include <iostream>
#include <ginac/ginac.h>
using namespace std;
using namespace GiNaC;
can be:
@example
-#include <ginac/ginac.h>
-using namespace std;
-using namespace GiNaC;
-
-int main()
@{
symbol x("x"), y("y");
AC_PROG_INSTALL
AC_LANG_CPLUSPLUS
-AM_PATH_GINAC(0.7.0, [
+AM_PATH_GINAC(0.9.0, [
LIBS="$LIBS $GINACLIB_LIBS"
CPPFLAGS="$CPPFLAGS $GINACLIB_CPPFLAGS"
], AC_MSG_ERROR([need to have GiNaC installed]))
git://www.ginac.de / ginac.git / blobdiff