vbvector.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_VBVECTOR_HH
#define DUNE_VBVECTOR_HH
 
#include <cmath>
#include <complex>
#include <iostream>
#include <memory>
 
#include "istlexception.hh"
#include "bvector.hh"
 
namespace Dune {
 
  template<class B, class A=std::allocator<B> >
  class VariableBlockVector : public block_vector_unmanaged<B,A>
                              // this derivation gives us all the blas level 1 and norms
                              // on the large array. However, access operators have to be
                              // overwritten.
  {
  public:
 
    //===== type definitions and constants
 
    typedef typename B::field_type field_type;
 
    typedef A allocator_type;
 
    typedef typename A::size_type size_type;
 
    typedef BlockVector<B,A> block_type;
 
    enum {
      blocklevel = B::blocklevel+2
    };
 
    // just a shorthand
    typedef BlockVectorWindow<B,A> window_type;
 
 
    //===== constructors and such
 
    VariableBlockVector () : block_vector_unmanaged<B,A>()
    {
      // nothing is known ...
      nblocks = 0;
      block = 0;
      initialized = false;
    }
 
    explicit VariableBlockVector (size_type _nblocks) : block_vector_unmanaged<B,A>()
    {
      // we can allocate the windows now
      nblocks = _nblocks;
      if (nblocks>0)
      {
        block = windowAllocator_.allocate(nblocks);
        new (block) window_type[nblocks];
      }
      else
      {
        nblocks = 0;
        block = 0;;
      }
 
      // Note: memory in base class still not allocated
      // the vector not usable
      initialized = false;
    }
 
    VariableBlockVector (size_type _nblocks, size_type m) : block_vector_unmanaged<B,A>()
    {
      // and we can allocate the big array in the base class
      this->n = _nblocks*m;
      if (this->n>0)
      {
        this->p = allocator_.allocate(this->n);
        new (this->p)B[this->n];
      }
      else
      {
        this->n = 0;
        this->p = 0;
      }
 
      // we can allocate the windows now
      nblocks = _nblocks;
      if (nblocks>0)
      {
        // allocate and construct the windows
        block = windowAllocator_.allocate(nblocks);
        new (block) window_type[nblocks];
 
        // set the windows into the big array
        for (size_type i=0; i<nblocks; ++i)
          block[i].set(m,this->p+(i*m));
      }
      else
      {
        nblocks = 0;
        block = 0;;
      }
 
      // and the vector is usable
      initialized = true;
    }
 
    VariableBlockVector (const VariableBlockVector& a)
    {
      // allocate the big array in the base class
      this->n = a.n;
      if (this->n>0)
      {
        // allocate and construct objects
        this->p = allocator_.allocate(this->n);
        new (this->p)B[this->n];
 
        // copy data
        for (size_type i=0; i<this->n; i++) this->p[i]=a.p[i];
      }
      else
      {
        this->n = 0;
        this->p = 0;
      }
 
      // we can allocate the windows now
      nblocks = a.nblocks;
      if (nblocks>0)
      {
        // alloc
        block = windowAllocator_.allocate(nblocks);
        new (block) window_type[nblocks];
 
        // and we must set the windows
        block[0].set(a.block[0].getsize(),this->p);           // first block
        for (size_type i=1; i<nblocks; ++i)                         // and the rest
          block[i].set(a.block[i].getsize(),block[i-1].getptr()+block[i-1].getsize());
      }
      else
      {
        nblocks = 0;
        block = 0;;
      }
 
      // and we have a usable vector
      initialized = true;
    }
 
    ~VariableBlockVector ()
    {
      if (this->n>0) {
        size_type i=this->n;
        while (i)
          this->p[--i].~B();
        allocator_.deallocate(this->p,this->n);
      }
      if (nblocks>0) {
        size_type i=nblocks;
        while (i)
          block[--i].~window_type();
        windowAllocator_.deallocate(block,nblocks);
      }
 
    }
 
 
    void resize (size_type _nblocks)
    {
      // deconstruct objects and deallocate memory if necessary
      if (this->n>0) {
        size_type i=this->n;
        while (i)
          this->p[--i].~B();
        allocator_.deallocate(this->p,this->n);
      }
      if (nblocks>0) {
        size_type i=nblocks;
        while (i)
          block[--i].~window_type();
        windowAllocator_.deallocate(block,nblocks);
      }
      this->n = 0;
      this->p = 0;
 
      // we can allocate the windows now
      nblocks = _nblocks;
      if (nblocks>0)
      {
        block = windowAllocator_.allocate(nblocks);
        new (block) window_type[nblocks];
      }
      else
      {
        nblocks = 0;
        block = 0;;
      }
 
      // and the vector not fully usable
      initialized = false;
    }
 
    void resize (size_type _nblocks, size_type m)
    {
      // deconstruct objects and deallocate memory if necessary
      if (this->n>0) {
        size_type i=this->n;
        while (i)
          this->p[--i].~B();
        allocator_.deallocate(this->p,this->n);
      }
      if (nblocks>0) {
        size_type i=nblocks;
        while (i)
          block[--i].~window_type();
        windowAllocator_.deallocate(block,nblocks);
      }
 
      // and we can allocate the big array in the base class
      this->n = _nblocks*m;
      if (this->n>0)
      {
        this->p = allocator_.allocate(this->n);
        new (this->p)B[this->n];
      }
      else
      {
        this->n = 0;
        this->p = 0;
      }
 
      // we can allocate the windows now
      nblocks = _nblocks;
      if (nblocks>0)
      {
        // allocate and construct objects
        block = windowAllocator_.allocate(nblocks);
        new (block) window_type[nblocks];
 
        // set the windows into the big array
        for (size_type i=0; i<nblocks; ++i)
          block[i].set(m,this->p+(i*m));
      }
      else
      {
        nblocks = 0;
        block = 0;;
      }
 
      // and the vector is usable
      initialized = true;
    }
 
    VariableBlockVector& operator= (const VariableBlockVector& a)
    {
      if (&a!=this)     // check if this and a are different objects
      {
        // reallocate arrays if necessary
        // Note: still the block sizes may vary !
        if (this->n!=a.n || nblocks!=a.nblocks)
        {
          // deconstruct objects and deallocate memory if necessary
          if (this->n>0) {
            size_type i=this->n;
            while (i)
              this->p[--i].~B();
            allocator_.deallocate(this->p,this->n);
          }
          if (nblocks>0) {
            size_type i=nblocks;
            while (i)
              block[--i].~window_type();
            windowAllocator_.deallocate(block,nblocks);
          }
 
          // allocate the big array in the base class
          this->n = a.n;
          if (this->n>0)
          {
            // allocate and construct objects
            this->p = allocator_.allocate(this->n);
            new (this->p)B[this->n];
          }
          else
          {
            this->n = 0;
            this->p = 0;
          }
 
          // we can allocate the windows now
          nblocks = a.nblocks;
          if (nblocks>0)
          {
            // alloc
            block = windowAllocator_.allocate(nblocks);
            new (block) window_type[nblocks];
          }
          else
          {
            nblocks = 0;
            block = 0;;
          }
        }
 
        // copy block structure, might be different although
        // sizes are the same !
        if (nblocks>0)
        {
          block[0].set(a.block[0].getsize(),this->p);                 // first block
          for (size_type i=1; i<nblocks; ++i)                               // and the rest
            block[i].set(a.block[i].getsize(),block[i-1].getptr()+block[i-1].getsize());
        }
 
        // and copy the data
        for (size_type i=0; i<this->n; i++) this->p[i]=a.p[i];
      }
 
      // and we have a usable vector
      initialized = true;
 
      return *this;     // Gebe Referenz zurueck damit a=b=c; klappt
    }
 
 
    //===== assignment from scalar
 
    VariableBlockVector& operator= (const field_type& k)
    {
      (static_cast<block_vector_unmanaged<B,A>&>(*this)) = k;
      return *this;
    }
 
 
    //===== the creation interface
 
    class CreateIterator
    {
    public:
      CreateIterator (VariableBlockVector& _v, int _i) : v(_v)
      {
        i = _i;
        k = 0;
        n = 0;
      }
 
      CreateIterator& operator++()
      {
        // we are at block i and the blocks size is known
 
        // set the blocks size to current k
        v.block[i].setsize(k);
 
        // accumulate total size
        n += k;
 
        // go to next block
        ++i;
 
        // reset block size
        k = 0;
 
        // if we are past the last block, finish off
        if (i==v.nblocks)
        {
          // now we can allocate the big array in the base class of v
          v.n = n;
          if (n>0)
          {
            // allocate and construct objects
            v.p = v.allocator_.allocate(n);
            new (v.p)B[n];
          }
          else
          {
            v.n = 0;
            v.p = 0;
          }
 
          // and we set the window pointer
          if (v.nblocks>0)
          {
            v.block[0].setptr(v.p);                       // pointer tofirst block
            for (size_type j=1; j<v.nblocks; ++j)               // and the rest
              v.block[j].setptr(v.block[j-1].getptr()+v.block[j-1].getsize());
          }
 
          // and the vector is ready
          v.initialized = true;
 
          //std::cout << "made vbvector with " << v.n << " components" << std::endl;
        }
 
        return *this;
      }
 
      bool operator!= (const CreateIterator& it) const
      {
        return (i!=it.i) || (&v!=&it.v);
      }
 
      bool operator== (const CreateIterator& it) const
      {
        return (i==it.i) && (&v==&it.v);
      }
 
      size_type index () const
      {
        return i;
      }
 
      void setblocksize (size_type _k)
      {
        k = _k;
      }
 
    private:
      VariableBlockVector& v;     // my vector
      size_type i;                      // current block to be defined
      size_type k;                      // size of current block to be defined
      size_type n;                      // total number of elements to be allocated
    };
 
    // CreateIterator wants to set all the arrays ...
    friend class CreateIterator;
 
    CreateIterator createbegin ()
    {
#ifdef DUNE_ISTL_WITH_CHECKING
      if (initialized) DUNE_THROW(ISTLError,"no CreateIterator in initialized state");
#endif
      return CreateIterator(*this,0);
    }
 
    CreateIterator createend ()
    {
      return CreateIterator(*this,nblocks);
    }
 
 
    //===== access to components
    // has to be overwritten from base class because it must
    // return access to the windows
 
    window_type& operator[] (size_type i)
    {
#ifdef DUNE_ISTL_WITH_CHECKING
      if (i>=nblocks) DUNE_THROW(ISTLError,"index out of range");
#endif
      return block[i];
    }
 
    const window_type& operator[] (size_type i) const
    {
#ifdef DUNE_ISTL_WITH_CHECKING
      if (i<0 || i>=nblocks) DUNE_THROW(ISTLError,"index out of range");
#endif
      return block[i];
    }
 
    // forward declaration
    class ConstIterator;
 
    class Iterator
    {
    public:
      Iterator ()
      {
        p = 0;
        i = 0;
      }
 
      Iterator (window_type* _p, size_type _i) : p(_p), i(_i)
      {       }
 
      Iterator& operator++()
      {
        ++i;
        return *this;
      }
 
      Iterator& operator--()
      {
        --i;
        return *this;
      }
 
      bool operator== (const Iterator& it) const
      {
        return (p+i)==(it.p+it.i);
      }
 
      bool operator!= (const Iterator& it) const
      {
        return (p+i)!=(it.p+it.i);
      }
 
      bool operator== (const ConstIterator& it) const
      {
        return (p+i)==(it.p+it.i);
      }
 
      bool operator!= (const ConstIterator& it) const
      {
        return (p+i)!=(it.p+it.i);
      }
 
      window_type& operator* () const
      {
        return p[i];
      }
 
      window_type* operator-> () const
      {
        return p+i;
      }
 
      // return index corresponding to pointer
      size_type index () const
      {
        return i;
      }
 
      friend class ConstIterator;
 
    private:
      window_type* p;
      size_type i;
    };
 
    Iterator begin ()
    {
      return Iterator(block,0);
    }
 
    Iterator end ()
    {
      return Iterator(block,nblocks);
    }
 
    Iterator beforeEnd ()
    {
      return Iterator(block,nblocks-1);
    }
 
    Iterator beforeBegin () const
    {
      return Iterator(block,-1);
    }
 
    Iterator find (size_type i)
    {
      if (i>=0 && i<nblocks)
        return Iterator(block,i);
      else
        return Iterator(block,nblocks);
    }
 
    ConstIterator find (size_type i) const
    {
      if (i>=0 && i<nblocks)
        return ConstIterator(block,i);
      else
        return ConstIterator(block,nblocks);
    }
 
    class ConstIterator
    {
    public:
      ConstIterator ()
      {
        p = 0;
        i = 0;
      }
 
      ConstIterator (const window_type* _p, size_type _i) : p(_p), i(_i)
      {       }
 
      ConstIterator (const Iterator& it) : p(it.p), i(it.i)
      {       }
 
      ConstIterator& operator++()
      {
        ++i;
        return *this;
      }
 
      ConstIterator& operator--()
      {
        --i;
        return *this;
      }
 
      bool operator== (const ConstIterator& it) const
      {
        return (p+i)==(it.p+it.i);
      }
 
      bool operator!= (const ConstIterator& it) const
      {
        return (p+i)!=(it.p+it.i);
      }
 
      bool operator== (const Iterator& it) const
      {
        return (p+i)==(it.p+it.i);
      }
 
      bool operator!= (const Iterator& it) const
      {
        return (p+i)!=(it.p+it.i);
      }
 
      const window_type& operator* () const
      {
        return p[i];
      }
 
      const window_type* operator-> () const
      {
        return p+i;
      }
 
      // return index corresponding to pointer
      size_type index () const
      {
        return i;
      }
 
      friend class Iterator;
 
    private:
      const window_type* p;
      size_type i;
    };
 
    ConstIterator begin () const
    {
      return ConstIterator(block,0);
    }
 
    ConstIterator end () const
    {
      return ConstIterator(block,nblocks);
    }
 
    ConstIterator beforeEnd() const
    {
      return ConstIterator(block,nblocks-1);
    }
 
    ConstIterator rend () const
    {
      return ConstIterator(block,-1);
    }
 
 
    //===== sizes
 
    size_type N () const
    {
      return nblocks;
    }
 
 
  private:
    size_type nblocks;            // number of blocks in vector
    window_type* block;     // array of blocks pointing to the array in the base class
    bool initialized;       // true if vector has been initialized
 
    A allocator_;
 
    typename A::template rebind<window_type>::other windowAllocator_;
  };
 
 
 
} // end namespace
 
#endif