lavc.h

Go to the documentation of this file.

// -*-C++-*- 

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

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

#ifndef _LA_VECTOR_COMPLEX_H_
#define _LA_VECTOR_COMPLEX_H_

#include "lafnames.h"
#include LA_GEN_MAT_COMPLEX_H


class LaVectorComplex: public LaGenMatComplex
{
   public:

      LaVectorComplex();

      LaVectorComplex(int n);

      LaVectorComplex(int m, int n);  

      LaVectorComplex(COMPLEX* v, int n);

      LaVectorComplex(COMPLEX*, int m, int n);

      LaVectorComplex(const LaGenMatComplex&);


      inline int size() const;

      inline int inc() const;

      inline int start() const;

      inline int end() const;

      inline LaIndex index() const;

      inline COMPLEX& operator()(int i);

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

      inline LaVectorComplex operator()(const LaIndex& i);

      inline LaVectorComplex operator()(const LaIndex& i) const;
    
      inline LaVectorComplex& operator=(COMPLEX s);

      // CS: addition
      inline LaVectorComplex& operator=(LaComplex s);

      inline LaVectorComplex& operator=(double s);
      // CS: end

      inline LaVectorComplex& operator=(const LaGenMatComplex& s);


      inline LaVectorComplex& inject(const LaGenMatComplex &s);

      inline LaVectorComplex& copy(const LaGenMatComplex &s);

      inline LaVectorComplex& ref(const LaGenMatComplex &s);
};

// NOTE: we default to column vectors, since matrices are column
//  oriented.

inline LaVectorComplex::LaVectorComplex() : LaGenMatComplex(0,1) {}
inline LaVectorComplex::LaVectorComplex(int i) : LaGenMatComplex(i,1) {}

// NOTE: one shouldn't be using this method to initalize, but
// it is here so that the constructor can be overloaded with 
// a runtime test.
//
inline LaVectorComplex::LaVectorComplex(int m, int n) : LaGenMatComplex(m,n)
{
   assert(n==1 || m==1);
}

inline LaVectorComplex::LaVectorComplex(COMPLEX *d, int m) : 
   LaGenMatComplex(d,m,1) {}

inline LaVectorComplex::LaVectorComplex(COMPLEX *d, int m, int n) : 
   LaGenMatComplex(d,m,n) {}

inline LaVectorComplex::LaVectorComplex(const LaGenMatComplex& G)
{
   assert(G.size(0)==1 || G.size(1)==1);

   (*this).ref(G);
}
        
//note that vectors can be either stored columnwise, or row-wise

// this will handle the 0x0 case as well.

inline int LaVectorComplex::size() const 
{
   return LaGenMatComplex::size(0)*LaGenMatComplex::size(1); 
}

inline COMPLEX& LaVectorComplex::operator()(int i)
{
   if (LaGenMatComplex::size(0)==1 )
      return LaGenMatComplex::operator()(0,i);
   else
      return LaGenMatComplex::operator()(i,0);
}

inline const COMPLEX& LaVectorComplex::operator()(int i) const
{
   if (LaGenMatComplex::size(0)==1 )
      return LaGenMatComplex::operator()(0,i);
   else
      return LaGenMatComplex::operator()(i,0);
}

inline LaVectorComplex LaVectorComplex::operator()(const LaIndex& I)
{
   if (LaGenMatComplex::size(0)==1)
      return LaGenMatComplex::operator()(LaIndex(0,0),I).shallow_assign(); 
   else
      return LaGenMatComplex::operator()(I,LaIndex(0,0)).shallow_assign(); 
}

inline LaVectorComplex LaVectorComplex::operator()(const LaIndex& I) const
{
   if (LaGenMatComplex::size(0)==1)
      return LaGenMatComplex::operator()(LaIndex(0,0),I).shallow_assign(); 
   else
      return LaGenMatComplex::operator()(I,LaIndex(0,0)).shallow_assign(); 
}

inline LaVectorComplex& LaVectorComplex::copy(const LaGenMatComplex &A)
{
   assert(A.size(0) == 1 || A.size(1) == 1);   //make sure rhs is a
   // a vector.
   LaGenMatComplex::copy(A);
   return *this;
}


inline LaVectorComplex& LaVectorComplex::operator=(const LaGenMatComplex &A)
{
   return copy(A); // until lapackpp-2.5.0: inject(A);
}

inline LaVectorComplex& LaVectorComplex::ref(const LaGenMatComplex &A)
{
   assert(A.size(0) == 1 || A.size(1) == 1);
   LaGenMatComplex::ref(A);
   return *this;
}

inline LaVectorComplex& LaVectorComplex::operator=(COMPLEX d)
{
   LaGenMatComplex::operator=(d);
   return *this;
}
inline LaVectorComplex& LaVectorComplex::operator=(LaComplex d)
{
   LaGenMatComplex::operator=(d.toCOMPLEX());
   return *this;
}
inline LaVectorComplex& LaVectorComplex::operator=(double d)
{
   LaGenMatComplex::operator=(LaComplex(d).toCOMPLEX());
   return *this;
}

inline LaVectorComplex& LaVectorComplex::inject(const LaGenMatComplex &A)
{
   assert(A.size(0) == 1 || A.size(1) == 1);
   LaGenMatComplex::inject(A);
   return *this;
}
    
inline int LaVectorComplex::inc() const
{
   if (LaGenMatComplex::size(1)==1 )
      return LaGenMatComplex::inc(0);
   else
      return LaGenMatComplex::inc(1)*LaGenMatComplex::gdim(0);
   // NOTE: This was changed on 2005-03-04 because without the dim[0]
   // this gives wrong results on non-unit-stride submatrix views.
}

inline LaIndex LaVectorComplex::index() const
{
   if (LaGenMatComplex::size(1)==1 )
      return LaGenMatComplex::index(0);
   else
      return LaGenMatComplex::index(1);
}

inline int LaVectorComplex::start() const
{
   if (LaGenMatComplex::size(1)==1 )
      return LaGenMatComplex::start(0);
   else
      return LaGenMatComplex::start(1);
}

inline int LaVectorComplex::end() const
{
   if (LaGenMatComplex::size(1)==1 )
      return LaGenMatComplex::end(0);
   else
      return LaGenMatComplex::end(1);
}

#endif 
// _LA_VECTOR_COMPLEX_H_

---