Changeset 964cd1 in git

Timestamp:

Mar 9, 2003, 9:52:43 AM (21 years ago)

Author:

Michael Brickenstein <bricken@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

32f58cd398994310d68f0171a7b1eda5d17811ba

Parents:

08405a9243e7a4046ddae06608507408e33cc842

Message:

*bricken: work in progress


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

Location:

Singular

Files:

• tgb.cc (modified) (6 diffs)
• tgb.h (modified) (4 diffs)

Singular/tgb.cc

@@ -1955 +1955 @@
 
 
-struct find_erg{
-  poly expand;
-  int expand_length;
-  int to_reduce_u;
-  int to_reduce_l;
-  int reduce_by;//index of reductor
-  BOOLEAN fromS;//else from los
-
-};
+
 static int guess_quality(const red_object & p, calc_dat* c){
   //looks only on bucket
@@ -2310 +2302 @@
     if(erg.reduce_by<0) break;
     multi_reduction_lls_trick(los,losl,c,erg);
-    //erweitern? muß noch implementiert werden
+    int sum=0;
+    BOOLEAN join=FALSE;
+    for(i=erg.to_reduce_l;i<=erg.to_reduce_u;i++){
+      if(!los[i].sum) sum++;
+      if (sum>=AC_NEW_MIN) {join=TRUE;break;}
+    }
+    
     int i;
     int len;
@@ -2341 +2339 @@
        nDelete(&coef);
        los[i].p = kBucketGetLm(los[i].bucket);
-       if(los[i].p!=NULL)
-         if((i>0)&&(los[i-1].p!=NULL)&&(pLmEqual(los[i-1].p,los[i].p)))
-             los[i].sev=los[i-1].sev;
-         else
-           los[i].sev=pGetShortExpVector(los[i].p);
+//        if(los[i].p!=NULL)
+//       if((i>0)&&(los[i-1].p!=NULL)&&(pLmEqual(los[i-1].p,los[i].p)))
+//           los[i].sev=los[i-1].sev;
+//       else
+//         los[i].sev=pGetShortExpVector(los[i].p);
+       los[i].validate();
        //better would be first sorting before sev
     }
@@ -2402 +2401 @@
       flatten();
       p=kBucketGetLm(bucket);
+      sev=pGetShortExpVector(p);
     } 
     else
     {
+ 
       p=lm_ac;
+      assume(sum->ac->sev==pGetShortExpVector(p));
+      sev=sum->ac->sev;
     }
     
   }
-  else
+  else{
     p=kBucketGetLm(bucket);
-
+    sev=pGetShortExpVector(p);
+  }
 }
 int red_object::clear_to_poly(){
@@ -2422 +2426 @@
 {
   //we have to add support later for building new sums at this points, this involves a change in the interface
-  if(this->sum==NULL)
-    kBucketPolyRed(this->bucket,reductor_full,
-                   full_len,
-                   c->strat->kNoether);
-  else 
-  {
-    assume(sum->ac!=NULL);
-    if(sum->ac->last_reduction_id!=reduction_id){
-      
-
-
-      
-      
-      number n1=kBucketPolyRed(sum->ac->bucket,reductor_full, full_len, c->strat->kNoether);
-      number n2=nMult(n1,sum->ac->multiplied);
-      nDelete(&sum->ac->multiplied);
-      nDelete(&n1);
-      sum->ac->multiplied=n2;
-    }
-      //reduce and adjust multiplied
-      sum->ac->last_reduction_id=reduction_id;
-      
-  }
-    
       
 }
@@ -2480 +2460 @@
     return s;
 }
+void reduction_step::reduce(red_object* r, int l, int u){}
+void simple_reducer::reduce(red_object* r, int l, int u){
+  int i;
+  for(i=l;i<=u;i++){
+    if(r[i].sum==NULL)
+      kBucketPolyRed(r[i].bucket,p,
+                     p_len,
+                     c->strat->kNoether);
+    else 
+    {
+      assume(r[i].sum->ac!=NULL);
+      if(r[i].sum->ac->last_reduction_id!=reduction_id){
+        number n1=kBucketPolyRed(r[i].sum->ac->bucket,p, p_len, c->strat->kNoether);
+        number n2=nMult(n1,r[i].sum->ac->multiplied);
+        nDelete(&r[i].sum->ac->multiplied);
+        nDelete(&n1);
+        r[i].sum->ac->multiplied=n2;
+      }
+      //reduce and adjust multiplied
+      r[i].sum->ac->last_reduction_id=reduction_id;
+      
+    }
+ 
+  }
+  for(i=l;i<=u;i++)
+    r[i].validate();
+}
+reduction_step::~reduction_step(){}
+simple_reducer::~simple_reducer(){
+  if(fill_back!=NULL)
+  {
+    kBucketInit(fill_back,p,p_len);
+  }
+    
+}
+void finalize_reduction_step(reduction_step* r){
+  delete r;
+}
+reduction_step* create_reduction_step(find_erg & erg, red_object* r, calc_dat* c){
+  static int id=0;
+  id++;
+  
+  simple_reducer* pointer= new simple_reducer();
+ 
+  if (erg.fromS){
+    pointer->p=c->strat->S[erg.reduce_by];
+    pointer->p_len=c->strat->lenS[erg.reduce_by];
+    pointer->fill_back=NULL;
+  }
+  else
+  {
+    kBucket_pt bucket=r[erg.reduce_by].bucket;
+    kBucketClear(bucket,&pointer->p,&pointer->p_len);
+
+    pointer->fill_back=bucket;
+  }
+
+  pointer->reduction_id=id;
+  pointer->c=c;
+ 
+  return pointer;
+};

Singular/tgb.h

@@ -25 +25 @@
 #define REDTAIL_S
 #define PAR_N 1000
+#define AC_NEW_MIN 5
 //#define REDTAIL_PROT
 //#define QUICK_SPOLY_TEST
@@ -48 +49 @@
   ///the polynomial data
   kBucket_pt bucket;
+  /// the short exponent vector
+  unsigned long sev;
   /// the reference counter
   int counter;
@@ -115 +118 @@
   void flatten();
   void validate();
-  void red_object::reduction_step(int reduction_id, poly reductor_full, int full_len, poly reductor_part, reduction_accumulator* join_to, calc_dat* c);
+  void reduction_step(int reduction_id, poly reductor_full, int full_len, poly reductor_part, reduction_accumulator* join_to, calc_dat* c);
   void adjust_coefs(number c_r, number c_ac_r);
   int guess_quality(calc_dat* c);
-  int red_object::clear_to_poly();
+  int clear_to_poly();
 };
 
@@ -164 +167 @@
 static sorted_pair_node* top_pair(calc_dat* c);
 static int quality(poly p, int len, calc_dat* c);
-
+/**
+   makes on each red_object in a region a single_step
+ **/
+class reduction_step{
+ public:
+  /// we assume hat all occuring red_objects have same lm, and all
+  /// occ. lm's in r[l...u] are the same, only reductor does not occur
+  virtual void reduce(red_object* r, int l, int u);
+  //int reduction_id;
+  virtual ~reduction_step();
+  calc_dat* c;
+  int reduction_id;
+};
+class simple_reducer:public reduction_step{
+ public:
+  poly p;
+  kBucket_pt fill_back;
+  int p_len;
+
+  void reduce(red_object* r, int l, int u);
+  ~simple_reducer();
+};
+//class sum_canceling_reducer:public reduction_step {
+//  void reduce(red_object* r, int l, int u);
+//};
+struct find_erg{
+  poly expand;
+  int expand_length;
+  int to_reduce_u;
+  int to_reduce_l;
+  int reduce_by;//index of reductor
+  BOOLEAN fromS;//else from los
+
+};
+
+reduction_step* create_reduction_step(find_erg & erg, red_object* r, calc_dat* c);
 #endif