matrix.h

Go to the documentation of this file.

/*-*-c++-*-****************************************************************
 *                     matrix.h Matrix class 
                       -------------------
 begin                : Feb 2003
 copyright            : (C) 2003 by Christian Stimming
 email                : 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.1 of the License, 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; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef MATRIX_H
#define MATRIX_H

#define LA_COMPLEX_SUPPORT

// activate bounds check for lapack++
#if DEBUG
# define LA_BOUNDS_CHECK
# define VECTOR_DOUBLE_BOUNDS_CHECK
#endif //DEBUG

#include <simthetic/misc.h>
#include <simthetic/signals.h>

#include <lafnames.h>       /* macros for LAPACK++ filenames */
#include <lapack.h>
#include LA_GEN_MAT_DOUBLE_H
#include LA_VECTOR_DOUBLE_H 
#include LA_GEN_MAT_COMPLEX_H
#include LA_VECTOR_COMPLEX_H
#include LA_VECTOR_LONG_INT_H
#include <blas++.h>
#include LA_SOLVE_DOUBLE_H
#include LA_EXCEPTION_H
#include LA_UTIL_H
#include <lacomplex.h>

namespace mimo 
{
   typedef LaComplex Complex;

   typedef LaGenMatDouble Matrix;

   typedef LaVectorDouble Vector;

   typedef LaGenMatComplex CMatrix;

   typedef LaVectorComplex CVector;
} // namespace mimo

namespace mimo
{

   inline int real_size(const CMatrix &, int complex_size)
   { return complex_size; }

   inline const Complex &c_assign(CMatrix &A, int i, int j, 
                  const Complex &c);

   inline Complex c_access(const CMatrix &A, int i, int j);

   std::ostream& c_print(std::ostream& s, const CMatrix& G);

   inline int c_size(const CMatrix &A, int dim);


   CMatrix c_eye(int i);
   CMatrix c_zeros(int i, int j);
   CMatrix c_ones(int i, int j);

   inline const Complex &c_add_s(CMatrix &A, int i, int j, const Complex&c);

   simth::Complex c_det(const CMatrix& A);
   



   Matrix eye(int i);
   Matrix zeros(int i, int j);
   Matrix ones(int i, int j);

   double det(const Matrix& A);



   inline const Complex &c_assign(CVector &A, int i, const Complex &c);

   inline Complex c_access(const CVector &A, int i);

   std::ostream& c_print(std::ostream& s, const CVector& G);

   inline int c_size(const CVector &A);

   inline const Complex &c_add_s(CVector &a, int i, const Complex&c);

   CVector c_ones(int i);
   CVector c_zeros(int i);
   Vector zeros(int i);


   inline
   void Blas_Add_Mult(CVector &dy, const Complex& c, 
              const CVector &dx)
   { ::Blas_Add_Mult(dy, c.toCOMPLEX(), dx); }

   inline
   void Blas_Mult(CVector &dy, const Complex& c, 
          const CVector &dx)
   { ::Blas_Mult(dy, c, dx); }

   inline
   void Blas_Scale(const Complex& c, CVector &dx)
   { ::Blas_Scale(c, dx); }

   inline
   Complex Blas_Dot_Prod(const CVector &dx, const CVector &dy)
   { return ::Blas_H_Dot_Prod(dx, dy); }


   inline
   void Blas_R1_Update(CMatrix &A, const CVector &dx, 
               const CVector &dy, const Complex& alpha)
   { ::Blas_R1_Update(A, dx, dy, alpha); }

    double Blas_NormF(const CMatrix &A);

    double Blas_NormF(const Matrix &A);

   double Blas_Cond(const CMatrix &a, double threshold = 0.0);

   unsigned Blas_Rank(const CMatrix &a, double threshold = 0.0);


   double Blas_NormF_squared(const CMatrix &A);

   void Mat_Add_Norm(Matrix &A, const CMatrix &B);
} // namespace mimo

// //////////////////////////////////
// CMatrix definitions
// //////////////////////////////////

#ifndef DOXYGEN_IGNORE


inline const mimo::Complex &mimo::c_assign(CMatrix &A, int i, int j, const mimo::Complex &c)
{
   A(i,j) = c;
   return c;
}
inline mimo::Complex mimo::c_access(const CMatrix &A, int i, int j)
{
   return mimo::Complex(A(i,j));
}
inline const mimo::Complex &mimo::c_assign(CVector &A, int i, const mimo::Complex &c)
{
   A(i)  =  c;
   return c;
}
inline mimo::Complex mimo::c_access(const CVector &A, int i)
{
   return mimo::Complex(A(i));
}

inline int mimo::c_size(const CMatrix &A, int dim)
{
   return A.size(dim); 
}
inline int mimo::c_size(const CVector &A)
{
   return A.size(); 
}
inline const mimo::Complex &mimo::c_add_s(CVector &A, int i, const mimo::Complex&c)
{
   A(i) = Complex(A(i)) + c;
   return c;
}
inline const mimo::Complex &mimo::c_add_s(CMatrix &A, int i, int j, const mimo::Complex&c)
{
   A(i,j) = Complex(A(i,j)) + c;
   return c;
}

#endif // DOXYGEN_IGNORE

#endif // MATRIX_H

---