- Generated by
1.7.5.1
|
C-XSC - A C++ Class Library for Extended Scientific Computing
2.5.4
|
00001 /* 00002 ** CXSC is a C++ library for eXtended Scientific Computing (V 2.5.4) 00003 ** 00004 ** Copyright (C) 1990-2000 Institut fuer Angewandte Mathematik, 00005 ** Universitaet Karlsruhe, Germany 00006 ** (C) 2000-2014 Wiss. Rechnen/Softwaretechnologie 00007 ** Universitaet Wuppertal, Germany 00008 ** 00009 ** This library is free software; you can redistribute it and/or 00010 ** modify it under the terms of the GNU Library General Public 00011 ** License as published by the Free Software Foundation; either 00012 ** version 2 of the License, or (at your option) any later version. 00013 ** 00014 ** This library is distributed in the hope that it will be useful, 00015 ** but WITHOUT ANY WARRANTY; without even the implied warranty of 00016 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00017 ** Library General Public License for more details. 00018 ** 00019 ** You should have received a copy of the GNU Library General Public 00020 ** License along with this library; if not, write to the Free 00021 ** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 00022 */ 00023 00024 /* CVS $Id: l_imatrix.hpp,v 1.22 2014/01/30 17:23:46 cxsc Exp $ */ 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; // start=first element index 0..n-1 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 //#if(CXSC_INDEX_CHECK) 00086 #ifdef _CXSC_FRIEND_TPL 00087 //----------------- Templates --------------------------------------- 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 //----------------- Konstruktoren ---------------------------------- 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 //---------------------- Standardfunktionen ------------------------ 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 // Real 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 // l_real 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 // interval 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 // real 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 // l_real 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 // interval 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 //#else 00712 //#endif 00713 00714 }; 00715 00716 00717 //----------------------- Matrix ----------------------------------------------- 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 //#if(CXSC_INDEX_CHECK) 00735 #ifdef _CXSC_FRIEND_TPL 00736 //----------------- Templates --------------------------------------- 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 //-------------- matrix-matrix ------------- 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 //-------- matrix-scalar ----------------- 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 //-------- matrix-vector --------------------- 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 //--- Real --------- matrix-scalar ---------------------- 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 //--- Real --------- matrix-vector ---------------------- 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 //-------------------------- Konstruktoren ---------------------------- 01127 01128 // l_interval 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 // real 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 // l_real 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 // interval 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 //--------------------------- Destruktoren ----------------------------- 01232 01233 INLINE ~l_imatrix() throw() { delete [] dat; } 01234 01235 //------------------------- Standardfunktionen ------------------------- 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 //#else 01269 //#endif 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; // slice size 01286 01287 public: 01288 //#if(CXSC_INDEX_CHECK) 01289 #ifdef _CXSC_FRIEND_TPL 01290 //----------------- Templates --------------------------------------- 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 //-------- matrix-matrix -------------- 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 //--------- matrix-vector -------------- 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 //--------- matrix-scalar -------------- 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 //--------------- Konstruktoren ---------------------------------------- 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 //---------------- Standardfunktionen ----------------------------------- 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 // real 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 // interval 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 // l_real 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 //#else 02094 //#endif 02095 }; 02096 02097 //================================================================ 02098 //====================== Subvector Functions ===================== 02099 02100 //=======================Vector / Scalar ========================= 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 //======================== Vector / Vector ======================== 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 // real 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 // l_real 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 // interval 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 //===================== Matrix Functions ============================= 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 //===================== Matrix / Scalar =============================== 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 //------------ real - l_imatrix ----------------------------------------------- 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 //----------------- rmatrix - l_interval ---------------- 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 //------------ l_real - l_imatrix ----------------------------------------------- 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 //----------------- l_rmatrix - l_interval ---------------- 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 //------------ interval - l_imatrix ----------------------------------------------- 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 //----------------- imatrix - l_interval ---------------- 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 //============================ Matrix / Vector =================================== 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 //----------------- real ------------------------------------- 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 //----------------- l_real ------------------------------------- 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 //----------------- interval ------------------------------------- 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 //================ Matrix / Matrix ============================ 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 //---------- rmatrix-l_imatrix ------------------ 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 //---------- l_rmatrix-l_imatrix ------------------ 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 //---------- imatrix-l_imatrix ------------------ 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 //---------- l_rmatrix-imatrix ------------------ 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 //------------- real x l_real ------------------------ 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 //------------- l_real x l_real ------------------------ 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 //============== Compare Operator ========================== 04640 04641 //-------------- Matrix - Matrix ------------------------- 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 //---------------- Matrix - Matrix_slice ---------------------- 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 //=================== Not Operator ============================= 04684 04686 INLINE bool operator !(const l_imatrix &ms) throw(); 04688 INLINE bool operator !(const l_imatrix_slice &ms) throw(); 04689 04690 //======================== Input / Output ======================== 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 } // namespace cxsc 04719 04720 #ifdef _CXSC_INCL_INL 04721 #include "matrix.inl" 04722 #include "l_imatrix.inl" 04723 #endif 04724 04725 04726 #endif 04727
1.7.5.1