Changeset 26336c in git


Ignore:
Timestamp:
Jan 9, 2006, 6:27:37 PM (18 years ago)
Author:
Hans Schönemann <hannes@…>
Branches:
(u'spielwiese', '2fa36c576e6a4ddbb1093b43c7f8e9835e17e52a')
Children:
b643d7a0728056fa1fe6ed4a0ac5429d7a0e8cfe
Parents:
36147a052fd99ded7a25ef52928b3fe768183b2e
Message:
*hannes: fixed by in rinvar.tst


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

Legend:

Unmodified
Added
Removed

  • kernel/kbuckets.cc

    r36147a r26336c  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: kbuckets.cc,v 1.11 2005-12-19 13:33:50 bricken Exp $ */
     4/* $Id: kbuckets.cc,v 1.12 2006-01-09 17:27:37 Singular Exp $ */
    55
    66#include "mod2.h"
    … …  
    245245       bucket->buckets_length[i]++;
    246246       assume(i <= bucket->buckets_used+1);
    247        
     247
    248248    } else {
    249249      #if 1
    … …  
    257257       bucket->buckets_length[i]=1;
    258258       bucket->coef[i]=p_NSet(n_Copy(coef,bucket->bucket_ring),bucket->bucket_ring);
    259        
     259
    260260       bucket->buckets[i]=lm;
    261261       bucket->buckets_length[i]=1;
    … …  
    688688  ring r = bucket->bucket_ring;
    689689
     690  if (m == NULL || p == NULL) return;
     691
    690692  if (l <= 0)
    691693  {
    … …  
    695697  else
    696698    l1 = l;
    697 
    698   if (m == NULL || p == NULL) return;
    699699
    700700  kBucketMergeLm(bucket);
    … …  
    703703  number n=n_Init(1,r);
    704704  if (i <= bucket->buckets_used && bucket->buckets[i] != NULL)
    705   { 
     705  {
    706706    //if (FALSE){
    707     if ((bucket->coef[i]!=NULL) &&(i>=coef_start)){
    708         number orig_coef=p_GetCoeff(bucket->coef[i],r);
    709         //we take ownership:
    710         p_SetCoeff0(bucket->coef[i],n_Init(0,r),r);
    711         number add_coef=n_Copy(p_GetCoeff(m,r),r);
    712         number gcd=n_Gcd(add_coef, orig_coef,r);
    713        
    714         if (!(n_IsOne(gcd,r))) {
    715             number orig_coef2=n_IntDiv(orig_coef,gcd,r);
    716             number add_coef2=n_IntDiv(add_coef, gcd,r);
    717             n_Delete(&orig_coef,r);
    718             n_Delete(&add_coef,r);
    719             orig_coef=orig_coef2;
    720             add_coef=add_coef2;
    721          
    722             //p_Mult_nn(bucket->buckets[i], orig_coef,r);
    723             n_Delete(&n,r);
    724             n=gcd;
    725            
    726         }
    727        
    728         //assume(n_IsOne(n,r));
    729         number backup=p_GetCoeff(m,r);
    730        
    731         p_SetCoeff0(m,add_coef,r);
    732         bucket->buckets[i]=p_Mult_nn(bucket->buckets[i],orig_coef,r);
    733        
     707    if ((bucket->coef[i]!=NULL) &&(i>=coef_start))
     708    {
     709      number orig_coef=p_GetCoeff(bucket->coef[i],r);
     710      //we take ownership:
     711      p_SetCoeff0(bucket->coef[i],n_Init(0,r),r);
     712      number add_coef=n_Copy(p_GetCoeff(m,r),r);
     713      number gcd=n_Gcd(add_coef, orig_coef,r);
     714
     715      if (!(n_IsOne(gcd,r)))
     716      {
     717        number orig_coef2=n_IntDiv(orig_coef,gcd,r);
     718        number add_coef2=n_IntDiv(add_coef, gcd,r);
    734719        n_Delete(&orig_coef,r);
    735         p_Delete(&bucket->coef[i],r);
    736        
    737 
    738         p1 = p_Plus_mm_Mult_qq(bucket->buckets[i], m, p1,
     720        n_Delete(&add_coef,r);
     721        orig_coef=orig_coef2;
     722        add_coef=add_coef2;
     723
     724        //p_Mult_nn(bucket->buckets[i], orig_coef,r);
     725        n_Delete(&n,r);
     726        n=gcd;
     727      }
     728
     729      //assume(n_IsOne(n,r));
     730      number backup=p_GetCoeff(m,r);
     731
     732      p_SetCoeff0(m,add_coef,r);
     733      bucket->buckets[i]=p_Mult_nn(bucket->buckets[i],orig_coef,r);
     734
     735      n_Delete(&orig_coef,r);
     736      p_Delete(&bucket->coef[i],r);
     737
     738      p1 = p_Plus_mm_Mult_qq(bucket->buckets[i], m, p1,
    739739                           bucket->buckets_length[i], l1, r);
    740         bucket->buckets[i]=NULL;
    741         l1=bucket->buckets_length[i];
    742         assume(l1==pLength(p1));
    743        
    744         p_SetCoeff(m,backup,r); //deletes add_coef
    745        
    746        
    747     }
    748     else {
    749    
    750     MULTIPLY_BUCKET(bucket,i);
    751     p1 = p_Plus_mm_Mult_qq(bucket->buckets[i], m, p1,
     740      l1=bucket->buckets_length[i];
     741      bucket->buckets[i]=NULL;
     742      bucket->buckets_length[i] = 0;
     743      i = pLogLength(l1);
     744      assume(l1==pLength(p1));
     745
     746      p_SetCoeff(m,backup,r); //deletes add_coef
     747    }
     748    else
     749    {
     750      MULTIPLY_BUCKET(bucket,i);
     751      p1 = p_Plus_mm_Mult_qq(bucket->buckets[i], m, p1,
    752752                           bucket->buckets_length[i], l1, r);
    753     l1 = bucket->buckets_length[i];
    754     bucket->buckets[i] = NULL;
    755     bucket->buckets_length[i] = 0;
    756     i = pLogLength(l1);
    757     }
    758   }
    759   else
    760   {
    761    
     753      l1 = bucket->buckets_length[i];
     754      bucket->buckets[i] = NULL;
     755      bucket->buckets_length[i] = 0;
     756      i = pLogLength(l1);
     757    }
     758  }
     759  else
     760  {
    762761    number swap_n=p_GetCoeff(m,r);
    763    
     762
    764763    assume(n_IsOne(n,r));
    765764    p_SetCoeff0(m,n,r);
    … …  
    767766    //p_SetCoeff0(n, swap_n, r);
    768767    //p_GetCoeff0(n, swap_n,r);
    769    
     768
    770769    p1 = r->p_Procs->pp_Mult_mm(p1, m, r, last);
    771770    //m may not be changed
    … …  
    775774  while ((bucket->buckets[i] != NULL) && (p1!=NULL))
    776775  {
    777 
    778776    assume(i!=0);
    779     if ((bucket->coef[i]!=NULL) &&(i>=coef_start)){
    780         number orig_coef=p_GetCoeff(bucket->coef[i],r);
    781         //we take ownership:
    782         p_SetCoeff0(bucket->coef[i],n_Init(0,r),r);
    783         number add_coef=n;
    784         number gcd=n_Gcd(add_coef, orig_coef,r);
    785        
    786         if (!(n_IsOne(gcd,r))) {
    787             number orig_coef2=n_IntDiv(orig_coef,gcd,r);
    788             number add_coef2=n_IntDiv(add_coef, gcd,r);
    789             n_Delete(&orig_coef,r);
    790             n_Delete(&add_coef,r);
    791             orig_coef=orig_coef2;
    792             add_coef=add_coef2;
    793             //p_Mult_nn(bucket->buckets[i], orig_coef,r);
    794             n_Delete(&n,r);
    795             n=gcd;
    796         }
    797        
    798         //assume(n_IsOne(n,r));
    799         bucket->buckets[i]=p_Mult_nn(bucket->buckets[i],orig_coef,r);
    800         p1=p_Mult_nn(p1,add_coef,r);
    801        
    802      
    803        
    804 
    805         p1 = p_Add_q(p1, bucket->buckets[i],r);
    806         l1=pLength(p1);
    807        
    808         bucket->buckets[i]=NULL;
     777    if ((bucket->coef[i]!=NULL) &&(i>=coef_start))
     778    {
     779      number orig_coef=p_GetCoeff(bucket->coef[i],r);
     780      //we take ownership:
     781      p_SetCoeff0(bucket->coef[i],n_Init(0,r),r);
     782      number add_coef=n;
     783      number gcd=n_Gcd(add_coef, orig_coef,r);
     784
     785      if (!(n_IsOne(gcd,r)))
     786      {
     787        number orig_coef2=n_IntDiv(orig_coef,gcd,r);
     788        number add_coef2=n_IntDiv(add_coef, gcd,r);
    809789        n_Delete(&orig_coef,r);
    810         p_Delete(&bucket->coef[i],r);
    811         //l1=bucket->buckets_length[i];
    812         assume(l1==pLength(p1));
    813        
    814 
    815        
    816     } else {   
    817    
    818     //don't do that, pull out gcd
    819     if(!(n_IsOne(n,r))) {
     790        n_Delete(&add_coef,r);
     791        orig_coef=orig_coef2;
     792        add_coef=add_coef2;
     793        //p_Mult_nn(bucket->buckets[i], orig_coef,r);
     794        n_Delete(&n,r);
     795        n=gcd;
     796      }
     797      //assume(n_IsOne(n,r));
     798      bucket->buckets[i]=p_Mult_nn(bucket->buckets[i],orig_coef,r);
     799      p1=p_Mult_nn(p1,add_coef,r);
     800
     801      p1 = p_Add_q(p1, bucket->buckets[i],r);
     802      l1=pLength(p1);
     803
     804      bucket->buckets[i]=NULL;
     805      n_Delete(&orig_coef,r);
     806      p_Delete(&bucket->coef[i],r);
     807      //l1=bucket->buckets_length[i];
     808      assume(l1==pLength(p1));
     809    }
     810    else
     811    {
     812      //don't do that, pull out gcd
     813      if(!(n_IsOne(n,r)))
     814      {
    820815        p1=p_Mult_nn(p1, n, r);
    821816        n_Delete(&n,r);
    822817        n=n_Init(1,r);
    823     }
    824    
    825     MULTIPLY_BUCKET(bucket,i);
    826     p1 = p_Add_q(p1, bucket->buckets[i],
     818      }
     819      MULTIPLY_BUCKET(bucket,i);
     820      p1 = p_Add_q(p1, bucket->buckets[i],
    827821                 l1, bucket->buckets_length[i], r);
    828     bucket->buckets[i] = NULL;
    829     bucket->buckets_length[i] = 0;
     822      bucket->buckets[i] = NULL;
     823      bucket->buckets_length[i] = 0;
     824    }
    830825    i = pLogLength(l1);
    831     }
    832   }
    833 
    834  
     826  }
     827
    835828  bucket->buckets[i] = p1;
    836  
     829
    837830  assume(bucket->coef[i]==NULL);
    838   if (!(n_IsOne(n,r))){
     831  if (!(n_IsOne(n,r)))
     832  {
    839833    bucket->coef[i]=p_NSet(n,r);
    840   } else {
     834  }
     835  else
     836  {
    841837    bucket->coef[i]=NULL;
    842838    n_Delete(&n,r);
    843839  }
    844   if ((p1==NULL) && (bucket->coef[i]!=NULL)) p_Delete(&bucket->coef[i],r);
     840  if ((p1==NULL) && (bucket->coef[i]!=NULL))
     841    p_Delete(&bucket->coef[i],r);
    845842  bucket->buckets_length[i]=l1;
    846843  if (i >= bucket->buckets_used)
    … …  
    10131010    if (rField_is_Zp(r))
    10141011        return TRUE;
    1015        
     1012
    10161013    //if (r->parameter!=NULL)
    10171014    number one=n_Init(1,r);
    … …  
    10261023        return TRUE;
    10271024    }
    1028 
    10291025    return FALSE;
    1030    
    1031 }
    1032 void kBucketSimpleContent(kBucket_pt bucket){
    1033     int i;
    1034     //PrintS("HHHHHHHHHHHHH");
    1035     for (i=0;i<=MAX_BUCKET;i++){
    1036         //if ((bucket->buckets[i]!=NULL) && (bucket->coef[i]!=NULL))
    1037         //    PrintS("H2H2H2");
    1038           if (i==0)
    1039            
    1040            {
    1041            
    1042            assume(bucket->buckets[i]==NULL);
    1043            }
    1044         if ((bucket->buckets[i]!=NULL) && (bucket->coef[i]==NULL)){
    1045             return;
    1046          }
    1047     }
    1048     //return;
    1049     ring r=bucket->bucket_ring;
    1050     number coef=n_Init(0,r);
    1051     //ATTENTION: will not work correct for GB over ring
    1052     //if (TEST_OPT_PROT)
    1053     //    PrintS("CCCCCCCCCCCCC");
    1054     for (i=0;i<=MAX_BUCKET;i++){
    1055         if (i==0)
    1056            
    1057            {
    1058            
    1059            assume(bucket->buckets[i]==NULL);
    1060            }
    1061         if (bucket->buckets[i]!=NULL){
    1062            
    1063             assume(bucket->coef[i]!=NULL);
    1064             //in this way it should crash on programming errors, yeah
    1065             number temp=nGcd(coef, pGetCoeff(bucket->buckets[i]),r);
    1066             n_Delete(&coef,r );
    1067             coef=temp;
    1068             if (nIsPseudoUnit(coef,r))
    1069             {
    1070                 n_Delete(&coef,r);
    1071                 return;
    1072             }
    1073            
    1074          }
    1075     }
    1076     if (TEST_OPT_PROT)
    1077         PrintS("S");
    1078     for(i=0;i<=MAX_BUCKET;i++){
    1079         if (bucket->buckets[i]!=NULL)
    1080         {
    1081         assume(bucket->coef[i]!=NULL);
    1082         number lc=p_GetCoeff(bucket->coef[i],r);
    1083         p_SetCoeff(bucket->coef[i], n_IntDiv(lc,coef,r),r);
    1084         }
    1085     }
    1086     return;
    1087 }
    1088 
    1089 
    1090 poly kBucketExtractLmOfBucket(kBucket_pt bucket, int i){
    1091     assume(bucket->buckets[i]!=NULL);
    1092    
    1093     ring r=bucket->bucket_ring;
    1094     poly p=bucket->buckets[i];
    1095     bucket->buckets_length[i]--;
    1096     if (bucket->coef[i]!=NULL){
    1097         poly next=pNext(p);
    1098         if (next==NULL){
    1099             MULTIPLY_BUCKET(bucket,i);
    1100             p=bucket->buckets[i];
    1101             bucket->buckets[i]=NULL;
    1102             return p;
    1103         } else {
    1104             bucket->buckets[i]=next;
    1105             number c=p_GetCoeff(bucket->coef[i],r);
    1106             pNext(p)=NULL;
    1107             p=p_Mult_nn(p,c,r);
    1108             assume(p!=NULL);
    1109             return p;
    1110         }
    1111        
    1112     } else {
    1113        
    1114         bucket->buckets[i]=pNext(bucket->buckets[i]);
    1115         pNext(p)=NULL;
    1116         assume(p!=NULL);
    1117         return p;
    1118     }
    1119    
    1120 }
     1026}
     1027
     1028void kBucketSimpleContent(kBucket_pt bucket)
     1029{
     1030  int i;
     1031  //PrintS("HHHHHHHHHHHHH");
     1032  for (i=0;i<=MAX_BUCKET;i++)
     1033  {
     1034    //if ((bucket->buckets[i]!=NULL) && (bucket->coef[i]!=NULL))
     1035    //    PrintS("H2H2H2");
     1036    if (i==0)
     1037    {
     1038      assume(bucket->buckets[i]==NULL);
     1039    }
     1040    if ((bucket->buckets[i]!=NULL) && (bucket->coef[i]==NULL))
     1041      return;
     1042  }
     1043  //return;
     1044  ring r=bucket->bucket_ring;
     1045  number coef=n_Init(0,r);
     1046  //ATTENTION: will not work correct for GB over ring
     1047  //if (TEST_OPT_PROT)
     1048  //    PrintS("CCCCCCCCCCCCC");
     1049  for (i=0;i<=MAX_BUCKET;i++)
     1050  {
     1051    if (i==0)
     1052    {
     1053      assume(bucket->buckets[i]==NULL);
     1054    }
     1055    if (bucket->buckets[i]!=NULL)
     1056    {
     1057      assume(bucket->coef[i]!=NULL);
     1058      //in this way it should crash on programming errors, yeah
     1059      number temp=nGcd(coef, pGetCoeff(bucket->buckets[i]),r);
     1060      n_Delete(&coef,r );
     1061      coef=temp;
     1062      if (nIsPseudoUnit(coef,r))
     1063      {
     1064        n_Delete(&coef,r);
     1065        return;
     1066      }
     1067    }
     1068  }
     1069  if (TEST_OPT_PROT)
     1070    PrintS("S");
     1071  for(i=0;i<=MAX_BUCKET;i++)
     1072  {
     1073    if (bucket->buckets[i]!=NULL)
     1074    {
     1075      assume(bucket->coef[i]!=NULL);
     1076      number lc=p_GetCoeff(bucket->coef[i],r);
     1077      p_SetCoeff(bucket->coef[i], n_IntDiv(lc,coef,r),r);
     1078    }
     1079  }
     1080}
     1081
     1082
     1083poly kBucketExtractLmOfBucket(kBucket_pt bucket, int i)
     1084{
     1085  assume(bucket->buckets[i]!=NULL);
     1086
     1087  ring r=bucket->bucket_ring;
     1088  poly p=bucket->buckets[i];
     1089  bucket->buckets_length[i]--;
     1090  if (bucket->coef[i]!=NULL)
     1091  {
     1092    poly next=pNext(p);
     1093    if (next==NULL)
     1094    {
     1095      MULTIPLY_BUCKET(bucket,i);
     1096      p=bucket->buckets[i];
     1097      bucket->buckets[i]=NULL;
     1098      return p;
     1099    }
     1100    else
     1101    {
     1102      bucket->buckets[i]=next;
     1103      number c=p_GetCoeff(bucket->coef[i],r);
     1104      pNext(p)=NULL;
     1105      p=p_Mult_nn(p,c,r);
     1106      assume(p!=NULL);
     1107      return p;
     1108    }
     1109  }
     1110  else
     1111  {
     1112    bucket->buckets[i]=pNext(bucket->buckets[i]);
     1113    pNext(p)=NULL;
     1114    assume(p!=NULL);
     1115    return p;
     1116  }
     1117}
Note: See TracChangeset for help on using the changeset viewer.