source: git/kernel/f5lists.h @ fbc7cb

jengelh-datetimespielwiese
Last change on this file since fbc7cb was a9c298, checked in by Hans Schoenemann <hannes@…>, 9 years ago
format stuff
  • Property mode set to 100644
File size: 10.3 KB
Line 
1/****************************************
2*  Computer Algebra System SINGULAR     *
3****************************************/
4/*
5* ABSTRACT: list interface
6*/
7#include <kernel/f5data.h>
8#ifndef F5LISTS_HEADER
9#define F5LISTS_HEADER
10
11#ifdef HAVE_F5
12/*
13============================
14============================
15classes for lists used in F5
16============================
17============================
18*/
19class PNode;
20class PList;
21class LNode;
22class LList;
23class LTagNode;
24class LTagList;
25class CNode;
26class CListOld;
27class RList;
28class RNode;
29class RTagNode;
30class RTagList;
31
32
33/**
34 * class PNode of nodes of polynomials
35 */
36class PNode {
37  private:
38    poly   data;
39    PNode*  next;
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 */
50class PList {
51  private:
52    PNode* first;
53  public:
54    PList();
55    void insert(poly p);
56    bool check(poly p);
57    void print();
58};
59
60/*
61=======================================
62class LNode (nodes for lists of LPolyOlds)
63=======================================
64*/
65class LNode {
66    private:
67        LPolyOld*  data;
68        LNode*  next;
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============================
124class LList(lists of LPolyOlds)
125============================
126*/
127class LList {
128    private:
129        LNode*  first;
130        LNode*  last;
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==============================================
163class LtagNode (nodes for lists of LPolyOld tags)
164==============================================
165*/
166class LTagNode {
167    private:
168        LNode*      data;
169        LTagNode*   next;
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=========================================================================
185class LTagList(lists of LPolyOld tags, i.e. first elements of a given index)
186=========================================================================
187*/
188class LTagList {
189    private:
190        LTagNode*   first;
191        LNode*      firstCurrentIdx;
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
205LNode*  getGPrevRedCheck();
206LNode*  getcompletedRedCheck();
207
208
209/*
210======================================================================================
211class TopRed(return values of subalgorithm TopRed in f5gb.cc), i.e. the first elements
212             of the lists LList* completed & LList* sPolyList
213======================================================================================
214*/
215class TopRed {
216    private:
217        LList*  _completed;
218        LList*  _toDo;
219    public:
220                TopRed();
221                TopRed(LList* c, LList* t);
222        LList*  getCompleted();
223        LList*  getToDo();
224};
225
226
227/*
228=======================================
229class CNode (nodes for lists of CPairOlds)
230=======================================
231*/
232class CNode {
233    private:
234        CPairOld* data;
235        CNode* next;
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============================
266class CListOld(lists of CPairOlds)
267============================
268*/
269class CListOld {
270    private:
271        CNode*  first;
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======================================
287class RNode (nodes for lists of RuleOlds)
288======================================
289*/
290class RNode {
291    private:
292        RuleOld*   data;
293        RNode*  next;
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============================
310class RList (lists of RuleOlds)
311============================
312*/
313class RList {
314    private:
315        RNode*  first;
316        // last alway has data=NULL and next=NULL, for initialization purposes used
317        RNode*  last;
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=============================================
334class RtagNode (nodes for lists of RuleOld tags)
335=============================================
336*/
337class RTagNode {
338    private:
339        RNode*      data;
340        RTagNode*   next;
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========================================================================
358class RTagList(lists of RuleOld tags, i.e. first elements of a given index)
359========================================================================
360*/
361class RTagList {
362    private:
363        RTagNode*   first;
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
Note: See TracBrowser for help on using the repository browser.