My Project  UNKNOWN_GIT_VERSION
Functions | Variables
pcv.cc File Reference
#include "kernel/mod2.h"
#include "Singular/tok.h"
#include "Singular/ipid.h"
#include "coeffs/numbers.h"
#include "kernel/polys.h"
#include "kernel/ideals.h"
#include "Singular/lists.h"
#include "polys/matpol.h"
#include "Singular/ipshell.h"
#include "Singular/pcv.h"

Go to the source code of this file.

Functions

lists pcvLAddL (lists l1, lists l2)
 
lists pcvPMulL (poly p, lists l1)
 
BOOLEAN pcvLAddL (leftv res, leftv h)
 
BOOLEAN pcvPMulL (leftv res, leftv h)
 
int pcvDeg (poly p)
 
int pcvMinDeg (poly p)
 
int pcvMinDeg (matrix m)
 
BOOLEAN pcvMinDeg (leftv res, leftv h)
 
void pcvInit (int d)
 
void pcvClean ()
 
int pcvM2N (poly m)
 
poly pcvN2M (int n)
 
poly pcvP2CV (poly p, int d0, int d1)
 
poly pcvCV2P (poly cv, int d0, int d1)
 
lists pcvP2CV (lists pl, int d0, int d1)
 
lists pcvCV2P (lists cvl, int d0, int d1)
 
BOOLEAN pcvP2CV (leftv res, leftv h)
 
BOOLEAN pcvCV2P (leftv res, leftv h)
 
int pcvDim (int d0, int d1)
 
BOOLEAN pcvDim (leftv res, leftv h)
 
int pcvBasis (lists b, int i, poly m, int d, int n)
 
lists pcvBasis (int d0, int d1)
 
BOOLEAN pcvBasis (leftv res, leftv h)
 

Variables

static int pcvMaxDegree
 
static int pcvTableSize
 
static int pcvIndexSize
 
static unsigned * pcvTable =NULL
 
static unsigned ** pcvIndex =NULL
 

Function Documentation

◆ pcvBasis() [1/3]

int pcvBasis ( lists  b,
int  i,
poly  m,
int  d,
int  n 
)

Definition at line 430 of file pcv.cc.

431 {
432  if(n<currRing->N)
433  {
434  for(int k=0,l=d;k<=l;k++,d--)
435  {
436  pSetExp(m,n,k);
437  i=pcvBasis(b,i,m,d,n+1);
438  }
439  }
440  else
441  {
442  pSetExp(m,n,d);
443  pSetm(m);
444  b->m[i].rtyp=POLY_CMD;
445  b->m[i++].data=pCopy(m);
446  }
447  return i;
448 }
#define pSetm(p)
Definition: polys.h:265
#define pSetExp(p, i, v)
Definition: polys.h:42
int k
Definition: cfEzgcd.cc:92
CanonicalForm b
Definition: cfModGcd.cc:4044
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:48
int m
Definition: cfEzgcd.cc:121
int i
Definition: cfEzgcd.cc:125
int pcvBasis(lists b, int i, poly m, int d, int n)
Definition: pcv.cc:430
int l
Definition: cfEzgcd.cc:93
#define pCopy(p)
return a copy of the poly
Definition: polys.h:180

◆ pcvBasis() [2/3]

lists pcvBasis ( int  d0,
int  d1 
)

Definition at line 450 of file pcv.cc.

451 {
452  if(d0<0) d0=0;
453  if(d1<0) d1=0;
455  b->Init(pcvDim(d0,d1));
456  poly m=pOne();
457  for(int d=d0,i=0;d<d1;d++)
458  i=pcvBasis(b,i,m,d,1);
459  pLmDelete(&m);
460  return b;
461 }
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
Definition: lists.h:22
#define pLmDelete(p)
assume p != NULL, deletes Lm(p)->coef and Lm(p)
Definition: polys.h:76
CanonicalForm b
Definition: cfModGcd.cc:4044
int pcvDim(int d0, int d1)
Definition: pcv.cc:400
int m
Definition: cfEzgcd.cc:121
int i
Definition: cfEzgcd.cc:125
#define pOne()
Definition: polys.h:309
int pcvBasis(lists b, int i, poly m, int d, int n)
Definition: pcv.cc:430
slists * lists
Definition: mpr_numeric.h:146
omBin slists_bin
Definition: lists.cc:23

◆ pcvBasis() [3/3]

BOOLEAN pcvBasis ( leftv  res,
leftv  h 
)

Definition at line 463 of file pcv.cc.

464 {
465  if(currRing)
466  {
467  const short t[]={2,INT_CMD,INT_CMD};
468  if (iiCheckTypes(h,t,1))
469  {
470  int d0=(int)(long)h->Data();
471  h=h->next;
472  int d1=(int)(long)h->Data();
473  res->rtyp=LIST_CMD;
474  res->data=(void*)pcvBasis(d0,d1);
475  return FALSE;
476  }
477  return TRUE;
478  }
479  WerrorS("no ring active");
480  return TRUE;
481 }
Definition: tok.h:96
#define FALSE
Definition: auxiliary.h:94
#define TRUE
Definition: auxiliary.h:98
void WerrorS(const char *s)
Definition: feFopen.cc:24
CanonicalForm res
Definition: facAbsFact.cc:64
int pcvBasis(lists b, int i, poly m, int d, int n)
Definition: pcv.cc:430
BOOLEAN iiCheckTypes(leftv args, const short *type_list, int report)
check a list of arguemys against a given field of types return TRUE if the types match return FALSE (...
Definition: ipshell.cc:6546
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
Definition: tok.h:118
static Poly * h
Definition: janet.cc:972

◆ pcvClean()

void pcvClean ( )

Definition at line 223 of file pcv.cc.

224 {
225  if(pcvTable)
226  {
228  pcvTable=NULL;
229  }
230  if(pcvIndex)
231  {
233  pcvIndex=NULL;
234  }
235 }
static unsigned * pcvTable
Definition: pcv.cc:28
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
static unsigned ** pcvIndex
Definition: pcv.cc:29
static int pcvIndexSize
Definition: pcv.cc:27
#define NULL
Definition: omList.c:10
static int pcvTableSize
Definition: pcv.cc:26

◆ pcvCV2P() [1/3]

poly pcvCV2P ( poly  cv,
int  d0,
int  d1 
)

Definition at line 297 of file pcv.cc.

298 {
299  poly p=NULL;
300  while(cv)
301  {
302  poly m=pcvN2M(pGetComp(cv));
303  if(m)
304  {
305  int d=pcvDeg(m);
306  if(d0<=d&&d<d1)
307  {
308  pSetCoeff(m,nCopy(pGetCoeff(cv)));
309  p=pAdd(p,m);
310  }
311  }
312  pIter(cv);
313  }
314  return p;
315 }
#define pAdd(p, q)
Definition: polys.h:198
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
Definition: monomials.h:45
#define pGetComp(p)
Component.
Definition: polys.h:37
#define pIter(p)
Definition: monomials.h:38
int pcvDeg(poly p)
Definition: pcv.cc:128
int m
Definition: cfEzgcd.cc:121
#define NULL
Definition: omList.c:10
poly pcvN2M(int n)
Definition: pcv.cc:254
#define nCopy(n)
Definition: numbers.h:16
int p
Definition: cfModGcd.cc:4019
#define pSetCoeff(p, n)
deletes old coeff before setting the new one
Definition: polys.h:31

◆ pcvCV2P() [2/3]

lists pcvCV2P ( lists  cvl,
int  d0,
int  d1 
)

Definition at line 339 of file pcv.cc.

340 {
342  pl->Init(cvl->nr+1);
343  pcvInit(d1);
344  for(int i=cvl->nr;i>=0;i--)
345  {
346  if(cvl->m[i].rtyp==VECTOR_CMD)
347  {
348  pl->m[i].rtyp=POLY_CMD;
349  pl->m[i].data=pcvCV2P((poly)cvl->m[i].data,d0,d1);
350  }
351  }
352  pcvClean();
353  return pl;
354 }
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
sleftv * m
Definition: lists.h:45
Definition: lists.h:22
void * data
Definition: subexpr.h:88
void pcvInit(int d)
Definition: pcv.cc:193
void pcvClean()
Definition: pcv.cc:223
poly pcvCV2P(poly cv, int d0, int d1)
Definition: pcv.cc:297
int i
Definition: cfEzgcd.cc:125
INLINE_THIS void Init(int l=0)
int nr
Definition: lists.h:43
slists * lists
Definition: mpr_numeric.h:146
int rtyp
Definition: subexpr.h:91
omBin slists_bin
Definition: lists.cc:23

◆ pcvCV2P() [3/3]

BOOLEAN pcvCV2P ( leftv  res,
leftv  h 
)

Definition at line 378 of file pcv.cc.

379 {
380  if(currRing)
381  {
382  const short t[]={3,LIST_CMD,INT_CMD,INT_CMD};
383  if (iiCheckTypes(h,t,1))
384  {
385  lists pl=(lists)h->Data();
386  h=h->next;
387  int d0=(int)(long)h->Data();
388  h=h->next;
389  int d1=(int)(long)h->Data();
390  res->rtyp=LIST_CMD;
391  res->data=(void*)pcvCV2P(pl,d0,d1);
392  return FALSE;
393  }
394  return TRUE;
395  }
396  WerrorS("no ring active");
397  return TRUE;
398 }
Definition: tok.h:96
Definition: lists.h:22
#define FALSE
Definition: auxiliary.h:94
#define TRUE
Definition: auxiliary.h:98
void WerrorS(const char *s)
Definition: feFopen.cc:24
CanonicalForm res
Definition: facAbsFact.cc:64
poly pcvCV2P(poly cv, int d0, int d1)
Definition: pcv.cc:297
slists * lists
Definition: mpr_numeric.h:146
BOOLEAN iiCheckTypes(leftv args, const short *type_list, int report)
check a list of arguemys against a given field of types return TRUE if the types match return FALSE (...
Definition: ipshell.cc:6546
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
Definition: tok.h:118
static Poly * h
Definition: janet.cc:972

◆ pcvDeg()

int pcvDeg ( poly  p)

Definition at line 128 of file pcv.cc.

129 {
130  int d=0;
131  for(int i=currRing->N;i>=1;i--) d+=pGetExp(p,i);
132  return d;
133 }
#define pGetExp(p, i)
Exponent.
Definition: polys.h:41
int i
Definition: cfEzgcd.cc:125
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
int p
Definition: cfModGcd.cc:4019

◆ pcvDim() [1/2]

int pcvDim ( int  d0,
int  d1 
)

Definition at line 400 of file pcv.cc.

401 {
402  if(d0<0) d0=0;
403  if(d1<0) d1=0;
404  pcvInit(d1);
405  int d=pcvIndex[currRing->N-1][d1]-pcvIndex[currRing->N-1][d0];
406  pcvClean();
407  return d;
408 }
static unsigned ** pcvIndex
Definition: pcv.cc:29
void pcvInit(int d)
Definition: pcv.cc:193
void pcvClean()
Definition: pcv.cc:223
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13

◆ pcvDim() [2/2]

BOOLEAN pcvDim ( leftv  res,
leftv  h 
)

Definition at line 410 of file pcv.cc.

411 {
412  if(currRing)
413  {
414  const short t[]={2,INT_CMD,INT_CMD};
415  if (iiCheckTypes(h,t,1))
416  {
417  int d0=(int)(long)h->Data();
418  h=h->next;
419  int d1=(int)(long)h->Data();
420  res->rtyp=INT_CMD;
421  res->data=(void*)(long)pcvDim(d0,d1);
422  return FALSE;
423  }
424  return TRUE;
425  }
426  WerrorS("no ring active");
427  return TRUE;
428 }
Definition: tok.h:96
#define FALSE
Definition: auxiliary.h:94
#define TRUE
Definition: auxiliary.h:98
void WerrorS(const char *s)
Definition: feFopen.cc:24
CanonicalForm res
Definition: facAbsFact.cc:64
int pcvDim(int d0, int d1)
Definition: pcv.cc:400
BOOLEAN iiCheckTypes(leftv args, const short *type_list, int report)
check a list of arguemys against a given field of types return TRUE if the types match return FALSE (...
Definition: ipshell.cc:6546
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
static Poly * h
Definition: janet.cc:972

◆ pcvInit()

void pcvInit ( int  d)

Definition at line 193 of file pcv.cc.

194 {
195  if(d<0) d=1;
196  pcvMaxDegree=d+1;
197  pcvTableSize=currRing->N*pcvMaxDegree*sizeof(unsigned);
198  pcvTable=(unsigned*)omAlloc0(pcvTableSize);
199  pcvIndexSize=currRing->N*sizeof(unsigned*);
200  pcvIndex=(unsigned**)omAlloc(pcvIndexSize);
201  for(int i=0;i<currRing->N;i++)
203  for(int i=0;i<pcvMaxDegree;i++)
204  pcvIndex[0][i]=i;
205  unsigned k,l;
206  for(int i=1;i<currRing->N;i++)
207  {
208  k=0;
209  for(int j=0;j<pcvMaxDegree;j++)
210  {
211  l=pcvIndex[i-1][j];
212  if(l>unsigned(~0)-k)
213  {
214  j=pcvMaxDegree;
215  i=currRing->N;
216  WerrorS("unsigned overflow");
217  }
218  else pcvIndex[i][j]=k+=l;
219  }
220  }
221 }
int j
Definition: facHensel.cc:105
static unsigned * pcvTable
Definition: pcv.cc:28
void WerrorS(const char *s)
Definition: feFopen.cc:24
int k
Definition: cfEzgcd.cc:92
static unsigned ** pcvIndex
Definition: pcv.cc:29
#define omAlloc(size)
Definition: omAllocDecl.h:210
int i
Definition: cfEzgcd.cc:125
static int pcvIndexSize
Definition: pcv.cc:27
static int pcvMaxDegree
Definition: pcv.cc:25
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
static int pcvTableSize
Definition: pcv.cc:26
#define omAlloc0(size)
Definition: omAllocDecl.h:211
int l
Definition: cfEzgcd.cc:93

◆ pcvLAddL() [1/2]

lists pcvLAddL ( lists  l1,
lists  l2 
)

Definition at line 31 of file pcv.cc.

32 {
34  int i=l1->nr;
35  if(l1->nr<l2->nr) i=l2->nr;
36  l0->Init(i+1);
37  for(;i>=0;i--)
38  {
39  if(i<=l1->nr
40  &&(l1->m[i].rtyp==POLY_CMD||l1->m[i].rtyp==BUCKET_CMD||l1->m[i].rtyp==VECTOR_CMD))
41  {
42  if (l1->m[i].rtyp==BUCKET_CMD)
43  {
44  poly p=sBucketPeek((sBucket_pt)l1->m[i].data);
45  l0->m[i].rtyp=POLY_CMD;
46  l0->m[i].data=pCopy(p);
47  }
48  else
49  {
50  l0->m[i].rtyp=l1->m[i].rtyp;
51  l0->m[i].data=pCopy((poly)l1->m[i].data);
52  }
53  if(i<=l2->nr&&l2->m[i].rtyp==l0->m[i].rtyp)
54  l0->m[i].data=pAdd((poly)l0->m[i].data,pCopy((poly)l2->m[i].data));
55  }
56  else
57  if(i<=l2->nr
58  &&(l2->m[i].rtyp==POLY_CMD||l2->m[i].rtyp==BUCKET_CMD||l2->m[i].rtyp==VECTOR_CMD))
59  {
60  if (l2->m[i].rtyp==BUCKET_CMD)
61  {
62  poly p=sBucketPeek((sBucket_pt)l2->m[i].data);
63  l0->m[i].rtyp=POLY_CMD;
64  l0->m[i].data=pCopy(p);
65  }
66  else
67  {
68  l0->m[i].rtyp=l2->m[i].rtyp;
69  l0->m[i].data=pCopy((poly)l2->m[i].data);
70  }
71  }
72  }
73  return(l0);
74 }
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
sleftv * m
Definition: lists.h:45
#define pAdd(p, q)
Definition: polys.h:198
Definition: lists.h:22
void * data
Definition: subexpr.h:88
int i
Definition: cfEzgcd.cc:125
INLINE_THIS void Init(int l=0)
int nr
Definition: lists.h:43
slists * lists
Definition: mpr_numeric.h:146
int rtyp
Definition: subexpr.h:91
poly sBucketPeek(sBucket_pt b)
Definition: sbuckets.cc:455
omBin slists_bin
Definition: lists.cc:23
int p
Definition: cfModGcd.cc:4019
#define pCopy(p)
return a copy of the poly
Definition: polys.h:180

◆ pcvLAddL() [2/2]

BOOLEAN pcvLAddL ( leftv  res,
leftv  h 
)

Definition at line 96 of file pcv.cc.

97 {
98  const short t[]={2,LIST_CMD,LIST_CMD};
99  if (iiCheckTypes(h,t,1))
100  {
101  lists l1=(lists)h->Data();
102  h=h->next;
103  lists l2=(lists)h->Data();
104  res->rtyp=LIST_CMD;
105  res->data=(void*)pcvLAddL(l1,l2);
106  return FALSE;
107  }
108  return TRUE;
109 }
Definition: lists.h:22
#define FALSE
Definition: auxiliary.h:94
#define TRUE
Definition: auxiliary.h:98
CanonicalForm res
Definition: facAbsFact.cc:64
lists pcvLAddL(lists l1, lists l2)
Definition: pcv.cc:31
slists * lists
Definition: mpr_numeric.h:146
BOOLEAN iiCheckTypes(leftv args, const short *type_list, int report)
check a list of arguemys against a given field of types return TRUE if the types match return FALSE (...
Definition: ipshell.cc:6546
Definition: tok.h:118
static Poly * h
Definition: janet.cc:972

◆ pcvM2N()

int pcvM2N ( poly  m)

Definition at line 237 of file pcv.cc.

238 {
239  unsigned n=0,dn,d=0;
240  for(int i=0;i<currRing->N;i++)
241  {
242  d+=pGetExp(m,i+1);
243  dn=pcvIndex[i][d];
244  if(dn>MAX_INT_VAL-n)
245  {
246  i=currRing->N;
247  WerrorS("component overflow");
248  }
249  else n+=dn;
250  }
251  return n+1;
252 }
const int MAX_INT_VAL
Definition: mylimits.h:12
void WerrorS(const char *s)
Definition: feFopen.cc:24
static unsigned ** pcvIndex
Definition: pcv.cc:29
#define pGetExp(p, i)
Exponent.
Definition: polys.h:41
int m
Definition: cfEzgcd.cc:121
int i
Definition: cfEzgcd.cc:125
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13

◆ pcvMinDeg() [1/3]

int pcvMinDeg ( poly  p)

Definition at line 135 of file pcv.cc.

136 {
137  if(!p) return -1;
138  int md=pcvDeg(p);
139  pIter(p);
140  while(p)
141  {
142  int d=pcvDeg(p);
143  if(d<md) md=d;
144  pIter(p);
145  }
146  return md;
147 }
#define pIter(p)
Definition: monomials.h:38
int pcvDeg(poly p)
Definition: pcv.cc:128
int p
Definition: cfModGcd.cc:4019

◆ pcvMinDeg() [2/3]

int pcvMinDeg ( matrix  m)

Definition at line 149 of file pcv.cc.

150 {
151  int i,j,d;
152  int md=-1;
153  for(i=1;i<=MATROWS(m);i++)
154  {
155  for(j=1;j<=MATCOLS(m);j++)
156  {
157  d=pcvMinDeg(MATELEM(m,i,j));
158  if((d>=0&&md>d)||md==-1) md=d;
159  }
160  }
161  return(md);
162 }
int j
Definition: facHensel.cc:105
int m
Definition: cfEzgcd.cc:121
int i
Definition: cfEzgcd.cc:125
#define MATCOLS(i)
Definition: matpol.h:27
#define MATROWS(i)
Definition: matpol.h:26
int pcvMinDeg(poly p)
Definition: pcv.cc:135
#define MATELEM(mat, i, j)
Definition: matpol.h:28

◆ pcvMinDeg() [3/3]

BOOLEAN pcvMinDeg ( leftv  res,
leftv  h 
)

Definition at line 164 of file pcv.cc.

165 {
166  if(h)
167  {
168  if(h->Typ()==BUCKET_CMD)
169  {
170  res->rtyp=INT_CMD;
171  res->data=(void*)(long)pcvMinDeg(sBucketPeek((sBucket_pt)h->Data()));
172  return FALSE;
173  }
174  else
175  if(h->Typ()==POLY_CMD)
176  {
177  res->rtyp=INT_CMD;
178  res->data=(void*)(long)pcvMinDeg((poly)h->Data());
179  return FALSE;
180  }
181  else
182  if(h->Typ()==MATRIX_CMD)
183  {
184  res->rtyp=INT_CMD;
185  res->data=(void*)(long)pcvMinDeg((matrix)h->Data());
186  return FALSE;
187  }
188  }
189  WerrorS("<poly> expected");
190  return TRUE;
191 }
Definition: tok.h:96
#define FALSE
Definition: auxiliary.h:94
#define TRUE
Definition: auxiliary.h:98
void WerrorS(const char *s)
Definition: feFopen.cc:24
CanonicalForm res
Definition: facAbsFact.cc:64
poly sBucketPeek(sBucket_pt b)
Definition: sbuckets.cc:455
static Poly * h
Definition: janet.cc:972
int pcvMinDeg(poly p)
Definition: pcv.cc:135

◆ pcvN2M()

poly pcvN2M ( int  n)

Definition at line 254 of file pcv.cc.

255 {
256  n--;
257  poly m=pOne();
258  int i,j=0,k;
259  for(i=currRing->N-1;i>=0;i--)
260  {
261  k=j;
262  for(j=0; (j<pcvMaxDegree) && (pcvIndex[i][j]<=(unsigned)n); j++);
263  j--;
264  n-=pcvIndex[i][j];
265  if(i<currRing->N-1) pSetExp(m,i+2,k-j);
266  }
267  if(n==0)
268  {
269  pSetExp(m,1,j);
270  pSetm(m);
271  return m;
272  }
273  else
274  {
275  pLmDelete(&m);
276  return NULL;
277  }
278 }
int j
Definition: facHensel.cc:105
#define pSetm(p)
Definition: polys.h:265
#define pSetExp(p, i, v)
Definition: polys.h:42
#define pLmDelete(p)
assume p != NULL, deletes Lm(p)->coef and Lm(p)
Definition: polys.h:76
int k
Definition: cfEzgcd.cc:92
static unsigned ** pcvIndex
Definition: pcv.cc:29
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:48
int m
Definition: cfEzgcd.cc:121
int i
Definition: cfEzgcd.cc:125
#define pOne()
Definition: polys.h:309
#define NULL
Definition: omList.c:10
static int pcvMaxDegree
Definition: pcv.cc:25
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13

◆ pcvP2CV() [1/3]

poly pcvP2CV ( poly  p,
int  d0,
int  d1 
)

Definition at line 280 of file pcv.cc.

281 {
282  poly cv=NULL;
283  while(p)
284  {
285  int d=pcvDeg(p);
286  if(d0<=d&&d<d1)
287  {
288  poly c=pNSet(nCopy(pGetCoeff(p)));
289  pSetComp(c,pcvM2N(p));
290  cv=pAdd(cv,c);
291  }
292  pIter(p);
293  }
294  return cv;
295 }
int pcvM2N(poly m)
Definition: pcv.cc:237
#define pAdd(p, q)
Definition: polys.h:198
#define pNSet(n)
Definition: polys.h:307
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
Definition: monomials.h:45
#define pIter(p)
Definition: monomials.h:38
int pcvDeg(poly p)
Definition: pcv.cc:128
#define pSetComp(p, v)
Definition: polys.h:38
#define NULL
Definition: omList.c:10
#define nCopy(n)
Definition: numbers.h:16
int p
Definition: cfModGcd.cc:4019

◆ pcvP2CV() [2/3]

lists pcvP2CV ( lists  pl,
int  d0,
int  d1 
)

Definition at line 317 of file pcv.cc.

318 {
320  cvl->Init(pl->nr+1);
321  pcvInit(d1);
322  for(int i=pl->nr;i>=0;i--)
323  {
324  if(pl->m[i].rtyp==POLY_CMD)
325  {
326  cvl->m[i].rtyp=VECTOR_CMD;
327  cvl->m[i].data=pcvP2CV((poly)pl->m[i].data,d0,d1);
328  }
329  else if(pl->m[i].rtyp==BUCKET_CMD)
330  {
331  cvl->m[i].rtyp=VECTOR_CMD;
332  cvl->m[i].data=pcvP2CV(sBucketPeek((sBucket_pt)pl->m[i].data),d0,d1);
333  }
334  }
335  pcvClean();
336  return cvl;
337 }
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
sleftv * m
Definition: lists.h:45
Definition: lists.h:22
void * data
Definition: subexpr.h:88
void pcvInit(int d)
Definition: pcv.cc:193
void pcvClean()
Definition: pcv.cc:223
int i
Definition: cfEzgcd.cc:125
INLINE_THIS void Init(int l=0)
int nr
Definition: lists.h:43
slists * lists
Definition: mpr_numeric.h:146
int rtyp
Definition: subexpr.h:91
poly sBucketPeek(sBucket_pt b)
Definition: sbuckets.cc:455
poly pcvP2CV(poly p, int d0, int d1)
Definition: pcv.cc:280
omBin slists_bin
Definition: lists.cc:23

◆ pcvP2CV() [3/3]

BOOLEAN pcvP2CV ( leftv  res,
leftv  h 
)

Definition at line 356 of file pcv.cc.

357 {
358  if(currRing)
359  {
360  const short t[]={3,LIST_CMD,INT_CMD,INT_CMD};
361  if (iiCheckTypes(h,t,1))
362  {
363  lists p=(lists)h->Data();
364  h=h->next;
365  int d0=(int)(long)h->Data();
366  h=h->next;
367  int d1=(int)(long)h->Data();
368  res->rtyp=LIST_CMD;
369  res->data=(void*)pcvP2CV(p,d0,d1);
370  return FALSE;
371  }
372  return TRUE;
373  }
374  WerrorS("no ring active");
375  return TRUE;
376 }
Definition: tok.h:96
Definition: lists.h:22
#define FALSE
Definition: auxiliary.h:94
#define TRUE
Definition: auxiliary.h:98
void WerrorS(const char *s)
Definition: feFopen.cc:24
CanonicalForm res
Definition: facAbsFact.cc:64
slists * lists
Definition: mpr_numeric.h:146
BOOLEAN iiCheckTypes(leftv args, const short *type_list, int report)
check a list of arguemys against a given field of types return TRUE if the types match return FALSE (...
Definition: ipshell.cc:6546
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
poly pcvP2CV(poly p, int d0, int d1)
Definition: pcv.cc:280
Definition: tok.h:118
int p
Definition: cfModGcd.cc:4019
static Poly * h
Definition: janet.cc:972

◆ pcvPMulL() [1/2]

lists pcvPMulL ( poly  p,
lists  l1 
)

Definition at line 76 of file pcv.cc.

77 {
79  l0->Init(l1->nr+1);
80  for(int i=l1->nr;i>=0;i--)
81  {
82  if(l1->m[i].rtyp==POLY_CMD)
83  {
84  l0->m[i].rtyp=POLY_CMD;
85  l0->m[i].data=ppMult_qq(p,(poly)l1->m[i].data);
86  }
87  else if(l1->m[i].rtyp==BUCKET_CMD)
88  {
89  l0->m[i].rtyp=POLY_CMD;
90  l0->m[i].data=ppMult_qq(p,sBucketPeek((sBucket_pt)l1->m[i].data));
91  }
92  }
93  return(l0);
94 }
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
#define ppMult_qq(p, q)
Definition: polys.h:203
sleftv * m
Definition: lists.h:45
Definition: lists.h:22
void * data
Definition: subexpr.h:88
int i
Definition: cfEzgcd.cc:125
INLINE_THIS void Init(int l=0)
int nr
Definition: lists.h:43
slists * lists
Definition: mpr_numeric.h:146
int rtyp
Definition: subexpr.h:91
poly sBucketPeek(sBucket_pt b)
Definition: sbuckets.cc:455
omBin slists_bin
Definition: lists.cc:23
int p
Definition: cfModGcd.cc:4019

◆ pcvPMulL() [2/2]

BOOLEAN pcvPMulL ( leftv  res,
leftv  h 
)

Definition at line 111 of file pcv.cc.

112 {
113  const short t1[]={2,POLY_CMD,LIST_CMD};
114  const short t2[]={2,BUCKET_CMD,LIST_CMD};
115  if (iiCheckTypes(h,t2,0)
116  ||iiCheckTypes(h,t1,1))
117  {
118  poly p=(poly)h->Data();
119  h=h->next;
120  lists l=(lists)h->Data();
121  res->rtyp=LIST_CMD;
122  res->data=(void*)pcvPMulL(p,l);
123  return FALSE;
124  }
125  return TRUE;
126 }
Definition: lists.h:22
#define FALSE
Definition: auxiliary.h:94
lists pcvPMulL(poly p, lists l1)
Definition: pcv.cc:76
#define TRUE
Definition: auxiliary.h:98
CanonicalForm res
Definition: facAbsFact.cc:64
slists * lists
Definition: mpr_numeric.h:146
BOOLEAN iiCheckTypes(leftv args, const short *type_list, int report)
check a list of arguemys against a given field of types return TRUE if the types match return FALSE (...
Definition: ipshell.cc:6546
Definition: tok.h:118
int p
Definition: cfModGcd.cc:4019
static Poly * h
Definition: janet.cc:972
int l
Definition: cfEzgcd.cc:93

Variable Documentation

◆ pcvIndex

unsigned** pcvIndex =NULL
static

Definition at line 29 of file pcv.cc.

◆ pcvIndexSize

int pcvIndexSize
static

Definition at line 27 of file pcv.cc.

◆ pcvMaxDegree

int pcvMaxDegree
static

Definition at line 25 of file pcv.cc.

◆ pcvTable

unsigned* pcvTable =NULL
static

Definition at line 28 of file pcv.cc.

◆ pcvTableSize

int pcvTableSize
static

Definition at line 26 of file pcv.cc.