Changeset 8e51ca in git


Ignore:
Timestamp:
Nov 20, 2012, 4:49:14 PM (10 years ago)
Author:
Oleksandr Motsak <motsak@…>
Branches:
(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', 'a800fe4b3e9d37a38c5a10cc0ae9dfa0c15a4ee6')
Children:
5edb7729cce147b1b9aa7e0c72198afd4ac4fa9c
Parents:
780b5285f9d867d03d9da5298c36e8bedf88eaf4bffe62d52befbed8110ddaf99bd0d711e101f9d4
Message:
Merge pull request #208 from mmklee/factory_clang_sw

Factory clang sw
Location:
factory
Files:
2 added
25 edited

Legend:

Unmodified
Added
Removed

  • factory/FLINTconvert.cc

    r780b52 r8e51ca  
    122122  {
    123123    CanonicalForm c= i.coeff();
    124     if (!c.isImm()) c.mapinto(); //c%= getCharacteristic();
     124    if (!c.isImm()) c=c.mapinto(); //c%= getCharacteristic();
    125125    if (!c.isImm())
    126126    {  //This case will never happen if the characteristic is in fact a prime

  • factory/Makefile.am

    r780b52 r8e51ca  
    8383                facIrredTest.cc \
    8484                facMul.cc \
     85                facNTLzzpEXGCD.cc \
    8586                facSparseHensel.cc \
    8687                ffops.cc \
    … …  
    162163                facIrredTest.h \
    163164                facMul.h \
     165                facNTLzzpEXGCD.h \
    164166                facSparseHensel.h \
    165167                ffops.h \

  • factory/NTLconvert.cc

    r780b52 r8e51ca  
    125125
    126126    CanonicalForm c=i.coeff();
    127     if (!c.isImm()) c.mapinto(); //c%= getCharacteristic();
     127    if (!c.isImm()) c=c.mapinto(); //c%= getCharacteristic();
    128128    if (!c.isImm())
    129129    {  //This case will never happen if the characteristic is in fact a prime

  • factory/algext.cc

    r780b52 r8e51ca  
    2626#include "cf_map.h"
    2727#include "cf_generator.h"
     28#include "facMul.h"
     29#include "facNTLzzpEXGCD.h"
    2830
    2931#ifdef HAVE_NTL
    … …  
    365367static CanonicalForm tryvcontent ( const CanonicalForm & f, const Variable & x, const CanonicalForm & M, bool & fail );
    366368static CanonicalForm trycf_content ( const CanonicalForm & f, const CanonicalForm & g, const CanonicalForm & M, bool & fail );
    367 static void tryDivide( const CanonicalForm & f, const CanonicalForm & g, const CanonicalForm & M, CanonicalForm & result, bool & divides, bool & fail );
    368369
    369370static inline CanonicalForm
    … …  
    463464    mv = g.level();
    464465  // here: mv is level of the largest variable in f, g
     466  Variable v1= Variable (1);
     467#ifdef HAVE_NTL
     468  Variable v= M.mvar();
     469  if (fac_NTL_char != getCharacteristic())
     470  {
     471    fac_NTL_char= getCharacteristic();
     472    zz_p::init (getCharacteristic());
     473  }
     474  zz_pX NTLMipo= convertFacCF2NTLzzpX (M);
     475  zz_pE::init (NTLMipo);
     476  zz_pEX NTLResult;
     477  zz_pEX NTLF;
     478  zz_pEX NTLG;
     479#endif
    465480  if(mv == 1) // f,g univariate
    466481  {
    467482    TIMING_START (alg_euclid_p)
     483#ifdef HAVE_NTL
     484    NTLF= convertFacCF2NTLzz_pEX (f, NTLMipo);
     485    NTLG= convertFacCF2NTLzz_pEX (g, NTLMipo);
     486    tryNTLGCD (NTLResult, NTLF, NTLG, fail);
     487    if (fail)
     488      return;
     489    result= convertNTLzz_pEX2CF (NTLResult, f.mvar(), v);
     490#else
    468491    tryEuclid(f,g,M,result,fail);
     492    if(fail)
     493      return;
     494#endif
    469495    TIMING_END_AND_PRINT (alg_euclid_p, "time for euclidean alg mod p: ")
    470     if(fail)
    471       return;
    472496    result= NN (reduce (result, M)); // do not forget to map back
    473497    return;
    … …  
    482506    return;
    483507  CanonicalForm c;
     508#ifdef HAVE_NTL
     509  NTLF= convertFacCF2NTLzz_pEX (cf, NTLMipo);
     510  NTLG= convertFacCF2NTLzz_pEX (cg, NTLMipo);
     511  tryNTLGCD (NTLResult, NTLF, NTLG, fail);
     512  if (fail)
     513    return;
     514  c= convertNTLzz_pEX2CF (NTLResult, v1, v);
     515#else
    484516  tryEuclid(cf,cg,M,c,fail);
    485517  if(fail)
    486518    return;
     519#endif
    487520  // f /= cf
    488521  f.tryDiv (cf, M, fail);
    … …  
    518551  CanonicalForm gamma;
    519552  TIMING_START (alg_euclid_p)
     553#ifdef HAVE_NTL
     554  NTLF= convertFacCF2NTLzz_pEX (firstLC (f), NTLMipo);
     555  NTLG= convertFacCF2NTLzz_pEX (firstLC (g), NTLMipo);
     556  tryNTLGCD (NTLResult, NTLF, NTLG, fail);
     557  if (fail)
     558    return;
     559  gamma= convertNTLzz_pEX2CF (NTLResult, v1, v);
     560#else
    520561  tryEuclid( firstLC(f), firstLC(g), M, gamma, fail );
     562  if(fail)
     563    return;
     564#endif
    521565  TIMING_END_AND_PRINT (alg_euclid_p, "time for gcd of lcs in alg mod p: ")
    522   if(fail)
    523     return;
    524566  for(int i=2; i<=mv; i++) // entries at i=0,1 not visited
    525567    if(N[i] < L[i])
    … …  
    822864        equal= true; // modular image did not add any new information
    823865      TIMING_START (alg_termination)
     866#ifdef HAVE_FLINT
     867      if (equal && tmp.isUnivariate() && f.isUnivariate() && g.isUnivariate()
     868          && f.level() == tmp.level() && tmp.level() == g.level())
     869      {
     870        CanonicalForm Q, R, sf, sg, stmp;
     871        Variable x= Variable (1);
     872        sf= swapvar (f, f.mvar(), x);
     873        sg= swapvar (g, f.mvar(), x);
     874        stmp= swapvar (tmp, f.mvar(), x);
     875        newtonDivrem (sf, stmp, Q, R);
     876        if (R.isZero())
     877        {
     878          newtonDivrem (sg, stmp, Q, R);
     879          if (R.isZero())
     880          {
     881            Off (SW_RATIONAL);
     882            setReduce (a,true);
     883            if (off_rational) Off(SW_RATIONAL); else On(SW_RATIONAL);
     884            TIMING_END_AND_PRINT (alg_termination,
     885                                 "time for successful termination test in alg gcd: ")
     886            return tmp*gcdcfcg;
     887          }
     888        }
     889      }
     890      else
     891#endif
    824892      if(equal && fdivides( tmp, f ) && fdivides( tmp, g )) // trial division
    825893      {
    … …  
    10171085  }
    10181086  return abs( f );
    1019 }
    1020 
    1021 
    1022 static void tryDivide( const CanonicalForm & f, const CanonicalForm & g, const CanonicalForm & M, CanonicalForm & result, bool & divides, bool & fail )
    1023 { // M "univariate" monic polynomial
    1024   // f, g polynomials with coeffs modulo M.
    1025   // if f is divisible by g, 'divides' is set to 1 and 'result' == f/g mod M coefficientwise.
    1026   // 'fail' is set to 1, iff a zero divisor is encountered.
    1027   // divides==1 implies fail==0
    1028   // required: getReduce(M.mvar())==0
    1029   if(g.inBaseDomain())
    1030   {
    1031     result = f/g;
    1032     divides = true;
    1033     return;
    1034   }
    1035   if(g.inCoeffDomain())
    1036   {
    1037     tryInvert(g,M,result,fail);
    1038     if(fail)
    1039       return;
    1040     result = reduce(f*result, M);
    1041     divides = true;
    1042     return;
    1043   }
    1044   // here: g NOT inCoeffDomain
    1045   Variable x = g.mvar();
    1046   if(f.degree(x) < g.degree(x))
    1047   {
    1048     divides = false;
    1049     return;
    1050   }
    1051   // here: f.degree(x) > 0 and f.degree(x) >= g.degree(x)
    1052   CanonicalForm F = f;
    1053   CanonicalForm q, leadG = LC(g);
    1054   result = 0;
    1055   while(!F.isZero())
    1056   {
    1057     tryDivide(F.LC(x),leadG,M,q,divides,fail);
    1058     if(fail || !divides)
    1059       return;
    1060     if(F.degree(x)<g.degree(x))
    1061     {
    1062       divides = false;
    1063       return;
    1064     }
    1065     q *= power(x,F.degree(x)-g.degree(x));
    1066     result += q;
    1067     F = reduce(F-q*g, M);
    1068   }
    1069   result = reduce(result, M);
    1070   divides = true;
    10711087}
    10721088

  • factory/cfModResultant.cc

    r780b52 r8e51ca  
    1414
    1515#include "cf_assert.h"
     16#include "timing.h"
    1617
    1718#include "cfModResultant.h"
    … …  
    2930#include "FLINTconvert.h"
    3031#endif
     32
     33TIMING_DEFINE_PRINT(fac_resultant_p)
    3134
    3235//TODO arrange by bound= deg (F,xlevel)*deg (G,i)+deg (G,xlevel)*deg (F, i)
    … …  
    255258  return CanonicalForm ((long) FLINTresult);
    256259#else
    257   zz_pBak bak;
    258   bak.save();
    259   zz_p::init (getCharacteristic());
     260  if (fac_NTL_char != getCharacteristic())
     261  {
     262    fac_NTL_char= getCharacteristic();
     263    zz_p::init (getCharacteristic());
     264  }
    260265  zz_pX NTLF= convertFacCF2NTLzzpX (F);
    261266  zz_pX NTLG= convertFacCF2NTLzzpX (G);
    … …  
    263268  zz_p NTLResult= resultant (NTLF, NTLG);
    264269
    265   bak.restore();
    266270  return CanonicalForm (to_long (rep (NTLResult)));
    267271#endif
    … …  
    327331    return power (B, degAx);
    328332
     333  if (A.isUnivariate() && B.isUnivariate() && A.level() == B.level())
     334    return uniResultant (A, B);
     335
    329336  CanonicalForm F= A;
    330337  CanonicalForm G= B;
    … …  
    337344
    338345  Variable y= Variable (2);
    339 
    340   if (F.isUnivariate() && G.isUnivariate() && F.level() == G.level())
    341     return N(uniResultant (F, G));
    342346
    343347  int i= -1;
    … …  
    363367    if (H == modResult)
    364368      equalCount++;
     369    else
     370      equalCount= 0;
    365371
    366372    count++;
    … …  
    473479  CanonicalForm resultModP, q (0), newResult, newQ;
    474480  CanonicalForm result;
     481  int equalCount= 0;
     482  CanonicalForm test, newTest;
     483  int count= 0;
    475484  do
    476485  {
    … …  
    487496    setCharacteristic (p);
    488497
     498    TIMING_START (fac_resultant_p);
    489499    resultModP= resultantFp (mapinto (F), mapinto (G), X, prob);
     500    TIMING_END_AND_PRINT (fac_resultant_p, "time to compute resultant mod p: ");
    490501
    491502    setCharacteristic (0);
    492503
     504    count++;
    493505    if ( q.isZero() )
    494506    {
    … …  
    501513      q= newQ;
    502514      result= newResult;
    503       if (newQ > bound)
    504       {
    505         result= symmetricRemainder (result, q);
     515      test= symmetricRemainder (result,q);
     516      if (test != newTest)
     517      {
     518        newTest= test;
     519        equalCount= 0;
     520      }
     521      else
     522        equalCount++;
     523      if (newQ > bound || (prob && equalCount == 2))
     524      {
     525        result= test;
    506526        break;
    507527      }

  • factory/cf_gcd.cc

    r780b52 r8e51ca  
    4545
    4646bool
    47 gcd_test_one ( const CanonicalForm & f, const CanonicalForm & g, bool swap )
    48 {
     47gcd_test_one ( const CanonicalForm & f, const CanonicalForm & g, bool swap, int & d )
     48{
     49    d= 0;
    4950    int count = 0;
    5051    // assume polys have same level;
    … …  
    114115      if (p == 2 && d < 6)
    115116      {
    116         zz_p::init (p);
     117        if (fac_NTL_char != 2)
     118        {
     119          fac_NTL_char= 2;
     120          zz_p::init (p);
     121        }
    117122        bool primFail= false;
    118123        Variable vBuf;
    … …  
    138143      else if ((p == 3 && d < 4) || ((p == 5 || p == 7) && d < 3))
    139144      {
    140         zz_p::init (p);
     145        if (fac_NTL_char != p)
     146        {
     147          fac_NTL_char= p;
     148          zz_p::init (p);
     149        }
    141150        bool primFail= false;
    142151        Variable vBuf;
    … …  
    218227    }
    219228
    220     if ( eval1.taildegree() > 0 && eval2.taildegree() > 0 )
    221     {
    222         if (passToGF)
    223           setCharacteristic (p);
    224         if (k > 1)
    225           setCharacteristic (p, k, gf_name);
    226         return false;
    227     }
    228 
    229229    CanonicalForm c= gcd (eval1, eval2);
    230     bool result= c.degree() < 1;
     230    d= c.degree();
     231    bool result= d < 1;
     232    if (d < 0)
     233      d= 0;
    231234
    232235    if (passToGF)
    … …  
    463466//}}}
    464467
    465 //{{{ static CanonicalForm balance ( const CanonicalForm & f, const CanonicalForm & q )
     468//{{{ static CanonicalForm balance_p ( const CanonicalForm & f, const CanonicalForm & q )
    466469//{{{ docu
    467470//
    468 // balance() - map f from positive to symmetric representation
     471// balance_p() - map f from positive to symmetric representation
    469472//   mod q.
    470473//
    … …  
    476479//}}}
    477480static CanonicalForm
     481balance_p ( const CanonicalForm & f, const CanonicalForm & q )
     482{
     483    Variable x = f.mvar();
     484    CanonicalForm result = 0, qh = q / 2;
     485    CanonicalForm c;
     486    CFIterator i;
     487    for ( i = f; i.hasTerms(); i++ )
     488    {
     489        c = i.coeff();
     490        if ( c.inCoeffDomain())
     491        {
     492          if ( c > qh )
     493            result += power( x, i.exp() ) * (c - q);
     494          else
     495            result += power( x, i.exp() ) * c;
     496        }
     497        else
     498          result += power( x, i.exp() ) * balance_p(c,q);
     499    }
     500    return result;
     501}
     502
     503/*static CanonicalForm
    478504balance ( const CanonicalForm & f, const CanonicalForm & q )
    479505{
    … …  
    490516    }
    491517    return result;
    492 }
     518}*/
    493519//}}}
    494520
    … …  
    566592    {
    567593      // now balance D mod q
    568       D = pp( balance( D, q ) );
     594      D = pp( balance_p( D, q ) );
    569595      if ( fdivides( D, f ) && fdivides( D, g ) )
    570596        return D * c;
    … …  
    597623    pi1 = pi1 / Ci1; pi = pi / Ci;
    598624    C = gcd( Ci, Ci1 );
     625    int d= 0;
    599626    if ( !( pi.isUnivariate() && pi1.isUnivariate() ) )
    600627    {
    601         if ( gcd_test_one( pi1, pi, true ) )
     628        if ( gcd_test_one( pi1, pi, true, d ) )
    602629        {
    603630          C=abs(C);
    … …  
    716743    pi1 = pi1 / Ci1; pi = pi / Ci;
    717744    C = gcd( Ci, Ci1 );
     745    int d= 0;
    718746    if ( pi.isUnivariate() && pi1.isUnivariate() )
    719747    {
    … …  
    729757        return gcd_poly_univar0( pi, pi1, true ) * C;
    730758    }
    731     else if ( gcd_test_one( pi1, pi, true ) )
     759    else if ( gcd_test_one( pi1, pi, true, d ) )
    732760      return C;
    733761    Variable v = f.mvar();
    … …  
    12041232    delete [] degsg;
    12051233}*/
    1206 
    1207 
    1208 static CanonicalForm
    1209 balance_p ( const CanonicalForm & f, const CanonicalForm & q )
    1210 {
    1211     Variable x = f.mvar();
    1212     CanonicalForm result = 0, qh = q / 2;
    1213     CanonicalForm c;
    1214     CFIterator i;
    1215     for ( i = f; i.hasTerms(); i++ )
    1216     {
    1217         c = i.coeff();
    1218         if ( c.inCoeffDomain())
    1219         {
    1220           if ( c > qh )
    1221             result += power( x, i.exp() ) * (c - q);
    1222           else
    1223             result += power( x, i.exp() ) * c;
    1224         }
    1225         else
    1226           result += power( x, i.exp() ) * balance_p(c,q);
    1227     }
    1228     return result;
    1229 }
    12301234
    12311235TIMING_DEFINE_PRINT(chinrem_termination)

  • factory/cf_gcd_smallp.cc

    r780b52 r8e51ca  
    414414Variable chooseExtension (const Variable & alpha)
    415415{
    416   zz_p::init (getCharacteristic());
     416  if (fac_NTL_char != getCharacteristic())
     417  {
     418    fac_NTL_char= getCharacteristic();
     419    zz_p::init (getCharacteristic());
     420  }
    417421  zz_pX NTLIrredpoly;
    418422  int i, m;
    … …  
    440444{
    441445  int p= getCharacteristic();
    442   zz_p::init (p);
     446  if (p != fac_NTL_char)
     447  {
     448    fac_NTL_char= p;
     449    zz_p::init (p);
     450  }
    443451  zz_pX NTLirredpoly;
    444452  //TODO: replace d by max_{i} (deg_x{i}(f))
    … …  
    13331341{
    13341342  int p= getCharacteristic();
    1335   zz_p::init (p);
     1343  if (fac_NTL_char != p)
     1344  {
     1345    fac_NTL_char= p;
     1346    zz_p::init (p);
     1347  }
    13361348  zz_pX NTLirredpoly;
    13371349  CanonicalForm CFirredpoly;
    … …  
    19982010#else
    19992011  int p= getCharacteristic ();
    2000   zz_p::init (p);
     2012  if (fac_NTL_char != p)
     2013  {
     2014    fac_NTL_char= p;
     2015    zz_p::init (p);
     2016  }
    20012017  mat_zz_p *NTLN= convertFacCFMatrix2NTLmat_zz_p(*N);
    20022018  long rk= gauss (*NTLN);
    … …  
    20282044    (*N) (j, M.columns() + 1)= L[i];
    20292045  int p= getCharacteristic ();
    2030   zz_p::init (p);
     2046  if (fac_NTL_char != p)
     2047  {
     2048    fac_NTL_char= p;
     2049    zz_p::init (p);
     2050  }
    20312051  zz_pX NTLMipo= convertFacCF2NTLzzpX (getMipo (alpha));
    20322052  zz_pE::init (NTLMipo);
    … …  
    20692089#else
    20702090  int p= getCharacteristic ();
    2071   zz_p::init (p);
     2091  if (fac_NTL_char != p)
     2092  {
     2093    fac_NTL_char= p;
     2094    zz_p::init (p);
     2095  }
    20722096  mat_zz_p *NTLN= convertFacCFMatrix2NTLmat_zz_p(*N);
    20732097  long rk= gauss (*NTLN);
    … …  
    21092133    (*N) (j, M.columns() + 1)= L[i];
    21102134  int p= getCharacteristic ();
    2111   zz_p::init (p);
     2135  if (fac_NTL_char != p)
     2136  {
     2137    fac_NTL_char= p;
     2138    zz_p::init (p);
     2139  }
    21122140  zz_pX NTLMipo= convertFacCF2NTLzzpX (getMipo (alpha));
    21132141  zz_pE::init (NTLMipo);
    … …  
    45474575  }
    45484576
    4549   if( gcd_test_one( F, G, false ) )
     4577  int dummy= 0;
     4578  if( gcd_test_one( F, G, false, dummy ) )
    45504579  {
    45514580    return N (d);
    … …  
    45624591  {
    45634592    if (p == 2)
    4564       setCharacteristic (2, 6, 'Z');
     4593      setCharacteristic (2, 12, 'Z');
    45654594    else if (p == 3)
    45664595      setCharacteristic (3, 4, 'Z');
    … …  
    45934622    if (p == 2 && d < 6)
    45944623    {
    4595       zz_p::init (p);
     4624      if (fac_NTL_char != p)
     4625      {
     4626        fac_NTL_char= p;
     4627        zz_p::init (p);
     4628      }
    45964629      bool primFail= false;
    45974630      Variable vBuf;
    … …  
    46174650    else if ((p == 3 && d < 4) || ((p == 5 || p == 7) && d < 3))
    46184651    {
    4619       zz_p::init (p);
     4652      if (fac_NTL_char != p)
     4653      {
     4654        fac_NTL_char= p;
     4655        zz_p::init (p);
     4656      }
    46204657      bool primFail= false;
    46214658      Variable vBuf;

  • factory/cf_map_ext.cc

    r780b52 r8e51ca  
    6767{
    6868  int p= getCharacteristic ();
    69   zz_p::init (p);
     69  if (fac_NTL_char != p)
     70  {
     71    fac_NTL_char= p;
     72    zz_p::init (p);
     73  }
    7074  zz_pX NTL_mipo= convertFacCF2NTLzzpX (getMipo (beta));
    7175  zz_pE::init (NTL_mipo);
    … …  
    325329  int d= degree (mipo);
    326330  int p= getCharacteristic ();
    327   zz_p::init (p);
     331  if (fac_NTL_char != p)
     332  {
     333    fac_NTL_char= p;
     334    zz_p::init (p);
     335  }
    328336  zz_pX NTL_mipo;
    329337  CanonicalForm mipo2;
    … …  
    378386    CanonicalForm primElemMipo= findMinPoly (primElem, alpha);
    379387    int p= getCharacteristic ();
    380     zz_p::init (p);
     388    if (fac_NTL_char != p)
     389    {
     390      fac_NTL_char= p;
     391      zz_p::init (p);
     392    }
    381393    zz_pX NTLMipo= convertFacCF2NTLzzpX (getMipo (beta));
    382394    zz_pE::init (NTLMipo);
    … …  
    399411  }
    400412  int p= getCharacteristic ();
    401   zz_p::init (p);
     413  if (fac_NTL_char != p)
     414  {
     415    fac_NTL_char= p;
     416    zz_p::init (p);
     417  }
    402418  zz_pX NTL_mipo= convertFacCF2NTLzzpX (getMipo (beta));
    403419  zz_pE::init (NTL_mipo);
    … …  
    422438  ASSERT (F.isUnivariate() && F.mvar()==alpha,"expected element of F_p(alpha)");
    423439
    424   zz_p::init (getCharacteristic());
     440  if (fac_NTL_char != getCharacteristic())
     441  {
     442    fac_NTL_char= getCharacteristic();
     443    zz_p::init (getCharacteristic());
     444  }
    425445  zz_pX NTLF= convertFacCF2NTLzzpX (F);
    426446  int d= degree (getMipo (alpha));

  • factory/facAlgExt.cc

    r780b52 r8e51ca  
    3535TIMING_DEFINE_PRINT(fac_alg_sqrf)
    3636TIMING_DEFINE_PRINT(fac_alg_factor_sqrf)
     37TIMING_DEFINE_PRINT(fac_alg_time_shift)
    3738
    3839// squarefree part of F
    … …  
    126127  ASSERT (degree (norm, alpha) <= 0, "wrong norm computed");
    127128  TIMING_START (fac_alg_factor_norm);
     129  bool save_sort= !isOn (SW_USE_NTL_SORT);
     130  On (SW_USE_NTL_SORT);
    128131  CFFList normFactors= factorize (norm);
     132  if (save_sort)
     133    Off (SW_USE_NTL_SORT);
    129134  TIMING_END_AND_PRINT (fac_alg_factor_norm, "time to factor norm: ");
    130135  CFList factors;
    … …  
    136141
    137142  normFactors.removeFirst();
     143  CFFListIterator i= normFactors;
    138144  CanonicalForm buf;
    139   buf= f;
     145  bool shiftBuf= false;
     146  if (!(normFactors.length() == 2 && degree (i.getItem().factor()) <= degree (f)))
     147  {
     148    TIMING_START (fac_alg_time_shift);
     149    if (shift != 0)
     150      buf= f (f.mvar() - shift*alpha, f.mvar());
     151    else
     152      buf= f;
     153    shiftBuf= true;
     154    TIMING_END_AND_PRINT (fac_alg_time_shift, "time to shift: ");
     155  }
     156  else
     157    buf= f;
    140158  CanonicalForm factor;
    141   for (CFFListIterator i= normFactors; i.hasItem(); i++)
     159  int count= 0;
     160  for (; i.hasItem(); i++)
    142161  {
    143162    ASSERT (i.getItem().exp() == 1, "norm not squarefree");
    144163    TIMING_START (fac_alg_gcd);
    145     if (shift == 0)
     164    if (shiftBuf)
    146165      factor= gcd (buf, i.getItem().factor());
    147166    else
    148       factor= gcd (buf, i.getItem().factor() (f.mvar() + shift*alpha, f.mvar()));
     167    {
     168      if (shift == 0)
     169        factor= gcd (buf, i.getItem().factor());
     170      else
     171        factor= gcd (buf, i.getItem().factor() (f.mvar() + shift*alpha, f.mvar()));
     172    }
    149173    buf /= factor;
     174    if (shiftBuf)
     175    {
     176      if (shift != 0)
     177        factor= factor (f.mvar() + shift*alpha, f.mvar());
     178    }
    150179    TIMING_END_AND_PRINT (fac_alg_gcd, "time to recover factors: ");
    151180    factors.append (factor);
     181    count++;
     182    if (normFactors.length() - 1 == count)
     183    {
     184      if (shiftBuf)
     185        factors.append (buf (f.mvar() + shift*alpha, f.mvar()));
     186      else
     187        factors.append (buf);
     188      buf= 1;
     189      break;
     190    }
    152191  }
    153192  ASSERT (degree (buf) <= 0, "incomplete factorization");

  • factory/facBivar.cc

    r780b52 r8e51ca  
    357357              (prod (bufUniFactors) == bufAeval));
    358358
     359    if (bufUniFactors.getFirst().inCoeffDomain())
     360      bufUniFactors.removeFirst();
     361
     362    if (bufUniFactors.length() == 1)
     363    {
     364      factors.append (A);
     365
     366      appendSwapDecompress (factors, conv (contentAxFactors),
     367                            conv (contentAyFactors), swap, swap2, N);
     368
     369      if (isOn (SW_RATIONAL))
     370        normalize (factors);
     371      return factors;
     372    }
     373
    359374    TIMING_START (fac_uni_factorizer);
    360375    if (extension)
    … …  
    367382              (prod (bufUniFactors2) == bufAeval2));
    368383
    369     if (bufUniFactors.getFirst().inCoeffDomain())
    370       bufUniFactors.removeFirst();
    371384    if (bufUniFactors2.getFirst().inCoeffDomain())
    372385      bufUniFactors2.removeFirst();
    373     if (bufUniFactors.length() == 1 || bufUniFactors2.length() == 1)
     386    if (bufUniFactors2.length() == 1)
    374387    {
    375388      factors.append (A);

  • factory/facFactorize.cc

    r780b52 r8e51ca  
    401401    oldAeval[i]= Aeval2[i];
    402402
    403   getLeadingCoeffs (A, Aeval2, uniFactors, evaluation);
     403  getLeadingCoeffs (A, Aeval2);
    404404
    405405  CFList biFactorsLCs;
    … …  
    622622                !isOnlyLeadingCoeff(iter2.getItem())) //content divides LCmultiplier completely and factor consists of more terms than just the leading coeff
    623623            {
    624               int index2= 1;
    625               for (CFListIterator iter3= leadingCoeffs2[lengthAeval2-1];
    626                    iter3.hasItem(); iter3++, index2++)
     624              Variable xx= Variable (2);
     625              CanonicalForm vars;
     626              vars= power (xx, degree (LC (getItem(oldBiFactors, index),1),
     627                                        xx));
     628              for (int i= 0; i < lengthAeval2; i++)
    627629              {
    628                 if (index2 == index)
     630                if (oldAeval[i].isEmpty())
     631                  continue;
     632                xx= oldAeval[i].getFirst().mvar();
     633                vars *= power (xx, degree (LC (getItem(oldAeval[i], index),1),
     634                                           xx));
     635              }
     636              if (vars.level() <= 2)
     637              {
     638                int index2= 1;
     639                for (CFListIterator iter3= leadingCoeffs2[lengthAeval2-1];
     640                     iter3.hasItem(); iter3++, index2++)
    629641                {
    630                   iter3.getItem() /= LCmultiplier;
    631                   break;
     642                  if (index2 == index)
     643                  {
     644                    iter3.getItem() /= LCmultiplier;
     645                    break;
     646                  }
    632647                }
     648                A /= LCmultiplier;
     649                foundMultiplier= true;
     650                iter.getItem()= 1;
    633651              }
    634               A /= LCmultiplier;
    635               foundMultiplier= true;
    636               iter.getItem()= 1;
    637652            }
    638653          }

  • factory/facFqBivar.cc

    r780b52 r8e51ca  
    155155          "univariate polynomial expected or constant expected");
    156156  CFFList factorsA;
    157   zz_p::init (getCharacteristic());
     157  if (fac_NTL_char != getCharacteristic())
     158  {
     159    fac_NTL_char= getCharacteristic();
     160    zz_p::init (getCharacteristic());
     161  }
    158162  if (GF)
    159163  {
    … …  
    673677Variable chooseExtension (const Variable & alpha, const Variable& beta, int k)
    674678{
    675   zz_p::init (getCharacteristic());
     679  if (fac_NTL_char != getCharacteristic())
     680  {
     681    fac_NTL_char= getCharacteristic();
     682    zz_p::init (getCharacteristic());
     683  }
    676684  zz_pX NTLIrredpoly;
    677685  int i=1, m= 2;
    … …  
    23502358  }
    23512359  delete [] A;
     2360  if (!wasInBounds)
     2361  {
     2362    if (start)
     2363      henselLiftResume12 (F, factors, start, degree (F) + 1, Pi, diophant, M);
     2364    else
     2365      henselLift12 (F, factors, degree (F) + 1, Pi, diophant, M);
     2366    factors.insert (LCF);
     2367  }
    23522368  return l;
    23532369}
    … …  
    24722488  }
    24732489  delete [] A;
     2490  if (!wasInBounds)
     2491  {
     2492    if (start)
     2493      henselLiftResume12 (F, factors, start, degree (F) + 1, Pi, diophant, M);
     2494    else
     2495      henselLift12 (F, factors, degree (F) + 1, Pi, diophant, M);
     2496    factors.insert (LCF);
     2497  }
    24742498  return l;
    24752499}
    … …  
    26522676  }
    26532677  delete [] A;
     2678  if (!wasInBounds)
     2679  {
     2680    if (start)
     2681      henselLiftResume12 (F, factors, start, degree (F) + 1, Pi, diophant, M);
     2682    else
     2683      henselLift12 (F, factors, degree (F) + 1, Pi, diophant, M);
     2684    factors.insert (LCF);
     2685  }
    26542686  return l;
    26552687}
    … …  
    28512883  }
    28522884  delete [] A;
     2885  if (!wasInBounds)
     2886  {
     2887    if (start)
     2888      henselLiftResume12 (F, factors, start, degree (F) + 1, Pi, diophant, M);
     2889    else
     2890      henselLift12 (F, factors, degree (F) + 1, Pi, diophant, M);
     2891    factors.insert (LCF);
     2892  }
    28532893  return l;
    28542894}
    … …  
    29703010  }
    29713011  delete [] A;
     3012  if (!wasInBounds)
     3013  {
     3014    if (start)
     3015      henselLiftResume12 (F, factors, start, degree (F) + 1, Pi, diophant, M);
     3016    else
     3017      henselLift12 (F, factors, degree (F) + 1, Pi, diophant, M);
     3018    factors.insert (LCF);
     3019  }
    29723020  return l;
    29733021}
    … …  
    31373185  }
    31383186  delete [] A;
     3187  if (!wasInBounds)
     3188  {
     3189    if (start)
     3190      henselLiftResume12 (F, factors, start, degree (F) + 1, Pi, diophant, M);
     3191    else
     3192      henselLift12 (F, factors, degree (F) + 1, Pi, diophant, M);
     3193    factors.insert (LCF);
     3194  }
    31393195  return l;
    31403196}
    … …  
    35073563  CFArray * A= new CFArray [factors.length()];
    35083564  CFArray bufQ= CFArray (factors.length());
    3509   zz_p::init (getCharacteristic());
     3565  if (fac_NTL_char != getCharacteristic())
     3566  {
     3567    fac_NTL_char= getCharacteristic();
     3568    zz_p::init (getCharacteristic());
     3569  }
    35103570  mat_zz_p NTLN;
    35113571  ident (NTLN, factors.length());
    … …  
    37003760  CFArray * A= new CFArray [factors.length()];
    37013761  CFArray bufQ= CFArray (factors.length());
    3702   zz_p::init (getCharacteristic());
     3762  if (fac_NTL_char != getCharacteristic())
     3763  {
     3764    fac_NTL_char= getCharacteristic();
     3765    zz_p::init (getCharacteristic());
     3766  }
    37033767  zz_pX NTLMipo= convertFacCF2NTLzzpX (getMipo (alpha));
    37043768  zz_pE::init (NTLMipo);
    … …  
    61586222  nmod_mat_t FLINTN;
    61596223#else
    6160   zz_p::init (getCharacteristic());
     6224  if (fac_NTL_char != getCharacteristic())
     6225  {
     6226    fac_NTL_char= getCharacteristic();
     6227    zz_p::init (getCharacteristic());
     6228  }
    61616229  mat_zz_p NTLN;
    61626230#endif
    … …  
    62706338    return Union (smallFactors,
    62716339                  factorRecombination (bufUniFactors, F,
    6272                                        power (y, degree (F) + 1 + degree (LCF)),
     6340                                       power (y, degree (F) + 1),
    62736341                                       degs, 1, bufUniFactors.length()/2
    62746342                                      )
    … …  
    70287096  int l= 1;
    70297097
    7030   zz_p::init (getCharacteristic());
     7098  if (fac_NTL_char != getCharacteristic())
     7099  {
     7100    fac_NTL_char= getCharacteristic();
     7101    zz_p::init (getCharacteristic());
     7102  }
    70317103  zz_pX NTLMipo;
    70327104  mat_zz_p NTLN;

  • factory/facFqFactorize.cc

    r780b52 r8e51ca  
    19371937
    19381938
    1939 void getLeadingCoeffs (const CanonicalForm& A, CFList*& Aeval,
    1940                        const CFList& uniFactors, const CFList& evaluation
     1939void getLeadingCoeffs (const CanonicalForm& A, CFList*& Aeval
    19411940                      )
    19421941{
    … …  
    25622561    oldAeval[i]= Aeval2[i];
    25632562
    2564   getLeadingCoeffs (A, Aeval2, uniFactors, evaluation);
     2563  getLeadingCoeffs (A, Aeval2);
    25652564
    25662565  CFList biFactorsLCs;
    … …  
    27862785                !isOnlyLeadingCoeff(iter2.getItem())) //content divides LCmultiplier completely and factor consists of more terms than just the leading coeff
    27872786            {
    2788               int index2= 1;
    2789               for (CFListIterator iter3= leadingCoeffs2[lengthAeval2-1];
    2790                    iter3.hasItem(); iter3++, index2++)
     2787              Variable xx= Variable (2);
     2788              CanonicalForm vars;
     2789              vars= power (xx, degree (LC (getItem(oldBiFactors, index),1),
     2790                                        xx));
     2791              for (int i= 0; i < lengthAeval2; i++)
    27912792              {
    2792                 if (index2 == index)
     2793                if (oldAeval[i].isEmpty())
     2794                  continue;
     2795                xx= oldAeval[i].getFirst().mvar();
     2796                vars *= power (xx, degree (LC (getItem(oldAeval[i], index),1),
     2797                                           xx));
     2798              }
     2799              if (vars.level() <= 2)
     2800              {
     2801                int index2= 1;
     2802                for (CFListIterator iter3= leadingCoeffs2[lengthAeval2-1];
     2803                     iter3.hasItem(); iter3++, index2++)
    27932804                {
    2794                   iter3.getItem() /= LCmultiplier;
    2795                   break;
     2805                  if (index2 == index)
     2806                  {
     2807                    iter3.getItem() /= LCmultiplier;
     2808                    break;
     2809                  }
    27962810                }
     2811                A /= LCmultiplier;
     2812                foundMultiplier= true;
     2813                iter.getItem()= 1;
    27972814              }
    2798               A /= LCmultiplier;
    2799               foundMultiplier= true;
    2800               iter.getItem()= 1;
    28012815            }
    28022816          }

  • factory/facFqFactorize.h

    r780b52 r8e51ca  
    601601void
    602602getLeadingCoeffs (const CanonicalForm& A,  ///< [in] some poly
    603                   CFList*& Aeval,          ///< [in,out] array of bivariate
     603                  CFList*& Aeval           ///< [in,out] array of bivariate
    604604                                           ///< factors, returns the leading
    605605                                           ///< coefficients of these factors
    606                   const CFList& uniFactors,///< [in] univariate factors of A
    607                   const CFList& evaluation ///< [in] evaluation point
    608606                 );
    609607

  • factory/facHensel.cc

    r780b52 r8e51ca  
    3030#include "cf_primes.h"
    3131#include "facBivar.h"
     32#include "facNTLzzpEXGCD.h"
    3233
    3334#ifdef HAVE_NTL
    … …  
    3839CFList productsNTL (const CFList& factors, const CanonicalForm& M)
    3940{
    40   zz_p::init (getCharacteristic());
     41  if (fac_NTL_char != getCharacteristic())
     42  {
     43    fac_NTL_char= getCharacteristic();
     44    zz_p::init (getCharacteristic());
     45  }
    4146  zz_pX NTLMipo= convertFacCF2NTLzzpX (M);
    4247  zz_pE::init (NTLMipo);
    … …  
    100105  buf1= bufFactors.getFirst();
    101106  buf2= i.getItem();
     107#ifdef HAVE_NTL
     108  Variable x= Variable (1);
     109  if (fac_NTL_char != getCharacteristic())
     110  {
     111    fac_NTL_char= getCharacteristic();
     112    zz_p::init (getCharacteristic());
     113  }
     114  zz_pX NTLMipo= convertFacCF2NTLzzpX (M);
     115  zz_pE::init (NTLMipo);
     116  zz_pEX NTLbuf1, NTLbuf2, NTLbuf3, NTLS, NTLT;
     117  NTLbuf1= convertFacCF2NTLzz_pEX (buf1, NTLMipo);
     118  NTLbuf2= convertFacCF2NTLzz_pEX (buf2, NTLMipo);
     119  tryNTLXGCD (NTLbuf3, NTLS, NTLT, NTLbuf1, NTLbuf2, fail);
     120  if (fail)
     121    return;
     122  S= convertNTLzz_pEX2CF (NTLS, x, M.mvar());
     123  T= convertNTLzz_pEX2CF (NTLT, x, M.mvar());
     124#else
    102125  tryExtgcd (buf1, buf2, M, buf3, S, T, fail);
    103126  if (fail)
    104127    return;
     128#endif
    105129  result.append (S);
    106130  result.append (T);
    … …  
    109133  for (; i.hasItem(); i++)
    110134  {
     135#ifdef HAVE_NTL
     136    NTLbuf1= convertFacCF2NTLzz_pEX (i.getItem(), NTLMipo);
     137    tryNTLXGCD (NTLbuf3, NTLS, NTLT, NTLbuf3, NTLbuf1, fail);
     138    if (fail)
     139      return;
     140    S= convertNTLzz_pEX2CF (NTLS, x, M.mvar());
     141    T= convertNTLzz_pEX2CF (NTLT, x, M.mvar());
     142#else
    111143    buf1= i.getItem();
    112144    tryExtgcd (buf3, buf1, M, buf3, S, T, fail);
    113145    if (fail)
    114146      return;
     147#endif
    115148    CFListIterator k= factors;
    116149    for (CFListIterator j= result; j.hasItem(); j++, k++)
    … …  
    535568  Variable beta;
    536569  Off (SW_RATIONAL);
    537   if (mipoHasDen)
    538   {
    539     setReduce (alpha, false);
    540     modMipo= modMipo.mapinto();
    541     modMipo /= lc (modMipo);
    542     beta= rootOf (modMipo);
    543     setReduce (alpha, true);
    544   }
     570  setReduce (alpha, false);
     571  modMipo= modMipo.mapinto();
     572  modMipo /= lc (modMipo);
     573  beta= rootOf (modMipo);
     574  setReduce (alpha, true);
    545575
    546576  setReduce (alpha, false);
    547577  for (k= 0; k < factors.length(); k++)
    548578  {
    549     if (!mipoHasDen)
    550       bufFactors [k]= bufFactors[k].mapinto();
    551     else
    552     {
    553       bufFactors [k]= bufFactors[k].mapinto();
    554       bufFactors [k]= replacevar (bufFactors[k], alpha, beta);
    555     }
     579    bufFactors [k]= bufFactors[k].mapinto();
     580    bufFactors [k]= replacevar (bufFactors[k], alpha, beta);
    556581  }
    557582  setReduce (alpha, true);
    … …  
    596621  recResult= mapinto (recResult);
    597622  setReduce (alpha, true);
    598   if (mipoHasDen)
    599   {
    600     for (CFListIterator i= recResult; i.hasItem(); i++)
    601       i.getItem()= replacevar (i.getItem(), alpha, beta);
    602   }
     623
     624  for (CFListIterator i= recResult; i.hasItem(); i++)
     625    i.getItem()= replacevar (i.getItem(), alpha, beta);
    603626
    604627  setCharacteristic (0);
    … …  
    621644    if (mipoHasDen)
    622645      coeffE= replacevar (coeffE, gamma, beta);
     646    else
     647      coeffE= replacevar (coeffE, alpha, beta);
    623648    setCharacteristic (0);
    624649    if (!coeffE.isZero())
    … …  
    631656      {
    632657        setCharacteristic (p);
    633         setReduce (alpha, false);
    634658        g= mulNTL (coeffE, j.getItem());
    635659        g= modNTL (g, bufFactors[ii]);
    636         setReduce (alpha, true);
    637660        setCharacteristic (0);
    638661        if (mipoHasDen)
    … …  
    641664          k.getItem() += replacevar (g.mapinto()*modulus, beta, gamma);
    642665          e -= mulNTL (replacevar (g.mapinto(), beta, gamma)*modulus,
    643                                    l.getItem(), b);
     666                       l.getItem(), b);
    644667          setReduce (beta, true);
    645668        }
    646669        else
    647670        {
    648           k.getItem() += g.mapinto()*modulus;
    649           e -= mulNTL (g.mapinto()*modulus, l.getItem(), b);
     671          k.getItem() += replacevar (g.mapinto()*modulus, beta, alpha);
     672          e -= mulNTL (replacevar (g.mapinto()*modulus, beta, alpha),
     673                       l.getItem(), b);
    650674        }
    651675        e= b(e);

  • factory/facMul.cc

    r780b52 r8e51ca  
    503503  ASSERT (F.isUnivariate() && G.isUnivariate(), "expected univariate polys");
    504504  ASSERT (F.level() == G.level(), "expected polys of same level");
    505   zz_p::init (getCharacteristic());
     505  if (fac_NTL_char != getCharacteristic())
     506  {
     507    fac_NTL_char= getCharacteristic();
     508    zz_p::init (getCharacteristic());
     509  }
    506510  Variable alpha;
    507511  CanonicalForm result;
    … …  
    619623  ASSERT (F.isUnivariate() && G.isUnivariate(), "expected univariate polys");
    620624  ASSERT (F.level() == G.level(), "expected polys of same level");
    621   zz_p::init (getCharacteristic());
     625  if (fac_NTL_char != getCharacteristic())
     626  {
     627    fac_NTL_char= getCharacteristic();
     628    zz_p::init (getCharacteristic());
     629  }
    622630  Variable alpha;
    623631  CanonicalForm result;
    … …  
    764772  ASSERT (F.isUnivariate() && G.isUnivariate(), "expected univariate polys");
    765773  ASSERT (F.level() == G.level(), "expected polys of same level");
    766   zz_p::init (getCharacteristic());
     774  if (fac_NTL_char != getCharacteristic())
     775  {
     776    fac_NTL_char= getCharacteristic();
     777    zz_p::init (getCharacteristic());
     778  }
    767779  Variable alpha;
    768780  CanonicalForm result;
    … …  
    20742086    int d1= degAx + degBx + 1;
    20752087    int d2= tmax (degAy, degBy);
    2076     zz_p::init (getCharacteristic());
     2088    if (fac_NTL_char != getCharacteristic())
     2089    {
     2090      fac_NTL_char= getCharacteristic();
     2091      zz_p::init (getCharacteristic());
     2092    }
    20772093    zz_pX NTLMipo= convertFacCF2NTLzzpX (getMipo (alpha));
    20782094    zz_pE::init (NTLMipo);
    … …  
    28342850  if (p > 0)
    28352851  {
    2836     zz_p::init (p);
     2852    if (fac_NTL_char != p)
     2853    {
     2854      fac_NTL_char= p;
     2855      zz_p::init (p);
     2856    }
    28372857    Variable alpha;
    28382858    if (hasFirstAlgVar (A, alpha) || hasFirstAlgVar (B, alpha))

  • factory/facMul.h

    r780b52 r8e51ca  
    155155         const CFList& M  ///< [in] contains only powers of Variables
    156156        );
     157
     158#ifdef HAVE_FLINT
     159/// division with remainder of univariate polynomials over Q and Q(a) using
     160/// Newton inversion, satisfying F=G*Q+R, deg(R) < deg(G)
     161void
     162newtonDivrem (const CanonicalForm& F, ///<[in] univariate poly
     163              const CanonicalForm& G, ///<[in] univariate poly
     164              CanonicalForm& Q,       ///<[in, out] quotient
     165              CanonicalForm& R        ///<[in, out] remainder
     166             );
     167#endif
     168
    157169#endif
    158170/* FAC_MUL_H */

  • factory/fac_ezgcd.cc

    r780b52 r8e51ca  
    492492  }
    493493
    494   if ( gcd_test_one( F, G, false ) )
     494  int dummy= 0;
     495  if ( gcd_test_one( F, G, false, dummy ) )
    495496  {
    496497    DEBDECLEVEL( cerr, "ezgcd" );

  • factory/fac_util.h

    r780b52 r8e51ca  
    5454/*ENDPUBLIC*/
    5555
    56 bool gcd_test_one ( const CanonicalForm & f, const CanonicalForm & g, bool swap );
     56bool gcd_test_one ( const CanonicalForm & f, const CanonicalForm & g, bool swap, int & d );
    5757
    5858CanonicalForm ezgcd ( const CanonicalForm & f, const CanonicalForm & g );

  • factory/libfac/charset/alg_factor.cc

    r780b52 r8e51ca  
    7676{
    7777    current++;
    78 }
    79 
    80 // replacement for factory's broken psr
    81 static CanonicalForm
    82 mypsr ( const CanonicalForm &rr, const CanonicalForm &vv, const Variable & x )
    83 {
    84   CanonicalForm r=rr, v=vv, l, test, lu, lv, t, retvalue;
    85   int dr, dv, d,n=0;
    86 
    87 
    88   dr = degree( r, x );
    89   dv = degree( v, x );
    90   if (dv <= dr) {l=LC(v,x); v = v -l*power(x,dv);}
    91   else { l = 1; }
    92   d= dr-dv+1;
    93   while ( ( dv <= dr  ) && ( r != r.genZero()) ){
    94     test = power(x,dr-dv)*v*LC(r,x);
    95     if ( dr == 0 ) { r= CanonicalForm(0); }
    96     else { r= r - LC(r,x)*power(x,dr); }
    97     r= l*r -test;
    98     dr= degree(r,x);
    99     n+=1;
    100   }
    101   r= power(l, d-n)*r;
    102   return r;
    10378}
    10479

  • factory/libfac/charset/algfactor.cc

    r780b52 r8e51ca  
    4343}
    4444
     45/* unused functions:
    4546static CFFList
    4647myDifference(const CFFList & Inputlist1,const CFFList & Inputlist2){
    … …  
    6566  }
    6667return 1;
    67 }
     68} */
    6869
    6970#ifdef CHARSETNADEBUG

  • factory/libfac/charset/charset.cc

    r780b52 r8e51ca  
    236236        if ( ! same( iitem, jitem ) )
    237237          if ( ! member(jitem, mem))
     238          {
    238239            if ( contractsub(iitem, jitem) ){
    239240              ts.append(jitem); mem.append(jitem);
    … …  
    243244                ts.append(iitem);
    244245              }
     246          }
    245247      }
    246248  }
    … …  
    515517  }
    516518  //  CERR << "ind= " << ind << "\n";
    517   if ( (ind == 1) ) //&& ( as.length() > 1) )
     519  if ( ind == 1 ) //&& ( as.length() > 1) )
    518520  {
    519521    if ( irreducible(AS) )

  • factory/libfac/charset/csutil.cc

    r780b52 r8e51ca  
    657657    elem = i.getItem();
    658658    if ( ! elem.isEmpty() )
     659    {
    659660      if ( length <= elem.length() ){ ppi2.append(elem); }
    660661      else { ppi1.append(elem); }
     662    }
    661663  }
    662664}

  • factory/libfac/factor/Factor.cc

    r780b52 r8e51ca  
    11///////////////////////////////////////////////////////////////////////////////
    2 static const char * errmsg = "\nYou found a bug!\nPlease inform singular@mathematik.uni-kl.de\nPlease include above information and your input (the ideal/polynomial and characteristic) in your bug-report.\nThank you.";
     2/*static const char * errmsg = "\nYou found a bug!\nPlease inform singular@mathematik.uni-kl.de\nPlease include above information and your input (the ideal/polynomial and characteristic) in your bug-report.\nThank you.";*/
    33///////////////////////////////////////////////////////////////////////////////
    44// FACTORY - Includes

  • factory/libfac/factor/SqrFree.cc

    r780b52 r8e51ca  
    11///////////////////////////////////////////////////////////////////////////////
    22// emacs edit mode for this file is -*- C++ -*-
    3 static const char * errmsg = "\nYou found a bug!\nPlease inform singular@mathematik.uni-kl.de\n Please include above information and your input (the ideal/polynomial and characteristic) in your bug-report.\nThank you.";
     3/*static const char * errmsg = "\nYou found a bug!\nPlease inform singular@mathematik.uni-kl.de\n Please include above information and your input (the ideal/polynomial and characteristic) in your bug-report.\nThank you.";*/
    44///////////////////////////////////////////////////////////////////////////////
    55// FACTORY - Includes
Note: See TracChangeset for help on using the changeset viewer.