- 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: rmatrix.hpp,v 1.46 2014/01/30 17:23:48 cxsc Exp $ */ 00025 00026 #ifndef _CXSC_RMATRIX_HPP_INCLUDED 00027 #define _CXSC_RMATRIX_HPP_INCLUDED 00028 00029 #include "xscclass.hpp" 00030 00031 #include "dot.hpp" 00032 #include "idot.hpp" 00033 #include "cidot.hpp" 00034 #include "rvector.hpp" 00035 #include "except.hpp" 00036 #include "matrix.hpp" 00037 00038 namespace cxsc { 00039 00040 class rmatrix; 00041 class rmatrix_slice; 00042 class srmatrix; 00043 class srmatrix_slice; 00044 class srmatrix_subv; 00045 class srvector; 00046 class srvector_slice; 00047 00048 00050 00053 class rmatrix_subv 00054 { 00055 friend class rvector; 00056 friend class ivector; // wegen ivector::ivector(const rmatrix_subv &) 00057 friend class cvector; 00058 friend class civector; 00059 friend class l_rvector; 00060 friend class l_ivector; 00061 friend class rmatrix; 00062 friend class rmatrix_slice; 00063 private: 00064 real *dat; 00065 int lb,ub; 00066 int size,start,offset; // start=first element index 0..n-1 00067 00068 public: 00070 friend INLINE rmatrix_subv Row(rmatrix &m,const int &i) 00071 #if(CXSC_INDEX_CHECK) 00072 throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT); 00073 #else 00074 throw(); 00075 #endif 00076 00077 friend INLINE rmatrix_subv Col(rmatrix &m,const int &i) 00078 #if(CXSC_INDEX_CHECK) 00079 throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT); 00080 #else 00081 throw(); 00082 #endif 00083 00084 friend INLINE rmatrix_subv Row(const rmatrix &m,const int &i) 00085 #if(CXSC_INDEX_CHECK) 00086 throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT); 00087 #else 00088 throw(); 00089 #endif 00090 00091 friend INLINE rmatrix_subv Col(const rmatrix &m,const int &i) 00092 #if(CXSC_INDEX_CHECK) 00093 throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT); 00094 #else 00095 throw(); 00096 #endif 00097 00098 //#if(CXSC_INDEX_CHECK) 00099 00100 00101 #ifdef _CXSC_FRIEND_TPL 00102 //----------------- Templates --------------------------------------- 00103 template <class MV1,class MV2> friend MV1 &_mvmvassign(MV1 &v,const MV2 &rv) 00104 #if(CXSC_INDEX_CHECK) 00105 throw(ERROR__OP_WITH_WRONG_DIM<MV1>); 00106 #else 00107 throw(); 00108 #endif 00109 template <class MV,class S> friend MV &_mvsassign(MV &v,const S &r) throw(); 00110 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv) 00111 #if(CXSC_INDEX_CHECK) 00112 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00113 #else 00114 throw(); 00115 #endif 00116 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) throw(); 00117 template <class MV,class V> friend V _mvabs(const MV &mv) throw(); 00118 template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2) 00119 #if(CXSC_INDEX_CHECK) 00120 throw(OP_WITH_WRONG_DIM); 00121 #else 00122 throw(); 00123 #endif 00124 00125 template <class DP,class MV1,class MV2> friend void _mvmvaccu(DP &dp, const MV1 & rv1, const MV2 &rv2) 00126 #if(CXSC_INDEX_CHECK) 00127 throw(OP_WITH_WRONG_DIM); 00128 #else 00129 throw(); 00130 #endif 00131 00132 template <class MV1,class MV2,class S> friend S _mvmvmult(const MV1 & rv1, const MV2 &rv2) 00133 #if(CXSC_INDEX_CHECK) 00134 throw(ERROR__OP_WITH_WRONG_DIM<MV1>); 00135 #else 00136 throw(); 00137 #endif 00138 template <class V,class MV,class S> friend S _vmvmult(const V &rv1, const MV &rv2) 00139 #if(CXSC_INDEX_CHECK) 00140 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00141 #else 00142 throw(); 00143 #endif 00144 template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) throw(); 00145 template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2) 00146 #if(CXSC_INDEX_CHECK) 00147 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00148 #else 00149 throw(); 00150 #endif 00151 template <class MV1,class MV2,class E> friend E _mvmvminus(const MV1 &rv1, const MV2 &rv2) 00152 #if(CXSC_INDEX_CHECK) 00153 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00154 #else 00155 throw(); 00156 #endif 00157 template <class MV,class V,class E> friend E _mvvplus(const MV &rv1, const V &rv2) 00158 #if(CXSC_INDEX_CHECK) 00159 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00160 #else 00161 throw(); 00162 #endif 00163 template <class MV,class V,class E> friend E _mvvminus(const MV &rv1, const V &rv2) 00164 #if(CXSC_INDEX_CHECK) 00165 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00166 #else 00167 throw(); 00168 #endif 00169 template <class V,class MV,class E> friend E _vmvminus(const V &rv1, const MV &rv2) 00170 #if(CXSC_INDEX_CHECK) 00171 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00172 #else 00173 throw(); 00174 #endif 00175 template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) throw(); 00176 template <class MV,class S> friend MV &_mvsmultassign(MV &v,const S &r) throw(); 00177 template <class MV, class S> friend MV &_mvsplusassign(MV &v,const S &r) throw(); 00178 template <class MV,class S> friend MV &_mvsminusassign(MV &v,const S &r) throw(); 00179 template <class MV,class S> friend MV &_mvsdivassign(MV &v,const S &r) throw(); 00180 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv) 00181 #if(CXSC_INDEX_CHECK) 00182 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00183 #else 00184 throw(); 00185 #endif 00186 template <class V,class MV> friend V &_vmvplusassign(V &rv,const MV &v) 00187 #if(CXSC_INDEX_CHECK) 00188 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00189 #else 00190 throw(); 00191 #endif 00192 template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv) 00193 #if(CXSC_INDEX_CHECK) 00194 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00195 #else 00196 throw(); 00197 #endif 00198 template <class V,class MV> friend V &_vmvminusassign(V &rv,const MV &v) 00199 #if(CXSC_INDEX_CHECK) 00200 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00201 #else 00202 throw(); 00203 #endif 00204 template <class MV1,class MV2,class E> friend E _mvmvconv(const MV1 &rv1, const MV2 &rv2) 00205 #if(CXSC_INDEX_CHECK) 00206 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00207 #else 00208 throw(); 00209 #endif 00210 template <class MV,class V,class E> friend E _mvvconv(const MV &rv1, const V &rv2) 00211 #if(CXSC_INDEX_CHECK) 00212 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00213 #else 00214 throw(); 00215 #endif 00216 00217 // interval 00218 00219 00220 template <class V,class MV> friend V &_vmvsetinf(V &rv,const MV &v) 00221 #if(CXSC_INDEX_CHECK) 00222 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00223 #else 00224 throw(); 00225 #endif 00226 template <class V,class MV> friend V &_vmvsetsup(V &rv,const MV &v) 00227 #if(CXSC_INDEX_CHECK) 00228 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00229 #else 00230 throw(); 00231 #endif 00232 template <class V,class MV> friend V &_vmvusetinf(V &rv,const MV &v) 00233 #if(CXSC_INDEX_CHECK) 00234 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00235 #else 00236 throw(); 00237 #endif 00238 template <class V,class MV> friend V &_vmvusetsup(V &rv,const MV &v) 00239 #if(CXSC_INDEX_CHECK) 00240 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00241 #else 00242 throw(); 00243 #endif 00244 00245 // complex 00246 00247 00248 template <class V,class MV> friend V &_vmvsetim(V &rv,const MV &v) 00249 #if(CXSC_INDEX_CHECK) 00250 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00251 #else 00252 throw(); 00253 #endif 00254 template <class V,class MV> friend V &_vmvsetre(V &rv,const MV &v) 00255 #if(CXSC_INDEX_CHECK) 00256 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00257 #else 00258 throw(); 00259 #endif 00260 00261 #endif 00262 00263 //----------------- Konstruktoren ---------------------------------- 00264 00266 explicit INLINE rmatrix_subv (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) { } 00267 public: 00269 INLINE rmatrix_subv(const rmatrix_subv &v) throw():dat(v.dat),lb(v.lb),ub(v.ub),size(v.size),start(v.start),offset(v.offset) { } 00270 public: 00271 00272 //---------------------- Standardfunktionen ------------------------ 00273 00274 friend INLINE rvector::rvector(const rmatrix_subv &) throw(); 00276 INLINE rmatrix_subv &operator =(const rmatrix_subv &rv) throw(); 00278 INLINE rmatrix_subv &operator =(const real &r) throw(); 00280 INLINE rmatrix_subv &operator =(const srmatrix_subv &m); 00282 INLINE rmatrix_subv &operator =(const srvector &m); 00284 INLINE rmatrix_subv &operator =(const srvector_slice &m); 00286 INLINE rmatrix_subv &operator =(const rmatrix &m) 00287 #if(CXSC_INDEX_CHECK) 00288 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 00289 #else 00290 throw(); 00291 #endif 00292 00293 INLINE rmatrix_subv &operator =(const rmatrix_slice &m) 00294 #if(CXSC_INDEX_CHECK) 00295 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 00296 #else 00297 throw(); 00298 #endif 00299 00300 INLINE rmatrix_subv &operator =(const rvector &v) 00301 #if(CXSC_INDEX_CHECK) 00302 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM); 00303 #else 00304 throw(); 00305 #endif 00306 00307 INLINE rmatrix_subv &operator =(const rvector_slice &v) 00308 #if(CXSC_INDEX_CHECK) 00309 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM); 00310 #else 00311 throw(); 00312 #endif 00313 00314 friend INLINE int Lb(const rmatrix_subv &rv) throw() { return rv.lb; } 00316 friend INLINE int Ub(const rmatrix_subv &rv) throw() { return rv.ub; } 00318 friend INLINE int VecLen(const rmatrix_subv &rv) throw() { return rv.size; } 00319 00321 INLINE real &operator [](const int &i) const 00322 #if(CXSC_INDEX_CHECK) 00323 throw(ERROR_RVECTOR_ELEMENT_NOT_IN_VEC); 00324 #else 00325 throw(); 00326 #endif 00327 00329 INLINE real &operator [](const int &i) 00330 #if(CXSC_INDEX_CHECK) 00331 throw(ERROR_RVECTOR_ELEMENT_NOT_IN_VEC); 00332 #else 00333 throw(); 00334 #endif 00335 00337 INLINE rmatrix_subv &operator ()() throw() { return *this; } 00339 INLINE rmatrix_subv operator ()(const int &i) 00340 #if(CXSC_INDEX_CHECK) 00341 throw(ERROR_RVECTOR_SUB_ARRAY_TOO_BIG); 00342 #else 00343 throw(); 00344 #endif 00345 00346 INLINE rmatrix_subv operator ()(const int &i1,const int &i2) 00347 #if(CXSC_INDEX_CHECK) 00348 throw(ERROR_RVECTOR_SUB_ARRAY_TOO_BIG); 00349 #else 00350 throw(); 00351 #endif 00352 00354 INLINE rmatrix_subv &operator *=(const real &c) throw(); 00356 INLINE rmatrix_subv &operator +=(const real &c) throw(); 00358 INLINE rmatrix_subv &operator -=(const real &c) throw(); 00360 INLINE rmatrix_subv &operator /=(const real &c) throw(); 00361 00363 INLINE rmatrix_subv &operator +=(const srvector &rv); 00365 INLINE rmatrix_subv &operator +=(const srvector_slice &rv); 00367 INLINE rmatrix_subv &operator +=(const srmatrix_subv &rv); 00368 00370 INLINE rmatrix_subv &operator -=(const srvector &rv); 00372 INLINE rmatrix_subv &operator -=(const srvector_slice &rv); 00374 INLINE rmatrix_subv &operator -=(const srmatrix_subv &rv); 00375 00377 INLINE rmatrix_subv &operator -=(const rvector &rv) 00378 #if(CXSC_INDEX_CHECK) 00379 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM); 00380 #else 00381 throw(); 00382 #endif 00383 00384 INLINE rmatrix_subv &operator -=(const rvector_slice &rv) 00385 #if(CXSC_INDEX_CHECK) 00386 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM); 00387 #else 00388 throw(); 00389 #endif 00390 00391 INLINE rmatrix_subv &operator +=(const rvector &rv) 00392 #if(CXSC_INDEX_CHECK) 00393 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM); 00394 #else 00395 throw(); 00396 #endif 00397 00398 INLINE rmatrix_subv &operator +=(const rvector_slice &rv) 00399 #if(CXSC_INDEX_CHECK) 00400 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM); 00401 #else 00402 throw(); 00403 #endif 00404 //#else 00405 //#endif 00406 00407 }; 00408 00409 00411 INLINE rmatrix_subv Row(rmatrix &m,const int &i) 00412 #if(CXSC_INDEX_CHECK) 00413 throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT); 00414 #else 00415 throw(); 00416 #endif 00417 00419 INLINE rmatrix_subv Col(rmatrix &m,const int &i) 00420 #if(CXSC_INDEX_CHECK) 00421 throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT); 00422 #else 00423 throw(); 00424 #endif 00425 00427 INLINE rmatrix_subv Row(const rmatrix &m,const int &i) 00428 #if(CXSC_INDEX_CHECK) 00429 throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT); 00430 #else 00431 throw(); 00432 #endif 00433 00435 INLINE rmatrix_subv Col(const rmatrix &m,const int &i) 00436 #if(CXSC_INDEX_CHECK) 00437 throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT); 00438 #else 00439 throw(); 00440 #endif 00441 00442 00443 //----------------------- Matrix ----------------------------------------------- 00444 00445 class rmatrix_slice; 00446 00448 00470 class rmatrix 00471 { 00472 friend class rmatrix_slice; 00473 friend class rmatrix_subv; 00474 friend class imatrix; 00475 friend class cmatrix; 00476 friend class cimatrix; 00477 friend class l_rmatrix; 00478 friend class l_imatrix; 00479 private: 00480 real *dat; 00481 int lb1,ub1,lb2,ub2,xsize,ysize; 00482 00483 public: 00484 double* to_blas_array() const { return (double*)dat; } 00485 //#if(CXSC_INDEX_CHECK) 00486 #ifdef _CXSC_FRIEND_TPL 00487 //----------------- Templates --------------------------------------- 00488 template <class S,class M> friend void _smconstr(S &s,const M &m) 00489 #if(CXSC_INDEX_CHECK) 00490 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>,ERROR__USE_OF_UNINITIALIZED_OBJ<M>); 00491 #else 00492 throw(); 00493 #endif 00494 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m) 00495 #if(CXSC_INDEX_CHECK) 00496 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>); 00497 #else 00498 throw(); 00499 #endif 00500 template <class M1,class M2,class S> friend M1 &_mmassign(M1 &m1,const M2 &m,S ms) throw(); 00501 template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) throw(); 00502 template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m) 00503 #if(CXSC_INDEX_CHECK) 00504 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00505 #else 00506 throw(); 00507 #endif 00508 template <class M,class S> friend M &_msassign(M &m,const S &r) throw(); 00509 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m) 00510 #if(CXSC_INDEX_CHECK) 00511 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>); 00512 #else 00513 throw(); 00514 #endif 00515 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) throw(); 00516 template <class M> friend int _mlb(const M &m, const int &i) 00517 #if(CXSC_INDEX_CHECK) 00518 throw(ERROR__WRONG_ROW_OR_COL<M>); 00519 #else 00520 throw(); 00521 #endif 00522 template <class M> friend int _mub(const M &m, const int &i) 00523 #if(CXSC_INDEX_CHECK) 00524 throw(ERROR__WRONG_ROW_OR_COL<M>); 00525 #else 00526 throw(); 00527 #endif 00528 template <class M> friend M &_msetlb(M &m, const int &i,const int &j) 00529 #if(CXSC_INDEX_CHECK) 00530 throw(ERROR__WRONG_ROW_OR_COL<M>); 00531 #else 00532 throw(); 00533 #endif 00534 template <class M> friend M &_msetub(M &m, const int &i,const int &j) 00535 #if(CXSC_INDEX_CHECK) 00536 throw(ERROR__WRONG_ROW_OR_COL<M>); 00537 #else 00538 throw(); 00539 #endif 00540 template <class M> friend void _mresize(M &A) throw(); 00541 template <class M,class S> friend void _mresize(M &A,const int &m, const int &n) 00542 #if(CXSC_INDEX_CHECK) 00543 throw(ERROR__WRONG_BOUNDARIES<M>); 00544 #else 00545 throw(); 00546 #endif 00547 template <class M,class S> friend void _mresize(M &A,const int &m1, const int &m2,const int &n1,const int &n2) 00548 #if(CXSC_INDEX_CHECK) 00549 throw(ERROR__WRONG_BOUNDARIES<M>); 00550 #else 00551 throw(); 00552 #endif 00553 template <class M,class E> friend E _mabs(const M &m) throw(); 00554 template <class MS,class E> friend E _msabs(const MS &ms) throw(); 00555 //------- matrix-matrix -------------- 00556 template <class M1,class M2,class E> friend E _mmplus(const M1 &m1,const M2 &m2) 00557 #if(CXSC_INDEX_CHECK) 00558 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00559 #else 00560 throw(); 00561 #endif 00562 template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms) 00563 #if(CXSC_INDEX_CHECK) 00564 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00565 #else 00566 throw(); 00567 #endif 00568 template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2) 00569 #if(CXSC_INDEX_CHECK) 00570 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00571 #else 00572 throw(); 00573 #endif 00574 template <class M> friend M _mminus(const M &m) throw(); 00575 template <class MS,class E> friend E _msminus(const MS &ms) throw(); 00576 template <class M1,class M2,class E> friend E _mmminus(const M1 &m1,const M2 &m2) 00577 #if(CXSC_INDEX_CHECK) 00578 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00579 #else 00580 throw(); 00581 #endif 00582 template <class M1,class M2> friend M1 &_mmplusassign(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> friend M &_mmsplusassign(M &m1,const MS &ms) 00589 #if(CXSC_INDEX_CHECK) 00590 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00591 #else 00592 throw(); 00593 #endif 00594 template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1) 00595 #if(CXSC_INDEX_CHECK) 00596 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00597 #else 00598 throw(); 00599 #endif 00600 template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms) 00601 #if(CXSC_INDEX_CHECK) 00602 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00603 #else 00604 throw(); 00605 #endif 00606 template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m) 00607 #if(CXSC_INDEX_CHECK) 00608 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00609 #else 00610 throw(); 00611 #endif 00612 template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2) 00613 #if(CXSC_INDEX_CHECK) 00614 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00615 #else 00616 throw(); 00617 #endif 00618 template <class M1,class M2> friend M1 &_mmminusassign(M1 &m1,const M2 &m2) 00619 #if(CXSC_INDEX_CHECK) 00620 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00621 #else 00622 throw(); 00623 #endif 00624 template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms) 00625 #if(CXSC_INDEX_CHECK) 00626 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00627 #else 00628 throw(); 00629 #endif 00630 template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1) 00631 #if(CXSC_INDEX_CHECK) 00632 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00633 #else 00634 throw(); 00635 #endif 00636 template <class M1,class M2,class E> friend E _mmmult(const M1 &m1, const M2 &m2) 00637 #if(CXSC_INDEX_CHECK) 00638 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00639 #else 00640 throw(); 00641 #endif 00642 template <class M1,class M2,class S> friend M1 &_mmmultassign(M1 &m1,const M2 &m2) 00643 #if(CXSC_INDEX_CHECK) 00644 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00645 #else 00646 throw(); 00647 #endif 00648 template <class M,class MS,class E> friend E _mmsmult(const M &m1, const MS &ms) 00649 #if(CXSC_INDEX_CHECK) 00650 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00651 #else 00652 throw(); 00653 #endif 00654 template <class MS,class M,class E> friend E _msmmult(const MS &ms, const M &m2) 00655 #if(CXSC_INDEX_CHECK) 00656 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00657 #else 00658 throw(); 00659 #endif 00660 template <class M,class MS,class S> friend M &_mmsmultassign(M &m1,const MS &ms) 00661 #if(CXSC_INDEX_CHECK) 00662 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00663 #else 00664 throw(); 00665 #endif 00666 template <class MS1,class MS2,class E> friend E _msmsmult(const MS1 &ms1, const MS2 &ms2) 00667 #if(CXSC_INDEX_CHECK) 00668 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00669 #else 00670 throw(); 00671 #endif 00672 template <class M1,class M2,class E> friend E _mmconv(const M1 &m1,const M2 &m2) 00673 #if(CXSC_INDEX_CHECK) 00674 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00675 #else 00676 throw(); 00677 #endif 00678 template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms) 00679 #if(CXSC_INDEX_CHECK) 00680 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00681 #else 00682 throw(); 00683 #endif 00684 //-------- matrix-scalar --------------------- 00685 template <class S,class M,class E> friend E _smmult(const S &c, const M &m) throw(); 00686 template <class M,class S> friend M &_msmultassign(M &m,const S &c) throw(); 00687 template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) throw(); 00688 template <class M,class S,class E> friend E _msdiv(const M &m,const S &c) throw(); 00689 template <class M,class S> friend M &_msdivassign(M &m,const S &c) throw(); 00690 template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) throw(); 00691 //--------- matrix-vector -------------------- 00692 template <class M,class V,class E> friend E _mvmult(const M &m,const V &v) 00693 #if(CXSC_INDEX_CHECK) 00694 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00695 #else 00696 throw(); 00697 #endif 00698 template <class V,class M,class E> friend E _vmmult(const V &v,const M &m) 00699 #if(CXSC_INDEX_CHECK) 00700 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00701 #else 00702 throw(); 00703 #endif 00704 template <class V,class M,class S> friend V &_vmmultassign(V &v,const M &m) 00705 #if(CXSC_INDEX_CHECK) 00706 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00707 #else 00708 throw(); 00709 #endif 00710 template <class VS,class M,class S> friend VS &_vsmmultassign(VS &v,const M &m) 00711 #if(CXSC_INDEX_CHECK) 00712 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00713 #else 00714 throw(); 00715 #endif 00716 00717 template <class M> friend void *_mvoid(const M &m) throw(); 00718 template <class M> friend bool _mnot(const M &m) throw(); 00719 template <class MS> friend void *_msvoid(const MS &ms) throw(); 00720 template <class MS> friend bool _msnot(const MS &ms) throw(); 00721 template <class M1,class M2> friend bool _mmeq(const M1 &m1,const M2 &m2) throw(); 00722 template <class M1,class M2> friend bool _mmneq(const M1 &m1,const M2 &m2) throw(); 00723 template <class M1,class M2> friend bool _mmless(const M1 &m1,const M2 &m2) throw(); 00724 template <class M1,class M2> friend bool _mmleq(const M1 &m1,const M2 &m2) throw(); 00725 template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) throw(); 00726 template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) throw(); 00727 template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) throw(); 00728 template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) throw(); 00729 template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) throw(); 00730 template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) throw(); 00731 template <class M> friend std::ostream &_mout(std::ostream &s,const M &r) throw(); 00732 template <class M> friend std::istream &_min(std::istream &s,M &r) throw(); 00733 00734 // Interval 00735 00736 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv) 00737 #if(CXSC_INDEX_CHECK) 00738 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00739 #else 00740 throw(); 00741 #endif 00742 00743 template <class M,class E> friend E _mdiam(const M &m) throw(); 00744 template <class M,class E> friend E _mmid(const M &m) throw(); 00745 template <class MS,class E> friend E _msdiam(const MS &ms) throw(); 00746 template <class MS,class E> friend E _msmid(const MS &ms) throw(); 00747 template <class M,class E> friend E _minf(const M &m) throw(); 00748 template <class M,class E> friend E _msup(const M &m) throw(); 00749 template <class M1,class M2> friend M1 &_mmsetinf(M1 &m1,const M2 &m2) 00750 #if(CXSC_INDEX_CHECK) 00751 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00752 #else 00753 throw(); 00754 #endif 00755 template <class M1,class M2> friend M1 &_mmsetsup(M1 &m1,const M2 &m2) 00756 #if(CXSC_INDEX_CHECK) 00757 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00758 #else 00759 throw(); 00760 #endif 00761 template <class M1,class M2> friend M1 &_mmusetinf(M1 &m1,const M2 &m2) 00762 #if(CXSC_INDEX_CHECK) 00763 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00764 #else 00765 throw(); 00766 #endif 00767 template <class M1,class M2> friend M1 &_mmusetsup(M1 &m1,const M2 &m2) 00768 #if(CXSC_INDEX_CHECK) 00769 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00770 #else 00771 throw(); 00772 #endif 00773 template <class MS,class E> friend E _msinf(const MS &ms) throw(); 00774 template <class MS,class E> friend E _mssup(const MS &ms) throw(); 00775 template <class MS1,class M2> friend MS1 &_msmsetinf(MS1 &ms1,const M2 &m2) 00776 #if(CXSC_INDEX_CHECK) 00777 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 00778 #else 00779 throw(); 00780 #endif 00781 template <class MS1,class M2> friend MS1 &_msmsetsup(MS1 &ms1,const M2 &m2) 00782 #if(CXSC_INDEX_CHECK) 00783 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 00784 #else 00785 throw(); 00786 #endif 00787 template <class MS1,class M2> friend MS1 &_msmusetinf(MS1 &ms1,const M2 &m2) 00788 #if(CXSC_INDEX_CHECK) 00789 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 00790 #else 00791 throw(); 00792 #endif 00793 template <class MS1,class M2> friend MS1 &_msmusetsup(MS1 &ms1,const M2 &m2) 00794 #if(CXSC_INDEX_CHECK) 00795 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 00796 #else 00797 throw(); 00798 #endif 00799 //--- Interval -------- matrix-matrix -------------- 00800 00801 template <class M1,class M2,class E> friend E _mmimult(const M1 &m1, const M2 &m2) 00802 #if(CXSC_INDEX_CHECK) 00803 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00804 #else 00805 throw(); 00806 #endif 00807 00808 template <class M1,class M2,class S> friend M1 &_mmimultassign(M1 &m1,const M2 &m2) 00809 #if(CXSC_INDEX_CHECK) 00810 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00811 #else 00812 throw(); 00813 #endif 00814 template <class M,class MS,class E> friend E _mmsimult(const M &m1, const MS &ms) 00815 #if(CXSC_INDEX_CHECK) 00816 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00817 #else 00818 throw(); 00819 #endif 00820 00821 template <class MS,class M,class E> friend E _msmimult(const MS &ms, const M &m2) 00822 #if(CXSC_INDEX_CHECK) 00823 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00824 #else 00825 throw(); 00826 #endif 00827 00828 template <class M,class MS,class S> friend M &_mmsimultassign(M &m1,const MS &ms) 00829 #if(CXSC_INDEX_CHECK) 00830 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00831 #else 00832 throw(); 00833 #endif 00834 template <class MS1,class MS2,class E> friend E _msmsimult(const MS1 &ms1, const MS2 &ms2) 00835 #if(CXSC_INDEX_CHECK) 00836 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00837 #else 00838 throw(); 00839 #endif 00840 00841 template <class M1,class M2> friend M1 &_mmconvassign(M1 &m1,const M2 &m2) 00842 #if(CXSC_INDEX_CHECK) 00843 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00844 #else 00845 throw(); 00846 #endif 00847 template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms) 00848 #if(CXSC_INDEX_CHECK) 00849 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00850 #else 00851 throw(); 00852 #endif 00853 template <class MS,class M> friend MS &_msmconvassign(MS &ms,const M &m1) 00854 #if(CXSC_INDEX_CHECK) 00855 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00856 #else 00857 throw(); 00858 #endif 00859 template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2) 00860 #if(CXSC_INDEX_CHECK) 00861 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00862 #else 00863 throw(); 00864 #endif 00865 template <class M1,class M2,class E> friend E _mmsect(const M1 &m1,const M2 &m2) 00866 #if(CXSC_INDEX_CHECK) 00867 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00868 #else 00869 throw(); 00870 #endif 00871 template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms) 00872 #if(CXSC_INDEX_CHECK) 00873 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00874 #else 00875 throw(); 00876 #endif 00877 00878 template <class M1,class M2> friend M1 &_mmsectassign(M1 &m1,const M2 &m2) 00879 #if(CXSC_INDEX_CHECK) 00880 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00881 #else 00882 throw(); 00883 #endif 00884 template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms) 00885 #if(CXSC_INDEX_CHECK) 00886 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00887 #else 00888 throw(); 00889 #endif 00890 template <class MS,class M> friend MS &_msmsectassign(MS &ms,const M &m1) 00891 #if(CXSC_INDEX_CHECK) 00892 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00893 #else 00894 throw(); 00895 #endif 00896 template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2) 00897 #if(CXSC_INDEX_CHECK) 00898 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00899 #else 00900 throw(); 00901 #endif 00902 //--- Interval -------- matrix-vector -------------- 00903 template <class M,class V,class E> friend E _mvimult(const M &m,const V &v) 00904 #if(CXSC_INDEX_CHECK) 00905 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00906 #else 00907 throw(); 00908 #endif 00909 template <class MS,class V,class E> friend E _msvimult(const MS &ms,const V &v) 00910 #if(CXSC_INDEX_CHECK) 00911 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00912 #else 00913 throw(); 00914 #endif 00915 template <class V,class MS,class E> friend E _vmsimult(const V &v,const MS &ms) 00916 #if(CXSC_INDEX_CHECK) 00917 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00918 #else 00919 throw(); 00920 #endif 00921 00922 00923 template <class V,class M,class E> friend E _vmimult(const V &v,const M &m) 00924 #if(CXSC_INDEX_CHECK) 00925 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00926 #else 00927 throw(); 00928 #endif 00929 template <class V,class M,class S> friend V &_vmimultassign(V &v,const M &m) 00930 #if(CXSC_INDEX_CHECK) 00931 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00932 #else 00933 throw(); 00934 #endif 00935 template <class VS,class M,class S> friend VS &_vsmimultassign(VS &v,const M &m) 00936 #if(CXSC_INDEX_CHECK) 00937 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00938 #else 00939 throw(); 00940 #endif 00941 00942 00943 // complex 00944 00945 template <class M,class E> friend E _mre(const M &m) throw(); 00946 template <class M,class E> friend E _mim(const M &m) throw(); 00947 template <class M1,class M2> friend M1 &_mmsetre(M1 &m1,const M2 &m2) 00948 #if(CXSC_INDEX_CHECK) 00949 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00950 #else 00951 throw(); 00952 #endif 00953 template <class M1,class M2> friend M1 &_mmsetim(M1 &m1,const M2 &m2) 00954 #if(CXSC_INDEX_CHECK) 00955 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00956 #else 00957 throw(); 00958 #endif 00959 template <class MS,class E> friend E _msre(const MS &ms) throw(); 00960 template <class MS,class E> friend E _msim(const MS &ms) throw(); 00961 template <class MS1,class M2> friend MS1 &_msmsetre(MS1 &ms1,const M2 &m2) 00962 #if(CXSC_INDEX_CHECK) 00963 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 00964 #else 00965 throw(); 00966 #endif 00967 template <class MS1,class M2> friend MS1 &_msmsetim(MS1 &ms1,const M2 &m2) 00968 #if(CXSC_INDEX_CHECK) 00969 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 00970 #else 00971 throw(); 00972 #endif 00973 //--- complex -------- matrix-matrix -------------- 00974 00975 template <class M1,class M2,class E> friend E _mmcmult(const M1 &m1, const M2 &m2) 00976 #if(CXSC_INDEX_CHECK) 00977 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00978 #else 00979 throw(); 00980 #endif 00981 00982 template <class M1,class M2,class S> friend M1 &_mmcmultassign(M1 &m1,const M2 &m2) 00983 #if(CXSC_INDEX_CHECK) 00984 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 00985 #else 00986 throw(); 00987 #endif 00988 template <class M,class MS,class E> friend E _mmscmult(const M &m1, const MS &ms) 00989 #if(CXSC_INDEX_CHECK) 00990 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00991 #else 00992 throw(); 00993 #endif 00994 00995 template <class MS,class M,class E> friend E _msmcmult(const MS &ms, const M &m2) 00996 #if(CXSC_INDEX_CHECK) 00997 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00998 #else 00999 throw(); 01000 #endif 01001 01002 template <class M,class MS,class S> friend M &_mmscmultassign(M &m1,const MS &ms) 01003 #if(CXSC_INDEX_CHECK) 01004 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01005 #else 01006 throw(); 01007 #endif 01008 template <class MS1,class MS2,class E> friend E _msmscmult(const MS1 &ms1, const MS2 &ms2) 01009 #if(CXSC_INDEX_CHECK) 01010 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01011 #else 01012 throw(); 01013 #endif 01014 01015 //--- complex -------- matrix-vector -------------- 01016 template <class M,class V,class E> friend E _mvcmult(const M &m,const V &v) 01017 #if(CXSC_INDEX_CHECK) 01018 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01019 #else 01020 throw(); 01021 #endif 01022 template <class MS,class V,class E> friend E _msvcmult(const MS &ms,const V &v) 01023 #if(CXSC_INDEX_CHECK) 01024 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01025 #else 01026 throw(); 01027 #endif 01028 template <class V,class MS,class E> friend E _vmscmult(const V &v,const MS &ms) 01029 #if(CXSC_INDEX_CHECK) 01030 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01031 #else 01032 throw(); 01033 #endif 01034 01035 template <class V,class M,class E> friend E _vmcmult(const V &v,const M &m) 01036 #if(CXSC_INDEX_CHECK) 01037 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01038 #else 01039 throw(); 01040 #endif 01041 template <class V,class M,class S> friend V &_vmcmultassign(V &v,const M &m) 01042 #if(CXSC_INDEX_CHECK) 01043 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01044 #else 01045 throw(); 01046 #endif 01047 template <class VS,class M,class S> friend VS &_vsmcmultassign(VS &v,const M &m) 01048 #if(CXSC_INDEX_CHECK) 01049 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01050 #else 01051 throw(); 01052 #endif 01053 01054 01055 // cinterval 01056 01058 friend INLINE rmatrix SupRe(const cimatrix &v) throw(); 01060 friend INLINE rmatrix SupIm(const cimatrix &v) throw(); 01062 friend INLINE rmatrix InfRe(const cimatrix &v) throw(); 01064 friend INLINE rmatrix InfIm(const cimatrix &v) throw(); 01066 friend INLINE rmatrix SupRe(const cimatrix_slice &v) throw(); 01068 friend INLINE rmatrix SupIm(const cimatrix_slice &v) throw(); 01070 friend INLINE rmatrix InfRe(const cimatrix_slice &v) throw(); 01072 friend INLINE rmatrix InfIm(const cimatrix_slice &v) throw(); 01073 01074 //--- cinterval -------- matrix-matrix -------------- 01075 01076 template <class M1,class M2,class E> friend E _mmcimult(const M1 &m1, const M2 &m2) 01077 #if(CXSC_INDEX_CHECK) 01078 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01079 #else 01080 throw(); 01081 #endif 01082 template <class M1,class M2,class S> friend M1 &_mmcimultassign(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 M,class MS,class E> friend E _mmscimult(const M &m1, const MS &ms) 01089 #if(CXSC_INDEX_CHECK) 01090 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01091 #else 01092 throw(); 01093 #endif 01094 template <class MS,class M,class E> friend E _msmcimult(const MS &ms, const M &m2) 01095 #if(CXSC_INDEX_CHECK) 01096 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01097 #else 01098 throw(); 01099 #endif 01100 template <class M,class MS,class S> friend M &_mmscimultassign(M &m1,const MS &ms) 01101 #if(CXSC_INDEX_CHECK) 01102 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01103 #else 01104 throw(); 01105 #endif 01106 template <class MS1,class MS2,class E> friend E _msmscimult(const MS1 &ms1, const MS2 &ms2) 01107 #if(CXSC_INDEX_CHECK) 01108 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01109 #else 01110 throw(); 01111 #endif 01112 01113 //--- cinterval -------- matrix-vector -------------- 01114 template <class M,class V,class E> friend E _mvcimult(const M &m,const V &v) 01115 #if(CXSC_INDEX_CHECK) 01116 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01117 #else 01118 throw(); 01119 #endif 01120 template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v) 01121 #if(CXSC_INDEX_CHECK) 01122 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01123 #else 01124 throw(); 01125 #endif 01126 template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms) 01127 #if(CXSC_INDEX_CHECK) 01128 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01129 #else 01130 throw(); 01131 #endif 01132 01133 template <class V,class M,class E> friend E _vmcimult(const V &v,const M &m) 01134 #if(CXSC_INDEX_CHECK) 01135 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01136 #else 01137 throw(); 01138 #endif 01139 template <class V,class M,class S> friend V &_vmcimultassign(V &v,const M &m) 01140 #if(CXSC_INDEX_CHECK) 01141 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01142 #else 01143 throw(); 01144 #endif 01145 template <class VS,class M,class S> friend VS &_vsmcimultassign(VS &v,const M &m) 01146 #if(CXSC_INDEX_CHECK) 01147 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01148 #else 01149 throw(); 01150 #endif 01151 01152 //--- l_real -------- matrix-matrix -------------- 01153 01154 template <class M1,class M2,class E> friend E _mmlmult(const M1 &m1, const M2 &m2) 01155 #if(CXSC_INDEX_CHECK) 01156 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01157 #else 01158 throw(); 01159 #endif 01160 template <class M1,class M2,class S> friend M1 &_mmlmultassign(M1 &m1,const M2 &m2) 01161 #if(CXSC_INDEX_CHECK) 01162 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 01163 #else 01164 throw(); 01165 #endif 01166 template <class M,class MS,class E> friend E _mmslmult(const M &m1, const MS &ms) 01167 #if(CXSC_INDEX_CHECK) 01168 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01169 #else 01170 throw(); 01171 #endif 01172 01173 template <class MS,class M,class E> friend E _msmlmult(const MS &ms, const M &m2) 01174 #if(CXSC_INDEX_CHECK) 01175 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01176 #else 01177 throw(); 01178 #endif 01179 01180 template <class M,class MS,class S> friend M &_mmslmultassign(M &m1,const MS &ms) 01181 #if(CXSC_INDEX_CHECK) 01182 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01183 #else 01184 throw(); 01185 #endif 01186 template <class MS1,class MS2,class E> friend E _msmslmult(const MS1 &ms1, const MS2 &ms2) 01187 #if(CXSC_INDEX_CHECK) 01188 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01189 #else 01190 throw(); 01191 #endif 01192 //--- l_real -------- matrix-vector -------------- 01193 template <class M,class V,class E> friend E _mvlmult(const M &m,const V &v) 01194 #if(CXSC_INDEX_CHECK) 01195 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01196 #else 01197 throw(); 01198 #endif 01199 template <class MS,class V,class E> friend E _msvlmult(const MS &ms,const V &v) 01200 #if(CXSC_INDEX_CHECK) 01201 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01202 #else 01203 throw(); 01204 #endif 01205 template <class V,class MS,class E> friend E _vmslmult(const V &v,const MS &ms) 01206 #if(CXSC_INDEX_CHECK) 01207 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01208 #else 01209 throw(); 01210 #endif 01211 01212 template <class V,class M,class E> friend E _vmlmult(const V &v,const M &m) 01213 #if(CXSC_INDEX_CHECK) 01214 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01215 #else 01216 throw(); 01217 #endif 01218 template <class V,class M,class S> friend V &_vmlmultassign(V &v,const M &m) 01219 #if(CXSC_INDEX_CHECK) 01220 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01221 #else 01222 throw(); 01223 #endif 01224 01225 //--- l_interval -------- matrix-matrix -------------- 01226 01227 template <class M1,class M2,class E> friend E _mmlimult(const M1 &m1, const M2 &m2) 01228 #if(CXSC_INDEX_CHECK) 01229 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01230 #else 01231 throw(); 01232 #endif 01233 01234 template <class M1,class M2,class S> friend M1 &_mmlimultassign(M1 &m1,const M2 &m2) 01235 #if(CXSC_INDEX_CHECK) 01236 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 01237 #else 01238 throw(); 01239 #endif 01240 template <class M,class MS,class E> friend E _mmslimult(const M &m1, const MS &ms) 01241 #if(CXSC_INDEX_CHECK) 01242 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01243 #else 01244 throw(); 01245 #endif 01246 01247 template <class MS,class M,class E> friend E _msmlimult(const MS &ms, const M &m2) 01248 #if(CXSC_INDEX_CHECK) 01249 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01250 #else 01251 throw(); 01252 #endif 01253 01254 template <class M,class MS,class S> friend M &_mmslimultassign(M &m1,const MS &ms) 01255 #if(CXSC_INDEX_CHECK) 01256 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01257 #else 01258 throw(); 01259 #endif 01260 template <class MS1,class MS2,class E> friend E _msmslimult(const MS1 &ms1, const MS2 &ms2) 01261 #if(CXSC_INDEX_CHECK) 01262 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01263 #else 01264 throw(); 01265 #endif 01266 01267 01268 //--- l_interval -------- matrix-vector -------------- 01269 template <class M,class V,class E> friend E _mvlimult(const M &m,const V &v) 01270 #if(CXSC_INDEX_CHECK) 01271 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01272 #else 01273 throw(); 01274 #endif 01275 template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v) 01276 #if(CXSC_INDEX_CHECK) 01277 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01278 #else 01279 throw(); 01280 #endif 01281 template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms) 01282 #if(CXSC_INDEX_CHECK) 01283 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01284 #else 01285 throw(); 01286 #endif 01287 01288 template <class V,class M,class E> friend E _vmlimult(const V &v,const M &m) 01289 #if(CXSC_INDEX_CHECK) 01290 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01291 #else 01292 throw(); 01293 #endif 01294 template <class V,class M,class S> friend V &_vmlimultassign(V &v,const M &m) 01295 #if(CXSC_INDEX_CHECK) 01296 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01297 #else 01298 throw(); 01299 #endif 01300 template <class VS,class M,class S> friend VS &_vsmlimultassign(VS &v,const M &m) 01301 #if(CXSC_INDEX_CHECK) 01302 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01303 #else 01304 throw(); 01305 #endif 01306 01307 #endif 01308 01309 //-------------------------- Konstruktoren ---------------------------- 01310 01312 INLINE rmatrix(const rmatrix &rm) throw(); 01314 INLINE rmatrix(const rmatrix_slice &rm) throw(); 01316 INLINE rmatrix() throw(); 01318 explicit INLINE rmatrix(const int &m, const int &n) 01319 #if(CXSC_INDEX_CHECK) 01320 throw(ERROR_RMATRIX_WRONG_BOUNDARIES); 01321 #else 01322 throw(); 01323 #endif 01324 01325 explicit INLINE rmatrix(const int &m1, const int &n1, const int &m2, const int &n2) 01326 #if(CXSC_INDEX_CHECK) 01327 throw(ERROR_RMATRIX_WRONG_BOUNDARIES); 01328 #else 01329 throw(); 01330 #endif 01331 01332 explicit INLINE rmatrix(const rvector &v) throw(); 01334 explicit INLINE rmatrix(const rvector_slice &v) throw(); 01336 explicit INLINE rmatrix(const real &r) throw(); 01338 INLINE rmatrix(const srmatrix&); 01340 INLINE rmatrix(const srmatrix_slice&); 01342 INLINE rmatrix(const intmatrix&); 01343 01344 01346 INLINE rmatrix &operator =(const real &r) throw(); 01348 INLINE rmatrix &operator =(const rmatrix &m) throw(); 01350 INLINE rmatrix &operator =(const rmatrix_slice &ms) throw(); 01352 INLINE rmatrix &operator =(const rvector &v) throw(); 01354 INLINE rmatrix &operator =(const rvector_slice &v) throw(); 01356 INLINE rmatrix &operator =(const srmatrix&); 01358 INLINE rmatrix &operator =(const srmatrix_slice&); 01359 01361 INLINE rmatrix &operator *=(const srmatrix &m); 01363 INLINE rmatrix &operator *=(const srmatrix_slice &m); 01365 INLINE rmatrix &operator +=(const srmatrix &m); 01367 INLINE rmatrix &operator +=(const srmatrix_slice &m); 01369 INLINE rmatrix &operator -=(const srmatrix &m); 01371 INLINE rmatrix &operator -=(const srmatrix_slice &m); 01372 01374 INLINE rmatrix operator()(const intvector& p, const intvector& q); 01376 INLINE rmatrix operator()(const intmatrix& P, const intmatrix& Q); 01378 INLINE rmatrix operator()(const intvector& p); 01380 INLINE rmatrix operator()(const intmatrix& P); 01381 01382 01383 //--------------------------- Destruktoren ----------------------------- 01384 01385 INLINE ~rmatrix() throw() { delete [] dat; } 01386 01387 //------------------------- Standardfunktionen ------------------------- 01388 01389 friend INLINE real::real(const rmatrix &m) 01390 #if(CXSC_INDEX_CHECK) 01391 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ,ERROR_RMATRIX_USE_OF_UNINITIALIZED_OBJ); 01392 #else 01393 throw(); 01394 #endif 01395 friend INLINE rvector::rvector(const rmatrix &m) 01396 #if(CXSC_INDEX_CHECK) 01397 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 01398 #else 01399 throw(); 01400 #endif 01401 01402 INLINE rmatrix_subv operator [](const int &i) const 01403 #if(CXSC_INDEX_CHECK) 01404 throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT); 01405 #else 01406 throw(); 01407 #endif 01408 01409 INLINE rmatrix_subv operator [](const cxscmatrix_column &i) const 01410 #if(CXSC_INDEX_CHECK) 01411 throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT); 01412 #else 01413 throw(); 01414 #endif 01415 01416 INLINE rmatrix &operator ()() throw() { return *this; } 01418 INLINE rmatrix_slice operator ()(const int &m, const int &n) 01419 #if(CXSC_INDEX_CHECK) 01420 throw(ERROR_RMATRIX_SUB_ARRAY_TOO_BIG); 01421 #else 01422 throw(); 01423 #endif 01424 01425 INLINE rmatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2) 01426 #if(CXSC_INDEX_CHECK) 01427 throw(ERROR_RMATRIX_SUB_ARRAY_TOO_BIG); 01428 #else 01429 throw(); 01430 #endif 01431 INLINE operator void*() throw(); 01432 //#else 01433 //#endif 01434 }; 01435 01437 01442 class rmatrix_slice 01443 { 01444 friend class rmatrix; 01445 friend class imatrix; 01446 friend class cmatrix; 01447 friend class cimatrix; 01448 friend class l_rmatrix; 01449 friend class l_imatrix; 01450 private: 01451 real *dat; 01452 int offset1,offset2,mxsize,mysize; 01453 int start1,end1,start2,end2,sxsize,sysize; // slice size 01454 01455 public: 01456 //#if(CXSC_INDEX_CHECK) 01457 #ifdef _CXSC_FRIEND_TPL 01458 //----------------- Templates --------------------------------------- 01459 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m) 01460 #if(CXSC_INDEX_CHECK) 01461 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>); 01462 #else 01463 throw(); 01464 #endif 01465 template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m) 01466 #if(CXSC_INDEX_CHECK) 01467 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01468 #else 01469 throw(); 01470 #endif 01471 template <class MS1,class MS2> friend MS1 &_msmsassign(MS1 &ms1,const MS2 &ms) 01472 #if(CXSC_INDEX_CHECK) 01473 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 01474 #else 01475 throw(); 01476 #endif 01477 template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) throw(); 01478 template <class MS,class S> friend MS &_mssassign(MS &ms,const S &r) throw(); 01479 template <class MS> friend int _mslb(const MS &ms, const int &i) 01480 #if(CXSC_INDEX_CHECK) 01481 throw(ERROR__WRONG_ROW_OR_COL<MS>); 01482 #else 01483 throw(); 01484 #endif 01485 template <class MS> friend int _msub(const MS &ms, const int &i) 01486 #if(CXSC_INDEX_CHECK) 01487 throw(ERROR__WRONG_ROW_OR_COL<MS>); 01488 #else 01489 throw(); 01490 #endif 01491 template <class MS,class E> friend E _msabs(const MS &ms) throw(); 01492 //------------ matrix-matrix -------------------- 01493 template <class MS,class E> friend E _msminus(const MS &ms) throw(); 01494 template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms) 01495 #if(CXSC_INDEX_CHECK) 01496 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01497 #else 01498 throw(); 01499 #endif 01500 template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2) 01501 #if(CXSC_INDEX_CHECK) 01502 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01503 #else 01504 throw(); 01505 #endif 01506 template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms) 01507 #if(CXSC_INDEX_CHECK) 01508 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01509 #else 01510 throw(); 01511 #endif 01512 template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1) 01513 #if(CXSC_INDEX_CHECK) 01514 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01515 #else 01516 throw(); 01517 #endif 01518 template <class MS1,class MS2> friend MS1 &_msmsplusassign(MS1 &ms1,const MS2 &ms2) 01519 #if(CXSC_INDEX_CHECK) 01520 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 01521 #else 01522 throw(); 01523 #endif 01524 template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms) 01525 #if(CXSC_INDEX_CHECK) 01526 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01527 #else 01528 throw(); 01529 #endif 01530 template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m) 01531 #if(CXSC_INDEX_CHECK) 01532 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01533 #else 01534 throw(); 01535 #endif 01536 template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2) 01537 #if(CXSC_INDEX_CHECK) 01538 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01539 #else 01540 throw(); 01541 #endif 01542 template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms) 01543 #if(CXSC_INDEX_CHECK) 01544 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01545 #else 01546 throw(); 01547 #endif 01548 template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1) 01549 #if(CXSC_INDEX_CHECK) 01550 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01551 #else 01552 throw(); 01553 #endif 01554 template <class MS1,class MS2> friend MS1 &_msmsminusassign(MS1 &ms1,const MS2 &ms2) 01555 #if(CXSC_INDEX_CHECK) 01556 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 01557 #else 01558 throw(); 01559 #endif 01560 template <class M,class MS,class E> friend E _mmsmult(const M &m1, const MS &ms) 01561 #if(CXSC_INDEX_CHECK) 01562 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01563 #else 01564 throw(); 01565 #endif 01566 template <class MS,class M,class E> friend E _msmmult(const MS &ms, const M &m2) 01567 #if(CXSC_INDEX_CHECK) 01568 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01569 #else 01570 throw(); 01571 #endif 01572 template <class M,class MS,class S> friend M &_mmsmultassign(M &m1,const MS &ms) 01573 #if(CXSC_INDEX_CHECK) 01574 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01575 #else 01576 throw(); 01577 #endif 01578 template <class MS1,class MS2,class E> friend E _msmsmult(const MS1 &ms1, const MS2 &ms2) 01579 #if(CXSC_INDEX_CHECK) 01580 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01581 #else 01582 throw(); 01583 #endif 01584 template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms) 01585 #if(CXSC_INDEX_CHECK) 01586 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01587 #else 01588 throw(); 01589 #endif 01590 template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2) 01591 #if(CXSC_INDEX_CHECK) 01592 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01593 #else 01594 throw(); 01595 #endif 01596 //---------- matrix-vector ------------------------ 01597 template <class MS,class V,class E> friend E _msvmult(const MS &ms,const V &v) 01598 #if(CXSC_INDEX_CHECK) 01599 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01600 #else 01601 throw(); 01602 #endif 01603 template <class V,class MS,class E> friend E _vmsmult(const V &v,const MS &ms) 01604 #if(CXSC_INDEX_CHECK) 01605 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01606 #else 01607 throw(); 01608 #endif 01609 template <class V,class MS,class S> friend V &_vmsmultassign(V &v,const MS &ms) 01610 #if(CXSC_INDEX_CHECK) 01611 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01612 #else 01613 throw(); 01614 #endif 01615 //--------- matrix-scalar ----------------- 01616 template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) throw(); 01617 template <class MS,class S> friend MS &_mssmultassign(MS &ms,const S &c) throw(); 01618 template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) throw(); 01619 template <class MS,class S> friend MS &_mssdivassign(MS &ms,const S &c) throw(); 01620 01621 template <class MS> friend void *_msvoid(const MS &ms) throw(); 01622 template <class MS> friend bool _msnot(const MS &ms) throw(); 01623 template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) throw(); 01624 template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) throw(); 01625 template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) throw(); 01626 template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) throw(); 01627 template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) throw(); 01628 template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) throw(); 01629 template <class MS1,class MS2> friend bool _msmseq(const MS1 &ms1,const MS2 &ms2) throw(); 01630 template <class MS1,class MS2> friend bool _msmsneq(const MS1 &ms1,const MS2 &ms2) throw(); 01631 template <class MS1,class MS2> friend bool _msmsless(const MS1 &ms1,const MS2 &ms2) throw(); 01632 template <class MS1,class MS2> friend bool _msmsleq(const MS1 &ms1,const MS2 &ms2) throw(); 01633 template <class MS> friend std::ostream &_msout(std::ostream &s,const MS &r) throw(); 01634 template <class MS> friend std::istream &_msin(std::istream &s,MS &r) throw(); 01635 01636 // Interval 01637 template <class M1,class MS2> friend M1 &_mmssetinf(M1 &m1,const MS2 &ms2) 01638 #if(CXSC_INDEX_CHECK) 01639 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 01640 #else 01641 throw(); 01642 #endif 01643 template <class M1,class MS2> friend M1 &_mmssetsup(M1 &m1,const MS2 &ms2) 01644 #if(CXSC_INDEX_CHECK) 01645 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 01646 #else 01647 throw(); 01648 #endif 01649 template <class M1,class MS2> friend M1 &_mmsusetinf(M1 &m1,const MS2 &ms2) 01650 #if(CXSC_INDEX_CHECK) 01651 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 01652 #else 01653 throw(); 01654 #endif 01655 template <class M1,class MS2> friend M1 &_mmsusetsup(M1 &m1,const MS2 &ms2) 01656 #if(CXSC_INDEX_CHECK) 01657 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 01658 #else 01659 throw(); 01660 #endif 01661 template <class MS1,class MS2> friend MS1 &_msmssetinf(MS1 &ms1,const MS2 &ms2) 01662 #if(CXSC_INDEX_CHECK) 01663 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 01664 #else 01665 throw(); 01666 #endif 01667 template <class MS1,class MS2> friend MS1 &_msmssetsup(MS1 &ms1,const MS2 &ms2) 01668 #if(CXSC_INDEX_CHECK) 01669 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 01670 #else 01671 throw(); 01672 #endif 01673 template <class MS1,class MS2> friend MS1 &_msmsusetinf(MS1 &ms1,const MS2 &ms2) 01674 #if(CXSC_INDEX_CHECK) 01675 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 01676 #else 01677 throw(); 01678 #endif 01679 template <class MS1,class MS2> friend MS1 &_msmsusetsup(MS1 &ms1,const MS2 &ms2) 01680 #if(CXSC_INDEX_CHECK) 01681 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 01682 #else 01683 throw(); 01684 #endif 01685 //--- Interval ---------- matrix-vector ----------- 01686 template <class MS,class V,class E> friend E _msvimult(const MS &ms,const V &v) 01687 #if(CXSC_INDEX_CHECK) 01688 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01689 #else 01690 throw(); 01691 #endif 01692 template <class V,class MS,class E> friend E _vmsimult(const V &v,const MS &ms) 01693 #if(CXSC_INDEX_CHECK) 01694 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01695 #else 01696 throw(); 01697 #endif 01698 template <class V,class MS,class S> friend V &_vmsimultassign(V &v,const MS &ms) 01699 #if(CXSC_INDEX_CHECK) 01700 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01701 #else 01702 throw(); 01703 #endif 01704 //--- Interval ---------- matrix-matrix ---------- 01705 01706 01707 template <class M,class MS,class E> friend E _mmsimult(const M &m1, const MS &ms) 01708 #if(CXSC_INDEX_CHECK) 01709 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01710 #else 01711 throw(); 01712 #endif 01713 template <class MS,class M,class E> friend E _msmimult(const MS &ms, const M &m2) 01714 #if(CXSC_INDEX_CHECK) 01715 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01716 #else 01717 throw(); 01718 #endif 01719 01720 template <class M,class MS,class S> friend M &_mmsimultassign(M &m1,const MS &ms) 01721 #if(CXSC_INDEX_CHECK) 01722 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01723 #else 01724 throw(); 01725 #endif 01726 01727 template <class MS1,class MS2,class E> friend E _msmsimult(const MS1 &ms1, const MS2 &ms2) 01728 #if(CXSC_INDEX_CHECK) 01729 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01730 #else 01731 throw(); 01732 #endif 01733 01734 template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms) 01735 #if(CXSC_INDEX_CHECK) 01736 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01737 #else 01738 throw(); 01739 #endif 01740 template <class MS1,class MS2> friend MS1 &_msmsconvassign(MS1 &ms1,const MS2 &ms2) 01741 #if(CXSC_INDEX_CHECK) 01742 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 01743 #else 01744 throw(); 01745 #endif 01746 template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms) 01747 #if(CXSC_INDEX_CHECK) 01748 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01749 #else 01750 throw(); 01751 #endif 01752 template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms) 01753 #if(CXSC_INDEX_CHECK) 01754 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01755 #else 01756 throw(); 01757 #endif 01758 template <class MS1,class MS2> friend MS1 &_msmssectassign(MS1 &ms1,const MS2 &ms2) 01759 #if(CXSC_INDEX_CHECK) 01760 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 01761 #else 01762 throw(); 01763 #endif 01764 template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2) 01765 #if(CXSC_INDEX_CHECK) 01766 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01767 #else 01768 throw(); 01769 #endif 01770 01771 // complex 01772 01773 template <class MS1,class MS2> friend MS1 &_msmssetre(MS1 &ms1,const MS2 &ms2) 01774 #if(CXSC_INDEX_CHECK) 01775 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 01776 #else 01777 throw(); 01778 #endif 01779 template <class MS1,class MS2> friend MS1 &_msmssetim(MS1 &ms1,const MS2 &ms2) 01780 #if(CXSC_INDEX_CHECK) 01781 throw(ERROR__OP_WITH_WRONG_DIM<MS1>); 01782 #else 01783 throw(); 01784 #endif 01785 template <class M1,class MS2> friend M1 &_mmssetre(M1 &m1,const MS2 &ms2) 01786 #if(CXSC_INDEX_CHECK) 01787 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 01788 #else 01789 throw(); 01790 #endif 01791 template <class M1,class MS2> friend M1 &_mmssetim(M1 &m1,const MS2 &ms2) 01792 #if(CXSC_INDEX_CHECK) 01793 throw(ERROR__OP_WITH_WRONG_DIM<M1>); 01794 #else 01795 throw(); 01796 #endif 01797 //--- complex ---------- matrix-vector ----------- 01798 template <class MS,class V,class E> friend E _msvcmult(const MS &ms,const V &v) 01799 #if(CXSC_INDEX_CHECK) 01800 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01801 #else 01802 throw(); 01803 #endif 01804 template <class V,class MS,class E> friend E _vmscmult(const V &v,const MS &ms) 01805 #if(CXSC_INDEX_CHECK) 01806 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01807 #else 01808 throw(); 01809 #endif 01810 template <class V,class MS,class S> friend V &_vmscmultassign(V &v,const MS &ms) 01811 #if(CXSC_INDEX_CHECK) 01812 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01813 #else 01814 throw(); 01815 #endif 01816 //--- complex ---------- matrix-matrix ---------- 01817 01818 01819 template <class M,class MS,class E> friend E _mmscmult(const M &m1, const MS &ms) 01820 #if(CXSC_INDEX_CHECK) 01821 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01822 #else 01823 throw(); 01824 #endif 01825 template <class MS,class M,class E> friend E _msmcmult(const MS &ms, const M &m2) 01826 #if(CXSC_INDEX_CHECK) 01827 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01828 #else 01829 throw(); 01830 #endif 01831 01832 template <class M,class MS,class S> friend M &_mmscmultassign(M &m1,const MS &ms) 01833 #if(CXSC_INDEX_CHECK) 01834 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01835 #else 01836 throw(); 01837 #endif 01838 template <class MS1,class MS2,class E> friend E _msmscmult(const MS1 &ms1, const MS2 &ms2) 01839 #if(CXSC_INDEX_CHECK) 01840 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01841 #else 01842 throw(); 01843 #endif 01844 01845 // cinterval -- matrix-vector 01846 template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v) 01847 #if(CXSC_INDEX_CHECK) 01848 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01849 #else 01850 throw(); 01851 #endif 01852 template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms) 01853 #if(CXSC_INDEX_CHECK) 01854 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01855 #else 01856 throw(); 01857 #endif 01858 template <class V,class MS,class S> friend V &_vmscimultassign(V &v,const MS &ms) 01859 #if(CXSC_INDEX_CHECK) 01860 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01861 #else 01862 throw(); 01863 #endif 01864 01865 /* friend TINLINE civector _msvscimult<rmatrix_slice,civector_slice,civector>(const rmatrix_slice &ms,const civector_slice &v) 01866 #if(CXSC_INDEX_CHECK) 01867 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM); 01868 #else 01869 throw(); 01870 #endif */ 01871 /* friend TINLINE civector _vsmscimult<civector_slice,rmatrix_slice,civector>(const civector_slice &v,const rmatrix_slice &ms) 01872 #if(CXSC_INDEX_CHECK) 01873 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM); 01874 #else 01875 throw(); 01876 #endif */ 01877 /* friend TINLINE civector &_vsmscimultassign<civector_slice,rmatrix_slice,interval>(civector_slice &v,const rmatrix_slice &ms) 01878 #if(CXSC_INDEX_CHECK) 01879 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM); 01880 #else 01881 throw(); 01882 #endif */ 01883 // cinterval -- matrix-matrix 01884 01885 template <class M,class MS,class E> friend E _mmscimult(const M &m1, const MS &ms) 01886 #if(CXSC_INDEX_CHECK) 01887 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01888 #else 01889 throw(); 01890 #endif 01891 template <class MS,class M,class E> friend E _msmcimult(const MS &ms, const M &m2) 01892 #if(CXSC_INDEX_CHECK) 01893 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01894 #else 01895 throw(); 01896 #endif 01897 template <class M,class MS,class S> friend M &_mmscimultassign(M &m1,const MS &ms) 01898 #if(CXSC_INDEX_CHECK) 01899 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01900 #else 01901 throw(); 01902 #endif 01903 01904 template <class MS1,class MS2,class E> friend E _msmscimult(const MS1 &ms1, const MS2 &ms2) 01905 #if(CXSC_INDEX_CHECK) 01906 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01907 #else 01908 throw(); 01909 #endif 01910 01911 //--- l_real ---------- matrix-vector ----------- 01912 template <class MS,class V,class E> friend E _msvlmult(const MS &ms,const V &v) 01913 #if(CXSC_INDEX_CHECK) 01914 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01915 #else 01916 throw(); 01917 #endif 01918 template <class V,class MS,class E> friend E _vmslmult(const V &v,const MS &ms) 01919 #if(CXSC_INDEX_CHECK) 01920 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01921 #else 01922 throw(); 01923 #endif 01924 template <class V,class MS,class S> friend V &_vmslmultassign(V &v,const MS &ms) 01925 #if(CXSC_INDEX_CHECK) 01926 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01927 #else 01928 throw(); 01929 #endif 01930 //--- l_real ---------- matrix-matrix ---------- 01931 01932 template <class M,class MS,class E> friend E _mmslmult(const M &m1, const MS &ms) 01933 #if(CXSC_INDEX_CHECK) 01934 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01935 #else 01936 throw(); 01937 #endif 01938 template <class MS,class M,class E> friend E _msmlmult(const MS &ms, const M &m2) 01939 #if(CXSC_INDEX_CHECK) 01940 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01941 #else 01942 throw(); 01943 #endif 01944 01945 template <class M,class MS,class S> friend M &_mmslmultassign(M &m1,const MS &ms) 01946 #if(CXSC_INDEX_CHECK) 01947 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01948 #else 01949 throw(); 01950 #endif 01951 template <class MS1,class MS2,class E> friend E _msmslmult(const MS1 &ms1, const MS2 &ms2) 01952 #if(CXSC_INDEX_CHECK) 01953 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01954 #else 01955 throw(); 01956 #endif 01957 01958 // l_interval -- matrix-vector 01959 template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v) 01960 #if(CXSC_INDEX_CHECK) 01961 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01962 #else 01963 throw(); 01964 #endif 01965 template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms) 01966 #if(CXSC_INDEX_CHECK) 01967 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01968 #else 01969 throw(); 01970 #endif 01971 template <class V,class MS,class S> friend V &_vmslimultassign(V &v,const MS &ms) 01972 #if(CXSC_INDEX_CHECK) 01973 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01974 #else 01975 throw(); 01976 #endif 01977 01978 /* friend TINLINE l_ivector _msvslimult<rmatrix_slice,l_ivector_slice,l_ivector>(const rmatrix_slice &ms,const l_ivector_slice &v) 01979 #if(CXSC_INDEX_CHECK) 01980 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM); 01981 #else 01982 throw(); 01983 #endif */ 01984 /* friend TINLINE l_ivector _vsmslimult<l_ivector_slice,rmatrix_slice,l_ivector>(const l_ivector_slice &v,const rmatrix_slice &ms) 01985 #if(CXSC_INDEX_CHECK) 01986 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM); 01987 #else 01988 throw(); 01989 #endif */ 01990 /* friend TINLINE l_ivector &_vsmslimultassign<l_ivector_slice,rmatrix_slice,interval>(l_ivector_slice &v,const rmatrix_slice &ms) 01991 #if(CXSC_INDEX_CHECK) 01992 throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM); 01993 #else 01994 throw(); 01995 #endif */ 01996 // l_interval -- matrix-matrix 01997 01998 template <class M,class MS,class E> friend E _mmslimult(const M &m1, const MS &ms) 01999 #if(CXSC_INDEX_CHECK) 02000 throw(ERROR__OP_WITH_WRONG_DIM<E>); 02001 #else 02002 throw(); 02003 #endif 02004 template <class MS,class M,class E> friend E _msmlimult(const MS &ms, const M &m2) 02005 #if(CXSC_INDEX_CHECK) 02006 throw(ERROR__OP_WITH_WRONG_DIM<E>); 02007 #else 02008 throw(); 02009 #endif 02010 02011 template <class M,class MS,class S> friend M &_mmslimultassign(M &m1,const MS &ms) 02012 #if(CXSC_INDEX_CHECK) 02013 throw(ERROR__OP_WITH_WRONG_DIM<M>); 02014 #else 02015 throw(); 02016 #endif 02017 02018 template <class MS1,class MS2,class E> friend E _msmslimult(const MS1 &ms1, const MS2 &ms2) 02019 #if(CXSC_INDEX_CHECK) 02020 throw(ERROR__OP_WITH_WRONG_DIM<E>); 02021 #else 02022 throw(); 02023 #endif 02024 02025 02026 #endif 02027 02028 02029 //--------------- Konstruktoren ---------------------------------------- 02030 02032 explicit INLINE rmatrix_slice(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) { } 02034 explicit INLINE rmatrix_slice(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) { } 02035 public: 02037 INLINE rmatrix_slice(const 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) { } 02038 public: 02039 02040 //---------------- Standardfunktionen ----------------------------------- 02041 02042 friend rvector::rvector(const rmatrix_slice &sl) 02043 #if(CXSC_INDEX_CHECK) 02044 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 02045 #else 02046 throw(); 02047 #endif 02048 friend INLINE rmatrix::rmatrix(const rmatrix_slice &) throw(); 02050 INLINE rmatrix_slice &operator =(const srmatrix &m); 02052 INLINE rmatrix_slice &operator =(const srmatrix_slice &m); 02053 02055 INLINE rmatrix_slice &operator =(const rmatrix &m) 02056 #if(CXSC_INDEX_CHECK) 02057 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02058 #else 02059 throw(); 02060 #endif 02061 02062 INLINE rmatrix_slice &operator =(const rmatrix_slice &ms) 02063 #if(CXSC_INDEX_CHECK) 02064 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02065 #else 02066 throw(); 02067 #endif 02068 02069 INLINE rmatrix_slice &operator =(const real &r) throw(); 02071 INLINE rmatrix_slice &operator =(const rvector &v) 02072 #if(CXSC_INDEX_CHECK) 02073 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02074 #else 02075 throw(); 02076 #endif 02077 02078 INLINE rmatrix_slice &operator =(const rvector_slice &v) 02079 #if(CXSC_INDEX_CHECK) 02080 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02081 #else 02082 throw(); 02083 #endif 02084 02085 INLINE rmatrix_slice &operator =(const rmatrix_subv &v) 02086 #if(CXSC_INDEX_CHECK) 02087 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02088 #else 02089 throw(); 02090 #endif 02091 02092 INLINE rmatrix_subv operator [](const int &i) const 02093 #if(CXSC_INDEX_CHECK) 02094 throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT); 02095 #else 02096 throw(); 02097 #endif 02098 02099 INLINE rmatrix_subv operator [](const cxscmatrix_column &i) const 02100 #if(CXSC_INDEX_CHECK) 02101 throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT); 02102 #else 02103 throw(); 02104 #endif 02105 02106 INLINE rmatrix_slice &operator ()() throw() { return *this; } 02108 INLINE rmatrix_slice operator ()(const int &m, const int &n) 02109 #if(CXSC_INDEX_CHECK) 02110 throw(ERROR_RMATRIX_SUB_ARRAY_TOO_BIG); 02111 #else 02112 throw(); 02113 #endif 02114 02115 INLINE rmatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2) 02116 #if(CXSC_INDEX_CHECK) 02117 throw(ERROR_RMATRIX_SUB_ARRAY_TOO_BIG); 02118 #else 02119 throw(); 02120 #endif 02121 02123 INLINE rmatrix_slice &operator *=(const srmatrix &m); 02125 INLINE rmatrix_slice &operator *=(const srmatrix_slice &m); 02126 02128 INLINE rmatrix_slice &operator *=(const rmatrix &m) 02129 #if(CXSC_INDEX_CHECK) 02130 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02131 #else 02132 throw(); 02133 #endif 02134 02135 INLINE rmatrix_slice &operator *=(const rmatrix_slice &ms2) 02136 #if(CXSC_INDEX_CHECK) 02137 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02138 #else 02139 throw(); 02140 #endif 02141 02143 INLINE rmatrix_slice &operator +=(const srmatrix &m); 02145 INLINE rmatrix_slice &operator +=(const srmatrix_slice &m); 02146 02148 INLINE rmatrix_slice &operator +=(const rmatrix &m1) 02149 #if(CXSC_INDEX_CHECK) 02150 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02151 #else 02152 throw(); 02153 #endif 02154 02155 INLINE rmatrix_slice &operator +=(const rmatrix_slice &ms2) 02156 #if(CXSC_INDEX_CHECK) 02157 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02158 #else 02159 throw(); 02160 #endif 02161 02163 INLINE rmatrix_slice &operator -=(const srmatrix &m); 02165 INLINE rmatrix_slice &operator -=(const srmatrix_slice &m); 02166 02168 INLINE rmatrix_slice &operator -=(const rmatrix &m1) 02169 #if(CXSC_INDEX_CHECK) 02170 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02171 #else 02172 throw(); 02173 #endif 02174 02175 INLINE rmatrix_slice &operator -=(const rmatrix_slice &ms2) 02176 #if(CXSC_INDEX_CHECK) 02177 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02178 #else 02179 throw(); 02180 #endif 02181 02182 INLINE rmatrix_slice &operator *=(const real &c) throw(); 02184 INLINE rmatrix_slice &operator /=(const real &c) throw(); 02185 INLINE operator void*() throw(); 02186 //#else 02187 //#endif 02188 }; 02189 02190 //================================================================ 02191 //====================== Subvector Functions ===================== 02192 02193 //=======================Vector / Scalar ========================= 02194 02196 INLINE rvector operator /(const rmatrix_subv &rv, const real &s) throw(); 02198 INLINE rvector operator *(const rmatrix_subv &rv, const real &s) throw(); 02200 INLINE rvector operator *(const real &s, const rmatrix_subv &rv) throw(); 02202 INLINE rvector abs(const rmatrix_subv &mv) throw(); 02203 02204 //======================== Vector / Vector ======================== 02205 02207 void accumulate(dotprecision &dp, const rmatrix_subv & rv1, const rmatrix_subv &rv2) 02208 #if(CXSC_INDEX_CHECK) 02209 throw(OP_WITH_WRONG_DIM); 02210 #else 02211 throw(); 02212 #endif 02213 02215 void accumulate_approx(dotprecision &dp, const rmatrix_subv & rv1, const rmatrix_subv &rv2); 02216 02218 void accumulate(dotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2) 02219 #if(CXSC_INDEX_CHECK) 02220 throw(OP_WITH_WRONG_DIM); 02221 #else 02222 throw(); 02223 #endif 02224 02226 void accumulate_approx(dotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2); 02227 02229 void accumulate(dotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2) 02230 #if(CXSC_INDEX_CHECK) 02231 throw(OP_WITH_WRONG_DIM); 02232 #else 02233 throw(); 02234 #endif 02235 02237 void accumulate_approx(dotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2); 02238 02240 void accumulate(cdotprecision &dp, const rmatrix_subv & rv1, const rmatrix_subv &rv2) 02241 #if(CXSC_INDEX_CHECK) 02242 throw(OP_WITH_WRONG_DIM); 02243 #else 02244 throw(); 02245 #endif 02246 02248 void accumulate_approx(cdotprecision &dp, const rmatrix_subv & rv1, const rmatrix_subv &rv2); 02249 02251 void accumulate(cdotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2) 02252 #if(CXSC_INDEX_CHECK) 02253 throw(OP_WITH_WRONG_DIM); 02254 #else 02255 throw(); 02256 #endif 02257 02259 void accumulate_approx(cdotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2); 02260 02262 void accumulate(cdotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2) 02263 #if(CXSC_INDEX_CHECK) 02264 throw(OP_WITH_WRONG_DIM); 02265 #else 02266 throw(); 02267 #endif 02268 02270 void accumulate_approx(cdotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2); 02271 02273 void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const rmatrix_subv &rv2) 02274 #if(CXSC_INDEX_CHECK) 02275 throw(OP_WITH_WRONG_DIM); 02276 #else 02277 throw(); 02278 #endif 02279 02280 void accumulate(idotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2) 02281 #if(CXSC_INDEX_CHECK) 02282 throw(OP_WITH_WRONG_DIM); 02283 #else 02284 throw(); 02285 #endif 02286 02287 void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2) 02288 #if(CXSC_INDEX_CHECK) 02289 throw(OP_WITH_WRONG_DIM); 02290 #else 02291 throw(); 02292 #endif 02293 02294 void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const rmatrix_subv &rv2) 02295 #if(CXSC_INDEX_CHECK) 02296 throw(OP_WITH_WRONG_DIM); 02297 #else 02298 throw(); 02299 #endif 02300 02301 void accumulate(cidotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2) 02302 #if(CXSC_INDEX_CHECK) 02303 throw(OP_WITH_WRONG_DIM); 02304 #else 02305 throw(); 02306 #endif 02307 02308 void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2) 02309 #if(CXSC_INDEX_CHECK) 02310 throw(OP_WITH_WRONG_DIM); 02311 #else 02312 throw(); 02313 #endif 02314 02315 void accumulate(dotprecision &dp,const rvector_slice &sl,const rmatrix_subv &sv) 02316 #if(CXSC_INDEX_CHECK) 02317 throw(OP_WITH_WRONG_DIM); 02318 #else 02319 throw(); 02320 #endif 02321 02323 void accumulate_approx(dotprecision &dp,const rvector_slice &sl,const rmatrix_subv &sv); 02324 02325 02327 void accumulate(cdotprecision &dp, const rvector_slice & sl1, const rmatrix_subv &rv2) 02328 #if(CXSC_INDEX_CHECK) 02329 throw(OP_WITH_WRONG_DIM); 02330 #else 02331 throw(); 02332 #endif 02333 02335 void accumulate_approx(cdotprecision &dp, const rvector_slice & sl1, const rmatrix_subv &rv2); 02336 02338 void accumulate(idotprecision &dp, const rvector_slice & sl1, const rmatrix_subv &rv2) 02339 #if(CXSC_INDEX_CHECK) 02340 throw(OP_WITH_WRONG_DIM); 02341 #else 02342 throw(); 02343 #endif 02344 02346 void accumulate(cidotprecision &dp, const rvector_slice & sl1, const rmatrix_subv &rv2) 02347 #if(CXSC_INDEX_CHECK) 02348 throw(OP_WITH_WRONG_DIM); 02349 #else 02350 throw(); 02351 #endif 02352 02354 void accumulate(dotprecision &dp,const rmatrix_subv &mv,const rvector_slice &vs) 02355 #if(CXSC_INDEX_CHECK) 02356 throw(OP_WITH_WRONG_DIM); 02357 #else 02358 throw(); 02359 #endif 02360 02362 void accumulate_approx(dotprecision &dp,const rmatrix_subv &mv,const rvector_slice &vs); 02363 02364 02366 void accumulate(cdotprecision &dp, const rmatrix_subv & rv1, const rvector_slice &sl2) 02367 #if(CXSC_INDEX_CHECK) 02368 throw(OP_WITH_WRONG_DIM); 02369 #else 02370 throw(); 02371 #endif 02372 02374 void accumulate_approx(cdotprecision &dp, const rmatrix_subv & rv1, const rvector_slice &sl2); 02375 02377 void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const rvector_slice &sl2) 02378 #if(CXSC_INDEX_CHECK) 02379 throw(OP_WITH_WRONG_DIM); 02380 #else 02381 throw(); 02382 #endif 02383 02385 void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const rvector_slice &sl2) 02386 #if(CXSC_INDEX_CHECK) 02387 throw(OP_WITH_WRONG_DIM); 02388 #else 02389 throw(); 02390 #endif 02391 02393 INLINE real operator *(const rmatrix_subv & rv1, const rmatrix_subv &rv2) 02394 #if(CXSC_INDEX_CHECK) 02395 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM); 02396 #else 02397 throw(); 02398 #endif 02399 02400 INLINE real operator *(const rvector & rv1, const rmatrix_subv &rv2) 02401 #if(CXSC_INDEX_CHECK) 02402 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM); 02403 #else 02404 throw(); 02405 #endif 02406 02407 INLINE real operator *(const rmatrix_subv &rv1,const rvector &rv2) 02408 #if(CXSC_INDEX_CHECK) 02409 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM); 02410 #else 02411 throw(); 02412 #endif 02413 02414 INLINE real operator *(const rvector_slice &sl,const rmatrix_subv &sv) 02415 #if(CXSC_INDEX_CHECK) 02416 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM); 02417 #else 02418 throw(); 02419 #endif 02420 02421 INLINE real operator *(const rmatrix_subv &mv,const rvector_slice &vs) 02422 #if(CXSC_INDEX_CHECK) 02423 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM); 02424 #else 02425 throw(); 02426 #endif 02427 02429 INLINE rvector operator +(const rmatrix_subv & rv1, const rmatrix_subv &rv2) 02430 #if(CXSC_INDEX_CHECK) 02431 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM); 02432 #else 02433 throw(); 02434 #endif 02435 02436 INLINE rvector operator +(const rmatrix_subv &rv1,const rvector &rv2) 02437 #if(CXSC_INDEX_CHECK) 02438 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM); 02439 #else 02440 throw(); 02441 #endif 02442 02443 INLINE rvector operator +(const rvector & rv1, const rmatrix_subv &rv2) 02444 #if(CXSC_INDEX_CHECK) 02445 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM); 02446 #else 02447 throw(); 02448 #endif 02449 02450 INLINE rvector operator +(const rvector_slice &sl,const rmatrix_subv &mv) 02451 #if(CXSC_INDEX_CHECK) 02452 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM); 02453 #else 02454 throw(); 02455 #endif 02456 02457 INLINE rvector operator +(const rmatrix_subv &mv,const rvector_slice &sl) 02458 #if(CXSC_INDEX_CHECK) 02459 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM); 02460 #else 02461 throw(); 02462 #endif 02463 02465 INLINE rvector operator -(const rmatrix_subv & rv1, const rmatrix_subv &rv2) 02466 #if(CXSC_INDEX_CHECK) 02467 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM); 02468 #else 02469 throw(); 02470 #endif 02471 02472 INLINE rvector operator -(const rvector & rv1, const rmatrix_subv &rv2) 02473 #if(CXSC_INDEX_CHECK) 02474 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM); 02475 #else 02476 throw(); 02477 #endif 02478 02479 INLINE rvector operator -(const rmatrix_subv &rv1,const rvector &rv2) 02480 #if(CXSC_INDEX_CHECK) 02481 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM); 02482 #else 02483 throw(); 02484 #endif 02485 02486 INLINE rvector operator -(const rvector_slice &sl,const rmatrix_subv &mv) 02487 #if(CXSC_INDEX_CHECK) 02488 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM); 02489 #else 02490 throw(); 02491 #endif 02492 02493 INLINE rvector operator -(const rmatrix_subv &mv,const rvector_slice &sl) 02494 #if(CXSC_INDEX_CHECK) 02495 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM); 02496 #else 02497 throw(); 02498 #endif 02499 02500 //==================================================================== 02501 //===================== Matrix Functions ============================= 02502 02504 INLINE rmatrix _rmatrix(const rmatrix &rm) throw(); 02506 INLINE rmatrix _rmatrix(const rvector &v) throw(); 02508 INLINE rmatrix _rmatrix(const rvector_slice &v) throw(); 02510 INLINE rmatrix _rmatrix(const real &r) throw(); 02511 02513 INLINE int Lb(const rmatrix &rm, const int &i) 02514 #if(CXSC_INDEX_CHECK) 02515 throw(ERROR_RMATRIX_WRONG_ROW_OR_COL); 02516 #else 02517 throw(); 02518 #endif 02519 02520 INLINE int Ub(const rmatrix &rm, const int &i) 02521 #if(CXSC_INDEX_CHECK) 02522 throw(ERROR_RMATRIX_WRONG_ROW_OR_COL); 02523 #else 02524 throw(); 02525 #endif 02526 02527 INLINE int Lb(const rmatrix_slice &rm, const int &i) 02528 #if(CXSC_INDEX_CHECK) 02529 throw(ERROR_RMATRIX_WRONG_ROW_OR_COL); 02530 #else 02531 throw(); 02532 #endif 02533 02534 INLINE int Ub(const rmatrix_slice &rm, const int &i) 02535 #if(CXSC_INDEX_CHECK) 02536 throw(ERROR_RMATRIX_WRONG_ROW_OR_COL); 02537 #else 02538 throw(); 02539 #endif 02540 02541 INLINE rmatrix &SetLb(rmatrix &m, const int &i,const int &j) 02542 #if(CXSC_INDEX_CHECK) 02543 throw(ERROR_RMATRIX_WRONG_ROW_OR_COL); 02544 #else 02545 throw(); 02546 #endif 02547 02548 INLINE rmatrix &SetUb(rmatrix &m, const int &i,const int &j) 02549 #if(CXSC_INDEX_CHECK) 02550 throw(ERROR_RMATRIX_WRONG_ROW_OR_COL); 02551 #else 02552 throw(); 02553 #endif 02554 02555 INLINE void Resize(rmatrix &A) throw(); 02557 INLINE void Resize(rmatrix &A,const int &m, const int &n) 02558 #if(CXSC_INDEX_CHECK) 02559 throw(ERROR_RMATRIX_WRONG_BOUNDARIES); 02560 #else 02561 throw(); 02562 #endif 02563 02564 INLINE void Resize(rmatrix &A,const int &m1, const int &m2,const int &n1,const int &n2) 02565 #if(CXSC_INDEX_CHECK) 02566 throw(ERROR_RMATRIX_WRONG_BOUNDARIES); 02567 #else 02568 throw(); 02569 #endif 02570 02572 INLINE rmatrix abs(const rmatrix &m) throw(); 02574 INLINE rmatrix abs(const rmatrix_slice &ms) throw(); 02576 INLINE rmatrix CompMat(const rmatrix &m) throw(); 02577 02578 //===================== Matrix / Scalar =============================== 02579 02581 INLINE rmatrix operator *(const real &c, const rmatrix &m) throw(); 02583 INLINE rmatrix operator *(const real &c, const rmatrix_slice &ms) throw(); 02585 INLINE rmatrix operator *(const rmatrix &m,const real &c) throw(); 02587 INLINE rmatrix operator *(const rmatrix_slice &ms,const real &c) throw(); 02589 INLINE rmatrix &operator *=(rmatrix &m,const real &c) throw(); 02591 INLINE rmatrix operator /(const rmatrix &m,const real &c) throw(); 02593 INLINE rmatrix operator /(const rmatrix_slice &ms, const real &c) throw(); 02595 INLINE rmatrix &operator /=(rmatrix &m,const real &c) throw(); 02596 02597 //============================ Matrix / Vector =================================== 02598 02599 //--------------------------- rvector --------------------------- 02600 02602 INLINE rvector operator *(const rmatrix &m,const rvector &v) 02603 #if(CXSC_INDEX_CHECK) 02604 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02605 #else 02606 throw(); 02607 #endif 02608 02609 INLINE rvector operator *(const rmatrix_slice &ms,const rvector &v) 02610 #if(CXSC_INDEX_CHECK) 02611 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02612 #else 02613 throw(); 02614 #endif 02615 02616 INLINE rvector operator *(const rvector &v,const rmatrix &m) 02617 #if(CXSC_INDEX_CHECK) 02618 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02619 #else 02620 throw(); 02621 #endif 02622 02623 INLINE rvector operator *(const rvector &v,const rmatrix_slice &ms) 02624 #if(CXSC_INDEX_CHECK) 02625 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02626 #else 02627 throw(); 02628 #endif 02629 02630 INLINE rvector &operator *=(rvector &v,const rmatrix &m) 02631 #if(CXSC_INDEX_CHECK) 02632 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02633 #else 02634 throw(); 02635 #endif 02636 02637 INLINE rvector &operator *=(rvector &v,const rmatrix_slice &ms) 02638 #if(CXSC_INDEX_CHECK) 02639 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02640 #else 02641 throw(); 02642 #endif 02643 02644 // Test 02646 INLINE rvector operator *(const rvector_slice &v,const rmatrix &m) 02647 #if(CXSC_INDEX_CHECK) 02648 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02649 #else 02650 throw(); 02651 #endif 02652 02653 02654 02655 //================ Matrix / Matrix ============================ 02656 02658 INLINE const rmatrix &operator +(const rmatrix &m1) throw(); 02660 INLINE rmatrix operator +(const rmatrix_slice &ms) throw(); 02662 INLINE rmatrix operator +(const rmatrix &m1,const rmatrix &m2) 02663 #if(CXSC_INDEX_CHECK) 02664 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02665 #else 02666 throw(); 02667 #endif 02668 02669 INLINE rmatrix operator +(const rmatrix &m,const rmatrix_slice &ms) 02670 #if(CXSC_INDEX_CHECK) 02671 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02672 #else 02673 throw(); 02674 #endif 02675 02676 INLINE rmatrix operator +(const rmatrix_slice &ms,const rmatrix &m) 02677 #if(CXSC_INDEX_CHECK) 02678 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02679 #else 02680 throw(); 02681 #endif 02682 02683 INLINE rmatrix operator +(const rmatrix_slice &m1,const rmatrix_slice &m2) 02684 #if(CXSC_INDEX_CHECK) 02685 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02686 #else 02687 throw(); 02688 #endif 02689 02690 INLINE rmatrix &operator +=(rmatrix &m1,const rmatrix &m2) 02691 #if(CXSC_INDEX_CHECK) 02692 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02693 #else 02694 throw(); 02695 #endif 02696 02697 INLINE rmatrix &operator +=(rmatrix &m1,const rmatrix_slice &ms) 02698 #if(CXSC_INDEX_CHECK) 02699 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02700 #else 02701 throw(); 02702 #endif 02703 02705 INLINE rmatrix operator -(const rmatrix &m) throw(); 02707 INLINE rmatrix operator -(const rmatrix_slice &ms) throw(); 02709 INLINE rmatrix operator -(const rmatrix &m1,const rmatrix &m2) 02710 #if(CXSC_INDEX_CHECK) 02711 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02712 #else 02713 throw(); 02714 #endif 02715 02716 INLINE rmatrix operator -(const rmatrix &m,const rmatrix_slice &ms) 02717 #if(CXSC_INDEX_CHECK) 02718 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02719 #else 02720 throw(); 02721 #endif 02722 02723 INLINE rmatrix operator -(const rmatrix_slice &ms,const rmatrix &m) 02724 #if(CXSC_INDEX_CHECK) 02725 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02726 #else 02727 throw(); 02728 #endif 02729 02730 INLINE rmatrix operator -(const rmatrix_slice &ms1,const rmatrix_slice &ms2) 02731 #if(CXSC_INDEX_CHECK) 02732 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02733 #else 02734 throw(); 02735 #endif 02736 02737 INLINE rmatrix &operator -=(rmatrix &m1,const rmatrix &m2) 02738 #if(CXSC_INDEX_CHECK) 02739 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02740 #else 02741 throw(); 02742 #endif 02743 02744 INLINE rmatrix &operator -=(rmatrix &m1,const rmatrix_slice &ms) 02745 #if(CXSC_INDEX_CHECK) 02746 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02747 #else 02748 throw(); 02749 #endif 02750 02752 INLINE rmatrix operator *(const rmatrix &m1, const rmatrix &m2) 02753 #if(CXSC_INDEX_CHECK) 02754 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02755 #else 02756 throw(); 02757 #endif 02758 02759 INLINE rmatrix operator *(const rmatrix &m1, const rmatrix_slice &ms) 02760 #if(CXSC_INDEX_CHECK) 02761 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02762 #else 02763 throw(); 02764 #endif 02765 02766 INLINE rmatrix operator *(const rmatrix_slice &ms, const rmatrix &m1) 02767 #if(CXSC_INDEX_CHECK) 02768 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02769 #else 02770 throw(); 02771 #endif 02772 02773 INLINE rmatrix operator *(const rmatrix_slice &ms1, const rmatrix_slice &ms2) 02774 #if(CXSC_INDEX_CHECK) 02775 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02776 #else 02777 throw(); 02778 #endif 02779 02780 INLINE rmatrix &operator *=(rmatrix &m1,const rmatrix &m2) 02781 #if(CXSC_INDEX_CHECK) 02782 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02783 #else 02784 throw(); 02785 #endif 02786 02787 INLINE rmatrix &operator *=(rmatrix &m1,const rmatrix_slice &ms) 02788 #if(CXSC_INDEX_CHECK) 02789 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 02790 #else 02791 throw(); 02792 #endif 02793 02794 02795 02796 //============== Compare Operator ========================== 02797 02798 //-------------- Matrix - Matrix ------------------------- 02799 02801 INLINE bool operator ==(const rmatrix &m1,const rmatrix &m2) throw(); 02803 INLINE bool operator !=(const rmatrix &m1,const rmatrix &m2) throw(); 02805 INLINE bool operator <(const rmatrix &m1,const rmatrix &m2) throw(); 02807 INLINE bool operator <=(const rmatrix &m1,const rmatrix &m2) throw(); 02809 INLINE bool operator >(const rmatrix &m1,const rmatrix &m2) throw(); 02811 INLINE bool operator >=(const rmatrix &m1,const rmatrix &m2) throw(); 02813 INLINE bool operator ==(const rmatrix &m1,const rmatrix_slice &ms) throw(); 02815 INLINE bool operator !=(const rmatrix &m1,const rmatrix_slice &ms) throw(); 02817 INLINE bool operator <(const rmatrix &m1,const rmatrix_slice &ms) throw(); 02819 INLINE bool operator <=(const rmatrix &m1,const rmatrix_slice &ms) throw(); 02821 INLINE bool operator >(const rmatrix &m1,const rmatrix_slice &ms) throw(); 02823 INLINE bool operator >=(const rmatrix &m1,const rmatrix_slice &ms) throw(); 02824 02825 //---------------- Matrix - Matrix_slice ---------------------- 02826 02828 INLINE bool operator ==(const rmatrix_slice &m1,const rmatrix_slice &m2) throw(); 02830 INLINE bool operator !=(const rmatrix_slice &m1,const rmatrix_slice &m2) throw(); 02832 INLINE bool operator <(const rmatrix_slice &m1,const rmatrix_slice &m2) throw(); 02834 INLINE bool operator <=(const rmatrix_slice &m1,const rmatrix_slice &m2) throw(); 02836 INLINE bool operator >(const rmatrix_slice &m1,const rmatrix_slice &m2) throw(); 02838 INLINE bool operator >=(const rmatrix_slice &m1,const rmatrix_slice &m2) throw(); 02839 02840 //=================== Not Operator ============================= 02841 02843 INLINE bool operator !(const rmatrix &ms) throw(); 02845 INLINE bool operator !(const rmatrix_slice &ms) throw(); 02846 02847 //======================== Input / Output ======================== 02848 02850 INLINE std::ostream &operator <<(std::ostream &s,const rmatrix &r) throw(); 02852 INLINE std::ostream &operator <<(std::ostream &s,const rmatrix_slice &r) throw(); 02854 INLINE std::istream &operator >>(std::istream &s,rmatrix &r) throw(); 02856 INLINE std::istream &operator >>(std::istream &s,rmatrix_slice &r) throw(); 02857 02858 //INLINE rmatrix_subv Row(rmatrix &m,const int &i) 02859 02861 INLINE int RowLen ( const rmatrix& ); 02863 INLINE int ColLen ( const rmatrix& ); 02865 INLINE int RowLen ( const rmatrix_slice& ); 02867 INLINE int ColLen ( const rmatrix_slice& ); 02869 rmatrix Id ( const rmatrix& ); 02871 rmatrix transp ( const rmatrix& ); 02873 void DoubleSize ( rmatrix& ); 02874 02875 02876 02877 } // namespace cxsc 02878 02879 #ifdef _CXSC_INCL_INL 02880 # include "matrix.inl" 02881 # include "rmatrix.inl" 02882 #endif 02883 02884 #ifdef _CXSC_IVECTOR_HPP_INCLUDED 02885 # ifdef _CXSC_INCL_INL 02886 # include "ivecrmat.inl" 02887 # else 02888 # include "ivecrmat.hpp" 02889 # endif 02890 #endif 02891 02892 #ifdef _CXSC_CVECTOR_HPP_INCLUDED 02893 # ifdef _CXSC_INCL_INL 02894 # include "cvecrmat.inl" 02895 # else 02896 # include "cvecrmat.hpp" 02897 # endif 02898 #endif 02899 02900 #ifdef _CXSC_CIVECTOR_HPP_INCLUDED 02901 # ifdef _CXSC_INCL_INL 02902 # include "civecrmat.inl" 02903 # else 02904 # include "civecrmat.hpp" 02905 # endif 02906 #endif 02907 02908 #ifdef _CXSC_LIVECTOR_HPP_INCLUDED 02909 # ifdef _CXSC_INCL_INL 02910 # include "livecrmat.inl" 02911 # else 02912 # include "livecrmat.hpp" 02913 # endif 02914 #endif 02915 02916 #ifdef _CXSC_LRVECTOR_HPP_INCLUDED 02917 # ifdef _CXSC_INCL_INL 02918 # include "lrvecrmat.inl" 02919 # else 02920 # include "lrvecrmat.hpp" 02921 # endif 02922 #endif 02923 02924 #ifdef CXSC_USE_BLAS 02925 #define _CXSC_BLAS_RMATRIX 02926 #include "cxsc_blas.inl" 02927 #endif 02928 02929 #endif
1.7.5.1