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::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::LNode ( LPolyOld lp)

Definition at line 134 of file f5lists.cc.

134  {
135  data = lp;
136  next = NULL;
137 }
LNode * next
Definition: f5lists.h:68
LPolyOld * data
Definition: f5lists.h:67
#define NULL
Definition: omList.c:10
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 }
LNode * next
Definition: f5lists.h:68
LPolyOld * data
Definition: f5lists.h:67
int l
Definition: cfEzgcd.cc:94
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 }
return P p
Definition: myNF.cc:203
LNode * next
Definition: f5lists.h:68
class of labeled polynomials
Definition: f5data.h:28
int i
Definition: cfEzgcd.cc:123
LPolyOld * data
Definition: f5lists.h:67
#define NULL
Definition: omList.c:10
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 }
return P p
Definition: myNF.cc:203
LNode * next
Definition: f5lists.h:68
class of labeled polynomials
Definition: f5data.h:28
int i
Definition: cfEzgcd.cc:123
LPolyOld * data
Definition: f5lists.h:67
int l
Definition: cfEzgcd.cc:94
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
LNode * next
Definition: f5lists.h:68
LPolyOld * getLPolyOld()
Definition: f5lists.cc:327
LPolyOld * data
Definition: f5lists.h:67
LNode::~LNode ( )

Definition at line 162 of file f5lists.cc.

162  {
163  //delete next;
164  //Print("DELETE LNODE\n");
165  delete data;
166 }
LPolyOld * data
Definition: f5lists.h:67

Member Function Documentation

int LNode::count ( LNode l)

Definition at line 408 of file f5lists.cc.

408  {
409  int nonDel = 0;
410  LNode* temp = l;
411  while(NULL != temp) {
412  if(!temp->getDel()) {
413  nonDel++;
414  temp = temp->next;
415  }
416  else {
417  temp = temp->next;
418  }
419  }
420  return nonDel;
421 }
bool getDel()
Definition: f5lists.cc:352
LNode * next
Definition: f5lists.h:68
Definition: f5lists.h:65
#define NULL
Definition: omList.c:10
int l
Definition: cfEzgcd.cc:94
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 }
LNode * next
Definition: f5lists.h:68
void deleteAll()
Definition: f5lists.cc:168
LPolyOld * data
Definition: f5lists.h:67
#define NULL
Definition: omList.c:10
LNode * LNode::deleteByDeg ( )

Definition at line 317 of file f5lists.cc.

317  {
318  return this;
319 }
bool LNode::getDel ( )

Definition at line 352 of file f5lists.cc.

352  {
353  return data->getDel();
354 }
LPolyOld * data
Definition: f5lists.h:67
bool getDel()
Definition: f5data.h:102
int LNode::getIndex ( )

Definition at line 340 of file f5lists.cc.

340  {
341  return data->getIndex();
342 }
int getIndex()
Definition: f5data.h:94
LPolyOld * data
Definition: f5lists.h:67
LPolyOld * LNode::getLPolyOld ( )

Definition at line 327 of file f5lists.cc.

327  {
328  return data;
329 }
LPolyOld * data
Definition: f5lists.h:67
LNode * LNode::getNext ( )

Definition at line 322 of file f5lists.cc.

322  {
323  return next;
324 }
LNode * next
Definition: f5lists.h:68
LNode * LNode::getNext ( LNode l)

Definition at line 389 of file f5lists.cc.

389  {
390  return l->next;
391 }
LNode * next
Definition: f5lists.h:68
poly LNode::getPoly ( )

Definition at line 332 of file f5lists.cc.

332  {
333  return data->getPoly();
334 }
poly getPoly()
Definition: f5data.h:86
LPolyOld * data
Definition: f5lists.h:67
LNode* LNode::getPrev ( )
RuleOld * LNode::getRuleOld ( )

Definition at line 344 of file f5lists.cc.

344  {
345  return data->getRuleOld();
346 }
LPolyOld * data
Definition: f5lists.h:67
RuleOld * getRuleOld()
Definition: f5data.h:98
poly LNode::getTerm ( )

Definition at line 336 of file f5lists.cc.

336  {
337  return data->getTerm();
338 }
poly getTerm()
Definition: f5data.h:90
LPolyOld * data
Definition: f5lists.h:67
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
LNode * next
Definition: f5lists.h:68
Definition: f5lists.h:65
#define NULL
Definition: omList.c:10
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 }
LNode()
Definition: f5lists.cc:130
return P p
Definition: myNF.cc:203
LNode * next
Definition: f5lists.h:68
Definition: f5lists.h:65
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10
LNode* LNode::insertByDeg ( LPolyOld lp)
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 }
LNode()
Definition: f5lists.cc:130
return P p
Definition: myNF.cc:203
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
Definition: polys.h:105
poly getTerm()
Definition: f5lists.cc:336
LNode * next
Definition: f5lists.h:68
Definition: f5lists.h:65
int i
Definition: cfEzgcd.cc:123
LPolyOld * data
Definition: f5lists.h:67
#define NULL
Definition: omList.c:10
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 }
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
Definition: polys.h:105
poly getTerm()
Definition: f5lists.cc:336
LNode * next
Definition: f5lists.h:68
Definition: f5lists.h:65
LPolyOld * data
Definition: f5lists.h:67
#define NULL
Definition: omList.c:10
int l
Definition: cfEzgcd.cc:94
LNode * LNode::insertFirst ( LNode l)
inline

Definition at line 266 of file f5lists.cc.

266  {
267  l->next = this;
268  return l;
269 }
LNode * next
Definition: f5lists.h:68
int l
Definition: cfEzgcd.cc:94
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 }
LNode()
Definition: f5lists.cc:130
Definition: f5lists.h:65
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 }
LNode()
Definition: f5lists.cc:130
return P p
Definition: myNF.cc:203
Definition: f5lists.h:65
int i
Definition: cfEzgcd.cc:123
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 }
LNode()
Definition: f5lists.cc:130
return P p
Definition: myNF.cc:203
LNode * next
Definition: f5lists.h:68
poly getPoly()
Definition: f5lists.cc:332
Definition: f5lists.h:65
#define NULL
Definition: omList.c:10
void LNode::print ( )

Definition at line 394 of file f5lists.cc.

394  {
395  LNode* temp = this;
396  Print("___________________List of S-polynomials______________________:\n");
397  while(NULL != temp && NULL != temp->data) {
398  Print("Index: %d\n",temp->getIndex());
399  Print("Term: ");
400  pWrite(temp->getTerm());
401  Print("Poly: ");
402  pWrite(temp->getPoly());
403  temp = temp->next;
404  }
405  Print("_______________________________________________________________\n");
406 }
#define Print
Definition: emacs.cc:83
poly getTerm()
Definition: f5lists.cc:336
LNode * next
Definition: f5lists.h:68
void pWrite(poly p)
Definition: polys.h:279
poly getPoly()
Definition: f5lists.cc:332
Definition: f5lists.h:65
LPolyOld * data
Definition: f5lists.h:67
#define NULL
Definition: omList.c:10
int getIndex()
Definition: f5lists.cc:340
void LNode::setDel ( bool  d)

Definition at line 373 of file f5lists.cc.

373  {
374  data->setDel(d);
375 }
LPolyOld * data
Definition: f5lists.h:67
void setDel(bool d)
Definition: f5data.h:82
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
int i
Definition: cfEzgcd.cc:123
LPolyOld * data
Definition: f5lists.h:67
void LNode::setNext ( LNode l)

Definition at line 369 of file f5lists.cc.

369  {
370  next = l;
371 }
LNode * next
Definition: f5lists.h:68
int l
Definition: cfEzgcd.cc:94
void LNode::setPoly ( poly  p)

Definition at line 357 of file f5lists.cc.

357  {
358  data->setPoly(p);
359 }
return P p
Definition: myNF.cc:203
void setPoly(poly p)
Definition: f5data.h:62
LPolyOld * data
Definition: f5lists.h:67
void LNode::setRuleOld ( RuleOld r)

Definition at line 348 of file f5lists.cc.

348  {
349  return data->setRuleOld(r);
350 }
LPolyOld * data
Definition: f5lists.h:67
void setRuleOld(RuleOld *r)
Definition: f5data.h:78
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
LPolyOld * data
Definition: f5lists.h:67

Field Documentation

LPolyOld* LNode::data
private

Definition at line 67 of file f5lists.h.

LNode* LNode::next
private

Definition at line 68 of file f5lists.h.


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