My Project  UNKNOWN_GIT_VERSION
Macros | Functions
mod_main.cc File Reference
#include "kernel/mod2.h"
#include "omalloc/omalloc.h"
#include "misc/intvec.h"
#include "misc/options.h"
#include "coeffs/coeffs.h"
#include "polys/PolyEnumerator.h"
#include "polys/monomials/p_polys.h"
#include "polys/monomials/ring.h"
#include "polys/simpleideals.h"
#include "kernel/GBEngine/kstd1.h"
#include "kernel/polys.h"
#include "kernel/GBEngine/syz.h"
#include "Singular/tok.h"
#include "Singular/ipid.h"
#include "Singular/lists.h"
#include "Singular/attrib.h"
#include "Singular/ipshell.h"
#include "singularxx_defs.h"
#include "syzextra.h"
#include "Singular/mod_lib.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

Go to the source code of this file.

Macros

#define ADD(C, D, E)   psModulFunctions->iiAddCproc((currPack->libname? currPack->libname: ""), (char*)C, D, E);
 

Functions

static BOOLEAN id_IsModule (ideal id, ring r)
 test whether this input has vectors among entries or no enties result must be FALSE for only 0-entries More...
 
static void NoReturn (leftv &res)
 
static BOOLEAN _ClearContent (leftv res, leftv h)
 wrapper around n_ClearContent More...
 
static BOOLEAN _ClearDenominators (leftv res, leftv h)
 wrapper around n_ClearDenominators More...
 
static int getOptionalInteger (const leftv &h, const int _n)
 try to get an optional (simple) integer argument out of h or return the default value More...
 
static number jjLONG2N (long d)
 
static void view (const intvec *v)
 
static BOOLEAN Tail (leftv res, leftv h)
 wrapper around p_Tail and id_Tail More...
 
static BOOLEAN leadcomp (leftv res, leftv h)
 Get leading component. More...
 
static BOOLEAN MakeInducedSchreyerOrdering (leftv res, leftv h)
 Same for Induced Schreyer ordering (ordering on components is defined by sign!) More...
 
static BOOLEAN GetInducedData (leftv res, leftv h)
 ? More...
 
static BOOLEAN SetInducedReferrence (leftv res, leftv h)
 Returns old SyzCompLimit, can set new limit. More...
 
static BOOLEAN idPrepare (leftv res, leftv h)
 Get raw syzygies (idPrepare) More...
 
int SI_MOD_INIT() syzextra (SModulFunctions *psModulFunctions)
 

Macro Definition Documentation

◆ ADD

#define ADD (   C,
  D,
  E 
)    psModulFunctions->iiAddCproc((currPack->libname? currPack->libname: ""), (char*)C, D, E);

Function Documentation

◆ _ClearContent()

static BOOLEAN _ClearContent ( leftv  res,
leftv  h 
)
static

wrapper around n_ClearContent

Definition at line 80 of file mod_main.cc.

81 {
82  NoReturn(res);
83 
84  const char *usage = "'ClearContent' needs a (non-zero!) poly or vector argument...";
85 
86  if( h == NULL )
87  {
88  WarnS(usage);
89  return TRUE;
90  }
91 
92  assume( h != NULL );
93 
94  if( !( h->Typ() == POLY_CMD || h->Typ() == VECTOR_CMD) )
95  {
96  WarnS(usage);
97  return TRUE;
98  }
99 
100  assume (h->Next() == NULL);
101 
102  poly ph = reinterpret_cast<poly>(h->Data());
103 
104  if( ph == NULL )
105  {
106  WarnS(usage);
107  return TRUE;
108  }
109 
110  const ring r = currRing;
111  assume( r != NULL ); assume( r->cf != NULL ); const coeffs C = r->cf;
112 
113  number n;
114 
115  // experimentall (recursive enumerator treatment) of alg. ext
116  CPolyCoeffsEnumerator itr(ph);
117  n_ClearContent(itr, n, C);
118 
119  res->data = n;
120  res->rtyp = NUMBER_CMD;
121 
122  return FALSE;
123 }

◆ _ClearDenominators()

static BOOLEAN _ClearDenominators ( leftv  res,
leftv  h 
)
static

wrapper around n_ClearDenominators

Definition at line 126 of file mod_main.cc.

127 {
128  NoReturn(res);
129 
130  const char *usage = "'ClearDenominators' needs a (non-zero!) poly or vector argument...";
131 
132  if( h == NULL )
133  {
134  WarnS(usage);
135  return TRUE;
136  }
137 
138  assume( h != NULL );
139 
140  if( !( h->Typ() == POLY_CMD || h->Typ() == VECTOR_CMD) )
141  {
142  WarnS(usage);
143  return TRUE;
144  }
145 
146  assume (h->Next() == NULL);
147 
148  poly ph = reinterpret_cast<poly>(h->Data());
149 
150  if( ph == NULL )
151  {
152  WarnS(usage);
153  return TRUE;
154  }
155 
156  const ring r = currRing;
157  assume( r != NULL ); assume( r->cf != NULL ); const coeffs C = r->cf;
158 
159  number n;
160 
161  // experimentall (recursive enumerator treatment) of alg. ext.
162  CPolyCoeffsEnumerator itr(ph);
163  n_ClearDenominators(itr, n, C);
164 
165  res->data = n;
166  res->rtyp = NUMBER_CMD;
167 
168  return FALSE;
169 }

◆ GetInducedData()

static BOOLEAN GetInducedData ( leftv  res,
leftv  h 
)
static

?

Definition at line 313 of file mod_main.cc.

314 {
315  const ring r = currRing;
316 
317  int p = 0; // which IS-block? p^th!
318 
319  if ((h!=NULL) && (h->Typ()==INT_CMD))
320  {
321  p = (int)((long)(h->Data())); h=h->next;
322  assume(p >= 0);
323  }
324 
325  const int pos = rGetISPos(p, r);
326 
327  if( /*(*/ -1 == pos /*)*/ )
328  {
329  WerrorS("`GetInducedData([int])` called on incompatible ring (not created by 'MakeInducedSchreyerOrdering'!)");
330  return TRUE;
331  }
332 
333 
334  const int iLimit = r->typ[pos].data.is.limit;
335  const ideal F = r->typ[pos].data.is.F;
336 
337  ideal FF = id_Copy(F, r);
338 
340  l->Init(2);
341 
342  l->m[0].rtyp = INT_CMD;
343  l->m[0].data = reinterpret_cast<void *>(iLimit);
344 
345 
346  // l->m[1].rtyp = MODUL_CMD;
347 
348  if( id_IsModule(FF, r) ) // ???
349  {
350  l->m[1].rtyp = MODUL_CMD;
351 
352  // Print("before: %d\n", FF->nrows);
353  // FF->nrows = id_RankFreeModule(FF, r); // ???
354  // Print("after: %d\n", FF->nrows);
355  }
356  else
357  l->m[1].rtyp = IDEAL_CMD;
358 
359  l->m[1].data = reinterpret_cast<void *>(FF);
360 
361  res->rtyp = LIST_CMD; // list of int/module
362  res->data = reinterpret_cast<void *>(l);
363 
364  return FALSE;
365 
366 }

◆ getOptionalInteger()

static int getOptionalInteger ( const leftv h,
const int  _n 
)
static

try to get an optional (simple) integer argument out of h or return the default value

Definition at line 174 of file mod_main.cc.

175 {
176  if( h!= NULL && h->Typ() == INT_CMD )
177  {
178  int n = (int)(long)(h->Data());
179 
180  if( n < 0 )
181  Warn("Negative (%d) optional integer argument", n);
182 
183  return (n);
184  }
185 
186  return (_n);
187 }

◆ id_IsModule()

static BOOLEAN id_IsModule ( ideal  id,
ring  r 
)
static

test whether this input has vectors among entries or no enties result must be FALSE for only 0-entries

Definition at line 50 of file mod_main.cc.

51 {
52  id_Test(id, r);
53 
54  if( id->rank != 1 ) return TRUE;
55 
56  if (rRing_has_Comp(r))
57  {
58  const int l = IDELEMS(id);
59 
60  for (int j=0; j<l; j++)
61  if (id->m[j] != NULL && p_GetComp(id->m[j], r) > 0)
62  return TRUE;
63 
64  return FALSE; // rank: 1, only zero or no entries? can be an ideal OR module... BUT in the use-case should better be an ideal!
65  }
66 
67  return FALSE;
68 }

◆ idPrepare()

static BOOLEAN idPrepare ( leftv  res,
leftv  h 
)
static

Get raw syzygies (idPrepare)

Definition at line 417 of file mod_main.cc.

418 {
419  // extern int rGetISPos(const int p, const ring r);
420 
421  const ring r = currRing;
422 
423  const bool isSyz = rIsSyzIndexRing(r);
424  const int posIS = rGetISPos(0, r);
425 
426 
427  if ( !( (h!=NULL) && (h->Typ()==MODUL_CMD) && (h->Data() != NULL) ) )
428  {
429  WerrorS("`idPrepare(<module>)` expected");
430  return TRUE;
431  }
432 
433  const ideal I = reinterpret_cast<ideal>(h->Data());
434 
435  assume( I != NULL );
436  idTest(I);
437 
438  int iComp = -1;
439 
440  h=h->next;
441  if ( (h!=NULL) && (h->Typ()==INT_CMD) )
442  {
443  iComp = (int)((long)(h->Data()));
444  }
445  else
446  {
447  if( (!isSyz) && (-1 == posIS) )
448  {
449  WerrorS("`idPrepare(<...>)` called on incompatible ring (not created by 'MakeSyzCompOrdering' or 'MakeInducedSchreyerOrdering'!)");
450  return TRUE;
451  }
452 
453  if( isSyz )
454  iComp = rGetCurrSyzLimit(r);
455  else
456  iComp = id_RankFreeModule(r->typ[posIS].data.is.F, r); // ;
457  }
458 
459  assume(iComp >= 0);
460 
461 
462  intvec* w = reinterpret_cast<intvec *>(atGet(h, "isHomog", INTVEC_CMD));
463  tHomog hom = testHomog;
464 
465  // int add_row_shift = 0;
466  //
467  if (w!=NULL)
468  {
469  w = ivCopy(w);
470  // add_row_shift = ww->min_in();
471  //
472  // (*ww) -= add_row_shift;
473  //
474  // if (idTestHomModule(I, currRing->qideal, ww))
475  // {
476  hom = isHomog;
477  // w = ww;
478  // }
479  // else
480  // {
481  // //WarnS("wrong weights");
482  // delete ww;
483  // w = NULL;
484  // hom=testHomog;
485  // }
486  }
487 
488 
489  // computes syzygies of h1,
490  // works always in a ring with ringorder_s
491  // NOTE: rSetSyzComp(syzcomp) should better be called beforehand
492  // ideal idPrepare (ideal h1, tHomog hom, int syzcomp, intvec **w);
493 
494  ideal J = // idPrepare( I, hom, iComp, &w);
495  kStd(I, currRing->qideal, hom, &w, NULL, iComp);
496 
497  idTest(J);
498 
499  if (w!=NULL)
500  atSet(res, omStrDup("isHomog"), w, INTVEC_CMD);
501  // if (w!=NULL) delete w;
502 
503  res->rtyp = MODUL_CMD;
504  res->data = reinterpret_cast<void *>(J);
505  return FALSE;
506 }

◆ jjLONG2N()

static number jjLONG2N ( long  d)
inlinestatic

Definition at line 189 of file mod_main.cc.

190 {
191  return n_Init(d, coeffs_BIGINT);
192 }

◆ leadcomp()

static BOOLEAN leadcomp ( leftv  res,
leftv  h 
)
static

Get leading component.

Definition at line 256 of file mod_main.cc.

257 {
258  if ((h!=NULL) && (h->Typ()==VECTOR_CMD || h->Typ()==POLY_CMD))
259  {
260  const ring r = currRing;
261 
262  const poly p = (poly)(h->Data());
263 
264  if (p != NULL )
265  {
266  assume( p != NULL );
267  p_LmTest(p, r);
268 
269  const unsigned long iComp = p_GetComp(p, r);
270 
271  // assume( iComp > 0 ); // p is a vector
272 
273  res->data = reinterpret_cast<void *>(jjLONG2N(iComp));
274  }
275  else
276  res->data = reinterpret_cast<void *>(jjLONG2N(0));
277 
278 
279  res->rtyp = BIGINT_CMD;
280  return FALSE;
281  }
282 
283  WerrorS("`leadcomp(<poly/vector>)` expected");
284  return TRUE;
285 }

◆ MakeInducedSchreyerOrdering()

static BOOLEAN MakeInducedSchreyerOrdering ( leftv  res,
leftv  h 
)
static

Same for Induced Schreyer ordering (ordering on components is defined by sign!)

Definition at line 288 of file mod_main.cc.

289 {
290  int sign = 1;
291  if ((h!=NULL) && (h->Typ()==INT_CMD))
292  {
293  const int s = (int)((long)(h->Data()));
294 
295  if( s != -1 && s != 1 )
296  {
297  WerrorS("`MakeInducedSchreyerOrdering(<int>)` called with wrong integer argument (must be +-1)!");
298  return TRUE;
299  }
300 
301  sign = s;
302  }
303 
304  assume( sign == 1 || sign == -1 );
305  res->data = reinterpret_cast<void *>(rAssure_InducedSchreyerOrdering(currRing, TRUE, sign));
306  res->rtyp = RING_CMD; // return new ring!
307  // QRING_CMD?
308  return FALSE;
309 }

◆ NoReturn()

static void NoReturn ( leftv res)
inlinestatic

Definition at line 73 of file mod_main.cc.

74 {
75  res->rtyp = NONE;
76  res->data = NULL;
77 }

◆ SetInducedReferrence()

static BOOLEAN SetInducedReferrence ( leftv  res,
leftv  h 
)
static

Returns old SyzCompLimit, can set new limit.

Definition at line 369 of file mod_main.cc.

370 {
371  res->Init();
372  NoReturn(res);
373 
374  const ring r = currRing;
375 
376  if( !( (h!=NULL) && ( (h->Typ()==IDEAL_CMD) || (h->Typ()==MODUL_CMD))) )
377  {
378  WerrorS("`SetInducedReferrence(<ideal/module>, [int[, int]])` expected");
379  return TRUE;
380  }
381 
382  const ideal F = (ideal)h->Data(); ; // No copy!
383  h=h->next;
384 
385  int rank = 0;
386 
387  if ((h!=NULL) && (h->Typ()==INT_CMD))
388  {
389  rank = (int)((long)(h->Data())); h=h->next;
390  assume(rank >= 0);
391  } else
392  rank = id_RankFreeModule(F, r); // Starting syz-comp (1st: i+1)
393 
394  int p = 0; // which IS-block? p^th!
395 
396  if ((h!=NULL) && (h->Typ()==INT_CMD))
397  {
398  p = (int)((long)(h->Data())); h=h->next;
399  assume(p >= 0);
400  }
401 
402  const int posIS = rGetISPos(p, r);
403 
404  if( /*(*/ -1 == posIS /*)*/ )
405  {
406  WerrorS("`SetInducedReferrence(<ideal/module>, [int[, int]])` called on incompatible ring (not created by 'MakeInducedSchreyerOrdering'!)");
407  return TRUE;
408  }
409 
410  // F & componentWeights belong to that ordering block of currRing now:
411  rSetISReference(r, F, rank, p); // F will be copied!
412  return FALSE;
413 }

◆ syzextra()

int SI_MOD_INIT() syzextra ( SModulFunctions psModulFunctions)

Definition at line 508 of file mod_main.cc.

509 {
510 
511 #define ADD(C,D,E) \
512  psModulFunctions->iiAddCproc((currPack->libname? currPack->libname: ""), (char*)C, D, E);
513 
514 
515  ADD("ClearContent", FALSE, _ClearContent);
516  ADD("ClearDenominators", FALSE, _ClearDenominators);
517 
518  ADD("leadcomp", FALSE, leadcomp);
519 
520  ADD("SetInducedReferrence", FALSE, SetInducedReferrence);
521  ADD("GetInducedData", FALSE, GetInducedData);
522  ADD("MakeInducedSchreyerOrdering", FALSE, MakeInducedSchreyerOrdering);
523 
524  ADD("idPrepare", FALSE, idPrepare);
525 
526  ADD("Tail", FALSE, Tail);
527 
528 #undef ADD
529  return MAX_TOK;
530 }

◆ Tail()

static BOOLEAN Tail ( leftv  res,
leftv  h 
)
static

wrapper around p_Tail and id_Tail

Definition at line 217 of file mod_main.cc.

218 {
219  NoReturn(res);
220 
221  if( h == NULL )
222  {
223  WarnS("Tail needs a poly/vector/ideal/module argument...");
224  return TRUE;
225  }
226 
227  assume( h != NULL );
228 
229  const ring r = currRing;
230 
231  if( h->Typ() == POLY_CMD || h->Typ() == VECTOR_CMD)
232  {
233  res->data = p_Tail( (const poly)h->Data(), r );
234  res->rtyp = h->Typ();
235 
236  h = h->Next(); assume (h == NULL);
237 
238  return FALSE;
239  }
240 
241  if( h->Typ() == IDEAL_CMD || h->Typ() == MODUL_CMD)
242  {
243  res->data = id_Tail( (const ideal)h->Data(), r );
244  res->rtyp = h->Typ();
245 
246  h = h->Next(); assume (h == NULL);
247 
248  return FALSE;
249  }
250 
251  WarnS("Tail needs a single poly/vector/ideal/module argument...");
252  return TRUE;
253 }

◆ view()

static void view ( const intvec v)
inlinestatic

Definition at line 194 of file mod_main.cc.

195 {
196 #ifndef SING_NDEBUG
197  v->view();
198 #else
199  // This code duplication is only due to Hannes's #ifndef SING_NDEBUG!
200  Print ("intvec: {rows: %d, cols: %d, length: %d, Values: \n", v->rows(), v->cols(), v->length());
201 
202  for (int i = 0; i < v->rows(); i++)
203  {
204  Print ("Row[%3d]:", i);
205  for (int j = 0; j < v->cols(); j++)
206  Print (" %5d", (*v)[j + i * (v->cols())] );
207  PrintLn ();
208  }
209  PrintS ("}\n");
210 #endif
211 
212 }
NoReturn
static void NoReturn(leftv &res)
Definition: mod_main.cc:73
FALSE
#define FALSE
Definition: auxiliary.h:94
SetInducedReferrence
static BOOLEAN SetInducedReferrence(leftv res, leftv h)
Returns old SyzCompLimit, can set new limit.
Definition: mod_main.cc:369
MakeInducedSchreyerOrdering
static BOOLEAN MakeInducedSchreyerOrdering(leftv res, leftv h)
Same for Induced Schreyer ordering (ordering on components is defined by sign!)
Definition: mod_main.cc:288
p_GetComp
#define p_GetComp(p, r)
Definition: monomials.h:65
j
int j
Definition: facHensel.cc:105
leadcomp
static BOOLEAN leadcomp(leftv res, leftv h)
Get leading component.
Definition: mod_main.cc:256
NUMBER_CMD
@ NUMBER_CMD
Definition: grammar.cc:288
BIGINT_CMD
@ BIGINT_CMD
Definition: tok.h:38
LIST_CMD
@ LIST_CMD
Definition: tok.h:118
MODUL_CMD
@ MODUL_CMD
Definition: grammar.cc:287
NONE
#define NONE
Definition: tok.h:219
MAX_TOK
@ MAX_TOK
Definition: tok.h:216
omStrDup
#define omStrDup(s)
Definition: omAllocDecl.h:263
sign
static int sign(int x)
Definition: ring.cc:3346
omAllocBin
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
idTest
#define idTest(id)
Definition: ideals.h:47
testHomog
@ testHomog
Definition: structs.h:41
idPrepare
static BOOLEAN idPrepare(leftv res, leftv h)
Get raw syzygies (idPrepare)
Definition: mod_main.cc:417
w
const CanonicalForm & w
Definition: facAbsFact.cc:55
RING_CMD
@ RING_CMD
Definition: grammar.cc:281
slists_bin
omBin slists_bin
Definition: lists.cc:23
rSetISReference
BOOLEAN rSetISReference(const ring r, const ideal F, const int i, const int p)
Changes r by setting induced ordering parameters: limit and reference leading terms F belong to r,...
Definition: ring.cc:4937
Tail
static BOOLEAN Tail(leftv res, leftv h)
wrapper around p_Tail and id_Tail
Definition: mod_main.cc:217
CPolyCoeffsEnumerator
Definition: PolyEnumerator.h:130
tHomog
tHomog
Definition: structs.h:38
rGetCurrSyzLimit
static int rGetCurrSyzLimit(const ring r)
Definition: ring.h:713
currRing
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
TRUE
#define TRUE
Definition: auxiliary.h:98
i
int i
Definition: cfEzgcd.cc:125
ivCopy
intvec * ivCopy(const intvec *o)
Definition: intvec.h:133
res
CanonicalForm res
Definition: facAbsFact.cc:64
INT_CMD
@ INT_CMD
Definition: tok.h:96
id_RankFreeModule
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
Definition: simpleideals.cc:782
PrintS
void PrintS(const char *s)
Definition: reporter.cc:284
GetInducedData
static BOOLEAN GetInducedData(leftv res, leftv h)
?
Definition: mod_main.cc:313
id_Tail
ideal id_Tail(const ideal id, const ring r)
return the tail of a given ideal or module returns NULL if input is NULL, otherwise the result is a n...
Definition: syzextra.cc:50
p_Tail
poly p_Tail(const poly p, const ring r)
return the tail of a given polynomial or vector returns NULL if input is NULL, otherwise the result i...
Definition: syzextra.cc:42
IDEAL_CMD
@ IDEAL_CMD
Definition: grammar.cc:284
h
static Poly * h
Definition: janet.cc:972
coeffs
atSet
void atSet(idhdl root, char *name, void *data, int typ)
Definition: attrib.cc:152
intvec
Definition: intvec.h:21
isHomog
@ isHomog
Definition: structs.h:40
jjLONG2N
static number jjLONG2N(long d)
Definition: mod_main.cc:189
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:538
VECTOR_CMD
@ VECTOR_CMD
Definition: grammar.cc:292
rAssure_InducedSchreyerOrdering
ring rAssure_InducedSchreyerOrdering(const ring r, BOOLEAN complete, int sgn)
Definition: ring.cc:4769
ADD
#define ADD(C, D, E)
p_LmTest
#define p_LmTest(p, r)
Definition: p_polys.h:165
slists
Definition: lists.h:23
INTVEC_CMD
@ INTVEC_CMD
Definition: tok.h:101
_ClearDenominators
static BOOLEAN _ClearDenominators(leftv res, leftv h)
wrapper around n_ClearDenominators
Definition: mod_main.cc:126
coeffs_BIGINT
coeffs coeffs_BIGINT
Definition: ipid.cc:52
id_IsModule
static BOOLEAN id_IsModule(ideal id, ring r)
test whether this input has vectors among entries or no enties result must be FALSE for only 0-entrie...
Definition: mod_main.cc:50
_ClearContent
static BOOLEAN _ClearContent(leftv res, leftv h)
wrapper around n_ClearContent
Definition: mod_main.cc:80
n_ClearContent
static FORCE_INLINE void n_ClearContent(ICoeffsEnumerator &numberCollectionEnumerator, number &c, const coeffs r)
Computes the content and (inplace) divides it out on a collection of numbers number c is the content ...
Definition: coeffs.h:950
n_ClearDenominators
static FORCE_INLINE void n_ClearDenominators(ICoeffsEnumerator &numberCollectionEnumerator, number &d, const coeffs r)
(inplace) Clears denominators on a collection of numbers number d is the LCM of all the coefficient d...
Definition: coeffs.h:957
rRing_has_Comp
#define rRing_has_Comp(r)
Definition: monomials.h:267
Print
#define Print
Definition: emacs.cc:80
atGet
void * atGet(idhdl root, const char *name, int t, void *defaultReturnValue)
Definition: attrib.cc:131
WerrorS
void WerrorS(const char *s)
Definition: feFopen.cc:24
WarnS
#define WarnS
Definition: emacs.cc:78
assume
#define assume(x)
Definition: mod2.h:390
NULL
#define NULL
Definition: omList.c:10
lists
slists * lists
Definition: mpr_numeric.h:146
l
int l
Definition: cfEzgcd.cc:93
Warn
#define Warn
Definition: emacs.cc:77
v
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
p
int p
Definition: cfModGcd.cc:4019
s
const CanonicalForm int s
Definition: facAbsFact.cc:55
POLY_CMD
@ POLY_CMD
Definition: grammar.cc:289
rIsSyzIndexRing
static BOOLEAN rIsSyzIndexRing(const ring r)
Definition: ring.h:710
IDELEMS
#define IDELEMS(i)
Definition: simpleideals.h:26
kStd
ideal kStd(ideal F, ideal Q, tHomog h, intvec **w, intvec *hilb, int syzComp, int newIdeal, intvec *vw, s_poly_proc_t sp)
Definition: kstd1.cc:2087
id_Copy
ideal id_Copy(ideal h1, const ring r)
copy an ideal
Definition: simpleideals.cc:404
PrintLn
void PrintLn()
Definition: reporter.cc:310
id_Test
#define id_Test(A, lR)
Definition: simpleideals.h:80
rGetISPos
int rGetISPos(const int p, const ring r)
Finds p^th IS ordering, and returns its position in r->typ[] returns -1 if something went wrong!...
Definition: ring.cc:4905