Gröbner basis project
Codebase for research into Gröbner basis computation
polynomial.hpp
1 #ifndef __POLYNOMIAL_H_
2 #define __POLYNOMIAL_H_
3 
4 /*****************************************************************************\
5 * This file is part of DynGB. *
6 * *
7 * DynGB is free software: you can redistribute it and/or modify *
8 * it under the terms of the GNU General Public License as published by *
9 * the Free Software Foundation, either version 2 of the License, or *
10 * (at your option) any later version. *
11 * *
12 * Foobar is distributed in the hope that it will be useful, *
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
15 * GNU General Public License for more details. *
16 * *
17 * You should have received a copy of the GNU General Public License *
18 * along with DynGB. If not, see <http://www.gnu.org/licenses/>. *
19 \*****************************************************************************/
20 
26 #include <cstdlib>
27 #include <iostream>
28 
29 using std::cout; using std::endl;
30 
31 #include "fields.hpp"
32 #include "monomial.hpp"
33 #include "strategies.hpp"
34 #include "polynomial_ring.hpp"
35 
36 extern Monomial_Ordering * generic_grevlex_ptr;
37 
38 // forward declarations
39 class Polynomial;
41 class Poly_Strategy_Data;
42 
61 public:
63  Polynomial_Term(const Monomial & m, const Prime_Field_Element & a) : t(m), c(a)
65  { /* already initialized */ }
67 
68 
70  const Monomial & monomial() { return t; }
72  const Prime_Field_Element & coefficient() { return c; }
74 protected:
76  const Monomial & t;
79 };
80 
102 {
103 public:
105 
111  : R(ring)
112  { }
114 
115  virtual ~Abstract_Polynomial() { if (strat != nullptr) delete strat; };
118 
119 
121  Polynomial_Ring & base_ring() const;
123  Prime_Field & ground_field();
128  unsigned number_of_variables() const;
131  return leading_monomial().monomial_ordering();
132  }
134  virtual Monomial & leading_monomial() const = 0;
136  virtual Prime_Field_Element leading_coefficient() const = 0;
138  virtual unsigned length() const = 0;
140  virtual bool is_zero() const = 0;
142  virtual bool can_reduce(Abstract_Polynomial &other) const;
144  virtual Poly_Strategy_Data * strategy() const { return strat; }
146  virtual DEG_TYPE standard_degree() const;
152  virtual DEG_TYPE weighted_degree(const WT_TYPE * w = nullptr) const;
154 
155 
157  virtual Abstract_Polynomial * zero_polynomial() const = 0;
159  virtual Abstract_Polynomial * monomial_multiple(const Monomial &) const = 0;
161  virtual Abstract_Polynomial * scalar_multiple(const Prime_Field_Element &)
162  const = 0;
164  void set_strategy(Poly_Strategy_Data * psd);
166 
167 
178  virtual void set_monomial_ordering(
179  const Monomial_Ordering * order, bool sort_anew = true
180  ) = 0;
187  virtual void sort_by_order() = 0;
189 
190 
192  virtual Polynomial_Iterator * new_iterator() const = 0;
193  virtual Polynomial_Iterator * begin() const = 0;
194  virtual Polynomial_Iterator * end() const = 0;
196 
197 
199  friend ostream & operator << (ostream & os,
200  const Abstract_Polynomial & p);
201  virtual void print(ostream & os=cout) const;
202  virtual void println(ostream & os=cout) const;
203  virtual void printlncout() const { println(); }
205 protected:
209  Poly_Strategy_Data * strat = nullptr;
210 };
211 
225 {
226 public:
228 
230  virtual ~Polynomial_Iterator() = 0;
232 
233 
235  virtual void restart_iteration() = 0;
237  virtual void moveRight() = 0;
239  const Polynomial_Iterator & operator++() { moveRight(); return *this; }
241  virtual bool canMoveRight() const = 0;
243  virtual void moveLeft() = 0;
245  virtual bool canMoveLeft() const = 0;
252  virtual bool fellOff() const = 0;
254 
255 
257  virtual const Abstract_Polynomial * my_poly() const { return p; }
259  virtual const Monomial & currMonomial() const = 0;
261  virtual const Prime_Field_Element & currCoeff() const = 0;
263  const Polynomial_Term operator *() const {
264  return Polynomial_Term(currMonomial(), currCoeff());
265  }
266  virtual bool operator !=(const Polynomial_Iterator & other) const {
267  return my_poly() != other.my_poly() or currMonomial() != other.currMonomial();
268  }
270 protected:
273 };
274 
284 {
285 public:
287 
289  virtual void set_currCoeff(const Prime_Field_Element &) = 0;
291  virtual void set_currMonomial(const Monomial &) = 0;
293 };
294 
306 {
307 public:
309 
312  Polynomial_Ring & R,
313  const Monomial_Ordering * ordering = generic_grevlex_ptr
314  ) : Abstract_Polynomial(R, ordering) { }
316 
317 
319  virtual ~Mutable_Polynomial() = 0;
321 
322 
324  virtual Mutable_Polynomial * zero_polynomial() const = 0;
326  virtual Mutable_Polynomial & operator +=(const Abstract_Polynomial &) = 0;
328  virtual Mutable_Polynomial & operator -=(const Abstract_Polynomial &) = 0;
330  virtual void add_polynomial_multiple(const Prime_Field_Element &,
331  const Monomial &,
332  const Abstract_Polynomial &,
333  bool subtract = false
334  ) = 0;
336  virtual void multiply_by_scalar(const Prime_Field_Element &a);
338  virtual void multiply_by_monomial(const Monomial &t);
340  virtual void reduce_by(const Abstract_Polynomial &p);
341  // utility
343  virtual Mutable_Polynomial * monomial_multiple(const Monomial &) const = 0;
345  virtual Mutable_Polynomial * scalar_multiple(const Prime_Field_Element &)
346  const = 0;
348 
349 
351  virtual Mutable_Polynomial_Iterator * new_mutable_iterator() = 0;
353 
354 
356  virtual Mutable_Polynomial * detach_head() = 0;
358  virtual void add_last(const Prime_Field_Element &, const Monomial &) = 0;
360 };
361 
362 #endif
Mutable_Polynomial(Polynomial_Ring &R, const Monomial_Ordering *ordering=generic_grevlex_ptr)
constructor
Definition: polynomial.hpp:311
The general class of a polynomial.
Definition: polynomial.hpp:101
const Monomial_Ordering * monomial_ordering() const
reports leading monomial’s monomial ordering
Definition: polynomial.hpp:130
polynomial-related strategy data
Definition: strategies.hpp:49
const Prime_Field_Element & coefficient()
the coefficient for this term
Definition: polynomial.hpp:72
Information necessary for a field modulo a prime.
Definition: fields.hpp:49
const Abstract_Polynomial * p
the polynomial this points to
Definition: polynomial.hpp:272
ray operator*(RAYENT_TYPE a, ray &r)
Multiply every coordinate in the given ray by the given scalar.
Definition: lp_solver.cpp:222
virtual const Abstract_Polynomial * my_poly() const
Reports the polynomial on which this is iterating.
Definition: polynomial.hpp:257
const Prime_Field_Element & c
the coefficient of this term
Definition: polynomial.hpp:78
Polynomials that need arithmetic typically descend from this class.
Definition: polynomial.hpp:305
Implementation of monomials.
Definition: monomial.hpp:69
Element of a field of prime characteristic.
Definition: fields.hpp:137
const Polynomial_Iterator & operator++()
Moves right in the polynomial, to the next smaller monomial.
Definition: polynomial.hpp:239
interface to a monomial ordering
Encapsulates information about a polynomial ring for easy access: ground field, number of indetermina...
A Mutable_Polynomial_Iterator allows one to modify the terms of a polynomial.
Definition: polynomial.hpp:283
const Monomial & monomial()
the monomial of this term
Definition: polynomial.hpp:70
Abstract_Polynomial(Polynomial_Ring &ring, const Monomial_Ordering *ordering)
Definition: polynomial.hpp:110
const Monomial & t
the monomial part of this term
Definition: polynomial.hpp:76
convenience class to help iterate through polynomials
Definition: polynomial.hpp:60
Used to iterate through a polynomial.
Definition: polynomial.hpp:224
virtual const Monomial & currMonomial() const =0
Reports the monomial at the current position.
Polynomial_Ring & R
data about polynomial ring
Definition: polynomial.hpp:207
virtual Poly_Strategy_Data * strategy() const
strategy related information
Definition: polynomial.hpp:144