Polynomial_impl.ipp

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_IMPL_IPP_
#define _POLYNOMIAL_IMPL_IPP_

#include "../include/Polynomial.hpp"
#include <stdexcept>
#include <iterator>
#ifdef VERBOSE
#include <iostream>
#endif

template <typename FieldT>
Polynomial<FieldT>::Polynomial(std::initializer_list<FieldT> in_list)
   :m_coefs{in_list},m_size{in_list.size()}
{
   trim();
}
template <typename FieldT>
template <typename InputIt>
Polynomial<FieldT>::Polynomial(InputIt first, InputIt last)
{
   for(auto it=first;  it != last; ++it) {
      m_coefs.push_back(*it);
      m_size++;
   }
   trim();
}
template <typename FieldT>
Polynomial<FieldT>::Polynomial(FieldT c)
   :m_coefs{c},m_size{1}
{
   trim();
}
template <typename FieldT>
template <typename convertibleToFieldT>
Polynomial<FieldT>::Polynomial(convertibleToFieldT v)
   :m_coefs{static_cast<FieldT>(v)},m_size{1}
{
   trim();
}

template<typename FieldT>
void Polynomial<FieldT>::appendTerm(FieldT coeff)
{
   m_coefs.push_back(coeff);
   ++m_size;
}
template <typename FieldT>
const FieldT& Polynomial<FieldT>::operator[] (size_t i) const 
{
   if(i>=m_size){
      throw std::out_of_range("");
   }
   return *(std::next(m_coefs.begin(),i));
}

template <typename FieldT>
FieldT& Polynomial<FieldT>::operator[] (size_t i) 
{
   /* calling the const version of the operator to avoid code duplication */
   return const_cast<FieldT&>((static_cast<Polynomial<FieldT> const*>(this)->operator[](i)));
}

template <typename FieldT>
Polynomial<FieldT> const & Polynomial<FieldT>::operator=(const Polynomial<FieldT>& rhs_ref)
{
   #ifdef VERBOSE
   std::cout<<"=(&)"<<std::endl;
   #endif
   /* Provide self assignment protection if the use cases demand. Skipping for now.*/
   Polynomial<FieldT> rhs (rhs_ref);
   using std::swap; // Just incase we need ADL
   swap(*this,rhs);
   return *this;
  
}
template <typename FieldT>
Polynomial<FieldT> const& Polynomial<FieldT>::operator=(Polynomial<FieldT>&& rhs)
{
   /* Provide self assignment protection if the use caandses demand. Skipping for now.*/
   #ifdef VERBOSE
   std::cout<<"=(&&)"<<std::endl;
   #endif

   using std::swap; // Just incase we need ADL
   swap(*this,rhs);
   return *this;
  
}




template <typename FieldT>
Polynomial<FieldT> const& Polynomial<FieldT>::operator+=(Polynomial<FieldT> const& p2)
{
   #ifdef VERBOSE
   std::cout<<"+=(&) "<<std::endl;
   #endif
   /* identify the polynomial which has higher degree*/
   Polynomial<FieldT> const& bigger_polynomial =  p2.size() > this->size() ? p2 : *this;
   Polynomial<FieldT> const& smaller_polynomial = p2.size() <= this->size() ? p2 : *this;
   /* copy the bigger polynomial */
   Polynomial<FieldT> copy_for_swap(bigger_polynomial);
   /* \todo Coefficient iterator class for Polynomial */
   auto s_it = smaller_polynomial.m_coefs.begin();
   auto b_it = copy_for_swap.m_coefs.begin();
   for( ;s_it != smaller_polynomial.m_coefs.end();) {
      *b_it+=*s_it; 
      ++s_it;
      ++b_it;
   } 
   /* ensure that the invariant is maintained */
   copy_for_swap.trim();
  /* swap this */
  swap(*this,copy_for_swap); 
  return *this;
}
template <typename FieldT>
Polynomial<FieldT> const& Polynomial<FieldT>::operator+=(Polynomial<FieldT>&& p2)
{
   #ifdef VERBOSE
   std::cout<<"+=(&&) "<<std::endl;
   #endif
   /* identify the polynomial which has higher degree*/
   Polynomial<FieldT>& bigger_polynomial =  p2.size() > this->size() ? p2 : *this;
   Polynomial<FieldT> const& smaller_polynomial = p2.size() <= this->size() ? p2 : *this;
   /* \todo Coefficient iterator class for Polynomial */
   auto s_it = smaller_polynomial.m_coefs.begin();
   auto b_it = bigger_polynomial.m_coefs.begin();
   for( ;s_it != smaller_polynomial.m_coefs.end();) {
      *b_it+=*s_it; 
      ++s_it;
      ++b_it;
   } 
   /* ensure that the invariant is maintained */
   bigger_polynomial.trim();
  /* swap this */
  swap(*this,bigger_polynomial); 
  return *this;
}
template <typename FieldT>
Polynomial<FieldT> const& Polynomial<FieldT>::operator-=(Polynomial<FieldT> const& p2)
{
   #ifdef VERBOSE
   std::cout<<"-=(&) "<<std::endl;
   #endif
   return (*this+=-p2);
}

template <typename FieldT>
Polynomial<FieldT> const& Polynomial<FieldT>::operator-=(Polynomial<FieldT>&& p2)
{
   #ifdef VERBOSE
   std::cout<<"-=(&&) "<<std::endl;
   #endif

   return (*this+=-std::move(p2));
}

template <typename FieldT>
Polynomial<FieldT> Polynomial<FieldT>::operator+(Polynomial<FieldT> p2) const
{
   #ifdef VERBOSE
   std::cout<<"this+(value) "<<std::endl;
   #endif
   p2+=(*this);
   return std::move(p2);
}
template <typename FieldT>
Polynomial<FieldT> Polynomial<FieldT>::operator+(const Polynomial<FieldT>& p2) 
{
   return static_cast<const Polynomial<FieldT>*>(this)->operator+(p2);
}

template <typename FieldT>
Polynomial<FieldT> Polynomial<FieldT>::operator-(Polynomial<FieldT> p2) const 
{
   #ifdef VERBOSE
   std::cout<<"this-(value) "<<std::endl;
   #endif
   Polynomial<FieldT> temp (-std::move(p2));
   temp+=*this;
   return std::move(temp);
}

template <typename FieldT>
Polynomial<FieldT> Polynomial<FieldT>::operator-(const Polynomial<FieldT>& p2) 
{
   return static_cast<const Polynomial<FieldT>*>(this)->operator-(p2);
}
/******************* Helpers **********************/
template <typename FieldT>
void Polynomial<FieldT>::trim() 
{
   for(typename std::list<FieldT>::reverse_iterator r_it = m_coefs.rbegin(); r_it != m_coefs.rend(); ) {
      /* remove trailing zeros but if there is only one coefficient and that is zero then leave it to be a 
       * zero polynomial */
      if ( *r_it == 0 && size() >1) {
         typename std::list<FieldT>::reverse_iterator to_delete_it = r_it;
         ++r_it; // reverse iterator decremented
         m_coefs.erase(--to_delete_it.base()); //pre-decrement necessary as base points to an element ahead of rit which would be end() 
         m_size--;
      }
      else {
         break; // break as soon as we find first non-zero coeff from behind
      }
   }
}

template <typename FieldT>
Polynomial<FieldT>& Polynomial<FieldT>::minus() {
   for(auto& coef : m_coefs) {
      coef = ::minus(coef);
   }
   return *this;
}


#endif// _POLYNOMIAL_IPP_