Loading...
Searching...
No Matches
ncSAMult.h
Go to the documentation of this file.
#ifndef GRING_SA_MULT_H
#define GRING_SA_MULT_H
/*****************************************
* Computer Algebra System SINGULAR *
*****************************************/
#ifdef HAVE_PLURAL
#include "misc/options.h"
#include "polys/monomials/ring.h"
#include "polys/nc/summator.h"// for CPolynomialSummator class
#include "reporter/reporter.h" // for Print!
#include "polys/monomials/p_polys.h"
#include "polys/operations/p_Mult_q.h"
#include "polys/nc/ncSAFormula.h" // for CFormulaPowerMultiplier and enum Enum_ncSAType
// //////////////////////////////////////////////////////////////////////// //
//
BOOLEAN ncInitSpecialPairMultiplication(ring r);
template <typename CExponent>
class CMultiplier
{
protected:
const ring m_basering;
const int m_NVars; // N = number of variables
public:
CMultiplier(ring rBaseRing): m_basering(rBaseRing), m_NVars(rBaseRing->N) {};
virtual ~CMultiplier() {};
inline ring GetBasering() const { return m_basering; };
inline int NVars() const { return m_NVars; }
inline poly LM(const poly pTerm, const ring r, int i = 1) const
{
poly pMonom = p_LmInit(pTerm, r);
pSetCoeff0(pMonom, n_Init(i, r->cf));
return pMonom;
}
// Term * Exponent -> Monom * Exponent
inline poly MultiplyTE(const poly pTerm, const CExponent expRight)
{
const ring r = GetBasering();
poly pMonom = LM(pTerm, r);
poly result = p_Mult_nn(MultiplyME(pMonom, expRight), p_GetCoeff(pTerm, r), r);
p_Delete(&pMonom, r);
return result;
}
// Exponent * Term -> Exponent * Monom
inline poly MultiplyET(const CExponent expLeft, const poly pTerm)
{
const ring r = GetBasering();
poly pMonom = LM(pTerm, r);
poly result = p_Mult_nn(MultiplyEM(expLeft, pMonom), p_GetCoeff(pTerm, r), r);
p_Delete(&pMonom, r);
return result;
}
// protected:
// Exponent * Exponent
virtual poly MultiplyEE(const CExponent expLeft, const CExponent expRight) = 0;
// Monom * Exponent
virtual poly MultiplyME(const poly pMonom, const CExponent expRight) = 0;
// Exponent * Monom
virtual poly MultiplyEM(const CExponent expLeft, const poly pMonom) = 0;
private: // no copy constructors!
CMultiplier();
CMultiplier(const CMultiplier&);
CMultiplier& operator=(const CMultiplier&);
};
class CSpecialPairMultiplier: public CMultiplier<int>
{
private:
int m_i; // 2-gen subalgebra in these variables...
int m_j;
// poly m_c_ij;
// poly m_d_ij;
public:
// 1 <= i < j <= NVars()
CSpecialPairMultiplier(ring r, int i, int j);
virtual ~CSpecialPairMultiplier();
inline int GetI() const { return m_i; } // X
inline int GetJ() const { return m_j; } // Y > X!
// protected:
typedef int CExponent;
// Exponent * Exponent
// Computes: var(j)^{expLeft} * var(i)^{expRight}
virtual poly MultiplyEE(const CExponent expLeft, const CExponent expRight) = 0;
// Monom * Exponent
// pMonom must be of the form: var(j)^{n}
virtual poly MultiplyME(const poly pMonom, const CExponent expRight);
// Exponent * Monom
// pMonom must be of the form: var(i)^{m}
virtual poly MultiplyEM(const CExponent expLeft, const poly pMonom);
};
struct CPower // represents var(iVar)^{iPower}
{
int Var;
int Power;
CPower(int i, int n): Var(i), Power(n) {};
/*
inline poly GetPoly(const ring r) const // TODO: search for GetPoly(r, 1) and remove "1"!
{
poly p = p_One(r);
p_SetExp(p, Var, Power, r);
p_Setm(p, r);
return p;
};
inline poly GetPoly(const ring r, int c) const
{
poly p = p_ISet(c, r);
p_SetExp(p, Var, Power, r);
p_Setm(p, r);
return p;
};
*/
};
class CPowerMultiplier: public CMultiplier<CPower>
{
private:
CSpecialPairMultiplier** m_specialpairs; // upper triangular submatrix of pairs 1 <= i < j <= N of a N x N matrix.
public:
CPowerMultiplier(ring r);
virtual ~CPowerMultiplier();
inline CSpecialPairMultiplier* GetPair(int i, int j) const
{
assume( m_specialpairs != NULL );
assume( i > 0 );
assume( i < j );
assume( j <= NVars() );
return m_specialpairs[( (NVars() * ((i)-1) - ((i) * ((i)-1))/2 + (j)-1) - (i) )];
}
inline CSpecialPairMultiplier*& GetPair(int i, int j)
{
assume( m_specialpairs != NULL );
assume( i > 0 );
assume( i < j );
assume( j <= NVars() );
return m_specialpairs[( (NVars() * ((i)-1) - ((i) * ((i)-1))/2 + (j)-1) - (i) )];
}
// protected:
typedef CPower CExponent;
// Exponent * Exponent
// Computes: var(j)^{expLeft} * var(i)^{expRight}
virtual poly MultiplyEE(const CExponent expLeft, const CExponent expRight);
// Monom * Exponent
// pMonom may NOT be of the form: var(j)^{n}!
virtual poly MultiplyME(const poly pMonom, const CExponent expRight);
// Exponent * Monom
// pMonom may NOT be of the form: var(i)^{m}!
virtual poly MultiplyEM(const CExponent expLeft, const poly pMonom);
// Main templates:
// Poly * Exponent
inline poly MultiplyPE(const poly pPoly, const CExponent expRight)
{
bool bUsePolynomial = TEST_OPT_NOT_BUCKETS || (pLength(pPoly) < MIN_LENGTH_BUCKET);
CPolynomialSummator sum(GetBasering(), bUsePolynomial);
for( poly q = pPoly; q !=NULL; q = pNext(q) )
sum += MultiplyTE(q, expRight);
return sum;
}
// Exponent * Poly
inline poly MultiplyEP(const CExponent expLeft, const poly pPoly)
{
bool bUsePolynomial = TEST_OPT_NOT_BUCKETS || (pLength(pPoly) < MIN_LENGTH_BUCKET);
CPolynomialSummator sum(GetBasering(), bUsePolynomial);
for( poly q = pPoly; q !=NULL; q = pNext(q) )
sum += MultiplyET(expLeft, q);
return sum;
}
// Poly * Exponent
inline poly MultiplyPEDestroy(poly pPoly, const CExponent expRight)
{
bool bUsePolynomial = TEST_OPT_NOT_BUCKETS || (pLength(pPoly) < MIN_LENGTH_BUCKET);
CPolynomialSummator sum(GetBasering(), bUsePolynomial);
for( ; pPoly!=NULL; pPoly = p_LmDeleteAndNext(pPoly, GetBasering()) )
sum += MultiplyTE(pPoly, expRight);
return sum;
}
// Exponent * Poly
inline poly MultiplyEPDestroy(const CExponent expLeft, poly pPoly)
{
bool bUsePolynomial = TEST_OPT_NOT_BUCKETS || (pLength(pPoly) < MIN_LENGTH_BUCKET);
CPolynomialSummator sum(GetBasering(), bUsePolynomial);
for( ; pPoly!=NULL; pPoly = p_LmDeleteAndNext(pPoly, GetBasering()) )
sum += MultiplyET(expLeft, pPoly);
return sum;
}
};
class CGlobalMultiplier: public CMultiplier<poly>
{
private:
// CGlobalCacheHash* m_cache;
CPowerMultiplier* m_powers;
const CFormulaPowerMultiplier* m_RingFormulaMultiplier;
public:
typedef CMultiplier<poly> CBaseType;
CGlobalMultiplier(ring r);
virtual ~CGlobalMultiplier();
// protected:
typedef poly CExponent;
// the following methods are literally equal!
// Exponent * Exponent
// TODO: handle components!!!
virtual poly MultiplyEE(const CExponent expLeft, const CExponent expRight);
// Monom * Exponent
virtual poly MultiplyME(const poly pMonom, const CExponent expRight);
// Exponent * Monom
virtual poly MultiplyEM(const CExponent expLeft, const poly pMonom);
// Main templates:
// Poly * Exponent
inline poly MultiplyPE(const poly pPoly, const CExponent expRight)
{
assume( pPoly != NULL ); assume( expRight != NULL );
const int iComponentMonom = p_GetComp(expRight, GetBasering());
bool bUsePolynomial = TEST_OPT_NOT_BUCKETS || (pLength(pPoly) < MIN_LENGTH_BUCKET);
CPolynomialSummator sum(GetBasering(), bUsePolynomial);
if( iComponentMonom!=0 )
{
for( poly q = pPoly; q !=NULL; q = pNext(q) )
{
#ifdef PDEBUG
{
const int iComponent = p_GetComp(q, GetBasering());
assume(iComponent == 0);
if( iComponent!=0 )
{
Werror("MultiplyPE: both sides have non-zero components: %d and %d!\n", iComponent, iComponentMonom);
// what should we do further?!?
return NULL;
}
}
#endif
sum += MultiplyTE(q, expRight); // NO Component!!!
}
poly t = sum; p_SetCompP(t, iComponentMonom, GetBasering());
return t;
} // iComponentMonom != 0!
else
{ // iComponentMonom == 0!
for( poly q = pPoly; q !=NULL; q = pNext(q) )
{
const int iComponent = p_GetComp(q, GetBasering());
#ifdef PDEBUG
if( iComponent!=0 )
{
Warn("MultiplyPE: Multiplication in the left module from the right by component %d!\n", iComponent);
// what should we do further?!?
}
#endif
poly t = MultiplyTE(q, expRight); // NO Component!!!
p_SetCompP(t, iComponent, GetBasering());
sum += t;
}
return sum;
} // iComponentMonom == 0!
}
// Exponent * Poly
inline poly MultiplyEP(const CExponent expLeft, const poly pPoly)
{
assume( pPoly != NULL ); assume( expLeft != NULL );
const int iComponentMonom = p_GetComp(expLeft, GetBasering());
bool bUsePolynomial = TEST_OPT_NOT_BUCKETS || (pLength(pPoly) < MIN_LENGTH_BUCKET);
CPolynomialSummator sum(GetBasering(), bUsePolynomial);
if( iComponentMonom!=0 )
{
for( poly q = pPoly; q !=NULL; q = pNext(q) )
{
#ifdef PDEBUG
{
const int iComponent = p_GetComp(q, GetBasering());
assume(iComponent == 0);
if( iComponent!=0 )
{
Werror("MultiplyEP: both sides have non-zero components: %d and %d!\n", iComponent, iComponentMonom);
// what should we do further?!?
return NULL;
}
}
#endif
sum += MultiplyET(expLeft, q);
}
poly t = sum; p_SetCompP(t, iComponentMonom, GetBasering());
return t;
} // iComponentMonom != 0!
else
{ // iComponentMonom == 0!
for( poly q = pPoly; q !=NULL; q = pNext(q) )
{
const int iComponent = p_GetComp(q, GetBasering());
poly t = MultiplyET(expLeft, q); // NO Component!!!
p_SetCompP(t, iComponent, GetBasering());
sum += t;
}
return sum;
} // iComponentMonom == 0!
}
// Poly * Exponent
inline poly MultiplyPEDestroy(poly pPoly, const CExponent expRight)
{
assume( pPoly != NULL ); assume( expRight != NULL );
const int iComponentMonom = p_GetComp(expRight, GetBasering());
bool bUsePolynomial = TEST_OPT_NOT_BUCKETS || (pLength(pPoly) < MIN_LENGTH_BUCKET);
CPolynomialSummator sum(GetBasering(), bUsePolynomial);
if( iComponentMonom!=0 )
{
for(poly q = pPoly ; q!=NULL; q = p_LmDeleteAndNext(q, GetBasering()) )
{
#ifdef PDEBUG
{
const int iComponent = p_GetComp(q, GetBasering());
assume(iComponent == 0);
if( iComponent!=0 )
{
Werror("MultiplyPEDestroy: both sides have non-zero components: %d and %d!\n", iComponent, iComponentMonom);
// what should we do further?!?
return NULL;
}
}
#endif
sum += MultiplyTE(q, expRight); // NO Component!!!
}
poly t = sum; p_SetCompP(t, iComponentMonom, GetBasering());
return t;
} // iComponentMonom != 0!
else
{ // iComponentMonom == 0!
for(poly q = pPoly ; q!=NULL; q = p_LmDeleteAndNext(q, GetBasering()) )
{
const int iComponent = p_GetComp(q, GetBasering());
#ifdef PDEBUG
if( iComponent!=0 )
{
Warn("MultiplyPEDestroy: Multiplication in the left module from the right by component %d!\n", iComponent);
// what should we do further?!?
}
#endif
poly t = MultiplyTE(q, expRight); // NO Component!!!
p_SetCompP(t, iComponent, GetBasering());
sum += t;
}
return sum;
} // iComponentMonom == 0!
}
// Exponent * Poly
inline poly MultiplyEPDestroy(const CExponent expLeft, poly pPoly)
{
assume( pPoly != NULL ); assume( expLeft != NULL );
const int iComponentMonom = p_GetComp(expLeft, GetBasering());
bool bUsePolynomial = TEST_OPT_NOT_BUCKETS || (pLength(pPoly) < MIN_LENGTH_BUCKET);
CPolynomialSummator sum(GetBasering(), bUsePolynomial);
if( iComponentMonom!=0 )
{
for(poly q = pPoly ; q!=NULL; q = p_LmDeleteAndNext(q, GetBasering()) )
{
#ifdef PDEBUG
{
const int iComponent = p_GetComp(q, GetBasering());
assume(iComponent == 0);
if( iComponent!=0 )
{
Werror("MultiplyEPDestroy: both sides have non-zero components: %d and %d!\n", iComponent, iComponentMonom);
// what should we do further?!?
return NULL;
}
}
#endif
sum += MultiplyET(expLeft, q);
}
poly t = sum; p_SetCompP(t, iComponentMonom, GetBasering());
return t;
} // iComponentMonom != 0!
else
{ // iComponentMonom == 0!
for(poly q = pPoly ; q!=NULL; q = p_LmDeleteAndNext(q, GetBasering()) )
{
const int iComponent = p_GetComp(q, GetBasering());
poly t = MultiplyET(expLeft, q); // NO Component!!!
p_SetCompP(t, iComponent, GetBasering());
sum += t;
}
return sum;
} // iComponentMonom == 0!
}
};
//////////////////////////////////////////////////////////////////////////
class CCommutativeSpecialPairMultiplier: public CSpecialPairMultiplier
{
public:
CCommutativeSpecialPairMultiplier(ring r, int i, int j);
virtual ~CCommutativeSpecialPairMultiplier();
// Exponent * Exponent
virtual poly MultiplyEE(const int expLeft, const int expRight);
};
//////////////////////////////////////////////////////////////////////////
class CAntiCommutativeSpecialPairMultiplier: public CSpecialPairMultiplier
{
public:
CAntiCommutativeSpecialPairMultiplier(ring r, int i, int j);
virtual ~CAntiCommutativeSpecialPairMultiplier();
// Exponent * Exponent
virtual poly MultiplyEE(const int expLeft, const int expRight);
};
//////////////////////////////////////////////////////////////////////////
class CQuasiCommutativeSpecialPairMultiplier: public CSpecialPairMultiplier
{
private:
const number m_q;
// TODO: make cache for some 'good' powers!?
public:
CQuasiCommutativeSpecialPairMultiplier(ring r, int i, int j, number q);
virtual ~CQuasiCommutativeSpecialPairMultiplier();
// Exponent * Exponent
virtual poly MultiplyEE(const int expLeft, const int expRight);
};
//////////////////////////////////////////////////////////////////////////
class CWeylSpecialPairMultiplier: public CSpecialPairMultiplier
{
private:
const number m_g;
// TODO: make cache for some 'good' powers!?
public:
CWeylSpecialPairMultiplier(ring r, int i, int j, number g);
virtual ~CWeylSpecialPairMultiplier();
// Exponent * Exponent
virtual poly MultiplyEE(const int expLeft, const int expRight);
};
//////////////////////////////////////////////////////////////////////////
class CHWeylSpecialPairMultiplier: public CSpecialPairMultiplier
{
private:
const int m_k;
// TODO: make cache for some 'good' powers!?
public:
CHWeylSpecialPairMultiplier(ring r, int i, int j, int k);
virtual ~CHWeylSpecialPairMultiplier();
// Exponent * Exponent
virtual poly MultiplyEE(const int expLeft, const int expRight);
};
//////////////////////////////////////////////////////////////////////////
class CShiftSpecialPairMultiplier: public CSpecialPairMultiplier
{
private:
const number m_shiftCoef;
const int m_shiftVar;
// TODO: make cache for some 'good' powers!?
public:
CShiftSpecialPairMultiplier(ring r, int i, int j, int s, number c);
virtual ~CShiftSpecialPairMultiplier();
// Exponent * Exponent
virtual poly MultiplyEE(const int expLeft, const int expRight);
};
// need: enum Enum_ncSAType;
//////////////////////////////////////////////////////////////////////////
// Using external 'formula' routines
class CExternalSpecialPairMultiplier: public CSpecialPairMultiplier
{
private:
Enum_ncSAType m_ncSAtype;
public:
CExternalSpecialPairMultiplier(ring r, int i, int j, Enum_ncSAType type);
virtual ~CExternalSpecialPairMultiplier();
// Exponent * Exponent
virtual poly MultiplyEE(const int expLeft, const int expRight);
};
#endif // HAVE_PLURAL :(
#endif //
BOOLEAN
int BOOLEAN
Definition auxiliary.h:88
N
const CanonicalForm CFMap CFMap & N
Definition cfEzgcd.cc:56
i
int i
Definition cfEzgcd.cc:132
k
int k
Definition cfEzgcd.cc:99
g
g
Definition cfModGcd.cc:4098
CAntiCommutativeSpecialPairMultiplier::CAntiCommutativeSpecialPairMultiplier
CAntiCommutativeSpecialPairMultiplier(ring r, int i, int j)
Definition ncSAMult.cc:554
CAntiCommutativeSpecialPairMultiplier::MultiplyEE
virtual poly MultiplyEE(const int expLeft, const int expRight)
Definition ncSAMult.cc:573
CAntiCommutativeSpecialPairMultiplier::~CAntiCommutativeSpecialPairMultiplier
virtual ~CAntiCommutativeSpecialPairMultiplier()
Definition ncSAMult.cc:564
CCommutativeSpecialPairMultiplier::~CCommutativeSpecialPairMultiplier
virtual ~CCommutativeSpecialPairMultiplier()
Definition ncSAMult.cc:532
CCommutativeSpecialPairMultiplier::CCommutativeSpecialPairMultiplier
CCommutativeSpecialPairMultiplier(ring r, int i, int j)
Definition ncSAMult.cc:522
CCommutativeSpecialPairMultiplier::MultiplyEE
virtual poly MultiplyEE(const int expLeft, const int expRight)
Definition ncSAMult.cc:541
CExternalSpecialPairMultiplier::m_ncSAtype
Enum_ncSAType m_ncSAtype
Definition ncSAMult.h:594
CExternalSpecialPairMultiplier::MultiplyEE
virtual poly MultiplyEE(const int expLeft, const int expRight)
Definition ncSAMult.cc:757
CExternalSpecialPairMultiplier::~CExternalSpecialPairMultiplier
virtual ~CExternalSpecialPairMultiplier()
Definition ncSAMult.cc:748
CExternalSpecialPairMultiplier::CExternalSpecialPairMultiplier
CExternalSpecialPairMultiplier(ring r, int i, int j, Enum_ncSAType type)
Definition ncSAMult.cc:738
CFormulaPowerMultiplier
Definition ncSAFormula.h:28
CGlobalMultiplier::MultiplyPEDestroy
poly MultiplyPEDestroy(poly pPoly, const CExponent expRight)
Definition ncSAMult.h:393
CGlobalMultiplier::CExponent
poly CExponent
Definition ncSAMult.h:278
CGlobalMultiplier::MultiplyEPDestroy
poly MultiplyEPDestroy(const CExponent expLeft, poly pPoly)
Definition ncSAMult.h:447
CGlobalMultiplier::MultiplyME
virtual poly MultiplyME(const poly pMonom, const CExponent expRight)
Definition ncSAMult.cc:492
CGlobalMultiplier::m_powers
CPowerMultiplier * m_powers
Definition ncSAMult.h:267
CGlobalMultiplier::MultiplyEP
poly MultiplyEP(const CExponent expLeft, const poly pPoly)
Definition ncSAMult.h:349
CGlobalMultiplier::MultiplyEE
virtual poly MultiplyEE(const CExponent expLeft, const CExponent expRight)
Definition ncSAMult.cc:323
CGlobalMultiplier::MultiplyPE
poly MultiplyPE(const poly pPoly, const CExponent expRight)
Definition ncSAMult.h:296
CGlobalMultiplier::CGlobalMultiplier
CGlobalMultiplier(ring r)
Definition ncSAMult.cc:293
CGlobalMultiplier::m_RingFormulaMultiplier
const CFormulaPowerMultiplier * m_RingFormulaMultiplier
Definition ncSAMult.h:268
CGlobalMultiplier::CBaseType
CMultiplier< poly > CBaseType
Definition ncSAMult.h:271
CGlobalMultiplier::MultiplyEM
virtual poly MultiplyEM(const CExponent expLeft, const poly pMonom)
Definition ncSAMult.cc:505
CGlobalMultiplier::~CGlobalMultiplier
virtual ~CGlobalMultiplier()
Definition ncSAMult.cc:306
CHWeylSpecialPairMultiplier::MultiplyEE
virtual poly MultiplyEE(const int expLeft, const int expRight)
Definition ncSAMult.cc:678
CHWeylSpecialPairMultiplier::CHWeylSpecialPairMultiplier
CHWeylSpecialPairMultiplier(ring r, int i, int j, int k)
Definition ncSAMult.cc:659
CHWeylSpecialPairMultiplier::m_k
const int m_k
Definition ncSAMult.h:557
CHWeylSpecialPairMultiplier::~CHWeylSpecialPairMultiplier
virtual ~CHWeylSpecialPairMultiplier()
Definition ncSAMult.cc:669
CMultiplier::CMultiplier
CMultiplier(ring rBaseRing)
Definition ncSAMult.h:32
CMultiplier< poly >::m_basering
const ring m_basering
Definition ncSAMult.h:28
CMultiplier::CMultiplier
CMultiplier(const CMultiplier &)
CMultiplier::operator=
CMultiplier & operator=(const CMultiplier &)
CMultiplier::MultiplyME
virtual poly MultiplyME(const poly pMonom, const CExponent expRight)=0
CMultiplier::CMultiplier
CMultiplier()
CMultiplier::MultiplyTE
poly MultiplyTE(const poly pTerm, const CExponent expRight)
Definition ncSAMult.h:47
CMultiplier::NVars
int NVars() const
Definition ncSAMult.h:36
CMultiplier::LM
poly LM(const poly pTerm, const ring r, int i=1) const
Definition ncSAMult.h:39
CMultiplier< poly >::m_NVars
const int m_NVars
Definition ncSAMult.h:29
CMultiplier::MultiplyET
poly MultiplyET(const CExponent expLeft, const poly pTerm)
Definition ncSAMult.h:61
CMultiplier::~CMultiplier
virtual ~CMultiplier()
Definition ncSAMult.h:33
CMultiplier::MultiplyEE
virtual poly MultiplyEE(const CExponent expLeft, const CExponent expRight)=0
CMultiplier::MultiplyEM
virtual poly MultiplyEM(const CExponent expLeft, const poly pMonom)=0
CMultiplier::GetBasering
ring GetBasering() const
Definition ncSAMult.h:35
CPolynomialSummator
CPolynomialSummator: unifies bucket and polynomial summation as the later is broken in buckets :(.
Definition summator.h:21
CPowerMultiplier
Definition ncSAMult.h:164
CPowerMultiplier::CExponent
CPower CExponent
Definition ncSAMult.h:194
CPowerMultiplier::GetPair
CSpecialPairMultiplier *& GetPair(int i, int j)
Definition ncSAMult.h:183
CPowerMultiplier::~CPowerMultiplier
virtual ~CPowerMultiplier()
Definition ncSAMult.cc:847
CPowerMultiplier::MultiplyEE
virtual poly MultiplyEE(const CExponent expLeft, const CExponent expRight)
Definition ncSAMult.cc:991
CPowerMultiplier::MultiplyME
virtual poly MultiplyME(const poly pMonom, const CExponent expRight)
Definition ncSAMult.cc:860
CPowerMultiplier::MultiplyPE
poly MultiplyPE(const poly pPoly, const CExponent expRight)
Definition ncSAMult.h:211
CPowerMultiplier::MultiplyEM
virtual poly MultiplyEM(const CExponent expLeft, const poly pMonom)
Definition ncSAMult.cc:924
CPowerMultiplier::GetPair
CSpecialPairMultiplier * GetPair(int i, int j) const
Definition ncSAMult.h:173
CPowerMultiplier::MultiplyPEDestroy
poly MultiplyPEDestroy(poly pPoly, const CExponent expRight)
Definition ncSAMult.h:235
CPowerMultiplier::MultiplyEPDestroy
poly MultiplyEPDestroy(const CExponent expLeft, poly pPoly)
Definition ncSAMult.h:247
CPowerMultiplier::m_specialpairs
CSpecialPairMultiplier ** m_specialpairs
Definition ncSAMult.h:166
CPowerMultiplier::MultiplyEP
poly MultiplyEP(const CExponent expLeft, const poly pPoly)
Definition ncSAMult.h:223
CPowerMultiplier::CPowerMultiplier
CPowerMultiplier(ring r)
Definition ncSAMult.cc:832
CQuasiCommutativeSpecialPairMultiplier::m_q
const number m_q
Definition ncSAMult.h:526
CQuasiCommutativeSpecialPairMultiplier::CQuasiCommutativeSpecialPairMultiplier
CQuasiCommutativeSpecialPairMultiplier(ring r, int i, int j, number q)
Definition ncSAMult.cc:586
CQuasiCommutativeSpecialPairMultiplier::~CQuasiCommutativeSpecialPairMultiplier
virtual ~CQuasiCommutativeSpecialPairMultiplier()
Definition ncSAMult.cc:598
CQuasiCommutativeSpecialPairMultiplier::MultiplyEE
virtual poly MultiplyEE(const int expLeft, const int expRight)
Definition ncSAMult.cc:607
CShiftSpecialPairMultiplier::CShiftSpecialPairMultiplier
CShiftSpecialPairMultiplier(ring r, int i, int j, int s, number c)
Definition ncSAMult.cc:696
CShiftSpecialPairMultiplier::m_shiftCoef
const number m_shiftCoef
Definition ncSAMult.h:573
CShiftSpecialPairMultiplier::MultiplyEE
virtual poly MultiplyEE(const int expLeft, const int expRight)
Definition ncSAMult.cc:716
CShiftSpecialPairMultiplier::~CShiftSpecialPairMultiplier
virtual ~CShiftSpecialPairMultiplier()
Definition ncSAMult.cc:707
CShiftSpecialPairMultiplier::m_shiftVar
const int m_shiftVar
Definition ncSAMult.h:574
CSpecialPairMultiplier
Definition ncSAMult.h:94
CSpecialPairMultiplier::CExponent
int CExponent
Definition ncSAMult.h:112
CSpecialPairMultiplier::CSpecialPairMultiplier
CSpecialPairMultiplier(ring r, int i, int j)
Definition ncSAMult.cc:1060
CSpecialPairMultiplier::GetI
int GetI() const
Definition ncSAMult.h:108
CSpecialPairMultiplier::GetJ
int GetJ() const
Definition ncSAMult.h:109
CSpecialPairMultiplier::MultiplyEM
virtual poly MultiplyEM(const CExponent expLeft, const poly pMonom)
Definition ncSAMult.cc:1097
CSpecialPairMultiplier::MultiplyME
virtual poly MultiplyME(const poly pMonom, const CExponent expRight)
Definition ncSAMult.cc:1085
CSpecialPairMultiplier::m_i
int m_i
Definition ncSAMult.h:96
CSpecialPairMultiplier::~CSpecialPairMultiplier
virtual ~CSpecialPairMultiplier()
Definition ncSAMult.cc:1074
CSpecialPairMultiplier::MultiplyEE
virtual poly MultiplyEE(const CExponent expLeft, const CExponent expRight)=0
CSpecialPairMultiplier::m_j
int m_j
Definition ncSAMult.h:97
CWeylSpecialPairMultiplier::m_g
const number m_g
Definition ncSAMult.h:542
CWeylSpecialPairMultiplier::MultiplyEE
virtual poly MultiplyEE(const int expLeft, const int expRight)
Definition ncSAMult.cc:642
CWeylSpecialPairMultiplier::CWeylSpecialPairMultiplier
CWeylSpecialPairMultiplier(ring r, int i, int j, number g)
Definition ncSAMult.cc:621
CWeylSpecialPairMultiplier::~CWeylSpecialPairMultiplier
virtual ~CWeylSpecialPairMultiplier()
Definition ncSAMult.cc:633
n_Init
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
Definition coeffs.h:541
Warn
#define Warn
Definition emacs.cc:77
result
return result
Definition facAbsBiFact.cc:76
s
const CanonicalForm int s
Definition facAbsFact.cc:51
j
int j
Definition facHensel.cc:110
assume
#define assume(x)
Definition mod2.h:389
p_GetComp
#define p_GetComp(p, r)
Definition monomials.h:64
pNext
#define pNext(p)
Definition monomials.h:36
pSetCoeff0
#define pSetCoeff0(p, n)
Definition monomials.h:59
p_GetCoeff
#define p_GetCoeff(p, r)
Definition monomials.h:50
ncSAFormula.h
Enum_ncSAType
Enum_ncSAType
Definition ncSAFormula.h:16
ncInitSpecialPairMultiplication
BOOLEAN ncInitSpecialPairMultiplication(ring r)
Definition ncSAMult.cc:266
NULL
#define NULL
Definition omList.c:12
options.h
TEST_OPT_NOT_BUCKETS
#define TEST_OPT_NOT_BUCKETS
Definition options.h:107
p_Mult_q.h
MIN_LENGTH_BUCKET
#define MIN_LENGTH_BUCKET
Definition p_Mult_q.h:21
p_polys.h
pLength
static int pLength(poly a)
Definition p_polys.h:190
p_LmInit
static poly p_LmInit(poly p, const ring r)
Definition p_polys.h:1356
p_SetCompP
static void p_SetCompP(poly p, int i, ring r)
Definition p_polys.h:256
p_Mult_nn
static poly p_Mult_nn(poly p, number n, const ring r)
Definition p_polys.h:960
p_Delete
static void p_Delete(poly *p, const ring r)
Definition p_polys.h:903
p_LmDeleteAndNext
static poly p_LmDeleteAndNext(poly p, const ring r)
Definition p_polys.h:757
Werror
void Werror(const char *fmt,...)
Definition reporter.cc:189
reporter.h
ring.h
CPower
Definition ncSAMult.h:133
CPower::CPower
CPower(int i, int n)
Definition ncSAMult.h:137
CPower::Power
int Power
Definition ncSAMult.h:135
CPower::Var
int Var
Definition ncSAMult.h:134
summator.h