Changeset 19addd1 in git


Ignore:
Timestamp:
Oct 25, 2013, 6:22:01 PM (11 years ago)
Author:
Yue Ren <ren@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'c7af8613769b29c741d6c338945669719f1fc4f8')
Children:
69b2c1754cbeecd7c1b844e71e2101e1b3794062
Parents:
b7b2c516034df879b01c7c8666bbdf0928da91dc
git-author:
Yue Ren <ren@mathematik.uni-kl.de>2013-10-25 18:22:01+02:00
git-committer:
Yue Ren <ren@mathematik.uni-kl.de>2013-10-25 18:25:28+02:00
Message:
fix: warnings
Location:
gfanlib
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • gfanlib/gfanlib_matrix.h

    rb7b2c5 r19addd1  
    6969  void appendRow(Vector<typ> const &v)
    7070    {
    71       assert(v.size()==width);
     71      assert((int)v.size()==width);
    7272      rows.push_back(v);
    7373      height++;
     
    410410  {
    411411    assert(typ::isField());
    412     assert(v.size()==getWidth());
     412    assert((int)v.size()==getWidth());
    413413
    414414    int pivotI=-1;
  • gfanlib/gfanlib_polyhedralfan.cpp

    rb7b2c5 r19addd1  
    352352
    353353      bool notAll=false;
    354       for(int j=0;j<theCone.indices.size();j++)
     354      for(unsigned j=0;j<theCone.indices.size();j++)
    355355        if(dot(rays[theCone.indices[j]],facetCandidates[i]).sign()==0)
    356356          indices.insert(theCone.indices[j]);
     
    395395void addFacesToSymmetricComplex(SymmetricComplex &c, ZCone const &cone, ZMatrix const &facetCandidates, ZMatrix const &generatorsOfLinealitySpace)
    396396{
    397   ZMatrix const &rays=c.getVertices();
     397  // ZMatrix const &rays=c.getVertices();
    398398  std::set<int> indices;
    399399
     
    502502}
    503503
    504 std::string PolyhedralFan::toString(int flags)const
     504std::string PolyhedralFan::toString(int /*flags*/)const
    505505//void PolyhedralFan::printWithIndices(class Printer *p, bool printMultiplicities, SymmetryGroup *sym, bool group, bool ignoreCones, bool xml, bool tPlaneSort, vector<string> const *comments)const
    506506{
  • gfanlib/gfanlib_polymakefile.cpp

    rb7b2c5 r19addd1  
    5353  list<int> ret;
    5454  int c=s.peek();
    55   while((c>='0') && (c<='9')|| (c==' '))
     55  while(((c>='0') && (c<='9')) || (c==' '))
    5656    {
    5757      //      fprintf(Stderr,"?\n");
     
    6666namespace gfan{
    6767PolymakeProperty::PolymakeProperty(const std::string &name_, const std::string &value_):
    68   name(name_),
    69   value(value_)
     68  value(value_),
     69  name(name_)
    7070{
    7171}
     
    271271
    272272
    273 bool PolymakeFile::readBooleanProperty(const char *p)
     273bool PolymakeFile::readBooleanProperty(const char */*p*/)
    274274{
    275275  return false;
     
    277277
    278278
    279 void PolymakeFile::writeBooleanProperty(const char *p, bool n)
     279void PolymakeFile::writeBooleanProperty(const char */*p*/, bool /*n*/)
    280280{
    281281}
     
    322322  stringstream t;
    323323
    324   if(comments)assert(comments->size()>=m.getHeight());
     324  if(comments)assert((int)comments->size()>=m.getHeight());
    325325  if(isXml)
    326326    {
     
    389389    {
    390390      t<<"<incidence_matrix>";
    391       for(int i=0;i<m.size();i++)
     391      for(unsigned i=0;i<m.size();i++)
    392392        {
    393393          t<<"<set>";
     
    405405  else
    406406    {
    407       for(int i=0;i<m.size();i++)
     407      for(unsigned i=0;i<m.size();i++)
    408408        {
    409409          t<<'{';
     
    445445    {
    446446      t<<"<vector>";
    447       for(int i=0;i<v.size();i++)
     447      for(unsigned i=0;i<v.size();i++)
    448448        {
    449449          if(i!=0)t<<" ";
     
    454454  else
    455455    {
    456       for(int i=0;i<v.size();i++)
     456      for(unsigned i=0;i<v.size();i++)
    457457        {
    458458          if(i!=0)t<<" ";
  • gfanlib/gfanlib_q.h

    rb7b2c5 r19addd1  
    156156    return mpq_sgn(value);
    157157  }
    158   static Rational gcd(Rational const &a, Rational const &b, Rational &s, Rational &t)
     158  static Rational gcd(Rational const &a, Rational const /*&b*/, Rational /*&s*/, Rational /*t*/)
    159159  {
    160160/*    mpz_t r;
  • gfanlib/gfanlib_symmetriccomplex.cpp

    rb7b2c5 r19addd1  
    1515
    1616SymmetricComplex::Cone::Cone(std::set<int> const &indices_, int dimension_, Integer multiplicity_, bool sortWithSymmetry, SymmetricComplex const &complex):
     17  isKnownToBeNonMaximalFlag(false),
    1718  dimension(dimension_),
    1819  multiplicity(multiplicity_),
    19   isKnownToBeNonMaximalFlag(false),
    2020  sortKeyPermutation(complex.n)
    2121{
     
    2727  ZMatrix const &vertices=complex.getVertices();
    2828  ZVector sum(vertices.getWidth());
    29   for(int i=0;i<indices.size();i++)
     29  for(unsigned i=0;i<indices.size();i++)
    3030    sum+=vertices[indices[i]];
    3131
     
    5656  ZMatrix const &vertices=complex.getVertices();
    5757  ZVector sum(vertices.getWidth());
    58   for(int i=0;i<indices.size();i++)
     58  for(unsigned i=0;i<indices.size();i++)
    5959    sum+=vertices[indices[i]];
    6060
     
    6262  Permutation const &bestPermutation=sortKeyPermutation;
    6363
    64   assert(bestPermutation.size()==n);
     64  assert((int)bestPermutation.size()==n);
    6565
    6666  IntVector indicesNew(indices.size());
    6767  int I=0;
    68   for(int i=0;i<indices.size();i++,I++)
     68  for(unsigned i=0;i<indices.size();i++,I++)
    6969    {
    7070      ZVector ny=bestPermutation.apply(complex.vertices[indices[i]]);
     
    8080{
    8181  std::set<int> ret;
    82   for(int i=0;i<indices.size();i++)
     82  for(unsigned i=0;i<indices.size();i++)
    8383    ret.insert(indices[i]);
    8484
     
    8989{
    9090  int next=0;
    91   for(int i=0;i<indices.size();i++)
     91  for(unsigned i=0;i<indices.size();i++)
    9292    {
    9393      while(1)
    9494        {
    95           if(next>=c.indices.size())return false;
     95          if(next>=(int)c.indices.size())return false;
    9696          if(indices[i]==c.indices[next])break;
    9797          next++;
     
    105105{
    106106  std::set<int> r;
    107   for(int i=0;i<indices.size();i++)
     107  for(unsigned i=0;i<indices.size();i++)
    108108    {
    109109      ZVector ny=permutation.apply(complex.vertices[indices[i]]);
     
    139139{
    140140  ZMatrix l;
    141   for(int i=0;i<indices.size();i++)
     141  for(unsigned i=0;i<indices.size();i++)
    142142    l.appendRow(complex.vertices[indices[i]]);
    143143
     
    150150SymmetricComplex::SymmetricComplex(ZMatrix const &rays, ZMatrix const &linealitySpace_, SymmetryGroup const &sym_):
    151151  n(rays.getWidth()),
     152  linealitySpace(canonicalizeSubspace(linealitySpace_)),
    152153  sym(sym_),
    153   dimension(-1),
    154   linealitySpace(canonicalizeSubspace(linealitySpace_))
     154  dimension(-1)
    155155{
    156156  assert(rays.getWidth()==linealitySpace.getWidth());
     
    222222}
    223223
    224 /*
     224#if 0
    225225IntVector SymmetricComplex::dimensionsAtInfinity()const
    226226{
     
    228228     dimension of the intersection of each cone in the complex with
    229229     the plane x_0=0 */
    230 /*
    231230  IntVector ret(cones.size());
    232231
     
    247246  return ret;
    248247}
    249 */
     248#endif
    250249
    251250void SymmetricComplex::buildConeLists(bool onlyMaximal, bool compressed, std::vector<std::vector<IntVector > >*conelist/*, ZMatrix *multiplicities*/)const
     
    259258      int numberOfOrbitsOutput=0;
    260259      int numberOfOrbitsOfThisDimension=0;
    261       bool newDimension=true;
     260      // bool newDimension=true;
    262261        {
    263262          int I=0;
    264263          for(ConeContainer::const_iterator i=cones.begin();i!=cones.end();i++,I++)
    265                   if(i->dimension==d)
    266                     {
    267                   numberOfOrbitsOfThisDimension++;
     264            if(i->dimension==d)
     265            {
     266              numberOfOrbitsOfThisDimension++;
    268267              if(!onlyMaximal || isMaximal(*i))
    269268                {
    270269                  numberOfOrbitsOutput++;
    271                   bool isMax=isMaximal(*i);
    272                   bool newOrbit=true;
     270                  // bool isMax=isMaximal(*i);
     271                  // bool newOrbit=true;
    273272                  std::set<std::set<int> > temp;
    274                     for(SymmetryGroup::ElementContainer::const_iterator k=sym.elements.begin();k!=sym.elements.end();k++)
    275                       {
     273                  for(SymmetryGroup::ElementContainer::const_iterator k=sym.elements.begin();k!=sym.elements.end();k++)
     274                    {
    276275                        Cone temp1=i->permuted(*k,*this,false);
    277276                        temp.insert(temp1.indexSet());
     
    291290                          *multiplicities << std::endl;
    292291                        }*/
    293                       newOrbit=false;
    294                       newDimension=false;
     292                      // newOrbit=false;
     293                      // newDimension=false;
    295294                    }
    296               }
    297                     }
    298         }
    299     }
    300 
    301 }
    302 
    303 std::string SymmetricComplex::toStringJustCones(int dimLow, int dimHigh, bool onlyMaximal, bool group, std::ostream *multiplicities, bool compressed, bool tPlaneSort)const
     295                }
     296            }
     297        }
     298    }
     299
     300}
     301
     302std::string SymmetricComplex::toStringJustCones(int dimLow, int dimHigh, bool onlyMaximal, bool group, std::ostream *multiplicities, bool compressed, bool /*tPlaneSort*/)const
    304303{
    305304  std::stringstream ret;
     
    392391        {
    393392          bool isBounded=true;
    394           for(int j=0;j<i->indices.size();j++)
     393          for(unsigned j=0;j<i->indices.size();j++)
    395394            if(vertices[i->indices[j]][0].sign()==0)isBounded=false;
    396395          doAdd=isBounded;
     
    692691  {
    693692    ZMatrix generators(indices.size(),getAmbientDimension());
    694     for(int i=0;i<indices.size();i++)
     693    for(unsigned i=0;i<indices.size();i++)
    695694      generators[i]=vertices[indices[i]];
    696695    return ZCone::givenByRays(generators,linealitySpace);
  • gfanlib/gfanlib_symmetry.cpp

    rb7b2c5 r19addd1  
    2525                TrieNode(IntVector const &v, int i)
    2626                {
    27                         if(i<v.size())
     27                  if(i<(int)v.size())
    2828                        m[v[i]]=TrieNode(v,i+1);
    2929                }
     
    3131                {
    3232                  int ret=0;
    33                   if(i==v.size())return 1;
     33                  if(i==(int)v.size())return 1;
    3434                  for(Map::const_iterator j=m.begin();j!=m.end();j++)
    3535                    {
     
    4141                void search(ZVector const &v, ZVector  &building, Permutation &tempPerm, Permutation &ret, ZVector &optimal, int i, bool &isImproving)const
    4242                {
    43                         if(i==v.size()){ret=tempPerm;optimal=building;isImproving=false;return;}
     43                  if(i==(int)v.size()){ret=tempPerm;optimal=building;isImproving=false;return;}
    4444                        if(isImproving)
    4545                                building[i]=-0x7fffffff;
     
    6161                void searchStabalizer(ZVector const &v, ZVector  &building, Permutation &tempPerm, Permutation &ret, ZVector &optimal, int i, bool &isImproving, ZVector const &toBeFixed)const
    6262                {
    63                         if(i==v.size())
     63                  if(i==(int)v.size())
    6464                                if(!(tempPerm.apply(v)<optimal))
    6565                                        {
     
    102102                void insert(Permutation const &v, int i)
    103103                {
    104                         if(i==v.size())return;
     104                  if(i==(int)v.size())return;
    105105                        if(m.count(v[i]))
    106106                                m[v[i]].insert(v,i+1);
     
    132132        int n;
    133133        Trie(int n_):
    134                 n(n_),
    135                 theTree(Permutation(n_),0)
     134                theTree(Permutation(n_),0),
     135                n(n_)
    136136        {
    137137        }
     
    276276  IntVector ret(size());
    277277  assert(size()==b.size());
    278   for(int i=0;i<size();i++)ret[i]=b[(*this)[i]];
     278  for(unsigned i=0;i<size();i++)ret[i]=b[(*this)[i]];
    279279  return Permutation(ret);
    280280}
     
    284284  IntVector ret(size());
    285285  assert(size()==b.size());
    286   for(int i=0;i<size();i++)ret[(*this)[i]]=b[i];
     286  for(unsigned i=0;i<size();i++)ret[(*this)[i]]=b[i];
    287287  return Permutation(ret);
    288288}
     
    292292  IntVector ret(size());
    293293  assert(size()==v.size());
    294   for(int i=0;i<size();i++)ret[i]=v[(*this)[i]];
     294  for(unsigned i=0;i<size();i++)ret[i]=v[(*this)[i]];
    295295  return ret;
    296296}
     
    300300  ZVector ret(size());
    301301  assert(size()==v.size());
    302   for(int i=0;i<size();i++)ret[i]=v[(*this)[i]];
     302  for(unsigned i=0;i<size();i++)ret[i]=v[(*this)[i]];
    303303  return ret;
    304304}
     
    309309  ZVector ret(size());
    310310  assert(size()==v.size());
    311   for(int i=0;i<size();i++)ret[(*this)[i]]=v[i];
     311  for(unsigned i=0;i<size();i++)ret[(*this)[i]]=v[i];
    312312  return ret;
    313313}
     
    431431ZVector Permutation::fundamentalDomainInequality()const
    432432{
    433   for(int i=0;i<size();i++)
    434     if((*this)[i]!=i)
     433  for(unsigned i=0;i<size();i++)
     434    if((*this)[i]!=(int)i)
    435435      return ZVector::standardVector(size(),i)-ZVector::standardVector(size(),(*this)[i]);
    436436  return ZVector(size());
  • gfanlib/gfanlib_vector.h

    rb7b2c5 r19addd1  
    101101      if(size()<b.size())return true;
    102102      if(size()>b.size())return false;
    103       for(int i=0;i<size();i++)
     103      for(unsigned i=0;i<size();i++)
    104104        {
    105105          if(v[i]<b[i])return true;
     
    156156      return pq*pq==pp*qq;
    157157*/
    158           int n=p.size();
     158          unsigned n=p.size();
    159159          assert(n==q.size());
    160           int i;
     160          unsigned i;
    161161          for(i=0;i<n;i++)
    162162          {
     
    167167          typ a=p.v[i];
    168168          typ b=q.v[i];
    169           for(int j=0;j<n;j++)
     169          for(unsigned j=0;j<n;j++)
    170170            if(a*q.v[j]!=b*p.v[j])return false;
    171171          return true;
     
    175175  // Arithmetic slow
    176176  //-----------------
    177   inline friend Vector operator*(typ s, const Vector& q){Vector p=q;for(int i=0;i<q.size();i++)p[i]*=s;return p;}
     177  inline friend Vector operator*(typ s, const Vector& q){Vector p=q;for(unsigned i=0;i<q.size();i++)p[i]*=s;return p;}
    178178//  inline friend Vektor operator/(const Vektor& q, typ s){Vektor p=q;for(int i=0;i<q.size();i++)p[i]/=s;return p;}
    179179/*  inline friend Vector operator*(const Vektor& p, const Vektor& q){assert(p.size()==q.size());Vektor p1=p;for(int i=0;i<p.size();i++)p1.v[i]*=q.v[i];return p1;}
     
    181181*/
    182182  inline friend Vector operator/(const Vector& p, typ const &s){Vector ret(p.size());for(unsigned i=0;i<p.size();i++)ret[i]=p[i]/s;return ret;}
    183   inline friend Vector operator+(const Vector& p, const Vector& q){assert(p.size()==q.size());Vector p1=p;for(int i=0;i<p.size();i++)p1[i]+=q[i];return p1;}
    184   inline friend Vector operator-(const Vector& p, const Vector& q){assert(p.size()==q.size());Vector p1=p;for(int i=0;i<p.size();i++)p1[i]-=q[i];return p1;}
    185   inline friend Vector max(const Vector& p, const Vector& q){assert(p.size()==q.size());Vector p1=p;for(int i=0;i<p.size();i++)if(p1[i]<q[i])p1[i]=q[i];return p1;}
    186   inline friend Vector min(const Vector& p, const Vector& q){assert(p.size()==q.size());Vector p1=p;for(int i=0;i<p.size();i++)if(p1[i]>q[i])p1[i]=q[i];return p1;}
     183  inline friend Vector operator+(const Vector& p, const Vector& q){assert(p.size()==q.size());Vector p1=p;for(unsigned i=0;i<p.size();i++)p1[i]+=q[i];return p1;}
     184  inline friend Vector operator-(const Vector& p, const Vector& q){assert(p.size()==q.size());Vector p1=p;for(unsigned i=0;i<p.size();i++)p1[i]-=q[i];return p1;}
     185  inline friend Vector max(const Vector& p, const Vector& q){assert(p.size()==q.size());Vector p1=p;for(unsigned i=0;i<p.size();i++)if(p1[i]<q[i])p1[i]=q[i];return p1;}
     186  inline friend Vector min(const Vector& p, const Vector& q){assert(p.size()==q.size());Vector p1=p;for(unsigned i=0;i<p.size();i++)if(p1[i]>q[i])p1[i]=q[i];return p1;}
    187187
    188188  friend Vector operator-(const Vector &b)
    189189  {
    190190    Vector ret(b.size());
    191     for(int i=0;i<b.size();i++)ret[i]=-b[i];
     191    for(unsigned i=0;i<b.size();i++)ret[i]=-b[i];
    192192    return ret;
    193193  }
     
    226226    {
    227227      assert(begin>=0);
    228       assert(end<=size());
     228      assert(end<=(int)size());
    229229      assert(end>=begin);
    230230      Vector ret(end-begin);
     
    293293    typ temp1,temp2;
    294294    typ ret(1);
    295     for(int i=0;i<size();i++)
     295    for(unsigned i=0;i<size();i++)
    296296      ret=typ::gcd(ret,v[i],temp1,temp2);
    297297    return ret;
  • gfanlib/gfanlib_zcone.cpp

    rb7b2c5 r19addd1  
    4444    dd_colrange d_input,j;
    4545    dd_RepresentationType rep=dd_Inequality;
    46     dd_boolean found=dd_FALSE, newformat=dd_FALSE, successful=dd_FALSE;
    47     char command[dd_linelenmax], comsave[dd_linelenmax];
     46    // dd_boolean found=dd_FALSE, newformat=dd_FALSE, successful=dd_FALSE;
     47    // char command[dd_linelenmax], comsave[dd_linelenmax];
    4848    dd_NumberType NT;
    4949
    5050    (*Error)=dd_NoError;
    5151
    52     rep=dd_Inequality; newformat=dd_TRUE;
     52    rep=dd_Inequality; // newformat=dd_TRUE;
    5353
    5454    m_input=g.getHeight();
     
    7070    }
    7171
    72     successful=dd_TRUE;
     72    // successful=dd_TRUE;
    7373
    7474    return M;
     
    108108  {
    109109    bool ret;
    110     dd_MatrixPtr M=NULL,M2=NULL,M3=NULL;
    111     dd_colrange d;
     110    dd_MatrixPtr M=NULL/*,M2=NULL,M3=NULL*/;
     111    // dd_colrange d;
    112112    dd_ErrorType err=dd_NoError;
    113     dd_rowset redrows,linrows,ignoredrows, basisrows;
    114     dd_colset ignoredcols, basiscols;
    115     dd_DataFileType inputfile;
    116     FILE *reading=NULL;
     113    // dd_rowset redrows,linrows,ignoredrows, basisrows;
     114    // dd_colset ignoredcols, basiscols;
     115    // dd_DataFileType inputfile;
     116    // FILE *reading=NULL;
    117117
    118118    cddinitGmp();
     
    121121    if (err!=dd_NoError) goto _L99;
    122122
    123     d=M->colsize;
     123    // d=M->colsize;
    124124
    125125    static dd_Arow temp;
     
    339339    if(numberOfRows==0)return;//the full space, so description is already irredundant
    340340
    341     dd_rowset r=NULL;
     341    // dd_rowset r=NULL;
    342342    ZMatrix g=inequalities;
    343343    g.append(equations);
    344344
    345     dd_LPSolverType solver=dd_DualSimplex;
     345    // dd_LPSolverType solver=dd_DualSimplex;
    346346    dd_MatrixPtr A=NULL;
    347347    dd_ErrorType err=dd_NoError;
     
    402402    int numberOfRows=numberOfEqualities+numberOfInequalities;
    403403
    404     dd_rowset r=NULL;
     404    // dd_rowset r=NULL;
    405405    ZMatrix g=inequalities;
    406406    g.append(equations);
     
    448448  void dual(ZMatrix const &inequalities, ZMatrix const &equations, ZMatrix &dualInequalities, ZMatrix &dualEquations)
    449449  {
    450     int result;
     450    // int result;
    451451
    452452    dd_MatrixPtr A=NULL;
     
    472472
    473473    return;
    474    _L99:
    475     assert(0);
     474   // _L99:
     475   // assert(0);
    476476  }
    477477  // this procedure is take from cddio.c.
     
    556556    int dim2=inequalities.getHeight();
    557557    if(dim2==0)return std::vector<std::vector<int> >();
    558     int dimension=inequalities.getWidth();
     558    // int dimension=inequalities.getWidth();
    559559
    560560    dd_MatrixPtr A=NULL;
     
    603603
    604604    return ret;
    605    _L99:
    606     assert(0);
    607     return std::vector<std::vector<int> >();
     605   // _L99:
     606   // assert(0);
     607   // return std::vector<std::vector<int> >();
    608608  }
    609609
     
    707707          inequalities=LpSolver::fastNormals(inequalities2);
    708708          goto noFallBack;
    709         fallBack://alternativ (disabled)
    710           lpSolver.removeRedundantRows(inequalities,equations,true);
     709        // fallBack://alternativ (disabled)
     710        //   lpSolver.removeRedundantRows(inequalities,equations,true);
    711711        noFallBack:;
    712712        }
     
    730730}
    731731
    732 std::ostream &operator<<(std::ostream &f, ZCone const &c)
     732void operator<<(std::ostream &f, ZCone const &c)
    733733{
    734734  f<<"Ambient dimension:"<<c.n<<std::endl;
     
    741741
    742742ZCone::ZCone(int ambientDimension):
     743  preassumptions(PCP_impliedEquationsKnown|PCP_facetsKnown),
     744  state(1),
     745  n(ambientDimension),
     746  multiplicity(1),
     747  linearForms(ZMatrix(0,ambientDimension)),
    743748  inequalities(ZMatrix(0,ambientDimension)),
    744749  equations(ZMatrix(0,ambientDimension)),
    745   n(ambientDimension),
    746   state(1),
    747   preassumptions(PCP_impliedEquationsKnown|PCP_facetsKnown),
     750  haveExtremeRaysBeenCached(false)
     751{
     752}
     753
     754
     755ZCone::ZCone(ZMatrix const &inequalities_, ZMatrix const &equations_, int preassumptions_):
     756  preassumptions(preassumptions_),
     757  state(0),
     758  n(inequalities_.getWidth()),
    748759  multiplicity(1),
    749   haveExtremeRaysBeenCached(false),
    750   linearForms(ZMatrix(0,ambientDimension))
    751 {
    752 }
    753 
    754 
    755 ZCone::ZCone(ZMatrix const &inequalities_, ZMatrix const &equations_, int preassumptions_):
     760  linearForms(ZMatrix(0,inequalities_.getWidth())),
    756761  inequalities(inequalities_),
    757762  equations(equations_),
    758   state(0),
    759   preassumptions(preassumptions_),
    760   multiplicity(1),
    761   haveExtremeRaysBeenCached(false),
    762   n(inequalities_.getWidth()),
    763   linearForms(ZMatrix(0,inequalities_.getWidth()))
     763  haveExtremeRaysBeenCached(false)
    764764  {
    765765  assert(preassumptions_<4);//OTHERWISE WE ARE DOING SOMETHING STUPID LIKE SPECIFYING AMBIENT DIMENSION
     
    10421042  std::vector<std::vector<int> > indices=lpSolver.extremeRaysInequalityIndices(inequalities);
    10431043
    1044   for(int i=0;i<indices.size();i++)
     1044  for(unsigned i=0;i<indices.size();i++)
    10451045    {
    10461046      /* At this point we know lineality space, implied equations and
     
    10821082
    10831083          std::vector<int> asVector(inequalities.getHeight());
    1084           for(int j=0;j<indices[i].size();j++){asVector[indices[i][j]]=1;}
     1084          for(unsigned j=0;j<indices[i].size();j++){asVector[indices[i][j]]=1;}
    10851085          ZMatrix equations=this->equations;
    10861086          ZVector theInequality;
    10871087
    1088           for(int j=0;j<asVector.size();j++)
     1088          for(unsigned j=0;j<asVector.size();j++)
    10891089            if(asVector[j])
    10901090              equations.appendRow(inequalities[j]);
     
    12291229ZCone ZCone::faceContaining(ZVector const &v)const
    12301230{
    1231   assert(n==v.size());
     1231  assert(n==(int)v.size());
    12321232  assert(contains(v));
    12331233  ZMatrix newEquations=equations;
  • gfanlib/gfanlib_zcone.h

    rb7b2c5 r19addd1  
    352352     */
    353353   // PolyhedralCone projection(int newn)const;
    354     friend std::ostream &operator<<(std::ostream &f, ZCone const &c);
     354    friend void operator<<(std::ostream &f, ZCone const &c);
    355355};
    356356
  • gfanlib/gfanlib_zfan.cpp

    rb7b2c5 r19addd1  
    1616  {
    1717    assert(dimension>=0);
    18     if(dimension>=T.size())return 0;
     18    if(dimension>=(int)T.size())return 0;
    1919    return T[dimension].size();
    2020  }
     
    162162
    163163//        log2 cerr<< "Number of orbits to expand "<<cones.size()<<endl;
    164         for(int i=0;i<cones.size();i++)
     164        for(unsigned i=0;i<cones.size();i++)
    165165        //  if(coneIndices==0 || coneIndices->count(i))
    166166            {
     
    202202  }
    203203  ZFan::ZFan(ZFan const& f):
     204    coneCollection(0),
    204205    complex(0),
    205     coneCollection(0),
    206206    cones(f.table(0,0)),
    207207    maximalCones(f.table(0,1)),
Note: See TracChangeset for help on using the changeset viewer.