CoCoALib-0.9905 date: 23 May 2007


CoCoA::PPOrdering Class Reference

#include <PPOrdering.H>

List of all members.

Public Member Functions

 PPOrdering (const PPOrderingBase *ptr)
const PPOrderingBaseoperator-> () const
 Allow const member fns to be called.
const PPOrderingBasemyRawPtr () const
 Used by "downcasting" functions Is(..), As(..), etc.


Detailed Description

      Copyright (c)  2005 John Abbott
      Permission is granted to copy, distribute and/or modify this document
      under the terms of the GNU Free Documentation License, Version 1.2;
      with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
      A copy of the licence is included in the file COPYING in this directory.



User documentation for PPOrdering
=================================

An object of the class PPOrdering represents an "arithmetic" ordering on
the (multiplicative) monoid of power products, i.e. such that the
ordering respects the monoid operation (viz. s < t => r*s < r*t for all
r,s,t in the monoid).  In CoCoALib orderings and gradings are
intimately linked (for gradings see also degree.txt).

Currently, the most typical use for a PPOrdering object is as a constructor
argument to a concrete PPMonoid (see file PPMonoid.txt).  At the moment
there are four functions which create new PPOrderings:

  NewLexOrdering(NumIndets);
  NewStdDegLexOrdering(NumIndets);
  NewStdDegRevLexOrdering(NumIndets);
  NewMatrixOrdering(NumIndets, GradingDim, OrderMatrix);

The first three create respectively lex, DegLex and DevRevLex orderings on
the given number of indeterminates.  Note the use of "Std" in the names to
emphasise that they are only for standard graded polynomial rings.

The last function creates a PPOrdering given a matrix.  GradingDim
specifies how many of the rows of OrderMatrix are to be taken as
specifying the grading.


The operations on a PPOrdering object are:

  out << PPO;      // output the PPO object to channel out
  NumIndets(PPO);  // number of indeterminates the ordering is intended for
  GradingDim(PPO); // the dimension of the grading associated to the ordering
  GetMatrix(PPO);  // a matrix defining the ordering

  IsLex(PPO);          // true iff PPO is implemented as lex
  IsStdDegLex(PPO);    // true iff PPO is implemented as StdDegLex
  IsStdDegRevLex(PPO); // true iff PPO is implemented as StdDegRevLex

Thus CoCoALib supports graded polynomial rings with the restriction that the
grading be compatible with the PP ordering: i.e.  the grading comprises
simply the first k entries of the "order vector".  The GradingDim is merely
the integer k (which may be zero if there is no grading).


A normal CoCoA library user need know no more than this about PPOrderings.
CoCoA Library contributors and the curious should read on.

A recent addition.  There is also a member function:

  PPO.myMatrixCopy(M)  where M is a matrix

It fills M with a matrix which specifies the ordering PPO.  Don't use it yet.


Maintainer documentation for PPOrdering
=======================================

The general ideas behind the implementations of PPOrdering and
PPOrderingBase are analogous to those used for ring and RingBase.
PPOrdering is a simple reference counting smart-pointer class, while
PPOrderingBase hosts the intrusive reference count (so that every concrete
derived class will inherit it).

The only remaining observation to make about the simple class PPOrdering is
that I have chosen to disable assignment -- I find it hard to imagine when
it could be useful to be able to assign PPOrderings, and suspect that
allowing assignment is more likely to lead to confusion and poor programming
style.

There are four concrete PPOrderings in the namespace CoCoA::PPO.  The
implementations are all simple and straightforward except for the matrix
ordering which is a little longer and messier but still easy enough to
follow.


Bugs, shortcomings and other ideas
==================================

Must resolve the restrictions on order matrices in NewMatrixOrdering
(matrix must be square).

We need better ways to "compose" PPOrderings, i.e. to build new ones
starting from existing ones.  Max knows the sorts of operation needed
here.  Something similar to CoCoA4's BlockMatrix command is needed.

Definition at line 43 of file PPOrdering.H.


Constructor & Destructor Documentation

CoCoA::PPOrdering::PPOrdering const PPOrderingBase ptr  )  [inline, explicit]
 

Definition at line 46 of file PPOrdering.H.


Member Function Documentation

const PPOrderingBase* CoCoA::PPOrdering::operator->  )  const [inline]
 

Allow const member fns to be called.

Definition at line 48 of file PPOrdering.H.

const PPOrderingBase* CoCoA::PPOrdering::myRawPtr  )  const [inline]
 

Used by "downcasting" functions Is(..), As(..), etc.

Definition at line 49 of file PPOrdering.H.

References CoCoA::SmartPtrIRC< T >::myRawPtr().


The documentation for this class was generated from the following file:
Generated on Wed May 23 13:46:26 2007 for CoCoALib by  doxygen 1.4.6