00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 #ifndef SELDON_FILE_LAPACK_LINEAREQUATIONS_CXX
00022
00023
00024 #include "Lapack_LinearEquations.hxx"
00025
00026
00027 namespace Seldon
00028 {
00029
00030
00032
00033
00034
00035
00036
00037
00038 template <class Prop0, class Allocator0,
00039 class Allocator1>
00040 void GetLU(Matrix<float, Prop0, ColMajor, Allocator0>& A,
00041 Vector<int, VectFull, Allocator1>& P,
00042 LapackInfo& info)
00043 {
00044 int m = A.GetM();
00045 int n = A.GetN();
00046 #ifdef SELDON_CHECK_BOUNDS
00047 if ((m <= 0)||(n <= 0))
00048 throw WrongDim("GetLU", "Provide a non-empty matrix");
00049 #endif
00050
00051 P.Reallocate(min(m, n));
00052 sgetrf_(&m, &n, A.GetData(), &m,
00053 P.GetData(), &info.GetInfoRef());
00054
00055 #ifdef SELDON_LAPACK_CHECK_INFO
00056 if (info.GetInfo() != 0)
00057 throw LapackError(info.GetInfo(), "GetLU",
00058 "An error occured during the factorization.");
00059 #endif
00060
00061 }
00062
00063
00064 template <class Prop0, class Allocator0,
00065 class Allocator1>
00066 void GetLU(Matrix<double, Prop0, ColMajor, Allocator0>& A,
00067 Vector<int, VectFull, Allocator1>& P,
00068 LapackInfo& info)
00069 {
00070 int m = A.GetM();
00071 int n = A.GetN();
00072
00073 #ifdef SELDON_CHECK_BOUNDS
00074 if ((m <= 0)||(n <= 0))
00075 throw WrongDim("GetLU", "Provide a non-empty matrix");
00076 #endif
00077
00078 P.Reallocate(min(m, n));
00079 dgetrf_(&m, &n, A.GetData(), &m,
00080 P.GetData(), &info.GetInfoRef());
00081
00082 #ifdef SELDON_LAPACK_CHECK_INFO
00083 if (info.GetInfo() != 0)
00084 throw LapackError(info.GetInfo(), "GetLU",
00085 "An error occured during the factorization.");
00086 #endif
00087
00088 }
00089
00090
00091 template <class Prop0, class Allocator0,
00092 class Allocator1>
00093 void GetLU(Matrix<complex<float>, Prop0, ColMajor, Allocator0>& A,
00094 Vector<int, VectFull, Allocator1>& P,
00095 LapackInfo& info)
00096 {
00097 int m = A.GetM();
00098 int n = A.GetN();
00099
00100 #ifdef SELDON_CHECK_BOUNDS
00101 if ((m <= 0)||(n <= 0))
00102 throw WrongDim("GetLU", "Provide a non-empty matrix");
00103 #endif
00104
00105 P.Reallocate(min(m, n));
00106 cgetrf_(&m, &n, A.GetDataVoid(), &m,
00107 P.GetData(), &info.GetInfoRef());
00108
00109 #ifdef SELDON_LAPACK_CHECK_INFO
00110 if (info.GetInfo() != 0)
00111 throw LapackError(info.GetInfo(), "GetLU",
00112 "An error occured during the factorization.");
00113 #endif
00114
00115 }
00116
00117
00118 template <class Prop0, class Allocator0,
00119 class Allocator1>
00120 void GetLU(Matrix<complex<double>, Prop0, ColMajor, Allocator0>& A,
00121 Vector<int, VectFull, Allocator1>& P,
00122 LapackInfo& info)
00123 {
00124 int m = A.GetM();
00125 int n = A.GetN();
00126
00127 #ifdef SELDON_CHECK_BOUNDS
00128 if ((m <= 0)||(n <= 0))
00129 throw WrongDim("GetLU", "Provide a non-empty matrix");
00130 #endif
00131
00132 P.Reallocate(min(m, n));
00133 zgetrf_(&m, &n, A.GetDataVoid(), &m,
00134 P.GetData(), &info.GetInfoRef());
00135
00136 #ifdef SELDON_LAPACK_CHECK_INFO
00137 if (info.GetInfo() != 0)
00138 throw LapackError(info.GetInfo(), "GetLU",
00139 "An error occured during the factorization.");
00140 #endif
00141
00142 }
00143
00144
00145
00146
00147
00148 template <class Prop0, class Allocator0,
00149 class Allocator1>
00150 void GetLU(Matrix<float, Prop0, RowMajor, Allocator0>& A,
00151 Vector<int, VectFull, Allocator1>& P,
00152 LapackInfo& info)
00153 {
00154 int m = A.GetM();
00155 int n = A.GetN();
00156
00157 #ifdef SELDON_CHECK_BOUNDS
00158 if ((m <= 0)||(n <= 0))
00159 throw WrongDim("GetLU", "Provide a non-empty matrix");
00160 #endif
00161
00162 P.Reallocate(min(m, n));
00163 sgetrf_(&m, &n, A.GetData(), &m,
00164 P.GetData(), &info.GetInfoRef());
00165
00166 #ifdef SELDON_LAPACK_CHECK_INFO
00167 if (info.GetInfo() != 0)
00168 throw LapackError(info.GetInfo(), "GetLU",
00169 "An error occured during the factorization.");
00170 #endif
00171
00172 }
00173
00174
00175 template <class Prop0, class Allocator0,
00176 class Allocator1>
00177 void GetLU(Matrix<double, Prop0, RowMajor, Allocator0>& A,
00178 Vector<int, VectFull, Allocator1>& P,
00179 LapackInfo& info)
00180 {
00181 int m = A.GetM();
00182 int n = A.GetN();
00183
00184 #ifdef SELDON_CHECK_BOUNDS
00185 if ((m <= 0)||(n <= 0))
00186 throw WrongDim("GetLU", "Provide a non-empty matrix");
00187 #endif
00188
00189 P.Reallocate(min(m, n));
00190 dgetrf_(&m, &n, A.GetData(), &m,
00191 P.GetData(), &info.GetInfoRef());
00192
00193 #ifdef SELDON_LAPACK_CHECK_INFO
00194 if (info.GetInfo() != 0)
00195 throw LapackError(info.GetInfo(), "GetLU",
00196 "An error occured during the factorization.");
00197 #endif
00198
00199 }
00200
00201
00202 template <class Prop0, class Allocator0,
00203 class Allocator1>
00204 void GetLU(Matrix<complex<float>, Prop0, RowMajor, Allocator0>& A,
00205 Vector<int, VectFull, Allocator1>& P,
00206 LapackInfo& info)
00207 {
00208 int m = A.GetM();
00209 int n = A.GetN();
00210
00211 #ifdef SELDON_CHECK_BOUNDS
00212 if ((m <= 0)||(n <= 0))
00213 throw WrongDim("GetLU", "Provide a non-empty matrix");
00214 #endif
00215
00216 P.Reallocate(min(m, n));
00217 cgetrf_(&m, &n, A.GetDataVoid(), &m,
00218 P.GetData(), &info.GetInfoRef());
00219
00220 #ifdef SELDON_LAPACK_CHECK_INFO
00221 if (info.GetInfo() != 0)
00222 throw LapackError(info.GetInfo(), "GetLU",
00223 "An error occured during the factorization.");
00224 #endif
00225
00226 }
00227
00228
00229 template <class Prop0, class Allocator0,
00230 class Allocator1>
00231 void GetLU(Matrix<complex<double>, Prop0, RowMajor, Allocator0>& A,
00232 Vector<int, VectFull, Allocator1>& P,
00233 LapackInfo& info)
00234 {
00235 int m = A.GetM();
00236 int n = A.GetN();
00237
00238 #ifdef SELDON_CHECK_BOUNDS
00239 if ((m <= 0)||(n <= 0))
00240 throw WrongDim("GetLU", "Provide a non-empty matrix");
00241 #endif
00242
00243 P.Reallocate(min(m, n));
00244 zgetrf_(&m, &n, A.GetDataVoid(), &m,
00245 P.GetData(), &info.GetInfoRef());
00246
00247 #ifdef SELDON_LAPACK_CHECK_INFO
00248 if (info.GetInfo() != 0)
00249 throw LapackError(info.GetInfo(), "GetLU",
00250 "An error occured during the factorization.");
00251 #endif
00252
00253 }
00254
00255
00256
00257
00258
00259 template <class Prop0, class Allocator0,
00260 class Allocator1>
00261 void GetLU(Matrix<float, Prop0, ColSym, Allocator0>& A,
00262 Vector<int, VectFull, Allocator1>& P,
00263 LapackInfo& info)
00264 {
00265 int m = A.GetM();
00266
00267 #ifdef SELDON_CHECK_BOUNDS
00268 if (m <= 0)
00269 throw WrongDim("GetLU", "Provide a non-empty matrix");
00270 #endif
00271
00272 int lwork = m;
00273 char uplo('U');
00274 Vector<float,VectFull,Allocator0> work(lwork);
00275 P.Reallocate(m);
00276 ssytrf_(&uplo, &m, A.GetData(), &m,
00277 P.GetData(), work.GetData(), &lwork, &info.GetInfoRef());
00278
00279 #ifdef SELDON_LAPACK_CHECK_INFO
00280 if (info.GetInfo() != 0)
00281 throw LapackError(info.GetInfo(), "GetLU",
00282 "An error occured during the factorization.");
00283 #endif
00284
00285 }
00286
00287
00288 template <class Prop0, class Allocator0,
00289 class Allocator1>
00290 void GetLU(Matrix<double, Prop0, ColSym, Allocator0>& A,
00291 Vector<int, VectFull, Allocator1>& P,
00292 LapackInfo& info)
00293 {
00294 int m = A.GetM();
00295 int lwork = m;
00296
00297 #ifdef SELDON_CHECK_BOUNDS
00298 if (m <= 0)
00299 throw WrongDim("GetLU", "Provide a non-empty matrix");
00300 #endif
00301
00302 char uplo('U');
00303 Vector<double,VectFull,Allocator0> work(lwork);
00304 P.Reallocate(m);
00305 dsytrf_(&uplo, &m, A.GetData(), &m,
00306 P.GetData(), work.GetData(), &lwork, &info.GetInfoRef());
00307
00308 #ifdef SELDON_LAPACK_CHECK_INFO
00309 if (info.GetInfo() != 0)
00310 throw LapackError(info.GetInfo(), "GetLU",
00311 "An error occured during the factorization.");
00312 #endif
00313
00314 }
00315
00316
00317 template <class Prop0, class Allocator0,
00318 class Allocator1>
00319 void GetLU(Matrix<complex<float>, Prop0, ColSym, Allocator0>& A,
00320 Vector<int, VectFull, Allocator1>& P,
00321 LapackInfo& info)
00322 {
00323 int m = A.GetM();
00324 int lwork = m;
00325
00326 #ifdef SELDON_CHECK_BOUNDS
00327 if (m <= 0)
00328 throw WrongDim("GetLU", "Provide a non-empty matrix");
00329 #endif
00330
00331 char uplo('U');
00332 Vector<complex<float>,VectFull,Allocator0> work(lwork);
00333 P.Reallocate(m);
00334 csytrf_(&uplo, &m, A.GetDataVoid(), &m,
00335 P.GetData(), work.GetDataVoid(),
00336 &lwork, &info.GetInfoRef());
00337
00338 #ifdef SELDON_LAPACK_CHECK_INFO
00339 if (info.GetInfo() != 0)
00340 throw LapackError(info.GetInfo(), "GetLU",
00341 "An error occured during the factorization.");
00342 #endif
00343
00344 }
00345
00346
00347 template <class Prop0, class Allocator0,
00348 class Allocator1>
00349 void GetLU(Matrix<complex<double>, Prop0, ColSym, Allocator0>& A,
00350 Vector<int, VectFull, Allocator1>& P,
00351 LapackInfo& info)
00352 {
00353 int m = A.GetM();
00354 int lwork = m;
00355
00356 #ifdef SELDON_CHECK_BOUNDS
00357 if (m <= 0)
00358 throw WrongDim("GetLU", "Provide a non-empty matrix");
00359 #endif
00360
00361 char uplo('U');
00362 Vector<complex<double>,VectFull,Allocator0> work(lwork);
00363 P.Reallocate(m);
00364 zsytrf_(&uplo, &m, A.GetDataVoid(), &m,
00365 P.GetData(), work.GetDataVoid(),
00366 &lwork, &info.GetInfoRef());
00367
00368 #ifdef SELDON_LAPACK_CHECK_INFO
00369 if (info.GetInfo() != 0)
00370 throw LapackError(info.GetInfo(), "GetLU",
00371 "An error occured during the factorization.");
00372 #endif
00373
00374 }
00375
00376
00377
00378
00379
00380 template <class Prop0, class Allocator0,
00381 class Allocator1>
00382 void GetLU(Matrix<float, Prop0, ColSymPacked, Allocator0>& A,
00383 Vector<int, VectFull, Allocator1>& P,
00384 LapackInfo& info)
00385 {
00386 int m = A.GetM();
00387
00388 #ifdef SELDON_CHECK_BOUNDS
00389 if (m <= 0)
00390 throw WrongDim("GetLU", "Provide a non-empty matrix");
00391 #endif
00392
00393 char uplo('U');
00394 P.Reallocate(m);
00395 ssptrf_(&uplo, &m, A.GetData(),
00396 P.GetData(), &info.GetInfoRef());
00397
00398 #ifdef SELDON_LAPACK_CHECK_INFO
00399 if (info.GetInfo() != 0)
00400 throw LapackError(info.GetInfo(), "GetLU",
00401 "An error occured during the factorization.");
00402 #endif
00403
00404 }
00405
00406
00407 template <class Prop0, class Allocator0,
00408 class Allocator1>
00409 void GetLU(Matrix<double, Prop0, ColSymPacked, Allocator0>& A,
00410 Vector<int, VectFull, Allocator1>& P,
00411 LapackInfo& info)
00412 {
00413 int m = A.GetM();
00414
00415 #ifdef SELDON_CHECK_BOUNDS
00416 if (m <= 0)
00417 throw WrongDim("GetLU", "Provide a non-empty matrix");
00418 #endif
00419
00420 char uplo('U');
00421 P.Reallocate(m);
00422 dsptrf_(&uplo, &m, A.GetData(),
00423 P.GetData(), &info.GetInfoRef());
00424
00425 #ifdef SELDON_LAPACK_CHECK_INFO
00426 if (info.GetInfo() != 0)
00427 throw LapackError(info.GetInfo(), "GetLU",
00428 "An error occured during the factorization.");
00429 #endif
00430
00431 }
00432
00433
00434 template <class Prop0, class Allocator0,
00435 class Allocator1>
00436 void GetLU(Matrix<complex<float>, Prop0, ColSymPacked, Allocator0>& A,
00437 Vector<int, VectFull, Allocator1>& P,
00438 LapackInfo& info)
00439 {
00440 int m = A.GetM();
00441
00442 #ifdef SELDON_CHECK_BOUNDS
00443 if (m <= 0)
00444 throw WrongDim("GetLU", "Provide a non-empty matrix");
00445 #endif
00446
00447 char uplo('U');
00448 P.Reallocate(m);
00449 csptrf_(&uplo, &m, A.GetDataVoid(),
00450 P.GetData(), &info.GetInfoRef());
00451
00452 #ifdef SELDON_LAPACK_CHECK_INFO
00453 if (info.GetInfo() != 0)
00454 throw LapackError(info.GetInfo(), "GetLU",
00455 "An error occured during the factorization.");
00456 #endif
00457
00458 }
00459
00460
00461 template <class Prop0, class Allocator0,
00462 class Allocator1>
00463 void GetLU(Matrix<complex<double>, Prop0, ColSymPacked, Allocator0>& A,
00464 Vector<int, VectFull, Allocator1>& P,
00465 LapackInfo& info)
00466 {
00467 int m = A.GetM();
00468
00469 #ifdef SELDON_CHECK_BOUNDS
00470 if (m <= 0)
00471 throw WrongDim("GetLU", "Provide a non-empty matrix");
00472 #endif
00473
00474 char uplo('U');
00475 P.Reallocate(m);
00476 zsptrf_(&uplo, &m, A.GetDataVoid(),
00477 P.GetData(), &info.GetInfoRef());
00478
00479 #ifdef SELDON_LAPACK_CHECK_INFO
00480 if (info.GetInfo() != 0)
00481 throw LapackError(info.GetInfo(), "GetLU",
00482 "An error occured during the factorization.");
00483 #endif
00484
00485 }
00486
00487
00488
00489
00490
00491 template <class Prop0, class Allocator0,
00492 class Allocator1>
00493 void GetLU(SeldonUplo Uplo,
00494 Matrix<float, Prop0, ColSymPacked, Allocator0>& A,
00495 Vector<int, VectFull, Allocator1>& P,
00496 LapackInfo& info)
00497 {
00498 int m = A.GetM();
00499
00500 #ifdef SELDON_CHECK_BOUNDS
00501 if (m <= 0)
00502 throw WrongDim("GetLU", "Provide a non-empty matrix");
00503 #endif
00504
00505 char uplo(Uplo);
00506 P.Reallocate(m);
00507 ssptrf_(&uplo, &m, A.GetData(),
00508 P.GetData(), &info.GetInfoRef());
00509
00510 #ifdef SELDON_LAPACK_CHECK_INFO
00511 if (info.GetInfo() != 0)
00512 throw LapackError(info.GetInfo(), "GetLU",
00513 "An error occured during the factorization.");
00514 #endif
00515
00516 }
00517
00518
00519 template <class Prop0, class Allocator0,
00520 class Allocator1>
00521 void GetLU(SeldonUplo Uplo,
00522 Matrix<double, Prop0, ColSymPacked, Allocator0>& A,
00523 Vector<int, VectFull, Allocator1>& P,
00524 LapackInfo& info)
00525 {
00526 int m = A.GetM();
00527
00528 #ifdef SELDON_CHECK_BOUNDS
00529 if (m <= 0)
00530 throw WrongDim("GetLU", "Provide a non-empty matrix");
00531 #endif
00532
00533 char uplo(Uplo);
00534 P.Reallocate(m);
00535 dsptrf_(&uplo, &m, A.GetData(),
00536 P.GetData(), &info.GetInfoRef());
00537
00538 #ifdef SELDON_LAPACK_CHECK_INFO
00539 if (info.GetInfo() != 0)
00540 throw LapackError(info.GetInfo(), "GetLU",
00541 "An error occured during the factorization.");
00542 #endif
00543
00544 }
00545
00546
00547 template <class Prop0, class Allocator0,
00548 class Allocator1>
00549 void GetLU(SeldonUplo Uplo,
00550 Matrix<complex<float>, Prop0, ColSymPacked, Allocator0>& A,
00551 Vector<int, VectFull, Allocator1>& P,
00552 LapackInfo& info)
00553 {
00554 int m = A.GetM();
00555
00556 #ifdef SELDON_CHECK_BOUNDS
00557 if (m <= 0)
00558 throw WrongDim("GetLU", "Provide a non-empty matrix");
00559 #endif
00560
00561 char uplo(Uplo);
00562 P.Reallocate(m);
00563 csptrf_(&uplo, &m, A.GetDataVoid(),
00564 P.GetData(), &info.GetInfoRef());
00565
00566 #ifdef SELDON_LAPACK_CHECK_INFO
00567 if (info.GetInfo() != 0)
00568 throw LapackError(info.GetInfo(), "GetLU",
00569 "An error occured during the factorization.");
00570 #endif
00571
00572 }
00573
00574
00575 template <class Prop0, class Allocator0,
00576 class Allocator1>
00577 void GetLU(SeldonUplo Uplo,
00578 Matrix<complex<double>, Prop0, ColSymPacked, Allocator0>& A,
00579 Vector<int, VectFull, Allocator1>& P,
00580 LapackInfo& info)
00581 {
00582 int m = A.GetM();
00583
00584 #ifdef SELDON_CHECK_BOUNDS
00585 if (m <= 0)
00586 throw WrongDim("GetLU", "Provide a non-empty matrix");
00587 #endif
00588
00589 char uplo(Uplo);
00590 P.Reallocate(m);
00591 zsptrf_(&uplo, &m, A.GetDataVoid(),
00592 P.GetData(), &info.GetInfoRef());
00593
00594 #ifdef SELDON_LAPACK_CHECK_INFO
00595 if (info.GetInfo() != 0)
00596 throw LapackError(info.GetInfo(), "GetLU",
00597 "An error occured during the factorization.");
00598 #endif
00599
00600 }
00601
00602
00603
00604
00605
00606 template <class Prop0, class Allocator0,
00607 class Allocator1>
00608 void GetLU(Matrix<float, Prop0, RowSym, Allocator0>& A,
00609 Vector<int, VectFull, Allocator1>& P,
00610 LapackInfo& info)
00611 {
00612 int m = A.GetM();
00613
00614 #ifdef SELDON_CHECK_BOUNDS
00615 if (m <= 0)
00616 throw WrongDim("GetLU", "Provide a non-empty matrix");
00617 #endif
00618
00619 int lwork = m;
00620 char uplo('L');
00621 Vector<float, VectFull, Allocator0> work(lwork);
00622 P.Reallocate(m);
00623 ssytrf_(&uplo, &m, A.GetData(), &m,
00624 P.GetData(), work.GetData(), &lwork, &info.GetInfoRef());
00625
00626 #ifdef SELDON_LAPACK_CHECK_INFO
00627 if (info.GetInfo() != 0)
00628 throw LapackError(info.GetInfo(), "GetLU",
00629 "An error occured during the factorization.");
00630 #endif
00631
00632 }
00633
00634
00635 template <class Prop0, class Allocator0,
00636 class Allocator1>
00637 void GetLU(Matrix<double, Prop0, RowSym, Allocator0>& A,
00638 Vector<int, VectFull, Allocator1>& P,
00639 LapackInfo& info)
00640 {
00641 int m = A.GetM();
00642
00643 #ifdef SELDON_CHECK_BOUNDS
00644 if (m <= 0)
00645 throw WrongDim("GetLU", "Provide a non-empty matrix");
00646 #endif
00647
00648 int lwork = m;
00649 char uplo('L');
00650 Vector<double, VectFull, Allocator0> work(lwork);
00651 P.Reallocate(m);
00652 dsytrf_(&uplo, &m, A.GetData(), &m,
00653 P.GetData(), work.GetData(), &lwork, &info.GetInfoRef());
00654
00655 #ifdef SELDON_LAPACK_CHECK_INFO
00656 if (info.GetInfo() != 0)
00657 throw LapackError(info.GetInfo(), "GetLU",
00658 "An error occured during the factorization.");
00659 #endif
00660
00661 }
00662
00663
00664 template <class Prop0, class Allocator0,
00665 class Allocator1>
00666 void GetLU(Matrix<complex<float>, Prop0, RowSym, Allocator0>& A,
00667 Vector<int, VectFull, Allocator1>& P,
00668 LapackInfo& info)
00669 {
00670 int m = A.GetM();
00671
00672 #ifdef SELDON_CHECK_BOUNDS
00673 if (m <= 0)
00674 throw WrongDim("GetLU", "Provide a non-empty matrix");
00675 #endif
00676
00677 int lwork = m;
00678 char uplo('L');
00679 Vector<complex<float>, VectFull, Allocator0> work(lwork);
00680 P.Reallocate(m);
00681 csytrf_(&uplo, &m, A.GetDataVoid(), &m,
00682 P.GetData(), work.GetDataVoid(),
00683 &lwork, &info.GetInfoRef());
00684
00685 #ifdef SELDON_LAPACK_CHECK_INFO
00686 if (info.GetInfo() != 0)
00687 throw LapackError(info.GetInfo(), "GetLU",
00688 "An error occured during the factorization.");
00689 #endif
00690
00691 }
00692
00693
00694 template <class Prop0, class Allocator0,
00695 class Allocator1>
00696 void GetLU(Matrix<complex<double>, Prop0, RowSym, Allocator0>& A,
00697 Vector<int, VectFull, Allocator1>& P,
00698 LapackInfo& info)
00699 {
00700 int m = A.GetM();
00701
00702 #ifdef SELDON_CHECK_BOUNDS
00703 if (m <= 0)
00704 throw WrongDim("GetLU", "Provide a non-empty matrix");
00705 #endif
00706
00707 int lwork = m;
00708 char uplo('L');
00709 Vector<complex<double>, VectFull, Allocator0> work(lwork);
00710 P.Reallocate(m);
00711 zsytrf_(&uplo, &m, A.GetDataVoid(), &m,
00712 P.GetData(), work.GetDataVoid(),
00713 &lwork, &info.GetInfoRef());
00714
00715 #ifdef SELDON_LAPACK_CHECK_INFO
00716 if (info.GetInfo() != 0)
00717 throw LapackError(info.GetInfo(), "GetLU",
00718 "An error occured during the factorization.");
00719 #endif
00720
00721 }
00722
00723
00724
00725
00726
00727 template <class Prop0, class Allocator0,
00728 class Allocator1>
00729 void GetLU(Matrix<float, Prop0, RowSymPacked, Allocator0>& A,
00730 Vector<int, VectFull, Allocator1>& P,
00731 LapackInfo& info)
00732 {
00733 int m = A.GetM();
00734
00735 #ifdef SELDON_CHECK_BOUNDS
00736 if (m <= 0)
00737 throw WrongDim("GetLU", "Provide a non-empty matrix");
00738 #endif
00739
00740 char uplo('L');
00741 P.Reallocate(m);
00742 ssptrf_(&uplo, &m, A.GetData(),
00743 P.GetData(), &info.GetInfoRef());
00744
00745 #ifdef SELDON_LAPACK_CHECK_INFO
00746 if (info.GetInfo() != 0)
00747 throw LapackError(info.GetInfo(), "GetLU",
00748 "An error occured during the factorization.");
00749 #endif
00750
00751 }
00752
00753
00754 template <class Prop0, class Allocator0,
00755 class Allocator1>
00756 void GetLU(Matrix<double, Prop0, RowSymPacked, Allocator0>& A,
00757 Vector<int, VectFull, Allocator1>& P,
00758 LapackInfo& info)
00759 {
00760 int m = A.GetM();
00761
00762 #ifdef SELDON_CHECK_BOUNDS
00763 if (m <= 0)
00764 throw WrongDim("GetLU", "Provide a non-empty matrix");
00765 #endif
00766
00767 char uplo('L');
00768 P.Reallocate(m);
00769 dsptrf_(&uplo, &m, A.GetData(),
00770 P.GetData(), &info.GetInfoRef());
00771
00772 #ifdef SELDON_LAPACK_CHECK_INFO
00773 if (info.GetInfo() != 0)
00774 throw LapackError(info.GetInfo(), "GetLU",
00775 "An error occured during the factorization.");
00776 #endif
00777
00778 }
00779
00780
00781 template <class Prop0, class Allocator0,
00782 class Allocator1>
00783 void GetLU(Matrix<complex<float>, Prop0, RowSymPacked, Allocator0>& A,
00784 Vector<int, VectFull, Allocator1>& P,
00785 LapackInfo& info)
00786 {
00787 int m = A.GetM();
00788
00789 #ifdef SELDON_CHECK_BOUNDS
00790 if (m <= 0)
00791 throw WrongDim("GetLU", "Provide a non-empty matrix");
00792 #endif
00793
00794 char uplo('L');
00795 P.Reallocate(m);
00796 csptrf_(&uplo, &m, A.GetDataVoid(),
00797 P.GetData(), &info.GetInfoRef());
00798
00799 #ifdef SELDON_LAPACK_CHECK_INFO
00800 if (info.GetInfo() != 0)
00801 throw LapackError(info.GetInfo(), "GetLU",
00802 "An error occured during the factorization.");
00803 #endif
00804
00805 }
00806
00807
00808 template <class Prop0, class Allocator0,
00809 class Allocator1>
00810 void GetLU(Matrix<complex<double>, Prop0, RowSymPacked, Allocator0>& A,
00811 Vector<int, VectFull, Allocator1>& P,
00812 LapackInfo& info)
00813 {
00814 int m = A.GetM();
00815
00816 #ifdef SELDON_CHECK_BOUNDS
00817 if (m <= 0)
00818 throw WrongDim("GetLU", "Provide a non-empty matrix");
00819 #endif
00820
00821 char uplo('L');
00822 P.Reallocate(m);
00823 zsptrf_(&uplo, &m, A.GetDataVoid(),
00824 P.GetData(), &info.GetInfoRef());
00825
00826 #ifdef SELDON_LAPACK_CHECK_INFO
00827 if (info.GetInfo() != 0)
00828 throw LapackError(info.GetInfo(), "GetLU",
00829 "An error occured during the factorization.");
00830 #endif
00831
00832 }
00833
00834
00835
00836
00837
00838 template <class Prop0, class Allocator0,
00839 class Allocator1>
00840 void GetLU(SeldonUplo Uplo,
00841 Matrix<float, Prop0, RowSymPacked, Allocator0>& A,
00842 Vector<int, VectFull, Allocator1>& P,
00843 LapackInfo& info)
00844 {
00845 int m = A.GetM();
00846
00847 #ifdef SELDON_CHECK_BOUNDS
00848 if (m <= 0)
00849 throw WrongDim("GetLU", "Provide a non-empty matrix");
00850 #endif
00851
00852 char uplo(Uplo.RevChar());
00853 P.Reallocate(m);
00854 ssptrf_(&uplo, &m, A.GetData(),
00855 P.GetData(), &info.GetInfoRef());
00856
00857 #ifdef SELDON_LAPACK_CHECK_INFO
00858 if (info.GetInfo() != 0)
00859 throw LapackError(info.GetInfo(), "GetLU",
00860 "An error occured during the factorization.");
00861 #endif
00862
00863 }
00864
00865
00866 template <class Prop0, class Allocator0,
00867 class Allocator1>
00868 void GetLU(SeldonUplo Uplo,
00869 Matrix<double, Prop0, RowSymPacked, Allocator0>& A,
00870 Vector<int, VectFull, Allocator1>& P,
00871 LapackInfo& info)
00872 {
00873 int m = A.GetM();
00874
00875 #ifdef SELDON_CHECK_BOUNDS
00876 if (m <= 0)
00877 throw WrongDim("GetLU", "Provide a non-empty matrix");
00878 #endif
00879
00880 char uplo(Uplo.RevChar());
00881 P.Reallocate(m);
00882 dsptrf_(&uplo, &m, A.GetData(),
00883 P.GetData(), &info.GetInfoRef());
00884
00885 #ifdef SELDON_LAPACK_CHECK_INFO
00886 if (info.GetInfo() != 0)
00887 throw LapackError(info.GetInfo(), "GetLU",
00888 "An error occured during the factorization.");
00889 #endif
00890
00891 }
00892
00893
00894 template <class Prop0, class Allocator0,
00895 class Allocator1>
00896 void GetLU(SeldonUplo Uplo,
00897 Matrix<complex<float>, Prop0, RowSymPacked, Allocator0>& A,
00898 Vector<int, VectFull, Allocator1>& P,
00899 LapackInfo& info)
00900 {
00901 int m = A.GetM();
00902
00903 #ifdef SELDON_CHECK_BOUNDS
00904 if (m <= 0)
00905 throw WrongDim("GetLU", "Provide a non-empty matrix");
00906 #endif
00907
00908 char uplo(Uplo.RevChar());
00909 P.Reallocate(m);
00910 csptrf_(&uplo, &m, A.GetDataVoid(),
00911 P.GetData(), &info.GetInfoRef());
00912
00913 #ifdef SELDON_LAPACK_CHECK_INFO
00914 if (info.GetInfo() != 0)
00915 throw LapackError(info.GetInfo(), "GetLU",
00916 "An error occured during the factorization.");
00917 #endif
00918
00919 }
00920
00921
00922 template <class Prop0, class Allocator0,
00923 class Allocator1>
00924 void GetLU(SeldonUplo Uplo,
00925 Matrix<complex<double>, Prop0, RowSymPacked, Allocator0>& A,
00926 Vector<int, VectFull, Allocator1>& P,
00927 LapackInfo& info)
00928 {
00929 int m = A.GetM();
00930
00931 #ifdef SELDON_CHECK_BOUNDS
00932 if (m <= 0)
00933 throw WrongDim("GetLU", "Provide a non-empty matrix");
00934 #endif
00935
00936 char uplo(Uplo.RevChar());
00937 P.Reallocate(m);
00938 zsptrf_(&uplo, &m, A.GetDataVoid(),
00939 P.GetData(), &info.GetInfoRef());
00940
00941 #ifdef SELDON_LAPACK_CHECK_INFO
00942 if (info.GetInfo() != 0)
00943 throw LapackError(info.GetInfo(), "GetLU",
00944 "An error occured during the factorization.");
00945 #endif
00946
00947 }
00948
00949
00950
00951
00952
00953 template <class Prop0, class Allocator0,
00954 class Allocator1>
00955 void GetLU(Matrix<complex<float>, Prop0, ColHerm, Allocator0>& A,
00956 Vector<int, VectFull, Allocator1>& P,
00957 LapackInfo& info)
00958 {
00959 int m = A.GetM();
00960
00961 #ifdef SELDON_CHECK_BOUNDS
00962 if (m <= 0)
00963 throw WrongDim("GetLU", "Provide a non-empty matrix");
00964 #endif
00965
00966 int lwork = m;
00967 char uplo('U');
00968 Vector<complex<float>, VectFull, Allocator0> work(lwork);
00969 P.Reallocate(m);
00970 chetrf_(&uplo, &m, A.GetDataVoid(), &m,
00971 P.GetData(), work.GetDataVoid(),
00972 &lwork, &info.GetInfoRef());
00973
00974 #ifdef SELDON_LAPACK_CHECK_INFO
00975 if (info.GetInfo() != 0)
00976 throw LapackError(info.GetInfo(), "GetLU",
00977 "An error occured during the factorization.");
00978 #endif
00979
00980 }
00981
00982
00983 template <class Prop0, class Allocator0,
00984 class Allocator1>
00985 void GetLU(Matrix<complex<double>, Prop0, ColHerm, Allocator0>& A,
00986 Vector<int, VectFull, Allocator1>& P,
00987 LapackInfo& info)
00988 {
00989 int m = A.GetM();
00990
00991 #ifdef SELDON_CHECK_BOUNDS
00992 if (m <= 0)
00993 throw WrongDim("GetLU", "Provide a non-empty matrix");
00994 #endif
00995
00996 int lwork = m;
00997 char uplo('U');
00998 Vector<complex<double>, VectFull, Allocator0> work(lwork);
00999 P.Reallocate(m);
01000 zhetrf_(&uplo, &m, A.GetDataVoid(), &m,
01001 P.GetData(), work.GetDataVoid(),
01002 &lwork, &info.GetInfoRef());
01003
01004 #ifdef SELDON_LAPACK_CHECK_INFO
01005 if (info.GetInfo() != 0)
01006 throw LapackError(info.GetInfo(), "GetLU",
01007 "An error occured during the factorization.");
01008 #endif
01009
01010 }
01011
01012
01013
01014
01015
01016 template <class Prop0, class Allocator0,
01017 class Allocator1>
01018 void GetLU(Matrix<complex<float>, Prop0, ColHermPacked, Allocator0>& A,
01019 Vector<int, VectFull, Allocator1>& P,
01020 LapackInfo& info)
01021 {
01022 int m = A.GetM();
01023
01024 #ifdef SELDON_CHECK_BOUNDS
01025 if (m <= 0)
01026 throw WrongDim("GetLU", "Provide a non-empty matrix");
01027 #endif
01028
01029 char uplo('U');
01030 P.Reallocate(m);
01031 chptrf_(&uplo, &m, A.GetDataVoid(),
01032 P.GetData(), &info.GetInfoRef());
01033
01034 #ifdef SELDON_LAPACK_CHECK_INFO
01035 if (info.GetInfo() != 0)
01036 throw LapackError(info.GetInfo(), "GetLU",
01037 "An error occured during the factorization.");
01038 #endif
01039
01040 }
01041
01042
01043 template <class Prop0, class Allocator0,
01044 class Allocator1>
01045 void GetLU(Matrix<complex<double>, Prop0, ColHermPacked, Allocator0>& A,
01046 Vector<int, VectFull, Allocator1>& P,
01047 LapackInfo& info)
01048 {
01049 int m = A.GetM();
01050
01051 #ifdef SELDON_CHECK_DIMENSIONS
01052 if (m <= 0)
01053 throw WrongDim("GetLU", "Provide a non-empty matrix");
01054 #endif
01055
01056 char uplo('U');
01057 P.Reallocate(m);
01058 zhptrf_(&uplo, &m, A.GetDataVoid(),
01059 P.GetData(), &info.GetInfoRef());
01060
01061 #ifdef SELDON_LAPACK_CHECK_INFO
01062 if (info.GetInfo() != 0)
01063 throw LapackError(info.GetInfo(), "GetLU",
01064 "An error occured during the factorization.");
01065 #endif
01066
01067 }
01068
01069
01070
01071
01072
01073 template <class Prop0, class Allocator0,
01074 class Allocator1>
01075 void GetLU(Matrix<complex<float>, Prop0, RowHerm, Allocator0>& A,
01076 Vector<int, VectFull, Allocator1>& P,
01077 LapackInfo& info)
01078 {
01079 int m = A.GetM();
01080
01081 #ifdef SELDON_CHECK_DIMENSIONS
01082 if (m <= 0)
01083 throw WrongDim("GetLU", "Provide a non-empty matrix");
01084 #endif
01085
01086 int lwork = m;
01087 char uplo('L');
01088 Vector<complex<float>, VectFull, Allocator0> work(lwork);
01089 P.Reallocate(m);
01090 chetrf_(&uplo, &m, A.GetDataVoid(), &m,
01091 P.GetData(), work.GetDataVoid(),
01092 &lwork, &info.GetInfoRef());
01093
01094 #ifdef SELDON_LAPACK_CHECK_INFO
01095 if (info.GetInfo() != 0)
01096 throw LapackError(info.GetInfo(), "GetLU",
01097 "An error occured during the factorization.");
01098 #endif
01099
01100 }
01101
01102
01103 template <class Prop0, class Allocator0,
01104 class Allocator1>
01105 void GetLU(Matrix<complex<double>, Prop0, RowHerm, Allocator0>& A,
01106 Vector<int, VectFull, Allocator1>& P,
01107 LapackInfo& info)
01108 {
01109 int m = A.GetM();
01110
01111 #ifdef SELDON_CHECK_DIMENSIONS
01112 if (m <= 0)
01113 throw WrongDim("GetLU", "Provide a non-empty matrix");
01114 #endif
01115
01116 int lwork = m;
01117 char uplo('L');
01118 Vector<complex<double>, VectFull, Allocator0> work(lwork);
01119 P.Reallocate(m);
01120 zhetrf_(&uplo, &m, A.GetDataVoid(), &m,
01121 P.GetData(), work.GetDataVoid(),
01122 &lwork, &info.GetInfoRef());
01123
01124 #ifdef SELDON_LAPACK_CHECK_INFO
01125 if (info.GetInfo() != 0)
01126 throw LapackError(info.GetInfo(), "GetLU",
01127 "An error occured during the factorization.");
01128 #endif
01129
01130 }
01131
01132
01133
01134
01135
01136 template <class Prop0, class Allocator0,
01137 class Allocator1>
01138 void GetLU(Matrix<complex<float>, Prop0, RowHermPacked, Allocator0>& A,
01139 Vector<int, VectFull, Allocator1>& P,
01140 LapackInfo& info)
01141 {
01142 int m = A.GetM();
01143
01144 #ifdef SELDON_CHECK_DIMENSIONS
01145 if (m <= 0)
01146 throw WrongDim("GetLU", "Provide a non-empty matrix");
01147 #endif
01148
01149 char uplo('L');
01150 P.Reallocate(m);
01151 chptrf_(&uplo, &m, A.GetDataVoid(),
01152 P.GetData(), &info.GetInfoRef());
01153
01154 #ifdef SELDON_LAPACK_CHECK_INFO
01155 if (info.GetInfo() != 0)
01156 throw LapackError(info.GetInfo(), "GetLU",
01157 "An error occured during the factorization.");
01158 #endif
01159
01160 }
01161
01162
01163 template <class Prop0, class Allocator0,
01164 class Allocator1>
01165 void GetLU(Matrix<complex<double>, Prop0, RowHermPacked, Allocator0>& A,
01166 Vector<int, VectFull, Allocator1>& P,
01167 LapackInfo& info)
01168 {
01169 int m = A.GetM();
01170
01171 #ifdef SELDON_CHECK_DIMENSIONS
01172 if (m <= 0)
01173 throw WrongDim("GetLU", "Provide a non-empty matrix");
01174 #endif
01175
01176 char uplo('L');
01177 P.Reallocate(m);
01178 zhptrf_(&uplo, &m, A.GetDataVoid(),
01179 P.GetData(), &info.GetInfoRef());
01180
01181 #ifdef SELDON_LAPACK_CHECK_INFO
01182 if (info.GetInfo() != 0)
01183 throw LapackError(info.GetInfo(), "GetLU",
01184 "An error occured during the factorization.");
01185 #endif
01186
01187 }
01188
01189
01190
01192
01193
01194
01196
01197
01198
01199
01200
01201
01202 template <class Prop0, class Allocator0,
01203 class Allocator1,class Allocator2>
01204 void SolveLU(const Matrix<float, Prop0, ColMajor, Allocator0>& A,
01205 const Vector<int, VectFull, Allocator1>& P,
01206 Vector<float, VectFull, Allocator2>& b,
01207 LapackInfo& info)
01208 {
01209
01210 #ifdef SELDON_CHECK_DIMENSIONS
01211 CheckDim(A, b, "SolveLU(A, pivot, X)");
01212 #endif
01213
01214 int m = A.GetM();
01215 int nrhs = 1;
01216 char trans('N');
01217 sgetrs_(&trans, &m, &nrhs, A.GetData(), &m, P.GetData(),
01218 b.GetData(), &m, &info.GetInfoRef() );
01219 }
01220
01221
01222 template <class Prop0, class Allocator0,
01223 class Allocator1, class Allocator2>
01224 void SolveLU(const Matrix<double, Prop0, ColMajor, Allocator0>& A,
01225 const Vector<int, VectFull, Allocator1>& P,
01226 Vector<double, VectFull, Allocator2>& b,
01227 LapackInfo& info)
01228 {
01229
01230 #ifdef SELDON_CHECK_DIMENSIONS
01231 CheckDim(A, b, "SolveLU(A, pivot, X)");
01232 #endif
01233
01234 int m = A.GetM();
01235 int nrhs = 1;
01236 char trans('N');
01237 dgetrs_(&trans, &m, &nrhs, A.GetData(), &m,P.GetData(),
01238 b.GetData(), &m, &info.GetInfoRef() );
01239 }
01240
01241
01242 template <class Prop0, class Allocator0,
01243 class Allocator1, class Allocator2>
01244 void SolveLU(const Matrix<complex<float>, Prop0, ColMajor, Allocator0>& A,
01245 const Vector<int, VectFull, Allocator1>& P,
01246 Vector<complex<float>, VectFull, Allocator2>& b,
01247 LapackInfo& info)
01248 {
01249
01250 #ifdef SELDON_CHECK_DIMENSIONS
01251 CheckDim(A, b, "SolveLU(A, pivot, X)");
01252 #endif
01253
01254 int m = A.GetM();
01255 int nrhs = 1;
01256 char trans('N');
01257 cgetrs_(&trans, &m, &nrhs, A.GetDataVoid(), &m,
01258 P.GetData(), b.GetDataVoid(),
01259 &m, &info.GetInfoRef() );
01260 }
01261
01262
01263 template <class Prop0, class Allocator0,
01264 class Allocator1, class Allocator2>
01265 void SolveLU(const Matrix<complex<double>, Prop0, ColMajor, Allocator0>& A,
01266 const Vector<int, VectFull, Allocator1>& P,
01267 Vector<complex<double>, VectFull, Allocator2>& b,
01268 LapackInfo& info)
01269 {
01270
01271 #ifdef SELDON_CHECK_DIMENSIONS
01272 CheckDim(A, b, "SolveLU(A, pivot, X)");
01273 #endif
01274
01275 int m = A.GetM();
01276 int nrhs = 1;
01277 char trans('N');
01278 zgetrs_(&trans, &m, &nrhs, A.GetData(), &m,
01279 P.GetData(), b.GetDataVoid(),
01280 &m, &info.GetInfoRef() );
01281 }
01282
01283
01284
01285
01286
01287 template <class Prop0, class Allocator0,
01288 class Allocator1,class Allocator2>
01289 void SolveLU(const SeldonTranspose& TransA,
01290 const Matrix<float, Prop0, ColMajor, Allocator0>& A,
01291 const Vector<int, VectFull, Allocator1>& P,
01292 Vector<float, VectFull, Allocator2>& b,
01293 LapackInfo& info)
01294 {
01295
01296 #ifdef SELDON_CHECK_DIMENSIONS
01297 CheckDim(A, b, "SolveLU(A, pivot, X)");
01298 #endif
01299
01300 int m = A.GetM();
01301 int nrhs = 1;
01302 char trans = TransA.Char();
01303 sgetrs_(&trans, &m, &nrhs, A.GetData(), &m, P.GetData(),
01304 b.GetData(), &m, &info.GetInfoRef());
01305 }
01306
01307 template <class Prop0, class Allocator0,
01308 class Allocator1,class Allocator2>
01309 void SolveLU(const SeldonTranspose& TransA,
01310 const Matrix<double, Prop0, ColMajor, Allocator0>& A,
01311 const Vector<int, VectFull, Allocator1>& P,
01312 Vector<double, VectFull, Allocator2>& b,
01313 LapackInfo& info)
01314 {
01315
01316 #ifdef SELDON_CHECK_DIMENSIONS
01317 CheckDim(A, b, "SolveLU(A, pivot, X)");
01318 #endif
01319
01320 int m = A.GetM();
01321 int nrhs = 1;
01322 char trans = TransA.Char();
01323 dgetrs_(&trans, &m, &nrhs, A.GetData(), &m, P.GetData(),
01324 b.GetData(), &m, &info.GetInfoRef());
01325 }
01326
01327 template <class Prop0, class Allocator0,
01328 class Allocator1,class Allocator2>
01329 void SolveLU(const SeldonTranspose& TransA,
01330 const Matrix<complex<float>, Prop0, ColMajor, Allocator0>& A,
01331 const Vector<int, VectFull, Allocator1>& P,
01332 Vector<complex<float>, VectFull, Allocator2>& b,
01333 LapackInfo& info)
01334 {
01335
01336 #ifdef SELDON_CHECK_DIMENSIONS
01337 CheckDim(A, b, "SolveLU(A, pivot, X)");
01338 #endif
01339
01340 int m = A.GetM();
01341 int nrhs = 1;
01342 char trans = TransA.Char();
01343 cgetrs_(&trans, &m, &nrhs, A.GetDataVoid(), &m, P.GetData(),
01344 b.GetDataVoid(), &m, &info.GetInfoRef());
01345 }
01346
01347 template <class Prop0, class Allocator0,
01348 class Allocator1,class Allocator2>
01349 void SolveLU(const SeldonTranspose& TransA,
01350 const Matrix<complex<double>, Prop0, ColMajor, Allocator0>& A,
01351 const Vector<int, VectFull, Allocator1>& P,
01352 Vector<complex<double>, VectFull, Allocator2>& b,
01353 LapackInfo& info)
01354 {
01355
01356 #ifdef SELDON_CHECK_DIMENSIONS
01357 CheckDim(A, b, "SolveLU(A, pivot, X)");
01358 #endif
01359
01360 int m = A.GetM();
01361 int nrhs = 1;
01362 char trans = TransA.Char();
01363 zgetrs_(&trans, &m, &nrhs, A.GetDataVoid(), &m, P.GetData(),
01364 b.GetDataVoid(), &m, &info.GetInfoRef());
01365 }
01366
01367
01368
01369
01370 template <class Prop0, class Allocator0,
01371 class Allocator1,class Allocator2>
01372 void SolveLU(const Matrix<float, Prop0, RowMajor, Allocator0>& A,
01373 const Vector<int, VectFull, Allocator1>& P,
01374 Vector<float, VectFull, Allocator2>& b,
01375 LapackInfo& info)
01376 {
01377
01378 #ifdef SELDON_CHECK_DIMENSIONS
01379 CheckDim(A, b, "SolveLU(A, pivot, X)");
01380 #endif
01381
01382 int m = A.GetM();
01383 int nrhs = 1;
01384 char trans('T');
01385 sgetrs_(&trans, &m, &nrhs, A.GetData(), &m,
01386 P.GetData(), b.GetData(), &m, &info.GetInfoRef() );
01387 }
01388
01389
01390 template <class Prop0, class Allocator0,
01391 class Allocator1,class Allocator2>
01392 void SolveLU(const Matrix<double, Prop0, RowMajor, Allocator0>& A,
01393 const Vector<int, VectFull, Allocator1>& P,
01394 Vector<double, VectFull, Allocator2>& b,
01395 LapackInfo& info)
01396 {
01397
01398 #ifdef SELDON_CHECK_DIMENSIONS
01399 CheckDim(A, b, "SolveLU(A, pivot, X)");
01400 #endif
01401
01402 int m = A.GetM();
01403 int nrhs = 1;
01404 char trans('T');
01405 dgetrs_(&trans, &m, &nrhs, A.GetData(), &m,
01406 P.GetData(), b.GetData(), &m, &info.GetInfoRef() );
01407 }
01408
01409
01410 template <class Prop0, class Allocator0,
01411 class Allocator1,class Allocator2>
01412 void SolveLU(const Matrix<complex<float>, Prop0, RowMajor, Allocator0>& A,
01413 const Vector<int, VectFull, Allocator1>& P,
01414 Vector<complex<float>, VectFull, Allocator2>& b,
01415 LapackInfo& info)
01416 {
01417
01418 #ifdef SELDON_CHECK_DIMENSIONS
01419 CheckDim(A, b, "SolveLU(A, pivot, X)");
01420 #endif
01421
01422 int m = A.GetM();
01423 int nrhs = 1;
01424 char trans('T');
01425 cgetrs_(&trans, &m, &nrhs, A.GetDataVoid(), &m,
01426 P.GetData(), b.GetData(), &m, &info.GetInfoRef() );
01427 }
01428
01429
01430 template <class Prop0, class Allocator0,
01431 class Allocator1,class Allocator2>
01432 void SolveLU(const Matrix<complex<double>, Prop0, RowMajor, Allocator0>& A,
01433 const Vector<int, VectFull, Allocator1>& P,
01434 Vector<complex<double>, VectFull, Allocator2>& b,
01435 LapackInfo& info)
01436 {
01437
01438 #ifdef SELDON_CHECK_DIMENSIONS
01439 CheckDim(A, b, "SolveLU(A, pivot, X)");
01440 #endif
01441
01442 int m = A.GetM();
01443 int nrhs = 1;
01444 char trans('T');
01445 zgetrs_(&trans, &m, &nrhs, A.GetDataVoid(), &m,
01446 P.GetData(), b.GetData(), &m, &info.GetInfoRef() );
01447 }
01448
01449
01450
01451
01452
01453 template <class Prop0, class Allocator0,
01454 class Allocator1,class Allocator2>
01455 void SolveLU(const SeldonTranspose& TransA,
01456 const Matrix<float, Prop0, RowMajor, Allocator0>& A,
01457 const Vector<int, VectFull, Allocator1>& P,
01458 Vector<float, VectFull, Allocator2>& b,
01459 LapackInfo& info)
01460 {
01461
01462 #ifdef SELDON_CHECK_DIMENSIONS
01463 CheckDim(A, b, "SolveLU(A, pivot, X)");
01464 #endif
01465
01466 int m = A.GetM();
01467 int nrhs = 1;
01468 char trans = TransA.RevChar();
01469 sgetrs_(&trans, &m, &nrhs, A.GetData(), &m, P.GetData(),
01470 b.GetData(), &m, &info.GetInfoRef());
01471 }
01472
01473 template <class Prop0, class Allocator0,
01474 class Allocator1,class Allocator2>
01475 void SolveLU(const SeldonTranspose& TransA,
01476 const Matrix<double, Prop0, RowMajor, Allocator0>& A,
01477 const Vector<int, VectFull, Allocator1>& P,
01478 Vector<double, VectFull, Allocator2>& b,
01479 LapackInfo& info)
01480 {
01481
01482 #ifdef SELDON_CHECK_DIMENSIONS
01483 CheckDim(A, b, "SolveLU(A, pivot, X)");
01484 #endif
01485
01486 int m = A.GetM();
01487 int nrhs = 1;
01488 char trans = TransA.RevChar();
01489 dgetrs_(&trans, &m, &nrhs, A.GetData(), &m, P.GetData(),
01490 b.GetData(), &m, &info.GetInfoRef());
01491 }
01492
01493 template <class Prop0, class Allocator0,
01494 class Allocator1,class Allocator2>
01495 void SolveLU(const SeldonTranspose& TransA,
01496 const Matrix<complex<float>, Prop0, RowMajor, Allocator0>& A,
01497 const Vector<int, VectFull, Allocator1>& P,
01498 Vector<complex<float>, VectFull, Allocator2>& b,
01499 LapackInfo& info)
01500 {
01501
01502 #ifdef SELDON_CHECK_DIMENSIONS
01503 CheckDim(A, b, "SolveLU(A, pivot, X)");
01504 #endif
01505
01506 int m = A.GetM();
01507 int nrhs = 1;
01508 char trans = TransA.RevChar();
01509 if (TransA.ConjTrans())
01510 Conjugate(b);
01511
01512 cgetrs_(&trans, &m, &nrhs, A.GetDataVoid(), &m, P.GetData(),
01513 b.GetDataVoid(), &m, &info.GetInfoRef());
01514
01515 if (TransA.ConjTrans())
01516 Conjugate(b);
01517 }
01518
01519 template <class Prop0, class Allocator0,
01520 class Allocator1,class Allocator2>
01521 void SolveLU(const SeldonTranspose& TransA,
01522 const Matrix<complex<double>, Prop0, RowMajor, Allocator0>& A,
01523 const Vector<int, VectFull, Allocator1>& P,
01524 Vector<complex<double>, VectFull, Allocator2>& b,
01525 LapackInfo& info)
01526 {
01527
01528 #ifdef SELDON_CHECK_DIMENSIONS
01529 CheckDim(A, b, "SolveLU(A, pivot, X)");
01530 #endif
01531
01532 int m = A.GetM();
01533 int nrhs = 1;
01534 char trans = TransA.RevChar();
01535 if (TransA.ConjTrans())
01536 Conjugate(b);
01537
01538 zgetrs_(&trans, &m, &nrhs, A.GetDataVoid(), &m, P.GetData(),
01539 b.GetDataVoid(), &m, &info.GetInfoRef());
01540
01541 if (TransA.ConjTrans())
01542 Conjugate(b);
01543 }
01544
01545
01546
01547
01548
01549 template <class Prop0, class Allocator0,
01550 class Allocator1, class Allocator2>
01551 void SolveLU(const Matrix<float, Prop0, ColSym, Allocator0>& A,
01552 const Vector<int, VectFull, Allocator1>& P,
01553 Vector<float, VectFull, Allocator2>& b,
01554 LapackInfo& info)
01555 {
01556
01557 #ifdef SELDON_CHECK_DIMENSIONS
01558 CheckDim(A, b, "SolveLU(A, pivot, X)");
01559 #endif
01560
01561 int m = A.GetM(); int nrhs = 1;
01562 char uplo('U');
01563 ssytrs_(&uplo, &m, &nrhs, A.GetData(), &m,
01564 P.GetData(), b.GetData(), &m, &info.GetInfoRef());
01565 }
01566
01567
01568 template <class Prop0, class Allocator0,
01569 class Allocator1, class Allocator2>
01570 void SolveLU(const Matrix<double, Prop0, ColSym, Allocator0>& A,
01571 const Vector<int, VectFull, Allocator1>& P,
01572 Vector<double, VectFull, Allocator2>& b,
01573 LapackInfo& info)
01574 {
01575
01576 #ifdef SELDON_CHECK_DIMENSIONS
01577 CheckDim(A, b, "SolveLU(A, pivot, X)");
01578 #endif
01579
01580 int m = A.GetM(); int nrhs = 1;
01581 char uplo('U');
01582 dsytrs_(&uplo, &m, &nrhs, A.GetData(), &m,
01583 P.GetData(), b.GetData(), &m, &info.GetInfoRef());
01584 }
01585
01586
01587 template <class Prop0, class Allocator0,
01588 class Allocator1, class Allocator2>
01589 void SolveLU(const Matrix<complex<float>, Prop0, ColSym, Allocator0>& A,
01590 const Vector<int, VectFull, Allocator1>& P,
01591 Vector<complex<float>, VectFull, Allocator2>& b,
01592 LapackInfo& info)
01593 {
01594
01595 #ifdef SELDON_CHECK_DIMENSIONS
01596 CheckDim(A, b, "SolveLU(A, pivot, X)");
01597 #endif
01598
01599 int m = A.GetM(); int nrhs = 1;
01600 char uplo('U');
01601 csytrs_(&uplo, &m, & nrhs, A.GetDataVoid(), &m,
01602 P.GetData(), b.GetDataVoid(), &m, &info.GetInfoRef());
01603 }
01604
01605
01606 template <class Prop0, class Allocator0,
01607 class Allocator1, class Allocator2>
01608 void SolveLU(const Matrix<complex<double>, Prop0, ColSym, Allocator0>& A,
01609 const Vector<int, VectFull, Allocator1>& P,
01610 Vector<complex<double>, VectFull, Allocator2>& b,
01611 LapackInfo& info)
01612 {
01613
01614 #ifdef SELDON_CHECK_DIMENSIONS
01615 CheckDim(A, b, "SolveLU(A, pivot, X)");
01616 #endif
01617
01618 int m = A.GetM(); int nrhs = 1;
01619 char uplo('U');
01620 zsytrs_(&uplo, &m, &nrhs, A.GetDataVoid(), &m,
01621 P.GetData(), b.GetDataVoid(), &m, &info.GetInfoRef());
01622 }
01623
01624
01625
01626
01627
01628 template <class Prop0, class Allocator0,
01629 class Allocator1, class Allocator2>
01630 void SolveLU(const Matrix<float, Prop0, ColSymPacked, Allocator0>& A,
01631 const Vector<int, VectFull, Allocator1>& P,
01632 Vector<float, VectFull, Allocator2>& b,
01633 LapackInfo& info)
01634 {
01635
01636 #ifdef SELDON_CHECK_DIMENSIONS
01637 CheckDim(A, b, "SolveLU(A, pivot, X)");
01638 #endif
01639
01640 int m = A.GetM();
01641 int nrhs = 1;
01642 char uplo('U');
01643 ssptrs_(&uplo, &m, &nrhs, A.GetData(), P.GetData(),
01644 b.GetData(), &m, &info.GetInfoRef() );
01645 }
01646
01647
01648 template <class Prop0, class Allocator0,
01649 class Allocator1, class Allocator2>
01650 void SolveLU(const Matrix<double, Prop0, ColSymPacked, Allocator0>& A,
01651 const Vector<int, VectFull, Allocator1>& P,
01652 Vector<double, VectFull, Allocator2>& b,
01653 LapackInfo& info)
01654 {
01655
01656 #ifdef SELDON_CHECK_DIMENSIONS
01657 CheckDim(A, b, "SolveLU(A, pivot, X)");
01658 #endif
01659
01660 int m = A.GetM();
01661 int nrhs = 1;
01662 char uplo('U');
01663 dsptrs_(&uplo, &m, &nrhs, A.GetData(), P.GetData(),
01664 b.GetData(), &m, &info.GetInfoRef() );
01665 }
01666
01667
01668 template <class Prop0, class Allocator0,
01669 class Allocator1,class Allocator2>
01670 void SolveLU(const Matrix<complex<float>, Prop0, ColSymPacked,
01671 Allocator0>& A, const Vector<int, VectFull, Allocator1>& P,
01672 Vector<complex<float>, VectFull, Allocator2>& b,
01673 LapackInfo& info)
01674 {
01675
01676 #ifdef SELDON_CHECK_DIMENSIONS
01677 CheckDim(A, b, "SolveLU(A, pivot, X)");
01678 #endif
01679
01680 int m = A.GetM();
01681 int nrhs = 1;
01682 char uplo('U');
01683 csptrs_(&uplo, &m, &nrhs, A.GetDataVoid(), P.GetData(),
01684 b.GetData(), &m, &info.GetInfoRef() );
01685 }
01686
01687
01688 template <class Prop0, class Allocator0,
01689 class Allocator1, class Allocator2>
01690 void SolveLU(const Matrix<complex<double>, Prop0, ColSymPacked,
01691 Allocator0>& A, const Vector<int, VectFull, Allocator1>& P,
01692 Vector<complex<double>, VectFull, Allocator2>& b,
01693 LapackInfo& info)
01694 {
01695
01696 #ifdef SELDON_CHECK_DIMENSIONS
01697 CheckDim(A, b, "SolveLU(A, pivot, X)");
01698 #endif
01699
01700 int m = A.GetM();
01701 int nrhs = 1;
01702 char uplo('U');
01703 zsptrs_(&uplo, &m, &nrhs, A.GetDataVoid(), P.GetData(),
01704 b.GetData(), &m, &info.GetInfoRef() );
01705 }
01706
01707
01708
01709
01710
01711 template <class Prop0, class Allocator0,
01712 class Allocator1, class Allocator2>
01713 void SolveLU(const Matrix<float, Prop0, RowSym, Allocator0>& A,
01714 const Vector<int, VectFull, Allocator1>& P,
01715 Vector<float, VectFull, Allocator2>& b,
01716 LapackInfo& info)
01717 {
01718
01719 #ifdef SELDON_CHECK_DIMENSIONS
01720 CheckDim(A, b, "SolveLU(A, pivot, X)");
01721 #endif
01722
01723 int m = A.GetM(); int nrhs = 1;
01724 char uplo('L');
01725 ssytrs_(&uplo, &m, &nrhs, A.GetData(), &m,
01726 P.GetData(), b.GetData(), &m, &info.GetInfoRef());
01727 }
01728
01729
01730 template <class Prop0, class Allocator0,
01731 class Allocator1, class Allocator2>
01732 void SolveLU(const Matrix<double, Prop0, RowSym, Allocator0>& A,
01733 const Vector<int, VectFull, Allocator1>& P,
01734 Vector<double, VectFull, Allocator2>& b,
01735 LapackInfo& info)
01736 {
01737
01738 #ifdef SELDON_CHECK_DIMENSIONS
01739 CheckDim(A, b, "SolveLU(A, pivot, X)");
01740 #endif
01741
01742 int m = A.GetM(); int nrhs = 1;
01743 char uplo('L');
01744 dsytrs_(&uplo, &m, &nrhs, A.GetData(), &m,
01745 P.GetData(), b.GetData(), &m, &info.GetInfoRef());
01746 }
01747
01748
01749 template <class Prop0, class Allocator0,
01750 class Allocator1, class Allocator2>
01751 void SolveLU(const Matrix<complex<float>, Prop0, RowSym, Allocator0>& A,
01752 const Vector<int, VectFull, Allocator1>& P,
01753 Vector<complex<float>, VectFull, Allocator2>& b,
01754 LapackInfo& info)
01755 {
01756
01757 #ifdef SELDON_CHECK_DIMENSIONS
01758 CheckDim(A, b, "SolveLU(A, pivot, X)");
01759 #endif
01760
01761 int m = A.GetM(); int nrhs = 1;
01762 char uplo('L');
01763 csytrs_(&uplo, &m, & nrhs, A.GetDataVoid(), &m,
01764 P.GetData(), b.GetDataVoid(), &m, &info.GetInfoRef());
01765 }
01766
01767
01768 template <class Prop0, class Allocator0,
01769 class Allocator1, class Allocator2>
01770 void SolveLU(const Matrix<complex<double>, Prop0, RowSym, Allocator0>& A,
01771 const Vector<int, VectFull, Allocator1>& P,
01772 Vector<complex<double>, VectFull, Allocator2>& b,
01773 LapackInfo& info)
01774 {
01775
01776 #ifdef SELDON_CHECK_DIMENSIONS
01777 CheckDim(A, b, "SolveLU(A, pivot, X)");
01778 #endif
01779
01780 int m = A.GetM(); int nrhs = 1;
01781 char uplo('L');
01782 zsytrs_(&uplo, &m, &nrhs, A.GetDataVoid(), &m,
01783 P.GetData(), b.GetDataVoid(), &m, &info.GetInfoRef());
01784 }
01785
01786
01787
01788
01789
01790 template <class Prop0, class Allocator0,
01791 class Allocator1, class Allocator2>
01792 void SolveLU(const Matrix<float, Prop0, RowSymPacked, Allocator0>& A,
01793 const Vector<int, VectFull, Allocator1>& P,
01794 Vector<float, VectFull, Allocator2>& b,
01795 LapackInfo& info)
01796 {
01797
01798 #ifdef SELDON_CHECK_DIMENSIONS
01799 CheckDim(A, b, "SolveLU(A, pivot, X)");
01800 #endif
01801
01802 int m = A.GetM();
01803 int nrhs = 1;
01804 char uplo('L');
01805 ssptrs_(&uplo, &m, &nrhs, A.GetData(), P.GetData(),
01806 b.GetData(), &m, &info.GetInfoRef() );
01807 }
01808
01809
01810 template <class Prop0, class Allocator0,
01811 class Allocator1, class Allocator2>
01812 void SolveLU(const Matrix<double, Prop0, RowSymPacked, Allocator0>& A,
01813 const Vector<int, VectFull, Allocator1>& P,
01814 Vector<double, VectFull, Allocator2>& b,
01815 LapackInfo& info)
01816 {
01817
01818 #ifdef SELDON_CHECK_DIMENSIONS
01819 CheckDim(A, b, "SolveLU(A, pivot, X)");
01820 #endif
01821
01822 int m = A.GetM();
01823 int nrhs = 1;
01824 char uplo('L');
01825 dsptrs_(&uplo, &m, &nrhs, A.GetData(), P.GetData(),
01826 b.GetData(), &m, &info.GetInfoRef() );
01827 }
01828
01829
01830 template <class Prop0, class Allocator0,
01831 class Allocator1, class Allocator2>
01832 void SolveLU(const Matrix<complex<float>, Prop0, RowSymPacked,
01833 Allocator0>& A, const Vector<int, VectFull, Allocator1>& P,
01834 Vector<complex<float>, VectFull, Allocator2>& b,
01835 LapackInfo& info)
01836 {
01837
01838 #ifdef SELDON_CHECK_DIMENSIONS
01839 CheckDim(A, b, "SolveLU(A, pivot, X)");
01840 #endif
01841
01842 int m = A.GetM();
01843 int nrhs = 1;
01844 char uplo('L');
01845 csptrs_(&uplo, &m, &nrhs, A.GetDataVoid(), P.GetData(),
01846 b.GetData(), &m, &info.GetInfoRef() );
01847 }
01848
01849
01850 template <class Prop0, class Allocator0,
01851 class Allocator1, class Allocator2>
01852 void SolveLU(const Matrix<complex<double>, Prop0, RowSymPacked,
01853 Allocator0>& A, const Vector<int, VectFull, Allocator1>& P,
01854 Vector<complex<double>, VectFull, Allocator2>& b,
01855 LapackInfo& info)
01856 {
01857
01858 #ifdef SELDON_CHECK_DIMENSIONS
01859 CheckDim(A, b, "SolveLU(A, pivot, X)");
01860 #endif
01861
01862 int m = A.GetM();
01863 int nrhs = 1;
01864 char uplo('L');
01865 zsptrs_(&uplo, &m, &nrhs, A.GetDataVoid(), P.GetData(),
01866 b.GetData(), &m, &info.GetInfoRef() );
01867 }
01868
01869
01870
01871
01872
01873 template <class Prop0, class Allocator0,
01874 class Allocator1, class Allocator2>
01875 void SolveLU(const Matrix<complex<float>, Prop0, ColHerm, Allocator0>& A,
01876 const Vector<int, VectFull, Allocator1>& P,
01877 Vector<complex<float>, VectFull, Allocator2>& b,
01878 LapackInfo& info)
01879 {
01880
01881 #ifdef SELDON_CHECK_DIMENSIONS
01882 CheckDim(A, b, "SolveLU(A, pivot, X)");
01883 #endif
01884
01885 int m = A.GetM(); int nrhs = 1;
01886 char uplo('U');
01887 chetrs_(&uplo, &m, & nrhs, A.GetDataVoid(), &m,
01888 P.GetData(), b.GetDataVoid(), &m, &info.GetInfoRef());
01889 }
01890
01891
01892 template <class Prop0, class Allocator0,
01893 class Allocator1, class Allocator2>
01894 void SolveLU(const Matrix<complex<double>, Prop0, ColHerm, Allocator0>& A,
01895 const Vector<int, VectFull, Allocator1>& P,
01896 Vector<complex<double>, VectFull, Allocator2>& b,
01897 LapackInfo& info)
01898 {
01899
01900 #ifdef SELDON_CHECK_DIMENSIONS
01901 CheckDim(A, b, "SolveLU(A, pivot, X)");
01902 #endif
01903
01904 int m = A.GetM(); int nrhs = 1;
01905 char uplo('U');
01906 zhetrs_(&uplo, &m, &nrhs, A.GetDataVoid(), &m,
01907 P.GetData(), b.GetDataVoid(), &m, &info.GetInfoRef());
01908 }
01909
01910
01911
01912
01913
01914 template <class Prop0, class Allocator0,
01915 class Allocator1, class Allocator2>
01916 void SolveLU(const Matrix<complex<float>, Prop0, ColHermPacked,
01917 Allocator0>& A, const Vector<int, VectFull, Allocator1>& P,
01918 Vector<complex<float>, VectFull, Allocator2>& b,
01919 LapackInfo& info)
01920 {
01921
01922 #ifdef SELDON_CHECK_DIMENSIONS
01923 CheckDim(A, b, "SolveLU(A, pivot, X)");
01924 #endif
01925
01926 int m = A.GetM(); int nrhs = 1;
01927 char uplo('U');
01928 chptrs_(&uplo, &m, & nrhs, A.GetDataVoid(),
01929 P.GetData(), b.GetDataVoid(), &m, &info.GetInfoRef());
01930 }
01931
01932
01933 template <class Prop0, class Allocator0,
01934 class Allocator1, class Allocator2>
01935 void SolveLU(const Matrix<complex<double>, Prop0, ColHermPacked,
01936 Allocator0>& A, const Vector<int, VectFull, Allocator1>& P,
01937 Vector<complex<double>, VectFull, Allocator2>& b,
01938 LapackInfo& info)
01939 {
01940
01941 #ifdef SELDON_CHECK_DIMENSIONS
01942 CheckDim(A, b, "SolveLU(A, pivot, X)");
01943 #endif
01944
01945 int m = A.GetM(); int nrhs = 1;
01946 char uplo('U');
01947 zhptrs_(&uplo, &m, &nrhs, A.GetDataVoid(),
01948 P.GetData(), b.GetDataVoid(), &m, &info.GetInfoRef());
01949 }
01950
01951
01952
01953
01954
01955 template <class Prop0, class Allocator0,
01956 class Allocator1, class Allocator2>
01957 void SolveLU(const Matrix<complex<float>, Prop0, RowHerm, Allocator0>& A,
01958 const Vector<int, VectFull, Allocator1>& P,
01959 Vector<complex<float>, VectFull, Allocator2>& b,
01960 LapackInfo& info)
01961 {
01962
01963 #ifdef SELDON_CHECK_DIMENSIONS
01964 CheckDim(A, b, "SolveLU(A, pivot, X)");
01965 #endif
01966
01967 int m = A.GetM(); int nrhs = 1;
01968 char uplo('L');
01969 Conjugate(b);
01970 chetrs_(&uplo, &m, & nrhs, A.GetDataVoid(), &m,
01971 P.GetData(), b.GetDataVoid(), &m, &info.GetInfoRef());
01972 Conjugate(b);
01973 }
01974
01975
01976 template <class Prop0, class Allocator0,
01977 class Allocator1, class Allocator2>
01978 void SolveLU(const Matrix<complex<double>, Prop0, RowHerm, Allocator0>& A,
01979 const Vector<int, VectFull, Allocator1>& P,
01980 Vector<complex<double>, VectFull, Allocator2>& b,
01981 LapackInfo& info)
01982 {
01983
01984 #ifdef SELDON_CHECK_DIMENSIONS
01985 CheckDim(A, b, "SolveLU(A, pivot, X)");
01986 #endif
01987
01988 int m = A.GetM(); int nrhs = 1;
01989 char uplo('L');
01990 Conjugate(b);
01991 zhetrs_(&uplo, &m, &nrhs, A.GetDataVoid(), &m,
01992 P.GetData(), b.GetDataVoid(), &m, &info.GetInfoRef());
01993 Conjugate(b);
01994 }
01995
01996
01997
01998
01999
02000 template <class Prop0, class Allocator0,
02001 class Allocator1, class Allocator2>
02002 void SolveLU(const Matrix<complex<float>, Prop0, RowHermPacked,
02003 Allocator0>& A, const Vector<int, VectFull, Allocator1>& P,
02004 Vector<complex<float>, VectFull, Allocator2>& b,
02005 LapackInfo& info)
02006 {
02007
02008 #ifdef SELDON_CHECK_DIMENSIONS
02009 CheckDim(A, b, "SolveLU(A, pivot, X)");
02010 #endif
02011
02012 int m = A.GetM(); int nrhs = 1;
02013 char uplo('L');
02014 Conjugate(b);
02015 chptrs_(&uplo, &m, & nrhs, A.GetDataVoid(),
02016 P.GetData(), b.GetDataVoid(), &m, &info.GetInfoRef());
02017 Conjugate(b);
02018 }
02019
02020
02021 template <class Prop0, class Allocator0,
02022 class Allocator1, class Allocator2>
02023 void SolveLU(const Matrix<complex<double>, Prop0, RowHermPacked,
02024 Allocator0>& A, const Vector<int, VectFull, Allocator1>& P,
02025 Vector<complex<double>, VectFull, Allocator2>& b,
02026 LapackInfo& info)
02027 {
02028
02029 #ifdef SELDON_CHECK_DIMENSIONS
02030 CheckDim(A, b, "SolveLU(A, pivot, X)");
02031 #endif
02032
02033 int m = A.GetM(); int nrhs = 1;
02034 char uplo('L');
02035 Conjugate(b);
02036 zhptrs_(&uplo, &m, &nrhs, A.GetDataVoid(),
02037 P.GetData(), b.GetDataVoid(), &m, &info.GetInfoRef());
02038 Conjugate(b);
02039 }
02040
02041
02042
02043
02044
02045 template <class Prop0, class Allocator0, class Allocator2>
02046 void SolveLU(const Matrix<float, Prop0, ColUpTriang, Allocator0>& A,
02047 Vector<float, VectFull, Allocator2>& b,
02048 LapackInfo& info)
02049 {
02050
02051 #ifdef SELDON_CHECK_DIMENSIONS
02052 CheckDim(A, b, "SolveLU(A, X)");
02053 #endif
02054
02055 int m = A.GetM(); int nrhs = 1;
02056 char uplo('U'); char trans('N'); char diag('N');
02057 strtrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetData(), &m,
02058 b.GetData(), &m, &info.GetInfoRef());
02059 }
02060
02061
02062 template <class Prop0, class Allocator0, class Allocator2>
02063 void SolveLU(const Matrix<double, Prop0, ColUpTriang, Allocator0>& A,
02064 Vector<double, VectFull, Allocator2>& b,
02065 LapackInfo& info)
02066 {
02067
02068 #ifdef SELDON_CHECK_DIMENSIONS
02069 CheckDim(A, b, "SolveLU(A, X)");
02070 #endif
02071
02072 int m = A.GetM(); int nrhs = 1;
02073 char uplo('U'); char trans('N'); char diag('N');
02074 dtrtrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetData(), &m,
02075 b.GetData(), &m, &info.GetInfoRef());
02076 }
02077
02078
02079 template <class Prop0, class Allocator0, class Allocator2>
02080 void SolveLU(const Matrix<complex<float>, Prop0, ColUpTriang,
02081 Allocator0>& A,
02082 Vector<complex<float>, VectFull, Allocator2>& b,
02083 LapackInfo& info)
02084 {
02085
02086 #ifdef SELDON_CHECK_DIMENSIONS
02087 CheckDim(A, b, "SolveLU(A, X)");
02088 #endif
02089
02090 int m = A.GetM(); int nrhs = 1;
02091 char uplo('U'); char trans('N'); char diag('N');
02092 ctrtrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetDataVoid(), &m,
02093 b.GetDataVoid(), &m, &info.GetInfoRef());
02094 }
02095
02096
02097 template <class Prop0, class Allocator0, class Allocator2>
02098 void SolveLU(const Matrix<complex<double>, Prop0, ColUpTriang,
02099 Allocator0>& A,
02100 Vector<complex<double>, VectFull, Allocator2>& b,
02101 LapackInfo& info)
02102 {
02103
02104 #ifdef SELDON_CHECK_DIMENSIONS
02105 CheckDim(A, b, "SolveLU(A, X)");
02106 #endif
02107
02108 int m = A.GetM(); int nrhs = 1;
02109 char uplo('U'); char trans('N'); char diag('N');
02110 ztrtrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetDataVoid(), &m,
02111 b.GetDataVoid(), &m, &info.GetInfoRef());
02112
02113 }
02114
02115
02116
02117
02118
02119 template <class Prop0, class Allocator0, class Allocator2>
02120 void SolveLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
02121 const Matrix<float, Prop0, ColUpTriang, Allocator0>& A,
02122 Vector<float, VectFull, Allocator2>& b,
02123 LapackInfo& info)
02124 {
02125
02126 #ifdef SELDON_CHECK_DIMENSIONS
02127 CheckDim(A, b, "SolveLU(A, X)");
02128 #endif
02129
02130 int m = A.GetM(); int nrhs = 1;
02131 char uplo('U');
02132 char trans = TransA.Char(); char diag = DiagA.Char();
02133 strtrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetData(), &m,
02134 b.GetData(), &m, &info.GetInfoRef());
02135 }
02136
02137
02138 template <class Prop0, class Allocator0, class Allocator2>
02139 void SolveLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
02140 const Matrix<double, Prop0, ColUpTriang, Allocator0>& A,
02141 Vector<double, VectFull, Allocator2>& b,
02142 LapackInfo& info)
02143 {
02144
02145 #ifdef SELDON_CHECK_DIMENSIONS
02146 CheckDim(A, b, "SolveLU(A, X)");
02147 #endif
02148
02149 int m = A.GetM(); int nrhs = 1;
02150 char uplo('U');
02151 char trans = TransA.Char(); char diag = DiagA.Char();
02152 dtrtrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetData(), &m,
02153 b.GetData(), &m, &info.GetInfoRef());
02154 }
02155
02156
02157 template <class Prop0, class Allocator0, class Allocator2>
02158 void SolveLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
02159 const Matrix<complex<float>, Prop0, ColUpTriang,
02160 Allocator0>& A,
02161 Vector<complex<float>, VectFull, Allocator2>& b,
02162 LapackInfo& info)
02163 {
02164
02165 #ifdef SELDON_CHECK_DIMENSIONS
02166 CheckDim(A, b, "SolveLU(A, X)");
02167 #endif
02168
02169 int m = A.GetM(); int nrhs = 1;
02170 char uplo('U');
02171 char trans = TransA.Char(); char diag = DiagA.Char();
02172 ctrtrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetDataVoid(), &m,
02173 b.GetDataVoid(), &m, &info.GetInfoRef());
02174 }
02175
02176
02177 template <class Prop0, class Allocator0, class Allocator2>
02178 void SolveLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
02179 const Matrix<complex<double>, Prop0, ColUpTriang,
02180 Allocator0>& A,
02181 Vector<complex<double>, VectFull, Allocator2>& b,
02182 LapackInfo& info)
02183 {
02184
02185 #ifdef SELDON_CHECK_DIMENSIONS
02186 CheckDim(A, b, "SolveLU(A, X)");
02187 #endif
02188
02189 int m = A.GetM(); int nrhs = 1;
02190 char uplo('U');
02191 char trans = TransA.Char(); char diag = DiagA.Char();
02192 ztrtrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetDataVoid(), &m,
02193 b.GetDataVoid(), &m, &info.GetInfoRef());
02194
02195 }
02196
02197
02198
02199
02200
02201 template <class Prop0, class Allocator0, class Allocator2>
02202 void SolveLU(const Matrix<float, Prop0, ColLoTriang, Allocator0>& A,
02203 Vector<float, VectFull, Allocator2>& b,
02204 LapackInfo& info)
02205 {
02206
02207 #ifdef SELDON_CHECK_DIMENSIONS
02208 CheckDim(A, b, "SolveLU(A, X)");
02209 #endif
02210
02211 int m = A.GetM(); int nrhs = 1;
02212 char uplo('L'); char trans('N'); char diag('N');
02213 strtrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetData(), &m,
02214 b.GetData(), &m, &info.GetInfoRef());
02215 }
02216
02217
02218 template <class Prop0, class Allocator0, class Allocator2>
02219 void SolveLU(const Matrix<double, Prop0, ColLoTriang, Allocator0>& A,
02220 Vector<double, VectFull, Allocator2>& b,
02221 LapackInfo& info)
02222 {
02223
02224 #ifdef SELDON_CHECK_DIMENSIONS
02225 CheckDim(A, b, "SolveLU(A, X)");
02226 #endif
02227
02228 int m = A.GetM(); int nrhs = 1;
02229 char uplo('L'); char trans('N'); char diag('N');
02230 dtrtrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetData(), &m,
02231 b.GetData(), &m, &info.GetInfoRef());
02232
02233 }
02234
02235
02236 template <class Prop0, class Allocator0, class Allocator2>
02237 void SolveLU(const Matrix<complex<float>, Prop0, ColLoTriang,
02238 Allocator0>& A,
02239 Vector<complex<float>, VectFull, Allocator2>& b,
02240 LapackInfo& info)
02241 {
02242
02243 #ifdef SELDON_CHECK_DIMENSIONS
02244 CheckDim(A, b, "SolveLU(A, X)");
02245 #endif
02246
02247 int m = A.GetM(); int nrhs = 1;
02248 char uplo('L'); char trans('N'); char diag('N');
02249 ctrtrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetDataVoid(), &m,
02250 b.GetDataVoid(), &m, &info.GetInfoRef());
02251 }
02252
02253
02254 template <class Prop0, class Allocator0, class Allocator2>
02255 void SolveLU(const Matrix<complex<double>, Prop0, ColLoTriang,
02256 Allocator0>& A,
02257 Vector<complex<double>, VectFull, Allocator2>& b,
02258 LapackInfo& info)
02259 {
02260
02261 #ifdef SELDON_CHECK_DIMENSIONS
02262 CheckDim(A, b, "SolveLU(A, X)");
02263 #endif
02264
02265 int m = A.GetM(); int nrhs = 1;
02266 char uplo('L'); char trans('N'); char diag('N');
02267 ztrtrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetDataVoid(), &m,
02268 b.GetDataVoid(), &m, &info.GetInfoRef());
02269
02270 }
02271
02272
02273
02274
02275
02276 template <class Prop0, class Allocator0, class Allocator2>
02277 void SolveLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
02278 const Matrix<float, Prop0, ColLoTriang, Allocator0>& A,
02279 Vector<float, VectFull, Allocator2>& b,
02280 LapackInfo& info)
02281 {
02282
02283 #ifdef SELDON_CHECK_DIMENSIONS
02284 CheckDim(A, b, "SolveLU(A, X)");
02285 #endif
02286
02287 int m = A.GetM(); int nrhs = 1;
02288 char uplo('L');
02289 char trans = TransA.Char(); char diag = DiagA.Char();
02290 strtrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetData(), &m,
02291 b.GetData(), &m, &info.GetInfoRef());
02292 }
02293
02294
02295 template <class Prop0, class Allocator0, class Allocator2>
02296 void SolveLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
02297 const Matrix<double, Prop0, ColLoTriang, Allocator0>& A,
02298 Vector<double, VectFull, Allocator2>& b,
02299 LapackInfo& info)
02300 {
02301
02302 #ifdef SELDON_CHECK_DIMENSIONS
02303 CheckDim(A, b, "SolveLU(A, X)");
02304 #endif
02305
02306 int m = A.GetM(); int nrhs = 1;
02307 char uplo('L');
02308 char trans = TransA.Char(); char diag = DiagA.Char();
02309 dtrtrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetData(), &m,
02310 b.GetData(), &m, &info.GetInfoRef());
02311
02312 }
02313
02314
02315 template <class Prop0, class Allocator0, class Allocator2>
02316 void SolveLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
02317 const Matrix<complex<float>, Prop0, ColLoTriang,
02318 Allocator0>& A,
02319 Vector<complex<float>, VectFull, Allocator2>& b,
02320 LapackInfo& info)
02321 {
02322
02323 #ifdef SELDON_CHECK_DIMENSIONS
02324 CheckDim(A, b, "SolveLU(A, X)");
02325 #endif
02326
02327 int m = A.GetM(); int nrhs = 1;
02328 char uplo('L');
02329 char trans = TransA.Char(); char diag = DiagA.Char();
02330 ctrtrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetDataVoid(), &m,
02331 b.GetDataVoid(), &m, &info.GetInfoRef());
02332 }
02333
02334
02335 template <class Prop0, class Allocator0, class Allocator2>
02336 void SolveLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
02337 const Matrix<complex<double>, Prop0, ColLoTriang,
02338 Allocator0>& A,
02339 Vector<complex<double>, VectFull, Allocator2>& b,
02340 LapackInfo& info)
02341 {
02342
02343 #ifdef SELDON_CHECK_DIMENSIONS
02344 CheckDim(A, b, "SolveLU(A, X)");
02345 #endif
02346
02347 int m = A.GetM(); int nrhs = 1;
02348 char uplo('L');
02349 char trans = TransA.Char(); char diag = DiagA.Char();
02350 ztrtrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetDataVoid(), &m,
02351 b.GetDataVoid(), &m, &info.GetInfoRef());
02352
02353 }
02354
02355
02356
02357
02358
02359 template <class Prop0, class Allocator0, class Allocator2>
02360 void SolveLU(const Matrix<float, Prop0, ColUpTriangPacked, Allocator0>& A,
02361 Vector<float, VectFull, Allocator2>& b,
02362 LapackInfo& info)
02363 {
02364
02365 #ifdef SELDON_CHECK_DIMENSIONS
02366 CheckDim(A, b, "SolveLU(A, X)");
02367 #endif
02368
02369 int m = A.GetM(); int nrhs = 1;
02370 char uplo('U'); char trans('N'); char diag('N');
02371 stptrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetData(),
02372 b.GetData(), &m, &info.GetInfoRef());
02373 }
02374
02375
02376 template <class Prop0, class Allocator0, class Allocator2>
02377 void SolveLU(const Matrix<double, Prop0, ColUpTriangPacked, Allocator0>& A,
02378 Vector<double, VectFull, Allocator2>& b,
02379 LapackInfo& info)
02380 {
02381
02382 #ifdef SELDON_CHECK_DIMENSIONS
02383 CheckDim(A, b, "SolveLU(A, X)");
02384 #endif
02385
02386 int m = A.GetM(); int nrhs = 1;
02387 char uplo('U'); char trans('N'); char diag('N');
02388 dtptrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetData(),
02389 b.GetData(), &m, &info.GetInfoRef());
02390
02391 }
02392
02393
02394 template <class Prop0, class Allocator0, class Allocator2>
02395 void SolveLU(const Matrix<complex<float>, Prop0, ColUpTriangPacked,
02396 Allocator0>& A,
02397 Vector<complex<float>, VectFull, Allocator2>& b,
02398 LapackInfo& info)
02399 {
02400
02401 #ifdef SELDON_CHECK_DIMENSIONS
02402 CheckDim(A, b, "SolveLU(A, X)");
02403 #endif
02404
02405 int m = A.GetM(); int nrhs = 1;
02406 char uplo('U'); char trans('N'); char diag('N');
02407 ctptrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetDataVoid(),
02408 b.GetDataVoid(), &m, &info.GetInfoRef());
02409 }
02410
02411
02412 template <class Prop0, class Allocator0, class Allocator2>
02413 void SolveLU(const Matrix<complex<double>, Prop0, ColUpTriangPacked,
02414 Allocator0>& A,
02415 Vector<complex<double>, VectFull, Allocator2>& b,
02416 LapackInfo& info)
02417 {
02418
02419 #ifdef SELDON_CHECK_DIMENSIONS
02420 CheckDim(A, b, "SolveLU(A, X)");
02421 #endif
02422
02423 int m = A.GetM(); int nrhs = 1;
02424 char uplo('U'); char trans('N'); char diag('N');
02425 ztptrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetDataVoid(),
02426 b.GetDataVoid(), &m, &info.GetInfoRef());
02427
02428 }
02429
02430
02431
02432
02433
02434 template <class Prop0, class Allocator0, class Allocator2>
02435 void SolveLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
02436 const Matrix<float, Prop0, ColUpTriangPacked, Allocator0>& A,
02437 Vector<float, VectFull, Allocator2>& b,
02438 LapackInfo& info)
02439 {
02440
02441 #ifdef SELDON_CHECK_DIMENSIONS
02442 CheckDim(A, b, "SolveLU(A, X)");
02443 #endif
02444
02445 int m = A.GetM(); int nrhs = 1;
02446 char uplo('U');
02447 char trans = TransA.Char(); char diag = DiagA.Char();
02448 stptrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetData(),
02449 b.GetData(), &m, &info.GetInfoRef());
02450 }
02451
02452
02453 template <class Prop0, class Allocator0, class Allocator2>
02454 void SolveLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
02455 const Matrix<double, Prop0, ColUpTriangPacked, Allocator0>& A,
02456 Vector<double, VectFull, Allocator2>& b,
02457 LapackInfo& info)
02458 {
02459
02460 #ifdef SELDON_CHECK_DIMENSIONS
02461 CheckDim(A, b, "SolveLU(A, X)");
02462 #endif
02463
02464 int m = A.GetM(); int nrhs = 1;
02465 char uplo('U');
02466 char trans = TransA.Char(); char diag = DiagA.Char();
02467 dtptrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetData(),
02468 b.GetData(), &m, &info.GetInfoRef());
02469
02470 }
02471
02472
02473 template <class Prop0, class Allocator0, class Allocator2>
02474 void SolveLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
02475 const Matrix<complex<float>, Prop0, ColUpTriangPacked,
02476 Allocator0>& A,
02477 Vector<complex<float>, VectFull, Allocator2>& b,
02478 LapackInfo& info)
02479 {
02480
02481 #ifdef SELDON_CHECK_DIMENSIONS
02482 CheckDim(A, b, "SolveLU(A, X)");
02483 #endif
02484
02485 int m = A.GetM(); int nrhs = 1;
02486 char uplo('U');
02487 char trans = TransA.Char(); char diag = DiagA.Char();
02488 ctptrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetDataVoid(),
02489 b.GetDataVoid(), &m, &info.GetInfoRef());
02490 }
02491
02492
02493 template <class Prop0, class Allocator0, class Allocator2>
02494 void SolveLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
02495 const Matrix<complex<double>, Prop0, ColUpTriangPacked,
02496 Allocator0>& A,
02497 Vector<complex<double>, VectFull, Allocator2>& b,
02498 LapackInfo& info)
02499 {
02500
02501 #ifdef SELDON_CHECK_DIMENSIONS
02502 CheckDim(A, b, "SolveLU(A, X)");
02503 #endif
02504
02505 int m = A.GetM(); int nrhs = 1;
02506 char uplo('U');
02507 char trans = TransA.Char(); char diag = DiagA.Char();
02508 ztptrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetDataVoid(),
02509 b.GetDataVoid(), &m, &info.GetInfoRef());
02510
02511 }
02512
02513
02514
02515
02516
02517 template <class Prop0, class Allocator0, class Allocator2>
02518 void SolveLU(const Matrix<float, Prop0, ColLoTriangPacked, Allocator0>& A,
02519 Vector<float, VectFull, Allocator2>& b,
02520 LapackInfo& info)
02521 {
02522
02523 #ifdef SELDON_CHECK_DIMENSIONS
02524 CheckDim(A, b, "SolveLU(A, X)");
02525 #endif
02526
02527 int m = A.GetM(); int nrhs = 1;
02528 char uplo('L'); char trans('N'); char diag('N');
02529 stptrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetData(),
02530 b.GetData(), &m, &info.GetInfoRef());
02531 }
02532
02533
02534 template <class Prop0, class Allocator0, class Allocator2>
02535 void SolveLU(const Matrix<double, Prop0, ColLoTriangPacked, Allocator0>& A,
02536 Vector<double, VectFull, Allocator2>& b,
02537 LapackInfo& info)
02538 {
02539
02540 #ifdef SELDON_CHECK_DIMENSIONS
02541 CheckDim(A, b, "SolveLU(A, X)");
02542 #endif
02543
02544 int m = A.GetM(); int nrhs = 1;
02545 char uplo('L'); char trans('N'); char diag('N');
02546 dtptrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetData(),
02547 b.GetData(), &m, &info.GetInfoRef());
02548
02549 }
02550
02551
02552 template <class Prop0, class Allocator0, class Allocator2>
02553 void SolveLU(const Matrix<complex<float>, Prop0, ColLoTriangPacked,
02554 Allocator0>& A,
02555 Vector<complex<float>, VectFull, Allocator2>& b,
02556 LapackInfo& info)
02557 {
02558
02559 #ifdef SELDON_CHECK_DIMENSIONS
02560 CheckDim(A, b, "SolveLU(A, X)");
02561 #endif
02562
02563 int m = A.GetM(); int nrhs = 1;
02564 char uplo('L'); char trans('N'); char diag('N');
02565 ctptrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetDataVoid(),
02566 b.GetDataVoid(), &m, &info.GetInfoRef());
02567 }
02568
02569
02570 template <class Prop0, class Allocator0, class Allocator2>
02571 void SolveLU(const Matrix<complex<double>, Prop0, ColLoTriangPacked,
02572 Allocator0>& A,
02573 Vector<complex<double>, VectFull, Allocator2>& b,
02574 LapackInfo& info)
02575 {
02576
02577 #ifdef SELDON_CHECK_DIMENSIONS
02578 CheckDim(A, b, "SolveLU(A, X)");
02579 #endif
02580
02581 int m = A.GetM(); int nrhs = 1;
02582 char uplo('L'); char trans('N'); char diag('N');
02583 ztptrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetDataVoid(),
02584 b.GetDataVoid(), &m, &info.GetInfoRef());
02585
02586 }
02587
02588
02589
02590
02591
02592 template <class Prop0, class Allocator0, class Allocator2>
02593 void SolveLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
02594 const Matrix<float, Prop0, ColLoTriangPacked, Allocator0>& A,
02595 Vector<float, VectFull, Allocator2>& b,
02596 LapackInfo& info)
02597 {
02598
02599 #ifdef SELDON_CHECK_DIMENSIONS
02600 CheckDim(A, b, "SolveLU(A, X)");
02601 #endif
02602
02603 int m = A.GetM(); int nrhs = 1;
02604 char uplo('L');
02605 char trans = TransA.Char(); char diag = DiagA.Char();
02606 stptrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetData(),
02607 b.GetData(), &m, &info.GetInfoRef());
02608 }
02609
02610
02611 template <class Prop0, class Allocator0, class Allocator2>
02612 void SolveLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
02613 const Matrix<double, Prop0, ColLoTriangPacked, Allocator0>& A,
02614 Vector<double, VectFull, Allocator2>& b,
02615 LapackInfo& info)
02616 {
02617
02618 #ifdef SELDON_CHECK_DIMENSIONS
02619 CheckDim(A, b, "SolveLU(A, X)");
02620 #endif
02621
02622 int m = A.GetM(); int nrhs = 1;
02623 char uplo('L');
02624 char trans = TransA.Char(); char diag = DiagA.Char();
02625 dtptrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetData(),
02626 b.GetData(), &m, &info.GetInfoRef());
02627
02628 }
02629
02630
02631 template <class Prop0, class Allocator0, class Allocator2>
02632 void SolveLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
02633 const Matrix<complex<float>, Prop0, ColLoTriangPacked,
02634 Allocator0>& A,
02635 Vector<complex<float>, VectFull, Allocator2>& b,
02636 LapackInfo& info)
02637 {
02638
02639 #ifdef SELDON_CHECK_DIMENSIONS
02640 CheckDim(A, b, "SolveLU(A, X)");
02641 #endif
02642
02643 int m = A.GetM(); int nrhs = 1;
02644 char uplo('L');
02645 char trans = TransA.Char(); char diag = DiagA.Char();
02646 ctptrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetDataVoid(),
02647 b.GetDataVoid(), &m, &info.GetInfoRef());
02648 }
02649
02650
02651 template <class Prop0, class Allocator0, class Allocator2>
02652 void SolveLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
02653 const Matrix<complex<double>, Prop0, ColLoTriangPacked,
02654 Allocator0>& A,
02655 Vector<complex<double>, VectFull, Allocator2>& b,
02656 LapackInfo& info)
02657 {
02658
02659 #ifdef SELDON_CHECK_DIMENSIONS
02660 CheckDim(A, b, "SolveLU(A, X)");
02661 #endif
02662
02663 int m = A.GetM(); int nrhs = 1;
02664 char uplo('L');
02665 char trans = TransA.Char(); char diag = DiagA.Char();
02666 ztptrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetDataVoid(),
02667 b.GetDataVoid(), &m, &info.GetInfoRef());
02668
02669 }
02670
02671
02672
02673
02674
02675 template <class Prop0, class Allocator0, class Allocator2>
02676 void SolveLU(const Matrix<float, Prop0, RowUpTriang, Allocator0>& A,
02677 Vector<float, VectFull, Allocator2>& b,
02678 LapackInfo& info)
02679 {
02680
02681 #ifdef SELDON_CHECK_DIMENSIONS
02682 CheckDim(A, b, "SolveLU(A, X)");
02683 #endif
02684
02685 int m = A.GetM(); int nrhs = 1;
02686 char uplo('L'); char trans('T'); char diag('N');
02687 strtrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetData(), &m,
02688 b.GetData(), &m, &info.GetInfoRef());
02689 }
02690
02691
02692 template <class Prop0, class Allocator0, class Allocator2>
02693 void SolveLU(const Matrix<double, Prop0, RowUpTriang, Allocator0>& A,
02694 Vector<double, VectFull, Allocator2>& b,
02695 LapackInfo& info)
02696 {
02697
02698 #ifdef SELDON_CHECK_DIMENSIONS
02699 CheckDim(A, b, "SolveLU(A, X)");
02700 #endif
02701
02702 int m = A.GetM(); int nrhs = 1;
02703 char uplo('L'); char trans('T'); char diag('N');
02704 dtrtrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetData(), &m,
02705 b.GetData(), &m, &info.GetInfoRef());
02706
02707 }
02708
02709
02710 template <class Prop0, class Allocator0, class Allocator2>
02711 void
02712 SolveLU(const Matrix<complex<float>, Prop0, RowUpTriang, Allocator0>& A,
02713 Vector<complex<float>, VectFull, Allocator2>& b,
02714 LapackInfo& info)
02715 {
02716
02717 #ifdef SELDON_CHECK_DIMENSIONS
02718 CheckDim(A, b, "SolveLU(A, X)");
02719 #endif
02720
02721 int m = A.GetM(); int nrhs = 1;
02722 char uplo('L'); char trans('T'); char diag('N');
02723 ctrtrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetDataVoid(), &m,
02724 b.GetDataVoid(), &m, &info.GetInfoRef());
02725 }
02726
02727
02728 template <class Prop0, class Allocator0, class Allocator2>
02729 void
02730 SolveLU(const Matrix<complex<double>, Prop0, RowUpTriang, Allocator0>& A,
02731 Vector<complex<double>, VectFull, Allocator2>& b,
02732 LapackInfo& info)
02733 {
02734
02735 #ifdef SELDON_CHECK_DIMENSIONS
02736 CheckDim(A, b, "SolveLU(A, X)");
02737 #endif
02738
02739 int m = A.GetM(); int nrhs = 1;
02740 char uplo('L'); char trans('T'); char diag('N');
02741 ztrtrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetDataVoid(), &m,
02742 b.GetDataVoid(), &m, &info.GetInfoRef());
02743
02744 }
02745
02746
02747
02748
02749
02750 template <class Prop0, class Allocator0, class Allocator2>
02751 void SolveLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
02752 const Matrix<float, Prop0, RowUpTriang, Allocator0>& A,
02753 Vector<float, VectFull, Allocator2>& b,
02754 LapackInfo& info)
02755 {
02756
02757 #ifdef SELDON_CHECK_DIMENSIONS
02758 CheckDim(A, b, "SolveLU(A, X)");
02759 #endif
02760
02761 int m = A.GetM(); int nrhs = 1;
02762 char uplo('L');
02763 char trans = TransA.RevChar(); char diag = DiagA.Char();
02764 strtrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetData(), &m,
02765 b.GetData(), &m, &info.GetInfoRef());
02766 }
02767
02768
02769 template <class Prop0, class Allocator0, class Allocator2>
02770 void SolveLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
02771 const Matrix<double, Prop0, RowUpTriang, Allocator0>& A,
02772 Vector<double, VectFull, Allocator2>& b,
02773 LapackInfo& info)
02774 {
02775
02776 #ifdef SELDON_CHECK_DIMENSIONS
02777 CheckDim(A, b, "SolveLU(A, X)");
02778 #endif
02779
02780 int m = A.GetM(); int nrhs = 1;
02781 char uplo('L');
02782 char trans = TransA.RevChar(); char diag = DiagA.Char();
02783 dtrtrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetData(), &m,
02784 b.GetData(), &m, &info.GetInfoRef());
02785
02786 }
02787
02788
02789 template <class Prop0, class Allocator0, class Allocator2>
02790 void
02791 SolveLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
02792 const Matrix<complex<float>, Prop0, RowUpTriang, Allocator0>& A,
02793 Vector<complex<float>, VectFull, Allocator2>& b,
02794 LapackInfo& info)
02795 {
02796
02797 #ifdef SELDON_CHECK_DIMENSIONS
02798 CheckDim(A, b, "SolveLU(A, X)");
02799 #endif
02800
02801 int m = A.GetM(); int nrhs = 1;
02802 char uplo('L');
02803 char trans = TransA.RevChar(); char diag = DiagA.Char();
02804 if (TransA.ConjTrans())
02805 Conjugate(b);
02806 ctrtrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetDataVoid(), &m,
02807 b.GetDataVoid(), &m, &info.GetInfoRef());
02808 if (TransA.ConjTrans())
02809 Conjugate(b);
02810 }
02811
02812
02813 template <class Prop0, class Allocator0, class Allocator2>
02814 void
02815 SolveLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
02816 const Matrix<complex<double>, Prop0, RowUpTriang, Allocator0>& A,
02817 Vector<complex<double>, VectFull, Allocator2>& b,
02818 LapackInfo& info)
02819 {
02820
02821 #ifdef SELDON_CHECK_DIMENSIONS
02822 CheckDim(A, b, "SolveLU(A, X)");
02823 #endif
02824
02825 int m = A.GetM(); int nrhs = 1;
02826 char uplo('L');
02827 char trans = TransA.RevChar(); char diag = DiagA.Char();
02828 if (TransA.ConjTrans())
02829 Conjugate(b);
02830 ztrtrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetDataVoid(), &m,
02831 b.GetDataVoid(), &m, &info.GetInfoRef());
02832 if (TransA.ConjTrans())
02833 Conjugate(b);
02834
02835 }
02836
02837
02838
02839
02840
02841 template <class Prop0, class Allocator0, class Allocator2>
02842 void SolveLU(const Matrix<float, Prop0, RowLoTriang, Allocator0>& A,
02843 Vector<float, VectFull, Allocator2>& b,
02844 LapackInfo& info)
02845 {
02846
02847 #ifdef SELDON_CHECK_DIMENSIONS
02848 CheckDim(A, b, "SolveLU(A, X)");
02849 #endif
02850
02851 int m = A.GetM(); int nrhs = 1;
02852 char uplo('U'); char trans('T'); char diag('N');
02853 strtrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetData(), &m,
02854 b.GetData(), &m, &info.GetInfoRef());
02855 }
02856
02857
02858 template <class Prop0, class Allocator0, class Allocator2>
02859 void SolveLU(const Matrix<double, Prop0, RowLoTriang, Allocator0>& A,
02860 Vector<double, VectFull, Allocator2>& b,
02861 LapackInfo& info)
02862 {
02863
02864 #ifdef SELDON_CHECK_DIMENSIONS
02865 CheckDim(A, b, "SolveLU(A, X)");
02866 #endif
02867
02868 int m = A.GetM(); int nrhs = 1;
02869 char uplo('U'); char trans('T'); char diag('N');
02870 dtrtrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetData(), &m,
02871 b.GetData(), &m, &info.GetInfoRef());
02872
02873 }
02874
02875
02876 template <class Prop0, class Allocator0, class Allocator2>
02877 void
02878 SolveLU(const Matrix<complex<float>, Prop0, RowLoTriang, Allocator0>& A,
02879 Vector<complex<float>, VectFull, Allocator2>& b,
02880 LapackInfo& info)
02881 {
02882
02883 #ifdef SELDON_CHECK_DIMENSIONS
02884 CheckDim(A, b, "SolveLU(A, X)");
02885 #endif
02886
02887 int m = A.GetM(); int nrhs = 1;
02888 char uplo('U'); char trans('T'); char diag('N');
02889 ctrtrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetDataVoid(), &m,
02890 b.GetDataVoid(), &m, &info.GetInfoRef());
02891 }
02892
02893
02894 template <class Prop0, class Allocator0, class Allocator2>
02895 void
02896 SolveLU(const Matrix<complex<double>, Prop0, RowLoTriang, Allocator0>& A,
02897 Vector<complex<double>, VectFull, Allocator2>& b,
02898 LapackInfo& info)
02899 {
02900
02901 #ifdef SELDON_CHECK_DIMENSIONS
02902 CheckDim(A, b, "SolveLU(A, X)");
02903 #endif
02904
02905 int m = A.GetM(); int nrhs = 1;
02906 char uplo('U'); char trans('T'); char diag('N');
02907 ztrtrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetDataVoid(), &m,
02908 b.GetDataVoid(), &m, &info.GetInfoRef());
02909
02910 }
02911
02912
02913
02914
02915
02916 template <class Prop0, class Allocator0, class Allocator2>
02917 void SolveLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
02918 const Matrix<float, Prop0, RowLoTriang, Allocator0>& A,
02919 Vector<float, VectFull, Allocator2>& b,
02920 LapackInfo& info)
02921 {
02922
02923 #ifdef SELDON_CHECK_DIMENSIONS
02924 CheckDim(A, b, "SolveLU(A, X)");
02925 #endif
02926
02927 int m = A.GetM(); int nrhs = 1;
02928 char uplo('U');
02929 char trans = TransA.RevChar(); char diag = DiagA.Char();
02930 strtrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetData(), &m,
02931 b.GetData(), &m, &info.GetInfoRef());
02932 }
02933
02934
02935 template <class Prop0, class Allocator0, class Allocator2>
02936 void SolveLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
02937 const Matrix<double, Prop0, RowLoTriang, Allocator0>& A,
02938 Vector<double, VectFull, Allocator2>& b,
02939 LapackInfo& info)
02940 {
02941
02942 #ifdef SELDON_CHECK_DIMENSIONS
02943 CheckDim(A, b, "SolveLU(A, X)");
02944 #endif
02945
02946 int m = A.GetM(); int nrhs = 1;
02947 char uplo('U');
02948 char trans = TransA.RevChar(); char diag = DiagA.Char();
02949 dtrtrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetData(), &m,
02950 b.GetData(), &m, &info.GetInfoRef());
02951
02952 }
02953
02954
02955 template <class Prop0, class Allocator0, class Allocator2>
02956 void
02957 SolveLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
02958 const Matrix<complex<float>, Prop0, RowLoTriang, Allocator0>& A,
02959 Vector<complex<float>, VectFull, Allocator2>& b,
02960 LapackInfo& info)
02961 {
02962
02963 #ifdef SELDON_CHECK_DIMENSIONS
02964 CheckDim(A, b, "SolveLU(A, X)");
02965 #endif
02966
02967 int m = A.GetM(); int nrhs = 1;
02968 char uplo('U');
02969 char trans = TransA.RevChar(); char diag = DiagA.Char();
02970 if (TransA.ConjTrans())
02971 Conjugate(b);
02972 ctrtrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetDataVoid(), &m,
02973 b.GetDataVoid(), &m, &info.GetInfoRef());
02974 if (TransA.ConjTrans())
02975 Conjugate(b);
02976 }
02977
02978
02979 template <class Prop0, class Allocator0, class Allocator2>
02980 void
02981 SolveLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
02982 const Matrix<complex<double>, Prop0, RowLoTriang, Allocator0>& A,
02983 Vector<complex<double>, VectFull, Allocator2>& b,
02984 LapackInfo& info)
02985 {
02986
02987 #ifdef SELDON_CHECK_DIMENSIONS
02988 CheckDim(A, b, "SolveLU(A, X)");
02989 #endif
02990
02991 int m = A.GetM(); int nrhs = 1;
02992 char uplo('U');
02993 char trans = TransA.RevChar(); char diag = DiagA.Char();
02994 if (TransA.ConjTrans())
02995 Conjugate(b);
02996 ztrtrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetDataVoid(), &m,
02997 b.GetDataVoid(), &m, &info.GetInfoRef());
02998 if (TransA.ConjTrans())
02999 Conjugate(b);
03000 }
03001
03002
03003
03004
03005
03006 template <class Prop0, class Allocator0, class Allocator2>
03007 void SolveLU(const Matrix<float, Prop0, RowUpTriangPacked, Allocator0>& A,
03008 Vector<float, VectFull, Allocator2>& b,
03009 LapackInfo& info)
03010 {
03011
03012 #ifdef SELDON_CHECK_DIMENSIONS
03013 CheckDim(A, b, "SolveLU(A, X)");
03014 #endif
03015
03016 int m = A.GetM(); int nrhs = 1;
03017 char uplo('L'); char trans('T'); char diag('N');
03018 stptrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetData(),
03019 b.GetData(), &m, &info.GetInfoRef());
03020 }
03021
03022
03023 template <class Prop0, class Allocator0, class Allocator2>
03024 void SolveLU(const Matrix<double, Prop0, RowUpTriangPacked, Allocator0>& A,
03025 Vector<double, VectFull, Allocator2>& b,
03026 LapackInfo& info)
03027 {
03028
03029 #ifdef SELDON_CHECK_DIMENSIONS
03030 CheckDim(A, b, "SolveLU(A, X)");
03031 #endif
03032
03033 int m = A.GetM(); int nrhs = 1;
03034 char uplo('L'); char trans('T'); char diag('N');
03035 dtptrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetData(),
03036 b.GetData(), &m, &info.GetInfoRef());
03037
03038 }
03039
03040
03041 template <class Prop0, class Allocator0, class Allocator2>
03042 void SolveLU(const Matrix<complex<float>, Prop0, RowUpTriangPacked,
03043 Allocator0>& A,
03044 Vector<complex<float>, VectFull, Allocator2>& b,
03045 LapackInfo& info)
03046 {
03047
03048 #ifdef SELDON_CHECK_DIMENSIONS
03049 CheckDim(A, b, "SolveLU(A, X)");
03050 #endif
03051
03052 int m = A.GetM(); int nrhs = 1;
03053 char uplo('L'); char trans('T'); char diag('N');
03054 ctptrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetDataVoid(),
03055 b.GetDataVoid(), &m, &info.GetInfoRef());
03056 }
03057
03058
03059 template <class Prop0, class Allocator0, class Allocator2>
03060 void SolveLU(const Matrix<complex<double>, Prop0, RowUpTriangPacked,
03061 Allocator0>& A,
03062 Vector<complex<double>, VectFull, Allocator2>& b,
03063 LapackInfo& info)
03064 {
03065
03066 #ifdef SELDON_CHECK_DIMENSIONS
03067 CheckDim(A, b, "SolveLU(A, X)");
03068 #endif
03069
03070 int m = A.GetM(); int nrhs = 1;
03071 char uplo('L'); char trans('T'); char diag('N');
03072 ztptrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetDataVoid(),
03073 b.GetDataVoid(), &m, &info.GetInfoRef());
03074
03075 }
03076
03077
03078
03079
03080
03081 template <class Prop0, class Allocator0, class Allocator2>
03082 void SolveLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
03083 const Matrix<float, Prop0, RowUpTriangPacked, Allocator0>& A,
03084 Vector<float, VectFull, Allocator2>& b,
03085 LapackInfo& info)
03086 {
03087
03088 #ifdef SELDON_CHECK_DIMENSIONS
03089 CheckDim(A, b, "SolveLU(A, X)");
03090 #endif
03091
03092 int m = A.GetM(); int nrhs = 1;
03093 char uplo('L');
03094 char trans = TransA.RevChar(); char diag = DiagA.Char();
03095 stptrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetData(),
03096 b.GetData(), &m, &info.GetInfoRef());
03097 }
03098
03099
03100 template <class Prop0, class Allocator0, class Allocator2>
03101 void SolveLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
03102 const Matrix<double, Prop0, RowUpTriangPacked, Allocator0>& A,
03103 Vector<double, VectFull, Allocator2>& b,
03104 LapackInfo& info)
03105 {
03106
03107 #ifdef SELDON_CHECK_DIMENSIONS
03108 CheckDim(A, b, "SolveLU(A, X)");
03109 #endif
03110
03111 int m = A.GetM(); int nrhs = 1;
03112 char uplo('L');
03113 char trans = TransA.RevChar(); char diag = DiagA.Char();
03114 dtptrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetData(),
03115 b.GetData(), &m, &info.GetInfoRef());
03116
03117 }
03118
03119
03120 template <class Prop0, class Allocator0, class Allocator2>
03121 void SolveLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
03122 const Matrix<complex<float>, Prop0, RowUpTriangPacked,
03123 Allocator0>& A,
03124 Vector<complex<float>, VectFull, Allocator2>& b,
03125 LapackInfo& info)
03126 {
03127
03128 #ifdef SELDON_CHECK_DIMENSIONS
03129 CheckDim(A, b, "SolveLU(A, X)");
03130 #endif
03131
03132 int m = A.GetM(); int nrhs = 1;
03133 char uplo('L');
03134 char trans = TransA.RevChar(); char diag = DiagA.Char();
03135 if (TransA.ConjTrans())
03136 Conjugate(b);
03137 ctptrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetDataVoid(),
03138 b.GetDataVoid(), &m, &info.GetInfoRef());
03139 if (TransA.ConjTrans())
03140 Conjugate(b);
03141 }
03142
03143
03144 template <class Prop0, class Allocator0, class Allocator2>
03145 void SolveLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
03146 const Matrix<complex<double>, Prop0, RowUpTriangPacked,
03147 Allocator0>& A,
03148 Vector<complex<double>, VectFull, Allocator2>& b,
03149 LapackInfo& info)
03150 {
03151
03152 #ifdef SELDON_CHECK_DIMENSIONS
03153 CheckDim(A, b, "SolveLU(A, X)");
03154 #endif
03155
03156 int m = A.GetM(); int nrhs = 1;
03157 char uplo('L');
03158 char trans = TransA.RevChar(); char diag = DiagA.Char();
03159 if (TransA.ConjTrans())
03160 Conjugate(b);
03161 ztptrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetDataVoid(),
03162 b.GetDataVoid(), &m, &info.GetInfoRef());
03163 if (TransA.ConjTrans())
03164 Conjugate(b);
03165 }
03166
03167
03168
03169
03170
03171 template <class Prop0, class Allocator0, class Allocator2>
03172 void SolveLU(const Matrix<float, Prop0, RowLoTriangPacked, Allocator0>& A,
03173 Vector<float, VectFull, Allocator2>& b,
03174 LapackInfo& info)
03175 {
03176
03177 #ifdef SELDON_CHECK_DIMENSIONS
03178 CheckDim(A, b, "SolveLU(A, X)");
03179 #endif
03180
03181 int m = A.GetM(); int nrhs = 1;
03182 char uplo('U'); char trans('T'); char diag('N');
03183 stptrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetData(),
03184 b.GetData(), &m, &info.GetInfoRef());
03185 }
03186
03187
03188 template <class Prop0, class Allocator0, class Allocator2>
03189 void SolveLU(const Matrix<double, Prop0, RowLoTriangPacked, Allocator0>& A,
03190 Vector<double, VectFull, Allocator2>& b,
03191 LapackInfo& info)
03192 {
03193
03194 #ifdef SELDON_CHECK_DIMENSIONS
03195 CheckDim(A, b, "SolveLU(A, X)");
03196 #endif
03197
03198 int m = A.GetM(); int nrhs = 1;
03199 char uplo('U'); char trans('T'); char diag('N');
03200 dtptrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetData(),
03201 b.GetData(), &m, &info.GetInfoRef());
03202
03203 }
03204
03205
03206 template <class Prop0, class Allocator0, class Allocator2>
03207 void SolveLU(const Matrix<complex<float>, Prop0, RowLoTriangPacked,
03208 Allocator0>& A,
03209 Vector<complex<float>, VectFull, Allocator2>& b,
03210 LapackInfo& info)
03211 {
03212
03213 #ifdef SELDON_CHECK_DIMENSIONS
03214 CheckDim(A, b, "SolveLU(A, X)");
03215 #endif
03216
03217 int m = A.GetM(); int nrhs = 1;
03218 char uplo('U'); char trans('T'); char diag('N');
03219
03220
03221 ctptrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetDataVoid(),
03222 b.GetDataVoid(), &m, &info.GetInfoRef());
03223 }
03224
03225
03226 template <class Prop0, class Allocator0, class Allocator2>
03227 void SolveLU(const Matrix<complex<double>, Prop0, RowLoTriangPacked,
03228 Allocator0>& A,
03229 Vector<complex<double>, VectFull, Allocator2>& b,
03230 LapackInfo& info)
03231 {
03232
03233 #ifdef SELDON_CHECK_DIMENSIONS
03234 CheckDim(A, b, "SolveLU(A, X)");
03235 #endif
03236
03237 int m = A.GetM(); int nrhs = 1;
03238 char uplo('U'); char trans('T'); char diag('N');
03239 ztptrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetDataVoid(),
03240 b.GetDataVoid(), &m, &info.GetInfoRef());
03241
03242 }
03243
03244
03245
03246
03247
03248 template <class Prop0, class Allocator0, class Allocator2>
03249 void SolveLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
03250 const Matrix<float, Prop0, RowLoTriangPacked, Allocator0>& A,
03251 Vector<float, VectFull, Allocator2>& b,
03252 LapackInfo& info)
03253 {
03254
03255 #ifdef SELDON_CHECK_DIMENSIONS
03256 CheckDim(A, b, "SolveLU(A, X)");
03257 #endif
03258
03259 int m = A.GetM(); int nrhs = 1;
03260 char uplo('U');
03261 char trans = TransA.RevChar(); char diag = DiagA.Char();
03262 stptrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetData(),
03263 b.GetData(), &m, &info.GetInfoRef());
03264 }
03265
03266
03267 template <class Prop0, class Allocator0, class Allocator2>
03268 void SolveLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
03269 const Matrix<double, Prop0, RowLoTriangPacked, Allocator0>& A,
03270 Vector<double, VectFull, Allocator2>& b,
03271 LapackInfo& info)
03272 {
03273
03274 #ifdef SELDON_CHECK_DIMENSIONS
03275 CheckDim(A, b, "SolveLU(A, X)");
03276 #endif
03277
03278 int m = A.GetM(); int nrhs = 1;
03279 char uplo('U');
03280 char trans = TransA.RevChar(); char diag = DiagA.Char();
03281 dtptrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetData(),
03282 b.GetData(), &m, &info.GetInfoRef());
03283
03284 }
03285
03286
03287 template <class Prop0, class Allocator0, class Allocator2>
03288 void SolveLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
03289 const Matrix<complex<float>, Prop0, RowLoTriangPacked,
03290 Allocator0>& A,
03291 Vector<complex<float>, VectFull, Allocator2>& b,
03292 LapackInfo& info)
03293 {
03294
03295 #ifdef SELDON_CHECK_DIMENSIONS
03296 CheckDim(A, b, "SolveLU(A, X)");
03297 #endif
03298
03299 int m = A.GetM(); int nrhs = 1;
03300 char uplo('U');
03301 char trans = TransA.RevChar(); char diag = DiagA.Char();
03302 if (TransA.ConjTrans())
03303 Conjugate(b);
03304 ctptrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetDataVoid(),
03305 b.GetDataVoid(), &m, &info.GetInfoRef());
03306 if (TransA.ConjTrans())
03307 Conjugate(b);
03308 }
03309
03310
03311 template <class Prop0, class Allocator0, class Allocator2>
03312 void SolveLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
03313 const Matrix<complex<double>, Prop0, RowLoTriangPacked,
03314 Allocator0>& A,
03315 Vector<complex<double>, VectFull, Allocator2>& b,
03316 LapackInfo& info)
03317 {
03318
03319 #ifdef SELDON_CHECK_DIMENSIONS
03320 CheckDim(A, b, "SolveLU(A, X)");
03321 #endif
03322
03323 int m = A.GetM(); int nrhs = 1;
03324 char uplo('U');
03325 char trans = TransA.RevChar(); char diag = DiagA.Char();
03326 if (TransA.ConjTrans())
03327 Conjugate(b);
03328 ztptrs_(&uplo, &trans, &diag, &m, & nrhs, A.GetDataVoid(),
03329 b.GetDataVoid(), &m, &info.GetInfoRef());
03330 if (TransA.ConjTrans())
03331 Conjugate(b);
03332 }
03333
03334
03335
03337
03338
03339
03341
03342
03343
03344
03345
03346
03347 template<class Prop0, class Allocator0, class Allocator1>
03348 float ReciprocalConditionNumber(const Matrix<float, Prop0, ColMajor,
03349 Allocator0>& A,
03350 Vector<int, VectFull, Allocator1>& P,
03351 SeldonNorm norm, float anorm,
03352 LapackInfo& info)
03353 {
03354 char norm_type = norm.Char();
03355
03356 int n = A.GetM(); float rcond(0);
03357 Vector<int> iwork(n); Vector<float, VectFull, Allocator0> work(4*n);
03358 sgecon_(&norm_type, &n, A.GetData(), &n, &anorm, &rcond,
03359 work.GetData(), iwork.GetData(), &info.GetInfoRef());
03360 return rcond;
03361 }
03362
03363
03364 template<class Prop0, class Allocator0, class Allocator1>
03365 double ReciprocalConditionNumber(const Matrix<double, Prop0, ColMajor,
03366 Allocator0>& A,
03367 Vector<int, VectFull, Allocator1>& P,
03368 SeldonNorm norm, double anorm,
03369 LapackInfo& info)
03370 {
03371 char norm_type = norm.Char();
03372
03373 int n = A.GetM(); double rcond(0);
03374 Vector<int> iwork(n); Vector<double, VectFull, Allocator0> work(4*n);
03375 dgecon_(&norm_type, &n, A.GetData(), &n, &anorm, &rcond,
03376 work.GetData(), iwork.GetData(), &info.GetInfoRef());
03377 return rcond;
03378 }
03379
03380
03381 template<class Prop0, class Allocator0, class Allocator1>
03382 float ReciprocalConditionNumber(const Matrix<complex<float>, Prop0,
03383 ColMajor, Allocator0>& A,
03384 Vector<int, VectFull, Allocator1>& P,
03385 SeldonNorm norm, float anorm,
03386 LapackInfo& info)
03387 {
03388 char norm_type = norm.Char();
03389
03390 int n = A.GetM(); float rcond(0);
03391 Vector<float> rwork(2*n);
03392 Vector<complex<float>, VectFull, Allocator0> work(2*n);
03393 cgecon_(&norm_type, &n, A.GetDataVoid(), &n, &anorm, &rcond,
03394 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
03395 return rcond;
03396 }
03397
03398
03399 template<class Prop0, class Allocator0, class Allocator1>
03400 double ReciprocalConditionNumber(const Matrix<complex<double>, Prop0,
03401 ColMajor, Allocator0>& A,
03402 Vector<int, VectFull, Allocator1>& P,
03403 SeldonNorm norm, double anorm,
03404 LapackInfo& info)
03405 {
03406 char norm_type = norm.Char();
03407
03408 int n = A.GetM(); double rcond(0);
03409 Vector<double> rwork(2*n);
03410 Vector<complex<double>, VectFull, Allocator0> work(2*n);
03411 zgecon_(&norm_type, &n, A.GetDataVoid(), &n, &anorm, &rcond,
03412 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
03413 return rcond;
03414 }
03415
03416
03417
03418
03419
03420 template<class Prop0, class Allocator0, class Allocator1>
03421 float ReciprocalConditionNumber(const Matrix<float, Prop0, RowMajor,
03422 Allocator0>& A,
03423 Vector<int, VectFull, Allocator1>& P,
03424 SeldonNorm norm, float anorm,
03425 LapackInfo& info)
03426 {
03427 char norm_type = norm.RevChar();
03428
03429 int n = A.GetM(); float rcond(0);
03430 Vector<int> iwork(n); Vector<float, VectFull, Allocator0> work(4*n);
03431 sgecon_(&norm_type, &n, A.GetData(), &n, &anorm, &rcond,
03432 work.GetData(), iwork.GetData(), &info.GetInfoRef());
03433 return rcond;
03434 }
03435
03436
03437 template<class Prop0, class Allocator0, class Allocator1>
03438 double ReciprocalConditionNumber(const Matrix<double, Prop0, RowMajor,
03439 Allocator0>& A,
03440 Vector<int, VectFull, Allocator1>& P,
03441 SeldonNorm norm, double anorm,
03442 LapackInfo& info)
03443 {
03444 char norm_type = norm.RevChar();
03445
03446 int n = A.GetM(); double rcond(0);
03447 Vector<int> iwork(n); Vector<double, VectFull, Allocator0> work(4*n);
03448 dgecon_(&norm_type, &n, A.GetData(), &n, &anorm, &rcond,
03449 work.GetData(), iwork.GetData(), &info.GetInfoRef());
03450 return rcond;
03451 }
03452
03453
03454 template<class Prop0, class Allocator0, class Allocator1>
03455 float ReciprocalConditionNumber(const Matrix<complex<float>, Prop0,
03456 RowMajor, Allocator0>& A,
03457 Vector<int, VectFull, Allocator1>& P,
03458 SeldonNorm norm, float anorm,
03459 LapackInfo& info)
03460 {
03461 char norm_type = norm.RevChar();
03462
03463 int n = A.GetM(); float rcond(0);
03464 Vector<float> rwork(2*n);
03465 Vector<complex<float>, VectFull, Allocator0> work(2*n);
03466 cgecon_(&norm_type, &n, A.GetDataVoid(), &n, &anorm, &rcond,
03467 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
03468 return rcond;
03469 }
03470
03471
03472 template<class Prop0, class Allocator0, class Allocator1>
03473 double ReciprocalConditionNumber(const Matrix<complex<double>, Prop0,
03474 RowMajor, Allocator0>& A,
03475 Vector<int, VectFull, Allocator1>& P,
03476 SeldonNorm norm, double anorm,
03477 LapackInfo& info)
03478 {
03479 char norm_type = norm.RevChar();
03480
03481 int n = A.GetM(); double rcond(0);
03482 Vector<double> rwork(2*n);
03483 Vector<complex<double>, VectFull, Allocator0> work(2*n);
03484 zgecon_(&norm_type, &n, A.GetDataVoid(), &n, &anorm, &rcond,
03485 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
03486 return rcond;
03487 }
03488
03489
03490
03491
03492
03493 template<class Prop0, class Allocator0, class Allocator1>
03494 float ReciprocalConditionNumber(const Matrix<float, Prop0, ColSym,
03495 Allocator0>& A,
03496 Vector<int, VectFull, Allocator1>& P,
03497 SeldonNorm norm, float anorm,
03498 LapackInfo& info)
03499 {
03500 char uplo('U');
03501
03502 int n = A.GetM(); float rcond(0);
03503 Vector<int> iwork(n); Vector<float, VectFull, Allocator0> work(2*n);
03504 ssycon_(&uplo, &n, A.GetData(), &n, P.GetData(), &anorm, &rcond,
03505 work.GetData(), iwork.GetData(), &info.GetInfoRef());
03506 return rcond;
03507 }
03508
03509
03510 template<class Prop0, class Allocator0, class Allocator1>
03511 double ReciprocalConditionNumber(const Matrix<double, Prop0, ColSym,
03512 Allocator0>& A,
03513 Vector<int, VectFull, Allocator1>& P,
03514 SeldonNorm norm, double anorm,
03515 LapackInfo& info)
03516 {
03517 char uplo('U');
03518
03519 int n = A.GetM(); double rcond(0);
03520 Vector<int> iwork(n); Vector<double, VectFull, Allocator0> work(2*n);
03521 dsycon_(&uplo, &n, A.GetData(), &n, P.GetData(), &anorm, &rcond,
03522 work.GetData(), iwork.GetData(), &info.GetInfoRef());
03523 return rcond;
03524 }
03525
03526
03527 template<class Prop0, class Allocator0, class Allocator1>
03528 float ReciprocalConditionNumber(const Matrix<complex<float>, Prop0,
03529 ColSym, Allocator0>& A,
03530 Vector<int, VectFull, Allocator1>& P,
03531 SeldonNorm norm, float anorm,
03532 LapackInfo& info)
03533 {
03534 char uplo('U');
03535
03536 int n = A.GetM(); float rcond(0);
03537 Vector<complex<float>, VectFull, Allocator0> work(2*n);
03538 csycon_(&uplo, &n, A.GetDataVoid(), &n, P.GetData(), &anorm, &rcond,
03539 work.GetDataVoid(), &info.GetInfoRef());
03540 return rcond;
03541 }
03542
03543
03544 template<class Prop0, class Allocator0, class Allocator1>
03545 double ReciprocalConditionNumber(const Matrix<complex<double>, Prop0,
03546 ColSym, Allocator0>& A,
03547 Vector<int, VectFull, Allocator1>& P,
03548 SeldonNorm norm, double anorm,
03549 LapackInfo& info)
03550 {
03551 char uplo('U');
03552
03553 int n = A.GetM(); double rcond(0);
03554 Vector<complex<double>, VectFull, Allocator0> work(2*n);
03555 zsycon_(&uplo, &n, A.GetDataVoid(), &n, P.GetData(), &anorm, &rcond,
03556 work.GetDataVoid(), &info.GetInfoRef());
03557 return rcond;
03558 }
03559
03560
03561
03562
03563
03564 template<class Prop0, class Allocator0, class Allocator1>
03565 float ReciprocalConditionNumber(const Matrix<float, Prop0,
03566 ColSymPacked, Allocator0>& A,
03567 Vector<int, VectFull, Allocator1>& P,
03568 SeldonNorm norm, float anorm,
03569 LapackInfo& info)
03570 {
03571 char uplo('U');
03572
03573 int n = A.GetM(); float rcond(0);
03574 Vector<int> iwork(n); Vector<float, VectFull, Allocator0> work(2*n);
03575 sspcon_(&uplo, &n, A.GetData(), P.GetData(), &anorm, &rcond,
03576 work.GetData(), iwork.GetData(), &info.GetInfoRef());
03577 return rcond;
03578 }
03579
03580
03581 template<class Prop0, class Allocator0, class Allocator1>
03582 double ReciprocalConditionNumber(const Matrix<double, Prop0, ColSymPacked,
03583 Allocator0>& A,
03584 Vector<int, VectFull, Allocator1>& P,
03585 SeldonNorm norm, double anorm,
03586 LapackInfo& info)
03587 {
03588 char uplo('U');
03589
03590 int n = A.GetM(); double rcond(0);
03591 Vector<int> iwork(n); Vector<double, VectFull, Allocator0> work(2*n);
03592 dspcon_(&uplo, &n, A.GetData(), P.GetData(), &anorm, &rcond,
03593 work.GetData(), iwork.GetData(), &info.GetInfoRef());
03594 return rcond;
03595 }
03596
03597
03598 template<class Prop0, class Allocator0, class Allocator1>
03599 float ReciprocalConditionNumber(const Matrix<complex<float>, Prop0,
03600 ColSymPacked, Allocator0>& A,
03601 Vector<int, VectFull, Allocator1>& P,
03602 SeldonNorm norm, float anorm,
03603 LapackInfo& info)
03604 {
03605 char uplo('U');
03606
03607 int n = A.GetM(); float rcond(0);
03608 Vector<complex<float>, VectFull, Allocator0> work(2*n);
03609 cspcon_(&uplo, &n, A.GetData(), P.GetData(), &anorm, &rcond,
03610 work.GetData(), &info.GetInfoRef());
03611 return rcond;
03612 }
03613
03614
03615 template<class Prop0, class Allocator0, class Allocator1>
03616 double ReciprocalConditionNumber(const Matrix<complex<double>, Prop0,
03617 ColSymPacked, Allocator0>& A,
03618 Vector<int, VectFull, Allocator1>& P,
03619 SeldonNorm norm, double anorm,
03620 LapackInfo& info)
03621 {
03622 char uplo('U');
03623
03624 int n = A.GetM(); double rcond(0);
03625 Vector<complex<double>, VectFull, Allocator0> work(2*n);
03626 zspcon_(&uplo, &n, A.GetData(), P.GetData(), &anorm, &rcond,
03627 work.GetData(), &info.GetInfoRef());
03628 return rcond;
03629 }
03630
03631
03632
03633
03634
03635 template<class Prop0, class Allocator0, class Allocator1>
03636 float ReciprocalConditionNumber(const Matrix<float, Prop0, RowSym,
03637 Allocator0>& A,
03638 Vector<int, VectFull, Allocator1>& P,
03639 SeldonNorm norm, float anorm,
03640 LapackInfo& info)
03641 {
03642 char uplo('L');
03643
03644 int n = A.GetM(); float rcond(0);
03645 Vector<int> iwork(n); Vector<float, VectFull, Allocator0> work(2*n);
03646 ssycon_(&uplo, &n, A.GetData(), &n, P.GetData(), &anorm, &rcond,
03647 work.GetData(), iwork.GetData(), &info.GetInfoRef());
03648 return rcond;
03649 }
03650
03651
03652 template<class Prop0, class Allocator0, class Allocator1>
03653 double ReciprocalConditionNumber(const Matrix<double, Prop0, RowSym,
03654 Allocator0>& A,
03655 Vector<int, VectFull, Allocator1>& P,
03656 SeldonNorm norm, double anorm,
03657 LapackInfo& info)
03658 {
03659 char uplo('L');
03660
03661 int n = A.GetM(); double rcond(0);
03662 Vector<int> iwork(n); Vector<double, VectFull, Allocator0> work(2*n);
03663 dsycon_(&uplo, &n, A.GetData(), &n, P.GetData(), &anorm, &rcond,
03664 work.GetData(), iwork.GetData(), &info.GetInfoRef());
03665 return rcond;
03666 }
03667
03668
03669 template<class Prop0, class Allocator0, class Allocator1>
03670 float ReciprocalConditionNumber(const Matrix<complex<float>, Prop0, RowSym,
03671 Allocator0>& A,
03672 Vector<int, VectFull, Allocator1>& P,
03673 SeldonNorm norm, float anorm,
03674 LapackInfo& info)
03675 {
03676 char uplo('L');
03677
03678 int n = A.GetM(); float rcond(0);
03679 Vector<complex<float>, VectFull, Allocator0> work(2*n);
03680 csycon_(&uplo, &n, A.GetDataVoid(), &n, P.GetData(), &anorm, &rcond,
03681 work.GetDataVoid(), &info.GetInfoRef());
03682 return rcond;
03683 }
03684
03685
03686 template<class Prop0, class Allocator0, class Allocator1>
03687 double ReciprocalConditionNumber(const Matrix<complex<double>, Prop0,
03688 RowSym, Allocator0>& A,
03689 Vector<int, VectFull, Allocator1>& P,
03690 SeldonNorm norm, double anorm,
03691 LapackInfo& info)
03692 {
03693 char uplo('L');
03694
03695 int n = A.GetM(); double rcond(0);
03696 Vector<complex<double>, VectFull, Allocator0> work(2*n);
03697 zsycon_(&uplo, &n, A.GetDataVoid(), &n, P.GetData(), &anorm, &rcond,
03698 work.GetDataVoid(), &info.GetInfoRef());
03699 return rcond;
03700 }
03701
03702
03703
03704
03705
03706 template<class Prop0, class Allocator0, class Allocator1>
03707 float ReciprocalConditionNumber(const Matrix<float, Prop0, RowSymPacked,
03708 Allocator0>& A,
03709 Vector<int, VectFull, Allocator1>& P,
03710 SeldonNorm norm, float anorm,
03711 LapackInfo& info)
03712 {
03713 char uplo('L');
03714
03715 int n = A.GetM(); float rcond(0);
03716 Vector<int> iwork(n); Vector<float, VectFull, Allocator0> work(2*n);
03717 sspcon_(&uplo, &n, A.GetData(), P.GetData(), &anorm, &rcond,
03718 work.GetData(), iwork.GetData(), &info.GetInfoRef());
03719 return rcond;
03720 }
03721
03722
03723 template<class Prop0, class Allocator0, class Allocator1>
03724 double ReciprocalConditionNumber(const Matrix<double, Prop0, RowSymPacked,
03725 Allocator0>& A,
03726 Vector<int, VectFull, Allocator1>& P,
03727 SeldonNorm norm, double anorm,
03728 LapackInfo& info)
03729 {
03730 char uplo('L');
03731
03732 int n = A.GetM(); double rcond(0);
03733 Vector<int> iwork(n); Vector<double, VectFull, Allocator0> work(2*n);
03734 dspcon_(&uplo, &n, A.GetData(), P.GetData(), &anorm, &rcond,
03735 work.GetData(), iwork.GetData(), &info.GetInfoRef());
03736 return rcond;
03737 }
03738
03739
03740 template<class Prop0, class Allocator0, class Allocator1>
03741 float ReciprocalConditionNumber(const Matrix<complex<float>, Prop0,
03742 RowSymPacked, Allocator0>& A,
03743 Vector<int, VectFull, Allocator1>& P,
03744 SeldonNorm norm, float anorm,
03745 LapackInfo& info)
03746 {
03747 char uplo('L');
03748
03749 int n = A.GetM(); float rcond(0);
03750 Vector<complex<float>, VectFull, Allocator0> work(2*n);
03751 cspcon_(&uplo, &n, A.GetData(), P.GetData(), &anorm, &rcond,
03752 work.GetData(), &info.GetInfoRef());
03753 return rcond;
03754 }
03755
03756
03757 template<class Prop0, class Allocator0, class Allocator1>
03758 double ReciprocalConditionNumber(const Matrix<complex<double>, Prop0,
03759 RowSymPacked, Allocator0>& A,
03760 Vector<int, VectFull, Allocator1>& P,
03761 SeldonNorm norm, double anorm,
03762 LapackInfo& info)
03763 {
03764 char uplo('L');
03765
03766 int n = A.GetM(); double rcond(0);
03767 Vector<complex<double>, VectFull, Allocator0> work(2*n);
03768 zspcon_(&uplo, &n, A.GetData(), P.GetData(), &anorm, &rcond,
03769 work.GetData(), &info.GetInfoRef());
03770 return rcond;
03771 }
03772
03773
03774
03775
03776
03777 template<class Prop0, class Allocator0, class Allocator1>
03778 float ReciprocalConditionNumber(const Matrix<complex<float>, Prop0,
03779 ColHerm, Allocator0>& A,
03780 Vector<int, VectFull, Allocator1>& P,
03781 SeldonNorm norm, float anorm,
03782 LapackInfo& info)
03783 {
03784 char uplo('U');
03785
03786 int n = A.GetM(); float rcond(0);
03787 Vector<complex<float>, VectFull, Allocator0> work(2*n);
03788 checon_(&uplo, &n, A.GetData(), &n, P.GetData(), &anorm, &rcond,
03789 work.GetData(), &info.GetInfoRef());
03790 return rcond;
03791 }
03792
03793
03794 template<class Prop0, class Allocator0, class Allocator1>
03795 double ReciprocalConditionNumber(const Matrix<complex<double>, Prop0,
03796 ColHerm, Allocator0>& A,
03797 Vector<int, VectFull, Allocator1>& P,
03798 SeldonNorm norm, double anorm,
03799 LapackInfo& info)
03800 {
03801 char uplo('U');
03802
03803 int n = A.GetM(); double rcond(0);
03804 Vector<complex<double>, VectFull, Allocator0> work(2*n);
03805 zhecon_(&uplo, &n, A.GetData(), &n, P.GetData(), &anorm, &rcond,
03806 work.GetData(), &info.GetInfoRef());
03807 return rcond;
03808 }
03809
03810
03811
03812
03813
03814 template<class Prop0, class Allocator0, class Allocator1>
03815 float ReciprocalConditionNumber(const Matrix<complex<float>, Prop0,
03816 ColHermPacked, Allocator0>& A,
03817 Vector<int, VectFull, Allocator1>& P,
03818 SeldonNorm norm, float anorm,
03819 LapackInfo& info)
03820 {
03821 char uplo('U');
03822
03823 int n = A.GetM(); float rcond(0);
03824 Vector<complex<float>, VectFull, Allocator0> work(2*n);
03825 chpcon_(&uplo, &n, A.GetData(), P.GetData(), &anorm, &rcond,
03826 work.GetData(), &info.GetInfoRef());
03827 return rcond;
03828 }
03829
03830
03831 template<class Prop0, class Allocator0, class Allocator1>
03832 double ReciprocalConditionNumber(const Matrix<complex<double>, Prop0,
03833 ColHermPacked, Allocator0>& A,
03834 Vector<int, VectFull, Allocator1>& P,
03835 SeldonNorm norm, double anorm,
03836 LapackInfo& info)
03837 {
03838 char uplo('U');
03839
03840 int n = A.GetM(); double rcond(0);
03841 Vector<complex<double>, VectFull, Allocator0> work(2*n);
03842 zhpcon_(&uplo, &n, A.GetData(), P.GetData(), &anorm, &rcond,
03843 work.GetData(), &info.GetInfoRef());
03844 return rcond;
03845 }
03846
03847
03848
03849
03850
03851 template<class Prop0, class Allocator0, class Allocator1>
03852 float ReciprocalConditionNumber(const Matrix<complex<float>, Prop0,
03853 RowHerm, Allocator0>& A,
03854 Vector<int, VectFull, Allocator1>& P,
03855 SeldonNorm norm, float anorm,
03856 LapackInfo& info)
03857 {
03858 char uplo('L');
03859
03860 int n = A.GetM(); float rcond(0);
03861 Vector<complex<float>, VectFull, Allocator0> work(2*n);
03862 checon_(&uplo, &n, A.GetData(), &n, P.GetData(), &anorm, &rcond,
03863 work.GetData(), &info.GetInfoRef());
03864 return rcond;
03865 }
03866
03867
03868 template<class Prop0, class Allocator0, class Allocator1>
03869 double ReciprocalConditionNumber(const Matrix<complex<double>, Prop0,
03870 RowHerm, Allocator0>& A,
03871 Vector<int, VectFull, Allocator1>& P,
03872 SeldonNorm norm, double anorm,
03873 LapackInfo& info)
03874 {
03875 char uplo('L');
03876
03877 int n = A.GetM(); double rcond(0);
03878 Vector<complex<double>, VectFull, Allocator0> work(2*n);
03879 zhecon_(&uplo, &n, A.GetData(), &n, P.GetData(), &anorm, &rcond,
03880 work.GetData(), &info.GetInfoRef());
03881 return rcond;
03882 }
03883
03884
03885
03886
03887
03888 template<class Prop0, class Allocator0, class Allocator1>
03889 float ReciprocalConditionNumber(const Matrix<complex<float>, Prop0,
03890 RowHermPacked, Allocator0>& A,
03891 Vector<int, VectFull, Allocator1>& P,
03892 SeldonNorm norm, float anorm,
03893 LapackInfo& info)
03894 {
03895 char uplo('L');
03896
03897 int n = A.GetM(); float rcond(0);
03898 Vector<complex<float>, VectFull, Allocator0> work(2*n);
03899 chpcon_(&uplo, &n, A.GetData(), P.GetData(), &anorm, &rcond,
03900 work.GetData(), &info.GetInfoRef());
03901 return rcond;
03902 }
03903
03904
03905 template<class Prop0, class Allocator0, class Allocator1>
03906 double ReciprocalConditionNumber(const Matrix<complex<double>, Prop0,
03907 RowHermPacked, Allocator0>& A,
03908 Vector<int, VectFull, Allocator1>& P,
03909 SeldonNorm norm, double anorm,
03910 LapackInfo& info)
03911 {
03912 char uplo('L');
03913
03914 int n = A.GetM(); double rcond(0);
03915 Vector<complex<double>, VectFull, Allocator0> work(2*n);
03916 zhpcon_(&uplo, &n, A.GetData(), P.GetData(), &anorm, &rcond,
03917 work.GetData(), &info.GetInfoRef());
03918 return rcond;
03919 }
03920
03921
03922
03923
03924
03925 template<class Prop0, class Allocator0>
03926 float ReciprocalConditionNumber(const Matrix<float, Prop0, ColUpTriang,
03927 Allocator0>& A, SeldonNorm norm,
03928 LapackInfo& info)
03929 {
03930 char uplo('U'); char norm_type = norm.Char(); char diag('N');
03931
03932 int n = A.GetM(); float rcond(0);
03933 Vector<int> iwork(n); Vector<float, VectFull, Allocator0> work(3*n);
03934 strcon_(&norm_type, &uplo, &diag, &n, A.GetData(), &n, &rcond,
03935 work.GetData(), iwork.GetData(), &info.GetInfoRef());
03936 return rcond;
03937 }
03938
03939
03940 template<class Prop0, class Allocator0>
03941 double ReciprocalConditionNumber(const Matrix<double, Prop0, ColUpTriang,
03942 Allocator0>& A, SeldonNorm norm,
03943 LapackInfo& info)
03944 {
03945 char uplo('U'); char norm_type = norm.Char(); char diag('N');
03946
03947 int n = A.GetM(); double rcond(0);
03948 Vector<int> iwork(n); Vector<double, VectFull, Allocator0> work(3*n);
03949 dtrcon_(&norm_type, &uplo, &diag, &n, A.GetData(), &n, &rcond,
03950 work.GetData(), iwork.GetData(), &info.GetInfoRef());
03951 return rcond;
03952 }
03953
03954
03955 template<class Prop0, class Allocator0>
03956 float ReciprocalConditionNumber(const Matrix<complex<float>, Prop0,
03957 ColUpTriang, Allocator0>& A,
03958 SeldonNorm norm,
03959 LapackInfo& info)
03960 {
03961 char uplo('U'); char norm_type = norm.Char(); char diag('N');
03962
03963 int n = A.GetM(); float rcond(0);
03964 Vector<float> rwork(n);
03965 Vector<complex<float>, VectFull, Allocator0> work(2*n);
03966 ctrcon_(&norm_type, &uplo, &diag, &n, A.GetDataVoid(), &n, &rcond,
03967 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
03968 return rcond;
03969 }
03970
03971
03972 template<class Prop0, class Allocator0>
03973 double ReciprocalConditionNumber(const Matrix<complex<double>, Prop0,
03974 ColUpTriang, Allocator0>& A,
03975 SeldonNorm norm,
03976 LapackInfo& info)
03977 {
03978 char uplo('U'); char norm_type = norm.Char(); char diag('N');
03979
03980 int n = A.GetM(); double rcond(0);
03981 Vector<double> rwork(n);
03982 Vector<complex<double>, VectFull, Allocator0> work(2*n);
03983 ztrcon_(&norm_type, &uplo, &diag, &n, A.GetDataVoid(), &n, &rcond,
03984 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
03985 return rcond;
03986 }
03987
03988
03989
03990
03991
03992 template<class Prop0, class Allocator0>
03993 float ReciprocalConditionNumber(const SeldonDiag& DiagA,
03994 const Matrix<float, Prop0, ColUpTriang,
03995 Allocator0>& A, SeldonNorm norm,
03996 LapackInfo& info)
03997 {
03998 char uplo('U'); char norm_type = norm.Char();
03999 char diag = DiagA.Char();
04000 int n = A.GetM(); float rcond(0);
04001 Vector<int> iwork(n); Vector<float, VectFull, Allocator0> work(3*n);
04002 strcon_(&norm_type, &uplo, &diag, &n, A.GetData(), &n, &rcond,
04003 work.GetData(), iwork.GetData(), &info.GetInfoRef());
04004 return rcond;
04005 }
04006
04007
04008 template<class Prop0, class Allocator0>
04009 double ReciprocalConditionNumber(const SeldonDiag& DiagA,
04010 const Matrix<double, Prop0, ColUpTriang,
04011 Allocator0>& A, SeldonNorm norm,
04012 LapackInfo& info)
04013 {
04014 char uplo('U'); char norm_type = norm.Char();
04015
04016 int n = A.GetM(); double rcond(0);
04017 char diag = DiagA.Char();
04018 Vector<int> iwork(n); Vector<double, VectFull, Allocator0> work(3*n);
04019 dtrcon_(&norm_type, &uplo, &diag, &n, A.GetData(), &n, &rcond,
04020 work.GetData(), iwork.GetData(), &info.GetInfoRef());
04021 return rcond;
04022 }
04023
04024
04025 template<class Prop0, class Allocator0>
04026 float ReciprocalConditionNumber(const SeldonDiag& DiagA,
04027 const Matrix<complex<float>, Prop0,
04028 ColUpTriang, Allocator0>& A,
04029 SeldonNorm norm,
04030 LapackInfo& info)
04031 {
04032 char uplo('U'); char norm_type = norm.Char();
04033 char diag = DiagA.Char();
04034 int n = A.GetM(); float rcond(0);
04035 Vector<float> rwork(n);
04036 Vector<complex<float>, VectFull, Allocator0> work(2*n);
04037 ctrcon_(&norm_type, &uplo, &diag, &n, A.GetDataVoid(), &n, &rcond,
04038 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
04039 return rcond;
04040 }
04041
04042
04043 template<class Prop0, class Allocator0>
04044 double ReciprocalConditionNumber(const SeldonDiag& DiagA,
04045 const Matrix<complex<double>, Prop0,
04046 ColUpTriang, Allocator0>& A,
04047 SeldonNorm norm,
04048 LapackInfo& info)
04049 {
04050 char uplo('U'); char norm_type = norm.Char();
04051 char diag = DiagA.Char();
04052 int n = A.GetM(); double rcond(0);
04053 Vector<double> rwork(n);
04054 Vector<complex<double>, VectFull, Allocator0> work(2*n);
04055 ztrcon_(&norm_type, &uplo, &diag, &n, A.GetDataVoid(), &n, &rcond,
04056 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
04057 return rcond;
04058 }
04059
04060
04061
04062
04063
04064 template<class Prop0, class Allocator0>
04065 float ReciprocalConditionNumber(const Matrix<float, Prop0,
04066 ColLoTriang, Allocator0>& A,
04067 SeldonNorm norm,
04068 LapackInfo& info)
04069 {
04070 char uplo('L'); char norm_type = norm.Char(); char diag('N');
04071
04072 int n = A.GetM(); float rcond(0);
04073 Vector<int> iwork(n); Vector<float, VectFull, Allocator0> work(3*n);
04074 strcon_(&norm_type, &uplo, &diag, &n, A.GetData(), &n, &rcond,
04075 work.GetData(), iwork.GetData(), &info.GetInfoRef());
04076 return rcond;
04077 }
04078
04079
04080 template<class Prop0, class Allocator0>
04081 double ReciprocalConditionNumber(const Matrix<double, Prop0, ColLoTriang,
04082 Allocator0>& A, SeldonNorm norm,
04083 LapackInfo& info)
04084 {
04085 char uplo('L'); char norm_type = norm.Char(); char diag('N');
04086
04087 int n = A.GetM(); double rcond(0);
04088 Vector<int> iwork(n); Vector<double, VectFull, Allocator0> work(3*n);
04089 dtrcon_(&norm_type, &uplo, &diag, &n, A.GetData(), &n, &rcond,
04090 work.GetData(), iwork.GetData(), &info.GetInfoRef());
04091 return rcond;
04092 }
04093
04094
04095 template<class Prop0, class Allocator0>
04096 float ReciprocalConditionNumber(const Matrix<complex<float>, Prop0,
04097 ColLoTriang, Allocator0>& A,
04098 SeldonNorm norm,
04099 LapackInfo& info)
04100 {
04101 char uplo('L'); char norm_type = norm.Char(); char diag('N');
04102
04103 int n = A.GetM(); float rcond(0);
04104 Vector<float> rwork(n);
04105 Vector<complex<float>, VectFull, Allocator0> work(2*n);
04106 ctrcon_(&norm_type, &uplo, &diag, &n, A.GetDataVoid(), &n, &rcond,
04107 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
04108 return rcond;
04109 }
04110
04111
04112 template<class Prop0, class Allocator0>
04113 double ReciprocalConditionNumber(const Matrix<complex<double>, Prop0,
04114 ColLoTriang, Allocator0>& A,
04115 SeldonNorm norm,
04116 LapackInfo& info)
04117 {
04118 char uplo('L'); char norm_type = norm.Char(); char diag('N');
04119
04120 int n = A.GetM(); double rcond(0);
04121 Vector<double> rwork(n);
04122 Vector<complex<double>, VectFull, Allocator0> work(2*n);
04123 ztrcon_(&norm_type, &uplo, &diag, &n, A.GetDataVoid(), &n, &rcond,
04124 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
04125 return rcond;
04126 }
04127
04128
04129
04130
04131
04132 template<class Prop0, class Allocator0>
04133 float ReciprocalConditionNumber(const SeldonDiag& DiagA,
04134 const Matrix<float, Prop0,
04135 ColLoTriang, Allocator0>& A,
04136 SeldonNorm norm,
04137 LapackInfo& info)
04138 {
04139 char uplo('L'); char norm_type = norm.Char();
04140 char diag = DiagA.Char();
04141 int n = A.GetM(); float rcond(0);
04142 Vector<int> iwork(n); Vector<float, VectFull, Allocator0> work(3*n);
04143 strcon_(&norm_type, &uplo, &diag, &n, A.GetData(), &n, &rcond,
04144 work.GetData(), iwork.GetData(), &info.GetInfoRef());
04145 return rcond;
04146 }
04147
04148
04149 template<class Prop0, class Allocator0>
04150 double ReciprocalConditionNumber(const SeldonDiag& DiagA,
04151 const Matrix<double, Prop0, ColLoTriang,
04152 Allocator0>& A, SeldonNorm norm,
04153 LapackInfo& info)
04154 {
04155 char uplo('L'); char norm_type = norm.Char();
04156 char diag = DiagA.Char();
04157 int n = A.GetM(); double rcond(0);
04158 Vector<int> iwork(n); Vector<double, VectFull, Allocator0> work(3*n);
04159 dtrcon_(&norm_type, &uplo, &diag, &n, A.GetData(), &n, &rcond,
04160 work.GetData(), iwork.GetData(), &info.GetInfoRef());
04161 return rcond;
04162 }
04163
04164
04165 template<class Prop0, class Allocator0>
04166 float ReciprocalConditionNumber(const SeldonDiag& DiagA,
04167 const Matrix<complex<float>, Prop0,
04168 ColLoTriang, Allocator0>& A,
04169 SeldonNorm norm,
04170 LapackInfo& info)
04171 {
04172 char uplo('L'); char norm_type = norm.Char();
04173 char diag = DiagA.Char();
04174 int n = A.GetM(); float rcond(0);
04175 Vector<float> rwork(n);
04176 Vector<complex<float>, VectFull, Allocator0> work(2*n);
04177 ctrcon_(&norm_type, &uplo, &diag, &n, A.GetDataVoid(), &n, &rcond,
04178 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
04179 return rcond;
04180 }
04181
04182
04183 template<class Prop0, class Allocator0>
04184 double ReciprocalConditionNumber(const SeldonDiag& DiagA,
04185 const Matrix<complex<double>, Prop0,
04186 ColLoTriang, Allocator0>& A,
04187 SeldonNorm norm,
04188 LapackInfo& info)
04189 {
04190 char uplo('L'); char norm_type = norm.Char();
04191 char diag = DiagA.Char();
04192 int n = A.GetM(); double rcond(0);
04193 Vector<double> rwork(n);
04194 Vector<complex<double>, VectFull, Allocator0> work(2*n);
04195 ztrcon_(&norm_type, &uplo, &diag, &n, A.GetDataVoid(), &n, &rcond,
04196 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
04197 return rcond;
04198 }
04199
04200
04201
04202
04203
04204 template<class Prop0, class Allocator0>
04205 float ReciprocalConditionNumber(const Matrix<float, Prop0,
04206 ColUpTriangPacked, Allocator0>& A,
04207 SeldonNorm norm,
04208 LapackInfo& info)
04209 {
04210 char uplo('U'); char norm_type = norm.Char(); char diag('N');
04211
04212 int n = A.GetM(); float rcond(0);
04213 Vector<int> iwork(n); Vector<float, VectFull, Allocator0> work(3*n);
04214 stpcon_(&norm_type, &uplo, &diag, &n, A.GetData(), &rcond,
04215 work.GetData(), iwork.GetData(), &info.GetInfoRef());
04216 return rcond;
04217 }
04218
04219
04220 template<class Prop0, class Allocator0>
04221 double ReciprocalConditionNumber(const Matrix<double, Prop0,
04222 ColUpTriangPacked, Allocator0>& A,
04223 SeldonNorm norm,
04224 LapackInfo& info)
04225 {
04226 char uplo('U'); char norm_type = norm.Char(); char diag('N');
04227
04228 int n = A.GetM(); double rcond(0);
04229 Vector<int> iwork(n); Vector<double, VectFull, Allocator0> work(3*n);
04230 dtpcon_(&norm_type, &uplo, &diag, &n, A.GetData(), &rcond,
04231 work.GetData(), iwork.GetData(), &info.GetInfoRef());
04232 return rcond;
04233 }
04234
04235
04236 template<class Prop0, class Allocator0>
04237 float ReciprocalConditionNumber(const Matrix<complex<float>, Prop0,
04238 ColUpTriangPacked, Allocator0>& A,
04239 SeldonNorm norm,
04240 LapackInfo& info)
04241 {
04242 char uplo('U'); char norm_type = norm.Char(); char diag('N');
04243
04244 int n = A.GetM(); float rcond(0);
04245 Vector<float> rwork(n);
04246 Vector<complex<float>, VectFull, Allocator0> work(2*n);
04247 ctpcon_(&norm_type, &uplo, &diag, &n, A.GetDataVoid(), &rcond,
04248 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
04249 return rcond;
04250 }
04251
04252
04253 template<class Prop0, class Allocator0>
04254 double ReciprocalConditionNumber(const Matrix<complex<double>, Prop0,
04255 ColUpTriangPacked, Allocator0>& A,
04256 SeldonNorm norm,
04257 LapackInfo& info)
04258 {
04259 char uplo('U'); char norm_type = norm.Char(); char diag('N');
04260
04261 int n = A.GetM(); double rcond(0);
04262 Vector<double> rwork(n);
04263 Vector<complex<double>, VectFull, Allocator0> work(2*n);
04264 ztpcon_(&norm_type, &uplo, &diag, &n, A.GetDataVoid(), &rcond,
04265 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
04266 return rcond;
04267 }
04268
04269
04270
04271
04272
04273 template<class Prop0, class Allocator0>
04274 float ReciprocalConditionNumber(const SeldonDiag& DiagA,
04275 const Matrix<float, Prop0,
04276 ColUpTriangPacked, Allocator0>& A,
04277 SeldonNorm norm,
04278 LapackInfo& info)
04279 {
04280 char uplo('U'); char norm_type = norm.Char();
04281 char diag = DiagA.Char();
04282 int n = A.GetM(); float rcond(0);
04283 Vector<int> iwork(n); Vector<float, VectFull, Allocator0> work(3*n);
04284 stpcon_(&norm_type, &uplo, &diag, &n, A.GetData(), &rcond,
04285 work.GetData(), iwork.GetData(), &info.GetInfoRef());
04286 return rcond;
04287 }
04288
04289
04290 template<class Prop0, class Allocator0>
04291 double ReciprocalConditionNumber(const SeldonDiag& DiagA,
04292 const Matrix<double, Prop0,
04293 ColUpTriangPacked, Allocator0>& A,
04294 SeldonNorm norm,
04295 LapackInfo& info)
04296 {
04297 char uplo('U'); char norm_type = norm.Char();
04298 char diag = DiagA.Char();
04299 int n = A.GetM(); double rcond(0);
04300 Vector<int> iwork(n); Vector<double, VectFull, Allocator0> work(3*n);
04301 dtpcon_(&norm_type, &uplo, &diag, &n, A.GetData(), &rcond,
04302 work.GetData(), iwork.GetData(), &info.GetInfoRef());
04303 return rcond;
04304 }
04305
04306
04307 template<class Prop0, class Allocator0>
04308 float ReciprocalConditionNumber(const SeldonDiag& DiagA,
04309 const Matrix<complex<float>, Prop0,
04310 ColUpTriangPacked, Allocator0>& A,
04311 SeldonNorm norm,
04312 LapackInfo& info)
04313 {
04314 char uplo('U'); char norm_type = norm.Char();
04315 char diag = DiagA.Char();
04316 int n = A.GetM(); float rcond(0);
04317 Vector<float> rwork(n);
04318 Vector<complex<float>, VectFull, Allocator0> work(2*n);
04319 ctpcon_(&norm_type, &uplo, &diag, &n, A.GetDataVoid(), &rcond,
04320 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
04321 return rcond;
04322 }
04323
04324
04325 template<class Prop0, class Allocator0>
04326 double ReciprocalConditionNumber(const SeldonDiag& DiagA,
04327 const Matrix<complex<double>, Prop0,
04328 ColUpTriangPacked, Allocator0>& A,
04329 SeldonNorm norm,
04330 LapackInfo& info)
04331 {
04332 char uplo('U'); char norm_type = norm.Char();
04333 char diag = DiagA.Char();
04334 int n = A.GetM(); double rcond(0);
04335 Vector<double> rwork(n);
04336 Vector<complex<double>, VectFull, Allocator0> work(2*n);
04337 ztpcon_(&norm_type, &uplo, &diag, &n, A.GetDataVoid(), &rcond,
04338 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
04339 return rcond;
04340 }
04341
04342
04343
04344
04345
04346 template<class Prop0, class Allocator0>
04347 float ReciprocalConditionNumber(const Matrix<float, Prop0,
04348 ColLoTriangPacked, Allocator0>& A,
04349 SeldonNorm norm,
04350 LapackInfo& info)
04351 {
04352 char uplo('L'); char norm_type = norm.Char(); char diag('N');
04353
04354 int n = A.GetM(); float rcond(0);
04355 Vector<int> iwork(n); Vector<float, VectFull, Allocator0> work(3*n);
04356 stpcon_(&norm_type, &uplo, &diag, &n, A.GetData(), &rcond,
04357 work.GetData(), iwork.GetData(), &info.GetInfoRef());
04358 return rcond;
04359 }
04360
04361
04362 template<class Prop0, class Allocator0>
04363 double ReciprocalConditionNumber(const Matrix<double, Prop0,
04364 ColLoTriangPacked, Allocator0>& A,
04365 SeldonNorm norm,
04366 LapackInfo& info)
04367 {
04368 char uplo('L'); char norm_type = norm.Char(); char diag('N');
04369
04370 int n = A.GetM(); double rcond(0);
04371 Vector<int> iwork(n); Vector<double, VectFull, Allocator0> work(3*n);
04372 dtpcon_(&norm_type, &uplo, &diag, &n, A.GetData(), &rcond,
04373 work.GetData(), iwork.GetData(), &info.GetInfoRef());
04374 return rcond;
04375 }
04376
04377
04378 template<class Prop0, class Allocator0>
04379 float ReciprocalConditionNumber(const Matrix<complex<float>, Prop0,
04380 ColLoTriangPacked, Allocator0>& A,
04381 SeldonNorm norm,
04382 LapackInfo& info)
04383 {
04384 char uplo('L'); char norm_type = norm.Char(); char diag('N');
04385
04386 int n = A.GetM(); float rcond(0);
04387 Vector<float> rwork(n);
04388 Vector<complex<float>, VectFull, Allocator0> work(2*n);
04389 ctpcon_(&norm_type, &uplo, &diag, &n, A.GetDataVoid(), &rcond,
04390 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
04391 return rcond;
04392 }
04393
04394
04395 template<class Prop0, class Allocator0>
04396 double ReciprocalConditionNumber(const Matrix<complex<double>, Prop0,
04397 ColLoTriangPacked, Allocator0>& A,
04398 SeldonNorm norm,
04399 LapackInfo& info)
04400 {
04401 char uplo('L'); char norm_type = norm.Char(); char diag('N');
04402
04403 int n = A.GetM(); double rcond(0);
04404 Vector<double> rwork(n);
04405 Vector<complex<double>, VectFull, Allocator0> work(2*n);
04406 ztpcon_(&norm_type, &uplo, &diag, &n, A.GetDataVoid(), &rcond,
04407 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
04408 return rcond;
04409 }
04410
04411
04412
04413
04414
04415 template<class Prop0, class Allocator0>
04416 float ReciprocalConditionNumber(const SeldonDiag& DiagA,
04417 const Matrix<float, Prop0,
04418 ColLoTriangPacked, Allocator0>& A,
04419 SeldonNorm norm,
04420 LapackInfo& info)
04421 {
04422 char uplo('L'); char norm_type = norm.Char();
04423 char diag = DiagA.Char();
04424 int n = A.GetM(); float rcond(0);
04425 Vector<int> iwork(n); Vector<float, VectFull, Allocator0> work(3*n);
04426 stpcon_(&norm_type, &uplo, &diag, &n, A.GetData(), &rcond,
04427 work.GetData(), iwork.GetData(), &info.GetInfoRef());
04428 return rcond;
04429 }
04430
04431
04432 template<class Prop0, class Allocator0>
04433 double ReciprocalConditionNumber(const SeldonDiag& DiagA,
04434 const Matrix<double, Prop0,
04435 ColLoTriangPacked, Allocator0>& A,
04436 SeldonNorm norm,
04437 LapackInfo& info)
04438 {
04439 char uplo('L'); char norm_type = norm.Char();
04440 char diag = DiagA.Char();
04441 int n = A.GetM(); double rcond(0);
04442 Vector<int> iwork(n); Vector<double, VectFull, Allocator0> work(3*n);
04443 dtpcon_(&norm_type, &uplo, &diag, &n, A.GetData(), &rcond,
04444 work.GetData(), iwork.GetData(), &info.GetInfoRef());
04445 return rcond;
04446 }
04447
04448
04449 template<class Prop0, class Allocator0>
04450 float ReciprocalConditionNumber(const SeldonDiag& DiagA,
04451 const Matrix<complex<float>, Prop0,
04452 ColLoTriangPacked, Allocator0>& A,
04453 SeldonNorm norm,
04454 LapackInfo& info)
04455 {
04456 char uplo('L'); char norm_type = norm.Char();
04457 char diag = DiagA.Char();
04458 int n = A.GetM(); float rcond(0);
04459 Vector<float> rwork(n);
04460 Vector<complex<float>, VectFull, Allocator0> work(2*n);
04461 ctpcon_(&norm_type, &uplo, &diag, &n, A.GetDataVoid(), &rcond,
04462 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
04463 return rcond;
04464 }
04465
04466
04467 template<class Prop0, class Allocator0>
04468 double ReciprocalConditionNumber(const SeldonDiag& DiagA,
04469 const Matrix<complex<double>, Prop0,
04470 ColLoTriangPacked, Allocator0>& A,
04471 SeldonNorm norm,
04472 LapackInfo& info)
04473 {
04474 char uplo('L'); char norm_type = norm.Char();
04475 char diag = DiagA.Char();
04476 int n = A.GetM(); double rcond(0);
04477 Vector<double> rwork(n);
04478 Vector<complex<double>, VectFull, Allocator0> work(2*n);
04479 ztpcon_(&norm_type, &uplo, &diag, &n, A.GetDataVoid(), &rcond,
04480 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
04481 return rcond;
04482 }
04483
04484
04485
04486
04487
04488 template<class Prop0, class Allocator0>
04489 float ReciprocalConditionNumber(const Matrix<float, Prop0, RowUpTriang,
04490 Allocator0>& A, SeldonNorm norm,
04491 LapackInfo& info)
04492 {
04493 char uplo('L'); char norm_type = norm.RevChar(); char diag('N');
04494
04495 int n = A.GetM(); float rcond(0);
04496 Vector<int> iwork(n); Vector<float, VectFull, Allocator0> work(3*n);
04497 strcon_(&norm_type, &uplo, &diag, &n, A.GetData(), &n, &rcond,
04498 work.GetData(), iwork.GetData(), &info.GetInfoRef());
04499 return rcond;
04500 }
04501
04502
04503 template<class Prop0, class Allocator0>
04504 double ReciprocalConditionNumber(const Matrix<double, Prop0, RowUpTriang,
04505 Allocator0>& A, SeldonNorm norm,
04506 LapackInfo& info)
04507 {
04508 char uplo('L'); char norm_type = norm.RevChar(); char diag('N');
04509
04510 int n = A.GetM(); double rcond(0);
04511 Vector<int> iwork(n); Vector<double, VectFull, Allocator0> work(3*n);
04512 dtrcon_(&norm_type, &uplo, &diag, &n, A.GetData(), &n, &rcond,
04513 work.GetData(), iwork.GetData(), &info.GetInfoRef());
04514 return rcond;
04515 }
04516
04517
04518 template<class Prop0, class Allocator0>
04519 float ReciprocalConditionNumber(const Matrix<complex<float>, Prop0,
04520 RowUpTriang, Allocator0>& A,
04521 SeldonNorm norm,
04522 LapackInfo& info)
04523 {
04524 char uplo('L'); char norm_type = norm.RevChar(); char diag('N');
04525
04526 int n = A.GetM(); float rcond(0);
04527 Vector<float> rwork(n);
04528 Vector<complex<float>, VectFull, Allocator0> work(2*n);
04529 ctrcon_(&norm_type, &uplo, &diag, &n, A.GetDataVoid(), &n, &rcond,
04530 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
04531 return rcond;
04532 }
04533
04534
04535 template<class Prop0, class Allocator0>
04536 double ReciprocalConditionNumber(const Matrix<complex<double>, Prop0,
04537 RowUpTriang, Allocator0>& A,
04538 SeldonNorm norm,
04539 LapackInfo& info)
04540 {
04541 char uplo('L'); char norm_type = norm.RevChar(); char diag('N');
04542
04543 int n = A.GetM(); double rcond(0);
04544 Vector<double> rwork(n);
04545 Vector<complex<double>, VectFull, Allocator0> work(2*n);
04546 ztrcon_(&norm_type, &uplo, &diag, &n, A.GetDataVoid(), &n, &rcond,
04547 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
04548 return rcond;
04549 }
04550
04551
04552
04553
04554
04555 template<class Prop0, class Allocator0>
04556 float ReciprocalConditionNumber(const SeldonDiag& DiagA,
04557 const Matrix<float, Prop0, RowUpTriang,
04558 Allocator0>& A, SeldonNorm norm,
04559 LapackInfo& info)
04560 {
04561 char uplo('L'); char norm_type = norm.RevChar();
04562 char diag = DiagA.Char();
04563 int n = A.GetM(); float rcond(0);
04564 Vector<int> iwork(n); Vector<float, VectFull, Allocator0> work(3*n);
04565 strcon_(&norm_type, &uplo, &diag, &n, A.GetData(), &n, &rcond,
04566 work.GetData(), iwork.GetData(), &info.GetInfoRef());
04567 return rcond;
04568 }
04569
04570
04571 template<class Prop0, class Allocator0>
04572 double ReciprocalConditionNumber(const SeldonDiag& DiagA,
04573 const Matrix<double, Prop0, RowUpTriang,
04574 Allocator0>& A, SeldonNorm norm,
04575 LapackInfo& info)
04576 {
04577 char uplo('L'); char norm_type = norm.RevChar();
04578 char diag = DiagA.Char();
04579 int n = A.GetM(); double rcond(0);
04580 Vector<int> iwork(n); Vector<double, VectFull, Allocator0> work(3*n);
04581 dtrcon_(&norm_type, &uplo, &diag, &n, A.GetData(), &n, &rcond,
04582 work.GetData(), iwork.GetData(), &info.GetInfoRef());
04583 return rcond;
04584 }
04585
04586
04587 template<class Prop0, class Allocator0>
04588 float ReciprocalConditionNumber(const SeldonDiag& DiagA,
04589 const Matrix<complex<float>, Prop0,
04590 RowUpTriang, Allocator0>& A,
04591 SeldonNorm norm,
04592 LapackInfo& info)
04593 {
04594 char uplo('L'); char norm_type = norm.RevChar();
04595 char diag = DiagA.Char();
04596 int n = A.GetM(); float rcond(0);
04597 Vector<float> rwork(n);
04598 Vector<complex<float>, VectFull, Allocator0> work(2*n);
04599 ctrcon_(&norm_type, &uplo, &diag, &n, A.GetDataVoid(), &n, &rcond,
04600 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
04601 return rcond;
04602 }
04603
04604
04605 template<class Prop0, class Allocator0>
04606 double ReciprocalConditionNumber(const SeldonDiag& DiagA,
04607 const Matrix<complex<double>, Prop0,
04608 RowUpTriang, Allocator0>& A,
04609 SeldonNorm norm,
04610 LapackInfo& info)
04611 {
04612 char uplo('L'); char norm_type = norm.RevChar();
04613 char diag = DiagA.Char();
04614 int n = A.GetM(); double rcond(0);
04615 Vector<double> rwork(n);
04616 Vector<complex<double>, VectFull, Allocator0> work(2*n);
04617 ztrcon_(&norm_type, &uplo, &diag, &n, A.GetDataVoid(), &n, &rcond,
04618 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
04619 return rcond;
04620 }
04621
04622
04623
04624
04625
04626 template<class Prop0, class Allocator0>
04627 float ReciprocalConditionNumber(const Matrix<float, Prop0,
04628 RowLoTriang, Allocator0>& A,
04629 SeldonNorm norm,
04630 LapackInfo& info)
04631 {
04632 char uplo('U'); char norm_type = norm.RevChar(); char diag('N');
04633
04634 int n = A.GetM(); float rcond(0);
04635 Vector<int> iwork(n); Vector<float, VectFull, Allocator0> work(3*n);
04636 strcon_(&norm_type, &uplo, &diag, &n, A.GetData(), &n, &rcond,
04637 work.GetData(), iwork.GetData(), &info.GetInfoRef());
04638 return rcond;
04639 }
04640
04641
04642 template<class Prop0, class Allocator0>
04643 double ReciprocalConditionNumber(const Matrix<double, Prop0,
04644 RowLoTriang, Allocator0>& A,
04645 SeldonNorm norm,
04646 LapackInfo& info)
04647 {
04648 char uplo('U'); char norm_type = norm.RevChar(); char diag('N');
04649
04650 int n = A.GetM(); double rcond(0);
04651 Vector<int> iwork(n); Vector<double, VectFull, Allocator0> work(3*n);
04652 dtrcon_(&norm_type, &uplo, &diag, &n, A.GetData(), &n, &rcond,
04653 work.GetData(), iwork.GetData(), &info.GetInfoRef());
04654 return rcond;
04655 }
04656
04657
04658 template<class Prop0, class Allocator0>
04659 float ReciprocalConditionNumber(const Matrix<complex<float>, Prop0,
04660 RowLoTriang, Allocator0>& A,
04661 SeldonNorm norm,
04662 LapackInfo& info)
04663 {
04664 char uplo('U'); char norm_type = norm.RevChar(); char diag('N');
04665
04666 int n = A.GetM(); float rcond(0);
04667 Vector<float> rwork(n);
04668 Vector<complex<float>, VectFull, Allocator0> work(2*n);
04669 ctrcon_(&norm_type, &uplo, &diag, &n, A.GetDataVoid(), &n, &rcond,
04670 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
04671 return rcond;
04672 }
04673
04674
04675 template<class Prop0, class Allocator0>
04676 double ReciprocalConditionNumber(const Matrix<complex<double>, Prop0,
04677 RowLoTriang, Allocator0>& A,
04678 SeldonNorm norm,
04679 LapackInfo& info)
04680 {
04681 char uplo('U'); char norm_type = norm.RevChar(); char diag('N');
04682
04683 int n = A.GetM(); double rcond(0);
04684 Vector<double> rwork(n);
04685 Vector<complex<double>, VectFull, Allocator0> work(2*n);
04686 ztrcon_(&norm_type, &uplo, &diag, &n, A.GetDataVoid(), &n, &rcond,
04687 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
04688 return rcond;
04689 }
04690
04691
04692
04693
04694
04695 template<class Prop0, class Allocator0>
04696 float ReciprocalConditionNumber(const SeldonDiag& DiagA,
04697 const Matrix<float, Prop0,
04698 RowLoTriang, Allocator0>& A,
04699 SeldonNorm norm,
04700 LapackInfo& info)
04701 {
04702 char uplo('U'); char norm_type = norm.RevChar();
04703 char diag = DiagA.Char();
04704 int n = A.GetM(); float rcond(0);
04705 Vector<int> iwork(n); Vector<float, VectFull, Allocator0> work(3*n);
04706 strcon_(&norm_type, &uplo, &diag, &n, A.GetData(), &n, &rcond,
04707 work.GetData(), iwork.GetData(), &info.GetInfoRef());
04708 return rcond;
04709 }
04710
04711
04712 template<class Prop0, class Allocator0>
04713 double ReciprocalConditionNumber(const SeldonDiag& DiagA,
04714 const Matrix<double, Prop0,
04715 RowLoTriang, Allocator0>& A,
04716 SeldonNorm norm,
04717 LapackInfo& info)
04718 {
04719 char uplo('U'); char norm_type = norm.RevChar();
04720 char diag = DiagA.Char();
04721 int n = A.GetM(); double rcond(0);
04722 Vector<int> iwork(n); Vector<double, VectFull, Allocator0> work(3*n);
04723 dtrcon_(&norm_type, &uplo, &diag, &n, A.GetData(), &n, &rcond,
04724 work.GetData(), iwork.GetData(), &info.GetInfoRef());
04725 return rcond;
04726 }
04727
04728
04729 template<class Prop0, class Allocator0>
04730 float ReciprocalConditionNumber(const SeldonDiag& DiagA,
04731 const Matrix<complex<float>, Prop0,
04732 RowLoTriang, Allocator0>& A,
04733 SeldonNorm norm,
04734 LapackInfo& info)
04735 {
04736 char uplo('U'); char norm_type = norm.RevChar();
04737 char diag = DiagA.Char();
04738 int n = A.GetM(); float rcond(0);
04739 Vector<float> rwork(n);
04740 Vector<complex<float>, VectFull, Allocator0> work(2*n);
04741 ctrcon_(&norm_type, &uplo, &diag, &n, A.GetDataVoid(), &n, &rcond,
04742 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
04743 return rcond;
04744 }
04745
04746
04747 template<class Prop0, class Allocator0>
04748 double ReciprocalConditionNumber(const SeldonDiag& DiagA,
04749 const Matrix<complex<double>, Prop0,
04750 RowLoTriang, Allocator0>& A,
04751 SeldonNorm norm,
04752 LapackInfo& info)
04753 {
04754 char uplo('U'); char norm_type = norm.RevChar();
04755 char diag = DiagA.Char();
04756 int n = A.GetM(); double rcond(0);
04757 Vector<double> rwork(n);
04758 Vector<complex<double>, VectFull, Allocator0> work(2*n);
04759 ztrcon_(&norm_type, &uplo, &diag, &n, A.GetDataVoid(), &n, &rcond,
04760 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
04761 return rcond;
04762 }
04763
04764
04765
04766
04767
04768 template<class Prop0, class Allocator0>
04769 float ReciprocalConditionNumber(const Matrix<float, Prop0,
04770 RowUpTriangPacked, Allocator0>& A,
04771 SeldonNorm norm,
04772 LapackInfo& info)
04773 {
04774 char uplo('L'); char norm_type = norm.RevChar(); char diag('N');
04775
04776 int n = A.GetM(); float rcond(0);
04777 Vector<int> iwork(n); Vector<float, VectFull, Allocator0> work(3*n);
04778 stpcon_(&norm_type, &uplo, &diag, &n, A.GetData(), &rcond,
04779 work.GetData(), iwork.GetData(), &info.GetInfoRef());
04780 return rcond;
04781 }
04782
04783
04784 template<class Prop0, class Allocator0>
04785 double ReciprocalConditionNumber(const Matrix<double, Prop0,
04786 RowUpTriangPacked, Allocator0>& A,
04787 SeldonNorm norm,
04788 LapackInfo& info)
04789 {
04790 char uplo('L'); char norm_type = norm.RevChar(); char diag('N');
04791
04792 int n = A.GetM(); double rcond(0);
04793 Vector<int> iwork(n); Vector<double, VectFull, Allocator0> work(3*n);
04794 dtpcon_(&norm_type, &uplo, &diag, &n, A.GetData(), &rcond,
04795 work.GetData(), iwork.GetData(), &info.GetInfoRef());
04796 return rcond;
04797 }
04798
04799
04800 template<class Prop0, class Allocator0>
04801 float ReciprocalConditionNumber(const Matrix<complex<float>, Prop0,
04802 RowUpTriangPacked, Allocator0>& A,
04803 SeldonNorm norm,
04804 LapackInfo& info)
04805 {
04806 char uplo('L'); char norm_type = norm.RevChar(); char diag('N');
04807
04808 int n = A.GetM(); float rcond(0);
04809 Vector<float> rwork(n);
04810 Vector<complex<float>, VectFull, Allocator0> work(2*n);
04811 ctpcon_(&norm_type, &uplo, &diag, &n, A.GetDataVoid(), &rcond,
04812 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
04813 return rcond;
04814 }
04815
04816
04817 template<class Prop0, class Allocator0>
04818 double ReciprocalConditionNumber(const Matrix<complex<double>, Prop0,
04819 RowUpTriangPacked, Allocator0>& A,
04820 SeldonNorm norm,
04821 LapackInfo& info)
04822 {
04823 char uplo('L'); char norm_type = norm.RevChar(); char diag('N');
04824
04825 int n = A.GetM(); double rcond(0);
04826 Vector<double> rwork(n);
04827 Vector<complex<double>, VectFull, Allocator0> work(2*n);
04828 ztpcon_(&norm_type, &uplo, &diag, &n, A.GetDataVoid(), &rcond,
04829 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
04830 return rcond;
04831 }
04832
04833
04834
04835
04836
04837 template<class Prop0, class Allocator0>
04838 float ReciprocalConditionNumber(const SeldonDiag& DiagA,
04839 const Matrix<float, Prop0,
04840 RowUpTriangPacked, Allocator0>& A,
04841 SeldonNorm norm,
04842 LapackInfo& info)
04843 {
04844 char uplo('L'); char norm_type = norm.RevChar();
04845 char diag = DiagA.Char();
04846 int n = A.GetM(); float rcond(0);
04847 Vector<int> iwork(n); Vector<float, VectFull, Allocator0> work(3*n);
04848 stpcon_(&norm_type, &uplo, &diag, &n, A.GetData(), &rcond,
04849 work.GetData(), iwork.GetData(), &info.GetInfoRef());
04850 return rcond;
04851 }
04852
04853
04854 template<class Prop0, class Allocator0>
04855 double ReciprocalConditionNumber(const SeldonDiag& DiagA,
04856 const Matrix<double, Prop0,
04857 RowUpTriangPacked, Allocator0>& A,
04858 SeldonNorm norm,
04859 LapackInfo& info)
04860 {
04861 char uplo('L'); char norm_type = norm.RevChar();
04862 char diag = DiagA.Char();
04863 int n = A.GetM(); double rcond(0);
04864 Vector<int> iwork(n); Vector<double, VectFull, Allocator0> work(3*n);
04865 dtpcon_(&norm_type, &uplo, &diag, &n, A.GetData(), &rcond,
04866 work.GetData(), iwork.GetData(), &info.GetInfoRef());
04867 return rcond;
04868 }
04869
04870
04871 template<class Prop0, class Allocator0>
04872 float ReciprocalConditionNumber(const SeldonDiag& DiagA,
04873 const Matrix<complex<float>, Prop0,
04874 RowUpTriangPacked, Allocator0>& A,
04875 SeldonNorm norm,
04876 LapackInfo& info)
04877 {
04878 char uplo('L'); char norm_type = norm.RevChar();
04879 char diag = DiagA.Char();
04880 int n = A.GetM(); float rcond(0);
04881 Vector<float> rwork(n);
04882 Vector<complex<float>, VectFull, Allocator0> work(2*n);
04883 ctpcon_(&norm_type, &uplo, &diag, &n, A.GetDataVoid(), &rcond,
04884 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
04885 return rcond;
04886 }
04887
04888
04889 template<class Prop0, class Allocator0>
04890 double ReciprocalConditionNumber(const SeldonDiag& DiagA,
04891 const Matrix<complex<double>, Prop0,
04892 RowUpTriangPacked, Allocator0>& A,
04893 SeldonNorm norm,
04894 LapackInfo& info)
04895 {
04896 char uplo('L'); char norm_type = norm.RevChar();
04897 char diag = DiagA.Char();
04898 int n = A.GetM(); double rcond(0);
04899 Vector<double> rwork(n);
04900 Vector<complex<double>, VectFull, Allocator0> work(2*n);
04901 ztpcon_(&norm_type, &uplo, &diag, &n, A.GetDataVoid(), &rcond,
04902 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
04903 return rcond;
04904 }
04905
04906
04907
04908
04909
04910 template<class Prop0, class Allocator0>
04911 float ReciprocalConditionNumber(const Matrix<float, Prop0,
04912 RowLoTriangPacked, Allocator0>& A,
04913 SeldonNorm norm,
04914 LapackInfo& info)
04915 {
04916 char uplo('U'); char norm_type = norm.RevChar(); char diag('N');
04917
04918 int n = A.GetM(); float rcond(0);
04919 Vector<int> iwork(n);
04920 Vector<float, VectFull, Allocator0> work(3*n);
04921 stpcon_(&norm_type, &uplo, &diag, &n, A.GetData(), &rcond,
04922 work.GetData(), iwork.GetData(), &info.GetInfoRef());
04923 return rcond;
04924 }
04925
04926
04927 template<class Prop0, class Allocator0>
04928 double ReciprocalConditionNumber(const Matrix<double, Prop0,
04929 RowLoTriangPacked, Allocator0>& A,
04930 SeldonNorm norm,
04931 LapackInfo& info)
04932 {
04933 char uplo('U'); char norm_type = norm.RevChar(); char diag('N');
04934
04935 int n = A.GetM(); double rcond(0);
04936 Vector<int> iwork(n); Vector<double, VectFull, Allocator0> work(3*n);
04937 dtpcon_(&norm_type, &uplo, &diag, &n, A.GetData(), &rcond,
04938 work.GetData(), iwork.GetData(), &info.GetInfoRef());
04939 return rcond;
04940 }
04941
04942
04943 template<class Prop0, class Allocator0>
04944 float ReciprocalConditionNumber(const Matrix<complex<float>, Prop0,
04945 RowLoTriangPacked, Allocator0>& A,
04946 SeldonNorm norm,
04947 LapackInfo& info)
04948 {
04949 char uplo('U'); char norm_type = norm.RevChar(); char diag('N');
04950
04951 int n = A.GetM(); float rcond(0);
04952 Vector<float> rwork(n);
04953 Vector<complex<float>, VectFull, Allocator0> work(2*n);
04954 ctpcon_(&norm_type, &uplo, &diag, &n, A.GetDataVoid(), &rcond,
04955 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
04956 return rcond;
04957 }
04958
04959
04960 template<class Prop0, class Allocator0>
04961 double ReciprocalConditionNumber(const Matrix<complex<double>, Prop0,
04962 RowLoTriangPacked, Allocator0>& A,
04963 SeldonNorm norm,
04964 LapackInfo& info)
04965 {
04966 char uplo('U'); char norm_type = norm.RevChar(); char diag('N');
04967
04968 int n = A.GetM(); double rcond(0);
04969 Vector<double> rwork(n);
04970 Vector<complex<double>, VectFull, Allocator0> work(2*n);
04971 ztpcon_(&norm_type, &uplo, &diag, &n, A.GetDataVoid(), &rcond,
04972 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
04973 return rcond;
04974 }
04975
04976
04977
04978
04979
04980 template<class Prop0, class Allocator0>
04981 float ReciprocalConditionNumber(const SeldonDiag& DiagA,
04982 const Matrix<float, Prop0,
04983 RowLoTriangPacked, Allocator0>& A,
04984 SeldonNorm norm,
04985 LapackInfo& info)
04986 {
04987 char uplo('U'); char norm_type = norm.RevChar();
04988 char diag = DiagA.Char();
04989 int n = A.GetM(); float rcond(0);
04990 Vector<int> iwork(n);
04991 Vector<float, VectFull, Allocator0> work(3*n);
04992 stpcon_(&norm_type, &uplo, &diag, &n, A.GetData(), &rcond,
04993 work.GetData(), iwork.GetData(), &info.GetInfoRef());
04994 return rcond;
04995 }
04996
04997
04998 template<class Prop0, class Allocator0>
04999 double ReciprocalConditionNumber(const SeldonDiag& DiagA,
05000 const Matrix<double, Prop0,
05001 RowLoTriangPacked, Allocator0>& A,
05002 SeldonNorm norm,
05003 LapackInfo& info)
05004 {
05005 char uplo('U'); char norm_type = norm.RevChar();
05006 char diag = DiagA.Char();
05007 int n = A.GetM(); double rcond(0);
05008 Vector<int> iwork(n); Vector<double, VectFull, Allocator0> work(3*n);
05009 dtpcon_(&norm_type, &uplo, &diag, &n, A.GetData(), &rcond,
05010 work.GetData(), iwork.GetData(), &info.GetInfoRef());
05011 return rcond;
05012 }
05013
05014
05015 template<class Prop0, class Allocator0>
05016 float ReciprocalConditionNumber(const SeldonDiag& DiagA,
05017 const Matrix<complex<float>, Prop0,
05018 RowLoTriangPacked, Allocator0>& A,
05019 SeldonNorm norm,
05020 LapackInfo& info)
05021 {
05022 char uplo('U'); char norm_type = norm.RevChar();
05023 char diag = DiagA.Char();
05024 int n = A.GetM(); float rcond(0);
05025 Vector<float> rwork(n);
05026 Vector<complex<float>, VectFull, Allocator0> work(2*n);
05027 ctpcon_(&norm_type, &uplo, &diag, &n, A.GetDataVoid(), &rcond,
05028 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
05029 return rcond;
05030 }
05031
05032
05033 template<class Prop0, class Allocator0>
05034 double ReciprocalConditionNumber(const SeldonDiag& DiagA,
05035 const Matrix<complex<double>, Prop0,
05036 RowLoTriangPacked, Allocator0>& A,
05037 SeldonNorm norm,
05038 LapackInfo& info)
05039 {
05040 char uplo('U'); char norm_type = norm.RevChar();
05041 char diag = DiagA.Char();
05042 int n = A.GetM(); double rcond(0);
05043 Vector<double> rwork(n);
05044 Vector<complex<double>, VectFull, Allocator0> work(2*n);
05045 ztpcon_(&norm_type, &uplo, &diag, &n, A.GetDataVoid(), &rcond,
05046 work.GetDataVoid(), rwork.GetData(), &info.GetInfoRef());
05047 return rcond;
05048 }
05049
05050
05051
05053
05054
05055
05057
05058
05059
05060
05061
05062
05063 template <class Prop0, class Allocator0,
05064 class Allocator1, class Allocator2,
05065 class Allocator3, class Allocator4>
05066 void RefineSolutionLU(const Matrix<float, Prop0, ColMajor, Allocator0>& A,
05067 const Matrix<float, Prop0, ColMajor,
05068 Allocator1>& Alu,
05069 const Vector<int, VectFull, Allocator2>& P,
05070 Vector<float, VectFull, Allocator3>& x,
05071 const Vector<float, VectFull, Allocator4>& b,
05072 float& ferr, float& berr,
05073 LapackInfo& info)
05074 {
05075
05076 #ifdef SELDON_CHECK_DIMENSIONS
05077 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05078 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05079 #endif
05080
05081 int m = A.GetM();
05082 int nrhs = 1;
05083 char trans('N');
05084 Vector<float, VectFull, Allocator3> work(3*m);
05085 Vector<int> iwork(m);
05086 sgerfs_(&trans, &m, &nrhs, A.GetData(), &m, Alu.GetData(), &m,
05087 P.GetData(), b.GetData(), &m, x.GetData(), &m,
05088 &ferr, &berr, work.GetData(),
05089 iwork.GetData(), &info.GetInfoRef() );
05090 }
05091
05092
05093 template <class Prop0, class Allocator0,
05094 class Allocator1, class Allocator2,
05095 class Allocator3, class Allocator4>
05096 void RefineSolutionLU(const Matrix<double, Prop0, ColMajor, Allocator0>& A,
05097 const Matrix<double, Prop0, ColMajor,
05098 Allocator1>& Alu,
05099 const Vector<int, VectFull, Allocator2>& P,
05100 Vector<double, VectFull, Allocator3>& x,
05101 const Vector<double, VectFull, Allocator4>& b,
05102 double& ferr, double& berr,
05103 LapackInfo& info)
05104 {
05105
05106 #ifdef SELDON_CHECK_DIMENSIONS
05107 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05108 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05109 #endif
05110
05111 int m = A.GetM();
05112 int nrhs = 1;
05113 char trans('N');
05114 Vector<double, VectFull, Allocator3> work(3*m);
05115 Vector<int> iwork(m);
05116 dgerfs_(&trans, &m, &nrhs, A.GetData(), &m, Alu.GetData(), &m,
05117 P.GetData(), b.GetData(), &m, x.GetData(), &m,
05118 &ferr, &berr, work.GetData(),
05119 iwork.GetData(), &info.GetInfoRef() );
05120 }
05121
05122
05123 template <class Prop0, class Allocator0,
05124 class Allocator1, class Allocator2,
05125 class Allocator3, class Allocator4>
05126 void RefineSolutionLU(const Matrix<complex<float>, Prop0,
05127 ColMajor, Allocator0>& A,
05128 const Matrix<complex<float>, Prop0,
05129 ColMajor, Allocator1>& Alu,
05130 const Vector<int, VectFull, Allocator2>& P,
05131 Vector<complex<float>, VectFull, Allocator3>& x,
05132 const Vector<complex<float>, VectFull,
05133 Allocator4>& b,
05134 float& ferr, float& berr,
05135 LapackInfo& info)
05136 {
05137
05138 #ifdef SELDON_CHECK_DIMENSIONS
05139 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05140 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05141 #endif
05142
05143 int m = A.GetM();
05144 int nrhs = 1;
05145 char trans('N');
05146 Vector<complex<float>, VectFull, Allocator3> work(2*m);
05147 Vector<float> rwork(m);
05148 cgerfs_(&trans, &m, &nrhs, A.GetDataVoid(), &m, Alu.GetDataVoid(), &m,
05149 P.GetData(), b.GetDataVoid(), &m, x.GetDataVoid(), &m, &ferr,
05150 &berr, work.GetData(), rwork.GetData(),
05151 &info.GetInfoRef() );
05152 }
05153
05154
05155 template <class Prop0, class Allocator0,
05156 class Allocator1, class Allocator2,
05157 class Allocator3, class Allocator4>
05158 void RefineSolutionLU(const Matrix<complex<double>, Prop0,
05159 ColMajor, Allocator0>& A,
05160 const Matrix<complex<double>, Prop0,
05161 ColMajor, Allocator1>& Alu,
05162 const Vector<int, VectFull, Allocator2>& P,
05163 Vector<complex<double>, VectFull, Allocator3>& x,
05164 const Vector<complex<double>, VectFull,
05165 Allocator4>& b,
05166 double& ferr, double& berr,
05167 LapackInfo& info)
05168 {
05169
05170 #ifdef SELDON_CHECK_DIMENSIONS
05171 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05172 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05173 #endif
05174
05175 int m = A.GetM();
05176 int nrhs = 1;
05177 char trans('N');
05178 Vector<complex<double>, VectFull, Allocator3> work(2*m);
05179 Vector<double> rwork(m);
05180 zgerfs_(&trans, &m, &nrhs, A.GetDataVoid(), &m, Alu.GetDataVoid(), &m,
05181 P.GetData(), b.GetDataVoid(), &m, x.GetDataVoid(), &m, &ferr,
05182 &berr, work.GetData(), rwork.GetData(),
05183 &info.GetInfoRef() );
05184 }
05185
05186
05187
05188
05189
05190 template <class Prop0, class Allocator0,
05191 class Allocator1, class Allocator2,
05192 class Allocator3, class Allocator4>
05193 void RefineSolutionLU(const SeldonTranspose& TransA,
05194 const Matrix<float, Prop0, ColMajor, Allocator0>& A,
05195 const Matrix<float, Prop0, ColMajor,
05196 Allocator1>& Alu,
05197 const Vector<int, VectFull, Allocator2>& P,
05198 Vector<float, VectFull, Allocator3>& x,
05199 const Vector<float, VectFull, Allocator4>& b,
05200 float& ferr, float& berr,
05201 LapackInfo& info)
05202 {
05203
05204 #ifdef SELDON_CHECK_DIMENSIONS
05205 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05206 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05207 #endif
05208
05209 int m = A.GetM();
05210 int nrhs = 1;
05211 char trans = TransA.Char();
05212 Vector<float, VectFull, Allocator3> work(3*m);
05213 Vector<int> iwork(m);
05214 sgerfs_(&trans, &m, &nrhs, A.GetData(), &m, Alu.GetData(), &m,
05215 P.GetData(), b.GetData(), &m, x.GetData(), &m,
05216 &ferr, &berr, work.GetData(),
05217 iwork.GetData(), &info.GetInfoRef() );
05218 }
05219
05220
05221 template <class Prop0, class Allocator0,
05222 class Allocator1, class Allocator2,
05223 class Allocator3, class Allocator4>
05224 void RefineSolutionLU(const SeldonTranspose& TransA,
05225 const Matrix<double, Prop0, ColMajor, Allocator0>& A,
05226 const Matrix<double, Prop0, ColMajor,
05227 Allocator1>& Alu,
05228 const Vector<int, VectFull, Allocator2>& P,
05229 Vector<double, VectFull, Allocator3>& x,
05230 const Vector<double, VectFull, Allocator4>& b,
05231 double& ferr, double& berr,
05232 LapackInfo& info)
05233 {
05234
05235 #ifdef SELDON_CHECK_DIMENSIONS
05236 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05237 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05238 #endif
05239
05240 int m = A.GetM();
05241 int nrhs = 1;
05242 char trans = TransA.Char();
05243 Vector<double, VectFull, Allocator3> work(3*m);
05244 Vector<int> iwork(m);
05245 dgerfs_(&trans, &m, &nrhs, A.GetData(), &m, Alu.GetData(), &m,
05246 P.GetData(), b.GetData(), &m, x.GetData(), &m,
05247 &ferr, &berr, work.GetData(),
05248 iwork.GetData(), &info.GetInfoRef() );
05249 }
05250
05251
05252 template <class Prop0, class Allocator0,
05253 class Allocator1, class Allocator2,
05254 class Allocator3, class Allocator4>
05255 void
05256 RefineSolutionLU(const SeldonTranspose& TransA,
05257 const Matrix<complex<float>, Prop0, ColMajor,
05258 Allocator0>& A,
05259 const Matrix<complex<float>, Prop0, ColMajor,
05260 Allocator1>& Alu,
05261 const Vector<int, VectFull, Allocator2>& P,
05262 Vector<complex<float>, VectFull, Allocator3>& x,
05263 const Vector<complex<float>, VectFull, Allocator4>& b,
05264 float& ferr, float& berr,
05265 LapackInfo& info)
05266 {
05267
05268 #ifdef SELDON_CHECK_DIMENSIONS
05269 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05270 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05271 #endif
05272
05273 int m = A.GetM();
05274 int nrhs = 1;
05275 char trans = TransA.Char();
05276 Vector<complex<float>, VectFull, Allocator3> work(2*m);
05277 Vector<float> rwork(m);
05278 cgerfs_(&trans, &m, &nrhs, A.GetDataVoid(), &m, Alu.GetDataVoid(), &m,
05279 P.GetData(), b.GetDataVoid(), &m, x.GetDataVoid(), &m,
05280 &ferr, &berr, work.GetDataVoid(),
05281 rwork.GetData(), &info.GetInfoRef() );
05282 }
05283
05284
05285 template <class Prop0, class Allocator0,
05286 class Allocator1, class Allocator2,
05287 class Allocator3, class Allocator4>
05288 void RefineSolutionLU(const SeldonTranspose& TransA,
05289 const Matrix<complex<double>, Prop0, ColMajor,
05290 Allocator0>& A,
05291 const Matrix<complex<double>, Prop0, ColMajor,
05292 Allocator1>& Alu,
05293 const Vector<int, VectFull, Allocator2>& P,
05294 Vector<complex<double>, VectFull, Allocator3>& x,
05295 const Vector<complex<double>, VectFull,
05296 Allocator4>& b,
05297 double& ferr, double& berr,
05298 LapackInfo& info)
05299 {
05300
05301 #ifdef SELDON_CHECK_DIMENSIONS
05302 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05303 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05304 #endif
05305
05306 int m = A.GetM();
05307 int nrhs = 1;
05308 char trans = TransA.Char();
05309 Vector<complex<double>, VectFull, Allocator3> work(2*m);
05310 Vector<double> rwork(m);
05311 zgerfs_(&trans, &m, &nrhs, A.GetDataVoid(), &m, Alu.GetDataVoid(), &m,
05312 P.GetData(), b.GetDataVoid(), &m, x.GetDataVoid(), &m,
05313 &ferr, &berr, work.GetDataVoid(),
05314 rwork.GetData(), &info.GetInfoRef());
05315 }
05316
05317
05318
05319
05320
05321 template <class Prop0, class Allocator0,
05322 class Allocator1, class Allocator2,
05323 class Allocator3, class Allocator4>
05324 void RefineSolutionLU(const Matrix<float, Prop0, RowMajor, Allocator0>& A,
05325 const Matrix<float, Prop0, RowMajor,
05326 Allocator1>& Alu,
05327 const Vector<int, VectFull, Allocator2>& P,
05328 Vector<float, VectFull, Allocator3>& x,
05329 const Vector<float, VectFull, Allocator4>& b,
05330 float& ferr, float& berr,
05331 LapackInfo& info)
05332 {
05333
05334 #ifdef SELDON_CHECK_DIMENSIONS
05335 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05336 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05337 #endif
05338
05339 int m = A.GetM();
05340 int nrhs = 1;
05341 char trans('T');
05342 Vector<float, VectFull, Allocator3> work(3*m);
05343 Vector<int> iwork(m);
05344 sgerfs_(&trans, &m, &nrhs, A.GetData(), &m, Alu.GetData(), &m,
05345 P.GetData(), b.GetData(), &m, x.GetData(), &m,
05346 &ferr, &berr, work.GetData(),
05347 iwork.GetData(), &info.GetInfoRef());
05348 }
05349
05350
05351 template <class Prop0, class Allocator0,
05352 class Allocator1, class Allocator2,
05353 class Allocator3, class Allocator4>
05354 void RefineSolutionLU(const Matrix<double, Prop0, RowMajor, Allocator0>& A,
05355 const Matrix<double, Prop0, RowMajor,
05356 Allocator1>& Alu,
05357 const Vector<int, VectFull, Allocator2>& P,
05358 Vector<double, VectFull, Allocator3>& x,
05359 const Vector<double, VectFull, Allocator4>& b,
05360 double& ferr, double& berr,
05361 LapackInfo& info)
05362 {
05363
05364 #ifdef SELDON_CHECK_DIMENSIONS
05365 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05366 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05367 #endif
05368
05369 int m = A.GetM();
05370 int nrhs = 1;
05371 char trans('T');
05372 Vector<double, VectFull, Allocator3> work(3*m);
05373 Vector<int> iwork(m);
05374 dgerfs_(&trans, &m, &nrhs, A.GetData(), &m, Alu.GetData(), &m,
05375 P.GetData(), b.GetData(), &m, x.GetData(), &m,
05376 &ferr, &berr, work.GetData(),
05377 iwork.GetData(), &info.GetInfoRef());
05378 }
05379
05380
05381 template <class Prop0, class Allocator0,
05382 class Allocator1, class Allocator2,
05383 class Allocator3, class Allocator4>
05384 void RefineSolutionLU(const Matrix<complex<float>, Prop0,
05385 RowMajor, Allocator0>& A,
05386 const Matrix<complex<float>, Prop0,
05387 RowMajor, Allocator1>& Alu,
05388 const Vector<int, VectFull, Allocator2>& P,
05389 Vector<complex<float>, VectFull, Allocator3>& x,
05390 const Vector<complex<float>, VectFull,
05391 Allocator4>& b,
05392 float& ferr, float& berr,
05393 LapackInfo& info)
05394 {
05395
05396 #ifdef SELDON_CHECK_DIMENSIONS
05397 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05398 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05399 #endif
05400
05401 int m = A.GetM();
05402 int nrhs = 1;
05403 char trans('T');
05404 Vector<complex<float>, VectFull, Allocator3> work(2*m);
05405 Vector<float> rwork(m);
05406 cgerfs_(&trans, &m, &nrhs, A.GetDataVoid(), &m, Alu.GetDataVoid(), &m,
05407 P.GetData(), b.GetDataVoid(), &m, x.GetDataVoid(), &m, &ferr,
05408 &berr, work.GetData(), rwork.GetData(),
05409 &info.GetInfoRef());
05410 }
05411
05412
05413 template <class Prop0, class Allocator0,
05414 class Allocator1, class Allocator2,
05415 class Allocator3, class Allocator4>
05416 void RefineSolutionLU(const Matrix<complex<double>, Prop0,
05417 RowMajor, Allocator0>& A,
05418 const Matrix<complex<double>, Prop0,
05419 RowMajor, Allocator1>& Alu,
05420 const Vector<int, VectFull, Allocator2>& P,
05421 Vector<complex<double>, VectFull, Allocator3>& x,
05422 const Vector<complex<double>, VectFull,
05423 Allocator4>& b,
05424 double& ferr, double& berr,
05425 LapackInfo& info)
05426 {
05427
05428 #ifdef SELDON_CHECK_DIMENSIONS
05429 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05430 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05431 #endif
05432
05433 int m = A.GetM();
05434 int nrhs = 1;
05435 char trans('T');
05436 Vector<complex<double>, VectFull, Allocator3> work(2*m);
05437 Vector<double> rwork(m);
05438 zgerfs_(&trans, &m, &nrhs, A.GetDataVoid(), &m, Alu.GetDataVoid(), &m,
05439 P.GetData(), b.GetDataVoid(), &m, x.GetDataVoid(), &m, &ferr,
05440 &berr, work.GetData(), rwork.GetData(),
05441 &info.GetInfoRef());
05442 }
05443
05444
05445
05446
05447
05448 template <class Prop0, class Allocator0,
05449 class Allocator1, class Allocator2,
05450 class Allocator3, class Allocator4>
05451 void RefineSolutionLU(const SeldonTranspose& TransA,
05452 const Matrix<float, Prop0, RowMajor, Allocator0>& A,
05453 const Matrix<float, Prop0, RowMajor,
05454 Allocator1>& Alu,
05455 const Vector<int, VectFull, Allocator2>& P,
05456 Vector<float, VectFull, Allocator3>& x,
05457 const Vector<float, VectFull, Allocator4>& b,
05458 float& ferr, float& berr,
05459 LapackInfo& info)
05460 {
05461
05462 #ifdef SELDON_CHECK_DIMENSIONS
05463 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05464 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05465 #endif
05466
05467 int m = A.GetM();
05468 int nrhs = 1;
05469 char trans = TransA.RevChar();
05470 Vector<float, VectFull, Allocator3> work(3*m);
05471 Vector<int> iwork(m);
05472 sgerfs_(&trans, &m, &nrhs, A.GetData(), &m, Alu.GetData(), &m,
05473 P.GetData(), b.GetData(), &m, x.GetData(), &m,
05474 &ferr, &berr, work.GetData(),
05475 iwork.GetData(), &info.GetInfoRef() );
05476 }
05477
05478
05479 template <class Prop0, class Allocator0,
05480 class Allocator1, class Allocator2,
05481 class Allocator3, class Allocator4>
05482 void RefineSolutionLU(const SeldonTranspose& TransA,
05483 const Matrix<double, Prop0, RowMajor, Allocator0>& A,
05484 const Matrix<double, Prop0, RowMajor,
05485 Allocator1>& Alu,
05486 const Vector<int, VectFull, Allocator2>& P,
05487 Vector<double, VectFull, Allocator3>& x,
05488 const Vector<double, VectFull, Allocator4>& b,
05489 double& ferr, double& berr,
05490 LapackInfo& info)
05491 {
05492
05493 #ifdef SELDON_CHECK_DIMENSIONS
05494 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05495 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05496 #endif
05497
05498 int m = A.GetM();
05499 int nrhs = 1;
05500 char trans = TransA.RevChar();
05501 Vector<double, VectFull, Allocator3> work(3*m);
05502 Vector<int> iwork(m);
05503 dgerfs_(&trans, &m, &nrhs, A.GetData(), &m, Alu.GetData(), &m,
05504 P.GetData(), b.GetData(), &m, x.GetData(), &m,
05505 &ferr, &berr, work.GetData(),
05506 iwork.GetData(), &info.GetInfoRef() );
05507 }
05508
05509
05510 template <class Prop0, class Allocator0,
05511 class Allocator1, class Allocator2,
05512 class Allocator3, class Allocator4>
05513 void RefineSolutionLU(const SeldonTranspose& TransA,
05514 const Matrix<complex<float>, Prop0, RowMajor,
05515 Allocator0>& A,
05516 const Matrix<complex<float>, Prop0, RowMajor,
05517 Allocator1>& Alu,
05518 const Vector<int, VectFull, Allocator2>& P,
05519 Vector<complex<float>, VectFull, Allocator3>& x,
05520 Vector<complex<float>, VectFull, Allocator4>& b,
05521 float& ferr, float& berr,
05522 LapackInfo& info)
05523 {
05524
05525 #ifdef SELDON_CHECK_DIMENSIONS
05526 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05527 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05528 #endif
05529
05530 int m = A.GetM();
05531 int nrhs = 1;
05532 char trans = TransA.RevChar();
05533 Vector<complex<float>, VectFull, Allocator3> work(2*m);
05534 Vector<float> rwork(m);
05535 if (TransA.ConjTrans())
05536 {
05537 Conjugate(b);
05538 Conjugate(x);
05539 }
05540 cgerfs_(&trans, &m, &nrhs, A.GetDataVoid(), &m, Alu.GetDataVoid(), &m,
05541 P.GetData(), b.GetDataVoid(), &m, x.GetDataVoid(), &m,
05542 &ferr, &berr, work.GetDataVoid(),
05543 rwork.GetData(), &info.GetInfoRef() );
05544 if (TransA.ConjTrans())
05545 {
05546 Conjugate(b);
05547 Conjugate(x);
05548 }
05549 }
05550
05551
05552 template <class Prop0, class Allocator0,
05553 class Allocator1, class Allocator2,
05554 class Allocator3, class Allocator4>
05555 void RefineSolutionLU(const SeldonTranspose& TransA,
05556 const Matrix<complex<double>, Prop0, RowMajor,
05557 Allocator0>& A,
05558 const Matrix<complex<double>, Prop0, RowMajor,
05559 Allocator1>& Alu,
05560 const Vector<int, VectFull, Allocator2>& P,
05561 Vector<complex<double>, VectFull, Allocator3>& x,
05562 Vector<complex<double>, VectFull,
05563 Allocator4>& b,
05564 double& ferr, double& berr,
05565 LapackInfo& info)
05566 {
05567
05568 #ifdef SELDON_CHECK_DIMENSIONS
05569 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05570 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05571 #endif
05572
05573 int m = A.GetM();
05574 int nrhs = 1;
05575 char trans = TransA.RevChar();
05576 Vector<complex<double>, VectFull, Allocator3> work(2*m);
05577 Vector<double> rwork(m);
05578 if (TransA.ConjTrans())
05579 {
05580 Conjugate(b);
05581 Conjugate(x);
05582 }
05583 zgerfs_(&trans, &m, &nrhs, A.GetDataVoid(), &m, Alu.GetDataVoid(), &m,
05584 P.GetData(), b.GetDataVoid(), &m, x.GetDataVoid(), &m,
05585 &ferr, &berr, work.GetDataVoid(),
05586 rwork.GetData(), &info.GetInfoRef());
05587 if (TransA.ConjTrans())
05588 {
05589 Conjugate(b);
05590 Conjugate(x);
05591 }
05592 }
05593
05594
05595
05596
05597
05598 template <class Prop0, class Allocator0,
05599 class Allocator1, class Allocator2,
05600 class Allocator3, class Allocator4>
05601 void RefineSolutionLU(const Matrix<float, Prop0, ColSym, Allocator0>& A,
05602 const Matrix<float, Prop0, ColSym,
05603 Allocator1>& Alu,
05604 const Vector<int, VectFull, Allocator2>& P,
05605 Vector<float, VectFull, Allocator3>& x,
05606 const Vector<float, VectFull, Allocator4>& b,
05607 float& ferr, float& berr,
05608 LapackInfo& info)
05609 {
05610
05611 #ifdef SELDON_CHECK_DIMENSIONS
05612 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05613 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05614 #endif
05615
05616 int m = A.GetM();
05617 int nrhs = 1;
05618 char uplo('U');
05619 Vector<float, VectFull, Allocator3> work(3*m);
05620 Vector<int> iwork(m);
05621 ssyrfs_(&uplo, &m, &nrhs, A.GetData(), &m, Alu.GetData(), &m,
05622 P.GetData(), b.GetData(), &m, x.GetData(), &m,
05623 &ferr, &berr, work.GetData(),
05624 iwork.GetData(), &info.GetInfoRef() );
05625 }
05626
05627
05628 template <class Prop0, class Allocator0,
05629 class Allocator1, class Allocator2,
05630 class Allocator3, class Allocator4>
05631 void RefineSolutionLU(const Matrix<double, Prop0, ColSym, Allocator0>& A,
05632 const Matrix<double, Prop0, ColSym,
05633 Allocator1>& Alu,
05634 const Vector<int, VectFull, Allocator2>& P,
05635 Vector<double, VectFull, Allocator3>& x,
05636 const Vector<double, VectFull, Allocator4>& b,
05637 double& ferr, double& berr,
05638 LapackInfo& info)
05639 {
05640
05641 #ifdef SELDON_CHECK_DIMENSIONS
05642 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05643 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05644 #endif
05645
05646 int m = A.GetM();
05647 int nrhs = 1;
05648 char uplo('U');
05649 Vector<double, VectFull, Allocator3> work(3*m);
05650 Vector<int> iwork(m);
05651 dsyrfs_(&uplo, &m, &nrhs, A.GetData(), &m, Alu.GetData(), &m,
05652 P.GetData(), b.GetData(), &m, x.GetData(), &m,
05653 &ferr, &berr, work.GetData(),
05654 iwork.GetData(), &info.GetInfoRef() );
05655 }
05656
05657
05658 template <class Prop0, class Allocator0,
05659 class Allocator1, class Allocator2,
05660 class Allocator3, class Allocator4>
05661 void RefineSolutionLU(const Matrix<complex<float>, Prop0,
05662 ColSym, Allocator0>& A,
05663 const Matrix<complex<float>, Prop0,
05664 ColSym, Allocator1>& Alu,
05665 const Vector<int, VectFull, Allocator2>& P,
05666 Vector<complex<float>, VectFull, Allocator3>& x,
05667 const Vector<complex<float>, VectFull,
05668 Allocator4>& b,
05669 float& ferr, float& berr,
05670 LapackInfo& info)
05671 {
05672
05673 #ifdef SELDON_CHECK_DIMENSIONS
05674 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05675 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05676 #endif
05677
05678 int m = A.GetM();
05679 int nrhs = 1;
05680 char uplo('U');
05681 Vector<complex<float>, VectFull, Allocator3> work(2*m);
05682 Vector<float> rwork(m);
05683 csyrfs_(&uplo, &m, &nrhs, A.GetDataVoid(), &m, Alu.GetDataVoid(), &m,
05684 P.GetData(), b.GetDataVoid(), &m, x.GetDataVoid(), &m, &ferr,
05685 &berr, work.GetData(), rwork.GetData(),
05686 &info.GetInfoRef() );
05687 }
05688
05689
05690 template <class Prop0, class Allocator0,
05691 class Allocator1, class Allocator2,
05692 class Allocator3, class Allocator4>
05693 void RefineSolutionLU(const Matrix<complex<double>, Prop0,
05694 ColSym, Allocator0>& A,
05695 const Matrix<complex<double>, Prop0,
05696 ColSym, Allocator1>& Alu,
05697 const Vector<int, VectFull, Allocator2>& P,
05698 Vector<complex<double>, VectFull, Allocator3>& x,
05699 const Vector<complex<double>, VectFull,
05700 Allocator4>& b,
05701 double& ferr, double& berr,
05702 LapackInfo& info)
05703 {
05704
05705 #ifdef SELDON_CHECK_DIMENSIONS
05706 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05707 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05708 #endif
05709
05710 int m = A.GetM();
05711 int nrhs = 1;
05712 char uplo('U');
05713 Vector<complex<double>, VectFull, Allocator3> work(2*m);
05714 Vector<double> rwork(m);
05715 zsyrfs_(&uplo, &m, &nrhs, A.GetDataVoid(), &m, Alu.GetDataVoid(), &m,
05716 P.GetData(), b.GetDataVoid(), &m, x.GetDataVoid(), &m, &ferr,
05717 &berr, work.GetData(), rwork.GetData(),
05718 &info.GetInfoRef() );
05719 }
05720
05721
05722
05723
05724
05725 template <class Prop0, class Allocator0,
05726 class Allocator1, class Allocator2,
05727 class Allocator3, class Allocator4>
05728 void RefineSolutionLU(const Matrix<float, Prop0, ColSymPacked,
05729 Allocator0>& A,
05730 const Matrix<float, Prop0, ColSymPacked,
05731 Allocator1>& Alu,
05732 const Vector<int, VectFull, Allocator2>& P,
05733 Vector<float, VectFull, Allocator3>& x,
05734 const Vector<float, VectFull, Allocator4>& b,
05735 float& ferr, float& berr,
05736 LapackInfo& info)
05737 {
05738
05739 #ifdef SELDON_CHECK_DIMENSIONS
05740 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05741 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05742 #endif
05743
05744 int m = A.GetM();
05745 int nrhs = 1;
05746 char uplo('U');
05747 Vector<float, VectFull, Allocator3> work(3*m);
05748 Vector<int> iwork(m);
05749 ssprfs_(&uplo, &m, &nrhs, A.GetData(), Alu.GetData(),
05750 P.GetData(), b.GetData(), &m, x.GetData(), &m,
05751 &ferr, &berr, work.GetData(),
05752 iwork.GetData(), &info.GetInfoRef() );
05753 }
05754
05755
05756 template <class Prop0, class Allocator0,
05757 class Allocator1, class Allocator2,
05758 class Allocator3, class Allocator4>
05759 void RefineSolutionLU(const Matrix<double, Prop0, ColSymPacked,
05760 Allocator0>& A,
05761 const Matrix<double, Prop0, ColSymPacked,
05762 Allocator1>& Alu,
05763 const Vector<int, VectFull, Allocator2>& P,
05764 Vector<double, VectFull, Allocator3>& x,
05765 const Vector<double, VectFull, Allocator4>& b,
05766 double& ferr, double& berr,
05767 LapackInfo& info)
05768 {
05769
05770 #ifdef SELDON_CHECK_DIMENSIONS
05771 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05772 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05773 #endif
05774
05775 int m = A.GetM();
05776 int nrhs = 1;
05777 char uplo('U');
05778 Vector<double, VectFull, Allocator3> work(3*m);
05779 Vector<int> iwork(m);
05780 dsprfs_(&uplo, &m, &nrhs, A.GetData(), Alu.GetData(),
05781 P.GetData(), b.GetData(), &m, x.GetData(), &m,
05782 &ferr, &berr, work.GetData(),
05783 iwork.GetData(), &info.GetInfoRef() );
05784 }
05785
05786
05787 template <class Prop0, class Allocator0,
05788 class Allocator1, class Allocator2,
05789 class Allocator3, class Allocator4>
05790 void RefineSolutionLU(const Matrix<complex<float>, Prop0,
05791 ColSymPacked, Allocator0>& A,
05792 const Matrix<complex<float>, Prop0,
05793 ColSymPacked, Allocator1>& Alu,
05794 const Vector<int, VectFull, Allocator2>& P,
05795 Vector<complex<float>, VectFull, Allocator3>& x,
05796 const Vector<complex<float>, VectFull,
05797 Allocator4>& b,
05798 float& ferr, float& berr,
05799 LapackInfo& info)
05800 {
05801
05802 #ifdef SELDON_CHECK_DIMENSIONS
05803 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05804 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05805 #endif
05806
05807 int m = A.GetM();
05808 int nrhs = 1;
05809 char uplo('U');
05810 Vector<complex<float>, VectFull, Allocator3> work(2*m);
05811 Vector<float> rwork(m);
05812 csprfs_(&uplo, &m, &nrhs, A.GetDataVoid(), Alu.GetDataVoid(),
05813 P.GetData(), b.GetDataVoid(), &m, x.GetDataVoid(), &m, &ferr,
05814 &berr, work.GetData(), rwork.GetData(),
05815 &info.GetInfoRef() );
05816 }
05817
05818
05819 template <class Prop0, class Allocator0,
05820 class Allocator1, class Allocator2,
05821 class Allocator3, class Allocator4>
05822 void RefineSolutionLU(const Matrix<complex<double>, Prop0,
05823 ColSymPacked, Allocator0>& A,
05824 const Matrix<complex<double>, Prop0,
05825 ColSymPacked, Allocator1>& Alu,
05826 const Vector<int, VectFull, Allocator2>& P,
05827 Vector<complex<double>, VectFull, Allocator3>& x,
05828 const Vector<complex<double>, VectFull,
05829 Allocator4>& b,
05830 double& ferr, double& berr,
05831 LapackInfo& info)
05832 {
05833
05834 #ifdef SELDON_CHECK_DIMENSIONS
05835 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05836 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05837 #endif
05838
05839 int m = A.GetM();
05840 int nrhs = 1;
05841 char uplo('U');
05842 Vector<complex<double>, VectFull, Allocator3> work(2*m);
05843 Vector<double> rwork(m);
05844 zsprfs_(&uplo, &m, &nrhs, A.GetDataVoid(), Alu.GetDataVoid(),
05845 P.GetData(), b.GetDataVoid(), &m, x.GetDataVoid(), &m, &ferr,
05846 &berr, work.GetData(), rwork.GetData(),
05847 &info.GetInfoRef() );
05848 }
05849
05850
05851
05852
05853
05854 template <class Prop0, class Allocator0,
05855 class Allocator1, class Allocator2,
05856 class Allocator3, class Allocator4>
05857 void RefineSolutionLU(const Matrix<float, Prop0, RowSym, Allocator0>& A,
05858 const Matrix<float, Prop0, RowSym,
05859 Allocator1>& Alu,
05860 const Vector<int, VectFull, Allocator2>& P,
05861 Vector<float, VectFull, Allocator3>& x,
05862 const Vector<float, VectFull, Allocator4>& b,
05863 float& ferr, float& berr,
05864 LapackInfo& info)
05865 {
05866
05867 #ifdef SELDON_CHECK_DIMENSIONS
05868 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05869 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05870 #endif
05871
05872 int m = A.GetM();
05873 int nrhs = 1;
05874 char uplo('L');
05875 Vector<float, VectFull, Allocator3> work(3*m);
05876 Vector<int> iwork(m);
05877 ssyrfs_(&uplo, &m, &nrhs, A.GetData(), &m, Alu.GetData(), &m,
05878 P.GetData(), b.GetData(), &m, x.GetData(), &m,
05879 &ferr, &berr, work.GetData(),
05880 iwork.GetData(), &info.GetInfoRef() );
05881 }
05882
05883
05884 template <class Prop0, class Allocator0,
05885 class Allocator1, class Allocator2,
05886 class Allocator3, class Allocator4>
05887 void RefineSolutionLU(const Matrix<double, Prop0, RowSym, Allocator0>& A,
05888 const Matrix<double, Prop0, RowSym,
05889 Allocator1>& Alu,
05890 const Vector<int, VectFull, Allocator2>& P,
05891 Vector<double, VectFull, Allocator3>& x,
05892 const Vector<double, VectFull, Allocator4>& b,
05893 double& ferr, double& berr,
05894 LapackInfo& info)
05895 {
05896
05897 #ifdef SELDON_CHECK_DIMENSIONS
05898 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05899 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05900 #endif
05901
05902 int m = A.GetM();
05903 int nrhs = 1;
05904 char uplo('L');
05905 Vector<double, VectFull, Allocator3> work(3*m);
05906 Vector<int> iwork(m);
05907 dsyrfs_(&uplo, &m, &nrhs, A.GetData(), &m, Alu.GetData(), &m,
05908 P.GetData(), b.GetData(), &m, x.GetData(), &m,
05909 &ferr, &berr, work.GetData(),
05910 iwork.GetData(), &info.GetInfoRef() );
05911 }
05912
05913
05914 template <class Prop0, class Allocator0,
05915 class Allocator1, class Allocator2,
05916 class Allocator3, class Allocator4>
05917 void RefineSolutionLU(const Matrix<complex<float>, Prop0,
05918 RowSym, Allocator0>& A,
05919 const Matrix<complex<float>, Prop0,
05920 RowSym, Allocator1>& Alu,
05921 const Vector<int, VectFull, Allocator2>& P,
05922 Vector<complex<float>, VectFull, Allocator3>& x,
05923 const Vector<complex<float>, VectFull,
05924 Allocator4>& b,
05925 float& ferr, float& berr,
05926 LapackInfo& info)
05927 {
05928
05929 #ifdef SELDON_CHECK_DIMENSIONS
05930 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05931 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05932 #endif
05933
05934 int m = A.GetM();
05935 int nrhs = 1;
05936 char uplo('L');
05937 Vector<complex<float>, VectFull, Allocator3> work(2*m);
05938 Vector<float> rwork(m);
05939 csyrfs_(&uplo, &m, &nrhs, A.GetDataVoid(), &m, Alu.GetDataVoid(), &m,
05940 P.GetData(), b.GetDataVoid(), &m, x.GetDataVoid(), &m, &ferr,
05941 &berr, work.GetData(), rwork.GetData(),
05942 &info.GetInfoRef() );
05943 }
05944
05945
05946 template <class Prop0, class Allocator0,
05947 class Allocator1, class Allocator2,
05948 class Allocator3, class Allocator4>
05949 void RefineSolutionLU(const Matrix<complex<double>, Prop0,
05950 RowSym, Allocator0>& A,
05951 const Matrix<complex<double>, Prop0,
05952 RowSym, Allocator1>& Alu,
05953 const Vector<int, VectFull, Allocator2>& P,
05954 Vector<complex<double>, VectFull, Allocator3>& x,
05955 const Vector<complex<double>, VectFull,
05956 Allocator4>& b,
05957 double& ferr, double& berr,
05958 LapackInfo& info)
05959 {
05960
05961 #ifdef SELDON_CHECK_DIMENSIONS
05962 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05963 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05964 #endif
05965
05966 int m = A.GetM();
05967 int nrhs = 1;
05968 char uplo('L');
05969 Vector<complex<double>, VectFull, Allocator3> work(2*m);
05970 Vector<double> rwork(m);
05971 zsyrfs_(&uplo, &m, &nrhs, A.GetDataVoid(), &m, Alu.GetDataVoid(), &m,
05972 P.GetData(), b.GetDataVoid(), &m, x.GetDataVoid(), &m, &ferr,
05973 &berr, work.GetData(), rwork.GetData(),
05974 &info.GetInfoRef() );
05975 }
05976
05977
05978
05979
05980
05981 template <class Prop0, class Allocator0,
05982 class Allocator1, class Allocator2,
05983 class Allocator3, class Allocator4>
05984 void RefineSolutionLU(const Matrix<float, Prop0, RowSymPacked,
05985 Allocator0>& A,
05986 const Matrix<float, Prop0, RowSymPacked,
05987 Allocator1>& Alu,
05988 const Vector<int, VectFull, Allocator2>& P,
05989 Vector<float, VectFull, Allocator3>& x,
05990 const Vector<float, VectFull, Allocator4>& b,
05991 float& ferr, float& berr,
05992 LapackInfo& info)
05993 {
05994
05995 #ifdef SELDON_CHECK_DIMENSIONS
05996 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05997 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
05998 #endif
05999
06000 int m = A.GetM();
06001 int nrhs = 1;
06002 char uplo('L');
06003 Vector<float, VectFull, Allocator3> work(3*m);
06004 Vector<int> iwork(m);
06005 ssprfs_(&uplo, &m, &nrhs, A.GetData(), Alu.GetData(),
06006 P.GetData(), b.GetData(), &m, x.GetData(), &m,
06007 &ferr, &berr, work.GetData(),
06008 iwork.GetData(), &info.GetInfoRef() );
06009 }
06010
06011
06012 template <class Prop0, class Allocator0,
06013 class Allocator1, class Allocator2,
06014 class Allocator3, class Allocator4>
06015 void RefineSolutionLU(const Matrix<double, Prop0, RowSymPacked,
06016 Allocator0>& A,
06017 const Matrix<double, Prop0, RowSymPacked,
06018 Allocator1>& Alu,
06019 const Vector<int, VectFull, Allocator2>& P,
06020 Vector<double, VectFull, Allocator3>& x,
06021 const Vector<double, VectFull, Allocator4>& b,
06022 double& ferr, double& berr,
06023 LapackInfo& info)
06024 {
06025
06026 #ifdef SELDON_CHECK_DIMENSIONS
06027 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
06028 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
06029 #endif
06030
06031 int m = A.GetM();
06032 int nrhs = 1;
06033 char uplo('L');
06034 Vector<double, VectFull, Allocator3> work(3*m);
06035 Vector<int> iwork(m);
06036 dsprfs_(&uplo, &m, &nrhs, A.GetData(), Alu.GetData(),
06037 P.GetData(), b.GetData(), &m, x.GetData(), &m,
06038 &ferr, &berr, work.GetData(),
06039 iwork.GetData(), &info.GetInfoRef() );
06040 }
06041
06042
06043 template <class Prop0, class Allocator0,
06044 class Allocator1, class Allocator2,
06045 class Allocator3, class Allocator4>
06046 void RefineSolutionLU(const Matrix<complex<float>, Prop0,
06047 RowSymPacked, Allocator0>& A,
06048 const Matrix<complex<float>, Prop0,
06049 RowSymPacked, Allocator1>& Alu,
06050 const Vector<int, VectFull, Allocator2>& P,
06051 Vector<complex<float>, VectFull, Allocator3>& x,
06052 const Vector<complex<float>, VectFull,
06053 Allocator4>& b,
06054 float& ferr, float& berr,
06055 LapackInfo& info)
06056 {
06057
06058 #ifdef SELDON_CHECK_DIMENSIONS
06059 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
06060 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
06061 #endif
06062
06063 int m = A.GetM();
06064 int nrhs = 1;
06065 char uplo('L');
06066 Vector<complex<float>, VectFull, Allocator3> work(2*m);
06067 Vector<float> rwork(m);
06068 csprfs_(&uplo, &m, &nrhs, A.GetDataVoid(), Alu.GetDataVoid(),
06069 P.GetData(), b.GetDataVoid(), &m, x.GetDataVoid(), &m, &ferr,
06070 &berr, work.GetData(), rwork.GetData(),
06071 &info.GetInfoRef() );
06072 }
06073
06074
06075 template <class Prop0, class Allocator0,
06076 class Allocator1, class Allocator2,
06077 class Allocator3, class Allocator4>
06078 void RefineSolutionLU(const Matrix<complex<double>, Prop0,
06079 RowSymPacked, Allocator0>& A,
06080 const Matrix<complex<double>, Prop0,
06081 RowSymPacked, Allocator1>& Alu,
06082 const Vector<int, VectFull, Allocator2>& P,
06083 Vector<complex<double>, VectFull, Allocator3>& x,
06084 const Vector<complex<double>, VectFull,
06085 Allocator4>& b,
06086 double& ferr, double& berr,
06087 LapackInfo& info)
06088 {
06089
06090 #ifdef SELDON_CHECK_DIMENSIONS
06091 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
06092 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
06093 #endif
06094
06095 int m = A.GetM();
06096 int nrhs = 1;
06097 char uplo('L');
06098 Vector<complex<double>, VectFull, Allocator3> work(2*m);
06099 Vector<double> rwork(m);
06100 zsprfs_(&uplo, &m, &nrhs, A.GetDataVoid(), Alu.GetDataVoid(),
06101 P.GetData(), b.GetDataVoid(), &m, x.GetDataVoid(), &m, &ferr,
06102 &berr, work.GetData(), rwork.GetData(),
06103 &info.GetInfoRef() );
06104 }
06105
06106
06107
06108
06109
06110 template <class Prop0, class Allocator0,
06111 class Allocator1, class Allocator2,
06112 class Allocator3, class Allocator4>
06113 void RefineSolutionLU(const Matrix<complex<float>, Prop0,
06114 ColHerm, Allocator0>& A,
06115 const Matrix<complex<float>, Prop0,
06116 ColHerm, Allocator1>& Alu,
06117 const Vector<int, VectFull, Allocator2>& P,
06118 Vector<complex<float>, VectFull, Allocator3>& x,
06119 const Vector<complex<float>, VectFull,
06120 Allocator4>& b,
06121 float& ferr, float& berr,
06122 LapackInfo& info)
06123 {
06124
06125 #ifdef SELDON_CHECK_DIMENSIONS
06126 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
06127 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
06128 #endif
06129
06130 int m = A.GetM();
06131 int nrhs = 1;
06132 char uplo('U');
06133 Vector<complex<float>, VectFull, Allocator3> work(2*m);
06134 Vector<float> rwork(m);
06135 cherfs_(&uplo, &m, &nrhs, A.GetDataVoid(), &m, Alu.GetDataVoid(), &m,
06136 P.GetData(), b.GetDataVoid(), &m, x.GetDataVoid(), &m, &ferr,
06137 &berr, work.GetData(), rwork.GetData(),
06138 &info.GetInfoRef() );
06139 }
06140
06141
06142 template <class Prop0, class Allocator0,
06143 class Allocator1, class Allocator2,
06144 class Allocator3, class Allocator4>
06145 void RefineSolutionLU(const Matrix<complex<double>, Prop0,
06146 ColHerm, Allocator0>& A,
06147 const Matrix<complex<double>, Prop0,
06148 ColHerm, Allocator1>& Alu,
06149 const Vector<int, VectFull, Allocator2>& P,
06150 Vector<complex<double>, VectFull, Allocator3>& x,
06151 const Vector<complex<double>, VectFull,
06152 Allocator4>& b,
06153 double& ferr, double& berr,
06154 LapackInfo& info)
06155 {
06156
06157 #ifdef SELDON_CHECK_DIMENSIONS
06158 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
06159 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
06160 #endif
06161
06162 int m = A.GetM();
06163 int nrhs = 1;
06164 char uplo('U');
06165 Vector<complex<double>, VectFull, Allocator3> work(2*m);
06166 Vector<double> rwork(m);
06167 zherfs_(&uplo, &m, &nrhs, A.GetDataVoid(), &m, Alu.GetDataVoid(), &m,
06168 P.GetData(), b.GetDataVoid(), &m, x.GetDataVoid(), &m, &ferr,
06169 &berr, work.GetData(), rwork.GetData(),
06170 &info.GetInfoRef() );
06171 }
06172
06173
06174
06175
06176
06177 template <class Prop0, class Allocator0,
06178 class Allocator1, class Allocator2,
06179 class Allocator3, class Allocator4>
06180 void RefineSolutionLU(const Matrix<complex<float>, Prop0,
06181 ColHermPacked, Allocator0>& A,
06182 const Matrix<complex<float>, Prop0,
06183 ColHermPacked, Allocator1>& Alu,
06184 const Vector<int, VectFull, Allocator2>& P,
06185 Vector<complex<float>, VectFull, Allocator3>& x,
06186 const Vector<complex<float>, VectFull,
06187 Allocator4>& b,
06188 float& ferr, float& berr,
06189 LapackInfo& info)
06190 {
06191
06192 #ifdef SELDON_CHECK_DIMENSIONS
06193 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
06194 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
06195 #endif
06196
06197 int m = A.GetM();
06198 int nrhs = 1;
06199 char uplo('U');
06200 Vector<complex<float>, VectFull, Allocator3> work(2*m);
06201 Vector<float> rwork(m);
06202 chprfs_(&uplo, &m, &nrhs, A.GetDataVoid(), Alu.GetDataVoid(),
06203 P.GetData(), b.GetDataVoid(), &m, x.GetDataVoid(), &m, &ferr,
06204 &berr, work.GetData(), rwork.GetData(),
06205 &info.GetInfoRef() );
06206 }
06207
06208
06209 template <class Prop0, class Allocator0,
06210 class Allocator1, class Allocator2,
06211 class Allocator3, class Allocator4>
06212 void RefineSolutionLU(const Matrix<complex<double>, Prop0,
06213 ColHermPacked, Allocator0>& A,
06214 const Matrix<complex<double>, Prop0,
06215 ColHermPacked, Allocator1>& Alu,
06216 const Vector<int, VectFull, Allocator2>& P,
06217 Vector<complex<double>, VectFull, Allocator3>& x,
06218 const Vector<complex<double>, VectFull,
06219 Allocator4>& b,
06220 double& ferr, double& berr,
06221 LapackInfo& info)
06222 {
06223
06224 #ifdef SELDON_CHECK_DIMENSIONS
06225 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
06226 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
06227 #endif
06228
06229 int m = A.GetM();
06230 int nrhs = 1;
06231 char uplo('U');
06232 Vector<complex<double>, VectFull, Allocator3> work(2*m);
06233 Vector<double> rwork(m);
06234 zhprfs_(&uplo, &m, &nrhs, A.GetDataVoid(), Alu.GetDataVoid(),
06235 P.GetData(), b.GetDataVoid(), &m, x.GetDataVoid(), &m, &ferr,
06236 &berr, work.GetData(), rwork.GetData(),
06237 &info.GetInfoRef() );
06238 }
06239
06240
06241
06242
06243
06244 template <class Prop0, class Allocator0,
06245 class Allocator1, class Allocator2,
06246 class Allocator3, class Allocator4>
06247 void RefineSolutionLU(const Matrix<complex<float>, Prop0,
06248 RowHerm, Allocator0>& A,
06249 const Matrix<complex<float>, Prop0,
06250 RowHerm, Allocator1>& Alu,
06251 const Vector<int, VectFull, Allocator2>& P,
06252 Vector<complex<float>, VectFull, Allocator3>& x,
06253 Vector<complex<float>, VectFull,
06254 Allocator4>& b,
06255 float& ferr, float& berr,
06256 LapackInfo& info)
06257 {
06258
06259 #ifdef SELDON_CHECK_DIMENSIONS
06260 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
06261 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
06262 #endif
06263
06264 int m = A.GetM();
06265 int nrhs = 1;
06266 char uplo('L');
06267 Vector<complex<float>, VectFull, Allocator3> work(2*m);
06268 Vector<float> rwork(m);
06269 Conjugate(b); Conjugate(x);
06270 cherfs_(&uplo, &m, &nrhs, A.GetDataVoid(), &m, Alu.GetDataVoid(), &m,
06271 P.GetData(), b.GetDataVoid(), &m, x.GetDataVoid(), &m, &ferr,
06272 &berr, work.GetData(), rwork.GetData(),
06273 &info.GetInfoRef() );
06274 Conjugate(b); Conjugate(x);
06275 }
06276
06277
06278 template <class Prop0, class Allocator0,
06279 class Allocator1, class Allocator2,
06280 class Allocator3, class Allocator4>
06281 void RefineSolutionLU(const Matrix<complex<double>, Prop0,
06282 RowHerm, Allocator0>& A,
06283 const Matrix<complex<double>, Prop0,
06284 RowHerm, Allocator1>& Alu,
06285 const Vector<int, VectFull, Allocator2>& P,
06286 Vector<complex<double>, VectFull, Allocator3>& x,
06287 Vector<complex<double>, VectFull,
06288 Allocator4>& b,
06289 double& ferr, double& berr,
06290 LapackInfo& info)
06291 {
06292
06293 #ifdef SELDON_CHECK_DIMENSIONS
06294 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
06295 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
06296 #endif
06297
06298 int m = A.GetM();
06299 int nrhs = 1;
06300 char uplo('L');
06301 Vector<complex<double>, VectFull, Allocator3> work(2*m);
06302 Vector<double> rwork(m);
06303 Conjugate(b); Conjugate(x);
06304 zherfs_(&uplo, &m, &nrhs, A.GetDataVoid(), &m, Alu.GetDataVoid(), &m,
06305 P.GetData(), b.GetDataVoid(), &m, x.GetDataVoid(), &m, &ferr,
06306 &berr, work.GetData(), rwork.GetData(),
06307 &info.GetInfoRef() );
06308 Conjugate(b); Conjugate(x);
06309 }
06310
06311
06312
06313
06314
06315 template <class Prop0, class Allocator0,
06316 class Allocator1, class Allocator2,
06317 class Allocator3, class Allocator4>
06318 void RefineSolutionLU(const Matrix<complex<float>, Prop0,
06319 RowHermPacked, Allocator0>& A,
06320 const Matrix<complex<float>, Prop0,
06321 RowHermPacked, Allocator1>& Alu,
06322 const Vector<int, VectFull, Allocator2>& P,
06323 Vector<complex<float>, VectFull, Allocator3>& x,
06324 Vector<complex<float>, VectFull,
06325 Allocator4>& b,
06326 float& ferr, float& berr,
06327 LapackInfo& info)
06328 {
06329
06330 #ifdef SELDON_CHECK_DIMENSIONS
06331 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
06332 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
06333 #endif
06334
06335 int m = A.GetM();
06336 int nrhs = 1;
06337 char uplo('L');
06338 Vector<complex<float>, VectFull, Allocator3> work(2*m);
06339 Vector<float> rwork(m);
06340 Conjugate(b); Conjugate(x);
06341 chprfs_(&uplo, &m, &nrhs, A.GetDataVoid(), Alu.GetDataVoid(),
06342 P.GetData(), b.GetDataVoid(), &m, x.GetDataVoid(), &m, &ferr,
06343 &berr, work.GetData(), rwork.GetData(),
06344 &info.GetInfoRef() );
06345 Conjugate(b); Conjugate(x);
06346 }
06347
06348
06349 template <class Prop0, class Allocator0,
06350 class Allocator1, class Allocator2,
06351 class Allocator3, class Allocator4>
06352 void RefineSolutionLU(const Matrix<complex<double>, Prop0,
06353 RowHermPacked, Allocator0>& A,
06354 const Matrix<complex<double>, Prop0,
06355 RowHermPacked, Allocator1>& Alu,
06356 const Vector<int, VectFull, Allocator2>& P,
06357 Vector<complex<double>, VectFull, Allocator3>& x,
06358 Vector<complex<double>, VectFull,
06359 Allocator4>& b,
06360 double& ferr, double& berr,
06361 LapackInfo& info)
06362 {
06363
06364 #ifdef SELDON_CHECK_DIMENSIONS
06365 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
06366 CheckDim(Alu, x, b, "RefineSolutionLU(A, Alu, pivot, X, Y)");
06367 #endif
06368
06369 int m = A.GetM();
06370 int nrhs = 1;
06371 char uplo('L');
06372 Vector<complex<double>, VectFull, Allocator3> work(2*m);
06373 Vector<double> rwork(m);
06374 Conjugate(b); Conjugate(x);
06375 zhprfs_(&uplo, &m, &nrhs, A.GetDataVoid(), Alu.GetDataVoid(),
06376 P.GetData(), b.GetDataVoid(), &m, x.GetDataVoid(), &m, &ferr,
06377 &berr, work.GetData(), rwork.GetData(),
06378 &info.GetInfoRef() );
06379 Conjugate(b); Conjugate(x);
06380 }
06381
06382
06383
06384
06385
06386 template <class Prop0, class Allocator0,
06387 class Allocator1, class Allocator2>
06388 void RefineSolutionLU(const Matrix<float, Prop0, ColUpTriang,
06389 Allocator0>& A,
06390 Vector<float, VectFull, Allocator1>& x,
06391 const Vector<float, VectFull, Allocator2>& b,
06392 float& ferr, float& berr,
06393 LapackInfo& info)
06394 {
06395
06396 #ifdef SELDON_CHECK_DIMENSIONS
06397 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
06398 #endif
06399
06400 int m = A.GetM();
06401 int nrhs = 1;
06402 char uplo('U');
06403 char trans('N'); char diag('N');
06404 Vector<float, VectFull, Allocator1> work(3*m);
06405 Vector<int> iwork(m);
06406 strrfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetData(), &m,
06407 b.GetData(), &m, x.GetData(), &m,
06408 &ferr, &berr, work.GetData(),
06409 iwork.GetData(), &info.GetInfoRef() );
06410 }
06411
06412 template <class Prop0, class Allocator0,
06413 class Allocator1, class Allocator2>
06414 void RefineSolutionLU(const Matrix<double, Prop0, ColUpTriang,
06415 Allocator0>& A,
06416 Vector<double, VectFull, Allocator1>& x,
06417 const Vector<double, VectFull, Allocator2>& b,
06418 double& ferr, double& berr,
06419 LapackInfo& info)
06420 {
06421
06422 #ifdef SELDON_CHECK_DIMENSIONS
06423 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
06424 #endif
06425
06426 int m = A.GetM();
06427 int nrhs = 1;
06428 char uplo('U');
06429 char trans('N'); char diag('N');
06430 Vector<double, VectFull, Allocator1> work(3*m);
06431 Vector<int> iwork(m);
06432 dtrrfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetData(), &m,
06433 b.GetData(), &m, x.GetData(), &m,
06434 &ferr, &berr, work.GetData(),
06435 iwork.GetData(), &info.GetInfoRef() );
06436 }
06437
06438
06439 template <class Prop0, class Allocator0,
06440 class Allocator1, class Allocator2>
06441 void
06442 RefineSolutionLU(const Matrix<complex<float>, Prop0, ColUpTriang,
06443 Allocator0>& A,
06444 Vector<complex<float>, VectFull, Allocator1>& x,
06445 const Vector<complex<float>, VectFull, Allocator2>& b,
06446 float& ferr, float& berr,
06447 LapackInfo& info)
06448 {
06449
06450 #ifdef SELDON_CHECK_DIMENSIONS
06451 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
06452 #endif
06453
06454 int m = A.GetM();
06455 int nrhs = 1;
06456 char uplo('U');
06457 char trans('N'); char diag('N');
06458 Vector<complex<float>, VectFull, Allocator1> work(2*m);
06459 Vector<float> rwork(m);
06460 ctrrfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetDataVoid(), &m,
06461 b.GetDataVoid(), &m, x.GetDataVoid(), &m,
06462 &ferr, &berr, work.GetDataVoid(),
06463 rwork.GetData(), &info.GetInfoRef() );
06464 }
06465
06466
06467 template <class Prop0, class Allocator0,
06468 class Allocator1, class Allocator2>
06469 void
06470 RefineSolutionLU(const Matrix<complex<double>, Prop0, ColUpTriang,
06471 Allocator0>& A,
06472 Vector<complex<double>, VectFull, Allocator1>& x,
06473 const Vector<complex<double>, VectFull, Allocator2>& b,
06474 double& ferr, double& berr,
06475 LapackInfo& info)
06476 {
06477
06478 #ifdef SELDON_CHECK_DIMENSIONS
06479 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
06480 #endif
06481
06482 int m = A.GetM();
06483 int nrhs = 1;
06484 char uplo('U');
06485 char trans('N'); char diag('N');
06486 Vector<complex<double>, VectFull, Allocator1> work(2*m);
06487 Vector<double> rwork(m);
06488 ztrrfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetDataVoid(), &m,
06489 b.GetDataVoid(), &m, x.GetDataVoid(), &m,
06490 &ferr, &berr, work.GetDataVoid(),
06491 rwork.GetData(), &info.GetInfoRef() );
06492 }
06493
06494
06495
06496
06497
06498 template <class Prop0, class Allocator0,
06499 class Allocator1, class Allocator2>
06500 void
06501 RefineSolutionLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
06502 const Matrix<float, Prop0, ColUpTriang,
06503 Allocator0>& A,
06504 Vector<float, VectFull, Allocator1>& x,
06505 const Vector<float, VectFull, Allocator2>& b,
06506 float& ferr, float& berr,
06507 LapackInfo& info)
06508 {
06509
06510 #ifdef SELDON_CHECK_DIMENSIONS
06511 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
06512 #endif
06513
06514 int m = A.GetM();
06515 int nrhs = 1;
06516 char uplo('U');
06517 char trans = TransA.Char(); char diag = DiagA.Char();
06518 Vector<float, VectFull, Allocator1> work(3*m);
06519 Vector<int> iwork(m);
06520 strrfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetData(), &m,
06521 b.GetData(), &m, x.GetData(), &m,
06522 &ferr, &berr, work.GetData(),
06523 iwork.GetData(), &info.GetInfoRef() );
06524 }
06525
06526 template <class Prop0, class Allocator0,
06527 class Allocator1, class Allocator2>
06528 void
06529 RefineSolutionLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
06530 const Matrix<double, Prop0, ColUpTriang,
06531 Allocator0>& A,
06532 Vector<double, VectFull, Allocator1>& x,
06533 const Vector<double, VectFull, Allocator2>& b,
06534 double& ferr, double& berr,
06535 LapackInfo& info)
06536 {
06537
06538 #ifdef SELDON_CHECK_DIMENSIONS
06539 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
06540 #endif
06541
06542 int m = A.GetM();
06543 int nrhs = 1;
06544 char uplo('U');
06545 char trans = TransA.Char(); char diag = DiagA.Char();
06546 Vector<double, VectFull, Allocator1> work(3*m);
06547 Vector<int> iwork(m);
06548 dtrrfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetData(), &m,
06549 b.GetData(), &m, x.GetData(), &m,
06550 &ferr, &berr, work.GetData(),
06551 iwork.GetData(), &info.GetInfoRef() );
06552 }
06553
06554
06555 template <class Prop0, class Allocator0,
06556 class Allocator1, class Allocator2>
06557 void
06558 RefineSolutionLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
06559 const Matrix<complex<float>, Prop0, ColUpTriang,
06560 Allocator0>& A,
06561 Vector<complex<float>, VectFull, Allocator1>& x,
06562 const Vector<complex<float>, VectFull, Allocator2>& b,
06563 float& ferr, float& berr,
06564 LapackInfo& info)
06565 {
06566
06567 #ifdef SELDON_CHECK_DIMENSIONS
06568 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
06569 #endif
06570
06571 int m = A.GetM();
06572 int nrhs = 1;
06573 char uplo('U');
06574 char trans = TransA.Char(); char diag = DiagA.Char();
06575 Vector<complex<float>, VectFull, Allocator1> work(2*m);
06576 Vector<float> rwork(m);
06577 ctrrfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetDataVoid(), &m,
06578 b.GetDataVoid(), &m, x.GetDataVoid(), &m,
06579 &ferr, &berr, work.GetDataVoid(),
06580 rwork.GetData(), &info.GetInfoRef() );
06581 }
06582
06583
06584 template <class Prop0, class Allocator0,
06585 class Allocator1, class Allocator2>
06586 void
06587 RefineSolutionLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
06588 const Matrix<complex<double>, Prop0, ColUpTriang,
06589 Allocator0>& A,
06590 Vector<complex<double>, VectFull, Allocator1>& x,
06591 const Vector<complex<double>, VectFull, Allocator2>& b,
06592 double& ferr, double& berr,
06593 LapackInfo& info)
06594 {
06595
06596 #ifdef SELDON_CHECK_DIMENSIONS
06597 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
06598 #endif
06599
06600 int m = A.GetM();
06601 int nrhs = 1;
06602 char uplo('U');
06603 char trans = TransA.Char(); char diag = DiagA.Char();
06604 Vector<complex<double>, VectFull, Allocator1> work(2*m);
06605 Vector<double> rwork(m);
06606 ztrrfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetDataVoid(), &m,
06607 b.GetDataVoid(), &m, x.GetDataVoid(), &m,
06608 &ferr, &berr, work.GetDataVoid(),
06609 rwork.GetData(), &info.GetInfoRef() );
06610 }
06611
06612
06613
06614
06615
06616 template <class Prop0, class Allocator0,
06617 class Allocator1, class Allocator2>
06618 void RefineSolutionLU(const Matrix<float, Prop0, ColLoTriang,
06619 Allocator0>& A,
06620 Vector<float, VectFull, Allocator1>& x,
06621 const Vector<float, VectFull, Allocator2>& b,
06622 float& ferr, float& berr,
06623 LapackInfo& info)
06624 {
06625
06626 #ifdef SELDON_CHECK_DIMENSIONS
06627 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
06628 #endif
06629
06630 int m = A.GetM();
06631 int nrhs = 1;
06632 char uplo('L');
06633 char trans('N'); char diag('N');
06634 Vector<float, VectFull, Allocator1> work(3*m);
06635 Vector<int> iwork(m);
06636 strrfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetData(), &m,
06637 b.GetData(), &m, x.GetData(), &m,
06638 &ferr, &berr, work.GetData(),
06639 iwork.GetData(), &info.GetInfoRef() );
06640 }
06641
06642 template <class Prop0, class Allocator0,
06643 class Allocator1, class Allocator2>
06644 void RefineSolutionLU(const Matrix<double, Prop0, ColLoTriang,
06645 Allocator0>& A,
06646 Vector<double, VectFull, Allocator1>& x,
06647 const Vector<double, VectFull, Allocator2>& b,
06648 double& ferr, double& berr,
06649 LapackInfo& info)
06650 {
06651
06652 #ifdef SELDON_CHECK_DIMENSIONS
06653 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
06654 #endif
06655
06656 int m = A.GetM();
06657 int nrhs = 1;
06658 char uplo('L');
06659 char trans('N'); char diag('N');
06660 Vector<double, VectFull, Allocator1> work(3*m);
06661 Vector<int> iwork(m);
06662 dtrrfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetData(), &m,
06663 b.GetData(), &m, x.GetData(), &m,
06664 &ferr, &berr, work.GetData(),
06665 iwork.GetData(), &info.GetInfoRef() );
06666 }
06667
06668
06669 template <class Prop0, class Allocator0,
06670 class Allocator1, class Allocator2>
06671 void
06672 RefineSolutionLU(const Matrix<complex<float>, Prop0, ColLoTriang,
06673 Allocator0>& A,
06674 Vector<complex<float>, VectFull, Allocator1>& x,
06675 const Vector<complex<float>, VectFull, Allocator2>& b,
06676 float& ferr, float& berr,
06677 LapackInfo& info)
06678 {
06679
06680 #ifdef SELDON_CHECK_DIMENSIONS
06681 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
06682 #endif
06683
06684 int m = A.GetM();
06685 int nrhs = 1;
06686 char uplo('L');
06687 char trans('N'); char diag('N');
06688 Vector<complex<float>, VectFull, Allocator1> work(2*m);
06689 Vector<float> rwork(m);
06690 ctrrfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetDataVoid(), &m,
06691 b.GetDataVoid(), &m, x.GetDataVoid(), &m,
06692 &ferr, &berr, work.GetDataVoid(),
06693 rwork.GetData(), &info.GetInfoRef() );
06694 }
06695
06696
06697 template <class Prop0, class Allocator0,
06698 class Allocator1, class Allocator2>
06699 void
06700 RefineSolutionLU(const Matrix<complex<double>, Prop0, ColLoTriang,
06701 Allocator0>& A,
06702 Vector<complex<double>, VectFull, Allocator1>& x,
06703 const Vector<complex<double>, VectFull, Allocator2>& b,
06704 double& ferr, double& berr,
06705 LapackInfo& info)
06706 {
06707
06708 #ifdef SELDON_CHECK_DIMENSIONS
06709 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
06710 #endif
06711
06712 int m = A.GetM();
06713 int nrhs = 1;
06714 char uplo('L');
06715 char trans('N'); char diag('N');
06716 Vector<complex<double>, VectFull, Allocator1> work(2*m);
06717 Vector<double> rwork(m);
06718 ztrrfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetDataVoid(), &m,
06719 b.GetDataVoid(), &m, x.GetDataVoid(), &m,
06720 &ferr, &berr, work.GetDataVoid(),
06721 rwork.GetData(), &info.GetInfoRef() );
06722 }
06723
06724
06725
06726
06727
06728 template <class Prop0, class Allocator0,
06729 class Allocator1, class Allocator2>
06730 void
06731 RefineSolutionLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
06732 const Matrix<float, Prop0, ColLoTriang,
06733 Allocator0>& A,
06734 Vector<float, VectFull, Allocator1>& x,
06735 const Vector<float, VectFull, Allocator2>& b,
06736 float& ferr, float& berr,
06737 LapackInfo& info)
06738 {
06739
06740 #ifdef SELDON_CHECK_DIMENSIONS
06741 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
06742 #endif
06743
06744 int m = A.GetM();
06745 int nrhs = 1;
06746 char uplo('L');
06747 char trans = TransA.Char(); char diag = DiagA.Char();
06748 Vector<float, VectFull, Allocator1> work(3*m);
06749 Vector<int> iwork(m);
06750 strrfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetData(), &m,
06751 b.GetData(), &m, x.GetData(), &m,
06752 &ferr, &berr, work.GetData(),
06753 iwork.GetData(), &info.GetInfoRef() );
06754 }
06755
06756 template <class Prop0, class Allocator0,
06757 class Allocator1, class Allocator2>
06758 void
06759 RefineSolutionLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
06760 const Matrix<double, Prop0, ColLoTriang,
06761 Allocator0>& A,
06762 Vector<double, VectFull, Allocator1>& x,
06763 const Vector<double, VectFull, Allocator2>& b,
06764 double& ferr, double& berr,
06765 LapackInfo& info)
06766 {
06767
06768 #ifdef SELDON_CHECK_DIMENSIONS
06769 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
06770 #endif
06771
06772 int m = A.GetM();
06773 int nrhs = 1;
06774 char uplo('L');
06775 char trans = TransA.Char(); char diag = DiagA.Char();
06776 Vector<double, VectFull, Allocator1> work(3*m);
06777 Vector<int> iwork(m);
06778 dtrrfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetData(), &m,
06779 b.GetData(), &m, x.GetData(), &m,
06780 &ferr, &berr, work.GetData(),
06781 iwork.GetData(), &info.GetInfoRef() );
06782 }
06783
06784
06785 template <class Prop0, class Allocator0,
06786 class Allocator1, class Allocator2>
06787 void
06788 RefineSolutionLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
06789 const Matrix<complex<float>, Prop0, ColLoTriang,
06790 Allocator0>& A,
06791 Vector<complex<float>, VectFull, Allocator1>& x,
06792 const Vector<complex<float>, VectFull, Allocator2>& b,
06793 float& ferr, float& berr,
06794 LapackInfo& info)
06795 {
06796
06797 #ifdef SELDON_CHECK_DIMENSIONS
06798 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
06799 #endif
06800
06801 int m = A.GetM();
06802 int nrhs = 1;
06803 char uplo('L');
06804 char trans = TransA.Char(); char diag = DiagA.Char();
06805 Vector<complex<float>, VectFull, Allocator1> work(2*m);
06806 Vector<float> rwork(m);
06807 ctrrfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetDataVoid(), &m,
06808 b.GetDataVoid(), &m, x.GetDataVoid(), &m,
06809 &ferr, &berr, work.GetDataVoid(),
06810 rwork.GetData(), &info.GetInfoRef() );
06811 }
06812
06813
06814 template <class Prop0, class Allocator0,
06815 class Allocator1, class Allocator2>
06816 void
06817 RefineSolutionLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
06818 const Matrix<complex<double>, Prop0, ColLoTriang,
06819 Allocator0>& A,
06820 Vector<complex<double>, VectFull, Allocator1>& x,
06821 const Vector<complex<double>, VectFull, Allocator2>& b,
06822 double& ferr, double& berr,
06823 LapackInfo& info)
06824 {
06825
06826 #ifdef SELDON_CHECK_DIMENSIONS
06827 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
06828 #endif
06829
06830 int m = A.GetM();
06831 int nrhs = 1;
06832 char uplo('L');
06833 char trans = TransA.Char(); char diag = DiagA.Char();
06834 Vector<complex<double>, VectFull, Allocator1> work(2*m);
06835 Vector<double> rwork(m);
06836 ztrrfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetDataVoid(), &m,
06837 b.GetDataVoid(), &m, x.GetDataVoid(), &m,
06838 &ferr, &berr, work.GetDataVoid(),
06839 rwork.GetData(), &info.GetInfoRef() );
06840 }
06841
06842
06843
06844
06845
06846 template <class Prop0, class Allocator0,
06847 class Allocator1, class Allocator2>
06848 void RefineSolutionLU(const Matrix<float, Prop0, ColUpTriangPacked,
06849 Allocator0>& A,
06850 Vector<float, VectFull, Allocator1>& x,
06851 const Vector<float, VectFull, Allocator2>& b,
06852 float& ferr, float& berr,
06853 LapackInfo& info)
06854 {
06855
06856 #ifdef SELDON_CHECK_DIMENSIONS
06857 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
06858 #endif
06859
06860 int m = A.GetM();
06861 int nrhs = 1;
06862 char uplo('U');
06863 char trans('N'); char diag('N');
06864 Vector<float, VectFull, Allocator1> work(3*m);
06865 Vector<int> iwork(m);
06866 stprfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetData(),
06867 b.GetData(), &m, x.GetData(), &m,
06868 &ferr, &berr, work.GetData(),
06869 iwork.GetData(), &info.GetInfoRef() );
06870 }
06871
06872 template <class Prop0, class Allocator0,
06873 class Allocator1, class Allocator2>
06874 void RefineSolutionLU(const Matrix<double, Prop0, ColUpTriangPacked,
06875 Allocator0>& A,
06876 Vector<double, VectFull, Allocator1>& x,
06877 const Vector<double, VectFull, Allocator2>& b,
06878 double& ferr, double& berr,
06879 LapackInfo& info)
06880 {
06881
06882 #ifdef SELDON_CHECK_DIMENSIONS
06883 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
06884 #endif
06885
06886 int m = A.GetM();
06887 int nrhs = 1;
06888 char uplo('U');
06889 char trans('N'); char diag('N');
06890 Vector<double, VectFull, Allocator1> work(3*m);
06891 Vector<int> iwork(m);
06892 dtprfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetData(),
06893 b.GetData(), &m, x.GetData(), &m,
06894 &ferr, &berr, work.GetData(),
06895 iwork.GetData(), &info.GetInfoRef() );
06896 }
06897
06898
06899 template <class Prop0, class Allocator0,
06900 class Allocator1, class Allocator2>
06901 void
06902 RefineSolutionLU(const Matrix<complex<float>, Prop0, ColUpTriangPacked,
06903 Allocator0>& A,
06904 Vector<complex<float>, VectFull, Allocator1>& x,
06905 const Vector<complex<float>, VectFull, Allocator2>& b,
06906 float& ferr, float& berr,
06907 LapackInfo& info)
06908 {
06909
06910 #ifdef SELDON_CHECK_DIMENSIONS
06911 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
06912 #endif
06913
06914 int m = A.GetM();
06915 int nrhs = 1;
06916 char uplo('U');
06917 char trans('N'); char diag('N');
06918 Vector<complex<float>, VectFull, Allocator1> work(2*m);
06919 Vector<float> rwork(m);
06920 ctprfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetDataVoid(),
06921 b.GetDataVoid(), &m, x.GetDataVoid(), &m,
06922 &ferr, &berr, work.GetDataVoid(),
06923 rwork.GetData(), &info.GetInfoRef() );
06924 }
06925
06926
06927 template <class Prop0, class Allocator0,
06928 class Allocator1, class Allocator2>
06929 void
06930 RefineSolutionLU(const Matrix<complex<double>, Prop0, ColUpTriangPacked,
06931 Allocator0>& A,
06932 Vector<complex<double>, VectFull, Allocator1>& x,
06933 const Vector<complex<double>, VectFull, Allocator2>& b,
06934 double& ferr, double& berr,
06935 LapackInfo& info)
06936 {
06937
06938 #ifdef SELDON_CHECK_DIMENSIONS
06939 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
06940 #endif
06941
06942 int m = A.GetM();
06943 int nrhs = 1;
06944 char uplo('U');
06945 char trans('N'); char diag('N');
06946 Vector<complex<double>, VectFull, Allocator1> work(2*m);
06947 Vector<double> rwork(m);
06948 ztprfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetDataVoid(),
06949 b.GetDataVoid(), &m, x.GetDataVoid(), &m,
06950 &ferr, &berr, work.GetDataVoid(),
06951 rwork.GetData(), &info.GetInfoRef() );
06952 }
06953
06954
06955
06956
06957
06958 template <class Prop0, class Allocator0,
06959 class Allocator1, class Allocator2>
06960 void
06961 RefineSolutionLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
06962 const Matrix<float, Prop0, ColUpTriangPacked,
06963 Allocator0>& A,
06964 Vector<float, VectFull, Allocator1>& x,
06965 const Vector<float, VectFull, Allocator2>& b,
06966 float& ferr, float& berr,
06967 LapackInfo& info)
06968 {
06969
06970 #ifdef SELDON_CHECK_DIMENSIONS
06971 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
06972 #endif
06973
06974 int m = A.GetM();
06975 int nrhs = 1;
06976 char uplo('U');
06977 char trans = TransA.Char(); char diag = DiagA.Char();
06978 Vector<float, VectFull, Allocator1> work(3*m);
06979 Vector<int> iwork(m);
06980 stprfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetData(),
06981 b.GetData(), &m, x.GetData(), &m,
06982 &ferr, &berr, work.GetData(),
06983 iwork.GetData(), &info.GetInfoRef() );
06984 }
06985
06986 template <class Prop0, class Allocator0,
06987 class Allocator1, class Allocator2>
06988 void
06989 RefineSolutionLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
06990 const Matrix<double, Prop0, ColUpTriangPacked,
06991 Allocator0>& A,
06992 Vector<double, VectFull, Allocator1>& x,
06993 const Vector<double, VectFull, Allocator2>& b,
06994 double& ferr, double& berr,
06995 LapackInfo& info)
06996 {
06997
06998 #ifdef SELDON_CHECK_DIMENSIONS
06999 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07000 #endif
07001
07002 int m = A.GetM();
07003 int nrhs = 1;
07004 char uplo('U');
07005 char trans = TransA.Char(); char diag = DiagA.Char();
07006 Vector<double, VectFull, Allocator1> work(3*m);
07007 Vector<int> iwork(m);
07008 dtprfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetData(),
07009 b.GetData(), &m, x.GetData(), &m,
07010 &ferr, &berr, work.GetData(),
07011 iwork.GetData(), &info.GetInfoRef() );
07012 }
07013
07014
07015 template <class Prop0, class Allocator0,
07016 class Allocator1, class Allocator2>
07017 void
07018 RefineSolutionLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
07019 const Matrix<complex<float>, Prop0, ColUpTriangPacked,
07020 Allocator0>& A,
07021 Vector<complex<float>, VectFull, Allocator1>& x,
07022 const Vector<complex<float>, VectFull, Allocator2>& b,
07023 float& ferr, float& berr,
07024 LapackInfo& info)
07025 {
07026
07027 #ifdef SELDON_CHECK_DIMENSIONS
07028 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07029 #endif
07030
07031 int m = A.GetM();
07032 int nrhs = 1;
07033 char uplo('U');
07034 char trans = TransA.Char(); char diag = DiagA.Char();
07035 Vector<complex<float>, VectFull, Allocator1> work(2*m);
07036 Vector<float> rwork(m);
07037 ctprfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetDataVoid(),
07038 b.GetDataVoid(), &m, x.GetDataVoid(), &m,
07039 &ferr, &berr, work.GetDataVoid(),
07040 rwork.GetData(), &info.GetInfoRef() );
07041 }
07042
07043
07044 template <class Prop0, class Allocator0,
07045 class Allocator1, class Allocator2>
07046 void
07047 RefineSolutionLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
07048 const Matrix<complex<double>, Prop0, ColUpTriangPacked,
07049 Allocator0>& A,
07050 Vector<complex<double>, VectFull, Allocator1>& x,
07051 const Vector<complex<double>, VectFull, Allocator2>& b,
07052 double& ferr, double& berr,
07053 LapackInfo& info)
07054 {
07055
07056 #ifdef SELDON_CHECK_DIMENSIONS
07057 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07058 #endif
07059
07060 int m = A.GetM();
07061 int nrhs = 1;
07062 char uplo('U');
07063 char trans = TransA.Char(); char diag = DiagA.Char();
07064 Vector<complex<double>, VectFull, Allocator1> work(2*m);
07065 Vector<double> rwork(m);
07066 ztprfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetDataVoid(),
07067 b.GetDataVoid(), &m, x.GetDataVoid(), &m,
07068 &ferr, &berr, work.GetDataVoid(),
07069 rwork.GetData(), &info.GetInfoRef() );
07070 }
07071
07072
07073
07074
07075
07076 template <class Prop0, class Allocator0,
07077 class Allocator1, class Allocator2>
07078 void RefineSolutionLU(const Matrix<float, Prop0, ColLoTriangPacked,
07079 Allocator0>& A,
07080 Vector<float, VectFull, Allocator1>& x,
07081 const Vector<float, VectFull, Allocator2>& b,
07082 float& ferr, float& berr,
07083 LapackInfo& info)
07084 {
07085
07086 #ifdef SELDON_CHECK_DIMENSIONS
07087 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07088 #endif
07089
07090 int m = A.GetM();
07091 int nrhs = 1;
07092 char uplo('L');
07093 char trans('N'); char diag('N');
07094 Vector<float, VectFull, Allocator1> work(3*m);
07095 Vector<int> iwork(m);
07096 stprfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetData(),
07097 b.GetData(), &m, x.GetData(), &m,
07098 &ferr, &berr, work.GetData(),
07099 iwork.GetData(), &info.GetInfoRef() );
07100 }
07101
07102 template <class Prop0, class Allocator0,
07103 class Allocator1, class Allocator2>
07104 void RefineSolutionLU(const Matrix<double, Prop0, ColLoTriangPacked,
07105 Allocator0>& A,
07106 Vector<double, VectFull, Allocator1>& x,
07107 const Vector<double, VectFull, Allocator2>& b,
07108 double& ferr, double& berr,
07109 LapackInfo& info)
07110 {
07111
07112 #ifdef SELDON_CHECK_DIMENSIONS
07113 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07114 #endif
07115
07116 int m = A.GetM();
07117 int nrhs = 1;
07118 char uplo('L');
07119 char trans('N'); char diag('N');
07120 Vector<double, VectFull, Allocator1> work(3*m);
07121 Vector<int> iwork(m);
07122 dtprfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetData(),
07123 b.GetData(), &m, x.GetData(), &m,
07124 &ferr, &berr, work.GetData(),
07125 iwork.GetData(), &info.GetInfoRef() );
07126 }
07127
07128
07129 template <class Prop0, class Allocator0,
07130 class Allocator1, class Allocator2>
07131 void
07132 RefineSolutionLU(const Matrix<complex<float>, Prop0, ColLoTriangPacked,
07133 Allocator0>& A,
07134 Vector<complex<float>, VectFull, Allocator1>& x,
07135 const Vector<complex<float>, VectFull, Allocator2>& b,
07136 float& ferr, float& berr,
07137 LapackInfo& info)
07138 {
07139
07140 #ifdef SELDON_CHECK_DIMENSIONS
07141 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07142 #endif
07143
07144 int m = A.GetM();
07145 int nrhs = 1;
07146 char uplo('L');
07147 char trans('N'); char diag('N');
07148 Vector<complex<float>, VectFull, Allocator1> work(2*m);
07149 Vector<float> rwork(m);
07150 ctprfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetDataVoid(),
07151 b.GetDataVoid(), &m, x.GetDataVoid(), &m,
07152 &ferr, &berr, work.GetDataVoid(),
07153 rwork.GetData(), &info.GetInfoRef() );
07154 }
07155
07156
07157 template <class Prop0, class Allocator0,
07158 class Allocator1, class Allocator2>
07159 void
07160 RefineSolutionLU(const Matrix<complex<double>, Prop0, ColLoTriangPacked,
07161 Allocator0>& A,
07162 Vector<complex<double>, VectFull, Allocator1>& x,
07163 const Vector<complex<double>, VectFull, Allocator2>& b,
07164 double& ferr, double& berr,
07165 LapackInfo& info)
07166 {
07167
07168 #ifdef SELDON_CHECK_DIMENSIONS
07169 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07170 #endif
07171
07172 int m = A.GetM();
07173 int nrhs = 1;
07174 char uplo('L');
07175 char trans('N'); char diag('N');
07176 Vector<complex<double>, VectFull, Allocator1> work(2*m);
07177 Vector<double> rwork(m);
07178 ztprfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetDataVoid(),
07179 b.GetDataVoid(), &m, x.GetDataVoid(), &m,
07180 &ferr, &berr, work.GetDataVoid(),
07181 rwork.GetData(), &info.GetInfoRef() );
07182 }
07183
07184
07185
07186
07187
07188 template <class Prop0, class Allocator0,
07189 class Allocator1, class Allocator2>
07190 void
07191 RefineSolutionLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
07192 const Matrix<float, Prop0, ColLoTriangPacked,
07193 Allocator0>& A,
07194 Vector<float, VectFull, Allocator1>& x,
07195 const Vector<float, VectFull, Allocator2>& b,
07196 float& ferr, float& berr,
07197 LapackInfo& info)
07198 {
07199
07200 #ifdef SELDON_CHECK_DIMENSIONS
07201 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07202 #endif
07203
07204 int m = A.GetM();
07205 int nrhs = 1;
07206 char uplo('L');
07207 char trans = TransA.Char(); char diag = DiagA.Char();
07208 Vector<float, VectFull, Allocator1> work(3*m);
07209 Vector<int> iwork(m);
07210 stprfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetData(),
07211 b.GetData(), &m, x.GetData(), &m,
07212 &ferr, &berr, work.GetData(),
07213 iwork.GetData(), &info.GetInfoRef() );
07214 }
07215
07216 template <class Prop0, class Allocator0,
07217 class Allocator1, class Allocator2>
07218 void
07219 RefineSolutionLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
07220 const Matrix<double, Prop0, ColLoTriangPacked,
07221 Allocator0>& A,
07222 Vector<double, VectFull, Allocator1>& x,
07223 const Vector<double, VectFull, Allocator2>& b,
07224 double& ferr, double& berr,
07225 LapackInfo& info)
07226 {
07227
07228 #ifdef SELDON_CHECK_DIMENSIONS
07229 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07230 #endif
07231
07232 int m = A.GetM();
07233 int nrhs = 1;
07234 char uplo('L');
07235 char trans = TransA.Char(); char diag = DiagA.Char();
07236 Vector<double, VectFull, Allocator1> work(3*m);
07237 Vector<int> iwork(m);
07238 dtprfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetData(),
07239 b.GetData(), &m, x.GetData(), &m,
07240 &ferr, &berr, work.GetData(),
07241 iwork.GetData(), &info.GetInfoRef() );
07242 }
07243
07244
07245 template <class Prop0, class Allocator0,
07246 class Allocator1, class Allocator2>
07247 void
07248 RefineSolutionLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
07249 const Matrix<complex<float>, Prop0, ColLoTriangPacked,
07250 Allocator0>& A,
07251 Vector<complex<float>, VectFull, Allocator1>& x,
07252 const Vector<complex<float>, VectFull, Allocator2>& b,
07253 float& ferr, float& berr,
07254 LapackInfo& info)
07255 {
07256
07257 #ifdef SELDON_CHECK_DIMENSIONS
07258 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07259 #endif
07260
07261 int m = A.GetM();
07262 int nrhs = 1;
07263 char uplo('L');
07264 char trans = TransA.Char(); char diag = DiagA.Char();
07265 Vector<complex<float>, VectFull, Allocator1> work(2*m);
07266 Vector<float> rwork(m);
07267 ctprfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetDataVoid(),
07268 b.GetDataVoid(), &m, x.GetDataVoid(), &m,
07269 &ferr, &berr, work.GetDataVoid(),
07270 rwork.GetData(), &info.GetInfoRef() );
07271 }
07272
07273
07274 template <class Prop0, class Allocator0,
07275 class Allocator1, class Allocator2>
07276 void
07277 RefineSolutionLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
07278 const Matrix<complex<double>, Prop0, ColLoTriangPacked,
07279 Allocator0>& A,
07280 Vector<complex<double>, VectFull, Allocator1>& x,
07281 const Vector<complex<double>, VectFull, Allocator2>& b,
07282 double& ferr, double& berr,
07283 LapackInfo& info)
07284 {
07285
07286 #ifdef SELDON_CHECK_DIMENSIONS
07287 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07288 #endif
07289
07290 int m = A.GetM();
07291 int nrhs = 1;
07292 char uplo('L');
07293 char trans = TransA.Char(); char diag = DiagA.Char();
07294 Vector<complex<double>, VectFull, Allocator1> work(2*m);
07295 Vector<double> rwork(m);
07296 ztprfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetDataVoid(),
07297 b.GetDataVoid(), &m, x.GetDataVoid(), &m,
07298 &ferr, &berr, work.GetDataVoid(),
07299 rwork.GetData(), &info.GetInfoRef() );
07300 }
07301
07302
07303
07304
07305
07306 template <class Prop0, class Allocator0,
07307 class Allocator1, class Allocator2>
07308 void RefineSolutionLU(const Matrix<float, Prop0, RowUpTriang,
07309 Allocator0>& A,
07310 Vector<float, VectFull, Allocator1>& x,
07311 const Vector<float, VectFull, Allocator2>& b,
07312 float& ferr, float& berr,
07313 LapackInfo& info)
07314 {
07315
07316 #ifdef SELDON_CHECK_DIMENSIONS
07317 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07318 #endif
07319
07320 int m = A.GetM();
07321 int nrhs = 1;
07322 char uplo('L');
07323 char trans('T'); char diag('N');
07324 Vector<float, VectFull, Allocator1> work(3*m);
07325 Vector<int> iwork(m);
07326 strrfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetData(), &m,
07327 b.GetData(), &m, x.GetData(), &m,
07328 &ferr, &berr, work.GetData(),
07329 iwork.GetData(), &info.GetInfoRef() );
07330 }
07331
07332 template <class Prop0, class Allocator0,
07333 class Allocator1, class Allocator2>
07334 void RefineSolutionLU(const Matrix<double, Prop0, RowUpTriang,
07335 Allocator0>& A,
07336 Vector<double, VectFull, Allocator1>& x,
07337 const Vector<double, VectFull, Allocator2>& b,
07338 double& ferr, double& berr,
07339 LapackInfo& info)
07340 {
07341
07342 #ifdef SELDON_CHECK_DIMENSIONS
07343 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07344 #endif
07345
07346 int m = A.GetM();
07347 int nrhs = 1;
07348 char uplo('L');
07349 char trans('T'); char diag('N');
07350 Vector<double, VectFull, Allocator1> work(3*m);
07351 Vector<int> iwork(m);
07352 dtrrfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetData(), &m,
07353 b.GetData(), &m, x.GetData(), &m,
07354 &ferr, &berr, work.GetData(),
07355 iwork.GetData(), &info.GetInfoRef() );
07356 }
07357
07358
07359 template <class Prop0, class Allocator0,
07360 class Allocator1, class Allocator2>
07361 void
07362 RefineSolutionLU(const Matrix<complex<float>, Prop0, RowUpTriang,
07363 Allocator0>& A,
07364 Vector<complex<float>, VectFull, Allocator1>& x,
07365 const Vector<complex<float>, VectFull, Allocator2>& b,
07366 float& ferr, float& berr,
07367 LapackInfo& info)
07368 {
07369
07370 #ifdef SELDON_CHECK_DIMENSIONS
07371 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07372 #endif
07373
07374 int m = A.GetM();
07375 int nrhs = 1;
07376 char uplo('L');
07377 char trans('T'); char diag('N');
07378 Vector<complex<float>, VectFull, Allocator1> work(2*m);
07379 Vector<float> rwork(m);
07380 ctrrfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetDataVoid(), &m,
07381 b.GetDataVoid(), &m, x.GetDataVoid(), &m,
07382 &ferr, &berr, work.GetDataVoid(),
07383 rwork.GetData(), &info.GetInfoRef() );
07384 }
07385
07386
07387 template <class Prop0, class Allocator0,
07388 class Allocator1, class Allocator2>
07389 void
07390 RefineSolutionLU(const Matrix<complex<double>, Prop0, RowUpTriang,
07391 Allocator0>& A,
07392 Vector<complex<double>, VectFull, Allocator1>& x,
07393 const Vector<complex<double>, VectFull, Allocator2>& b,
07394 double& ferr, double& berr,
07395 LapackInfo& info)
07396 {
07397
07398 #ifdef SELDON_CHECK_DIMENSIONS
07399 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07400 #endif
07401
07402 int m = A.GetM();
07403 int nrhs = 1;
07404 char uplo('L');
07405 char trans('T'); char diag('N');
07406 Vector<complex<double>, VectFull, Allocator1> work(2*m);
07407 Vector<double> rwork(m);
07408 ztrrfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetDataVoid(), &m,
07409 b.GetDataVoid(), &m, x.GetDataVoid(), &m,
07410 &ferr, &berr, work.GetDataVoid(),
07411 rwork.GetData(), &info.GetInfoRef() );
07412 }
07413
07414
07415
07416
07417
07418 template <class Prop0, class Allocator0,
07419 class Allocator1, class Allocator2>
07420 void
07421 RefineSolutionLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
07422 const Matrix<float, Prop0, RowUpTriang,
07423 Allocator0>& A,
07424 Vector<float, VectFull, Allocator1>& x,
07425 const Vector<float, VectFull, Allocator2>& b,
07426 float& ferr, float& berr,
07427 LapackInfo& info)
07428 {
07429
07430 #ifdef SELDON_CHECK_DIMENSIONS
07431 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07432 #endif
07433
07434 int m = A.GetM();
07435 int nrhs = 1;
07436 char uplo('L');
07437 char trans = TransA.RevChar(); char diag = DiagA.Char();
07438 Vector<float, VectFull, Allocator1> work(3*m);
07439 Vector<int> iwork(m);
07440 strrfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetData(), &m,
07441 b.GetData(), &m, x.GetData(), &m,
07442 &ferr, &berr, work.GetData(),
07443 iwork.GetData(), &info.GetInfoRef() );
07444 }
07445
07446 template <class Prop0, class Allocator0,
07447 class Allocator1, class Allocator2>
07448 void
07449 RefineSolutionLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
07450 const Matrix<double, Prop0, RowUpTriang,
07451 Allocator0>& A,
07452 Vector<double, VectFull, Allocator1>& x,
07453 const Vector<double, VectFull, Allocator2>& b,
07454 double& ferr, double& berr,
07455 LapackInfo& info)
07456 {
07457
07458 #ifdef SELDON_CHECK_DIMENSIONS
07459 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07460 #endif
07461
07462 int m = A.GetM();
07463 int nrhs = 1;
07464 char uplo('L');
07465 char trans = TransA.RevChar(); char diag = DiagA.Char();
07466 Vector<double, VectFull, Allocator1> work(3*m);
07467 Vector<int> iwork(m);
07468 dtrrfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetData(), &m,
07469 b.GetData(), &m, x.GetData(), &m,
07470 &ferr, &berr, work.GetData(),
07471 iwork.GetData(), &info.GetInfoRef() );
07472 }
07473
07474
07475 template <class Prop0, class Allocator0,
07476 class Allocator1, class Allocator2>
07477 void
07478 RefineSolutionLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
07479 const Matrix<complex<float>, Prop0, RowUpTriang,
07480 Allocator0>& A,
07481 Vector<complex<float>, VectFull, Allocator1>& x,
07482 Vector<complex<float>, VectFull, Allocator2>& b,
07483 float& ferr, float& berr,
07484 LapackInfo& info)
07485 {
07486
07487 #ifdef SELDON_CHECK_DIMENSIONS
07488 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07489 #endif
07490
07491 int m = A.GetM();
07492 int nrhs = 1;
07493 char uplo('L');
07494 char trans = TransA.RevChar(); char diag = DiagA.Char();
07495 Vector<complex<float>, VectFull, Allocator1> work(2*m);
07496 Vector<float> rwork(m);
07497 if (TransA.ConjTrans())
07498 {
07499 Conjugate(b);
07500 Conjugate(x);
07501 }
07502 ctrrfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetDataVoid(), &m,
07503 b.GetDataVoid(), &m, x.GetDataVoid(), &m,
07504 &ferr, &berr, work.GetDataVoid(),
07505 rwork.GetData(), &info.GetInfoRef() );
07506 if (TransA.ConjTrans())
07507 {
07508 Conjugate(b);
07509 Conjugate(x);
07510 }
07511 }
07512
07513
07514 template <class Prop0, class Allocator0,
07515 class Allocator1, class Allocator2>
07516 void
07517 RefineSolutionLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
07518 const Matrix<complex<double>, Prop0, RowUpTriang,
07519 Allocator0>& A,
07520 Vector<complex<double>, VectFull, Allocator1>& x,
07521 Vector<complex<double>, VectFull, Allocator2>& b,
07522 double& ferr, double& berr,
07523 LapackInfo& info)
07524 {
07525
07526 #ifdef SELDON_CHECK_DIMENSIONS
07527 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07528 #endif
07529
07530 int m = A.GetM();
07531 int nrhs = 1;
07532 char uplo('L');
07533 char trans = TransA.RevChar(); char diag = DiagA.Char();
07534 Vector<complex<double>, VectFull, Allocator1> work(2*m);
07535 Vector<double> rwork(m);
07536 if (TransA.ConjTrans())
07537 {
07538 Conjugate(b);
07539 Conjugate(x);
07540 }
07541 ztrrfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetDataVoid(), &m,
07542 b.GetDataVoid(), &m, x.GetDataVoid(), &m,
07543 &ferr, &berr, work.GetDataVoid(),
07544 rwork.GetData(), &info.GetInfoRef() );
07545 if (TransA.ConjTrans())
07546 {
07547 Conjugate(b);
07548 Conjugate(x);
07549 }
07550 }
07551
07552
07553
07554
07555
07556 template <class Prop0, class Allocator0,
07557 class Allocator1, class Allocator2>
07558 void RefineSolutionLU(const Matrix<float, Prop0, RowLoTriang,
07559 Allocator0>& A,
07560 Vector<float, VectFull, Allocator1>& x,
07561 const Vector<float, VectFull, Allocator2>& b,
07562 float& ferr, float& berr,
07563 LapackInfo& info)
07564 {
07565
07566 #ifdef SELDON_CHECK_DIMENSIONS
07567 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07568 #endif
07569
07570 int m = A.GetM();
07571 int nrhs = 1;
07572 char uplo('U');
07573 char trans('T'); char diag('N');
07574 Vector<float, VectFull, Allocator1> work(3*m);
07575 Vector<int> iwork(m);
07576 strrfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetData(), &m,
07577 b.GetData(), &m, x.GetData(), &m,
07578 &ferr, &berr, work.GetData(),
07579 iwork.GetData(), &info.GetInfoRef() );
07580 }
07581
07582 template <class Prop0, class Allocator0,
07583 class Allocator1, class Allocator2>
07584 void RefineSolutionLU(const Matrix<double, Prop0, RowLoTriang,
07585 Allocator0>& A,
07586 Vector<double, VectFull, Allocator1>& x,
07587 const Vector<double, VectFull, Allocator2>& b,
07588 double& ferr, double& berr,
07589 LapackInfo& info)
07590 {
07591
07592 #ifdef SELDON_CHECK_DIMENSIONS
07593 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07594 #endif
07595
07596 int m = A.GetM();
07597 int nrhs = 1;
07598 char uplo('U');
07599 char trans('T'); char diag('N');
07600 Vector<double, VectFull, Allocator1> work(3*m);
07601 Vector<int> iwork(m);
07602 dtrrfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetData(), &m,
07603 b.GetData(), &m, x.GetData(), &m,
07604 &ferr, &berr, work.GetData(),
07605 iwork.GetData(), &info.GetInfoRef() );
07606 }
07607
07608
07609 template <class Prop0, class Allocator0,
07610 class Allocator1, class Allocator2>
07611 void
07612 RefineSolutionLU(const Matrix<complex<float>, Prop0, RowLoTriang,
07613 Allocator0>& A,
07614 Vector<complex<float>, VectFull, Allocator1>& x,
07615 const Vector<complex<float>, VectFull, Allocator2>& b,
07616 float& ferr, float& berr,
07617 LapackInfo& info)
07618 {
07619
07620 #ifdef SELDON_CHECK_DIMENSIONS
07621 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07622 #endif
07623
07624 int m = A.GetM();
07625 int nrhs = 1;
07626 char uplo('U');
07627 char trans('T'); char diag('N');
07628 Vector<complex<float>, VectFull, Allocator1> work(2*m);
07629 Vector<float> rwork(m);
07630 ctrrfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetDataVoid(), &m,
07631 b.GetDataVoid(), &m, x.GetDataVoid(), &m,
07632 &ferr, &berr, work.GetDataVoid(),
07633 rwork.GetData(), &info.GetInfoRef() );
07634 }
07635
07636
07637 template <class Prop0, class Allocator0,
07638 class Allocator1, class Allocator2>
07639 void
07640 RefineSolutionLU(const Matrix<complex<double>, Prop0, RowLoTriang,
07641 Allocator0>& A,
07642 Vector<complex<double>, VectFull, Allocator1>& x,
07643 const Vector<complex<double>, VectFull, Allocator2>& b,
07644 double& ferr, double& berr,
07645 LapackInfo& info)
07646 {
07647
07648 #ifdef SELDON_CHECK_DIMENSIONS
07649 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07650 #endif
07651
07652 int m = A.GetM();
07653 int nrhs = 1;
07654 char uplo('U');
07655 char trans('T'); char diag('N');
07656 Vector<complex<double>, VectFull, Allocator1> work(2*m);
07657 Vector<double> rwork(m);
07658 ztrrfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetDataVoid(), &m,
07659 b.GetDataVoid(), &m, x.GetDataVoid(), &m,
07660 &ferr, &berr, work.GetDataVoid(),
07661 rwork.GetData(), &info.GetInfoRef() );
07662 }
07663
07664
07665
07666
07667
07668 template <class Prop0, class Allocator0,
07669 class Allocator1, class Allocator2>
07670 void
07671 RefineSolutionLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
07672 const Matrix<float, Prop0, RowLoTriang,
07673 Allocator0>& A,
07674 Vector<float, VectFull, Allocator1>& x,
07675 const Vector<float, VectFull, Allocator2>& b,
07676 float& ferr, float& berr,
07677 LapackInfo& info)
07678 {
07679
07680 #ifdef SELDON_CHECK_DIMENSIONS
07681 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07682 #endif
07683
07684 int m = A.GetM();
07685 int nrhs = 1;
07686 char uplo('U');
07687 char trans = TransA.RevChar(); char diag = DiagA.Char();
07688 Vector<float, VectFull, Allocator1> work(3*m);
07689 Vector<int> iwork(m);
07690 strrfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetData(), &m,
07691 b.GetData(), &m, x.GetData(), &m,
07692 &ferr, &berr, work.GetData(),
07693 iwork.GetData(), &info.GetInfoRef() );
07694 }
07695
07696 template <class Prop0, class Allocator0,
07697 class Allocator1, class Allocator2>
07698 void
07699 RefineSolutionLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
07700 const Matrix<double, Prop0, RowLoTriang,
07701 Allocator0>& A,
07702 Vector<double, VectFull, Allocator1>& x,
07703 const Vector<double, VectFull, Allocator2>& b,
07704 double& ferr, double& berr,
07705 LapackInfo& info)
07706 {
07707
07708 #ifdef SELDON_CHECK_DIMENSIONS
07709 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07710 #endif
07711
07712 int m = A.GetM();
07713 int nrhs = 1;
07714 char uplo('U');
07715 char trans = TransA.RevChar(); char diag = DiagA.Char();
07716 Vector<double, VectFull, Allocator1> work(3*m);
07717 Vector<int> iwork(m);
07718 dtrrfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetData(), &m,
07719 b.GetData(), &m, x.GetData(), &m,
07720 &ferr, &berr, work.GetData(),
07721 iwork.GetData(), &info.GetInfoRef() );
07722 }
07723
07724
07725 template <class Prop0, class Allocator0,
07726 class Allocator1, class Allocator2>
07727 void
07728 RefineSolutionLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
07729 const Matrix<complex<float>, Prop0, RowLoTriang,
07730 Allocator0>& A,
07731 Vector<complex<float>, VectFull, Allocator1>& x,
07732 Vector<complex<float>, VectFull, Allocator2>& b,
07733 float& ferr, float& berr,
07734 LapackInfo& info)
07735 {
07736
07737 #ifdef SELDON_CHECK_DIMENSIONS
07738 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07739 #endif
07740
07741 int m = A.GetM();
07742 int nrhs = 1;
07743 char uplo('U');
07744 char trans = TransA.RevChar(); char diag = DiagA.Char();
07745 Vector<complex<float>, VectFull, Allocator1> work(2*m);
07746 Vector<float> rwork(m);
07747 if (TransA.ConjTrans())
07748 {
07749 Conjugate(b);
07750 Conjugate(x);
07751 }
07752 ctrrfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetDataVoid(), &m,
07753 b.GetDataVoid(), &m, x.GetDataVoid(), &m,
07754 &ferr, &berr, work.GetDataVoid(),
07755 rwork.GetData(), &info.GetInfoRef() );
07756 if (TransA.ConjTrans())
07757 {
07758 Conjugate(b);
07759 Conjugate(x);
07760 }
07761 }
07762
07763
07764 template <class Prop0, class Allocator0,
07765 class Allocator1, class Allocator2>
07766 void
07767 RefineSolutionLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
07768 const Matrix<complex<double>, Prop0, RowLoTriang,
07769 Allocator0>& A,
07770 Vector<complex<double>, VectFull, Allocator1>& x,
07771 Vector<complex<double>, VectFull, Allocator2>& b,
07772 double& ferr, double& berr,
07773 LapackInfo& info)
07774 {
07775
07776 #ifdef SELDON_CHECK_DIMENSIONS
07777 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07778 #endif
07779
07780 int m = A.GetM();
07781 int nrhs = 1;
07782 char uplo('U');
07783 char trans = TransA.RevChar(); char diag = DiagA.Char();
07784 Vector<complex<double>, VectFull, Allocator1> work(2*m);
07785 Vector<double> rwork(m);
07786 if (TransA.ConjTrans())
07787 {
07788 Conjugate(b);
07789 Conjugate(x);
07790 }
07791 ztrrfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetDataVoid(), &m,
07792 b.GetDataVoid(), &m, x.GetDataVoid(), &m,
07793 &ferr, &berr, work.GetDataVoid(),
07794 rwork.GetData(), &info.GetInfoRef() );
07795 if (TransA.ConjTrans())
07796 {
07797 Conjugate(b);
07798 Conjugate(x);
07799 }
07800 }
07801
07802
07803
07804
07805
07806 template <class Prop0, class Allocator0,
07807 class Allocator1, class Allocator2>
07808 void RefineSolutionLU(const Matrix<float, Prop0, RowUpTriangPacked,
07809 Allocator0>& A,
07810 Vector<float, VectFull, Allocator1>& x,
07811 const Vector<float, VectFull, Allocator2>& b,
07812 float& ferr, float& berr,
07813 LapackInfo& info)
07814 {
07815
07816 #ifdef SELDON_CHECK_DIMENSIONS
07817 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07818 #endif
07819
07820 int m = A.GetM();
07821 int nrhs = 1;
07822 char uplo('L');
07823 char trans('T'); char diag('N');
07824 Vector<float, VectFull, Allocator1> work(3*m);
07825 Vector<int> iwork(m);
07826 stprfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetData(),
07827 b.GetData(), &m, x.GetData(), &m,
07828 &ferr, &berr, work.GetData(),
07829 iwork.GetData(), &info.GetInfoRef() );
07830 }
07831
07832 template <class Prop0, class Allocator0,
07833 class Allocator1, class Allocator2>
07834 void RefineSolutionLU(const Matrix<double, Prop0, RowUpTriangPacked,
07835 Allocator0>& A,
07836 Vector<double, VectFull, Allocator1>& x,
07837 const Vector<double, VectFull, Allocator2>& b,
07838 double& ferr, double& berr,
07839 LapackInfo& info)
07840 {
07841
07842 #ifdef SELDON_CHECK_DIMENSIONS
07843 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07844 #endif
07845
07846 int m = A.GetM();
07847 int nrhs = 1;
07848 char uplo('L');
07849 char trans('T'); char diag('N');
07850 Vector<double, VectFull, Allocator1> work(3*m);
07851 Vector<int> iwork(m);
07852 dtprfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetData(),
07853 b.GetData(), &m, x.GetData(), &m,
07854 &ferr, &berr, work.GetData(),
07855 iwork.GetData(), &info.GetInfoRef() );
07856 }
07857
07858
07859 template <class Prop0, class Allocator0,
07860 class Allocator1, class Allocator2>
07861 void
07862 RefineSolutionLU(const Matrix<complex<float>, Prop0, RowUpTriangPacked,
07863 Allocator0>& A,
07864 Vector<complex<float>, VectFull, Allocator1>& x,
07865 const Vector<complex<float>, VectFull, Allocator2>& b,
07866 float& ferr, float& berr,
07867 LapackInfo& info)
07868 {
07869
07870 #ifdef SELDON_CHECK_DIMENSIONS
07871 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07872 #endif
07873
07874 int m = A.GetM();
07875 int nrhs = 1;
07876 char uplo('L');
07877 char trans('T'); char diag('N');
07878 Vector<complex<float>, VectFull, Allocator1> work(2*m);
07879 Vector<float> rwork(m);
07880 ctprfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetDataVoid(),
07881 b.GetDataVoid(), &m, x.GetDataVoid(), &m,
07882 &ferr, &berr, work.GetDataVoid(),
07883 rwork.GetData(), &info.GetInfoRef() );
07884 }
07885
07886
07887 template <class Prop0, class Allocator0,
07888 class Allocator1, class Allocator2>
07889 void
07890 RefineSolutionLU(const Matrix<complex<double>, Prop0, RowUpTriangPacked,
07891 Allocator0>& A,
07892 Vector<complex<double>, VectFull, Allocator1>& x,
07893 const Vector<complex<double>, VectFull, Allocator2>& b,
07894 double& ferr, double& berr,
07895 LapackInfo& info)
07896 {
07897
07898 #ifdef SELDON_CHECK_DIMENSIONS
07899 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07900 #endif
07901
07902 int m = A.GetM();
07903 int nrhs = 1;
07904 char uplo('L');
07905 char trans('T'); char diag('N');
07906 Vector<complex<double>, VectFull, Allocator1> work(2*m);
07907 Vector<double> rwork(m);
07908 ztprfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetDataVoid(),
07909 b.GetDataVoid(), &m, x.GetDataVoid(), &m,
07910 &ferr, &berr, work.GetDataVoid(),
07911 rwork.GetData(), &info.GetInfoRef() );
07912 }
07913
07914
07915
07916
07917
07918 template <class Prop0, class Allocator0,
07919 class Allocator1, class Allocator2>
07920 void
07921 RefineSolutionLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
07922 const Matrix<float, Prop0, RowUpTriangPacked,
07923 Allocator0>& A,
07924 Vector<float, VectFull, Allocator1>& x,
07925 const Vector<float, VectFull, Allocator2>& b,
07926 float& ferr, float& berr,
07927 LapackInfo& info)
07928 {
07929
07930 #ifdef SELDON_CHECK_DIMENSIONS
07931 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07932 #endif
07933
07934 int m = A.GetM();
07935 int nrhs = 1;
07936 char uplo('L');
07937 char trans = TransA.RevChar(); char diag = DiagA.Char();
07938 Vector<float, VectFull, Allocator1> work(3*m);
07939 Vector<int> iwork(m);
07940 stprfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetData(),
07941 b.GetData(), &m, x.GetData(), &m,
07942 &ferr, &berr, work.GetData(),
07943 iwork.GetData(), &info.GetInfoRef() );
07944 }
07945
07946 template <class Prop0, class Allocator0,
07947 class Allocator1, class Allocator2>
07948 void
07949 RefineSolutionLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
07950 const Matrix<double, Prop0, RowUpTriangPacked,
07951 Allocator0>& A,
07952 Vector<double, VectFull, Allocator1>& x,
07953 const Vector<double, VectFull, Allocator2>& b,
07954 double& ferr, double& berr,
07955 LapackInfo& info)
07956 {
07957
07958 #ifdef SELDON_CHECK_DIMENSIONS
07959 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07960 #endif
07961
07962 int m = A.GetM();
07963 int nrhs = 1;
07964 char uplo('L');
07965 char trans = TransA.RevChar(); char diag = DiagA.Char();
07966 Vector<double, VectFull, Allocator1> work(3*m);
07967 Vector<int> iwork(m);
07968 dtprfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetData(),
07969 b.GetData(), &m, x.GetData(), &m,
07970 &ferr, &berr, work.GetData(),
07971 iwork.GetData(), &info.GetInfoRef() );
07972 }
07973
07974
07975 template <class Prop0, class Allocator0,
07976 class Allocator1, class Allocator2>
07977 void
07978 RefineSolutionLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
07979 const Matrix<complex<float>, Prop0, RowUpTriangPacked,
07980 Allocator0>& A,
07981 Vector<complex<float>, VectFull, Allocator1>& x,
07982 Vector<complex<float>, VectFull, Allocator2>& b,
07983 float& ferr, float& berr,
07984 LapackInfo& info)
07985 {
07986
07987 #ifdef SELDON_CHECK_DIMENSIONS
07988 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
07989 #endif
07990
07991 int m = A.GetM();
07992 int nrhs = 1;
07993 char uplo('L');
07994 char trans = TransA.RevChar(); char diag = DiagA.Char();
07995 Vector<complex<float>, VectFull, Allocator1> work(2*m);
07996 Vector<float> rwork(m);
07997 if (TransA.ConjTrans())
07998 {
07999 Conjugate(b);
08000 Conjugate(x);
08001 }
08002 ctprfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetDataVoid(),
08003 b.GetDataVoid(), &m, x.GetDataVoid(), &m,
08004 &ferr, &berr, work.GetDataVoid(),
08005 rwork.GetData(), &info.GetInfoRef() );
08006 if (TransA.ConjTrans())
08007 {
08008 Conjugate(b);
08009 Conjugate(x);
08010 }
08011 }
08012
08013
08014 template <class Prop0, class Allocator0,
08015 class Allocator1, class Allocator2>
08016 void
08017 RefineSolutionLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
08018 const Matrix<complex<double>, Prop0, RowUpTriangPacked,
08019 Allocator0>& A,
08020 Vector<complex<double>, VectFull, Allocator1>& x,
08021 Vector<complex<double>, VectFull, Allocator2>& b,
08022 double& ferr, double& berr,
08023 LapackInfo& info)
08024 {
08025
08026 #ifdef SELDON_CHECK_DIMENSIONS
08027 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
08028 #endif
08029
08030 int m = A.GetM();
08031 int nrhs = 1;
08032 char uplo('L');
08033 char trans = TransA.RevChar(); char diag = DiagA.Char();
08034 Vector<complex<double>, VectFull, Allocator1> work(2*m);
08035 Vector<double> rwork(m);
08036 if (TransA.ConjTrans())
08037 {
08038 Conjugate(b);
08039 Conjugate(x);
08040 }
08041 ztprfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetDataVoid(),
08042 b.GetDataVoid(), &m, x.GetDataVoid(), &m,
08043 &ferr, &berr, work.GetDataVoid(),
08044 rwork.GetData(), &info.GetInfoRef() );
08045 if (TransA.ConjTrans())
08046 {
08047 Conjugate(b);
08048 Conjugate(x);
08049 }
08050 }
08051
08052
08053
08054
08055
08056 template <class Prop0, class Allocator0,
08057 class Allocator1, class Allocator2>
08058 void RefineSolutionLU(const Matrix<float, Prop0, RowLoTriangPacked,
08059 Allocator0>& A,
08060 Vector<float, VectFull, Allocator1>& x,
08061 const Vector<float, VectFull, Allocator2>& b,
08062 float& ferr, float& berr,
08063 LapackInfo& info)
08064 {
08065
08066 #ifdef SELDON_CHECK_DIMENSIONS
08067 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
08068 #endif
08069
08070 int m = A.GetM();
08071 int nrhs = 1;
08072 char uplo('U');
08073 char trans('T'); char diag('N');
08074 Vector<float, VectFull, Allocator1> work(3*m);
08075 Vector<int> iwork(m);
08076 stprfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetData(),
08077 b.GetData(), &m, x.GetData(), &m,
08078 &ferr, &berr, work.GetData(),
08079 iwork.GetData(), &info.GetInfoRef() );
08080 }
08081
08082 template <class Prop0, class Allocator0,
08083 class Allocator1, class Allocator2>
08084 void RefineSolutionLU(const Matrix<double, Prop0, RowLoTriangPacked,
08085 Allocator0>& A,
08086 Vector<double, VectFull, Allocator1>& x,
08087 const Vector<double, VectFull, Allocator2>& b,
08088 double& ferr, double& berr,
08089 LapackInfo& info)
08090 {
08091
08092 #ifdef SELDON_CHECK_DIMENSIONS
08093 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
08094 #endif
08095
08096 int m = A.GetM();
08097 int nrhs = 1;
08098 char uplo('U');
08099 char trans('T'); char diag('N');
08100 Vector<double, VectFull, Allocator1> work(3*m);
08101 Vector<int> iwork(m);
08102 dtprfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetData(),
08103 b.GetData(), &m, x.GetData(), &m,
08104 &ferr, &berr, work.GetData(),
08105 iwork.GetData(), &info.GetInfoRef() );
08106 }
08107
08108
08109 template <class Prop0, class Allocator0,
08110 class Allocator1, class Allocator2>
08111 void
08112 RefineSolutionLU(const Matrix<complex<float>, Prop0, RowLoTriangPacked,
08113 Allocator0>& A,
08114 Vector<complex<float>, VectFull, Allocator1>& x,
08115 const Vector<complex<float>, VectFull, Allocator2>& b,
08116 float& ferr, float& berr,
08117 LapackInfo& info)
08118 {
08119
08120 #ifdef SELDON_CHECK_DIMENSIONS
08121 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
08122 #endif
08123
08124 int m = A.GetM();
08125 int nrhs = 1;
08126 char uplo('U');
08127 char trans('T'); char diag('N');
08128 Vector<complex<float>, VectFull, Allocator1> work(2*m);
08129 Vector<float> rwork(m);
08130 ctprfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetDataVoid(),
08131 b.GetDataVoid(), &m, x.GetDataVoid(), &m,
08132 &ferr, &berr, work.GetDataVoid(),
08133 rwork.GetData(), &info.GetInfoRef() );
08134 }
08135
08136
08137 template <class Prop0, class Allocator0,
08138 class Allocator1, class Allocator2>
08139 void
08140 RefineSolutionLU(const Matrix<complex<double>, Prop0, RowLoTriangPacked,
08141 Allocator0>& A,
08142 Vector<complex<double>, VectFull, Allocator1>& x,
08143 const Vector<complex<double>, VectFull, Allocator2>& b,
08144 double& ferr, double& berr,
08145 LapackInfo& info)
08146 {
08147
08148 #ifdef SELDON_CHECK_DIMENSIONS
08149 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
08150 #endif
08151
08152 int m = A.GetM();
08153 int nrhs = 1;
08154 char uplo('U');
08155 char trans('T'); char diag('N');
08156 Vector<complex<double>, VectFull, Allocator1> work(2*m);
08157 Vector<double> rwork(m);
08158 ztprfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetDataVoid(),
08159 b.GetDataVoid(), &m, x.GetDataVoid(), &m,
08160 &ferr, &berr, work.GetDataVoid(),
08161 rwork.GetData(), &info.GetInfoRef() );
08162 }
08163
08164
08165
08166
08167
08168 template <class Prop0, class Allocator0,
08169 class Allocator1, class Allocator2>
08170 void
08171 RefineSolutionLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
08172 const Matrix<float, Prop0, RowLoTriangPacked,
08173 Allocator0>& A,
08174 Vector<float, VectFull, Allocator1>& x,
08175 const Vector<float, VectFull, Allocator2>& b,
08176 float& ferr, float& berr,
08177 LapackInfo& info)
08178 {
08179
08180 #ifdef SELDON_CHECK_DIMENSIONS
08181 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
08182 #endif
08183
08184 int m = A.GetM();
08185 int nrhs = 1;
08186 char uplo('U');
08187 char trans = TransA.RevChar(); char diag = DiagA.Char();
08188 Vector<float, VectFull, Allocator1> work(3*m);
08189 Vector<int> iwork(m);
08190 stprfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetData(),
08191 b.GetData(), &m, x.GetData(), &m,
08192 &ferr, &berr, work.GetData(),
08193 iwork.GetData(), &info.GetInfoRef() );
08194 }
08195
08196 template <class Prop0, class Allocator0,
08197 class Allocator1, class Allocator2>
08198 void
08199 RefineSolutionLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
08200 const Matrix<double, Prop0, RowLoTriangPacked,
08201 Allocator0>& A,
08202 Vector<double, VectFull, Allocator1>& x,
08203 const Vector<double, VectFull, Allocator2>& b,
08204 double& ferr, double& berr,
08205 LapackInfo& info)
08206 {
08207
08208 #ifdef SELDON_CHECK_DIMENSIONS
08209 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
08210 #endif
08211
08212 int m = A.GetM();
08213 int nrhs = 1;
08214 char uplo('U');
08215 char trans = TransA.RevChar(); char diag = DiagA.Char();
08216 Vector<double, VectFull, Allocator1> work(3*m);
08217 Vector<int> iwork(m);
08218 dtprfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetData(),
08219 b.GetData(), &m, x.GetData(), &m,
08220 &ferr, &berr, work.GetData(),
08221 iwork.GetData(), &info.GetInfoRef() );
08222 }
08223
08224
08225 template <class Prop0, class Allocator0,
08226 class Allocator1, class Allocator2>
08227 void
08228 RefineSolutionLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
08229 const Matrix<complex<float>, Prop0, RowLoTriangPacked,
08230 Allocator0>& A,
08231 Vector<complex<float>, VectFull, Allocator1>& x,
08232 Vector<complex<float>, VectFull, Allocator2>& b,
08233 float& ferr, float& berr,
08234 LapackInfo& info)
08235 {
08236
08237 #ifdef SELDON_CHECK_DIMENSIONS
08238 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
08239 #endif
08240
08241 int m = A.GetM();
08242 int nrhs = 1;
08243 char uplo('U');
08244 char trans = TransA.RevChar(); char diag = DiagA.Char();
08245 Vector<complex<float>, VectFull, Allocator1> work(2*m);
08246 Vector<float> rwork(m);
08247 if (TransA.ConjTrans())
08248 {
08249 Conjugate(b);
08250 Conjugate(x);
08251 }
08252 ctprfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetDataVoid(),
08253 b.GetDataVoid(), &m, x.GetDataVoid(), &m,
08254 &ferr, &berr, work.GetDataVoid(),
08255 rwork.GetData(), &info.GetInfoRef() );
08256 if (TransA.ConjTrans())
08257 {
08258 Conjugate(b);
08259 Conjugate(x);
08260 }
08261 }
08262
08263
08264 template <class Prop0, class Allocator0,
08265 class Allocator1, class Allocator2>
08266 void
08267 RefineSolutionLU(const SeldonTranspose& TransA, const SeldonDiag& DiagA,
08268 const Matrix<complex<double>, Prop0, RowLoTriangPacked,
08269 Allocator0>& A,
08270 Vector<complex<double>, VectFull, Allocator1>& x,
08271 Vector<complex<double>, VectFull, Allocator2>& b,
08272 double& ferr, double& berr,
08273 LapackInfo& info)
08274 {
08275
08276 #ifdef SELDON_CHECK_DIMENSIONS
08277 CheckDim(A, x, b, "RefineSolutionLU(A, Alu, X, Y)");
08278 #endif
08279
08280 int m = A.GetM();
08281 int nrhs = 1;
08282 char uplo('U');
08283 char trans = TransA.RevChar(); char diag = DiagA.Char();
08284 Vector<complex<double>, VectFull, Allocator1> work(2*m);
08285 Vector<double> rwork(m);
08286 if (TransA.ConjTrans())
08287 {
08288 Conjugate(b);
08289 Conjugate(x);
08290 }
08291 ztprfs_(&uplo, &trans, &diag, &m, &nrhs, A.GetDataVoid(),
08292 b.GetDataVoid(), &m, x.GetDataVoid(), &m,
08293 &ferr, &berr, work.GetDataVoid(),
08294 rwork.GetData(), &info.GetInfoRef() );
08295 if (TransA.ConjTrans())
08296 {
08297 Conjugate(b);
08298 Conjugate(x);
08299 }
08300 }
08301
08302
08303
08305
08306
08307
08309
08310
08311
08312
08313
08314
08315 template <class Prop0, class Allocator0>
08316 void GetInverse(Matrix<float, Prop0, ColMajor, Allocator0>& A,
08317 LapackInfo& info)
08318 {
08319 int m = A.GetM();
08320 Vector<int, VectFull, CallocAlloc<int> > pivot;
08321 Vector<float, VectFull, Allocator0> work(m);
08322 GetLU(A, pivot, info);
08323 sgetri_(&m, A.GetData(), &m, pivot.GetData(), work.GetData(), &m,
08324 &info.GetInfoRef());
08325
08326 #ifdef SELDON_LAPACK_CHECK_INFO
08327 if (info.GetInfo() != 0)
08328 throw LapackError(info.GetInfo(), "GetInverse",
08329 "The matrix is inversible ? ");
08330 #endif
08331
08332 }
08333
08334
08335 template <class Prop0, class Allocator0>
08336 void GetInverse(Matrix<double, Prop0, ColMajor, Allocator0>& A,
08337 LapackInfo& info)
08338 {
08339 int m = A.GetM();
08340 Vector<int, VectFull, CallocAlloc<int> > pivot;
08341 Vector<double, VectFull, Allocator0> work(m);
08342 GetLU(A, pivot, info);
08343 dgetri_(&m, A.GetData(), &m, pivot.GetData(), work.GetData(), &m,
08344 &info.GetInfoRef());
08345
08346 #ifdef SELDON_LAPACK_CHECK_INFO
08347 if (info.GetInfo() != 0)
08348 throw LapackError(info.GetInfo(), "GetInverse",
08349 "The matrix is inversible ? ");
08350 #endif
08351
08352 }
08353
08354
08355 template <class Prop0, class Allocator0>
08356 void GetInverse(Matrix<complex<float>, Prop0, ColMajor, Allocator0>& A,
08357 LapackInfo& info)
08358 {
08359 int m = A.GetM();
08360 Vector<int, VectFull, CallocAlloc<int> > pivot;
08361 Vector<complex<float>, VectFull, Allocator0> work(m);
08362 GetLU(A, pivot, info);
08363 cgetri_(&m, A.GetDataVoid(), &m, pivot.GetData(),
08364 work.GetDataVoid(), &m, &info.GetInfoRef());
08365
08366 #ifdef SELDON_LAPACK_CHECK_INFO
08367 if (info.GetInfo() != 0)
08368 throw LapackError(info.GetInfo(), "GetInverse",
08369 "The matrix is inversible ? ");
08370 #endif
08371
08372 }
08373
08374
08375 template <class Prop0, class Allocator0>
08376 void GetInverse(Matrix<complex<double>, Prop0, ColMajor, Allocator0>& A,
08377 LapackInfo& info)
08378 {
08379 int m = A.GetM();
08380 Vector<int, VectFull, CallocAlloc<int> > pivot;
08381 Vector<complex<double>, VectFull, Allocator0> work(m);
08382 GetLU(A, pivot, info);
08383 zgetri_(&m, A.GetDataVoid(), &m, pivot.GetData(),
08384 work.GetDataVoid(), &m, &info.GetInfoRef());
08385
08386 #ifdef SELDON_LAPACK_CHECK_INFO
08387 if (info.GetInfo() != 0)
08388 throw LapackError(info.GetInfo(), "GetInverse",
08389 "The matrix is inversible ? ");
08390 #endif
08391
08392 }
08393
08394
08395
08396
08397
08398 template <class Prop0, class Allocator0>
08399 void GetInverse(Matrix<float, Prop0, RowMajor, Allocator0>& A,
08400 LapackInfo& info)
08401 {
08402 int m = A.GetM();
08403 Vector<int, VectFull, CallocAlloc<int> > pivot;
08404 Vector<float, VectFull, Allocator0> work(m);
08405 GetLU(A, pivot, info);
08406 sgetri_(&m, A.GetData(), &m, pivot.GetData(), work.GetData(), &m,
08407 &info.GetInfoRef());
08408
08409 #ifdef SELDON_LAPACK_CHECK_INFO
08410 if (info.GetInfo() != 0)
08411 throw LapackError(info.GetInfo(), "GetInverse",
08412 "The matrix is inversible ? ");
08413 #endif
08414
08415 }
08416
08417
08418 template <class Prop0, class Allocator0>
08419 void GetInverse(Matrix<double, Prop0, RowMajor, Allocator0>& A,
08420 LapackInfo& info)
08421 {
08422 int m = A.GetM();
08423 Vector<int, VectFull, CallocAlloc<int> > pivot;
08424 Vector<double, VectFull, Allocator0> work(m);
08425 GetLU(A, pivot, info);
08426 dgetri_(&m, A.GetData(), &m, pivot.GetData(), work.GetData(), &m,
08427 &info.GetInfoRef());
08428
08429 #ifdef SELDON_LAPACK_CHECK_INFO
08430 if (info.GetInfo() != 0)
08431 throw LapackError(info.GetInfo(), "GetInverse",
08432 "The matrix is inversible ? ");
08433 #endif
08434
08435 }
08436
08437
08438 template <class Prop0, class Allocator0>
08439 void GetInverse(Matrix<complex<float>, Prop0, RowMajor, Allocator0>& A,
08440 LapackInfo& info)
08441 {
08442 int m = A.GetM();
08443 Vector<int, VectFull, CallocAlloc<int> > pivot;
08444 Vector<complex<float>, VectFull, Allocator0> work(m);
08445 GetLU(A, pivot, info);
08446 cgetri_(&m, A.GetDataVoid(), &m, pivot.GetData(),
08447 work.GetDataVoid(), &m, &info.GetInfoRef());
08448
08449 #ifdef SELDON_LAPACK_CHECK_INFO
08450 if (info.GetInfo() != 0)
08451 throw LapackError(info.GetInfo(), "GetInverse",
08452 "The matrix is inversible ? ");
08453 #endif
08454
08455 }
08456
08457
08458 template <class Prop0, class Allocator0>
08459 void GetInverse(Matrix<complex<double>, Prop0, RowMajor, Allocator0>& A,
08460 LapackInfo& info)
08461 {
08462 int m = A.GetM();
08463 Vector<int, VectFull, CallocAlloc<int> > pivot;
08464 Vector<complex<double>, VectFull, Allocator0> work(m);
08465 GetLU(A, pivot, info);
08466 zgetri_(&m, A.GetDataVoid(), &m, pivot.GetData(),
08467 work.GetDataVoid(), &m, &info.GetInfoRef());
08468
08469 #ifdef SELDON_LAPACK_CHECK_INFO
08470 if (info.GetInfo() != 0)
08471 throw LapackError(info.GetInfo(), "GetInverse",
08472 "The matrix is inversible ? ");
08473 #endif
08474
08475 }
08476
08477
08478
08479
08480
08481 template <class Prop0, class Allocator0>
08482 void GetInverse(Matrix<float, Prop0, ColSym, Allocator0>& A,
08483 LapackInfo& info)
08484 {
08485 int m = A.GetM();
08486 char uplo('U');
08487 Vector<int, VectFull, CallocAlloc<int> > pivot;
08488 Vector<float, VectFull, Allocator0> work(2*m);
08489 GetLU(A, pivot, info);
08490 ssytri_(&uplo, &m, A.GetData(), &m, pivot.GetData(), work.GetData(),
08491 &info.GetInfoRef());
08492
08493 #ifdef SELDON_LAPACK_CHECK_INFO
08494 if (info.GetInfo() != 0)
08495 throw LapackError(info.GetInfo(), "GetInverse",
08496 "The matrix is inversible ? ");
08497 #endif
08498
08499 }
08500
08501
08502 template <class Prop0, class Allocator0>
08503 void GetInverse(Matrix<double, Prop0, ColSym, Allocator0>& A,
08504 LapackInfo& info)
08505 {
08506 int m = A.GetM();
08507 char uplo('U');
08508 Vector<int, VectFull, CallocAlloc<int> > pivot;
08509 Vector<double, VectFull, Allocator0> work(2*m);
08510 GetLU(A, pivot, info);
08511 dsytri_(&uplo, &m, A.GetData(), &m, pivot.GetData(), work.GetData(),
08512 &info.GetInfoRef());
08513
08514 #ifdef SELDON_LAPACK_CHECK_INFO
08515 if (info.GetInfo() != 0)
08516 throw LapackError(info.GetInfo(), "GetInverse",
08517 "The matrix is inversible ? ");
08518 #endif
08519
08520 }
08521
08522
08523 template <class Prop0, class Allocator0>
08524 void GetInverse(Matrix<complex<float>, Prop0, ColSym, Allocator0>& A,
08525 LapackInfo& info)
08526 {
08527 int m = A.GetM();
08528 char uplo('U');
08529 Vector<int, VectFull, CallocAlloc<int> > pivot;
08530 Vector<complex<float>, VectFull, Allocator0> work(2*m);
08531 GetLU(A, pivot, info);
08532 csytri_(&uplo, &m, A.GetDataVoid(), &m, pivot.GetData(),
08533 work.GetDataVoid(), &info.GetInfoRef());
08534
08535 #ifdef SELDON_LAPACK_CHECK_INFO
08536 if (info.GetInfo() != 0)
08537 throw LapackError(info.GetInfo(), "GetInverse",
08538 "The matrix is inversible ? ");
08539 #endif
08540
08541 }
08542
08543
08544 template <class Prop0, class Allocator0>
08545 void GetInverse(Matrix<complex<double>, Prop0, ColSym, Allocator0>& A,
08546 LapackInfo& info)
08547 {
08548 int m = A.GetM();
08549 char uplo('U');
08550 Vector<int, VectFull, CallocAlloc<int> > pivot;
08551 Vector<complex<double>, VectFull, Allocator0> work(2*m);
08552 GetLU(A, pivot, info);
08553 zsytri_(&uplo, &m, A.GetDataVoid(), &m, pivot.GetData(),
08554 work.GetDataVoid(), &info.GetInfoRef());
08555
08556 #ifdef SELDON_LAPACK_CHECK_INFO
08557 if (info.GetInfo() != 0)
08558 throw LapackError(info.GetInfo(), "GetInverse",
08559 "The matrix is inversible ? ");
08560 #endif
08561
08562 }
08563
08564
08565
08566
08567
08568 template <class Prop0, class Allocator0>
08569 void GetInverse(Matrix<float, Prop0, ColSymPacked, Allocator0>& A,
08570 LapackInfo& info)
08571 {
08572 int m = A.GetM();
08573 char uplo('U');
08574 Vector<int, VectFull, CallocAlloc<int> > pivot;
08575 Vector<float, VectFull, Allocator0> work(m);
08576 GetLU(A, pivot, info);
08577 ssptri_(&uplo, &m, A.GetData(), pivot.GetData(), work.GetData(),
08578 &info.GetInfoRef());
08579
08580 #ifdef SELDON_LAPACK_CHECK_INFO
08581 if (info.GetInfo() != 0)
08582 throw LapackError(info.GetInfo(), "GetInverse",
08583 "The matrix is inversible ? ");
08584 #endif
08585
08586 }
08587
08588
08589 template <class Prop0, class Allocator0>
08590 void GetInverse(Matrix<double, Prop0, ColSymPacked, Allocator0>& A,
08591 LapackInfo& info)
08592 {
08593 int m = A.GetM();
08594 char uplo('U');
08595 Vector<int, VectFull, CallocAlloc<int> > pivot;
08596 Vector<double, VectFull, Allocator0> work(m);
08597 GetLU(A, pivot, info);
08598 dsptri_(&uplo, &m, A.GetData(), pivot.GetData(), work.GetData(),
08599 &info.GetInfoRef());
08600
08601 #ifdef SELDON_LAPACK_CHECK_INFO
08602 if (info.GetInfo() != 0)
08603 throw LapackError(info.GetInfo(), "GetInverse",
08604 "The matrix is inversible ? ");
08605 #endif
08606
08607 }
08608
08609
08610 template <class Prop0, class Allocator0>
08611 void GetInverse(Matrix<complex<float>, Prop0, ColSymPacked, Allocator0>& A,
08612 LapackInfo& info)
08613 {
08614 int m = A.GetM();
08615 char uplo('U');
08616 Vector<int, VectFull, CallocAlloc<int> > pivot;
08617 Vector<complex<float>, VectFull, Allocator0> work(m);
08618 GetLU(A, pivot, info);
08619 csptri_(&uplo, &m, A.GetDataVoid(), pivot.GetData(),
08620 work.GetDataVoid(), &info.GetInfoRef());
08621
08622 #ifdef SELDON_LAPACK_CHECK_INFO
08623 if (info.GetInfo() != 0)
08624 throw LapackError(info.GetInfo(), "GetInverse",
08625 "The matrix is inversible ? ");
08626 #endif
08627
08628 }
08629
08630
08631 template <class Prop0, class Allocator0>
08632 void GetInverse(Matrix<complex<double>, Prop0, ColSymPacked, Allocator0>& A,
08633 LapackInfo& info)
08634 {
08635 int m = A.GetM();
08636 char uplo('U');
08637 Vector<int, VectFull, CallocAlloc<int> > pivot;
08638 Vector<complex<double>, VectFull, Allocator0> work(m);
08639 GetLU(A, pivot, info);
08640 zsptri_(&uplo, &m, A.GetDataVoid(), pivot.GetData(),
08641 work.GetDataVoid(), &info.GetInfoRef());
08642
08643 #ifdef SELDON_LAPACK_CHECK_INFO
08644 if (info.GetInfo() != 0)
08645 throw LapackError(info.GetInfo(), "GetInverse",
08646 "The matrix is inversible ? ");
08647 #endif
08648
08649 }
08650
08651
08652
08653
08654
08655 template <class Prop0, class Allocator0>
08656 void GetInverse(Matrix<float, Prop0, RowSym, Allocator0>& A,
08657 LapackInfo& info)
08658 {
08659 int m = A.GetM();
08660 char uplo('L');
08661 Vector<int, VectFull, CallocAlloc<int> > pivot;
08662 Vector<float, VectFull, Allocator0> work(2*m);
08663 GetLU(A, pivot, info);
08664 ssytri_(&uplo, &m, A.GetData(), &m, pivot.GetData(), work.GetData(),
08665 &info.GetInfoRef());
08666
08667 #ifdef SELDON_LAPACK_CHECK_INFO
08668 if (info.GetInfo() != 0)
08669 throw LapackError(info.GetInfo(), "GetInverse",
08670 "The matrix is inversible ? ");
08671 #endif
08672
08673 }
08674
08675
08676 template <class Prop0, class Allocator0>
08677 void GetInverse(Matrix<double, Prop0, RowSym, Allocator0>& A,
08678 LapackInfo& info)
08679 {
08680 int m = A.GetM();
08681 char uplo('L');
08682 Vector<int, VectFull, CallocAlloc<int> > pivot;
08683 Vector<double, VectFull, Allocator0> work(2*m);
08684 GetLU(A, pivot, info);
08685 dsytri_(&uplo, &m, A.GetData(), &m, pivot.GetData(), work.GetData(),
08686 &info.GetInfoRef());
08687
08688 #ifdef SELDON_LAPACK_CHECK_INFO
08689 if (info.GetInfo() != 0)
08690 throw LapackError(info.GetInfo(), "GetInverse",
08691 "The matrix is inversible ? ");
08692 #endif
08693
08694 }
08695
08696
08697 template <class Prop0, class Allocator0>
08698 void GetInverse(Matrix<complex<float>, Prop0, RowSym, Allocator0>& A,
08699 LapackInfo& info)
08700 {
08701 int m = A.GetM();
08702 char uplo('L');
08703 Vector<int, VectFull, CallocAlloc<int> > pivot;
08704 Vector<complex<float>, VectFull, Allocator0> work(2*m);
08705 GetLU(A, pivot, info);
08706 csytri_(&uplo, &m, A.GetDataVoid(), &m, pivot.GetData(),
08707 work.GetDataVoid(), &info.GetInfoRef());
08708
08709 #ifdef SELDON_LAPACK_CHECK_INFO
08710 if (info.GetInfo() != 0)
08711 throw LapackError(info.GetInfo(), "GetInverse",
08712 "The matrix is inversible ? ");
08713 #endif
08714
08715 }
08716
08717
08718 template <class Prop0, class Allocator0>
08719 void GetInverse(Matrix<complex<double>, Prop0, RowSym, Allocator0>& A,
08720 LapackInfo& info)
08721 {
08722 int m = A.GetM();
08723 char uplo('L');
08724 Vector<int, VectFull, CallocAlloc<int> > pivot;
08725 Vector<complex<double>, VectFull, Allocator0> work(2*m);
08726 GetLU(A, pivot, info);
08727 zsytri_(&uplo, &m, A.GetDataVoid(), &m, pivot.GetData(),
08728 work.GetDataVoid(), &info.GetInfoRef());
08729
08730 #ifdef SELDON_LAPACK_CHECK_INFO
08731 if (info.GetInfo() != 0)
08732 throw LapackError(info.GetInfo(), "GetInverse",
08733 "The matrix is inversible ? ");
08734 #endif
08735
08736 }
08737
08738
08739
08740
08741
08742 template <class Prop0, class Allocator0>
08743 void GetInverse(Matrix<float, Prop0, RowSymPacked, Allocator0>& A,
08744 LapackInfo& info)
08745 {
08746 int m = A.GetM();
08747 char uplo('L');
08748 Vector<int, VectFull, CallocAlloc<int> > pivot;
08749 Vector<float, VectFull, Allocator0> work(m);
08750 GetLU(A, pivot, info);
08751 ssptri_(&uplo, &m, A.GetData(), pivot.GetData(), work.GetData(),
08752 &info.GetInfoRef());
08753
08754 #ifdef SELDON_LAPACK_CHECK_INFO
08755 if (info.GetInfo() != 0)
08756 throw LapackError(info.GetInfo(), "GetInverse",
08757 "The matrix is inversible ? ");
08758 #endif
08759
08760 }
08761
08762
08763 template <class Prop0, class Allocator0>
08764 void GetInverse(Matrix<double, Prop0, RowSymPacked, Allocator0>& A,
08765 LapackInfo& info)
08766 {
08767 int m = A.GetM();
08768 char uplo('L');
08769 Vector<int, VectFull, CallocAlloc<int> > pivot;
08770 Vector<double, VectFull, Allocator0> work(m);
08771 GetLU(A, pivot, info);
08772 dsptri_(&uplo, &m, A.GetData(), pivot.GetData(), work.GetData(),
08773 &info.GetInfoRef());
08774
08775 #ifdef SELDON_LAPACK_CHECK_INFO
08776 if (info.GetInfo() != 0)
08777 throw LapackError(info.GetInfo(), "GetInverse",
08778 "The matrix is inversible ? ");
08779 #endif
08780
08781 }
08782
08783
08784 template <class Prop0, class Allocator0>
08785 void GetInverse(Matrix<complex<float>, Prop0, RowSymPacked, Allocator0>& A,
08786 LapackInfo& info)
08787 {
08788 int m = A.GetM();
08789 char uplo('L');
08790 Vector<int, VectFull, CallocAlloc<int> > pivot;
08791 Vector<complex<float>, VectFull, Allocator0> work(m);
08792 GetLU(A, pivot, info);
08793 csptri_(&uplo, &m, A.GetDataVoid(), pivot.GetData(),
08794 work.GetDataVoid(), &info.GetInfoRef());
08795
08796 #ifdef SELDON_LAPACK_CHECK_INFO
08797 if (info.GetInfo() != 0)
08798 throw LapackError(info.GetInfo(), "GetInverse",
08799 "The matrix is inversible ? ");
08800 #endif
08801
08802 }
08803
08804
08805 template <class Prop0, class Allocator0>
08806 void GetInverse(Matrix<complex<double>, Prop0, RowSymPacked, Allocator0>& A,
08807 LapackInfo& info)
08808 {
08809 int m = A.GetM();
08810 char uplo('L');
08811 Vector<int, VectFull, CallocAlloc<int> > pivot;
08812 Vector<complex<double>, VectFull, Allocator0> work(m);
08813 GetLU(A, pivot, info);
08814 zsptri_(&uplo, &m, A.GetDataVoid(), pivot.GetData(),
08815 work.GetDataVoid(), &info.GetInfoRef());
08816
08817 #ifdef SELDON_LAPACK_CHECK_INFO
08818 if (info.GetInfo() != 0)
08819 throw LapackError(info.GetInfo(), "GetInverse",
08820 "The matrix is inversible ? ");
08821 #endif
08822
08823 }
08824
08825
08826
08827
08828
08829 template <class Prop0, class Allocator0>
08830 void GetInverse(Matrix<complex<float>, Prop0, ColHerm, Allocator0>& A,
08831 LapackInfo& info)
08832 {
08833 int m = A.GetM();
08834 char uplo('U');
08835 Vector<int, VectFull, CallocAlloc<int> > pivot;
08836 Vector<complex<float>, VectFull, Allocator0> work(m);
08837 GetLU(A, pivot, info);
08838 chetri_(&uplo, &m, A.GetDataVoid(), &m, pivot.GetData(),
08839 work.GetDataVoid(), &info.GetInfoRef());
08840
08841 #ifdef SELDON_LAPACK_CHECK_INFO
08842 if (info.GetInfo() != 0)
08843 throw LapackError(info.GetInfo(), "GetInverse",
08844 "The matrix is inversible ? ");
08845 #endif
08846
08847 }
08848
08849
08850 template <class Prop0, class Allocator0>
08851 void GetInverse(Matrix<complex<double>, Prop0, ColHerm, Allocator0>& A,
08852 LapackInfo& info)
08853 {
08854 int m = A.GetM();
08855 char uplo('U');
08856 Vector<int, VectFull, CallocAlloc<int> > pivot;
08857 Vector<complex<double>, VectFull, Allocator0> work(m);
08858 GetLU(A, pivot, info);
08859 zhetri_(&uplo, &m, A.GetDataVoid(), &m, pivot.GetData(),
08860 work.GetDataVoid(), &info.GetInfoRef());
08861
08862 #ifdef SELDON_LAPACK_CHECK_INFO
08863 if (info.GetInfo() != 0)
08864 throw LapackError(info.GetInfo(), "GetInverse",
08865 "The matrix is inversible ? ");
08866 #endif
08867
08868 }
08869
08870
08871
08872
08873
08874 template <class Prop0, class Allocator0>
08875 void GetInverse(Matrix<complex<float>, Prop0, ColHermPacked,
08876 Allocator0>& A,
08877 LapackInfo& info)
08878 {
08879 int m = A.GetM();
08880 char uplo('U');
08881 Vector<int, VectFull, CallocAlloc<int> > pivot;
08882 Vector<complex<float>, VectFull, Allocator0> work(m);
08883 GetLU(A, pivot, info);
08884 chptri_(&uplo, &m, A.GetDataVoid(), pivot.GetData(),
08885 work.GetDataVoid(), &info.GetInfoRef());
08886
08887 #ifdef SELDON_LAPACK_CHECK_INFO
08888 if (info.GetInfo() != 0)
08889 throw LapackError(info.GetInfo(), "GetInverse",
08890 "The matrix is inversible ? ");
08891 #endif
08892
08893 }
08894
08895
08896 template <class Prop0, class Allocator0>
08897 void GetInverse(Matrix<complex<double>, Prop0, ColHermPacked,
08898 Allocator0>& A,
08899 LapackInfo& info)
08900 {
08901 int m = A.GetM();
08902 char uplo('U');
08903 Vector<int, VectFull, CallocAlloc<int> > pivot;
08904 Vector<complex<double>, VectFull, Allocator0> work(m);
08905 GetLU(A, pivot, info);
08906 zhptri_(&uplo, &m, A.GetDataVoid(), pivot.GetData(),
08907 work.GetDataVoid(), &info.GetInfoRef());
08908
08909 #ifdef SELDON_LAPACK_CHECK_INFO
08910 if (info.GetInfo() != 0)
08911 throw LapackError(info.GetInfo(), "GetInverse",
08912 "The matrix is inversible ? ");
08913 #endif
08914
08915 }
08916
08917
08918
08919
08920
08921 template <class Prop0, class Allocator0>
08922 void GetInverse(Matrix<complex<float>, Prop0, RowHerm, Allocator0>& A,
08923 LapackInfo& info)
08924 {
08925 int m = A.GetM();
08926 char uplo('L');
08927 Vector<int, VectFull, CallocAlloc<int> > pivot;
08928 Vector<complex<float>, VectFull, Allocator0> work(m);
08929 GetLU(A, pivot, info);
08930 chetri_(&uplo, &m, A.GetDataVoid(), &m, pivot.GetData(),
08931 work.GetDataVoid(), &info.GetInfoRef());
08932
08933 #ifdef SELDON_LAPACK_CHECK_INFO
08934 if (info.GetInfo() != 0)
08935 throw LapackError(info.GetInfo(), "GetInverse",
08936 "The matrix is inversible ? ");
08937 #endif
08938
08939 }
08940
08941
08942 template <class Prop0, class Allocator0>
08943 void GetInverse(Matrix<complex<double>, Prop0, RowHerm, Allocator0>& A,
08944 LapackInfo& info)
08945 {
08946 int m = A.GetM();
08947 char uplo('L');
08948 Vector<int, VectFull, CallocAlloc<int> > pivot;
08949 Vector<complex<double>, VectFull, Allocator0> work(m);
08950 GetLU(A, pivot, info);
08951 zhetri_(&uplo, &m, A.GetDataVoid(), &m, pivot.GetData(),
08952 work.GetDataVoid(), &info.GetInfoRef());
08953
08954 #ifdef SELDON_LAPACK_CHECK_INFO
08955 if (info.GetInfo() != 0)
08956 throw LapackError(info.GetInfo(), "GetInverse",
08957 "The matrix is inversible ? ");
08958 #endif
08959
08960 }
08961
08962
08963
08964
08965
08966 template <class Prop0, class Allocator0>
08967 void GetInverse(Matrix<complex<float>, Prop0, RowHermPacked,
08968 Allocator0>& A,
08969 LapackInfo& info)
08970 {
08971 int m = A.GetM();
08972 char uplo('L');
08973 Vector<int, VectFull, CallocAlloc<int> > pivot;
08974 Vector<complex<float>, VectFull, Allocator0> work(m);
08975 GetLU(A, pivot, info);
08976 chptri_(&uplo, &m, A.GetDataVoid(), pivot.GetData(),
08977 work.GetDataVoid(), &info.GetInfoRef());
08978
08979 #ifdef SELDON_LAPACK_CHECK_INFO
08980 if (info.GetInfo() != 0)
08981 throw LapackError(info.GetInfo(), "GetInverse",
08982 "The matrix is inversible ? ");
08983 #endif
08984
08985 }
08986
08987
08988 template <class Prop0, class Allocator0>
08989 void GetInverse(Matrix<complex<double>, Prop0, RowHermPacked,
08990 Allocator0>& A,
08991 LapackInfo& info)
08992 {
08993 int m = A.GetM();
08994 char uplo('L');
08995 Vector<int, VectFull, CallocAlloc<int> > pivot;
08996 Vector<complex<double>, VectFull, Allocator0> work(m);
08997 GetLU(A, pivot, info);
08998 zhptri_(&uplo, &m, A.GetDataVoid(), pivot.GetData(),
08999 work.GetDataVoid(), &info.GetInfoRef());
09000
09001 #ifdef SELDON_LAPACK_CHECK_INFO
09002 if (info.GetInfo() != 0)
09003 throw LapackError(info.GetInfo(), "GetInverse",
09004 "The matrix is inversible ? ");
09005 #endif
09006
09007 }
09008
09009
09010
09011
09012
09013 template <class Prop0, class Allocator0>
09014 void GetInverse(Matrix<float, Prop0, ColUpTriang, Allocator0>& A,
09015 LapackInfo& info)
09016 {
09017 int m = A.GetM();
09018 char uplo('U'); char diag('N');
09019 strtri_(&uplo, &diag, &m, A.GetData(), &m,
09020 &info.GetInfoRef());
09021
09022 #ifdef SELDON_LAPACK_CHECK_INFO
09023 if (info.GetInfo() != 0)
09024 throw LapackError(info.GetInfo(), "GetInverse",
09025 "The matrix is inversible ? ");
09026 #endif
09027
09028 }
09029
09030
09031 template <class Prop0, class Allocator0>
09032 void GetInverse(Matrix<double, Prop0, ColUpTriang, Allocator0>& A,
09033 LapackInfo& info)
09034 {
09035 int m = A.GetM();
09036 char uplo('U'); char diag('N');
09037 dtrtri_(&uplo, &diag, &m, A.GetData(), &m,
09038 &info.GetInfoRef());
09039
09040 #ifdef SELDON_LAPACK_CHECK_INFO
09041 if (info.GetInfo() != 0)
09042 throw LapackError(info.GetInfo(), "GetInverse",
09043 "The matrix is inversible ? ");
09044 #endif
09045
09046 }
09047
09048
09049 template <class Prop0, class Allocator0>
09050 void GetInverse(Matrix<complex<float>, Prop0, ColUpTriang, Allocator0>& A,
09051 LapackInfo& info)
09052 {
09053 int m = A.GetM();
09054 char uplo('U'); char diag('N');
09055 ctrtri_(&uplo, &diag, &m, A.GetDataVoid(), &m,
09056 &info.GetInfoRef());
09057
09058 #ifdef SELDON_LAPACK_CHECK_INFO
09059 if (info.GetInfo() != 0)
09060 throw LapackError(info.GetInfo(), "GetInverse",
09061 "The matrix is inversible ? ");
09062 #endif
09063
09064 }
09065
09066
09067 template <class Prop0, class Allocator0>
09068 void GetInverse(Matrix<complex<double>, Prop0, ColUpTriang, Allocator0>& A,
09069 LapackInfo& info)
09070 {
09071 int m = A.GetM();
09072 char uplo('U'); char diag('N');
09073 ztrtri_(&uplo, &diag, &m, A.GetDataVoid(), &m,
09074 &info.GetInfoRef());
09075
09076 #ifdef SELDON_LAPACK_CHECK_INFO
09077 if (info.GetInfo() != 0)
09078 throw LapackError(info.GetInfo(), "GetInverse",
09079 "The matrix is inversible ? ");
09080 #endif
09081
09082 }
09083
09084
09085
09086
09087
09088 template <class Prop0, class Allocator0>
09089 void GetInverse(const SeldonDiag& DiagA,
09090 Matrix<float, Prop0, ColUpTriang, Allocator0>& A,
09091 LapackInfo& info)
09092 {
09093 int m = A.GetM();
09094 char uplo('U'); char diag = DiagA.Char();
09095 strtri_(&uplo, &diag, &m, A.GetData(), &m,
09096 &info.GetInfoRef());
09097
09098 #ifdef SELDON_LAPACK_CHECK_INFO
09099 if (info.GetInfo() != 0)
09100 throw LapackError(info.GetInfo(), "GetInverse",
09101 "The matrix is inversible ? ");
09102 #endif
09103
09104 }
09105
09106
09107 template <class Prop0, class Allocator0>
09108 void GetInverse(const SeldonDiag& DiagA,
09109 Matrix<double, Prop0, ColUpTriang, Allocator0>& A,
09110 LapackInfo& info)
09111 {
09112 int m = A.GetM();
09113 char uplo('U'); char diag = DiagA.Char();
09114 dtrtri_(&uplo, &diag, &m, A.GetData(), &m,
09115 &info.GetInfoRef());
09116
09117 #ifdef SELDON_LAPACK_CHECK_INFO
09118 if (info.GetInfo() != 0)
09119 throw LapackError(info.GetInfo(), "GetInverse",
09120 "The matrix is inversible ? ");
09121 #endif
09122
09123 }
09124
09125
09126 template <class Prop0, class Allocator0>
09127 void GetInverse(const SeldonDiag& DiagA,
09128 Matrix<complex<float>, Prop0, ColUpTriang, Allocator0>& A,
09129 LapackInfo& info)
09130 {
09131 int m = A.GetM();
09132 char uplo('U'); char diag = DiagA.Char();
09133 ctrtri_(&uplo, &diag, &m, A.GetDataVoid(), &m,
09134 &info.GetInfoRef());
09135
09136 #ifdef SELDON_LAPACK_CHECK_INFO
09137 if (info.GetInfo() != 0)
09138 throw LapackError(info.GetInfo(), "GetInverse",
09139 "The matrix is inversible ? ");
09140 #endif
09141
09142 }
09143
09144
09145 template <class Prop0, class Allocator0>
09146 void GetInverse(const SeldonDiag& DiagA,
09147 Matrix<complex<double>, Prop0, ColUpTriang, Allocator0>& A,
09148 LapackInfo& info)
09149 {
09150 int m = A.GetM();
09151 char uplo('U'); char diag = DiagA.Char();
09152 ztrtri_(&uplo, &diag, &m, A.GetDataVoid(), &m,
09153 &info.GetInfoRef());
09154
09155 #ifdef SELDON_LAPACK_CHECK_INFO
09156 if (info.GetInfo() != 0)
09157 throw LapackError(info.GetInfo(), "GetInverse",
09158 "The matrix is inversible ? ");
09159 #endif
09160
09161 }
09162
09163
09164
09165
09166
09167 template <class Prop0, class Allocator0>
09168 void GetInverse(Matrix<float, Prop0, ColLoTriang, Allocator0>& A,
09169 LapackInfo& info)
09170 {
09171 int m = A.GetM();
09172 char uplo('L'); char diag('N');
09173 strtri_(&uplo, &diag, &m, A.GetData(), &m,
09174 &info.GetInfoRef());
09175
09176 #ifdef SELDON_LAPACK_CHECK_INFO
09177 if (info.GetInfo() != 0)
09178 throw LapackError(info.GetInfo(), "GetInverse",
09179 "The matrix is inversible ? ");
09180 #endif
09181
09182 }
09183
09184
09185 template <class Prop0, class Allocator0>
09186 void GetInverse(Matrix<double, Prop0, ColLoTriang, Allocator0>& A,
09187 LapackInfo& info)
09188 {
09189 int m = A.GetM();
09190 char uplo('L'); char diag('N');
09191 dtrtri_(&uplo, &diag, &m, A.GetData(), &m,
09192 &info.GetInfoRef());
09193
09194 #ifdef SELDON_LAPACK_CHECK_INFO
09195 if (info.GetInfo() != 0)
09196 throw LapackError(info.GetInfo(), "GetInverse",
09197 "The matrix is inversible ? ");
09198 #endif
09199
09200 }
09201
09202
09203 template <class Prop0, class Allocator0>
09204 void GetInverse(Matrix<complex<float>, Prop0, ColLoTriang, Allocator0>& A,
09205 LapackInfo& info)
09206 {
09207 int m = A.GetM();
09208 char uplo('L'); char diag('N');
09209 ctrtri_(&uplo, &diag, &m, A.GetDataVoid(), &m,
09210 &info.GetInfoRef());
09211
09212 #ifdef SELDON_LAPACK_CHECK_INFO
09213 if (info.GetInfo() != 0)
09214 throw LapackError(info.GetInfo(), "GetInverse",
09215 "The matrix is inversible ? ");
09216 #endif
09217
09218 }
09219
09220
09221 template <class Prop0, class Allocator0>
09222 void GetInverse(Matrix<complex<double>, Prop0, ColLoTriang, Allocator0>& A,
09223 LapackInfo& info)
09224 {
09225 int m = A.GetM();
09226 char uplo('L'); char diag('N');
09227 ztrtri_(&uplo, &diag, &m, A.GetDataVoid(), &m,
09228 &info.GetInfoRef());
09229
09230 #ifdef SELDON_LAPACK_CHECK_INFO
09231 if (info.GetInfo() != 0)
09232 throw LapackError(info.GetInfo(), "GetInverse",
09233 "The matrix is inversible ? ");
09234 #endif
09235
09236 }
09237
09238
09239
09240
09241
09242 template <class Prop0, class Allocator0>
09243 void GetInverse(const SeldonDiag& DiagA,
09244 Matrix<float, Prop0, ColLoTriang, Allocator0>& A,
09245 LapackInfo& info)
09246 {
09247 int m = A.GetM();
09248 char uplo('L'); char diag = DiagA.Char();
09249 strtri_(&uplo, &diag, &m, A.GetData(), &m,
09250 &info.GetInfoRef());
09251
09252 #ifdef SELDON_LAPACK_CHECK_INFO
09253 if (info.GetInfo() != 0)
09254 throw LapackError(info.GetInfo(), "GetInverse",
09255 "The matrix is inversible ? ");
09256 #endif
09257
09258 }
09259
09260
09261 template <class Prop0, class Allocator0>
09262 void GetInverse(const SeldonDiag& DiagA,
09263 Matrix<double, Prop0, ColLoTriang, Allocator0>& A,
09264 LapackInfo& info)
09265 {
09266 int m = A.GetM();
09267 char uplo('L'); char diag = DiagA.Char();
09268 dtrtri_(&uplo, &diag, &m, A.GetData(), &m,
09269 &info.GetInfoRef());
09270
09271 #ifdef SELDON_LAPACK_CHECK_INFO
09272 if (info.GetInfo() != 0)
09273 throw LapackError(info.GetInfo(), "GetInverse",
09274 "The matrix is inversible ? ");
09275 #endif
09276
09277 }
09278
09279
09280 template <class Prop0, class Allocator0>
09281 void GetInverse(const SeldonDiag& DiagA,
09282 Matrix<complex<float>, Prop0, ColLoTriang, Allocator0>& A,
09283 LapackInfo& info)
09284 {
09285 int m = A.GetM();
09286 char uplo('L'); char diag = DiagA.Char();
09287 ctrtri_(&uplo, &diag, &m, A.GetDataVoid(), &m,
09288 &info.GetInfoRef());
09289
09290 #ifdef SELDON_LAPACK_CHECK_INFO
09291 if (info.GetInfo() != 0)
09292 throw LapackError(info.GetInfo(), "GetInverse",
09293 "The matrix is inversible ? ");
09294 #endif
09295
09296 }
09297
09298
09299 template <class Prop0, class Allocator0>
09300 void GetInverse(const SeldonDiag& DiagA,
09301 Matrix<complex<double>, Prop0, ColLoTriang, Allocator0>& A,
09302 LapackInfo& info)
09303 {
09304 int m = A.GetM();
09305 char uplo('L'); char diag = DiagA.Char();
09306 ztrtri_(&uplo, &diag, &m, A.GetDataVoid(), &m,
09307 &info.GetInfoRef());
09308
09309 #ifdef SELDON_LAPACK_CHECK_INFO
09310 if (info.GetInfo() != 0)
09311 throw LapackError(info.GetInfo(), "GetInverse",
09312 "The matrix is inversible ? ");
09313 #endif
09314
09315 }
09316
09317
09318
09319
09320
09321 template <class Prop0, class Allocator0>
09322 void GetInverse(Matrix<float, Prop0, ColUpTriangPacked, Allocator0>& A,
09323 LapackInfo& info)
09324 {
09325 int m = A.GetM();
09326 char uplo('U'); char diag('N');
09327 stptri_(&uplo, &diag, &m, A.GetData(), &info.GetInfoRef());
09328
09329 #ifdef SELDON_LAPACK_CHECK_INFO
09330 if (info.GetInfo() != 0)
09331 throw LapackError(info.GetInfo(), "GetInverse",
09332 "The matrix is inversible ? ");
09333 #endif
09334
09335 }
09336
09337
09338 template <class Prop0, class Allocator0>
09339 void GetInverse(Matrix<double, Prop0, ColUpTriangPacked, Allocator0>& A,
09340 LapackInfo& info)
09341 {
09342 int m = A.GetM();
09343 char uplo('U'); char diag('N');
09344 dtptri_(&uplo, &diag, &m, A.GetData(), &info.GetInfoRef());
09345
09346 #ifdef SELDON_LAPACK_CHECK_INFO
09347 if (info.GetInfo() != 0)
09348 throw LapackError(info.GetInfo(), "GetInverse",
09349 "The matrix is inversible ? ");
09350 #endif
09351
09352 }
09353
09354
09355 template <class Prop0, class Allocator0>
09356 void GetInverse(Matrix<complex<float>, Prop0, ColUpTriangPacked,
09357 Allocator0>& A,
09358 LapackInfo& info)
09359 {
09360 int m = A.GetM();
09361 char uplo('U'); char diag('N');
09362 ctptri_(&uplo, &diag, &m, A.GetDataVoid(), &info.GetInfoRef());
09363
09364 #ifdef SELDON_LAPACK_CHECK_INFO
09365 if (info.GetInfo() != 0)
09366 throw LapackError(info.GetInfo(), "GetInverse",
09367 "The matrix is inversible ? ");
09368 #endif
09369
09370 }
09371
09372
09373 template <class Prop0, class Allocator0>
09374 void GetInverse(Matrix<complex<double>, Prop0, ColUpTriangPacked,
09375 Allocator0>& A,
09376 LapackInfo& info)
09377 {
09378 int m = A.GetM();
09379 char uplo('U'); char diag('N');
09380 ztptri_(&uplo, &diag, &m, A.GetDataVoid(),
09381 &info.GetInfoRef());
09382
09383 #ifdef SELDON_LAPACK_CHECK_INFO
09384 if (info.GetInfo() != 0)
09385 throw LapackError(info.GetInfo(), "GetInverse",
09386 "The matrix is inversible ? ");
09387 #endif
09388
09389 }
09390
09391
09392
09393
09394
09395 template <class Prop0, class Allocator0>
09396 void GetInverse(const SeldonDiag& DiagA,
09397 Matrix<float, Prop0, ColUpTriangPacked, Allocator0>& A,
09398 LapackInfo& info)
09399 {
09400 int m = A.GetM();
09401 char uplo('U'); char diag = DiagA.Char();
09402 stptri_(&uplo, &diag, &m, A.GetData(), &info.GetInfoRef());
09403
09404 #ifdef SELDON_LAPACK_CHECK_INFO
09405 if (info.GetInfo() != 0)
09406 throw LapackError(info.GetInfo(), "GetInverse",
09407 "The matrix is inversible ? ");
09408 #endif
09409
09410 }
09411
09412
09413 template <class Prop0, class Allocator0>
09414 void GetInverse(const SeldonDiag& DiagA,
09415 Matrix<double, Prop0, ColUpTriangPacked, Allocator0>& A,
09416 LapackInfo& info)
09417 {
09418 int m = A.GetM();
09419 char uplo('U'); char diag = DiagA.Char();
09420 dtptri_(&uplo, &diag, &m, A.GetData(), &info.GetInfoRef());
09421
09422 #ifdef SELDON_LAPACK_CHECK_INFO
09423 if (info.GetInfo() != 0)
09424 throw LapackError(info.GetInfo(), "GetInverse",
09425 "The matrix is inversible ? ");
09426 #endif
09427
09428 }
09429
09430
09431 template <class Prop0, class Allocator0>
09432 void GetInverse(const SeldonDiag& DiagA,
09433 Matrix<complex<float>, Prop0, ColUpTriangPacked,
09434 Allocator0>& A,
09435 LapackInfo& info)
09436 {
09437 int m = A.GetM();
09438 char uplo('U'); char diag = DiagA.Char();
09439 ctptri_(&uplo, &diag, &m, A.GetDataVoid(), &info.GetInfoRef());
09440
09441 #ifdef SELDON_LAPACK_CHECK_INFO
09442 if (info.GetInfo() != 0)
09443 throw LapackError(info.GetInfo(), "GetInverse",
09444 "The matrix is inversible ? ");
09445 #endif
09446
09447 }
09448
09449
09450 template <class Prop0, class Allocator0>
09451 void GetInverse(const SeldonDiag& DiagA,
09452 Matrix<complex<double>, Prop0, ColUpTriangPacked,
09453 Allocator0>& A,
09454 LapackInfo& info)
09455 {
09456 int m = A.GetM();
09457 char uplo('U'); char diag = DiagA.Char();
09458 ztptri_(&uplo, &diag, &m, A.GetDataVoid(),
09459 &info.GetInfoRef());
09460
09461 #ifdef SELDON_LAPACK_CHECK_INFO
09462 if (info.GetInfo() != 0)
09463 throw LapackError(info.GetInfo(), "GetInverse",
09464 "The matrix is inversible ? ");
09465 #endif
09466
09467 }
09468
09469
09470
09471
09472
09473 template <class Prop0, class Allocator0>
09474 void GetInverse(Matrix<float, Prop0, ColLoTriangPacked, Allocator0>& A,
09475 LapackInfo& info)
09476 {
09477 int m = A.GetM();
09478 char uplo('L'); char diag('N');
09479 stptri_(&uplo, &diag, &m, A.GetData(), &info.GetInfoRef());
09480
09481 #ifdef SELDON_LAPACK_CHECK_INFO
09482 if (info.GetInfo() != 0)
09483 throw LapackError(info.GetInfo(), "GetInverse",
09484 "The matrix is inversible ? ");
09485 #endif
09486
09487 }
09488
09489
09490 template <class Prop0, class Allocator0>
09491 void GetInverse(Matrix<double, Prop0, ColLoTriangPacked, Allocator0>& A,
09492 LapackInfo& info)
09493 {
09494 int m = A.GetM();
09495 char uplo('L'); char diag('N');
09496 dtptri_(&uplo, &diag, &m, A.GetData(), &info.GetInfoRef());
09497
09498 #ifdef SELDON_LAPACK_CHECK_INFO
09499 if (info.GetInfo() != 0)
09500 throw LapackError(info.GetInfo(), "GetInverse",
09501 "The matrix is inversible ? ");
09502 #endif
09503
09504 }
09505
09506
09507 template <class Prop0, class Allocator0>
09508 void GetInverse(Matrix<complex<float>, Prop0, ColLoTriangPacked,
09509 Allocator0>& A,
09510 LapackInfo& info)
09511 {
09512 int m = A.GetM();
09513 char uplo('L'); char diag('N');
09514 ctptri_(&uplo, &diag, &m, A.GetDataVoid(),
09515 &info.GetInfoRef());
09516
09517 #ifdef SELDON_LAPACK_CHECK_INFO
09518 if (info.GetInfo() != 0)
09519 throw LapackError(info.GetInfo(), "GetInverse",
09520 "The matrix is inversible ? ");
09521 #endif
09522
09523 }
09524
09525
09526 template <class Prop0, class Allocator0>
09527 void GetInverse(Matrix<complex<double>, Prop0, ColLoTriangPacked,
09528 Allocator0>& A,
09529 LapackInfo& info)
09530 {
09531 int m = A.GetM();
09532 char uplo('L'); char diag('N');
09533 ztptri_(&uplo, &diag, &m, A.GetDataVoid(),
09534 &info.GetInfoRef());
09535
09536 #ifdef SELDON_LAPACK_CHECK_INFO
09537 if (info.GetInfo() != 0)
09538 throw LapackError(info.GetInfo(), "GetInverse",
09539 "The matrix is inversible ? ");
09540 #endif
09541
09542 }
09543
09544
09545
09546
09547
09548 template <class Prop0, class Allocator0>
09549 void GetInverse(const SeldonDiag& DiagA,
09550 Matrix<float, Prop0, ColLoTriangPacked, Allocator0>& A,
09551 LapackInfo& info)
09552 {
09553 int m = A.GetM();
09554 char uplo('L'); char diag = DiagA.Char();
09555 stptri_(&uplo, &diag, &m, A.GetData(), &info.GetInfoRef());
09556
09557 #ifdef SELDON_LAPACK_CHECK_INFO
09558 if (info.GetInfo() != 0)
09559 throw LapackError(info.GetInfo(), "GetInverse",
09560 "The matrix is inversible ? ");
09561 #endif
09562
09563 }
09564
09565
09566 template <class Prop0, class Allocator0>
09567 void GetInverse(const SeldonDiag& DiagA,
09568 Matrix<double, Prop0, ColLoTriangPacked, Allocator0>& A,
09569 LapackInfo& info)
09570 {
09571 int m = A.GetM();
09572 char uplo('L'); char diag = DiagA.Char();
09573 dtptri_(&uplo, &diag, &m, A.GetData(), &info.GetInfoRef());
09574
09575 #ifdef SELDON_LAPACK_CHECK_INFO
09576 if (info.GetInfo() != 0)
09577 throw LapackError(info.GetInfo(), "GetInverse",
09578 "The matrix is inversible ? ");
09579 #endif
09580
09581 }
09582
09583
09584 template <class Prop0, class Allocator0>
09585 void GetInverse(const SeldonDiag& DiagA,
09586 Matrix<complex<float>, Prop0, ColLoTriangPacked,
09587 Allocator0>& A,
09588 LapackInfo& info)
09589 {
09590 int m = A.GetM();
09591 char uplo('L'); char diag = DiagA.Char();
09592 ctptri_(&uplo, &diag, &m, A.GetDataVoid(),
09593 &info.GetInfoRef());
09594
09595 #ifdef SELDON_LAPACK_CHECK_INFO
09596 if (info.GetInfo() != 0)
09597 throw LapackError(info.GetInfo(), "GetInverse",
09598 "The matrix is inversible ? ");
09599 #endif
09600
09601 }
09602
09603
09604 template <class Prop0, class Allocator0>
09605 void GetInverse(const SeldonDiag& DiagA,
09606 Matrix<complex<double>, Prop0, ColLoTriangPacked,
09607 Allocator0>& A,
09608 LapackInfo& info)
09609 {
09610 int m = A.GetM();
09611 char uplo('L'); char diag = DiagA.Char();
09612 ztptri_(&uplo, &diag, &m, A.GetDataVoid(),
09613 &info.GetInfoRef());
09614
09615 #ifdef SELDON_LAPACK_CHECK_INFO
09616 if (info.GetInfo() != 0)
09617 throw LapackError(info.GetInfo(), "GetInverse",
09618 "The matrix is inversible ? ");
09619 #endif
09620
09621 }
09622
09623
09624
09625
09626
09627 template <class Prop0, class Allocator0>
09628 void GetInverse(Matrix<float, Prop0, RowUpTriang, Allocator0>& A,
09629 LapackInfo& info)
09630 {
09631 int m = A.GetM();
09632 char uplo('L'); char diag('N');
09633 strtri_(&uplo, &diag, &m, A.GetData(), &m,
09634 &info.GetInfoRef());
09635
09636 #ifdef SELDON_LAPACK_CHECK_INFO
09637 if (info.GetInfo() != 0)
09638 throw LapackError(info.GetInfo(), "GetInverse",
09639 "The matrix is inversible ? ");
09640 #endif
09641
09642 }
09643
09644
09645 template <class Prop0, class Allocator0>
09646 void GetInverse(Matrix<double, Prop0, RowUpTriang, Allocator0>& A,
09647 LapackInfo& info)
09648 {
09649 int m = A.GetM();
09650 char uplo('L'); char diag('N');
09651 dtrtri_(&uplo, &diag, &m, A.GetData(), &m,
09652 &info.GetInfoRef());
09653
09654 #ifdef SELDON_LAPACK_CHECK_INFO
09655 if (info.GetInfo() != 0)
09656 throw LapackError(info.GetInfo(), "GetInverse",
09657 "The matrix is inversible ? ");
09658 #endif
09659
09660 }
09661
09662
09663 template <class Prop0, class Allocator0>
09664 void GetInverse(Matrix<complex<float>, Prop0, RowUpTriang, Allocator0>& A,
09665 LapackInfo& info)
09666 {
09667 int m = A.GetM();
09668 char uplo('L'); char diag('N');
09669 ctrtri_(&uplo, &diag, &m, A.GetDataVoid(), &m,
09670 &info.GetInfoRef());
09671
09672 #ifdef SELDON_LAPACK_CHECK_INFO
09673 if (info.GetInfo() != 0)
09674 throw LapackError(info.GetInfo(), "GetInverse",
09675 "The matrix is inversible ? ");
09676 #endif
09677
09678 }
09679
09680
09681 template <class Prop0, class Allocator0>
09682 void GetInverse(Matrix<complex<double>, Prop0, RowUpTriang, Allocator0>& A,
09683 LapackInfo& info)
09684 {
09685 int m = A.GetM();
09686 char uplo('L'); char diag('N');
09687 ztrtri_(&uplo, &diag, &m, A.GetDataVoid(), &m,
09688 &info.GetInfoRef());
09689
09690 #ifdef SELDON_LAPACK_CHECK_INFO
09691 if (info.GetInfo() != 0)
09692 throw LapackError(info.GetInfo(), "GetInverse",
09693 "The matrix is inversible ? ");
09694 #endif
09695
09696 }
09697
09698
09699
09700
09701
09702 template <class Prop0, class Allocator0>
09703 void GetInverse(const SeldonDiag& DiagA,
09704 Matrix<float, Prop0, RowUpTriang, Allocator0>& A,
09705 LapackInfo& info)
09706 {
09707 int m = A.GetM();
09708 char uplo('L'); char diag = DiagA.Char();
09709 strtri_(&uplo, &diag, &m, A.GetData(), &m,
09710 &info.GetInfoRef());
09711
09712 #ifdef SELDON_LAPACK_CHECK_INFO
09713 if (info.GetInfo() != 0)
09714 throw LapackError(info.GetInfo(), "GetInverse",
09715 "The matrix is inversible ? ");
09716 #endif
09717
09718 }
09719
09720
09721 template <class Prop0, class Allocator0>
09722 void GetInverse(const SeldonDiag& DiagA,
09723 Matrix<double, Prop0, RowUpTriang, Allocator0>& A,
09724 LapackInfo& info)
09725 {
09726 int m = A.GetM();
09727 char uplo('L'); char diag = DiagA.Char();
09728 dtrtri_(&uplo, &diag, &m, A.GetData(), &m,
09729 &info.GetInfoRef());
09730
09731 #ifdef SELDON_LAPACK_CHECK_INFO
09732 if (info.GetInfo() != 0)
09733 throw LapackError(info.GetInfo(), "GetInverse",
09734 "The matrix is inversible ? ");
09735 #endif
09736
09737 }
09738
09739
09740 template <class Prop0, class Allocator0>
09741 void GetInverse(const SeldonDiag& DiagA,
09742 Matrix<complex<float>, Prop0, RowUpTriang, Allocator0>& A,
09743 LapackInfo& info)
09744 {
09745 int m = A.GetM();
09746 char uplo('L'); char diag = DiagA.Char();
09747 ctrtri_(&uplo, &diag, &m, A.GetDataVoid(), &m,
09748 &info.GetInfoRef());
09749
09750 #ifdef SELDON_LAPACK_CHECK_INFO
09751 if (info.GetInfo() != 0)
09752 throw LapackError(info.GetInfo(), "GetInverse",
09753 "The matrix is inversible ? ");
09754 #endif
09755
09756 }
09757
09758
09759 template <class Prop0, class Allocator0>
09760 void GetInverse(const SeldonDiag& DiagA,
09761 Matrix<complex<double>, Prop0, RowUpTriang, Allocator0>& A,
09762 LapackInfo& info)
09763 {
09764 int m = A.GetM();
09765 char uplo('L'); char diag = DiagA.Char();
09766 ztrtri_(&uplo, &diag, &m, A.GetDataVoid(), &m,
09767 &info.GetInfoRef());
09768
09769 #ifdef SELDON_LAPACK_CHECK_INFO
09770 if (info.GetInfo() != 0)
09771 throw LapackError(info.GetInfo(), "GetInverse",
09772 "The matrix is inversible ? ");
09773 #endif
09774
09775 }
09776
09777
09778
09779
09780
09781 template <class Prop0, class Allocator0>
09782 void GetInverse(Matrix<float, Prop0, RowLoTriang, Allocator0>& A,
09783 LapackInfo& info)
09784 {
09785 int m = A.GetM();
09786 char uplo('U'); char diag('N');
09787 strtri_(&uplo, &diag, &m, A.GetData(), &m,
09788 &info.GetInfoRef());
09789
09790 #ifdef SELDON_LAPACK_CHECK_INFO
09791 if (info.GetInfo() != 0)
09792 throw LapackError(info.GetInfo(), "GetInverse",
09793 "The matrix is inversible ? ");
09794 #endif
09795
09796 }
09797
09798
09799 template <class Prop0, class Allocator0>
09800 void GetInverse(Matrix<double, Prop0, RowLoTriang, Allocator0>& A,
09801 LapackInfo& info)
09802 {
09803 int m = A.GetM();
09804 char uplo('U'); char diag('N');
09805 dtrtri_(&uplo, &diag, &m, A.GetData(), &m,
09806 &info.GetInfoRef());
09807
09808 #ifdef SELDON_LAPACK_CHECK_INFO
09809 if (info.GetInfo() != 0)
09810 throw LapackError(info.GetInfo(), "GetInverse",
09811 "The matrix is inversible ? ");
09812 #endif
09813
09814 }
09815
09816
09817 template <class Prop0, class Allocator0>
09818 void GetInverse(Matrix<complex<float>, Prop0, RowLoTriang, Allocator0>& A,
09819 LapackInfo& info)
09820 {
09821 int m = A.GetM();
09822 char uplo('U'); char diag('N');
09823 ctrtri_(&uplo, &diag, &m, A.GetDataVoid(), &m,
09824 &info.GetInfoRef());
09825
09826 #ifdef SELDON_LAPACK_CHECK_INFO
09827 if (info.GetInfo() != 0)
09828 throw LapackError(info.GetInfo(), "GetInverse",
09829 "The matrix is inversible ? ");
09830 #endif
09831
09832 }
09833
09834
09835 template <class Prop0, class Allocator0>
09836 void GetInverse(Matrix<complex<double>, Prop0, RowLoTriang, Allocator0>& A,
09837 LapackInfo& info)
09838 {
09839 int m = A.GetM();
09840 char uplo('U'); char diag('N');
09841 ztrtri_(&uplo, &diag, &m, A.GetDataVoid(), &m,
09842 &info.GetInfoRef());
09843
09844 #ifdef SELDON_LAPACK_CHECK_INFO
09845 if (info.GetInfo() != 0)
09846 throw LapackError(info.GetInfo(), "GetInverse",
09847 "The matrix is inversible ? ");
09848 #endif
09849
09850 }
09851
09852
09853
09854
09855
09856 template <class Prop0, class Allocator0>
09857 void GetInverse(const SeldonDiag& DiagA,
09858 Matrix<float, Prop0, RowLoTriang, Allocator0>& A,
09859 LapackInfo& info)
09860 {
09861 int m = A.GetM();
09862 char uplo('U'); char diag = DiagA.Char();
09863 strtri_(&uplo, &diag, &m, A.GetData(), &m,
09864 &info.GetInfoRef());
09865
09866 #ifdef SELDON_LAPACK_CHECK_INFO
09867 if (info.GetInfo() != 0)
09868 throw LapackError(info.GetInfo(), "GetInverse",
09869 "The matrix is inversible ? ");
09870 #endif
09871
09872 }
09873
09874
09875 template <class Prop0, class Allocator0>
09876 void GetInverse(const SeldonDiag& DiagA,
09877 Matrix<double, Prop0, RowLoTriang, Allocator0>& A,
09878 LapackInfo& info)
09879 {
09880 int m = A.GetM();
09881 char uplo('U'); char diag = DiagA.Char();
09882 dtrtri_(&uplo, &diag, &m, A.GetData(), &m,
09883 &info.GetInfoRef());
09884
09885 #ifdef SELDON_LAPACK_CHECK_INFO
09886 if (info.GetInfo() != 0)
09887 throw LapackError(info.GetInfo(), "GetInverse",
09888 "The matrix is inversible ? ");
09889 #endif
09890
09891 }
09892
09893
09894 template <class Prop0, class Allocator0>
09895 void GetInverse(const SeldonDiag& DiagA,
09896 Matrix<complex<float>, Prop0, RowLoTriang, Allocator0>& A,
09897 LapackInfo& info)
09898 {
09899 int m = A.GetM();
09900 char uplo('U'); char diag = DiagA.Char();
09901 ctrtri_(&uplo, &diag, &m, A.GetDataVoid(), &m,
09902 &info.GetInfoRef());
09903
09904 #ifdef SELDON_LAPACK_CHECK_INFO
09905 if (info.GetInfo() != 0)
09906 throw LapackError(info.GetInfo(), "GetInverse",
09907 "The matrix is inversible ? ");
09908 #endif
09909
09910 }
09911
09912
09913 template <class Prop0, class Allocator0>
09914 void GetInverse(const SeldonDiag& DiagA,
09915 Matrix<complex<double>, Prop0, RowLoTriang, Allocator0>& A,
09916 LapackInfo& info)
09917 {
09918 int m = A.GetM();
09919 char uplo('U'); char diag = DiagA.Char();
09920 ztrtri_(&uplo, &diag, &m, A.GetDataVoid(), &m,
09921 &info.GetInfoRef());
09922
09923 #ifdef SELDON_LAPACK_CHECK_INFO
09924 if (info.GetInfo() != 0)
09925 throw LapackError(info.GetInfo(), "GetInverse",
09926 "The matrix is inversible ? ");
09927 #endif
09928
09929 }
09930
09931
09932
09933
09934
09935 template <class Prop0, class Allocator0>
09936 void GetInverse(Matrix<float, Prop0, RowUpTriangPacked, Allocator0>& A,
09937 LapackInfo& info)
09938 {
09939 int m = A.GetM();
09940 char uplo('L'); char diag('N');
09941 stptri_(&uplo, &diag, &m, A.GetData(), &info.GetInfoRef());
09942
09943 #ifdef SELDON_LAPACK_CHECK_INFO
09944 if (info.GetInfo() != 0)
09945 throw LapackError(info.GetInfo(), "GetInverse",
09946 "The matrix is inversible ? ");
09947 #endif
09948
09949 }
09950
09951
09952 template <class Prop0, class Allocator0>
09953 void GetInverse(Matrix<double, Prop0, RowUpTriangPacked, Allocator0>& A,
09954 LapackInfo& info)
09955 {
09956 int m = A.GetM();
09957 char uplo('L'); char diag('N');
09958 dtptri_(&uplo, &diag, &m, A.GetData(), &info.GetInfoRef());
09959
09960 #ifdef SELDON_LAPACK_CHECK_INFO
09961 if (info.GetInfo() != 0)
09962 throw LapackError(info.GetInfo(), "GetInverse",
09963 "The matrix is inversible ? ");
09964 #endif
09965
09966 }
09967
09968
09969 template <class Prop0, class Allocator0>
09970 void GetInverse(Matrix<complex<float>, Prop0, RowUpTriangPacked,
09971 Allocator0>& A,
09972 LapackInfo& info)
09973 {
09974 int m = A.GetM();
09975 char uplo('L'); char diag('N');
09976 ctptri_(&uplo, &diag, &m, A.GetDataVoid(), &info.GetInfoRef());
09977
09978 #ifdef SELDON_LAPACK_CHECK_INFO
09979 if (info.GetInfo() != 0)
09980 throw LapackError(info.GetInfo(), "GetInverse",
09981 "The matrix is inversible ? ");
09982 #endif
09983
09984 }
09985
09986
09987 template <class Prop0, class Allocator0>
09988 void GetInverse(Matrix<complex<double>, Prop0, RowUpTriangPacked,
09989 Allocator0>& A,
09990 LapackInfo& info)
09991 {
09992 int m = A.GetM();
09993 char uplo('L'); char diag('N');
09994 ztptri_(&uplo, &diag, &m, A.GetDataVoid(),
09995 &info.GetInfoRef());
09996
09997 #ifdef SELDON_LAPACK_CHECK_INFO
09998 if (info.GetInfo() != 0)
09999 throw LapackError(info.GetInfo(), "GetInverse",
10000 "The matrix is inversible ? ");
10001 #endif
10002
10003 }
10004
10005
10006
10007
10008
10009 template <class Prop0, class Allocator0>
10010 void GetInverse(const SeldonDiag& DiagA,
10011 Matrix<float, Prop0, RowUpTriangPacked, Allocator0>& A,
10012 LapackInfo& info)
10013 {
10014 int m = A.GetM();
10015 char uplo('L'); char diag = DiagA.Char();
10016 stptri_(&uplo, &diag, &m, A.GetData(), &info.GetInfoRef());
10017
10018 #ifdef SELDON_LAPACK_CHECK_INFO
10019 if (info.GetInfo() != 0)
10020 throw LapackError(info.GetInfo(), "GetInverse",
10021 "The matrix is inversible ? ");
10022 #endif
10023
10024 }
10025
10026
10027 template <class Prop0, class Allocator0>
10028 void GetInverse(const SeldonDiag& DiagA,
10029 Matrix<double, Prop0, RowUpTriangPacked, Allocator0>& A,
10030 LapackInfo& info)
10031 {
10032 int m = A.GetM();
10033 char uplo('L'); char diag = DiagA.Char();
10034 dtptri_(&uplo, &diag, &m, A.GetData(), &info.GetInfoRef());
10035
10036 #ifdef SELDON_LAPACK_CHECK_INFO
10037 if (info.GetInfo() != 0)
10038 throw LapackError(info.GetInfo(), "GetInverse",
10039 "The matrix is inversible ? ");
10040 #endif
10041
10042 }
10043
10044
10045 template <class Prop0, class Allocator0>
10046 void GetInverse(const SeldonDiag& DiagA,
10047 Matrix<complex<float>, Prop0, RowUpTriangPacked,
10048 Allocator0>& A,
10049 LapackInfo& info)
10050 {
10051 int m = A.GetM();
10052 char uplo('L'); char diag = DiagA.Char();
10053 ctptri_(&uplo, &diag, &m, A.GetDataVoid(), &info.GetInfoRef());
10054
10055 #ifdef SELDON_LAPACK_CHECK_INFO
10056 if (info.GetInfo() != 0)
10057 throw LapackError(info.GetInfo(), "GetInverse",
10058 "The matrix is inversible ? ");
10059 #endif
10060
10061 }
10062
10063
10064 template <class Prop0, class Allocator0>
10065 void GetInverse(const SeldonDiag& DiagA,
10066 Matrix<complex<double>, Prop0, RowUpTriangPacked,
10067 Allocator0>& A,
10068 LapackInfo& info)
10069 {
10070 int m = A.GetM();
10071 char uplo('L'); char diag = DiagA.Char();
10072 ztptri_(&uplo, &diag, &m, A.GetDataVoid(),
10073 &info.GetInfoRef());
10074
10075 #ifdef SELDON_LAPACK_CHECK_INFO
10076 if (info.GetInfo() != 0)
10077 throw LapackError(info.GetInfo(), "GetInverse",
10078 "The matrix is inversible ? ");
10079 #endif
10080
10081 }
10082
10083
10084
10085
10086
10087 template <class Prop0, class Allocator0>
10088 void GetInverse(Matrix<float, Prop0, RowLoTriangPacked, Allocator0>& A,
10089 LapackInfo& info)
10090 {
10091 int m = A.GetM();
10092 char uplo('U'); char diag('N');
10093 stptri_(&uplo, &diag, &m, A.GetData(), &info.GetInfoRef());
10094
10095 #ifdef SELDON_LAPACK_CHECK_INFO
10096 if (info.GetInfo() != 0)
10097 throw LapackError(info.GetInfo(), "GetInverse",
10098 "The matrix is inversible ? ");
10099 #endif
10100
10101 }
10102
10103
10104 template <class Prop0, class Allocator0>
10105 void GetInverse(Matrix<double, Prop0, RowLoTriangPacked, Allocator0>& A,
10106 LapackInfo& info)
10107 {
10108 int m = A.GetM();
10109 char uplo('U'); char diag('N');
10110 dtptri_(&uplo, &diag, &m, A.GetData(), &info.GetInfoRef());
10111
10112 #ifdef SELDON_LAPACK_CHECK_INFO
10113 if (info.GetInfo() != 0)
10114 throw LapackError(info.GetInfo(), "GetInverse",
10115 "The matrix is inversible ? ");
10116 #endif
10117
10118 }
10119
10120
10121 template <class Prop0, class Allocator0>
10122 void GetInverse(Matrix<complex<float>, Prop0, RowLoTriangPacked,
10123 Allocator0>& A,
10124 LapackInfo& info)
10125 {
10126 int m = A.GetM();
10127 char uplo('U'); char diag('N');
10128 ctptri_(&uplo, &diag, &m, A.GetDataVoid(),
10129 &info.GetInfoRef());
10130
10131 #ifdef SELDON_LAPACK_CHECK_INFO
10132 if (info.GetInfo() != 0)
10133 throw LapackError(info.GetInfo(), "GetInverse",
10134 "The matrix is inversible ? ");
10135 #endif
10136
10137 }
10138
10139
10140 template <class Prop0, class Allocator0>
10141 void GetInverse(Matrix<complex<double>, Prop0, RowLoTriangPacked,
10142 Allocator0>& A,
10143 LapackInfo& info)
10144 {
10145 int m = A.GetM();
10146 char uplo('U'); char diag('N');
10147 ztptri_(&uplo, &diag, &m, A.GetDataVoid(),
10148 &info.GetInfoRef());
10149
10150 #ifdef SELDON_LAPACK_CHECK_INFO
10151 if (info.GetInfo() != 0)
10152 throw LapackError(info.GetInfo(), "GetInverse",
10153 "The matrix is inversible ? ");
10154 #endif
10155
10156 }
10157
10158
10159
10160
10161
10162 template <class Prop0, class Allocator0>
10163 void GetInverse(const SeldonDiag& DiagA,
10164 Matrix<float, Prop0, RowLoTriangPacked, Allocator0>& A,
10165 LapackInfo& info)
10166 {
10167 int m = A.GetM();
10168 char uplo('U'); char diag = DiagA.Char();
10169 stptri_(&uplo, &diag, &m, A.GetData(), &info.GetInfoRef());
10170
10171 #ifdef SELDON_LAPACK_CHECK_INFO
10172 if (info.GetInfo() != 0)
10173 throw LapackError(info.GetInfo(), "GetInverse",
10174 "The matrix is inversible ? ");
10175 #endif
10176
10177 }
10178
10179
10180 template <class Prop0, class Allocator0>
10181 void GetInverse(const SeldonDiag& DiagA,
10182 Matrix<double, Prop0, RowLoTriangPacked, Allocator0>& A,
10183 LapackInfo& info)
10184 {
10185 int m = A.GetM();
10186 char uplo('U'); char diag = DiagA.Char();
10187 dtptri_(&uplo, &diag, &m, A.GetData(), &info.GetInfoRef());
10188
10189 #ifdef SELDON_LAPACK_CHECK_INFO
10190 if (info.GetInfo() != 0)
10191 throw LapackError(info.GetInfo(), "GetInverse",
10192 "The matrix is inversible ? ");
10193 #endif
10194
10195 }
10196
10197
10198 template <class Prop0, class Allocator0>
10199 void GetInverse(const SeldonDiag& DiagA,
10200 Matrix<complex<float>, Prop0, RowLoTriangPacked,
10201 Allocator0>& A,
10202 LapackInfo& info)
10203 {
10204 int m = A.GetM();
10205 char uplo('U'); char diag = DiagA.Char();
10206 ctptri_(&uplo, &diag, &m, A.GetDataVoid(),
10207 &info.GetInfoRef());
10208
10209 #ifdef SELDON_LAPACK_CHECK_INFO
10210 if (info.GetInfo() != 0)
10211 throw LapackError(info.GetInfo(), "GetInverse",
10212 "The matrix is inversible ? ");
10213 #endif
10214
10215 }
10216
10217
10218 template <class Prop0, class Allocator0>
10219 void GetInverse(const SeldonDiag& DiagA,
10220 Matrix<complex<double>, Prop0, RowLoTriangPacked,
10221 Allocator0>& A,
10222 LapackInfo& info)
10223 {
10224 int m = A.GetM();
10225 char uplo('U'); char diag = DiagA.Char();
10226 ztptri_(&uplo, &diag, &m, A.GetDataVoid(),
10227 &info.GetInfoRef());
10228
10229 #ifdef SELDON_LAPACK_CHECK_INFO
10230 if (info.GetInfo() != 0)
10231 throw LapackError(info.GetInfo(), "GetInverse",
10232 "The matrix is inversible ? ");
10233 #endif
10234
10235 }
10236
10237
10238
10240
10241
10242
10244
10245
10246
10247
10248
10249
10250 template<class Prop0, class Allocator0,
10251 class Allocator1, class Allocator2>
10252 void GetScalingFactors(const Matrix<float, Prop0, ColMajor, Allocator0>& A,
10253 Vector<float, VectFull, Allocator1>& row_scale,
10254 Vector<float, VectFull, Allocator2>& col_scale,
10255 float& row_condition_number,
10256 float& col_condition_number, float& amax,
10257 LapackInfo& info)
10258 {
10259
10260 #ifdef SELDON_CHECK_DIMENSIONS
10261 CheckDim(A, col_scale, row_scale, string("GetScalingFactors(A, X, Y, ")
10262 + string(" rowcnd, colcnd, amax)"));
10263 #endif
10264
10265 int m = A.GetM(), n = A.GetN();
10266 int lda = A.GetLD();
10267 sgeequ_(&m, &n, A.GetData(), &lda, row_scale.GetData(),
10268 col_scale.GetData(), &row_condition_number, &col_condition_number,
10269 &amax, &info.GetInfoRef());
10270 }
10271
10272
10273 template<class Prop0, class Allocator0,
10274 class Allocator1, class Allocator2>
10275 void GetScalingFactors(const Matrix<double, Prop0, ColMajor, Allocator0>& A,
10276 Vector<double, VectFull, Allocator1>& row_scale,
10277 Vector<double, VectFull, Allocator2>& col_scale,
10278 double& row_condition_number,
10279 double& col_condition_number, double& amax,
10280 LapackInfo& info)
10281 {
10282
10283 #ifdef SELDON_CHECK_DIMENSIONS
10284 CheckDim(A, col_scale, row_scale, string("GetScalingFactors(A, X, Y, ")
10285 + string(" rowcnd, colcnd, amax)"));
10286 #endif
10287
10288 int m = A.GetM(), n = A.GetN();
10289 int lda = A.GetLD();
10290 dgeequ_(&m, &n, A.GetData(), &lda, row_scale.GetData(),
10291 col_scale.GetData(), &row_condition_number, &col_condition_number,
10292 &amax, &info.GetInfoRef());
10293 }
10294
10295
10296 template<class Prop0, class Allocator0,
10297 class Allocator1, class Allocator2>
10298 void GetScalingFactors(const Matrix<complex<float>, Prop0, ColMajor,
10299 Allocator0>& A,
10300 Vector<float, VectFull, Allocator1>& row_scale,
10301 Vector<float, VectFull, Allocator2>& col_scale,
10302 float& row_condition_number,
10303 float& col_condition_number, float& amax,
10304 LapackInfo& info)
10305 {
10306
10307 #ifdef SELDON_CHECK_DIMENSIONS
10308 CheckDim(A, col_scale, row_scale, string("GetScalingFactors(A, X, Y, ")
10309 +string("rowcnd, colcnd, amax)"));
10310 #endif
10311
10312 int m = A.GetM(), n = A.GetN();
10313 int lda = A.GetLD();
10314 cgeequ_(&m, &n, A.GetDataVoid(), &lda, row_scale.GetData(),
10315 col_scale.GetData(), &row_condition_number,
10316 &col_condition_number, &amax, &info.GetInfoRef());
10317 }
10318
10319
10320 template<class Prop0, class Allocator0,
10321 class Allocator1, class Allocator2>
10322 void GetScalingFactors(const Matrix<complex<double>, Prop0, ColMajor,
10323 Allocator0>& A,
10324 Vector<double, VectFull, Allocator1>& row_scale,
10325 Vector<double, VectFull, Allocator2>& col_scale,
10326 double& row_condition_number,
10327 double& col_condition_number, double& amax,
10328 LapackInfo& info)
10329 {
10330
10331 #ifdef SELDON_CHECK_DIMENSIONS
10332 CheckDim(A, col_scale, row_scale, string("GetScalingFactors(A, X, Y, ")
10333 + string("rowcnd, colcnd, amax)"));
10334 #endif
10335
10336 int m = A.GetM(), n = A.GetN();
10337 int lda = A.GetLD();
10338 zgeequ_(&m, &n, A.GetDataVoid(), &lda, row_scale.GetData(),
10339 col_scale.GetData(), &row_condition_number,
10340 &col_condition_number, &amax, &info.GetInfoRef());
10341 }
10342
10343
10344
10345
10346
10347 template<class Prop0, class Allocator0,
10348 class Allocator1, class Allocator2>
10349 void GetScalingFactors(const Matrix<float, Prop0, RowMajor, Allocator0>& A,
10350 Vector<float, VectFull, Allocator1>& row_scale,
10351 Vector<float, VectFull, Allocator2>& col_scale,
10352 float& row_condition_number,
10353 float& col_condition_number, float& amax,
10354 LapackInfo& info)
10355 {
10356
10357 #ifdef SELDON_CHECK_DIMENSIONS
10358 CheckDim(A, col_scale, row_scale, string("GetScalingFactors(A, X, Y, ")
10359 + string(" rowcnd, colcnd, amax)"));
10360 #endif
10361
10362 int m = A.GetM(), n = A.GetN();
10363 int lda = A.GetLD();
10364 sgeequ_(&n, &m, A.GetData(), &lda, col_scale.GetData(),
10365 row_scale.GetData(), &col_condition_number, &row_condition_number,
10366 &amax, &info.GetInfoRef());
10367 }
10368
10369
10370 template<class Prop0, class Allocator0,
10371 class Allocator1, class Allocator2>
10372 void GetScalingFactors(const Matrix<double, Prop0, RowMajor, Allocator0>& A,
10373 Vector<double, VectFull, Allocator1>& row_scale,
10374 Vector<double, VectFull, Allocator2>& col_scale,
10375 double& row_condition_number,
10376 double& col_condition_number, double& amax,
10377 LapackInfo& info)
10378 {
10379
10380 #ifdef SELDON_CHECK_DIMENSIONS
10381 CheckDim(A, col_scale, row_scale, string("GetScalingFactors(A, X, Y, ")
10382 + string(" rowcnd, colcnd, amax)"));
10383 #endif
10384
10385 int m = A.GetM(), n = A.GetN();
10386 int lda = A.GetLD();
10387 dgeequ_(&n, &m, A.GetData(), &lda, col_scale.GetData(),
10388 row_scale.GetData(), &col_condition_number, &row_condition_number,
10389 &amax, &info.GetInfoRef());
10390 }
10391
10392
10393 template<class Prop0, class Allocator0,
10394 class Allocator1, class Allocator2>
10395 void GetScalingFactors(const Matrix<complex<float>, Prop0, RowMajor,
10396 Allocator0>& A,
10397 Vector<float, VectFull, Allocator1>& row_scale,
10398 Vector<float, VectFull, Allocator2>& col_scale,
10399 float& row_condition_number,
10400 float& col_condition_number, float& amax,
10401 LapackInfo& info)
10402 {
10403
10404 #ifdef SELDON_CHECK_DIMENSIONS
10405 CheckDim(A, col_scale, row_scale, string("GetScalingFactors(A, X, Y,")
10406 + string(" rowcnd, colcnd, amax)"));
10407 #endif
10408
10409 int m = A.GetM(), n = A.GetN();
10410 int lda = A.GetLD();
10411 cgeequ_(&n, &m, A.GetDataVoid(), &lda, col_scale.GetData(),
10412 row_scale.GetData(), &col_condition_number,
10413 &row_condition_number, &amax, &info.GetInfoRef());
10414 }
10415
10416
10417 template<class Prop0, class Allocator0,
10418 class Allocator1, class Allocator2>
10419 void GetScalingFactors(const Matrix<complex<double>, Prop0, RowMajor,
10420 Allocator0>& A,
10421 Vector<double, VectFull, Allocator1>& row_scale,
10422 Vector<double, VectFull, Allocator2>& col_scale,
10423 double& row_condition_number,
10424 double& col_condition_number, double& amax,
10425 LapackInfo& info)
10426 {
10427
10428 #ifdef SELDON_CHECK_DIMENSIONS
10429 CheckDim(A, col_scale, row_scale, string("GetScalingFactors(A, X, Y, ")
10430 + string("rowcnd, colcnd, amax)"));
10431 #endif
10432
10433 int m = A.GetM(), n = A.GetN();
10434 int lda = A.GetLD();
10435 zgeequ_(&n, &m, A.GetDataVoid(), &lda, col_scale.GetData(),
10436 row_scale.GetData(), &col_condition_number,
10437 &row_condition_number, &amax, &info.GetInfoRef());
10438 }
10439
10440
10441
10443
10444
10446
10447
10448
10449 template<class Prop, class Allocator>
10450 void GetCholesky(Matrix<double, Prop, RowSymPacked, Allocator>& A,
10451 LapackInfo& info)
10452 {
10453 int n = A.GetN();
10454 #ifdef SELDON_CHECK_BOUNDS
10455 if (n <= 0)
10456 throw WrongDim("GetCholesky", "Provide a non-empty matrix");
10457 #endif
10458
10459 char uplo('L');
10460 dpptrf_(&uplo, &n, A.GetData(), &info.GetInfoRef());
10461
10462 #ifdef SELDON_LAPACK_CHECK_INFO
10463 if (info.GetInfo() != 0)
10464 throw LapackError(info.GetInfo(), "GetCholesky",
10465 "An error occured during the factorization.");
10466 #endif
10467
10468 }
10469
10470
10471 template<class Prop, class Allocator>
10472 void GetCholesky(Matrix<double, Prop, ColSymPacked, Allocator>& A,
10473 LapackInfo& info)
10474 {
10475 int n = A.GetN();
10476 #ifdef SELDON_CHECK_BOUNDS
10477 if (n <= 0)
10478 throw WrongDim("GetCholesky", "Provide a non-empty matrix");
10479 #endif
10480
10481 char uplo('U');
10482 dpptrf_(&uplo, &n, A.GetData(), &info.GetInfoRef());
10483
10484 #ifdef SELDON_LAPACK_CHECK_INFO
10485 if (info.GetInfo() != 0)
10486 throw LapackError(info.GetInfo(), "GetCholesky",
10487 "An error occured during the factorization.");
10488 #endif
10489
10490 }
10491
10492
10493
10495
10496
10498
10499
10500
10501 template<class Transp, class Prop, class Allocator, class Allocator2>
10502 void SolveCholesky(const Transp& TransA,
10503 const Matrix<double, Prop, RowSymPacked, Allocator>& A,
10504 Vector<double, VectFull, Allocator2>& X,
10505 LapackInfo& info)
10506 {
10507 #ifdef SELDON_CHECK_BOUNDS
10508 if (X.GetM() != A.GetM())
10509 throw WrongDim("SolveCholesky",
10510 "The vector should have a dimension compatible "
10511 "with the matrix.");
10512 #endif
10513
10514
10515 char uplo('L'); char trans(TransA.Char()); char diag('N');
10516 int n = A.GetM(); int nrhs = 1;
10517 dtptrs_(&uplo, &trans, &diag, &n, &nrhs, A.GetData(), X.GetData(),
10518 &n, &info.GetInfoRef());
10519 }
10520
10521
10522 template<class Transp, class Prop, class Allocator, class Allocator2>
10523 void SolveCholesky(const Transp& TransA,
10524 const Matrix<double, Prop, ColSymPacked, Allocator>& A,
10525 Vector<double, VectFull, Allocator2>& X,
10526 LapackInfo& info)
10527 {
10528 #ifdef SELDON_CHECK_BOUNDS
10529 if (X.GetM() != A.GetM())
10530 throw WrongDim("SolveCholesky",
10531 "The vector should have a dimension compatible "
10532 "with the matrix.");
10533 #endif
10534
10535
10536 char uplo('U'); char trans(TransA.RevChar()); char diag('N');
10537 int n = A.GetM(); int nrhs = 1;
10538 dtptrs_(&uplo, &trans, &diag, &n, &nrhs, A.GetData(), X.GetData(),
10539 &n, &info.GetInfoRef());
10540 }
10541
10542
10543
10545
10546
10548
10549
10550
10551 template<class Transp, class Prop, class Allocator, class Allocator2>
10552 void MltCholesky(const Transp& TransA,
10553 const Matrix<double, Prop, RowSymPacked, Allocator>& A,
10554 Vector<double, VectFull, Allocator2>& X,
10555 LapackInfo& info)
10556 {
10557 #ifdef SELDON_CHECK_BOUNDS
10558 if (X.GetM() != A.GetM())
10559 throw WrongDim("MltCholesky",
10560 "The vector should have a dimension compatible "
10561 "with the matrix.");
10562 #endif
10563
10564
10565 if (TransA.Trans())
10566 cblas_dtpmv(CblasRowMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
10567 A.GetM(), A.GetData(), X.GetData(), 1);
10568 else
10569 cblas_dtpmv(CblasRowMajor, CblasUpper, CblasTrans, CblasNonUnit,
10570 A.GetM(), A.GetData(), X.GetData(), 1);
10571 }
10572
10573
10574 template<class Transp, class Prop, class Allocator, class Allocator2>
10575 void MltCholesky(const Transp& TransA,
10576 const Matrix<double, Prop, ColSymPacked, Allocator>& A,
10577 Vector<double, VectFull, Allocator2>& X,
10578 LapackInfo& info)
10579 {
10580 #ifdef SELDON_CHECK_BOUNDS
10581 if (X.GetM() != A.GetM())
10582 throw WrongDim("MltCholesky",
10583 "The vector should have a dimension compatible "
10584 "with the matrix.");
10585 #endif
10586
10587
10588 if (TransA.Trans())
10589 cblas_dtpmv(CblasColMajor, CblasUpper, CblasNoTrans, CblasNonUnit,
10590 A.GetM(), A.GetData(), X.GetData(), 1);
10591 else
10592 cblas_dtpmv(CblasColMajor, CblasUpper, CblasTrans, CblasNonUnit,
10593 A.GetM(), A.GetData(), X.GetData(), 1);
10594 }
10595
10596
10597
10599
10600
10601
10602
10603 template<class T, class Prop, class Storage, class Allocator,
10604 class Allocator1, class Allocator2>
10605 void GetAndSolveLU(Matrix<T, Prop, Storage, Allocator>& A,
10606 Vector<int, VectFull, Allocator1>& P,
10607 Vector<T, VectFull, Allocator2>& b,
10608 LapackInfo& info)
10609 {
10610 GetLU(A, P, info);
10611 SolveLU(A, P, b, info);
10612 }
10613
10614
10615 }
10616
10617 #define SELDON_FILE_LAPACK_LINEAREQUATIONS_CXX
10618 #endif
