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