My Project
kInline.h
Go to the documentation of this file.
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"
23#include "polys/kbuckets.h"
24
25#include "kernel/polys.h"
26
27#ifdef HAVE_SHIFTBBA
28#include "polys/shiftop.h"
29#endif
30
31
32#define HAVE_TAIL_BIN
33// This doesn't really work, fixme, if necessary
34// #define HAVE_LM_BIN
35
36
37
39{
40 assume(i>= 0 && i<=sl);
41 assume(S_2_R[i] >= 0 && S_2_R[i] <= tl);
42 TObject* TT = R[S_2_R[i]];
43 assume(TT != NULL && TT->p == S[i]);
44 return TT;
45}
46
48{
49 if (i >= 0 && i <= sl)
50 {
51 int sri= S_2_R[i];
52 if ((sri >= 0) && (sri <= tl))
53 {
54 TObject* t = R[sri];
55 if ((t != NULL) && (t->p == S[i]))
56 return t;
57 }
58 // last but not least, try kFindInT
59 sri = kFindInT(S[i], T, tl);
60 if (sri >= 0)
61 return &(T[sri]);
62 }
63 return NULL;
64}
65
67{
68 if (tailRing == currRing)
69 return kNoether;
70 else
71 {
72 assume((kNoether == NULL && t_kNoether == NULL) ||
73 (kNoether != NULL && t_kNoether != NULL));
74 return t_kNoether;
75 }
76}
77
78/***************************************************************
79 *
80 * Operation on TObjects
81 *
82 ***************************************************************/
83
85{
86 TSet T = (TSet)omAlloc0(setmaxT*sizeof(TObject));
87 for (int i=setmaxT-1; i>=0; i--)
88 {
89 T[i].tailRing = currRing;
90 T[i].i_r = -1;
91 }
92 return T;
93}
94
96{
97 return (TObject**) omAlloc0(setmaxT*sizeof(TObject*));
98}
99
100KINLINE unsigned long* initsevT()
101{
102 return (unsigned long*) omAlloc0(setmaxT*sizeof(unsigned long));
103}
104
105// initialization
107{
108 tailRing = r;
109}
111{
112 memset(this, 0, sizeof(sTObject));
113 i_r = -1;
114 Set(r);
115}
117{
118 Init(r);
119}
120KINLINE void sTObject::Set(poly p_in, ring r)
121{
122 if (r != currRing)
123 {
124 assume(r == tailRing);
125#ifdef HAVE_SHIFTBBA
126 if (r->isLPring)
127 {
128 shift = si_max(p_mFirstVblock(p_in, r) - 1, 0);
129 if (!shift) p_Test(p_in, r);
130 }
131 else
132#endif
133 {
134 p_Test(p_in, r);
135 }
136 t_p = p_in;
137 }
138 else
139 {
140#ifdef HAVE_SHIFTBBA
141 if (currRing->isLPring)
142 {
143 shift = si_max(p_mFirstVblock(p_in, currRing) - 1, 0);
144 if (!shift) p_Test(p_in, currRing);
145 }
146 else
147#endif
148 {
149 p_Test(p_in, currRing);
150 }
151 p = p_in;
152 }
153 pLength=::pLength(p_in);
154}
155
156KINLINE sTObject::sTObject(poly p_in, ring r)
157{
158 Init(r);
159 Set(p_in, r);
160}
161
162KINLINE void sTObject::Set(poly p_in, ring c_r, ring t_r)
163{
164 if (c_r != t_r)
165 {
166 assume(c_r == currRing && t_r == tailRing);
167#ifdef HAVE_SHIFTBBA
168 if (c_r->isLPring)
169 {
170 shift = si_max(p_mFirstVblock(p_in, c_r) - 1, 0);
171 if (!shift) p_Test(p_in, currRing);
172 }
173 else
174#endif
175 {
176 p_Test(p_in, currRing);
177 }
178 p = p_in;
179 pLength=::pLength(p_in);
180 }
181 else
182 {
183 Set(p_in, c_r);
184 }
185}
186
187KINLINE sTObject::sTObject(poly p_in, ring c_r, ring t_r)
188{
189 Init(t_r);
190 Set(p_in, c_r, t_r);
191}
192
194{
195 *this = *T;
196 if (copy)
197 {
198 if (t_p != NULL)
199 {
202 }
203 else
204 {
205 p = p_Copy(p, currRing);
206 }
207 }
208}
209
211{
212 if (t_p != NULL)
213 {
215 if (p != NULL)
217 }
218 else
219 {
221 }
222}
223
225{
226 p = NULL;
227 t_p = NULL;
228 ecart = 0;
229 length = 0;
230 pLength = 0;
231 FDeg = 0;
233}
234
236{
237 if (t_p != NULL)
238 {
240 if (p != NULL) /* and t_p!=NULL*/
241 {
242 p = p_LmInit(p, currRing);
244 pNext(p) = pNext(t_p);
245 }
246 }
247 else
248 {
249 p = p_Copy(p, currRing);
250 }
251}
252
254{
255 if (p == NULL && t_p != NULL)
257
258 return p;
259}
261{
262 if (t_p == NULL)
263 {
264 if (p != NULL && tailRing != currRing)
265 {
267 return t_p;
268 }
269 return p;
270 }
271 return t_p;
272}
274{
275 assume(r == tailRing || r == currRing);
276 if (r == currRing)
277 return GetLmCurrRing();
278
279 if (t_p == NULL && p != NULL)
281
282 return t_p;
283}
284
285KINLINE void sTObject::GetLm(poly &p_r, ring &r_r) const
286{
287 if (t_p != NULL)
288 {
289 p_r = t_p;
290 r_r = tailRing;
291 }
292 else
293 {
294 p_r = p;
295 r_r = currRing;
296 }
297}
298
300{
301 return (p == NULL && t_p == NULL);
302}
303
305{
306 if (pLength <= 0) pLength = ::pLength(p != NULL ? p : t_p);
307 return pLength;
308}
309
311{
312 if (p == NULL && t_p != NULL)
314}
315
317{
318 assume(p != NULL || t_p != NULL);
319 if (t_p != NULL) return pNext(t_p);
320 return pNext(p);
321}
322
323// Iterations
325{
326 assume(p != NULL || t_p != NULL);
327 if (t_p != NULL)
328 {
330 if (p != NULL)
331 {
333 p = NULL;
334 }
335 }
336 else
337 {
339 }
341}
342
343
344// arithmetic
346{
347 if (t_p != NULL)
348 {
349 t_p = p_Mult_nn(t_p, n, tailRing);
350 if (p != NULL) pSetCoeff0(p, pGetCoeff(t_p));
351 }
352 else
353 {
354 p = p_Mult_nn(p, n, currRing, tailRing);
355 }
356}
357
359{
360 if (t_p != NULL)
361 {
363 if (p != NULL) pSetCoeff0(p, pGetCoeff(t_p));
364 }
365 else
366 {
367 pNormalize(p);
368 }
370}
371
373{
374 if (bucket != NULL)
376}
377
379{
380 if (t_p != NULL)
381 {
383 if (p != NULL) pSetCoeff0(p, pGetCoeff(t_p));
384 }
385 else
386 {
388 }
389}
390
391KINLINE void
392sTObject::ShallowCopyDelete(ring new_tailRing, omBin new_tailBin,
393 pShallowCopyDeleteProc p_shallow_copy_delete,
394 BOOLEAN set_max)
395{
396 if (new_tailBin == NULL) new_tailBin = new_tailRing->PolyBin;
397 if (t_p != NULL)
398 {
399 t_p = p_shallow_copy_delete(t_p, tailRing, new_tailRing, new_tailBin);
400 if (p != NULL)
401 pNext(p) = pNext(t_p);
402 if (new_tailRing == currRing)
403 {
404 if (p == NULL) p = t_p;
405 else p_LmFree(t_p, tailRing);
406 t_p = NULL;
407 }
408 }
409 else if (p != NULL) /* && t_p==NULL */
410 {
411 if (pNext(p) != NULL)
412 {
413 pNext(p) = p_shallow_copy_delete(pNext(p),
414 tailRing, new_tailRing, new_tailBin);
415 }
416 if (new_tailRing != currRing)
417 {
418 t_p = k_LmInit_currRing_2_tailRing(p, new_tailRing);
419 pNext(t_p) = pNext(p);
420 }
421 }
422 if (max_exp != NULL)
423 {
424 max_exp = p_shallow_copy_delete(max_exp,tailRing,new_tailRing,new_tailBin);
425 }
426 else if (set_max && pNext(t_p) != NULL)
427 {
428 max_exp = p_GetMaxExpP(pNext(t_p), new_tailRing);
429 }
430 tailRing = new_tailRing;
431}
432
434{
435 if (p != NULL) return p_FDeg(p, currRing);
436 return tailRing->pFDeg(t_p, tailRing);
437}
439{
440 if (p != NULL) return p_Totaldegree(p, currRing);
441 return p_Totaldegree(t_p,tailRing);
442}
444{
445 FDeg = this->pFDeg();
446 return FDeg;
447}
449{
450 assume(FDeg == this->pFDeg());
451 return FDeg;
452}
454{
455 return tailRing->pLDeg(GetLmTailRing(), &length, tailRing);
456}
458{
459 FDeg = this->pFDeg();
460 long d = this->pLDeg();
461 ecart = d - FDeg;
462 return d;
463}
464
465//extern void pCleardenom(poly p);
466// extern void pNorm(poly p);
467
468// manipulations
470{
471 assume(p != NULL);
473 {
474 number n;
475 if (t_p != NULL)
476 {
479 }
480 else
481 {
483 }
484 if (!nIsOne(n))
485 {
487 denom->n=nInvers(n);
488 denom->next=DENOMINATOR_LIST;
489 DENOMINATOR_LIST=denom;
490 }
491 nDelete(&n);
492 }
493 else
494 {
495 if (t_p != NULL)
496 {
499 }
500 else
501 {
503 }
504 }
505}
506
508{
509 assume(p != NULL);
510 if (t_p != NULL)
511 {
514 {
516 }
518 }
519 else
520 {
523 {
524 p=p_Neg (p,currRing);
525 }
526 }
527}
528
529KINLINE void sTObject::pNorm() // pNorm seems to be a _bad_ method name...
530{
531 assume(p != NULL);
532 if (! is_normalized)
533 {
534 p_Norm(p, currRing);
535 if (t_p != NULL)
538 }
539}
540
541
542
543/***************************************************************
544 *
545 * Operation on LObjects
546 *
547 ***************************************************************/
548// Initialization
550{
552 sev = 0;
553}
554// Initialization
556{
558 if (bucket != NULL)
560}
561
563{
564 memset(this, 0, sizeof(sLObject));
565 i_r1 = -1;
566 i_r2 = -1;
567 i_r = -1;
568 Set(r);
569}
571{
572 Init(r);
573}
574KINLINE sLObject::sLObject(poly p_in, ring r)
575{
576 Init(r);
577 Set(p_in, r);
578}
579
580KINLINE sLObject::sLObject(poly p_in, ring c_r, ring t_r)
581{
582 Init(t_r);
583 Set(p_in, c_r, t_r);
584}
585
587{
588 if (bucket == NULL)
589 {
590 unsigned l = GetpLength();
591 if (use_bucket && (l > 1))
592 {
593 poly tp = GetLmTailRing();
594 assume(l == ::pLength(tp));
596 kBucketInit(bucket, pNext(tp), l-1);
597 pNext(tp) = NULL;
598 if (p != NULL) pNext(p) = NULL;
599 pLength = 0;
600 }
601 }
602}
603
604KINLINE void sLObject::SetLmTail(poly lm, poly p_tail, int p_Length, int use_bucket, ring _tailRing)
605{
606
607 Set(lm, _tailRing);
608 if (use_bucket)
609 {
610 bucket = kBucketCreate(_tailRing);
611 kBucketInit(bucket, p_tail, p_Length);
612 pNext(lm) = NULL;
613 pLength = 0;
614 }
615 else
616 {
617 pNext(lm) = p_tail;
618 pLength = p_Length + 1;
619 }
620}
621
623{
624 if (bucket != NULL)
625 {
627 }
628 else
629 {
630 poly _p = (t_p != NULL ? t_p : p);
631 assume(_p != NULL);
632 pNext(_p) = __p_Mult_nn(pNext(_p), n, tailRing);
633 }
634}
635
637 poly spNoether)
638{
639 if (bucket != NULL)
640 {
641 kBucket_Minus_m_Mult_p(bucket, m, q, &lq, spNoether);
642 }
643 else
644 {
645 if (lq<=0) lq= ::pLength(q);
646 poly _p = (t_p != NULL ? t_p : p);
647 assume(_p != NULL);
648
649 int lp=pLength-1;
650 pNext(_p) = p_Minus_mm_Mult_qq( pNext(_p), m, q, lp, lq,
651 spNoether, tailRing );
652 pLength=lp+1;
653// tailRing->p_Procs->p_Minus_mm_Mult_qq(pNext(_p), m, q, shorter,spNoether, tailRing, last);
654// pLength += lq - shorter;
655 }
656}
657
659{
661 if (bucket != NULL)
662 {
663 poly _p = kBucketExtractLm(bucket);
664 if (_p == NULL)
665 {
667 p = t_p = NULL;
668 return;
669 }
670 Set(_p, tailRing);
671 }
672 else
673 {
674 pLength--;
675 }
676}
677
679{
680 poly ret = GetLmTailRing();
681 poly pn;
682
683 assume(p != NULL || t_p != NULL);
684
685 if (bucket != NULL)
686 {
688 if (pn == NULL)
690 }
691 else
692 {
693 pn = pNext(ret);
694 }
695 pLength--;
696 pNext(ret) = NULL;
697 if (p != NULL && t_p != NULL)
699
700 Set(pn, tailRing);
701 return ret;
702}
703
705{
706 //kTest_L(this);
707 poly tp = GetLmTailRing();
708 assume(tp != NULL);
709
710 if (bucket != NULL)
711 {
714 pLength++;
715 }
716 return tp;
717}
718
719
721{
722 //kTest_L(this);
723 if (p == NULL)
724 {
726 ((lmBin!=NULL)?lmBin:currRing->PolyBin));
727 FDeg = pFDeg();
728 }
729 else if ((lmBin != NULL) && (lmBin != currRing->PolyBin))
730 {
732 FDeg = pFDeg();
733 }
734
735 if (bucket != NULL)
736 {
739 pLength++;
740 if (t_p != NULL) pNext(t_p) = pNext(p);
741 }
742 //kTest_L(this);
743 return p;
744}
745
746KINLINE void
748 pShallowCopyDeleteProc p_shallow_copy_delete)
749{
750 if (bucket != NULL)
751 kBucketShallowCopyDelete(bucket, new_tailRing, new_tailRing->PolyBin,
752 p_shallow_copy_delete);
753 sTObject::ShallowCopyDelete(new_tailRing,
754 new_tailRing->PolyBin,p_shallow_copy_delete,
755 FALSE);
756}
757
759{
760 if (t_p != NULL)
761 {
763 }
764 else
765 {
767 }
768}
769
771{
772 if (bucket != NULL)
773 {
775 kBucket_pt new_bucket = kBucketCreate(tailRing);
776 kBucketInit(new_bucket,
777 p_Copy(bucket->buckets[i], tailRing),
778 bucket->buckets_length[i]);
779 bucket = new_bucket;
780 if (t_p != NULL) pNext(t_p) = NULL;
781 if (p != NULL) pNext(p) = NULL;
782 }
784}
785
787{
788 poly tp = GetLmTailRing();
789 assume(tp != NULL);
790 if (bucket != NULL)
791 {
793 pNext(tp) = bucket->buckets[i];
794 long ldeg = tailRing->pLDeg(tp, &length, tailRing);
795 pNext(tp) = NULL;
796 return ldeg;
797 }
798 else
799 return tailRing->pLDeg(tp, &length, tailRing);
800}
802{
803 if (! deg_last || bucket != NULL) return sLObject::pLDeg();
804
805 long ldeg;
806 ldeg = tailRing->pLDeg(GetLmTailRing(), &length, tailRing);
807#ifndef SING_NDEBUG
808 if ( pLength == 0)
811#else
813#endif
814 return ldeg;
815}
816
818{
819 FDeg = this->pFDeg();
820 long d = this->pLDeg();
821 ecart = d - FDeg;
822 return d;
823}
825{
826 FDeg = this->pFDeg();
827 long d = this->pLDeg(use_last);
828 ecart = d - FDeg;
829 return d;
830}
832{
833 if (bucket == NULL)
834 return sTObject::GetpLength();
836 return bucket->buckets_length[i] + 1;
837}
839{
840 if (length_pLength)
841 {
842 length = this->GetpLength();
843 }
844 else
845 this->pLDeg();
846 return length;
847}
849{
850 poly tp = GetLmTailRing();
851 assume(tp != NULL);
852 if (bucket != NULL)
853 {
855 pNext(tp) = bucket->buckets[i];
856 long m = p_MinComp(tp, tailRing);
857 pNext(tp) = NULL;
858 return m;
859 }
860 else
861 return p_MinComp(tp, tailRing);
862}
864{
865 poly pp;
866 ring r;
867 GetLm(pp, r);
868 assume(pp != NULL);
869 return p_GetComp(pp, r);
870}
871
873{
874 memset(this, 0, sizeof(*this));
875 memcpy(this, &t, sizeof(sTObject));
876 return *this;
877}
878
880{
881 if (p1 == NULL) return NULL;
882 if (i_r1 == -1) i_r1 = kFindInT(p1, s->T, s->tl);
883 assume(i_r1 >= 0 && i_r1 <= s->tl);
884 TObject* T = s->R[i_r1];
885 assume(T->p == p1);
886 return T;
887}
888
890{
891 if (p1 == NULL) return NULL;
892 assume(p2 != NULL);
893 if (i_r2 == -1) i_r2 = kFindInT(p2, strat->T, strat->tl);
894 assume(i_r2 >= 0 && i_r2 <= strat->tl);
895 TObject* T = strat->R[i_r2];
896 assume(T->p == p2);
897 return T;
898}
899
901 TObject* &T_1, TObject* &T_2)
902{
903 if (p1 == NULL)
904 {
905 T_1 = NULL;
906 T_2 = NULL;
907 return;
908 }
909 assume(p1 != NULL && p2 != NULL);
910 if (i_r1 == -1) i_r1 = kFindInT(p1, strat->T, strat->tl);
911 if (i_r2 == -1) i_r2 = kFindInT(p2, strat->T, strat->tl);
912 assume(i_r1 >= 0 && i_r1 <= strat->tl);
913 assume(i_r2 >= 0 && i_r2 <= strat->tl);
914 T_1 = strat->R[i_r1];
915 T_2 = strat->R[i_r2];
916 assume(T_1->p == p1);
917 assume(T_2->p == p2);
918 return;
919}
920
921/***************************************************************
922 *
923 * Conversion of polys
924 *
925 ***************************************************************/
926
927KINLINE poly k_LmInit_currRing_2_tailRing(poly p, ring tailRing, omBin tailBin)
928{
929
930 poly t_p = p_LmInit(p, currRing, tailRing, tailBin);
931 pNext(t_p) = pNext(p);
932 pSetCoeff0(t_p, pGetCoeff(p));
933 return t_p;
934}
935
936KINLINE poly k_LmInit_tailRing_2_currRing(poly t_p, ring tailRing, omBin lmBin)
937{
938 poly p = p_LmInit(t_p, tailRing, currRing, lmBin);
939 pNext(p) = pNext(t_p);
940 pSetCoeff0(p, pGetCoeff(t_p));
941 return p;
942}
943
944// this should be made more efficient
946{
947 poly np = k_LmInit_currRing_2_tailRing(p, tailRing, tailBin);
949 return np;
950}
951
953{
954 poly np = k_LmInit_tailRing_2_currRing(p, tailRing, lmBin);
955 p_LmFree(p, tailRing);
956 return np;
957}
958
959KINLINE poly k_LmInit_currRing_2_tailRing(poly p, ring tailRing)
960{
961 return k_LmInit_currRing_2_tailRing(p, tailRing, tailRing->PolyBin);
962}
963
964KINLINE poly k_LmInit_tailRing_2_currRing(poly p, ring tailRing)
965{
966 return k_LmInit_tailRing_2_currRing(p, tailRing, currRing->PolyBin);
967}
968
970{
971 return k_LmShallowCopyDelete_currRing_2_tailRing(p, tailRing, tailRing->PolyBin);
972}
973
975{
976 return k_LmShallowCopyDelete_tailRing_2_currRing(p, tailRing, currRing->PolyBin);
977}
978
979/***************************************************************
980 *
981 * Lcm business
982 *
983 ***************************************************************/
984// get m1 = LCM(LM(p1), LM(p2))/LM(p1)
985// m2 = LCM(LM(p1), LM(p2))/LM(p2)
986KINLINE BOOLEAN k_GetLeadTerms(const poly p1, const poly p2, const ring p_r,
987 poly &m1, poly &m2, const ring m_r)
988{
989 p_LmCheckPolyRing(p1, p_r);
990 p_LmCheckPolyRing(p2, p_r);
991
992 int i;
993 long x;
994 m1 = p_Init(m_r,m_r->PolyBin);
995 m2 = p_Init(m_r,m_r->PolyBin);
996
997 for (i = p_r->N; i; i--)
998 {
999 x = p_GetExpDiff(p1, p2, i, p_r);
1000 if (x > 0)
1001 {
1002 if (x > (long) m_r->bitmask) goto false_return;
1003 p_SetExp(m2,i,x, m_r);
1004 p_SetExp(m1,i,0, m_r);
1005 }
1006 else
1007 {
1008 if (-x > (long) m_r->bitmask) goto false_return;
1009 p_SetExp(m1,i,-x, m_r);
1010 p_SetExp(m2,i,0, m_r);
1011 }
1012 }
1013
1014 p_Setm(m1, m_r);
1015 p_Setm(m2, m_r);
1016 return TRUE;
1017
1018 false_return:
1019 p_LmFree(m1, m_r);
1020 p_LmFree(m2, m_r);
1021 m1 = m2 = NULL;
1022 return FALSE;
1023}
1024
1025#ifdef HAVE_RINGS
1026// get m1 = LCM(LM(p1), LM(p2))/LM(p1)
1027// m2 = LCM(LM(p1), LM(p2))/LM(p2) in tailRing
1028// lcm = LCM(LM(p1), LM(p2)) in leadRing
1029KINLINE void k_GetStrongLeadTerms(const poly p1, const poly p2, const ring leadRing,
1030 poly &m1, poly &m2, poly &lcm, const ring tailRing)
1031{
1032 p_LmCheckPolyRing(p1, leadRing);
1033 p_LmCheckPolyRing(p2, leadRing);
1034
1035 int i;
1036 int x;
1037 int e1;
1038 int e2;
1039 int s;
1040 m1 = p_Init(tailRing,tailRing->PolyBin);
1041 m2 = p_Init(tailRing,tailRing->PolyBin);
1042 lcm = p_Init(leadRing,leadRing->PolyBin);
1043
1044 for (i = leadRing->N; i>=0; i--)
1045 {
1046 e1 = p_GetExp(p1,i,leadRing);
1047 e2 = p_GetExp(p2,i,leadRing);
1048 x = e1 - e2;
1049 if (x > 0)
1050 {
1051 p_SetExp(m2,i,x, tailRing);
1052 //p_SetExp(m1,i,0, tailRing); // done by p_Init
1053 s = e1;
1054 }
1055 else if (x<0)
1056 {
1057 p_SetExp(m1,i,-x, tailRing);
1058 //p_SetExp(m2,i,0, tailRing); // done by p_Init
1059 s = e2;
1060 }
1061 else
1062 s = e1; // e1==e2
1063 p_SetExp(lcm,i,s, leadRing);
1064 }
1065
1066 p_Setm(m1, tailRing);
1067 p_Setm(m2, tailRing);
1068 p_Setm(lcm, leadRing);
1069}
1070#endif
1071
1072/***************************************************************
1073 *
1074 * Misc things
1075 *
1076 ***************************************************************/
1078{
1079 BOOLEAN ret;
1080 number mult, rest;
1081 TObject red = *PW;
1082 red.Copy();
1083 rest = n_QuotRem(pGetCoeff(Red->p), pGetCoeff(red.p),
1084 &mult, currRing->cf);
1085 red.Mult_nn(rest);
1086
1087 assume(PR->GetLmCurrRing() != red.GetLmCurrRing());
1088 ret = ksReducePolyLC(Red, &red, NULL, &mult);
1089 red.Delete();
1090 red.Clear();
1091
1092 return ret;
1093}
1094
1096{
1097 BOOLEAN ret;
1098 number coef;
1099
1100 assume(PR->GetLmCurrRing() != PW->GetLmCurrRing());
1101 ret = ksReducePoly(Red, PW, NULL, &coef);
1102
1103 if (!ret)
1104 {
1105 if (! n_IsOne(coef, currRing->cf))
1106 {
1107 PR->Mult_nn(coef);
1108 // HANNES: mark for Normalize
1109 }
1110 n_Delete(&coef, currRing->cf);
1111 }
1112 return ret;
1113}
1114
1116{
1117 BOOLEAN ret;
1118 number coef;
1119
1120 assume(PR->GetLmCurrRing() != PW->GetLmCurrRing());
1121 Red->HeadNormalize();
1122 ret = ksReducePoly(Red, PW, NULL, &coef);
1123
1124 if (!ret)
1125 {
1126 if (! n_IsOne(coef, currRing->cf))
1127 {
1128 PR->Mult_nn(coef);
1129 // HANNES: mark for Normalize
1130 }
1131 n_Delete(&coef, currRing->cf);
1132 }
1133 return ret;
1134}
1135
1136/***************************************************************
1137 *
1138 * Routines for backwards-Compatibility
1139 *
1140 *
1141 ***************************************************************/
1142KINLINE poly ksOldSpolyRed(poly p1, poly p2, poly spNoether)
1143{
1144 LObject L(p2);
1145 TObject T(p1);
1146
1147 ksReducePoly(&L, &T, spNoether);
1148
1149 return L.GetLmCurrRing();
1150}
1151
1152KINLINE poly ksOldSpolyRedNew(poly p1, poly p2, poly spNoether)
1153{
1154 LObject L(p_Copy(p2, currRing));
1155 TObject T(p1);
1156
1157 ksReducePoly(&L, &T, spNoether);
1158
1159 return L.GetLmCurrRing();
1160}
1161
1162KINLINE poly ksOldCreateSpoly(poly p1, poly p2, poly spNoether, ring r)
1163{
1164 LObject L(r);
1165 L.p1 = p1;
1166 L.p2 = p2;
1167
1168 ksCreateSpoly(&L, spNoether);
1169 return L.GetLmCurrRing();
1170}
1171
1172void ksOldSpolyTail(poly p1, poly q, poly q2, poly spNoether, ring r)
1173{
1174 LObject L(q, currRing, r);
1175 TObject T(p1, currRing, r);
1176
1177 ksReducePolyTail(&L, &T, q2, spNoether);
1178}
1179
1181{
1182 LObject L(p);
1183 return redtailBba(&L, pos, strat,FALSE, normalize);
1184}
1185
1187{
1188 LObject L(p, currRing, strat->tailRing); // ? L(p); ??
1189 return redtailBbaBound(&L, pos, strat,bound, FALSE, normalize);
1190}
1191
1192#ifdef HAVE_RINGS
1193KINLINE poly redtailBba_Ring (poly p,int pos,kStrategy strat)
1194{
1195 LObject L(p, currRing, strat->tailRing);
1196 return redtailBba_Ring(&L, pos, strat);
1197}
1198KINLINE poly redtailBba_Z (poly p,int pos,kStrategy strat)
1199{
1200 LObject L(p, currRing, strat->tailRing);
1201 return redtailBba_Z(&L, pos, strat);
1202}
1203#endif
1204
1205KINLINE void clearS (poly p, unsigned long p_sev, int* at, int* k,
1206 kStrategy strat)
1207{
1208 assume(p_sev == pGetShortExpVector(p));
1209 if (strat->noClearS) return;
1210 #ifdef HAVE_RINGS
1212 {
1213 if (!pLmShortDivisibleBy(p,p_sev, strat->S[*at], ~ strat->sevS[*at]))
1214 return;
1215 if(!n_DivBy(pGetCoeff(strat->S[*at]), pGetCoeff(p), currRing->cf))
1216 return;
1217 }
1218 else
1219 #endif
1220 {
1221 if (!pLmShortDivisibleBy(p,p_sev, strat->S[*at], ~ strat->sevS[*at])) return;
1222 }
1223 deleteInS((*at),strat);
1224 (*at)--;
1225 (*k)--;
1226}
1227
1228// dummy function for function pointer strat->rewCrit being usable in all
1229// possible choices for criteria
1230KINLINE BOOLEAN arriRewDummy(poly /*sig*/, unsigned long /*not_sevSig*/, poly /*lm*/, kStrategy /*strat*/, int /*start=0*/)
1231{
1232 return FALSE;
1233}
1234
1235#endif // defined(KINLINE) || defined(KUTIL_CC)
1236#endif // KINLINE_H
#define NULL
Definition: auxiliary.h:104
static int si_max(const int a, const int b)
Definition: auxiliary.h:124
int BOOLEAN
Definition: auxiliary.h:87
#define TRUE
Definition: auxiliary.h:100
#define FALSE
Definition: auxiliary.h:96
CanonicalForm pp(const CanonicalForm &)
CanonicalForm pp ( const CanonicalForm & f )
Definition: cf_gcd.cc:676
CanonicalForm lcm(const CanonicalForm &, const CanonicalForm &)
CanonicalForm lcm ( const CanonicalForm & f, const CanonicalForm & g )
Definition: cf_gcd.cc:763
CanonicalForm normalize(const CanonicalForm &F)
normalize a poly, i.e. in char 0 clear denominators, remove integer content in char p divide by leadi...
int l
Definition: cfEzgcd.cc:100
int m
Definition: cfEzgcd.cc:128
int i
Definition: cfEzgcd.cc:132
int k
Definition: cfEzgcd.cc:99
void mult(CFList &L1, const CFList &L2)
multiply two lists componentwise
Definition: cfModGcd.cc:2178
Variable x
Definition: cfModGcd.cc:4084
int p
Definition: cfModGcd.cc:4080
static CanonicalForm bound(const CFMatrix &M)
Definition: cf_linsys.cc:460
KINLINE long SetDegStuffReturnLDeg()
Definition: kInline.h:817
KINLINE void Tail_Mult_nn(number n)
Definition: kInline.h:622
int i_r1
Definition: kutil.h:193
KINLINE void Copy()
Definition: kInline.h:770
KINLINE void Delete()
Definition: kInline.h:555
KINLINE void LmDeleteAndIter()
Definition: kInline.h:658
KINLINE TObject * T_2(const skStrategy *strat)
Definition: kInline.h:889
KINLINE void PrepareRed(BOOLEAN use_bucket)
Definition: kInline.h:586
KINLINE void CanonicalizeP()
Definition: kInline.h:372
KINLINE void SetLmTail(poly lm, poly new_p, int length, int use_bucket, ring r)
Definition: kInline.h:604
KINLINE void T_1_2(const skStrategy *strat, TObject *&T_1, TObject *&T_2)
Definition: kInline.h:900
KINLINE void Normalize()
Definition: kInline.h:358
unsigned long sev
Definition: kutil.h:187
KINLINE void Init(ring tailRing=currRing)
Definition: kInline.h:562
KINLINE long MinComp()
Definition: kInline.h:848
kBucket_pt bucket
Definition: kutil.h:192
poly p2
Definition: kutil.h:188
KINLINE TObject * T_1(const skStrategy *strat)
Definition: kInline.h:879
KINLINE int GetpLength()
Definition: kInline.h:831
KINLINE int SetLength(BOOLEAN lengt_pLength=FALSE)
Definition: kInline.h:838
KINLINE void Clear()
Definition: kInline.h:549
KINLINE void Tail_Minus_mm_Mult_qq(poly m, poly qq, int lq, poly spNoether)
Definition: kInline.h:636
KINLINE void ShallowCopyDelete(ring new_tailRing, pShallowCopyDeleteProc p_shallow_copy_delete)
Definition: kInline.h:747
KINLINE poly GetTP()
Definition: kInline.h:704
KINLINE long pLDeg()
Definition: kInline.h:786
KINLINE sLObject & operator=(const sTObject &)
Definition: kInline.h:872
KINLINE void SetShortExpVector()
Definition: kInline.h:758
KINLINE void HeadNormalize()
Definition: kInline.h:378
KINLINE poly GetP(omBin lmBin=(omBin) NULL)
Definition: kInline.h:720
KINLINE sLObject(ring tailRing=currRing)
Definition: kInline.h:570
poly p1
Definition: kutil.h:188
KINLINE long Comp()
Definition: kInline.h:863
KINLINE poly LmExtractAndIter()
Definition: kInline.h:678
int i_r2
Definition: kutil.h:193
Definition: kutil.h:69
KINLINE poly GetLm(ring r)
Definition: kInline.h:273
KINLINE poly GetLmCurrRing()
Definition: kInline.h:253
KINLINE void Init(ring r=currRing)
Definition: kInline.h:110
KINLINE void Mult_nn(number n)
Definition: kInline.h:345
int length
Definition: kutil.h:79
KINLINE long SetDegStuffReturnLDeg()
Definition: kInline.h:457
KINLINE poly GetLmTailRing()
Definition: kInline.h:260
KINLINE void pCleardenom()
Definition: kInline.h:469
int ecart
Definition: kutil.h:78
KINLINE long GetpFDeg() const
Definition: kInline.h:448
KINLINE sTObject(ring tailRing=currRing)
Definition: kInline.h:116
KINLINE void ShallowCopyDelete(ring new_tailRing, omBin new_tailBin, pShallowCopyDeleteProc p_shallow_copy_delete, BOOLEAN set_max=TRUE)
Definition: kInline.h:392
KINLINE void SetLmCurrRing()
Definition: kInline.h:310
poly max_exp
Definition: kutil.h:75
char is_normalized
Definition: kutil.h:87
KINLINE long pLDeg()
Definition: kInline.h:453
KINLINE void LmDeleteAndIter()
Definition: kInline.h:324
int pLength
Definition: kutil.h:80
KINLINE long pFDeg() const
Definition: kInline.h:433
int i_r
Definition: kutil.h:81
poly p
Definition: kutil.h:73
KINLINE BOOLEAN IsNull() const
Definition: kInline.h:299
KINLINE void Set(ring r=currRing)
Definition: kInline.h:106
KINLINE void Delete()
Definition: kInline.h:210
poly t_p
Definition: kutil.h:74
ring tailRing
Definition: kutil.h:76
KINLINE int GetpLength()
Definition: kInline.h:304
KINLINE void pNorm()
Definition: kInline.h:529
KINLINE void Clear()
Definition: kInline.h:224
long FDeg
Definition: kutil.h:77
KINLINE poly Next()
Definition: kInline.h:316
int shift
Definition: kutil.h:84
KINLINE void pContent()
Definition: kInline.h:507
KINLINE long pTotalDeg() const
Definition: kInline.h:438
KINLINE long SetpFDeg()
Definition: kInline.h:443
KINLINE void Copy()
Definition: kInline.h:235
KINLINE poly kNoetherTail()
Definition: kInline.h:66
poly t_kNoether
Definition: kutil.h:334
int * S_2_R
Definition: kutil.h:345
ring tailRing
Definition: kutil.h:346
TSet T
Definition: kutil.h:327
polyset S
Definition: kutil.h:307
poly kNoether
Definition: kutil.h:331
TObject ** R
Definition: kutil.h:343
int tl
Definition: kutil.h:353
KINLINE TObject * s_2_t(int i)
Definition: kInline.h:47
KINLINE TObject * S_2_T(int i)
Definition: kInline.h:38
char noClearS
Definition: kutil.h:406
int sl
Definition: kutil.h:351
unsigned long * sevS
Definition: kutil.h:323
static FORCE_INLINE number n_QuotRem(number a, number b, number *q, const coeffs r)
Definition: coeffs.h:704
static FORCE_INLINE BOOLEAN n_GreaterZero(number n, const coeffs r)
ordered fields: TRUE iff 'n' is positive; in Z/pZ: TRUE iff 0 < m <= roundedBelow(p/2),...
Definition: coeffs.h:495
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete 'p'
Definition: coeffs.h:456
static FORCE_INLINE BOOLEAN n_DivBy(number a, number b, const coeffs r)
test whether 'a' is divisible 'b'; for r encoding a field: TRUE iff 'b' does not represent zero in Z:...
Definition: coeffs.h:777
static FORCE_INLINE BOOLEAN n_IsOne(number n, const coeffs r)
TRUE iff 'n' represents the one element.
Definition: coeffs.h:469
const CanonicalForm int s
Definition: facAbsFact.cc:51
CFArray copy(const CFList &list)
write elements of list into an array
static number Copy(number a, const coeffs)
Definition: flintcf_Q.cc:202
STATIC_VAR jList * T
Definition: janet.cc:30
KINLINE poly k_LmShallowCopyDelete_tailRing_2_currRing(poly p, ring tailRing, omBin lmBin)
Definition: kInline.h:952
KINLINE poly ksOldCreateSpoly(poly p1, poly p2, poly spNoether, ring r)
Definition: kInline.h:1162
KINLINE poly redtailBba_Ring(poly p, int pos, kStrategy strat)
Definition: kInline.h:1193
void ksOldSpolyTail(poly p1, poly q, poly q2, poly spNoether, ring r)
Definition: kInline.h:1172
KINLINE poly k_LmShallowCopyDelete_currRing_2_tailRing(poly p, ring tailRing, omBin tailBin)
Definition: kInline.h:945
KINLINE poly k_LmInit_currRing_2_tailRing(poly p, ring tailRing, omBin tailBin)
Definition: kInline.h:927
KINLINE TSet initT()
Definition: kInline.h:84
KINLINE void k_GetStrongLeadTerms(const poly p1, const poly p2, const ring leadRing, poly &m1, poly &m2, poly &lcm, const ring tailRing)
Definition: kInline.h:1029
KINLINE int ksReducePolyTailLC_Z(LObject *PR, TObject *PW, LObject *Red)
Definition: kInline.h:1077
KINLINE poly redtailBba(poly p, int pos, kStrategy strat, BOOLEAN normalize)
Definition: kInline.h:1180
KINLINE poly ksOldSpolyRed(poly p1, poly p2, poly spNoether)
Definition: kInline.h:1142
KINLINE poly k_LmInit_tailRing_2_currRing(poly t_p, ring tailRing, omBin lmBin)
Definition: kInline.h:936
KINLINE TObject ** initR()
Definition: kInline.h:95
KINLINE poly redtailBbaBound(poly p, int pos, kStrategy strat, int bound, BOOLEAN normalize)
Definition: kInline.h:1186
KINLINE BOOLEAN arriRewDummy(poly, unsigned long, poly, kStrategy, int)
Definition: kInline.h:1230
KINLINE int ksReducePolyTail(LObject *PR, TObject *PW, LObject *Red)
Definition: kInline.h:1115
KINLINE poly ksOldSpolyRedNew(poly p1, poly p2, poly spNoether)
Definition: kInline.h:1152
KINLINE void clearS(poly p, unsigned long p_sev, int *at, int *k, kStrategy strat)
Definition: kInline.h:1205
KINLINE BOOLEAN k_GetLeadTerms(const poly p1, const poly p2, const ring p_r, poly &m1, poly &m2, const ring m_r)
Definition: kInline.h:986
KINLINE poly redtailBba_Z(poly p, int pos, kStrategy strat)
Definition: kInline.h:1198
KINLINE int ksReducePolyTail_Z(LObject *PR, TObject *PW, LObject *Red)
Definition: kInline.h:1095
KINLINE unsigned long * initsevT()
Definition: kInline.h:100
void kBucketDeleteAndDestroy(kBucket_pt *bucket_pt)
Definition: kbuckets.cc:223
void kBucketClear(kBucket_pt bucket, poly *p, int *length)
Definition: kbuckets.cc:521
void kBucketShallowCopyDelete(kBucket_pt bucket, ring new_tailRing, omBin new_tailBin, pShallowCopyDeleteProc p_shallow_copy_delete)
For changing the ring of the Bpoly to new_tailBin.
Definition: kbuckets.cc:535
void kBucket_Minus_m_Mult_p(kBucket_pt bucket, poly m, poly p, int *l, poly spNoether)
Bpoly == Bpoly - m*p; where m is a monom Does not destroy p and m assume (*l <= 0 || pLength(p) == *l...
Definition: kbuckets.cc:722
void kBucket_Mult_n(kBucket_pt bucket, number n)
Multiply Bucket by number ,i.e. Bpoly == n*Bpoly.
Definition: kbuckets.cc:598
void kBucketDestroy(kBucket_pt *bucket_pt)
Definition: kbuckets.cc:216
void kBucketInit(kBucket_pt bucket, poly lm, int length)
Definition: kbuckets.cc:493
poly kBucketExtractLm(kBucket_pt bucket)
Definition: kbuckets.cc:511
kBucket_pt kBucketCreate(const ring bucket_ring)
Creation/Destruction of buckets.
Definition: kbuckets.cc:209
void kBucketNormalize(kBucket_pt bucket)
apply n_Normalize to all coefficients
int kBucketCanonicalize(kBucket_pt bucket)
Canonicalizes Bpoly, i.e. converts polys of buckets into one poly in one bucket: Returns number of bu...
int ksReducePolyLC(LObject *PR, TObject *PW, poly spNoether, number *coef, kStrategy strat)
Definition: kspoly.cc:452
void ksCreateSpoly(LObject *Pair, poly spNoether, int use_buckets, ring tailRing, poly m1, poly m2, TObject **R)
Definition: kspoly.cc:1167
int ksReducePoly(LObject *PR, TObject *PW, poly spNoether, number *coef, poly *mon, kStrategy strat)
Definition: kspoly.cc:185
int kFindInT(poly p, TSet T, int tlength)
returns index of p in TSet, or -1 if not found
Definition: kutil.cc:718
void deleteInS(int i, kStrategy strat)
Definition: kutil.cc:1137
VAR denominator_list DENOMINATOR_LIST
Definition: kutil.cc:84
denominator_list_s * denominator_list
Definition: kutil.h:63
TObject * TSet
Definition: kutil.h:59
denominator_list next
Definition: kutil.h:65
#define setmaxT
Definition: kutil.h:33
#define KINLINE
Definition: kutil.h:49
class sTObject TObject
Definition: kutil.h:57
class sLObject LObject
Definition: kutil.h:58
#define assume(x)
Definition: mod2.h:387
#define p_GetComp(p, r)
Definition: monomials.h:64
#define pNext(p)
Definition: monomials.h:36
#define pSetCoeff0(p, n)
Definition: monomials.h:59
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
Definition: monomials.h:44
Definition: lq.h:40
#define nDelete(n)
Definition: numbers.h:16
#define nInvers(a)
Definition: numbers.h:33
#define nIsOne(n)
Definition: numbers.h:25
#define nNormalize(n)
Definition: numbers.h:30
#define omAlloc(size)
Definition: omAllocDecl.h:210
#define omAlloc0(size)
Definition: omAllocDecl.h:211
omBin_t * omBin
Definition: omStructs.h:12
#define TEST_OPT_CONTENTSB
Definition: options.h:127
p_Length
Definition: p_Procs_Impl.h:123
poly p_GetMaxExpP(poly p, const ring r)
return monomial r such that GetExp(r,i) is maximum of all monomials in p; coeff == 0,...
Definition: p_polys.cc:1133
void p_Cleardenom_n(poly ph, const ring r, number &c)
Definition: p_polys.cc:3009
void p_SimpleContent(poly ph, int smax, const ring r)
Definition: p_polys.cc:2619
void p_Norm(poly p1, const ring r)
Definition: p_polys.cc:3789
unsigned long p_GetShortExpVector(const poly p, const ring r)
Definition: p_polys.cc:4809
void p_ProjectiveUnique(poly ph, const ring r)
Definition: p_polys.cc:3198
poly p_Last(const poly p, int &l, const ring r)
Definition: p_polys.cc:4649
static poly p_Neg(poly p, const ring r)
Definition: p_polys.h:1067
static long p_GetExpDiff(poly p1, poly p2, int i, ring r)
Definition: p_polys.h:635
BOOLEAN p_LmCheckPolyRing(poly p, ring r)
Definition: pDebug.cc:118
static poly p_LmInit(poly p, const ring r)
Definition: p_polys.h:1295
static long p_FDeg(const poly p, const ring r)
Definition: p_polys.h:380
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent @Note: VarOffset encodes the position in p->exp
Definition: p_polys.h:488
static long p_MinComp(poly p, ring lmRing, ring tailRing)
Definition: p_polys.h:313
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:233
static poly p_LmShallowCopyDelete(poly p, const ring r)
Definition: p_polys.h:1353
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent @Note: the integer VarOffset encodes:
Definition: p_polys.h:469
static poly p_Mult_nn(poly p, number n, const ring r)
Definition: p_polys.h:918
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:861
static void p_LmFree(poly p, ring)
Definition: p_polys.h:683
static poly p_Minus_mm_Mult_qq(poly p, const poly m, const poly q, int &lp, int lq, const poly spNoether, const ring r)
Definition: p_polys.h:1030
static poly p_Init(const ring r, omBin bin)
Definition: p_polys.h:1280
static poly p_LmDeleteAndNext(poly p, const ring r)
Definition: p_polys.h:725
static poly p_Copy(poly p, const ring r)
returns a copy of p
Definition: p_polys.h:812
static long p_Totaldegree(poly p, const ring r)
Definition: p_polys.h:1467
#define p_Test(p, r)
Definition: p_polys.h:162
#define __p_Mult_nn(p, n, r)
Definition: p_polys.h:931
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
Compatiblity layer for legacy polynomial operations (over currRing)
#define pLmShortDivisibleBy(a, sev_a, b, not_sev_b)
Divisibility tests based on Short Exponent vectors sev_a == pGetShortExpVector(a) not_sev_b == ~ pGet...
Definition: polys.h:146
#define pGetShortExpVector(a)
returns the "Short Exponent Vector" – used to speed up divisibility tests (see polys-impl....
Definition: polys.h:152
#define pNormalize(p)
Definition: polys.h:317
static BOOLEAN rField_is_Ring(const ring r)
Definition: ring.h:486
static BOOLEAN rIsSyzIndexRing(const ring r)
Definition: ring.h:722
poly(* pShallowCopyDeleteProc)(poly s_p, ring source_r, ring dest_r, omBin dest_bin)
returns a poly from dest_r which is a ShallowCopy of s_p from source_r assumes that source_r->N == de...
Definition: ring.h:44
int p_mFirstVblock(poly p, const ring ri)
Definition: shiftop.cc:475