sybmd.h

Go to the documentation of this file.

//      LAPACK++ (V. 1.1)
//      (C) 1992-1996 All Rights Reserved.

// Dominik Wagenfuehr <dominik.wagenfuehr@arcor.de>
// Copyright (C) 2006

// This library 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, or (at
// your option) any later version.

// This library 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 this library; see the file COPYING.  If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.

#ifndef _LA_SYMM_BAND_MAT_DOUBLE_H_
#define _LA_SYMM_BAND_MAT_DOUBLE_H_

#include "arch.h"
#include "lafnames.h"
#include LA_GEN_MAT_DOUBLE_H

class DLLIMPORT LaSymmBandMatDouble
{
  LaGenMatDouble data_;  // internal storage.

  int N_;       // N_ is (NxN)
  int kl_;      // kl_ = # subdiags
  static double outofbounds_; // out of range value returned.
  static int debug_;         // print debug info.
  static int *info_;         // print matrix info only, not values
                             //   originally 0, set to 1, and then
                             //   reset to 0 after use.


public:

  /*::::::::::::::::::::::::::*/
  /* Constructors/Destructors */
  /*::::::::::::::::::::::::::*/

  LaSymmBandMatDouble();

  LaSymmBandMatDouble(int n, int p);

  LaSymmBandMatDouble(const LaSymmBandMatDouble& A);

  ~LaSymmBandMatDouble();

  LaSymmBandMatDouble& resize(int n, int p);

  LaSymmBandMatDouble& resize(const LaSymmBandMatDouble& ob);


  LaSymmBandMatDouble& operator=(double scalar);

  LaSymmBandMatDouble& operator=(const LaSymmBandMatDouble& ob);

  double& operator()(int i, int j);

  double& operator()(int i, int j) const;

  inline LaSymmBandMatDouble& ref(LaSymmBandMatDouble &ob);

  LaSymmBandMatDouble& copy(const LaSymmBandMatDouble &ob);


  inline int size(int d) const;         // submatrix size

  inline int inc(int d) const;          // explicit increment

  inline int gdim(int d) const;         // global dimensions

  inline double* addr() const 
  {     
        return data_.addr();
  }
  
  inline int ref_count() const  
  { 
        return data_.ref_count();
  }
  
  inline LaIndex index(int d) const
  { 
        return data_.index(d);
  }
  
  inline int subdiags()
  { 
        return (kl_);
  }

  inline int subdiags() const
  {
        return (kl_);
  }


  inline int shallow() const
  {
        return data_.shallow();
  }
  
  inline int debug() const
  {
        return debug_;
  }
  
  inline int debug(int d)
  {
        return debug_ = d;
  }

  inline const LaSymmBandMatDouble& info() const
  {
        int *t = info_;
        *t = 1;
        return *this;
  };

  inline void print_data() const
  {
        std::cout << data_;
  }

  friend std::ostream& operator<<(std::ostream &s, const LaSymmBandMatDouble &ob);

};

  // member functions and operators

inline LaSymmBandMatDouble& LaSymmBandMatDouble::ref(LaSymmBandMatDouble &ob)
{
  data_.ref(ob.data_);
  N_ = ob.N_;
  kl_ = ob.kl_;

  return *this;
}

inline int LaSymmBandMatDouble::size(int d) const
{
   return(data_.size(1));
}

inline int LaSymmBandMatDouble::inc(int d) const
{
   return(data_.inc(d));
}

inline int LaSymmBandMatDouble::gdim(int d) const
{
   return(data_.gdim(d));
}

inline double& LaSymmBandMatDouble::operator()(int i, int j)
{
#ifdef LA_BOUNDS_CHECK
   assert(i >= 0);
   assert(i < N_);
   assert(j >= 0);
   assert(j < N_);
#endif

   if (i >= j)
   {
      if (i-j <= kl_)
         return data_(kl_ + i - j, j);
      else
      {
#ifdef LA_BOUNDS_CHECK
         assert(0);
#else
         return outofbounds_;
#endif
      }
   }
   else // if (j>i)
   {
      if (j-i <= kl_)
         return data_(kl_ + j - i,i);
      else
      {
#ifdef LA_BOUNDS_CHECK
         assert(0);
#else
         return outofbounds_;
#endif
      }
   }
}

inline double& LaSymmBandMatDouble::operator()(int i, int j) const
{
#ifdef LA_BOUNDS_CHECK
   assert(i >= 0);
   assert(i < N_);
   assert(j >= 0);
   assert(j < N_);
#endif

   if (i >= j)
   {
      if (i-j <= kl_)
         return data_(kl_ + i - j, j);
      else
      {
#ifdef LA_BOUNDS_CHECK
         assert(0);
#else
         return outofbounds_;
#endif
      }
   }
   else // if (j>i)
   {
      if (j-i <= kl_)
         return data_(kl_ + j - i,i);
      else
      {
#ifdef LA_BOUNDS_CHECK
         assert(0);
#else
         return outofbounds_;
#endif
      }
   }
}

#endif 
// _LA_SYMM_BAND_MAT_DOUBLE_H_

---