Polynomial.hpp

Go to the documentation of this file.

//   Copyright 2018 Dhruvesh Nikhilkumar Patel
//
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.
//
#ifndef _POLYNOMIAL_HPP_
#define _POLYNOMIAL_HPP_

#include<list> // for doubly linked list
#include <initializer_list> // for init lists arguments
#ifdef INTRUSIVE_TESTS
#include "gtest/gtest.h"
#endif
#include <iostream>
#include <algorithm>

template<typename FieldT>
class PolynomialMultiplicationInterface;

template <typename FieldT>
class Polynomial
{

public:
   /*********** Constructors **************/
   Polynomial():m_coefs(),m_size(0){}
   Polynomial(std::initializer_list<FieldT>);
   template <typename InputIt>
   Polynomial(InputIt first, InputIt last);

   Polynomial(FieldT c);
   template <typename convertibleToFieldT>
   Polynomial (convertibleToFieldT v);
   Polynomial(const Polynomial& rhs) 
      :m_coefs{rhs.m_coefs},m_size{rhs.m_size}
   {
      #ifdef VERBOSE
      std::cout<<"copy constructor Polynomial(const Polynomial&)"<<std::endl;
      #endif
   }
   Polynomial(Polynomial&& rhs):Polynomial()
   {
      #ifdef VERBOSE
      std::cout<<"move constructor Polynomial(Polynomial&&)"<<std::endl;
      #endif
      swap(*this,rhs);
   }
   void appendTerm(FieldT coeff);
   
   /************** Operators *************/
   const FieldT& operator[](size_t i) const;
   FieldT& operator[](size_t i) ;


   friend void swap(Polynomial& lhs, Polynomial& rhs) noexcept
   {
      std::swap(lhs.m_coefs,rhs.m_coefs);
      std::swap(lhs.m_size,rhs.m_size);
   }


   Polynomial const& operator=(const Polynomial& rhs);
   Polynomial const& operator=(Polynomial&& rhs);

   friend Polynomial operator-(Polynomial const& rhs) {
      #ifdef VERBOSE
      std::cout<<"friend -(const &)"<<std::endl;
      #endif
      Polynomial<FieldT> temp (rhs);
      temp.minus();
      return temp;
   }
   friend Polynomial operator-(Polynomial&& temp)  {
      #ifdef VERBOSE
      std::cout<<"friend -(&&)"<<std::endl;
      #endif
      temp.minus();
      return std::move(temp); 
   }
   const Polynomial& operator+=(Polynomial const& p2) ;
   const Polynomial& operator+=(Polynomial&& p2) ;
   const Polynomial& operator-=(Polynomial const& p2) ;
   const Polynomial& operator-=(Polynomial&& p2) ;

   Polynomial operator+(const Polynomial& p2);
   Polynomial operator+(Polynomial p2) const;

   Polynomial operator-(const Polynomial& p2);
   Polynomial operator-(Polynomial p2) const;

  
public: 
   /********** getters **********/
   size_t size() {return m_size;}
   size_t size() const {return m_size;}
   friend std::ostream& operator<< (std::ostream& os, const Polynomial& p) 
   {   
      size_t pow=0;
      os<<"(";
      std::for_each(p.m_coefs.begin(),p.m_coefs.end(), [&](const FieldT& coef) {os<< "+ "<<coef <<"x^"<<pow <<" ";++pow; });
      os<<")";
      return os; 
   }
private:
   std::list<FieldT> m_coefs; 
   size_t m_size; 
   /*********** Helpers ********/
   void trim();


   Polynomial& minus();


   /************ Friend classes ************/
   friend class PolynomialMultiplicationInterface<FieldT>;

#ifdef INTRUSIVE_TESTS
public: 
   friend class PolynomialTest;
   FRIEND_TEST(PolynomialTest,helper_trim);
   FRIEND_TEST(PolynomialTest,helper_minus);
   friend class PolynomialTestMPZ;
   FRIEND_TEST(PolynomialMPZTest,helper_trim);
   FRIEND_TEST(PolynomialMPZTest,helper_minus);
#endif

};
//namespace PolynomialNS {
//   /*! \brief Brief function description here
//    * \param lhs lhs+=rhs
//    * \param rhs lhs+=rhs
//    */
//   template <typename FieldT>
//   FieldT& add_assign(FieldT& lhs,const FieldT& rhs) {
//      return lhs+=rhs;
//   }
//   /*! \brief Brief function description here
//    * \param lhs lhs-=rhs
//    * \param rhs lhs-=rhs
//    */
//   template <typename FieldT>
//   FieldT& subtract_assign(FieldT& lhs,const FieldT& rhs) {
//      return lhs-=rhs;
//   }
//}
template <typename T>
T minus(T v) {
   return -v;
}

template<typename FieldT>
Polynomial<FieldT> operator*(const Polynomial<FieldT>& p1, const Polynomial<FieldT>& p2);



#endif //_POLYNOMIAL_HPP_