f5lists.h
Go to the documentation of this file.
1 #ifndef F5LISTS_HEADER
2 #define F5LISTS_HEADER
3 /****************************************
4 * Computer Algebra System SINGULAR *
5 ****************************************/
6 /*
7 * ABSTRACT: list interface
8 */
10 
11 #ifdef HAVE_F5
12 /*
13 ============================
14 ============================
15 classes for lists used in F5
16 ============================
17 ============================
18 */
19 class PNode;
20 class PList;
21 class LNode;
22 class LList;
23 class LTagNode;
24 class LTagList;
25 class CNode;
26 class CListOld;
27 class RList;
28 class RNode;
29 class RTagNode;
30 class RTagList;
31 
32 
33 /**
34  * class PNode of nodes of polynomials
35  */
36 class PNode {
37  private:
38  poly data;
40  public:
41  PNode(poly p, PNode* n);
42  poly getPoly();
43  PNode* getNext();
44  PNode* insert(poly p);
45 };
46 
47 /**
48  * class PList of lists of PNodes
49  */
50 class PList {
51  private:
53  public:
54  PList();
55  void insert(poly p);
56  bool check(poly p);
57  void print();
58 };
59 
60 /*
61 =======================================
62 class LNode (nodes for lists of LPolyOlds)
63 =======================================
64 */
65 class LNode {
66  private:
69  public:
70  // generating new list elements from the labeled / classical polynomial view
71  LNode();
72  LNode(LPolyOld* lp);
73  LNode(LPolyOld* lp, LNode* l);
74  LNode(poly t, int i, poly p, RuleOld* r=NULL);
75  LNode(poly t, int i, poly p, RuleOld* r, LNode* l);
76  LNode(LNode* ln);
77  ~LNode();
78  void deleteAll();
79  // insert new elements to the list at the end from the labeled / classical polynomial view
80  // needed for gPrev
81  LNode* insert(LPolyOld* lp);
82  LNode* insert(poly t, int i, poly p, RuleOld* r);
83  LNode* insertByDeg(LPolyOld* lp);
84  // insert new elements to the list in front from the labeled / classical polynomial view
85  // needed for sPolyList
86  LNode* insertSP(LPolyOld* lp);
87  LNode* insertSP(poly t, int i, poly p, RuleOld* r);
88  // insert new elements to the list with resp. to increasing labels
89  // only used for the S-polys to be reduced (TopReduction building new S-polys with higher label)
90  LNode* insertByLabel(poly t, int i, poly p, RuleOld* r);
91  LNode* insertByLabel(LNode* l);
92  LNode* insertFirst(LNode* l);
93  // deletes the first elements of the list with the same degree
94  // get next & prev from current LNode
95  LNode* getNext();
96  LNode* getPrev();
97  // only used for the S-polys, which are already sorted by increasing degree by CListOld
98  LNode* deleteByDeg();
99  // get the LPolyOld* out of LNode*
100  LPolyOld* getLPolyOld();
101  // get the data from the LPolyOld saved in LNode
102  poly getPoly();
103  poly getTerm();
104  int getIndex();
105  RuleOld* getRuleOld();
106  bool getDel();
107  // set the data from the LPolyOld saved in LNode
108  void setPoly(poly p);
109  void setTerm(poly t);
110  void setIndex(int i);
111  void setNext(LNode* l);
112  void setRuleOld(RuleOld* r);
113  void setDel(bool d);
114  // test if for any list element the polynomial part of the data is equal to *p
115  bool polyTest(poly* p);
116  LNode* getNext(LNode* l);
117  void print();
118  int count(LNode* l);
119 };
120 
121 
122 /*
123 ============================
124 class LList(lists of LPolyOlds)
125 ============================
126 */
127 class LList {
128  private:
131  int length;
132  public:
133  LList();
134  LList(LPolyOld* lp);
135  LList(poly t,int i,poly p, RuleOld* r = NULL);
136  ~LList();
137  // insertion at the end of the list
138  // needed for gPrev
139  void insert(LPolyOld* lp);
140  void insert(poly t,int i, poly p, RuleOld* r = NULL);
141  void insertByDeg(LPolyOld* lp);
142  // insertion in front of the list
143  // needed for sPolyList
144  void insertSP(LPolyOld* lp);
145  void insertSP(poly t,int i, poly p, RuleOld* r = NULL);
146  void insertByLabel(poly t, int i, poly p, RuleOld* r = NULL);
147  void insertByLabel(LNode* l);
148  void insertFirst(LNode* l);
149  void deleteByDeg();
150  bool polyTest(poly* p);
151  LNode* getFirst();
152  LNode* getLast();
153  int getLength();
154  void setFirst(LNode* l);
155  void print();
156  int count(LNode* l);
157 };
158 
159 
160 
161 /*
162 ==============================================
163 class LtagNode (nodes for lists of LPolyOld tags)
164 ==============================================
165 */
166 class LTagNode {
167  private:
170  public:
171  LTagNode();
172  LTagNode(LNode* l);
173  LTagNode(LNode* l, LTagNode* n);
174  ~LTagNode();
175  // declaration with first as parameter due to sorting of LTagList
176  LTagNode* insert(LNode* l);
177  LNode* getLNode();
178  LTagNode* getNext();
179  LNode* get(int i, int length);
180 };
181 
182 
183 /*
184 =========================================================================
185 class LTagList(lists of LPolyOld tags, i.e. first elements of a given index)
186 =========================================================================
187 */
188 class LTagList {
189  private:
192  int length;
193  public:
194  LTagList();
195  LTagList(LNode* l);
196  ~LTagList();
197  // declaration with first as parameter in LTagNode due to sorting of LTagList
198  void insert(LNode* l);
199  void setFirstCurrentIdx(LNode* l);
200  LNode* get(int idx);
201  LNode* getFirst();
202  LNode* getFirstCurrentIdx();
203 };
204 
207 
208 
209 /*
210 ======================================================================================
211 class TopRed(return values of subalgorithm TopRed in f5gb.cc), i.e. the first elements
212  of the lists LList* completed & LList* sPolyList
213 ======================================================================================
214 */
215 class TopRed {
216  private:
219  public:
220  TopRed();
221  TopRed(LList* c, LList* t);
222  LList* getCompleted();
223  LList* getToDo();
224 };
225 
226 
227 /*
228 =======================================
229 class CNode (nodes for lists of CPairOlds)
230 =======================================
231 */
232 class CNode {
233  private:
236  public:
237  CNode();
238  CNode(CPairOld* c);
239  CNode(CPairOld* c, CNode* n);
240  ~CNode();
241  CNode* insert(CPairOld* c);
242  CNode* insertWithoutSort(CPairOld* cp);
243  CNode* getMinDeg();
244  CPairOld* getData();
245  CNode* getNext();
246  LPolyOld* getAdLp1();
247  LPolyOld* getAdLp2();
248  poly getLp1Poly();
249  poly getLp2Poly();
250  poly getLp1Term();
251  poly getLp2Term();
252  poly getT1();
253  poly* getAdT1();
254  poly getT2();
255  poly* getAdT2();
256  int getLp1Index();
257  int getLp2Index();
258  bool getDel();
259  RuleOld* getTestedRuleOld();
260  void print();
261 };
262 
263 
264 /*
265 ============================
266 class CListOld(lists of CPairOlds)
267 ============================
268 */
269 class CListOld {
270  private:
272  public:
273  // for initialization of CListOlds, last element alwas has data=NULL and next=NULL
274  CListOld();
275  CListOld(CPairOld* c);
276  ~CListOld();
277  CNode* getFirst();
278  void insert(CPairOld* c);
279  void insertWithoutSort(CPairOld* c);
280  CNode* getMinDeg();
281  void print();
282 };
283 
284 
285 /*
286 ======================================
287 class RNode (nodes for lists of RuleOlds)
288 ======================================
289 */
290 class RNode {
291  private:
294  public:
295  RNode();
296  RNode(RuleOld* r);
297  ~RNode();
298  RNode* insert(RuleOld* r);
299  RNode* insert(int i, poly t);
300  RNode* insertOrdered(RuleOld* r);
301  RNode* getNext();
302  RuleOld* getRuleOld();
303  int getRuleOldIndex();
304  poly getRuleOldTerm();
305  void print();
306 };
307 
308 /*
309 ============================
310 class RList (lists of RuleOlds)
311 ============================
312 */
313 class RList {
314  private:
316  // last alway has data=NULL and next=NULL, for initialization purposes used
318  public:
319  RList();
320  RList(RuleOld* r);
321  ~RList();
322  void insert(RuleOld* r);
323  void insert(int i, poly t);
324  void insertOrdered(RuleOld* r);
325  RNode* getFirst();
326  RuleOld* getRuleOld();
327  void print();
328 };
329 
330 
331 
332 /*
333 =============================================
334 class RtagNode (nodes for lists of RuleOld tags)
335 =============================================
336 */
337 class RTagNode {
338  private:
341  public:
342  RTagNode();
343  RTagNode(RNode* r);
344  RTagNode(RNode* r, RTagNode* n);
345  ~RTagNode();
346  // declaration with first as parameter due to sorting of LTagList
347  RTagNode* insert(RNode* r);
348  RNode* getRNode();
349  RTagNode* getNext();
350  RNode* get(int idx, int length);
351  void set(RNode*);
352  void print();
353 };
354 
355 
356 /*
357 ========================================================================
358 class RTagList(lists of RuleOld tags, i.e. first elements of a given index)
359 ========================================================================
360 */
361 class RTagList {
362  private:
364  int length;
365  public:
366  RTagList();
367  RTagList(RNode* r);
368  ~RTagList();
369  // declaration with first as parameter in LTagNode due to sorting of LTagList
370  void insert(RNode* r);
371  RNode* getFirst();
372  RNode* get(int idx);
373  void setFirst(RNode* r);
374  void print();
375  int getLength();
376 };
377 #endif
378 #endif
int status int void size_t count
Definition: si_signals.h:59
PNode(poly p, PNode *n)
functions working on the class PNode
Definition: f5lists.cc:25
class PNode of nodes of polynomials
Definition: f5lists.h:36
int check
Definition: libparse.cc:1104
CNode * first
Definition: f5lists.h:271
poly getPoly()
Definition: f5lists.cc:30
poly data
Definition: f5lists.h:38
LNode * last
Definition: f5lists.h:130
static poly getTerm(const ideal H, const mark ab)
LNode * next
Definition: f5lists.h:68
Definition: f5lists.h:313
structure of RuleOlds(i.e.
Definition: f5data.h:232
LList * _toDo
Definition: f5lists.h:218
int length
Definition: f5lists.h:364
LTagNode * first
Definition: f5lists.h:190
RTagNode * first
Definition: f5lists.h:363
class PList of lists of PNodes
Definition: f5lists.h:50
RTagNode * next
Definition: f5lists.h:340
LNode * first
Definition: f5lists.h:129
RNode * first
Definition: f5lists.h:315
Definition: f5lists.h:65
Definition: f5lists.h:232
int length
Definition: f5lists.h:192
LNode * getGPrevRedCheck()
class of labeled polynomials
Definition: f5data.h:28
else L getLast()(0
LTagNode * next
Definition: f5lists.h:169
int i
Definition: cfEzgcd.cc:125
PNode * getNext()
Definition: f5lists.cc:34
RNode * last
Definition: f5lists.h:317
PNode * first
Definition: f5lists.h:52
LPolyOld * data
Definition: f5lists.h:67
CNode * next
Definition: f5lists.h:235
PNode * next
Definition: f5lists.h:39
LList * _completed
Definition: f5lists.h:217
int length
Definition: f5lists.h:131
CPairOld * data
Definition: f5lists.h:234
#define NULL
Definition: omList.c:12
RNode * data
Definition: f5lists.h:339
Definition: f5lists.h:127
PNode * insert(poly p)
Definition: f5lists.cc:37
LNode * getcompletedRedCheck()
static BOOLEAN length(leftv result, leftv arg)
Definition: interval.cc:263
RNode * next
Definition: f5lists.h:293
int p
Definition: cfModGcd.cc:4019
Definition: f5lists.h:290
LNode * firstCurrentIdx
Definition: f5lists.h:191
RuleOld * data
Definition: f5lists.h:292
int l
Definition: cfEzgcd.cc:93
LNode * data
Definition: f5lists.h:168
structure of labeled critical pairs
Definition: f5data.h:123