l_rmatrix.hpp

00001 /*
00002 **  CXSC is a C++ library for eXtended Scientific Computing (V 2.5.1)
00003 **
00004 **  Copyright (C) 1990-2000 Institut fuer Angewandte Mathematik,
00005 **                          Universitaet Karlsruhe, Germany
00006 **            (C) 2000-2011 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.16 2011/06/07 15:17:40 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
Generated on Thu Jun 9 11:20:51 2011 for C-XSC - A C++ Class Library for Extended Scientific Computing by  doxygen 1.4.6