DistributedVectorInline.cxx

// Copyright (C) 2014 INRIA
// Author(s): 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_DISTRIBUTED_VECTOR_INLINE_CXX
 
#include "DistributedVector.hxx"
 
namespace Seldon
{
 
  template<class T, class Allocator>
  inline DistributedVector<T, Allocator>::DistributedVector()
  { OverlapRowNumbers = NULL; comm_ = MPI_COMM_SELF; }
 
  
 
  template<class T, class Allocator>
  inline DistributedVector<T, Allocator>
  ::DistributedVector(const IVect& rows, const MPI_Comm& comm)
    : OverlapRowNumbers(const_cast<IVect*>(&rows)), comm_(comm)
  {
  }
  
  
  template<class T, class Allocator>
  inline DistributedVector<T, Allocator>::
  DistributedVector(const DistributedVector<T, Allocator>& V)
    : Vector<T, VectFull, Allocator>(V),
      OverlapRowNumbers(V.OverlapRowNumbers), comm_(V.comm_)
  {
  }
 
  
  template<class T, class Allocator>
  inline void DistributedVector<T, Allocator>
  ::SetOverlapRow(const IVect& rows, const MPI_Comm& comm)
  {
    OverlapRowNumbers = const_cast<IVect*>(&rows);
    comm_ = comm;
  }
 
  
  template<class T, class Allocator>
  inline int DistributedVector<T, Allocator>::GetNbOverlap() const
  {
    if (OverlapRowNumbers == NULL)
      return 0;
    
    return OverlapRowNumbers->GetM();
  }
  
  
  template<class T, class Allocator>
  inline int DistributedVector<T, Allocator>::GetOverlapRow(int i) const
  {
#ifdef SELDON_DEBUG_LEVEL_3
    CheckPointer((void*)OverlapRowNumbers, "DistributedVector::GetOverlapRow");
#endif
 
    return (*OverlapRowNumbers)(i);
  }
  
  
  template<class T, class Allocator>
  inline const MPI_Comm& DistributedVector<T, Allocator>
  ::GetCommunicator() const
  {
    return comm_;
  }
 
 
  template<class T, class Allocator>
  void DistributedVector<T, Allocator>::SetCommunicator(const MPI_Comm& comm)
  {
    comm_ = comm;
  }
 
 
  template<class T>
  inline T DotProd(const DistributedVector<T>& X,
                   const DistributedVector<T>& Y)
  {
    return DotProdVector(X, Y);
  }
 
  template<class T>
  inline complex<T> DotProd(const DistributedVector<complex<T> >& X,
                            const DistributedVector<T>& Y)
  {
    abort();
    return complex<T>(0, 0);
  }
 
  template<class T>
  inline complex<T> DotProd(const DistributedVector<T>& X,
                            const DistributedVector<complex<T> >& Y)
  {
    abort();
    return complex<T>(0, 0);
  }
 
  template<class T>
  inline T DotProdConj(const DistributedVector<T>& X,
                       const DistributedVector<T>& Y)
  {
    return DotProdVector(X, Y);
  }
 
  template<class T>
  inline complex<T> DotProdConj(const DistributedVector<complex<T> >& X,
                                const DistributedVector<complex<T> >& Y)
  {
    return DotProdConjVector(X, Y);
  }
 
  template<class T>
  inline complex<T> DotProdConj(const DistributedVector<complex<T> >& X,
                                const DistributedVector<T>& Y)
  {
    abort();
    return complex<T>(0, 0);
  }
 
  template<class T>
  inline complex<T> DotProdConj(const DistributedVector<T>& X,
                                const DistributedVector<complex<T> >& Y)
  {
    abort();
    return complex<T>(0, 0);
  }
  
}
 
#define SELDON_FILE_DISTRIBUTED_VECTOR_INLINE_CXX
#endif