← Back to branch summary

~ubuntu-branches/ubuntu/saucy/gfan/saucy-proposed

« back to all changes in this revision

Viewing changes to app_tropical.cpp

  • Committer: Package Import Robot
  • Author(s): Cédric Boutillier
  • Date: 2013-07-09 10:44:01 UTC
  • mfrom: (2.1.2 experimental)
  • Revision ID: package-import@ubuntu.com-20130709104401-5q66ozz5j5af0dak
Tags: 0.5+dfsg-3
* Upload to unstable.
* modify remove_failing_tests_on_32bits.patch to replace command of
  0009RenderStairCase test with an empty one instead of deleting it.
* remove lintian override about spelling error

Show diffs side-by-side

added added

removed removed

Lines of Context:
app_tropical.cpp
1
 
#include "vektor.h"
2
 
#include "printer.h"
3
 
#include "parser.h"
4
 
#include "gfanapplication.h"
5
 
#include "minkowskisum.h"
6
 
#include "newtonpolytope.h"
7
 
#include "buchberger.h"
8
 
#include "wallideal.h"
9
 
#include "lp.h"
10
 
#include "tropical.h"
11
 
#include "division.h"
12
 
#include "bergman.h"
13
 
#include "tropical2.h"
14
 
#include "dimension.h"
15
 
#include "timer.h"
16
 
 
17
 
class TropicalApplication : public GFanApplication
18
 
{
19
 
  FieldOption theFieldOption;
20
 
  SimpleOption optionMultipleSets;
21
 
  SimpleOption optionRay;
22
 
  SimpleOption optionTraverse;
23
 
  SimpleOption optionPerformanceTimer;
24
 
  SimpleOption optionSymmetry;
25
 
  SimpleOption optionGuess;
26
 
  SimpleOption optionIncidencePrinting;
27
 
  SimpleOption optionInitialIdealPrinting;
28
 
public:
29
 
  bool includeInDefaultInstallation()
30
 
  {
31
 
    return false;
32
 
  }
33
 
  const char *helpText()
34
 
  {
35
 
    return "topical.\n";
36
 
  }
37
 
  TropicalApplication():
38
 
    optionPerformanceTimer("-T","Enable performance timer"),
39
 
    optionMultipleSets("-m","undocumented"),
40
 
    optionRay("--ray","undocumented"),
41
 
    optionGuess("--guess","undocumented"),
42
 
    optionTraverse("--traverse","undocumented"),
43
 
    optionSymmetry("--symmetry","undocumented"),
44
 
    optionIncidencePrinting("--incidence","Print incidence information. This will also extract the full fan from its orbits!"),
45
 
    optionInitialIdealPrinting("--initialideals","Print the initial ideals during incidence printing ONLY with --incidence")
46
 
  {
47
 
    registerOptions();
48
 
  }
49
 
  char *name()
50
 
  {
51
 
    return "_tropical";
52
 
  }
53
 
  int main()
54
 
  {
55
 
    PolynomialSetList tropical;
56
 
 
57
 
    lpSetSolver("cddgmp");
58
 
    FileParser P(Stdin);
59
 
 
60
 
    if(optionGuess.getValue())
61
 
      {
62
 
        PolynomialSet g=P.parsePolynomialSetWithRing();
63
 
        buchberger(&g,StandardGradedLexicographicTermOrder());
64
 
 
65
 
 
66
 
        PolynomialSet fullBasis(g.getRing());
67
 
        PolynomialSet g2=guessInitialIdealWithoutMonomial(g,&fullBasis,false);
68
 
 
69
 
        AsciiPrinter(Stdout).printPolynomialSet(g2);
70
 
        AsciiPrinter(Stdout).printPolynomialSet(fullBasis);
71
 
 
72
 
        
73
 
 
74
 
        fprintf(Stderr,"Input:  Krull dimension %i Dimension of homogeneity space %i\n",krullDimension(g),dimensionOfHomogeneitySpace(g));
75
 
        fprintf(Stderr,"Output: Krull dimension %i Dimension of homogeneity space %i\n",krullDimension(g2),dimensionOfHomogeneitySpace(g2));
76
 
 
77
 
 
78
 
        return 0;
79
 
      }
80
 
 
81
 
 
82
 
    if(optionRay.getValue())
83
 
      {
84
 
        AsciiPrinter p(Stdout);
85
 
        bergmanRay(P.parsePolynomialSetWithRing()).print(p);
86
 
 
87
 
        return 0;
88
 
      }
89
 
 
90
 
    if(optionTraverse.getValue())
91
 
      {
92
 
        AsciiPrinter p(Stdout);
93
 
        PolynomialSet coneGroebnerBasis=P.parsePolynomialSetWithRing();
94
 
        PolynomialSet idealGroebnerBasis=P.parsePolynomialSet(coneGroebnerBasis.getRing());
95
 
        coneGroebnerBasis.changeNumberOfVariables(idealGroebnerBasis.numberOfVariablesInRing());
96
 
 
97
 
        SymmetryGroup s(idealGroebnerBasis.numberOfVariablesInRing());
98
 
        if(optionSymmetry.getValue())
99
 
          {
100
 
            IntegerVectorList generators=P.parseIntegerVectorList();
101
 
            for(IntegerVectorList::iterator i=generators.begin();i!=generators.end();i++)
102
 
              {
103
 
                assert(areIdealsEqual(idealGroebnerBasis,SymmetryGroup::permutePolynomialSet(idealGroebnerBasis,*i)));
104
 
              }
105
 
            
106
 
            s.computeClosure(generators);
107
 
            s.print(Stderr);
108
 
          }
109
 
 
110
 
        BergmanFan f=bergman(coneGroebnerBasis,idealGroebnerBasis,&s);
111
 
        f.print(p);
112
 
 
113
 
        if(optionIncidencePrinting.getValue())
114
 
          {
115
 
            PolyhedralFan p1=f.toPolyhedralFan();
116
 
            
117
 
            p1.removeAllLowerDimensional();
118
 
            
119
 
            AsciiPrinter Q(Stdout);
120
 
            
121
 
            assert(0);//            p1.printWithIndices(&Q,&s);
122
 
          }
123
 
        if(optionInitialIdealPrinting.getValue())
124
 
          {
125
 
            //      AsciiPrinter p(Stderr);
126
 
            PolyhedralFan p1=f.toPolyhedralFan();
127
 
            int n=p1.getAmbientDimension();
128
 
            IncidenceList a=p1.getIncidenceList(&s);
129
 
            IntegerVectorList rays=p1.getRaysInPrintingOrder(&s);
130
 
            p.printString("Rays:\n");
131
 
            p.printVectorList(rays);
132
 
            vector<IntegerVector> rays2(rays.size());
133
 
            int K=0;
134
 
            for(IntegerVectorList::const_iterator k=rays.begin();k!=rays.end();k++)
135
 
              rays2[K++]=*k;
136
 
 
137
 
            for(IncidenceList::const_iterator j=a.begin();j!=a.end();j++)
138
 
              {
139
 
                p.printInteger(j->first);
140
 
                for(IntegerVectorList::const_iterator i=j->second.begin();i!=j->second.end();i++)
141
 
                  {
142
 
                    p.printVector(*i);
143
 
                    IntegerVector v(n);
144
 
                    for(int t=0;t<i->size();t++)
145
 
                      {
146
 
                        v+=rays2[(*i)[t]];
147
 
                      }
148
 
                    p.printVector(v);
149
 
                    PolynomialSet g2=idealGroebnerBasis;
150
 
                    buchberger(&g2,WeightReverseLexicographicTermOrder(v));
151
 
                    g2=initialFormsAssumeMarked(g2,v);
152
 
                    g2=saturatedIdeal(g2);
153
 
                    p.printPolynomialSet(g2);
154
 
                    
155
 
                  }
156
 
              }
157
 
          }
158
 
 
159
 
 
160
 
 
161
 
        if(optionPerformanceTimer.getValue())Timer::printList();
162
 
        return 0;
163
 
      }
164
 
 
165
 
    PolynomialSetList input;
166
 
 
167
 
    if(optionMultipleSets.getValue())
168
 
      input=P.parsePolynomialSetListWithRing();
169
 
    else
170
 
      input.push_back(P.parsePolynomialSetWithRing());
171
 
 
172
 
    for(PolynomialSetList::const_iterator g=input.begin();g!=input.end();g++)
173
 
      {
174
 
 
175
 
        PolynomialSetList s=fullColoredIdeals(*g,false);
176
 
        
177
 
        static int num;
178
 
        fprintf(Stderr,"Monomial Intial Ideal num: %i\n",num++);
179
 
 
180
 
        //  AsciiPrinter(Stdout).printPolynomialSetList(s);
181
 
        
182
 
        //  fprintf(Stdout,"contains no monomials:\n");
183
 
        for(PolynomialSetList::const_iterator i=s.begin();i!=s.end();i++)
184
 
          {
185
 
            fprintf(Stderr,"Testing ideal:\n");
186
 
            AsciiPrinter(Stderr).printPolynomialSet(*i);
187
 
            if(!containsMonomial(*i))
188
 
              {         
189
 
                //  AsciiPrinter(Stdout).printPolynomialSet(*i);
190
 
                
191
 
                PolynomialSet g=*i;
192
 
                
193
 
                buchberger(&g,StandardGradedLexicographicTermOrder());
194
 
                
195
 
                bool inList=false;
196
 
                for(PolynomialSetList::const_iterator j=tropical.begin();j!=tropical.end();j++)
197
 
                  {
198
 
                    if(areIdealsEqual(*j,g))
199
 
                      {
200
 
                        inList=true;
201
 
                        break;
202
 
                      }
203
 
                  }
204
 
                if(!inList)tropical.push_back(g);
205
 
              }
206
 
          }
207
 
      }
208
 
    fprintf(Stderr,"No duplicates:\n");
209
 
    AsciiPrinter(Stdout).printPolynomialSetList(tropical);
210
 
 
211
 
 
212
 
    for(PolynomialSetList::const_iterator i=tropical.begin();i!=tropical.end();i++)
213
 
      {
214
 
        int coDim=rankOfMatrix(wallInequalities(*i));
215
 
        int d=i->numberOfVariablesInRing()-coDim;
216
 
        if(d<0)
217
 
          {
218
 
            fprintf(Stderr,"Error computing dimension of cone:");
219
 
            AsciiPrinter(Stderr).printPolynomialSet(*i);
220
 
            AsciiPrinter(Stderr).printVectorList(wallInequalities(*i));
221
 
            fprintf(Stderr,"coDim= %i, numberOfVariables= %i\n",coDim,i->numberOfVariablesInRing());
222
 
          }
223
 
        fprintf(Stderr,"%i\n",d);
224
 
      }
225
 
 
226
 
    return 0;
227
 
  }
228
 
};
229
 
 
230
 
static TropicalApplication theApplication;