CoCoALib-0.9905 date: 23 May 2007


CoCoA::PolyRingBase Class Reference

#include <PolyRing.H>

Inheritance diagram for CoCoA::PolyRingBase:

Inheritance graph
[legend]
List of all members.

Simple functions on polynomials

virtual const std::vector<
RingElem > & 
myIndets () const =0
virtual void myIndetPower (RawPtr rawf, std::size_t var, unsigned int exp) const =0
virtual std::size_t myNumTerms (ConstRawPtr rawf) const =0
virtual bool myIsConstant (ConstRawPtr rawf) const =0
virtual bool myIsIndet (std::size_t &index, ConstRawPtr rawf) const =0
virtual bool myIsMonomial (ConstRawPtr rawf) const =0
virtual std::size_t myStdDeg (ConstRawPtr rawf) const =0
virtual long myLog (ConstRawPtr rawf, std::size_t var) const =0
virtual ConstRefRingElem myLC (ConstRawPtr rawf) const =0
virtual void myContent (RawPtr rawcontent, ConstRawPtr rawf) const =0
virtual void myRemoveBigContent (RawPtr rawf) const =0
virtual void myMulByCoeff (RawPtr rawf, ConstRawPtr rawc) const =0
virtual void myDivByCoeff (RawPtr rawf, ConstRawPtr rawc) const =0
virtual void myDeriv (RawPtr rawlhs, ConstRawPtr rawf, ConstRawPtr rawx) const =0
 lhs = deriv(f, x)

Public Types

typedef RingElemConstRawPtr ConstRawPtr
typedef RingElemRawPtr RawPtr

Public Member Functions

virtual std::size_t myNumIndets () const =0
virtual const ringmyCoeffRing () const =0
virtual RingHom myHomCtor (const ring &codomain, const RingHom &CoeffHom, const std::vector< RingElem > &IndetImages) const =0
virtual const RingHommyCoeffEmbeddingHom () const =0
virtual void myCharacteristic (ZZ &p) const =0
virtual bool IamCommutative () const =0
virtual bool IamIntegralDomain () const =0
virtual bool IamGCDDomain () const
 Defaults to true.
virtual bool IamOrderedDomain () const
 Defaults to false.
virtual bool IamField () const =0
virtual ConstRefRingElem myZero () const =0
virtual ConstRefRingElem myOne () const =0
virtual RingElemRawPtr myNew () const =0
virtual RingElemRawPtr myNew (long int n) const =0
virtual RingElemRawPtr myNew (const ZZ &N) const =0
virtual RingElemRawPtr myNew (ConstRawPtr rawx) const =0
virtual void myDelete (RawPtr rawx) const =0
 destroys x (incl all resources)
virtual void mySwap (RawPtr rawx, RawPtr rawy) const =0
 swap(x, y)
virtual void myAssign (RawPtr rawlhs, ConstRawPtr rawx) const =0
 lhs = x
virtual void myAssign (RawPtr rawlhs, long n) const =0
 lhs = n
virtual void myAssign (RawPtr rawlhs, const ZZ &N) const =0
 lhs = N
virtual void myAssignZero (RawPtr rawlhs) const =0
 lhs = 0
virtual void myNegate (RawPtr rawlhs, ConstRawPtr rawx) const =0
 lhs = -x
virtual void myAdd (RawPtr rawlhs, ConstRawPtr rawx, ConstRawPtr rawy) const =0
 lhs = x+y
virtual void mySub (RawPtr rawlhs, ConstRawPtr rawx, ConstRawPtr rawy) const =0
 lhs = x-y
virtual void myMul (RawPtr rawlhs, ConstRawPtr rawx, ConstRawPtr rawy) const =0
 lhs = x*y
virtual void myDiv (RawPtr rawlhs, ConstRawPtr rawx, ConstRawPtr rawy) const =0
 lhs = x/y
virtual bool myIsDivisible (RawPtr rawlhs, ConstRawPtr rawx, ConstRawPtr rawy) const =0
 lhs = x/y, if divisible
virtual bool myIsInvertible (ConstRawPtr rawx) const
 true iff x is invertible
virtual void myGcd (RawPtr rawlhs, ConstRawPtr rawx, ConstRawPtr rawy) const
 lhs = gcd(x,y) if GCDDomain;
virtual void myGcdQuot (RawPtr rawlhs, RawPtr rawxquot, RawPtr rawyquot, ConstRawPtr rawx, ConstRawPtr rawy) const
 lhs = gcd(x,y) xquot = x/gcd, yquot = y/gcd if GCDDomain;
virtual void myExgcd (RawPtr rawlhs, RawPtr rawxcofac, RawPtr rawycofac, ConstRawPtr rawx, ConstRawPtr rawy) const
 lhs = gcd(x,y) = xcofac*x + ycofac*y if GCDDomain;
void myPower (RawPtr rawlhs, ConstRawPtr rawx, unsigned long n) const
 lhs = x^n, n>=0
void myPower (RawPtr rawlhs, ConstRawPtr rawx, const ZZ &N) const
 lhs = x^N, N>=0
virtual void mySymbols (std::vector< symbol > &SymList) const
 append symbols in ring to SymList
virtual void myOutput (std::ostream &out, ConstRawPtr rawx) const =0
 out << x
virtual void myOutput (OpenMathOutput &OMOut, ConstRawPtr rawx) const =0
 OMOut << x.
virtual bool myIsPrintAtom (ConstRawPtr rawx) const
 x^n may be printed without parentheses
virtual bool myIsPrintedWithMinus (ConstRawPtr rawx) const
 first character of x printed is a minus sign
virtual void myOutputSelf (std::ostream &out) const =0
 out << R
virtual void myOutputSelf (OpenMathOutput &OMOut) const =0
 OMOut << R.
virtual bool myIsZero (ConstRawPtr rawx) const =0
 x == 0
virtual bool myIsOne (ConstRawPtr rawx) const =0
 x == 1
virtual bool myIsMinusOne (ConstRawPtr rawx) const
 x == -1
virtual bool myIsInteger (ZZ &N, ConstRawPtr rawx) const =0
 true iff x is integer
virtual bool myIsRational (ZZ &N, ZZ &D, ConstRawPtr rawx) const =0
 true iff x is rational
virtual bool myIsZeroAddMul (RawPtr rawlhs, ConstRawPtr rawy, ConstRawPtr rawz) const
 lhs += y*z, result says whether lhs == 0.
virtual bool myIsEqual (ConstRawPtr rawx, ConstRawPtr rawy) const =0
 x == y
virtual int myCmp (ConstRawPtr rawx, ConstRawPtr rawy) const
 result is <0, =0, >0 according as x<y, x=y, x>y
virtual int mySign (ConstRawPtr rawx) const
 -1,0,+1 according as x <0,=0,>0
virtual ideal myIdealCtor (const std::vector< RingElem > &gens) const =0
virtual RingHom myCompose (const RingHom &phi, const RingHom &theta) const =0
 phi(theta(...))

Protected Member Functions

virtual void myPowerSmallExp (RawPtr rawlhs, ConstRawPtr rawx, unsigned long n) const =0
 lhs = x^n (non-trivial)
virtual void myPowerBigExp (RawPtr rawlhs, ConstRawPtr rawx, const ZZ &N) const
 lhs = x^N (non-triv, N large); default gives error
void mySequentialPower (RawPtr rawlhs, ConstRawPtr rawx, unsigned long n) const
 lhs = x^n
void myBinaryPower (RawPtr rawlhs, ConstRawPtr rawx, unsigned long n) const
 lhs = x^n
void myBinaryPower (RawPtr rawlhs, ConstRawPtr rawx, const ZZ &N) const
 lhs = x^N
void myGcdInField (RawPtr rawlhs, ConstRawPtr rawx, ConstRawPtr rawy) const
 lhs = gcd(x, y) in a field
void myRefCountInc () const
 increments ref count
void myRefCountDec () const
 decrements ref count, and self destructs if count becomes 0
void myRefCountZero () const
 sets myRefCount to 0

Static Protected Member Functions

static std::size_t NewRingID ()

Protected Attributes

const std::size_t myID

Friends

std::size_t ID (const ring &R)

Detailed Description

Definition at line 40 of file PolyRing.H.


Member Typedef Documentation

typedef RingElemConstRawPtr CoCoA::RingBase::ConstRawPtr [inherited]
 

Definition at line 180 of file ring.H.

typedef RingElemRawPtr CoCoA::RingBase::RawPtr [inherited]
 

Definition at line 181 of file ring.H.


Member Function Documentation

virtual std::size_t CoCoA::PolyRingBase::myNumIndets  )  const [pure virtual]
 

virtual const ring& CoCoA::PolyRingBase::myCoeffRing  )  const [pure virtual]
 

virtual const std::vector<RingElem>& CoCoA::PolyRingBase::myIndets  )  const [pure virtual]
 

virtual void CoCoA::PolyRingBase::myIndetPower RawPtr  rawf,
std::size_t  var,
unsigned int  exp
const [pure virtual]
 

virtual std::size_t CoCoA::PolyRingBase::myNumTerms ConstRawPtr  rawf  )  const [pure virtual]
 

virtual bool CoCoA::PolyRingBase::myIsConstant ConstRawPtr  rawf  )  const [pure virtual]
 

Implemented in CoCoA::SparsePolyRingBase.

virtual bool CoCoA::PolyRingBase::myIsIndet std::size_t &  index,
ConstRawPtr  rawf
const [pure virtual]
 

Implemented in CoCoA::SparsePolyRingBase.

virtual bool CoCoA::PolyRingBase::myIsMonomial ConstRawPtr  rawf  )  const [pure virtual]
 

virtual std::size_t CoCoA::PolyRingBase::myStdDeg ConstRawPtr  rawf  )  const [pure virtual]
 

Implemented in CoCoA::SparsePolyRingBase.

virtual long CoCoA::PolyRingBase::myLog ConstRawPtr  rawf,
std::size_t  var
const [pure virtual]
 

virtual ConstRefRingElem CoCoA::PolyRingBase::myLC ConstRawPtr  rawf  )  const [pure virtual]
 

virtual void CoCoA::PolyRingBase::myContent RawPtr  rawcontent,
ConstRawPtr  rawf
const [pure virtual]
 

Implemented in CoCoA::SparsePolyRingBase.

virtual void CoCoA::PolyRingBase::myRemoveBigContent RawPtr  rawf  )  const [pure virtual]
 

Implemented in CoCoA::SparsePolyRingBase.

virtual void CoCoA::PolyRingBase::myMulByCoeff RawPtr  rawf,
ConstRawPtr  rawc
const [pure virtual]
 

virtual void CoCoA::PolyRingBase::myDivByCoeff RawPtr  rawf,
ConstRawPtr  rawc
const [pure virtual]
 

virtual void CoCoA::PolyRingBase::myDeriv RawPtr  rawlhs,
ConstRawPtr  rawf,
ConstRawPtr  rawx
const [pure virtual]
 

lhs = deriv(f, x)

virtual RingHom CoCoA::PolyRingBase::myHomCtor const ring codomain,
const RingHom CoeffHom,
const std::vector< RingElem > &  IndetImages
const [pure virtual]
 

Implemented in CoCoA::SparsePolyRingBase.

virtual const RingHom& CoCoA::PolyRingBase::myCoeffEmbeddingHom  )  const [pure virtual]
 

static std::size_t CoCoA::RingBase::NewRingID  )  [static, protected, inherited]
 

virtual void CoCoA::RingBase::myCharacteristic ZZ p  )  const [pure virtual, inherited]
 

virtual bool CoCoA::RingBase::IamCommutative  )  const [pure virtual, inherited]
 

virtual bool CoCoA::RingBase::IamIntegralDomain  )  const [pure virtual, inherited]
 

virtual bool CoCoA::RingBase::IamGCDDomain  )  const [virtual, inherited]
 

Defaults to true.

virtual bool CoCoA::RingBase::IamOrderedDomain  )  const [virtual, inherited]
 

Defaults to false.

virtual bool CoCoA::RingBase::IamField  )  const [pure virtual, inherited]
 

virtual ConstRefRingElem CoCoA::RingBase::myZero  )  const [pure virtual, inherited]
 

virtual ConstRefRingElem CoCoA::RingBase::myOne  )  const [pure virtual, inherited]
 

virtual RingElemRawPtr CoCoA::RingBase::myNew  )  const [pure virtual, inherited]
 

virtual RingElemRawPtr CoCoA::RingBase::myNew long int  n  )  const [pure virtual, inherited]
 

virtual RingElemRawPtr CoCoA::RingBase::myNew const ZZ N  )  const [pure virtual, inherited]
 

virtual RingElemRawPtr CoCoA::RingBase::myNew ConstRawPtr  rawx  )  const [pure virtual, inherited]
 

virtual void CoCoA::RingBase::myDelete RawPtr  rawx  )  const [pure virtual, inherited]
 

destroys x (incl all resources)

virtual void CoCoA::RingBase::mySwap RawPtr  rawx,
RawPtr  rawy
const [pure virtual, inherited]
 

swap(x, y)

virtual void CoCoA::RingBase::myAssign RawPtr  rawlhs,
ConstRawPtr  rawx
const [pure virtual, inherited]
 

lhs = x

virtual void CoCoA::RingBase::myAssign RawPtr  rawlhs,
long  n
const [pure virtual, inherited]
 

lhs = n

virtual void CoCoA::RingBase::myAssign RawPtr  rawlhs,
const ZZ N
const [pure virtual, inherited]
 

lhs = N

virtual void CoCoA::RingBase::myAssignZero RawPtr  rawlhs  )  const [pure virtual, inherited]
 

lhs = 0

virtual void CoCoA::RingBase::myNegate RawPtr  rawlhs,
ConstRawPtr  rawx
const [pure virtual, inherited]
 

lhs = -x

virtual void CoCoA::RingBase::myAdd RawPtr  rawlhs,
ConstRawPtr  rawx,
ConstRawPtr  rawy
const [pure virtual, inherited]
 

lhs = x+y

virtual void CoCoA::RingBase::mySub RawPtr  rawlhs,
ConstRawPtr  rawx,
ConstRawPtr  rawy
const [pure virtual, inherited]
 

lhs = x-y

virtual void CoCoA::RingBase::myMul RawPtr  rawlhs,
ConstRawPtr  rawx,
ConstRawPtr  rawy
const [pure virtual, inherited]
 

lhs = x*y

virtual void CoCoA::RingBase::myDiv RawPtr  rawlhs,
ConstRawPtr  rawx,
ConstRawPtr  rawy
const [pure virtual, inherited]
 

lhs = x/y

virtual bool CoCoA::RingBase::myIsDivisible RawPtr  rawlhs,
ConstRawPtr  rawx,
ConstRawPtr  rawy
const [pure virtual, inherited]
 

lhs = x/y, if divisible

virtual bool CoCoA::RingBase::myIsInvertible ConstRawPtr  rawx  )  const [virtual, inherited]
 

true iff x is invertible

virtual void CoCoA::RingBase::myGcd RawPtr  rawlhs,
ConstRawPtr  rawx,
ConstRawPtr  rawy
const [virtual, inherited]
 

lhs = gcd(x,y) if GCDDomain;

virtual void CoCoA::RingBase::myGcdQuot RawPtr  rawlhs,
RawPtr  rawxquot,
RawPtr  rawyquot,
ConstRawPtr  rawx,
ConstRawPtr  rawy
const [virtual, inherited]
 

lhs = gcd(x,y) xquot = x/gcd, yquot = y/gcd if GCDDomain;

virtual void CoCoA::RingBase::myExgcd RawPtr  rawlhs,
RawPtr  rawxcofac,
RawPtr  rawycofac,
ConstRawPtr  rawx,
ConstRawPtr  rawy
const [virtual, inherited]
 

lhs = gcd(x,y) = xcofac*x + ycofac*y if GCDDomain;

void CoCoA::RingBase::myPower RawPtr  rawlhs,
ConstRawPtr  rawx,
unsigned long  n
const [inherited]
 

lhs = x^n, n>=0

void CoCoA::RingBase::myPower RawPtr  rawlhs,
ConstRawPtr  rawx,
const ZZ N
const [inherited]
 

lhs = x^N, N>=0

virtual void CoCoA::RingBase::mySymbols std::vector< symbol > &  SymList  )  const [virtual, inherited]
 

append symbols in ring to SymList

virtual void CoCoA::RingBase::myOutput std::ostream &  out,
ConstRawPtr  rawx
const [pure virtual, inherited]
 

out << x

virtual void CoCoA::RingBase::myOutput OpenMathOutput OMOut,
ConstRawPtr  rawx
const [pure virtual, inherited]
 

OMOut << x.

virtual bool CoCoA::RingBase::myIsPrintAtom ConstRawPtr  rawx  )  const [virtual, inherited]
 

x^n may be printed without parentheses

virtual bool CoCoA::RingBase::myIsPrintedWithMinus ConstRawPtr  rawx  )  const [virtual, inherited]
 

first character of x printed is a minus sign

virtual void CoCoA::RingBase::myOutputSelf std::ostream &  out  )  const [pure virtual, inherited]
 

out << R

virtual void CoCoA::RingBase::myOutputSelf OpenMathOutput OMOut  )  const [pure virtual, inherited]
 

OMOut << R.

virtual bool CoCoA::RingBase::myIsZero ConstRawPtr  rawx  )  const [pure virtual, inherited]
 

x == 0

virtual bool CoCoA::RingBase::myIsOne ConstRawPtr  rawx  )  const [pure virtual, inherited]
 

x == 1

virtual bool CoCoA::RingBase::myIsMinusOne ConstRawPtr  rawx  )  const [virtual, inherited]
 

x == -1

virtual bool CoCoA::RingBase::myIsInteger ZZ N,
ConstRawPtr  rawx
const [pure virtual, inherited]
 

true iff x is integer

virtual bool CoCoA::RingBase::myIsRational ZZ N,
ZZ D,
ConstRawPtr  rawx
const [pure virtual, inherited]
 

true iff x is rational

virtual bool CoCoA::RingBase::myIsZeroAddMul RawPtr  rawlhs,
ConstRawPtr  rawy,
ConstRawPtr  rawz
const [virtual, inherited]
 

lhs += y*z, result says whether lhs == 0.

virtual bool CoCoA::RingBase::myIsEqual ConstRawPtr  rawx,
ConstRawPtr  rawy
const [pure virtual, inherited]
 

x == y

virtual int CoCoA::RingBase::myCmp ConstRawPtr  rawx,
ConstRawPtr  rawy
const [virtual, inherited]
 

result is <0, =0, >0 according as x<y, x=y, x>y

virtual int CoCoA::RingBase::mySign ConstRawPtr  rawx  )  const [virtual, inherited]
 

-1,0,+1 according as x <0,=0,>0

virtual ideal CoCoA::RingBase::myIdealCtor const std::vector< RingElem > &  gens  )  const [pure virtual, inherited]
 

Implemented in CoCoA::SparsePolyRingBase.

virtual RingHom CoCoA::RingBase::myCompose const RingHom phi,
const RingHom theta
const [pure virtual, inherited]
 

phi(theta(...))

Implemented in CoCoA::SparsePolyRingBase.

virtual void CoCoA::RingBase::myPowerSmallExp RawPtr  rawlhs,
ConstRawPtr  rawx,
unsigned long  n
const [protected, pure virtual, inherited]
 

lhs = x^n (non-trivial)

virtual void CoCoA::RingBase::myPowerBigExp RawPtr  rawlhs,
ConstRawPtr  rawx,
const ZZ N
const [protected, virtual, inherited]
 

lhs = x^N (non-triv, N large); default gives error

void CoCoA::RingBase::mySequentialPower RawPtr  rawlhs,
ConstRawPtr  rawx,
unsigned long  n
const [protected, inherited]
 

lhs = x^n

void CoCoA::RingBase::myBinaryPower RawPtr  rawlhs,
ConstRawPtr  rawx,
unsigned long  n
const [protected, inherited]
 

lhs = x^n

void CoCoA::RingBase::myBinaryPower RawPtr  rawlhs,
ConstRawPtr  rawx,
const ZZ N
const [protected, inherited]
 

lhs = x^N

void CoCoA::RingBase::myGcdInField RawPtr  rawlhs,
ConstRawPtr  rawx,
ConstRawPtr  rawy
const [protected, inherited]
 

lhs = gcd(x, y) in a field

void CoCoA::IntrusiveReferenceCount::myRefCountInc  )  const [inline, protected, inherited]
 

increments ref count

Definition at line 86 of file SmartPtrIRC.H.

Referenced by CoCoA::ModuleBase::ModuleBase().

void CoCoA::IntrusiveReferenceCount::myRefCountDec  )  const [inline, protected, inherited]
 

decrements ref count, and self destructs if count becomes 0

Definition at line 91 of file SmartPtrIRC.H.

void CoCoA::IntrusiveReferenceCount::myRefCountZero  )  const [inline, protected, inherited]
 

sets myRefCount to 0

Definition at line 97 of file SmartPtrIRC.H.


Friends And Related Function Documentation

std::size_t ID const ring R  )  [friend, inherited]
 

Definition at line 419 of file ring.H.


Member Data Documentation

const std::size_t CoCoA::RingBase::myID [protected, inherited]
 

Definition at line 171 of file ring.H.


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