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_CIMATRIX_HPP_INCLUDED
00027 #define _CXSC_CIMATRIX_HPP_INCLUDED
00028
00029 #include "xscclass.hpp"
00030 #include "cidot.hpp"
00031 #include "civector.hpp"
00032 #include "except.hpp"
00033 #include "matrix.hpp"
00034 #include "imatrix.hpp"
00035 #include "cmatrix.hpp"
00036
00037
00038 namespace cxsc {
00039
00040 class cimatrix;
00041 class cimatrix_slice;
00042 class srmatrix;
00043 class srmatrix_slice;
00044 class srmatrix_subv;
00045 class simatrix;
00046 class simatrix_slice;
00047 class simatrix_subv;
00048 class scmatrix;
00049 class scmatrix_slice;
00050 class scmatrix_subv;
00051 class scimatrix;
00052 class scimatrix_slice;
00053 class scimatrix_subv;
00054
00055
00056
00057
00058
00059
00060
00061
00062
00064
00067 class cimatrix_subv
00068 {
00069 friend class civector;
00070 friend class cimatrix;
00071 friend class cimatrix_slice;
00072
00073 private:
00074 cinterval *dat;
00075 int lb,ub;
00076 int size,start,offset;
00077
00078 public:
00080 friend INLINE cimatrix_subv Row(cimatrix &m,const int &i)
00081 #if(CXSC_INDEX_CHECK)
00082 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
00083 #else
00084 throw();
00085 #endif
00086
00088 friend INLINE cimatrix_subv Col(cimatrix &m,const int &i)
00089 #if(CXSC_INDEX_CHECK)
00090 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
00091 #else
00092 throw();
00093 #endif
00094
00095 friend INLINE cimatrix_subv Row(const cimatrix &m,const int &i)
00096 #if(CXSC_INDEX_CHECK)
00097 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
00098 #else
00099 throw();
00100 #endif
00101
00103 friend INLINE cimatrix_subv Col(const cimatrix &m,const int &i)
00104 #if(CXSC_INDEX_CHECK)
00105 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
00106 #else
00107 throw();
00108 #endif
00109
00110
00111 #ifdef _CXSC_FRIEND_TPL
00112
00113 template <class MV1,class MV2> friend MV1 &_mvmvassign(MV1 &v,const MV2 &rv)
00114 #if(CXSC_INDEX_CHECK)
00115 throw(ERROR__OP_WITH_WRONG_DIM<MV1>);
00116 #else
00117 throw();
00118 #endif
00119 template <class MV,class S> friend MV &_mvsassign(MV &v,const S &r) throw();
00120 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
00121 #if(CXSC_INDEX_CHECK)
00122 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00123 #else
00124 throw();
00125 #endif
00126 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) throw();
00127 template <class MV,class V> friend MV &_mvvsetinf(MV &v,const V &rv)
00128 #if(CXSC_INDEX_CHECK)
00129 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00130 #else
00131 throw();
00132 #endif
00133 template <class MV,class V> friend MV &_mvvsetsup(MV &v,const V &rv)
00134 #if(CXSC_INDEX_CHECK)
00135 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00136 #else
00137 throw();
00138 #endif
00139 template <class MV,class V> friend MV &_mvvusetinf(MV &v,const V &rv)
00140 #if(CXSC_INDEX_CHECK)
00141 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00142 #else
00143 throw();
00144 #endif
00145 template <class MV,class V> friend MV &_mvvusetsup(MV &v,const V &rv)
00146 #if(CXSC_INDEX_CHECK)
00147 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00148 #else
00149 throw();
00150 #endif
00151 template <class MV,class V> friend MV &_mvvsetre(MV &v,const V &rv)
00152 #if(CXSC_INDEX_CHECK)
00153 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00154 #else
00155 throw();
00156 #endif
00157 template <class MV,class V> friend MV &_mvvsetim(MV &v,const V &rv)
00158 #if(CXSC_INDEX_CHECK)
00159 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00160 #else
00161 throw();
00162 #endif
00163 template <class MV,class V> friend V _mvabs(const MV &mv) throw();
00164 template <class MV,class V> friend V _mvim(const MV &mv) throw();
00165 template <class MV,class V> friend V _mvre(const MV &mv) throw();
00166 template <class MV,class V> friend V _mvdiam(const MV &mv) throw();
00167 template <class MV,class V> friend V _mvmid(const MV &mv) throw();
00168 template <class MV,class V> friend V _mvinf(const MV &mv) throw();
00169 template <class MV,class V> friend V _mvsup(const MV &mv) throw();
00170
00171 template <class MV,class S> friend MV &_mvssetinf(MV &mv, const S &s) throw();
00172 template <class MV,class S> friend MV &_mvssetsup(MV &mv, const S &s) throw();
00173 template <class MV,class S> friend MV &_mvsusetinf(MV &mv, const S &s) throw();
00174 template <class MV,class S> friend MV &_mvsusetsup(MV &mv, const S &s) throw();
00175 template <class MV,class S> friend MV &_mvssetim(MV &mv, const S &s) throw();
00176 template <class MV,class S> friend MV &_mvssetre(MV &mv, const S &s) throw();
00177 template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
00178 #if(CXSC_INDEX_CHECK)
00179 throw(OP_WITH_WRONG_DIM);
00180 #else
00181 throw();
00182 #endif
00183 template <class DP,class MV1,class MV2> friend void _mvmvaccu(DP &dp, const MV1 & rv1, const MV2 &rv2)
00184 #if(CXSC_INDEX_CHECK)
00185 throw(OP_WITH_WRONG_DIM);
00186 #else
00187 throw();
00188 #endif
00189 template <class MV1,class MV2,class S> friend S _mvmvcimult(const MV1 & rv1, const MV2 &rv2)
00190 #if(CXSC_INDEX_CHECK)
00191 throw(ERROR__OP_WITH_WRONG_DIM<MV1>);
00192 #else
00193 throw();
00194 #endif
00195 template <class V,class MV,class S> friend S _vmvcimult(const V &rv1, const MV &rv2)
00196 #if(CXSC_INDEX_CHECK)
00197 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00198 #else
00199 throw();
00200 #endif
00201 template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) throw();
00202 template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
00203 #if(CXSC_INDEX_CHECK)
00204 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00205 #else
00206 throw();
00207 #endif
00208 template <class MV1,class MV2,class E> friend E _mvmvminus(const MV1 &rv1, const MV2 &rv2)
00209 #if(CXSC_INDEX_CHECK)
00210 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00211 #else
00212 throw();
00213 #endif
00214 template <class MV,class V,class E> friend E _mvvplus(const MV &rv1, const V &rv2)
00215 #if(CXSC_INDEX_CHECK)
00216 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00217 #else
00218 throw();
00219 #endif
00220 template <class MV,class V,class E> friend E _mvvminus(const MV &rv1, const V &rv2)
00221 #if(CXSC_INDEX_CHECK)
00222 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00223 #else
00224 throw();
00225 #endif
00226 template <class V,class MV,class E> friend E _vmvminus(const V &rv1, const MV &rv2)
00227 #if(CXSC_INDEX_CHECK)
00228 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00229 #else
00230 throw();
00231 #endif
00232 template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) throw();
00233 template <class MV,class S> friend MV &_mvsmultassign(MV &v,const S &r) throw();
00234 template <class MV, class S> friend MV &_mvsplusassign(MV &v,const S &r) throw();
00235 template <class MV,class S> friend MV &_mvsminusassign(MV &v,const S &r) throw();
00236 template <class MV,class S> friend MV &_mvsdivassign(MV &v,const S &r) throw();
00237 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
00238 #if(CXSC_INDEX_CHECK)
00239 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00240 #else
00241 throw();
00242 #endif
00243 template <class V,class MV> friend V &_vmvplusassign(V &rv,const MV &v)
00244 #if(CXSC_INDEX_CHECK)
00245 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00246 #else
00247 throw();
00248 #endif
00249 template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv)
00250 #if(CXSC_INDEX_CHECK)
00251 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00252 #else
00253 throw();
00254 #endif
00255 template <class V,class MV> friend V &_vmvminusassign(V &rv,const MV &v)
00256 #if(CXSC_INDEX_CHECK)
00257 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00258 #else
00259 throw();
00260 #endif
00261 template <class MV1,class MV2,class E> friend E _mvmvconv(const MV1 &rv1, const MV2 &rv2)
00262 #if(CXSC_INDEX_CHECK)
00263 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00264 #else
00265 throw();
00266 #endif
00267 template <class MV,class V,class E> friend E _mvvconv(const MV &rv1, const V &rv2)
00268 #if(CXSC_INDEX_CHECK)
00269 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00270 #else
00271 throw();
00272 #endif
00273 template <class MV,class V> friend MV &_mvvconvassign(MV &v,const V &rv)
00274 #if(CXSC_INDEX_CHECK)
00275 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00276 #else
00277 throw();
00278 #endif
00279 template <class MV1,class MV2,class E> friend E _mvmvsect(const MV1 &rv1, const MV2 &rv2)
00280 #if(CXSC_INDEX_CHECK)
00281 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00282 #else
00283 throw();
00284 #endif
00285 template <class MV,class V,class E> friend E _mvvsect(const MV &rv1, const V &rv2)
00286 #if(CXSC_INDEX_CHECK)
00287 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00288 #else
00289 throw();
00290 #endif
00291 template <class MV,class V> friend MV &_mvvsectassign(MV &v,const V &rv)
00292 #if(CXSC_INDEX_CHECK)
00293 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00294 #else
00295 throw();
00296 #endif
00297 template <class V,class MV> friend V &_vmvsectassign(V &rv,const MV &v)
00298 #if(CXSC_INDEX_CHECK)
00299 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00300 #else
00301 throw();
00302 #endif
00303
00304
00305
00306
00307
00308
00309
00310 #endif
00311
00312
00313
00315 explicit INLINE cimatrix_subv (cinterval *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) { }
00316 public:
00318 INLINE cimatrix_subv(const cimatrix_subv &v) throw():dat(v.dat),lb(v.lb),ub(v.ub),size(v.size),start(v.start),offset(v.offset) { }
00319 public:
00320
00321
00322
00324 cimatrix_subv &operator =(const scimatrix_subv &rv);
00326 cimatrix_subv &operator =(const srmatrix_subv &rv);
00328 cimatrix_subv &operator =(const simatrix_subv &rv);
00330 cimatrix_subv &operator =(const scmatrix_subv &rv);
00331
00333 cimatrix_subv &operator =(const scivector &rv);
00335 cimatrix_subv &operator =(const srvector &rv);
00337 cimatrix_subv &operator =(const scvector &rv);
00339 cimatrix_subv &operator =(const sivector &rv);
00340
00342 cimatrix_subv &operator =(const scivector_slice &rv);
00344 cimatrix_subv &operator =(const srvector_slice &rv);
00346 cimatrix_subv &operator =(const scvector_slice &rv);
00348 cimatrix_subv &operator =(const sivector_slice &rv);
00349
00351 cimatrix_subv &operator =(const cimatrix_subv &rv) throw();
00353 cimatrix_subv &operator =(const cinterval &r) throw();
00355 cimatrix_subv &operator =(const cimatrix &m)
00356 #if(CXSC_INDEX_CHECK)
00357 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00358 #else
00359 throw();
00360 #endif
00361
00362 cimatrix_subv &operator =(const cimatrix_slice &m)
00363 #if(CXSC_INDEX_CHECK)
00364 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00365 #else
00366 throw();
00367 #endif
00368
00369 INLINE cimatrix_subv &operator =(const civector &v)
00370 #if(CXSC_INDEX_CHECK)
00371 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00372 #else
00373 throw();
00374 #endif
00375
00376 INLINE cimatrix_subv &operator =(const civector_slice &v)
00377 #if(CXSC_INDEX_CHECK)
00378 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00379 #else
00380 throw();
00381 #endif
00382
00384 INLINE cimatrix_subv &operator =(const real &r) throw();
00386 INLINE cimatrix_subv &operator =(const rmatrix &m)
00387 #if(CXSC_INDEX_CHECK)
00388 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00389 #else
00390 throw();
00391 #endif
00392
00393 INLINE cimatrix_subv &operator =(const rmatrix_slice &m)
00394 #if(CXSC_INDEX_CHECK)
00395 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00396 #else
00397 throw();
00398 #endif
00399
00400 INLINE cimatrix_subv &operator =(const rvector &v)
00401 #if(CXSC_INDEX_CHECK)
00402 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00403 #else
00404 throw();
00405 #endif
00406
00407 INLINE cimatrix_subv &operator =(const rvector_slice &v)
00408 #if(CXSC_INDEX_CHECK)
00409 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00410 #else
00411 throw();
00412 #endif
00413
00414 INLINE cimatrix_subv &operator =(const rmatrix_subv &rv) throw();
00415
00416
00418 INLINE cimatrix_subv &operator =(const complex &r) throw();
00420 INLINE cimatrix_subv &operator =(const cmatrix &m)
00421 #if(CXSC_INDEX_CHECK)
00422 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00423 #else
00424 throw();
00425 #endif
00426
00427 INLINE cimatrix_subv &operator =(const cmatrix_slice &m)
00428 #if(CXSC_INDEX_CHECK)
00429 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00430 #else
00431 throw();
00432 #endif
00433
00434 INLINE cimatrix_subv &operator =(const cvector &v)
00435 #if(CXSC_INDEX_CHECK)
00436 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00437 #else
00438 throw();
00439 #endif
00440
00441 INLINE cimatrix_subv &operator =(const cvector_slice &v)
00442 #if(CXSC_INDEX_CHECK)
00443 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00444 #else
00445 throw();
00446 #endif
00447
00448 INLINE cimatrix_subv &operator =(const cmatrix_subv &rv) throw();
00449
00450
00452 INLINE cimatrix_subv &operator =(const interval &r) throw();
00454 INLINE cimatrix_subv &operator =(const imatrix &m)
00455 #if(CXSC_INDEX_CHECK)
00456 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00457 #else
00458 throw();
00459 #endif
00460
00461 INLINE cimatrix_subv &operator =(const imatrix_slice &m)
00462 #if(CXSC_INDEX_CHECK)
00463 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00464 #else
00465 throw();
00466 #endif
00467
00468 INLINE cimatrix_subv &operator =(const ivector &v)
00469 #if(CXSC_INDEX_CHECK)
00470 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00471 #else
00472 throw();
00473 #endif
00474
00475 INLINE cimatrix_subv &operator =(const ivector_slice &v)
00476 #if(CXSC_INDEX_CHECK)
00477 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00478 #else
00479 throw();
00480 #endif
00481
00482 INLINE cimatrix_subv &operator =(const imatrix_subv &rv) throw();
00483
00485 friend INLINE int Lb(const cimatrix_subv &rv) throw() { return rv.lb; }
00487 friend INLINE int Ub(const cimatrix_subv &rv) throw() { return rv.ub; }
00489 friend INLINE int VecLen(const cimatrix_subv &rv) throw() { return rv.size; }
00490
00492 INLINE cinterval &operator [](const int &i) const
00493 #if(CXSC_INDEX_CHECK)
00494 throw(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC);
00495 #else
00496 throw();
00497 #endif
00498
00500 INLINE cinterval &operator [](const int &i)
00501 #if(CXSC_INDEX_CHECK)
00502 throw(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC);
00503 #else
00504 throw();
00505 #endif
00506
00508 INLINE cimatrix_subv &operator ()() throw() { return *this; }
00510 INLINE cimatrix_subv operator ()(const int &i)
00511 #if(CXSC_INDEX_CHECK)
00512 throw(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG);
00513 #else
00514 throw();
00515 #endif
00516
00517 INLINE cimatrix_subv operator ()(const int &i1,const int &i2)
00518 #if(CXSC_INDEX_CHECK)
00519 throw(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG);
00520 #else
00521 throw();
00522 #endif
00523
00525 INLINE cimatrix_subv &operator *=(const cinterval &c) throw();
00527 INLINE cimatrix_subv &operator +=(const cinterval &c) throw();
00529 INLINE cimatrix_subv &operator -=(const cinterval &c) throw();
00531 INLINE cimatrix_subv &operator /=(const cinterval &c) throw();
00533 INLINE cimatrix_subv &operator -=(const scivector &rv);
00535 INLINE cimatrix_subv &operator +=(const scivector &rv);
00537 INLINE cimatrix_subv &operator &=(const scivector &rv);
00539 INLINE cimatrix_subv &operator |=(const scivector &rv);
00541 INLINE cimatrix_subv &operator -=(const scivector_slice &rv);
00543 INLINE cimatrix_subv &operator +=(const scivector_slice &rv);
00545 INLINE cimatrix_subv &operator &=(const scivector_slice &rv);
00547 INLINE cimatrix_subv &operator |=(const scivector_slice &rv);
00549 INLINE cimatrix_subv &operator -=(const scimatrix_subv &rv);
00551 INLINE cimatrix_subv &operator +=(const scimatrix_subv &rv);
00553 INLINE cimatrix_subv &operator &=(const scimatrix_subv &rv);
00555 INLINE cimatrix_subv &operator |=(const scimatrix_subv &rv);
00556
00558 INLINE cimatrix_subv &operator -=(const civector &rv)
00559 #if(CXSC_INDEX_CHECK)
00560 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00561 #else
00562 throw();
00563 #endif
00564
00565 INLINE cimatrix_subv &operator +=(const civector &rv)
00566 #if(CXSC_INDEX_CHECK)
00567 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00568 #else
00569 throw();
00570 #endif
00571
00572 INLINE cimatrix_subv &operator -=(const civector_slice &rv)
00573 #if(CXSC_INDEX_CHECK)
00574 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00575 #else
00576 throw();
00577 #endif
00578
00579 INLINE cimatrix_subv &operator +=(const civector_slice &rv)
00580 #if(CXSC_INDEX_CHECK)
00581 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00582 #else
00583 throw();
00584 #endif
00585
00586 INLINE cimatrix_subv &operator |=(const civector &rv)
00587 #if(CXSC_INDEX_CHECK)
00588 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00589 #else
00590 throw();
00591 #endif
00592
00593 INLINE cimatrix_subv &operator |=(const civector_slice &rv)
00594 #if(CXSC_INDEX_CHECK)
00595 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00596 #else
00597 throw();
00598 #endif
00599
00600 INLINE cimatrix_subv &operator &=(const civector &rv)
00601 #if(CXSC_INDEX_CHECK)
00602 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00603 #else
00604 throw();
00605 #endif
00606
00607 INLINE cimatrix_subv &operator &=(const civector_slice &rv)
00608 #if(CXSC_INDEX_CHECK)
00609 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00610 #else
00611 throw();
00612 #endif
00613
00615 INLINE cimatrix_subv &operator *=(const real &c) throw();
00617 INLINE cimatrix_subv &operator +=(const real &c) throw();
00619 INLINE cimatrix_subv &operator -=(const real &c) throw();
00621 INLINE cimatrix_subv &operator /=(const real &c) throw();
00623 INLINE cimatrix_subv &operator -=(const srvector &rv);
00625 INLINE cimatrix_subv &operator +=(const srvector &rv);
00627 INLINE cimatrix_subv &operator |=(const srvector &rv);
00629 INLINE cimatrix_subv &operator -=(const srvector_slice &rv);
00631 INLINE cimatrix_subv &operator +=(const srvector_slice &rv);
00633 INLINE cimatrix_subv &operator |=(const srvector_slice &rv);
00635 INLINE cimatrix_subv &operator -=(const srmatrix_subv &rv);
00637 INLINE cimatrix_subv &operator +=(const srmatrix_subv &rv);
00639 INLINE cimatrix_subv &operator |=(const srmatrix_subv &rv);
00641 INLINE cimatrix_subv &operator -=(const rvector &rv)
00642 #if(CXSC_INDEX_CHECK)
00643 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00644 #else
00645 throw();
00646 #endif
00647
00648 INLINE cimatrix_subv &operator +=(const rvector &rv)
00649 #if(CXSC_INDEX_CHECK)
00650 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00651 #else
00652 throw();
00653 #endif
00654
00655 INLINE cimatrix_subv &operator -=(const rvector_slice &rv)
00656 #if(CXSC_INDEX_CHECK)
00657 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00658 #else
00659 throw();
00660 #endif
00661
00662 INLINE cimatrix_subv &operator +=(const rvector_slice &rv)
00663 #if(CXSC_INDEX_CHECK)
00664 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00665 #else
00666 throw();
00667 #endif
00668
00669 INLINE cimatrix_subv &operator |=(const rvector &rv)
00670 #if(CXSC_INDEX_CHECK)
00671 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00672 #else
00673 throw();
00674 #endif
00675
00676 INLINE cimatrix_subv &operator |=(const rvector_slice &rv)
00677 #if(CXSC_INDEX_CHECK)
00678 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00679 #else
00680 throw();
00681 #endif
00682
00683 INLINE cimatrix_subv &operator &=(const rvector &rv)
00684 #if(CXSC_INDEX_CHECK)
00685 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00686 #else
00687 throw();
00688 #endif
00689
00690 INLINE cimatrix_subv &operator &=(const rvector_slice &rv)
00691 #if(CXSC_INDEX_CHECK)
00692 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00693 #else
00694 throw();
00695 #endif
00696
00698 INLINE cimatrix_subv &operator *=(const complex &c) throw();
00700 INLINE cimatrix_subv &operator +=(const complex &c) throw();
00702 INLINE cimatrix_subv &operator -=(const complex &c) throw();
00704 INLINE cimatrix_subv &operator /=(const complex &c) throw();
00706 INLINE cimatrix_subv &operator -=(const scvector &rv);
00708 INLINE cimatrix_subv &operator +=(const scvector &rv);
00710 INLINE cimatrix_subv &operator |=(const scvector &rv);
00712 INLINE cimatrix_subv &operator -=(const scvector_slice &rv);
00714 INLINE cimatrix_subv &operator +=(const scvector_slice &rv);
00716 INLINE cimatrix_subv &operator |=(const scvector_slice &rv);
00718 INLINE cimatrix_subv &operator -=(const scmatrix_subv &rv);
00720 INLINE cimatrix_subv &operator +=(const scmatrix_subv &rv);
00722 INLINE cimatrix_subv &operator &=(const scmatrix_subv &rv);
00724 INLINE cimatrix_subv &operator |=(const scmatrix_subv &rv);
00726 INLINE cimatrix_subv &operator -=(const cvector &rv)
00727 #if(CXSC_INDEX_CHECK)
00728 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00729 #else
00730 throw();
00731 #endif
00732
00733 INLINE cimatrix_subv &operator +=(const cvector &rv)
00734 #if(CXSC_INDEX_CHECK)
00735 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00736 #else
00737 throw();
00738 #endif
00739
00740 INLINE cimatrix_subv &operator -=(const cvector_slice &rv)
00741 #if(CXSC_INDEX_CHECK)
00742 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00743 #else
00744 throw();
00745 #endif
00746
00747 INLINE cimatrix_subv &operator +=(const cvector_slice &rv)
00748 #if(CXSC_INDEX_CHECK)
00749 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00750 #else
00751 throw();
00752 #endif
00753
00754 INLINE cimatrix_subv &operator |=(const cvector &rv)
00755 #if(CXSC_INDEX_CHECK)
00756 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00757 #else
00758 throw();
00759 #endif
00760
00761 INLINE cimatrix_subv &operator |=(const cvector_slice &rv)
00762 #if(CXSC_INDEX_CHECK)
00763 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00764 #else
00765 throw();
00766 #endif
00767
00768 INLINE cimatrix_subv &operator &=(const cvector &rv)
00769 #if(CXSC_INDEX_CHECK)
00770 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00771 #else
00772 throw();
00773 #endif
00774
00775 INLINE cimatrix_subv &operator &=(const cvector_slice &rv)
00776 #if(CXSC_INDEX_CHECK)
00777 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00778 #else
00779 throw();
00780 #endif
00781
00783 INLINE cimatrix_subv &operator *=(const interval &c) throw();
00785 INLINE cimatrix_subv &operator +=(const interval &c) throw();
00787 INLINE cimatrix_subv &operator -=(const interval &c) throw();
00789 INLINE cimatrix_subv &operator /=(const interval &c) throw();
00791 INLINE cimatrix_subv &operator -=(const sivector &rv);
00793 INLINE cimatrix_subv &operator +=(const sivector &rv);
00795 INLINE cimatrix_subv &operator &=(const sivector &rv);
00797 INLINE cimatrix_subv &operator |=(const sivector &rv);
00799 INLINE cimatrix_subv &operator -=(const sivector_slice &rv);
00801 INLINE cimatrix_subv &operator +=(const sivector_slice &rv);
00803 INLINE cimatrix_subv &operator &=(const sivector_slice &rv);
00805 INLINE cimatrix_subv &operator |=(const sivector_slice &rv);
00807 INLINE cimatrix_subv &operator -=(const simatrix_subv &rv);
00809 INLINE cimatrix_subv &operator +=(const simatrix_subv &rv);
00811 INLINE cimatrix_subv &operator &=(const simatrix_subv &rv);
00813 INLINE cimatrix_subv &operator |=(const simatrix_subv &rv);
00815 INLINE cimatrix_subv &operator -=(const ivector &rv)
00816 #if(CXSC_INDEX_CHECK)
00817 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00818 #else
00819 throw();
00820 #endif
00821
00822 INLINE cimatrix_subv &operator +=(const ivector &rv)
00823 #if(CXSC_INDEX_CHECK)
00824 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00825 #else
00826 throw();
00827 #endif
00828
00829 INLINE cimatrix_subv &operator -=(const ivector_slice &rv)
00830 #if(CXSC_INDEX_CHECK)
00831 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00832 #else
00833 throw();
00834 #endif
00835
00836 INLINE cimatrix_subv &operator +=(const ivector_slice &rv)
00837 #if(CXSC_INDEX_CHECK)
00838 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00839 #else
00840 throw();
00841 #endif
00842
00843 INLINE cimatrix_subv &operator |=(const ivector &rv)
00844 #if(CXSC_INDEX_CHECK)
00845 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00846 #else
00847 throw();
00848 #endif
00849
00850 INLINE cimatrix_subv &operator |=(const ivector_slice &rv)
00851 #if(CXSC_INDEX_CHECK)
00852 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00853 #else
00854 throw();
00855 #endif
00856
00857 INLINE cimatrix_subv &operator &=(const ivector &rv)
00858 #if(CXSC_INDEX_CHECK)
00859 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00860 #else
00861 throw();
00862 #endif
00863
00864 INLINE cimatrix_subv &operator &=(const ivector_slice &rv)
00865 #if(CXSC_INDEX_CHECK)
00866 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
00867 #else
00868 throw();
00869 #endif
00870
00871
00872
00873 };
00874
00875
00877 INLINE cimatrix_subv Row(cimatrix &m,const int &i)
00878 #if(CXSC_INDEX_CHECK)
00879 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
00880 #else
00881 throw();
00882 #endif
00883
00884 INLINE cimatrix_subv Col(cimatrix &m,const int &i)
00885 #if(CXSC_INDEX_CHECK)
00886 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
00887 #else
00888 throw();
00889 #endif
00890
00891
00892
00893
00894 class cimatrix_slice;
00895
00896
00897
00898
00899
00900
00901
00902
00904
00907 class cimatrix
00908 {
00909 friend class cimatrix_slice;
00910 friend class cimatrix_subv;
00911 private:
00912 cinterval *dat;
00913 int lb1,ub1,lb2,ub2,xsize,ysize;
00914
00915 public:
00916
00917 #ifdef _CXSC_FRIEND_TPL
00918
00919 template <class S,class M> friend void _smconstr(S &s,const M &m)
00920 #if(CXSC_INDEX_CHECK)
00921 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>,ERROR__USE_OF_UNINITIALIZED_OBJ<M>);
00922 #else
00923 throw();
00924 #endif
00925 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
00926 #if(CXSC_INDEX_CHECK)
00927 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
00928 #else
00929 throw();
00930 #endif
00931 template <class M1,class M2,class S> friend M1 &_mmassign(M1 &m1,const M2 &m,S ms) throw();
00932 template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) throw();
00933 template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m)
00934 #if(CXSC_INDEX_CHECK)
00935 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00936 #else
00937 throw();
00938 #endif
00939 template <class M,class S> friend M &_msassign(M &m,const S &r) throw();
00940 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m)
00941 #if(CXSC_INDEX_CHECK)
00942 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
00943 #else
00944 throw();
00945 #endif
00946 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) throw();
00947 template <class M> friend int _mlb(const M &m, const int &i)
00948 #if(CXSC_INDEX_CHECK)
00949 throw(ERROR__WRONG_ROW_OR_COL<M>);
00950 #else
00951 throw();
00952 #endif
00953 template <class M> friend int _mub(const M &m, const int &i)
00954 #if(CXSC_INDEX_CHECK)
00955 throw(ERROR__WRONG_ROW_OR_COL<M>);
00956 #else
00957 throw();
00958 #endif
00959 template <class M> friend M &_msetlb(M &m, const int &i,const int &j)
00960 #if(CXSC_INDEX_CHECK)
00961 throw(ERROR__WRONG_ROW_OR_COL<M>);
00962 #else
00963 throw();
00964 #endif
00965 template <class M> friend M &_msetub(M &m, const int &i,const int &j)
00966 #if(CXSC_INDEX_CHECK)
00967 throw(ERROR__WRONG_ROW_OR_COL<M>);
00968 #else
00969 throw();
00970 #endif
00971 template <class M> friend void _mresize(M &A) throw();
00972 template <class M,class S> friend void _mresize(M &A,const int &m, const int &n)
00973 #if(CXSC_INDEX_CHECK)
00974 throw(ERROR__WRONG_BOUNDARIES<M>);
00975 #else
00976 throw();
00977 #endif
00978 template <class M,class S> friend void _mresize(M &A,const int &m1, const int &m2,const int &n1,const int &n2)
00979 #if(CXSC_INDEX_CHECK)
00980 throw(ERROR__WRONG_BOUNDARIES<M>);
00981 #else
00982 throw();
00983 #endif
00984 template <class M,class E> friend E _mabs(const M &m) throw();
00985 template <class M,class E> friend E _mdiam(const M &m) throw();
00986 template <class M,class E> friend E _mmid(const M &m) throw();
00987 template <class M,class E> friend E _mre(const M &m) throw();
00988 template <class M,class E> friend E _mim(const M &m) throw();
00989 friend INLINE rmatrix SupRe(const cimatrix &v) throw();
00990 friend INLINE rmatrix SupIm(const cimatrix &v) throw();
00991 friend INLINE rmatrix InfRe(const cimatrix &v) throw();
00992 friend INLINE rmatrix InfIm(const cimatrix &v) throw();
00993 template <class M1,class M2> friend M1 &_mmsetre(M1 &m1,const M2 &m2)
00994 #if(CXSC_INDEX_CHECK)
00995 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00996 #else
00997 throw();
00998 #endif
00999 template <class M1,class M2> friend M1 &_mmsetim(M1 &m1,const M2 &m2)
01000 #if(CXSC_INDEX_CHECK)
01001 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01002 #else
01003 throw();
01004 #endif
01005 template <class M1,class MS2> friend M1 &_mmssetre(M1 &m1,const MS2 &ms2)
01006 #if(CXSC_INDEX_CHECK)
01007 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01008 #else
01009 throw();
01010 #endif
01011 template <class M1,class MS2> friend M1 &_mmssetim(M1 &m1,const MS2 &ms2)
01012 #if(CXSC_INDEX_CHECK)
01013 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01014 #else
01015 throw();
01016 #endif
01017 template <class M,class E> friend E _minf(const M &m) throw();
01018 template <class M,class E> friend E _msup(const M &m) throw();
01019 template <class M1,class M2> friend M1 &_mmsetinf(M1 &m1,const M2 &m2)
01020 #if(CXSC_INDEX_CHECK)
01021 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01022 #else
01023 throw();
01024 #endif
01025 template <class M1,class M2> friend M1 &_mmsetsup(M1 &m1,const M2 &m2)
01026 #if(CXSC_INDEX_CHECK)
01027 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01028 #else
01029 throw();
01030 #endif
01031 template <class M1,class MS2> friend M1 &_mmssetinf(M1 &m1,const MS2 &ms2)
01032 #if(CXSC_INDEX_CHECK)
01033 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01034 #else
01035 throw();
01036 #endif
01037 template <class M1,class MS2> friend M1 &_mmssetsup(M1 &m1,const MS2 &ms2)
01038 #if(CXSC_INDEX_CHECK)
01039 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01040 #else
01041 throw();
01042 #endif
01043 template <class M1,class M2> friend M1 &_mmusetinf(M1 &m1,const M2 &m2)
01044 #if(CXSC_INDEX_CHECK)
01045 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01046 #else
01047 throw();
01048 #endif
01049 template <class M1,class M2> friend M1 &_mmusetsup(M1 &m1,const M2 &m2)
01050 #if(CXSC_INDEX_CHECK)
01051 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01052 #else
01053 throw();
01054 #endif
01055 template <class M1,class MS2> friend M1 &_mmsusetinf(M1 &m1,const MS2 &ms2)
01056 #if(CXSC_INDEX_CHECK)
01057 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01058 #else
01059 throw();
01060 #endif
01061 template <class M1,class MS2> friend M1 &_mmsusetsup(M1 &m1,const MS2 &ms2)
01062 #if(CXSC_INDEX_CHECK)
01063 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01064 #else
01065 throw();
01066 #endif
01067
01068 template <class M1,class M2,class E> friend E _mmplus(const M1 &m1,const M2 &m2)
01069 #if(CXSC_INDEX_CHECK)
01070 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01071 #else
01072 throw();
01073 #endif
01074 template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms)
01075 #if(CXSC_INDEX_CHECK)
01076 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01077 #else
01078 throw();
01079 #endif
01080 template <class M> friend M _mminus(const M &m) throw();
01081 template <class MS,class E> friend E _msminus(const MS &ms) throw();
01082 template <class M1,class M2,class E> friend E _mmminus(const M1 &m1,const M2 &m2)
01083 #if(CXSC_INDEX_CHECK)
01084 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01085 #else
01086 throw();
01087 #endif
01088 template <class M1,class M2> friend M1 &_mmplusassign(M1 &m1,const M2 &m2)
01089 #if(CXSC_INDEX_CHECK)
01090 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01091 #else
01092 throw();
01093 #endif
01094 template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms)
01095 #if(CXSC_INDEX_CHECK)
01096 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01097 #else
01098 throw();
01099 #endif
01100 template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1)
01101 #if(CXSC_INDEX_CHECK)
01102 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01103 #else
01104 throw();
01105 #endif
01106 template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2)
01107 #if(CXSC_INDEX_CHECK)
01108 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01109 #else
01110 throw();
01111 #endif
01112 template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms)
01113 #if(CXSC_INDEX_CHECK)
01114 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01115 #else
01116 throw();
01117 #endif
01118 template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m)
01119 #if(CXSC_INDEX_CHECK)
01120 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01121 #else
01122 throw();
01123 #endif
01124 template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2)
01125 #if(CXSC_INDEX_CHECK)
01126 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01127 #else
01128 throw();
01129 #endif
01130 template <class M1,class M2> friend M1 &_mmminusassign(M1 &m1,const M2 &m2)
01131 #if(CXSC_INDEX_CHECK)
01132 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01133 #else
01134 throw();
01135 #endif
01136 template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms)
01137 #if(CXSC_INDEX_CHECK)
01138 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01139 #else
01140 throw();
01141 #endif
01142 template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1)
01143 #if(CXSC_INDEX_CHECK)
01144 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01145 #else
01146 throw();
01147 #endif
01148 template <class M1,class M2,class E> friend E _mmcimult(const M1 &m1, const M2 &m2)
01149 #if(CXSC_INDEX_CHECK)
01150 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01151 #else
01152 throw();
01153 #endif
01154 template <class M1,class M2,class S> friend M1 &_mmcimultassign(M1 &m1,const M2 &m2)
01155 #if(CXSC_INDEX_CHECK)
01156 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01157 #else
01158 throw();
01159 #endif
01160 template <class M,class MS,class E> friend E _mmscimult(const M &m1, const MS &ms)
01161 #if(CXSC_INDEX_CHECK)
01162 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01163 #else
01164 throw();
01165 #endif
01166 template <class MS,class M,class E> friend E _msmcimult(const MS &ms, const M &m2)
01167 #if(CXSC_INDEX_CHECK)
01168 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01169 #else
01170 throw();
01171 #endif
01172 template <class M,class MS,class S> friend M &_mmscimultassign(M &m1,const MS &ms)
01173 #if(CXSC_INDEX_CHECK)
01174 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01175 #else
01176 throw();
01177 #endif
01178 template <class MS1,class MS2,class E> friend E _msmscimult(const MS1 &ms1, const MS2 &ms2)
01179 #if(CXSC_INDEX_CHECK)
01180 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01181 #else
01182 throw();
01183 #endif
01184 template <class M1,class M2,class E> friend E _mmconv(const M1 &m1,const M2 &m2)
01185 #if(CXSC_INDEX_CHECK)
01186 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01187 #else
01188 throw();
01189 #endif
01190 template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms)
01191 #if(CXSC_INDEX_CHECK)
01192 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01193 #else
01194 throw();
01195 #endif
01196 template <class M1,class M2> friend M1 &_mmconvassign(M1 &m1,const M2 &m2)
01197 #if(CXSC_INDEX_CHECK)
01198 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01199 #else
01200 throw();
01201 #endif
01202 template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms)
01203 #if(CXSC_INDEX_CHECK)
01204 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01205 #else
01206 throw();
01207 #endif
01208 template <class MS,class M> friend MS &_msmconvassign(MS &ms,const M &m1)
01209 #if(CXSC_INDEX_CHECK)
01210 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01211 #else
01212 throw();
01213 #endif
01214 template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2)
01215 #if(CXSC_INDEX_CHECK)
01216 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01217 #else
01218 throw();
01219 #endif
01220 template <class M1,class M2,class E> friend E _mmsect(const M1 &m1,const M2 &m2)
01221 #if(CXSC_INDEX_CHECK)
01222 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01223 #else
01224 throw();
01225 #endif
01226 template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms)
01227 #if(CXSC_INDEX_CHECK)
01228 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01229 #else
01230 throw();
01231 #endif
01232 template <class M1,class M2> friend M1 &_mmsectassign(M1 &m1,const M2 &m2)
01233 #if(CXSC_INDEX_CHECK)
01234 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01235 #else
01236 throw();
01237 #endif
01238 template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms)
01239 #if(CXSC_INDEX_CHECK)
01240 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01241 #else
01242 throw();
01243 #endif
01244 template <class MS,class M> friend MS &_msmsectassign(MS &ms,const M &m1)
01245 #if(CXSC_INDEX_CHECK)
01246 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01247 #else
01248 throw();
01249 #endif
01250 template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2)
01251 #if(CXSC_INDEX_CHECK)
01252 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01253 #else
01254 throw();
01255 #endif
01256
01257 template <class S,class M,class E> friend E _smmult(const S &c, const M &m) throw();
01258 template <class M,class S> friend M &_msmultassign(M &m,const S &c) throw();
01259 template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) throw();
01260 template <class M,class S,class E> friend E _msdiv(const M &m,const S &c) throw();
01261 template <class M,class S> friend M &_msdivassign(M &m,const S &c) throw();
01262 template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) throw();
01263
01264 template <class M,class V,class E> friend E _mvcimult(const M &m,const V &v)
01265 #if(CXSC_INDEX_CHECK)
01266 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01267 #else
01268 throw();
01269 #endif
01270 template <class V,class M,class E> friend E _vmcimult(const V &v,const M &m)
01271 #if(CXSC_INDEX_CHECK)
01272 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01273 #else
01274 throw();
01275 #endif
01276 template <class V,class M,class S> friend V &_vmcimultassign(V &v,const M &m)
01277 #if(CXSC_INDEX_CHECK)
01278 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01279 #else
01280 throw();
01281 #endif
01282 template <class VS,class M,class S> friend VS &_vsmcimultassign(VS &v,const M &m)
01283 #if(CXSC_INDEX_CHECK)
01284 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01285 #else
01286 throw();
01287 #endif
01288
01289 template <class M> friend void *_mvoid(const M &m) throw();
01290 template <class M> friend bool _mnot(const M &m) throw();
01291 template <class MS> friend void *_msvoid(const MS &ms) throw();
01292 template <class MS> friend bool _msnot(const MS &ms) throw();
01293 template <class M1,class M2> friend bool _mmeq(const M1 &m1,const M2 &m2) throw();
01294 template <class M1,class M2> friend bool _mmneq(const M1 &m1,const M2 &m2) throw();
01295 template <class M1,class M2> friend bool _mmless(const M1 &m1,const M2 &m2) throw();
01296 template <class M1,class M2> friend bool _mmleq(const M1 &m1,const M2 &m2) throw();
01297 template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) throw();
01298 template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) throw();
01299 template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) throw();
01300 template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) throw();
01301 template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) throw();
01302 template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) throw();
01303 template <class M> friend std::ostream &_mout(std::ostream &s,const M &r) throw();
01304 template <class M> friend std::istream &_min(std::istream &s,M &r) throw();
01305
01306
01307
01308
01309
01310
01311
01312
01313 template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v)
01314 #if(CXSC_INDEX_CHECK)
01315 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01316 #else
01317 throw();
01318 #endif
01319 template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms)
01320 #if(CXSC_INDEX_CHECK)
01321 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01322 #else
01323 throw();
01324 #endif
01325
01326
01327
01328
01329
01330
01331
01332
01333
01334
01335
01336
01337
01338
01339
01340
01341
01342
01343
01344
01345
01346
01347
01348
01349
01350
01351
01352
01353
01354 #endif
01355
01356
01357
01358
01360 INLINE cimatrix(const cimatrix &rm) throw();
01362 INLINE cimatrix(const cimatrix_slice &rm) throw();
01364 INLINE cimatrix(const scimatrix &rm);
01366 INLINE cimatrix(const scimatrix_slice &rm);
01368 INLINE cimatrix() throw();
01370 explicit INLINE cimatrix(const int &m, const int &n)
01371 #if(CXSC_INDEX_CHECK)
01372 throw(ERROR_CIMATRIX_WRONG_BOUNDARIES);
01373 #else
01374 throw();
01375 #endif
01376
01377 explicit INLINE cimatrix(const int &m1, const int &n1, const int &m2, const int &n2)
01378 #if(CXSC_INDEX_CHECK)
01379 throw(ERROR_CIMATRIX_WRONG_BOUNDARIES);
01380 #else
01381 throw();
01382 #endif
01383
01384 explicit INLINE cimatrix(const civector &v) throw();
01386 explicit INLINE cimatrix(const civector_slice &v) throw();
01388 explicit INLINE cimatrix(const cinterval &r) throw();
01390 INLINE cimatrix &operator =(const cinterval &r) throw();
01392 INLINE cimatrix &operator =(const cimatrix &m) throw();
01394 INLINE cimatrix &operator =(const cimatrix_slice &ms) throw();
01396 INLINE cimatrix &operator =(const scimatrix &m);
01398 INLINE cimatrix &operator =(const scimatrix_slice &ms);
01400 INLINE cimatrix &operator =(const civector &v) throw();
01402 INLINE cimatrix &operator =(const civector_slice &v) throw();
01403
01405 explicit INLINE cimatrix(const real &r) throw();
01407 explicit INLINE cimatrix(const rmatrix &rm) throw();
01409 explicit INLINE cimatrix(const rmatrix_slice &rm) throw();
01411 explicit INLINE cimatrix(const srmatrix &rm);
01413 explicit INLINE cimatrix(const srmatrix_slice &rm);
01415 explicit INLINE cimatrix(const rvector &v) throw();
01417 explicit INLINE cimatrix(const rvector_slice &v) throw();
01419 INLINE cimatrix &operator =(const real &r) throw();
01421 INLINE cimatrix &operator =(const rmatrix &m) throw();
01423 INLINE cimatrix &operator =(const rmatrix_slice &ms) throw();
01425 INLINE cimatrix &operator =(const srmatrix &m);
01427 INLINE cimatrix &operator =(const srmatrix_slice &ms);
01429 INLINE cimatrix &operator =(const rvector &v) throw();
01431 INLINE cimatrix &operator =(const rvector_slice &v) throw();
01432
01433
01435 explicit INLINE cimatrix(const complex &r) throw();
01437 explicit INLINE cimatrix(const cmatrix &rm) throw();
01439 explicit INLINE cimatrix(const cmatrix_slice &rm) throw();
01441 explicit INLINE cimatrix(const scmatrix &rm);
01443 explicit INLINE cimatrix(const scmatrix_slice &rm);
01445 explicit INLINE cimatrix(const cvector &v) throw();
01447 explicit INLINE cimatrix(const cvector_slice &v) throw();
01449 INLINE cimatrix &operator =(const complex &r) throw();
01451 INLINE cimatrix &operator =(const cmatrix &m) throw();
01453 INLINE cimatrix &operator =(const cmatrix_slice &ms) throw();
01455 INLINE cimatrix &operator =(const scmatrix &m);
01457 INLINE cimatrix &operator =(const scmatrix_slice &ms);
01459 INLINE cimatrix &operator =(const cvector &v) throw();
01461 INLINE cimatrix &operator =(const cvector_slice &v) throw();
01462
01463
01465 explicit INLINE cimatrix(const interval &r) throw();
01467 explicit INLINE cimatrix(const imatrix &rm) throw();
01469 explicit INLINE cimatrix(const imatrix_slice &rm) throw();
01471 explicit INLINE cimatrix(const simatrix &rm);
01473 explicit INLINE cimatrix(const simatrix_slice &rm);
01475 explicit INLINE cimatrix(const ivector &v) throw();
01477 explicit INLINE cimatrix(const ivector_slice &v) throw();
01479 INLINE cimatrix &operator =(const interval &r) throw();
01481 INLINE cimatrix &operator =(const imatrix &m) throw();
01483 INLINE cimatrix &operator =(const imatrix_slice &ms) throw();
01485 INLINE cimatrix &operator =(const simatrix &m);
01487 INLINE cimatrix &operator =(const simatrix_slice &ms);
01489 INLINE cimatrix &operator =(const ivector &v) throw();
01491 INLINE cimatrix &operator =(const ivector_slice &v) throw();
01492
01493
01494
01495 INLINE ~cimatrix() throw() { delete [] dat; }
01496
01497
01499 INLINE cimatrix &operator +=(const scimatrix &m1);
01501 INLINE cimatrix &operator +=(const scimatrix_slice &m1);
01503 INLINE cimatrix &operator -=(const scimatrix &m1);
01505 INLINE cimatrix &operator -=(const scimatrix_slice &m1);
01507 INLINE cimatrix &operator |=(const scimatrix &m1);
01509 INLINE cimatrix &operator |=(const scimatrix_slice &m1);
01511 INLINE cimatrix &operator &=(const scimatrix &m1);
01513 INLINE cimatrix &operator &=(const scimatrix_slice &m1);
01515 INLINE cimatrix &operator *=(const scimatrix &m1);
01517 INLINE cimatrix &operator *=(const scimatrix_slice &m1);
01518
01520 INLINE cimatrix &operator +=(const srmatrix &m1);
01522 INLINE cimatrix &operator +=(const srmatrix_slice &m1);
01524 INLINE cimatrix &operator -=(const srmatrix &m1);
01526 INLINE cimatrix &operator -=(const srmatrix_slice &m1);
01528 INLINE cimatrix &operator |=(const srmatrix &m1);
01530 INLINE cimatrix &operator |=(const srmatrix_slice &m1);
01532 INLINE cimatrix &operator &=(const srmatrix &m1);
01534 INLINE cimatrix &operator &=(const srmatrix_slice &m1);
01536 INLINE cimatrix &operator *=(const srmatrix &m1);
01538 INLINE cimatrix &operator *=(const srmatrix_slice &m1);
01539
01541 INLINE cimatrix &operator +=(const scmatrix &m1);
01543 INLINE cimatrix &operator +=(const scmatrix_slice &m1);
01545 INLINE cimatrix &operator -=(const scmatrix &m1);
01547 INLINE cimatrix &operator -=(const scmatrix_slice &m1);
01549 INLINE cimatrix &operator |=(const scmatrix &m1);
01551 INLINE cimatrix &operator |=(const scmatrix_slice &m1);
01553 INLINE cimatrix &operator &=(const scmatrix &m1);
01555 INLINE cimatrix &operator &=(const scmatrix_slice &m1);
01557 INLINE cimatrix &operator *=(const scmatrix &m1);
01559 INLINE cimatrix &operator *=(const scmatrix_slice &m1);
01560
01562 INLINE cimatrix &operator +=(const simatrix &m1);
01564 INLINE cimatrix &operator +=(const simatrix_slice &m1);
01566 INLINE cimatrix &operator -=(const simatrix &m1);
01568 INLINE cimatrix &operator -=(const simatrix_slice &m1);
01570 INLINE cimatrix &operator |=(const simatrix &m1);
01572 INLINE cimatrix &operator |=(const simatrix_slice &m1);
01574 INLINE cimatrix &operator &=(const simatrix &m1);
01576 INLINE cimatrix &operator &=(const simatrix_slice &m1);
01578 INLINE cimatrix &operator *=(const simatrix &m1);
01580 INLINE cimatrix &operator *=(const simatrix_slice &m1);
01581
01583 INLINE cimatrix operator()(const intvector& p, const intvector& q);
01585 INLINE cimatrix operator()(const intmatrix& P, const intmatrix& Q);
01587 INLINE cimatrix operator()(const intvector& p);
01589 INLINE cimatrix operator()(const intmatrix& P);
01590
01591
01592
01594 INLINE cimatrix_subv operator [](const int &i) const
01595 #if(CXSC_INDEX_CHECK)
01596 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
01597 #else
01598 throw();
01599 #endif
01600
01601 INLINE cimatrix_subv operator [](const cxscmatrix_column &i) const
01602 #if(CXSC_INDEX_CHECK)
01603 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
01604 #else
01605 throw();
01606 #endif
01607
01608 INLINE cimatrix_subv operator [](const int &i)
01609 #if(CXSC_INDEX_CHECK)
01610 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
01611 #else
01612 throw();
01613 #endif
01614
01615 INLINE cimatrix_subv operator [](const cxscmatrix_column &i)
01616 #if(CXSC_INDEX_CHECK)
01617 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
01618 #else
01619 throw();
01620 #endif
01621
01623 INLINE cimatrix &operator ()() throw() { return *this; }
01625 INLINE cimatrix_slice operator ()(const int &m, const int &n)
01626 #if(CXSC_INDEX_CHECK)
01627 throw(ERROR_CIMATRIX_SUB_ARRAY_TOO_BIG);
01628 #else
01629 throw();
01630 #endif
01631
01632 INLINE cimatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
01633 #if(CXSC_INDEX_CHECK)
01634 throw(ERROR_CIMATRIX_SUB_ARRAY_TOO_BIG);
01635 #else
01636 throw();
01637 #endif
01638 INLINE operator void*() throw();
01639
01640
01641 };
01642
01643
01645
01650 class cimatrix_slice
01651 {
01652 friend class cimatrix;
01653 private:
01654 cinterval *dat;
01655 int offset1,offset2,mxsize,mysize;
01656 int start1,end1,start2,end2,sxsize,sysize;
01657
01658 public:
01659
01660 #ifdef _CXSC_FRIEND_TPL
01661
01662 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m)
01663 #if(CXSC_INDEX_CHECK)
01664 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>);
01665 #else
01666 throw();
01667 #endif
01668 template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m)
01669 #if(CXSC_INDEX_CHECK)
01670 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01671 #else
01672 throw();
01673 #endif
01674 template <class MS1,class MS2> friend MS1 &_msmsassign(MS1 &ms1,const MS2 &ms)
01675 #if(CXSC_INDEX_CHECK)
01676 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01677 #else
01678 throw();
01679 #endif
01680 template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) throw();
01681 template <class MS,class S> friend MS &_mssassign(MS &ms,const S &r) throw();
01682 template <class MS> friend int _mslb(const MS &ms, const int &i)
01683 #if(CXSC_INDEX_CHECK)
01684 throw(ERROR__WRONG_ROW_OR_COL<MS>);
01685 #else
01686 throw();
01687 #endif
01688 template <class MS> friend int _msub(const MS &ms, const int &i)
01689 #if(CXSC_INDEX_CHECK)
01690 throw(ERROR__WRONG_ROW_OR_COL<MS>);
01691 #else
01692 throw();
01693 #endif
01694 template <class MS,class E> friend E _msabs(const MS &ms) throw();
01695 template <class MS,class E> friend E _msinf(const MS &ms) throw();
01696 template <class MS,class E> friend E _mssup(const MS &ms) throw();
01697 template <class MS,class E> friend E _msdiam(const MS &ms) throw();
01698 template <class MS,class E> friend E _msmid(const MS &ms) throw();
01699 template <class MS,class E> friend E _msre(const MS &ms) throw();
01700 template <class MS,class E> friend E _msim(const MS &ms) throw();
01701 friend INLINE rmatrix SupRe(const cimatrix_slice &v) throw();
01702 friend INLINE rmatrix SupIm(const cimatrix_slice &v) throw();
01703 friend INLINE rmatrix InfRe(const cimatrix_slice &v) throw();
01704 friend INLINE rmatrix InfIm(const cimatrix_slice &v) throw();
01705 template <class MS1,class M2> friend MS1 &_msmsetre(MS1 &ms1,const M2 &m2)
01706 #if(CXSC_INDEX_CHECK)
01707 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01708 #else
01709 throw();
01710 #endif
01711 template <class MS1,class M2> friend MS1 &_msmsetim(MS1 &ms1,const M2 &m2)
01712 #if(CXSC_INDEX_CHECK)
01713 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01714 #else
01715 throw();
01716 #endif
01717 template <class MS1,class MS2> friend MS1 &_msmssetre(MS1 &ms1,const MS2 &ms2)
01718 #if(CXSC_INDEX_CHECK)
01719 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01720 #else
01721 throw();
01722 #endif
01723 template <class MS1,class MS2> friend MS1 &_msmssetim(MS1 &ms1,const MS2 &ms2)
01724 #if(CXSC_INDEX_CHECK)
01725 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01726 #else
01727 throw();
01728 #endif
01729 template <class MS1,class M2> friend MS1 &_msmsetinf(MS1 &ms1,const M2 &m2)
01730 #if(CXSC_INDEX_CHECK)
01731 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01732 #else
01733 throw();
01734 #endif
01735 template <class MS1,class M2> friend MS1 &_msmsetsup(MS1 &ms1,const M2 &m2)
01736 #if(CXSC_INDEX_CHECK)
01737 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01738 #else
01739 throw();
01740 #endif
01741 template <class MS1,class MS2> friend MS1 &_msmssetinf(MS1 &ms1,const MS2 &ms2)
01742 #if(CXSC_INDEX_CHECK)
01743 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01744 #else
01745 throw();
01746 #endif
01747 template <class MS1,class MS2> friend MS1 &_msmssetsup(MS1 &ms1,const MS2 &ms2)
01748 #if(CXSC_INDEX_CHECK)
01749 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01750 #else
01751 throw();
01752 #endif
01753 template <class MS1,class M2> friend MS1 &_msmusetinf(MS1 &ms1,const M2 &m2)
01754 #if(CXSC_INDEX_CHECK)
01755 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01756 #else
01757 throw();
01758 #endif
01759 template <class MS1,class M2> friend MS1 &_msmusetsup(MS1 &ms1,const M2 &m2)
01760 #if(CXSC_INDEX_CHECK)
01761 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01762 #else
01763 throw();
01764 #endif
01765 template <class MS1,class MS2> friend MS1 &_msmsusetinf(MS1 &ms1,const MS2 &ms2)
01766 #if(CXSC_INDEX_CHECK)
01767 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01768 #else
01769 throw();
01770 #endif
01771 template <class MS1,class MS2> friend MS1 &_msmsusetsup(MS1 &ms1,const MS2 &ms2)
01772 #if(CXSC_INDEX_CHECK)
01773 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01774 #else
01775 throw();
01776 #endif
01777
01778 template <class MS,class E> friend E _msminus(const MS &ms) throw();
01779 template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms)
01780 #if(CXSC_INDEX_CHECK)
01781 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01782 #else
01783 throw();
01784 #endif
01785 template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2)
01786 #if(CXSC_INDEX_CHECK)
01787 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01788 #else
01789 throw();
01790 #endif
01791 template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms)
01792 #if(CXSC_INDEX_CHECK)
01793 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01794 #else
01795 throw();
01796 #endif
01797 template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1)
01798 #if(CXSC_INDEX_CHECK)
01799 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01800 #else
01801 throw();
01802 #endif
01803 template <class MS1,class MS2> friend MS1 &_msmsplusassign(MS1 &ms1,const MS2 &ms2)
01804 #if(CXSC_INDEX_CHECK)
01805 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01806 #else
01807 throw();
01808 #endif
01809 template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms)
01810 #if(CXSC_INDEX_CHECK)
01811 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01812 #else
01813 throw();
01814 #endif
01815 template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m)
01816 #if(CXSC_INDEX_CHECK)
01817 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01818 #else
01819 throw();
01820 #endif
01821 template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2)
01822 #if(CXSC_INDEX_CHECK)
01823 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01824 #else
01825 throw();
01826 #endif
01827 template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms)
01828 #if(CXSC_INDEX_CHECK)
01829 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01830 #else
01831 throw();
01832 #endif
01833 template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1)
01834 #if(CXSC_INDEX_CHECK)
01835 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01836 #else
01837 throw();
01838 #endif
01839 template <class MS1,class MS2> friend MS1 &_msmsminusassign(MS1 &ms1,const MS2 &ms2)
01840 #if(CXSC_INDEX_CHECK)
01841 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01842 #else
01843 throw();
01844 #endif
01845 template <class M,class MS,class E> friend E _mmscimult(const M &m1, const MS &ms)
01846 #if(CXSC_INDEX_CHECK)
01847 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01848 #else
01849 throw();
01850 #endif
01851 template <class MS,class M,class E> friend E _msmcimult(const MS &ms, const M &m2)
01852 #if(CXSC_INDEX_CHECK)
01853 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01854 #else
01855 throw();
01856 #endif
01857 template <class M,class MS,class S> friend M &_mmscimultassign(M &m1,const MS &ms)
01858 #if(CXSC_INDEX_CHECK)
01859 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01860 #else
01861 throw();
01862 #endif
01863 template <class MS1,class MS2,class E> friend E _msmscimult(const MS1 &ms1, const MS2 &ms2)
01864 #if(CXSC_INDEX_CHECK)
01865 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01866 #else
01867 throw();
01868 #endif
01869 template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms)
01870 #if(CXSC_INDEX_CHECK)
01871 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01872 #else
01873 throw();
01874 #endif
01875 template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms)
01876 #if(CXSC_INDEX_CHECK)
01877 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01878 #else
01879 throw();
01880 #endif
01881 template <class MS,class M> friend MS &_msmconvassign(MS &ms,const M &m1)
01882 #if(CXSC_INDEX_CHECK)
01883 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01884 #else
01885 throw();
01886 #endif
01887 template <class MS1,class MS2> friend MS1 &_msmsconvassign(MS1 &ms1,const MS2 &ms2)
01888 #if(CXSC_INDEX_CHECK)
01889 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01890 #else
01891 throw();
01892 #endif
01893 template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2)
01894 #if(CXSC_INDEX_CHECK)
01895 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01896 #else
01897 throw();
01898 #endif
01899 template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms)
01900 #if(CXSC_INDEX_CHECK)
01901 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01902 #else
01903 throw();
01904 #endif
01905 template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms)
01906 #if(CXSC_INDEX_CHECK)
01907 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01908 #else
01909 throw();
01910 #endif
01911 template <class MS,class M> friend MS &_msmsectassign(MS &ms,const M &m1)
01912 #if(CXSC_INDEX_CHECK)
01913 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01914 #else
01915 throw();
01916 #endif
01917 template <class MS1,class MS2> friend MS1 &_msmssectassign(MS1 &ms1,const MS2 &ms2)
01918 #if(CXSC_INDEX_CHECK)
01919 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01920 #else
01921 throw();
01922 #endif
01923 template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2)
01924 #if(CXSC_INDEX_CHECK)
01925 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01926 #else
01927 throw();
01928 #endif
01929
01930 template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v)
01931 #if(CXSC_INDEX_CHECK)
01932 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01933 #else
01934 throw();
01935 #endif
01936 template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms)
01937 #if(CXSC_INDEX_CHECK)
01938 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01939 #else
01940 throw();
01941 #endif
01942 template <class V,class MS,class S> friend V &_vmscimultassign(V &v,const MS &ms)
01943 #if(CXSC_INDEX_CHECK)
01944 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01945 #else
01946 throw();
01947 #endif
01948
01949 template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) throw();
01950 template <class MS,class S> friend MS &_mssmultassign(MS &ms,const S &c) throw();
01951 template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) throw();
01952 template <class MS,class S> friend MS &_mssdivassign(MS &ms,const S &c) throw();
01953
01954 template <class MS> friend void *_msvoid(const MS &ms) throw();
01955 template <class MS> friend bool _msnot(const MS &ms) throw();
01956 template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) throw();
01957 template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) throw();
01958 template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) throw();
01959 template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) throw();
01960 template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) throw();
01961 template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) throw();
01962 template <class MS1,class MS2> friend bool _msmseq(const MS1 &ms1,const MS2 &ms2) throw();
01963 template <class MS1,class MS2> friend bool _msmsneq(const MS1 &ms1,const MS2 &ms2) throw();
01964 template <class MS1,class MS2> friend bool _msmsless(const MS1 &ms1,const MS2 &ms2) throw();
01965 template <class MS1,class MS2> friend bool _msmsleq(const MS1 &ms1,const MS2 &ms2) throw();
01966 template <class MS> friend std::ostream &_msout(std::ostream &s,const MS &r) throw();
01967 template <class MS> friend std::istream &_msin(std::istream &s,MS &r) throw();
01968
01969
01970
01971
01972
01973
01974
01975
01976
01977
01978
01979
01980
01981
01982
01983
01984
01985
01986
01987
01988
01989
01990
01991
01992
01993
01994
01995
01996
01997
01998 #endif
01999
02000
02001
02003 explicit INLINE cimatrix_slice(cimatrix &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) { }
02005 explicit INLINE cimatrix_slice(cimatrix_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) { }
02006 public:
02008 INLINE cimatrix_slice(const cimatrix_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) { }
02009 public:
02010
02011
02012
02013 friend INLINE civector::civector(const cimatrix_slice &sl)
02014 #if(CXSC_INDEX_CHECK)
02015 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
02016 #else
02017 throw();
02018 #endif
02019 friend INLINE cimatrix::cimatrix(const cimatrix_slice &) throw();
02021 INLINE cimatrix_slice &operator =(const cimatrix &m)
02022 #if(CXSC_INDEX_CHECK)
02023 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02024 #else
02025 throw();
02026 #endif
02027
02028 INLINE cimatrix_slice &operator =(const cimatrix_slice &ms)
02029 #if(CXSC_INDEX_CHECK)
02030 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02031 #else
02032 throw();
02033 #endif
02034
02035 INLINE cimatrix_slice &operator =(const cinterval &r) throw();
02037 INLINE cimatrix_slice &operator =(const scimatrix &v);
02039 INLINE cimatrix_slice &operator =(const scimatrix_subv &v);
02041 INLINE cimatrix_slice &operator =(const scimatrix_slice &v);
02043 INLINE cimatrix_slice &operator =(const civector &v)
02044 #if(CXSC_INDEX_CHECK)
02045 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02046 #else
02047 throw();
02048 #endif
02049
02050 INLINE cimatrix_slice &operator =(const civector_slice &v)
02051 #if(CXSC_INDEX_CHECK)
02052 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02053 #else
02054 throw();
02055 #endif
02056
02057 INLINE cimatrix_slice &operator =(const cimatrix_subv &v)
02058 #if(CXSC_INDEX_CHECK)
02059 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02060 #else
02061 throw();
02062 #endif
02063
02065 INLINE cimatrix_slice &operator =(const srmatrix &v);
02067 INLINE cimatrix_slice &operator =(const srmatrix_subv &v);
02069 INLINE cimatrix_slice &operator =(const srmatrix_slice &v);
02071 INLINE cimatrix_slice &operator =(const rmatrix &m)
02072 #if(CXSC_INDEX_CHECK)
02073 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02074 #else
02075 throw();
02076 #endif
02077
02078 INLINE cimatrix_slice &operator =(const rmatrix_slice &ms)
02079 #if(CXSC_INDEX_CHECK)
02080 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02081 #else
02082 throw();
02083 #endif
02084
02085 INLINE cimatrix_slice &operator =(const real &r) throw();
02087 INLINE cimatrix_slice &operator =(const rvector &v)
02088 #if(CXSC_INDEX_CHECK)
02089 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02090 #else
02091 throw();
02092 #endif
02093
02094 INLINE cimatrix_slice &operator =(const rvector_slice &v)
02095 #if(CXSC_INDEX_CHECK)
02096 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02097 #else
02098 throw();
02099 #endif
02100
02101 INLINE cimatrix_slice &operator =(const rmatrix_subv &v)
02102 #if(CXSC_INDEX_CHECK)
02103 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02104 #else
02105 throw();
02106 #endif
02107
02108
02110 INLINE cimatrix_slice &operator =(const simatrix_subv &v);
02112 INLINE cimatrix_slice &operator =(const simatrix &v);
02114 INLINE cimatrix_slice &operator =(const simatrix_slice &v);
02116 INLINE cimatrix_slice &operator =(const imatrix &m)
02117 #if(CXSC_INDEX_CHECK)
02118 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02119 #else
02120 throw();
02121 #endif
02122
02123 INLINE cimatrix_slice &operator =(const imatrix_slice &ms)
02124 #if(CXSC_INDEX_CHECK)
02125 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02126 #else
02127 throw();
02128 #endif
02129
02130 INLINE cimatrix_slice &operator =(const interval &r) throw();
02132 INLINE cimatrix_slice &operator =(const ivector &v)
02133 #if(CXSC_INDEX_CHECK)
02134 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02135 #else
02136 throw();
02137 #endif
02138
02139 INLINE cimatrix_slice &operator =(const ivector_slice &v)
02140 #if(CXSC_INDEX_CHECK)
02141 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02142 #else
02143 throw();
02144 #endif
02145
02146 INLINE cimatrix_slice &operator =(const imatrix_subv &v)
02147 #if(CXSC_INDEX_CHECK)
02148 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02149 #else
02150 throw();
02151 #endif
02152
02153
02155 INLINE cimatrix_slice &operator =(const scmatrix &v);
02157 INLINE cimatrix_slice &operator =(const scmatrix_subv &v);
02159 INLINE cimatrix_slice &operator =(const scmatrix_slice &v);
02161 INLINE cimatrix_slice &operator =(const cmatrix &m)
02162 #if(CXSC_INDEX_CHECK)
02163 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02164 #else
02165 throw();
02166 #endif
02167
02168 INLINE cimatrix_slice &operator =(const cmatrix_slice &ms)
02169 #if(CXSC_INDEX_CHECK)
02170 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02171 #else
02172 throw();
02173 #endif
02174
02175 INLINE cimatrix_slice &operator =(const complex &r) throw();
02177 INLINE cimatrix_slice &operator =(const cvector &v)
02178 #if(CXSC_INDEX_CHECK)
02179 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02180 #else
02181 throw();
02182 #endif
02183
02184 INLINE cimatrix_slice &operator =(const cvector_slice &v)
02185 #if(CXSC_INDEX_CHECK)
02186 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02187 #else
02188 throw();
02189 #endif
02190
02191 INLINE cimatrix_slice &operator =(const cmatrix_subv &v)
02192 #if(CXSC_INDEX_CHECK)
02193 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02194 #else
02195 throw();
02196 #endif
02197
02199 INLINE cimatrix_subv operator [](const int &i)
02200 #if(CXSC_INDEX_CHECK)
02201 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
02202 #else
02203 throw();
02204 #endif
02205
02206 INLINE cimatrix_subv operator [](const cxscmatrix_column &i)
02207 #if(CXSC_INDEX_CHECK)
02208 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
02209 #else
02210 throw();
02211 #endif
02212
02214 INLINE cimatrix_subv operator [](const int &i) const
02215 #if(CXSC_INDEX_CHECK)
02216 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
02217 #else
02218 throw();
02219 #endif
02220
02221 INLINE cimatrix_subv operator [](const cxscmatrix_column &i) const
02222 #if(CXSC_INDEX_CHECK)
02223 throw(ERROR_CIMATRIX_ROW_OR_COL_NOT_IN_MAT);
02224 #else
02225 throw();
02226 #endif
02227
02229 INLINE cimatrix_slice &operator ()() throw() { return *this; }
02231 INLINE cimatrix_slice operator ()(const int &m, const int &n)
02232 #if(CXSC_INDEX_CHECK)
02233 throw(ERROR_CIMATRIX_SUB_ARRAY_TOO_BIG);
02234 #else
02235 throw();
02236 #endif
02237
02238 INLINE cimatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
02239 #if(CXSC_INDEX_CHECK)
02240 throw(ERROR_CIMATRIX_SUB_ARRAY_TOO_BIG);
02241 #else
02242 throw();
02243 #endif
02244 INLINE operator void*() throw();
02245
02247 INLINE cimatrix_slice &operator +=(const cinterval &c) throw();
02249 INLINE cimatrix_slice &operator -=(const cinterval &c) throw();
02251 INLINE cimatrix_slice &operator *=(const cinterval &c) throw();
02253 INLINE cimatrix_slice &operator /=(const cinterval &c) throw();
02255 INLINE cimatrix_slice &operator +=(const scimatrix &m1);
02257 INLINE cimatrix_slice &operator +=(const scimatrix_slice &m1);
02259 INLINE cimatrix_slice &operator -=(const scimatrix &m1);
02261 INLINE cimatrix_slice &operator -=(const scimatrix_slice &m1);
02263 INLINE cimatrix_slice &operator |=(const scimatrix &m1);
02265 INLINE cimatrix_slice &operator |=(const scimatrix_slice &m1);
02267 INLINE cimatrix_slice &operator &=(const scimatrix &m1);
02269 INLINE cimatrix_slice &operator &=(const scimatrix_slice &m1);
02271 INLINE cimatrix_slice &operator *=(const scimatrix &m1);
02273 INLINE cimatrix_slice &operator *=(const scimatrix_slice &m1);
02274
02276 INLINE cimatrix_slice &operator +=(const cimatrix &m1)
02277 #if(CXSC_INDEX_CHECK)
02278 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02279 #else
02280 throw();
02281 #endif
02282
02283 INLINE cimatrix_slice &operator +=(const cimatrix_slice &ms2)
02284 #if(CXSC_INDEX_CHECK)
02285 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02286 #else
02287 throw();
02288 #endif
02289
02290 INLINE cimatrix_slice &operator -=(const cimatrix &m1)
02291 #if(CXSC_INDEX_CHECK)
02292 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02293 #else
02294 throw();
02295 #endif
02296
02297 INLINE cimatrix_slice &operator -=(const cimatrix_slice &ms2)
02298 #if(CXSC_INDEX_CHECK)
02299 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02300 #else
02301 throw();
02302 #endif
02303
02304 INLINE cimatrix_slice &operator |=(const cimatrix &m1)
02305 #if(CXSC_INDEX_CHECK)
02306 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02307 #else
02308 throw();
02309 #endif
02310
02311 INLINE cimatrix_slice &operator |=(const cimatrix_slice &ms2)
02312 #if(CXSC_INDEX_CHECK)
02313 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02314 #else
02315 throw();
02316 #endif
02317
02318 INLINE cimatrix_slice &operator &=(const cimatrix &m1)
02319 #if(CXSC_INDEX_CHECK)
02320 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02321 #else
02322 throw();
02323 #endif
02324
02325 INLINE cimatrix_slice &operator &=(const cimatrix_slice &ms2)
02326 #if(CXSC_INDEX_CHECK)
02327 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02328 #else
02329 throw();
02330 #endif
02331
02332 INLINE cimatrix_slice &operator *=(const cimatrix &m)
02333 #if(CXSC_INDEX_CHECK)
02334 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02335 #else
02336 throw();
02337 #endif
02338
02339 INLINE cimatrix_slice &operator *=(const cimatrix_slice &ms2)
02340 #if(CXSC_INDEX_CHECK)
02341 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02342 #else
02343 throw();
02344 #endif
02345
02347 INLINE cimatrix_slice &operator +=(const real &c) throw();
02349 INLINE cimatrix_slice &operator -=(const real &c) throw();
02351 INLINE cimatrix_slice &operator *=(const real &c) throw();
02353 INLINE cimatrix_slice &operator /=(const real &c) throw();
02355 INLINE cimatrix_slice &operator +=(const srmatrix &m1);
02357 INLINE cimatrix_slice &operator +=(const srmatrix_slice &m1);
02359 INLINE cimatrix_slice &operator -=(const srmatrix &m1);
02361 INLINE cimatrix_slice &operator -=(const srmatrix_slice &m1);
02363 INLINE cimatrix_slice &operator |=(const srmatrix &m1);
02365 INLINE cimatrix_slice &operator |=(const srmatrix_slice &m1);
02367 INLINE cimatrix_slice &operator &=(const srmatrix &m1);
02369 INLINE cimatrix_slice &operator &=(const srmatrix_slice &m1);
02371 INLINE cimatrix_slice &operator *=(const srmatrix &m1);
02373 INLINE cimatrix_slice &operator *=(const srmatrix_slice &m1);
02374
02376 INLINE cimatrix_slice &operator +=(const rmatrix_slice &ms2)
02377 #if(CXSC_INDEX_CHECK)
02378 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02379 #else
02380 throw();
02381 #endif
02382
02383 INLINE cimatrix_slice &operator +=(const rmatrix &m1)
02384 #if(CXSC_INDEX_CHECK)
02385 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02386 #else
02387 throw();
02388 #endif
02389
02390 INLINE cimatrix_slice &operator -=(const rmatrix &m1)
02391 #if(CXSC_INDEX_CHECK)
02392 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02393 #else
02394 throw();
02395 #endif
02396
02397 INLINE cimatrix_slice &operator -=(const rmatrix_slice &ms2)
02398 #if(CXSC_INDEX_CHECK)
02399 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02400 #else
02401 throw();
02402 #endif
02403
02404 INLINE cimatrix_slice &operator |=(const rmatrix &m1)
02405 #if(CXSC_INDEX_CHECK)
02406 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02407 #else
02408 throw();
02409 #endif
02410
02411 INLINE cimatrix_slice &operator |=(const rmatrix_slice &ms2)
02412 #if(CXSC_INDEX_CHECK)
02413 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02414 #else
02415 throw();
02416 #endif
02417
02418 INLINE cimatrix_slice &operator &=(const rmatrix &m1)
02419 #if(CXSC_INDEX_CHECK)
02420 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02421 #else
02422 throw();
02423 #endif
02424
02425 INLINE cimatrix_slice &operator &=(const rmatrix_slice &ms2)
02426 #if(CXSC_INDEX_CHECK)
02427 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02428 #else
02429 throw();
02430 #endif
02431
02432 INLINE cimatrix_slice &operator *=(const rmatrix &m)
02433 #if(CXSC_INDEX_CHECK)
02434 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02435 #else
02436 throw();
02437 #endif
02438
02439 INLINE cimatrix_slice &operator *=(const rmatrix_slice &ms2)
02440 #if(CXSC_INDEX_CHECK)
02441 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02442 #else
02443 throw();
02444 #endif
02445
02447 INLINE cimatrix_slice &operator +=(const complex &c) throw();
02449 INLINE cimatrix_slice &operator -=(const complex &c) throw();
02451 INLINE cimatrix_slice &operator *=(const complex &c) throw();
02453 INLINE cimatrix_slice &operator /=(const complex &c) throw();
02455 INLINE cimatrix_slice &operator +=(const scmatrix &m1);
02457 INLINE cimatrix_slice &operator +=(const scmatrix_slice &m1);
02459 INLINE cimatrix_slice &operator -=(const scmatrix &m1);
02461 INLINE cimatrix_slice &operator -=(const scmatrix_slice &m1);
02463 INLINE cimatrix_slice &operator |=(const scmatrix &m1);
02465 INLINE cimatrix_slice &operator |=(const scmatrix_slice &m1);
02467 INLINE cimatrix_slice &operator &=(const scmatrix &m1);
02469 INLINE cimatrix_slice &operator &=(const scmatrix_slice &m1);
02471 INLINE cimatrix_slice &operator *=(const scmatrix &m1);
02473 INLINE cimatrix_slice &operator *=(const scmatrix_slice &m1);
02474
02476 INLINE cimatrix_slice &operator +=(const cmatrix_slice &ms2)
02477 #if(CXSC_INDEX_CHECK)
02478 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02479 #else
02480 throw();
02481 #endif
02482
02483 INLINE cimatrix_slice &operator +=(const cmatrix &m1)
02484 #if(CXSC_INDEX_CHECK)
02485 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02486 #else
02487 throw();
02488 #endif
02489
02490 INLINE cimatrix_slice &operator -=(const cmatrix &m1)
02491 #if(CXSC_INDEX_CHECK)
02492 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02493 #else
02494 throw();
02495 #endif
02496
02497 INLINE cimatrix_slice &operator -=(const cmatrix_slice &ms2)
02498 #if(CXSC_INDEX_CHECK)
02499 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02500 #else
02501 throw();
02502 #endif
02503
02504 INLINE cimatrix_slice &operator |=(const cmatrix &m1)
02505 #if(CXSC_INDEX_CHECK)
02506 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02507 #else
02508 throw();
02509 #endif
02510
02511 INLINE cimatrix_slice &operator |=(const cmatrix_slice &ms2)
02512 #if(CXSC_INDEX_CHECK)
02513 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02514 #else
02515 throw();
02516 #endif
02517
02518 INLINE cimatrix_slice &operator &=(const cmatrix &m1)
02519 #if(CXSC_INDEX_CHECK)
02520 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02521 #else
02522 throw();
02523 #endif
02524
02525 INLINE cimatrix_slice &operator &=(const cmatrix_slice &ms2)
02526 #if(CXSC_INDEX_CHECK)
02527 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02528 #else
02529 throw();
02530 #endif
02531
02532 INLINE cimatrix_slice &operator *=(const cmatrix &m)
02533 #if(CXSC_INDEX_CHECK)
02534 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02535 #else
02536 throw();
02537 #endif
02538
02539 INLINE cimatrix_slice &operator *=(const cmatrix_slice &ms2)
02540 #if(CXSC_INDEX_CHECK)
02541 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02542 #else
02543 throw();
02544 #endif
02545
02547 INLINE cimatrix_slice &operator +=(const interval &c) throw();
02549 INLINE cimatrix_slice &operator -=(const interval &c) throw();
02551 INLINE cimatrix_slice &operator *=(const interval &c) throw();
02553 INLINE cimatrix_slice &operator /=(const interval &c) throw();
02555 INLINE cimatrix_slice &operator +=(const simatrix &m1);
02557 INLINE cimatrix_slice &operator +=(const simatrix_slice &m1);
02559 INLINE cimatrix_slice &operator -=(const simatrix &m1);
02561 INLINE cimatrix_slice &operator -=(const simatrix_slice &m1);
02563 INLINE cimatrix_slice &operator |=(const simatrix &m1);
02565 INLINE cimatrix_slice &operator |=(const simatrix_slice &m1);
02567 INLINE cimatrix_slice &operator &=(const simatrix &m1);
02569 INLINE cimatrix_slice &operator &=(const simatrix_slice &m1);
02571 INLINE cimatrix_slice &operator *=(const simatrix &m1);
02573 INLINE cimatrix_slice &operator *=(const simatrix_slice &m1);
02574
02576 INLINE cimatrix_slice &operator +=(const imatrix_slice &ms2)
02577 #if(CXSC_INDEX_CHECK)
02578 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02579 #else
02580 throw();
02581 #endif
02582
02583 INLINE cimatrix_slice &operator +=(const imatrix &m1)
02584 #if(CXSC_INDEX_CHECK)
02585 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02586 #else
02587 throw();
02588 #endif
02589
02590 INLINE cimatrix_slice &operator -=(const imatrix &m1)
02591 #if(CXSC_INDEX_CHECK)
02592 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02593 #else
02594 throw();
02595 #endif
02596
02597 INLINE cimatrix_slice &operator -=(const imatrix_slice &ms2)
02598 #if(CXSC_INDEX_CHECK)
02599 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02600 #else
02601 throw();
02602 #endif
02603
02604 INLINE cimatrix_slice &operator |=(const imatrix &m1)
02605 #if(CXSC_INDEX_CHECK)
02606 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02607 #else
02608 throw();
02609 #endif
02610
02611 INLINE cimatrix_slice &operator |=(const imatrix_slice &ms2)
02612 #if(CXSC_INDEX_CHECK)
02613 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02614 #else
02615 throw();
02616 #endif
02617
02618 INLINE cimatrix_slice &operator &=(const imatrix &m1)
02619 #if(CXSC_INDEX_CHECK)
02620 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02621 #else
02622 throw();
02623 #endif
02624
02625 INLINE cimatrix_slice &operator &=(const imatrix_slice &ms2)
02626 #if(CXSC_INDEX_CHECK)
02627 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02628 #else
02629 throw();
02630 #endif
02631
02632 INLINE cimatrix_slice &operator *=(const imatrix &m)
02633 #if(CXSC_INDEX_CHECK)
02634 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02635 #else
02636 throw();
02637 #endif
02638
02639 INLINE cimatrix_slice &operator *=(const imatrix_slice &ms2)
02640 #if(CXSC_INDEX_CHECK)
02641 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02642 #else
02643 throw();
02644 #endif
02645
02646
02647
02648 };
02649
02650
02651
02652
02653
02654
02656 INLINE civector operator /(const cimatrix_subv &rv, const cinterval &s) throw();
02658 INLINE civector operator *(const cimatrix_subv &rv, const cinterval &s) throw();
02660 INLINE civector operator *(const cinterval &s, const cimatrix_subv &rv) throw();
02662 INLINE ivector abs(const cimatrix_subv &mv) throw();
02664 INLINE cvector diam(const cimatrix_subv &mv) throw();
02666 INLINE cvector mid(const cimatrix_subv &mv) throw();
02668 INLINE cvector Inf(const cimatrix_subv &mv) throw();
02670 INLINE cvector Sup(const cimatrix_subv &mv) throw();
02672 INLINE ivector Im(const cimatrix_subv &mv) throw();
02674 INLINE ivector Re(const cimatrix_subv &mv) throw();
02676 INLINE rmatrix SupRe(const cimatrix &v) throw();
02678 INLINE rmatrix SupIm(const cimatrix &v) throw();
02680 INLINE rmatrix InfRe(const cimatrix &v) throw();
02682 INLINE rmatrix InfIm(const cimatrix &v) throw();
02684 INLINE rmatrix SupRe(const cimatrix_slice &v) throw();
02686 INLINE rmatrix SupIm(const cimatrix_slice &v) throw();
02688 INLINE rmatrix InfRe(const cimatrix_slice &v) throw();
02690 INLINE rmatrix InfIm(const cimatrix_slice &v) throw();
02692 INLINE cimatrix_subv &SetInf(cimatrix_subv &iv,const cvector &rv)
02693 #if(CXSC_INDEX_CHECK)
02694 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02695 #else
02696 throw();
02697 #endif
02698
02699 INLINE cimatrix_subv &SetSup(cimatrix_subv &iv,const cvector &rv)
02700 #if(CXSC_INDEX_CHECK)
02701 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02702 #else
02703 throw();
02704 #endif
02705
02706 INLINE cimatrix_subv &UncheckedSetInf(cimatrix_subv &iv,const cvector &rv)
02707 #if(CXSC_INDEX_CHECK)
02708 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02709 #else
02710 throw();
02711 #endif
02712
02713 INLINE cimatrix_subv &UncheckedSetSup(cimatrix_subv &iv,const cvector &rv)
02714 #if(CXSC_INDEX_CHECK)
02715 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02716 #else
02717 throw();
02718 #endif
02719
02720 INLINE cimatrix_subv &SetIm(cimatrix_subv &iv,const ivector &rv)
02721 #if(CXSC_INDEX_CHECK)
02722 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02723 #else
02724 throw();
02725 #endif
02726
02727 INLINE cimatrix_subv &SetRe(cimatrix_subv &iv,const ivector &rv)
02728 #if(CXSC_INDEX_CHECK)
02729 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
02730 #else
02731 throw();
02732 #endif
02733
02735 INLINE cimatrix_subv &SetSup(cimatrix_subv &iv,const complex &r) throw();
02737 INLINE cimatrix_subv &SetInf(cimatrix_subv &iv,const complex &r) throw();
02739 INLINE cimatrix_subv &UncheckedSetSup(cimatrix_subv &iv,const complex &r) throw();
02741 INLINE cimatrix_subv &SetUncheckedInf(cimatrix_subv &iv,const complex &r) throw();
02743 INLINE cimatrix_subv &SetRe(cimatrix_subv &iv,const interval &r) throw();
02745 INLINE cimatrix_subv &SetIm(cimatrix_subv &iv,const interval &r) throw();
02746
02747
02748
02749
02751 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const cimatrix_subv &rv2)
02752 #if(CXSC_INDEX_CHECK)
02753 throw(OP_WITH_WRONG_DIM);
02754 #else
02755 throw();
02756 #endif
02757
02758 void accumulate(cidotprecision &dp, const civector & rv1, const cimatrix_subv &rv2)
02759 #if(CXSC_INDEX_CHECK)
02760 throw(OP_WITH_WRONG_DIM);
02761 #else
02762 throw();
02763 #endif
02764
02765 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const civector &rv2)
02766 #if(CXSC_INDEX_CHECK)
02767 throw(OP_WITH_WRONG_DIM);
02768 #else
02769 throw();
02770 #endif
02771
02772 void accumulate(cidotprecision &dp, const civector_slice & sl1, const cimatrix_subv &rv2)
02773 #if(CXSC_INDEX_CHECK)
02774 throw(OP_WITH_WRONG_DIM);
02775 #else
02776 throw();
02777 #endif
02778
02779 void accumulate(cidotprecision &dp, const civector_slice & sl1, const rmatrix_subv &rv2)
02780 #if(CXSC_INDEX_CHECK)
02781 throw(OP_WITH_WRONG_DIM);
02782 #else
02783 throw();
02784 #endif
02785
02786 void accumulate(cidotprecision &dp, const civector_slice & sl1, const cmatrix_subv &rv2)
02787 #if(CXSC_INDEX_CHECK)
02788 throw(OP_WITH_WRONG_DIM);
02789 #else
02790 throw();
02791 #endif
02792
02794 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const civector_slice &sl2)
02795 #if(CXSC_INDEX_CHECK)
02796 throw(OP_WITH_WRONG_DIM);
02797 #else
02798 throw();
02799 #endif
02800
02802 INLINE cinterval operator *(const cimatrix_subv & rv1, const cimatrix_subv &rv2)
02803 #if(CXSC_INDEX_CHECK)
02804 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02805 #else
02806 throw();
02807 #endif
02808
02809 INLINE cinterval operator *(const civector & rv1, const cimatrix_subv &rv2)
02810 #if(CXSC_INDEX_CHECK)
02811 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02812 #else
02813 throw();
02814 #endif
02815
02816 INLINE cinterval operator *(const cimatrix_subv &rv1,const civector &rv2)
02817 #if(CXSC_INDEX_CHECK)
02818 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02819 #else
02820 throw();
02821 #endif
02822
02823 INLINE cinterval operator *(const civector_slice &sl,const cimatrix_subv &sv)
02824 #if(CXSC_INDEX_CHECK)
02825 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02826 #else
02827 throw();
02828 #endif
02829
02830 INLINE cinterval operator *(const cimatrix_subv &mv,const civector_slice &vs)
02831 #if(CXSC_INDEX_CHECK)
02832 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02833 #else
02834 throw();
02835 #endif
02836
02838 INLINE civector operator +(const cimatrix_subv & rv1, const cimatrix_subv &rv2)
02839 #if(CXSC_INDEX_CHECK)
02840 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02841 #else
02842 throw();
02843 #endif
02844
02845 INLINE civector operator +(const cimatrix_subv &rv1,const civector &rv2)
02846 #if(CXSC_INDEX_CHECK)
02847 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02848 #else
02849 throw();
02850 #endif
02851
02852 INLINE civector operator +(const civector & rv1, const cimatrix_subv &rv2)
02853 #if(CXSC_INDEX_CHECK)
02854 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02855 #else
02856 throw();
02857 #endif
02858
02859 INLINE civector operator +(const civector_slice &sl,const cimatrix_subv &mv)
02860 #if(CXSC_INDEX_CHECK)
02861 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02862 #else
02863 throw();
02864 #endif
02865
02866 INLINE civector operator +(const cimatrix_subv &mv,const civector_slice &sl)
02867 #if(CXSC_INDEX_CHECK)
02868 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02869 #else
02870 throw();
02871 #endif
02872
02874 INLINE civector operator -(const cimatrix_subv & rv1, const cimatrix_subv &rv2)
02875 #if(CXSC_INDEX_CHECK)
02876 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02877 #else
02878 throw();
02879 #endif
02880
02881 INLINE civector operator -(const civector & rv1, const cimatrix_subv &rv2)
02882 #if(CXSC_INDEX_CHECK)
02883 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02884 #else
02885 throw();
02886 #endif
02887
02888 INLINE civector operator -(const cimatrix_subv &rv1,const civector &rv2)
02889 #if(CXSC_INDEX_CHECK)
02890 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02891 #else
02892 throw();
02893 #endif
02894
02895 INLINE civector operator -(const civector_slice &sl,const cimatrix_subv &mv)
02896 #if(CXSC_INDEX_CHECK)
02897 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02898 #else
02899 throw();
02900 #endif
02901
02902 INLINE civector operator -(const cimatrix_subv &mv,const civector_slice &sl)
02903 #if(CXSC_INDEX_CHECK)
02904 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02905 #else
02906 throw();
02907 #endif
02908
02909
02910
02912 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const rmatrix_subv &rv2)
02913 #if(CXSC_INDEX_CHECK)
02914 throw(OP_WITH_WRONG_DIM);
02915 #else
02916 throw();
02917 #endif
02918
02919 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const rvector_slice &sl2)
02920 #if(CXSC_INDEX_CHECK)
02921 throw(OP_WITH_WRONG_DIM);
02922 #else
02923 throw();
02924 #endif
02925
02926 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const rvector &rv2)
02927 #if(CXSC_INDEX_CHECK)
02928 throw(OP_WITH_WRONG_DIM);
02929 #else
02930 throw();
02931 #endif
02932
02933 void accumulate(cidotprecision &dp, const rvector & rv1, const cimatrix_subv &rv2)
02934 #if(CXSC_INDEX_CHECK)
02935 throw(OP_WITH_WRONG_DIM);
02936 #else
02937 throw();
02938 #endif
02939
02940 void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const cimatrix_subv &rv2)
02941 #if(CXSC_INDEX_CHECK)
02942 throw(OP_WITH_WRONG_DIM);
02943 #else
02944 throw();
02945 #endif
02946
02947 void accumulate(cidotprecision &dp, const rvector_slice & sl1, const cimatrix_subv &rv2)
02948 #if(CXSC_INDEX_CHECK)
02949 throw(OP_WITH_WRONG_DIM);
02950 #else
02951 throw();
02952 #endif
02953
02954
02955
02957 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const cmatrix_subv &rv2)
02958 #if(CXSC_INDEX_CHECK)
02959 throw(OP_WITH_WRONG_DIM);
02960 #else
02961 throw();
02962 #endif
02963
02964 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const cvector_slice &sl2)
02965 #if(CXSC_INDEX_CHECK)
02966 throw(OP_WITH_WRONG_DIM);
02967 #else
02968 throw();
02969 #endif
02970
02971 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const cvector &rv2)
02972 #if(CXSC_INDEX_CHECK)
02973 throw(OP_WITH_WRONG_DIM);
02974 #else
02975 throw();
02976 #endif
02977
02978 void accumulate(cidotprecision &dp, const cvector & rv1, const cimatrix_subv &rv2)
02979 #if(CXSC_INDEX_CHECK)
02980 throw(OP_WITH_WRONG_DIM);
02981 #else
02982 throw();
02983 #endif
02984
02985 void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const cimatrix_subv &rv2)
02986 #if(CXSC_INDEX_CHECK)
02987 throw(OP_WITH_WRONG_DIM);
02988 #else
02989 throw();
02990 #endif
02991
02992 void accumulate(cidotprecision &dp, const cvector_slice & sl1, const cimatrix_subv &rv2)
02993 #if(CXSC_INDEX_CHECK)
02994 throw(OP_WITH_WRONG_DIM);
02995 #else
02996 throw();
02997 #endif
02998
02999
03000
03002 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const imatrix_subv &rv2)
03003 #if(CXSC_INDEX_CHECK)
03004 throw(OP_WITH_WRONG_DIM);
03005 #else
03006 throw();
03007 #endif
03008
03009 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const ivector_slice &sl2)
03010 #if(CXSC_INDEX_CHECK)
03011 throw(OP_WITH_WRONG_DIM);
03012 #else
03013 throw();
03014 #endif
03015
03016 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const ivector &rv2)
03017 #if(CXSC_INDEX_CHECK)
03018 throw(OP_WITH_WRONG_DIM);
03019 #else
03020 throw();
03021 #endif
03022
03023 void accumulate(cidotprecision &dp, const ivector & rv1, const cimatrix_subv &rv2)
03024 #if(CXSC_INDEX_CHECK)
03025 throw(OP_WITH_WRONG_DIM);
03026 #else
03027 throw();
03028 #endif
03029
03030 void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const cimatrix_subv &rv2)
03031 #if(CXSC_INDEX_CHECK)
03032 throw(OP_WITH_WRONG_DIM);
03033 #else
03034 throw();
03035 #endif
03036
03037 void accumulate(cidotprecision &dp, const ivector_slice & sl1, const cimatrix_subv &rv2)
03038 #if(CXSC_INDEX_CHECK)
03039 throw(OP_WITH_WRONG_DIM);
03040 #else
03041 throw();
03042 #endif
03043
03044 void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const imatrix_subv &rv2)
03045 #if(CXSC_INDEX_CHECK)
03046 throw(OP_WITH_WRONG_DIM);
03047 #else
03048 throw();
03049 #endif
03050
03051 void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const cmatrix_subv &rv2)
03052 #if(CXSC_INDEX_CHECK)
03053 throw(OP_WITH_WRONG_DIM);
03054 #else
03055 throw();
03056 #endif
03057
03058
03059
03060
03061
03063 INLINE cimatrix _imatrix(const cimatrix &rm) throw();
03065 INLINE cimatrix _imatrix(const civector &v) throw();
03067 INLINE cimatrix _imatrix(const civector_slice &v) throw();
03069 INLINE cimatrix _imatrix(const cinterval &r) throw();
03070
03072 INLINE int Lb(const cimatrix &rm, const int &i)
03073 #if(CXSC_INDEX_CHECK)
03074 throw(ERROR_CIMATRIX_WRONG_ROW_OR_COL);
03075 #else
03076 throw();
03077 #endif
03078
03079 INLINE int Ub(const cimatrix &rm, const int &i)
03080 #if(CXSC_INDEX_CHECK)
03081 throw(ERROR_CIMATRIX_WRONG_ROW_OR_COL);
03082 #else
03083 throw();
03084 #endif
03085
03086 INLINE int Lb(const cimatrix_slice &rm, const int &i)
03087 #if(CXSC_INDEX_CHECK)
03088 throw(ERROR_CIMATRIX_WRONG_ROW_OR_COL);
03089 #else
03090 throw();
03091 #endif
03092
03093 INLINE int Ub(const cimatrix_slice &rm, const int &i)
03094 #if(CXSC_INDEX_CHECK)
03095 throw(ERROR_CIMATRIX_WRONG_ROW_OR_COL);
03096 #else
03097 throw();
03098 #endif
03099
03100 INLINE cimatrix &SetLb(cimatrix &m, const int &i,const int &j)
03101 #if(CXSC_INDEX_CHECK)
03102 throw(ERROR_CIMATRIX_WRONG_ROW_OR_COL);
03103 #else
03104 throw();
03105 #endif
03106
03107 INLINE cimatrix &SetUb(cimatrix &m, const int &i,const int &j)
03108 #if(CXSC_INDEX_CHECK)
03109 throw(ERROR_CIMATRIX_WRONG_ROW_OR_COL);
03110 #else
03111 throw();
03112 #endif
03113
03114 INLINE void Resize(cimatrix &A) throw();
03116 INLINE void Resize(cimatrix &A,const int &m, const int &n)
03117 #if(CXSC_INDEX_CHECK)
03118 throw(ERROR_CIMATRIX_WRONG_BOUNDARIES);
03119 #else
03120 throw();
03121 #endif
03122
03123 INLINE void Resize(cimatrix &A,const int &m1, const int &m2,const int &n1,const int &n2)
03124 #if(CXSC_INDEX_CHECK)
03125 throw(ERROR_CIMATRIX_WRONG_BOUNDARIES);
03126 #else
03127 throw();
03128 #endif
03129
03131 INLINE imatrix abs(const cimatrix &m) throw();
03133 INLINE imatrix abs(const cimatrix_slice &ms) throw();
03135 INLINE cmatrix diam(const cimatrix &m) throw();
03137 INLINE cmatrix diam(const cimatrix_slice &m) throw();
03139 INLINE cmatrix mid(const cimatrix &m) throw();
03141 INLINE cmatrix mid(const cimatrix_slice &m) throw();
03143 INLINE cmatrix Inf(const cimatrix &m) throw();
03145 INLINE cmatrix Sup(const cimatrix &m) throw();
03147 INLINE cmatrix Inf(const cimatrix_slice &m) throw();
03149 INLINE cmatrix Sup(const cimatrix_slice &m) throw();
03151 INLINE cimatrix &SetInf(cimatrix &cm,const cmatrix &rm)
03152 #if(CXSC_INDEX_CHECK)
03153 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03154 #else
03155 throw();
03156 #endif
03157
03158 INLINE cimatrix_slice &SetInf(cimatrix_slice &cm,const cmatrix &rm)
03159 #if(CXSC_INDEX_CHECK)
03160 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03161 #else
03162 throw();
03163 #endif
03164
03165 INLINE cimatrix &SetInf(cimatrix &cm,const cmatrix_slice &rm)
03166 #if(CXSC_INDEX_CHECK)
03167 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03168 #else
03169 throw();
03170 #endif
03171
03172 INLINE cimatrix_slice &SetInf(cimatrix_slice &cm,const cmatrix_slice &rm)
03173 #if(CXSC_INDEX_CHECK)
03174 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03175 #else
03176 throw();
03177 #endif
03178
03179 INLINE cimatrix &SetSup(cimatrix &cm,const cmatrix &rm)
03180 #if(CXSC_INDEX_CHECK)
03181 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03182 #else
03183 throw();
03184 #endif
03185
03186 INLINE cimatrix_slice &SetSup(cimatrix_slice &cm,const cmatrix &rm)
03187 #if(CXSC_INDEX_CHECK)
03188 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03189 #else
03190 throw();
03191 #endif
03192
03193 INLINE cimatrix &SetSup(cimatrix &cm,const cmatrix_slice &rm)
03194 #if(CXSC_INDEX_CHECK)
03195 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03196 #else
03197 throw();
03198 #endif
03199
03200 INLINE cimatrix_slice &SetSup(cimatrix_slice &cm,const cmatrix_slice &rm)
03201 #if(CXSC_INDEX_CHECK)
03202 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03203 #else
03204 throw();
03205 #endif
03206
03207 INLINE cimatrix &UncheckedSetInf(cimatrix &cm,const cmatrix &rm)
03208 #if(CXSC_INDEX_CHECK)
03209 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03210 #else
03211 throw();
03212 #endif
03213
03214 INLINE cimatrix_slice &UncheckedSetInf(cimatrix_slice &cm,const cmatrix &rm)
03215 #if(CXSC_INDEX_CHECK)
03216 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03217 #else
03218 throw();
03219 #endif
03220
03221 INLINE cimatrix &UncheckedSetInf(cimatrix &cm,const cmatrix_slice &rm)
03222 #if(CXSC_INDEX_CHECK)
03223 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03224 #else
03225 throw();
03226 #endif
03227
03228 INLINE cimatrix_slice &UncheckedSetInf(cimatrix_slice &cm,const cmatrix_slice &rm)
03229 #if(CXSC_INDEX_CHECK)
03230 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03231 #else
03232 throw();
03233 #endif
03234
03235 INLINE cimatrix &UncheckedSetSup(cimatrix &cm,const cmatrix &rm)
03236 #if(CXSC_INDEX_CHECK)
03237 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03238 #else
03239 throw();
03240 #endif
03241
03242 INLINE cimatrix_slice &UncheckedSetSup(cimatrix_slice &cm,const cmatrix &rm)
03243 #if(CXSC_INDEX_CHECK)
03244 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03245 #else
03246 throw();
03247 #endif
03248
03249 INLINE cimatrix &UncheckedSetSup(cimatrix &cm,const cmatrix_slice &rm)
03250 #if(CXSC_INDEX_CHECK)
03251 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03252 #else
03253 throw();
03254 #endif
03255
03256 INLINE cimatrix_slice &UncheckedSetSup(cimatrix_slice &cm,const cmatrix_slice &rm)
03257 #if(CXSC_INDEX_CHECK)
03258 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03259 #else
03260 throw();
03261 #endif
03262
03264 INLINE imatrix Im(const cimatrix &m) throw();
03266 INLINE imatrix Re(const cimatrix &m) throw();
03268 INLINE imatrix Im(const cimatrix_slice &m) throw();
03270 INLINE imatrix Re(const cimatrix_slice &m) throw();
03272 INLINE cimatrix &SetIm(cimatrix &cm,const imatrix &rm)
03273 #if(CXSC_INDEX_CHECK)
03274 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03275 #else
03276 throw();
03277 #endif
03278
03279 INLINE cimatrix_slice &SetIm(cimatrix_slice &cm,const imatrix &rm)
03280 #if(CXSC_INDEX_CHECK)
03281 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03282 #else
03283 throw();
03284 #endif
03285
03286 INLINE cimatrix &SetIm(cimatrix &cm,const imatrix_slice &rm)
03287 #if(CXSC_INDEX_CHECK)
03288 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03289 #else
03290 throw();
03291 #endif
03292
03293 INLINE cimatrix_slice &SetIm(cimatrix_slice &cm,const imatrix_slice &rm)
03294 #if(CXSC_INDEX_CHECK)
03295 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03296 #else
03297 throw();
03298 #endif
03299
03300 INLINE cimatrix &SetRe(cimatrix &cm,const imatrix &rm)
03301 #if(CXSC_INDEX_CHECK)
03302 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03303 #else
03304 throw();
03305 #endif
03306
03307 INLINE cimatrix_slice &SetRe(cimatrix_slice &cm,const imatrix &rm)
03308 #if(CXSC_INDEX_CHECK)
03309 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03310 #else
03311 throw();
03312 #endif
03313
03314 INLINE cimatrix &SetRe(cimatrix &cm,const imatrix_slice &rm)
03315 #if(CXSC_INDEX_CHECK)
03316 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03317 #else
03318 throw();
03319 #endif
03320
03321 INLINE cimatrix_slice &SetRe(cimatrix_slice &cm,const imatrix_slice &rm)
03322 #if(CXSC_INDEX_CHECK)
03323 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03324 #else
03325 throw();
03326 #endif
03327
03328
03329
03331 INLINE cimatrix operator *(const cinterval &c, const cimatrix &m) throw();
03333 INLINE cimatrix operator *(const cinterval &c, const cimatrix_slice &ms) throw();
03335 INLINE cimatrix operator *(const cimatrix &m,const cinterval &c) throw();
03337 INLINE cimatrix operator *(const cimatrix_slice &ms,const cinterval &c) throw();
03339 INLINE cimatrix &operator *=(cimatrix &m,const cinterval &c) throw();
03341 INLINE cimatrix operator /(const cimatrix &m,const cinterval &c) throw();
03343 INLINE cimatrix operator /(const cimatrix_slice &ms, const cinterval &c) throw();
03345 INLINE cimatrix &operator /=(cimatrix &m,const cinterval &c) throw();
03346
03347
03348
03350 INLINE cimatrix operator *(const real &c, const cimatrix &m) throw();
03352 INLINE cimatrix operator *(const real &c, const cimatrix_slice &ms) throw();
03354 INLINE cimatrix operator *(const cimatrix &m,const real &c) throw();
03356 INLINE cimatrix operator *(const cimatrix_slice &ms,const real &c) throw();
03358 INLINE cimatrix &operator *=(cimatrix &m,const real &c) throw();
03360 INLINE cimatrix operator /(const cimatrix &m,const real &c) throw();
03362 INLINE cimatrix operator /(const cimatrix_slice &ms, const real &c) throw();
03364 INLINE cimatrix &operator /=(cimatrix &m,const real &c) throw();
03365
03366
03368 INLINE cimatrix operator *(const cinterval &c, const rmatrix &m) throw();
03370 INLINE cimatrix operator *(const cinterval &c, const rmatrix_slice &ms) throw();
03372 INLINE cimatrix operator *(const rmatrix &m,const cinterval &c) throw();
03374 INLINE cimatrix operator *(const rmatrix_slice &ms,const cinterval &c) throw();
03376 INLINE cimatrix operator /(const rmatrix &m,const cinterval &c) throw();
03378 INLINE cimatrix operator /(const rmatrix_slice &ms, const cinterval &c) throw();
03379
03380
03381
03383 INLINE cimatrix operator *(const complex &c, const cimatrix &m) throw();
03385 INLINE cimatrix operator *(const complex &c, const cimatrix_slice &ms) throw();
03387 INLINE cimatrix operator *(const cimatrix &m,const complex &c) throw();
03389 INLINE cimatrix operator *(const cimatrix_slice &ms,const complex &c) throw();
03391 INLINE cimatrix &operator *=(cimatrix &m,const complex &c) throw();
03393 INLINE cimatrix operator /(const cimatrix &m,const complex &c) throw();
03395 INLINE cimatrix operator /(const cimatrix_slice &ms, const complex &c) throw();
03397 INLINE cimatrix &operator /=(cimatrix &m,const complex &c) throw();
03398
03399
03401 INLINE cimatrix operator *(const cinterval &c, const cmatrix &m) throw();
03403 INLINE cimatrix operator *(const cinterval &c, const cmatrix_slice &ms) throw();
03405 INLINE cimatrix operator *(const cmatrix &m,const cinterval &c) throw();
03407 INLINE cimatrix operator *(const cmatrix_slice &ms,const cinterval &c) throw();
03409 INLINE cimatrix operator /(const cmatrix &m,const cinterval &c) throw();
03411 INLINE cimatrix operator /(const cmatrix_slice &ms, const cinterval &c) throw();
03412
03413
03414
03416 INLINE cimatrix operator *(const interval &c, const cimatrix &m) throw();
03418 INLINE cimatrix operator *(const interval &c, const cimatrix_slice &ms) throw();
03420 INLINE cimatrix operator *(const cimatrix &m,const interval &c) throw();
03422 INLINE cimatrix operator *(const cimatrix_slice &ms,const interval &c) throw();
03424 INLINE cimatrix &operator *=(cimatrix &m,const interval &c) throw();
03426 INLINE cimatrix operator /(const cimatrix &m,const interval &c) throw();
03428 INLINE cimatrix operator /(const cimatrix_slice &ms, const interval &c) throw();
03430 INLINE cimatrix &operator /=(cimatrix &m,const interval &c) throw();
03431
03432
03434 INLINE cimatrix operator *(const cinterval &c, const imatrix &m) throw();
03436 INLINE cimatrix operator *(const cinterval &c, const imatrix_slice &ms) throw();
03438 INLINE cimatrix operator *(const imatrix &m,const cinterval &c) throw();
03440 INLINE cimatrix operator *(const imatrix_slice &ms,const cinterval &c) throw();
03442 INLINE cimatrix operator /(const imatrix &m,const cinterval &c) throw();
03444 INLINE cimatrix operator /(const imatrix_slice &ms, const cinterval &c) throw();
03445
03446
03447
03448
03449
03451 INLINE civector operator *(const cimatrix &m,const civector &v)
03452 #if(CXSC_INDEX_CHECK)
03453 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03454 #else
03455 throw();
03456 #endif
03457
03458 INLINE civector operator *(const cimatrix_slice &ms,const civector &v)
03459 #if(CXSC_INDEX_CHECK)
03460 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03461 #else
03462 throw();
03463 #endif
03464
03465 INLINE civector operator *(const civector &v,const cimatrix &m)
03466 #if(CXSC_INDEX_CHECK)
03467 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03468 #else
03469 throw();
03470 #endif
03471
03472 INLINE civector operator *(const civector &v,const cimatrix_slice &ms)
03473 #if(CXSC_INDEX_CHECK)
03474 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03475 #else
03476 throw();
03477 #endif
03478
03479 INLINE civector &operator *=(civector &v,const cimatrix &m)
03480 #if(CXSC_INDEX_CHECK)
03481 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03482 #else
03483 throw();
03484 #endif
03485
03486 INLINE civector &operator *=(civector &v,const cimatrix_slice &ms)
03487 #if(CXSC_INDEX_CHECK)
03488 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03489 #else
03490 throw();
03491 #endif
03492
03494 INLINE civector operator *(const civector_slice &v,const cimatrix &m)
03495 #if(CXSC_INDEX_CHECK)
03496 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03497 #else
03498 throw();
03499 #endif
03500
03501 INLINE civector operator *(const civector_slice &v,const cimatrix_slice &m)
03502 #if(CXSC_INDEX_CHECK)
03503 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03504 #else
03505 throw();
03506 #endif
03507
03508
03509
03511 INLINE civector operator *(const rvector &v,const cimatrix &m)
03512 #if(CXSC_INDEX_CHECK)
03513 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03514 #else
03515 throw();
03516 #endif
03517
03518 INLINE civector operator *(const rvector &v,const cimatrix_slice &ms)
03519 #if(CXSC_INDEX_CHECK)
03520 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03521 #else
03522 throw();
03523 #endif
03524
03525 INLINE civector operator *(const rvector_slice &v,const cimatrix &m)
03526 #if(CXSC_INDEX_CHECK)
03527 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03528 #else
03529 throw();
03530 #endif
03531
03533 INLINE civector operator *(const cimatrix &m,const rvector &v)
03534 #if(CXSC_INDEX_CHECK)
03535 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03536 #else
03537 throw();
03538 #endif
03539
03540 INLINE civector operator *(const cimatrix_slice &ms,const rvector &v)
03541 #if(CXSC_INDEX_CHECK)
03542 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03543 #else
03544 throw();
03545 #endif
03546
03547
03548
03550 INLINE civector operator *(const cvector &v,const cimatrix &m)
03551 #if(CXSC_INDEX_CHECK)
03552 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03553 #else
03554 throw();
03555 #endif
03556
03557 INLINE civector operator *(const cvector &v,const cimatrix_slice &ms)
03558 #if(CXSC_INDEX_CHECK)
03559 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03560 #else
03561 throw();
03562 #endif
03563
03564 INLINE civector operator *(const cvector_slice &v,const cimatrix &m)
03565 #if(CXSC_INDEX_CHECK)
03566 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03567 #else
03568 throw();
03569 #endif
03570
03572 INLINE civector operator *(const cimatrix &m,const cvector &v)
03573 #if(CXSC_INDEX_CHECK)
03574 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03575 #else
03576 throw();
03577 #endif
03578
03579 INLINE civector operator *(const cimatrix_slice &ms,const cvector &v)
03580 #if(CXSC_INDEX_CHECK)
03581 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03582 #else
03583 throw();
03584 #endif
03585
03586
03587
03589 INLINE civector operator *(const ivector &v,const cimatrix &m)
03590 #if(CXSC_INDEX_CHECK)
03591 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03592 #else
03593 throw();
03594 #endif
03595
03596 INLINE civector operator *(const ivector &v,const cimatrix_slice &ms)
03597 #if(CXSC_INDEX_CHECK)
03598 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03599 #else
03600 throw();
03601 #endif
03602
03603 INLINE civector operator *(const ivector_slice &v,const cimatrix &m)
03604 #if(CXSC_INDEX_CHECK)
03605 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03606 #else
03607 throw();
03608 #endif
03609
03611 INLINE civector operator *(const cimatrix &m,const ivector &v)
03612 #if(CXSC_INDEX_CHECK)
03613 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03614 #else
03615 throw();
03616 #endif
03617
03618 INLINE civector operator *(const cimatrix_slice &ms,const ivector &v)
03619 #if(CXSC_INDEX_CHECK)
03620 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03621 #else
03622 throw();
03623 #endif
03624
03625
03626
03627
03629 INLINE const cimatrix &operator +(const cimatrix &m1) throw();
03631 INLINE cimatrix operator +(const cimatrix_slice &ms) throw();
03633 INLINE cimatrix operator +(const cimatrix &m1,const cimatrix &m2)
03634 #if(CXSC_INDEX_CHECK)
03635 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03636 #else
03637 throw();
03638 #endif
03639
03640 INLINE cimatrix operator +(const cimatrix &m,const cimatrix_slice &ms)
03641 #if(CXSC_INDEX_CHECK)
03642 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03643 #else
03644 throw();
03645 #endif
03646
03647 INLINE cimatrix operator +(const cimatrix_slice &ms,const cimatrix &m)
03648 #if(CXSC_INDEX_CHECK)
03649 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03650 #else
03651 throw();
03652 #endif
03653
03654 INLINE cimatrix operator +(const cimatrix_slice &m1,const cimatrix_slice &m2)
03655 #if(CXSC_INDEX_CHECK)
03656 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03657 #else
03658 throw();
03659 #endif
03660
03661 INLINE cimatrix &operator +=(cimatrix &m1,const cimatrix &m2)
03662 #if(CXSC_INDEX_CHECK)
03663 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03664 #else
03665 throw();
03666 #endif
03667
03668 INLINE cimatrix &operator +=(cimatrix &m1,const cimatrix_slice &ms)
03669 #if(CXSC_INDEX_CHECK)
03670 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03671 #else
03672 throw();
03673 #endif
03674
03676 INLINE cimatrix operator -(const cimatrix &m) throw();
03678 INLINE cimatrix operator -(const cimatrix_slice &ms) throw();
03680 INLINE cimatrix operator -(const cimatrix &m1,const cimatrix &m2)
03681 #if(CXSC_INDEX_CHECK)
03682 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03683 #else
03684 throw();
03685 #endif
03686
03687 INLINE cimatrix operator -(const cimatrix &m,const cimatrix_slice &ms)
03688 #if(CXSC_INDEX_CHECK)
03689 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03690 #else
03691 throw();
03692 #endif
03693
03694 INLINE cimatrix operator -(const cimatrix_slice &ms,const cimatrix &m)
03695 #if(CXSC_INDEX_CHECK)
03696 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03697 #else
03698 throw();
03699 #endif
03700
03701 INLINE cimatrix operator -(const cimatrix_slice &ms1,const cimatrix_slice &ms2)
03702 #if(CXSC_INDEX_CHECK)
03703 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03704 #else
03705 throw();
03706 #endif
03707
03708 INLINE cimatrix &operator -=(cimatrix &m1,const cimatrix &m2)
03709 #if(CXSC_INDEX_CHECK)
03710 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03711 #else
03712 throw();
03713 #endif
03714
03715 INLINE cimatrix &operator -=(cimatrix &m1,const cimatrix_slice &ms)
03716 #if(CXSC_INDEX_CHECK)
03717 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03718 #else
03719 throw();
03720 #endif
03721
03723 INLINE cimatrix operator *(const cimatrix &m1, const cimatrix &m2)
03724 #if(CXSC_INDEX_CHECK)
03725 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03726 #else
03727 throw();
03728 #endif
03729
03730 INLINE cimatrix operator *(const cimatrix &m1, const cimatrix_slice &ms)
03731 #if(CXSC_INDEX_CHECK)
03732 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03733 #else
03734 throw();
03735 #endif
03736
03737 INLINE cimatrix operator *(const cimatrix_slice &ms, const cimatrix &m1)
03738 #if(CXSC_INDEX_CHECK)
03739 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03740 #else
03741 throw();
03742 #endif
03743
03744 INLINE cimatrix operator *(const cimatrix_slice &ms1, const cimatrix_slice &ms2)
03745 #if(CXSC_INDEX_CHECK)
03746 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03747 #else
03748 throw();
03749 #endif
03750
03751 INLINE cimatrix &operator *=(cimatrix &m1,const cimatrix &m2)
03752 #if(CXSC_INDEX_CHECK)
03753 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03754 #else
03755 throw();
03756 #endif
03757
03758 INLINE cimatrix &operator *=(cimatrix &m1,const cimatrix_slice &ms)
03759 #if(CXSC_INDEX_CHECK)
03760 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03761 #else
03762 throw();
03763 #endif
03764
03765
03767 INLINE cimatrix operator |(const cimatrix &m1,const cimatrix &m2)
03768 #if(CXSC_INDEX_CHECK)
03769 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03770 #else
03771 throw();
03772 #endif
03773
03774 INLINE cimatrix operator |(const cimatrix &m,const cimatrix_slice &ms)
03775 #if(CXSC_INDEX_CHECK)
03776 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03777 #else
03778 throw();
03779 #endif
03780
03781 INLINE cimatrix operator |(const cimatrix_slice &ms,const cimatrix &m)
03782 #if(CXSC_INDEX_CHECK)
03783 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03784 #else
03785 throw();
03786 #endif
03787
03788 INLINE cimatrix operator |(const cimatrix_slice &m1,const cimatrix_slice &m2)
03789 #if(CXSC_INDEX_CHECK)
03790 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03791 #else
03792 throw();
03793 #endif
03794
03795 INLINE cimatrix &operator |=(cimatrix &m1,const cimatrix &m2)
03796 #if(CXSC_INDEX_CHECK)
03797 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03798 #else
03799 throw();
03800 #endif
03801
03802 INLINE cimatrix &operator |=(cimatrix &m1,const cimatrix_slice &ms)
03803 #if(CXSC_INDEX_CHECK)
03804 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03805 #else
03806 throw();
03807 #endif
03808
03810 INLINE cimatrix operator &(const cimatrix &m1,const cimatrix &m2)
03811 #if(CXSC_INDEX_CHECK)
03812 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03813 #else
03814 throw();
03815 #endif
03816
03817 INLINE cimatrix operator &(const cimatrix &m,const cimatrix_slice &ms)
03818 #if(CXSC_INDEX_CHECK)
03819 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03820 #else
03821 throw();
03822 #endif
03823
03824 INLINE cimatrix operator &(const cimatrix_slice &ms,const cimatrix &m)
03825 #if(CXSC_INDEX_CHECK)
03826 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03827 #else
03828 throw();
03829 #endif
03830
03831 INLINE cimatrix operator &(const cimatrix_slice &m1,const cimatrix_slice &m2)
03832 #if(CXSC_INDEX_CHECK)
03833 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03834 #else
03835 throw();
03836 #endif
03837
03838 INLINE cimatrix &operator &=(cimatrix &m1,const cimatrix &m2)
03839 #if(CXSC_INDEX_CHECK)
03840 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03841 #else
03842 throw();
03843 #endif
03844
03845 INLINE cimatrix &operator &=(cimatrix &m1,const cimatrix_slice &ms)
03846 #if(CXSC_INDEX_CHECK)
03847 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03848 #else
03849 throw();
03850 #endif
03851
03852
03854 INLINE cimatrix operator +(const rmatrix &m1,const cimatrix &m2)
03855 #if(CXSC_INDEX_CHECK)
03856 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03857 #else
03858 throw();
03859 #endif
03860
03861 INLINE cimatrix operator +(const cimatrix &m1,const rmatrix &m2)
03862 #if(CXSC_INDEX_CHECK)
03863 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03864 #else
03865 throw();
03866 #endif
03867
03868 INLINE cimatrix operator +(const rmatrix &m,const cimatrix_slice &ms)
03869 #if(CXSC_INDEX_CHECK)
03870 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03871 #else
03872 throw();
03873 #endif
03874
03875 INLINE cimatrix operator +(const cimatrix &m,const rmatrix_slice &ms)
03876 #if(CXSC_INDEX_CHECK)
03877 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03878 #else
03879 throw();
03880 #endif
03881
03882 INLINE cimatrix operator +(const rmatrix_slice &ms,const cimatrix &m)
03883 #if(CXSC_INDEX_CHECK)
03884 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03885 #else
03886 throw();
03887 #endif
03888
03889 INLINE cimatrix operator +(const cimatrix_slice &ms,const rmatrix &m)
03890 #if(CXSC_INDEX_CHECK)
03891 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03892 #else
03893 throw();
03894 #endif
03895
03896 INLINE cimatrix operator +(const rmatrix_slice &m1,const cimatrix_slice &m2)
03897 #if(CXSC_INDEX_CHECK)
03898 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03899 #else
03900 throw();
03901 #endif
03902
03903 INLINE cimatrix operator +(const cimatrix_slice &m1,const rmatrix_slice &m2)
03904 #if(CXSC_INDEX_CHECK)
03905 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03906 #else
03907 throw();
03908 #endif
03909
03910 INLINE cimatrix &operator +=(cimatrix &m1,const rmatrix &m2)
03911 #if(CXSC_INDEX_CHECK)
03912 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03913 #else
03914 throw();
03915 #endif
03916
03917 INLINE cimatrix &operator +=(cimatrix &m1,const rmatrix_slice &ms)
03918 #if(CXSC_INDEX_CHECK)
03919 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03920 #else
03921 throw();
03922 #endif
03923
03925 INLINE cimatrix operator -(const rmatrix &m1,const cimatrix &m2)
03926 #if(CXSC_INDEX_CHECK)
03927 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03928 #else
03929 throw();
03930 #endif
03931
03932 INLINE cimatrix operator -(const cimatrix &m1,const rmatrix &m2)
03933 #if(CXSC_INDEX_CHECK)
03934 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03935 #else
03936 throw();
03937 #endif
03938
03939 INLINE cimatrix operator -(const rmatrix &m,const cimatrix_slice &ms)
03940 #if(CXSC_INDEX_CHECK)
03941 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03942 #else
03943 throw();
03944 #endif
03945
03946 INLINE cimatrix operator -(const cimatrix &m,const rmatrix_slice &ms)
03947 #if(CXSC_INDEX_CHECK)
03948 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03949 #else
03950 throw();
03951 #endif
03952
03953 INLINE cimatrix operator -(const rmatrix_slice &ms,const cimatrix &m)
03954 #if(CXSC_INDEX_CHECK)
03955 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03956 #else
03957 throw();
03958 #endif
03959
03960 INLINE cimatrix operator -(const cimatrix_slice &ms,const rmatrix &m)
03961 #if(CXSC_INDEX_CHECK)
03962 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03963 #else
03964 throw();
03965 #endif
03966
03967 INLINE cimatrix operator -(const rmatrix_slice &ms1,const cimatrix_slice &ms2)
03968 #if(CXSC_INDEX_CHECK)
03969 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03970 #else
03971 throw();
03972 #endif
03973
03974 INLINE cimatrix operator -(const cimatrix_slice &ms1,const rmatrix_slice &ms2)
03975 #if(CXSC_INDEX_CHECK)
03976 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03977 #else
03978 throw();
03979 #endif
03980
03981 INLINE cimatrix &operator -=(cimatrix &m1,const rmatrix &m2)
03982 #if(CXSC_INDEX_CHECK)
03983 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03984 #else
03985 throw();
03986 #endif
03987
03988 INLINE cimatrix &operator -=(cimatrix &m1,const rmatrix_slice &ms)
03989 #if(CXSC_INDEX_CHECK)
03990 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03991 #else
03992 throw();
03993 #endif
03994
03996 INLINE cimatrix operator *(const rmatrix &m1, const cimatrix &m2)
03997 #if(CXSC_INDEX_CHECK)
03998 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
03999 #else
04000 throw();
04001 #endif
04002
04003 INLINE cimatrix operator *(const cimatrix &m1, const rmatrix &m2)
04004 #if(CXSC_INDEX_CHECK)
04005 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04006 #else
04007 throw();
04008 #endif
04009
04010 INLINE cimatrix operator *(const rmatrix &m1, const cimatrix_slice &ms)
04011 #if(CXSC_INDEX_CHECK)
04012 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04013 #else
04014 throw();
04015 #endif
04016
04017 INLINE cimatrix operator *(const cimatrix &m1, const rmatrix_slice &ms)
04018 #if(CXSC_INDEX_CHECK)
04019 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04020 #else
04021 throw();
04022 #endif
04023
04024 INLINE cimatrix operator *(const rmatrix_slice &ms, const cimatrix &m1)
04025 #if(CXSC_INDEX_CHECK)
04026 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04027 #else
04028 throw();
04029 #endif
04030
04031 INLINE cimatrix operator *(const cimatrix_slice &ms, const rmatrix &m1)
04032 #if(CXSC_INDEX_CHECK)
04033 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04034 #else
04035 throw();
04036 #endif
04037
04038 INLINE cimatrix operator *(const rmatrix_slice &ms1, const cimatrix_slice &ms2)
04039 #if(CXSC_INDEX_CHECK)
04040 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04041 #else
04042 throw();
04043 #endif
04044
04045 INLINE cimatrix operator *(const cimatrix_slice &ms1, const rmatrix_slice &ms2)
04046 #if(CXSC_INDEX_CHECK)
04047 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04048 #else
04049 throw();
04050 #endif
04051
04052 INLINE cimatrix &operator *=(cimatrix &m1,const rmatrix &m2)
04053 #if(CXSC_INDEX_CHECK)
04054 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04055 #else
04056 throw();
04057 #endif
04058
04059 INLINE cimatrix &operator *=(cimatrix &m1,const rmatrix_slice &ms)
04060 #if(CXSC_INDEX_CHECK)
04061 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04062 #else
04063 throw();
04064 #endif
04065
04067 INLINE cimatrix operator |(const rmatrix &m1,const cimatrix &m2)
04068 #if(CXSC_INDEX_CHECK)
04069 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04070 #else
04071 throw();
04072 #endif
04073
04074 INLINE cimatrix operator |(const cimatrix &m1,const rmatrix &m2)
04075 #if(CXSC_INDEX_CHECK)
04076 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04077 #else
04078 throw();
04079 #endif
04080
04081 INLINE cimatrix operator |(const rmatrix &m,const cimatrix_slice &ms)
04082 #if(CXSC_INDEX_CHECK)
04083 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04084 #else
04085 throw();
04086 #endif
04087
04088 INLINE cimatrix operator |(const cimatrix &m,const rmatrix_slice &ms)
04089 #if(CXSC_INDEX_CHECK)
04090 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04091 #else
04092 throw();
04093 #endif
04094
04095 INLINE cimatrix operator |(const rmatrix_slice &ms,const cimatrix &m)
04096 #if(CXSC_INDEX_CHECK)
04097 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04098 #else
04099 throw();
04100 #endif
04101
04102 INLINE cimatrix operator |(const cimatrix_slice &ms,const rmatrix &m)
04103 #if(CXSC_INDEX_CHECK)
04104 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04105 #else
04106 throw();
04107 #endif
04108
04109 INLINE cimatrix operator |(const rmatrix_slice &m1,const cimatrix_slice &m2)
04110 #if(CXSC_INDEX_CHECK)
04111 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04112 #else
04113 throw();
04114 #endif
04115
04116 INLINE cimatrix operator |(const cimatrix_slice &m1,const rmatrix_slice &m2)
04117 #if(CXSC_INDEX_CHECK)
04118 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04119 #else
04120 throw();
04121 #endif
04122
04123 INLINE cimatrix &operator |=(cimatrix &m1,const rmatrix &m2)
04124 #if(CXSC_INDEX_CHECK)
04125 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04126 #else
04127 throw();
04128 #endif
04129
04130 INLINE cimatrix &operator |=(cimatrix &m1,const rmatrix_slice &ms)
04131 #if(CXSC_INDEX_CHECK)
04132 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04133 #else
04134 throw();
04135 #endif
04136
04138 INLINE cimatrix operator &(const rmatrix &m1,const cimatrix &m2)
04139 #if(CXSC_INDEX_CHECK)
04140 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04141 #else
04142 throw();
04143 #endif
04144
04145 INLINE cimatrix operator &(const cimatrix &m1,const rmatrix &m2)
04146 #if(CXSC_INDEX_CHECK)
04147 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04148 #else
04149 throw();
04150 #endif
04151
04152 INLINE cimatrix operator &(const rmatrix &m,const cimatrix_slice &ms)
04153 #if(CXSC_INDEX_CHECK)
04154 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04155 #else
04156 throw();
04157 #endif
04158
04159 INLINE cimatrix operator &(const cimatrix &m,const rmatrix_slice &ms)
04160 #if(CXSC_INDEX_CHECK)
04161 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04162 #else
04163 throw();
04164 #endif
04165
04166 INLINE cimatrix operator &(const rmatrix_slice &ms,const cimatrix &m)
04167 #if(CXSC_INDEX_CHECK)
04168 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04169 #else
04170 throw();
04171 #endif
04172
04173 INLINE cimatrix operator &(const cimatrix_slice &ms,const rmatrix &m)
04174 #if(CXSC_INDEX_CHECK)
04175 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04176 #else
04177 throw();
04178 #endif
04179
04180 INLINE cimatrix operator &(const rmatrix_slice &m1,const cimatrix_slice &m2)
04181 #if(CXSC_INDEX_CHECK)
04182 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04183 #else
04184 throw();
04185 #endif
04186
04187 INLINE cimatrix operator &(const cimatrix_slice &m1,const rmatrix_slice &m2)
04188 #if(CXSC_INDEX_CHECK)
04189 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04190 #else
04191 throw();
04192 #endif
04193
04194 INLINE cimatrix &operator &=(cimatrix &m1,const rmatrix &m2)
04195 #if(CXSC_INDEX_CHECK)
04196 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04197 #else
04198 throw();
04199 #endif
04200
04201 INLINE cimatrix &operator &=(cimatrix &m1,const rmatrix_slice &ms)
04202 #if(CXSC_INDEX_CHECK)
04203 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04204 #else
04205 throw();
04206 #endif
04207
04208
04210 INLINE cimatrix operator +(const cmatrix &m1,const cimatrix &m2)
04211 #if(CXSC_INDEX_CHECK)
04212 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04213 #else
04214 throw();
04215 #endif
04216
04217 INLINE cimatrix operator +(const cimatrix &m1,const cmatrix &m2)
04218 #if(CXSC_INDEX_CHECK)
04219 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04220 #else
04221 throw();
04222 #endif
04223
04224 INLINE cimatrix operator +(const cmatrix &m,const cimatrix_slice &ms)
04225 #if(CXSC_INDEX_CHECK)
04226 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04227 #else
04228 throw();
04229 #endif
04230
04231 INLINE cimatrix operator +(const cimatrix &m,const cmatrix_slice &ms)
04232 #if(CXSC_INDEX_CHECK)
04233 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04234 #else
04235 throw();
04236 #endif
04237
04238 INLINE cimatrix operator +(const cmatrix_slice &ms,const cimatrix &m)
04239 #if(CXSC_INDEX_CHECK)
04240 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04241 #else
04242 throw();
04243 #endif
04244
04245 INLINE cimatrix operator +(const cimatrix_slice &ms,const cmatrix &m)
04246 #if(CXSC_INDEX_CHECK)
04247 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04248 #else
04249 throw();
04250 #endif
04251
04252 INLINE cimatrix operator +(const cmatrix_slice &m1,const cimatrix_slice &m2)
04253 #if(CXSC_INDEX_CHECK)
04254 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04255 #else
04256 throw();
04257 #endif
04258
04259 INLINE cimatrix operator +(const cimatrix_slice &m1,const cmatrix_slice &m2)
04260 #if(CXSC_INDEX_CHECK)
04261 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04262 #else
04263 throw();
04264 #endif
04265
04266 INLINE cimatrix &operator +=(cimatrix &m1,const cmatrix &m2)
04267 #if(CXSC_INDEX_CHECK)
04268 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04269 #else
04270 throw();
04271 #endif
04272
04273 INLINE cimatrix &operator +=(cimatrix &m1,const cmatrix_slice &ms)
04274 #if(CXSC_INDEX_CHECK)
04275 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04276 #else
04277 throw();
04278 #endif
04279
04281 INLINE cimatrix operator -(const cmatrix &m1,const cimatrix &m2)
04282 #if(CXSC_INDEX_CHECK)
04283 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04284 #else
04285 throw();
04286 #endif
04287
04288 INLINE cimatrix operator -(const cimatrix &m1,const cmatrix &m2)
04289 #if(CXSC_INDEX_CHECK)
04290 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04291 #else
04292 throw();
04293 #endif
04294
04295 INLINE cimatrix operator -(const cmatrix &m,const cimatrix_slice &ms)
04296 #if(CXSC_INDEX_CHECK)
04297 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04298 #else
04299 throw();
04300 #endif
04301
04302 INLINE cimatrix operator -(const cimatrix &m,const cmatrix_slice &ms)
04303 #if(CXSC_INDEX_CHECK)
04304 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04305 #else
04306 throw();
04307 #endif
04308
04309 INLINE cimatrix operator -(const cmatrix_slice &ms,const cimatrix &m)
04310 #if(CXSC_INDEX_CHECK)
04311 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04312 #else
04313 throw();
04314 #endif
04315
04316 INLINE cimatrix operator -(const cimatrix_slice &ms,const cmatrix &m)
04317 #if(CXSC_INDEX_CHECK)
04318 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04319 #else
04320 throw();
04321 #endif
04322
04323 INLINE cimatrix operator -(const cmatrix_slice &ms1,const cimatrix_slice &ms2)
04324 #if(CXSC_INDEX_CHECK)
04325 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04326 #else
04327 throw();
04328 #endif
04329
04330 INLINE cimatrix operator -(const cimatrix_slice &ms1,const cmatrix_slice &ms2)
04331 #if(CXSC_INDEX_CHECK)
04332 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04333 #else
04334 throw();
04335 #endif
04336
04337 INLINE cimatrix &operator -=(cimatrix &m1,const cmatrix &m2)
04338 #if(CXSC_INDEX_CHECK)
04339 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04340 #else
04341 throw();
04342 #endif
04343
04344 INLINE cimatrix &operator -=(cimatrix &m1,const cmatrix_slice &ms)
04345 #if(CXSC_INDEX_CHECK)
04346 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04347 #else
04348 throw();
04349 #endif
04350
04352 INLINE cimatrix operator *(const cmatrix &m1, const cimatrix &m2)
04353 #if(CXSC_INDEX_CHECK)
04354 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04355 #else
04356 throw();
04357 #endif
04358
04359 INLINE cimatrix operator *(const cimatrix &m1, const cmatrix &m2)
04360 #if(CXSC_INDEX_CHECK)
04361 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04362 #else
04363 throw();
04364 #endif
04365
04366 INLINE cimatrix operator *(const cmatrix &m1, const cimatrix_slice &ms)
04367 #if(CXSC_INDEX_CHECK)
04368 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04369 #else
04370 throw();
04371 #endif
04372
04373 INLINE cimatrix operator *(const cimatrix &m1, const cmatrix_slice &ms)
04374 #if(CXSC_INDEX_CHECK)
04375 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04376 #else
04377 throw();
04378 #endif
04379
04380 INLINE cimatrix operator *(const cmatrix_slice &ms, const cimatrix &m1)
04381 #if(CXSC_INDEX_CHECK)
04382 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04383 #else
04384 throw();
04385 #endif
04386
04387 INLINE cimatrix operator *(const cimatrix_slice &ms, const cmatrix &m1)
04388 #if(CXSC_INDEX_CHECK)
04389 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04390 #else
04391 throw();
04392 #endif
04393
04394 INLINE cimatrix operator *(const cmatrix_slice &ms1, const cimatrix_slice &ms2)
04395 #if(CXSC_INDEX_CHECK)
04396 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04397 #else
04398 throw();
04399 #endif
04400
04401 INLINE cimatrix operator *(const cimatrix_slice &ms1, const cmatrix_slice &ms2)
04402 #if(CXSC_INDEX_CHECK)
04403 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04404 #else
04405 throw();
04406 #endif
04407
04408 INLINE cimatrix &operator *=(cimatrix &m1,const cmatrix &m2)
04409 #if(CXSC_INDEX_CHECK)
04410 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04411 #else
04412 throw();
04413 #endif
04414
04415 INLINE cimatrix &operator *=(cimatrix &m1,const cmatrix_slice &ms)
04416 #if(CXSC_INDEX_CHECK)
04417 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04418 #else
04419 throw();
04420 #endif
04421
04423 INLINE cimatrix operator |(const cmatrix &m1,const cimatrix &m2)
04424 #if(CXSC_INDEX_CHECK)
04425 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04426 #else
04427 throw();
04428 #endif
04429
04430 INLINE cimatrix operator |(const cimatrix &m1,const cmatrix &m2)
04431 #if(CXSC_INDEX_CHECK)
04432 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04433 #else
04434 throw();
04435 #endif
04436
04437 INLINE cimatrix operator |(const cmatrix &m,const cimatrix_slice &ms)
04438 #if(CXSC_INDEX_CHECK)
04439 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04440 #else
04441 throw();
04442 #endif
04443
04444 INLINE cimatrix operator |(const cimatrix &m,const cmatrix_slice &ms)
04445 #if(CXSC_INDEX_CHECK)
04446 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04447 #else
04448 throw();
04449 #endif
04450
04451 INLINE cimatrix operator |(const cmatrix_slice &ms,const cimatrix &m)
04452 #if(CXSC_INDEX_CHECK)
04453 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04454 #else
04455 throw();
04456 #endif
04457
04458 INLINE cimatrix operator |(const cimatrix_slice &ms,const cmatrix &m)
04459 #if(CXSC_INDEX_CHECK)
04460 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04461 #else
04462 throw();
04463 #endif
04464
04465 INLINE cimatrix operator |(const cmatrix_slice &m1,const cimatrix_slice &m2)
04466 #if(CXSC_INDEX_CHECK)
04467 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04468 #else
04469 throw();
04470 #endif
04471
04472 INLINE cimatrix operator |(const cimatrix_slice &m1,const cmatrix_slice &m2)
04473 #if(CXSC_INDEX_CHECK)
04474 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04475 #else
04476 throw();
04477 #endif
04478
04479 INLINE cimatrix &operator |=(cimatrix &m1,const cmatrix &m2)
04480 #if(CXSC_INDEX_CHECK)
04481 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04482 #else
04483 throw();
04484 #endif
04485
04486 INLINE cimatrix &operator |=(cimatrix &m1,const cmatrix_slice &ms)
04487 #if(CXSC_INDEX_CHECK)
04488 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04489 #else
04490 throw();
04491 #endif
04492
04494 INLINE cimatrix operator &(const cmatrix &m1,const cimatrix &m2)
04495 #if(CXSC_INDEX_CHECK)
04496 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04497 #else
04498 throw();
04499 #endif
04500
04501 INLINE cimatrix operator &(const cimatrix &m1,const cmatrix &m2)
04502 #if(CXSC_INDEX_CHECK)
04503 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04504 #else
04505 throw();
04506 #endif
04507
04508 INLINE cimatrix operator &(const cmatrix &m,const cimatrix_slice &ms)
04509 #if(CXSC_INDEX_CHECK)
04510 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04511 #else
04512 throw();
04513 #endif
04514
04515 INLINE cimatrix operator &(const cimatrix &m,const cmatrix_slice &ms)
04516 #if(CXSC_INDEX_CHECK)
04517 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04518 #else
04519 throw();
04520 #endif
04521
04522 INLINE cimatrix operator &(const cmatrix_slice &ms,const cimatrix &m)
04523 #if(CXSC_INDEX_CHECK)
04524 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04525 #else
04526 throw();
04527 #endif
04528
04529 INLINE cimatrix operator &(const cimatrix_slice &ms,const cmatrix &m)
04530 #if(CXSC_INDEX_CHECK)
04531 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04532 #else
04533 throw();
04534 #endif
04535
04536 INLINE cimatrix operator &(const cmatrix_slice &m1,const cimatrix_slice &m2)
04537 #if(CXSC_INDEX_CHECK)
04538 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04539 #else
04540 throw();
04541 #endif
04542
04543 INLINE cimatrix operator &(const cimatrix_slice &m1,const cmatrix_slice &m2)
04544 #if(CXSC_INDEX_CHECK)
04545 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04546 #else
04547 throw();
04548 #endif
04549
04550 INLINE cimatrix &operator &=(cimatrix &m1,const cmatrix &m2)
04551 #if(CXSC_INDEX_CHECK)
04552 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04553 #else
04554 throw();
04555 #endif
04556
04557 INLINE cimatrix &operator &=(cimatrix &m1,const cmatrix_slice &ms)
04558 #if(CXSC_INDEX_CHECK)
04559 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04560 #else
04561 throw();
04562 #endif
04563
04564
04566 INLINE cimatrix operator +(const imatrix &m1,const cimatrix &m2)
04567 #if(CXSC_INDEX_CHECK)
04568 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04569 #else
04570 throw();
04571 #endif
04572
04573 INLINE cimatrix operator +(const cimatrix &m1,const imatrix &m2)
04574 #if(CXSC_INDEX_CHECK)
04575 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04576 #else
04577 throw();
04578 #endif
04579
04580 INLINE cimatrix operator +(const imatrix &m,const cimatrix_slice &ms)
04581 #if(CXSC_INDEX_CHECK)
04582 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04583 #else
04584 throw();
04585 #endif
04586
04587 INLINE cimatrix operator +(const cimatrix &m,const imatrix_slice &ms)
04588 #if(CXSC_INDEX_CHECK)
04589 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04590 #else
04591 throw();
04592 #endif
04593
04594 INLINE cimatrix operator +(const imatrix_slice &ms,const cimatrix &m)
04595 #if(CXSC_INDEX_CHECK)
04596 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04597 #else
04598 throw();
04599 #endif
04600
04601 INLINE cimatrix operator +(const cimatrix_slice &ms,const imatrix &m)
04602 #if(CXSC_INDEX_CHECK)
04603 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04604 #else
04605 throw();
04606 #endif
04607
04608 INLINE cimatrix operator +(const imatrix_slice &m1,const cimatrix_slice &m2)
04609 #if(CXSC_INDEX_CHECK)
04610 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04611 #else
04612 throw();
04613 #endif
04614
04615 INLINE cimatrix operator +(const cimatrix_slice &m1,const imatrix_slice &m2)
04616 #if(CXSC_INDEX_CHECK)
04617 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04618 #else
04619 throw();
04620 #endif
04621
04622 INLINE cimatrix &operator +=(cimatrix &m1,const imatrix &m2)
04623 #if(CXSC_INDEX_CHECK)
04624 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04625 #else
04626 throw();
04627 #endif
04628
04629 INLINE cimatrix &operator +=(cimatrix &m1,const imatrix_slice &ms)
04630 #if(CXSC_INDEX_CHECK)
04631 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04632 #else
04633 throw();
04634 #endif
04635
04637 INLINE cimatrix operator -(const imatrix &m1,const cimatrix &m2)
04638 #if(CXSC_INDEX_CHECK)
04639 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04640 #else
04641 throw();
04642 #endif
04643
04644 INLINE cimatrix operator -(const cimatrix &m1,const imatrix &m2)
04645 #if(CXSC_INDEX_CHECK)
04646 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04647 #else
04648 throw();
04649 #endif
04650
04651 INLINE cimatrix operator -(const imatrix &m,const cimatrix_slice &ms)
04652 #if(CXSC_INDEX_CHECK)
04653 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04654 #else
04655 throw();
04656 #endif
04657
04658 INLINE cimatrix operator -(const cimatrix &m,const imatrix_slice &ms)
04659 #if(CXSC_INDEX_CHECK)
04660 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04661 #else
04662 throw();
04663 #endif
04664
04665 INLINE cimatrix operator -(const imatrix_slice &ms,const cimatrix &m)
04666 #if(CXSC_INDEX_CHECK)
04667 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04668 #else
04669 throw();
04670 #endif
04671
04672 INLINE cimatrix operator -(const cimatrix_slice &ms,const imatrix &m)
04673 #if(CXSC_INDEX_CHECK)
04674 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04675 #else
04676 throw();
04677 #endif
04678
04679 INLINE cimatrix operator -(const imatrix_slice &ms1,const cimatrix_slice &ms2)
04680 #if(CXSC_INDEX_CHECK)
04681 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04682 #else
04683 throw();
04684 #endif
04685
04686 INLINE cimatrix operator -(const cimatrix_slice &ms1,const imatrix_slice &ms2)
04687 #if(CXSC_INDEX_CHECK)
04688 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04689 #else
04690 throw();
04691 #endif
04692
04693 INLINE cimatrix &operator -=(cimatrix &m1,const imatrix &m2)
04694 #if(CXSC_INDEX_CHECK)
04695 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04696 #else
04697 throw();
04698 #endif
04699
04700 INLINE cimatrix &operator -=(cimatrix &m1,const imatrix_slice &ms)
04701 #if(CXSC_INDEX_CHECK)
04702 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04703 #else
04704 throw();
04705 #endif
04706
04708 INLINE cimatrix operator *(const imatrix &m1, const cimatrix &m2)
04709 #if(CXSC_INDEX_CHECK)
04710 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04711 #else
04712 throw();
04713 #endif
04714
04715 INLINE cimatrix operator *(const cimatrix &m1, const imatrix &m2)
04716 #if(CXSC_INDEX_CHECK)
04717 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04718 #else
04719 throw();
04720 #endif
04721
04722 INLINE cimatrix operator *(const imatrix &m1, const cimatrix_slice &ms)
04723 #if(CXSC_INDEX_CHECK)
04724 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04725 #else
04726 throw();
04727 #endif
04728
04729 INLINE cimatrix operator *(const cimatrix &m1, const imatrix_slice &ms)
04730 #if(CXSC_INDEX_CHECK)
04731 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04732 #else
04733 throw();
04734 #endif
04735
04736 INLINE cimatrix operator *(const imatrix_slice &ms, const cimatrix &m1)
04737 #if(CXSC_INDEX_CHECK)
04738 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04739 #else
04740 throw();
04741 #endif
04742
04743 INLINE cimatrix operator *(const cimatrix_slice &ms, const imatrix &m1)
04744 #if(CXSC_INDEX_CHECK)
04745 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04746 #else
04747 throw();
04748 #endif
04749
04750 INLINE cimatrix operator *(const imatrix_slice &ms1, const cimatrix_slice &ms2)
04751 #if(CXSC_INDEX_CHECK)
04752 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04753 #else
04754 throw();
04755 #endif
04756
04757 INLINE cimatrix operator *(const cimatrix_slice &ms1, const imatrix_slice &ms2)
04758 #if(CXSC_INDEX_CHECK)
04759 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04760 #else
04761 throw();
04762 #endif
04763
04764 INLINE cimatrix &operator *=(cimatrix &m1,const imatrix &m2)
04765 #if(CXSC_INDEX_CHECK)
04766 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04767 #else
04768 throw();
04769 #endif
04770
04771 INLINE cimatrix &operator *=(cimatrix &m1,const imatrix_slice &ms)
04772 #if(CXSC_INDEX_CHECK)
04773 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04774 #else
04775 throw();
04776 #endif
04777
04779 INLINE cimatrix operator |(const imatrix &m1,const cimatrix &m2)
04780 #if(CXSC_INDEX_CHECK)
04781 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04782 #else
04783 throw();
04784 #endif
04785
04786 INLINE cimatrix operator |(const cimatrix &m1,const imatrix &m2)
04787 #if(CXSC_INDEX_CHECK)
04788 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04789 #else
04790 throw();
04791 #endif
04792
04793 INLINE cimatrix operator |(const imatrix &m,const cimatrix_slice &ms)
04794 #if(CXSC_INDEX_CHECK)
04795 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04796 #else
04797 throw();
04798 #endif
04799
04800 INLINE cimatrix operator |(const cimatrix &m,const imatrix_slice &ms)
04801 #if(CXSC_INDEX_CHECK)
04802 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04803 #else
04804 throw();
04805 #endif
04806
04807 INLINE cimatrix operator |(const imatrix_slice &ms,const cimatrix &m)
04808 #if(CXSC_INDEX_CHECK)
04809 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04810 #else
04811 throw();
04812 #endif
04813
04814 INLINE cimatrix operator |(const cimatrix_slice &ms,const imatrix &m)
04815 #if(CXSC_INDEX_CHECK)
04816 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04817 #else
04818 throw();
04819 #endif
04820
04821 INLINE cimatrix operator |(const imatrix_slice &m1,const cimatrix_slice &m2)
04822 #if(CXSC_INDEX_CHECK)
04823 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04824 #else
04825 throw();
04826 #endif
04827
04828 INLINE cimatrix operator |(const cimatrix_slice &m1,const imatrix_slice &m2)
04829 #if(CXSC_INDEX_CHECK)
04830 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04831 #else
04832 throw();
04833 #endif
04834
04835 INLINE cimatrix &operator |=(cimatrix &m1,const imatrix &m2)
04836 #if(CXSC_INDEX_CHECK)
04837 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04838 #else
04839 throw();
04840 #endif
04841
04842 INLINE cimatrix &operator |=(cimatrix &m1,const imatrix_slice &ms)
04843 #if(CXSC_INDEX_CHECK)
04844 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04845 #else
04846 throw();
04847 #endif
04848
04850 INLINE cimatrix operator &(const imatrix &m1,const cimatrix &m2)
04851 #if(CXSC_INDEX_CHECK)
04852 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04853 #else
04854 throw();
04855 #endif
04856
04857 INLINE cimatrix operator &(const cimatrix &m1,const imatrix &m2)
04858 #if(CXSC_INDEX_CHECK)
04859 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04860 #else
04861 throw();
04862 #endif
04863
04864 INLINE cimatrix operator &(const imatrix &m,const cimatrix_slice &ms)
04865 #if(CXSC_INDEX_CHECK)
04866 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04867 #else
04868 throw();
04869 #endif
04870
04871 INLINE cimatrix operator &(const cimatrix &m,const imatrix_slice &ms)
04872 #if(CXSC_INDEX_CHECK)
04873 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04874 #else
04875 throw();
04876 #endif
04877
04878 INLINE cimatrix operator &(const imatrix_slice &ms,const cimatrix &m)
04879 #if(CXSC_INDEX_CHECK)
04880 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04881 #else
04882 throw();
04883 #endif
04884
04885 INLINE cimatrix operator &(const cimatrix_slice &ms,const imatrix &m)
04886 #if(CXSC_INDEX_CHECK)
04887 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04888 #else
04889 throw();
04890 #endif
04891
04892 INLINE cimatrix operator &(const imatrix_slice &m1,const cimatrix_slice &m2)
04893 #if(CXSC_INDEX_CHECK)
04894 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04895 #else
04896 throw();
04897 #endif
04898
04899 INLINE cimatrix operator &(const cimatrix_slice &m1,const imatrix_slice &m2)
04900 #if(CXSC_INDEX_CHECK)
04901 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04902 #else
04903 throw();
04904 #endif
04905
04906 INLINE cimatrix &operator &=(cimatrix &m1,const imatrix &m2)
04907 #if(CXSC_INDEX_CHECK)
04908 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04909 #else
04910 throw();
04911 #endif
04912
04913 INLINE cimatrix &operator &=(cimatrix &m1,const imatrix_slice &ms)
04914 #if(CXSC_INDEX_CHECK)
04915 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04916 #else
04917 throw();
04918 #endif
04919
04920
04922 INLINE cimatrix operator +(const cmatrix &m1,const imatrix &m2)
04923 #if(CXSC_INDEX_CHECK)
04924 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04925 #else
04926 throw();
04927 #endif
04928
04929 INLINE cimatrix operator +(const imatrix &m1,const cmatrix &m2)
04930 #if(CXSC_INDEX_CHECK)
04931 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04932 #else
04933 throw();
04934 #endif
04935
04936 INLINE cimatrix operator +(const cmatrix &m,const imatrix_slice &ms)
04937 #if(CXSC_INDEX_CHECK)
04938 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04939 #else
04940 throw();
04941 #endif
04942
04943 INLINE cimatrix operator +(const imatrix &m,const cmatrix_slice &ms)
04944 #if(CXSC_INDEX_CHECK)
04945 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04946 #else
04947 throw();
04948 #endif
04949
04950 INLINE cimatrix operator +(const cmatrix_slice &ms,const imatrix &m)
04951 #if(CXSC_INDEX_CHECK)
04952 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04953 #else
04954 throw();
04955 #endif
04956
04957 INLINE cimatrix operator +(const imatrix_slice &ms,const cmatrix &m)
04958 #if(CXSC_INDEX_CHECK)
04959 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04960 #else
04961 throw();
04962 #endif
04963
04964 INLINE cimatrix operator +(const cmatrix_slice &m1,const imatrix_slice &m2)
04965 #if(CXSC_INDEX_CHECK)
04966 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04967 #else
04968 throw();
04969 #endif
04970
04971 INLINE cimatrix operator +(const imatrix_slice &m1,const cmatrix_slice &m2)
04972 #if(CXSC_INDEX_CHECK)
04973 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04974 #else
04975 throw();
04976 #endif
04977
04979 INLINE cimatrix operator -(const cmatrix &m1,const imatrix &m2)
04980 #if(CXSC_INDEX_CHECK)
04981 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04982 #else
04983 throw();
04984 #endif
04985
04986 INLINE cimatrix operator -(const imatrix &m1,const cmatrix &m2)
04987 #if(CXSC_INDEX_CHECK)
04988 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04989 #else
04990 throw();
04991 #endif
04992
04993 INLINE cimatrix operator -(const cmatrix &m,const imatrix_slice &ms)
04994 #if(CXSC_INDEX_CHECK)
04995 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
04996 #else
04997 throw();
04998 #endif
04999
05000 INLINE cimatrix operator -(const imatrix &m,const cmatrix_slice &ms)
05001 #if(CXSC_INDEX_CHECK)
05002 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
05003 #else
05004 throw();
05005 #endif
05006
05007 INLINE cimatrix operator -(const cmatrix_slice &ms,const imatrix &m)
05008 #if(CXSC_INDEX_CHECK)
05009 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
05010 #else
05011 throw();
05012 #endif
05013
05014 INLINE cimatrix operator -(const imatrix_slice &ms,const cmatrix &m)
05015 #if(CXSC_INDEX_CHECK)
05016 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
05017 #else
05018 throw();
05019 #endif
05020
05021 INLINE cimatrix operator -(const cmatrix_slice &ms1,const imatrix_slice &ms2)
05022 #if(CXSC_INDEX_CHECK)
05023 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
05024 #else
05025 throw();
05026 #endif
05027
05028 INLINE cimatrix operator -(const imatrix_slice &ms1,const cmatrix_slice &ms2)
05029 #if(CXSC_INDEX_CHECK)
05030 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
05031 #else
05032 throw();
05033 #endif
05034
05036 INLINE cimatrix operator *(const cmatrix &m1, const imatrix &m2)
05037 #if(CXSC_INDEX_CHECK)
05038 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
05039 #else
05040 throw();
05041 #endif
05042
05043 INLINE cimatrix operator *(const imatrix &m1, const cmatrix &m2)
05044 #if(CXSC_INDEX_CHECK)
05045 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
05046 #else
05047 throw();
05048 #endif
05049
05050 INLINE cimatrix operator *(const cmatrix &m1, const imatrix_slice &ms)
05051 #if(CXSC_INDEX_CHECK)
05052 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
05053 #else
05054 throw();
05055 #endif
05056
05057 INLINE cimatrix operator *(const imatrix &m1, const cmatrix_slice &ms)
05058 #if(CXSC_INDEX_CHECK)
05059 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
05060 #else
05061 throw();
05062 #endif
05063
05064 INLINE cimatrix operator *(const cmatrix_slice &ms, const imatrix &m1)
05065 #if(CXSC_INDEX_CHECK)
05066 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
05067 #else
05068 throw();
05069 #endif
05070
05071 INLINE cimatrix operator *(const imatrix_slice &ms, const cmatrix &m1)
05072 #if(CXSC_INDEX_CHECK)
05073 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
05074 #else
05075 throw();
05076 #endif
05077
05078 INLINE cimatrix operator *(const cmatrix_slice &ms1, const imatrix_slice &ms2)
05079 #if(CXSC_INDEX_CHECK)
05080 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
05081 #else
05082 throw();
05083 #endif
05084
05085 INLINE cimatrix operator *(const imatrix_slice &ms1, const cmatrix_slice &ms2)
05086 #if(CXSC_INDEX_CHECK)
05087 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
05088 #else
05089 throw();
05090 #endif
05091
05093 INLINE cimatrix operator |(const cmatrix &m1,const imatrix &m2)
05094 #if(CXSC_INDEX_CHECK)
05095 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
05096 #else
05097 throw();
05098 #endif
05099
05100 INLINE cimatrix operator |(const imatrix &m1,const cmatrix &m2)
05101 #if(CXSC_INDEX_CHECK)
05102 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
05103 #else
05104 throw();
05105 #endif
05106
05107 INLINE cimatrix operator |(const cmatrix &m,const imatrix_slice &ms)
05108 #if(CXSC_INDEX_CHECK)
05109 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
05110 #else
05111 throw();
05112 #endif
05113
05114 INLINE cimatrix operator |(const imatrix &m,const cmatrix_slice &ms)
05115 #if(CXSC_INDEX_CHECK)
05116 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
05117 #else
05118 throw();
05119 #endif
05120
05121 INLINE cimatrix operator |(const cmatrix_slice &ms,const imatrix &m)
05122 #if(CXSC_INDEX_CHECK)
05123 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
05124 #else
05125 throw();
05126 #endif
05127
05128 INLINE cimatrix operator |(const imatrix_slice &ms,const cmatrix &m)
05129 #if(CXSC_INDEX_CHECK)
05130 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
05131 #else
05132 throw();
05133 #endif
05134
05135 INLINE cimatrix operator |(const cmatrix_slice &m1,const imatrix_slice &m2)
05136 #if(CXSC_INDEX_CHECK)
05137 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
05138 #else
05139 throw();
05140 #endif
05141
05142 INLINE cimatrix operator |(const imatrix_slice &m1,const cmatrix_slice &m2)
05143 #if(CXSC_INDEX_CHECK)
05144 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
05145 #else
05146 throw();
05147 #endif
05148
05150 INLINE cimatrix operator &(const cmatrix &m1,const imatrix &m2)
05151 #if(CXSC_INDEX_CHECK)
05152 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
05153 #else
05154 throw();
05155 #endif
05156
05157 INLINE cimatrix operator &(const imatrix &m1,const cmatrix &m2)
05158 #if(CXSC_INDEX_CHECK)
05159 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
05160 #else
05161 throw();
05162 #endif
05163
05164 INLINE cimatrix operator &(const cmatrix &m,const imatrix_slice &ms)
05165 #if(CXSC_INDEX_CHECK)
05166 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
05167 #else
05168 throw();
05169 #endif
05170
05171 INLINE cimatrix operator &(const imatrix &m,const cmatrix_slice &ms)
05172 #if(CXSC_INDEX_CHECK)
05173 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
05174 #else
05175 throw();
05176 #endif
05177
05178 INLINE cimatrix operator &(const cmatrix_slice &ms,const imatrix &m)
05179 #if(CXSC_INDEX_CHECK)
05180 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
05181 #else
05182 throw();
05183 #endif
05184
05185 INLINE cimatrix operator &(const imatrix_slice &ms,const cmatrix &m)
05186 #if(CXSC_INDEX_CHECK)
05187 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
05188 #else
05189 throw();
05190 #endif
05191
05192 INLINE cimatrix operator &(const cmatrix_slice &m1,const imatrix_slice &m2)
05193 #if(CXSC_INDEX_CHECK)
05194 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
05195 #else
05196 throw();
05197 #endif
05198
05199 INLINE cimatrix operator &(const imatrix_slice &m1,const cmatrix_slice &m2)
05200 #if(CXSC_INDEX_CHECK)
05201 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
05202 #else
05203 throw();
05204 #endif
05205
05206
05208 INLINE cimatrix operator |(const rmatrix &rv1, const cmatrix &rv2)
05209 #if(CXSC_INDEX_CHECK)
05210 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
05211 #else
05212 throw();
05213 #endif
05214
05215 INLINE cimatrix operator |(const cmatrix &rv1, const rmatrix &rv2)
05216 #if(CXSC_INDEX_CHECK)
05217 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
05218 #else
05219 throw();
05220 #endif
05221
05222 INLINE cimatrix operator |(const cmatrix &rv, const rmatrix_slice &sl)
05223 #if(CXSC_INDEX_CHECK)
05224 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
05225 #else
05226 throw();
05227 #endif
05228
05229 INLINE cimatrix operator |(const rmatrix_slice &sl,const cmatrix &rv)
05230 #if(CXSC_INDEX_CHECK)
05231 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
05232 #else
05233 throw();
05234 #endif
05235
05236 INLINE cimatrix operator |(const cmatrix_slice &sl, const rmatrix &rv)
05237 #if(CXSC_INDEX_CHECK)
05238 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
05239 #else
05240 throw();
05241 #endif
05242
05243 INLINE cimatrix operator |(const rmatrix &rv,const cmatrix_slice &sl)
05244 #if(CXSC_INDEX_CHECK)
05245 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
05246 #else
05247 throw();
05248 #endif
05249
05250 INLINE cimatrix operator |(const cmatrix_slice &sl1, const rmatrix_slice &sl2)
05251 #if(CXSC_INDEX_CHECK)
05252 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
05253 #else
05254 throw();
05255 #endif
05256
05257 INLINE cimatrix operator |(const rmatrix_slice &sl1, const cmatrix_slice &sl2)
05258 #if(CXSC_INDEX_CHECK)
05259 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
05260 #else
05261 throw();
05262 #endif
05263
05264
05265
05267 INLINE cimatrix operator |(const cmatrix &rv1, const cmatrix &rv2)
05268 #if(CXSC_INDEX_CHECK)
05269 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
05270 #else
05271 throw();
05272 #endif
05273
05274 INLINE cimatrix operator |(const cmatrix &rv1, const cmatrix &rv2)
05275 #if(CXSC_INDEX_CHECK)
05276 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
05277 #else
05278 throw();
05279 #endif
05280
05281 INLINE cimatrix operator |(const cmatrix &rv, const cmatrix_slice &sl)
05282 #if(CXSC_INDEX_CHECK)
05283 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
05284 #else
05285 throw();
05286 #endif
05287
05288 INLINE cimatrix operator |(const cmatrix_slice &sl,const cmatrix &rv)
05289 #if(CXSC_INDEX_CHECK)
05290 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
05291 #else
05292 throw();
05293 #endif
05294
05295 INLINE cimatrix operator |(const cmatrix_slice &sl, const cmatrix &rv)
05296 #if(CXSC_INDEX_CHECK)
05297 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
05298 #else
05299 throw();
05300 #endif
05301
05302 INLINE cimatrix operator |(const cmatrix &rv,const cmatrix_slice &sl)
05303 #if(CXSC_INDEX_CHECK)
05304 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
05305 #else
05306 throw();
05307 #endif
05308
05309 INLINE cimatrix operator |(const cmatrix_slice &sl1, const cmatrix_slice &sl2)
05310 #if(CXSC_INDEX_CHECK)
05311 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
05312 #else
05313 throw();
05314 #endif
05315
05316 INLINE cimatrix operator |(const cmatrix_slice &sl1, const cmatrix_slice &sl2)
05317 #if(CXSC_INDEX_CHECK)
05318 throw(ERROR__OP_WITH_WRONG_DIM<cimatrix>);
05319 #else
05320 throw();
05321 #endif
05322
05323
05324
05325
05326
05327
05329 INLINE bool operator ==(const cimatrix &m1,const cimatrix &m2) throw();
05331 INLINE bool operator !=(const cimatrix &m1,const cimatrix &m2) throw();
05333 INLINE bool operator <(const cimatrix &m1,const cimatrix &m2) throw();
05335 INLINE bool operator <=(const cimatrix &m1,const cimatrix &m2) throw();
05337 INLINE bool operator >(const cimatrix &m1,const cimatrix &m2) throw();
05339 INLINE bool operator >=(const cimatrix &m1,const cimatrix &m2) throw();
05341 INLINE bool operator ==(const cimatrix &m1,const cimatrix_slice &ms) throw();
05343 INLINE bool operator !=(const cimatrix &m1,const cimatrix_slice &ms) throw();
05345 INLINE bool operator <(const cimatrix &m1,const cimatrix_slice &ms) throw();
05347 INLINE bool operator <=(const cimatrix &m1,const cimatrix_slice &ms) throw();
05349 INLINE bool operator >(const cimatrix &m1,const cimatrix_slice &ms) throw();
05351 INLINE bool operator >=(const cimatrix &m1,const cimatrix_slice &ms) throw();
05352
05353
05354
05356 INLINE bool operator ==(const cimatrix_slice &m1,const cimatrix_slice &m2) throw();
05358 INLINE bool operator !=(const cimatrix_slice &m1,const cimatrix_slice &m2) throw();
05360 INLINE bool operator <(const cimatrix_slice &m1,const cimatrix_slice &m2) throw();
05362 INLINE bool operator <=(const cimatrix_slice &m1,const cimatrix_slice &m2) throw();
05364 INLINE bool operator >(const cimatrix_slice &m1,const cimatrix_slice &m2) throw();
05366 INLINE bool operator >=(const cimatrix_slice &m1,const cimatrix_slice &m2) throw();
05367
05368
05369
05371 INLINE bool operator !(const cimatrix &ms) throw();
05373 INLINE bool operator !(const cimatrix_slice &ms) throw();
05374
05375
05376
05378 INLINE std::ostream &operator <<(std::ostream &s,const cimatrix &r) throw();
05380 INLINE std::ostream &operator <<(std::ostream &s,const cimatrix_slice &r) throw();
05382 INLINE std::istream &operator >>(std::istream &s,cimatrix &r) throw();
05384 INLINE std::istream &operator >>(std::istream &s,cimatrix_slice &r) throw();
05385
05387 cimatrix Id ( const cimatrix& );
05389 cimatrix transp ( const cimatrix& );
05391 INLINE int RowLen ( const cimatrix& );
05393 INLINE int ColLen ( const cimatrix& );
05395 INLINE int RowLen ( const cimatrix_slice& );
05397 INLINE int ColLen ( const cimatrix_slice& );
05399 void DoubleSize ( cimatrix& );
05400
05401 }
05402
05403
05404 #ifdef _CXSC_INCL_INL
05405 #include "matrix.inl"
05406 #include "cimatrix.inl"
05407 #endif
05408
05409
05410 #ifdef CXSC_USE_BLAS
05411 #define _CXSC_BLAS_CIMATRIX
05412 #include "cxsc_blas.inl"
05413 #endif
05414
05415 #endif
