← Back to branch summary

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

« back to all changes in this revision

Viewing changes to field_rationalfunctions2.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:
field_rationalfunctions2.cpp
 
1
#include "field_rationalfunctions2.h"
 
2
 
 
3
#include <memory>
 
4
#include <assert.h>
 
5
#include <gmp.h>
 
6
#include <sstream>
 
7
#include <iostream>
 
8
 
 
9
#include "termorder.h"
 
10
#include "division.h"
 
11
#include "buchberger.h"
 
12
#include "saturation.h"
 
13
#include "printer.h"
 
14
 
 
15
#include "log.h"
 
16
 
 
17
int FieldElementRationalFunctions2Living;
 
18
 
 
19
class FieldElementRationalFunction2 : public FieldElementImplementation
 
20
{
 
21
 public:
 
22
  Polynomial p,q;
 
23
  FieldElementRationalFunction2(FieldImplementation &a):
 
24
    FieldElementImplementation(a),
 
25
    p(((FieldRationalFunctions2Implementation*)&a)->getPolynomialRing()),
 
26
    q(Term(((FieldRationalFunctions2Implementation*)&a)->getPolynomialRing().getField().zHomomorphism(1),Monomial(((FieldRationalFunctions2Implementation*)&a)->getPolynomialRing())))
 
27
  {
 
28
    FieldElementRationalFunctions2Living++;
 
29
  }
 
30
  FieldElementRationalFunction2(FieldImplementation &a,int n_):
 
31
    FieldElementImplementation(a),
 
32
    p(Term(((FieldRationalFunctions2Implementation*)&a)->getPolynomialRing().getField().zHomomorphism(n_),Monomial(((FieldRationalFunctions2Implementation*)&a)->getPolynomialRing()))),
 
33
    q(Term(((FieldRationalFunctions2Implementation*)&a)->getPolynomialRing().getField().zHomomorphism(1),Monomial(((FieldRationalFunctions2Implementation*)&a)->getPolynomialRing())))
 
34
    {
 
35
      if(n_==0)p=Polynomial(((FieldRationalFunctions2Implementation*)&a)->getPolynomialRing());
 
36
      FieldElementRationalFunctions2Living++;
 
37
    }
 
38
  void normalize()
 
39
  {
 
40
/*    PolynomialSet g(p.getRing());
 
41
    g.push_back(p);
 
42
    g.push_back(q);
 
43
//    LexicographicTermOrder T;
 
44
    LexicographicTermOrder T;
 
45
    buchberger(&g,T);
 
46
    minimize(&g);
 
47
//    assert(g.size()==1);
 
48
    if(g.size()==1)
 
49
    {
 
50
        Polynomial r=g.front();
 
51
 
 
52
    PolynomialSet Q(p.getRing());
 
53
    PolynomialSet P(p.getRing());
 
54
    division(p,g,T,&P);
 
55
    division(q,g,T,&Q);
 
56
    p=*P.begin();
 
57
    q=*Q.begin();
 
58
    assert(!q.isZero());
 
59
    FieldElement a=q.terms.rbegin()->second;
 
60
    p*=a;
 
61
    q*=a.inverse();
 
62
    }*/
 
63
    }
 
64
  FieldElementRationalFunction2(FieldImplementation &a, Polynomial const &p_, Polynomial const &q_):
 
65
    FieldElementImplementation(a),
 
66
    p(p_),
 
67
    q(q_)
 
68
    {
 
69
 
 
70
      FieldElementRationalFunctions2Living++;
 
71
    }
 
72
  virtual ~FieldElementRationalFunction2()
 
73
    {
 
74
      FieldElementRationalFunctions2Living--;
 
75
    }
 
76
  FieldElementRationalFunction2& operator=(const FieldElementRationalFunction2& a)
 
77
    {
 
78
      assert(0);
 
79
      return *this;
 
80
    }
 
81
 
 
82
  void operator*=(const FieldElementImplementation &a)
 
83
    {
 
84
      const FieldElementRationalFunction2 *A=(const FieldElementRationalFunction2*)&a;
 
85
      assert(A);
 
86
 
 
87
      p*=A->p;
 
88
      q*=A->q;
 
89
      normalize();
 
90
    }
 
91
  void operator+=(const FieldElementImplementation &a)
 
92
    {
 
93
      const FieldElementRationalFunction2 *A=(const FieldElementRationalFunction2*)&a;
 
94
      assert(A);
 
95
 
 
96
      p=p*A->q+A->p*q;
 
97
      q=A->q*q;
 
98
      normalize();
 
99
    }
 
100
  void madd(const FieldElementImplementation &a,const FieldElementImplementation &b)
 
101
    {
 
102
      const FieldElementRationalFunction2 *A=(const FieldElementRationalFunction2*)&a;
 
103
      const FieldElementRationalFunction2 *B=(const FieldElementRationalFunction2*)&b;
 
104
      assert(A);
 
105
      assert(B);
 
106
 
 
107
      p=p*(A->q*B->q)+(A->p*B->p)*q;
 
108
      q=A->q*B->q*q;
 
109
      normalize();
 
110
    }
 
111
  FieldElementRationalFunction2 *one() const;
 
112
  bool isZero() const
 
113
    {
 
114
      return p.isZero();
 
115
    }
 
116
 
 
117
  FieldElementRationalFunction2 *sum(const FieldElementImplementation &b)const
 
118
    {
 
119
      const FieldElementRationalFunction2 *B=(const FieldElementRationalFunction2*)&b;
 
120
 
 
121
      FieldElementRationalFunction2 *r= new FieldElementRationalFunction2(*getField(),p*B->q+B->p*q,B->q*q);
 
122
 
 
123
      return r;
 
124
    }
 
125
  FieldElementRationalFunction2 *difference(const FieldElementImplementation &b)const
 
126
    {
 
127
      const FieldElementRationalFunction2 *B=(const FieldElementRationalFunction2*)&b;
 
128
      FieldElementRationalFunction2 *r= new FieldElementRationalFunction2(*getField(),p*B->q-B->p*q,B->q*q);
 
129
      return r;
 
130
    }
 
131
  FieldElementRationalFunction2 *negation()const
 
132
    {
 
133
      FieldElementRationalFunction2 *r= new FieldElementRationalFunction2(*getField(),p-p-p,q);
 
134
 
 
135
      return r;
 
136
    }
 
137
  FieldElementImplementation *inverse()const
 
138
  {
 
139
    if(isZero())
 
140
      {
 
141
        AsciiPrinter P(Stderr);
 
142
        P.printString("Error inverting FieldElement: ");
 
143
        //      P.printFieldElement(*this);
 
144
        P.printString("\n");
 
145
        assert(0);
 
146
      }
 
147
 
 
148
    FieldElementRationalFunction2 *r= new FieldElementRationalFunction2(*getField(),q,p);
 
149
 
 
150
    return r;
 
151
  }
 
152
 
 
153
  int sign()const
 
154
  {
 
155
          assert(0);//not an ordered field (yet)
 
156
    if(isZero())return 0;
 
157
    return p.terms.rbegin()->second.sign();
 
158
  }
 
159
 
 
160
  static string LaTeXTranslator(const string &s)
 
161
  {
 
162
          assert(0);//not supported yet
 
163
/*    int startIndex=0;
 
164
    string sign;
 
165
    if(s[0]=='-')
 
166
      {
 
167
        sign=string("-");
 
168
        startIndex=1;
 
169
      }
 
170
    int slashIndex=-1;
 
171
    for(int i=startIndex;i<s.length();i++)if(s[i]=='/')slashIndex=i;
 
172
    if(slashIndex==-1)
 
173
      return string(s);
 
174
 
 
175
    return sign+string("{").append(s,startIndex,slashIndex-startIndex)+string("\\over ").append(s,slashIndex+1,s.length()-slashIndex-1)+string("}");
 
176
*/
 
177
          }
 
178
 
 
179
  std::string toString(bool writeIfOne=true, bool alwaysWriteSign=false, bool latexMode=false /*, bool mathMode=true*/) const
 
180
  {
 
181
    stringstream s;
 
182
 
 
183
    //    s << "(" <<p.toString(latexMode) << "/" << q.toString(latexMode) << ")";
 
184
    s << "(";
 
185
    s<<p.toString(latexMode);
 
186
    s << "/";
 
187
    s << q.toString(latexMode);
 
188
    s << ")";
 
189
    return s.str();
 
190
  }
 
191
 
 
192
  FieldElementRationalFunction2 *copy()const
 
193
  {
 
194
    FieldElementRationalFunction2 *r= new FieldElementRationalFunction2(*getField());
 
195
    r->p=p;
 
196
    r->q=q;
 
197
 
 
198
    return r;
 
199
  }
 
200
};
 
201
 
 
202
PolynomialRing FieldRationalFunctions2Implementation::getPolynomialRing()const
 
203
{
 
204
  return thePolynomialRing;
 
205
}
 
206
 
 
207
bool FieldRationalFunctions2Implementation::isRationals()const
 
208
{
 
209
  return false;
 
210
}
 
211
 
 
212
FieldRationalFunctions2Implementation::FieldRationalFunctions2Implementation(PolynomialRing const &r):
 
213
  thePolynomialRing(r)
 
214
{
 
215
}
 
216
 
 
217
std::string FieldRationalFunctions2Implementation::toString()const
 
218
{
 
219
  stringstream s;
 
220
  s<< thePolynomialRing.getField().toString() << "("<<thePolynomialRing.toStringVariableNames()<< ")";
 
221
  return s.str();
 
222
}
 
223
 
 
224
FieldElementImplementation *FieldRationalFunctions2Implementation::zHomomorphismImplementation(int n)
 
225
{
 
226
  FieldElementImplementation *ret=new FieldElementRationalFunction2(*this,n);
 
227
  return ret;
 
228
}
 
229
 
 
230
FieldElement FieldRationalFunctions2Implementation::zHomomorphism(int n)
 
231
{
 
232
  return FieldElement(zHomomorphismImplementation(n));
 
233
}
 
234
 
 
235
const char *FieldRationalFunctions2Implementation::name()
 
236
{
 
237
  return "Rational functions in n variables";
 
238
}
 
239
 
 
240
FieldElementRationalFunction2 *FieldElementRationalFunction2::one() const
 
241
{
 
242
  return new FieldElementRationalFunction2(*getField(),1);
 
243
}
 
244
 
 
245
 
 
246
 
 
247
FieldRationalFunctions2::FieldRationalFunctions2(PolynomialRing const &r):
 
248
  Field(new FieldRationalFunctions2Implementation(r))
 
249
{
 
250
}
 
251
 
 
252
 
 
253
FieldElement FieldRationalFunctions2::polynomialToFraction(Polynomial const &p)
 
254
{
 
255
  FieldRationalFunctions2Implementation *imp=dynamic_cast<FieldRationalFunctions2Implementation*>(implementingObject);
 
256
  Polynomial q=Term(imp->getPolynomialRing().getField().zHomomorphism(1),Monomial(imp->getPolynomialRing()));
 
257
 
 
258
  return new FieldElementRationalFunction2(*imp, p, q);
 
259
}
 
260
 
 
261
/*****************************************************
 
262
 * Conversion functions
 
263
 *****************************************************/
 
264
PolynomialRing makeVariablesParameters(PolynomialRing const &r, int numberOfParameters)
 
265
{
 
266
        assert(numberOfParameters>=0);
 
267
        assert(numberOfParameters<=r.getNumberOfVariables());
 
268
        vector<string> names(numberOfParameters);
 
269
        for(int i=0;i<numberOfParameters;i++)names[i]=r.getVariableName(i);
 
270
        PolynomialRing temp(r.getField(),names);
 
271
        vector<string> names2(r.getNumberOfVariables()-numberOfParameters);
 
272
        for(int i=0;i<names2.size();i++)names2[i]=r.getVariableName(i+numberOfParameters);
 
273
 
 
274
        return PolynomialRing(FieldRationalFunctions2(temp),names2);
 
275
}
 
276
 
 
277
Polynomial makeVariablesParameters(PolynomialRing const &genericRing, Polynomial const &p)
 
278
{
 
279
        Polynomial ret(genericRing);
 
280
        FieldRationalFunctions2Implementation const *coefficientField=dynamic_cast<FieldRationalFunctions2Implementation const*>(genericRing.getField().implementingObject);
 
281
        FieldRationalFunctions2 &DANGER=(FieldRationalFunctions2&)genericRing.getField();
 
282
        PolynomialRing coefRing=coefficientField->getPolynomialRing();
 
283
 
 
284
        for(TermMap::const_iterator i=p.terms.begin();i!=p.terms.end();i++)
 
285
        {
 
286
                FieldElement c=i->second;
 
287
                IntegerVector v=i->first.exponent;
 
288
                IntegerVector coefficientExponent=v.subvector(0,p.getRing().getNumberOfVariables()-genericRing.getNumberOfVariables());
 
289
                IntegerVector monomialExponent=v.subvector(p.getRing().getNumberOfVariables()-genericRing.getNumberOfVariables(),v.size());
 
290
                FieldElement c2=DANGER.polynomialToFraction(Term( c,Monomial(coefRing, coefficientExponent)));//does the numerator not belong to a field?
 
291
                ret+=Polynomial(Term(c2,Monomial(genericRing,monomialExponent)));
 
292
        }
 
293
        return ret;
 
294
}
 
295
 
 
296
PolynomialSet makeVariablesParameters(PolynomialRing const &genericRing, PolynomialSet const &p)
 
297
{
 
298
        PolynomialSet ret(genericRing);
 
299
        for(PolynomialSet::const_iterator i=p.begin();i!=p.end();i++)
 
300
                ret.push_back(makeVariablesParameters(genericRing,*i));
 
301
 
 
302
        return ret;
 
303
}