CoCoALib Examples

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                                                         

It offers the function "PrimaryDecomposition" for a mon'l sqfr ideal
which will be included in CoCoALib (sooner or later).

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

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)

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 the various parts of this object.                    

This example shows how to specify that a CoCoA::GMPAllocator be used for 
managing the memory for small GMP values.  If you do computations        
involving many small big-integers (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 CoCoA::GMPAllocator is to be used.                    

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 code also shows how to create the "chess examples".           

This example shows how to change the global output channel GlobalOutput. 
The most important point is that the variable  out  is at top-level      
inside program().  If it were inside the then-block, the ofstream        
would be destroyed as soon as control leaves the then-block; and at      
that point the global output stream would contain a dangling reference.  

Please note that the matrix code is still rather young. 

Please note that the module code is still rather young. 

Example of use of the Mayer-Vietoris trees.  

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

NewNormalizConeLong gives more speed 
NewNormalizConeMPZ  gives reliability 

the input file can be specified in the source code
                                                           

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

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 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 priority 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...   

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        
PPMonoidEvZZ: stores the Exponent vector at ZZ's                    
              necessary if you use big exponents (>2^10)            
              obviously slow   

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 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.                

Program giving example of basic arithmetic with exact rational numbers 
represented as values of type QQ.  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 QQ value and an element of the ring RingQ, contrast this example     
with ex-RingQ1.C.                                                      

It offers the function "QuotientBasisRec"          
which will be included in CoCoALib (sooner or later).

This program uses a RandomSource object 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.                      

CoCoALib offers a pseudorandom bit generator.  The generator can be   
seeded when it is created; this allows different pseudorandom         
sequences to be produced, though the sequence is completely determined
by the initial seed value.  The `prob' 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.                                                     

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.                                                     

Use of the fundamental rings Z and Q.                                
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)).   

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.                                  

The program asks the user for the characteristic N, and then tries 
different ways of making Z mod N.

CanonicalHom is an easy way to make these homomorphisms:  
R --> R/I,    R --> R[x],   R --> FractionField(R),       
R --> R,      Q --> R,      Z --> 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;                        

Familiarize yourself with the example ex-RingZ1.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).                   

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.                                   

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.                                 

This program illustrates that ZZ values can be used much like normal C++ ints 
except that there is a almost no limit on the magnitude of the values. 
It shows use of some more advanced functions for ZZ values.            
NB If you need extreme efficiency then use the GMP library directly.   

This program illustrates basic operations on ZZ 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-RingZ1.                                      

This program illustrates that ZZ 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-RingZ1.