fn_eig.hpp

Go to the documentation of this file.
00001 // Copyright (C) 2010 NICTA and the authors listed below
00002 // http://nicta.com.au
00003 // 
00004 // Authors:
00005 // - Conrad Sanderson (conradsand at ieee dot org)
00006 // - Edmund Highcock (edmund dot highcock at merton dot ox dot ac dot uk)
00007 // 
00008 // This file is part of the Armadillo C++ library.
00009 // It is provided without any warranty of fitness
00010 // for any purpose. You can redistribute this file
00011 // and/or modify it under the terms of the GNU
00012 // Lesser General Public License (LGPL) as published
00013 // by the Free Software Foundation, either version 3
00014 // of the License or (at your option) any later version.
00015 // (see http://www.opensource.org/licenses for more info)
00016 
00017 
00018 //! \addtogroup fn_eig
00019 //! @{
00020 
00021 
00022 //
00023 // symmetric/hermitian matrices
00024 //
00025 
00026 
00027 //! Eigenvalues of real/complex symmetric/hermitian matrix X
00028 template<typename T1>
00029 inline
00030 void
00031 eig_sym(Col<typename T1::pod_type>& eigval, const Base<typename T1::elem_type,T1>& X)
00032   {
00033   arma_extra_debug_sigprint();
00034   
00035   typedef typename T1::elem_type eT;
00036   
00037   // unwrap_check not used as T1::elem_type and T1::pod_type may not be the same.
00038   // furthermore, it doesn't matter if A is an alias of S, as auxlib::eig() makes a copy of A
00039 
00040   const unwrap<T1> tmp(X.get_ref());
00041   const Mat<eT>& A = tmp.M;
00042 
00043   auxlib::eig_sym(eigval, A);
00044   }
00045 
00046 
00047 
00048 //! Eigenvalues of real/complex symmetric/hermitian matrix X
00049 template<typename T1>
00050 inline
00051 Col<typename T1::pod_type>
00052 eig_sym(const Base<typename T1::elem_type,T1>& X)
00053   {
00054   arma_extra_debug_sigprint();
00055   
00056   Col<typename T1::pod_type> out;
00057   eig_sym(out, X);
00058   
00059   return out;
00060   }
00061 
00062 
00063 //! Eigenvalues and eigenvectors of real/complex symmetric/hermitian matrix X
00064 template<typename T1> 
00065 inline
00066 void
00067 eig_sym
00068   (
00069   Col<typename T1::pod_type>& eigval,
00070   Mat<typename T1::elem_type>& eigvec,
00071   const Base<typename T1::elem_type,T1>& X
00072   )
00073   {
00074   arma_extra_debug_sigprint();
00075 
00076   typedef typename T1::elem_type eT;
00077   
00078   const unwrap<T1> tmp(X.get_ref());
00079   const Mat<eT>& A = tmp.M;
00080   
00081   auxlib::eig_sym(eigval, eigvec, A);
00082   }
00083 
00084 
00085 
00086 //
00087 // general matrices
00088 //
00089 
00090 
00091 
00092 //! Eigenvalues and eigenvectors (both left and right) of general real/complex square matrix X
00093 template<typename T1>
00094 inline
00095 void
00096 eig_gen
00097   (
00098   Col< std::complex<typename T1::pod_type> >& eigval, 
00099   Mat<typename T1::elem_type>&                l_eigvec,
00100   Mat<typename T1::elem_type>&                r_eigvec,
00101   const Base<typename T1::elem_type,T1>&      X
00102   )
00103   {
00104   arma_extra_debug_sigprint();
00105 
00106   typedef typename T1::elem_type eT;
00107   
00108   const unwrap<T1> tmp(X.get_ref());
00109   const Mat<eT>& A = tmp.M;
00110 
00111   auxlib::eig_gen(eigval, l_eigvec, r_eigvec, A, 'b');
00112   }
00113 
00114 
00115 
00116 //! Eigenvalues and eigenvectors of general real square matrix X.
00117 //! Optional argument 'side' specifies which eigenvectors should be computed:
00118 //! 'r' for right (default) and 'l' for left.
00119 template<typename eT, typename T1>
00120 inline
00121 void
00122 eig_gen
00123   (
00124   Col< std::complex<eT> >& eigval, 
00125   Mat< std::complex<eT> >& eigvec,
00126   const Base<eT, T1>& X, 
00127   const char side = 'r'
00128   )
00129   {
00130   arma_extra_debug_sigprint();
00131 
00132   //std::cout << "real" << std::endl;
00133 
00134   const unwrap<T1> tmp(X.get_ref());
00135   const Mat<eT>& A = tmp.M;
00136 
00137   Mat<eT> dummy_eigvec;
00138   Mat<eT> tmp_eigvec;
00139   
00140   switch(side)
00141     {
00142     case 'r':
00143       auxlib::eig_gen(eigval, dummy_eigvec, tmp_eigvec, A, side);
00144       break;
00145 
00146     case 'l':
00147       auxlib::eig_gen(eigval, tmp_eigvec, dummy_eigvec, A, side);
00148       break;
00149       
00150     default:
00151       arma_stop("eig_gen(): parameter 'side' is invalid");
00152     }
00153 
00154 
00155   const u32 n = A.n_rows;
00156 
00157   if(n > 0)
00158     {
00159     eigvec.set_size(n,n);
00160 
00161     for(u32 j=0; j<n; ++j)
00162       {
00163       if( (j < n-1) && (eigval[j] == std::conj(eigval[j+1])) )
00164         {
00165         // eigvec.col(j)   = Mat< std::complex<eT> >( tmp_eigvec.col(j),  tmp_eigvec.col(j+1) );
00166         // eigvec.col(j+1) = Mat< std::complex<eT> >( tmp_eigvec.col(j), -tmp_eigvec.col(j+1) );
00167 
00168         for(u32 i=0; i<n; ++i)
00169           {
00170           eigvec.at(i,j)   = std::complex<eT>( tmp_eigvec.at(i,j),  tmp_eigvec.at(i,j+1) );
00171           eigvec.at(i,j+1) = std::complex<eT>( tmp_eigvec.at(i,j), -tmp_eigvec.at(i,j+1) );
00172           }
00173 
00174         ++j;
00175         }
00176       else
00177         {
00178         // eigvec.col(i) = tmp_eigvec.col(i);
00179 
00180         for(u32 i=0; i<n; ++i)
00181           {
00182           eigvec.at(i,j) = std::complex<eT>(tmp_eigvec.at(i,j), eT(0));
00183           }
00184 
00185         }
00186       }
00187     }
00188 
00189   }
00190 
00191 
00192 
00193 //! Eigenvalues and eigenvectors of general complex square matrix X
00194 //! Optional argument 'side' specifies which eigenvectors should be computed:
00195 //! 'r' for right (default) and 'l' for left.
00196 template<typename T, typename T1>
00197 inline
00198 void
00199 eig_gen
00200   (
00201   Col< std::complex<T> >& eigval, 
00202   Mat< std::complex<T> >& eigvec,
00203   const Base<std::complex<T>, T1>& X, 
00204   const char side = 'r'
00205   )
00206   {
00207   arma_extra_debug_sigprint();
00208   //std::cout << "complex" << std::endl;
00209 
00210   typedef typename std::complex<T> eT;
00211 
00212   const unwrap<T1> tmp(X.get_ref());
00213   const Mat<eT>& A = tmp.M;
00214 
00215   Mat<eT> dummy_eigvec;
00216   
00217   switch(side)
00218     {
00219     case 'r':
00220       auxlib::eig_gen(eigval, dummy_eigvec, eigvec, A, side);
00221       break;
00222 
00223     case 'l':
00224       auxlib::eig_gen(eigval, eigvec, dummy_eigvec, A, side);
00225       break;
00226       
00227     default:
00228       arma_stop("eig_gen(): parameter 'side' is invalid");
00229     }
00230   }
00231 
00232 
00233 
00234 //! @}
00235