My Project  UNKNOWN_GIT_VERSION
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 169 of file ringgb.cc.

170 {
171  number cf = nCopy(pGetCoeff(f)), cg = nCopy(pGetCoeff(g));
172  (void)ksCheckCoeff(&cf, &cg, currRing->cf); // gcd and zero divisors
173  poly fm, gm;
174  k_GetLeadTerms(f, g, currRing, fm, gm, currRing);
175  pSetCoeff0(fm, cg);
176  pSetCoeff0(gm, cf); // and now, m1 * LT(p1) == m2 * LT(p2)
177  poly sp = pSub(ppMult_mm(f, fm), ppMult_mm(g, gm));
178  pDelete(&fm);
179  pDelete(&gm);
180  return(sp);
181 }

◆ reduce_poly_fct()

poly reduce_poly_fct ( poly  p,
ring  r 
)

Definition at line 30 of file ringgb.cc.

31 {
32  return kFindZeroPoly(p, r, r);
33 }

◆ ringNF()

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

Definition at line 200 of file ringgb.cc.

201 {
202  // If f = 0, then normal form is also 0
203  if (f == NULL) { return NULL; }
204  poly tmp = NULL;
205  poly h = pCopy(f);
206  int i = findRingSolver(h, G, r);
207  int c = 1;
208  while (h != NULL && i >= 0) {
209 // Print("%d-step NF - h:", c);
210 // wrp(h);
211 // PrintS(" ");
212 // PrintS("G->m[i]:");
213 // wrp(G->m[i]);
214 // PrintLn();
215  tmp = h;
216  h = plain_spoly(h, G->m[i]);
217  pDelete(&tmp);
218 // PrintS("=> h=");
219 // wrp(h);
220 // PrintLn();
221  i = findRingSolver(h, G, r);
222  c++;
223  }
224  return h;
225 }

◆ ringRedNF()

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

Definition at line 118 of file ringgb.cc.

119 {
120  // If f = 0, then normal form is also 0
121  if (f == NULL) { return NULL; }
122  poly h = NULL;
123  poly g = pCopy(f);
124  int c = 0;
125  while (g != NULL)
126  {
127  Print("%d-step RedNF - g=", c);
128  wrp(g);
129  PrintS(" | h=");
130  wrp(h);
131  PrintLn();
132  g = ringNF(g, G, r);
133  if (g != NULL) {
134  h = pAdd(h, pHead(g));
135  pLmDelete(&g);
136  }
137  c++;
138  }
139  return h;
140 }

◆ testGB()

int testGB ( ideal  I,
ideal  GI 
)

Definition at line 227 of file ringgb.cc.

227  {
228  poly f, g, h, nf;
229  int i = 0;
230  int j = 0;
231  PrintS("I included?");
232  for (i = 0; i < IDELEMS(I); i++) {
233  if (ringNF(I->m[i], GI, currRing) != NULL) {
234  PrintS("Not reduced to zero from I: ");
235  wrp(I->m[i]);
236  PrintS(" --> ");
237  wrp(ringNF(I->m[i], GI, currRing));
238  PrintLn();
239  return(0);
240  }
241  PrintS("-");
242  }
243  PrintS(" Yes!\nspoly --> 0?");
244  for (i = 0; i < IDELEMS(GI); i++)
245  {
246  for (j = i + 1; j < IDELEMS(GI); j++)
247  {
248  f = pCopy(GI->m[i]);
249  g = pCopy(GI->m[j]);
250  h = plain_spoly(f, g);
251  nf = ringNF(h, GI, currRing);
252  if (nf != NULL)
253  {
254  PrintS("spoly(");
255  wrp(GI->m[i]);
256  PrintS(", ");
257  wrp(GI->m[j]);
258  PrintS(") = ");
259  wrp(h);
260  PrintS(" --> ");
261  wrp(nf);
262  PrintLn();
263  return(0);
264  }
265  pDelete(&f);
266  pDelete(&g);
267  pDelete(&h);
268  pDelete(&nf);
269  PrintS("-");
270  }
271  }
272  if (!(rField_is_Domain(currRing)))
273  {
274  PrintS(" Yes!\nzero-spoly --> 0?");
275  for (i = 0; i < IDELEMS(GI); i++)
276  {
277  f = plain_zero_spoly(GI->m[i]);
278  nf = ringNF(f, GI, currRing);
279  if (nf != NULL) {
280  PrintS("spoly(");
281  wrp(GI->m[i]);
282  PrintS(", ");
283  wrp(0);
284  PrintS(") = ");
285  wrp(h);
286  PrintS(" --> ");
287  wrp(nf);
288  PrintLn();
289  return(0);
290  }
291  pDelete(&f);
292  pDelete(&nf);
293  PrintS("-");
294  }
295  }
296  PrintS(" Yes!");
297  PrintLn();
298  return(1);
299 }
ksCheckCoeff
int ksCheckCoeff(number *a, number *b)
kFindZeroPoly
poly kFindZeroPoly(poly input_p, ring leadRing, ring tailRing)
Definition: kstd2.cc:324
j
int j
Definition: facHensel.cc:105
f
FILE * f
Definition: checklibs.c:9
ppMult_mm
#define ppMult_mm(p, m)
Definition: polys.h:196
rField_is_Domain
static BOOLEAN rField_is_Domain(const ring r)
Definition: ring.h:478
cf
CanonicalForm cf
Definition: cfModGcd.cc:4024
g
g
Definition: cfModGcd.cc:4031
findRingSolver
int findRingSolver(poly rside, ideal G, ring r)
Definition: ringgb.cc:153
pDelete
#define pDelete(p_ptr)
Definition: polys.h:181
nf
Definition: gnumpfl.cc:28
currRing
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
i
int i
Definition: cfEzgcd.cc:125
PrintS
void PrintS(const char *s)
Definition: reporter.cc:284
h
static Poly * h
Definition: janet.cc:972
k_GetLeadTerms
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:931
cg
CanonicalForm cg
Definition: cfModGcd.cc:4024
pAdd
#define pAdd(p, q)
Definition: polys.h:198
plain_spoly
poly plain_spoly(poly f, poly g)
Definition: ringgb.cc:169
Print
#define Print
Definition: emacs.cc:80
pSetCoeff0
#define pSetCoeff0(p, n)
Definition: monomials.h:60
NULL
#define NULL
Definition: omList.c:10
pLmDelete
#define pLmDelete(p)
assume p != NULL, deletes Lm(p)->coef and Lm(p)
Definition: polys.h:76
p
int p
Definition: cfModGcd.cc:4019
pCopy
#define pCopy(p)
return a copy of the poly
Definition: polys.h:180
ringNF
poly ringNF(poly f, ideal G, ring r)
Definition: ringgb.cc:200
IDELEMS
#define IDELEMS(i)
Definition: simpleideals.h:24
plain_zero_spoly
poly plain_zero_spoly(poly h)
Definition: ringgb.cc:186
pHead
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL
Definition: polys.h:67
pGetCoeff
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
PrintLn
void PrintLn()
Definition: reporter.cc:310
G
static TreeM * G
Definition: janet.cc:32
pSub
#define pSub(a, b)
Definition: polys.h:281
nCopy
#define nCopy(n)
Definition: numbers.h:16
wrp
void wrp(poly p)
Definition: polys.h:304