algebra/infinite_vector.h

// -*- c++ -*-

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

#ifndef _MATHTL_INFINITE_VECTOR_H
#define _MATHTL_INFINITE_VECTOR_H

#include <set>
#include <map>
#include <algorithm>
#include <iterator>
#include <utils/array1d.h>
#include <algebra/infinite_matrix.h>

// external functionality, for convenience:
#include <algebra/vector_norms.h>
#include <algebra/vector_arithmetics.h>

namespace MathTL
{
  template <class C, class I = int>
  class InfiniteVector
    : protected std::map<I,C>
  {
  public:
    InfiniteVector();

    InfiniteVector(const InfiniteVector<C,I>& v);

    class const_iterator
      : protected std::map<I,C>::const_iterator
    {
    public:
      typedef typename std::map<I,C>::const_iterator::iterator_category iterator_category;

      typedef typename std::map<I,C>::const_iterator::value_type value_type;

      typedef typename std::map<I,C>::const_iterator::difference_type difference_type;

      typedef typename std::map<I,C>::const_iterator::pointer pointer;

      typedef typename std::map<I,C>::const_iterator::reference reference;

      const_iterator(const typename std::map<I,C>::const_iterator& entry);

      const_iterator& operator ++ ();

      const_iterator operator ++ (int step);

      const C& operator * () const;

      const C* operator -> () const;

      I index() const;

      bool operator == (const const_iterator& it) const;

      bool operator != (const const_iterator& it) const;

      bool operator < (const const_iterator& it) const;
    };

    const_iterator begin() const;

    const_iterator end() const;

    class const_reverse_iterator
      : protected std::reverse_iterator<typename std::map<I,C>::const_iterator>
    {
    public:
      const_reverse_iterator(const std::reverse_iterator<typename std::map<I,C>::const_iterator>& entry);

      const_reverse_iterator& operator ++ ();

      const_reverse_iterator operator ++ (int step);

      const C& operator * () const;

      const C* operator -> () const;

      I index() const;

      bool operator == (const const_reverse_iterator& it) const;

      bool operator != (const const_reverse_iterator& it) const;

      bool operator < (const const_reverse_iterator& it) const;
    };

    const_reverse_iterator rbegin() const;

    const_reverse_iterator rend() const;

    InfiniteVector<C,I>& operator = (const InfiniteVector<C,I>& v);

    void swap (InfiniteVector<C,I>& v);

    inline bool empty() const { return std::map<I,C>::empty(); }

    void clear();
    
    bool operator == (const InfiniteVector<C,I>& v) const;

    bool operator != (const InfiniteVector<C,I>& v) const;

    C operator [] (const I& index) const;

    C get_coefficient(const I& index) const;

    C& operator [] (const I& index);

    void set_coefficient(const I& index, const C value);

    size_t size() const;

    void support(std::set<I>& supp) const;
    
    void clip(const std::set<I>& supp);

    void compress(const double eta = 1e-15);

    void add_coefficient(const I& index, const C increment);

    void add(const InfiniteVector<C,I>& v);

    void add(const C s, const InfiniteVector<C,I>& v);

    void sadd(const C s, const InfiniteVector<C,I>& v);

    void scale(const C s);

    void scale(const InfiniteDiagonalMatrix<C,I>* D, const int k = 1);
    
    InfiniteVector<C,I>& operator += (const InfiniteVector<C,I>& v);

    void subtract(const InfiniteVector<C,I>& v);

    InfiniteVector<C,I>& operator -= (const InfiniteVector<C,I>& v);

    InfiniteVector<C,I>& operator *= (const C c);
    
    InfiniteVector<C,I>& operator /= (const C c);

    const C operator * (const InfiniteVector<C,I>& v) const;

    struct decreasing_order
      : public std::binary_function<const std::pair<I,C>&,
                                    const std::pair<I,C>&,
                                    bool>
    {
      inline bool operator () (const std::pair<I,C>& p1,
                               const std::pair<I,C>& p2)
      {
        return (fabs(p1.second) > fabs(p2.second));
      }
    };

    double weak_norm(const double tau) const;

    void COARSE(const double eps, InfiniteVector<C,I>& v) const;
    
//     /*!
//       Computes v such that \|*this-v\|_{\ell_2}\le\epsilon;
//       In contrast to the usual coarse routine, here the 
//       This routine is a suggestion from Rob Stevenson.
//     */
//     void COARSE(const double eps, InfiniteVector<C,I>& v) const;

    const double wrmsqr_norm(const double atol, const double rtol,
                             const InfiniteVector<C,I>& v, const InfiniteVector<C,I>& w) const; 
  };
  
  template <class C, class I>
  InfiniteVector<C,I> operator + (const InfiniteVector<C,I>& v1,
                                  const InfiniteVector<C,I>& v2)
  {
    InfiniteVector<C,I> r(v1);
    r += v2;
    return r;
  }

  template <class C, class I>
  InfiniteVector<C,I> operator - (const InfiniteVector<C,I>& v1,
                                  const InfiniteVector<C,I>& v2)
  {
    InfiniteVector<C,I> r(v1);
    r -= v2;
    return r;
  }

  template <class C, class I>
  InfiniteVector<C,I> operator - (const InfiniteVector<C,I>& v)
  {
    InfiniteVector<C,I> r(v);
    r -= C(-1);
    return r;
  }

  template <class C, class I>
  InfiniteVector<C,I> operator * (const C c, const InfiniteVector<C,I>& v)
  {
     InfiniteVector<C,I> r(v);
     r *= c;
     return r;
  }

  template <class C, class I>
  void swap(InfiniteVector<C,I>& v1, InfiniteVector<C,I>& v2);

  template<class C, class I>
  std::ostream& operator << (std::ostream& os, const InfiniteVector<C,I>& v);
}

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

#endif