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_LIMATRIX_HPP_INCLUDED
00027 #define _CXSC_LIMATRIX_HPP_INCLUDED
00028
00029 #include "xscclass.hpp"
00030 #include "idot.hpp"
00031 #include "l_ivector.hpp"
00032 #include "except.hpp"
00033 #include "matrix.hpp"
00034 #include "imatrix.hpp"
00035 #include "l_rmatrix.hpp"
00036
00037 namespace cxsc {
00038
00039 class l_imatrix;
00040 class l_imatrix_slice;
00041
00043
00046 class l_imatrix_subv
00047 {
00048 friend class l_ivector;
00049 friend class l_imatrix;
00050 friend class l_imatrix_slice;
00051 private:
00052 l_interval *dat;
00053 int lb,ub;
00054 int size,start,offset;
00055
00056 public:
00058 friend INLINE l_imatrix_subv Row(l_imatrix &m,const int &i)
00059 #if(CXSC_INDEX_CHECK)
00060 throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT);
00061 #else
00062 throw();
00063 #endif
00064
00065 friend INLINE l_imatrix_subv Col(l_imatrix &m,const int &i)
00066 #if(CXSC_INDEX_CHECK)
00067 throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT);
00068 #else
00069 throw();
00070 #endif
00071
00072 friend INLINE l_imatrix_subv Row(const l_imatrix &m,const int &i)
00073 #if(CXSC_INDEX_CHECK)
00074 throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT);
00075 #else
00076 throw();
00077 #endif
00078
00079 friend INLINE l_imatrix_subv Col(const l_imatrix &m,const int &i)
00080 #if(CXSC_INDEX_CHECK)
00081 throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT);
00082 #else
00083 throw();
00084 #endif
00085
00086 #ifdef _CXSC_FRIEND_TPL
00087
00088 template <class MV1,class MV2> friend MV1 &_mvmvassign(MV1 &v,const MV2 &rv)
00089 #if(CXSC_INDEX_CHECK)
00090 throw(ERROR__OP_WITH_WRONG_DIM<MV1>);
00091 #else
00092 throw();
00093 #endif
00094 template <class MV,class S> friend MV &_mvsassign(MV &v,const S &r) throw();
00095 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
00096 #if(CXSC_INDEX_CHECK)
00097 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00098 #else
00099 throw();
00100 #endif
00101 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) throw();
00102 template <class MV,class V> friend MV &_mvvsetinf(MV &v,const V &rv)
00103 #if(CXSC_INDEX_CHECK)
00104 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00105 #else
00106 throw();
00107 #endif
00108 template <class MV,class V> friend MV &_mvvsetsup(MV &v,const V &rv)
00109 #if(CXSC_INDEX_CHECK)
00110 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00111 #else
00112 throw();
00113 #endif
00114 template <class MV,class V> friend MV &_mvvusetinf(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 &_mvvusetsup(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 &_mvvsetre(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 &_mvvsetim(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 V> friend V _mvabs(const MV &mv) throw();
00139 template <class MV,class V> friend V _mvdiam(const MV &mv) throw();
00140 template <class MV,class V> friend V _mvmid(const MV &mv) throw();
00141 template <class MV,class V> friend V _mvinf(const MV &mv) throw();
00142 template <class MV,class V> friend V _mvsup(const MV &mv) throw();
00143
00144 template <class MV,class S> friend MV &_mvssetinf(MV &mv, const S &s) throw();
00145 template <class MV,class S> friend MV &_mvssetsup(MV &mv, const S &s) throw();
00146 template <class MV,class S> friend MV &_mvsusetinf(MV &mv, const S &s) throw();
00147 template <class MV,class S> friend MV &_mvsusetsup(MV &mv, const S &s) throw();
00148
00149 template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
00150 #if(CXSC_INDEX_CHECK)
00151 throw(OP_WITH_WRONG_DIM);
00152 #else
00153 throw();
00154 #endif
00155 template <class DP,class MV1,class MV2> friend void _mvmvaccu(DP &dp, const MV1 & rv1, const MV2 &rv2)
00156 #if(CXSC_INDEX_CHECK)
00157 throw(OP_WITH_WRONG_DIM);
00158 #else
00159 throw();
00160 #endif
00161 template <class MV1,class MV2,class S> friend S _mvmvlimult(const MV1 & rv1, const MV2 &rv2)
00162 #if(CXSC_INDEX_CHECK)
00163 throw(ERROR__OP_WITH_WRONG_DIM<MV1>);
00164 #else
00165 throw();
00166 #endif
00167 template <class V,class MV,class S> friend S _vmvlimult(const V &rv1, const MV &rv2)
00168 #if(CXSC_INDEX_CHECK)
00169 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00170 #else
00171 throw();
00172 #endif
00173 template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) throw();
00174 template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
00175 #if(CXSC_INDEX_CHECK)
00176 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00177 #else
00178 throw();
00179 #endif
00180 template <class MV1,class MV2,class E> friend E _mvmvminus(const MV1 &rv1, const MV2 &rv2)
00181 #if(CXSC_INDEX_CHECK)
00182 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00183 #else
00184 throw();
00185 #endif
00186 template <class MV,class V,class E> friend E _mvvplus(const MV &rv1, const V &rv2)
00187 #if(CXSC_INDEX_CHECK)
00188 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00189 #else
00190 throw();
00191 #endif
00192 template <class MV,class V,class E> friend E _mvvminus(const MV &rv1, const V &rv2)
00193 #if(CXSC_INDEX_CHECK)
00194 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00195 #else
00196 throw();
00197 #endif
00198 template <class V,class MV,class E> friend E _vmvminus(const V &rv1, const MV &rv2)
00199 #if(CXSC_INDEX_CHECK)
00200 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00201 #else
00202 throw();
00203 #endif
00204 template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) throw();
00205 template <class MV,class S> friend MV &_mvsmultassign(MV &v,const S &r) throw();
00206 template <class MV, class S> friend MV &_mvsplusassign(MV &v,const S &r) throw();
00207 template <class MV,class S> friend MV &_mvsminusassign(MV &v,const S &r) throw();
00208 template <class MV,class S> friend MV &_mvsdivassign(MV &v,const S &r) throw();
00209 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
00210 #if(CXSC_INDEX_CHECK)
00211 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00212 #else
00213 throw();
00214 #endif
00215 template <class V,class MV> friend V &_vmvplusassign(V &rv,const MV &v)
00216 #if(CXSC_INDEX_CHECK)
00217 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00218 #else
00219 throw();
00220 #endif
00221 template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv)
00222 #if(CXSC_INDEX_CHECK)
00223 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00224 #else
00225 throw();
00226 #endif
00227 template <class V,class MV> friend V &_vmvminusassign(V &rv,const MV &v)
00228 #if(CXSC_INDEX_CHECK)
00229 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00230 #else
00231 throw();
00232 #endif
00233 template <class MV1,class MV2,class E> friend E _mvmvconv(const MV1 &rv1, const MV2 &rv2)
00234 #if(CXSC_INDEX_CHECK)
00235 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00236 #else
00237 throw();
00238 #endif
00239 template <class MV,class V,class E> friend E _mvvconv(const MV &rv1, const V &rv2)
00240 #if(CXSC_INDEX_CHECK)
00241 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00242 #else
00243 throw();
00244 #endif
00245 template <class MV,class V> friend MV &_mvvconvassign(MV &v,const V &rv)
00246 #if(CXSC_INDEX_CHECK)
00247 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00248 #else
00249 throw();
00250 #endif
00251 template <class MV1,class MV2,class E> friend E _mvmvsect(const MV1 &rv1, const MV2 &rv2)
00252 #if(CXSC_INDEX_CHECK)
00253 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00254 #else
00255 throw();
00256 #endif
00257 template <class MV,class V,class E> friend E _mvvsect(const MV &rv1, const V &rv2)
00258 #if(CXSC_INDEX_CHECK)
00259 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00260 #else
00261 throw();
00262 #endif
00263 template <class MV,class V> friend MV &_mvvsectassign(MV &v,const V &rv)
00264 #if(CXSC_INDEX_CHECK)
00265 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00266 #else
00267 throw();
00268 #endif
00269 template <class V,class MV> friend V &_vmvsectassign(V &rv,const MV &v)
00270 #if(CXSC_INDEX_CHECK)
00271 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00272 #else
00273 throw();
00274 #endif
00275
00276
00277 #endif
00278
00279
00280
00282 explicit INLINE l_imatrix_subv (l_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) { }
00283 public:
00285 INLINE l_imatrix_subv(const l_imatrix_subv &v) throw():dat(v.dat),lb(v.lb),ub(v.ub),size(v.size),start(v.start),offset(v.offset) { }
00286 public:
00287
00288
00289
00291 INLINE l_imatrix_subv &operator =(const l_imatrix_subv &rv) throw();
00293 INLINE l_imatrix_subv &operator =(const l_interval &r) throw();
00295 INLINE l_imatrix_subv &operator =(const l_imatrix &m)
00296 #if(CXSC_INDEX_CHECK)
00297 throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00298 #else
00299 throw();
00300 #endif
00301
00302 INLINE l_imatrix_subv &operator =(const l_imatrix_slice &m)
00303 #if(CXSC_INDEX_CHECK)
00304 throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00305 #else
00306 throw();
00307 #endif
00308
00309 INLINE l_imatrix_subv &operator =(const l_ivector &v)
00310 #if(CXSC_INDEX_CHECK)
00311 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00312 #else
00313 throw();
00314 #endif
00315
00316 INLINE l_imatrix_subv &operator =(const l_ivector_slice &v)
00317 #if(CXSC_INDEX_CHECK)
00318 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00319 #else
00320 throw();
00321 #endif
00322
00324 INLINE l_imatrix_subv &operator =(const real &r) throw();
00326 INLINE l_imatrix_subv &operator =(const rmatrix &m)
00327 #if(CXSC_INDEX_CHECK)
00328 throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00329 #else
00330 throw();
00331 #endif
00332
00333 INLINE l_imatrix_subv &operator =(const rmatrix_slice &m)
00334 #if(CXSC_INDEX_CHECK)
00335 throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00336 #else
00337 throw();
00338 #endif
00339
00340 INLINE l_imatrix_subv &operator =(const rvector &v)
00341 #if(CXSC_INDEX_CHECK)
00342 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00343 #else
00344 throw();
00345 #endif
00346
00347 INLINE l_imatrix_subv &operator =(const rvector_slice &v)
00348 #if(CXSC_INDEX_CHECK)
00349 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00350 #else
00351 throw();
00352 #endif
00353
00354 INLINE l_imatrix_subv &operator =(const rmatrix_subv &rv) throw();
00355
00356
00358 INLINE l_imatrix_subv &operator =(const l_real &r) throw();
00360 INLINE l_imatrix_subv &operator =(const l_rmatrix &m)
00361 #if(CXSC_INDEX_CHECK)
00362 throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00363 #else
00364 throw();
00365 #endif
00366
00367 INLINE l_imatrix_subv &operator =(const l_rmatrix_slice &m)
00368 #if(CXSC_INDEX_CHECK)
00369 throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00370 #else
00371 throw();
00372 #endif
00373
00374 INLINE l_imatrix_subv &operator =(const l_rvector &v)
00375 #if(CXSC_INDEX_CHECK)
00376 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00377 #else
00378 throw();
00379 #endif
00380
00381 INLINE l_imatrix_subv &operator =(const l_rvector_slice &v)
00382 #if(CXSC_INDEX_CHECK)
00383 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00384 #else
00385 throw();
00386 #endif
00387
00388 INLINE l_imatrix_subv &operator =(const l_rmatrix_subv &rv) throw();
00389
00390
00392 INLINE l_imatrix_subv &operator =(const interval &r) throw();
00394 INLINE l_imatrix_subv &operator =(const imatrix &m)
00395 #if(CXSC_INDEX_CHECK)
00396 throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00397 #else
00398 throw();
00399 #endif
00400
00401 INLINE l_imatrix_subv &operator =(const imatrix_slice &m)
00402 #if(CXSC_INDEX_CHECK)
00403 throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00404 #else
00405 throw();
00406 #endif
00407
00408 INLINE l_imatrix_subv &operator =(const ivector &v)
00409 #if(CXSC_INDEX_CHECK)
00410 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00411 #else
00412 throw();
00413 #endif
00414
00415 INLINE l_imatrix_subv &operator =(const ivector_slice &v)
00416 #if(CXSC_INDEX_CHECK)
00417 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00418 #else
00419 throw();
00420 #endif
00421
00422 INLINE l_imatrix_subv &operator =(const imatrix_subv &rv) throw();
00423
00425 friend INLINE int Lb(const l_imatrix_subv &rv) throw() { return rv.lb; }
00427 friend INLINE int Ub(const l_imatrix_subv &rv) throw() { return rv.ub; }
00429 INLINE l_interval &operator [](const int &i) const
00430 #if(CXSC_INDEX_CHECK)
00431 throw(ERROR_LIVECTOR_ELEMENT_NOT_IN_VEC);
00432 #else
00433 throw();
00434 #endif
00435
00436 INLINE l_imatrix_subv &operator ()() throw() { return *this; }
00438 INLINE l_imatrix_subv operator ()(const int &i)
00439 #if(CXSC_INDEX_CHECK)
00440 throw(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG);
00441 #else
00442 throw();
00443 #endif
00444
00445 INLINE l_imatrix_subv operator ()(const int &i1,const int &i2)
00446 #if(CXSC_INDEX_CHECK)
00447 throw(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG);
00448 #else
00449 throw();
00450 #endif
00451
00453 INLINE l_imatrix_subv &operator *=(const l_interval &c) throw();
00455 INLINE l_imatrix_subv &operator +=(const l_interval &c) throw();
00457 INLINE l_imatrix_subv &operator -=(const l_interval &c) throw();
00459 INLINE l_imatrix_subv &operator /=(const l_interval &c) throw();
00461 INLINE l_imatrix_subv &operator -=(const l_ivector &rv)
00462 #if(CXSC_INDEX_CHECK)
00463 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00464 #else
00465 throw();
00466 #endif
00467
00468 INLINE l_imatrix_subv &operator +=(const l_ivector &rv)
00469 #if(CXSC_INDEX_CHECK)
00470 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00471 #else
00472 throw();
00473 #endif
00474
00475 INLINE l_imatrix_subv &operator -=(const l_ivector_slice &rv)
00476 #if(CXSC_INDEX_CHECK)
00477 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00478 #else
00479 throw();
00480 #endif
00481
00482 INLINE l_imatrix_subv &operator +=(const l_ivector_slice &rv)
00483 #if(CXSC_INDEX_CHECK)
00484 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00485 #else
00486 throw();
00487 #endif
00488
00489 INLINE l_imatrix_subv &operator |=(const l_ivector &rv)
00490 #if(CXSC_INDEX_CHECK)
00491 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00492 #else
00493 throw();
00494 #endif
00495
00496 INLINE l_imatrix_subv &operator |=(const l_ivector_slice &rv)
00497 #if(CXSC_INDEX_CHECK)
00498 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00499 #else
00500 throw();
00501 #endif
00502
00503 INLINE l_imatrix_subv &operator &=(const l_ivector &rv)
00504 #if(CXSC_INDEX_CHECK)
00505 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00506 #else
00507 throw();
00508 #endif
00509
00510 INLINE l_imatrix_subv &operator &=(const l_ivector_slice &rv)
00511 #if(CXSC_INDEX_CHECK)
00512 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00513 #else
00514 throw();
00515 #endif
00516
00518 INLINE l_imatrix_subv &operator *=(const real &c) throw();
00520 INLINE l_imatrix_subv &operator +=(const real &c) throw();
00522 INLINE l_imatrix_subv &operator -=(const real &c) throw();
00524 INLINE l_imatrix_subv &operator /=(const real &c) throw();
00526 INLINE l_imatrix_subv &operator -=(const rvector &rv)
00527 #if(CXSC_INDEX_CHECK)
00528 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00529 #else
00530 throw();
00531 #endif
00532
00533 INLINE l_imatrix_subv &operator +=(const rvector &rv)
00534 #if(CXSC_INDEX_CHECK)
00535 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00536 #else
00537 throw();
00538 #endif
00539
00540 INLINE l_imatrix_subv &operator -=(const rvector_slice &rv)
00541 #if(CXSC_INDEX_CHECK)
00542 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00543 #else
00544 throw();
00545 #endif
00546
00547 INLINE l_imatrix_subv &operator +=(const rvector_slice &rv)
00548 #if(CXSC_INDEX_CHECK)
00549 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00550 #else
00551 throw();
00552 #endif
00553
00554 INLINE l_imatrix_subv &operator |=(const rvector &rv)
00555 #if(CXSC_INDEX_CHECK)
00556 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00557 #else
00558 throw();
00559 #endif
00560
00561 INLINE l_imatrix_subv &operator |=(const rvector_slice &rv)
00562 #if(CXSC_INDEX_CHECK)
00563 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00564 #else
00565 throw();
00566 #endif
00567
00568 INLINE l_imatrix_subv &operator &=(const rvector &rv)
00569 #if(CXSC_INDEX_CHECK)
00570 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00571 #else
00572 throw();
00573 #endif
00574
00575 INLINE l_imatrix_subv &operator &=(const rvector_slice &rv)
00576 #if(CXSC_INDEX_CHECK)
00577 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00578 #else
00579 throw();
00580 #endif
00581
00583 INLINE l_imatrix_subv &operator *=(const l_real &c) throw();
00585 INLINE l_imatrix_subv &operator +=(const l_real &c) throw();
00587 INLINE l_imatrix_subv &operator -=(const l_real &c) throw();
00589 INLINE l_imatrix_subv &operator /=(const l_real &c) throw();
00591 INLINE l_imatrix_subv &operator -=(const l_rvector &rv)
00592 #if(CXSC_INDEX_CHECK)
00593 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00594 #else
00595 throw();
00596 #endif
00597
00598 INLINE l_imatrix_subv &operator +=(const l_rvector &rv)
00599 #if(CXSC_INDEX_CHECK)
00600 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00601 #else
00602 throw();
00603 #endif
00604
00605 INLINE l_imatrix_subv &operator -=(const l_rvector_slice &rv)
00606 #if(CXSC_INDEX_CHECK)
00607 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00608 #else
00609 throw();
00610 #endif
00611
00612 INLINE l_imatrix_subv &operator +=(const l_rvector_slice &rv)
00613 #if(CXSC_INDEX_CHECK)
00614 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00615 #else
00616 throw();
00617 #endif
00618
00619 INLINE l_imatrix_subv &operator |=(const l_rvector &rv)
00620 #if(CXSC_INDEX_CHECK)
00621 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00622 #else
00623 throw();
00624 #endif
00625
00626 INLINE l_imatrix_subv &operator |=(const l_rvector_slice &rv)
00627 #if(CXSC_INDEX_CHECK)
00628 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00629 #else
00630 throw();
00631 #endif
00632
00633 INLINE l_imatrix_subv &operator &=(const l_rvector &rv)
00634 #if(CXSC_INDEX_CHECK)
00635 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00636 #else
00637 throw();
00638 #endif
00639
00640 INLINE l_imatrix_subv &operator &=(const l_rvector_slice &rv)
00641 #if(CXSC_INDEX_CHECK)
00642 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00643 #else
00644 throw();
00645 #endif
00646
00648 INLINE l_imatrix_subv &operator *=(const interval &c) throw();
00650 INLINE l_imatrix_subv &operator +=(const interval &c) throw();
00652 INLINE l_imatrix_subv &operator -=(const interval &c) throw();
00654 INLINE l_imatrix_subv &operator /=(const interval &c) throw();
00656 INLINE l_imatrix_subv &operator -=(const ivector &rv)
00657 #if(CXSC_INDEX_CHECK)
00658 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00659 #else
00660 throw();
00661 #endif
00662
00663 INLINE l_imatrix_subv &operator +=(const ivector &rv)
00664 #if(CXSC_INDEX_CHECK)
00665 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00666 #else
00667 throw();
00668 #endif
00669
00670 INLINE l_imatrix_subv &operator -=(const ivector_slice &rv)
00671 #if(CXSC_INDEX_CHECK)
00672 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00673 #else
00674 throw();
00675 #endif
00676
00677 INLINE l_imatrix_subv &operator +=(const ivector_slice &rv)
00678 #if(CXSC_INDEX_CHECK)
00679 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00680 #else
00681 throw();
00682 #endif
00683
00684 INLINE l_imatrix_subv &operator |=(const ivector &rv)
00685 #if(CXSC_INDEX_CHECK)
00686 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00687 #else
00688 throw();
00689 #endif
00690
00691 INLINE l_imatrix_subv &operator |=(const ivector_slice &rv)
00692 #if(CXSC_INDEX_CHECK)
00693 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00694 #else
00695 throw();
00696 #endif
00697
00698 INLINE l_imatrix_subv &operator &=(const ivector &rv)
00699 #if(CXSC_INDEX_CHECK)
00700 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00701 #else
00702 throw();
00703 #endif
00704
00705 INLINE l_imatrix_subv &operator &=(const ivector_slice &rv)
00706 #if(CXSC_INDEX_CHECK)
00707 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00708 #else
00709 throw();
00710 #endif
00711
00712
00713
00714 };
00715
00716
00717
00718
00719 class l_imatrix_slice;
00720
00722
00725 class l_imatrix
00726 {
00727 friend class l_imatrix_slice;
00728 friend class l_imatrix_subv;
00729 private:
00730 l_interval *dat;
00731 int lb1,ub1,lb2,ub2,xsize,ysize;
00732
00733 public:
00734
00735 #ifdef _CXSC_FRIEND_TPL
00736
00737 template <class S,class M> friend void _smconstr(S &s,const M &m)
00738 #if(CXSC_INDEX_CHECK)
00739 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>,ERROR__USE_OF_UNINITIALIZED_OBJ<M>);
00740 #else
00741 throw();
00742 #endif
00743 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
00744 #if(CXSC_INDEX_CHECK)
00745 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
00746 #else
00747 throw();
00748 #endif
00749 template <class M1,class M2,class S> friend M1 &_mmassign(M1 &m1,const M2 &m,S ms) throw();
00750 template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) throw();
00751 template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m)
00752 #if(CXSC_INDEX_CHECK)
00753 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00754 #else
00755 throw();
00756 #endif
00757 template <class M,class S> friend M &_msassign(M &m,const S &r) throw();
00758 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m)
00759 #if(CXSC_INDEX_CHECK)
00760 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
00761 #else
00762 throw();
00763 #endif
00764 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) throw();
00765 template <class M> friend int _mlb(const M &m, const int &i)
00766 #if(CXSC_INDEX_CHECK)
00767 throw(ERROR__WRONG_ROW_OR_COL<M>);
00768 #else
00769 throw();
00770 #endif
00771 template <class M> friend int _mub(const M &m, const int &i)
00772 #if(CXSC_INDEX_CHECK)
00773 throw(ERROR__WRONG_ROW_OR_COL<M>);
00774 #else
00775 throw();
00776 #endif
00777 template <class M> friend M &_msetlb(M &m, const int &i,const int &j)
00778 #if(CXSC_INDEX_CHECK)
00779 throw(ERROR__WRONG_ROW_OR_COL<M>);
00780 #else
00781 throw();
00782 #endif
00783 template <class M> friend M &_msetub(M &m, const int &i,const int &j)
00784 #if(CXSC_INDEX_CHECK)
00785 throw(ERROR__WRONG_ROW_OR_COL<M>);
00786 #else
00787 throw();
00788 #endif
00789 template <class M> friend void _mresize(M &A) throw();
00790 template <class M,class S> friend void _mresize(M &A,const int &m, const int &n)
00791 #if(CXSC_INDEX_CHECK)
00792 throw(ERROR__WRONG_BOUNDARIES<M>);
00793 #else
00794 throw();
00795 #endif
00796 template <class M,class S> friend void _mresize(M &A,const int &m1, const int &m2,const int &n1,const int &n2)
00797 #if(CXSC_INDEX_CHECK)
00798 throw(ERROR__WRONG_BOUNDARIES<M>);
00799 #else
00800 throw();
00801 #endif
00802 template <class M,class E> friend E _mabs(const M &m) throw();
00803 template <class MS,class E> friend E _msabs(const MS &ms) throw();
00804 template <class M,class E> friend E _mdiam(const M &m) throw();
00805 template <class M,class E> friend E _mmid(const M &m) throw();
00806 template <class M,class E> friend E _minf(const M &m) throw();
00807 template <class M,class E> friend E _msup(const M &m) throw();
00808 template <class M1,class M2> friend M1 &_mmsetinf(M1 &m1,const M2 &m2)
00809 #if(CXSC_INDEX_CHECK)
00810 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00811 #else
00812 throw();
00813 #endif
00814 template <class M1,class M2> friend M1 &_mmsetsup(M1 &m1,const M2 &m2)
00815 #if(CXSC_INDEX_CHECK)
00816 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00817 #else
00818 throw();
00819 #endif
00820 template <class M1,class MS2> friend M1 &_mmssetinf(M1 &m1,const MS2 &ms2)
00821 #if(CXSC_INDEX_CHECK)
00822 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00823 #else
00824 throw();
00825 #endif
00826 template <class M1,class MS2> friend M1 &_mmssetsup(M1 &m1,const MS2 &ms2)
00827 #if(CXSC_INDEX_CHECK)
00828 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00829 #else
00830 throw();
00831 #endif
00832 template <class M1,class M2> friend M1 &_mmusetinf(M1 &m1,const M2 &m2)
00833 #if(CXSC_INDEX_CHECK)
00834 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00835 #else
00836 throw();
00837 #endif
00838 template <class M1,class M2> friend M1 &_mmusetsup(M1 &m1,const M2 &m2)
00839 #if(CXSC_INDEX_CHECK)
00840 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00841 #else
00842 throw();
00843 #endif
00844 template <class M1,class MS2> friend M1 &_mmsusetinf(M1 &m1,const MS2 &ms2)
00845 #if(CXSC_INDEX_CHECK)
00846 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00847 #else
00848 throw();
00849 #endif
00850 template <class M1,class MS2> friend M1 &_mmsusetsup(M1 &m1,const MS2 &ms2)
00851 #if(CXSC_INDEX_CHECK)
00852 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00853 #else
00854 throw();
00855 #endif
00856
00857 template <class M1,class M2,class E> friend E _mmplus(const M1 &m1,const M2 &m2)
00858 #if(CXSC_INDEX_CHECK)
00859 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00860 #else
00861 throw();
00862 #endif
00863 template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms)
00864 #if(CXSC_INDEX_CHECK)
00865 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00866 #else
00867 throw();
00868 #endif
00869 template <class M> friend M _mminus(const M &m) throw();
00870 template <class MS,class E> friend E _msminus(const MS &ms) throw();
00871 template <class M1,class M2,class E> friend E _mmminus(const M1 &m1,const M2 &m2)
00872 #if(CXSC_INDEX_CHECK)
00873 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00874 #else
00875 throw();
00876 #endif
00877 template <class M1,class M2> friend M1 &_mmplusassign(M1 &m1,const M2 &m2)
00878 #if(CXSC_INDEX_CHECK)
00879 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00880 #else
00881 throw();
00882 #endif
00883 template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms)
00884 #if(CXSC_INDEX_CHECK)
00885 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00886 #else
00887 throw();
00888 #endif
00889 template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1)
00890 #if(CXSC_INDEX_CHECK)
00891 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00892 #else
00893 throw();
00894 #endif
00895 template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2)
00896 #if(CXSC_INDEX_CHECK)
00897 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00898 #else
00899 throw();
00900 #endif
00901 template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms)
00902 #if(CXSC_INDEX_CHECK)
00903 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00904 #else
00905 throw();
00906 #endif
00907 template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m)
00908 #if(CXSC_INDEX_CHECK)
00909 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00910 #else
00911 throw();
00912 #endif
00913 template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2)
00914 #if(CXSC_INDEX_CHECK)
00915 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00916 #else
00917 throw();
00918 #endif
00919 template <class M1,class M2> friend M1 &_mmminusassign(M1 &m1,const M2 &m2)
00920 #if(CXSC_INDEX_CHECK)
00921 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00922 #else
00923 throw();
00924 #endif
00925 template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms)
00926 #if(CXSC_INDEX_CHECK)
00927 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00928 #else
00929 throw();
00930 #endif
00931 template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1)
00932 #if(CXSC_INDEX_CHECK)
00933 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00934 #else
00935 throw();
00936 #endif
00937 template <class M1,class M2,class E> friend E _mmlimult(const M1 &m1, const M2 &m2)
00938 #if(CXSC_INDEX_CHECK)
00939 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00940 #else
00941 throw();
00942 #endif
00943 template <class M1,class M2,class S> friend M1 &_mmlimultassign(M1 &m1,const M2 &m2)
00944 #if(CXSC_INDEX_CHECK)
00945 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00946 #else
00947 throw();
00948 #endif
00949 template <class M,class MS,class E> friend E _mmslimult(const M &m1, const MS &ms)
00950 #if(CXSC_INDEX_CHECK)
00951 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00952 #else
00953 throw();
00954 #endif
00955 template <class MS,class M,class E> friend E _msmlimult(const MS &ms, const M &m2)
00956 #if(CXSC_INDEX_CHECK)
00957 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00958 #else
00959 throw();
00960 #endif
00961 template <class M,class MS,class S> friend M &_mmslimultassign(M &m1,const MS &ms)
00962 #if(CXSC_INDEX_CHECK)
00963 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00964 #else
00965 throw();
00966 #endif
00967 template <class MS1,class MS2,class E> friend E _msmslimult(const MS1 &ms1, const MS2 &ms2)
00968 #if(CXSC_INDEX_CHECK)
00969 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00970 #else
00971 throw();
00972 #endif
00973 template <class M1,class M2,class E> friend E _mmconv(const M1 &m1,const M2 &m2)
00974 #if(CXSC_INDEX_CHECK)
00975 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00976 #else
00977 throw();
00978 #endif
00979 template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms)
00980 #if(CXSC_INDEX_CHECK)
00981 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00982 #else
00983 throw();
00984 #endif
00985 template <class M1,class M2> friend M1 &_mmconvassign(M1 &m1,const M2 &m2)
00986 #if(CXSC_INDEX_CHECK)
00987 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00988 #else
00989 throw();
00990 #endif
00991 template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms)
00992 #if(CXSC_INDEX_CHECK)
00993 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00994 #else
00995 throw();
00996 #endif
00997 template <class MS,class M> friend MS &_msmconvassign(MS &ms,const M &m1)
00998 #if(CXSC_INDEX_CHECK)
00999 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01000 #else
01001 throw();
01002 #endif
01003 template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2)
01004 #if(CXSC_INDEX_CHECK)
01005 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01006 #else
01007 throw();
01008 #endif
01009 template <class M1,class M2,class E> friend E _mmsect(const M1 &m1,const M2 &m2)
01010 #if(CXSC_INDEX_CHECK)
01011 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01012 #else
01013 throw();
01014 #endif
01015 template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms)
01016 #if(CXSC_INDEX_CHECK)
01017 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01018 #else
01019 throw();
01020 #endif
01021 template <class M1,class M2> friend M1 &_mmsectassign(M1 &m1,const M2 &m2)
01022 #if(CXSC_INDEX_CHECK)
01023 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01024 #else
01025 throw();
01026 #endif
01027 template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms)
01028 #if(CXSC_INDEX_CHECK)
01029 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01030 #else
01031 throw();
01032 #endif
01033 template <class MS,class M> friend MS &_msmsectassign(MS &ms,const M &m1)
01034 #if(CXSC_INDEX_CHECK)
01035 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01036 #else
01037 throw();
01038 #endif
01039 template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2)
01040 #if(CXSC_INDEX_CHECK)
01041 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01042 #else
01043 throw();
01044 #endif
01045
01046 template <class S,class M,class E> friend E _smmult(const S &c, const M &m) throw();
01047 template <class M,class S> friend M &_msmultassign(M &m,const S &c) throw();
01048 template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) throw();
01049 template <class M,class S,class E> friend E _msdiv(const M &m,const S &c) throw();
01050 template <class M,class S> friend M &_msdivassign(M &m,const S &c) throw();
01051 template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) throw();
01052
01053 template <class M,class V,class E> friend E _mvlimult(const M &m,const V &v)
01054 #if(CXSC_INDEX_CHECK)
01055 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01056 #else
01057 throw();
01058 #endif
01059 template <class V,class M,class E> friend E _vmlimult(const V &v,const M &m)
01060 #if(CXSC_INDEX_CHECK)
01061 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01062 #else
01063 throw();
01064 #endif
01065 template <class V,class M,class S> friend V &_vmlimultassign(V &v,const M &m)
01066 #if(CXSC_INDEX_CHECK)
01067 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01068 #else
01069 throw();
01070 #endif
01071 template <class VS,class M,class S> friend VS &_vsmlimultassign(VS &v,const M &m)
01072 #if(CXSC_INDEX_CHECK)
01073 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01074 #else
01075 throw();
01076 #endif
01077
01078 template <class M> friend void *_mvoid(const M &m) throw();
01079 template <class M> friend bool _mnot(const M &m) throw();
01080 template <class MS> friend void *_msvoid(const MS &ms) throw();
01081 template <class MS> friend bool _msnot(const MS &ms) throw();
01082 template <class M1,class M2> friend bool _mmeq(const M1 &m1,const M2 &m2) throw();
01083 template <class M1,class M2> friend bool _mmneq(const M1 &m1,const M2 &m2) throw();
01084 template <class M1,class M2> friend bool _mmless(const M1 &m1,const M2 &m2) throw();
01085 template <class M1,class M2> friend bool _mmleq(const M1 &m1,const M2 &m2) throw();
01086 template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) throw();
01087 template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) throw();
01088 template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) throw();
01089 template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) throw();
01090 template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) throw();
01091 template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) throw();
01092 template <class M> friend std::ostream &_mout(std::ostream &s,const M &r) throw();
01093 template <class M> friend std::istream &_min(std::istream &s,M &r) throw();
01094
01095
01096 template <class M1,class MS2> friend M1 &_mmssetre(M1 &m1,const MS2 &ms2)
01097 #if(CXSC_INDEX_CHECK)
01098 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01099 #else
01100 throw();
01101 #endif
01102 template <class M1,class MS2> friend M1 &_mmssetim(M1 &m1,const MS2 &ms2)
01103 #if(CXSC_INDEX_CHECK)
01104 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01105 #else
01106 throw();
01107 #endif
01108
01109
01110 template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v)
01111 #if(CXSC_INDEX_CHECK)
01112 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01113 #else
01114 throw();
01115 #endif
01116 template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms)
01117 #if(CXSC_INDEX_CHECK)
01118 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01119 #else
01120 throw();
01121 #endif
01122
01123
01124 #endif
01125
01126
01127
01128
01130 INLINE l_imatrix(const l_imatrix &rm) throw();
01132 INLINE l_imatrix(const l_imatrix_slice &rm) throw();
01134 INLINE l_imatrix() throw();
01136 explicit INLINE l_imatrix(const int &m, const int &n)
01137 #if(CXSC_INDEX_CHECK)
01138 throw(ERROR_LIMATRIX_WRONG_BOUNDARIES);
01139 #else
01140 throw();
01141 #endif
01142
01143 explicit INLINE l_imatrix(const int &m1, const int &n1, const int &m2, const int &n2)
01144 #if(CXSC_INDEX_CHECK)
01145 throw(ERROR_LIMATRIX_WRONG_BOUNDARIES);
01146 #else
01147 throw();
01148 #endif
01149
01150 explicit INLINE l_imatrix(const l_ivector &v) throw();
01152 explicit INLINE l_imatrix(const l_ivector_slice &v) throw();
01154 explicit INLINE l_imatrix(const l_interval &r) throw();
01156 INLINE l_imatrix &operator =(const l_interval &r) throw();
01158 INLINE l_imatrix &operator =(const l_imatrix &m) throw();
01160 INLINE l_imatrix &operator =(const l_imatrix_slice &ms) throw();
01162 INLINE l_imatrix &operator =(const l_ivector &v) throw();
01164 INLINE l_imatrix &operator =(const l_ivector_slice &v) throw();
01165
01167 explicit INLINE l_imatrix(const real &r) throw();
01169 explicit INLINE l_imatrix(const rmatrix &rm) throw();
01171 explicit INLINE l_imatrix(const rmatrix_slice &rm) throw();
01173 explicit INLINE l_imatrix(const rvector &v) throw();
01175 explicit INLINE l_imatrix(const rvector_slice &v) throw();
01177 INLINE l_imatrix &operator =(const real &r) throw();
01179 INLINE l_imatrix &operator =(const rmatrix &m) throw();
01181 INLINE l_imatrix &operator =(const rmatrix_slice &ms) throw();
01183 INLINE l_imatrix &operator =(const rvector &v) throw();
01185 INLINE l_imatrix &operator =(const rvector_slice &v) throw();
01186
01187
01189 explicit INLINE l_imatrix(const l_real &r) throw();
01191 explicit INLINE l_imatrix(const l_rmatrix &rm) throw();
01193 explicit INLINE l_imatrix(const l_rmatrix_slice &rm) throw();
01195 explicit INLINE l_imatrix(const l_rvector &v) throw();
01197 explicit INLINE l_imatrix(const l_rvector_slice &v) throw();
01199 INLINE l_imatrix &operator =(const l_real &r) throw();
01201 INLINE l_imatrix &operator =(const l_rmatrix &m) throw();
01203 INLINE l_imatrix &operator =(const l_rmatrix_slice &ms) throw();
01205 INLINE l_imatrix &operator =(const l_rvector &v) throw();
01207 INLINE l_imatrix &operator =(const l_rvector_slice &v) throw();
01208
01209
01211 explicit INLINE l_imatrix(const interval &r) throw();
01213 explicit INLINE l_imatrix(const imatrix &rm) throw();
01215 explicit INLINE l_imatrix(const imatrix_slice &rm) throw();
01217 explicit INLINE l_imatrix(const ivector &v) throw();
01219 explicit INLINE l_imatrix(const ivector_slice &v) throw();
01221 INLINE l_imatrix &operator =(const interval &r) throw();
01223 INLINE l_imatrix &operator =(const imatrix &m) throw();
01225 INLINE l_imatrix &operator =(const imatrix_slice &ms) throw();
01227 INLINE l_imatrix &operator =(const ivector &v) throw();
01229 INLINE l_imatrix &operator =(const ivector_slice &v) throw();
01230
01231
01232
01233 INLINE ~l_imatrix() throw() { delete [] dat; }
01234
01235
01236
01238 INLINE l_imatrix_subv operator [](const int &i) const
01239 #if(CXSC_INDEX_CHECK)
01240 throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT);
01241 #else
01242 throw();
01243 #endif
01244
01245 INLINE l_imatrix_subv operator [](const cxscmatrix_column &i) const
01246 #if(CXSC_INDEX_CHECK)
01247 throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT);
01248 #else
01249 throw();
01250 #endif
01251
01252 INLINE l_imatrix &operator ()() throw() { return *this; }
01254 INLINE l_imatrix_slice operator ()(const int &m, const int &n)
01255 #if(CXSC_INDEX_CHECK)
01256 throw(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG);
01257 #else
01258 throw();
01259 #endif
01260
01261 INLINE l_imatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
01262 #if(CXSC_INDEX_CHECK)
01263 throw(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG);
01264 #else
01265 throw();
01266 #endif
01267 INLINE operator void*() throw();
01268
01269
01270 };
01271
01272
01274
01279 class l_imatrix_slice
01280 {
01281 friend class l_imatrix;
01282 private:
01283 l_interval *dat;
01284 int offset1,offset2,mxsize,mysize;
01285 int start1,end1,start2,end2,sxsize,sysize;
01286
01287 public:
01288
01289 #ifdef _CXSC_FRIEND_TPL
01290
01291 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m)
01292 #if(CXSC_INDEX_CHECK)
01293 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>);
01294 #else
01295 throw();
01296 #endif
01297 template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m)
01298 #if(CXSC_INDEX_CHECK)
01299 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01300 #else
01301 throw();
01302 #endif
01303 template <class MS1,class MS2> friend MS1 &_msmsassign(MS1 &ms1,const MS2 &ms)
01304 #if(CXSC_INDEX_CHECK)
01305 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01306 #else
01307 throw();
01308 #endif
01309 template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) throw();
01310 template <class MS,class S> friend MS &_mssassign(MS &ms,const S &r) throw();
01311 template <class MS> friend int _mslb(const MS &ms, const int &i)
01312 #if(CXSC_INDEX_CHECK)
01313 throw(ERROR__WRONG_ROW_OR_COL<MS>);
01314 #else
01315 throw();
01316 #endif
01317 template <class MS> friend int _msub(const MS &ms, const int &i)
01318 #if(CXSC_INDEX_CHECK)
01319 throw(ERROR__WRONG_ROW_OR_COL<MS>);
01320 #else
01321 throw();
01322 #endif
01323 template <class MS,class E> friend E _msabs(const MS &ms) throw();
01324 template <class MS,class E> friend E _msinf(const MS &ms) throw();
01325 template <class MS,class E> friend E _mssup(const MS &ms) throw();
01326 template <class MS,class E> friend E _msdiam(const MS &ms) throw();
01327 template <class MS,class E> friend E _msmid(const MS &ms) throw();
01328 template <class MS1,class M2> friend MS1 &_msmsetinf(MS1 &ms1,const M2 &m2)
01329 #if(CXSC_INDEX_CHECK)
01330 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01331 #else
01332 throw();
01333 #endif
01334 template <class MS1,class M2> friend MS1 &_msmsetsup(MS1 &ms1,const M2 &m2)
01335 #if(CXSC_INDEX_CHECK)
01336 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01337 #else
01338 throw();
01339 #endif
01340 template <class MS1,class MS2> friend MS1 &_msmssetinf(MS1 &ms1,const MS2 &ms2)
01341 #if(CXSC_INDEX_CHECK)
01342 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01343 #else
01344 throw();
01345 #endif
01346 template <class MS1,class MS2> friend MS1 &_msmssetsup(MS1 &ms1,const MS2 &ms2)
01347 #if(CXSC_INDEX_CHECK)
01348 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01349 #else
01350 throw();
01351 #endif
01352 template <class MS1,class M2> friend MS1 &_msmusetinf(MS1 &ms1,const M2 &m2)
01353 #if(CXSC_INDEX_CHECK)
01354 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01355 #else
01356 throw();
01357 #endif
01358 template <class MS1,class M2> friend MS1 &_msmusetsup(MS1 &ms1,const M2 &m2)
01359 #if(CXSC_INDEX_CHECK)
01360 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01361 #else
01362 throw();
01363 #endif
01364 template <class MS1,class MS2> friend MS1 &_msmsusetinf(MS1 &ms1,const MS2 &ms2)
01365 #if(CXSC_INDEX_CHECK)
01366 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01367 #else
01368 throw();
01369 #endif
01370 template <class MS1,class MS2> friend MS1 &_msmsusetsup(MS1 &ms1,const MS2 &ms2)
01371 #if(CXSC_INDEX_CHECK)
01372 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01373 #else
01374 throw();
01375 #endif
01376
01377 template <class MS,class E> friend E _msminus(const MS &ms) throw();
01378 template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms)
01379 #if(CXSC_INDEX_CHECK)
01380 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01381 #else
01382 throw();
01383 #endif
01384 template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2)
01385 #if(CXSC_INDEX_CHECK)
01386 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01387 #else
01388 throw();
01389 #endif
01390 template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms)
01391 #if(CXSC_INDEX_CHECK)
01392 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01393 #else
01394 throw();
01395 #endif
01396 template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1)
01397 #if(CXSC_INDEX_CHECK)
01398 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01399 #else
01400 throw();
01401 #endif
01402 template <class MS1,class MS2> friend MS1 &_msmsplusassign(MS1 &ms1,const MS2 &ms2)
01403 #if(CXSC_INDEX_CHECK)
01404 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01405 #else
01406 throw();
01407 #endif
01408 template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms)
01409 #if(CXSC_INDEX_CHECK)
01410 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01411 #else
01412 throw();
01413 #endif
01414 template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m)
01415 #if(CXSC_INDEX_CHECK)
01416 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01417 #else
01418 throw();
01419 #endif
01420 template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2)
01421 #if(CXSC_INDEX_CHECK)
01422 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01423 #else
01424 throw();
01425 #endif
01426 template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms)
01427 #if(CXSC_INDEX_CHECK)
01428 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01429 #else
01430 throw();
01431 #endif
01432 template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1)
01433 #if(CXSC_INDEX_CHECK)
01434 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01435 #else
01436 throw();
01437 #endif
01438 template <class MS1,class MS2> friend MS1 &_msmsminusassign(MS1 &ms1,const MS2 &ms2)
01439 #if(CXSC_INDEX_CHECK)
01440 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01441 #else
01442 throw();
01443 #endif
01444 template <class M,class MS,class E> friend E _mmslimult(const M &m1, const MS &ms)
01445 #if(CXSC_INDEX_CHECK)
01446 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01447 #else
01448 throw();
01449 #endif
01450 template <class MS,class M,class E> friend E _msmlimult(const MS &ms, const M &m2)
01451 #if(CXSC_INDEX_CHECK)
01452 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01453 #else
01454 throw();
01455 #endif
01456 template <class M,class MS,class S> friend M &_mmslimultassign(M &m1,const MS &ms)
01457 #if(CXSC_INDEX_CHECK)
01458 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01459 #else
01460 throw();
01461 #endif
01462 template <class MS1,class MS2,class E> friend E _msmslimult(const MS1 &ms1, const MS2 &ms2)
01463 #if(CXSC_INDEX_CHECK)
01464 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01465 #else
01466 throw();
01467 #endif
01468 template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms)
01469 #if(CXSC_INDEX_CHECK)
01470 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01471 #else
01472 throw();
01473 #endif
01474 template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms)
01475 #if(CXSC_INDEX_CHECK)
01476 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01477 #else
01478 throw();
01479 #endif
01480 template <class MS,class M> friend MS &_msmconvassign(MS &ms,const M &m1)
01481 #if(CXSC_INDEX_CHECK)
01482 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01483 #else
01484 throw();
01485 #endif
01486 template <class MS1,class MS2> friend MS1 &_msmsconvassign(MS1 &ms1,const MS2 &ms2)
01487 #if(CXSC_INDEX_CHECK)
01488 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01489 #else
01490 throw();
01491 #endif
01492 template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2)
01493 #if(CXSC_INDEX_CHECK)
01494 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01495 #else
01496 throw();
01497 #endif
01498 template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms)
01499 #if(CXSC_INDEX_CHECK)
01500 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01501 #else
01502 throw();
01503 #endif
01504 template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms)
01505 #if(CXSC_INDEX_CHECK)
01506 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01507 #else
01508 throw();
01509 #endif
01510 template <class MS,class M> friend MS &_msmsectassign(MS &ms,const M &m1)
01511 #if(CXSC_INDEX_CHECK)
01512 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01513 #else
01514 throw();
01515 #endif
01516 template <class MS1,class MS2> friend MS1 &_msmssectassign(MS1 &ms1,const MS2 &ms2)
01517 #if(CXSC_INDEX_CHECK)
01518 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01519 #else
01520 throw();
01521 #endif
01522 template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2)
01523 #if(CXSC_INDEX_CHECK)
01524 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01525 #else
01526 throw();
01527 #endif
01528
01529 template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v)
01530 #if(CXSC_INDEX_CHECK)
01531 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01532 #else
01533 throw();
01534 #endif
01535 template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms)
01536 #if(CXSC_INDEX_CHECK)
01537 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01538 #else
01539 throw();
01540 #endif
01541 template <class V,class MS,class S> friend V &_vmslimultassign(V &v,const MS &ms)
01542 #if(CXSC_INDEX_CHECK)
01543 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01544 #else
01545 throw();
01546 #endif
01547
01548 template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) throw();
01549 template <class MS,class S> friend MS &_mssmultassign(MS &ms,const S &c) throw();
01550 template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) throw();
01551 template <class MS,class S> friend MS &_mssdivassign(MS &ms,const S &c) throw();
01552
01553 template <class MS> friend void *_msvoid(const MS &ms) throw();
01554 template <class MS> friend bool _msnot(const MS &ms) throw();
01555 template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) throw();
01556 template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) throw();
01557 template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) throw();
01558 template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) throw();
01559 template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) throw();
01560 template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) throw();
01561 template <class MS1,class MS2> friend bool _msmseq(const MS1 &ms1,const MS2 &ms2) throw();
01562 template <class MS1,class MS2> friend bool _msmsneq(const MS1 &ms1,const MS2 &ms2) throw();
01563 template <class MS1,class MS2> friend bool _msmsless(const MS1 &ms1,const MS2 &ms2) throw();
01564 template <class MS1,class MS2> friend bool _msmsleq(const MS1 &ms1,const MS2 &ms2) throw();
01565 template <class MS> friend std::ostream &_msout(std::ostream &s,const MS &r) throw();
01566 template <class MS> friend std::istream &_msin(std::istream &s,MS &r) throw();
01567
01568
01569 #endif
01570
01571
01572
01574 explicit INLINE l_imatrix_slice(l_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) { }
01576 explicit INLINE l_imatrix_slice(l_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) { }
01577 public:
01579 INLINE l_imatrix_slice(const l_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) { }
01580 public:
01581
01582
01583
01584 friend INLINE l_ivector::l_ivector(const l_imatrix_slice &sl)
01585 #if(CXSC_INDEX_CHECK)
01586 throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
01587 #else
01588 throw();
01589 #endif
01590 friend INLINE l_imatrix::l_imatrix(const l_imatrix_slice &) throw();
01592 INLINE l_imatrix_slice &operator =(const l_imatrix &m)
01593 #if(CXSC_INDEX_CHECK)
01594 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01595 #else
01596 throw();
01597 #endif
01598
01599 INLINE l_imatrix_slice &operator =(const l_imatrix_slice &ms)
01600 #if(CXSC_INDEX_CHECK)
01601 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01602 #else
01603 throw();
01604 #endif
01605
01606 INLINE l_imatrix_slice &operator =(const l_interval &r) throw();
01608 INLINE l_imatrix_slice &operator =(const l_ivector &v)
01609 #if(CXSC_INDEX_CHECK)
01610 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01611 #else
01612 throw();
01613 #endif
01614
01615 INLINE l_imatrix_slice &operator =(const l_ivector_slice &v)
01616 #if(CXSC_INDEX_CHECK)
01617 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01618 #else
01619 throw();
01620 #endif
01621
01622 INLINE l_imatrix_slice &operator =(const l_imatrix_subv &v)
01623 #if(CXSC_INDEX_CHECK)
01624 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01625 #else
01626 throw();
01627 #endif
01628
01630 INLINE l_imatrix_slice &operator =(const rmatrix &m)
01631 #if(CXSC_INDEX_CHECK)
01632 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01633 #else
01634 throw();
01635 #endif
01636
01637 INLINE l_imatrix_slice &operator =(const rmatrix_slice &ms)
01638 #if(CXSC_INDEX_CHECK)
01639 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01640 #else
01641 throw();
01642 #endif
01643
01644 INLINE l_imatrix_slice &operator =(const real &r) throw();
01646 INLINE l_imatrix_slice &operator =(const rvector &v)
01647 #if(CXSC_INDEX_CHECK)
01648 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01649 #else
01650 throw();
01651 #endif
01652
01653 INLINE l_imatrix_slice &operator =(const rvector_slice &v)
01654 #if(CXSC_INDEX_CHECK)
01655 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01656 #else
01657 throw();
01658 #endif
01659
01660 INLINE l_imatrix_slice &operator =(const rmatrix_subv &v)
01661 #if(CXSC_INDEX_CHECK)
01662 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01663 #else
01664 throw();
01665 #endif
01666
01667
01669 INLINE l_imatrix_slice &operator =(const imatrix &m)
01670 #if(CXSC_INDEX_CHECK)
01671 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01672 #else
01673 throw();
01674 #endif
01675
01676 INLINE l_imatrix_slice &operator =(const imatrix_slice &ms)
01677 #if(CXSC_INDEX_CHECK)
01678 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01679 #else
01680 throw();
01681 #endif
01682
01683 INLINE l_imatrix_slice &operator =(const interval &r) throw();
01685 INLINE l_imatrix_slice &operator =(const ivector &v)
01686 #if(CXSC_INDEX_CHECK)
01687 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01688 #else
01689 throw();
01690 #endif
01691
01692 INLINE l_imatrix_slice &operator =(const ivector_slice &v)
01693 #if(CXSC_INDEX_CHECK)
01694 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01695 #else
01696 throw();
01697 #endif
01698
01699 INLINE l_imatrix_slice &operator =(const imatrix_subv &v)
01700 #if(CXSC_INDEX_CHECK)
01701 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01702 #else
01703 throw();
01704 #endif
01705
01706
01708 INLINE l_imatrix_slice &operator =(const l_rmatrix &m)
01709 #if(CXSC_INDEX_CHECK)
01710 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01711 #else
01712 throw();
01713 #endif
01714
01715 INLINE l_imatrix_slice &operator =(const l_rmatrix_slice &ms)
01716 #if(CXSC_INDEX_CHECK)
01717 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01718 #else
01719 throw();
01720 #endif
01721
01722 INLINE l_imatrix_slice &operator =(const l_real &r) throw();
01724 INLINE l_imatrix_slice &operator =(const l_rvector &v)
01725 #if(CXSC_INDEX_CHECK)
01726 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01727 #else
01728 throw();
01729 #endif
01730
01731 INLINE l_imatrix_slice &operator =(const l_rvector_slice &v)
01732 #if(CXSC_INDEX_CHECK)
01733 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01734 #else
01735 throw();
01736 #endif
01737
01738 INLINE l_imatrix_slice &operator =(const l_rmatrix_subv &v)
01739 #if(CXSC_INDEX_CHECK)
01740 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01741 #else
01742 throw();
01743 #endif
01744
01746 INLINE l_imatrix_subv operator [](const int &i)
01747 #if(CXSC_INDEX_CHECK)
01748 throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT);
01749 #else
01750 throw();
01751 #endif
01752
01753 INLINE l_imatrix_subv operator [](const cxscmatrix_column &i)
01754 #if(CXSC_INDEX_CHECK)
01755 throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT);
01756 #else
01757 throw();
01758 #endif
01759
01760 INLINE l_imatrix_slice &operator ()() throw() { return *this; }
01762 INLINE l_imatrix_slice operator ()(const int &m, const int &n)
01763 #if(CXSC_INDEX_CHECK)
01764 throw(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG);
01765 #else
01766 throw();
01767 #endif
01768
01769 INLINE l_imatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
01770 #if(CXSC_INDEX_CHECK)
01771 throw(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG);
01772 #else
01773 throw();
01774 #endif
01775 INLINE operator void*() throw();
01776
01778 INLINE l_imatrix_slice &operator +=(const l_interval &c) throw();
01780 INLINE l_imatrix_slice &operator -=(const l_interval &c) throw();
01782 INLINE l_imatrix_slice &operator *=(const l_interval &c) throw();
01784 INLINE l_imatrix_slice &operator /=(const l_interval &c) throw();
01786 INLINE l_imatrix_slice &operator +=(const l_imatrix &m1)
01787 #if(CXSC_INDEX_CHECK)
01788 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01789 #else
01790 throw();
01791 #endif
01792
01793 INLINE l_imatrix_slice &operator +=(const l_imatrix_slice &ms2)
01794 #if(CXSC_INDEX_CHECK)
01795 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01796 #else
01797 throw();
01798 #endif
01799
01800 INLINE l_imatrix_slice &operator -=(const l_imatrix &m1)
01801 #if(CXSC_INDEX_CHECK)
01802 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01803 #else
01804 throw();
01805 #endif
01806
01807 INLINE l_imatrix_slice &operator -=(const l_imatrix_slice &ms2)
01808 #if(CXSC_INDEX_CHECK)
01809 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01810 #else
01811 throw();
01812 #endif
01813
01814 INLINE l_imatrix_slice &operator |=(const l_imatrix &m1)
01815 #if(CXSC_INDEX_CHECK)
01816 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01817 #else
01818 throw();
01819 #endif
01820
01821 INLINE l_imatrix_slice &operator |=(const l_imatrix_slice &ms2)
01822 #if(CXSC_INDEX_CHECK)
01823 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01824 #else
01825 throw();
01826 #endif
01827
01828 INLINE l_imatrix_slice &operator &=(const l_imatrix &m1)
01829 #if(CXSC_INDEX_CHECK)
01830 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01831 #else
01832 throw();
01833 #endif
01834
01835 INLINE l_imatrix_slice &operator &=(const l_imatrix_slice &ms2)
01836 #if(CXSC_INDEX_CHECK)
01837 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01838 #else
01839 throw();
01840 #endif
01841
01842 INLINE l_imatrix_slice &operator *=(const l_imatrix &m)
01843 #if(CXSC_INDEX_CHECK)
01844 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01845 #else
01846 throw();
01847 #endif
01848
01849 INLINE l_imatrix_slice &operator *=(const l_imatrix_slice &ms2)
01850 #if(CXSC_INDEX_CHECK)
01851 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01852 #else
01853 throw();
01854 #endif
01855
01857 INLINE l_imatrix_slice &operator +=(const real &c) throw();
01859 INLINE l_imatrix_slice &operator -=(const real &c) throw();
01861 INLINE l_imatrix_slice &operator *=(const real &c) throw();
01863 INLINE l_imatrix_slice &operator /=(const real &c) throw();
01865 INLINE l_imatrix_slice &operator +=(const rmatrix_slice &ms2)
01866 #if(CXSC_INDEX_CHECK)
01867 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01868 #else
01869 throw();
01870 #endif
01871
01872 INLINE l_imatrix_slice &operator +=(const rmatrix &m1)
01873 #if(CXSC_INDEX_CHECK)
01874 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01875 #else
01876 throw();
01877 #endif
01878
01879 INLINE l_imatrix_slice &operator -=(const rmatrix &m1)
01880 #if(CXSC_INDEX_CHECK)
01881 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01882 #else
01883 throw();
01884 #endif
01885
01886 INLINE l_imatrix_slice &operator -=(const rmatrix_slice &ms2)
01887 #if(CXSC_INDEX_CHECK)
01888 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01889 #else
01890 throw();
01891 #endif
01892
01893 INLINE l_imatrix_slice &operator |=(const rmatrix &m1)
01894 #if(CXSC_INDEX_CHECK)
01895 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01896 #else
01897 throw();
01898 #endif
01899
01900 INLINE l_imatrix_slice &operator |=(const rmatrix_slice &ms2)
01901 #if(CXSC_INDEX_CHECK)
01902 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01903 #else
01904 throw();
01905 #endif
01906
01907 INLINE l_imatrix_slice &operator &=(const rmatrix &m1)
01908 #if(CXSC_INDEX_CHECK)
01909 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01910 #else
01911 throw();
01912 #endif
01913
01914 INLINE l_imatrix_slice &operator &=(const rmatrix_slice &ms2)
01915 #if(CXSC_INDEX_CHECK)
01916 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01917 #else
01918 throw();
01919 #endif
01920
01921 INLINE l_imatrix_slice &operator *=(const rmatrix &m)
01922 #if(CXSC_INDEX_CHECK)
01923 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01924 #else
01925 throw();
01926 #endif
01927
01928 INLINE l_imatrix_slice &operator *=(const rmatrix_slice &ms2)
01929 #if(CXSC_INDEX_CHECK)
01930 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01931 #else
01932 throw();
01933 #endif
01934
01936 INLINE l_imatrix_slice &operator +=(const l_real &c) throw();
01938 INLINE l_imatrix_slice &operator -=(const l_real &c) throw();
01940 INLINE l_imatrix_slice &operator *=(const l_real &c) throw();
01942 INLINE l_imatrix_slice &operator /=(const l_real &c) throw();
01944 INLINE l_imatrix_slice &operator +=(const l_rmatrix_slice &ms2)
01945 #if(CXSC_INDEX_CHECK)
01946 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01947 #else
01948 throw();
01949 #endif
01950
01951 INLINE l_imatrix_slice &operator +=(const l_rmatrix &m1)
01952 #if(CXSC_INDEX_CHECK)
01953 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01954 #else
01955 throw();
01956 #endif
01957
01958 INLINE l_imatrix_slice &operator -=(const l_rmatrix &m1)
01959 #if(CXSC_INDEX_CHECK)
01960 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01961 #else
01962 throw();
01963 #endif
01964
01965 INLINE l_imatrix_slice &operator -=(const l_rmatrix_slice &ms2)
01966 #if(CXSC_INDEX_CHECK)
01967 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01968 #else
01969 throw();
01970 #endif
01971
01972 INLINE l_imatrix_slice &operator |=(const l_rmatrix &m1)
01973 #if(CXSC_INDEX_CHECK)
01974 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01975 #else
01976 throw();
01977 #endif
01978
01979 INLINE l_imatrix_slice &operator |=(const l_rmatrix_slice &ms2)
01980 #if(CXSC_INDEX_CHECK)
01981 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01982 #else
01983 throw();
01984 #endif
01985
01986 INLINE l_imatrix_slice &operator &=(const l_rmatrix &m1)
01987 #if(CXSC_INDEX_CHECK)
01988 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01989 #else
01990 throw();
01991 #endif
01992
01993 INLINE l_imatrix_slice &operator &=(const l_rmatrix_slice &ms2)
01994 #if(CXSC_INDEX_CHECK)
01995 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01996 #else
01997 throw();
01998 #endif
01999
02000 INLINE l_imatrix_slice &operator *=(const l_rmatrix &m)
02001 #if(CXSC_INDEX_CHECK)
02002 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02003 #else
02004 throw();
02005 #endif
02006
02007 INLINE l_imatrix_slice &operator *=(const l_rmatrix_slice &ms2)
02008 #if(CXSC_INDEX_CHECK)
02009 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02010 #else
02011 throw();
02012 #endif
02013
02015 INLINE l_imatrix_slice &operator +=(const interval &c) throw();
02017 INLINE l_imatrix_slice &operator -=(const interval &c) throw();
02019 INLINE l_imatrix_slice &operator *=(const interval &c) throw();
02021 INLINE l_imatrix_slice &operator /=(const interval &c) throw();
02023 INLINE l_imatrix_slice &operator +=(const imatrix_slice &ms2)
02024 #if(CXSC_INDEX_CHECK)
02025 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02026 #else
02027 throw();
02028 #endif
02029
02030 INLINE l_imatrix_slice &operator +=(const imatrix &m1)
02031 #if(CXSC_INDEX_CHECK)
02032 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02033 #else
02034 throw();
02035 #endif
02036
02037 INLINE l_imatrix_slice &operator -=(const imatrix &m1)
02038 #if(CXSC_INDEX_CHECK)
02039 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02040 #else
02041 throw();
02042 #endif
02043
02044 INLINE l_imatrix_slice &operator -=(const imatrix_slice &ms2)
02045 #if(CXSC_INDEX_CHECK)
02046 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02047 #else
02048 throw();
02049 #endif
02050
02051 INLINE l_imatrix_slice &operator |=(const imatrix &m1)
02052 #if(CXSC_INDEX_CHECK)
02053 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02054 #else
02055 throw();
02056 #endif
02057
02058 INLINE l_imatrix_slice &operator |=(const imatrix_slice &ms2)
02059 #if(CXSC_INDEX_CHECK)
02060 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02061 #else
02062 throw();
02063 #endif
02064
02065 INLINE l_imatrix_slice &operator &=(const imatrix &m1)
02066 #if(CXSC_INDEX_CHECK)
02067 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02068 #else
02069 throw();
02070 #endif
02071
02072 INLINE l_imatrix_slice &operator &=(const imatrix_slice &ms2)
02073 #if(CXSC_INDEX_CHECK)
02074 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02075 #else
02076 throw();
02077 #endif
02078
02079 INLINE l_imatrix_slice &operator *=(const imatrix &m)
02080 #if(CXSC_INDEX_CHECK)
02081 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02082 #else
02083 throw();
02084 #endif
02085
02086 INLINE l_imatrix_slice &operator *=(const imatrix_slice &ms2)
02087 #if(CXSC_INDEX_CHECK)
02088 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02089 #else
02090 throw();
02091 #endif
02092
02093
02094
02095 };
02096
02097
02098
02099
02100
02101
02103 INLINE l_ivector operator /(const l_imatrix_subv &rv, const l_interval &s) throw();
02105 INLINE l_ivector operator *(const l_imatrix_subv &rv, const l_interval &s) throw();
02107 INLINE l_ivector operator *(const l_interval &s, const l_imatrix_subv &rv) throw();
02109 INLINE l_ivector abs(const l_imatrix_subv &mv) throw();
02111 INLINE l_rvector diam(const l_imatrix_subv &mv) throw();
02113 INLINE l_rvector mid(const l_imatrix_subv &mv) throw();
02115 INLINE l_rvector Inf(const l_imatrix_subv &mv) throw();
02117 INLINE l_rvector Sup(const l_imatrix_subv &mv) throw();
02119 INLINE l_imatrix_subv &SetInf(l_imatrix_subv &iv,const l_rvector &rv)
02120 #if(CXSC_INDEX_CHECK)
02121 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02122 #else
02123 throw();
02124 #endif
02125
02126 INLINE l_imatrix_subv &SetSup(l_imatrix_subv &iv,const l_rvector &rv)
02127 #if(CXSC_INDEX_CHECK)
02128 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02129 #else
02130 throw();
02131 #endif
02132
02133 INLINE l_imatrix_subv &UncheckedSetInf(l_imatrix_subv &iv,const l_rvector &rv)
02134 #if(CXSC_INDEX_CHECK)
02135 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02136 #else
02137 throw();
02138 #endif
02139
02140 INLINE l_imatrix_subv &UncheckedSetSup(l_imatrix_subv &iv,const l_rvector &rv)
02141 #if(CXSC_INDEX_CHECK)
02142 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02143 #else
02144 throw();
02145 #endif
02146
02148 INLINE l_imatrix_subv &SetSup(l_imatrix_subv &iv,const l_real &r) throw();
02150 INLINE l_imatrix_subv &SetInf(l_imatrix_subv &iv,const l_real &r) throw();
02152 INLINE l_imatrix_subv &UncheckedSetSup(l_imatrix_subv &iv,const l_real &r) throw();
02154 INLINE l_imatrix_subv &SetUncheckedInf(l_imatrix_subv &iv,const l_real &r) throw();
02155
02156
02157
02158
02160 INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_imatrix_subv &rv2)
02161 #if(CXSC_INDEX_CHECK)
02162 throw(OP_WITH_WRONG_DIM);
02163 #else
02164 throw();
02165 #endif
02166
02167 INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const l_imatrix_subv &rv2)
02168 #if(CXSC_INDEX_CHECK)
02169 throw(OP_WITH_WRONG_DIM);
02170 #else
02171 throw();
02172 #endif
02173
02174 INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_ivector &rv2)
02175 #if(CXSC_INDEX_CHECK)
02176 throw(OP_WITH_WRONG_DIM);
02177 #else
02178 throw();
02179 #endif
02180
02181 INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl1, const l_imatrix_subv &rv2)
02182 #if(CXSC_INDEX_CHECK)
02183 throw(OP_WITH_WRONG_DIM);
02184 #else
02185 throw();
02186 #endif
02187
02188 INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_ivector_slice &sl2)
02189 #if(CXSC_INDEX_CHECK)
02190 throw(OP_WITH_WRONG_DIM);
02191 #else
02192 throw();
02193 #endif
02194
02196 INLINE l_interval operator *(const l_imatrix_subv & rv1, const l_imatrix_subv &rv2)
02197 #if(CXSC_INDEX_CHECK)
02198 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
02199 #else
02200 throw();
02201 #endif
02202
02203 INLINE l_interval operator *(const l_ivector & rv1, const l_imatrix_subv &rv2)
02204 #if(CXSC_INDEX_CHECK)
02205 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
02206 #else
02207 throw();
02208 #endif
02209
02210 INLINE l_interval operator *(const l_imatrix_subv &rv1,const l_ivector &rv2)
02211 #if(CXSC_INDEX_CHECK)
02212 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
02213 #else
02214 throw();
02215 #endif
02216
02217 INLINE l_interval operator *(const l_ivector_slice &sl,const l_imatrix_subv &sv)
02218 #if(CXSC_INDEX_CHECK)
02219 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
02220 #else
02221 throw();
02222 #endif
02223
02224 INLINE l_interval operator *(const l_imatrix_subv &mv,const l_ivector_slice &vs)
02225 #if(CXSC_INDEX_CHECK)
02226 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
02227 #else
02228 throw();
02229 #endif
02230
02232 INLINE l_ivector operator +(const l_imatrix_subv & rv1, const l_imatrix_subv &rv2)
02233 #if(CXSC_INDEX_CHECK)
02234 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
02235 #else
02236 throw();
02237 #endif
02238
02239 INLINE l_ivector operator +(const l_imatrix_subv &rv1,const l_ivector &rv2)
02240 #if(CXSC_INDEX_CHECK)
02241 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
02242 #else
02243 throw();
02244 #endif
02245
02246 INLINE l_ivector operator +(const l_ivector & rv1, const l_imatrix_subv &rv2)
02247 #if(CXSC_INDEX_CHECK)
02248 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
02249 #else
02250 throw();
02251 #endif
02252
02253 INLINE l_ivector operator +(const l_ivector_slice &sl,const l_imatrix_subv &mv)
02254 #if(CXSC_INDEX_CHECK)
02255 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
02256 #else
02257 throw();
02258 #endif
02259
02260 INLINE l_ivector operator +(const l_imatrix_subv &mv,const l_ivector_slice &sl)
02261 #if(CXSC_INDEX_CHECK)
02262 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
02263 #else
02264 throw();
02265 #endif
02266
02268 INLINE l_ivector operator -(const l_imatrix_subv & rv1, const l_imatrix_subv &rv2)
02269 #if(CXSC_INDEX_CHECK)
02270 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
02271 #else
02272 throw();
02273 #endif
02274
02275 INLINE l_ivector operator -(const l_ivector & rv1, const l_imatrix_subv &rv2)
02276 #if(CXSC_INDEX_CHECK)
02277 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
02278 #else
02279 throw();
02280 #endif
02281
02282 INLINE l_ivector operator -(const l_imatrix_subv &rv1,const l_ivector &rv2)
02283 #if(CXSC_INDEX_CHECK)
02284 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
02285 #else
02286 throw();
02287 #endif
02288
02289 INLINE l_ivector operator -(const l_ivector_slice &sl,const l_imatrix_subv &mv)
02290 #if(CXSC_INDEX_CHECK)
02291 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
02292 #else
02293 throw();
02294 #endif
02295
02296 INLINE l_ivector operator -(const l_imatrix_subv &mv,const l_ivector_slice &sl)
02297 #if(CXSC_INDEX_CHECK)
02298 throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
02299 #else
02300 throw();
02301 #endif
02302
02303
02304
02306 INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const rmatrix_subv &rv2)
02307 #if(CXSC_INDEX_CHECK)
02308 throw(OP_WITH_WRONG_DIM);
02309 #else
02310 throw();
02311 #endif
02312
02313 INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const rvector_slice &sl2)
02314 #if(CXSC_INDEX_CHECK)
02315 throw(OP_WITH_WRONG_DIM);
02316 #else
02317 throw();
02318 #endif
02319
02320 INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const rvector &rv2)
02321 #if(CXSC_INDEX_CHECK)
02322 throw(OP_WITH_WRONG_DIM);
02323 #else
02324 throw();
02325 #endif
02326
02327 INLINE void accumulate(idotprecision &dp, const rvector & rv1, const l_imatrix_subv &rv2)
02328 #if(CXSC_INDEX_CHECK)
02329 throw(OP_WITH_WRONG_DIM);
02330 #else
02331 throw();
02332 #endif
02333
02334 INLINE void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const l_imatrix_subv &rv2)
02335 #if(CXSC_INDEX_CHECK)
02336 throw(OP_WITH_WRONG_DIM);
02337 #else
02338 throw();
02339 #endif
02340
02341 INLINE void accumulate(idotprecision &dp, const rvector_slice & sl1, const l_imatrix_subv &rv2)
02342 #if(CXSC_INDEX_CHECK)
02343 throw(OP_WITH_WRONG_DIM);
02344 #else
02345 throw();
02346 #endif
02347
02348
02349
02351 INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_rmatrix_subv &rv2)
02352 #if(CXSC_INDEX_CHECK)
02353 throw(OP_WITH_WRONG_DIM);
02354 #else
02355 throw();
02356 #endif
02357
02358 INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_rvector_slice &sl2)
02359 #if(CXSC_INDEX_CHECK)
02360 throw(OP_WITH_WRONG_DIM);
02361 #else
02362 throw();
02363 #endif
02364
02365 INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_rvector &rv2)
02366 #if(CXSC_INDEX_CHECK)
02367 throw(OP_WITH_WRONG_DIM);
02368 #else
02369 throw();
02370 #endif
02371
02372 INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const l_imatrix_subv &rv2)
02373 #if(CXSC_INDEX_CHECK)
02374 throw(OP_WITH_WRONG_DIM);
02375 #else
02376 throw();
02377 #endif
02378
02379 INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const l_imatrix_subv &rv2)
02380 #if(CXSC_INDEX_CHECK)
02381 throw(OP_WITH_WRONG_DIM);
02382 #else
02383 throw();
02384 #endif
02385
02386 INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl1, const l_imatrix_subv &rv2)
02387 #if(CXSC_INDEX_CHECK)
02388 throw(OP_WITH_WRONG_DIM);
02389 #else
02390 throw();
02391 #endif
02392
02393
02394
02396 INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const imatrix_subv &rv2)
02397 #if(CXSC_INDEX_CHECK)
02398 throw(OP_WITH_WRONG_DIM);
02399 #else
02400 throw();
02401 #endif
02402
02403 INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const ivector_slice &sl2)
02404 #if(CXSC_INDEX_CHECK)
02405 throw(OP_WITH_WRONG_DIM);
02406 #else
02407 throw();
02408 #endif
02409
02410 INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const ivector &rv2)
02411 #if(CXSC_INDEX_CHECK)
02412 throw(OP_WITH_WRONG_DIM);
02413 #else
02414 throw();
02415 #endif
02416
02417 INLINE void accumulate(idotprecision &dp, const ivector & rv1, const l_imatrix_subv &rv2)
02418 #if(CXSC_INDEX_CHECK)
02419 throw(OP_WITH_WRONG_DIM);
02420 #else
02421 throw();
02422 #endif
02423
02424 INLINE void accumulate(idotprecision &dp, const imatrix_subv & rv1, const l_imatrix_subv &rv2)
02425 #if(CXSC_INDEX_CHECK)
02426 throw(OP_WITH_WRONG_DIM);
02427 #else
02428 throw();
02429 #endif
02430
02431 INLINE void accumulate(idotprecision &dp, const ivector_slice & sl1, const l_imatrix_subv &rv2)
02432 #if(CXSC_INDEX_CHECK)
02433 throw(OP_WITH_WRONG_DIM);
02434 #else
02435 throw();
02436 #endif
02437
02438
02439
02440
02441
02443 INLINE l_imatrix _imatrix(const l_imatrix &rm) throw();
02445 INLINE l_imatrix _imatrix(const l_ivector &v) throw();
02447 INLINE l_imatrix _imatrix(const l_ivector_slice &v) throw();
02449 INLINE l_imatrix _imatrix(const l_interval &r) throw();
02450
02452 INLINE int Lb(const l_imatrix &rm, const int &i)
02453 #if(CXSC_INDEX_CHECK)
02454 throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL);
02455 #else
02456 throw();
02457 #endif
02458
02459 INLINE int Ub(const l_imatrix &rm, const int &i)
02460 #if(CXSC_INDEX_CHECK)
02461 throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL);
02462 #else
02463 throw();
02464 #endif
02465
02466 INLINE int Lb(const l_imatrix_slice &rm, const int &i)
02467 #if(CXSC_INDEX_CHECK)
02468 throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL);
02469 #else
02470 throw();
02471 #endif
02472
02473 INLINE int Ub(const l_imatrix_slice &rm, const int &i)
02474 #if(CXSC_INDEX_CHECK)
02475 throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL);
02476 #else
02477 throw();
02478 #endif
02479
02480 INLINE l_imatrix &SetLb(l_imatrix &m, const int &i,const int &j)
02481 #if(CXSC_INDEX_CHECK)
02482 throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL);
02483 #else
02484 throw();
02485 #endif
02486
02487 INLINE l_imatrix &SetUb(l_imatrix &m, const int &i,const int &j)
02488 #if(CXSC_INDEX_CHECK)
02489 throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL);
02490 #else
02491 throw();
02492 #endif
02493
02494 INLINE void Resize(l_imatrix &A) throw();
02496 INLINE void Resize(l_imatrix &A,const int &m, const int &n)
02497 #if(CXSC_INDEX_CHECK)
02498 throw(ERROR_LIMATRIX_WRONG_BOUNDARIES);
02499 #else
02500 throw();
02501 #endif
02502
02503 INLINE void Resize(l_imatrix &A,const int &m1, const int &m2,const int &n1,const int &n2)
02504 #if(CXSC_INDEX_CHECK)
02505 throw(ERROR_LIMATRIX_WRONG_BOUNDARIES);
02506 #else
02507 throw();
02508 #endif
02509
02511 INLINE l_imatrix abs(const l_imatrix &m) throw();
02513 INLINE l_imatrix abs(const l_imatrix_slice &ms) throw();
02515 INLINE l_rmatrix diam(const l_imatrix &m) throw();
02517 INLINE l_rmatrix diam(const l_imatrix_slice &m) throw();
02519 INLINE l_rmatrix mid(const l_imatrix &m) throw();
02521 INLINE l_rmatrix mid(const l_imatrix_slice &m) throw();
02523 INLINE l_rmatrix Inf(const l_imatrix &m) throw();
02525 INLINE l_rmatrix Sup(const l_imatrix &m) throw();
02527 INLINE l_rmatrix Inf(const l_imatrix_slice &m) throw();
02529 INLINE l_rmatrix Sup(const l_imatrix_slice &m) throw();
02531 INLINE l_imatrix &SetInf(l_imatrix &cm,const l_rmatrix &rm)
02532 #if(CXSC_INDEX_CHECK)
02533 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02534 #else
02535 throw();
02536 #endif
02537
02538 INLINE l_imatrix_slice &SetInf(l_imatrix_slice &cm,const l_rmatrix &rm)
02539 #if(CXSC_INDEX_CHECK)
02540 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02541 #else
02542 throw();
02543 #endif
02544
02545 INLINE l_imatrix &SetInf(l_imatrix &cm,const l_rmatrix_slice &rm)
02546 #if(CXSC_INDEX_CHECK)
02547 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02548 #else
02549 throw();
02550 #endif
02551
02552 INLINE l_imatrix_slice &SetInf(l_imatrix_slice &cm,const l_rmatrix_slice &rm)
02553 #if(CXSC_INDEX_CHECK)
02554 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02555 #else
02556 throw();
02557 #endif
02558
02559 INLINE l_imatrix &SetSup(l_imatrix &cm,const l_rmatrix &rm)
02560 #if(CXSC_INDEX_CHECK)
02561 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02562 #else
02563 throw();
02564 #endif
02565
02566 INLINE l_imatrix_slice &SetSup(l_imatrix_slice &cm,const l_rmatrix &rm)
02567 #if(CXSC_INDEX_CHECK)
02568 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02569 #else
02570 throw();
02571 #endif
02572
02573 INLINE l_imatrix &SetSup(l_imatrix &cm,const l_rmatrix_slice &rm)
02574 #if(CXSC_INDEX_CHECK)
02575 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02576 #else
02577 throw();
02578 #endif
02579
02580 INLINE l_imatrix_slice &SetSup(l_imatrix_slice &cm,const l_rmatrix_slice &rm)
02581 #if(CXSC_INDEX_CHECK)
02582 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02583 #else
02584 throw();
02585 #endif
02586
02587 INLINE l_imatrix &UncheckedSetInf(l_imatrix &cm,const l_rmatrix &rm)
02588 #if(CXSC_INDEX_CHECK)
02589 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02590 #else
02591 throw();
02592 #endif
02593
02594 INLINE l_imatrix_slice &UncheckedSetInf(l_imatrix_slice &cm,const l_rmatrix &rm)
02595 #if(CXSC_INDEX_CHECK)
02596 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02597 #else
02598 throw();
02599 #endif
02600
02601 INLINE l_imatrix &UncheckedSetInf(l_imatrix &cm,const l_rmatrix_slice &rm)
02602 #if(CXSC_INDEX_CHECK)
02603 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02604 #else
02605 throw();
02606 #endif
02607
02608 INLINE l_imatrix_slice &UncheckedSetInf(l_imatrix_slice &cm,const l_rmatrix_slice &rm)
02609 #if(CXSC_INDEX_CHECK)
02610 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02611 #else
02612 throw();
02613 #endif
02614
02615 INLINE l_imatrix &UncheckedSetSup(l_imatrix &cm,const l_rmatrix &rm)
02616 #if(CXSC_INDEX_CHECK)
02617 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02618 #else
02619 throw();
02620 #endif
02621
02622 INLINE l_imatrix_slice &UncheckedSetSup(l_imatrix_slice &cm,const l_rmatrix &rm)
02623 #if(CXSC_INDEX_CHECK)
02624 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02625 #else
02626 throw();
02627 #endif
02628
02629 INLINE l_imatrix &UncheckedSetSup(l_imatrix &cm,const l_rmatrix_slice &rm)
02630 #if(CXSC_INDEX_CHECK)
02631 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02632 #else
02633 throw();
02634 #endif
02635
02636 INLINE l_imatrix_slice &UncheckedSetSup(l_imatrix_slice &cm,const l_rmatrix_slice &rm)
02637 #if(CXSC_INDEX_CHECK)
02638 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02639 #else
02640 throw();
02641 #endif
02642
02643
02644
02646 INLINE l_imatrix operator *(const l_interval &c, const l_imatrix &m) throw();
02648 INLINE l_imatrix operator *(const l_interval &c, const l_imatrix_slice &ms) throw();
02650 INLINE l_imatrix operator *(const l_imatrix &m,const l_interval &c) throw();
02652 INLINE l_imatrix operator *(const l_imatrix_slice &ms,const l_interval &c) throw();
02654 INLINE l_imatrix &operator *=(l_imatrix &m,const l_interval &c) throw();
02656 INLINE l_imatrix operator /(const l_imatrix &m,const l_interval &c) throw();
02658 INLINE l_imatrix operator /(const l_imatrix_slice &ms, const l_interval &c) throw();
02660 INLINE l_imatrix &operator /=(l_imatrix &m,const l_interval &c) throw();
02661
02662
02663
02665 INLINE l_imatrix operator *(const real &c, const l_imatrix &m) throw();
02667 INLINE l_imatrix operator *(const real &c, const l_imatrix_slice &ms) throw();
02669 INLINE l_imatrix operator *(const l_imatrix &m,const real &c) throw();
02671 INLINE l_imatrix operator *(const l_imatrix_slice &ms,const real &c) throw();
02673 INLINE l_imatrix &operator *=(l_imatrix &m,const real &c) throw();
02675 INLINE l_imatrix operator /(const l_imatrix &m,const real &c) throw();
02677 INLINE l_imatrix operator /(const l_imatrix_slice &ms, const real &c) throw();
02679 INLINE l_imatrix &operator /=(l_imatrix &m,const real &c) throw();
02680
02681
02683 INLINE l_imatrix operator *(const l_interval &c, const rmatrix &m) throw();
02685 INLINE l_imatrix operator *(const l_interval &c, const rmatrix_slice &ms) throw();
02687 INLINE l_imatrix operator *(const rmatrix &m,const l_interval &c) throw();
02689 INLINE l_imatrix operator *(const rmatrix_slice &ms,const l_interval &c) throw();
02691 INLINE l_imatrix operator /(const rmatrix &m,const l_interval &c) throw();
02693 INLINE l_imatrix operator /(const rmatrix_slice &ms, const l_interval &c) throw();
02694
02695
02696
02698 INLINE l_imatrix operator *(const l_real &c, const l_imatrix &m) throw();
02700 INLINE l_imatrix operator *(const l_real &c, const l_imatrix_slice &ms) throw();
02702 INLINE l_imatrix operator *(const l_imatrix &m,const l_real &c) throw();
02704 INLINE l_imatrix operator *(const l_imatrix_slice &ms,const l_real &c) throw();
02706 INLINE l_imatrix &operator *=(l_imatrix &m,const l_real &c) throw();
02708 INLINE l_imatrix operator /(const l_imatrix &m,const l_real &c) throw();
02710 INLINE l_imatrix operator /(const l_imatrix_slice &ms, const l_real &c) throw();
02712 INLINE l_imatrix &operator /=(l_imatrix &m,const l_real &c) throw();
02713
02714
02716 INLINE l_imatrix operator *(const l_interval &c, const l_rmatrix &m) throw();
02718 INLINE l_imatrix operator *(const l_interval &c, const l_rmatrix_slice &ms) throw();
02720 INLINE l_imatrix operator *(const l_rmatrix &m,const l_interval &c) throw();
02722 INLINE l_imatrix operator *(const l_rmatrix_slice &ms,const l_interval &c) throw();
02724 INLINE l_imatrix operator /(const l_rmatrix &m,const l_interval &c) throw();
02726 INLINE l_imatrix operator /(const l_rmatrix_slice &ms, const l_interval &c) throw();
02727
02728
02729
02731 INLINE l_imatrix operator *(const interval &c, const l_imatrix &m) throw();
02733 INLINE l_imatrix operator *(const interval &c, const l_imatrix_slice &ms) throw();
02735 INLINE l_imatrix operator *(const l_imatrix &m,const interval &c) throw();
02737 INLINE l_imatrix operator *(const l_imatrix_slice &ms,const interval &c) throw();
02739 INLINE l_imatrix &operator *=(l_imatrix &m,const interval &c) throw();
02741 INLINE l_imatrix operator /(const l_imatrix &m,const interval &c) throw();
02743 INLINE l_imatrix operator /(const l_imatrix_slice &ms, const interval &c) throw();
02745 INLINE l_imatrix &operator /=(l_imatrix &m,const interval &c) throw();
02746
02747
02749 INLINE l_imatrix operator *(const l_interval &c, const imatrix &m) throw();
02751 INLINE l_imatrix operator *(const l_interval &c, const imatrix_slice &ms) throw();
02753 INLINE l_imatrix operator *(const imatrix &m,const l_interval &c) throw();
02755 INLINE l_imatrix operator *(const imatrix_slice &ms,const l_interval &c) throw();
02757 INLINE l_imatrix operator /(const imatrix &m,const l_interval &c) throw();
02759 INLINE l_imatrix operator /(const imatrix_slice &ms, const l_interval &c) throw();
02760
02761
02762
02763
02764
02766 INLINE l_ivector operator *(const l_imatrix &m,const l_ivector &v)
02767 #if(CXSC_INDEX_CHECK)
02768 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02769 #else
02770 throw();
02771 #endif
02772
02773 INLINE l_ivector operator *(const l_imatrix_slice &ms,const l_ivector &v)
02774 #if(CXSC_INDEX_CHECK)
02775 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02776 #else
02777 throw();
02778 #endif
02779
02780 INLINE l_ivector operator *(const l_ivector &v,const l_imatrix &m)
02781 #if(CXSC_INDEX_CHECK)
02782 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02783 #else
02784 throw();
02785 #endif
02786
02787 INLINE l_ivector operator *(const l_ivector &v,const l_imatrix_slice &ms)
02788 #if(CXSC_INDEX_CHECK)
02789 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02790 #else
02791 throw();
02792 #endif
02793
02794 INLINE l_ivector &operator *=(l_ivector &v,const l_imatrix &m)
02795 #if(CXSC_INDEX_CHECK)
02796 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02797 #else
02798 throw();
02799 #endif
02800
02801 INLINE l_ivector &operator *=(l_ivector &v,const l_imatrix_slice &ms)
02802 #if(CXSC_INDEX_CHECK)
02803 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02804 #else
02805 throw();
02806 #endif
02807
02809 INLINE l_ivector operator *(const l_ivector_slice &v,const l_imatrix &m)
02810 #if(CXSC_INDEX_CHECK)
02811 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02812 #else
02813 throw();
02814 #endif
02815
02816 INLINE l_ivector operator *(const l_ivector_slice &v,const l_imatrix_slice &m)
02817 #if(CXSC_INDEX_CHECK)
02818 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02819 #else
02820 throw();
02821 #endif
02822
02823
02824
02826 INLINE l_ivector operator *(const rvector &v,const l_imatrix &m)
02827 #if(CXSC_INDEX_CHECK)
02828 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02829 #else
02830 throw();
02831 #endif
02832
02833 INLINE l_ivector operator *(const rvector &v,const l_imatrix_slice &ms)
02834 #if(CXSC_INDEX_CHECK)
02835 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02836 #else
02837 throw();
02838 #endif
02839
02840 INLINE l_ivector operator *(const rvector_slice &v,const l_imatrix &m)
02841 #if(CXSC_INDEX_CHECK)
02842 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02843 #else
02844 throw();
02845 #endif
02846
02848 INLINE l_ivector operator *(const l_imatrix &m,const rvector &v)
02849 #if(CXSC_INDEX_CHECK)
02850 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02851 #else
02852 throw();
02853 #endif
02854
02855 INLINE l_ivector operator *(const l_imatrix_slice &ms,const rvector &v)
02856 #if(CXSC_INDEX_CHECK)
02857 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02858 #else
02859 throw();
02860 #endif
02861
02862
02863
02865 INLINE l_ivector operator *(const l_rvector &v,const l_imatrix &m)
02866 #if(CXSC_INDEX_CHECK)
02867 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02868 #else
02869 throw();
02870 #endif
02871
02872 INLINE l_ivector operator *(const l_rvector &v,const l_imatrix_slice &ms)
02873 #if(CXSC_INDEX_CHECK)
02874 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02875 #else
02876 throw();
02877 #endif
02878
02879 INLINE l_ivector operator *(const l_rvector_slice &v,const l_imatrix &m)
02880 #if(CXSC_INDEX_CHECK)
02881 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02882 #else
02883 throw();
02884 #endif
02885
02887 INLINE l_ivector operator *(const l_imatrix &m,const l_rvector &v)
02888 #if(CXSC_INDEX_CHECK)
02889 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02890 #else
02891 throw();
02892 #endif
02893
02894 INLINE l_ivector operator *(const l_imatrix_slice &ms,const l_rvector &v)
02895 #if(CXSC_INDEX_CHECK)
02896 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02897 #else
02898 throw();
02899 #endif
02900
02901
02902
02904 INLINE l_ivector operator *(const ivector &v,const l_imatrix &m)
02905 #if(CXSC_INDEX_CHECK)
02906 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02907 #else
02908 throw();
02909 #endif
02910
02911 INLINE l_ivector operator *(const ivector &v,const l_imatrix_slice &ms)
02912 #if(CXSC_INDEX_CHECK)
02913 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02914 #else
02915 throw();
02916 #endif
02917
02918 INLINE l_ivector operator *(const ivector_slice &v,const l_imatrix &m)
02919 #if(CXSC_INDEX_CHECK)
02920 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02921 #else
02922 throw();
02923 #endif
02924
02926 INLINE l_ivector operator *(const l_imatrix &m,const ivector &v)
02927 #if(CXSC_INDEX_CHECK)
02928 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02929 #else
02930 throw();
02931 #endif
02932
02933 INLINE l_ivector operator *(const l_imatrix_slice &ms,const ivector &v)
02934 #if(CXSC_INDEX_CHECK)
02935 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02936 #else
02937 throw();
02938 #endif
02939
02940
02941
02942
02944 INLINE const l_imatrix &operator +(const l_imatrix &m1) throw();
02946 INLINE l_imatrix operator +(const l_imatrix_slice &ms) throw();
02948 INLINE l_imatrix operator +(const l_imatrix &m1,const l_imatrix &m2)
02949 #if(CXSC_INDEX_CHECK)
02950 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02951 #else
02952 throw();
02953 #endif
02954
02955 INLINE l_imatrix operator +(const l_imatrix &m,const l_imatrix_slice &ms)
02956 #if(CXSC_INDEX_CHECK)
02957 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02958 #else
02959 throw();
02960 #endif
02961
02962 INLINE l_imatrix operator +(const l_imatrix_slice &ms,const l_imatrix &m)
02963 #if(CXSC_INDEX_CHECK)
02964 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02965 #else
02966 throw();
02967 #endif
02968
02969 INLINE l_imatrix operator +(const l_imatrix_slice &m1,const l_imatrix_slice &m2)
02970 #if(CXSC_INDEX_CHECK)
02971 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02972 #else
02973 throw();
02974 #endif
02975
02976 INLINE l_imatrix &operator +=(l_imatrix &m1,const l_imatrix &m2)
02977 #if(CXSC_INDEX_CHECK)
02978 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02979 #else
02980 throw();
02981 #endif
02982
02983 INLINE l_imatrix &operator +=(l_imatrix &m1,const l_imatrix_slice &ms)
02984 #if(CXSC_INDEX_CHECK)
02985 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02986 #else
02987 throw();
02988 #endif
02989
02991 INLINE l_imatrix operator -(const l_imatrix &m) throw();
02993 INLINE l_imatrix operator -(const l_imatrix_slice &ms) throw();
02995 INLINE l_imatrix operator -(const l_imatrix &m1,const l_imatrix &m2)
02996 #if(CXSC_INDEX_CHECK)
02997 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02998 #else
02999 throw();
03000 #endif
03001
03002 INLINE l_imatrix operator -(const l_imatrix &m,const l_imatrix_slice &ms)
03003 #if(CXSC_INDEX_CHECK)
03004 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03005 #else
03006 throw();
03007 #endif
03008
03009 INLINE l_imatrix operator -(const l_imatrix_slice &ms,const l_imatrix &m)
03010 #if(CXSC_INDEX_CHECK)
03011 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03012 #else
03013 throw();
03014 #endif
03015
03016 INLINE l_imatrix operator -(const l_imatrix_slice &ms1,const l_imatrix_slice &ms2)
03017 #if(CXSC_INDEX_CHECK)
03018 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03019 #else
03020 throw();
03021 #endif
03022
03023 INLINE l_imatrix &operator -=(l_imatrix &m1,const l_imatrix &m2)
03024 #if(CXSC_INDEX_CHECK)
03025 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03026 #else
03027 throw();
03028 #endif
03029
03030 INLINE l_imatrix &operator -=(l_imatrix &m1,const l_imatrix_slice &ms)
03031 #if(CXSC_INDEX_CHECK)
03032 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03033 #else
03034 throw();
03035 #endif
03036
03038 INLINE l_imatrix operator *(const l_imatrix &m1, const l_imatrix &m2)
03039 #if(CXSC_INDEX_CHECK)
03040 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03041 #else
03042 throw();
03043 #endif
03044
03045 INLINE l_imatrix operator *(const l_imatrix &m1, const l_imatrix_slice &ms)
03046 #if(CXSC_INDEX_CHECK)
03047 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03048 #else
03049 throw();
03050 #endif
03051
03052 INLINE l_imatrix operator *(const l_imatrix_slice &ms, const l_imatrix &m1)
03053 #if(CXSC_INDEX_CHECK)
03054 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03055 #else
03056 throw();
03057 #endif
03058
03059 INLINE l_imatrix operator *(const l_imatrix_slice &ms1, const l_imatrix_slice &ms2)
03060 #if(CXSC_INDEX_CHECK)
03061 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03062 #else
03063 throw();
03064 #endif
03065
03066 INLINE l_imatrix &operator *=(l_imatrix &m1,const l_imatrix &m2)
03067 #if(CXSC_INDEX_CHECK)
03068 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03069 #else
03070 throw();
03071 #endif
03072
03073 INLINE l_imatrix &operator *=(l_imatrix &m1,const l_imatrix_slice &ms)
03074 #if(CXSC_INDEX_CHECK)
03075 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03076 #else
03077 throw();
03078 #endif
03079
03080
03082 INLINE l_imatrix operator |(const l_imatrix &m1,const l_imatrix &m2)
03083 #if(CXSC_INDEX_CHECK)
03084 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03085 #else
03086 throw();
03087 #endif
03088
03089 INLINE l_imatrix operator |(const l_imatrix &m,const l_imatrix_slice &ms)
03090 #if(CXSC_INDEX_CHECK)
03091 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03092 #else
03093 throw();
03094 #endif
03095
03096 INLINE l_imatrix operator |(const l_imatrix_slice &ms,const l_imatrix &m)
03097 #if(CXSC_INDEX_CHECK)
03098 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03099 #else
03100 throw();
03101 #endif
03102
03103 INLINE l_imatrix operator |(const l_imatrix_slice &m1,const l_imatrix_slice &m2)
03104 #if(CXSC_INDEX_CHECK)
03105 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03106 #else
03107 throw();
03108 #endif
03109
03110 INLINE l_imatrix &operator |=(l_imatrix &m1,const l_imatrix &m2)
03111 #if(CXSC_INDEX_CHECK)
03112 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03113 #else
03114 throw();
03115 #endif
03116
03117 INLINE l_imatrix &operator |=(l_imatrix &m1,const l_imatrix_slice &ms)
03118 #if(CXSC_INDEX_CHECK)
03119 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03120 #else
03121 throw();
03122 #endif
03123
03125 INLINE l_imatrix operator &(const l_imatrix &m1,const l_imatrix &m2)
03126 #if(CXSC_INDEX_CHECK)
03127 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03128 #else
03129 throw();
03130 #endif
03131
03132 INLINE l_imatrix operator &(const l_imatrix &m,const l_imatrix_slice &ms)
03133 #if(CXSC_INDEX_CHECK)
03134 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03135 #else
03136 throw();
03137 #endif
03138
03139 INLINE l_imatrix operator &(const l_imatrix_slice &ms,const l_imatrix &m)
03140 #if(CXSC_INDEX_CHECK)
03141 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03142 #else
03143 throw();
03144 #endif
03145
03146 INLINE l_imatrix operator &(const l_imatrix_slice &m1,const l_imatrix_slice &m2)
03147 #if(CXSC_INDEX_CHECK)
03148 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03149 #else
03150 throw();
03151 #endif
03152
03153 INLINE l_imatrix &operator &=(l_imatrix &m1,const l_imatrix &m2)
03154 #if(CXSC_INDEX_CHECK)
03155 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03156 #else
03157 throw();
03158 #endif
03159
03160 INLINE l_imatrix &operator &=(l_imatrix &m1,const l_imatrix_slice &ms)
03161 #if(CXSC_INDEX_CHECK)
03162 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03163 #else
03164 throw();
03165 #endif
03166
03167
03169 INLINE l_imatrix operator +(const rmatrix &m1,const l_imatrix &m2)
03170 #if(CXSC_INDEX_CHECK)
03171 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03172 #else
03173 throw();
03174 #endif
03175
03176 INLINE l_imatrix operator +(const l_imatrix &m1,const rmatrix &m2)
03177 #if(CXSC_INDEX_CHECK)
03178 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03179 #else
03180 throw();
03181 #endif
03182
03183 INLINE l_imatrix operator +(const rmatrix &m,const l_imatrix_slice &ms)
03184 #if(CXSC_INDEX_CHECK)
03185 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03186 #else
03187 throw();
03188 #endif
03189
03190 INLINE l_imatrix operator +(const l_imatrix &m,const rmatrix_slice &ms)
03191 #if(CXSC_INDEX_CHECK)
03192 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03193 #else
03194 throw();
03195 #endif
03196
03197 INLINE l_imatrix operator +(const rmatrix_slice &ms,const l_imatrix &m)
03198 #if(CXSC_INDEX_CHECK)
03199 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03200 #else
03201 throw();
03202 #endif
03203
03204 INLINE l_imatrix operator +(const l_imatrix_slice &ms,const rmatrix &m)
03205 #if(CXSC_INDEX_CHECK)
03206 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03207 #else
03208 throw();
03209 #endif
03210
03211 INLINE l_imatrix operator +(const rmatrix_slice &m1,const l_imatrix_slice &m2)
03212 #if(CXSC_INDEX_CHECK)
03213 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03214 #else
03215 throw();
03216 #endif
03217
03218 INLINE l_imatrix operator +(const l_imatrix_slice &m1,const rmatrix_slice &m2)
03219 #if(CXSC_INDEX_CHECK)
03220 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03221 #else
03222 throw();
03223 #endif
03224
03225 INLINE l_imatrix &operator +=(l_imatrix &m1,const rmatrix &m2)
03226 #if(CXSC_INDEX_CHECK)
03227 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03228 #else
03229 throw();
03230 #endif
03231
03232 INLINE l_imatrix &operator +=(l_imatrix &m1,const rmatrix_slice &ms)
03233 #if(CXSC_INDEX_CHECK)
03234 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03235 #else
03236 throw();
03237 #endif
03238
03240 INLINE l_imatrix operator -(const rmatrix &m1,const l_imatrix &m2)
03241 #if(CXSC_INDEX_CHECK)
03242 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03243 #else
03244 throw();
03245 #endif
03246
03247 INLINE l_imatrix operator -(const l_imatrix &m1,const rmatrix &m2)
03248 #if(CXSC_INDEX_CHECK)
03249 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03250 #else
03251 throw();
03252 #endif
03253
03254 INLINE l_imatrix operator -(const rmatrix &m,const l_imatrix_slice &ms)
03255 #if(CXSC_INDEX_CHECK)
03256 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03257 #else
03258 throw();
03259 #endif
03260
03261 INLINE l_imatrix operator -(const l_imatrix &m,const rmatrix_slice &ms)
03262 #if(CXSC_INDEX_CHECK)
03263 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03264 #else
03265 throw();
03266 #endif
03267
03268 INLINE l_imatrix operator -(const rmatrix_slice &ms,const l_imatrix &m)
03269 #if(CXSC_INDEX_CHECK)
03270 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03271 #else
03272 throw();
03273 #endif
03274
03275 INLINE l_imatrix operator -(const l_imatrix_slice &ms,const rmatrix &m)
03276 #if(CXSC_INDEX_CHECK)
03277 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03278 #else
03279 throw();
03280 #endif
03281
03282 INLINE l_imatrix operator -(const rmatrix_slice &ms1,const l_imatrix_slice &ms2)
03283 #if(CXSC_INDEX_CHECK)
03284 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03285 #else
03286 throw();
03287 #endif
03288
03289 INLINE l_imatrix operator -(const l_imatrix_slice &ms1,const rmatrix_slice &ms2)
03290 #if(CXSC_INDEX_CHECK)
03291 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03292 #else
03293 throw();
03294 #endif
03295
03296 INLINE l_imatrix &operator -=(l_imatrix &m1,const rmatrix &m2)
03297 #if(CXSC_INDEX_CHECK)
03298 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03299 #else
03300 throw();
03301 #endif
03302
03303 INLINE l_imatrix &operator -=(l_imatrix &m1,const rmatrix_slice &ms)
03304 #if(CXSC_INDEX_CHECK)
03305 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03306 #else
03307 throw();
03308 #endif
03309
03311 INLINE l_imatrix operator *(const rmatrix &m1, const l_imatrix &m2)
03312 #if(CXSC_INDEX_CHECK)
03313 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03314 #else
03315 throw();
03316 #endif
03317
03318 INLINE l_imatrix operator *(const l_imatrix &m1, const rmatrix &m2)
03319 #if(CXSC_INDEX_CHECK)
03320 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03321 #else
03322 throw();
03323 #endif
03324
03325 INLINE l_imatrix operator *(const rmatrix &m1, const l_imatrix_slice &ms)
03326 #if(CXSC_INDEX_CHECK)
03327 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03328 #else
03329 throw();
03330 #endif
03331
03332 INLINE l_imatrix operator *(const l_imatrix &m1, const rmatrix_slice &ms)
03333 #if(CXSC_INDEX_CHECK)
03334 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03335 #else
03336 throw();
03337 #endif
03338
03339 INLINE l_imatrix operator *(const rmatrix_slice &ms, const l_imatrix &m1)
03340 #if(CXSC_INDEX_CHECK)
03341 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03342 #else
03343 throw();
03344 #endif
03345
03346 INLINE l_imatrix operator *(const l_imatrix_slice &ms, const rmatrix &m1)
03347 #if(CXSC_INDEX_CHECK)
03348 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03349 #else
03350 throw();
03351 #endif
03352
03353 INLINE l_imatrix operator *(const rmatrix_slice &ms1, const l_imatrix_slice &ms2)
03354 #if(CXSC_INDEX_CHECK)
03355 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03356 #else
03357 throw();
03358 #endif
03359
03360 INLINE l_imatrix operator *(const l_imatrix_slice &ms1, const rmatrix_slice &ms2)
03361 #if(CXSC_INDEX_CHECK)
03362 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03363 #else
03364 throw();
03365 #endif
03366
03367 INLINE l_imatrix &operator *=(l_imatrix &m1,const rmatrix &m2)
03368 #if(CXSC_INDEX_CHECK)
03369 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03370 #else
03371 throw();
03372 #endif
03373
03374 INLINE l_imatrix &operator *=(l_imatrix &m1,const rmatrix_slice &ms)
03375 #if(CXSC_INDEX_CHECK)
03376 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03377 #else
03378 throw();
03379 #endif
03380
03382 INLINE l_imatrix operator |(const rmatrix &m1,const l_imatrix &m2)
03383 #if(CXSC_INDEX_CHECK)
03384 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03385 #else
03386 throw();
03387 #endif
03388
03389 INLINE l_imatrix operator |(const l_imatrix &m1,const rmatrix &m2)
03390 #if(CXSC_INDEX_CHECK)
03391 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03392 #else
03393 throw();
03394 #endif
03395
03396 INLINE l_imatrix operator |(const rmatrix &m,const l_imatrix_slice &ms)
03397 #if(CXSC_INDEX_CHECK)
03398 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03399 #else
03400 throw();
03401 #endif
03402
03403 INLINE l_imatrix operator |(const l_imatrix &m,const rmatrix_slice &ms)
03404 #if(CXSC_INDEX_CHECK)
03405 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03406 #else
03407 throw();
03408 #endif
03409
03410 INLINE l_imatrix operator |(const rmatrix_slice &ms,const l_imatrix &m)
03411 #if(CXSC_INDEX_CHECK)
03412 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03413 #else
03414 throw();
03415 #endif
03416
03417 INLINE l_imatrix operator |(const l_imatrix_slice &ms,const rmatrix &m)
03418 #if(CXSC_INDEX_CHECK)
03419 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03420 #else
03421 throw();
03422 #endif
03423
03424 INLINE l_imatrix operator |(const rmatrix_slice &m1,const l_imatrix_slice &m2)
03425 #if(CXSC_INDEX_CHECK)
03426 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03427 #else
03428 throw();
03429 #endif
03430
03431 INLINE l_imatrix operator |(const l_imatrix_slice &m1,const rmatrix_slice &m2)
03432 #if(CXSC_INDEX_CHECK)
03433 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03434 #else
03435 throw();
03436 #endif
03437
03438 INLINE l_imatrix &operator |=(l_imatrix &m1,const rmatrix &m2)
03439 #if(CXSC_INDEX_CHECK)
03440 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03441 #else
03442 throw();
03443 #endif
03444
03445 INLINE l_imatrix &operator |=(l_imatrix &m1,const rmatrix_slice &ms)
03446 #if(CXSC_INDEX_CHECK)
03447 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03448 #else
03449 throw();
03450 #endif
03451
03453 INLINE l_imatrix operator &(const rmatrix &m1,const l_imatrix &m2)
03454 #if(CXSC_INDEX_CHECK)
03455 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03456 #else
03457 throw();
03458 #endif
03459
03460 INLINE l_imatrix operator &(const l_imatrix &m1,const rmatrix &m2)
03461 #if(CXSC_INDEX_CHECK)
03462 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03463 #else
03464 throw();
03465 #endif
03466
03467 INLINE l_imatrix operator &(const rmatrix &m,const l_imatrix_slice &ms)
03468 #if(CXSC_INDEX_CHECK)
03469 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03470 #else
03471 throw();
03472 #endif
03473
03474 INLINE l_imatrix operator &(const l_imatrix &m,const rmatrix_slice &ms)
03475 #if(CXSC_INDEX_CHECK)
03476 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03477 #else
03478 throw();
03479 #endif
03480
03481 INLINE l_imatrix operator &(const rmatrix_slice &ms,const l_imatrix &m)
03482 #if(CXSC_INDEX_CHECK)
03483 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03484 #else
03485 throw();
03486 #endif
03487
03488 INLINE l_imatrix operator &(const l_imatrix_slice &ms,const rmatrix &m)
03489 #if(CXSC_INDEX_CHECK)
03490 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03491 #else
03492 throw();
03493 #endif
03494
03495 INLINE l_imatrix operator &(const rmatrix_slice &m1,const l_imatrix_slice &m2)
03496 #if(CXSC_INDEX_CHECK)
03497 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03498 #else
03499 throw();
03500 #endif
03501
03502 INLINE l_imatrix operator &(const l_imatrix_slice &m1,const rmatrix_slice &m2)
03503 #if(CXSC_INDEX_CHECK)
03504 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03505 #else
03506 throw();
03507 #endif
03508
03509 INLINE l_imatrix &operator &=(l_imatrix &m1,const rmatrix &m2)
03510 #if(CXSC_INDEX_CHECK)
03511 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03512 #else
03513 throw();
03514 #endif
03515
03516 INLINE l_imatrix &operator &=(l_imatrix &m1,const rmatrix_slice &ms)
03517 #if(CXSC_INDEX_CHECK)
03518 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03519 #else
03520 throw();
03521 #endif
03522
03523
03525 INLINE l_imatrix operator +(const l_rmatrix &m1,const l_imatrix &m2)
03526 #if(CXSC_INDEX_CHECK)
03527 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03528 #else
03529 throw();
03530 #endif
03531
03532 INLINE l_imatrix operator +(const l_imatrix &m1,const l_rmatrix &m2)
03533 #if(CXSC_INDEX_CHECK)
03534 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03535 #else
03536 throw();
03537 #endif
03538
03539 INLINE l_imatrix operator +(const l_rmatrix &m,const l_imatrix_slice &ms)
03540 #if(CXSC_INDEX_CHECK)
03541 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03542 #else
03543 throw();
03544 #endif
03545
03546 INLINE l_imatrix operator +(const l_imatrix &m,const l_rmatrix_slice &ms)
03547 #if(CXSC_INDEX_CHECK)
03548 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03549 #else
03550 throw();
03551 #endif
03552
03553 INLINE l_imatrix operator +(const l_rmatrix_slice &ms,const l_imatrix &m)
03554 #if(CXSC_INDEX_CHECK)
03555 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03556 #else
03557 throw();
03558 #endif
03559
03560 INLINE l_imatrix operator +(const l_imatrix_slice &ms,const l_rmatrix &m)
03561 #if(CXSC_INDEX_CHECK)
03562 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03563 #else
03564 throw();
03565 #endif
03566
03567 INLINE l_imatrix operator +(const l_rmatrix_slice &m1,const l_imatrix_slice &m2)
03568 #if(CXSC_INDEX_CHECK)
03569 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03570 #else
03571 throw();
03572 #endif
03573
03574 INLINE l_imatrix operator +(const l_imatrix_slice &m1,const l_rmatrix_slice &m2)
03575 #if(CXSC_INDEX_CHECK)
03576 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03577 #else
03578 throw();
03579 #endif
03580
03581 INLINE l_imatrix &operator +=(l_imatrix &m1,const l_rmatrix &m2)
03582 #if(CXSC_INDEX_CHECK)
03583 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03584 #else
03585 throw();
03586 #endif
03587
03588 INLINE l_imatrix &operator +=(l_imatrix &m1,const l_rmatrix_slice &ms)
03589 #if(CXSC_INDEX_CHECK)
03590 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03591 #else
03592 throw();
03593 #endif
03594
03596 INLINE l_imatrix operator -(const l_rmatrix &m1,const l_imatrix &m2)
03597 #if(CXSC_INDEX_CHECK)
03598 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03599 #else
03600 throw();
03601 #endif
03602
03603 INLINE l_imatrix operator -(const l_imatrix &m1,const l_rmatrix &m2)
03604 #if(CXSC_INDEX_CHECK)
03605 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03606 #else
03607 throw();
03608 #endif
03609
03610 INLINE l_imatrix operator -(const l_rmatrix &m,const l_imatrix_slice &ms)
03611 #if(CXSC_INDEX_CHECK)
03612 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03613 #else
03614 throw();
03615 #endif
03616
03617 INLINE l_imatrix operator -(const l_imatrix &m,const l_rmatrix_slice &ms)
03618 #if(CXSC_INDEX_CHECK)
03619 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03620 #else
03621 throw();
03622 #endif
03623
03624 INLINE l_imatrix operator -(const l_rmatrix_slice &ms,const l_imatrix &m)
03625 #if(CXSC_INDEX_CHECK)
03626 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03627 #else
03628 throw();
03629 #endif
03630
03631 INLINE l_imatrix operator -(const l_imatrix_slice &ms,const l_rmatrix &m)
03632 #if(CXSC_INDEX_CHECK)
03633 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03634 #else
03635 throw();
03636 #endif
03637
03638 INLINE l_imatrix operator -(const l_rmatrix_slice &ms1,const l_imatrix_slice &ms2)
03639 #if(CXSC_INDEX_CHECK)
03640 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03641 #else
03642 throw();
03643 #endif
03644
03645 INLINE l_imatrix operator -(const l_imatrix_slice &ms1,const l_rmatrix_slice &ms2)
03646 #if(CXSC_INDEX_CHECK)
03647 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03648 #else
03649 throw();
03650 #endif
03651
03652 INLINE l_imatrix &operator -=(l_imatrix &m1,const l_rmatrix &m2)
03653 #if(CXSC_INDEX_CHECK)
03654 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03655 #else
03656 throw();
03657 #endif
03658
03659 INLINE l_imatrix &operator -=(l_imatrix &m1,const l_rmatrix_slice &ms)
03660 #if(CXSC_INDEX_CHECK)
03661 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03662 #else
03663 throw();
03664 #endif
03665
03667 INLINE l_imatrix operator *(const l_rmatrix &m1, const l_imatrix &m2)
03668 #if(CXSC_INDEX_CHECK)
03669 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03670 #else
03671 throw();
03672 #endif
03673
03674 INLINE l_imatrix operator *(const l_imatrix &m1, const l_rmatrix &m2)
03675 #if(CXSC_INDEX_CHECK)
03676 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03677 #else
03678 throw();
03679 #endif
03680
03681 INLINE l_imatrix operator *(const l_rmatrix &m1, const l_imatrix_slice &ms)
03682 #if(CXSC_INDEX_CHECK)
03683 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03684 #else
03685 throw();
03686 #endif
03687
03688 INLINE l_imatrix operator *(const l_imatrix &m1, const l_rmatrix_slice &ms)
03689 #if(CXSC_INDEX_CHECK)
03690 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03691 #else
03692 throw();
03693 #endif
03694
03695 INLINE l_imatrix operator *(const l_rmatrix_slice &ms, const l_imatrix &m1)
03696 #if(CXSC_INDEX_CHECK)
03697 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03698 #else
03699 throw();
03700 #endif
03701
03702 INLINE l_imatrix operator *(const l_imatrix_slice &ms, const l_rmatrix &m1)
03703 #if(CXSC_INDEX_CHECK)
03704 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03705 #else
03706 throw();
03707 #endif
03708
03709 INLINE l_imatrix operator *(const l_rmatrix_slice &ms1, const l_imatrix_slice &ms2)
03710 #if(CXSC_INDEX_CHECK)
03711 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03712 #else
03713 throw();
03714 #endif
03715
03716 INLINE l_imatrix operator *(const l_imatrix_slice &ms1, const l_rmatrix_slice &ms2)
03717 #if(CXSC_INDEX_CHECK)
03718 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03719 #else
03720 throw();
03721 #endif
03722
03723 INLINE l_imatrix &operator *=(l_imatrix &m1,const l_rmatrix &m2)
03724 #if(CXSC_INDEX_CHECK)
03725 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03726 #else
03727 throw();
03728 #endif
03729
03730 INLINE l_imatrix &operator *=(l_imatrix &m1,const l_rmatrix_slice &ms)
03731 #if(CXSC_INDEX_CHECK)
03732 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03733 #else
03734 throw();
03735 #endif
03736
03738 INLINE l_imatrix operator |(const l_rmatrix &m1,const l_imatrix &m2)
03739 #if(CXSC_INDEX_CHECK)
03740 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03741 #else
03742 throw();
03743 #endif
03744
03745 INLINE l_imatrix operator |(const l_imatrix &m1,const l_rmatrix &m2)
03746 #if(CXSC_INDEX_CHECK)
03747 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03748 #else
03749 throw();
03750 #endif
03751
03752 INLINE l_imatrix operator |(const l_rmatrix &m,const l_imatrix_slice &ms)
03753 #if(CXSC_INDEX_CHECK)
03754 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03755 #else
03756 throw();
03757 #endif
03758
03759 INLINE l_imatrix operator |(const l_imatrix &m,const l_rmatrix_slice &ms)
03760 #if(CXSC_INDEX_CHECK)
03761 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03762 #else
03763 throw();
03764 #endif
03765
03766 INLINE l_imatrix operator |(const l_rmatrix_slice &ms,const l_imatrix &m)
03767 #if(CXSC_INDEX_CHECK)
03768 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03769 #else
03770 throw();
03771 #endif
03772
03773 INLINE l_imatrix operator |(const l_imatrix_slice &ms,const l_rmatrix &m)
03774 #if(CXSC_INDEX_CHECK)
03775 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03776 #else
03777 throw();
03778 #endif
03779
03780 INLINE l_imatrix operator |(const l_rmatrix_slice &m1,const l_imatrix_slice &m2)
03781 #if(CXSC_INDEX_CHECK)
03782 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03783 #else
03784 throw();
03785 #endif
03786
03787 INLINE l_imatrix operator |(const l_imatrix_slice &m1,const l_rmatrix_slice &m2)
03788 #if(CXSC_INDEX_CHECK)
03789 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03790 #else
03791 throw();
03792 #endif
03793
03794 INLINE l_imatrix &operator |=(l_imatrix &m1,const l_rmatrix &m2)
03795 #if(CXSC_INDEX_CHECK)
03796 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03797 #else
03798 throw();
03799 #endif
03800
03801 INLINE l_imatrix &operator |=(l_imatrix &m1,const l_rmatrix_slice &ms)
03802 #if(CXSC_INDEX_CHECK)
03803 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03804 #else
03805 throw();
03806 #endif
03807
03809 INLINE l_imatrix operator &(const l_rmatrix &m1,const l_imatrix &m2)
03810 #if(CXSC_INDEX_CHECK)
03811 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03812 #else
03813 throw();
03814 #endif
03815
03816 INLINE l_imatrix operator &(const l_imatrix &m1,const l_rmatrix &m2)
03817 #if(CXSC_INDEX_CHECK)
03818 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03819 #else
03820 throw();
03821 #endif
03822
03823 INLINE l_imatrix operator &(const l_rmatrix &m,const l_imatrix_slice &ms)
03824 #if(CXSC_INDEX_CHECK)
03825 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03826 #else
03827 throw();
03828 #endif
03829
03830 INLINE l_imatrix operator &(const l_imatrix &m,const l_rmatrix_slice &ms)
03831 #if(CXSC_INDEX_CHECK)
03832 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03833 #else
03834 throw();
03835 #endif
03836
03837 INLINE l_imatrix operator &(const l_rmatrix_slice &ms,const l_imatrix &m)
03838 #if(CXSC_INDEX_CHECK)
03839 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03840 #else
03841 throw();
03842 #endif
03843
03844 INLINE l_imatrix operator &(const l_imatrix_slice &ms,const l_rmatrix &m)
03845 #if(CXSC_INDEX_CHECK)
03846 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03847 #else
03848 throw();
03849 #endif
03850
03851 INLINE l_imatrix operator &(const l_rmatrix_slice &m1,const l_imatrix_slice &m2)
03852 #if(CXSC_INDEX_CHECK)
03853 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03854 #else
03855 throw();
03856 #endif
03857
03858 INLINE l_imatrix operator &(const l_imatrix_slice &m1,const l_rmatrix_slice &m2)
03859 #if(CXSC_INDEX_CHECK)
03860 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03861 #else
03862 throw();
03863 #endif
03864
03865 INLINE l_imatrix &operator &=(l_imatrix &m1,const l_rmatrix &m2)
03866 #if(CXSC_INDEX_CHECK)
03867 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03868 #else
03869 throw();
03870 #endif
03871
03872 INLINE l_imatrix &operator &=(l_imatrix &m1,const l_rmatrix_slice &ms)
03873 #if(CXSC_INDEX_CHECK)
03874 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03875 #else
03876 throw();
03877 #endif
03878
03879
03881 INLINE l_imatrix operator +(const imatrix &m1,const l_imatrix &m2)
03882 #if(CXSC_INDEX_CHECK)
03883 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03884 #else
03885 throw();
03886 #endif
03887
03888 INLINE l_imatrix operator +(const l_imatrix &m1,const imatrix &m2)
03889 #if(CXSC_INDEX_CHECK)
03890 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03891 #else
03892 throw();
03893 #endif
03894
03895 INLINE l_imatrix operator +(const imatrix &m,const l_imatrix_slice &ms)
03896 #if(CXSC_INDEX_CHECK)
03897 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03898 #else
03899 throw();
03900 #endif
03901
03902 INLINE l_imatrix operator +(const l_imatrix &m,const imatrix_slice &ms)
03903 #if(CXSC_INDEX_CHECK)
03904 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03905 #else
03906 throw();
03907 #endif
03908
03909 INLINE l_imatrix operator +(const imatrix_slice &ms,const l_imatrix &m)
03910 #if(CXSC_INDEX_CHECK)
03911 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03912 #else
03913 throw();
03914 #endif
03915
03916 INLINE l_imatrix operator +(const l_imatrix_slice &ms,const imatrix &m)
03917 #if(CXSC_INDEX_CHECK)
03918 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03919 #else
03920 throw();
03921 #endif
03922
03923 INLINE l_imatrix operator +(const imatrix_slice &m1,const l_imatrix_slice &m2)
03924 #if(CXSC_INDEX_CHECK)
03925 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03926 #else
03927 throw();
03928 #endif
03929
03930 INLINE l_imatrix operator +(const l_imatrix_slice &m1,const imatrix_slice &m2)
03931 #if(CXSC_INDEX_CHECK)
03932 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03933 #else
03934 throw();
03935 #endif
03936
03937 INLINE l_imatrix &operator +=(l_imatrix &m1,const imatrix &m2)
03938 #if(CXSC_INDEX_CHECK)
03939 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03940 #else
03941 throw();
03942 #endif
03943
03944 INLINE l_imatrix &operator +=(l_imatrix &m1,const imatrix_slice &ms)
03945 #if(CXSC_INDEX_CHECK)
03946 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03947 #else
03948 throw();
03949 #endif
03950
03952 INLINE l_imatrix operator -(const imatrix &m1,const l_imatrix &m2)
03953 #if(CXSC_INDEX_CHECK)
03954 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03955 #else
03956 throw();
03957 #endif
03958
03959 INLINE l_imatrix operator -(const l_imatrix &m1,const imatrix &m2)
03960 #if(CXSC_INDEX_CHECK)
03961 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03962 #else
03963 throw();
03964 #endif
03965
03966 INLINE l_imatrix operator -(const imatrix &m,const l_imatrix_slice &ms)
03967 #if(CXSC_INDEX_CHECK)
03968 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03969 #else
03970 throw();
03971 #endif
03972
03973 INLINE l_imatrix operator -(const l_imatrix &m,const imatrix_slice &ms)
03974 #if(CXSC_INDEX_CHECK)
03975 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03976 #else
03977 throw();
03978 #endif
03979
03980 INLINE l_imatrix operator -(const imatrix_slice &ms,const l_imatrix &m)
03981 #if(CXSC_INDEX_CHECK)
03982 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03983 #else
03984 throw();
03985 #endif
03986
03987 INLINE l_imatrix operator -(const l_imatrix_slice &ms,const imatrix &m)
03988 #if(CXSC_INDEX_CHECK)
03989 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03990 #else
03991 throw();
03992 #endif
03993
03994 INLINE l_imatrix operator -(const imatrix_slice &ms1,const l_imatrix_slice &ms2)
03995 #if(CXSC_INDEX_CHECK)
03996 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03997 #else
03998 throw();
03999 #endif
04000
04001 INLINE l_imatrix operator -(const l_imatrix_slice &ms1,const imatrix_slice &ms2)
04002 #if(CXSC_INDEX_CHECK)
04003 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04004 #else
04005 throw();
04006 #endif
04007
04008 INLINE l_imatrix &operator -=(l_imatrix &m1,const imatrix &m2)
04009 #if(CXSC_INDEX_CHECK)
04010 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04011 #else
04012 throw();
04013 #endif
04014
04015 INLINE l_imatrix &operator -=(l_imatrix &m1,const imatrix_slice &ms)
04016 #if(CXSC_INDEX_CHECK)
04017 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04018 #else
04019 throw();
04020 #endif
04021
04023 INLINE l_imatrix operator *(const imatrix &m1, const l_imatrix &m2)
04024 #if(CXSC_INDEX_CHECK)
04025 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04026 #else
04027 throw();
04028 #endif
04029
04030 INLINE l_imatrix operator *(const l_imatrix &m1, const imatrix &m2)
04031 #if(CXSC_INDEX_CHECK)
04032 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04033 #else
04034 throw();
04035 #endif
04036
04037 INLINE l_imatrix operator *(const imatrix &m1, const l_imatrix_slice &ms)
04038 #if(CXSC_INDEX_CHECK)
04039 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04040 #else
04041 throw();
04042 #endif
04043
04044 INLINE l_imatrix operator *(const l_imatrix &m1, const imatrix_slice &ms)
04045 #if(CXSC_INDEX_CHECK)
04046 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04047 #else
04048 throw();
04049 #endif
04050
04051 INLINE l_imatrix operator *(const imatrix_slice &ms, const l_imatrix &m1)
04052 #if(CXSC_INDEX_CHECK)
04053 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04054 #else
04055 throw();
04056 #endif
04057
04058 INLINE l_imatrix operator *(const l_imatrix_slice &ms, const imatrix &m1)
04059 #if(CXSC_INDEX_CHECK)
04060 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04061 #else
04062 throw();
04063 #endif
04064
04065 INLINE l_imatrix operator *(const imatrix_slice &ms1, const l_imatrix_slice &ms2)
04066 #if(CXSC_INDEX_CHECK)
04067 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04068 #else
04069 throw();
04070 #endif
04071
04072 INLINE l_imatrix operator *(const l_imatrix_slice &ms1, const imatrix_slice &ms2)
04073 #if(CXSC_INDEX_CHECK)
04074 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04075 #else
04076 throw();
04077 #endif
04078
04079 INLINE l_imatrix &operator *=(l_imatrix &m1,const imatrix &m2)
04080 #if(CXSC_INDEX_CHECK)
04081 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04082 #else
04083 throw();
04084 #endif
04085
04086 INLINE l_imatrix &operator *=(l_imatrix &m1,const imatrix_slice &ms)
04087 #if(CXSC_INDEX_CHECK)
04088 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04089 #else
04090 throw();
04091 #endif
04092
04094 INLINE l_imatrix operator |(const imatrix &m1,const l_imatrix &m2)
04095 #if(CXSC_INDEX_CHECK)
04096 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04097 #else
04098 throw();
04099 #endif
04100
04101 INLINE l_imatrix operator |(const l_imatrix &m1,const imatrix &m2)
04102 #if(CXSC_INDEX_CHECK)
04103 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04104 #else
04105 throw();
04106 #endif
04107
04108 INLINE l_imatrix operator |(const imatrix &m,const l_imatrix_slice &ms)
04109 #if(CXSC_INDEX_CHECK)
04110 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04111 #else
04112 throw();
04113 #endif
04114
04115 INLINE l_imatrix operator |(const l_imatrix &m,const imatrix_slice &ms)
04116 #if(CXSC_INDEX_CHECK)
04117 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04118 #else
04119 throw();
04120 #endif
04121
04122 INLINE l_imatrix operator |(const imatrix_slice &ms,const l_imatrix &m)
04123 #if(CXSC_INDEX_CHECK)
04124 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04125 #else
04126 throw();
04127 #endif
04128
04129 INLINE l_imatrix operator |(const l_imatrix_slice &ms,const imatrix &m)
04130 #if(CXSC_INDEX_CHECK)
04131 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04132 #else
04133 throw();
04134 #endif
04135
04136 INLINE l_imatrix operator |(const imatrix_slice &m1,const l_imatrix_slice &m2)
04137 #if(CXSC_INDEX_CHECK)
04138 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04139 #else
04140 throw();
04141 #endif
04142
04143 INLINE l_imatrix operator |(const l_imatrix_slice &m1,const imatrix_slice &m2)
04144 #if(CXSC_INDEX_CHECK)
04145 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04146 #else
04147 throw();
04148 #endif
04149
04150 INLINE l_imatrix &operator |=(l_imatrix &m1,const imatrix &m2)
04151 #if(CXSC_INDEX_CHECK)
04152 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04153 #else
04154 throw();
04155 #endif
04156
04157 INLINE l_imatrix &operator |=(l_imatrix &m1,const imatrix_slice &ms)
04158 #if(CXSC_INDEX_CHECK)
04159 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04160 #else
04161 throw();
04162 #endif
04163
04165 INLINE l_imatrix operator &(const imatrix &m1,const l_imatrix &m2)
04166 #if(CXSC_INDEX_CHECK)
04167 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04168 #else
04169 throw();
04170 #endif
04171
04172 INLINE l_imatrix operator &(const l_imatrix &m1,const imatrix &m2)
04173 #if(CXSC_INDEX_CHECK)
04174 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04175 #else
04176 throw();
04177 #endif
04178
04179 INLINE l_imatrix operator &(const imatrix &m,const l_imatrix_slice &ms)
04180 #if(CXSC_INDEX_CHECK)
04181 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04182 #else
04183 throw();
04184 #endif
04185
04186 INLINE l_imatrix operator &(const l_imatrix &m,const imatrix_slice &ms)
04187 #if(CXSC_INDEX_CHECK)
04188 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04189 #else
04190 throw();
04191 #endif
04192
04193 INLINE l_imatrix operator &(const imatrix_slice &ms,const l_imatrix &m)
04194 #if(CXSC_INDEX_CHECK)
04195 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04196 #else
04197 throw();
04198 #endif
04199
04200 INLINE l_imatrix operator &(const l_imatrix_slice &ms,const imatrix &m)
04201 #if(CXSC_INDEX_CHECK)
04202 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04203 #else
04204 throw();
04205 #endif
04206
04207 INLINE l_imatrix operator &(const imatrix_slice &m1,const l_imatrix_slice &m2)
04208 #if(CXSC_INDEX_CHECK)
04209 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04210 #else
04211 throw();
04212 #endif
04213
04214 INLINE l_imatrix operator &(const l_imatrix_slice &m1,const imatrix_slice &m2)
04215 #if(CXSC_INDEX_CHECK)
04216 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04217 #else
04218 throw();
04219 #endif
04220
04221 INLINE l_imatrix &operator &=(l_imatrix &m1,const imatrix &m2)
04222 #if(CXSC_INDEX_CHECK)
04223 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04224 #else
04225 throw();
04226 #endif
04227
04228 INLINE l_imatrix &operator &=(l_imatrix &m1,const imatrix_slice &ms)
04229 #if(CXSC_INDEX_CHECK)
04230 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04231 #else
04232 throw();
04233 #endif
04234
04235
04237 INLINE l_imatrix operator +(const l_rmatrix &m1,const imatrix &m2)
04238 #if(CXSC_INDEX_CHECK)
04239 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04240 #else
04241 throw();
04242 #endif
04243
04244 INLINE l_imatrix operator +(const imatrix &m1,const l_rmatrix &m2)
04245 #if(CXSC_INDEX_CHECK)
04246 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04247 #else
04248 throw();
04249 #endif
04250
04251 INLINE l_imatrix operator +(const l_rmatrix &m,const imatrix_slice &ms)
04252 #if(CXSC_INDEX_CHECK)
04253 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04254 #else
04255 throw();
04256 #endif
04257
04258 INLINE l_imatrix operator +(const imatrix &m,const l_rmatrix_slice &ms)
04259 #if(CXSC_INDEX_CHECK)
04260 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04261 #else
04262 throw();
04263 #endif
04264
04265 INLINE l_imatrix operator +(const l_rmatrix_slice &ms,const imatrix &m)
04266 #if(CXSC_INDEX_CHECK)
04267 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04268 #else
04269 throw();
04270 #endif
04271
04272 INLINE l_imatrix operator +(const imatrix_slice &ms,const l_rmatrix &m)
04273 #if(CXSC_INDEX_CHECK)
04274 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04275 #else
04276 throw();
04277 #endif
04278
04279 INLINE l_imatrix operator +(const l_rmatrix_slice &m1,const imatrix_slice &m2)
04280 #if(CXSC_INDEX_CHECK)
04281 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04282 #else
04283 throw();
04284 #endif
04285
04286 INLINE l_imatrix operator +(const imatrix_slice &m1,const l_rmatrix_slice &m2)
04287 #if(CXSC_INDEX_CHECK)
04288 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04289 #else
04290 throw();
04291 #endif
04292
04294 INLINE l_imatrix operator -(const l_rmatrix &m1,const imatrix &m2)
04295 #if(CXSC_INDEX_CHECK)
04296 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04297 #else
04298 throw();
04299 #endif
04300
04301 INLINE l_imatrix operator -(const imatrix &m1,const l_rmatrix &m2)
04302 #if(CXSC_INDEX_CHECK)
04303 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04304 #else
04305 throw();
04306 #endif
04307
04308 INLINE l_imatrix operator -(const l_rmatrix &m,const imatrix_slice &ms)
04309 #if(CXSC_INDEX_CHECK)
04310 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04311 #else
04312 throw();
04313 #endif
04314
04315 INLINE l_imatrix operator -(const imatrix &m,const l_rmatrix_slice &ms)
04316 #if(CXSC_INDEX_CHECK)
04317 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04318 #else
04319 throw();
04320 #endif
04321
04322 INLINE l_imatrix operator -(const l_rmatrix_slice &ms,const imatrix &m)
04323 #if(CXSC_INDEX_CHECK)
04324 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04325 #else
04326 throw();
04327 #endif
04328
04329 INLINE l_imatrix operator -(const imatrix_slice &ms,const l_rmatrix &m)
04330 #if(CXSC_INDEX_CHECK)
04331 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04332 #else
04333 throw();
04334 #endif
04335
04336 INLINE l_imatrix operator -(const l_rmatrix_slice &ms1,const imatrix_slice &ms2)
04337 #if(CXSC_INDEX_CHECK)
04338 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04339 #else
04340 throw();
04341 #endif
04342
04343 INLINE l_imatrix operator -(const imatrix_slice &ms1,const l_rmatrix_slice &ms2)
04344 #if(CXSC_INDEX_CHECK)
04345 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04346 #else
04347 throw();
04348 #endif
04349
04351 INLINE l_imatrix operator *(const l_rmatrix &m1, const imatrix &m2)
04352 #if(CXSC_INDEX_CHECK)
04353 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04354 #else
04355 throw();
04356 #endif
04357
04358 INLINE l_imatrix operator *(const imatrix &m1, const l_rmatrix &m2)
04359 #if(CXSC_INDEX_CHECK)
04360 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04361 #else
04362 throw();
04363 #endif
04364
04365 INLINE l_imatrix operator *(const l_rmatrix &m1, const imatrix_slice &ms)
04366 #if(CXSC_INDEX_CHECK)
04367 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04368 #else
04369 throw();
04370 #endif
04371
04372 INLINE l_imatrix operator *(const imatrix &m1, const l_rmatrix_slice &ms)
04373 #if(CXSC_INDEX_CHECK)
04374 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04375 #else
04376 throw();
04377 #endif
04378
04379 INLINE l_imatrix operator *(const l_rmatrix_slice &ms, const imatrix &m1)
04380 #if(CXSC_INDEX_CHECK)
04381 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04382 #else
04383 throw();
04384 #endif
04385
04386 INLINE l_imatrix operator *(const imatrix_slice &ms, const l_rmatrix &m1)
04387 #if(CXSC_INDEX_CHECK)
04388 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04389 #else
04390 throw();
04391 #endif
04392
04393 INLINE l_imatrix operator *(const l_rmatrix_slice &ms1, const imatrix_slice &ms2)
04394 #if(CXSC_INDEX_CHECK)
04395 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04396 #else
04397 throw();
04398 #endif
04399
04400 INLINE l_imatrix operator *(const imatrix_slice &ms1, const l_rmatrix_slice &ms2)
04401 #if(CXSC_INDEX_CHECK)
04402 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04403 #else
04404 throw();
04405 #endif
04406
04408 INLINE l_imatrix operator |(const l_rmatrix &m1,const imatrix &m2)
04409 #if(CXSC_INDEX_CHECK)
04410 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04411 #else
04412 throw();
04413 #endif
04414
04415 INLINE l_imatrix operator |(const imatrix &m1,const l_rmatrix &m2)
04416 #if(CXSC_INDEX_CHECK)
04417 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04418 #else
04419 throw();
04420 #endif
04421
04422 INLINE l_imatrix operator |(const l_rmatrix &m,const imatrix_slice &ms)
04423 #if(CXSC_INDEX_CHECK)
04424 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04425 #else
04426 throw();
04427 #endif
04428
04429 INLINE l_imatrix operator |(const imatrix &m,const l_rmatrix_slice &ms)
04430 #if(CXSC_INDEX_CHECK)
04431 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04432 #else
04433 throw();
04434 #endif
04435
04436 INLINE l_imatrix operator |(const l_rmatrix_slice &ms,const imatrix &m)
04437 #if(CXSC_INDEX_CHECK)
04438 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04439 #else
04440 throw();
04441 #endif
04442
04443 INLINE l_imatrix operator |(const imatrix_slice &ms,const l_rmatrix &m)
04444 #if(CXSC_INDEX_CHECK)
04445 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04446 #else
04447 throw();
04448 #endif
04449
04450 INLINE l_imatrix operator |(const l_rmatrix_slice &m1,const imatrix_slice &m2)
04451 #if(CXSC_INDEX_CHECK)
04452 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04453 #else
04454 throw();
04455 #endif
04456
04457 INLINE l_imatrix operator |(const imatrix_slice &m1,const l_rmatrix_slice &m2)
04458 #if(CXSC_INDEX_CHECK)
04459 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04460 #else
04461 throw();
04462 #endif
04463
04465 INLINE l_imatrix operator &(const l_rmatrix &m1,const imatrix &m2)
04466 #if(CXSC_INDEX_CHECK)
04467 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04468 #else
04469 throw();
04470 #endif
04471
04472 INLINE l_imatrix operator &(const imatrix &m1,const l_rmatrix &m2)
04473 #if(CXSC_INDEX_CHECK)
04474 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04475 #else
04476 throw();
04477 #endif
04478
04479 INLINE l_imatrix operator &(const l_rmatrix &m,const imatrix_slice &ms)
04480 #if(CXSC_INDEX_CHECK)
04481 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04482 #else
04483 throw();
04484 #endif
04485
04486 INLINE l_imatrix operator &(const imatrix &m,const l_rmatrix_slice &ms)
04487 #if(CXSC_INDEX_CHECK)
04488 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04489 #else
04490 throw();
04491 #endif
04492
04493 INLINE l_imatrix operator &(const l_rmatrix_slice &ms,const imatrix &m)
04494 #if(CXSC_INDEX_CHECK)
04495 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04496 #else
04497 throw();
04498 #endif
04499
04500 INLINE l_imatrix operator &(const imatrix_slice &ms,const l_rmatrix &m)
04501 #if(CXSC_INDEX_CHECK)
04502 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04503 #else
04504 throw();
04505 #endif
04506
04507 INLINE l_imatrix operator &(const l_rmatrix_slice &m1,const imatrix_slice &m2)
04508 #if(CXSC_INDEX_CHECK)
04509 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04510 #else
04511 throw();
04512 #endif
04513
04514 INLINE l_imatrix operator &(const imatrix_slice &m1,const l_rmatrix_slice &m2)
04515 #if(CXSC_INDEX_CHECK)
04516 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04517 #else
04518 throw();
04519 #endif
04520
04521
04523 INLINE l_imatrix operator |(const rmatrix &rv1, const l_rmatrix &rv2)
04524 #if(CXSC_INDEX_CHECK)
04525 throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
04526 #else
04527 throw();
04528 #endif
04529
04530 INLINE l_imatrix operator |(const l_rmatrix &rv1, const rmatrix &rv2)
04531 #if(CXSC_INDEX_CHECK)
04532 throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
04533 #else
04534 throw();
04535 #endif
04536
04537 INLINE l_imatrix operator |(const l_rmatrix &rv, const rmatrix_slice &sl)
04538 #if(CXSC_INDEX_CHECK)
04539 throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
04540 #else
04541 throw();
04542 #endif
04543
04544 INLINE l_imatrix operator |(const rmatrix_slice &sl,const l_rmatrix &rv)
04545 #if(CXSC_INDEX_CHECK)
04546 throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
04547 #else
04548 throw();
04549 #endif
04550
04551 INLINE l_imatrix operator |(const l_rmatrix_slice &sl, const rmatrix &rv)
04552 #if(CXSC_INDEX_CHECK)
04553 throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
04554 #else
04555 throw();
04556 #endif
04557
04558 INLINE l_imatrix operator |(const rmatrix &rv,const l_rmatrix_slice &sl)
04559 #if(CXSC_INDEX_CHECK)
04560 throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
04561 #else
04562 throw();
04563 #endif
04564
04565 INLINE l_imatrix operator |(const l_rmatrix_slice &sl1, const rmatrix_slice &sl2)
04566 #if(CXSC_INDEX_CHECK)
04567 throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
04568 #else
04569 throw();
04570 #endif
04571
04572 INLINE l_imatrix operator |(const rmatrix_slice &sl1, const l_rmatrix_slice &sl2)
04573 #if(CXSC_INDEX_CHECK)
04574 throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
04575 #else
04576 throw();
04577 #endif
04578
04579
04580
04582 INLINE l_imatrix operator |(const l_rmatrix &rv1, const l_rmatrix &rv2)
04583 #if(CXSC_INDEX_CHECK)
04584 throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
04585 #else
04586 throw();
04587 #endif
04588
04589 INLINE l_imatrix operator |(const l_rmatrix &rv1, const l_rmatrix &rv2)
04590 #if(CXSC_INDEX_CHECK)
04591 throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
04592 #else
04593 throw();
04594 #endif
04595
04596 INLINE l_imatrix operator |(const l_rmatrix &rv, const l_rmatrix_slice &sl)
04597 #if(CXSC_INDEX_CHECK)
04598 throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
04599 #else
04600 throw();
04601 #endif
04602
04603 INLINE l_imatrix operator |(const l_rmatrix_slice &sl,const l_rmatrix &rv)
04604 #if(CXSC_INDEX_CHECK)
04605 throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
04606 #else
04607 throw();
04608 #endif
04609
04610 INLINE l_imatrix operator |(const l_rmatrix_slice &sl, const l_rmatrix &rv)
04611 #if(CXSC_INDEX_CHECK)
04612 throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
04613 #else
04614 throw();
04615 #endif
04616
04617 INLINE l_imatrix operator |(const l_rmatrix &rv,const l_rmatrix_slice &sl)
04618 #if(CXSC_INDEX_CHECK)
04619 throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
04620 #else
04621 throw();
04622 #endif
04623
04624 INLINE l_imatrix operator |(const l_rmatrix_slice &sl1, const l_rmatrix_slice &sl2)
04625 #if(CXSC_INDEX_CHECK)
04626 throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
04627 #else
04628 throw();
04629 #endif
04630
04631 INLINE l_imatrix operator |(const l_rmatrix_slice &sl1, const l_rmatrix_slice &sl2)
04632 #if(CXSC_INDEX_CHECK)
04633 throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
04634 #else
04635 throw();
04636 #endif
04637
04638
04639
04640
04641
04642
04644 INLINE bool operator ==(const l_imatrix &m1,const l_imatrix &m2) throw();
04646 INLINE bool operator !=(const l_imatrix &m1,const l_imatrix &m2) throw();
04648 INLINE bool operator <(const l_imatrix &m1,const l_imatrix &m2) throw();
04650 INLINE bool operator <=(const l_imatrix &m1,const l_imatrix &m2) throw();
04652 INLINE bool operator >(const l_imatrix &m1,const l_imatrix &m2) throw();
04654 INLINE bool operator >=(const l_imatrix &m1,const l_imatrix &m2) throw();
04656 INLINE bool operator ==(const l_imatrix &m1,const l_imatrix_slice &ms) throw();
04658 INLINE bool operator !=(const l_imatrix &m1,const l_imatrix_slice &ms) throw();
04660 INLINE bool operator <(const l_imatrix &m1,const l_imatrix_slice &ms) throw();
04662 INLINE bool operator <=(const l_imatrix &m1,const l_imatrix_slice &ms) throw();
04664 INLINE bool operator >(const l_imatrix &m1,const l_imatrix_slice &ms) throw();
04666 INLINE bool operator >=(const l_imatrix &m1,const l_imatrix_slice &ms) throw();
04667
04668
04669
04671 INLINE bool operator ==(const l_imatrix_slice &m1,const l_imatrix_slice &m2) throw();
04673 INLINE bool operator !=(const l_imatrix_slice &m1,const l_imatrix_slice &m2) throw();
04675 INLINE bool operator <(const l_imatrix_slice &m1,const l_imatrix_slice &m2) throw();
04677 INLINE bool operator <=(const l_imatrix_slice &m1,const l_imatrix_slice &m2) throw();
04679 INLINE bool operator >(const l_imatrix_slice &m1,const l_imatrix_slice &m2) throw();
04681 INLINE bool operator >=(const l_imatrix_slice &m1,const l_imatrix_slice &m2) throw();
04682
04683
04684
04686 INLINE bool operator !(const l_imatrix &ms) throw();
04688 INLINE bool operator !(const l_imatrix_slice &ms) throw();
04689
04690
04691
04693 INLINE std::ostream &operator <<(std::ostream &s,const l_imatrix &r) throw();
04695 INLINE std::ostream &operator <<(std::ostream &s,const l_imatrix_slice &r) throw();
04697 INLINE std::istream &operator >>(std::istream &s,l_imatrix &r) throw();
04699 INLINE std::istream &operator >>(std::istream &s,l_imatrix_slice &r) throw();
04700
04702 l_imatrix Id ( const l_imatrix& );
04704 l_imatrix transp ( const l_imatrix& );
04706 l_real MaxRelDiam ( const l_imatrix_subv& );
04708 INLINE int RowLen ( const l_imatrix& );
04710 INLINE int ColLen ( const l_imatrix& );
04712 INLINE int RowLen ( const l_imatrix_slice& );
04714 INLINE int ColLen ( const l_imatrix_slice& );
04716 void DoubleSize ( l_imatrix& );
04717
04718 }
04719
04720 #ifdef _CXSC_INCL_INL
04721 #include "matrix.inl"
04722 #include "l_imatrix.inl"
04723 #endif
04724
04725
04726 #endif
04727
