HeterogeneousMatrixCollectionInline.cxx

// Copyright (C) 2010 INRIA
// Author(s): Marc Fragu
//
// 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_HETEROGENEOUS_MATRIX_COLLECTION_INLINE_CXX
 
#include "HeterogeneousMatrixCollection.hxx"
 
namespace Seldon
{
 
 
  // HETEROGENEOUSMATRIXCOLLECTION //
 
 
 
  template <class Prop0, class Storage0,
            class Prop1, class Storage1,
            template <class U> class Allocator> inline
  HeterogeneousMatrixCollection<Prop0, Storage0, Prop1, Storage1, Allocator>
  ::HeterogeneousMatrixCollection(const HeterogeneousMatrixCollection<Prop0,
                                  Storage0, Prop1, Storage1, Allocator>& A):
    Matrix_Base<double, Allocator<double> >()
  {
    this->Copy(A);
  }
 
 
  /**************
   * DESTRUCTOR *
   **************/
 
 
  template <class Prop0, class Storage0,
            class Prop1, class Storage1,
            template <class U> class Allocator> inline
  HeterogeneousMatrixCollection<Prop0, Storage0, Prop1, Storage1, Allocator>
  ::~HeterogeneousMatrixCollection()
  {
    this->Clear();
  }
 
 
  /*******************
   * BASIC FUNCTIONS *
   *******************/
 
 
 
  template <class Prop0, class Storage0,
            class Prop1, class Storage1,
            template <class U> class Allocator> inline int
  HeterogeneousMatrixCollection<Prop0, Storage0, Prop1, Storage1, Allocator>
  ::GetM() const
  {
    return this->m_;
  }
 
 
 
  template <class Prop0, class Storage0,
            class Prop1, class Storage1,
            template <class U> class Allocator> inline int
  HeterogeneousMatrixCollection<Prop0, Storage0, Prop1, Storage1, Allocator>
  ::GetMmatrix() const
  {
    return Mmatrix_;
  }
 
 
 
  template <class Prop0, class Storage0,
            class Prop1, class Storage1,
            template <class U> class Allocator> inline int
  HeterogeneousMatrixCollection<Prop0, Storage0, Prop1, Storage1, Allocator>
  ::GetM(int i) const
  {
#ifdef SELDON_CHECK_BOUNDS
    if (i < 0 || i >= Mmatrix_)
      throw WrongRow("HeterogeneousMatrixCollection::GetM()",
                     string("Index should be in [0, ")
                     + to_str(Mmatrix_ - 1) + "], but is equal to "
                     + to_str(i) + ".");
#endif
 
    return Mlocal_(i);
  }
 
 
 
  template <class Prop0, class Storage0,
            class Prop1, class Storage1,
            template <class U> class Allocator> inline int
  HeterogeneousMatrixCollection<Prop0, Storage0, Prop1, Storage1, Allocator>
  ::GetN() const
  {
    return this->n_;
  }
 
 
 
  template <class Prop0, class Storage0,
            class Prop1, class Storage1,
            template <class U> class Allocator> inline int
  HeterogeneousMatrixCollection<Prop0, Storage0, Prop1, Storage1, Allocator>
  ::GetNmatrix() const
  {
    return Nmatrix_;
  }
 
 
 
  template <class Prop0, class Storage0,
            class Prop1, class Storage1,
            template <class U> class Allocator> inline int
  HeterogeneousMatrixCollection<Prop0, Storage0, Prop1, Storage1, Allocator>
  ::GetN(int j) const
  {
#ifdef SELDON_CHECK_BOUNDS
    if (j < 0 || j >= Nmatrix_)
      throw WrongCol("HeterogeneousMatrixCollection::GetN()",
                     string("Index should be in [0, ")
                     + to_str(Nmatrix_ - 1) + "], but is equal to "
                     + to_str(j) + ".");
#endif
 
    return Nlocal_(j);
  }
 
 
 
  template <class Prop0, class Storage0,
            class Prop1, class Storage1,
            template <class U> class Allocator> inline int
  HeterogeneousMatrixCollection<Prop0, Storage0, Prop1, Storage1, Allocator>
  ::GetSize() const
  {
    return this->m_ * this->n_;
  }
 
 
 
  template <class Prop0, class Storage0,
            class Prop1, class Storage1,
            template <class U> class Allocator>
  inline int
  HeterogeneousMatrixCollection<Prop0, Storage0, Prop1, Storage1, Allocator>
  ::GetDataSize() const
  {
    return nz_;
  }
 
 
  template <class Prop0, class Storage0,
            class Prop1, class Storage1,
            template <class U> class Allocator>
  inline size_t 
  HeterogeneousMatrixCollection<Prop0, Storage0, Prop1, Storage1, Allocator>
  ::GetMemorySize() const
  {
    // to implement
    return 0;
  }
 
 
 
 
  template <class Prop0, class Storage0,
            class Prop1, class Storage1,
            template <class U> class Allocator>
  inline int
  HeterogeneousMatrixCollection<Prop0, Storage0, Prop1, Storage1, Allocator>
  ::GetType(int i, int j) const
  {
#ifdef SELDON_CHECK_BOUNDS
    if (i < 0 || i >= Mmatrix_)
      throw WrongRow("HeterogeneousMatrixCollection::GetType()",
                     string("Index should be in [0, ")
                     + to_str(Mmatrix_ - 1) + "], but is equal to "
                     + to_str(i) + ".");
    if (j < 0 || j >= Nmatrix_)
      throw WrongCol("HeterogeneousMatrixCollection::GetType()",
                     string("Index should be in [0, ")
                     + to_str(Nmatrix_ - 1) + "], but is equal to "
                     + to_str(j) + ".");
#endif
    return collection_(i, j);
  }
 
 
 
 
  template <class Prop0, class Storage0,
            class Prop1, class Storage1,
            template <class U> class Allocator> inline typename
  HeterogeneousMatrixCollection<Prop0, Storage0, Prop1, Storage1, Allocator>
  ::float_dense_c&
  HeterogeneousMatrixCollection<Prop0, Storage0, Prop1, Storage1, Allocator>
  ::GetFloatDense()
  {
    return float_dense_c_;
  }
 
 
 
  template <class Prop0, class Storage0,
            class Prop1, class Storage1,
            template <class U> class Allocator> inline const typename
  HeterogeneousMatrixCollection<Prop0, Storage0, Prop1, Storage1, Allocator>
  ::float_dense_c&
  HeterogeneousMatrixCollection<Prop0, Storage0, Prop1, Storage1, Allocator>
  ::GetFloatDense() const
  {
    return float_dense_c_;
  }
 
 
 
  template <class Prop0, class Storage0,
            class Prop1, class Storage1,
            template <class U> class Allocator> inline typename
  HeterogeneousMatrixCollection<Prop0, Storage0, Prop1, Storage1, Allocator>
  ::float_sparse_c&
  HeterogeneousMatrixCollection<Prop0, Storage0, Prop1, Storage1, Allocator>
  ::GetFloatSparse()
  {
    return float_sparse_c_;
  }
 
 
 
  template <class Prop0, class Storage0,
            class Prop1, class Storage1,
            template <class U> class Allocator> inline const typename
  HeterogeneousMatrixCollection<Prop0, Storage0, Prop1, Storage1, Allocator>
  ::float_sparse_c&
  HeterogeneousMatrixCollection<Prop0, Storage0, Prop1, Storage1, Allocator>
  ::GetFloatSparse() const
  {
    return float_sparse_c_;
  }
 
 
 
  template <class Prop0, class Storage0,
            class Prop1, class Storage1,
            template <class U> class Allocator> inline typename
  HeterogeneousMatrixCollection<Prop0, Storage0, Prop1, Storage1, Allocator>
  ::double_dense_c&
  HeterogeneousMatrixCollection<Prop0, Storage0, Prop1, Storage1, Allocator>
  ::GetDoubleDense()
  {
    return double_dense_c_;
  }
 
 
 
  template <class Prop0, class Storage0,
            class Prop1, class Storage1,
            template <class U> class Allocator> inline const typename
  HeterogeneousMatrixCollection<Prop0, Storage0, Prop1, Storage1, Allocator>
  ::double_dense_c&
  HeterogeneousMatrixCollection<Prop0, Storage0, Prop1, Storage1, Allocator>
  ::GetDoubleDense() const
  {
    return double_dense_c_;
  }
 
 
 
  template <class Prop0, class Storage0,
            class Prop1, class Storage1,
            template <class U> class Allocator> inline typename
  HeterogeneousMatrixCollection<Prop0, Storage0, Prop1, Storage1, Allocator>
  ::double_sparse_c&
  HeterogeneousMatrixCollection<Prop0, Storage0, Prop1, Storage1, Allocator>
  ::GetDoubleSparse()
  {
    return double_sparse_c_;
  }
 
 
 
  template <class Prop0, class Storage0,
            class Prop1, class Storage1,
            template <class U> class Allocator> inline const typename
  HeterogeneousMatrixCollection<Prop0, Storage0, Prop1, Storage1, Allocator>
  ::double_sparse_c&
  HeterogeneousMatrixCollection<Prop0, Storage0, Prop1, Storage1, Allocator>
  ::GetDoubleSparse() const
  {
    return double_sparse_c_;
  }
 
 
  /****************
   * CONSTRUCTORS *
   ****************/
 
 
 
  template <template <class U> class Allocator>
  inline
  Matrix<FloatDouble, General, DenseSparseCollection, Allocator<double> >
  ::Matrix():
    HeterogeneousMatrixCollection<General, RowMajor, General,
                                  RowSparse, Allocator>()
  {
  }
 
 
 
  template <template <class U> class Allocator>
  inline
  Matrix<FloatDouble, General, DenseSparseCollection, Allocator<double> >
  ::Matrix(int i, int j):
    HeterogeneousMatrixCollection<General, RowMajor, General,
                                  RowSparse, Allocator>(i, j)
  {
  }
 
 
} // namespace Seldon.
 
#define SELDON_FILE_MATRIX_HETEROGENEOUS_COLLECTION_INLINE_CXX
#endif