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