source: git/kernel/kInline.h @ e9927f

fieker-DuValspielwiese
Last change on this file since e9927f was e9927f, checked in by Hans Schoenemann <hannes@…>, 12 years ago
fix: length computation in sLObject::Tail_Minus_mm_Mult_qq
  • Property mode set to 100644
File size: 23.6 KB
Line 
1/****************************************
2*  Computer Algebra System SINGULAR     *
3****************************************/
4/***************************************************************
5 *  File:    kInline.h
6 *  Purpose: implementation of std related inline routines
7 *  Author:  obachman (Olaf Bachmann)
8 *  Created: 8/00
9 *******************************************************************/
10#ifndef KINLINE_H
11#define KINLINE_H
12
13#if !defined(NO_KINLINE) || defined(KUTIL_CC)
14/* this file is a header file with inline routines,
15 *     if NO_KINLINE is not defined (AND ONLY THEN!)
16 * otherwise it is an part of kutil.cc and a source file!
17 * (remark: NO_KINLINE is defined by KDEBUG, i.e. in the debug version)
18 */
19
20#include <omalloc/omalloc.h>
21#include <misc/options.h>
22
23#include <polys/monomials/p_polys.h>
24#include <polys/kbuckets.h>
25
26#include <kernel/polys.h>
27
28
29#define HAVE_TAIL_BIN
30// This doesn't really work, fixme, if necessary
31// #define HAVE_LM_BIN
32
33
34
35KINLINE TObject* skStrategy::S_2_T(int i)
36{
37  assume(i>= 0 && i<=sl);
38  assume(S_2_R[i] >= 0 && S_2_R[i] <= tl);
39  TObject* TT = R[S_2_R[i]];
40  assume(TT != NULL && TT->p == S[i]);
41  return TT;
42}
43
44KINLINE TObject* skStrategy::s_2_t(int i)
45{
46  if (i >= 0 && i <= sl)
47  {
48    int sri= S_2_R[i];
49    if ((sri >= 0) && (sri <= tl))
50    {
51      TObject* t = R[sri];
52      if ((t != NULL) && (t->p == S[i]))
53        return t;
54    }
55    // last but not least, try kFindInT
56    sri = kFindInT(S[i], T, tl);
57    if (sri >= 0)
58      return &(T[sri]);
59  }
60  return NULL;
61}
62
63KINLINE poly skStrategy::kNoetherTail()
64{
65  if (tailRing == currRing)
66    return kNoether;
67  else
68  {
69    assume((kNoether == NULL && t_kNoether == NULL) ||
70           (kNoether != NULL && t_kNoether != NULL));
71    return t_kNoether;
72  }
73}
74
75/***************************************************************
76 *
77 * Operation on TObjects
78 *
79 ***************************************************************/
80
81KINLINE TSet initT ()
82{
83  TSet T = (TSet)omAlloc0(setmaxT*sizeof(TObject));
84  for (int i=setmaxT-1; i>=0; i--)
85  {
86    T[i].tailRing = currRing;
87    T[i].i_r = -1;
88  }
89  return T;
90}
91
92KINLINE TObject** initR()
93{
94  return (TObject**) omAlloc0(setmaxT*sizeof(TObject*));
95}
96
97KINLINE unsigned long* initsevT()
98{
99  return (unsigned long*) omAlloc0(setmaxT*sizeof(unsigned long));
100}
101
102// initialization
103KINLINE void sTObject::Set(ring r)
104{
105  tailRing = r;
106}
107KINLINE void sTObject::Init(ring r)
108{
109  memset(this, 0, sizeof(sTObject));
110  i_r = -1;
111  Set(r);
112}
113KINLINE sTObject::sTObject(ring r)
114{
115  Init(r);
116}
117KINLINE void sTObject::Set(poly p_in, ring r)
118{
119  if (r != currRing)
120  {
121    assume(r == tailRing);
122    p_Test(p_in, r);
123    t_p = p_in;
124  }
125  else
126  {
127    pp_Test(p_in, currRing, tailRing);
128    p = p_in;
129  }
130}
131
132KINLINE sTObject::sTObject(poly p_in, ring r)
133{
134  Init(r);
135  Set(p_in, r);
136}
137
138KINLINE void sTObject::Set(poly p_in, ring c_r, ring t_r)
139{
140  if (c_r != t_r)
141  {
142    assume(c_r == currRing && t_r == tailRing);
143    pp_Test(p_in, currRing, t_r);
144    p = p_in;
145  }
146  else
147  {
148    Set(p_in, c_r);
149  }
150}
151
152KINLINE sTObject::sTObject(poly p_in, ring c_r, ring t_r)
153{
154  Init(t_r);
155  Set(p_in, c_r, t_r);
156}
157
158KINLINE sTObject::sTObject(sTObject* T, int copy)
159{
160  *this = *T;
161  if (copy)
162  {
163    if (t_p != NULL)
164    {
165      t_p = p_Copy(t_p, tailRing);
166      p = k_LmInit_tailRing_2_currRing(t_p, tailRing);
167    }
168    else
169    {
170      p = p_Copy(p, currRing, tailRing);
171    }
172  }
173}
174
175KINLINE void sTObject::Delete()
176{
177  if (t_p != NULL)
178  {
179    p_Delete(&t_p, tailRing);
180    if (p != NULL)
181      p_LmFree(p, currRing);
182  }
183  else
184  {
185    p_Delete(&p, currRing, tailRing);
186  }
187}
188
189KINLINE void sTObject::Clear()
190{
191  p = NULL;
192  t_p = NULL;
193  ecart = 0;
194  length = 0;
195  pLength = 0;
196  FDeg = 0;
197  is_normalized = FALSE;
198}
199
200KINLINE void sTObject::Copy()
201{
202  if (t_p != NULL)
203  {
204    t_p = p_Copy(t_p, tailRing);
205    if (p != NULL)
206    {
207      p = p_Head(p, currRing);
208      if (pNext(t_p) != NULL) pNext(p) = pNext(t_p);
209    }
210  }
211  else
212  {
213    p = p_Copy(p, currRing, tailRing);
214  }
215}
216
217KINLINE poly sTObject::GetLmCurrRing()
218{
219  if (p == NULL && t_p != NULL)
220    p = k_LmInit_tailRing_2_currRing(t_p, tailRing);
221
222  return p;
223}
224KINLINE poly sTObject::GetLmTailRing()
225{
226  if (t_p == NULL)
227  {
228    if (p != NULL && tailRing != currRing)
229    {
230      t_p = k_LmInit_currRing_2_tailRing(p, tailRing);
231      return t_p;
232    }
233    return p;
234  }
235  return t_p;
236}
237KINLINE poly sTObject::GetLm(ring r)
238{
239  assume(r == tailRing || r == currRing);
240  if (r == currRing)
241    return GetLmCurrRing();
242
243  if (t_p == NULL && p != NULL)
244    t_p = k_LmInit_currRing_2_tailRing(p, tailRing);
245
246  return t_p;
247}
248
249KINLINE void sTObject::GetLm(poly &p_r, ring &r_r) const
250{
251  if (t_p != NULL)
252  {
253    p_r = t_p;
254    r_r = tailRing;
255  }
256  else
257  {
258    p_r = p;
259    r_r = currRing;
260  }
261}
262
263KINLINE BOOLEAN sTObject::IsNull() const
264{
265  return (p == NULL && t_p == NULL);
266}
267
268KINLINE int sTObject::GetpLength()
269{
270  if (pLength <= 0) pLength = ::pLength(p != NULL ? p : t_p);
271  return pLength;
272}
273
274KINLINE void sTObject::SetLmCurrRing()
275{
276  if (p == NULL && t_p != NULL)
277    p = k_LmInit_tailRing_2_currRing(t_p, tailRing);
278}
279
280KINLINE poly sTObject::Next()
281{
282  assume(p != NULL || t_p != NULL);
283  if (t_p != NULL) return pNext(t_p);
284  return pNext(p);
285}
286
287// Iterations
288KINLINE void sTObject::LmDeleteAndIter()
289{
290  assume(p != NULL || t_p != NULL);
291  if (t_p != NULL)
292  {
293    t_p = p_LmDeleteAndNext(t_p, tailRing);
294    if (p != NULL)
295    {
296      p_LmFree(p, currRing);
297      p = NULL;
298    }
299  }
300  else
301  {
302    p = p_LmDeleteAndNext(p, currRing);
303  }
304  is_normalized = FALSE;
305}
306
307
308// arithmetic
309KINLINE void sTObject::Mult_nn(number n)
310{
311  if (t_p != NULL)
312  {    t_p = p_Mult_nn(t_p, n, tailRing);
313    if (p != NULL) pSetCoeff0(p, pGetCoeff(t_p));
314  }
315  else
316  {
317    p = p_Mult_nn(p, n, currRing, tailRing);
318  }
319}
320
321KINLINE void sLObject::Normalize()
322{
323  if (t_p != NULL)
324  {
325    pNormalize(t_p);
326    if (p != NULL) pSetCoeff0(p, pGetCoeff(t_p));
327  }
328  else
329  {
330    pNormalize(p);
331  }
332}
333
334KINLINE void sLObject::HeadNormalize()
335{
336  if (t_p != NULL)
337  {
338    nNormalize(pGetCoeff(t_p));
339    if (p != NULL) pSetCoeff0(p, pGetCoeff(t_p));
340  }
341  else
342  {
343    nNormalize(pGetCoeff(p));
344  }
345}
346
347KINLINE void
348sTObject::ShallowCopyDelete(ring new_tailRing, omBin new_tailBin,
349                            pShallowCopyDeleteProc p_shallow_copy_delete,
350                            BOOLEAN set_max)
351{
352  if (new_tailBin == NULL) new_tailBin = new_tailRing->PolyBin;
353  if (t_p != NULL)
354  {
355    t_p = p_shallow_copy_delete(t_p, tailRing, new_tailRing, new_tailBin);
356    if (p != NULL)
357      pNext(p) = pNext(t_p);
358    if (new_tailRing == currRing)
359    {
360      if (p == NULL) p = t_p;
361      else p_LmFree(t_p, tailRing);
362      t_p = NULL;
363    }
364  }
365  else if (p != NULL)
366  {
367    if (pNext(p) != NULL)
368    {
369      pNext(p) = p_shallow_copy_delete(pNext(p),
370                                       tailRing, new_tailRing, new_tailBin);
371    }
372    if (new_tailRing != currRing)
373    {
374      t_p = k_LmInit_currRing_2_tailRing(p, new_tailRing);
375      pNext(t_p) = pNext(p);
376    }
377  }
378  if (max != NULL)
379  {
380    if (new_tailRing == currRing)
381    {
382      p_LmFree(max, tailRing);
383      max = NULL;
384    }
385    else
386      max = p_shallow_copy_delete(max,tailRing,new_tailRing,new_tailBin);
387  }
388  else if (set_max && new_tailRing != currRing && pNext(t_p) != NULL)
389  {
390    max = p_GetMaxExpP(pNext(t_p), new_tailRing);
391  }
392  tailRing = new_tailRing;
393}
394
395KINLINE long sTObject::pFDeg() const
396{
397  if (p != NULL) return p_FDeg(p, currRing);
398  return tailRing->pFDeg(t_p, tailRing);
399}
400KINLINE long sTObject::pTotalDeg() const
401{
402  if (p != NULL) return p_Totaldegree(p, currRing);
403  return p_Totaldegree(t_p,tailRing);
404}
405KINLINE long sTObject::SetpFDeg()
406{
407  FDeg = this->pFDeg();
408  return FDeg;
409}
410KINLINE long sTObject::GetpFDeg() const
411{
412  assume(FDeg == this->pFDeg());
413  return FDeg;
414}
415KINLINE long sTObject::pLDeg()
416{
417  return tailRing->pLDeg(GetLmTailRing(), &length, tailRing);
418}
419KINLINE long sTObject::SetDegStuffReturnLDeg()
420{
421  FDeg = this->pFDeg();
422  long d = this->pLDeg();
423  ecart = d - FDeg;
424  return d;
425}
426
427//extern void pCleardenom(poly p);
428// extern void pNorm(poly p);
429
430// manipulations
431KINLINE void  sTObject::pCleardenom()
432{
433  assume(p != NULL);
434  if (TEST_OPT_CONTENTSB)
435    {
436      number n;
437      if (t_p != NULL)
438        {
439          p_Cleardenom_n(t_p, tailRing, n);
440          pSetCoeff0(p, pGetCoeff(t_p));
441        }
442      else
443        {
444#ifdef HAVE_RATGRING
445          p_Cleardenom_n(p, currRing, n);
446#else
447          p_Cleardenom_n(p, currRing, n);
448#endif
449        }
450      if (!nIsOne(n))
451        {
452          denominator_list denom=(denominator_list)omAlloc(sizeof(denominator_list_s));
453          denom->n=nInvers(n);
454          denom->next=DENOMINATOR_LIST;
455          DENOMINATOR_LIST=denom;
456        }
457      nDelete(&n);
458    }
459  else
460    {
461      if (t_p != NULL)
462        {
463          p_Cleardenom(t_p, tailRing);
464          pSetCoeff0(p, pGetCoeff(t_p));
465        }
466      else
467        {
468#ifdef HAVE_RATGRING
469          p_Cleardenom(p, currRing);
470#else
471          p_Cleardenom(p, currRing);
472#endif
473        }
474    }
475}
476
477KINLINE void sTObject::pNorm() // pNorm seems to be a _bad_ method name...
478{
479  assume(p != NULL);
480  if (! is_normalized)
481  {
482    p_Norm(p, currRing);
483    if (t_p != NULL)
484      pSetCoeff0(t_p, pGetCoeff(p));
485    is_normalized = TRUE;
486  }
487}
488
489
490
491/***************************************************************
492 *
493 * Operation on LObjects
494 *
495 ***************************************************************/
496// Initialization
497KINLINE void sLObject::Clear()
498{
499  sTObject::Clear();
500  sev = 0;
501}
502// Initialization
503KINLINE void sLObject::Delete()
504{
505  sTObject::Delete();
506  if (bucket != NULL)
507    kBucketDeleteAndDestroy(&bucket);
508}
509
510KINLINE void sLObject::Init(ring r)
511{
512  memset(this, 0, sizeof(sLObject));
513  i_r1 = -1;
514  i_r2 = -1;
515  i_r = -1;
516  Set(r);
517}
518KINLINE sLObject::sLObject(ring r)
519{
520  Init(r);
521}
522KINLINE sLObject::sLObject(poly p_in, ring r)
523{
524  Init(r);
525  Set(p_in, r);
526}
527
528KINLINE sLObject::sLObject(poly p_in, ring c_r, ring t_r)
529{
530  Init(t_r);
531  Set(p_in, c_r, t_r);
532}
533
534KINLINE void sLObject::PrepareRed(BOOLEAN use_bucket)
535{
536  if (bucket == NULL)
537  {
538    int l = GetpLength();
539    if (use_bucket && l > 1)
540    {
541      poly tp = GetLmTailRing();
542      assume(l == ::pLength(tp));
543      bucket = kBucketCreate(tailRing);
544      kBucketInit(bucket, pNext(tp), l-1);
545      pNext(tp) = NULL;
546      if (p != NULL) pNext(p) = NULL;
547      pLength = 0;
548    }
549  }
550}
551
552KINLINE void sLObject::SetLmTail(poly lm, poly p_tail, int p_Length, int use_bucket, ring _tailRing)
553{
554
555  Set(lm, _tailRing);
556  if (use_bucket)
557  {
558    bucket = kBucketCreate(_tailRing);
559    kBucketInit(bucket, p_tail, p_Length);
560    pNext(lm) = NULL;
561    pLength = 0;
562  }
563  else
564  {
565    pNext(lm) = p_tail;
566    pLength = p_Length + 1;
567  }
568}
569
570KINLINE void sLObject::Tail_Mult_nn(number n)
571{
572  if (bucket != NULL)
573  {
574    kBucket_Mult_n(bucket, n);
575  }
576  else
577  {
578    poly _p = (t_p != NULL ? t_p : p);
579    assume(_p != NULL);
580    pNext(_p) = p_Mult_nn(pNext(_p), n, tailRing);
581  }
582}
583
584KINLINE void sLObject::Tail_Minus_mm_Mult_qq(poly m, poly q, int lq,
585                                             poly spNoether)
586{
587  if (bucket != NULL)
588  {
589    kBucket_Minus_m_Mult_p(bucket, m, q, &lq, spNoether);
590  }
591  else
592  {
593    poly _p = (t_p != NULL ? t_p : p);
594    assume(_p != NULL);
595
596    int lp=pLength-1;
597    pNext(_p) = p_Minus_mm_Mult_qq( pNext(_p), m, q, lp, lq, 
598                                    spNoether, tailRing );
599    pLength=lp+1;
600//    tailRing->p_Procs->p_Minus_mm_Mult_qq(pNext(_p), m, q, shorter,spNoether, tailRing, last);
601//    pLength += lq - shorter;
602  }
603}
604
605KINLINE void sLObject::LmDeleteAndIter()
606{
607  sTObject::LmDeleteAndIter();
608  if (bucket != NULL)
609  {
610    poly _p = kBucketExtractLm(bucket);
611    if (_p == NULL)
612    {
613      kBucketDestroy(&bucket);
614      p = t_p = NULL;
615      return;
616    }
617    Set(_p, tailRing);
618  }
619  else
620  {
621    pLength--;
622  }
623}
624
625KINLINE poly sLObject::LmExtractAndIter()
626{
627  poly ret = GetLmTailRing();
628  poly pn;
629
630  assume(p != NULL || t_p != NULL);
631
632  if (bucket != NULL)
633  {
634    pn = kBucketExtractLm(bucket);
635    if (pn == NULL)
636      kBucketDestroy(&bucket);
637  }
638  else
639  {
640    pn = pNext(ret);
641  }
642  pLength--;
643  pNext(ret) = NULL;
644  if (p != NULL && t_p != NULL)
645    p_LmFree(p, currRing);
646
647  Set(pn, tailRing);
648  return ret;
649}
650
651KINLINE poly sLObject::CanonicalizeP()
652{
653  //kTest_L(this);
654  int i = -1;
655
656  if (bucket != NULL)
657    i = kBucketCanonicalize(bucket);
658
659  if (p == NULL)
660    p = k_LmInit_tailRing_2_currRing(t_p, tailRing);
661
662  if (i >= 0) pNext(p) = bucket->buckets[i];
663  return p;
664}
665
666KINLINE poly sLObject::GetTP()
667{
668  //kTest_L(this);
669  poly tp = GetLmTailRing();
670  assume(tp != NULL);
671
672  if (bucket != NULL)
673  {
674    kBucketClear(bucket, &pNext(tp), &pLength);
675    kBucketDestroy(&bucket);
676    pLength++;
677  }
678  return tp;
679}
680
681
682KINLINE poly sLObject::GetP(omBin lmBin)
683{
684  //kTest_L(this);
685  if (p == NULL)
686  {
687    p = k_LmInit_tailRing_2_currRing(t_p, tailRing,
688                                     (lmBin!=NULL?lmBin:currRing->PolyBin));
689    FDeg = pFDeg();
690  }
691  else if (lmBin != NULL && lmBin != currRing->PolyBin)
692  {
693    p = p_LmShallowCopyDelete(p, currRing);
694    FDeg = pFDeg();
695  }
696
697  if (bucket != NULL)
698  {
699    kBucketClear(bucket, &pNext(p), &pLength);
700    kBucketDestroy(&bucket);
701    pLength++;
702    if (t_p != NULL) pNext(t_p) = pNext(p);
703  }
704  //kTest_L(this);
705  return p;
706}
707
708KINLINE void
709sLObject::ShallowCopyDelete(ring new_tailRing,
710                            pShallowCopyDeleteProc p_shallow_copy_delete)
711{
712  if (bucket != NULL)
713    kBucketShallowCopyDelete(bucket, new_tailRing, new_tailRing->PolyBin,
714                             p_shallow_copy_delete);
715  sTObject::ShallowCopyDelete(new_tailRing,
716                              new_tailRing->PolyBin,p_shallow_copy_delete,
717                              FALSE);
718}
719
720KINLINE void sLObject::SetShortExpVector()
721{
722  if (t_p != NULL)
723  {
724    sev = p_GetShortExpVector(t_p, tailRing);
725  }
726  else
727  {
728    sev = p_GetShortExpVector(p, currRing);
729  }
730}
731
732KINLINE void sLObject::Copy()
733{
734  if (bucket != NULL)
735  {
736    int i = kBucketCanonicalize(bucket);
737    kBucket_pt new_bucket = kBucketCreate(tailRing);
738    kBucketInit(new_bucket,
739                p_Copy(bucket->buckets[i], tailRing),
740                bucket->buckets_length[i]);
741    bucket = new_bucket;
742    if (t_p != NULL) pNext(t_p) = NULL;
743    if (p != NULL) pNext(p) = NULL;
744  }
745  TObject::Copy();
746}
747
748KINLINE poly sLObject::CopyGetP()
749{
750  if (bucket != NULL)
751  {
752    int i = kBucketCanonicalize(bucket);
753    poly bp = p_Copy(bucket->buckets[i], tailRing);
754    pLength = bucket->buckets_length[i] + 1;
755    if (bp != NULL)
756    {
757      assume(t_p != NULL || p != NULL);
758      if (t_p != NULL) pNext(t_p) = bp;
759      else pNext(p) = bp;
760    }
761    bucket = NULL;
762  }
763  return sLObject::GetP();
764}
765
766
767KINLINE long sLObject::pLDeg()
768{
769  poly tp = GetLmTailRing();
770  assume(tp != NULL);
771  if (bucket != NULL)
772  {
773    int i = kBucketCanonicalize(bucket);
774    pNext(tp) = bucket->buckets[i];
775    long ldeg = tailRing->pLDeg(tp, &length, tailRing);
776    pNext(tp) = NULL;
777    return ldeg;
778  }
779  else
780    return tailRing->pLDeg(tp, &length, tailRing);
781}
782KINLINE long sLObject::pLDeg(BOOLEAN deg_last)
783{
784  if (! deg_last || bucket != NULL) return sLObject::pLDeg();
785
786  long ldeg;
787  ldeg = tailRing->pLDeg(GetLmTailRing(), &length, tailRing);
788#ifdef HAVE_ASSUME
789  if ( pLength == 0)
790    p_Last(GetLmTailRing(), pLength, tailRing);
791  assume ( pLength == length || rIsSyzIndexRing(currRing));
792#else
793  pLength=length;
794#endif
795  return ldeg;
796}
797
798KINLINE long sLObject::SetDegStuffReturnLDeg()
799{
800  FDeg = this->pFDeg();
801  long d = this->pLDeg();
802  ecart = d - FDeg;
803  return d;
804}
805KINLINE long sLObject::SetDegStuffReturnLDeg(BOOLEAN use_last)
806{
807  FDeg = this->pFDeg();
808  long d = this->pLDeg(use_last);
809  ecart = d - FDeg;
810  return d;
811}
812KINLINE int sLObject::GetpLength()
813{
814  if (bucket == NULL)
815    return sTObject::GetpLength();
816  int i = kBucketCanonicalize(bucket);
817  return bucket->buckets_length[i] + 1;
818}
819KINLINE int sLObject::SetLength(BOOLEAN length_pLength)
820{
821  if (length_pLength)
822  {
823    length = this->GetpLength();
824  }
825  else
826    this->pLDeg();
827  return length;
828}
829KINLINE long sLObject::MinComp()
830{
831  poly tp = GetLmTailRing();
832  assume(tp != NULL);
833  if (bucket != NULL)
834  {
835    int i = kBucketCanonicalize(bucket);
836    pNext(tp) = bucket->buckets[i];
837    long m = p_MinComp(tp, tailRing);
838    pNext(tp) = NULL;
839    return m;
840  }
841  else
842    return p_MinComp(tp, tailRing);
843}
844KINLINE long sLObject::Comp()
845{
846  poly pp;
847  ring r;
848  GetLm(pp, r);
849  assume(pp != NULL);
850  return p_GetComp(pp, r);
851}
852
853KINLINE sLObject& sLObject::operator=(const sTObject& t)
854{
855  memset(this, 0, sizeof(*this));
856  memcpy(this, &t, sizeof(sTObject));
857  return *this;
858}
859
860KINLINE TObject* sLObject::T_1(const skStrategy* s)
861{
862  if (p1 == NULL) return NULL;
863  if (i_r1 == -1) i_r1 = kFindInT(p1, s->T, s->tl);
864  assume(i_r1 >= 0 && i_r1 <= s->tl);
865  TObject* T = s->R[i_r1];
866  assume(T->p == p1);
867  return T;
868}
869
870KINLINE TObject* sLObject::T_2(const skStrategy* strat)
871{
872  if (p1 == NULL) return NULL;
873  assume(p2 != NULL);
874  if (i_r2 == -1) i_r2 = kFindInT(p2, strat->T, strat->tl);
875  assume(i_r2 >= 0 && i_r2 <= strat->tl);
876  TObject* T = strat->R[i_r2];
877  assume(T->p == p2);
878  return T;
879}
880
881KINLINE void    sLObject::T_1_2(const skStrategy* strat,
882                                TObject* &T_1, TObject* &T_2)
883{
884  if (p1 == NULL)
885  {
886    T_1 = NULL;
887    T_2 = NULL;
888    return;
889  }
890  assume(p1 != NULL && p2 != NULL);
891  if (i_r1 == -1) i_r1 = kFindInT(p1, strat->T, strat->tl);
892  if (i_r2 == -1) i_r2 = kFindInT(p2, strat->T, strat->tl);
893  assume(i_r1 >= 0 && i_r1 <= strat->tl);
894  assume(i_r2 >= 0 && i_r2 <= strat->tl);
895  T_1 = strat->R[i_r1];
896  T_2 = strat->R[i_r2];
897  assume(T_1->p == p1);
898  assume(T_2->p == p2);
899  return;
900}
901
902/***************************************************************
903 *
904 * Conversion of polys
905 *
906 ***************************************************************/
907
908KINLINE poly k_LmInit_currRing_2_tailRing(poly p, ring tailRing, omBin tailBin)
909{
910
911  poly np = p_LmInit(p, currRing, tailRing, tailBin);
912  pNext(np) = pNext(p);
913  pSetCoeff0(np, pGetCoeff(p));
914  return np;
915}
916
917KINLINE poly k_LmInit_tailRing_2_currRing(poly p, ring tailRing, omBin lmBin)
918{
919  poly np = p_LmInit(p, tailRing, currRing, lmBin);
920  pNext(np) = pNext(p);
921  pSetCoeff0(np, pGetCoeff(p));
922  return np;
923}
924
925// this should be made more efficient
926KINLINE poly k_LmShallowCopyDelete_currRing_2_tailRing(poly p, ring tailRing, omBin tailBin)
927{
928  poly np = k_LmInit_currRing_2_tailRing(p, tailRing, tailBin);
929  p_LmFree(p, currRing);
930  return np;
931}
932
933KINLINE poly k_LmShallowCopyDelete_tailRing_2_currRing(poly p, ring tailRing, omBin lmBin)
934{
935  poly np = k_LmInit_tailRing_2_currRing(p, tailRing, lmBin);
936  p_LmFree(p, tailRing);
937  return np;
938}
939
940KINLINE poly k_LmInit_currRing_2_tailRing(poly p, ring tailRing)
941{
942  return k_LmInit_currRing_2_tailRing(p, tailRing, tailRing->PolyBin);
943}
944
945KINLINE poly k_LmInit_tailRing_2_currRing(poly p, ring tailRing)
946{
947  return  k_LmInit_tailRing_2_currRing(p, tailRing, currRing->PolyBin);
948}
949
950KINLINE poly k_LmShallowCopyDelete_currRing_2_tailRing(poly p, ring tailRing)
951{
952  return k_LmShallowCopyDelete_currRing_2_tailRing(p, tailRing, tailRing->PolyBin);
953}
954
955KINLINE poly k_LmShallowCopyDelete_tailRing_2_currRing(poly p, ring tailRing)
956{
957  return  k_LmShallowCopyDelete_tailRing_2_currRing(p, tailRing, currRing->PolyBin);
958}
959
960/***************************************************************
961 *
962 * Lcm business
963 *
964 ***************************************************************/
965// get m1 = LCM(LM(p1), LM(p2))/LM(p1)
966//     m2 = LCM(LM(p1), LM(p2))/LM(p2)
967KINLINE BOOLEAN k_GetLeadTerms(const poly p1, const poly p2, const ring p_r,
968                               poly &m1, poly &m2, const ring m_r)
969{
970  p_LmCheckPolyRing(p1, p_r);
971  p_LmCheckPolyRing(p2, p_r);
972
973  int i;
974  long x;
975  m1 = p_Init(m_r);
976  m2 = p_Init(m_r);
977
978  for (i = p_r->N; i; i--)
979  {
980    x = p_GetExpDiff(p1, p2, i, p_r);
981    if (x > 0)
982    {
983      if (x > (long) m_r->bitmask) goto false_return;
984      p_SetExp(m2,i,x, m_r);
985      p_SetExp(m1,i,0, m_r);
986    }
987    else
988    {
989      if (-x > (long) m_r->bitmask) goto false_return;
990      p_SetExp(m1,i,-x, m_r);
991      p_SetExp(m2,i,0, m_r);
992    }
993  }
994
995  p_Setm(m1, m_r);
996  p_Setm(m2, m_r);
997  return TRUE;
998
999  false_return:
1000  p_LmFree(m1, m_r);
1001  p_LmFree(m2, m_r);
1002  m1 = m2 = NULL;
1003  return FALSE;
1004}
1005
1006#ifdef HAVE_RINGS
1007// get m1 = LCM(LM(p1), LM(p2))/LM(p1)
1008//     m2 = LCM(LM(p1), LM(p2))/LM(p2)   in tailRing
1009//    lcm = LCM(LM(p1), LM(p2)           in leadRing
1010KINLINE void k_GetStrongLeadTerms(const poly p1, const poly p2, const ring leadRing,
1011                               poly &m1, poly &m2, poly &lcm, const ring tailRing)
1012{
1013  p_LmCheckPolyRing(p1, leadRing);
1014  p_LmCheckPolyRing(p2, leadRing);
1015
1016  int i;
1017  int x;
1018  int e1;
1019  int e2;
1020  int s;
1021  m1 = p_Init(tailRing);
1022  m2 = p_Init(tailRing);
1023  lcm = p_Init(leadRing);
1024
1025  for (i = leadRing->N; i>=1; i--)
1026  {
1027    e1 = p_GetExp(p1,i,leadRing);
1028    e2 = p_GetExp(p2,i,leadRing);
1029    x = e1 - e2;
1030    if (x > 0)
1031    {
1032      p_SetExp(m2,i,x, tailRing);
1033      //p_SetExp(m1,i,0, tailRing); // done by p_Init
1034      s = e1;
1035    }
1036    else
1037    {
1038      p_SetExp(m1,i,-x, tailRing);
1039      //p_SetExp(m2,i,0, tailRing); // done by p_Init
1040      s = e2;
1041    }
1042    p_SetExp(lcm,i,s, leadRing);
1043  }
1044  if ((s=pGetComp(p1))!=0)
1045  {
1046    p_SetComp(lcm,s, leadRing);
1047  } 
1048  else if ((s=pGetComp(p2))!=0)
1049  {
1050    p_SetComp(lcm,s, leadRing);
1051  } 
1052  // else p_SetComp(lcm,0,tailRing); // done by p_Init
1053
1054  p_Setm(m1, tailRing);
1055  p_Setm(m2, tailRing);
1056  p_Setm(lcm, leadRing);
1057}
1058#endif
1059
1060/***************************************************************
1061 *
1062 * Misc things
1063 *
1064 ***************************************************************/
1065KINLINE int ksReducePolyTail(LObject* PR, TObject* PW, LObject* Red)
1066{
1067  BOOLEAN ret;
1068  number coef;
1069
1070  assume(PR->GetLmCurrRing() != PW->GetLmCurrRing());
1071  Red->HeadNormalize();
1072  ret = ksReducePoly(Red, PW, NULL, &coef);
1073
1074  if (!ret)
1075  {
1076    if (! n_IsOne(coef, currRing->cf))
1077    {
1078      PR->Mult_nn(coef);
1079      // HANNES: mark for Normalize
1080    }
1081    n_Delete(&coef, currRing->cf);
1082  }
1083  return ret;
1084}
1085
1086/***************************************************************
1087 *
1088 * Routines for backwards-Compatibility
1089 *
1090 *
1091 ***************************************************************/
1092KINLINE poly ksOldSpolyRed(poly p1, poly p2, poly spNoether)
1093{
1094  LObject L(p2);
1095  TObject T(p1);
1096
1097  ksReducePoly(&L, &T, spNoether);
1098
1099  return L.GetLmCurrRing();
1100}
1101
1102KINLINE poly ksOldSpolyRedNew(poly p1, poly p2, poly spNoether)
1103{
1104  LObject L(p_Copy(p2, currRing));
1105  TObject T(p1);
1106
1107  ksReducePoly(&L, &T, spNoether);
1108
1109  return L.GetLmCurrRing();
1110}
1111
1112KINLINE poly ksOldCreateSpoly(poly p1, poly p2, poly spNoether, ring r)
1113{
1114  LObject L(r);
1115  L.p1 = p1;
1116  L.p2 = p2;
1117
1118  ksCreateSpoly(&L, spNoether);
1119  return L.GetLmCurrRing();
1120}
1121
1122void ksOldSpolyTail(poly p1, poly q, poly q2, poly spNoether, ring r)
1123{
1124  LObject L(q,  currRing, r);
1125  TObject T(p1, currRing, r);
1126
1127  ksReducePolyTail(&L, &T, q2, spNoether);
1128}
1129
1130KINLINE poly redtailBba (poly p,int pos,kStrategy strat,BOOLEAN normalize)
1131{
1132  LObject L(p, currRing, strat->tailRing);
1133  return redtailBba(&L, pos, strat,FALSE, normalize);
1134}
1135
1136#ifdef HAVE_RINGS
1137KINLINE poly redtailBba_Z (poly p,int pos,kStrategy strat)
1138{
1139  LObject L(p, currRing, strat->tailRing);
1140  return redtailBba_Z(&L, pos, strat);
1141}
1142#endif
1143
1144KINLINE poly redtailBba(TObject *T, int pos,kStrategy strat)
1145{
1146  LObject L;
1147  L = *T;
1148  poly p = redtailBba(&L, pos, strat, FALSE);
1149  *T = L;
1150  //kTest_T(T);
1151  assume( p == T->p);
1152  return p;
1153}
1154
1155KINLINE void clearS (poly p, unsigned long p_sev, int* at, int* k,
1156                    kStrategy strat)
1157{
1158  assume(p_sev == pGetShortExpVector(p));
1159  if (strat->noClearS) return;
1160  if (!pLmShortDivisibleBy(p,p_sev, strat->S[*at], ~ strat->sevS[*at])) return;
1161  deleteInS((*at),strat);
1162  (*at)--;
1163  (*k)--;
1164}
1165
1166// dummy function for function pointer strat->rewCrit being usable in all
1167// possible choices for criteria
1168KINLINE BOOLEAN arriRewDummy(poly /*sig*/, unsigned long /*not_sevSig*/, kStrategy /*strat*/, int start=0)
1169{
1170  return FALSE;
1171}
1172
1173#endif // defined(KINLINE) || defined(KUTIL_CC)
1174#endif // KINLINE_H
Note: See TracBrowser for help on using the repository browser.