Matrix_ComplexSparseInline.cxx

// Copyright (C) 2001-2011 Vivien Mallet
// Copyright (C) 2003-2011 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_MATRIX_COMPLEXSPARSE_INLINE_CXX
 
#include "Matrix_ComplexSparse.hxx"
 
namespace Seldon
{
  
  /**************
   * DESTRUCTOR *
   **************/
 
 
  template <class T, class Prop, class Storage, class Allocator>
  inline Matrix_ComplexSparse<T, Prop, Storage, Allocator>
  ::~Matrix_ComplexSparse()
  {
    this->Clear();
  }
 
 
  /*******************
   * BASIC FUNCTIONS *
   *******************/
 
 
 
  template <class T, class Prop, class Storage, class Allocator>
  inline long Matrix_ComplexSparse<T, Prop, Storage, Allocator>::GetNonZeros() const
  {
    return real_nz_ + imag_nz_;
  }
 
 
 
  template <class T, class Prop, class Storage, class Allocator>
  inline long Matrix_ComplexSparse<T, Prop, Storage, Allocator>::GetDataSize() const
  {
    return real_nz_ + imag_nz_;
  }
 
 
 
  template <class T, class Prop, class Storage, class Allocator>
  inline long* Matrix_ComplexSparse<T, Prop, Storage, Allocator>::GetRealPtr() const
  {
    return real_ptr_;
  }
 
 
 
  template <class T, class Prop, class Storage, class Allocator>
  inline long* Matrix_ComplexSparse<T, Prop, Storage, Allocator>::GetImagPtr() const
  {
    return imag_ptr_;
  }
 
 
 
  template <class T, class Prop, class Storage, class Allocator>
  inline int* Matrix_ComplexSparse<T, Prop, Storage, Allocator>::GetRealInd() const
  {
    return real_ind_;
  }
 
 
 
  template <class T, class Prop, class Storage, class Allocator>
  inline int* Matrix_ComplexSparse<T, Prop, Storage, Allocator>::GetImagInd() const
  {
    return imag_ind_;
  }
 
 
 
  template <class T, class Prop, class Storage, class Allocator>
  inline int Matrix_ComplexSparse<T, Prop, Storage, Allocator>
  ::GetRealPtrSize() const
  {
    return (Storage::GetFirst(this->m_, this->n_) + 1);
  }
 
 
 
  template <class T, class Prop, class Storage, class Allocator>
  inline int Matrix_ComplexSparse<T, Prop, Storage, Allocator>
  ::GetImagPtrSize() const
  {
    return (Storage::GetFirst(this->m_, this->n_) + 1);
  }
 
 
 
  template <class T, class Prop, class Storage, class Allocator>
  inline long Matrix_ComplexSparse<T, Prop, Storage, Allocator>
  ::GetRealIndSize() const
  {
    return real_nz_;
  }
 
 
 
  template <class T, class Prop, class Storage, class Allocator>
  inline long Matrix_ComplexSparse<T, Prop, Storage, Allocator>
  ::GetImagIndSize() const
  {
    return imag_nz_;
  }
 
  
 
  template <class T, class Prop, class Storage, class Allocator>
  inline long Matrix_ComplexSparse<T, Prop, Storage, Allocator>
  ::GetRealDataSize() const
  {
    return real_nz_;
  }
 
 
 
  template <class T, class Prop, class Storage, class Allocator>
  inline long Matrix_ComplexSparse<T, Prop, Storage, Allocator>
  ::GetImagDataSize() const
  {
    return imag_nz_;
  }
 
  
 
  template <class T, class Prop, class Storage, class Allocator>
  inline typename Allocator::value_type*
  Matrix_ComplexSparse<T, Prop, Storage, Allocator>::GetRealData() const
  {
    return real_data_;
  }
 
 
 
  template <class T, class Prop, class Storage, class Allocator>
  inline typename Allocator::value_type*
  Matrix_ComplexSparse<T, Prop, Storage, Allocator>::GetImagData() const
  {
    return imag_data_;
  }
 
 
  /**********************************
   * ELEMENT ACCESS AND AFFECTATION *
   **********************************/
 
 
 
  template <class T, class Prop, class Storage, class Allocator>
  inline const typename Matrix_ComplexSparse<T, Prop, Storage, Allocator>
  ::value_type&
  Matrix_ComplexSparse<T, Prop, Storage, Allocator>::GetReal(int i, int j) const
  {
    return ValReal(i, j);
  }
  
  
 
  template <class T, class Prop, class Storage, class Allocator>
  inline const typename Matrix_ComplexSparse<T, Prop, Storage, Allocator>
  ::value_type&
  Matrix_ComplexSparse<T, Prop, Storage, Allocator>::GetImag(int i, int j) const
  {
    return ValImag(i, j);
  }
  
  
 
  template <class T, class Prop, class Storage, class Allocator>
  inline void Matrix_ComplexSparse<T, Prop, Storage, Allocator>
  ::AddInteraction(int i, int j, const entry_type& val)
  {
    if (real(val) != value_type(0))
      GetReal(i, j) += real(val);
 
    if (imag(val) != value_type(0))
      GetImag(i, j) += imag(val);
  }
 
 
  template <class T, class Prop, class Storage, class Allocator>
  inline void Matrix_ComplexSparse<T, Prop, Storage, Allocator>
  ::AddInteractionRow(int i, int nb, const Vector<int>& col,
                      const Vector<entry_type>& val, bool sorted)
  {
    throw Undefined("AddInteractionRow", "Not implemented");
  }
 
 
 
  template <class T, class Prop, class Storage, class Allocator>
  inline void Matrix_ComplexSparse<T, Prop, Storage, Allocator>
  ::Set(int i, int j, const entry_type& val)
  {
    GetReal(i, j) = real(val);
    GetImag(i, j) = imag(val);
  }
 
  
 
  template <class T, class Prop, class Storage, class Allocator>
  inline Matrix_ComplexSparse<T, Prop, Storage, Allocator>&
  Matrix_ComplexSparse<T, Prop, Storage, Allocator>
  ::operator= (const Matrix_ComplexSparse<T, Prop, Storage, Allocator>& A)
  {
    this->Copy(A);
 
    return *this;
  }
 
 
#ifdef SELDON_WITH_VIRTUAL
  template <class T, class Prop, class Storage, class Allocator>
  inline void Matrix_ComplexSparse<T, Prop, Storage, Allocator>
  ::ApplySor(const SeldonTranspose& trans, Vector<Treal>& x, const Vector<Treal>& r,
             const typename ClassComplexType<T>::Treal& omega,
             int nb_iter, int stage_ssor) const
  {
    SOR(trans, static_cast<const Matrix<T, Prop, Storage, Allocator>& >(*this),
        x, r, omega, nb_iter, stage_ssor);
  }
  
  template <class T, class Prop, class Storage, class Allocator>
  inline void Matrix_ComplexSparse<T, Prop, Storage, Allocator>
  ::ApplySor(const SeldonTranspose& trans, Vector<Tcplx>& x, const Vector<Tcplx>& r,
             const typename ClassComplexType<T>::Treal& omega,
             int nb_iter, int stage_ssor) const
  {
    SOR(trans,
        static_cast<const Matrix<T, Prop, Storage, Allocator>& >(*this),
        x, r, omega, nb_iter, stage_ssor);
  }
  
  template <class T, class Prop, class Storage, class Allocator>
  inline void Matrix_ComplexSparse<T, Prop, Storage, Allocator>
  ::MltAddVector(const Treal& alpha, const Vector<Treal>& x,
                 const Treal& beta, Vector<Treal>& y) const
  {
    cout << "Not defined for real numbers" << endl;
    abort();
  }
  
  template <class T, class Prop, class Storage, class Allocator>
  inline void Matrix_ComplexSparse<T, Prop, Storage, Allocator>
  ::MltAddVector(const Tcplx& alpha, const Vector<Tcplx>& x,
                 const Tcplx& beta, Vector<Tcplx>& y) const
  {
    MltAdd(alpha,
           static_cast<const Matrix<T, Prop, Storage, Allocator>& >(*this),
           x, beta, y);
  }
 
  template <class T, class Prop, class Storage, class Allocator>
  inline void Matrix_ComplexSparse<T, Prop, Storage, Allocator>
  ::MltAddVector(const Treal& alpha, const SeldonTranspose& trans,
                 const Vector<Treal>& x,
                 const Treal& beta, Vector<Treal>& y) const
  {
    cout << "Not defined for real numbers" << endl;
    abort();
  }
  
  template <class T, class Prop, class Storage, class Allocator>
  inline void Matrix_ComplexSparse<T, Prop, Storage, Allocator>
  ::MltAddVector(const Tcplx& alpha, const SeldonTranspose& trans,
                 const Vector<Tcplx>& x,
                 const Tcplx& beta, Vector<Tcplx>& y) const
  {
    MltAdd(alpha, trans,
           static_cast<const Matrix<T, Prop, Storage, Allocator>& >(*this),
           x, beta, y);
  }
  
  template <class T, class Prop, class Storage, class Allocator>
  inline void Matrix_ComplexSparse<T, Prop, Storage, Allocator>
  ::MltVector(const Vector<Treal>& x, Vector<Treal>& y) const
  {
    cout << "Not defined for real numbers" << endl;
    abort();
  }
 
  template <class T, class Prop, class Storage, class Allocator>
  inline void Matrix_ComplexSparse<T, Prop, Storage, Allocator>
  ::MltVector(const Vector<Tcplx>& x, Vector<Tcplx>& y) const
  {
    Mlt(static_cast<const Matrix<T, Prop, Storage, Allocator>& >(*this), x, y);
  }
 
  template <class T, class Prop, class Storage, class Allocator>
  inline void Matrix_ComplexSparse<T, Prop, Storage, Allocator>  
  ::MltVector(const SeldonTranspose& trans,
              const Vector<Treal>& x, Vector<Treal>& y) const
  {
    cout << "Not defined for real numbers" << endl;
    abort();
  }
 
  template <class T, class Prop, class Storage, class Allocator>
  inline void Matrix_ComplexSparse<T, Prop, Storage, Allocator>  
  ::MltVector(const SeldonTranspose& trans,
              const Vector<Tcplx>& x, Vector<Tcplx>& y) const
  {
    Mlt(trans,
        static_cast<const Matrix<T, Prop, Storage, Allocator>& >(*this), x, y);
  }
 
  template <class T, class Prop, class Storage, class Allocator>
  inline bool Matrix_ComplexSparse<T, Prop, Storage, Allocator>  
  ::IsSymmetric() const
  {
    return false;
  }
#endif
 
  
  // MATRIX<COLCOMPLEXSPARSE> //
 
 
  /****************
   * CONSTRUCTORS *
   ****************/
 
 
  template <class T, class Prop, class Allocator>
  inline Matrix<T, Prop, ColComplexSparse, Allocator>::Matrix() :
    Matrix_ComplexSparse<T, Prop, ColComplexSparse, Allocator>()
  {
  }
 
 
 
  template <class T, class Prop, class Allocator>
  inline Matrix<T, Prop, ColComplexSparse, Allocator>::Matrix(int i, int j):
    Matrix_ComplexSparse<T, Prop, ColComplexSparse, Allocator>(i, j, 0, 0)
  {
  }
 
 
 
  template <class T, class Prop, class Allocator>
  inline Matrix<T, Prop, ColComplexSparse, Allocator>::Matrix(int i, int j,
                                                              long real_nz,
                                                              long imag_nz):
    Matrix_ComplexSparse<T, Prop, ColComplexSparse, Allocator>(i, j,
                                                               real_nz,
                                                               imag_nz)
  {
  }
 
 
 
  template <class T, class Prop, class Allocator>
  template <class Storage0, class Allocator0,
            class Storage1, class Allocator1,
            class Storage2, class Allocator2>
  inline Matrix<T, Prop, ColComplexSparse, Allocator>::
  Matrix(int i, int j,
         Vector<value_type, Storage0, Allocator0>& real_values,
         Vector<long, Storage1, Allocator1>& real_ptr,
         Vector<int, Storage2, Allocator2>& real_ind,
         Vector<value_type, Storage0, Allocator0>& imag_values,
         Vector<long, Storage1, Allocator1>& imag_ptr,
         Vector<int, Storage2, Allocator2>& imag_ind):
    Matrix_ComplexSparse<T, Prop, ColComplexSparse, Allocator>(i, j,
                                                               real_values,
                                                               real_ptr,
                                                               real_ind,
                                                               imag_values,
                                                               imag_ptr,
                                                               imag_ind)
  {
  }
 
 
 
  // MATRIX<ROWCOMPLEXSPARSE> //
 
 
  /****************
   * CONSTRUCTORS *
   ****************/
 
 
  template <class T, class Prop, class Allocator>
  inline Matrix<T, Prop, RowComplexSparse, Allocator>::Matrix() :
    Matrix_ComplexSparse<T, Prop, RowComplexSparse, Allocator>()
  {
  }
 
 
 
  template <class T, class Prop, class Allocator> inline
  Matrix<T, Prop, RowComplexSparse, Allocator>::Matrix(int i, int j):
    Matrix_ComplexSparse<T, Prop, RowComplexSparse, Allocator>(i, j, 0, 0)
  {
  }
 
 
  template <class T, class Prop, class Allocator> inline
  Matrix<T, Prop, RowComplexSparse, Allocator>::Matrix(int i, int j,
                                                       long real_nz,
                                                       long imag_nz):
    Matrix_ComplexSparse<T, Prop, RowComplexSparse, Allocator>(i, j,
                                                               real_nz,
                                                               imag_nz)
  {
  }
 
 
 
  template <class T, class Prop, class Allocator>
  template <class Storage0, class Allocator0,
            class Storage1, class Allocator1,
            class Storage2, class Allocator2>
  inline Matrix<T, Prop, RowComplexSparse, Allocator>::
  Matrix(int i, int j,
         Vector<value_type, Storage0, Allocator0>& real_values,
         Vector<long, Storage1, Allocator1>& real_ptr,
         Vector<int, Storage2, Allocator2>& real_ind,
         Vector<value_type, Storage0, Allocator0>& imag_values,
         Vector<long, Storage1, Allocator1>& imag_ptr,
         Vector<int, Storage2, Allocator2>& imag_ind):
    Matrix_ComplexSparse<T, Prop, RowComplexSparse, Allocator>(i, j,
                                                               real_values,
                                                               real_ptr,
                                                               real_ind,
                                                               imag_values,
                                                               imag_ptr,
                                                               imag_ind)
  {
  }
  
  
} // namespace Seldon.
 
#define SELDON_FILE_MATRIX_COMPLEXSPARSE_INLINE_CXX
#endif