Functions | Variables
customstd.cc File Reference
#include <Singular/libsingular.h>
#include <vector>
#include <iostream>

Go to the source code of this file.

Functions

static BOOLEAN sat_vars_sp (kStrategy strat)
 
static BOOLEAN satstd (leftv res, leftv args)
 
int SI_MOD_INIT() std_demo (SModulFunctions *p)
 

Variables

ideal idealCache =NULL
 
std::vector< int > satstdSaturatingVariables
 

Function Documentation

static BOOLEAN sat_vars_sp ( kStrategy  strat)
static

Definition at line 44 of file customstd.cc.

45 {
46  BOOLEAN b = FALSE; // set b to TRUE, if spoly was changed,
47  // let it remain FALSE otherwise
48  if (strat->P.t_p==NULL)
49  {
50  poly p=strat->P.p;
51 
52  // iterate over all terms of p and
53  // compute the minimum mm of all exponent vectors
54  int *mm=(int*)omAlloc((1+rVar(currRing))*sizeof(int));
55  int *m0=(int*)omAlloc((1+rVar(currRing))*sizeof(int));
56  p_GetExpV(p,mm,currRing);
57  bool nonTrivialSaturationToBeDone=true;
58  for (p=pNext(p); p!=NULL; pIter(p))
59  {
60  nonTrivialSaturationToBeDone=false;
61  p_GetExpV(p,m0,currRing);
62  for (int i=satstdSaturatingVariables.size()-1; i>=0; i--)
63  {
64  int li = satstdSaturatingVariables[i];
65  mm[li]=si_min(mm[li],m0[li]);
66  if (mm[li]>0) nonTrivialSaturationToBeDone=true;
67  }
68  // abort if the minimum is zero in each component
69  if (nonTrivialSaturationToBeDone==false) break;
70  }
71  if (nonTrivialSaturationToBeDone==true)
72  {
73  // std::cout << "simplifying!" << std::endl;
74  p=p_Copy(strat->P.p,currRing);
75  memset(&strat->P,0,sizeof(strat->P));
76  strat->P.tailRing = strat->tailRing;
77  strat->P.p=p;
78  while(p!=NULL)
79  {
80  for (int i=satstdSaturatingVariables.size()-1; i>=0; i--)
81  {
82  int li = satstdSaturatingVariables[i];
83  p_SubExp(p,li,mm[li],currRing);
84  }
85  p_Setm(p,currRing);
86  pIter(p);
87  }
88  b = TRUE;
89  }
90  omFree(mm);
91  omFree(m0);
92  }
93  else
94  {
95  poly p=strat->P.t_p;
96 
97  // iterate over all terms of p and
98  // compute the minimum mm of all exponent vectors
99  int *mm=(int*)omAlloc((1+rVar(currRing))*sizeof(int));
100  int *m0=(int*)omAlloc((1+rVar(currRing))*sizeof(int));
101  p_GetExpV(p,mm,strat->tailRing);
102  bool nonTrivialSaturationToBeDone=true;
103  for (p = pNext(p); p!=NULL; pIter(p))
104  {
105  nonTrivialSaturationToBeDone=false;
106  p_GetExpV(p,m0,strat->tailRing);
107  for(int i=satstdSaturatingVariables.size()-1; i>=0; i--)
108  {
109  int li = satstdSaturatingVariables[i];
110  mm[li]=si_min(mm[li],m0[li]);
111  if (mm[li]>0) nonTrivialSaturationToBeDone = true;
112  }
113  // abort if the minimum is zero in each component
114  if (!nonTrivialSaturationToBeDone) break;
115  }
116  if (nonTrivialSaturationToBeDone)
117  {
118  p=p_Copy(strat->P.t_p,strat->tailRing);
119  memset(&strat->P,0,sizeof(strat->P));
120  strat->P.tailRing = strat->tailRing;
121  strat->P.t_p=p;
122  while(p!=NULL)
123  {
124  for(int i=satstdSaturatingVariables.size()-1; i>=0; i--)
125  {
126  int li = satstdSaturatingVariables[i];
127  p_SubExp(p,li,mm[li],strat->tailRing);
128  }
129  p_Setm(p,strat->tailRing);
130  pIter(p);
131  }
132  strat->P.GetP();
133  b = TRUE;
134  }
135  omFree(mm);
136  omFree(m0);
137  }
138  return b; // return TRUE if sp was changed, FALSE if not
139 }
static int si_min(const int a, const int b)
Definition: auxiliary.h:167
#define FALSE
Definition: auxiliary.h:140
return P p
Definition: myNF.cc:203
static void p_GetExpV(poly p, int *ev, const ring r)
Definition: p_polys.h:1449
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:537
#define TRUE
Definition: auxiliary.h:144
#define omAlloc(size)
Definition: omAllocDecl.h:210
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition: p_polys.h:810
static long p_SubExp(poly p, int v, long ee, ring r)
Definition: p_polys.h:608
#define pIter(p)
Definition: monomials.h:44
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
#define omFree(addr)
Definition: omAllocDecl.h:261
LObject P
Definition: kutil.h:298
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10
ring tailRing
Definition: kutil.h:341
#define pNext(p)
Definition: monomials.h:43
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:228
std::vector< int > satstdSaturatingVariables
Definition: customstd.cc:8
polyrec * poly
Definition: hilb.h:10
int BOOLEAN
Definition: auxiliary.h:131
const poly b
Definition: syzextra.cc:213
static BOOLEAN satstd ( leftv  res,
leftv  args 
)
static

Definition at line 141 of file customstd.cc.

142 {
143  leftv u = args;
144  if ((u!=NULL) && (u->Typ()==IDEAL_CMD))
145  {
146  leftv v = u->next;
147 
148  if (v==NULL)
149  {
150  int n = rVar(currRing);
151  satstdSaturatingVariables = std::vector<int>(n);
152  for (int i=n-1; i>=0; i--)
154  }
155  else
156  {
157  if (v->Typ()==IDEAL_CMD)
158  {
159  ideal J = (ideal) v->Data();
160 
161  int k = IDELEMS(J);
162  satstdSaturatingVariables = std::vector<int>(k);
163  for (int i=0; i<k; i++)
164  {
165  poly x = J->m[i];
166  int li = p_Var(x,currRing);
167  if (li>0)
169  else
170  {
171  WerrorS("satstd: second argument only ideals generated by variables supported for now");
172  return TRUE;
173  }
174  }
175  }
176  else
177  {
178  WerrorS("satstd: unexpected parameters");
179  return TRUE;
180  }
181  }
182 
183  ideal I = (ideal) u->Data();
184 
185  idealCache = NULL;
186  I=kStd(I,currRing->qideal,testHomog,NULL,NULL,0,0,NULL,sat_vars_sp);
187  satstdSaturatingVariables = std::vector<int>();
188 
189  res->rtyp=IDEAL_CMD;
190  if (idealCache)
191  {
192  id_Delete(&I,currRing);
193  res->data = (char*) idealCache;
194  idealCache = NULL;
195  }
196  else
197  {
198  idSkipZeroes(I);
199  res->data=(char*)I;
200  }
201  return FALSE;
202  }
203  WerrorS("satstd: unexpected parameters");
204  return TRUE;
205 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
#define FALSE
Definition: auxiliary.h:140
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:537
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
#define TRUE
Definition: auxiliary.h:144
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:2225
void WerrorS(const char *s)
Definition: feFopen.cc:24
int k
Definition: cfEzgcd.cc:93
int Typ()
Definition: subexpr.cc:976
void * data
Definition: subexpr.h:89
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
ideal idealCache
Definition: customstd.cc:6
int i
Definition: cfEzgcd.cc:123
#define IDELEMS(i)
Definition: simpleideals.h:24
void idSkipZeroes(ideal ide)
gives an ideal/module the minimal possible size
leftv next
Definition: subexpr.h:87
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
#define NULL
Definition: omList.c:10
int rtyp
Definition: subexpr.h:92
Variable x
Definition: cfModGcd.cc:4023
void * Data()
Definition: subexpr.cc:1118
std::vector< int > satstdSaturatingVariables
Definition: customstd.cc:8
polyrec * poly
Definition: hilb.h:10
static BOOLEAN sat_vars_sp(kStrategy strat)
Definition: customstd.cc:44
int p_Var(poly m, const ring r)
Definition: p_polys.cc:4462
int SI_MOD_INIT() std_demo ( SModulFunctions p)

Definition at line 444 of file customstd.cc.

445 {
446  // p->iiAddCproc("std_demo","std_with_display",FALSE,std_with_display);
447  p->iiAddCproc("customstd.so","satstd",FALSE,satstd);
448  // p->iiAddCproc("std_demo","satstdWithInitialCheck",FALSE,satstdWithInitialCheck);
449  // p->iiAddCproc("std_demo","abortifmonomialstd",FALSE,abortifmonomialstd);
450  // PrintS("init of std_demo - type `listvar(Std_demo);` to its contents\n");
451  return (MAX_TOK);
452 }
#define FALSE
Definition: auxiliary.h:140
Definition: tok.h:217
int(* iiAddCproc)(const char *libname, const char *procname, BOOLEAN pstatic, BOOLEAN(*func)(leftv res, leftv v))
Definition: ipid.h:73
static BOOLEAN satstd(leftv res, leftv args)
Definition: customstd.cc:141

Variable Documentation

ideal idealCache =NULL

Definition at line 6 of file customstd.cc.

std::vector<int> satstdSaturatingVariables

Definition at line 8 of file customstd.cc.