Changeset ff48aa in git


Ignore:
Timestamp:
Jan 31, 2015, 11:44:20 AM (9 years ago)
Author:
Yue Ren <ren@…>
Branches:
(u'spielwiese', '8e0ad00ce244dfd0756200662572aef8402f13d5')
Children:
5510099a60c7cd4cb8ef47b8e583ed11e4b4ffe3
Parents:
08749da88db85345212e694597d458072913a9c5
git-author:
Yue Ren <ren@mathematik.uni-kl.de>2015-01-31 11:44:20+01:00
git-committer:
Yue Ren <ren@mathematik.uni-kl.de>2015-02-06 13:47:06+01:00
Message:
chg: timing tests begin
Location:
Singular/dyn_modules/gfanlib
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • Singular/dyn_modules/gfanlib/bbfan.cc

    r08749da rff48aa  
    539539  {
    540540    leftv v=u->next;
    541     // if ((v != NULL) && (v->Typ() == INT_CMD))
     541    if ((v != NULL) && (v->Typ() == INT_CMD))
    542542    {
    543543      leftv w=v->next;
    544       // if ((w != NULL) && (w->Typ() == INT_CMD))
     544      if ((w != NULL) && (w->Typ() == INT_CMD))
    545545      {
    546546        gfan::ZFan* zf = (gfan::ZFan*) u->Data();

  • Singular/dyn_modules/gfanlib/groebnerCone.cc

    r08749da rff48aa  
    5959groebnerCone::groebnerCone():
    6060  polynomialIdeal(NULL),
    61   reducedPolynomialIdeal(NULL),
    62   initialPolynomialIdeal(NULL),
    6361  polynomialRing(NULL),
    6462  polyhedralCone(gfan::ZCone(0)),
    … …  
    7068groebnerCone::groebnerCone(const ideal I, const ring r, const tropicalStrategy& currentCase):
    7169  polynomialIdeal(NULL),
    72   reducedPolynomialIdeal(NULL),
    73   initialPolynomialIdeal(NULL),
    7470  polynomialRing(NULL),
    7571  currentStrategy(&currentCase)
    7672{
    7773  assume(checkPolynomialInput(I,r));
    78   if (I)
    79   {
    80     polynomialIdeal = id_Copy(I,r);
    81     reducedPolynomialIdeal = id_Copy(I,r);
    82   }
     74  if (I) polynomialIdeal = id_Copy(I,r);
    8375  if (r) polynomialRing = rCopy(r);
    84   currentCase.pReduce(polynomialIdeal,r);
    85   currentCase.reduce(reducedPolynomialIdeal,polynomialRing);
     76  ideal redI = id_Copy(polynomialIdeal,polynomialRing);
     77  currentCase.pReduce(redI,polynomialRing);
     78  currentCase.reduce(redI,polynomialRing);
    8679
    8780  int n = rVar(polynomialRing);
    … …  
    9285  gfan::ZVector tailexpw = gfan::ZVector(n);
    9386  gfan::ZMatrix inequalities = gfan::ZMatrix(0,n);
    94   for (int i=0; i<idSize(reducedPolynomialIdeal); i++)
    95   {
    96     g = reducedPolynomialIdeal->m[i];
     87  for (int i=0; i<idSize(redI); i++)
     88  {
     89    g = redI->m[i];
    9790    if (g)
    9891    {
    … …  
    121114  polyhedralCone.canonicalize();
    122115  interiorPoint = polyhedralCone.getRelativeInteriorPoint();
    123   initialPolynomialIdeal = initial(reducedPolynomialIdeal,polynomialRing,interiorPoint);
    124116  assume(checkOrderingAndCone(polynomialRing,polyhedralCone));
     117  id_Delete(&redI,polynomialRing);
    125118}
    126119
    … …  
    134127groebnerCone::groebnerCone(const ideal I, const ring r, const gfan::ZVector& w, const tropicalStrategy& currentCase):
    135128  polynomialIdeal(NULL),
    136   reducedPolynomialIdeal(NULL),
    137   initialPolynomialIdeal(NULL),
    138129  polynomialRing(NULL),
    139130  currentStrategy(&currentCase)
    140131{
    141132  assume(checkPolynomialInput(I,r));
    142   if (I)
    143   {
    144     polynomialIdeal = id_Copy(I,r);
    145     reducedPolynomialIdeal = id_Copy(I,r);
    146   }
     133  if (I) polynomialIdeal = id_Copy(I,r);
    147134  if (r) polynomialRing = rCopy(r);
    148   currentCase.pReduce(polynomialIdeal,r);
    149   currentCase.reduce(reducedPolynomialIdeal,polynomialRing);
     135  ideal redI = id_Copy(polynomialIdeal,polynomialRing);
     136  currentCase.pReduce(redI,polynomialRing);
     137  currentCase.reduce(redI,polynomialRing);
    150138
    151139  int n = rVar(polynomialRing);
    … …  
    153141  gfan::ZMatrix equations = gfan::ZMatrix(0,n);
    154142  int* expv = (int*) omAlloc((n+1)*sizeof(int));
    155   for (int i=0; i<idSize(reducedPolynomialIdeal); i++)
    156   {
    157     poly g = reducedPolynomialIdeal->m[i];
     143  for (int i=0; i<idSize(redI); i++)
     144  {
     145    poly g = redI->m[i];
    158146    if (g)
    159147    {
    … …  
    186174  polyhedralCone.canonicalize();
    187175  interiorPoint = polyhedralCone.getRelativeInteriorPoint();
    188   initialPolynomialIdeal = initial(reducedPolynomialIdeal,polynomialRing,interiorPoint);
    189176  assume(checkOrderingAndCone(polynomialRing,polyhedralCone));
     177  id_Delete(&redI,polynomialRing);
    190178}
    191179
    … …  
    196184groebnerCone::groebnerCone(const ideal I, const ring r, const gfan::ZVector& u, const gfan::ZVector& w, const tropicalStrategy& currentCase):
    197185  polynomialIdeal(NULL),
    198   reducedPolynomialIdeal(NULL),
    199   initialPolynomialIdeal(NULL),
    200186  polynomialRing(NULL),
    201187  currentStrategy(&currentCase)
    202188{
    203189  assume(checkPolynomialInput(I,r));
    204   if (I)
    205   {
    206     polynomialIdeal = id_Copy(I,r);
    207     reducedPolynomialIdeal = id_Copy(I,r);
    208   }
     190  if (I) polynomialIdeal = id_Copy(I,r);
    209191  if (r) polynomialRing = rCopy(r);
    210   currentCase.pReduce(polynomialIdeal,r);
    211   currentCase.reduce(reducedPolynomialIdeal,polynomialRing);
     192  ideal redI = id_Copy(polynomialIdeal,polynomialRing);
     193  currentCase.pReduce(redI,polynomialRing);
     194  currentCase.reduce(redI,polynomialRing);
    212195
    213196  int n = rVar(polynomialRing);
    … …  
    215198  gfan::ZMatrix equations = gfan::ZMatrix(0,n);
    216199  int* expv = (int*) omAlloc((n+1)*sizeof(int));
    217   for (int i=0; i<idSize(reducedPolynomialIdeal); i++)
    218   {
    219     poly g = reducedPolynomialIdeal->m[i];
     200  for (int i=0; i<idSize(redI); i++)
     201  {
     202    poly g = redI->m[i];
    220203    if (g)
    221204    {
    … …  
    249232  polyhedralCone.canonicalize();
    250233  interiorPoint = polyhedralCone.getRelativeInteriorPoint();
    251   initialPolynomialIdeal = initial(reducedPolynomialIdeal,polynomialRing,interiorPoint);
    252234  assume(checkOrderingAndCone(polynomialRing,polyhedralCone));
     235  id_Delete(&redI,polynomialRing);
    253236}
    254237
    … …  
    256239groebnerCone::groebnerCone(const ideal I, const ideal inI, const ring r, const tropicalStrategy& currentCase):
    257240  polynomialIdeal(id_Copy(I,r)),
    258   reducedPolynomialIdeal(id_Copy(I,r)),
    259   initialPolynomialIdeal(id_Copy(inI,r)),
    260241  polynomialRing(rCopy(r)),
    261242  currentStrategy(&currentCase)
    … …  
    263244  assume(checkPolynomialInput(I,r));
    264245  assume(checkPolynomialInput(inI,r));
    265   currentCase.pReduce(polynomialIdeal,r);
    266   currentStrategy->reduce(reducedPolynomialIdeal,polynomialRing);
    267   // currentStrategy->reduce(initialPolynomialIdeal,polynomialRing);
     246
     247  ideal redI = id_Copy(polynomialIdeal,polynomialRing);
     248  currentCase.pReduce(redI,polynomialRing);
     249  currentCase.reduce(redI,polynomialRing);
    268250
    269251  int n = rVar(r);
    270252  gfan::ZMatrix equations = gfan::ZMatrix(0,n);
    271253  int* expv = (int*) omAlloc((n+1)*sizeof(int));
    272   for (int i=0; i<idSize(initialPolynomialIdeal); i++)
    273   {
    274     poly g = initialPolynomialIdeal->m[i];
     254  for (int i=0; i<idSize(inI); i++)
     255  {
     256    poly g = inI->m[i];
    275257    if (g)
    276258    {
    … …  
    286268  }
    287269  gfan::ZMatrix inequalities = gfan::ZMatrix(0,n);
    288   for (int i=0; i<idSize(reducedPolynomialIdeal); i++)
    289   {
    290     poly g = reducedPolynomialIdeal->m[i];
     270  for (int i=0; i<idSize(redI); i++)
     271  {
     272    poly g = redI->m[i];
    291273    if (g)
    292274    {
    … …  
    313295  interiorPoint = polyhedralCone.getRelativeInteriorPoint();
    314296  assume(checkOrderingAndCone(polynomialRing,polyhedralCone));
     297  id_Delete(&redI,polynomialRing);
    315298}
    316299
    317300groebnerCone::groebnerCone(const groebnerCone &sigma):
    318301  polynomialIdeal(NULL),
    319   reducedPolynomialIdeal(NULL),
    320   initialPolynomialIdeal(NULL),
    321302  polynomialRing(NULL),
    322303  polyhedralCone(gfan::ZCone(sigma.getPolyhedralCone())),
    … …  
    328309  assume(checkPolyhedralInput(sigma.getPolyhedralCone(),sigma.getInteriorPoint()));
    329310  if (sigma.getPolynomialIdeal()) polynomialIdeal = id_Copy(sigma.getPolynomialIdeal(),sigma.getPolynomialRing());
    330   if (sigma.getReducedPolynomialIdeal()) reducedPolynomialIdeal = id_Copy(sigma.getReducedPolynomialIdeal(),sigma.getPolynomialRing());
    331   if (sigma.getInitialPolynomialIdeal()) initialPolynomialIdeal = id_Copy(sigma.getInitialPolynomialIdeal(),sigma.getPolynomialRing());
    332311  if (sigma.getPolynomialRing()) polynomialRing = rCopy(sigma.getPolynomialRing());
    333312}
    … …  
    339318  assume(checkPolyhedralInput(polyhedralCone,interiorPoint));
    340319  if (polynomialIdeal) id_Delete(&polynomialIdeal,polynomialRing);
    341   if (reducedPolynomialIdeal) id_Delete(&reducedPolynomialIdeal,polynomialRing);
    342   if (initialPolynomialIdeal) id_Delete(&initialPolynomialIdeal,polynomialRing);
    343320  if (polynomialRing) rDelete(polynomialRing);
    344321}
    … …  
    442419   *   to obtain an initial form with respect to interiorPoint+e*facetNormal,
    443420   *   for e>0 sufficiently small */
    444   std::pair<ideal,ring> flipped = currentStrategy->computeFlip(reducedPolynomialIdeal,polynomialRing,interiorPoint,facetNormal);
     421  std::pair<ideal,ring> flipped = currentStrategy->computeFlip(polynomialIdeal,polynomialRing,interiorPoint,facetNormal);
    445422  assume(checkPolynomialInput(flipped.first,flipped.second));
    446423  groebnerCone flippedCone(flipped.first, flipped.second, interiorPoint, facetNormal, *currentStrategy);

  • Singular/dyn_modules/gfanlib/groebnerCone.h

    r08749da rff48aa  
    3535  ideal polynomialIdeal;
    3636  /**
    37    * reduced form of the ideal from which the equations and inequalities can be read
    38    */
    39   ideal reducedPolynomialIdeal;
    40   /**
    41    * generators of the initial ideal
    42    */
    43   ideal initialPolynomialIdeal;
    44   /**
    4537   * ring in which the ideal exists
    4638   */
    … …  
    7466
    7567  ideal getPolynomialIdeal() const { return polynomialIdeal; };
    76   ideal getReducedPolynomialIdeal() const { return reducedPolynomialIdeal; };
    77   ideal getInitialPolynomialIdeal() const { return initialPolynomialIdeal; };
    7868  ring getPolynomialRing() const { return polynomialRing; };
    7969  gfan::ZCone getPolyhedralCone() const { return polyhedralCone; };

  • Singular/dyn_modules/gfanlib/startingCone.cc

    r08749da rff48aa  
    6464  int dim = zc.dimension();
    6565  return (linDim+1)==dim;
     66}
     67
     68
     69/**
     70 * Computes a starting point outside the lineatliy space by traversing the Groebner fan,
     71 * checking each cone whether it contains a ray in the tropical variety.
     72 * Returns a point in the tropical variety and a maximal Groebner cone containing the point.
     73 **/
     74std::pair<gfan::ZVector,groebnerCone> tropicalStartingPoint(const ideal I, const ring r, const tropicalStrategy& currentStrategy)
     75{
     76  // start by computing a maximal Groebner cone and
     77  // check whether one of its rays lies in the tropical variety
     78  const groebnerCone sigma(I,r,currentStrategy);
     79  gfan::ZVector startingPoint = sigma.tropicalPoint();
     80  if (startingPoint.size() > 0)
     81    return std::make_pair(startingPoint,sigma);
     82
     83  // if not, traverse the groebnerFan and until such a cone is found
     84  // and return the maximal cone together with a point in its ray
     85  groebnerCones groebnerFan;
     86  groebnerCones workingList;
     87  workingList.insert(sigma);
     88  while (!workingList.empty())
     89  {
     90    const groebnerCone sigma = *(workingList.begin());
     91    groebnerCones neighbours = sigma.groebnerNeighbours();
     92    for (groebnerCones::iterator tau = neighbours.begin(); tau!=neighbours.end(); tau++)
     93    {
     94      if (groebnerFan.count(*tau) == 0)
     95      {
     96        if (workingList.count(*tau) == 0)
     97        {
     98          startingPoint = tau->tropicalPoint();
     99          if (startingPoint.size() > 0)
     100            return std::make_pair(startingPoint,*tau);
     101        }
     102        workingList.insert(*tau);
     103      }
     104    }
     105    groebnerFan.insert(sigma);
     106    workingList.erase(sigma);
     107  }
     108
     109  // return some trivial output, if such a cone cannot be found
     110  gfan::ZVector emptyVector = gfan::ZVector(0);
     111  groebnerCone emptyCone = groebnerCone();
     112  return std::pair<gfan::ZVector,groebnerCone>(emptyVector,emptyCone);
    66113}
    67114

  • Singular/dyn_modules/gfanlib/std_wrapper.cc

    r08749da rff48aa  
    1010
    1111  intvec* nullVector = NULL;
    12   ideal stdI = kStd(I,currRing->qideal,h,&nullVector);
     12  ideal stdI = kStd(I,currRing->qideal,h,&nullVector); // there is still a memory leak here!!!
     13  id_DelDiv(stdI,currRing);
     14  idSkipZeroes(stdI);
    1315
    1416  if (origin != r)

  • Singular/dyn_modules/gfanlib/tropical.cc

    r08749da rff48aa  
    235235  p->iiAddCproc("","groebnerCone",FALSE,groebnerCone);
    236236  p->iiAddCproc("","maximalGroebnerCone",FALSE,maximalGroebnerCone);
     237  p->iiAddCproc("","homogeneitySpace",FALSE,homogeneitySpace);
    237238  p->iiAddCproc("","initial",FALSE,initial);
    238239  // p->iiAddCproc("","tropicalNeighbours",FALSE,tropicalNeighbours);
    … …  
    276277  // p->iiAddCproc("","ppreduceInitially",FALSE,ppreduceInitially);
    277278  // p->iiAddCproc("","ttreduceInitially",FALSE,ttreduceInitially);
    278   // p->iiAddCproc("","homogeneitySpace",FALSE,homogeneitySpace);
    279 }
     279  p->iiAddCproc("","homogeneitySpace",FALSE,homogeneitySpace);
     280}

  • Singular/dyn_modules/gfanlib/tropicalCurves.cc

    r08749da rff48aa  
    131131   * If all initial ideals are monomial free, then we have our tropical curve */
    132132  // gfan::ZFan* zf = toFanStar(C);
    133   // std::cout << zf->toString();
     133  // std::cout << zf->toString(2+4+8+128) << std::endl;
    134134  // delete zf;
    135135  for (std::set<gfan::ZCone>::iterator zc=C.begin(); zc!=C.end();)
    … …  
    137137    gfan::ZVector w = zc->getRelativeInteriorPoint();
    138138    gfan::ZMatrix W = zc->generatorsOfSpan();
     139    // std::cout << zc->extremeRays() << std::endl;
    139140
    140141    ring s = genericlyWeightedOrdering(r,u,w,W,currentStrategy);
    … …  
    148149
    149150    poly mons = currentStrategy.checkInitialIdealForMonomial(ininIs,s,w);
    150     // poly mons = checkForMonomialViaSuddenSaturation(ininIs,s);
    151151    if (mons)
    152152    {
     153      // std::cout << "computing witness in tropical star!" << std::endl;
    153154      poly gs = witness(mons,inIsSTD,ininIs,s);
    154155      C = intersect(C,tropicalVariety(gs,s,currentStrategy),d);
    … …  
    161162      zc = C.begin();
    162163      // gfan::ZFan* zf = toFanStar(C);
    163       // std::cout << zf->toString();
     164      // std::cout << zf->toString(2+4+8+128) << std::endl;
    164165      // delete zf;
    165166      id_Delete(&inIs,s);
    … …  
    170171    else
    171172    {
    172       gfan::ZVector wNeg = -w;
     173      id_Delete(&inIs,s);
     174      id_Delete(&inIsSTD,s);
     175      id_Delete(&ininIs,s);
     176      rDelete(s);
     177
     178      gfan::ZVector wNeg = currentStrategy.negateWeight(w);
    173179      if (zc->contains(wNeg))
    174180      {
    … …  
    183189
    184190        mons = currentStrategy.checkInitialIdealForMonomial(ininIs,s,wNeg);
    185         // mons = checkForMonomialViaSuddenSaturation(ininIs,s);
    186191        if (mons)
    187192        {
    … …  
    217222{
    218223  std::set<gfan::ZCone> C = tropicalStar(I,r,u,currentStrategy);
    219   gfan::ZFan* zf = toFanStar(C);
     224  // gfan::ZFan* zf = toFanStar(C);
    220225  // std::cout << zf->toString();
    221   delete zf;
     226  // delete zf;
    222227  gfan::ZMatrix raysOfC(0,u.size());
    223228  if (!currentStrategy.restrictToLowerHalfSpace())

  • Singular/dyn_modules/gfanlib/tropicalStrategy.h

    r08749da rff48aa  
    259259  }
    260260
     261  gfan::ZVector negateWeight(const gfan::ZVector w) const
     262  {
     263    gfan::ZVector wNeg(w.size());
     264
     265    if (this->isValuationNonTrivial())
     266    {
     267      wNeg[0]=w[0];
     268      for (int i=1; i<w.size(); i++)
     269        wNeg[i]=w[i];
     270    }
     271    else
     272      wNeg = -w;
     273
     274    return wNeg;
     275  }
     276
    261277  /**
    262278   * If valuation trivial, returns a copy of r with a positive weight prepended,

  • Singular/dyn_modules/gfanlib/tropicalVariety.cc

    r08749da rff48aa  
    4242BOOLEAN tropicalVariety(leftv res, leftv args)
    4343{
    44   omUpdateInfo();
    45   Print("usedBytesAfter=%ld\n",om_Info.UsedBytes);
    4644  leftv u = args;
    4745  if ((u!=NULL) && (u->Typ()==IDEAL_CMD))
    … …  
    113111        stdI = id_Copy(I,currRing);
    114112      tropicalStrategy currentStrategy(stdI,p,currRing);
     113      // tropicalStrategy currentStrategy(I,p,currRing);
    115114      gfan::ZFan* tropI = tropicalVariety(currentStrategy);
    116115      res->rtyp = fanID;
Note: See TracChangeset for help on using the changeset viewer.