My Project  debian-1:4.1.1-p2+ds-4build2
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 ()
 
LNode * insert (LPolyOld *lp)
 
LNode * insert (poly t, int i, poly p, RuleOld *r)
 
LNode * insertByDeg (LPolyOld *lp)
 
LNode * insertSP (LPolyOld *lp)
 
LNode * insertSP (poly t, int i, poly p, RuleOld *r)
 
LNode * insertByLabel (poly t, int i, poly p, RuleOld *r)
 
LNode * insertByLabel (LNode *l)
 
LNode * insertFirst (LNode *l)
 
LNode * getNext ()
 
LNode * getPrev ()
 
LNode * deleteByDeg ()
 
LPolyOld * getLPolyOld ()
 
poly getPoly ()
 
poly getTerm ()
 
int getIndex ()
 
RuleOld * getRuleOld ()
 
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)
 
LNode * getNext (LNode *l)
 
void print ()
 
int count (LNode *l)
 

Private Attributes

LPolyOld * data
 
LNode * next
 

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() [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 }

◆ 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 }

◆ 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()

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 }

◆ 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 }

◆ 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 }

◆ getIndex()

int LNode::getIndex ( )

Definition at line 340 of file f5lists.cc.

340  {
341  return data->getIndex();
342 }

◆ 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 }

◆ getPrev()

LNode* LNode::getPrev ( )

◆ getRuleOld()

RuleOld * LNode::getRuleOld ( )

Definition at line 344 of file f5lists.cc.

344  {
345  return data->getRuleOld();
346 }

◆ getTerm()

poly LNode::getTerm ( )

Definition at line 336 of file f5lists.cc.

336  {
337  return data->getTerm();
338 }

◆ 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 }

◆ 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 }

◆ 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 }

◆ 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 }

◆ setDel()

void LNode::setDel ( bool  d)

Definition at line 373 of file f5lists.cc.

373  {
374  data->setDel(d);
375 }

◆ setIndex()

void LNode::setIndex ( int  i)

Definition at line 365 of file f5lists.cc.

365  {
366  data->setIndex(i);
367 }

◆ 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 }

◆ setRuleOld()

void LNode::setRuleOld ( RuleOld *  r)

Definition at line 348 of file f5lists.cc.

348  {
349  return data->setRuleOld(r);
350 }

◆ setTerm()

void LNode::setTerm ( poly  t)

Definition at line 361 of file f5lists.cc.

361  {
362  data->setTerm(t);
363 }

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:
LPolyOld::setDel
void setDel(bool d)
Definition: f5data.h:82
LNode::next
LNode * next
Definition: f5lists.h:68
LNode::getPoly
poly getPoly()
Definition: f5lists.cc:332
LPolyOld::getIndex
int getIndex()
Definition: f5data.h:94
LPolyOld::setIndex
void setIndex(int i)
Definition: f5data.h:74
LPolyOld::setTerm
void setTerm(poly t)
Definition: f5data.h:68
LPolyOld::getPoly
poly getPoly()
Definition: f5data.h:86
LNode::getLPolyOld
LPolyOld * getLPolyOld()
Definition: f5lists.cc:327
LNode::getTerm
poly getTerm()
Definition: f5lists.cc:336
LNode::LNode
LNode()
Definition: f5lists.cc:130
i
int i
Definition: cfEzgcd.cc:125
PrintS
void PrintS(const char *s)
Definition: reporter.cc:284
LNode::deleteAll
void deleteAll()
Definition: f5lists.cc:168
LPolyOld::setPoly
void setPoly(poly p)
Definition: f5data.h:62
LPolyOld::getDel
bool getDel()
Definition: f5data.h:102
LNode::getIndex
int getIndex()
Definition: f5lists.cc:340
LPolyOld::setRuleOld
void setRuleOld(RuleOld *r)
Definition: f5data.h:78
LPolyOld::getTerm
poly getTerm()
Definition: f5data.h:90
Print
#define Print
Definition: emacs.cc:80
LNode
Definition: f5lists.h:65
LNode::data
LPolyOld * data
Definition: f5lists.h:67
NULL
#define NULL
Definition: omList.c:10
l
int l
Definition: cfEzgcd.cc:93
LNode::getNext
LNode * getNext()
Definition: f5lists.cc:322
p
int p
Definition: cfModGcd.cc:4019
pLmCmp
#define pLmCmp(p, q)
returns 0|1|-1 if p=q|p>q|p<q w.r.t monomial ordering
Definition: polys.h:105
LNode::getDel
bool getDel()
Definition: f5lists.cc:352
LPolyOld::getRuleOld
RuleOld * getRuleOld()
Definition: f5data.h:98
LPolyOld
Definition: f5data.h:28
pWrite
void pWrite(poly p)
Definition: polys.h:294
Generated on Tue Mar 24 2020 14:10:46 for My Project by   doxygen 1.8.17 for Singular debian-1:4.1.1-p2+ds-4build2