Changeset 71a4d7 in git for factory/facFqFactorize.cc


Ignore:
Timestamp:
Feb 18, 2013, 5:10:09 PM (11 years ago)
Author:
Oleksandr Motsak <malex984@…>
Branches:
(u'spielwiese', '4a9821a93ffdc22a6696668bd4f6b8c9de3e6c5f')
Children:
65148c4d2a607796fbd578ae2f3219965019aaae
Parents:
d826a82d3b17fc5f6da647679a15d4f1af7657fdf1becf6c8965f6addf0a63ca09a9418a48c294be
Message:
Merge pull request #264 from mmklee/sync

Sync Master and Spielwiese
File:
1 edited

Legend:

Unmodified
Added
Removed

  • factory/facFqFactorize.cc

    rd826a8 r71a4d7  
    4949TIMING_DEFINE_PRINT(fac_fq_check_mainvar)
    5050TIMING_DEFINE_PRINT(fac_fq_compress)
     51
    5152
    5253static inline
    … …  
    12081209  int k= factors1.length();
    12091210  int l= factors2.length();
    1210   int n= 1;
     1211  int n= 0;
    12111212  int m;
    12121213  CFFListIterator j;
    12131214  for (CFFListIterator i= factors1; (n < k && i.hasItem()); i++, n++)
    12141215  {
    1215     m= 1;
     1216    m= 0;
    12161217    for (j= factors2; (m < l && j.hasItem()); j++, m++)
    12171218    {
    … …  
    13241325             const CFArray& evalPoint)
    13251326{
    1326   CanonicalForm tmp;
    1327   CFListIterator j;
    1328   for (CFListIterator i= uniFactors; i.hasItem(); i++)
    1329   {
    1330     tmp= i.getItem();
    1331     if (i.hasItem())
    1332       i++;
    1333     else
    1334       break;
    1335     for (j= i; j.hasItem(); j++)
    1336     {
    1337       if (tmp == j.getItem())
    1338         return 0;
    1339     }
    1340   }
    1341 
    13421327  CanonicalForm F= G;
    13431328  CFFList sqrfFactorization;
    … …  
    13591344
    13601345  CFFList sqrfFactors;
     1346  CanonicalForm tmp;
    13611347  CFList tmp2;
    13621348  int k= 0;
    … …  
    14841470      result.insert (Lc (LCF));
    14851471    else
    1486     {
    1487       for (CFListIterator i= result; i.hasItem(); i++)
    1488         i.getItem() *= LCF;
    14891472      result.insert (LCF);
    1490     }
     1473
    14911474    return result;
    14921475  }
    … …  
    15521535        bufBufFactors= bufFactors;
    15531536        evalPoint= CFArray (evaluation.length() - 1);
    1554         for (int k= 0; k < evaluation.length()-1; k++)
     1537        for (int k= 1; k < evaluation.length(); k++)
    15551538        {
    15561539          if (N (Variable (k+1)).level() != y.level())
    1557             evalPoint[k]= buf[k+1];
     1540            evalPoint[k-1]= buf[k];
    15581541          else
    1559             evalPoint[k]= buf[0];
     1542            evalPoint[k-1]= buf[0];
    15601543        }
    15611544        pass= testFactors (bufF, bufBufFactors, alpha, sqrfPartF, bufFactors,
    … …  
    15791562            result.append (1);
    15801563          result= distributeContent (result, differentSecondVarLCs, lSecondVarLCs);
    1581           if (!result.getFirst().inCoeffDomain())
    1582           {
    1583             CFListIterator iter= result;
    1584             CanonicalForm tmp= iter.getItem();
    1585             iter++;
    1586             for (; iter.hasItem(); iter++)
    1587               iter.getItem() *= tmp;
    1588           }
    15891564          y= Variable (1);
    15901565          delete [] bufSqrfFactors;
    … …  
    16011576      result.append (1);
    16021577    result= distributeContent (result, differentSecondVarLCs, lSecondVarLCs);
    1603     if (!result.getFirst().inCoeffDomain())
    1604     {
    1605       CFListIterator iter= result;
    1606       CanonicalForm tmp= iter.getItem();
    1607       iter++;
    1608       for (; iter.hasItem(); iter++)
    1609         iter.getItem() *= tmp;
    1610     }
    16111578    y= Variable (1);
    16121579    delete [] bufSqrfFactors;
    … …  
    16831650      {
    16841651        int* liftBounds= new int [sqrfPartF.level() - 1];
    1685         liftBounds [0]= liftBound;
    16861652        bool noOneToOne= false;
    16871653        CFList *leadingCoeffs2= new CFList [sqrfPartF.level()-2];
    … …  
    17001666
    17011667        int liftBoundsLength= sqrfPartF.level() - 1;
    1702         for (int i= 1; i < liftBoundsLength; i++)
     1668        for (int i= 0; i < liftBoundsLength; i++)
    17031669          liftBounds [i]= degree (sqrfPartF, i + 2) + 1;
    17041670        evalSqrfPartF= evaluateAtZero (sqrfPartF);
    … …  
    17641730  if (!result.getFirst().inCoeffDomain())
    17651731  {
    1766     CFListIterator i= result;
    1767     CanonicalForm tmp;
     1732    // prepare input for recursion
    17681733    if (foundDifferent)
    1769       i.getItem()= swapvar (i.getItem(), Variable (2), y);
    1770 
    1771     tmp= i.getItem();
    1772 
    1773     i++;
    1774     for (; i.hasItem(); i++)
    1775     {
    1776       if (foundDifferent)
    1777         i.getItem()= swapvar (i.getItem(), Variable (2), y)*tmp;
     1734    {
     1735      for (CFListIterator i= result; i.hasItem(); i++)
     1736        i.getItem()= swapvar (i.getItem(), Variable (2), y);
     1737      CFList l= differentSecondVarLCs [j];
     1738      for (CFListIterator i= l; i.hasItem(); i++)
     1739        i.getItem()= swapvar (i.getItem(), y, z);
     1740      differentSecondVarLCs [j]= l;
     1741    }
     1742
     1743    F= result.getFirst();
     1744    int level= 0;
     1745    if (foundDifferent)
     1746    {
     1747      level= y.level() - 2;
     1748      for (int i= y.level(); i > 1; i--)
     1749      {
     1750        if (degree (F,i) > 0)
     1751        {
     1752          if (y.level() == 3)
     1753            level= 0;
     1754          else
     1755            level= i-3;
     1756        }
     1757      }
     1758    }
     1759lcretry:
     1760    if (lSecondVarLCs - level > 0)
     1761    {
     1762      CFList evaluation2= evaluation;
     1763      int j= lSecondVarLCs+2;
     1764      CanonicalForm swap;
     1765      CFListIterator i;
     1766      for (i= evaluation2; i.hasItem(); i++, j--)
     1767      {
     1768        if (j==y.level())
     1769        {
     1770          swap= i.getItem();
     1771          i.getItem()= evaluation2.getLast();
     1772          evaluation2.removeLast();
     1773          evaluation2.append (swap);
     1774        }
     1775      }
     1776
     1777      CFList newLCs= differentSecondVarLCs[level];
     1778      if (newLCs.isEmpty())
     1779      {
     1780        if (degree (F, level+3) > 0)
     1781        {
     1782          delete [] bufSqrfFactors;
     1783          return result; //TODO handle this case
     1784        }
     1785        level=level+1;
     1786        goto lcretry;
     1787      }
     1788      i= newLCs;
     1789      CFListIterator iter= result;
     1790      iter++;
     1791      CanonicalForm quot;
     1792      for (;iter.hasItem(); iter++, i++)
     1793      {
     1794        swap= iter.getItem();
     1795        if (degree (swap, level+3) > 0)
     1796        {
     1797          int count= evaluation.length()+1;
     1798          for (CFListIterator iter2= evaluation2; iter2.hasItem(); iter2++,
     1799                                                                    count--)
     1800          {
     1801            if (count != level+3)
     1802              swap= swap (iter2.getItem(), count);
     1803          }
     1804          if (fdivides (swap, i.getItem(), quot))
     1805            i.getItem()= quot;
     1806        }
     1807      }
     1808      CFList * differentSecondVarLCs2= new CFList [lSecondVarLCs - level - 1];
     1809      for (int j= level+1; j < lSecondVarLCs; j++)
     1810      {
     1811        if (degree (F, j+3) > 0)
     1812        {
     1813          if (!differentSecondVarLCs[j].isEmpty())
     1814          {
     1815            differentSecondVarLCs2[j - level - 1]= differentSecondVarLCs[j];
     1816            i= differentSecondVarLCs2[j-level - 1];
     1817            iter=result;
     1818            iter++;
     1819            for (;iter.hasItem(); iter++, i++)
     1820            {
     1821              swap= iter.getItem();
     1822              if (degree (swap, j+3) > 0)
     1823              {
     1824                int count= evaluation.length()+1;
     1825                for (CFListIterator iter2= evaluation2; iter2.hasItem();iter2++,
     1826                                                                        count--)
     1827                {
     1828                  if (count != j+3)
     1829                    swap= swap (iter2.getItem(), count);
     1830                }
     1831                if (fdivides (swap, i.getItem(), quot))
     1832                  i.getItem()= quot;
     1833              }
     1834            }
     1835          }
     1836        }
     1837      }
     1838
     1839      for (int j= 0; j < level+1; j++)
     1840        evaluation2.removeLast();
     1841      Variable dummyvar= Variable (1);
     1842
     1843      CanonicalForm newLCF= result.getFirst();
     1844      newLCF=swapvar (newLCF, Variable (2), Variable (level+3));
     1845      for (i=newLCs; i.hasItem(); i++)
     1846        i.getItem()= swapvar (i.getItem(), Variable (2), Variable (level+3));
     1847      for (int j= 1; j < lSecondVarLCs-level;j++)
     1848      {
     1849        for (i= differentSecondVarLCs2[j-1]; i.hasItem(); i++)
     1850          i.getItem()= swapvar (i.getItem(), Variable (2+j),
     1851                                             Variable (level+3+j));
     1852        newLCF= swapvar (newLCF, Variable (2+j), Variable (level+3+j));
     1853      }
     1854
     1855      CFList recursiveResult=
     1856      precomputeLeadingCoeff (newLCF, newLCs, alpha, evaluation2,
     1857                              differentSecondVarLCs2, lSecondVarLCs - level - 1,
     1858                              dummyvar);
     1859
     1860      if (dummyvar.level() != 1)
     1861      {
     1862        for (i= recursiveResult; i.hasItem(); i++)
     1863          i.getItem()= swapvar (i.getItem(), Variable (2), dummyvar);
     1864      }
     1865      for (i= recursiveResult; i.hasItem(); i++)
     1866      {
     1867        for (int j= lSecondVarLCs-level-1; j > 0; j--)
     1868          i.getItem()=swapvar (i.getItem(), Variable (2+j),
     1869                                      Variable (level+3+j));
     1870        i.getItem()= swapvar (i.getItem(), Variable (2), Variable (level+3));
     1871      }
     1872
     1873      if (recursiveResult.getFirst() == result.getFirst())
     1874      {
     1875        delete [] bufSqrfFactors;
     1876        delete [] differentSecondVarLCs2;
     1877        return result;
     1878      }
    17781879      else
    1779         i.getItem() *= tmp;
     1880      {
     1881        iter=recursiveResult;
     1882        i= result;
     1883        i.getItem()= iter.getItem();
     1884        i++;
     1885        iter++;
     1886        for (; i.hasItem(); i++, iter++)
     1887          i.getItem() *= iter.getItem();
     1888        delete [] differentSecondVarLCs2;
     1889      }
    17801890    }
    17811891  }
    … …  
    19842094  CFArray l;
    19852095  int pos, index;
     2096  bool leaveLoop=false;
    19862097  for (int j= 0; j < AevalLength; j++)
    19872098  {
    … …  
    19912102      for (iter= evaluation; iter.hasItem(); iter++, i--)
    19922103      {
    1993         if (i == Aeval[j].getFirst().level())
    1994         {
    1995           evalPoint= iter.getItem();
     2104        for (iter2= Aeval[j]; iter2.hasItem(); iter2++)
     2105        {
     2106          if (i == iter2.getItem().level())
     2107          {
     2108            evalPoint= iter.getItem();
     2109            leaveLoop= true;
     2110            break;
     2111          }
     2112        }
     2113        if (leaveLoop)
     2114        {
     2115          leaveLoop= false;
    19962116          break;
    19972117        }
    … …  
    20402160                      int minFactorsLength)
    20412161{
    2042   CFListIterator iter;
     2162  CFListIterator iter, iter2;
    20432163  CanonicalForm evalPoint;
    20442164  int i;
    … …  
    20462166  Variable y= Variable (2);
    20472167  CFList list;
     2168  bool leaveLoop= false;
    20482169  for (int j= 0; j < A.level() - 2; j++)
    20492170  {
    … …  
    20542175      for (iter= evaluation; iter.hasItem(); iter++, i--)
    20552176      {
    2056         if (i == Aeval[j].getFirst().level())
    2057         {
    2058           evalPoint= iter.getItem();
     2177        for (iter2= Aeval[j]; iter2.hasItem(); iter2++)
     2178        {
     2179          if (i == iter2.getItem().level())
     2180          {
     2181            evalPoint= iter.getItem();
     2182            leaveLoop= true;
     2183            break;
     2184          }
     2185        }
     2186        if (leaveLoop)
     2187        {
     2188          leaveLoop= false;
    20592189          break;
    20602190        }
    … …  
    20722202}
    20732203
    2074 void prepareLeadingCoeffs (CFList*& LCs, int n, const CFList& leadingCoeffs,
    2075                            const CFList& biFactors, const CFList& evaluation)
     2204void
     2205prepareLeadingCoeffs (CFList*& LCs, CanonicalForm& A, CFList& Aeval, int n,
     2206                      const CFList& leadingCoeffs, const CFList& biFactors,
     2207                      const CFList& evaluation)
    20762208{
    20772209  CFList l= leadingCoeffs;
    … …  
    20982230      j.getItem() *= ii.getItem();
    20992231  }
     2232
     2233  Aeval= evaluateAtEval (A, evaluation, 2);
     2234
     2235  CanonicalForm hh= 1/Lc (Aeval.getFirst());
     2236
     2237  for (iter= Aeval; iter.hasItem(); iter++)
     2238    iter.getItem() *= hh;
     2239
     2240  A *= hh;
    21002241}
    21012242
    … …  
    22172358}
    22182359
     2360void
     2361changeSecondVariable (CanonicalForm& A, CFList& biFactors, CFList& evaluation,
     2362                      CFList*& oldAeval, int lengthAeval2,
     2363                      const CFList& uniFactors, const Variable& w)
     2364{
     2365  Variable y= Variable (2);
     2366  A= swapvar (A, y, w);
     2367  int i= A.level();
     2368  CanonicalForm evalPoint;
     2369  for (CFListIterator iter= evaluation; iter.hasItem(); iter++, i--)
     2370  {
     2371    if (i == w.level())
     2372    {
     2373      evalPoint= iter.getItem();
     2374      iter.getItem()= evaluation.getLast();
     2375      evaluation.removeLast();
     2376      evaluation.append (evalPoint);
     2377      break;
     2378    }
     2379  }
     2380  for (i= 0; i < lengthAeval2; i++)
     2381  {
     2382    if (oldAeval[i].isEmpty())
     2383      continue;
     2384    if (oldAeval[i].getFirst().level() == w.level())
     2385    {
     2386      CFArray tmp= copy (oldAeval[i]);
     2387      oldAeval[i]= biFactors;
     2388      for (CFListIterator iter= oldAeval[i]; iter.hasItem(); iter++)
     2389        iter.getItem()= swapvar (iter.getItem(), w, y);
     2390      for (int ii= 0; ii < tmp.size(); ii++)
     2391        tmp[ii]= swapvar (tmp[ii], w, y);
     2392      CFArray tmp2= CFArray (tmp.size());
     2393      CanonicalForm buf;
     2394      for (int ii= 0; ii < tmp.size(); ii++)
     2395      {
     2396        buf= tmp[ii] (evaluation.getLast(),y);
     2397        buf /= Lc (buf);
     2398        tmp2[findItem (uniFactors, buf)-1]=tmp[ii];
     2399      }
     2400      biFactors= CFList();
     2401      for (int j= 0; j < tmp2.size(); j++)
     2402        biFactors.append (tmp2[j]);
     2403    }
     2404  }
     2405}
     2406
     2407void
     2408distributeLCmultiplier (CanonicalForm& A, CFList& leadingCoeffs,
     2409                        CFList& biFactors, const CFList& evaluation,
     2410                        const CanonicalForm& LCmultipler)
     2411{
     2412  CanonicalForm tmp= power (LCmultipler, biFactors.length() - 1);
     2413  A *= tmp;
     2414  tmp= LCmultipler;
     2415  CFListIterator iter= leadingCoeffs;
     2416  for (;iter.hasItem(); iter++)
     2417    iter.getItem() *= LCmultipler;
     2418  iter= evaluation;
     2419  for (int i= A.level(); i > 2; i--, iter++)
     2420    tmp= tmp (iter.getItem(), i);
     2421  if (!tmp.inCoeffDomain())
     2422  {
     2423    for (CFListIterator i= biFactors; i.hasItem(); i++)
     2424    {
     2425      i.getItem() *= tmp/LC (i.getItem(), 1);
     2426      i.getItem() /= Lc (i.getItem());
     2427    }
     2428  }
     2429}
     2430
     2431void
     2432LCHeuristic (CanonicalForm& A, const CanonicalForm& LCmultiplier,
     2433             CFList& biFactors, CFList*& leadingCoeffs, const CFList* oldAeval,
     2434             int lengthAeval, const CFList& evaluation,
     2435             const CFList& oldBiFactors)
     2436{
     2437  CFListIterator iter, iter2;
     2438  int index;
     2439  Variable xx;
     2440  CFList vars1;
     2441  CFFList sqrfMultiplier= sqrFree (LCmultiplier);
     2442  if (sqrfMultiplier.getFirst().factor().inCoeffDomain())
     2443    sqrfMultiplier.removeFirst();
     2444  sqrfMultiplier= sortCFFListByNumOfVars (sqrfMultiplier);
     2445  xx= Variable (2);
     2446  for (iter= oldBiFactors; iter.hasItem(); iter++)
     2447    vars1.append (power (xx, degree (LC (iter.getItem(),1), xx)));
     2448  for (int i= 0; i < lengthAeval; i++)
     2449  {
     2450    if (oldAeval[i].isEmpty())
     2451      continue;
     2452    xx= oldAeval[i].getFirst().mvar();
     2453    iter2= vars1;
     2454    for (iter= oldAeval[i]; iter.hasItem(); iter++, iter2++)
     2455      iter2.getItem() *= power (xx, degree (LC (iter.getItem(),1), xx));
     2456  }
     2457  CanonicalForm tmp;
     2458  iter2= vars1;
     2459  for (iter= leadingCoeffs[lengthAeval-1]; iter.hasItem(); iter++, iter2++)
     2460  {
     2461    tmp= iter.getItem()/LCmultiplier;
     2462    for (int i=1; i <= tmp.level(); i++)
     2463    {
     2464      if (degree (tmp,i) > 0 && (degree (iter2.getItem(),i) > degree (tmp,i)))
     2465        iter2.getItem() /= power (Variable (i), degree (tmp,i));
     2466    }
     2467  }
     2468  int multi;
     2469  for (CFFListIterator ii= sqrfMultiplier; ii.hasItem(); ii++)
     2470  {
     2471    multi= 0;
     2472    for (iter= vars1; iter.hasItem(); iter++)
     2473    {
     2474      tmp= iter.getItem();
     2475      while (fdivides (myGetVars (ii.getItem().factor()), tmp))
     2476      {
     2477        multi++;
     2478        tmp /= myGetVars (ii.getItem().factor());
     2479      }
     2480    }
     2481    if (multi == ii.getItem().exp())
     2482    {
     2483      index= 1;
     2484      for (iter= vars1; iter.hasItem(); iter++, index++)
     2485      {
     2486        while (fdivides (myGetVars (ii.getItem().factor()), iter.getItem()))
     2487        {
     2488          int index2= 1;
     2489          for (iter2= leadingCoeffs[lengthAeval-1]; iter2.hasItem();iter2++,
     2490                                                                    index2++)
     2491          {
     2492            if (index2 == index)
     2493              continue;
     2494            else
     2495            {
     2496              tmp= ii.getItem().factor();
     2497              iter2.getItem() /= tmp;
     2498              CFListIterator iter3= evaluation;
     2499              for (int jj= A.level(); jj > 2; jj--, iter3++)
     2500                tmp= tmp (iter3.getItem(), jj);
     2501              if (!tmp.inCoeffDomain())
     2502              {
     2503                int index3= 1;
     2504                for (iter3= biFactors; iter3.hasItem(); iter3++, index3++)
     2505                {
     2506                  if (index3 == index2)
     2507                  {
     2508                    iter3.getItem() /= tmp;
     2509                    iter3.getItem() /= Lc (iter3.getItem());
     2510                    break;
     2511                  }
     2512                }
     2513              }
     2514              A /= ii.getItem().factor();
     2515            }
     2516          }
     2517          iter.getItem() /= getVars (ii.getItem().factor());
     2518        }
     2519      }
     2520    }
     2521    else
     2522    {
     2523      index= 1;
     2524      for (iter= vars1; iter.hasItem(); iter++, index++)
     2525      {
     2526        if (!fdivides (myGetVars (ii.getItem().factor()), iter.getItem()))
     2527        {
     2528          int index2= 1;
     2529          for (iter2= leadingCoeffs[lengthAeval-1];iter2.hasItem();iter2++,
     2530                                                                    index2++)
     2531          {
     2532            if (index2 == index)
     2533            {
     2534              tmp= power (ii.getItem().factor(), ii.getItem().exp());
     2535              iter2.getItem() /= tmp;
     2536              A /= tmp;
     2537              CFListIterator iter3= evaluation;
     2538              for (int jj= A.level(); jj > 2; jj--, iter3++)
     2539                tmp= tmp (iter3.getItem(), jj);
     2540              if (!tmp.inCoeffDomain())
     2541              {
     2542                int index3= 1;
     2543                for (iter3= biFactors; iter3.hasItem(); iter3++, index3++)
     2544                {
     2545                  if (index3 == index2)
     2546                  {
     2547                    iter3.getItem() /= tmp;
     2548                    iter3.getItem() /= Lc (iter3.getItem());
     2549                    break;
     2550                  }
     2551                }
     2552              }
     2553            }
     2554          }
     2555        }
     2556      }
     2557    }
     2558  }
     2559}
     2560
     2561void
     2562LCHeuristicCheck (const CFList& LCs, const CFList& contents, CanonicalForm& A,
     2563                  const CanonicalForm& oldA, CFList& leadingCoeffs,
     2564                  bool& foundTrueMultiplier)
     2565{
     2566  CanonicalForm pLCs= prod (LCs);
     2567  if (fdivides (pLCs, LC (oldA,1)) && (LC(oldA,1)/pLCs).inCoeffDomain()) // check if the product of the lead coeffs of the primitive factors equals the lead coeff of the old A
     2568  {
     2569    A= oldA;
     2570    CFListIterator iter2= leadingCoeffs;
     2571    for (CFListIterator iter= contents; iter.hasItem(); iter++, iter2++)
     2572      iter2.getItem() /= iter.getItem();
     2573    foundTrueMultiplier= true;
     2574  }
     2575}
     2576
     2577void
     2578LCHeuristic2 (const CanonicalForm& LCmultiplier, const CFList& factors,
     2579              CFList& leadingCoeffs, CFList& contents, CFList& LCs,
     2580              bool& foundTrueMultiplier)
     2581{
     2582  CanonicalForm cont;
     2583  int index= 1;
     2584  CFListIterator iter2;
     2585  for (CFListIterator iter= factors; iter.hasItem(); iter++, index++)
     2586  {
     2587    cont= content (iter.getItem(), 1);
     2588    cont= gcd (cont, LCmultiplier);
     2589    contents.append (cont);
     2590    if (cont.inCoeffDomain()) // trivial content->LCmultiplier needs to go there
     2591    {
     2592      foundTrueMultiplier= true;
     2593      int index2= 1;
     2594      for (iter2= leadingCoeffs; iter2.hasItem(); iter2++, index2++)
     2595      {
     2596        if (index2 == index)
     2597          continue;
     2598        iter2.getItem() /= LCmultiplier;
     2599      }
     2600      break;
     2601    }
     2602    else
     2603      LCs.append (LC (iter.getItem()/cont, 1));
     2604  }
     2605}
     2606
     2607void
     2608LCHeuristic3 (const CanonicalForm& LCmultiplier, const CFList& factors,
     2609              const CFList& oldBiFactors, const CFList& contents,
     2610              const CFList* oldAeval, CanonicalForm& A, CFList*& leadingCoeffs,
     2611              int lengthAeval, bool& foundMultiplier)
     2612{
     2613  int index= 1;
     2614  CFListIterator iter, iter2= factors;
     2615  for (iter= contents; iter.hasItem(); iter++, iter2++, index++)
     2616  {
     2617    if (fdivides (iter.getItem(), LCmultiplier))
     2618    {
     2619      if ((LCmultiplier/iter.getItem()).inCoeffDomain() &&
     2620          !isOnlyLeadingCoeff(iter2.getItem())) //content divides LCmultiplier completely and factor consists of more terms than just the leading coeff
     2621      {
     2622        Variable xx= Variable (2);
     2623        CanonicalForm vars;
     2624        vars= power (xx, degree (LC (getItem(oldBiFactors, index),1),
     2625                                  xx));
     2626        for (int i= 0; i < lengthAeval; i++)
     2627        {
     2628          if (oldAeval[i].isEmpty())
     2629            continue;
     2630          xx= oldAeval[i].getFirst().mvar();
     2631          vars *= power (xx, degree (LC (getItem(oldAeval[i], index),1),
     2632                                      xx));
     2633        }
     2634        if (vars.level() <= 2)
     2635        {
     2636          int index2= 1;
     2637          for (CFListIterator iter3= leadingCoeffs[lengthAeval-1];
     2638                iter3.hasItem(); iter3++, index2++)
     2639          {
     2640            if (index2 == index)
     2641            {
     2642              iter3.getItem() /= LCmultiplier;
     2643              break;
     2644            }
     2645          }
     2646          A /= LCmultiplier;
     2647          foundMultiplier= true;
     2648          iter.getItem()= 1;
     2649        }
     2650      }
     2651    }
     2652  }
     2653}
     2654
     2655void
     2656LCHeuristic4 (const CFList& oldBiFactors, const CFList* oldAeval,
     2657              const CFList& contents, const CFList& factors,
     2658              const CanonicalForm& testVars, int lengthAeval,
     2659              CFList*& leadingCoeffs, CanonicalForm& A,
     2660              CanonicalForm& LCmultiplier, bool& foundMultiplier)
     2661{
     2662  int index=1;
     2663  CFListIterator iter, iter2= factors;
     2664  for (iter= contents; iter.hasItem(); iter++, iter2++, index++)
     2665  {
     2666    if (!iter.getItem().isOne() &&
     2667        fdivides (iter.getItem(), LCmultiplier))
     2668    {
     2669      if (!isOnlyLeadingCoeff (iter2.getItem())) // factor is more than just leading coeff
     2670      {
     2671        int index2= 1;
     2672        for (iter2= leadingCoeffs[lengthAeval-1]; iter2.hasItem();
     2673              iter2++, index2++)
     2674        {
     2675          if (index2 == index)
     2676          {
     2677            iter2.getItem() /= iter.getItem();
     2678            foundMultiplier= true;
     2679            break;
     2680          }
     2681        }
     2682        A /= iter.getItem();
     2683        LCmultiplier /= iter.getItem();
     2684        iter.getItem()= 1;
     2685      }
     2686      else if (fdivides (getVars (LCmultiplier), testVars))//factor consists of just leading coeff
     2687      {
     2688        Variable xx= Variable (2);
     2689        CanonicalForm vars;
     2690        vars= power (xx, degree (LC (getItem(oldBiFactors, index),1),
     2691                                  xx));
     2692        for (int i= 0; i < lengthAeval; i++)
     2693        {
     2694          if (oldAeval[i].isEmpty())
     2695            continue;
     2696          xx= oldAeval[i].getFirst().mvar();
     2697          vars *= power (xx, degree (LC (getItem(oldAeval[i], index),1),
     2698                                      xx));
     2699        }
     2700        if (myGetVars(content(getItem(leadingCoeffs[lengthAeval-1],index),1))
     2701            /myGetVars (LCmultiplier) == vars)
     2702        {
     2703          int index2= 1;
     2704          for (iter2= leadingCoeffs[lengthAeval-1]; iter2.hasItem();
     2705                iter2++, index2++)
     2706          {
     2707            if (index2 == index)
     2708            {
     2709              iter2.getItem() /= LCmultiplier;
     2710              foundMultiplier= true;
     2711              break;
     2712            }
     2713          }
     2714          A /= LCmultiplier;
     2715          iter.getItem()= 1;
     2716        }
     2717      }
     2718    }
     2719  }
     2720}
     2721
    22192722CFList
    22202723extFactorize (const CanonicalForm& F, const ExtensionInfo& info);
    … …  
    23622865  bool fail= false;
    23632866  int swapLevel2= 0;
    2364   int level;
     2867  //int level;
    23652868  int factorNums= 3;
    23662869  CFList biFactors, bufBiFactors;
    … …  
    23912894    if (fail && (i == 0))
    23922895    {
    2393       if (!swapLevel)
     2896      /*if (!swapLevel) //uncomment to reenable search for new main variable
    23942897        level= 2;
    23952898      else
    2396         level= swapLevel + 1;
    2397 
    2398       CanonicalForm g;
    2399       swapLevel2= newMainVariableSearch (A, Aeval, evaluation, alpha, level, g);
    2400 
    2401       if (!swapLevel2) // need to pass to an extension
    2402       {
     2899        level= swapLevel + 1;*/
     2900
     2901      //CanonicalForm g;
     2902      //swapLevel2= newMainVariableSearch (A, Aeval, evaluation, alpha, level, g);
     2903
     2904      /*if (!swapLevel2) // need to pass to an extension
     2905      {*/
    24032906        factors= extFactorize (A, info);
    24042907        appendSwapDecompress (factors, contentAFactors, N, swapLevel, x);
    … …  
    24072910        delete [] Aeval2;
    24082911        return factors;
    2409       }
     2912      /*}
    24102913      else
    24112914      {
    … …  
    24262929        bufA= A;
    24272930        bufEvaluation= evaluation;
    2428       }
     2931      }*/ //end uncomment
    24292932    }
    24302933    else if (fail && (i > 0))
    … …  
    25913094
    25923095  if (v.level() != 1)
    2593   {
    2594     A= swapvar (A, y, v);
    2595     int i= A.level();
    2596     CanonicalForm evalPoint;
    2597     for (CFListIterator iter= evaluation; iter.hasItem(); iter++, i--)
    2598     {
    2599       if (i == v.level())
    2600       {
    2601         evalPoint= iter.getItem();
    2602         iter.getItem()= evaluation.getLast();
    2603         evaluation.removeLast();
    2604         evaluation.append (evalPoint);
    2605         break;
    2606       }
    2607     }
    2608     for (i= 0; i < lengthAeval2; i++)
    2609     {
    2610       if (oldAeval[i].isEmpty())
    2611         continue;
    2612       if (oldAeval[i].getFirst().level() == v.level())
    2613       {
    2614         CFArray tmp= copy (oldAeval[i]);
    2615         oldAeval[i]= biFactors;
    2616         for (CFListIterator iter= oldAeval[i]; iter.hasItem(); iter++)
    2617           iter.getItem()= swapvar (iter.getItem(), v, y);
    2618         for (int ii= 0; ii < tmp.size(); ii++)
    2619           tmp[ii]= swapvar (tmp[ii], v, y);
    2620         CFArray tmp2= CFArray (tmp.size());
    2621         CanonicalForm buf;
    2622         for (int ii= 0; ii < tmp.size(); ii++)
    2623         {
    2624           buf= tmp[ii] (evaluation.getLast(),y);
    2625           buf /= Lc (buf);
    2626           tmp2[findItem (uniFactors, buf)-1]=tmp[ii];
    2627         }
    2628         biFactors= CFList();
    2629         for (int j= 0; j < tmp2.size(); j++)
    2630           biFactors.append (tmp2[j]);
    2631       }
    2632     }
    2633   }
    2634 
    2635   CFListIterator iter;
     3096    changeSecondVariable (A, biFactors, evaluation, oldAeval, lengthAeval2,
     3097                          uniFactors, v);
     3098
    26363099  CanonicalForm oldA= A;
    26373100  CFList oldBiFactors= biFactors;
    2638   if (!leadingCoeffs.getFirst().inCoeffDomain())
    2639   {
    2640     CanonicalForm tmp= power (leadingCoeffs.getFirst(), biFactors.length() - 1);
    2641     A *= tmp;
    2642     tmp= leadingCoeffs.getFirst();
    2643     iter= evaluation;
    2644     for (int i= A.level(); i > 2; i--, iter++)
    2645       tmp= tmp (iter.getItem(), i);
    2646     if (!tmp.inCoeffDomain())
    2647     {
    2648       for (CFListIterator i= biFactors; i.hasItem(); i++)
    2649       {
    2650         i.getItem() *= tmp/LC (i.getItem(), 1);
    2651         i.getItem() /= Lc (i.getItem());
    2652       }
    2653     }
    2654   }
    26553101
    26563102  CanonicalForm LCmultiplier= leadingCoeffs.getFirst();
    … …  
    26583104  leadingCoeffs.removeFirst();
    26593105
     3106  if (!LCmultiplierIsConst)
     3107    distributeLCmultiplier (A, leadingCoeffs, biFactors, evaluation, LCmultiplier);
     3108
    26603109  //prepare leading coefficients
    26613110  CFList* leadingCoeffs2= new CFList [lengthAeval2];
    2662   prepareLeadingCoeffs (leadingCoeffs2, A.level(), leadingCoeffs, biFactors,
    2663                         evaluation);
    2664 
    2665   Aeval= evaluateAtEval (A, evaluation, 2);
    2666   CanonicalForm hh= 1/Lc (Aeval.getFirst());
    2667   for (iter= Aeval; iter.hasItem(); iter++)
    2668     iter.getItem() *= hh;
    2669 
    2670   A *= hh;
    2671 
    2672 
    2673   CFListIterator iter2;
     3111  prepareLeadingCoeffs (leadingCoeffs2, A, Aeval, A.level(), leadingCoeffs,
     3112                        biFactors, evaluation);
     3113
     3114  CFListIterator iter;
    26743115  CFList bufLeadingCoeffs2= leadingCoeffs2[lengthAeval2-1];
    26753116  bufBiFactors= biFactors;
    26763117  bufA= A;
    2677   CanonicalForm bufLCmultiplier= LCmultiplier;
    2678   CanonicalForm testVars;
     3118  CanonicalForm testVars, bufLCmultiplier= LCmultiplier;
    26793119  if (!LCmultiplierIsConst)
    26803120  {
    … …  
    27523192      LCheuristic= true;
    27533193      factors= oldFactors;
    2754       CanonicalForm cont;
    27553194      CFList contents, LCs;
    2756       int index=1;
    27573195      bool foundTrueMultiplier= false;
    2758       for (iter= factors; iter.hasItem(); iter++, index++)
    2759       {
    2760         cont= content (iter.getItem(), 1);
    2761         cont= gcd (cont , LCmultiplier);
    2762         contents.append (cont);
    2763         if (cont.inCoeffDomain()) // trivial content->LCmultiplier needs to go there
    2764         {
    2765           foundTrueMultiplier= true;
    2766           int index2= 1;
    2767           for (iter2= leadingCoeffs2[lengthAeval2-1]; iter2.hasItem(); iter2++,
    2768                                                                     index2++)
    2769           {
    2770             if (index2 == index)
    2771               continue;
    2772             iter2.getItem() /= LCmultiplier;
    2773           }
     3196      LCHeuristic2 (LCmultiplier, factors, leadingCoeffs2[lengthAeval2-1],
     3197                    contents, LCs, foundTrueMultiplier);
     3198      if (foundTrueMultiplier)
     3199      {
    27743200          A= oldA;
    27753201          leadingCoeffs= leadingCoeffs2[lengthAeval2-1];
    27763202          for (int i= lengthAeval2-1; i > -1; i--)
    27773203            leadingCoeffs2[i]= CFList();
    2778           prepareLeadingCoeffs (leadingCoeffs2, A.level(), leadingCoeffs,
    2779                                 biFactors, evaluation );
    2780           Aeval= evaluateAtEval (A, evaluation, 2);
    2781 
    2782           hh= 1/Lc (Aeval.getFirst());
    2783 
    2784           for (iter2= Aeval; iter2.hasItem(); iter2++)
    2785             iter2.getItem() *= hh;
    2786 
    2787           A *= hh;
    2788           break;
    2789         }
    2790         else
    2791           LCs.append (LC (iter.getItem()/cont, 1));
    2792       }
    2793       if (!foundTrueMultiplier)
    2794       {
    2795         index= 1;
    2796         iter2= factors;
     3204          prepareLeadingCoeffs (leadingCoeffs2, A, Aeval, A.level(),
     3205                                leadingCoeffs, biFactors, evaluation);
     3206      }
     3207      else
     3208      {
    27973209        bool foundMultiplier= false;
    2798         for (iter= contents; iter.hasItem(); iter++, iter2++, index++)
    2799         {
    2800           if (fdivides (iter.getItem(), LCmultiplier))
    2801           {
    2802             if ((LCmultiplier/iter.getItem()).inCoeffDomain() &&
    2803                 !isOnlyLeadingCoeff(iter2.getItem())) //content divides LCmultiplier completely and factor consists of more terms than just the leading coeff
    2804             {
    2805               Variable xx= Variable (2);
    2806               CanonicalForm vars;
    2807               vars= power (xx, degree (LC (getItem(oldBiFactors, index),1),
    2808                                         xx));
    2809               for (int i= 0; i < lengthAeval2; i++)
    2810               {
    2811                 if (oldAeval[i].isEmpty())
    2812                   continue;
    2813                 xx= oldAeval[i].getFirst().mvar();
    2814                 vars *= power (xx, degree (LC (getItem(oldAeval[i], index),1),
    2815                                            xx));
    2816               }
    2817               if (vars.level() <= 2)
    2818               {
    2819                 int index2= 1;
    2820                 for (CFListIterator iter3= leadingCoeffs2[lengthAeval2-1];
    2821                      iter3.hasItem(); iter3++, index2++)
    2822                 {
    2823                   if (index2 == index)
    2824                   {
    2825                     iter3.getItem() /= LCmultiplier;
    2826                     break;
    2827                   }
    2828                 }
    2829                 A /= LCmultiplier;
    2830                 foundMultiplier= true;
    2831                 iter.getItem()= 1;
    2832               }
    2833             }
    2834           }
    2835         }
     3210        LCHeuristic3 (LCmultiplier, factors, oldBiFactors, contents, oldAeval,
     3211                      A, leadingCoeffs2, lengthAeval2, foundMultiplier);
     3212
    28363213        // coming from above: divide out more LCmultiplier if possible
    28373214        if (foundMultiplier)
    28383215        {
    28393216          foundMultiplier= false;
    2840           index=1;
    2841           iter2= factors;
    2842           for (iter= contents; iter.hasItem(); iter++, iter2++, index++)
    2843           {
    2844             if (!iter.getItem().isOne() &&
    2845                 fdivides (iter.getItem(), LCmultiplier))
    2846             {
    2847               if (!isOnlyLeadingCoeff (iter2.getItem())) // factor is more than just leading coeff
    2848               {
    2849                 int index2= 1;
    2850                 for (iter2= leadingCoeffs2[lengthAeval2-1]; iter2.hasItem();
    2851                      iter2++, index2++)
    2852                 {
    2853                   if (index2 == index)
    2854                   {
    2855                     iter2.getItem() /= iter.getItem();
    2856                     foundMultiplier= true;
    2857                     break;
    2858                   }
    2859                 }
    2860                 A /= iter.getItem();
    2861                 LCmultiplier /= iter.getItem();
    2862                 iter.getItem()= 1;
    2863               }
    2864               else if (fdivides (getVars (LCmultiplier), testVars))//factor consists of just leading coeff
    2865               {
    2866                 //TODO maybe use a sqrffree decomposition of LCmultiplier as below
    2867                 Variable xx= Variable (2);
    2868                 CanonicalForm vars;
    2869                 vars= power (xx, degree (LC (getItem(oldBiFactors, index),1),
    2870                                           xx));
    2871                 for (int i= 0; i < lengthAeval2; i++)
    2872                 {
    2873                   if (oldAeval[i].isEmpty())
    2874                     continue;
    2875                   xx= oldAeval[i].getFirst().mvar();
    2876                   vars *= power (xx, degree (LC (getItem(oldAeval[i], index),1),
    2877                                              xx));
    2878                 }
    2879                 if (myGetVars(content(getItem(leadingCoeffs2[lengthAeval2-1],index),1))
    2880                     /myGetVars (LCmultiplier) == vars)
    2881                 {
    2882                   int index2= 1;
    2883                   for (iter2= leadingCoeffs2[lengthAeval2-1]; iter2.hasItem();
    2884                        iter2++, index2++)
    2885                   {
    2886                     if (index2 == index)
    2887                     {
    2888                       iter2.getItem() /= LCmultiplier;
    2889                       foundMultiplier= true;
    2890                       break;
    2891                     }
    2892                   }
    2893                   A /= LCmultiplier;
    2894                   iter.getItem()= 1;
    2895                 }
    2896               }
    2897             }
    2898           }
     3217          LCHeuristic4 (oldBiFactors, oldAeval, contents, factors, testVars,
     3218                        lengthAeval2, leadingCoeffs2, A, LCmultiplier,
     3219                        foundMultiplier);
    28993220        }
    29003221        else
    29013222        {
    2902           CanonicalForm pLCs= prod (LCs);
    2903           if (fdivides (pLCs, LC (oldA,1)) && (LC(oldA,1)/pLCs).inCoeffDomain()) // check if the product of the lead coeffs of the primitive factors equals the lead coeff of the old A
    2904           {
    2905             A= oldA;
    2906             iter2= leadingCoeffs2[lengthAeval2-1];
    2907             for (iter= contents; iter.hasItem(); iter++, iter2++)
    2908               iter2.getItem() /= iter.getItem();
    2909             foundMultiplier= true;
    2910           }
     3223          LCHeuristicCheck (LCs, contents, A, oldA,
     3224                            leadingCoeffs2[lengthAeval2-1], foundMultiplier);
    29113225          if (!foundMultiplier && fdivides (getVars (LCmultiplier), testVars))
    29123226          {
    2913             Variable xx;
    2914             CFList vars1;
    2915             CFFList sqrfMultiplier= sqrFree (LCmultiplier);
    2916             if (sqrfMultiplier.getFirst().factor().inCoeffDomain())
    2917               sqrfMultiplier.removeFirst();
    2918             sqrfMultiplier= sortCFFListByNumOfVars (sqrfMultiplier);
    2919             xx= Variable (2);
    2920             for (iter= oldBiFactors; iter.hasItem(); iter++)
    2921               vars1.append (power (xx, degree (LC (iter.getItem(),1), xx)));
    2922             for (int i= 0; i < lengthAeval2; i++)
    2923             {
    2924               if (oldAeval[i].isEmpty())
    2925                 continue;
    2926               xx= oldAeval[i].getFirst().mvar();
    2927               iter2= vars1;
    2928               for (iter= oldAeval[i]; iter.hasItem(); iter++, iter2++)
    2929                 iter2.getItem() *= power(xx,degree (LC (iter.getItem(),1), xx));
    2930             }
    2931             CanonicalForm tmp;
    2932             iter2= vars1;
    2933             for (iter= leadingCoeffs2[lengthAeval2-1]; iter.hasItem(); iter++,
    2934                                                                     iter2++)
    2935             {
    2936               tmp= iter.getItem()/LCmultiplier;
    2937               for (int i=1; i <= tmp.level(); i++)
    2938               {
    2939                 if (degree(tmp,i) > 0 &&
    2940                     (degree(iter2.getItem(),i) > degree (tmp,i)))
    2941                   iter2.getItem() /= power (Variable (i), degree (tmp,i));
    2942               }
    2943             }
    2944             int multi;
    2945             for (CFFListIterator ii= sqrfMultiplier; ii.hasItem(); ii++)
    2946             {
    2947               multi= 0;
    2948               for (iter= vars1; iter.hasItem(); iter++)
    2949               {
    2950                 tmp= iter.getItem();
    2951                 while (fdivides (myGetVars (ii.getItem().factor()), tmp))
    2952                 {
    2953                   multi++;
    2954                   tmp /= myGetVars (ii.getItem().factor());
    2955                 }
    2956               }
    2957               if (multi == ii.getItem().exp())
    2958               {
    2959                 index= 1;
    2960                 for (iter= vars1; iter.hasItem(); iter++, index++)
    2961                 {
    2962                   while (fdivides (myGetVars(ii.getItem().factor()),
    2963                                    iter.getItem()
    2964                                   )
    2965                         )
    2966                   {
    2967                     int index2= 1;
    2968                     for (iter2= leadingCoeffs2[lengthAeval2-1]; iter2.hasItem();
    2969                          iter2++, index2++)
    2970                     {
    2971                       if (index2 == index)
    2972                         continue;
    2973                       else
    2974                       {
    2975                         tmp= ii.getItem().factor();
    2976                         iter2.getItem() /= tmp;
    2977                         CFListIterator iter3= evaluation;
    2978                         for (int jj= A.level(); jj > 2; jj--, iter3++)
    2979                           tmp= tmp (iter3.getItem(), jj);
    2980                         if (!tmp.inCoeffDomain())
    2981                         {
    2982                           int index3= 1;
    2983                           for (iter3= biFactors; iter3.hasItem(); iter3++,
    2984                                                                   index3++)
    2985                           {
    2986                             if (index3 == index2)
    2987                             {
    2988                               iter3.getItem() /= tmp;
    2989                               iter3.getItem() /= Lc (iter3.getItem());
    2990                               break;
    2991                             }
    2992                           }
    2993                         }
    2994                         A /= ii.getItem().factor();
    2995                       }
    2996                     }
    2997                     iter.getItem() /= getVars (ii.getItem().factor());
    2998                   }
    2999                 }
    3000               }
    3001               else
    3002               {
    3003                 index= 1;
    3004                 for (iter= vars1; iter.hasItem(); iter++, index++)
    3005                 {
    3006                   if (!fdivides (myGetVars (ii.getItem().factor()),
    3007                                  iter.getItem()
    3008                                 )
    3009                      )
    3010                   {
    3011                     int index2= 1;
    3012                     for (iter2= leadingCoeffs2[lengthAeval2-1]; iter2.hasItem();
    3013                          iter2++, index2++)
    3014                     {
    3015                       if (index2 == index)
    3016                       {
    3017                         tmp= power (ii.getItem().factor(), ii.getItem().exp());
    3018                         iter2.getItem() /= tmp;
    3019                         A /= tmp;
    3020                         CFListIterator iter3= evaluation;
    3021                         for (int jj= A.level(); jj > 2; jj--, iter3++)
    3022                           tmp= tmp (iter3.getItem(), jj);
    3023                         if (!tmp.inCoeffDomain())
    3024                         {
    3025                           int index3= 1;
    3026                           for (iter3= biFactors; iter3.hasItem(); iter3++,
    3027                                                                   index3++)
    3028                           {
    3029                             if (index3 == index2)
    3030                             {
    3031                               iter3.getItem() /= tmp;
    3032                               iter3.getItem() /= Lc (iter3.getItem());
    3033                               break;
    3034                             }
    3035                           }
    3036                         }
    3037                       }
    3038                     }
    3039                   }
    3040                 }
    3041               }
    3042             }
     3227            LCHeuristic (A, LCmultiplier, biFactors, leadingCoeffs2, oldAeval,
     3228                         lengthAeval2, evaluation, oldBiFactors);
    30433229          }
    30443230        }
    … …  
    30483234        for (int i= lengthAeval2-1; i > -1; i--)
    30493235          leadingCoeffs2[i]= CFList();
    3050         prepareLeadingCoeffs (leadingCoeffs2,A.level(),leadingCoeffs, biFactors,
    3051                               evaluation);
    3052         Aeval= evaluateAtEval (A, evaluation, 2);
    3053 
    3054         hh= 1/Lc (Aeval.getFirst());
    3055 
    3056         for (CFListIterator i= Aeval; i.hasItem(); i++)
    3057           i.getItem() *= hh;
    3058 
    3059         A *= hh;
     3236        prepareLeadingCoeffs (leadingCoeffs2, A, Aeval, A.level(),leadingCoeffs,
     3237                              biFactors, evaluation);
    30603238      }
    30613239      factors= CFList();
    … …  
    30803258  {
    30813259    LCheuristic= true;
    3082     int index;
    3083     Variable xx;
    3084     CFList vars1;
    3085     CFFList sqrfMultiplier= sqrFree (LCmultiplier);
    3086     if (sqrfMultiplier.getFirst().factor().inCoeffDomain())
    3087       sqrfMultiplier.removeFirst();
    3088     sqrfMultiplier= sortCFFListByNumOfVars (sqrfMultiplier);
    3089     xx= Variable (2);
    3090     for (iter= oldBiFactors; iter.hasItem(); iter++)
    3091       vars1.append (power (xx, degree (LC (iter.getItem(),1), xx)));
    3092     for (int i= 0; i < lengthAeval2; i++)
    3093     {
    3094       if (oldAeval[i].isEmpty())
    3095         continue;
    3096       xx= oldAeval[i].getFirst().mvar();
    3097       iter2= vars1;
    3098       for (iter= oldAeval[i]; iter.hasItem(); iter++, iter2++)
    3099         iter2.getItem() *= power (xx, degree (LC (iter.getItem(),1), xx));
    3100     }
    3101     CanonicalForm tmp;
    3102     iter2= vars1;
    3103     for (iter= leadingCoeffs2[lengthAeval2-1]; iter.hasItem(); iter++, iter2++)
    3104     {
    3105       tmp= iter.getItem()/LCmultiplier;
    3106       for (int i=1; i <= tmp.level(); i++)
    3107       {
    3108         if (degree (tmp,i) > 0 && (degree (iter2.getItem(),i) > degree (tmp,i)))
    3109           iter2.getItem() /= power (Variable (i), degree (tmp,i));
    3110       }
    3111     }
    3112     int multi;
    3113     for (CFFListIterator ii= sqrfMultiplier; ii.hasItem(); ii++)
    3114     {
    3115       multi= 0;
    3116       for (iter= vars1; iter.hasItem(); iter++)
    3117       {
    3118         tmp= iter.getItem();
    3119         while (fdivides (myGetVars (ii.getItem().factor()), tmp))
    3120         {
    3121           multi++;
    3122           tmp /= myGetVars (ii.getItem().factor());
    3123         }
    3124       }
    3125       if (multi == ii.getItem().exp())
    3126       {
    3127         index= 1;
    3128         for (iter= vars1; iter.hasItem(); iter++, index++)
    3129         {
    3130           while (fdivides (myGetVars (ii.getItem().factor()), iter.getItem()))
    3131           {
    3132             int index2= 1;
    3133             for (iter2= leadingCoeffs2[lengthAeval2-1]; iter2.hasItem();iter2++,
    3134                                                                       index2++)
    3135             {
    3136               if (index2 == index)
    3137                 continue;
    3138               else
    3139               {
    3140                 tmp= ii.getItem().factor();
    3141                 iter2.getItem() /= tmp;
    3142                 CFListIterator iter3= evaluation;
    3143                 for (int jj= A.level(); jj > 2; jj--, iter3++)
    3144                   tmp= tmp (iter3.getItem(), jj);
    3145                 if (!tmp.inCoeffDomain())
    3146                 {
    3147                   int index3= 1;
    3148                   for (iter3= biFactors; iter3.hasItem(); iter3++, index3++)
    3149                   {
    3150                     if (index3 == index2)
    3151                     {
    3152                       iter3.getItem() /= tmp;
    3153                       iter3.getItem() /= Lc (iter3.getItem());
    3154                       break;
    3155                     }
    3156                   }
    3157                 }
    3158                 A /= ii.getItem().factor();
    3159               }
    3160             }
    3161             iter.getItem() /= getVars (ii.getItem().factor());
    3162           }
    3163         }
    3164       }
    3165       else
    3166       {
    3167         index= 1;
    3168         for (iter= vars1; iter.hasItem(); iter++, index++)
    3169         {
    3170           if (!fdivides (myGetVars (ii.getItem().factor()), iter.getItem()))
    3171           {
    3172             int index2= 1;
    3173             for (iter2= leadingCoeffs2[lengthAeval2-1];iter2.hasItem();iter2++,
    3174                                                                       index2++)
    3175             {
    3176               if (index2 == index)
    3177               {
    3178                 tmp= power (ii.getItem().factor(), ii.getItem().exp());
    3179                 iter2.getItem() /= tmp;
    3180                 A /= tmp;
    3181                 CFListIterator iter3= evaluation;
    3182                 for (int jj= A.level(); jj > 2; jj--, iter3++)
    3183                   tmp= tmp (iter3.getItem(), jj);
    3184                 if (!tmp.inCoeffDomain())
    3185                 {
    3186                   int index3= 1;
    3187                   for (iter3= biFactors; iter3.hasItem(); iter3++, index3++)
    3188                   {
    3189                     if (index3 == index2)
    3190                     {
    3191                       iter3.getItem() /= tmp;
    3192                       iter3.getItem() /= Lc (iter3.getItem());
    3193                       break;
    3194                     }
    3195                   }
    3196                 }
    3197               }
    3198             }
    3199           }
    3200         }
    3201       }
    3202     }
     3260    LCHeuristic (A, LCmultiplier, biFactors, leadingCoeffs2, oldAeval,
     3261                 lengthAeval2, evaluation, oldBiFactors);
    32033262
    32043263    leadingCoeffs= leadingCoeffs2[lengthAeval2-1];
    32053264    for (int i= lengthAeval2-1; i > -1; i--)
    32063265      leadingCoeffs2[i]= CFList();
    3207     prepareLeadingCoeffs (leadingCoeffs2,A.level(),leadingCoeffs, biFactors,
    3208                           evaluation);
    3209     Aeval= evaluateAtEval (A, evaluation, 2);
    3210 
    3211     hh= 1/Lc (Aeval.getFirst());
    3212 
    3213     for (CFListIterator i= Aeval; i.hasItem(); i++)
    3214       i.getItem() *= hh;
    3215 
    3216     A *= hh;
     3266    prepareLeadingCoeffs (leadingCoeffs2, A, Aeval, A.level(),leadingCoeffs,
     3267                          biFactors, evaluation);
    32173268
    32183269    if (!fdivides (LC (oldA,1),prod (leadingCoeffs2[lengthAeval2-1])))
    … …  
    32833334  if (noOneToOne)
    32843335  {
    3285 
    32863336    if (!LCmultiplierIsConst && LCheuristic)
    32873337    {
Note: See TracChangeset for help on using the changeset viewer.