Changeset e744d9 in git

Timestamp:

Jul 17, 2014, 12:28:18 PM (9 years ago)

Author:

Yue Ren <ren@…>

Branches:

(u'spielwiese', 'a7324b6e0b44a1a8ed3fa4d9ca3e2ff210ddd52c')

Children:

eb836ceccfffe01622457439ed104bca800bc101

Parents:

3c0aa5079c417e92fdfaa03c1d87d73f5b365291

git-author:

Yue Ren <ren@mathematik.uni-kl.de>2014-07-17 12:28:18+02:00

git-committer:

Yue Ren <ren@mathematik.uni-kl.de>2015-02-06 13:47:03+01:00

Message:

chg: status update 17.07.

Files:

• Singular/dyn_modules/gfanlib/Makefile.am (modified) (1 diff)
• Singular/dyn_modules/gfanlib/containsMonomial.cc (modified) (2 diffs)
• Singular/dyn_modules/gfanlib/groebnerCone.cc (modified) (2 diffs)
• Singular/dyn_modules/gfanlib/groebnerCone.h (modified) (1 diff)
• Singular/dyn_modules/gfanlib/initial.cc (modified) (5 diffs)
• Singular/dyn_modules/gfanlib/initial.h (modified) (2 diffs)
• Singular/dyn_modules/gfanlib/startingCone.cc (modified) (4 diffs)
• Singular/dyn_modules/gfanlib/tropicalCurves.cc (modified) (4 diffs)
• dyn_modules/callgfanlib/std_wrapper.cc (added)
• dyn_modules/callgfanlib/std_wrapper.h (added)
• dyn_modules/callgfanlib/tropicalVariety.cc (modified) (2 diffs)
• gfanlib/gfanlib_zcone.cpp (modified) (1 diff)

Singular/dyn_modules/gfanlib/Makefile.am

@@ -1 +1 @@
 ACLOCAL_AMFLAGS = -I ../../m4
 
-SOURCES = gfanlib_exceptions.h callgfanlib_conversion.cc callgfanlib_conversion.h bbcone.cc bbcone.h bbfan.cc bbfan.h bbpolytope.cc bbpolytope.h gfan.h gitfan.cc gitfan.h tropicalVarietyOfPolynomials.h tropicalVarietyOfPolynomials.cc ppinitialReduction.cc ppinitialReduction.h ttinitialReduction.cc ttinitialReduction.h containsMonomial.cc containsMonomial.h adjustWeights.cc adjustWeights.h tropicalStrategy.cc tropicalStrategy.h initial.cc initial.h witness.cc witness.h lift.cc lift.h flip.cc flip.h tropicalCurves.cc tropicalCurves.h groebnerCone.cc groebnerCone.h startingCone.cc startingCone.h tropicalTraversal.cc tropicalTraversal.h tropicalVarietyOfIdeals.cc tropicalVarietyOfIdeals.h tropicalVariety.cc tropicalVariety.h tropical.cc tropical.h gfanlib.cc
+SOURCES = gfanlib_exceptions.h callgfanlib_conversion.cc callgfanlib_conversion.h bbcone.cc bbcone.h bbfan.cc bbfan.h bbpolytope.cc bbpolytope.h gfan.h gitfan.cc gitfan.h std_wrapper.cc std_wrapper.h tropicalVarietyOfPolynomials.h tropicalVarietyOfPolynomials.cc ppinitialReduction.cc ppinitialReduction.h ttinitialReduction.cc ttinitialReduction.h containsMonomial.cc containsMonomial.h adjustWeights.cc adjustWeights.h tropicalStrategy.cc tropicalStrategy.h initial.cc initial.h witness.cc witness.h lift.cc lift.h flip.cc flip.h tropicalCurves.cc tropicalCurves.h groebnerCone.cc groebnerCone.h startingCone.cc startingCone.h tropicalTraversal.cc tropicalTraversal.h tropicalVarietyOfIdeals.cc tropicalVarietyOfIdeals.h tropicalVariety.cc tropicalVariety.h tropical.cc tropical.h gfanlib.cc
 
 MY_CPPFLAGS =  -I${top_srcdir} -I${top_builddir} \

Singular/dyn_modules/gfanlib/containsMonomial.cc

@@ -148 +148 @@
   }
 
-
   J = kStd(J,NULL,isHomog,NULL);
 
@@ -166 +165 @@
 poly checkForMonomialViaSuddenSaturation(const ideal I, const ring r)
 {
-  // assume(rField_is_Ring_Z(currRing));
-
-  // ring s = rCopy0(r);
-  // nKillChar(s->cf);
-  // s->cf = nInitChar(n_Zp,(void*)(long)n_Int(p_GetCoeff(I->m[0],currRing),currRing->cf));
-  // rComplete(s); rChangeCurrRing(s);
-  // int k = idSize(I);
-  // ideal J = idInit(k-1);
-  // nMapFunc nMap = n_SetMap(r->cf,r->cf);
-  // for (int i=1; i<k; i++)
-  // {
-  //   J->m[i-1] = p_PermPoly(I->m[i],NULL,r,r,nMap,NULL,0);
-  //   p_Test(J->m[i-1],currRing);
-  // }
   ring origin = currRing;
   ideal M = idInit(1);

Singular/dyn_modules/gfanlib/groebnerCone.cc

@@ -121 +121 @@
   {
     poly g = polynomialIdeal->m[i];
-    pGetExpV(g,expv);
+    p_GetExpV(g,expv,polynomialRing);
     gfan::ZVector leadexpv = intStar2ZVector(n,expv);
     long d = wDeg(g,polynomialRing,w);
     for (pIter(g); g; pIter(g))
     {
-      pGetExpV(g,expv); gfan::ZVector tailexpv = intStar2ZVector(n,expv);
+      p_GetExpV(g,expv,polynomialRing);
+      gfan::ZVector tailexpv = intStar2ZVector(n,expv);
       if (wDeg(g,polynomialRing,w)==d)
         equations.appendRow(leadexpv-tailexpv);
@@ -134 +135 @@
         inequalities.appendRow(leadexpv-tailexpv);
       }
+    }
+  }
+  omFreeSize(expv,(n+1)*sizeof(int));
+
+  polyhedralCone = gfan::ZCone(inequalities,equations);
+  interiorPoint = polyhedralCone.getRelativeInteriorPoint();
+  assume(checkOrderingAndCone(polynomialRing,polyhedralCone));
+}
+
+groebnerCone::groebnerCone(const ideal I, const ideal inI, const ring r, const tropicalStrategy& currentCase):
+  polynomialIdeal(id_Copy(I,r)),
+  polynomialRing(rCopy(r)),
+  currentStrategy(&currentCase)
+{
+  assume(checkPolynomialInput(I,r));
+  assume(checkPolynomialInput(inI,r));
+  int n = rVar(r);
+  gfan::ZMatrix equations = gfan::ZMatrix(0,n);
+  int* expv = (int*) omAlloc((n+1)*sizeof(int));
+  for (int i=0; i<idSize(inI); i++)
+  {
+    poly g = inI->m[i];
+    p_GetExpV(g,expv,r);
+    gfan::ZVector leadexpv = intStar2ZVector(n,expv);
+    for (pIter(g); g; pIter(g))
+    {
+      p_GetExpV(g,expv,r);
+      gfan::ZVector tailexpv = intStar2ZVector(n,expv);
+      equations.appendRow(leadexpv-tailexpv);
+    }
+  }
+  gfan::ZMatrix inequalities = gfan::ZMatrix(0,n);
+  for (int i=0; i<idSize(I); i++)
+  {
+    poly g = I->m[i];
+    p_GetExpV(g,expv,r);
+    gfan::ZVector leadexpv = intStar2ZVector(n,expv);
+    for (pIter(g); g; pIter(g))
+    {
+      p_GetExpV(g,expv,r);
+      gfan::ZVector tailexpv = intStar2ZVector(n,expv);
+      inequalities.appendRow(leadexpv-tailexpv);
     }
   }

Singular/dyn_modules/gfanlib/groebnerCone.h

@@ -32 +32 @@
   groebnerCone(const ideal I, const ring r, const tropicalStrategy& currentCase);
   groebnerCone(const ideal I, const ring r, const gfan::ZVector& w, const tropicalStrategy& currentCase);
+  groebnerCone(const ideal I, const ideal inI, const ring r, const tropicalStrategy& currentCase);
   groebnerCone(const groebnerCone& sigma);
   ~groebnerCone();

Singular/dyn_modules/gfanlib/initial.cc

@@ -23 +23 @@
     d += p_GetExp(p,i+1,r)*w[i].toInt();
   }
+  return d;
+}
+
+/***
+ * Computes the weighted multidegree of the leading term of p with respect to W.
+ * The weighted multidegree is a vector whose i-th entry is the weighted degree
+ * with respect to the i-th row vector of W.
+ **/
+gfan::ZVector WDeg(const poly p, const ring r, const gfan::ZMatrix W)
+{
+  gfan::ZVector d = gfan::ZVector(W.getHeight());
+  for (int i=0; i<W.getHeight(); i++)
+    d[i] = wDeg(p,r,W[i]);
   return d;
 }
@@ -81 +94 @@
 
 /***
- * Returns the first terms of p of same weighted degree under w,
- * this is not necessarily the initial form of p with respect to w!
+ * Returns the initial form of p with respect to w
  **/
 poly initial(const poly p, const ring r, const gfan::ZVector w)
 {
-  int n = r->N;
-  int* expv = (int*) omAlloc(n*sizeof(int));
   poly q0 = p_Head(p,r);
   poly q1 = q0;
@@ -93 +103 @@
   for (poly currentTerm = p->next; currentTerm; pIter(currentTerm))
   {
-    if (wDeg(currentTerm,r,w)==d)
+    long e = wDeg(currentTerm,r,w);
+    if (e>d)
     {
-      pNext(q1) = p_Head(currentTerm,r);
-      pIter(q1);
+      p_Delete(&q0,r);
+      q0 = p_Head(p,r);
+      q1 = q0;
+      d = e;
     }
-  }
-  omFreeSize(expv,n*sizeof(int));
+    else
+      if (e==d)
+      {
+        pNext(q1) = p_Head(currentTerm,r);
+        pIter(q1);
+      }
+  }
   return q0;
 }
@@ -105 +123 @@
 /***
  * Runs the above procedure over all generators of an ideal.
+ * Returns the initial ideal if and only if the weight is in the maximal Groebner cone
+ * of the current ordering.
  **/
 ideal initial(const ideal I, const ring r, const gfan::ZVector w)
@@ -113 +133 @@
   return inI;
 }
+
+
+/***
+ * Returns the initial form of p with respect to W,
+ * i.e. the sum over all terms of p with highest multidegree with respect to W.
+ **/
+poly initial(const poly p, const ring r, const gfan::ZMatrix W)
+{
+  int n = rVar(r);
+  poly q0 = p_Head(p,r);
+  poly q1 = q0;
+  gfan::ZVector d = WDeg(p,r,W);
+  for (poly currentTerm = p->next; currentTerm; pIter(currentTerm))
+  {
+    gfan::ZVector e = WDeg(currentTerm,r,W);
+    if (d<e)
+    {
+      p_Delete(&q0,r);
+      q0 = p_Head(p,r);
+      q1 = q0;
+      d = e;
+    }
+    else
+      if (d==e)
+      {
+        pNext(q1) = p_Head(currentTerm,r);
+        pIter(q1);
+      }
+  }
+  return q0;
+}
+
+/***
+ * Runs the above procedure over all generators of an ideal.
+ * Returns the initial ideal if and only if the weight is in the maximal Groebner cone
+ * of the current ordering.
+ **/
+ideal initial(const ideal I, const ring r, const gfan::ZMatrix W)
+{
+  int k = idSize(I); ideal inI = idInit(k);
+  for (int i=0; i<k; i++)
+    inI->m[i] = initial(I->m[i],r,W);
+  return inI;
+}
+
 
 #ifndef NDEBUG

Singular/dyn_modules/gfanlib/initial.h

@@ -14 +14 @@
  **/
 long wDeg(const poly p, const ring r, const gfan::ZVector w);
+
+/***
+ * Computes the weighted multidegree of the leading term of p with respect to W.
+ * The weighted multidegree is a vector whose i-th entry is the weighted degree
+ * with respect to the i-th row vector of W.
+ **/
+gfan::ZVector WDeg(const poly p, const ring r, const gfan::ZMatrix W);
 
 /***
@@ -32 +39 @@
 poly initial(const poly p, const ring r, const gfan::ZVector w);
 ideal initial(const ideal I, const ring r, const gfan::ZVector w);
-
+poly initial(const poly p, const ring r, const gfan::ZMatrix W);
+poly initial(const ideal I, const ring r, const gfan::ZMatrix W);
 
 

Singular/dyn_modules/gfanlib/startingCone.cc

@@ -40 +40 @@
  * containing the point.
  **/
-std::pair<gfan::ZVector,groebnerCone> tropicalStartingPointViaGroebnerFan(const ideal I, const ring r, const tropicalStrategy& currentStrategy)
+std::pair<gfan::ZVector,groebnerCone> tropicalStartingDataViaGroebnerFan(const ideal I, const ring r, const tropicalStrategy& currentStrategy)
 {
   currentStrategy.reduce(I,r);
@@ -84 +84 @@
     ideal I = (ideal) u->Data();
     tropicalStrategy currentStrategy(I,currRing);
-    std::pair<gfan::ZVector,groebnerCone> startingData = tropicalStartingPointViaGroebnerFan(I,currRing,currentStrategy);
+    std::pair<gfan::ZVector,groebnerCone> startingData = tropicalStartingDataViaGroebnerFan(I,currRing,currentStrategy);
     gfan::ZVector startingPoint = startingData.first;
     res->rtyp = BIGINTMAT_CMD;
@@ -131 +131 @@
 
   gfan::ZCone zc = linealitySpaceOfGroebnerFan(inI,s);
-  gfan::ZVector potentialStartingPoint; groebnerCone ambientMaximalCone;
+  gfan::ZVector startingPoint; groebnerCone ambientMaximalCone;
   while (zc.dimension()<currentStrategy.getDimensionOfIdeal())
   {
-    std::pair<gfan::ZVector,groebnerCone> startingData = tropicalStartingPointViaGroebnerFan(inI,s,currentStrategy);
-    potentialStartingPoint = startingData.first;
+    std::pair<gfan::ZVector,groebnerCone> startingData = tropicalStartingDataViaGroebnerFan(inI,s,currentStrategy);
+    startingPoint = startingData.first;
     ambientMaximalCone = groebnerCone(startingData.second);
 
@@ -142 +142 @@
     s = ambientMaximalCone.getPolynomialRing();
 
-    inI = sloppyInitial(inI,s,potentialStartingPoint);
+    inI = sloppyInitial(inI,s,startingPoint);
     zc = linealitySpaceOfGroebnerFan(inI,s);
   }
 
   ideal J = lift(I,r,inI,s);
+  groebnerCone tropicalStartingCone(J,inI,s,currentStrategy);
   id_Delete(&inI,s);
-  groebnerCone tropicalStartingCone(J,s,potentialStartingPoint,currentStrategy);
   id_Delete(&J,s);
 

Singular/dyn_modules/gfanlib/tropicalCurves.cc

@@ -44 +44 @@
 
 /***
- * Given a weight w and k more weights E[1], ..., E[h] stored as row vectors of a matrix E,
- + returns a ring whose ordering is weighted with respect to any
- * w+\varepsilon_1*E[1]+...+\varepsilon_k*E[h] for \varepsilon_i sufficiently small.
- * In particular, if E[1], ..., E[h] generate a vector space of dimension d,
- * this ordering can be used to compute a Groebner cone of dimension d containing w.
- **/
-static ring genericlyWeightedOrdering(const ring r, const gfan::ZVector w, const gfan::ZMatrix E,
-                                      const tropicalStrategy& currentStrategy)
-{
-  int n = r->N;
+ * Given a ring r, weights u, w, and a matrix E, returns a copy of r whose ordering is,
+ * for any ideal homogeneous with respect to u, weighted with respect to u and
+ * whose tiebreaker is genericly weighted with respect to v and E in the following sense:
+ * the ordering "lies" on the affine space A running through v and spanned by the row vectors of E,
+ * and it lies in a Groebner cone of dimension at least rank(E)=dim(A).
+ **/
+static ring genericlyWeightedOrdering(const ring r, const gfan::ZVector u, const gfan::ZVector w,
+                                      const gfan::ZMatrix W, const tropicalStrategy& currentStrategy)
+{
+  int n = rVar(r);
   int h = E.getHeight();
 
@@ -59 +59 @@
   ring s = rCopy0(r);
   omFree(s->order);
-  s->order  = (int*) omAlloc0((h+3)*sizeof(int));
+  s->order  = (int*) omAlloc0((h+4)*sizeof(int));
   omFree(s->block0);
-  s->block0 = (int*) omAlloc0((h+3)*sizeof(int));
+  s->block0 = (int*) omAlloc0((h+4)*sizeof(int));
   omFree(s->block1);
-  s->block1 = (int*) omAlloc0((h+3)*sizeof(int));
+  s->block1 = (int*) omAlloc0((h+4)*sizeof(int));
   for (int j=0; s->wvhdl[j]; j++) omFree(s->wvhdl[j]);
   omFree(s->wvhdl);
-  s->wvhdl  = (int**) omAlloc0((h+3)*sizeof(int*));
-
-  /* construct a new ordering and keep an eye out for weight overflows */
+  s->wvhdl  = (int**) omAlloc0((h+4)*sizeof(int*));
+
+  /* construct a new ordering as describe above */
   bool overflow;
   s->order[0] = ringorder_a;
   s->block0[0] = 1;
   s->block1[0] = n;
-  s->wvhdl[0] = ZVectorToIntStar(w,overflow);
-  for (int j=1; j<h; j++)
-  {
-    s->order[j] = ringorder_a;
-    s->block0[j] = 1;
-    s->block1[j] = n;
-    s->wvhdl[j] = ZVectorToIntStar(currentStrategy.adjustWeightUnderHomogeneity(E[j-1],w),overflow);
-  }
-  s->order[h] = ringorder_wp;
-  s->block0[h] = 1;
-  s->block1[h] = n;
-  s->wvhdl[h] = ZVectorToIntStar(currentStrategy.adjustWeightUnderHomogeneity(E[h-1],w),overflow);
-  s->order[h+1] = ringorder_C;
+  gfan::ZVector uAdjusted = currentStrategy.adjustWeightForHomogeneity(u);
+  s->wvhdl[0] = ZVectorToIntStar(uAdjusted,overflow);
+  s->order[1] = ringorder_a;
+  s->block0[1] = 1;
+  s->block1[1] = n;
+  gfan::ZVector wAdjusted = currentStrategy.adjustWeightUnterHomogeneity(w,uAdjusted);
+  s->wvhdl[1] = ZVectorToIntStar(wAdjusted,overflow);
+  for (int j=0; j<h; j++)
+  {
+    s->order[j+2] = ringorder_a;
+    s->block0[j+2] = 1;
+    s->block1[j+2] = n;
+    wAdjusted = currentStrategy.adjustWeightUnderHomogeneity(W[j],uAdjusted);
+    s->wvhdl[j+2] = ZVectorToIntStar(wAdjusted,overflow);
+  }
+  s->order[h+2] = ringorder_wp;
+  s->block0[h+2] = 1;
+  s->block1[h+2] = n;
+  wAdjusted = currentStrategy.adjustWeightUnderHomogeneity(W[j],uAdjusted);
+  s->wvhdl[h+2] = ZVectorToIntStar(wAdjusted,overflow);
+  s->order[h+3] = ringorder_C;
 
   if (overflow)
@@ -97 +105 @@
 
 /***
- * Given an ideal I which is homogeneous in the later variables of r,
- * whose tropicalization is, modulo its lineality space, a tropical Curve,
- * computes the said tropicalization.
- * At the end of the computation, I will contain a tropical basis.
- * If the dimension of the tropical variety is known beforehand,
- * it can be provided in order to speed up the computation.
- **/
-std::set<gfan::ZCone> tropicalCurve(ideal I, const ring r, const tropicalStrategy currentStrategy)
-{
-  int k = idSize(I);
+ * Let I be an ideal. Given a weight vector u in the relative interior
+ * of a one-codimensional cone of the tropical variety of I and
+ * the initial ideal inI with respect to it, computes the star of the tropical variety in u.
+ **/
+std::set<gfan::ZCone> tropicalStar(ideal inI, const ring r, const gfan::ZVector u,
+                                   const tropicalStrategy currentStrategy)
+{
+  int k = idSize(inI);
+  int d = currentStrategy.getDimensionOfIdeal();
 
   /* Compute the common refinement over all tropical varieties
    * of the polynomials in the generating set */
-  std::set<gfan::ZCone> C = tropicalVariety(I->m[0],r,currentStrategy);
+  std::set<gfan::ZCone> C = tropicalVariety(inI->m[0],r,currentStrategy);
   for (int i=1; i<k; i++)
-    C = intersect(C,tropicalVariety(I->m[i],r,currentStrategy),currentStrategy.getDimensionOfIdeal());
+    C = intersect(C,tropicalVariety(inI->m[i],r,currentStrategy),d);
 
   /* Cycle through all maximal cones of the refinement.
@@ -124 +131 @@
   {
     gfan::ZVector v = zc->getRelativeInteriorPoint();
-    gfan::ZMatrix E = zc->generatorsOfSpan();
-
-    ring s = genericlyWeightedOrdering(r,v,E,currentStrategy);
-    nMapFunc nMap = n_SetMap(r->cf,s->cf);
-    ideal Is = idInit(k);
+    gfan::ZMatrix W = zc->generatorsOfSpan();
+
+    ring s = genericlyWeightedOrdering(r,v,W,currentStrategy);
+    nMapFunc identity = n_SetMap(r->cf,s->cf);
+    ideal inIs = idInit(k);
     for (int j=0; j<k; j++)
-      Is->m[j] = p_PermPoly(I->m[j],NULL,r,s,nMap,NULL,0);
-    ideal inIs = initial(Is,s,E[E.getHeight()-1]);
+      inIs->m[j] = p_PermPoly(inI->m[j],NULL,r,s,identity,NULL,0);
+
+    inIs = gfanlib_kStd_wrapper(inIs,s,isHomog);
+    ideal ininIs = initial(inIs,s,E[E.getHeight()-1]);
 
     poly mons = checkForMonomialViaSuddenSaturation(inIs,s);
     if (mons)
     {
-      poly gs = witness(mons,Is,inIs,s);
-      C = intersect(C,tropicalVariety(gs,s,currentStrategy),currentStrategy.getDimensionOfIdeal());
+      poly gs = witness(mons,inIs,ininIs,s);
+      C = intersect(C,tropicalVariety(gs,s,currentStrategy),d);
       nMapFunc mMap = n_SetMap(s->cf,r->cf);
       poly gr = p_PermPoly(gs,NULL,s,r,mMap,NULL,0);

dyn_modules/callgfanlib/tropicalVariety.cc

@@ -4 +4 @@
 #include <tropicalVarietyOfIdeals.h>
 #include <libpolys/coeffs/numbers.h>
+#include <libpolys/misc/options.h>
 #include <kernel/structs.h>
+
+
+BITSET bitsetSave1, bitsetSave2;
+
+/***
+ * sets option(redSB)
+ **/
+static void setOptionRedSB()
+{
+  SI_SAVE_OPT(bitsetSave1,bitsetSave2);
+  si_opt_1|=Sy_bit(OPT_REDSB);
+}
+
+/***
+ * sets option(noredSB);
+ **/
+static void undoSetOptionRedSB()
+{
+  SI_RESTORE_OPT(bitsetSave1,bitsetSave2);
+}
 
 BOOLEAN tropicalVariety(leftv res, leftv args)
@@ -25 +46 @@
       number p = (number) v->CopyD();
       tropicalStrategy currentStrategy(I,p,currRing);
+      setOptionRedSB();
       gfan::ZFan* tropI = tropicalVariety(I,currRing,currentStrategy);
+      undoSetOptionRedSB();
       res->rtyp = fanID;
       res->data = (char*) tropI;

gfanlib/gfanlib_zcone.cpp

@@ -742 +742 @@
         f<<*this;
         return f.str();
+// =======
+//   std::stringstream s;
+//   s<<"AMBIENT_DIM"<<std::endl;
+//   s<<this->ambientDimension()<<std::endl;
+
+//   gfan::ZMatrix i=this->getInequalities();
+//   if (this->areFacetsKnown())
+//     s<<"FACETS"<<std::endl;
+//   else
+//     s<<"INEQUALITIES"<<std::endl;
+//   s<<i<<std::endl;
+
+//   gfan::ZMatrix e=this->getEquations();
+//   if (this->areImpliedEquationsKnown())
+//     s<<"LINEAR_SPAN"<<std::endl;
+//   else
+//     s<<"EQUATIONS"<<std::endl;
+//   s<<e<<std::endl;
+
+//   gfan::ZMatrix r=this->extremeRays();
+//   s<<"RAYS"<<std::endl;
+//   s<<r<<std::endl;
+
+//   gfan::ZMatrix l=this->generatorsOfLinealitySpace();
+//   s<<"LINEALITY_SPACE"<<std::endl;
+//   s<<l<<std::endl;
+
+//   std::cout << s.str();
+//   return;
+// >>>>>>> chg: status update 17.07.
 }