LinAlg: LinAlg.h Source File

00001 //===========================================================================
00042 //===========================================================================
00043 
00044 #ifndef LINALG_H
00045 #define LINALG_H
00046 
00047 #include "Array/Array2D.h"
00048 
00049 
00052 void eigensort
00053 (
00054     Array2D< double >& vmatA,
00055     Array  < double >& dvecA
00056 );
00057 
00060 void eigensymmJacobi
00061 (
00062     Array2D< double >& amatA,
00063     Array2D< double >& vmatA,
00064     Array  < double >& dvecA
00065 );
00066 
00070 void eigensymmJacobi2
00071 (
00072     Array2D< double >& amatA,
00073     Array2D< double >& vmatA,
00074     Array  < double >& dvecA
00075 );
00076 
00077 
00078 
00082 void eigensymm_intermediate
00083 (
00084     const Array2D< double >& amatA,
00085     Array2D <double >& hmatA,
00086     Array2D< double >& vmatA,
00087     Array  < double >& dvecA
00088 );
00089 
00095 
00096 void eigensymm
00097 (
00098     const Array2D< double >& amatA,
00099     Array2D< double >& vmatA,
00100     Array  < double >& dvecA
00101 );
00102 
00103 
00109 
00110 void eigensymm
00111 (
00112     const Array< double >& A,
00113     Array< double >& G,
00114     Array< double >& l
00115 );
00116 
00117 
00122 
00123 void eigensymm
00124 (
00125     const Array2D< double >& amatA,
00126     Array2D< double >& vmatA,
00127     Array  < double >& dvecA,
00128     Array  < double >& odvecA
00129 );
00130 
00131 
00136 
00137 void eigensymm
00138 (
00139     const Array< double >& A,
00140     Array< double >& G,
00141     Array< double >& l,
00142     Array< double >& od
00143 );
00144 
00145 // eigen computes the eigenvalues of an arbitrary (non-symmetric)
00146 // matrix A and stores the unsorted eigenvalues in vr and vi (vr real
00147 // parts, vi complex parts)
00148 
00149 void eigen(Array<double> A, Array<double> & vr, Array<double> & vi);
00150 
00151 //===========================================================================
00171 void CholeskyDecomposition(const Array2D< double >& M, Array2D< double >& C);
00172 
00173 
00174 
00176 double eigenerr
00177 (
00178     const Array2D< double >& amatA,
00179     const Array2D< double >& vmatA,
00180     const Array  < double >& dvecA,
00181     unsigned c
00182 );
00183 
00185 unsigned rank
00186 (
00187     const Array2D< double >& amatA,
00188     const Array2D< double >& vmatA,
00189     const Array  < double >& dvecA
00190 );
00191 
00193 double detsymm
00194 (
00195     Array2D< double >& amatA,
00196     Array2D< double >& vmatA,
00197     Array  < double >& dvecA
00198 );
00199 
00201 double logdetsymm
00202 (
00203     Array2D< double >& amatA,
00204     Array2D< double >& vmatA,
00205     Array  < double >& dvecA
00206 );
00207 
00210 unsigned rankDecomp
00211 (
00212   Array2D< double >& amatA,
00213     Array2D< double >& hmatA,
00214     Array2D< double >& vmatA,
00215     Array  < double >& dvecA
00216 );
00217 
00224 void discrimAnalysis
00225 (
00226     Array2D< double >& betweenCovarA,
00227     Array2D< double >& withinCovarA,
00228     Array2D< double >& transMatA,
00229     Array  < double >& dvecA,
00230     unsigned& m
00231 );
00232 
00233 
00238 void linearRegress
00239 (
00240     Array2D< double >& cxxMatA,
00241     Array2D< double >& cxyMatA,
00242     Array  < double >& mxVecA,
00243     Array  < double >& myVecA,
00244     Array2D< double >& amatA,
00245     Array  < double >& bvecA,
00246     Array  < double >& dvecA
00247 );
00248 
00249 
00253 unsigned svdrank
00254 (
00255     const Array2D< double >& amatA,
00256     Array2D< double >& umatA,
00257     Array2D< double >& vmatA,
00258     Array  < double >& wvecA
00259 );
00260 
00261 
00268 void svd
00269 (
00270     const Array2D< double >& amatA,
00271     Array2D< double >& umatA,
00272     Array2D< double >& vmatA,
00273     Array  < double >& wvecA,
00274     unsigned maxIterations = 200,
00275     bool ignoreThreshold = true
00276 );
00277 
00278 
00279 
00281 void svdsort
00282 (
00283     Array2D< double >& umatA,
00284     Array2D< double >& vmatA,
00285     Array  < double >& wvecA
00286 );
00287 
00288 
00289 
00290 //===========================================================================
00340 template < class T >
00341 Array< T > transpose(const Array< T >& v)
00342 {
00343     SIZE_CHECK(v.ndim() == 2)
00344     Array< T > z;
00345     z.resize(v.dim(1), v.dim(0));
00346     for (unsigned i = v.dim(0); i--;)
00347         for (unsigned j = v.dim(1); j--;)
00348             z(j, i) = v(i, j);
00349     return z;
00350 }
00351 
00352 
00353 //===========================================================================
00405 template < class T >
00406 Array< T > diagonal(const Array< T >& v)
00407 {
00408     SIZE_CHECK(v.ndim() == 1)
00409     Array< T > z(v.nelem(), v.nelem());
00410     z = 0;
00411     for (unsigned i = v.nelem(); i--;)
00412         z(i, i) = v.elem(i);
00413     return z;
00414 }
00415 
00416 
00417 //===========================================================================
00457 template < class T >
00458 T trace(const Array< T >& v)
00459 {
00460     SIZE_CHECK(v.ndim() == 2 && v.dim(0) == v.dim(1))
00461 
00462     T t(v(0, 0));
00463     for (unsigned i = 1; i < v.dim(0); ++i)
00464         t += v(i, i);
00465     return t;
00466 }
00467 
00468 
00470 Array< double > mean(const Array< double >& x);
00471 
00472 
00474 Array< double > variance(const Array< double >& x);
00475 
00476 
00478 double angle(const Array< double >& x, const Array< double >& y);
00479 
00480 
00483 double corrcoef(const Array< double >& x, const Array< double >& y);
00484 
00485 
00488 Array< double > corrcoef(const Array< double >& x);
00489 
00490 
00492 void meanvar
00493 (
00494     const Array< double >& x,
00495     Array< double >&,
00496     Array< double >&
00497 );
00498 
00500 void meanvar
00501 (
00502     const Array< double >& pxA,
00503     const Array< double >& xA,
00504     double &mA,
00505     double &vA,
00506     const int startA = -1,
00507     const int endA = -1
00508 );
00509 
00510 
00512 double covariance(const Array< double >& x, const Array< double >& y);
00513 
00514 
00517 Array< double > covariance(const Array< double >& x);
00518 
00519 
00524 Array< double > invert(const Array< double >&);
00525 
00526 
00528 void matMat(Array2D<double> &A, const Array2D<double> &B, const Array2D<double> &C);
00529 
00531 void matColVec(Array<double> &A, const Array2D<double> &B, const Array<double> &C);
00532 
00534 void matColVec(ArrayReference<double> A, const Array2D<double> &B, const ArrayReference<double> C);
00535 
00537 void matColVec(Array<double> &A, const Array2D<double> &B, const Array<double> &C, unsigned int index);
00538 
00540 double vecMatVec(const Array<double> &A, const Array2D<double> &B, const Array<double> &C);
00541 
00543 double vecMatVec(const Array<double> &A, unsigned int i, const Array2D<double> &B, const Array<double> &C, unsigned int j);
00544 
00545 
00547 void invertSymm(Array2D<double> &I, const Array2D< double >& A);
00548 
00550 void invertSymmPositiveDefinite(Array2D<double> &I, const Array2D< double >& ArrSymm);
00551 
00553 unsigned g_inverse
00554 (
00555     const Array2D< double >& amatA,
00556     Array2D< double >& bmatA,
00557     unsigned maxIterations = 200,
00558     double tolerance = 1e-10,
00559     bool ignoreThreshold = true
00560 );
00561 
00563 void g_inverseCholesky(const Array2D< double >& A, Array2D< double >& outA, double thresholdFactor =  1e-9); 
00564 
00566 void g_inverseMoorePenrose(const Array2D< double >& A, Array2D< double >& outA);
00567 
00568 #endif  // LINALG_H
00569