computation/interfaces/Blas_3.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_3_CXX
00021 
00022 /*
00023   Functions included in this file:
00024 
00025   xGEMM   (MltAdd)
00026   xSYMM   (MltAdd)
00027   xHEMM   (MltAdd)
00028   xTRMM   (Mlt)
00029   xTRSM   (Solve)
00030 */
00031 
00032 extern "C"
00033 {
00034 #include "cblas.h"
00035 }
00036 
00037 namespace Seldon
00038 {
00039 
00040 
00042   // MltAdd //
00043 
00044 
00045   /*** ColMajor and NoTrans ***/
00046 
00047 
00048   template <class Prop0, class Allocator0,
00049             class Prop1, class Allocator1,
00050             class Prop2, class Allocator2>
00051   void MltAdd(const float alpha,
00052               const Matrix<float, Prop0, ColMajor, Allocator0>& A,
00053               const Matrix<float, Prop1, ColMajor, Allocator1>& B,
00054               const float beta,
00055               Matrix<float, Prop2, ColMajor, Allocator2>& C)
00056   {
00057 
00058 #ifdef SELDON_CHECK_DIMENSIONS
00059     CheckDim(A, B, C, "MltAdd(alpha, A, B, beta, C)");
00060 #endif
00061 
00062     cblas_sgemm(CblasColMajor, CblasNoTrans, CblasNoTrans,
00063                 C.GetM(), C.GetN(), A.GetN(),
00064                 alpha, A.GetData(), A.GetLD(), B.GetData(), B.GetLD(),
00065                 beta, C.GetData(), C.GetLD());
00066   }
00067 
00068 
00069   template <class Prop0, class Allocator0,
00070             class Prop1, class Allocator1,
00071             class Prop2, class Allocator2>
00072   void MltAdd(const double alpha,
00073               const Matrix<double, Prop0, ColMajor, Allocator0>& A,
00074               const Matrix<double, Prop1, ColMajor, Allocator1>& B,
00075               const double beta,
00076               Matrix<double, Prop2, ColMajor, Allocator2>& C)
00077   {
00078 
00079 #ifdef SELDON_CHECK_DIMENSIONS
00080     CheckDim(A, B, C, "MltAdd(alpha, A, B, beta, C)");
00081 #endif
00082 
00083     cblas_dgemm(CblasColMajor, CblasNoTrans, CblasNoTrans,
00084                 C.GetM(), C.GetN(), A.GetN(),
00085                 alpha, A.GetData(), A.GetLD(), B.GetData(), B.GetLD(),
00086                 beta, C.GetData(), C.GetLD());
00087   }
00088 
00089 
00090   template <class Prop0, class Allocator0,
00091             class Prop1, class Allocator1,
00092             class Prop2, class Allocator2>
00093   void MltAdd(const complex<float> alpha,
00094               const Matrix<complex<float>, Prop0, ColMajor, Allocator0>& A,
00095               const Matrix<complex<float>, Prop1, ColMajor, Allocator1>& B,
00096               const complex<float> beta,
00097               Matrix<complex<float>, Prop2, ColMajor, Allocator2>& C)
00098   {
00099 
00100 #ifdef SELDON_CHECK_DIMENSIONS
00101     CheckDim(A, B, C, "MltAdd(alpha, A, B, beta, C)");
00102 #endif
00103 
00104     cblas_cgemm(CblasColMajor, CblasNoTrans, CblasNoTrans,
00105                 C.GetM(), C.GetN(), A.GetN(),
00106                 reinterpret_cast<const void*>(&alpha),
00107                 reinterpret_cast<const void*>(A.GetData()), A.GetLD(),
00108                 reinterpret_cast<const void*>(B.GetData()), B.GetLD(),
00109                 reinterpret_cast<const void*>(&beta),
00110                 reinterpret_cast<void*>(C.GetData()), C.GetLD());
00111   }
00112 
00113 
00114   template <class Prop0, class Allocator0,
00115             class Prop1, class Allocator1,
00116             class Prop2, class Allocator2>
00117   void MltAdd(const complex<double> alpha,
00118               const Matrix<complex<double>, Prop0, ColMajor, Allocator0>& A,
00119               const Matrix<complex<double>, Prop1, ColMajor, Allocator1>& B,
00120               const complex<double> beta,
00121               Matrix<complex<double>, Prop2, ColMajor, Allocator2>& C)
00122   {
00123 
00124 #ifdef SELDON_CHECK_DIMENSIONS
00125     CheckDim(A, B, C, "MltAdd(alpha, A, B, beta, C)");
00126 #endif
00127 
00128     cblas_zgemm(CblasColMajor, CblasNoTrans, CblasNoTrans,
00129                 C.GetM(), C.GetN(), A.GetN(),
00130                 reinterpret_cast<const void*>(&alpha),
00131                 reinterpret_cast<const void*>(A.GetData()), A.GetLD(),
00132                 reinterpret_cast<const void*>(B.GetData()), B.GetLD(),
00133                 reinterpret_cast<const void*>(&beta),
00134                 reinterpret_cast<void*>(C.GetData()), C.GetLD());
00135   }
00136 
00137 
00138   /*** ColMajor and TransA, TransB ***/
00139 
00140 
00141   template <class Prop0, class Allocator0,
00142             class Prop1, class Allocator1,
00143             class Prop2, class Allocator2>
00144   void MltAdd(const float alpha,
00145               const SeldonTranspose& TransA,
00146               const Matrix<float, Prop0, ColMajor, Allocator0>& A,
00147               const SeldonTranspose& TransB,
00148               const Matrix<float, Prop1, ColMajor, Allocator1>& B,
00149               const float beta,
00150               Matrix<float, Prop2, ColMajor, Allocator2>& C)
00151   {
00152 
00153 #ifdef SELDON_CHECK_DIMENSIONS
00154     CheckDim(TransA, A, TransB, B, C,
00155              "MltAdd(alpha, TransA, A, TransB, B, beta, C)");
00156 #endif
00157 
00158     cblas_sgemm(CblasColMajor, TransA, TransB, C.GetM(), C.GetN(),
00159                 A.GetN(TransA), alpha, A.GetData(), A.GetLD(),
00160                 B.GetData(), B.GetLD(), beta, C.GetData(), C.GetLD());
00161   }
00162 
00163 
00164   template <class Prop0, class Allocator0,
00165             class Prop1, class Allocator1,
00166             class Prop2, class Allocator2>
00167   void MltAdd(const double alpha,
00168               const SeldonTranspose& TransA,
00169               const Matrix<double, Prop0, ColMajor, Allocator0>& A,
00170               const SeldonTranspose& TransB,
00171               const Matrix<double, Prop1, ColMajor, Allocator1>& B,
00172               const double beta,
00173               Matrix<double, Prop2, ColMajor, Allocator2>& C)
00174   {
00175 
00176 #ifdef SELDON_CHECK_DIMENSIONS
00177     CheckDim(TransA, A, TransB, B, C,
00178              "MltAdd(alpha, TransA, A, TransB, B, beta, C)");
00179 #endif
00180 
00181     cblas_dgemm(CblasColMajor, TransA, TransB, C.GetM(), C.GetN(),
00182                 A.GetN(TransA), alpha, A.GetData(), A.GetLD(),
00183                 B.GetData(), B.GetLD(), beta, C.GetData(), C.GetLD());
00184   }
00185 
00186 
00187   template <class Prop0, class Allocator0,
00188             class Prop1, class Allocator1,
00189             class Prop2, class Allocator2>
00190   void MltAdd(const complex<float> alpha,
00191               const SeldonTranspose& TransA,
00192               const Matrix<complex<float>, Prop0, ColMajor, Allocator0>& A,
00193               const SeldonTranspose& TransB,
00194               const Matrix<complex<float>, Prop1, ColMajor, Allocator1>& B,
00195               const complex<float> beta,
00196               Matrix<complex<float>, Prop2, ColMajor, Allocator2>& C)
00197   {
00198 
00199 #ifdef SELDON_CHECK_DIMENSIONS
00200     CheckDim(TransA, A, TransB, B, C,
00201              "MltAdd(alpha, TransA, A, TransB, B, beta, C)");
00202 #endif
00203 
00204     cblas_cgemm(CblasColMajor, TransA, TransB, C.GetM(), C.GetN(),
00205                 A.GetN(TransA), reinterpret_cast<const void*>(&alpha),
00206                 reinterpret_cast<const void*>(A.GetData()), A.GetLD(),
00207                 reinterpret_cast<const void*>(B.GetData()), B.GetLD(),
00208                 reinterpret_cast<const void*>(&beta),
00209                 reinterpret_cast<void*>(C.GetData()), C.GetLD());
00210   }
00211 
00212 
00213   template <class Prop0, class Allocator0,
00214             class Prop1, class Allocator1,
00215             class Prop2, class Allocator2>
00216   void MltAdd(const complex<double> alpha,
00217               const SeldonTranspose& TransA,
00218               const Matrix<complex<double>, Prop0, ColMajor, Allocator0>& A,
00219               const SeldonTranspose& TransB,
00220               const Matrix<complex<double>, Prop1, ColMajor, Allocator1>& B,
00221               const complex<double> beta,
00222               Matrix<complex<double>, Prop2, ColMajor, Allocator2>& C)
00223   {
00224 
00225 #ifdef SELDON_CHECK_DIMENSIONS
00226     CheckDim(TransA, A, TransB, B, C,
00227              "MltAdd(alpha, TransA, A, TransB, B, beta, C)");
00228 #endif
00229 
00230     cblas_zgemm(CblasColMajor, TransA, TransB, C.GetM(), C.GetN(),
00231                 A.GetN(TransA), reinterpret_cast<const void*>(&alpha),
00232                 reinterpret_cast<const void*>(A.GetData()), A.GetLD(),
00233                 reinterpret_cast<const void*>(B.GetData()), B.GetLD(),
00234                 reinterpret_cast<const void*>(&beta),
00235                 reinterpret_cast<void*>(C.GetData()), C.GetLD());
00236   }
00237 
00238 
00239   /*** RowMajor and NoTrans ***/
00240 
00241 
00242   template <class Prop0, class Allocator0,
00243             class Prop1, class Allocator1,
00244             class Prop2, class Allocator2>
00245   void MltAdd(const float alpha,
00246               const Matrix<float, Prop0, RowMajor, Allocator0>& A,
00247               const Matrix<float, Prop1, RowMajor, Allocator1>& B,
00248               const float beta,
00249               Matrix<float, Prop2, RowMajor, Allocator2>& C)
00250   {
00251 
00252 #ifdef SELDON_CHECK_DIMENSIONS
00253     CheckDim(A, B, C, "MltAdd(alpha, A, B, beta, C)");
00254 #endif
00255 
00256     cblas_sgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans,
00257                 C.GetM(), C.GetN(), A.GetN(),
00258                 alpha, A.GetData(), A.GetLD(), B.GetData(), B.GetLD(),
00259                 beta, C.GetData(), C.GetLD());
00260   }
00261 
00262 
00263   template <class Prop0, class Allocator0,
00264             class Prop1, class Allocator1,
00265             class Prop2, class Allocator2>
00266   void MltAdd(const double alpha,
00267               const Matrix<double, Prop0, RowMajor, Allocator0>& A,
00268               const Matrix<double, Prop1, RowMajor, Allocator1>& B,
00269               const double beta,
00270               Matrix<double, Prop2, RowMajor, Allocator2>& C)
00271   {
00272 
00273 #ifdef SELDON_CHECK_DIMENSIONS
00274     CheckDim(A, B, C, "MltAdd(alpha, A, B, beta, C)");
00275 #endif
00276 
00277     cblas_dgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans,
00278                 C.GetM(), C.GetN(), A.GetN(),
00279                 alpha, A.GetData(), A.GetLD(), B.GetData(), B.GetLD(),
00280                 beta, C.GetData(), C.GetLD());
00281   }
00282 
00283 
00284   template <class Prop0, class Allocator0,
00285             class Prop1, class Allocator1,
00286             class Prop2, class Allocator2>
00287   void MltAdd(const complex<float> alpha,
00288               const Matrix<complex<float>, Prop0, RowMajor, Allocator0>& A,
00289               const Matrix<complex<float>, Prop1, RowMajor, Allocator1>& B,
00290               const complex<float> beta,
00291               Matrix<complex<float>, Prop2, RowMajor, Allocator2>& C)
00292   {
00293 
00294 #ifdef SELDON_CHECK_DIMENSIONS
00295     CheckDim(A, B, C, "MltAdd(alpha, A, B, beta, C)");
00296 #endif
00297 
00298     cblas_cgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans,
00299                 C.GetM(), C.GetN(), A.GetN(),
00300                 reinterpret_cast<const void*>(&alpha),
00301                 reinterpret_cast<const void*>(A.GetData()), A.GetLD(),
00302                 reinterpret_cast<const void*>(B.GetData()), B.GetLD(),
00303                 reinterpret_cast<const void*>(&beta),
00304                 reinterpret_cast<void*>(C.GetData()), C.GetLD());
00305   }
00306 
00307 
00308   template <class Prop0, class Allocator0,
00309             class Prop1, class Allocator1,
00310             class Prop2, class Allocator2>
00311   void MltAdd(const complex<double> alpha,
00312               const Matrix<complex<double>, Prop0, RowMajor, Allocator0>& A,
00313               const Matrix<complex<double>, Prop1, RowMajor, Allocator1>& B,
00314               const complex<double> beta,
00315               Matrix<complex<double>, Prop2, RowMajor, Allocator2>& C)
00316   {
00317 
00318 #ifdef SELDON_CHECK_DIMENSIONS
00319     CheckDim(A, B, C, "MltAdd(alpha, A, B, beta, C)");
00320 #endif
00321 
00322     cblas_zgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans,
00323                 C.GetM(), C.GetN(), A.GetN(),
00324                 reinterpret_cast<const void*>(&alpha),
00325                 reinterpret_cast<const void*>(A.GetData()), A.GetLD(),
00326                 reinterpret_cast<const void*>(B.GetData()), B.GetLD(),
00327                 reinterpret_cast<const void*>(&beta),
00328                 reinterpret_cast<void*>(C.GetData()), C.GetLD());
00329   }
00330 
00331 
00332   /*** RowMajor and TransA, TransB ***/
00333 
00334 
00335   template <class Prop0, class Allocator0,
00336             class Prop1, class Allocator1,
00337             class Prop2, class Allocator2>
00338   void MltAdd(const float alpha,
00339               const SeldonTranspose& TransA,
00340               const Matrix<float, Prop0, RowMajor, Allocator0>& A,
00341               const SeldonTranspose& TransB,
00342               const Matrix<float, Prop1, RowMajor, Allocator1>& B,
00343               const float beta,
00344               Matrix<float, Prop2, RowMajor, Allocator2>& C)
00345   {
00346 
00347 #ifdef SELDON_CHECK_DIMENSIONS
00348     CheckDim(TransA, A, TransB, B, C,
00349              "MltAdd(alpha, TransA, A, TransB, B, beta, C)");
00350 #endif
00351 
00352     cblas_sgemm(CblasRowMajor, TransA, TransB, C.GetM(), C.GetN(),
00353                 A.GetN(TransA), alpha, A.GetData(), A.GetLD(),
00354                 B.GetData(), B.GetLD(), beta, C.GetData(), C.GetLD());
00355   }
00356 
00357 
00358   template <class Prop0, class Allocator0,
00359             class Prop1, class Allocator1,
00360             class Prop2, class Allocator2>
00361   void MltAdd(const double alpha,
00362               const SeldonTranspose& TransA,
00363               const Matrix<double, Prop0, RowMajor, Allocator0>& A,
00364               const SeldonTranspose& TransB,
00365               const Matrix<double, Prop1, RowMajor, Allocator1>& B,
00366               const double beta,
00367               Matrix<double, Prop2, RowMajor, Allocator2>& C)
00368   {
00369 
00370 #ifdef SELDON_CHECK_DIMENSIONS
00371     CheckDim(TransA, A, TransB, B, C,
00372              "MltAdd(alpha, TransA, A, TransB, B, beta, C)");
00373 #endif
00374 
00375     cblas_dgemm(CblasRowMajor, TransA, TransB, C.GetM(), C.GetN(),
00376                 A.GetN(TransA), alpha, A.GetData(), A.GetLD(),
00377                 B.GetData(), B.GetLD(), beta, C.GetData(), C.GetLD());
00378   }
00379 
00380 
00381   template <class Prop0, class Allocator0,
00382             class Prop1, class Allocator1,
00383             class Prop2, class Allocator2>
00384   void MltAdd(const complex<float> alpha,
00385               const SeldonTranspose& TransA,
00386               const Matrix<complex<float>, Prop0, RowMajor, Allocator0>& A,
00387               const SeldonTranspose& TransB,
00388               const Matrix<complex<float>, Prop1, RowMajor, Allocator1>& B,
00389               const complex<float> beta,
00390               Matrix<complex<float>, Prop2, RowMajor, Allocator2>& C)
00391   {
00392 
00393 #ifdef SELDON_CHECK_DIMENSIONS
00394     CheckDim(TransA, A, TransB, B, C,
00395              "MltAdd(alpha, TransA, A, TransB, B, beta, C)");
00396 #endif
00397 
00398     cblas_cgemm(CblasRowMajor, TransA, TransB, C.GetM(), C.GetN(),
00399                 A.GetN(TransA), reinterpret_cast<const void*>(&alpha),
00400                 reinterpret_cast<const void*>(A.GetData()), A.GetLD(),
00401                 reinterpret_cast<const void*>(B.GetData()), B.GetLD(),
00402                 reinterpret_cast<const void*>(&beta),
00403                 reinterpret_cast<void*>(C.GetData()), C.GetLD());
00404   }
00405 
00406 
00407   template <class Prop0, class Allocator0,
00408             class Prop1, class Allocator1,
00409             class Prop2, class Allocator2>
00410   void MltAdd(const complex<double> alpha,
00411               const SeldonTranspose& TransA,
00412               const Matrix<complex<double>, Prop0, RowMajor, Allocator0>& A,
00413               const SeldonTranspose& TransB,
00414               const Matrix<complex<double>, Prop1, RowMajor, Allocator1>& B,
00415               const complex<double> beta,
00416               Matrix<complex<double>, Prop2, RowMajor, Allocator2>& C)
00417   {
00418 
00419 #ifdef SELDON_CHECK_DIMENSIONS
00420     CheckDim(TransA, A, TransB, B, C,
00421              "MltAdd(alpha, TransA, A, TransB, B, beta, C)");
00422 #endif
00423 
00424     cblas_zgemm(CblasRowMajor, TransA, TransB, C.GetM(), C.GetN(),
00425                 A.GetN(TransA), reinterpret_cast<const void*>(&alpha),
00426                 reinterpret_cast<const void*>(A.GetData()), A.GetLD(),
00427                 reinterpret_cast<const void*>(B.GetData()), B.GetLD(),
00428                 reinterpret_cast<const void*>(&beta),
00429                 reinterpret_cast<void*>(C.GetData()), C.GetLD());
00430   }
00431 
00432 
00433   // MltAdd //
00435 
00436 
00437 
00439   // MltAdd //
00440 
00441 
00442   /*** ColSym and Upper ***/
00443 
00444 
00445   template <class Prop0, class Allocator0,
00446             class Prop1, class Allocator1,
00447             class Prop2, class Allocator2>
00448   void MltAdd(const SeldonSide& Side,
00449               const float alpha,
00450               const Matrix<float, Prop0, ColSym, Allocator0>& A,
00451               const Matrix<float, Prop1, ColMajor, Allocator1>& B,
00452               const float beta,
00453               Matrix<float, Prop2, ColMajor, Allocator2>& C)
00454   {
00455 
00456 #ifdef SELDON_CHECK_DIMENSIONS
00457     CheckDim(Side, A, B, C, "MltAdd(side, alpha, A, B, beta, C)");
00458 #endif
00459 
00460     cblas_ssymm(CblasColMajor, Side, CblasUpper,
00461                 C.GetM(), C.GetN(),
00462                 alpha, A.GetData(), A.GetM(), B.GetData(), B.GetM(),
00463                 beta, C.GetData(), C.GetM());
00464   }
00465 
00466 
00467   template <class Prop0, class Allocator0,
00468             class Prop1, class Allocator1,
00469             class Prop2, class Allocator2>
00470   void MltAdd(const SeldonSide& Side,
00471               const double alpha,
00472               const Matrix<double, Prop0, ColSym, Allocator0>& A,
00473               const Matrix<double, Prop1, ColMajor, Allocator1>& B,
00474               const double beta,
00475               Matrix<double, Prop2, ColMajor, Allocator2>& C)
00476   {
00477 
00478 #ifdef SELDON_CHECK_DIMENSIONS
00479     CheckDim(Side, A, B, C, "MltAdd(side, alpha, A, B, beta, C)");
00480 #endif
00481 
00482     cblas_dsymm(CblasColMajor, Side, CblasUpper,
00483                 C.GetM(), C.GetN(),
00484                 alpha, A.GetData(), A.GetM(), B.GetData(), B.GetM(),
00485                 beta, C.GetData(), C.GetM());
00486   }
00487 
00488 
00489   template <class Prop0, class Allocator0,
00490             class Prop1, class Allocator1,
00491             class Prop2, class Allocator2>
00492   void MltAdd(const SeldonSide& Side,
00493               const complex<float> alpha,
00494               const Matrix<complex<float>, Prop0, ColSym, Allocator0>& A,
00495               const Matrix<complex<float>, Prop1, ColMajor, Allocator1>& B,
00496               const complex<float> beta,
00497               Matrix<complex<float>, Prop2, ColMajor, Allocator2>& C)
00498   {
00499 
00500 #ifdef SELDON_CHECK_DIMENSIONS
00501     CheckDim(Side, A, B, C, "MltAdd(side, alpha, A, B, beta, C)");
00502 #endif
00503 
00504     cblas_csymm(CblasColMajor, Side, CblasUpper,
00505                 C.GetM(), C.GetN(),
00506                 reinterpret_cast<const void*>(&alpha),
00507                 reinterpret_cast<const void*>(A.GetData()), A.GetM(),
00508                 reinterpret_cast<const void*>(B.GetData()), B.GetM(),
00509                 reinterpret_cast<const void*>(&beta),
00510                 reinterpret_cast<void*>(C.GetData()), C.GetM());
00511   }
00512 
00513 
00514   template <class Prop0, class Allocator0,
00515             class Prop1, class Allocator1,
00516             class Prop2, class Allocator2>
00517   void MltAdd(const SeldonSide& Side,
00518               const complex<double> alpha,
00519               const Matrix<complex<double>, Prop0, ColSym, Allocator0>& A,
00520               const Matrix<complex<double>, Prop1, ColMajor, Allocator1>& B,
00521               const complex<double> beta,
00522               Matrix<complex<double>, Prop2, ColMajor, Allocator2>& C)
00523   {
00524 
00525 #ifdef SELDON_CHECK_DIMENSIONS
00526     CheckDim(Side, A, B, C, "MltAdd(side, alpha, A, B, beta, C)");
00527 #endif
00528 
00529     cblas_zsymm(CblasColMajor, Side, CblasUpper,
00530                 C.GetM(), C.GetN(),
00531                 reinterpret_cast<const void*>(&alpha),
00532                 reinterpret_cast<const void*>(A.GetData()), A.GetM(),
00533                 reinterpret_cast<const void*>(B.GetData()), B.GetM(),
00534                 reinterpret_cast<const void*>(&beta),
00535                 reinterpret_cast<void*>(C.GetData()), C.GetM());
00536   }
00537 
00538 
00539   /*** ColSym and UpLo ***/
00540 
00541 
00542   template <class Prop0, class Allocator0,
00543             class Prop1, class Allocator1,
00544             class Prop2, class Allocator2>
00545   void MltAdd(const SeldonSide& Side,
00546               const float alpha,
00547               const SeldonUplo& Uplo,
00548               const Matrix<float, Prop0, ColSym, Allocator0>& A,
00549               const Matrix<float, Prop1, ColMajor, Allocator1>& B,
00550               const float beta,
00551               Matrix<float, Prop2, ColMajor, Allocator2>& C)
00552   {
00553 
00554 #ifdef SELDON_CHECK_DIMENSIONS
00555     CheckDim(Side, A, B, C, "MltAdd(side, alpha, uplo, A, B, beta, C)");
00556 #endif
00557 
00558     cblas_ssymm(CblasColMajor, Side, Uplo,
00559                 C.GetM(), C.GetN(),
00560                 alpha, A.GetData(), A.GetM(), B.GetData(), B.GetM(),
00561                 beta, C.GetData(), C.GetM());
00562   }
00563 
00564 
00565   template <class Prop0, class Allocator0,
00566             class Prop1, class Allocator1,
00567             class Prop2, class Allocator2>
00568   void MltAdd(const SeldonSide& Side,
00569               const double alpha,
00570               const SeldonUplo& Uplo,
00571               const Matrix<double, Prop0, ColSym, Allocator0>& A,
00572               const Matrix<double, Prop1, ColMajor, Allocator1>& B,
00573               const double beta,
00574               Matrix<double, Prop2, ColMajor, Allocator2>& C)
00575   {
00576 
00577 #ifdef SELDON_CHECK_DIMENSIONS
00578     CheckDim(Side, A, B, C, "MltAdd(side, alpha, uplo, A, B, beta, C)");
00579 #endif
00580 
00581     cblas_dsymm(CblasColMajor, Side, Uplo,
00582                 C.GetM(), C.GetN(),
00583                 alpha, A.GetData(), A.GetM(), B.GetData(), B.GetM(),
00584                 beta, C.GetData(), C.GetM());
00585   }
00586 
00587 
00588   template <class Prop0, class Allocator0,
00589             class Prop1, class Allocator1,
00590             class Prop2, class Allocator2>
00591   void MltAdd(const SeldonSide& Side,
00592               const complex<float> alpha,
00593               const SeldonUplo& Uplo,
00594               const Matrix<complex<float>, Prop0, ColSym, Allocator0>& A,
00595               const Matrix<complex<float>, Prop1, ColMajor, Allocator1>& B,
00596               const complex<float> beta,
00597               Matrix<complex<float>, Prop2, ColMajor, Allocator2>& C)
00598   {
00599 
00600 #ifdef SELDON_CHECK_DIMENSIONS
00601     CheckDim(Side, A, B, C, "MltAdd(side, alpha, uplo, A, B, beta, C)");
00602 #endif
00603 
00604     cblas_csymm(CblasColMajor, Side, Uplo,
00605                 C.GetM(), C.GetN(),
00606                 reinterpret_cast<const void*>(&alpha),
00607                 reinterpret_cast<const void*>(A.GetData()), A.GetM(),
00608                 reinterpret_cast<const void*>(B.GetData()), B.GetM(),
00609                 reinterpret_cast<const void*>(&beta),
00610                 reinterpret_cast<void*>(C.GetData()), C.GetM());
00611   }
00612 
00613 
00614   template <class Prop0, class Allocator0,
00615             class Prop1, class Allocator1,
00616             class Prop2, class Allocator2>
00617   void MltAdd(const SeldonSide& Side,
00618               const complex<double> alpha,
00619               const SeldonUplo& Uplo,
00620               const Matrix<complex<double>, Prop0, ColSym, Allocator0>& A,
00621               const Matrix<complex<double>, Prop1, ColMajor, Allocator1>& B,
00622               const complex<double> beta,
00623               Matrix<complex<double>, Prop2, ColMajor, Allocator2>& C)
00624   {
00625 
00626 #ifdef SELDON_CHECK_DIMENSIONS
00627     CheckDim(Side, A, B, C, "MltAdd(side, alpha, uplo, A, B, beta, C)");
00628 #endif
00629 
00630     cblas_zsymm(CblasColMajor, Side, Uplo,
00631                 C.GetM(), C.GetN(),
00632                 reinterpret_cast<const void*>(&alpha),
00633                 reinterpret_cast<const void*>(A.GetData()), A.GetM(),
00634                 reinterpret_cast<const void*>(B.GetData()), B.GetM(),
00635                 reinterpret_cast<const void*>(&beta),
00636                 reinterpret_cast<void*>(C.GetData()), C.GetM());
00637   }
00638 
00639 
00640   /*** RowSym and Upper ***/
00641 
00642 
00643   template <class Prop0, class Allocator0,
00644             class Prop1, class Allocator1,
00645             class Prop2, class Allocator2>
00646   void MltAdd(const SeldonSide& Side,
00647               const float alpha,
00648               const Matrix<float, Prop0, RowSym, Allocator0>& A,
00649               const Matrix<float, Prop1, RowMajor, Allocator1>& B,
00650               const float beta,
00651               Matrix<float, Prop2, RowMajor, Allocator2>& C)
00652   {
00653 
00654 #ifdef SELDON_CHECK_DIMENSIONS
00655     CheckDim(Side, A, B, C, "MltAdd(side, alpha, A, B, beta, C)");
00656 #endif
00657 
00658     cblas_ssymm(CblasRowMajor, Side, CblasUpper,
00659                 C.GetM(), C.GetN(),
00660                 alpha, A.GetData(), A.GetM(), B.GetData(), B.GetN(),
00661                 beta, C.GetData(), C.GetN());
00662   }
00663 
00664 
00665   template <class Prop0, class Allocator0,
00666             class Prop1, class Allocator1,
00667             class Prop2, class Allocator2>
00668   void MltAdd(const SeldonSide& Side,
00669               const double alpha,
00670               const Matrix<double, Prop0, RowSym, Allocator0>& A,
00671               const Matrix<double, Prop1, RowMajor, Allocator1>& B,
00672               const double beta,
00673               Matrix<double, Prop2, RowMajor, Allocator2>& C)
00674   {
00675 
00676 #ifdef SELDON_CHECK_DIMENSIONS
00677     CheckDim(Side, A, B, C, "MltAdd(side, alpha, A, B, beta, C)");
00678 #endif
00679 
00680     cblas_dsymm(CblasRowMajor, Side, CblasUpper,
00681                 C.GetM(), C.GetN(),
00682                 alpha, A.GetData(), A.GetM(), B.GetData(), B.GetN(),
00683                 beta, C.GetData(), C.GetN());
00684   }
00685 
00686 
00687   template <class Prop0, class Allocator0,
00688             class Prop1, class Allocator1,
00689             class Prop2, class Allocator2>
00690   void MltAdd(const SeldonSide& Side,
00691               const complex<float> alpha,
00692               const Matrix<complex<float>, Prop0, RowSym, Allocator0>& A,
00693               const Matrix<complex<float>, Prop1, RowMajor, Allocator1>& B,
00694               const complex<float> beta,
00695               Matrix<complex<float>, Prop2, RowMajor, Allocator2>& C)
00696   {
00697 
00698 #ifdef SELDON_CHECK_DIMENSIONS
00699     CheckDim(Side, A, B, C, "MltAdd(side, alpha, A, B, beta, C)");
00700 #endif
00701 
00702     cblas_csymm(CblasRowMajor, Side, CblasUpper,
00703                 C.GetM(), C.GetN(),
00704                 reinterpret_cast<const void*>(&alpha),
00705                 reinterpret_cast<const void*>(A.GetData()), A.GetM(),
00706                 reinterpret_cast<const void*>(B.GetData()), B.GetN(),
00707                 reinterpret_cast<const void*>(&beta),
00708                 reinterpret_cast<void*>(C.GetData()), C.GetN());
00709   }
00710 
00711 
00712   template <class Prop0, class Allocator0,
00713             class Prop1, class Allocator1,
00714             class Prop2, class Allocator2>
00715   void MltAdd(const SeldonSide& Side,
00716               const complex<double> alpha,
00717               const Matrix<complex<double>, Prop0, RowSym, Allocator0>& A,
00718               const Matrix<complex<double>, Prop1, RowMajor, Allocator1>& B,
00719               const complex<double> beta,
00720               Matrix<complex<double>, Prop2, RowMajor, Allocator2>& C)
00721   {
00722 
00723 #ifdef SELDON_CHECK_DIMENSIONS
00724     CheckDim(Side, A, B, C, "MltAdd(side, alpha, A, B, beta, C)");
00725 #endif
00726 
00727     cblas_zsymm(CblasRowMajor, Side, CblasUpper,
00728                 C.GetM(), C.GetN(),
00729                 reinterpret_cast<const void*>(&alpha),
00730                 reinterpret_cast<const void*>(A.GetData()), A.GetM(),
00731                 reinterpret_cast<const void*>(B.GetData()), B.GetN(),
00732                 reinterpret_cast<const void*>(&beta),
00733                 reinterpret_cast<void*>(C.GetData()), C.GetN());
00734   }
00735 
00736 
00737   /*** RowSym and UpLo ***/
00738 
00739 
00740   template <class Prop0, class Allocator0,
00741             class Prop1, class Allocator1,
00742             class Prop2, class Allocator2>
00743   void MltAdd(const SeldonSide& Side,
00744               const float alpha,
00745               const SeldonUplo& Uplo,
00746               const Matrix<float, Prop0, RowSym, Allocator0>& A,
00747               const Matrix<float, Prop1, RowMajor, Allocator1>& B,
00748               const float beta,
00749               Matrix<float, Prop2, RowMajor, Allocator2>& C)
00750   {
00751 
00752 #ifdef SELDON_CHECK_DIMENSIONS
00753     CheckDim(Side, A, B, C, "MltAdd(side, alpha, uplo, A, B, beta, C)");
00754 #endif
00755 
00756     cblas_ssymm(CblasRowMajor, Side, Uplo,
00757                 C.GetM(), C.GetN(),
00758                 alpha, A.GetData(), A.GetM(), B.GetData(), B.GetN(),
00759                 beta, C.GetData(), C.GetN());
00760   }
00761 
00762 
00763   template <class Prop0, class Allocator0,
00764             class Prop1, class Allocator1,
00765             class Prop2, class Allocator2>
00766   void MltAdd(const SeldonSide& Side,
00767               const double alpha,
00768               const SeldonUplo& Uplo,
00769               const Matrix<double, Prop0, RowSym, Allocator0>& A,
00770               const Matrix<double, Prop1, RowMajor, Allocator1>& B,
00771               const double beta,
00772               Matrix<double, Prop2, RowMajor, Allocator2>& C)
00773   {
00774 
00775 #ifdef SELDON_CHECK_DIMENSIONS
00776     CheckDim(Side, A, B, C, "MltAdd(side, alpha, uplo, A, B, beta, C)");
00777 #endif
00778 
00779     cblas_dsymm(CblasRowMajor, Side, Uplo,
00780                 C.GetM(), C.GetN(),
00781                 alpha, A.GetData(), A.GetM(), B.GetData(), B.GetN(),
00782                 beta, C.GetData(), C.GetN());
00783   }
00784 
00785 
00786   template <class Prop0, class Allocator0,
00787             class Prop1, class Allocator1,
00788             class Prop2, class Allocator2>
00789   void MltAdd(const SeldonSide& Side,
00790               const complex<float> alpha,
00791               const SeldonUplo& Uplo,
00792               const Matrix<complex<float>, Prop0, RowSym, Allocator0>& A,
00793               const Matrix<complex<float>, Prop1, RowMajor, Allocator1>& B,
00794               const complex<float> beta,
00795               Matrix<complex<float>, Prop2, RowMajor, Allocator2>& C)
00796   {
00797 
00798 #ifdef SELDON_CHECK_DIMENSIONS
00799     CheckDim(Side, A, B, C, "MltAdd(side, alpha, uplo, A, B, beta, C)");
00800 #endif
00801 
00802     cblas_csymm(CblasRowMajor, Side, Uplo,
00803                 C.GetM(), C.GetN(),
00804                 reinterpret_cast<const void*>(&alpha),
00805                 reinterpret_cast<const void*>(A.GetData()), A.GetM(),
00806                 reinterpret_cast<const void*>(B.GetData()), B.GetN(),
00807                 reinterpret_cast<const void*>(&beta),
00808                 reinterpret_cast<void*>(C.GetData()), C.GetN());
00809   }
00810 
00811 
00812   template <class Prop0, class Allocator0,
00813             class Prop1, class Allocator1,
00814             class Prop2, class Allocator2>
00815   void MltAdd(const SeldonSide& Side,
00816               const complex<double> alpha,
00817               const SeldonUplo& Uplo,
00818               const Matrix<complex<double>, Prop0, RowSym, Allocator0>& A,
00819               const Matrix<complex<double>, Prop1, RowMajor, Allocator1>& B,
00820               const complex<double> beta,
00821               Matrix<complex<double>, Prop2, RowMajor, Allocator2>& C)
00822   {
00823 
00824 #ifdef SELDON_CHECK_DIMENSIONS
00825     CheckDim(Side, A, B, C, "MltAdd(side, alpha, uplo, A, B, beta, C)");
00826 #endif
00827 
00828     cblas_zsymm(CblasRowMajor, Side, Uplo,
00829                 C.GetM(), C.GetN(),
00830                 reinterpret_cast<const void*>(&alpha),
00831                 reinterpret_cast<const void*>(A.GetData()), A.GetM(),
00832                 reinterpret_cast<const void*>(B.GetData()), B.GetN(),
00833                 reinterpret_cast<const void*>(&beta),
00834                 reinterpret_cast<void*>(C.GetData()), C.GetN());
00835   }
00836 
00837 
00838   // MltAdd //
00840 
00841 
00842 
00844   // MltAdd //
00845 
00846 
00847   /*** ColHerm and Upper ***/
00848 
00849 
00850   template <class Prop0, class Allocator0,
00851             class Prop1, class Allocator1,
00852             class Prop2, class Allocator2>
00853   void MltAdd(const SeldonSide& Side,
00854               const complex<float> alpha,
00855               const Matrix<complex<float>, Prop0, ColHerm, Allocator0>& A,
00856               const Matrix<complex<float>, Prop1, ColMajor, Allocator1>& B,
00857               const complex<float> beta,
00858               Matrix<complex<float>, Prop2, ColMajor, Allocator2>& C)
00859   {
00860 
00861 #ifdef SELDON_CHECK_DIMENSIONS
00862     CheckDim(Side, A, B, C, "MltAdd(side, alpha, A, B, beta, C)");
00863 #endif
00864 
00865     cblas_chemm(CblasColMajor, Side, CblasUpper,
00866                 C.GetM(), C.GetN(),
00867                 reinterpret_cast<const void*>(&alpha),
00868                 reinterpret_cast<const void*>(A.GetData()), A.GetM(),
00869                 reinterpret_cast<const void*>(B.GetData()), B.GetM(),
00870                 reinterpret_cast<const void*>(&beta),
00871                 reinterpret_cast<void*>(C.GetData()), C.GetM());
00872   }
00873 
00874 
00875   template <class Prop0, class Allocator0,
00876             class Prop1, class Allocator1,
00877             class Prop2, class Allocator2>
00878   void MltAdd(const SeldonSide& Side,
00879               const complex<double> alpha,
00880               const Matrix<complex<double>, Prop0, ColHerm, Allocator0>& A,
00881               const Matrix<complex<double>, Prop1, ColMajor, Allocator1>& B,
00882               const complex<double> beta,
00883               Matrix<complex<double>, Prop2, ColMajor, Allocator2>& C)
00884   {
00885 
00886 #ifdef SELDON_CHECK_DIMENSIONS
00887     CheckDim(Side, A, B, C, "MltAdd(side, alpha, A, B, beta, C)");
00888 #endif
00889 
00890     cblas_zhemm(CblasColMajor, Side, CblasUpper,
00891                 C.GetM(), C.GetN(),
00892                 reinterpret_cast<const void*>(&alpha),
00893                 reinterpret_cast<const void*>(A.GetData()), A.GetM(),
00894                 reinterpret_cast<const void*>(B.GetData()), B.GetM(),
00895                 reinterpret_cast<const void*>(&beta),
00896                 reinterpret_cast<void*>(C.GetData()), C.GetM());
00897   }
00898 
00899 
00900   /*** ColHerm and UpLo ***/
00901 
00902 
00903   template <class Prop0, class Allocator0,
00904             class Prop1, class Allocator1,
00905             class Prop2, class Allocator2>
00906   void MltAdd(const SeldonSide& Side,
00907               const complex<float> alpha,
00908               const SeldonUplo& Uplo,
00909               const Matrix<complex<float>, Prop0, ColHerm, Allocator0>& A,
00910               const Matrix<complex<float>, Prop1, ColMajor, Allocator1>& B,
00911               const complex<float> beta,
00912               Matrix<complex<float>, Prop2, ColMajor, Allocator2>& C)
00913   {
00914 
00915 #ifdef SELDON_CHECK_DIMENSIONS
00916     CheckDim(Side, A, B, C, "MltAdd(side, alpha, uplo, A, B, beta, C)");
00917 #endif
00918 
00919     cblas_chemm(CblasColMajor, Side, Uplo,
00920                 C.GetM(), C.GetN(),
00921                 reinterpret_cast<const void*>(&alpha),
00922                 reinterpret_cast<const void*>(A.GetData()), A.GetM(),
00923                 reinterpret_cast<const void*>(B.GetData()), B.GetM(),
00924                 reinterpret_cast<const void*>(&beta),
00925                 reinterpret_cast<void*>(C.GetData()), C.GetM());
00926   }
00927 
00928 
00929   template <class Prop0, class Allocator0,
00930             class Prop1, class Allocator1,
00931             class Prop2, class Allocator2>
00932   void MltAdd(const SeldonSide& Side,
00933               const complex<double> alpha,
00934               const SeldonUplo& Uplo,
00935               const Matrix<complex<double>, Prop0, ColHerm, Allocator0>& A,
00936               const Matrix<complex<double>, Prop1, ColMajor, Allocator1>& B,
00937               const complex<double> beta,
00938               Matrix<complex<double>, Prop2, ColMajor, Allocator2>& C)
00939   {
00940 
00941 #ifdef SELDON_CHECK_DIMENSIONS
00942     CheckDim(Side, A, B, C, "MltAdd(side, alpha, uplo, A, B, beta, C)");
00943 #endif
00944 
00945     cblas_zhemm(CblasColMajor, Side, Uplo,
00946                 C.GetM(), C.GetN(),
00947                 reinterpret_cast<const void*>(&alpha),
00948                 reinterpret_cast<const void*>(A.GetData()), A.GetM(),
00949                 reinterpret_cast<const void*>(B.GetData()), B.GetM(),
00950                 reinterpret_cast<const void*>(&beta),
00951                 reinterpret_cast<void*>(C.GetData()), C.GetM());
00952   }
00953 
00954 
00955   /*** RowHerm and Upper ***/
00956 
00957 
00958   template <class Prop0, class Allocator0,
00959             class Prop1, class Allocator1,
00960             class Prop2, class Allocator2>
00961   void MltAdd(const SeldonSide& Side,
00962               const complex<float> alpha,
00963               const Matrix<complex<float>, Prop0, RowHerm, Allocator0>& A,
00964               const Matrix<complex<float>, Prop1, RowMajor, Allocator1>& B,
00965               const complex<float> beta,
00966               Matrix<complex<float>, Prop2, RowMajor, Allocator2>& C)
00967   {
00968 
00969 #ifdef SELDON_CHECK_DIMENSIONS
00970     CheckDim(Side, A, B, C, "MltAdd(side, alpha, A, B, beta, C)");
00971 #endif
00972 
00973     cblas_chemm(CblasRowMajor, Side, CblasUpper,
00974                 C.GetM(), C.GetN(),
00975                 reinterpret_cast<const void*>(&alpha),
00976                 reinterpret_cast<const void*>(A.GetData()), A.GetM(),
00977                 reinterpret_cast<const void*>(B.GetData()), B.GetN(),
00978                 reinterpret_cast<const void*>(&beta),
00979                 reinterpret_cast<void*>(C.GetData()), C.GetN());
00980   }
00981 
00982 
00983   template <class Prop0, class Allocator0,
00984             class Prop1, class Allocator1,
00985             class Prop2, class Allocator2>
00986   void MltAdd(const SeldonSide& Side,
00987               const complex<double> alpha,
00988               const Matrix<complex<double>, Prop0, RowHerm, Allocator0>& A,
00989               const Matrix<complex<double>, Prop1, RowMajor, Allocator1>& B,
00990               const complex<double> beta,
00991               Matrix<complex<double>, Prop2, RowMajor, Allocator2>& C)
00992   {
00993 
00994 #ifdef SELDON_CHECK_DIMENSIONS
00995     CheckDim(Side, A, B, C, "MltAdd(side, alpha, A, B, beta, C)");
00996 #endif
00997 
00998     cblas_zhemm(CblasRowMajor, Side, CblasUpper,
00999                 C.GetM(), C.GetN(),
01000                 reinterpret_cast<const void*>(&alpha),
01001                 reinterpret_cast<const void*>(A.GetData()), A.GetM(),
01002                 reinterpret_cast<const void*>(B.GetData()), B.GetN(),
01003                 reinterpret_cast<const void*>(&beta),
01004                 reinterpret_cast<void*>(C.GetData()), C.GetN());
01005   }
01006 
01007 
01008   /*** RowHerm and UpLo ***/
01009 
01010 
01011   template <class Prop0, class Allocator0,
01012             class Prop1, class Allocator1,
01013             class Prop2, class Allocator2>
01014   void MltAdd(const SeldonSide& Side,
01015               const complex<float> alpha,
01016               const SeldonUplo& Uplo,
01017               const Matrix<complex<float>, Prop0, RowHerm, Allocator0>& A,
01018               const Matrix<complex<float>, Prop1, RowMajor, Allocator1>& B,
01019               const complex<float> beta,
01020               Matrix<complex<float>, Prop2, RowMajor, Allocator2>& C)
01021   {
01022 
01023 #ifdef SELDON_CHECK_DIMENSIONS
01024     CheckDim(Side, A, B, C, "MltAdd(side, alpha, uplo, A, B, beta, C)");
01025 #endif
01026 
01027     cblas_chemm(CblasRowMajor, Side, Uplo,
01028                 C.GetM(), C.GetN(),
01029                 reinterpret_cast<const void*>(&alpha),
01030                 reinterpret_cast<const void*>(A.GetData()), A.GetM(),
01031                 reinterpret_cast<const void*>(B.GetData()), B.GetN(),
01032                 reinterpret_cast<const void*>(&beta),
01033                 reinterpret_cast<void*>(C.GetData()), C.GetN());
01034   }
01035 
01036 
01037   template <class Prop0, class Allocator0,
01038             class Prop1, class Allocator1,
01039             class Prop2, class Allocator2>
01040   void MltAdd(const SeldonSide& Side,
01041               const complex<double> alpha,
01042               const SeldonUplo& Uplo,
01043               const Matrix<complex<double>, Prop0, RowHerm, Allocator0>& A,
01044               const Matrix<complex<double>, Prop1, RowMajor, Allocator1>& B,
01045               const complex<double> beta,
01046               Matrix<complex<double>, Prop2, RowMajor, Allocator2>& C)
01047   {
01048 
01049 #ifdef SELDON_CHECK_DIMENSIONS
01050     CheckDim(Side, A, B, C, "MltAdd(side, alpha, uplo, A, B, beta, C)");
01051 #endif
01052 
01053     cblas_zhemm(CblasRowMajor, Side, Uplo,
01054                 C.GetM(), C.GetN(),
01055                 reinterpret_cast<const void*>(&alpha),
01056                 reinterpret_cast<const void*>(A.GetData()), A.GetM(),
01057                 reinterpret_cast<const void*>(B.GetData()), B.GetN(),
01058                 reinterpret_cast<const void*>(&beta),
01059                 reinterpret_cast<void*>(C.GetData()), C.GetN());
01060   }
01061 
01062 
01063   // MltAdd //
01065 
01066 
01067 
01069   // Mlt //
01070 
01071 
01072   /*** ColUpTriang, NoTrans and NonUnit ***/
01073 
01074 
01075   template <class Prop0, class Allocator0,
01076             class Prop1, class Allocator1>
01077   void Mlt(const SeldonSide& Side,
01078            const float alpha,
01079            const Matrix<float, Prop0, ColUpTriang, Allocator0>& A,
01080            Matrix<float, Prop1, ColMajor, Allocator1>& B)
01081   {
01082 
01083 #ifdef SELDON_CHECK_DIMENSIONS
01084     CheckDim(Side, A, B, "Mlt(side, alpha, A, B)");
01085 #endif
01086 
01087     cblas_strmm(CblasColMajor, Side, CblasUpper, CblasNoTrans, CblasNonUnit,
01088                 B.GetM(), B.GetN(),
01089                 alpha, A.GetData(), A.GetM(), B.GetData(), B.GetM());
01090   }
01091 
01092 
01093   template <class Prop0, class Allocator0,
01094             class Prop1, class Allocator1>
01095   void Mlt(const SeldonSide& Side,
01096            const double alpha,
01097            const Matrix<double, Prop0, ColUpTriang, Allocator0>& A,
01098            Matrix<double, Prop1, ColMajor, Allocator1>& B)
01099   {
01100 
01101 #ifdef SELDON_CHECK_DIMENSIONS
01102     CheckDim(Side, A, B, "Mlt(side, alpha, A, B)");
01103 #endif
01104 
01105     cblas_dtrmm(CblasColMajor, Side, CblasUpper, CblasNoTrans, CblasNonUnit,
01106                 B.GetM(), B.GetN(),
01107                 alpha, A.GetData(), A.GetM(), B.GetData(), B.GetM());
01108   }
01109 
01110 
01111   template <class Prop0, class Allocator0,
01112             class Prop1, class Allocator1>
01113   void Mlt(const SeldonSide& Side,
01114            const complex<float> alpha,
01115            const Matrix<complex<float>, Prop0, ColUpTriang, Allocator0>& A,
01116            Matrix<complex<float>, Prop1, ColMajor, Allocator1>& B)
01117   {
01118 
01119 #ifdef SELDON_CHECK_DIMENSIONS
01120     CheckDim(Side, A, B, "Mlt(side, alpha, A, B)");
01121 #endif
01122 
01123     cblas_ctrmm(CblasColMajor, Side, CblasUpper, CblasNoTrans, CblasNonUnit,
01124                 B.GetM(), B.GetN(),
01125                 reinterpret_cast<const void*>(&alpha),
01126                 reinterpret_cast<const void*>(A.GetData()), A.GetM(),
01127                 reinterpret_cast<void*>(B.GetData()), B.GetM());
01128   }
01129 
01130 
01131   template <class Prop0, class Allocator0,
01132             class Prop1, class Allocator1>
01133   void Mlt(const SeldonSide& Side,
01134            const complex<double> alpha,
01135            const Matrix<complex<double>, Prop0, ColUpTriang, Allocator0>& A,
01136            Matrix<complex<double>, Prop1, ColMajor, Allocator1>& B)
01137   {
01138 
01139 #ifdef SELDON_CHECK_DIMENSIONS
01140     CheckDim(Side, A, B, "Mlt(side, alpha, A, B)");
01141 #endif
01142 
01143     cblas_ztrmm(CblasColMajor, Side, CblasUpper, CblasNoTrans, CblasNonUnit,
01144                 B.GetM(), B.GetN(),
01145                 reinterpret_cast<const void*>(&alpha),
01146                 reinterpret_cast<const void*>(A.GetData()), A.GetM(),
01147                 reinterpret_cast<void*>(B.GetData()), B.GetM());
01148   }
01149 
01150 
01151   /*** ColUpTriang ***/
01152 
01153 
01154   template <class Prop0, class Allocator0,
01155             class Prop1, class Allocator1>
01156   void Mlt(const SeldonSide& Side,
01157            const float alpha,
01158            const SeldonTranspose& TransA,
01159            const SeldonDiag& DiagA,
01160            const Matrix<float, Prop0, ColUpTriang, Allocator0>& A,
01161            Matrix<float, Prop1, ColMajor, Allocator1>& B)
01162   {
01163 
01164 #ifdef SELDON_CHECK_DIMENSIONS
01165     CheckDim(Side, A, B, "Mlt(side, alpha, status, diag, A, B)");
01166 #endif
01167 
01168     cblas_strmm(CblasColMajor, Side, CblasUpper, TransA, DiagA,
01169                 B.GetM(), B.GetN(),
01170                 alpha, A.GetData(), A.GetM(), B.GetData(), B.GetM());
01171   }
01172 
01173 
01174   template <class Prop0, class Allocator0,
01175             class Prop1, class Allocator1>
01176   void Mlt(const SeldonSide& Side,
01177            const double alpha,
01178            const SeldonTranspose& TransA,
01179            const SeldonDiag& DiagA,
01180            const Matrix<double, Prop0, ColUpTriang, Allocator0>& A,
01181            Matrix<double, Prop1, ColMajor, Allocator1>& B)
01182   {
01183 
01184 #ifdef SELDON_CHECK_DIMENSIONS
01185     CheckDim(Side, A, B, "Mlt(side, alpha, status, diag, A, B)");
01186 #endif
01187 
01188     cblas_dtrmm(CblasColMajor, Side, CblasUpper, TransA, DiagA,
01189                 B.GetM(), B.GetN(),
01190                 alpha, A.GetData(), A.GetM(), B.GetData(), B.GetM());
01191   }
01192 
01193 
01194   template <class Prop0, class Allocator0,
01195             class Prop1, class Allocator1>
01196   void Mlt(const SeldonSide& Side,
01197            const complex<float> alpha,
01198            const SeldonTranspose& TransA,
01199            const SeldonDiag& DiagA,
01200            const Matrix<complex<float>, Prop0, ColUpTriang, Allocator0>& A,
01201            Matrix<complex<float>, Prop1, ColMajor, Allocator1>& B)
01202   {
01203 
01204 #ifdef SELDON_CHECK_DIMENSIONS
01205     CheckDim(Side, A, B, "Mlt(side, alpha, status, diag, A, B)");
01206 #endif
01207 
01208     cblas_ctrmm(CblasColMajor, Side, CblasUpper, TransA, DiagA,
01209                 B.GetM(), B.GetN(),
01210                 reinterpret_cast<const void*>(&alpha),
01211                 reinterpret_cast<const void*>(A.GetData()), A.GetM(),
01212                 reinterpret_cast<void*>(B.GetData()), B.GetM());
01213   }
01214 
01215 
01216   template <class Prop0, class Allocator0,
01217             class Prop1, class Allocator1>
01218   void Mlt(const SeldonSide& Side,
01219            const complex<double> alpha,
01220            const SeldonTranspose& TransA,
01221            const SeldonDiag& DiagA,
01222            const Matrix<complex<double>, Prop0, ColUpTriang, Allocator0>& A,
01223            Matrix<complex<double>, Prop1, ColMajor, Allocator1>& B)
01224   {
01225 
01226 #ifdef SELDON_CHECK_DIMENSIONS
01227     CheckDim(Side, A, B, "Mlt(side, alpha, status, diag, A, B)");
01228 #endif
01229 
01230     cblas_ztrmm(CblasColMajor, Side, CblasUpper, TransA, DiagA,
01231                 B.GetM(), B.GetN(),
01232                 reinterpret_cast<const void*>(&alpha),
01233                 reinterpret_cast<const void*>(A.GetData()), A.GetM(),
01234                 reinterpret_cast<void*>(B.GetData()), B.GetM());
01235   }
01236 
01237 
01238   /*** ColLoTriang, NoTrans and NonUnit ***/
01239 
01240 
01241   template <class Prop0, class Allocator0,
01242             class Prop1, class Allocator1>
01243   void Mlt(const SeldonSide& Side,
01244            const float alpha,
01245            const Matrix<float, Prop0, ColLoTriang, Allocator0>& A,
01246            Matrix<float, Prop1, ColMajor, Allocator1>& B)
01247   {
01248 
01249 #ifdef SELDON_CHECK_DIMENSIONS
01250     CheckDim(Side, A, B, "Mlt(side, alpha, A, B)");
01251 #endif
01252 
01253     cblas_strmm(CblasColMajor, Side, CblasLower, CblasNoTrans, CblasNonUnit,
01254                 B.GetM(), B.GetN(),
01255                 alpha, A.GetData(), A.GetM(), B.GetData(), B.GetM());
01256   }
01257 
01258 
01259   template <class Prop0, class Allocator0,
01260             class Prop1, class Allocator1>
01261   void Mlt(const SeldonSide& Side,
01262            const double alpha,
01263            const Matrix<double, Prop0, ColLoTriang, Allocator0>& A,
01264            Matrix<double, Prop1, ColMajor, Allocator1>& B)
01265   {
01266 
01267 #ifdef SELDON_CHECK_DIMENSIONS
01268     CheckDim(Side, A, B, "Mlt(side, alpha, A, B)");
01269 #endif
01270 
01271     cblas_dtrmm(CblasColMajor, Side, CblasLower, CblasNoTrans, CblasNonUnit,
01272                 B.GetM(), B.GetN(),
01273                 alpha, A.GetData(), A.GetM(), B.GetData(), B.GetM());
01274   }
01275 
01276 
01277   template <class Prop0, class Allocator0,
01278             class Prop1, class Allocator1>
01279   void Mlt(const SeldonSide& Side,
01280            const complex<float> alpha,
01281            const Matrix<complex<float>, Prop0, ColLoTriang, Allocator0>& A,
01282            Matrix<complex<float>, Prop1, ColMajor, Allocator1>& B)
01283   {
01284 
01285 #ifdef SELDON_CHECK_DIMENSIONS
01286     CheckDim(Side, A, B, "Mlt(side, alpha, A, B)");
01287 #endif
01288 
01289     cblas_ctrmm(CblasColMajor, Side, CblasLower, CblasNoTrans, CblasNonUnit,
01290                 B.GetM(), B.GetN(),
01291                 reinterpret_cast<const void*>(&alpha),
01292                 reinterpret_cast<const void*>(A.GetData()), A.GetM(),
01293                 reinterpret_cast<void*>(B.GetData()), B.GetM());
01294   }
01295 
01296 
01297   template <class Prop0, class Allocator0,
01298             class Prop1, class Allocator1>
01299   void Mlt(const SeldonSide& Side,
01300            const complex<double> alpha,
01301            const Matrix<complex<double>, Prop0, ColLoTriang, Allocator0>& A,
01302            Matrix<complex<double>, Prop1, ColMajor, Allocator1>& B)
01303   {
01304 
01305 #ifdef SELDON_CHECK_DIMENSIONS
01306     CheckDim(Side, A, B, "Mlt(side, alpha, A, B)");
01307 #endif
01308 
01309     cblas_ztrmm(CblasColMajor, Side, CblasLower, CblasNoTrans, CblasNonUnit,
01310                 B.GetM(), B.GetN(),
01311                 reinterpret_cast<const void*>(&alpha),
01312                 reinterpret_cast<const void*>(A.GetData()), A.GetM(),
01313                 reinterpret_cast<void*>(B.GetData()), B.GetM());
01314   }
01315 
01316 
01317   /*** ColLoTriang ***/
01318 
01319 
01320   template <class Prop0, class Allocator0,
01321             class Prop1, class Allocator1>
01322   void Mlt(const SeldonSide& Side,
01323            const float alpha,
01324            const SeldonTranspose& TransA,
01325            const SeldonDiag& DiagA,
01326            const Matrix<float, Prop0, ColLoTriang, Allocator0>& A,
01327            Matrix<float, Prop1, ColMajor, Allocator1>& B)
01328   {
01329 
01330 #ifdef SELDON_CHECK_DIMENSIONS
01331     CheckDim(Side, A, B, "Mlt(side, alpha, status, diag, A, B)");
01332 #endif
01333 
01334     cblas_strmm(CblasColMajor, Side, CblasLower, TransA, DiagA,
01335                 B.GetM(), B.GetN(),
01336                 alpha, A.GetData(), A.GetM(), B.GetData(), B.GetM());
01337   }
01338 
01339 
01340   template <class Prop0, class Allocator0,
01341             class Prop1, class Allocator1>
01342   void Mlt(const SeldonSide& Side,
01343            const double alpha,
01344            const SeldonTranspose& TransA,
01345            const SeldonDiag& DiagA,
01346            const Matrix<double, Prop0, ColLoTriang, Allocator0>& A,
01347            Matrix<double, Prop1, ColMajor, Allocator1>& B)
01348   {
01349 
01350 #ifdef SELDON_CHECK_DIMENSIONS
01351     CheckDim(Side, A, B, "Mlt(side, alpha, status, diag, A, B)");
01352 #endif
01353 
01354     cblas_dtrmm(CblasColMajor, Side, CblasLower, TransA, DiagA,
01355                 B.GetM(), B.GetN(),
01356                 alpha, A.GetData(), A.GetM(), B.GetData(), B.GetM());
01357   }
01358 
01359 
01360   template <class Prop0, class Allocator0,
01361             class Prop1, class Allocator1>
01362   void Mlt(const SeldonSide& Side,
01363            const complex<float> alpha,
01364            const SeldonTranspose& TransA,
01365            const SeldonDiag& DiagA,
01366            const Matrix<complex<float>, Prop0, ColLoTriang, Allocator0>& A,
01367            Matrix<complex<float>, Prop1, ColMajor, Allocator1>& B)
01368   {
01369 
01370 #ifdef SELDON_CHECK_DIMENSIONS
01371     CheckDim(Side, A, B, "Mlt(side, alpha, status, diag, A, B)");
01372 #endif
01373 
01374     cblas_ctrmm(CblasColMajor, Side, CblasLower, TransA, DiagA,
01375                 B.GetM(), B.GetN(),
01376                 reinterpret_cast<const void*>(&alpha),
01377                 reinterpret_cast<const void*>(A.GetData()), A.GetM(),
01378                 reinterpret_cast<void*>(B.GetData()), B.GetM());
01379   }
01380 
01381 
01382   template <class Prop0, class Allocator0,
01383             class Prop1, class Allocator1>
01384   void Mlt(const SeldonSide& Side,
01385            const complex<double> alpha,
01386            const SeldonTranspose& TransA,
01387            const SeldonDiag& DiagA,
01388            const Matrix<complex<double>, Prop0, ColLoTriang, Allocator0>& A,
01389            Matrix<complex<double>, Prop1, ColMajor, Allocator1>& B)
01390   {
01391 
01392 #ifdef SELDON_CHECK_DIMENSIONS
01393     CheckDim(Side, A, B, "Mlt(side, alpha, status, diag, A, B)");
01394 #endif
01395 
01396     cblas_ztrmm(CblasColMajor, Side, CblasLower, TransA, DiagA,
01397                 B.GetM(), B.GetN(),
01398                 reinterpret_cast<const void*>(&alpha),
01399                 reinterpret_cast<const void*>(A.GetData()), A.GetM(),
01400                 reinterpret_cast<void*>(B.GetData()), B.GetM());
01401   }
01402 
01403 
01404   /*** RowUpTriang, NoTrans and NonUnit ***/
01405 
01406 
01407   template <class Prop0, class Allocator0,
01408             class Prop1, class Allocator1>
01409   void Mlt(const SeldonSide& Side,
01410            const float alpha,
01411            const Matrix<float, Prop0, RowUpTriang, Allocator0>& A,
01412            Matrix<float, Prop1, RowMajor, Allocator1>& B)
01413   {
01414 
01415 #ifdef SELDON_CHECK_DIMENSIONS
01416     CheckDim(Side, A, B, "Mlt(side, alpha, A, B)");
01417 #endif
01418 
01419     cblas_strmm(CblasRowMajor, Side, CblasUpper, CblasNoTrans, CblasNonUnit,
01420                 B.GetM(), B.GetN(),
01421                 alpha, A.GetData(), A.GetN(), B.GetData(), B.GetN());
01422   }
01423 
01424 
01425   template <class Prop0, class Allocator0,
01426             class Prop1, class Allocator1>
01427   void Mlt(const SeldonSide& Side,
01428            const double alpha,
01429            const Matrix<double, Prop0, RowUpTriang, Allocator0>& A,
01430            Matrix<double, Prop1, RowMajor, Allocator1>& B)
01431   {
01432 
01433 #ifdef SELDON_CHECK_DIMENSIONS
01434     CheckDim(Side, A, B, "Mlt(side, alpha, A, B)");
01435 #endif
01436 
01437     cblas_dtrmm(CblasRowMajor, Side, CblasUpper, CblasNoTrans, CblasNonUnit,
01438                 B.GetM(), B.GetN(),
01439                 alpha, A.GetData(), A.GetN(), B.GetData(), B.GetN());
01440   }
01441 
01442 
01443   template <class Prop0, class Allocator0,
01444             class Prop1, class Allocator1>
01445   void Mlt(const SeldonSide& Side,
01446            const complex<float> alpha,
01447            const Matrix<complex<float>, Prop0, RowUpTriang, Allocator0>& A,
01448            Matrix<complex<float>, Prop1, RowMajor, Allocator1>& B)
01449   {
01450 
01451 #ifdef SELDON_CHECK_DIMENSIONS
01452     CheckDim(Side, A, B, "Mlt(side, alpha, A, B)");
01453 #endif
01454 
01455     cblas_ctrmm(CblasRowMajor, Side, CblasUpper, CblasNoTrans, CblasNonUnit,
01456                 B.GetM(), B.GetN(),
01457                 reinterpret_cast<const void*>(&alpha),
01458                 reinterpret_cast<const void*>(A.GetData()), A.GetN(),
01459                 reinterpret_cast<void*>(B.GetData()), B.GetN());
01460   }
01461 
01462 
01463   template <class Prop0, class Allocator0,
01464             class Prop1, class Allocator1>
01465   void Mlt(const SeldonSide& Side,
01466            const complex<double> alpha,
01467            const Matrix<complex<double>, Prop0, RowUpTriang, Allocator0>& A,
01468            Matrix<complex<double>, Prop1, RowMajor, Allocator1>& B)
01469   {
01470 
01471 #ifdef SELDON_CHECK_DIMENSIONS
01472     CheckDim(Side, A, B, "Mlt(side, alpha, A, B)");
01473 #endif
01474 
01475     cblas_ztrmm(CblasRowMajor, Side, CblasUpper, CblasNoTrans, CblasNonUnit,
01476                 B.GetM(), B.GetN(),
01477                 reinterpret_cast<const void*>(&alpha),
01478                 reinterpret_cast<const void*>(A.GetData()), A.GetN(),
01479                 reinterpret_cast<void*>(B.GetData()), B.GetN());
01480   }
01481 
01482 
01483   /*** RowUpTriang ***/
01484 
01485 
01486   template <class Prop0, class Allocator0,
01487             class Prop1, class Allocator1>
01488   void Mlt(const SeldonSide& Side,
01489            const float alpha,
01490            const SeldonTranspose& TransA,
01491            const SeldonDiag& DiagA,
01492            const Matrix<float, Prop0, RowUpTriang, Allocator0>& A,
01493            Matrix<float, Prop1, RowMajor, Allocator1>& B)
01494   {
01495 
01496 #ifdef SELDON_CHECK_DIMENSIONS
01497     CheckDim(Side, A, B, "Mlt(side, alpha, status, diag, A, B)");
01498 #endif
01499 
01500     cblas_strmm(CblasRowMajor, Side, CblasUpper, TransA, DiagA,
01501                 B.GetM(), B.GetN(),
01502                 alpha, A.GetData(), A.GetN(), B.GetData(), B.GetN());
01503   }
01504 
01505 
01506   template <class Prop0, class Allocator0,
01507             class Prop1, class Allocator1>
01508   void Mlt(const SeldonSide& Side,
01509            const double alpha,
01510            const SeldonTranspose& TransA,
01511            const SeldonDiag& DiagA,
01512            const Matrix<double, Prop0, RowUpTriang, Allocator0>& A,
01513            Matrix<double, Prop1, RowMajor, Allocator1>& B)
01514   {
01515 
01516 #ifdef SELDON_CHECK_DIMENSIONS
01517     CheckDim(Side, A, B, "Mlt(side, alpha, status, diag, A, B)");
01518 #endif
01519 
01520     cblas_dtrmm(CblasRowMajor, Side, CblasUpper, TransA, DiagA,
01521                 B.GetM(), B.GetN(),
01522                 alpha, A.GetData(), A.GetN(), B.GetData(), B.GetN());
01523   }
01524 
01525 
01526   template <class Prop0, class Allocator0,
01527             class Prop1, class Allocator1>
01528   void Mlt(const SeldonSide& Side,
01529            const complex<float> alpha,
01530            const SeldonTranspose& TransA,
01531            const SeldonDiag& DiagA,
01532            const Matrix<complex<float>, Prop0, RowUpTriang, Allocator0>& A,
01533            Matrix<complex<float>, Prop1, RowMajor, Allocator1>& B)
01534   {
01535 
01536 #ifdef SELDON_CHECK_DIMENSIONS
01537     CheckDim(Side, A, B, "Mlt(side, alpha, status, diag, A, B)");
01538 #endif
01539 
01540     cblas_ctrmm(CblasRowMajor, Side, CblasUpper, TransA, DiagA,
01541                 B.GetM(), B.GetN(),
01542                 reinterpret_cast<const void*>(&alpha),
01543                 reinterpret_cast<const void*>(A.GetData()), A.GetN(),
01544                 reinterpret_cast<void*>(B.GetData()), B.GetN());
01545   }
01546 
01547 
01548   template <class Prop0, class Allocator0,
01549             class Prop1, class Allocator1>
01550   void Mlt(const SeldonSide& Side,
01551            const complex<double> alpha,
01552            const SeldonTranspose& TransA,
01553            const SeldonDiag& DiagA,
01554            const Matrix<complex<double>, Prop0, RowUpTriang, Allocator0>& A,
01555            Matrix<complex<double>, Prop1, RowMajor, Allocator1>& B)
01556   {
01557 
01558 #ifdef SELDON_CHECK_DIMENSIONS
01559     CheckDim(Side, A, B, "Mlt(side, alpha, status, diag, A, B)");
01560 #endif
01561 
01562     cblas_ztrmm(CblasRowMajor, Side, CblasUpper, TransA, DiagA,
01563                 B.GetM(), B.GetN(),
01564                 reinterpret_cast<const void*>(&alpha),
01565                 reinterpret_cast<const void*>(A.GetData()), A.GetN(),
01566                 reinterpret_cast<void*>(B.GetData()), B.GetN());
01567   }
01568 
01569 
01570   /*** RowLoTriang, NoTrans and NonUnit ***/
01571 
01572 
01573   template <class Prop0, class Allocator0,
01574             class Prop1, class Allocator1>
01575   void Mlt(const SeldonSide& Side,
01576            const float alpha,
01577            const Matrix<float, Prop0, RowLoTriang, Allocator0>& A,
01578            Matrix<float, Prop1, RowMajor, Allocator1>& B)
01579   {
01580 
01581 #ifdef SELDON_CHECK_DIMENSIONS
01582     CheckDim(Side, A, B, "Mlt(side, alpha, A, B)");
01583 #endif
01584 
01585     cblas_strmm(CblasRowMajor, Side, CblasLower, CblasNoTrans, CblasNonUnit,
01586                 B.GetM(), B.GetN(),
01587                 alpha, A.GetData(), A.GetN(), B.GetData(), B.GetN());
01588   }
01589 
01590 
01591   template <class Prop0, class Allocator0,
01592             class Prop1, class Allocator1>
01593   void Mlt(const SeldonSide& Side,
01594            const double alpha,
01595            const Matrix<double, Prop0, RowLoTriang, Allocator0>& A,
01596            Matrix<double, Prop1, RowMajor, Allocator1>& B)
01597   {
01598 
01599 #ifdef SELDON_CHECK_DIMENSIONS
01600     CheckDim(Side, A, B, "Mlt(side, alpha, A, B)");
01601 #endif
01602 
01603     cblas_dtrmm(CblasRowMajor, Side, CblasLower, CblasNoTrans, CblasNonUnit,
01604                 B.GetM(), B.GetN(),
01605                 alpha, A.GetData(), A.GetN(), B.GetData(), B.GetN());
01606   }
01607 
01608 
01609   template <class Prop0, class Allocator0,
01610             class Prop1, class Allocator1>
01611   void Mlt(const SeldonSide& Side,
01612            const complex<float> alpha,
01613            const Matrix<complex<float>, Prop0, RowLoTriang, Allocator0>& A,
01614            Matrix<complex<float>, Prop1, RowMajor, Allocator1>& B)
01615   {
01616 
01617 #ifdef SELDON_CHECK_DIMENSIONS
01618     CheckDim(Side, A, B, "Mlt(side, alpha, A, B)");
01619 #endif
01620 
01621     cblas_ctrmm(CblasRowMajor, Side, CblasLower, CblasNoTrans, CblasNonUnit,
01622                 B.GetM(), B.GetN(),
01623                 reinterpret_cast<const void*>(&alpha),
01624                 reinterpret_cast<const void*>(A.GetData()), A.GetN(),
01625                 reinterpret_cast<void*>(B.GetData()), B.GetN());
01626   }
01627 
01628 
01629   template <class Prop0, class Allocator0,
01630             class Prop1, class Allocator1>
01631   void Mlt(const SeldonSide& Side,
01632            const complex<double> alpha,
01633            const Matrix<complex<double>, Prop0, RowLoTriang, Allocator0>& A,
01634            Matrix<complex<double>, Prop1, RowMajor, Allocator1>& B)
01635   {
01636 
01637 #ifdef SELDON_CHECK_DIMENSIONS
01638     CheckDim(Side, A, B, "Mlt(side, alpha, A, B)");
01639 #endif
01640 
01641     cblas_ztrmm(CblasRowMajor, Side, CblasLower, CblasNoTrans, CblasNonUnit,
01642                 B.GetM(), B.GetN(),
01643                 reinterpret_cast<const void*>(&alpha),
01644                 reinterpret_cast<const void*>(A.GetData()), A.GetN(),
01645                 reinterpret_cast<void*>(B.GetData()), B.GetN());
01646   }
01647 
01648 
01649   /*** RowLoTriang ***/
01650 
01651 
01652   template <class Prop0, class Allocator0,
01653             class Prop1, class Allocator1>
01654   void Mlt(const SeldonSide& Side,
01655            const float alpha,
01656            const SeldonTranspose& TransA,
01657            const SeldonDiag& DiagA,
01658            const Matrix<float, Prop0, RowLoTriang, Allocator0>& A,
01659            Matrix<float, Prop1, RowMajor, Allocator1>& B)
01660   {
01661 
01662 #ifdef SELDON_CHECK_DIMENSIONS
01663     CheckDim(Side, A, B, "Mlt(side, alpha, status, diag, A, B)");
01664 #endif
01665 
01666     cblas_strmm(CblasRowMajor, Side, CblasLower, TransA, DiagA,
01667                 B.GetM(), B.GetN(),
01668                 alpha, A.GetData(), A.GetN(), B.GetData(), B.GetN());
01669   }
01670 
01671 
01672   template <class Prop0, class Allocator0,
01673             class Prop1, class Allocator1>
01674   void Mlt(const SeldonSide& Side,
01675            const double alpha,
01676            const SeldonTranspose& TransA,
01677            const SeldonDiag& DiagA,
01678            const Matrix<double, Prop0, RowLoTriang, Allocator0>& A,
01679            Matrix<double, Prop1, RowMajor, Allocator1>& B)
01680   {
01681 
01682 #ifdef SELDON_CHECK_DIMENSIONS
01683     CheckDim(Side, A, B, "Mlt(side, alpha, status, diag, A, B)");
01684 #endif
01685 
01686     cblas_dtrmm(CblasRowMajor, Side, CblasLower, TransA, DiagA,
01687                 B.GetM(), B.GetN(),
01688                 alpha, A.GetData(), A.GetN(), B.GetData(), B.GetN());
01689   }
01690 
01691 
01692   template <class Prop0, class Allocator0,
01693             class Prop1, class Allocator1>
01694   void Mlt(const SeldonSide& Side,
01695            const complex<float> alpha,
01696            const SeldonTranspose& TransA,
01697            const SeldonDiag& DiagA,
01698            const Matrix<complex<float>, Prop0, RowLoTriang, Allocator0>& A,
01699            Matrix<complex<float>, Prop1, RowMajor, Allocator1>& B)
01700   {
01701 
01702 #ifdef SELDON_CHECK_DIMENSIONS
01703     CheckDim(Side, A, B, "Mlt(side, alpha, status, diag, A, B)");
01704 #endif
01705 
01706     cblas_ctrmm(CblasRowMajor, Side, CblasLower, TransA, DiagA,
01707                 B.GetM(), B.GetN(),
01708                 reinterpret_cast<const void*>(&alpha),
01709                 reinterpret_cast<const void*>(A.GetData()), A.GetN(),
01710                 reinterpret_cast<void*>(B.GetData()), B.GetN());
01711   }
01712 
01713 
01714   template <class Prop0, class Allocator0,
01715             class Prop1, class Allocator1>
01716   void Mlt(const SeldonSide& Side,
01717            const complex<double> alpha,
01718            const SeldonTranspose& TransA,
01719            const SeldonDiag& DiagA,
01720            const Matrix<complex<double>, Prop0, RowLoTriang, Allocator0>& A,
01721            Matrix<complex<double>, Prop1, RowMajor, Allocator1>& B)
01722   {
01723 
01724 #ifdef SELDON_CHECK_DIMENSIONS
01725     CheckDim(Side, A, B, "Mlt(side, alpha, status, diag, A, B)");
01726 #endif
01727 
01728     cblas_ztrmm(CblasRowMajor, Side, CblasLower, TransA, DiagA,
01729                 B.GetM(), B.GetN(),
01730                 reinterpret_cast<const void*>(&alpha),
01731                 reinterpret_cast<const void*>(A.GetData()), A.GetN(),
01732                 reinterpret_cast<void*>(B.GetData()), B.GetN());
01733   }
01734 
01735 
01736   // Mlt //
01738 
01739 
01740 
01742   // Solve //
01743 
01744 
01745   /*** ColUpTriang, NoTrans and NonUnit ***/
01746 
01747 
01748   template <class Prop0, class Allocator0,
01749             class Prop1, class Allocator1>
01750   void Solve(const SeldonSide& Side,
01751              const float alpha,
01752              const Matrix<float, Prop0, ColUpTriang, Allocator0>& A,
01753              Matrix<float, Prop1, ColMajor, Allocator1>& B)
01754   {
01755 
01756 #ifdef SELDON_CHECK_DIMENSIONS
01757     CheckDim(Side, A, B, "Solve(side, alpha, A, B)");
01758 #endif
01759 
01760     cblas_strsm(CblasColMajor, Side, CblasUpper, CblasNoTrans, CblasNonUnit,
01761                 B.GetM(), B.GetN(),
01762                 alpha, A.GetData(), A.GetM(), B.GetData(), B.GetM());
01763   }
01764 
01765 
01766   template <class Prop0, class Allocator0,
01767             class Prop1, class Allocator1>
01768   void Solve(const SeldonSide& Side,
01769              const double alpha,
01770              const Matrix<double, Prop0, ColUpTriang, Allocator0>& A,
01771              Matrix<double, Prop1, ColMajor, Allocator1>& B)
01772   {
01773 
01774 #ifdef SELDON_CHECK_DIMENSIONS
01775     CheckDim(Side, A, B, "Solve(side, alpha, A, B)");
01776 #endif
01777 
01778     cblas_dtrsm(CblasColMajor, Side, CblasUpper, CblasNoTrans, CblasNonUnit,
01779                 B.GetM(), B.GetN(),
01780                 alpha, A.GetData(), A.GetM(), B.GetData(), B.GetM());
01781   }
01782 
01783 
01784   template <class Prop0, class Allocator0,
01785             class Prop1, class Allocator1>
01786   void Solve(const SeldonSide& Side,
01787              const complex<float> alpha,
01788              const Matrix<complex<float>, Prop0, ColUpTriang, Allocator0>& A,
01789              Matrix<complex<float>, Prop1, ColMajor, Allocator1>& B)
01790   {
01791 
01792 #ifdef SELDON_CHECK_DIMENSIONS
01793     CheckDim(Side, A, B, "Solve(side, alpha, A, B)");
01794 #endif
01795 
01796     cblas_ctrsm(CblasColMajor, Side, CblasUpper, CblasNoTrans, CblasNonUnit,
01797                 B.GetM(), B.GetN(),
01798                 reinterpret_cast<const void*>(&alpha),
01799                 reinterpret_cast<const void*>(A.GetData()), A.GetM(),
01800                 reinterpret_cast<void*>(B.GetData()), B.GetM());
01801   }
01802 
01803 
01804   template <class Prop0, class Allocator0,
01805             class Prop1, class Allocator1>
01806   void Solve(const SeldonSide& Side,
01807              const complex<double> alpha,
01808              const Matrix<complex<double>, Prop0, ColUpTriang, Allocator0>& A,
01809              Matrix<complex<double>, Prop1, ColMajor, Allocator1>& B)
01810   {
01811 
01812 #ifdef SELDON_CHECK_DIMENSIONS
01813     CheckDim(Side, A, B, "Solve(side, alpha, A, B)");
01814 #endif
01815 
01816     cblas_ztrsm(CblasColMajor, Side, CblasUpper, CblasNoTrans, CblasNonUnit,
01817                 B.GetM(), B.GetN(),
01818                 reinterpret_cast<const void*>(&alpha),
01819                 reinterpret_cast<const void*>(A.GetData()), A.GetM(),
01820                 reinterpret_cast<void*>(B.GetData()), B.GetM());
01821   }
01822 
01823 
01824   /*** ColUpTriang ***/
01825 
01826 
01827   template <class Prop0, class Allocator0,
01828             class Prop1, class Allocator1>
01829   void Solve(const SeldonSide& Side,
01830              const float alpha,
01831              const SeldonTranspose& TransA,
01832              const SeldonDiag& DiagA,
01833              const Matrix<float, Prop0, ColUpTriang, Allocator0>& A,
01834              Matrix<float, Prop1, ColMajor, Allocator1>& B)
01835   {
01836 
01837 #ifdef SELDON_CHECK_DIMENSIONS
01838     CheckDim(Side, A, B, "Solve(side, alpha, status, diag, A, B)");
01839 #endif
01840 
01841     cblas_strsm(CblasColMajor, Side, CblasUpper, TransA, DiagA,
01842                 B.GetM(), B.GetN(),
01843                 alpha, A.GetData(), A.GetM(), B.GetData(), B.GetM());
01844   }
01845 
01846 
01847   template <class Prop0, class Allocator0,
01848             class Prop1, class Allocator1>
01849   void Solve(const SeldonSide& Side,
01850              const double alpha,
01851              const SeldonTranspose& TransA,
01852              const SeldonDiag& DiagA,
01853              const Matrix<double, Prop0, ColUpTriang, Allocator0>& A,
01854              Matrix<double, Prop1, ColMajor, Allocator1>& B)
01855   {
01856 
01857 #ifdef SELDON_CHECK_DIMENSIONS
01858     CheckDim(Side, A, B, "Solve(side, alpha, status, diag, A, B)");
01859 #endif
01860 
01861     cblas_dtrsm(CblasColMajor, Side, CblasUpper, TransA, DiagA,
01862                 B.GetM(), B.GetN(),
01863                 alpha, A.GetData(), A.GetM(), B.GetData(), B.GetM());
01864   }
01865 
01866 
01867   template <class Prop0, class Allocator0,
01868             class Prop1, class Allocator1>
01869   void Solve(const SeldonSide& Side,
01870              const complex<float> alpha,
01871              const SeldonTranspose& TransA,
01872              const SeldonDiag& DiagA,
01873              const Matrix<complex<float>, Prop0, ColUpTriang, Allocator0>& A,
01874              Matrix<complex<float>, Prop1, ColMajor, Allocator1>& B)
01875   {
01876 
01877 #ifdef SELDON_CHECK_DIMENSIONS
01878     CheckDim(Side, A, B, "Solve(side, alpha, status, diag, A, B)");
01879 #endif
01880 
01881     cblas_ctrsm(CblasColMajor, Side, CblasUpper, TransA, DiagA,
01882                 B.GetM(), B.GetN(),
01883                 reinterpret_cast<const void*>(&alpha),
01884                 reinterpret_cast<const void*>(A.GetData()), A.GetM(),
01885                 reinterpret_cast<void*>(B.GetData()), B.GetM());
01886   }
01887 
01888 
01889   template <class Prop0, class Allocator0,
01890             class Prop1, class Allocator1>
01891   void Solve(const SeldonSide& Side,
01892              const complex<double> alpha,
01893              const SeldonTranspose& TransA,
01894              const SeldonDiag& DiagA,
01895              const Matrix<complex<double>, Prop0, ColUpTriang, Allocator0>& A,
01896              Matrix<complex<double>, Prop1, ColMajor, Allocator1>& B)
01897   {
01898 
01899 #ifdef SELDON_CHECK_DIMENSIONS
01900     CheckDim(Side, A, B, "Solve(side, alpha, status, diag, A, B)");
01901 #endif
01902 
01903     cblas_ztrsm(CblasColMajor, Side, CblasUpper, TransA, DiagA,
01904                 B.GetM(), B.GetN(),
01905                 reinterpret_cast<const void*>(&alpha),
01906                 reinterpret_cast<const void*>(A.GetData()), A.GetM(),
01907                 reinterpret_cast<void*>(B.GetData()), B.GetM());
01908   }
01909 
01910 
01911   /*** ColLoTriang, NoTrans and NonUnit ***/
01912 
01913 
01914   template <class Prop0, class Allocator0,
01915             class Prop1, class Allocator1>
01916   void Solve(const SeldonSide& Side,
01917              const float alpha,
01918              const Matrix<float, Prop0, ColLoTriang, Allocator0>& A,
01919              Matrix<float, Prop1, ColMajor, Allocator1>& B)
01920   {
01921 
01922 #ifdef SELDON_CHECK_DIMENSIONS
01923     CheckDim(Side, A, B, "Solve(side, alpha, A, B)");
01924 #endif
01925 
01926     cblas_strsm(CblasColMajor, Side, CblasLower, CblasNoTrans, CblasNonUnit,
01927                 B.GetM(), B.GetN(),
01928                 alpha, A.GetData(), A.GetM(), B.GetData(), B.GetM());
01929   }
01930 
01931 
01932   template <class Prop0, class Allocator0,
01933             class Prop1, class Allocator1>
01934   void Solve(const SeldonSide& Side,
01935              const double alpha,
01936              const Matrix<double, Prop0, ColLoTriang, Allocator0>& A,
01937              Matrix<double, Prop1, ColMajor, Allocator1>& B)
01938   {
01939 
01940 #ifdef SELDON_CHECK_DIMENSIONS
01941     CheckDim(Side, A, B, "Solve(side, alpha, A, B)");
01942 #endif
01943 
01944     cblas_dtrsm(CblasColMajor, Side, CblasLower, CblasNoTrans, CblasNonUnit,
01945                 B.GetM(), B.GetN(),
01946                 alpha, A.GetData(), A.GetM(), B.GetData(), B.GetM());
01947   }
01948 
01949 
01950   template <class Prop0, class Allocator0,
01951             class Prop1, class Allocator1>
01952   void Solve(const SeldonSide& Side,
01953              const complex<float> alpha,
01954              const Matrix<complex<float>, Prop0, ColLoTriang, Allocator0>& A,
01955              Matrix<complex<float>, Prop1, ColMajor, Allocator1>& B)
01956   {
01957 
01958 #ifdef SELDON_CHECK_DIMENSIONS
01959     CheckDim(Side, A, B, "Solve(side, alpha, A, B)");
01960 #endif
01961 
01962     cblas_ctrsm(CblasColMajor, Side, CblasLower, CblasNoTrans, CblasNonUnit,
01963                 B.GetM(), B.GetN(),
01964                 reinterpret_cast<const void*>(&alpha),
01965                 reinterpret_cast<const void*>(A.GetData()), A.GetM(),
01966                 reinterpret_cast<void*>(B.GetData()), B.GetM());
01967   }
01968 
01969 
01970   template <class Prop0, class Allocator0,
01971             class Prop1, class Allocator1>
01972   void Solve(const SeldonSide& Side,
01973              const complex<double> alpha,
01974              const Matrix<complex<double>, Prop0, ColLoTriang, Allocator0>& A,
01975              Matrix<complex<double>, Prop1, ColMajor, Allocator1>& B)
01976   {
01977 
01978 #ifdef SELDON_CHECK_DIMENSIONS
01979     CheckDim(Side, A, B, "Solve(side, alpha, A, B)");
01980 #endif
01981 
01982     cblas_ztrsm(CblasColMajor, Side, CblasLower, CblasNoTrans, CblasNonUnit,
01983                 B.GetM(), B.GetN(),
01984                 reinterpret_cast<const void*>(&alpha),
01985                 reinterpret_cast<const void*>(A.GetData()), A.GetM(),
01986                 reinterpret_cast<void*>(B.GetData()), B.GetM());
01987   }
01988 
01989 
01990   /*** ColLoTriang ***/
01991 
01992 
01993   template <class Prop0, class Allocator0,
01994             class Prop1, class Allocator1>
01995   void Solve(const SeldonSide& Side,
01996              const float alpha,
01997              const SeldonTranspose& TransA,
01998              const SeldonDiag& DiagA,
01999              const Matrix<float, Prop0, ColLoTriang, Allocator0>& A,
02000              Matrix<float, Prop1, ColMajor, Allocator1>& B)
02001   {
02002 
02003 #ifdef SELDON_CHECK_DIMENSIONS
02004     CheckDim(Side, A, B, "Solve(side, alpha, status, diag, A, B)");
02005 #endif
02006 
02007     cblas_strsm(CblasColMajor, Side, CblasLower, TransA, DiagA,
02008                 B.GetM(), B.GetN(),
02009                 alpha, A.GetData(), A.GetM(), B.GetData(), B.GetM());
02010   }
02011 
02012 
02013   template <class Prop0, class Allocator0,
02014             class Prop1, class Allocator1>
02015   void Solve(const SeldonSide& Side,
02016              const double alpha,
02017              const SeldonTranspose& TransA,
02018              const SeldonDiag& DiagA,
02019              const Matrix<double, Prop0, ColLoTriang, Allocator0>& A,
02020              Matrix<double, Prop1, ColMajor, Allocator1>& B)
02021   {
02022 
02023 #ifdef SELDON_CHECK_DIMENSIONS
02024     CheckDim(Side, A, B, "Solve(side, alpha, status, diag, A, B)");
02025 #endif
02026 
02027     cblas_dtrsm(CblasColMajor, Side, CblasLower, TransA, DiagA,
02028                 B.GetM(), B.GetN(),
02029                 alpha, A.GetData(), A.GetM(), B.GetData(), B.GetM());
02030   }
02031 
02032 
02033   template <class Prop0, class Allocator0,
02034             class Prop1, class Allocator1>
02035   void Solve(const SeldonSide& Side,
02036              const complex<float> alpha,
02037              const SeldonTranspose& TransA,
02038              const SeldonDiag& DiagA,
02039              const Matrix<complex<float>, Prop0, ColLoTriang, Allocator0>& A,
02040              Matrix<complex<float>, Prop1, ColMajor, Allocator1>& B)
02041   {
02042 
02043 #ifdef SELDON_CHECK_DIMENSIONS
02044     CheckDim(Side, A, B, "Solve(side, alpha, status, diag, A, B)");
02045 #endif
02046 
02047     cblas_ctrsm(CblasColMajor, Side, CblasLower, TransA, DiagA,
02048                 B.GetM(), B.GetN(),
02049                 reinterpret_cast<const void*>(&alpha),
02050                 reinterpret_cast<const void*>(A.GetData()), A.GetM(),
02051                 reinterpret_cast<void*>(B.GetData()), B.GetM());
02052   }
02053 
02054 
02055   template <class Prop0, class Allocator0,
02056             class Prop1, class Allocator1>
02057   void Solve(const SeldonSide& Side,
02058              const complex<double> alpha,
02059              const SeldonTranspose& TransA,
02060              const SeldonDiag& DiagA,
02061              const Matrix<complex<double>, Prop0, ColLoTriang, Allocator0>& A,
02062              Matrix<complex<double>, Prop1, ColMajor, Allocator1>& B)
02063   {
02064 
02065 #ifdef SELDON_CHECK_DIMENSIONS
02066     CheckDim(Side, A, B, "Solve(side, alpha, status, diag, A, B)");
02067 #endif
02068 
02069     cblas_ztrsm(CblasColMajor, Side, CblasLower, TransA, DiagA,
02070                 B.GetM(), B.GetN(),
02071                 reinterpret_cast<const void*>(&alpha),
02072                 reinterpret_cast<const void*>(A.GetData()), A.GetM(),
02073                 reinterpret_cast<void*>(B.GetData()), B.GetM());
02074   }
02075 
02076 
02077   /*** RowUpTriang, NoTrans and NonUnit ***/
02078 
02079 
02080   template <class Prop0, class Allocator0,
02081             class Prop1, class Allocator1>
02082   void Solve(const SeldonSide& Side,
02083              const float alpha,
02084              const Matrix<float, Prop0, RowUpTriang, Allocator0>& A,
02085              Matrix<float, Prop1, RowMajor, Allocator1>& B)
02086   {
02087 
02088 #ifdef SELDON_CHECK_DIMENSIONS
02089     CheckDim(Side, A, B, "Solve(side, alpha, A, B)");
02090 #endif
02091 
02092     cblas_strsm(CblasRowMajor, Side, CblasUpper, CblasNoTrans, CblasNonUnit,
02093                 B.GetM(), B.GetN(),
02094                 alpha, A.GetData(), A.GetN(), B.GetData(), B.GetN());
02095   }
02096 
02097 
02098   template <class Prop0, class Allocator0,
02099             class Prop1, class Allocator1>
02100   void Solve(const SeldonSide& Side,
02101              const double alpha,
02102              const Matrix<double, Prop0, RowUpTriang, Allocator0>& A,
02103              Matrix<double, Prop1, RowMajor, Allocator1>& B)
02104   {
02105 
02106 #ifdef SELDON_CHECK_DIMENSIONS
02107     CheckDim(Side, A, B, "Solve(side, alpha, A, B)");
02108 #endif
02109 
02110     cblas_dtrsm(CblasRowMajor, Side, CblasUpper, CblasNoTrans, CblasNonUnit,
02111                 B.GetM(), B.GetN(),
02112                 alpha, A.GetData(), A.GetN(), B.GetData(), B.GetN());
02113   }
02114 
02115 
02116   template <class Prop0, class Allocator0,
02117             class Prop1, class Allocator1>
02118   void Solve(const SeldonSide& Side,
02119              const complex<float> alpha,
02120              const Matrix<complex<float>, Prop0, RowUpTriang, Allocator0>& A,
02121              Matrix<complex<float>, Prop1, RowMajor, Allocator1>& B)
02122   {
02123 
02124 #ifdef SELDON_CHECK_DIMENSIONS
02125     CheckDim(Side, A, B, "Solve(side, alpha, A, B)");
02126 #endif
02127 
02128     cblas_ctrsm(CblasRowMajor, Side, CblasUpper, CblasNoTrans, CblasNonUnit,
02129                 B.GetM(), B.GetN(),
02130                 reinterpret_cast<const void*>(&alpha),
02131                 reinterpret_cast<const void*>(A.GetData()), A.GetN(),
02132                 reinterpret_cast<void*>(B.GetData()), B.GetN());
02133   }
02134 
02135 
02136   template <class Prop0, class Allocator0,
02137             class Prop1, class Allocator1>
02138   void Solve(const SeldonSide& Side,
02139              const complex<double> alpha,
02140              const Matrix<complex<double>, Prop0, RowUpTriang, Allocator0>& A,
02141              Matrix<complex<double>, Prop1, RowMajor, Allocator1>& B)
02142   {
02143 
02144 #ifdef SELDON_CHECK_DIMENSIONS
02145     CheckDim(Side, A, B, "Solve(side, alpha, A, B)");
02146 #endif
02147 
02148     cblas_ztrsm(CblasRowMajor, Side, CblasUpper, CblasNoTrans, CblasNonUnit,
02149                 B.GetM(), B.GetN(),
02150                 reinterpret_cast<const void*>(&alpha),
02151                 reinterpret_cast<const void*>(A.GetData()), A.GetN(),
02152                 reinterpret_cast<void*>(B.GetData()), B.GetN());
02153   }
02154 
02155 
02156   /*** RowUpTriang ***/
02157 
02158 
02159   template <class Prop0, class Allocator0,
02160             class Prop1, class Allocator1>
02161   void Solve(const SeldonSide& Side,
02162              const float alpha,
02163              const SeldonTranspose& TransA,
02164              const SeldonDiag& DiagA,
02165              const Matrix<float, Prop0, RowUpTriang, Allocator0>& A,
02166              Matrix<float, Prop1, RowMajor, Allocator1>& B)
02167   {
02168 
02169 #ifdef SELDON_CHECK_DIMENSIONS
02170     CheckDim(Side, A, B, "Solve(side, alpha, status, diag, A, B)");
02171 #endif
02172 
02173     cblas_strsm(CblasRowMajor, Side, CblasUpper, TransA, DiagA,
02174                 B.GetM(), B.GetN(),
02175                 alpha, A.GetData(), A.GetN(), B.GetData(), B.GetN());
02176   }
02177 
02178 
02179   template <class Prop0, class Allocator0,
02180             class Prop1, class Allocator1>
02181   void Solve(const SeldonSide& Side,
02182              const double alpha,
02183              const SeldonTranspose& TransA,
02184              const SeldonDiag& DiagA,
02185              const Matrix<double, Prop0, RowUpTriang, Allocator0>& A,
02186              Matrix<double, Prop1, RowMajor, Allocator1>& B)
02187   {
02188 
02189 #ifdef SELDON_CHECK_DIMENSIONS
02190     CheckDim(Side, A, B, "Solve(side, alpha, status, diag, A, B)");
02191 #endif
02192 
02193     cblas_dtrsm(CblasRowMajor, Side, CblasUpper, TransA, DiagA,
02194                 B.GetM(), B.GetN(),
02195                 alpha, A.GetData(), A.GetN(), B.GetData(), B.GetN());
02196   }
02197 
02198 
02199   template <class Prop0, class Allocator0,
02200             class Prop1, class Allocator1>
02201   void Solve(const SeldonSide& Side,
02202              const complex<float> alpha,
02203              const SeldonTranspose& TransA,
02204              const SeldonDiag& DiagA,
02205              const Matrix<complex<float>, Prop0, RowUpTriang, Allocator0>& A,
02206              Matrix<complex<float>, Prop1, RowMajor, Allocator1>& B)
02207   {
02208 
02209 #ifdef SELDON_CHECK_DIMENSIONS
02210     CheckDim(Side, A, B, "Solve(side, alpha, status, diag, A, B)");
02211 #endif
02212 
02213     cblas_ctrsm(CblasRowMajor, Side, CblasUpper, TransA, DiagA,
02214                 B.GetM(), B.GetN(),
02215                 reinterpret_cast<const void*>(&alpha),
02216                 reinterpret_cast<const void*>(A.GetData()), A.GetN(),
02217                 reinterpret_cast<void*>(B.GetData()), B.GetN());
02218   }
02219 
02220 
02221   template <class Prop0, class Allocator0,
02222             class Prop1, class Allocator1>
02223   void Solve(const SeldonSide& Side,
02224              const complex<double> alpha,
02225              const SeldonTranspose& TransA,
02226              const SeldonDiag& DiagA,
02227              const Matrix<complex<double>, Prop0, RowUpTriang, Allocator0>& A,
02228              Matrix<complex<double>, Prop1, RowMajor, Allocator1>& B)
02229   {
02230 
02231 #ifdef SELDON_CHECK_DIMENSIONS
02232     CheckDim(Side, A, B, "Solve(side, alpha, status, diag, A, B)");
02233 #endif
02234 
02235     cblas_ztrsm(CblasRowMajor, Side, CblasUpper, TransA, DiagA,
02236                 B.GetM(), B.GetN(),
02237                 reinterpret_cast<const void*>(&alpha),
02238                 reinterpret_cast<const void*>(A.GetData()), A.GetN(),
02239                 reinterpret_cast<void*>(B.GetData()), B.GetN());
02240   }
02241 
02242 
02243   /*** RowLoTriang, NoTrans and NonUnit ***/
02244 
02245 
02246   template <class Prop0, class Allocator0,
02247             class Prop1, class Allocator1>
02248   void Solve(const SeldonSide& Side,
02249              const float alpha,
02250              const Matrix<float, Prop0, RowLoTriang, Allocator0>& A,
02251              Matrix<float, Prop1, RowMajor, Allocator1>& B)
02252   {
02253 
02254 #ifdef SELDON_CHECK_DIMENSIONS
02255     CheckDim(Side, A, B, "Solve(side, alpha, A, B)");
02256 #endif
02257 
02258     cblas_strsm(CblasRowMajor, Side, CblasLower, CblasNoTrans, CblasNonUnit,
02259                 B.GetM(), B.GetN(),
02260                 alpha, A.GetData(), A.GetN(), B.GetData(), B.GetN());
02261   }
02262 
02263 
02264   template <class Prop0, class Allocator0,
02265             class Prop1, class Allocator1>
02266   void Solve(const SeldonSide& Side,
02267              const double alpha,
02268              const Matrix<double, Prop0, RowLoTriang, Allocator0>& A,
02269              Matrix<double, Prop1, RowMajor, Allocator1>& B)
02270   {
02271 
02272 #ifdef SELDON_CHECK_DIMENSIONS
02273     CheckDim(Side, A, B, "Solve(side, alpha, A, B)");
02274 #endif
02275 
02276     cblas_dtrsm(CblasRowMajor, Side, CblasLower, CblasNoTrans, CblasNonUnit,
02277                 B.GetM(), B.GetN(),
02278                 alpha, A.GetData(), A.GetN(), B.GetData(), B.GetN());
02279   }
02280 
02281 
02282   template <class Prop0, class Allocator0,
02283             class Prop1, class Allocator1>
02284   void Solve(const SeldonSide& Side,
02285              const complex<float> alpha,
02286              const Matrix<complex<float>, Prop0, RowLoTriang, Allocator0>& A,
02287              Matrix<complex<float>, Prop1, RowMajor, Allocator1>& B)
02288   {
02289 
02290 #ifdef SELDON_CHECK_DIMENSIONS
02291     CheckDim(Side, A, B, "Solve(side, alpha, A, B)");
02292 #endif
02293 
02294     cblas_ctrsm(CblasRowMajor, Side, CblasLower, CblasNoTrans, CblasNonUnit,
02295                 B.GetM(), B.GetN(),
02296                 reinterpret_cast<const void*>(&alpha),
02297                 reinterpret_cast<const void*>(A.GetData()), A.GetN(),
02298                 reinterpret_cast<void*>(B.GetData()), B.GetN());
02299   }
02300 
02301 
02302   template <class Prop0, class Allocator0,
02303             class Prop1, class Allocator1>
02304   void Solve(const SeldonSide& Side,
02305              const complex<double> alpha,
02306              const Matrix<complex<double>, Prop0, RowLoTriang, Allocator0>& A,
02307              Matrix<complex<double>, Prop1, RowMajor, Allocator1>& B)
02308   {
02309 
02310 #ifdef SELDON_CHECK_DIMENSIONS
02311     CheckDim(Side, A, B, "Solve(side, alpha, A, B)");
02312 #endif
02313 
02314     cblas_ztrsm(CblasRowMajor, Side, CblasLower, CblasNoTrans, CblasNonUnit,
02315                 B.GetM(), B.GetN(),
02316                 reinterpret_cast<const void*>(&alpha),
02317                 reinterpret_cast<const void*>(A.GetData()), A.GetN(),
02318                 reinterpret_cast<void*>(B.GetData()), B.GetN());
02319   }
02320 
02321 
02322   /*** RowLoTriang ***/
02323 
02324 
02325   template <class Prop0, class Allocator0,
02326             class Prop1, class Allocator1>
02327   void Solve(const SeldonSide& Side,
02328              const float alpha,
02329              const SeldonTranspose& TransA,
02330              const SeldonDiag& DiagA,
02331              const Matrix<float, Prop0, RowLoTriang, Allocator0>& A,
02332              Matrix<float, Prop1, RowMajor, Allocator1>& B)
02333   {
02334 
02335 #ifdef SELDON_CHECK_DIMENSIONS
02336     CheckDim(Side, A, B, "Solve(side, alpha, status, diag, A, B)");
02337 #endif
02338 
02339     cblas_strsm(CblasRowMajor, Side, CblasLower, TransA, DiagA,
02340                 B.GetM(), B.GetN(),
02341                 alpha, A.GetData(), A.GetN(), B.GetData(), B.GetN());
02342   }
02343 
02344 
02345   template <class Prop0, class Allocator0,
02346             class Prop1, class Allocator1>
02347   void Solve(const SeldonSide& Side,
02348              const double alpha,
02349              const SeldonTranspose& TransA,
02350              const SeldonDiag& DiagA,
02351              const Matrix<double, Prop0, RowLoTriang, Allocator0>& A,
02352              Matrix<double, Prop1, RowMajor, Allocator1>& B)
02353   {
02354 
02355 #ifdef SELDON_CHECK_DIMENSIONS
02356     CheckDim(Side, A, B, "Solve(side, alpha, status, diag, A, B)");
02357 #endif
02358 
02359     cblas_dtrsm(CblasRowMajor, Side, CblasLower, TransA, DiagA,
02360                 B.GetM(), B.GetN(),
02361                 alpha, A.GetData(), A.GetN(), B.GetData(), B.GetN());
02362   }
02363 
02364 
02365   template <class Prop0, class Allocator0,
02366             class Prop1, class Allocator1>
02367   void Solve(const SeldonSide& Side,
02368              const complex<float> alpha,
02369              const SeldonTranspose& TransA,
02370              const SeldonDiag& DiagA,
02371              const Matrix<complex<float>, Prop0, RowLoTriang, Allocator0>& A,
02372              Matrix<complex<float>, Prop1, RowMajor, Allocator1>& B)
02373   {
02374 
02375 #ifdef SELDON_CHECK_DIMENSIONS
02376     CheckDim(Side, A, B, "Solve(side, alpha, status, diag, A, B)");
02377 #endif
02378 
02379     cblas_ctrsm(CblasRowMajor, Side, CblasLower, TransA, DiagA,
02380                 B.GetM(), B.GetN(),
02381                 reinterpret_cast<const void*>(&alpha),
02382                 reinterpret_cast<const void*>(A.GetData()), A.GetN(),
02383                 reinterpret_cast<void*>(B.GetData()), B.GetN());
02384   }
02385 
02386 
02387   template <class Prop0, class Allocator0,
02388             class Prop1, class Allocator1>
02389   void Solve(const SeldonSide& Side,
02390              const complex<double> alpha,
02391              const SeldonTranspose& TransA,
02392              const SeldonDiag& DiagA,
02393              const Matrix<complex<double>, Prop0, RowLoTriang, Allocator0>& A,
02394              Matrix<complex<double>, Prop1, RowMajor, Allocator1>& B)
02395   {
02396 
02397 #ifdef SELDON_CHECK_DIMENSIONS
02398     CheckDim(Side, A, B, "Solve(side, alpha, status, diag, A, B)");
02399 #endif
02400 
02401     cblas_ztrsm(CblasRowMajor, Side, CblasLower, TransA, DiagA,
02402                 B.GetM(), B.GetN(),
02403                 reinterpret_cast<const void*>(&alpha),
02404                 reinterpret_cast<const void*>(A.GetData()), A.GetN(),
02405                 reinterpret_cast<void*>(B.GetData()), B.GetN());
02406   }
02407 
02408 
02409   // Solve //
02411 
02412 
02413 } // namespace Seldon.
02414 
02415 #define SELDON_FILE_BLAS_3_CXX
02416 #endif
Email Contact