Changeset 2537fa0 in git


Ignore:
Timestamp:
Mar 19, 2013, 2:31:03 PM (10 years ago)
Author:
Martin Lee <martinlee84@…>
Branches:
(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', '5a0dde71de01068fad5736a17555c993ecbbf495')
Children:
2d35fe77fb45655052d739f5e90e572b52fe709f
Parents:
5e4636810908842f714d87ac378a9aa9c48ec33f
git-author:
Martin Lee <martinlee84@web.de>2013-03-19 14:31:03+01:00
git-committer:
Martin Lee <martinlee84@web.de>2013-03-22 15:53:08+01:00
Message:
chg: shift evaluation point during factor reconstruction
Location:
factory
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • factory/facBivar.cc

    r5e4636 r2537fa0  
    583583
    584584  TIMING_START (fac_bi_factor_recombination);
    585   factors= factorRecombination (uniFactors, A, MODl, degs, 1,
     585  factors= factorRecombination (uniFactors, A, MODl, degs, evaluation, 1,
    586586                                uniFactors.length()/2, b, den);
    587587  TIMING_END_AND_PRINT (fac_bi_factor_recombination,
     
    595595    factors= earlyFactors;
    596596
    597   for (CFListIterator i= factors; i.hasItem(); i++)
    598     i.getItem()= i.getItem() (y - evaluation, y);
    599 
    600597  appendSwapDecompress (factors, conv (contentAxFactors),
    601598                        conv (contentAyFactors), swap, swap2, N);
  • factory/facFqBivar.cc

    r5e4636 r2537fa0  
    481481CFList
    482482factorRecombination (CFList& factors, CanonicalForm& F,
    483                      const CanonicalForm& N, DegreePattern& degs, int s,
    484                      int thres, const modpk& b, const CanonicalForm& den
     483                     const CanonicalForm& N, DegreePattern& degs, const
     484                     CanonicalForm& eval, int s, int thres, const modpk& b,
     485                     const CanonicalForm& den
    485486                    )
    486487{
     
    492493  if (F.inCoeffDomain())
    493494    return CFList();
     495  Variable y= Variable (2);
    494496  if (degs.getLength() <= 1 || factors.length() == 1)
    495497  {
    496     CFList result= CFList (F);
     498    CFList result= CFList (F(y-eval,y));
    497499    F= 1;
    498500    return result;
     
    513515  T= factors;
    514516  CFList result;
    515   Variable y= Variable (2);
    516517  Variable x= Variable (1);
    517518  CanonicalForm denom= den, denQuot;
     
    550551            g= b(g);
    551552          T.removeFirst();
    552           result.append (g/content (g, x));
     553          g /= content (g,x);
     554          result.append (g(y-eval,y));
    553555          F= 1;
    554556          return result;
     
    556558        else
    557559        {
    558           result= CFList (F);
     560          result= CFList (F(y-eval,y));
    559561          F= 1;
    560562          return result;
     
    610612            denom *= abs (lc (g));
    611613            recombination= true;
    612             result.append (g);
     614            result.append (g (y-eval,y));
    613615            if (b.getp() != 0)
    614616            {
     
    638640              if (recombination)
    639641              {
    640                 result.append (buf);
     642                result.append (buf (y-eval,y));
    641643                F= 1;
    642644                return result;
     
    644646              else
    645647              {
    646                 result= CFList (F);
     648                result= CFList (F (y-eval,y));
    647649                F= 1;
    648650                return result;
     
    664666      if (recombination)
    665667      {
    666         result.append (buf);
     668        result.append (buf(y-eval,y));
    667669        F= 1;
    668670        return result;
     
    670672      else
    671673      {
    672         result= CFList (F);
     674        result= CFList (F(y-eval,y));
    673675        F= 1;
    674676        return result;
     
    682684  if (T.length() < 2*s)
    683685  {
    684     result.append (F);
     686    result.append (F(y-eval,y));
    685687    F= 1;
    686688    return result;
     
    735737earlyFactorDetection (CFList& reconstructedFactors, CanonicalForm& F, CFList&
    736738                      factors, int& adaptedLiftBound, int*& factorsFoundIndex,
    737                       DegreePattern& degs, bool& success, int deg,
    738                       const modpk& b, CanonicalForm& den)
     739                      DegreePattern& degs, bool& success, int deg, const
     740                      CanonicalForm& eval, const modpk& b, CanonicalForm& den)
    739741{
    740742  DegreePattern bufDegs1= degs;
     
    743745  CanonicalForm buf= F;
    744746  Variable x= Variable (1);
     747  Variable y= Variable (2);
    745748  CanonicalForm g, quot;
    746749  CanonicalForm M= power (F.mvar(), deg);
     
    798801          {
    799802            den *= abs (lc (g));
    800             reconstructedFactors.append (g);
     803            reconstructedFactors.append (g (y-eval,y));
    801804            factorsFoundIndex[l]= 1;
    802805            if (b.getp() != 0)
     
    827830              if (!buf.inCoeffDomain())
    828831              {
    829                 reconstructedFactors.append (buf);
     832                reconstructedFactors.append (buf (y-eval,y));
    830833                F= 1;
    831834              }
     
    852855earlyFactorDetection (CFList& reconstructedFactors, CanonicalForm& F, CFList&
    853856                      factors, int& adaptedLiftBound, int*& factorsFoundIndex,
    854                       DegreePattern& degs, bool& success, int deg,
    855                       const modpk& b)
     857                      DegreePattern& degs, bool& success, int deg, const
     858                      CanonicalForm& eval, const modpk& b)
    856859{
    857860  CanonicalForm den= 1;
    858   earlyFactorDetection (reconstructedFactors, F, factors, adaptedLiftBound, factorsFoundIndex, degs, success, deg,b, den);
     861  earlyFactorDetection (reconstructedFactors, F, factors, adaptedLiftBound,
     862                        factorsFoundIndex, degs, success, deg, eval, b, den);
    859863}
    860864
     
    11271131        earlyFactorDetection (earlyFactors, bufA, bufUniFactors, newLiftBound,
    11281132                              factorsFoundIndex, degs, earlySuccess,
    1129                               smallFactorDeg, b, den);
     1133                              smallFactorDeg, eval, b, den);
    11301134      else
    11311135        earlyFactorDetection(earlyFactors, bufA, bufBufUniFactors, newLiftBound,
    11321136                             factorsFoundIndex, degs, earlySuccess,
    1133                              smallFactorDeg, b, den);
     1137                             smallFactorDeg, eval, b, den);
    11341138    }
    11351139    else
     
    11561160          earlyFactorDetection (earlyFactors, bufA, bufUniFactors, newLiftBound,
    11571161                                factorsFoundIndex, degs, earlySuccess,
    1158                                 liftPre[sizeOfLiftPre-1] + 1, b, den);
     1162                                liftPre[sizeOfLiftPre-1] + 1, eval, b, den);
    11591163          else
    11601164          earlyFactorDetection (earlyFactors,bufA,bufBufUniFactors,newLiftBound,
    11611165                                factorsFoundIndex, degs, earlySuccess,
    1162                                 liftPre[sizeOfLiftPre-1] + 1, b, den);
     1166                                liftPre[sizeOfLiftPre-1] + 1, eval, b, den);
    11631167        }
    11641168        else
     
    11901194          earlyFactorDetection (earlyFactors, bufA, bufUniFactors, newLiftBound,
    11911195                                factorsFoundIndex, degs, earlySuccess,
    1192                                 liftPre[i-1] + 1, b, den);
     1196                                liftPre[i-1] + 1, eval, b, den);
    11931197          else
    11941198          earlyFactorDetection (earlyFactors,bufA,bufBufUniFactors,newLiftBound,
    11951199                                factorsFoundIndex, degs, earlySuccess,
    1196                                 liftPre[i-1] + 1, b, den);
     1200                                liftPre[i-1] + 1, eval, b, den);
    11971201        }
    11981202        else
     
    12331237      earlyFactorDetection (earlyFactors, bufA, bufUniFactors, newLiftBound,
    12341238                            factorsFoundIndex, degs, earlySuccess,
    1235                             smallFactorDeg, b, den);
     1239                            smallFactorDeg, eval, b, den);
    12361240      else
    12371241      earlyFactorDetection (earlyFactors, bufA, bufBufUniFactors, newLiftBound,
    12381242                            factorsFoundIndex, degs, earlySuccess,
    1239                             smallFactorDeg, b, den);
     1243                            smallFactorDeg, eval, b, den);
    12401244    }
    12411245    else
     
    12621266        if (v==alpha)
    12631267        earlyFactorDetection (earlyFactors, bufA, bufUniFactors, newLiftBound,
    1264                               factorsFoundIndex, degs, earlySuccess, dummy, b,
    1265                               den);
     1268                              factorsFoundIndex, degs, earlySuccess, dummy,eval,
     1269                              b, den);
    12661270        else
    12671271        earlyFactorDetection (earlyFactors, bufA,bufBufUniFactors, newLiftBound,
    1268                               factorsFoundIndex, degs, earlySuccess, dummy, b,
    1269                               den);
     1272                              factorsFoundIndex, degs, earlySuccess, dummy,eval,
     1273                              b, den);
    12701274      }
    12711275      else
     
    12921296          if (v==alpha)
    12931297          earlyFactorDetection (earlyFactors, bufA, bufUniFactors, newLiftBound,
    1294                                 factorsFoundIndex, degs, earlySuccess, dummy,b,
    1295                                 den);
     1298                                factorsFoundIndex, degs, earlySuccess, dummy,
     1299                                eval, b, den);
    12961300          else
    12971301          earlyFactorDetection (earlyFactors,bufA,bufBufUniFactors,newLiftBound,
    1298                                 factorsFoundIndex, degs, earlySuccess, dummy,b,
    1299                                 den);
     1302                                factorsFoundIndex, degs, earlySuccess, dummy,
     1303                                eval, b, den);
    13001304        }
    13011305        else
     
    14711475reconstructionTry (CFList& reconstructedFactors, CanonicalForm& F, const CFList&
    14721476                   factors, const int liftBound, int& factorsFound, int*&
    1473                    factorsFoundIndex, mat_zz_pE& N, bool beenInThres
     1477                   factorsFoundIndex, mat_zz_pE& N, const CanonicalForm& eval,
     1478                   bool beenInThres
    14741479                  )
    14751480{
     
    14771482  Variable x= Variable (1);
    14781483  CanonicalForm yToL= power (y, liftBound);
     1484  CanonicalForm bufF= F (y-eval, y);
    14791485  if (factors.length() == 2)
    14801486  {
     
    14841490    tmp1= mulMod2 (tmp1, LC (F,x), yToL);
    14851491    tmp1 /= content (tmp1, x);
     1492    tmp1= tmp1 (y-eval, y);
    14861493    tmp2= mulMod2 (tmp2, LC (F,x), yToL);
    14871494    tmp2 /= content (tmp2, x);
     1495    tmp2= tmp2 (y-eval, y);
    14881496    tmp3 = tmp1*tmp2;
    1489     if (tmp3/Lc (tmp3) == F/Lc (F))
     1497    if (tmp3/Lc (tmp3) == bufF/Lc (bufF))
    14901498    {
    14911499      factorsFound++;
     
    15241532    buf= mulMod2 (buf, LC (F,x), yToL);
    15251533    buf /= content (buf, x);
    1526     if (fdivides (buf, F, quot))
     1534    buf= buf (y-eval,y);
     1535    if (fdivides (buf, bufF, quot))
    15271536    {
    15281537      factorsFoundIndex[i - 1]= 1;
    15291538      factorsFound++;
    1530       F= quot;
    1531       F /= Lc (F);
     1539      bufF= quot;
     1540      bufF /= Lc (bufF);
    15321541      reconstructedFactors.append (buf);
    15331542    }
    1534     if (degree (F) <= 0)
     1543    if (degree (bufF) <= 0)
    15351544      return;
    15361545    if (factorsFound + 1 == N.NumCols())
    15371546    {
    1538       reconstructedFactors.append (F);
     1547      reconstructedFactors.append (bufF);
     1548      F= 1;
    15391549      return;
    15401550    }
    15411551  }
     1552  if (reconstructedFactors.length() != 0)
     1553    F= bufF (y+eval,y);
    15421554}
    15431555
     
    15451557reconstructionTry (CFList& reconstructedFactors, CanonicalForm& F, const CFList&
    15461558                   factors, const int liftBound, int& factorsFound, int*&
    1547                    factorsFoundIndex, mat_zz_p& N, bool beenInThres
     1559                   factorsFoundIndex, mat_zz_p& N, const CanonicalForm& eval,
     1560                   bool beenInThres
    15481561                  )
    15491562{
     
    15511564  Variable x= Variable (1);
    15521565  CanonicalForm yToL= power (y, liftBound);
     1566  CanonicalForm bufF= F (y-eval, y);
    15531567  if (factors.length() == 2)
    15541568  {
     
    15581572    tmp1= mulMod2 (tmp1, LC (F,x), yToL);
    15591573    tmp1 /= content (tmp1, x);
     1574    tmp1= tmp1 (y-eval, y);
    15601575    tmp2= mulMod2 (tmp2, LC (F,x), yToL);
    15611576    tmp2 /= content (tmp2, x);
     1577    tmp2= tmp2 (y-eval,y);
    15621578    tmp3 = tmp1*tmp2;
    1563     if (tmp3/Lc (tmp3) == F/Lc (F))
     1579    if (tmp3/Lc (tmp3) == bufF/Lc (bufF))
    15641580    {
    15651581      factorsFound++;
     
    15981614    buf= mulMod2 (buf, LC (F,x), yToL);
    15991615    buf /= content (buf, x);
    1600     if (fdivides (buf, F, quot))
     1616    buf= buf (y-eval,y);
     1617    if (fdivides (buf, bufF, quot))
    16011618    {
    16021619      factorsFoundIndex[i - 1]= 1;
    16031620      factorsFound++;
    1604       F= quot;
    1605       F /= Lc (F);
     1621      bufF= quot;
     1622      bufF /= Lc (bufF);
    16061623      reconstructedFactors.append (buf);
    16071624    }
    1608     if (degree (F) <= 0)
     1625    if (degree (bufF) <= 0)
    16091626      return;
    16101627    if (factorsFound + 1 == N.NumCols())
    16111628    {
    1612       reconstructedFactors.append (F);
     1629      reconstructedFactors.append (bufF);
     1630      F=1;
    16131631      return;
    16141632    }
    16151633  }
     1634  if (reconstructedFactors.length() != 0)
     1635    F= bufF (y+eval,y);
    16161636}
    16171637
     
    16201640reconstructionTry (CFList& reconstructedFactors, CanonicalForm& F, const CFList&
    16211641                   factors, const int liftBound, int& factorsFound, int*&
    1622                    factorsFoundIndex, nmod_mat_t N, bool beenInThres
     1642                   factorsFoundIndex, nmod_mat_t N, const CanonicalForm& eval,
     1643                   bool beenInThres
    16231644                  )
    16241645{
     
    16261647  Variable x= Variable (1);
    16271648  CanonicalForm yToL= power (y, liftBound);
     1649  CanonicalForm bufF= F (y-eval, y);
    16281650  if (factors.length() == 2)
    16291651  {
     
    16331655    tmp1= mulMod2 (tmp1, LC (F,x), yToL);
    16341656    tmp1 /= content (tmp1, x);
     1657    tmp1= tmp1 (y-eval, y);
    16351658    tmp2= mulMod2 (tmp2, LC (F,x), yToL);
    16361659    tmp2 /= content (tmp2, x);
     1660    tmp2= tmp2 (y-eval, y);
    16371661    tmp3 = tmp1*tmp2;
    1638     if (tmp3/Lc (tmp3) == F/Lc (F))
     1662    if (tmp3/Lc (tmp3) == bufF/Lc (bufF))
    16391663    {
    16401664      factorsFound++;
     
    16731697    buf= mulMod2 (buf, LC (F,x), yToL);
    16741698    buf /= content (buf, x);
    1675     if (fdivides (buf, F, quot))
     1699    buf= buf (y-eval,y);
     1700    if (fdivides (buf, bufF, quot))
    16761701    {
    16771702      factorsFoundIndex[i]= 1;
    16781703      factorsFound++;
    1679       F= quot;
    1680       F /= Lc (F);
     1704      bufF= quot;
     1705      bufF /= Lc (bufF);
    16811706      reconstructedFactors.append (buf);
    16821707    }
     
    16851710    if (factorsFound + 1 == nmod_mat_ncols (N))
    16861711    {
    1687       reconstructedFactors.append (F);
     1712      F= 1;
     1713      reconstructedFactors.append (bufF);
    16881714      return;
    16891715    }
    16901716  }
     1717  if (reconstructedFactors.length() != 0)
     1718    F= bufF (y+eval,y);
    16911719}
    16921720#endif
     
    16941722CFList
    16951723reconstruction (CanonicalForm& G, CFList& factors, int* zeroOneVecs, int
    1696                 precision, const mat_zz_pE& N
     1724                precision, const mat_zz_pE& N, const CanonicalForm& eval
    16971725               )
    16981726{
     
    17261754      F= quot;
    17271755      F /= Lc (F);
    1728       result.append (buf);
     1756      result.append (buf (y-eval,y));
    17291757      bufFactors= Difference (bufFactors, factorsConsidered);
    17301758    }
     
    19541982CFList
    19551983reconstruction (CanonicalForm& G, CFList& factors, int* zeroOneVecs,
    1956                 int precision, const mat_zz_p& N)
     1984                int precision, const mat_zz_p& N, const CanonicalForm& eval)
    19571985{
    19581986  Variable y= Variable (2);
     
    19862014      F= quot;
    19872015      F /= Lc (F);
    1988       result.append (buf);
     2016      result.append (buf (y-eval,y));
    19892017      bufFactors= Difference (bufFactors, factorsConsidered);
    19902018    }
     
    20042032CFList
    20052033reconstruction (CanonicalForm& G, CFList& factors, int* zeroOneVecs,
    2006                 int precision, const nmod_mat_t N)
     2034                int precision, const nmod_mat_t N, const CanonicalForm& eval)
    20072035{
    20082036  Variable y= Variable (2);
     
    20362064      F= quot;
    20372065      F /= Lc (F);
    2038       result.append (buf);
     2066      result.append (buf (y-eval,y));
    20392067      bufFactors= Difference (bufFactors, factorsConsidered);
    20402068    }
     
    32553283CFList
    32563284increasePrecision (CanonicalForm& F, CFList& factors, int factorsFound,
    3257                    int oldNumCols, int oldL, int precision
     3285                   int oldNumCols, int oldL, int precision,
     3286                   const CanonicalForm& eval
    32583287                  )
    32593288{
     
    32613290  bool isIrreducible= false;
    32623291  int* bounds= computeBounds (F, d, isIrreducible);
     3292  Variable y= F.mvar();
    32633293  if (isIrreducible)
    32643294  {
     
    32663296    CanonicalForm G= F;
    32673297    F= 1;
    3268     return CFList (G);
     3298    return CFList (G (y-eval, y));
    32693299  }
    32703300  CFArray * A= new CFArray [factors.length()];
     
    32993329  mat_zz_p* NTLC, NTLK;
    33003330#endif
    3301   Variable y= F.mvar();
    33023331  CanonicalForm truncF;
    33033332  while (l <= precision)
     
    33723401          CanonicalForm G= F;
    33733402          F= 1;
    3374           return CFList (G);
     3403          return CFList (G (y-eval,y));
    33753404        }
    33763405      }
     
    33983427#ifdef HAVE_FLINT
    33993428        reconstructionTry (result, bufF, factors, degree (F) + 1, factorsFound2,
    3400                            factorsFoundIndex, FLINTN, false
     3429                           factorsFoundIndex, FLINTN, eval, false
    34013430                          );
    34023431        if (result.length() == nmod_mat_ncols (FLINTN))
     
    34053434#else
    34063435        reconstructionTry (result, bufF, factors, degree (F) + 1, factorsFound2,
    3407                            factorsFoundIndex, NTLN, false
     3436                           factorsFoundIndex, NTLN, eval, false
    34083437                          );
    34093438        if (result.length() == NTLN.NumCols())
     
    34233452#ifdef HAVE_FLINT
    34243453        int * zeroOne= extractZeroOneVecs (FLINTN);
    3425         CFList result= reconstruction (bufF,factors,zeroOne,precision,FLINTN);
     3454        CFList result= reconstruction (bufF,factors,zeroOne,precision,FLINTN, eval);
    34263455        nmod_mat_clear (FLINTN);
    34273456#else
    34283457        int * zeroOne= extractZeroOneVecs (NTLN);
    3429         CFList result= reconstruction (bufF, factors, zeroOne, precision, NTLN);
     3458        CFList result= reconstruction (bufF, factors, zeroOne, precision, NTLN, eval);
    34303459#endif
    34313460        F= bufF;
     
    34613490increasePrecision (CanonicalForm& F, CFList& factors, int factorsFound,
    34623491                   int oldNumCols, int oldL, const Variable&,
    3463                    int precision
     3492                   int precision, const CanonicalForm& eval
    34643493                  )
    34653494{
    34663495  int d;
    34673496  bool isIrreducible= false;
     3497  Variable y= F.mvar();
    34683498  int* bounds= computeBounds (F, d, isIrreducible);
    34693499  if (isIrreducible)
     
    34723502    CanonicalForm G= F;
    34733503    F= 1;
    3474     return CFList (G);
     3504    return CFList (G (y-eval,y));
    34753505  }
    34763506  CFArray * A= new CFArray [factors.length()];
     
    34933523  mat_zz_pE* NTLC, NTLK;
    34943524  CFArray buf;
    3495   Variable y= F.mvar();
    34963525  CanonicalForm truncF;
    34973526  while (l <= precision)
     
    35383567          CanonicalForm G= F;
    35393568          F= 1;
    3540           return CFList (G);
     3569          return CFList (G (y-eval,y));
    35413570        }
    35423571      }
     
    35543583        CanonicalForm bufF= F;
    35553584        reconstructionTry (result, bufF, factors, degree (F) + 1, factorsFound2,
    3556                            factorsFoundIndex, NTLN, false);
     3585                           factorsFoundIndex, NTLN, eval, false);
    35573586        if (result.length() == NTLN.NumCols())
    35583587        {
     
    35693598        CanonicalForm bufF= F;
    35703599        int * zeroOne= extractZeroOneVecs (NTLN);
    3571         CFList result= reconstruction (bufF, factors, zeroOne, precision, NTLN);
     3600        CFList result= reconstruction (bufF, factors, zeroOne, precision, NTLN, eval);
    35723601        F= bufF;
    35733602        delete [] zeroOne;
     
    39373966increasePrecisionFq2Fp (CanonicalForm& F, CFList& factors, int factorsFound,
    39383967                        int oldNumCols, int oldL, const Variable& alpha,
    3939                         int precision
     3968                        int precision, const CanonicalForm& eval
    39403969                       )
    39413970{
    39423971  int d;
    39433972  bool isIrreducible= false;
     3973  Variable y= F.mvar();
    39443974  int* bounds= computeBounds (F, d, isIrreducible);
    39453975  if (isIrreducible)
     
    39483978    CanonicalForm G= F;
    39493979    F= 1;
    3950     return CFList (G);
     3980    return CFList (G (y-eval,y));
    39513981  }
    39523982  int extensionDeg= degree (getMipo (alpha));
     
    39824012#endif
    39834013  CFArray buf;
    3984   Variable y= F.mvar();
    39854014  CanonicalForm truncF;
    39864015  while (l <= precision)
     
    40554084          CanonicalForm G= F;
    40564085          F= 1;
    4057           return CFList (G);
     4086          return CFList (G (y-eval,y));
    40584087        }
    40594088      }
     
    40814110#ifdef HAVE_FLINT
    40824111        reconstructionTry (result, bufF, factors, degree (F) + 1, factorsFound2,
    4083                            factorsFoundIndex, FLINTN, false
     4112                           factorsFoundIndex, FLINTN, eval, false
    40844113                          );
    40854114        if (result.length() == nmod_mat_ncols (FLINTN))
     
    40884117#else
    40894118        reconstructionTry (result, bufF, factors, degree (F) + 1, factorsFound2,
    4090                            factorsFoundIndex, NTLN, false
     4119                           factorsFoundIndex, NTLN, eval, false
    40914120                          );
    40924121        if (result.length() == NTLN.NumCols())
     
    41064135#ifdef HAVE_FLINT
    41074136        int * zeroOne= extractZeroOneVecs (FLINTN);
    4108         CFList result= reconstruction (bufF,factors,zeroOne,precision,FLINTN);
     4137        CFList result= reconstruction (bufF,factors,zeroOne,precision,FLINTN, eval);
    41094138        nmod_mat_clear (FLINTN);
    41104139#else
    41114140        int * zeroOne= extractZeroOneVecs (NTLN);
    4112         CFList result= reconstruction (bufF, factors, zeroOne, precision, NTLN);
     4141        CFList result= reconstruction (bufF, factors, zeroOne, precision, NTLN, eval);
    41134142#endif
    41144143        F= bufF;
     
    41444173CFList
    41454174increasePrecision (CanonicalForm& F, CFList& factors, int oldL, int
    4146                    l, int d, int* bounds, CFArray& bufQ, nmod_mat_t FLINTN
     4175                   l, int d, int* bounds, CFArray& bufQ, nmod_mat_t FLINTN,
     4176                   const CanonicalForm& eval
    41474177                  )
    41484178#else
    41494179CFList
    41504180increasePrecision (CanonicalForm& F, CFList& factors, int oldL, int
    4151                    l, int d, int* bounds, CFArray& bufQ, mat_zz_p& NTLN
     4181                   l, int d, int* bounds, CFArray& bufQ, mat_zz_p& NTLN,
     4182                   const CanonicalForm& eval
    41524183                  )
    41534184#endif
     
    42534284        {
    42544285          delete [] A;
    4255           return CFList (F);
     4286          return CFList (F (y-eval,y));
    42564287        }
    42574288      }
     
    42644295    {
    42654296      delete [] A;
    4266       return CFList (F);
     4297      return CFList (F (y-eval,y));
    42674298    }
    42684299    int * zeroOneVecs;
     
    42754306    bufUniFactors= factors;
    42764307#ifdef HAVE_FLINT
    4277     result= reconstruction (bufF, bufUniFactors, zeroOneVecs, oldL, FLINTN);
    4278 #else
    4279     result= reconstruction (bufF, bufUniFactors, zeroOneVecs, oldL, NTLN);
     4308    result= reconstruction (bufF, bufUniFactors, zeroOneVecs, oldL, FLINTN, eval);
     4309#else
     4310    result= reconstruction (bufF, bufUniFactors, zeroOneVecs, oldL, NTLN, eval);
    42804311#endif
    42814312    delete [] zeroOneVecs;
     
    43084339CFList
    43094340increasePrecision (CanonicalForm& F, CFList& factors, int oldL, int
    4310                    l, int d, int* bounds, CFArray& bufQ, mat_zz_pE& NTLN
     4341                   l, int d, int* bounds, CFArray& bufQ, mat_zz_pE& NTLN,
     4342                   const CanonicalForm& eval
    43114343                  )
    43124344{
     
    43664398        {
    43674399          delete [] A;
    4368           return CFList (F);
     4400          return CFList (F (y-eval,y));
    43694401        }
    43704402      }
     
    43734405    {
    43744406      delete [] A;
    4375       return CFList (F);
     4407      return CFList (F (y-eval,y));
    43764408    }
    43774409
     
    43804412    bufF= F;
    43814413    bufUniFactors= factors;
    4382     result= reconstruction (bufF, bufUniFactors, zeroOneVecs, oldL, NTLN);
     4414    result= reconstruction (bufF, bufUniFactors, zeroOneVecs, oldL, NTLN, eval);
    43834415    delete [] zeroOneVecs;
    43844416    if (degree (bufF) + 1 + degree (LC (bufF, 1)) < l && result.length() > 0)
     
    45834615increasePrecisionFq2Fp (CanonicalForm& F, CFList& factors, int oldL, int l,
    45844616                        int d, int* bounds, CFArray& bufQ, nmod_mat_t FLINTN,
    4585                         const Variable& alpha
     4617                        const Variable& alpha, const CanonicalForm& eval
    45864618                       )
    45874619#else
     
    45894621increasePrecisionFq2Fp (CanonicalForm& F, CFList& factors, int oldL, int l,
    45904622                        int d, int* bounds, CFArray& bufQ, mat_zz_p& NTLN,
    4591                         const Variable& alpha
     4623                        const Variable& alpha, const CanonicalForm& eval
    45924624                       )
    45934625#endif
     
    46904722        {
    46914723          delete [] A;
    4692           return CFList (F);
     4724          return CFList (F(y-eval,y));
    46934725        }
    46944726      }
     
    47054737    bufUniFactors= factors;
    47064738#ifdef HAVE_FLINT
    4707     result= reconstruction (bufF, bufUniFactors, zeroOneVecs, oldL, FLINTN);
    4708 #else
    4709     result= reconstruction (bufF, bufUniFactors, zeroOneVecs, oldL, NTLN);
     4739    result= reconstruction (bufF, bufUniFactors, zeroOneVecs, oldL, FLINTN, eval);
     4740#else
     4741    result= reconstruction (bufF, bufUniFactors, zeroOneVecs, oldL, NTLN, eval);
    47104742#endif
    47114743    delete [] zeroOneVecs;
     
    47414773                                    factors, int l, int liftBound, int d, int*
    47424774                                    bounds, nmod_mat_t FLINTN, CFList& diophant,
    4743                                     CFMatrix& M, CFArray& Pi, CFArray& bufQ
     4775                                    CFMatrix& M, CFArray& Pi, CFArray& bufQ,
     4776                                    const CanonicalForm& eval
    47444777                                   )
    47454778#else
     
    47484781                                    factors, int l, int liftBound, int d, int*
    47494782                                    bounds, mat_zz_p& NTLN, CFList& diophant,
    4750                                     CFMatrix& M, CFArray& Pi, CFArray& bufQ
     4783                                    CFMatrix& M, CFArray& Pi, CFArray& bufQ,
     4784                                    const CanonicalForm& eval
    47514785                                   )
    47524786#endif
     
    48754909    bufF= F;
    48764910#ifdef HAVE_FLINT
    4877     result= reconstruction (bufF, bufFactors, zeroOneVecs, l, FLINTN);
    4878 #else
    4879     result= reconstruction (bufF, bufFactors, zeroOneVecs, l, NTLN);
     4911    result= reconstruction (bufF, bufFactors, zeroOneVecs, l, FLINTN, eval);
     4912#else
     4913    result= reconstruction (bufF, bufFactors, zeroOneVecs, l, NTLN, eval);
    48804914#endif
    48814915    delete [] zeroOneVecs;
     
    49074941      if (l < liftBound)
    49084942        reconstructionTry (result, bufF, bufFactors, l, factorsFound,
    4909                            factorsFoundIndex, FLINTN, false
     4943                           factorsFoundIndex, FLINTN, eval, false
    49104944                          );
    49114945      else
    49124946        reconstructionTry (result, bufF, bufFactors, degree (bufF) + 1 +
    49134947                           degree (LCF), factorsFound, factorsFoundIndex,
    4914                            FLINTN, false
     4948                           FLINTN, eval, false
    49154949                          );
    49164950
     
    49194953      if (l < liftBound)
    49204954        reconstructionTry (result, bufF, bufFactors, l, factorsFound,
    4921                            factorsFoundIndex, NTLN, false
     4955                           factorsFoundIndex, NTLN, eval, false
    49224956                          );
    49234957      else
    49244958        reconstructionTry (result, bufF, bufFactors, degree (bufF) + 1 +
    49254959                           degree (LCF), factorsFound, factorsFoundIndex,
    4926                            NTLN, false
     4960                           NTLN, eval, false
    49274961                          );
    49284962
     
    49544988  {
    49554989    delete [] A;
    4956     return CFList (F);
     4990    return CFList (F (y-eval,y));
    49574991  }
    49584992  delete [] A;
     
    49665000                                    factors, int l, int liftBound, int d, int*
    49675001                                    bounds, mat_zz_pE& NTLN, CFList& diophant,
    4968                                     CFMatrix& M, CFArray& Pi, CFArray& bufQ
     5002                                    CFMatrix& M, CFArray& Pi, CFArray& bufQ,
     5003                                    const CanonicalForm& eval
    49695004                                   )
    49705005{
     
    50385073    int * zeroOneVecs= extractZeroOneVecs (NTLN);
    50395074    bufF= F;
    5040     result= reconstruction (bufF, bufFactors, zeroOneVecs, l, NTLN);
     5075    result= reconstruction (bufF, bufFactors, zeroOneVecs, l, NTLN, eval);
    50415076    delete [] zeroOneVecs;
    50425077    if (result.length() > 0 && degree (bufF) + 1 + degree (LC (bufF, 1)) <= l)
     
    50575092      if (l < liftBound)
    50585093        reconstructionTry (result, bufF, bufFactors, l, factorsFound,
    5059                            factorsFoundIndex, NTLN, false
     5094                           factorsFoundIndex, NTLN, eval, false
    50605095                          );
    50615096      else
    50625097        reconstructionTry (result, bufF, bufFactors, degree (bufF) + 1 +
    50635098                           degree (LCF), factorsFound, factorsFoundIndex,
    5064                            NTLN, false
     5099                           NTLN, eval, false
    50655100                          );
    50665101      if (NTLN.NumCols() == result.length())
     
    50905125  {
    50915126    delete [] A;
    5092     return CFList (F);
     5127    return CFList (F (y-eval,y));
    50935128  }
    50945129  delete [] A;
     
    53065341                                         nmod_mat_t FLINTN, CFList& diophant,
    53075342                                         CFMatrix& M, CFArray& Pi, CFArray& bufQ,
    5308                                          const Variable& alpha
     5343                                         const Variable& alpha,
     5344                                         const CanonicalForm& eval
    53095345                                        )
    53105346#else
     
    53145350                                         mat_zz_p& NTLN, CFList& diophant,
    53155351                                         CFMatrix& M, CFArray& Pi, CFArray& bufQ,
    5316                                          const Variable& alpha
     5352                                         const Variable& alpha,
     5353                                         const CanonicalForm& eval
    53175354                                        )
    53185355#endif
     
    54395476    CanonicalForm bufF= F;
    54405477#ifdef HAVE_FLINT
    5441     result= reconstruction (bufF, bufFactors, zeroOneVecs, l, FLINTN);
    5442 #else
    5443     result= reconstruction (bufF, bufFactors, zeroOneVecs, l, NTLN);
     5478    result= reconstruction (bufF, bufFactors, zeroOneVecs, l, FLINTN, eval);
     5479#else
     5480    result= reconstruction (bufF, bufFactors, zeroOneVecs, l, NTLN,  eval);
    54445481#endif
    54455482    delete [] zeroOneVecs;
     
    54715508      if (l < degree (bufF) + 1 + degree (LCF))
    54725509        reconstructionTry (result, bufF, bufFactors, l, factorsFound,
    5473                            factorsFoundIndex, FLINTN, false
     5510                           factorsFoundIndex, FLINTN, eval, false
    54745511                          );
    54755512      else
    54765513        reconstructionTry (result, bufF, bufFactors, degree (bufF) + 1 +
    54775514                           degree (LCF), factorsFound, factorsFoundIndex,
    5478                            FLINTN, false
     5515                           FLINTN, eval, false
    54795516                          );
    54805517      if (nmod_mat_ncols (FLINTN) == result.length())
     
    54825519      if (l < degree (bufF) + 1 + degree (LCF))
    54835520        reconstructionTry (result, bufF, bufFactors, l, factorsFound,
    5484                            factorsFoundIndex, NTLN, false
     5521                           factorsFoundIndex, NTLN, eval, false
    54855522                          );
    54865523      else
    54875524        reconstructionTry (result, bufF, bufFactors, degree (bufF) + 1 +
    54885525                           degree (LCF), factorsFound, factorsFoundIndex,
    5489                            NTLN, false
     5526                           NTLN, eval, false
    54905527                          );
    54915528      if (NTLN.NumCols() == result.length())
     
    55165553  {
    55175554    delete [] A;
    5518     return CFList (F);
     5555    return CFList (F (y-eval,y));
    55195556  }
    55205557  delete [] A;
     
    56635700#ifdef HAVE_FLINT
    56645701    reconstructionTry (result, bufF, factors, smallFactorDeg, factorsFound,
    5665                        factorsFoundIndex, FLINTN, beenInThres
     5702                       factorsFoundIndex, FLINTN, evaluation, beenInThres
    56665703                      );
    56675704    if (result.length() == nmod_mat_ncols (FLINTN))
     
    56705707#else
    56715708    reconstructionTry (result, bufF, factors, smallFactorDeg, factorsFound,
    5672                        factorsFoundIndex, NTLN, beenInThres
     5709                       factorsFoundIndex, NTLN, evaluation, beenInThres
    56735710                      );
    56745711    if (result.length() == NTLN.NumCols())
     
    57015738#ifdef HAVE_FLINT
    57025739      reconstructionTry (result, bufF, factors, l, factorsFound,
    5703                          factorsFoundIndex, FLINTN, beenInThres
     5740                         factorsFoundIndex, FLINTN, evaluation, beenInThres
    57045741                        );
    57055742      if (result.length() == nmod_mat_ncols (FLINTN))
     
    57085745#else
    57095746      reconstructionTry (result, bufF, factors, l, factorsFound,
    5710                          factorsFoundIndex, NTLN, beenInThres
     5747                         factorsFoundIndex, NTLN, evaluation, beenInThres
    57115748                        );
    57125749      if (result.length() == NTLN.NumCols())
     
    57285765    {
    57295766      dummy= tmin (degree (F,y)+1, ((degree (F,y)/4)+1)*i+4);
     5767      if (l < dummy)
     5768      {
     5769        factors.insert (LCF);
     5770        henselLiftResume12 (F, factors, l, dummy, Pi, diophant, M);
     5771        l= dummy;
     5772        if (i == 1 && degree (F)%4==0 && symmetric && factors.length() == 2 &&
     5773            LC (F,1).inCoeffDomain() &&
     5774           (degree (factors.getFirst(), 1) == degree (factors.getLast(),1)))
     5775        {
     5776          Variable x= Variable (1);
     5777          CanonicalForm g, h, gg, hh, multiplier1, multiplier2, check1, check2;
     5778          int m= degree (F)/4+1;
     5779          g= factors.getFirst();
     5780          h= factors.getLast();
     5781          g= mod (g, power (y,m));
     5782          h= mod (h, power (y,m));
     5783          g= g (y-evaluation, y);
     5784          h= h (y-evaluation, y);
     5785          gg= mod (swapvar (g,x,y),power (x,m));
     5786          gg= gg (y + evaluation, y);
     5787          multiplier1= factors.getLast()[m-1][0]/gg[m-1][0];
     5788          gg= div (gg, power (y,m));
     5789          gg= gg*power (y,m);
     5790          hh= mod (swapvar (h,x,y),power (x,m));
     5791          hh= hh (y + evaluation, y);
     5792          multiplier2= factors.getFirst()[m-1][0]/hh[m-1][0];
     5793          hh= div (hh, power (y,m));
     5794          hh= hh*power (y,m);
     5795          gg= multiplier1*gg+mod (factors.getLast(), power (y,m));
     5796          hh= multiplier2*hh+mod (factors.getFirst(), power (y,m));
     5797          check1= gg (y-evaluation,y);
     5798          check2= hh (y-evaluation,y);
     5799          CanonicalForm oldcheck1= check1;
     5800          check1= swapvar (check1, x, y);
     5801          if (check1/Lc (check1) == check2/Lc (check2))
     5802          {
     5803#ifdef HAVE_FLINT
     5804            nmod_mat_clear (FLINTN);
     5805#endif
     5806            result.append (oldcheck1);
     5807            result.append (check2);
     5808            delete [] liftPre;
     5809            delete [] factorsFoundIndex;
     5810            return result;
     5811          }
     5812        }
     5813      }
     5814      else
     5815      {
     5816        i++;
     5817        if (i < 5)
     5818          continue;
     5819      }
     5820#ifdef HAVE_FLINT
     5821      reconstructionTry (result, bufF, factors, l, factorsFound,
     5822                         factorsFoundIndex, FLINTN, evaluation, beenInThres
     5823                        );
     5824      if (result.length() == nmod_mat_ncols (FLINTN))
     5825      {
     5826        nmod_mat_clear (FLINTN);
     5827#else
     5828      reconstructionTry (result, bufF, factors, l, factorsFound,
     5829                         factorsFoundIndex, NTLN, evaluation, beenInThres
     5830                        );
     5831      if (result.length() == NTLN.NumCols())
     5832      {
     5833#endif
     5834        delete [] liftPre;
     5835        delete [] factorsFoundIndex;
     5836        return result;
     5837      }
     5838      i++;
     5839    }
     5840  }
     5841
     5842#ifdef HAVE_FLINT
     5843  nmod_mat_clear (FLINTN);
     5844#endif
     5845  delete [] liftPre;
     5846  delete [] factorsFoundIndex;
     5847  return result;
     5848}
     5849
     5850CFList
     5851earlyReconstructionAndLifting (const CanonicalForm& F, const mat_zz_pE& N,
     5852                               CanonicalForm& bufF, CFList& factors, int& l,
     5853                               int& factorsFound, bool beenInThres, CFMatrix& M,
     5854                               CFArray& Pi, CFList& diophant, bool symmetric,
     5855                               const CanonicalForm& evaluation
     5856                              )
     5857{
     5858  int sizeOfLiftPre;
     5859  int * liftPre= getLiftPrecisions (F, sizeOfLiftPre, degree (LC (F, 1), 2));
     5860  Variable y= F.mvar();
     5861  factorsFound= 0;
     5862  CanonicalForm LCF= LC (F, 1);
     5863  CFList result;
     5864  int smallFactorDeg= 11;
     5865  mat_zz_pE NTLN= N;
     5866  int * factorsFoundIndex= new int [NTLN.NumCols()];
     5867  for (long i= 0; i < NTLN.NumCols(); i++)
     5868    factorsFoundIndex [i]= 0;
     5869
     5870  if (degree (F) + 1 > smallFactorDeg)
     5871  {
     5872    if (l < smallFactorDeg)
     5873    {
     5874      factors.insert (LCF);
     5875      henselLiftResume12 (F, factors, l, smallFactorDeg, Pi, diophant, M);
     5876      l= smallFactorDeg;
     5877    }
     5878    reconstructionTry (result, bufF, factors, smallFactorDeg, factorsFound,
     5879                       factorsFoundIndex, NTLN, evaluation, beenInThres
     5880                      );
     5881    if (result.length() == NTLN.NumCols())
     5882    {
     5883      delete [] liftPre;
     5884      delete [] factorsFoundIndex;
     5885      return result;
     5886    }
     5887  }
     5888
     5889  int i= sizeOfLiftPre - 1;
     5890  int dummy= 1;
     5891  if (sizeOfLiftPre > 1 && sizeOfLiftPre < 30)
     5892  {
     5893    while (i > 0)
     5894    {
     5895      if (l < liftPre[i-1] + 1)
     5896      {
     5897        factors.insert (LCF);
     5898        henselLiftResume12 (F, factors, l, liftPre[i-1] + 1, Pi, diophant, M);
     5899        l= liftPre[i-1] + 1;
     5900      }
     5901      else
     5902      {
     5903        i--;
     5904        if (i != 0)
     5905          continue;
     5906      }
     5907      reconstructionTry (result, bufF, factors, l, factorsFound,
     5908                         factorsFoundIndex, NTLN, evaluation, beenInThres
     5909                        );
     5910      if (result.length() == NTLN.NumCols())
     5911      {
     5912        delete [] liftPre;
     5913        delete [] factorsFoundIndex;
     5914        return result;
     5915      }
     5916      i--;
     5917    }
     5918  }
     5919  else
     5920  {
     5921    i= 1;
     5922    while ((degree (F,y)/4+1)*i + 4 <= smallFactorDeg)
     5923      i++;
     5924    while (i < 5)
     5925    {
     5926      dummy= tmin (degree (F,y)+1, (degree (F,y)/4+1)*i+4);
    57305927      if (l < dummy)
    57315928      {
     
    57635960          if (check1/Lc (check1) == check2/Lc (check2))
    57645961          {
    5765 #ifdef HAVE_FLINT
    5766             nmod_mat_clear (FLINTN);
    5767 #endif
    5768             result.append (gg);
    5769             result.append (hh);
     5962            result.append (check1);
     5963            result.append (check2);
    57705964            delete [] liftPre;
    57715965            delete [] factorsFoundIndex;
     
    57805974          continue;
    57815975      }
    5782 #ifdef HAVE_FLINT
    57835976      reconstructionTry (result, bufF, factors, l, factorsFound,
    5784                          factorsFoundIndex, FLINTN, beenInThres
    5785                         );
    5786       if (result.length() == nmod_mat_ncols (FLINTN))
    5787       {
    5788         nmod_mat_clear (FLINTN);
    5789 #else
    5790       reconstructionTry (result, bufF, factors, l, factorsFound,
    5791                          factorsFoundIndex, NTLN, beenInThres
    5792                         );
    5793       if (result.length() == NTLN.NumCols())
    5794       {
    5795 #endif
    5796         delete [] liftPre;
    5797         delete [] factorsFoundIndex;
    5798         return result;
    5799       }
    5800       i++;
    5801     }
    5802   }
    5803 
    5804 #ifdef HAVE_FLINT
    5805   nmod_mat_clear (FLINTN);
    5806 #endif
    5807   delete [] liftPre;
    5808   delete [] factorsFoundIndex;
    5809   return result;
    5810 }
    5811 
    5812 CFList
    5813 earlyReconstructionAndLifting (const CanonicalForm& F, const mat_zz_pE& N,
    5814                                CanonicalForm& bufF, CFList& factors, int& l,
    5815                                int& factorsFound, bool beenInThres, CFMatrix& M,
    5816                                CFArray& Pi, CFList& diophant, bool symmetric,
    5817                                const CanonicalForm& evaluation
    5818                               )
    5819 {
    5820   int sizeOfLiftPre;
    5821   int * liftPre= getLiftPrecisions (F, sizeOfLiftPre, degree (LC (F, 1), 2));
    5822   Variable y= F.mvar();
    5823   factorsFound= 0;
    5824   CanonicalForm LCF= LC (F, 1);
    5825   CFList result;
    5826   int smallFactorDeg= 11;
    5827   mat_zz_pE NTLN= N;
    5828   int * factorsFoundIndex= new int [NTLN.NumCols()];
    5829   for (long i= 0; i < NTLN.NumCols(); i++)
    5830     factorsFoundIndex [i]= 0;
    5831 
    5832   if (degree (F) + 1 > smallFactorDeg)
    5833   {
    5834     if (l < smallFactorDeg)
    5835     {
    5836       factors.insert (LCF);
    5837       henselLiftResume12 (F, factors, l, smallFactorDeg, Pi, diophant, M);
    5838       l= smallFactorDeg;
    5839     }
    5840     reconstructionTry (result, bufF, factors, smallFactorDeg, factorsFound,
    5841                        factorsFoundIndex, NTLN, beenInThres
    5842                       );
    5843     if (result.length() == NTLN.NumCols())
    5844     {
    5845       delete [] liftPre;
    5846       delete [] factorsFoundIndex;
    5847       return result;
    5848     }
    5849   }
    5850 
    5851   int i= sizeOfLiftPre - 1;
    5852   int dummy= 1;
    5853   if (sizeOfLiftPre > 1 && sizeOfLiftPre < 30)
    5854   {
    5855     while (i > 0)
    5856     {
    5857       if (l < liftPre[i-1] + 1)
    5858       {
    5859         factors.insert (LCF);
    5860         henselLiftResume12 (F, factors, l, liftPre[i-1] + 1, Pi, diophant, M);
    5861         l= liftPre[i-1] + 1;
    5862       }
    5863       else
    5864       {
    5865         i--;
    5866         if (i != 0)
    5867           continue;
    5868       }
    5869       reconstructionTry (result, bufF, factors, l, factorsFound,
    5870                          factorsFoundIndex, NTLN, beenInThres
    5871                         );
    5872       if (result.length() == NTLN.NumCols())
    5873       {
    5874         delete [] liftPre;
    5875         delete [] factorsFoundIndex;
    5876         return result;
    5877       }
    5878       i--;
    5879     }
    5880   }
    5881   else
    5882   {
    5883     i= 1;
    5884     while ((degree (F,y)/4+1)*i + 4 <= smallFactorDeg)
    5885       i++;
    5886     while (i < 5)
    5887     {
    5888       dummy= tmin (degree (F,y)+1, (degree (F,y)/4+1)*i+4);
    5889       if (l < dummy)
    5890       {
    5891         factors.insert (LCF);
    5892         henselLiftResume12 (F, factors, l, dummy, Pi, diophant, M);
    5893         l= dummy;
    5894         if (i == 1 && degree (F)%4==0 && symmetric && factors.length() == 2 &&
    5895             LC (F,1).inCoeffDomain() &&
    5896            (degree (factors.getFirst(), 1) == degree (factors.getLast(),1)))
    5897         {
    5898           Variable x= Variable (1);
    5899           CanonicalForm g, h, gg, hh, multiplier1, multiplier2, check1, check2;
    5900           int m= degree (F)/4+1;
    5901           g= factors.getFirst();
    5902           h= factors.getLast();
    5903           g= mod (g, power (y,m));
    5904           h= mod (h, power (y,m));
    5905           g= g (y-evaluation, y);
    5906           h= h (y-evaluation, y);
    5907           gg= mod (swapvar (g,x,y),power (x,m));
    5908           gg= gg (y + evaluation, y);
    5909           multiplier1= factors.getLast()[m-1][0]/gg[m-1][0];
    5910           gg= div (gg, power (y,m));
    5911           gg= gg*power (y,m);
    5912           hh= mod (swapvar (h,x,y),power (x,m));
    5913           hh= hh (y + evaluation, y);
    5914           multiplier2= factors.getFirst()[m-1][0]/hh[m-1][0];
    5915           hh= div (hh, power (y,m));
    5916           hh= hh*power (y,m);
    5917           gg= multiplier1*gg+mod (factors.getLast(), power (y,m));
    5918           hh= multiplier2*hh+mod (factors.getFirst(), power (y,m));
    5919           check1= gg (y-evaluation,y);
    5920           check2= hh (y-evaluation,y);
    5921           check1= swapvar (check1, x, y);
    5922           if (check1/Lc (check1) == check2/Lc (check2))
    5923           {
    5924             result.append (gg);
    5925             result.append (hh);
    5926             delete [] liftPre;
    5927             delete [] factorsFoundIndex;
    5928             return result;
    5929           }
    5930         }
    5931       }
    5932       else
    5933       {
    5934         i++;
    5935         if (i < 5)
    5936           continue;
    5937       }
    5938       reconstructionTry (result, bufF, factors, l, factorsFound,
    5939                          factorsFoundIndex, NTLN, beenInThres
     5977                         factorsFoundIndex, NTLN, evaluation, beenInThres
    59405978                        );
    59415979      if (result.length() == NTLN.NumCols())
     
    60696107sieveSmallFactors (const CanonicalForm& G, CFList& uniFactors, DegreePattern&
    60706108                   degPat, CanonicalForm& H, CFList& diophant, CFArray& Pi,
    6071                    CFMatrix& M, bool& success, int d
     6109                   CFMatrix& M, bool& success, int d, const CanonicalForm& eval
    60726110                  )
    60736111{
     
    60856123  CFList earlyFactors;
    60866124  earlyFactorDetection (earlyFactors, F, bufUniFactors, adaptedLiftBound,
    6087                         factorsFoundIndex, degs, success, smallFactorDeg);
     6125                        factorsFoundIndex, degs, success, smallFactorDeg, eval);
    60886126  delete [] factorsFoundIndex;
    60896127  if (degs.getLength() == 1)
     
    61626200henselLiftAndLatticeRecombi (const CanonicalForm& G, const CFList& uniFactors,
    61636201                             const Variable& alpha, const DegreePattern& degPat,
    6164                              bool symmetric, const CanonicalForm& evaluation
     6202                             bool symmetric, const CanonicalForm& eval
    61656203                            )
    61666204{
     
    61956233  bool success= false;
    61966234  smallFactors= sieveSmallFactors (F, bufUniFactors, degs, H, diophant, Pi, M,
    6197                                    success, minBound + 1
     6235                                   success, minBound + 1, eval
    61986236                                  );
    61996237
     
    62056243      {
    62066244        delete [] bounds;
    6207         return CFList (G);
     6245        return CFList (G (y-eval,y));
    62086246      }
    62096247    }
     
    62206258  {
    62216259    index= 1;
    6222     tmp1= mod (i.getItem(),y);
     6260    tmp1= mod (i.getItem(),y-eval);
    62236261    tmp1 /= Lc (tmp1);
    62246262    for (CFListIterator j= bufUniFactors; j.hasItem(); j++, index++)
     
    62486286    if (isIrreducible)
    62496287    {
    6250       smallFactors.append (F);
     6288      smallFactors.append (F (y-eval,y));
    62516289      delete [] bounds;
    62526290      return smallFactors;
     
    62696307    if (degs.getLength() <= 1)
    62706308    {
    6271       smallFactors.append (F);
     6309      smallFactors.append (F (y-eval,y));
    62726310      delete [] bounds;
    62736311      return smallFactors;
     
    64006438                  factorRecombination (bufUniFactors, F,
    64016439                                       power (y, degree (F) + 1),
    6402                                        degs, 1, bufUniFactors.length()/2
     6440                                       degs, eval, 1, bufUniFactors.length()/2
    64036441                                      )
    64046442                 );
     
    64136451#endif
    64146452    delete [] bounds;
    6415     return Union (CFList (F), smallFactors);
     6453    return Union (CFList (F(y-eval,y)), smallFactors);
    64166454  }
    64176455
     
    64446482      reconstructionTry (result, bufF, bufUniFactors, degree (F) + 1,
    64456483#ifdef HAVE_FLINT
    6446                          factorsFound, factorsFoundIndex, FLINTN, false
    6447 #else
    6448                          factorsFound, factorsFoundIndex, NTLN, false
     6484                         factorsFound, factorsFoundIndex, FLINTN, eval, false
     6485#else
     6486                         factorsFound, factorsFoundIndex, NTLN, eval, false
    64496487#endif
    64506488                        );
    64516489    else
    64526490        reconstructionTry (result, bufF, bufUniFactors, degree (F) + 1,
    6453                            factorsFound, factorsFoundIndex, NTLNe, false
     6491                           factorsFound, factorsFoundIndex, NTLNe, eval, false
    64546492                          );
    64556493    if (alpha.level() == 1 || (alpha.level() != 1 && reduceFq2Fp))
     
    65056543      reconstructionTry (result, bufF, bufUniFactors, degree (F) + 1,
    65066544#ifdef HAVE_FLINT
    6507                          factorsFound, factorsFoundIndex, FLINTN, false
    6508 #else
    6509                          factorsFound, factorsFoundIndex, NTLN, false
     6545                         factorsFound, factorsFoundIndex, FLINTN, eval, false
     6546#else
     6547                         factorsFound, factorsFoundIndex, NTLN, eval, false
    65106548#endif
    65116549                        );
    65126550    else
    65136551      reconstructionTry (result, bufF, bufUniFactors, degree (F) + 1,
    6514                          factorsFound, factorsFoundIndex, NTLNe, false
     6552                         factorsFound, factorsFoundIndex, NTLNe, eval, false
    65156553                        );
    65166554    if (alpha.level() == 1 || (alpha.level() != 1 && reduceFq2Fp))
     
    65846622#endif
    65856623                                           factorsFound, beenInThres, M, Pi,
    6586                                            diophant, symmetric, evaluation
     6624                                           diophant, symmetric, eval
    65876625                                          );
    65886626
     
    66036641    result= earlyReconstructionAndLifting (F, NTLNe, bufF, bufUniFactors, l,
    66046642                                           factorsFound, beenInThres, M, Pi,
    6605                                            diophant, symmetric, evaluation
     6643                                           diophant, symmetric, eval
    66066644                                          );
    66076645
     
    66216659      {
    66226660        index= 1;
    6623         tmp1= mod (i.getItem(), y);
     6661        tmp1= mod (i.getItem(), y-eval);
    66246662        tmp1 /= Lc (tmp1);
    66256663        for (CFListIterator j= bufUniFactors; j.hasItem(); j++, index++)
     
    66966734        for (iter2= result; iter2.hasItem(); iter2++)
    66976735        {
    6698           tmp= mod (iter2.getItem(), y);
     6736          tmp= mod (iter2.getItem(), y-eval);
    66996737          tmp /= Lc (tmp);
    67006738          if (tmp == buf)
     
    67216759#endif
    67226760      resultBufF= increasePrecision (bufF, bufUniFactors, factorsFound,
    6723                                      oldNumCols, oldL, l
     6761                                     oldNumCols, oldL, l, eval
    67246762                                    );
    67256763    }
     
    67356773
    67366774        resultBufF= increasePrecisionFq2Fp (bufF, bufUniFactors, factorsFound,
    6737                                             oldNumCols, oldL, alpha, l
     6775                                            oldNumCols, oldL, alpha, l, eval
    67386776                                           );
    67396777      }
     
    67436781
    67446782        resultBufF= increasePrecision (bufF, bufUniFactors, factorsFound,
    6745                                        oldNumCols, oldL,  alpha, l
     6783                                       oldNumCols, oldL, alpha, l, eval
    67466784                                      );
    67476785      }
     
    67746812        nmod_mat_clear (FLINTN);
    67756813#endif
    6776       result.append (bufF);
     6814      result.append (bufF (y-eval,y));
    67776815      return result;
    67786816    }
     
    67836821    return Union (result, henselLiftAndLatticeRecombi (bufF, bufUniFactors,
    67846822                                                       alpha, degs, symmetric,
    6785                                                        evaluation
     6823                                                       eval
    67866824                                                      )
    67876825                 );
     
    67946832        result=increasePrecision (F, bufUniFactors, oldL, l, d, bounds, bufQ,
    67956833#ifdef HAVE_FLINT
    6796                                   FLINTN
    6797 #else
    6798                                   NTLN
     6834                                  FLINTN, eval
     6835#else
     6836                                  NTLN, eval
    67996837#endif
    68006838                                 );
     
    68066844          result=increasePrecisionFq2Fp (F, bufUniFactors, oldL, l, d, bounds,
    68076845#ifdef HAVE_FLINT
    6808                                          bufQ, FLINTN, alpha
    6809 #else
    6810                                          bufQ, NTLN, alpha
     6846                                         bufQ, FLINTN, alpha, eval
     6847#else
     6848                                         bufQ, NTLN, alpha, eval
    68116849#endif
    68126850                                        );
     
    68156853      {
    68166854          result=increasePrecision (F, bufUniFactors, oldL, l, d, bounds, bufQ,
    6817                                     NTLNe
     6855                                    NTLNe, eval
    68186856                                   );
    68196857      }
     
    68536891                                                    liftBound, d, bounds, NTLN,
    68546892#endif
    6855                                                     diophant, M, Pi, bufQ
     6893                                                    diophant, M, Pi, bufQ, eval
    68566894                                                   );
    68576895      else
     
    68656903                                                           NTLN, diophant, M,
    68666904#endif
    6867                                                            Pi, bufQ, alpha
     6905                                                           Pi, bufQ, alpha, eval
    68686906                                                          );
    68696907        else
     
    68716909                                                      liftBound, d, bounds,
    68726910                                                      NTLNe, diophant, M,
    6873                                                       Pi, bufQ
     6911                                                      Pi, bufQ, eval
    68746912                                                     );
    68756913      }
     
    69186956    delete [] bounds;
    69196957    result= Union (result, smallFactors);
    6920     result.append (F);
     6958    result.append (F (y-eval,y));
    69216959    return result;
    69226960  }
     
    69336971    CanonicalForm MODl= power (y, degree (F) + 1);
    69346972    delete [] bounds;
    6935     return Union (result, factorRecombination (bufUniFactors, F, MODl, degs, 1,
    6936                                                bufUniFactors.length()/2
     6973    return Union (result, factorRecombination (bufUniFactors, F, MODl, degs,
     6974                                               eval, 1, bufUniFactors.length()/2
    69376975                                              )
    69386976                 );
     
    69456983    delete [] bounds;
    69466984    return Union (result, henselLiftAndLatticeRecombi (F, bufUniFactors, alpha,
    6947                                                        degs,symmetric, evaluation
     6985                                                       degs,symmetric, eval
    69486986                                                      )
    69496987                 );
     
    79067944                                       evaluation, 1, uniFactors.length()/2);
    79077945    else
    7908       factors= factorRecombination (uniFactors, A, MODl, degs, 1,
     7946      factors= factorRecombination (uniFactors, A, MODl, degs, evaluation, 1,
    79097947                                    uniFactors.length()/2);
    79107948    TIMING_END_AND_PRINT (fac_fq_bi_factor_recombination,
     
    79587996    {
    79597997      TIMING_START (fac_fq_bi_factor_recombination);
    7960       factors= factorRecombination (uniFactors, A, MODl, degs, 1, 3);
     7998      factors= factorRecombination (uniFactors, A, MODl, degs, evaluation, 1, 3);
    79617999      TIMING_END_AND_PRINT (fac_fq_bi_factor_recombination,
    79628000                            "time for small subset naive recombi over Fq: ");
     
    79698007        if (alpha.level() == 1)
    79708008          tmp= increasePrecision (A, uniFactors, 0, uniFactors.length(), 1,
    7971                                   liftBound
     8009                                  liftBound, evaluation
    79728010                                 );
    79738011        else
     
    79758013          if (degree (A) > getCharacteristic())
    79768014            tmp= increasePrecisionFq2Fp (A, uniFactors, 0, uniFactors.length(),
    7977                                          1, alpha, liftBound
     8015                                         1, alpha, liftBound, evaluation
    79788016                                        );
    79798017          else
    79808018            tmp= increasePrecision (A, uniFactors, 0, uniFactors.length(), 1,
    7981                                     alpha, liftBound
     8019                                    alpha, liftBound, evaluation
    79828020                                   );
    79838021        }
     
    79938031          degs.refine ();
    79948032          factors= Union (factors, factorRecombination (uniFactors, A, MODl,
    7995                                                         degs, 4,
     8033                                                        degs, evaluation, 4,
    79968034                                                        uniFactors.length()/2
    79978035                                                       )
     
    80728110    delete [] bounds2;
    80738111  delete [] bounds;
    8074   if (!extension)
    8075   {
    8076     for (CFListIterator i= factors; i.hasItem(); i++)
    8077       i.getItem()= i.getItem() (y - evaluation, y);
    8078   }
    80798112
    80808113  appendSwapDecompress (factors, contentAxFactors, contentAyFactors,
  • factory/facFqBivar.h

    r5e4636 r2537fa0  
    545545            const CanonicalForm& M,     ///< [in] Variable (2)^liftBound
    546546            DegreePattern& degs,        ///< [in] degree pattern
     547            const CanonicalForm& eval,  ///< [in] evaluation point
    547548            int s,                      ///< [in] algorithm starts checking
    548549                                        ///< subsets of size s
     
    598599           bool& success,          ///< [in,out] indicating success
    599600           int deg,                ///< [in] stage of Hensel lifting
    600            const modpk& b= modpk() ///< [in] coeff bound
     601           const CanonicalForm& eval, ///<[in] evaluation point
     602           const modpk& b= modpk()///< [in] coeff bound
    601603                     );
    602604
Note: See TracChangeset for help on using the changeset viewer.