source: git/gfanlib/gfanlib_symmetriccomplex.cpp @ e078e0

spielwiese
Last change on this file since e078e0 was c4d065, checked in by Frank Seelisch <seelisch@…>, 13 years ago
coding at Goettingen (cones&fans) git-svn-id: file:///usr/local/Singular/svn/trunk@13677 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 21.3 KB
Line 
1/*
2 * gfanlib_symmetriccomplex.cpp
3 *
4 *  Created on: Nov 16, 2010
5 *      Author: anders
6 */
7
8#include "gfanlib_symmetriccomplex.h"
9#include "gfanlib_polymakefile.h"
10
11#include <sstream>
12#include <iostream>
13
14namespace gfan{
15
16SymmetricComplex::Cone::Cone(std::set<int> const &indices_, int dimension_, Integer multiplicity_, bool sortWithSymmetry, SymmetricComplex const &complex):
17  dimension(dimension_),
18  multiplicity(multiplicity_),
19  isKnownToBeNonMaximalFlag(false),
20  sortKeyPermutation(complex.n)
21{
22  indices=IntVector(indices_.size());
23  int j=0;
24  for(std::set<int>::const_iterator i=indices_.begin();i!=indices_.end();i++,j++)
25    indices[j]=*i;
26
27  ZMatrix const &vertices=complex.getVertices();
28  ZVector sum(vertices.getWidth());
29  for(int i=0;i<indices.size();i++)
30    sum+=vertices[indices[i]];
31
32  if(sortWithSymmetry)
33    {
34      sortKey=complex.sym.orbitRepresentative(sum,&sortKeyPermutation);
35    }
36  else
37    {
38      sortKey=sum;
39    }
40}
41
42
43int SymmetricComplex::indexOfVertex(ZVector const &v)const
44{
45//  std::cerr<<v<<std::endl<<"In";
46//  for(std::map<ZVector,int>::const_iterator i =indexMap.begin();i!=indexMap.end();i++)std::cerr<<i->first;
47
48  std::map<ZVector,int>::const_iterator it=indexMap.find(v);
49  assert(it!=indexMap.end());
50  return it->second;
51}
52
53
54void SymmetricComplex::Cone::remap(SymmetricComplex &complex)
55{
56  ZMatrix const &vertices=complex.getVertices();
57  ZVector sum(vertices.getWidth());
58  for(int i=0;i<indices.size();i++)
59    sum+=vertices[indices[i]];
60
61  int n=sum.size();
62  Permutation const &bestPermutation=sortKeyPermutation;
63
64  assert(bestPermutation.size()==n);
65
66  IntVector indicesNew(indices.size());
67  int I=0;
68  for(int i=0;i<indices.size();i++,I++)
69    {
70      ZVector ny=bestPermutation.apply(complex.vertices[indices[i]]);
71      std::map<ZVector,int>::const_iterator it=complex.indexMap.find(ny);
72      assert(it!=complex.indexMap.end());
73      indicesNew[I]=it->second;
74    }
75  indices=indicesNew;
76}
77
78
79std::set<int> SymmetricComplex::Cone::indexSet()const
80{
81  std::set<int> ret;
82  for(int i=0;i<indices.size();i++)
83    ret.insert(indices[i]);
84
85  return ret;
86}
87
88bool SymmetricComplex::Cone::isSubsetOf(Cone const &c)const
89{
90  int next=0;
91  for(int i=0;i<indices.size();i++)
92    {
93      while(1)
94        {
95          if(next>=c.indices.size())return false;
96          if(indices[i]==c.indices[next])break;
97          next++;
98        }
99    }
100  return true;
101}
102
103
104SymmetricComplex::Cone SymmetricComplex::Cone::permuted(Permutation const &permutation, SymmetricComplex const &complex, bool withSymmetry)const
105{
106  std::set<int> r;
107  for(int i=0;i<indices.size();i++)
108    {
109      ZVector ny=permutation.apply(complex.vertices[indices[i]]);
110      std::map<ZVector,int>::const_iterator it=complex.indexMap.find(ny);
111      if(it==complex.indexMap.end())
112        {
113//          AsciiPrinter(Stderr).printVector(complex.vertices[indices[i]]);
114//          AsciiPrinter(Stderr).printVector(ny);
115
116          assert(0);
117        }
118      r.insert(it->second);
119    }
120
121
122  return Cone(r,dimension,multiplicity,withSymmetry,complex);
123}
124
125
126bool SymmetricComplex::Cone::operator<(Cone const & b)const
127{
128  return sortKey<b.sortKey;
129}
130
131
132bool SymmetricComplex::Cone::isSimplicial(int linealityDim)const
133{
134  return (indices.size()+linealityDim)==dimension;
135}
136
137
138ZMatrix SymmetricComplex::Cone::orthogonalComplement(SymmetricComplex &complex)const
139{
140  ZMatrix l;
141  for(int i=0;i<indices.size();i++)
142    l.appendRow(complex.vertices[indices[i]]);
143
144  return l.reduceAndComputeKernel();
145//  FieldMatrix m=integerMatrixToFieldMatrix(rowsToIntegerMatrix(l,complex.n),Q);
146//  return fieldMatrixToIntegerMatrixPrimitive(m.reduceAndComputeKernel()).getRows();
147}
148
149
150SymmetricComplex::SymmetricComplex(ZMatrix const &rays, ZMatrix const &linealitySpace_, SymmetryGroup const &sym_):
151  n(rays.getWidth()),
152  sym(sym_),
153  dimension(-1),
154  linealitySpace(canonicalizeSubspace(linealitySpace_))
155{
156  assert(rays.getWidth()==linealitySpace.getWidth());
157//  vertices=rowsToIntegerMatrix(v,n);
158  vertices=rays;
159
160  for(int i=0;i<vertices.getHeight();i++)indexMap[vertices[i]]=i;
161}
162
163
164bool SymmetricComplex::contains(Cone const &c)const
165{
166  Cone temp=c;
167  return cones.find(temp)!=cones.end();///////////////////!!!!!!!!!!!!!!!!!!!!!!!
168}
169
170
171void SymmetricComplex::insert(Cone const &c)
172{
173        if(c.dimension>dimension)dimension=c.dimension;
174  if(!contains(c))//#2
175    {
176      cones.insert(c);
177    }
178  else
179    {
180      if(c.isKnownToBeNonMaximal()){cones.erase(c);cones.insert(c);}// mark as non-maximal
181    }
182}
183
184
185int SymmetricComplex::getMaxDim()const
186{
187  return dimension;
188}
189
190
191int SymmetricComplex::getMinDim()const
192{
193  int ret=100000;
194  for(ConeContainer::const_iterator i=cones.begin();i!=cones.end();i++)
195    {
196      if(i->dimension<ret)ret=i->dimension;
197    }
198  return ret;
199}
200
201
202bool SymmetricComplex::isMaximal(Cone const &c)const
203{
204  if(c.isKnownToBeNonMaximal())return false;
205  if(c.dimension==dimension)return true;
206  for(SymmetryGroup::ElementContainer::const_iterator k=sym.elements.begin();k!=sym.elements.end();k++)
207    {
208      Cone c2=c.permuted(*k,*this,false);
209      for(ConeContainer::const_iterator i=cones.begin();i!=cones.end();i++)
210        {
211          if(i->dimension>c.dimension)
212            if(c2.isSubsetOf(*i) && !i->isSubsetOf(c2))return false;
213        }
214    }
215  return true;
216}
217
218/*
219IntVector SymmetricComplex::dimensionsAtInfinity()const
220{
221  /* Using a double description like method this routine computes the
222     dimension of the intersection of each cone in the complex with
223     the plane x_0=0 */
224/*
225  IntVector ret(cones.size());
226
227  int I=0;
228  for(ConeContainer::const_iterator i=cones.begin();i!=cones.end();i++,I++)
229    {
230      ZMatrix raysAtInfinity;
231      for(int j=0;j<i->indices.size();j++)
232        {
233          if(vertices[i->indices[j]][0]==0)raysAtInfinity.push_back(vertices[i->indices[j]]);
234          for(vector<int>::const_iterator k=j;k!=i->indices.end();k++)
235            if(vertices[*j][0]*vertices[*k][0]<0)
236              raysAtInfinity.push_back(((vertices[*j][0]>0)?1:-1)*(vertices[*j][0])*vertices[*k]+
237                                       ((vertices[*k][0]>0)?1:-1)*(vertices[*k][0])*vertices[*j]);
238        }
239      ret[I]=rankOfMatrix(raysAtInfinity);
240    }
241  return ret;
242}
243*/
244
245void SymmetricComplex::buildConeLists(bool onlyMaximal, bool compressed, std::vector<std::vector<IntVector > >*conelist/*, ZMatrix *multiplicities*/)const
246{
247  int dimLow=this->linealitySpace.getHeight();
248  int dimHigh=this->getMaxDim();
249  if(dimHigh<dimLow)dimHigh=dimLow-1;
250  if(conelist)*conelist=std::vector<std::vector<IntVector> >(dimHigh-dimLow+1);
251  for(int d=dimLow;d<=dimHigh;d++)
252    {
253      int numberOfOrbitsOutput=0;
254      int numberOfOrbitsOfThisDimension=0;
255      bool newDimension=true;
256        {
257          int I=0;
258          for(ConeContainer::const_iterator i=cones.begin();i!=cones.end();i++,I++)
259                  if(i->dimension==d)
260                    {
261                      numberOfOrbitsOfThisDimension++;
262              if(!onlyMaximal || isMaximal(*i))
263                {
264                  numberOfOrbitsOutput++;
265                  bool isMax=isMaximal(*i);
266                  bool newOrbit=true;
267                  std::set<std::set<int> > temp;
268                    for(SymmetryGroup::ElementContainer::const_iterator k=sym.elements.begin();k!=sym.elements.end();k++)
269                      {
270                        Cone temp1=i->permuted(*k,*this,false);
271                        temp.insert(temp1.indexSet());
272                        if(compressed)break;
273                    }
274                  for(std::set<std::set<int> >::const_iterator j=temp.begin();j!=temp.end();j++)
275                    {
276                      IntVector temp;
277                      for(std::set<int>::const_iterator k=j->begin();k!=j->end();k++)temp.push_back(*k);
278                      if(conelist)(*conelist)[d-dimLow].push_back(temp);
279 /*                     if(isMax)if(multiplicities)
280                        {
281
282                          *multiplicities << i->multiplicity;
283                          if(group)if(newOrbit)*multiplicities << "\t# New orbit";
284                          if(newDimension)*multiplicities << "\t# Dimension "<<d;
285                          *multiplicities << std::endl;
286                        }*/
287                      newOrbit=false;
288                      newDimension=false;
289                    }
290              }
291                    }
292        }
293    }
294
295}
296
297std::string SymmetricComplex::toStringJustCones(int dimLow, int dimHigh, bool onlyMaximal, bool group, std::ostream *multiplicities, bool compressed, bool tPlaneSort)const
298{
299  std::stringstream ret;
300
301  ZVector additionalSortKeys(cones.size());
302//  if(tPlaneSort)additionalSortKeys=dimensionsAtInfinity();
303//  Integer lowKey=additionalSortKeys.min();
304//  Integer highKey=additionalSortKeys.max();
305
306  for(int d=dimLow;d<=dimHigh;d++)
307    {
308      int numberOfOrbitsOutput=0;
309      int numberOfOrbitsOfThisDimension=0;
310      bool newDimension=true;
311 //     for(int key=lowKey;key<=highKey;key++)
312        {
313          int I=0;
314          for(ConeContainer::const_iterator i=cones.begin();i!=cones.end();i++,I++)
315 //           if(additionalSortKeys[I]==key)
316                  if(i->dimension==d)
317                    {
318                      numberOfOrbitsOfThisDimension++;
319              if(!onlyMaximal || isMaximal(*i))
320                {
321                  numberOfOrbitsOutput++;
322                  bool isMax=isMaximal(*i);
323                  bool newOrbit=true;
324                  std::set<std::set<int> > temp;
325                    for(SymmetryGroup::ElementContainer::const_iterator k=sym.elements.begin();k!=sym.elements.end();k++)
326                      {
327                        Cone temp1=i->permuted(*k,*this,false);
328                        temp.insert(temp1.indexSet());
329                        if(compressed)break;
330                    }
331                  for(std::set<std::set<int> >::const_iterator j=temp.begin();j!=temp.end();j++)
332                    {
333                      ret << "{";
334                      for(std::set<int>::const_iterator a=j->begin();a!=j->end();a++)
335                        {
336                          if(a!=j->begin())ret<<" ";
337                          ret << *a;
338                        }
339                      ret << "}";
340                      if(group)if(newOrbit)ret << "\t# New orbit";
341                      if(newDimension)ret << "\t# Dimension "<<d;
342                      ret <<std::endl;
343                      if(isMax)if(multiplicities)
344                        {
345                          *multiplicities << i->multiplicity;
346                          if(group)if(newOrbit)*multiplicities << "\t# New orbit";
347                          if(newDimension)*multiplicities << "\t# Dimension "<<d;
348                          *multiplicities << std::endl;
349                        }
350                      newOrbit=false;
351                      newDimension=false;
352                    }
353              }
354                    }
355        }
356    }
357
358  return ret.str();
359}
360
361
362ZVector SymmetricComplex::fvector(bool boundedPart)const
363{
364  int min=getMinDim();
365  int dimHigh=getMaxDim();
366  if(dimHigh<min)dimHigh=min-1;
367  ZVector ret(dimHigh-min+1);
368
369  for(ConeContainer::const_iterator i=cones.begin();i!=cones.end();i++)
370    {
371      bool doAdd=!boundedPart;
372      if(boundedPart)
373        {
374          bool isBounded=true;
375          for(int j=0;j<i->indices.size();j++)
376            if(vertices[i->indices[j]][0].sign()==0)isBounded=false;
377          doAdd=isBounded;
378        }
379      if(doAdd)
380        ret[i->dimension-min]+=Integer(sym.orbitSize(i->sortKey));
381    }
382  return ret;
383}
384
385
386bool SymmetricComplex::isPure()const
387{
388  int dim=-1;
389  for(ConeContainer::const_iterator i=cones.begin();i!=cones.end();i++)
390    {
391      if(isMaximal(*i))
392        {
393          int dim2=i->dimension;
394          if(dim==-1)dim=dim2;
395          if(dim!=dim2)return false;
396        }
397    }
398  return true;
399}
400
401
402bool SymmetricComplex::isSimplicial()const
403{
404  int linealityDim=getMinDim();
405  for(ConeContainer::const_iterator i=cones.begin();i!=cones.end();i++)
406    if(!i->isSimplicial(linealityDim))
407      return false;
408  return true;
409}
410
411
412void SymmetricComplex::remap()
413{
414  for(ConeContainer::iterator i=cones.begin();i!=cones.end();i++)
415    {
416      Cone const&j=*i;
417      Cone &j2=const_cast<Cone&>(j);//DANGER: cast away const. This does not change the sort key in the container, so should be OK.
418      j2.remap(*this);
419    }
420}
421
422
423int SymmetricComplex::numberOfConesOfDimension(int d)const
424{
425  assert(sym.isTrivial());
426
427  int ret=0;
428  for(ConeContainer::const_iterator i=cones.begin();i!=cones.end();i++)
429    if(d==i->dimension)
430      {
431        ret++;
432      }
433  return ret;
434}
435
436
437int SymmetricComplex::dimensionIndex(Cone const &c)
438{
439  assert(sym.isTrivial());
440
441  int ret=0;
442  for(ConeContainer::const_iterator i=cones.begin();i!=cones.end();i++)
443    if(c.dimension==i->dimension)
444      {
445        if(!(c<*i)&&!(*i<c))
446          return ret;
447        else
448          ret++;
449      }
450  return ret;
451}
452
453#if 0
454void SymmetricComplex::boundary(Cone const &c, vector<int> &indices_, vector<int> &signs)
455{
456  indices_=vector<int>();
457  signs=vector<int>();
458  int d=c.dimension;
459
460
461  IntegerVectorList l;
462  for(int i=0;i<c.indices.size();i++)
463    l.push_back(vertices[c.indices[i]]);
464  IntegerVectorList facetNormals=PolyhedralCone(l,IntegerVectorList(),n).extremeRays();
465  IntegerVectorList complementBasis=c.orthogonalComplement(*this);
466  for(IntegerVectorList::const_iterator i=facetNormals.begin();i!=facetNormals.end();i++)
467    {
468      IntegerVectorList complementBasis1=complementBasis;
469      complementBasis1.push_back(*i);
470      FieldMatrix m=integerMatrixToFieldMatrix(rowsToIntegerMatrix(complementBasis1,n),Q);
471      IntegerVectorList completion=fieldMatrixToIntegerMatrixPrimitive(m.reduceAndComputeKernel()).getRows();
472      for(IntegerVectorList::const_iterator j=completion.begin();j!=completion.end();j++)complementBasis1.push_back(*j);
473      int sign=determinantSign(complementBasis1);
474
475      set<int> indices;
476      for(vector<int>::const_iterator j=c.indices.begin();j!=c.indices.end();j++)if(dotLong(vertices[*j],*i)==0)indices.insert(*j);
477      Cone facet(indices,d-1,1,true,*this);
478      IntegerVectorList complementBasis2=facet.orthogonalComplement(*this);
479      for(IntegerVectorList::const_iterator j=completion.begin();j!=completion.end();j++)complementBasis2.push_back(*j);
480      indices_.push_back(dimensionIndex(facet));
481      signs.push_back(sign*determinantSign(complementBasis2));
482    }
483}
484
485
486IntegerMatrix SymmetricComplex::boundaryMap(int d)
487{
488  assert(sym.isTrivial());
489
490  IntegerMatrix ret(numberOfConesOfDimension(d-1),numberOfConesOfDimension(d));
491
492  for(ConeContainer::const_iterator i=cones.begin();i!=cones.end();i++)
493    if(d==i->dimension)
494      {
495        int I=dimensionIndex(*i);
496        vector<int> indices;
497        vector<int> signs;
498        boundary(*i,indices,signs);
499        for(int j=0;j<indices.size();j++)
500          {
501              ret[indices[j]][I]+=signs[j];
502          }
503      }
504  return ret;
505}
506#endif
507
508
509  std::string SymmetricComplex::toString(int flags)const
510  {
511    PolymakeFile polymakeFile;
512    polymakeFile.create("NONAME","PolyhedralFan","PolyhedralFan",flags&FPF_xml);
513
514
515
516
517
518    polymakeFile.writeCardinalProperty("AMBIENT_DIM",n);
519    polymakeFile.writeCardinalProperty("DIM",getMaxDim());
520    polymakeFile.writeCardinalProperty("LINEALITY_DIM",linealitySpace.getHeight());
521    //    polymakeFile.writeMatrixProperty("RAYS",rays,true,comments);
522        polymakeFile.writeMatrixProperty("RAYS",vertices,true);
523    polymakeFile.writeCardinalProperty("N_RAYS",vertices.getHeight());
524
525
526    polymakeFile.writeMatrixProperty("LINEALITY_SPACE",linealitySpace,n);
527    polymakeFile.writeMatrixProperty("ORTH_LINEALITY_SPACE",kernel(linealitySpace),n);
528
529/*
530    if(flags & FPF_primitiveRays)
531    {
532      ZMatrix primitiveRays;
533      for(int i=0;i<rays.getHeight();i++)
534        for(PolyhedralConeList::const_iterator j=cones.begin();j!=cones.end();j++)
535          if(j->contains(*i)&&(j->dimensionOfLinealitySpace()+1==j->dimension()))
536            primitiveRays.push_back(j->semiGroupGeneratorOfRay());
537
538      polymakeFile.writeMatrixProperty("PRIMITIVE_RAYS",rowsToIntegerMatrix(primitiveRays,n));
539    }
540*/
541#if 0
542    ZMatrix generatorsOfLinealitySpace=cones.begin()->generatorsOfLinealitySpace();
543
544    log1 fprintf(Stderr,"Building symmetric complex.\n");
545    for(PolyhedralConeList::const_iterator i=cones.begin();i!=cones.end();i++)
546      {
547        {
548          static int t;
549  //        log1 fprintf(Stderr,"Adding faces of cone %i\n",t++);
550        }
551  //      log2 fprintf(Stderr,"Dim: %i\n",i->dimension());
552
553        addFacesToSymmetricComplex(symCom,*i,i->getHalfSpaces(),generatorsOfLinealitySpace);
554      }
555
556  //  log1 cerr<<"Remapping";
557    symCom.remap();
558  //  log1 cerr<<"Done remapping";
559
560
561    PolyhedralFan f=*this;
562#endif
563
564  //  log1 fprintf(Stderr,"Computing f-vector.\n");
565    ZVector fvector=this->fvector();
566    polymakeFile.writeCardinalVectorProperty("F_VECTOR",fvector);
567  //  log1 fprintf(Stderr,"Done computing f-vector.\n");
568
569    if(flags&FPF_boundedInfo)
570      {
571  //      log1 fprintf(Stderr,"Computing bounded f-vector.\n");
572        ZVector fvectorBounded=this->fvector(true);
573        polymakeFile.writeCardinalVectorProperty("F_VECTOR_BOUNDED",fvectorBounded);
574  //      log1 fprintf(Stderr,"Done computing bounded f-vector.\n");
575      }
576#if 0
577    {
578      Integer euler;
579      int mul=-1;
580      for(int i=0;i<fvector.size();i++,mul*=-1)euler+=Integer(mul)*fvector[i];
581      polymakeFile.writeCardinalProperty("MY_EULER",euler);
582    }
583#endif
584  //  log1 fprintf(Stderr,"Checking if complex is simplicial and pure.\n");
585    polymakeFile.writeCardinalProperty("SIMPLICIAL",isSimplicial());
586    polymakeFile.writeCardinalProperty("PURE",isPure());
587  //  log1 fprintf(Stderr,"Done checking.\n");
588
589
590    polymakeFile.writeStringProperty("CONES",toStringJustCones(getMinDim(),getMaxDim(),false,flags&FPF_group, 0,false,flags&FPF_tPlaneSort));
591    polymakeFile.writeStringProperty("MAXIMAL_CONES",toStringJustCones(getMinDim(),getMaxDim(),true,flags&FPF_group, 0,false,flags&FPF_tPlaneSort));
592    polymakeFile.writeStringProperty("CONES_ORBITS",toStringJustCones(getMinDim(),getMaxDim(),false,flags&FPF_group, 0,true,flags&FPF_tPlaneSort));
593    polymakeFile.writeStringProperty("MAXIMAL_CONES_ORBITS",toStringJustCones(getMinDim(),getMaxDim(),true,flags&FPF_group, 0,true,flags&FPF_tPlaneSort));
594
595    if(!sym.isTrivial())
596      {
597        polymakeFile.writeMatrixProperty("SYMMETRY_GENERATORS",IntToZMatrix(sym.getGenerators()));
598      }
599
600    std::stringstream s;
601    polymakeFile.writeStream(s);
602    return s.str();
603
604    #if 0
605
606    if(flags&FPF_conesCompressed)
607    {
608  //    log1 fprintf(Stderr,"Producing list of cones up to symmetry.\n");
609      polymakeFile.writeStringProperty("CONES_ORBITS",symCom.toString(symCom.getMinDim(),symCom.getMaxDim(),false,flags&FPF_group,0,true,flags&FPF_tPlaneSort));
610  //    log1 fprintf(Stderr,"Done producing list of cones up to symmetry.\n");
611  //    log1 fprintf(Stderr,"Producing list of maximal cones up to symmetry.\n");
612      stringstream multiplicities;
613      polymakeFile.writeStringProperty("MAXIMAL_CONES_ORBITS",symCom.toString(symCom.getMinDim(),symCom.getMaxDim(),true,flags&FPF_group, &multiplicities,true,flags&FPF_tPlaneSort));
614      if(flags&FPF_multiplicities)polymakeFile.writeStringProperty("MULTIPLICITIES_ORBITS",multiplicities.str());
615  //    log1 fprintf(Stderr,"Done producing list of maximal cones up to symmetry.\n");
616    }
617
618    if(flags&FPF_conesExpanded)
619      {
620        if(flags&FPF_cones)
621          {
622  //          log1 fprintf(Stderr,"Producing list of cones.\n");
623            polymakeFile.writeStringProperty("CONES",symCom.toString(symCom.getMinDim(),symCom.getMaxDim(),false,flags&FPF_group,0,false,flags&FPF_tPlaneSort));
624  //          log1 fprintf(Stderr,"Done producing list of cones.\n");
625          }
626        if(flags&FPF_maximalCones)
627          {
628  //          log1 fprintf(Stderr,"Producing list of maximal cones.\n");
629            stringstream multiplicities;
630            polymakeFile.writeStringProperty("MAXIMAL_CONES",symCom.toString(symCom.getMinDim(),symCom.getMaxDim(),true,flags&FPF_group, &multiplicities,false,flags&FPF_tPlaneSort));
631            if(flags&FPF_multiplicities)polymakeFile.writeStringProperty("MULTIPLICITIES",multiplicities.str());
632  //          log1 fprintf(Stderr,"Done producing list of maximal cones.\n");
633          }
634      }
635  #endif
636    #if 0
637    if(flags&FPF_values)
638      {
639        {
640          ZMatrix values;
641          for(int i=0;i<linealitySpaceGenerators.getHeight();i++)
642            {
643              ZVector v(1);
644              v[0]=evaluatePiecewiseLinearFunction(linealitySpaceGenerators[i]);
645              values.appendRow(v);
646            }
647          polymakeFile.writeMatrixProperty("LINEALITY_VALUES",rowsToIntegerMatrix(values,1));
648        }
649        {
650          ZMatrix values;
651          for(IntegerVectorList::const_iterator i=rays.begin();i!=rays.end();i++)
652            {
653              ZVector v(1);
654              v[0]=evaluatePiecewiseLinearFunction(*i);
655              values.push_back(v);
656            }
657          polymakeFile.writeMatrixProperty("RAY_VALUES",rowsToIntegerMatrix(values,1));
658        }
659      }
660  #endif
661
662
663  //  log1 fprintf(Stderr,"Producing final string for output.\n");
664  /*  stringstream s;
665    polymakeFile.writeStream(s);
666    string S=s.str();
667  //  log1 fprintf(Stderr,"Printing string.\n");
668    p->printString(S.c_str());
669  *///  log1 fprintf(Stderr,"Done printing string.\n");
670  }
671
672  ZCone SymmetricComplex::makeZCone(IntVector const &indices)const
673  {
674    ZMatrix generators(indices.size(),getAmbientDimension());
675    for(int i=0;i<indices.size();i++)
676      generators[i]=vertices[indices[i]];
677    return ZCone::givenByRays(generators,linealitySpace);
678  }
679}
Note: See TracBrowser for help on using the repository browser.