Public Types | Public Member Functions | Private Attributes
CPowerMultiplier Class Reference

#include <ncSAMult.h>

Public Types

typedef CPower CExponent
 

Public Member Functions

 CPowerMultiplier (ring r)
 
virtual ~CPowerMultiplier ()
 
CSpecialPairMultiplierGetPair (int i, int j) const
 
CSpecialPairMultiplier *& GetPair (int i, int j)
 
virtual poly MultiplyEE (const CExponent expLeft, const CExponent expRight)
 
virtual poly MultiplyME (const poly pMonom, const CExponent expRight)
 
virtual poly MultiplyEM (const CExponent expLeft, const poly pMonom)
 
poly MultiplyPE (const poly pPoly, const CExponent expRight)
 
poly MultiplyEP (const CExponent expLeft, const poly pPoly)
 
poly MultiplyPEDestroy (poly pPoly, const CExponent expRight)
 
poly MultiplyEPDestroy (const CExponent expLeft, poly pPoly)
 
- Public Member Functions inherited from CMultiplier< CPower >
 CMultiplier (ring rBaseRing)
 
virtual ~CMultiplier ()
 
ring GetBasering () const
 
int NVars () const
 
poly LM (const poly pTerm, const ring r, int i=1) const
 
poly MultiplyTE (const poly pTerm, const CPowerexpRight)
 
poly MultiplyET (const CPowerexpLeft, const poly pTerm)
 

Private Attributes

CSpecialPairMultiplier ** m_specialpairs
 

Additional Inherited Members

- Protected Attributes inherited from CMultiplier< CPower >
const ring m_basering
 
const int m_NVars
 

Detailed Description

Definition at line 168 of file ncSAMult.h.

Member Typedef Documentation

Definition at line 199 of file ncSAMult.h.

Constructor & Destructor Documentation

CPowerMultiplier::CPowerMultiplier ( ring  r)

Definition at line 833 of file ncSAMult.cc.

834 {
835 #if OUTPUT
836  PrintS("CPowerMultiplier::CPowerMultiplier(ring)!");
837  PrintLn();
838 #endif
839 
841 
842  for( int i = 1; i < NVars(); i++ )
843  for( int j = i + 1; j <= NVars(); j++ )
844  GetPair(i, j) = AnalyzePair(GetBasering(), i, j); // factory method!
845 }
CSpecialPairMultiplier * AnalyzePair(const ring r, int i, int j)
Definition: ncSAMult.cc:779
void PrintLn()
Definition: reporter.cc:322
int NVars() const
Definition: ncSAMult.h:41
CSpecialPairMultiplier ** m_specialpairs
Definition: ncSAMult.h:171
CSpecialPairMultiplier * GetPair(int i, int j) const
Definition: ncSAMult.h:178
const ring r
Definition: syzextra.cc:208
int j
Definition: myNF.cc:70
int i
Definition: cfEzgcd.cc:123
void PrintS(const char *s)
Definition: reporter.cc:294
ring GetBasering() const
Definition: ncSAMult.h:40
#define omAlloc0(size)
Definition: omAllocDecl.h:211
CPowerMultiplier::~CPowerMultiplier ( )
virtual

Definition at line 848 of file ncSAMult.cc.

849 {
850 #if OUTPUT
851  PrintS("CPowerMultiplier::~CPowerMultiplier()!");
852  PrintLn();
853 #endif
854 
855  omFreeSize((ADDRESS)m_specialpairs, ((NVars() * (NVars()-1)) / 2) * sizeof(CSpecialPairMultiplier*) );
856 }
void PrintLn()
Definition: reporter.cc:322
int NVars() const
Definition: ncSAMult.h:41
CSpecialPairMultiplier ** m_specialpairs
Definition: ncSAMult.h:171
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
void * ADDRESS
Definition: auxiliary.h:161
void PrintS(const char *s)
Definition: reporter.cc:294

Member Function Documentation

CSpecialPairMultiplier* CPowerMultiplier::GetPair ( int  i,
int  j 
) const
inline

Definition at line 178 of file ncSAMult.h.

179  {
180  assume( m_specialpairs != NULL );
181  assume( i > 0 );
182  assume( i < j );
183  assume( j <= NVars() );
184 
185  return m_specialpairs[( (NVars() * ((i)-1) - ((i) * ((i)-1))/2 + (j)-1) - (i) )];
186  }
int NVars() const
Definition: ncSAMult.h:41
CSpecialPairMultiplier ** m_specialpairs
Definition: ncSAMult.h:171
int j
Definition: myNF.cc:70
#define assume(x)
Definition: mod2.h:405
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10
CSpecialPairMultiplier*& CPowerMultiplier::GetPair ( int  i,
int  j 
)
inline

Definition at line 188 of file ncSAMult.h.

189  {
190  assume( m_specialpairs != NULL );
191  assume( i > 0 );
192  assume( i < j );
193  assume( j <= NVars() );
194 
195  return m_specialpairs[( (NVars() * ((i)-1) - ((i) * ((i)-1))/2 + (j)-1) - (i) )];
196  }
int NVars() const
Definition: ncSAMult.h:41
CSpecialPairMultiplier ** m_specialpairs
Definition: ncSAMult.h:171
int j
Definition: myNF.cc:70
#define assume(x)
Definition: mod2.h:405
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10
poly CPowerMultiplier::MultiplyEE ( const CExponent  expLeft,
const CExponent  expRight 
)
virtual

Implements CMultiplier< CPower >.

Definition at line 992 of file ncSAMult.cc.

993 {
994 #if OUTPUT
995  PrintS("CPowerMultiplier::MultiplyEE)!");
996  PrintLn();
997 #endif
998 
999  const int i = expRight.Var, j = expLeft.Var;
1000  const int ei = expRight.Power, ej = expLeft.Power;
1001 
1002 #if OUTPUT
1003  Print("Input: var(%d)^{%d} * var(%d)^{%d}", j, ej, i, ei);
1004  PrintLn();
1005 #endif
1006 
1007  assume(1 <= i);
1008  assume(j <= NVars());
1009  assume(1 <= j);
1010  assume(i <= NVars());
1011  assume(ei > 0);
1012  assume(ej > 0);
1013 
1014  if( i >= j )
1015  {
1016  const ring r = GetBasering();
1017 
1018  poly product = p_One(r);
1019  p_SetExp(product, j, ej, r);
1020  p_SetExp(product, i, ei, r);
1021  p_Setm(product, r);
1022 
1023  return product;
1024 
1025  } else
1026  {
1027  assume(i < j);
1028 
1029  // No Cache Lookup!? :(
1030 
1031  CSpecialPairMultiplier* pSpecialMultiplier = GetPair(i, j);
1032 
1033  // Special case?
1034  if( pSpecialMultiplier != NULL )
1035  {
1036  assume( pSpecialMultiplier->GetI() == i );
1037  assume( pSpecialMultiplier->GetJ() == j );
1038  assume( pSpecialMultiplier->GetBasering() == GetBasering() );
1039 
1040  return pSpecialMultiplier->MultiplyEE(ej, ei);
1041  } else
1042  {
1043  // Perform general NC Multiplication:
1044  // TODO
1045 
1046  WerrorS("Sorry the general case is not implemented this way yet!!!");
1047  assume(0);
1048 
1049  // poly product = NULL;
1050  }
1051  }
1052 
1053  return NULL;
1054 }
int GetJ() const
Definition: ncSAMult.h:114
void PrintLn()
Definition: reporter.cc:322
#define Print
Definition: emacs.cc:83
int NVars() const
Definition: ncSAMult.h:41
void WerrorS(const char *s)
Definition: feFopen.cc:23
CSpecialPairMultiplier * GetPair(int i, int j) const
Definition: ncSAMult.h:178
int GetI() const
Definition: ncSAMult.h:113
const ring r
Definition: syzextra.cc:208
poly p_One(const ring r)
Definition: p_polys.cc:1318
int j
Definition: myNF.cc:70
#define assume(x)
Definition: mod2.h:405
int i
Definition: cfEzgcd.cc:123
void PrintS(const char *s)
Definition: reporter.cc:294
ring GetBasering() const
Definition: ncSAMult.h:40
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent : VarOffset encodes the position in p->exp
Definition: p_polys.h:484
virtual poly MultiplyEE(const CExponent expLeft, const CExponent expRight)=0
#define NULL
Definition: omList.c:10
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:436
polyrec * poly
Definition: hilb.h:10
poly CPowerMultiplier::MultiplyEM ( const CExponent  expLeft,
const poly  pMonom 
)
virtual

Implements CMultiplier< CPower >.

Definition at line 925 of file ncSAMult.cc.

926 {
927  const ring r = GetBasering();
928 
929  // TODO: as above! (difference due to Left/Right semmantics!)
930  const int j = expLeft.Var;
931  const int n = expLeft.Power;
932 
933 #if OUTPUT
934  Print("CPowerMultiplier::MultiplyEM(var(%d)^{%d} * monom)!", j, n);
935  PrintLn();
936  PrintS("Monom: "); p_Write(pMonom, r);
937 #endif
938 
939  assume( (j > 0) && (j <= NVars()));
940 
941  if( n == 0 )
942  return p_Head(pMonom, r); // Copy?!?
943 
944 
945  int v = 1; // NVars();
946  int e = p_GetExp(pMonom, v, r);
947 
948  while((v < j) && (e == 0))
949  e = p_GetExp(pMonom, ++v, r);
950 
951  if( v == j )
952  {
953  poly p = p_Head(pMonom, r);
954  p_SetExp(p, j, e + n, r);
955  p_Setm(p, r);
956 
957  return p;
958  }
959 
960  assume( v < j );
961  assume( e > 0 );
962 
963 
964  // And now the General Case: v > j!
965 
966  poly p = MultiplyEE( expLeft, CPower(v, e) ); // Easy way!
967 
968  ++v;
969 
970  while(v <= NVars())
971  {
972  e = p_GetExp(pMonom, v, r);
973 
974  if( e > 0 )
975  p = MultiplyPEDestroy(p, CPower(v, e));
976 
977  ++v;
978  }
979 
980 #if OUTPUT
981  PrintS("CPowerMultiplier::MultiplyEM() ===> ");
982  p_Write(p, r);
983 #endif
984 
985  return p;
986 
987 }
void PrintLn()
Definition: reporter.cc:322
#define Print
Definition: emacs.cc:83
int NVars() const
Definition: ncSAMult.h:41
return P p
Definition: myNF.cc:203
const CanonicalForm CFMap CFMap int &both_non_zero int n
Definition: cfEzgcd.cc:52
poly MultiplyPEDestroy(poly pPoly, const CExponent expRight)
Definition: ncSAMult.h:240
static poly p_Head(poly p, const ring r)
Definition: p_polys.h:819
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:465
int j
Definition: myNF.cc:70
#define assume(x)
Definition: mod2.h:405
virtual poly MultiplyEE(const CExponent expLeft, const CExponent expRight)
Definition: ncSAMult.cc:992
void PrintS(const char *s)
Definition: reporter.cc:294
ring GetBasering() const
Definition: ncSAMult.h:40
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent : VarOffset encodes the position in p->exp
Definition: p_polys.h:484
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:436
void p_Write(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:206
polyrec * poly
Definition: hilb.h:10
poly CPowerMultiplier::MultiplyEP ( const CExponent  expLeft,
const poly  pPoly 
)
inline

Definition at line 228 of file ncSAMult.h.

229  {
230  bool bUsePolynomial = TEST_OPT_NOT_BUCKETS || (pLength(pPoly) < MIN_LENGTH_BUCKET);
231  CPolynomialSummator sum(GetBasering(), bUsePolynomial);
232 
233  for( poly q = pPoly; q !=NULL; q = pNext(q) )
234  sum += MultiplyET(expLeft, q);
235 
236  return sum;
237  }
#define MIN_LENGTH_BUCKET
Definition: p_Mult_q.h:22
static int pLength(poly a)
Definition: p_polys.h:189
#define TEST_OPT_NOT_BUCKETS
Definition: options.h:100
ring GetBasering() const
Definition: ncSAMult.h:40
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
poly MultiplyET(const CPowerexpLeft, const poly pTerm)
Definition: ncSAMult.h:66
CPolynomialSummator: unifies bucket and polynomial summation as the later is brocken in buckets :(...
Definition: summator.h:29
polyrec * poly
Definition: hilb.h:10
poly CPowerMultiplier::MultiplyEPDestroy ( const CExponent  expLeft,
poly  pPoly 
)
inline

Definition at line 252 of file ncSAMult.h.

253  {
254  bool bUsePolynomial = TEST_OPT_NOT_BUCKETS || (pLength(pPoly) < MIN_LENGTH_BUCKET);
255  CPolynomialSummator sum(GetBasering(), bUsePolynomial);
256 
257  for( ; pPoly!=NULL; pPoly = p_LmDeleteAndNext(pPoly, GetBasering()) )
258  sum += MultiplyET(expLeft, pPoly);
259 
260  return sum;
261  }
static poly p_LmDeleteAndNext(poly p, const ring r)
Definition: p_polys.h:721
#define MIN_LENGTH_BUCKET
Definition: p_Mult_q.h:22
static int pLength(poly a)
Definition: p_polys.h:189
#define TEST_OPT_NOT_BUCKETS
Definition: options.h:100
ring GetBasering() const
Definition: ncSAMult.h:40
#define NULL
Definition: omList.c:10
poly MultiplyET(const CPowerexpLeft, const poly pTerm)
Definition: ncSAMult.h:66
CPolynomialSummator: unifies bucket and polynomial summation as the later is brocken in buckets :(...
Definition: summator.h:29
poly CPowerMultiplier::MultiplyME ( const poly  pMonom,
const CExponent  expRight 
)
virtual

Implements CMultiplier< CPower >.

Definition at line 861 of file ncSAMult.cc.

862 {
863  const int j = expRight.Var;
864  const int n = expRight.Power;
865 
866  const ring r = GetBasering();
867 
868 #if OUTPUT
869  Print("CPowerMultiplier::MultiplyME(monom * var(%d)^{%d})!", j, n);
870  PrintLn();
871  PrintS("Monom: "); p_Write(pMonom, r);
872 #endif
873 
874  assume( (j > 0) && (j <= NVars()));
875 
876  if( n == 0 )
877  return p_Head(pMonom, r); // Copy?!?
878 
879 
880  int v = NVars();
881  int e = p_GetExp(pMonom, v, r);
882 
883  while((v > j) && (e == 0))
884  e = p_GetExp(pMonom, --v, r);
885 
886  // TODO: review this!
887  if( v == j )
888  {
889  poly p = p_Head(pMonom, r);
890  p_SetExp(p, v, e + n, r);
891  p_Setm(p, r);
892 
893  return p;
894  }
895 
896  assume( v > j );
897  assume( e > 0 );
898 
899  // And now the General Case: v > j!
900 
901  poly p = MultiplyEE( CPower(v, e), expRight ); // Easy way!
902 
903  --v;
904 
905  while(v > 0)
906  {
907  e = p_GetExp(pMonom, v, GetBasering());
908 
909  if( e > 0 )
910  p = MultiplyEPDestroy(CPower(v, e), p);
911 
912  --v;
913  }
914 
915 #if OUTPUT
916  PrintS("CPowerMultiplier::MultiplyME() ===> ");
917  p_Write(p, GetBasering());
918 #endif
919 
920  return p;
921 }
void PrintLn()
Definition: reporter.cc:322
#define Print
Definition: emacs.cc:83
int NVars() const
Definition: ncSAMult.h:41
return P p
Definition: myNF.cc:203
const CanonicalForm CFMap CFMap int &both_non_zero int n
Definition: cfEzgcd.cc:52
static poly p_Head(poly p, const ring r)
Definition: p_polys.h:819
const ring r
Definition: syzextra.cc:208
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent : the integer VarOffset encodes:
Definition: p_polys.h:465
int j
Definition: myNF.cc:70
#define assume(x)
Definition: mod2.h:405
virtual poly MultiplyEE(const CExponent expLeft, const CExponent expRight)
Definition: ncSAMult.cc:992
void PrintS(const char *s)
Definition: reporter.cc:294
ring GetBasering() const
Definition: ncSAMult.h:40
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent : VarOffset encodes the position in p->exp
Definition: p_polys.h:484
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:436
poly MultiplyEPDestroy(const CExponent expLeft, poly pPoly)
Definition: ncSAMult.h:252
void p_Write(poly p, ring lmRing, ring tailRing)
Definition: polys0.cc:206
polyrec * poly
Definition: hilb.h:10
poly CPowerMultiplier::MultiplyPE ( const poly  pPoly,
const CExponent  expRight 
)
inline

Definition at line 216 of file ncSAMult.h.

217  {
218  bool bUsePolynomial = TEST_OPT_NOT_BUCKETS || (pLength(pPoly) < MIN_LENGTH_BUCKET);
219  CPolynomialSummator sum(GetBasering(), bUsePolynomial);
220 
221  for( poly q = pPoly; q !=NULL; q = pNext(q) )
222  sum += MultiplyTE(q, expRight);
223 
224  return sum;
225  }
poly MultiplyTE(const poly pTerm, const CPowerexpRight)
Definition: ncSAMult.h:52
#define MIN_LENGTH_BUCKET
Definition: p_Mult_q.h:22
static int pLength(poly a)
Definition: p_polys.h:189
#define TEST_OPT_NOT_BUCKETS
Definition: options.h:100
ring GetBasering() const
Definition: ncSAMult.h:40
#define NULL
Definition: omList.c:10
#define pNext(p)
Definition: monomials.h:43
CPolynomialSummator: unifies bucket and polynomial summation as the later is brocken in buckets :(...
Definition: summator.h:29
polyrec * poly
Definition: hilb.h:10
poly CPowerMultiplier::MultiplyPEDestroy ( poly  pPoly,
const CExponent  expRight 
)
inline

Definition at line 240 of file ncSAMult.h.

241  {
242  bool bUsePolynomial = TEST_OPT_NOT_BUCKETS || (pLength(pPoly) < MIN_LENGTH_BUCKET);
243  CPolynomialSummator sum(GetBasering(), bUsePolynomial);
244 
245  for( ; pPoly!=NULL; pPoly = p_LmDeleteAndNext(pPoly, GetBasering()) )
246  sum += MultiplyTE(pPoly, expRight);
247 
248  return sum;
249  }
static poly p_LmDeleteAndNext(poly p, const ring r)
Definition: p_polys.h:721
poly MultiplyTE(const poly pTerm, const CPowerexpRight)
Definition: ncSAMult.h:52
#define MIN_LENGTH_BUCKET
Definition: p_Mult_q.h:22
static int pLength(poly a)
Definition: p_polys.h:189
#define TEST_OPT_NOT_BUCKETS
Definition: options.h:100
ring GetBasering() const
Definition: ncSAMult.h:40
#define NULL
Definition: omList.c:10
CPolynomialSummator: unifies bucket and polynomial summation as the later is brocken in buckets :(...
Definition: summator.h:29

Field Documentation

CSpecialPairMultiplier** CPowerMultiplier::m_specialpairs
private

Definition at line 171 of file ncSAMult.h.


The documentation for this class was generated from the following files: