My Project
Functions
ringgb.h File Reference
#include "kernel/polys.h"

Go to the source code of this file.

Functions

poly ringNF (poly f, ideal G, ring r)
 
poly plain_spoly (poly f, poly g)
 
int testGB (ideal I, ideal GI)
 
poly reduce_poly_fct (poly p, ring r)
 
poly ringRedNF (poly f, ideal G, ring r)
 

Function Documentation

◆ plain_spoly()

poly plain_spoly ( poly  f,
poly  g 
)

Definition at line 168 of file ringgb.cc.

169 {
170  number cf = nCopy(pGetCoeff(f)), cg = nCopy(pGetCoeff(g));
171  (void)ksCheckCoeff(&cf, &cg, currRing->cf); // gcd and zero divisors
172  poly fm, gm;
173  k_GetLeadTerms(f, g, currRing, fm, gm, currRing);
174  pSetCoeff0(fm, cg);
175  pSetCoeff0(gm, cf); // and now, m1 * LT(p1) == m2 * LT(p2)
176  poly sp = pSub(ppMult_mm(f, fm), ppMult_mm(g, gm));
177  pDelete(&fm);
178  pDelete(&gm);
179  return(sp);
180 }
g
Definition: cfModGcd.cc:4090
CanonicalForm cf
Definition: cfModGcd.cc:4083
CanonicalForm cg
Definition: cfModGcd.cc:4083
FILE * f
Definition: checklibs.c:9
KINLINE BOOLEAN k_GetLeadTerms(const poly p1, const poly p2, const ring p_r, poly &m1, poly &m2, const ring m_r)
Definition: kInline.h:1018
int ksCheckCoeff(number *a, number *b, const coeffs r)
Definition: kbuckets.cc:1504
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
Definition: monomials.h:44
#define pSetCoeff0(p, n)
Definition: monomials.h:59
#define nCopy(n)
Definition: numbers.h:15
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
#define pDelete(p_ptr)
Definition: polys.h:186
#define ppMult_mm(p, m)
Definition: polys.h:201
#define pSub(a, b)
Definition: polys.h:287

◆ reduce_poly_fct()

poly reduce_poly_fct ( poly  p,
ring  r 
)

Definition at line 29 of file ringgb.cc.

30 {
31  return kFindZeroPoly(p, r, r);
32 }
int p
Definition: cfModGcd.cc:4078
poly kFindZeroPoly(poly input_p, ring leadRing, ring tailRing)
Definition: kstd2.cc:569

◆ ringNF()

poly ringNF ( poly  f,
ideal  G,
ring  r 
)

Definition at line 201 of file ringgb.cc.

202 {
203  // If f = 0, then normal form is also 0
204  if (f == NULL) { return NULL; }
205  poly tmp = NULL;
206  poly h = pCopy(f);
207  int i = findRingSolver(h, G, r);
208  int c = 1;
209  while (h != NULL && i >= 0) {
210 // Print("%d-step NF - h:", c);
211 // wrp(h);
212 // PrintS(" ");
213 // PrintS("G->m[i]:");
214 // wrp(G->m[i]);
215 // PrintLn();
216  tmp = h;
217  h = plain_spoly(h, G->m[i]);
218  pDelete(&tmp);
219 // PrintS("=> h=");
220 // wrp(h);
221 // PrintLn();
222  i = findRingSolver(h, G, r);
223  c++;
224  }
225  return h;
226 }
int i
Definition: cfEzgcd.cc:132
STATIC_VAR TreeM * G
Definition: janet.cc:31
STATIC_VAR Poly * h
Definition: janet.cc:971
#define NULL
Definition: omList.c:12
#define pCopy(p)
return a copy of the poly
Definition: polys.h:185
int findRingSolver(poly rside, ideal G, ring r)
Definition: ringgb.cc:152
poly plain_spoly(poly f, poly g)
Definition: ringgb.cc:168

◆ ringRedNF()

poly ringRedNF ( poly  f,
ideal  G,
ring  r 
)

Definition at line 117 of file ringgb.cc.

118 {
119  // If f = 0, then normal form is also 0
120  if (f == NULL) { return NULL; }
121  poly h = NULL;
122  poly g = pCopy(f);
123  int c = 0;
124  while (g != NULL)
125  {
126  Print("%d-step RedNF - g=", c);
127  wrp(g);
128  PrintS(" | h=");
129  wrp(h);
130  PrintLn();
131  g = ringNF(g, G, r);
132  if (g != NULL) {
133  h = pAdd(h, pHead(g));
134  pLmDelete(&g);
135  }
136  c++;
137  }
138  return h;
139 }
#define Print
Definition: emacs.cc:80
#define pAdd(p, q)
Definition: polys.h:203
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL
Definition: polys.h:67
#define pLmDelete(p)
assume p != NULL, deletes Lm(p)->coef and Lm(p)
Definition: polys.h:76
void wrp(poly p)
Definition: polys.h:310
void PrintS(const char *s)
Definition: reporter.cc:284
void PrintLn()
Definition: reporter.cc:310
poly ringNF(poly f, ideal G, ring r)
Definition: ringgb.cc:201

◆ testGB()

int testGB ( ideal  I,
ideal  GI 
)

Definition at line 228 of file ringgb.cc.

228  {
229  poly f, g, h, nf;
230  int i = 0;
231  int j = 0;
232  PrintS("I included?");
233  for (i = 0; i < IDELEMS(I); i++) {
234  if (ringNF(I->m[i], GI, currRing) != NULL) {
235  PrintS("Not reduced to zero from I: ");
236  wrp(I->m[i]);
237  PrintS(" --> ");
238  wrp(ringNF(I->m[i], GI, currRing));
239  PrintLn();
240  return(0);
241  }
242  PrintS("-");
243  }
244  PrintS(" Yes!\nspoly --> 0?");
245  for (i = 0; i < IDELEMS(GI); i++)
246  {
247  for (j = i + 1; j < IDELEMS(GI); j++)
248  {
249  f = pCopy(GI->m[i]);
250  g = pCopy(GI->m[j]);
251  h = plain_spoly(f, g);
252  nf = ringNF(h, GI, currRing);
253  if (nf != NULL)
254  {
255  PrintS("spoly(");
256  wrp(GI->m[i]);
257  PrintS(", ");
258  wrp(GI->m[j]);
259  PrintS(") = ");
260  wrp(h);
261  PrintS(" --> ");
262  wrp(nf);
263  PrintLn();
264  return(0);
265  }
266  pDelete(&f);
267  pDelete(&g);
268  pDelete(&h);
269  pDelete(&nf);
270  PrintS("-");
271  }
272  }
273  if (!(rField_is_Domain(currRing)))
274  {
275  PrintS(" Yes!\nzero-spoly --> 0?");
276  for (i = 0; i < IDELEMS(GI); i++)
277  {
278  f = plain_zero_spoly(GI->m[i]);
279  nf = ringNF(f, GI, currRing);
280  if (nf != NULL) {
281  PrintS("spoly(");
282  wrp(GI->m[i]);
283  PrintS(", ");
284  wrp(0);
285  PrintS(") = ");
286  wrp(h);
287  PrintS(" --> ");
288  wrp(nf);
289  PrintLn();
290  return(0);
291  }
292  pDelete(&f);
293  pDelete(&nf);
294  PrintS("-");
295  }
296  }
297  PrintS(" Yes!");
298  PrintLn();
299  return(1);
300 }
int j
Definition: facHensel.cc:110
static BOOLEAN rField_is_Domain(const ring r)
Definition: ring.h:487
poly plain_zero_spoly(poly h)
Definition: ringgb.cc:185
#define IDELEMS(i)
Definition: simpleideals.h:23
Definition: gnumpfl.cc:25