Matrix_Base.cxx

// Copyright (C) 2001-2009 Vivien Mallet
//
// 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_BASE_CXX
 
#include "Matrix_Base.hxx"
 
namespace Seldon
{
 
#ifdef SELDON_WITH_VIRTUAL
  template <class T>
  void VirtualMatrix<T>::Reallocate(int m, int n)
  {
    // this method should be overloaded
    // if not overloaded, an exception is raised:
    throw Undefined("Reallocate", "Not implemented"); 
  }
 
 
  template <class T>
  void VirtualMatrix<T>::Zero()
  {
    // this method should be overloaded
    // if not overloaded, an exception is raised:
    throw Undefined("Zero", "Not implemented"); 
  }
 
 
  template <class T>
  void VirtualMatrix<T>::SetEntry(int i, int j, const T& x)
  {
    // this method should be overloaded in sparse matrices
    // if not overloaded, an exception is raised:
    throw Undefined("SetEntry", "Not implemented");
  }
  
  
  template <class T>
  void VirtualMatrix<T>::AddInteraction(int i, int j, const T& x)
  {
    // this method should be overloaded in sparse matrices
    // if not overloaded, an exception is raised:
    throw Undefined("AddInteraction", "Not implemented");
  }
 
  
  template <class T>
  void VirtualMatrix<T>::AddInteractionRow(int, int, const Vector<int>&,
                                           const Vector<T>& val, bool sorted)
  {
    // this method should be overloaded in sparse matrices
    // if not overloaded, an exception is raised:
    throw Undefined("AddInteractionRow", "Not implemented");
  }
 
 
  template <class T>
  void VirtualMatrix<T>::AddInteractionColumn(int, int, const Vector<int>&,
                                              const Vector<T>& val, bool sorted)
  {
    // this method should be overloaded in sparse matrices
    // if not overloaded, an exception is raised:
    throw Undefined("AddInteractionColumn", "Not implemented");
  }
 
 
 
  template <class T>
  void VirtualMatrix<T>::AddDistantInteraction(int i, int jglob, int proc,
                                               const T& val)
  {
    // this method should be overloaded in distributed sparse matrices
    // if not overloaded, an exception is raised:
    throw Undefined("AddDistantInteraction", "Not implemented");
  }
 
 
 
  template <class T>
  void VirtualMatrix<T>::AddRowDistantInteraction(int iglob, int j, int proc,
                                                  const T& val)
  {
    // this method should be overloaded in distributed sparse matrices
    // if not overloaded, an exception is raised:
    throw Undefined("AddRowDistantInteraction", "Not implemented");
  }
  
 
  template <class T>
  size_t VirtualMatrix<T>::GetMemorySize() const
  {
    // this method should be overloaded
    // if not overloaded, an exception is raised:
    throw Undefined("GetMemorySize", "Not implemented"); 
  }
  
  
  template <class T>
  void VirtualMatrix<T>::Clear()
  {
    // this method should be overloaded
    // if not overloaded, an exception is raised:
    throw Undefined("Clear", "Not implemented"); 
  }
 
  
  template <class T>
  inline void VirtualMatrix<T>::ClearRow(int i)
  {
    // this method should be overloaded in sparse matrices
    // if not overloaded, an exception is raised:
    throw Undefined("ClearRow", "Not implemented");
  }
 
 
  template<class T> void VirtualMatrix<T>
  ::ApplySor(const SeldonTranspose&, Vector<Treal>& x, const Vector<Treal>& r,
             const typename ClassComplexType<T>::Treal& omega,
             int nb_iter, int stage_ssor) const
  {
    throw Undefined("ApplySOR", "Not implemented");
  }
  
 
  template<class T> void VirtualMatrix<T>
  ::ApplySor(const SeldonTranspose&, Vector<Tcplx>& x, const Vector<Tcplx>& r,
             const typename ClassComplexType<T>::Treal& omega,
             int nb_iter, int stage_ssor) const
  {
    throw Undefined("ApplySOR with transpose", "Not implemented");
  }
 
 
  template<class T> void VirtualMatrix<T>
  ::MltAddVector(const Treal& alpha, const Vector<Treal>& x,
                 const Treal& beta, Vector<Treal>& y) const
  {
    throw Undefined("MltAddVector", "Not implemented");
  }
 
 
  template<class T> void VirtualMatrix<T>
  ::MltAddVector(const Tcplx& alpha, const Vector<Tcplx>& x,
                 const Tcplx& beta, Vector<Tcplx>& y) const
  {
    throw Undefined("MltAddVector", "Not implemented");
  }
 
 
  template<class T> void VirtualMatrix<T>
  ::MltAddVector(const Treal& alpha, const SeldonTranspose&,
                 const Vector<Treal>& x,
                 const Treal& beta, Vector<Treal>& y) const
  {
    throw Undefined("MltAddVector", "Not implemented");
  }
 
 
  template<class T> void VirtualMatrix<T>
  ::MltAddVector(const Tcplx& alpha, const SeldonTranspose&,
                 const Vector<Tcplx>& x,
                 const Tcplx& beta, Vector<Tcplx>& y) const
  {
    throw Undefined("MltAddVector", "Not implemented");
  }
 
 
  template<class T> void VirtualMatrix<T>
  ::MltVector(const Vector<Treal>& x, Vector<Treal>& y) const
  {
    throw Undefined("MltVector", "Not implemented");
  }
 
 
  template<class T> void VirtualMatrix<T>
  ::MltVector(const Vector<Tcplx>& x, Vector<Tcplx>& y) const
  {
    throw Undefined("MltVector", "Not implemented");
  }
  
 
  template<class T> void VirtualMatrix<T>
  ::MltVector(const SeldonTranspose&,
              const Vector<Treal>& x, Vector<Treal>& y) const
  {
    throw Undefined("MltVector with transpose", "Not implemented");
  }
 
 
  template<class T> void VirtualMatrix<T>
  ::MltVector(const SeldonTranspose&,
              const Vector<Tcplx>& x, Vector<Tcplx>& y) const
  {
    throw Undefined("MltVector with transpose", "Not implemented");
  }
  
  
  template<class T> bool VirtualMatrix<T>::IsSymmetric() const
  {
    return false;
  }
  
  
  template<class T> bool VirtualMatrix<T>::IsComplex() const
  {
    return IsComplexNumber(T());
  }
#endif
 
 
  // operator<< overloaded for matrices.
  template <class T, class Prop, class Storage, class Allocator>
  ostream& operator << (ostream& out,
                        const Matrix<T, Prop, Storage, Allocator>& A)
  {
    
    for (int i = 0; i < A.GetM(); i++)
      {
        for (int j = 0; j < A.GetN(); j++)
          out << A(i, j) << '\t';
        out << endl;
      }
 
    return out;
 
  }
 
} // namespace Seldon.
 
#define SELDON_FILE_MATRIX_BASE_CXX
#endif