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_IMATRIX_HPP_INCLUDED
00027 #define _CXSC_IMATRIX_HPP_INCLUDED
00028
00029 #include "xscclass.hpp"
00030 #include "idot.hpp"
00031 #include "cidot.hpp"
00032 #include "ivector.hpp"
00033 #include "except.hpp"
00034 #include "matrix.hpp"
00035 #include "rmatrix.hpp"
00036
00037
00038 namespace cxsc {
00039
00040
00041 class imatrix;
00042 class imatrix_slice;
00043 class simatrix;
00044 class simatrix_slice;
00045 class simatrix_subv;
00046 class srmatrix;
00047 class srmatrix_slice;
00048 class srmatrix_subv;
00049
00050
00052
00055 class imatrix_subv
00056 {
00057 friend class ivector;
00058 friend class civector;
00059 friend class l_ivector;
00060 friend class imatrix;
00061 friend class imatrix_slice;
00062 private:
00063 interval *dat;
00064 int lb,ub;
00065 int size,start,offset;
00066
00067 public:
00069 friend INLINE imatrix_subv Row(imatrix &m,const int &i)
00070 #if(CXSC_INDEX_CHECK)
00071 throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT);
00072 #else
00073 throw();
00074 #endif
00075
00076 friend INLINE imatrix_subv Col(imatrix &m,const int &i)
00077 #if(CXSC_INDEX_CHECK)
00078 throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT);
00079 #else
00080 throw();
00081 #endif
00082
00083 friend INLINE imatrix_subv Row(const imatrix &m,const int &i)
00084 #if(CXSC_INDEX_CHECK)
00085 throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT);
00086 #else
00087 throw();
00088 #endif
00089
00090 friend INLINE imatrix_subv Col(const imatrix &m,const int &i)
00091 #if(CXSC_INDEX_CHECK)
00092 throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT);
00093 #else
00094 throw();
00095 #endif
00096
00097
00098 #ifdef _CXSC_FRIEND_TPL
00099
00100 template <class MV1,class MV2> friend MV1 &_mvmvassign(MV1 &v,const MV2 &rv)
00101 #if(CXSC_INDEX_CHECK)
00102 throw(ERROR__OP_WITH_WRONG_DIM<MV1>);
00103 #else
00104 throw();
00105 #endif
00106 template <class MV,class S> friend MV &_mvsassign(MV &v,const S &r) throw();
00107 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
00108 #if(CXSC_INDEX_CHECK)
00109 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00110 #else
00111 throw();
00112 #endif
00113 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) throw();
00114 template <class MV,class V> friend MV &_mvvsetinf(MV &v,const V &rv)
00115 #if(CXSC_INDEX_CHECK)
00116 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00117 #else
00118 throw();
00119 #endif
00120 template <class MV,class V> friend MV &_mvvsetsup(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 MV,class V> friend MV &_mvvusetinf(MV &v,const V &rv)
00127 #if(CXSC_INDEX_CHECK)
00128 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00129 #else
00130 throw();
00131 #endif
00132 template <class MV,class V> friend MV &_mvvusetsup(MV &v,const V &rv)
00133 #if(CXSC_INDEX_CHECK)
00134 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00135 #else
00136 throw();
00137 #endif
00138 template <class MV,class S> friend MV &_mvssetinf(MV &mv, const S &s) throw();
00139 template <class MV,class S> friend MV &_mvssetsup(MV &mv, const S &s) throw();
00140 template <class MV,class S> friend MV &_mvsusetinf(MV &mv, const S &s) throw();
00141 template <class MV,class S> friend MV &_mvsusetsup(MV &mv, const S &s) throw();
00142 template <class MV,class V> friend V _mvabs(const MV &mv) throw();
00143 template <class MV,class V> friend V _mvdiam(const MV &mv) throw();
00144 template <class MV,class V> friend V _mvmid(const MV &mv) throw();
00145 template <class MV,class V> friend V _mvinf(const MV &mv) throw();
00146 template <class MV,class V> friend V _mvsup(const MV &mv) throw();
00147 template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
00148 #if(CXSC_INDEX_CHECK)
00149 throw(OP_WITH_WRONG_DIM);
00150 #else
00151 throw();
00152 #endif
00153 template <class DP,class MV1,class MV2> friend void _mvmvaccu(DP &dp, const MV1 & rv1, const MV2 &rv2)
00154 #if(CXSC_INDEX_CHECK)
00155 throw(OP_WITH_WRONG_DIM);
00156 #else
00157 throw();
00158 #endif
00159 template <class MV1,class MV2,class S> friend S _mvmvimult(const MV1 & rv1, const MV2 &rv2)
00160 #if(CXSC_INDEX_CHECK)
00161 throw(ERROR__OP_WITH_WRONG_DIM<MV1>);
00162 #else
00163 throw();
00164 #endif
00165 template <class V,class MV,class S> friend S _vmvimult(const V &rv1, const MV &rv2)
00166 #if(CXSC_INDEX_CHECK)
00167 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00168 #else
00169 throw();
00170 #endif
00171 template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) throw();
00172 template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
00173 #if(CXSC_INDEX_CHECK)
00174 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00175 #else
00176 throw();
00177 #endif
00178 template <class MV1,class MV2,class E> friend E _mvmvminus(const MV1 &rv1, const MV2 &rv2)
00179 #if(CXSC_INDEX_CHECK)
00180 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00181 #else
00182 throw();
00183 #endif
00184 template <class MV,class V,class E> friend E _mvvplus(const MV &rv1, const V &rv2)
00185 #if(CXSC_INDEX_CHECK)
00186 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00187 #else
00188 throw();
00189 #endif
00190 template <class MV,class V,class E> friend E _mvvminus(const MV &rv1, const V &rv2)
00191 #if(CXSC_INDEX_CHECK)
00192 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00193 #else
00194 throw();
00195 #endif
00196 template <class V,class MV,class E> friend E _vmvminus(const V &rv1, const MV &rv2)
00197 #if(CXSC_INDEX_CHECK)
00198 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00199 #else
00200 throw();
00201 #endif
00202 template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) throw();
00203 template <class MV,class S> friend MV &_mvsmultassign(MV &v,const S &r) throw();
00204 template <class MV, class S> friend MV &_mvsplusassign(MV &v,const S &r) throw();
00205 template <class MV,class S> friend MV &_mvsminusassign(MV &v,const S &r) throw();
00206 template <class MV,class S> friend MV &_mvsdivassign(MV &v,const S &r) throw();
00207 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
00208 #if(CXSC_INDEX_CHECK)
00209 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00210 #else
00211 throw();
00212 #endif
00213 template <class V,class MV> friend V &_vmvplusassign(V &rv,const MV &v)
00214 #if(CXSC_INDEX_CHECK)
00215 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00216 #else
00217 throw();
00218 #endif
00219 template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv)
00220 #if(CXSC_INDEX_CHECK)
00221 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00222 #else
00223 throw();
00224 #endif
00225 template <class V,class MV> friend V &_vmvminusassign(V &rv,const MV &v)
00226 #if(CXSC_INDEX_CHECK)
00227 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00228 #else
00229 throw();
00230 #endif
00231 template <class MV1,class MV2,class E> friend E _mvmvconv(const MV1 &rv1, const MV2 &rv2)
00232 #if(CXSC_INDEX_CHECK)
00233 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00234 #else
00235 throw();
00236 #endif
00237 template <class MV,class V,class E> friend E _mvvconv(const MV &rv1, const V &rv2)
00238 #if(CXSC_INDEX_CHECK)
00239 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00240 #else
00241 throw();
00242 #endif
00243 template <class MV,class V> friend MV &_mvvconvassign(MV &v,const V &rv)
00244 #if(CXSC_INDEX_CHECK)
00245 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00246 #else
00247 throw();
00248 #endif
00249 template <class MV1,class MV2,class E> friend E _mvmvsect(const MV1 &rv1, const MV2 &rv2)
00250 #if(CXSC_INDEX_CHECK)
00251 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00252 #else
00253 throw();
00254 #endif
00255 template <class MV,class V,class E> friend E _mvvsect(const MV &rv1, const V &rv2)
00256 #if(CXSC_INDEX_CHECK)
00257 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00258 #else
00259 throw();
00260 #endif
00261 template <class MV,class V> friend MV &_mvvsectassign(MV &v,const V &rv)
00262 #if(CXSC_INDEX_CHECK)
00263 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00264 #else
00265 throw();
00266 #endif
00267 template <class V,class MV> friend V &_vmvsectassign(V &rv,const MV &v)
00268 #if(CXSC_INDEX_CHECK)
00269 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00270 #else
00271 throw();
00272 #endif
00273
00274
00275 template <class V,class MV> friend V &_vmvsetim(V &rv,const MV &v)
00276 #if(CXSC_INDEX_CHECK)
00277 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00278 #else
00279 throw();
00280 #endif
00281 template <class V,class MV> friend V &_vmvsetre(V &rv,const MV &v)
00282 #if(CXSC_INDEX_CHECK)
00283 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00284 #else
00285 throw();
00286 #endif
00287
00288
00289
00290
00291
00292
00293
00294
00295
00296
00297
00298
00299
00300
00301 #endif
00302
00303
00304
00306 explicit INLINE imatrix_subv (interval *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) { }
00307 public:
00309 INLINE imatrix_subv(const imatrix_subv &v) throw():dat(v.dat),lb(v.lb),ub(v.ub),size(v.size),start(v.start),offset(v.offset) { }
00310 public:
00311
00312
00313
00315 INLINE imatrix_subv &operator =(const simatrix_subv &rv);
00317 INLINE imatrix_subv &operator =(const srmatrix_subv &rv);
00319 INLINE imatrix_subv &operator =(const srvector &rv);
00321 INLINE imatrix_subv &operator =(const sivector &rv);
00323 INLINE imatrix_subv &operator =(const srvector_slice &rv);
00325 INLINE imatrix_subv &operator =(const sivector_slice &rv);
00326
00328 INLINE imatrix_subv &operator =(const imatrix_subv &rv) throw();
00330 INLINE imatrix_subv &operator =(const interval &r) throw();
00332 INLINE imatrix_subv &operator =(const imatrix &m)
00333 #if(CXSC_INDEX_CHECK)
00334 throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
00335 #else
00336 throw();
00337 #endif
00338
00339 INLINE imatrix_subv &operator =(const imatrix_slice &m)
00340 #if(CXSC_INDEX_CHECK)
00341 throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
00342 #else
00343 throw();
00344 #endif
00345
00346 INLINE imatrix_subv &operator =(const ivector &v)
00347 #if(CXSC_INDEX_CHECK)
00348 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00349 #else
00350 throw();
00351 #endif
00352
00353 INLINE imatrix_subv &operator =(const ivector_slice &v)
00354 #if(CXSC_INDEX_CHECK)
00355 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00356 #else
00357 throw();
00358 #endif
00359
00361 INLINE imatrix_subv &operator =(const rmatrix_subv &rv) throw();
00363 INLINE imatrix_subv &operator =(const real &r) throw();
00365 INLINE imatrix_subv &operator =(const rmatrix &m)
00366 #if(CXSC_INDEX_CHECK)
00367 throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
00368 #else
00369 throw();
00370 #endif
00371
00372 INLINE imatrix_subv &operator =(const rmatrix_slice &m)
00373 #if(CXSC_INDEX_CHECK)
00374 throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
00375 #else
00376 throw();
00377 #endif
00378
00379 INLINE imatrix_subv &operator =(const rvector &v)
00380 #if(CXSC_INDEX_CHECK)
00381 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00382 #else
00383 throw();
00384 #endif
00385
00386 INLINE imatrix_subv &operator =(const rvector_slice &v)
00387 #if(CXSC_INDEX_CHECK)
00388 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00389 #else
00390 throw();
00391 #endif
00392
00394 friend INLINE int Lb(const imatrix_subv &rv) throw() { return rv.lb; }
00396 friend INLINE int Ub(const imatrix_subv &rv) throw() { return rv.ub; }
00398 friend INLINE int VecLen(const imatrix_subv &rv) throw() { return rv.size; }
00399
00401 INLINE interval &operator [](const int &i) const
00402 #if(CXSC_INDEX_CHECK)
00403 throw(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC);
00404 #else
00405 throw();
00406 #endif
00407
00409 INLINE interval &operator [](const int &i)
00410 #if(CXSC_INDEX_CHECK)
00411 throw(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC);
00412 #else
00413 throw();
00414 #endif
00415
00417 INLINE imatrix_subv &operator ()() throw() { return *this; }
00419 INLINE imatrix_subv operator ()(const int &i)
00420 #if(CXSC_INDEX_CHECK)
00421 throw(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG);
00422 #else
00423 throw();
00424 #endif
00425
00426 INLINE imatrix_subv operator ()(const int &i1,const int &i2)
00427 #if(CXSC_INDEX_CHECK)
00428 throw(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG);
00429 #else
00430 throw();
00431 #endif
00432
00434 INLINE imatrix_subv &operator *=(const interval &c) throw();
00436 INLINE imatrix_subv &operator +=(const interval &c) throw();
00438 INLINE imatrix_subv &operator -=(const interval &c) throw();
00440 INLINE imatrix_subv &operator /=(const interval &c) throw();
00441
00442
00444 INLINE imatrix_subv &operator +=(const sivector &rv);
00446 INLINE imatrix_subv &operator -=(const sivector &rv);
00448 INLINE imatrix_subv &operator +=(const srvector &rv);
00450 INLINE imatrix_subv &operator -=(const srvector &rv);
00452 INLINE imatrix_subv &operator +=(const sivector_slice &rv);
00454 INLINE imatrix_subv &operator -=(const sivector_slice &rv);
00456 INLINE imatrix_subv &operator +=(const srvector_slice &rv);
00458 INLINE imatrix_subv &operator -=(const srvector_slice &rv);
00460 INLINE imatrix_subv &operator +=(const simatrix_subv &rv);
00462 INLINE imatrix_subv &operator -=(const simatrix_subv &rv);
00464 INLINE imatrix_subv &operator +=(const srmatrix_subv &rv);
00466 INLINE imatrix_subv &operator -=(const srmatrix_subv &rv);
00467
00469 INLINE imatrix_subv &operator |=(const sivector &rv);
00471 INLINE imatrix_subv &operator &=(const sivector &rv);
00473 INLINE imatrix_subv &operator |=(const srvector &rv);
00475 INLINE imatrix_subv &operator &=(const srvector &rv);
00477 INLINE imatrix_subv &operator |=(const sivector_slice &rv);
00479 INLINE imatrix_subv &operator &=(const sivector_slice &rv);
00481 INLINE imatrix_subv &operator |=(const srvector_slice &rv);
00483 INLINE imatrix_subv &operator &=(const srvector_slice &rv);
00485 INLINE imatrix_subv &operator |=(const simatrix_subv &rv);
00487 INLINE imatrix_subv &operator &=(const simatrix_subv &rv);
00489 INLINE imatrix_subv &operator |=(const srmatrix_subv &rv);
00491 INLINE imatrix_subv &operator &=(const srmatrix_subv &rv);
00492
00493
00495 INLINE imatrix_subv &operator -=(const ivector &rv)
00496 #if(CXSC_INDEX_CHECK)
00497 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00498 #else
00499 throw();
00500 #endif
00501
00502 INLINE imatrix_subv &operator +=(const ivector &rv)
00503 #if(CXSC_INDEX_CHECK)
00504 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00505 #else
00506 throw();
00507 #endif
00508
00509 INLINE imatrix_subv &operator -=(const ivector_slice &rv)
00510 #if(CXSC_INDEX_CHECK)
00511 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00512 #else
00513 throw();
00514 #endif
00515
00516 INLINE imatrix_subv &operator +=(const ivector_slice &rv)
00517 #if(CXSC_INDEX_CHECK)
00518 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00519 #else
00520 throw();
00521 #endif
00522
00523 INLINE imatrix_subv &operator |=(const ivector &rv)
00524 #if(CXSC_INDEX_CHECK)
00525 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00526 #else
00527 throw();
00528 #endif
00529
00530 INLINE imatrix_subv &operator |=(const ivector_slice &rv)
00531 #if(CXSC_INDEX_CHECK)
00532 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00533 #else
00534 throw();
00535 #endif
00536
00537 INLINE imatrix_subv &operator &=(const ivector &rv)
00538 #if(CXSC_INDEX_CHECK)
00539 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00540 #else
00541 throw();
00542 #endif
00543
00544 INLINE imatrix_subv &operator &=(const ivector_slice &rv)
00545 #if(CXSC_INDEX_CHECK)
00546 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00547 #else
00548 throw();
00549 #endif
00550
00552 INLINE imatrix_subv &operator *=(const real &c) throw();
00554 INLINE imatrix_subv &operator +=(const real &c) throw();
00556 INLINE imatrix_subv &operator -=(const real &c) throw();
00558 INLINE imatrix_subv &operator /=(const real &c) throw();
00559
00561 INLINE imatrix_subv &operator +=(const rvector &rv)
00562 #if(CXSC_INDEX_CHECK)
00563 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00564 #else
00565 throw();
00566 #endif
00567
00568 INLINE imatrix_subv &operator +=(const rvector_slice &rv)
00569 #if(CXSC_INDEX_CHECK)
00570 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00571 #else
00572 throw();
00573 #endif
00574
00575 INLINE imatrix_subv &operator -=(const rvector &rv)
00576 #if(CXSC_INDEX_CHECK)
00577 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00578 #else
00579 throw();
00580 #endif
00581
00582 INLINE imatrix_subv &operator -=(const rvector_slice &rv)
00583 #if(CXSC_INDEX_CHECK)
00584 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00585 #else
00586 throw();
00587 #endif
00588
00589 INLINE imatrix_subv &operator |=(const rvector &rv)
00590 #if(CXSC_INDEX_CHECK)
00591 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00592 #else
00593 throw();
00594 #endif
00595
00596 INLINE imatrix_subv &operator |=(const rvector_slice &rv)
00597 #if(CXSC_INDEX_CHECK)
00598 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00599 #else
00600 throw();
00601 #endif
00602
00603 INLINE imatrix_subv &operator &=(const rvector &rv)
00604 #if(CXSC_INDEX_CHECK)
00605 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00606 #else
00607 throw();
00608 #endif
00609
00610 INLINE imatrix_subv &operator &=(const rvector_slice &rv)
00611 #if(CXSC_INDEX_CHECK)
00612 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00613 #else
00614 throw();
00615 #endif
00616
00617
00618
00619 };
00620
00621
00623 INLINE imatrix_subv Row(imatrix &m,const int &i)
00624 #if(CXSC_INDEX_CHECK)
00625 throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT);
00626 #else
00627 throw();
00628 #endif
00629
00630 INLINE imatrix_subv Col(imatrix &m,const int &i)
00631 #if(CXSC_INDEX_CHECK)
00632 throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT);
00633 #else
00634 throw();
00635 #endif
00636
00637 INLINE imatrix_subv Row(const imatrix &m,const int &i)
00638 #if(CXSC_INDEX_CHECK)
00639 throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT);
00640 #else
00641 throw();
00642 #endif
00643
00644 INLINE imatrix_subv Col(const imatrix &m,const int &i)
00645 #if(CXSC_INDEX_CHECK)
00646 throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT);
00647 #else
00648 throw();
00649 #endif
00650
00651
00652
00653 class imatrix_slice;
00654
00656
00659 class imatrix
00660 {
00661 friend class imatrix_slice;
00662 friend class imatrix_subv;
00663 friend class cimatrix;
00664 friend class l_imatrix;
00665 private:
00666 interval *dat;
00667 int lb1,ub1,lb2,ub2,xsize,ysize;
00668
00669 public:
00670
00671 #ifdef _CXSC_FRIEND_TPL
00672
00673 template <class S,class M> friend void _smconstr(S &s,const M &m)
00674 #if(CXSC_INDEX_CHECK)
00675 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>,ERROR__USE_OF_UNINITIALIZED_OBJ<M>);
00676 #else
00677 throw();
00678 #endif
00679 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
00680 #if(CXSC_INDEX_CHECK)
00681 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
00682 #else
00683 throw();
00684 #endif
00685 template <class M1,class M2,class S> friend M1 &_mmassign(M1 &m1,const M2 &m,S ms) throw();
00686 template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) throw();
00687 template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m)
00688 #if(CXSC_INDEX_CHECK)
00689 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00690 #else
00691 throw();
00692 #endif
00693 template <class M,class S> friend M &_msassign(M &m,const S &r) throw();
00694 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m)
00695 #if(CXSC_INDEX_CHECK)
00696 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
00697 #else
00698 throw();
00699 #endif
00700 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) throw();
00701 template <class M> friend int _mlb(const M &m, const int &i)
00702 #if(CXSC_INDEX_CHECK)
00703 throw(ERROR__WRONG_ROW_OR_COL<M>);
00704 #else
00705 throw();
00706 #endif
00707 template <class M> friend int _mub(const M &m, const int &i)
00708 #if(CXSC_INDEX_CHECK)
00709 throw(ERROR__WRONG_ROW_OR_COL<M>);
00710 #else
00711 throw();
00712 #endif
00713 template <class M> friend M &_msetlb(M &m, const int &i,const int &j)
00714 #if(CXSC_INDEX_CHECK)
00715 throw(ERROR__WRONG_ROW_OR_COL<M>);
00716 #else
00717 throw();
00718 #endif
00719 template <class M> friend M &_msetub(M &m, const int &i,const int &j)
00720 #if(CXSC_INDEX_CHECK)
00721 throw(ERROR__WRONG_ROW_OR_COL<M>);
00722 #else
00723 throw();
00724 #endif
00725 template <class M> friend void _mresize(M &A) throw();
00726 template <class M,class S> friend void _mresize(M &A,const int &m, const int &n)
00727 #if(CXSC_INDEX_CHECK)
00728 throw(ERROR__WRONG_BOUNDARIES<M>);
00729 #else
00730 throw();
00731 #endif
00732 template <class M,class S> friend void _mresize(M &A,const int &m1, const int &m2,const int &n1,const int &n2)
00733 #if(CXSC_INDEX_CHECK)
00734 throw(ERROR__WRONG_BOUNDARIES<M>);
00735 #else
00736 throw();
00737 #endif
00738 template <class M,class E> friend E _mabs(const M &m) throw();
00739 template <class MS,class E> friend E _msabs(const MS &ms) throw();
00740 template <class M,class E> friend E _mdiam(const M &m) throw();
00741 template <class M,class E> friend E _mmid(const M &m) throw();
00742 template <class M,class E> friend E _minf(const M &m) throw();
00743 template <class M,class E> friend E _msup(const M &m) throw();
00744 template <class M1,class M2> friend M1 &_mmsetinf(M1 &m1,const M2 &m2)
00745 #if(CXSC_INDEX_CHECK)
00746 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00747 #else
00748 throw();
00749 #endif
00750 template <class M1,class M2> friend M1 &_mmsetsup(M1 &m1,const M2 &m2)
00751 #if(CXSC_INDEX_CHECK)
00752 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00753 #else
00754 throw();
00755 #endif
00756 template <class M1,class MS2> friend M1 &_mmssetinf(M1 &m1,const MS2 &ms2)
00757 #if(CXSC_INDEX_CHECK)
00758 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00759 #else
00760 throw();
00761 #endif
00762 template <class M1,class MS2> friend M1 &_mmssetsup(M1 &m1,const MS2 &ms2)
00763 #if(CXSC_INDEX_CHECK)
00764 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00765 #else
00766 throw();
00767 #endif
00768 template <class M1,class M2> friend M1 &_mmusetinf(M1 &m1,const M2 &m2)
00769 #if(CXSC_INDEX_CHECK)
00770 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00771 #else
00772 throw();
00773 #endif
00774 template <class M1,class M2> friend M1 &_mmusetsup(M1 &m1,const M2 &m2)
00775 #if(CXSC_INDEX_CHECK)
00776 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00777 #else
00778 throw();
00779 #endif
00780 template <class M1,class MS2> friend M1 &_mmsusetinf(M1 &m1,const MS2 &ms2)
00781 #if(CXSC_INDEX_CHECK)
00782 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00783 #else
00784 throw();
00785 #endif
00786 template <class M1,class MS2> friend M1 &_mmsusetsup(M1 &m1,const MS2 &ms2)
00787 #if(CXSC_INDEX_CHECK)
00788 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00789 #else
00790 throw();
00791 #endif
00792
00793 template <class M1,class M2,class E> friend E _mmplus(const M1 &m1,const M2 &m2)
00794 #if(CXSC_INDEX_CHECK)
00795 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00796 #else
00797 throw();
00798 #endif
00799 template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms)
00800 #if(CXSC_INDEX_CHECK)
00801 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00802 #else
00803 throw();
00804 #endif
00805 template <class M> friend M _mminus(const M &m) throw();
00806 template <class MS,class E> friend E _msminus(const MS &ms) throw();
00807 template <class M1,class M2,class E> friend E _mmminus(const M1 &m1,const M2 &m2)
00808 #if(CXSC_INDEX_CHECK)
00809 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00810 #else
00811 throw();
00812 #endif
00813 template <class M1,class M2> friend M1 &_mmplusassign(M1 &m1,const M2 &m2)
00814 #if(CXSC_INDEX_CHECK)
00815 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00816 #else
00817 throw();
00818 #endif
00819 template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms)
00820 #if(CXSC_INDEX_CHECK)
00821 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00822 #else
00823 throw();
00824 #endif
00825 template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1)
00826 #if(CXSC_INDEX_CHECK)
00827 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00828 #else
00829 throw();
00830 #endif
00831 template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2)
00832 #if(CXSC_INDEX_CHECK)
00833 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00834 #else
00835 throw();
00836 #endif
00837 template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms)
00838 #if(CXSC_INDEX_CHECK)
00839 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00840 #else
00841 throw();
00842 #endif
00843 template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m)
00844 #if(CXSC_INDEX_CHECK)
00845 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00846 #else
00847 throw();
00848 #endif
00849 template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2)
00850 #if(CXSC_INDEX_CHECK)
00851 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00852 #else
00853 throw();
00854 #endif
00855 template <class M1,class M2> friend M1 &_mmminusassign(M1 &m1,const M2 &m2)
00856 #if(CXSC_INDEX_CHECK)
00857 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00858 #else
00859 throw();
00860 #endif
00861 template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms)
00862 #if(CXSC_INDEX_CHECK)
00863 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00864 #else
00865 throw();
00866 #endif
00867 template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1)
00868 #if(CXSC_INDEX_CHECK)
00869 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00870 #else
00871 throw();
00872 #endif
00873 template <class M1,class M2,class E> friend E _mmimult(const M1 &m1, const M2 &m2)
00874 #if(CXSC_INDEX_CHECK)
00875 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00876 #else
00877 throw();
00878 #endif
00879 template <class M1,class M2,class S> friend M1 &_mmimultassign(M1 &m1,const M2 &m2)
00880 #if(CXSC_INDEX_CHECK)
00881 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00882 #else
00883 throw();
00884 #endif
00885 template <class M,class MS,class E> friend E _mmsimult(const M &m1, const MS &ms)
00886 #if(CXSC_INDEX_CHECK)
00887 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00888 #else
00889 throw();
00890 #endif
00891 template <class MS,class M,class E> friend E _msmimult(const MS &ms, const M &m2)
00892 #if(CXSC_INDEX_CHECK)
00893 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00894 #else
00895 throw();
00896 #endif
00897 template <class M,class MS,class S> friend M &_mmsimultassign(M &m1,const MS &ms)
00898 #if(CXSC_INDEX_CHECK)
00899 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00900 #else
00901 throw();
00902 #endif
00903 template <class MS1,class MS2,class E> friend E _msmsimult(const MS1 &ms1, const MS2 &ms2)
00904 #if(CXSC_INDEX_CHECK)
00905 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00906 #else
00907 throw();
00908 #endif
00909 template <class M1,class M2,class E> friend E _mmconv(const M1 &m1,const M2 &m2)
00910 #if(CXSC_INDEX_CHECK)
00911 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00912 #else
00913 throw();
00914 #endif
00915 template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms)
00916 #if(CXSC_INDEX_CHECK)
00917 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00918 #else
00919 throw();
00920 #endif
00921 template <class M1,class M2> friend M1 &_mmconvassign(M1 &m1,const M2 &m2)
00922 #if(CXSC_INDEX_CHECK)
00923 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00924 #else
00925 throw();
00926 #endif
00927 template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms)
00928 #if(CXSC_INDEX_CHECK)
00929 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00930 #else
00931 throw();
00932 #endif
00933 template <class MS,class M> friend MS &_msmconvassign(MS &ms,const M &m1)
00934 #if(CXSC_INDEX_CHECK)
00935 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00936 #else
00937 throw();
00938 #endif
00939 template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2)
00940 #if(CXSC_INDEX_CHECK)
00941 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00942 #else
00943 throw();
00944 #endif
00945 template <class M1,class M2,class E> friend E _mmsect(const M1 &m1,const M2 &m2)
00946 #if(CXSC_INDEX_CHECK)
00947 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00948 #else
00949 throw();
00950 #endif
00951 template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms)
00952 #if(CXSC_INDEX_CHECK)
00953 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00954 #else
00955 throw();
00956 #endif
00957 template <class M1,class M2> friend M1 &_mmsectassign(M1 &m1,const M2 &m2)
00958 #if(CXSC_INDEX_CHECK)
00959 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00960 #else
00961 throw();
00962 #endif
00963 template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms)
00964 #if(CXSC_INDEX_CHECK)
00965 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00966 #else
00967 throw();
00968 #endif
00969 template <class MS,class M> friend MS &_msmsectassign(MS &ms,const M &m1)
00970 #if(CXSC_INDEX_CHECK)
00971 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00972 #else
00973 throw();
00974 #endif
00975 template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2)
00976 #if(CXSC_INDEX_CHECK)
00977 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00978 #else
00979 throw();
00980 #endif
00981
00982 template <class S,class M,class E> friend E _smmult(const S &c, const M &m) throw();
00983 template <class M,class S> friend M &_msmultassign(M &m,const S &c) throw();
00984 template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) throw();
00985 template <class M,class S,class E> friend E _msdiv(const M &m,const S &c) throw();
00986 template <class M,class S> friend M &_msdivassign(M &m,const S &c) throw();
00987 template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) throw();
00988
00989 template <class M,class V,class E> friend E _mvimult(const M &m,const V &v)
00990 #if(CXSC_INDEX_CHECK)
00991 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00992 #else
00993 throw();
00994 #endif
00995 template <class V,class M,class E> friend E _vmimult(const V &v,const M &m)
00996 #if(CXSC_INDEX_CHECK)
00997 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00998 #else
00999 throw();
01000 #endif
01001 template <class V,class M,class S> friend V &_vmimultassign(V &v,const M &m)
01002 #if(CXSC_INDEX_CHECK)
01003 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01004 #else
01005 throw();
01006 #endif
01007 template <class VS,class M,class S> friend VS &_vsmimultassign(VS &v,const M &m)
01008 #if(CXSC_INDEX_CHECK)
01009 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01010 #else
01011 throw();
01012 #endif
01013
01014 template <class M> friend void *_mvoid(const M &m) throw();
01015 template <class M> friend bool _mnot(const M &m) throw();
01016 template <class MS> friend void *_msvoid(const MS &ms) throw();
01017 template <class MS> friend bool _msnot(const MS &ms) throw();
01018 template <class M1,class M2> friend bool _mmeq(const M1 &m1,const M2 &m2) throw();
01019 template <class M1,class M2> friend bool _mmneq(const M1 &m1,const M2 &m2) throw();
01020 template <class M1,class M2> friend bool _mmless(const M1 &m1,const M2 &m2) throw();
01021 template <class M1,class M2> friend bool _mmleq(const M1 &m1,const M2 &m2) throw();
01022 template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) throw();
01023 template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) throw();
01024 template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) throw();
01025 template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) throw();
01026 template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) throw();
01027 template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) throw();
01028 template <class M> friend std::ostream &_mout(std::ostream &s,const M &r) throw();
01029 template <class M> friend std::istream &_min(std::istream &s,M &r) throw();
01030
01031
01032 template <class MS,class V,class E> friend E _msvimult(const MS &ms,const V &v)
01033 #if(CXSC_INDEX_CHECK)
01034 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01035 #else
01036 throw();
01037 #endif
01038 template <class V,class MS,class E> friend E _vmsimult(const V &v,const MS &ms)
01039 #if(CXSC_INDEX_CHECK)
01040 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01041 #else
01042 throw();
01043 #endif
01044
01045
01046
01047 template <class M1,class M2,class E> friend E _mmcimult(const M1 &m1, const M2 &m2)
01048 #if(CXSC_INDEX_CHECK)
01049 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01050 #else
01051 throw();
01052 #endif
01053 template <class M,class MS,class E> friend E _mmscimult(const M &m1, const MS &ms)
01054 #if(CXSC_INDEX_CHECK)
01055 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01056 #else
01057 throw();
01058 #endif
01059 template <class MS,class M,class E> friend E _msmcimult(const MS &ms, const M &m2)
01060 #if(CXSC_INDEX_CHECK)
01061 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01062 #else
01063 throw();
01064 #endif
01065 template <class MS1,class MS2,class E> friend E _msmscimult(const MS1 &ms1, const MS2 &ms2)
01066 #if(CXSC_INDEX_CHECK)
01067 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01068 #else
01069 throw();
01070 #endif
01071
01072
01073 template <class M,class V,class E> friend E _mvcimult(const M &m,const V &v)
01074 #if(CXSC_INDEX_CHECK)
01075 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01076 #else
01077 throw();
01078 #endif
01079 template <class V,class M,class E> friend E _vmcimult(const V &v,const M &m)
01080 #if(CXSC_INDEX_CHECK)
01081 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01082 #else
01083 throw();
01084 #endif
01085
01086
01087
01088
01089
01090
01091
01092
01093
01094
01095
01096
01097
01098
01099 template <class M,class E> friend E _mre(const M &m) throw();
01100 template <class M,class E> friend E _mim(const M &m) throw();
01101 template <class MS,class E> friend E _msre(const MS &ms) throw();
01102 template <class MS,class E> friend E _msim(const MS &ms) throw();
01103 template <class M1,class M2> friend M1 &_mmsetre(M1 &m1,const M2 &m2)
01104 #if(CXSC_INDEX_CHECK)
01105 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01106 #else
01107 throw();
01108 #endif
01109 template <class M1,class M2> friend M1 &_mmsetim(M1 &m1,const M2 &m2)
01110 #if(CXSC_INDEX_CHECK)
01111 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01112 #else
01113 throw();
01114 #endif
01115 template <class MS1,class M2> friend MS1 &_msmsetre(MS1 &ms1,const M2 &m2)
01116 #if(CXSC_INDEX_CHECK)
01117 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01118 #else
01119 throw();
01120 #endif
01121 template <class MS1,class M2> friend MS1 &_msmsetim(MS1 &ms1,const M2 &m2)
01122 #if(CXSC_INDEX_CHECK)
01123 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01124 #else
01125 throw();
01126 #endif
01127
01128
01129 template <class M1,class M2,class S> friend M1 &_mmcimultassign(M1 &m1,const M2 &m2)
01130 #if(CXSC_INDEX_CHECK)
01131 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01132 #else
01133 throw();
01134 #endif
01135 template <class M,class MS,class S> friend M &_mmscimultassign(M &m1,const MS &ms)
01136 #if(CXSC_INDEX_CHECK)
01137 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01138 #else
01139 throw();
01140 #endif
01141
01142
01143 template <class V,class M,class S> friend V &_vmcimultassign(V &v,const M &m)
01144 #if(CXSC_INDEX_CHECK)
01145 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01146 #else
01147 throw();
01148 #endif
01149 template <class VS,class M,class S> friend VS &_vsmcimultassign(VS &v,const M &m)
01150 #if(CXSC_INDEX_CHECK)
01151 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01152 #else
01153 throw();
01154 #endif
01155
01156
01157
01158
01159
01160
01161
01162
01163
01164
01165
01166
01167
01168
01169
01170
01171 template <class M1,class M2,class E> friend E _mmlimult(const M1 &m1, const M2 &m2)
01172 #if(CXSC_INDEX_CHECK)
01173 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01174 #else
01175 throw();
01176 #endif
01177 template <class M,class MS,class E> friend E _mmslimult(const M &m1, const MS &ms)
01178 #if(CXSC_INDEX_CHECK)
01179 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01180 #else
01181 throw();
01182 #endif
01183 template <class MS,class M,class E> friend E _msmlimult(const MS &ms, const M &m2)
01184 #if(CXSC_INDEX_CHECK)
01185 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01186 #else
01187 throw();
01188 #endif
01189 template <class MS1,class MS2,class E> friend E _msmslimult(const MS1 &ms1, const MS2 &ms2)
01190 #if(CXSC_INDEX_CHECK)
01191 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01192 #else
01193 throw();
01194 #endif
01195
01196
01197 template <class M,class V,class E> friend E _mvlimult(const M &m,const V &v)
01198 #if(CXSC_INDEX_CHECK)
01199 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01200 #else
01201 throw();
01202 #endif
01203 template <class V,class M,class E> friend E _vmlimult(const V &v,const M &m)
01204 #if(CXSC_INDEX_CHECK)
01205 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01206 #else
01207 throw();
01208 #endif
01209
01210
01211
01212
01213
01214
01215
01216
01217
01218
01219
01220
01221
01222
01223 template <class M1,class M2,class S> friend M1 &_mmlimultassign(M1 &m1,const M2 &m2)
01224 #if(CXSC_INDEX_CHECK)
01225 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01226 #else
01227 throw();
01228 #endif
01229 template <class M,class MS,class S> friend M &_mmslimultassign(M &m1,const MS &ms)
01230 #if(CXSC_INDEX_CHECK)
01231 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01232 #else
01233 throw();
01234 #endif
01235
01236
01237 template <class V,class M,class S> friend V &_vmlimultassign(V &v,const M &m)
01238 #if(CXSC_INDEX_CHECK)
01239 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01240 #else
01241 throw();
01242 #endif
01243 template <class VS,class M,class S> friend VS &_vsmlimultassign(VS &v,const M &m)
01244 #if(CXSC_INDEX_CHECK)
01245 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01246 #else
01247 throw();
01248 #endif
01249
01250
01251
01252
01253
01254
01255
01256
01257
01258
01259
01260
01261
01262
01263 #endif
01264
01265
01266
01267
01269 INLINE imatrix(const imatrix &rm) throw();
01271 INLINE imatrix(const imatrix_slice &rm) throw();
01273 INLINE imatrix(const simatrix &rm);
01275 INLINE imatrix(const simatrix_slice &rm);
01277 INLINE imatrix() throw();
01279 explicit INLINE imatrix(const int &m, const int &n)
01280 #if(CXSC_INDEX_CHECK)
01281 throw(ERROR_IMATRIX_WRONG_BOUNDARIES);
01282 #else
01283 throw();
01284 #endif
01285
01286 explicit INLINE imatrix(const int &m1, const int &n1, const int &m2, const int &n2)
01287 #if(CXSC_INDEX_CHECK)
01288 throw(ERROR_IMATRIX_WRONG_BOUNDARIES);
01289 #else
01290 throw();
01291 #endif
01292
01293 explicit INLINE imatrix(const ivector &v) throw();
01295 explicit INLINE imatrix(const ivector_slice &v) throw();
01297 explicit INLINE imatrix(const interval &r) throw();
01299 INLINE imatrix &operator =(const interval &r) throw();
01301 INLINE imatrix &operator =(const imatrix &m) throw();
01303 INLINE imatrix &operator =(const imatrix_slice &ms) throw();
01305 INLINE imatrix &operator =(const simatrix &m);
01307 INLINE imatrix &operator =(const simatrix_slice &ms);
01309 INLINE imatrix &operator =(const ivector &v) throw();
01311 INLINE imatrix &operator =(const ivector_slice &v) throw();
01312
01314 explicit INLINE imatrix(const real &r) throw();
01316 explicit INLINE imatrix(const rmatrix &rm) throw();
01318 explicit INLINE imatrix(const rmatrix_slice &rm) throw();
01320 explicit INLINE imatrix(const srmatrix &rm);
01322 explicit INLINE imatrix(const srmatrix_slice &rm);
01324 explicit INLINE imatrix(const rvector &v) throw();
01326 explicit INLINE imatrix(const rvector_slice &v) throw();
01328 INLINE imatrix &operator =(const real &r) throw();
01330 INLINE imatrix &operator =(const rmatrix &m) throw();
01332 INLINE imatrix &operator =(const rmatrix_slice &ms) throw();
01334 INLINE imatrix &operator =(const srmatrix &m);
01336 INLINE imatrix &operator =(const srmatrix_slice &ms);
01338 INLINE imatrix &operator =(const rvector &v) throw();
01340 INLINE imatrix &operator =(const rvector_slice &v) throw();
01341
01342
01343
01344 INLINE ~imatrix() throw() { delete [] dat; }
01345
01346
01347
01349 INLINE imatrix &operator+=(const simatrix&);
01351 INLINE imatrix &operator+=(const simatrix_slice&);
01353 INLINE imatrix &operator+=(const srmatrix&);
01355 INLINE imatrix &operator+=(const srmatrix_slice&);
01357 INLINE imatrix &operator-=(const simatrix&);
01359 INLINE imatrix &operator-=(const simatrix_slice&);
01361 INLINE imatrix &operator-=(const srmatrix&);
01363 INLINE imatrix &operator-=(const srmatrix_slice&);
01365 INLINE imatrix &operator*=(const simatrix&);
01367 INLINE imatrix &operator*=(const simatrix_slice&);
01369 INLINE imatrix &operator*=(const srmatrix&);
01371 INLINE imatrix &operator*=(const srmatrix_slice&);
01373 INLINE imatrix &operator|=(const simatrix&);
01375 INLINE imatrix &operator|=(const simatrix_slice&);
01377 INLINE imatrix &operator|=(const srmatrix&);
01379 INLINE imatrix &operator|=(const srmatrix_slice&);
01381 INLINE imatrix &operator&=(const simatrix&);
01383 INLINE imatrix &operator&=(const simatrix_slice&);
01385 INLINE imatrix &operator&=(const srmatrix&);
01387 INLINE imatrix &operator&=(const srmatrix_slice&);
01388
01390 INLINE imatrix operator()(const intvector& p, const intvector& q);
01392 INLINE imatrix operator()(const intmatrix& P, const intmatrix& Q);
01394 INLINE imatrix operator()(const intvector& p);
01396 INLINE imatrix operator()(const intmatrix& P);
01397
01398
01399
01401 INLINE imatrix_subv operator [](const int &i) const
01402 #if(CXSC_INDEX_CHECK)
01403 throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT);
01404 #else
01405 throw();
01406 #endif
01407
01408 INLINE imatrix_subv operator [](const cxscmatrix_column &i) const
01409 #if(CXSC_INDEX_CHECK)
01410 throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT);
01411 #else
01412 throw();
01413 #endif
01414
01415 INLINE imatrix &operator ()() throw() { return *this; }
01417 INLINE imatrix_slice operator ()(const int &m, const int &n)
01418 #if(CXSC_INDEX_CHECK)
01419 throw(ERROR_IMATRIX_SUB_ARRAY_TOO_BIG);
01420 #else
01421 throw();
01422 #endif
01423
01424 INLINE imatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
01425 #if(CXSC_INDEX_CHECK)
01426 throw(ERROR_IMATRIX_SUB_ARRAY_TOO_BIG);
01427 #else
01428 throw();
01429 #endif
01430 INLINE operator void*() throw();
01431
01432
01433 };
01434
01436
01441 class imatrix_slice
01442 {
01443 friend class imatrix;
01444 friend class cimatrix;
01445 friend class l_imatrix;
01446 private:
01447 interval *dat;
01448 int offset1,offset2,mxsize,mysize;
01449 int start1,end1,start2,end2,sxsize,sysize;
01450
01451 public:
01452
01453 #ifdef _CXSC_FRIEND_TPL
01454
01455 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m)
01456 #if(CXSC_INDEX_CHECK)
01457 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>);
01458 #else
01459 throw();
01460 #endif
01461 template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m)
01462 #if(CXSC_INDEX_CHECK)
01463 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01464 #else
01465 throw();
01466 #endif
01467 template <class MS1,class MS2> friend MS1 &_msmsassign(MS1 &ms1,const MS2 &ms)
01468 #if(CXSC_INDEX_CHECK)
01469 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01470 #else
01471 throw();
01472 #endif
01473 template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) throw();
01474 template <class MS,class S> friend MS &_mssassign(MS &ms,const S &r) throw();
01475 template <class MS> friend int _mslb(const MS &ms, const int &i)
01476 #if(CXSC_INDEX_CHECK)
01477 throw(ERROR__WRONG_ROW_OR_COL<MS>);
01478 #else
01479 throw();
01480 #endif
01481 template <class MS> friend int _msub(const MS &ms, const int &i)
01482 #if(CXSC_INDEX_CHECK)
01483 throw(ERROR__WRONG_ROW_OR_COL<MS>);
01484 #else
01485 throw();
01486 #endif
01487 template <class MS,class E> friend E _msabs(const MS &ms) throw();
01488 template <class MS,class E> friend E _msdiam(const MS &ms) throw();
01489 template <class MS,class E> friend E _msmid(const MS &ms) throw();
01490 template <class MS,class E> friend E _msinf(const MS &ms) throw();
01491 template <class MS,class E> friend E _mssup(const MS &ms) throw();
01492 template <class MS1,class M2> friend MS1 &_msmsetinf(MS1 &ms1,const M2 &m2)
01493 #if(CXSC_INDEX_CHECK)
01494 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01495 #else
01496 throw();
01497 #endif
01498 template <class MS1,class M2> friend MS1 &_msmsetsup(MS1 &ms1,const M2 &m2)
01499 #if(CXSC_INDEX_CHECK)
01500 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01501 #else
01502 throw();
01503 #endif
01504 template <class MS1,class MS2> friend MS1 &_msmssetinf(MS1 &ms1,const MS2 &ms2)
01505 #if(CXSC_INDEX_CHECK)
01506 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01507 #else
01508 throw();
01509 #endif
01510 template <class MS1,class MS2> friend MS1 &_msmssetsup(MS1 &ms1,const MS2 &ms2)
01511 #if(CXSC_INDEX_CHECK)
01512 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01513 #else
01514 throw();
01515 #endif
01516 template <class MS1,class M2> friend MS1 &_msmusetinf(MS1 &ms1,const M2 &m2)
01517 #if(CXSC_INDEX_CHECK)
01518 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01519 #else
01520 throw();
01521 #endif
01522 template <class MS1,class M2> friend MS1 &_msmusetsup(MS1 &ms1,const M2 &m2)
01523 #if(CXSC_INDEX_CHECK)
01524 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01525 #else
01526 throw();
01527 #endif
01528 template <class MS1,class MS2> friend MS1 &_msmsusetinf(MS1 &ms1,const MS2 &ms2)
01529 #if(CXSC_INDEX_CHECK)
01530 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01531 #else
01532 throw();
01533 #endif
01534 template <class MS1,class MS2> friend MS1 &_msmsusetsup(MS1 &ms1,const MS2 &ms2)
01535 #if(CXSC_INDEX_CHECK)
01536 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01537 #else
01538 throw();
01539 #endif
01540
01541 template <class MS,class E> friend E _msminus(const MS &ms) throw();
01542 template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms)
01543 #if(CXSC_INDEX_CHECK)
01544 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01545 #else
01546 throw();
01547 #endif
01548 template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2)
01549 #if(CXSC_INDEX_CHECK)
01550 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01551 #else
01552 throw();
01553 #endif
01554 template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms)
01555 #if(CXSC_INDEX_CHECK)
01556 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01557 #else
01558 throw();
01559 #endif
01560 template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1)
01561 #if(CXSC_INDEX_CHECK)
01562 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01563 #else
01564 throw();
01565 #endif
01566 template <class MS1,class MS2> friend MS1 &_msmsplusassign(MS1 &ms1,const MS2 &ms2)
01567 #if(CXSC_INDEX_CHECK)
01568 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01569 #else
01570 throw();
01571 #endif
01572 template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms)
01573 #if(CXSC_INDEX_CHECK)
01574 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01575 #else
01576 throw();
01577 #endif
01578 template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m)
01579 #if(CXSC_INDEX_CHECK)
01580 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01581 #else
01582 throw();
01583 #endif
01584 template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2)
01585 #if(CXSC_INDEX_CHECK)
01586 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01587 #else
01588 throw();
01589 #endif
01590 template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms)
01591 #if(CXSC_INDEX_CHECK)
01592 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01593 #else
01594 throw();
01595 #endif
01596 template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1)
01597 #if(CXSC_INDEX_CHECK)
01598 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01599 #else
01600 throw();
01601 #endif
01602 template <class MS1,class MS2> friend MS1 &_msmsminusassign(MS1 &ms1,const MS2 &ms2)
01603 #if(CXSC_INDEX_CHECK)
01604 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01605 #else
01606 throw();
01607 #endif
01608 template <class M,class MS,class E> friend E _mmsimult(const M &m1, const MS &ms)
01609 #if(CXSC_INDEX_CHECK)
01610 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01611 #else
01612 throw();
01613 #endif
01614 template <class MS,class M,class E> friend E _msmimult(const MS &ms, const M &m2)
01615 #if(CXSC_INDEX_CHECK)
01616 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01617 #else
01618 throw();
01619 #endif
01620 template <class M,class MS,class S> friend M &_mmsimultassign(M &m1,const MS &ms)
01621 #if(CXSC_INDEX_CHECK)
01622 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01623 #else
01624 throw();
01625 #endif
01626 template <class MS1,class MS2,class E> friend E _msmsimult(const MS1 &ms1, const MS2 &ms2)
01627 #if(CXSC_INDEX_CHECK)
01628 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01629 #else
01630 throw();
01631 #endif
01632 template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms)
01633 #if(CXSC_INDEX_CHECK)
01634 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01635 #else
01636 throw();
01637 #endif
01638 template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms)
01639 #if(CXSC_INDEX_CHECK)
01640 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01641 #else
01642 throw();
01643 #endif
01644 template <class MS,class M> friend MS &_msmconvassign(MS &ms,const M &m1)
01645 #if(CXSC_INDEX_CHECK)
01646 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01647 #else
01648 throw();
01649 #endif
01650 template <class MS1,class MS2> friend MS1 &_msmsconvassign(MS1 &ms1,const MS2 &ms2)
01651 #if(CXSC_INDEX_CHECK)
01652 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01653 #else
01654 throw();
01655 #endif
01656 template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2)
01657 #if(CXSC_INDEX_CHECK)
01658 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01659 #else
01660 throw();
01661 #endif
01662 template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms)
01663 #if(CXSC_INDEX_CHECK)
01664 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01665 #else
01666 throw();
01667 #endif
01668 template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms)
01669 #if(CXSC_INDEX_CHECK)
01670 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01671 #else
01672 throw();
01673 #endif
01674 template <class MS,class M> friend MS &_msmsectassign(MS &ms,const M &m1)
01675 #if(CXSC_INDEX_CHECK)
01676 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01677 #else
01678 throw();
01679 #endif
01680 template <class MS1,class MS2> friend MS1 &_msmssectassign(MS1 &ms1,const MS2 &ms2)
01681 #if(CXSC_INDEX_CHECK)
01682 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01683 #else
01684 throw();
01685 #endif
01686 template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2)
01687 #if(CXSC_INDEX_CHECK)
01688 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01689 #else
01690 throw();
01691 #endif
01692
01693 template <class MS,class V,class E> friend E _msvimult(const MS &ms,const V &v)
01694 #if(CXSC_INDEX_CHECK)
01695 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01696 #else
01697 throw();
01698 #endif
01699 template <class V,class MS,class E> friend E _vmsimult(const V &v,const MS &ms)
01700 #if(CXSC_INDEX_CHECK)
01701 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01702 #else
01703 throw();
01704 #endif
01705 template <class V,class MS,class S> friend V &_vmsimultassign(V &v,const MS &ms)
01706 #if(CXSC_INDEX_CHECK)
01707 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01708 #else
01709 throw();
01710 #endif
01711
01712 template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) throw();
01713 template <class MS,class S> friend MS &_mssmultassign(MS &ms,const S &c) throw();
01714 template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) throw();
01715 template <class MS,class S> friend MS &_mssdivassign(MS &ms,const S &c) throw();
01716
01717 template <class MS> friend void *_msvoid(const MS &ms) throw();
01718 template <class MS> friend bool _msnot(const MS &ms) throw();
01719 template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) throw();
01720 template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) throw();
01721 template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) throw();
01722 template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) throw();
01723 template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) throw();
01724 template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) throw();
01725 template <class MS1,class MS2> friend bool _msmseq(const MS1 &ms1,const MS2 &ms2) throw();
01726 template <class MS1,class MS2> friend bool _msmsneq(const MS1 &ms1,const MS2 &ms2) throw();
01727 template <class MS1,class MS2> friend bool _msmsless(const MS1 &ms1,const MS2 &ms2) throw();
01728 template <class MS1,class MS2> friend bool _msmsleq(const MS1 &ms1,const MS2 &ms2) throw();
01729 template <class MS> friend std::ostream &_msout(std::ostream &s,const MS &r) throw();
01730 template <class MS> friend std::istream &_msin(std::istream &s,MS &r) throw();
01731
01732
01733
01734 template <class M,class MS,class E> friend E _mmscimult(const M &m1, const MS &ms)
01735 #if(CXSC_INDEX_CHECK)
01736 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01737 #else
01738 throw();
01739 #endif
01740 template <class MS,class M,class E> friend E _msmcimult(const MS &ms, const M &m2)
01741 #if(CXSC_INDEX_CHECK)
01742 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01743 #else
01744 throw();
01745 #endif
01746 template <class MS1,class MS2,class E> friend E _msmscimult(const MS1 &ms1, const MS2 &ms2)
01747 #if(CXSC_INDEX_CHECK)
01748 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01749 #else
01750 throw();
01751 #endif
01752
01753
01754 template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v)
01755 #if(CXSC_INDEX_CHECK)
01756 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01757 #else
01758 throw();
01759 #endif
01760 template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms)
01761 #if(CXSC_INDEX_CHECK)
01762 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01763 #else
01764 throw();
01765 #endif
01766
01767
01768 template <class M1,class MS2> friend M1 &_mmssetre(M1 &m1,const MS2 &ms2)
01769 #if(CXSC_INDEX_CHECK)
01770 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01771 #else
01772 throw();
01773 #endif
01774 template <class M1,class MS2> friend M1 &_mmssetim(M1 &m1,const MS2 &ms2)
01775 #if(CXSC_INDEX_CHECK)
01776 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01777 #else
01778 throw();
01779 #endif
01780 template <class MS1,class MS2> friend MS1 &_msmssetre(MS1 &ms1,const MS2 &ms2)
01781 #if(CXSC_INDEX_CHECK)
01782 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01783 #else
01784 throw();
01785 #endif
01786 template <class MS1,class MS2> friend MS1 &_msmssetim(MS1 &ms1,const MS2 &ms2)
01787 #if(CXSC_INDEX_CHECK)
01788 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01789 #else
01790 throw();
01791 #endif
01792
01793 template <class M,class MS,class S> friend M &_mmscimultassign(M &m1,const MS &ms)
01794 #if(CXSC_INDEX_CHECK)
01795 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01796 #else
01797 throw();
01798 #endif
01799
01800
01801 template <class V,class MS,class S> friend V &_vmscimultassign(V &v,const MS &ms)
01802 #if(CXSC_INDEX_CHECK)
01803 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01804 #else
01805 throw();
01806 #endif
01807
01808
01809
01810
01811
01812
01813
01814
01815
01816
01817
01818
01819
01820
01821
01822
01823
01824
01825
01826
01827
01828
01829 template <class M,class MS,class E> friend E _mmslimult(const M &m1, const MS &ms)
01830 #if(CXSC_INDEX_CHECK)
01831 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01832 #else
01833 throw();
01834 #endif
01835 template <class MS,class M,class E> friend E _msmlimult(const MS &ms, const M &m2)
01836 #if(CXSC_INDEX_CHECK)
01837 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01838 #else
01839 throw();
01840 #endif
01841 template <class MS1,class MS2,class E> friend E _msmslimult(const MS1 &ms1, const MS2 &ms2)
01842 #if(CXSC_INDEX_CHECK)
01843 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01844 #else
01845 throw();
01846 #endif
01847
01848
01849 template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v)
01850 #if(CXSC_INDEX_CHECK)
01851 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01852 #else
01853 throw();
01854 #endif
01855 template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms)
01856 #if(CXSC_INDEX_CHECK)
01857 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01858 #else
01859 throw();
01860 #endif
01861
01862
01863 template <class M,class MS,class S> friend M &_mmslimultassign(M &m1,const MS &ms)
01864 #if(CXSC_INDEX_CHECK)
01865 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01866 #else
01867 throw();
01868 #endif
01869
01870
01871 template <class V,class MS,class S> friend V &_vmslimultassign(V &v,const MS &ms)
01872 #if(CXSC_INDEX_CHECK)
01873 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01874 #else
01875 throw();
01876 #endif
01877
01878
01879
01880
01881
01882
01883
01884
01885
01886
01887
01888
01889
01890
01891
01892
01893
01894
01895
01896 #endif
01897
01898
01899
01901 explicit INLINE imatrix_slice(imatrix &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) { }
01903 explicit INLINE imatrix_slice(imatrix_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) { }
01904 public:
01906 INLINE imatrix_slice(const imatrix_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) { }
01907 public:
01908
01909
01910
01911 friend INLINE ivector::ivector(const imatrix_slice &sl)
01912 #if(CXSC_INDEX_CHECK)
01913 throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
01914 #else
01915 throw();
01916 #endif
01917 friend INLINE imatrix::imatrix(const imatrix_slice &) throw();
01919 INLINE imatrix_slice &operator =(const imatrix &m)
01920 #if(CXSC_INDEX_CHECK)
01921 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01922 #else
01923 throw();
01924 #endif
01925
01926 INLINE imatrix_slice &operator =(const imatrix_slice &ms)
01927 #if(CXSC_INDEX_CHECK)
01928 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01929 #else
01930 throw();
01931 #endif
01932
01933 INLINE imatrix_slice &operator =(const interval &r) throw();
01935 INLINE imatrix_slice &operator =(const ivector &v)
01936 #if(CXSC_INDEX_CHECK)
01937 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01938 #else
01939 throw();
01940 #endif
01941
01942 INLINE imatrix_slice &operator =(const ivector_slice &v)
01943 #if(CXSC_INDEX_CHECK)
01944 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01945 #else
01946 throw();
01947 #endif
01948
01949 INLINE imatrix_slice &operator =(const rmatrix &m)
01950 #if(CXSC_INDEX_CHECK)
01951 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01952 #else
01953 throw();
01954 #endif
01955
01956 INLINE imatrix_slice &operator =(const rmatrix_slice &ms)
01957 #if(CXSC_INDEX_CHECK)
01958 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01959 #else
01960 throw();
01961 #endif
01962
01963 INLINE imatrix_slice &operator =(const real &r) throw();
01965 INLINE imatrix_slice &operator =(const rvector &v)
01966 #if(CXSC_INDEX_CHECK)
01967 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01968 #else
01969 throw();
01970 #endif
01971
01972 INLINE imatrix_slice &operator =(const rvector_slice &v)
01973 #if(CXSC_INDEX_CHECK)
01974 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01975 #else
01976 throw();
01977 #endif
01978
01979 INLINE imatrix_subv operator [](const int &i)
01980 #if(CXSC_INDEX_CHECK)
01981 throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT);
01982 #else
01983 throw();
01984 #endif
01985
01986 INLINE imatrix_subv operator [](const cxscmatrix_column &i)
01987 #if(CXSC_INDEX_CHECK)
01988 throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT);
01989 #else
01990 throw();
01991 #endif
01992
01994 INLINE imatrix_subv operator [](const int &i) const
01995 #if(CXSC_INDEX_CHECK)
01996 throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT);
01997 #else
01998 throw();
01999 #endif
02000
02001 INLINE imatrix_subv operator [](const cxscmatrix_column &i) const
02002 #if(CXSC_INDEX_CHECK)
02003 throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT);
02004 #else
02005 throw();
02006 #endif
02007
02008
02010 INLINE imatrix_slice &operator ()() throw() { return *this; }
02012 INLINE imatrix_slice operator ()(const int &m, const int &n)
02013 #if(CXSC_INDEX_CHECK)
02014 throw(ERROR_IMATRIX_SUB_ARRAY_TOO_BIG);
02015 #else
02016 throw();
02017 #endif
02018
02019 INLINE imatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
02020 #if(CXSC_INDEX_CHECK)
02021 throw(ERROR_IMATRIX_SUB_ARRAY_TOO_BIG);
02022 #else
02023 throw();
02024 #endif
02025
02026 INLINE imatrix_slice &operator *=(const imatrix &m)
02027 #if(CXSC_INDEX_CHECK)
02028 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02029 #else
02030 throw();
02031 #endif
02032
02033 INLINE imatrix_slice &operator *=(const rmatrix &m)
02034 #if(CXSC_INDEX_CHECK)
02035 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02036 #else
02037 throw();
02038 #endif
02039
02040 INLINE imatrix_slice &operator *=(const imatrix_slice &ms2)
02041 #if(CXSC_INDEX_CHECK)
02042 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02043 #else
02044 throw();
02045 #endif
02046
02047 INLINE imatrix_slice &operator *=(const rmatrix_slice &ms2)
02048 #if(CXSC_INDEX_CHECK)
02049 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02050 #else
02051 throw();
02052 #endif
02053
02054 INLINE imatrix_slice &operator +=(const imatrix &m1)
02055 #if(CXSC_INDEX_CHECK)
02056 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02057 #else
02058 throw();
02059 #endif
02060
02061 INLINE imatrix_slice &operator +=(const rmatrix &m1)
02062 #if(CXSC_INDEX_CHECK)
02063 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02064 #else
02065 throw();
02066 #endif
02067
02068 INLINE imatrix_slice &operator +=(const imatrix_slice &ms2)
02069 #if(CXSC_INDEX_CHECK)
02070 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02071 #else
02072 throw();
02073 #endif
02074
02075 INLINE imatrix_slice &operator +=(const rmatrix_slice &ms2)
02076 #if(CXSC_INDEX_CHECK)
02077 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02078 #else
02079 throw();
02080 #endif
02081
02082 INLINE imatrix_slice &operator -=(const imatrix &m1)
02083 #if(CXSC_INDEX_CHECK)
02084 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02085 #else
02086 throw();
02087 #endif
02088
02089 INLINE imatrix_slice &operator -=(const rmatrix &m1)
02090 #if(CXSC_INDEX_CHECK)
02091 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02092 #else
02093 throw();
02094 #endif
02095
02096 INLINE imatrix_slice &operator -=(const imatrix_slice &ms2)
02097 #if(CXSC_INDEX_CHECK)
02098 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02099 #else
02100 throw();
02101 #endif
02102
02103 INLINE imatrix_slice &operator -=(const rmatrix_slice &ms2)
02104 #if(CXSC_INDEX_CHECK)
02105 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02106 #else
02107 throw();
02108 #endif
02109
02110 INLINE imatrix_slice &operator |=(const imatrix &m1)
02111 #if(CXSC_INDEX_CHECK)
02112 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02113 #else
02114 throw();
02115 #endif
02116
02117 INLINE imatrix_slice &operator |=(const rmatrix &m1)
02118 #if(CXSC_INDEX_CHECK)
02119 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02120 #else
02121 throw();
02122 #endif
02123
02124 INLINE imatrix_slice &operator |=(const imatrix_slice &ms2)
02125 #if(CXSC_INDEX_CHECK)
02126 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02127 #else
02128 throw();
02129 #endif
02130
02131 INLINE imatrix_slice &operator |=(const rmatrix_slice &ms2)
02132 #if(CXSC_INDEX_CHECK)
02133 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02134 #else
02135 throw();
02136 #endif
02137
02138 INLINE imatrix_slice &operator &=(const imatrix &m1)
02139 #if(CXSC_INDEX_CHECK)
02140 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02141 #else
02142 throw();
02143 #endif
02144
02145 INLINE imatrix_slice &operator &=(const rmatrix &m1)
02146 #if(CXSC_INDEX_CHECK)
02147 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02148 #else
02149 throw();
02150 #endif
02151
02152 INLINE imatrix_slice &operator &=(const imatrix_slice &ms2)
02153 #if(CXSC_INDEX_CHECK)
02154 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02155 #else
02156 throw();
02157 #endif
02158
02159 INLINE imatrix_slice &operator &=(const rmatrix_slice &ms2)
02160 #if(CXSC_INDEX_CHECK)
02161 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02162 #else
02163 throw();
02164 #endif
02165
02166 INLINE imatrix_slice &operator *=(const interval &c) throw();
02168 INLINE imatrix_slice &operator *=(const real &c) throw();
02170 INLINE imatrix_slice &operator /=(const interval &c) throw();
02172 INLINE imatrix_slice &operator /=(const real &c) throw();
02173 INLINE operator void*() throw();
02174
02175
02177 INLINE imatrix_slice &operator+=(const simatrix&);
02179 INLINE imatrix_slice &operator+=(const simatrix_slice&);
02181 INLINE imatrix_slice &operator+=(const srmatrix&);
02183 INLINE imatrix_slice &operator+=(const srmatrix_slice&);
02185 INLINE imatrix_slice &operator-=(const simatrix&);
02187 INLINE imatrix_slice &operator-=(const simatrix_slice&);
02189 INLINE imatrix_slice &operator-=(const srmatrix&);
02191 INLINE imatrix_slice &operator-=(const srmatrix_slice&);
02193 INLINE imatrix_slice &operator*=(const simatrix&);
02195 INLINE imatrix_slice &operator*=(const simatrix_slice&);
02197 INLINE imatrix_slice &operator*=(const srmatrix&);
02199 INLINE imatrix_slice &operator*=(const srmatrix_slice&);
02201 INLINE imatrix_slice &operator|=(const simatrix&);
02203 INLINE imatrix_slice &operator|=(const simatrix_slice&);
02205 INLINE imatrix_slice &operator|=(const srmatrix&);
02207 INLINE imatrix_slice &operator|=(const srmatrix_slice&);
02209 INLINE imatrix_slice &operator&=(const simatrix&);
02211 INLINE imatrix_slice &operator&=(const simatrix_slice&);
02213 INLINE imatrix_slice &operator&=(const srmatrix&);
02215 INLINE imatrix_slice &operator&=(const srmatrix_slice&);
02216
02217
02218
02219 };
02220
02221
02222
02223
02224
02225
02227 INLINE ivector operator /(const imatrix_subv &rv, const interval &s) throw();
02229 INLINE ivector operator *(const imatrix_subv &rv, const interval &s) throw();
02231 INLINE ivector operator *(const interval &s, const imatrix_subv &rv) throw();
02233 INLINE ivector abs(const imatrix_subv &mv) throw();
02235 INLINE rvector absmin(const imatrix_subv &mv) throw();
02237 INLINE rvector absmax(const imatrix_subv &mv) throw();
02239 INLINE rvector diam(const imatrix_subv &mv) throw();
02241 INLINE rvector mid(const imatrix_subv &mv) throw();
02243 INLINE rvector Inf(const imatrix_subv &mv) throw();
02245 INLINE rvector Sup(const imatrix_subv &mv) throw();
02246
02247
02248
02249
02250
02252 INLINE imatrix_subv &SetInf(imatrix_subv &mv,const rvector &rv)
02253 #if(CXSC_INDEX_CHECK)
02254 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02255 #else
02256 throw();
02257 #endif
02258
02259 INLINE imatrix_subv &SetSup(imatrix_subv &mv,const rvector &rv)
02260 #if(CXSC_INDEX_CHECK)
02261 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02262 #else
02263 throw();
02264 #endif
02265
02266 INLINE imatrix_subv &UncheckedSetInf(imatrix_subv &mv,const rvector &rv)
02267 #if(CXSC_INDEX_CHECK)
02268 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02269 #else
02270 throw();
02271 #endif
02272
02273 INLINE imatrix_subv &UncheckedSetSup(imatrix_subv &mv,const rvector &rv)
02274 #if(CXSC_INDEX_CHECK)
02275 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02276 #else
02277 throw();
02278 #endif
02279
02280 INLINE imatrix_subv &SetSup(imatrix_subv &iv,const real &r) throw();
02282 INLINE imatrix_subv &SetInf(imatrix_subv &iv,const real &r) throw();
02284 INLINE imatrix_subv &UncheckedSetSup(imatrix_subv &iv,const real &r) throw();
02286 INLINE imatrix_subv &SetUncheckedInf(imatrix_subv &iv,const real &r) throw();
02287
02288
02290 void accumulate(idotprecision &dp, const imatrix_subv & rv1, const imatrix_subv &rv2)
02291 #if(CXSC_INDEX_CHECK)
02292 throw(OP_WITH_WRONG_DIM);
02293 #else
02294 throw();
02295 #endif
02296
02297 void accumulate(idotprecision &dp, const ivector & rv1, const imatrix_subv &rv2)
02298 #if(CXSC_INDEX_CHECK)
02299 throw(OP_WITH_WRONG_DIM);
02300 #else
02301 throw();
02302 #endif
02303
02304 void accumulate(idotprecision &dp, const imatrix_subv & rv1, const ivector &rv2)
02305 #if(CXSC_INDEX_CHECK)
02306 throw(OP_WITH_WRONG_DIM);
02307 #else
02308 throw();
02309 #endif
02310
02311 void accumulate(idotprecision &dp, const ivector_slice & sl1, const imatrix_subv &rv2)
02312 #if(CXSC_INDEX_CHECK)
02313 throw(OP_WITH_WRONG_DIM);
02314 #else
02315 throw();
02316 #endif
02317
02318 void accumulate(idotprecision &dp, const imatrix_subv & rv1, const ivector_slice &sl2)
02319 #if(CXSC_INDEX_CHECK)
02320 throw(OP_WITH_WRONG_DIM);
02321 #else
02322 throw();
02323 #endif
02324
02326 void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const imatrix_subv &rv2)
02327 #if(CXSC_INDEX_CHECK)
02328 throw(OP_WITH_WRONG_DIM);
02329 #else
02330 throw();
02331 #endif
02332
02333 void accumulate(cidotprecision &dp, const ivector & rv1, const imatrix_subv &rv2)
02334 #if(CXSC_INDEX_CHECK)
02335 throw(OP_WITH_WRONG_DIM);
02336 #else
02337 throw();
02338 #endif
02339
02340 void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const ivector &rv2)
02341 #if(CXSC_INDEX_CHECK)
02342 throw(OP_WITH_WRONG_DIM);
02343 #else
02344 throw();
02345 #endif
02346
02347 void accumulate(cidotprecision &dp, const ivector_slice & sl1, const imatrix_subv &rv2)
02348 #if(CXSC_INDEX_CHECK)
02349 throw(OP_WITH_WRONG_DIM);
02350 #else
02351 throw();
02352 #endif
02353
02354 void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const ivector_slice &sl2)
02355 #if(CXSC_INDEX_CHECK)
02356 throw(OP_WITH_WRONG_DIM);
02357 #else
02358 throw();
02359 #endif
02360
02362 INLINE interval operator *(const imatrix_subv & rv1, const imatrix_subv &rv2)
02363 #if(CXSC_INDEX_CHECK)
02364 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
02365 #else
02366 throw();
02367 #endif
02368
02369 INLINE interval operator *(const ivector & rv1, const imatrix_subv &rv2)
02370 #if(CXSC_INDEX_CHECK)
02371 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
02372 #else
02373 throw();
02374 #endif
02375
02376 INLINE interval operator *(const imatrix_subv &rv1,const ivector &rv2)
02377 #if(CXSC_INDEX_CHECK)
02378 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
02379 #else
02380 throw();
02381 #endif
02382
02383 INLINE interval operator *(const ivector_slice &sl,const imatrix_subv &sv)
02384 #if(CXSC_INDEX_CHECK)
02385 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
02386 #else
02387 throw();
02388 #endif
02389
02390 INLINE interval operator *(const imatrix_subv &mv,const ivector_slice &vs)
02391 #if(CXSC_INDEX_CHECK)
02392 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
02393 #else
02394 throw();
02395 #endif
02396
02398 INLINE ivector operator +(const imatrix_subv & rv1, const imatrix_subv &rv2)
02399 #if(CXSC_INDEX_CHECK)
02400 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
02401 #else
02402 throw();
02403 #endif
02404
02405 INLINE ivector operator +(const imatrix_subv &rv1,const ivector &rv2)
02406 #if(CXSC_INDEX_CHECK)
02407 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
02408 #else
02409 throw();
02410 #endif
02411
02412 INLINE ivector operator +(const ivector & rv1, const imatrix_subv &rv2)
02413 #if(CXSC_INDEX_CHECK)
02414 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
02415 #else
02416 throw();
02417 #endif
02418
02419 INLINE ivector operator +(const ivector_slice &sl,const imatrix_subv &mv)
02420 #if(CXSC_INDEX_CHECK)
02421 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
02422 #else
02423 throw();
02424 #endif
02425
02426 INLINE ivector operator +(const imatrix_subv &mv,const ivector_slice &sl)
02427 #if(CXSC_INDEX_CHECK)
02428 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
02429 #else
02430 throw();
02431 #endif
02432
02434 INLINE ivector operator -(const imatrix_subv & rv1, const imatrix_subv &rv2)
02435 #if(CXSC_INDEX_CHECK)
02436 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
02437 #else
02438 throw();
02439 #endif
02440
02441 INLINE ivector operator -(const ivector & rv1, const imatrix_subv &rv2)
02442 #if(CXSC_INDEX_CHECK)
02443 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
02444 #else
02445 throw();
02446 #endif
02447
02448 INLINE ivector operator -(const imatrix_subv &rv1,const ivector &rv2)
02449 #if(CXSC_INDEX_CHECK)
02450 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
02451 #else
02452 throw();
02453 #endif
02454
02455 INLINE ivector operator -(const ivector_slice &sl,const imatrix_subv &mv)
02456 #if(CXSC_INDEX_CHECK)
02457 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
02458 #else
02459 throw();
02460 #endif
02461
02462 INLINE ivector operator -(const imatrix_subv &mv,const ivector_slice &sl)
02463 #if(CXSC_INDEX_CHECK)
02464 throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
02465 #else
02466 throw();
02467 #endif
02468
02469
02470
02472 void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const imatrix_subv &rv2)
02473 #if(CXSC_INDEX_CHECK)
02474 throw(OP_WITH_WRONG_DIM);
02475 #else
02476 throw();
02477 #endif
02478
02479 void accumulate(idotprecision &dp, const rvector & rv1, const imatrix_subv &rv2)
02480 #if(CXSC_INDEX_CHECK)
02481 throw(OP_WITH_WRONG_DIM);
02482 #else
02483 throw();
02484 #endif
02485
02486 void accumulate(idotprecision &dp, const rvector_slice & sl1, const imatrix_subv &rv2)
02487 #if(CXSC_INDEX_CHECK)
02488 throw(OP_WITH_WRONG_DIM);
02489 #else
02490 throw();
02491 #endif
02492
02494 void accumulate(idotprecision &dp, const imatrix_subv & rv1, const rmatrix_subv &rv2)
02495 #if(CXSC_INDEX_CHECK)
02496 throw(OP_WITH_WRONG_DIM);
02497 #else
02498 throw();
02499 #endif
02500
02501 void accumulate(idotprecision &dp, const imatrix_subv & rv1, const rvector &rv2)
02502 #if(CXSC_INDEX_CHECK)
02503 throw(OP_WITH_WRONG_DIM);
02504 #else
02505 throw();
02506 #endif
02507
02508 void accumulate(idotprecision &dp, const imatrix_subv & rv1, const rvector_slice &sl2)
02509 #if(CXSC_INDEX_CHECK)
02510 throw(OP_WITH_WRONG_DIM);
02511 #else
02512 throw();
02513 #endif
02514
02516 void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const imatrix_subv &rv2)
02517 #if(CXSC_INDEX_CHECK)
02518 throw(OP_WITH_WRONG_DIM);
02519 #else
02520 throw();
02521 #endif
02522
02523 void accumulate(cidotprecision &dp, const rvector & rv1, const imatrix_subv &rv2)
02524 #if(CXSC_INDEX_CHECK)
02525 throw(OP_WITH_WRONG_DIM);
02526 #else
02527 throw();
02528 #endif
02529
02530 void accumulate(cidotprecision &dp, const rvector_slice & sl1, const imatrix_subv &rv2)
02531 #if(CXSC_INDEX_CHECK)
02532 throw(OP_WITH_WRONG_DIM);
02533 #else
02534 throw();
02535 #endif
02536
02538 void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const rmatrix_subv &rv2)
02539 #if(CXSC_INDEX_CHECK)
02540 throw(OP_WITH_WRONG_DIM);
02541 #else
02542 throw();
02543 #endif
02544
02545 void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const rvector &rv2)
02546 #if(CXSC_INDEX_CHECK)
02547 throw(OP_WITH_WRONG_DIM);
02548 #else
02549 throw();
02550 #endif
02551
02552 void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const rvector_slice &sl2)
02553 #if(CXSC_INDEX_CHECK)
02554 throw(OP_WITH_WRONG_DIM);
02555 #else
02556 throw();
02557 #endif
02558
02559
02560
02562 void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const imatrix_subv &rv2)
02563 #if(CXSC_INDEX_CHECK)
02564 throw(OP_WITH_WRONG_DIM);
02565 #else
02566 throw();
02567 #endif
02568
02569 void accumulate(cidotprecision &dp, const cvector & rv1, const imatrix_subv &rv2)
02570 #if(CXSC_INDEX_CHECK)
02571 throw(OP_WITH_WRONG_DIM);
02572 #else
02573 throw();
02574 #endif
02575
02576 void accumulate(cidotprecision &dp, const cvector_slice & sl1, const imatrix_subv &rv2)
02577 #if(CXSC_INDEX_CHECK)
02578 throw(OP_WITH_WRONG_DIM);
02579 #else
02580 throw();
02581 #endif
02582
02584 void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const cmatrix_subv &rv2)
02585 #if(CXSC_INDEX_CHECK)
02586 throw(OP_WITH_WRONG_DIM);
02587 #else
02588 throw();
02589 #endif
02590
02591 void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const cvector &rv2)
02592 #if(CXSC_INDEX_CHECK)
02593 throw(OP_WITH_WRONG_DIM);
02594 #else
02595 throw();
02596 #endif
02597
02598 void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const cvector_slice &sl2)
02599 #if(CXSC_INDEX_CHECK)
02600 throw(OP_WITH_WRONG_DIM);
02601 #else
02602 throw();
02603 #endif
02604
02605
02606
02608 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const imatrix_subv &rv2)
02609 #if(CXSC_INDEX_CHECK)
02610 throw(OP_WITH_WRONG_DIM);
02611 #else
02612 throw();
02613 #endif
02614
02615 void accumulate(cidotprecision &dp, const civector & rv1, const imatrix_subv &rv2)
02616 #if(CXSC_INDEX_CHECK)
02617 throw(OP_WITH_WRONG_DIM);
02618 #else
02619 throw();
02620 #endif
02621
02622 void accumulate(cidotprecision &dp, const civector_slice & sl1, const imatrix_subv &rv2)
02623 #if(CXSC_INDEX_CHECK)
02624 throw(OP_WITH_WRONG_DIM);
02625 #else
02626 throw();
02627 #endif
02628
02630 void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const cimatrix_subv &rv2)
02631 #if(CXSC_INDEX_CHECK)
02632 throw(OP_WITH_WRONG_DIM);
02633 #else
02634 throw();
02635 #endif
02636
02637 void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const civector &rv2)
02638 #if(CXSC_INDEX_CHECK)
02639 throw(OP_WITH_WRONG_DIM);
02640 #else
02641 throw();
02642 #endif
02643
02644 void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const civector_slice &sl2)
02645 #if(CXSC_INDEX_CHECK)
02646 throw(OP_WITH_WRONG_DIM);
02647 #else
02648 throw();
02649 #endif
02650
02651
02652
02653
02654
02656 INLINE imatrix _imatrix(const imatrix &rm) throw();
02658 INLINE imatrix _imatrix(const ivector &v) throw();
02660 INLINE imatrix _imatrix(const ivector_slice &v) throw();
02662 INLINE imatrix _imatrix(const interval &r) throw();
02663
02665 INLINE int Lb(const imatrix &rm, const int &i)
02666 #if(CXSC_INDEX_CHECK)
02667 throw(ERROR_IMATRIX_WRONG_ROW_OR_COL);
02668 #else
02669 throw();
02670 #endif
02671
02672 INLINE int Ub(const imatrix &rm, const int &i)
02673 #if(CXSC_INDEX_CHECK)
02674 throw(ERROR_IMATRIX_WRONG_ROW_OR_COL);
02675 #else
02676 throw();
02677 #endif
02678
02679 INLINE int Lb(const imatrix_slice &rm, const int &i)
02680 #if(CXSC_INDEX_CHECK)
02681 throw(ERROR_IMATRIX_WRONG_ROW_OR_COL);
02682 #else
02683 throw();
02684 #endif
02685
02686 INLINE int Ub(const imatrix_slice &rm, const int &i)
02687 #if(CXSC_INDEX_CHECK)
02688 throw(ERROR_IMATRIX_WRONG_ROW_OR_COL);
02689 #else
02690 throw();
02691 #endif
02692
02693 INLINE imatrix &SetLb(imatrix &m, const int &i,const int &j)
02694 #if(CXSC_INDEX_CHECK)
02695 throw(ERROR_IMATRIX_WRONG_ROW_OR_COL);
02696 #else
02697 throw();
02698 #endif
02699
02700 INLINE imatrix &SetUb(imatrix &m, const int &i,const int &j)
02701 #if(CXSC_INDEX_CHECK)
02702 throw(ERROR_IMATRIX_WRONG_ROW_OR_COL);
02703 #else
02704 throw();
02705 #endif
02706
02707 INLINE void Resize(imatrix &A) throw();
02709 INLINE void Resize(imatrix &A,const int &m, const int &n)
02710 #if(CXSC_INDEX_CHECK)
02711 throw(ERROR_IMATRIX_WRONG_BOUNDARIES);
02712 #else
02713 throw();
02714 #endif
02715
02716 INLINE void Resize(imatrix &A,const int &m1, const int &m2,const int &n1,const int &n2)
02717 #if(CXSC_INDEX_CHECK)
02718 throw(ERROR_IMATRIX_WRONG_BOUNDARIES);
02719 #else
02720 throw();
02721 #endif
02722
02724 INLINE imatrix abs(const imatrix &m) throw();
02726 INLINE rmatrix absmin(const imatrix &m) throw();
02728 INLINE rmatrix absmax(const imatrix &m) throw();
02730 INLINE imatrix abs(const imatrix_slice &ms) throw();
02732 INLINE rmatrix absmin(const imatrix_slice &ms) throw();
02734 INLINE rmatrix absmax(const imatrix_slice &ms) throw();
02736 INLINE rmatrix diam(const imatrix &m) throw();
02738 INLINE rmatrix diam(const imatrix_slice &ms) throw();
02740 INLINE rmatrix mid(const imatrix &m) throw();
02742 INLINE rmatrix mid(const imatrix_slice &ms) throw();
02744 INLINE rmatrix Inf(const imatrix &m) throw();
02746 INLINE rmatrix Sup(const imatrix &m) throw();
02748 INLINE rmatrix Inf(const imatrix_slice &m) throw();
02750 INLINE rmatrix Sup(const imatrix_slice &m) throw();
02752 INLINE imatrix &SetInf(imatrix &cm,const rmatrix &rm)
02753 #if(CXSC_INDEX_CHECK)
02754 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02755 #else
02756 throw();
02757 #endif
02758
02759 INLINE imatrix_slice &SetInf(imatrix_slice &cm,const rmatrix &rm)
02760 #if(CXSC_INDEX_CHECK)
02761 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02762 #else
02763 throw();
02764 #endif
02765
02766 INLINE imatrix &SetInf(imatrix &cm,const rmatrix_slice &rm)
02767 #if(CXSC_INDEX_CHECK)
02768 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02769 #else
02770 throw();
02771 #endif
02772
02773 INLINE imatrix_slice &SetInf(imatrix_slice &cm,const rmatrix_slice &rm)
02774 #if(CXSC_INDEX_CHECK)
02775 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02776 #else
02777 throw();
02778 #endif
02779
02780 INLINE imatrix &SetSup(imatrix &cm,const rmatrix &rm)
02781 #if(CXSC_INDEX_CHECK)
02782 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02783 #else
02784 throw();
02785 #endif
02786
02787 INLINE imatrix_slice &SetSup(imatrix_slice &cm,const rmatrix &rm)
02788 #if(CXSC_INDEX_CHECK)
02789 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02790 #else
02791 throw();
02792 #endif
02793
02794 INLINE imatrix &SetSup(imatrix &cm,const rmatrix_slice &rm)
02795 #if(CXSC_INDEX_CHECK)
02796 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02797 #else
02798 throw();
02799 #endif
02800
02801 INLINE imatrix_slice &SetSup(imatrix_slice &cm,const rmatrix_slice &rm)
02802 #if(CXSC_INDEX_CHECK)
02803 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02804 #else
02805 throw();
02806 #endif
02807
02808 INLINE imatrix &UncheckedSetInf(imatrix &cm,const rmatrix &rm)
02809 #if(CXSC_INDEX_CHECK)
02810 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02811 #else
02812 throw();
02813 #endif
02814
02815 INLINE imatrix_slice &UncheckedSetInf(imatrix_slice &cm,const rmatrix &rm)
02816 #if(CXSC_INDEX_CHECK)
02817 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02818 #else
02819 throw();
02820 #endif
02821
02822 INLINE imatrix &UncheckedSetInf(imatrix &cm,const rmatrix_slice &rm)
02823 #if(CXSC_INDEX_CHECK)
02824 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02825 #else
02826 throw();
02827 #endif
02828
02829 INLINE imatrix_slice &UncheckedSetInf(imatrix_slice &cm,const rmatrix_slice &rm)
02830 #if(CXSC_INDEX_CHECK)
02831 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02832 #else
02833 throw();
02834 #endif
02835
02836 INLINE imatrix &UncheckedSetSup(imatrix &cm,const rmatrix &rm)
02837 #if(CXSC_INDEX_CHECK)
02838 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02839 #else
02840 throw();
02841 #endif
02842
02843 INLINE imatrix_slice &UncheckedSetSup(imatrix_slice &cm,const rmatrix &rm)
02844 #if(CXSC_INDEX_CHECK)
02845 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02846 #else
02847 throw();
02848 #endif
02849
02850 INLINE imatrix &UncheckedSetSup(imatrix &cm,const rmatrix_slice &rm)
02851 #if(CXSC_INDEX_CHECK)
02852 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02853 #else
02854 throw();
02855 #endif
02856
02857 INLINE imatrix_slice &UncheckedSetSup(imatrix_slice &cm,const rmatrix_slice &rm)
02858 #if(CXSC_INDEX_CHECK)
02859 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02860 #else
02861 throw();
02862 #endif
02863
02864
02865
02867 INLINE imatrix operator *(const interval &c, const imatrix &m) throw();
02869 INLINE imatrix operator *(const interval &c, const imatrix_slice &ms) throw();
02871 INLINE imatrix operator *(const imatrix &m,const interval &c) throw();
02873 INLINE imatrix operator *(const imatrix_slice &ms,const interval &c) throw();
02875 INLINE imatrix &operator *=(imatrix &m,const interval &c) throw();
02877 INLINE imatrix operator /(const imatrix &m,const interval &c) throw();
02879 INLINE imatrix operator /(const imatrix_slice &ms, const interval &c) throw();
02881 INLINE imatrix &operator /=(imatrix &m,const interval &c) throw();
02882
02883
02884
02886 INLINE imatrix operator *(const real &c, const imatrix &m) throw();
02888 INLINE imatrix operator *(const real &c, const imatrix_slice &ms) throw();
02890 INLINE imatrix operator *(const imatrix &m,const real &c) throw();
02892 INLINE imatrix operator *(const imatrix_slice &ms,const real &c) throw();
02894 INLINE imatrix &operator *=(imatrix &m,const real &c) throw();
02896 INLINE imatrix operator /(const imatrix &m,const real &c) throw();
02898 INLINE imatrix operator /(const imatrix_slice &ms, const real &c) throw();
02900 INLINE imatrix &operator /=(imatrix &m,const real &c) throw();
02901
02902
02904 INLINE imatrix operator *(const interval &c, const rmatrix &m) throw();
02906 INLINE imatrix operator *(const interval &c, const rmatrix_slice &ms) throw();
02908 INLINE imatrix operator *(const rmatrix &m,const interval &c) throw();
02910 INLINE imatrix operator *(const rmatrix_slice &ms,const interval &c) throw();
02912 INLINE imatrix operator /(const rmatrix &m,const interval &c) throw();
02914 INLINE imatrix operator /(const rmatrix_slice &ms, const interval &c) throw();
02915
02916
02917
02918
02919
02921 INLINE ivector operator *(const imatrix &m,const ivector &v)
02922 #if(CXSC_INDEX_CHECK)
02923 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02924 #else
02925 throw();
02926 #endif
02927
02928 INLINE ivector operator *(const imatrix_slice &ms,const ivector &v)
02929 #if(CXSC_INDEX_CHECK)
02930 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02931 #else
02932 throw();
02933 #endif
02934
02935 INLINE ivector operator *(const ivector &v,const imatrix &m)
02936 #if(CXSC_INDEX_CHECK)
02937 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02938 #else
02939 throw();
02940 #endif
02941
02942 INLINE ivector operator *(const ivector &v,const imatrix_slice &ms)
02943 #if(CXSC_INDEX_CHECK)
02944 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02945 #else
02946 throw();
02947 #endif
02948
02949 INLINE ivector &operator *=(ivector &v,const imatrix &m)
02950 #if(CXSC_INDEX_CHECK)
02951 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02952 #else
02953 throw();
02954 #endif
02955
02956 INLINE ivector &operator *=(ivector &v,const imatrix_slice &ms)
02957 #if(CXSC_INDEX_CHECK)
02958 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02959 #else
02960 throw();
02961 #endif
02962
02964 INLINE ivector operator *(const ivector_slice &v,const imatrix &m)
02965 #if(CXSC_INDEX_CHECK)
02966 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02967 #else
02968 throw();
02969 #endif
02970
02971 INLINE ivector operator *(const ivector_slice &v,const imatrix_slice &m)
02972 #if(CXSC_INDEX_CHECK)
02973 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02974 #else
02975 throw();
02976 #endif
02977
02978
02979
02980
02982 INLINE ivector operator *(const rvector &v,const imatrix &m)
02983 #if(CXSC_INDEX_CHECK)
02984 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02985 #else
02986 throw();
02987 #endif
02988
02989 INLINE ivector operator *(const rvector &v,const imatrix_slice &ms)
02990 #if(CXSC_INDEX_CHECK)
02991 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02992 #else
02993 throw();
02994 #endif
02995
02996 INLINE ivector operator *(const rvector_slice &v,const imatrix &m)
02997 #if(CXSC_INDEX_CHECK)
02998 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02999 #else
03000 throw();
03001 #endif
03002
03004 INLINE ivector operator *(const imatrix &m,const rvector &v)
03005 #if(CXSC_INDEX_CHECK)
03006 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03007 #else
03008 throw();
03009 #endif
03010
03011 INLINE ivector operator *(const imatrix_slice &ms,const rvector &v)
03012 #if(CXSC_INDEX_CHECK)
03013 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03014 #else
03015 throw();
03016 #endif
03017
03018
03019
03020
03022 INLINE const imatrix &operator +(const imatrix &m1) throw();
03024 INLINE imatrix operator +(const imatrix_slice &ms) throw();
03026 INLINE imatrix operator +(const imatrix &m1,const imatrix &m2)
03027 #if(CXSC_INDEX_CHECK)
03028 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03029 #else
03030 throw();
03031 #endif
03032
03033 INLINE imatrix operator +(const imatrix &m,const imatrix_slice &ms)
03034 #if(CXSC_INDEX_CHECK)
03035 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03036 #else
03037 throw();
03038 #endif
03039
03040 INLINE imatrix operator +(const imatrix_slice &ms,const imatrix &m)
03041 #if(CXSC_INDEX_CHECK)
03042 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03043 #else
03044 throw();
03045 #endif
03046
03047 INLINE imatrix operator +(const imatrix_slice &m1,const imatrix_slice &m2)
03048 #if(CXSC_INDEX_CHECK)
03049 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03050 #else
03051 throw();
03052 #endif
03053
03054 INLINE imatrix &operator +=(imatrix &m1,const imatrix &m2)
03055 #if(CXSC_INDEX_CHECK)
03056 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03057 #else
03058 throw();
03059 #endif
03060
03061 INLINE imatrix &operator +=(imatrix &m1,const imatrix_slice &ms)
03062 #if(CXSC_INDEX_CHECK)
03063 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03064 #else
03065 throw();
03066 #endif
03067
03069 INLINE imatrix operator -(const imatrix &m) throw();
03071 INLINE imatrix operator -(const imatrix_slice &ms) throw();
03073 INLINE imatrix operator -(const imatrix &m1,const imatrix &m2)
03074 #if(CXSC_INDEX_CHECK)
03075 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03076 #else
03077 throw();
03078 #endif
03079
03080 INLINE imatrix operator -(const imatrix &m,const imatrix_slice &ms)
03081 #if(CXSC_INDEX_CHECK)
03082 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03083 #else
03084 throw();
03085 #endif
03086
03087 INLINE imatrix operator -(const imatrix_slice &ms,const imatrix &m)
03088 #if(CXSC_INDEX_CHECK)
03089 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03090 #else
03091 throw();
03092 #endif
03093
03094 INLINE imatrix operator -(const imatrix_slice &ms1,const imatrix_slice &ms2)
03095 #if(CXSC_INDEX_CHECK)
03096 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03097 #else
03098 throw();
03099 #endif
03100
03101 INLINE imatrix &operator -=(imatrix &m1,const imatrix &m2)
03102 #if(CXSC_INDEX_CHECK)
03103 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03104 #else
03105 throw();
03106 #endif
03107
03108 INLINE imatrix &operator -=(imatrix &m1,const imatrix_slice &ms)
03109 #if(CXSC_INDEX_CHECK)
03110 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03111 #else
03112 throw();
03113 #endif
03114
03116 INLINE imatrix operator *(const imatrix &m1, const imatrix &m2)
03117 #if(CXSC_INDEX_CHECK)
03118 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03119 #else
03120 throw();
03121 #endif
03122
03123 INLINE imatrix operator *(const imatrix &m1, const imatrix_slice &ms)
03124 #if(CXSC_INDEX_CHECK)
03125 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03126 #else
03127 throw();
03128 #endif
03129
03130 INLINE imatrix operator *(const imatrix_slice &ms, const imatrix &m1)
03131 #if(CXSC_INDEX_CHECK)
03132 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03133 #else
03134 throw();
03135 #endif
03136
03137 INLINE imatrix operator *(const imatrix_slice &ms1, const imatrix_slice &ms2)
03138 #if(CXSC_INDEX_CHECK)
03139 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03140 #else
03141 throw();
03142 #endif
03143
03144 INLINE imatrix &operator *=(imatrix &m1,const imatrix &m2)
03145 #if(CXSC_INDEX_CHECK)
03146 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03147 #else
03148 throw();
03149 #endif
03150
03151 INLINE imatrix &operator *=(imatrix &m1,const imatrix_slice &ms)
03152 #if(CXSC_INDEX_CHECK)
03153 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03154 #else
03155 throw();
03156 #endif
03157
03158
03160 INLINE imatrix operator |(const imatrix &m1,const imatrix &m2)
03161 #if(CXSC_INDEX_CHECK)
03162 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03163 #else
03164 throw();
03165 #endif
03166
03167 INLINE imatrix operator |(const imatrix &m,const imatrix_slice &ms)
03168 #if(CXSC_INDEX_CHECK)
03169 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03170 #else
03171 throw();
03172 #endif
03173
03174 INLINE imatrix operator |(const imatrix_slice &ms,const imatrix &m)
03175 #if(CXSC_INDEX_CHECK)
03176 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03177 #else
03178 throw();
03179 #endif
03180
03181 INLINE imatrix operator |(const imatrix_slice &m1,const imatrix_slice &m2)
03182 #if(CXSC_INDEX_CHECK)
03183 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03184 #else
03185 throw();
03186 #endif
03187
03188 INLINE imatrix &operator |=(imatrix &m1,const imatrix &m2)
03189 #if(CXSC_INDEX_CHECK)
03190 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03191 #else
03192 throw();
03193 #endif
03194
03195 INLINE imatrix &operator |=(imatrix &m1,const imatrix_slice &ms)
03196 #if(CXSC_INDEX_CHECK)
03197 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03198 #else
03199 throw();
03200 #endif
03201
03203 INLINE imatrix operator &(const imatrix &m1,const imatrix &m2)
03204 #if(CXSC_INDEX_CHECK)
03205 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03206 #else
03207 throw();
03208 #endif
03209
03210 INLINE imatrix operator &(const imatrix &m,const imatrix_slice &ms)
03211 #if(CXSC_INDEX_CHECK)
03212 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03213 #else
03214 throw();
03215 #endif
03216
03217 INLINE imatrix operator &(const imatrix_slice &ms,const imatrix &m)
03218 #if(CXSC_INDEX_CHECK)
03219 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03220 #else
03221 throw();
03222 #endif
03223
03224 INLINE imatrix operator &(const imatrix_slice &m1,const imatrix_slice &m2)
03225 #if(CXSC_INDEX_CHECK)
03226 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03227 #else
03228 throw();
03229 #endif
03230
03231 INLINE imatrix &operator &=(imatrix &m1,const imatrix &m2)
03232 #if(CXSC_INDEX_CHECK)
03233 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03234 #else
03235 throw();
03236 #endif
03237
03238 INLINE imatrix &operator &=(imatrix &m1,const imatrix_slice &ms)
03239 #if(CXSC_INDEX_CHECK)
03240 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03241 #else
03242 throw();
03243 #endif
03244
03245
03247 INLINE imatrix operator +(const rmatrix &m1,const imatrix &m2)
03248 #if(CXSC_INDEX_CHECK)
03249 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03250 #else
03251 throw();
03252 #endif
03253
03254 INLINE imatrix operator +(const imatrix &m1,const rmatrix &m2)
03255 #if(CXSC_INDEX_CHECK)
03256 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03257 #else
03258 throw();
03259 #endif
03260
03261 INLINE imatrix operator +(const rmatrix &m,const imatrix_slice &ms)
03262 #if(CXSC_INDEX_CHECK)
03263 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03264 #else
03265 throw();
03266 #endif
03267
03268 INLINE imatrix operator +(const imatrix &m,const rmatrix_slice &ms)
03269 #if(CXSC_INDEX_CHECK)
03270 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03271 #else
03272 throw();
03273 #endif
03274
03275 INLINE imatrix operator +(const rmatrix_slice &ms,const imatrix &m)
03276 #if(CXSC_INDEX_CHECK)
03277 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03278 #else
03279 throw();
03280 #endif
03281
03282 INLINE imatrix operator +(const imatrix_slice &ms,const rmatrix &m)
03283 #if(CXSC_INDEX_CHECK)
03284 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03285 #else
03286 throw();
03287 #endif
03288
03289 INLINE imatrix operator +(const rmatrix_slice &m1,const imatrix_slice &m2)
03290 #if(CXSC_INDEX_CHECK)
03291 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03292 #else
03293 throw();
03294 #endif
03295
03296 INLINE imatrix operator +(const imatrix_slice &m1,const rmatrix_slice &m2)
03297 #if(CXSC_INDEX_CHECK)
03298 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03299 #else
03300 throw();
03301 #endif
03302
03303 INLINE imatrix &operator +=(imatrix &m1,const rmatrix &m2)
03304 #if(CXSC_INDEX_CHECK)
03305 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03306 #else
03307 throw();
03308 #endif
03309
03310 INLINE imatrix &operator +=(imatrix &m1,const rmatrix_slice &ms)
03311 #if(CXSC_INDEX_CHECK)
03312 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03313 #else
03314 throw();
03315 #endif
03316
03318 INLINE imatrix operator -(const rmatrix &m1,const imatrix &m2)
03319 #if(CXSC_INDEX_CHECK)
03320 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03321 #else
03322 throw();
03323 #endif
03324
03325 INLINE imatrix operator -(const imatrix &m1,const rmatrix &m2)
03326 #if(CXSC_INDEX_CHECK)
03327 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03328 #else
03329 throw();
03330 #endif
03331
03332 INLINE imatrix operator -(const rmatrix &m,const imatrix_slice &ms)
03333 #if(CXSC_INDEX_CHECK)
03334 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03335 #else
03336 throw();
03337 #endif
03338
03339 INLINE imatrix operator -(const imatrix &m,const rmatrix_slice &ms)
03340 #if(CXSC_INDEX_CHECK)
03341 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03342 #else
03343 throw();
03344 #endif
03345
03346 INLINE imatrix operator -(const rmatrix_slice &ms,const imatrix &m)
03347 #if(CXSC_INDEX_CHECK)
03348 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03349 #else
03350 throw();
03351 #endif
03352
03353 INLINE imatrix operator -(const imatrix_slice &ms,const rmatrix &m)
03354 #if(CXSC_INDEX_CHECK)
03355 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03356 #else
03357 throw();
03358 #endif
03359
03360 INLINE imatrix operator -(const rmatrix_slice &ms1,const imatrix_slice &ms2)
03361 #if(CXSC_INDEX_CHECK)
03362 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03363 #else
03364 throw();
03365 #endif
03366
03367 INLINE imatrix operator -(const imatrix_slice &ms1,const rmatrix_slice &ms2)
03368 #if(CXSC_INDEX_CHECK)
03369 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03370 #else
03371 throw();
03372 #endif
03373
03374 INLINE imatrix &operator -=(imatrix &m1,const rmatrix &m2)
03375 #if(CXSC_INDEX_CHECK)
03376 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03377 #else
03378 throw();
03379 #endif
03380
03381 INLINE imatrix &operator -=(imatrix &m1,const rmatrix_slice &ms)
03382 #if(CXSC_INDEX_CHECK)
03383 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03384 #else
03385 throw();
03386 #endif
03387
03389 INLINE imatrix operator *(const rmatrix &m1, const imatrix &m2)
03390 #if(CXSC_INDEX_CHECK)
03391 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03392 #else
03393 throw();
03394 #endif
03395
03396 INLINE imatrix operator *(const imatrix &m1, const rmatrix &m2)
03397 #if(CXSC_INDEX_CHECK)
03398 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03399 #else
03400 throw();
03401 #endif
03402
03403 INLINE imatrix operator *(const rmatrix &m1, const imatrix_slice &ms)
03404 #if(CXSC_INDEX_CHECK)
03405 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03406 #else
03407 throw();
03408 #endif
03409
03410 INLINE imatrix operator *(const imatrix &m1, const rmatrix_slice &ms)
03411 #if(CXSC_INDEX_CHECK)
03412 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03413 #else
03414 throw();
03415 #endif
03416
03417 INLINE imatrix operator *(const rmatrix_slice &ms, const imatrix &m1)
03418 #if(CXSC_INDEX_CHECK)
03419 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03420 #else
03421 throw();
03422 #endif
03423
03424 INLINE imatrix operator *(const imatrix_slice &ms, const rmatrix &m1)
03425 #if(CXSC_INDEX_CHECK)
03426 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03427 #else
03428 throw();
03429 #endif
03430
03431 INLINE imatrix operator *(const rmatrix_slice &ms1, const imatrix_slice &ms2)
03432 #if(CXSC_INDEX_CHECK)
03433 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03434 #else
03435 throw();
03436 #endif
03437
03438 INLINE imatrix operator *(const imatrix_slice &ms1, const rmatrix_slice &ms2)
03439 #if(CXSC_INDEX_CHECK)
03440 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03441 #else
03442 throw();
03443 #endif
03444
03445 INLINE imatrix &operator *=(imatrix &m1,const rmatrix &m2)
03446 #if(CXSC_INDEX_CHECK)
03447 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03448 #else
03449 throw();
03450 #endif
03451
03452 INLINE imatrix &operator *=(imatrix &m1,const rmatrix_slice &ms)
03453 #if(CXSC_INDEX_CHECK)
03454 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03455 #else
03456 throw();
03457 #endif
03458
03460 INLINE imatrix operator |(const rmatrix &m1,const imatrix &m2)
03461 #if(CXSC_INDEX_CHECK)
03462 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03463 #else
03464 throw();
03465 #endif
03466
03467 INLINE imatrix operator |(const imatrix &m1,const rmatrix &m2)
03468 #if(CXSC_INDEX_CHECK)
03469 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03470 #else
03471 throw();
03472 #endif
03473
03474 INLINE imatrix operator |(const rmatrix &m,const imatrix_slice &ms)
03475 #if(CXSC_INDEX_CHECK)
03476 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03477 #else
03478 throw();
03479 #endif
03480
03481 INLINE imatrix operator |(const imatrix &m,const rmatrix_slice &ms)
03482 #if(CXSC_INDEX_CHECK)
03483 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03484 #else
03485 throw();
03486 #endif
03487
03488 INLINE imatrix operator |(const rmatrix_slice &ms,const imatrix &m)
03489 #if(CXSC_INDEX_CHECK)
03490 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03491 #else
03492 throw();
03493 #endif
03494
03495 INLINE imatrix operator |(const imatrix_slice &ms,const rmatrix &m)
03496 #if(CXSC_INDEX_CHECK)
03497 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03498 #else
03499 throw();
03500 #endif
03501
03502 INLINE imatrix operator |(const rmatrix_slice &m1,const imatrix_slice &m2)
03503 #if(CXSC_INDEX_CHECK)
03504 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03505 #else
03506 throw();
03507 #endif
03508
03509 INLINE imatrix operator |(const imatrix_slice &m1,const rmatrix_slice &m2)
03510 #if(CXSC_INDEX_CHECK)
03511 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03512 #else
03513 throw();
03514 #endif
03515
03516 INLINE imatrix &operator |=(imatrix &m1,const rmatrix &m2)
03517 #if(CXSC_INDEX_CHECK)
03518 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03519 #else
03520 throw();
03521 #endif
03522
03523 INLINE imatrix &operator |=(imatrix &m1,const rmatrix_slice &ms)
03524 #if(CXSC_INDEX_CHECK)
03525 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03526 #else
03527 throw();
03528 #endif
03529
03531 INLINE imatrix operator &(const rmatrix &m1,const imatrix &m2)
03532 #if(CXSC_INDEX_CHECK)
03533 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03534 #else
03535 throw();
03536 #endif
03537
03538 INLINE imatrix operator &(const imatrix &m1,const rmatrix &m2)
03539 #if(CXSC_INDEX_CHECK)
03540 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03541 #else
03542 throw();
03543 #endif
03544
03545 INLINE imatrix operator &(const rmatrix &m,const imatrix_slice &ms)
03546 #if(CXSC_INDEX_CHECK)
03547 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03548 #else
03549 throw();
03550 #endif
03551
03552 INLINE imatrix operator &(const imatrix &m,const rmatrix_slice &ms)
03553 #if(CXSC_INDEX_CHECK)
03554 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03555 #else
03556 throw();
03557 #endif
03558
03559 INLINE imatrix operator &(const rmatrix_slice &ms,const imatrix &m)
03560 #if(CXSC_INDEX_CHECK)
03561 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03562 #else
03563 throw();
03564 #endif
03565
03566 INLINE imatrix operator &(const imatrix_slice &ms,const rmatrix &m)
03567 #if(CXSC_INDEX_CHECK)
03568 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03569 #else
03570 throw();
03571 #endif
03572
03573 INLINE imatrix operator &(const rmatrix_slice &m1,const imatrix_slice &m2)
03574 #if(CXSC_INDEX_CHECK)
03575 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03576 #else
03577 throw();
03578 #endif
03579
03580 INLINE imatrix operator &(const imatrix_slice &m1,const rmatrix_slice &m2)
03581 #if(CXSC_INDEX_CHECK)
03582 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03583 #else
03584 throw();
03585 #endif
03586
03587 INLINE imatrix &operator &=(imatrix &m1,const rmatrix &m2)
03588 #if(CXSC_INDEX_CHECK)
03589 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03590 #else
03591 throw();
03592 #endif
03593
03594 INLINE imatrix &operator &=(imatrix &m1,const rmatrix_slice &ms)
03595 #if(CXSC_INDEX_CHECK)
03596 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03597 #else
03598 throw();
03599 #endif
03600
03601
03602
03604 INLINE imatrix operator |(const rmatrix &m1,const rmatrix &m2)
03605 #if(CXSC_INDEX_CHECK)
03606 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
03607 #else
03608 throw();
03609 #endif
03610
03611 INLINE imatrix operator |(const rmatrix &m,const rmatrix_slice &ms)
03612 #if(CXSC_INDEX_CHECK)
03613 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
03614 #else
03615 throw();
03616 #endif
03617
03618 INLINE imatrix operator |(const rmatrix_slice &ms,const rmatrix &m)
03619 #if(CXSC_INDEX_CHECK)
03620 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
03621 #else
03622 throw();
03623 #endif
03624
03625 INLINE imatrix operator |(const rmatrix_slice &m1,const rmatrix_slice &m2)
03626 #if(CXSC_INDEX_CHECK)
03627 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
03628 #else
03629 throw();
03630 #endif
03631
03632
03633
03634
03635
03637 INLINE bool operator ==(const imatrix &m1,const imatrix &m2) throw();
03639 INLINE bool operator !=(const imatrix &m1,const imatrix &m2) throw();
03641 INLINE bool operator <(const imatrix &m1,const imatrix &m2) throw();
03643 INLINE bool operator <=(const imatrix &m1,const imatrix &m2) throw();
03645 INLINE bool operator >(const imatrix &m1,const imatrix &m2) throw();
03647 INLINE bool operator >=(const imatrix &m1,const imatrix &m2) throw();
03649 INLINE bool operator ==(const imatrix &m1,const imatrix_slice &ms) throw();
03651 INLINE bool operator !=(const imatrix &m1,const imatrix_slice &ms) throw();
03653 INLINE bool operator <(const imatrix &m1,const imatrix_slice &ms) throw();
03655 INLINE bool operator <=(const imatrix &m1,const imatrix_slice &ms) throw();
03657 INLINE bool operator >(const imatrix &m1,const imatrix_slice &ms) throw();
03659 INLINE bool operator >=(const imatrix &m1,const imatrix_slice &ms) throw();
03660
03661
03662
03664 INLINE bool operator ==(const imatrix_slice &m1,const imatrix_slice &m2) throw();
03666 INLINE bool operator !=(const imatrix_slice &m1,const imatrix_slice &m2) throw();
03668 INLINE bool operator <(const imatrix_slice &m1,const imatrix_slice &m2) throw();
03670 INLINE bool operator <=(const imatrix_slice &m1,const imatrix_slice &m2) throw();
03672 INLINE bool operator >(const imatrix_slice &m1,const imatrix_slice &m2) throw();
03674 INLINE bool operator >=(const imatrix_slice &m1,const imatrix_slice &m2) throw();
03675
03676
03677
03679 INLINE bool operator !(const imatrix &ms) throw();
03681 INLINE bool operator !(const imatrix_slice &ms) throw();
03682
03683
03684
03686 INLINE std::ostream &operator <<(std::ostream &s,const imatrix &r) throw();
03688 INLINE std::ostream &operator <<(std::ostream &s,const imatrix_slice &r) throw();
03690 INLINE std::istream &operator >>(std::istream &s,imatrix &r) throw();
03692 INLINE std::istream &operator >>(std::istream &s,imatrix_slice &r) throw();
03693
03695 rmatrix CompMat ( const imatrix& );
03697 imatrix Id ( const imatrix& );
03699 imatrix transp ( const imatrix& );
03701 real MaxRelDiam ( const imatrix_subv& );
03703 INLINE int RowLen ( const imatrix& );
03705 INLINE int ColLen ( const imatrix& );
03707 INLINE int RowLen ( const imatrix_slice& );
03709 INLINE int ColLen ( const imatrix_slice& );
03711 void DoubleSize ( imatrix& );
03712
03713 }
03714
03715 #ifdef _CXSC_INCL_INL
03716 #include "matrix.inl"
03717 #include "imatrix.inl"
03718 #endif
03719
03720 #ifdef _CXSC_CIVECTOR_HPP_INCLUDED
03721 # ifdef _CXSC_INCL_INL
03722 # include "civecimat.inl"
03723 # else
03724 # include "civecimat.hpp"
03725 # endif
03726 #endif
03727
03728 #ifdef _CXSC_CVECTOR_HPP_INCLUDED
03729 # ifdef _CXSC_INCL_INL
03730 # include "cvecimat.inl"
03731 # else
03732 # include "cvecimat.hpp"
03733 # endif
03734 #endif
03735
03736 #ifdef _CXSC_CMATRIX_HPP_INCLUDED
03737 # ifdef _CXSC_INCL_INL
03738 # include "cmatimat.inl"
03739 # else
03740 # include "cmatimat.hpp"
03741 # endif
03742 #endif
03743
03744 #ifdef _CXSC_LIVECTOR_HPP_INCLUDED
03745 # ifdef _CXSC_INCL_INL
03746 # include "livecimat.inl"
03747 # else
03748 # include "livecimat.hpp"
03749 # endif
03750 #endif
03751
03752 #ifdef _CXSC_LRVECTOR_HPP_INCLUDED
03753 # ifdef _CXSC_INCL_INL
03754 # include "lrvecimat.inl"
03755 # else
03756 # include "lrvecimat.hpp"
03757 # endif
03758 #endif
03759
03760 #ifdef _CXSC_LRMATRIX_HPP_INCLUDED
03761 # ifdef _CXSC_INCL_INL
03762 # include "lrmatimat.inl"
03763 # else
03764 # include "lrmatimat.hpp"
03765 # endif
03766 #endif
03767
03768
03769 #ifdef CXSC_USE_BLAS
03770 #define _CXSC_BLAS_IMATRIX
03771 #include "cxsc_blas.inl"
03772 #endif
03773
03774 #endif
