My Project  debian-1:4.1.1-p2+ds-4build4
Public Member Functions | Private Attributes
LNode Class Reference

#include <f5lists.h>

Public Member Functions

 LNode ()
 
 LNode (LPolyOld *lp)
 
 LNode (LPolyOld *lp, LNode *l)
 
 LNode (poly t, int i, poly p, RuleOld *r=NULL)
 
 LNode (poly t, int i, poly p, RuleOld *r, LNode *l)
 
 LNode (LNode *ln)
 
 ~LNode ()
 
void deleteAll ()
 
LNodeinsert (LPolyOld *lp)
 
LNodeinsert (poly t, int i, poly p, RuleOld *r)
 
LNodeinsertByDeg (LPolyOld *lp)
 
LNodeinsertSP (LPolyOld *lp)
 
LNodeinsertSP (poly t, int i, poly p, RuleOld *r)
 
LNodeinsertByLabel (poly t, int i, poly p, RuleOld *r)
 
LNodeinsertByLabel (LNode *l)
 
LNodeinsertFirst (LNode *l)
 
LNodegetNext ()
 
LNodegetPrev ()
 
LNodedeleteByDeg ()
 
LPolyOldgetLPolyOld ()
 
poly getPoly ()
 
poly getTerm ()
 
int getIndex ()
 
RuleOldgetRuleOld ()
 
bool getDel ()
 
void setPoly (poly p)
 
void setTerm (poly t)
 
void setIndex (int i)
 
void setNext (LNode *l)
 
void setRuleOld (RuleOld *r)
 
void setDel (bool d)
 
bool polyTest (poly *p)
 
LNodegetNext (LNode *l)
 
void print ()
 
int count (LNode *l)
 

Private Attributes

LPolyOlddata
 
LNodenext
 

Detailed Description

Definition at line 65 of file f5lists.h.

Constructor & Destructor Documentation

◆ LNode() [1/6]

LNode::LNode ( )

Definition at line 130 of file f5lists.cc.

130  {
131  data = NULL;
132  next = NULL;
133 }
LNode * next
Definition: f5lists.h:68
LPolyOld * data
Definition: f5lists.h:67
#define NULL
Definition: omList.c:10

◆ LNode() [2/6]

LNode::LNode ( LPolyOld lp)

Definition at line 134 of file f5lists.cc.

134  {
135  data = lp;
136  next = NULL;
137 }

◆ LNode() [3/6]

LNode::LNode ( LPolyOld lp,
LNode l 
)

Definition at line 139 of file f5lists.cc.

139  {
140 //Print("HIER LNODE\n");
141  data = lp;
142  next = l;
143 }
int l
Definition: cfEzgcd.cc:93

◆ LNode() [4/6]

LNode::LNode ( poly  t,
int  i,
poly  p,
RuleOld r = NULL 
)

Definition at line 145 of file f5lists.cc.

145  {
146 LPolyOld* lp = new LPolyOld(t,i,p,r);
147 data = lp;
148 next = NULL;
149 }
int i
Definition: cfEzgcd.cc:125
int p
Definition: cfModGcd.cc:4019

◆ LNode() [5/6]

LNode::LNode ( poly  t,
int  i,
poly  p,
RuleOld r,
LNode l 
)

Definition at line 151 of file f5lists.cc.

151  {
152  LPolyOld* lp = new LPolyOld(t,i,p,r);
153  data = lp;
154  next = l;
155 }

◆ LNode() [6/6]

LNode::LNode ( LNode ln)

Definition at line 157 of file f5lists.cc.

157  {
158  data = ln->getLPolyOld();
159  next = ln->getNext();
160 }
LNode * getNext()
Definition: f5lists.cc:322
LPolyOld * getLPolyOld()
Definition: f5lists.cc:327

◆ ~LNode()

LNode::~LNode ( )

Definition at line 162 of file f5lists.cc.

162  {
163  //delete next;
164  //Print("DELETE LNODE\n");
165  delete data;
166 }

Member Function Documentation

◆ count()

int LNode::count ( LNode l)

Definition at line 409 of file f5lists.cc.

409  {
410  int nonDel = 0;
411  LNode* temp = l;
412  while(NULL != temp) {
413  if(!temp->getDel()) {
414  nonDel++;
415  temp = temp->next;
416  }
417  else {
418  temp = temp->next;
419  }
420  }
421  return nonDel;
422 }
Definition: f5lists.h:65
bool getDel()
Definition: f5lists.cc:352

◆ deleteAll()

void LNode::deleteAll ( )

Definition at line 168 of file f5lists.cc.

168  {
169  while(NULL != next) {
170  //Print("%p\n",next);
171  //pWrite(next->data->getPoly());
172  next->deleteAll();
173  }
174  delete data;
175 }
void deleteAll()
Definition: f5lists.cc:168

◆ deleteByDeg()

LNode * LNode::deleteByDeg ( )

Definition at line 317 of file f5lists.cc.

317  {
318  return this;
319 }

◆ getDel()

bool LNode::getDel ( )

Definition at line 352 of file f5lists.cc.

352  {
353  return data->getDel();
354 }
bool getDel()
Definition: f5data.h:102

◆ getIndex()

int LNode::getIndex ( )

Definition at line 340 of file f5lists.cc.

340  {
341  return data->getIndex();
342 }
int getIndex()
Definition: f5data.h:94

◆ getLPolyOld()

LPolyOld * LNode::getLPolyOld ( )

Definition at line 327 of file f5lists.cc.

327  {
328  return data;
329 }

◆ getNext() [1/2]

LNode * LNode::getNext ( )

Definition at line 322 of file f5lists.cc.

322  {
323  return next;
324 }

◆ getNext() [2/2]

LNode * LNode::getNext ( LNode l)

Definition at line 389 of file f5lists.cc.

389  {
390  return l->next;
391 }

◆ getPoly()

poly LNode::getPoly ( )

Definition at line 332 of file f5lists.cc.

332  {
333  return data->getPoly();
334 }
poly getPoly()
Definition: f5data.h:86

◆ getPrev()

LNode* LNode::getPrev ( )

◆ getRuleOld()

RuleOld * LNode::getRuleOld ( )

Definition at line 344 of file f5lists.cc.

344  {
345  return data->getRuleOld();
346 }
RuleOld * getRuleOld()
Definition: f5data.h:98

◆ getTerm()

poly LNode::getTerm ( )

Definition at line 336 of file f5lists.cc.

336  {
337  return data->getTerm();
338 }
poly getTerm()
Definition: f5data.h:90

◆ insert() [1/2]

LNode * LNode::insert ( LPolyOld lp)
inline

Definition at line 179 of file f5lists.cc.

179  {
180  //Print("LAST GPREV: ");
181  //pWrite(this->getPoly());
182  if(NULL == this) {
183  LNode* newElement = new LNode(lp,this);
184  return newElement;
185  }
186  else {
187  LNode* newElement = new LNode(lp, NULL);
188  this->next = newElement;
189  return newElement;
190  }
191 }
LNode()
Definition: f5lists.cc:130

◆ insert() [2/2]

LNode * LNode::insert ( poly  t,
int  i,
poly  p,
RuleOld r 
)
inline

Definition at line 193 of file f5lists.cc.

193  {
194  if(NULL == this) {
195  LNode* newElement = new LNode(t,i,p,r,this);
196  return newElement;
197  }
198  else {
199  LNode* newElement = new LNode(t, i, p, r, NULL);
200  this->next = newElement;
201  return newElement;
202  }
203 }

◆ insertByDeg()

LNode* LNode::insertByDeg ( LPolyOld lp)

◆ insertByLabel() [1/2]

LNode * LNode::insertByLabel ( LNode l)
inline

Definition at line 271 of file f5lists.cc.

271  {
272  //Print("ADDING SOLYS TO THE LIST\n");
273  //Print("new element: ");
274  //pWrite(t);
275  if(NULL == this) { // || NULL == data) {
276  l->next = this;
277  return l;
278  }
279  else {
280  //Print("tested element1: ");
281  //pWrite(this->getTerm());
282  if(-1 == pLmCmp(l->getTerm(),this->getTerm())) {
283  //Print("HIERDRIN\n");
284  l->next = this;
285  //Print("%p\n",this);
286  //Print("%p\n",newElement->next);
287  return l;
288  }
289  else {
290  LNode* temp = this;
291  while(NULL != temp->next && NULL != temp->next->data) {
292  //Print("tested element: ");
293  //pWrite(temp->getTerm());
294  if(-1 == pLmCmp(l->getTerm(),temp->next->getTerm())) {
295  l->next = temp->next;
296  temp->next = l;
297  return this;
298  }
299  else {
300  temp = temp->next;
301  //Print("%p\n",temp);
302  //Print("%p\n",temp->data);
303 
304  //Print("%p\n",temp->next);
305  }
306  }
307  //Print("HIER\n");
308  l->next = temp->next;
309  temp->next = l;
310  return this;
311  }
312  }
313 }
poly getTerm()
Definition: f5lists.cc:336
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
Definition: polys.h:105

◆ insertByLabel() [2/2]

LNode * LNode::insertByLabel ( poly  t,
int  i,
poly  p,
RuleOld r 
)
inline

Definition at line 222 of file f5lists.cc.

222  {
223  //Print("ADDING SOLYS TO THE LIST\n");
224  //Print("new element: ");
225  //pWrite(t);
226  if(NULL == this) { // || NULL == data) {
227  LNode* newElement = new LNode(t, i, p, r, this);
228  return newElement;
229  }
230  else {
231  //Print("tested element1: ");
232  //pWrite(this->getTerm());
233  if(-1 == pLmCmp(t,this->getTerm())) {
234  //Print("HIERDRIN\n");
235  LNode* newElement = new LNode(t, i, p, r, this);
236  //Print("%p\n",this);
237  //Print("%p\n",newElement->next);
238  return newElement;
239  }
240  else {
241  LNode* temp = this;
242  while(NULL != temp->next && NULL != temp->next->data) {
243  //Print("tested element: ");
244  //pWrite(temp->getTerm());
245  if(-1 == pLmCmp(t,temp->next->getTerm())) {
246  LNode* newElement = new LNode(t, i, p, r, temp->next);
247  temp->next = newElement;
248  return this;
249  }
250  else {
251  temp = temp->next;
252  //Print("%p\n",temp);
253  //Print("%p\n",temp->data);
254 
255  //Print("%p\n",temp->next);
256  }
257  }
258  //Print("HIER\n");
259  LNode* newElement = new LNode(t, i, p, r, temp->next);
260  temp->next = newElement;
261  return this;
262  }
263  }
264 }

◆ insertFirst()

LNode * LNode::insertFirst ( LNode l)
inline

Definition at line 266 of file f5lists.cc.

266  {
267  l->next = this;
268  return l;
269 }

◆ insertSP() [1/2]

LNode * LNode::insertSP ( LPolyOld lp)
inline

Definition at line 207 of file f5lists.cc.

207  {
208  LNode* newElement = new LNode(lp, this);
209  //Print("INSERTED IN SPOLYLIST: ");
210  //pWrite(lp->getTerm());
211  return newElement;
212 }

◆ insertSP() [2/2]

LNode * LNode::insertSP ( poly  t,
int  i,
poly  p,
RuleOld r 
)
inline

Definition at line 214 of file f5lists.cc.

214  {
215  LNode* newElement = new LNode(t, i, p, r, this);
216  //Print("INSERTED IN SPOLYLIST: ");
217  //pWrite(t);
218 return newElement;
219 }

◆ polyTest()

bool LNode::polyTest ( poly *  p)

Definition at line 378 of file f5lists.cc.

378  {
379  LNode* temp = new LNode(this);
380  while(NULL != temp) {
381  if(pComparePolys(temp->getPoly(),*p)) {
382  return 1;
383  }
384  temp = temp->next;
385  }
386  return 0;
387 }
poly getPoly()
Definition: f5lists.cc:332

◆ print()

void LNode::print ( )

Definition at line 394 of file f5lists.cc.

395 {
396  LNode* temp = this;
397  PrintS("___________________List of S-polynomials______________________:\n");
398  while(NULL != temp && NULL != temp->data) {
399  Print("Index: %d\n",temp->getIndex());
400  PrintS("Term: ");
401  pWrite(temp->getTerm());
402  PrintS("Poly: ");
403  pWrite(temp->getPoly());
404  temp = temp->next;
405  }
406  PrintS("_______________________________________________________________\n");
407 }
int getIndex()
Definition: f5lists.cc:340
#define Print
Definition: emacs.cc:80
void pWrite(poly p)
Definition: polys.h:294
void PrintS(const char *s)
Definition: reporter.cc:284

◆ setDel()

void LNode::setDel ( bool  d)

Definition at line 373 of file f5lists.cc.

373  {
374  data->setDel(d);
375 }
void setDel(bool d)
Definition: f5data.h:82

◆ setIndex()

void LNode::setIndex ( int  i)

Definition at line 365 of file f5lists.cc.

365  {
366  data->setIndex(i);
367 }
void setIndex(int i)
Definition: f5data.h:74

◆ setNext()

void LNode::setNext ( LNode l)

Definition at line 369 of file f5lists.cc.

369  {
370  next = l;
371 }

◆ setPoly()

void LNode::setPoly ( poly  p)

Definition at line 357 of file f5lists.cc.

357  {
358  data->setPoly(p);
359 }
void setPoly(poly p)
Definition: f5data.h:62

◆ setRuleOld()

void LNode::setRuleOld ( RuleOld r)

Definition at line 348 of file f5lists.cc.

348  {
349  return data->setRuleOld(r);
350 }
void setRuleOld(RuleOld *r)
Definition: f5data.h:78

◆ setTerm()

void LNode::setTerm ( poly  t)

Definition at line 361 of file f5lists.cc.

361  {
362  data->setTerm(t);
363 }
void setTerm(poly t)
Definition: f5data.h:68

Field Documentation

◆ data

LPolyOld* LNode::data
private

Definition at line 67 of file f5lists.h.

◆ next

LNode* LNode::next
private

Definition at line 68 of file f5lists.h.


The documentation for this class was generated from the following files: