      PPVector
      Copyright (c)  2008 Anna Bigatti
      GNU Free Documentation License, Version 1.2
%!includeconf: ../aux-txt2tags/config.t2t
      TeXTitle{PPVector}{Anna Bigatti}

modernise

== class PPVector ==
%======================================================================

**WARNING THIS IS STILL A PRELIMINARY IMPLEMENTATION** as indicated by
the names of the implementation files: ``TmpPPVector.H`` and ``TmpPPVector.C``.

This class is for dealing with lists of power-products.

This class has been designed to be used by monomial ideal operations,
Hilbert, and Mayer-Vietoris trees.

The key functions interpret the list as generators of a monomial
ideal: interreduction, divisibility test (ideal membership), lcms
(ideal intersection).

The elements are [[PPWithMask]], to make fast divisibility tests.
Constructor requires a [[PPMonoid]] and a ``DivMaskRule`` (see
[[DivMask]]), so that the user can choose the best suited
implementations (mostly depending on the number of indeterminates and
on the size of the exponents).

=== Examples ===
- [ex-PPVector.C ../../examples/index.html#ex-PPVector.C]


== Fields and main functions ==
%======================================================================
Member fields are
```
    PPMonoid myPPM;
    DivMaskRule myDMR;
    std::vector<PPWithMask> myVec;
```
=== Utility functions ===
- ``PPMonoid PPM(const PPVector& PPs)``
- ``DivMaskRule DMR(const PPVector& PPs)``
- ``std::ostream& operator<<(std::ostream&, PPVector)``
- ``bool IsEmpty(const PPVector& PPs)``
- ``long len(const PPVector& PPs)``
- ``void convert(std::vector<RingElem>& v, ring P, const PPVector& PPs)``
  converts PP's into RingElem's
- ``void convert(PPVector PPs, const std::vector<RingElem>& v)``
  converts vector<RingElem> (if monomial!) into PPVector
- ``void PushBack(PPVector& PPs, ConstRefPPMonoidElem pp)``
  if owner(pp) != PPM(PPs) it maps it
- ``void PushBackPopBack(PPVector& ToPPs, PPVector& FromPPs)``
  move last PP from ``FromPPs`` into ``ToPPs``
- ``void swap(PPVector& PPs1, PPVector& PPs2)``
   swap PPs1 and PPs1


=== Mathemetical functions ===
- ``bool IsDivisible(const PPWithMask& pp, const PPVector& ByL);``
  true is pp is divisible by an element of L
- ``bool IsDivisible(ConstRefPPMonoidElem pp, const PPVector& ByL);``
  true is pp is divisible by an element of L
- ``void interreduce(PPVector& PPs);``
  interreduce PPs (NOT exception clean)
- ``void InterreduceSort(PPVector& PPs);``
  interreduce and sort PPs (NOT exception clean)
- ``void lcms(PPVector& PPs, const PPVector& PPs1, const PPVector& PPs2);``
   all the lcm between elements of PPs1 and PPs2, effectively the
   generators of the intersection ideal



== Bugs, Shortcomings and other ideas ==
%======================================================================

=== Abstract Class ===
%----------------------------------------------------------------------

There was an attempt to make it an abstract class, ``PPVectorBase``, made
of abstract ``PPVectorElem``, with the plan to have concrete classes a
vector of [[PPWithMask]], of ``PPMonoidElem``, and of square-free pps
(which cannot make a [[PPMonoid]] because x*x is not square-free).

But this failed because most operations would need to know the type of
the elements in the vector making it more suitable for templates.  But
- (1) I much prefer inheritance (mathematically cleaner) and 
- (2) probably all this generality is useless.


So it was sadly abandoned.
