- Generated by
1.7.5.1
|
C-XSC - A C++ Class Library for Extended Scientific Computing
2.5.4
|
00001 /* 00002 ** CXSC is a C++ library for eXtended Scientific Computing (V 2.5.4) 00003 ** 00004 ** Copyright (C) 1990-2000 Institut fuer Angewandte Mathematik, 00005 ** Universitaet Karlsruhe, Germany 00006 ** (C) 2000-2014 Wiss. Rechnen/Softwaretechnologie 00007 ** Universitaet Wuppertal, Germany 00008 ** 00009 ** This library is free software; you can redistribute it and/or 00010 ** modify it under the terms of the GNU Library General Public 00011 ** License as published by the Free Software Foundation; either 00012 ** version 2 of the License, or (at your option) any later version. 00013 ** 00014 ** This library is distributed in the hope that it will be useful, 00015 ** but WITHOUT ANY WARRANTY; without even the implied warranty of 00016 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00017 ** Library General Public License for more details. 00018 ** 00019 ** You should have received a copy of the GNU Library General Public 00020 ** License along with this library; if not, write to the Free 00021 ** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 00022 */ 00023 00024 /* CVS $Id: cmatrix.hpp,v 1.37 2014/01/30 17:23:44 cxsc Exp $ */ 00025 00026 #ifndef _CXSC_CMATRIX_HPP_INCLUDED 00027 #define _CXSC_CMATRIX_HPP_INCLUDED 00028 00029 #include "xscclass.hpp" 00030 #include "cdot.hpp" 00031 #include "cidot.hpp" 00032 #include "cvector.hpp" 00033 #include "except.hpp" 00034 #include "matrix.hpp" 00035 #include "rmatrix.hpp" 00036 00037 namespace cxsc { 00038 00039 class cmatrix; 00040 class cmatrix_slice; 00041 class srmatrix; 00042 class srmatrix_slice; 00043 class srmatrix_subv; 00044 class scmatrix; 00045 class scmatrix_slice; 00046 class scmatrix_subv; 00047 00048 00050 00053 class cmatrix_subv 00054 { 00055 friend class cvector; 00056 friend class civector; 00057 friend class cmatrix; 00058 friend class cmatrix_slice; 00059 private: 00060 complex *dat; 00061 int lb,ub; 00062 int size,start,offset; // start=first element index 0..n-1 00063 00064 public: 00066 friend INLINE cmatrix_subv Row(cmatrix &m,const int &i) 00067 #if(CXSC_INDEX_CHECK) 00068 throw(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT); 00069 #else 00070 throw(); 00071 #endif 00072 00073 friend INLINE cmatrix_subv Col(cmatrix &m,const int &i) 00074 #if(CXSC_INDEX_CHECK) 00075 throw(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT); 00076 #else 00077 throw(); 00078 #endif 00079 friend INLINE cmatrix_subv Row(const cmatrix &m,const int &i) 00080 #if(CXSC_INDEX_CHECK) 00081 throw(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT); 00082 #else 00083 throw(); 00084 #endif 00085 00086 friend INLINE cmatrix_subv Col(const cmatrix &m,const int &i) 00087 #if(CXSC_INDEX_CHECK) 00088 throw(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT); 00089 #else 00090 throw(); 00091 #endif 00092 //#if(CXSC_INDEX_CHECK) 00093 #ifdef _CXSC_FRIEND_TPL 00094 //----------------- Templates --------------------------------------- 00095 template <class MV1,class MV2> friend MV1 &_mvmvassign(MV1 &v,const MV2 &rv) 00096 #if(CXSC_INDEX_CHECK) 00097 throw(ERROR__OP_WITH_WRONG_DIM<MV1>); 00098 #else 00099 throw(); 00100 #endif 00101 template <class MV,class S> friend MV &_mvsassign(MV &v,const S &r) throw(); 00102 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv) 00103 #if(CXSC_INDEX_CHECK) 00104 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00105 #else 00106 throw(); 00107 #endif 00108 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) throw(); 00109 template <class MV,class V> friend V _mvabs(const MV &mv) throw(); 00110 template <class MV,class V> friend V _mvim(const MV &mv) throw(); 00111 template <class MV,class V> friend V _mvre(const MV &mv) throw(); 00112 template <class MV,class V> friend MV &_mvvsetim(MV &v,const V &rv) 00113 #if(CXSC_INDEX_CHECK) 00114 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00115 #else 00116 throw(); 00117 #endif 00118 template <class MV,class V> friend MV &_mvvsetre(MV &v,const V &rv) 00119 #if(CXSC_INDEX_CHECK) 00120 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00121 #else 00122 throw(); 00123 #endif 00124 template <class MV,class S> friend MV &_mvssetim(MV &mv, const S &s) throw(); 00125 template <class MV,class S> friend MV &_mvssetre(MV &mv, const S &s) throw(); 00126 template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2) 00127 #if(CXSC_INDEX_CHECK) 00128 throw(OP_WITH_WRONG_DIM); 00129 #else 00130 throw(); 00131 #endif 00132 template <class DP,class MV1,class MV2> friend void _mvmvaccu(DP &dp, const MV1 & rv1, const MV2 &rv2) 00133 #if(CXSC_INDEX_CHECK) 00134 throw(OP_WITH_WRONG_DIM); 00135 #else 00136 throw(); 00137 #endif 00138 00139 template <class MV1,class MV2,class S> friend S _mvmvcmult(const MV1 & rv1, const MV2 &rv2) 00140 #if(CXSC_INDEX_CHECK) 00141 throw(ERROR__OP_WITH_WRONG_DIM<MV1>); 00142 #else 00143 throw(); 00144 #endif 00145 template <class MV1,class MV2,class S> friend S _mvmvcimult(const MV1 & rv1, const MV2 &rv2) 00146 #if(CXSC_INDEX_CHECK) 00147 throw(ERROR__OP_WITH_WRONG_DIM<MV1>); 00148 #else 00149 throw(); 00150 #endif 00151 template <class V,class MV,class S> friend S _vmvcmult(const V &rv1, const MV &rv2) 00152 #if(CXSC_INDEX_CHECK) 00153 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00154 #else 00155 throw(); 00156 #endif 00157 template <class V,class MV,class S> friend S _vmvcimult(const V &rv1, const MV &rv2) 00158 #if(CXSC_INDEX_CHECK) 00159 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00160 #else 00161 throw(); 00162 #endif 00163 template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) throw(); 00164 template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2) 00165 #if(CXSC_INDEX_CHECK) 00166 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00167 #else 00168 throw(); 00169 #endif 00170 template <class MV1,class MV2,class E> friend E _mvmvminus(const MV1 &rv1, const MV2 &rv2) 00171 #if(CXSC_INDEX_CHECK) 00172 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00173 #else 00174 throw(); 00175 #endif 00176 template <class MV,class V,class E> friend E _mvvplus(const MV &rv1, const V &rv2) 00177 #if(CXSC_INDEX_CHECK) 00178 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00179 #else 00180 throw(); 00181 #endif 00182 template <class MV,class V,class E> friend E _mvvminus(const MV &rv1, const V &rv2) 00183 #if(CXSC_INDEX_CHECK) 00184 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00185 #else 00186 throw(); 00187 #endif 00188 template <class V,class MV,class E> friend E _vmvminus(const V &rv1, const MV &rv2) 00189 #if(CXSC_INDEX_CHECK) 00190 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00191 #else 00192 throw(); 00193 #endif 00194 template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) throw(); 00195 template <class MV,class S> friend MV &_mvsmultassign(MV &v,const S &r) throw(); 00196 template <class MV, class S> friend MV &_mvsplusassign(MV &v,const S &r) throw(); 00197 template <class MV,class S> friend MV &_mvsminusassign(MV &v,const S &r) throw(); 00198 template <class MV,class S> friend MV &_mvsdivassign(MV &v,const S &r) throw(); 00199 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv) 00200 #if(CXSC_INDEX_CHECK) 00201 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00202 #else 00203 throw(); 00204 #endif 00205 template <class V,class MV> friend V &_vmvplusassign(V &rv,const MV &v) 00206 #if(CXSC_INDEX_CHECK) 00207 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00208 #else 00209 throw(); 00210 #endif 00211 template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv) 00212 #if(CXSC_INDEX_CHECK) 00213 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00214 #else 00215 throw(); 00216 #endif 00217 template <class V,class MV> friend V &_vmvminusassign(V &rv,const MV &v) 00218 #if(CXSC_INDEX_CHECK) 00219 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00220 #else 00221 throw(); 00222 #endif 00223 // Real 00224 00225 00226 // interval 00227 00228 template <class V,class MV> friend V &_vmvsetinf(V &rv,const MV &v) 00229 #if(CXSC_INDEX_CHECK) 00230 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00231 #else 00232 throw(); 00233 #endif 00234 template <class V,class MV> friend V &_vmvsetsup(V &rv,const MV &v) 00235 #if(CXSC_INDEX_CHECK) 00236 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00237 #else 00238 throw(); 00239 #endif 00240 template <class V,class MV> friend V &_vmvusetinf(V &rv,const MV &v) 00241 #if(CXSC_INDEX_CHECK) 00242 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00243 #else 00244 throw(); 00245 #endif 00246 template <class V,class MV> friend V &_vmvusetsup(V &rv,const MV &v) 00247 #if(CXSC_INDEX_CHECK) 00248 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00249 #else 00250 throw(); 00251 #endif 00252 00253 #endif 00254 00255 //----------------- Konstruktoren ---------------------------------- 00256 00258 explicit INLINE cmatrix_subv (complex *d, const int &l, const int &u, const int &s, const int &st, const int &o) throw():dat(d),lb(l),ub(u),size(s),start(st),offset(o) { } 00259 public: 00261 INLINE cmatrix_subv(const cmatrix_subv &v) throw():dat(v.dat),lb(v.lb),ub(v.ub),size(v.size),start(v.start),offset(v.offset) { } 00262 public: 00263 00264 //---------------------- Standardfunktionen ------------------------ 00266 friend INLINE int Lb(const cmatrix_subv &rv) throw() { return rv.lb; } 00268 friend INLINE int Ub(const cmatrix_subv &rv) throw() { return rv.ub; } 00270 friend INLINE int VecLen(const cmatrix_subv &rv) throw() { return rv.size; } 00271 00273 INLINE complex& operator [](const int &i) const 00274 #if(CXSC_INDEX_CHECK) 00275 throw(ERROR_CVECTOR_ELEMENT_NOT_IN_VEC); 00276 #else 00277 throw(); 00278 #endif 00279 00281 INLINE complex& operator [](const int &i) 00282 #if(CXSC_INDEX_CHECK) 00283 throw(ERROR_CVECTOR_ELEMENT_NOT_IN_VEC); 00284 #else 00285 throw(); 00286 #endif 00287 00289 INLINE cmatrix_subv &operator ()() throw() { return *this; } 00291 INLINE cmatrix_subv operator ()(const int &i) 00292 #if(CXSC_INDEX_CHECK) 00293 throw(ERROR_CVECTOR_SUB_ARRAY_TOO_BIG); 00294 #else 00295 throw(); 00296 #endif 00297 00298 INLINE cmatrix_subv operator ()(const int &i1,const int &i2) 00299 #if(CXSC_INDEX_CHECK) 00300 throw(ERROR_CVECTOR_SUB_ARRAY_TOO_BIG); 00301 #else 00302 throw(); 00303 #endif 00304 00306 INLINE cmatrix_subv &operator =(const scmatrix_subv &rv); 00308 INLINE cmatrix_subv &operator =(const scvector &r); 00310 INLINE cmatrix_subv &operator =(const scvector_slice &r); 00312 INLINE cmatrix_subv &operator =(const srmatrix_subv &rv); 00314 INLINE cmatrix_subv &operator =(const srvector &r); 00316 INLINE cmatrix_subv &operator =(const srvector_slice &r); 00317 00319 INLINE cmatrix_subv &operator =(const cmatrix_subv &rv) throw(); 00321 INLINE cmatrix_subv &operator =(const complex &r) throw(); 00323 INLINE cmatrix_subv &operator =(const cmatrix &m) 00324 #if(CXSC_INDEX_CHECK) 00325 throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ); 00326 #else 00327 throw(); 00328 #endif 00329 00330 INLINE cmatrix_subv &operator =(const cmatrix_slice &m) 00331 #if(CXSC_INDEX_CHECK) 00332 throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ); 00333 #else 00334 throw(); 00335 #endif 00336 00337 INLINE cmatrix_subv &operator =(const cvector &v) 00338 #if(CXSC_INDEX_CHECK) 00339 throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM); 00340 #else 00341 throw(); 00342 #endif 00343 00344 INLINE cmatrix_subv &operator =(const cvector_slice &v) 00345 #if(CXSC_INDEX_CHECK) 00346 throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM); 00347 #else 00348 throw(); 00349 #endif 00350 00351 //Sparse 00353 INLINE cmatrix_subv &operator +=(const scmatrix_subv &rv); 00355 INLINE cmatrix_subv &operator +=(const scvector &r); 00357 INLINE cmatrix_subv &operator +=(const scvector_slice &r); 00359 INLINE cmatrix_subv &operator +=(const srmatrix_subv &rv); 00361 INLINE cmatrix_subv &operator +=(const srvector &r); 00363 INLINE cmatrix_subv &operator +=(const srvector_slice &r); 00365 INLINE cmatrix_subv &operator -=(const scmatrix_subv &rv); 00367 INLINE cmatrix_subv &operator -=(const scvector &r); 00369 INLINE cmatrix_subv &operator -=(const scvector_slice &r); 00371 INLINE cmatrix_subv &operator -=(const srmatrix_subv &rv); 00373 INLINE cmatrix_subv &operator -=(const srvector &r); 00375 INLINE cmatrix_subv &operator -=(const srvector_slice &r); 00376 00378 INLINE cmatrix_subv &operator *=(const complex &c) throw(); 00380 INLINE cmatrix_subv &operator +=(const complex &c) throw(); 00382 INLINE cmatrix_subv &operator -=(const complex &c) throw(); 00384 INLINE cmatrix_subv &operator /=(const complex &c) throw(); 00386 INLINE cmatrix_subv &operator -=(const cvector &rv) 00387 #if(CXSC_INDEX_CHECK) 00388 throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM); 00389 #else 00390 throw(); 00391 #endif 00392 00393 INLINE cmatrix_subv &operator +=(const cvector &rv) 00394 #if(CXSC_INDEX_CHECK) 00395 throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM); 00396 #else 00397 throw(); 00398 #endif 00399 00400 INLINE cmatrix_subv &operator -=(const cvector_slice &rv) 00401 #if(CXSC_INDEX_CHECK) 00402 throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM); 00403 #else 00404 throw(); 00405 #endif 00406 00407 INLINE cmatrix_subv &operator +=(const cvector_slice &rv) 00408 #if(CXSC_INDEX_CHECK) 00409 throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM); 00410 #else 00411 throw(); 00412 #endif 00413 // Real 00415 INLINE cmatrix_subv &operator =(const rmatrix_subv &rv) throw(); 00417 INLINE cmatrix_subv &operator =(const real &r) throw(); 00419 INLINE cmatrix_subv &operator =(const rmatrix &m) 00420 #if(CXSC_INDEX_CHECK) 00421 throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ); 00422 #else 00423 throw(); 00424 #endif 00425 00426 INLINE cmatrix_subv &operator =(const rmatrix_slice &m) 00427 #if(CXSC_INDEX_CHECK) 00428 throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ); 00429 #else 00430 throw(); 00431 #endif 00432 00433 INLINE cmatrix_subv &operator =(const rvector &v) 00434 #if(CXSC_INDEX_CHECK) 00435 throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM); 00436 #else 00437 throw(); 00438 #endif 00439 00440 INLINE cmatrix_subv &operator =(const rvector_slice &v) 00441 #if(CXSC_INDEX_CHECK) 00442 throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM); 00443 #else 00444 throw(); 00445 #endif 00446 00448 INLINE cmatrix_subv &operator *=(const real &c) throw(); 00450 INLINE cmatrix_subv &operator +=(const real &c) throw(); 00452 INLINE cmatrix_subv &operator -=(const real &c) throw(); 00454 INLINE cmatrix_subv &operator /=(const real &c) throw(); 00456 INLINE cmatrix_subv &operator -=(const rvector &rv) 00457 #if(CXSC_INDEX_CHECK) 00458 throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM); 00459 #else 00460 throw(); 00461 #endif 00462 00463 INLINE cmatrix_subv &operator +=(const rvector &rv) 00464 #if(CXSC_INDEX_CHECK) 00465 throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM); 00466 #else 00467 throw(); 00468 #endif 00469 00470 INLINE cmatrix_subv &operator -=(const rvector_slice &rv) 00471 #if(CXSC_INDEX_CHECK) 00472 throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM); 00473 #else 00474 throw(); 00475 #endif 00476 00477 INLINE cmatrix_subv &operator +=(const rvector_slice &rv) 00478 #if(CXSC_INDEX_CHECK) 00479 throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM); 00480 #else 00481 throw(); 00482 #endif 00483 //#else 00484 //#endif 00485 00486 }; 00487 00489 INLINE cmatrix_subv Row(cmatrix &m,const int &i) 00490 #if(CXSC_INDEX_CHECK) 00491 throw(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT); 00492 #else 00493 throw(); 00494 #endif 00495 00496 INLINE cmatrix_subv Col(cmatrix &m,const int &i) 00497 #if(CXSC_INDEX_CHECK) 00498 throw(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT); 00499 #else 00500 throw(); 00501 #endif 00502 00503 00504 00505 //----------------------- Matrix ----------------------------------------------- 00506 00507 class cmatrix_slice; 00508 00510 00513 class cmatrix 00514 { 00515 friend class cmatrix_slice; 00516 friend class cmatrix_subv; 00517 friend class cimatrix; 00518 private: 00519 complex *dat; 00520 int lb1,ub1,lb2,ub2,xsize,ysize; 00521 00522 public: 00523 double* to_blas_array() const { return (double*)dat; } 00524 //#if(CXSC_INDEX_CHECK) 00525 #ifdef _CXSC_FRIEND_TPL 00526 //----------------- Templates --------------------------------------- 00527 template <class S,class M> friend void _smconstr(S &s,const M &m) 00528 #if(CXSC_INDEX_CHECK) 00529 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>,ERROR__USE_OF_UNINITIALIZED_OBJ<M>); 00530 #else 00531 throw(); 00532 #endif 00533 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m) 00534 #if(CXSC_INDEX_CHECK) 00535 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>); 00536 #else 00537 throw(); 00538 #endif 00539 template <class M1,class M2,class S> friend M1 &_mmassign(M1 &m1,const M2 &m,S ms) throw(); 00540 template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) throw(); 00541 template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m) 00542 #if(CXSC_INDEX_CHECK) 00543 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00544 #else 00545 throw(); 00546 #endif 00547 template <class M,class S> friend M &_msassign(M &m,const S &r) throw(); 00548 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m) 00549 #if(CXSC_INDEX_CHECK) 00550 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>); 00551 #else 00552 throw(); 00553 #endif 00554 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) throw(); 00555 template <class M> friend int _mlb(const M &m, const int &i) 00556 #if(CXSC_INDEX_CHECK) 00557 throw(ERROR__WRONG_ROW_OR_COL<M>); 00558 #else 00559 throw(); 00560 #endif 00561 template <class M> friend int _mub(const M &m, const int &i) 00562 #if(CXSC_INDEX_CHECK) 00563 throw(ERROR__WRONG_ROW_OR_COL<M>); 00564 #else 00565 throw(); 00566 #endif 00567 template <class M> friend M &_msetlb(M &m, const int &i,const int &j) 00568 #if(CXSC_INDEX_CHECK) 00569 throw(ERROR__WRONG_ROW_OR_COL<M>); 00570 #else 00571 throw(); 00572 #endif 00573 template <class M> friend M &_msetub(M &m, const int &i,const int &j) 00574 #if(CXSC_INDEX_CHECK) 00575 throw(ERROR__WRONG_ROW_OR_COL<M>); 00576 #else 00577 throw(); 00578 #endif 00579 template <class M,class E> friend E _mre(const M &m) throw(); 00580 template <class M,class E> friend E _mim(const M &m) throw(); 00581 template <class M1,class M2> friend M1 &_mmsetre(M1 &m1,const M2 &m2) 00582 #if(CXSC_INDEX_CHECK) 00583 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00584 #else 00585 throw(); 00586 #endif 00587 template <class M1,class M2> friend M1 &_mmsetim(M1 &m1,const M2 &m2) 00588 #if(CXSC_INDEX_CHECK) 00589 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00590 #else 00591 throw(); 00592 #endif 00593 template <class M1,class MS2> friend M1 &_mmssetre(M1 &m1,const MS2 &ms2) 00594 #if(CXSC_INDEX_CHECK) 00595 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00596 #else 00597 throw(); 00598 #endif 00599 template <class M1,class MS2> friend M1 &_mmssetim(M1 &m1,const MS2 &ms2) 00600 #if(CXSC_INDEX_CHECK) 00601 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00602 #else 00603 throw(); 00604 #endif 00605 template <class M> friend void _mresize(M &A) throw(); 00606 template <class M,class S> friend void _mresize(M &A,const int &m, const int &n) 00607 #if(CXSC_INDEX_CHECK) 00608 throw(ERROR__WRONG_BOUNDARIES<M>); 00609 #else 00610 throw(); 00611 #endif 00612 template <class M,class S> friend void _mresize(M &A,const int &m1, const int &m2,const int &n1,const int &n2) 00613 #if(CXSC_INDEX_CHECK) 00614 throw(ERROR__WRONG_BOUNDARIES<M>); 00615 #else 00616 throw(); 00617 #endif 00618 template <class M,class E> friend E _mabs(const M &m) throw(); 00619 //-------------- matrix-matrix ------------- 00620 template <class M1,class M2,class E> friend E _mmplus(const M1 &m1,const M2 &m2) 00621 #if(CXSC_INDEX_CHECK) 00622 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00623 #else 00624 throw(); 00625 #endif 00626 template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms) 00627 #if(CXSC_INDEX_CHECK) 00628 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00629 #else 00630 throw(); 00631 #endif 00632 template <class M> friend M _mminus(const M &m) throw(); 00633 template <class MS,class E> friend E _msminus(const MS &ms) throw(); 00634 template <class M1,class M2,class E> friend E _mmminus(const M1 &m1,const M2 &m2) 00635 #if(CXSC_INDEX_CHECK) 00636 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00637 #else 00638 throw(); 00639 #endif 00640 template <class M1,class M2> friend M1 &_mmplusassign(M1 &m1,const M2 &m2) 00641 #if(CXSC_INDEX_CHECK) 00642 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00643 #else 00644 throw(); 00645 #endif 00646 template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms) 00647 #if(CXSC_INDEX_CHECK) 00648 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00649 #else 00650 throw(); 00651 #endif 00652 template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1) 00653 #if(CXSC_INDEX_CHECK) 00654 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00655 #else 00656 throw(); 00657 #endif 00658 template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2) 00659 #if(CXSC_INDEX_CHECK) 00660 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00661 #else 00662 throw(); 00663 #endif 00664 template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms) 00665 #if(CXSC_INDEX_CHECK) 00666 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00667 #else 00668 throw(); 00669 #endif 00670 template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m) 00671 #if(CXSC_INDEX_CHECK) 00672 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00673 #else 00674 throw(); 00675 #endif 00676 template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2) 00677 #if(CXSC_INDEX_CHECK) 00678 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00679 #else 00680 throw(); 00681 #endif 00682 template <class M1,class M2> friend M1 &_mmminusassign(M1 &m1,const M2 &m2) 00683 #if(CXSC_INDEX_CHECK) 00684 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00685 #else 00686 throw(); 00687 #endif 00688 template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms) 00689 #if(CXSC_INDEX_CHECK) 00690 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00691 #else 00692 throw(); 00693 #endif 00694 template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1) 00695 #if(CXSC_INDEX_CHECK) 00696 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00697 #else 00698 throw(); 00699 #endif 00700 template <class M1,class M2,class E> friend E _mmcmult(const M1 &m1, const M2 &m2) 00701 #if(CXSC_INDEX_CHECK) 00702 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00703 #else 00704 throw(); 00705 #endif 00706 template <class M1,class M2,class E> friend E _mmcimult(const M1 &m1, const M2 &m2) 00707 #if(CXSC_INDEX_CHECK) 00708 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00709 #else 00710 throw(); 00711 #endif 00712 template <class M1,class M2,class S> friend M1 &_mmcmultassign(M1 &m1,const M2 &m2) 00713 #if(CXSC_INDEX_CHECK) 00714 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00715 #else 00716 throw(); 00717 #endif 00718 template <class M1,class M2,class S> friend M1 &_mmcimultassign(M1 &m1,const M2 &m2) 00719 #if(CXSC_INDEX_CHECK) 00720 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00721 #else 00722 throw(); 00723 #endif 00724 template <class M,class MS,class E> friend E _mmscmult(const M &m1, const MS &ms) 00725 #if(CXSC_INDEX_CHECK) 00726 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00727 #else 00728 throw(); 00729 #endif 00730 template <class M,class MS,class E> friend E _mmscimult(const M &m1, const MS &ms) 00731 #if(CXSC_INDEX_CHECK) 00732 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00733 #else 00734 throw(); 00735 #endif 00736 template <class MS,class M,class E> friend E _msmcmult(const MS &ms, const M &m2) 00737 #if(CXSC_INDEX_CHECK) 00738 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00739 #else 00740 throw(); 00741 #endif 00742 template <class MS,class M,class E> friend E _msmcimult(const MS &ms, const M &m2) 00743 #if(CXSC_INDEX_CHECK) 00744 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00745 #else 00746 throw(); 00747 #endif 00748 template <class M,class MS,class S> friend M &_mmscmultassign(M &m1,const MS &ms) 00749 #if(CXSC_INDEX_CHECK) 00750 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00751 #else 00752 throw(); 00753 #endif 00754 template <class M,class MS,class S> friend M &_mmscimultassign(M &m1,const MS &ms) 00755 #if(CXSC_INDEX_CHECK) 00756 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00757 #else 00758 throw(); 00759 #endif 00760 template <class MS1,class MS2,class E> friend E _msmscmult(const MS1 &ms1, const MS2 &ms2) 00761 #if(CXSC_INDEX_CHECK) 00762 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00763 #else 00764 throw(); 00765 #endif 00766 template <class MS1,class MS2,class E> friend E _msmscimult(const MS1 &ms1, const MS2 &ms2) 00767 #if(CXSC_INDEX_CHECK) 00768 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00769 #else 00770 throw(); 00771 #endif 00772 template <class M1,class M2,class E> friend E _mmconv(const M1 &m1,const M2 &m2) 00773 #if(CXSC_INDEX_CHECK) 00774 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00775 #else 00776 throw(); 00777 #endif 00778 template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms) 00779 #if(CXSC_INDEX_CHECK) 00780 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00781 #else 00782 throw(); 00783 #endif 00784 //-------- matrix-scalar ----------------- 00785 template <class S,class M,class E> friend E _smmult(const S &c, const M &m) throw(); 00786 template <class M,class S> friend M &_msmultassign(M &m,const S &c) throw(); 00787 template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) throw(); 00788 template <class M,class S,class E> friend E _msdiv(const M &m,const S &c) throw(); 00789 template <class M,class S> friend M &_msdivassign(M &m,const S &c) throw(); 00790 template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) throw(); 00791 //-------- matrix-vector --------------------- 00792 template <class M,class V,class E> friend E _mvcmult(const M &m,const V &v) 00793 #if(CXSC_INDEX_CHECK) 00794 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00795 #else 00796 throw(); 00797 #endif 00798 template <class M,class V,class E> friend E _mvcimult(const M &m,const V &v) 00799 #if(CXSC_INDEX_CHECK) 00800 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00801 #else 00802 throw(); 00803 #endif 00804 template <class V,class M,class E> friend E _vmcmult(const V &v,const M &m) 00805 #if(CXSC_INDEX_CHECK) 00806 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00807 #else 00808 throw(); 00809 #endif 00810 template <class V,class M,class E> friend E _vmcimult(const V &v,const M &m) 00811 #if(CXSC_INDEX_CHECK) 00812 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00813 #else 00814 throw(); 00815 #endif 00816 template <class V,class M,class S> friend V &_vmcmultassign(V &v,const M &m) 00817 #if(CXSC_INDEX_CHECK) 00818 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00819 #else 00820 throw(); 00821 #endif 00822 template <class V,class M,class S> friend V &_vmcimultassign(V &v,const M &m) 00823 #if(CXSC_INDEX_CHECK) 00824 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00825 #else 00826 throw(); 00827 #endif 00828 template <class VS,class M,class S> friend VS &_vsmcmultassign(VS &v,const M &m) 00829 #if(CXSC_INDEX_CHECK) 00830 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00831 #else 00832 throw(); 00833 #endif 00834 template <class VS,class M,class S> friend VS &_vsmcimultassign(VS &v,const M &m) 00835 #if(CXSC_INDEX_CHECK) 00836 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00837 #else 00838 throw(); 00839 #endif 00840 00841 template <class M> friend void *_mvoid(const M &m) throw(); 00842 template <class M> friend bool _mnot(const M &m) throw(); 00843 template <class MS> friend void *_msvoid(const MS &ms) throw(); 00844 template <class MS> friend bool _msnot(const MS &ms) throw(); 00845 template <class M1,class M2> friend bool _mmeq(const M1 &m1,const M2 &m2) throw(); 00846 template <class M1,class M2> friend bool _mmneq(const M1 &m1,const M2 &m2) throw(); 00847 template <class M1,class M2> friend bool _mmless(const M1 &m1,const M2 &m2) throw(); 00848 template <class M1,class M2> friend bool _mmleq(const M1 &m1,const M2 &m2) throw(); 00849 template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) throw(); 00850 template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) throw(); 00851 template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) throw(); 00852 template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) throw(); 00853 template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) throw(); 00854 template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) throw(); 00855 template <class M> friend std::ostream &_mout(std::ostream &s,const M &r) throw(); 00856 template <class M> friend std::istream &_min(std::istream &s,M &r) throw(); 00857 00858 // Real 00859 00860 //--- Real --------- matrix-matrix ---------------------- 00861 00862 //--- Real --------- matrix-scalar ---------------------- 00863 00864 //--- Real --------- matrix-vector ---------------------- 00865 template <class MS,class V,class E> friend E _msvcmult(const MS &ms,const V &v) 00866 #if(CXSC_INDEX_CHECK) 00867 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00868 #else 00869 throw(); 00870 #endif 00871 template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v) 00872 #if(CXSC_INDEX_CHECK) 00873 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00874 #else 00875 throw(); 00876 #endif 00877 template <class V,class MS,class E> friend E _vmscmult(const V &v,const MS &ms) 00878 #if(CXSC_INDEX_CHECK) 00879 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00880 #else 00881 throw(); 00882 #endif 00883 template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms) 00884 #if(CXSC_INDEX_CHECK) 00885 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00886 #else 00887 throw(); 00888 #endif 00889 00890 // interval -------- 00891 // matrix-matrix 00892 00893 template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2) 00894 #if(CXSC_INDEX_CHECK) 00895 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00896 #else 00897 throw(); 00898 #endif 00899 template <class M1,class M2,class E> friend E _mmsect(const M1 &m1,const M2 &m2) 00900 #if(CXSC_INDEX_CHECK) 00901 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00902 #else 00903 throw(); 00904 #endif 00905 template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms) 00906 #if(CXSC_INDEX_CHECK) 00907 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00908 #else 00909 throw(); 00910 #endif 00911 00912 template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2) 00913 #if(CXSC_INDEX_CHECK) 00914 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00915 #else 00916 throw(); 00917 #endif 00918 // matrix-scalar 00919 00920 // matrix-vector 00921 00922 // cinterval ---------- 00923 00924 template <class M,class E> friend E _mdiam(const M &m) throw(); 00925 template <class M,class E> friend E _mmid(const M &m) throw(); 00926 template <class MS,class E> friend E _msdiam(const MS &ms) throw(); 00927 template <class MS,class E> friend E _msmid(const MS &ms) throw(); 00928 template <class M,class E> friend E _minf(const M &m) throw(); 00929 template <class MS,class E> friend E _msinf(const MS &ms) throw(); 00930 template <class M,class E> friend E _msup(const M &m) throw(); 00931 template <class MS,class E> friend E _mssup(const MS &ms) throw(); 00932 template <class M1,class M2> friend M1 &_mmsetinf(M1 &m1,const M2 &m2) 00933 #if(CXSC_INDEX_CHECK) 00934 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00935 #else 00936 throw(); 00937 #endif 00938 template <class M1,class M2> friend M1 &_mmsetsup(M1 &m1,const M2 &m2) 00939 #if(CXSC_INDEX_CHECK) 00940 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00941 #else 00942 throw(); 00943 #endif 00944 template <class M1,class M2> friend M1 &_mmusetinf(M1 &m1,const M2 &m2) 00945 #if(CXSC_INDEX_CHECK) 00946 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00947 #else 00948 throw(); 00949 #endif 00950 template <class M1,class M2> friend M1 &_mmusetsup(M1 &m1,const M2 &m2) 00951 #if(CXSC_INDEX_CHECK) 00952 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00953 #else 00954 throw(); 00955 #endif 00956 template <class MS1,class M2> friend MS1 &_msmsetinf(MS1 &ms1,const M2 &m2) 00957 #if(CXSC_INDEX_CHECK) 00958 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 00959 #else 00960 throw(); 00961 #endif 00962 template <class MS1,class M2> friend MS1 &_msmsetsup(MS1 &ms1,const M2 &m2) 00963 #if(CXSC_INDEX_CHECK) 00964 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 00965 #else 00966 throw(); 00967 #endif 00968 template <class MS1,class M2> friend MS1 &_msmusetinf(MS1 &ms1,const M2 &m2) 00969 #if(CXSC_INDEX_CHECK) 00970 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 00971 #else 00972 throw(); 00973 #endif 00974 template <class MS1,class M2> friend MS1 &_msmusetsup(MS1 &ms1,const M2 &m2) 00975 #if(CXSC_INDEX_CHECK) 00976 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 00977 #else 00978 throw(); 00979 #endif 00980 00981 // matrix-matrix 00982 00983 template <class M1,class M2> friend M1 &_mmconvassign(M1 &m1,const M2 &m2) 00984 #if(CXSC_INDEX_CHECK) 00985 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00986 #else 00987 throw(); 00988 #endif 00989 template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms) 00990 #if(CXSC_INDEX_CHECK) 00991 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00992 #else 00993 throw(); 00994 #endif 00995 template <class MS,class M> friend MS &_msmconvassign(MS &ms,const M &m1) 00996 #if(CXSC_INDEX_CHECK) 00997 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00998 #else 00999 throw(); 01000 #endif 01001 01002 template <class M1,class M2> friend M1 &_mmsectassign(M1 &m1,const M2 &m2) 01003 #if(CXSC_INDEX_CHECK) 01004 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 01005 #else 01006 throw(); 01007 #endif 01008 template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms) 01009 #if(CXSC_INDEX_CHECK) 01010 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01011 #else 01012 throw(); 01013 #endif 01014 template <class MS,class M> friend MS &_msmsectassign(MS &ms,const M &m1) 01015 #if(CXSC_INDEX_CHECK) 01016 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01017 #else 01018 throw(); 01019 #endif 01020 // matrix-scalar 01021 01022 // matrix-vector 01023 01024 #endif 01025 01026 //-------------------------- Konstruktoren ---------------------------- 01027 01028 // complex 01030 INLINE cmatrix(const cmatrix &rm) throw(); 01032 INLINE cmatrix(const cmatrix_slice &rm) throw(); 01034 INLINE cmatrix(const scmatrix &rm); 01036 INLINE cmatrix(const scmatrix_slice &rm); 01038 INLINE cmatrix() throw(); 01040 explicit INLINE cmatrix(const int &m, const int &n) 01041 #if(CXSC_INDEX_CHECK) 01042 throw(ERROR_CMATRIX_WRONG_BOUNDARIES); 01043 #else 01044 throw(); 01045 #endif 01046 01047 explicit INLINE cmatrix(const int &m1, const int &n1, const int &m2, const int &n2) 01048 #if(CXSC_INDEX_CHECK) 01049 throw(ERROR_CMATRIX_WRONG_BOUNDARIES); 01050 #else 01051 throw(); 01052 #endif 01053 01054 explicit INLINE cmatrix(const cvector &v) throw(); 01056 explicit INLINE cmatrix(const cvector_slice &v) throw(); 01058 explicit INLINE cmatrix(const complex &r) throw(); 01060 INLINE cmatrix &operator =(const complex &r) throw(); 01062 INLINE cmatrix &operator =(const cmatrix &m) throw(); 01064 INLINE cmatrix &operator =(const cmatrix_slice &ms) throw(); 01066 INLINE cmatrix &operator =(const scmatrix &m); 01068 INLINE cmatrix &operator =(const scmatrix_slice &ms); 01070 INLINE cmatrix &operator =(const cvector &v) throw(); 01072 INLINE cmatrix &operator =(const cvector_slice &v) throw(); 01073 // real 01075 explicit INLINE cmatrix(const real &) throw(); 01077 explicit INLINE cmatrix(const rmatrix &rm) throw(); 01079 explicit INLINE cmatrix(const rmatrix_slice &rm) throw(); 01081 explicit INLINE cmatrix(const srmatrix &rm); 01083 explicit INLINE cmatrix(const srmatrix_slice &rm); 01085 explicit INLINE cmatrix(const rvector &v) throw(); 01087 explicit INLINE cmatrix(const rvector_slice &v) throw(); 01089 INLINE cmatrix &operator =(const real &r) throw(); 01091 INLINE cmatrix &operator =(const rmatrix &m) throw(); 01093 INLINE cmatrix &operator =(const rmatrix_slice &ms) throw(); 01095 INLINE cmatrix &operator =(const srmatrix &m); 01097 INLINE cmatrix &operator =(const srmatrix_slice &ms); 01099 INLINE cmatrix &operator =(const rvector &v) throw(); 01101 INLINE cmatrix &operator =(const rvector_slice &v) throw(); 01102 01103 //--------------------------- Destruktoren ----------------------------- 01104 01105 INLINE ~cmatrix() throw() { delete [] dat; } 01106 01107 01108 //--------------------------- Operatoren ----------------------------- 01110 INLINE cmatrix &operator +=(const srmatrix &m); 01112 INLINE cmatrix &operator +=(const srmatrix_slice &ms); 01114 INLINE cmatrix &operator +=(const scmatrix &m); 01116 INLINE cmatrix &operator +=(const scmatrix_slice &ms); 01118 INLINE cmatrix &operator -=(const srmatrix &m); 01120 INLINE cmatrix &operator -=(const srmatrix_slice &ms); 01122 INLINE cmatrix &operator -=(const scmatrix &m); 01124 INLINE cmatrix &operator -=(const scmatrix_slice &ms); 01126 INLINE cmatrix &operator *=(const srmatrix &m); 01128 INLINE cmatrix &operator *=(const srmatrix_slice &ms); 01130 INLINE cmatrix &operator *=(const scmatrix &m); 01132 INLINE cmatrix &operator *=(const scmatrix_slice &ms); 01133 01135 INLINE cmatrix operator()(const intvector& p, const intvector& q); 01137 INLINE cmatrix operator()(const intmatrix& P, const intmatrix& Q); 01139 INLINE cmatrix operator()(const intvector& p); 01141 INLINE cmatrix operator()(const intmatrix& P); 01142 01143 01144 //------------------------- Standardfunktionen ------------------------- 01145 01147 INLINE cmatrix_subv operator [](const int &i) const 01148 #if(CXSC_INDEX_CHECK) 01149 throw(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT); 01150 #else 01151 throw(); 01152 #endif 01153 01154 INLINE cmatrix_subv operator [](const cxscmatrix_column &i) const 01155 #if(CXSC_INDEX_CHECK) 01156 throw(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT); 01157 #else 01158 throw(); 01159 #endif 01160 01161 INLINE cmatrix_subv operator [](const int &i) 01162 #if(CXSC_INDEX_CHECK) 01163 throw(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT); 01164 #else 01165 throw(); 01166 #endif 01167 01168 INLINE cmatrix_subv operator [](const cxscmatrix_column &i) 01169 #if(CXSC_INDEX_CHECK) 01170 throw(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT); 01171 #else 01172 throw(); 01173 #endif 01174 01175 INLINE cmatrix &operator ()() throw() { return *this; } 01177 INLINE cmatrix_slice operator ()(const int &m, const int &n) 01178 #if(CXSC_INDEX_CHECK) 01179 throw(ERROR_CMATRIX_SUB_ARRAY_TOO_BIG); 01180 #else 01181 throw(); 01182 #endif 01183 01184 INLINE cmatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2) 01185 #if(CXSC_INDEX_CHECK) 01186 throw(ERROR_CMATRIX_SUB_ARRAY_TOO_BIG); 01187 #else 01188 throw(); 01189 #endif 01190 INLINE operator void*() throw(); 01191 //#else 01192 //#endif 01193 }; 01194 01195 01197 01202 class cmatrix_slice 01203 { 01204 friend class cmatrix; 01205 friend class cimatrix; 01206 private: 01207 complex *dat; 01208 int offset1,offset2,mxsize,mysize; 01209 int start1,end1,start2,end2,sxsize,sysize; // slice size 01210 01211 public: 01212 //#if(CXSC_INDEX_CHECK) 01213 #ifdef _CXSC_FRIEND_TPL 01214 //----------------- Templates --------------------------------------- 01215 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m) 01216 #if(CXSC_INDEX_CHECK) 01217 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>); 01218 #else 01219 throw(); 01220 #endif 01221 template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m) 01222 #if(CXSC_INDEX_CHECK) 01223 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01224 #else 01225 throw(); 01226 #endif 01227 template <class MS1,class MS2> friend MS1 &_msmsassign(MS1 &ms1,const MS2 &ms) 01228 #if(CXSC_INDEX_CHECK) 01229 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 01230 #else 01231 throw(); 01232 #endif 01233 template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) throw(); 01234 template <class MS,class S> friend MS &_mssassign(MS &ms,const S &r) throw(); 01235 01236 template <class MS> friend int _mslb(const MS &ms, const int &i) 01237 #if(CXSC_INDEX_CHECK) 01238 throw(ERROR__WRONG_ROW_OR_COL<MS>); 01239 #else 01240 throw(); 01241 #endif 01242 template <class MS> friend int _msub(const MS &ms, const int &i) 01243 #if(CXSC_INDEX_CHECK) 01244 throw(ERROR__WRONG_ROW_OR_COL<MS>); 01245 #else 01246 throw(); 01247 #endif 01248 template <class MS,class E> friend E _msre(const MS &ms) throw(); 01249 template <class MS,class E> friend E _msim(const MS &ms) throw(); 01250 template <class MS1,class M2> friend MS1 &_msmsetre(MS1 &ms1,const M2 &m2) 01251 #if(CXSC_INDEX_CHECK) 01252 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 01253 #else 01254 throw(); 01255 #endif 01256 template <class MS1,class M2> friend MS1 &_msmsetim(MS1 &ms1,const M2 &m2) 01257 #if(CXSC_INDEX_CHECK) 01258 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 01259 #else 01260 throw(); 01261 #endif 01262 template <class MS1,class MS2> friend MS1 &_msmssetre(MS1 &ms1,const MS2 &ms2) 01263 #if(CXSC_INDEX_CHECK) 01264 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 01265 #else 01266 throw(); 01267 #endif 01268 template <class MS1,class MS2> friend MS1 &_msmssetim(MS1 &ms1,const MS2 &ms2) 01269 #if(CXSC_INDEX_CHECK) 01270 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 01271 #else 01272 throw(); 01273 #endif 01274 template <class MS,class E> friend E _msabs(const MS &ms) throw(); 01275 //-------- matrix-matrix -------------- 01276 template <class MS,class E> friend E _msminus(const MS &ms) throw(); 01277 template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms) 01278 #if(CXSC_INDEX_CHECK) 01279 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01280 #else 01281 throw(); 01282 #endif 01283 template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2) 01284 #if(CXSC_INDEX_CHECK) 01285 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01286 #else 01287 throw(); 01288 #endif 01289 template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms) 01290 #if(CXSC_INDEX_CHECK) 01291 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01292 #else 01293 throw(); 01294 #endif 01295 template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1) 01296 #if(CXSC_INDEX_CHECK) 01297 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01298 #else 01299 throw(); 01300 #endif 01301 template <class MS1,class MS2> friend MS1 &_msmsplusassign(MS1 &ms1,const MS2 &ms2) 01302 #if(CXSC_INDEX_CHECK) 01303 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 01304 #else 01305 throw(); 01306 #endif 01307 template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms) 01308 #if(CXSC_INDEX_CHECK) 01309 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01310 #else 01311 throw(); 01312 #endif 01313 template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m) 01314 #if(CXSC_INDEX_CHECK) 01315 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01316 #else 01317 throw(); 01318 #endif 01319 template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2) 01320 #if(CXSC_INDEX_CHECK) 01321 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01322 #else 01323 throw(); 01324 #endif 01325 template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms) 01326 #if(CXSC_INDEX_CHECK) 01327 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01328 #else 01329 throw(); 01330 #endif 01331 template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1) 01332 #if(CXSC_INDEX_CHECK) 01333 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01334 #else 01335 throw(); 01336 #endif 01337 template <class MS1,class MS2> friend MS1 &_msmsminusassign(MS1 &ms1,const MS2 &ms2) 01338 #if(CXSC_INDEX_CHECK) 01339 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 01340 #else 01341 throw(); 01342 #endif 01343 template <class M,class MS,class E> friend E _mmscmult(const M &m1, const MS &ms) 01344 #if(CXSC_INDEX_CHECK) 01345 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01346 #else 01347 throw(); 01348 #endif 01349 template <class M,class MS,class E> friend E _mmscimult(const M &m1, const MS &ms) 01350 #if(CXSC_INDEX_CHECK) 01351 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01352 #else 01353 throw(); 01354 #endif 01355 template <class MS,class M,class E> friend E _msmcmult(const MS &ms, const M &m2) 01356 #if(CXSC_INDEX_CHECK) 01357 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01358 #else 01359 throw(); 01360 #endif 01361 template <class MS,class M,class E> friend E _msmcimult(const MS &ms, const M &m2) 01362 #if(CXSC_INDEX_CHECK) 01363 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01364 #else 01365 throw(); 01366 #endif 01367 template <class M,class MS,class S> friend M &_mmscmultassign(M &m1,const MS &ms) 01368 #if(CXSC_INDEX_CHECK) 01369 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01370 #else 01371 throw(); 01372 #endif 01373 template <class M,class MS,class S> friend M &_mmscimultassign(M &m1,const MS &ms) 01374 #if(CXSC_INDEX_CHECK) 01375 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01376 #else 01377 throw(); 01378 #endif 01379 template <class MS1,class MS2,class E> friend E _msmscmult(const MS1 &ms1, const MS2 &ms2) 01380 #if(CXSC_INDEX_CHECK) 01381 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01382 #else 01383 throw(); 01384 #endif 01385 template <class MS1,class MS2,class E> friend E _msmscimult(const MS1 &ms1, const MS2 &ms2) 01386 #if(CXSC_INDEX_CHECK) 01387 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01388 #else 01389 throw(); 01390 #endif 01391 template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms) 01392 #if(CXSC_INDEX_CHECK) 01393 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01394 #else 01395 throw(); 01396 #endif 01397 template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2) 01398 #if(CXSC_INDEX_CHECK) 01399 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01400 #else 01401 throw(); 01402 #endif 01403 //--------- matrix-vector -------------- 01404 template <class MS,class V,class E> friend E _msvcmult(const MS &ms,const V &v) 01405 #if(CXSC_INDEX_CHECK) 01406 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01407 #else 01408 throw(); 01409 #endif 01410 template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v) 01411 #if(CXSC_INDEX_CHECK) 01412 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01413 #else 01414 throw(); 01415 #endif 01416 template <class V,class MS,class E> friend E _vmscmult(const V &v,const MS &ms) 01417 #if(CXSC_INDEX_CHECK) 01418 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01419 #else 01420 throw(); 01421 #endif 01422 template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms) 01423 #if(CXSC_INDEX_CHECK) 01424 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01425 #else 01426 throw(); 01427 #endif 01428 template <class V,class MS,class S> friend V &_vmscmultassign(V &v,const MS &ms) 01429 #if(CXSC_INDEX_CHECK) 01430 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01431 #else 01432 throw(); 01433 #endif 01434 template <class V,class MS,class S> friend V &_vmscimultassign(V &v,const MS &ms) 01435 #if(CXSC_INDEX_CHECK) 01436 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01437 #else 01438 throw(); 01439 #endif 01440 //--------- matrix-scalar -------------- 01441 template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) throw(); 01442 template <class MS,class S> friend MS &_mssmultassign(MS &ms,const S &c) throw(); 01443 template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) throw(); 01444 template <class MS,class S> friend MS &_mssdivassign(MS &ms,const S &c) throw(); 01445 01446 template <class MS> friend void *_msvoid(const MS &ms) throw(); 01447 template <class MS> friend bool _msnot(const MS &ms) throw(); 01448 template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) throw(); 01449 template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) throw(); 01450 template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) throw(); 01451 template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) throw(); 01452 template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) throw(); 01453 template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) throw(); 01454 template <class MS1,class MS2> friend bool _msmseq(const MS1 &ms1,const MS2 &ms2) throw(); 01455 template <class MS1,class MS2> friend bool _msmsneq(const MS1 &ms1,const MS2 &ms2) throw(); 01456 template <class MS1,class MS2> friend bool _msmsless(const MS1 &ms1,const MS2 &ms2) throw(); 01457 template <class MS1,class MS2> friend bool _msmsleq(const MS1 &ms1,const MS2 &ms2) throw(); 01458 template <class MS> friend std::ostream &_msout(std::ostream &s,const MS &r) throw(); 01459 template <class MS> friend std::istream &_msin(std::istream &s,MS &r) throw(); 01460 01461 // Real 01462 01463 //--- Real ------------ matrix-scalar ----------- 01464 //--- Real ------------ matrix-vector ----------- 01465 //--- Real ------------ matrix-matrix ----------- 01466 // interval ---------------- 01467 // matrix-matrix 01468 01469 template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms) 01470 #if(CXSC_INDEX_CHECK) 01471 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01472 #else 01473 throw(); 01474 #endif 01475 template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2) 01476 #if(CXSC_INDEX_CHECK) 01477 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01478 #else 01479 throw(); 01480 #endif 01481 // matrix-scalar 01482 // matrix-vector 01483 01484 // cinterval -------------- 01485 01486 template <class M1,class MS2> friend M1 &_mmssetinf(M1 &m1,const MS2 &ms2) 01487 #if(CXSC_INDEX_CHECK) 01488 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 01489 #else 01490 throw(); 01491 #endif 01492 template <class M1,class MS2> friend M1 &_mmssetsup(M1 &m1,const MS2 &ms2) 01493 #if(CXSC_INDEX_CHECK) 01494 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 01495 #else 01496 throw(); 01497 #endif 01498 template <class M1,class MS2> friend M1 &_mmsusetinf(M1 &m1,const MS2 &ms2) 01499 #if(CXSC_INDEX_CHECK) 01500 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 01501 #else 01502 throw(); 01503 #endif 01504 template <class M1,class MS2> friend M1 &_mmsusetsup(M1 &m1,const MS2 &ms2) 01505 #if(CXSC_INDEX_CHECK) 01506 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 01507 #else 01508 throw(); 01509 #endif 01510 template <class MS1,class MS2> friend MS1 &_msmssetinf(MS1 &ms1,const MS2 &ms2) 01511 #if(CXSC_INDEX_CHECK) 01512 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 01513 #else 01514 throw(); 01515 #endif 01516 template <class MS1,class MS2> friend MS1 &_msmssetsup(MS1 &ms1,const MS2 &ms2) 01517 #if(CXSC_INDEX_CHECK) 01518 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 01519 #else 01520 throw(); 01521 #endif 01522 template <class MS1,class MS2> friend MS1 &_msmsusetinf(MS1 &ms1,const MS2 &ms2) 01523 #if(CXSC_INDEX_CHECK) 01524 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 01525 #else 01526 throw(); 01527 #endif 01528 template <class MS1,class MS2> friend MS1 &_msmsusetsup(MS1 &ms1,const MS2 &ms2) 01529 #if(CXSC_INDEX_CHECK) 01530 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 01531 #else 01532 throw(); 01533 #endif 01534 01535 // matrix-matrix 01536 01537 template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms) 01538 #if(CXSC_INDEX_CHECK) 01539 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01540 #else 01541 throw(); 01542 #endif 01543 template <class MS1,class MS2> friend MS1 &_msmsconvassign(MS1 &ms1,const MS2 &ms2) 01544 #if(CXSC_INDEX_CHECK) 01545 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 01546 #else 01547 throw(); 01548 #endif 01549 01550 template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms) 01551 #if(CXSC_INDEX_CHECK) 01552 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01553 #else 01554 throw(); 01555 #endif 01556 template <class MS1,class MS2> friend MS1 &_msmssectassign(MS1 &ms1,const MS2 &ms2) 01557 #if(CXSC_INDEX_CHECK) 01558 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 01559 #else 01560 throw(); 01561 #endif 01562 01563 // matrix-scalar 01564 // cinterval -- matrix-vector 01565 01566 01567 /* friend TINLINE civector &_vsmscimultassign<civector_slice,cmatrix_slice,cinterval>(civector_slice &v,const cmatrix_slice &ms) 01568 #if(CXSC_INDEX_CHECK) 01569 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM); 01570 #else 01571 throw(); 01572 #endif */ 01573 01574 #endif 01575 01576 //--------------- Konstruktoren ---------------------------------------- 01577 01579 explicit INLINE cmatrix_slice(cmatrix &a,const int &l1,const int &u1,const int &l2, const int &u2) throw():dat(a.dat),offset1(l1-a.lb1),offset2(l2-a.lb2),mxsize(a.xsize),mysize(a.ysize),start1(l1),end1(u1),start2(l2),end2(u2),sxsize(u2-l2+1),sysize(u1-l1+1) { } 01581 explicit INLINE cmatrix_slice(cmatrix_slice &a,const int &l1,const int &u1,const int &l2, const int &u2) throw():dat(a.dat),offset1(a.offset1+l1-a.start1),offset2(a.offset2+l2-a.start2),mxsize(a.mxsize),mysize(a.mysize),start1(l1),end1(u1),start2(l2),end2(u2),sxsize(u2-l2+1),sysize(u1-l1+1) { } 01582 public: 01584 INLINE cmatrix_slice(const cmatrix_slice &ms) throw():dat(ms.dat),offset1(ms.offset1),offset2(ms.offset2),mxsize(ms.mxsize),mysize(ms.mysize),start1(ms.start1),end1(ms.end1),start2(ms.start2),end2(ms.end2),sxsize(ms.sxsize),sysize(ms.sysize) { } 01585 public: 01586 01587 //---------------- Standardfunktionen ----------------------------------- 01588 01589 friend cvector::cvector(const cmatrix_slice &sl) 01590 #if(CXSC_INDEX_CHECK) 01591 throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ); 01592 #else 01593 throw(); 01594 #endif 01595 friend INLINE cmatrix::cmatrix(const cmatrix_slice &) throw(); 01597 INLINE cmatrix_slice &operator =(const cmatrix &m) 01598 #if(CXSC_INDEX_CHECK) 01599 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 01600 #else 01601 throw(); 01602 #endif 01603 01604 //Sparse 01606 INLINE cmatrix_slice &operator =(const scmatrix &ms); 01608 INLINE cmatrix_slice &operator =(const scmatrix_slice &ms); 01610 INLINE cmatrix_slice &operator =(const srmatrix &ms); 01612 INLINE cmatrix_slice &operator =(const srmatrix_slice &ms); 01613 01614 01616 INLINE cmatrix_slice &operator =(const cmatrix_slice &ms) 01617 #if(CXSC_INDEX_CHECK) 01618 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 01619 #else 01620 throw(); 01621 #endif 01622 01623 INLINE cmatrix_slice &operator =(const complex &r) throw(); 01625 INLINE cmatrix_slice &operator =(const cvector &v) 01626 #if(CXSC_INDEX_CHECK) 01627 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 01628 #else 01629 throw(); 01630 #endif 01631 01632 INLINE cmatrix_slice &operator =(const cvector_slice &v) 01633 #if(CXSC_INDEX_CHECK) 01634 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 01635 #else 01636 throw(); 01637 #endif 01638 01639 INLINE cmatrix_slice &operator =(const rmatrix &m) 01640 #if(CXSC_INDEX_CHECK) 01641 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 01642 #else 01643 throw(); 01644 #endif 01645 01646 INLINE cmatrix_slice &operator =(const rmatrix_slice &ms) 01647 #if(CXSC_INDEX_CHECK) 01648 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 01649 #else 01650 throw(); 01651 #endif 01652 01653 INLINE cmatrix_slice &operator =(const real &r) throw(); 01655 INLINE cmatrix_slice &operator =(const rvector &v) 01656 #if(CXSC_INDEX_CHECK) 01657 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 01658 #else 01659 throw(); 01660 #endif 01661 01662 INLINE cmatrix_slice &operator =(const rvector_slice &v) 01663 #if(CXSC_INDEX_CHECK) 01664 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 01665 #else 01666 throw(); 01667 #endif 01668 01669 INLINE cmatrix_subv operator [](const int &i) 01670 #if(CXSC_INDEX_CHECK) 01671 throw(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT); 01672 #else 01673 throw(); 01674 #endif 01675 01676 INLINE cmatrix_subv operator [](const cxscmatrix_column &i) 01677 #if(CXSC_INDEX_CHECK) 01678 throw(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT); 01679 #else 01680 throw(); 01681 #endif 01682 01684 INLINE cmatrix_subv operator [](const int &i) const 01685 #if(CXSC_INDEX_CHECK) 01686 throw(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT); 01687 #else 01688 throw(); 01689 #endif 01690 01691 INLINE cmatrix_subv operator [](const cxscmatrix_column &i) const 01692 #if(CXSC_INDEX_CHECK) 01693 throw(ERROR_CMATRIX_ROW_OR_COL_NOT_IN_MAT); 01694 #else 01695 throw(); 01696 #endif 01697 01698 INLINE cmatrix_slice &operator ()() throw() { return *this; } 01700 INLINE cmatrix_slice operator ()(const int &m, const int &n) 01701 #if(CXSC_INDEX_CHECK) 01702 throw(ERROR_CMATRIX_SUB_ARRAY_TOO_BIG); 01703 #else 01704 throw(); 01705 #endif 01706 01707 INLINE cmatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2) 01708 #if(CXSC_INDEX_CHECK) 01709 throw(ERROR_CMATRIX_SUB_ARRAY_TOO_BIG); 01710 #else 01711 throw(); 01712 #endif 01713 01714 //Sparse 01716 INLINE cmatrix_slice &operator +=(const srmatrix &m); 01718 INLINE cmatrix_slice &operator +=(const srmatrix_slice &ms); 01720 INLINE cmatrix_slice &operator +=(const scmatrix &m); 01722 INLINE cmatrix_slice &operator +=(const scmatrix_slice &ms); 01724 INLINE cmatrix_slice &operator -=(const srmatrix &m); 01726 INLINE cmatrix_slice &operator -=(const srmatrix_slice &ms); 01728 INLINE cmatrix_slice &operator -=(const scmatrix &m); 01730 INLINE cmatrix_slice &operator -=(const scmatrix_slice &ms); 01732 INLINE cmatrix_slice &operator *=(const srmatrix &m); 01734 INLINE cmatrix_slice &operator *=(const srmatrix_slice &ms); 01736 INLINE cmatrix_slice &operator *=(const scmatrix &m); 01738 INLINE cmatrix_slice &operator *=(const scmatrix_slice &ms); 01739 01741 INLINE cmatrix_slice &operator *=(const cmatrix &m) 01742 #if(CXSC_INDEX_CHECK) 01743 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 01744 #else 01745 throw(); 01746 #endif 01747 01748 INLINE cmatrix_slice &operator *=(const rmatrix &m) 01749 #if(CXSC_INDEX_CHECK) 01750 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 01751 #else 01752 throw(); 01753 #endif 01754 01755 INLINE cmatrix_slice &operator *=(const cmatrix_slice &ms2) 01756 #if(CXSC_INDEX_CHECK) 01757 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 01758 #else 01759 throw(); 01760 #endif 01761 01762 INLINE cmatrix_slice &operator *=(const rmatrix_slice &ms2) 01763 #if(CXSC_INDEX_CHECK) 01764 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 01765 #else 01766 throw(); 01767 #endif 01768 01769 INLINE cmatrix_slice &operator +=(const cmatrix &m1) 01770 #if(CXSC_INDEX_CHECK) 01771 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 01772 #else 01773 throw(); 01774 #endif 01775 01776 INLINE cmatrix_slice &operator +=(const rmatrix &m1) 01777 #if(CXSC_INDEX_CHECK) 01778 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 01779 #else 01780 throw(); 01781 #endif 01782 01783 INLINE cmatrix_slice &operator +=(const cmatrix_slice &ms2) 01784 #if(CXSC_INDEX_CHECK) 01785 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 01786 #else 01787 throw(); 01788 #endif 01789 01790 INLINE cmatrix_slice &operator +=(const rmatrix_slice &ms2) 01791 #if(CXSC_INDEX_CHECK) 01792 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 01793 #else 01794 throw(); 01795 #endif 01796 01797 INLINE cmatrix_slice &operator -=(const cmatrix &m1) 01798 #if(CXSC_INDEX_CHECK) 01799 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 01800 #else 01801 throw(); 01802 #endif 01803 01804 INLINE cmatrix_slice &operator -=(const rmatrix &m1) 01805 #if(CXSC_INDEX_CHECK) 01806 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 01807 #else 01808 throw(); 01809 #endif 01810 01811 INLINE cmatrix_slice &operator -=(const cmatrix_slice &ms2) 01812 #if(CXSC_INDEX_CHECK) 01813 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 01814 #else 01815 throw(); 01816 #endif 01817 01818 INLINE cmatrix_slice &operator -=(const rmatrix_slice &ms2) 01819 #if(CXSC_INDEX_CHECK) 01820 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 01821 #else 01822 throw(); 01823 #endif 01824 01825 INLINE cmatrix_slice &operator |=(const cmatrix &m1) 01826 #if(CXSC_INDEX_CHECK) 01827 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 01828 #else 01829 throw(); 01830 #endif 01831 01832 INLINE cmatrix_slice &operator |=(const rmatrix &m1) 01833 #if(CXSC_INDEX_CHECK) 01834 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 01835 #else 01836 throw(); 01837 #endif 01838 01839 INLINE cmatrix_slice &operator |=(const cmatrix_slice &ms2) 01840 #if(CXSC_INDEX_CHECK) 01841 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 01842 #else 01843 throw(); 01844 #endif 01845 01846 INLINE cmatrix_slice &operator |=(const rmatrix_slice &ms2) 01847 #if(CXSC_INDEX_CHECK) 01848 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 01849 #else 01850 throw(); 01851 #endif 01852 01853 INLINE cmatrix_slice &operator *=(const complex &c) throw(); 01855 INLINE cmatrix_slice &operator *=(const real &c) throw(); 01857 INLINE cmatrix_slice &operator /=(const complex &c) throw(); 01859 INLINE cmatrix_slice &operator /=(const real &c) throw(); 01860 INLINE operator void*() throw(); 01861 //#else 01862 //#endif 01863 }; 01864 01865 //================================================================ 01866 //====================== Subvector Functions ===================== 01867 01868 //=======================Vector / Scalar ========================= 01869 01871 INLINE cvector operator /(const cmatrix_subv &rv, const complex &s) throw(); 01873 INLINE cvector operator *(const cmatrix_subv &rv, const complex &s) throw(); 01875 INLINE cvector operator *(const complex &s, const cmatrix_subv &rv) throw(); 01876 01877 //======================== Vector / Vector ======================== 01878 01880 INLINE rvector abs(const cmatrix_subv &mv) throw(); 01882 INLINE rvector Im(const cmatrix_subv &mv) throw(); 01884 INLINE rvector Re(const cmatrix_subv &mv) throw(); 01886 INLINE cmatrix_subv &SetIm(cmatrix_subv &mv,const rvector &rv) 01887 #if(CXSC_INDEX_CHECK) 01888 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 01889 #else 01890 throw(); 01891 #endif 01892 01893 INLINE cmatrix_subv &SetRe(cmatrix_subv &mv,const rvector &rv) 01894 #if(CXSC_INDEX_CHECK) 01895 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 01896 #else 01897 throw(); 01898 #endif 01899 01900 INLINE cmatrix_subv &SetRe(cmatrix_subv &iv,const real &r) throw(); 01902 INLINE cmatrix_subv &SetIm(cmatrix_subv &iv,const real &r) throw(); 01903 01904 01906 void accumulate(cdotprecision &dp, const cmatrix_subv & rv1, const cmatrix_subv &rv2) 01907 #if(CXSC_INDEX_CHECK) 01908 throw(OP_WITH_WRONG_DIM); 01909 #else 01910 throw(); 01911 #endif 01912 01914 void accumulate_approx(cdotprecision &dp, const cmatrix_subv & rv1, const cmatrix_subv &rv2); 01915 01917 void accumulate(cdotprecision &dp, const cvector & rv1, const cmatrix_subv &rv2) 01918 #if(CXSC_INDEX_CHECK) 01919 throw(OP_WITH_WRONG_DIM); 01920 #else 01921 throw(); 01922 #endif 01923 01925 void accumulate_approx(cdotprecision &dp, const cvector & rv1, const cmatrix_subv &rv2); 01926 01928 void accumulate(cdotprecision &dp, const cmatrix_subv & rv1, const cvector &rv2) 01929 #if(CXSC_INDEX_CHECK) 01930 throw(OP_WITH_WRONG_DIM); 01931 #else 01932 throw(); 01933 #endif 01934 01936 void accumulate_approx(cdotprecision &dp, const cmatrix_subv & rv1, const cvector &rv2); 01937 01939 void accumulate(cdotprecision &dp, const cvector_slice & sl1, const cmatrix_subv &rv2) 01940 #if(CXSC_INDEX_CHECK) 01941 throw(OP_WITH_WRONG_DIM); 01942 #else 01943 throw(); 01944 #endif 01945 01947 void accumulate_approx(cdotprecision &dp, const cvector_slice & sl1, const cmatrix_subv &rv2); 01948 01950 void accumulate(cdotprecision &dp, const cmatrix_subv & rv1, const cvector_slice &sl2) 01951 #if(CXSC_INDEX_CHECK) 01952 throw(OP_WITH_WRONG_DIM); 01953 #else 01954 throw(); 01955 #endif 01956 01958 void accumulate_approx(cdotprecision &dp, const cmatrix_subv & rv1, const cvector_slice &sl2); 01959 01960 01962 void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const cmatrix_subv &rv2) 01963 #if(CXSC_INDEX_CHECK) 01964 throw(OP_WITH_WRONG_DIM); 01965 #else 01966 throw(); 01967 #endif 01968 01969 void accumulate(cidotprecision &dp, const cvector & rv1, const cmatrix_subv &rv2) 01970 #if(CXSC_INDEX_CHECK) 01971 throw(OP_WITH_WRONG_DIM); 01972 #else 01973 throw(); 01974 #endif 01975 01976 void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const cvector &rv2) 01977 #if(CXSC_INDEX_CHECK) 01978 throw(OP_WITH_WRONG_DIM); 01979 #else 01980 throw(); 01981 #endif 01982 01983 void accumulate(cidotprecision &dp, const cvector_slice & sl1, const cmatrix_subv &rv2) 01984 #if(CXSC_INDEX_CHECK) 01985 throw(OP_WITH_WRONG_DIM); 01986 #else 01987 throw(); 01988 #endif 01989 01990 void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const cvector_slice &sl2) 01991 #if(CXSC_INDEX_CHECK) 01992 throw(OP_WITH_WRONG_DIM); 01993 #else 01994 throw(); 01995 #endif 01996 01998 INLINE complex operator *(const cmatrix_subv & rv1, const cmatrix_subv &rv2) 01999 #if(CXSC_INDEX_CHECK) 02000 throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM); 02001 #else 02002 throw(); 02003 #endif 02004 02005 INLINE complex operator *(const cvector & rv1, const cmatrix_subv &rv2) 02006 #if(CXSC_INDEX_CHECK) 02007 throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM); 02008 #else 02009 throw(); 02010 #endif 02011 02012 INLINE complex operator *(const cmatrix_subv &rv1,const cvector &rv2) 02013 #if(CXSC_INDEX_CHECK) 02014 throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM); 02015 #else 02016 throw(); 02017 #endif 02018 02019 INLINE complex operator *(const cvector_slice &sl,const cmatrix_subv &sv) 02020 #if(CXSC_INDEX_CHECK) 02021 throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM); 02022 #else 02023 throw(); 02024 #endif 02025 02026 INLINE complex operator *(const cmatrix_subv &mv,const cvector_slice &vs) 02027 #if(CXSC_INDEX_CHECK) 02028 throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM); 02029 #else 02030 throw(); 02031 #endif 02032 02034 INLINE cvector operator +(const cmatrix_subv & rv1, const cmatrix_subv &rv2) 02035 #if(CXSC_INDEX_CHECK) 02036 throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM); 02037 #else 02038 throw(); 02039 #endif 02040 02041 INLINE cvector operator +(const cmatrix_subv &rv1,const cvector &rv2) 02042 #if(CXSC_INDEX_CHECK) 02043 throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM); 02044 #else 02045 throw(); 02046 #endif 02047 02048 INLINE cvector operator +(const cvector & rv1, const cmatrix_subv &rv2) 02049 #if(CXSC_INDEX_CHECK) 02050 throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM); 02051 #else 02052 throw(); 02053 #endif 02054 02055 INLINE cvector operator +(const cvector_slice &sl,const cmatrix_subv &mv) 02056 #if(CXSC_INDEX_CHECK) 02057 throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM); 02058 #else 02059 throw(); 02060 #endif 02061 02062 INLINE cvector operator +(const cmatrix_subv &mv,const cvector_slice &sl) 02063 #if(CXSC_INDEX_CHECK) 02064 throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM); 02065 #else 02066 throw(); 02067 #endif 02068 02070 INLINE cvector operator -(const cmatrix_subv & rv1, const cmatrix_subv &rv2) 02071 #if(CXSC_INDEX_CHECK) 02072 throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM); 02073 #else 02074 throw(); 02075 #endif 02076 02077 INLINE cvector operator -(const cvector & rv1, const cmatrix_subv &rv2) 02078 #if(CXSC_INDEX_CHECK) 02079 throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM); 02080 #else 02081 throw(); 02082 #endif 02083 02084 INLINE cvector operator -(const cmatrix_subv &rv1,const cvector &rv2) 02085 #if(CXSC_INDEX_CHECK) 02086 throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM); 02087 #else 02088 throw(); 02089 #endif 02090 02091 INLINE cvector operator -(const cvector_slice &sl,const cmatrix_subv &mv) 02092 #if(CXSC_INDEX_CHECK) 02093 throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM); 02094 #else 02095 throw(); 02096 #endif 02097 02098 INLINE cvector operator -(const cmatrix_subv &mv,const cvector_slice &sl) 02099 #if(CXSC_INDEX_CHECK) 02100 throw(ERROR_CVECTOR_OP_WITH_WRONG_DIM); 02101 #else 02102 throw(); 02103 #endif 02104 02105 //==================================================================== 02106 //===================== Matrix Functions ============================= 02107 02109 INLINE cmatrix _cmatrix(const cmatrix &rm) throw(); 02111 INLINE cmatrix _cmatrix(const cvector &v) throw(); 02113 INLINE cmatrix _cmatrix(const cvector_slice &v) throw(); 02115 INLINE cmatrix _cmatrix(const complex &r) throw(); 02116 02118 INLINE int Lb(const cmatrix &rm, const int &i) 02119 #if(CXSC_INDEX_CHECK) 02120 throw(ERROR_CMATRIX_WRONG_ROW_OR_COL); 02121 #else 02122 throw(); 02123 #endif 02124 02125 INLINE int Ub(const cmatrix &rm, const int &i) 02126 #if(CXSC_INDEX_CHECK) 02127 throw(ERROR_CMATRIX_WRONG_ROW_OR_COL); 02128 #else 02129 throw(); 02130 #endif 02131 02132 INLINE int Lb(const cmatrix_slice &rm, const int &i) 02133 #if(CXSC_INDEX_CHECK) 02134 throw(ERROR_CMATRIX_WRONG_ROW_OR_COL); 02135 #else 02136 throw(); 02137 #endif 02138 02139 INLINE int Ub(const cmatrix_slice &rm, const int &i) 02140 #if(CXSC_INDEX_CHECK) 02141 throw(ERROR_CMATRIX_WRONG_ROW_OR_COL); 02142 #else 02143 throw(); 02144 #endif 02145 02146 INLINE cmatrix &SetLb(cmatrix &m, const int &i,const int &j) 02147 #if(CXSC_INDEX_CHECK) 02148 throw(ERROR_CMATRIX_WRONG_ROW_OR_COL); 02149 #else 02150 throw(); 02151 #endif 02152 02153 INLINE cmatrix &SetUb(cmatrix &m, const int &i,const int &j) 02154 #if(CXSC_INDEX_CHECK) 02155 throw(ERROR_CMATRIX_WRONG_ROW_OR_COL); 02156 #else 02157 throw(); 02158 #endif 02159 02160 INLINE void Resize(cmatrix &A) throw(); 02162 INLINE void Resize(cmatrix &A,const int &m, const int &n) 02163 #if(CXSC_INDEX_CHECK) 02164 throw(ERROR_CMATRIX_WRONG_BOUNDARIES); 02165 #else 02166 throw(); 02167 #endif 02168 02169 INLINE void Resize(cmatrix &A,const int &m1, const int &m2,const int &n1,const int &n2) 02170 #if(CXSC_INDEX_CHECK) 02171 throw(ERROR_CMATRIX_WRONG_BOUNDARIES); 02172 #else 02173 throw(); 02174 #endif 02175 02177 INLINE rmatrix abs(const cmatrix &m) throw(); 02179 INLINE rmatrix abs(const cmatrix_slice &ms) throw(); 02181 INLINE rmatrix Im(const cmatrix &m) throw(); 02183 INLINE rmatrix Re(const cmatrix &m) throw(); 02185 INLINE rmatrix Im(const cmatrix_slice &m) throw(); 02187 INLINE rmatrix Re(const cmatrix_slice &m) throw(); 02189 INLINE cmatrix &SetIm(cmatrix &cm,const rmatrix &rm) 02190 #if(CXSC_INDEX_CHECK) 02191 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02192 #else 02193 throw(); 02194 #endif 02195 02196 INLINE cmatrix_slice &SetIm(cmatrix_slice &cm,const rmatrix &rm) 02197 #if(CXSC_INDEX_CHECK) 02198 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02199 #else 02200 throw(); 02201 #endif 02202 02203 INLINE cmatrix &SetIm(cmatrix &cm,const rmatrix_slice &rm) 02204 #if(CXSC_INDEX_CHECK) 02205 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02206 #else 02207 throw(); 02208 #endif 02209 02210 INLINE cmatrix_slice &SetIm(cmatrix_slice &cm,const rmatrix_slice &rm) 02211 #if(CXSC_INDEX_CHECK) 02212 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02213 #else 02214 throw(); 02215 #endif 02216 02217 INLINE cmatrix &SetRe(cmatrix &cm,const rmatrix &rm) 02218 #if(CXSC_INDEX_CHECK) 02219 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02220 #else 02221 throw(); 02222 #endif 02223 02224 INLINE cmatrix_slice &SetRe(cmatrix_slice &cm,const rmatrix &rm) 02225 #if(CXSC_INDEX_CHECK) 02226 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02227 #else 02228 throw(); 02229 #endif 02230 02231 INLINE cmatrix &SetRe(cmatrix &cm,const rmatrix_slice &rm) 02232 #if(CXSC_INDEX_CHECK) 02233 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02234 #else 02235 throw(); 02236 #endif 02237 02238 INLINE cmatrix_slice &SetRe(cmatrix_slice &cm,const rmatrix_slice &rm) 02239 #if(CXSC_INDEX_CHECK) 02240 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02241 #else 02242 throw(); 02243 #endif 02244 02245 //===================== Matrix / Scalar =============================== 02246 02248 INLINE cmatrix operator *(const complex &c, const cmatrix &m) throw(); 02250 INLINE cmatrix operator *(const complex &c, const cmatrix_slice &ms) throw(); 02252 INLINE cmatrix operator *(const cmatrix &m,const complex &c) throw(); 02254 INLINE cmatrix operator *(const cmatrix_slice &ms,const complex &c) throw(); 02256 INLINE cmatrix &operator *=(cmatrix &m,const complex &c) throw(); 02258 INLINE cmatrix operator /(const cmatrix &m,const complex &c) throw(); 02260 INLINE cmatrix operator /(const cmatrix_slice &ms, const complex &c) throw(); 02262 INLINE cmatrix &operator /=(cmatrix &m,const complex &c) throw(); 02263 02264 //------------ real - cmatrix ----------------------------------------------- 02265 02267 INLINE cmatrix operator *(const real &c, const cmatrix &m) throw(); 02269 INLINE cmatrix operator *(const real &c, const cmatrix_slice &ms) throw(); 02271 INLINE cmatrix operator *(const cmatrix &m,const real &c) throw(); 02273 INLINE cmatrix operator *(const cmatrix_slice &ms,const real &c) throw(); 02275 INLINE cmatrix &operator *=(cmatrix &m,const real &c) throw(); 02277 INLINE cmatrix operator /(const cmatrix &m,const real &c) throw(); 02279 INLINE cmatrix operator /(const cmatrix_slice &ms, const real &c) throw(); 02281 INLINE cmatrix &operator /=(cmatrix &m,const real &c) throw(); 02282 //----------------- rmatrix - complex ---------------- 02283 02285 INLINE cmatrix operator *(const complex &c, const rmatrix &m) throw(); 02287 INLINE cmatrix operator *(const complex &c, const rmatrix_slice &ms) throw(); 02289 INLINE cmatrix operator *(const rmatrix &m,const complex &c) throw(); 02291 INLINE cmatrix operator *(const rmatrix_slice &ms,const complex &c) throw(); 02293 INLINE cmatrix operator /(const rmatrix &m,const complex &c) throw(); 02295 INLINE cmatrix operator /(const rmatrix_slice &ms, const complex &c) throw(); 02296 02297 02298 //============================ Matrix / Vector =================================== 02299 02300 02302 INLINE cvector operator *(const cmatrix &m,const cvector &v) 02303 #if(CXSC_INDEX_CHECK) 02304 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02305 #else 02306 throw(); 02307 #endif 02308 02309 INLINE cvector operator *(const cmatrix_slice &ms,const cvector &v) 02310 #if(CXSC_INDEX_CHECK) 02311 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02312 #else 02313 throw(); 02314 #endif 02315 02316 INLINE cvector operator *(const cvector &v,const cmatrix &m) 02317 #if(CXSC_INDEX_CHECK) 02318 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02319 #else 02320 throw(); 02321 #endif 02322 02323 INLINE cvector operator *(const cvector &v,const cmatrix_slice &ms) 02324 #if(CXSC_INDEX_CHECK) 02325 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02326 #else 02327 throw(); 02328 #endif 02329 02330 INLINE cvector &operator *=(cvector &v,const cmatrix &m) 02331 #if(CXSC_INDEX_CHECK) 02332 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02333 #else 02334 throw(); 02335 #endif 02336 02337 INLINE cvector &operator *=(cvector &v,const cmatrix_slice &ms) 02338 #if(CXSC_INDEX_CHECK) 02339 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02340 #else 02341 throw(); 02342 #endif 02343 02345 INLINE cvector operator *(const cvector_slice &v,const cmatrix &m) 02346 #if(CXSC_INDEX_CHECK) 02347 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02348 #else 02349 throw(); 02350 #endif 02351 02352 INLINE cvector operator *(const cvector_slice &v,const cmatrix_slice &m) 02353 #if(CXSC_INDEX_CHECK) 02354 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02355 #else 02356 throw(); 02357 #endif 02358 02359 //----------------- real ------------------------------------- 02360 02362 INLINE cvector operator *(const rvector &v,const cmatrix &m) 02363 #if(CXSC_INDEX_CHECK) 02364 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02365 #else 02366 throw(); 02367 #endif 02368 02369 INLINE cvector operator *(const rvector &v,const cmatrix_slice &ms) 02370 #if(CXSC_INDEX_CHECK) 02371 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02372 #else 02373 throw(); 02374 #endif 02375 02376 INLINE cvector operator *(const rvector_slice &v,const cmatrix &m) 02377 #if(CXSC_INDEX_CHECK) 02378 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02379 #else 02380 throw(); 02381 #endif 02382 02384 INLINE cvector operator *(const cmatrix &m,const rvector &v) 02385 #if(CXSC_INDEX_CHECK) 02386 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02387 #else 02388 throw(); 02389 #endif 02390 02391 INLINE cvector operator *(const cmatrix_slice &ms,const rvector &v) 02392 #if(CXSC_INDEX_CHECK) 02393 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02394 #else 02395 throw(); 02396 #endif 02397 02398 02399 //================ Matrix / Matrix ============================ 02400 02402 INLINE const cmatrix &operator +(const cmatrix &m1) throw(); 02404 INLINE cmatrix operator +(const cmatrix_slice &ms) throw(); 02406 INLINE cmatrix operator +(const cmatrix &m1,const cmatrix &m2) 02407 #if(CXSC_INDEX_CHECK) 02408 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02409 #else 02410 throw(); 02411 #endif 02412 02413 INLINE cmatrix operator +(const cmatrix &m,const cmatrix_slice &ms) 02414 #if(CXSC_INDEX_CHECK) 02415 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02416 #else 02417 throw(); 02418 #endif 02419 02420 INLINE cmatrix operator +(const cmatrix_slice &ms,const cmatrix &m) 02421 #if(CXSC_INDEX_CHECK) 02422 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02423 #else 02424 throw(); 02425 #endif 02426 02427 INLINE cmatrix operator +(const cmatrix_slice &m1,const cmatrix_slice &m2) 02428 #if(CXSC_INDEX_CHECK) 02429 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02430 #else 02431 throw(); 02432 #endif 02433 02434 INLINE cmatrix &operator +=(cmatrix &m1,const cmatrix &m2) 02435 #if(CXSC_INDEX_CHECK) 02436 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02437 #else 02438 throw(); 02439 #endif 02440 02441 INLINE cmatrix &operator +=(cmatrix &m1,const cmatrix_slice &ms) 02442 #if(CXSC_INDEX_CHECK) 02443 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02444 #else 02445 throw(); 02446 #endif 02447 02449 INLINE cmatrix operator -(const cmatrix &m) throw(); 02451 INLINE cmatrix operator -(const cmatrix_slice &ms) throw(); 02453 INLINE cmatrix operator -(const cmatrix &m1,const cmatrix &m2) 02454 #if(CXSC_INDEX_CHECK) 02455 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02456 #else 02457 throw(); 02458 #endif 02459 02460 INLINE cmatrix operator -(const cmatrix &m,const cmatrix_slice &ms) 02461 #if(CXSC_INDEX_CHECK) 02462 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02463 #else 02464 throw(); 02465 #endif 02466 02467 INLINE cmatrix operator -(const cmatrix_slice &ms,const cmatrix &m) 02468 #if(CXSC_INDEX_CHECK) 02469 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02470 #else 02471 throw(); 02472 #endif 02473 02474 INLINE cmatrix operator -(const cmatrix_slice &ms1,const cmatrix_slice &ms2) 02475 #if(CXSC_INDEX_CHECK) 02476 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02477 #else 02478 throw(); 02479 #endif 02480 02481 INLINE cmatrix &operator -=(cmatrix &m1,const cmatrix &m2) 02482 #if(CXSC_INDEX_CHECK) 02483 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02484 #else 02485 throw(); 02486 #endif 02487 02488 INLINE cmatrix &operator -=(cmatrix &m1,const cmatrix_slice &ms) 02489 #if(CXSC_INDEX_CHECK) 02490 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02491 #else 02492 throw(); 02493 #endif 02494 02496 INLINE cmatrix operator *(const cmatrix &m1, const cmatrix &m2) 02497 #if(CXSC_INDEX_CHECK) 02498 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02499 #else 02500 throw(); 02501 #endif 02502 02503 INLINE cmatrix operator *(const cmatrix &m1, const cmatrix_slice &ms) 02504 #if(CXSC_INDEX_CHECK) 02505 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02506 #else 02507 throw(); 02508 #endif 02509 02510 INLINE cmatrix operator *(const cmatrix_slice &ms, const cmatrix &m1) 02511 #if(CXSC_INDEX_CHECK) 02512 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02513 #else 02514 throw(); 02515 #endif 02516 02517 INLINE cmatrix operator *(const cmatrix_slice &ms1, const cmatrix_slice &ms2) 02518 #if(CXSC_INDEX_CHECK) 02519 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02520 #else 02521 throw(); 02522 #endif 02523 02524 INLINE cmatrix &operator *=(cmatrix &m1,const cmatrix &m2) 02525 #if(CXSC_INDEX_CHECK) 02526 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02527 #else 02528 throw(); 02529 #endif 02530 02531 INLINE cmatrix &operator *=(cmatrix &m1,const cmatrix_slice &ms) 02532 #if(CXSC_INDEX_CHECK) 02533 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02534 #else 02535 throw(); 02536 #endif 02537 02538 02539 //---------- rmatrix-cmatrix ------------------ 02541 INLINE cmatrix operator +(const rmatrix &m1,const cmatrix &m2) 02542 #if(CXSC_INDEX_CHECK) 02543 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02544 #else 02545 throw(); 02546 #endif 02547 02548 INLINE cmatrix operator +(const cmatrix &m1,const rmatrix &m2) 02549 #if(CXSC_INDEX_CHECK) 02550 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02551 #else 02552 throw(); 02553 #endif 02554 02555 INLINE cmatrix operator +(const rmatrix &m,const cmatrix_slice &ms) 02556 #if(CXSC_INDEX_CHECK) 02557 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02558 #else 02559 throw(); 02560 #endif 02561 02562 INLINE cmatrix operator +(const cmatrix &m,const rmatrix_slice &ms) 02563 #if(CXSC_INDEX_CHECK) 02564 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02565 #else 02566 throw(); 02567 #endif 02568 02569 INLINE cmatrix operator +(const rmatrix_slice &ms,const cmatrix &m) 02570 #if(CXSC_INDEX_CHECK) 02571 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02572 #else 02573 throw(); 02574 #endif 02575 02576 INLINE cmatrix operator +(const cmatrix_slice &ms,const rmatrix &m) 02577 #if(CXSC_INDEX_CHECK) 02578 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02579 #else 02580 throw(); 02581 #endif 02582 02583 INLINE cmatrix operator +(const rmatrix_slice &m1,const cmatrix_slice &m2) 02584 #if(CXSC_INDEX_CHECK) 02585 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02586 #else 02587 throw(); 02588 #endif 02589 02590 INLINE cmatrix operator +(const cmatrix_slice &m1,const rmatrix_slice &m2) 02591 #if(CXSC_INDEX_CHECK) 02592 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02593 #else 02594 throw(); 02595 #endif 02596 02597 INLINE cmatrix &operator +=(cmatrix &m1,const rmatrix &m2) 02598 #if(CXSC_INDEX_CHECK) 02599 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02600 #else 02601 throw(); 02602 #endif 02603 02604 INLINE cmatrix &operator +=(cmatrix &m1,const rmatrix_slice &ms) 02605 #if(CXSC_INDEX_CHECK) 02606 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02607 #else 02608 throw(); 02609 #endif 02610 02612 INLINE cmatrix operator -(const rmatrix &m1,const cmatrix &m2) 02613 #if(CXSC_INDEX_CHECK) 02614 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02615 #else 02616 throw(); 02617 #endif 02618 02619 INLINE cmatrix operator -(const cmatrix &m1,const rmatrix &m2) 02620 #if(CXSC_INDEX_CHECK) 02621 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02622 #else 02623 throw(); 02624 #endif 02625 02626 INLINE cmatrix operator -(const rmatrix &m,const cmatrix_slice &ms) 02627 #if(CXSC_INDEX_CHECK) 02628 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02629 #else 02630 throw(); 02631 #endif 02632 02633 INLINE cmatrix operator -(const cmatrix &m,const rmatrix_slice &ms) 02634 #if(CXSC_INDEX_CHECK) 02635 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02636 #else 02637 throw(); 02638 #endif 02639 02640 INLINE cmatrix operator -(const rmatrix_slice &ms,const cmatrix &m) 02641 #if(CXSC_INDEX_CHECK) 02642 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02643 #else 02644 throw(); 02645 #endif 02646 02647 INLINE cmatrix operator -(const cmatrix_slice &ms,const rmatrix &m) 02648 #if(CXSC_INDEX_CHECK) 02649 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02650 #else 02651 throw(); 02652 #endif 02653 02654 INLINE cmatrix operator -(const rmatrix_slice &ms1,const cmatrix_slice &ms2) 02655 #if(CXSC_INDEX_CHECK) 02656 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02657 #else 02658 throw(); 02659 #endif 02660 02661 INLINE cmatrix operator -(const cmatrix_slice &ms1,const rmatrix_slice &ms2) 02662 #if(CXSC_INDEX_CHECK) 02663 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02664 #else 02665 throw(); 02666 #endif 02667 02668 INLINE cmatrix &operator -=(cmatrix &m1,const rmatrix &m2) 02669 #if(CXSC_INDEX_CHECK) 02670 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02671 #else 02672 throw(); 02673 #endif 02674 02675 INLINE cmatrix &operator -=(cmatrix &m1,const rmatrix_slice &ms) 02676 #if(CXSC_INDEX_CHECK) 02677 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02678 #else 02679 throw(); 02680 #endif 02681 02683 INLINE cmatrix operator *(const rmatrix &m1, const cmatrix &m2) 02684 #if(CXSC_INDEX_CHECK) 02685 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02686 #else 02687 throw(); 02688 #endif 02689 02690 INLINE cmatrix operator *(const cmatrix &m1, const rmatrix &m2) 02691 #if(CXSC_INDEX_CHECK) 02692 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02693 #else 02694 throw(); 02695 #endif 02696 02697 INLINE cmatrix operator *(const rmatrix &m1, const cmatrix_slice &ms) 02698 #if(CXSC_INDEX_CHECK) 02699 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02700 #else 02701 throw(); 02702 #endif 02703 02704 INLINE cmatrix operator *(const cmatrix &m1, const rmatrix_slice &ms) 02705 #if(CXSC_INDEX_CHECK) 02706 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02707 #else 02708 throw(); 02709 #endif 02710 02711 INLINE cmatrix operator *(const rmatrix_slice &ms, const cmatrix &m1) 02712 #if(CXSC_INDEX_CHECK) 02713 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02714 #else 02715 throw(); 02716 #endif 02717 02718 INLINE cmatrix operator *(const cmatrix_slice &ms, const rmatrix &m1) 02719 #if(CXSC_INDEX_CHECK) 02720 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02721 #else 02722 throw(); 02723 #endif 02724 02725 INLINE cmatrix operator *(const rmatrix_slice &ms1, const cmatrix_slice &ms2) 02726 #if(CXSC_INDEX_CHECK) 02727 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02728 #else 02729 throw(); 02730 #endif 02731 02732 INLINE cmatrix operator *(const cmatrix_slice &ms1, const rmatrix_slice &ms2) 02733 #if(CXSC_INDEX_CHECK) 02734 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02735 #else 02736 throw(); 02737 #endif 02738 02739 INLINE cmatrix &operator *=(cmatrix &m1,const rmatrix &m2) 02740 #if(CXSC_INDEX_CHECK) 02741 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02742 #else 02743 throw(); 02744 #endif 02745 02746 INLINE cmatrix &operator *=(cmatrix &m1,const rmatrix_slice &ms) 02747 #if(CXSC_INDEX_CHECK) 02748 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 02749 #else 02750 throw(); 02751 #endif 02752 02753 02754 //============== Compare Operator ========================== 02755 02756 //-------------- Matrix - Matrix ------------------------- 02757 02759 INLINE bool operator ==(const cmatrix &m1,const cmatrix &m2) throw(); 02761 INLINE bool operator !=(const cmatrix &m1,const cmatrix &m2) throw(); 02762 /* INLINE bool operator <(const cmatrix &m1,const cmatrix &m2) throw(); 02763 INLINE bool operator <=(const cmatrix &m1,const cmatrix &m2) throw(); 02764 INLINE bool operator >(const cmatrix &m1,const cmatrix &m2) throw(); 02765 INLINE bool operator >=(const cmatrix &m1,const cmatrix &m2) throw();*/ 02767 INLINE bool operator ==(const cmatrix &m1,const cmatrix_slice &ms) throw(); 02769 INLINE bool operator !=(const cmatrix &m1,const cmatrix_slice &ms) throw(); 02770 /* INLINE bool operator <(const cmatrix &m1,const cmatrix_slice &ms) throw(); 02771 INLINE bool operator <=(const cmatrix &m1,const cmatrix_slice &ms) throw(); 02772 INLINE bool operator >(const cmatrix &m1,const cmatrix_slice &ms) throw(); 02773 INLINE bool operator >=(const cmatrix &m1,const cmatrix_slice &ms) throw(); 02774 */ 02775 //---------------- Matrix - Matrix_slice ---------------------- 02776 02778 INLINE bool operator ==(const cmatrix_slice &m1,const cmatrix_slice &m2) throw(); 02780 INLINE bool operator !=(const cmatrix_slice &m1,const cmatrix_slice &m2) throw(); 02781 /* INLINE bool operator <(const cmatrix_slice &m1,const cmatrix_slice &m2) throw(); 02782 INLINE bool operator <=(const cmatrix_slice &m1,const cmatrix_slice &m2) throw(); 02783 INLINE bool operator >(const cmatrix_slice &m1,const cmatrix_slice &m2) throw(); 02784 INLINE bool operator >=(const cmatrix_slice &m1,const cmatrix_slice &m2) throw(); 02785 */ 02786 //=================== Not Operator ============================= 02787 02789 INLINE bool operator !(const cmatrix &ms) throw(); 02791 INLINE bool operator !(const cmatrix_slice &ms) throw(); 02792 02793 //======================== Input / Output ======================== 02794 02796 INLINE std::ostream &operator <<(std::ostream &s,const cmatrix &r) throw(); 02798 INLINE std::ostream &operator <<(std::ostream &s,const cmatrix_slice &r) throw(); 02800 INLINE std::istream &operator >>(std::istream &s,cmatrix &r) throw(); 02802 INLINE std::istream &operator >>(std::istream &s,cmatrix_slice &r) throw(); 02803 02805 INLINE int RowLen ( const cmatrix& ); 02807 INLINE int ColLen ( const cmatrix& ); 02809 INLINE int RowLen ( const cmatrix_slice& ); 02811 INLINE int ColLen ( const cmatrix_slice& ); 02813 rmatrix CompMat ( const cmatrix& ); 02815 cmatrix Id ( cmatrix& ); 02817 cmatrix transp ( const cmatrix& ); 02819 void DoubleSize ( cmatrix& ); 02820 02821 } // namespace cxsc 02822 02823 02824 #ifdef _CXSC_INCL_INL 02825 #include "matrix.inl" 02826 #include "cmatrix.inl" 02827 #endif 02828 02829 #ifdef _CXSC_CIVECTOR_HPP_INCLUDED 02830 # ifdef _CXSC_INCL_INL 02831 # include "civeccmat.inl" 02832 # else 02833 # include "civeccmat.hpp" 02834 # endif 02835 #endif 02836 02837 #ifdef _CXSC_IVECTOR_HPP_INCLUDED 02838 # ifdef _CXSC_INCL_INL 02839 # include "iveccmat.inl" 02840 # else 02841 # include "iveccmat.hpp" 02842 # endif 02843 #endif 02844 02845 #ifdef _CXSC_IMATRIX_HPP_INCLUDED 02846 # ifdef _CXSC_INCL_INL 02847 # include "cmatimat.inl" 02848 # else 02849 # include "cmatimat.hpp" 02850 # endif 02851 #endif 02852 02853 02854 #ifdef CXSC_USE_BLAS 02855 #define _CXSC_BLAS_CMATRIX 02856 #include "cxsc_blas.inl" 02857 #endif 02858 02859 #endif
1.7.5.1