C-XSC - A C++ Class Library for Extended Scientific Computing
2.5.4
|
00001 /* 00002 ** CXSC is a C++ library for eXtended Scientific Computing (V 2.5.4) 00003 ** 00004 ** Copyright (C) 1990-2000 Institut fuer Angewandte Mathematik, 00005 ** Universitaet Karlsruhe, Germany 00006 ** (C) 2000-2014 Wiss. Rechnen/Softwaretechnologie 00007 ** Universitaet Wuppertal, Germany 00008 ** 00009 ** This library is free software; you can redistribute it and/or 00010 ** modify it under the terms of the GNU Library General Public 00011 ** License as published by the Free Software Foundation; either 00012 ** version 2 of the License, or (at your option) any later version. 00013 ** 00014 ** This library is distributed in the hope that it will be useful, 00015 ** but WITHOUT ANY WARRANTY; without even the implied warranty of 00016 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00017 ** Library General Public License for more details. 00018 ** 00019 ** You should have received a copy of the GNU Library General Public 00020 ** License along with this library; if not, write to the Free 00021 ** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 00022 */ 00023 00024 /* CVS $Id: l_rmatrix.hpp,v 1.20 2014/01/30 17:23:46 cxsc Exp $ */ 00025 00026 #ifndef _CXSC_LRMATRIX_HPP_INCLUDED 00027 #define _CXSC_LRMATRIX_HPP_INCLUDED 00028 00029 #include "xscclass.hpp" 00030 #include "dot.hpp" 00031 #include "idot.hpp" 00032 #include "l_rvector.hpp" 00033 #include "except.hpp" 00034 #include "matrix.hpp" 00035 #include "rmatrix.hpp" 00036 00037 namespace cxsc { 00038 00039 class l_rmatrix; 00040 class l_rmatrix_slice; 00041 00043 00046 class l_rmatrix_subv 00047 { 00048 friend class l_rvector; 00049 friend class l_ivector; 00050 friend class l_rmatrix; 00051 friend class l_rmatrix_slice; 00052 private: 00053 l_real *dat; 00054 int lb,ub; 00055 int size,start,offset; // start=first element index 0..n-1 00056 00057 public: 00059 friend INLINE l_rmatrix_subv Row(l_rmatrix &m,const int &i) 00060 #if(CXSC_INDEX_CHECK) 00061 throw(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT); 00062 #else 00063 throw(); 00064 #endif 00065 00066 friend INLINE l_rmatrix_subv Col(l_rmatrix &m,const int &i) 00067 #if(CXSC_INDEX_CHECK) 00068 throw(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT); 00069 #else 00070 throw(); 00071 #endif 00072 00073 friend INLINE l_rmatrix_subv Row(const l_rmatrix &m,const int &i) 00074 #if(CXSC_INDEX_CHECK) 00075 throw(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT); 00076 #else 00077 throw(); 00078 #endif 00079 00080 friend INLINE l_rmatrix_subv Col(const l_rmatrix &m,const int &i) 00081 #if(CXSC_INDEX_CHECK) 00082 throw(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT); 00083 #else 00084 throw(); 00085 #endif 00086 //#if(CXSC_INDEX_CHECK) 00087 00088 template<typename S, typename T> 00089 friend inline void addDot(const S &x, const T &y, dotprecision &val); 00090 00091 00092 #ifdef _CXSC_FRIEND_TPL 00093 //----------------- Templates --------------------------------------- 00094 template <class MV1,class MV2> friend MV1 &_mvmvassign(MV1 &v,const MV2 &rv) 00095 #if(CXSC_INDEX_CHECK) 00096 throw(ERROR__OP_WITH_WRONG_DIM<MV1>); 00097 #else 00098 throw(); 00099 #endif 00100 template <class MV,class S> friend MV &_mvsassign(MV &v,const S &r) throw(); 00101 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv) 00102 #if(CXSC_INDEX_CHECK) 00103 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00104 #else 00105 throw(); 00106 #endif 00107 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) throw(); 00108 template <class MV,class V> friend V _mvabs(const MV &mv) throw(); 00109 template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2) 00110 #if(CXSC_INDEX_CHECK) 00111 throw(OP_WITH_WRONG_DIM); 00112 #else 00113 throw(); 00114 #endif 00115 template <class DP,class MV1,class MV2> friend void _mvmvaccu(DP &dp, const MV1 & rv1, const MV2 &rv2) 00116 #if(CXSC_INDEX_CHECK) 00117 throw(OP_WITH_WRONG_DIM); 00118 #else 00119 throw(); 00120 #endif 00121 00122 00123 template <class MV1,class MV2,class S> friend S _mvmvlmult(const MV1 & rv1, const MV2 &rv2) 00124 #if(CXSC_INDEX_CHECK) 00125 throw(ERROR__OP_WITH_WRONG_DIM<MV1>); 00126 #else 00127 throw(); 00128 #endif 00129 template <class V,class MV,class S> friend S _vmvlmult(const V &rv1, const MV &rv2) 00130 #if(CXSC_INDEX_CHECK) 00131 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00132 #else 00133 throw(); 00134 #endif 00135 template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) throw(); 00136 template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2) 00137 #if(CXSC_INDEX_CHECK) 00138 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00139 #else 00140 throw(); 00141 #endif 00142 template <class MV1,class MV2,class E> friend E _mvmvminus(const MV1 &rv1, const MV2 &rv2) 00143 #if(CXSC_INDEX_CHECK) 00144 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00145 #else 00146 throw(); 00147 #endif 00148 template <class MV,class V,class E> friend E _mvvplus(const MV &rv1, const V &rv2) 00149 #if(CXSC_INDEX_CHECK) 00150 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00151 #else 00152 throw(); 00153 #endif 00154 template <class MV,class V,class E> friend E _mvvminus(const MV &rv1, const V &rv2) 00155 #if(CXSC_INDEX_CHECK) 00156 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00157 #else 00158 throw(); 00159 #endif 00160 template <class V,class MV,class E> friend E _vmvminus(const V &rv1, const MV &rv2) 00161 #if(CXSC_INDEX_CHECK) 00162 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00163 #else 00164 throw(); 00165 #endif 00166 template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) throw(); 00167 template <class MV,class S> friend MV &_mvsmultassign(MV &v,const S &r) throw(); 00168 template <class MV, class S> friend MV &_mvsplusassign(MV &v,const S &r) throw(); 00169 template <class MV,class S> friend MV &_mvsminusassign(MV &v,const S &r) throw(); 00170 template <class MV,class S> friend MV &_mvsdivassign(MV &v,const S &r) throw(); 00171 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv) 00172 #if(CXSC_INDEX_CHECK) 00173 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00174 #else 00175 throw(); 00176 #endif 00177 template <class V,class MV> friend V &_vmvplusassign(V &rv,const MV &v) 00178 #if(CXSC_INDEX_CHECK) 00179 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00180 #else 00181 throw(); 00182 #endif 00183 template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv) 00184 #if(CXSC_INDEX_CHECK) 00185 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00186 #else 00187 throw(); 00188 #endif 00189 template <class V,class MV> friend V &_vmvminusassign(V &rv,const MV &v) 00190 #if(CXSC_INDEX_CHECK) 00191 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00192 #else 00193 throw(); 00194 #endif 00195 00196 template <class V,class MV> friend V &_vmvsetinf(V &rv,const MV &v) 00197 #if(CXSC_INDEX_CHECK) 00198 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00199 #else 00200 throw(); 00201 #endif 00202 template <class V,class MV> friend V &_vmvsetsup(V &rv,const MV &v) 00203 #if(CXSC_INDEX_CHECK) 00204 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00205 #else 00206 throw(); 00207 #endif 00208 template <class V,class MV> friend V &_vmvusetinf(V &rv,const MV &v) 00209 #if(CXSC_INDEX_CHECK) 00210 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00211 #else 00212 throw(); 00213 #endif 00214 template <class V,class MV> friend V &_vmvusetsup(V &rv,const MV &v) 00215 #if(CXSC_INDEX_CHECK) 00216 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00217 #else 00218 throw(); 00219 #endif 00220 00221 #endif 00222 00223 //----------------- Konstruktoren ---------------------------------- 00224 00226 explicit INLINE l_rmatrix_subv (l_real *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) { } 00227 public: 00229 INLINE l_rmatrix_subv(const l_rmatrix_subv &v) throw():dat(v.dat),lb(v.lb),ub(v.ub),size(v.size),start(v.start),offset(v.offset) { } 00230 public: 00231 00232 //---------------------- Standardfunktionen ------------------------ 00234 friend INLINE int Lb(const l_rmatrix_subv &rv) throw() { return rv.lb; } 00236 friend INLINE int Ub(const l_rmatrix_subv &rv) throw() { return rv.ub; } 00238 INLINE l_real &operator [](const int &i) const 00239 #if(CXSC_INDEX_CHECK) 00240 throw(ERROR_LRVECTOR_ELEMENT_NOT_IN_VEC); 00241 #else 00242 throw(); 00243 #endif 00244 00245 INLINE l_rmatrix_subv &operator ()() throw() { return *this; } 00247 INLINE l_rmatrix_subv operator ()(const int &i) 00248 #if(CXSC_INDEX_CHECK) 00249 throw(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG); 00250 #else 00251 throw(); 00252 #endif 00253 00254 INLINE l_rmatrix_subv operator ()(const int &i1,const int &i2) 00255 #if(CXSC_INDEX_CHECK) 00256 throw(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG); 00257 #else 00258 throw(); 00259 #endif 00260 00261 00263 INLINE l_rmatrix_subv &operator =(const l_rmatrix_subv &rv) throw(); 00265 INLINE l_rmatrix_subv &operator =(const l_real &r) throw(); 00267 INLINE l_rmatrix_subv &operator =(const l_rmatrix &m) 00268 #if(CXSC_INDEX_CHECK) 00269 throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ); 00270 #else 00271 throw(); 00272 #endif 00273 00274 INLINE l_rmatrix_subv &operator =(const l_rmatrix_slice &m) 00275 #if(CXSC_INDEX_CHECK) 00276 throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ); 00277 #else 00278 throw(); 00279 #endif 00280 00281 INLINE l_rmatrix_subv &operator =(const l_rvector &v) 00282 #if(CXSC_INDEX_CHECK) 00283 throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM); 00284 #else 00285 throw(); 00286 #endif 00287 00288 INLINE l_rmatrix_subv &operator =(const l_rvector_slice &v) 00289 #if(CXSC_INDEX_CHECK) 00290 throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM); 00291 #else 00292 throw(); 00293 #endif 00294 00296 INLINE l_rmatrix_subv &operator *=(const l_real &c) throw(); 00298 INLINE l_rmatrix_subv &operator +=(const l_real &c) throw(); 00300 INLINE l_rmatrix_subv &operator -=(const l_real &c) throw(); 00302 INLINE l_rmatrix_subv &operator /=(const l_real &c) throw(); 00304 INLINE l_rmatrix_subv &operator -=(const l_rvector &rv) 00305 #if(CXSC_INDEX_CHECK) 00306 throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM); 00307 #else 00308 throw(); 00309 #endif 00310 00311 INLINE l_rmatrix_subv &operator +=(const l_rvector &rv) 00312 #if(CXSC_INDEX_CHECK) 00313 throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM); 00314 #else 00315 throw(); 00316 #endif 00317 00318 INLINE l_rmatrix_subv &operator -=(const l_rvector_slice &rv) 00319 #if(CXSC_INDEX_CHECK) 00320 throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM); 00321 #else 00322 throw(); 00323 #endif 00324 00325 INLINE l_rmatrix_subv &operator +=(const l_rvector_slice &rv) 00326 #if(CXSC_INDEX_CHECK) 00327 throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM); 00328 #else 00329 throw(); 00330 #endif 00331 // Real 00333 INLINE l_rmatrix_subv &operator =(const rmatrix_subv &rv) throw(); 00335 INLINE l_rmatrix_subv &operator =(const real &r) throw(); 00337 INLINE l_rmatrix_subv &operator =(const rmatrix &m) 00338 #if(CXSC_INDEX_CHECK) 00339 throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ); 00340 #else 00341 throw(); 00342 #endif 00343 00344 INLINE l_rmatrix_subv &operator =(const rmatrix_slice &m) 00345 #if(CXSC_INDEX_CHECK) 00346 throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ); 00347 #else 00348 throw(); 00349 #endif 00350 00351 INLINE l_rmatrix_subv &operator =(const rvector &v) 00352 #if(CXSC_INDEX_CHECK) 00353 throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM); 00354 #else 00355 throw(); 00356 #endif 00357 00358 INLINE l_rmatrix_subv &operator =(const rvector_slice &v) 00359 #if(CXSC_INDEX_CHECK) 00360 throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM); 00361 #else 00362 throw(); 00363 #endif 00364 00366 INLINE l_rmatrix_subv &operator *=(const real &c) throw(); 00368 INLINE l_rmatrix_subv &operator +=(const real &c) throw(); 00370 INLINE l_rmatrix_subv &operator -=(const real &c) throw(); 00372 INLINE l_rmatrix_subv &operator /=(const real &c) throw(); 00374 INLINE l_rmatrix_subv &operator -=(const rvector &rv) 00375 #if(CXSC_INDEX_CHECK) 00376 throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM); 00377 #else 00378 throw(); 00379 #endif 00380 00381 INLINE l_rmatrix_subv &operator +=(const rvector &rv) 00382 #if(CXSC_INDEX_CHECK) 00383 throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM); 00384 #else 00385 throw(); 00386 #endif 00387 00388 INLINE l_rmatrix_subv &operator -=(const rvector_slice &rv) 00389 #if(CXSC_INDEX_CHECK) 00390 throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM); 00391 #else 00392 throw(); 00393 #endif 00394 00395 INLINE l_rmatrix_subv &operator +=(const rvector_slice &rv) 00396 #if(CXSC_INDEX_CHECK) 00397 throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM); 00398 #else 00399 throw(); 00400 #endif 00401 //#else 00402 //#endif 00403 00404 }; 00405 00406 00407 //----------------------- Matrix ----------------------------------------------- 00408 00409 class l_rmatrix_slice; 00410 00412 00415 class l_rmatrix 00416 { 00417 friend class l_rmatrix_slice; 00418 friend class l_rmatrix_subv; 00419 friend class l_imatrix; 00420 private: 00421 l_real *dat; 00422 int lb1,ub1,lb2,ub2,xsize,ysize; 00423 00424 public: 00425 //#if(CXSC_INDEX_CHECK) 00426 #ifdef _CXSC_FRIEND_TPL 00427 //----------------- Templates --------------------------------------- 00428 template <class S,class M> friend void _smconstr(S &s,const M &m) 00429 #if(CXSC_INDEX_CHECK) 00430 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>,ERROR__USE_OF_UNINITIALIZED_OBJ<M>); 00431 #else 00432 throw(); 00433 #endif 00434 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m) 00435 #if(CXSC_INDEX_CHECK) 00436 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>); 00437 #else 00438 throw(); 00439 #endif 00440 template <class M1,class M2,class S> friend M1 &_mmassign(M1 &m1,const M2 &m,S ms) throw(); 00441 template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) throw(); 00442 template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m) 00443 #if(CXSC_INDEX_CHECK) 00444 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00445 #else 00446 throw(); 00447 #endif 00448 template <class M,class S> friend M &_msassign(M &m,const S &r) throw(); 00449 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m) 00450 #if(CXSC_INDEX_CHECK) 00451 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>); 00452 #else 00453 throw(); 00454 #endif 00455 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) throw(); 00456 template <class M> friend int _mlb(const M &m, const int &i) 00457 #if(CXSC_INDEX_CHECK) 00458 throw(ERROR__WRONG_ROW_OR_COL<M>); 00459 #else 00460 throw(); 00461 #endif 00462 template <class M> friend int _mub(const M &m, const int &i) 00463 #if(CXSC_INDEX_CHECK) 00464 throw(ERROR__WRONG_ROW_OR_COL<M>); 00465 #else 00466 throw(); 00467 #endif 00468 template <class M> friend M &_msetlb(M &m, const int &i,const int &j) 00469 #if(CXSC_INDEX_CHECK) 00470 throw(ERROR__WRONG_ROW_OR_COL<M>); 00471 #else 00472 throw(); 00473 #endif 00474 template <class M> friend M &_msetub(M &m, const int &i,const int &j) 00475 #if(CXSC_INDEX_CHECK) 00476 throw(ERROR__WRONG_ROW_OR_COL<M>); 00477 #else 00478 throw(); 00479 #endif 00480 template <class M> friend void _mresize(M &A) throw(); 00481 template <class M,class S> friend void _mresize(M &A,const int &m, const int &n) 00482 #if(CXSC_INDEX_CHECK) 00483 throw(ERROR__WRONG_BOUNDARIES<M>); 00484 #else 00485 throw(); 00486 #endif 00487 template <class M,class S> friend void _mresize(M &A,const int &m1, const int &m2,const int &n1,const int &n2) 00488 #if(CXSC_INDEX_CHECK) 00489 throw(ERROR__WRONG_BOUNDARIES<M>); 00490 #else 00491 throw(); 00492 #endif 00493 template <class M,class E> friend E _mabs(const M &m) throw(); 00494 template <class MS,class E> friend E _msabs(const MS &ms) throw(); 00495 //-------------- matrix-matrix ------------- 00496 template <class M1,class M2,class E> friend E _mmplus(const M1 &m1,const M2 &m2) 00497 #if(CXSC_INDEX_CHECK) 00498 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00499 #else 00500 throw(); 00501 #endif 00502 template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms) 00503 #if(CXSC_INDEX_CHECK) 00504 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00505 #else 00506 throw(); 00507 #endif 00508 template <class M> friend M _mminus(const M &m) throw(); 00509 template <class MS,class E> friend E _msminus(const MS &ms) throw(); 00510 template <class M1,class M2,class E> friend E _mmminus(const M1 &m1,const M2 &m2) 00511 #if(CXSC_INDEX_CHECK) 00512 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00513 #else 00514 throw(); 00515 #endif 00516 template <class M1,class M2> friend M1 &_mmplusassign(M1 &m1,const M2 &m2) 00517 #if(CXSC_INDEX_CHECK) 00518 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00519 #else 00520 throw(); 00521 #endif 00522 template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms) 00523 #if(CXSC_INDEX_CHECK) 00524 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00525 #else 00526 throw(); 00527 #endif 00528 template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1) 00529 #if(CXSC_INDEX_CHECK) 00530 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00531 #else 00532 throw(); 00533 #endif 00534 template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2) 00535 #if(CXSC_INDEX_CHECK) 00536 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00537 #else 00538 throw(); 00539 #endif 00540 template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms) 00541 #if(CXSC_INDEX_CHECK) 00542 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00543 #else 00544 throw(); 00545 #endif 00546 template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m) 00547 #if(CXSC_INDEX_CHECK) 00548 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00549 #else 00550 throw(); 00551 #endif 00552 template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2) 00553 #if(CXSC_INDEX_CHECK) 00554 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00555 #else 00556 throw(); 00557 #endif 00558 template <class M1,class M2> friend M1 &_mmminusassign(M1 &m1,const M2 &m2) 00559 #if(CXSC_INDEX_CHECK) 00560 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00561 #else 00562 throw(); 00563 #endif 00564 template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms) 00565 #if(CXSC_INDEX_CHECK) 00566 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00567 #else 00568 throw(); 00569 #endif 00570 template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1) 00571 #if(CXSC_INDEX_CHECK) 00572 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00573 #else 00574 throw(); 00575 #endif 00576 template <class M1,class M2,class E> friend E _mmlmult(const M1 &m1, const M2 &m2) 00577 #if(CXSC_INDEX_CHECK) 00578 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00579 #else 00580 throw(); 00581 #endif 00582 template <class M1,class M2,class S> friend M1 &_mmlmultassign(M1 &m1,const M2 &m2) 00583 #if(CXSC_INDEX_CHECK) 00584 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00585 #else 00586 throw(); 00587 #endif 00588 template <class M,class MS,class E> friend E _mmslmult(const M &m1, const MS &ms) 00589 #if(CXSC_INDEX_CHECK) 00590 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00591 #else 00592 throw(); 00593 #endif 00594 template <class MS,class M,class E> friend E _msmlmult(const MS &ms, const M &m2) 00595 #if(CXSC_INDEX_CHECK) 00596 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00597 #else 00598 throw(); 00599 #endif 00600 template <class M,class MS,class S> friend M &_mmslmultassign(M &m1,const MS &ms) 00601 #if(CXSC_INDEX_CHECK) 00602 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00603 #else 00604 throw(); 00605 #endif 00606 template <class MS1,class MS2,class E> friend E _msmslmult(const MS1 &ms1, const MS2 &ms2) 00607 #if(CXSC_INDEX_CHECK) 00608 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00609 #else 00610 throw(); 00611 #endif 00612 template <class M1,class M2,class E> friend E _mmconv(const M1 &m1,const M2 &m2) 00613 #if(CXSC_INDEX_CHECK) 00614 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00615 #else 00616 throw(); 00617 #endif 00618 template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms) 00619 #if(CXSC_INDEX_CHECK) 00620 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00621 #else 00622 throw(); 00623 #endif 00624 //-------- matrix-scalar ----------------- 00625 template <class S,class M,class E> friend E _smmult(const S &c, const M &m) throw(); 00626 template <class M,class S> friend M &_msmultassign(M &m,const S &c) throw(); 00627 template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) throw(); 00628 template <class M,class S,class E> friend E _msdiv(const M &m,const S &c) throw(); 00629 template <class M,class S> friend M &_msdivassign(M &m,const S &c) throw(); 00630 template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) throw(); 00631 //-------- matrix-vector --------------------- 00632 template <class M,class V,class E> friend E _mvlmult(const M &m,const V &v) 00633 #if(CXSC_INDEX_CHECK) 00634 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00635 #else 00636 throw(); 00637 #endif 00638 template <class V,class M,class E> friend E _vmlmult(const V &v,const M &m) 00639 #if(CXSC_INDEX_CHECK) 00640 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00641 #else 00642 throw(); 00643 #endif 00644 template <class V,class M,class S> friend V &_vmlmultassign(V &v,const M &m) 00645 #if(CXSC_INDEX_CHECK) 00646 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00647 #else 00648 throw(); 00649 #endif 00650 template <class VS,class M,class S> friend VS &_vsmlmultassign(VS &v,const M &m) 00651 #if(CXSC_INDEX_CHECK) 00652 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00653 #else 00654 throw(); 00655 #endif 00656 00657 template <class M> friend void *_mvoid(const M &m) throw(); 00658 template <class M> friend bool _mnot(const M &m) throw(); 00659 template <class MS> friend void *_msvoid(const MS &ms) throw(); 00660 template <class MS> friend bool _msnot(const MS &ms) throw(); 00661 template <class M1,class M2> friend bool _mmeq(const M1 &m1,const M2 &m2) throw(); 00662 template <class M1,class M2> friend bool _mmneq(const M1 &m1,const M2 &m2) throw(); 00663 template <class M1,class M2> friend bool _mmless(const M1 &m1,const M2 &m2) throw(); 00664 template <class M1,class M2> friend bool _mmleq(const M1 &m1,const M2 &m2) throw(); 00665 template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) throw(); 00666 template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) throw(); 00667 template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) throw(); 00668 template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) throw(); 00669 template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) throw(); 00670 template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) throw(); 00671 template <class M> friend std::ostream &_mout(std::ostream &s,const M &r) throw(); 00672 template <class M> friend std::istream &_min(std::istream &s,M &r) throw(); 00673 00674 //--- Real --------- matrix-vector ---------------------- 00675 template <class MS,class V,class E> friend E _msvlmult(const MS &ms,const V &v) 00676 #if(CXSC_INDEX_CHECK) 00677 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00678 #else 00679 throw(); 00680 #endif 00681 template <class V,class MS,class E> friend E _vmslmult(const V &v,const MS &ms) 00682 #if(CXSC_INDEX_CHECK) 00683 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00684 #else 00685 throw(); 00686 #endif 00687 00688 template <class M1,class M2,class E> friend E _mmlimult(const M1 &m1, const M2 &m2) 00689 #if(CXSC_INDEX_CHECK) 00690 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00691 #else 00692 throw(); 00693 #endif 00694 00695 template <class M,class MS,class E> friend E _mmslimult(const M &m1, const MS &ms) 00696 #if(CXSC_INDEX_CHECK) 00697 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00698 #else 00699 throw(); 00700 #endif 00701 00702 template <class MS,class M,class E> friend E _msmlimult(const MS &ms, const M &m2) 00703 #if(CXSC_INDEX_CHECK) 00704 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00705 #else 00706 throw(); 00707 #endif 00708 00709 template <class MS1,class MS2,class E> friend E _msmslimult(const MS1 &ms1, const MS2 &ms2) 00710 #if(CXSC_INDEX_CHECK) 00711 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00712 #else 00713 throw(); 00714 #endif 00715 00716 template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2) 00717 #if(CXSC_INDEX_CHECK) 00718 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00719 #else 00720 throw(); 00721 #endif 00722 template <class M1,class M2,class E> friend E _mmsect(const M1 &m1,const M2 &m2) 00723 #if(CXSC_INDEX_CHECK) 00724 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00725 #else 00726 throw(); 00727 #endif 00728 template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms) 00729 #if(CXSC_INDEX_CHECK) 00730 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00731 #else 00732 throw(); 00733 #endif 00734 00735 template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2) 00736 #if(CXSC_INDEX_CHECK) 00737 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00738 #else 00739 throw(); 00740 #endif 00741 // matrix-scalar 00742 00743 // matrix-vector 00744 00745 template <class M,class V,class E> friend E _mvlimult(const M &m,const V &v) 00746 #if(CXSC_INDEX_CHECK) 00747 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00748 #else 00749 throw(); 00750 #endif 00751 template <class V,class M,class E> friend E _vmlimult(const V &v,const M &m) 00752 #if(CXSC_INDEX_CHECK) 00753 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00754 #else 00755 throw(); 00756 #endif 00757 template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v) 00758 #if(CXSC_INDEX_CHECK) 00759 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00760 #else 00761 throw(); 00762 #endif 00763 00764 // l_interval ---------- 00765 00766 template <class M,class E> friend E _mdiam(const M &m) throw(); 00767 template <class M,class E> friend E _mmid(const M &m) throw(); 00768 template <class MS,class E> friend E _msdiam(const MS &ms) throw(); 00769 template <class MS,class E> friend E _msmid(const MS &ms) throw(); 00770 template <class M,class E> friend E _minf(const M &m) throw(); 00771 template <class MS,class E> friend E _msinf(const MS &ms) throw(); 00772 template <class M,class E> friend E _msup(const M &m) throw(); 00773 template <class MS,class E> friend E _mssup(const MS &ms) throw(); 00774 template <class M1,class M2> friend M1 &_mmsetinf(M1 &m1,const M2 &m2) 00775 #if(CXSC_INDEX_CHECK) 00776 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00777 #else 00778 throw(); 00779 #endif 00780 template <class M1,class M2> friend M1 &_mmsetsup(M1 &m1,const M2 &m2) 00781 #if(CXSC_INDEX_CHECK) 00782 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00783 #else 00784 throw(); 00785 #endif 00786 template <class M1,class M2> friend M1 &_mmusetinf(M1 &m1,const M2 &m2) 00787 #if(CXSC_INDEX_CHECK) 00788 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00789 #else 00790 throw(); 00791 #endif 00792 template <class M1,class M2> friend M1 &_mmusetsup(M1 &m1,const M2 &m2) 00793 #if(CXSC_INDEX_CHECK) 00794 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00795 #else 00796 throw(); 00797 #endif 00798 template <class MS1,class M2> friend MS1 &_msmsetinf(MS1 &ms1,const M2 &m2) 00799 #if(CXSC_INDEX_CHECK) 00800 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 00801 #else 00802 throw(); 00803 #endif 00804 template <class MS1,class M2> friend MS1 &_msmsetsup(MS1 &ms1,const M2 &m2) 00805 #if(CXSC_INDEX_CHECK) 00806 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 00807 #else 00808 throw(); 00809 #endif 00810 template <class MS1,class M2> friend MS1 &_msmusetinf(MS1 &ms1,const M2 &m2) 00811 #if(CXSC_INDEX_CHECK) 00812 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 00813 #else 00814 throw(); 00815 #endif 00816 template <class MS1,class M2> friend MS1 &_msmusetsup(MS1 &ms1,const M2 &m2) 00817 #if(CXSC_INDEX_CHECK) 00818 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 00819 #else 00820 throw(); 00821 #endif 00822 00823 template <class M1,class M2,class S> friend M1 &_mmlimultassign(M1 &m1,const M2 &m2) 00824 #if(CXSC_INDEX_CHECK) 00825 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00826 #else 00827 throw(); 00828 #endif 00829 00830 template <class M,class MS,class S> friend M &_mmslimultassign(M &m1,const MS &ms) 00831 #if(CXSC_INDEX_CHECK) 00832 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00833 #else 00834 throw(); 00835 #endif 00836 00837 template <class M1,class M2> friend M1 &_mmconvassign(M1 &m1,const M2 &m2) 00838 #if(CXSC_INDEX_CHECK) 00839 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00840 #else 00841 throw(); 00842 #endif 00843 template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms) 00844 #if(CXSC_INDEX_CHECK) 00845 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00846 #else 00847 throw(); 00848 #endif 00849 template <class MS,class M> friend MS &_msmconvassign(MS &ms,const M &m1) 00850 #if(CXSC_INDEX_CHECK) 00851 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00852 #else 00853 throw(); 00854 #endif 00855 00856 template <class M1,class M2> friend M1 &_mmsectassign(M1 &m1,const M2 &m2) 00857 #if(CXSC_INDEX_CHECK) 00858 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00859 #else 00860 throw(); 00861 #endif 00862 template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms) 00863 #if(CXSC_INDEX_CHECK) 00864 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00865 #else 00866 throw(); 00867 #endif 00868 template <class MS,class M> friend MS &_msmsectassign(MS &ms,const M &m1) 00869 #if(CXSC_INDEX_CHECK) 00870 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00871 #else 00872 throw(); 00873 #endif 00874 00875 template <class V,class M,class S> friend V &_vmlimultassign(V &v,const M &m) 00876 #if(CXSC_INDEX_CHECK) 00877 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00878 #else 00879 throw(); 00880 #endif 00881 template <class VS,class M,class S> friend VS &_vsmlimultassign(VS &v,const M &m) 00882 #if(CXSC_INDEX_CHECK) 00883 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00884 #else 00885 throw(); 00886 #endif 00887 00888 #endif 00889 00890 //-------------------------- Konstruktoren ---------------------------- 00891 00892 // l_real 00894 INLINE l_rmatrix(const l_rmatrix &rm) throw(); 00896 INLINE l_rmatrix(const l_rmatrix_slice &rm) throw(); 00898 INLINE l_rmatrix() throw(); 00900 explicit INLINE l_rmatrix(const int &m, const int &n) 00901 #if(CXSC_INDEX_CHECK) 00902 throw(ERROR_LRMATRIX_WRONG_BOUNDARIES); 00903 #else 00904 throw(); 00905 #endif 00906 00907 explicit INLINE l_rmatrix(const int &m1, const int &n1, const int &m2, const int &n2) 00908 #if(CXSC_INDEX_CHECK) 00909 throw(ERROR_LRMATRIX_WRONG_BOUNDARIES); 00910 #else 00911 throw(); 00912 #endif 00913 00914 explicit INLINE l_rmatrix(const l_rvector &v) throw(); 00916 explicit INLINE l_rmatrix(const l_rvector_slice &v) throw(); 00918 explicit INLINE l_rmatrix(const l_real &r) throw(); 00920 INLINE l_rmatrix &operator =(const l_real &r) throw(); 00922 INLINE l_rmatrix &operator =(const l_rmatrix &m) throw(); 00924 INLINE l_rmatrix &operator =(const l_rmatrix_slice &ms) throw(); 00926 INLINE l_rmatrix &operator =(const l_rvector &v) throw(); 00928 INLINE l_rmatrix &operator =(const l_rvector_slice &v) throw(); 00929 // real 00931 explicit INLINE l_rmatrix(const real &) throw(); 00933 explicit INLINE l_rmatrix(const rmatrix &rm) throw(); 00935 explicit INLINE l_rmatrix(const rmatrix_slice &rm) throw(); 00937 explicit INLINE l_rmatrix(const rvector &v) throw(); 00939 explicit INLINE l_rmatrix(const rvector_slice &v) throw(); 00941 INLINE l_rmatrix &operator =(const real &r) throw(); 00943 INLINE l_rmatrix &operator =(const rmatrix &m) throw(); 00945 INLINE l_rmatrix &operator =(const rmatrix_slice &ms) throw(); 00947 INLINE l_rmatrix &operator =(const rvector &v) throw(); 00949 INLINE l_rmatrix &operator =(const rvector_slice &v) throw(); 00950 00951 //--------------------------- Destruktoren ----------------------------- 00952 00953 INLINE ~l_rmatrix() throw() { delete [] dat; } 00954 00955 //------------------------- Standardfunktionen ------------------------- 00956 00958 INLINE l_rmatrix_subv operator [](const int &i) const 00959 #if(CXSC_INDEX_CHECK) 00960 throw(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT); 00961 #else 00962 throw(); 00963 #endif 00964 00965 INLINE l_rmatrix_subv operator [](const cxscmatrix_column &i) const 00966 #if(CXSC_INDEX_CHECK) 00967 throw(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT); 00968 #else 00969 throw(); 00970 #endif 00971 00972 INLINE l_rmatrix &operator ()() throw() { return *this; } 00974 INLINE l_rmatrix_slice operator ()(const int &m, const int &n) 00975 #if(CXSC_INDEX_CHECK) 00976 throw(ERROR_LRMATRIX_SUB_ARRAY_TOO_BIG); 00977 #else 00978 throw(); 00979 #endif 00980 00981 INLINE l_rmatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2) 00982 #if(CXSC_INDEX_CHECK) 00983 throw(ERROR_LRMATRIX_SUB_ARRAY_TOO_BIG); 00984 #else 00985 throw(); 00986 #endif 00987 INLINE operator void*() throw(); 00988 //#else 00989 //#endif 00990 }; 00991 00992 00994 00999 class l_rmatrix_slice 01000 { 01001 friend class l_rmatrix; 01002 friend class l_imatrix; 01003 private: 01004 l_real *dat; 01005 int offset1,offset2,mxsize,mysize; 01006 int start1,end1,start2,end2,sxsize,sysize; // slice size 01007 01008 public: 01009 //#if(CXSC_INDEX_CHECK) 01010 #ifdef _CXSC_FRIEND_TPL 01011 //----------------- Templates --------------------------------------- 01012 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m) 01013 #if(CXSC_INDEX_CHECK) 01014 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>); 01015 #else 01016 throw(); 01017 #endif 01018 template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m) 01019 #if(CXSC_INDEX_CHECK) 01020 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01021 #else 01022 throw(); 01023 #endif 01024 template <class MS1,class MS2> friend MS1 &_msmsassign(MS1 &ms1,const MS2 &ms) 01025 #if(CXSC_INDEX_CHECK) 01026 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 01027 #else 01028 throw(); 01029 #endif 01030 template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) throw(); 01031 template <class MS,class S> friend MS &_mssassign(MS &ms,const S &r) throw(); 01032 01033 template <class MS> friend int _mslb(const MS &ms, const int &i) 01034 #if(CXSC_INDEX_CHECK) 01035 throw(ERROR__WRONG_ROW_OR_COL<MS>); 01036 #else 01037 throw(); 01038 #endif 01039 template <class MS> friend int _msub(const MS &ms, const int &i) 01040 #if(CXSC_INDEX_CHECK) 01041 throw(ERROR__WRONG_ROW_OR_COL<MS>); 01042 #else 01043 throw(); 01044 #endif 01045 template <class MS,class E> friend E _msabs(const MS &ms) throw(); 01046 //-------- matrix-matrix -------------- 01047 template <class MS,class E> friend E _msminus(const MS &ms) throw(); 01048 template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms) 01049 #if(CXSC_INDEX_CHECK) 01050 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01051 #else 01052 throw(); 01053 #endif 01054 template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2) 01055 #if(CXSC_INDEX_CHECK) 01056 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01057 #else 01058 throw(); 01059 #endif 01060 template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms) 01061 #if(CXSC_INDEX_CHECK) 01062 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01063 #else 01064 throw(); 01065 #endif 01066 template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1) 01067 #if(CXSC_INDEX_CHECK) 01068 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01069 #else 01070 throw(); 01071 #endif 01072 template <class MS1,class MS2> friend MS1 &_msmsplusassign(MS1 &ms1,const MS2 &ms2) 01073 #if(CXSC_INDEX_CHECK) 01074 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 01075 #else 01076 throw(); 01077 #endif 01078 template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms) 01079 #if(CXSC_INDEX_CHECK) 01080 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01081 #else 01082 throw(); 01083 #endif 01084 template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m) 01085 #if(CXSC_INDEX_CHECK) 01086 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01087 #else 01088 throw(); 01089 #endif 01090 template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2) 01091 #if(CXSC_INDEX_CHECK) 01092 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01093 #else 01094 throw(); 01095 #endif 01096 template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms) 01097 #if(CXSC_INDEX_CHECK) 01098 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01099 #else 01100 throw(); 01101 #endif 01102 template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1) 01103 #if(CXSC_INDEX_CHECK) 01104 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01105 #else 01106 throw(); 01107 #endif 01108 template <class MS1,class MS2> friend MS1 &_msmsminusassign(MS1 &ms1,const MS2 &ms2) 01109 #if(CXSC_INDEX_CHECK) 01110 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 01111 #else 01112 throw(); 01113 #endif 01114 template <class M,class MS,class E> friend E _mmslmult(const M &m1, const MS &ms) 01115 #if(CXSC_INDEX_CHECK) 01116 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01117 #else 01118 throw(); 01119 #endif 01120 template <class MS,class M,class E> friend E _msmlmult(const MS &ms, const M &m2) 01121 #if(CXSC_INDEX_CHECK) 01122 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01123 #else 01124 throw(); 01125 #endif 01126 template <class M,class MS,class S> friend M &_mmslmultassign(M &m1,const MS &ms) 01127 #if(CXSC_INDEX_CHECK) 01128 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01129 #else 01130 throw(); 01131 #endif 01132 template <class MS1,class MS2,class E> friend E _msmslmult(const MS1 &ms1, const MS2 &ms2) 01133 #if(CXSC_INDEX_CHECK) 01134 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01135 #else 01136 throw(); 01137 #endif 01138 template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms) 01139 #if(CXSC_INDEX_CHECK) 01140 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01141 #else 01142 throw(); 01143 #endif 01144 template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2) 01145 #if(CXSC_INDEX_CHECK) 01146 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01147 #else 01148 throw(); 01149 #endif 01150 //--------- matrix-vector -------------- 01151 template <class MS,class V,class E> friend E _msvlmult(const MS &ms,const V &v) 01152 #if(CXSC_INDEX_CHECK) 01153 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01154 #else 01155 throw(); 01156 #endif 01157 template <class V,class MS,class E> friend E _vmslmult(const V &v,const MS &ms) 01158 #if(CXSC_INDEX_CHECK) 01159 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01160 #else 01161 throw(); 01162 #endif 01163 template <class V,class MS,class S> friend V &_vmslmultassign(V &v,const MS &ms) 01164 #if(CXSC_INDEX_CHECK) 01165 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01166 #else 01167 throw(); 01168 #endif 01169 //--------- matrix-scalar -------------- 01170 template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) throw(); 01171 template <class MS,class S> friend MS &_mssmultassign(MS &ms,const S &c) throw(); 01172 template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) throw(); 01173 template <class MS,class S> friend MS &_mssdivassign(MS &ms,const S &c) throw(); 01174 01175 template <class MS> friend void *_msvoid(const MS &ms) throw(); 01176 template <class MS> friend bool _msnot(const MS &ms) throw(); 01177 template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) throw(); 01178 template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) throw(); 01179 template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) throw(); 01180 template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) throw(); 01181 template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) throw(); 01182 template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) throw(); 01183 template <class MS1,class MS2> friend bool _msmseq(const MS1 &ms1,const MS2 &ms2) throw(); 01184 template <class MS1,class MS2> friend bool _msmsneq(const MS1 &ms1,const MS2 &ms2) throw(); 01185 template <class MS1,class MS2> friend bool _msmsless(const MS1 &ms1,const MS2 &ms2) throw(); 01186 template <class MS1,class MS2> friend bool _msmsleq(const MS1 &ms1,const MS2 &ms2) throw(); 01187 template <class MS> friend std::ostream &_msout(std::ostream &s,const MS &r) throw(); 01188 template <class MS> friend std::istream &_msin(std::istream &s,MS &r) throw(); 01189 01190 //--- Real ------------ matrix-matrix ----------- 01191 01192 template <class M,class MS,class E> friend E _mmslimult(const M &m1, const MS &ms) 01193 #if(CXSC_INDEX_CHECK) 01194 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01195 #else 01196 throw(); 01197 #endif 01198 template <class MS,class M,class E> friend E _msmlimult(const MS &ms, const M &m2) 01199 #if(CXSC_INDEX_CHECK) 01200 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01201 #else 01202 throw(); 01203 #endif 01204 01205 template <class MS1,class MS2,class E> friend E _msmslimult(const MS1 &ms1, const MS2 &ms2) 01206 #if(CXSC_INDEX_CHECK) 01207 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01208 #else 01209 throw(); 01210 #endif 01211 01212 template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms) 01213 #if(CXSC_INDEX_CHECK) 01214 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01215 #else 01216 throw(); 01217 #endif 01218 template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2) 01219 #if(CXSC_INDEX_CHECK) 01220 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01221 #else 01222 throw(); 01223 #endif 01224 // matrix-scalar 01225 // matrix-vector 01226 01227 template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v) 01228 #if(CXSC_INDEX_CHECK) 01229 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01230 #else 01231 throw(); 01232 #endif 01233 template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms) 01234 #if(CXSC_INDEX_CHECK) 01235 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01236 #else 01237 throw(); 01238 #endif 01239 01240 // l_interval -------------- 01241 01242 template <class M1,class MS2> friend M1 &_mmssetinf(M1 &m1,const MS2 &ms2) 01243 #if(CXSC_INDEX_CHECK) 01244 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 01245 #else 01246 throw(); 01247 #endif 01248 template <class M1,class MS2> friend M1 &_mmssetsup(M1 &m1,const MS2 &ms2) 01249 #if(CXSC_INDEX_CHECK) 01250 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 01251 #else 01252 throw(); 01253 #endif 01254 template <class M1,class MS2> friend M1 &_mmsusetinf(M1 &m1,const MS2 &ms2) 01255 #if(CXSC_INDEX_CHECK) 01256 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 01257 #else 01258 throw(); 01259 #endif 01260 template <class M1,class MS2> friend M1 &_mmsusetsup(M1 &m1,const MS2 &ms2) 01261 #if(CXSC_INDEX_CHECK) 01262 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 01263 #else 01264 throw(); 01265 #endif 01266 template <class MS1,class MS2> friend MS1 &_msmssetinf(MS1 &ms1,const MS2 &ms2) 01267 #if(CXSC_INDEX_CHECK) 01268 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 01269 #else 01270 throw(); 01271 #endif 01272 template <class MS1,class MS2> friend MS1 &_msmssetsup(MS1 &ms1,const MS2 &ms2) 01273 #if(CXSC_INDEX_CHECK) 01274 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 01275 #else 01276 throw(); 01277 #endif 01278 template <class MS1,class MS2> friend MS1 &_msmsusetinf(MS1 &ms1,const MS2 &ms2) 01279 #if(CXSC_INDEX_CHECK) 01280 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 01281 #else 01282 throw(); 01283 #endif 01284 template <class MS1,class MS2> friend MS1 &_msmsusetsup(MS1 &ms1,const MS2 &ms2) 01285 #if(CXSC_INDEX_CHECK) 01286 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 01287 #else 01288 throw(); 01289 #endif 01290 01291 01292 template <class M,class MS,class S> friend M &_mmslimultassign(M &m1,const MS &ms) 01293 #if(CXSC_INDEX_CHECK) 01294 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01295 #else 01296 throw(); 01297 #endif 01298 01299 01300 template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms) 01301 #if(CXSC_INDEX_CHECK) 01302 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01303 #else 01304 throw(); 01305 #endif 01306 template <class MS1,class MS2> friend MS1 &_msmsconvassign(MS1 &ms1,const MS2 &ms2) 01307 #if(CXSC_INDEX_CHECK) 01308 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 01309 #else 01310 throw(); 01311 #endif 01312 01313 template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms) 01314 #if(CXSC_INDEX_CHECK) 01315 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01316 #else 01317 throw(); 01318 #endif 01319 template <class MS1,class MS2> friend MS1 &_msmssectassign(MS1 &ms1,const MS2 &ms2) 01320 #if(CXSC_INDEX_CHECK) 01321 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 01322 #else 01323 throw(); 01324 #endif 01325 01326 /* friend TINLINE l_ivector &_vsmslimultassign<l_ivector_slice,l_rmatrix_slice,l_interval>(l_ivector_slice &v,const l_rmatrix_slice &ms) 01327 #if(CXSC_INDEX_CHECK) 01328 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM); 01329 #else 01330 throw(); 01331 #endif */ 01332 template <class V,class MS,class S> friend V &_vmslimultassign(V &v,const MS &ms) 01333 #if(CXSC_INDEX_CHECK) 01334 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01335 #else 01336 throw(); 01337 #endif 01338 01339 #endif 01340 01341 //--------------- Konstruktoren ---------------------------------------- 01342 01344 explicit INLINE l_rmatrix_slice(l_rmatrix &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) { } 01346 explicit INLINE l_rmatrix_slice(l_rmatrix_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) { } 01347 public: 01349 INLINE l_rmatrix_slice(const l_rmatrix_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) { } 01350 public: 01351 01352 //---------------- Standardfunktionen ----------------------------------- 01353 01354 friend INLINE l_rvector::l_rvector(const l_rmatrix_slice &sl) 01355 #if(CXSC_INDEX_CHECK) 01356 throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ); 01357 #else 01358 throw(); 01359 #endif 01360 friend INLINE l_rmatrix::l_rmatrix(const l_rmatrix_slice &) throw(); 01362 INLINE l_rmatrix_slice &operator =(const l_rmatrix &m) 01363 #if(CXSC_INDEX_CHECK) 01364 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01365 #else 01366 throw(); 01367 #endif 01368 01369 INLINE l_rmatrix_slice &operator =(const l_rmatrix_slice &ms) 01370 #if(CXSC_INDEX_CHECK) 01371 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01372 #else 01373 throw(); 01374 #endif 01375 01376 INLINE l_rmatrix_slice &operator =(const l_real &r) throw(); 01378 INLINE l_rmatrix_slice &operator =(const l_rvector &v) 01379 #if(CXSC_INDEX_CHECK) 01380 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01381 #else 01382 throw(); 01383 #endif 01384 01385 INLINE l_rmatrix_slice &operator =(const l_rvector_slice &v) 01386 #if(CXSC_INDEX_CHECK) 01387 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01388 #else 01389 throw(); 01390 #endif 01391 01392 INLINE l_rmatrix_slice &operator =(const rmatrix &m) 01393 #if(CXSC_INDEX_CHECK) 01394 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01395 #else 01396 throw(); 01397 #endif 01398 01399 INLINE l_rmatrix_slice &operator =(const rmatrix_slice &ms) 01400 #if(CXSC_INDEX_CHECK) 01401 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01402 #else 01403 throw(); 01404 #endif 01405 01406 INLINE l_rmatrix_slice &operator =(const real &r) throw(); 01408 INLINE l_rmatrix_slice &operator =(const rvector &v) 01409 #if(CXSC_INDEX_CHECK) 01410 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01411 #else 01412 throw(); 01413 #endif 01414 01415 INLINE l_rmatrix_slice &operator =(const rvector_slice &v) 01416 #if(CXSC_INDEX_CHECK) 01417 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01418 #else 01419 throw(); 01420 #endif 01421 01422 INLINE l_rmatrix_subv operator [](const int &i) const 01423 #if(CXSC_INDEX_CHECK) 01424 throw(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT); 01425 #else 01426 throw(); 01427 #endif 01428 01429 INLINE l_rmatrix_subv operator [](const cxscmatrix_column &i) const 01430 #if(CXSC_INDEX_CHECK) 01431 throw(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT); 01432 #else 01433 throw(); 01434 #endif 01435 01436 INLINE l_rmatrix_slice &operator ()() throw() { return *this; } 01438 INLINE l_rmatrix_slice operator ()(const int &m, const int &n) 01439 #if(CXSC_INDEX_CHECK) 01440 throw(ERROR_LRMATRIX_SUB_ARRAY_TOO_BIG); 01441 #else 01442 throw(); 01443 #endif 01444 01445 INLINE l_rmatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2) 01446 #if(CXSC_INDEX_CHECK) 01447 throw(ERROR_LRMATRIX_SUB_ARRAY_TOO_BIG); 01448 #else 01449 throw(); 01450 #endif 01451 01452 INLINE l_rmatrix_slice &operator *=(const l_rmatrix &m) 01453 #if(CXSC_INDEX_CHECK) 01454 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01455 #else 01456 throw(); 01457 #endif 01458 01459 INLINE l_rmatrix_slice &operator *=(const rmatrix &m) 01460 #if(CXSC_INDEX_CHECK) 01461 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01462 #else 01463 throw(); 01464 #endif 01465 01466 INLINE l_rmatrix_slice &operator *=(const l_rmatrix_slice &ms2) 01467 #if(CXSC_INDEX_CHECK) 01468 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01469 #else 01470 throw(); 01471 #endif 01472 01473 INLINE l_rmatrix_slice &operator *=(const rmatrix_slice &ms2) 01474 #if(CXSC_INDEX_CHECK) 01475 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01476 #else 01477 throw(); 01478 #endif 01479 01480 INLINE l_rmatrix_slice &operator +=(const l_rmatrix &m1) 01481 #if(CXSC_INDEX_CHECK) 01482 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01483 #else 01484 throw(); 01485 #endif 01486 01487 INLINE l_rmatrix_slice &operator +=(const rmatrix &m1) 01488 #if(CXSC_INDEX_CHECK) 01489 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01490 #else 01491 throw(); 01492 #endif 01493 01494 INLINE l_rmatrix_slice &operator +=(const l_rmatrix_slice &ms2) 01495 #if(CXSC_INDEX_CHECK) 01496 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01497 #else 01498 throw(); 01499 #endif 01500 01501 INLINE l_rmatrix_slice &operator +=(const rmatrix_slice &ms2) 01502 #if(CXSC_INDEX_CHECK) 01503 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01504 #else 01505 throw(); 01506 #endif 01507 01508 INLINE l_rmatrix_slice &operator -=(const l_rmatrix &m1) 01509 #if(CXSC_INDEX_CHECK) 01510 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01511 #else 01512 throw(); 01513 #endif 01514 01515 INLINE l_rmatrix_slice &operator -=(const rmatrix &m1) 01516 #if(CXSC_INDEX_CHECK) 01517 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01518 #else 01519 throw(); 01520 #endif 01521 01522 INLINE l_rmatrix_slice &operator -=(const l_rmatrix_slice &ms2) 01523 #if(CXSC_INDEX_CHECK) 01524 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01525 #else 01526 throw(); 01527 #endif 01528 01529 INLINE l_rmatrix_slice &operator -=(const rmatrix_slice &ms2) 01530 #if(CXSC_INDEX_CHECK) 01531 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01532 #else 01533 throw(); 01534 #endif 01535 01536 INLINE l_rmatrix_slice &operator |=(const l_rmatrix &m1) 01537 #if(CXSC_INDEX_CHECK) 01538 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01539 #else 01540 throw(); 01541 #endif 01542 01543 INLINE l_rmatrix_slice &operator |=(const rmatrix &m1) 01544 #if(CXSC_INDEX_CHECK) 01545 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01546 #else 01547 throw(); 01548 #endif 01549 01550 INLINE l_rmatrix_slice &operator |=(const l_rmatrix_slice &ms2) 01551 #if(CXSC_INDEX_CHECK) 01552 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01553 #else 01554 throw(); 01555 #endif 01556 01557 INLINE l_rmatrix_slice &operator |=(const rmatrix_slice &ms2) 01558 #if(CXSC_INDEX_CHECK) 01559 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01560 #else 01561 throw(); 01562 #endif 01563 01564 INLINE l_rmatrix_slice &operator *=(const l_real &c) throw(); 01566 INLINE l_rmatrix_slice &operator *=(const real &c) throw(); 01568 INLINE l_rmatrix_slice &operator /=(const l_real &c) throw(); 01570 INLINE l_rmatrix_slice &operator /=(const real &c) throw(); 01571 INLINE operator void*() throw(); 01572 //#else 01573 //#endif 01574 }; 01575 01576 //================================================================ 01577 //====================== Subvector Functions ===================== 01578 01579 //=======================Vector / Scalar ========================= 01580 01582 INLINE l_rvector operator /(const l_rmatrix_subv &rv, const l_real &s) throw(); 01584 INLINE l_rvector operator *(const l_rmatrix_subv &rv, const l_real &s) throw(); 01586 INLINE l_rvector operator *(const l_real &s, const l_rmatrix_subv &rv) throw(); 01587 01588 //======================== Vector / Vector ======================== 01589 01591 INLINE l_rvector abs(const l_rmatrix_subv &mv) throw(); 01592 01594 INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const l_rmatrix_subv &rv2) 01595 #if(CXSC_INDEX_CHECK) 01596 throw(OP_WITH_WRONG_DIM); 01597 #else 01598 throw(); 01599 #endif 01600 01601 INLINE void accumulate(dotprecision &dp, const l_rvector & rv1, const l_rmatrix_subv &rv2) 01602 #if(CXSC_INDEX_CHECK) 01603 throw(OP_WITH_WRONG_DIM); 01604 #else 01605 throw(); 01606 #endif 01607 01608 INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const l_rvector &rv2) 01609 #if(CXSC_INDEX_CHECK) 01610 throw(OP_WITH_WRONG_DIM); 01611 #else 01612 throw(); 01613 #endif 01614 01615 INLINE void accumulate(dotprecision &dp, const l_rvector_slice & sl1, const l_rmatrix_subv &rv2) 01616 #if(CXSC_INDEX_CHECK) 01617 throw(OP_WITH_WRONG_DIM); 01618 #else 01619 throw(); 01620 #endif 01621 01622 INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const l_rvector_slice &sl2) 01623 #if(CXSC_INDEX_CHECK) 01624 throw(OP_WITH_WRONG_DIM); 01625 #else 01626 throw(); 01627 #endif 01628 01630 INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const l_rmatrix_subv &rv2) 01631 #if(CXSC_INDEX_CHECK) 01632 throw(OP_WITH_WRONG_DIM); 01633 #else 01634 throw(); 01635 #endif 01636 01637 INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const l_rmatrix_subv &rv2) 01638 #if(CXSC_INDEX_CHECK) 01639 throw(OP_WITH_WRONG_DIM); 01640 #else 01641 throw(); 01642 #endif 01643 01644 INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const l_rvector &rv2) 01645 #if(CXSC_INDEX_CHECK) 01646 throw(OP_WITH_WRONG_DIM); 01647 #else 01648 throw(); 01649 #endif 01650 01651 INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl1, const l_rmatrix_subv &rv2) 01652 #if(CXSC_INDEX_CHECK) 01653 throw(OP_WITH_WRONG_DIM); 01654 #else 01655 throw(); 01656 #endif 01657 01658 INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const l_rvector_slice &sl2) 01659 #if(CXSC_INDEX_CHECK) 01660 throw(OP_WITH_WRONG_DIM); 01661 #else 01662 throw(); 01663 #endif 01664 01666 INLINE l_real operator *(const l_rmatrix_subv & rv1, const l_rmatrix_subv &rv2) 01667 #if(CXSC_INDEX_CHECK) 01668 throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM); 01669 #else 01670 throw(); 01671 #endif 01672 01673 INLINE l_real operator *(const l_rvector & rv1, const l_rmatrix_subv &rv2) 01674 #if(CXSC_INDEX_CHECK) 01675 throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM); 01676 #else 01677 throw(); 01678 #endif 01679 01680 INLINE l_real operator *(const l_rmatrix_subv &rv1,const l_rvector &rv2) 01681 #if(CXSC_INDEX_CHECK) 01682 throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM); 01683 #else 01684 throw(); 01685 #endif 01686 01687 INLINE l_real operator *(const l_rvector_slice &sl,const l_rmatrix_subv &sv) 01688 #if(CXSC_INDEX_CHECK) 01689 throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM); 01690 #else 01691 throw(); 01692 #endif 01693 01694 INLINE l_real operator *(const l_rmatrix_subv &mv,const l_rvector_slice &vs) 01695 #if(CXSC_INDEX_CHECK) 01696 throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM); 01697 #else 01698 throw(); 01699 #endif 01700 01702 INLINE l_rvector operator +(const l_rmatrix_subv & rv1, const l_rmatrix_subv &rv2) 01703 #if(CXSC_INDEX_CHECK) 01704 throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM); 01705 #else 01706 throw(); 01707 #endif 01708 01709 INLINE l_rvector operator +(const l_rmatrix_subv &rv1,const l_rvector &rv2) 01710 #if(CXSC_INDEX_CHECK) 01711 throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM); 01712 #else 01713 throw(); 01714 #endif 01715 01716 INLINE l_rvector operator +(const l_rvector & rv1, const l_rmatrix_subv &rv2) 01717 #if(CXSC_INDEX_CHECK) 01718 throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM); 01719 #else 01720 throw(); 01721 #endif 01722 01723 INLINE l_rvector operator +(const l_rvector_slice &sl,const l_rmatrix_subv &mv) 01724 #if(CXSC_INDEX_CHECK) 01725 throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM); 01726 #else 01727 throw(); 01728 #endif 01729 01730 INLINE l_rvector operator +(const l_rmatrix_subv &mv,const l_rvector_slice &sl) 01731 #if(CXSC_INDEX_CHECK) 01732 throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM); 01733 #else 01734 throw(); 01735 #endif 01736 01738 INLINE l_rvector operator -(const l_rmatrix_subv & rv1, const l_rmatrix_subv &rv2) 01739 #if(CXSC_INDEX_CHECK) 01740 throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM); 01741 #else 01742 throw(); 01743 #endif 01744 01745 INLINE l_rvector operator -(const l_rvector & rv1, const l_rmatrix_subv &rv2) 01746 #if(CXSC_INDEX_CHECK) 01747 throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM); 01748 #else 01749 throw(); 01750 #endif 01751 01752 INLINE l_rvector operator -(const l_rmatrix_subv &rv1,const l_rvector &rv2) 01753 #if(CXSC_INDEX_CHECK) 01754 throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM); 01755 #else 01756 throw(); 01757 #endif 01758 01759 INLINE l_rvector operator -(const l_rvector_slice &sl,const l_rmatrix_subv &mv) 01760 #if(CXSC_INDEX_CHECK) 01761 throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM); 01762 #else 01763 throw(); 01764 #endif 01765 01766 INLINE l_rvector operator -(const l_rmatrix_subv &mv,const l_rvector_slice &sl) 01767 #if(CXSC_INDEX_CHECK) 01768 throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM); 01769 #else 01770 throw(); 01771 #endif 01772 01773 //==================================================================== 01774 //===================== Matrix Functions ============================= 01775 01777 INLINE l_rmatrix _l_rmatrix(const l_rmatrix &rm) throw(); 01779 INLINE l_rmatrix _l_rmatrix(const l_rvector &v) throw(); 01781 INLINE l_rmatrix _l_rmatrix(const l_rvector_slice &v) throw(); 01783 INLINE l_rmatrix _l_rmatrix(const l_real &r) throw(); 01784 01786 INLINE int Lb(const l_rmatrix &rm, const int &i) 01787 #if(CXSC_INDEX_CHECK) 01788 throw(ERROR_LRMATRIX_WRONG_ROW_OR_COL); 01789 #else 01790 throw(); 01791 #endif 01792 01793 INLINE int Ub(const l_rmatrix &rm, const int &i) 01794 #if(CXSC_INDEX_CHECK) 01795 throw(ERROR_LRMATRIX_WRONG_ROW_OR_COL); 01796 #else 01797 throw(); 01798 #endif 01799 01800 INLINE int Lb(const l_rmatrix_slice &rm, const int &i) 01801 #if(CXSC_INDEX_CHECK) 01802 throw(ERROR_LRMATRIX_WRONG_ROW_OR_COL); 01803 #else 01804 throw(); 01805 #endif 01806 01807 INLINE int Ub(const l_rmatrix_slice &rm, const int &i) 01808 #if(CXSC_INDEX_CHECK) 01809 throw(ERROR_LRMATRIX_WRONG_ROW_OR_COL); 01810 #else 01811 throw(); 01812 #endif 01813 01814 INLINE l_rmatrix &SetLb(l_rmatrix &m, const int &i,const int &j) 01815 #if(CXSC_INDEX_CHECK) 01816 throw(ERROR_LRMATRIX_WRONG_ROW_OR_COL); 01817 #else 01818 throw(); 01819 #endif 01820 01821 INLINE l_rmatrix &SetUb(l_rmatrix &m, const int &i,const int &j) 01822 #if(CXSC_INDEX_CHECK) 01823 throw(ERROR_LRMATRIX_WRONG_ROW_OR_COL); 01824 #else 01825 throw(); 01826 #endif 01827 01828 INLINE void Resize(l_rmatrix &A) throw(); 01830 INLINE void Resize(l_rmatrix &A,const int &m, const int &n) 01831 #if(CXSC_INDEX_CHECK) 01832 throw(ERROR_LRMATRIX_WRONG_BOUNDARIES); 01833 #else 01834 throw(); 01835 #endif 01836 01837 INLINE void Resize(l_rmatrix &A,const int &m1, const int &m2,const int &n1,const int &n2) 01838 #if(CXSC_INDEX_CHECK) 01839 throw(ERROR_LRMATRIX_WRONG_BOUNDARIES); 01840 #else 01841 throw(); 01842 #endif 01843 01845 INLINE l_rmatrix abs(const l_rmatrix &m) throw(); 01847 INLINE l_rmatrix abs(const l_rmatrix_slice &ms) throw(); 01848 01849 //===================== Matrix / Scalar =============================== 01850 01852 INLINE l_rmatrix operator *(const l_real &c, const l_rmatrix &m) throw(); 01854 INLINE l_rmatrix operator *(const l_real &c, const l_rmatrix_slice &ms) throw(); 01856 INLINE l_rmatrix operator *(const l_rmatrix &m,const l_real &c) throw(); 01858 INLINE l_rmatrix operator *(const l_rmatrix_slice &ms,const l_real &c) throw(); 01860 INLINE l_rmatrix &operator *=(l_rmatrix &m,const l_real &c) throw(); 01862 INLINE l_rmatrix operator /(const l_rmatrix &m,const l_real &c) throw(); 01864 INLINE l_rmatrix operator /(const l_rmatrix_slice &ms, const l_real &c) throw(); 01866 INLINE l_rmatrix &operator /=(l_rmatrix &m,const l_real &c) throw(); 01867 01868 //------------ real - l_rmatrix ----------------------------------------------- 01869 01871 INLINE l_rmatrix operator *(const real &c, const l_rmatrix &m) throw(); 01873 INLINE l_rmatrix operator *(const real &c, const l_rmatrix_slice &ms) throw(); 01875 INLINE l_rmatrix operator *(const l_rmatrix &m,const real &c) throw(); 01877 INLINE l_rmatrix operator *(const l_rmatrix_slice &ms,const real &c) throw(); 01879 INLINE l_rmatrix &operator *=(l_rmatrix &m,const real &c) throw(); 01881 INLINE l_rmatrix operator /(const l_rmatrix &m,const real &c) throw(); 01883 INLINE l_rmatrix operator /(const l_rmatrix_slice &ms, const real &c) throw(); 01885 INLINE l_rmatrix &operator /=(l_rmatrix &m,const real &c) throw(); 01886 //----------------- rmatrix - l_real ---------------- 01887 01889 INLINE l_rmatrix operator *(const l_real &c, const rmatrix &m) throw(); 01891 INLINE l_rmatrix operator *(const l_real &c, const rmatrix_slice &ms) throw(); 01893 INLINE l_rmatrix operator *(const rmatrix &m,const l_real &c) throw(); 01895 INLINE l_rmatrix operator *(const rmatrix_slice &ms,const l_real &c) throw(); 01897 INLINE l_rmatrix operator /(const rmatrix &m,const l_real &c) throw(); 01899 INLINE l_rmatrix operator /(const rmatrix_slice &ms, const l_real &c) throw(); 01900 01901 01902 //============================ Matrix / Vector =================================== 01903 01904 01906 INLINE l_rvector operator *(const l_rmatrix &m,const l_rvector &v) 01907 #if(CXSC_INDEX_CHECK) 01908 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01909 #else 01910 throw(); 01911 #endif 01912 01913 INLINE l_rvector operator *(const l_rmatrix_slice &ms,const l_rvector &v) 01914 #if(CXSC_INDEX_CHECK) 01915 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01916 #else 01917 throw(); 01918 #endif 01919 01920 INLINE l_rvector operator *(const l_rvector &v,const l_rmatrix &m) 01921 #if(CXSC_INDEX_CHECK) 01922 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01923 #else 01924 throw(); 01925 #endif 01926 01927 INLINE l_rvector operator *(const l_rvector &v,const l_rmatrix_slice &ms) 01928 #if(CXSC_INDEX_CHECK) 01929 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01930 #else 01931 throw(); 01932 #endif 01933 01934 INLINE l_rvector &operator *=(l_rvector &v,const l_rmatrix &m) 01935 #if(CXSC_INDEX_CHECK) 01936 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01937 #else 01938 throw(); 01939 #endif 01940 01941 INLINE l_rvector &operator *=(l_rvector &v,const l_rmatrix_slice &ms) 01942 #if(CXSC_INDEX_CHECK) 01943 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01944 #else 01945 throw(); 01946 #endif 01947 01949 INLINE l_rvector operator *(const l_rvector_slice &v,const l_rmatrix &m) 01950 #if(CXSC_INDEX_CHECK) 01951 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01952 #else 01953 throw(); 01954 #endif 01955 01956 INLINE l_rvector operator *(const l_rvector_slice &v,const l_rmatrix_slice &m) 01957 #if(CXSC_INDEX_CHECK) 01958 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01959 #else 01960 throw(); 01961 #endif 01962 01963 //----------------- real ------------------------------------- 01964 01966 INLINE l_rvector operator *(const rvector &v,const l_rmatrix &m) 01967 #if(CXSC_INDEX_CHECK) 01968 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01969 #else 01970 throw(); 01971 #endif 01972 01973 INLINE l_rvector operator *(const rvector &v,const l_rmatrix_slice &ms) 01974 #if(CXSC_INDEX_CHECK) 01975 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01976 #else 01977 throw(); 01978 #endif 01979 01980 INLINE l_rvector operator *(const rvector_slice &v,const l_rmatrix &m) 01981 #if(CXSC_INDEX_CHECK) 01982 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01983 #else 01984 throw(); 01985 #endif 01986 01988 INLINE l_rvector operator *(const l_rmatrix &m,const rvector &v) 01989 #if(CXSC_INDEX_CHECK) 01990 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01991 #else 01992 throw(); 01993 #endif 01994 01995 INLINE l_rvector operator *(const l_rmatrix_slice &ms,const rvector &v) 01996 #if(CXSC_INDEX_CHECK) 01997 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 01998 #else 01999 throw(); 02000 #endif 02001 02002 02003 //================ Matrix / Matrix ============================ 02004 02006 INLINE const l_rmatrix &operator +(const l_rmatrix &m1) throw(); 02008 INLINE l_rmatrix operator +(const l_rmatrix_slice &ms) throw(); 02010 INLINE l_rmatrix operator +(const l_rmatrix &m1,const l_rmatrix &m2) 02011 #if(CXSC_INDEX_CHECK) 02012 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02013 #else 02014 throw(); 02015 #endif 02016 02017 INLINE l_rmatrix operator +(const l_rmatrix &m,const l_rmatrix_slice &ms) 02018 #if(CXSC_INDEX_CHECK) 02019 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02020 #else 02021 throw(); 02022 #endif 02023 02024 INLINE l_rmatrix operator +(const l_rmatrix_slice &ms,const l_rmatrix &m) 02025 #if(CXSC_INDEX_CHECK) 02026 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02027 #else 02028 throw(); 02029 #endif 02030 02031 INLINE l_rmatrix operator +(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2) 02032 #if(CXSC_INDEX_CHECK) 02033 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02034 #else 02035 throw(); 02036 #endif 02037 02038 INLINE l_rmatrix &operator +=(l_rmatrix &m1,const l_rmatrix &m2) 02039 #if(CXSC_INDEX_CHECK) 02040 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02041 #else 02042 throw(); 02043 #endif 02044 02045 INLINE l_rmatrix &operator +=(l_rmatrix &m1,const l_rmatrix_slice &ms) 02046 #if(CXSC_INDEX_CHECK) 02047 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02048 #else 02049 throw(); 02050 #endif 02051 02053 INLINE l_rmatrix operator -(const l_rmatrix &m) throw(); 02055 INLINE l_rmatrix operator -(const l_rmatrix_slice &ms) throw(); 02057 INLINE l_rmatrix operator -(const l_rmatrix &m1,const l_rmatrix &m2) 02058 #if(CXSC_INDEX_CHECK) 02059 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02060 #else 02061 throw(); 02062 #endif 02063 02064 INLINE l_rmatrix operator -(const l_rmatrix &m,const l_rmatrix_slice &ms) 02065 #if(CXSC_INDEX_CHECK) 02066 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02067 #else 02068 throw(); 02069 #endif 02070 02071 INLINE l_rmatrix operator -(const l_rmatrix_slice &ms,const l_rmatrix &m) 02072 #if(CXSC_INDEX_CHECK) 02073 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02074 #else 02075 throw(); 02076 #endif 02077 02078 INLINE l_rmatrix operator -(const l_rmatrix_slice &ms1,const l_rmatrix_slice &ms2) 02079 #if(CXSC_INDEX_CHECK) 02080 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02081 #else 02082 throw(); 02083 #endif 02084 02085 INLINE l_rmatrix &operator -=(l_rmatrix &m1,const l_rmatrix &m2) 02086 #if(CXSC_INDEX_CHECK) 02087 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02088 #else 02089 throw(); 02090 #endif 02091 02092 INLINE l_rmatrix &operator -=(l_rmatrix &m1,const l_rmatrix_slice &ms) 02093 #if(CXSC_INDEX_CHECK) 02094 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02095 #else 02096 throw(); 02097 #endif 02098 02100 INLINE l_rmatrix operator *(const l_rmatrix &m1, const l_rmatrix &m2) 02101 #if(CXSC_INDEX_CHECK) 02102 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02103 #else 02104 throw(); 02105 #endif 02106 02107 INLINE l_rmatrix operator *(const l_rmatrix &m1, const l_rmatrix_slice &ms) 02108 #if(CXSC_INDEX_CHECK) 02109 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02110 #else 02111 throw(); 02112 #endif 02113 02114 INLINE l_rmatrix operator *(const l_rmatrix_slice &ms, const l_rmatrix &m1) 02115 #if(CXSC_INDEX_CHECK) 02116 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02117 #else 02118 throw(); 02119 #endif 02120 02121 INLINE l_rmatrix operator *(const l_rmatrix_slice &ms1, const l_rmatrix_slice &ms2) 02122 #if(CXSC_INDEX_CHECK) 02123 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02124 #else 02125 throw(); 02126 #endif 02127 02128 INLINE l_rmatrix &operator *=(l_rmatrix &m1,const l_rmatrix &m2) 02129 #if(CXSC_INDEX_CHECK) 02130 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02131 #else 02132 throw(); 02133 #endif 02134 02135 INLINE l_rmatrix &operator *=(l_rmatrix &m1,const l_rmatrix_slice &ms) 02136 #if(CXSC_INDEX_CHECK) 02137 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02138 #else 02139 throw(); 02140 #endif 02141 02142 02143 //---------- rmatrix-l_rmatrix ------------------ 02145 INLINE l_rmatrix operator +(const rmatrix &m1,const l_rmatrix &m2) 02146 #if(CXSC_INDEX_CHECK) 02147 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02148 #else 02149 throw(); 02150 #endif 02151 02152 INLINE l_rmatrix operator +(const l_rmatrix &m1,const rmatrix &m2) 02153 #if(CXSC_INDEX_CHECK) 02154 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02155 #else 02156 throw(); 02157 #endif 02158 02159 INLINE l_rmatrix operator +(const rmatrix &m,const l_rmatrix_slice &ms) 02160 #if(CXSC_INDEX_CHECK) 02161 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02162 #else 02163 throw(); 02164 #endif 02165 02166 INLINE l_rmatrix operator +(const l_rmatrix &m,const rmatrix_slice &ms) 02167 #if(CXSC_INDEX_CHECK) 02168 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02169 #else 02170 throw(); 02171 #endif 02172 02173 INLINE l_rmatrix operator +(const rmatrix_slice &ms,const l_rmatrix &m) 02174 #if(CXSC_INDEX_CHECK) 02175 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02176 #else 02177 throw(); 02178 #endif 02179 02180 INLINE l_rmatrix operator +(const l_rmatrix_slice &ms,const rmatrix &m) 02181 #if(CXSC_INDEX_CHECK) 02182 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02183 #else 02184 throw(); 02185 #endif 02186 02187 INLINE l_rmatrix operator +(const rmatrix_slice &m1,const l_rmatrix_slice &m2) 02188 #if(CXSC_INDEX_CHECK) 02189 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02190 #else 02191 throw(); 02192 #endif 02193 02194 INLINE l_rmatrix operator +(const l_rmatrix_slice &m1,const rmatrix_slice &m2) 02195 #if(CXSC_INDEX_CHECK) 02196 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02197 #else 02198 throw(); 02199 #endif 02200 02201 INLINE l_rmatrix &operator +=(l_rmatrix &m1,const rmatrix &m2) 02202 #if(CXSC_INDEX_CHECK) 02203 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02204 #else 02205 throw(); 02206 #endif 02207 02208 INLINE l_rmatrix &operator +=(l_rmatrix &m1,const rmatrix_slice &ms) 02209 #if(CXSC_INDEX_CHECK) 02210 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02211 #else 02212 throw(); 02213 #endif 02214 02216 INLINE l_rmatrix operator -(const rmatrix &m1,const l_rmatrix &m2) 02217 #if(CXSC_INDEX_CHECK) 02218 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02219 #else 02220 throw(); 02221 #endif 02222 02223 INLINE l_rmatrix operator -(const l_rmatrix &m1,const rmatrix &m2) 02224 #if(CXSC_INDEX_CHECK) 02225 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02226 #else 02227 throw(); 02228 #endif 02229 02230 INLINE l_rmatrix operator -(const rmatrix &m,const l_rmatrix_slice &ms) 02231 #if(CXSC_INDEX_CHECK) 02232 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02233 #else 02234 throw(); 02235 #endif 02236 02237 INLINE l_rmatrix operator -(const l_rmatrix &m,const rmatrix_slice &ms) 02238 #if(CXSC_INDEX_CHECK) 02239 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02240 #else 02241 throw(); 02242 #endif 02243 02244 INLINE l_rmatrix operator -(const rmatrix_slice &ms,const l_rmatrix &m) 02245 #if(CXSC_INDEX_CHECK) 02246 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02247 #else 02248 throw(); 02249 #endif 02250 02251 INLINE l_rmatrix operator -(const l_rmatrix_slice &ms,const rmatrix &m) 02252 #if(CXSC_INDEX_CHECK) 02253 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02254 #else 02255 throw(); 02256 #endif 02257 02258 INLINE l_rmatrix operator -(const rmatrix_slice &ms1,const l_rmatrix_slice &ms2) 02259 #if(CXSC_INDEX_CHECK) 02260 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02261 #else 02262 throw(); 02263 #endif 02264 02265 INLINE l_rmatrix operator -(const l_rmatrix_slice &ms1,const rmatrix_slice &ms2) 02266 #if(CXSC_INDEX_CHECK) 02267 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02268 #else 02269 throw(); 02270 #endif 02271 02272 INLINE l_rmatrix &operator -=(l_rmatrix &m1,const rmatrix &m2) 02273 #if(CXSC_INDEX_CHECK) 02274 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02275 #else 02276 throw(); 02277 #endif 02278 02279 INLINE l_rmatrix &operator -=(l_rmatrix &m1,const rmatrix_slice &ms) 02280 #if(CXSC_INDEX_CHECK) 02281 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02282 #else 02283 throw(); 02284 #endif 02285 02287 INLINE l_rmatrix operator *(const rmatrix &m1, const l_rmatrix &m2) 02288 #if(CXSC_INDEX_CHECK) 02289 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02290 #else 02291 throw(); 02292 #endif 02293 02294 INLINE l_rmatrix operator *(const l_rmatrix &m1, const rmatrix &m2) 02295 #if(CXSC_INDEX_CHECK) 02296 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02297 #else 02298 throw(); 02299 #endif 02300 02301 INLINE l_rmatrix operator *(const rmatrix &m1, const l_rmatrix_slice &ms) 02302 #if(CXSC_INDEX_CHECK) 02303 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02304 #else 02305 throw(); 02306 #endif 02307 02308 INLINE l_rmatrix operator *(const l_rmatrix &m1, const rmatrix_slice &ms) 02309 #if(CXSC_INDEX_CHECK) 02310 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02311 #else 02312 throw(); 02313 #endif 02314 02315 INLINE l_rmatrix operator *(const rmatrix_slice &ms, const l_rmatrix &m1) 02316 #if(CXSC_INDEX_CHECK) 02317 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02318 #else 02319 throw(); 02320 #endif 02321 02322 INLINE l_rmatrix operator *(const l_rmatrix_slice &ms, const rmatrix &m1) 02323 #if(CXSC_INDEX_CHECK) 02324 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02325 #else 02326 throw(); 02327 #endif 02328 02329 INLINE l_rmatrix operator *(const rmatrix_slice &ms1, const l_rmatrix_slice &ms2) 02330 #if(CXSC_INDEX_CHECK) 02331 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02332 #else 02333 throw(); 02334 #endif 02335 02336 INLINE l_rmatrix operator *(const l_rmatrix_slice &ms1, const rmatrix_slice &ms2) 02337 #if(CXSC_INDEX_CHECK) 02338 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02339 #else 02340 throw(); 02341 #endif 02342 02343 INLINE l_rmatrix &operator *=(l_rmatrix &m1,const rmatrix &m2) 02344 #if(CXSC_INDEX_CHECK) 02345 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02346 #else 02347 throw(); 02348 #endif 02349 02350 INLINE l_rmatrix &operator *=(l_rmatrix &m1,const rmatrix_slice &ms) 02351 #if(CXSC_INDEX_CHECK) 02352 throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM); 02353 #else 02354 throw(); 02355 #endif 02356 02357 02358 //============== Compare Operator ========================== 02359 02360 //-------------- Matrix - Matrix ------------------------- 02361 02363 INLINE bool operator ==(const l_rmatrix &m1,const l_rmatrix &m2) throw(); 02365 INLINE bool operator !=(const l_rmatrix &m1,const l_rmatrix &m2) throw(); 02367 INLINE bool operator <(const l_rmatrix &m1,const l_rmatrix &m2) throw(); 02369 INLINE bool operator <=(const l_rmatrix &m1,const l_rmatrix &m2) throw(); 02371 INLINE bool operator >(const l_rmatrix &m1,const l_rmatrix &m2) throw(); 02373 INLINE bool operator >=(const l_rmatrix &m1,const l_rmatrix &m2) throw(); 02375 INLINE bool operator ==(const l_rmatrix &m1,const l_rmatrix_slice &ms) throw(); 02377 INLINE bool operator !=(const l_rmatrix &m1,const l_rmatrix_slice &ms) throw(); 02379 INLINE bool operator <(const l_rmatrix &m1,const l_rmatrix_slice &ms) throw(); 02381 INLINE bool operator <=(const l_rmatrix &m1,const l_rmatrix_slice &ms) throw(); 02383 INLINE bool operator >(const l_rmatrix &m1,const l_rmatrix_slice &ms) throw(); 02385 INLINE bool operator >=(const l_rmatrix &m1,const l_rmatrix_slice &ms) throw(); 02386 02387 //---------------- Matrix - Matrix_slice ---------------------- 02388 02390 INLINE bool operator ==(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2) throw(); 02392 INLINE bool operator !=(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2) throw(); 02394 INLINE bool operator <(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2) throw(); 02396 INLINE bool operator <=(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2) throw(); 02398 INLINE bool operator >(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2) throw(); 02400 INLINE bool operator >=(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2) throw(); 02401 02402 //=================== Not Operator ============================= 02403 02405 INLINE bool operator !(const l_rmatrix &ms) throw(); 02407 INLINE bool operator !(const l_rmatrix_slice &ms) throw(); 02408 02409 //======================== Input / Output ======================== 02410 02412 INLINE std::ostream &operator <<(std::ostream &s,const l_rmatrix &r) throw(); 02414 INLINE std::ostream &operator <<(std::ostream &s,const l_rmatrix_slice &r) throw(); 02416 INLINE std::istream &operator >>(std::istream &s,l_rmatrix &r) throw(); 02418 INLINE std::istream &operator >>(std::istream &s,l_rmatrix_slice &r) throw(); 02419 02421 INLINE int RowLen ( const l_rmatrix& ); 02423 INLINE int ColLen ( const l_rmatrix& ); 02425 INLINE int RowLen ( const l_rmatrix_slice& ); 02427 INLINE int ColLen ( const l_rmatrix_slice& ); 02429 l_rmatrix Id ( const l_rmatrix& ); 02431 l_rmatrix transp ( const l_rmatrix& ); 02433 void DoubleSize ( l_rmatrix& ); 02434 02435 } // namespace cxsc 02436 02437 #ifdef _CXSC_INCL_INL 02438 #include "matrix.inl" 02439 #include "l_rmatrix.inl" 02440 #endif 02441 02442 #ifdef _CXSC_LIVECTOR_HPP_INCLUDED 02443 # ifdef _CXSC_INCL_INL 02444 # include "liveclrmat.inl" 02445 # else 02446 # include "liveclrmat.hpp" 02447 # endif 02448 #endif 02449 02450 #ifdef _CXSC_IVECTOR_HPP_INCLUDED 02451 # ifdef _CXSC_INCL_INL 02452 # include "iveclrmat.inl" 02453 # else 02454 # include "iveclrmat.hpp" 02455 # endif 02456 #endif 02457 02458 #ifdef _CXSC_IMATRIX_HPP_INCLUDED 02459 # ifdef _CXSC_INCL_INL 02460 # include "lrmatimat.inl" 02461 # else 02462 # include "lrmatimat.hpp" 02463 # endif 02464 #endif 02465 02466 02467 #endif 02468