gmc.h

Go to the documentation of this file.

// -*-C++-*- 

// Copyright (C) 2004 
// Christian Stimming <stimming@tuhh.de>

// Row-order modifications by Jacob (Jack) Gryn <jgryn at cs dot yorku dot ca>

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

//      LAPACK++ (V. 1.1)
//      (C) 1992-1996 All Rights Reserved.
//
//      Lapack++ Rectangular Matrix Class
//
//      Dense (nonsingular) matrix, assumes no special structure or properties.
//
//      ) allows 2-d indexing
//      ) non-unit strides
//      ) deep (copy) assignment
//      ) std::cout << A.info()  prints out internal states of A
//      ) indexing via A(i,j) where i,j are either integers or
//              LaIndex         

#ifndef _LA_GEN_MAT_COMPLEX_H_
#define _LA_GEN_MAT_COMPLEX_H_

#ifndef LA_COMPLEX_SUPPORT
/* An application must define LA_COMPLEX_SUPPORT if it wants to use
 * complex numbers here. */
# error "The macro LA_COMPLEX_SUPPORT needs to be defined if you want to use complex-valued matrices."
#endif

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

class LaGenMatComplex;
class LaGenMatDouble;
class LaGenMatFloat;
class LaGenMatInt;
class LaGenMatLongInt;

class DLLIMPORT LaGenMatComplex
{
   public:
      typedef COMPLEX value_type;
      typedef LaGenMatComplex matrix_type;
      typedef VectorComplex vec_type;
   private:
      vec_type     v;
      LaIndex           ii[2];
      int             dim[2];  // size of original matrix, not submatrix
      //int             sz[2];   // size of this submatrix
      void init(int m, int n);
      int size0;
      int size1;
      static int  debug_; // trace all entry and exits into methods and 
      // operators of this class.  This variable is
      // explicitly initalized in lagenmatCOMPLEX.cc

      static int      *info_;   // print matrix info only, not values
      //   originally 0, set to 1, and then
      //   reset to 0 after use.
      // use as in
      //
      //    std::cout << B.info() << std::endl;
      //
      // this *info_ member is unique in that it really isn't
      // part of the matrix info, just a flag as to how
      // to print it.   We've included in this beta release
      // as part of our testing, but we do not expect it 
      // to be user accessable.
      // It has to be declared as global static
      // so that we may monitor expresssions like
      // X::(const &X) and still utilize without violating
      // the "const" condition.
      // Because this *info_ is used at most one at a time,
      // there is no harm in keeping only one copy of it,
      // also, we do not need to malloc free space every time
      // we call a matrix constructor.


      int shallow_; // set flag to '0' in order to return matrices
                    // by value from functions without unecessary
                    // copying.


      // users shouldn't be able to modify assignment semantics..
      //
      //LaGenMatComplex& shallow_assign();

   public:


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

      LaGenMatComplex();

      LaGenMatComplex(int m, int n);

      LaGenMatComplex(COMPLEX*v, int m, int n, bool row_ordering=false);

      LaGenMatComplex(const LaGenMatComplex&);

      explicit LaGenMatComplex(const LaGenMatDouble& s_real, 
                      const LaGenMatDouble& s_imag = LaGenMatDouble());

      LaGenMatComplex& resize(int m, int n);

      LaGenMatComplex& resize(const LaGenMatComplex& s);

      virtual ~LaGenMatComplex();


      bool is_zero() const;

      bool is_submatrixview() const
      { return size(0) != gdim(0) || size(1) != gdim(1); };

      bool has_unitstride() const
      { return inc(0) == 1 && inc(1) == 1; };

      bool equal_to(const LaGenMatComplex& mat) const;


      /*::::::::::::::::::::::::::::::::*/
      /*  Indices and access operations */
      /*::::::::::::::::::::::::::::::::*/

      inline int size(int d) const;   // submatrix size
      inline int cols() const { return size(1); }
      inline int rows() const { return size(0); }

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

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

      inline int start(int d) const;  // return ii[d].start()

      inline int end(int d) const;    // return ii[d].end()

      inline LaIndex index(int d) const;// index

      inline int ref_count() const;

      inline COMPLEX* addr() const;       // begining addr of data space

      inline COMPLEX& operator()(int i, int j);

      inline COMPLEX& operator()(int i, int j) const;

      LaGenMatComplex operator()(const LaIndex& I, const LaIndex& J) ;

      LaGenMatComplex operator()(const LaIndex& I, const LaIndex& J) const;

      LaGenMatComplex row(int k);
      LaGenMatComplex row(int k) const;
      LaGenMatComplex col(int k);
      LaGenMatComplex col(int k) const;

      LaGenMatComplex& operator=(COMPLEX s);

      // CS: addition
      LaGenMatComplex& operator=(const LaComplex& s);

      /* Set elements of left-hand size to the scalar value s. No
       * new matrix is created, so that if there are other matrices
       * that reference this memory space, they will also be
       * affected. */
      //LaGenMatComplex& operator=(const std::complex<double>& s);
      // CS: end

      LaGenMatComplex& operator=(const LaGenMatComplex& s); //copy

      LaGenMatComplex& operator+=(COMPLEX s);

      LaGenMatComplex& add(COMPLEX s);

      LaGenMatComplex& scale(const LaComplex& s);

      LaGenMatComplex& scale(COMPLEX s);

      LaGenMatComplex& operator*=(COMPLEX s);

      LaGenMatComplex& inject(const LaGenMatComplex& s);

      LaGenMatComplex& copy(const LaGenMatComplex& s);

      LaGenMatComplex copy() const;

      LaGenMatComplex& copy(const LaGenMatDouble& s_real, 
                            const LaGenMatDouble& s_imag = LaGenMatDouble());

      inline LaGenMatComplex& shallow_assign();

      LaGenMatComplex& ref(const LaGenMatComplex& s);

      LaGenMatComplex repmat (int M, int N) const;
      value_type trace () const;
      LaGenMatComplex diag () const;

      LaGenMatDouble real() const;

      LaGenMatDouble imag() const;


      inline int shallow() const      // read global shallow flag
      { return shallow_;}
      inline int debug() const;       // read global debug flag
      inline int debug(int d);        // set global debug flag

      inline const LaGenMatComplex& info() const { 
         *(const_cast<LaGenMatComplex*>(this)->info_) = 1; 
         return *this; 
      };

      inline std::ostream& Info(std::ostream& s) const
      {
         s << "Size: (" << size(0) << "x" << size(1) << ") " ;
         s << "Indeces: " << ii[0] << " " << ii[1];
         s << "#ref: " << ref_count() << "addr: " << addr() << std::endl;
         return s;
      };

      friend DLLIMPORT std::ostream& operator<<(std::ostream&, const LaGenMatComplex&);

      LaGenMatDouble real_to_LaGenMatDouble() const;
      LaGenMatFloat real_to_LaGenMatFloat() const;
      LaGenMatInt real_to_LaGenMatInt() const;
      LaGenMatLongInt real_to_LaGenMatLongInt() const;
      LaGenMatDouble imag_to_LaGenMatDouble() const;
      LaGenMatFloat imag_to_LaGenMatFloat() const;
      LaGenMatInt imag_to_LaGenMatInt() const;
      LaGenMatLongInt imag_to_LaGenMatLongInt() const;


      static LaGenMatComplex zeros (int N, int M=0);
      static LaGenMatComplex ones (int N, int M=0);
      static LaGenMatComplex eye (int N, int M=0);
      static LaGenMatComplex rand (int N, int M,
                               double low=0, double high=1);
      static LaGenMatComplex from_diag (const LaGenMatComplex &vect);
      static LaGenMatComplex linspace (value_type start, 
                                   value_type end,
                                   int nr_points);

};  //* End of LaGenMatComplex Class *//



namespace la {
   typedef LaGenMatComplex cmat;
} // namespace

DLLIMPORT
std::ostream& operator<<(std::ostream&, const LaGenMatComplex&);


    //* Member Functions *//


 
inline int LaGenMatComplex::size(int d) const
{
   if (d==0)
      return size0;
   else
      return size1;
   //return sz[d];
}

inline int LaGenMatComplex::inc(int d) const
{
   return ii[d].inc();
}

inline int LaGenMatComplex::gdim(int d) const
{
   return dim[d];
}

inline int LaGenMatComplex::start(int d) const
{
   return ii[d].start();
}

inline int LaGenMatComplex::end(int d) const
{
   return ii[d].end();
}

inline int LaGenMatComplex::ref_count() const
{
   return v.ref_count();
}


inline LaIndex LaGenMatComplex::index(int d)  const
{
   return ii[d];
}

inline COMPLEX* LaGenMatComplex::addr() const
{
   return  v.addr();
}

inline int LaGenMatComplex::debug() const
{
   return debug_;
}

inline int LaGenMatComplex::debug(int d)
{
   return debug_ = d;
}

inline COMPLEX& LaGenMatComplex::operator()(int i, int j)
{

#ifdef LA_BOUNDS_CHECK
   assert(i>=0);
   assert(i<size(0));
   assert(j>=0);
   assert(j<size(1));
#endif
   return v( dim[0]*(ii[1].start() + j*ii[1].inc()) + 
             ii[0].start() + i*ii[0].inc());
}

inline COMPLEX& LaGenMatComplex::operator()(int i, int j) const
{

#ifdef LA_BOUNDS_CHECK
   assert(i>=0);
   assert(i<size(0));
   assert(j>=0);
   assert(j<size(1));
#endif

   return v( dim[0]*(ii[1].start() + j*ii[1].inc()) + 
             ii[0].start() + i*ii[0].inc());
}




inline  LaGenMatComplex&  LaGenMatComplex::shallow_assign()
{
   shallow_ = 1;
   return *this;
}



#ifndef LA_COMPLEX_SUPPORT
// Repeat this warning again
# error "The macro LA_COMPLEX_SUPPORT needs to be defined if you want to use complex-valued matrices."
#endif


#endif 
// _LA_GEN_MAT_H_

---