C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
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: imatrix.hpp,v 1.41 2014/01/30 17:23:45 cxsc Exp $ */
00025 
00026 #ifndef _CXSC_IMATRIX_HPP_INCLUDED
00027 #define _CXSC_IMATRIX_HPP_INCLUDED
00028 
00029 #include "xscclass.hpp"
00030 #include "idot.hpp"
00031 #include "cidot.hpp"
00032 #include "ivector.hpp"
00033 #include "except.hpp"
00034 #include "matrix.hpp"
00035 #include "rmatrix.hpp"
00036 
00037 
00038 namespace cxsc {
00039 
00040 
00041 class imatrix;
00042 class imatrix_slice;
00043 class simatrix;
00044 class simatrix_slice;
00045 class simatrix_subv;
00046 class srmatrix;
00047 class srmatrix_slice;
00048 class srmatrix_subv;
00049 
00050 
00052 
00055 class imatrix_subv
00056 {
00057         friend class ivector;
00058         friend class civector;
00059         friend class l_ivector;
00060         friend class imatrix;
00061         friend class imatrix_slice;
00062         private:
00063         interval *dat;
00064         int lb,ub;
00065         int size,start,offset; // start=first element index 0..n-1
00066         
00067         public:
00069         friend INLINE imatrix_subv Row(imatrix &m,const int &i)
00070 #if(CXSC_INDEX_CHECK)
00071         throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT);
00072 #else
00073         throw();
00074 #endif
00075 
00076         friend INLINE imatrix_subv Col(imatrix &m,const int &i)
00077 #if(CXSC_INDEX_CHECK)
00078         throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT);
00079 #else
00080         throw();
00081 #endif
00082 
00083         friend INLINE imatrix_subv Row(const imatrix &m,const int &i)
00084 #if(CXSC_INDEX_CHECK)
00085         throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT);
00086 #else
00087         throw();
00088 #endif
00089 
00090         friend INLINE imatrix_subv Col(const imatrix &m,const int &i)
00091 #if(CXSC_INDEX_CHECK)
00092         throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT);
00093 #else
00094         throw();
00095 #endif
00096 
00097 //#if(CXSC_INDEX_CHECK)
00098 #ifdef _CXSC_FRIEND_TPL
00099         //----------------- Templates ---------------------------------------
00100 template <class MV1,class MV2> friend  MV1 &_mvmvassign(MV1 &v,const MV2 &rv)
00101 #if(CXSC_INDEX_CHECK)
00102         throw(ERROR__OP_WITH_WRONG_DIM<MV1>);
00103 #else
00104         throw();
00105 #endif
00106 template <class MV,class S> friend  MV &_mvsassign(MV &v,const  S &r) throw();
00107 template <class MV,class V> friend  MV &_mvvassign(MV &v,const V &rv)
00108 #if(CXSC_INDEX_CHECK)
00109         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00110 #else
00111         throw();
00112 #endif
00113 template <class V,class MV2,class S> friend  V &_vmvassign(V &v,const MV2 &rv) throw();
00114 template <class MV,class V> friend  MV &_mvvsetinf(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 &_mvvsetsup(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 &_mvvusetinf(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 &_mvvusetsup(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 S> friend      MV &_mvssetinf(MV &mv, const S &s) throw();
00139  template <class MV,class S> friend      MV &_mvssetsup(MV &mv, const S &s) throw();
00140  template <class MV,class S> friend      MV &_mvsusetinf(MV &mv, const S &s) throw();
00141  template <class MV,class S> friend      MV &_mvsusetsup(MV &mv, const S &s) throw();
00142 template <class MV,class V> friend  V _mvabs(const MV &mv) throw();
00143 template <class MV,class V> friend  V _mvdiam(const MV &mv) throw();
00144 template <class MV,class V> friend  V _mvmid(const MV &mv) throw();
00145 template <class MV,class V> friend  V _mvinf(const MV &mv) throw();
00146 template <class MV,class V> friend  V _mvsup(const MV &mv) throw();
00147 template <class DP,class V,class SV> friend      void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
00148 #if(CXSC_INDEX_CHECK)
00149                 throw(OP_WITH_WRONG_DIM);
00150 #else
00151         throw();
00152 #endif
00153 template <class DP,class MV1,class MV2> friend   void _mvmvaccu(DP &dp, const MV1 & rv1, const MV2 &rv2)
00154 #if(CXSC_INDEX_CHECK)
00155                 throw(OP_WITH_WRONG_DIM);
00156 #else
00157         throw();
00158 #endif
00159  template <class MV1,class MV2,class S> friend   S _mvmvimult(const MV1 & rv1, const MV2 &rv2)
00160 #if(CXSC_INDEX_CHECK)
00161                 throw(ERROR__OP_WITH_WRONG_DIM<MV1>);
00162 #else
00163         throw();
00164 #endif
00165  template <class V,class MV,class S> friend      S _vmvimult(const V &rv1, const MV &rv2)
00166 #if(CXSC_INDEX_CHECK)
00167                 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00168 #else
00169         throw();
00170 #endif
00171  template <class MV,class S,class E> friend      E _mvsmult(const MV &rv, const S &s) throw();
00172  template <class MV1,class MV2,class E> friend   E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
00173 #if(CXSC_INDEX_CHECK)
00174                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00175 #else
00176         throw();
00177 #endif
00178  template <class MV1,class MV2,class E> friend   E _mvmvminus(const MV1 &rv1, const MV2 &rv2)
00179 #if(CXSC_INDEX_CHECK)
00180                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00181 #else
00182         throw();
00183 #endif
00184  template <class MV,class V,class E> friend      E _mvvplus(const MV &rv1, const V &rv2)
00185 #if(CXSC_INDEX_CHECK)
00186                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00187 #else
00188         throw();
00189 #endif
00190  template <class MV,class V,class E> friend      E _mvvminus(const MV &rv1, const V &rv2)
00191 #if(CXSC_INDEX_CHECK)
00192                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00193 #else
00194         throw();
00195 #endif
00196  template <class V,class MV,class E> friend      E _vmvminus(const V &rv1, const MV &rv2)
00197 #if(CXSC_INDEX_CHECK)
00198                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00199 #else
00200         throw();
00201 #endif
00202  template <class MV,class S,class E> friend      E _mvsdiv(const MV &rv, const S &s) throw();
00203 template <class MV,class S> friend  MV &_mvsmultassign(MV &v,const S &r) throw();
00204 template <class MV, class S> friend  MV &_mvsplusassign(MV &v,const S &r) throw();
00205 template <class MV,class S> friend  MV &_mvsminusassign(MV &v,const S &r) throw();
00206 template <class MV,class S> friend  MV &_mvsdivassign(MV &v,const S &r) throw();
00207 template <class MV,class V> friend  MV &_mvvplusassign(MV &v,const V &rv)
00208 #if(CXSC_INDEX_CHECK)
00209         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00210 #else
00211         throw();
00212 #endif
00213 template <class V,class MV> friend  V &_vmvplusassign(V &rv,const MV &v)
00214 #if(CXSC_INDEX_CHECK)
00215         throw(ERROR__OP_WITH_WRONG_DIM<V>);
00216 #else
00217         throw();
00218 #endif
00219 template <class MV,class V> friend  MV &_mvvminusassign(MV &v,const V &rv)
00220 #if(CXSC_INDEX_CHECK)
00221         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00222 #else
00223         throw();
00224 #endif
00225 template <class V,class MV> friend  V &_vmvminusassign(V &rv,const MV &v)
00226 #if(CXSC_INDEX_CHECK)
00227         throw(ERROR__OP_WITH_WRONG_DIM<V>);
00228 #else
00229         throw();
00230 #endif
00231  template <class MV1,class MV2,class E> friend   E _mvmvconv(const MV1 &rv1, const MV2 &rv2)
00232 #if(CXSC_INDEX_CHECK)
00233                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00234 #else
00235         throw();
00236 #endif
00237  template <class MV,class V,class E> friend      E _mvvconv(const MV &rv1, const V &rv2)
00238 #if(CXSC_INDEX_CHECK)
00239                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00240 #else
00241         throw();
00242 #endif
00243 template <class MV,class V> friend  MV &_mvvconvassign(MV &v,const V &rv)
00244 #if(CXSC_INDEX_CHECK)
00245         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00246 #else
00247         throw();
00248 #endif
00249  template <class MV1,class MV2,class E> friend   E _mvmvsect(const MV1 &rv1, const MV2 &rv2)
00250 #if(CXSC_INDEX_CHECK)
00251                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00252 #else
00253         throw();
00254 #endif
00255  template <class MV,class V,class E> friend      E _mvvsect(const MV &rv1, const V &rv2)
00256 #if(CXSC_INDEX_CHECK)
00257                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00258 #else
00259         throw();
00260 #endif
00261 template <class MV,class V> friend  MV &_mvvsectassign(MV &v,const V &rv)
00262 #if(CXSC_INDEX_CHECK)
00263         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00264 #else
00265         throw();
00266 #endif
00267 template <class V,class MV> friend  V &_vmvsectassign(V &rv,const MV &v)
00268 #if(CXSC_INDEX_CHECK)
00269         throw(ERROR__OP_WITH_WRONG_DIM<V>);
00270 #else
00271         throw();
00272 #endif
00273 
00274         //cinterval
00275 template <class V,class MV> friend  V &_vmvsetim(V &rv,const MV &v)
00276 #if(CXSC_INDEX_CHECK)
00277         throw(ERROR__OP_WITH_WRONG_DIM<V>);
00278 #else
00279         throw();
00280 #endif
00281 template <class V,class MV> friend  V &_vmvsetre(V &rv,const MV &v)
00282 #if(CXSC_INDEX_CHECK)
00283         throw(ERROR__OP_WITH_WRONG_DIM<V>);
00284 #else
00285         throw();
00286 #endif
00287   /*    friend TINLINE civector_slice &_vsmvsetim(civector_slice &,const imatrix_subv &)
00288 #if(CXSC_INDEX_CHECK)
00289         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
00290 #else
00291         throw();
00292 #endif
00293         friend TINLINE civector_slice &_vsmvsetre(civector_slice &,const imatrix_subv &)
00294 #if(CXSC_INDEX_CHECK)
00295         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
00296 #else
00297         throw();
00298 #endif
00299   */
00300 
00301 #endif
00302 
00303         //----------------- Konstruktoren ----------------------------------
00304 
00306         explicit INLINE imatrix_subv (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) { }
00307         public:
00309         INLINE imatrix_subv(const imatrix_subv &v) throw():dat(v.dat),lb(v.lb),ub(v.ub),size(v.size),start(v.start),offset(v.offset) { }
00310         public:
00311 
00312         //---------------------- Standardfunktionen ------------------------
00313 
00315         INLINE imatrix_subv &operator =(const simatrix_subv &rv);
00317         INLINE imatrix_subv &operator =(const srmatrix_subv &rv);
00319         INLINE imatrix_subv &operator =(const srvector &rv);
00321         INLINE imatrix_subv &operator =(const sivector &rv);
00323         INLINE imatrix_subv &operator =(const srvector_slice &rv);
00325         INLINE imatrix_subv &operator =(const sivector_slice &rv);
00326 
00328         INLINE imatrix_subv &operator =(const imatrix_subv &rv) throw();
00330         INLINE imatrix_subv &operator =(const interval &r) throw();
00332         INLINE imatrix_subv &operator =(const imatrix &m)
00333 #if(CXSC_INDEX_CHECK)
00334         throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
00335 #else
00336         throw();
00337 #endif
00338 
00339         INLINE imatrix_subv &operator =(const imatrix_slice &m)
00340 #if(CXSC_INDEX_CHECK)
00341         throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
00342 #else
00343         throw();
00344 #endif
00345 
00346         INLINE imatrix_subv &operator =(const ivector &v)
00347 #if(CXSC_INDEX_CHECK)
00348         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00349 #else
00350         throw();
00351 #endif
00352 
00353         INLINE imatrix_subv &operator =(const ivector_slice &v)
00354 #if(CXSC_INDEX_CHECK)
00355         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00356 #else
00357         throw();
00358 #endif
00359         // Real
00361         INLINE imatrix_subv &operator =(const rmatrix_subv &rv) throw();
00363         INLINE imatrix_subv &operator =(const real &r) throw();
00365         INLINE imatrix_subv &operator =(const rmatrix &m)
00366 #if(CXSC_INDEX_CHECK)
00367         throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
00368 #else
00369         throw();
00370 #endif
00371 
00372         INLINE imatrix_subv &operator =(const rmatrix_slice &m)
00373 #if(CXSC_INDEX_CHECK)
00374         throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
00375 #else
00376         throw();
00377 #endif
00378 
00379         INLINE imatrix_subv &operator =(const rvector &v)
00380 #if(CXSC_INDEX_CHECK)
00381         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00382 #else
00383         throw();
00384 #endif
00385 
00386         INLINE imatrix_subv &operator =(const rvector_slice &v)
00387 #if(CXSC_INDEX_CHECK)
00388         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00389 #else
00390         throw();
00391 #endif
00392 
00394         friend INLINE int Lb(const imatrix_subv &rv) throw() { return rv.lb; }
00396         friend INLINE int Ub(const imatrix_subv &rv) throw() { return rv.ub; }
00398         friend INLINE int VecLen(const imatrix_subv &rv) throw() { return rv.size; }
00399 
00401         INLINE interval &operator [](const int &i) const
00402 #if(CXSC_INDEX_CHECK)
00403         throw(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC);
00404 #else
00405         throw();
00406 #endif
00407 
00409         INLINE interval &operator [](const int &i)
00410 #if(CXSC_INDEX_CHECK)
00411         throw(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC);
00412 #else
00413         throw();
00414 #endif
00415 
00417         INLINE imatrix_subv &operator ()() throw() { return *this; }
00419         INLINE imatrix_subv operator ()(const int &i)
00420 #if(CXSC_INDEX_CHECK)
00421         throw(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG);
00422 #else
00423         throw();
00424 #endif
00425 
00426         INLINE imatrix_subv operator ()(const int &i1,const int &i2)
00427 #if(CXSC_INDEX_CHECK)
00428         throw(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG);
00429 #else
00430         throw();
00431 #endif
00432         
00434         INLINE imatrix_subv &operator *=(const interval &c) throw();
00436         INLINE imatrix_subv &operator +=(const interval &c) throw();
00438         INLINE imatrix_subv &operator -=(const interval &c) throw();
00440         INLINE imatrix_subv &operator /=(const interval &c) throw();
00441 
00442         //Sparse 
00444         INLINE imatrix_subv &operator +=(const sivector &rv);
00446         INLINE imatrix_subv &operator -=(const sivector &rv);
00448         INLINE imatrix_subv &operator +=(const srvector &rv);
00450         INLINE imatrix_subv &operator -=(const srvector &rv);
00452         INLINE imatrix_subv &operator +=(const sivector_slice &rv);
00454         INLINE imatrix_subv &operator -=(const sivector_slice &rv);
00456         INLINE imatrix_subv &operator +=(const srvector_slice &rv);
00458         INLINE imatrix_subv &operator -=(const srvector_slice &rv);
00460         INLINE imatrix_subv &operator +=(const simatrix_subv &rv);
00462         INLINE imatrix_subv &operator -=(const simatrix_subv &rv);
00464         INLINE imatrix_subv &operator +=(const srmatrix_subv &rv);
00466         INLINE imatrix_subv &operator -=(const srmatrix_subv &rv);
00467 
00469         INLINE imatrix_subv &operator |=(const sivector &rv);
00471         INLINE imatrix_subv &operator &=(const sivector &rv);
00473         INLINE imatrix_subv &operator |=(const srvector &rv);
00475         INLINE imatrix_subv &operator &=(const srvector &rv);
00477         INLINE imatrix_subv &operator |=(const sivector_slice &rv);
00479         INLINE imatrix_subv &operator &=(const sivector_slice &rv);
00481         INLINE imatrix_subv &operator |=(const srvector_slice &rv);
00483         INLINE imatrix_subv &operator &=(const srvector_slice &rv);
00485         INLINE imatrix_subv &operator |=(const simatrix_subv &rv);
00487         INLINE imatrix_subv &operator &=(const simatrix_subv &rv);
00489         INLINE imatrix_subv &operator |=(const srmatrix_subv &rv);
00491         INLINE imatrix_subv &operator &=(const srmatrix_subv &rv);
00492 
00493 
00495         INLINE imatrix_subv &operator -=(const ivector &rv)
00496 #if(CXSC_INDEX_CHECK)
00497         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00498 #else
00499         throw();
00500 #endif
00501 
00502         INLINE imatrix_subv &operator +=(const ivector &rv)
00503 #if(CXSC_INDEX_CHECK)
00504         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00505 #else
00506         throw();
00507 #endif
00508 
00509         INLINE imatrix_subv &operator -=(const ivector_slice &rv)
00510 #if(CXSC_INDEX_CHECK)
00511         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00512 #else
00513         throw();
00514 #endif
00515 
00516         INLINE imatrix_subv &operator +=(const ivector_slice &rv)
00517 #if(CXSC_INDEX_CHECK)
00518         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00519 #else
00520         throw();
00521 #endif
00522 
00523         INLINE imatrix_subv &operator |=(const ivector &rv)
00524 #if(CXSC_INDEX_CHECK)
00525         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00526 #else
00527         throw();
00528 #endif
00529 
00530         INLINE imatrix_subv &operator |=(const ivector_slice &rv)
00531 #if(CXSC_INDEX_CHECK)
00532         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00533 #else
00534         throw();
00535 #endif
00536 
00537         INLINE imatrix_subv &operator &=(const ivector &rv)
00538 #if(CXSC_INDEX_CHECK)
00539         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00540 #else
00541         throw();
00542 #endif
00543 
00544         INLINE imatrix_subv &operator &=(const ivector_slice &rv)
00545 #if(CXSC_INDEX_CHECK)
00546         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00547 #else
00548         throw();
00549 #endif
00550         // real
00552         INLINE imatrix_subv &operator *=(const real &c) throw();
00554         INLINE imatrix_subv &operator +=(const real &c) throw();
00556         INLINE imatrix_subv &operator -=(const real &c) throw();
00558         INLINE imatrix_subv &operator /=(const real &c) throw();
00559 
00561         INLINE imatrix_subv &operator +=(const rvector &rv)
00562 #if(CXSC_INDEX_CHECK)
00563         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00564 #else
00565         throw();
00566 #endif
00567 
00568         INLINE imatrix_subv &operator +=(const rvector_slice &rv)
00569 #if(CXSC_INDEX_CHECK)
00570         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00571 #else
00572         throw();
00573 #endif
00574 
00575         INLINE imatrix_subv &operator -=(const rvector &rv)
00576 #if(CXSC_INDEX_CHECK)
00577         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00578 #else
00579         throw();
00580 #endif
00581 
00582         INLINE imatrix_subv &operator -=(const rvector_slice &rv)
00583 #if(CXSC_INDEX_CHECK)
00584         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00585 #else
00586         throw();
00587 #endif
00588 
00589         INLINE imatrix_subv &operator |=(const rvector &rv)
00590 #if(CXSC_INDEX_CHECK)
00591         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00592 #else
00593         throw();
00594 #endif
00595 
00596         INLINE imatrix_subv &operator |=(const rvector_slice &rv)
00597 #if(CXSC_INDEX_CHECK)
00598         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00599 #else
00600         throw();
00601 #endif
00602 
00603         INLINE imatrix_subv &operator &=(const rvector &rv)
00604 #if(CXSC_INDEX_CHECK)
00605         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00606 #else
00607         throw();
00608 #endif
00609 
00610         INLINE imatrix_subv &operator &=(const rvector_slice &rv)
00611 #if(CXSC_INDEX_CHECK)
00612         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
00613 #else
00614         throw();
00615 #endif
00616 //#else
00617 //#endif        
00618 
00619 };
00620 
00621 
00623 INLINE imatrix_subv Row(imatrix &m,const int &i)
00624 #if(CXSC_INDEX_CHECK)
00625         throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT);
00626 #else
00627         throw();
00628 #endif
00629 
00630 INLINE imatrix_subv Col(imatrix &m,const int &i)
00631 #if(CXSC_INDEX_CHECK)
00632         throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT);
00633 #else
00634         throw();
00635 #endif
00636 
00637 INLINE imatrix_subv Row(const imatrix &m,const int &i)
00638 #if(CXSC_INDEX_CHECK)
00639         throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT);
00640 #else
00641         throw();
00642 #endif
00643 
00644 INLINE imatrix_subv Col(const imatrix &m,const int &i)
00645 #if(CXSC_INDEX_CHECK)
00646         throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT);
00647 #else
00648         throw();
00649 #endif
00650 
00651 //----------------------- Matrix -----------------------------------------------
00652 
00653 class imatrix_slice;
00654 
00656 
00659 class imatrix
00660 {
00661         friend class imatrix_slice;
00662         friend class imatrix_subv;
00663         friend class cimatrix;
00664         friend class l_imatrix;
00665         private:
00666         interval *dat;
00667         int lb1,ub1,lb2,ub2,xsize,ysize;
00668 
00669         public:
00670 //#if(CXSC_INDEX_CHECK)
00671 #ifdef _CXSC_FRIEND_TPL
00672         //----------------- Templates ---------------------------------------
00673 template <class S,class M> friend  void _smconstr(S &s,const M &m)
00674 #if(CXSC_INDEX_CHECK)
00675         throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>,ERROR__USE_OF_UNINITIALIZED_OBJ<M>);
00676 #else
00677         throw();
00678 #endif
00679 template <class V,class M,class S> friend  void _vmconstr(V &v,const M &m)
00680 #if(CXSC_INDEX_CHECK)
00681         throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
00682 #else
00683         throw();
00684 #endif
00685  template <class M1,class M2,class S> friend     M1 &_mmassign(M1 &m1,const M2 &m,S ms) throw();
00686  template <class M,class MS2,class S> friend     M &_mmsassign(M &m,const MS2 &ms) throw();
00687  template <class MS,class M> friend      MS &_msmassign(MS &ms,const M &m)
00688 #if(CXSC_INDEX_CHECK)
00689                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00690 #else
00691         throw();
00692 #endif
00693  template <class M,class S> friend       M &_msassign(M &m,const S &r) throw();
00694 template <class V,class M,class S> friend  V &_vmassign(V &v,const M &m)
00695 #if(CXSC_INDEX_CHECK)
00696         throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
00697 #else
00698         throw();
00699 #endif
00700 template <class M,class V,class S> friend  M &_mvassign(M &m,const V &v) throw();
00701  template <class M> friend       int _mlb(const M &m, const int &i)
00702 #if(CXSC_INDEX_CHECK)
00703         throw(ERROR__WRONG_ROW_OR_COL<M>);
00704 #else
00705         throw();
00706 #endif
00707  template <class M> friend       int _mub(const M &m, const int &i)
00708 #if(CXSC_INDEX_CHECK)
00709         throw(ERROR__WRONG_ROW_OR_COL<M>);
00710 #else
00711         throw();
00712 #endif
00713  template <class M> friend       M &_msetlb(M &m, const int &i,const int &j)
00714 #if(CXSC_INDEX_CHECK)
00715         throw(ERROR__WRONG_ROW_OR_COL<M>);
00716 #else
00717         throw();
00718 #endif
00719  template <class M> friend       M &_msetub(M &m, const int &i,const int &j)
00720 #if(CXSC_INDEX_CHECK)
00721         throw(ERROR__WRONG_ROW_OR_COL<M>);
00722 #else
00723         throw();
00724 #endif
00725  template <class M> friend       void _mresize(M &A) throw();
00726  template <class M,class S> friend       void _mresize(M &A,const int &m, const int &n)
00727 #if(CXSC_INDEX_CHECK)
00728                 throw(ERROR__WRONG_BOUNDARIES<M>);
00729 #else
00730         throw();
00731 #endif
00732  template <class M,class S> friend       void _mresize(M &A,const int &m1, const int &m2,const int &n1,const int &n2)
00733 #if(CXSC_INDEX_CHECK)
00734                 throw(ERROR__WRONG_BOUNDARIES<M>);
00735 #else
00736         throw();
00737 #endif
00738  template <class M,class E> friend       E _mabs(const M &m) throw();
00739  template <class MS,class E> friend      E _msabs(const MS &ms) throw();
00740  template <class M,class E> friend       E _mdiam(const M &m) throw();
00741  template <class M,class E> friend       E _mmid(const M &m) throw();
00742  template <class M,class E> friend       E _minf(const M &m) throw();
00743  template <class M,class E> friend       E _msup(const M &m) throw();
00744  template <class M1,class M2> friend     M1 &_mmsetinf(M1 &m1,const M2 &m2)
00745 #if(CXSC_INDEX_CHECK)
00746                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00747 #else
00748         throw();
00749 #endif
00750  template <class M1,class M2> friend     M1 &_mmsetsup(M1 &m1,const M2 &m2)
00751 #if(CXSC_INDEX_CHECK)
00752                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00753 #else
00754         throw();
00755 #endif
00756  template <class M1,class MS2> friend    M1 &_mmssetinf(M1 &m1,const MS2 &ms2)
00757 #if(CXSC_INDEX_CHECK)
00758                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00759 #else
00760         throw();
00761 #endif
00762  template <class M1,class MS2> friend    M1 &_mmssetsup(M1 &m1,const MS2 &ms2)
00763 #if(CXSC_INDEX_CHECK)
00764                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00765 #else
00766         throw();
00767 #endif
00768  template <class M1,class M2> friend     M1 &_mmusetinf(M1 &m1,const M2 &m2)
00769 #if(CXSC_INDEX_CHECK)
00770                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00771 #else
00772         throw();
00773 #endif
00774  template <class M1,class M2> friend     M1 &_mmusetsup(M1 &m1,const M2 &m2)
00775 #if(CXSC_INDEX_CHECK)
00776                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00777 #else
00778         throw();
00779 #endif
00780  template <class M1,class MS2> friend    M1 &_mmsusetinf(M1 &m1,const MS2 &ms2)
00781 #if(CXSC_INDEX_CHECK)
00782                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00783 #else
00784         throw();
00785 #endif
00786  template <class M1,class MS2> friend    M1 &_mmsusetsup(M1 &m1,const MS2 &ms2)
00787 #if(CXSC_INDEX_CHECK)
00788                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00789 #else
00790         throw();
00791 #endif
00792         //-------------- matrix-matrix -------------
00793  template <class M1,class M2,class E> friend     E _mmplus(const M1 &m1,const M2 &m2)
00794 #if(CXSC_INDEX_CHECK)
00795                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00796 #else
00797         throw();
00798 #endif
00799  template <class M,class MS,class E> friend      E _mmsplus(const M &m,const MS &ms)
00800 #if(CXSC_INDEX_CHECK)
00801                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00802 #else
00803         throw();
00804 #endif
00805  template <class M> friend       M _mminus(const M &m) throw();
00806  template <class MS,class E> friend      E _msminus(const MS &ms) throw();
00807  template <class M1,class M2,class E> friend     E _mmminus(const M1 &m1,const M2 &m2)
00808 #if(CXSC_INDEX_CHECK)
00809                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00810 #else
00811         throw();
00812 #endif
00813  template <class M1,class M2> friend     M1 &_mmplusassign(M1 &m1,const M2 &m2)
00814 #if(CXSC_INDEX_CHECK)
00815                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00816 #else
00817         throw();
00818 #endif
00819  template <class M,class MS> friend      M &_mmsplusassign(M &m1,const MS &ms)
00820 #if(CXSC_INDEX_CHECK)
00821                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00822 #else
00823         throw();
00824 #endif
00825  template <class MS,class M> friend      MS &_msmplusassign(MS &ms,const M &m1)
00826 #if(CXSC_INDEX_CHECK)
00827                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00828 #else
00829         throw();
00830 #endif
00831  template <class MS1,class MS2,class E> friend   E _msmsplus(const MS1 &m1,const MS2 &m2)
00832 #if(CXSC_INDEX_CHECK)
00833                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00834 #else
00835         throw();
00836 #endif
00837  template <class M,class MS,class E> friend      E _mmsminus(const M &m,const MS &ms)
00838 #if(CXSC_INDEX_CHECK)
00839                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00840 #else
00841         throw();
00842 #endif
00843  template <class MS,class M,class E> friend      E _msmminus(const MS &ms,const M &m)
00844 #if(CXSC_INDEX_CHECK)
00845                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00846 #else
00847         throw();
00848 #endif
00849  template <class MS1,class MS2,class E> friend   E _msmsminus(const MS1 &ms1,const MS2 &ms2)
00850 #if(CXSC_INDEX_CHECK)
00851                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00852 #else
00853         throw();
00854 #endif
00855  template <class M1,class M2> friend     M1 &_mmminusassign(M1 &m1,const M2 &m2)
00856 #if(CXSC_INDEX_CHECK)
00857                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00858 #else
00859         throw();
00860 #endif
00861  template <class M,class MS> friend      M &_mmsminusassign(M &m1,const MS &ms)
00862 #if(CXSC_INDEX_CHECK)
00863                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00864 #else
00865         throw();
00866 #endif
00867  template <class MS,class M> friend      MS &_msmminusassign(MS &ms,const M &m1)
00868 #if(CXSC_INDEX_CHECK)
00869                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00870 #else
00871         throw();
00872 #endif
00873  template <class M1,class M2,class E> friend     E _mmimult(const M1 &m1, const M2 &m2)
00874 #if(CXSC_INDEX_CHECK)
00875                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00876 #else
00877         throw();
00878 #endif
00879  template <class M1,class M2,class S> friend     M1 &_mmimultassign(M1 &m1,const M2 &m2)
00880 #if(CXSC_INDEX_CHECK)
00881                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00882 #else
00883         throw();
00884 #endif
00885  template <class M,class MS,class E> friend      E _mmsimult(const M &m1, const MS &ms)
00886 #if(CXSC_INDEX_CHECK)
00887                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00888 #else
00889         throw();
00890 #endif
00891  template <class MS,class M,class E> friend      E _msmimult(const MS &ms, const M &m2)
00892 #if(CXSC_INDEX_CHECK)
00893                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00894 #else
00895         throw();
00896 #endif
00897  template <class M,class MS,class S> friend      M &_mmsimultassign(M &m1,const MS &ms)
00898 #if(CXSC_INDEX_CHECK)
00899                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00900 #else
00901         throw();
00902 #endif
00903  template <class MS1,class MS2,class E> friend   E _msmsimult(const MS1 &ms1, const MS2 &ms2)
00904 #if(CXSC_INDEX_CHECK)
00905                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00906 #else
00907         throw();
00908 #endif
00909  template <class M1,class M2,class E> friend     E _mmconv(const M1 &m1,const M2 &m2)
00910 #if(CXSC_INDEX_CHECK)
00911                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00912 #else
00913         throw();
00914 #endif
00915  template <class M,class MS,class E> friend      E _mmsconv(const M &m,const MS &ms)
00916 #if(CXSC_INDEX_CHECK)
00917                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00918 #else
00919         throw();
00920 #endif
00921  template <class M1,class M2> friend     M1 &_mmconvassign(M1 &m1,const M2 &m2)
00922 #if(CXSC_INDEX_CHECK)
00923                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00924 #else
00925         throw();
00926 #endif
00927  template <class M,class MS> friend      M &_mmsconvassign(M &m1,const MS &ms)
00928 #if(CXSC_INDEX_CHECK)
00929                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00930 #else
00931         throw();
00932 #endif
00933  template <class MS,class M> friend      MS &_msmconvassign(MS &ms,const M &m1)
00934 #if(CXSC_INDEX_CHECK)
00935                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00936 #else
00937         throw();
00938 #endif
00939  template <class MS1,class MS2,class E> friend   E _msmsconv(const MS1 &m1,const MS2 &m2)
00940 #if(CXSC_INDEX_CHECK)
00941                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00942 #else
00943         throw();
00944 #endif
00945  template <class M1,class M2,class E> friend     E _mmsect(const M1 &m1,const M2 &m2)
00946 #if(CXSC_INDEX_CHECK)
00947                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00948 #else
00949         throw();
00950 #endif
00951  template <class M,class MS,class E> friend      E _mmssect(const M &m,const MS &ms)
00952 #if(CXSC_INDEX_CHECK)
00953                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00954 #else
00955         throw();
00956 #endif
00957  template <class M1,class M2> friend     M1 &_mmsectassign(M1 &m1,const M2 &m2)
00958 #if(CXSC_INDEX_CHECK)
00959                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
00960 #else
00961         throw();
00962 #endif
00963  template <class M,class MS> friend      M &_mmssectassign(M &m1,const MS &ms)
00964 #if(CXSC_INDEX_CHECK)
00965                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00966 #else
00967         throw();
00968 #endif
00969  template <class MS,class M> friend      MS &_msmsectassign(MS &ms,const M &m1)
00970 #if(CXSC_INDEX_CHECK)
00971                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00972 #else
00973         throw();
00974 #endif
00975  template <class MS1,class MS2,class E> friend   E _msmssect(const MS1 &m1,const MS2 &m2)
00976 #if(CXSC_INDEX_CHECK)
00977                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00978 #else
00979         throw();
00980 #endif
00981         //-------- matrix-scalar -----------------
00982  template <class S,class M,class E> friend       E _smmult(const S &c, const M &m) throw();
00983  template <class M,class S> friend       M &_msmultassign(M &m,const S &c) throw();
00984  template <class S,class MS,class E> friend      E _smsmult(const S &c, const MS &ms) throw();
00985  template <class M,class S,class E> friend       E _msdiv(const M &m,const S &c) throw();
00986  template <class M,class S> friend       M &_msdivassign(M &m,const S &c) throw();
00987  template <class MS,class S,class E> friend      E _mssdiv(const MS &ms, const S &c) throw();
00988         //-------- matrix-vector ---------------------
00989  template <class M,class V,class E> friend       E _mvimult(const M &m,const V &v)
00990 #if(CXSC_INDEX_CHECK)
00991                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00992 #else
00993         throw();
00994 #endif
00995  template <class V,class M,class E> friend       E _vmimult(const V &v,const M &m)
00996 #if(CXSC_INDEX_CHECK)
00997                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00998 #else
00999         throw();
01000 #endif
01001  template <class V,class M,class S> friend       V &_vmimultassign(V &v,const M &m)
01002 #if(CXSC_INDEX_CHECK)
01003                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01004 #else
01005         throw();
01006 #endif
01007  template <class VS,class M,class S> friend      VS &_vsmimultassign(VS &v,const M &m)
01008 #if(CXSC_INDEX_CHECK)
01009                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01010 #else
01011         throw();
01012 #endif
01013         
01014  template <class M> friend       void *_mvoid(const M &m) throw();
01015  template <class M> friend       bool _mnot(const M &m) throw();
01016  template <class MS> friend      void *_msvoid(const MS &ms) throw();
01017  template <class MS> friend      bool _msnot(const MS &ms) throw();
01018  template <class M1,class M2> friend     bool _mmeq(const M1 &m1,const M2 &m2) throw();
01019  template <class M1,class M2> friend     bool _mmneq(const M1 &m1,const M2 &m2) throw();
01020  template <class M1,class M2> friend     bool _mmless(const M1 &m1,const M2 &m2) throw();
01021  template <class M1,class M2> friend     bool _mmleq(const M1 &m1,const M2 &m2) throw();
01022  template <class M,class MS> friend      bool _mmseq(const M &m1,const MS &ms) throw();
01023  template <class M,class MS> friend      bool _mmsneq(const M &m1,const MS &ms) throw();
01024  template <class M,class MS> friend      bool _mmsless(const M &m1,const MS &ms) throw();
01025  template <class M,class MS> friend      bool _mmsleq(const M &m1,const MS &ms) throw();
01026  template <class MS,class M> friend      bool _msmless(const MS &ms,const M &m1) throw();
01027  template <class MS,class M> friend      bool _msmleq(const MS &ms,const M &m1) throw();
01028  template <class M> friend      std::ostream &_mout(std::ostream &s,const M &r) throw();
01029  template <class M> friend      std::istream &_min(std::istream &s,M &r) throw();
01030 
01031         //--- Real --------- matrix-vector ----------------------
01032  template <class MS,class V,class E> friend      E _msvimult(const MS &ms,const V &v)
01033 #if(CXSC_INDEX_CHECK)
01034                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01035 #else
01036         throw();
01037 #endif
01038  template <class V,class MS,class E> friend      E _vmsimult(const V &v,const MS &ms)
01039 #if(CXSC_INDEX_CHECK)
01040                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01041 #else
01042         throw();
01043 #endif
01044 
01045         // complex -----------
01046         // matrix-matrix
01047  template <class M1,class M2,class E> friend     E _mmcimult(const M1 &m1, const M2 &m2)
01048 #if(CXSC_INDEX_CHECK)
01049                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01050 #else
01051         throw();
01052 #endif
01053  template <class M,class MS,class E> friend      E _mmscimult(const M &m1, const MS &ms)
01054 #if(CXSC_INDEX_CHECK)
01055                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01056 #else
01057         throw();
01058 #endif
01059  template <class MS,class M,class E> friend      E _msmcimult(const MS &ms, const M &m2)
01060 #if(CXSC_INDEX_CHECK)
01061                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01062 #else
01063         throw();
01064 #endif
01065  template <class MS1,class MS2,class E> friend   E _msmscimult(const MS1 &ms1, const MS2 &ms2)
01066 #if(CXSC_INDEX_CHECK)
01067                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01068 #else
01069         throw();
01070 #endif
01071 
01072         // matrix-vector
01073  template <class M,class V,class E> friend       E _mvcimult(const M &m,const V &v)
01074 #if(CXSC_INDEX_CHECK)
01075                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01076 #else
01077         throw();
01078 #endif
01079  template <class V,class M,class E> friend       E _vmcimult(const V &v,const M &m)
01080 #if(CXSC_INDEX_CHECK)
01081                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01082 #else
01083         throw();
01084 #endif
01085   /*   friend TINLINE civector _mvscimult<imatrix,cvector_slice,civector>(const imatrix &m,const cvector_slice &v)
01086 #if(CXSC_INDEX_CHECK)
01087         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01088 #else
01089         throw();
01090         #endif */
01091   /*   friend TINLINE civector _vsmcimult<cvector_slice,imatrix,civector>(const cvector_slice &v,const imatrix &m)
01092 #if(CXSC_INDEX_CHECK)
01093         throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
01094 #else
01095         throw();
01096         #endif */
01097 
01098         // cinterval--------
01099  template <class M,class E> friend       E _mre(const M &m) throw();
01100  template <class M,class E> friend       E _mim(const M &m) throw();
01101  template <class MS,class E> friend      E _msre(const MS &ms) throw();
01102  template <class MS,class E> friend      E _msim(const MS &ms) throw();
01103  template <class M1,class M2> friend     M1 &_mmsetre(M1 &m1,const M2 &m2)
01104 #if(CXSC_INDEX_CHECK)
01105                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01106 #else
01107         throw();
01108 #endif
01109  template <class M1,class M2> friend     M1 &_mmsetim(M1 &m1,const M2 &m2)
01110 #if(CXSC_INDEX_CHECK)
01111                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01112 #else
01113         throw();
01114 #endif
01115  template <class MS1,class M2> friend    MS1 &_msmsetre(MS1 &ms1,const M2 &m2)
01116 #if(CXSC_INDEX_CHECK)
01117                 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01118 #else
01119         throw();
01120 #endif
01121  template <class MS1,class M2> friend    MS1 &_msmsetim(MS1 &ms1,const M2 &m2)
01122 #if(CXSC_INDEX_CHECK)
01123                 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01124 #else
01125         throw();
01126 #endif
01127 
01128         // matrix-matrix
01129  template <class M1,class M2,class S> friend     M1 &_mmcimultassign(M1 &m1,const M2 &m2)
01130 #if(CXSC_INDEX_CHECK)
01131                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01132 #else
01133         throw();
01134 #endif
01135  template <class M,class MS,class S> friend      M &_mmscimultassign(M &m1,const MS &ms)
01136 #if(CXSC_INDEX_CHECK)
01137                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01138 #else
01139         throw();
01140 #endif
01141 
01142         // matrix-vector
01143  template <class V,class M,class S> friend       V &_vmcimultassign(V &v,const M &m)
01144 #if(CXSC_INDEX_CHECK)
01145                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01146 #else
01147         throw();
01148 #endif
01149  template <class VS,class M,class S> friend      VS &_vsmcimultassign(VS &v,const M &m)
01150 #if(CXSC_INDEX_CHECK)
01151                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01152 #else
01153         throw();
01154 #endif
01155 
01156   /*   friend TINLINE civector _mvscimult<imatrix,civector_slice,civector>(const imatrix &m,const civector_slice &v)
01157 #if(CXSC_INDEX_CHECK)
01158         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01159 #else
01160         throw();
01161         #endif */
01162   /*   friend TINLINE civector _vsmcimult<civector_slice,imatrix,civector>(const civector_slice &v,const imatrix &m)
01163 #if(CXSC_INDEX_CHECK)
01164         throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
01165 #else
01166         throw();
01167         #endif */ 
01168 
01169         // l_real -----------
01170         // matrix-matrix
01171  template <class M1,class M2,class E> friend     E _mmlimult(const M1 &m1, const M2 &m2)
01172 #if(CXSC_INDEX_CHECK)
01173                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01174 #else
01175         throw();
01176 #endif
01177  template <class M,class MS,class E> friend      E _mmslimult(const M &m1, const MS &ms)
01178 #if(CXSC_INDEX_CHECK)
01179                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01180 #else
01181         throw();
01182 #endif
01183  template <class MS,class M,class E> friend      E _msmlimult(const MS &ms, const M &m2)
01184 #if(CXSC_INDEX_CHECK)
01185                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01186 #else
01187         throw();
01188 #endif
01189  template <class MS1,class MS2,class E> friend   E _msmslimult(const MS1 &ms1, const MS2 &ms2)
01190 #if(CXSC_INDEX_CHECK)
01191                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01192 #else
01193         throw();
01194 #endif
01195 
01196         // matrix-vector
01197  template <class M,class V,class E> friend       E _mvlimult(const M &m,const V &v)
01198 #if(CXSC_INDEX_CHECK)
01199                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01200 #else
01201         throw();
01202 #endif
01203  template <class V,class M,class E> friend       E _vmlimult(const V &v,const M &m)
01204 #if(CXSC_INDEX_CHECK)
01205                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01206 #else
01207         throw();
01208 #endif
01209   /*   friend TINLINE l_ivector _mvslimult<imatrix,l_rvector_slice,l_ivector>(const imatrix &m,const l_rvector_slice &v)
01210 #if(CXSC_INDEX_CHECK)
01211         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01212 #else
01213         throw();
01214         #endif */
01215   /*   friend TINLINE l_ivector _vsmlimult<l_rvector_slice,imatrix,l_ivector>(const l_rvector_slice &v,const imatrix &m)
01216 #if(CXSC_INDEX_CHECK)
01217         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01218 #else
01219         throw();
01220         #endif */
01221 
01222         // matrix-matrix
01223  template <class M1,class M2,class S> friend     M1 &_mmlimultassign(M1 &m1,const M2 &m2)
01224 #if(CXSC_INDEX_CHECK)
01225                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01226 #else
01227         throw();
01228 #endif
01229  template <class M,class MS,class S> friend      M &_mmslimultassign(M &m1,const MS &ms)
01230 #if(CXSC_INDEX_CHECK)
01231                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01232 #else
01233         throw();
01234 #endif
01235 
01236         // matrix-vector
01237  template <class V,class M,class S> friend       V &_vmlimultassign(V &v,const M &m)
01238 #if(CXSC_INDEX_CHECK)
01239                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01240 #else
01241         throw();
01242 #endif
01243  template <class VS,class M,class S> friend      VS &_vsmlimultassign(VS &v,const M &m)
01244 #if(CXSC_INDEX_CHECK)
01245                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01246 #else
01247         throw();
01248 #endif
01249 
01250 /*   friend TINLINE l_ivector _mvslimult<imatrix,l_ivector_slice,l_ivector>(const imatrix &m,const l_ivector_slice &v)
01251 #if(CXSC_INDEX_CHECK)
01252         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01253 #else
01254         throw();
01255         #endif */
01256   /*   friend TINLINE l_ivector _vsmlimult<l_ivector_slice,imatrix,l_ivector>(const l_ivector_slice &v,const imatrix &m)
01257 #if(CXSC_INDEX_CHECK)
01258         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01259 #else
01260         throw();
01261         #endif */
01262 
01263 #endif
01264         
01265         //--------------------------  Konstruktoren ----------------------------
01266 
01267 // interval
01269         INLINE imatrix(const imatrix &rm) throw();
01271         INLINE imatrix(const imatrix_slice &rm) throw();
01273         INLINE imatrix(const simatrix &rm);
01275         INLINE imatrix(const simatrix_slice &rm);
01277         INLINE imatrix() throw();
01279         explicit INLINE imatrix(const int &m, const int &n)
01280 #if(CXSC_INDEX_CHECK)
01281         throw(ERROR_IMATRIX_WRONG_BOUNDARIES);
01282 #else
01283         throw();
01284 #endif
01285 
01286         explicit INLINE imatrix(const int &m1, const int &n1, const int &m2, const int &n2)
01287 #if(CXSC_INDEX_CHECK)
01288         throw(ERROR_IMATRIX_WRONG_BOUNDARIES);
01289 #else
01290         throw();
01291 #endif
01292 
01293         explicit INLINE imatrix(const ivector &v) throw();
01295         explicit INLINE imatrix(const ivector_slice &v) throw();
01297         explicit INLINE imatrix(const interval &r) throw();
01299         INLINE imatrix &operator =(const interval &r) throw();
01301         INLINE imatrix &operator =(const imatrix &m) throw();
01303         INLINE imatrix &operator =(const imatrix_slice &ms) throw();
01305         INLINE imatrix &operator =(const simatrix &m);
01307         INLINE imatrix &operator =(const simatrix_slice &ms);
01309         INLINE imatrix &operator =(const ivector &v) throw();
01311         INLINE imatrix &operator =(const ivector_slice &v) throw();
01312 //  real
01314         explicit INLINE imatrix(const real &r) throw();
01316         explicit INLINE imatrix(const rmatrix &rm) throw();
01318         explicit INLINE imatrix(const rmatrix_slice &rm) throw();
01320         explicit INLINE imatrix(const srmatrix &rm);
01322         explicit INLINE imatrix(const srmatrix_slice &rm);
01324         explicit INLINE imatrix(const rvector &v) throw();
01326         explicit INLINE imatrix(const rvector_slice &v) throw();
01328         INLINE imatrix &operator =(const real &r) throw();
01330         INLINE imatrix &operator =(const rmatrix &m) throw();
01332         INLINE imatrix &operator =(const rmatrix_slice &ms) throw();
01334         INLINE imatrix &operator =(const srmatrix &m);
01336         INLINE imatrix &operator =(const srmatrix_slice &ms);
01338         INLINE imatrix &operator =(const rvector &v) throw();
01340         INLINE imatrix &operator =(const rvector_slice &v) throw();
01341 
01342         //--------------------------- Destruktoren -----------------------------
01343 
01344         INLINE ~imatrix() throw() { delete [] dat; }
01345 
01346         //--------------------------- Operatoren -----------------------------
01347 
01349         INLINE imatrix &operator+=(const simatrix&);
01351         INLINE imatrix &operator+=(const simatrix_slice&);
01353         INLINE imatrix &operator+=(const srmatrix&);
01355         INLINE imatrix &operator+=(const srmatrix_slice&);
01357         INLINE imatrix &operator-=(const simatrix&);
01359         INLINE imatrix &operator-=(const simatrix_slice&);
01361         INLINE imatrix &operator-=(const srmatrix&);
01363         INLINE imatrix &operator-=(const srmatrix_slice&);
01365         INLINE imatrix &operator*=(const simatrix&);
01367         INLINE imatrix &operator*=(const simatrix_slice&);
01369         INLINE imatrix &operator*=(const srmatrix&);
01371         INLINE imatrix &operator*=(const srmatrix_slice&);
01373         INLINE imatrix &operator|=(const simatrix&);
01375         INLINE imatrix &operator|=(const simatrix_slice&);
01377         INLINE imatrix &operator|=(const srmatrix&);
01379         INLINE imatrix &operator|=(const srmatrix_slice&);
01381         INLINE imatrix &operator&=(const simatrix&);
01383         INLINE imatrix &operator&=(const simatrix_slice&);
01385         INLINE imatrix &operator&=(const srmatrix&);
01387         INLINE imatrix &operator&=(const srmatrix_slice&);
01388 
01390         INLINE imatrix operator()(const intvector& p, const intvector& q);
01392         INLINE imatrix operator()(const intmatrix& P, const intmatrix& Q);
01394         INLINE imatrix operator()(const intvector& p);
01396         INLINE imatrix operator()(const intmatrix& P);
01397 
01398         //------------------------- Standardfunktionen -------------------------
01399 
01401         INLINE imatrix_subv operator [](const int &i) const
01402 #if(CXSC_INDEX_CHECK)
01403         throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT);
01404 #else
01405         throw();
01406 #endif
01407 
01408         INLINE imatrix_subv operator [](const cxscmatrix_column &i) const
01409 #if(CXSC_INDEX_CHECK)
01410         throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT);
01411 #else
01412         throw();
01413 #endif
01414 
01415         INLINE imatrix &operator ()() throw() { return *this; }
01417         INLINE imatrix_slice operator ()(const int &m, const int &n)
01418 #if(CXSC_INDEX_CHECK)
01419         throw(ERROR_IMATRIX_SUB_ARRAY_TOO_BIG);
01420 #else
01421         throw();
01422 #endif
01423 
01424         INLINE imatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
01425 #if(CXSC_INDEX_CHECK)
01426         throw(ERROR_IMATRIX_SUB_ARRAY_TOO_BIG);
01427 #else
01428         throw();
01429 #endif
01430         INLINE operator void*() throw();
01431 //#else
01432 //#endif
01433 };
01434 
01436 
01441 class imatrix_slice
01442 {
01443         friend class imatrix;
01444         friend class cimatrix;
01445         friend class l_imatrix;
01446         private:
01447         interval *dat;
01448         int offset1,offset2,mxsize,mysize;
01449         int start1,end1,start2,end2,sxsize,sysize;     // slice size
01450 
01451         public:
01452 //#if(CXSC_INDEX_CHECK)
01453 #ifdef _CXSC_FRIEND_TPL
01454         //----------------- Templates ---------------------------------------
01455 template <class V,class MS,class S> friend  void _vmsconstr(V &v,const MS &m)
01456 #if(CXSC_INDEX_CHECK)
01457         throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>);
01458 #else
01459         throw();
01460 #endif
01461  template <class MS,class M> friend      MS &_msmassign(MS &ms,const M &m)
01462 #if(CXSC_INDEX_CHECK)
01463                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01464 #else
01465         throw();
01466 #endif
01467  template <class MS1,class MS2> friend   MS1 &_msmsassign(MS1 &ms1,const MS2 &ms)
01468 #if(CXSC_INDEX_CHECK)
01469                 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01470 #else
01471         throw();
01472 #endif
01473  template <class M,class MS2,class S> friend     M &_mmsassign(M &m,const MS2 &ms) throw();
01474  template <class MS,class S> friend      MS &_mssassign(MS &ms,const S &r) throw();
01475  template <class MS> friend      int _mslb(const MS &ms, const int &i)
01476 #if(CXSC_INDEX_CHECK)
01477         throw(ERROR__WRONG_ROW_OR_COL<MS>);
01478 #else
01479         throw();
01480 #endif
01481  template <class MS> friend      int _msub(const MS &ms, const int &i)
01482 #if(CXSC_INDEX_CHECK)
01483         throw(ERROR__WRONG_ROW_OR_COL<MS>);
01484 #else
01485         throw();
01486 #endif
01487  template <class MS,class E> friend      E _msabs(const MS &ms) throw();
01488  template <class MS,class E> friend      E _msdiam(const MS &ms) throw();
01489  template <class MS,class E> friend      E _msmid(const MS &ms) throw();
01490  template <class MS,class E> friend      E _msinf(const MS &ms) throw();
01491  template <class MS,class E> friend      E _mssup(const MS &ms) throw();
01492  template <class MS1,class M2> friend    MS1 &_msmsetinf(MS1 &ms1,const M2 &m2)
01493 #if(CXSC_INDEX_CHECK)
01494                 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01495 #else
01496         throw();
01497 #endif
01498  template <class MS1,class M2> friend    MS1 &_msmsetsup(MS1 &ms1,const M2 &m2)
01499 #if(CXSC_INDEX_CHECK)
01500                 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01501 #else
01502         throw();
01503 #endif
01504  template <class MS1,class MS2> friend   MS1 &_msmssetinf(MS1 &ms1,const MS2 &ms2)
01505 #if(CXSC_INDEX_CHECK)
01506                 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01507 #else
01508         throw();
01509 #endif
01510  template <class MS1,class MS2> friend   MS1 &_msmssetsup(MS1 &ms1,const MS2 &ms2)
01511 #if(CXSC_INDEX_CHECK)
01512                 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01513 #else
01514         throw();
01515 #endif
01516  template <class MS1,class M2> friend    MS1 &_msmusetinf(MS1 &ms1,const M2 &m2)
01517 #if(CXSC_INDEX_CHECK)
01518                 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01519 #else
01520         throw();
01521 #endif
01522  template <class MS1,class M2> friend    MS1 &_msmusetsup(MS1 &ms1,const M2 &m2)
01523 #if(CXSC_INDEX_CHECK)
01524                 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01525 #else
01526         throw();
01527 #endif
01528  template <class MS1,class MS2> friend   MS1 &_msmsusetinf(MS1 &ms1,const MS2 &ms2)
01529 #if(CXSC_INDEX_CHECK)
01530                 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01531 #else
01532         throw();
01533 #endif
01534  template <class MS1,class MS2> friend   MS1 &_msmsusetsup(MS1 &ms1,const MS2 &ms2)
01535 #if(CXSC_INDEX_CHECK)
01536                 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01537 #else
01538         throw();
01539 #endif
01540         //-------- matrix-matrix --------------
01541  template <class MS,class E> friend      E _msminus(const MS &ms) throw();
01542  template <class M,class MS,class E> friend      E _mmsplus(const M &m,const MS &ms)
01543 #if(CXSC_INDEX_CHECK)
01544                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01545 #else
01546         throw();
01547 #endif
01548  template <class MS1,class MS2,class E> friend   E _msmsplus(const MS1 &m1,const MS2 &m2)
01549 #if(CXSC_INDEX_CHECK)
01550                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01551 #else
01552         throw();
01553 #endif
01554  template <class M,class MS> friend      M &_mmsplusassign(M &m1,const MS &ms)
01555 #if(CXSC_INDEX_CHECK)
01556                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01557 #else
01558         throw();
01559 #endif
01560  template <class MS,class M> friend      MS &_msmplusassign(MS &ms,const M &m1)
01561 #if(CXSC_INDEX_CHECK)
01562                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01563 #else
01564         throw();
01565 #endif
01566  template <class MS1,class MS2> friend   MS1 &_msmsplusassign(MS1 &ms1,const MS2 &ms2)
01567 #if(CXSC_INDEX_CHECK)
01568                 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01569 #else
01570         throw();
01571 #endif
01572  template <class M,class MS,class E> friend      E _mmsminus(const M &m,const MS &ms)
01573 #if(CXSC_INDEX_CHECK)
01574                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01575 #else
01576         throw();
01577 #endif
01578  template <class MS,class M,class E> friend      E _msmminus(const MS &ms,const M &m)
01579 #if(CXSC_INDEX_CHECK)
01580                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01581 #else
01582         throw();
01583 #endif
01584  template <class MS1,class MS2,class E> friend   E _msmsminus(const MS1 &ms1,const MS2 &ms2)
01585 #if(CXSC_INDEX_CHECK)
01586                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01587 #else
01588         throw();
01589 #endif
01590  template <class M,class MS> friend      M &_mmsminusassign(M &m1,const MS &ms)
01591 #if(CXSC_INDEX_CHECK)
01592                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01593 #else
01594         throw();
01595 #endif
01596  template <class MS,class M> friend      MS &_msmminusassign(MS &ms,const M &m1)
01597 #if(CXSC_INDEX_CHECK)
01598                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01599 #else
01600         throw();
01601 #endif
01602  template <class MS1,class MS2> friend   MS1 &_msmsminusassign(MS1 &ms1,const MS2 &ms2)
01603 #if(CXSC_INDEX_CHECK)
01604                 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01605 #else
01606         throw();
01607 #endif
01608  template <class M,class MS,class E> friend      E _mmsimult(const M &m1, const MS &ms)
01609 #if(CXSC_INDEX_CHECK)
01610                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01611 #else
01612         throw();
01613 #endif
01614  template <class MS,class M,class E> friend      E _msmimult(const MS &ms, const M &m2)
01615 #if(CXSC_INDEX_CHECK)
01616                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01617 #else
01618         throw();
01619 #endif
01620  template <class M,class MS,class S> friend      M &_mmsimultassign(M &m1,const MS &ms)
01621 #if(CXSC_INDEX_CHECK)
01622                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01623 #else
01624         throw();
01625 #endif
01626  template <class MS1,class MS2,class E> friend   E _msmsimult(const MS1 &ms1, const MS2 &ms2)
01627 #if(CXSC_INDEX_CHECK)
01628                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01629 #else
01630         throw();
01631 #endif
01632  template <class M,class MS,class E> friend      E _mmsconv(const M &m,const MS &ms)
01633 #if(CXSC_INDEX_CHECK)
01634                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01635 #else
01636         throw();
01637 #endif
01638  template <class M,class MS> friend      M &_mmsconvassign(M &m1,const MS &ms)
01639 #if(CXSC_INDEX_CHECK)
01640                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01641 #else
01642         throw();
01643 #endif
01644  template <class MS,class M> friend      MS &_msmconvassign(MS &ms,const M &m1)
01645 #if(CXSC_INDEX_CHECK)
01646                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01647 #else
01648         throw();
01649 #endif
01650  template <class MS1,class MS2> friend   MS1 &_msmsconvassign(MS1 &ms1,const MS2 &ms2)
01651 #if(CXSC_INDEX_CHECK)
01652                 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01653 #else
01654         throw();
01655 #endif
01656  template <class MS1,class MS2,class E> friend   E _msmsconv(const MS1 &m1,const MS2 &m2)
01657 #if(CXSC_INDEX_CHECK)
01658                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01659 #else
01660         throw();
01661 #endif
01662  template <class M,class MS,class E> friend      E _mmssect(const M &m,const MS &ms)
01663 #if(CXSC_INDEX_CHECK)
01664                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01665 #else
01666         throw();
01667 #endif
01668  template <class M,class MS> friend      M &_mmssectassign(M &m1,const MS &ms)
01669 #if(CXSC_INDEX_CHECK)
01670                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01671 #else
01672         throw();
01673 #endif
01674  template <class MS,class M> friend      MS &_msmsectassign(MS &ms,const M &m1)
01675 #if(CXSC_INDEX_CHECK)
01676                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01677 #else
01678         throw();
01679 #endif
01680  template <class MS1,class MS2> friend   MS1 &_msmssectassign(MS1 &ms1,const MS2 &ms2)
01681 #if(CXSC_INDEX_CHECK)
01682                 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01683 #else
01684         throw();
01685 #endif
01686  template <class MS1,class MS2,class E> friend   E _msmssect(const MS1 &m1,const MS2 &m2)
01687 #if(CXSC_INDEX_CHECK)
01688                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01689 #else
01690         throw();
01691 #endif
01692         //--------- matrix-vector --------------
01693  template <class MS,class V,class E> friend      E _msvimult(const MS &ms,const V &v)
01694 #if(CXSC_INDEX_CHECK)
01695                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01696 #else
01697         throw();
01698 #endif
01699  template <class V,class MS,class E> friend      E _vmsimult(const V &v,const MS &ms)
01700 #if(CXSC_INDEX_CHECK)
01701                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01702 #else
01703         throw();
01704 #endif
01705  template <class V,class MS,class S> friend      V &_vmsimultassign(V &v,const MS &ms)
01706 #if(CXSC_INDEX_CHECK)
01707                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01708 #else
01709         throw();
01710 #endif
01711         //--------- matrix-scalar --------------
01712  template <class S,class MS,class E> friend      E _smsmult(const S &c, const MS &ms) throw();
01713  template <class MS,class S> friend      MS &_mssmultassign(MS &ms,const S &c) throw();
01714  template <class MS,class S,class E> friend      E _mssdiv(const MS &ms, const S &c) throw();
01715  template <class MS,class S> friend      MS &_mssdivassign(MS &ms,const S &c) throw();
01716         
01717  template <class MS> friend      void *_msvoid(const MS &ms) throw();
01718  template <class MS> friend      bool _msnot(const MS &ms) throw();
01719  template <class M,class MS> friend      bool _mmseq(const M &m1,const MS &ms) throw();
01720  template <class M,class MS> friend      bool _mmsneq(const M &m1,const MS &ms) throw();
01721  template <class M,class MS> friend      bool _mmsless(const M &m1,const MS &ms) throw();
01722  template <class M,class MS> friend      bool _mmsleq(const M &m1,const MS &ms) throw();
01723  template <class MS,class M> friend      bool _msmless(const MS &ms,const M &m1) throw();
01724  template <class MS,class M> friend      bool _msmleq(const MS &ms,const M &m1) throw();
01725  template <class MS1,class MS2> friend   bool _msmseq(const MS1 &ms1,const MS2 &ms2) throw();
01726  template <class MS1,class MS2> friend   bool _msmsneq(const MS1 &ms1,const MS2 &ms2) throw();
01727  template <class MS1,class MS2> friend   bool _msmsless(const MS1 &ms1,const MS2 &ms2) throw();
01728  template <class MS1,class MS2> friend   bool _msmsleq(const MS1 &ms1,const MS2 &ms2) throw();
01729  template <class MS> friend     std::ostream &_msout(std::ostream &s,const MS &r) throw();
01730  template <class MS> friend     std::istream &_msin(std::istream &s,MS &r) throw();
01731 
01732         // complex ---------
01733         // matrix-matrix
01734  template <class M,class MS,class E> friend      E _mmscimult(const M &m1, const MS &ms)
01735 #if(CXSC_INDEX_CHECK)
01736                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01737 #else
01738         throw();
01739 #endif
01740  template <class MS,class M,class E> friend      E _msmcimult(const MS &ms, const M &m2)
01741 #if(CXSC_INDEX_CHECK)
01742                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01743 #else
01744         throw();
01745 #endif
01746  template <class MS1,class MS2,class E> friend   E _msmscimult(const MS1 &ms1, const MS2 &ms2)
01747 #if(CXSC_INDEX_CHECK)
01748                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01749 #else
01750         throw();
01751 #endif
01752 
01753         // matrix-vector
01754  template <class MS,class V,class E> friend      E _msvcimult(const MS &ms,const V &v)
01755 #if(CXSC_INDEX_CHECK)
01756                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01757 #else
01758         throw();
01759 #endif
01760  template <class V,class MS,class E> friend      E _vmscimult(const V &v,const MS &ms)
01761 #if(CXSC_INDEX_CHECK)
01762                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01763 #else
01764         throw();
01765 #endif
01766 
01767         // civector --------
01768  template <class M1,class MS2> friend    M1 &_mmssetre(M1 &m1,const MS2 &ms2)
01769 #if(CXSC_INDEX_CHECK)
01770                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01771 #else
01772         throw();
01773 #endif
01774  template <class M1,class MS2> friend    M1 &_mmssetim(M1 &m1,const MS2 &ms2)
01775 #if(CXSC_INDEX_CHECK)
01776                 throw(ERROR__OP_WITH_WRONG_DIM<M1>);
01777 #else
01778         throw();
01779 #endif
01780  template <class MS1,class MS2> friend   MS1 &_msmssetre(MS1 &ms1,const MS2 &ms2)
01781 #if(CXSC_INDEX_CHECK)
01782                 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01783 #else
01784         throw();
01785 #endif
01786  template <class MS1,class MS2> friend   MS1 &_msmssetim(MS1 &ms1,const MS2 &ms2)
01787 #if(CXSC_INDEX_CHECK)
01788                 throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
01789 #else
01790         throw();
01791 #endif
01792         // matrix-matrix
01793  template <class M,class MS,class S> friend      M &_mmscimultassign(M &m1,const MS &ms)
01794 #if(CXSC_INDEX_CHECK)
01795                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01796 #else
01797         throw();
01798 #endif
01799 
01800         // matrix-vector
01801  template <class V,class MS,class S> friend      V &_vmscimultassign(V &v,const MS &ms)
01802 #if(CXSC_INDEX_CHECK)
01803                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01804 #else
01805         throw();
01806 #endif
01807 
01808   /*   friend TINLINE civector _msvscimult<imatrix_slice,civector_slice,civector>(const imatrix_slice &ms,const civector_slice &v)
01809 #if(CXSC_INDEX_CHECK)
01810         throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
01811 #else
01812         throw();
01813         #endif */
01814   /*   friend TINLINE civector _vsmscimult<civector_slice,imatrix_slice,civector>(const civector_slice &v,const imatrix_slice &ms)
01815 #if(CXSC_INDEX_CHECK)
01816         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01817 #else
01818         throw();
01819         #endif */
01820   /*   friend TINLINE civector &_vsmscimultassign<civector_slice,imatrix_slice,cinterval>(civector_slice &v,const imatrix_slice &m)
01821 #if(CXSC_INDEX_CHECK)
01822         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01823 #else
01824         throw();
01825         #endif */
01826 
01827         // l_real ---------
01828         // matrix-matrix
01829  template <class M,class MS,class E> friend      E _mmslimult(const M &m1, const MS &ms)
01830 #if(CXSC_INDEX_CHECK)
01831                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01832 #else
01833         throw();
01834 #endif
01835  template <class MS,class M,class E> friend      E _msmlimult(const MS &ms, const M &m2)
01836 #if(CXSC_INDEX_CHECK)
01837                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01838 #else
01839         throw();
01840 #endif
01841  template <class MS1,class MS2,class E> friend   E _msmslimult(const MS1 &ms1, const MS2 &ms2)
01842 #if(CXSC_INDEX_CHECK)
01843                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01844 #else
01845         throw();
01846 #endif
01847 
01848         // matrix-vector
01849  template <class MS,class V,class E> friend      E _msvlimult(const MS &ms,const V &v)
01850 #if(CXSC_INDEX_CHECK)
01851                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01852 #else
01853         throw();
01854 #endif
01855  template <class V,class MS,class E> friend      E _vmslimult(const V &v,const MS &ms)
01856 #if(CXSC_INDEX_CHECK)
01857                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01858 #else
01859         throw();
01860 #endif
01861 
01862         // matrix-matrix
01863  template <class M,class MS,class S> friend      M &_mmslimultassign(M &m1,const MS &ms)
01864 #if(CXSC_INDEX_CHECK)
01865                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01866 #else
01867         throw();
01868 #endif
01869 
01870         // matrix-vector
01871  template <class V,class MS,class S> friend      V &_vmslimultassign(V &v,const MS &ms)
01872 #if(CXSC_INDEX_CHECK)
01873                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01874 #else
01875         throw();
01876 #endif
01877 
01878   /*   friend TINLINE l_ivector _msvslimult<imatrix_slice,l_ivector_slice,l_ivector>(const imatrix_slice &ms,const l_ivector_slice &v)
01879 #if(CXSC_INDEX_CHECK)
01880         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01881 #else
01882         throw();
01883         #endif */
01884   /*  friend TINLINE l_ivector _vsmslimult<l_ivector_slice,imatrix_slice,l_ivector>(const l_ivector_slice &v,const imatrix_slice &ms)
01885 #if(CXSC_INDEX_CHECK)
01886         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01887 #else
01888         throw();
01889         #endif */
01890   /*   friend TINLINE l_ivector &_vsmslimultassign<l_ivector_slice,imatrix_slice,l_interval>(l_ivector_slice &v,const imatrix_slice &m)
01891 #if(CXSC_INDEX_CHECK)
01892         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01893 #else
01894         throw();
01895         #endif */
01896 #endif
01897 
01898         //--------------- Konstruktoren ----------------------------------------
01899 
01901         explicit INLINE imatrix_slice(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) { }
01903         explicit INLINE imatrix_slice(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) { }
01904         public: 
01906         INLINE imatrix_slice(const 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) { }
01907         public:
01908 
01909         //---------------- Standardfunktionen -----------------------------------
01910 
01911         friend INLINE ivector::ivector(const imatrix_slice &sl)
01912 #if(CXSC_INDEX_CHECK)
01913         throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
01914 #else
01915         throw();
01916 #endif
01917         friend INLINE imatrix::imatrix(const imatrix_slice &) throw();
01919         INLINE imatrix_slice &operator =(const imatrix &m)
01920 #if(CXSC_INDEX_CHECK)
01921         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01922 #else
01923         throw();
01924 #endif
01925 
01926         INLINE imatrix_slice &operator =(const imatrix_slice &ms)
01927 #if(CXSC_INDEX_CHECK)
01928         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01929 #else
01930         throw();
01931 #endif
01932 
01933         INLINE imatrix_slice &operator =(const interval &r) throw();
01935         INLINE imatrix_slice &operator =(const ivector &v)
01936 #if(CXSC_INDEX_CHECK)
01937         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01938 #else
01939         throw();
01940 #endif
01941 
01942         INLINE imatrix_slice &operator =(const ivector_slice &v)
01943 #if(CXSC_INDEX_CHECK)
01944         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01945 #else
01946         throw();
01947 #endif
01948 
01949         INLINE imatrix_slice &operator =(const rmatrix &m)
01950 #if(CXSC_INDEX_CHECK)
01951         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01952 #else
01953         throw();
01954 #endif
01955 
01956         INLINE imatrix_slice &operator =(const rmatrix_slice &ms)
01957 #if(CXSC_INDEX_CHECK)
01958         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01959 #else
01960         throw();
01961 #endif
01962 
01963         INLINE imatrix_slice &operator =(const real &r) throw();
01965         INLINE imatrix_slice &operator =(const rvector &v)
01966 #if(CXSC_INDEX_CHECK)
01967         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01968 #else
01969         throw();
01970 #endif
01971 
01972         INLINE imatrix_slice &operator =(const rvector_slice &v)
01973 #if(CXSC_INDEX_CHECK)
01974         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01975 #else
01976         throw();
01977 #endif
01978 
01979         INLINE imatrix_subv operator [](const int &i)
01980 #if(CXSC_INDEX_CHECK)
01981         throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT);
01982 #else
01983         throw();
01984 #endif
01985 
01986         INLINE imatrix_subv operator [](const cxscmatrix_column &i)
01987 #if(CXSC_INDEX_CHECK)
01988         throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT);
01989 #else
01990         throw();
01991 #endif
01992 
01994         INLINE imatrix_subv operator [](const int &i) const
01995 #if(CXSC_INDEX_CHECK)
01996         throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT);
01997 #else
01998         throw();
01999 #endif
02000 
02001         INLINE imatrix_subv operator [](const cxscmatrix_column &i) const
02002 #if(CXSC_INDEX_CHECK)
02003         throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT);
02004 #else
02005         throw();
02006 #endif
02007 
02008 
02010         INLINE imatrix_slice &operator ()() throw() { return *this; }
02012         INLINE imatrix_slice operator ()(const int &m, const int &n)
02013 #if(CXSC_INDEX_CHECK)
02014         throw(ERROR_IMATRIX_SUB_ARRAY_TOO_BIG);
02015 #else
02016         throw();
02017 #endif
02018 
02019         INLINE imatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
02020 #if(CXSC_INDEX_CHECK)
02021         throw(ERROR_IMATRIX_SUB_ARRAY_TOO_BIG);
02022 #else
02023         throw();
02024 #endif
02025 
02026         INLINE imatrix_slice &operator *=(const imatrix &m)
02027 #if(CXSC_INDEX_CHECK)
02028         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02029 #else
02030         throw();
02031 #endif
02032 
02033         INLINE imatrix_slice &operator *=(const rmatrix &m)
02034 #if(CXSC_INDEX_CHECK)
02035         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02036 #else
02037         throw();
02038 #endif
02039 
02040         INLINE imatrix_slice &operator *=(const imatrix_slice &ms2)
02041 #if(CXSC_INDEX_CHECK)
02042         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02043 #else
02044         throw();
02045 #endif
02046 
02047         INLINE imatrix_slice &operator *=(const rmatrix_slice &ms2)
02048 #if(CXSC_INDEX_CHECK)
02049         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02050 #else
02051         throw();
02052 #endif
02053 
02054         INLINE imatrix_slice &operator +=(const imatrix &m1)
02055 #if(CXSC_INDEX_CHECK)
02056         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02057 #else
02058         throw();
02059 #endif
02060 
02061         INLINE imatrix_slice &operator +=(const rmatrix &m1)
02062 #if(CXSC_INDEX_CHECK)
02063         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02064 #else
02065         throw();
02066 #endif
02067 
02068         INLINE imatrix_slice &operator +=(const imatrix_slice &ms2)
02069 #if(CXSC_INDEX_CHECK)
02070         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02071 #else
02072         throw();
02073 #endif
02074 
02075         INLINE imatrix_slice &operator +=(const rmatrix_slice &ms2)
02076 #if(CXSC_INDEX_CHECK)
02077         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02078 #else
02079         throw();
02080 #endif
02081 
02082         INLINE imatrix_slice &operator -=(const imatrix &m1)
02083 #if(CXSC_INDEX_CHECK)
02084         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02085 #else
02086         throw();
02087 #endif
02088 
02089         INLINE imatrix_slice &operator -=(const rmatrix &m1)
02090 #if(CXSC_INDEX_CHECK)
02091         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02092 #else
02093         throw();
02094 #endif
02095 
02096         INLINE imatrix_slice &operator -=(const imatrix_slice &ms2)
02097 #if(CXSC_INDEX_CHECK)
02098         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02099 #else
02100         throw();
02101 #endif
02102 
02103         INLINE imatrix_slice &operator -=(const rmatrix_slice &ms2)
02104 #if(CXSC_INDEX_CHECK)
02105         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02106 #else
02107         throw();
02108 #endif
02109 
02110         INLINE imatrix_slice &operator |=(const imatrix &m1)
02111 #if(CXSC_INDEX_CHECK)
02112         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02113 #else
02114         throw();
02115 #endif
02116 
02117         INLINE imatrix_slice &operator |=(const rmatrix &m1)
02118 #if(CXSC_INDEX_CHECK)
02119         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02120 #else
02121         throw();
02122 #endif
02123 
02124         INLINE imatrix_slice &operator |=(const imatrix_slice &ms2)
02125 #if(CXSC_INDEX_CHECK)
02126         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02127 #else
02128         throw();
02129 #endif
02130 
02131         INLINE imatrix_slice &operator |=(const rmatrix_slice &ms2)
02132 #if(CXSC_INDEX_CHECK)
02133         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02134 #else
02135         throw();
02136 #endif
02137 
02138         INLINE imatrix_slice &operator &=(const imatrix &m1)
02139 #if(CXSC_INDEX_CHECK)
02140         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02141 #else
02142         throw();
02143 #endif
02144 
02145         INLINE imatrix_slice &operator &=(const rmatrix &m1)
02146 #if(CXSC_INDEX_CHECK)
02147         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02148 #else
02149         throw();
02150 #endif
02151 
02152         INLINE imatrix_slice &operator &=(const imatrix_slice &ms2)
02153 #if(CXSC_INDEX_CHECK)
02154         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02155 #else
02156         throw();
02157 #endif
02158 
02159         INLINE imatrix_slice &operator &=(const rmatrix_slice &ms2)
02160 #if(CXSC_INDEX_CHECK)
02161         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02162 #else
02163         throw();
02164 #endif
02165 
02166         INLINE imatrix_slice &operator *=(const interval &c) throw();
02168         INLINE imatrix_slice &operator *=(const real &c) throw();
02170         INLINE imatrix_slice &operator /=(const interval &c) throw();
02172         INLINE imatrix_slice &operator /=(const real &c) throw();
02173         INLINE operator void*() throw();
02174 
02175         //Sparse operators
02177         INLINE imatrix_slice &operator+=(const simatrix&);
02179         INLINE imatrix_slice &operator+=(const simatrix_slice&);
02181         INLINE imatrix_slice &operator+=(const srmatrix&);
02183         INLINE imatrix_slice &operator+=(const srmatrix_slice&);
02185         INLINE imatrix_slice &operator-=(const simatrix&);
02187         INLINE imatrix_slice &operator-=(const simatrix_slice&);
02189         INLINE imatrix_slice &operator-=(const srmatrix&);
02191         INLINE imatrix_slice &operator-=(const srmatrix_slice&);
02193         INLINE imatrix_slice &operator*=(const simatrix&);
02195         INLINE imatrix_slice &operator*=(const simatrix_slice&);
02197         INLINE imatrix_slice &operator*=(const srmatrix&);
02199         INLINE imatrix_slice &operator*=(const srmatrix_slice&);
02201         INLINE imatrix_slice &operator|=(const simatrix&);
02203         INLINE imatrix_slice &operator|=(const simatrix_slice&);
02205         INLINE imatrix_slice &operator|=(const srmatrix&);
02207         INLINE imatrix_slice &operator|=(const srmatrix_slice&);
02209         INLINE imatrix_slice &operator&=(const simatrix&);
02211         INLINE imatrix_slice &operator&=(const simatrix_slice&);
02213         INLINE imatrix_slice &operator&=(const srmatrix&);
02215         INLINE imatrix_slice &operator&=(const srmatrix_slice&);
02216 
02217 //#else
02218 //#endif
02219 };
02220 
02221 //================================================================
02222 //====================== Subvector Functions =====================
02223 
02224 //=======================Vector / Scalar =========================
02225 
02227         INLINE ivector operator /(const imatrix_subv &rv, const interval &s) throw();
02229         INLINE ivector operator *(const imatrix_subv &rv, const interval &s) throw();
02231         INLINE ivector operator *(const interval &s, const imatrix_subv &rv) throw();
02233         INLINE ivector abs(const imatrix_subv &mv) throw();
02235         INLINE rvector absmin(const imatrix_subv &mv) throw();
02237         INLINE rvector absmax(const imatrix_subv &mv) throw();
02239         INLINE rvector diam(const imatrix_subv &mv) throw();
02241         INLINE rvector mid(const imatrix_subv &mv) throw();
02243         INLINE rvector Inf(const imatrix_subv &mv) throw();
02245         INLINE rvector Sup(const imatrix_subv &mv) throw();
02246 
02247 //  real
02248 
02249 //======================== Vector / Vector ========================
02250 
02252         INLINE imatrix_subv &SetInf(imatrix_subv &mv,const rvector &rv)
02253 #if(CXSC_INDEX_CHECK)
02254         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02255 #else
02256         throw();
02257 #endif
02258 
02259         INLINE imatrix_subv &SetSup(imatrix_subv &mv,const rvector &rv)
02260 #if(CXSC_INDEX_CHECK)
02261         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02262 #else
02263         throw();
02264 #endif
02265 
02266         INLINE imatrix_subv &UncheckedSetInf(imatrix_subv &mv,const rvector &rv)
02267 #if(CXSC_INDEX_CHECK)
02268         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02269 #else
02270         throw();
02271 #endif
02272 
02273         INLINE imatrix_subv &UncheckedSetSup(imatrix_subv &mv,const rvector &rv)
02274 #if(CXSC_INDEX_CHECK)
02275         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02276 #else
02277         throw();
02278 #endif
02279 
02280         INLINE imatrix_subv &SetSup(imatrix_subv &iv,const real &r) throw();
02282         INLINE imatrix_subv &SetInf(imatrix_subv &iv,const real &r) throw();
02284         INLINE imatrix_subv &UncheckedSetSup(imatrix_subv &iv,const real &r) throw();
02286         INLINE imatrix_subv &SetUncheckedInf(imatrix_subv &iv,const real &r) throw();
02287 
02288         
02290          void accumulate(idotprecision &dp, const imatrix_subv & rv1, const imatrix_subv &rv2)
02291 #if(CXSC_INDEX_CHECK)
02292         throw(OP_WITH_WRONG_DIM);
02293 #else
02294         throw();
02295 #endif
02296 
02297          void accumulate(idotprecision &dp, const ivector & rv1, const imatrix_subv &rv2)
02298 #if(CXSC_INDEX_CHECK)
02299         throw(OP_WITH_WRONG_DIM);
02300 #else
02301         throw();
02302 #endif
02303 
02304          void accumulate(idotprecision &dp, const imatrix_subv & rv1, const ivector &rv2)
02305 #if(CXSC_INDEX_CHECK)
02306         throw(OP_WITH_WRONG_DIM);
02307 #else
02308         throw();
02309 #endif
02310 
02311          void accumulate(idotprecision &dp, const ivector_slice & sl1, const imatrix_subv &rv2)
02312 #if(CXSC_INDEX_CHECK)
02313         throw(OP_WITH_WRONG_DIM);
02314 #else
02315         throw();
02316 #endif
02317 
02318          void accumulate(idotprecision &dp, const imatrix_subv & rv1, const ivector_slice &sl2)
02319 #if(CXSC_INDEX_CHECK)
02320         throw(OP_WITH_WRONG_DIM);
02321 #else
02322         throw();
02323 #endif
02324         
02326          void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const imatrix_subv &rv2)
02327 #if(CXSC_INDEX_CHECK)
02328         throw(OP_WITH_WRONG_DIM);
02329 #else
02330         throw();
02331 #endif
02332 
02333          void accumulate(cidotprecision &dp, const ivector & rv1, const imatrix_subv &rv2)
02334 #if(CXSC_INDEX_CHECK)
02335         throw(OP_WITH_WRONG_DIM);
02336 #else
02337         throw();
02338 #endif
02339 
02340          void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const ivector &rv2)
02341 #if(CXSC_INDEX_CHECK)
02342         throw(OP_WITH_WRONG_DIM);
02343 #else
02344         throw();
02345 #endif
02346 
02347          void accumulate(cidotprecision &dp, const ivector_slice & sl1, const imatrix_subv &rv2)
02348 #if(CXSC_INDEX_CHECK)
02349         throw(OP_WITH_WRONG_DIM);
02350 #else
02351         throw();
02352 #endif
02353 
02354          void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const ivector_slice &sl2)
02355 #if(CXSC_INDEX_CHECK)
02356         throw(OP_WITH_WRONG_DIM);
02357 #else
02358         throw();
02359 #endif
02360         
02362         INLINE interval operator *(const imatrix_subv & rv1, const imatrix_subv &rv2)
02363 #if(CXSC_INDEX_CHECK)
02364         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
02365 #else
02366         throw();
02367 #endif
02368 
02369         INLINE interval operator *(const ivector & rv1, const imatrix_subv &rv2)
02370 #if(CXSC_INDEX_CHECK)
02371         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
02372 #else
02373         throw();
02374 #endif
02375 
02376         INLINE interval operator *(const imatrix_subv &rv1,const ivector &rv2)
02377 #if(CXSC_INDEX_CHECK)
02378         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
02379 #else
02380         throw();
02381 #endif
02382 
02383         INLINE interval operator *(const ivector_slice &sl,const imatrix_subv &sv)
02384 #if(CXSC_INDEX_CHECK)
02385         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
02386 #else
02387         throw();
02388 #endif
02389 
02390         INLINE interval operator *(const imatrix_subv &mv,const ivector_slice &vs)
02391 #if(CXSC_INDEX_CHECK)
02392         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
02393 #else
02394         throw();
02395 #endif
02396 
02398         INLINE ivector operator +(const imatrix_subv & rv1, const imatrix_subv &rv2)
02399 #if(CXSC_INDEX_CHECK)
02400         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
02401 #else
02402         throw();
02403 #endif
02404 
02405         INLINE ivector operator +(const imatrix_subv &rv1,const ivector &rv2)
02406 #if(CXSC_INDEX_CHECK)
02407         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
02408 #else
02409         throw();
02410 #endif
02411 
02412         INLINE ivector operator +(const ivector & rv1, const imatrix_subv &rv2)
02413 #if(CXSC_INDEX_CHECK)
02414         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
02415 #else
02416         throw();
02417 #endif
02418 
02419         INLINE ivector operator +(const ivector_slice &sl,const imatrix_subv &mv)
02420 #if(CXSC_INDEX_CHECK)
02421         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
02422 #else
02423         throw();
02424 #endif
02425 
02426         INLINE ivector operator +(const imatrix_subv &mv,const ivector_slice &sl)
02427 #if(CXSC_INDEX_CHECK)
02428         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
02429 #else
02430         throw();
02431 #endif
02432         
02434         INLINE ivector operator -(const imatrix_subv & rv1, const imatrix_subv &rv2)
02435 #if(CXSC_INDEX_CHECK)
02436         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
02437 #else
02438         throw();
02439 #endif
02440 
02441         INLINE ivector operator -(const ivector & rv1, const imatrix_subv &rv2)
02442 #if(CXSC_INDEX_CHECK)
02443         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
02444 #else
02445         throw();
02446 #endif
02447 
02448         INLINE ivector operator -(const imatrix_subv &rv1,const ivector &rv2)
02449 #if(CXSC_INDEX_CHECK)
02450         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
02451 #else
02452         throw();
02453 #endif
02454 
02455         INLINE ivector operator -(const ivector_slice &sl,const imatrix_subv &mv)
02456 #if(CXSC_INDEX_CHECK)
02457         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
02458 #else
02459         throw();
02460 #endif
02461 
02462         INLINE ivector operator -(const imatrix_subv &mv,const ivector_slice &sl)
02463 #if(CXSC_INDEX_CHECK)
02464         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM);
02465 #else
02466         throw();
02467 #endif
02468 
02469 // real
02470 
02472          void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const imatrix_subv &rv2)
02473 #if(CXSC_INDEX_CHECK)
02474         throw(OP_WITH_WRONG_DIM);
02475 #else
02476         throw();
02477 #endif
02478 
02479          void accumulate(idotprecision &dp, const rvector & rv1, const imatrix_subv &rv2)
02480 #if(CXSC_INDEX_CHECK)
02481         throw(OP_WITH_WRONG_DIM);
02482 #else
02483         throw();
02484 #endif
02485 
02486          void accumulate(idotprecision &dp, const rvector_slice & sl1, const imatrix_subv &rv2)
02487 #if(CXSC_INDEX_CHECK)
02488         throw(OP_WITH_WRONG_DIM);
02489 #else
02490         throw();
02491 #endif
02492 
02494          void accumulate(idotprecision &dp, const imatrix_subv & rv1, const rmatrix_subv &rv2)
02495 #if(CXSC_INDEX_CHECK)
02496         throw(OP_WITH_WRONG_DIM);
02497 #else
02498         throw();
02499 #endif
02500 
02501          void accumulate(idotprecision &dp, const imatrix_subv & rv1, const rvector &rv2)
02502 #if(CXSC_INDEX_CHECK)
02503         throw(OP_WITH_WRONG_DIM);
02504 #else
02505         throw();
02506 #endif
02507 
02508          void accumulate(idotprecision &dp, const imatrix_subv & rv1, const rvector_slice &sl2)
02509 #if(CXSC_INDEX_CHECK)
02510         throw(OP_WITH_WRONG_DIM);
02511 #else
02512         throw();
02513 #endif
02514 
02516          void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const imatrix_subv &rv2)
02517 #if(CXSC_INDEX_CHECK)
02518         throw(OP_WITH_WRONG_DIM);
02519 #else
02520         throw();
02521 #endif
02522 
02523          void accumulate(cidotprecision &dp, const rvector & rv1, const imatrix_subv &rv2)
02524 #if(CXSC_INDEX_CHECK)
02525         throw(OP_WITH_WRONG_DIM);
02526 #else
02527         throw();
02528 #endif
02529 
02530          void accumulate(cidotprecision &dp, const rvector_slice & sl1, const imatrix_subv &rv2)
02531 #if(CXSC_INDEX_CHECK)
02532         throw(OP_WITH_WRONG_DIM);
02533 #else
02534         throw();
02535 #endif
02536 
02538          void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const rmatrix_subv &rv2)
02539 #if(CXSC_INDEX_CHECK)
02540         throw(OP_WITH_WRONG_DIM);
02541 #else
02542         throw();
02543 #endif
02544 
02545          void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const rvector &rv2)
02546 #if(CXSC_INDEX_CHECK)
02547         throw(OP_WITH_WRONG_DIM);
02548 #else
02549         throw();
02550 #endif
02551 
02552          void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const rvector_slice &sl2)
02553 #if(CXSC_INDEX_CHECK)
02554         throw(OP_WITH_WRONG_DIM);
02555 #else
02556         throw();
02557 #endif
02558 
02559 // complex
02560 
02562          void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const imatrix_subv &rv2)
02563 #if(CXSC_INDEX_CHECK)
02564         throw(OP_WITH_WRONG_DIM);
02565 #else
02566         throw();
02567 #endif
02568 
02569          void accumulate(cidotprecision &dp, const cvector & rv1, const imatrix_subv &rv2)
02570 #if(CXSC_INDEX_CHECK)
02571         throw(OP_WITH_WRONG_DIM);
02572 #else
02573         throw();
02574 #endif
02575 
02576          void accumulate(cidotprecision &dp, const cvector_slice & sl1, const imatrix_subv &rv2)
02577 #if(CXSC_INDEX_CHECK)
02578         throw(OP_WITH_WRONG_DIM);
02579 #else
02580         throw();
02581 #endif
02582 
02584          void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const cmatrix_subv &rv2)
02585 #if(CXSC_INDEX_CHECK)
02586         throw(OP_WITH_WRONG_DIM);
02587 #else
02588         throw();
02589 #endif
02590 
02591          void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const cvector &rv2)
02592 #if(CXSC_INDEX_CHECK)
02593         throw(OP_WITH_WRONG_DIM);
02594 #else
02595         throw();
02596 #endif
02597 
02598          void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const cvector_slice &sl2)
02599 #if(CXSC_INDEX_CHECK)
02600         throw(OP_WITH_WRONG_DIM);
02601 #else
02602         throw();
02603 #endif
02604 
02605 // cinterval
02606 
02608          void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const imatrix_subv &rv2)
02609 #if(CXSC_INDEX_CHECK)
02610         throw(OP_WITH_WRONG_DIM);
02611 #else
02612         throw();
02613 #endif
02614 
02615          void accumulate(cidotprecision &dp, const civector & rv1, const imatrix_subv &rv2)
02616 #if(CXSC_INDEX_CHECK)
02617         throw(OP_WITH_WRONG_DIM);
02618 #else
02619         throw();
02620 #endif
02621 
02622          void accumulate(cidotprecision &dp, const civector_slice & sl1, const imatrix_subv &rv2)
02623 #if(CXSC_INDEX_CHECK)
02624         throw(OP_WITH_WRONG_DIM);
02625 #else
02626         throw();
02627 #endif
02628 
02630          void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const cimatrix_subv &rv2)
02631 #if(CXSC_INDEX_CHECK)
02632         throw(OP_WITH_WRONG_DIM);
02633 #else
02634         throw();
02635 #endif
02636 
02637          void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const civector &rv2)
02638 #if(CXSC_INDEX_CHECK)
02639         throw(OP_WITH_WRONG_DIM);
02640 #else
02641         throw();
02642 #endif
02643 
02644          void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const civector_slice &sl2)
02645 #if(CXSC_INDEX_CHECK)
02646         throw(OP_WITH_WRONG_DIM);
02647 #else
02648         throw();
02649 #endif
02650 
02651 
02652 //====================================================================
02653 //===================== Matrix Functions =============================
02654 
02656         INLINE imatrix _imatrix(const imatrix &rm) throw();
02658         INLINE imatrix _imatrix(const ivector &v) throw();
02660         INLINE imatrix _imatrix(const ivector_slice &v) throw();
02662         INLINE imatrix _imatrix(const interval &r) throw();
02663 
02665         INLINE int Lb(const imatrix &rm, const int &i)
02666 #if(CXSC_INDEX_CHECK)
02667         throw(ERROR_IMATRIX_WRONG_ROW_OR_COL);
02668 #else
02669         throw();
02670 #endif
02671 
02672         INLINE int Ub(const imatrix &rm, const int &i)
02673 #if(CXSC_INDEX_CHECK)
02674         throw(ERROR_IMATRIX_WRONG_ROW_OR_COL);
02675 #else
02676         throw();
02677 #endif
02678 
02679         INLINE int Lb(const imatrix_slice &rm, const int &i)
02680 #if(CXSC_INDEX_CHECK)
02681         throw(ERROR_IMATRIX_WRONG_ROW_OR_COL);
02682 #else
02683         throw();
02684 #endif
02685 
02686         INLINE int Ub(const imatrix_slice &rm, const int &i)
02687 #if(CXSC_INDEX_CHECK)
02688         throw(ERROR_IMATRIX_WRONG_ROW_OR_COL);
02689 #else
02690         throw();
02691 #endif
02692 
02693         INLINE imatrix &SetLb(imatrix &m, const int &i,const int &j)
02694 #if(CXSC_INDEX_CHECK)
02695         throw(ERROR_IMATRIX_WRONG_ROW_OR_COL);
02696 #else
02697         throw();
02698 #endif
02699 
02700         INLINE imatrix &SetUb(imatrix &m, const int &i,const int &j)
02701 #if(CXSC_INDEX_CHECK)
02702         throw(ERROR_IMATRIX_WRONG_ROW_OR_COL);
02703 #else
02704         throw();
02705 #endif
02706 
02707         INLINE void Resize(imatrix &A) throw();
02709         INLINE void Resize(imatrix &A,const int &m, const int &n)
02710 #if(CXSC_INDEX_CHECK)
02711         throw(ERROR_IMATRIX_WRONG_BOUNDARIES);
02712 #else
02713         throw();
02714 #endif
02715 
02716         INLINE void Resize(imatrix &A,const int &m1, const int &m2,const int &n1,const int &n2)
02717 #if(CXSC_INDEX_CHECK)
02718         throw(ERROR_IMATRIX_WRONG_BOUNDARIES);
02719 #else
02720         throw();
02721 #endif
02722 
02724         INLINE imatrix abs(const imatrix &m) throw();
02726         INLINE rmatrix absmin(const imatrix &m) throw();
02728         INLINE rmatrix absmax(const imatrix &m) throw();
02730         INLINE imatrix abs(const imatrix_slice &ms) throw();
02732         INLINE rmatrix absmin(const imatrix_slice &ms) throw();
02734         INLINE rmatrix absmax(const imatrix_slice &ms) throw();
02736         INLINE rmatrix diam(const imatrix &m) throw();
02738         INLINE rmatrix diam(const imatrix_slice &ms) throw();
02740         INLINE rmatrix mid(const imatrix &m) throw();
02742         INLINE rmatrix mid(const imatrix_slice &ms) throw();
02744         INLINE rmatrix Inf(const imatrix &m) throw();
02746         INLINE rmatrix Sup(const imatrix &m) throw();
02748         INLINE rmatrix Inf(const imatrix_slice &m) throw();
02750         INLINE rmatrix Sup(const imatrix_slice &m) throw();
02752         INLINE imatrix &SetInf(imatrix &cm,const rmatrix &rm)
02753 #if(CXSC_INDEX_CHECK)
02754         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02755 #else
02756         throw();
02757 #endif
02758 
02759         INLINE imatrix_slice &SetInf(imatrix_slice &cm,const rmatrix &rm)
02760 #if(CXSC_INDEX_CHECK)
02761         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02762 #else
02763         throw();
02764 #endif
02765 
02766         INLINE imatrix &SetInf(imatrix &cm,const rmatrix_slice &rm)
02767 #if(CXSC_INDEX_CHECK)
02768         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02769 #else
02770         throw();
02771 #endif
02772 
02773         INLINE imatrix_slice &SetInf(imatrix_slice &cm,const rmatrix_slice &rm)
02774 #if(CXSC_INDEX_CHECK)
02775         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02776 #else
02777         throw();
02778 #endif
02779 
02780         INLINE imatrix &SetSup(imatrix &cm,const rmatrix &rm)
02781 #if(CXSC_INDEX_CHECK)
02782         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02783 #else
02784         throw();
02785 #endif
02786 
02787         INLINE imatrix_slice &SetSup(imatrix_slice &cm,const rmatrix &rm)
02788 #if(CXSC_INDEX_CHECK)
02789         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02790 #else
02791         throw();
02792 #endif
02793 
02794         INLINE imatrix &SetSup(imatrix &cm,const rmatrix_slice &rm)
02795 #if(CXSC_INDEX_CHECK)
02796         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02797 #else
02798         throw();
02799 #endif
02800 
02801         INLINE imatrix_slice &SetSup(imatrix_slice &cm,const rmatrix_slice &rm)
02802 #if(CXSC_INDEX_CHECK)
02803         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02804 #else
02805         throw();
02806 #endif
02807 
02808         INLINE imatrix &UncheckedSetInf(imatrix &cm,const rmatrix &rm)
02809 #if(CXSC_INDEX_CHECK)
02810         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02811 #else
02812         throw();
02813 #endif
02814 
02815         INLINE imatrix_slice &UncheckedSetInf(imatrix_slice &cm,const rmatrix &rm)
02816 #if(CXSC_INDEX_CHECK)
02817         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02818 #else
02819         throw();
02820 #endif
02821 
02822         INLINE imatrix &UncheckedSetInf(imatrix &cm,const rmatrix_slice &rm)
02823 #if(CXSC_INDEX_CHECK)
02824         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02825 #else
02826         throw();
02827 #endif
02828 
02829         INLINE imatrix_slice &UncheckedSetInf(imatrix_slice &cm,const rmatrix_slice &rm)
02830 #if(CXSC_INDEX_CHECK)
02831         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02832 #else
02833         throw();
02834 #endif
02835 
02836         INLINE imatrix &UncheckedSetSup(imatrix &cm,const rmatrix &rm)
02837 #if(CXSC_INDEX_CHECK)
02838         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02839 #else
02840         throw();
02841 #endif
02842 
02843         INLINE imatrix_slice &UncheckedSetSup(imatrix_slice &cm,const rmatrix &rm)
02844 #if(CXSC_INDEX_CHECK)
02845         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02846 #else
02847         throw();
02848 #endif
02849 
02850         INLINE imatrix &UncheckedSetSup(imatrix &cm,const rmatrix_slice &rm)
02851 #if(CXSC_INDEX_CHECK)
02852         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02853 #else
02854         throw();
02855 #endif
02856 
02857         INLINE imatrix_slice &UncheckedSetSup(imatrix_slice &cm,const rmatrix_slice &rm)
02858 #if(CXSC_INDEX_CHECK)
02859         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02860 #else
02861         throw();
02862 #endif
02863 
02864 //===================== Matrix / Scalar ===============================
02865 
02867         INLINE imatrix operator *(const interval &c, const imatrix &m) throw();
02869         INLINE imatrix operator *(const interval &c, const imatrix_slice &ms) throw();
02871         INLINE imatrix operator *(const imatrix &m,const interval &c) throw();
02873         INLINE imatrix operator *(const imatrix_slice &ms,const interval &c) throw();
02875         INLINE imatrix &operator *=(imatrix &m,const interval &c) throw();
02877         INLINE imatrix operator /(const imatrix &m,const interval &c) throw();
02879         INLINE imatrix operator /(const imatrix_slice &ms, const interval &c) throw();
02881         INLINE imatrix &operator /=(imatrix &m,const interval &c) throw();
02882         
02883 //------------ real - imatrix -----------------------------------------------
02884 
02886         INLINE imatrix operator *(const real &c, const imatrix &m) throw();
02888         INLINE imatrix operator *(const real &c, const imatrix_slice &ms) throw();
02890         INLINE imatrix operator *(const imatrix &m,const real &c) throw();
02892         INLINE imatrix operator *(const imatrix_slice &ms,const real &c) throw();
02894         INLINE imatrix &operator *=(imatrix &m,const real &c) throw();
02896         INLINE imatrix operator /(const imatrix &m,const real &c) throw();
02898         INLINE imatrix operator /(const imatrix_slice &ms, const real &c) throw();
02900         INLINE imatrix &operator /=(imatrix &m,const real &c) throw();
02901 //----------------- rmatrix - interval ----------------
02902 
02904         INLINE imatrix operator *(const interval &c, const rmatrix &m) throw();
02906         INLINE imatrix operator *(const interval &c, const rmatrix_slice &ms) throw();
02908         INLINE imatrix operator *(const rmatrix &m,const interval &c) throw();
02910         INLINE imatrix operator *(const rmatrix_slice &ms,const interval &c) throw();
02912         INLINE imatrix operator /(const rmatrix &m,const interval &c) throw();
02914         INLINE imatrix operator /(const rmatrix_slice &ms, const interval &c) throw();
02915         
02916 
02917 //============================ Matrix / Vector ===================================
02918 
02919 
02921         INLINE ivector operator *(const imatrix &m,const ivector &v)
02922 #if(CXSC_INDEX_CHECK)
02923         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02924 #else
02925         throw();
02926 #endif
02927 
02928         INLINE ivector operator *(const imatrix_slice &ms,const ivector &v)
02929 #if(CXSC_INDEX_CHECK)
02930         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02931 #else
02932         throw();
02933 #endif
02934 
02935         INLINE ivector operator *(const ivector &v,const imatrix &m)
02936 #if(CXSC_INDEX_CHECK)
02937         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02938 #else
02939         throw();
02940 #endif
02941 
02942         INLINE ivector operator *(const ivector &v,const imatrix_slice &ms)
02943 #if(CXSC_INDEX_CHECK)
02944         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02945 #else
02946         throw();
02947 #endif
02948 
02949         INLINE ivector &operator *=(ivector &v,const imatrix &m)
02950 #if(CXSC_INDEX_CHECK)
02951         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02952 #else
02953         throw();
02954 #endif
02955 
02956         INLINE ivector &operator *=(ivector &v,const imatrix_slice &ms)
02957 #if(CXSC_INDEX_CHECK)
02958         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02959 #else
02960         throw();
02961 #endif
02962 
02964         INLINE ivector operator *(const ivector_slice &v,const imatrix &m)
02965 #if(CXSC_INDEX_CHECK)
02966         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02967 #else
02968         throw();
02969 #endif
02970 
02971         INLINE ivector operator *(const ivector_slice &v,const imatrix_slice &m)
02972 #if(CXSC_INDEX_CHECK)
02973         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02974 #else
02975         throw();
02976 #endif
02977         
02978 //----------------- real -------------------------------------
02979 
02980 
02982         INLINE ivector operator *(const rvector &v,const imatrix &m)
02983 #if(CXSC_INDEX_CHECK)
02984         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02985 #else
02986         throw();
02987 #endif
02988 
02989         INLINE ivector operator *(const rvector &v,const imatrix_slice &ms)
02990 #if(CXSC_INDEX_CHECK)
02991         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02992 #else
02993         throw();
02994 #endif
02995 
02996         INLINE ivector operator *(const rvector_slice &v,const imatrix &m)
02997 #if(CXSC_INDEX_CHECK)
02998         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02999 #else
03000         throw();
03001 #endif
03002         
03004         INLINE ivector operator *(const imatrix &m,const rvector &v)
03005 #if(CXSC_INDEX_CHECK)
03006         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03007 #else
03008         throw();
03009 #endif
03010 
03011         INLINE ivector operator *(const imatrix_slice &ms,const rvector &v)
03012 #if(CXSC_INDEX_CHECK)
03013         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03014 #else
03015         throw();
03016 #endif
03017         
03018 
03019 //================ Matrix / Matrix ============================
03020 
03022         INLINE const imatrix &operator +(const imatrix &m1) throw();
03024         INLINE imatrix operator +(const imatrix_slice &ms) throw();
03026         INLINE imatrix operator +(const imatrix &m1,const imatrix &m2)
03027 #if(CXSC_INDEX_CHECK)
03028         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03029 #else
03030         throw();
03031 #endif
03032 
03033         INLINE imatrix operator +(const imatrix &m,const imatrix_slice &ms)
03034 #if(CXSC_INDEX_CHECK)
03035         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03036 #else
03037         throw();
03038 #endif
03039 
03040         INLINE imatrix operator +(const imatrix_slice &ms,const imatrix &m)
03041 #if(CXSC_INDEX_CHECK)
03042         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03043 #else
03044         throw();
03045 #endif
03046 
03047         INLINE imatrix operator +(const imatrix_slice &m1,const imatrix_slice &m2)
03048 #if(CXSC_INDEX_CHECK)
03049         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03050 #else
03051         throw();
03052 #endif
03053 
03054         INLINE imatrix &operator +=(imatrix &m1,const imatrix &m2)
03055 #if(CXSC_INDEX_CHECK)
03056         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03057 #else
03058         throw();
03059 #endif
03060 
03061         INLINE imatrix &operator +=(imatrix &m1,const imatrix_slice &ms)
03062 #if(CXSC_INDEX_CHECK)
03063         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03064 #else
03065         throw();
03066 #endif
03067         
03069         INLINE imatrix operator -(const imatrix &m) throw();
03071         INLINE imatrix operator -(const imatrix_slice &ms) throw();
03073         INLINE imatrix operator -(const imatrix &m1,const imatrix &m2)
03074 #if(CXSC_INDEX_CHECK)
03075         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03076 #else
03077         throw();
03078 #endif
03079 
03080         INLINE imatrix operator -(const imatrix &m,const imatrix_slice &ms)
03081 #if(CXSC_INDEX_CHECK)
03082         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03083 #else
03084         throw();
03085 #endif
03086 
03087         INLINE imatrix operator -(const imatrix_slice &ms,const imatrix &m)
03088 #if(CXSC_INDEX_CHECK)
03089         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03090 #else
03091         throw();
03092 #endif
03093 
03094         INLINE imatrix operator -(const imatrix_slice &ms1,const imatrix_slice &ms2)
03095 #if(CXSC_INDEX_CHECK)
03096         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03097 #else
03098         throw();
03099 #endif
03100 
03101         INLINE imatrix &operator -=(imatrix &m1,const imatrix &m2)
03102 #if(CXSC_INDEX_CHECK)
03103         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03104 #else
03105         throw();
03106 #endif
03107 
03108         INLINE imatrix &operator -=(imatrix &m1,const imatrix_slice &ms)
03109 #if(CXSC_INDEX_CHECK)
03110         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03111 #else
03112         throw();
03113 #endif
03114         
03116         INLINE imatrix operator *(const imatrix &m1, const imatrix &m2)
03117 #if(CXSC_INDEX_CHECK)
03118         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03119 #else
03120         throw();
03121 #endif
03122 
03123         INLINE imatrix operator *(const imatrix &m1, const imatrix_slice &ms)
03124 #if(CXSC_INDEX_CHECK)
03125         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03126 #else
03127         throw();
03128 #endif
03129 
03130         INLINE imatrix operator *(const imatrix_slice &ms, const imatrix &m1)
03131 #if(CXSC_INDEX_CHECK)
03132         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03133 #else
03134         throw();
03135 #endif
03136 
03137         INLINE imatrix operator *(const imatrix_slice &ms1, const imatrix_slice &ms2)
03138 #if(CXSC_INDEX_CHECK)
03139         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03140 #else
03141         throw();
03142 #endif
03143 
03144         INLINE imatrix &operator *=(imatrix &m1,const imatrix &m2)
03145 #if(CXSC_INDEX_CHECK)
03146         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03147 #else
03148         throw();
03149 #endif
03150 
03151         INLINE imatrix &operator *=(imatrix &m1,const imatrix_slice &ms)
03152 #if(CXSC_INDEX_CHECK)
03153         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03154 #else
03155         throw();
03156 #endif
03157         
03158         
03160         INLINE imatrix operator |(const imatrix &m1,const imatrix &m2)
03161 #if(CXSC_INDEX_CHECK)
03162         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03163 #else
03164         throw();
03165 #endif
03166 
03167         INLINE imatrix operator |(const imatrix &m,const imatrix_slice &ms)
03168 #if(CXSC_INDEX_CHECK)
03169         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03170 #else
03171         throw();
03172 #endif
03173 
03174         INLINE imatrix operator |(const imatrix_slice &ms,const imatrix &m)
03175 #if(CXSC_INDEX_CHECK)
03176         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03177 #else
03178         throw();
03179 #endif
03180 
03181         INLINE imatrix operator |(const imatrix_slice &m1,const imatrix_slice &m2)
03182 #if(CXSC_INDEX_CHECK)
03183         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03184 #else
03185         throw();
03186 #endif
03187 
03188         INLINE imatrix &operator |=(imatrix &m1,const imatrix &m2)
03189 #if(CXSC_INDEX_CHECK)
03190         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03191 #else
03192         throw();
03193 #endif
03194 
03195         INLINE imatrix &operator |=(imatrix &m1,const imatrix_slice &ms)
03196 #if(CXSC_INDEX_CHECK)
03197         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03198 #else
03199         throw();
03200 #endif
03201         
03203         INLINE imatrix operator &(const imatrix &m1,const imatrix &m2)
03204 #if(CXSC_INDEX_CHECK)
03205         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03206 #else
03207         throw();
03208 #endif
03209 
03210         INLINE imatrix operator &(const imatrix &m,const imatrix_slice &ms)
03211 #if(CXSC_INDEX_CHECK)
03212         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03213 #else
03214         throw();
03215 #endif
03216 
03217         INLINE imatrix operator &(const imatrix_slice &ms,const imatrix &m)
03218 #if(CXSC_INDEX_CHECK)
03219         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03220 #else
03221         throw();
03222 #endif
03223 
03224         INLINE imatrix operator &(const imatrix_slice &m1,const imatrix_slice &m2)
03225 #if(CXSC_INDEX_CHECK)
03226         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03227 #else
03228         throw();
03229 #endif
03230 
03231         INLINE imatrix &operator &=(imatrix &m1,const imatrix &m2)
03232 #if(CXSC_INDEX_CHECK)
03233         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03234 #else
03235         throw();
03236 #endif
03237 
03238         INLINE imatrix &operator &=(imatrix &m1,const imatrix_slice &ms)
03239 #if(CXSC_INDEX_CHECK)
03240         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03241 #else
03242         throw();
03243 #endif
03244         
03245         //---------- rmatrix-imatrix ------------------
03247         INLINE imatrix operator +(const rmatrix &m1,const imatrix &m2)
03248 #if(CXSC_INDEX_CHECK)
03249         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03250 #else
03251         throw();
03252 #endif
03253 
03254         INLINE imatrix operator +(const imatrix &m1,const rmatrix &m2)
03255 #if(CXSC_INDEX_CHECK)
03256         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03257 #else
03258         throw();
03259 #endif
03260 
03261         INLINE imatrix operator +(const rmatrix &m,const imatrix_slice &ms)
03262 #if(CXSC_INDEX_CHECK)
03263         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03264 #else
03265         throw();
03266 #endif
03267 
03268         INLINE imatrix operator +(const imatrix &m,const rmatrix_slice &ms)
03269 #if(CXSC_INDEX_CHECK)
03270         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03271 #else
03272         throw();
03273 #endif
03274 
03275         INLINE imatrix operator +(const rmatrix_slice &ms,const imatrix &m)
03276 #if(CXSC_INDEX_CHECK)
03277         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03278 #else
03279         throw();
03280 #endif
03281 
03282         INLINE imatrix operator +(const imatrix_slice &ms,const rmatrix &m)
03283 #if(CXSC_INDEX_CHECK)
03284         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03285 #else
03286         throw();
03287 #endif
03288 
03289         INLINE imatrix operator +(const rmatrix_slice &m1,const imatrix_slice &m2)
03290 #if(CXSC_INDEX_CHECK)
03291         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03292 #else
03293         throw();
03294 #endif
03295 
03296         INLINE imatrix operator +(const imatrix_slice &m1,const rmatrix_slice &m2)
03297 #if(CXSC_INDEX_CHECK)
03298         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03299 #else
03300         throw();
03301 #endif
03302 
03303         INLINE imatrix &operator +=(imatrix &m1,const rmatrix &m2)
03304 #if(CXSC_INDEX_CHECK)
03305         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03306 #else
03307         throw();
03308 #endif
03309 
03310         INLINE imatrix &operator +=(imatrix &m1,const rmatrix_slice &ms)
03311 #if(CXSC_INDEX_CHECK)
03312         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03313 #else
03314         throw();
03315 #endif
03316         
03318         INLINE imatrix operator -(const rmatrix &m1,const imatrix &m2)
03319 #if(CXSC_INDEX_CHECK)
03320         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03321 #else
03322         throw();
03323 #endif
03324 
03325         INLINE imatrix operator -(const imatrix &m1,const rmatrix &m2)
03326 #if(CXSC_INDEX_CHECK)
03327         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03328 #else
03329         throw();
03330 #endif
03331 
03332         INLINE imatrix operator -(const rmatrix &m,const imatrix_slice &ms)
03333 #if(CXSC_INDEX_CHECK)
03334         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03335 #else
03336         throw();
03337 #endif
03338 
03339         INLINE imatrix operator -(const imatrix &m,const rmatrix_slice &ms)
03340 #if(CXSC_INDEX_CHECK)
03341         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03342 #else
03343         throw();
03344 #endif
03345 
03346         INLINE imatrix operator -(const rmatrix_slice &ms,const imatrix &m)
03347 #if(CXSC_INDEX_CHECK)
03348         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03349 #else
03350         throw();
03351 #endif
03352 
03353         INLINE imatrix operator -(const imatrix_slice &ms,const rmatrix &m)
03354 #if(CXSC_INDEX_CHECK)
03355         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03356 #else
03357         throw();
03358 #endif
03359 
03360         INLINE imatrix operator -(const rmatrix_slice &ms1,const imatrix_slice &ms2)
03361 #if(CXSC_INDEX_CHECK)
03362         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03363 #else
03364         throw();
03365 #endif
03366 
03367         INLINE imatrix operator -(const imatrix_slice &ms1,const rmatrix_slice &ms2)
03368 #if(CXSC_INDEX_CHECK)
03369         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03370 #else
03371         throw();
03372 #endif
03373 
03374         INLINE imatrix &operator -=(imatrix &m1,const rmatrix &m2)
03375 #if(CXSC_INDEX_CHECK)
03376         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03377 #else
03378         throw();
03379 #endif
03380 
03381         INLINE imatrix &operator -=(imatrix &m1,const rmatrix_slice &ms)
03382 #if(CXSC_INDEX_CHECK)
03383         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03384 #else
03385         throw();
03386 #endif
03387         
03389         INLINE imatrix operator *(const rmatrix &m1, const imatrix &m2)
03390 #if(CXSC_INDEX_CHECK)
03391         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03392 #else
03393         throw();
03394 #endif
03395 
03396         INLINE imatrix operator *(const imatrix &m1, const rmatrix &m2)
03397 #if(CXSC_INDEX_CHECK)
03398         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03399 #else
03400         throw();
03401 #endif
03402 
03403         INLINE imatrix operator *(const rmatrix &m1, const imatrix_slice &ms)
03404 #if(CXSC_INDEX_CHECK)
03405         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03406 #else
03407         throw();
03408 #endif
03409 
03410         INLINE imatrix operator *(const imatrix &m1, const rmatrix_slice &ms)
03411 #if(CXSC_INDEX_CHECK)
03412         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03413 #else
03414         throw();
03415 #endif
03416 
03417         INLINE imatrix operator *(const rmatrix_slice &ms, const imatrix &m1)
03418 #if(CXSC_INDEX_CHECK)
03419         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03420 #else
03421         throw();
03422 #endif
03423 
03424         INLINE imatrix operator *(const imatrix_slice &ms, const rmatrix &m1)
03425 #if(CXSC_INDEX_CHECK)
03426         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03427 #else
03428         throw();
03429 #endif
03430 
03431         INLINE imatrix operator *(const rmatrix_slice &ms1, const imatrix_slice &ms2)
03432 #if(CXSC_INDEX_CHECK)
03433         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03434 #else
03435         throw();
03436 #endif
03437 
03438         INLINE imatrix operator *(const imatrix_slice &ms1, const rmatrix_slice &ms2)
03439 #if(CXSC_INDEX_CHECK)
03440         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03441 #else
03442         throw();
03443 #endif
03444 
03445         INLINE imatrix &operator *=(imatrix &m1,const rmatrix &m2)
03446 #if(CXSC_INDEX_CHECK)
03447         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03448 #else
03449         throw();
03450 #endif
03451 
03452         INLINE imatrix &operator *=(imatrix &m1,const rmatrix_slice &ms)
03453 #if(CXSC_INDEX_CHECK)
03454         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03455 #else
03456         throw();
03457 #endif
03458         
03460         INLINE imatrix operator |(const rmatrix &m1,const imatrix &m2)
03461 #if(CXSC_INDEX_CHECK)
03462         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03463 #else
03464         throw();
03465 #endif
03466 
03467         INLINE imatrix operator |(const imatrix &m1,const rmatrix &m2)
03468 #if(CXSC_INDEX_CHECK)
03469         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03470 #else
03471         throw();
03472 #endif
03473 
03474         INLINE imatrix operator |(const rmatrix &m,const imatrix_slice &ms)
03475 #if(CXSC_INDEX_CHECK)
03476         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03477 #else
03478         throw();
03479 #endif
03480 
03481         INLINE imatrix operator |(const imatrix &m,const rmatrix_slice &ms)
03482 #if(CXSC_INDEX_CHECK)
03483         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03484 #else
03485         throw();
03486 #endif
03487 
03488         INLINE imatrix operator |(const rmatrix_slice &ms,const imatrix &m)
03489 #if(CXSC_INDEX_CHECK)
03490         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03491 #else
03492         throw();
03493 #endif
03494 
03495         INLINE imatrix operator |(const imatrix_slice &ms,const rmatrix &m)
03496 #if(CXSC_INDEX_CHECK)
03497         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03498 #else
03499         throw();
03500 #endif
03501 
03502         INLINE imatrix operator |(const rmatrix_slice &m1,const imatrix_slice &m2)
03503 #if(CXSC_INDEX_CHECK)
03504         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03505 #else
03506         throw();
03507 #endif
03508 
03509         INLINE imatrix operator |(const imatrix_slice &m1,const rmatrix_slice &m2)
03510 #if(CXSC_INDEX_CHECK)
03511         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03512 #else
03513         throw();
03514 #endif
03515 
03516         INLINE imatrix &operator |=(imatrix &m1,const rmatrix &m2)
03517 #if(CXSC_INDEX_CHECK)
03518         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03519 #else
03520         throw();
03521 #endif
03522 
03523         INLINE imatrix &operator |=(imatrix &m1,const rmatrix_slice &ms)
03524 #if(CXSC_INDEX_CHECK)
03525         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03526 #else
03527         throw();
03528 #endif
03529         
03531         INLINE imatrix operator &(const rmatrix &m1,const imatrix &m2)
03532 #if(CXSC_INDEX_CHECK)
03533         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03534 #else
03535         throw();
03536 #endif
03537 
03538         INLINE imatrix operator &(const imatrix &m1,const rmatrix &m2)
03539 #if(CXSC_INDEX_CHECK)
03540         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03541 #else
03542         throw();
03543 #endif
03544 
03545         INLINE imatrix operator &(const rmatrix &m,const imatrix_slice &ms)
03546 #if(CXSC_INDEX_CHECK)
03547         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03548 #else
03549         throw();
03550 #endif
03551 
03552         INLINE imatrix operator &(const imatrix &m,const rmatrix_slice &ms)
03553 #if(CXSC_INDEX_CHECK)
03554         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03555 #else
03556         throw();
03557 #endif
03558 
03559         INLINE imatrix operator &(const rmatrix_slice &ms,const imatrix &m)
03560 #if(CXSC_INDEX_CHECK)
03561         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03562 #else
03563         throw();
03564 #endif
03565 
03566         INLINE imatrix operator &(const imatrix_slice &ms,const rmatrix &m)
03567 #if(CXSC_INDEX_CHECK)
03568         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03569 #else
03570         throw();
03571 #endif
03572 
03573         INLINE imatrix operator &(const rmatrix_slice &m1,const imatrix_slice &m2)
03574 #if(CXSC_INDEX_CHECK)
03575         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03576 #else
03577         throw();
03578 #endif
03579 
03580         INLINE imatrix operator &(const imatrix_slice &m1,const rmatrix_slice &m2)
03581 #if(CXSC_INDEX_CHECK)
03582         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03583 #else
03584         throw();
03585 #endif
03586 
03587         INLINE imatrix &operator &=(imatrix &m1,const rmatrix &m2)
03588 #if(CXSC_INDEX_CHECK)
03589         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03590 #else
03591         throw();
03592 #endif
03593 
03594         INLINE imatrix &operator &=(imatrix &m1,const rmatrix_slice &ms)
03595 #if(CXSC_INDEX_CHECK)
03596         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
03597 #else
03598         throw();
03599 #endif
03600         
03601         // rmatrix x rmatrix --------------------------------------
03602 
03604         INLINE imatrix operator |(const rmatrix &m1,const rmatrix &m2)
03605 #if(CXSC_INDEX_CHECK)
03606         throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
03607 #else
03608         throw();
03609 #endif
03610 
03611         INLINE imatrix operator |(const rmatrix &m,const rmatrix_slice &ms)
03612 #if(CXSC_INDEX_CHECK)
03613         throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
03614 #else
03615         throw();
03616 #endif
03617 
03618         INLINE imatrix operator |(const rmatrix_slice &ms,const rmatrix &m)
03619 #if(CXSC_INDEX_CHECK)
03620         throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
03621 #else
03622         throw();
03623 #endif
03624 
03625         INLINE imatrix operator |(const rmatrix_slice &m1,const rmatrix_slice &m2)
03626 #if(CXSC_INDEX_CHECK)
03627         throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
03628 #else
03629         throw();
03630 #endif
03631 
03632 //============== Compare Operator ==========================
03633 
03634 //-------------- Matrix - Matrix   -------------------------
03635 
03637         INLINE bool operator ==(const imatrix &m1,const imatrix &m2) throw();
03639         INLINE bool operator !=(const imatrix &m1,const imatrix &m2) throw();
03641         INLINE bool operator <(const imatrix &m1,const imatrix &m2) throw();
03643         INLINE bool operator <=(const imatrix &m1,const imatrix &m2) throw();
03645         INLINE bool operator >(const imatrix &m1,const imatrix &m2) throw();
03647         INLINE bool operator >=(const imatrix &m1,const imatrix &m2) throw();
03649         INLINE bool operator ==(const imatrix &m1,const imatrix_slice &ms) throw();
03651         INLINE bool operator !=(const imatrix &m1,const imatrix_slice &ms) throw();
03653         INLINE bool operator <(const imatrix &m1,const imatrix_slice &ms) throw();
03655         INLINE bool operator <=(const imatrix &m1,const imatrix_slice &ms) throw();
03657         INLINE bool operator >(const imatrix &m1,const imatrix_slice &ms) throw();
03659         INLINE bool operator >=(const imatrix &m1,const imatrix_slice &ms) throw();
03660 
03661 //---------------- Matrix - Matrix_slice ----------------------
03662 
03664         INLINE bool operator ==(const imatrix_slice &m1,const imatrix_slice &m2) throw();
03666         INLINE bool operator !=(const imatrix_slice &m1,const imatrix_slice &m2) throw();
03668         INLINE bool operator <(const imatrix_slice &m1,const imatrix_slice &m2) throw();
03670         INLINE bool operator <=(const imatrix_slice &m1,const imatrix_slice &m2) throw();
03672         INLINE bool operator >(const imatrix_slice &m1,const imatrix_slice &m2) throw();
03674         INLINE bool operator >=(const imatrix_slice &m1,const imatrix_slice &m2) throw();
03675 
03676 //=================== Not Operator =============================
03677 
03679         INLINE bool operator !(const imatrix &ms) throw();
03681         INLINE bool operator !(const imatrix_slice &ms) throw();
03682 
03683 //======================== Input / Output ========================
03684 
03686         INLINE std::ostream &operator <<(std::ostream &s,const imatrix &r) throw();
03688         INLINE std::ostream &operator <<(std::ostream &s,const imatrix_slice &r) throw();
03690         INLINE std::istream &operator >>(std::istream &s,imatrix &r) throw();
03692         INLINE std::istream &operator >>(std::istream &s,imatrix_slice &r) throw();
03693 
03695         rmatrix  CompMat    ( const imatrix& );
03697         imatrix  Id         ( const imatrix& );
03699         imatrix  transp     ( const imatrix& );
03701         real     MaxRelDiam ( const imatrix_subv& );
03703         INLINE int RowLen   ( const imatrix& );
03705         INLINE int ColLen   ( const imatrix& );
03707         INLINE int RowLen   ( const imatrix_slice& );
03709         INLINE int ColLen   ( const imatrix_slice& );
03711         void     DoubleSize ( imatrix& );
03712 
03713 } // namespace cxsc 
03714 
03715 #ifdef _CXSC_INCL_INL
03716 #include "matrix.inl"
03717 #include "imatrix.inl"
03718 #endif
03719 
03720 #ifdef _CXSC_CIVECTOR_HPP_INCLUDED
03721 # ifdef _CXSC_INCL_INL
03722 #  include "civecimat.inl"
03723 # else
03724 #  include "civecimat.hpp"
03725 # endif
03726 #endif
03727 
03728 #ifdef _CXSC_CVECTOR_HPP_INCLUDED
03729 # ifdef _CXSC_INCL_INL
03730 #  include "cvecimat.inl"
03731 # else
03732 #  include "cvecimat.hpp"
03733 # endif
03734 #endif
03735 
03736 #ifdef _CXSC_CMATRIX_HPP_INCLUDED
03737 # ifdef _CXSC_INCL_INL
03738 #  include "cmatimat.inl"
03739 # else
03740 #  include "cmatimat.hpp"
03741 # endif
03742 #endif
03743 
03744 #ifdef _CXSC_LIVECTOR_HPP_INCLUDED
03745 # ifdef _CXSC_INCL_INL
03746 #  include "livecimat.inl"
03747 # else
03748 #  include "livecimat.hpp"
03749 # endif
03750 #endif
03751 
03752 #ifdef _CXSC_LRVECTOR_HPP_INCLUDED
03753 # ifdef _CXSC_INCL_INL
03754 #  include "lrvecimat.inl"
03755 # else
03756 #  include "lrvecimat.hpp"
03757 # endif
03758 #endif
03759 
03760 #ifdef _CXSC_LRMATRIX_HPP_INCLUDED
03761 # ifdef _CXSC_INCL_INL
03762 #  include "lrmatimat.inl"
03763 # else
03764 #  include "lrmatimat.hpp"
03765 # endif
03766 #endif
03767 
03768 
03769 #ifdef CXSC_USE_BLAS
03770 #define _CXSC_BLAS_IMATRIX
03771 #include "cxsc_blas.inl"
03772 #endif
03773 
03774 #endif