VectorInline.cxx

// Copyright (C) 2001-2011 Vivien Mallet
// Copyright (C) 2003-2015 Marc Duruflé
//
// This file is part of the linear-algebra library Seldon,
// http://seldon.sourceforge.net/.
//
// Seldon is free software; you can redistribute it and/or modify it under the
// terms of the GNU Lesser General Public License as published by the Free
// Software Foundation; either version 2.1 of the License, or (at your option)
// any later version.
//
// Seldon is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for
// more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with Seldon. If not, see http://www.gnu.org/licenses/.
 
 
#ifndef SELDON_FILE_VECTOR_INLINE_CXX
 
#include "Vector.hxx"
#include "VectorExpressionInline.cxx"
 
namespace Seldon
{
 
 
  // C_VECTOR_BASE //
 
 
  /****************
   * CONSTRUCTORS *
   ****************/
 
 
 
  template <class T, class Allocator>
  inline Vector_Base<T, Allocator>::Vector_Base()
  {
    m_ = 0;
    data_ = NULL;
  }
 
 
 
  template <class T, class Allocator>
  inline Vector_Base<T, Allocator>::Vector_Base(size_t i)
  {
    m_ = i;
    data_ = NULL;
  }
 
 
 
  template <class T, class Allocator>
  inline Vector_Base<T, Allocator>::
  Vector_Base(const Vector_Base<T, Allocator>& A)
  {
    m_ = A.GetM();
    data_ = NULL;
  }
 
 
  /**************
   * DESTRUCTOR *
   **************/
 
 
  template <class T, class Allocator>
  inline Vector_Base<T, Allocator>::~Vector_Base()
  {
    this->Clear();
  }
 
 
  template <class T, class Allocator>
  inline void Vector_Base<T, Allocator>::Clear()
  {
    
#ifdef SELDON_CHECK_MEMORY
    try
      {
#endif
 
        if (data_ != NULL)
          {
            Allocator::deallocate(data_, m_);
            m_ = 0;
            data_ = NULL;
          }
 
#ifdef SELDON_CHECK_MEMORY
      }
    catch (...)
      {
        m_ = 0;
        data_ = NULL;
      }
#endif
 
  }
 
  
  /*******************
   * BASIC FUNCTIONS *
   *******************/
 
 
 
  template <class T, class Allocator>
  inline long Vector_Base<T, Allocator>::GetM() const
  {
    return m_;
  }
 
 
 
  template <class T, class Allocator>
  inline size_t Vector_Base<T, Allocator>::GetLength() const
  {
    return m_;
  }
 
 
 
  template <class T, class Allocator>
  inline size_t Vector_Base<T, Allocator>::GetSize() const
  {
    return m_;
  }
 
 
 
  template <class T, class Allocator>
  inline size_t Vector_Base<T, Allocator>::GetMemorySize() const
  {
    return sizeof(*this) + sizeof(T)*size_t(GetSize());
  }
 
  
 
  template <class T, class Allocator>
  inline typename Vector_Base<T, Allocator>::pointer
  Vector_Base<T, Allocator>::GetData() const
  {
    return data_;
  }
 
 
 
  template <class T, class Allocator>
  inline typename Vector_Base<T, Allocator>::const_pointer
  Vector_Base<T, Allocator>::GetDataConst() const
  {
    return reinterpret_cast<typename Vector_Base<T,
      Allocator>::const_pointer>(data_);
  }
 
 
 
  template <class T, class Allocator>
  inline void* Vector_Base<T, Allocator>::GetDataVoid() const
  {
    return reinterpret_cast<void*>(data_);
  }
 
 
 
  template <class T, class Allocator>
  inline const void* Vector_Base<T, Allocator>::GetDataConstVoid() const
  {
    return reinterpret_cast<const void*>(data_);
  }
 
 
  // VECTOR<VECT_FULL> //
 
 
  /****************
   * CONSTRUCTORS *
   ****************/
 
 
 
  template <class T, class Allocator>
  inline Vector<T, VectFull, Allocator>::Vector():
    Vector_Base<T, Allocator>()
  {
  }
 
 
 
  template <class T, class Allocator>
  inline Vector<T, VectFull, Allocator>::Vector(size_t i):
    Vector_Base<T, Allocator>(i)
  {
 
#ifdef SELDON_CHECK_MEMORY
    try
      {
#endif
 
        this->data_ = Allocator::allocate(i, this);
 
#ifdef SELDON_CHECK_MEMORY
      }
    catch (...)
      {
        this->m_ = 0;
        this->data_ = NULL;
      }
    if (this->data_ == NULL)
      this->m_ = 0;
    if (this->data_ == NULL && i != 0)
      throw NoMemory("Vector<VectFull>::Vector(int)",
                     string("Unable to allocate memory for a vector of size ")
                     + to_str(i*sizeof(T)) + " bytes ("
                     + to_str(i) + " elements).");
#endif
 
  }
 
 
 
  template <class T, class Allocator>
  inline Vector<T, VectFull, Allocator>
  ::Vector(size_t i, typename Vector<T, VectFull, Allocator>::pointer data):
    Vector_Base<T, Allocator>()
  {
    SetData(i, data);
  }
 
 
 
  template <class T, class Allocator>
  inline Vector<T, VectFull, Allocator>::
  Vector(const Vector<T, VectFull, Allocator>& V):
    Vector_Base<T, Allocator>(V)
  {
 
#ifdef SELDON_CHECK_MEMORY
    try
      {
#endif
 
        this->data_ = Allocator::allocate(V.GetM(), this);
 
#ifdef SELDON_CHECK_MEMORY
      }
    catch (...)
      {
        this->m_ = 0;
        this->data_ = NULL;
      }
    if (this->data_ == NULL)
      this->m_ = 0;
    if (this->data_ == NULL && V.GetM() != 0)
      throw NoMemory("Vector<VectFull>::Vector(Vector<VectFull>&)",
                     string("Unable to allocate memory for a vector of size ")
                     + to_str(V.GetM()*sizeof(T)) + " bytes ("
                     + to_str(V.GetM()) + " elements).");
#endif
 
    Allocator::memorycpy(this->data_, V.GetData(), V.GetM());
 
  }
 
 
  /**************
   * DESTRUCTOR *
   **************/
 
 
  template <class T, class Allocator>
  inline Vector<T, VectFull, Allocator>::~Vector()
  {
  }
 
 
  /*********************
   * MEMORY MANAGEMENT *
   *********************/
 
 
 
  template <class T, class Allocator>
  inline void Vector<T, VectFull, Allocator>::Clear()
  {
    Vector_Base<T, Allocator>::Clear();
  }
 
 
 
  template <class T, class Allocator>
  inline void Vector<T, VectFull, Allocator>::Reallocate(size_t i)
  {
    ReallocateVector(i);
  }
 
 
 
  template <class T, class Allocator>
  inline void Vector<T, VectFull, Allocator>::ReallocateVector(size_t i)
  {
    // function implemented in the aim that explicit specialization
    // of Reallocate can call ReallocateVector
    if (i != this->m_)
      {
 
        this->m_ = i;
 
#ifdef SELDON_CHECK_MEMORY
        try
          {
#endif
 
            this->data_ =
              reinterpret_cast<pointer>(Allocator::
                                        reallocate(this->data_, i, this));
 
#ifdef SELDON_CHECK_MEMORY
          }
        catch (...)
          {
            this->m_ = 0;
            this->data_ = NULL;
            return;
          }
        if (this->data_ == NULL)
          {
            this->m_ = 0;
            return;
          }
#endif
 
      }
  }
 
 
  template <class T, class Allocator>
  inline void Vector<T, VectFull, Allocator>
  ::SetData(size_t i, typename Vector<T, VectFull, Allocator>::pointer data)
  {
    this->Clear();
 
    this->m_ = i;
 
    this->data_ = data;
  }
 
 
 
  template <class T, class Allocator>
  template <class Allocator0>
  inline void Vector<T, VectFull, Allocator>
  ::SetData(const Vector<T, VectFull, Allocator0>& V)
  {
    SetData(V.GetLength(), V.GetData());
  }
 
 
 
  template <class T, class Allocator>
  inline void Vector<T, VectFull, Allocator>::Nullify()
  {
    this->m_ = 0;
    this->data_ = NULL;
  }
 
 
  /**********************************
   * ELEMENT ACCESS AND AFFECTATION *
   **********************************/
 
 
 
  template <class T, class Allocator>
  inline typename Vector<T, VectFull, Allocator>::reference
  Vector<T, VectFull, Allocator>::operator() (long i)
  {
 
#ifdef SELDON_CHECK_BOUNDS
    CheckBounds(i, this->m_, "Vector<VectFull>");
#endif
 
    return this->data_[i];
  }
 
 
 
  template <class T, class Allocator>
  inline typename Vector<T, VectFull, Allocator>::reference
  Vector<T, VectFull, Allocator>::Get(long i)
  {
 
#ifdef SELDON_CHECK_BOUNDS
    CheckBounds(i, this->m_, "Vector<VectFull>");
#endif
 
    return this->data_[i];
  }
 
 
 
  template <class T, class Allocator>
  inline typename Vector<T, VectFull, Allocator>::const_reference
  Vector<T, VectFull, Allocator>::operator() (long i) const
  {
 
#ifdef SELDON_CHECK_BOUNDS
    CheckBounds(i, this->m_, "Vector<VectFull>");
#endif
 
    return this->data_[i];
  }
 
 
 
  template <class T, class Allocator>
  inline typename Vector<T, VectFull, Allocator>::const_reference
  Vector<T, VectFull, Allocator>::Get(long i) const
  {
 
#ifdef SELDON_CHECK_BOUNDS
    CheckBounds(i, this->m_, "Vector<VectFull>");
#endif
 
    return this->data_[i];
  }
 
 
 
  template <class T, class Allocator>
  inline Vector<T, VectFull, Allocator>& Vector<T, VectFull, Allocator>
  ::operator= (const Vector<T, VectFull, Allocator>& X)
  {
    this->Copy(X);
 
    return *this;
  }
 
 
 
  template <class T, class Allocator>
  inline void Vector<T, VectFull, Allocator>
  ::Copy(const Vector<T, VectFull, Allocator>& X)
  {
    this->Reallocate(X.GetLength());
 
    Allocator::memorycpy(this->data_, X.GetData(), this->m_);
  }
 
 
 
  template <class T, class Allocator>
  inline Vector<T, VectFull, Allocator>
  Vector<T, VectFull, Allocator>::Copy() const
  {
    return Vector<T, VectFull, Allocator>(*this);
  }
 
 
 
  template <class T, class Allocator> template<class T0>
  inline Vector<T, VectFull, Allocator>& Vector<T, VectFull, Allocator>
  ::operator*= (const T0& alpha)
  {
    for (size_t i = 0; i < this->m_; i++)
      this->data_[i] *= alpha;
 
    return *this;
  }
 
 
  template<class T, class Allocator> template<class E>
  inline Vector<T, VectFull, Allocator>& Vector<T, VectFull, Allocator>
  ::operator =(const VectorExpression<T, E>& X)
  {
    this->Reallocate(X.GetSize());
    for (size_t i = 0; i < this->m_; i++)
      this->data_[i] = X(i);
    
    return *this;
  }
 
 
  template<class T, class Allocator> template<class E>
  inline Vector<T, VectFull, Allocator>& Vector<T, VectFull, Allocator>
  ::operator +=(const VectorExpression<T, E>& X)
  {
    for (size_t i = 0; i < this->m_; i++)
      this->data_[i] += X(i);
    
    return *this;
  }
 
 
  template<class T, class Allocator> template<class E>
  inline Vector<T, VectFull, Allocator>& Vector<T, VectFull, Allocator>
  ::operator -=(const VectorExpression<T, E>& X)
  {
    for (size_t i = 0; i < this->m_; i++)
      this->data_[i] -= X(i);
    
    return *this;
  }
 
 
 
  template <class T, class Allocator>
  inline void Vector<T, VectFull, Allocator>::Append(const T& x)
  {
    size_t i = this->GetLength();
    this->Reallocate(i + 1);
    this->data_[i] = x;
  }
 
 
 
  template <class T, class Allocator> template<class T0>
  inline void Vector<T, VectFull, Allocator>::PushBack(const T0& x)
  {
    Resize(this->m_+1);
    this->data_[this->m_-1] = x;
  }
 
 
 
  template <class T, class Allocator> template<class Allocator0>
  inline void Vector<T, VectFull, Allocator>
  ::PushBack(const Vector<T, VectFull, Allocator0>& X)
  {
    size_t Nold = this->m_;
    Resize(this->m_ + X.GetSize());
    for (size_t i = 0; i < X.GetSize(); i++)
      this->data_[Nold+i] = X(i);
  }
 
 
  /*******************
   * BASIC FUNCTIONS *
   *******************/
 
 
 
  template <class T, class Allocator>
  inline size_t Vector<T, VectFull, Allocator>::GetDataSize()
  {
    return this->m_;
  }
 
 
  /************************
   * CONVENIENT FUNCTIONS *
   ************************/
 
 
 
  template <class T, class Allocator>
  inline void Vector<T, VectFull, Allocator>::Zero()
  {
    Allocator::memoryset(this->data_, char(0),
                         this->GetDataSize() * sizeof(value_type));
  }
 
 
  template <class T, class Allocator>
  inline void Vector<T, VectFull, Allocator>::Fill()
  {
    for (size_t i = 0; i < this->m_; i++)
      SetComplexReal(i, this->data_[i]);
  }
 
 
 
  template <class T, class Allocator>
  template <class T0>
  inline void Vector<T, VectFull, Allocator>::Fill(const T0& x)
  {
    T x_;
    SetComplexReal(x, x_);
    for (size_t i = 0; i < this->m_; i++)
      this->data_[i] = x_;
  }
 
 
 
  template <class T, class Allocator>
  inline Vector<T, VectFull, Allocator>&
  Vector<T, VectFull, Allocator>::operator= (const T& x)
  {
    this->Fill(x);
 
    return *this;
  }
 
 
 
  template <class T, class Allocator>
  inline void Vector<T, VectFull, Allocator>::FillRand()
  {
#ifndef SELDON_WITHOUT_REINIT_RANDOM
    srand(time(NULL));
#endif
    for (size_t i = 0; i < this->m_; i++)
      SetComplexReal(rand(), this->data_[i]);
  }
 
 
  template <class T, class Allocator>
  inline void Vector<T, VectFull, Allocator>::Print() const
  {
    for (size_t i = 0; i < this->GetLength(); i++)
      cout << (*this)(i) << "\t";
    cout << endl;
  }
  
  
} // namespace Seldon.
 
#define SELDON_FILE_VECTOR_INLINE_CXX
#endif