matrix/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
{


  /****************
   * CONSTRUCTORS *
   ****************/



  template <class T, class Allocator>
  inline Matrix_Base<T, Allocator>::Matrix_Base()
  {
    m_ = 0;
    n_ = 0;
    data_ = NULL;
  }



  template <class T, class Allocator>
  inline Matrix_Base<T, Allocator>::Matrix_Base(int i, int j)
  {
#ifdef SELDON_CHECK_DIMENSIONS
    if (i < 0 || j < 0)
      throw WrongDim("Matrix_Base::Matrix_Base(int, int)",
                     "Unable to define a matrix with size "
                     + to_str(i) + " by " + to_str(j) + ".");
#endif

    m_ = i;
    n_ = j;
    data_ = NULL;
  }



  template <class T, class Allocator>
  inline Matrix_Base<T, Allocator>::
  Matrix_Base(const Matrix_Base<T, Allocator>& A)
  {
    m_ = A.GetM();
    n_ = A.GetN();
    data_ = NULL;
  }


  /**************
   * DESTRUCTOR *
   **************/



  template <class T, class Allocator>
  inline Matrix_Base<T, Allocator>::~Matrix_Base()
  {

  }


  /*******************
   * BASIC FUNCTIONS *
   *******************/



  template <class T, class Allocator>
  int Matrix_Base<T, Allocator>::GetM() const
  {
    return m_;
  }



  template <class T, class Allocator>
  int Matrix_Base<T, Allocator>::GetN() const
  {
    return n_;
  }



  template <class T, class Allocator>
  int Matrix_Base<T, Allocator>::GetM(const SeldonTranspose& status) const
  {
    if (status.NoTrans())
      return m_;
    else
      return n_;
  }



  template <class T, class Allocator>
  int Matrix_Base<T, Allocator>::GetN(const SeldonTranspose& status) const
  {
    if (status.NoTrans())
      return n_;
    else
      return m_;
  }


#ifdef SELDON_WITH_BLAS


  template <class T, class Allocator>
  int Matrix_Base<T, Allocator>::GetM(const CBLAS_TRANSPOSE& status) const
  {
    if (status == CblasNoTrans)
      return m_;
    else
      return n_;
  }
#endif


#ifdef SELDON_WITH_BLAS


  template <class T, class Allocator>
  int Matrix_Base<T, Allocator>::GetN(const CBLAS_TRANSPOSE& status) const
  {
    if (status == CblasNoTrans)
      return n_;
    else
      return m_;
  }
#endif



  template <class T, class Allocator>
  int Matrix_Base<T, Allocator>::GetSize() const
  {
    return m_ * n_;
  }



  template <class T, class Allocator>
  typename Matrix_Base<T, Allocator>::pointer
  Matrix_Base<T, Allocator>::GetData() const
  {
    return data_;
  }



  template <class T, class Allocator>
  typename Matrix_Base<T, Allocator>::const_pointer
  Matrix_Base<T, Allocator>::GetDataConst() const
  {
    return reinterpret_cast<typename Matrix_Base<T,
      Allocator>::const_pointer>(data_);
  }



  template <class T, class Allocator>
  void* Matrix_Base<T, Allocator>::GetDataVoid() const
  {
    return reinterpret_cast<void*>(data_);
  }



  template <class T, class Allocator>
  const void* Matrix_Base<T, Allocator>::GetDataConstVoid() const
  {
    return reinterpret_cast<const void*>(data_);
  }



  template <class T, class Allocator>
  Allocator& Matrix_Base<T, Allocator>::GetAllocator()
  {
    return allocator_;
  }


  // 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