computation/interfaces/Blas_2.cxx

00001 // Copyright (C) 2001-2009 Vivien Mallet
00002 //
00003 // This file is part of the linear-algebra library Seldon,
00004 // http://seldon.sourceforge.net/.
00005 //
00006 // Seldon is free software; you can redistribute it and/or modify it under the
00007 // terms of the GNU Lesser General Public License as published by the Free
00008 // Software Foundation; either version 2.1 of the License, or (at your option)
00009 // any later version.
00010 //
00011 // Seldon is distributed in the hope that it will be useful, but WITHOUT ANY
00012 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
00013 // FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for
00014 // more details.
00015 //
00016 // You should have received a copy of the GNU Lesser General Public License
00017 // along with Seldon. If not, see http://www.gnu.org/licenses/.
00018 
00019 
00020 #ifndef SELDON_FILE_BLAS_2_CXX
00021 
00022 /*
00023   Functions included in this file:
00024 
00025   xTRMV   (Mlt)
00026   xTPMV   (Mlt)
00027   xGEMV   (MltAdd)
00028   xHEMV   (MltAdd)
00029   xHPMV   (MltAdd)
00030   xSYMV   (MltAdd)
00031   xSPMV   (MltAdd)
00032   xGER    (Rank1Update)
00033   xGERU   (Rank1Update)
00034   xGERC   (Rank1Update)
00035   xSPR    (Rank1Update)
00036   xHPR    (Rank1Update)
00037   xSPR2   (Rank2Update)
00038   xHPR2   (Rank2Update)
00039   xTRSV   (Solve)
00040   xTPSV   (Solve)
00041 */
00042 
00043 extern "C"
00044 {
00045 #include "cblas.h"
00046 }
00047 
00048 namespace Seldon
00049 {
00050 
00051 
00053   // MLT //
00054 
00055 
00056   /*** ColUpTriang, NoTrans and NonUnit ***/
00057 
00058 
00059   template <class Prop0, class Allocator0,
00060             class Allocator1>
00061   void Mlt(const Matrix<float, Prop0, ColUpTriang, Allocator0>& A,
00062            Vector<float, VectFull, Allocator1>& X)
00063   {
00064 
00065 #ifdef SELDON_CHECK_DIMENSIONS
00066     CheckDim(A, X, "Mlt(M, X)");
00067 #endif
00068 
00069     cblas_strmv(CblasColMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
00070                 A.GetN(), A.GetData(), A.GetM(), X.GetData(), 1);
00071   }
00072 
00073 
00074   template <class Prop0, class Allocator0,
00075             class Allocator1>
00076   void Mlt(const Matrix<double, Prop0, ColUpTriang, Allocator0>& A,
00077            Vector<double, VectFull, Allocator1>& X)
00078   {
00079 
00080 #ifdef SELDON_CHECK_DIMENSIONS
00081     CheckDim(A, X, "Mlt(M, X)");
00082 #endif
00083 
00084     cblas_dtrmv(CblasColMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
00085                 A.GetN(), A.GetData(), A.GetM(), X.GetData(), 1);
00086   }
00087 
00088 
00089   template <class Prop0, class Allocator0,
00090             class Allocator1>
00091   void
00092   Mlt(const Matrix<complex<float>, Prop0, ColUpTriang, Allocator0>& A,
00093       Vector<complex<float>, VectFull, Allocator1>& X)
00094   {
00095 
00096 #ifdef SELDON_CHECK_DIMENSIONS
00097     CheckDim(A, X, "Mlt(M, X)");
00098 #endif
00099 
00100     cblas_ctrmv(CblasColMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
00101                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
00102                 A.GetM(), reinterpret_cast<void*>(X.GetData()), 1);
00103   }
00104 
00105 
00106   template <class Prop0, class Allocator0,
00107             class Allocator1>
00108   void
00109   Mlt(const Matrix<complex<double>, Prop0, ColUpTriang, Allocator0>& A,
00110       Vector<complex<double>, VectFull, Allocator1>& X)
00111   {
00112 
00113 #ifdef SELDON_CHECK_DIMENSIONS
00114     CheckDim(A, X, "Mlt(M, X)");
00115 #endif
00116 
00117     cblas_ztrmv(CblasColMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
00118                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
00119                 A.GetM(), reinterpret_cast<void*>(X.GetData()), 1);
00120   }
00121 
00122 
00123   /*** ColUpTriang ***/
00124 
00125 
00126   template <class Prop0, class Allocator0,
00127             class Allocator1>
00128   void Mlt(const SeldonTranspose& TransA,
00129            const SeldonDiag& DiagA,
00130            const Matrix<float, Prop0, ColUpTriang, Allocator0>& A,
00131            Vector<float, VectFull, Allocator1>& X)
00132   {
00133 
00134 #ifdef SELDON_CHECK_DIMENSIONS
00135     CheckDim(A, X, "Mlt(status, diag, M, X)");
00136 #endif
00137 
00138     cblas_strmv(CblasColMajor, CblasUpper, TransA, DiagA,
00139                 A.GetN(), A.GetData(), A.GetM(), X.GetData(), 1);
00140   }
00141 
00142 
00143   template <class Prop0, class Allocator0,
00144             class Allocator1>
00145   void Mlt(const SeldonTranspose& TransA,
00146            const SeldonDiag& DiagA,
00147            const Matrix<double, Prop0, ColUpTriang, Allocator0>& A,
00148            Vector<double, VectFull, Allocator1>& X)
00149   {
00150 
00151 #ifdef SELDON_CHECK_DIMENSIONS
00152     CheckDim(A, X, "Mlt(status, diag, M, X)");
00153 #endif
00154 
00155     cblas_dtrmv(CblasColMajor, CblasUpper, TransA, DiagA,
00156                 A.GetN(), A.GetData(), A.GetM(), X.GetData(), 1);
00157   }
00158 
00159 
00160   template <class Prop0, class Allocator0,
00161             class Allocator1>
00162   void
00163   Mlt(const SeldonTranspose& TransA,
00164       const SeldonDiag& DiagA,
00165       const Matrix<complex<float>, Prop0, ColUpTriang, Allocator0>& A,
00166       Vector<complex<float>, VectFull, Allocator1>& X)
00167   {
00168 
00169 #ifdef SELDON_CHECK_DIMENSIONS
00170     CheckDim(A, X, "Mlt(status, diag, M, X)");
00171 #endif
00172 
00173     cblas_ctrmv(CblasColMajor, CblasUpper, TransA, DiagA,
00174                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
00175                 A.GetM(), reinterpret_cast<void*>(X.GetData()), 1);
00176   }
00177 
00178 
00179   template <class Prop0, class Allocator0,
00180             class Allocator1>
00181   void
00182   Mlt(const SeldonTranspose& TransA,
00183       const SeldonDiag& DiagA,
00184       const Matrix<complex<double>, Prop0, ColUpTriang, Allocator0>& A,
00185       Vector<complex<double>, VectFull, Allocator1>& X)
00186   {
00187 
00188 #ifdef SELDON_CHECK_DIMENSIONS
00189     CheckDim(A, X, "Mlt(status, diag, M, X)");
00190 #endif
00191 
00192     cblas_ztrmv(CblasColMajor, CblasUpper, TransA, DiagA,
00193                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
00194                 A.GetM(), reinterpret_cast<void*>(X.GetData()), 1);
00195   }
00196 
00197 
00198   /*** ColLoTriang, NoTrans and NonUnit ***/
00199 
00200 
00201   template <class Prop0, class Allocator0,
00202             class Allocator1>
00203   void Mlt(const Matrix<float, Prop0, ColLoTriang, Allocator0>& A,
00204            Vector<float, VectFull, Allocator1>& X)
00205   {
00206 
00207 #ifdef SELDON_CHECK_DIMENSIONS
00208     CheckDim(A, X, "Mlt(M, X)");
00209 #endif
00210 
00211     cblas_strmv(CblasColMajor, CblasLower, CblasNoTrans, CblasNonUnit,
00212                 A.GetN(), A.GetData(), A.GetM(), X.GetData(), 1);
00213   }
00214 
00215 
00216   template <class Prop0, class Allocator0,
00217             class Allocator1>
00218   void Mlt(const Matrix<double, Prop0, ColLoTriang, Allocator0>& A,
00219            Vector<double, VectFull, Allocator1>& X)
00220   {
00221 
00222 #ifdef SELDON_CHECK_DIMENSIONS
00223     CheckDim(A, X, "Mlt(M, X)");
00224 #endif
00225 
00226     cblas_dtrmv(CblasColMajor, CblasLower, CblasNoTrans, CblasNonUnit,
00227                 A.GetN(), A.GetData(), A.GetM(), X.GetData(), 1);
00228   }
00229 
00230 
00231   template <class Prop0, class Allocator0,
00232             class Allocator1>
00233   void
00234   Mlt(const Matrix<complex<float>, Prop0, ColLoTriang, Allocator0>& A,
00235       Vector<complex<float>, VectFull, Allocator1>& X)
00236   {
00237 
00238 #ifdef SELDON_CHECK_DIMENSIONS
00239     CheckDim(A, X, "Mlt(M, X)");
00240 #endif
00241 
00242     cblas_ctrmv(CblasColMajor, CblasLower, CblasNoTrans, CblasNonUnit,
00243                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
00244                 A.GetM(), reinterpret_cast<void*>(X.GetData()), 1);
00245   }
00246 
00247 
00248   template <class Prop0, class Allocator0,
00249             class Allocator1>
00250   void
00251   Mlt(const Matrix<complex<double>, Prop0, ColLoTriang, Allocator0>& A,
00252       Vector<complex<double>, VectFull, Allocator1>& X)
00253   {
00254 
00255 #ifdef SELDON_CHECK_DIMENSIONS
00256     CheckDim(A, X, "Mlt(M, X)");
00257 #endif
00258 
00259     cblas_ztrmv(CblasColMajor, CblasLower, CblasNoTrans, CblasNonUnit,
00260                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
00261                 A.GetM(), reinterpret_cast<void*>(X.GetData()), 1);
00262   }
00263 
00264 
00265   /*** ColLoTriang ***/
00266 
00267 
00268   template <class Prop0, class Allocator0,
00269             class Allocator1>
00270   void Mlt(const SeldonTranspose& TransA,
00271            const SeldonDiag& DiagA,
00272            const Matrix<float, Prop0, ColLoTriang, Allocator0>& A,
00273            Vector<float, VectFull, Allocator1>& X)
00274   {
00275 
00276 #ifdef SELDON_CHECK_DIMENSIONS
00277     CheckDim(A, X, "Mlt(status, diag, M, X)");
00278 #endif
00279 
00280     cblas_strmv(CblasColMajor, CblasLower, TransA, DiagA,
00281                 A.GetN(), A.GetData(), A.GetM(), X.GetData(), 1);
00282   }
00283 
00284 
00285   template <class Prop0, class Allocator0,
00286             class Allocator1>
00287   void Mlt(const SeldonTranspose& TransA,
00288            const SeldonDiag& DiagA,
00289            const Matrix<double, Prop0, ColLoTriang, Allocator0>& A,
00290            Vector<double, VectFull, Allocator1>& X)
00291   {
00292 
00293 #ifdef SELDON_CHECK_DIMENSIONS
00294     CheckDim(A, X, "Mlt(status, diag, M, X)");
00295 #endif
00296 
00297     cblas_dtrmv(CblasColMajor, CblasLower, TransA, DiagA,
00298                 A.GetN(), A.GetData(), A.GetM(), X.GetData(), 1);
00299   }
00300 
00301 
00302   template <class Prop0, class Allocator0,
00303             class Allocator1>
00304   void
00305   Mlt(const SeldonTranspose& TransA,
00306       const SeldonDiag& DiagA,
00307       const Matrix<complex<float>, Prop0, ColLoTriang, Allocator0>& A,
00308       Vector<complex<float>, VectFull, Allocator1>& X)
00309   {
00310 
00311 #ifdef SELDON_CHECK_DIMENSIONS
00312     CheckDim(A, X, "Mlt(status, diag, M, X)");
00313 #endif
00314 
00315     cblas_ctrmv(CblasColMajor, CblasLower, TransA, DiagA,
00316                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
00317                 A.GetM(), reinterpret_cast<void*>(X.GetData()), 1);
00318   }
00319 
00320 
00321   template <class Prop0, class Allocator0,
00322             class Allocator1>
00323   void
00324   Mlt(const SeldonTranspose& TransA,
00325       const SeldonDiag& DiagA,
00326       const Matrix<complex<double>, Prop0, ColLoTriang, Allocator0>& A,
00327       Vector<complex<double>, VectFull, Allocator1>& X)
00328   {
00329 
00330 #ifdef SELDON_CHECK_DIMENSIONS
00331     CheckDim(A, X, "Mlt(status, diag, M, X)");
00332 #endif
00333 
00334     cblas_ztrmv(CblasColMajor, CblasLower, TransA, DiagA,
00335                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
00336                 A.GetM(), reinterpret_cast<void*>(X.GetData()), 1);
00337   }
00338 
00339 
00340   /*** RowUpTriang, NoTrans and NonUnit ***/
00341 
00342 
00343   template <class Prop0, class Allocator0,
00344             class Allocator1>
00345   void Mlt(const Matrix<float, Prop0, RowUpTriang, Allocator0>& A,
00346            Vector<float, VectFull, Allocator1>& X)
00347   {
00348 
00349 #ifdef SELDON_CHECK_DIMENSIONS
00350     CheckDim(A, X, "Mlt(M, X)");
00351 #endif
00352 
00353     cblas_strmv(CblasRowMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
00354                 A.GetN(), A.GetData(), A.GetM(), X.GetData(), 1);
00355   }
00356 
00357 
00358   template <class Prop0, class Allocator0,
00359             class Allocator1>
00360   void Mlt(const Matrix<double, Prop0, RowUpTriang, Allocator0>& A,
00361            Vector<double, VectFull, Allocator1>& X)
00362   {
00363 
00364 #ifdef SELDON_CHECK_DIMENSIONS
00365     CheckDim(A, X, "Mlt(M, X)");
00366 #endif
00367 
00368     cblas_dtrmv(CblasRowMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
00369                 A.GetN(), A.GetData(), A.GetM(), X.GetData(), 1);
00370   }
00371 
00372 
00373   template <class Prop0, class Allocator0,
00374             class Allocator1>
00375   void
00376   Mlt(const Matrix<complex<float>, Prop0, RowUpTriang, Allocator0>& A,
00377       Vector<complex<float>, VectFull, Allocator1>& X)
00378   {
00379 
00380 #ifdef SELDON_CHECK_DIMENSIONS
00381     CheckDim(A, X, "Mlt(M, X)");
00382 #endif
00383 
00384     cblas_ctrmv(CblasRowMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
00385                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
00386                 A.GetM(), reinterpret_cast<void*>(X.GetData()), 1);
00387   }
00388 
00389 
00390   template <class Prop0, class Allocator0,
00391             class Allocator1>
00392   void
00393   Mlt(const Matrix<complex<double>, Prop0, RowUpTriang, Allocator0>& A,
00394       Vector<complex<double>, VectFull, Allocator1>& X)
00395   {
00396 
00397 #ifdef SELDON_CHECK_DIMENSIONS
00398     CheckDim(A, X, "Mlt(M, X)");
00399 #endif
00400 
00401     cblas_ztrmv(CblasRowMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
00402                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
00403                 A.GetM(), reinterpret_cast<void*>(X.GetData()), 1);
00404   }
00405 
00406 
00407   /*** RowUpTriang ***/
00408 
00409 
00410   template <class Prop0, class Allocator0,
00411             class Allocator1>
00412   void Mlt(const SeldonTranspose& TransA,
00413            const SeldonDiag& DiagA,
00414            const Matrix<float, Prop0, RowUpTriang, Allocator0>& A,
00415            Vector<float, VectFull, Allocator1>& X)
00416   {
00417 
00418 #ifdef SELDON_CHECK_DIMENSIONS
00419     CheckDim(A, X, "Mlt(status, diag, M, X)");
00420 #endif
00421 
00422     cblas_strmv(CblasRowMajor, CblasUpper, TransA, DiagA,
00423                 A.GetN(), A.GetData(), A.GetM(), X.GetData(), 1);
00424   }
00425 
00426 
00427   template <class Prop0, class Allocator0,
00428             class Allocator1>
00429   void Mlt(const SeldonTranspose& TransA,
00430            const SeldonDiag& DiagA,
00431            const Matrix<double, Prop0, RowUpTriang, Allocator0>& A,
00432            Vector<double, VectFull, Allocator1>& X)
00433   {
00434 
00435 #ifdef SELDON_CHECK_DIMENSIONS
00436     CheckDim(A, X, "Mlt(status, diag, M, X)");
00437 #endif
00438 
00439     cblas_dtrmv(CblasRowMajor, CblasUpper, TransA, DiagA,
00440                 A.GetN(), A.GetData(), A.GetM(), X.GetData(), 1);
00441   }
00442 
00443 
00444   template <class Prop0, class Allocator0,
00445             class Allocator1>
00446   void
00447   Mlt(const SeldonTranspose& TransA,
00448       const SeldonDiag& DiagA,
00449       const Matrix<complex<float>, Prop0, RowUpTriang, Allocator0>& A,
00450       Vector<complex<float>, VectFull, Allocator1>& X)
00451   {
00452 
00453 #ifdef SELDON_CHECK_DIMENSIONS
00454     CheckDim(A, X, "Mlt(status, diag, M, X)");
00455 #endif
00456 
00457     cblas_ctrmv(CblasRowMajor, CblasUpper, TransA, DiagA,
00458                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
00459                 A.GetM(), reinterpret_cast<void*>(X.GetData()), 1);
00460   }
00461 
00462 
00463   template <class Prop0, class Allocator0,
00464             class Allocator1>
00465   void
00466   Mlt(const SeldonTranspose& TransA,
00467       const SeldonDiag& DiagA,
00468       const Matrix<complex<double>, Prop0, RowUpTriang, Allocator0>& A,
00469       Vector<complex<double>, VectFull, Allocator1>& X)
00470   {
00471 
00472 #ifdef SELDON_CHECK_DIMENSIONS
00473     CheckDim(A, X, "Mlt(status, diag, M, X)");
00474 #endif
00475 
00476     cblas_ztrmv(CblasRowMajor, CblasUpper, TransA, DiagA,
00477                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
00478                 A.GetM(), reinterpret_cast<void*>(X.GetData()), 1);
00479   }
00480 
00481 
00482   /*** RowLoTriang, NoTrans and NonUnit ***/
00483 
00484 
00485   template <class Prop0, class Allocator0,
00486             class Allocator1>
00487   void Mlt(const Matrix<float, Prop0, RowLoTriang, Allocator0>& A,
00488            Vector<float, VectFull, Allocator1>& X)
00489   {
00490 
00491 #ifdef SELDON_CHECK_DIMENSIONS
00492     CheckDim(A, X, "Mlt(M, X)");
00493 #endif
00494 
00495     cblas_strmv(CblasRowMajor, CblasLower, CblasNoTrans, CblasNonUnit,
00496                 A.GetN(), A.GetData(), A.GetM(), X.GetData(), 1);
00497   }
00498 
00499 
00500   template <class Prop0, class Allocator0,
00501             class Allocator1>
00502   void Mlt(const Matrix<double, Prop0, RowLoTriang, Allocator0>& A,
00503            Vector<double, VectFull, Allocator1>& X)
00504   {
00505 
00506 #ifdef SELDON_CHECK_DIMENSIONS
00507     CheckDim(A, X, "Mlt(M, X)");
00508 #endif
00509 
00510     cblas_dtrmv(CblasRowMajor, CblasLower, CblasNoTrans, CblasNonUnit,
00511                 A.GetN(), A.GetData(), A.GetM(), X.GetData(), 1);
00512   }
00513 
00514 
00515   template <class Prop0, class Allocator0,
00516             class Allocator1>
00517   void
00518   Mlt(const Matrix<complex<float>, Prop0, RowLoTriang, Allocator0>& A,
00519       Vector<complex<float>, VectFull, Allocator1>& X)
00520   {
00521 
00522 #ifdef SELDON_CHECK_DIMENSIONS
00523     CheckDim(A, X, "Mlt(M, X)");
00524 #endif
00525 
00526     cblas_ctrmv(CblasRowMajor, CblasLower, CblasNoTrans, CblasNonUnit,
00527                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
00528                 A.GetM(), reinterpret_cast<void*>(X.GetData()), 1);
00529   }
00530 
00531 
00532   template <class Prop0, class Allocator0,
00533             class Allocator1>
00534   void
00535   Mlt(const Matrix<complex<double>, Prop0, RowLoTriang, Allocator0>& A,
00536       Vector<complex<double>, VectFull, Allocator1>& X)
00537   {
00538 
00539 #ifdef SELDON_CHECK_DIMENSIONS
00540     CheckDim(A, X, "Mlt(M, X)");
00541 #endif
00542 
00543     cblas_ztrmv(CblasRowMajor, CblasLower, CblasNoTrans, CblasNonUnit,
00544                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
00545                 A.GetM(), reinterpret_cast<void*>(X.GetData()), 1);
00546   }
00547 
00548 
00549   /*** RowLoTriang ***/
00550 
00551 
00552   template <class Prop0, class Allocator0,
00553             class Allocator1>
00554   void Mlt(const SeldonTranspose& TransA,
00555            const SeldonDiag& DiagA,
00556            const Matrix<float, Prop0, RowLoTriang, Allocator0>& A,
00557            Vector<float, VectFull, Allocator1>& X)
00558   {
00559 
00560 #ifdef SELDON_CHECK_DIMENSIONS
00561     CheckDim(A, X, "Mlt(status, diag, M, X)");
00562 #endif
00563 
00564     cblas_strmv(CblasRowMajor, CblasLower, TransA, DiagA,
00565                 A.GetN(), A.GetData(), A.GetM(), X.GetData(), 1);
00566   }
00567 
00568 
00569   template <class Prop0, class Allocator0,
00570             class Allocator1>
00571   void Mlt(const SeldonTranspose& TransA,
00572            const SeldonDiag& DiagA,
00573            const Matrix<double, Prop0, RowLoTriang, Allocator0>& A,
00574            Vector<double, VectFull, Allocator1>& X)
00575   {
00576 
00577 #ifdef SELDON_CHECK_DIMENSIONS
00578     CheckDim(A, X, "Mlt(status, diag, M, X)");
00579 #endif
00580 
00581     cblas_dtrmv(CblasRowMajor, CblasLower, TransA, DiagA,
00582                 A.GetN(), A.GetData(), A.GetM(), X.GetData(), 1);
00583   }
00584 
00585 
00586   template <class Prop0, class Allocator0,
00587             class Allocator1>
00588   void
00589   Mlt(const SeldonTranspose& TransA,
00590       const SeldonDiag& DiagA,
00591       const Matrix<complex<float>, Prop0, RowLoTriang, Allocator0>& A,
00592       Vector<complex<float>, VectFull, Allocator1>& X)
00593   {
00594 
00595 #ifdef SELDON_CHECK_DIMENSIONS
00596     CheckDim(A, X, "Mlt(status, diag, M, X)");
00597 #endif
00598 
00599     cblas_ctrmv(CblasRowMajor, CblasLower, TransA, DiagA,
00600                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
00601                 A.GetM(), reinterpret_cast<void*>(X.GetData()), 1);
00602   }
00603 
00604 
00605   template <class Prop0, class Allocator0,
00606             class Allocator1>
00607   void
00608   Mlt(const SeldonTranspose& TransA,
00609       const SeldonDiag& DiagA,
00610       const Matrix<complex<double>, Prop0, RowLoTriang, Allocator0>& A,
00611       Vector<complex<double>, VectFull, Allocator1>& X)
00612   {
00613 
00614 #ifdef SELDON_CHECK_DIMENSIONS
00615     CheckDim(A, X, "Mlt(status, diag, M, X)");
00616 #endif
00617 
00618     cblas_ztrmv(CblasRowMajor, CblasLower, TransA, DiagA,
00619                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
00620                 A.GetM(), reinterpret_cast<void*>(X.GetData()), 1);
00621   }
00622 
00623 
00624   /*** ColUpTriangPacked, NoTrans and NonUnit ***/
00625 
00626 
00627   template <class Prop0, class Allocator0,
00628             class Allocator1>
00629   void Mlt(const Matrix<float, Prop0, ColUpTriangPacked, Allocator0>& A,
00630            Vector<float, VectFull, Allocator1>& X)
00631   {
00632 
00633 #ifdef SELDON_CHECK_DIMENSIONS
00634     CheckDim(A, X, "Mlt(M, X)");
00635 #endif
00636 
00637     cblas_stpmv(CblasColMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
00638                 A.GetN(), A.GetData(), X.GetData(), 1);
00639   }
00640 
00641 
00642   template <class Prop0, class Allocator0,
00643             class Allocator1>
00644   void Mlt(const Matrix<double, Prop0, ColUpTriangPacked, Allocator0>& A,
00645            Vector<double, VectFull, Allocator1>& X)
00646   {
00647 
00648 #ifdef SELDON_CHECK_DIMENSIONS
00649     CheckDim(A, X, "Mlt(M, X)");
00650 #endif
00651 
00652     cblas_dtpmv(CblasColMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
00653                 A.GetN(), A.GetData(), X.GetData(), 1);
00654   }
00655 
00656 
00657   template <class Prop0, class Allocator0,
00658             class Allocator1>
00659   void
00660   Mlt(const Matrix<complex<float>, Prop0, ColUpTriangPacked, Allocator0>& A,
00661       Vector<complex<float>, VectFull, Allocator1>& X)
00662   {
00663 
00664 #ifdef SELDON_CHECK_DIMENSIONS
00665     CheckDim(A, X, "Mlt(M, X)");
00666 #endif
00667 
00668     cblas_ctpmv(CblasColMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
00669                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
00670                 reinterpret_cast<void*>(X.GetData()), 1);
00671   }
00672 
00673 
00674   template <class Prop0, class Allocator0,
00675             class Allocator1>
00676   void
00677   Mlt(const Matrix<complex<double>, Prop0, ColUpTriangPacked, Allocator0>& A,
00678       Vector<complex<double>, VectFull, Allocator1>& X)
00679   {
00680 
00681 #ifdef SELDON_CHECK_DIMENSIONS
00682     CheckDim(A, X, "Mlt(M, X)");
00683 #endif
00684 
00685     cblas_ztpmv(CblasColMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
00686                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
00687                 reinterpret_cast<void*>(X.GetData()), 1);
00688   }
00689 
00690 
00691   /*** ColUpTriangPacked ***/
00692 
00693 
00694   template <class Prop0, class Allocator0,
00695             class Allocator1>
00696   void Mlt(const SeldonTranspose& TransA,
00697            const SeldonDiag& DiagA,
00698            const Matrix<float, Prop0, ColUpTriangPacked, Allocator0>& A,
00699            Vector<float, VectFull, Allocator1>& X)
00700   {
00701 
00702 #ifdef SELDON_CHECK_DIMENSIONS
00703     CheckDim(A, X, "Mlt(status, diag, M, X)");
00704 #endif
00705 
00706     cblas_stpmv(CblasColMajor, CblasUpper, TransA, DiagA,
00707                 A.GetN(), A.GetData(), X.GetData(), 1);
00708   }
00709 
00710 
00711   template <class Prop0, class Allocator0,
00712             class Allocator1>
00713   void Mlt(const SeldonTranspose& TransA,
00714            const SeldonDiag& DiagA,
00715            const Matrix<double, Prop0, ColUpTriangPacked, Allocator0>& A,
00716            Vector<double, VectFull, Allocator1>& X)
00717   {
00718 
00719 #ifdef SELDON_CHECK_DIMENSIONS
00720     CheckDim(A, X, "Mlt(status, diag, M, X)");
00721 #endif
00722 
00723     cblas_dtpmv(CblasColMajor, CblasUpper, TransA, DiagA,
00724                 A.GetN(), A.GetData(), X.GetData(), 1);
00725   }
00726 
00727 
00728   template <class Prop0, class Allocator0,
00729             class Allocator1>
00730   void
00731   Mlt(const SeldonTranspose& TransA,
00732       const SeldonDiag& DiagA,
00733       const Matrix<complex<float>, Prop0, ColUpTriangPacked, Allocator0>& A,
00734       Vector<complex<float>, VectFull, Allocator1>& X)
00735   {
00736 
00737 #ifdef SELDON_CHECK_DIMENSIONS
00738     CheckDim(A, X, "Mlt(status, diag, M, X)");
00739 #endif
00740 
00741     cblas_ctpmv(CblasColMajor, CblasUpper, TransA, DiagA,
00742                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
00743                 reinterpret_cast<void*>(X.GetData()), 1);
00744   }
00745 
00746 
00747   template <class Prop0, class Allocator0,
00748             class Allocator1>
00749   void
00750   Mlt(const SeldonTranspose& TransA,
00751       const SeldonDiag& DiagA,
00752       const Matrix<complex<double>, Prop0, ColUpTriangPacked, Allocator0>& A,
00753       Vector<complex<double>, VectFull, Allocator1>& X)
00754   {
00755 
00756 #ifdef SELDON_CHECK_DIMENSIONS
00757     CheckDim(A, X, "Mlt(status, diag, M, X)");
00758 #endif
00759 
00760     cblas_ztpmv(CblasColMajor, CblasUpper, TransA, DiagA,
00761                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
00762                 reinterpret_cast<void*>(X.GetData()), 1);
00763   }
00764 
00765 
00766   /*** ColLoTriangPacked, NoTrans and NonUnit ***/
00767 
00768 
00769   template <class Prop0, class Allocator0,
00770             class Allocator1>
00771   void Mlt(const Matrix<float, Prop0, ColLoTriangPacked, Allocator0>& A,
00772            Vector<float, VectFull, Allocator1>& X)
00773   {
00774 
00775 #ifdef SELDON_CHECK_DIMENSIONS
00776     CheckDim(A, X, "Mlt(M, X)");
00777 #endif
00778 
00779     cblas_stpmv(CblasColMajor, CblasLower, CblasNoTrans, CblasNonUnit,
00780                 A.GetN(), A.GetData(), X.GetData(), 1);
00781   }
00782 
00783 
00784   template <class Prop0, class Allocator0,
00785             class Allocator1>
00786   void Mlt(const Matrix<double, Prop0, ColLoTriangPacked, Allocator0>& A,
00787            Vector<double, VectFull, Allocator1>& X)
00788   {
00789 
00790 #ifdef SELDON_CHECK_DIMENSIONS
00791     CheckDim(A, X, "Mlt(M, X)");
00792 #endif
00793 
00794     cblas_dtpmv(CblasColMajor, CblasLower, CblasNoTrans, CblasNonUnit,
00795                 A.GetN(), A.GetData(), X.GetData(), 1);
00796   }
00797 
00798 
00799   template <class Prop0, class Allocator0,
00800             class Allocator1>
00801   void
00802   Mlt(const Matrix<complex<float>, Prop0, ColLoTriangPacked, Allocator0>& A,
00803       Vector<complex<float>, VectFull, Allocator1>& X)
00804   {
00805 
00806 #ifdef SELDON_CHECK_DIMENSIONS
00807     CheckDim(A, X, "Mlt(M, X)");
00808 #endif
00809 
00810     cblas_ctpmv(CblasColMajor, CblasLower, CblasNoTrans, CblasNonUnit,
00811                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
00812                 reinterpret_cast<void*>(X.GetData()), 1);
00813   }
00814 
00815 
00816   template <class Prop0, class Allocator0,
00817             class Allocator1>
00818   void
00819   Mlt(const Matrix<complex<double>, Prop0, ColLoTriangPacked, Allocator0>& A,
00820       Vector<complex<double>, VectFull, Allocator1>& X)
00821   {
00822 
00823 #ifdef SELDON_CHECK_DIMENSIONS
00824     CheckDim(A, X, "Mlt(M, X)");
00825 #endif
00826 
00827     cblas_ztpmv(CblasColMajor, CblasLower, CblasNoTrans, CblasNonUnit,
00828                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
00829                 reinterpret_cast<void*>(X.GetData()), 1);
00830   }
00831 
00832 
00833   /*** ColLoTriangPacked ***/
00834 
00835 
00836   template <class Prop0, class Allocator0,
00837             class Allocator1>
00838   void Mlt(const SeldonTranspose& TransA,
00839            const SeldonDiag& DiagA,
00840            const Matrix<float, Prop0, ColLoTriangPacked, Allocator0>& A,
00841            Vector<float, VectFull, Allocator1>& X)
00842   {
00843 
00844 #ifdef SELDON_CHECK_DIMENSIONS
00845     CheckDim(A, X, "Mlt(status, diag, M, X)");
00846 #endif
00847 
00848     cblas_stpmv(CblasColMajor, CblasLower, TransA, DiagA,
00849                 A.GetN(), A.GetData(), X.GetData(), 1);
00850   }
00851 
00852 
00853   template <class Prop0, class Allocator0,
00854             class Allocator1>
00855   void Mlt(const SeldonTranspose& TransA,
00856            const SeldonDiag& DiagA,
00857            const Matrix<double, Prop0, ColLoTriangPacked, Allocator0>& A,
00858            Vector<double, VectFull, Allocator1>& X)
00859   {
00860 
00861 #ifdef SELDON_CHECK_DIMENSIONS
00862     CheckDim(A, X, "Mlt(status, diag, M, X)");
00863 #endif
00864 
00865     cblas_dtpmv(CblasColMajor, CblasLower, TransA, DiagA,
00866                 A.GetN(), A.GetData(), X.GetData(), 1);
00867   }
00868 
00869 
00870   template <class Prop0, class Allocator0,
00871             class Allocator1>
00872   void
00873   Mlt(const SeldonTranspose& TransA,
00874       const SeldonDiag& DiagA,
00875       const Matrix<complex<float>, Prop0, ColLoTriangPacked, Allocator0>& A,
00876       Vector<complex<float>, VectFull, Allocator1>& X)
00877   {
00878 
00879 #ifdef SELDON_CHECK_DIMENSIONS
00880     CheckDim(A, X, "Mlt(status, diag, M, X)");
00881 #endif
00882 
00883     cblas_ctpmv(CblasColMajor, CblasLower, TransA, DiagA,
00884                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
00885                 reinterpret_cast<void*>(X.GetData()), 1);
00886   }
00887 
00888 
00889   template <class Prop0, class Allocator0,
00890             class Allocator1>
00891   void
00892   Mlt(const SeldonTranspose& TransA,
00893       const SeldonDiag& DiagA,
00894       const Matrix<complex<double>, Prop0, ColLoTriangPacked, Allocator0>& A,
00895       Vector<complex<double>, VectFull, Allocator1>& X)
00896   {
00897 
00898 #ifdef SELDON_CHECK_DIMENSIONS
00899     CheckDim(A, X, "Mlt(status, diag, M, X)");
00900 #endif
00901 
00902     cblas_ztpmv(CblasColMajor, CblasLower, TransA, DiagA,
00903                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
00904                 reinterpret_cast<void*>(X.GetData()), 1);
00905   }
00906 
00907 
00908   /*** RowUpTriangPacked, NoTrans and NonUnit ***/
00909 
00910 
00911   template <class Prop0, class Allocator0,
00912             class Allocator1>
00913   void Mlt(const Matrix<float, Prop0, RowUpTriangPacked, Allocator0>& A,
00914            Vector<float, VectFull, Allocator1>& X)
00915   {
00916 
00917 #ifdef SELDON_CHECK_DIMENSIONS
00918     CheckDim(A, X, "Mlt(M, X)");
00919 #endif
00920 
00921     cblas_stpmv(CblasRowMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
00922                 A.GetN(), A.GetData(), X.GetData(), 1);
00923   }
00924 
00925 
00926   template <class Prop0, class Allocator0,
00927             class Allocator1>
00928   void Mlt(const Matrix<double, Prop0, RowUpTriangPacked, Allocator0>& A,
00929            Vector<double, VectFull, Allocator1>& X)
00930   {
00931 
00932 #ifdef SELDON_CHECK_DIMENSIONS
00933     CheckDim(A, X, "Mlt(M, X)");
00934 #endif
00935 
00936     cblas_dtpmv(CblasRowMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
00937                 A.GetN(), A.GetData(), X.GetData(), 1);
00938   }
00939 
00940 
00941   template <class Prop0, class Allocator0,
00942             class Allocator1>
00943   void
00944   Mlt(const Matrix<complex<float>, Prop0, RowUpTriangPacked, Allocator0>& A,
00945       Vector<complex<float>, VectFull, Allocator1>& X)
00946   {
00947 
00948 #ifdef SELDON_CHECK_DIMENSIONS
00949     CheckDim(A, X, "Mlt(M, X)");
00950 #endif
00951 
00952     cblas_ctpmv(CblasRowMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
00953                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
00954                 reinterpret_cast<void*>(X.GetData()), 1);
00955   }
00956 
00957 
00958   template <class Prop0, class Allocator0,
00959             class Allocator1>
00960   void
00961   Mlt(const Matrix<complex<double>, Prop0, RowUpTriangPacked, Allocator0>& A,
00962       Vector<complex<double>, VectFull, Allocator1>& X)
00963   {
00964 
00965 #ifdef SELDON_CHECK_DIMENSIONS
00966     CheckDim(A, X, "Mlt(M, X)");
00967 #endif
00968 
00969     cblas_ztpmv(CblasRowMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
00970                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
00971                 reinterpret_cast<void*>(X.GetData()), 1);
00972   }
00973 
00974 
00975   /*** RowUpTriangPacked ***/
00976 
00977 
00978   template <class Prop0, class Allocator0,
00979             class Allocator1>
00980   void Mlt(const SeldonTranspose& TransA,
00981            const SeldonDiag& DiagA,
00982            const Matrix<float, Prop0, RowUpTriangPacked, Allocator0>& A,
00983            Vector<float, VectFull, Allocator1>& X)
00984   {
00985 
00986 #ifdef SELDON_CHECK_DIMENSIONS
00987     CheckDim(A, X, "Mlt(status, diag, M, X)");
00988 #endif
00989 
00990     cblas_stpmv(CblasRowMajor, CblasUpper, TransA, DiagA,
00991                 A.GetN(), A.GetData(), X.GetData(), 1);
00992   }
00993 
00994 
00995   template <class Prop0, class Allocator0,
00996             class Allocator1>
00997   void Mlt(const SeldonTranspose& TransA,
00998            const SeldonDiag& DiagA,
00999            const Matrix<double, Prop0, RowUpTriangPacked, Allocator0>& A,
01000            Vector<double, VectFull, Allocator1>& X)
01001   {
01002 
01003 #ifdef SELDON_CHECK_DIMENSIONS
01004     CheckDim(A, X, "Mlt(status, diag, M, X)");
01005 #endif
01006 
01007     cblas_dtpmv(CblasRowMajor, CblasUpper, TransA, DiagA,
01008                 A.GetN(), A.GetData(), X.GetData(), 1);
01009   }
01010 
01011 
01012   template <class Prop0, class Allocator0,
01013             class Allocator1>
01014   void
01015   Mlt(const SeldonTranspose& TransA,
01016       const SeldonDiag& DiagA,
01017       const Matrix<complex<float>, Prop0, RowUpTriangPacked, Allocator0>& A,
01018       Vector<complex<float>, VectFull, Allocator1>& X)
01019   {
01020 
01021 #ifdef SELDON_CHECK_DIMENSIONS
01022     CheckDim(A, X, "Mlt(status, diag, M, X)");
01023 #endif
01024 
01025     cblas_ctpmv(CblasRowMajor, CblasUpper, TransA, DiagA,
01026                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
01027                 reinterpret_cast<void*>(X.GetData()), 1);
01028   }
01029 
01030 
01031   template <class Prop0, class Allocator0,
01032             class Allocator1>
01033   void
01034   Mlt(const SeldonTranspose& TransA,
01035       const SeldonDiag& DiagA,
01036       const Matrix<complex<double>, Prop0, RowUpTriangPacked, Allocator0>& A,
01037       Vector<complex<double>, VectFull, Allocator1>& X)
01038   {
01039 
01040 #ifdef SELDON_CHECK_DIMENSIONS
01041     CheckDim(A, X, "Mlt(status, diag, M, X)");
01042 #endif
01043 
01044     cblas_ztpmv(CblasRowMajor, CblasUpper, TransA, DiagA,
01045                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
01046                 reinterpret_cast<void*>(X.GetData()), 1);
01047   }
01048 
01049 
01050   /*** RowLoTriangPacked, NoTrans and NonUnit ***/
01051 
01052 
01053   template <class Prop0, class Allocator0,
01054             class Allocator1>
01055   void Mlt(const Matrix<float, Prop0, RowLoTriangPacked, Allocator0>& A,
01056            Vector<float, VectFull, Allocator1>& X)
01057   {
01058 
01059 #ifdef SELDON_CHECK_DIMENSIONS
01060     CheckDim(A, X, "Mlt(M, X)");
01061 #endif
01062 
01063     cblas_stpmv(CblasRowMajor, CblasLower, CblasNoTrans, CblasNonUnit,
01064                 A.GetN(), A.GetData(), X.GetData(), 1);
01065   }
01066 
01067 
01068   template <class Prop0, class Allocator0,
01069             class Allocator1>
01070   void Mlt(const Matrix<double, Prop0, RowLoTriangPacked, Allocator0>& A,
01071            Vector<double, VectFull, Allocator1>& X)
01072   {
01073 
01074 #ifdef SELDON_CHECK_DIMENSIONS
01075     CheckDim(A, X, "Mlt(M, X)");
01076 #endif
01077 
01078     cblas_dtpmv(CblasRowMajor, CblasLower, CblasNoTrans, CblasNonUnit,
01079                 A.GetN(), A.GetData(), X.GetData(), 1);
01080   }
01081 
01082 
01083   template <class Prop0, class Allocator0,
01084             class Allocator1>
01085   void
01086   Mlt(const Matrix<complex<float>, Prop0, RowLoTriangPacked, Allocator0>& A,
01087       Vector<complex<float>, VectFull, Allocator1>& X)
01088   {
01089 
01090 #ifdef SELDON_CHECK_DIMENSIONS
01091     CheckDim(A, X, "Mlt(M, X)");
01092 #endif
01093 
01094     cblas_ctpmv(CblasRowMajor, CblasLower, CblasNoTrans, CblasNonUnit,
01095                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
01096                 reinterpret_cast<void*>(X.GetData()), 1);
01097   }
01098 
01099 
01100   template <class Prop0, class Allocator0,
01101             class Allocator1>
01102   void
01103   Mlt(const Matrix<complex<double>, Prop0, RowLoTriangPacked, Allocator0>& A,
01104       Vector<complex<double>, VectFull, Allocator1>& X)
01105   {
01106 
01107 #ifdef SELDON_CHECK_DIMENSIONS
01108     CheckDim(A, X, "Mlt(M, X)");
01109 #endif
01110 
01111     cblas_ztpmv(CblasRowMajor, CblasLower, CblasNoTrans, CblasNonUnit,
01112                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
01113                 reinterpret_cast<void*>(X.GetData()), 1);
01114   }
01115 
01116 
01117   /*** RowLoTriangPacked ***/
01118 
01119 
01120   template <class Prop0, class Allocator0,
01121             class Allocator1>
01122   void Mlt(const SeldonTranspose& TransA,
01123            const SeldonDiag& DiagA,
01124            const Matrix<float, Prop0, RowLoTriangPacked, Allocator0>& A,
01125            Vector<float, VectFull, Allocator1>& X)
01126   {
01127 
01128 #ifdef SELDON_CHECK_DIMENSIONS
01129     CheckDim(A, X, "Mlt(status, diag, M, X)");
01130 #endif
01131 
01132     cblas_stpmv(CblasRowMajor, CblasLower, TransA, DiagA,
01133                 A.GetN(), A.GetData(), X.GetData(), 1);
01134   }
01135 
01136 
01137   template <class Prop0, class Allocator0,
01138             class Allocator1>
01139   void Mlt(const SeldonTranspose& TransA,
01140            const SeldonDiag& DiagA,
01141            const Matrix<double, Prop0, RowLoTriangPacked, Allocator0>& A,
01142            Vector<double, VectFull, Allocator1>& X)
01143   {
01144 
01145 #ifdef SELDON_CHECK_DIMENSIONS
01146     CheckDim(A, X, "Mlt(status, diag, M, X)");
01147 #endif
01148 
01149     cblas_dtpmv(CblasRowMajor, CblasLower, TransA, DiagA,
01150                 A.GetN(), A.GetData(), X.GetData(), 1);
01151   }
01152 
01153 
01154   template <class Prop0, class Allocator0,
01155             class Allocator1>
01156   void
01157   Mlt(const SeldonTranspose& TransA,
01158       const SeldonDiag& DiagA,
01159       const Matrix<complex<float>, Prop0, RowLoTriangPacked, Allocator0>& A,
01160       Vector<complex<float>, VectFull, Allocator1>& X)
01161   {
01162 
01163 #ifdef SELDON_CHECK_DIMENSIONS
01164     CheckDim(A, X, "Mlt(status, diag, M, X)");
01165 #endif
01166 
01167     cblas_ctpmv(CblasRowMajor, CblasLower, TransA, DiagA,
01168                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
01169                 reinterpret_cast<void*>(X.GetData()), 1);
01170   }
01171 
01172 
01173   template <class Prop0, class Allocator0,
01174             class Allocator1>
01175   void
01176   Mlt(const SeldonTranspose& TransA,
01177       const SeldonDiag& DiagA,
01178       const Matrix<complex<double>, Prop0, RowLoTriangPacked, Allocator0>& A,
01179       Vector<complex<double>, VectFull, Allocator1>& X)
01180   {
01181 
01182 #ifdef SELDON_CHECK_DIMENSIONS
01183     CheckDim(A, X, "Mlt(status, diag, M, X)");
01184 #endif
01185 
01186     cblas_ztpmv(CblasRowMajor, CblasLower, TransA, DiagA,
01187                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
01188                 reinterpret_cast<void*>(X.GetData()), 1);
01189   }
01190 
01191 
01192   // MLT //
01194 
01195 
01196 
01198   // MLTADD //
01199 
01200 
01201   // General //
01202 
01203   /*** ColMajor and NoTrans ***/
01204 
01205 
01206   template <class Prop0, class Allocator0,
01207             class Allocator1, class Allocator2>
01208   void MltAdd(const float alpha,
01209               const Matrix<float, Prop0, ColMajor, Allocator0>& A,
01210               const Vector<float, VectFull, Allocator1>& X,
01211               const float beta,
01212               Vector<float, VectFull, Allocator2>& Y)
01213   {
01214 
01215 #ifdef SELDON_CHECK_DIMENSIONS
01216     CheckDim(A, X, Y, "MltAdd(alpha, M, X, beta, Y)");
01217 #endif
01218 
01219     cblas_sgemv(CblasColMajor, CblasNoTrans,
01220                 A.GetM(), A.GetN(), alpha, A.GetData(), A.GetLD(),
01221                 X.GetData(), 1, beta, Y.GetData(), 1);
01222   }
01223 
01224 
01225   template <class Prop0, class Allocator0,
01226             class Allocator1, class Allocator2>
01227   void MltAdd(const double alpha,
01228               const Matrix<double, Prop0, ColMajor, Allocator0>& A,
01229               const Vector<double, VectFull, Allocator1>& X,
01230               const double beta,
01231               Vector<double, VectFull, Allocator2>& Y)
01232   {
01233 
01234 #ifdef SELDON_CHECK_DIMENSIONS
01235     CheckDim(A, X, Y, "MltAdd(alpha, M, X, beta, Y)");
01236 #endif
01237 
01238     cblas_dgemv(CblasColMajor, CblasNoTrans,
01239                 A.GetM(), A.GetN(), alpha, A.GetData(), A.GetLD(),
01240                 X.GetData(), 1, beta, Y.GetData(), 1);
01241   }
01242 
01243 
01244   template <class Prop0, class Allocator0,
01245             class Allocator1, class Allocator2>
01246   void MltAdd(const complex<float> alpha,
01247               const Matrix<complex<float>, Prop0, ColMajor, Allocator0>& A,
01248               const Vector<complex<float>, VectFull, Allocator1>& X,
01249               const complex<float> beta,
01250               Vector<complex<float>, VectFull, Allocator2>& Y)
01251   {
01252 
01253 #ifdef SELDON_CHECK_DIMENSIONS
01254     CheckDim(A, X, Y, "MltAdd(alpha, M, X, beta, Y)");
01255 #endif
01256 
01257     cblas_cgemv(CblasColMajor, CblasNoTrans,
01258                 A.GetM(), A.GetN(), reinterpret_cast<const void*>(&alpha),
01259                 reinterpret_cast<const void*>(A.GetData()), A.GetLD(),
01260                 reinterpret_cast<const void*>(X.GetData()), 1,
01261                 reinterpret_cast<const void*>(&beta),
01262                 reinterpret_cast<void*>(Y.GetData()), 1);
01263   }
01264 
01265 
01266   template <class Prop0, class Allocator0,
01267             class Allocator1, class Allocator2>
01268   void MltAdd(const complex<double> alpha,
01269               const Matrix<complex<double>, Prop0, ColMajor, Allocator0>& A,
01270               const Vector<complex<double>, VectFull, Allocator1>& X,
01271               const complex<double> beta,
01272               Vector<complex<double>, VectFull, Allocator2>& Y)
01273   {
01274 
01275 #ifdef SELDON_CHECK_DIMENSIONS
01276     CheckDim(A, X, Y, "MltAdd(alpha, M, X, beta, Y)");
01277 #endif
01278 
01279     cblas_zgemv(CblasColMajor, CblasNoTrans,
01280                 A.GetM(), A.GetN(), reinterpret_cast<const void*>(&alpha),
01281                 reinterpret_cast<const void*>(A.GetData()), A.GetLD(),
01282                 reinterpret_cast<const void*>(X.GetData()), 1,
01283                 reinterpret_cast<const void*>(&beta),
01284                 reinterpret_cast<void*>(Y.GetData()), 1);
01285   }
01286 
01287 
01288   /*** ColMajor and TransA ***/
01289 
01290 
01291   template <class Prop0, class Allocator0,
01292             class Allocator1, class Allocator2>
01293   void MltAdd(const float alpha,
01294               const SeldonTranspose& TransA,
01295               const Matrix<float, Prop0, ColMajor, Allocator0>& A,
01296               const Vector<float, VectFull, Allocator1>& X,
01297               const float beta,
01298               Vector<float, VectFull, Allocator2>& Y)
01299   {
01300 
01301 #ifdef SELDON_CHECK_DIMENSIONS
01302     CheckDim(TransA, A, X, Y, "MltAdd(alpha, status, M, X, beta, Y)");
01303 #endif
01304 
01305     cblas_sgemv(CblasColMajor, TransA,
01306                 A.GetM(), A.GetN(), alpha, A.GetData(), A.GetLD(),
01307                 X.GetData(), 1, beta, Y.GetData(), 1);
01308   }
01309 
01310 
01311   template <class Prop0, class Allocator0,
01312             class Allocator1, class Allocator2>
01313   void MltAdd(const double alpha,
01314               const SeldonTranspose& TransA,
01315               const Matrix<double, Prop0, ColMajor, Allocator0>& A,
01316               const Vector<double, VectFull, Allocator1>& X,
01317               const double beta,
01318               Vector<double, VectFull, Allocator2>& Y)
01319   {
01320 
01321 #ifdef SELDON_CHECK_DIMENSIONS
01322     CheckDim(TransA, A, X, Y, "MltAdd(alpha, status, M, X, beta, Y)");
01323 #endif
01324 
01325     cblas_dgemv(CblasColMajor, TransA,
01326                 A.GetM(), A.GetN(), alpha, A.GetData(), A.GetLD(),
01327                 X.GetData(), 1, beta, Y.GetData(), 1);
01328   }
01329 
01330 
01331   template <class Prop0, class Allocator0,
01332             class Allocator1, class Allocator2>
01333   void MltAdd(const complex<float> alpha,
01334               const SeldonTranspose& TransA,
01335               const Matrix<complex<float>, Prop0, ColMajor, Allocator0>& A,
01336               const Vector<complex<float>, VectFull, Allocator1>& X,
01337               const complex<float> beta,
01338               Vector<complex<float>, VectFull, Allocator2>& Y)
01339   {
01340 
01341 #ifdef SELDON_CHECK_DIMENSIONS
01342     CheckDim(TransA, A, X, Y, "MltAdd(alpha, status, M, X, beta, Y)");
01343 #endif
01344 
01345     cblas_cgemv(CblasColMajor, TransA,
01346                 A.GetM(), A.GetN(), reinterpret_cast<const void*>(&alpha),
01347                 reinterpret_cast<const void*>(A.GetData()), A.GetLD(),
01348                 reinterpret_cast<const void*>(X.GetData()), 1,
01349                 reinterpret_cast<const void*>(&beta),
01350                 reinterpret_cast<void*>(Y.GetData()), 1);
01351   }
01352 
01353 
01354   template <class Prop0, class Allocator0,
01355             class Allocator1, class Allocator2>
01356   void MltAdd(const complex<double> alpha,
01357               const SeldonTranspose& TransA,
01358               const Matrix<complex<double>, Prop0, ColMajor, Allocator0>& A,
01359               const Vector<complex<double>, VectFull, Allocator1>& X,
01360               const complex<double> beta,
01361               Vector<complex<double>, VectFull, Allocator2>& Y)
01362   {
01363 
01364 #ifdef SELDON_CHECK_DIMENSIONS
01365     CheckDim(TransA, A, X, Y, "MltAdd(alpha, status, M, X, beta, Y)");
01366 #endif
01367 
01368     cblas_zgemv(CblasColMajor, TransA,
01369                 A.GetM(), A.GetN(), reinterpret_cast<const void*>(&alpha),
01370                 reinterpret_cast<const void*>(A.GetData()), A.GetLD(),
01371                 reinterpret_cast<const void*>(X.GetData()), 1,
01372                 reinterpret_cast<const void*>(&beta),
01373                 reinterpret_cast<void*>(Y.GetData()), 1);
01374   }
01375 
01376 
01377   /*** RowMajor and NoTrans ***/
01378 
01379 
01380   template <class Prop0, class Allocator0,
01381             class Allocator1, class Allocator2>
01382   void MltAdd(const float alpha,
01383               const Matrix<float, Prop0, RowMajor, Allocator0>& A,
01384               const Vector<float, VectFull, Allocator1>& X,
01385               const float beta,
01386               Vector<float, VectFull, Allocator2>& Y)
01387   {
01388 
01389 #ifdef SELDON_CHECK_DIMENSIONS
01390     CheckDim(A, X, Y, "MltAdd(alpha, M, X, beta, Y)");
01391 #endif
01392 
01393     cblas_sgemv(CblasRowMajor, CblasNoTrans,
01394                 A.GetM(), A.GetN(), alpha, A.GetData(), A.GetLD(),
01395                 X.GetData(), 1, beta, Y.GetData(), 1);
01396   }
01397 
01398 
01399   template <class Prop0, class Allocator0,
01400             class Allocator1, class Allocator2>
01401   void MltAdd(const double alpha,
01402               const Matrix<double, Prop0, RowMajor, Allocator0>& A,
01403               const Vector<double, VectFull, Allocator1>& X,
01404               const double beta,
01405               Vector<double, VectFull, Allocator2>& Y)
01406   {
01407 
01408 #ifdef SELDON_CHECK_DIMENSIONS
01409     CheckDim(A, X, Y, "MltAdd(alpha, M, X, beta, Y)");
01410 #endif
01411 
01412     cblas_dgemv(CblasRowMajor, CblasNoTrans,
01413                 A.GetM(), A.GetN(), alpha, A.GetData(), A.GetLD(),
01414                 X.GetData(), 1, beta, Y.GetData(), 1);
01415   }
01416 
01417 
01418   template <class Prop0, class Allocator0,
01419             class Allocator1, class Allocator2>
01420   void MltAdd(const complex<float> alpha,
01421               const Matrix<complex<float>, Prop0, RowMajor, Allocator0>& A,
01422               const Vector<complex<float>, VectFull, Allocator1>& X,
01423               const complex<float> beta,
01424               Vector<complex<float>, VectFull, Allocator2>& Y)
01425   {
01426 
01427 #ifdef SELDON_CHECK_DIMENSIONS
01428     CheckDim(A, X, Y, "MltAdd(alpha, M, X, beta, Y)");
01429 #endif
01430 
01431     cblas_cgemv(CblasRowMajor, CblasNoTrans,
01432                 A.GetM(), A.GetN(), reinterpret_cast<const void*>(&alpha),
01433                 reinterpret_cast<const void*>(A.GetData()), A.GetLD(),
01434                 reinterpret_cast<const void*>(X.GetData()), 1,
01435                 reinterpret_cast<const void*>(&beta),
01436                 reinterpret_cast<void*>(Y.GetData()), 1);
01437   }
01438 
01439 
01440   template <class Prop0, class Allocator0,
01441             class Allocator1, class Allocator2>
01442   void MltAdd(const complex<double> alpha,
01443               const Matrix<complex<double>, Prop0, RowMajor, Allocator0>& A,
01444               const Vector<complex<double>, VectFull, Allocator1>& X,
01445               const complex<double> beta,
01446               Vector<complex<double>, VectFull, Allocator2>& Y)
01447   {
01448 
01449 #ifdef SELDON_CHECK_DIMENSIONS
01450     CheckDim(A, X, Y, "MltAdd(alpha, M, X, beta, Y)");
01451 #endif
01452 
01453     cblas_zgemv(CblasRowMajor, CblasNoTrans,
01454                 A.GetM(), A.GetN(), reinterpret_cast<const void*>(&alpha),
01455                 reinterpret_cast<const void*>(A.GetData()), A.GetLD(),
01456                 reinterpret_cast<const void*>(X.GetData()), 1,
01457                 reinterpret_cast<const void*>(&beta),
01458                 reinterpret_cast<void*>(Y.GetData()), 1);
01459   }
01460 
01461 
01462   /*** RowMajor and TransA ***/
01463 
01464 
01465   template <class Prop0, class Allocator0,
01466             class Allocator1, class Allocator2>
01467   void MltAdd(const float alpha,
01468               const SeldonTranspose& TransA,
01469               const Matrix<float, Prop0, RowMajor, Allocator0>& A,
01470               const Vector<float, VectFull, Allocator1>& X,
01471               const float beta,
01472               Vector<float, VectFull, Allocator2>& Y)
01473   {
01474 
01475 #ifdef SELDON_CHECK_DIMENSIONS
01476     CheckDim(TransA, A, X, Y, "MltAdd(alpha, status, M, X, beta, Y)");
01477 #endif
01478 
01479     cblas_sgemv(CblasRowMajor, TransA,
01480                 A.GetM(), A.GetN(), alpha, A.GetData(), A.GetLD(),
01481                 X.GetData(), 1, beta, Y.GetData(), 1);
01482   }
01483 
01484 
01485   template <class Prop0, class Allocator0,
01486             class Allocator1, class Allocator2>
01487   void MltAdd(const double alpha,
01488               const SeldonTranspose& TransA,
01489               const Matrix<double, Prop0, RowMajor, Allocator0>& A,
01490               const Vector<double, VectFull, Allocator1>& X,
01491               const double beta,
01492               Vector<double, VectFull, Allocator2>& Y)
01493   {
01494 
01495 #ifdef SELDON_CHECK_DIMENSIONS
01496     CheckDim(TransA, A, X, Y, "MltAdd(alpha, status, M, X, beta, Y)");
01497 #endif
01498 
01499     cblas_dgemv(CblasRowMajor, TransA,
01500                 A.GetM(), A.GetN(), alpha, A.GetData(), A.GetLD(),
01501                 X.GetData(), 1, beta, Y.GetData(), 1);
01502   }
01503 
01504 
01505   template <class Prop0, class Allocator0,
01506             class Allocator1, class Allocator2>
01507   void MltAdd(const complex<float> alpha,
01508               const SeldonTranspose& TransA,
01509               const Matrix<complex<float>, Prop0, RowMajor, Allocator0>& A,
01510               const Vector<complex<float>, VectFull, Allocator1>& X,
01511               const complex<float> beta,
01512               Vector<complex<float>, VectFull, Allocator2>& Y)
01513   {
01514 
01515 #ifdef SELDON_CHECK_DIMENSIONS
01516     CheckDim(TransA, A, X, Y, "MltAdd(alpha, status, M, X, beta, Y)");
01517 #endif
01518 
01519     cblas_cgemv(CblasRowMajor, TransA,
01520                 A.GetM(), A.GetN(), reinterpret_cast<const void*>(&alpha),
01521                 reinterpret_cast<const void*>(A.GetData()), A.GetLD(),
01522                 reinterpret_cast<const void*>(X.GetData()), 1,
01523                 reinterpret_cast<const void*>(&beta),
01524                 reinterpret_cast<void*>(Y.GetData()), 1);
01525   }
01526 
01527 
01528   template <class Prop0, class Allocator0,
01529             class Allocator1, class Allocator2>
01530   void MltAdd(const complex<double> alpha,
01531               const SeldonTranspose& TransA,
01532               const Matrix<complex<double>, Prop0, RowMajor, Allocator0>& A,
01533               const Vector<complex<double>, VectFull, Allocator1>& X,
01534               const complex<double> beta,
01535               Vector<complex<double>, VectFull, Allocator2>& Y)
01536   {
01537 
01538 #ifdef SELDON_CHECK_DIMENSIONS
01539     CheckDim(TransA, A, X, Y, "MltAdd(alpha, status, M, X, beta, Y)");
01540 #endif
01541 
01542     cblas_zgemv(CblasRowMajor, TransA,
01543                 A.GetM(), A.GetN(), reinterpret_cast<const void*>(&alpha),
01544                 reinterpret_cast<const void*>(A.GetData()), A.GetLD(),
01545                 reinterpret_cast<const void*>(X.GetData()), 1,
01546                 reinterpret_cast<const void*>(&beta),
01547                 reinterpret_cast<void*>(Y.GetData()), 1);
01548   }
01549 
01550 
01551   // Hermitian //
01552 
01553   /*** ColHerm and Upper ***/
01554 
01555 
01556   template <class Prop0, class Allocator0,
01557             class Allocator1, class Allocator2>
01558   void MltAdd(const complex<float> alpha,
01559               const Matrix<complex<float>, Prop0, ColHerm, Allocator0>& A,
01560               const Vector<complex<float>, VectFull, Allocator1>& X,
01561               const complex<float> beta,
01562               Vector<complex<float>, VectFull, Allocator2>& Y)
01563   {
01564 
01565 #ifdef SELDON_CHECK_DIMENSIONS
01566     CheckDim(A, X, Y, "MltAdd(alpha, M, X, beta, Y)");
01567 #endif
01568 
01569     cblas_chemv(CblasColMajor, CblasUpper,
01570                 A.GetM(), reinterpret_cast<const void*>(&alpha),
01571                 A.GetDataConstVoid(), A.GetM(),
01572                 X.GetDataConstVoid(), 1, reinterpret_cast<const void*>(&beta),
01573                 Y.GetDataVoid(), 1);
01574   }
01575 
01576 
01577   template <class Prop0, class Allocator0,
01578             class Allocator1, class Allocator2>
01579   void MltAdd(const complex<double> alpha,
01580               const Matrix<complex<double>, Prop0, ColHerm, Allocator0>& A,
01581               const Vector<complex<double>, VectFull, Allocator1>& X,
01582               const complex<double> beta,
01583               Vector<complex<double>, VectFull, Allocator2>& Y)
01584   {
01585 
01586 #ifdef SELDON_CHECK_DIMENSIONS
01587     CheckDim(A, X, Y, "MltAdd(alpha, M, X, beta, Y)");
01588 #endif
01589 
01590     cblas_zhemv(CblasColMajor, CblasUpper,
01591                 A.GetM(), reinterpret_cast<const void*>(&alpha),
01592                 A.GetDataConstVoid(), A.GetM(),
01593                 X.GetDataConstVoid(), 1, reinterpret_cast<const void*>(&beta),
01594                 Y.GetDataVoid(), 1);
01595   }
01596 
01597 
01598   /*** ColHerm and Uplo ***/
01599 
01600 
01601   template <class Prop0, class Allocator0,
01602             class Allocator1, class Allocator2>
01603   void MltAdd(const complex<float> alpha,
01604               const SeldonUplo& Uplo,
01605               const Matrix<complex<float>, Prop0, ColHerm, Allocator0>& A,
01606               const Vector<complex<float>, VectFull, Allocator1>& X,
01607               const complex<float> beta,
01608               Vector<complex<float>, VectFull, Allocator2>& Y)
01609   {
01610 
01611 #ifdef SELDON_CHECK_DIMENSIONS
01612     CheckDim(A, X, Y, "MltAdd(alpha, uplo, M, X, beta, Y)");
01613 #endif
01614 
01615     cblas_chemv(CblasColMajor, Uplo,
01616                 A.GetM(), reinterpret_cast<const void*>(&alpha),
01617                 A.GetDataConstVoid(), A.GetM(),
01618                 X.GetDataConstVoid(), 1, reinterpret_cast<const void*>(&beta),
01619                 Y.GetDataVoid(), 1);
01620   }
01621 
01622 
01623   template <class Prop0, class Allocator0,
01624             class Allocator1, class Allocator2>
01625   void MltAdd(const complex<double> alpha,
01626               const SeldonUplo& Uplo,
01627               const Matrix<complex<double>, Prop0, ColHerm, Allocator0>& A,
01628               const Vector<complex<double>, VectFull, Allocator1>& X,
01629               const complex<double> beta,
01630               Vector<complex<double>, VectFull, Allocator2>& Y)
01631   {
01632 
01633 #ifdef SELDON_CHECK_DIMENSIONS
01634     CheckDim(A, X, Y, "MltAdd(alpha, uplo, M, X, beta, Y)");
01635 #endif
01636 
01637     cblas_zhemv(CblasColMajor, Uplo,
01638                 A.GetM(), reinterpret_cast<const void*>(&alpha),
01639                 A.GetDataConstVoid(), A.GetM(),
01640                 X.GetDataConstVoid(), 1, reinterpret_cast<const void*>(&beta),
01641                 Y.GetDataVoid(), 1);
01642   }
01643 
01644 
01645   /*** RowHerm and Upper ***/
01646 
01647 
01648   template <class Prop0, class Allocator0,
01649             class Allocator1, class Allocator2>
01650   void MltAdd(const complex<float> alpha,
01651               const Matrix<complex<float>, Prop0, RowHerm, Allocator0>& A,
01652               const Vector<complex<float>, VectFull, Allocator1>& X,
01653               const complex<float> beta,
01654               Vector<complex<float>, VectFull, Allocator2>& Y)
01655   {
01656 
01657 #ifdef SELDON_CHECK_DIMENSIONS
01658     CheckDim(A, X, Y, "MltAdd(alpha, M, X, beta, Y)");
01659 #endif
01660 
01661     cblas_chemv(CblasRowMajor, CblasUpper,
01662                 A.GetM(), reinterpret_cast<const void*>(&alpha),
01663                 A.GetDataConstVoid(), A.GetM(),
01664                 X.GetDataConstVoid(), 1, reinterpret_cast<const void*>(&beta),
01665                 Y.GetDataVoid(), 1);
01666   }
01667 
01668 
01669   template <class Prop0, class Allocator0,
01670             class Allocator1, class Allocator2>
01671   void MltAdd(const complex<double> alpha,
01672               const Matrix<complex<double>, Prop0, RowHerm, Allocator0>& A,
01673               const Vector<complex<double>, VectFull, Allocator1>& X,
01674               const complex<double> beta,
01675               Vector<complex<double>, VectFull, Allocator2>& Y)
01676   {
01677 
01678 #ifdef SELDON_CHECK_DIMENSIONS
01679     CheckDim(A, X, Y, "MltAdd(alpha, M, X, beta, Y)");
01680 #endif
01681 
01682     cblas_zhemv(CblasRowMajor, CblasUpper,
01683                 A.GetM(), reinterpret_cast<const void*>(&alpha),
01684                 A.GetDataConstVoid(), A.GetM(),
01685                 X.GetDataConstVoid(), 1, reinterpret_cast<const void*>(&beta),
01686                 Y.GetDataVoid(), 1);
01687   }
01688 
01689 
01690   /*** RowHerm and Uplo ***/
01691 
01692 
01693   template <class Prop0, class Allocator0,
01694             class Allocator1, class Allocator2>
01695   void MltAdd(const complex<float> alpha,
01696               const SeldonUplo& Uplo,
01697               const Matrix<complex<float>, Prop0, RowHerm, Allocator0>& A,
01698               const Vector<complex<float>, VectFull, Allocator1>& X,
01699               const complex<float> beta,
01700               Vector<complex<float>, VectFull, Allocator2>& Y)
01701   {
01702 
01703 #ifdef SELDON_CHECK_DIMENSIONS
01704     CheckDim(A, X, Y, "MltAdd(alpha, uplo, M, X, beta, Y)");
01705 #endif
01706 
01707     cblas_chemv(CblasRowMajor, Uplo,
01708                 A.GetM(), reinterpret_cast<const void*>(&alpha),
01709                 A.GetDataConstVoid(), A.GetM(),
01710                 X.GetDataConstVoid(), 1, reinterpret_cast<const void*>(&beta),
01711                 Y.GetDataVoid(), 1);
01712   }
01713 
01714 
01715   template <class Prop0, class Allocator0,
01716             class Allocator1, class Allocator2>
01717   void MltAdd(const complex<double> alpha,
01718               const SeldonUplo& Uplo,
01719               const Matrix<complex<double>, Prop0, RowHerm, Allocator0>& A,
01720               const Vector<complex<double>, VectFull, Allocator1>& X,
01721               const complex<double> beta,
01722               Vector<complex<double>, VectFull, Allocator2>& Y)
01723   {
01724 
01725 #ifdef SELDON_CHECK_DIMENSIONS
01726     CheckDim(A, X, Y, "MltAdd(alpha, uplo, M, X, beta, Y)");
01727 #endif
01728 
01729     cblas_zhemv(CblasRowMajor, Uplo,
01730                 A.GetM(), reinterpret_cast<const void*>(&alpha),
01731                 A.GetDataConstVoid(), A.GetM(),
01732                 X.GetDataConstVoid(), 1, reinterpret_cast<const void*>(&beta),
01733                 Y.GetDataVoid(), 1);
01734   }
01735 
01736 
01737   // HermPacked //
01738 
01739   /*** ColHermPacked and Upper ***/
01740 
01741 
01742   template <class Prop0, class Allocator0,
01743             class Allocator1, class Allocator2>
01744   void MltAdd(const complex<float> alpha,
01745               const Matrix<complex<float>, Prop0,
01746               ColHermPacked, Allocator0>& A,
01747               const Vector<complex<float>, VectFull, Allocator1>& X,
01748               const complex<float> beta,
01749               Vector<complex<float>, VectFull, Allocator2>& Y)
01750   {
01751 
01752 #ifdef SELDON_CHECK_DIMENSIONS
01753     CheckDim(A, X, Y, "MltAdd(alpha, M, X, beta, Y)");
01754 #endif
01755 
01756     cblas_chpmv(CblasColMajor, CblasUpper,
01757                 A.GetM(), reinterpret_cast<const void*>(&alpha),
01758                 A.GetDataConstVoid(),
01759                 X.GetDataConstVoid(), 1, reinterpret_cast<const void*>(&beta),
01760                 Y.GetDataVoid(), 1);
01761   }
01762 
01763 
01764   template <class Prop0, class Allocator0,
01765             class Allocator1, class Allocator2>
01766   void MltAdd(const complex<double> alpha,
01767               const Matrix<complex<double>, Prop0,
01768               ColHermPacked, Allocator0>& A,
01769               const Vector<complex<double>, VectFull, Allocator1>& X,
01770               const complex<double> beta,
01771               Vector<complex<double>, VectFull, Allocator2>& Y)
01772   {
01773 
01774 #ifdef SELDON_CHECK_DIMENSIONS
01775     CheckDim(A, X, Y, "MltAdd(alpha, M, X, beta, Y)");
01776 #endif
01777 
01778     cblas_zhpmv(CblasColMajor, CblasUpper,
01779                 A.GetM(), reinterpret_cast<const void*>(&alpha),
01780                 A.GetDataConstVoid(),
01781                 X.GetDataConstVoid(), 1, reinterpret_cast<const void*>(&beta),
01782                 Y.GetDataVoid(), 1);
01783   }
01784 
01785 
01786   /*** ColHermPacked and Uplo ***/
01787 
01788 
01789   template <class Prop0, class Allocator0,
01790             class Allocator1, class Allocator2>
01791   void MltAdd(const complex<float> alpha,
01792               const SeldonUplo& Uplo,
01793               const Matrix<complex<float>, Prop0,
01794               ColHermPacked, Allocator0>& A,
01795               const Vector<complex<float>, VectFull, Allocator1>& X,
01796               const complex<float> beta,
01797               Vector<complex<float>, VectFull, Allocator2>& Y)
01798   {
01799 
01800 #ifdef SELDON_CHECK_DIMENSIONS
01801     CheckDim(A, X, Y, "MltAdd(alpha, uplo, M, X, beta, Y)");
01802 #endif
01803 
01804     cblas_chpmv(CblasColMajor, Uplo,
01805                 A.GetM(), reinterpret_cast<const void*>(&alpha),
01806                 A.GetDataConstVoid(),
01807                 X.GetDataConstVoid(), 1, reinterpret_cast<const void*>(&beta),
01808                 Y.GetDataVoid(), 1);
01809   }
01810 
01811 
01812   template <class Prop0, class Allocator0,
01813             class Allocator1, class Allocator2>
01814   void MltAdd(const complex<double> alpha,
01815               const SeldonUplo& Uplo,
01816               const Matrix<complex<double>, Prop0,
01817               ColHermPacked, Allocator0>& A,
01818               const Vector<complex<double>, VectFull, Allocator1>& X,
01819               const complex<double> beta,
01820               Vector<complex<double>, VectFull, Allocator2>& Y)
01821   {
01822 
01823 #ifdef SELDON_CHECK_DIMENSIONS
01824     CheckDim(A, X, Y, "MltAdd(alpha, uplo, M, X, beta, Y)");
01825 #endif
01826 
01827     cblas_zhpmv(CblasColMajor, Uplo,
01828                 A.GetM(), reinterpret_cast<const void*>(&alpha),
01829                 A.GetDataConstVoid(),
01830                 X.GetDataConstVoid(), 1, reinterpret_cast<const void*>(&beta),
01831                 Y.GetDataVoid(), 1);
01832   }
01833 
01834 
01835   /*** RowHermPacked and Upper ***/
01836 
01837 
01838   template <class Prop0, class Allocator0,
01839             class Allocator1, class Allocator2>
01840   void MltAdd(const complex<float> alpha,
01841               const Matrix<complex<float>, Prop0,
01842               RowHermPacked, Allocator0>& A,
01843               const Vector<complex<float>, VectFull, Allocator1>& X,
01844               const complex<float> beta,
01845               Vector<complex<float>, VectFull, Allocator2>& Y)
01846   {
01847 
01848 #ifdef SELDON_CHECK_DIMENSIONS
01849     CheckDim(A, X, Y, "MltAdd(alpha, M, X, beta, Y)");
01850 #endif
01851 
01852     cblas_chpmv(CblasRowMajor, CblasUpper,
01853                 A.GetM(), reinterpret_cast<const void*>(&alpha),
01854                 A.GetDataConstVoid(),
01855                 X.GetDataConstVoid(), 1, reinterpret_cast<const void*>(&beta),
01856                 Y.GetDataVoid(), 1);
01857   }
01858 
01859 
01860   template <class Prop0, class Allocator0,
01861             class Allocator1, class Allocator2>
01862   void MltAdd(const complex<double> alpha,
01863               const Matrix<complex<double>, Prop0,
01864               RowHermPacked, Allocator0>& A,
01865               const Vector<complex<double>, VectFull, Allocator1>& X,
01866               const complex<double> beta,
01867               Vector<complex<double>, VectFull, Allocator2>& Y)
01868   {
01869 
01870 #ifdef SELDON_CHECK_DIMENSIONS
01871     CheckDim(A, X, Y, "MltAdd(alpha, M, X, beta, Y)");
01872 #endif
01873 
01874     cblas_zhpmv(CblasRowMajor, CblasUpper,
01875                 A.GetM(), reinterpret_cast<const void*>(&alpha),
01876                 A.GetDataConstVoid(),
01877                 X.GetDataConstVoid(), 1, reinterpret_cast<const void*>(&beta),
01878                 Y.GetDataVoid(), 1);
01879   }
01880 
01881 
01882   /*** RowHermPacked and Uplo ***/
01883 
01884 
01885   template <class Prop0, class Allocator0,
01886             class Allocator1, class Allocator2>
01887   void MltAdd(const complex<float> alpha,
01888               const SeldonUplo& Uplo,
01889               const Matrix<complex<float>, Prop0,
01890               RowHermPacked, Allocator0>& A,
01891               const Vector<complex<float>, VectFull, Allocator1>& X,
01892               const complex<float> beta,
01893               Vector<complex<float>, VectFull, Allocator2>& Y)
01894   {
01895 
01896 #ifdef SELDON_CHECK_DIMENSIONS
01897     CheckDim(A, X, Y, "MltAdd(alpha, uplo, M, X, beta, Y)");
01898 #endif
01899 
01900     cblas_chpmv(CblasRowMajor, Uplo,
01901                 A.GetM(), reinterpret_cast<const void*>(&alpha),
01902                 A.GetDataConstVoid(),
01903                 X.GetDataConstVoid(), 1, reinterpret_cast<const void*>(&beta),
01904                 Y.GetDataVoid(), 1);
01905   }
01906 
01907 
01908   template <class Prop0, class Allocator0,
01909             class Allocator1, class Allocator2>
01910   void MltAdd(const complex<double> alpha,
01911               const SeldonUplo& Uplo,
01912               const Matrix<complex<double>, Prop0,
01913               RowHermPacked, Allocator0>& A,
01914               const Vector<complex<double>, VectFull, Allocator1>& X,
01915               const complex<double> beta,
01916               Vector<complex<double>, VectFull, Allocator2>& Y)
01917   {
01918 
01919 #ifdef SELDON_CHECK_DIMENSIONS
01920     CheckDim(A, X, Y, "MltAdd(alpha, uplo, M, X, beta, Y)");
01921 #endif
01922 
01923     cblas_zhpmv(CblasRowMajor, Uplo,
01924                 A.GetM(), reinterpret_cast<const void*>(&alpha),
01925                 A.GetDataConstVoid(),
01926                 X.GetDataConstVoid(), 1, reinterpret_cast<const void*>(&beta),
01927                 Y.GetDataVoid(), 1);
01928   }
01929 
01930 
01931   // Symmetric //
01932 
01933   /*** ColSym and Upper ***/
01934 
01935 
01936   template <class Prop0, class Allocator0,
01937             class Allocator1, class Allocator2>
01938   void MltAdd(const float alpha,
01939               const Matrix<float, Prop0, ColSym, Allocator0>& A,
01940               const Vector<float, VectFull, Allocator1>& X,
01941               const float beta,
01942               Vector<float, VectFull, Allocator2>& Y)
01943   {
01944 
01945 #ifdef SELDON_CHECK_DIMENSIONS
01946     CheckDim(A, X, Y, "MltAdd(alpha, M, X, beta, Y)");
01947 #endif
01948 
01949     cblas_ssymv(CblasColMajor, CblasUpper,
01950                 A.GetM(), alpha, A.GetData(), A.GetM(),
01951                 X.GetData(), 1, beta, Y.GetData(), 1);
01952   }
01953 
01954 
01955   template <class Prop0, class Allocator0,
01956             class Allocator1, class Allocator2>
01957   void MltAdd(const double alpha,
01958               const Matrix<double, Prop0, ColSym, Allocator0>& A,
01959               const Vector<double, VectFull, Allocator1>& X,
01960               const double beta,
01961               Vector<double, VectFull, Allocator2>& Y)
01962   {
01963 
01964 #ifdef SELDON_CHECK_DIMENSIONS
01965     CheckDim(A, X, Y, "MltAdd(alpha, M, X, beta, Y)");
01966 #endif
01967 
01968     cblas_dsymv(CblasColMajor, CblasUpper,
01969                 A.GetM(), alpha, A.GetData(), A.GetM(),
01970                 X.GetData(), 1, beta, Y.GetData(), 1);
01971   }
01972 
01973 
01974   /*** ColSym and Uplo ***/
01975 
01976 
01977   template <class Prop0, class Allocator0,
01978             class Allocator1, class Allocator2>
01979   void MltAdd(const float alpha,
01980               const SeldonUplo& Uplo,
01981               const Matrix<float, Prop0, ColSym, Allocator0>& A,
01982               const Vector<float, VectFull, Allocator1>& X,
01983               const float beta,
01984               Vector<float, VectFull, Allocator2>& Y)
01985   {
01986 
01987 #ifdef SELDON_CHECK_DIMENSIONS
01988     CheckDim(A, X, Y, "MltAdd(alpha, uplo, M, X, beta, Y)");
01989 #endif
01990 
01991     cblas_ssymv(CblasColMajor, Uplo,
01992                 A.GetM(), alpha, A.GetData(), A.GetM(),
01993                 X.GetData(), 1, beta, Y.GetData(), 1);
01994   }
01995 
01996 
01997   template <class Prop0, class Allocator0,
01998             class Allocator1, class Allocator2>
01999   void MltAdd(const double alpha,
02000               const SeldonUplo& Uplo,
02001               const Matrix<double, Prop0, ColSym, Allocator0>& A,
02002               const Vector<double, VectFull, Allocator1>& X,
02003               const double beta,
02004               Vector<double, VectFull, Allocator2>& Y)
02005   {
02006 
02007 #ifdef SELDON_CHECK_DIMENSIONS
02008     CheckDim(A, X, Y, "MltAdd(alpha, uplo, M, X, beta, Y)");
02009 #endif
02010 
02011     cblas_dsymv(CblasColMajor, Uplo,
02012                 A.GetM(), alpha, A.GetData(), A.GetM(),
02013                 X.GetData(), 1, beta, Y.GetData(), 1);
02014   }
02015 
02016 
02017   /*** RowSym and Upper ***/
02018 
02019 
02020   template <class Prop0, class Allocator0,
02021             class Allocator1, class Allocator2>
02022   void MltAdd(const float alpha,
02023               const Matrix<float, Prop0, RowSym, Allocator0>& A,
02024               const Vector<float, VectFull, Allocator1>& X,
02025               const float beta,
02026               Vector<float, VectFull, Allocator2>& Y)
02027   {
02028 
02029 #ifdef SELDON_CHECK_DIMENSIONS
02030     CheckDim(A, X, Y, "MltAdd(alpha, M, X, beta, Y)");
02031 #endif
02032 
02033     cblas_ssymv(CblasRowMajor, CblasUpper,
02034                 A.GetM(), alpha, A.GetData(), A.GetM(),
02035                 X.GetData(), 1, beta, Y.GetData(), 1);
02036   }
02037 
02038 
02039   template <class Prop0, class Allocator0,
02040             class Allocator1, class Allocator2>
02041   void MltAdd(const double alpha,
02042               const Matrix<double, Prop0, RowSym, Allocator0>& A,
02043               const Vector<double, VectFull, Allocator1>& X,
02044               const double beta,
02045               Vector<double, VectFull, Allocator2>& Y)
02046   {
02047 
02048 #ifdef SELDON_CHECK_DIMENSIONS
02049     CheckDim(A, X, Y, "MltAdd(alpha, M, X, beta, Y)");
02050 #endif
02051 
02052     cblas_dsymv(CblasRowMajor, CblasUpper,
02053                 A.GetM(), alpha, A.GetData(), A.GetM(),
02054                 X.GetData(), 1, beta, Y.GetData(), 1);
02055   }
02056 
02057 
02058   /*** RowSym and Uplo ***/
02059 
02060 
02061   template <class Prop0, class Allocator0,
02062             class Allocator1, class Allocator2>
02063   void MltAdd(const float alpha,
02064               const SeldonUplo& Uplo,
02065               const Matrix<float, Prop0, RowSym, Allocator0>& A,
02066               const Vector<float, VectFull, Allocator1>& X,
02067               const float beta,
02068               Vector<float, VectFull, Allocator2>& Y)
02069   {
02070 
02071 #ifdef SELDON_CHECK_DIMENSIONS
02072     CheckDim(A, X, Y, "MltAdd(alpha, uplo, M, X, beta, Y)");
02073 #endif
02074 
02075     cblas_ssymv(CblasRowMajor, Uplo,
02076                 A.GetM(), alpha, A.GetData(), A.GetM(),
02077                 X.GetData(), 1, beta, Y.GetData(), 1);
02078   }
02079 
02080 
02081   template <class Prop0, class Allocator0,
02082             class Allocator1, class Allocator2>
02083   void MltAdd(const double alpha,
02084               const SeldonUplo& Uplo,
02085               const Matrix<double, Prop0, RowSym, Allocator0>& A,
02086               const Vector<double, VectFull, Allocator1>& X,
02087               const double beta,
02088               Vector<double, VectFull, Allocator2>& Y)
02089   {
02090 
02091 #ifdef SELDON_CHECK_DIMENSIONS
02092     CheckDim(A, X, Y, "MltAdd(alpha, uplo, M, X, beta, Y)");
02093 #endif
02094 
02095     cblas_dsymv(CblasRowMajor, Uplo,
02096                 A.GetM(), alpha, A.GetData(), A.GetM(),
02097                 X.GetData(), 1, beta, Y.GetData(), 1);
02098   }
02099 
02100 
02101   // SymPacked //
02102 
02103   /*** ColSymPacked and Upper ***/
02104 
02105 
02106   template <class Prop0, class Allocator0,
02107             class Allocator1, class Allocator2>
02108   void MltAdd(const float alpha,
02109               const Matrix<float, Prop0, ColSymPacked, Allocator0>& A,
02110               const Vector<float, VectFull, Allocator1>& X,
02111               const float beta,
02112               Vector<float, VectFull, Allocator2>& Y)
02113   {
02114 
02115 #ifdef SELDON_CHECK_DIMENSIONS
02116     CheckDim(A, X, Y, "MltAdd(alpha, M, X, beta, Y)");
02117 #endif
02118 
02119     cblas_sspmv(CblasColMajor, CblasUpper,
02120                 A.GetM(), alpha, A.GetData(),
02121                 X.GetData(), 1, beta, Y.GetData(), 1);
02122   }
02123 
02124 
02125   template <class Prop0, class Allocator0,
02126             class Allocator1, class Allocator2>
02127   void MltAdd(const double alpha,
02128               const Matrix<double, Prop0, ColSymPacked, Allocator0>& A,
02129               const Vector<double, VectFull, Allocator1>& X,
02130               const double beta,
02131               Vector<double, VectFull, Allocator2>& Y)
02132   {
02133 
02134 #ifdef SELDON_CHECK_DIMENSIONS
02135     CheckDim(A, X, Y, "MltAdd(alpha, M, X, beta, Y)");
02136 #endif
02137 
02138     cblas_dspmv(CblasColMajor, CblasUpper,
02139                 A.GetM(), alpha, A.GetData(),
02140                 X.GetData(), 1, beta, Y.GetData(), 1);
02141   }
02142 
02143 
02144   /*** ColSymPacked and Uplo ***/
02145 
02146 
02147   template <class Prop0, class Allocator0,
02148             class Allocator1, class Allocator2>
02149   void MltAdd(const float alpha,
02150               const SeldonUplo& Uplo,
02151               const Matrix<float, Prop0, ColSymPacked, Allocator0>& A,
02152               const Vector<float, VectFull, Allocator1>& X,
02153               const float beta,
02154               Vector<float, VectFull, Allocator2>& Y)
02155   {
02156 
02157 #ifdef SELDON_CHECK_DIMENSIONS
02158     CheckDim(A, X, Y, "MltAdd(alpha, uplo, M, X, beta, Y)");
02159 #endif
02160 
02161     cblas_sspmv(CblasColMajor, Uplo,
02162                 A.GetM(), alpha, A.GetData(),
02163                 X.GetData(), 1, beta, Y.GetData(), 1);
02164   }
02165 
02166 
02167   template <class Prop0, class Allocator0,
02168             class Allocator1, class Allocator2>
02169   void MltAdd(const double alpha,
02170               const SeldonUplo& Uplo,
02171               const Matrix<double, Prop0, ColSymPacked, Allocator0>& A,
02172               const Vector<double, VectFull, Allocator1>& X,
02173               const double beta,
02174               Vector<double, VectFull, Allocator2>& Y)
02175   {
02176 
02177 #ifdef SELDON_CHECK_DIMENSIONS
02178     CheckDim(A, X, Y, "MltAdd(alpha, uplo, M, X, beta, Y)");
02179 #endif
02180 
02181     cblas_dspmv(CblasColMajor, Uplo,
02182                 A.GetM(), alpha, A.GetData(),
02183                 X.GetData(), 1, beta, Y.GetData(), 1);
02184   }
02185 
02186 
02187   /*** RowSymPacked and Upper ***/
02188 
02189 
02190   template <class Prop0, class Allocator0,
02191             class Allocator1, class Allocator2>
02192   void MltAdd(const float alpha,
02193               const Matrix<float, Prop0, RowSymPacked, Allocator0>& A,
02194               const Vector<float, VectFull, Allocator1>& X,
02195               const float beta,
02196               Vector<float, VectFull, Allocator2>& Y)
02197   {
02198 
02199 #ifdef SELDON_CHECK_DIMENSIONS
02200     CheckDim(A, X, Y, "MltAdd(alpha, M, X, beta, Y)");
02201 #endif
02202 
02203     cblas_sspmv(CblasRowMajor, CblasUpper,
02204                 A.GetM(), alpha, A.GetData(),
02205                 X.GetData(), 1, beta, Y.GetData(), 1);
02206   }
02207 
02208 
02209   template <class Prop0, class Allocator0,
02210             class Allocator1, class Allocator2>
02211   void MltAdd(const double alpha,
02212               const Matrix<double, Prop0, RowSymPacked, Allocator0>& A,
02213               const Vector<double, VectFull, Allocator1>& X,
02214               const double beta,
02215               Vector<double, VectFull, Allocator2>& Y)
02216   {
02217 
02218 #ifdef SELDON_CHECK_DIMENSIONS
02219     CheckDim(A, X, Y, "MltAdd(alpha, M, X, beta, Y)");
02220 #endif
02221 
02222     cblas_dspmv(CblasRowMajor, CblasUpper,
02223                 A.GetM(), alpha, A.GetData(),
02224                 X.GetData(), 1, beta, Y.GetData(), 1);
02225   }
02226 
02227 
02228   /*** RowSymPacked and Uplo ***/
02229 
02230 
02231   template <class Prop0, class Allocator0,
02232             class Allocator1, class Allocator2>
02233   void MltAdd(const float alpha,
02234               const SeldonUplo& Uplo,
02235               const Matrix<float, Prop0, RowSymPacked, Allocator0>& A,
02236               const Vector<float, VectFull, Allocator1>& X,
02237               const float beta,
02238               Vector<float, VectFull, Allocator2>& Y)
02239   {
02240 
02241 #ifdef SELDON_CHECK_DIMENSIONS
02242     CheckDim(A, X, Y, "MltAdd(alpha, uplo, M, X, beta, Y)");
02243 #endif
02244 
02245     cblas_sspmv(CblasRowMajor, Uplo,
02246                 A.GetM(), alpha, A.GetData(),
02247                 X.GetData(), 1, beta, Y.GetData(), 1);
02248   }
02249 
02250 
02251   template <class Prop0, class Allocator0,
02252             class Allocator1, class Allocator2>
02253   void MltAdd(const double alpha,
02254               const SeldonUplo& Uplo,
02255               const Matrix<double, Prop0, RowSymPacked, Allocator0>& A,
02256               const Vector<double, VectFull, Allocator1>& X,
02257               const double beta,
02258               Vector<double, VectFull, Allocator2>& Y)
02259   {
02260 
02261 #ifdef SELDON_CHECK_DIMENSIONS
02262     CheckDim(A, X, Y, "MltAdd(alpha, uplo, M, X, beta, Y)");
02263 #endif
02264 
02265     cblas_dspmv(CblasRowMajor, Uplo,
02266                 A.GetM(), alpha, A.GetData(),
02267                 X.GetData(), 1, beta, Y.GetData(), 1);
02268   }
02269 
02270 
02271   // MLTADD //
02273 
02274 
02275 
02277   // RANK1UPDATE //
02278 
02279 
02280   /*** ColMajor ***/
02281 
02282 
02283   template <class Prop0, class Allocator0,
02284             class Allocator1, class Allocator2>
02285   void Rank1Update(const float alpha,
02286                    const Vector<float, VectFull, Allocator1>& X,
02287                    const Vector<float, VectFull, Allocator2>& Y,
02288                    Matrix<float, Prop0, ColMajor, Allocator0>& A)
02289   {
02290 
02291 #ifdef SELDON_CHECK_DIMENSIONS
02292     CheckDim(SeldonNoTrans, A, Y, X,
02293              "Rank1Update(alpha, X, Y, M)", "X.Y' + M");
02294 #endif
02295 
02296     cblas_sger(CblasColMajor, A.GetM(), A.GetN(), alpha, X.GetData(), 1,
02297                Y.GetData(), 1, A.GetData(), A.GetLD());
02298   }
02299 
02300 
02301   template <class Prop0, class Allocator0,
02302             class Allocator1, class Allocator2>
02303   void Rank1Update(const double alpha,
02304                    const Vector<double, VectFull, Allocator1>& X,
02305                    const Vector<double, VectFull, Allocator2>& Y,
02306                    Matrix<double, Prop0, ColMajor, Allocator0>& A)
02307   {
02308 
02309 #ifdef SELDON_CHECK_DIMENSIONS
02310     CheckDim(SeldonNoTrans, A, Y, X,
02311              "Rank1Update(alpha, X, Y, M)", "X.Y' + M");
02312 #endif
02313 
02314     cblas_dger(CblasColMajor, A.GetM(), A.GetN(), alpha, X.GetData(), 1,
02315                Y.GetData(), 1, A.GetData(), A.GetLD());
02316   }
02317 
02318 
02319   template <class Prop0, class Allocator0,
02320             class Allocator1, class Allocator2>
02321   void Rank1Update(const complex<float> alpha,
02322                    const Vector<complex<float>, VectFull, Allocator1>& X,
02323                    const Vector<complex<float>, VectFull, Allocator2>& Y,
02324                    Matrix<complex<float>, Prop0, ColMajor, Allocator0>& A)
02325   {
02326 
02327 #ifdef SELDON_CHECK_DIMENSIONS
02328     CheckDim(SeldonNoTrans, A, Y, X,
02329              "Rank1Update(alpha, X, Y, M)", "X.Y' + M");
02330 #endif
02331 
02332     cblas_cgeru(CblasColMajor, A.GetM(), A.GetN(),
02333                 reinterpret_cast<const void*>(&alpha),
02334                 reinterpret_cast<const void*>(X.GetData()), 1,
02335                 reinterpret_cast<const void*>(Y.GetData()), 1,
02336                 reinterpret_cast<void*>(A.GetData()), A.GetLD());
02337   }
02338 
02339 
02340   template <class Prop0, class Allocator0,
02341             class Allocator1, class Allocator2>
02342   void Rank1Update(const complex<double> alpha,
02343                    const Vector<complex<double>, VectFull, Allocator1>& X,
02344                    const Vector<complex<double>, VectFull, Allocator2>& Y,
02345                    Matrix<complex<double>, Prop0, ColMajor, Allocator0>& A)
02346   {
02347 
02348 #ifdef SELDON_CHECK_DIMENSIONS
02349     CheckDim(SeldonNoTrans, A, Y, X,
02350              "Rank1Update(alpha, X, Y, M)", "X.Y' + M");
02351 #endif
02352 
02353     cblas_zgeru(CblasColMajor, A.GetM(), A.GetN(),
02354                 reinterpret_cast<const void*>(&alpha),
02355                 reinterpret_cast<const void*>(X.GetData()), 1,
02356                 reinterpret_cast<const void*>(Y.GetData()), 1,
02357                 reinterpret_cast<void*>(A.GetData()), A.GetLD());
02358   }
02359 
02360 
02361   /*** ColMajor and ConjY ***/
02362 
02363 
02364   template <class Prop0, class Allocator0,
02365             class Allocator1, class Allocator2>
02366   void Rank1Update(const complex<float> alpha,
02367                    const Vector<complex<float>, VectFull, Allocator1>& X,
02368                    const SeldonConjugate& ConjY,
02369                    const Vector<complex<float>, VectFull, Allocator2>& Y,
02370                    Matrix<complex<float>, Prop0, ColMajor, Allocator0>& A)
02371   {
02372 
02373 #ifdef SELDON_CHECK_DIMENSIONS
02374     CheckDim(SeldonNoTrans, A, Y, X,
02375              "Rank1Update(alpha, X, status, Y, M)", "X.Y' + M");
02376 #endif
02377 
02378     if (ConjY.Conj())
02379       cblas_cgerc(CblasColMajor, A.GetM(), A.GetN(),
02380                   reinterpret_cast<const void*>(&alpha),
02381                   reinterpret_cast<const void*>(X.GetData()), 1,
02382                   reinterpret_cast<const void*>(Y.GetData()), 1,
02383                   reinterpret_cast<void*>(A.GetData()), A.GetLD());
02384     else
02385       cblas_cgeru(CblasColMajor, A.GetM(), A.GetN(),
02386                   reinterpret_cast<const void*>(&alpha),
02387                   reinterpret_cast<const void*>(X.GetData()), 1,
02388                   reinterpret_cast<const void*>(Y.GetData()), 1,
02389                   reinterpret_cast<void*>(A.GetData()), A.GetLD());
02390   }
02391 
02392 
02393   template <class Prop0, class Allocator0,
02394             class Allocator1, class Allocator2>
02395   void Rank1Update(const complex<double> alpha,
02396                    const Vector<complex<double>, VectFull, Allocator1>& X,
02397                    const SeldonConjugate& ConjY,
02398                    const Vector<complex<double>, VectFull, Allocator2>& Y,
02399                    Matrix<complex<double>, Prop0, ColMajor, Allocator0>& A)
02400   {
02401 
02402 #ifdef SELDON_CHECK_DIMENSIONS
02403     CheckDim(SeldonNoTrans, A, Y, X,
02404              "Rank1Update(alpha, X, status, Y, M)", "X.Y' + M");
02405 #endif
02406 
02407     if (ConjY.Conj())
02408       cblas_zgerc(CblasColMajor, A.GetM(), A.GetN(),
02409                   reinterpret_cast<const void*>(&alpha),
02410                   reinterpret_cast<const void*>(X.GetData()), 1,
02411                   reinterpret_cast<const void*>(Y.GetData()), 1,
02412                   reinterpret_cast<void*>(A.GetData()), A.GetLD());
02413     else
02414       cblas_zgeru(CblasColMajor, A.GetM(), A.GetN(),
02415                   reinterpret_cast<const void*>(&alpha),
02416                   reinterpret_cast<const void*>(X.GetData()), 1,
02417                   reinterpret_cast<const void*>(Y.GetData()), 1,
02418                   reinterpret_cast<void*>(A.GetData()), A.GetLD());
02419   }
02420 
02421 
02422   /*** RowMajor ***/
02423 
02424 
02425   template <class Prop0, class Allocator0,
02426             class Allocator1, class Allocator2>
02427   void Rank1Update(const float alpha,
02428                    const Vector<float, VectFull, Allocator1>& X,
02429                    const Vector<float, VectFull, Allocator2>& Y,
02430                    Matrix<float, Prop0, RowMajor, Allocator0>& A)
02431   {
02432 
02433 #ifdef SELDON_CHECK_DIMENSIONS
02434     CheckDim(SeldonNoTrans, A, Y, X,
02435              "Rank1Update(alpha, X, Y, M)", "X.Y' + M");
02436 #endif
02437 
02438     cblas_sger(CblasRowMajor, A.GetM(), A.GetN(), alpha, X.GetData(), 1,
02439                Y.GetData(), 1, A.GetData(), A.GetLD());
02440   }
02441 
02442 
02443   template <class Prop0, class Allocator0,
02444             class Allocator1, class Allocator2>
02445   void Rank1Update(const double alpha,
02446                    const Vector<double, VectFull, Allocator1>& X,
02447                    const Vector<double, VectFull, Allocator2>& Y,
02448                    Matrix<double, Prop0, RowMajor, Allocator0>& A)
02449   {
02450 
02451 #ifdef SELDON_CHECK_DIMENSIONS
02452     CheckDim(SeldonNoTrans, A, Y, X,
02453              "Rank1Update(alpha, X, Y, M)", "X.Y' + M");
02454 #endif
02455 
02456     cblas_dger(CblasRowMajor, A.GetM(), A.GetN(), alpha, X.GetData(), 1,
02457                Y.GetData(), 1, A.GetData(), A.GetLD());
02458   }
02459 
02460 
02461   template <class Prop0, class Allocator0,
02462             class Allocator1, class Allocator2>
02463   void Rank1Update(const complex<float> alpha,
02464                    const Vector<complex<float>, VectFull, Allocator1>& X,
02465                    const Vector<complex<float>, VectFull, Allocator2>& Y,
02466                    Matrix<complex<float>, Prop0, RowMajor, Allocator0>& A)
02467   {
02468 
02469 #ifdef SELDON_CHECK_DIMENSIONS
02470     CheckDim(SeldonNoTrans, A, Y, X,
02471              "Rank1Update(alpha, X, Y, M)", "X.Y' + M");
02472 #endif
02473 
02474     cblas_cgeru(CblasRowMajor, A.GetM(), A.GetN(),
02475                 reinterpret_cast<const void*>(&alpha),
02476                 reinterpret_cast<const void*>(X.GetData()), 1,
02477                 reinterpret_cast<const void*>(Y.GetData()), 1,
02478                 reinterpret_cast<void*>(A.GetData()), A.GetLD());
02479   }
02480 
02481 
02482   template <class Prop0, class Allocator0,
02483             class Allocator1, class Allocator2>
02484   void Rank1Update(const complex<double> alpha,
02485                    const Vector<complex<double>, VectFull, Allocator1>& X,
02486                    const Vector<complex<double>, VectFull, Allocator2>& Y,
02487                    Matrix<complex<double>, Prop0, RowMajor, Allocator0>& A)
02488   {
02489 
02490 #ifdef SELDON_CHECK_DIMENSIONS
02491     CheckDim(SeldonNoTrans, A, Y, X,
02492              "Rank1Update(alpha, X, Y, M)", "X.Y' + M");
02493 #endif
02494 
02495     cblas_zgeru(CblasRowMajor, A.GetM(), A.GetN(),
02496                 reinterpret_cast<const void*>(&alpha),
02497                 reinterpret_cast<const void*>(X.GetData()), 1,
02498                 reinterpret_cast<const void*>(Y.GetData()), 1,
02499                 reinterpret_cast<void*>(A.GetData()), A.GetLD());
02500   }
02501 
02502 
02503   /*** RowMajor and ConjY ***/
02504 
02505 
02506   template <class Prop0, class Allocator0,
02507             class Allocator1, class Allocator2>
02508   void Rank1Update(const complex<float> alpha,
02509                    const Vector<complex<float>, VectFull, Allocator1>& X,
02510                    const SeldonConjugate& ConjY,
02511                    const Vector<complex<float>, VectFull, Allocator2>& Y,
02512                    Matrix<complex<float>, Prop0, RowMajor, Allocator0>& A)
02513   {
02514 
02515 #ifdef SELDON_CHECK_DIMENSIONS
02516     CheckDim(SeldonNoTrans, A, Y, X,
02517              "Rank1Update(alpha, X, status, Y, M)", "X.Y' + M");
02518 #endif
02519 
02520     if (ConjY.Conj())
02521       cblas_cgerc(CblasRowMajor, A.GetM(), A.GetN(),
02522                   reinterpret_cast<const void*>(&alpha),
02523                   reinterpret_cast<const void*>(X.GetData()), 1,
02524                   reinterpret_cast<const void*>(Y.GetData()), 1,
02525                   reinterpret_cast<void*>(A.GetData()), A.GetLD());
02526     else
02527       cblas_cgeru(CblasRowMajor, A.GetM(), A.GetN(),
02528                   reinterpret_cast<const void*>(&alpha),
02529                   reinterpret_cast<const void*>(X.GetData()), 1,
02530                   reinterpret_cast<const void*>(Y.GetData()), 1,
02531                   reinterpret_cast<void*>(A.GetData()), A.GetLD());
02532   }
02533 
02534 
02535   template <class Prop0, class Allocator0,
02536             class Allocator1, class Allocator2>
02537   void Rank1Update(const complex<double> alpha,
02538                    const Vector<complex<double>, VectFull, Allocator1>& X,
02539                    const SeldonConjugate& ConjY,
02540                    const Vector<complex<double>, VectFull, Allocator2>& Y,
02541                    Matrix<complex<double>, Prop0, RowMajor, Allocator0>& A)
02542   {
02543 
02544 #ifdef SELDON_CHECK_DIMENSIONS
02545     CheckDim(SeldonNoTrans, A, Y, X,
02546              "Rank1Update(alpha, X, status, Y, M)", "X.Y' + M");
02547 #endif
02548 
02549     if (ConjY.Conj())
02550       cblas_zgerc(CblasRowMajor, A.GetM(), A.GetN(),
02551                   reinterpret_cast<const void*>(&alpha),
02552                   reinterpret_cast<const void*>(X.GetData()), 1,
02553                   reinterpret_cast<const void*>(Y.GetData()), 1,
02554                   reinterpret_cast<void*>(A.GetData()), A.GetLD());
02555     else
02556       cblas_zgeru(CblasRowMajor, A.GetM(), A.GetN(),
02557                   reinterpret_cast<const void*>(&alpha),
02558                   reinterpret_cast<const void*>(X.GetData()), 1,
02559                   reinterpret_cast<const void*>(Y.GetData()), 1,
02560                   reinterpret_cast<void*>(A.GetData()), A.GetLD());
02561   }
02562 
02563 
02564   /*** ColSymPacked and Upper ***/
02565 
02566 
02567   template <class Allocator0,
02568             class Prop1, class Allocator1>
02569   void Rank1Update(const float alpha,
02570                    const Vector<float, VectFull, Allocator0>& X,
02571                    Matrix<float, Prop1, ColSymPacked, Allocator1>& A)
02572   {
02573 
02574 #ifdef SELDON_CHECK_DIMENSIONS
02575     CheckDim(A, X, "Rank1Update(alpha, X, M)", "X.X' + M");
02576 #endif
02577 
02578     cblas_sspr(CblasColMajor, CblasUpper, A.GetM(), alpha,
02579                X.GetData(), 1, A.GetData());
02580   }
02581 
02582 
02583   template <class Allocator0,
02584             class Prop1, class Allocator1>
02585   void Rank1Update(const double alpha,
02586                    const Vector<double, VectFull, Allocator0>& X,
02587                    Matrix<double, Prop1, ColSymPacked, Allocator1>& A)
02588   {
02589 
02590 #ifdef SELDON_CHECK_DIMENSIONS
02591     CheckDim(A, X, "Rank1Update(alpha, X, M)", "X.X' + M");
02592 #endif
02593 
02594     cblas_dspr(CblasColMajor, CblasUpper, A.GetM(), alpha,
02595                X.GetData(), 1, A.GetData());
02596   }
02597 
02598 
02599   template <class Allocator0,
02600             class Prop1, class Allocator1>
02601   void
02602   Rank1Update(const float alpha,
02603               const Vector<complex<float>, VectFull, Allocator0>& X,
02604               Matrix<complex<float>, Prop1, ColHermPacked, Allocator1>& A)
02605   {
02606 
02607 #ifdef SELDON_CHECK_DIMENSIONS
02608     CheckDim(A, X, "Rank1Update(alpha, X, M)", "X.X' + M");
02609 #endif
02610 
02611     cblas_chpr(CblasColMajor, CblasUpper, A.GetM(), alpha,
02612                reinterpret_cast<const void*>(X.GetData()), 1,
02613                reinterpret_cast<void*>(A.GetData()));
02614   }
02615 
02616 
02617   template <class Allocator0,
02618             class Prop1, class Allocator1>
02619   void
02620   Rank1Update(const double alpha,
02621               const Vector<complex<double>, VectFull, Allocator0>& X,
02622               Matrix<complex<double>, Prop1, ColHermPacked, Allocator1>& A)
02623   {
02624 
02625 #ifdef SELDON_CHECK_DIMENSIONS
02626     CheckDim(A, X, "Rank1Update(alpha, X, M)", "X.X' + M");
02627 #endif
02628 
02629     cblas_zhpr(CblasColMajor, CblasUpper, A.GetM(), alpha,
02630                reinterpret_cast<const void*>(X.GetData()), 1,
02631                reinterpret_cast<void*>(A.GetData()));
02632   }
02633 
02634 
02635   /*** ColSymPacked and Uplo ***/
02636 
02637 
02638   template <class Allocator0,
02639             class Prop1, class Allocator1>
02640   void Rank1Update(const float alpha,
02641                    const Vector<float, VectFull, Allocator0>& X,
02642                    const SeldonUplo& Uplo,
02643                    Matrix<float, Prop1, ColSymPacked, Allocator1>& A)
02644   {
02645 
02646 #ifdef SELDON_CHECK_DIMENSIONS
02647     CheckDim(A, X, "Rank1Update(alpha, X, uplo, M)", "X.X' + M");
02648 #endif
02649 
02650     cblas_sspr(CblasColMajor, Uplo, A.GetM(), alpha,
02651                X.GetData(), 1, A.GetData());
02652   }
02653 
02654 
02655   template <class Allocator0,
02656             class Prop1, class Allocator1>
02657   void Rank1Update(const double alpha,
02658                    const Vector<double, VectFull, Allocator0>& X,
02659                    const SeldonUplo& Uplo,
02660                    Matrix<double, Prop1, ColSymPacked, Allocator1>& A)
02661   {
02662 
02663 #ifdef SELDON_CHECK_DIMENSIONS
02664     CheckDim(A, X, "Rank1Update(alpha, X, uplo, M)", "X.X' + M");
02665 #endif
02666 
02667     cblas_dspr(CblasColMajor, Uplo, A.GetM(), alpha,
02668                X.GetData(), 1, A.GetData());
02669   }
02670 
02671 
02672   template <class Allocator0,
02673             class Prop1, class Allocator1>
02674   void
02675   Rank1Update(const float alpha,
02676               const Vector<complex<float>, VectFull, Allocator0>& X,
02677               const SeldonUplo& Uplo,
02678               Matrix<complex<float>, Prop1, ColHermPacked, Allocator1>& A)
02679   {
02680 
02681 #ifdef SELDON_CHECK_DIMENSIONS
02682     CheckDim(A, X, "Rank1Update(alpha, X, uplo, M)", "X.X' + M");
02683 #endif
02684 
02685     cblas_chpr(CblasColMajor, Uplo, A.GetM(), alpha,
02686                reinterpret_cast<const void*>(X.GetData()), 1,
02687                reinterpret_cast<void*>(A.GetData()));
02688   }
02689 
02690 
02691   template <class Allocator0,
02692             class Prop1, class Allocator1>
02693   void
02694   Rank1Update(const double alpha,
02695               const Vector<complex<double>, VectFull, Allocator0>& X,
02696               const SeldonUplo& Uplo,
02697               Matrix<complex<double>, Prop1, ColHermPacked, Allocator1>& A)
02698   {
02699 
02700 #ifdef SELDON_CHECK_DIMENSIONS
02701     CheckDim(A, X, "Rank1Update(alpha, X, uplo, M)", "X.X' + M");
02702 #endif
02703 
02704     cblas_zhpr(CblasColMajor, Uplo, A.GetM(), alpha,
02705                reinterpret_cast<const void*>(X.GetData()), 1,
02706                reinterpret_cast<void*>(A.GetData()));
02707   }
02708 
02709 
02710   /*** RowSymPacked and Upper ***/
02711 
02712 
02713   template <class Allocator0,
02714             class Prop1, class Allocator1>
02715   void Rank1Update(const float alpha,
02716                    const Vector<float, VectFull, Allocator0>& X,
02717                    Matrix<float, Prop1, RowSymPacked, Allocator1>& A)
02718   {
02719 
02720 #ifdef SELDON_CHECK_DIMENSIONS
02721     CheckDim(A, X, "Rank1Update(alpha, X, M)", "X.X' + M");
02722 #endif
02723 
02724     cblas_sspr(CblasRowMajor, CblasUpper, A.GetM(), alpha,
02725                X.GetData(), 1, A.GetData());
02726   }
02727 
02728 
02729   template <class Allocator0,
02730             class Prop1, class Allocator1>
02731   void Rank1Update(const double alpha,
02732                    const Vector<double, VectFull, Allocator0>& X,
02733                    Matrix<double, Prop1, RowSymPacked, Allocator1>& A)
02734   {
02735 
02736 #ifdef SELDON_CHECK_DIMENSIONS
02737     CheckDim(A, X, "Rank1Update(alpha, X, M)", "X.X' + M");
02738 #endif
02739 
02740     cblas_dspr(CblasRowMajor, CblasUpper, A.GetM(), alpha,
02741                X.GetData(), 1, A.GetData());
02742   }
02743 
02744 
02745   template <class Allocator0,
02746             class Prop1, class Allocator1>
02747   void
02748   Rank1Update(const float alpha,
02749               const Vector<complex<float>, VectFull, Allocator0>& X,
02750               Matrix<complex<float>, Prop1, RowHermPacked, Allocator1>& A)
02751   {
02752 
02753 #ifdef SELDON_CHECK_DIMENSIONS
02754     CheckDim(A, X, "Rank1Update(alpha, X, M)", "X.X' + M");
02755 #endif
02756 
02757     cblas_chpr(CblasRowMajor, CblasUpper, A.GetM(), alpha,
02758                reinterpret_cast<const void*>(X.GetData()), 1,
02759                reinterpret_cast<void*>(A.GetData()));
02760   }
02761 
02762 
02763   template <class Allocator0,
02764             class Prop1, class Allocator1>
02765   void
02766   Rank1Update(const double alpha,
02767               const Vector<complex<double>, VectFull, Allocator0>& X,
02768               Matrix<complex<double>, Prop1, RowHermPacked, Allocator1>& A)
02769   {
02770 
02771 #ifdef SELDON_CHECK_DIMENSIONS
02772     CheckDim(A, X, "Rank1Update(alpha, X, M)", "X.X' + M");
02773 #endif
02774 
02775     cblas_zhpr(CblasRowMajor, CblasUpper, A.GetM(), alpha,
02776                reinterpret_cast<const void*>(X.GetData()), 1,
02777                reinterpret_cast<void*>(A.GetData()));
02778   }
02779 
02780 
02781   /*** RowSymPacked and Uplo ***/
02782 
02783 
02784   template <class Allocator0,
02785             class Prop1, class Allocator1>
02786   void Rank1Update(const float alpha,
02787                    const Vector<float, VectFull, Allocator0>& X,
02788                    const SeldonUplo& Uplo,
02789                    Matrix<float, Prop1, RowSymPacked, Allocator1>& A)
02790   {
02791 
02792 #ifdef SELDON_CHECK_DIMENSIONS
02793     CheckDim(A, X, "Rank1Update(alpha, X, uplo, M)", "X.X' + M");
02794 #endif
02795 
02796     cblas_sspr(CblasRowMajor, Uplo, A.GetM(), alpha,
02797                X.GetData(), 1, A.GetData());
02798   }
02799 
02800 
02801   template <class Allocator0,
02802             class Prop1, class Allocator1>
02803   void Rank1Update(const double alpha,
02804                    const Vector<double, VectFull, Allocator0>& X,
02805                    const SeldonUplo& Uplo,
02806                    Matrix<double, Prop1, RowSymPacked, Allocator1>& A)
02807   {
02808 
02809 #ifdef SELDON_CHECK_DIMENSIONS
02810     CheckDim(A, X, "Rank1Update(alpha, X, uplo, M)", "X.X' + M");
02811 #endif
02812 
02813     cblas_dspr(CblasRowMajor, Uplo, A.GetM(), alpha,
02814                X.GetData(), 1, A.GetData());
02815   }
02816 
02817 
02818   template <class Allocator0,
02819             class Prop1, class Allocator1>
02820   void
02821   Rank1Update(const float alpha,
02822               const Vector<complex<float>, VectFull, Allocator0>& X,
02823               const SeldonUplo& Uplo,
02824               Matrix<complex<float>, Prop1, RowHermPacked, Allocator1>& A)
02825   {
02826 
02827 #ifdef SELDON_CHECK_DIMENSIONS
02828     CheckDim(A, X, "Rank1Update(alpha, X, uplo, M)", "X.X' + M");
02829 #endif
02830 
02831     cblas_chpr(CblasRowMajor, Uplo, A.GetM(), alpha,
02832                reinterpret_cast<const void*>(X.GetData()), 1,
02833                reinterpret_cast<void*>(A.GetData()));
02834   }
02835 
02836 
02837   template <class Allocator0,
02838             class Prop1, class Allocator1>
02839   void
02840   Rank1Update(const double alpha,
02841               const Vector<complex<double>, VectFull, Allocator0>& X,
02842               const SeldonUplo& Uplo,
02843               Matrix<complex<double>, Prop1, RowHermPacked, Allocator1>& A)
02844   {
02845 
02846 #ifdef SELDON_CHECK_BOUNDS
02847     CheckDim(A, X, "Rank1Update(alpha, X, uplo, M)", "X.X' + M");
02848 #endif
02849 
02850     cblas_zhpr(CblasRowMajor, Uplo, A.GetM(), alpha,
02851                reinterpret_cast<const void*>(X.GetData()), 1,
02852                reinterpret_cast<void*>(A.GetData()));
02853   }
02854 
02855 
02856   // RANK1UPDATE //
02858 
02859 
02860 
02862   // RANK2UPDATE //
02863 
02864 
02865   /*** ColSymPacked and Upper ***/
02866 
02867 
02868   template <class Allocator0,
02869             class Prop1, class Allocator1,
02870             class Allocator2>
02871   void Rank2Update(const float alpha,
02872                    const Vector<float, VectFull, Allocator0>& X,
02873                    const Vector<float, VectFull, Allocator2>& Y,
02874                    Matrix<float, Prop1, ColSymPacked, Allocator1>& A)
02875   {
02876 
02877 #ifdef SELDON_CHECK_BOUNDS
02878     CheckDim(A, X, "Rank2Update(alpha, X, Y, M)", "X.Y' + Y.X' + M");
02879     CheckDim(A, Y, "Rank2Update(alpha, X, Y, M)", "X.Y' + Y.X' + M");
02880 #endif
02881 
02882     cblas_sspr2(CblasColMajor, CblasUpper, A.GetM(), alpha,
02883                 X.GetData(), 1, Y.GetData(), 1, A.GetData());
02884   }
02885 
02886 
02887   template <class Allocator0,
02888             class Prop1, class Allocator1,
02889             class Allocator2>
02890   void Rank2Update(const double alpha,
02891                    const Vector<double, VectFull, Allocator0>& X,
02892                    const Vector<double, VectFull, Allocator2>& Y,
02893                    Matrix<double, Prop1, ColSymPacked, Allocator1>& A)
02894   {
02895 
02896 #ifdef SELDON_CHECK_DIMENSIONS
02897     CheckDim(A, X, "Rank2Update(alpha, X, Y, M)", "X.Y' + Y.X' + M");
02898     CheckDim(A, Y, "Rank2Update(alpha, X, Y, M)", "X.Y' + Y.X' + M");
02899 #endif
02900 
02901     cblas_dspr2(CblasColMajor, CblasUpper, A.GetM(), alpha,
02902                 X.GetData(), 1, Y.GetData(), 1, A.GetData());
02903   }
02904 
02905 
02906   template <class Allocator0,
02907             class Prop1, class Allocator1,
02908             class Allocator2>
02909   void
02910   Rank2Update(const complex<float> alpha,
02911               const Vector<complex<float>, VectFull, Allocator0>& X,
02912               const Vector<complex<float>, VectFull, Allocator2>& Y,
02913               Matrix<complex<float>, Prop1, ColHermPacked, Allocator1>& A)
02914   {
02915 
02916 #ifdef SELDON_CHECK_DIMENSIONS
02917     CheckDim(A, X, "Rank2Update(alpha, X, Y, M)", "X.Y' + Y.X' + M");
02918     CheckDim(A, Y, "Rank2Update(alpha, X, Y, M)", "X.Y' + Y.X' + M");
02919 #endif
02920 
02921     cblas_chpr2(CblasColMajor, CblasUpper, A.GetM(),
02922                 reinterpret_cast<const void*>(&alpha),
02923                 reinterpret_cast<const void*>(X.GetData()), 1,
02924                 reinterpret_cast<const void*>(Y.GetData()), 1,
02925                 reinterpret_cast<void*>(A.GetData()));
02926   }
02927 
02928 
02929   template <class Allocator0,
02930             class Prop1, class Allocator1,
02931             class Allocator2>
02932   void
02933   Rank2Update(const complex<double> alpha,
02934               const Vector<complex<double>, VectFull, Allocator0>& X,
02935               const Vector<complex<double>, VectFull, Allocator2>& Y,
02936               Matrix<complex<double>, Prop1, ColHermPacked, Allocator1>& A)
02937   {
02938 
02939 #ifdef SELDON_CHECK_DIMENSIONS
02940     CheckDim(A, X, "Rank2Update(alpha, X, Y, M)", "X.Y' + Y.X' + M");
02941     CheckDim(A, Y, "Rank2Update(alpha, X, Y, M)", "X.Y' + Y.X' + M");
02942 #endif
02943 
02944     cblas_zhpr2(CblasColMajor, CblasUpper, A.GetM(),
02945                 reinterpret_cast<const void*>(&alpha),
02946                 reinterpret_cast<const void*>(X.GetData()), 1,
02947                 reinterpret_cast<const void*>(Y.GetData()), 1,
02948                 reinterpret_cast<void*>(A.GetData()));
02949   }
02950 
02951 
02952   /*** ColSymPacked and Uplo ***/
02953 
02954 
02955   template <class Allocator0,
02956             class Prop1, class Allocator1,
02957             class Allocator2>
02958   void Rank2Update(const float alpha,
02959                    const Vector<float, VectFull, Allocator0>& X,
02960                    const Vector<float, VectFull, Allocator2>& Y,
02961                    const SeldonUplo& Uplo,
02962                    Matrix<float, Prop1, ColSymPacked, Allocator1>& A)
02963   {
02964 
02965 #ifdef SELDON_CHECK_DIMENSIONS
02966     CheckDim(A, X, "Rank2Update(alpha, X, Y, uplo, M)", "X.Y' + Y.X' + M");
02967     CheckDim(A, Y, "Rank2Update(alpha, X, Y, uplo, M)", "X.Y' + Y.X' + M");
02968 #endif
02969 
02970     cblas_sspr2(CblasColMajor, Uplo, A.GetM(), alpha,
02971                 X.GetData(), 1, Y.GetData(), 1, A.GetData());
02972   }
02973 
02974 
02975   template <class Allocator0,
02976             class Prop1, class Allocator1,
02977             class Allocator2>
02978   void Rank2Update(const double alpha,
02979                    const Vector<double, VectFull, Allocator0>& X,
02980                    const Vector<double, VectFull, Allocator2>& Y,
02981                    const SeldonUplo& Uplo,
02982                    Matrix<double, Prop1, ColSymPacked, Allocator1>& A)
02983   {
02984 
02985 #ifdef SELDON_CHECK_DIMENSIONS
02986     CheckDim(A, X, "Rank2Update(alpha, X, Y, uplo, M)", "X.Y' + Y.X' + M");
02987     CheckDim(A, Y, "Rank2Update(alpha, X, Y, uplo, M)", "X.Y' + Y.X' + M");
02988 #endif
02989 
02990     cblas_dspr2(CblasColMajor, Uplo, A.GetM(), alpha,
02991                 X.GetData(), 1, Y.GetData(), 1, A.GetData());
02992   }
02993 
02994 
02995   template <class Allocator0,
02996             class Prop1, class Allocator1,
02997             class Allocator2>
02998   void
02999   Rank2Update(const complex<float> alpha,
03000               const Vector<complex<float>, VectFull, Allocator0>& X,
03001               const Vector<complex<float>, VectFull, Allocator2>& Y,
03002               const SeldonUplo& Uplo,
03003               Matrix<complex<float>, Prop1, ColHermPacked, Allocator1>& A)
03004   {
03005 
03006 #ifdef SELDON_CHECK_DIMENSIONS
03007     CheckDim(A, X, "Rank2Update(alpha, X, Y, uplo, M)", "X.Y' + Y.X' + M");
03008     CheckDim(A, Y, "Rank2Update(alpha, X, Y, uplo, M)", "X.Y' + Y.X' + M");
03009 #endif
03010 
03011     cblas_chpr2(CblasColMajor, Uplo, A.GetM(),
03012                 reinterpret_cast<const void*>(&alpha),
03013                 reinterpret_cast<const void*>(X.GetData()), 1,
03014                 reinterpret_cast<const void*>(Y.GetData()), 1,
03015                 reinterpret_cast<void*>(A.GetData()));
03016   }
03017 
03018 
03019   template <class Allocator0,
03020             class Prop1, class Allocator1,
03021             class Allocator2>
03022   void
03023   Rank2Update(const complex<double> alpha,
03024               const Vector<complex<double>, VectFull, Allocator0>& X,
03025               const Vector<complex<double>, VectFull, Allocator2>& Y,
03026               const SeldonUplo& Uplo,
03027               Matrix<complex<double>, Prop1, ColHermPacked, Allocator1>& A)
03028   {
03029 
03030 #ifdef SELDON_CHECK_DIMENSIONS
03031     CheckDim(A, X, "Rank2Update(alpha, X, Y, uplo, M)", "X.Y' + Y.X' + M");
03032     CheckDim(A, Y, "Rank2Update(alpha, X, Y, uplo, M)", "X.Y' + Y.X' + M");
03033 #endif
03034 
03035     cblas_zhpr2(CblasColMajor, Uplo, A.GetM(),
03036                 reinterpret_cast<const void*>(&alpha),
03037                 reinterpret_cast<const void*>(X.GetData()), 1,
03038                 reinterpret_cast<const void*>(Y.GetData()), 1,
03039                 reinterpret_cast<void*>(A.GetData()));
03040   }
03041 
03042 
03043   /*** RowSymPacked and Upper ***/
03044 
03045 
03046   template <class Allocator0,
03047             class Prop1, class Allocator1,
03048             class Allocator2>
03049   void Rank2Update(const float alpha,
03050                    const Vector<float, VectFull, Allocator0>& X,
03051                    const Vector<float, VectFull, Allocator2>& Y,
03052                    Matrix<float, Prop1, RowSymPacked, Allocator1>& A)
03053   {
03054 
03055 #ifdef SELDON_CHECK_DIMENSIONS
03056     CheckDim(A, X, "Rank2Update(alpha, X, Y, M)", "X.Y' + Y.X' + M");
03057     CheckDim(A, Y, "Rank2Update(alpha, X, Y, M)", "X.Y' + Y.X' + M");
03058 #endif
03059 
03060     cblas_sspr2(CblasRowMajor, CblasUpper, A.GetM(), alpha,
03061                 X.GetData(), 1, Y.GetData(), 1, A.GetData());
03062   }
03063 
03064 
03065   template <class Allocator0,
03066             class Prop1, class Allocator1,
03067             class Allocator2>
03068   void Rank2Update(const double alpha,
03069                    const Vector<double, VectFull, Allocator0>& X,
03070                    const Vector<double, VectFull, Allocator2>& Y,
03071                    Matrix<double, Prop1, RowSymPacked, Allocator1>& A)
03072   {
03073 
03074 #ifdef SELDON_CHECK_DIMENSIONS
03075     CheckDim(A, X, "Rank2Update(alpha, X, Y, M)", "X.Y' + Y.X' + M");
03076     CheckDim(A, Y, "Rank2Update(alpha, X, Y, M)", "X.Y' + Y.X' + M");
03077 #endif
03078 
03079     cblas_dspr2(CblasRowMajor, CblasUpper, A.GetM(), alpha,
03080                 X.GetData(), 1, Y.GetData(), 1, A.GetData());
03081   }
03082 
03083 
03084   template <class Allocator0,
03085             class Prop1, class Allocator1,
03086             class Allocator2>
03087   void
03088   Rank2Update(const complex<float> alpha,
03089               const Vector<complex<float>, VectFull, Allocator0>& X,
03090               const Vector<complex<float>, VectFull, Allocator2>& Y,
03091               Matrix<complex<float>, Prop1, RowHermPacked, Allocator1>& A)
03092   {
03093 
03094 #ifdef SELDON_CHECK_DIMENSIONS
03095     CheckDim(A, X, "Rank2Update(alpha, X, Y, M)", "X.Y' + Y.X' + M");
03096     CheckDim(A, Y, "Rank2Update(alpha, X, Y, M)", "X.Y' + Y.X' + M");
03097 #endif
03098 
03099     cblas_chpr2(CblasRowMajor, CblasUpper, A.GetM(),
03100                 reinterpret_cast<const void*>(&alpha),
03101                 reinterpret_cast<const void*>(X.GetData()), 1,
03102                 reinterpret_cast<const void*>(Y.GetData()), 1,
03103                 reinterpret_cast<void*>(A.GetData()));
03104   }
03105 
03106 
03107   template <class Allocator0,
03108             class Prop1, class Allocator1,
03109             class Allocator2>
03110   void
03111   Rank2Update(const complex<double> alpha,
03112               const Vector<complex<double>, VectFull, Allocator0>& X,
03113               const Vector<complex<double>, VectFull, Allocator2>& Y,
03114               Matrix<complex<double>, Prop1, RowHermPacked, Allocator1>& A)
03115   {
03116 
03117 #ifdef SELDON_CHECK_DIMENSIONS
03118     CheckDim(A, X, "Rank2Update(alpha, X, Y, M)", "X.Y' + Y.X' + M");
03119     CheckDim(A, Y, "Rank2Update(alpha, X, Y, M)", "X.Y' + Y.X' + M");
03120 #endif
03121 
03122     cblas_zhpr2(CblasRowMajor, CblasUpper, A.GetM(),
03123                 reinterpret_cast<const void*>(&alpha),
03124                 reinterpret_cast<const void*>(X.GetData()), 1,
03125                 reinterpret_cast<const void*>(Y.GetData()), 1,
03126                 reinterpret_cast<void*>(A.GetData()));
03127   }
03128 
03129 
03130   /*** RowSymPacked and Uplo ***/
03131 
03132 
03133   template <class Allocator0,
03134             class Prop1, class Allocator1,
03135             class Allocator2>
03136   void Rank2Update(const float alpha,
03137                    const Vector<float, VectFull, Allocator0>& X,
03138                    const Vector<float, VectFull, Allocator2>& Y,
03139                    const SeldonUplo& Uplo,
03140                    Matrix<float, Prop1, RowSymPacked, Allocator1>& A)
03141   {
03142 
03143 #ifdef SELDON_CHECK_DIMENSIONS
03144     CheckDim(A, X, "Rank2Update(alpha, X, Y, uplo, M)", "X.Y' + Y.X' + M");
03145     CheckDim(A, Y, "Rank2Update(alpha, X, Y, uplo, M)", "X.Y' + Y.X' + M");
03146 #endif
03147 
03148     cblas_sspr2(CblasRowMajor, Uplo, A.GetM(), alpha,
03149                 X.GetData(), 1, Y.GetData(), 1, A.GetData());
03150   }
03151 
03152 
03153   template <class Allocator0,
03154             class Prop1, class Allocator1,
03155             class Allocator2>
03156   void Rank2Update(const double alpha,
03157                    const Vector<double, VectFull, Allocator0>& X,
03158                    const Vector<double, VectFull, Allocator2>& Y,
03159                    const SeldonUplo& Uplo,
03160                    Matrix<double, Prop1, RowSymPacked, Allocator1>& A)
03161   {
03162 
03163 #ifdef SELDON_CHECK_DIMENSIONS
03164     CheckDim(A, X, "Rank2Update(alpha, X, Y, uplo, M)", "X.Y' + Y.X' + M");
03165     CheckDim(A, Y, "Rank2Update(alpha, X, Y, uplo, M)", "X.Y' + Y.X' + M");
03166 #endif
03167 
03168     cblas_dspr2(CblasRowMajor, Uplo, A.GetM(), alpha,
03169                 X.GetData(), 1, Y.GetData(), 1, A.GetData());
03170   }
03171 
03172 
03173   template <class Allocator0,
03174             class Prop1, class Allocator1,
03175             class Allocator2>
03176   void
03177   Rank2Update(const complex<float> alpha,
03178               const Vector<complex<float>, VectFull, Allocator0>& X,
03179               const Vector<complex<float>, VectFull, Allocator2>& Y,
03180               const SeldonUplo& Uplo,
03181               Matrix<complex<float>, Prop1, RowHermPacked, Allocator1>& A)
03182   {
03183 
03184 #ifdef SELDON_CHECK_DIMENSIONS
03185     CheckDim(A, X, "Rank2Update(alpha, X, Y, uplo, M)", "X.Y' + Y.X' + M");
03186     CheckDim(A, Y, "Rank2Update(alpha, X, Y, uplo, M)", "X.Y' + Y.X' + M");
03187 #endif
03188 
03189     cblas_chpr2(CblasRowMajor, Uplo, A.GetM(),
03190                 reinterpret_cast<const void*>(&alpha),
03191                 reinterpret_cast<const void*>(X.GetData()), 1,
03192                 reinterpret_cast<const void*>(Y.GetData()), 1,
03193                 reinterpret_cast<void*>(A.GetData()));
03194   }
03195 
03196 
03197   template <class Allocator0,
03198             class Prop1, class Allocator1,
03199             class Allocator2>
03200   void
03201   Rank2Update(const complex<double> alpha,
03202               const Vector<complex<double>, VectFull, Allocator0>& X,
03203               const Vector<complex<double>, VectFull, Allocator2>& Y,
03204               const SeldonUplo& Uplo,
03205               Matrix<complex<double>, Prop1, RowHermPacked, Allocator1>& A)
03206   {
03207 
03208 #ifdef SELDON_CHECK_DIMENSIONS
03209     CheckDim(A, X, "Rank2Update(alpha, X, Y, uplo, M)", "X.Y' + Y.X' + M");
03210     CheckDim(A, Y, "Rank2Update(alpha, X, Y, uplo, M)", "X.Y' + Y.X' + M");
03211 #endif
03212 
03213     cblas_zhpr2(CblasRowMajor, Uplo, A.GetM(),
03214                 reinterpret_cast<const void*>(&alpha),
03215                 reinterpret_cast<const void*>(X.GetData()), 1,
03216                 reinterpret_cast<const void*>(Y.GetData()), 1,
03217                 reinterpret_cast<void*>(A.GetData()));
03218   }
03219 
03220 
03221   // RANK2UPDATE //
03223 
03224 
03225 
03227   // SOLVE //
03228 
03229 
03230   /*** ColUpTriang, NoTrans and NonUnit ***/
03231 
03232 
03233   template <class Prop0, class Allocator0,
03234             class Allocator1>
03235   void Solve(const Matrix<float, Prop0, ColUpTriang, Allocator0>& A,
03236              Vector<float, VectFull, Allocator1>& X)
03237   {
03238 
03239 #ifdef SELDON_CHECK_DIMENSIONS
03240     CheckDim(A, X, "Solve(M, X)");
03241 #endif
03242 
03243     cblas_strsv(CblasColMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
03244                 A.GetN(), A.GetData(), A.GetM(), X.GetData(), 1);
03245   }
03246 
03247 
03248   template <class Prop0, class Allocator0,
03249             class Allocator1>
03250   void Solve(const Matrix<double, Prop0, ColUpTriang, Allocator0>& A,
03251              Vector<double, VectFull, Allocator1>& X)
03252   {
03253 
03254 #ifdef SELDON_CHECK_DIMENSIONS
03255     CheckDim(A, X, "Solve(M, X)");
03256 #endif
03257 
03258     cblas_dtrsv(CblasColMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
03259                 A.GetN(), A.GetData(), A.GetM(), X.GetData(), 1);
03260   }
03261 
03262 
03263   template <class Prop0, class Allocator0,
03264             class Allocator1>
03265   void
03266   Solve(const Matrix<complex<float>, Prop0, ColUpTriang, Allocator0>& A,
03267         Vector<complex<float>, VectFull, Allocator1>& X)
03268   {
03269 
03270 #ifdef SELDON_CHECK_DIMENSIONS
03271     CheckDim(A, X, "Solve(M, X)");
03272 #endif
03273 
03274     cblas_ctrsv(CblasColMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
03275                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
03276                 A.GetM(), reinterpret_cast<void*>(X.GetData()), 1);
03277   }
03278 
03279 
03280   template <class Prop0, class Allocator0,
03281             class Allocator1>
03282   void
03283   Solve(const Matrix<complex<double>, Prop0,
03284         ColUpTriang, Allocator0>& A,
03285         Vector<complex<double>, VectFull, Allocator1>& X)
03286   {
03287 
03288 #ifdef SELDON_CHECK_DIMENSIONS
03289     CheckDim(A, X, "Solve(M, X)");
03290 #endif
03291 
03292     cblas_ztrsv(CblasColMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
03293                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
03294                 A.GetM(), reinterpret_cast<void*>(X.GetData()), 1);
03295   }
03296 
03297 
03298   /*** ColUpTriang ***/
03299 
03300 
03301   template <class Prop0, class Allocator0,
03302             class Allocator1>
03303   void Solve(const SeldonTranspose& TransA,
03304              const SeldonDiag& DiagA,
03305              const Matrix<float, Prop0, ColUpTriang, Allocator0>& A,
03306              Vector<float, VectFull, Allocator1>& X)
03307   {
03308 
03309 #ifdef SELDON_CHECK_DIMENSIONS
03310     CheckDim(A, X, "Solve(status, diag, M, X)");
03311 #endif
03312 
03313     cblas_strsv(CblasColMajor, CblasUpper, TransA, DiagA,
03314                 A.GetN(), A.GetData(), A.GetM(), X.GetData(), 1);
03315   }
03316 
03317 
03318   template <class Prop0, class Allocator0,
03319             class Allocator1>
03320   void Solve(const SeldonTranspose& TransA,
03321              const SeldonDiag& DiagA,
03322              const Matrix<double, Prop0, ColUpTriang, Allocator0>& A,
03323              Vector<double, VectFull, Allocator1>& X)
03324   {
03325 
03326 #ifdef SELDON_CHECK_DIMENSIONS
03327     CheckDim(A, X, "Solve(status, diag, M, X)");
03328 #endif
03329 
03330     cblas_dtrsv(CblasColMajor, CblasUpper, TransA, DiagA,
03331                 A.GetN(), A.GetData(), A.GetM(), X.GetData(), 1);
03332   }
03333 
03334 
03335   template <class Prop0, class Allocator0,
03336             class Allocator1>
03337   void
03338   Solve(const SeldonTranspose& TransA,
03339         const SeldonDiag& DiagA,
03340         const Matrix<complex<float>, Prop0, ColUpTriang, Allocator0>& A,
03341         Vector<complex<float>, VectFull, Allocator1>& X)
03342   {
03343 
03344 #ifdef SELDON_CHECK_DIMENSIONS
03345     CheckDim(A, X, "Solve(status, diag, M, X)");
03346 #endif
03347 
03348     cblas_ctrsv(CblasColMajor, CblasUpper, TransA, DiagA,
03349                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
03350                 A.GetM(), reinterpret_cast<void*>(X.GetData()), 1);
03351   }
03352 
03353 
03354   template <class Prop0, class Allocator0,
03355             class Allocator1>
03356   void
03357   Solve(const SeldonTranspose& TransA,
03358         const SeldonDiag& DiagA,
03359         const Matrix<complex<double>, Prop0,
03360         ColUpTriang, Allocator0>& A,
03361         Vector<complex<double>, VectFull, Allocator1>& X)
03362   {
03363 
03364 #ifdef SELDON_CHECK_DIMENSIONS
03365     CheckDim(A, X, "Solve(status, diag, M, X)");
03366 #endif
03367 
03368     cblas_ztrsv(CblasColMajor, CblasUpper, TransA, DiagA,
03369                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
03370                 A.GetM(), reinterpret_cast<void*>(X.GetData()), 1);
03371   }
03372 
03373 
03374   /*** ColLoTriang, NoTrans and NonUnit ***/
03375 
03376 
03377   template <class Prop0, class Allocator0,
03378             class Allocator1>
03379   void Solve(const Matrix<float, Prop0, ColLoTriang, Allocator0>& A,
03380              Vector<float, VectFull, Allocator1>& X)
03381   {
03382 
03383 #ifdef SELDON_CHECK_DIMENSIONS
03384     CheckDim(A, X, "Solve(M, X)");
03385 #endif
03386 
03387     cblas_strsv(CblasColMajor, CblasLower, CblasNoTrans, CblasNonUnit,
03388                 A.GetN(), A.GetData(), A.GetM(), X.GetData(), 1);
03389   }
03390 
03391 
03392   template <class Prop0, class Allocator0,
03393             class Allocator1>
03394   void Solve(const Matrix<double, Prop0, ColLoTriang, Allocator0>& A,
03395              Vector<double, VectFull, Allocator1>& X)
03396   {
03397 
03398 #ifdef SELDON_CHECK_DIMENSIONS
03399     CheckDim(A, X, "Solve(M, X)");
03400 #endif
03401 
03402     cblas_dtrsv(CblasColMajor, CblasLower, CblasNoTrans, CblasNonUnit,
03403                 A.GetN(), A.GetData(), A.GetM(), X.GetData(), 1);
03404   }
03405 
03406 
03407   template <class Prop0, class Allocator0,
03408             class Allocator1>
03409   void
03410   Solve(const Matrix<complex<float>, Prop0, ColLoTriang, Allocator0>& A,
03411         Vector<complex<float>, VectFull, Allocator1>& X)
03412   {
03413 
03414 #ifdef SELDON_CHECK_DIMENSIONS
03415     CheckDim(A, X, "Solve(M, X)");
03416 #endif
03417 
03418     cblas_ctrsv(CblasColMajor, CblasLower, CblasNoTrans, CblasNonUnit,
03419                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
03420                 A.GetM(), reinterpret_cast<void*>(X.GetData()), 1);
03421   }
03422 
03423 
03424   template <class Prop0, class Allocator0,
03425             class Allocator1>
03426   void
03427   Solve(const Matrix<complex<double>, Prop0,
03428         ColLoTriang, Allocator0>& A,
03429         Vector<complex<double>, VectFull, Allocator1>& X)
03430   {
03431 
03432 #ifdef SELDON_CHECK_DIMENSIONS
03433     CheckDim(A, X, "Solve(M, X)");
03434 #endif
03435 
03436     cblas_ztrsv(CblasColMajor, CblasLower, CblasNoTrans, CblasNonUnit,
03437                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
03438                 A.GetM(), reinterpret_cast<void*>(X.GetData()), 1);
03439   }
03440 
03441 
03442   /*** ColLoTriang ***/
03443 
03444 
03445   template <class Prop0, class Allocator0,
03446             class Allocator1>
03447   void Solve(const SeldonTranspose& TransA,
03448              const SeldonDiag& DiagA,
03449              const Matrix<float, Prop0, ColLoTriang, Allocator0>& A,
03450              Vector<float, VectFull, Allocator1>& X)
03451   {
03452 
03453 #ifdef SELDON_CHECK_DIMENSIONS
03454     CheckDim(A, X, "Solve(status, uplo, M, X)");
03455 #endif
03456 
03457     cblas_strsv(CblasColMajor, CblasLower, TransA, DiagA,
03458                 A.GetN(), A.GetData(), A.GetM(), X.GetData(), 1);
03459   }
03460 
03461 
03462   template <class Prop0, class Allocator0,
03463             class Allocator1>
03464   void Solve(const SeldonTranspose& TransA,
03465              const SeldonDiag& DiagA,
03466              const Matrix<double, Prop0, ColLoTriang, Allocator0>& A,
03467              Vector<double, VectFull, Allocator1>& X)
03468   {
03469 
03470 #ifdef SELDON_CHECK_DIMENSIONS
03471     CheckDim(A, X, "Solve(status, uplo, M, X)");
03472 #endif
03473 
03474     cblas_dtrsv(CblasColMajor, CblasLower, TransA, DiagA,
03475                 A.GetN(), A.GetData(), A.GetM(), X.GetData(), 1);
03476   }
03477 
03478 
03479   template <class Prop0, class Allocator0,
03480             class Allocator1>
03481   void
03482   Solve(const SeldonTranspose& TransA,
03483         const SeldonDiag& DiagA,
03484         const Matrix<complex<float>, Prop0, ColLoTriang, Allocator0>& A,
03485         Vector<complex<float>, VectFull, Allocator1>& X)
03486   {
03487 
03488 #ifdef SELDON_CHECK_DIMENSIONS
03489     CheckDim(A, X, "Solve(status, uplo, M, X)");
03490 #endif
03491 
03492     cblas_ctrsv(CblasColMajor, CblasLower, TransA, DiagA,
03493                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
03494                 A.GetM(), reinterpret_cast<void*>(X.GetData()), 1);
03495   }
03496 
03497 
03498   template <class Prop0, class Allocator0,
03499             class Allocator1>
03500   void
03501   Solve(const SeldonTranspose& TransA,
03502         const SeldonDiag& DiagA,
03503         const Matrix<complex<double>, Prop0,
03504         ColLoTriang, Allocator0>& A,
03505         Vector<complex<double>, VectFull, Allocator1>& X)
03506   {
03507 
03508 #ifdef SELDON_CHECK_DIMENSIONS
03509     CheckDim(A, X, "Solve(status, uplo, M, X)");
03510 #endif
03511 
03512     cblas_ztrsv(CblasColMajor, CblasLower, TransA, DiagA,
03513                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
03514                 A.GetM(), reinterpret_cast<void*>(X.GetData()), 1);
03515   }
03516 
03517 
03518   /*** RowUpTriang, NoTrans and NonUnit ***/
03519 
03520 
03521   template <class Prop0, class Allocator0,
03522             class Allocator1>
03523   void Solve(const Matrix<float, Prop0, RowUpTriang, Allocator0>& A,
03524              Vector<float, VectFull, Allocator1>& X)
03525   {
03526 
03527 #ifdef SELDON_CHECK_DIMENSIONS
03528     CheckDim(A, X, "Solve(M, X)");
03529 #endif
03530 
03531     cblas_strsv(CblasRowMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
03532                 A.GetN(), A.GetData(), A.GetM(), X.GetData(), 1);
03533   }
03534 
03535 
03536   template <class Prop0, class Allocator0,
03537             class Allocator1>
03538   void Solve(const Matrix<double, Prop0, RowUpTriang, Allocator0>& A,
03539              Vector<double, VectFull, Allocator1>& X)
03540   {
03541 
03542 #ifdef SELDON_CHECK_DIMENSIONS
03543     CheckDim(A, X, "Solve(M, X)");
03544 #endif
03545 
03546     cblas_dtrsv(CblasRowMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
03547                 A.GetN(), A.GetData(), A.GetM(), X.GetData(), 1);
03548   }
03549 
03550 
03551   template <class Prop0, class Allocator0,
03552             class Allocator1>
03553   void
03554   Solve(const Matrix<complex<float>, Prop0, RowUpTriang, Allocator0>& A,
03555         Vector<complex<float>, VectFull, Allocator1>& X)
03556   {
03557 
03558 #ifdef SELDON_CHECK_DIMENSIONS
03559     CheckDim(A, X, "Solve(M, X)");
03560 #endif
03561 
03562     cblas_ctrsv(CblasRowMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
03563                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
03564                 A.GetM(), reinterpret_cast<void*>(X.GetData()), 1);
03565   }
03566 
03567 
03568   template <class Prop0, class Allocator0,
03569             class Allocator1>
03570   void
03571   Solve(const Matrix<complex<double>, Prop0,
03572         RowUpTriang, Allocator0>& A,
03573         Vector<complex<double>, VectFull, Allocator1>& X)
03574   {
03575 
03576 #ifdef SELDON_CHECK_DIMENSIONS
03577     CheckDim(A, X, "Solve(M, X)");
03578 #endif
03579 
03580     cblas_ztrsv(CblasRowMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
03581                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
03582                 A.GetM(), reinterpret_cast<void*>(X.GetData()), 1);
03583   }
03584 
03585 
03586   /*** RowUpTriang ***/
03587 
03588 
03589   template <class Prop0, class Allocator0,
03590             class Allocator1>
03591   void Solve(const SeldonTranspose& TransA,
03592              const SeldonDiag& DiagA,
03593              const Matrix<float, Prop0, RowUpTriang, Allocator0>& A,
03594              Vector<float, VectFull, Allocator1>& X)
03595   {
03596 
03597 #ifdef SELDON_CHECK_DIMENSIONS
03598     CheckDim(A, X, "Solve(status, diag, M, X)");
03599 #endif
03600 
03601     cblas_strsv(CblasRowMajor, CblasUpper, TransA, DiagA,
03602                 A.GetN(), A.GetData(), A.GetM(), X.GetData(), 1);
03603   }
03604 
03605 
03606   template <class Prop0, class Allocator0,
03607             class Allocator1>
03608   void Solve(const SeldonTranspose& TransA,
03609              const SeldonDiag& DiagA,
03610              const Matrix<double, Prop0, RowUpTriang, Allocator0>& A,
03611              Vector<double, VectFull, Allocator1>& X)
03612   {
03613 
03614 #ifdef SELDON_CHECK_DIMENSIONS
03615     CheckDim(A, X, "Solve(status, diag, M, X)");
03616 #endif
03617 
03618     cblas_dtrsv(CblasRowMajor, CblasUpper, TransA, DiagA,
03619                 A.GetN(), A.GetData(), A.GetM(), X.GetData(), 1);
03620   }
03621 
03622 
03623   template <class Prop0, class Allocator0,
03624             class Allocator1>
03625   void
03626   Solve(const SeldonTranspose& TransA,
03627         const SeldonDiag& DiagA,
03628         const Matrix<complex<float>, Prop0, RowUpTriang, Allocator0>& A,
03629         Vector<complex<float>, VectFull, Allocator1>& X)
03630   {
03631 
03632 #ifdef SELDON_CHECK_DIMENSIONS
03633     CheckDim(A, X, "Solve(status, diag, M, X)");
03634 #endif
03635 
03636     cblas_ctrsv(CblasRowMajor, CblasUpper, TransA, DiagA,
03637                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
03638                 A.GetM(), reinterpret_cast<void*>(X.GetData()), 1);
03639   }
03640 
03641 
03642   template <class Prop0, class Allocator0,
03643             class Allocator1>
03644   void
03645   Solve(const SeldonTranspose& TransA,
03646         const SeldonDiag& DiagA,
03647         const Matrix<complex<double>, Prop0,
03648         RowUpTriang, Allocator0>& A,
03649         Vector<complex<double>, VectFull, Allocator1>& X)
03650   {
03651 
03652 #ifdef SELDON_CHECK_DIMENSIONS
03653     CheckDim(A, X, "Solve(status, diag, M, X)");
03654 #endif
03655 
03656     cblas_ztrsv(CblasRowMajor, CblasUpper, TransA, DiagA,
03657                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
03658                 A.GetM(), reinterpret_cast<void*>(X.GetData()), 1);
03659   }
03660 
03661 
03662   /*** RowLoTriang, NoTrans and NonUnit ***/
03663 
03664 
03665   template <class Prop0, class Allocator0,
03666             class Allocator1>
03667   void Solve(const Matrix<float, Prop0, RowLoTriang, Allocator0>& A,
03668              Vector<float, VectFull, Allocator1>& X)
03669   {
03670 
03671 #ifdef SELDON_CHECK_DIMENSIONS
03672     CheckDim(A, X, "Solve(M, X)");
03673 #endif
03674 
03675     cblas_strsv(CblasRowMajor, CblasLower, CblasNoTrans, CblasNonUnit,
03676                 A.GetN(), A.GetData(), A.GetM(), X.GetData(), 1);
03677   }
03678 
03679 
03680   template <class Prop0, class Allocator0,
03681             class Allocator1>
03682   void Solve(const Matrix<double, Prop0, RowLoTriang, Allocator0>& A,
03683              Vector<double, VectFull, Allocator1>& X)
03684   {
03685 
03686 #ifdef SELDON_CHECK_DIMENSIONS
03687     CheckDim(A, X, "Solve(M, X)");
03688 #endif
03689 
03690     cblas_dtrsv(CblasRowMajor, CblasLower, CblasNoTrans, CblasNonUnit,
03691                 A.GetN(), A.GetData(), A.GetM(), X.GetData(), 1);
03692   }
03693 
03694 
03695   template <class Prop0, class Allocator0,
03696             class Allocator1>
03697   void
03698   Solve(const Matrix<complex<float>, Prop0, RowLoTriang, Allocator0>& A,
03699         Vector<complex<float>, VectFull, Allocator1>& X)
03700   {
03701 
03702 #ifdef SELDON_CHECK_DIMENSIONS
03703     CheckDim(A, X, "Solve(M, X)");
03704 #endif
03705 
03706     cblas_ctrsv(CblasRowMajor, CblasLower, CblasNoTrans, CblasNonUnit,
03707                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
03708                 A.GetM(), reinterpret_cast<void*>(X.GetData()), 1);
03709   }
03710 
03711 
03712   template <class Prop0, class Allocator0,
03713             class Allocator1>
03714   void
03715   Solve(const Matrix<complex<double>, Prop0,
03716         RowLoTriang, Allocator0>& A,
03717         Vector<complex<double>, VectFull, Allocator1>& X)
03718   {
03719 
03720 #ifdef SELDON_CHECK_DIMENSIONS
03721     CheckDim(A, X, "Solve(M, X)");
03722 #endif
03723 
03724     cblas_ztrsv(CblasRowMajor, CblasLower, CblasNoTrans, CblasNonUnit,
03725                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
03726                 A.GetM(), reinterpret_cast<void*>(X.GetData()), 1);
03727   }
03728 
03729 
03730   /*** RowLoTriang ***/
03731 
03732 
03733   template <class Prop0, class Allocator0,
03734             class Allocator1>
03735   void Solve(const SeldonTranspose& TransA,
03736              const SeldonDiag& DiagA,
03737              const Matrix<float, Prop0, RowLoTriang, Allocator0>& A,
03738              Vector<float, VectFull, Allocator1>& X)
03739   {
03740 
03741 #ifdef SELDON_CHECK_DIMENSIONS
03742     CheckDim(A, X, "Solve(status, diag, M, X)");
03743 #endif
03744 
03745     cblas_strsv(CblasRowMajor, CblasLower, TransA, DiagA,
03746                 A.GetN(), A.GetData(), A.GetM(), X.GetData(), 1);
03747   }
03748 
03749 
03750   template <class Prop0, class Allocator0,
03751             class Allocator1>
03752   void Solve(const SeldonTranspose& TransA,
03753              const SeldonDiag& DiagA,
03754              const Matrix<double, Prop0, RowLoTriang, Allocator0>& A,
03755              Vector<double, VectFull, Allocator1>& X)
03756   {
03757 
03758 #ifdef SELDON_CHECK_DIMENSIONS
03759     CheckDim(A, X, "Solve(status, diag, M, X)");
03760 #endif
03761 
03762     cblas_dtrsv(CblasRowMajor, CblasLower, TransA, DiagA,
03763                 A.GetN(), A.GetData(), A.GetM(), X.GetData(), 1);
03764   }
03765 
03766 
03767   template <class Prop0, class Allocator0,
03768             class Allocator1>
03769   void
03770   Solve(const SeldonTranspose& TransA,
03771         const SeldonDiag& DiagA,
03772         const Matrix<complex<float>, Prop0, RowLoTriang, Allocator0>& A,
03773         Vector<complex<float>, VectFull, Allocator1>& X)
03774   {
03775 
03776 #ifdef SELDON_CHECK_DIMENSIONS
03777     CheckDim(A, X, "Solve(status, diag, M, X)");
03778 #endif
03779 
03780     cblas_ctrsv(CblasRowMajor, CblasLower, TransA, DiagA,
03781                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
03782                 A.GetM(), reinterpret_cast<void*>(X.GetData()), 1);
03783   }
03784 
03785 
03786   template <class Prop0, class Allocator0,
03787             class Allocator1>
03788   void
03789   Solve(const SeldonTranspose& TransA,
03790         const SeldonDiag& DiagA,
03791         const Matrix<complex<double>, Prop0,
03792         RowLoTriang, Allocator0>& A,
03793         Vector<complex<double>, VectFull, Allocator1>& X)
03794   {
03795 
03796 #ifdef SELDON_CHECK_DIMENSIONS
03797     CheckDim(A, X, "Solve(status, diag, M, X)");
03798 #endif
03799 
03800     cblas_ztrsv(CblasRowMajor, CblasLower, TransA, DiagA,
03801                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
03802                 A.GetM(), reinterpret_cast<void*>(X.GetData()), 1);
03803   }
03804 
03805 
03806   /*** ColUpTriangPacked, NoTrans and NonUnit ***/
03807 
03808 
03809   template <class Prop0, class Allocator0,
03810             class Allocator1>
03811   void Solve(const Matrix<float, Prop0, ColUpTriangPacked, Allocator0>& A,
03812              Vector<float, VectFull, Allocator1>& X)
03813   {
03814 
03815 #ifdef SELDON_CHECK_DIMENSIONS
03816     CheckDim(A, X, "Solve(M, X)");
03817 #endif
03818 
03819     cblas_stpsv(CblasColMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
03820                 A.GetN(), A.GetData(), X.GetData(), 1);
03821   }
03822 
03823 
03824   template <class Prop0, class Allocator0,
03825             class Allocator1>
03826   void Solve(const Matrix<double, Prop0, ColUpTriangPacked, Allocator0>& A,
03827              Vector<double, VectFull, Allocator1>& X)
03828   {
03829 
03830 #ifdef SELDON_CHECK_DIMENSIONS
03831     CheckDim(A, X, "Solve(M, X)");
03832 #endif
03833 
03834     cblas_dtpsv(CblasColMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
03835                 A.GetN(), A.GetData(), X.GetData(), 1);
03836   }
03837 
03838 
03839   template <class Prop0, class Allocator0,
03840             class Allocator1>
03841   void
03842   Solve(const Matrix<complex<float>, Prop0, ColUpTriangPacked, Allocator0>& A,
03843         Vector<complex<float>, VectFull, Allocator1>& X)
03844   {
03845 
03846 #ifdef SELDON_CHECK_DIMENSIONS
03847     CheckDim(A, X, "Solve(M, X)");
03848 #endif
03849 
03850     cblas_ctpsv(CblasColMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
03851                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
03852                 reinterpret_cast<void*>(X.GetData()), 1);
03853   }
03854 
03855 
03856   template <class Prop0, class Allocator0,
03857             class Allocator1>
03858   void
03859   Solve(const Matrix<complex<double>, Prop0,
03860         ColUpTriangPacked, Allocator0>& A,
03861         Vector<complex<double>, VectFull, Allocator1>& X)
03862   {
03863 
03864 #ifdef SELDON_CHECK_DIMENSIONS
03865     CheckDim(A, X, "Solve(M, X)");
03866 #endif
03867 
03868     cblas_ztpsv(CblasColMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
03869                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
03870                 reinterpret_cast<void*>(X.GetData()), 1);
03871   }
03872 
03873 
03874   /*** ColUpTriangPacked ***/
03875 
03876 
03877   template <class Prop0, class Allocator0,
03878             class Allocator1>
03879   void Solve(const SeldonTranspose& TransA,
03880              const SeldonDiag& DiagA,
03881              const Matrix<float, Prop0, ColUpTriangPacked, Allocator0>& A,
03882              Vector<float, VectFull, Allocator1>& X)
03883   {
03884 
03885 #ifdef SELDON_CHECK_DIMENSIONS
03886     CheckDim(A, X, "Solve(status, diag, M, X)");
03887 #endif
03888 
03889     cblas_stpsv(CblasColMajor, CblasUpper, TransA, DiagA,
03890                 A.GetN(), A.GetData(), X.GetData(), 1);
03891   }
03892 
03893 
03894   template <class Prop0, class Allocator0,
03895             class Allocator1>
03896   void Solve(const SeldonTranspose& TransA,
03897              const SeldonDiag& DiagA,
03898              const Matrix<double, Prop0, ColUpTriangPacked, Allocator0>& A,
03899              Vector<double, VectFull, Allocator1>& X)
03900   {
03901 
03902 #ifdef SELDON_CHECK_DIMENSIONS
03903     CheckDim(A, X, "Solve(status, diag, M, X)");
03904 #endif
03905 
03906     cblas_dtpsv(CblasColMajor, CblasUpper, TransA, DiagA,
03907                 A.GetN(), A.GetData(), X.GetData(), 1);
03908   }
03909 
03910 
03911   template <class Prop0, class Allocator0,
03912             class Allocator1>
03913   void
03914   Solve(const SeldonTranspose& TransA,
03915         const SeldonDiag& DiagA,
03916         const Matrix<complex<float>, Prop0, ColUpTriangPacked, Allocator0>& A,
03917         Vector<complex<float>, VectFull, Allocator1>& X)
03918   {
03919 
03920 #ifdef SELDON_CHECK_DIMENSIONS
03921     CheckDim(A, X, "Solve(status, diag, M, X)");
03922 #endif
03923 
03924     cblas_ctpsv(CblasColMajor, CblasUpper, TransA, DiagA,
03925                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
03926                 reinterpret_cast<void*>(X.GetData()), 1);
03927   }
03928 
03929 
03930   template <class Prop0, class Allocator0,
03931             class Allocator1>
03932   void
03933   Solve(const SeldonTranspose& TransA,
03934         const SeldonDiag& DiagA,
03935         const Matrix<complex<double>, Prop0,
03936         ColUpTriangPacked, Allocator0>& A,
03937         Vector<complex<double>, VectFull, Allocator1>& X)
03938   {
03939 
03940 #ifdef SELDON_CHECK_DIMENSIONS
03941     CheckDim(A, X, "Solve(status, diag, M, X)");
03942 #endif
03943 
03944     cblas_ztpsv(CblasColMajor, CblasUpper, TransA, DiagA,
03945                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
03946                 reinterpret_cast<void*>(X.GetData()), 1);
03947   }
03948 
03949 
03950   /*** ColLoTriangPacked, NoTrans and NonUnit ***/
03951 
03952 
03953   template <class Prop0, class Allocator0,
03954             class Allocator1>
03955   void Solve(const Matrix<float, Prop0, ColLoTriangPacked, Allocator0>& A,
03956              Vector<float, VectFull, Allocator1>& X)
03957   {
03958 
03959 #ifdef SELDON_CHECK_DIMENSIONS
03960     CheckDim(A, X, "Solve(M, X)");
03961 #endif
03962 
03963     cblas_stpsv(CblasColMajor, CblasLower, CblasNoTrans, CblasNonUnit,
03964                 A.GetN(), A.GetData(), X.GetData(), 1);
03965   }
03966 
03967 
03968   template <class Prop0, class Allocator0,
03969             class Allocator1>
03970   void Solve(const Matrix<double, Prop0, ColLoTriangPacked, Allocator0>& A,
03971              Vector<double, VectFull, Allocator1>& X)
03972   {
03973 
03974 #ifdef SELDON_CHECK_DIMENSIONS
03975     CheckDim(A, X, "Solve(M, X)");
03976 #endif
03977 
03978     cblas_dtpsv(CblasColMajor, CblasLower, CblasNoTrans, CblasNonUnit,
03979                 A.GetN(), A.GetData(), X.GetData(), 1);
03980   }
03981 
03982 
03983   template <class Prop0, class Allocator0,
03984             class Allocator1>
03985   void
03986   Solve(const Matrix<complex<float>, Prop0, ColLoTriangPacked, Allocator0>& A,
03987         Vector<complex<float>, VectFull, Allocator1>& X)
03988   {
03989 
03990 #ifdef SELDON_CHECK_DIMENSIONS
03991     CheckDim(A, X, "Solve(M, X)");
03992 #endif
03993 
03994     cblas_ctpsv(CblasColMajor, CblasLower, CblasNoTrans, CblasNonUnit,
03995                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
03996                 reinterpret_cast<void*>(X.GetData()), 1);
03997   }
03998 
03999 
04000   template <class Prop0, class Allocator0,
04001             class Allocator1>
04002   void
04003   Solve(const Matrix<complex<double>, Prop0,
04004         ColLoTriangPacked, Allocator0>& A,
04005         Vector<complex<double>, VectFull, Allocator1>& X)
04006   {
04007 
04008 #ifdef SELDON_CHECK_DIMENSIONS
04009     CheckDim(A, X, "Solve(M, X)");
04010 #endif
04011 
04012     cblas_ztpsv(CblasColMajor, CblasLower, CblasNoTrans, CblasNonUnit,
04013                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
04014                 reinterpret_cast<void*>(X.GetData()), 1);
04015   }
04016 
04017 
04018   /*** ColLoTriangPacked ***/
04019 
04020 
04021   template <class Prop0, class Allocator0,
04022             class Allocator1>
04023   void Solve(const SeldonTranspose& TransA,
04024              const SeldonDiag& DiagA,
04025              const Matrix<float, Prop0, ColLoTriangPacked, Allocator0>& A,
04026              Vector<float, VectFull, Allocator1>& X)
04027   {
04028 
04029 #ifdef SELDON_CHECK_DIMENSIONS
04030     CheckDim(A, X, "Solve(status, diag, M, X)");
04031 #endif
04032 
04033     cblas_stpsv(CblasColMajor, CblasLower, TransA, DiagA,
04034                 A.GetN(), A.GetData(), X.GetData(), 1);
04035   }
04036 
04037 
04038   template <class Prop0, class Allocator0,
04039             class Allocator1>
04040   void Solve(const SeldonTranspose& TransA,
04041              const SeldonDiag& DiagA,
04042              const Matrix<double, Prop0, ColLoTriangPacked, Allocator0>& A,
04043              Vector<double, VectFull, Allocator1>& X)
04044   {
04045 
04046 #ifdef SELDON_CHECK_DIMENSIONS
04047     CheckDim(A, X, "Solve(status, diag, M, X)");
04048 #endif
04049 
04050     cblas_dtpsv(CblasColMajor, CblasLower, TransA, DiagA,
04051                 A.GetN(), A.GetData(), X.GetData(), 1);
04052   }
04053 
04054 
04055   template <class Prop0, class Allocator0,
04056             class Allocator1>
04057   void
04058   Solve(const SeldonTranspose& TransA,
04059         const SeldonDiag& DiagA,
04060         const Matrix<complex<float>, Prop0, ColLoTriangPacked, Allocator0>& A,
04061         Vector<complex<float>, VectFull, Allocator1>& X)
04062   {
04063 
04064 #ifdef SELDON_CHECK_DIMENSIONS
04065     CheckDim(A, X, "Solve(status, diag, M, X)");
04066 #endif
04067 
04068     cblas_ctpsv(CblasColMajor, CblasLower, TransA, DiagA,
04069                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
04070                 reinterpret_cast<void*>(X.GetData()), 1);
04071   }
04072 
04073 
04074   template <class Prop0, class Allocator0,
04075             class Allocator1>
04076   void
04077   Solve(const SeldonTranspose& TransA,
04078         const SeldonDiag& DiagA,
04079         const Matrix<complex<double>, Prop0,
04080         ColLoTriangPacked, Allocator0>& A,
04081         Vector<complex<double>, VectFull, Allocator1>& X)
04082   {
04083 
04084 #ifdef SELDON_CHECK_DIMENSIONS
04085     CheckDim(A, X, "Solve(status, diag, M, X)");
04086 #endif
04087 
04088     cblas_ztpsv(CblasColMajor, CblasLower, TransA, DiagA,
04089                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
04090                 reinterpret_cast<void*>(X.GetData()), 1);
04091   }
04092 
04093 
04094   /*** RowUpTriangPacked, NoTrans and NonUnit ***/
04095 
04096 
04097   template <class Prop0, class Allocator0,
04098             class Allocator1>
04099   void Solve(const Matrix<float, Prop0, RowUpTriangPacked, Allocator0>& A,
04100              Vector<float, VectFull, Allocator1>& X)
04101   {
04102 
04103 #ifdef SELDON_CHECK_DIMENSIONS
04104     CheckDim(A, X, "Solve(M, X)");
04105 #endif
04106 
04107     cblas_stpsv(CblasRowMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
04108                 A.GetN(), A.GetData(), X.GetData(), 1);
04109   }
04110 
04111 
04112   template <class Prop0, class Allocator0,
04113             class Allocator1>
04114   void Solve(const Matrix<double, Prop0, RowUpTriangPacked, Allocator0>& A,
04115              Vector<double, VectFull, Allocator1>& X)
04116   {
04117 
04118 #ifdef SELDON_CHECK_DIMENSIONS
04119     CheckDim(A, X, "Solve(M, X)");
04120 #endif
04121 
04122     cblas_dtpsv(CblasRowMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
04123                 A.GetN(), A.GetData(), X.GetData(), 1);
04124   }
04125 
04126 
04127   template <class Prop0, class Allocator0,
04128             class Allocator1>
04129   void
04130   Solve(const Matrix<complex<float>, Prop0, RowUpTriangPacked, Allocator0>& A,
04131         Vector<complex<float>, VectFull, Allocator1>& X)
04132   {
04133 
04134 #ifdef SELDON_CHECK_DIMENSIONS
04135     CheckDim(A, X, "Solve(M, X)");
04136 #endif
04137 
04138     cblas_ctpsv(CblasRowMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
04139                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
04140                 reinterpret_cast<void*>(X.GetData()), 1);
04141   }
04142 
04143 
04144   template <class Prop0, class Allocator0,
04145             class Allocator1>
04146   void
04147   Solve(const Matrix<complex<double>, Prop0,
04148         RowUpTriangPacked, Allocator0>& A,
04149         Vector<complex<double>, VectFull, Allocator1>& X)
04150   {
04151 
04152 #ifdef SELDON_CHECK_DIMENSIONS
04153     CheckDim(A, X, "Solve(M, X)");
04154 #endif
04155 
04156     cblas_ztpsv(CblasRowMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
04157                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
04158                 reinterpret_cast<void*>(X.GetData()), 1);
04159   }
04160 
04161 
04162   /*** RowUpTriangPacked ***/
04163 
04164 
04165   template <class Prop0, class Allocator0,
04166             class Allocator1>
04167   void Solve(const SeldonTranspose& TransA,
04168              const SeldonDiag& DiagA,
04169              const Matrix<float, Prop0, RowUpTriangPacked, Allocator0>& A,
04170              Vector<float, VectFull, Allocator1>& X)
04171   {
04172 
04173 #ifdef SELDON_CHECK_DIMENSIONS
04174     CheckDim(A, X, "Solve(status, diag, M, X)");
04175 #endif
04176 
04177     cblas_stpsv(CblasRowMajor, CblasUpper, TransA, DiagA,
04178                 A.GetN(), A.GetData(), X.GetData(), 1);
04179   }
04180 
04181 
04182   template <class Prop0, class Allocator0,
04183             class Allocator1>
04184   void Solve(const SeldonTranspose& TransA,
04185              const SeldonDiag& DiagA,
04186              const Matrix<double, Prop0, RowUpTriangPacked, Allocator0>& A,
04187              Vector<double, VectFull, Allocator1>& X)
04188   {
04189 
04190 #ifdef SELDON_CHECK_DIMENSIONS
04191     CheckDim(A, X, "Solve(status, diag, M, X)");
04192 #endif
04193 
04194     cblas_dtpsv(CblasRowMajor, CblasUpper, TransA, DiagA,
04195                 A.GetN(), A.GetData(), X.GetData(), 1);
04196   }
04197 
04198 
04199   template <class Prop0, class Allocator0,
04200             class Allocator1>
04201   void
04202   Solve(const SeldonTranspose& TransA,
04203         const SeldonDiag& DiagA,
04204         const Matrix<complex<float>, Prop0, RowUpTriangPacked, Allocator0>& A,
04205         Vector<complex<float>, VectFull, Allocator1>& X)
04206   {
04207 
04208 #ifdef SELDON_CHECK_DIMENSIONS
04209     CheckDim(A, X, "Solve(status, diag, M, X)");
04210 #endif
04211 
04212     cblas_ctpsv(CblasRowMajor, CblasUpper, TransA, DiagA,
04213                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
04214                 reinterpret_cast<void*>(X.GetData()), 1);
04215   }
04216 
04217 
04218   template <class Prop0, class Allocator0,
04219             class Allocator1>
04220   void
04221   Solve(const SeldonTranspose& TransA,
04222         const SeldonDiag& DiagA,
04223         const Matrix<complex<double>, Prop0,
04224         RowUpTriangPacked, Allocator0>& A,
04225         Vector<complex<double>, VectFull, Allocator1>& X)
04226   {
04227 
04228 #ifdef SELDON_CHECK_DIMENSIONS
04229     CheckDim(A, X, "Solve(status, diag, M, X)");
04230 #endif
04231 
04232     cblas_ztpsv(CblasRowMajor, CblasUpper, TransA, DiagA,
04233                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
04234                 reinterpret_cast<void*>(X.GetData()), 1);
04235   }
04236 
04237 
04238   /*** RowLoTriangPacked, NoTrans and NonUnit ***/
04239 
04240 
04241   template <class Prop0, class Allocator0,
04242             class Allocator1>
04243   void Solve(const Matrix<float, Prop0, RowLoTriangPacked, Allocator0>& A,
04244              Vector<float, VectFull, Allocator1>& X)
04245   {
04246 
04247 #ifdef SELDON_CHECK_DIMENSIONS
04248     CheckDim(A, X, "Solve(M, X)");
04249 #endif
04250 
04251     cblas_stpsv(CblasRowMajor, CblasLower, CblasNoTrans, CblasNonUnit,
04252                 A.GetN(), A.GetData(), X.GetData(), 1);
04253   }
04254 
04255 
04256   template <class Prop0, class Allocator0,
04257             class Allocator1>
04258   void Solve(const Matrix<double, Prop0, RowLoTriangPacked, Allocator0>& A,
04259              Vector<double, VectFull, Allocator1>& X)
04260   {
04261 
04262 #ifdef SELDON_CHECK_DIMENSIONS
04263     CheckDim(A, X, "Solve(M, X)");
04264 #endif
04265 
04266     cblas_dtpsv(CblasRowMajor, CblasLower, CblasNoTrans, CblasNonUnit,
04267                 A.GetN(), A.GetData(), X.GetData(), 1);
04268   }
04269 
04270 
04271   template <class Prop0, class Allocator0,
04272             class Allocator1>
04273   void
04274   Solve(const Matrix<complex<float>, Prop0, RowLoTriangPacked, Allocator0>& A,
04275         Vector<complex<float>, VectFull, Allocator1>& X)
04276   {
04277 
04278 #ifdef SELDON_CHECK_DIMENSIONS
04279     CheckDim(A, X, "Solve(M, X)");
04280 #endif
04281 
04282     cblas_ctpsv(CblasRowMajor, CblasLower, CblasNoTrans, CblasNonUnit,
04283                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
04284                 reinterpret_cast<void*>(X.GetData()), 1);
04285   }
04286 
04287 
04288   template <class Prop0, class Allocator0,
04289             class Allocator1>
04290   void
04291   Solve(const Matrix<complex<double>, Prop0,
04292         RowLoTriangPacked, Allocator0>& A,
04293         Vector<complex<double>, VectFull, Allocator1>& X)
04294   {
04295 
04296 #ifdef SELDON_CHECK_DIMENSIONS
04297     CheckDim(A, X, "Solve(M, X)");
04298 #endif
04299 
04300     cblas_ztpsv(CblasRowMajor, CblasLower, CblasNoTrans, CblasNonUnit,
04301                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
04302                 reinterpret_cast<void*>(X.GetData()), 1);
04303   }
04304 
04305 
04306   /*** RowLoTriangPacked ***/
04307 
04308 
04309   template <class Prop0, class Allocator0,
04310             class Allocator1>
04311   void Solve(const SeldonTranspose& TransA,
04312              const SeldonDiag& DiagA,
04313              const Matrix<float, Prop0, RowLoTriangPacked, Allocator0>& A,
04314              Vector<float, VectFull, Allocator1>& X)
04315   {
04316 
04317 #ifdef SELDON_CHECK_DIMENSIONS
04318     CheckDim(A, X, "Solve(status, diag, M, X)");
04319 #endif
04320 
04321     cblas_stpsv(CblasRowMajor, CblasLower, TransA, DiagA,
04322                 A.GetN(), A.GetData(), X.GetData(), 1);
04323   }
04324 
04325 
04326   template <class Prop0, class Allocator0,
04327             class Allocator1>
04328   void Solve(const SeldonTranspose& TransA,
04329              const SeldonDiag& DiagA,
04330              const Matrix<double, Prop0, RowLoTriangPacked, Allocator0>& A,
04331              Vector<double, VectFull, Allocator1>& X)
04332   {
04333 
04334 #ifdef SELDON_CHECK_DIMENSIONS
04335     CheckDim(A, X, "Solve(status, diag, M, X)");
04336 #endif
04337 
04338     cblas_dtpsv(CblasRowMajor, CblasLower, TransA, DiagA,
04339                 A.GetN(), A.GetData(), X.GetData(), 1);
04340   }
04341 
04342 
04343   template <class Prop0, class Allocator0,
04344             class Allocator1>
04345   void
04346   Solve(const SeldonTranspose& TransA,
04347         const SeldonDiag& DiagA,
04348         const Matrix<complex<float>, Prop0, RowLoTriangPacked, Allocator0>& A,
04349         Vector<complex<float>, VectFull, Allocator1>& X)
04350   {
04351 
04352 #ifdef SELDON_CHECK_DIMENSIONS
04353     CheckDim(A, X, "Solve(status, diag, M, X)");
04354 #endif
04355 
04356     cblas_ctpsv(CblasRowMajor, CblasLower, TransA, DiagA,
04357                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
04358                 reinterpret_cast<void*>(X.GetData()), 1);
04359   }
04360 
04361 
04362   template <class Prop0, class Allocator0,
04363             class Allocator1>
04364   void
04365   Solve(const SeldonTranspose& TransA,
04366         const SeldonDiag& DiagA,
04367         const Matrix<complex<double>, Prop0,
04368         RowLoTriangPacked, Allocator0>& A,
04369         Vector<complex<double>, VectFull, Allocator1>& X)
04370   {
04371 
04372 #ifdef SELDON_CHECK_DIMENSIONS
04373     CheckDim(A, X, "Solve(status, diag, M, X)");
04374 #endif
04375 
04376     cblas_ztpsv(CblasRowMajor, CblasLower, TransA, DiagA,
04377                 A.GetN(), reinterpret_cast<const void*>(A.GetData()),
04378                 reinterpret_cast<void*>(X.GetData()), 1);
04379   }
04380 
04381 
04382   // SOLVE //
04384 
04385 
04386 } // namespace Seldon.
04387 
04388 #define SELDON_FILE_BLAS_2_CXX
04389 #endif
Email Contact