Changeset 47e836b in git


Ignore:
Timestamp:
Aug 3, 2011, 2:53:56 PM (12 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', 'a800fe4b3e9d37a38c5a10cc0ae9dfa0c15a4ee6')
Children:
b44f5efd50dcfa0bb89204f55621946bbb67238d
Parents:
3342df1a96f6513ccd51901066e6cb096c2c9780
git-author:
Hans Schoenemann <hannes@mathematik.uni-kl.de>2011-08-03 14:53:56+02:00
git-committer:
Mohamed Barakat <mohamed.barakat@rwth-aachen.de>2011-11-09 13:11:35+01:00
Message:
fix tgb.cc, tgbgauss.cc
Location:
kernel
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • kernel/tgb.cc

    r3342df r47e836b  
    1515///@TODO: grade aus ecartS, setze dazu strat->honey; und nutze p.ecart
    1616///@TODO: no tail reductions in syz comp
     17#include <stdlib.h>
     18#include <stdio.h>
     19#include <queue>
    1720#include <kernel/mod2.h>
    1821#include <kernel/tgb.h>
    … …  
    2730#include <kernel/longrat.h>
    2831#include <coeffs/modulop.h>
    29 #include <stdlib.h>
    30 #include <stdio.h>
    31 #include <queue>
    3232#define BUCKETS_FOR_NORO_RED 1
    3333#define SR_HDL(A) ((long)(A))
    … …  
    176176}
    177177#endif
     178struct snumber_dummy
     179{
     180  mpz_t z;
     181  mpz_t n;
     182  #if defined(LDEBUG)
     183  int debug;
     184  #endif
     185  BOOLEAN s;
     186};
     187typedef struct snumber_dummy  *number_dummy;
     188
    178189
    179190int QlogSize (number n)
    180191{
    181   if(SR_HDL (n) & SR_INT)
    182   {
    183     long i = SR_TO_INT (n);
    184     if(i == 0)
    185       return 0;
    186 
     192  long nl=n_Size(n,currRing->cf);
     193  if (nl==0L) return 0;
     194  if (nl==1L)
     195  {
     196    long i = n_Int(n,currRing->cf);
    187197    unsigned long v;
    188198    v = (i >= 0) ? i : -i;
    … …  
    196206  }
    197207  //assume denominator is 0
    198   return mpz_sizeinbase (n->z, 2);
     208  number_dummy nn=(number_dummy)n;
     209  return mpz_sizeinbase (nn->z, 2);
    199210}
    200211
    … …  
    985996  P.p = h;                      /*p_Copy(h,c->r); */
    986997  P.ecart = ecart;
    987   P.FDeg = pFDeg (P.p, c->r);
     998  P.FDeg = c->r->pFDeg (P.p, c->r);
    988999  if(!(simplified))
    9891000  {
    … …  
    25892600/*template <class number_type> SparseRow<number_type>* noro_red_to_non_poly(poly p, int &len, NoroCache<number_type>* cache,slimgb_alg* c)
    25902601 * {
    2591   if (npPrimeM<255)
     2602  if (n_GetChar(currRing->cf)<255)
    25922603  {
    25932604    return noro_red_to_non_poly_t<tgb_uint8>(p,len,cache,c);
    … …  
    25952606  else
    25962607  {
    2597     if (npPrimeM<65000)
     2608    if (n_GetChar(currRing->cf)<65000)
    25982609    {
    25992610      return noro_red_to_non_poly_t<tgb_uint16>(p,len,cache,c);
    … …  
    28352846    }
    28362847    {
    2837       if(npPrimeM < 255)
     2848      if(n_GetChar(currRing->cf) < 255)
    28382849      {
    28392850        noro_step < tgb_uint8 > (p, pn, c);
    … …  
    28412852      else
    28422853      {
    2843         if(npPrimeM < 65000)
     2854        if(n_GetChar(currRing->cf) < 65000)
    28442855        {
    28452856          noro_step < tgb_uint16 > (p, pn, c);
    … …  
    33533364#ifdef USE_NORO
    33543365  use_noro = ((!(nc)) && (S->rank <= 1) && (rField_is_Zp (r))
    3355               && (!(eliminationProblem)) && (npPrimeM <= 32003));
     3366              && (!(eliminationProblem)) && (n_GetChar(currRing->cf) <= 32003));
    33563367  use_noro_last_block = false;
    33573368  if((!(use_noro)) && (lastDpBlockStart <= (currRing->N)))
    33583369  {
    33593370    use_noro_last_block = ((!(nc)) && (S->rank <= 1) && (rField_is_Zp (r))
    3360                            && (npPrimeM <= 32003));
     3371                           && (n_GetChar(currRing->cf) <= 32003));
    33613372  }
    33623373#else
    … …  
    35733584  {
    35743585    rChangeCurrRing (new_ring);
    3575     s_h = idrCopyR_NoSort (arg_I, orig_ring);
     3586    s_h = idrCopyR_NoSort (arg_I, orig_ring, new_ring);
    35763587    idTest (s_h);
    35773588    /*int i;
    … …  
    35973608    idTest (s_result);
    35983609    rChangeCurrRing (orig_ring);
    3599     result = idrMoveR_NoSort (s_result, new_ring);
     3610    result = idrMoveR_NoSort (s_result, new_ring, orig_ring);
    36003611
    36013612    idTest (result);
    … …  
    47174728        p_noro[i] = p;
    47184729      }
    4719       if(npPrimeM < 255)
     4730      if(n_GetChar(currRing->cf) < 255)
    47204731      {
    47214732        noro_step < tgb_uint8 > (p_noro, pn_noro, c);
    … …  
    47234734      else
    47244735      {
    4725         if(npPrimeM < 65000)
     4736        if(n_GetChar(currRing->cf) < 65000)
    47264737        {
    47274738          noro_step < tgb_uint16 > (p_noro, pn_noro, c);

  • kernel/tgb_internal.h

    r3342df r47e836b  
    1111#define USE_NORO 1
    1212
     13#include <omalloc/omalloc.h>
    1314
    1415//#define TGB_DEBUG
    … …  
    4344//#define USE_STDVECBOOL 1
    4445#ifdef HAVE_BOOST
    45 #include <omalloc/omalloc.h>
    4646#include <vector>
    4747using boost::dynamic_bitset;
    … …  
    5252using std::vector;
    5353#endif
    54 
    55 #include <omalloc/omalloc.h>
     54#include <stdlib.h>
     55
    5656#include <polys/monomials/p_polys.h>
    5757
    … …  
    6161#include <misc/options.h>
    6262#include <polys/polys.h>
    63 #include <stdlib.h>
    6463#include <kernel/modulop.h>
    6564#include <kernel/kutil.h>
    … …  
    624623    //assume(impl.find(p_Copy(term,currRing))==impl.end());
    625624    //assume(len==pLength(nf));
    626     assume(npIsOne(p_GetCoeff(term,currRing)));
     625    assume(n_IsOne(p_GetCoeff(term,currRing),currRing->cf));
    627626    if (term==nf)
    628627    {
    … …  
    792791    number coef_bak=p_GetCoeff(t,c->r);
    793792
    794     p_SetCoeff(t,npInit(1,c->r),c->r);
    795     assume(npIsOne(p_GetCoeff(c->strat->S[i],c->r)));
     793    p_SetCoeff(t,n_Init(1,c->r->cf),c->r);
     794    assume(n_IsOne(p_GetCoeff(c->strat->S[i],c->r),c->r->cf));
    796795    number coefstrat=p_GetCoeff(c->strat->S[i],c->r);
    797796
    … …  
    799798    poly exp_diff=cache->temp_term;
    800799    p_ExpVectorDiff(exp_diff,t,c->strat->S[i],c->r);
    801     p_SetCoeff(exp_diff,npNeg(npInvers(coefstrat)),c->r);
     800    p_SetCoeff(exp_diff,n_Neg(n_Invers(coefstrat,c->r->cf),c->r->cf),c->r);
    802801    p_Setm(exp_diff,c->r);
    803802    assume(c->strat->S[i]!=NULL);
    … …  
    819818  } else {
    820819    number coef_bak=p_GetCoeff(t,c->r);
    821     number one=npInit(1, currRing);
     820    number one=n_Init(1, c->r->cf);
    822821    p_SetCoeff(t,one,c->r);
    823822
    … …  
    929928  const int len=row->len;
    930929  tgb_uint32 buffer[256];
    931   const tgb_uint32 prime=npPrimeM;
     930  const tgb_uint32 prime=n_GetChar(currRing->cf);
    932931  const tgb_uint32 c=F4mat_to_number_type(coef);
    933932  assume(!(npIsZero(coef)));
    … …  
    956955      assume(bpos<256);
    957956      assume(!(npIsZero((number)(long) buffer[bpos])));
    958       temp_array[idx]=F4mat_to_number_type(npAddM((number)(long) temp_array[idx], (number)(long) buffer[bpos++]));
     957      temp_array[idx]=F4mat_to_number_type(n_Add((number)(long) temp_array[idx], (number)(long) buffer[bpos++],currRing->cf));
    959958      assume(idx<temp_size);
    960959    }
    … …  
    970969  //const int len=temp_size;
    971970  tgb_uint32 buffer[256];
    972   const tgb_uint32 prime=npPrimeM;
     971  const tgb_uint32 prime=n_GetChar(currRing->cf);
    973972  const tgb_uint32 c=F4mat_to_number_type(coef);
    974973  assume(!(npIsZero(coef)));
    … …  
    997996      assume(bpos<256);
    998997      //assume(!(npIsZero((number) buffer[bpos])));
    999       temp_array[i]=F4mat_to_number_type(npAddM((number)(long) temp_array[i], (number)(long) buffer[bpos++]));
     998      temp_array[i]=F4mat_to_number_type(n_Add((number)(long) temp_array[i], (number)(long) buffer[bpos++],currRing->cf));
    1000999      assume(i<temp_size);
    10011000    }
    … …  
    10171016  for(i=0;i<len;i++)
    10181017  {
    1019       temp_array[i]=F4mat_to_number_type(npAddM((number)(long) temp_array[i], (number)(long) row[i]));
     1018      temp_array[i]=F4mat_to_number_type(n_Add((number)(long) temp_array[i], (number)(long) row[i],currRing->cf));
    10201019      assume(i<temp_size);
    10211020  }
    … …  
    10371036  {
    10381037
    1039       temp_array[i]=F4mat_to_number_type(npSubM((number)(long) temp_array[i], (number)(long) row[i]));
     1038      temp_array[i]=F4mat_to_number_type(n_Sub((number)(long) temp_array[i], (number)(long) row[i],currRing->cf));
    10401039      assume(i<temp_size);
    10411040  }
    … …  
    10531052        {
    10541053          int idx=idx_array[j];
    1055           temp_array[idx]=F4mat_to_number_type(   (number_type)(long)npAddM((number) (long)temp_array[idx],(number)(long) coef_array[j]));
     1054          temp_array[idx]=F4mat_to_number_type(   (number_type)(long)n_Add((number) (long)temp_array[idx],(number)(long) coef_array[j],currRing->cf));
    10561055          assume(idx<temp_size);
    10571056        }
    … …  
    10671066        {
    10681067          int idx=idx_array[j];
    1069           temp_array[idx]=F4mat_to_number_type(  (number_type)(long) npSubM((number) (long)temp_array[idx],(number)(long) coef_array[j]));
     1068          temp_array[idx]=F4mat_to_number_type(  (number_type)(long) n_Sub((number) (long)temp_array[idx],(number)(long) coef_array[j],currRing->cf));
    10701069          assume(idx<temp_size);
    10711070        }
    … …  
    10791078   int temp_size=cache->nIrreducibleMonomials;
    10801079   memset(temp_array,0,temp_size_bytes);
    1081    number minus_one=npInit(-1,currRing);
     1080   number minus_one=n_Init(-1,currRing->cf);
    10821081   int i;
    10831082   for(i=0;i<len;i++)
    … …  
    11301129         if (red.ref->value_len==NoroCache<number_type>::backLinkCode)
    11311130         {
    1132            temp_array[red.ref->term_index]=F4mat_to_number_type( npAddM((number)(long) temp_array[red.ref->term_index],red.coef));
     1131           temp_array[red.ref->term_index]=F4mat_to_number_type( n_Add((number)(long) temp_array[red.ref->term_index],red.coef,currRing->cf));
    11331132         }
    11341133         else
    … …  
    11781177    assume(coef_array[j]!=0);
    11791178    CoefIdx<number_type> ci;
    1180     ci.coef=F4mat_to_number_type(npMultM((number)(long) coef,(number)(long) coef_array[j]));
     1179    ci.coef=F4mat_to_number_type(n_Mult((number)(long) coef,(number)(long) coef_array[j],currRing->cf));
    11811180    ci.idx=idx_array[j];
    11821181    pairs[pos++]=ci;
    … …  
    11931192      assume(coef_array[j]!=0);
    11941193      CoefIdx<number_type> ci;
    1195       ci.coef=F4mat_to_number_type(npMultM((number)(long) coef,(number)(long) coef_array[j]));
     1194      ci.coef=F4mat_to_number_type(n_Mult((number)(long) coef,(number)(long) coef_array[j],currRing->cf));
    11961195      assume(ci.coef!=0);
    11971196      ci.idx=j;
    … …  
    12281227      assume(coef_array[j]!=0);
    12291228      CoefIdx<number_type> ci;
    1230       ci.coef=F4mat_to_number_type(npNegM((number)(long) coef_array[j]));
     1229      ci.coef=F4mat_to_number_type(n_Neg((number)(long) coef_array[j],currRing->cf));
    12311230      assume(ci.coef!=0);
    12321231      ci.idx=j;
    … …  
    12551254    assume(coef_array[j]!=0);
    12561255    CoefIdx<number_type> ci;
    1257     ci.coef=F4mat_to_number_type(npNegM(coef_array[j]));
     1256    ci.coef=F4mat_to_number_type(n_Neg((number)coef_array[j],currRing->cf));
    12581257    ci.idx=idx_array[j];
    12591258    pairs[pos++]=ci;
    … …  
    12831282  CoefIdx<number_type>* pairs=(CoefIdx<number_type>*) cache->tempBuffer; //omalloc(together*sizeof(CoefIdx<number_type>));
    12841283  int pos=0;
    1285   const number one=npInit(1, currRing);
    1286   const number minus_one=npInit(-1, currRing);
     1284  const number one=n_Init(1, currRing->cf);
     1285  const number minus_one=n_Init(-1, currRing->cf);
    12871286  for(i=0;i<len;i++)
    12881287  {
    … …  
    13631362    else
    13641363    {
    1365       pairs[act].coef=F4mat_to_number_type(npAddM((number)(long)pairs[act].coef,(number)(long)pairs[i].coef));
     1364      pairs[act].coef=F4mat_to_number_type(n_Add((number)(long)pairs[act].coef,(number)(long)pairs[i].coef,currRing->cf));
    13661365    }
    13671366  }
    … …  
    15301529    for(i=startIndices[row];i<ncols;i++)
    15311530    {
    1532       row_array[i]=F4mat_to_number_type(npMult((number)(long) row_array[i],(number)(long) coef));
     1531      row_array[i]=F4mat_to_number_type(n_Mult((number)(long) row_array[i],(number)(long) coef,currRing->cf));
    15331532    }
    15341533  }
    … …  
    15371536    //assume rows "under r" have bigger or equal start index
    15381537    number_type* row_array=rows[r];
    1539     number_type zero=F4mat_to_number_type(npInit(0, currRing));
     1538    number_type zero=F4mat_to_number_type((number)0 /*npInit(0, currRing)*/);
    15401539    int start=startIndices[r];
    15411540    number_type coef=row_array[start];
    … …  
    15431542    int other_row;
    15441543    assume(!(npIsZero((number)(long) row_array[start])));
    1545     if (!(npIsOne((number)(long) coef)))
    1546       multiplyRow(r,F4mat_to_number_type(npInvers((number)(long) coef)));
    1547     assume(npIsOne((number)(long) row_array[start]));
     1544    if (!(n_IsOne((number)(long) coef,currRing->cf)))
     1545      multiplyRow(r,F4mat_to_number_type(n_Invers((number)(long) coef,currRing->cf)));
     1546    assume(n_IsOne((number)(long) row_array[start],currRing->cf));
    15481547    int lastIndex=modP_lastIndexRow(row_array, ncols);
    1549     number minus_one=npInit(-1, currRing);
     1548    number minus_one=n_Init(-1, currRing->cf);
    15501549    for (other_row=r+1;other_row<nrows;other_row++)
    15511550    {
    … …  
    15551554        int i;
    15561555        number_type* other_row_array=rows[other_row];
    1557         number coef2=npNeg((number)(long) other_row_array[start]);
     1556        number coef2=n_Neg((number)(long) other_row_array[start],currRing->cf);
    15581557        if (coef2==minus_one)
    15591558        {
    … …  
    15611560          {
    15621561            if (row_array[i]!=zero)
    1563               other_row_array[i]=F4mat_to_number_type(npSubM((number)(long) other_row_array[i], (number)(long) row_array[i]));
     1562              other_row_array[i]=F4mat_to_number_type(n_Sub((number)(long) other_row_array[i], (number)(long) row_array[i],currRing->cf));
    15641563          }
    15651564      }
    … …  
    15701569          {
    15711570            if (row_array[i]!=zero)
    1572             other_row_array[i]=F4mat_to_number_type(npAddM(npMult(coef2,(number)(long) row_array[i]),(number) (long)other_row_array[i]));
     1571            other_row_array[i]=F4mat_to_number_type(n_Add(n_Mult(coef2,(number)(long) row_array[i],currRing->cf),(number)(long) other_row_array[i],currRing->cf));
    15731572          }
    15741573        }
    … …  
    16361635    for(i=startIndices[row];i<ncols;i++)
    16371636    {
    1638       row_array[i]=(number_type)(long)(npMult((number)(long) row_array[i],(number)(long) coef));
     1637      row_array[i]=F4mat_to_number_type(n_Mult((number)(long) row_array[i],(number)(long) coef,currRing->cf));
    16391638    }
    16401639  }
    … …  
    16961695    assume(start<ncols);
    16971696    int other_row;
    1698     if (!(npIsOne((number)(long) row_array[r])))
     1697    if (!(n_IsOne((number)(long) row_array[r],currRing->cf)))
    16991698    {
    17001699      //it should be one, but this safety is not expensive
    1701       multiplyRow(r, (number_type)(long)(npInvers((number)(long) row_array[start])));
     1700      multiplyRow(r, F4mat_to_number_type(n_Invers((number)(long) row_array[start],currRing->cf)));
    17021701    }
    17031702    int lastIndex=modP_lastIndexRow(row_array, ncols);
    … …  
    17101709      {
    17111710        number_type* other_row_array=rows[other_row];
    1712         number coef=((number)(long) other_row_array[start]);
    1713         coef=npNeg(coef);
     1711        number coef=n_Neg((number)(long) other_row_array[start],currRing->cf);
    17141712        assume(!(npIsZero(coef)));
    17151713        int i;
    … …  
    17181716        {
    17191717          if (row_array[i]!=zero)
    1720             other_row_array[i]=(number_type)(long)(npAddM(npMult(coef,(number)(long)row_array[i]),(number)(long)other_row_array[i]));
     1718            other_row_array[i]=F4mat_to_number_type(n_Add(n_Mult(coef,(number)(long)row_array[i],currRing->cf),(number)(long)other_row_array[i],currRing->cf));
    17211719        }
    17221720        updateLastReducibleIndex(other_row,r);

  • kernel/tgbgauss.cc

    r3342df r47e836b  
    272272        number n2=c2;
    273273
    274         ksCheckCoeff(&n1,&n2);
     274        ksCheckCoeff(&n1,&n2,currRing->cf);
    275275        //nDelete(&c1);
    276276        n1=nNeg(n1);
    … …  
    432432          number n2=c2;
    433433
    434           ksCheckCoeff(&n1,&n2);
     434          ksCheckCoeff(&n1,&n2,currRing->cf);
    435435          nDelete(&c1);
    436436          mat->mult_row(i,n2);
    … …  
    887887      while (p!=NULL)
    888888      {
    889         d = nIntDiv(pGetCoeff(p),h);
     889        d = nIntDiv(p->coef,h);
    890890        nDelete(&p->coef);
    891891        p->coef=d;

  • kernel/tgbgauss.h

    r3342df r47e836b  
    1010#include <kernel/mod2.h>
    1111#include <coeffs/numbers.h>
     12#include <polys/monomials/p_polys.h>
    1213//#include "tgb_internal.h"
    1314
Note: See TracChangeset for help on using the changeset viewer.