CoCoALib-0.9905 date: 23 May 2007


CoCoA::SparsePolyRingBase Class Reference

#include <SparsePolyRing.H>

Inheritance diagram for CoCoA::SparsePolyRingBase:

Inheritance graph
[legend]
Collaboration diagram for CoCoA::SparsePolyRingBase:

Collaboration graph
[legend]
List of all members.

Special functions on polynomials needed for implementing Buchberger's Algorithm

enum  SkipLMFlag { SkipLMg, DontSkipLMg }
virtual bool myIsZeroAddLCs (RawPtr rawf, RawPtr rawg) const =0
 f+=LM(g); g-=LM(g); assumes LPP(f)==LPP(g); returns LC(f)+LC(g)==0
virtual void myMoveLM (RawPtr rawf, RawPtr rawg) const =0
 f+=LM(g); g-=LM(g); assumes LM(f)<LM(g)
virtual void myDeleteLM (RawPtr rawf) const =0
virtual void myDivLM (RawPtr rawlhs, ConstRawPtr rawf, ConstRawPtr rawg) const =0
 lhs=div(LM(f),LM(g)); assumes f!=0,g!=0
virtual int myCmpLPP (ConstRawPtr rawf, ConstRawPtr rawg) const =0
 cmp(LPP(f),LPP(g)); assumes f!=0,g!=0
virtual void myAddClear (RawPtr rawf, RawPtr rawg) const =0
 f+=g; g=0;
virtual void myAppendClear (RawPtr rawf, RawPtr rawg) const =0
 f+=g; g=0; appends g to f with no checks
virtual void myAddMul (RawPtr rawf, ConstRawPtr rawh, ConstRawPtr rawg) const =0
 f += LM(h)*g
virtual void myAddMul (RawPtr rawf, ConstRawPtr rawh, ConstRawPtr rawg, SkipLMFlag) const =0
 f += LM(h)*g
virtual void myReductionStep (RawPtr rawf, ConstRawPtr rawg) const =0
virtual void myReductionStepGCD (RawPtr rawf, ConstRawPtr rawg, RefRingElem FScale) const =0

Public Types

typedef RingElemConstRawPtr ConstRawPtr
typedef RingElemRawPtr RawPtr

Public Member Functions

virtual std::size_t myNumIndets () const =0
virtual const ringmyCoeffRing () 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
Member functions every concrete SparsePolyRing implementation must have in addition to those of PolyRingBase.
virtual const PPMonoidmyPPM () const =0
virtual std::size_t myGradingDim () const
virtual bool myIsValid (ConstRawPtr rawf) const
 true iff f is a valid representation, otherwise error
virtual std::size_t myStdDeg (ConstRawPtr rawf) const
 returns standard degree of f
virtual long myLog (ConstRawPtr rawf, size_t index) const
 returns the maximum exponent of x[index] in f
virtual ConstRefPPMonoidElem myLPP (ConstRawPtr rawf) const =0
virtual void myContent (RawPtr rawcontent, ConstRawPtr rawf) const
virtual void myRemoveBigContent (RawPtr rawf) const
virtual void myMulByPP (RawPtr rawf, PPMonoidElemConstRawPtr rawpp) const =0
functions inherited from ring with a single implementation for all SparsePolyRing implementations
virtual void myMul (RawPtr rawlhs, ConstRawPtr rawx, ConstRawPtr rawy) const
 lhs = x*y
virtual void myOutput (std::ostream &out, ConstRawPtr rawx) const
 out << x
virtual bool myIsPrintAtom (ConstRawPtr rawx) const
 x^n may be printed without parentheses
virtual void myOutput (OpenMathOutput &OMOut, ConstRawPtr rawx) const
 OMOut << x.
virtual bool myIsOne (ConstRawPtr rawf) const
 true iff rawf == 1
virtual bool myIsMinusOne (ConstRawPtr rawf) const
 true iff rawf == -1
virtual bool myIsConstant (ConstRawPtr rawf) const
 true iff rawf == c (possibly 0)
virtual bool myIsIndet (std::size_t &IndetIndex, ConstRawPtr rawf) const
 true iff rawf is x[IndetIndex]
virtual bool myIsHomogeneous (ConstRawPtr rawf) const
 true iff f is homogeneous
virtual void myHomog (RawPtr rawfHom, ConstRawPtr rawf, ConstRawPtr rawh) const
 fHom = f homogenized with h (indet of wdeg 1, GrDim=1)
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 bool myIsInteger (ZZ &N, ConstRawPtr rawx) const
 true iff x is integer
virtual bool myIsRational (ZZ &N, ZZ &D, ConstRawPtr rawx) const
 true iff x is rational
virtual ideal myIdealCtor (const std::vector< RingElem > &gens) const
virtual void myPowerSmallExp (RawPtr rawlhs, ConstRawPtr rawx, unsigned long n) const
Functions for creating/building polynomials
virtual RingElem myMonomial (ConstRawPtr rawc, PPMonoidElemConstRawPtr rawpp) const =0
virtual SparsePolyIter myBeginIter (ConstRawPtr rawf) const =0
virtual SparsePolyIter myEndIter (ConstRawPtr rawf) const =0
virtual void myPushFront (RawPtr rawf, ConstRawPtr rawc, const std::vector< long > &expv) const =0
virtual void myPushBack (RawPtr rawf, ConstRawPtr rawc, const std::vector< long > &expv) const =0
 SHOULD BE vector<ZZ> ????
Functions for homomorphisms
RingHom myHomCtor (const ring &codomain, const RingHom &CoeffHom, const std::vector< RingElem > &IndetImages) const
RingHom myCompose (const RingHom &phi, const RingHom &theta) const
 phi(theta(...))
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 myIsMonomial (ConstRawPtr rawf) const =0
virtual long myLog (ConstRawPtr rawf, std::size_t var) const =0
virtual ConstRefRingElem myLC (ConstRawPtr 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)

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)

Classes

class  CoeffEmbeddingHomImpl
class  HomImpl
class  IdealImpl

Detailed Description

Definition at line 108 of file SparsePolyRing.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 Enumeration Documentation

enum CoCoA::SparsePolyRingBase::SkipLMFlag
 

Enumerator:
SkipLMg 
DontSkipLMg 

Definition at line 172 of file SparsePolyRing.H.


Member Function Documentation

virtual const PPMonoid& CoCoA::SparsePolyRingBase::myPPM  )  const [pure virtual]
 

Referenced by myGradingDim().

std::size_t CoCoA::SparsePolyRingBase::myGradingDim  )  const [inline, virtual]
 

Definition at line 316 of file SparsePolyRing.H.

References CoCoA::GradingDim(), and myPPM().

virtual bool CoCoA::SparsePolyRingBase::myIsValid ConstRawPtr  rawf  )  const [virtual]
 

true iff f is a valid representation, otherwise error

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

returns standard degree of f

Implements CoCoA::PolyRingBase.

virtual long CoCoA::SparsePolyRingBase::myLog ConstRawPtr  rawf,
size_t  index
const [virtual]
 

returns the maximum exponent of x[index] in f

virtual ConstRefPPMonoidElem CoCoA::SparsePolyRingBase::myLPP ConstRawPtr  rawf  )  const [pure virtual]
 

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

Implements CoCoA::PolyRingBase.

virtual void CoCoA::SparsePolyRingBase::myRemoveBigContent RawPtr  rawf  )  const [virtual]
 

Implements CoCoA::PolyRingBase.

virtual void CoCoA::SparsePolyRingBase::myMulByPP RawPtr  rawf,
PPMonoidElemConstRawPtr  rawpp
const [pure virtual]
 

virtual void CoCoA::SparsePolyRingBase::myMul RawPtr  rawlhs,
ConstRawPtr  rawx,
ConstRawPtr  rawy
const [virtual]
 

lhs = x*y

virtual void CoCoA::SparsePolyRingBase::myOutput std::ostream &  out,
ConstRawPtr  rawx
const [virtual]
 

out << x

virtual bool CoCoA::SparsePolyRingBase::myIsPrintAtom ConstRawPtr  rawx  )  const [virtual]
 

x^n may be printed without parentheses

virtual void CoCoA::SparsePolyRingBase::myOutput OpenMathOutput OMOut,
ConstRawPtr  rawx
const [virtual]
 

OMOut << x.

virtual bool CoCoA::SparsePolyRingBase::myIsOne ConstRawPtr  rawf  )  const [virtual]
 

true iff rawf == 1

virtual bool CoCoA::SparsePolyRingBase::myIsMinusOne ConstRawPtr  rawf  )  const [virtual]
 

true iff rawf == -1

virtual bool CoCoA::SparsePolyRingBase::myIsConstant ConstRawPtr  rawf  )  const [virtual]
 

true iff rawf == c (possibly 0)

Implements CoCoA::PolyRingBase.

virtual bool CoCoA::SparsePolyRingBase::myIsIndet std::size_t &  IndetIndex,
ConstRawPtr  rawf
const [virtual]
 

true iff rawf is x[IndetIndex]

Implements CoCoA::PolyRingBase.

virtual bool CoCoA::SparsePolyRingBase::myIsHomogeneous ConstRawPtr  rawf  )  const [virtual]
 

true iff f is homogeneous

virtual void CoCoA::SparsePolyRingBase::myHomog RawPtr  rawfHom,
ConstRawPtr  rawf,
ConstRawPtr  rawh
const [virtual]
 

fHom = f homogenized with h (indet of wdeg 1, GrDim=1)

virtual bool CoCoA::SparsePolyRingBase::myIsInvertible ConstRawPtr  rawx  )  const [virtual]
 

true iff x is invertible

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

lhs = gcd(x,y) if GCDDomain;

virtual bool CoCoA::SparsePolyRingBase::myIsInteger ZZ N,
ConstRawPtr  rawx
const [virtual]
 

true iff x is integer

virtual bool CoCoA::SparsePolyRingBase::myIsRational ZZ N,
ZZ D,
ConstRawPtr  rawx
const [virtual]
 

true iff x is rational

virtual ideal CoCoA::SparsePolyRingBase::myIdealCtor const std::vector< RingElem > &  gens  )  const [virtual]
 

Implements CoCoA::RingBase.

virtual void CoCoA::SparsePolyRingBase::myPowerSmallExp RawPtr  rawlhs,
ConstRawPtr  rawx,
unsigned long  n
const [virtual]
 

virtual RingElem CoCoA::SparsePolyRingBase::myMonomial ConstRawPtr  rawc,
PPMonoidElemConstRawPtr  rawpp
const [pure virtual]
 

virtual SparsePolyIter CoCoA::SparsePolyRingBase::myBeginIter ConstRawPtr  rawf  )  const [pure virtual]
 

virtual SparsePolyIter CoCoA::SparsePolyRingBase::myEndIter ConstRawPtr  rawf  )  const [pure virtual]
 

virtual void CoCoA::SparsePolyRingBase::myPushFront RawPtr  rawf,
ConstRawPtr  rawc,
const std::vector< long > &  expv
const [pure virtual]
 

virtual void CoCoA::SparsePolyRingBase::myPushBack RawPtr  rawf,
ConstRawPtr  rawc,
const std::vector< long > &  expv
const [pure virtual]
 

SHOULD BE vector<ZZ> ????

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

Implements CoCoA::PolyRingBase.

RingHom CoCoA::SparsePolyRingBase::myCompose const RingHom phi,
const RingHom theta
const [virtual]
 

phi(theta(...))

Implements CoCoA::RingBase.

virtual bool CoCoA::SparsePolyRingBase::myIsZeroAddLCs RawPtr  rawf,
RawPtr  rawg
const [pure virtual]
 

f+=LM(g); g-=LM(g); assumes LPP(f)==LPP(g); returns LC(f)+LC(g)==0

virtual void CoCoA::SparsePolyRingBase::myMoveLM RawPtr  rawf,
RawPtr  rawg
const [pure virtual]
 

f+=LM(g); g-=LM(g); assumes LM(f)<LM(g)

virtual void CoCoA::SparsePolyRingBase::myDeleteLM RawPtr  rawf  )  const [pure virtual]
 

virtual void CoCoA::SparsePolyRingBase::myDivLM RawPtr  rawlhs,
ConstRawPtr  rawf,
ConstRawPtr  rawg
const [pure virtual]
 

lhs=div(LM(f),LM(g)); assumes f!=0,g!=0

virtual int CoCoA::SparsePolyRingBase::myCmpLPP ConstRawPtr  rawf,
ConstRawPtr  rawg
const [pure virtual]
 

cmp(LPP(f),LPP(g)); assumes f!=0,g!=0

virtual void CoCoA::SparsePolyRingBase::myAddClear RawPtr  rawf,
RawPtr  rawg
const [pure virtual]
 

f+=g; g=0;

virtual void CoCoA::SparsePolyRingBase::myAppendClear RawPtr  rawf,
RawPtr  rawg
const [pure virtual]
 

f+=g; g=0; appends g to f with no checks

virtual void CoCoA::SparsePolyRingBase::myAddMul RawPtr  rawf,
ConstRawPtr  rawh,
ConstRawPtr  rawg
const [pure virtual]
 

f += LM(h)*g

virtual void CoCoA::SparsePolyRingBase::myAddMul RawPtr  rawf,
ConstRawPtr  rawh,
ConstRawPtr  rawg,
SkipLMFlag 
const [pure virtual]
 

f += LM(h)*g

virtual void CoCoA::SparsePolyRingBase::myReductionStep RawPtr  rawf,
ConstRawPtr  rawg
const [pure virtual]
 

virtual void CoCoA::SparsePolyRingBase::myReductionStepGCD RawPtr  rawf,
ConstRawPtr  rawg,
RefRingElem  FScale
const [pure virtual]
 

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

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

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

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

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

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

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

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

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

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

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

lhs = deriv(f, x)

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

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

References CoCoA::IntrusiveReferenceCount::myRefCount.

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.

References CoCoA::IntrusiveReferenceCount::myRefCount.

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

sets myRefCount to 0

Definition at line 97 of file SmartPtrIRC.H.

References CoCoA::IntrusiveReferenceCount::myRefCount.


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:44:54 2007 for CoCoALib by  doxygen 1.4.6