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