Changeset 38ffb7 in git


Ignore:
Timestamp:
Sep 2, 2011, 11:41:32 AM (13 years ago)
Author:
Martin Lee <martinlee84@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', '648d28f488f6ff08f5607ff229b9ad9e4a5b93c2')
Children:
96f9fdfab406c4f1b69b407c26a25d199352b8c5
Parents:
0349c206d67778742e0d31e4173c6f30b493a2a8
Message:
code clean up in facFqBivar.cc, facFqFactorize.cc, facFactorize.cc


git-svn-id: file:///usr/local/Singular/svn/trunk@14378 2c84dea3-7e68-4137-9b89-c4e89433aadc
Location:
factory
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • factory/facFactorize.cc

    r0349c20 r38ffb7  
    3636  bool found= false;
    3737  CanonicalForm deriv_x, gcd_deriv;
     38  CFListIterator iter;
    3839  do
    3940  {
     
    7677      continue;
    7778    }
    78     CFListIterator i= eval;
    79     i++;
    80     CanonicalForm contentx= content (i.getItem(), x);
     79    iter= eval;
     80    iter++;
     81    CanonicalForm contentx= content (iter.getItem(), x);
    8182    if (degree (contentx) > 0)
    8283    {
     
    103104  minFactorsLength= 0;
    104105  irred= false;
     106  Variable v;
     107  CFList factors;
    105108  for (int j= 0; j < A.level() - 2; j++)
    106109  {
    107110    if (!Aeval[j].isEmpty())
    108111    {
    109       Variable v= Variable (Aeval[j].getFirst().level());
    110 
    111       CFList factors= ratBiSqrfFactorize (Aeval[j].getFirst(), w);
     112      v= Variable (Aeval[j].getFirst().level());
     113
     114      factors= ratBiSqrfFactorize (Aeval[j].getFirst(), w);
    112115
    113116      if (factors.getFirst().inCoeffDomain())
     
    135138             CFFList*& bufSqrfFactors, CFList& evalSqrfPartF)
    136139{
     140  CanonicalForm tmp;
     141  CFListIterator j;
    137142  for (CFListIterator i= uniFactors; i.hasItem(); i++)
    138143  {
    139     CanonicalForm tmp= i.getItem();
     144    tmp= i.getItem();
    140145    if (i.hasItem())
    141146      i++;
    142147    else
    143148      break;
    144     for (CFListIterator j= i; j.hasItem(); j++)
     149    for (j= i; j.hasItem(); j++)
    145150    {
    146151      if (tmp == j.getItem())
     
    167172  int k= 0;
    168173  factors= uniFactors;
     174  CFFListIterator iter;
    169175  for (CFListIterator i= factors; i.hasItem(); i++, k++)
    170176  {
    171     CanonicalForm tmp= 1;
     177    tmp= 1;
    172178    sqrfFactors= sqrFree (i.getItem());
    173179
    174     for (CFFListIterator j= sqrfFactors; j.hasItem(); j++)
    175     {
    176       tmp2.append (j.getItem().factor());
    177       tmp *= j.getItem().factor();
     180    for (iter= sqrfFactors; iter.hasItem(); iter++)
     181    {
     182      tmp2.append (iter.getItem().factor());
     183      tmp *= iter.getItem().factor();
    178184    }
    179185    i.getItem()= tmp/Lc(tmp);
     
    194200    if (i == 0)
    195201    {
    196       for (CFFListIterator k= bufSqrfFactors [i]; k.hasItem(); k++)
    197       {
    198         k.getItem()= CFFactor (k.getItem().factor()/Lc (k.getItem().factor()),
    199                                k.getItem().exp());
    200         factors.append (k.getItem().factor());
     202      for (iter= bufSqrfFactors [i]; iter.hasItem(); iter++)
     203      {
     204        iter.getItem()= CFFactor (iter.getItem().factor()/
     205                                  Lc (iter.getItem().factor()),
     206                                  iter.getItem().exp());
     207        factors.append (iter.getItem().factor());
    201208      }
    202209    }
    203210    else
    204211    {
    205       for (CFFListIterator k= bufSqrfFactors [i]; k.hasItem(); k++)
    206       {
    207         k.getItem()= CFFactor (k.getItem().factor()/Lc (k.getItem().factor()),
    208                                k.getItem().exp());
    209         if (!find (factors, k.getItem().factor()))
    210           factors.append (k.getItem().factor());
     212      for (iter= bufSqrfFactors [i]; iter.hasItem(); iter++)
     213      {
     214        iter.getItem()= CFFactor (iter.getItem().factor()/
     215                               Lc (iter.getItem().factor()),
     216                               iter.getItem().exp());
     217        if (!find (factors, iter.getItem().factor()))
     218          factors.append (iter.getItem().factor());
    211219      }
    212220    }
     
    214222
    215223  test= prod (factors);
    216   CanonicalForm tmp= evalSqrfPartF.getFirst() (0,2);
     224  tmp= evalSqrfPartF.getFirst() (0,2);
    217225  if (test/Lc (test) != tmp/Lc (tmp))
    218226    return 0;
     
    258266    else
    259267    {
     268      CFListIterator j;
    260269      for (int i= 0; i < length; i++)
    261270      {
    262         for (CFListIterator j= differentSecondVarLCs[i]; j.hasItem(); j++)
     271        for (j= differentSecondVarLCs[i]; j.hasItem(); j++)
    263272        {
    264273          if (j.getItem().level() == LCFLevel)
     
    296305  CFFList * bufSqrfFactors= new CFFList [factors.length()];
    297306  CFList evalSqrfPartF;
    298   CanonicalForm bufContent;
    299307  CFList bufFactors;
    300308  //TODO sqrfPartF einmal berechnen nicht stÀndig
     
    319327    for (int i= 0; i < length; i++)
    320328    {
     329      CanonicalForm bufF;
     330      CFListIterator iter;
     331      CFList bufBufFactors;
    321332      if (!differentSecondVarLCs [i].isEmpty())
    322333      {
    323334        bool allConstant= true;
    324         for (CFListIterator iter= differentSecondVarLCs[i]; iter.hasItem();
    325              iter++)
     335        for (iter= differentSecondVarLCs[i]; iter.hasItem(); iter++)
    326336        {
    327337          if (!iter.getItem().inCoeffDomain())
     
    335345
    336346        bufFactors= differentSecondVarLCs [i];
    337         for (CFListIterator iter= bufFactors; iter.hasItem(); iter++)
     347        for (iter= bufFactors; iter.hasItem(); iter++)
    338348          iter.getItem()= swapvar (iter.getItem(), x, y);
    339         CanonicalForm bufF= F;
     349        bufF= F;
    340350        z= Variable (y.level() - lev);
    341351        bufF= swapvar (bufF, x, z);
    342         CFList bufBufFactors= bufFactors;
     352        bufBufFactors= bufFactors;
    343353        pass= testFactors (bufF, bufBufFactors, sqrfPartF, bufFactors,
    344354                           bufSqrfFactors, evalSqrfPartF);
     
    348358          F= bufF;
    349359          CFList l= factors;
    350           for (CFListIterator iter= l; iter.hasItem(); iter++)
     360          for (iter= l; iter.hasItem(); iter++)
    351361            iter.getItem()= swapvar (iter.getItem(), x, y);
    352362          differentSecondVarLCs [i]= l;
     
    402412
    403413  CFList result;
     414  CFFListIterator k;
     415  CanonicalForm tmp;
    404416  for (int i= 0; i < LCFFactors.length(); i++)
    405417  {
    406     CanonicalForm tmp= 1;
    407     for (CFFListIterator k= bufSqrfFactors[i]; k.hasItem(); k++)
     418    tmp= 1;
     419    for (k= bufSqrfFactors[i]; k.hasItem(); k++)
    408420    {
    409421      int pos= findItem (bufFactors, k.getItem().factor());
  • factory/facFqBivar.cc

    r0349c20 r38ffb7  
    961961  Variable x= Variable (1);
    962962  CanonicalForm yToL= power (y, liftBound);
    963   CanonicalForm quot;
     963  CanonicalForm quot, buf;
     964  CFListIterator iter;
    964965  for (long i= 1; i <= N.NumCols(); i++)
    965966  {
    966967    if (factorsFoundIndex [i - 1] == 1)
    967968      continue;
    968     CFListIterator iter= factors;
    969     CanonicalForm buf;
     969    iter= factors;
    970970    if (beenInThres)
    971971    {
     
    10161016  Variable y= Variable (2);
    10171017  Variable x= Variable (1);
    1018   CanonicalForm quot;
     1018  CanonicalForm quot, buf;
    10191019  CanonicalForm yToL= power (y, liftBound);
     1020  CFListIterator iter;
    10201021  for (long i= 1; i <= N.NumCols(); i++)
    10211022  {
    10221023    if (factorsFoundIndex [i - 1] == 1)
    10231024      continue;
    1024     CFListIterator iter= factors;
    1025     CanonicalForm buf;
     1025    iter= factors;
    10261026    if (beenInThres)
    10271027    {
     
    10731073  CanonicalForm F= G;
    10741074  CanonicalForm yToL= power (y, precision);
    1075   CanonicalForm quot;
    1076   CFList result;
     1075  CanonicalForm quot, buf;
     1076  CFList result, factorsConsidered;
    10771077  CFList bufFactors= factors;
    1078   CFList factorsConsidered;
     1078  CFListIterator iter;
    10791079  for (long i= 1; i <= N.NumCols(); i++)
    10801080  {
    10811081    if (zeroOneVecs [i - 1] == 0)
    10821082      continue;
    1083     CFListIterator iter= factors;
    1084     CanonicalForm buf= 1;
     1083    iter= factors;
     1084    buf= 1;
    10851085    factorsConsidered= CFList();
    10861086    for (long j= 1; j <= N.NumRows(); j++, iter++)
     
    11231123  CanonicalForm F= G;
    11241124  CanonicalForm yToL= power (y, precision);
    1125   CanonicalForm quot;
     1125  CanonicalForm quot, buf, buf2;
    11261126  CFList result;
    11271127  CFList bufFactors= factors;
    11281128  CFList factorsConsidered;
     1129  CFListIterator iter;
    11291130  for (long i= 1; i <= N.NumCols(); i++)
    11301131  {
    11311132    if (zeroOneVecs [i - 1] == 0)
    11321133      continue;
    1133     CFListIterator iter= factors;
    1134     CanonicalForm buf= 1;
     1134    iter= factors;
     1135    buf= 1;
    11351136    factorsConsidered= CFList();
    11361137    for (long j= 1; j <= N.NumRows(); j++, iter++)
     
    11421143      }
    11431144    }
    1144     CanonicalForm buf2= buf;
     1145    buf2= buf;
    11451146    buf *= LC (F, x);
    11461147    buf= mod (buf, yToL);
     
    11831184  CFList bufFactors= factors;
    11841185  CFList factorsConsidered;
    1185   CanonicalForm buf2, quot;
     1186  CanonicalForm buf2, quot, buf;
     1187  CFListIterator iter;
    11861188  for (long i= 1; i <= N.NumCols(); i++)
    11871189  {
    11881190    if (zeroOneVecs [i - 1] == 0)
    11891191      continue;
    1190     CFListIterator iter= factors;
    1191     CanonicalForm buf= 1;
     1192    iter= factors;
     1193    buf= 1;
    11921194    factorsConsidered= CFList();
    11931195    for (long j= 1; j <= N.NumRows(); j++, iter++)
     
    12511253  CanonicalForm F= G;
    12521254  CanonicalForm yToL= power (y, precision);
    1253   CanonicalForm quot;
     1255  CanonicalForm quot, buf;
    12541256  CFList result;
    12551257  CFList bufFactors= factors;
    12561258  CFList factorsConsidered;
     1259  CFListIterator iter;
    12571260  for (long i= 1; i <= N.NumCols(); i++)
    12581261  {
    12591262    if (zeroOneVecs [i - 1] == 0)
    12601263      continue;
    1261     CFListIterator iter= factors;
    1262     CanonicalForm buf= 1;
     1264    iter= factors;
     1265    buf= 1;
    12631266    factorsConsidered= CFList();
    12641267    for (long j= 1; j <= N.NumRows(); j++, iter++)
     
    13071310  CanonicalForm delta= info.getDelta();
    13081311  CanonicalForm yToL= power (y, liftBound);
    1309   CanonicalForm quot;
     1312  CanonicalForm quot, buf, buf2;
    13101313  CFList source, dest;
     1314  CFListIterator iter;
    13111315  for (long i= 1; i <= N.NumCols(); i++)
    13121316  {
    13131317    if (factorsFoundIndex [i - 1] == 1)
    13141318      continue;
    1315     CFListIterator iter= factors;
    1316     CanonicalForm buf;
    1317     CanonicalForm buf2;
     1319    iter= factors;
    13181320    if (beenInThres)
    13191321    {
     
    13561358    else
    13571359    {
    1358       CFList source, dest;
    13591360      if (!isInExtension (buf2, gamma, k, delta, source, dest))
    13601361      {
     
    13981399  int oldL= l/2;
    13991400  bool reduced= false;
     1401  mat_zz_p NTLK, *NTLC;
     1402  CFMatrix C;
     1403  CFArray buf;
     1404  CFListIterator j;
    14001405  while (l <= liftBound)
    14011406  {
    1402 
    14031407    if (start)
    14041408    {
     
    14151419
    14161420    factors.insert (LCF);
    1417     CFListIterator j= factors;
     1421    j= factors;
    14181422    j++;
    14191423
     
    14211425    {
    14221426      if (!wasInBounds)
    1423       {
    14241427        A[i]= logarithmicDerivative (F, j.getItem(), l, bufQ[i]);
    1425       }
    14261428      else
    14271429        A[i]= logarithmicDerivative (F, j.getItem(), l, oldL, bufQ[i], bufQ[i]);
     
    14341436        wasInBounds= true;
    14351437        int k= tmin (bounds [i] + 1, l/2);
    1436         CFMatrix C= CFMatrix (l - k, factors.length() - 1);
     1438        C= CFMatrix (l - k, factors.length() - 1);
    14371439        for (int ii= 0; ii < factors.length() - 1; ii++)
    14381440        {
    1439           CFArray buf;
    14401441          if (A[ii].size() - 1 >= i)
    14411442            buf= getCoeffs (A[ii] [i], k);
    14421443          writeInMatrix (C, buf, ii + 1, 0);
    14431444        }
    1444         mat_zz_p* NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
    1445         mat_zz_p NTLK= (*NTLC)*NTLN;
     1445        NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
     1446        NTLK= (*NTLC)*NTLN;
    14461447        transpose (NTLK, NTLK);
    14471448        kernel (NTLK, NTLK);
     
    15151516  int oldL= l/2;
    15161517  bool reduced= false;
     1518  Variable y= F.mvar();
     1519  Variable x= Variable (1);
     1520  CanonicalForm powX, imBasis;
     1521  CFMatrix Mat, C;
     1522  CFArray buf;
     1523  CFIterator iter;
     1524  mat_zz_p* NTLMat, *NTLC, NTLK;
     1525  CFListIterator j;
    15171526  while (l <= liftBound)
    15181527  {
     
    15301539    }
    15311540
    1532     Variable y= F.mvar();
    1533     Variable x= Variable (1);
    1534 
    15351541    factors.insert (LCF);
    15361542
     
    15381544      setCharacteristic (getCharacteristic());
    15391545
    1540     CanonicalForm powX= power (y-gamma, l);
    1541     CFMatrix Mat= CFMatrix (l*degMipo, l*degMipo);
     1546    powX= power (y-gamma, l);
     1547    Mat= CFMatrix (l*degMipo, l*degMipo);
    15421548    for (int i= 0; i < l*degMipo; i++)
    15431549    {
    1544 
    1545       CanonicalForm imBasis= mod (power (y, i), powX);
     1550      imBasis= mod (power (y, i), powX);
    15461551      imBasis= imBasis (power (y, degMipo), y);
    15471552      imBasis= imBasis (y, gamma);
    1548       CFIterator iter= imBasis;
     1553      iter= imBasis;
    15491554      for (; iter.hasTerms(); iter++)
    15501555        Mat (iter.exp()+ 1, i+1)= iter.coeff();
    15511556    }
    15521557
    1553     mat_zz_p* NTLMat= convertFacCFMatrix2NTLmat_zz_p (Mat);
     1558    NTLMat= convertFacCFMatrix2NTLmat_zz_p (Mat);
    15541559    *NTLMat= inv (*NTLMat);
    15551560
     
    15571562      setCharacteristic (getCharacteristic(), degMipo, info.getGFName());
    15581563
    1559     CFListIterator j= factors;
     1564    j= factors;
    15601565    j++;
    15611566
     
    15741579        wasInBounds= true;
    15751580        int k= tmin (bounds [i] + 1, (l/2)*degMipo);
    1576         CFMatrix C= CFMatrix (l*degMipo - k, factors.length() - 1);
     1581        C= CFMatrix (l*degMipo - k, factors.length() - 1);
    15771582
    15781583        for (int ii= 0; ii < factors.length() - 1; ii++)
    15791584        {
    1580           CFArray buf;
    15811585          if (A[ii].size() - 1 >= i)
    15821586          {
     
    16101614          setCharacteristic(getCharacteristic());
    16111615
    1612         mat_zz_p* NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
    1613         mat_zz_p NTLK= (*NTLC)*NTLN;
     1616        NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
     1617        NTLK= (*NTLC)*NTLN;
    16141618        transpose (NTLK, NTLK);
    16151619        kernel (NTLK, NTLK);
     
    16741678  int oldL= l/2;
    16751679  bool reduced= false;
     1680  CFListIterator j;
     1681  mat_zz_pE* NTLC, NTLK;
     1682  CFArray buf;
     1683  CFMatrix C;
    16761684  while (l <= liftBound)
    16771685  {
     
    16901698
    16911699    factors.insert (LCF);
    1692     CFListIterator j= factors;
     1700    j= factors;
    16931701    j++;
    16941702
     
    17131721        wasInBounds= true;
    17141722        int k= tmin (bounds [i] + 1, l/2);
    1715         CFMatrix C= CFMatrix (l - k, factors.length() - 1);
     1723        C= CFMatrix (l - k, factors.length() - 1);
    17161724        for (int ii= 0; ii < factors.length() - 1; ii++)
    17171725        {
    1718           CFArray buf;
     1726
    17191727          if (A[ii].size() - 1 >= i)
    17201728            buf= getCoeffs (A[ii] [i], k);
     
    17221730        }
    17231731
    1724         mat_zz_pE* NTLC= convertFacCFMatrix2NTLmat_zz_pE(C);
    1725         mat_zz_pE NTLK= (*NTLC)*NTLN;
     1732        NTLC= convertFacCFMatrix2NTLmat_zz_pE(C);
     1733        NTLK= (*NTLC)*NTLN;
    17261734        transpose (NTLK, NTLK);
    17271735        kernel (NTLK, NTLK);
     
    17841792  int extensionDeg= degree (getMipo (alpha));
    17851793  bool reduced= false;
     1794  CFListIterator j;
     1795  CFMatrix C;
     1796  CFArray buf;
     1797  mat_zz_p* NTLC, NTLK;
    17861798  while (l <= liftBound)
    17871799  {
     
    18001812
    18011813    factors.insert (LCF);
    1802     CFListIterator j= factors;
     1814    j= factors;
    18031815    j++;
    18041816
     
    18231835        wasInBounds= true;
    18241836        int k= tmin (bounds [i] + 1, l/2);
    1825         CFMatrix C= CFMatrix ((l - k)*extensionDeg, factors.length() - 1);
     1837        C= CFMatrix ((l - k)*extensionDeg, factors.length() - 1);
    18261838        for (int ii= 0; ii < factors.length() - 1; ii++)
    18271839        {
    1828           CFArray buf;
    18291840          if (A[ii].size() - 1 >= i)
    18301841            buf= getCoeffs (A[ii] [i], k, alpha);
     
    18321843        }
    18331844
    1834         mat_zz_p* NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
    1835         mat_zz_p NTLK= (*NTLC)*NTLN;
     1845        NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
     1846        NTLK= (*NTLC)*NTLN;
    18361847        transpose (NTLK, NTLK);
    18371848        kernel (NTLK, NTLK);
     
    19001911  bool useOldQs= false;
    19011912  bool hitBound= false;
     1913  CFListIterator j;
     1914  CFMatrix C;
     1915  CFArray buf;
     1916  mat_zz_p* NTLC, NTLK;
    19021917  while (l <= precision)
    19031918  {
    1904     CFListIterator j= factors;
     1919    j= factors;
    19051920    if (useOldQs)
    19061921    {
     
    19211936      {
    19221937        int k= tmin (bounds [i] + 1, l/2);
    1923         CFMatrix C= CFMatrix (l - k, factors.length());
     1938        C= CFMatrix (l - k, factors.length());
    19241939        for (int ii= 0; ii < factors.length(); ii++)
    19251940        {
    1926           CFArray buf;
    19271941          if (A[ii].size() - 1 >= i)
    19281942            buf= getCoeffs (A[ii] [i], k);
    19291943          writeInMatrix (C, buf, ii + 1, 0);
    19301944        }
    1931         mat_zz_p* NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
    1932         mat_zz_p NTLK= (*NTLC)*NTLN;
     1945        NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
     1946        NTLK= (*NTLC)*NTLN;
    19331947        transpose (NTLK, NTLK);
    19341948        kernel (NTLK, NTLK);
     
    19601974                           factorsFoundIndex, NTLN, false
    19611975                          );
    1962         F= bufF;
    1963         if (result.length() > 0)
     1976        if (result.length() == NTLN.NumCols())
    19641977        {
    19651978          delete [] factorsFoundIndex;
     
    20252038  bool useOldQs= false;
    20262039  bool hitBound= false;
     2040  CFListIterator j;
     2041  CFMatrix C;
     2042  mat_zz_pE* NTLC, NTLK;
     2043  CFArray buf;
    20272044  while (l <= precision)
    20282045  {
    2029     CFListIterator j= factors;
     2046    j= factors;
    20302047    if (useOldQs)
    20312048    {
     
    20462063      {
    20472064        int k= tmin (bounds [i] + 1, l/2);
    2048         CFMatrix C= CFMatrix (l - k, factors.length());
     2065        C= CFMatrix (l - k, factors.length());
    20492066        for (int ii= 0; ii < factors.length(); ii++)
    20502067        {
    2051           CFArray buf;
    20522068          if (A[ii].size() - 1 >= i)
    20532069            buf= getCoeffs (A[ii] [i], k);
    20542070          writeInMatrix (C, buf, ii + 1, 0);
    20552071        }
    2056         mat_zz_pE* NTLC= convertFacCFMatrix2NTLmat_zz_pE(C);
    2057         mat_zz_pE NTLK= (*NTLC)*NTLN;
     2072        NTLC= convertFacCFMatrix2NTLmat_zz_pE(C);
     2073        NTLK= (*NTLC)*NTLN;
    20582074        transpose (NTLK, NTLK);
    20592075        kernel (NTLK, NTLK);
     
    21562172  CanonicalForm primElemAlpha= info.getGamma();
    21572173  CanonicalForm imPrimElemAlpha= info.getDelta();
     2174  CFListIterator j;
     2175  Variable y= F.mvar();
     2176  CanonicalForm powX, imBasis;
     2177  CFMatrix Mat, C;
     2178  CFIterator iter;
     2179  mat_zz_p* NTLMat,*NTLC, NTLK;
     2180  CFArray buf;
    21582181  while (l <= precision)
    21592182  {
    2160     CFListIterator j= factors;
     2183    j= factors;
    21612184    if (GF)
    21622185      setCharacteristic (getCharacteristic());
    2163     Variable y= F.mvar();
    2164     CanonicalForm powX= power (y-gamma, l);
    2165     CFMatrix Mat= CFMatrix (l*degMipo, l*degMipo);
     2186    powX= power (y-gamma, l);
     2187    Mat= CFMatrix (l*degMipo, l*degMipo);
    21662188    for (int i= 0; i < l*degMipo; i++)
    21672189    {
    2168 
    2169       CanonicalForm imBasis= mod (power (y, i), powX);
     2190      imBasis= mod (power (y, i), powX);
    21702191      imBasis= imBasis (power (y, degMipo), y);
    21712192      imBasis= imBasis (y, gamma);
    2172       CFIterator iter= imBasis;
     2193      iter= imBasis;
    21732194      for (; iter.hasTerms(); iter++)
    21742195          Mat (iter.exp()+ 1, i+1)= iter.coeff();
    21752196    }
    21762197
    2177     mat_zz_p* NTLMat= convertFacCFMatrix2NTLmat_zz_p (Mat);
     2198    NTLMat= convertFacCFMatrix2NTLmat_zz_p (Mat);
    21782199    *NTLMat= inv (*NTLMat);
    21792200    if (GF)
     
    21982219      {
    21992220        int k= tmin (bounds [i] + 1, (l/2)*degMipo);
    2200         CFMatrix C= CFMatrix (l*degMipo - k, factors.length());
     2221        C= CFMatrix (l*degMipo - k, factors.length());
    22012222        for (int ii= 0; ii < factors.length(); ii++)
    22022223        {
    2203           CFArray buf;
    22042224          if (A[ii].size() - 1 >= i)
    22052225          {
     
    22332253          setCharacteristic(getCharacteristic());
    22342254
    2235         mat_zz_p* NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
    2236         mat_zz_p NTLK= (*NTLC)*NTLN;
     2255        NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
     2256        NTLK= (*NTLC)*NTLN;
    22372257        transpose (NTLK, NTLK);
    22382258        kernel (NTLK, NTLK);
     
    22612281      if (isReduced (NTLN))
    22622282      {
    2263       int * factorsFoundIndex= new int [NTLN.NumCols()];
    2264       for (long i= 0; i < NTLN.NumCols(); i++)
    2265         factorsFoundIndex[i]= 0;
    2266       int factorsFound2= 0;
    2267       CFList result;
    2268       CanonicalForm bufF= F;
    2269       extReconstructionTry (result, bufF, factors, degree (F)+1, factorsFound2,
    2270                             factorsFoundIndex, NTLN, false, info, evaluation
    2271                            );
    2272       if (result.length() == NTLN.NumCols())
    2273       {
     2283        int * factorsFoundIndex= new int [NTLN.NumCols()];
     2284        for (long i= 0; i < NTLN.NumCols(); i++)
     2285          factorsFoundIndex[i]= 0;
     2286        int factorsFound2= 0;
     2287        CFList result;
     2288        CanonicalForm bufF= F;
     2289        extReconstructionTry (result, bufF, factors,degree (F)+1, factorsFound2,
     2290                              factorsFoundIndex, NTLN, false, info, evaluation
     2291                             );
     2292        if (result.length() == NTLN.NumCols())
     2293        {
     2294          delete [] factorsFoundIndex;
     2295          delete [] A;
     2296          delete [] bounds;
     2297          return result;
     2298        }
    22742299        delete [] factorsFoundIndex;
    2275         delete [] A;
    2276         delete [] bounds;
    2277         return result;
    2278       }
    2279       delete [] factorsFoundIndex;
    22802300      }
    22812301      else if (l == precision)
     
    23382358  bool hitBound= false;
    23392359  Variable y= Variable (2);
     2360  CFListIterator j;
     2361  CFMatrix C;
     2362  CFArray buf;
     2363  mat_zz_pE* NTLC, NTLK;
    23402364  while (l <= precision)
    23412365  {
    2342     CFListIterator j= factors;
     2366    j= factors;
    23432367    if (useOldQs)
    23442368    {
     
    23492373    {
    23502374      for (int i= 0; i < factors.length(); i++, j++)
    2351       {
    23522375        A[i]= logarithmicDerivative (F, j.getItem(), l, bufQ [i]);
    2353       }
    23542376    }
    23552377    useOldQs= true;
     
    23592381      {
    23602382        int k= tmin (bounds [i] + 1, l/2);
    2361         CFMatrix C= CFMatrix (l - k, factors.length());
     2383        C= CFMatrix (l - k, factors.length());
    23622384        for (int ii= 0; ii < factors.length(); ii++)
    23632385        {
    2364           CFArray buf;
    23652386          if (A[ii].size() - 1 >= i)
    23662387            buf= getCoeffs (A[ii] [i], k);
    23672388          writeInMatrix (C, buf, ii + 1, 0);
    23682389        }
    2369         mat_zz_pE* NTLC= convertFacCFMatrix2NTLmat_zz_pE(C);
    2370         mat_zz_pE NTLK= (*NTLC)*NTLN;
     2390        NTLC= convertFacCFMatrix2NTLmat_zz_pE(C);
     2391        NTLK= (*NTLC)*NTLN;
    23712392        transpose (NTLK, NTLK);
    23722393        kernel (NTLK, NTLK);
     
    24262447  return CFList();
    24272448}
    2428 
    24292449
    24302450CFList
     
    24532473  bool useOldQs= false;
    24542474  bool hitBound= false;
     2475  CFListIterator j;
     2476  CFMatrix C;
     2477  mat_zz_p* NTLC, NTLK;
     2478  CFArray buf;
    24552479  while (l <= precision)
    24562480  {
    2457     CFListIterator j= factors;
     2481    j= factors;
    24582482    if (useOldQs)
    24592483    {
     
    24742498      {
    24752499        int k= tmin (bounds [i] + 1, l/2);
    2476         CFMatrix C= CFMatrix ((l - k)*extensionDeg, factors.length());
     2500        C= CFMatrix ((l - k)*extensionDeg, factors.length());
    24772501        for (int ii= 0; ii < factors.length(); ii++)
    24782502        {
    2479           CFArray buf;
    24802503          if (A[ii].size() - 1 >= i)
    24812504            buf= getCoeffs (A[ii] [i], k, alpha);
    24822505          writeInMatrix (C, buf, ii + 1, 0);
    24832506        }
    2484         mat_zz_p* NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
    2485         mat_zz_p NTLK= (*NTLC)*NTLN;
     2507        NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
     2508        NTLK= (*NTLC)*NTLN;
    24862509        transpose (NTLK, NTLK);
    24872510        kernel (NTLK, NTLK);
     
    25672590  }
    25682591  bool useOldQs= false;
     2592  CFListIterator j;
     2593  CFMatrix C;
     2594  CFArray buf;
     2595  mat_zz_p* NTLC, NTLK;
     2596  CanonicalForm bufF;
     2597  CFList bufUniFactors;
    25692598  while (oldL <= l)
    25702599  {
    2571     CFListIterator j= factors;
     2600    j= factors;
    25722601    if (useOldQs)
    25732602    {
     
    25892618      {
    25902619        int k= tmin (bounds [i] + 1, oldL/2);
    2591         CFMatrix C= CFMatrix (oldL - k, factors.length());
     2620        C= CFMatrix (oldL - k, factors.length());
    25922621        for (int ii= 0; ii < factors.length(); ii++)
    25932622        {
    2594           CFArray buf;
    25952623          if (A[ii].size() - 1 >= i)
    25962624            buf= getCoeffs (A[ii] [i], k);
    25972625          writeInMatrix (C, buf, ii + 1, 0);
    25982626        }
    2599         mat_zz_p* NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
    2600         mat_zz_p NTLK= (*NTLC)*NTLN;
     2627        NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
     2628        NTLK= (*NTLC)*NTLN;
    26012629        transpose (NTLK, NTLK);
    26022630        kernel (NTLK, NTLK);
     
    26192647    int * zeroOneVecs;
    26202648    zeroOneVecs= extractZeroOneVecs (NTLN);
    2621     CanonicalForm bufF= F;
    2622     CFList bufUniFactors= factors;
     2649    bufF= F;
     2650    bufUniFactors= factors;
    26232651    result= reconstruction (bufF, bufUniFactors, zeroOneVecs, oldL, NTLN);
    26242652    delete [] zeroOneVecs;
     
    26622690  if (NTLN.NumRows() != factors.length()) //refined factors
    26632691    ident (NTLN, factors.length());
     2692  CFListIterator j;
     2693  CFMatrix C;
     2694  CFArray buf;
     2695  mat_zz_pE* NTLC, NTLK;
     2696  CanonicalForm bufF;
     2697  CFList bufUniFactors;
    26642698  while (oldL <= l)
    26652699  {
    2666     CFListIterator j= factors;
     2700    j= factors;
    26672701    if (useOldQs)
    26682702    {
     
    26842718      {
    26852719        int k= tmin (bounds [i] + 1, oldL/2);
    2686         CFMatrix C= CFMatrix (oldL - k, factors.length());
     2720        C= CFMatrix (oldL - k, factors.length());
    26872721        for (int ii= 0; ii < factors.length(); ii++)
    26882722        {
    2689           CFArray buf;
    26902723          if (A[ii].size() - 1 >= i)
    26912724            buf= getCoeffs (A[ii] [i], k);
    26922725          writeInMatrix (C, buf, ii + 1, 0);
    26932726        }
    2694         mat_zz_pE* NTLC= convertFacCFMatrix2NTLmat_zz_pE(C);
    2695         mat_zz_pE NTLK= (*NTLC)*NTLN;
     2727        NTLC= convertFacCFMatrix2NTLmat_zz_pE(C);
     2728        NTLK= (*NTLC)*NTLN;
    26962729        transpose (NTLK, NTLK);
    26972730        kernel (NTLK, NTLK);
     
    27152748    int * zeroOneVecs;
    27162749    zeroOneVecs= extractZeroOneVecs (NTLN);
    2717     CanonicalForm bufF= F;
    2718     CFList bufUniFactors= factors;
     2750    bufF= F;
     2751    bufUniFactors= factors;
    27192752    result= reconstruction (bufF, bufUniFactors, zeroOneVecs, oldL, NTLN);
    27202753    delete [] zeroOneVecs;
     
    27682801  if (NTLN.NumRows() != factors.length()) //refined factors
    27692802    ident (NTLN, factors.length());
     2803  Variable y= F.mvar();
     2804  CFListIterator j;
     2805  CanonicalForm powX, imBasis, bufF;
     2806  CFMatrix Mat, C;
     2807  CFIterator iter;
     2808  mat_zz_p* NTLMat;
     2809  CFArray buf;
     2810  mat_zz_p* NTLC, NTLK;
     2811  CFList bufUniFactors;
    27702812  while (oldL <= l)
    27712813  {
    2772     CFListIterator j= factors;
     2814    j= factors;
    27732815    if (GF)
    27742816      setCharacteristic (getCharacteristic());
    2775     Variable y= F.mvar();
    2776     CanonicalForm powX= power (y-gamma, oldL);
    2777     CFMatrix Mat= CFMatrix (oldL*degMipo, oldL*degMipo);
     2817
     2818    powX= power (y-gamma, oldL);
     2819    Mat= CFMatrix (oldL*degMipo, oldL*degMipo);
    27782820    for (int i= 0; i < oldL*degMipo; i++)
    27792821    {
    2780 
    2781       CanonicalForm imBasis= mod (power (y, i), powX);
     2822      imBasis= mod (power (y, i), powX);
    27822823      imBasis= imBasis (power (y, degMipo), y);
    27832824      imBasis= imBasis (y, gamma);
    2784       CFIterator iter= imBasis;
     2825      iter= imBasis;
    27852826      for (; iter.hasTerms(); iter++)
    27862827        Mat (iter.exp()+ 1, i+1)= iter.coeff();
    27872828    }
    27882829
    2789     mat_zz_p* NTLMat= convertFacCFMatrix2NTLmat_zz_p (Mat);
     2830    NTLMat= convertFacCFMatrix2NTLmat_zz_p (Mat);
    27902831    *NTLMat= inv (*NTLMat);
    27912832    if (GF)
     
    28102851      {
    28112852        int k= tmin (bounds [i] + 1, oldL/2);
    2812         CFMatrix C= CFMatrix (oldL*degMipo - k, factors.length());
     2853        C= CFMatrix (oldL*degMipo - k, factors.length());
    28132854        for (int ii= 0; ii < factors.length(); ii++)
    28142855        {
    2815           CFArray buf;
    28162856          if (A[ii].size() - 1 >= i)
    28172857          {
     
    28452885          setCharacteristic(getCharacteristic());
    28462886
    2847         mat_zz_p* NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
    2848         mat_zz_p NTLK= (*NTLC)*NTLN;
     2887        NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
     2888        NTLK= (*NTLC)*NTLN;
    28492889        transpose (NTLK, NTLK);
    28502890        kernel (NTLK, NTLK);
     
    28802920    int * zeroOneVecs;
    28812921    zeroOneVecs= extractZeroOneVecs (NTLN);
    2882     CanonicalForm bufF= F;
    2883     CFList bufUniFactors= factors;
     2922    bufF= F;
     2923    bufUniFactors= factors;
    28842924    result= extReconstruction (bufF, bufUniFactors, zeroOneVecs, oldL, NTLN,
    28852925                               info, evaluation
     
    28932933    }
    28942934
    2895     if (isReduced (NTLN))
    2896     {
    2897       int factorsFound= 0;
    2898       CanonicalForm bufF= F;
    2899       int* factorsFoundIndex= new int [NTLN.NumCols()];
    2900       for (long i= 0; i < NTLN.NumCols(); i++)
    2901         factorsFoundIndex[i]= 0;
    2902       extReconstructionTry (result, bufF, factors, l, factorsFound,
    2903                             factorsFoundIndex, NTLN, false, info, evaluation
    2904                            );
    2905       if (NTLN.NumCols() == result.length())
    2906       {
    2907         delete [] A;
    2908         delete [] factorsFoundIndex;
    2909         return result;
    2910       }
    2911     }
    29122935    result= CFList();
    29132936    oldL2= oldL;
     
    29422965  bool useOldQs= false;
    29432966  if (NTLN.NumRows() != factors.length()) //refined factors
    2944   {
    2945     int minBound= bounds [0];
    2946     for (int i= 1; i < d; i++)
    2947     {
    2948       if (bounds [i] != 0)
    2949         minBound= tmin (minBound, bounds [i]);
    2950     }
    2951     oldL= 2*(minBound+1);
    2952     oldL2= minBound + 1;
    29532967    ident (NTLN, factors.length());
    2954   }
     2968  CFListIterator j;
     2969  CFMatrix C;
     2970  CFArray buf;
     2971  mat_zz_p* NTLC, NTLK;
     2972  CanonicalForm bufF;
     2973  CFList bufUniFactors;
    29552974  while (oldL <= l)
    29562975  {
    2957     CFListIterator j= factors;
     2976    j= factors;
    29582977    if (useOldQs)
    29592978    {
     
    29752994      {
    29762995        int k= tmin (bounds [i] + 1, oldL/2);
    2977         CFMatrix C= CFMatrix ((oldL - k)*extensionDeg, factors.length());
     2996        C= CFMatrix ((oldL - k)*extensionDeg, factors.length());
    29782997        for (int ii= 0; ii < factors.length(); ii++)
    29792998        {
    2980           CFArray buf;
    29812999          if (A[ii].size() - 1 >= i)
    29823000            buf= getCoeffs (A[ii] [i], k, alpha);
    29833001          writeInMatrix (C, buf, ii + 1, 0);
    29843002        }
    2985         mat_zz_p* NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
    2986         mat_zz_p NTLK= (*NTLC)*NTLN;
     3003        NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
     3004        NTLK= (*NTLC)*NTLN;
    29873005        transpose (NTLK, NTLK);
    29883006        kernel (NTLK, NTLK);
     
    30013019    zeroOneVecs= extractZeroOneVecs (NTLN);
    30023020
    3003     CanonicalForm bufF= F;
    3004     CFList bufUniFactors= factors;
     3021    bufF= F;
     3022    bufUniFactors= factors;
    30053023    result= reconstruction (bufF, bufUniFactors, zeroOneVecs, oldL, NTLN);
    30063024    delete [] zeroOneVecs;
     
    30503068  if (NTLN.NumRows() != factors.length()) //refined factors
    30513069    ident (NTLN, factors.length());
     3070  CFListIterator j;
     3071  CFMatrix C;
     3072  CFArray buf;
     3073  mat_zz_p* NTLC, NTLK;
     3074  CanonicalForm bufF;
    30523075  while (l <= liftBound)
    30533076  {
     
    30563079    bufFactors.insert (LCF);
    30573080    bufFactors.removeFirst();
    3058     CFListIterator j= bufFactors;
     3081    j= bufFactors;
    30593082    if (useOldQs)
    30603083    {
     
    30723095      {
    30733096        int k= tmin (bounds [i] + 1, l/2);
    3074         CFMatrix C= CFMatrix (l - k, bufFactors.length());
     3097        C= CFMatrix (l - k, bufFactors.length());
    30753098        for (int ii= 0; ii < bufFactors.length(); ii++)
    30763099        {
    3077           CFArray buf;
    30783100          if (A[ii].size() - 1 >= i)
    30793101            buf= getCoeffs (A[ii] [i], k);
    30803102          writeInMatrix (C, buf, ii + 1, 0);
    30813103        }
    3082         mat_zz_p* NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
    3083         mat_zz_p NTLK= (*NTLC)*NTLN;
     3104        NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
     3105        NTLK= (*NTLC)*NTLN;
    30843106        transpose (NTLK, NTLK);
    30853107        kernel (NTLK, NTLK);
     
    31013123
    31023124    int * zeroOneVecs= extractZeroOneVecs (NTLN);
    3103     CanonicalForm bufF= F;
     3125    bufF= F;
    31043126    result= reconstruction (bufF, bufFactors, zeroOneVecs, l, NTLN);
    31053127    delete [] zeroOneVecs;
     
    31153137    {
    31163138      int factorsFound= 0;
    3117       CanonicalForm bufF= F;
     3139      bufF= F;
    31183140      int* factorsFoundIndex= new int [NTLN.NumCols()];
    31193141      for (long i= 0; i < NTLN.NumCols(); i++)
     
    31823204  if (NTLN.NumRows() != factors.length()) //refined factors
    31833205    ident (NTLN, factors.length());
     3206  CFListIterator j;
     3207  CFArray buf;
     3208  mat_zz_pE* NTLC, NTLK;
     3209  CanonicalForm bufF;
    31843210  while (l <= liftBound)
    31853211  {
    31863212    bufFactors.insert (LCF);
    31873213    henselLiftResume12 (F, bufFactors, oldL, l, Pi, diophant, M);
    3188     CFListIterator j= bufFactors;
     3214    j= bufFactors;
    31893215    if (useOldQs)
    31903216    {
     
    32053231        for (int ii= 0; ii < bufFactors.length(); ii++)
    32063232        {
    3207           CFArray buf;
    32083233          if (A[ii].size() - 1 >= i)
    32093234            buf= getCoeffs (A[ii] [i], k);
    32103235          writeInMatrix (C, buf, ii + 1, 0);
    32113236        }
    3212         mat_zz_pE* NTLC= convertFacCFMatrix2NTLmat_zz_pE(C);
    3213         mat_zz_pE NTLK= (*NTLC)*NTLN;
     3237        NTLC= convertFacCFMatrix2NTLmat_zz_pE(C);
     3238        NTLK= (*NTLC)*NTLN;
    32143239        transpose (NTLK, NTLK);
    32153240        kernel (NTLK, NTLK);
     
    32293254    }
    32303255
    3231       int * zeroOneVecs= extractZeroOneVecs (NTLN);
    3232       CanonicalForm bufF= F;
    3233       result= reconstruction (bufF, bufFactors, zeroOneVecs, l, NTLN);
    3234       delete [] zeroOneVecs;
    3235       if (result.length() > 0 && degree (bufF) + 1 + degree (LC (bufF, 1)) <= l)
    3236       {
    3237         F= bufF;
    3238         factors= bufFactors;
    3239         delete [] A;
    3240         return result;
    3241       }
     3256    int * zeroOneVecs= extractZeroOneVecs (NTLN);
     3257    bufF= F;
     3258    result= reconstruction (bufF, bufFactors, zeroOneVecs, l, NTLN);
     3259    delete [] zeroOneVecs;
     3260    if (result.length() > 0 && degree (bufF) + 1 + degree (LC (bufF, 1)) <= l)
     3261    {
     3262      F= bufF;
     3263      factors= bufFactors;
     3264      delete [] A;
     3265      return result;
     3266    }
    32423267
    32433268    if (isReduced (NTLN))
    32443269    {
    32453270      int factorsFound= 0;
    3246       CanonicalForm bufF= F;
     3271      bufF= F;
    32473272      int* factorsFoundIndex= new int [NTLN.NumCols()];
    32483273      for (long i= 0; i < NTLN.NumCols(); i++)
     
    33193344  if (NTLN.NumRows() != factors.length()) //refined factors
    33203345    ident (NTLN, factors.length());
     3346  Variable y= F.mvar();
     3347  CanonicalForm powX, imBasis, bufF;
     3348  CFMatrix Mat, C;
     3349  CFIterator iter;
     3350  mat_zz_p* NTLMat,*NTLC, NTLK;
     3351  CFListIterator j;
     3352  CFArray buf;
    33213353  while (l <= liftBound)
    33223354  {
     
    33273359      setCharacteristic (getCharacteristic());
    33283360
    3329     Variable y= F.mvar();
    3330     CanonicalForm powX= power (y-gamma, l);
    3331     CFMatrix Mat= CFMatrix (l*degMipo, l*degMipo);
     3361    powX= power (y-gamma, l);
     3362    Mat= CFMatrix (l*degMipo, l*degMipo);
    33323363    for (int i= 0; i < l*degMipo; i++)
    33333364    {
    33343365
    3335       CanonicalForm imBasis= mod (power (y, i), powX);
     3366      imBasis= mod (power (y, i), powX);
    33363367      imBasis= imBasis (power (y, degMipo), y);
    33373368      imBasis= imBasis (y, gamma);
    3338       CFIterator iter= imBasis;
     3369      iter= imBasis;
    33393370      for (; iter.hasTerms(); iter++)
    33403371        Mat (iter.exp()+ 1, i+1)= iter.coeff();
    33413372    }
    33423373
    3343     mat_zz_p* NTLMat= convertFacCFMatrix2NTLmat_zz_p (Mat);
     3374    NTLMat= convertFacCFMatrix2NTLmat_zz_p (Mat);
    33443375    *NTLMat= inv (*NTLMat);
    33453376
     
    33473378      setCharacteristic (getCharacteristic(), degMipo, info.getGFName());
    33483379
    3349     CFListIterator j= bufFactors;
     3380    j= bufFactors;
    33503381    if (useOldQs)
    33513382    {
     
    33633394      {
    33643395        int k= tmin (bounds [i] + 1, l/2);
    3365         CFMatrix C= CFMatrix (l*degMipo - k, bufFactors.length());
     3396        C= CFMatrix (l*degMipo - k, bufFactors.length());
    33663397        for (int ii= 0; ii < bufFactors.length(); ii++)
    33673398        {
    3368           CFArray buf;
    33693399          if (A[ii].size() - 1 >= i)
    33703400          {
     
    33973427        if (GF)
    33983428          setCharacteristic(getCharacteristic());
    3399         mat_zz_p* NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
    3400         mat_zz_p NTLK= (*NTLC)*NTLN;
     3429        NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
     3430        NTLK= (*NTLC)*NTLN;
    34013431        transpose (NTLK, NTLK);
    34023432        kernel (NTLK, NTLK);
     
    34193449    }
    34203450
    3421       int * zeroOneVecs= extractZeroOneVecs (NTLN);
    3422       CanonicalForm bufF= F;
    3423       result= extReconstruction (bufF, bufFactors, zeroOneVecs, l, NTLN, info,
    3424                                  evaluation
    3425                                 );
    3426       delete [] zeroOneVecs;
    3427       if (result.length() > 0 && degree (bufF) + 1 + degree (LC (bufF, 1)) <= l)
    3428       {
    3429         F= bufF;
    3430         factors= bufFactors;
    3431         delete [] A;
    3432         return result;
    3433       }
     3451    int * zeroOneVecs= extractZeroOneVecs (NTLN);
     3452    bufF= F;
     3453    result= extReconstruction (bufF, bufFactors, zeroOneVecs, l, NTLN, info,
     3454                               evaluation
     3455                              );
     3456    delete [] zeroOneVecs;
     3457    if (result.length() > 0 && degree (bufF) + 1 + degree (LC (bufF, 1)) <= l)
     3458    {
     3459      F= bufF;
     3460      factors= bufFactors;
     3461      delete [] A;
     3462      return result;
     3463    }
    34343464
    34353465    if (isReduced (NTLN))
    34363466    {
    34373467      int factorsFound= 0;
    3438       CanonicalForm bufF= F;
     3468      bufF= F;
    34393469      int* factorsFoundIndex= new int [NTLN.NumCols()];
    34403470      for (long i= 0; i < NTLN.NumCols(); i++)
     
    35073537  if (NTLN.NumRows() != factors.length()) //refined factors
    35083538    ident (NTLN, factors.length());
     3539  CFListIterator j;
     3540  CFMatrix C;
     3541  mat_zz_p* NTLC, NTLK;
     3542  CanonicalForm bufF;
    35093543  while (l <= liftBound)
    35103544  {
    35113545    bufFactors.insert (LCF);
    35123546    henselLiftResume12 (F, bufFactors, oldL, l, Pi, diophant, M);
    3513     CFListIterator j= bufFactors;
     3547    j= bufFactors;
    35143548    if (useOldQs)
    35153549    {
     
    35273561      {
    35283562        int k= tmin (bounds [i] + 1, l/2);
    3529         CFMatrix C= CFMatrix ((l - k)*extensionDeg, bufFactors.length());
     3563        C= CFMatrix ((l - k)*extensionDeg, bufFactors.length());
    35303564        for (int ii= 0; ii < bufFactors.length(); ii++)
    35313565        {
     
    35353569          writeInMatrix (C, buf, ii + 1, 0);
    35363570        }
    3537         mat_zz_p* NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
    3538         mat_zz_p NTLK= (*NTLC)*NTLN;
     3571        NTLC= convertFacCFMatrix2NTLmat_zz_p(C);
     3572        NTLK= (*NTLC)*NTLN;
    35393573        transpose (NTLK, NTLK);
    35403574        kernel (NTLK, NTLK);
     
    35543588    }
    35553589
    3556       int * zeroOneVecs= extractZeroOneVecs (NTLN);
    3557       CanonicalForm bufF= F;
    3558       result= reconstruction (bufF, bufFactors, zeroOneVecs, l, NTLN);
    3559       delete [] zeroOneVecs;
    3560       if (result.length() > 0 && degree (bufF) + 1 + degree (LC (bufF, 1)) <= l)
    3561       {
    3562         F= bufF;
    3563         factors= bufFactors;
    3564         delete [] A;
    3565         return result;
    3566       }
     3590    int * zeroOneVecs= extractZeroOneVecs (NTLN);
     3591    CanonicalForm bufF= F;
     3592    result= reconstruction (bufF, bufFactors, zeroOneVecs, l, NTLN);
     3593    delete [] zeroOneVecs;
     3594    if (result.length() > 0 && degree (bufF) + 1 + degree (LC (bufF, 1)) <= l)
     3595    {
     3596      F= bufF;
     3597      factors= bufFactors;
     3598      delete [] A;
     3599      return result;
     3600    }
    35673601
    35683602    if (isReduced (NTLN))
    35693603    {
    35703604      int factorsFound= 0;
    3571       CanonicalForm bufF= F;
     3605      bufF= F;
    35723606      int* factorsFoundIndex= new int [NTLN.NumCols()];
    35733607      for (long i= 0; i < NTLN.NumCols(); i++)
     
    36243658  Variable y= Variable (2);
    36253659  CanonicalForm LCF= LC (F, 1);
     3660  CFListIterator iter;
     3661  CanonicalForm buf;
    36263662  for (long i= 1; i <= NTLN.NumCols(); i++)
    36273663  {
    3628     CFListIterator iter= factors;
    3629     CanonicalForm buf= 1;
     3664    iter= factors;
     3665    buf= 1;
    36303666    for (long j= 1; j <= NTLN.NumRows(); j++, iter++)
    36313667    {
     
    36523688  Variable y= Variable (2);
    36533689  CanonicalForm LCF= LC (F, 1);
     3690  CFListIterator iter;
     3691  CanonicalForm buf;
    36543692  for (long i= 1; i <= NTLN.NumCols(); i++)
    36553693  {
    3656     CFListIterator iter= factors;
    3657     CanonicalForm buf= 1;
     3694    iter= factors;
     3695    buf= 1;
    36583696    for (long j= 1; j <= NTLN.NumRows(); j++, iter++)
    36593697    {
     
    40364074
    40374075  int index;
     4076  CanonicalForm tmp1, tmp2;
    40384077  for (CFListIterator i= smallFactors; i.hasItem(); i++)
    40394078  {
    40404079    index= 1;
    4041     CanonicalForm tmp1, tmp2;
    40424080    tmp1= mod (i.getItem(),y);
    40434081    tmp1 /= Lc (tmp1);
     
    43334371    if (beenInThres)
    43344372    {
    4335     int index;
    4336     for (CFListIterator i= result; i.hasItem(); i++)
    4337     {
    4338       index= 1;
    4339       CanonicalForm tmp1, tmp2;
    4340       tmp1= mod (i.getItem(), y);
    4341       tmp1 /= Lc (tmp1);
    4342       for (CFListIterator j= bufUniFactors; j.hasItem(); j++, index++)
    4343       {
    4344         tmp2= mod (j.getItem(), y);
    4345         tmp2 /= Lc (tmp2);
    4346         if (tmp1 == tmp2)
    4347         {
    4348           index++;
    4349           j.remove(index);
    4350           break;
    4351         }
    4352       }
    4353     }
     4373      int index;
     4374      for (CFListIterator i= result; i.hasItem(); i++)
     4375      {
     4376        index= 1;
     4377        tmp1= mod (i.getItem(), y);
     4378        tmp1 /= Lc (tmp1);
     4379        for (CFListIterator j= bufUniFactors; j.hasItem(); j++, index++)
     4380        {
     4381          tmp2= mod (j.getItem(), y);
     4382          tmp2 /= Lc (tmp2);
     4383          if (tmp1 == tmp2)
     4384          {
     4385            index++;
     4386            j.remove(index);
     4387            break;
     4388          }
     4389        }
     4390      }
    43544391    }
    43554392    else
    43564393    {
    4357     int * zeroOne= extractZeroOneVecs (NTLN);
    4358     CFList bufBufUniFactors= bufUniFactors;
    4359     for (int i= 0; i < NTLN.NumCols(); i++)
    4360     {
    4361       if (zeroOne [i] == 0)
    4362         continue;
    4363       CFListIterator iter= bufUniFactors;
    4364       CanonicalForm buf= 1;
     4394      int * zeroOne= extractZeroOneVecs (NTLN);
     4395      CFList bufBufUniFactors= bufUniFactors;
     4396      CFListIterator iter, iter2;
     4397      CanonicalForm buf;
    43654398      CFList factorsConsidered;
    4366       for (int j= 0; j < NTLN.NumRows(); j++, iter++)
    4367       {
    4368         if (!IsZero (NTLN (j + 1,i + 1)))
    4369         {
    4370           factorsConsidered.append (iter.getItem());
    4371           buf *= mod (iter.getItem(), y);
    4372         }
    4373       }
    4374       buf /= Lc (buf);
    4375       for (CFListIterator iter2= result; iter2.hasItem(); iter2++)
    4376       {
    4377         CanonicalForm tmp= mod (iter2.getItem(), y);
    4378         tmp /= Lc (tmp);
    4379         if (tmp == buf)
    4380         {
    4381           bufBufUniFactors= Difference (bufBufUniFactors, factorsConsidered);
    4382           break;
    4383         }
    4384       }
    4385     }
    4386     bufUniFactors= bufBufUniFactors;
    4387     delete [] zeroOne;
     4399      CanonicalForm tmp;
     4400      for (int i= 0; i < NTLN.NumCols(); i++)
     4401      {
     4402        if (zeroOne [i] == 0)
     4403          continue;
     4404        iter= bufUniFactors;
     4405        buf= 1;
     4406        factorsConsidered= CFList();
     4407        for (int j= 0; j < NTLN.NumRows(); j++, iter++)
     4408        {
     4409          if (!IsZero (NTLN (j + 1,i + 1)))
     4410          {
     4411            factorsConsidered.append (iter.getItem());
     4412            buf *= mod (iter.getItem(), y);
     4413          }
     4414        }
     4415        buf /= Lc (buf);
     4416        for (iter2= result; iter2.hasItem(); iter2++)
     4417        {
     4418          tmp= mod (iter2.getItem(), y);
     4419          tmp /= Lc (tmp);
     4420          if (tmp == buf)
     4421          {
     4422            bufBufUniFactors= Difference (bufBufUniFactors, factorsConsidered);
     4423            break;
     4424          }
     4425        }
     4426      }
     4427      bufUniFactors= bufBufUniFactors;
     4428      delete [] zeroOne;
    43884429    }
    43894430
     
    46894730
    46904731  int index;
     4732  CanonicalForm tmp1, tmp2;
    46914733  for (CFListIterator i= smallFactors; i.hasItem(); i++)
    46924734  {
    46934735    index= 1;
    4694     CanonicalForm tmp1, tmp2;
    46954736    tmp1= mod (i.getItem(), y - evaluation);
    46964737    tmp1 /= Lc (tmp1);
     
    48284869  {
    48294870    int * factorsFoundIndex;
    4830       factorsFoundIndex= new int [NTLN.NumCols()];
    4831       for (long i= 0; i < NTLN.NumCols(); i++)
    4832         factorsFoundIndex[i]= 0;
     4871    factorsFoundIndex= new int [NTLN.NumCols()];
     4872    for (long i= 0; i < NTLN.NumCols(); i++)
     4873      factorsFoundIndex[i]= 0;
    48334874    CanonicalForm bufF= F;
    48344875    int factorsFound= 0;
     
    48824923      {
    48834924        index= 1;
    4884         CanonicalForm tmp1, tmp2;
    48854925        tmp1= mod (i.getItem(), y-evaluation);
    48864926        tmp1 /= Lc (tmp1);
     
    49024942      int * zeroOne= extractZeroOneVecs (NTLN);
    49034943      CFList bufBufUniFactors= bufUniFactors;
     4944      CFListIterator iter, iter2;
     4945      CanonicalForm buf;
     4946      CFList factorsConsidered;
    49044947      for (int i= 0; i < NTLN.NumCols(); i++)
    49054948      {
    49064949        if (zeroOne [i] == 0)
    49074950          continue;
    4908         CFListIterator iter= bufUniFactors;
    4909         CanonicalForm buf= 1;
    4910         CFList factorsConsidered;
     4951        iter= bufUniFactors;
     4952        buf= 1;
     4953        factorsConsidered= CFList();
    49114954        for (int j= 0; j < NTLN.NumRows(); j++, iter++)
    49124955        {
     
    49184961        }
    49194962        buf /= Lc (buf);
    4920         for (CFListIterator iter2= result; iter2.hasItem(); iter2++)
     4963        for (iter2= result; iter2.hasItem(); iter2++)
    49214964        {
    49224965          CanonicalForm tmp= mod (iter2.getItem(), y - evaluation);
  • factory/facFqFactorize.cc

    r0349c20 r38ffb7  
    11711171  CFList result;
    11721172
     1173  CanonicalForm tmp;
    11731174  for (CFListIterator i= factors; i.hasItem(); i++)
    11741175  {
    1175     CanonicalForm tmp= i.getItem();
     1176    tmp= i.getItem();
    11761177    tmp= mulMod (tmp, LCBuf, M);
    11771178    tmp= tmp/content (tmp, 1);
     
    11971198  int n= 1;
    11981199  int m;
    1199   for (CFFListIterator i= factors1; (i.hasItem() && n < k); i++, n++)
     1200  CFFListIterator j;
     1201  for (CFFListIterator i= factors1; (n < k && i.hasItem()); i++, n++)
    12001202  {
    12011203    m= 1;
    1202     for (CFFListIterator j= factors2; (j.hasItem() && m < l); j++, m++)
    1203     {
    1204       CanonicalForm g= gcd (i.getItem().factor(), j.getItem().factor());
     1204    for (j= factors2; (m < l && j.hasItem()); j++, m++)
     1205    {
     1206      g= gcd (i.getItem().factor(), j.getItem().factor());
    12051207      if (degree (g) > 0)
    12061208      {
     
    12531255  }
    12541256
     1257  Variable v;
     1258  CFListIterator iter1;
     1259  CanonicalForm tmp, g;
    12551260  for (int i= 0; i < length; i++)
    12561261  {
    12571262    if (differentSecondVarFactors[i].isEmpty())
    12581263      continue;
    1259     CFListIterator iter1= l;
     1264    iter1= l;
    12601265    iter1++;
    12611266
    1262     Variable v= Variable (i + 3);
     1267    v= Variable (i + 3);
    12631268    for (CFListIterator iter2= differentSecondVarFactors[i]; iter2.hasItem();
    12641269         iter2++, iter1++)
     
    12661271      if (degree (iter2.getItem(),v) == degree (iter1.getItem(),v))
    12671272        continue;
    1268       CanonicalForm tmp= iter1.getItem();
     1273      tmp= iter1.getItem();
    12691274      for (int j= tmp.level(); j > 1; j--)
    12701275      {
     
    12731278        tmp= tmp (0, j);
    12741279      }
    1275       CanonicalForm g= gcd (iter2.getItem(), content);
     1280      g= gcd (iter2.getItem(), content);
    12761281      if (degree (g) > 0)
    12771282      {
     
    13061311             CFFList*& bufSqrfFactors, CFList& evalSqrfPartF)
    13071312{
     1313  CanonicalForm tmp;
     1314  CFListIterator j;
    13081315  for (CFListIterator i= uniFactors; i.hasItem(); i++)
    13091316  {
    1310     CanonicalForm tmp= i.getItem();
     1317    tmp= i.getItem();
    13111318    if (i.hasItem())
    13121319      i++;
    13131320    else
    13141321      break;
    1315     for (CFListIterator j= i; j.hasItem(); j++)
     1322    for (j= i; j.hasItem(); j++)
    13161323    {
    13171324      if (tmp == j.getItem())
     
    13381345  int k= 0;
    13391346  factors= uniFactors;
     1347  CFFListIterator iter;
    13401348  for (CFListIterator i= factors; i.hasItem(); i++, k++)
    13411349  {
    1342     CanonicalForm tmp= 1;
     1350    tmp= 1;
    13431351    sqrfFactors= squarefreeFactorization (i.getItem(), alpha);
    13441352
    1345     for (CFFListIterator j= sqrfFactors; j.hasItem(); j++)
    1346     {
    1347       tmp2.append (j.getItem().factor());
    1348       tmp *= j.getItem().factor();
     1353    for (iter= sqrfFactors; iter.hasItem(); iter++)
     1354    {
     1355      tmp2.append (iter.getItem().factor());
     1356      tmp *= iter.getItem().factor();
    13491357    }
    13501358    i.getItem()= tmp/Lc(tmp);
     
    13541362  for (int i= 0; i < factors.length() - 1; i++)
    13551363  {
    1356     for (int k= i + 1; k < factors.length(); k++)
     1364    for (k= i + 1; k < factors.length(); k++)
    13571365    {
    13581366      gcdFreeBasis (bufSqrfFactors [i], bufSqrfFactors[k]);
     
    13651373    if (i == 0)
    13661374    {
    1367       for (CFFListIterator k= bufSqrfFactors [i]; k.hasItem(); k++)
    1368       {
    1369         k.getItem()= CFFactor (k.getItem().factor()/Lc (k.getItem().factor()),
    1370                                k.getItem().exp());
    1371         factors.append (k.getItem().factor());
     1375      for (iter= bufSqrfFactors [i]; iter.hasItem(); iter++)
     1376      {
     1377        iter.getItem()= CFFactor (iter.getItem().factor()/
     1378                                  Lc (iter.getItem().factor()),
     1379                                  iter.getItem().exp());
     1380        factors.append (iter.getItem().factor());
    13721381      }
    13731382    }
    13741383    else
    13751384    {
    1376       for (CFFListIterator k= bufSqrfFactors [i]; k.hasItem(); k++)
    1377       {
    1378         k.getItem()= CFFactor (k.getItem().factor()/Lc (k.getItem().factor()),
    1379                                k.getItem().exp());
    1380         if (!find (factors, k.getItem().factor()))
    1381           factors.append (k.getItem().factor());
     1385      for (iter= bufSqrfFactors [i]; iter.hasItem(); iter++)
     1386      {
     1387        iter.getItem()= CFFactor (iter.getItem().factor()/
     1388                                  Lc (iter.getItem().factor()),
     1389                                  iter.getItem().exp());
     1390        if (!find (factors, iter.getItem().factor()))
     1391          factors.append (iter.getItem().factor());
    13821392      }
    13831393    }
     
    13851395
    13861396  test= prod (factors);
    1387   CanonicalForm tmp= evalSqrfPartF.getFirst() (0,2);
     1397  tmp= evalSqrfPartF.getFirst() (0,2);
    13881398  if (test/Lc (test) != tmp/Lc (tmp))
    13891399    return 0;
     
    14301440    else
    14311441    {
     1442      CFListIterator j;
    14321443      for (int i= 0; i < length; i++)
    14331444      {
    1434         for (CFListIterator j= differentSecondVarLCs[i]; j.hasItem(); j++)
     1445        for (j= differentSecondVarLCs[i]; j.hasItem(); j++)
    14351446        {
    14361447          if (j.getItem().level() == LCFLevel)
     
    14681479  CFFList * bufSqrfFactors= new CFFList [factors.length()];
    14691480  CFList evalSqrfPartF;
    1470   CanonicalForm bufContent;
    14711481  CFList bufFactors;
    14721482  int pass= testFactors (F, factors, alpha, sqrfPartF,
     
    14891499      }
    14901500    }
     1501    CFListIterator iter;
     1502    CFList bufBufFactors;
     1503    CanonicalForm bufF;
    14911504    for (int i= 0; i < length; i++)
    14921505    {
     
    14941507      {
    14951508        bool allConstant= true;
    1496         for (CFListIterator iter= differentSecondVarLCs[i]; iter.hasItem();
    1497              iter++)
     1509        for (iter= differentSecondVarLCs[i]; iter.hasItem(); iter++)
    14981510        {
    14991511          if (!iter.getItem().inCoeffDomain())
     
    15071519
    15081520        bufFactors= differentSecondVarLCs [i];
    1509         for (CFListIterator iter= bufFactors; iter.hasItem(); iter++)
     1521        for (iter= bufFactors; iter.hasItem(); iter++)
    15101522          iter.getItem()= swapvar (iter.getItem(), x, y);
    1511         CanonicalForm bufF= F;
     1523        bufF= F;
    15121524        z= Variable (y.level() - lev);
    15131525        bufF= swapvar (bufF, x, z);
    1514         CFList bufBufFactors= bufFactors;
     1526        bufBufFactors= bufFactors;
    15151527        pass= testFactors (bufF, bufBufFactors, alpha, sqrfPartF, bufFactors,
    15161528                           bufSqrfFactors, evalSqrfPartF);
     
    15201532          F= bufF;
    15211533          CFList l= factors;
    1522           for (CFListIterator iter= l; iter.hasItem(); iter++)
     1534          for (iter= l; iter.hasItem(); iter++)
    15231535            iter.getItem()= swapvar (iter.getItem(), x, y);
    15241536          differentSecondVarLCs [i]= l;
     
    15731585
    15741586  CFList result;
     1587  CFFListIterator k;
    15751588  for (int i= 0; i < LCFFactors.length(); i++)
    15761589  {
    15771590    CanonicalForm tmp= 1;
    1578     for (CFFListIterator k= bufSqrfFactors[i]; k.hasItem(); k++)
     1591    for (k= bufSqrfFactors[i]; k.hasItem(); k++)
    15791592    {
    15801593      int pos= findItem (bufFactors, k.getItem().factor());
     
    16341647                                  const CanonicalForm& A)
    16351648{
     1649  CanonicalForm tmp;
     1650  CFList tmp2;
     1651  CFListIterator iter;
    16361652  for (int i= A.level(); i > 2; i--)
    16371653  {
    1638     CanonicalForm tmp= A;
    1639     CFList tmp2= CFList();
    1640     CFListIterator iter= evaluation;
     1654    tmp= A;
     1655    tmp2= CFList();
     1656    iter= evaluation;
    16411657    bool preserveDegree= true;
    16421658    for (int j= A.level(); j > 1; j--, iter++)
     
    17481764  minFactorsLength= 0;
    17491765  irred= false;
     1766  CFList factors;
     1767  Variable v;
    17501768  for (int j= 0; j < A.level() - 2; j++)
    17511769  {
    17521770    if (!Aeval[j].isEmpty())
    17531771    {
    1754       Variable v= Variable (Aeval[j].getFirst().level());
    1755 
    1756       CFList factors;
     1772      v= Variable (Aeval[j].getFirst().level());
    17571773      if (CFFactory::gettype() == GaloisFieldDomain)
    17581774        factors= GFBiSqrfFactorize (Aeval[j].getFirst());
     
    17831799                      )
    17841800{
     1801  CanonicalForm evalPoint;
     1802  int i;
     1803  CFListIterator iter, iter2;
     1804  Variable v;
     1805  CFList l, LCs;
     1806  CanonicalForm buf;
    17851807  for (int j= 0; j < A.level() - 2; j++)
    17861808  {
    17871809    if (!Aeval[j].isEmpty())
    17881810    {
    1789       int i= A.level();
    1790       CanonicalForm evalPoint;
    1791       for (CFListIterator iter= evaluation; iter.hasItem(); iter++, i--)
     1811      i= A.level();
     1812      for (iter= evaluation; iter.hasItem(); iter++, i--)
    17921813      {
    17931814        if (i == Aeval[j].getFirst().level())
     
    17981819      }
    17991820
    1800       Variable v= Variable (i);
     1821      v= Variable (i);
    18011822      if (Aeval[j].length() > uniFactors.length())
    18021823        Aeval[j]= recombination (Aeval[j], uniFactors, 1,
     
    18041825                                 evalPoint, v);
    18051826
    1806       CFList l;
    1807       CanonicalForm buf;
    1808       for (CFListIterator iter1= uniFactors; iter1.hasItem(); iter1++)
    1809       {
    1810         for (CFListIterator iter2= Aeval[j]; iter2.hasItem(); iter2++)
     1827      l= CFList();
     1828      for (iter= uniFactors; iter.hasItem(); iter++)
     1829      {
     1830        for (iter2= Aeval[j]; iter2.hasItem(); iter2++)
    18111831        {
    18121832          buf= mod (iter2.getItem(), v - evalPoint);
    18131833          buf /= Lc (buf);
    1814           if (iter1.getItem() == buf)
     1834          if (iter.getItem() == buf)
    18151835          {
    18161836            l.append (iter2.getItem());
     
    18211841      Aeval [j]= l;
    18221842
    1823       CFList LCs;
    1824       for (CFListIterator iter= Aeval[j]; iter.hasItem(); iter++)
     1843      LCs= CFList();
     1844      for (iter= Aeval[j]; iter.hasItem(); iter++)
    18251845        LCs.append (LC (iter.getItem() (v + evalPoint, v), 1));
    18261846      normalize (LCs);
     
    18491869                      int minFactorsLength)
    18501870{
     1871  CFListIterator iter;
     1872  CanonicalForm evalPoint;
     1873  int i;
     1874  Variable v;
     1875  Variable y= Variable (2);
     1876  CFList list;
    18511877  for (int j= 0; j < A.level() - 2; j++)
    18521878  {
    18531879    if (Aeval[j].length() == minFactorsLength)
    18541880    {
    1855       int i= A.level();
    1856       CanonicalForm evalPoint;
    1857       for (CFListIterator iter= evaluation; iter.hasItem(); iter++, i--)
     1881      i= A.level();
     1882
     1883      for (iter= evaluation; iter.hasItem(); iter++, i--)
    18581884      {
    18591885        if (i == Aeval[j].getFirst().level())
     
    18641890      }
    18651891
    1866       Variable v= Variable (i);
    1867       CFList list= buildUniFactors (Aeval[j], evalPoint, v);
    1868 
    1869       Variable y= Variable (2);
     1892      v= Variable (i);
     1893      list= buildUniFactors (Aeval[j], evalPoint, v);
     1894
    18701895      biFactors= recombination (biFactors, list, 1,
    18711896                                biFactors.length() - list.length() + 1,
     
    18811906  CFList l= leadingCoeffs;
    18821907  LCs [n-3]= l;
     1908  CFListIterator j;
    18831909  for (int i= n - 1; i > 2; i--)
    18841910  {
    1885     for (CFListIterator j= l; j.hasItem(); j++)
     1911    for (j= l; j.hasItem(); j++)
    18861912      j.getItem()= j.getItem() (0, i + 1);
    18871913    LCs [i - 3]= l;
     
    18971923  {
    18981924    ii= normalizeFactor;
    1899     for (CFListIterator j= LCs [i]; j.hasItem(); j++, ii++)
     1925    for (j= LCs [i]; j.hasItem(); j++, ii++)
    19001926      j.getItem() *= ii.getItem();
    19011927  }
Note: See TracChangeset for help on using the changeset viewer.