Changeset afbebe in git


Ignore:
Timestamp:
Oct 9, 2012, 11:11:29 AM (12 years ago)
Author:
Martin Lee <martinlee84@…>
Branches:
(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')
Children:
a25f7a7df8cf584f3b2fa702cf106448e9ceced5
Parents:
becbea965e6c5de8e8ab195c7f480cabc295ac0c
git-author:
Martin Lee <martinlee84@web.de>2012-10-09 11:11:29+02:00
git-committer:
Martin Lee <martinlee84@web.de>2012-10-24 12:26:22+02:00
Message:
chg: deleted some unused code
chg: joined precomputeLeadingCoeff from facFactorize.cc and facFqFactorize.cc
Location:
factory
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • factory/facBivar.cc

    rbecbea rafbebe  
    184184    i++;
    185185  } while (1);
    186 }
    187 
    188 CFList
    189 earlyFactorDetection0 (CanonicalForm& F, CFList& factors,int& adaptedLiftBound,
    190                       DegreePattern& degs, bool& success, int deg)
    191 {
    192   DegreePattern bufDegs1= degs;
    193   DegreePattern bufDegs2;
    194   CFList result;
    195   CFList T= factors;
    196   CanonicalForm buf= F;
    197   CanonicalForm LCBuf= LC (buf, Variable (1));
    198   CanonicalForm g, quot;
    199   CanonicalForm M= power (F.mvar(), deg);
    200   adaptedLiftBound= 0;
    201   int d= degree (F) + degree (LCBuf, F.mvar());
    202   for (CFListIterator i= factors; i.hasItem(); i++)
    203   {
    204     if (!bufDegs1.find (degree (i.getItem(), 1)))
    205       continue;
    206     else
    207     {
    208       g= i.getItem() (0, 1);
    209       g *= LCBuf;
    210       g= mod (g, M);
    211       if (fdivides (LC (g), LCBuf))
    212       {
    213         g= mulMod2 (i.getItem(), LCBuf, M);
    214         g /= content (g, Variable (1));
    215         if (fdivides (g, buf, quot))
    216         {
    217           result.append (g);
    218           buf= quot;
    219           d -= degree (g) + degree (LC (g, Variable (1)), F.mvar());
    220           LCBuf= LC (buf, Variable (1));
    221           T= Difference (T, CFList (i.getItem()));
    222 
    223           // compute new possible degree pattern
    224           bufDegs2= DegreePattern (T);
    225           bufDegs1.intersect (bufDegs2);
    226           bufDegs1.refine ();
    227           if (bufDegs1.getLength() <= 1)
    228           {
    229             result.append (buf);
    230             break;
    231           }
    232         }
    233       }
    234     }
    235   }
    236   adaptedLiftBound= d + 1;
    237   if (d < deg)
    238   {
    239     factors= T;
    240     degs= bufDegs1;
    241     F= buf;
    242     success= true;
    243   }
    244   if (bufDegs1.getLength() <= 1)
    245     degs= bufDegs1;
    246   return result;
    247 }
    248 
    249 
    250 CFList
    251 henselLiftAndEarly0 (CanonicalForm& A, bool& earlySuccess, CFList&
    252                     earlyFactors, DegreePattern& degs, int& liftBound,
    253                     const CFList& uniFactors, const CanonicalForm& eval)
    254 {
    255   int sizeOfLiftPre;
    256   int * liftPre= getLiftPrecisions (A, sizeOfLiftPre, degree (LC (A, 1), 2));
    257 
    258   Variable x= Variable (1);
    259   Variable y= Variable (2);
    260   CFArray Pi;
    261   CFList diophant;
    262   CFList bufUniFactors= uniFactors;
    263   bufUniFactors.insert (LC (A, x));
    264   CFMatrix M= CFMatrix (liftBound, bufUniFactors.length() - 1);
    265   earlySuccess= false;
    266   int newLiftBound= 0;
    267   int smallFactorDeg= tmin (11, liftPre [sizeOfLiftPre- 1] + 1);//this is a tunable parameter
    268   if (smallFactorDeg >= liftBound || degree (A,y) <= 4)
    269     henselLift12 (A, bufUniFactors, liftBound, Pi, diophant, M);
    270   else if (sizeOfLiftPre > 1 && sizeOfLiftPre < 30)
    271   {
    272     henselLift12 (A, bufUniFactors, smallFactorDeg, Pi, diophant, M);
    273     earlyFactors= earlyFactorDetection0 (A, bufUniFactors, newLiftBound,
    274                                         degs, earlySuccess,
    275                                         smallFactorDeg);
    276     if (degs.getLength() > 1 && !earlySuccess &&
    277         smallFactorDeg != liftPre [sizeOfLiftPre-1] + 1)
    278     {
    279       if (newLiftBound > liftPre[sizeOfLiftPre-1]+1)
    280       {
    281         bufUniFactors.insert (LC (A, x));
    282         henselLiftResume12 (A, bufUniFactors, smallFactorDeg,
    283                             liftPre[sizeOfLiftPre-1] + 1, Pi, diophant, M);
    284         earlyFactors= earlyFactorDetection0 (A, bufUniFactors, newLiftBound,
    285                       degs, earlySuccess, liftPre[sizeOfLiftPre-1] + 1);
    286       }
    287     }
    288     else if (earlySuccess)
    289       liftBound= newLiftBound;
    290     int i= sizeOfLiftPre - 1;
    291     while (degs.getLength() > 1 && !earlySuccess && i - 1 >= 0)
    292     {
    293       if (newLiftBound > liftPre[i] + 1)
    294       {
    295         bufUniFactors.insert (LC (A, x));
    296         henselLiftResume12 (A, bufUniFactors, liftPre[i] + 1,
    297                             liftPre[i-1] + 1, Pi, diophant, M);
    298         earlyFactors= earlyFactorDetection0 (A, bufUniFactors, newLiftBound,
    299                       degs, earlySuccess, liftPre[i-1] + 1);
    300       }
    301       else
    302       {
    303         liftBound= newLiftBound;
    304         break;
    305       }
    306       i--;
    307     }
    308     if (earlySuccess)
    309       liftBound= newLiftBound;
    310     //after here all factors are lifted to liftPre[sizeOfLiftPre-1]
    311   }
    312   else
    313   {
    314     henselLift12 (A, bufUniFactors, smallFactorDeg, Pi, diophant, M);
    315     earlyFactors= earlyFactorDetection0 (A, bufUniFactors, newLiftBound,
    316                                         degs, earlySuccess,
    317                                         smallFactorDeg);
    318     int i= 1;
    319     while ((degree (A,y)/4)*i + 4 <= smallFactorDeg)
    320       i++;
    321     if (degs.getLength() > 1 && !earlySuccess)
    322     {
    323       bufUniFactors.insert (LC (A, x));
    324       henselLiftResume12 (A, bufUniFactors, smallFactorDeg,
    325                           (degree (A, y)/4)*i + 4, Pi, diophant, M);
    326       earlyFactors= earlyFactorDetection0 (A, bufUniFactors, newLiftBound,
    327                     degs, earlySuccess, (degree (A, y)/4)*i + 4);
    328     }
    329     while (degs.getLength() > 1 && !earlySuccess && i < 4)
    330     {
    331       if (newLiftBound > (degree (A, y)/4)*i + 4)
    332       {
    333         bufUniFactors.insert (LC (A, x));
    334         henselLiftResume12 (A, bufUniFactors, (degree (A,y)/4)*i + 4,
    335                             (degree (A, y)/4)*(i+1) + 4, Pi, diophant, M);
    336         earlyFactors= earlyFactorDetection0 (A, bufUniFactors, newLiftBound,
    337                       degs, earlySuccess, (degree (A, y)/4)*(i+1) + 4);
    338       }
    339       else
    340       {
    341         liftBound= newLiftBound;
    342         break;
    343       }
    344       i++;
    345     }
    346     if (earlySuccess)
    347       liftBound= newLiftBound;
    348   }
    349 
    350   return bufUniFactors;
    351186}
    352187

  • factory/facFactorize.cc

    rbecbea rafbebe  
    149149      Aeval [j]= factors;
    150150    }
    151     else if (!Aeval[j].isEmpty())
    152       Aeval[j]=CFList();
    153151  }
    154152}
    155 
    156 int
    157 testFactors (const CanonicalForm& G, const CFList& uniFactors,
    158              CanonicalForm& sqrfPartF, CFList& factors,
    159              CFFList*& bufSqrfFactors, CFList& evalSqrfPartF,
    160              const CFArray& evalPoint)
    161 {
    162   CanonicalForm tmp;
    163   CFListIterator j;
    164   for (CFListIterator i= uniFactors; i.hasItem(); i++)
    165   {
    166     tmp= i.getItem();
    167     if (i.hasItem())
    168       i++;
    169     else
    170       break;
    171     for (j= i; j.hasItem(); j++)
    172     {
    173       if (tmp == j.getItem())
    174         return 0;
    175     }
    176   }
    177 
    178   CanonicalForm F= G;
    179   CFFList sqrfFactorization= sqrFree (F);
    180 
    181   sqrfPartF= 1;
    182   for (CFFListIterator i= sqrfFactorization; i.hasItem(); i++)
    183     sqrfPartF *= i.getItem().factor();
    184 
    185   evalSqrfPartF= evaluateAtEval (sqrfPartF, evalPoint);
    186 
    187   CanonicalForm test= evalSqrfPartF.getFirst() (evalPoint[0], 2);
    188 
    189   if (degree (test) != degree (sqrfPartF, 1) || test.inCoeffDomain())
    190     return 0;
    191 
    192   CFFList sqrfFactors;
    193   CFList tmp2;
    194   int k= 0;
    195   factors= uniFactors;
    196   CFFListIterator iter;
    197   for (CFListIterator i= factors; i.hasItem(); i++, k++)
    198   {
    199     tmp= 1;
    200     sqrfFactors= sqrFree (i.getItem());
    201 
    202     for (iter= sqrfFactors; iter.hasItem(); iter++)
    203     {
    204       tmp2.append (iter.getItem().factor());
    205       tmp *= iter.getItem().factor();
    206     }
    207     i.getItem()= tmp/Lc(tmp);
    208     bufSqrfFactors [k]= sqrfFactors;
    209   }
    210 
    211   for (int i= 0; i < factors.length() - 1; i++)
    212   {
    213     for (int k= i + 1; k < factors.length(); k++)
    214     {
    215       gcdFreeBasis (bufSqrfFactors [i], bufSqrfFactors[k]);
    216     }
    217   }
    218 
    219   factors= CFList();
    220   for (int i= 0; i < uniFactors.length(); i++)
    221   {
    222     if (i == 0)
    223     {
    224       for (iter= bufSqrfFactors [i]; iter.hasItem(); iter++)
    225       {
    226         if (iter.getItem().factor().inCoeffDomain())
    227           continue;
    228         iter.getItem()= CFFactor (iter.getItem().factor()/
    229                                   Lc (iter.getItem().factor()),
    230                                   iter.getItem().exp());
    231         factors.append (iter.getItem().factor());
    232       }
    233     }
    234     else
    235     {
    236       for (iter= bufSqrfFactors [i]; iter.hasItem(); iter++)
    237       {
    238         if (iter.getItem().factor().inCoeffDomain())
    239           continue;
    240         iter.getItem()= CFFactor (iter.getItem().factor()/
    241                                Lc (iter.getItem().factor()),
    242                                iter.getItem().exp());
    243         if (!find (factors, iter.getItem().factor()))
    244           factors.append (iter.getItem().factor());
    245       }
    246     }
    247   }
    248 
    249   test= prod (factors);
    250   tmp= evalSqrfPartF.getFirst() (evalPoint[0],2);
    251   if (test/Lc (test) != tmp/Lc (tmp))
    252     return 0;
    253   else
    254     return 1;
    255 }
    256 
    257 CFList
    258 precomputeLeadingCoeff (const CanonicalForm& LCF, const CFList& LCFFactors,
    259                         const CFList& evaluation,CFList*& differentSecondVarLCs,
    260                         int length, Variable& y
    261                        )
    262 {
    263   y= Variable (1);
    264   if (LCF.inCoeffDomain())
    265   {
    266     CFList result;
    267     for (int i= 1; i <= LCFFactors.length() + 1; i++)
    268       result.append (1);
    269     return result;
    270   }
    271 
    272   CFMap N, M;
    273   CFArray dummy= CFArray (2);
    274   dummy [0]= LCF;
    275   dummy [1]= Variable (2);
    276   compress (dummy, M, N);
    277   CanonicalForm F= M (LCF);
    278   if (LCF.isUnivariate())
    279   {
    280     CFList result;
    281     int LCFLevel= LCF.level();
    282     bool found= false;
    283     if (LCFLevel == 2)
    284     {
    285     //bivariate leading coefficients are already the true leading coefficients
    286       result= LCFFactors;
    287       found= true;
    288     }
    289     else
    290     {
    291       CFListIterator j;
    292       for (int i= 0; i < length; i++)
    293       {
    294         for (j= differentSecondVarLCs[i]; j.hasItem(); j++)
    295         {
    296           if (j.getItem().level() == LCFLevel)
    297           {
    298             found= true;
    299             break;
    300           }
    301         }
    302         if (found)
    303         {
    304           result= differentSecondVarLCs [i];
    305           break;
    306         }
    307       }
    308       if (!found)
    309         result= LCFFactors;
    310     }
    311     if (found)
    312       result.insert (Lc (LCF));
    313     else
    314     {
    315       for (CFListIterator i= result; i.hasItem(); i++)
    316         i.getItem() *= LCF;
    317       result.insert (LCF);
    318     }
    319     return result;
    320   }
    321 
    322   CFList factors= LCFFactors;
    323 
    324   for (CFListIterator i= factors; i.hasItem(); i++)
    325     i.getItem()= M (i.getItem());
    326 
    327   CanonicalForm sqrfPartF;
    328   CFFList * bufSqrfFactors= new CFFList [factors.length()];
    329   CFList evalSqrfPartF, bufFactors;
    330   CFArray evalPoint= CFArray (evaluation.length() - 1);
    331   CFArray buf= CFArray (evaluation.length());
    332   CFArray swap= CFArray (evaluation.length());
    333   CFListIterator iter= evaluation;
    334   CanonicalForm vars=getVars (LCF)*Variable (2);
    335   for (int i= evaluation.length() +1; i > 1; i--, iter++)
    336   {
    337     buf[i-2]=iter.getItem();
    338     if (degree (vars, i) > 0)
    339       swap[M(Variable (i)).level()-1]=buf[i-2];
    340   }
    341   buf= swap;
    342   for (int i= 0; i < evaluation.length() - 1; i++)
    343     evalPoint[i]= buf[i+1];
    344 
    345   //TODO sqrfPartF einmal berechnen nicht stÀndig
    346   int pass= testFactors (F, factors, sqrfPartF,
    347                          bufFactors, bufSqrfFactors, evalSqrfPartF, evalPoint);
    348 
    349   bool foundDifferent= false;
    350   Variable z;
    351   Variable x= y;
    352   int j= 0;
    353   if (!pass)
    354   {
    355     int lev= 0;
    356     CanonicalForm bufF;
    357     CFList bufBufFactors;
    358     for (int i= 0; i < length; i++)
    359     {
    360       if (!differentSecondVarLCs [i].isEmpty())
    361       {
    362         bool allConstant= true;
    363         for (iter= differentSecondVarLCs[i]; iter.hasItem(); iter++)
    364         {
    365           if (!iter.getItem().inCoeffDomain())
    366           {
    367             allConstant= false;
    368             y= Variable (iter.getItem().level());
    369             lev= M(y).level();
    370           }
    371         }
    372         if (allConstant)
    373           continue;
    374 
    375         bufFactors= differentSecondVarLCs [i];
    376         for (iter= bufFactors; iter.hasItem(); iter++)
    377           iter.getItem()= swapvar (iter.getItem(), x, y);
    378         bufF= F;
    379         z= Variable (lev);
    380         bufF= swapvar (bufF, x, z);
    381         bufBufFactors= bufFactors;
    382         evalPoint= CFArray (evaluation.length() - 1);
    383         for (int k= 0; k < evaluation.length()-1; k++)
    384         {
    385           if (N (Variable (k+1)).level() != y.level())
    386             evalPoint[k]= buf[k+1];
    387           else
    388             evalPoint[k]= buf[0];
    389         }
    390         pass= testFactors (bufF, bufBufFactors, sqrfPartF, bufFactors,
    391                            bufSqrfFactors, evalSqrfPartF, evalPoint);
    392         if (pass)
    393         {
    394           foundDifferent= true;
    395           F= bufF;
    396           CFList l= factors;
    397           for (iter= l; iter.hasItem(); iter++)
    398             iter.getItem()= swapvar (iter.getItem(), x, y);
    399           differentSecondVarLCs [i]= l;
    400           j= i;
    401           break;
    402         }
    403         if (!pass && i == length - 1)
    404         {
    405           CFList result;
    406           result.append (LCF);
    407           for (int j= 1; j <= factors.length(); j++)
    408             result.append (1);
    409           result= distributeContent (result, differentSecondVarLCs, length);
    410           if (!result.getFirst().inCoeffDomain())
    411           {
    412             CFListIterator iter= result;
    413             CanonicalForm tmp= iter.getItem();
    414             iter++;
    415             for (; iter.hasItem(); iter++)
    416               iter.getItem() *= tmp;
    417           }
    418 
    419           y= Variable (1);
    420           delete [] bufSqrfFactors;
    421           return result;
    422         }
    423       }
    424     }
    425   }
    426   if (!pass)
    427   {
    428     CFList result;
    429     result.append (LCF);
    430     for (int j= 1; j <= factors.length(); j++)
    431       result.append (LCF);
    432     y= Variable (1);
    433     delete [] bufSqrfFactors;
    434     return result;
    435   }
    436   else
    437     factors= bufFactors;
    438 
    439 
    440   bufFactors= factors;
    441 
    442   CFMap MM, NN;
    443   dummy [0]= sqrfPartF;
    444   dummy [1]= 1;
    445   compress (dummy, MM, NN);
    446   sqrfPartF= MM (sqrfPartF);
    447   CanonicalForm varsSqrfPartF= getVars (sqrfPartF);
    448   for (CFListIterator iter= factors; iter.hasItem(); iter++)
    449     iter.getItem()= MM (iter.getItem());
    450 
    451   CFList evaluation2;
    452   for (int i= 2; i <= varsSqrfPartF.level(); i++)
    453     evaluation2.insert (evalPoint[NN (Variable (i)).level()-2]);
    454 
    455   CFList interMedResult;
    456   CanonicalForm oldSqrfPartF= sqrfPartF;
    457   sqrfPartF= shift2Zero (sqrfPartF, evalSqrfPartF, evaluation2);
    458   if (factors.length() > 1)
    459   {
    460     CanonicalForm LC1= LC (oldSqrfPartF, 1);
    461     CFList leadingCoeffs;
    462     for (int i= 0; i < factors.length(); i++)
    463       leadingCoeffs.append (LC1);
    464 
    465     CFList LC1eval= evaluateAtEval (LC1, evaluation2,2);
    466     CFList oldFactors= factors;
    467     for (CFListIterator i= oldFactors; i.hasItem(); i++)
    468       i.getItem() *= LC1eval.getFirst()/Lc (i.getItem());
    469 
    470     bool success= false;
    471     CanonicalForm oldSqrfPartFPowLC= oldSqrfPartF*power(LC1,factors.length()-1);
    472     CFList heuResult;
    473     if (size (oldSqrfPartFPowLC)/getNumVars (oldSqrfPartFPowLC) < 500 &&
    474         LucksWangSparseHeuristic (oldSqrfPartFPowLC,
    475                                   oldFactors, 2, leadingCoeffs, heuResult))
    476     {
    477       interMedResult= recoverFactors (oldSqrfPartF, heuResult);
    478       if (oldFactors.length() == interMedResult.length())
    479         success= true;
    480     }
    481     if (!success)
    482     {
    483       LC1= LC (evalSqrfPartF.getFirst(), 1);
    484 
    485       CFArray leadingCoeffs= CFArray (factors.length());
    486       for (int i= 0; i < factors.length(); i++)
    487         leadingCoeffs[i]= LC1;
    488 
    489       for (CFListIterator i= factors; i.hasItem(); i++)
    490         i.getItem() *= LC1 (0,2)/Lc (i.getItem());
    491       factors.insert (1);
    492 
    493       CanonicalForm
    494       newSqrfPartF= evalSqrfPartF.getFirst()*power (LC1, factors.length() - 2);
    495 
    496       int liftBound= degree (newSqrfPartF,2) + 1;
    497 
    498       CFMatrix M= CFMatrix (liftBound, factors.length() - 1);
    499       CFArray Pi;
    500       CFList diophant;
    501       nonMonicHenselLift12 (newSqrfPartF, factors, liftBound, Pi, diophant, M,
    502                             leadingCoeffs, false);
    503 
    504       if (sqrfPartF.level() > 2)
    505       {
    506         int* liftBounds= new int [sqrfPartF.level() - 1];
    507         liftBounds [0]= liftBound;
    508         bool noOneToOne= false;
    509         CFList *leadingCoeffs2= new CFList [sqrfPartF.level()-2];
    510         LC1= LC (evalSqrfPartF.getLast(), 1);
    511         CFList LCs;
    512         for (int i= 0; i < factors.length(); i++)
    513           LCs.append (LC1);
    514         leadingCoeffs2 [sqrfPartF.level() - 3]= LCs;
    515         for (int i= sqrfPartF.level() - 1; i > 2; i--)
    516         {
    517           for (CFListIterator j= LCs; j.hasItem(); j++)
    518             j.getItem()= j.getItem() (0, i + 1);
    519           leadingCoeffs2 [i - 3]= LCs;
    520         }
    521         sqrfPartF *= power (LC1, factors.length()-1);
    522 
    523         int liftBoundsLength= sqrfPartF.level() - 1;
    524         for (int i= 1; i < liftBoundsLength; i++)
    525           liftBounds [i]= degree (sqrfPartF, i + 2) + 1;
    526         evalSqrfPartF= evaluateAtZero (sqrfPartF);
    527         evalSqrfPartF.removeFirst();
    528         factors= nonMonicHenselLift (evalSqrfPartF, factors, leadingCoeffs2,
    529                  diophant, Pi, liftBounds, sqrfPartF.level() - 1, noOneToOne);
    530         delete [] leadingCoeffs2;
    531         delete [] liftBounds;
    532       }
    533       for (CFListIterator iter= factors; iter.hasItem(); iter++)
    534         iter.getItem()= reverseShift (iter.getItem(), evaluation2);
    535 
    536       interMedResult=
    537       recoverFactors (reverseShift(evalSqrfPartF.getLast(),evaluation2),
    538                       factors);
    539     }
    540   }
    541   else
    542   {
    543     CanonicalForm contF=content (oldSqrfPartF,1);
    544     factors= CFList (oldSqrfPartF/contF);
    545     interMedResult= recoverFactors (oldSqrfPartF, factors);
    546   }
    547 
    548   for (CFListIterator iter= interMedResult; iter.hasItem(); iter++)
    549     iter.getItem()= NN (iter.getItem());
    550 
    551   CFList result;
    552   CFFListIterator k;
    553   CanonicalForm tmp;
    554   for (int i= 0; i < LCFFactors.length(); i++)
    555   {
    556     tmp= 1;
    557     for (k= bufSqrfFactors[i]; k.hasItem(); k++)
    558     {
    559       int pos= findItem (bufFactors, k.getItem().factor());
    560       if (pos)
    561         tmp *= power (getItem (interMedResult, pos), k.getItem().exp());
    562     }
    563     result.append (tmp);
    564   }
    565 
    566   for (CFListIterator i= result; i.hasItem(); i++)
    567   {
    568     F /= i.getItem();
    569     if (foundDifferent)
    570       i.getItem()= swapvar (i.getItem(), x, z);
    571     i.getItem()= N (i.getItem());
    572   }
    573 
    574   if (foundDifferent)
    575   {
    576     CFList l= differentSecondVarLCs [j];
    577     for (CFListIterator i= l; i.hasItem(); i++)
    578       i.getItem()= swapvar (i.getItem(), y, z);
    579     differentSecondVarLCs [j]= l;
    580     F= swapvar (F, x, z);
    581   }
    582 
    583   result.insert (N (F));
    584 
    585   result= distributeContent (result, differentSecondVarLCs, length);
    586 
    587   if (!result.getFirst().inCoeffDomain())
    588   {
    589     CFListIterator i= result;
    590     CanonicalForm tmp;
    591     if (foundDifferent)
    592       i.getItem()= swapvar (i.getItem(), Variable (2), y);
    593 
    594     tmp= i.getItem();
    595 
    596     i++;
    597     for (; i.hasItem(); i++)
    598     {
    599       if (foundDifferent)
    600         i.getItem()= swapvar (i.getItem(), Variable (2), y)*tmp;
    601       else
    602         i.getItem() *= tmp;
    603     }
    604   }
    605   else
    606     y= Variable (1);
    607 
    608   delete [] bufSqrfFactors;
    609 
    610   return result;
    611 }
    612 
    613153
    614154CFList
    … …  
    839379
    840380  Variable w;
    841   CFList leadingCoeffs= precomputeLeadingCoeff (LC (A, 1), biFactorsLCs,
     381  CFList leadingCoeffs= precomputeLeadingCoeff (LC (A, 1), biFactorsLCs, x,
    842382                                          evaluation, Aeval2, lengthAeval2, w);
    843383

  • factory/facFqFactorize.cc

    rbecbea rafbebe  
    13271327
    13281328  CanonicalForm F= G;
    1329   CFFList sqrfFactorization= squarefreeFactorization (F, alpha);
     1329  CFFList sqrfFactorization;
     1330  if (getCharacteristic() > 0)
     1331    sqrfFactorization= squarefreeFactorization (F, alpha);
     1332  else
     1333    sqrfFactorization= sqrFree (F);
    13301334
    13311335  sqrfPartF= 1;
    … …  
    13481352  {
    13491353    tmp= 1;
    1350     sqrfFactors= squarefreeFactorization (i.getItem(), alpha);
     1354    if (getCharacteristic() > 0)
     1355      sqrfFactors= squarefreeFactorization (i.getItem(), alpha);
     1356    else
     1357      sqrfFactors= sqrFree (i.getItem());
    13511358
    13521359    for (iter= sqrfFactors; iter.hasItem(); iter++)

  • factory/facFqFactorize.h

    rbecbea rafbebe  
    640640             );
    641641
     642/// computes a list l of length length(LCFFactors)+1 of polynomials such that
     643/// prod (l)=LCF, note that the first entry of l may be non constant. Intended
     644/// to be used to precompute coefficients of a polynomial f from its bivariate
     645/// factorizations.
     646///
     647/// @return see above
     648CFList
     649precomputeLeadingCoeff (const CanonicalForm& LCF,       ///<[in] a multivariate
     650                                                        ///< poly
     651                        const CFList& LCFFactors,       ///<[in] a list of
     652                                                        ///< univariate factors
     653                                                        ///< of LCF of level 2
     654                        const Variable& alpha,          ///<[in] algebraic var.
     655                        const CFList& evaluation,       ///<[in] an evaluation
     656                                                        ///< point having
     657                                                        ///< lSecondVarLCs+1
     658                                                        ///< components
     659                        CFList* & differentSecondVarLCs,///<[in] LCs of factors
     660                                                        ///< of f wrt different
     661                                                        ///< second variables
     662                        int lSecondVarLCs,              ///<[in] length of the
     663                                                        ///< above
     664                        Variable& y                     ///<[in,out] if y.level()
     665                                                        ///< is not 1 on output
     666                                                        ///< the second variable
     667                                                        ///< has been changed to
     668                                                        ///< y
     669                       );
     670
    642671#endif
    643672/* FAC_FQ_FACTORIZE_H */
Note: See TracChangeset for help on using the changeset viewer.