# PPVector

© 2008 Anna Bigatti
GNU Free Documentation License, Version 1.2

- class PPVector
  - Examples
- Fields and main functions
  - Utility functions
  - Mathemetical functions
- Bugs, Shortcomings and other ideas
  - Abstract Class

CoCoALib Documentation Index

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

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