Macros | Functions
ringgb.cc File Reference
#include "kernel/mod2.h"
#include "kernel/GBEngine/kutil.h"
#include "kernel/structs.h"
#include "kernel/polys.h"
#include "polys/monomials/p_polys.h"
#include "kernel/ideals.h"
#include "kernel/GBEngine/kstd1.h"
#include "kernel/GBEngine/khstd.h"
#include "polys/kbuckets.h"
#include "polys/weight.h"
#include "misc/intvec.h"
#include "polys/nc/nc.h"
#include "kernel/GBEngine/ringgb.h"

Go to the source code of this file.

Macros

#define NO_BUCKETS
 

Functions

poly reduce_poly_fct (poly p, ring r)
 
int indexOf2 (number n)
 
BOOLEAN ring2toM_GetLeadTerms (const poly p1, const poly p2, const ring p_r, poly &m1, poly &m2, const ring m_r)
 
void printPolyMsg (const char *start, poly f, const char *end)
 
poly spolyRing2toM (poly f, poly g, ring r)
 
poly ringRedNF (poly f, ideal G, ring r)
 
int findRingSolver (poly rside, ideal G, ring r)
 
poly plain_spoly (poly f, poly g)
 
poly plain_zero_spoly (poly h)
 
poly ringNF (poly f, ideal G, ring r)
 
int testGB (ideal I, ideal GI)
 

Macro Definition Documentation

◆ NO_BUCKETS

#define NO_BUCKETS

Definition at line 8 of file ringgb.cc.

Function Documentation

◆ findRingSolver()

int findRingSolver ( poly  rside,
ideal  G,
ring  r 
)

Definition at line 152 of file ringgb.cc.

153 {
154  if (rside == NULL) return -1;
155  int i;
156 // int iO2rside = indexOf2(pGetCoeff(rside));
157  for (i = 0; i < IDELEMS(G); i++)
158  {
159  if // (indexOf2(pGetCoeff(G->m[i])) <= iO2rside && / should not be necessary any more
160  (p_LmDivisibleBy(G->m[i], rside, r))
161  {
162  return i;
163  }
164  }
165  return -1;
166 }
int i
Definition: cfEzgcd.cc:125
#define IDELEMS(i)
Definition: simpleideals.h:23
static BOOLEAN p_LmDivisibleBy(poly a, poly b, const ring r)
Definition: p_polys.h:1823
#define NULL
Definition: omList.c:12
STATIC_VAR TreeM * G
Definition: janet.cc:31

◆ indexOf2()

int indexOf2 ( number  n)

Definition at line 38 of file ringgb.cc.

39 {
40  long test = (long) n;
41  int i = 0;
42  while (test%2 == 0)
43  {
44  i++;
45  test = test / 2;
46  }
47  return i;
48 }
int i
Definition: cfEzgcd.cc:125
CanonicalForm test
Definition: cfModGcd.cc:4037

◆ 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 }
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:964
#define ppMult_mm(p, m)
Definition: polys.h:197
int ksCheckCoeff(number *a, number *b)
g
Definition: cfModGcd.cc:4031
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
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
#define pSub(a, b)
Definition: polys.h:283
FILE * f
Definition: checklibs.c:9
CanonicalForm cf
Definition: cfModGcd.cc:4024
CanonicalForm cg
Definition: cfModGcd.cc:4024
#define pDelete(p_ptr)
Definition: polys.h:182
#define nCopy(n)
Definition: numbers.h:15
#define pSetCoeff0(p, n)
Definition: monomials.h:59

◆ plain_zero_spoly()

poly plain_zero_spoly ( poly  h)

Definition at line 185 of file ringgb.cc.

186 {
187  poly p = NULL;
188  number gcd = n_Gcd((number) 0, pGetCoeff(h), currRing->cf);
189  if (!n_IsOne( gcd, currRing->cf ))
190  {
191  number tmp=n_Ann(gcd,currRing->cf);
192  p = p_Copy(h->next, currRing);
193  p = __p_Mult_nn(p, tmp, currRing);
194  n_Delete(&tmp,currRing->cf);
195  }
196  return p;
197 }
static FORCE_INLINE number n_Gcd(number a, number b, const coeffs r)
in Z: return the gcd of &#39;a&#39; and &#39;b&#39; in Z/nZ, Z/2^kZ: computed as in the case Z in Z/pZ...
Definition: coeffs.h:686
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the one element.
Definition: coeffs.h:468
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
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition: p_polys.h:811
static FORCE_INLINE number n_Ann(number a, const coeffs r)
if r is a ring with zero divisors, return an annihilator!=0 of b otherwise return NULL ...
Definition: coeffs.h:701
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
STATIC_VAR Poly * h
Definition: janet.cc:971
#define __p_Mult_nn(p, n, r)
Definition: p_polys.h:930
#define NULL
Definition: omList.c:12
int gcd(int a, int b)
Definition: walkSupport.cc:836
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:455
int p
Definition: cfModGcd.cc:4019

◆ printPolyMsg()

void printPolyMsg ( const char *  start,
poly  f,
const char *  end 
)

Definition at line 96 of file ringgb.cc.

97 {
98  PrintS(start);
99  wrp(f);
100  PrintS(end);
101 }
FILE * f
Definition: checklibs.c:9
void PrintS(const char *s)
Definition: reporter.cc:284
void wrp(poly p)
Definition: polys.h:306

◆ 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 }
poly kFindZeroPoly(poly input_p, ring leadRing, ring tailRing)
Definition: kstd2.cc:454
int p
Definition: cfModGcd.cc:4019

◆ ring2toM_GetLeadTerms()

BOOLEAN ring2toM_GetLeadTerms ( const poly  p1,
const poly  p2,
const ring  p_r,
poly &  m1,
poly &  m2,
const ring  m_r 
)

Definition at line 57 of file ringgb.cc.

59 {
60  int i;
61  int x;
62  m1 = p_Init(m_r);
63  m2 = p_Init(m_r);
64 
65  for (i = p_r->N; i; i--)
66  {
67  x = p_GetExpDiff(p1, p2, i, p_r);
68  if (x > 0)
69  {
70  p_SetExp(m2,i,x, m_r);
71  p_SetExp(m1,i,0, m_r);
72  }
73  else
74  {
75  p_SetExp(m1,i,-x, m_r);
76  p_SetExp(m2,i,0, m_r);
77  }
78  }
79  p_Setm(m1, m_r);
80  p_Setm(m2, m_r);
81  long cp1 = (long) pGetCoeff(p1);
82  long cp2 = (long) pGetCoeff(p2);
83  if (cp1 != 0 && cp2 != 0)
84  {
85  while (cp1%2 == 0 && cp2%2 == 0)
86  {
87  cp1 = cp1 / 2;
88  cp2 = cp2 / 2;
89  }
90  }
91  p_SetCoeff(m1, (number) cp2, m_r);
92  p_SetCoeff(m2, (number) cp1, m_r);
93  return TRUE;
94 }
#define TRUE
Definition: auxiliary.h:100
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
static number p_SetCoeff(poly p, number n, ring r)
Definition: p_polys.h:411
static long p_GetExpDiff(poly p1, poly p2, int i, ring r)
Definition: p_polys.h:634
int i
Definition: cfEzgcd.cc:125
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent : VarOffset encodes the position in p->exp
Definition: p_polys.h:487
Variable x
Definition: cfModGcd.cc:4023
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:232
static poly p_Init(const ring r, omBin bin)
Definition: p_polys.h:1259

◆ ringNF()

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

Definition at line 199 of file ringgb.cc.

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

◆ 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 }
void PrintLn()
Definition: reporter.cc:310
#define Print
Definition: emacs.cc:80
#define pAdd(p, q)
Definition: polys.h:199
#define pLmDelete(p)
assume p != NULL, deletes Lm(p)->coef and Lm(p)
Definition: polys.h:76
g
Definition: cfModGcd.cc:4031
FILE * f
Definition: checklibs.c:9
void PrintS(const char *s)
Definition: reporter.cc:284
#define pHead(p)
returns newly allocated copy of Lm(p), coef is copied, next=NULL, p might be NULL ...
Definition: polys.h:67
STATIC_VAR Poly * h
Definition: janet.cc:971
#define NULL
Definition: omList.c:12
void wrp(poly p)
Definition: polys.h:306
poly ringNF(poly f, ideal G, ring r)
Definition: ringgb.cc:199
STATIC_VAR TreeM * G
Definition: janet.cc:31
#define pCopy(p)
return a copy of the poly
Definition: polys.h:181

◆ spolyRing2toM()

poly spolyRing2toM ( poly  f,
poly  g,
ring  r 
)

Definition at line 103 of file ringgb.cc.

104 {
105  poly m1 = NULL;
106  poly m2 = NULL;
107  ring2toM_GetLeadTerms(f, g, r, m1, m2, r);
108  // printPolyMsg("spoly: m1=", m1, " | ");
109  // printPolyMsg("m2=", m2, "");
110  // PrintLn();
111  poly sp = pSub(p_Mult_mm(f, m1, r), pp_Mult_mm(g, m2, r));
112  pDelete(&m1);
113  pDelete(&m2);
114  return(sp);
115 }
static poly p_Mult_mm(poly p, poly m, const ring r)
Definition: p_polys.h:1000
static poly pp_Mult_mm(poly p, poly m, const ring r)
Definition: p_polys.h:990
g
Definition: cfModGcd.cc:4031
BOOLEAN ring2toM_GetLeadTerms(const poly p1, const poly p2, const ring p_r, poly &m1, poly &m2, const ring m_r)
Definition: ringgb.cc:57
#define pSub(a, b)
Definition: polys.h:283
FILE * f
Definition: checklibs.c:9
#define NULL
Definition: omList.c:12
#define pDelete(p_ptr)
Definition: polys.h:182

◆ testGB()

int testGB ( ideal  I,
ideal  GI 
)

Definition at line 226 of file ringgb.cc.

226  {
227  poly f, g, h, nf;
228  int i = 0;
229  int j = 0;
230  PrintS("I included?");
231  for (i = 0; i < IDELEMS(I); i++) {
232  if (ringNF(I->m[i], GI, currRing) != NULL) {
233  PrintS("Not reduced to zero from I: ");
234  wrp(I->m[i]);
235  PrintS(" --> ");
236  wrp(ringNF(I->m[i], GI, currRing));
237  PrintLn();
238  return(0);
239  }
240  PrintS("-");
241  }
242  PrintS(" Yes!\nspoly --> 0?");
243  for (i = 0; i < IDELEMS(GI); i++)
244  {
245  for (j = i + 1; j < IDELEMS(GI); j++)
246  {
247  f = pCopy(GI->m[i]);
248  g = pCopy(GI->m[j]);
249  h = plain_spoly(f, g);
250  nf = ringNF(h, GI, currRing);
251  if (nf != NULL)
252  {
253  PrintS("spoly(");
254  wrp(GI->m[i]);
255  PrintS(", ");
256  wrp(GI->m[j]);
257  PrintS(") = ");
258  wrp(h);
259  PrintS(" --> ");
260  wrp(nf);
261  PrintLn();
262  return(0);
263  }
264  pDelete(&f);
265  pDelete(&g);
266  pDelete(&h);
267  pDelete(&nf);
268  PrintS("-");
269  }
270  }
271  if (!(rField_is_Domain(currRing)))
272  {
273  PrintS(" Yes!\nzero-spoly --> 0?");
274  for (i = 0; i < IDELEMS(GI); i++)
275  {
276  f = plain_zero_spoly(GI->m[i]);
277  nf = ringNF(f, GI, currRing);
278  if (nf != NULL) {
279  PrintS("spoly(");
280  wrp(GI->m[i]);
281  PrintS(", ");
282  wrp(0);
283  PrintS(") = ");
284  wrp(h);
285  PrintS(" --> ");
286  wrp(nf);
287  PrintLn();
288  return(0);
289  }
290  pDelete(&f);
291  pDelete(&nf);
292  PrintS("-");
293  }
294  }
295  PrintS(" Yes!");
296  PrintLn();
297  return(1);
298 }
int j
Definition: facHensel.cc:105
void PrintLn()
Definition: reporter.cc:310
static BOOLEAN rField_is_Domain(const ring r)
Definition: ring.h:482
g
Definition: cfModGcd.cc:4031
Definition: gnumpfl.cc:26
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
FILE * f
Definition: checklibs.c:9
int i
Definition: cfEzgcd.cc:125
void PrintS(const char *s)
Definition: reporter.cc:284
#define IDELEMS(i)
Definition: simpleideals.h:23
poly plain_spoly(poly f, poly g)
Definition: ringgb.cc:168
STATIC_VAR Poly * h
Definition: janet.cc:971
#define NULL
Definition: omList.c:12
#define pDelete(p_ptr)
Definition: polys.h:182
poly plain_zero_spoly(poly h)
Definition: ringgb.cc:185
void wrp(poly p)
Definition: polys.h:306
poly ringNF(poly f, ideal G, ring r)
Definition: ringgb.cc:199
#define pCopy(p)
return a copy of the poly
Definition: polys.h:181