CoCoALib 0.99850 Examples

This example shows some very basic features of CoCoALib.           
We show types for representing "big" integers and rationals.     
We also show how to do some compututations with polynomials.       

This example shows how to compute the `AlexanderDual' and the       
`PrimaryDecomposition' of monomial ideals.  These operations are    
offered by both CoCoALib and the external library Frobby.  This     
program shows how to check whether Frobby is available, and if so,  
how to call its functions with CoCoALib data.                       

A short example which reads a set of approximate points (with common epsilon)
and then applies the various preprocessing algorithms to them.  It prints out
the resulting preprocessed set with the corresponding weights, and the time taken.

This program illustrates basic operations on BigInt values, showing that   
they can be used much like normal C++ ints except that there is a almost   
no limit on the magnitude of the values.                                   
NB If you need extreme efficiency then use the GMP library directly.       
Contrast this example with ex-RingZZ1.                                     

This program illustrates that BigInt values can be used much like normal C++ 
ints except that there is a almost no limit on the magnitude of the values.  
NB If you need extreme efficiency then use the GMP library directly.         
Contrast this example with ex-RingZZ1.                                       

This program shows that BigInts can be used much like normal C++ ints
with the advantage that there is almost no limit on the magnitude of 
the values.  Here we generate random BigInts and test them for being 
probable primes -- stopping as soon as we find a likely prime.       
NB If you need extreme efficiency then use the GMP library directly. 

Program giving example of basic arithmetic with exact rational numbers 
represented as values of type BigRat.  The syntax recalls that used for    
the built-in C++ numerical types.  Emphasis is on convenience rather   
utmost execution speed.  To understand better the difference between   
a BigRat value and an element of the ring RingQ, contrast this example     
with ex-RingQ1.C.                                                      

This example shows how to create objects of type BigRatInterval,  
and how to do basic arithmetic with them.    

BuildInfo::PrintAll gives important information in the (enormously 
unlikely :-) event that you need to report a bug in CoCoALib. 

This example shows how to compute a factor base using an object of
type GCDFreeBasis_RingElem.  The gennerators of the factor base   
may be supplied individually, or all together in a vector.        

This example shows how to use a CpuTimeLimit object to limit the    
CPU time used in a function containing a loop: just call the memfn  
operator(), which will throw TimeoutException if timeout occurs.    
Note that timeout may occur a bit later than requested.             

This example shows how to use a CpuTimeLimit object to limit the   
CPU time used in a section of code.  In particular, it shows use of
myPrepareForNewLoop between two loops (with differing costs for a  
single iteration).  Compare this example with ex-CpuTimeLimit1.C.

This still has to be improved to become an interesting example (copied from test)Environments: DenseUPolyClean (Fp, Z)  

We show how to use DivMasks directly -- it is a bit tedious!             
See also the example ex-PPWithMask1.C, which has a friendlier interface. 
We show how the various different DivMaskRules can be selected.          

This example program illustrates the effectiveness of the various    
DivMaskRules when using DivMasks as a quick non-divisibility check.  
Using DivMasks to check divisibility we can obtain two answers:      
'Surely not' or 'Maybe'.  The intention here is to see how often     
'Maybe' really means 'Yes, divisible'.  We see that the effectiveness
depends also on the presence of unused indeterminate in the PPMonoid.

We show how to convert to and from PPMonoidElem.             
We list the available operations which are a lot faster than 
the corresponding ones on PPMonoidElems.                     
By default DynamicBitsets are printed as STL bitsets, i.e.   
0th bit in the rightmost position.  We show other options.   

Note that the ordering is xel, i.e. like lex but starting    
the comparison from the position with highest index (as they 
are printed by default)

We show how to convert to and from RingElem.             
We create an ideal I and convert its generator into DynamicBitsets.

This is an example program showing how to see which external  
libraries have been compiled into CoCoALib.                   

Example of use of MantissaAndExponent10 and related MantExp10 structure. 
Example of use of MantissaAndExponent2 and related MantExp2 structure.   
Example of use of FloatApprox (similatr to MantissaAndExponent2).        

This program shows what can be computed in CoCoALib using GFan:  
a library for computations in ..., 
....

This example shows how to specify that a CoCoALib custom allocator be used
for managing the memory for small GMP values.  If you do computations    
involving many small big-integers (e.g. up to about 40 decimal digits) then
the custom allocator may give slightly better run-time performance (with 
debugging turned off!)  The argument to the constructor for GlobalManager
indicates that the CoCoALib allocator is to be used for GMP values.      

This example shows the various ways of specifying the memory manager to  
be used by the GMP library.  The choice of memory manager is indicated as
an argument to the GlobalManager constructor.  Here we illustrate four   
choices: the CoCoALib default, the system allocator, the specialized     
GMPAllocator (with and without explicit indication of the slice size).   
The program measures the speed of computation with these various choices.

This example program shows how to apply Graeffe's method.           
When applying Graeffe's method to a polynomial in ZZ[x], the roots  
of a polynomial get raised to some power. The graeffe function is   
for squaring the roots, the graeffe3 function cubes them and the    
GraeffeN function raises them to a custom power. The GraeffeSeq     
class provides a way to iterate over all the powers up to a certain 
degree. In this example, the various functions are being applied    
to a polynomial with roots that are easy to calculate.              

Make a copy of this file (called "foo.C", say) and put your code 
inside the procedure "program".                                  
To compile your file in the examples directory just do this:       
  make foo                                                         

This short example show how to call IdealOfPoints.                
The points are specified as rows of a matrix (over some field k). 
You need a polynomial ring for the answer: its coeff ring must be 
the same field k as used in the matrix.                           

Make a copy of this file (called "foo.C", say) and put your code 
inside the procedure "program".                                  
To compile your file in the examples directory just do this:       
  make foo                                                         

 We explain the function JanetBasis and show whicht options we can choose. 

 PrintNonMultVar, PrintMultVar, IsPommaretBasis, StandardRepresentation(f) 

This example program shows how to check a LRS for degeneracy.       
In order to achieve this, the characteristic polynomial can be used 
used to determine whether it has two distinct roots whose quotient  
is a root of unity. As a simple example, two LRS-degenerate         
polynomials and one not-degenerate are examined.                    

This is a short example showing how to use LogStream, and how to  
make it refer to a different output stream.                       

The paper examples are available at:
  http://www.dima.unige.it/~bigatti/cocoa/ex-MVT-Simplicial-tests.zip
This program reads from stdin.  For your convenience run it as:
  ./ex-MVT-Simplicial < ex-MVT-Simplicial-tests/<...>

MVT for square free monomial ideals  

MVT for square free monomial ideals  

Example of use of the Mayer-Vietoris trees.  

This program shows the first prototype for MathSAT communication.
The CoCoA class to use is MathSAT::env.                          
Only linear constraints, defined by matrices or polynomials.     
The matrices have n+1 columns: last col is for constants.        
The linear polynomials are compared with 0 (eq0, neq0, leq0, lt0).

This program shows another example for MathSAT communication.    
Similar to ex-MathSAT1, also shows the use of verbosity.         

 JBResolution, JBBettiDiagramm, JBMinimalResolution. 

This is just an example!  If you want to compute Normal Forms 
you should use the library function "NF".                   

This program shows what can be computed in CoCoALib using Normaliz:  
a library for computations in affine monoids, vector configurations, 
lattice polytopes, and rational cones.

This example reads a normaliz input file and computes the support hyperplanes.
It also shows how to set some libnormaliz flags.

 DiffieHellman   
 ElGamal         
 RSA             
 Rabin           
 ====                                                      

This programs show how to use some of the basic number theoretic functions.
Many of the examples use machine integers for convenience, but all the     
functions also work with BigInt values (except NextPrime and PrevPrime).   

This program illustrates use of CRTMill to build a large integer 
from its residues modulo various different primes.               

This program tests how hard it is to find a "Goldbach" represetation 
of an integer; i.e. a sum of two primes.  It has to do many primality  
tests, so it is faster to use a table than call IsPrime repeatedly.    

This program shows how to reconstruct a rational from several        
residue-modulus pairs (allowing for some of them to be wrong).       
CoCoALib offers two methods: one using continued fractions, the other
using lattice reduction.  The actual reconstruction is performed     
inside ContFracTrial or LatticeTrial.                                

Each ordering is degree-compatible with grading over Z^GradingDim 
i.e. the grading is given by the first GradingDim rows            
of the ordering matrix.                                           

This program illustrates calling the functions for making  
orthogonal polynomials (Chebyshev, Hermite, Laguerre).     

The implementations of PPMonoids are optimized for different uses:  
PPMonoidEv:   stores the Exponent vector                            
              good for accessing the exponents, slow for ordering   
PPMonoidOv:   stores the Order vector                               
              good for ordering, slow for accessing the exponents   
PPMonoidEvOv: stores the Exponent vector and the Order vector       
              good for accessing the exponents and for ordering     
              uses more memory and takes more time to assign        
PPMonoidBigEv: stores the Exponent vector as BigInt's               
              necessary if you use big exponents (>2^10)            
              obviously slow   

This program shows how to create and use a PPMonoidHom.  

PPVector is a vector of PPWithMask.                       
It's been designed to represent the list of generators of 
monomial ideals (e.g. to facilitate interreduction).      
USE WITH CARE!  The interface may still change slightly.

We show how to use PPWithMasks for testing divisibility.      
This program is very similar to ex-DivMask1.C.  The main      
differences are that this program is shorter and clearer, and 
it does a proper job of testing divisibility (even when the   
 useless null rule is used).                                  

This example program test the speed of the divisibility test  
on values of type PPwithMask.  The main aim is to show that   
different DivMaskRules can produces differing behaviour, and  
which rule is best depends on the problem (e.g. few indets    
and high degrees, or many indets and low degrees).  Here we   
see also that unused indets can affect the speed.             
In case you're interested, the program ex-DivMask2 measures   
the effectiveness of the various DivMaskRules.                

This program shows the easiest way to read a RingElem (not just polys) 
from an expression written in a string or in a file.                   
It is much more refined than what was available/shown in ex-PolyInput1.
NB As always, reading from string is convenient but NOT efficient.     

Unlike in CoCoA-5, there no functions in CoCoALib to extract the      
support, the coeff list or the monomials from a polynomial.  Instead  
CoCoALib offers an "iterator" over the terms in a sparse polynomial:
you can access the coeff and PP directly from the iterator.           

This is just an example!  If you want to homogenize polynomials  
you should use the library function "homog".                   

This example program exhibits two things: various ways of creating 
polynomial rings, and several operations specific to elements of a 
polynomial ring.                                                   
In the procedure "program" there are examples of creating        
polynomial rings.                                                  
In the procedure "SomeComputations" there are brief examples of  
the operations specific to elements of PolyRings (e.g. deg).       
See also ex-ring2.C.                                               

Because of C/C++ precedence on operator "^" we cannot overload
it to define powers, as a consequence writing power-products can
be quite tedious or difficult to read.                          
Here we show how to write a simple function to create exponent  
vectors to be passed to "monomial".                           
I wish there were a better way to initialise a C++ vector...    

This example program shows how to extract the "coefficients" 
of a polynomial, and also how to compute some other operations 
on the coefficients (e.g. content).  CoCoALib offers two notions
of coefficient: one is the natural one dictated by the ring,   
and the other comes from identifying e.g. k[x,y,z] and k[x,z][y]

More specialized and optimized polynomial rings                   

In this file we explain how to compute several stability positions.  

In this file we explain how to using some methods which are using the Pommaret Basis.  

An example of how to use a ProgressReporter to print occasional 
updates during a long iterative computation.                    

The function "QuotientBasis" is now included in CoCoALib,          
so this example is a lot shorter than it was before version 0.9943.  
It returns a vector of PPMonoidElem.

CoCoALib offers a way to make uniform pseudo-random number generators.      
When creating the generator you must specify the (inclusive) upper and lower
bounds for the random numbers which will be generated.  When creating a     
generator you may specify a `seed'; this allows different pseudo-random     
sequences to be produced, though the sequence is completely determined by   
its initial seed value.                                                     

CoCoALib offers a pseudorandom bit generator.  The generator can be   
seeded when it is created; this allows different pseudo-random        
sequences to be produced, though the sequence is completely determined
by the initial seed value.  The `NextBiasedBool' function filters a   
random bit sequence to produce `true' with a specified probability.   

CoCoALib offers a way to make uniform pseudo-random number generators.   
When creating the generator you must specify the (inclusive)             
upper and lower bounds for the random numbers which will be generated.   
When creating a generator you may specify a `seed';                      
this allows different pseudo-random sequences to be produced,            
though the sequence is completely determined by its initial seed value.  

This program uses GlobalRandomSource() to generate uniformly   
distributed random bits/booleans, machine integers in a given  
range, and big integers in a given range.  For the booleans and
machine integers it produces a histogram.                      
Use of globals could be dangerous in multi-threaded programs.  

This program uses explicitly a RandomSource object to generate 
distributed random bits/booleans, machine integers in a given  
range, and big integers in a given range.                      

Create your first polynomial ring and polynomial.           
Basic operations an printing. 

This is a long list of function calls from different rings.  

The program asks the user for the value of N, it creates the     
ring of integers mod N, and finally uses "brute force" to find 
all square-roots of 2 modulo N.                                  

This program compares the speeds of computing sums and products in   
the three different implementations of small prime finite fields.    
It performs the timing tests for different sizes of prime, and       
illustrates that different implementations have different upper      
limits for the characteristic -- these limits depend on the platform.
It also gives the performance of the finite field created by NewZZmod

This example illustrates how to create an algebraic extension of a finite 
field, and how to obtain its generator.  We use the (group) generator to  
run through all the elements of the finite field.                         

CanonicalHom is an easy way to make these homomorphisms:  
R --> R/I,    R --> R[x],   R --> FractionField(R),       
R --> R,      QQ --> R,     ZZ --> R,                     
PolyAlgebraHom makes the R-algebra homomorphisms:         
R[x] --> R,   R[x] --> R[y]                               

The example in this file shows how to create and use some      
homomorphisms between rings.  In particular, it gives a simple 
example of mixed ring arithmetic: the user must map all values 
into a single ring before combining them arithmetically.       

We compute these polynomials (with parameters) in some rings: 
f = (2*a/3-1)*x[0] + 1/a;  g = x[0]-a;                        

The example in this file shows how to create a RingHom from 
one quotient ring to another.  First we make a RingHom from 
a polynomial ring to the codomain (a quotient ring), then we
use the function `InducedHom' to extend it to the full domain.

Familiarize yourself with the example ex-RingZZ1.C before proceeding. 
As C++ does not natively have any rings, we must construct them from  
scratch.                                                              

Example showing iterative increase of precision using RingTwinFloat    
until the answer is found (or some maximum precision is reached).      
This program will always fail to find the limit: J-M Muller's sequence 
actually converges to 6 (rather slowly), however it is pathological    
because it converges to 100 using any finite precision arithmetic.     
RingTwinFloat detects the onset of pathological convergence to 100, and
throws an InsufficientPrecision exception.                             

Example showing that certain RingTwinFloat values may have a precision  
higher than that requested.  In this case we request 64 bits (i.e.      
about 19 decimal digits), but in fact we can remove the nineteen most   
significant digits and still have a result with the requested precision.
So the original value of the variable third did in fact have at         
least 127 bits correct (i.e. about 38 decimal digits).                   

Example illustrating the `soft transitions' from false to uncertain      
and from uncertain to true in the equality test between twin floats.     
For many small values of eps this example computes 1+eps and compares    
the to 1 (either by direct comparison, or by subtacting and seeing if    
the difference is positive or zero.  Direct comparison is better than    
computing the difference (which throws InsufficientPrecision more often).

All these examples about RingWeyl will probably be merged into one.

This shows a computation of a Groebner Basis.
All these examples about RingWeyl will probably be merged into one.

This shows a computation of a Groebner Basis.
All these examples about RingWeyl will probably be merged into one.

This shows a computation of a Groebner Basis.
All these examples about RingWeyl will probably be merged into one.

This shows a computation of a Groebner Basis.
All these examples about RingWeyl will probably be merged into one.

To calculate with elements of a ring we must first create the   
ring, then we can create C++ objects of type RingElem which     
belong to the ring -- a RingElem can change its value but not   
the ring to which it belongs.                                   

This program illustrates use of the RootBound function for      
obtaining an upper bound on the abs value of the complex roots. 
The function has an optional second arg.  The second arg says   
how many Graeffe iterations to perform; these lead to a better  
bound, but can be slow for large polynomials (as the example    
makes clear).                                                   

This example illustrates basic use of SmallFpImpl for arithmetic in a
small prime finite field.  ex-SmallFp3 shows how to compute more     
efficiently, but it is not for the faint-hearted!                    
Here we see how to create a SmallFpImpl object, and its use for basic
arithmetic (add, sub, mul, div, power) on finite field elements.     

This simple example shows how to use the SmallFp export conventions
"SymmResidues" and "NonNegResidues", and the effect they have. 

**ADVANCED**  This example program is for advanced CoCoALib users.    
SmallFpImpl enables you to perform arithmetic efficiently in a small  
prime finite field.  The catch is that efficient use is not as simple 
as using RingElems directly.  We take as a specific illustrative      
example the computation of an inner product.  Be prepared to spend    
some time reading and comprehending the code!                         

This example illustrates evaluating a univariate polynomial  
with integer coefficients at an integer or rational point.   

Make a copy of this file (called "foo.C", say) and put your code 
inside the procedure "program".                                  
To compile your file in the examples directory just do this:       
  make foo                                                         

This example shows simple use of RealRadical and HasRealRoot3.  

This shows how to use the functions SturmSeq and NumRealRoots.  

Example of using a SumBigRat object to sum many rationals.     
SumBigRat can be rather faster than directly summing.          
Similarly SumBigInt is suitable for summing many big integers. 

Example of use FloatStr, ScientificStr and DecimalStr for printing 
rationals in a comprehensible/decimal format.                      

Example of use FloatStr, ScientificStr and DecimalStr for printing 
rationals in a comprehensible/decimal format.                      

This program illustrates use of product, sum, and LexCmp3.      
The functions are fairly general, but we present just a simple  
case.  They can also be used with lists instead of vectors      

This example shows how to print out a C++ vector of values.          
It also shows that you can just as easily print a vector of vectors. 

This is a program showing how to use VerificationLevel.  
We construct a polynomial which confuses MinPolyQuot, then
show that MinPolyQuot gives the wrong answer if verification
is 0; but it get the right answer if verification is 2.
The guaranteed correct answer can be obtained by passing "guaranteed()"

This program shows a simple use of three-state booleans.        
We define a quick primality test which is guaranteed to be fast 
but which sometimes has to return a verdict of "Don't know" so
it can keep its guarantee of speed.  We then see how often the  
quick test gives a definite answer, and how often it has to say 
"Don't know".                                                 

This is an example showing some basic arithmetic ops in C++. 
With a strong caution about division and computing powers.   

This is an example showing some very basic C++:  comments, 
variable declaration (and init) for basic types and        
how to print.  See also ex-c++-bool.C                      

This is an example showing basic use of booleans in C++.  
Note especially the `smart' operators for `and' and `or'. 
See also ex-c++-basic.C.                                  

This is a (harder) example showing the implemention of a simple C++ class.
It shows class definition, and use of an object of that class.            
The class contains a general factorization of an integer.  The class data 
members are `private' so their values can be seen or changed only by      
`member functions' or `friend functions'.                                 

This is an example showing some basic function definitions in C++. 
The command `return' ends computation in the function/procedure;   
in a function it also says which value to return to the caller.    
C++ barely distinguishes between "functions" (which return a     
value) and "procedures" (which return no value).                 

This is an example showing the C++ integer type "long".  There  
are other types with different bit-widths; all can be "signed"  
or "unsigned" (just for non-negative values).  Computations     
are fast, but may cause overflow -- something you should avoid! 
We give an example showing how awkward it can be to avoid or    
anticipate overflow.  There are no such problems with BigInt!   

This is an example showing some basic "for" loops in C++.    
It also shows "continue" and "break" inside a loop.        
We restrict to simple integer "for" loops.  See also examples
for vectors and iterators.                                     

This is an example showing the new style "for" loop in C++.   
See ex-c++-loop-for1.C for "continue" and "break" commands. 
We show how to state whether the elements are copied.           

This is an example showing some basic "for" loops in C++.    
It also shows "continue" and "break" inside a loop.        
We restrict to simple integer "for" loops.  See also examples
for vectors and iterators.                                     

This is an example showing some basic use of C++ vectors.    
C++ has few built-in types, but the STL (Standard Template   
Library) contains many useful extensions.  std::vector is    
is one of these extensions.  It is a homogeneous array: a    
collection of many objects of the same type, and each one    
may be accessed directly by an integer index (from 0 to n-1) 
See also ex-c++-loop-for2.C for iterating over the elements. 

This is an example showing how to translate CoCoA-5 list  
functions APPEND, FIRST & LAST into C++.  APPEND translates
nicely into push_back. Also first(L) and last(L) have nice
translations; BUT first(L,k) and last(L,k) do not have    
efficient translations -- there are usually better, but   
different techniques in C++.                              

This example illustrates use of the iterators for subsets and for tuples.  
The iterators actually work on "indexes" in the range 0 to n-1.          

This program illustrates use of some of the "conversion" functions.  
These functions convert integer/rational values from one type into     
another preserving the value -- if the conversion cannot be safely made
then this is indicated (via a boolean or an error).                    

This example program shows how to check for cyclotomicity.          
The input is always expected to be a univariate polynomial over ZZ. 
Here, two cyclotomic and one non-cyclotomic polynomial are being    
examined.

Make a copy of this file (called "foo.C", say) and put your code 
inside the procedure "program".                                  
To compile your file in the examples directory just do this:       
  make foo                                                         

CoCoALib uses C++ exceptions to inform the user that a problem has occurred.    
This simple example illustrates the CoCoALib convention for reporting an error: 
call the macro CoCoA_THROW_ERROR which both constructs the "ErrorInfo" value  
and throws it.  It also shows how to catch these CoCoALib exceptions, which are 
always objects of type "ErrorInfo".  The most useful part of a CoCoALib       
exception is its error code: after catching a CoCoALib exception we can check   
whether its code is one we expected (and can deal with).  The full list of      
possible error codes can be found in the header file CoCoA/error.H.             

This example shows how to interpret the result of a factorization. 
It creates a ring element (belonging to a polynomial ring), and    
factorizes it.  The result is a "factorization object".  We show 
how to access/use the various fields in this object.               

  "Frobby - Computations With Monomial Ideals"  
Web page: http://www.broune.com/frobby/

We simulate a long sum:
we add the summands of a long polynomial f (and f*x) one at a time,   
and do it twice to consider also the arithmetics on the coefficients. 
The advantage for geobuckets comes when f is quite long.              
Geobuckets are to be used as a temporary value;                       
the final result is then copied into a RingElem.

This code also shows how to create the "chess examples".           

This short example shows how to create ideals from one or more 
ring elements.  If there are at most 4 generators this can be  
done directly; otherwise put the generators in a vector, and   
create the ideal from the vector.                              

This short example shows how to perform various operations  
involving ideals.  Certain operations are valid only for    
ideals in a polynomial ring.                                

This short example shows an easy way of making CoCoALib programs  
handle signals (or interrupts), by converting them to exceptions. 
There are two crucial parts: create a SignalWatcher to say which  
signals to watch for, and call CheckForInterrupt when it is       
convenient to act upon the interrupting signal.                   

This example shows how to make a CoCoALib programs watch for   
signals only during a section of code.  Look at ex-interrupt1  
before looking at this example!  Compare what happens when you 
interrupt the first computation, and when you interrupt the    
second (identical) computation.                                

This example shows how to make a CoCoALib program watch for   
signals, and if one is detected, it prints extra info.  Look  
at ex-interrupt1.C and ex-interrupt2.C before looking at this.

The numeric limits of CoCoALib depend on many factors: 
some choices from the authors of CoCoALib,                  
the compilation flags of CoCoALib, which in turn depend on  
the architecture of your machine and the compilations flags 
used by the gmp and boost libraries.                        

Example program illustrating the creation of matrices, and some 
basic operations on them. 

Example program illustrating the creation of matrix views, and some    
effects of "aliasing", i.e. where there is more than one way to refer
to a single entry of the matrix.  We gives examples of creating various
views: ZeroMat, IdentityMat, transpose, submat, BlockMat2x2, ConcatHor 
and ConcatVer.

This program shows how to solve linear systems (matrix equations). 
At the moment linear system solving is only partially implemented. 
It will work if the matrix is over a field; otherwise it may fail. 

A simple example showing how a C++ vector can be viewed as a matrix.
You can even view the same vector in several different ways.        

Please note that the module code is still rather young. 

Please note that the module code is still rather young. 

This example program shows how to call an obsolescent CoCoALib function. 
You must do two things: 
(1) include the header file CoCoA/obsolescent.H 
(2) give the option AllowObsolescentFns to GlobalManager

Use of the fundamental rings ZZ and QQ.                              
Creation of ring elements (C++ type RingElem).                       
Operations allowed on elements of the same ring:                     
  zero(R) and one(R)                                                 
  a + b, a - b, a * b                                                
  -a                                                                 
  a = b   (assignment)                                               
  a == b  and  a != b  (comparison)                                  
  IsZero(a), IsOne(a), IsMinusOne(a)                                 
Moreover other operations might be allowed, for example:             
  a > b   if the ring is ordered                                     
  a / b   if exact division is possible (and implemented!)           
See ex-RingHom*.C for how to move elements from one ring to another. 

This example creates several different sorts of ring,            
and then calls PrintRingInfo on each one.                        
PrintRingInfo calls various functions to obtain information      
about each ring passed to it.  Naturally, some query functions   
make sense only for certain types of ring (e.g. NumIndets(R)).   

Symbols are used to give print names to indeterminates.  Their main   
use is as an argument to a pseudo-ctor for a PPMonoid or a polynomial 
ring -- see examples for those types.                                 

Often algorithms need one to work with an addition new indeterminate
which must be different from all indeterminates already being use.  
In CoCoALib we can create new "anonymous" indeterminates guaranteed
to be different from all others.  This examples shows how to create 
them singly, and also several all together.                         

This program illustrates the use of VerboseLog for producing progress    
reports on the various steps of an algorithm.  You must set the global   
verbosity level using the fn SetVerbosityLevel (higher values mean more  
messages are printed) immediately before the call you want to investigate
and set it back to 0 afterwards!