* Really remove silly acronyms. The fucking network breakdown this release_1-0-0
authorRichard Kreckel <Richard.Kreckel@uni-mainz.de>
Tue, 6 Nov 2001 20:04:16 +0000 (20:04 +0000)
committerRichard Kreckel <Richard.Kreckel@uni-mainz.de>
Tue, 6 Nov 2001 20:04:16 +0000 (20:04 +0000)
  afternoon has garbled the file so half of the commit has failed.

doc/tutorial/ginac.texi

index 70c669b..c86114d 100644 (file)
@@ -455,15 +455,14 @@ installation.
 
 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
@@ -553,9 +552,9 @@ $ ./configure
 @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++
@@ -893,25 +892,24 @@ can use the expression's @code{.subs()} method (@pxref{Substituting Expressions}
 @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.
@@ -1004,7 +1002,7 @@ done some arithmetic with them it is frequently desired to retrieve some
 kind of information from them like asking whether that number is
 integer, rational, real or complex.  For those cases GiNaC provides
 several useful methods.  (Internally, they fall back to invocations of
-certain @acronym{CLN} functions.)
+certain CLN functions.)
 
 As an example, let's construct some rational number, multiply it with
 some multiple of its denominator and test what comes out:
@@ -1036,13 +1034,12 @@ by @code{numeric}'s copy constructor but in an intermediate step it
 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
@@ -4072,12 +4069,12 @@ negative real axis where the points on the axis itself belong to the
 upper part (i.e. continuous with quadrant II).  The inverse
 trigonometric and hyperbolic functions are not defined for complex
 arguments by the C++ standard, however.  In GiNaC we follow the
-conventions used by @acronym{CLN}, which in turn follow the carefully
-designed definitions in the Common Lisp standard.  It should be noted
-that this convention is identical to the one used by the C99 standard
-and by most serious CAS.  It is to be expected that future revisions of
-the C++ standard incorporate these functions in the complex domain in a
-manner compatible with C99.
+conventions used by CLN, which in turn follow the carefully designed
+definitions in the Common Lisp standard.  It should be noted that this
+convention is identical to the one used by the C99 standard and by most
+serious CAS.  It is to be expected that future revisions of the C++
+standard incorporate these functions in the complex domain in a manner
+compatible with C99.
 
 
 @node Input/Output, Extending GiNaC, Built-in Functions, Methods and Functions
@@ -4507,7 +4504,7 @@ evaluate themselves numerically to a precision declared at runtime
 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
@@ -5184,9 +5181,10 @@ expressions interactively, as in traditional CASs.  Currently, two such
 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
@@ -5227,16 +5225,18 @@ not planned for the near future).
 @item
 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 @acronym{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 @acronym{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.
+compiler), the currently used version of the CLN library (fast large
+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