Changeset 93af5b in git

Timestamp:

Sep 27, 1999, 4:33:28 PM (25 years ago)

Author:

Olaf Bachmann <obachman@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

360948186b228cfd2f4f810105615449e16ece57

Parents:

59dff80d507cfb0f41b20d3321cf98898ad960e0

Message:

wal merge


git-svn-id: file:///usr/local/Singular/svn/trunk@3676 2c84dea3-7e68-4137-9b89-c4e89433aadc

Location:

Singular

Files:

• kbPolyProcs.cc (modified) (14 diffs)
• kbPolyProcs.h (modified) (4 diffs)

Singular/kbPolyProcs.cc

@@ -11 +11 @@
 #include "modulop.h"
 #include "spolys0.h"
-
-/***************************************************************
- *
- * Reduces p1 with p2
- * Assumes p1 != NULL, p2 != NULL, Lm(p1) divides Lm(p2)
- *         pLength(p2) == l2
+#include "polys-comp.h"
+
+#define HAVE_COMP_MACROS
+
+/***************************************************************
+ *
+ * Reduces PR with PW
+ * Assumes PR != NULL, PW != NULL, Lm(PR) divides Lm(PW)
  * 
  ***************************************************************/
-void kbReducePoly(poly *p1, int *l1,
-                  poly p2, int l2, 
-                  poly spNoether,
-                  kbPolyProcs_pt pprocs,
-                  memHeap heap)
+void kbReducePoly(LObject* PR,
+                  TObject* PW,
+                  poly spNoether)
 {
-  assume(p2 != NULL && 
-         pDivisibleBy(p2,  *p1));
-#ifdef HAVE_LENGTH
-  assume(pLength(p2) == (int) l2);
-  assume(pLength(p1) == (int) l1);
-#endif  
-
-  poly a2 = pNext(p2), lm = *p1;
-  *p1 = pNext(*p1);
-  *l1 = *l1 -1;
+  assume(kTest_L(PR));
+  assume(kTest_T(PW));
+
+  poly p1 = PR->p;
+  poly p2 = PW->p;
+  assume(p2 != NULL && p1 != NULL && pDivisibleBy(p2,  p1));
+
+  poly a2 = pNext(p2), lm = p1;
+  p1 = pNext(p1);
+  PR->p = p1;
   BOOLEAN reset_vec=FALSE;
   
   if (a2==NULL)
   {
-    kb_pDelete1(lm, heap);
+    pDelete1(&lm);
     return;
   }
@@ -48 +48 @@
     int ct = spCheckCoeff(&an, &bn);
     pSetCoeff(lm, bn);
-    if ((ct == 0) || (ct == 2)) kb_n_Mult_p_General(an, *p1);
+    if ((ct == 0) || (ct == 2)) kb_n_Mult_p(an, PR->p);
     nDelete(&an);
   }
-
   
   if (pGetComp(p2) != pGetComp(lm))
@@ -61 +60 @@
   pMonSubFast(lm, p2);
   assume(pGetComp(lm) == 0);
-
-  kb_p_Minus_m_Mult_q_General(p1, l1, lm, a2, l2-1, spNoether);
-  
-  kb_pDelete1(lm, heap);
+  lm->next = NULL;
+  pTest(lm);
+  int l1, l2;
+  kb_p_Minus_m_Mult_q(&(PR->p), &l1, 
+                      lm, 
+                      a2, l2, spNoether);
+  
+  pDelete1(&lm);
   if (reset_vec) spModuleToPoly(p2);
 }
@@ -74 +77 @@
  *
  ***************************************************************/
-void kbCreateSpoly(poly *sp, int *lsp, 
-                   poly p1, int l1,
-                   poly p2, int l2,
-                   poly spNoether,
-                   kbPolyProcs_pt pprocs,
-                   memHeap heap)
+void kbCreateSpoly(LObject* Pair, 
+                   poly spNoether)
 {
-#ifdef HAVE_LENGTH
-  assume(p1 != NULL && (l1 <= 0 || pLength(p1) == l1));
-  assume(p2 != NULL && (l2 <= 0 || pLength(p2) == l2));
-#endif
-#ifdef KB_USE_HEAPS
-  assume(heap != NULL);
-#else
-  assume(heap == NULL);
-#endif  
-  
+  assume(kTest_L(Pair));
+  poly p1 = Pair->p1;
+  poly p2 = Pair->p2;
+
+  assume(p1 != NULL);
+  assume(p2 != NULL);
+
   poly a1 = pNext(p1), a2 = pNext(p2);
   number lc1 = pGetCoeff(p1), lc2 = pGetCoeff(p2);
@@ -96 +92 @@
   int co=0, ct = spCheckCoeff(&lc1, &lc2);
   Exponent_t x;
+  int l1;
 
   if (pGetComp(p1)!=pGetComp(p2))
@@ -135 +132 @@
 
   // get m2 * a2
-  a2 = kb_p_Mult_m_General(a2, m2);
-#ifdef HAVE_LENGTH
-  if (l1 <= 0) l1 = pLength(a1); else l1--;
-  if (l2 <= 0) l2 = pLength(a2); else l2--;
-#endif
+  Pair->p = kb_p_Mult_m(a2, m2);
+
+  int l2;
   // and, finally, the spoly
-  kb_p_Minus_m_Mult_q_General(&a2, &l2, m1, a1, l1);
+  kb_p_Minus_m_Mult_q(&(Pair->p), &l2, m1, a1, l1);
   
   // Clean-up time
@@ -158 +153 @@
     }
   }
-  *sp = a2;
-  *lsp = l2;
-  pTest(*sp);
 }
 
@@ -224 +216 @@
 
   Top:     // compare a1 and a2 w.r.t. monomial ordering
-//  register long d;
-  long d;
+  register long d;
 #ifdef HAVE_COMP_MACROS
-  _pMonComp(a1, a2, d, goto NotEqual, goto Equal);
+  _pMonComp(a1, a2, d, goto NotEqual , goto Equal);
 #else
   if ((d = pComp0(a1, a2))) goto NotEqual; else goto Equal;
@@ -294 +285 @@
 
   Finish:
-#ifdef HAVE_LENGTH  
+#ifdef HAVE_LENGTH
   assume(pLength(pNext(&rp)) == (int) l);
 #endif
@@ -365 +356 @@
                                   poly q, int lq,
                                   poly spNoether,
-                                  kb_p_Mult_m_Proc kb_p_Mult_m,
                                   memHeap heap)
 { 
@@ -376 +366 @@
   assume(pLength(q) == lq);
   assume(pLength(*pp) == *lpp);
-#endif
-  assume(pGetComp(m) == 0);
   pTest(*pp);
   pTest(q);
+#endif
+  assume(pGetComp(m) == 0);
   // we are done if q == NULL
   if (q == NULL || m == NULL) return;
@@ -474 +464 @@
    {
      pSetCoeff0(m, tneg);
-     pNext(a) = kb_p_Mult_m_General(q, m, spNoether, heap);
+     pNext(a) = kb_p_Mult_m(q, m, spNoether, heap);
      pSetCoeff0(m, tm);
    }
@@ -484 +474 @@
    *lpp = lp;
    pNext(m) = NULL;
-
-#ifdef HAVE_LENGTH   
+#ifdef HAVE_LENGTH
    assume(pLength(*pp) == *lpp);
-#endif
    pTest(*pp);
+#endif
 } 
 
@@ -531 +520 @@
 
   // set characterisic
-  if (rField_is_Zp(r)) ch = chMODP;
+  if (r->ch > 1) ch = chMODP;
   
   // set Ordering Type

Singular/kbPolyProcs.h

@@ -4 +4 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: kbPolyProcs.h,v 1.2 1999-05-26 16:20:16 obachman Exp $ */
+/* $Id: kbPolyProcs.h,v 1.3 1999-09-27 14:33:26 obachman Exp $ */
 #include "mod2.h"
 #include "mmheap.h"
 #include "ring.h"
+#include "kutil.h"
 
 
@@ -37 +38 @@
                                          poly q, int lq,
                                          poly spNoether,
-                                         kb_p_Mult_m_Proc kb_p_Mult_m,
                                          memHeap heap = NULL);
 extern void kb_p_Minus_m_Mult_q_General(poly *p, int *lp, 
@@ -43 +43 @@
                                         poly q, int lq,
                                         poly spNoether,
-                                        kb_p_Mult_m_Proc kb_p_Mult_m,
                                         memHeap heap = NULL);
 
@@ -65 +64 @@
                            BOOLEAN homog = FALSE);
 
+
+#define kb_n_Mult_p kb_n_Mult_p_General
+#define kb_p_Add_q  kb_p_Add_q_General
+#define kb_p_Minus_m_Mult_q  kb_p_Minus_m_Mult_q_General
+#define kb_p_Mult_m kb_p_Mult_m_General
+
+///////////////////////////////////////////////////////////////////////
+///
+/// General Procedures for poly arithemetic which always work
+///
+void kb_n_Mult_p_General(number n, poly p);
+void kb_p_Add_q_General(poly *p, int *lp,
+                        poly *q, int *lq, 
+                        memHeap heap = NULL);
+poly  kb_p_Mult_m_General(poly p,
+                          poly m, 
+                          poly spNoether = NULL,
+                          memHeap heap = NULL);
+void kb_p_Minus_m_Mult_q_General (poly *pp, int *lpp, 
+                                  poly m,
+                                  poly q, int lq,
+                                  poly spNoether = NULL,
+                                  memHeap heap = NULL);
+
+
+void kbCreateSpoly(LObject* P,
+                   poly spNoether = NULL);
+
+
+void kbReducePoly(LObject* RP, // Poly to be reduced
+                  TObject* WP, // Poly with which is reduced
+                  poly spNoether = NULL);
+
+
 #endif /* KBPOLYPROCS_H */