00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
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;
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
00093 #ifdef _CXSC_FRIEND_TPL
00094
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
00224
00225
00226
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
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
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
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
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
00484
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
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
00525 #ifdef _CXSC_FRIEND_TPL
00526
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
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
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
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
00859
00860
00861
00862
00863
00864
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
00891
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
00919
00920
00921
00922
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
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
01021
01022
01023
01024 #endif
01025
01026
01027
01028
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
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
01104
01105 INLINE ~cmatrix() throw() { delete [] dat; }
01106
01107
01108
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
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
01192
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;
01210
01211 public:
01212
01213 #ifdef _CXSC_FRIEND_TPL
01214
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
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
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
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
01462
01463
01464
01465
01466
01467
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
01482
01483
01484
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
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
01564
01565
01566
01567
01568
01569
01570
01571
01572
01573
01574 #endif
01575
01576
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
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
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
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
01862
01863 };
01864
01865
01866
01867
01868
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
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
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
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
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
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
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
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
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
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
02755
02756
02757
02759 INLINE bool operator ==(const cmatrix &m1,const cmatrix &m2) throw();
02761 INLINE bool operator !=(const cmatrix &m1,const cmatrix &m2) throw();
02762
02763
02764
02765
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
02771
02772
02773
02774
02775
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
02782
02783
02784
02785
02786
02787
02789 INLINE bool operator !(const cmatrix &ms) throw();
02791 INLINE bool operator !(const cmatrix_slice &ms) throw();
02792
02793
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 cmatrix Id ( cmatrix& );
02815 cmatrix transp ( const cmatrix& );
02817 void DoubleSize ( cmatrix& );
02818
02819 }
02820
02821
02822 #ifdef _CXSC_INCL_INL
02823 #include "matrix.inl"
02824 #include "cmatrix.inl"
02825 #endif
02826
02827 #ifdef _CXSC_CIVECTOR_HPP_INCLUDED
02828 # ifdef _CXSC_INCL_INL
02829 # include "civeccmat.inl"
02830 # else
02831 # include "civeccmat.hpp"
02832 # endif
02833 #endif
02834
02835 #ifdef _CXSC_IVECTOR_HPP_INCLUDED
02836 # ifdef _CXSC_INCL_INL
02837 # include "iveccmat.inl"
02838 # else
02839 # include "iveccmat.hpp"
02840 # endif
02841 #endif
02842
02843 #ifdef _CXSC_IMATRIX_HPP_INCLUDED
02844 # ifdef _CXSC_INCL_INL
02845 # include "cmatimat.inl"
02846 # else
02847 # include "cmatimat.hpp"
02848 # endif
02849 #endif
02850
02851
02852 #ifdef CXSC_USE_BLAS
02853 #define _CXSC_BLAS_CMATRIX
02854 #include "cxsc_blas.inl"
02855 #endif
02856
02857 #endif
