C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
l_imatrix.hpp
00001 /*
00002 **  CXSC is a C++ library for eXtended Scientific Computing (V 2.5.4)
00003 **
00004 **  Copyright (C) 1990-2000 Institut fuer Angewandte Mathematik,
00005 **                          Universitaet Karlsruhe, Germany
00006 **            (C) 2000-2014 Wiss. Rechnen/Softwaretechnologie
00007 **                          Universitaet Wuppertal, Germany   
00008 **
00009 **  This library is free software; you can redistribute it and/or
00010 **  modify it under the terms of the GNU Library General Public
00011 **  License as published by the Free Software Foundation; either
00012 **  version 2 of the License, or (at your option) any later version.
00013 **
00014 **  This library is distributed in the hope that it will be useful,
00015 **  but WITHOUT ANY WARRANTY; without even the implied warranty of
00016 **  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00017 **  Library General Public License for more details.
00018 **
00019 **  You should have received a copy of the GNU Library General Public
00020 **  License along with this library; if not, write to the Free
00021 **  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00022 */
00023 
00024 /* CVS $Id: l_imatrix.hpp,v 1.22 2014/01/30 17:23:46 cxsc Exp $ */
00025 
00026 #ifndef _CXSC_LIMATRIX_HPP_INCLUDED
00027 #define _CXSC_LIMATRIX_HPP_INCLUDED
00028 
00029 #include "xscclass.hpp"
00030 #include "idot.hpp"
00031 #include "l_ivector.hpp"
00032 #include "except.hpp"
00033 #include "matrix.hpp"
00034 #include "imatrix.hpp"
00035 #include "l_rmatrix.hpp"
00036 
00037 namespace cxsc {
00038 
00039 class l_imatrix;
00040 class l_imatrix_slice;
00041 
00043 
00046 class l_imatrix_subv
00047 {
00048         friend class l_ivector;
00049         friend class l_imatrix;
00050         friend class l_imatrix_slice;
00051         private:
00052         l_interval *dat;
00053         int lb,ub;
00054         int size,start,offset; // start=first element index 0..n-1
00055         
00056         public:
00058         friend INLINE l_imatrix_subv Row(l_imatrix &m,const int &i)
00059 #if(CXSC_INDEX_CHECK)
00060         throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT);
00061 #else
00062         throw();
00063 #endif
00064 
00065         friend INLINE l_imatrix_subv Col(l_imatrix &m,const int &i)
00066 #if(CXSC_INDEX_CHECK)
00067         throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT);
00068 #else
00069         throw();
00070 #endif
00071 
00072         friend INLINE l_imatrix_subv Row(const l_imatrix &m,const int &i)
00073 #if(CXSC_INDEX_CHECK)
00074         throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT);
00075 #else
00076         throw();
00077 #endif
00078 
00079         friend INLINE l_imatrix_subv Col(const l_imatrix &m,const int &i)
00080 #if(CXSC_INDEX_CHECK)
00081         throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT);
00082 #else
00083         throw();
00084 #endif
00085 //#if(CXSC_INDEX_CHECK)
00086 #ifdef _CXSC_FRIEND_TPL
00087         //----------------- Templates ---------------------------------------
00088 template <class MV1,class MV2> friend  MV1 &_mvmvassign(MV1 &v,const MV2 &rv)
00089 #if(CXSC_INDEX_CHECK)
00090         throw(ERROR__OP_WITH_WRONG_DIM<MV1>);
00091 #else
00092         throw();
00093 #endif
00094 template <class MV,class S> friend  MV &_mvsassign(MV &v,const  S &r) throw();
00095 template <class MV,class V> friend  MV &_mvvassign(MV &v,const V &rv)
00096 #if(CXSC_INDEX_CHECK)
00097         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00098 #else
00099         throw();
00100 #endif
00101 template <class V,class MV2,class S> friend  V &_vmvassign(V &v,const MV2 &rv) throw();
00102 template <class MV,class V> friend  MV &_mvvsetinf(MV &v,const V &rv)
00103 #if(CXSC_INDEX_CHECK)
00104         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00105 #else
00106         throw();
00107 #endif
00108 template <class MV,class V> friend  MV &_mvvsetsup(MV &v,const V &rv)
00109 #if(CXSC_INDEX_CHECK)
00110         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00111 #else
00112         throw();
00113 #endif
00114 template <class MV,class V> friend  MV &_mvvusetinf(MV &v,const V &rv)
00115 #if(CXSC_INDEX_CHECK)
00116         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00117 #else
00118         throw();
00119 #endif
00120 template <class MV,class V> friend  MV &_mvvusetsup(MV &v,const V &rv)
00121 #if(CXSC_INDEX_CHECK)
00122         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00123 #else
00124         throw();
00125 #endif
00126 template <class MV,class V> friend  MV &_mvvsetre(MV &v,const V &rv)
00127 #if(CXSC_INDEX_CHECK)
00128         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00129 #else
00130         throw();
00131 #endif
00132 template <class MV,class V> friend  MV &_mvvsetim(MV &v,const V &rv)
00133 #if(CXSC_INDEX_CHECK)
00134         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00135 #else
00136         throw();
00137 #endif
00138 template <class MV,class V> friend  V _mvabs(const MV &mv) throw();
00139 template <class MV,class V> friend  V _mvdiam(const MV &mv) throw();
00140 template <class MV,class V> friend  V _mvmid(const MV &mv) throw();
00141 template <class MV,class V> friend  V _mvinf(const MV &mv) throw();
00142 template <class MV,class V> friend  V _mvsup(const MV &mv) throw();
00143 
00144  template <class MV,class S> friend      MV &_mvssetinf(MV &mv, const S &s) throw();
00145  template <class MV,class S> friend      MV &_mvssetsup(MV &mv, const S &s) throw();
00146  template <class MV,class S> friend      MV &_mvsusetinf(MV &mv, const S &s) throw();
00147  template <class MV,class S> friend      MV &_mvsusetsup(MV &mv, const S &s) throw();
00148 
00149 template <class DP,class V,class SV> friend      void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
00150 #if(CXSC_INDEX_CHECK)
00151                 throw(OP_WITH_WRONG_DIM);
00152 #else
00153         throw();
00154 #endif
00155 template <class DP,class MV1,class MV2> friend   void _mvmvaccu(DP &dp, const MV1 & rv1, const MV2 &rv2)
00156 #if(CXSC_INDEX_CHECK)
00157                 throw(OP_WITH_WRONG_DIM);
00158 #else
00159         throw();
00160 #endif
00161  template <class MV1,class MV2,class S> friend   S _mvmvlimult(const MV1 & rv1, const MV2 &rv2)
00162 #if(CXSC_INDEX_CHECK)
00163                 throw(ERROR__OP_WITH_WRONG_DIM<MV1>);
00164 #else
00165         throw();
00166 #endif
00167  template <class V,class MV,class S> friend      S _vmvlimult(const V &rv1, const MV &rv2)
00168 #if(CXSC_INDEX_CHECK)
00169                 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00170 #else
00171         throw();
00172 #endif
00173  template <class MV,class S,class E> friend      E _mvsmult(const MV &rv, const S &s) throw();
00174  template <class MV1,class MV2,class E> friend   E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
00175 #if(CXSC_INDEX_CHECK)
00176                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00177 #else
00178         throw();
00179 #endif
00180  template <class MV1,class MV2,class E> friend   E _mvmvminus(const MV1 &rv1, const MV2 &rv2)
00181 #if(CXSC_INDEX_CHECK)
00182                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00183 #else
00184         throw();
00185 #endif
00186  template <class MV,class V,class E> friend      E _mvvplus(const MV &rv1, const V &rv2)
00187 #if(CXSC_INDEX_CHECK)
00188                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00189 #else
00190         throw();
00191 #endif
00192  template <class MV,class V,class E> friend      E _mvvminus(const MV &rv1, const V &rv2)
00193 #if(CXSC_INDEX_CHECK)
00194                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00195 #else
00196         throw();
00197 #endif
00198  template <class V,class MV,class E> friend      E _vmvminus(const V &rv1, const MV &rv2)
00199 #if(CXSC_INDEX_CHECK)
00200                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00201 #else
00202         throw();
00203 #endif
00204  template <class MV,class S,class E> friend      E _mvsdiv(const MV &rv, const S &s) throw();
00205 template <class MV,class S> friend  MV &_mvsmultassign(MV &v,const S &r) throw();
00206 template <class MV, class S> friend  MV &_mvsplusassign(MV &v,const S &r) throw();
00207 template <class MV,class S> friend  MV &_mvsminusassign(MV &v,const S &r) throw();
00208 template <class MV,class S> friend  MV &_mvsdivassign(MV &v,const S &r) throw();
00209 template <class MV,class V> friend  MV &_mvvplusassign(MV &v,const V &rv)
00210 #if(CXSC_INDEX_CHECK)
00211         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00212 #else
00213         throw();
00214 #endif
00215 template <class V,class MV> friend  V &_vmvplusassign(V &rv,const MV &v)
00216 #if(CXSC_INDEX_CHECK)
00217         throw(ERROR__OP_WITH_WRONG_DIM<V>);
00218 #else
00219         throw();
00220 #endif
00221 template <class MV,class V> friend  MV &_mvvminusassign(MV &v,const V &rv)
00222 #if(CXSC_INDEX_CHECK)
00223         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00224 #else
00225         throw();
00226 #endif
00227 template <class V,class MV> friend  V &_vmvminusassign(V &rv,const MV &v)
00228 #if(CXSC_INDEX_CHECK)
00229         throw(ERROR__OP_WITH_WRONG_DIM<V>);
00230 #else
00231         throw();
00232 #endif
00233  template <class MV1,class MV2,class E> friend   E _mvmvconv(const MV1 &rv1, const MV2 &rv2)
00234 #if(CXSC_INDEX_CHECK)
00235                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00236 #else
00237         throw();
00238 #endif
00239  template <class MV,class V,class E> friend      E _mvvconv(const MV &rv1, const V &rv2)
00240 #if(CXSC_INDEX_CHECK)
00241                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00242 #else
00243         throw();
00244 #endif
00245 template <class MV,class V> friend  MV &_mvvconvassign(MV &v,const V &rv)
00246 #if(CXSC_INDEX_CHECK)
00247         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00248 #else
00249         throw();
00250 #endif
00251  template <class MV1,class MV2,class E> friend   E _mvmvsect(const MV1 &rv1, const MV2 &rv2)
00252 #if(CXSC_INDEX_CHECK)
00253                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00254 #else
00255         throw();
00256 #endif
00257  template <class MV,class V,class E> friend      E _mvvsect(const MV &rv1, const V &rv2)
00258 #if(CXSC_INDEX_CHECK)
00259                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00260 #else
00261         throw();
00262 #endif
00263 template <class MV,class V> friend  MV &_mvvsectassign(MV &v,const V &rv)
00264 #if(CXSC_INDEX_CHECK)
00265         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00266 #else
00267         throw();
00268 #endif
00269 template <class V,class MV> friend  V &_vmvsectassign(V &rv,const MV &v)
00270 #if(CXSC_INDEX_CHECK)
00271         throw(ERROR__OP_WITH_WRONG_DIM<V>);
00272 #else
00273         throw();
00274 #endif
00275 
00276 
00277 #endif
00278 
00279         //----------------- Konstruktoren ----------------------------------
00280 
00282         explicit INLINE l_imatrix_subv (l_interval *d, const int &l, const int &u, const int &s, const int &st, const int &o) throw():dat(d),lb(l),ub(u),size(s),start(st),offset(o) { }
00283         public:
00285         INLINE l_imatrix_subv(const l_imatrix_subv &v) throw():dat(v.dat),lb(v.lb),ub(v.ub),size(v.size),start(v.start),offset(v.offset) { }
00286         public:
00287 
00288         //---------------------- Standardfunktionen ------------------------
00289 
00291         INLINE l_imatrix_subv &operator =(const l_imatrix_subv &rv) throw();
00293         INLINE l_imatrix_subv &operator =(const l_interval &r) throw();
00295         INLINE l_imatrix_subv &operator =(const l_imatrix &m)
00296 #if(CXSC_INDEX_CHECK)
00297         throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00298 #else
00299         throw();
00300 #endif
00301 
00302         INLINE l_imatrix_subv &operator =(const l_imatrix_slice &m)
00303 #if(CXSC_INDEX_CHECK)
00304         throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00305 #else
00306         throw();
00307 #endif
00308 
00309         INLINE l_imatrix_subv &operator =(const l_ivector &v)
00310 #if(CXSC_INDEX_CHECK)
00311         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00312 #else
00313         throw();
00314 #endif
00315 
00316         INLINE l_imatrix_subv &operator =(const l_ivector_slice &v)
00317 #if(CXSC_INDEX_CHECK)
00318         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00319 #else
00320         throw();
00321 #endif
00322         // Real
00324         INLINE l_imatrix_subv &operator =(const real &r) throw();
00326         INLINE l_imatrix_subv &operator =(const rmatrix &m)
00327 #if(CXSC_INDEX_CHECK)
00328         throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00329 #else
00330         throw();
00331 #endif
00332 
00333         INLINE l_imatrix_subv &operator =(const rmatrix_slice &m)
00334 #if(CXSC_INDEX_CHECK)
00335         throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00336 #else
00337         throw();
00338 #endif
00339 
00340         INLINE l_imatrix_subv &operator =(const rvector &v)
00341 #if(CXSC_INDEX_CHECK)
00342         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00343 #else
00344         throw();
00345 #endif
00346 
00347         INLINE l_imatrix_subv &operator =(const rvector_slice &v)
00348 #if(CXSC_INDEX_CHECK)
00349         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00350 #else
00351         throw();
00352 #endif
00353 
00354         INLINE l_imatrix_subv &operator =(const rmatrix_subv &rv) throw();
00355 
00356         // l_real
00358         INLINE l_imatrix_subv &operator =(const l_real &r) throw();
00360         INLINE l_imatrix_subv &operator =(const l_rmatrix &m)
00361 #if(CXSC_INDEX_CHECK)
00362         throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00363 #else
00364         throw();
00365 #endif
00366 
00367         INLINE l_imatrix_subv &operator =(const l_rmatrix_slice &m)
00368 #if(CXSC_INDEX_CHECK)
00369         throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00370 #else
00371         throw();
00372 #endif
00373 
00374         INLINE l_imatrix_subv &operator =(const l_rvector &v)
00375 #if(CXSC_INDEX_CHECK)
00376         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00377 #else
00378         throw();
00379 #endif
00380 
00381         INLINE l_imatrix_subv &operator =(const l_rvector_slice &v)
00382 #if(CXSC_INDEX_CHECK)
00383         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00384 #else
00385         throw();
00386 #endif
00387 
00388         INLINE l_imatrix_subv &operator =(const l_rmatrix_subv &rv) throw();
00389 
00390         // interval
00392         INLINE l_imatrix_subv &operator =(const interval &r) throw();
00394         INLINE l_imatrix_subv &operator =(const imatrix &m)
00395 #if(CXSC_INDEX_CHECK)
00396         throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00397 #else
00398         throw();
00399 #endif
00400 
00401         INLINE l_imatrix_subv &operator =(const imatrix_slice &m)
00402 #if(CXSC_INDEX_CHECK)
00403         throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00404 #else
00405         throw();
00406 #endif
00407 
00408         INLINE l_imatrix_subv &operator =(const ivector &v)
00409 #if(CXSC_INDEX_CHECK)
00410         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00411 #else
00412         throw();
00413 #endif
00414 
00415         INLINE l_imatrix_subv &operator =(const ivector_slice &v)
00416 #if(CXSC_INDEX_CHECK)
00417         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00418 #else
00419         throw();
00420 #endif
00421 
00422         INLINE l_imatrix_subv &operator =(const imatrix_subv &rv) throw();
00423 
00425         friend INLINE int Lb(const l_imatrix_subv &rv) throw() { return rv.lb; }
00427         friend INLINE int Ub(const l_imatrix_subv &rv) throw() { return rv.ub; }
00429         INLINE l_interval &operator [](const int &i) const
00430 #if(CXSC_INDEX_CHECK)
00431         throw(ERROR_LIVECTOR_ELEMENT_NOT_IN_VEC);
00432 #else
00433         throw();
00434 #endif
00435 
00436         INLINE l_imatrix_subv &operator ()() throw() { return *this; }
00438         INLINE l_imatrix_subv operator ()(const int &i)
00439 #if(CXSC_INDEX_CHECK)
00440         throw(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG);
00441 #else
00442         throw();
00443 #endif
00444 
00445         INLINE l_imatrix_subv operator ()(const int &i1,const int &i2)
00446 #if(CXSC_INDEX_CHECK)
00447         throw(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG);
00448 #else
00449         throw();
00450 #endif
00451         
00453         INLINE l_imatrix_subv &operator *=(const l_interval &c) throw();
00455         INLINE l_imatrix_subv &operator +=(const l_interval &c) throw();
00457         INLINE l_imatrix_subv &operator -=(const l_interval &c) throw();
00459         INLINE l_imatrix_subv &operator /=(const l_interval &c) throw();
00461         INLINE l_imatrix_subv &operator -=(const l_ivector &rv)
00462 #if(CXSC_INDEX_CHECK)
00463         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00464 #else
00465         throw();
00466 #endif
00467 
00468         INLINE l_imatrix_subv &operator +=(const l_ivector &rv)
00469 #if(CXSC_INDEX_CHECK)
00470         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00471 #else
00472         throw();
00473 #endif
00474 
00475         INLINE l_imatrix_subv &operator -=(const l_ivector_slice &rv)
00476 #if(CXSC_INDEX_CHECK)
00477         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00478 #else
00479         throw();
00480 #endif
00481 
00482         INLINE l_imatrix_subv &operator +=(const l_ivector_slice &rv)
00483 #if(CXSC_INDEX_CHECK)
00484         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00485 #else
00486         throw();
00487 #endif
00488 
00489         INLINE l_imatrix_subv &operator |=(const l_ivector &rv)
00490 #if(CXSC_INDEX_CHECK)
00491         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00492 #else
00493         throw();
00494 #endif
00495 
00496         INLINE l_imatrix_subv &operator |=(const l_ivector_slice &rv)
00497 #if(CXSC_INDEX_CHECK)
00498         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00499 #else
00500         throw();
00501 #endif
00502 
00503         INLINE l_imatrix_subv &operator &=(const l_ivector &rv)
00504 #if(CXSC_INDEX_CHECK)
00505         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00506 #else
00507         throw();
00508 #endif
00509 
00510         INLINE l_imatrix_subv &operator &=(const l_ivector_slice &rv)
00511 #if(CXSC_INDEX_CHECK)
00512         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00513 #else
00514         throw();
00515 #endif
00516         // real
00518         INLINE l_imatrix_subv &operator *=(const real &c) throw();
00520         INLINE l_imatrix_subv &operator +=(const real &c) throw();
00522         INLINE l_imatrix_subv &operator -=(const real &c) throw();
00524         INLINE l_imatrix_subv &operator /=(const real &c) throw();
00526         INLINE l_imatrix_subv &operator -=(const rvector &rv)
00527 #if(CXSC_INDEX_CHECK)
00528         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00529 #else
00530         throw();
00531 #endif
00532 
00533         INLINE l_imatrix_subv &operator +=(const rvector &rv)
00534 #if(CXSC_INDEX_CHECK)
00535         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00536 #else
00537         throw();
00538 #endif
00539 
00540         INLINE l_imatrix_subv &operator -=(const rvector_slice &rv)
00541 #if(CXSC_INDEX_CHECK)
00542         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00543 #else
00544         throw();
00545 #endif
00546 
00547         INLINE l_imatrix_subv &operator +=(const rvector_slice &rv)
00548 #if(CXSC_INDEX_CHECK)
00549         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00550 #else
00551         throw();
00552 #endif
00553 
00554         INLINE l_imatrix_subv &operator |=(const rvector &rv)
00555 #if(CXSC_INDEX_CHECK)
00556         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00557 #else
00558         throw();
00559 #endif
00560 
00561         INLINE l_imatrix_subv &operator |=(const rvector_slice &rv)
00562 #if(CXSC_INDEX_CHECK)
00563         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00564 #else
00565         throw();
00566 #endif
00567 
00568         INLINE l_imatrix_subv &operator &=(const rvector &rv)
00569 #if(CXSC_INDEX_CHECK)
00570         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00571 #else
00572         throw();
00573 #endif
00574 
00575         INLINE l_imatrix_subv &operator &=(const rvector_slice &rv)
00576 #if(CXSC_INDEX_CHECK)
00577         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00578 #else
00579         throw();
00580 #endif
00581         // l_real
00583         INLINE l_imatrix_subv &operator *=(const l_real &c) throw();
00585         INLINE l_imatrix_subv &operator +=(const l_real &c) throw();
00587         INLINE l_imatrix_subv &operator -=(const l_real &c) throw();
00589         INLINE l_imatrix_subv &operator /=(const l_real &c) throw();
00591         INLINE l_imatrix_subv &operator -=(const l_rvector &rv)
00592 #if(CXSC_INDEX_CHECK)
00593         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00594 #else
00595         throw();
00596 #endif
00597 
00598         INLINE l_imatrix_subv &operator +=(const l_rvector &rv)
00599 #if(CXSC_INDEX_CHECK)
00600         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00601 #else
00602         throw();
00603 #endif
00604 
00605         INLINE l_imatrix_subv &operator -=(const l_rvector_slice &rv)
00606 #if(CXSC_INDEX_CHECK)
00607         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00608 #else
00609         throw();
00610 #endif
00611 
00612         INLINE l_imatrix_subv &operator +=(const l_rvector_slice &rv)
00613 #if(CXSC_INDEX_CHECK)
00614         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00615 #else
00616         throw();
00617 #endif
00618 
00619         INLINE l_imatrix_subv &operator |=(const l_rvector &rv)
00620 #if(CXSC_INDEX_CHECK)
00621         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00622 #else
00623         throw();
00624 #endif
00625 
00626         INLINE l_imatrix_subv &operator |=(const l_rvector_slice &rv)
00627 #if(CXSC_INDEX_CHECK)
00628         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00629 #else
00630         throw();
00631 #endif
00632 
00633         INLINE l_imatrix_subv &operator &=(const l_rvector &rv)
00634 #if(CXSC_INDEX_CHECK)
00635         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00636 #else
00637         throw();
00638 #endif
00639 
00640         INLINE l_imatrix_subv &operator &=(const l_rvector_slice &rv)
00641 #if(CXSC_INDEX_CHECK)
00642         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00643 #else
00644         throw();
00645 #endif
00646         // interval
00648         INLINE l_imatrix_subv &operator *=(const interval &c) throw();
00650         INLINE l_imatrix_subv &operator +=(const interval &c) throw();
00652         INLINE l_imatrix_subv &operator -=(const interval &c) throw();
00654         INLINE l_imatrix_subv &operator /=(const interval &c) throw();
00656         INLINE l_imatrix_subv &operator -=(const ivector &rv)
00657 #if(CXSC_INDEX_CHECK)
00658         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00659 #else
00660         throw();
00661 #endif
00662 
00663         INLINE l_imatrix_subv &operator +=(const ivector &rv)
00664 #if(CXSC_INDEX_CHECK)
00665         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00666 #else
00667         throw();
00668 #endif
00669 
00670         INLINE l_imatrix_subv &operator -=(const ivector_slice &rv)
00671 #if(CXSC_INDEX_CHECK)
00672         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00673 #else
00674         throw();
00675 #endif
00676 
00677         INLINE l_imatrix_subv &operator +=(const ivector_slice &rv)
00678 #if(CXSC_INDEX_CHECK)
00679         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00680 #else
00681         throw();
00682 #endif
00683 
00684         INLINE l_imatrix_subv &operator |=(const ivector &rv)
00685 #if(CXSC_INDEX_CHECK)
00686         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00687 #else
00688         throw();
00689 #endif
00690 
00691         INLINE l_imatrix_subv &operator |=(const ivector_slice &rv)
00692 #if(CXSC_INDEX_CHECK)
00693         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00694 #else
00695         throw();
00696 #endif
00697 
00698         INLINE l_imatrix_subv &operator &=(const ivector &rv)
00699 #if(CXSC_INDEX_CHECK)
00700         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00701 #else
00702         throw();
00703 #endif
00704 
00705         INLINE l_imatrix_subv &operator &=(const ivector_slice &rv)
00706 #if(CXSC_INDEX_CHECK)
00707         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
00708 #else
00709         throw();
00710 #endif
00711 //#else
00712 //#endif        
00713 
00714 };
00715 
00716 
00717 //----------------------- Matrix -----------------------------------------------
00718 
00719 class l_imatrix_slice;
00720 
00722 
00725 class l_imatrix
00726 {
00727         friend class l_imatrix_slice;
00728         friend class l_imatrix_subv;
00729         private:
00730         l_interval *dat;
00731         int lb1,ub1,lb2,ub2,xsize,ysize;
00732 
00733         public:
00734 //#if(CXSC_INDEX_CHECK)
00735 #ifdef _CXSC_FRIEND_TPL
00736         //----------------- Templates ---------------------------------------
00737 template <class S,class M> friend  void _smconstr(S &s,const M &m)
00738 #if(CXSC_INDEX_CHECK)
00739         throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>,ERROR__USE_OF_UNINITIALIZED_OBJ<M>);
00740 #else
00741         throw();
00742 #endif
00743 template <class V,class M,class S> friend  void _vmconstr(V &v,const M &m)
00744 #if(CXSC_INDEX_CHECK)
00745         throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
00746 #else
00747         throw();
00748 #endif
00749  template <class M1,class M2,class S> friend     M1 &_mmassign(M1 &m1,const M2 &m,S ms) throw();
00750  template <class M,class MS2,class S> friend     M &_mmsassign(M &m,const MS2 &ms) throw();
00751  template <class MS,class M> friend      MS &_msmassign(MS &ms,const M &m)
00752 #if(CXSC_INDEX_CHECK)
00753                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00754 #else
00755         throw();
00756 #endif
00757  template <class M,class S> friend       M &_msassign(M &m,const S &r) throw();
00758 template <class V,class M,class S> friend  V &_vmassign(V &v,const M &m)
00759 #if(CXSC_INDEX_CHECK)
00760         throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
00761 #else
00762         throw();
00763 #endif
00764 template <class M,class V,class S> friend  M &_mvassign(M &m,const V &v) throw();
00765  template <class M> friend       int _mlb(const M &m, const int &i)
00766 #if(CXSC_INDEX_CHECK)
00767         throw(ERROR__WRONG_ROW_OR_COL<M>);
00768 #else
00769         throw();
00770 #endif
00771  template <class M> friend       int _mub(const M &m, const int &i)
00772 #if(CXSC_INDEX_CHECK)
00773         throw(ERROR__WRONG_ROW_OR_COL<M>);
00774 #else
00775         throw();
00776 #endif
00777  template <class M> friend       M &_msetlb(M &m, const int &i,const int &j)
00778 #if(CXSC_INDEX_CHECK)
00779         throw(ERROR__WRONG_ROW_OR_COL<M>);
00780 #else
00781         throw();
00782 #endif
00783  template <class M> friend       M &_msetub(M &m, const int &i,const int &j)
00784 #if(CXSC_INDEX_CHECK)
00785         throw(ERROR__WRONG_ROW_OR_COL<M>);
00786 #else
00787         throw();
00788 #endif
00789  template <class M> friend       void _mresize(M &A) throw();
00790  template <class M,class S> friend       void _mresize(M &A,const int &m, const int &n)
00791 #if(CXSC_INDEX_CHECK)
00792                 throw(ERROR__WRONG_BOUNDARIES<M>);
00793 #else
00794         throw();
00795 #endif
00796  template <class M,class S> friend       void _mresize(M &A,const int &m1, const int &m2,const int &n1,const int &n2)
00797 #if(CXSC_INDEX_CHECK)
00798                 throw(ERROR__WRONG_BOUNDARIES<M>);
00799 #else
00800         throw();
00801 #endif
00802  template <class M,class E> friend       E _mabs(const M &m) throw();
00803  template <class MS,class E> friend      E _msabs(const MS &ms) throw();
00804  template <class M,class E> friend       E _mdiam(const M &m) throw();
00805  template <class M,class E> friend       E _mmid(const M &m) throw();
00806  template <class M,class E> friend       E _minf(const M &m) throw();
00807  template <class M,class E> friend       E _msup(const M &m) throw();
00808  template <class M1,class M2> friend     M1 &_mmsetinf(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 M1,class M2> friend     M1 &_mmsetsup(M1 &m1,const M2 &m2)
00815 #if(CXSC_INDEX_CHECK)
00816                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00817 #else
00818         throw();
00819 #endif
00820  template <class M1,class MS2> friend    M1 &_mmssetinf(M1 &m1,const MS2 &ms2)
00821 #if(CXSC_INDEX_CHECK)
00822                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00823 #else
00824         throw();
00825 #endif
00826  template <class M1,class MS2> friend    M1 &_mmssetsup(M1 &m1,const MS2 &ms2)
00827 #if(CXSC_INDEX_CHECK)
00828                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00829 #else
00830         throw();
00831 #endif
00832  template <class M1,class M2> friend     M1 &_mmusetinf(M1 &m1,const M2 &m2)
00833 #if(CXSC_INDEX_CHECK)
00834                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00835 #else
00836         throw();
00837 #endif
00838  template <class M1,class M2> friend     M1 &_mmusetsup(M1 &m1,const M2 &m2)
00839 #if(CXSC_INDEX_CHECK)
00840                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00841 #else
00842         throw();
00843 #endif
00844  template <class M1,class MS2> friend    M1 &_mmsusetinf(M1 &m1,const MS2 &ms2)
00845 #if(CXSC_INDEX_CHECK)
00846                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00847 #else
00848         throw();
00849 #endif
00850  template <class M1,class MS2> friend    M1 &_mmsusetsup(M1 &m1,const MS2 &ms2)
00851 #if(CXSC_INDEX_CHECK)
00852                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00853 #else
00854         throw();
00855 #endif
00856         //-------------- matrix-matrix -------------
00857  template <class M1,class M2,class E> friend     E _mmplus(const M1 &m1,const M2 &m2)
00858 #if(CXSC_INDEX_CHECK)
00859                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00860 #else
00861         throw();
00862 #endif
00863  template <class M,class MS,class E> friend      E _mmsplus(const M &m,const MS &ms)
00864 #if(CXSC_INDEX_CHECK)
00865                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00866 #else
00867         throw();
00868 #endif
00869  template <class M> friend       M _mminus(const M &m) throw();
00870  template <class MS,class E> friend      E _msminus(const MS &ms) throw();
00871  template <class M1,class M2,class E> friend     E _mmminus(const M1 &m1,const M2 &m2)
00872 #if(CXSC_INDEX_CHECK)
00873                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00874 #else
00875         throw();
00876 #endif
00877  template <class M1,class M2> friend     M1 &_mmplusassign(M1 &m1,const M2 &m2)
00878 #if(CXSC_INDEX_CHECK)
00879                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00880 #else
00881         throw();
00882 #endif
00883  template <class M,class MS> friend      M &_mmsplusassign(M &m1,const MS &ms)
00884 #if(CXSC_INDEX_CHECK)
00885                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00886 #else
00887         throw();
00888 #endif
00889  template <class MS,class M> friend      MS &_msmplusassign(MS &ms,const M &m1)
00890 #if(CXSC_INDEX_CHECK)
00891                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00892 #else
00893         throw();
00894 #endif
00895  template <class MS1,class MS2,class E> friend   E _msmsplus(const MS1 &m1,const MS2 &m2)
00896 #if(CXSC_INDEX_CHECK)
00897                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00898 #else
00899         throw();
00900 #endif
00901  template <class M,class MS,class E> friend      E _mmsminus(const M &m,const MS &ms)
00902 #if(CXSC_INDEX_CHECK)
00903                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00904 #else
00905         throw();
00906 #endif
00907  template <class MS,class M,class E> friend      E _msmminus(const MS &ms,const M &m)
00908 #if(CXSC_INDEX_CHECK)
00909                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00910 #else
00911         throw();
00912 #endif
00913  template <class MS1,class MS2,class E> friend   E _msmsminus(const MS1 &ms1,const MS2 &ms2)
00914 #if(CXSC_INDEX_CHECK)
00915                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00916 #else
00917         throw();
00918 #endif
00919  template <class M1,class M2> friend     M1 &_mmminusassign(M1 &m1,const M2 &m2)
00920 #if(CXSC_INDEX_CHECK)
00921                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00922 #else
00923         throw();
00924 #endif
00925  template <class M,class MS> friend      M &_mmsminusassign(M &m1,const MS &ms)
00926 #if(CXSC_INDEX_CHECK)
00927                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00928 #else
00929         throw();
00930 #endif
00931  template <class MS,class M> friend      MS &_msmminusassign(MS &ms,const M &m1)
00932 #if(CXSC_INDEX_CHECK)
00933                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00934 #else
00935         throw();
00936 #endif
00937  template <class M1,class M2,class E> friend     E _mmlimult(const M1 &m1, const M2 &m2)
00938 #if(CXSC_INDEX_CHECK)
00939                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00940 #else
00941         throw();
00942 #endif
00943  template <class M1,class M2,class S> friend     M1 &_mmlimultassign(M1 &m1,const M2 &m2)
00944 #if(CXSC_INDEX_CHECK)
00945                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00946 #else
00947         throw();
00948 #endif
00949  template <class M,class MS,class E> friend      E _mmslimult(const M &m1, const MS &ms)
00950 #if(CXSC_INDEX_CHECK)
00951                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00952 #else
00953         throw();
00954 #endif
00955  template <class MS,class M,class E> friend      E _msmlimult(const MS &ms, const M &m2)
00956 #if(CXSC_INDEX_CHECK)
00957                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00958 #else
00959         throw();
00960 #endif
00961  template <class M,class MS,class S> friend      M &_mmslimultassign(M &m1,const MS &ms)
00962 #if(CXSC_INDEX_CHECK)
00963                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00964 #else
00965         throw();
00966 #endif
00967  template <class MS1,class MS2,class E> friend   E _msmslimult(const MS1 &ms1, const MS2 &ms2)
00968 #if(CXSC_INDEX_CHECK)
00969                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00970 #else
00971         throw();
00972 #endif
00973  template <class M1,class M2,class E> friend     E _mmconv(const M1 &m1,const M2 &m2)
00974 #if(CXSC_INDEX_CHECK)
00975                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00976 #else
00977         throw();
00978 #endif
00979  template <class M,class MS,class E> friend      E _mmsconv(const M &m,const MS &ms)
00980 #if(CXSC_INDEX_CHECK)
00981                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00982 #else
00983         throw();
00984 #endif
00985  template <class M1,class M2> friend     M1 &_mmconvassign(M1 &m1,const M2 &m2)
00986 #if(CXSC_INDEX_CHECK)
00987                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00988 #else
00989         throw();
00990 #endif
00991  template <class M,class MS> friend      M &_mmsconvassign(M &m1,const MS &ms)
00992 #if(CXSC_INDEX_CHECK)
00993                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00994 #else
00995         throw();
00996 #endif
00997  template <class MS,class M> friend      MS &_msmconvassign(MS &ms,const M &m1)
00998 #if(CXSC_INDEX_CHECK)
00999                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01000 #else
01001         throw();
01002 #endif
01003  template <class MS1,class MS2,class E> friend   E _msmsconv(const MS1 &m1,const MS2 &m2)
01004 #if(CXSC_INDEX_CHECK)
01005                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01006 #else
01007         throw();
01008 #endif
01009  template <class M1,class M2,class E> friend     E _mmsect(const M1 &m1,const M2 &m2)
01010 #if(CXSC_INDEX_CHECK)
01011                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01012 #else
01013         throw();
01014 #endif
01015  template <class M,class MS,class E> friend      E _mmssect(const M &m,const MS &ms)
01016 #if(CXSC_INDEX_CHECK)
01017                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01018 #else
01019         throw();
01020 #endif
01021  template <class M1,class M2> friend     M1 &_mmsectassign(M1 &m1,const M2 &m2)
01022 #if(CXSC_INDEX_CHECK)
01023                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01024 #else
01025         throw();
01026 #endif
01027  template <class M,class MS> friend      M &_mmssectassign(M &m1,const MS &ms)
01028 #if(CXSC_INDEX_CHECK)
01029                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01030 #else
01031         throw();
01032 #endif
01033  template <class MS,class M> friend      MS &_msmsectassign(MS &ms,const M &m1)
01034 #if(CXSC_INDEX_CHECK)
01035                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01036 #else
01037         throw();
01038 #endif
01039  template <class MS1,class MS2,class E> friend   E _msmssect(const MS1 &m1,const MS2 &m2)
01040 #if(CXSC_INDEX_CHECK)
01041                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01042 #else
01043         throw();
01044 #endif
01045         //-------- matrix-scalar -----------------
01046  template <class S,class M,class E> friend       E _smmult(const S &c, const M &m) throw();
01047  template <class M,class S> friend       M &_msmultassign(M &m,const S &c) throw();
01048  template <class S,class MS,class E> friend      E _smsmult(const S &c, const MS &ms) throw();
01049  template <class M,class S,class E> friend       E _msdiv(const M &m,const S &c) throw();
01050  template <class M,class S> friend       M &_msdivassign(M &m,const S &c) throw();
01051  template <class MS,class S,class E> friend      E _mssdiv(const MS &ms, const S &c) throw();
01052         //-------- matrix-vector ---------------------
01053  template <class M,class V,class E> friend       E _mvlimult(const M &m,const V &v)
01054 #if(CXSC_INDEX_CHECK)
01055                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01056 #else
01057         throw();
01058 #endif
01059  template <class V,class M,class E> friend       E _vmlimult(const V &v,const M &m)
01060 #if(CXSC_INDEX_CHECK)
01061                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01062 #else
01063         throw();
01064 #endif
01065  template <class V,class M,class S> friend       V &_vmlimultassign(V &v,const M &m)
01066 #if(CXSC_INDEX_CHECK)
01067                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01068 #else
01069         throw();
01070 #endif
01071  template <class VS,class M,class S> friend      VS &_vsmlimultassign(VS &v,const M &m)
01072 #if(CXSC_INDEX_CHECK)
01073                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01074 #else
01075         throw();
01076 #endif
01077         
01078  template <class M> friend       void *_mvoid(const M &m) throw();
01079  template <class M> friend       bool _mnot(const M &m) throw();
01080  template <class MS> friend      void *_msvoid(const MS &ms) throw();
01081  template <class MS> friend      bool _msnot(const MS &ms) throw();
01082  template <class M1,class M2> friend     bool _mmeq(const M1 &m1,const M2 &m2) throw();
01083  template <class M1,class M2> friend     bool _mmneq(const M1 &m1,const M2 &m2) throw();
01084  template <class M1,class M2> friend     bool _mmless(const M1 &m1,const M2 &m2) throw();
01085  template <class M1,class M2> friend     bool _mmleq(const M1 &m1,const M2 &m2) throw();
01086  template <class M,class MS> friend      bool _mmseq(const M &m1,const MS &ms) throw();
01087  template <class M,class MS> friend      bool _mmsneq(const M &m1,const MS &ms) throw();
01088  template <class M,class MS> friend      bool _mmsless(const M &m1,const MS &ms) throw();
01089  template <class M,class MS> friend      bool _mmsleq(const M &m1,const MS &ms) throw();
01090  template <class MS,class M> friend      bool _msmless(const MS &ms,const M &m1) throw();
01091  template <class MS,class M> friend      bool _msmleq(const MS &ms,const M &m1) throw();
01092  template <class M> friend      std::ostream &_mout(std::ostream &s,const M &r) throw();
01093  template <class M> friend      std::istream &_min(std::istream &s,M &r) throw();
01094 
01095         //--- Real --------- matrix-scalar ----------------------
01096  template <class M1,class MS2> friend    M1 &_mmssetre(M1 &m1,const MS2 &ms2)
01097 #if(CXSC_INDEX_CHECK)
01098                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01099 #else
01100         throw();
01101 #endif
01102  template <class M1,class MS2> friend    M1 &_mmssetim(M1 &m1,const MS2 &ms2)
01103 #if(CXSC_INDEX_CHECK)
01104                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01105 #else
01106         throw();
01107 #endif
01108 
01109         //--- Real --------- matrix-vector ----------------------
01110  template <class MS,class V,class E> friend      E _msvlimult(const MS &ms,const V &v)
01111 #if(CXSC_INDEX_CHECK)
01112                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01113 #else
01114         throw();
01115 #endif
01116  template <class V,class MS,class E> friend      E _vmslimult(const V &v,const MS &ms)
01117 #if(CXSC_INDEX_CHECK)
01118                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01119 #else
01120         throw();
01121 #endif
01122 
01123 
01124 #endif
01125         
01126         //--------------------------  Konstruktoren ----------------------------
01127 
01128 // l_interval
01130         INLINE l_imatrix(const l_imatrix &rm) throw();
01132         INLINE l_imatrix(const l_imatrix_slice &rm) throw();
01134         INLINE l_imatrix() throw();
01136         explicit INLINE l_imatrix(const int &m, const int &n)
01137 #if(CXSC_INDEX_CHECK)
01138         throw(ERROR_LIMATRIX_WRONG_BOUNDARIES);
01139 #else
01140         throw();
01141 #endif
01142 
01143         explicit INLINE l_imatrix(const int &m1, const int &n1, const int &m2, const int &n2)
01144 #if(CXSC_INDEX_CHECK)
01145         throw(ERROR_LIMATRIX_WRONG_BOUNDARIES);
01146 #else
01147         throw();
01148 #endif
01149 
01150         explicit INLINE l_imatrix(const l_ivector &v) throw();
01152         explicit INLINE l_imatrix(const l_ivector_slice &v) throw();
01154         explicit INLINE l_imatrix(const l_interval &r) throw();
01156         INLINE l_imatrix &operator =(const l_interval &r) throw();
01158         INLINE l_imatrix &operator =(const l_imatrix &m) throw();
01160         INLINE l_imatrix &operator =(const l_imatrix_slice &ms) throw();
01162         INLINE l_imatrix &operator =(const l_ivector &v) throw();
01164         INLINE l_imatrix &operator =(const l_ivector_slice &v) throw();
01165 //  real
01167         explicit INLINE l_imatrix(const real &r) throw();
01169         explicit INLINE l_imatrix(const rmatrix &rm) throw();
01171         explicit INLINE l_imatrix(const rmatrix_slice &rm) throw();
01173         explicit INLINE l_imatrix(const rvector &v) throw();
01175         explicit INLINE l_imatrix(const rvector_slice &v) throw();
01177         INLINE l_imatrix &operator =(const real &r) throw();
01179         INLINE l_imatrix &operator =(const rmatrix &m) throw();
01181         INLINE l_imatrix &operator =(const rmatrix_slice &ms) throw();
01183         INLINE l_imatrix &operator =(const rvector &v) throw();
01185         INLINE l_imatrix &operator =(const rvector_slice &v) throw();
01186 
01187 //  l_real
01189         explicit INLINE l_imatrix(const l_real &r) throw();
01191         explicit INLINE l_imatrix(const l_rmatrix &rm) throw();
01193         explicit INLINE l_imatrix(const l_rmatrix_slice &rm) throw();
01195         explicit INLINE l_imatrix(const l_rvector &v) throw();
01197         explicit INLINE l_imatrix(const l_rvector_slice &v) throw();
01199         INLINE l_imatrix &operator =(const l_real &r) throw();
01201         INLINE l_imatrix &operator =(const l_rmatrix &m) throw();
01203         INLINE l_imatrix &operator =(const l_rmatrix_slice &ms) throw();
01205         INLINE l_imatrix &operator =(const l_rvector &v) throw();
01207         INLINE l_imatrix &operator =(const l_rvector_slice &v) throw();
01208 
01209 //  interval
01211         explicit INLINE l_imatrix(const interval &r) throw();
01213         explicit INLINE l_imatrix(const imatrix &rm) throw();
01215         explicit INLINE l_imatrix(const imatrix_slice &rm) throw();
01217         explicit INLINE l_imatrix(const ivector &v) throw();
01219         explicit INLINE l_imatrix(const ivector_slice &v) throw();
01221         INLINE l_imatrix &operator =(const interval &r) throw();
01223         INLINE l_imatrix &operator =(const imatrix &m) throw();
01225         INLINE l_imatrix &operator =(const imatrix_slice &ms) throw();
01227         INLINE l_imatrix &operator =(const ivector &v) throw();
01229         INLINE l_imatrix &operator =(const ivector_slice &v) throw();
01230 
01231         //--------------------------- Destruktoren -----------------------------
01232 
01233         INLINE ~l_imatrix() throw() { delete [] dat; }
01234 
01235         //------------------------- Standardfunktionen -------------------------
01236 
01238         INLINE l_imatrix_subv operator [](const int &i) const
01239 #if(CXSC_INDEX_CHECK)
01240         throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT);
01241 #else
01242         throw();
01243 #endif
01244 
01245         INLINE l_imatrix_subv operator [](const cxscmatrix_column &i) const
01246 #if(CXSC_INDEX_CHECK)
01247         throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT);
01248 #else
01249         throw();
01250 #endif
01251 
01252         INLINE l_imatrix &operator ()() throw() { return *this; }
01254         INLINE l_imatrix_slice operator ()(const int &m, const int &n)
01255 #if(CXSC_INDEX_CHECK)
01256         throw(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG);
01257 #else
01258         throw();
01259 #endif
01260 
01261         INLINE l_imatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
01262 #if(CXSC_INDEX_CHECK)
01263         throw(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG);
01264 #else
01265         throw();
01266 #endif
01267         INLINE operator void*() throw();
01268 //#else
01269 //#endif
01270 };
01271 
01272         
01274 
01279 class l_imatrix_slice
01280 {
01281         friend class l_imatrix;
01282         private:
01283         l_interval *dat;
01284         int offset1,offset2,mxsize,mysize;
01285         int start1,end1,start2,end2,sxsize,sysize;     // slice size
01286 
01287         public:
01288 //#if(CXSC_INDEX_CHECK)
01289 #ifdef _CXSC_FRIEND_TPL
01290         //----------------- Templates ---------------------------------------
01291 template <class V,class MS,class S> friend  void _vmsconstr(V &v,const MS &m)
01292 #if(CXSC_INDEX_CHECK)
01293         throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>);
01294 #else
01295         throw();
01296 #endif
01297  template <class MS,class M> friend      MS &_msmassign(MS &ms,const M &m)
01298 #if(CXSC_INDEX_CHECK)
01299                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01300 #else
01301         throw();
01302 #endif
01303  template <class MS1,class MS2> friend   MS1 &_msmsassign(MS1 &ms1,const MS2 &ms)
01304 #if(CXSC_INDEX_CHECK)
01305                 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01306 #else
01307         throw();
01308 #endif
01309  template <class M,class MS2,class S> friend     M &_mmsassign(M &m,const MS2 &ms) throw();
01310  template <class MS,class S> friend      MS &_mssassign(MS &ms,const S &r) throw();
01311  template <class MS> friend      int _mslb(const MS &ms, const int &i)
01312 #if(CXSC_INDEX_CHECK)
01313         throw(ERROR__WRONG_ROW_OR_COL<MS>);
01314 #else
01315         throw();
01316 #endif
01317  template <class MS> friend      int _msub(const MS &ms, const int &i)
01318 #if(CXSC_INDEX_CHECK)
01319         throw(ERROR__WRONG_ROW_OR_COL<MS>);
01320 #else
01321         throw();
01322 #endif
01323  template <class MS,class E> friend      E _msabs(const MS &ms) throw();
01324  template <class MS,class E> friend      E _msinf(const MS &ms) throw();
01325  template <class MS,class E> friend      E _mssup(const MS &ms) throw();
01326  template <class MS,class E> friend      E _msdiam(const MS &ms) throw();
01327  template <class MS,class E> friend      E _msmid(const MS &ms) throw();
01328  template <class MS1,class M2> friend    MS1 &_msmsetinf(MS1 &ms1,const M2 &m2)
01329 #if(CXSC_INDEX_CHECK)
01330                 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01331 #else
01332         throw();
01333 #endif
01334  template <class MS1,class M2> friend    MS1 &_msmsetsup(MS1 &ms1,const M2 &m2)
01335 #if(CXSC_INDEX_CHECK)
01336                 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01337 #else
01338         throw();
01339 #endif
01340  template <class MS1,class MS2> friend   MS1 &_msmssetinf(MS1 &ms1,const MS2 &ms2)
01341 #if(CXSC_INDEX_CHECK)
01342                 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01343 #else
01344         throw();
01345 #endif
01346  template <class MS1,class MS2> friend   MS1 &_msmssetsup(MS1 &ms1,const MS2 &ms2)
01347 #if(CXSC_INDEX_CHECK)
01348                 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01349 #else
01350         throw();
01351 #endif
01352  template <class MS1,class M2> friend    MS1 &_msmusetinf(MS1 &ms1,const M2 &m2)
01353 #if(CXSC_INDEX_CHECK)
01354                 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01355 #else
01356         throw();
01357 #endif
01358  template <class MS1,class M2> friend    MS1 &_msmusetsup(MS1 &ms1,const M2 &m2)
01359 #if(CXSC_INDEX_CHECK)
01360                 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01361 #else
01362         throw();
01363 #endif
01364  template <class MS1,class MS2> friend   MS1 &_msmsusetinf(MS1 &ms1,const MS2 &ms2)
01365 #if(CXSC_INDEX_CHECK)
01366                 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01367 #else
01368         throw();
01369 #endif
01370  template <class MS1,class MS2> friend   MS1 &_msmsusetsup(MS1 &ms1,const MS2 &ms2)
01371 #if(CXSC_INDEX_CHECK)
01372                 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01373 #else
01374         throw();
01375 #endif
01376         //-------- matrix-matrix --------------
01377  template <class MS,class E> friend      E _msminus(const MS &ms) throw();
01378  template <class M,class MS,class E> friend      E _mmsplus(const M &m,const MS &ms)
01379 #if(CXSC_INDEX_CHECK)
01380                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01381 #else
01382         throw();
01383 #endif
01384  template <class MS1,class MS2,class E> friend   E _msmsplus(const MS1 &m1,const MS2 &m2)
01385 #if(CXSC_INDEX_CHECK)
01386                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01387 #else
01388         throw();
01389 #endif
01390  template <class M,class MS> friend      M &_mmsplusassign(M &m1,const MS &ms)
01391 #if(CXSC_INDEX_CHECK)
01392                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01393 #else
01394         throw();
01395 #endif
01396  template <class MS,class M> friend      MS &_msmplusassign(MS &ms,const M &m1)
01397 #if(CXSC_INDEX_CHECK)
01398                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01399 #else
01400         throw();
01401 #endif
01402  template <class MS1,class MS2> friend   MS1 &_msmsplusassign(MS1 &ms1,const MS2 &ms2)
01403 #if(CXSC_INDEX_CHECK)
01404                 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01405 #else
01406         throw();
01407 #endif
01408  template <class M,class MS,class E> friend      E _mmsminus(const M &m,const MS &ms)
01409 #if(CXSC_INDEX_CHECK)
01410                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01411 #else
01412         throw();
01413 #endif
01414  template <class MS,class M,class E> friend      E _msmminus(const MS &ms,const M &m)
01415 #if(CXSC_INDEX_CHECK)
01416                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01417 #else
01418         throw();
01419 #endif
01420  template <class MS1,class MS2,class E> friend   E _msmsminus(const MS1 &ms1,const MS2 &ms2)
01421 #if(CXSC_INDEX_CHECK)
01422                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01423 #else
01424         throw();
01425 #endif
01426  template <class M,class MS> friend      M &_mmsminusassign(M &m1,const MS &ms)
01427 #if(CXSC_INDEX_CHECK)
01428                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01429 #else
01430         throw();
01431 #endif
01432  template <class MS,class M> friend      MS &_msmminusassign(MS &ms,const M &m1)
01433 #if(CXSC_INDEX_CHECK)
01434                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01435 #else
01436         throw();
01437 #endif
01438  template <class MS1,class MS2> friend   MS1 &_msmsminusassign(MS1 &ms1,const MS2 &ms2)
01439 #if(CXSC_INDEX_CHECK)
01440                 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01441 #else
01442         throw();
01443 #endif
01444  template <class M,class MS,class E> friend      E _mmslimult(const M &m1, const MS &ms)
01445 #if(CXSC_INDEX_CHECK)
01446                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01447 #else
01448         throw();
01449 #endif
01450  template <class MS,class M,class E> friend      E _msmlimult(const MS &ms, const M &m2)
01451 #if(CXSC_INDEX_CHECK)
01452                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01453 #else
01454         throw();
01455 #endif
01456  template <class M,class MS,class S> friend      M &_mmslimultassign(M &m1,const MS &ms)
01457 #if(CXSC_INDEX_CHECK)
01458                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01459 #else
01460         throw();
01461 #endif
01462  template <class MS1,class MS2,class E> friend   E _msmslimult(const MS1 &ms1, const MS2 &ms2)
01463 #if(CXSC_INDEX_CHECK)
01464                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01465 #else
01466         throw();
01467 #endif
01468  template <class M,class MS,class E> friend      E _mmsconv(const M &m,const MS &ms)
01469 #if(CXSC_INDEX_CHECK)
01470                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01471 #else
01472         throw();
01473 #endif
01474  template <class M,class MS> friend      M &_mmsconvassign(M &m1,const MS &ms)
01475 #if(CXSC_INDEX_CHECK)
01476                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01477 #else
01478         throw();
01479 #endif
01480  template <class MS,class M> friend      MS &_msmconvassign(MS &ms,const M &m1)
01481 #if(CXSC_INDEX_CHECK)
01482                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01483 #else
01484         throw();
01485 #endif
01486  template <class MS1,class MS2> friend   MS1 &_msmsconvassign(MS1 &ms1,const MS2 &ms2)
01487 #if(CXSC_INDEX_CHECK)
01488                 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01489 #else
01490         throw();
01491 #endif
01492  template <class MS1,class MS2,class E> friend   E _msmsconv(const MS1 &m1,const MS2 &m2)
01493 #if(CXSC_INDEX_CHECK)
01494                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01495 #else
01496         throw();
01497 #endif
01498  template <class M,class MS,class E> friend      E _mmssect(const M &m,const MS &ms)
01499 #if(CXSC_INDEX_CHECK)
01500                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01501 #else
01502         throw();
01503 #endif
01504  template <class M,class MS> friend      M &_mmssectassign(M &m1,const MS &ms)
01505 #if(CXSC_INDEX_CHECK)
01506                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01507 #else
01508         throw();
01509 #endif
01510  template <class MS,class M> friend      MS &_msmsectassign(MS &ms,const M &m1)
01511 #if(CXSC_INDEX_CHECK)
01512                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01513 #else
01514         throw();
01515 #endif
01516  template <class MS1,class MS2> friend   MS1 &_msmssectassign(MS1 &ms1,const MS2 &ms2)
01517 #if(CXSC_INDEX_CHECK)
01518                 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01519 #else
01520         throw();
01521 #endif
01522  template <class MS1,class MS2,class E> friend   E _msmssect(const MS1 &m1,const MS2 &m2)
01523 #if(CXSC_INDEX_CHECK)
01524                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01525 #else
01526         throw();
01527 #endif
01528         //--------- matrix-vector --------------
01529  template <class MS,class V,class E> friend      E _msvlimult(const MS &ms,const V &v)
01530 #if(CXSC_INDEX_CHECK)
01531                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01532 #else
01533         throw();
01534 #endif
01535  template <class V,class MS,class E> friend      E _vmslimult(const V &v,const MS &ms)
01536 #if(CXSC_INDEX_CHECK)
01537                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01538 #else
01539         throw();
01540 #endif
01541  template <class V,class MS,class S> friend      V &_vmslimultassign(V &v,const MS &ms)
01542 #if(CXSC_INDEX_CHECK)
01543                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01544 #else
01545         throw();
01546 #endif
01547         //--------- matrix-scalar --------------
01548  template <class S,class MS,class E> friend      E _smsmult(const S &c, const MS &ms) throw();
01549  template <class MS,class S> friend      MS &_mssmultassign(MS &ms,const S &c) throw();
01550  template <class MS,class S,class E> friend      E _mssdiv(const MS &ms, const S &c) throw();
01551  template <class MS,class S> friend      MS &_mssdivassign(MS &ms,const S &c) throw();
01552         
01553  template <class MS> friend      void *_msvoid(const MS &ms) throw();
01554  template <class MS> friend      bool _msnot(const MS &ms) throw();
01555  template <class M,class MS> friend      bool _mmseq(const M &m1,const MS &ms) throw();
01556  template <class M,class MS> friend      bool _mmsneq(const M &m1,const MS &ms) throw();
01557  template <class M,class MS> friend      bool _mmsless(const M &m1,const MS &ms) throw();
01558  template <class M,class MS> friend      bool _mmsleq(const M &m1,const MS &ms) throw();
01559  template <class MS,class M> friend      bool _msmless(const MS &ms,const M &m1) throw();
01560  template <class MS,class M> friend      bool _msmleq(const MS &ms,const M &m1) throw();
01561  template <class MS1,class MS2> friend   bool _msmseq(const MS1 &ms1,const MS2 &ms2) throw();
01562  template <class MS1,class MS2> friend   bool _msmsneq(const MS1 &ms1,const MS2 &ms2) throw();
01563  template <class MS1,class MS2> friend   bool _msmsless(const MS1 &ms1,const MS2 &ms2) throw();
01564  template <class MS1,class MS2> friend   bool _msmsleq(const MS1 &ms1,const MS2 &ms2) throw();
01565  template <class MS> friend     std::ostream &_msout(std::ostream &s,const MS &r) throw();
01566  template <class MS> friend     std::istream &_msin(std::istream &s,MS &r) throw();
01567 
01568 
01569 #endif
01570 
01571         //--------------- Konstruktoren ----------------------------------------
01572 
01574         explicit INLINE l_imatrix_slice(l_imatrix &a,const int &l1,const int &u1,const int &l2, const int &u2) throw():dat(a.dat),offset1(l1-a.lb1),offset2(l2-a.lb2),mxsize(a.xsize),mysize(a.ysize),start1(l1),end1(u1),start2(l2),end2(u2),sxsize(u2-l2+1),sysize(u1-l1+1) { }
01576         explicit INLINE l_imatrix_slice(l_imatrix_slice &a,const int &l1,const int &u1,const int &l2, const int &u2) throw():dat(a.dat),offset1(a.offset1+l1-a.start1),offset2(a.offset2+l2-a.start2),mxsize(a.mxsize),mysize(a.mysize),start1(l1),end1(u1),start2(l2),end2(u2),sxsize(u2-l2+1),sysize(u1-l1+1) { }
01577         public: 
01579         INLINE l_imatrix_slice(const l_imatrix_slice &ms) throw():dat(ms.dat),offset1(ms.offset1),offset2(ms.offset2),mxsize(ms.mxsize),mysize(ms.mysize),start1(ms.start1),end1(ms.end1),start2(ms.start2),end2(ms.end2),sxsize(ms.sxsize),sysize(ms.sysize) { }
01580         public:
01581 
01582         //---------------- Standardfunktionen -----------------------------------
01583 
01584         friend INLINE l_ivector::l_ivector(const l_imatrix_slice &sl)
01585 #if(CXSC_INDEX_CHECK)
01586         throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
01587 #else
01588         throw();
01589 #endif
01590         friend INLINE l_imatrix::l_imatrix(const l_imatrix_slice &) throw();
01592         INLINE l_imatrix_slice &operator =(const l_imatrix &m)
01593 #if(CXSC_INDEX_CHECK)
01594         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01595 #else
01596         throw();
01597 #endif
01598 
01599         INLINE l_imatrix_slice &operator =(const l_imatrix_slice &ms)
01600 #if(CXSC_INDEX_CHECK)
01601         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01602 #else
01603         throw();
01604 #endif
01605 
01606         INLINE l_imatrix_slice &operator =(const l_interval &r) throw();
01608         INLINE l_imatrix_slice &operator =(const l_ivector &v)
01609 #if(CXSC_INDEX_CHECK)
01610         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01611 #else
01612         throw();
01613 #endif
01614 
01615         INLINE l_imatrix_slice &operator =(const l_ivector_slice &v)
01616 #if(CXSC_INDEX_CHECK)
01617         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01618 #else
01619         throw();
01620 #endif
01621 
01622         INLINE l_imatrix_slice &operator =(const l_imatrix_subv &v)
01623 #if(CXSC_INDEX_CHECK)
01624         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01625 #else
01626         throw();
01627 #endif
01628         // real
01630         INLINE l_imatrix_slice &operator =(const rmatrix &m)
01631 #if(CXSC_INDEX_CHECK)
01632         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01633 #else
01634         throw();
01635 #endif
01636 
01637         INLINE l_imatrix_slice &operator =(const rmatrix_slice &ms)
01638 #if(CXSC_INDEX_CHECK)
01639         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01640 #else
01641         throw();
01642 #endif
01643 
01644         INLINE l_imatrix_slice &operator =(const real &r) throw();
01646         INLINE l_imatrix_slice &operator =(const rvector &v)
01647 #if(CXSC_INDEX_CHECK)
01648         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01649 #else
01650         throw();
01651 #endif
01652 
01653         INLINE l_imatrix_slice &operator =(const rvector_slice &v)
01654 #if(CXSC_INDEX_CHECK)
01655         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01656 #else
01657         throw();
01658 #endif
01659 
01660         INLINE l_imatrix_slice &operator =(const rmatrix_subv &v)
01661 #if(CXSC_INDEX_CHECK)
01662         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01663 #else
01664         throw();
01665 #endif
01666 
01667         // interval
01669         INLINE l_imatrix_slice &operator =(const imatrix &m)
01670 #if(CXSC_INDEX_CHECK)
01671         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01672 #else
01673         throw();
01674 #endif
01675 
01676         INLINE l_imatrix_slice &operator =(const imatrix_slice &ms)
01677 #if(CXSC_INDEX_CHECK)
01678         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01679 #else
01680         throw();
01681 #endif
01682 
01683         INLINE l_imatrix_slice &operator =(const interval &r) throw();
01685         INLINE l_imatrix_slice &operator =(const ivector &v)
01686 #if(CXSC_INDEX_CHECK)
01687         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01688 #else
01689         throw();
01690 #endif
01691 
01692         INLINE l_imatrix_slice &operator =(const ivector_slice &v)
01693 #if(CXSC_INDEX_CHECK)
01694         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01695 #else
01696         throw();
01697 #endif
01698 
01699         INLINE l_imatrix_slice &operator =(const imatrix_subv &v)
01700 #if(CXSC_INDEX_CHECK)
01701         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01702 #else
01703         throw();
01704 #endif
01705 
01706         // l_real
01708         INLINE l_imatrix_slice &operator =(const l_rmatrix &m)
01709 #if(CXSC_INDEX_CHECK)
01710         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01711 #else
01712         throw();
01713 #endif
01714 
01715         INLINE l_imatrix_slice &operator =(const l_rmatrix_slice &ms)
01716 #if(CXSC_INDEX_CHECK)
01717         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01718 #else
01719         throw();
01720 #endif
01721 
01722         INLINE l_imatrix_slice &operator =(const l_real &r) throw();
01724         INLINE l_imatrix_slice &operator =(const l_rvector &v)
01725 #if(CXSC_INDEX_CHECK)
01726         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01727 #else
01728         throw();
01729 #endif
01730 
01731         INLINE l_imatrix_slice &operator =(const l_rvector_slice &v)
01732 #if(CXSC_INDEX_CHECK)
01733         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01734 #else
01735         throw();
01736 #endif
01737 
01738         INLINE l_imatrix_slice &operator =(const l_rmatrix_subv &v)
01739 #if(CXSC_INDEX_CHECK)
01740         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01741 #else
01742         throw();
01743 #endif
01744 
01746         INLINE l_imatrix_subv operator [](const int &i)
01747 #if(CXSC_INDEX_CHECK)
01748         throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT);
01749 #else
01750         throw();
01751 #endif
01752 
01753         INLINE l_imatrix_subv operator [](const cxscmatrix_column &i)
01754 #if(CXSC_INDEX_CHECK)
01755         throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT);
01756 #else
01757         throw();
01758 #endif
01759 
01760         INLINE l_imatrix_slice &operator ()() throw() { return *this; }
01762         INLINE l_imatrix_slice operator ()(const int &m, const int &n)
01763 #if(CXSC_INDEX_CHECK)
01764         throw(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG);
01765 #else
01766         throw();
01767 #endif
01768 
01769         INLINE l_imatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
01770 #if(CXSC_INDEX_CHECK)
01771         throw(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG);
01772 #else
01773         throw();
01774 #endif
01775         INLINE operator void*() throw();
01776 
01778         INLINE l_imatrix_slice &operator +=(const l_interval &c) throw();
01780         INLINE l_imatrix_slice &operator -=(const l_interval &c) throw();
01782         INLINE l_imatrix_slice &operator *=(const l_interval &c) throw();
01784         INLINE l_imatrix_slice &operator /=(const l_interval &c) throw();
01786         INLINE l_imatrix_slice &operator +=(const l_imatrix &m1)
01787 #if(CXSC_INDEX_CHECK)
01788         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01789 #else
01790         throw();
01791 #endif
01792 
01793         INLINE l_imatrix_slice &operator +=(const l_imatrix_slice &ms2)
01794 #if(CXSC_INDEX_CHECK)
01795         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01796 #else
01797         throw();
01798 #endif
01799 
01800         INLINE l_imatrix_slice &operator -=(const l_imatrix &m1)
01801 #if(CXSC_INDEX_CHECK)
01802         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01803 #else
01804         throw();
01805 #endif
01806 
01807         INLINE l_imatrix_slice &operator -=(const l_imatrix_slice &ms2)
01808 #if(CXSC_INDEX_CHECK)
01809         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01810 #else
01811         throw();
01812 #endif
01813 
01814         INLINE l_imatrix_slice &operator |=(const l_imatrix &m1)
01815 #if(CXSC_INDEX_CHECK)
01816         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01817 #else
01818         throw();
01819 #endif
01820 
01821         INLINE l_imatrix_slice &operator |=(const l_imatrix_slice &ms2)
01822 #if(CXSC_INDEX_CHECK)
01823         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01824 #else
01825         throw();
01826 #endif
01827 
01828         INLINE l_imatrix_slice &operator &=(const l_imatrix &m1)
01829 #if(CXSC_INDEX_CHECK)
01830         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01831 #else
01832         throw();
01833 #endif
01834 
01835         INLINE l_imatrix_slice &operator &=(const l_imatrix_slice &ms2)
01836 #if(CXSC_INDEX_CHECK)
01837         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01838 #else
01839         throw();
01840 #endif
01841 
01842         INLINE l_imatrix_slice &operator *=(const l_imatrix &m)
01843 #if(CXSC_INDEX_CHECK)
01844         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01845 #else
01846         throw();
01847 #endif
01848 
01849         INLINE l_imatrix_slice &operator *=(const l_imatrix_slice &ms2)
01850 #if(CXSC_INDEX_CHECK)
01851         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01852 #else
01853         throw();
01854 #endif
01855 
01857         INLINE l_imatrix_slice &operator +=(const real &c) throw();
01859         INLINE l_imatrix_slice &operator -=(const real &c) throw();
01861         INLINE l_imatrix_slice &operator *=(const real &c) throw();
01863         INLINE l_imatrix_slice &operator /=(const real &c) throw();
01865         INLINE l_imatrix_slice &operator +=(const rmatrix_slice &ms2)
01866 #if(CXSC_INDEX_CHECK)
01867         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01868 #else
01869         throw();
01870 #endif
01871 
01872         INLINE l_imatrix_slice &operator +=(const rmatrix &m1)
01873 #if(CXSC_INDEX_CHECK)
01874         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01875 #else
01876         throw();
01877 #endif
01878 
01879         INLINE l_imatrix_slice &operator -=(const rmatrix &m1)
01880 #if(CXSC_INDEX_CHECK)
01881         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01882 #else
01883         throw();
01884 #endif
01885 
01886         INLINE l_imatrix_slice &operator -=(const rmatrix_slice &ms2)
01887 #if(CXSC_INDEX_CHECK)
01888         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01889 #else
01890         throw();
01891 #endif
01892 
01893         INLINE l_imatrix_slice &operator |=(const rmatrix &m1)
01894 #if(CXSC_INDEX_CHECK)
01895         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01896 #else
01897         throw();
01898 #endif
01899 
01900         INLINE l_imatrix_slice &operator |=(const rmatrix_slice &ms2)
01901 #if(CXSC_INDEX_CHECK)
01902         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01903 #else
01904         throw();
01905 #endif
01906 
01907         INLINE l_imatrix_slice &operator &=(const rmatrix &m1)
01908 #if(CXSC_INDEX_CHECK)
01909         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01910 #else
01911         throw();
01912 #endif
01913 
01914         INLINE l_imatrix_slice &operator &=(const rmatrix_slice &ms2)
01915 #if(CXSC_INDEX_CHECK)
01916         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01917 #else
01918         throw();
01919 #endif
01920 
01921         INLINE l_imatrix_slice &operator *=(const rmatrix &m)
01922 #if(CXSC_INDEX_CHECK)
01923         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01924 #else
01925         throw();
01926 #endif
01927 
01928         INLINE l_imatrix_slice &operator *=(const rmatrix_slice &ms2)
01929 #if(CXSC_INDEX_CHECK)
01930         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01931 #else
01932         throw();
01933 #endif
01934 
01936         INLINE l_imatrix_slice &operator +=(const l_real &c) throw();
01938         INLINE l_imatrix_slice &operator -=(const l_real &c) throw();
01940         INLINE l_imatrix_slice &operator *=(const l_real &c) throw();
01942         INLINE l_imatrix_slice &operator /=(const l_real &c) throw();
01944         INLINE l_imatrix_slice &operator +=(const l_rmatrix_slice &ms2)
01945 #if(CXSC_INDEX_CHECK)
01946         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01947 #else
01948         throw();
01949 #endif
01950 
01951         INLINE l_imatrix_slice &operator +=(const l_rmatrix &m1)
01952 #if(CXSC_INDEX_CHECK)
01953         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01954 #else
01955         throw();
01956 #endif
01957 
01958         INLINE l_imatrix_slice &operator -=(const l_rmatrix &m1)
01959 #if(CXSC_INDEX_CHECK)
01960         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01961 #else
01962         throw();
01963 #endif
01964 
01965         INLINE l_imatrix_slice &operator -=(const l_rmatrix_slice &ms2)
01966 #if(CXSC_INDEX_CHECK)
01967         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01968 #else
01969         throw();
01970 #endif
01971 
01972         INLINE l_imatrix_slice &operator |=(const l_rmatrix &m1)
01973 #if(CXSC_INDEX_CHECK)
01974         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01975 #else
01976         throw();
01977 #endif
01978 
01979         INLINE l_imatrix_slice &operator |=(const l_rmatrix_slice &ms2)
01980 #if(CXSC_INDEX_CHECK)
01981         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01982 #else
01983         throw();
01984 #endif
01985 
01986         INLINE l_imatrix_slice &operator &=(const l_rmatrix &m1)
01987 #if(CXSC_INDEX_CHECK)
01988         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01989 #else
01990         throw();
01991 #endif
01992 
01993         INLINE l_imatrix_slice &operator &=(const l_rmatrix_slice &ms2)
01994 #if(CXSC_INDEX_CHECK)
01995         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01996 #else
01997         throw();
01998 #endif
01999 
02000         INLINE l_imatrix_slice &operator *=(const l_rmatrix &m)
02001 #if(CXSC_INDEX_CHECK)
02002         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02003 #else
02004         throw();
02005 #endif
02006 
02007         INLINE l_imatrix_slice &operator *=(const l_rmatrix_slice &ms2)
02008 #if(CXSC_INDEX_CHECK)
02009         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02010 #else
02011         throw();
02012 #endif
02013 
02015         INLINE l_imatrix_slice &operator +=(const interval &c) throw();
02017         INLINE l_imatrix_slice &operator -=(const interval &c) throw();
02019         INLINE l_imatrix_slice &operator *=(const interval &c) throw();
02021         INLINE l_imatrix_slice &operator /=(const interval &c) throw();
02023         INLINE l_imatrix_slice &operator +=(const imatrix_slice &ms2)
02024 #if(CXSC_INDEX_CHECK)
02025         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02026 #else
02027         throw();
02028 #endif
02029 
02030         INLINE l_imatrix_slice &operator +=(const imatrix &m1)
02031 #if(CXSC_INDEX_CHECK)
02032         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02033 #else
02034         throw();
02035 #endif
02036 
02037         INLINE l_imatrix_slice &operator -=(const imatrix &m1)
02038 #if(CXSC_INDEX_CHECK)
02039         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02040 #else
02041         throw();
02042 #endif
02043 
02044         INLINE l_imatrix_slice &operator -=(const imatrix_slice &ms2)
02045 #if(CXSC_INDEX_CHECK)
02046         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02047 #else
02048         throw();
02049 #endif
02050 
02051         INLINE l_imatrix_slice &operator |=(const imatrix &m1)
02052 #if(CXSC_INDEX_CHECK)
02053         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02054 #else
02055         throw();
02056 #endif
02057 
02058         INLINE l_imatrix_slice &operator |=(const imatrix_slice &ms2)
02059 #if(CXSC_INDEX_CHECK)
02060         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02061 #else
02062         throw();
02063 #endif
02064 
02065         INLINE l_imatrix_slice &operator &=(const imatrix &m1)
02066 #if(CXSC_INDEX_CHECK)
02067         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02068 #else
02069         throw();
02070 #endif
02071 
02072         INLINE l_imatrix_slice &operator &=(const imatrix_slice &ms2)
02073 #if(CXSC_INDEX_CHECK)
02074         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02075 #else
02076         throw();
02077 #endif
02078 
02079         INLINE l_imatrix_slice &operator *=(const imatrix &m)
02080 #if(CXSC_INDEX_CHECK)
02081         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02082 #else
02083         throw();
02084 #endif
02085 
02086         INLINE l_imatrix_slice &operator *=(const imatrix_slice &ms2)
02087 #if(CXSC_INDEX_CHECK)
02088         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02089 #else
02090         throw();
02091 #endif
02092 
02093 //#else
02094 //#endif
02095 };
02096 
02097 //================================================================
02098 //====================== Subvector Functions =====================
02099 
02100 //=======================Vector / Scalar =========================
02101 
02103         INLINE l_ivector operator /(const l_imatrix_subv &rv, const l_interval &s) throw();
02105         INLINE l_ivector operator *(const l_imatrix_subv &rv, const l_interval &s) throw();
02107         INLINE l_ivector operator *(const l_interval &s, const l_imatrix_subv &rv) throw();
02109         INLINE l_ivector abs(const l_imatrix_subv &mv) throw();
02111         INLINE l_rvector diam(const l_imatrix_subv &mv) throw();
02113         INLINE l_rvector mid(const l_imatrix_subv &mv) throw();
02115         INLINE l_rvector Inf(const l_imatrix_subv &mv) throw();
02117         INLINE l_rvector Sup(const l_imatrix_subv &mv) throw();
02119         INLINE l_imatrix_subv &SetInf(l_imatrix_subv &iv,const l_rvector &rv)
02120 #if(CXSC_INDEX_CHECK)
02121         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02122 #else
02123         throw();
02124 #endif
02125 
02126         INLINE l_imatrix_subv &SetSup(l_imatrix_subv &iv,const l_rvector &rv)
02127 #if(CXSC_INDEX_CHECK)
02128         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02129 #else
02130         throw();
02131 #endif
02132 
02133         INLINE l_imatrix_subv &UncheckedSetInf(l_imatrix_subv &iv,const l_rvector &rv)
02134 #if(CXSC_INDEX_CHECK)
02135         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02136 #else
02137         throw();
02138 #endif
02139 
02140         INLINE l_imatrix_subv &UncheckedSetSup(l_imatrix_subv &iv,const l_rvector &rv)
02141 #if(CXSC_INDEX_CHECK)
02142         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02143 #else
02144         throw();
02145 #endif
02146 
02148         INLINE l_imatrix_subv &SetSup(l_imatrix_subv &iv,const l_real &r) throw();
02150         INLINE l_imatrix_subv &SetInf(l_imatrix_subv &iv,const l_real &r) throw();
02152         INLINE l_imatrix_subv &UncheckedSetSup(l_imatrix_subv &iv,const l_real &r) throw();
02154         INLINE l_imatrix_subv &SetUncheckedInf(l_imatrix_subv &iv,const l_real &r) throw();
02155 
02156 //======================== Vector / Vector ========================
02157 
02158         
02160         INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_imatrix_subv &rv2)
02161 #if(CXSC_INDEX_CHECK)
02162         throw(OP_WITH_WRONG_DIM);
02163 #else
02164         throw();
02165 #endif
02166 
02167         INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const l_imatrix_subv &rv2)
02168 #if(CXSC_INDEX_CHECK)
02169         throw(OP_WITH_WRONG_DIM);
02170 #else
02171         throw();
02172 #endif
02173 
02174         INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_ivector &rv2)
02175 #if(CXSC_INDEX_CHECK)
02176         throw(OP_WITH_WRONG_DIM);
02177 #else
02178         throw();
02179 #endif
02180 
02181         INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl1, const l_imatrix_subv &rv2)
02182 #if(CXSC_INDEX_CHECK)
02183         throw(OP_WITH_WRONG_DIM);
02184 #else
02185         throw();
02186 #endif
02187 
02188         INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_ivector_slice &sl2)
02189 #if(CXSC_INDEX_CHECK)
02190         throw(OP_WITH_WRONG_DIM);
02191 #else
02192         throw();
02193 #endif
02194         
02196         INLINE l_interval operator *(const l_imatrix_subv & rv1, const l_imatrix_subv &rv2)
02197 #if(CXSC_INDEX_CHECK)
02198         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
02199 #else
02200         throw();
02201 #endif
02202 
02203         INLINE l_interval operator *(const l_ivector & rv1, const l_imatrix_subv &rv2)
02204 #if(CXSC_INDEX_CHECK)
02205         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
02206 #else
02207         throw();
02208 #endif
02209 
02210         INLINE l_interval operator *(const l_imatrix_subv &rv1,const l_ivector &rv2)
02211 #if(CXSC_INDEX_CHECK)
02212         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
02213 #else
02214         throw();
02215 #endif
02216 
02217         INLINE l_interval operator *(const l_ivector_slice &sl,const l_imatrix_subv &sv)
02218 #if(CXSC_INDEX_CHECK)
02219         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
02220 #else
02221         throw();
02222 #endif
02223 
02224         INLINE l_interval operator *(const l_imatrix_subv &mv,const l_ivector_slice &vs)
02225 #if(CXSC_INDEX_CHECK)
02226         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
02227 #else
02228         throw();
02229 #endif
02230 
02232         INLINE l_ivector operator +(const l_imatrix_subv & rv1, const l_imatrix_subv &rv2)
02233 #if(CXSC_INDEX_CHECK)
02234         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
02235 #else
02236         throw();
02237 #endif
02238 
02239         INLINE l_ivector operator +(const l_imatrix_subv &rv1,const l_ivector &rv2)
02240 #if(CXSC_INDEX_CHECK)
02241         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
02242 #else
02243         throw();
02244 #endif
02245 
02246         INLINE l_ivector operator +(const l_ivector & rv1, const l_imatrix_subv &rv2)
02247 #if(CXSC_INDEX_CHECK)
02248         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
02249 #else
02250         throw();
02251 #endif
02252 
02253         INLINE l_ivector operator +(const l_ivector_slice &sl,const l_imatrix_subv &mv)
02254 #if(CXSC_INDEX_CHECK)
02255         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
02256 #else
02257         throw();
02258 #endif
02259 
02260         INLINE l_ivector operator +(const l_imatrix_subv &mv,const l_ivector_slice &sl)
02261 #if(CXSC_INDEX_CHECK)
02262         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
02263 #else
02264         throw();
02265 #endif
02266         
02268         INLINE l_ivector operator -(const l_imatrix_subv & rv1, const l_imatrix_subv &rv2)
02269 #if(CXSC_INDEX_CHECK)
02270         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
02271 #else
02272         throw();
02273 #endif
02274 
02275         INLINE l_ivector operator -(const l_ivector & rv1, const l_imatrix_subv &rv2)
02276 #if(CXSC_INDEX_CHECK)
02277         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
02278 #else
02279         throw();
02280 #endif
02281 
02282         INLINE l_ivector operator -(const l_imatrix_subv &rv1,const l_ivector &rv2)
02283 #if(CXSC_INDEX_CHECK)
02284         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
02285 #else
02286         throw();
02287 #endif
02288 
02289         INLINE l_ivector operator -(const l_ivector_slice &sl,const l_imatrix_subv &mv)
02290 #if(CXSC_INDEX_CHECK)
02291         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
02292 #else
02293         throw();
02294 #endif
02295 
02296         INLINE l_ivector operator -(const l_imatrix_subv &mv,const l_ivector_slice &sl)
02297 #if(CXSC_INDEX_CHECK)
02298         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
02299 #else
02300         throw();
02301 #endif
02302 
02303 //  real
02304 
02306         INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const rmatrix_subv &rv2)
02307 #if(CXSC_INDEX_CHECK)
02308         throw(OP_WITH_WRONG_DIM);
02309 #else
02310         throw();
02311 #endif
02312 
02313         INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const rvector_slice &sl2)
02314 #if(CXSC_INDEX_CHECK)
02315         throw(OP_WITH_WRONG_DIM);
02316 #else
02317         throw();
02318 #endif
02319 
02320         INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const rvector &rv2)
02321 #if(CXSC_INDEX_CHECK)
02322         throw(OP_WITH_WRONG_DIM);
02323 #else
02324         throw();
02325 #endif
02326 
02327         INLINE void accumulate(idotprecision &dp, const rvector & rv1, const l_imatrix_subv &rv2)
02328 #if(CXSC_INDEX_CHECK)
02329         throw(OP_WITH_WRONG_DIM);
02330 #else
02331         throw();
02332 #endif
02333 
02334         INLINE void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const l_imatrix_subv &rv2)
02335 #if(CXSC_INDEX_CHECK)
02336         throw(OP_WITH_WRONG_DIM);
02337 #else
02338         throw();
02339 #endif
02340 
02341         INLINE void accumulate(idotprecision &dp, const rvector_slice & sl1, const l_imatrix_subv &rv2)
02342 #if(CXSC_INDEX_CHECK)
02343         throw(OP_WITH_WRONG_DIM);
02344 #else
02345         throw();
02346 #endif
02347         
02348 // l_real
02349 
02351         INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_rmatrix_subv &rv2)
02352 #if(CXSC_INDEX_CHECK)
02353         throw(OP_WITH_WRONG_DIM);
02354 #else
02355         throw();
02356 #endif
02357 
02358         INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_rvector_slice &sl2)
02359 #if(CXSC_INDEX_CHECK)
02360         throw(OP_WITH_WRONG_DIM);
02361 #else
02362         throw();
02363 #endif
02364 
02365         INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_rvector &rv2)
02366 #if(CXSC_INDEX_CHECK)
02367         throw(OP_WITH_WRONG_DIM);
02368 #else
02369         throw();
02370 #endif
02371 
02372         INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const l_imatrix_subv &rv2)
02373 #if(CXSC_INDEX_CHECK)
02374         throw(OP_WITH_WRONG_DIM);
02375 #else
02376         throw();
02377 #endif
02378 
02379         INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const l_imatrix_subv &rv2)
02380 #if(CXSC_INDEX_CHECK)
02381         throw(OP_WITH_WRONG_DIM);
02382 #else
02383         throw();
02384 #endif
02385 
02386         INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl1, const l_imatrix_subv &rv2)
02387 #if(CXSC_INDEX_CHECK)
02388         throw(OP_WITH_WRONG_DIM);
02389 #else
02390         throw();
02391 #endif
02392         
02393 // interval
02394 
02396         INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const imatrix_subv &rv2)
02397 #if(CXSC_INDEX_CHECK)
02398         throw(OP_WITH_WRONG_DIM);
02399 #else
02400         throw();
02401 #endif
02402 
02403         INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const ivector_slice &sl2)
02404 #if(CXSC_INDEX_CHECK)
02405         throw(OP_WITH_WRONG_DIM);
02406 #else
02407         throw();
02408 #endif
02409 
02410         INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const ivector &rv2)
02411 #if(CXSC_INDEX_CHECK)
02412         throw(OP_WITH_WRONG_DIM);
02413 #else
02414         throw();
02415 #endif
02416 
02417         INLINE void accumulate(idotprecision &dp, const ivector & rv1, const l_imatrix_subv &rv2)
02418 #if(CXSC_INDEX_CHECK)
02419         throw(OP_WITH_WRONG_DIM);
02420 #else
02421         throw();
02422 #endif
02423 
02424         INLINE void accumulate(idotprecision &dp, const imatrix_subv & rv1, const l_imatrix_subv &rv2)
02425 #if(CXSC_INDEX_CHECK)
02426         throw(OP_WITH_WRONG_DIM);
02427 #else
02428         throw();
02429 #endif
02430 
02431         INLINE void accumulate(idotprecision &dp, const ivector_slice & sl1, const l_imatrix_subv &rv2)
02432 #if(CXSC_INDEX_CHECK)
02433         throw(OP_WITH_WRONG_DIM);
02434 #else
02435         throw();
02436 #endif
02437         
02438 
02439 //====================================================================
02440 //===================== Matrix Functions =============================
02441 
02443         INLINE l_imatrix _imatrix(const l_imatrix &rm) throw();
02445         INLINE l_imatrix _imatrix(const l_ivector &v) throw();
02447         INLINE l_imatrix _imatrix(const l_ivector_slice &v) throw();
02449         INLINE l_imatrix _imatrix(const l_interval &r) throw();
02450 
02452         INLINE int Lb(const l_imatrix &rm, const int &i)
02453 #if(CXSC_INDEX_CHECK)
02454         throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL);
02455 #else
02456         throw();
02457 #endif
02458 
02459         INLINE int Ub(const l_imatrix &rm, const int &i)
02460 #if(CXSC_INDEX_CHECK)
02461         throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL);
02462 #else
02463         throw();
02464 #endif
02465 
02466         INLINE int Lb(const l_imatrix_slice &rm, const int &i)
02467 #if(CXSC_INDEX_CHECK)
02468         throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL);
02469 #else
02470         throw();
02471 #endif
02472 
02473         INLINE int Ub(const l_imatrix_slice &rm, const int &i)
02474 #if(CXSC_INDEX_CHECK)
02475         throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL);
02476 #else
02477         throw();
02478 #endif
02479 
02480         INLINE l_imatrix &SetLb(l_imatrix &m, const int &i,const int &j)
02481 #if(CXSC_INDEX_CHECK)
02482         throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL);
02483 #else
02484         throw();
02485 #endif
02486 
02487         INLINE l_imatrix &SetUb(l_imatrix &m, const int &i,const int &j)
02488 #if(CXSC_INDEX_CHECK)
02489         throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL);
02490 #else
02491         throw();
02492 #endif
02493 
02494         INLINE void Resize(l_imatrix &A) throw();
02496         INLINE void Resize(l_imatrix &A,const int &m, const int &n)
02497 #if(CXSC_INDEX_CHECK)
02498         throw(ERROR_LIMATRIX_WRONG_BOUNDARIES);
02499 #else
02500         throw();
02501 #endif
02502 
02503         INLINE void Resize(l_imatrix &A,const int &m1, const int &m2,const int &n1,const int &n2)
02504 #if(CXSC_INDEX_CHECK)
02505         throw(ERROR_LIMATRIX_WRONG_BOUNDARIES);
02506 #else
02507         throw();
02508 #endif
02509 
02511         INLINE l_imatrix abs(const l_imatrix &m) throw();
02513         INLINE l_imatrix abs(const l_imatrix_slice &ms) throw();
02515         INLINE l_rmatrix diam(const l_imatrix &m) throw();
02517         INLINE l_rmatrix diam(const l_imatrix_slice &m) throw();
02519         INLINE l_rmatrix mid(const l_imatrix &m) throw();
02521         INLINE l_rmatrix mid(const l_imatrix_slice &m) throw();
02523         INLINE l_rmatrix Inf(const l_imatrix &m) throw();
02525         INLINE l_rmatrix Sup(const l_imatrix &m) throw();
02527         INLINE l_rmatrix Inf(const l_imatrix_slice &m) throw();
02529         INLINE l_rmatrix Sup(const l_imatrix_slice &m) throw();
02531         INLINE l_imatrix &SetInf(l_imatrix &cm,const l_rmatrix &rm)
02532 #if(CXSC_INDEX_CHECK)
02533         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02534 #else
02535         throw();
02536 #endif
02537 
02538         INLINE l_imatrix_slice &SetInf(l_imatrix_slice &cm,const l_rmatrix &rm)
02539 #if(CXSC_INDEX_CHECK)
02540         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02541 #else
02542         throw();
02543 #endif
02544 
02545         INLINE l_imatrix &SetInf(l_imatrix &cm,const l_rmatrix_slice &rm)
02546 #if(CXSC_INDEX_CHECK)
02547         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02548 #else
02549         throw();
02550 #endif
02551 
02552         INLINE l_imatrix_slice &SetInf(l_imatrix_slice &cm,const l_rmatrix_slice &rm)
02553 #if(CXSC_INDEX_CHECK)
02554         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02555 #else
02556         throw();
02557 #endif
02558 
02559         INLINE l_imatrix &SetSup(l_imatrix &cm,const l_rmatrix &rm)
02560 #if(CXSC_INDEX_CHECK)
02561         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02562 #else
02563         throw();
02564 #endif
02565 
02566         INLINE l_imatrix_slice &SetSup(l_imatrix_slice &cm,const l_rmatrix &rm)
02567 #if(CXSC_INDEX_CHECK)
02568         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02569 #else
02570         throw();
02571 #endif
02572 
02573         INLINE l_imatrix &SetSup(l_imatrix &cm,const l_rmatrix_slice &rm)
02574 #if(CXSC_INDEX_CHECK)
02575         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02576 #else
02577         throw();
02578 #endif
02579 
02580         INLINE l_imatrix_slice &SetSup(l_imatrix_slice &cm,const l_rmatrix_slice &rm)
02581 #if(CXSC_INDEX_CHECK)
02582         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02583 #else
02584         throw();
02585 #endif
02586 
02587         INLINE l_imatrix &UncheckedSetInf(l_imatrix &cm,const l_rmatrix &rm)
02588 #if(CXSC_INDEX_CHECK)
02589         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02590 #else
02591         throw();
02592 #endif
02593 
02594         INLINE l_imatrix_slice &UncheckedSetInf(l_imatrix_slice &cm,const l_rmatrix &rm)
02595 #if(CXSC_INDEX_CHECK)
02596         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02597 #else
02598         throw();
02599 #endif
02600 
02601         INLINE l_imatrix &UncheckedSetInf(l_imatrix &cm,const l_rmatrix_slice &rm)
02602 #if(CXSC_INDEX_CHECK)
02603         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02604 #else
02605         throw();
02606 #endif
02607 
02608         INLINE l_imatrix_slice &UncheckedSetInf(l_imatrix_slice &cm,const l_rmatrix_slice &rm)
02609 #if(CXSC_INDEX_CHECK)
02610         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02611 #else
02612         throw();
02613 #endif
02614 
02615         INLINE l_imatrix &UncheckedSetSup(l_imatrix &cm,const l_rmatrix &rm)
02616 #if(CXSC_INDEX_CHECK)
02617         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02618 #else
02619         throw();
02620 #endif
02621 
02622         INLINE l_imatrix_slice &UncheckedSetSup(l_imatrix_slice &cm,const l_rmatrix &rm)
02623 #if(CXSC_INDEX_CHECK)
02624         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02625 #else
02626         throw();
02627 #endif
02628 
02629         INLINE l_imatrix &UncheckedSetSup(l_imatrix &cm,const l_rmatrix_slice &rm)
02630 #if(CXSC_INDEX_CHECK)
02631         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02632 #else
02633         throw();
02634 #endif
02635 
02636         INLINE l_imatrix_slice &UncheckedSetSup(l_imatrix_slice &cm,const l_rmatrix_slice &rm)
02637 #if(CXSC_INDEX_CHECK)
02638         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02639 #else
02640         throw();
02641 #endif
02642 
02643 //===================== Matrix / Scalar ===============================
02644 
02646         INLINE l_imatrix operator *(const l_interval &c, const l_imatrix &m) throw();
02648         INLINE l_imatrix operator *(const l_interval &c, const l_imatrix_slice &ms) throw();
02650         INLINE l_imatrix operator *(const l_imatrix &m,const l_interval &c) throw();
02652         INLINE l_imatrix operator *(const l_imatrix_slice &ms,const l_interval &c) throw();
02654         INLINE l_imatrix &operator *=(l_imatrix &m,const l_interval &c) throw();
02656         INLINE l_imatrix operator /(const l_imatrix &m,const l_interval &c) throw();
02658         INLINE l_imatrix operator /(const l_imatrix_slice &ms, const l_interval &c) throw();
02660         INLINE l_imatrix &operator /=(l_imatrix &m,const l_interval &c) throw();
02661         
02662 //------------ real - l_imatrix -----------------------------------------------
02663 
02665         INLINE l_imatrix operator *(const real &c, const l_imatrix &m) throw();
02667         INLINE l_imatrix operator *(const real &c, const l_imatrix_slice &ms) throw();
02669         INLINE l_imatrix operator *(const l_imatrix &m,const real &c) throw();
02671         INLINE l_imatrix operator *(const l_imatrix_slice &ms,const real &c) throw();
02673         INLINE l_imatrix &operator *=(l_imatrix &m,const real &c) throw();
02675         INLINE l_imatrix operator /(const l_imatrix &m,const real &c) throw();
02677         INLINE l_imatrix operator /(const l_imatrix_slice &ms, const real &c) throw();
02679         INLINE l_imatrix &operator /=(l_imatrix &m,const real &c) throw();
02680 //----------------- rmatrix - l_interval ----------------
02681 
02683         INLINE l_imatrix operator *(const l_interval &c, const rmatrix &m) throw();
02685         INLINE l_imatrix operator *(const l_interval &c, const rmatrix_slice &ms) throw();
02687         INLINE l_imatrix operator *(const rmatrix &m,const l_interval &c) throw();
02689         INLINE l_imatrix operator *(const rmatrix_slice &ms,const l_interval &c) throw();
02691         INLINE l_imatrix operator /(const rmatrix &m,const l_interval &c) throw();
02693         INLINE l_imatrix operator /(const rmatrix_slice &ms, const l_interval &c) throw();
02694         
02695 //------------ l_real - l_imatrix -----------------------------------------------
02696 
02698         INLINE l_imatrix operator *(const l_real &c, const l_imatrix &m) throw();
02700         INLINE l_imatrix operator *(const l_real &c, const l_imatrix_slice &ms) throw();
02702         INLINE l_imatrix operator *(const l_imatrix &m,const l_real &c) throw();
02704         INLINE l_imatrix operator *(const l_imatrix_slice &ms,const l_real &c) throw();
02706         INLINE l_imatrix &operator *=(l_imatrix &m,const l_real &c) throw();
02708         INLINE l_imatrix operator /(const l_imatrix &m,const l_real &c) throw();
02710         INLINE l_imatrix operator /(const l_imatrix_slice &ms, const l_real &c) throw();
02712         INLINE l_imatrix &operator /=(l_imatrix &m,const l_real &c) throw();
02713 //----------------- l_rmatrix - l_interval ----------------
02714 
02716         INLINE l_imatrix operator *(const l_interval &c, const l_rmatrix &m) throw();
02718         INLINE l_imatrix operator *(const l_interval &c, const l_rmatrix_slice &ms) throw();
02720         INLINE l_imatrix operator *(const l_rmatrix &m,const l_interval &c) throw();
02722         INLINE l_imatrix operator *(const l_rmatrix_slice &ms,const l_interval &c) throw();
02724         INLINE l_imatrix operator /(const l_rmatrix &m,const l_interval &c) throw();
02726         INLINE l_imatrix operator /(const l_rmatrix_slice &ms, const l_interval &c) throw();
02727         
02728 //------------ interval - l_imatrix -----------------------------------------------
02729 
02731         INLINE l_imatrix operator *(const interval &c, const l_imatrix &m) throw();
02733         INLINE l_imatrix operator *(const interval &c, const l_imatrix_slice &ms) throw();
02735         INLINE l_imatrix operator *(const l_imatrix &m,const interval &c) throw();
02737         INLINE l_imatrix operator *(const l_imatrix_slice &ms,const interval &c) throw();
02739         INLINE l_imatrix &operator *=(l_imatrix &m,const interval &c) throw();
02741         INLINE l_imatrix operator /(const l_imatrix &m,const interval &c) throw();
02743         INLINE l_imatrix operator /(const l_imatrix_slice &ms, const interval &c) throw();
02745         INLINE l_imatrix &operator /=(l_imatrix &m,const interval &c) throw();
02746 //----------------- imatrix - l_interval ----------------
02747 
02749         INLINE l_imatrix operator *(const l_interval &c, const imatrix &m) throw();
02751         INLINE l_imatrix operator *(const l_interval &c, const imatrix_slice &ms) throw();
02753         INLINE l_imatrix operator *(const imatrix &m,const l_interval &c) throw();
02755         INLINE l_imatrix operator *(const imatrix_slice &ms,const l_interval &c) throw();
02757         INLINE l_imatrix operator /(const imatrix &m,const l_interval &c) throw();
02759         INLINE l_imatrix operator /(const imatrix_slice &ms, const l_interval &c) throw();
02760         
02761 
02762 //============================ Matrix / Vector ===================================
02763 
02764 
02766         INLINE l_ivector operator *(const l_imatrix &m,const l_ivector &v)
02767 #if(CXSC_INDEX_CHECK)
02768         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02769 #else
02770         throw();
02771 #endif
02772 
02773         INLINE l_ivector operator *(const l_imatrix_slice &ms,const l_ivector &v)
02774 #if(CXSC_INDEX_CHECK)
02775         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02776 #else
02777         throw();
02778 #endif
02779 
02780         INLINE l_ivector operator *(const l_ivector &v,const l_imatrix &m)
02781 #if(CXSC_INDEX_CHECK)
02782         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02783 #else
02784         throw();
02785 #endif
02786 
02787         INLINE l_ivector operator *(const l_ivector &v,const l_imatrix_slice &ms)
02788 #if(CXSC_INDEX_CHECK)
02789         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02790 #else
02791         throw();
02792 #endif
02793 
02794         INLINE l_ivector &operator *=(l_ivector &v,const l_imatrix &m)
02795 #if(CXSC_INDEX_CHECK)
02796         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02797 #else
02798         throw();
02799 #endif
02800 
02801         INLINE l_ivector &operator *=(l_ivector &v,const l_imatrix_slice &ms)
02802 #if(CXSC_INDEX_CHECK)
02803         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02804 #else
02805         throw();
02806 #endif
02807 
02809         INLINE l_ivector operator *(const l_ivector_slice &v,const l_imatrix &m)
02810 #if(CXSC_INDEX_CHECK)
02811         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02812 #else
02813         throw();
02814 #endif
02815 
02816         INLINE l_ivector operator *(const l_ivector_slice &v,const l_imatrix_slice &m)
02817 #if(CXSC_INDEX_CHECK)
02818         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02819 #else
02820         throw();
02821 #endif
02822         
02823 //----------------- real -------------------------------------
02824 
02826         INLINE l_ivector operator *(const rvector &v,const l_imatrix &m)
02827 #if(CXSC_INDEX_CHECK)
02828         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02829 #else
02830         throw();
02831 #endif
02832 
02833         INLINE l_ivector operator *(const rvector &v,const l_imatrix_slice &ms)
02834 #if(CXSC_INDEX_CHECK)
02835         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02836 #else
02837         throw();
02838 #endif
02839 
02840         INLINE l_ivector operator *(const rvector_slice &v,const l_imatrix &m)
02841 #if(CXSC_INDEX_CHECK)
02842         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02843 #else
02844         throw();
02845 #endif
02846         
02848         INLINE l_ivector operator *(const l_imatrix &m,const rvector &v)
02849 #if(CXSC_INDEX_CHECK)
02850         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02851 #else
02852         throw();
02853 #endif
02854 
02855         INLINE l_ivector operator *(const l_imatrix_slice &ms,const rvector &v)
02856 #if(CXSC_INDEX_CHECK)
02857         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02858 #else
02859         throw();
02860 #endif
02861         
02862 //----------------- l_real -------------------------------------
02863 
02865         INLINE l_ivector operator *(const l_rvector &v,const l_imatrix &m)
02866 #if(CXSC_INDEX_CHECK)
02867         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02868 #else
02869         throw();
02870 #endif
02871 
02872         INLINE l_ivector operator *(const l_rvector &v,const l_imatrix_slice &ms)
02873 #if(CXSC_INDEX_CHECK)
02874         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02875 #else
02876         throw();
02877 #endif
02878 
02879         INLINE l_ivector operator *(const l_rvector_slice &v,const l_imatrix &m)
02880 #if(CXSC_INDEX_CHECK)
02881         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02882 #else
02883         throw();
02884 #endif
02885         
02887         INLINE l_ivector operator *(const l_imatrix &m,const l_rvector &v)
02888 #if(CXSC_INDEX_CHECK)
02889         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02890 #else
02891         throw();
02892 #endif
02893 
02894         INLINE l_ivector operator *(const l_imatrix_slice &ms,const l_rvector &v)
02895 #if(CXSC_INDEX_CHECK)
02896         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02897 #else
02898         throw();
02899 #endif
02900         
02901 //----------------- interval -------------------------------------
02902 
02904         INLINE l_ivector operator *(const ivector &v,const l_imatrix &m)
02905 #if(CXSC_INDEX_CHECK)
02906         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02907 #else
02908         throw();
02909 #endif
02910 
02911         INLINE l_ivector operator *(const ivector &v,const l_imatrix_slice &ms)
02912 #if(CXSC_INDEX_CHECK)
02913         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02914 #else
02915         throw();
02916 #endif
02917 
02918         INLINE l_ivector operator *(const ivector_slice &v,const l_imatrix &m)
02919 #if(CXSC_INDEX_CHECK)
02920         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02921 #else
02922         throw();
02923 #endif
02924         
02926         INLINE l_ivector operator *(const l_imatrix &m,const ivector &v)
02927 #if(CXSC_INDEX_CHECK)
02928         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02929 #else
02930         throw();
02931 #endif
02932 
02933         INLINE l_ivector operator *(const l_imatrix_slice &ms,const ivector &v)
02934 #if(CXSC_INDEX_CHECK)
02935         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02936 #else
02937         throw();
02938 #endif
02939         
02940 
02941 //================ Matrix / Matrix ============================
02942 
02944         INLINE const l_imatrix &operator +(const l_imatrix &m1) throw();
02946         INLINE l_imatrix operator +(const l_imatrix_slice &ms) throw();
02948         INLINE l_imatrix operator +(const l_imatrix &m1,const l_imatrix &m2)
02949 #if(CXSC_INDEX_CHECK)
02950         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02951 #else
02952         throw();
02953 #endif
02954 
02955         INLINE l_imatrix operator +(const l_imatrix &m,const l_imatrix_slice &ms)
02956 #if(CXSC_INDEX_CHECK)
02957         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02958 #else
02959         throw();
02960 #endif
02961 
02962         INLINE l_imatrix operator +(const l_imatrix_slice &ms,const l_imatrix &m)
02963 #if(CXSC_INDEX_CHECK)
02964         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02965 #else
02966         throw();
02967 #endif
02968 
02969         INLINE l_imatrix operator +(const l_imatrix_slice &m1,const l_imatrix_slice &m2)
02970 #if(CXSC_INDEX_CHECK)
02971         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02972 #else
02973         throw();
02974 #endif
02975 
02976         INLINE l_imatrix &operator +=(l_imatrix &m1,const l_imatrix &m2)
02977 #if(CXSC_INDEX_CHECK)
02978         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02979 #else
02980         throw();
02981 #endif
02982 
02983         INLINE l_imatrix &operator +=(l_imatrix &m1,const l_imatrix_slice &ms)
02984 #if(CXSC_INDEX_CHECK)
02985         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02986 #else
02987         throw();
02988 #endif
02989         
02991         INLINE l_imatrix operator -(const l_imatrix &m) throw();
02993         INLINE l_imatrix operator -(const l_imatrix_slice &ms) throw();
02995         INLINE l_imatrix operator -(const l_imatrix &m1,const l_imatrix &m2)
02996 #if(CXSC_INDEX_CHECK)
02997         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
02998 #else
02999         throw();
03000 #endif
03001 
03002         INLINE l_imatrix operator -(const l_imatrix &m,const l_imatrix_slice &ms)
03003 #if(CXSC_INDEX_CHECK)
03004         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03005 #else
03006         throw();
03007 #endif
03008 
03009         INLINE l_imatrix operator -(const l_imatrix_slice &ms,const l_imatrix &m)
03010 #if(CXSC_INDEX_CHECK)
03011         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03012 #else
03013         throw();
03014 #endif
03015 
03016         INLINE l_imatrix operator -(const l_imatrix_slice &ms1,const l_imatrix_slice &ms2)
03017 #if(CXSC_INDEX_CHECK)
03018         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03019 #else
03020         throw();
03021 #endif
03022 
03023         INLINE l_imatrix &operator -=(l_imatrix &m1,const l_imatrix &m2)
03024 #if(CXSC_INDEX_CHECK)
03025         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03026 #else
03027         throw();
03028 #endif
03029 
03030         INLINE l_imatrix &operator -=(l_imatrix &m1,const l_imatrix_slice &ms)
03031 #if(CXSC_INDEX_CHECK)
03032         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03033 #else
03034         throw();
03035 #endif
03036         
03038         INLINE l_imatrix operator *(const l_imatrix &m1, const l_imatrix &m2)
03039 #if(CXSC_INDEX_CHECK)
03040         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03041 #else
03042         throw();
03043 #endif
03044 
03045         INLINE l_imatrix operator *(const l_imatrix &m1, const l_imatrix_slice &ms)
03046 #if(CXSC_INDEX_CHECK)
03047         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03048 #else
03049         throw();
03050 #endif
03051 
03052         INLINE l_imatrix operator *(const l_imatrix_slice &ms, const l_imatrix &m1)
03053 #if(CXSC_INDEX_CHECK)
03054         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03055 #else
03056         throw();
03057 #endif
03058 
03059         INLINE l_imatrix operator *(const l_imatrix_slice &ms1, const l_imatrix_slice &ms2)
03060 #if(CXSC_INDEX_CHECK)
03061         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03062 #else
03063         throw();
03064 #endif
03065 
03066         INLINE l_imatrix &operator *=(l_imatrix &m1,const l_imatrix &m2)
03067 #if(CXSC_INDEX_CHECK)
03068         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03069 #else
03070         throw();
03071 #endif
03072 
03073         INLINE l_imatrix &operator *=(l_imatrix &m1,const l_imatrix_slice &ms)
03074 #if(CXSC_INDEX_CHECK)
03075         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03076 #else
03077         throw();
03078 #endif
03079         
03080         
03082         INLINE l_imatrix operator |(const l_imatrix &m1,const l_imatrix &m2)
03083 #if(CXSC_INDEX_CHECK)
03084         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03085 #else
03086         throw();
03087 #endif
03088 
03089         INLINE l_imatrix operator |(const l_imatrix &m,const l_imatrix_slice &ms)
03090 #if(CXSC_INDEX_CHECK)
03091         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03092 #else
03093         throw();
03094 #endif
03095 
03096         INLINE l_imatrix operator |(const l_imatrix_slice &ms,const l_imatrix &m)
03097 #if(CXSC_INDEX_CHECK)
03098         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03099 #else
03100         throw();
03101 #endif
03102 
03103         INLINE l_imatrix operator |(const l_imatrix_slice &m1,const l_imatrix_slice &m2)
03104 #if(CXSC_INDEX_CHECK)
03105         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03106 #else
03107         throw();
03108 #endif
03109 
03110         INLINE l_imatrix &operator |=(l_imatrix &m1,const l_imatrix &m2)
03111 #if(CXSC_INDEX_CHECK)
03112         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03113 #else
03114         throw();
03115 #endif
03116 
03117         INLINE l_imatrix &operator |=(l_imatrix &m1,const l_imatrix_slice &ms)
03118 #if(CXSC_INDEX_CHECK)
03119         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03120 #else
03121         throw();
03122 #endif
03123         
03125         INLINE l_imatrix operator &(const l_imatrix &m1,const l_imatrix &m2)
03126 #if(CXSC_INDEX_CHECK)
03127         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03128 #else
03129         throw();
03130 #endif
03131 
03132         INLINE l_imatrix operator &(const l_imatrix &m,const l_imatrix_slice &ms)
03133 #if(CXSC_INDEX_CHECK)
03134         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03135 #else
03136         throw();
03137 #endif
03138 
03139         INLINE l_imatrix operator &(const l_imatrix_slice &ms,const l_imatrix &m)
03140 #if(CXSC_INDEX_CHECK)
03141         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03142 #else
03143         throw();
03144 #endif
03145 
03146         INLINE l_imatrix operator &(const l_imatrix_slice &m1,const l_imatrix_slice &m2)
03147 #if(CXSC_INDEX_CHECK)
03148         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03149 #else
03150         throw();
03151 #endif
03152 
03153         INLINE l_imatrix &operator &=(l_imatrix &m1,const l_imatrix &m2)
03154 #if(CXSC_INDEX_CHECK)
03155         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03156 #else
03157         throw();
03158 #endif
03159 
03160         INLINE l_imatrix &operator &=(l_imatrix &m1,const l_imatrix_slice &ms)
03161 #if(CXSC_INDEX_CHECK)
03162         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03163 #else
03164         throw();
03165 #endif
03166         
03167         //---------- rmatrix-l_imatrix ------------------
03169         INLINE l_imatrix operator +(const rmatrix &m1,const l_imatrix &m2)
03170 #if(CXSC_INDEX_CHECK)
03171         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03172 #else
03173         throw();
03174 #endif
03175 
03176         INLINE l_imatrix operator +(const l_imatrix &m1,const rmatrix &m2)
03177 #if(CXSC_INDEX_CHECK)
03178         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03179 #else
03180         throw();
03181 #endif
03182 
03183         INLINE l_imatrix operator +(const rmatrix &m,const l_imatrix_slice &ms)
03184 #if(CXSC_INDEX_CHECK)
03185         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03186 #else
03187         throw();
03188 #endif
03189 
03190         INLINE l_imatrix operator +(const l_imatrix &m,const rmatrix_slice &ms)
03191 #if(CXSC_INDEX_CHECK)
03192         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03193 #else
03194         throw();
03195 #endif
03196 
03197         INLINE l_imatrix operator +(const rmatrix_slice &ms,const l_imatrix &m)
03198 #if(CXSC_INDEX_CHECK)
03199         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03200 #else
03201         throw();
03202 #endif
03203 
03204         INLINE l_imatrix operator +(const l_imatrix_slice &ms,const rmatrix &m)
03205 #if(CXSC_INDEX_CHECK)
03206         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03207 #else
03208         throw();
03209 #endif
03210 
03211         INLINE l_imatrix operator +(const rmatrix_slice &m1,const l_imatrix_slice &m2)
03212 #if(CXSC_INDEX_CHECK)
03213         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03214 #else
03215         throw();
03216 #endif
03217 
03218         INLINE l_imatrix operator +(const l_imatrix_slice &m1,const rmatrix_slice &m2)
03219 #if(CXSC_INDEX_CHECK)
03220         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03221 #else
03222         throw();
03223 #endif
03224 
03225         INLINE l_imatrix &operator +=(l_imatrix &m1,const rmatrix &m2)
03226 #if(CXSC_INDEX_CHECK)
03227         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03228 #else
03229         throw();
03230 #endif
03231 
03232         INLINE l_imatrix &operator +=(l_imatrix &m1,const rmatrix_slice &ms)
03233 #if(CXSC_INDEX_CHECK)
03234         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03235 #else
03236         throw();
03237 #endif
03238         
03240         INLINE l_imatrix operator -(const rmatrix &m1,const l_imatrix &m2)
03241 #if(CXSC_INDEX_CHECK)
03242         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03243 #else
03244         throw();
03245 #endif
03246 
03247         INLINE l_imatrix operator -(const l_imatrix &m1,const rmatrix &m2)
03248 #if(CXSC_INDEX_CHECK)
03249         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03250 #else
03251         throw();
03252 #endif
03253 
03254         INLINE l_imatrix operator -(const rmatrix &m,const l_imatrix_slice &ms)
03255 #if(CXSC_INDEX_CHECK)
03256         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03257 #else
03258         throw();
03259 #endif
03260 
03261         INLINE l_imatrix operator -(const l_imatrix &m,const rmatrix_slice &ms)
03262 #if(CXSC_INDEX_CHECK)
03263         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03264 #else
03265         throw();
03266 #endif
03267 
03268         INLINE l_imatrix operator -(const rmatrix_slice &ms,const l_imatrix &m)
03269 #if(CXSC_INDEX_CHECK)
03270         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03271 #else
03272         throw();
03273 #endif
03274 
03275         INLINE l_imatrix operator -(const l_imatrix_slice &ms,const rmatrix &m)
03276 #if(CXSC_INDEX_CHECK)
03277         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03278 #else
03279         throw();
03280 #endif
03281 
03282         INLINE l_imatrix operator -(const rmatrix_slice &ms1,const l_imatrix_slice &ms2)
03283 #if(CXSC_INDEX_CHECK)
03284         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03285 #else
03286         throw();
03287 #endif
03288 
03289         INLINE l_imatrix operator -(const l_imatrix_slice &ms1,const rmatrix_slice &ms2)
03290 #if(CXSC_INDEX_CHECK)
03291         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03292 #else
03293         throw();
03294 #endif
03295 
03296         INLINE l_imatrix &operator -=(l_imatrix &m1,const rmatrix &m2)
03297 #if(CXSC_INDEX_CHECK)
03298         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03299 #else
03300         throw();
03301 #endif
03302 
03303         INLINE l_imatrix &operator -=(l_imatrix &m1,const rmatrix_slice &ms)
03304 #if(CXSC_INDEX_CHECK)
03305         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03306 #else
03307         throw();
03308 #endif
03309         
03311         INLINE l_imatrix operator *(const rmatrix &m1, const l_imatrix &m2)
03312 #if(CXSC_INDEX_CHECK)
03313         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03314 #else
03315         throw();
03316 #endif
03317 
03318         INLINE l_imatrix operator *(const l_imatrix &m1, const rmatrix &m2)
03319 #if(CXSC_INDEX_CHECK)
03320         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03321 #else
03322         throw();
03323 #endif
03324 
03325         INLINE l_imatrix operator *(const rmatrix &m1, const l_imatrix_slice &ms)
03326 #if(CXSC_INDEX_CHECK)
03327         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03328 #else
03329         throw();
03330 #endif
03331 
03332         INLINE l_imatrix operator *(const l_imatrix &m1, const rmatrix_slice &ms)
03333 #if(CXSC_INDEX_CHECK)
03334         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03335 #else
03336         throw();
03337 #endif
03338 
03339         INLINE l_imatrix operator *(const rmatrix_slice &ms, const l_imatrix &m1)
03340 #if(CXSC_INDEX_CHECK)
03341         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03342 #else
03343         throw();
03344 #endif
03345 
03346         INLINE l_imatrix operator *(const l_imatrix_slice &ms, const rmatrix &m1)
03347 #if(CXSC_INDEX_CHECK)
03348         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03349 #else
03350         throw();
03351 #endif
03352 
03353         INLINE l_imatrix operator *(const rmatrix_slice &ms1, const l_imatrix_slice &ms2)
03354 #if(CXSC_INDEX_CHECK)
03355         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03356 #else
03357         throw();
03358 #endif
03359 
03360         INLINE l_imatrix operator *(const l_imatrix_slice &ms1, const rmatrix_slice &ms2)
03361 #if(CXSC_INDEX_CHECK)
03362         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03363 #else
03364         throw();
03365 #endif
03366 
03367         INLINE l_imatrix &operator *=(l_imatrix &m1,const rmatrix &m2)
03368 #if(CXSC_INDEX_CHECK)
03369         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03370 #else
03371         throw();
03372 #endif
03373 
03374         INLINE l_imatrix &operator *=(l_imatrix &m1,const rmatrix_slice &ms)
03375 #if(CXSC_INDEX_CHECK)
03376         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03377 #else
03378         throw();
03379 #endif
03380         
03382         INLINE l_imatrix operator |(const rmatrix &m1,const l_imatrix &m2)
03383 #if(CXSC_INDEX_CHECK)
03384         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03385 #else
03386         throw();
03387 #endif
03388 
03389         INLINE l_imatrix operator |(const l_imatrix &m1,const rmatrix &m2)
03390 #if(CXSC_INDEX_CHECK)
03391         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03392 #else
03393         throw();
03394 #endif
03395 
03396         INLINE l_imatrix operator |(const rmatrix &m,const l_imatrix_slice &ms)
03397 #if(CXSC_INDEX_CHECK)
03398         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03399 #else
03400         throw();
03401 #endif
03402 
03403         INLINE l_imatrix operator |(const l_imatrix &m,const rmatrix_slice &ms)
03404 #if(CXSC_INDEX_CHECK)
03405         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03406 #else
03407         throw();
03408 #endif
03409 
03410         INLINE l_imatrix operator |(const rmatrix_slice &ms,const l_imatrix &m)
03411 #if(CXSC_INDEX_CHECK)
03412         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03413 #else
03414         throw();
03415 #endif
03416 
03417         INLINE l_imatrix operator |(const l_imatrix_slice &ms,const rmatrix &m)
03418 #if(CXSC_INDEX_CHECK)
03419         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03420 #else
03421         throw();
03422 #endif
03423 
03424         INLINE l_imatrix operator |(const rmatrix_slice &m1,const l_imatrix_slice &m2)
03425 #if(CXSC_INDEX_CHECK)
03426         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03427 #else
03428         throw();
03429 #endif
03430 
03431         INLINE l_imatrix operator |(const l_imatrix_slice &m1,const rmatrix_slice &m2)
03432 #if(CXSC_INDEX_CHECK)
03433         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03434 #else
03435         throw();
03436 #endif
03437 
03438         INLINE l_imatrix &operator |=(l_imatrix &m1,const rmatrix &m2)
03439 #if(CXSC_INDEX_CHECK)
03440         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03441 #else
03442         throw();
03443 #endif
03444 
03445         INLINE l_imatrix &operator |=(l_imatrix &m1,const rmatrix_slice &ms)
03446 #if(CXSC_INDEX_CHECK)
03447         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03448 #else
03449         throw();
03450 #endif
03451         
03453         INLINE l_imatrix operator &(const rmatrix &m1,const l_imatrix &m2)
03454 #if(CXSC_INDEX_CHECK)
03455         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03456 #else
03457         throw();
03458 #endif
03459 
03460         INLINE l_imatrix operator &(const l_imatrix &m1,const rmatrix &m2)
03461 #if(CXSC_INDEX_CHECK)
03462         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03463 #else
03464         throw();
03465 #endif
03466 
03467         INLINE l_imatrix operator &(const rmatrix &m,const l_imatrix_slice &ms)
03468 #if(CXSC_INDEX_CHECK)
03469         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03470 #else
03471         throw();
03472 #endif
03473 
03474         INLINE l_imatrix operator &(const l_imatrix &m,const rmatrix_slice &ms)
03475 #if(CXSC_INDEX_CHECK)
03476         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03477 #else
03478         throw();
03479 #endif
03480 
03481         INLINE l_imatrix operator &(const rmatrix_slice &ms,const l_imatrix &m)
03482 #if(CXSC_INDEX_CHECK)
03483         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03484 #else
03485         throw();
03486 #endif
03487 
03488         INLINE l_imatrix operator &(const l_imatrix_slice &ms,const rmatrix &m)
03489 #if(CXSC_INDEX_CHECK)
03490         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03491 #else
03492         throw();
03493 #endif
03494 
03495         INLINE l_imatrix operator &(const rmatrix_slice &m1,const l_imatrix_slice &m2)
03496 #if(CXSC_INDEX_CHECK)
03497         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03498 #else
03499         throw();
03500 #endif
03501 
03502         INLINE l_imatrix operator &(const l_imatrix_slice &m1,const rmatrix_slice &m2)
03503 #if(CXSC_INDEX_CHECK)
03504         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03505 #else
03506         throw();
03507 #endif
03508 
03509         INLINE l_imatrix &operator &=(l_imatrix &m1,const rmatrix &m2)
03510 #if(CXSC_INDEX_CHECK)
03511         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03512 #else
03513         throw();
03514 #endif
03515 
03516         INLINE l_imatrix &operator &=(l_imatrix &m1,const rmatrix_slice &ms)
03517 #if(CXSC_INDEX_CHECK)
03518         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03519 #else
03520         throw();
03521 #endif
03522         
03523         //---------- l_rmatrix-l_imatrix ------------------
03525         INLINE l_imatrix operator +(const l_rmatrix &m1,const l_imatrix &m2)
03526 #if(CXSC_INDEX_CHECK)
03527         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03528 #else
03529         throw();
03530 #endif
03531 
03532         INLINE l_imatrix operator +(const l_imatrix &m1,const l_rmatrix &m2)
03533 #if(CXSC_INDEX_CHECK)
03534         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03535 #else
03536         throw();
03537 #endif
03538 
03539         INLINE l_imatrix operator +(const l_rmatrix &m,const l_imatrix_slice &ms)
03540 #if(CXSC_INDEX_CHECK)
03541         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03542 #else
03543         throw();
03544 #endif
03545 
03546         INLINE l_imatrix operator +(const l_imatrix &m,const l_rmatrix_slice &ms)
03547 #if(CXSC_INDEX_CHECK)
03548         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03549 #else
03550         throw();
03551 #endif
03552 
03553         INLINE l_imatrix operator +(const l_rmatrix_slice &ms,const l_imatrix &m)
03554 #if(CXSC_INDEX_CHECK)
03555         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03556 #else
03557         throw();
03558 #endif
03559 
03560         INLINE l_imatrix operator +(const l_imatrix_slice &ms,const l_rmatrix &m)
03561 #if(CXSC_INDEX_CHECK)
03562         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03563 #else
03564         throw();
03565 #endif
03566 
03567         INLINE l_imatrix operator +(const l_rmatrix_slice &m1,const l_imatrix_slice &m2)
03568 #if(CXSC_INDEX_CHECK)
03569         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03570 #else
03571         throw();
03572 #endif
03573 
03574         INLINE l_imatrix operator +(const l_imatrix_slice &m1,const l_rmatrix_slice &m2)
03575 #if(CXSC_INDEX_CHECK)
03576         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03577 #else
03578         throw();
03579 #endif
03580 
03581         INLINE l_imatrix &operator +=(l_imatrix &m1,const l_rmatrix &m2)
03582 #if(CXSC_INDEX_CHECK)
03583         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03584 #else
03585         throw();
03586 #endif
03587 
03588         INLINE l_imatrix &operator +=(l_imatrix &m1,const l_rmatrix_slice &ms)
03589 #if(CXSC_INDEX_CHECK)
03590         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03591 #else
03592         throw();
03593 #endif
03594         
03596         INLINE l_imatrix operator -(const l_rmatrix &m1,const l_imatrix &m2)
03597 #if(CXSC_INDEX_CHECK)
03598         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03599 #else
03600         throw();
03601 #endif
03602 
03603         INLINE l_imatrix operator -(const l_imatrix &m1,const l_rmatrix &m2)
03604 #if(CXSC_INDEX_CHECK)
03605         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03606 #else
03607         throw();
03608 #endif
03609 
03610         INLINE l_imatrix operator -(const l_rmatrix &m,const l_imatrix_slice &ms)
03611 #if(CXSC_INDEX_CHECK)
03612         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03613 #else
03614         throw();
03615 #endif
03616 
03617         INLINE l_imatrix operator -(const l_imatrix &m,const l_rmatrix_slice &ms)
03618 #if(CXSC_INDEX_CHECK)
03619         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03620 #else
03621         throw();
03622 #endif
03623 
03624         INLINE l_imatrix operator -(const l_rmatrix_slice &ms,const l_imatrix &m)
03625 #if(CXSC_INDEX_CHECK)
03626         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03627 #else
03628         throw();
03629 #endif
03630 
03631         INLINE l_imatrix operator -(const l_imatrix_slice &ms,const l_rmatrix &m)
03632 #if(CXSC_INDEX_CHECK)
03633         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03634 #else
03635         throw();
03636 #endif
03637 
03638         INLINE l_imatrix operator -(const l_rmatrix_slice &ms1,const l_imatrix_slice &ms2)
03639 #if(CXSC_INDEX_CHECK)
03640         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03641 #else
03642         throw();
03643 #endif
03644 
03645         INLINE l_imatrix operator -(const l_imatrix_slice &ms1,const l_rmatrix_slice &ms2)
03646 #if(CXSC_INDEX_CHECK)
03647         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03648 #else
03649         throw();
03650 #endif
03651 
03652         INLINE l_imatrix &operator -=(l_imatrix &m1,const l_rmatrix &m2)
03653 #if(CXSC_INDEX_CHECK)
03654         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03655 #else
03656         throw();
03657 #endif
03658 
03659         INLINE l_imatrix &operator -=(l_imatrix &m1,const l_rmatrix_slice &ms)
03660 #if(CXSC_INDEX_CHECK)
03661         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03662 #else
03663         throw();
03664 #endif
03665         
03667         INLINE l_imatrix operator *(const l_rmatrix &m1, const l_imatrix &m2)
03668 #if(CXSC_INDEX_CHECK)
03669         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03670 #else
03671         throw();
03672 #endif
03673 
03674         INLINE l_imatrix operator *(const l_imatrix &m1, const l_rmatrix &m2)
03675 #if(CXSC_INDEX_CHECK)
03676         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03677 #else
03678         throw();
03679 #endif
03680 
03681         INLINE l_imatrix operator *(const l_rmatrix &m1, const l_imatrix_slice &ms)
03682 #if(CXSC_INDEX_CHECK)
03683         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03684 #else
03685         throw();
03686 #endif
03687 
03688         INLINE l_imatrix operator *(const l_imatrix &m1, const l_rmatrix_slice &ms)
03689 #if(CXSC_INDEX_CHECK)
03690         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03691 #else
03692         throw();
03693 #endif
03694 
03695         INLINE l_imatrix operator *(const l_rmatrix_slice &ms, const l_imatrix &m1)
03696 #if(CXSC_INDEX_CHECK)
03697         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03698 #else
03699         throw();
03700 #endif
03701 
03702         INLINE l_imatrix operator *(const l_imatrix_slice &ms, const l_rmatrix &m1)
03703 #if(CXSC_INDEX_CHECK)
03704         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03705 #else
03706         throw();
03707 #endif
03708 
03709         INLINE l_imatrix operator *(const l_rmatrix_slice &ms1, const l_imatrix_slice &ms2)
03710 #if(CXSC_INDEX_CHECK)
03711         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03712 #else
03713         throw();
03714 #endif
03715 
03716         INLINE l_imatrix operator *(const l_imatrix_slice &ms1, const l_rmatrix_slice &ms2)
03717 #if(CXSC_INDEX_CHECK)
03718         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03719 #else
03720         throw();
03721 #endif
03722 
03723         INLINE l_imatrix &operator *=(l_imatrix &m1,const l_rmatrix &m2)
03724 #if(CXSC_INDEX_CHECK)
03725         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03726 #else
03727         throw();
03728 #endif
03729 
03730         INLINE l_imatrix &operator *=(l_imatrix &m1,const l_rmatrix_slice &ms)
03731 #if(CXSC_INDEX_CHECK)
03732         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03733 #else
03734         throw();
03735 #endif
03736         
03738         INLINE l_imatrix operator |(const l_rmatrix &m1,const l_imatrix &m2)
03739 #if(CXSC_INDEX_CHECK)
03740         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03741 #else
03742         throw();
03743 #endif
03744 
03745         INLINE l_imatrix operator |(const l_imatrix &m1,const l_rmatrix &m2)
03746 #if(CXSC_INDEX_CHECK)
03747         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03748 #else
03749         throw();
03750 #endif
03751 
03752         INLINE l_imatrix operator |(const l_rmatrix &m,const l_imatrix_slice &ms)
03753 #if(CXSC_INDEX_CHECK)
03754         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03755 #else
03756         throw();
03757 #endif
03758 
03759         INLINE l_imatrix operator |(const l_imatrix &m,const l_rmatrix_slice &ms)
03760 #if(CXSC_INDEX_CHECK)
03761         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03762 #else
03763         throw();
03764 #endif
03765 
03766         INLINE l_imatrix operator |(const l_rmatrix_slice &ms,const l_imatrix &m)
03767 #if(CXSC_INDEX_CHECK)
03768         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03769 #else
03770         throw();
03771 #endif
03772 
03773         INLINE l_imatrix operator |(const l_imatrix_slice &ms,const l_rmatrix &m)
03774 #if(CXSC_INDEX_CHECK)
03775         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03776 #else
03777         throw();
03778 #endif
03779 
03780         INLINE l_imatrix operator |(const l_rmatrix_slice &m1,const l_imatrix_slice &m2)
03781 #if(CXSC_INDEX_CHECK)
03782         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03783 #else
03784         throw();
03785 #endif
03786 
03787         INLINE l_imatrix operator |(const l_imatrix_slice &m1,const l_rmatrix_slice &m2)
03788 #if(CXSC_INDEX_CHECK)
03789         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03790 #else
03791         throw();
03792 #endif
03793 
03794         INLINE l_imatrix &operator |=(l_imatrix &m1,const l_rmatrix &m2)
03795 #if(CXSC_INDEX_CHECK)
03796         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03797 #else
03798         throw();
03799 #endif
03800 
03801         INLINE l_imatrix &operator |=(l_imatrix &m1,const l_rmatrix_slice &ms)
03802 #if(CXSC_INDEX_CHECK)
03803         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03804 #else
03805         throw();
03806 #endif
03807         
03809         INLINE l_imatrix operator &(const l_rmatrix &m1,const l_imatrix &m2)
03810 #if(CXSC_INDEX_CHECK)
03811         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03812 #else
03813         throw();
03814 #endif
03815 
03816         INLINE l_imatrix operator &(const l_imatrix &m1,const l_rmatrix &m2)
03817 #if(CXSC_INDEX_CHECK)
03818         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03819 #else
03820         throw();
03821 #endif
03822 
03823         INLINE l_imatrix operator &(const l_rmatrix &m,const l_imatrix_slice &ms)
03824 #if(CXSC_INDEX_CHECK)
03825         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03826 #else
03827         throw();
03828 #endif
03829 
03830         INLINE l_imatrix operator &(const l_imatrix &m,const l_rmatrix_slice &ms)
03831 #if(CXSC_INDEX_CHECK)
03832         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03833 #else
03834         throw();
03835 #endif
03836 
03837         INLINE l_imatrix operator &(const l_rmatrix_slice &ms,const l_imatrix &m)
03838 #if(CXSC_INDEX_CHECK)
03839         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03840 #else
03841         throw();
03842 #endif
03843 
03844         INLINE l_imatrix operator &(const l_imatrix_slice &ms,const l_rmatrix &m)
03845 #if(CXSC_INDEX_CHECK)
03846         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03847 #else
03848         throw();
03849 #endif
03850 
03851         INLINE l_imatrix operator &(const l_rmatrix_slice &m1,const l_imatrix_slice &m2)
03852 #if(CXSC_INDEX_CHECK)
03853         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03854 #else
03855         throw();
03856 #endif
03857 
03858         INLINE l_imatrix operator &(const l_imatrix_slice &m1,const l_rmatrix_slice &m2)
03859 #if(CXSC_INDEX_CHECK)
03860         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03861 #else
03862         throw();
03863 #endif
03864 
03865         INLINE l_imatrix &operator &=(l_imatrix &m1,const l_rmatrix &m2)
03866 #if(CXSC_INDEX_CHECK)
03867         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03868 #else
03869         throw();
03870 #endif
03871 
03872         INLINE l_imatrix &operator &=(l_imatrix &m1,const l_rmatrix_slice &ms)
03873 #if(CXSC_INDEX_CHECK)
03874         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03875 #else
03876         throw();
03877 #endif
03878         
03879         //---------- imatrix-l_imatrix ------------------
03881         INLINE l_imatrix operator +(const imatrix &m1,const l_imatrix &m2)
03882 #if(CXSC_INDEX_CHECK)
03883         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03884 #else
03885         throw();
03886 #endif
03887 
03888         INLINE l_imatrix operator +(const l_imatrix &m1,const imatrix &m2)
03889 #if(CXSC_INDEX_CHECK)
03890         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03891 #else
03892         throw();
03893 #endif
03894 
03895         INLINE l_imatrix operator +(const imatrix &m,const l_imatrix_slice &ms)
03896 #if(CXSC_INDEX_CHECK)
03897         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03898 #else
03899         throw();
03900 #endif
03901 
03902         INLINE l_imatrix operator +(const l_imatrix &m,const imatrix_slice &ms)
03903 #if(CXSC_INDEX_CHECK)
03904         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03905 #else
03906         throw();
03907 #endif
03908 
03909         INLINE l_imatrix operator +(const imatrix_slice &ms,const l_imatrix &m)
03910 #if(CXSC_INDEX_CHECK)
03911         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03912 #else
03913         throw();
03914 #endif
03915 
03916         INLINE l_imatrix operator +(const l_imatrix_slice &ms,const imatrix &m)
03917 #if(CXSC_INDEX_CHECK)
03918         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03919 #else
03920         throw();
03921 #endif
03922 
03923         INLINE l_imatrix operator +(const imatrix_slice &m1,const l_imatrix_slice &m2)
03924 #if(CXSC_INDEX_CHECK)
03925         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03926 #else
03927         throw();
03928 #endif
03929 
03930         INLINE l_imatrix operator +(const l_imatrix_slice &m1,const imatrix_slice &m2)
03931 #if(CXSC_INDEX_CHECK)
03932         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03933 #else
03934         throw();
03935 #endif
03936 
03937         INLINE l_imatrix &operator +=(l_imatrix &m1,const imatrix &m2)
03938 #if(CXSC_INDEX_CHECK)
03939         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03940 #else
03941         throw();
03942 #endif
03943 
03944         INLINE l_imatrix &operator +=(l_imatrix &m1,const imatrix_slice &ms)
03945 #if(CXSC_INDEX_CHECK)
03946         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03947 #else
03948         throw();
03949 #endif
03950         
03952         INLINE l_imatrix operator -(const imatrix &m1,const l_imatrix &m2)
03953 #if(CXSC_INDEX_CHECK)
03954         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03955 #else
03956         throw();
03957 #endif
03958 
03959         INLINE l_imatrix operator -(const l_imatrix &m1,const imatrix &m2)
03960 #if(CXSC_INDEX_CHECK)
03961         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03962 #else
03963         throw();
03964 #endif
03965 
03966         INLINE l_imatrix operator -(const imatrix &m,const l_imatrix_slice &ms)
03967 #if(CXSC_INDEX_CHECK)
03968         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03969 #else
03970         throw();
03971 #endif
03972 
03973         INLINE l_imatrix operator -(const l_imatrix &m,const imatrix_slice &ms)
03974 #if(CXSC_INDEX_CHECK)
03975         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03976 #else
03977         throw();
03978 #endif
03979 
03980         INLINE l_imatrix operator -(const imatrix_slice &ms,const l_imatrix &m)
03981 #if(CXSC_INDEX_CHECK)
03982         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03983 #else
03984         throw();
03985 #endif
03986 
03987         INLINE l_imatrix operator -(const l_imatrix_slice &ms,const imatrix &m)
03988 #if(CXSC_INDEX_CHECK)
03989         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03990 #else
03991         throw();
03992 #endif
03993 
03994         INLINE l_imatrix operator -(const imatrix_slice &ms1,const l_imatrix_slice &ms2)
03995 #if(CXSC_INDEX_CHECK)
03996         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
03997 #else
03998         throw();
03999 #endif
04000 
04001         INLINE l_imatrix operator -(const l_imatrix_slice &ms1,const imatrix_slice &ms2)
04002 #if(CXSC_INDEX_CHECK)
04003         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04004 #else
04005         throw();
04006 #endif
04007 
04008         INLINE l_imatrix &operator -=(l_imatrix &m1,const imatrix &m2)
04009 #if(CXSC_INDEX_CHECK)
04010         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04011 #else
04012         throw();
04013 #endif
04014 
04015         INLINE l_imatrix &operator -=(l_imatrix &m1,const imatrix_slice &ms)
04016 #if(CXSC_INDEX_CHECK)
04017         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04018 #else
04019         throw();
04020 #endif
04021         
04023         INLINE l_imatrix operator *(const imatrix &m1, const l_imatrix &m2)
04024 #if(CXSC_INDEX_CHECK)
04025         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04026 #else
04027         throw();
04028 #endif
04029 
04030         INLINE l_imatrix operator *(const l_imatrix &m1, const imatrix &m2)
04031 #if(CXSC_INDEX_CHECK)
04032         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04033 #else
04034         throw();
04035 #endif
04036 
04037         INLINE l_imatrix operator *(const imatrix &m1, const l_imatrix_slice &ms)
04038 #if(CXSC_INDEX_CHECK)
04039         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04040 #else
04041         throw();
04042 #endif
04043 
04044         INLINE l_imatrix operator *(const l_imatrix &m1, const imatrix_slice &ms)
04045 #if(CXSC_INDEX_CHECK)
04046         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04047 #else
04048         throw();
04049 #endif
04050 
04051         INLINE l_imatrix operator *(const imatrix_slice &ms, const l_imatrix &m1)
04052 #if(CXSC_INDEX_CHECK)
04053         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04054 #else
04055         throw();
04056 #endif
04057 
04058         INLINE l_imatrix operator *(const l_imatrix_slice &ms, const imatrix &m1)
04059 #if(CXSC_INDEX_CHECK)
04060         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04061 #else
04062         throw();
04063 #endif
04064 
04065         INLINE l_imatrix operator *(const imatrix_slice &ms1, const l_imatrix_slice &ms2)
04066 #if(CXSC_INDEX_CHECK)
04067         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04068 #else
04069         throw();
04070 #endif
04071 
04072         INLINE l_imatrix operator *(const l_imatrix_slice &ms1, const imatrix_slice &ms2)
04073 #if(CXSC_INDEX_CHECK)
04074         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04075 #else
04076         throw();
04077 #endif
04078 
04079         INLINE l_imatrix &operator *=(l_imatrix &m1,const imatrix &m2)
04080 #if(CXSC_INDEX_CHECK)
04081         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04082 #else
04083         throw();
04084 #endif
04085 
04086         INLINE l_imatrix &operator *=(l_imatrix &m1,const imatrix_slice &ms)
04087 #if(CXSC_INDEX_CHECK)
04088         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04089 #else
04090         throw();
04091 #endif
04092         
04094         INLINE l_imatrix operator |(const imatrix &m1,const l_imatrix &m2)
04095 #if(CXSC_INDEX_CHECK)
04096         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04097 #else
04098         throw();
04099 #endif
04100 
04101         INLINE l_imatrix operator |(const l_imatrix &m1,const imatrix &m2)
04102 #if(CXSC_INDEX_CHECK)
04103         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04104 #else
04105         throw();
04106 #endif
04107 
04108         INLINE l_imatrix operator |(const imatrix &m,const l_imatrix_slice &ms)
04109 #if(CXSC_INDEX_CHECK)
04110         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04111 #else
04112         throw();
04113 #endif
04114 
04115         INLINE l_imatrix operator |(const l_imatrix &m,const imatrix_slice &ms)
04116 #if(CXSC_INDEX_CHECK)
04117         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04118 #else
04119         throw();
04120 #endif
04121 
04122         INLINE l_imatrix operator |(const imatrix_slice &ms,const l_imatrix &m)
04123 #if(CXSC_INDEX_CHECK)
04124         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04125 #else
04126         throw();
04127 #endif
04128 
04129         INLINE l_imatrix operator |(const l_imatrix_slice &ms,const imatrix &m)
04130 #if(CXSC_INDEX_CHECK)
04131         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04132 #else
04133         throw();
04134 #endif
04135 
04136         INLINE l_imatrix operator |(const imatrix_slice &m1,const l_imatrix_slice &m2)
04137 #if(CXSC_INDEX_CHECK)
04138         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04139 #else
04140         throw();
04141 #endif
04142 
04143         INLINE l_imatrix operator |(const l_imatrix_slice &m1,const imatrix_slice &m2)
04144 #if(CXSC_INDEX_CHECK)
04145         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04146 #else
04147         throw();
04148 #endif
04149 
04150         INLINE l_imatrix &operator |=(l_imatrix &m1,const imatrix &m2)
04151 #if(CXSC_INDEX_CHECK)
04152         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04153 #else
04154         throw();
04155 #endif
04156 
04157         INLINE l_imatrix &operator |=(l_imatrix &m1,const imatrix_slice &ms)
04158 #if(CXSC_INDEX_CHECK)
04159         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04160 #else
04161         throw();
04162 #endif
04163         
04165         INLINE l_imatrix operator &(const imatrix &m1,const l_imatrix &m2)
04166 #if(CXSC_INDEX_CHECK)
04167         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04168 #else
04169         throw();
04170 #endif
04171 
04172         INLINE l_imatrix operator &(const l_imatrix &m1,const imatrix &m2)
04173 #if(CXSC_INDEX_CHECK)
04174         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04175 #else
04176         throw();
04177 #endif
04178 
04179         INLINE l_imatrix operator &(const imatrix &m,const l_imatrix_slice &ms)
04180 #if(CXSC_INDEX_CHECK)
04181         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04182 #else
04183         throw();
04184 #endif
04185 
04186         INLINE l_imatrix operator &(const l_imatrix &m,const imatrix_slice &ms)
04187 #if(CXSC_INDEX_CHECK)
04188         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04189 #else
04190         throw();
04191 #endif
04192 
04193         INLINE l_imatrix operator &(const imatrix_slice &ms,const l_imatrix &m)
04194 #if(CXSC_INDEX_CHECK)
04195         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04196 #else
04197         throw();
04198 #endif
04199 
04200         INLINE l_imatrix operator &(const l_imatrix_slice &ms,const imatrix &m)
04201 #if(CXSC_INDEX_CHECK)
04202         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04203 #else
04204         throw();
04205 #endif
04206 
04207         INLINE l_imatrix operator &(const imatrix_slice &m1,const l_imatrix_slice &m2)
04208 #if(CXSC_INDEX_CHECK)
04209         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04210 #else
04211         throw();
04212 #endif
04213 
04214         INLINE l_imatrix operator &(const l_imatrix_slice &m1,const imatrix_slice &m2)
04215 #if(CXSC_INDEX_CHECK)
04216         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04217 #else
04218         throw();
04219 #endif
04220 
04221         INLINE l_imatrix &operator &=(l_imatrix &m1,const imatrix &m2)
04222 #if(CXSC_INDEX_CHECK)
04223         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04224 #else
04225         throw();
04226 #endif
04227 
04228         INLINE l_imatrix &operator &=(l_imatrix &m1,const imatrix_slice &ms)
04229 #if(CXSC_INDEX_CHECK)
04230         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04231 #else
04232         throw();
04233 #endif
04234         
04235         //---------- l_rmatrix-imatrix ------------------
04237         INLINE l_imatrix operator +(const l_rmatrix &m1,const imatrix &m2)
04238 #if(CXSC_INDEX_CHECK)
04239         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04240 #else
04241         throw();
04242 #endif
04243 
04244         INLINE l_imatrix operator +(const imatrix &m1,const l_rmatrix &m2)
04245 #if(CXSC_INDEX_CHECK)
04246         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04247 #else
04248         throw();
04249 #endif
04250 
04251         INLINE l_imatrix operator +(const l_rmatrix &m,const imatrix_slice &ms)
04252 #if(CXSC_INDEX_CHECK)
04253         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04254 #else
04255         throw();
04256 #endif
04257 
04258         INLINE l_imatrix operator +(const imatrix &m,const l_rmatrix_slice &ms)
04259 #if(CXSC_INDEX_CHECK)
04260         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04261 #else
04262         throw();
04263 #endif
04264 
04265         INLINE l_imatrix operator +(const l_rmatrix_slice &ms,const imatrix &m)
04266 #if(CXSC_INDEX_CHECK)
04267         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04268 #else
04269         throw();
04270 #endif
04271 
04272         INLINE l_imatrix operator +(const imatrix_slice &ms,const l_rmatrix &m)
04273 #if(CXSC_INDEX_CHECK)
04274         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04275 #else
04276         throw();
04277 #endif
04278 
04279         INLINE l_imatrix operator +(const l_rmatrix_slice &m1,const imatrix_slice &m2)
04280 #if(CXSC_INDEX_CHECK)
04281         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04282 #else
04283         throw();
04284 #endif
04285 
04286         INLINE l_imatrix operator +(const imatrix_slice &m1,const l_rmatrix_slice &m2)
04287 #if(CXSC_INDEX_CHECK)
04288         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04289 #else
04290         throw();
04291 #endif
04292         
04294         INLINE l_imatrix operator -(const l_rmatrix &m1,const imatrix &m2)
04295 #if(CXSC_INDEX_CHECK)
04296         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04297 #else
04298         throw();
04299 #endif
04300 
04301         INLINE l_imatrix operator -(const imatrix &m1,const l_rmatrix &m2)
04302 #if(CXSC_INDEX_CHECK)
04303         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04304 #else
04305         throw();
04306 #endif
04307 
04308         INLINE l_imatrix operator -(const l_rmatrix &m,const imatrix_slice &ms)
04309 #if(CXSC_INDEX_CHECK)
04310         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04311 #else
04312         throw();
04313 #endif
04314 
04315         INLINE l_imatrix operator -(const imatrix &m,const l_rmatrix_slice &ms)
04316 #if(CXSC_INDEX_CHECK)
04317         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04318 #else
04319         throw();
04320 #endif
04321 
04322         INLINE l_imatrix operator -(const l_rmatrix_slice &ms,const imatrix &m)
04323 #if(CXSC_INDEX_CHECK)
04324         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04325 #else
04326         throw();
04327 #endif
04328 
04329         INLINE l_imatrix operator -(const imatrix_slice &ms,const l_rmatrix &m)
04330 #if(CXSC_INDEX_CHECK)
04331         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04332 #else
04333         throw();
04334 #endif
04335 
04336         INLINE l_imatrix operator -(const l_rmatrix_slice &ms1,const imatrix_slice &ms2)
04337 #if(CXSC_INDEX_CHECK)
04338         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04339 #else
04340         throw();
04341 #endif
04342 
04343         INLINE l_imatrix operator -(const imatrix_slice &ms1,const l_rmatrix_slice &ms2)
04344 #if(CXSC_INDEX_CHECK)
04345         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04346 #else
04347         throw();
04348 #endif
04349         
04351         INLINE l_imatrix operator *(const l_rmatrix &m1, const imatrix &m2)
04352 #if(CXSC_INDEX_CHECK)
04353         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04354 #else
04355         throw();
04356 #endif
04357 
04358         INLINE l_imatrix operator *(const imatrix &m1, const l_rmatrix &m2)
04359 #if(CXSC_INDEX_CHECK)
04360         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04361 #else
04362         throw();
04363 #endif
04364 
04365         INLINE l_imatrix operator *(const l_rmatrix &m1, const imatrix_slice &ms)
04366 #if(CXSC_INDEX_CHECK)
04367         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04368 #else
04369         throw();
04370 #endif
04371 
04372         INLINE l_imatrix operator *(const imatrix &m1, const l_rmatrix_slice &ms)
04373 #if(CXSC_INDEX_CHECK)
04374         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04375 #else
04376         throw();
04377 #endif
04378 
04379         INLINE l_imatrix operator *(const l_rmatrix_slice &ms, const imatrix &m1)
04380 #if(CXSC_INDEX_CHECK)
04381         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04382 #else
04383         throw();
04384 #endif
04385 
04386         INLINE l_imatrix operator *(const imatrix_slice &ms, const l_rmatrix &m1)
04387 #if(CXSC_INDEX_CHECK)
04388         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04389 #else
04390         throw();
04391 #endif
04392 
04393         INLINE l_imatrix operator *(const l_rmatrix_slice &ms1, const imatrix_slice &ms2)
04394 #if(CXSC_INDEX_CHECK)
04395         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04396 #else
04397         throw();
04398 #endif
04399 
04400         INLINE l_imatrix operator *(const imatrix_slice &ms1, const l_rmatrix_slice &ms2)
04401 #if(CXSC_INDEX_CHECK)
04402         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04403 #else
04404         throw();
04405 #endif
04406         
04408         INLINE l_imatrix operator |(const l_rmatrix &m1,const imatrix &m2)
04409 #if(CXSC_INDEX_CHECK)
04410         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04411 #else
04412         throw();
04413 #endif
04414 
04415         INLINE l_imatrix operator |(const imatrix &m1,const l_rmatrix &m2)
04416 #if(CXSC_INDEX_CHECK)
04417         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04418 #else
04419         throw();
04420 #endif
04421 
04422         INLINE l_imatrix operator |(const l_rmatrix &m,const imatrix_slice &ms)
04423 #if(CXSC_INDEX_CHECK)
04424         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04425 #else
04426         throw();
04427 #endif
04428 
04429         INLINE l_imatrix operator |(const imatrix &m,const l_rmatrix_slice &ms)
04430 #if(CXSC_INDEX_CHECK)
04431         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04432 #else
04433         throw();
04434 #endif
04435 
04436         INLINE l_imatrix operator |(const l_rmatrix_slice &ms,const imatrix &m)
04437 #if(CXSC_INDEX_CHECK)
04438         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04439 #else
04440         throw();
04441 #endif
04442 
04443         INLINE l_imatrix operator |(const imatrix_slice &ms,const l_rmatrix &m)
04444 #if(CXSC_INDEX_CHECK)
04445         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04446 #else
04447         throw();
04448 #endif
04449 
04450         INLINE l_imatrix operator |(const l_rmatrix_slice &m1,const imatrix_slice &m2)
04451 #if(CXSC_INDEX_CHECK)
04452         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04453 #else
04454         throw();
04455 #endif
04456 
04457         INLINE l_imatrix operator |(const imatrix_slice &m1,const l_rmatrix_slice &m2)
04458 #if(CXSC_INDEX_CHECK)
04459         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04460 #else
04461         throw();
04462 #endif
04463         
04465         INLINE l_imatrix operator &(const l_rmatrix &m1,const imatrix &m2)
04466 #if(CXSC_INDEX_CHECK)
04467         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04468 #else
04469         throw();
04470 #endif
04471 
04472         INLINE l_imatrix operator &(const imatrix &m1,const l_rmatrix &m2)
04473 #if(CXSC_INDEX_CHECK)
04474         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04475 #else
04476         throw();
04477 #endif
04478 
04479         INLINE l_imatrix operator &(const l_rmatrix &m,const imatrix_slice &ms)
04480 #if(CXSC_INDEX_CHECK)
04481         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04482 #else
04483         throw();
04484 #endif
04485 
04486         INLINE l_imatrix operator &(const imatrix &m,const l_rmatrix_slice &ms)
04487 #if(CXSC_INDEX_CHECK)
04488         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04489 #else
04490         throw();
04491 #endif
04492 
04493         INLINE l_imatrix operator &(const l_rmatrix_slice &ms,const imatrix &m)
04494 #if(CXSC_INDEX_CHECK)
04495         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04496 #else
04497         throw();
04498 #endif
04499 
04500         INLINE l_imatrix operator &(const imatrix_slice &ms,const l_rmatrix &m)
04501 #if(CXSC_INDEX_CHECK)
04502         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04503 #else
04504         throw();
04505 #endif
04506 
04507         INLINE l_imatrix operator &(const l_rmatrix_slice &m1,const imatrix_slice &m2)
04508 #if(CXSC_INDEX_CHECK)
04509         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04510 #else
04511         throw();
04512 #endif
04513 
04514         INLINE l_imatrix operator &(const imatrix_slice &m1,const l_rmatrix_slice &m2)
04515 #if(CXSC_INDEX_CHECK)
04516         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
04517 #else
04518         throw();
04519 #endif
04520         
04521 //------------- real x l_real ------------------------
04523         INLINE l_imatrix operator |(const rmatrix &rv1, const l_rmatrix &rv2)
04524 #if(CXSC_INDEX_CHECK)
04525         throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
04526 #else
04527         throw();
04528 #endif
04529 
04530         INLINE l_imatrix operator |(const l_rmatrix &rv1, const rmatrix &rv2)
04531 #if(CXSC_INDEX_CHECK)
04532         throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
04533 #else
04534         throw();
04535 #endif
04536 
04537         INLINE l_imatrix operator |(const l_rmatrix &rv, const rmatrix_slice &sl)
04538 #if(CXSC_INDEX_CHECK)
04539         throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
04540 #else
04541         throw();
04542 #endif
04543 
04544         INLINE l_imatrix operator |(const rmatrix_slice &sl,const l_rmatrix &rv)
04545 #if(CXSC_INDEX_CHECK)
04546         throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
04547 #else
04548         throw();
04549 #endif
04550 
04551         INLINE l_imatrix operator |(const l_rmatrix_slice &sl, const rmatrix &rv)
04552 #if(CXSC_INDEX_CHECK)
04553         throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
04554 #else
04555         throw();
04556 #endif
04557 
04558         INLINE l_imatrix operator |(const rmatrix &rv,const l_rmatrix_slice &sl)
04559 #if(CXSC_INDEX_CHECK)
04560         throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
04561 #else
04562         throw();
04563 #endif
04564 
04565         INLINE l_imatrix operator |(const l_rmatrix_slice &sl1, const rmatrix_slice &sl2)
04566 #if(CXSC_INDEX_CHECK)
04567         throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
04568 #else
04569         throw();
04570 #endif
04571 
04572         INLINE l_imatrix operator |(const rmatrix_slice &sl1, const l_rmatrix_slice &sl2)
04573 #if(CXSC_INDEX_CHECK)
04574         throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
04575 #else
04576         throw();
04577 #endif
04578         
04579 
04580 //------------- l_real x l_real ------------------------
04582         INLINE l_imatrix operator |(const l_rmatrix &rv1, const l_rmatrix &rv2)
04583 #if(CXSC_INDEX_CHECK)
04584         throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
04585 #else
04586         throw();
04587 #endif
04588 
04589         INLINE l_imatrix operator |(const l_rmatrix &rv1, const l_rmatrix &rv2)
04590 #if(CXSC_INDEX_CHECK)
04591         throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
04592 #else
04593         throw();
04594 #endif
04595 
04596         INLINE l_imatrix operator |(const l_rmatrix &rv, const l_rmatrix_slice &sl)
04597 #if(CXSC_INDEX_CHECK)
04598         throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
04599 #else
04600         throw();
04601 #endif
04602 
04603         INLINE l_imatrix operator |(const l_rmatrix_slice &sl,const l_rmatrix &rv)
04604 #if(CXSC_INDEX_CHECK)
04605         throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
04606 #else
04607         throw();
04608 #endif
04609 
04610         INLINE l_imatrix operator |(const l_rmatrix_slice &sl, const l_rmatrix &rv)
04611 #if(CXSC_INDEX_CHECK)
04612         throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
04613 #else
04614         throw();
04615 #endif
04616 
04617         INLINE l_imatrix operator |(const l_rmatrix &rv,const l_rmatrix_slice &sl)
04618 #if(CXSC_INDEX_CHECK)
04619         throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
04620 #else
04621         throw();
04622 #endif
04623 
04624         INLINE l_imatrix operator |(const l_rmatrix_slice &sl1, const l_rmatrix_slice &sl2)
04625 #if(CXSC_INDEX_CHECK)
04626         throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
04627 #else
04628         throw();
04629 #endif
04630 
04631         INLINE l_imatrix operator |(const l_rmatrix_slice &sl1, const l_rmatrix_slice &sl2)
04632 #if(CXSC_INDEX_CHECK)
04633         throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>);
04634 #else
04635         throw();
04636 #endif
04637         
04638 
04639 //============== Compare Operator ==========================
04640 
04641 //-------------- Matrix - Matrix   -------------------------
04642 
04644         INLINE bool operator ==(const l_imatrix &m1,const l_imatrix &m2) throw();
04646         INLINE bool operator !=(const l_imatrix &m1,const l_imatrix &m2) throw();
04648         INLINE bool operator <(const l_imatrix &m1,const l_imatrix &m2) throw();
04650         INLINE bool operator <=(const l_imatrix &m1,const l_imatrix &m2) throw();
04652         INLINE bool operator >(const l_imatrix &m1,const l_imatrix &m2) throw();
04654         INLINE bool operator >=(const l_imatrix &m1,const l_imatrix &m2) throw();
04656         INLINE bool operator ==(const l_imatrix &m1,const l_imatrix_slice &ms) throw();
04658         INLINE bool operator !=(const l_imatrix &m1,const l_imatrix_slice &ms) throw();
04660         INLINE bool operator <(const l_imatrix &m1,const l_imatrix_slice &ms) throw();
04662         INLINE bool operator <=(const l_imatrix &m1,const l_imatrix_slice &ms) throw();
04664         INLINE bool operator >(const l_imatrix &m1,const l_imatrix_slice &ms) throw();
04666         INLINE bool operator >=(const l_imatrix &m1,const l_imatrix_slice &ms) throw();
04667 
04668 //---------------- Matrix - Matrix_slice ----------------------
04669 
04671         INLINE bool operator ==(const l_imatrix_slice &m1,const l_imatrix_slice &m2) throw();
04673         INLINE bool operator !=(const l_imatrix_slice &m1,const l_imatrix_slice &m2) throw();
04675         INLINE bool operator <(const l_imatrix_slice &m1,const l_imatrix_slice &m2) throw();
04677         INLINE bool operator <=(const l_imatrix_slice &m1,const l_imatrix_slice &m2) throw();
04679         INLINE bool operator >(const l_imatrix_slice &m1,const l_imatrix_slice &m2) throw();
04681         INLINE bool operator >=(const l_imatrix_slice &m1,const l_imatrix_slice &m2) throw();
04682 
04683 //=================== Not Operator =============================
04684 
04686         INLINE bool operator !(const l_imatrix &ms) throw();
04688         INLINE bool operator !(const l_imatrix_slice &ms) throw();
04689 
04690 //======================== Input / Output ========================
04691 
04693         INLINE std::ostream &operator <<(std::ostream &s,const l_imatrix &r) throw();
04695         INLINE std::ostream &operator <<(std::ostream &s,const l_imatrix_slice &r) throw();
04697         INLINE std::istream &operator >>(std::istream &s,l_imatrix &r) throw();
04699         INLINE std::istream &operator >>(std::istream &s,l_imatrix_slice &r) throw();
04700 
04702         l_imatrix  Id         ( const l_imatrix& );
04704         l_imatrix  transp     ( const l_imatrix& );
04706         l_real     MaxRelDiam ( const l_imatrix_subv& );
04708         INLINE int RowLen   ( const l_imatrix& );
04710         INLINE int ColLen   ( const l_imatrix& );
04712         INLINE int RowLen   ( const l_imatrix_slice& );
04714         INLINE int ColLen   ( const l_imatrix_slice& );
04716         void     DoubleSize ( l_imatrix& );
04717 
04718 } // namespace cxsc 
04719 
04720 #ifdef _CXSC_INCL_INL
04721 #include "matrix.inl"
04722 #include "l_imatrix.inl"
04723 #endif
04724 
04725 
04726 #endif
04727