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