My Project
Loading...
Searching...
No Matches
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 129 of file f5lists.cc.

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

◆ LNode() [2/6]

LNode::LNode ( LPolyOld *  lp)

Definition at line 133 of file f5lists.cc.

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

◆ LNode() [3/6]

LNode::LNode ( LPolyOld *  lp,
LNode *  l 
)

Definition at line 138 of file f5lists.cc.

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

◆ LNode() [4/6]

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

Definition at line 144 of file f5lists.cc.

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

◆ LNode() [5/6]

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

Definition at line 150 of file f5lists.cc.

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

◆ LNode() [6/6]

LNode::LNode ( LNode *  ln)

Definition at line 156 of file f5lists.cc.

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

◆ ~LNode()

LNode::~LNode ( )

Definition at line 161 of file f5lists.cc.

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

Member Function Documentation

◆ count()

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}
LNode
Definition: f5lists.h:65
LNode::getDel
bool getDel()
Definition: f5lists.cc:351

◆ deleteAll()

void LNode::deleteAll ( )

Definition at line 167 of file f5lists.cc.

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

◆ deleteByDeg()

LNode * LNode::deleteByDeg ( )

Definition at line 316 of file f5lists.cc.

316 {
317 return this;
318}

◆ getDel()

bool LNode::getDel ( )

Definition at line 351 of file f5lists.cc.

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

◆ getIndex()

int LNode::getIndex ( )

Definition at line 339 of file f5lists.cc.

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

◆ getLPolyOld()

LPolyOld * LNode::getLPolyOld ( )

Definition at line 326 of file f5lists.cc.

326 {
327 return data;
328}

◆ getNext() [1/2]

LNode * LNode::getNext ( )

Definition at line 321 of file f5lists.cc.

321 {
322 return next;
323}

◆ getNext() [2/2]

LNode * LNode::getNext ( LNode *  l)

Definition at line 388 of file f5lists.cc.

388 {
389 return l->next;
390}

◆ getPoly()

poly LNode::getPoly ( )

Definition at line 331 of file f5lists.cc.

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

◆ getPrev()

LNode * LNode::getPrev ( )

◆ getRuleOld()

RuleOld * LNode::getRuleOld ( )

Definition at line 343 of file f5lists.cc.

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

◆ getTerm()

poly LNode::getTerm ( )

Definition at line 335 of file f5lists.cc.

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

◆ insert() [1/2]

LNode * LNode::insert ( LPolyOld *  lp)
inline

Definition at line 178 of file f5lists.cc.

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

◆ insert() [2/2]

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

Definition at line 192 of file f5lists.cc.

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

◆ insertByDeg()

LNode * LNode::insertByDeg ( LPolyOld *  lp)

◆ insertByLabel() [1/2]

LNode * LNode::insertByLabel ( LNode *  l)
inline

Definition at line 270 of file f5lists.cc.

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

◆ insertByLabel() [2/2]

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

Definition at line 221 of file f5lists.cc.

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

◆ insertFirst()

LNode * LNode::insertFirst ( LNode *  l)
inline

Definition at line 265 of file f5lists.cc.

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

◆ insertSP() [1/2]

LNode * LNode::insertSP ( LPolyOld *  lp)
inline

Definition at line 206 of file f5lists.cc.

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

◆ insertSP() [2/2]

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

Definition at line 213 of file f5lists.cc.

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

◆ polyTest()

bool LNode::polyTest ( poly *  p)

Definition at line 377 of file f5lists.cc.

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

◆ print()

void LNode::print ( )

Definition at line 393 of file f5lists.cc.

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

◆ setDel()

void LNode::setDel ( bool  d)

Definition at line 372 of file f5lists.cc.

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

◆ setIndex()

void LNode::setIndex ( int  i)

Definition at line 364 of file f5lists.cc.

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

◆ setNext()

void LNode::setNext ( LNode *  l)

Definition at line 368 of file f5lists.cc.

368 {
369 next = l;
370}

◆ setPoly()

void LNode::setPoly ( poly  p)

Definition at line 356 of file f5lists.cc.

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

◆ setRuleOld()

void LNode::setRuleOld ( RuleOld *  r)

Definition at line 347 of file f5lists.cc.

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

◆ setTerm()

void LNode::setTerm ( poly  t)

Definition at line 360 of file f5lists.cc.

360 {
361 data->setTerm(t);
362}
LPolyOld::setTerm
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:
Generated on Mon Feb 27 2023 10:53:54 for My Project by   doxygen 1.9.5 for Singular