CoCoALib-0.9905 date: 23 May 2007


CoCoA::QuotientRingBase Class Reference

#include <QuotientRing.H>

Inheritance diagram for CoCoA::QuotientRingBase:

Inheritance graph
[legend]
List of all members.

Public Types

typedef RingElemConstRawPtr ConstRawPtr
typedef RingElemRawPtr RawPtr

Public Member Functions

virtual RingElem myCanonicalRepr (ConstRawPtr rawx) const =0
virtual void myReduction (RawPtr rawimage, ConstRawPtr rawarg) const =0
virtual const RingHommyQuotientingHom () const =0
virtual RingHom myInducedHomCtor (const RingHom &InducingHom) 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

 QuotientRingBase (const ring &R, const ideal &I)
RingHom myQuotientingHomCtor () const
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

ring myBaseRing
const ideal myDefiningIdeal
const ring myReprRing
const ideal myReducingIdeal
const std::size_t myID

Friends

const ringBaseRing (const QuotientRing &RmodI)
const idealDefiningIdeal (const QuotientRing &RmodI)
const ringReprRing (const QuotientRing &RmodI)
const idealReducingIdeal (const QuotientRing &RmodI)
std::size_t ID (const ring &R)

Detailed Description

Definition at line 48 of file QuotientRing.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.


Constructor & Destructor Documentation

CoCoA::QuotientRingBase::QuotientRingBase const ring R,
const ideal I
[protected]
 


Member Function Documentation

virtual RingElem CoCoA::QuotientRingBase::myCanonicalRepr ConstRawPtr  rawx  )  const [pure virtual]
 

virtual void CoCoA::QuotientRingBase::myReduction RawPtr  rawimage,
ConstRawPtr  rawarg
const [pure virtual]
 

virtual const RingHom& CoCoA::QuotientRingBase::myQuotientingHom  )  const [pure virtual]
 

virtual RingHom CoCoA::QuotientRingBase::myInducedHomCtor const RingHom InducingHom  )  const [pure virtual]
 

RingHom CoCoA::QuotientRingBase::myQuotientingHomCtor  )  const [protected]
 

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

const ring& BaseRing const QuotientRing RmodI  )  [friend]
 

const ideal& DefiningIdeal const QuotientRing RmodI  )  [friend]
 

const ring& ReprRing const QuotientRing RmodI  )  [friend]
 

const ideal& ReducingIdeal const QuotientRing RmodI  )  [friend]
 

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

Definition at line 419 of file ring.H.


Member Data Documentation

ring CoCoA::QuotientRingBase::myBaseRing [protected]
 

Definition at line 60 of file QuotientRing.H.

const ideal CoCoA::QuotientRingBase::myDefiningIdeal [protected]
 

Definition at line 61 of file QuotientRing.H.

const ring CoCoA::QuotientRingBase::myReprRing [protected]
 

Definition at line 62 of file QuotientRing.H.

const ideal CoCoA::QuotientRingBase::myReducingIdeal [protected]
 

Definition at line 63 of file QuotientRing.H.

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