Use std::vector instead of Array; add explicit move to polynomial

Author: tturocy

src/solvers/enumpoly/poly.cc

@@ -26,16 +26,16 @@
 namespace Gambit {
 
 template <class T>
-Array<Monomial<T>> Polynomial<T>::Adder(const Array<Monomial<T>> &p_one,
-                                        const Array<Monomial<T>> &p_two) const
+std::vector<Monomial<T>> Polynomial<T>::Adder(const std::vector<Monomial<T>> &p_one,
+                                              const std::vector<Monomial<T>> &p_two) const
 {
   if (p_one.empty()) {
     return p_two;
   }
   if (p_two.empty()) {
     return p_one;
   }
-  Array<Monomial<T>> answer;
+  std::vector<Monomial<T>> answer;
   answer.reserve(p_one.size() + p_two.size());
 
   auto it1 = p_one.begin();
@@ -73,10 +73,10 @@ Array<Monomial<T>> Polynomial<T>::Adder(const Array<Monomial<T>> &p_one,
 }
 
 template <class T>
-Array<Monomial<T>> Polynomial<T>::Mult(const Array<Monomial<T>> &p_one,
-                                       const Array<Monomial<T>> &p_two) const
+std::vector<Monomial<T>> Polynomial<T>::Mult(const std::vector<Monomial<T>> &p_one,
+                                             const std::vector<Monomial<T>> &p_two) const
 {
-  Array<Monomial<T>> result;
+  std::vector<Monomial<T>> result;
 
   if (p_one.empty() || p_two.empty()) {
     return result;
@@ -90,7 +90,7 @@ Array<Monomial<T>> Polynomial<T>::Mult(const Array<Monomial<T>> &p_one,
   }
   std::sort(result.begin(), result.end(),
             [](const Monomial<T> &a, const Monomial<T> &b) { return a.ExpV() < b.ExpV(); });
-  Array<Monomial<T>> merged;
+  std::vector<Monomial<T>> merged;
   merged.reserve(result.size());
 
   auto it = result.begin();
@@ -152,7 +152,7 @@ template <class T> Polynomial<T> Polynomial<T>::DivideByPolynomial(const Polynom
 
 template <class T> Polynomial<T> Polynomial<T>::PartialDerivative(int varnumber) const
 {
-  Array<Monomial<T>> terms;
+  std::vector<Monomial<T>> terms;
   terms.reserve(m_terms.size());
 
   for (const auto &term : m_terms) {
@@ -164,14 +164,15 @@ template <class T> Polynomial<T> Polynomial<T>::PartialDerivative(int varnumber)
     terms.emplace_back(term.Coef() * static_cast<T>(exponent), expv.DecrementExponent(varnumber));
   }
 
-  Polynomial<T> result(m_space);
+  Polynomial result(m_space);
   result.m_terms = std::move(terms);
   return result;
 }
 
 template <class T> Polynomial<T> Polynomial<T>::LeadingCoefficient(int varnumber) const
 {
   Polynomial result(m_space);
+  result.m_terms.reserve(m_terms.size());
 
   const int degree = DegreeOfVar(varnumber);
   if (degree == 0) {
@@ -239,6 +240,7 @@ Polynomial<T> Polynomial<T>::TranslateOfMono(const Monomial<T> &m,
 template <class T> Polynomial<T> Polynomial<T>::TranslateOfPoly(const Vector<T> &new_origin) const
 {
   Polynomial answer(m_space);
+  answer.m_terms.reserve(m_terms.size());
   for (const auto &mono : m_terms) {
     answer += TranslateOfMono(mono, new_origin);
   }
@@ -261,6 +263,7 @@ Polynomial<T> Polynomial<T>::MonoInNewCoordinates(const Monomial<T> &m, const Ma
     }
 
     Polynomial linearform(m_space);
+    linearform.m_terms.reserve(GetDimension());
     for (int j = 1; j <= dim; ++j) {
       const T &coeff = M(var_index, j);
       if (coeff != static_cast<T>(0)) {
@@ -276,6 +279,7 @@ Polynomial<T> Polynomial<T>::MonoInNewCoordinates(const Monomial<T> &m, const Ma
 template <class T> Polynomial<T> Polynomial<T>::PolyInNewCoordinates(const Matrix<T> &M) const
 {
   Polynomial answer(m_space);
+  answer.m_terms.reserve(m_terms.size());
   for (const auto &term : m_terms) {
     answer += MonoInNewCoordinates(term, M);
   }

src/solvers/enumpoly/poly.h

@@ -240,11 +240,13 @@ template <class T> class Monomial {
 // A multivariate polynomial
 template <class T> class Polynomial {
   std::shared_ptr<VariableSpace> m_space;
-  Array<Monomial<T>> m_terms;
+  std::vector<Monomial<T>> m_terms;
 
   // Arithmetic
-  Array<Monomial<T>> Adder(const Array<Monomial<T>> &, const Array<Monomial<T>> &) const;
-  Array<Monomial<T>> Mult(const Array<Monomial<T>> &, const Array<Monomial<T>> &) const;
+  std::vector<Monomial<T>> Adder(const std::vector<Monomial<T>> &,
+                                 const std::vector<Monomial<T>> &) const;
+  std::vector<Monomial<T>> Mult(const std::vector<Monomial<T>> &,
+                                const std::vector<Monomial<T>> &) const;
   Polynomial DivideByPolynomial(const Polynomial &den) const;
 
   Polynomial TranslateOfMono(const Monomial<T> &, const Vector<T> &) const;
@@ -260,6 +262,8 @@ template <class T> class Polynomial {
     }
   }
   Polynomial(const Polynomial &) = default;
+  Polynomial(Polynomial &&) = default;
+  Polynomial &operator=(Polynomial &&) = default;
   // Constructs a polynomial x_{var_no}^exp
   explicit Polynomial(std::shared_ptr<VariableSpace> p, const int var_no, const int exp)
     : m_space(p)
@@ -370,7 +374,7 @@ template <class T> class Polynomial {
       return std::max(v, m.TotalDegree());
     });
   }
-  [[nodiscard]] const Array<Monomial<T>> &GetTerms() const noexcept { return m_terms; }
+  [[nodiscard]] const std::vector<Monomial<T>> &GetTerms() const noexcept { return m_terms; }
   bool IsZero() const noexcept { return m_terms.empty(); }
   bool IsConstant() const noexcept
   {