algebra/laurent_polynomial.h

// -*- c++ -*-

// +--------------------------------------------------------------------+
// | This file is part of MathTL - the Mathematical Template Library    |
// |                                                                    |
// | Copyright (c) 2002-2009                                            |
// | Thorsten Raasch, Manuel Werner                                     |
// +--------------------------------------------------------------------+

#ifndef _MATHTL_LAURENT_POLYNOMIAL_H
#define _MATHTL_LAURENT_POLYNOMIAL_H

#include <cassert>
#include <utils/function.h>
#include <algebra/infinite_vector.h>
#include <algebra/polynomial.h>
#include <geometry/point.h>

namespace MathTL
{
  template <class R>
  class LaurentPolynomial
    : protected InfiniteVector<R,int>, public Function<1, R>
  {
  public:
    typedef typename InfiniteVector<R,int>::const_iterator
    const_iterator;

    typedef typename InfiniteVector<R,int>::const_reverse_iterator
    const_reverse_iterator;

    LaurentPolynomial();

    LaurentPolynomial(const LaurentPolynomial<R>& p);

    explicit LaurentPolynomial(const R c);

    explicit LaurentPolynomial(const Polynomial<R>& p);

    virtual ~LaurentPolynomial();

    LaurentPolynomial<R>& operator = (const LaurentPolynomial<R>& p);

    LaurentPolynomial<R>& operator = (const R c);

    unsigned int degree() const;

    R get_coefficient(const int k) const;

    void set_coefficient(const int k, const R coeff);

    const_iterator begin() const;

    const_iterator end() const;

    const_reverse_iterator rbegin() const;

    const_reverse_iterator rend() const;

    R value(const R x) const;

    R value(const Point<1>& p,
            const unsigned int component = 0) const;

    void vector_value(const Point<1> &p,
                      Vector<R>& values) const;

    void add(const LaurentPolynomial<R>& p);

    void add(const R s, const LaurentPolynomial<R>& p);

    void sadd(const R s, const LaurentPolynomial<R>& p);

    LaurentPolynomial<R>& operator += (const LaurentPolynomial<R>& p);

    LaurentPolynomial<R> operator + (const LaurentPolynomial<R>& p) const;

    void subtract(const LaurentPolynomial<R>& p);

    LaurentPolynomial<R>& operator -= (const LaurentPolynomial<R> &p);

    LaurentPolynomial<R> operator - () const;
    
    LaurentPolynomial<R> operator - (const LaurentPolynomial<R> &p) const;

    LaurentPolynomial<R>& operator *= (const R c);

    LaurentPolynomial<R> operator * (const R c) const;
    
    void multiply(const LaurentPolynomial<R>& p);

    LaurentPolynomial<R>& operator *= (const LaurentPolynomial<R>& p);

    LaurentPolynomial<R> power(const unsigned int k) const;

    void divide(const LaurentPolynomial<R>& q, LaurentPolynomial<R>& p) const;

    void divide(const LaurentPolynomial<R>& q,
                LaurentPolynomial<R>& p, LaurentPolynomial<R>& r) const;
  };

  template <class R>
  LaurentPolynomial<R> operator * (const R c, const LaurentPolynomial<R>& p);

  template <class R>
  LaurentPolynomial<R> operator * (const LaurentPolynomial<R>& p,
                                   const LaurentPolynomial<R>& q);
    
  template <class R>
  std::ostream& operator << (std::ostream &s, const LaurentPolynomial<R> &p);

}

// include implementation of inline functions
#include <algebra/laurent_polynomial.cpp>

#endif