Changeset f047b5 in git


Ignore:
Timestamp:
Feb 1, 2012, 10:54:42 AM (11 years ago)
Author:
Martin Lee <martinlee84@…>
Branches:
(u'spielwiese', '0d6b7fcd9813a1ca1ed4220cfa2b104b97a0a003')
Children:
09609a2f4751f0b3b3d459d710552a967e51d5d6
Parents:
a36fcb58f4703ad6ae050f4f3537bc41ed4b2ce4
git-author:
Martin Lee <martinlee84@web.de>2012-02-01 10:54:42+01:00
git-committer:
Oleksandr Motsak <motsak@mathematik.uni-kl.de>2012-02-10 14:16:44+01:00
Message:
chg: deleted unnecessary divisibility test
File:
1 edited

Legend:

Unmodified
Added
Removed

  • factory/facFqBivar.cc

    ra36fcb5 rf047b5  
    327327      else
    328328      {
    329         g= prodMod0 (S, M);
    330         g= mod (g*LCBuf, M);
    331         g /= content (g);
    332         if (fdivides (LC (g), LCBuf))
    333         {
    334           S.insert (LCBuf);
    335           g= prodMod (S, M);
    336           S.removeFirst();
    337           g /= content (g, x);
    338           if (fdivides (g, buf, quot))
     329        S.insert (LCBuf);
     330        g= prodMod (S, M);
     331        S.removeFirst();
     332        g /= content (g, x);
     333        if (fdivides (g, buf, quot))
     334        {
     335          buf2= g (y - eval, y);
     336          buf2 /= Lc (buf2);
     337
     338          if (!k && beta.level() == 1)
    339339          {
    340             buf2= g (y - eval, y);
    341             buf2 /= Lc (buf2);
    342 
    343             if (!k && beta.level() == 1)
     340            if (degree (buf2, alpha) < degMipoBeta)
    344341            {
    345               if (degree (buf2, alpha) < degMipoBeta)
     342              buf= quot;
     343              LCBuf= LC (buf, x);
     344              recombination= true;
     345              appendTestMapDown (result, buf2, info, source, dest);
     346              trueFactor= true;
     347            }
     348          }
     349          else
     350          {
     351            if (!isInExtension (buf2, gamma, k, delta, source, dest))
     352            {
     353              buf= quot;
     354              LCBuf= LC (buf, x);
     355              recombination= true;
     356              appendTestMapDown (result, buf2, info, source, dest);
     357              trueFactor= true;
     358            }
     359          }
     360          if (trueFactor)
     361          {
     362            T= Difference (T, S);
     363            // compute new possible degree pattern
     364            bufDegs2= DegreePattern (T);
     365            bufDegs1.intersect (bufDegs2);
     366            bufDegs1.refine ();
     367            if (T.length() < 2*s || T.length() == s ||
     368                bufDegs1.getLength() == 1)
     369            {
     370              delete [] v;
     371              if (recombination)
    346372              {
    347                 buf= quot;
    348                 LCBuf= LC (buf, x);
    349                 recombination= true;
    350                 appendTestMapDown (result, buf2, info, source, dest);
    351                 trueFactor= true;
     373                appendTestMapDown (result, buf (y - eval, y), info, source,
     374                                    dest);
     375                F= 1;
     376                return result;
     377              }
     378              else
     379              {
     380                appendMapDown (result, F (y - eval, y), info, source, dest);
     381                F= 1;
     382                return result;
    352383              }
    353384            }
    354             else
    355             {
    356               if (!isInExtension (buf2, gamma, k, delta, source, dest))
    357               {
    358                 buf= quot;
    359                 LCBuf= LC (buf, x);
    360                 recombination= true;
    361                 appendTestMapDown (result, buf2, info, source, dest);
    362                 trueFactor= true;
    363               }
    364             }
    365             if (trueFactor)
    366             {
    367               T= Difference (T, S);
    368               // compute new possible degree pattern
    369               bufDegs2= DegreePattern (T);
    370               bufDegs1.intersect (bufDegs2);
    371               bufDegs1.refine ();
    372               if (T.length() < 2*s || T.length() == s ||
    373                   bufDegs1.getLength() == 1)
    374               {
    375                 delete [] v;
    376                 if (recombination)
    377                 {
    378                   appendTestMapDown (result, buf (y - eval, y), info, source,
    379                                      dest);
    380                   F= 1;
    381                   return result;
    382                 }
    383                 else
    384                 {
    385                   appendMapDown (result, F (y - eval, y), info, source, dest);
    386                   F= 1;
    387                   return result;
    388                 }
    389               }
    390               trueFactor= false;
    391               TT= copy (T);
    392               indexUpdate (v, s, T.length(), nosubset);
    393               if (nosubset) break;
    394             }
     385            trueFactor= false;
     386            TT= copy (T);
     387            indexUpdate (v, s, T.length(), nosubset);
     388            if (nosubset) break;
    395389          }
    396390        }
    … …  
    507501      else
    508502      {
    509         g= prodMod0 (S, M);
    510         g= mod (g*LCBuf, M);
    511         g /= content (g);
    512         if (fdivides (LC(g), LCBuf))
    513         {
    514           S.insert (LCBuf);
    515           g= prodMod (S, M);
    516           S.removeFirst();
    517           g /= content (g, x);
    518 
    519           if (fdivides (g, buf, quot))
     503        S.insert (LCBuf);
     504        g= prodMod (S, M);
     505        S.removeFirst();
     506        g /= content (g, x);
     507
     508        if (fdivides (g, buf, quot))
     509        {
     510          recombination= true;
     511          result.append (g);
     512          buf= quot;
     513          LCBuf= LC (buf, x);
     514          T= Difference (T, S);
     515
     516          // compute new possible degree pattern
     517          bufDegs2= DegreePattern (T);
     518          bufDegs1.intersect (bufDegs2);
     519          bufDegs1.refine ();
     520          if (T.length() < 2*s || T.length() == s ||
     521              bufDegs1.getLength() == 1)
    520522          {
    521             recombination= true;
    522             result.append (g);
    523             buf= quot;
    524             LCBuf= LC (buf, x);
    525             T= Difference (T, S);
    526 
    527             // compute new possible degree pattern
    528             bufDegs2= DegreePattern (T);
    529             bufDegs1.intersect (bufDegs2);
    530             bufDegs1.refine ();
    531             if (T.length() < 2*s || T.length() == s ||
    532                 bufDegs1.getLength() == 1)
     523            delete [] v;
     524            if (recombination)
    533525            {
    534               delete [] v;
    535               if (recombination)
    536               {
    537                 result.append (buf);
    538                 F= 1;
    539                 return result;
    540               }
    541               else
    542               {
    543                 result= CFList (F);
    544                 F= 1;
    545                 return result;
    546               }
     526              result.append (buf);
     527              F= 1;
     528              return result;
    547529            }
    548             TT= copy (T);
    549             indexUpdate (v, s, T.length(), nosubset);
    550             if (nosubset) break;
     530            else
     531            {
     532              result= CFList (F);
     533              F= 1;
     534              return result;
     535            }
    551536          }
     537          TT= copy (T);
     538          indexUpdate (v, s, T.length(), nosubset);
     539          if (nosubset) break;
    552540        }
    553541      }
    … …  
    644632    else
    645633    {
    646       g= i.getItem() (0, 1);
    647       g *= LCBuf;
    648       g= mod (g, M);
    649       if (fdivides (LC (g), LCBuf))
    650       {
    651         g= mulMod2 (i.getItem(), LCBuf, M);
    652         g /= content (g, x);
    653         if (fdivides (g, buf, quot))
    654         {
    655           result.append (g);
    656           buf= quot;
    657           d -= degree (g);
    658           LCBuf= LC (buf, x);
    659           T= Difference (T, CFList (i.getItem()));
    660 
    661           // compute new possible degree pattern
    662           bufDegs2= DegreePattern (T);
    663           bufDegs1.intersect (bufDegs2);
    664           bufDegs1.refine ();
    665           if (bufDegs1.getLength() <= 1)
    666           {
    667             result.append (buf);
    668             break;
    669           }
     634      g= mulMod2 (i.getItem(), LCBuf, M);
     635      g /= content (g, x);
     636      if (fdivides (g, buf, quot))
     637      {
     638        result.append (g);
     639        buf= quot;
     640        d -= degree (g);
     641        LCBuf= LC (buf, x);
     642        T= Difference (T, CFList (i.getItem()));
     643
     644        // compute new possible degree pattern
     645        bufDegs2= DegreePattern (T);
     646        bufDegs1.intersect (bufDegs2);
     647        bufDegs1.refine ();
     648        if (bufDegs1.getLength() <= 1)
     649        {
     650          result.append (buf);
     651          break;
    670652        }
    671653      }
    … …  
    717699    else
    718700    {
    719       g= i.getItem() (0, 1);
    720       g *= LCBuf;
    721       g= mod (g, M);
    722       if (fdivides (LC (g), LCBuf))
    723       {
    724         g= mulMod2 (i.getItem(), LCBuf, M);
    725         g /= content (g, x);
    726         if (fdivides (g, buf, quot))
    727         {
    728           buf2= g (y - eval, y);
    729           buf2 /= Lc (buf2);
    730 
    731           if (!k && beta == x)
     701      g= mulMod2 (i.getItem(), LCBuf, M);
     702      g /= content (g, x);
     703      if (fdivides (g, buf, quot))
     704      {
     705        buf2= g (y - eval, y);
     706        buf2 /= Lc (buf2);
     707
     708        if (!k && beta == x)
     709        {
     710          if (degree (buf2, alpha) < degMipoBeta)
    732711          {
    733             if (degree (buf2, alpha) < degMipoBeta)
    734             {
    735               appendTestMapDown (result, buf2, info, source, dest);
    736               buf= quot;
    737               d -= degree (g);
    738               LCBuf= LC (buf, x);
    739               trueFactor= true;
    740             }
     712            appendTestMapDown (result, buf2, info, source, dest);
     713            buf= quot;
     714            d -= degree (g);
     715            LCBuf= LC (buf, x);
     716            trueFactor= true;
    741717          }
    742           else
     718        }
     719        else
     720        {
     721          if (!isInExtension (buf2, gamma, k, delta, source, dest))
    743722          {
    744             if (!isInExtension (buf2, gamma, k, delta, source, dest))
    745             {
    746               appendTestMapDown (result, buf2, info, source, dest);
    747               buf= quot;
    748               d -= degree (g);
    749               LCBuf= LC (buf, x);
    750               trueFactor= true;
    751             }
     723            appendTestMapDown (result, buf2, info, source, dest);
     724            buf= quot;
     725            d -= degree (g);
     726            LCBuf= LC (buf, x);
     727            trueFactor= true;
    752728          }
    753           if (trueFactor)
     729        }
     730        if (trueFactor)
     731        {
     732          T= Difference (T, CFList (i.getItem()));
     733
     734          // compute new possible degree pattern
     735          bufDegs2= DegreePattern (T);
     736          bufDegs1.intersect (bufDegs2);
     737          bufDegs1.refine ();
     738          trueFactor= false;
     739          if (bufDegs1.getLength() <= 1)
    754740          {
    755             T= Difference (T, CFList (i.getItem()));
    756 
    757             // compute new possible degree pattern
    758             bufDegs2= DegreePattern (T);
    759             bufDegs1.intersect (bufDegs2);
    760             bufDegs1.refine ();
    761             trueFactor= false;
    762             if (bufDegs1.getLength() <= 1)
    763             {
    764               buf= buf (y - eval, y);
    765               buf /= Lc (buf);
    766               appendMapDown (result, buf, info, source, dest);
    767               break;
    768             }
     741            buf= buf (y - eval, y);
     742            buf /= Lc (buf);
     743            appendMapDown (result, buf, info, source, dest);
     744            break;
    769745          }
    770746        }
Note: See TracChangeset for help on using the changeset viewer.