shiftgb.cc
Go to the documentation of this file.
1 /****************************************
2 * Computer Algebra System SINGULAR *
3 ****************************************/
4 /*
5 * ABSTRACT: kernel: utils for shift GB and free GB
6 */
7 
8 
9 
10 
11 #include <kernel/mod2.h>
12 
13 #ifdef HAVE_SHIFTBBA
14 #include <polys/monomials/ring.h>
15 #include <kernel/polys.h>
16 #include <coeffs/numbers.h>
17 #include <kernel/ideals.h>
18 #include <polys/matpol.h>
19 #include <polys/kbuckets.h>
20 #include <kernel/GBEngine/kstd1.h>
21 #include <polys/sbuckets.h>
23 #include <kernel/GBEngine/kutil.h>
24 #include <kernel/structs.h>
25 #include <omalloc/omalloc.h>
26 #include <kernel/GBEngine/khstd.h>
27 #include <polys/kbuckets.h>
28 #include <polys/weight.h>
29 #include <misc/intvec.h>
30 #include <kernel/structs.h>
33 #include <polys/weight.h>
34 #include <misc/intvec.h>
36 #include <polys/nc/sca.h>
37 
38 
39 #define freeT(A,v) omFreeSize((ADDRESS)A,(v+1)*sizeof(int))
40 
41 
42 /* TODO: write p* stuff as instances of p_* for all the functions */
43 /* p_* functions are new, p* are old */
44 
45 poly p_LPshiftT(poly p, int sh, int uptodeg, int lV, kStrategy strat, const ring r)
46 {
47  /* assume shift takes place, shifts the poly p by sh */
48  /* p is like TObject: lm in currRing = r, tail in tailRing */
49 
50  if (p==NULL) return(p);
51 
54 
55  /* assume sh and uptodeg agree TODO check */
56 
57  if (sh == 0) return(p); /* the zero shift */
58 
59  poly q = NULL;
60  poly s = p_mLPshift(p, sh, uptodeg, lV, r); // lm in currRing
61  poly pp = pNext(p);
62 
63  while (pp != NULL)
64  {
65  q = p_Add_q(q, p_mLPshift(pp,sh,uptodeg,lV,strat->tailRing),strat->tailRing);
66  pIter(pp);
67  }
68  pNext(s) = q;
69  /* int version: returns TRUE if it was successful */
70  return(s);
71 }
72 
73 
74 poly p_LPshift(poly p, int sh, int uptodeg, int lV, const ring r)
75 {
76  /* assume shift takes place */
77  /* shifts the poly p from the ring r by sh */
78 
79  /* assume sh and uptodeg agree TODO check */
80 
81  if (p==NULL) return(p);
82  if (sh == 0) return(p); /* the zero shift */
83 
84  poly q = NULL;
85  poly pp = p; // do not take copies
86  while (pp!=NULL)
87  {
88  q = p_Add_q(q, p_mLPshift(pp,sh,uptodeg,lV,r),r);
89  pIter(pp);
90  }
91  return(q);
92 }
93 
94 poly p_mLPshift(poly p, int sh, int uptodeg, int lV, const ring r)
95 {
96  /* p is a monomial from the ring r */
97 
98  if (sh == 0) return(p); /* the zero shift */
99 
100  if (sh < 0 )
101  {
102 #ifdef PDEBUG
103  PrintS("pmLPshift: negative shift requested\n");
104 #endif
105  return(NULL); /* violation, 2check */
106  }
107 
108  int L = p_mLastVblock(p,lV,r);
109  if (L+sh-1 > uptodeg)
110  {
111 #ifdef PDEBUG
112  PrintS("p_mLPshift: too big shift requested\n");
113 #endif
114  return(NULL); /* violation, 2check */
115  }
116  int *e=(int *)omAlloc0((r->N+1)*sizeof(int));
117  int *s=(int *)omAlloc0((r->N+1)*sizeof(int));
118  p_GetExpV(p,e,r);
119 
120  int j;
121  // for (j=1; j<=r->N; j++)
122  // L*lV gives the last position of the last block
123  for (j=1; j<= L*lV ; j++)
124  {
125  if (e[j]==1)
126  {
127  s[j + (sh*lV)] = e[j]; /* actually 1 */
128 #ifdef PDEBUG
129  omCheckAddr(s);
130 #endif
131  }
132 #ifdef PDEBUG
133  else
134  {
135  if (e[j]!=0)
136  {
137  // Print("p_mLPshift: ex[%d]=%d\n",j,e[j]);
138  }
139  }
140 #endif
141  }
142  poly m = p_One(r);
143  p_SetExpV(m,s,r);
144  freeT(e, r->N);
145  freeT(s, r->N);
146  /* pSetm(m); */ /* done in the pSetExpV */
147  /* think on the component and coefficient */
148  // number c = pGetCoeff(p);
149  // p_SetCoeff0(m,p_GetCoeff(p,r),r);
150  p_SetComp(m,p_GetComp(p,r),r); // component is preserved
151  p_SetCoeff0(m,n_Copy(p_GetCoeff(p,r),r->cf),r); // coeff is preserved
152  return(m);
153 }
154 
155 poly pLPshift(poly p, int sh, int uptodeg, int lV)
156 {
157  /* assume shift takes place */
158  /* shifts the poly p by sh */
159  /* deletes p */
160 
161  /* assume sh and uptodeg agree */
162 
163  if (sh == 0) return(p); /* the zero shift */
164 
165  poly q = NULL;
166  poly pp = p; // pCopy(p);
167  while (pp!=NULL)
168  {
169  q = p_Add_q(q, pmLPshift(pp,sh,uptodeg,lV),currRing);
170  pIter(pp);
171  }
172  /* delete pp? */
173  p_Delete(&p,currRing);
174  /* int version: returns TRUE if it was successful */
175  return(q);
176 }
177 
178 poly pmLPshift(poly p, int sh, int uptodeg, int lV)
179 {
180  /* TODO: use a shortcut with p_ version */
181  /* pm is a monomial */
182 
183  if (sh == 0) return(p); /* the zero shift */
184 
185  if (sh < 0 )
186  {
187 #ifdef PDEBUG
188  PrintS("pmLPshift: negative shift requested\n");
189 #endif
190  return(NULL); /* violation, 2check */
191  }
192 
193  int L = pmLastVblock(p,lV);
194  if (L+sh-1 > uptodeg)
195  {
196 #ifdef PDEBUG
197  PrintS("pmLPshift: too big shift requested\n");
198 #endif
199  return(NULL); /* violation, 2check */
200  }
201  int *e=(int *)omAlloc0((currRing->N+1)*sizeof(int));
202  int *s=(int *)omAlloc0((currRing->N+1)*sizeof(int));
203  pGetExpV(p,e);
204  number c = pGetCoeff(p);
205  int j;
206  for (j=1; j<=currRing->N; j++)
207  {
208  if (e[j]==1)
209  {
210  s[j + (sh*lV)] = e[j]; /* actually 1 */
211  }
212  }
213  poly m = pOne();
214  pSetExpV(m,s);
215  /* pSetm(m); */ /* done in the pSetExpV */
216  /* think on the component */
217  pSetCoeff0(m,c);
218  freeT(e, currRing->N);
219  freeT(s, currRing->N);
220  return(m);
221 }
222 
223 int pLastVblock(poly p, int lV)
224 {
225  /* returns the number of maximal block */
226  /* appearing among the monomials of p */
227  /* the 0th block is the 1st one */
228  poly q = p; //p_Copy(p,currRing); /* need it ? */
229  int ans = 0;
230  int ansnew = 0;
231  while (q!=NULL)
232  {
233  ansnew = pmLastVblock(q,lV);
234  ans = si_max(ans,ansnew);
235  pIter(q);
236  }
237  /* do not need to delete q */
238  return(ans);
239 }
240 
241 int pmLastVblock(poly p, int lV)
242 {
243  /* for a monomial p, returns the number of the last block */
244  /* where a nonzero exponent is sitting */
245  if (pIsConstantPoly(p))
246  {
247  return(int(0));
248  }
249  int *e=(int *)omAlloc0((currRing->N+1)*sizeof(int));
250  pGetExpV(p,e);
251  int j,b;
252  j = currRing->N;
253  while ( (!e[j]) && (j>=1) ) j--;
254  freeT(e, currRing->N);
255  if (j==0)
256  {
257 #ifdef PDEBUG
258  PrintS("pmLastVblock: unexpected zero exponent vector\n");
259 #endif
260  return(j);
261  }
262  b = (int)(j/lV) + 1; /* the number of the block, >=1 */
263  return (b);
264 }
265 
266 int p_LastVblockT(poly p, int lV, kStrategy strat, const ring r)
267 {
268  /* returns the number of maximal block */
269  /* appearing among the monomials of p */
270  /* the 0th block is the 1st one */
271 
272  /* p is like TObject: lm in currRing = r, tail in tailRing */
275 
276  int ans = p_mLastVblock(p, lV, r); // Block of LM
277  poly q = pNext(p);
278  int ansnew = 0;
279  while (q != NULL)
280  {
281  ansnew = p_mLastVblock(q, lV, strat->tailRing);
282  ans = si_max(ans,ansnew);
283  pIter(q);
284  }
285  /* do not need to delete q */
286  return(ans);
287 }
288 
289 int p_LastVblock(poly p, int lV, const ring r)
290 {
291  /* returns the number of maximal block */
292  /* appearing among the monomials of p */
293  /* the 0th block is the 1st one */
294  poly q = p; //p_Copy(p,currRing); /* need it ? */
295  int ans = 0;
296  int ansnew = 0;
297  while (q!=NULL)
298  {
299  ansnew = p_mLastVblock(q, lV, r);
300  ans = si_max(ans,ansnew);
301  pIter(q);
302  }
303  /* do not need to delete q */
304  return(ans);
305 }
306 
307 int p_mLastVblock(poly p, int lV, const ring r)
308 {
309  /* for a monomial p, returns the number of the last block */
310  /* where a nonzero exponent is sitting */
311  if (p_LmIsConstant(p,r))
312  {
313  return(0);
314  }
315  int *e=(int *)omAlloc0((r->N+1)*sizeof(int));
316  p_GetExpV(p,e,r);
317  int j,b;
318  j = r->N;
319  while ( (!e[j]) && (j>=1) ) j--;
320  if (j==0)
321  {
322 #ifdef PDEBUG
323  PrintS("pmLastVblock: unexpected zero exponent vector\n");
324 #endif
325  return(j);
326  }
327  b = (int)((j+lV-1)/lV); /* the number of the block, >=1 */
328  freeT(e,r->N);
329  return (b);
330 }
331 
332 int pFirstVblock(poly p, int lV)
333 {
334  /* returns the number of maximal block */
335  /* appearing among the monomials of p */
336  /* the 0th block is the 1st one */
337  poly q = p; //p_Copy(p,currRing); /* need it ? */
338  int ans = 0;
339  int ansnew = 0;
340  while (q!=NULL)
341  {
342  ansnew = pmFirstVblock(q,lV);
343  ans = si_min(ans,ansnew);
344  pIter(q);
345  }
346  /* do not need to delete q */
347  return(ans);
348 }
349 
350 int pmFirstVblock(poly p, int lV)
351 {
352  if (pIsConstantPoly(p))
353  {
354  return(int(0));
355  }
356  /* for a monomial p, returns the number of the first block */
357  /* where a nonzero exponent is sitting */
358  int *e=(int *)omAlloc0((currRing->N+1)*sizeof(int));
359  pGetExpV(p,e);
360  int j,b;
361  j = 1;
362  while ( (!e[j]) && (j<=currRing->N-1) ) j++;
363  if (j==currRing->N + 1)
364  {
365 #ifdef PDEBUG
366  PrintS("pmFirstVblock: unexpected zero exponent vector\n");
367 #endif
368  return(j);
369  }
370  b = (int)(j/lV)+1; /* the number of the block, 1<= N <= currRing->N */
371  return (b);
372 }
373 
374  /* there should be two routines: */
375  /* 1. test place-squarefreeness: in homog this suffices: isInV */
376  /* 2. test the presence of a hole -> in the tail??? */
377 
378 int isInV(poly p, int lV)
379 {
380  /* investigate only the leading monomial of p in currRing */
381  if ( pIsConstant(p) ) return(1);
382  if (lV <= 0) return(0);
383  /* returns 1 iff p is in V */
384  /* that is in each block up to a certain one there is only one nonzero exponent */
385  /* lV = the length of V = the number of orig vars */
386  int *e = (int *)omAlloc0((currRing->N+1)*sizeof(int));
387  int b = (int)((currRing->N +lV-1)/lV); /* the number of blocks */
388  //int b = (int)(currRing->N)/lV;
389  int *B = (int *)omAlloc0((b+1)*sizeof(int)); /* the num of elements in a block */
390  pGetExpV(p,e);
391  int i,j;
392  for (j=1; j<=b; j++)
393  {
394  /* we go through all the vars */
395  /* by blocks in lV vars */
396  for (i=(j-1)*lV + 1; i<= j*lV; i++)
397  {
398  if (e[i]) B[j] = B[j]+1;
399  }
400  }
401  // j = b;
402  // while ( (!B[j]) && (j>=1)) j--;
403  for (j=b; j>=1; j--)
404  {
405  if (B[j]!=0) break;
406  }
407  /* do not need e anymore */
408  freeT(e, currRing->N);
409 
410  if (j==0) goto ret_true;
411 // {
412 // /* it is a zero exp vector, which is in V */
413 // freeT(B, b);
414 // return(1);
415 // }
416  /* now B[j] != 0 and we test place-squarefreeness */
417  for (; j>=1; j--)
418  {
419  if (B[j]!=1)
420  {
421  freeT(B, b);
422  return(0);
423  }
424  }
425  ret_true:
426  freeT(B, b);
427  return(1);
428 }
429 
430 int poly_isInV(poly p, int lV)
431 {
432  /* tests whether the whole polynomial p in in V */
433  poly q = p;
434  while (q!=NULL)
435  {
436  if ( !isInV(q,lV) )
437  {
438  return(0);
439  }
440  q = pNext(q);
441  }
442  return(1);
443 }
444 
445 int ideal_isInV(ideal I, int lV)
446 {
447  /* tests whether each polynomial of an ideal I lies in in V */
448  int i;
449  int s = IDELEMS(I)-1;
450  for(i = 0; i <= s; i++)
451  {
452  if ( !poly_isInV(I->m[i],lV) )
453  {
454  return(0);
455  }
456  }
457  return(1);
458 }
459 
460 
461 int itoInsert(poly p, int uptodeg, int lV, const ring r)
462 {
463  /* for poly in lmCR/tailTR presentation */
464  /* the below situation (commented out) might happen! */
465 // if (r == currRing)
466 // {
467 // "Current ring is not expected in toInsert";
468 // return(0);
469 // }
470  /* compute the number of insertions */
471  int i = p_mLastVblock(p, lV, currRing);
472  if (pNext(p) != NULL)
473  {
474  i = si_max(i, p_LastVblock(pNext(p), lV, r) );
475  }
476  // i = uptodeg - i +1;
477  i = uptodeg - i;
478  // p_wrp(p,currRing,r); Print("----i:%d",i); PrintLn();
479  return(i);
480 }
481 
482 poly p_ShrinkT(poly p, int lV, kStrategy strat, const ring r)
483 //poly p_Shrink(poly p, int uptodeg, int lV, kStrategy strat, const ring r)
484 {
485  /* p is like TObject: lm in currRing = r, tail in tailRing */
486  /* proc shrinks the poly p in ring r */
487  /* lV = the length of V = the number of orig vars */
488  /* check assumes/exceptions */
489  /* r->N is a multiple of lV */
490 
491  if (p==NULL) return(p);
492 
495 
496  poly q = NULL;
497  poly s = p_mShrink(p, lV, r); // lm in currRing
498  poly pp = pNext(p);
499 
500  while (pp != NULL)
501  {
502  // q = p_Add_q(q, p_mShrink(pp,uptodeg,lV,strat->tailRing),strat->tailRing);
503  q = p_Add_q(q, p_mShrink(pp,lV,strat->tailRing),strat->tailRing);
504  pIter(pp);
505  }
506  pNext(s) = q;
507  return(s);
508 }
509 
510 poly p_Shrink(poly p, int lV, const ring r)
511 {
512  /* proc shrinks the poly p in ring r */
513  /* lV = the length of V = the number of orig vars */
514  /* check assumes/exceptions */
515  /* r->N is a multiple of lV */
516 
517  if (p==NULL) return(p);
519  poly q = NULL;
520  poly pp = p;
521 
522  while (pp != NULL)
523  {
524  q = p_Add_q(q, p_mShrink(pp,lV,r),r);
525  pIter(pp);
526  }
527  return(q);
528 }
529 
530 poly p_mShrink(poly p, int lV, const ring r)
531 {
532  /* shrinks the monomial p in ring r */
533  /* lV = the length of V = the number of orig vars */
534 
535  /* check assumes/exceptions */
536  /* r->N is a multiple of lV */
537 
538  int *e = (int *)omAlloc0((r->N+1)*sizeof(int));
539  int b = (int)((r->N +lV-1)/lV); /* the number of blocks */
540  // int *B = (int *)omAlloc0((b+1)*sizeof(int)); /* the num of elements in a block */
541  int *S = (int *)omAlloc0((r->N+1)*sizeof(int)); /* the shrinked exponent */
542  p_GetExpV(p,e,r);
543  int i,j; int cnt = 1; //counter for blocks in S
544  for (j=1; j<=b; j++)
545  {
546  /* we go through all the vars */
547  /* by blocks in lV vars */
548  for (i=(j-1)*lV + 1; i<= j*lV; i++)
549  {
550  if (e[i]==1)
551  {
552  // B[j] = B[j]+1; // for control in V?
553  S[(cnt-1)*lV + (i - (j-1)*lV)] = e[i];
554  /* assuming we are in V, can interrupt here */
555  cnt++;
556  // break; //results in incomplete shrink!
557  i = j*lV; // manual break under assumption p is in V
558  }
559  }
560  }
561 #ifdef PDEBUG
562  // Print("p_mShrink: cnt = [%d], b = %d\n",cnt,b);
563 #endif
564  // cnt -1 <= b must hold!
565  // freeT(B, b);
566  poly s = p_One(r);
567  p_SetExpV(s,S,r);
568  freeT(e, r->N);
569  freeT(S, r->N);
570  /* p_Setm(s,r); // done by p_SetExpV */
571  p_SetComp(s,p_GetComp(p,r),r); // component is preserved
572  p_SetCoeff(s,p_GetCoeff(p,r),r); // coeff is preserved
573 #ifdef PDEBUG
574  // Print("p_mShrink: from "); p_wrp(p,r); Print(" to "); p_wrp(s,r); PrintLn();
575 #endif
576  return(s);
577 }
578 
579 /* shiftgb stuff */
580 
581 
582 /*2
583  *if the leading term of p
584  *divides the leading term of some T[i] it will be canceled
585  */
586 // static inline void clearSShift (poly p, unsigned long p_sev,int l, int* at, int* k,
587 // kStrategy strat)
588 // {
589 // assume(p_sev == pGetShortExpVector(p));
590 // if (!pLmShortDivisibleBy(p,p_sev, strat->T[*at].p, ~ strat->sevT[*at])) return;
591 // // if (l>=strat->lenS[*at]) return;
592 // if (TEST_OPT_PROT)
593 // PrintS("!");
594 // mflush();
595 // //pDelete(&strat->S[*at]);
596 // deleteInS((*at),strat);
597 // (*at)--;
598 // (*k)--;
599 // // assume(lenS_correct(strat));
600 // }
601 
602 /* remarks: cleanT : just deletion
603 enlargeT: just reallocation */
604 
605 #endif
int p_mLastVblock(poly p, int lV, const ring r)
Definition: shiftgb.cc:307
const CanonicalForm int s
Definition: facAbsFact.cc:55
int itoInsert(poly p, int uptodeg, int lV, const ring r)
Definition: shiftgb.cc:461
BOOLEAN p_LmCheckIsFromRing(poly p, ring r)
Definition: pDebug.cc:71
static int si_min(const int a, const int b)
Definition: auxiliary.h:167
poly pmLPshift(poly p, int sh, int uptodeg, int lV)
Definition: shiftgb.cc:178
Compatiblity layer for legacy polynomial operations (over currRing)
return P p
Definition: myNF.cc:203
poly p_ShrinkT(poly p, int lV, kStrategy strat, const ring r)
Definition: shiftgb.cc:482
int poly_isInV(poly p, int lV)
Definition: shiftgb.cc:430
int ideal_isInV(ideal I, int lV)
Definition: shiftgb.cc:445
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition: p_polys.h:236
#define p_GetComp(p, r)
Definition: monomials.h:72
static void p_GetExpV(poly p, int *ev, const ring r)
Definition: p_polys.h:1448
poly p_mShrink(poly p, int lV, const ring r)
Definition: shiftgb.cc:530
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
static number p_SetCoeff(poly p, number n, ring r)
Definition: p_polys.h:401
static void p_SetExpV(poly p, int *ev, const ring r)
Definition: p_polys.h:1456
poly pp
Definition: myNF.cc:296
static BOOLEAN p_LmIsConstant(const poly p, const ring r)
Definition: p_polys.h:954
poly p_LPshift(poly p, int sh, int uptodeg, int lV, const ring r)
Definition: shiftgb.cc:74
#define pIter(p)
Definition: monomials.h:44
poly p_Shrink(poly p, int lV, const ring r)
Definition: shiftgb.cc:510
int p_LastVblockT(poly p, int lV, kStrategy strat, const ring r)
Definition: shiftgb.cc:266
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
const ring r
Definition: syzextra.cc:208
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:49
poly p_One(const ring r)
Definition: p_polys.cc:1318
int j
Definition: myNF.cc:70
#define assume(x)
Definition: mod2.h:405
#define pSetExpV(p, e)
Definition: polys.h:97
poly pLPshift(poly p, int sh, int uptodeg, int lV)
Definition: shiftgb.cc:155
int m
Definition: cfEzgcd.cc:119
#define pIsConstant(p)
like above, except that Comp might be != 0
Definition: polys.h:209
static int si_max(const int a, const int b)
Definition: auxiliary.h:166
int i
Definition: cfEzgcd.cc:123
void PrintS(const char *s)
Definition: reporter.cc:294
int isInV(poly p, int lV)
Definition: shiftgb.cc:378
#define pOne()
Definition: polys.h:286
#define freeT(A, v)
Definition: shiftgb.cc:39
#define IDELEMS(i)
Definition: simpleideals.h:24
int int kStrategy strat
Definition: myNF.cc:68
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:850
int pFirstVblock(poly p, int lV)
Definition: shiftgb.cc:332
int pLastVblock(poly p, int lV)
Definition: shiftgb.cc:223
poly p_LPshiftT(poly p, int sh, int uptodeg, int lV, kStrategy strat, const ring r)
Definition: shiftgb.cc:45
BOOLEAN p_CheckIsFromRing(poly p, ring r)
Definition: pDebug.cc:101
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of &#39;n&#39;
Definition: coeffs.h:452
ring tailRing
Definition: kutil.h:341
b *CanonicalForm B
Definition: facBivar.cc:51
#define pGetExpV(p, e)
Gets a copy of (resp. set) the exponent vector, where e is assumed to point to (r->N +1)*sizeof(long)...
Definition: polys.h:96
poly p_mLPshift(poly p, int sh, int uptodeg, int lV, const ring r)
Definition: shiftgb.cc:94
#define pNext(p)
Definition: monomials.h:43
#define pSetCoeff0(p, n)
Definition: monomials.h:67
#define p_GetCoeff(p, r)
Definition: monomials.h:57
#define pIsConstantPoly(p)
return TRUE if all monomials of p are constant
Definition: polys.h:217
#define p_SetCoeff0(p, n, r)
Definition: monomials.h:68
#define omCheckAddr(addr)
Definition: omAllocDecl.h:328
int p_LastVblock(poly p, int lV, const ring r)
Definition: shiftgb.cc:289
polyrec * poly
Definition: hilb.h:10
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:884
const poly b
Definition: syzextra.cc:213
int pmFirstVblock(poly p, int lV)
Definition: shiftgb.cc:350
int pmLastVblock(poly p, int lV)
Definition: shiftgb.cc:241
#define omAlloc0(size)
Definition: omAllocDecl.h:211