CoCoALib-0.9905 date: 23 May 2007


CoCoA Namespace Reference


Classes

class  bool3
 Class for three way "booleans": DefinitelyFalse, uncertain, and DefinitelyTrue. More...
class  CheckedCast
class  degree
class  DistrMPoly
 Implementation of "clean" polynomials. More...
class  DistrMPolyInlFpPP
 Implementation of polynomials for RingDistrMPolyInlFpPP. More...
class  DistrMPolyInlPP
 Implementation of polynomials for RingDistrMPolyInlPP. More...
class  DivMask
 Implementation of DivMask for fast divisibility test. More...
class  DivMaskRule
class  DivMaskRuleBase
class  EFGModule
class  EFGModuleBase
class  ErrorInfo
class  FractionFieldBase
class  FractionField
class  FreeModuleBase
class  FreeModule
class  geobucket
 Implementation of polynomials for fast summation of many short polynomials. More...
class  GlobalManager
class  GMPAllocator
class  ideal
class  IdealBase
class  MachineInteger
class  ConstMatrix
class  matrix
class  ConstMatrixBase
class  MatrixBase
class  AutoPtrSlice
class  MemPoolFast
class  MemPoolDebug
union  ModuleRawPtr
class  module
class  ModuleElem
class  ModuleBase
class  ModuleTermOrdering
class  ModuleTermOrderingBase
class  OpenMathSymbol
class  OpenMathOutput
class  OpenMathOutputBase
class  OpenMathInput
class  OpenMathInputBase
class  OpenMathOutputXML
class  OpenMathInputXML
class  PolyRingBase
class  PolyRing
class  PPMonoid
class  PPMonoidElemConstRawPtr
class  PPMonoidElemRawPtr
class  ConstRefPPMonoidElem
class  RefPPMonoidElem
class  PPMonoidElem
class  PPMonoidBase
class  PPOrdering
class  PPOrderingBase
class  PPWithMask
 Implementation of PPMonoidElem with DivMask for fast divisibility test. More...
class  QBGenerator
class  QuotientRingBase
class  QuotientRing
class  RandomBitStream
class  ReductionCog
class  ReductionCogBase
class  ring
class  RingElemConstRawPtr
class  RingElemRawPtr
class  ConstRefRingElem
class  RefRingElem
class  RingElem
class  AutoRingElem
class  RingBase
class  RingFloatBase
class  RingFloat
class  RingHomBase
class  RingHom
class  RingHomEmbeddingBase
class  RingHomInducedBase
class  ServerOp
class  ServerOpBase
class  SmallFpDoubleImpl
class  SmallFpImpl
class  SmallFpLogImpl
class  SmallPrimeSource
class  SmartPtrIRC
class  IntrusiveReferenceCount
class  SparsePolyIterBase
class  SparsePolyIter
class  SparsePolyRing
class  SparsePolyRingBase
class  symbol
class  SeqProd
class  SeqSum
class  GPair
class  ModuleGPairList
class  GRingInfo
class  GPoly
class  ReductorData
class  Reductors
class  GReductor
class  DegStats
class  Stats
class  facet
class  LexicographicOrderFacet
class  FacetComplex
class  ConnectionBlock
struct  DeleteObject
class  ZZ

Namespaces

namespace  ApproxPts
namespace  BuildInfo
namespace  OrdvArith
namespace  ERR
namespace  ErrorLanguage
namespace  CoeffEncoding

Pseudo constructors for RingElems owned by SparsePolyRing

RingElem monomial (const SparsePolyRing &P, ConstRefRingElem c, ConstRefPPMonoidElem pp)
RingElem monomial (const SparsePolyRing &P, const ZZ &N, ConstRefPPMonoidElem pp)
RingElem monomial (const SparsePolyRing &P, long n, ConstRefPPMonoidElem pp)
RingElem monomial (const SparsePolyRing &P, ConstRefRingElem c, const std::vector< long > &expv)
RingElem monomial (const SparsePolyRing &P, const ZZ &N, const std::vector< long > &expv)
RingElem monomial (const SparsePolyRing &P, long n, const std::vector< long > &expv)
RefRingElem PushFront (RefRingElem f, ConstRefRingElem c, const std::vector< long > &expv)
RefRingElem PushBack (RefRingElem f, ConstRefRingElem c, const std::vector< long > &expv)
 SHOULD BE vector<ZZ> ????

Special functions on RingElems owned by SparsePolyRing

ConstRefPPMonoidElem LPP (ConstRefRingElem f)
degree wdeg (ConstRefRingElem f)
int CmpWDeg (ConstRefRingElem f1, ConstRefRingElem f2)
bool IsHomogeneous (ConstRefRingElem f)
RingElem homog (ConstRefRingElem f, ConstRefRingElem h)
 homogenize f with indet h (GrDim=1, wdeg(h)=1)
RingElem NR (ConstRefRingElem f, const std::vector< RingElem > &v)
 Normal Remainder (remainder of the Division Algorithm). If v is a GBasis it gives the Normal Form.
SparsePolyIter BeginIter (ConstRefRingElem f)
SparsePolyIter EndIter (ConstRefRingElem f)

Typedefs

typedef unsigned int SmallFpElem_t
typedef unsigned int SmallFpLogElem_t
typedef unsigned short SmallExponent_t
typedef MemPoolFast MemPool
typedef std::list< std::pair<
RingElem, unsigned int > > 
FactorList
typedef std::list< GPairGPairList
typedef std::vector< GPairListMGPairList
typedef std::list< GPolyGPolyList
typedef std::list< GPoly * > GPolyPtrList
typedef std::vector< GPoly * > GPolyPtrVector
typedef std::vector< RingElemPolyList
typedef std::vector< ModuleElemVectorList
typedef std::bitset< WordLenBitsetWordLen
typedef std::list< facet
>::const_iterator 
FacetComplexConstIter
typedef std::list< facet
>::iterator 
FacetComplexIter
typedef std::vector< std::pair<
FacetComplexConstIter, std::vector<
FacetComplexConstIter
> > >::const_iterator 
conn_block_const_itr
typedef std::vector< std::pair<
FacetComplexConstIter, std::vector<
FacetComplexConstIter
> > >::iterator 
ConnBlockIter

Enumerations

enum  SkipTagType { TagWasRead, GetTag }
enum  OpenMathTag {
  OpenMathObj, OpenMathApply, OpenMathInt, OpenMathSym,
  OpenMathAttr, OpenMathEOF
}
enum  ComputationInputAndGradingType { AllGraded, AllAffine, AffineInputWithGradedRing }
enum  ClearType { clear }
enum  ModOrdTypeForcing { NoForcing, PosWDegTO, WDegTOPos, WDegPosTO }

Functions

double round (double x)
double square (double x)
void AssertionFailed (const char *const cond, const char *const file, unsigned long line)
std::ostream & operator<< (std::ostream &out, bool3 flag)
OpenMathOutputoperator<< (OpenMathOutput &out, bool3 flag)
bool IsDefinitelyFalse (bool3 flag)
bool IsUncertain (bool3 flag)
bool IsDefinitelyTrue (bool3 flag)
RingHom CanonicalHom (const ring &domain, const ring &codomain)
std::string ReadOperationString (std::istream &in)
void ReadPolyList (std::istream &in, PolyList &PL, const SparsePolyRing &P, SkipTagType ST)
void ReadVectorList (std::istream &in, VectorList &L, const FreeModule &FM, SkipTagType ST)
matrix ReadIntegerMatrix (std::istream &in, SkipTagType ST)
matrix ReadRationalMatrix (std::istream &in, SkipTagType ST)
FreeModule ReadFreeModule (std::istream &in, SkipTagType ST)
SparsePolyRing ReadPolyRing (std::istream &in, SkipTagType ST)
PPOrdering ReadPolyRingOrdering (std::istream &in, size_t NumInds, SkipTagType ST)
void PrintTimeToLog (double T)
void PrintTimeToCoCoA4 (double T)
void PrintVersionToCoCoA4 ()
void WritePolyRing (std::ostream &out, const SparsePolyRing &P)
void WriteMonomials (std::ostream &out, ConstRefRingElem p)
void WriteMatrixInVar (std::ostream &out, const std::string &VarName, const matrix &M)
void WritePolyListInVar (std::ostream &out, const std::string &VarName, const PolyList &PL)
void WriteVectorListInVar (std::ostream &out, const std::string &VarName, const VectorList &VL)
void AssertTag (const std::string &input_tag, const std::string &expected_tag)
void SkipTag (std::istream &in, const std::string &expected_tag)
void ThrowInputError (const std::string &unknown_tag)
SparsePolyRing NewPolyRingServer (ZZ charact, size_t FloatPrecision, size_t NumParams, const PPOrdering &O)
bool convert (long &lhs, const ZZ &src)
bool convert (int &lhs, const ZZ &src)
bool convert (unsigned long &lhs, const ZZ &src)
bool convert (unsigned int &lhs, const ZZ &src)
bool convert (std::string &lhs, const ZZ &src, int base=10)
bool convert (ZZ &lhs, const std::string &src, int base=0)
bool convert (ZZ &num, ZZ &den, double z)
 convert double z into an exact rational ==> den will be a power of 2.
bool convert (double &z, const ZZ &N)
 conversion may discard information!
bool convert (double &z, const ZZ &num, const ZZ &den)
 conversion may discard information!
bool convert (long &dest, const unsigned long &src)
bool convert (long &dest, const unsigned int &src)
bool convert (long &dest, const unsigned short &src)
bool convert (long &dest, const unsigned char &src)
std::size_t GradingDim (const degree &d)
 Computes "dimension" of the degree.
degree operator+ (const degree &d1, const degree &d2)
 Computes d1+d2.
degree operator- (const degree &d1, const degree &d2)
 Computes d1-d2.
degree top (const degree &d1, const degree &d2)
 i-th compt is max(d1[i], d2[i])
int cmp (const degree &d1, const degree &d2)
 lex comparison, result is <0,=0,>0
void SetComponent (degree &d, std::size_t index, const ZZ &value)
void SetComponent (degree &d, std::size_t index, long value)
std::ostream & operator<< (std::ostream &out, const degree &d)
 prints out the degree, handles dim=1 specially.
int FastCmp (const degree &d1, const degree &d2)
bool operator< (const degree &d1, const degree &d2)
bool operator<= (const degree &d1, const degree &d2)
bool operator> (const degree &d1, const degree &d2)
bool operator>= (const degree &d1, const degree &d2)
bool operator== (const degree &d1, const degree &d2)
bool operator!= (const degree &d1, const degree &d2)
matrix NewDenseMatrix (const ring &R, std::size_t NumRows, std::size_t NumCols)
matrix NewDenseMatrix (const ring &R, std::size_t NumRows, std::size_t NumCols, const std::vector< std::vector< int > > &M)
matrix NewDenseMatrix (ConstMatrix M)
void inverse (matrix &lhs, ConstMatrix M)
void adjoint (matrix &lhs, ConstMatrix M)
void mul (matrix &lhs, ConstMatrix M1, ConstMatrix M2)
matrix NewDiagMatrix (const ring &R, std::size_t NumRows, std::size_t NumCols)
matrix NewDiagMatrix (const ring &R, std::size_t NumRows, std::size_t NumCols, std::vector< RingElem > DiagEntries)
void deriv (DistrMPoly &lhs, const DistrMPoly &, std::size_t IndetIndex)
void deriv (DistrMPoly &lhs, const DistrMPoly &f, ConstRefPPMonoidElem x)
bool IsCompatible (const DistrMPoly &f, const DistrMPoly &g)
std::size_t NumTerms (const DistrMPoly &f)
ConstRefRingElem LC (const DistrMPoly &f)
RingElem content (const DistrMPoly &f)
ConstRefPPMonoidElem LPP (const DistrMPoly &f)
int CmpLPP (const DistrMPoly &f, const DistrMPoly &g)
void MoveLM (DistrMPoly &f, DistrMPoly &g)
long log (const DistrMPoly &f, std::size_t IndetIndex)
void DivLM (DistrMPoly &lhs, const DistrMPoly &f, const DistrMPoly &g)
bool IsZeroAddLCs (DistrMPoly &f, DistrMPoly &g)
void add (DistrMPoly &lhs, const DistrMPoly &g, const DistrMPoly &h)
void sub (DistrMPoly &lhs, const DistrMPoly &g, const DistrMPoly &h)
bool div (DistrMPoly &lhs, const DistrMPoly &g, const DistrMPoly &h)
void gcd (DistrMPoly &lhs, const DistrMPoly &g, const DistrMPoly &h)
void output (std::ostream &out, const DistrMPoly &f)
bool IsPrintAtom (const DistrMPoly &f)
void output (OpenMathOutput &OMOut, const DistrMPoly &f)
bool IsZero (const DistrMPoly &f)
bool IsOne (const DistrMPoly &f)
bool IsMinusOne (const DistrMPoly &f)
bool IsConstant (const DistrMPoly &f)
bool IsIndet (std::size_t &index, const DistrMPoly &f)
bool IsEqual (const DistrMPoly &f, const DistrMPoly &g)
void WeylMul (DistrMPoly &lhs, const DistrMPoly &g, const DistrMPoly &h)
void WeylDiv (DistrMPoly &lhs, const DistrMPoly &g, const DistrMPoly &h)
bool IsEnded (const DistrMPoly::iter &i)
ConstRefRingElem coeff (const DistrMPoly::iter &i)
ConstRefPPMonoidElem PP (const DistrMPoly::iter &i)
void swap (DistrMPoly &f, DistrMPoly &g)
void deriv (DistrMPolyInlFpPP &lhs, const DistrMPolyInlFpPP &, std::size_t IndetIndex)
void deriv (DistrMPolyInlFpPP &lhs, const DistrMPolyInlFpPP &f, ConstRefPPMonoidElem x)
bool IsCompatible (const DistrMPolyInlFpPP &f, const DistrMPolyInlFpPP &g)
std::size_t NumTerms (const DistrMPolyInlFpPP &f)
const DistrMPolyInlFpPP::InlineFpElem_tLC (const DistrMPolyInlFpPP &f)
ConstRefPPMonoidElem LPP (const DistrMPolyInlFpPP &f)
int CmpLPP (const DistrMPolyInlFpPP &f, const DistrMPolyInlFpPP &g)
void MoveLM (DistrMPolyInlFpPP &f, DistrMPolyInlFpPP &g)
long log (const DistrMPolyInlFpPP &f, std::size_t IndetIndex)
void DivLM (DistrMPolyInlFpPP &lhs, const DistrMPolyInlFpPP &f, const DistrMPolyInlFpPP &g)
bool IsZeroAddLCs (DistrMPolyInlFpPP &f, DistrMPolyInlFpPP &g)
void add (DistrMPolyInlFpPP &lhs, const DistrMPolyInlFpPP &g, const DistrMPolyInlFpPP &h)
void sub (DistrMPolyInlFpPP &lhs, const DistrMPolyInlFpPP &g, const DistrMPolyInlFpPP &h)
bool div (DistrMPolyInlFpPP &lhs, const DistrMPolyInlFpPP &g, const DistrMPolyInlFpPP &h)
void output (std::ostream &out, const DistrMPolyInlFpPP &f)
bool IsZero (const DistrMPolyInlFpPP &f)
bool IsEqual (const DistrMPolyInlFpPP &f, const DistrMPolyInlFpPP &g)
void WeylMul (DistrMPolyInlFpPP &lhs, const DistrMPolyInlFpPP &g, const DistrMPolyInlFpPP &h)
void WeylDiv (DistrMPolyInlFpPP &lhs, const DistrMPolyInlFpPP &g, const DistrMPolyInlFpPP &h)
bool IsEnded (const DistrMPolyInlFpPP::iter &i)
ConstRefRingElem coeff (const DistrMPolyInlFpPP::iter &i)
ConstRefPPMonoidElem PP (const DistrMPolyInlFpPP::iter &i)
void swap (DistrMPolyInlFpPP &f, DistrMPolyInlFpPP &g)
void deriv (DistrMPolyInlPP &lhs, const DistrMPolyInlPP &, std::size_t IndetIndex)
void deriv (DistrMPolyInlPP &lhs, const DistrMPolyInlPP &f, ConstRefPPMonoidElem x)
const ringCoeffRing (const DistrMPolyInlPP &f)
const PPMonoidPPM (const DistrMPolyInlPP &f)
bool IsCompatible (const DistrMPolyInlPP &f, const DistrMPolyInlPP &g)
std::size_t NumTerms (const DistrMPolyInlPP &f)
ConstRefRingElem LC (const DistrMPolyInlPP &f)
RingElemRawPtrRawLC (DistrMPolyInlPP &f)
const RingElemRawPtrRawLC (const DistrMPolyInlPP &f)
RingElem content (const DistrMPolyInlPP &f)
ConstRefPPMonoidElem LPP (const DistrMPolyInlPP &f)
int CmpLPP (const DistrMPolyInlPP &f, const DistrMPolyInlPP &g)
void MoveLM (DistrMPolyInlPP &f, DistrMPolyInlPP &g)
long log (const DistrMPolyInlPP &f, std::size_t IndetIndex)
void DivLM (DistrMPolyInlPP &lhs, const DistrMPolyInlPP &f, const DistrMPolyInlPP &g)
bool IsZeroAddLCs (DistrMPolyInlPP &f, DistrMPolyInlPP &g)
void add (DistrMPolyInlPP &lhs, const DistrMPolyInlPP &g, const DistrMPolyInlPP &h)
void sub (DistrMPolyInlPP &lhs, const DistrMPolyInlPP &g, const DistrMPolyInlPP &h)
bool div (DistrMPolyInlPP &lhs, const DistrMPolyInlPP &g, const DistrMPolyInlPP &h)
void gcd (DistrMPolyInlPP &lhs, const DistrMPolyInlPP &g, const DistrMPolyInlPP &h)
void output (std::ostream &out, const DistrMPolyInlPP &f)
bool IsPrintAtom (const DistrMPolyInlPP &f)
void output (OpenMathOutput &OMOut, const DistrMPolyInlPP &f)
bool IsZero (const DistrMPolyInlPP &f)
bool IsOne (const DistrMPolyInlPP &f)
bool IsMinusOne (const DistrMPolyInlPP &f)
bool IsConstant (const DistrMPolyInlPP &f)
bool IsIndet (std::size_t &index, const DistrMPolyInlPP &f)
bool IsEqual (const DistrMPolyInlPP &f, const DistrMPolyInlPP &g)
void WeylMul (DistrMPolyInlPP &lhs, const DistrMPolyInlPP &g, const DistrMPolyInlPP &h)
void WeylDiv (DistrMPolyInlPP &lhs, const DistrMPolyInlPP &g, const DistrMPolyInlPP &h)
bool IsEnded (const DistrMPolyInlPP::iter &i)
ConstRefRingElem coeff (const DistrMPolyInlPP::iter &i)
ConstRefPPMonoidElem PP (const DistrMPolyInlPP::iter &i)
void swap (DistrMPolyInlPP &f, DistrMPolyInlPP &g)
std::ostream & operator<< (std::ostream &out, const DivMask &dm)
std::ostream & operator<< (std::ostream &out, const DivMaskRule &DMR)
DivMaskRule NewDivMaskNull ()
DivMaskRule NewDivMaskSingleBit ()
DivMaskRule NewDivMaskSingleBitWrap ()
DivMaskRule NewDivMaskEvenPowers ()
DivMaskRule NewDivMaskHashing ()
const DivMask::mask_t bits (const DivMask &dm)
bool operator== (const DivMask &dm1, const DivMask &dm2)
bool operator!= (const DivMask &dm1, const DivMask &dm2)
bool IsSubset (const DivMask &dm1, const DivMask &dm2)
std::size_t NumCompts (const EFGModule &M)
const std::vector< ModuleElem > & gens (const EFGModule &M)
const std::vector< ModuleElem > & TidyGens (const EFGModule &M)
bool IsEFGModule (const module &M)
EFGModule AsEFGModule (const module &M)
const FreeModuleAmbientFreeModule (const EFGModule &M)
std::ostream & operator<< (std::ostream &out, const ErrorInfo &err)
void ANNOUNCE (const ErrorInfo &err)
void error (const ErrorInfo &err)
ideal NewFieldIdeal (const ring &k, const std::vector< RingElem > &gens)
 FieldIdealImpl -- the simple ideals of a field.
FractionField NewFractionField (const ring &R)
bool IsFractionField (const ring &Q)
FractionField AsFractionField (const ring &R)
const ringBaseRing (const FractionField &Q)
const RingHomEmbeddingHom (const FractionField &FrF)
RingHom InducedHom (const FractionField &FrF, const RingHom &InducingHom)
RingElem num (ConstRefRingElem q)
RingElem den (ConstRefRingElem q)
FreeModule NewFreeModule (const ring &R, std::size_t NumCompts)
bool IsFreeModule (const module &M)
FreeModule AsFreeModule (const module &M)
size_t FirstNonZeroPos (const ModuleElem &v)
const std::vector< degree > & shifts (const FreeModule &M)
 defined only if GradedFreeModuleImpl
const ModuleTermOrderingordering (const FreeModule &M)
 defined only if GradedFreeModuleImpl
FreeModule NewGradedFreeModule (const SparsePolyRing &P, std::size_t NumCompts)
 this is not intended for public use: NewFreeModule is intelligent
FreeModule NewFreeModule (const ring &P, const ModuleTermOrdering &O)
bool IsGradedFreeModule (const module &M)
std::size_t LPos (const ModuleElem &v)
degree wdeg (const ModuleElem &v)
int CmpWDeg (const ModuleElem &v1, const ModuleElem &v2)
ConstRefPPMonoidElem LPP (const ModuleElem &v)
bool IsHomogeneous (const ModuleElem &v)
std::ostream & operator<< (std::ostream &, const geobucket &)
void AddClear (RefRingElem f, geobucket &gbk)
void ReductionStep (geobucket &gbk, ConstRefRingElem g, std::size_t RedLen)
void ReductionStepGCD (geobucket &gbk, ConstRefRingElem g, RefRingElem FScale, std::size_t RedLen)
bool IsZero (const geobucket::bucket &b)
ConstRefPPMonoidElem LPP (const geobucket &gbk)
const ringCoeffRing (const geobucket &g)
const PPMonoidPPM (const geobucket &g)
bool IsZero (const geobucket &g)
RingElem operator% (long n, const ideal &I)
 reduce n modulo I
RingElem operator% (const ZZ &N, const ideal &I)
 reduce N modulo I
RingElem operator% (ConstRefRingElem r, const ideal &I)
 reduce r modulo I
RingElem NF (ConstRefRingElem r, const ideal &I)
 reduce r modulo I, same as %
const ringAmbientRing (const ideal &I)
const ideal operator+ (const ideal &I, const ideal &J)
idealoperator+= (ideal &I, const ideal &J)
const ideal intersect (const ideal &I, const ideal &J)
const ideal colon (const ideal &I, const ideal &J)
bool IsContained (const ideal &I, const ideal &J)
bool operator== (const ideal &I, const ideal &J)
bool IsElem (ConstRefRingElem r, const ideal &I)
std::ostream & operator<< (std::ostream &out, const ideal &I)
OpenMathOutputoperator<< (OpenMathOutput &OMOut, const ideal &I)
bool IsZero (const ideal &I)
bool IsOne (const ideal &I)
bool IsMaximal (const ideal &I)
bool IsPrime (const ideal &I)
const std::vector< RingElem > & gens (const ideal &I)
const std::vector< RingElem > & TidyGens (const ideal &I)
std::istream & GlobalInput ()
std::ostream & GlobalOutput ()
std::ostream & GlobalErrput ()
std::ostream & GlobalLogput ()
std::istream & SetGlobalInput (std::istream &in)
std::ostream & SetGlobalOutput (std::ostream &out)
std::ostream & SetGlobalErrput (std::ostream &err)
std::ostream & SetGlobalLogput (std::ostream &log)
template<typename FwdIterator_t>
void OutputRange (std::ostream &out, FwdIterator_t start, const FwdIterator_t &end)
template<typename entry_t>
std::ostream & operator<< (std::ostream &out, const std::vector< entry_t > &v)
template<typename entry_t>
std::ostream & operator<< (std::ostream &out, const std::list< entry_t > &v)
bool IsNegative (const MachineInteger &n)
unsigned long AsUnsignedLong (const MachineInteger &n)
long AsSignedLong (const MachineInteger &n)
unsigned long abs (const MachineInteger &n)
std::ostream & operator<< (std::ostream &out, const MachineInteger &n)
bool IsZero (const MachineInteger &n)
int sign (const MachineInteger &n)
bool IsOdd (const MachineInteger &n)
bool IsEven (const MachineInteger &n)
int cmp (const MachineInteger &n1, const MachineInteger &n2)
unsigned long gcd (const MachineInteger &a, const MachineInteger &b)
std::ostream & operator<< (std::ostream &out, ConstMatrix M)
void AssignZero (matrix &M)
void SetEntry (matrix &M, std::size_t i, std::size_t j, ConstRefRingElem r)
void SetEntry (matrix &M, std::size_t i, std::size_t j, long n)
void SetEntry (matrix &M, std::size_t i, std::size_t j, const ZZ &N)
bool IsZeroRow (ConstMatrix M, std::size_t i)
bool IsZeroCol (ConstMatrix M, std::size_t j)
RingElem det (ConstMatrix M)
std::size_t rank (ConstMatrix M)
const ringBaseRing (ConstMatrix M)
std::size_t NumRows (ConstMatrix M)
std::size_t NumCols (ConstMatrix M)
void DetByGauss (RefRingElem d, ConstMatrix M)
size_t RankByGauss (ConstMatrix M)
void InverseByGauss (matrix &lhs, ConstMatrix M)
void AdjointByInverse (matrix &lhs, ConstMatrix M)
void GrammSchmidtRows (matrix &M)
void GrammSchmidtRows (matrix &M, std::size_t row)
bool IsTermOrdering (ConstMatrix M)
matrix NewPositiveMatrix (ConstMatrix M)
 returns a matrix with positive entries which defines an equivalent term-ordering
bool IsPositiveGrading (ConstMatrix M, size_t GradingDim)
 are the first GradingDim rows of M a positive grading?
matrix NewMatrixConcatHor (ConstMatrix M1, ConstMatrix M2)
matrix NewMatrixConcatVer (ConstMatrix M1, ConstMatrix M2)
matrix NewMatrixConcatDiag (ConstMatrix M1, ConstMatrix M2)
matrix NewMatrixConcatAntiDiag (ConstMatrix M1, ConstMatrix M2)
matrix NewMatrixMinimize (ConstMatrix M)
 the (ordering) matrix obtained by removing linearly dependent rows
matrix NewDenseMatrixRevLex (ring R, size_t n)
matrix NewMatrixCompleteOrd (ConstMatrix M)
matrix NewMatrixElim (size_t NumIndets, std::vector< size_t > IndetsToElim)
matrix NewMatrixElim (ConstMatrix GradingM, std::vector< size_t > IndetsToElim, bool IsHomog)
ModuleElem operator- (const ModuleElem &)
ModuleElem operator+ (const ModuleElem &, const ModuleElem &)
ModuleElem operator- (const ModuleElem &, const ModuleElem &)
ModuleElem operator * (ConstRefRingElem, const ModuleElem &)
ModuleElem operator * (const ModuleElem &, ConstRefRingElem)
ModuleElem operator/ (const ModuleElem &, ConstRefRingElem)
ModuleElemoperator+= (ModuleElem &, const ModuleElem &)
ModuleElemoperator-= (ModuleElem &, const ModuleElem &)
ModuleElemoperator *= (ModuleElem &, ConstRefRingElem)
ModuleElemoperator/= (ModuleElem &, ConstRefRingElem)
ModuleElem operator * (long, const ModuleElem &)
ModuleElem operator * (const ModuleElem &, long)
ModuleElem operator/ (const ModuleElem &, long)
ModuleElemoperator *= (ModuleElem &, long)
ModuleElemoperator/= (ModuleElem &, long)
std::ostream & operator<< (std::ostream &, const ModuleElem &v)
std::ostream & operator<< (std::ostream &, const module &M)
OpenMathOutputoperator<< (OpenMathOutput &OMOut, const ModuleElem &v)
OpenMathOutputoperator<< (OpenMathOutput &OMOut, const module &M)
bool IsZero (const ModuleElem &)
bool operator== (const ModuleElem &v1, const ModuleElem &v2)
bool operator!= (const ModuleElem &v1, const ModuleElem &v2)
const ringBaseRing (const module &M)
const ModuleElemzero (const module &M)
const moduleowner (const ModuleElem &v)
ModuleRawPtrraw (ModuleElem &v)
const ModuleRawPtrraw (const ModuleElem &v)
bool operator!= (const module &M1, const module M2)
std::ostream & operator<< (std::ostream &out, const ModuleTermOrdering &MTO)
OpenMathOutputoperator<< (OpenMathOutput &OMOut, const ModuleTermOrdering &MTO)
const std::vector< degree > & shifts (const ModuleTermOrdering &O)
std::size_t NumComponents (const ModuleTermOrdering &MTO)
std::size_t GradingDim (const ModuleTermOrdering &MTO)
const PPOrderingModPPOrdering (const ModuleTermOrdering &MTO)
ModuleTermOrdering NewWDegTOPos (const PPOrdering &PPO, std::size_t NumComponents)
ModuleTermOrdering NewPosWDegTO (const PPOrdering &PPO, std::size_t NumComponents)
ModuleTermOrdering NewWDegPosTO (const PPOrdering &PPO, std::size_t NumComponents)
ModuleTermOrdering NewWDegTOPos (const PPOrdering &PPO, const std::vector< degree > &shifts)
ModuleTermOrdering NewWDegPosTO (const PPOrdering &PPO, const std::vector< degree > &shifts)
ModuleTermOrdering NewPosWDegTO (const PPOrdering &PPO, const std::vector< degree > &shifts)
ModuleTermOrdering NewWDegTOPos (const PPOrdering &PPO, const std::vector< std::size_t > &perm)
ModuleTermOrdering NewWDegPosTO (const PPOrdering &PPO, const std::vector< std::size_t > &perm)
ModuleTermOrdering NewWDegTOPos (const PPOrdering &PPO, const std::vector< degree > &shifts, const std::vector< std::size_t > &perm)
ModuleTermOrdering NewWDegPosTO (const PPOrdering &PPO, const std::vector< degree > &shifts, const std::vector< std::size_t > &perm)
bool IsWDegTOPos (const ModuleTermOrdering &MTO)
bool IsPosWDegTO (const ModuleTermOrdering &MTO)
bool IsWDegPosTO (const ModuleTermOrdering &MTO)
std::ostream & operator<< (std::ostream &out, const OpenMathSymbol &oms)
OpenMathOutputoperator<< (OpenMathOutput &OMOut, short n)
OpenMathOutputoperator<< (OpenMathOutput &OMOut, int n)
OpenMathOutputoperator<< (OpenMathOutput &OMOut, long n)
OpenMathOutputoperator<< (OpenMathOutput &OMOut, unsigned short n)
OpenMathOutputoperator<< (OpenMathOutput &OMOut, unsigned int n)
OpenMathOutputoperator<< (OpenMathOutput &OMOut, unsigned long n)
OpenMathOutputoperator<< (OpenMathOutput &OMOut, const ZZ &N)
OpenMathOutputoperator<< (OpenMathOutput &OMOut, const OpenMathSymbol &s)
OpenMathInputoperator>> (OpenMathInput &OMIn, long &n)
OpenMathInputoperator>> (OpenMathInput &OMIn, ZZ &N)
OpenMathInputoperator>> (OpenMathInput &OMIn, OpenMathSymbol &s)
OrdvArith::reference NewOrdvArith (const PPOrdering &PPO)
std::vector< std::vector<
int > > 
NewElimMatrix (std::size_t NumIndets, const std::vector< std::size_t > &ElimIndets)
std::vector< std::vector<
int > > 
NewElimMatrixAdj (std::size_t NumIndets, const std::vector< std::size_t > &ElimIndets)
bool IsPolyRing (const ring &R)
PolyRing AsPolyRing (const ring &R)
const ringCoeffRing (const PolyRing &Rx)
std::size_t NumIndets (const PolyRing &Rx)
const RingHomCoeffEmbeddingHom (const PolyRing &Rx)
const std::vector< RingElem > & indets (const PolyRing &Rx)
const RingElemindet (const PolyRing &P, std::size_t var)
RingElem IndetPower (const PolyRing &P, std::size_t var, unsigned int n)
std::size_t NumTerms (ConstRefRingElem f)
bool IsMonomial (ConstRefRingElem f)
 f == coeff*pp
bool IsConstant (ConstRefRingElem f)
 f == coeff
bool IsIndet (ConstRefRingElem f)
 f == x[i]
bool IsIndet (std::size_t &index, ConstRefRingElem f)
 f == x[i]; index=i
std::size_t StdDeg (ConstRefRingElem f)
std::size_t deg (ConstRefRingElem f)
long log (ConstRefRingElem f, std::size_t var)
ConstRefRingElem LC (ConstRefRingElem f)
RingElem content (ConstRefRingElem f)
RingElem deriv (ConstRefRingElem f, ConstRefRingElem x)
 derivative of f w.r.t. x, x must be an indeterminate
RingElem deriv (ConstRefRingElem f, std::size_t x)
 here x is the index of the indeterminate
RingHom PolyRingHom (const PolyRing &domain, const ring &codomain, const RingHom &CoeffHom, const std::vector< RingElem > &IndetImages)
 R[x] -> S, defined by CoeffHom: R->S and x->IndetImages.
RingHom PolyAlgebraHom (const PolyRing &domain, const ring &codomain, const std::vector< RingElem > &IndetImages)
 R[x] -> R or R[x]->R[y], defined by R->R and x->IndetImages.
const std::vector< PPMonoidElem > & indets (const PPMonoid &PPM)
 std::vector whose n-th entry is n-th indet as PPMonoidElem
std::vector< symbolsymbols (const PPMonoid &PPM)
 std::vector of the symbols in PPM
std::size_t StdDeg (ConstRefPPMonoidElem pp)
 standard degree of pp
degree wdeg (ConstRefPPMonoidElem pp)
 degree according to grading
int CmpWDeg (ConstRefPPMonoidElem pp1, ConstRefPPMonoidElem pp2)
 <0 =0 >0 according as wdeg(t1) < = > wdeg(t2)
long log (ConstRefPPMonoidElem pp, std::size_t var)
 degree in indet of index var
ZZ ZZLog (ConstRefPPMonoidElem pp, std::size_t var)
 degree in indet of index var
void exponents (std::vector< long > &v, ConstRefPPMonoidElem pp)
 SHOULD BE vector<ZZ> ????
void swap (RefPPMonoidElem pp1, RefPPMonoidElem pp2)
 swap(t1, t2);
bool IsOne (ConstRefPPMonoidElem pp)
bool IsIndet (std::size_t &index, ConstRefPPMonoidElem pp)
bool IsIndetPower (std::size_t &index, ZZ &exp, ConstRefPPMonoidElem pp)
int cmp (ConstRefPPMonoidElem pp1, ConstRefPPMonoidElem pp2)
 <0, =0, >0 as pp1 < = > pp2
bool operator== (ConstRefPPMonoidElem pp1, ConstRefPPMonoidElem pp2)
 pp1 == pp2;
bool operator!= (ConstRefPPMonoidElem pp1, ConstRefPPMonoidElem pp2)
 pp1 != pp2;
bool operator< (ConstRefPPMonoidElem pp1, ConstRefPPMonoidElem pp2)
 pp1 < pp2;
bool operator<= (ConstRefPPMonoidElem pp1, ConstRefPPMonoidElem pp2)
 pp1 <= pp2;
bool operator> (ConstRefPPMonoidElem pp1, ConstRefPPMonoidElem pp2)
 pp1 > pp2;
bool operator>= (ConstRefPPMonoidElem pp1, ConstRefPPMonoidElem pp2)
 pp1 => pp2;
std::ostream & operator<< (std::ostream &out, const PPMonoid &PPM)
std::ostream & operator<< (std::ostream &out, ConstRefPPMonoidElem pp)
OpenMathOutputoperator<< (OpenMathOutput &OMOut, ConstRefPPMonoidElem t)
PPMonoidElem operator * (ConstRefPPMonoidElem pp1, ConstRefPPMonoidElem pp2)
 pp1*pp2;
PPMonoidElem operator/ (ConstRefPPMonoidElem pp1, ConstRefPPMonoidElem pp2)
 pp1/pp2;
PPMonoidElem colon (ConstRefPPMonoidElem pp1, ConstRefPPMonoidElem pp2)
 pp1:pp2
PPMonoidElem gcd (ConstRefPPMonoidElem pp1, ConstRefPPMonoidElem pp2)
 gcd(pp1, pp2)
PPMonoidElem lcm (ConstRefPPMonoidElem pp1, ConstRefPPMonoidElem pp2)
 lcm(pp1, pp2)
PPMonoidElem power (ConstRefPPMonoidElem pp, long exp)
 pp^exp
PPMonoidElem power (ConstRefPPMonoidElem pp, const ZZ &EXP)
 pp^EXP
bool IsCoprime (ConstRefPPMonoidElem pp1, ConstRefPPMonoidElem pp2)
 is gcd(pp1, pp2)=1?
bool IsDivisible (ConstRefPPMonoidElem pp1, ConstRefPPMonoidElem pp2)
 is pp1 divisible by pp2?
void AssignOne (RefPPMonoidElem dest)
RefPPMonoidElem operator *= (RefPPMonoidElem dest, ConstRefPPMonoidElem t)
RefPPMonoidElem operator/= (RefPPMonoidElem dest, ConstRefPPMonoidElem t)
ConstRefPPMonoidElem indet (const PPMonoid &M, std::size_t var)
PPMonoidElem IndetPower (const PPMonoid &M, std::size_t var, long exp)
PPMonoid NewPPMonoid (const std::vector< symbol > &IndetNames, const PPOrdering &ord)
bool operator!= (const PPMonoid &M1, const PPMonoid &M2)
ConstRefPPMonoidElem one (const PPMonoid &PPM)
std::size_t NumIndets (const PPMonoid &M)
const PPOrderingordering (const PPMonoid &M)
std::size_t GradingDim (const PPMonoid &M)
const PPMonoidowner (const ConstRefPPMonoidElem &rawpp)
PPMonoidElemRawPtr raw (RefPPMonoidElem &rawpp)
PPMonoidElemConstRawPtr raw (const ConstRefPPMonoidElem &rawpp)
PPMonoid NewPPMonoidEv (const std::vector< symbol > &IndetNames, const PPOrdering &ord)
PPMonoid NewPPMonoidEvOv (const std::vector< symbol > &IndetNames, const PPOrdering &ord)
PPMonoid NewPPMonoidEvZZ (const std::vector< symbol > &IndetNames, const PPOrdering &ord)
PPMonoid NewPPMonoidOv (const std::vector< symbol > &IndetNames, const PPOrdering &ord)
PPMonoid NewPPMonoidSparse (const std::vector< symbol > &IndetNames, const PPOrdering &ord)
std::ostream & operator<< (std::ostream &out, const PPOrdering &PPO)
OpenMathOutputoperator<< (OpenMathOutput &OMOut, const PPOrdering &PPO)
std::size_t NumIndets (const PPOrdering &PPO)
std::size_t GradingDim (const PPOrdering &PPO)
PPOrdering NewLexOrdering (std::size_t NumIndets)
PPOrdering NewStdDegLexOrdering (std::size_t NumIndets)
PPOrdering NewStdDegRevLexOrdering (std::size_t NumIndets)
PPOrdering NewMatrixOrdering (std::size_t NumIndets, std::size_t GradingDim, ConstMatrix OrderMatrix)
bool IsLex (const PPOrdering &PPO)
bool IsStdDegLex (const PPOrdering &PPO)
bool IsStdDegRevLex (const PPOrdering &PPO)
matrix GetMatrix (const PPOrdering &PPO)
std::ostream & operator<< (std::ostream &out, const PPWithMask &pm)
bool IsEqualFast (const PPWithMask &pm1, const PPWithMask &pm2)
bool IsDivisibleFast (const PPWithMask &pm1, const PPWithMask &pm2)
const PPMonoidPPM (const QBGenerator &QBG)
std::ostream & operator<< (std::ostream &out, const QBGenerator &QBG)
EFGModule NewQuotientModule (const EFGModule &Mnumer, const EFGModule &Mdenom)
QuotientRing NewQuotientRing (const ring &R, const ideal &I)
QuotientRing NewZmod (long n)
QuotientRing NewZmod (const ZZ &N)
bool IsQuotientRing (const ring &R)
QuotientRing AsQuotientRing (const ring &R)
const ringBaseRing (const QuotientRing &RmodI)
const idealDefiningIdeal (const QuotientRing &RmodI)
const ringReprRing (const QuotientRing &RmodI)
const idealReducingIdeal (const QuotientRing &RmodI)
const RingHomQuotientingHom (const QuotientRing &RmodI)
RingHom InducedHom (const QuotientRing &RmodI, const RingHom &phi)
RingElem CanonicalRepr (ConstRefRingElem r)
 given x in R/I produces X in R s.t. QuotientingHom(RmodI)(X)=x
bool sample (RandomBitStream &RBS)
bool prob (double P, RandomBitStream &RBS)
std::ostream & operator<< (std::ostream &out, const RandomBitStream &RBS)
ConstRefPPMonoidElem ActiveLPP (const ReductionCog &F)
bool IsActiveZero (const ReductionCog &F)
std::ostream & operator<< (std::ostream &out, const ReductionCog &F)
ReductionCog NewRedCogPolyField (const SparsePolyRing &P)
ReductionCog NewRedCogPolyGCD (const SparsePolyRing &P)
ReductionCog NewRedCogGeobucketField (const SparsePolyRing &P)
ReductionCog NewRedCogGeobucketGCD (const SparsePolyRing &P)
std::vector< symbolsymbols (const ring &R)
bool operator== (ConstRefRingElem, ConstRefRingElem)
bool operator!= (ConstRefRingElem, ConstRefRingElem)
RingElem operator- (ConstRefRingElem)
RingElem operator+ (ConstRefRingElem, ConstRefRingElem)
RingElem operator- (ConstRefRingElem, ConstRefRingElem)
RingElem operator * (ConstRefRingElem, ConstRefRingElem)
RingElem operator/ (ConstRefRingElem, ConstRefRingElem)
RingElem gcd (ConstRefRingElem, ConstRefRingElem)
void GcdQuot (RefRingElem gcd, RefRingElem xquot, RefRingElem yquot, ConstRefRingElem x, ConstRefRingElem y)
RefRingElem operator+= (RefRingElem, ConstRefRingElem)
RefRingElem operator-= (RefRingElem, ConstRefRingElem)
RefRingElem operator *= (RefRingElem, ConstRefRingElem)
RefRingElem operator/= (RefRingElem, ConstRefRingElem)
std::ostream & operator<< (std::ostream &, ConstRefRingElem)
OpenMathOutputoperator<< (OpenMathOutput &OMOut, ConstRefRingElem)
bool IsZero (ConstRefRingElem)
bool IsOne (ConstRefRingElem)
bool IsMinusOne (ConstRefRingElem)
bool IsInteger (ZZ &N, ConstRefRingElem x)
bool IsRational (ZZ &N, ZZ &D, ConstRefRingElem x)
bool IsInvertible (ConstRefRingElem)
bool IsDivisible (ConstRefRingElem, ConstRefRingElem)
bool IsDivisible (long, ConstRefRingElem)
bool IsDivisible (ConstRefRingElem, long)
bool IsDivisible (const ZZ &N, ConstRefRingElem)
bool IsDivisible (ConstRefRingElem, const ZZ &N)
RingElem power (ConstRefRingElem x, long n)
 NB exponent may be negative.
RingElem power (ConstRefRingElem x, const ZZ &N)
 NB exponent may be negative.
ConstRefRingElem zero (const ring &R)
ConstRefRingElem one (const ring &R)
std::ostream & operator<< (std::ostream &out, const ring &R)
OpenMathOutputoperator<< (OpenMathOutput &OMOut, const ring &R)
int sign (ConstRefRingElem x)
RingElem abs (ConstRefRingElem x)
int cmp (ConstRefRingElem x, ConstRefRingElem y)
int cmp (ConstRefRingElem x, long n)
int cmp (long n, ConstRefRingElem y)
int cmp (ConstRefRingElem x, const ZZ &N)
int cmp (const ZZ &N, ConstRefRingElem y)
bool operator< (ConstRefRingElem x, ConstRefRingElem y)
bool operator<= (ConstRefRingElem x, ConstRefRingElem y)
bool operator> (ConstRefRingElem x, ConstRefRingElem y)
bool operator>= (ConstRefRingElem x, ConstRefRingElem y)
bool operator< (ConstRefRingElem x, long y)
bool operator<= (ConstRefRingElem x, long y)
bool operator> (ConstRefRingElem x, long y)
bool operator>= (ConstRefRingElem x, long y)
bool operator< (long x, ConstRefRingElem y)
bool operator<= (long x, ConstRefRingElem y)
bool operator> (long x, ConstRefRingElem y)
bool operator>= (long x, ConstRefRingElem y)
bool operator< (ConstRefRingElem x, const ZZ &y)
bool operator<= (ConstRefRingElem x, const ZZ &y)
bool operator> (ConstRefRingElem x, const ZZ &y)
bool operator>= (ConstRefRingElem x, const ZZ &y)
bool operator< (const ZZ &x, ConstRefRingElem y)
bool operator<= (const ZZ &x, ConstRefRingElem y)
bool operator> (const ZZ &x, ConstRefRingElem y)
bool operator>= (const ZZ &x, ConstRefRingElem y)
bool operator== (ConstRefRingElem, long)
bool operator!= (ConstRefRingElem, long)
RingElem operator+ (ConstRefRingElem, long)
RingElem operator- (ConstRefRingElem, long)
RingElem operator * (ConstRefRingElem, long)
RingElem operator/ (ConstRefRingElem, long)
RingElem gcd (ConstRefRingElem, long)
bool operator== (long, ConstRefRingElem)
bool operator!= (long, ConstRefRingElem)
RingElem operator+ (long, ConstRefRingElem)
RingElem operator- (long, ConstRefRingElem)
RingElem operator * (long, ConstRefRingElem)
RingElem operator/ (long, ConstRefRingElem)
RingElem gcd (long, ConstRefRingElem)
RefRingElem operator+= (RefRingElem, long)
RefRingElem operator-= (RefRingElem, long)
RefRingElem operator *= (RefRingElem, long)
RefRingElem operator/= (RefRingElem, long)
bool operator== (ConstRefRingElem, const ZZ &)
bool operator!= (ConstRefRingElem, const ZZ &)
RingElem operator+ (ConstRefRingElem, const ZZ &)
RingElem operator- (ConstRefRingElem, const ZZ &)
RingElem operator * (ConstRefRingElem, const ZZ &)
RingElem operator/ (ConstRefRingElem, const ZZ &)
RingElem gcd (ConstRefRingElem, const ZZ &)
bool operator== (const ZZ &, ConstRefRingElem)
bool operator!= (const ZZ &, ConstRefRingElem)
RingElem operator+ (const ZZ &, ConstRefRingElem)
RingElem operator- (const ZZ &, ConstRefRingElem)
RingElem operator * (const ZZ &, ConstRefRingElem)
RingElem operator/ (const ZZ &, ConstRefRingElem)
RingElem gcd (const ZZ &, ConstRefRingElem)
RefRingElem operator+= (RefRingElem, const ZZ &)
RefRingElem operator-= (RefRingElem, const ZZ &)
RefRingElem operator *= (RefRingElem, const ZZ &)
RefRingElem operator/= (RefRingElem, const ZZ &)
bool operator== (const ring &R1, const ring &R2)
bool operator!= (const ring &R1, const ring &R2)
RingElemRawPtr raw (AutoRingElem &x)
RingElemRawPtr release (AutoRingElem &x)
const ringowner (const ConstRefRingElem &x)
const RingElemConstRawPtrraw (const ConstRefRingElem &x)
RingElemRawPtrraw (RefRingElem &x)
std::size_t ID (const ring &R)
ZZ characteristic (const ring &R)
bool IsGCDDomain (const ring &R)
bool IsCommutative (const ring &R)
bool IsIntegralDomain (const ring &R)
bool IsField (const ring &R)
bool IsOrderedDomain (const ring &R)
void swap (RefRingElem f, RefRingElem g)
SparsePolyRing NewPolyRing_DMP (const ring &CoeffRing, const PPMonoid &PPM)
SparsePolyRing NewPolyRing_DMP (const ring &CoeffRing, const std::vector< symbol > &IndetNames, const PPOrdering &ord)
SparsePolyRing NewPolyRing_DMP (const ring &CoeffRing, const std::vector< symbol > &IndetNames)
 Default ordering is StdDegRevLex.
SparsePolyRing NewPolyRing_DMP (const ring &CoeffRing, std::size_t NumIndets)
 Default ordering is StdDegRevLex.
SparsePolyRing NewPolyRing_DMPII (const ring &CoeffRing, const std::vector< symbol > &IndetNames, const PPOrdering &ord)
SparsePolyRing NewPolyRing_DMPII (const ring &CoeffRing, const std::vector< symbol > &IndetNames)
 Default ordering is StdDegRevLex.
SparsePolyRing NewPolyRing_DMPII (const ring &CoeffRing, std::size_t NumIndets)
 Default ordering is StdDegRevLex.
SparsePolyRing NewPolyRing_DMPI (const ring &CoeffRing, const std::vector< symbol > &IndetNames, const PPOrdering &ord)
SparsePolyRing NewPolyRing_DMPI (const ring &CoeffRing, const std::vector< symbol > &IndetNames)
 Default ordering is StdDegRevLex.
SparsePolyRing NewPolyRing_DMPI (const ring &CoeffRing, std::size_t NumIndets)
 Default ordering is StdDegRevLex.
RingFloat NewRingFloat (size_t MantissaBits)
bool IsRingFloat (const ring &RR)
RingFloat AsRingFloat (const ring &RR)
size_t PrecisionBits (const RingFloat &RR)
bool IsPracticallyEqual (ConstRefRingElem x, ConstRefRingElem y)
QuotientRing NewRingFp (long p)
QuotientRing NewRingFp (const ZZ &P)
QuotientRing NewRingFp (const ideal &I)
bool IsRingFp (const ring &R)
 DO NOT USE this function unless you really know what you're doing!
QuotientRing NewRingFpDouble (long p)
QuotientRing NewRingFpDouble (const ZZ &P)
QuotientRing NewRingFpDouble (const ideal &I)
QuotientRing NewRingFpLog (long p)
QuotientRing NewRingFpLog (const ZZ &P)
QuotientRing NewRingFpLog (const ideal &I)
const ringdomain (const RingHom &phi)
 inline accessor fn
const ringcodomain (const RingHom &phi)
 inline accessor fn
std::ostream & operator<< (std::ostream &out, const RingHom &phi)
bool IsInKer (const ideal &I, const RingHom &phi)
 is I in ker(phi)?
RingHom IdentityHom (const ring &R)
const FractionFieldRingQ ()
 The unique field of rationals.
bool IsQ (const ring &R)
RingHom QEmbeddingHom (const ring &codomain)
 This can produce a partial homomorphism.
std::vector< symbolWANAMES (const std::vector< symbol > &names)
 {x,y,z,..} --> {x,y,z,..,dx,dy,dz,..}
SparsePolyRing NewWeylAlgebra (const ring &CoeffRing, std::size_t NumTrueIndets, const std::vector< std::size_t > &ElimIndets)
SparsePolyRing NewWeylAlgebra (const ring &CoeffRing, const std::vector< symbol > &names, const std::vector< std::size_t > &ElimIndets)
const ringRingZ ()
 The unique ring of integers.
bool IsZ (const ring &R)
RingHom ZEmbeddingHom (const ring &codomain)
void RegisterOp (const std::string &s, ServerOp o)
ServerOpGetOperation (const std::string &s)
void CheckOperationRegistry ()
bool IsVoidOperation (const ServerOp &o)
std::ostream & operator<< (std::ostream &out, const ServerOp &o)
bool IsSmallPrime (unsigned long n)
unsigned long NextSmallPrime (unsigned long n)
unsigned long PrevSmallPrime (unsigned long n)
unsigned long FindPrimRoot (unsigned long p)
unsigned long CurrentPrime (const SmallPrimeSource &ps)
template<typename T>
bool operator== (const SmartPtrIRC< T > &ptr1, const SmartPtrIRC< T > &ptr2)
template<typename T>
bool operator!= (const SmartPtrIRC< T > &ptr1, const SmartPtrIRC< T > &ptr2)
SparsePolyRing NewPolyRing (const ring &CoeffRing, const PPMonoid &PPM)
SparsePolyRing NewPolyRing (const ring &CoeffRing, const std::vector< symbol > &IndetNames, const PPOrdering &ord)
SparsePolyRing NewPolyRing (const ring &CoeffRing, const std::vector< symbol > &IndetNames)
 Default ordering is StdDegRevLex.
SparsePolyRing NewPolyRing (const ring &CoeffRing, std::size_t NumIndets)
 Default ordering is StdDegRevLex.
bool IsSparsePolyRing (const ring &R)
SparsePolyRing AsSparsePolyRing (const ring &R)
const PPMonoidPPM (const SparsePolyRing &Rx)
std::size_t GradingDim (const SparsePolyRing &Rx)
bool IsZeroDim (const ideal &I)
bool IsEnded (const SparsePolyIter &i)
ConstRefRingElem coeff (const SparsePolyIter &i)
ConstRefPPMonoidElem PP (const SparsePolyIter &i)
bool operator== (const SparsePolyIter &i1, const SparsePolyIter &i2)
bool operator!= (const SparsePolyIter &i1, const SparsePolyIter &i2)
ConstMatrix NewZeroMatrix (const ring &R, std::size_t NumRows, std::size_t NumCols)
 Public fn to create a zero matrix.
ConstMatrix NewIdentityMatrix (const ring &R, std::size_t dim)
ConstMatrix NewTransposeMatrix (ConstMatrix M)
ConstMatrix NewSubmatrix (ConstMatrix M, const std::vector< std::size_t > &rows, const std::vector< std::size_t > &cols)
ConstMatrix NewBlockMatrix (ConstMatrix A, ConstMatrix B, ConstMatrix C, ConstMatrix D)
EFGModule NewSubmodule (const EFGModule &M, const std::vector< ModuleElem > &gens)
const std::string & head (const symbol &sym)
std::size_t NumIndices (const symbol &sym)
int index (const symbol &sym, size_t n)
std::ostream & operator<< (std::ostream &out, const symbol &sym)
std::istream & operator>> (std::istream &in, symbol &sym)
int cmp (const symbol &sym1, const symbol &sym2)
bool operator== (const symbol &sym1, const symbol &sym2)
bool operator!= (const symbol &sym1, const symbol &sym2)
bool operator< (const symbol &sym1, const symbol &sym2)
bool operator<= (const symbol &sym1, const symbol &sym2)
bool operator> (const symbol &sym1, const symbol &sym2)
bool operator>= (const symbol &sym1, const symbol &sym2)
std::vector< symbolSymbolRange (const symbol &sym1, const symbol &sym2)
std::vector< symbolSymbolRange (const std::string &head, int lo, int hi)
std::vector< symbolsymbols (const std::string &head1)
std::vector< symbolsymbols (const std::string &head1, const std::string &head2)
std::vector< symbolsymbols (const std::string &head1, const std::string &head2, const std::string &head3)
std::vector< symbolsymbols (const std::string &head1, const std::string &head2, const std::string &head3, const std::string &head4)
double CpuTime ()
 Returns user CPU usage in seconds since start of program.
double RealTime ()
 Returns number of seconds elapsed since some fixed point in the past.
template<typename InputIterator, typename arith_t>
arith_t product (InputIterator begin, InputIterator end, const arith_t &InitialValue)
template<typename arith_t>
arith_t product (const std::list< arith_t > &L)
template<typename arith_t>
arith_t product (const std::vector< arith_t > &V)
template<typename InputIterator, typename arith_t>
arith_t sum (InputIterator begin, InputIterator end, const arith_t &InitialValue)
template<typename arith_t>
arith_t sum (const std::list< arith_t > &L)
template<typename arith_t>
arith_t sum (const std::vector< arith_t > &V)
void F5 (std::vector< CoCoA::RingElem > &GB, const std::vector< CoCoA::RingElem > &I)
void F5 (std::vector< CoCoA::RingElem > &GB, const CoCoA::ideal &I)
FactorList factorize (ConstRefRingElem x)
void ComputeGBasis (PolyList &, const PolyList &)
void ComputeGBasis (VectorList &, const VectorList &)
void ComputeGBasisFrameWork (PolyList &, const PolyList &)
void ComputeElim (VectorList &, const VectorList &, ConstRefPPMonoidElem)
 Not yet implemented.
void ComputeElim (PolyList &, const PolyList &, ConstRefPPMonoidElem)
void ComputeSyz (VectorList &, const VectorList &)
void ComputeSyz (VectorList &, const PolyList &)
void ComputeIntersection (VectorList &, const VectorList &, const VectorList &)
void ComputeIntersection (PolyList &, const PolyList &, const PolyList &)
void ComputeColon (PolyList &, const VectorList &, const VectorList &)
void ComputeColon (PolyList &, const PolyList &, const PolyList &)
void ComputeColon (VectorList &, const VectorList &, const PolyList &)
void ComputeCColon (PolyList &, const VectorList &, const VectorList &)
void ComputeCColon (PolyList &, const PolyList &, const PolyList &)
void ComputeCColon (VectorList &, const VectorList &, const PolyList &)
void ComputeSaturation (VectorList &, const VectorList &, const PolyList &)
void ComputeSaturation (PolyList &, const PolyList &, const PolyList &)
void ComputeSSaturation (PolyList &, const PolyList &, const PolyList &)
void ComputeSSaturation (VectorList &, const VectorList &, const PolyList &)
void ComputeHomogenization (VectorList &, const VectorList &, const PolyList &)
 Not yet implemented.
void ComputeHomogenization (PolyList &, const PolyList &, const PolyList &)
 Not yet implemented.
bool RadicalMembership (const PolyList &, ConstRefRingElem)
void ComputeLT (VectorList &, const VectorList &)
 Not yet implemented.
void ComputeLT (PolyList &, const PolyList &)
bool operator== (const PolyList &, const PolyList &)
void Ordered_Insert (GPairList &, GPair)
void RemoveFromGPList (GPairList &, GPair &)
ConstRefPPMonoidElem LCM (const GPair &gp)
const PPWithMaskLCMwMask (const GPair &gp)
ConstRefRingElem OrdPoly (const GPair &gp)
RingHom CreateNewP2OldPRingHom (const SparsePolyRing &theNewSPR, const SparsePolyRing &theOldSPR)
RingHom CreateOldP2NewPRingHom (const SparsePolyRing &theNewSPR, const SparsePolyRing &theOldSPR)
unsigned int ModuleVarIndex (const SparsePolyRing &)
unsigned int Component (ConstRefPPMonoidElem T, const GRingInfo &theGRI)
GPolyFindReducer (const PPWithMask &pm, const unsigned int component, const Reductors &theReductors)
GPolyFindReducer (const GPoly &, const Reductors &theReductors)
void monic (PolyList &)
void monic (GPolyList &)
void power (RefRingElem theResult, const std::vector< RingElem > &theV, const degree &the_d)
ConstRefPPMonoidElem LPP (const GPoly &f)
ConstRefRingElem LC (const GPoly &f)
const PPWithMaskLPPwMask (const GPoly &f)
const SparsePolyRingowner (const GPoly &gp)
const PPMonoidPPM (const GPoly &gp)
const ringCoeffRing (const GPoly &gp)
PPMonoidElem MakeVarIToNth (const PPMonoid &PPM, const unsigned int, const unsigned int)
SparsePolyRing owner (const PolyList &thePL)
SparsePolyRing owner (const std::vector< RingElem > &thePV)
SparsePolyRing owner (const GPolyList &theGPL)
void PolyList2PolyVectorClear (PolyList &, std::vector< RingElem > &)
void PolyVector2PolyListClear (std::vector< RingElem > &, PolyList &)
SparsePolyRing NewSparsePolyRing (const ring &CoeffRing, const std::vector< symbol > &IndetNames, const PPOrdering &ord)
const GRingInfoGetGRI (const GPolyList &theGPL)
FreeModule owner (const VectorList &theVL)
SparsePolyRing MakeNewPRingFromModule (const FreeModule &FM)
SparsePolyRing MakeNewPRingFromModule (const FreeModule &FM, ModOrdTypeForcing MOType)
SparsePolyRing MakeNewPRingForSimpleEmbedding (const SparsePolyRing &theOldP)
SparsePolyRing MakeNewPRingForSimpleEmbedding (const SparsePolyRing &theOldP, ModOrdTypeForcing MOType)
FreeModule MakeNewFreeModuleForSyz (const GPolyList &GPL)
FreeModule MakeNewFreeModuleForSyz (const VectorList &VL)
FreeModule MakeNewFreeModuleForSyz (const PolyList &PL)
SparsePolyRing MakeElimRingFromOld (const SparsePolyRing &theOldP, const std::vector< long > &theElimVars, const bool IsHomog)
SparsePolyRing MakeNewPRingFromModulePosFirst (const FreeModule &FM, bool HomogInput)
SparsePolyRing MakeNewPRingForSimpleEmbeddingPosFirst (const SparsePolyRing &OldP, bool HomogInput)
GPoly EmbedPoly (ConstRefRingElem p, const GRingInfo &theGRI, const size_t CompIndex)
GPoly EmbedPoly (ConstRefRingElem p, const GRingInfo &theGRI, const degree &the_d, const size_t CompIndex)
GPoly EmbedVector (const ModuleElem &v, const GRingInfo &theGRI)
GPoly EmbedVector (const ModuleElem &v, const GRingInfo &theGRI, const size_t StartingFromCompIndex)
GPolyList EmbedVectorList (const VectorList &theVL, const GRingInfo &theGRI)
GPolyList EmbedVectorList (const VectorList &theVL, const GRingInfo &theGRI, const size_t StartingFromCompIndex)
GPolyList EmbedPolyList (PolyList &thePL, const GRingInfo &theGRI)
GPolyList EmbedPolyList (const PolyList &thePL, const GRingInfo &theGRI, const degree &the_d, const size_t CompIndex)
GPolyList EmbedPolyList (const PolyList &InputPolyList, const GRingInfo &theGRI, const size_t CompIndex)
GPolyList SyzEmbedVectorList (const VectorList &InputVectorList, const GRingInfo &theGRI)
GPolyList SyzEmbedPolyList (const PolyList &InputPolyList, const GRingInfo &theGRI)
GPolyList IntEmbedVectorLists (const VectorList &VL1, const VectorList &VL2, const GRingInfo &theGRI)
GPolyList IntEmbedPolyLists (const PolyList &PL1, const PolyList &PL2, const GRingInfo &theGRI)
GPolyList ColonEmbedVectorLists (const VectorList &VL1, const VectorList &VL2, const GRingInfo &theGRI)
GPolyList ColonEmbedPolyLists (const PolyList &PL1, const PolyList &PL2, const GRingInfo &theGRI)
void SyzEmbedGPolyList (GPolyList &theGPL)
void IntEmbedGPolyList (GPolyList &theGPL1, GPolyList &theGPL2)
void ColonEmbedGPolyList (GPolyList &theGPL, GPoly &the_gp)
ModuleElem DeEmbedPoly (ConstRefRingElem p, const GRingInfo &theGRI, const size_t ComponentsLimit)
ModuleElem DeEmbedPoly (ConstRefRingElem p, const GRingInfo &theGRI)
VectorList DeEmbedPolyList (const PolyList &PL, const GRingInfo &theGRI)
VectorList DeEmbedPolyList (const PolyList &PL, const GRingInfo &theGRI, const std::size_t ComponentsLimit)
void DeEmbedPoly (ModuleElem &theOutputP, const GPoly &the_gp, const size_t ComponentsLimit)
void DeEmbedPoly (ModuleElem &theOutputP, GPoly &the_gp)
void DeEmbedPolyList (VectorList &theOutputVL, GPolyList &theGPL)
void DeEmbedPolyList (VectorList &theOutputVL, const GPolyList &theGPL, const std::size_t ComponentsLimit)
void DeEmbedPoly (RefRingElem theOutputP, GPoly &the_gp)
void DeEmbedPolyList (PolyList &theOutputPL, GPolyList &theGPL, const std::size_t ComponentsLimit)
RingElem DeEmbedPolyToP (ConstRefRingElem the_p, const GRingInfo &theGRI)
PolyList DeEmbedPolyListToPL (const PolyList &PL, const GRingInfo &theGRI, const std::size_t ComponentsLimit)
void PolyList2GPolyList (const PolyList &, GPolyList &, const GRingInfo &)
void GPolyList2PolyList (const GPolyList &, PolyList &)
void PolyList2GPolyListClear (PolyList &, GPolyList &, const GRingInfo &)
void GPolyList2PolyListClear (GPolyList &, PolyList &)
void homogenized (RefRingElem the_hp, ConstRefRingElem the_p, const std::vector< RingElem > the_Y)
 hp = hom(p,y) in the ring with the y's
void homogenized (ModuleElem &the_hv, const ModuleElem &the_v, const GRingInfo &theGRI)
std::vector< long > PolyList2IndexList (const PolyList &)
PPMonoidElem IndexList2PPMonoidElem (const PPMonoid &, const std::vector< long > &)
std::vector< long > PPMonoidElem2IndexList (ConstRefPPMonoidElem)
bool IsHomogeneous (const PolyList &)
bool IsHomogeneous (const VectorList &)
std::vector< degreeDegStructure (ConstRefRingElem)
std::vector< std::vector<
degree > > 
DegStructure (const ModuleElem &)
std::vector< std::vector<
degree > > 
DegStructure (const PolyList &)
std::vector< std::vector<
std::vector< degree > > > 
DegStructure (const VectorList &)
PolyList MakePolyList (ConstRefRingElem)
VectorList MakeVectorList (const ModuleElem &)
RingElem CoeffCommonDenominator (ConstRefRingElem f)
PolyList WithoutDenominators (const PolyList &PL, SparsePolyRing Rx)
PolyList WithDenominator1Hom (const PolyList &PL, SparsePolyRing P)
RingElem HilbertNumeratorMod (PolyRing HSRing, ideal I)
bool lesser (const bool &, const bool &)
bool lesser (const facet &f1, const facet &f2)
bool AreDirectlyConnected (const facet &f1, const facet &f2)
bool contains (const facet &f1, const facet &f2)
bool IsFLesser (const facet &f, const facet &g1, const facet &g2)
facet operator- (const facet &v1, const facet &v2)
facet operator+ (const facet &v1, const facet &v2)
facet FacetIntersection (const facet &v1, const facet &v2)
template<typename T1, typename T2>
int cmp (const T1 &a, const T2 &b)
template<class InputIterator1, class InputIterator2>
int LexCmp3 (InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, InputIterator2 end2)
std::ostream & operator<< (std::ostream &out, const ZZ &N)
std::istream & operator>> (std::istream &in, ZZ &N)
void swap (ZZ &a, ZZ &b)
const ZZ::rtn abs (const ZZ &N)
const ZZ::rtn operator- (const ZZ &N)
const ZZ::rtn operator+ (const ZZ &N1, const ZZ &N2)
const ZZ::rtn operator- (const ZZ &N1, const ZZ &N2)
const ZZ::rtn operator * (const ZZ &N1, const ZZ &N2)
const ZZ::rtn operator/ (const ZZ &N1, const ZZ &N2)
const ZZ::rtn operator% (const ZZ &N1, const ZZ &N2)
const ZZ::rtn operator+ (const ZZ &N1, MachineInteger n2)
const ZZ::rtn operator- (const ZZ &N1, MachineInteger n2)
const ZZ::rtn operator * (const ZZ &N1, MachineInteger n2)
const ZZ::rtn operator/ (const ZZ &N1, MachineInteger n2)
const ZZ::rtn operator% (const ZZ &N1, MachineInteger n2)
const ZZ::rtn operator+ (MachineInteger n1, const ZZ &N2)
const ZZ::rtn operator- (MachineInteger n1, const ZZ &N2)
const ZZ::rtn operator * (MachineInteger n1, const ZZ &N2)
const ZZ::rtn operator/ (MachineInteger n1, const ZZ &N2)
const ZZ::rtn operator% (MachineInteger n1, const ZZ &N2)
const ZZ::rtn power (const ZZ &base, const ZZ &exponent)
const ZZ::rtn power (const ZZ &base, MachineInteger exponent)
const ZZ::rtn power (MachineInteger base, const ZZ &exponent)
const ZZ::rtn power (MachineInteger base, MachineInteger exponent)
void powermod (ZZ &dest, const ZZ &base, const ZZ &exp, const ZZ &modulus)
void powermod (ZZ &dest, const ZZ &base, MachineInteger exp, const ZZ &modulus)
const ZZ::rtn gcd (const ZZ &a, const ZZ &b)
const ZZ::rtn lcm (const ZZ &a, const ZZ &b)
void gcdext (ZZ &g, ZZ &c_a, ZZ &c_b, const ZZ &a, const ZZ &b)
bool invmod (ZZ &dest, const ZZ &r, const ZZ &m)
void add (ZZ &lhs, const ZZ &N1, const ZZ &N2)
void sub (ZZ &lhs, const ZZ &N1, const ZZ &N2)
void mul (ZZ &lhs, const ZZ &N1, const ZZ &N2)
void div (ZZ &lhs, const ZZ &N1, const ZZ &N2)
void mod (ZZ &lhs, const ZZ &N1, const ZZ &N2)
void quorem (ZZ &quo, ZZ &rem, const ZZ &num, const ZZ &den)
void divexact (ZZ &lhs, const ZZ &N1, const ZZ &N2)
void add (ZZ &lhs, const ZZ &N1, MachineInteger n2)
void sub (ZZ &lhs, const ZZ &N1, MachineInteger n2)
void mul (ZZ &lhs, const ZZ &N1, MachineInteger n2)
void div (ZZ &lhs, const ZZ &N1, MachineInteger n2)
void mod (ZZ &lhs, const ZZ &N1, MachineInteger n2)
void quorem (ZZ &quo, ZZ &rem, const ZZ &num, MachineInteger den)
void add (ZZ &lhs, MachineInteger n1, const ZZ &N2)
void sub (ZZ &lhs, MachineInteger n1, const ZZ &N2)
void mul (ZZ &lhs, MachineInteger n1, const ZZ &N2)
void div (ZZ &lhs, MachineInteger n1, const ZZ &N2)
void mod (ZZ &lhs, MachineInteger n1, const ZZ &N2)
void quorem (ZZ &quo, ZZ &rem, MachineInteger num, const ZZ &den)
void neg (ZZ &lhs, const ZZ &rhs)
void abs (ZZ &lhs, const ZZ &rhs)
void gcd (ZZ &lhs, const ZZ &N1, const ZZ &N2)
void lcm (ZZ &lhs, const ZZ &N1, const ZZ &N2)
bool IsZero (const ZZ &N)
bool IsOne (const ZZ &N)
bool IsMinusOne (const ZZ &N)
bool IsPositive (const ZZ &N)
bool IsNegative (const ZZ &N)
int sign (const ZZ &N)
bool IsOdd (const ZZ &N)
bool IsEven (const ZZ &N)
bool IsPPrime (const ZZ &N, unsigned int niters=25)
bool IsPPrime (MachineInteger n, unsigned int NumIters=25)
int cmp (const ZZ &N1, const ZZ &N2)
int cmp (const ZZ &N1, MachineInteger n2)
int cmp (MachineInteger n1, const ZZ &N2)
bool operator== (const ZZ &N1, const ZZ &N2)
bool operator!= (const ZZ &N1, const ZZ &N2)
bool operator> (const ZZ &N1, const ZZ &N2)
bool operator>= (const ZZ &N1, const ZZ &N2)
bool operator< (const ZZ &N1, const ZZ &N2)
bool operator<= (const ZZ &N1, const ZZ &N2)
bool operator== (const ZZ &N1, MachineInteger n2)
bool operator!= (const ZZ &N1, MachineInteger n2)
bool operator> (const ZZ &N1, MachineInteger n2)
bool operator>= (const ZZ &N1, MachineInteger n2)
bool operator< (const ZZ &N1, MachineInteger n2)
bool operator<= (const ZZ &N1, MachineInteger n2)
bool operator== (MachineInteger n1, const ZZ &N2)
bool operator!= (MachineInteger n1, const ZZ &N2)
bool operator> (MachineInteger n1, const ZZ &N2)
bool operator>= (MachineInteger n1, const ZZ &N2)
bool operator< (MachineInteger n1, const ZZ &N2)
bool operator<= (MachineInteger n1, const ZZ &N2)
double mantissa (const ZZ &n)
std::size_t exponent (const ZZ &n)
std::size_t NumDigits (const ZZ &n, int base=2)
double log (const ZZ &n)
ZZ::rtn RangeFactorial (MachineInteger lo, MachineInteger hi)
const ZZ::rtn factorial (const ZZ &N)
const ZZ::rtn factorial (MachineInteger n)
const ZZ::rtn binomial (const ZZ &N, const ZZ &R)
const ZZ::rtn binomial (MachineInteger n, const ZZ &R)
const ZZ::rtn binomial (const ZZ &N, MachineInteger r)
const ZZ::rtn binomial (MachineInteger n, MachineInteger r)
const ZZ::rtn fibonacci (const ZZ &N)
const ZZ::rtn fibonacci (MachineInteger n)
const ZZ::rtn random (const ZZ &lo, const ZZ &hi)
 rnd number in range lo to hi (incl).
const ZZ::rtn random (MachineInteger lo, MachineInteger hi)
 rnd number in range lo to hi (incl).
const ZZ::rtn random (MachineInteger lo, const ZZ &hi)
 rnd number in range lo to hi (incl).
const ZZ::rtn random (const ZZ &lo, MachineInteger hi)
 rnd number in range lo to hi (incl).
mpz_t & mpzref (ZZ &N)
const mpz_t & mpzref (const ZZ &N)

Variables

const unsigned int WordLen = 64


Typedef Documentation

typedef unsigned int CoCoA::SmallFpElem_t
 

Definition at line 28 of file config.H.

typedef unsigned int CoCoA::SmallFpLogElem_t
 

Definition at line 29 of file config.H.

typedef unsigned short CoCoA::SmallExponent_t
 

Definition at line 33 of file config.H.

typedef MemPoolFast CoCoA::MemPool
 

Definition at line 221 of file MemPool.H.

typedef std::list< std::pair<RingElem, unsigned int> > CoCoA::FactorList
 

Definition at line 35 of file TmpFactor.H.

typedef std::list<GPair> CoCoA::GPairList
 

Definition at line 94 of file TmpGPair.H.

typedef std::vector<GPairList> CoCoA::MGPairList
 

Definition at line 102 of file TmpGPair.H.

typedef std::list<GPoly> CoCoA::GPolyList
 

Definition at line 155 of file TmpGPoly.H.

typedef std::list<GPoly*> CoCoA::GPolyPtrList
 

Definition at line 306 of file TmpGPoly.H.

typedef std::vector<GPoly*> CoCoA::GPolyPtrVector
 

Definition at line 307 of file TmpGPoly.H.

typedef std::vector<RingElem> CoCoA::PolyList
 

Definition at line 29 of file TmpGTypes.H.

typedef std::vector<ModuleElem> CoCoA::VectorList
 

Definition at line 33 of file TmpGTypes.H.

typedef std::bitset<WordLen> CoCoA::BitsetWordLen
 

Definition at line 46 of file TmpIsTree.H.

typedef std::list<facet>::const_iterator CoCoA::FacetComplexConstIter
 

Definition at line 123 of file TmpIsTree.H.

typedef std::list<facet>::iterator CoCoA::FacetComplexIter
 

Definition at line 124 of file TmpIsTree.H.

typedef std::vector<std::pair<FacetComplexConstIter,std::vector<FacetComplexConstIter> > >::const_iterator CoCoA::conn_block_const_itr
 

Definition at line 125 of file TmpIsTree.H.

typedef std::vector<std::pair<FacetComplexConstIter,std::vector<FacetComplexConstIter> > >::iterator CoCoA::ConnBlockIter
 

Definition at line 126 of file TmpIsTree.H.


Enumeration Type Documentation

enum CoCoA::SkipTagType
 

Enumerator:
TagWasRead 
GetTag 

Definition at line 37 of file CoCoA4io.H.

enum CoCoA::OpenMathTag
 

Enumerator:
OpenMathObj 
OpenMathApply 
OpenMathInt 
OpenMathSym 
OpenMathAttr 
OpenMathEOF 

Definition at line 105 of file OpenMath.H.

enum CoCoA::ComputationInputAndGradingType
 

Enumerator:
AllGraded 
AllAffine 
AffineInputWithGradedRing 

Definition at line 61 of file TmpGPoly.H.

enum CoCoA::ClearType
 

Enumerator:
clear 

Definition at line 153 of file TmpGPoly.H.

enum CoCoA::ModOrdTypeForcing
 

Enumerator:
NoForcing 
PosWDegTO 
WDegTOPos 
WDegPosTO 

Definition at line 162 of file TmpGReductor.H.


Function Documentation

double CoCoA::round double  x  )  [inline]
 

Definition at line 34 of file ApproxPts.H.

double CoCoA::square double  x  )  [inline]
 

Definition at line 39 of file ApproxPts.H.

void CoCoA::AssertionFailed const char *const   cond,
const char *const   file,
unsigned long  line
 

std::ostream& CoCoA::operator<< std::ostream &  out,
bool3  flag
 

OpenMathOutput& CoCoA::operator<< OpenMathOutput &  out,
bool3  flag
 

bool CoCoA::IsDefinitelyFalse bool3  flag  )  [inline]
 

Definition at line 74 of file bool3.H.

References CoCoA::bool3::DefinitelyFalse, and CoCoA::bool3::myTruthValue.

bool CoCoA::IsUncertain bool3  flag  )  [inline]
 

Definition at line 78 of file bool3.H.

References CoCoA::bool3::myTruthValue, and CoCoA::bool3::uncertain.

bool CoCoA::IsDefinitelyTrue bool3  flag  )  [inline]
 

Definition at line 82 of file bool3.H.

References CoCoA::bool3::DefinitelyTrue, and CoCoA::bool3::myTruthValue.

RingHom CoCoA::CanonicalHom const ring &  domain,
const ring &  codomain
 

std::string CoCoA::ReadOperationString std::istream &  in  ) 
 

void CoCoA::ReadPolyList std::istream &  in,
PolyList PL,
const SparsePolyRing &  P,
SkipTagType  ST
 

void CoCoA::ReadVectorList std::istream &  in,
VectorList L,
const FreeModule &  FM,
SkipTagType  ST
 

matrix CoCoA::ReadIntegerMatrix std::istream &  in,
SkipTagType  ST
 

matrix CoCoA::ReadRationalMatrix std::istream &  in,
SkipTagType  ST
 

FreeModule CoCoA::ReadFreeModule std::istream &  in,
SkipTagType  ST
 

SparsePolyRing CoCoA::ReadPolyRing std::istream &  in,
SkipTagType  ST
 

PPOrdering CoCoA::ReadPolyRingOrdering std::istream &  in,
size_t  NumInds,
SkipTagType  ST
 

void CoCoA::PrintTimeToLog double  T  ) 
 

void CoCoA::PrintTimeToCoCoA4 double  T  ) 
 

void CoCoA::PrintVersionToCoCoA4  ) 
 

void CoCoA::WritePolyRing std::ostream &  out,
const SparsePolyRing &  P
 

void CoCoA::WriteMonomials std::ostream &  out,
ConstRefRingElem  p
 

void CoCoA::WriteMatrixInVar std::ostream &  out,
const std::string &  VarName,
const matrix &  M
 

void CoCoA::WritePolyListInVar std::ostream &  out,
const std::string &  VarName,
const PolyList PL
 

void CoCoA::WriteVectorListInVar std::ostream &  out,
const std::string &  VarName,
const VectorList VL
 

void CoCoA::AssertTag const std::string &  input_tag,
const std::string &  expected_tag
 

void CoCoA::SkipTag std::istream &  in,
const std::string &  expected_tag
 

void CoCoA::ThrowInputError const std::string &  unknown_tag  ) 
 

SparsePolyRing CoCoA::NewPolyRingServer ZZ  charact,
size_t  FloatPrecision,
size_t  NumParams,
const PPOrdering &  O
 

bool CoCoA::convert long &  lhs,
const ZZ &  src
 

Referenced by CoCoA::CheckedCast< T >::CheckedCast().

bool CoCoA::convert int &  lhs,
const ZZ &  src
 

bool CoCoA::convert unsigned long &  lhs,
const ZZ &  src
 

bool CoCoA::convert unsigned int &  lhs,
const ZZ &  src
 

bool CoCoA::convert std::string &  lhs,
const ZZ &  src,
int  base = 10
 

bool CoCoA::convert ZZ &  lhs,
const std::string &  src,
int  base = 0
 

bool CoCoA::convert ZZ &  num,
ZZ &  den,
double  z
 

convert double z into an exact rational ==> den will be a power of 2.

bool CoCoA::convert double &  z,
const ZZ &  N
 

conversion may discard information!

bool CoCoA::convert double &  z,
const ZZ &  num,
const ZZ &  den
 

conversion may discard information!

bool CoCoA::convert long &  dest,
const unsigned long &  src
[inline]
 

Definition at line 50 of file convert.H.

bool CoCoA::convert long &  dest,
const unsigned int &  src
[inline]
 

Definition at line 53 of file convert.H.

bool CoCoA::convert long &  dest,
const unsigned short &  src
[inline]
 

Definition at line 56 of file convert.H.

bool CoCoA::convert long &  dest,
const unsigned char &  src
[inline]
 

Definition at line 59 of file convert.H.

size_t CoCoA::GradingDim const degree &  d  )  [inline]
 

Computes "dimension" of the degree.

Definition at line 136 of file degree.H.

References CoCoA::degree::myGradingDim().

Referenced by GradingDim(), CoCoA::SparsePolyRingBase::myGradingDim(), and CoCoA::GRingInfo::myY().

degree CoCoA::operator+ const degree &  d1,
const degree &  d2
 

Computes d1+d2.

degree CoCoA::operator- const degree &  d1,
const degree &  d2
 

Computes d1-d2.

degree CoCoA::top const degree &  d1,
const degree &  d2
 

i-th compt is max(d1[i], d2[i])

int CoCoA::cmp const degree &  d1,
const degree &  d2
 

lex comparison, result is <0,=0,>0

Referenced by LexCmp3(), operator!=(), operator<(), operator<=(), operator==(), operator>(), and operator>=().

void CoCoA::SetComponent degree &  d,
std::size_t  index,
const ZZ &  value
 

void CoCoA::SetComponent degree &  d,
std::size_t  index,
long  value
 

std::ostream& CoCoA::operator<< std::ostream &  out,
const degree &  d
 

prints out the degree, handles dim=1 specially.

int CoCoA::FastCmp const degree &  d1,
const degree &  d2
[inline]
 

Definition at line 88 of file degree.H.

References LexCmp3(), CoCoA::degree::myCoords, and CoCoA::degree::myGradingDim().

bool CoCoA::operator< const degree &  d1,
const degree &  d2
[inline]
 

Definition at line 100 of file degree.H.

References cmp().

bool CoCoA::operator<= const degree &  d1,
const degree &  d2
[inline]
 

Definition at line 106 of file degree.H.

References cmp().

bool CoCoA::operator> const degree &  d1,
const degree &  d2
[inline]
 

Definition at line 112 of file degree.H.

References cmp().

bool CoCoA::operator>= const degree &  d1,
const degree &  d2
[inline]
 

Definition at line 118 of file degree.H.

References cmp().

bool CoCoA::operator== const degree &  d1,
const degree &  d2
[inline]
 

Definition at line 124 of file degree.H.

References cmp().

bool CoCoA::operator!= const degree &  d1,
const degree &  d2
[inline]
 

Definition at line 130 of file degree.H.

References cmp().

matrix CoCoA::NewDenseMatrix const ring &  R,
std::size_t  NumRows,
std::size_t  NumCols
 

      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 the classes DenseMatrix and DenseMatrixImpl
==================================================================

A normal user should never need to know about the class DenseMatrixImpl;
see below for notes aimed at library maintainers.
This section is solely about the class "DenseMatrix".

An object of type DenseMatrix is a matrix represented in the most
natural way: as an array of its entries.  For instance a DenseMatrix
of 4 rows and three columns will contain 12=4x3 entries.  Contrast this
with the a SparseMatrix where the values (and positions) of only
the non-zero entries are recorded.

To create a DenseMatrix over the ring R with r rows and c columns use
the call
  NewDenseMatrix(R, r, c)
Initially the matrix will be filled with zero values.


Currently a DenseMatrix has no special operations in addition to those
for a general matrix (see documentation in the file matrix.txt).  Here
is a brief summary of the operations
  BaseRing(M)    -- the ring to which the matrix entries belong
  NumRows(M)     -- the number of rows in M (may be zero)
  NumCols(M)     -- the number of columns in M (may be zero)

  cout << M      -- print out the value of the matrix

  M(i, j)        -- a copy of entry (i,j) in the matrix
  SetEntry(M,i,j,r)   -- assign the RingElem r to entry (i,j) of matrix M
  SetEntry(M,i,j,n)   -- assign the integer n to entry (i,j) of matrix M



Maintainer documentation for the classes DenseMatrix and DenseMatrixImpl
========================================================================

The class "DenseMatrix" is just a reference counting smart-pointer to an
object of type derived from DenseMatrixImpl; this is analogous to the
way rings are implemented.  The class DenseMatrix is derived from
matrix, so that a DenseMatrix may be used anywhere a matrix is required.


DenseMatrixImpl is a concrete class derived from MatrixBase.  As such it
supplies definitions for all pure virtual functions (see matrix.txt).
DenseMatrixImpl represents the value of a matrix as an object of type
   vector< vector<RingElem> >
The convention used is that the outer vector has an entry for each row,
and each inner vector contains the values of that row.  The indices of
a matrix entry correspond directly to the vector<> indices needed to
get at the value of that entry.

Note that each entry in a DenseMatrixImpl is a full RingElem, so there
is considerable redundancy in having multiple copies of the ring to
which the entries belong.  The primary design goal was to keep the
implementation as simple as possible (without worrying about run-time
performance).

A DenseMatrixImpl object keeps explicit track of its own size (in the
data members myNumRows and myNumColumns).  This makes life easier when
handling matrices one of whose dimensions is zero.  The space overhead
should normally be utterly negligible.

Member functions accepting indices use CoCoA_ASSERT to check the
validity of the index values.  This is useful during debugging but
should cost nothing when compiled with debugging turned off.


Bugs and Shortcomings
=====================

This is a first implementation: simplicity was paramount, efficiency disregarded.

The code and documentation are both new and little tried.

matrix CoCoA::NewDenseMatrix const ring &  R,
std::size_t  NumRows,
std::size_t  NumCols,
const std::vector< std::vector< int > > &  M
 

matrix CoCoA::NewDenseMatrix ConstMatrix  M  ) 
 

void CoCoA::inverse matrix &  lhs,
ConstMatrix  M
 

void CoCoA::adjoint matrix &  lhs,
ConstMatrix  M
 

void CoCoA::mul matrix &  lhs,
ConstMatrix  M1,
ConstMatrix  M2
 

matrix CoCoA::NewDiagMatrix const ring &  R,
std::size_t  NumRows,
std::size_t  NumCols
 

      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 files DiagMatrix
=======================================

The functions in these files are for manipulating diagonal matrices,
i.e. matrices in which every entry not on the main diagonal is zero.

A typical CoCoA Library user need know about only the following two
functions for creating diagonal matrices:

  NewDiagMatrix(R, rows, cols)
  -- this creates a new diagonal matrix (over R) of the given
     dimensions and whose diagonal entries are initially all zero.

  NewDiagMatrix(R, rows, cols, DiagEntries)
  -- this creates a new diagonal matrix (over R) of the given
     dimensions and whose diagonal entries are initially copies
     of the values in the std::vector DiagEntries; so the matrix
     entry in position (i,i) is initially DiagEntries[i].

A run-time error (ERR::ConstMatEntry) will result if the program
attempts to assign to any off-diagonal entry in a DiagMatrix (even if
the value being assigned is zero).  The only permitted modifying
row/column operations are those which multiply a row/column by a scalar
value; all other modifying row/column operations will produce a run-time
error (ERR::ConstMatEntry).



Maintainer documentation for files DiagMatrix
=============================================

The implementation is straightforward, though will appear more complex
than one might first imagine because the code allows for non-square
diagonal matrices -- the only modifiable entries are those on the
leading diagonal.  I have deliberately added a check in the constructors
to allow only square diagonal matrices (see notes below).

Those roles of the four data members are pretty obvious, as are their
types (except for [myDiagEntries], see notes).


Bugs, Shortcomings and other ideas
==================================

Why is [myDiagEntries] a vector of RingElems instead of a vector
of [RingElemRawPtr]s?

Why are member fns throwing errors instead of using CoCoA_ASSERT?

Should DiagMatrix be restricted to being a square matrix?
Currently the constructors enforce this, but the other member
functions have been written to handle non-square matrices
(the only entries which may be non-zero are those having equal
row and column indices).

Should the code allow zero to be assigned to off-diagonal positions?
Analogously for row/column ops which in that particular instance
would not require changing an off-diagonal entry to a non-zero value?

Should there be a constructor from a matrix of unknown type which
simply picks out the diagonal entries?  What would happen if there
were non-zero off-diagonal entries?

=============================================================================

matrix CoCoA::NewDiagMatrix const ring &  R,
std::size_t  NumRows,
std::size_t  NumCols,
std::vector< RingElem >  DiagEntries
 

void CoCoA::deriv DistrMPoly &  lhs,
const DistrMPoly &  ,
std::size_t  IndetIndex
 

void CoCoA::deriv DistrMPoly &  lhs,
const DistrMPoly &  f,
ConstRefPPMonoidElem  x
 

bool CoCoA::IsCompatible const DistrMPoly &  f,
const DistrMPoly &  g
 

std::size_t CoCoA::NumTerms const DistrMPoly &  f  ) 
 

ConstRefRingElem CoCoA::LC const DistrMPoly &  f  ) 
 

RingElem CoCoA::content const DistrMPoly &  f  ) 
 

ConstRefPPMonoidElem CoCoA::LPP const DistrMPoly &  f  ) 
 

Referenced by LPP().

int CoCoA::CmpLPP const DistrMPoly &  f,
const DistrMPoly &  g
[inline]
 

Definition at line 266 of file DistrMPoly.H.

References CoCoA_ASSERT, IsZero(), CoCoA::DistrMPoly::myPPM, CoCoA::DistrMPoly::mySummands, and raw().

void CoCoA::MoveLM DistrMPoly &  f,
DistrMPoly &  g
 

long CoCoA::log const DistrMPoly &  f,
std::size_t  IndetIndex
 

Referenced by Component().

void CoCoA::DivLM DistrMPoly &  lhs,
const DistrMPoly &  f,
const DistrMPoly &  g
 

bool CoCoA::IsZeroAddLCs DistrMPoly &  f,
DistrMPoly &  g
 

void CoCoA::add DistrMPoly &  lhs,
const DistrMPoly &  g,
const DistrMPoly &  h
 

void CoCoA::sub DistrMPoly &  lhs,
const DistrMPoly &  g,
const DistrMPoly &  h
 

bool CoCoA::div DistrMPoly &  lhs,
const DistrMPoly &  g,
const DistrMPoly &  h
 

void CoCoA::gcd DistrMPoly &  lhs,
const DistrMPoly &  g,
const DistrMPoly &  h
 

void CoCoA::output std::ostream &  out,
const DistrMPoly &  f
 

bool CoCoA::IsPrintAtom const DistrMPoly &  f  ) 
 

void CoCoA::output OpenMathOutput &  OMOut,
const DistrMPoly &  f
 

bool CoCoA::IsZero const DistrMPoly &  f  ) 
 

Referenced by CmpLPP(), IsZero(), LC(), LPP(), sign(), and StdDeg().

bool CoCoA::IsOne const DistrMPoly &  f  ) 
 

bool CoCoA::IsMinusOne const DistrMPoly &  f  ) 
 

bool CoCoA::IsConstant const DistrMPoly &  f  ) 
 

bool CoCoA::IsIndet std::size_t &  index,
const DistrMPoly &  f
 

bool CoCoA::IsEqual const DistrMPoly &  f,
const DistrMPoly &  g
 

void CoCoA::WeylMul DistrMPoly &  lhs,
const DistrMPoly &  g,
const DistrMPoly &  h
 

void CoCoA::WeylDiv DistrMPoly &  lhs,
const DistrMPoly &  g,
const DistrMPoly &  h
 

bool CoCoA::IsEnded const DistrMPoly::iter &  i  )  [inline]
 

Definition at line 296 of file DistrMPoly.H.

References CoCoA::DistrMPoly::iter::IamEnded().

Referenced by coeff(), and PP().

ConstRefRingElem CoCoA::coeff const DistrMPoly::iter &  i  )  [inline]
 

Definition at line 331 of file DistrMPoly.H.

References CoCoA_ERROR, IsEnded(), CoCoA::DistrMPoly::iter::myCoeff(), and CoCoA::ERR::PolyIterEnded.

ConstRefPPMonoidElem CoCoA::PP const DistrMPoly::iter &  i  )  [inline]
 

Definition at line 344 of file DistrMPoly.H.

References CoCoA_ERROR, IsEnded(), CoCoA::DistrMPoly::iter::myPP(), and CoCoA::ERR::PolyIterEnded.

Referenced by LCM(), and LPP().

void CoCoA::swap DistrMPoly &  f,
DistrMPoly &  g
[inline]
 

Definition at line 375 of file DistrMPoly.H.

References CoCoA::DistrMPoly::ourSwap().

void CoCoA::deriv DistrMPolyInlFpPP &  lhs,
const DistrMPolyInlFpPP &  ,
std::size_t  IndetIndex
 

void CoCoA::deriv DistrMPolyInlFpPP &  lhs,
const DistrMPolyInlFpPP &  f,
ConstRefPPMonoidElem  x
 

bool CoCoA::IsCompatible const DistrMPolyInlFpPP &  f,
const DistrMPolyInlFpPP &  g
 

std::size_t CoCoA::NumTerms const DistrMPolyInlFpPP &  f  ) 
 

const DistrMPolyInlFpPP::InlineFpElem_t& CoCoA::LC const DistrMPolyInlFpPP &  f  ) 
 

ConstRefPPMonoidElem CoCoA::LPP const DistrMPolyInlFpPP &  f  ) 
 

int CoCoA::CmpLPP const DistrMPolyInlFpPP &  f,
const DistrMPolyInlFpPP &  g
[inline]
 

Definition at line 273 of file DistrMPolyInlFpPP.H.

References CoCoA_ASSERT, IsZero(), CoCoA::DistrMPolyInlFpPP::myOrdvArith, and CoCoA::DistrMPolyInlFpPP::mySummands.

void CoCoA::MoveLM DistrMPolyInlFpPP &  f,
DistrMPolyInlFpPP &  g
 

long CoCoA::log const DistrMPolyInlFpPP &  f,
std::size_t  IndetIndex
 

void CoCoA::DivLM DistrMPolyInlFpPP &  lhs,
const DistrMPolyInlFpPP &  f,
const DistrMPolyInlFpPP &  g
 

bool CoCoA::IsZeroAddLCs DistrMPolyInlFpPP &  f,
DistrMPolyInlFpPP &  g
 

void CoCoA::add DistrMPolyInlFpPP &  lhs,
const DistrMPolyInlFpPP &  g,
const DistrMPolyInlFpPP &  h
 

void CoCoA::sub DistrMPolyInlFpPP &  lhs,
const DistrMPolyInlFpPP &  g,
const DistrMPolyInlFpPP &  h
 

bool CoCoA::div DistrMPolyInlFpPP &  lhs,
const DistrMPolyInlFpPP &  g,
const DistrMPolyInlFpPP &  h
 

void CoCoA::output std::ostream &  out,
const DistrMPolyInlFpPP &  f
 

bool CoCoA::IsZero const DistrMPolyInlFpPP &  f  ) 
 

bool CoCoA::IsEqual const DistrMPolyInlFpPP &  f,
const DistrMPolyInlFpPP &  g
 

void CoCoA::WeylMul DistrMPolyInlFpPP &  lhs,
const DistrMPolyInlFpPP &  g,
const DistrMPolyInlFpPP &  h
 

void CoCoA::WeylDiv DistrMPolyInlFpPP &  lhs,
const DistrMPolyInlFpPP &  g,
const DistrMPolyInlFpPP &  h
 

bool CoCoA::IsEnded const DistrMPolyInlFpPP::iter &  i  )  [inline]
 

Definition at line 303 of file DistrMPolyInlFpPP.H.

References CoCoA::DistrMPolyInlFpPP::iter::IamEnded().

ConstRefRingElem CoCoA::coeff const DistrMPolyInlFpPP::iter &  i  )  [inline]
 

Definition at line 338 of file DistrMPolyInlFpPP.H.

References CoCoA_ERROR, IsEnded(), CoCoA::DistrMPolyInlFpPP::iter::myCoeff(), and CoCoA::ERR::PolyIterEnded.

ConstRefPPMonoidElem CoCoA::PP const DistrMPolyInlFpPP::iter &  i  )  [inline]
 

Definition at line 351 of file DistrMPolyInlFpPP.H.

References CoCoA_ERROR, IsEnded(), CoCoA::DistrMPolyInlFpPP::iter::myPP(), and CoCoA::ERR::PolyIterEnded.

void CoCoA::swap DistrMPolyInlFpPP &  f,
DistrMPolyInlFpPP &  g
[inline]
 

Definition at line 489 of file DistrMPolyInlFpPP.H.

References CoCoA::DistrMPolyInlFpPP::ourSwap().

void CoCoA::deriv DistrMPolyInlPP &  lhs,
const DistrMPolyInlPP &  ,
std::size_t  IndetIndex
 

void CoCoA::deriv DistrMPolyInlPP &  lhs,
const DistrMPolyInlPP &  f,
ConstRefPPMonoidElem  x
 

const ring & CoCoA::CoeffRing const DistrMPolyInlPP &  f  )  [inline]
 

Definition at line 254 of file DistrMPolyInlPP.H.

References CoCoA::DistrMPolyInlPP::myCoeffRing.

Referenced by CoeffRing().

const PPMonoid & CoCoA::PPM const DistrMPolyInlPP &  f  )  [inline]
 

Definition at line 260 of file DistrMPolyInlPP.H.

References CoCoA::DistrMPolyInlPP::myPPM.

Referenced by indets(), one(), CoCoA::PPMonoid::operator==(), CoCoA::module::operator==(), and PPM().

bool CoCoA::IsCompatible const DistrMPolyInlPP &  f,
const DistrMPolyInlPP &  g
 

std::size_t CoCoA::NumTerms const DistrMPolyInlPP &  f  ) 
 

ConstRefRingElem CoCoA::LC const DistrMPolyInlPP &  f  ) 
 

RingElemRawPtr& CoCoA::RawLC DistrMPolyInlPP &  f  ) 
 

const RingElemRawPtr& CoCoA::RawLC const DistrMPolyInlPP &  f  ) 
 

RingElem CoCoA::content const DistrMPolyInlPP &  f  ) 
 

ConstRefPPMonoidElem CoCoA::LPP const DistrMPolyInlPP &  f  ) 
 

int CoCoA::CmpLPP const DistrMPolyInlPP &  f,
const DistrMPolyInlPP &  g
[inline]
 

Definition at line 279 of file DistrMPolyInlPP.H.

References CoCoA_ASSERT, IsZero(), CoCoA::DistrMPolyInlPP::myOrdvArith, and CoCoA::DistrMPolyInlPP::mySummands.

void CoCoA::MoveLM DistrMPolyInlPP &  f,
DistrMPolyInlPP &  g
 

long CoCoA::log const DistrMPolyInlPP &  f,
std::size_t  IndetIndex
 

void CoCoA::DivLM DistrMPolyInlPP &  lhs,
const DistrMPolyInlPP &  f,
const DistrMPolyInlPP &  g
 

bool CoCoA::IsZeroAddLCs DistrMPolyInlPP &  f,
DistrMPolyInlPP &  g
 

void CoCoA::add DistrMPolyInlPP &  lhs,
const DistrMPolyInlPP &  g,
const DistrMPolyInlPP &  h
 

void CoCoA::sub DistrMPolyInlPP &  lhs,
const DistrMPolyInlPP &  g,
const DistrMPolyInlPP &  h
 

bool CoCoA::div DistrMPolyInlPP &  lhs,
const DistrMPolyInlPP &  g,
const DistrMPolyInlPP &  h
 

void CoCoA::gcd DistrMPolyInlPP &  lhs,
const DistrMPolyInlPP &  g,
const DistrMPolyInlPP &  h
 

void CoCoA::output std::ostream &  out,
const DistrMPolyInlPP &  f
 

bool CoCoA::IsPrintAtom const DistrMPolyInlPP &  f  ) 
 

void CoCoA::output OpenMathOutput &  OMOut,
const DistrMPolyInlPP &  f
 

bool CoCoA::IsZero const DistrMPolyInlPP &  f  ) 
 

bool CoCoA::IsOne const DistrMPolyInlPP &  f  ) 
 

bool CoCoA::IsMinusOne const DistrMPolyInlPP &  f  ) 
 

bool CoCoA::IsConstant const DistrMPolyInlPP &  f  ) 
 

bool CoCoA::IsIndet std::size_t &  index,
const DistrMPolyInlPP &  f
 

bool CoCoA::IsEqual const DistrMPolyInlPP &  f,
const DistrMPolyInlPP &  g
 

void CoCoA::WeylMul DistrMPolyInlPP &  lhs,
const DistrMPolyInlPP &  g,
const DistrMPolyInlPP &  h
 

void CoCoA::WeylDiv DistrMPolyInlPP &  lhs,
const DistrMPolyInlPP &  g,
const DistrMPolyInlPP &  h
 

bool CoCoA::IsEnded const DistrMPolyInlPP::iter &  i  )  [inline]
 

Definition at line 309 of file DistrMPolyInlPP.H.

References CoCoA::DistrMPolyInlPP::iter::IamEnded().

ConstRefRingElem CoCoA::coeff const DistrMPolyInlPP::iter &  i  )  [inline]
 

Definition at line 344 of file DistrMPolyInlPP.H.

References CoCoA_ERROR, IsEnded(), CoCoA::DistrMPolyInlPP::iter::myCoeff(), and CoCoA::ERR::PolyIterEnded.

ConstRefPPMonoidElem CoCoA::PP const DistrMPolyInlPP::iter &  i  )  [inline]
 

Definition at line 357 of file DistrMPolyInlPP.H.

References CoCoA_ERROR, IsEnded(), CoCoA::DistrMPolyInlPP::iter::myPP(), and CoCoA::ERR::PolyIterEnded.

void CoCoA::swap DistrMPolyInlPP &  f,
DistrMPolyInlPP &  g
[inline]
 

Definition at line 389 of file DistrMPolyInlPP.H.

References CoCoA::DistrMPolyInlPP::ourSwap().

std::ostream& CoCoA::operator<< std::ostream &  out,
const DivMask &  dm
 

std::ostream& CoCoA::operator<< std::ostream &  out,
const DivMaskRule &  DMR
 

DivMaskRule CoCoA::NewDivMaskNull  ) 
 

DivMaskRule CoCoA::NewDivMaskSingleBit  ) 
 

DivMaskRule CoCoA::NewDivMaskSingleBitWrap  ) 
 

DivMaskRule CoCoA::NewDivMaskEvenPowers  ) 
 

DivMaskRule CoCoA::NewDivMaskHashing  ) 
 

const DivMask::mask_t CoCoA::bits const DivMask &  dm  )  [inline]
 

Definition at line 117 of file DivMask.H.

References CoCoA::DivMask::myBits.

Referenced by IsSubset(), and operator==().

bool CoCoA::operator== const DivMask &  dm1,
const DivMask &  dm2
[inline]
 

Definition at line 122 of file DivMask.H.

References bits().

bool CoCoA::operator!= const DivMask &  dm1,
const DivMask &  dm2
[inline]
 

Definition at line 127 of file DivMask.H.

bool CoCoA::IsSubset const DivMask &  dm1,
const DivMask &  dm2
[inline]
 

Definition at line 133 of file DivMask.H.

References bits().

Referenced by IsDivisibleFast().

std::size_t CoCoA::NumCompts const EFGModule &  M  )  [inline]
 

Definition at line 130 of file EFGModule.H.

const std::vector< ModuleElem > & CoCoA::gens const EFGModule &  M  )  [inline]
 

Definition at line 142 of file EFGModule.H.

Referenced by F5().

const std::vector< ModuleElem > & CoCoA::TidyGens const EFGModule &  M  )  [inline]
 

Definition at line 148 of file EFGModule.H.

bool CoCoA::IsEFGModule const module &  M  )  [inline]
 

Definition at line 85 of file EFGModule.H.

References CoCoA::module::myRawPtr().

Referenced by AsEFGModule(), and CoCoA::EFGModule::EFGModule().

EFGModule CoCoA::AsEFGModule const module &  M  )  [inline]
 

Definition at line 92 of file EFGModule.H.

References CoCoA_ERROR, IsEFGModule(), CoCoA::module::myRawPtr(), and CoCoA::ERR::NotEFGModule.

const FreeModule& CoCoA::AmbientFreeModule const EFGModule &  M  )  [inline]
 

Definition at line 136 of file EFGModule.H.

std::ostream& CoCoA::operator<< std::ostream &  out,
const ErrorInfo &  err
 

void CoCoA::ANNOUNCE const ErrorInfo &  err  ) 
 

void CoCoA::error const ErrorInfo &  err  ) 
 

ideal CoCoA::NewFieldIdeal const ring &  k,
const std::vector< RingElem > &  gens
 

FieldIdealImpl -- the simple ideals of a field.

      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 files FieldIdeal*
========================================

The structure of ideals in a field is so simple that it is usually
ignored completely: there are just two ideals being the zero ideal
and the whole field.  Nonetheless it is helpful to have an
implementation of them.

There is only one publicly callable function here

   NewFieldIdeal(k, gens)

where k is a CoCoA::ring which represents a field, and gens is a
std::vector<CoCoA::RingElem> being a collection of generators
(RingElem values belonging to k).  It creates a CoCoA::ideal
which represents the ideal of k generated by the elements of gens;
gens may be empty.

For operations on ideals, please see ideal.txt.


Maintainer documentation for files FieldIdeal*
==============================================

The implementation is slightly more complex than one might naively
expect: the primary complication is simply the need to retain the list
of generators as specified by the user.

myTidyGensValue is either empty or it contains a single copy of RingElem(k, 1)
according as the ideal is zero or the whole field.


Bugs, Shortcomings, and other ideas
===================================

One would like to think that code so short and so simple couldn't
possibly harbour any nasty surprises.  Then again one might just
be surprised...

I definitely do not like the name of the function GetPtr; perhaps import?
What is the correct way to achieve the end I want to achieve?

FractionField CoCoA::NewFractionField const ring &  R  ) 
 

bool CoCoA::IsFractionField const ring &  Q  ) 
 

FractionField CoCoA::AsFractionField const ring &  R  ) 
 

const ring& CoCoA::BaseRing const FractionField &  Q  ) 
 

const RingHom& CoCoA::EmbeddingHom const FractionField &  FrF  ) 
 

RingHom CoCoA::InducedHom const FractionField &  FrF,
const RingHom &  InducingHom
 

RingElem CoCoA::num ConstRefRingElem  q  ) 
 

RingElem CoCoA::den ConstRefRingElem  q  ) 
 

FreeModule CoCoA::NewFreeModule const ring &  R,
std::size_t  NumCompts
 

bool CoCoA::IsFreeModule const module &  M  ) 
 

FreeModule CoCoA::AsFreeModule const module &  M  ) 
 

size_t CoCoA::FirstNonZeroPos const ModuleElem &  v  ) 
 

const std::vector<degree>& CoCoA::shifts const FreeModule &  M  ) 
 

defined only if GradedFreeModuleImpl

const ModuleTermOrdering& CoCoA::ordering const FreeModule &  M  ) 
 

defined only if GradedFreeModuleImpl

Referenced by GradingDim().

FreeModule CoCoA::NewGradedFreeModule const SparsePolyRing &  P,
std::size_t  NumCompts
 

this is not intended for public use: NewFreeModule is intelligent

FreeModule CoCoA::NewFreeModule const ring &  P,
const ModuleTermOrdering &  O
 

bool CoCoA::IsGradedFreeModule const module &  M  ) 
 

std::size_t CoCoA::LPos const ModuleElem &  v  ) 
 

degree CoCoA::wdeg const ModuleElem &  v  ) 
 

int CoCoA::CmpWDeg const ModuleElem &  v1,
const ModuleElem &  v2
 

ConstRefPPMonoidElem CoCoA::LPP const ModuleElem &  v  ) 
 

bool CoCoA::IsHomogeneous const ModuleElem &  v  ) 
 

std::ostream& CoCoA::operator<< std::ostream &  ,
const geobucket & 
 

void CoCoA::AddClear RefRingElem  f,
geobucket &  gbk
 

void CoCoA::ReductionStep geobucket &  gbk,
ConstRefRingElem  g,
std::size_t  RedLen
 

void CoCoA::ReductionStepGCD geobucket &  gbk,
ConstRefRingElem  g,
RefRingElem  FScale,
std::size_t  RedLen
 

bool CoCoA::IsZero const geobucket::bucket &  b  )  [inline]
 

Definition at line 196 of file geobucket.H.

References IsZero(), and CoCoA::geobucket::bucket::myPoly.

ConstRefPPMonoidElem CoCoA::LPP const geobucket &  gbk  )  [inline]
 

Definition at line 202 of file geobucket.H.

References CoCoA::geobucket::IhaveLM, LPP(), CoCoA::geobucket::myBuckets, and CoCoA::geobucket::mySetLM().

const ring& CoCoA::CoeffRing const geobucket &  g  )  [inline]
 

Definition at line 214 of file geobucket.H.

References CoeffRing(), and CoCoA::geobucket::myPolyRing.

const PPMonoid& CoCoA::PPM const geobucket &  g  )  [inline]
 

Definition at line 218 of file geobucket.H.

References CoCoA::geobucket::myPolyRing, and PPM().

bool CoCoA::IsZero const geobucket &  g  )  [inline]
 

Definition at line 222 of file geobucket.H.

References CoCoA::geobucket::IhaveLM, IsZero(), CoCoA::geobucket::myBuckets, and CoCoA::geobucket::mySetLM().

RingElem CoCoA::operator% long  n,
const ideal &  I
 

reduce n modulo I

RingElem CoCoA::operator% const ZZ &  N,
const ideal &  I
 

reduce N modulo I

RingElem CoCoA::operator% ConstRefRingElem  r,
const ideal &  I
 

reduce r modulo I

RingElem CoCoA::NF ConstRefRingElem  r,
const ideal &  I
[inline]
 

reduce r modulo I, same as %

Definition at line 205 of file ideal.H.

const ring & CoCoA::AmbientRing const ideal &  I  )  [inline]
 

Definition at line 193 of file ideal.H.

Referenced by IsElem().

const ideal CoCoA::operator+ const ideal &  I,
const ideal &  J
 

ideal& CoCoA::operator+= ideal &  I,
const ideal &  J
 

const ideal CoCoA::intersect const ideal &  I,
const ideal &  J
 

const ideal CoCoA::colon const ideal &  I,
const ideal &  J
 

bool CoCoA::IsContained const ideal &  I,
const ideal &  J
 

bool CoCoA::operator== const ideal &  I,
const ideal &  J
 

bool CoCoA::IsElem ConstRefRingElem  r,
const ideal &  I
[inline]
 

Definition at line 199 of file ideal.H.

References AmbientRing(), CoCoA_ERROR, CoCoA::ERR::MixedRings, owner(), and raw().

std::ostream& CoCoA::operator<< std::ostream &  out,
const ideal &  I
 

OpenMathOutput& CoCoA::operator<< OpenMathOutput &  OMOut,
const ideal &  I
 

bool CoCoA::IsZero const ideal &  I  )  [inline]
 

Definition at line 157 of file ideal.H.

bool CoCoA::IsOne const ideal &  I  )  [inline]
 

Definition at line 163 of file ideal.H.

bool CoCoA::IsMaximal const ideal &  I  )  [inline]
 

Definition at line 169 of file ideal.H.

bool CoCoA::IsPrime const ideal &  I  )  [inline]
 

Definition at line 175 of file ideal.H.

const std::vector<RingElem>& CoCoA::gens const ideal &  I  )  [inline]
 

Definition at line 181 of file ideal.H.

const std::vector<RingElem>& CoCoA::TidyGens const ideal &  I  )  [inline]
 

Definition at line 187 of file ideal.H.

std::istream& CoCoA::GlobalInput  ) 
 

      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 files io.H and io.C
==========================================

These files supply four standard global I/O channels for the CoCoA
library.  These channels mimic the global channels present in the C++
STL: [cin], [cout], [cerr], and [clog].

The current choices for these four channels can be obtained by calling
these functions (inside namespace CoCoA):

  std::istream& GlobalInput();
  std::ostream& GlobalOutput();
  std::ostream& GlobalErrput();
  std::ostream& GlobalLogput();


By default the standard global I/O channels for the CoCoA library are
the corresponding ones of the standard C++ library.  Alternative
choices may be specified by calling these functions (see *NOTE*)
  std::istream& SetGlobalInput(std::istream& in);
  std::ostream& SetGlobalOutput(std::ostream& out);
  std::ostream& SetGlobalErrput(std::ostream& err);
  std::ostream& SetGlobalLogput(std::ostream& log);

In each case the value returned is the previous istream/ostream
associated with that channel.

*NOTE* the procedures for changing the settings of the global i/o
streams maintain a reference to the value supplied.  If you use a
local variable as argument, make sure that its value is not destroyed
before you have finished i/o on it.  See the example program ex-io.C.


Maintenance notes for the files io.H and io.C
=============================================

The implementation could hardly be simpler.

As recommended in Meyers's book I have put the globals in an anonymous
namespace.  I chose to use plain pointers for the global variables
[InPtr], [OutPtr], [ErrPtr] and [LogPtr]; references are unsuitable because
they cannot be reseated in C++, and [auto_ptr] is unsuitable because
we do not want to own the streams.  I do not believe that there can be
problems with race-conditions when these four global variables are
initialized since we use only the addresses of [std::cin], etc.
However, there could be race-condition problems with subsequent
changes to the values.


Bugs, Shortcomings, etc
=======================

The names [GlobalInput] etc are rather cumbersome.  It is also annoying to
have to call them as functions.  I could use automatic type conversions
to eliminate the need for the "()"s -- I'll wait until people start
complaining.  Suggestions for better names are welcome.

Another reason for having a new class to represent [GlobalOutput] etc. is
that the template for printing [std::list]s and [std::vector]s could easily
clash with a user's definition of [operator<<].

It is tempting to make the simple functions in io.C into inline functions,
but inlining is tricky with the global variables in an anonymous namespace.
And anyway the minor gain in performance will easily be swamped by the
high costs of actually conducting I/O; so making them inline would
really be quite pointless.

It would be nice to avoid the potential pitfalls of dangling references,
but I do not currently see how to achieve this.

std::ostream& CoCoA::GlobalOutput  ) 
 

std::ostream& CoCoA::GlobalErrput  ) 
 

std::ostream& CoCoA::GlobalLogput  ) 
 

std::istream& CoCoA::SetGlobalInput std::istream &  in  ) 
 

std::ostream& CoCoA::SetGlobalOutput std::ostream &  out  ) 
 

std::ostream& CoCoA::SetGlobalErrput std::ostream &  err  ) 
 

std::ostream& CoCoA::SetGlobalLogput std::ostream &  log  ) 
 

template<typename FwdIterator_t>
void CoCoA::OutputRange std::ostream &  out,
FwdIterator_t  start,
const FwdIterator_t &  end
 

Definition at line 52 of file io.H.

template<typename entry_t>
std::ostream& CoCoA::operator<< std::ostream &  out,
const std::vector< entry_t > &  v
[inline]
 

Definition at line 64 of file io.H.

template<typename entry_t>
std::ostream& CoCoA::operator<< std::ostream &  out,
const std::list< entry_t > &  v
[inline]
 

Definition at line 73 of file io.H.

bool CoCoA::IsNegative const MachineInteger &  n  )  [inline]
 

Definition at line 54 of file MachineInteger.H.

References CoCoA::MachineInteger::IamNegative.

Referenced by sign().

unsigned long CoCoA::AsUnsignedLong const MachineInteger &  n  )  [inline]
 

Definition at line 57 of file MachineInteger.H.

References CoCoA_ASSERT, CoCoA::MachineInteger::IamNegative, and CoCoA::MachineInteger::myValue.

Referenced by IsZero().

long CoCoA::AsSignedLong const MachineInteger &  n  )  [inline]
 

Definition at line 63 of file MachineInteger.H.

References CoCoA_ASSERT, CoCoA::MachineInteger::IamNegative, and CoCoA::MachineInteger::myValue.

unsigned long CoCoA::abs const MachineInteger &  n  )  [inline]
 

Definition at line 69 of file MachineInteger.H.

References CoCoA::MachineInteger::IamNegative, and CoCoA::MachineInteger::myValue.

Referenced by IsOdd().

std::ostream& CoCoA::operator<< std::ostream &  out,
const MachineInteger &  n
 

bool CoCoA::IsZero const MachineInteger &  n  )  [inline]
 

Definition at line 74 of file MachineInteger.H.

References AsUnsignedLong().

int CoCoA::sign const MachineInteger &  n  )  [inline]
 

Definition at line 84 of file MachineInteger.H.

References IsNegative(), and IsZero().

Referenced by LexCmp3().

bool CoCoA::IsOdd const MachineInteger &  n  )  [inline]
 

Definition at line 87 of file MachineInteger.H.

References abs().

Referenced by IsEven().

bool CoCoA::IsEven const MachineInteger &  n  )  [inline]
 

Definition at line 90 of file MachineInteger.H.

References IsOdd().

int CoCoA::cmp const MachineInteger &  n1,
const MachineInteger &  n2
 

unsigned long CoCoA::gcd const MachineInteger &  a,
const MachineInteger &  b
 

std::ostream& CoCoA::operator<< std::ostream &  out,
ConstMatrix  M
 

void CoCoA::AssignZero matrix &  M  ) 
 

void CoCoA::SetEntry matrix &  M,
std::size_t  i,
std::size_t  j,
ConstRefRingElem  r
 

void CoCoA::SetEntry matrix &  M,
std::size_t  i,
std::size_t  j,
long  n
 

void CoCoA::SetEntry matrix &  M,
std::size_t  i,
std::size_t  j,
const ZZ &  N
 

bool CoCoA::IsZeroRow ConstMatrix  M,
std::size_t  i
 

bool CoCoA::IsZeroCol ConstMatrix  M,
std::size_t  j
 

RingElem CoCoA::det ConstMatrix  M  ) 
 

std::size_t CoCoA::rank ConstMatrix  M  ) 
 

const ring& CoCoA::BaseRing ConstMatrix  M  )  [inline]
 

Definition at line 257 of file matrix.H.

std::size_t CoCoA::NumRows ConstMatrix  M  )  [inline]
 

Definition at line 263 of file matrix.H.

std::size_t CoCoA::NumCols ConstMatrix  M  )  [inline]
 

Definition at line 269 of file matrix.H.

void CoCoA::DetByGauss RefRingElem  d,
ConstMatrix  M
 

size_t CoCoA::RankByGauss ConstMatrix  M  ) 
 

void CoCoA::InverseByGauss matrix &  lhs,
ConstMatrix  M
 

void CoCoA::AdjointByInverse matrix &  lhs,
ConstMatrix  M
 

void CoCoA::GrammSchmidtRows matrix &  M  ) 
 

void CoCoA::GrammSchmidtRows matrix &  M,
std::size_t  row
 

bool CoCoA::IsTermOrdering ConstMatrix  M  ) 
 

expects a matrix with entries in an ordered ring

matrix CoCoA::NewPositiveMatrix ConstMatrix  M  ) 
 

returns a matrix with positive entries which defines an equivalent term-ordering

bool CoCoA::IsPositiveGrading ConstMatrix  M,
size_t  GradingDim
 

are the first GradingDim rows of M a positive grading?

matrix CoCoA::NewMatrixConcatHor ConstMatrix  M1,
ConstMatrix  M2
 

matrix CoCoA::NewMatrixConcatVer ConstMatrix  M1,
ConstMatrix  M2
 

matrix CoCoA::NewMatrixConcatDiag ConstMatrix  M1,
ConstMatrix  M2
 

matrix CoCoA::NewMatrixConcatAntiDiag ConstMatrix  M1,
ConstMatrix  M2
 

matrix CoCoA::NewMatrixMinimize ConstMatrix  M  ) 
 

the (ordering) matrix obtained by removing linearly dependent rows

matrix CoCoA::NewDenseMatrixRevLex ring  R,
size_t  n
 

matrix CoCoA::NewMatrixCompleteOrd ConstMatrix  M  ) 
 

matrix CoCoA::NewMatrixElim size_t  NumIndets,
std::vector< size_t >  IndetsToElim
 

matrix CoCoA::NewMatrixElim ConstMatrix  GradingM,
std::vector< size_t >  IndetsToElim,
bool  IsHomog
 

ModuleElem CoCoA::operator- const ModuleElem &   ) 
 

ModuleElem CoCoA::operator+ const ModuleElem &  ,
const ModuleElem & 
 

ModuleElem CoCoA::operator- const ModuleElem &  ,
const ModuleElem & 
 

ModuleElem CoCoA::operator * ConstRefRingElem  ,
const ModuleElem & 
 

ModuleElem CoCoA::operator * const ModuleElem &  ,
ConstRefRingElem 
 

ModuleElem CoCoA::operator/ const ModuleElem &  ,
ConstRefRingElem 
 

ModuleElem& CoCoA::operator+= ModuleElem &  ,
const ModuleElem & 
 

ModuleElem& CoCoA::operator-= ModuleElem &  ,
const ModuleElem & 
 

ModuleElem& CoCoA::operator *= ModuleElem &  ,
ConstRefRingElem 
 

ModuleElem& CoCoA::operator/= ModuleElem &  ,
ConstRefRingElem 
 

ModuleElem CoCoA::operator * long  ,
const ModuleElem & 
 

ModuleElem CoCoA::operator * const ModuleElem &  ,
long 
 

ModuleElem CoCoA::operator/ const ModuleElem &  ,
long 
 

ModuleElem& CoCoA::operator *= ModuleElem &  ,
long 
 

ModuleElem& CoCoA::operator/= ModuleElem &  ,
long 
 

std::ostream& CoCoA::operator<< std::ostream &  ,
const ModuleElem &  v
 

std::ostream& CoCoA::operator<< std::ostream &  ,
const module &  M
 

OpenMathOutput& CoCoA::operator<< OpenMathOutput &  OMOut,
const ModuleElem &  v
 

OpenMathOutput& CoCoA::operator<< OpenMathOutput &  OMOut,
const module &  M
 

bool CoCoA::IsZero const ModuleElem &   ) 
 

bool CoCoA::operator== const ModuleElem &  v1,
const ModuleElem &  v2
 

bool CoCoA::operator!= const ModuleElem &  v1,
const ModuleElem &  v2
 

const ring& CoCoA::BaseRing const module &  M  )  [inline]
 

Definition at line 157 of file module.H.

const ModuleElem& CoCoA::zero const module &  M  )  [inline]
 

Definition at line 163 of file module.H.

const module& CoCoA::owner const ModuleElem &  v  )  [inline]
 

Definition at line 169 of file module.H.

References CoCoA::ModuleElem::myM.

Referenced by CoeffRing(), IsElem(), LC(), LPP(), PPM(), StdDeg(), and swap().

ModuleRawPtr& CoCoA::raw ModuleElem &  v  )  [inline]
 

Definition at line 175 of file module.H.

References CoCoA::ModuleElem::myValue.

Referenced by CmpLPP(), IsElem(), LC(), LPP(), StdDeg(), and swap().

const ModuleRawPtr& CoCoA::raw const ModuleElem &  v  )  [inline]
 

Definition at line 181 of file module.H.

References CoCoA::ModuleElem::myValue.

bool CoCoA::operator!= const module &  M1,
const module  M2
[inline]
 

Definition at line 187 of file module.H.

std::ostream& CoCoA::operator<< std::ostream &  out,
const ModuleTermOrdering &  MTO
 

OpenMathOutput& CoCoA::operator<< OpenMathOutput &  OMOut,
const ModuleTermOrdering &  MTO
 

const std::vector<degree>& CoCoA::shifts const ModuleTermOrdering &  O  ) 
 

std::size_t CoCoA::NumComponents const ModuleTermOrdering &  MTO  ) 
 

std::size_t CoCoA::GradingDim const ModuleTermOrdering &  MTO  ) 
 

const PPOrdering& CoCoA::ModPPOrdering const ModuleTermOrdering &  MTO  ) 
 

ModuleTermOrdering CoCoA::NewWDegTOPos const PPOrdering &  PPO,
std::size_t  NumComponents
 

ModuleTermOrdering CoCoA::NewPosWDegTO const PPOrdering &  PPO,
std::size_t  NumComponents
 

ModuleTermOrdering CoCoA::NewWDegPosTO const PPOrdering &  PPO,
std::size_t  NumComponents
 

ModuleTermOrdering CoCoA::NewWDegTOPos const PPOrdering &  PPO,
const std::vector< degree > &  shifts
 

ModuleTermOrdering CoCoA::NewWDegPosTO const PPOrdering &  PPO,
const std::vector< degree > &  shifts
 

ModuleTermOrdering CoCoA::NewPosWDegTO const PPOrdering &  PPO,
const std::vector< degree > &  shifts
 

ModuleTermOrdering CoCoA::NewWDegTOPos const PPOrdering &  PPO,
const std::vector< std::size_t > &  perm
 

ModuleTermOrdering CoCoA::NewWDegPosTO const PPOrdering &  PPO,
const std::vector< std::size_t > &  perm
 

ModuleTermOrdering CoCoA::NewWDegTOPos const PPOrdering &  PPO,
const std::vector< degree > &  shifts,
const std::vector< std::size_t > &  perm
 

ModuleTermOrdering CoCoA::NewWDegPosTO const PPOrdering &  PPO,
const std::vector< degree > &  shifts,
const std::vector< std::size_t > &  perm
 

bool CoCoA::IsWDegTOPos const ModuleTermOrdering &  MTO  ) 
 

bool CoCoA::IsPosWDegTO const ModuleTermOrdering &  MTO  ) 
 

bool CoCoA::IsWDegPosTO const ModuleTermOrdering &  MTO  ) 
 

std::ostream& CoCoA::operator<< std::ostream &  out,
const OpenMathSymbol &  oms
 

OpenMathOutput& CoCoA::operator<< OpenMathOutput &  OMOut,
short  n
 

OpenMathOutput& CoCoA::operator<< OpenMathOutput &  OMOut,
int  n
 

OpenMathOutput& CoCoA::operator<< OpenMathOutput &  OMOut,
long  n
 

OpenMathOutput& CoCoA::operator<< OpenMathOutput &  OMOut,
unsigned short  n
 

OpenMathOutput& CoCoA::operator<< OpenMathOutput &  OMOut,
unsigned int  n
 

OpenMathOutput& CoCoA::operator<< OpenMathOutput &  OMOut,
unsigned long  n
 

OpenMathOutput& CoCoA::operator<< OpenMathOutput &  OMOut,
const ZZ &  N
 

OpenMathOutput& CoCoA::operator<< OpenMathOutput &  OMOut,
const OpenMathSymbol &  s
 

OpenMathInput& CoCoA::operator>> OpenMathInput &  OMIn,
long &  n
 

OpenMathInput& CoCoA::operator>> OpenMathInput &  OMIn,
ZZ &  N
 

OpenMathInput& CoCoA::operator>> OpenMathInput &  OMIn,
OpenMathSymbol &  s
 

OrdvArith::reference CoCoA::NewOrdvArith const PPOrdering &  PPO  ) 
 

std::vector< std::vector<int> > CoCoA::NewElimMatrix std::size_t  NumIndets,
const std::vector< std::size_t > &  ElimIndets
 

std::vector< std::vector<int> > CoCoA::NewElimMatrixAdj std::size_t  NumIndets,
const std::vector< std::size_t > &  ElimIndets
 

bool CoCoA::IsPolyRing const ring &  R  )  [inline]
 

Definition at line 122 of file PolyRing.H.

References CoCoA::ring::myRawPtr().

Referenced by AsPolyRing(), LC(), and StdDeg().

PolyRing CoCoA::AsPolyRing const ring &  R  )  [inline]
 

Definition at line 133 of file PolyRing.H.

References CoCoA_ERROR, IsPolyRing(), CoCoA::ring::myRawPtr(), and CoCoA::ERR::NotPolyRing.

Referenced by LC(), and StdDeg().

const ring & CoCoA::CoeffRing const PolyRing &  Rx  )  [inline]
 

Definition at line 147 of file PolyRing.H.

std::size_t CoCoA::NumIndets const PolyRing &  Rx  )  [inline]
 

Definition at line 153 of file PolyRing.H.

Referenced by CoCoA::GRingInfo::myY().

const RingHom & CoCoA::CoeffEmbeddingHom const PolyRing &  Rx  )  [inline]
 

Definition at line 159 of file PolyRing.H.

const std::vector< RingElem > & CoCoA::indets const PolyRing &  Rx  )  [inline]
 

Definition at line 165 of file PolyRing.H.

const RingElem& CoCoA::indet const PolyRing &  P,
std::size_t  var
 

Referenced by CoCoA::GRingInfo::myE(), and CoCoA::GRingInfo::myY().

RingElem CoCoA::IndetPower const PolyRing &  P,
std::size_t  var,
unsigned int  n
 

std::size_t CoCoA::NumTerms ConstRefRingElem  f  ) 
 

bool CoCoA::IsMonomial ConstRefRingElem  f  ) 
 

f == coeff*pp

bool CoCoA::IsConstant ConstRefRingElem  f  ) 
 

f == coeff

bool CoCoA::IsIndet ConstRefRingElem  f  ) 
 

f == x[i]

bool CoCoA::IsIndet std::size_t &  index,
ConstRefRingElem  f
 

f == x[i]; index=i

std::size_t CoCoA::StdDeg ConstRefRingElem  f  )  [inline]
 

Definition at line 171 of file PolyRing.H.

References AsPolyRing(), CoCoA_ERROR, IsPolyRing(), IsZero(), CoCoA::ERR::NotElemPolyRing, owner(), raw(), and CoCoA::ERR::ZeroPoly.

Referenced by deg().

std::size_t CoCoA::deg ConstRefRingElem  f  )  [inline]
 

Definition at line 179 of file PolyRing.H.

References StdDeg().

long CoCoA::log ConstRefRingElem  f,
std::size_t  var
 

ConstRefRingElem CoCoA::LC ConstRefRingElem  f  )  [inline]
 

Definition at line 185 of file PolyRing.H.

References AsPolyRing(), CoCoA_ERROR, IsPolyRing(), IsZero(), CoCoA::ERR::NotElemPolyRing, owner(), raw(), and CoCoA::ERR::ZeroPoly.

RingElem CoCoA::content ConstRefRingElem  f  ) 
 

RingElem CoCoA::deriv ConstRefRingElem  f,
ConstRefRingElem  x
 

derivative of f w.r.t. x, x must be an indeterminate

RingElem CoCoA::deriv ConstRefRingElem  f,
std::size_t  x
 

here x is the index of the indeterminate

RingHom CoCoA::PolyRingHom const PolyRing &  domain,
const ring &  codomain,
const RingHom &  CoeffHom,
const std::vector< RingElem > &  IndetImages
 

R[x] -> S, defined by CoeffHom: R->S and x->IndetImages.

RingHom CoCoA::PolyAlgebraHom const PolyRing &  domain,
const ring &  codomain,
const std::vector< RingElem > &  IndetImages
 

R[x] -> R or R[x]->R[y], defined by R->R and x->IndetImages.

const std::vector< PPMonoidElem > & CoCoA::indets const PPMonoid &  PPM  )  [inline]
 

std::vector whose n-th entry is n-th indet as PPMonoidElem

Definition at line 327 of file PPMonoid.H.

References PPM().

std::vector<symbol> CoCoA::symbols const PPMonoid &  PPM  ) 
 

std::vector of the symbols in PPM

std::size_t CoCoA::StdDeg ConstRefPPMonoidElem  pp  ) 
 

standard degree of pp

degree CoCoA::wdeg ConstRefPPMonoidElem  pp  ) 
 

degree according to grading

int CoCoA::CmpWDeg ConstRefPPMonoidElem  pp1,
ConstRefPPMonoidElem  pp2
 

<0 =0 >0 according as wdeg(t1) < = > wdeg(t2)

long CoCoA::log ConstRefPPMonoidElem  pp,
std::size_t  var
 

degree in indet of index var

ZZ CoCoA::ZZLog ConstRefPPMonoidElem  pp,
std::size_t  var
 

degree in indet of index var

void CoCoA::exponents std::vector< long > &  v,
ConstRefPPMonoidElem  pp
 

SHOULD BE vector<ZZ> ????

void CoCoA::swap RefPPMonoidElem  pp1,
RefPPMonoidElem  pp2
 

swap(t1, t2);

bool CoCoA::IsOne ConstRefPPMonoidElem  pp  ) 
 

bool CoCoA::IsIndet std::size_t &  index,
ConstRefPPMonoidElem  pp
 

bool CoCoA::IsIndetPower std::size_t &  index,
ZZ &  exp,
ConstRefPPMonoidElem  pp
 

int CoCoA::cmp ConstRefPPMonoidElem  pp1,
ConstRefPPMonoidElem  pp2
 

<0, =0, >0 as pp1 < = > pp2

bool CoCoA::operator== ConstRefPPMonoidElem  pp1,
ConstRefPPMonoidElem  pp2
 

pp1 == pp2;

bool CoCoA::operator!= ConstRefPPMonoidElem  pp1,
ConstRefPPMonoidElem  pp2
 

pp1 != pp2;

bool CoCoA::operator< ConstRefPPMonoidElem  pp1,
ConstRefPPMonoidElem  pp2
 

pp1 < pp2;

bool CoCoA::operator<= ConstRefPPMonoidElem  pp1,
ConstRefPPMonoidElem  pp2
 

pp1 <= pp2;

bool CoCoA::operator> ConstRefPPMonoidElem  pp1,
ConstRefPPMonoidElem  pp2
 

pp1 > pp2;

bool CoCoA::operator>= ConstRefPPMonoidElem  pp1,
ConstRefPPMonoidElem  pp2
 

pp1 => pp2;

std::ostream& CoCoA::operator<< std::ostream &  out,
const PPMonoid &  PPM
 

std::ostream& CoCoA::operator<< std::ostream &  out,
ConstRefPPMonoidElem  pp
 

OpenMathOutput& CoCoA::operator<< OpenMathOutput &  OMOut,
ConstRefPPMonoidElem  t
 

PPMonoidElem CoCoA::operator * ConstRefPPMonoidElem  pp1,
ConstRefPPMonoidElem  pp2
 

pp1*pp2;

PPMonoidElem CoCoA::operator/ ConstRefPPMonoidElem  pp1,
ConstRefPPMonoidElem  pp2
 

pp1/pp2;

PPMonoidElem CoCoA::colon ConstRefPPMonoidElem  pp1,
ConstRefPPMonoidElem  pp2
 

pp1:pp2

PPMonoidElem CoCoA::gcd ConstRefPPMonoidElem  pp1,
ConstRefPPMonoidElem  pp2
 

gcd(pp1, pp2)

PPMonoidElem CoCoA::lcm ConstRefPPMonoidElem  pp1,
ConstRefPPMonoidElem  pp2
 

lcm(pp1, pp2)

PPMonoidElem CoCoA::power ConstRefPPMonoidElem  pp,
long  exp
 

pp^exp

Referenced by CoCoA::GRingInfo::myE().

PPMonoidElem CoCoA::power ConstRefPPMonoidElem  pp,
const ZZ &  EXP
 

pp^EXP

bool CoCoA::IsCoprime ConstRefPPMonoidElem  pp1,
ConstRefPPMonoidElem  pp2
 

is gcd(pp1, pp2)=1?

bool CoCoA::IsDivisible ConstRefPPMonoidElem  pp1,
ConstRefPPMonoidElem  pp2
 

is pp1 divisible by pp2?

Referenced by IsDivisibleFast().

void CoCoA::AssignOne RefPPMonoidElem  dest  ) 
 

RefPPMonoidElem CoCoA::operator *= RefPPMonoidElem  dest,
ConstRefPPMonoidElem  t
 

RefPPMonoidElem CoCoA::operator/= RefPPMonoidElem  dest,
ConstRefPPMonoidElem  t
 

ConstRefPPMonoidElem CoCoA::indet const PPMonoid &  M,
std::size_t  var
 

PPMonoidElem CoCoA::IndetPower const PPMonoid &  M,
std::size_t  var,
long  exp
 

PPMonoid CoCoA::NewPPMonoid const std::vector< symbol > &  IndetNames,
const PPOrdering &  ord
 

bool CoCoA::operator!= const PPMonoid &  M1,
const PPMonoid &  M2
[inline]
 

Definition at line 288 of file PPMonoid.H.

ConstRefPPMonoidElem CoCoA::one const PPMonoid &  PPM  )  [inline]
 

Definition at line 297 of file PPMonoid.H.

References PPM().

std::size_t CoCoA::NumIndets const PPMonoid &  M  )  [inline]
 

Definition at line 309 of file PPMonoid.H.

const PPOrdering& CoCoA::ordering const PPMonoid &  M  )  [inline]
 

Definition at line 315 of file PPMonoid.H.

std::size_t CoCoA::GradingDim const PPMonoid &  M  )  [inline]
 

Definition at line 321 of file PPMonoid.H.

References GradingDim(), and ordering().

const PPMonoid& CoCoA::owner const ConstRefPPMonoidElem &  rawpp  )  [inline]
 

Definition at line 343 of file PPMonoid.H.

References CoCoA::ConstRefPPMonoidElem::myPPM.

PPMonoidElemRawPtr CoCoA::raw RefPPMonoidElem &  rawpp  )  [inline]
 

Definition at line 349 of file PPMonoid.H.

References CoCoA::ConstRefPPMonoidElem::myPPPtr.

PPMonoidElemConstRawPtr CoCoA::raw const ConstRefPPMonoidElem &  rawpp  )  [inline]
 

Definition at line 355 of file PPMonoid.H.

References CoCoA::ConstRefPPMonoidElem::myPPPtr.

PPMonoid CoCoA::NewPPMonoidEv const std::vector< symbol > &  IndetNames,
const PPOrdering &  ord
 

PPMonoid CoCoA::NewPPMonoidEvOv const std::vector< symbol > &  IndetNames,
const PPOrdering &  ord
 

PPMonoid CoCoA::NewPPMonoidEvZZ const std::vector< symbol > &  IndetNames,
const PPOrdering &  ord
 

PPMonoid CoCoA::NewPPMonoidOv const std::vector< symbol > &  IndetNames,
const PPOrdering &  ord
 

PPMonoid CoCoA::NewPPMonoidSparse const std::vector< symbol > &  IndetNames,
const PPOrdering &  ord
 

std::ostream& CoCoA::operator<< std::ostream &  out,
const PPOrdering &  PPO
 

OpenMathOutput& CoCoA::operator<< OpenMathOutput &  OMOut,
const PPOrdering &  PPO
 

std::size_t CoCoA::NumIndets const PPOrdering &  PPO  )  [inline]
 

Definition at line 87 of file PPOrdering.H.

std::size_t CoCoA::GradingDim const PPOrdering &  PPO  )  [inline]
 

Definition at line 91 of file PPOrdering.H.

PPOrdering CoCoA::NewLexOrdering std::size_t  NumIndets  ) 
 

PPOrdering CoCoA::NewStdDegLexOrdering std::size_t  NumIndets  ) 
 

PPOrdering CoCoA::NewStdDegRevLexOrdering std::size_t  NumIndets  ) 
 

PPOrdering CoCoA::NewMatrixOrdering std::size_t  NumIndets,
std::size_t  GradingDim,
ConstMatrix  OrderMatrix
 

bool CoCoA::IsLex const PPOrdering &  PPO  ) 
 

bool CoCoA::IsStdDegLex const PPOrdering &  PPO  ) 
 

bool CoCoA::IsStdDegRevLex const PPOrdering &  PPO  ) 
 

matrix CoCoA::GetMatrix const PPOrdering &  PPO  ) 
 

std::ostream& CoCoA::operator<< std::ostream &  out,
const PPWithMask &  pm
 

bool CoCoA::IsEqualFast const PPWithMask &  pm1,
const PPWithMask &  pm2
[inline]
 

Definition at line 92 of file PPWithMask.H.

References CoCoA::PPWithMask::myDivMask, and CoCoA::PPWithMask::myPP.

bool CoCoA::IsDivisibleFast const PPWithMask &  pm1,
const PPWithMask &  pm2
[inline]
 

Definition at line 98 of file PPWithMask.H.

References IsDivisible(), IsSubset(), CoCoA::PPWithMask::myDivMask, and CoCoA::PPWithMask::myPP.

const PPMonoid& CoCoA::PPM const QBGenerator &  QBG  ) 
 

std::ostream& CoCoA::operator<< std::ostream &  out,
const QBGenerator &  QBG
 

EFGModule CoCoA::NewQuotientModule const EFGModule &  Mnumer,
const EFGModule &  Mdenom
 

QuotientRing CoCoA::NewQuotientRing const ring &  R,
const ideal &  I
 

QuotientRing CoCoA::NewZmod long  n  ) 
 

QuotientRing CoCoA::NewZmod const ZZ &  N  ) 
 

bool CoCoA::IsQuotientRing const ring &  R  ) 
 

QuotientRing CoCoA::AsQuotientRing const ring &  R  ) 
 

const ring & CoCoA::BaseRing const QuotientRing &  RmodI  )  [inline]
 

Definition at line 112 of file QuotientRing.H.

const ideal & CoCoA::DefiningIdeal const QuotientRing &  RmodI  )  [inline]
 

Definition at line 118 of file QuotientRing.H.

const ring & CoCoA::ReprRing const QuotientRing &  RmodI  )  [inline]
 

Definition at line 124 of file QuotientRing.H.

const ideal & CoCoA::ReducingIdeal const QuotientRing &  RmodI  )  [inline]
 

Definition at line 130 of file QuotientRing.H.

const RingHom& CoCoA::QuotientingHom const QuotientRing &  RmodI  ) 
 

RingHom CoCoA::InducedHom const QuotientRing &  RmodI,
const RingHom &  phi
 

RingElem CoCoA::CanonicalRepr ConstRefRingElem  r  ) 
 

given x in R/I produces X in R s.t. QuotientingHom(RmodI)(X)=x

bool CoCoA::sample RandomBitStream &  RBS  )  [inline]
 

Definition at line 79 of file random.H.

bool CoCoA::prob double  P,
RandomBitStream &  RBS
 

std::ostream& CoCoA::operator<< std::ostream &  out,
const RandomBitStream &  RBS
 

ConstRefPPMonoidElem CoCoA::ActiveLPP const ReductionCog &  F  )  [inline]
 

Definition at line 86 of file ReductionCog.H.

bool CoCoA::IsActiveZero const ReductionCog &  F  )  [inline]
 

Definition at line 89 of file ReductionCog.H.

std::ostream& CoCoA::operator<< std::ostream &  out,
const ReductionCog &  F
 

ReductionCog CoCoA::NewRedCogPolyField const SparsePolyRing &  P  ) 
 

ReductionCog CoCoA::NewRedCogPolyGCD const SparsePolyRing &  P  ) 
 

ReductionCog CoCoA::NewRedCogGeobucketField const SparsePolyRing &  P  ) 
 

ReductionCog CoCoA::NewRedCogGeobucketGCD const SparsePolyRing &  P  ) 
 

std::vector<symbol> CoCoA::symbols const ring &  R  ) 
 

bool CoCoA::operator== ConstRefRingElem  ,
ConstRefRingElem 
 

bool CoCoA::operator!= ConstRefRingElem  ,
ConstRefRingElem 
[inline]
 

Definition at line 510 of file ring.H.

RingElem CoCoA::operator- ConstRefRingElem   ) 
 

RingElem CoCoA::operator+ ConstRefRingElem  ,
ConstRefRingElem 
 

RingElem CoCoA::operator- ConstRefRingElem  ,
ConstRefRingElem 
 

RingElem CoCoA::operator * ConstRefRingElem  ,
ConstRefRingElem 
 

RingElem CoCoA::operator/ ConstRefRingElem  ,
ConstRefRingElem 
 

RingElem CoCoA::gcd ConstRefRingElem  ,
ConstRefRingElem 
 

void CoCoA::GcdQuot RefRingElem  gcd,
RefRingElem  xquot,
RefRingElem  yquot,
ConstRefRingElem  x,
ConstRefRingElem  y
 

RefRingElem CoCoA::operator+= RefRingElem  ,
ConstRefRingElem 
 

RefRingElem CoCoA::operator-= RefRingElem  ,
ConstRefRingElem 
 

RefRingElem CoCoA::operator *= RefRingElem  ,
ConstRefRingElem 
 

RefRingElem CoCoA::operator/= RefRingElem  ,
ConstRefRingElem 
 

std::ostream& CoCoA::operator<< std::ostream &  ,
ConstRefRingElem 
 

OpenMathOutput& CoCoA::operator<< OpenMathOutput &  OMOut,
ConstRefRingElem 
 

bool CoCoA::IsZero ConstRefRingElem   ) 
 

bool CoCoA::IsOne ConstRefRingElem   ) 
 

bool CoCoA::IsMinusOne ConstRefRingElem   ) 
 

bool CoCoA::IsInteger ZZ &  N,
ConstRefRingElem  x
 

bool CoCoA::IsRational ZZ &  N,
ZZ &  D,
ConstRefRingElem  x
 

bool CoCoA::IsInvertible ConstRefRingElem   ) 
 

bool CoCoA::IsDivisible ConstRefRingElem  ,
ConstRefRingElem 
 

bool CoCoA::IsDivisible long  ,
ConstRefRingElem 
 

bool CoCoA::IsDivisible ConstRefRingElem  ,
long 
 

bool CoCoA::IsDivisible const ZZ &  N,
ConstRefRingElem 
 

bool CoCoA::IsDivisible ConstRefRingElem  ,
const ZZ &  N
 

RingElem CoCoA::power ConstRefRingElem  x,
long  n
 

NB exponent may be negative.

RingElem CoCoA::power ConstRefRingElem  x,
const ZZ &  N
 

NB exponent may be negative.

ConstRefRingElem CoCoA::zero const ring &  R  )  [inline]
 

Definition at line 456 of file ring.H.

ConstRefRingElem CoCoA::one const ring &  R  )  [inline]
 

Definition at line 462 of file ring.H.

std::ostream& CoCoA::operator<< std::ostream &  out,
const ring &  R
 

OpenMathOutput& CoCoA::operator<< OpenMathOutput &  OMOut,
const ring &  R
 

int CoCoA::sign ConstRefRingElem  x  ) 
 

RingElem CoCoA::abs ConstRefRingElem  x  ) 
 

int CoCoA::cmp ConstRefRingElem  x,
ConstRefRingElem  y
 

int CoCoA::cmp ConstRefRingElem  x,
long  n
 

int CoCoA::cmp long  n,
ConstRefRingElem  y
 

int CoCoA::cmp ConstRefRingElem  x,
const ZZ &  N
 

int CoCoA::cmp const ZZ &  N,
ConstRefRingElem  y
 

bool CoCoA::operator< ConstRefRingElem  x,
ConstRefRingElem  y
 

bool CoCoA::operator<= ConstRefRingElem  x,
ConstRefRingElem  y
 

bool CoCoA::operator> ConstRefRingElem  x,
ConstRefRingElem  y
 

bool CoCoA::operator>= ConstRefRingElem  x,
ConstRefRingElem  y
 

bool CoCoA::operator< ConstRefRingElem  x,
long  y
 

bool CoCoA::operator<= ConstRefRingElem  x,
long  y
 

bool CoCoA::operator> ConstRefRingElem  x,
long  y
 

bool CoCoA::operator>= ConstRefRingElem  x,
long  y
 

bool CoCoA::operator< long  x,
ConstRefRingElem  y
 

bool CoCoA::operator<= long  x,
ConstRefRingElem  y
 

bool CoCoA::operator> long  x,
ConstRefRingElem  y
 

bool CoCoA::operator>= long  x,
ConstRefRingElem  y
 

bool CoCoA::operator< ConstRefRingElem  x