C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
l_rvector.hpp
00001 /*
00002 **  CXSC is a C++ library for eXtended Scientific Computing (V 2.5.4)
00003 **
00004 **  Copyright (C) 1990-2000 Institut fuer Angewandte Mathematik,
00005 **                          Universitaet Karlsruhe, Germany
00006 **            (C) 2000-2014 Wiss. Rechnen/Softwaretechnologie
00007 **                          Universitaet Wuppertal, Germany   
00008 **
00009 **  This library is free software; you can redistribute it and/or
00010 **  modify it under the terms of the GNU Library General Public
00011 **  License as published by the Free Software Foundation; either
00012 **  version 2 of the License, or (at your option) any later version.
00013 **
00014 **  This library is distributed in the hope that it will be useful,
00015 **  but WITHOUT ANY WARRANTY; without even the implied warranty of
00016 **  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00017 **  Library General Public License for more details.
00018 **
00019 **  You should have received a copy of the GNU Library General Public
00020 **  License along with this library; if not, write to the Free
00021 **  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00022 */
00023 
00024 /* CVS $Id: l_rvector.hpp,v 1.19 2014/01/30 17:23:46 cxsc Exp $ */
00025 
00026 #ifndef _CXSC_LRVECTOR_HPP_INCLUDED
00027 #define _CXSC_LRVECTOR_HPP_INCLUDED
00028 
00029 #include "xscclass.hpp"
00030 #include "except.hpp"
00031 #include "dot.hpp"
00032 #include "idot.hpp"
00033 #include "l_real.hpp" // used for declaration of Inf, Sup,...
00034 //#include "cxscmatr.hpp"
00035 #include "rvector.hpp"
00036 #include "vector.hpp"
00037 
00038 
00039 #include <iostream>
00040 
00041 //#include "matrix.hpp" // hat hier eigentlich nichts zu suchen, sonst aber Internal Compiler Error #9
00042 
00043 namespace cxsc {
00044 
00045 class l_rvector_slice;
00046 
00048 
00053 class l_rvector
00054 {
00055         friend class l_rvector_slice;
00056         friend class l_rmatrix;
00057         friend class l_rmatrix_subv;
00058         friend class l_ivector;
00059         friend class l_imatrix;
00060         private:
00061         l_real *dat;
00062         int l,u,size;
00063 
00064         public:
00065 //#if(CXSC_INDEX_CHECK)
00066 
00067 template<typename S, typename T>
00068 friend inline void addDot(const S &x, const T &y, dotprecision &val);
00069 
00070 
00071 #ifdef _CXSC_FRIEND_TPL
00072         //------------ Templates --------------------------------------------------
00073         // l_real
00074 template <class V,class MS,class S> friend  void _vmsconstr(V &v,const MS &m)
00075 #if(CXSC_INDEX_CHECK)
00076         throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>);
00077 #else
00078         throw();
00079 #endif
00080 template <class V,class M,class S> friend  void _vmconstr(V &v,const M &m)
00081 #if(CXSC_INDEX_CHECK)
00082         throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
00083 #else
00084         throw();
00085 #endif
00086  template <class V> friend       void _vresize(V &rv) throw();
00087  template <class V,class S> friend       void _vresize(V &rv, const int &len)
00088 #if(CXSC_INDEX_CHECK)
00089                 throw(ERROR__WRONG_BOUNDARIES<V>);
00090 #else
00091         throw();
00092 #endif
00093  template <class V,class S> friend       void _vresize(V &rv, const int &lb, const int &ub)
00094 #if(CXSC_INDEX_CHECK)
00095                 throw(ERROR__WRONG_BOUNDARIES<V>);
00096 #else
00097         throw();
00098 #endif
00099  template <class V1,class V2,class S> friend     V1 &_vvassign(V1 &rv1,const V2 &rv2) throw();
00100  template <class V,class S> friend       V & _vsassign(V &rv,const S &r) throw();
00101  template <class V,class VS,class S> friend      V & _vvsassign(V &rv,const VS &sl) throw();
00102  template <class VS,class V> friend      VS & _vsvassign(VS &sl,const V &rv)
00103 #if(CXSC_INDEX_CHECK)
00104                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00105 #else
00106         throw();
00107 #endif
00108 template <class V,class M,class S> friend  V &_vmassign(V &v,const M &m)
00109 #if(CXSC_INDEX_CHECK)
00110         throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
00111 #else
00112         throw();
00113 #endif
00114 template <class M,class V,class S> friend  M &_mvassign(M &m,const V &v) throw();
00115  template <class V> friend       V _vconj(const V &rv) throw();
00116  template <class VS,class E> friend      E _vsconj(const VS &sl) throw();
00117  template <class V,class E> friend       E _vabs(const V &rv) throw();
00118  template <class VS,class E> friend      E _vsabs(const VS &sl) throw();
00119 template <class MV,class V> friend  V _mvabs(const MV &mv) throw();
00120 
00121 //-------- vector-vector -----------------------
00122  template <class DP,class V1,class V2> friend    void _vvaccu(DP &dp, const V1 & rv1, const V2 &rv2)
00123 #if(CXSC_INDEX_CHECK)
00124                 throw(OP_WITH_WRONG_DIM);
00125 #else
00126         throw();
00127 #endif
00128  template <class DP,class VS,class V> friend     void _vsvaccu(DP &dp, const VS & sl, const V &rv)
00129 #if(CXSC_INDEX_CHECK)
00130                 throw(OP_WITH_WRONG_DIM);
00131 #else
00132         throw();
00133 #endif
00134  template <class V1,class V2,class E> friend     E _vvlmult(const V1 & rv1, const V2 &rv2)
00135 #if(CXSC_INDEX_CHECK)
00136                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00137 #else
00138         throw();
00139 #endif
00140  template <class VS,class V,class E> friend      E _vsvlmult(const VS & sl, const V &rv)
00141 #if(CXSC_INDEX_CHECK)
00142                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00143 #else
00144         throw();
00145 #endif
00146  template <class V,class S> friend       V &_vsmultassign(V &rv,const S &r) throw();
00147  template <class V1,class V2,class E> friend     E _vvplus(const V1 &rv1, const V2 &rv2)
00148 #if(CXSC_INDEX_CHECK)
00149                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00150 #else
00151         throw();
00152 #endif
00153  template <class V,class VS,class E> friend      E _vvsplus(const V &rv,const VS &sl)
00154 #if(CXSC_INDEX_CHECK)
00155                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00156 #else
00157         throw();
00158 #endif
00159  template <class VS1,class VS2,class E> friend   E _vsvsplus(const VS1 &s1,const VS2 &s2)
00160 #if(CXSC_INDEX_CHECK)
00161                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00162 #else
00163         throw();
00164 #endif
00165  template <class VS1,class VS2,class E> friend   E _vsvsminus(const VS1 &s1,const VS2 &s2)
00166 #if(CXSC_INDEX_CHECK)
00167                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00168 #else
00169         throw();
00170 #endif
00171  template <class V1,class V2> friend     V1 &_vvplusassign(V1 &rv1, const V2 &rv2)
00172 #if(CXSC_INDEX_CHECK)
00173                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00174 #else
00175         throw();
00176 #endif
00177  template <class V,class VS> friend      V &_vvsplusassign(V &rv, const VS &sl)
00178 #if(CXSC_INDEX_CHECK)
00179                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00180 #else
00181         throw();
00182 #endif
00183  template <class VS,class V> friend      VS &_vsvplusassign(VS &sl, const V &rv)
00184 #if(CXSC_INDEX_CHECK)
00185                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00186 #else
00187         throw();
00188 #endif
00189  template <class VS1,class VS2> friend   VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
00190 #if(CXSC_INDEX_CHECK)
00191                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00192 #else
00193         throw();
00194 #endif
00195  template <class VS1,class VS2> friend   VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
00196 #if(CXSC_INDEX_CHECK)
00197                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00198 #else
00199         throw();
00200 #endif
00201  template <class V1,class V2> friend     V1 &_vvminusassign(V1 &rv1, const V2 &rv2)
00202 #if(CXSC_INDEX_CHECK)
00203                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00204 #else
00205         throw();
00206 #endif
00207  template <class V,class VS> friend      V &_vvsminusassign(V &rv, const VS &sl)
00208 #if(CXSC_INDEX_CHECK)
00209                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00210 #else
00211         throw();
00212 #endif
00213  template <class VS,class V> friend      VS &_vsvminusassign(VS &sl, const V &rv)
00214 #if(CXSC_INDEX_CHECK)
00215                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00216 #else
00217         throw();
00218 #endif
00219  template <class V> friend       V _vminus(const V &rv) throw();
00220  template <class VS,class V> friend      V _vsminus(const VS &sl) throw();
00221  template <class V1,class V2,class E> friend     E _vvminus(const V1 &rv1, const V2 &rv2)
00222 #if(CXSC_INDEX_CHECK)
00223                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00224 #else
00225         throw();
00226 #endif
00227  template <class V,class VS,class E> friend      E _vvsminus(const V &rv, const VS &sl)
00228 #if(CXSC_INDEX_CHECK)
00229                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00230 #else
00231         throw();
00232 #endif
00233  template <class VS,class V,class E> friend      E _vsvminus(const VS &sl,const V &rv)
00234 #if(CXSC_INDEX_CHECK)
00235                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00236 #else
00237         throw();
00238 #endif
00239  template <class V,class MV,class S> friend      S _vmvlmult(const V &rv1, const MV &rv2)
00240 #if(CXSC_INDEX_CHECK)
00241                 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00242 #else
00243         throw();
00244 #endif
00245  template <class V1,class V2,class E> friend     E _vvconv(const V1 &rv1, const V2 &rv2)
00246 #if(CXSC_INDEX_CHECK)
00247                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00248 #else
00249         throw();
00250 #endif
00251  template <class V,class VS,class E> friend      E _vvsconv(const V &rv,const VS &sl)
00252 #if(CXSC_INDEX_CHECK)
00253                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00254 #else
00255         throw();
00256 #endif
00257  template <class VS1,class VS2,class E> friend   E _vsvsconv(const VS1 &s1,const VS2 &s2)
00258 #if(CXSC_INDEX_CHECK)
00259                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00260 #else
00261         throw();
00262 #endif
00263         //--------- vector-scalar -----------------
00264  template <class V,class S,class E> friend       E _vsdiv(const V &rv, const S &s) throw();
00265  template <class V,class S> friend       V &_vsdivassign(V &rv,const S &r) throw();
00266  template <class VS,class S,class E> friend      E _vssdiv(const VS &sl, const S &s) throw();
00267  template <class V,class S,class E> friend       E _vsmult(const V &rv, const S &s) throw();
00268  template <class VS,class S,class E> friend      E _vssmult(const VS &sl, const S &s) throw();
00269  template <class MV,class S,class E> friend      E _mvsmult(const MV &rv, const S &s) throw();
00270  template <class MV1,class MV2,class E> friend   E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
00271 #if(CXSC_INDEX_CHECK)
00272                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00273 #else
00274         throw();
00275 #endif
00276  template <class MV,class V,class E> friend      E _mvvplus(const MV &rv1, const V &rv2)
00277 #if(CXSC_INDEX_CHECK)
00278                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00279 #else
00280         throw();
00281 #endif
00282  template <class MV,class V,class E> friend      E _mvvminus(const MV &rv1, const V &rv2)
00283 #if(CXSC_INDEX_CHECK)
00284                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00285 #else
00286         throw();
00287 #endif
00288  template <class V,class MV,class E> friend      E _vmvminus(const V &rv1, const MV &rv2)
00289 #if(CXSC_INDEX_CHECK)
00290                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00291 #else
00292         throw();
00293 #endif
00294  template <class MV1,class MV2,class E> friend   E _mvmvminus(const MV1 &rv1, const MV2 &rv2)
00295 #if(CXSC_INDEX_CHECK)
00296                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00297 #else
00298         throw();
00299 #endif
00300 template <class MV,class V> friend  MV &_mvvplusassign(MV &v,const V &rv)
00301 #if(CXSC_INDEX_CHECK)
00302         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00303 #else
00304         throw();
00305 #endif
00306 template <class MV,class V> friend  MV &_mvvminusassign(MV &v,const V &rv)
00307 #if(CXSC_INDEX_CHECK)
00308         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00309 #else
00310         throw();
00311 #endif
00312  template <class MV,class S,class E> friend      E _mvsdiv(const MV &rv, const S &s) throw();
00313 template <class MV,class V> friend  MV &_mvvassign(MV &v,const V &rv)
00314 #if(CXSC_INDEX_CHECK)
00315         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00316 #else
00317         throw();
00318 #endif
00319 template <class DP,class V,class SV> friend      void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
00320 #if(CXSC_INDEX_CHECK)
00321                 throw(OP_WITH_WRONG_DIM);
00322 #else
00323         throw();
00324 #endif
00325 
00326  template <class V1,class V2> friend     bool _vveq(const V1 &rv1, const V2 &rv2) throw();
00327  template <class VS,class V> friend      bool _vsveq(const VS &sl, const V &rv) throw();
00328  template <class V1,class V2> friend     bool _vvneq(const V1 &rv1, const V2 &rv2) throw();
00329  template <class VS,class V> friend      bool _vsvneq(const VS &sl, const V &rv) throw();
00330  template <class V1,class V2> friend     bool _vvless(const V1 &rv1, const V2 &rv2) throw();
00331  template <class VS,class V> friend      bool _vsvless(const VS &sl, const V &rv) throw();
00332  template <class V1,class V2> friend     bool _vvleq(const V1 &rv1, const V2 &rv2) throw();
00333  template <class VS,class V> friend      bool _vsvleq(const VS &sl, const V &rv) throw();
00334  template <class V,class VS> friend      bool _vvsless(const V &rv, const VS &sl) throw();
00335  template <class V,class VS> friend      bool _vvsleq(const V &rv, const VS &sl) throw();
00336  template <class V> friend       bool _vnot(const V &rv) throw();
00337  template <class V> friend       void *_vvoid(const V &rv) throw();
00338  template <class VS1,class VS2> friend   bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw();
00339  template <class VS1,class VS2> friend   bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw();
00340  template <class VS1,class VS2> friend   bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw();
00341  template <class VS1,class VS2> friend   bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw();
00342  template <class VS> friend      bool _vsnot(const VS &sl) throw();
00343  template <class VS> friend      void *_vsvoid(const VS &sl) throw();
00344  template <class V> friend      std::ostream &_vout(std::ostream &s, const V &rv) throw();
00345  template <class V> friend      std::istream &_vin(std::istream &s, V &rv) throw();
00346 
00347         //------------- vector-matrix ---------------
00348 template <class V,class MV2,class S> friend  V &_vmvassign(V &v,const MV2 &rv) throw();
00349  template <class M,class V,class E> friend       E _mvlmult(const M &m,const V &v)
00350 #if(CXSC_INDEX_CHECK)
00351                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00352 #else
00353         throw();
00354 #endif
00355  template <class V,class M,class E> friend       E _vmlmult(const V &v,const M &m)
00356 #if(CXSC_INDEX_CHECK)
00357                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00358 #else
00359         throw();
00360 #endif
00361  template <class V,class M,class S> friend       V &_vmlmultassign(V &v,const M &m)
00362 #if(CXSC_INDEX_CHECK)
00363                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00364 #else
00365         throw();
00366 #endif
00367  template <class MS,class V,class E> friend      E _msvlmult(const MS &ms,const V &v)
00368 #if(CXSC_INDEX_CHECK)
00369                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00370 #else
00371         throw();
00372 #endif
00373  template <class V,class MS,class E> friend      E _vmslmult(const V &v,const MS &ms)
00374 #if(CXSC_INDEX_CHECK)
00375                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00376 #else
00377         throw();
00378 #endif
00379  template <class V,class MS,class S> friend      V &_vmslmultassign(V &v,const MS &ms)
00380 #if(CXSC_INDEX_CHECK)
00381                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00382 #else
00383         throw();
00384 #endif
00385         
00386         // interval -----------------
00387         // vector-vector
00388  template <class V1,class V2,class E> friend     E _vvlimult(const V1 & rv1, const V2 &rv2)
00389 #if(CXSC_INDEX_CHECK)
00390                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00391 #else
00392         throw();
00393 #endif
00394  template <class VS,class V,class E> friend      E _vsvlimult(const VS & sl, const V &rv)
00395 #if(CXSC_INDEX_CHECK)
00396                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00397 #else
00398         throw();
00399 #endif
00400  template <class VS1,class VS2,class E> friend   E _vsvslimult(const VS1 & sl1, const VS2 &sl2)
00401 #if(CXSC_INDEX_CHECK)
00402                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00403 #else
00404         throw();
00405 #endif
00406  template <class V1,class V2,class E> friend     E _vvsect(const V1 &rv1, const V2 &rv2)
00407 #if(CXSC_INDEX_CHECK)
00408                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00409 #else
00410         throw();
00411 #endif
00412  template <class V,class VS,class E> friend      E _vvssect(const V &rv,const VS &sl)
00413 #if(CXSC_INDEX_CHECK)
00414                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00415 #else
00416         throw();
00417 #endif
00418  template <class VS1,class VS2,class E> friend   E _vsvssect(const VS1 &s1,const VS2 &s2)
00419 #if(CXSC_INDEX_CHECK)
00420                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00421 #else
00422         throw();
00423 #endif
00424 
00425         // vector-matrix
00426  template <class M,class V,class E> friend       E _mvlimult(const M &m,const V &v)
00427 #if(CXSC_INDEX_CHECK)
00428                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00429 #else
00430         throw();
00431 #endif
00432  template <class V,class M,class E> friend       E _vmlimult(const V &v,const M &m)
00433 #if(CXSC_INDEX_CHECK)
00434                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00435 #else
00436         throw();
00437 #endif
00438  template <class MS,class V,class E> friend      E _msvlimult(const MS &ms,const V &v)
00439 #if(CXSC_INDEX_CHECK)
00440                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00441 #else
00442         throw();
00443 #endif
00444  template <class V,class MS,class E> friend      E _vmslimult(const V &v,const MS &ms)
00445 #if(CXSC_INDEX_CHECK)
00446                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00447 #else
00448         throw();
00449 #endif
00450         
00451         // l_interval -----------------
00452  template <class V1,class V2> friend     V1 &_vvsetinf(V1 &rv1, const V2 &rv2)
00453 #if(CXSC_INDEX_CHECK)
00454                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00455 #else
00456         throw();
00457 #endif
00458  template <class V1,class V2> friend     V1 &_vvsetsup(V1 &rv1, const V2 &rv2)
00459 #if(CXSC_INDEX_CHECK)
00460                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00461 #else
00462         throw();
00463 #endif
00464  template <class V1,class V2> friend     V1 &_vvusetinf(V1 &rv1, const V2 &rv2)
00465 #if(CXSC_INDEX_CHECK)
00466                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00467 #else
00468         throw();
00469 #endif
00470  template <class V1,class V2> friend     V1 &_vvusetsup(V1 &rv1, const V2 &rv2)
00471 #if(CXSC_INDEX_CHECK)
00472                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00473 #else
00474         throw();
00475 #endif
00476  template <class VS,class V> friend      VS &_vsvsetinf(VS &sl, const V &rv)
00477 #if(CXSC_INDEX_CHECK)
00478                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00479 #else
00480         throw();
00481 #endif
00482  template <class VS,class V> friend      VS &_vsvsetsup(VS &sl, const V &rv)
00483 #if(CXSC_INDEX_CHECK)
00484                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00485 #else
00486         throw();
00487 #endif
00488  template <class VS,class V> friend      VS &_vsvusetinf(VS &sl, const V &rv)
00489 #if(CXSC_INDEX_CHECK)
00490                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00491 #else
00492         throw();
00493 #endif
00494  template <class VS,class V> friend      VS &_vsvusetsup(VS &sl, const V &rv)
00495 #if(CXSC_INDEX_CHECK)
00496                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00497 #else
00498         throw();
00499 #endif
00500 template <class MV,class V> friend  MV &_mvvsetinf(MV &v,const V &rv)
00501 #if(CXSC_INDEX_CHECK)
00502         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00503 #else
00504         throw();
00505 #endif
00506 template <class MV,class V> friend  MV &_mvvsetsup(MV &v,const V &rv)
00507 #if(CXSC_INDEX_CHECK)
00508         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00509 #else
00510         throw();
00511 #endif
00512 template <class MV,class V> friend  MV &_mvvusetinf(MV &v,const V &rv)
00513 #if(CXSC_INDEX_CHECK)
00514         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00515 #else
00516         throw();
00517 #endif
00518 template <class MV,class V> friend  MV &_mvvusetsup(MV &v,const V &rv)
00519 #if(CXSC_INDEX_CHECK)
00520         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00521 #else
00522         throw();
00523 #endif
00524  template <class V,class E> friend       E _vmid(const V &rv) throw();
00525  template <class V,class E> friend       E _vinf(const V &rv) throw();
00526  template <class V,class E> friend       E _vsup(const V &rv) throw();
00527  template <class V,class E> friend       E _vdiam(const V &rv) throw();
00528  template <class VS,class E> friend      E _vsmid(const VS &sl) throw();
00529  template <class VS,class E> friend      E _vsinf(const VS &sl) throw();
00530  template <class VS,class E> friend      E _vssup(const VS &sl) throw();
00531  template <class VS,class E> friend      E _vsdiam(const VS &sl) throw();
00532 template <class MV,class V> friend  V _mvdiam(const MV &mv) throw();
00533 template <class MV,class V> friend  V _mvmid(const MV &mv) throw();
00534 template <class MV,class V> friend  V _mvinf(const MV &mv) throw();
00535 template <class MV,class V> friend  V _mvsup(const MV &mv) throw();
00536 
00537         // vector-vector
00538  template <class V1,class V2> friend     V1 &_vvconvassign(V1 &rv1, const V2 &rv2)
00539 #if(CXSC_INDEX_CHECK)
00540                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00541 #else
00542         throw();
00543 #endif
00544  template <class V1,class V2> friend     V1 &_vvsectassign(V1 &rv1, const V2 &rv2)
00545 #if(CXSC_INDEX_CHECK)
00546                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00547 #else
00548         throw();
00549 #endif
00550  template <class VS,class V> friend      VS &_vsvconvassign(VS &sl, const V &rv)
00551 #if(CXSC_INDEX_CHECK)
00552                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00553 #else
00554         throw();
00555 #endif
00556  template <class VS,class V> friend      VS &_vsvsectassign(VS &sl, const V &rv)
00557 #if(CXSC_INDEX_CHECK)
00558                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00559 #else
00560         throw();
00561 #endif
00562 
00563 template <class MV,class V> friend  MV &_mvvconvassign(MV &v,const V &rv)
00564 #if(CXSC_INDEX_CHECK)
00565         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00566 #else
00567         throw();
00568 #endif
00569 template <class MV,class V> friend  MV &_mvvsectassign(MV &v,const V &rv)
00570 #if(CXSC_INDEX_CHECK)
00571         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00572 #else
00573         throw();
00574 #endif
00575 
00576 
00577 #endif
00578 
00579         //------ Konstruktoren ----------------------------------------------------
00581         INLINE l_rvector () throw();
00583         explicit INLINE l_rvector(const int &i) throw();
00584 #ifdef OLD_CXSC
00585 
00586         explicit INLINE l_rvector(const class index &i) throw(); // for backwards compatibility
00587 #endif
00588 
00589         explicit INLINE l_rvector(const int &i1,const int &i2)
00590 #if(CXSC_INDEX_CHECK)
00591         throw(ERROR_LRVECTOR_WRONG_BOUNDARIES,ERROR_LRVECTOR_NO_MORE_MEMORY);
00592 #else
00593         throw();
00594 #endif
00595 
00596         INLINE l_rvector(const l_rmatrix_subv &) throw();
00598         explicit INLINE l_rvector(const l_real &) throw();
00600         explicit INLINE l_rvector(const l_rmatrix &)
00601 #if(CXSC_INDEX_CHECK)
00602         throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ);
00603 #else
00604         throw();
00605 #endif
00606 
00607         explicit INLINE l_rvector(const l_rmatrix_slice &sl)
00608 #if(CXSC_INDEX_CHECK)
00609         throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ);
00610 #else
00611         throw();
00612 #endif
00613 
00614         INLINE l_rvector(const l_rvector_slice &rs) throw();
00616         INLINE l_rvector(const l_rvector &v) throw();
00617         // Real
00619         explicit INLINE l_rvector(const real &) throw();
00621         explicit INLINE l_rvector(const rvector_slice &rs) throw();
00623         explicit INLINE l_rvector(const rvector &v) throw();
00625         explicit INLINE l_rvector(const rmatrix &)
00626 #if(CXSC_INDEX_CHECK)
00627         throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
00628 #else
00629         throw();
00630 #endif
00631 
00632         explicit INLINE l_rvector(const rmatrix_slice &sl)
00633 #if(CXSC_INDEX_CHECK)
00634         throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
00635 #else
00636         throw();
00637 #endif
00638 
00639         explicit INLINE l_rvector(const rmatrix_subv &) throw();
00640         
00641         // l_real
00643         INLINE l_rvector &operator =(const l_rvector &rv) throw();
00645         INLINE l_rvector &operator =(const l_rvector_slice &sl) throw();
00647         INLINE l_rvector &operator =(const l_real &r) throw();
00649         INLINE l_rvector &operator =(const l_rmatrix &m)
00650 #if(CXSC_INDEX_CHECK)
00651         throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ);
00652 #else
00653         throw();
00654 #endif
00655 
00656         INLINE l_rvector &operator =(const l_rmatrix_slice &)
00657 #if(CXSC_INDEX_CHECK)
00658         throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ);
00659 #else
00660         throw();
00661 #endif
00662 
00663         INLINE l_rvector &operator =(const l_rmatrix_subv &) throw();
00664         // Real
00666         INLINE l_rvector &operator =(const rvector &rv) throw();
00668         INLINE l_rvector &operator =(const rvector_slice &sl) throw();
00670         INLINE l_rvector &operator =(const real &r) throw();
00672         INLINE l_rvector &operator =(const rmatrix &m)
00673 #if(CXSC_INDEX_CHECK)
00674         throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
00675 #else
00676         throw();
00677 #endif
00678 
00679         INLINE l_rvector &operator =(const rmatrix_slice &)
00680 #if(CXSC_INDEX_CHECK)
00681         throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
00682 #else
00683         throw();
00684 #endif
00685 
00686         INLINE l_rvector &operator =(const rmatrix_subv &) throw();
00687 
00688         //--------- Destruktor ----------------------------------------------------
00689         INLINE ~l_rvector() { delete [] dat; }
00690 
00691         //------ Standardfunktionen -----------------------------------------------
00692         
00693         friend INLINE l_real::l_real(const l_rvector &)
00694 #if(CXSC_INDEX_CHECK)
00695         throw(ERROR_LRVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_LRVECTOR_USE_OF_UNINITIALIZED_OBJ);
00696 #else
00697         throw();
00698 #endif
00699 
00700         friend INLINE int Lb(const l_rvector &rv) throw() { return rv.l; }
00702         friend INLINE int Ub(const l_rvector &rv) throw() { return rv.u; }
00704         friend INLINE int VecLen(const l_rvector &rv) throw() { return rv.size; }
00706         friend INLINE l_rvector & SetLb(l_rvector &rv, const int &l) throw() { rv.l=l; rv.u=l+rv.size-1; return rv;}
00708         friend INLINE l_rvector & SetUb(l_rvector &rv, const int &u) throw() { rv.u=u; rv.l=u-rv.size+1; return rv;}
00710         INLINE l_real & operator [](const int &i) const
00711 #if(CXSC_INDEX_CHECK)
00712         throw(ERROR_LRVECTOR_ELEMENT_NOT_IN_VEC);
00713 #else
00714         throw();
00715 #endif
00716 
00717         INLINE l_rvector & operator ()() throw() { return *this; }
00719         INLINE l_rvector_slice operator ()(const int &i)
00720 #if(CXSC_INDEX_CHECK)
00721         throw(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG);
00722 #else
00723         throw();
00724 #endif
00725 
00726         INLINE l_rvector_slice operator ()(const int &i1,const int &i2)
00727 #if(CXSC_INDEX_CHECK)
00728         throw(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG);
00729 #else
00730         throw();
00731 #endif
00732         INLINE operator void*() throw();
00733 //#else
00734 //#endif
00735 };
00736 
00737 
00739 
00744 class l_rvector_slice
00745 {
00746         friend class l_rvector;
00747         friend class l_rmatrix;
00748         friend class l_ivector;
00749         friend class l_imatrix;
00750         private:
00751         l_real *dat;
00752         int l,u,size;
00753         int start,end;
00754 
00755         public:
00756 //#if(CXSC_INDEX_CHECK) 
00757 
00758 template<typename S, typename T>
00759 friend inline void addDot(const S &x, const T &y, dotprecision &val);
00760 
00761 
00762 #ifdef _CXSC_FRIEND_TPL
00763 //------------------------- Templates -------------------------------------------
00764 // l_real / l_real
00765 
00766  template <class VS1,class VS2> friend   VS1 & _vsvsassign(VS1 &sl1,const VS2 &sl2)
00767 #if(CXSC_INDEX_CHECK)
00768                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00769 #else
00770         throw();
00771 #endif
00772  template <class V,class VS,class S> friend      V & _vvsassign(V &rv,const VS &sl) throw();
00773  template <class VS,class V> friend      VS & _vsvassign(VS &sl,const V &rv)
00774 #if(CXSC_INDEX_CHECK)
00775                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00776 #else
00777         throw();
00778 #endif
00779  template <class VS,class S> friend      VS & _vssassign(VS &sl,const S &r) throw();
00780 
00781  template <class DP,class VS,class V> friend     void _vsvaccu(DP &dp, const VS & sl, const V &rv)
00782 #if(CXSC_INDEX_CHECK)
00783                 throw(OP_WITH_WRONG_DIM);
00784 #else
00785         throw();
00786 #endif
00787  template <class DP,class VS1,class VS2> friend          void _vsvsaccu(DP &dp, const VS1 & sl1, const VS2 &sl2)
00788 #if(CXSC_INDEX_CHECK)
00789                 throw(OP_WITH_WRONG_DIM);
00790 #else
00791         throw();
00792 #endif
00793 
00794  template <class VS,class S,class E> friend      E _vssdiv(const VS &sl, const S &s) throw();
00795  template <class VS,class S,class E> friend      E _vssmult(const VS &sl, const S &s) throw();
00796 
00797  template <class VS,class V,class E> friend      E _vsvlmult(const VS & sl, const V &rv)
00798 #if(CXSC_INDEX_CHECK)
00799                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00800 #else
00801         throw();
00802 #endif
00803  template <class VS,class S> friend      VS &_vssmultassign(VS &rv,const S &r) throw();
00804  template <class VS,class S> friend      VS &_vssdivassign(VS &rv,const S &r) throw();
00805  template <class V,class VS,class E> friend      E _vvsplus(const V &rv,const VS &sl)
00806 #if(CXSC_INDEX_CHECK)
00807                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00808 #else
00809         throw();
00810 #endif
00811  template <class VS1,class VS2,class E> friend   E _vsvsplus(const VS1 &s1,const VS2 &s2)
00812 #if(CXSC_INDEX_CHECK)
00813                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00814 #else
00815         throw();
00816 #endif
00817  template <class VS1,class VS2,class E> friend   E _vsvsminus(const VS1 &s1,const VS2 &s2)
00818 #if(CXSC_INDEX_CHECK)
00819                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00820 #else
00821         throw();
00822 #endif
00823  template <class V,class VS> friend      V &_vvsplusassign(V &rv, const VS &sl)
00824 #if(CXSC_INDEX_CHECK)
00825                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00826 #else
00827         throw();
00828 #endif
00829  template <class VS,class V> friend      VS &_vsvplusassign(VS &sl, const V &rv)
00830 #if(CXSC_INDEX_CHECK)
00831                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00832 #else
00833         throw();
00834 #endif
00835  template <class VS1,class VS2> friend   VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
00836 #if(CXSC_INDEX_CHECK)
00837                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00838 #else
00839         throw();
00840 #endif
00841  template <class VS1,class VS2> friend   VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
00842 #if(CXSC_INDEX_CHECK)
00843                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00844 #else
00845         throw();
00846 #endif
00847  template <class V,class VS> friend      V &_vvsminusassign(V &rv, const VS &sl)
00848 #if(CXSC_INDEX_CHECK)
00849                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00850 #else
00851         throw();
00852 #endif
00853  template <class VS,class V> friend      VS &_vsvminusassign(VS &sl, const V &rv)
00854 #if(CXSC_INDEX_CHECK)
00855                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00856 #else
00857         throw();
00858 #endif
00859  template <class VS,class V> friend      V _vsminus(const VS &sl) throw();
00860  template <class V,class VS,class E> friend      E _vvsminus(const V &rv, const VS &sl)
00861 #if(CXSC_INDEX_CHECK)
00862                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00863 #else
00864         throw();
00865 #endif
00866  template <class VS,class V,class E> friend      E _vsvminus(const VS &sl,const V &rv)
00867 #if(CXSC_INDEX_CHECK)
00868                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00869 #else
00870         throw();
00871 #endif
00872  template <class V,class VS,class E> friend      E _vvsconv(const V &rv,const VS &sl)
00873 #if(CXSC_INDEX_CHECK)
00874                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00875 #else
00876         throw();
00877 #endif
00878  template <class VS1,class VS2,class E> friend   E _vsvsconv(const VS1 &s1,const VS2 &s2)
00879 #if(CXSC_INDEX_CHECK)
00880                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00881 #else
00882         throw();
00883 #endif
00884  template <class VS,class V> friend      bool _vsveq(const VS &sl, const V &rv) throw();
00885  template <class VS,class V> friend      bool _vsvneq(const VS &sl, const V &rv) throw();
00886  template <class VS,class V> friend      bool _vsvless(const VS &sl, const V &rv) throw();
00887  template <class VS,class V> friend      bool _vsvleq(const VS &sl, const V &rv) throw();
00888  template <class V,class VS> friend      bool _vvsless(const V &rv, const VS &sl) throw();
00889  template <class V,class VS> friend      bool _vvsleq(const V &rv, const VS &sl) throw();
00890  template <class VS,class E> friend      E _vsabs(const VS &sl) throw();
00891  template <class VS1,class VS2,class E> friend   E _vsvslmult(const VS1 & sl1, const VS2 &sl2)
00892 #if(CXSC_INDEX_CHECK)
00893                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00894 #else
00895         throw();
00896 #endif
00897  template <class VS1,class VS2> friend   bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw();
00898  template <class VS1,class VS2> friend   bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw();
00899  template <class VS1,class VS2> friend   bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw();
00900  template <class VS1,class VS2> friend   bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw();
00901  template <class VS> friend      bool _vsnot(const VS &sl) throw();
00902  template <class VS> friend      void *_vsvoid(const VS &sl) throw();
00903  template <class V> friend      std::ostream &_vsout(std::ostream &s, const V &rv) throw();
00904  template <class V> friend      std::istream &_vsin(std::istream &s, V &rv) throw();
00905 
00906  template <class VS,class M,class S> friend      VS &_vsmlmultassign(VS &v,const M &m)
00907 #if(CXSC_INDEX_CHECK)
00908                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00909 #else
00910         throw();
00911 #endif
00912         
00913         // l_real / Real
00914  template <class V,class MS,class E> friend      E _vmslmult(const V &v,const MS &ms)
00915 #if(CXSC_INDEX_CHECK)
00916                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00917 #else
00918         throw();
00919 #endif
00920         
00921  template <class V,class VS,class E> friend      E _vvssect(const V &rv,const VS &sl)
00922 #if(CXSC_INDEX_CHECK)
00923                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00924 #else
00925         throw();
00926 #endif
00927  template <class VS1,class VS2,class E> friend   E _vsvssect(const VS1 &s1,const VS2 &s2)
00928 #if(CXSC_INDEX_CHECK)
00929                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00930 #else
00931         throw();
00932 #endif
00933 
00934         // interval -----------
00935         // vector-vector -------
00936  template <class V1,class V2,class E> friend     E _vvlimult(const V1 & rv1, const V2 &rv2)
00937 #if(CXSC_INDEX_CHECK)
00938                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00939 #else
00940         throw();
00941 #endif
00942  template <class VS,class V,class E> friend      E _vsvlimult(const VS & sl, const V &rv)
00943 #if(CXSC_INDEX_CHECK)
00944                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00945 #else
00946         throw();
00947 #endif
00948  template <class VS1,class VS2,class E> friend   E _vsvslimult(const VS1 & sl1, const VS2 &sl2)
00949 #if(CXSC_INDEX_CHECK)
00950                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00951 #else
00952         throw();
00953 #endif
00954  template <class V1,class V2,class E> friend     E _vvplus(const V1 &rv1, const V2 &rv2)
00955 #if(CXSC_INDEX_CHECK)
00956                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00957 #else
00958         throw();
00959 #endif
00960  template <class V1,class V2,class E> friend     E _vvminus(const V1 &rv1, const V2 &rv2)
00961 #if(CXSC_INDEX_CHECK)
00962                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00963 #else
00964         throw();
00965 #endif
00966 
00967         // vector-matrix -------
00968   /*   friend TINLINE l_ivector _mvslimult<imatrix,l_rvector_slice,l_ivector>(const imatrix &m,const l_rvector_slice &v)
00969 #if(CXSC_INDEX_CHECK)
00970         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
00971 #else
00972         throw();
00973         #endif */
00974   /*   friend TINLINE l_ivector _vsmlimult<l_rvector_slice,imatrix,l_ivector>(const l_rvector_slice &v,const imatrix &m)
00975 #if(CXSC_INDEX_CHECK)
00976         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
00977 #else
00978         throw();
00979         #endif */
00980 
00981         // l_interval -- vector-vector
00982  template <class V,class VS> friend      V &_vvsconvassign(V &rv, const VS &sl)
00983 #if(CXSC_INDEX_CHECK)
00984                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00985 #else
00986         throw();
00987 #endif
00988  template <class V,class VS> friend      V &_vvssectassign(V &rv, const VS &sl)
00989 #if(CXSC_INDEX_CHECK)
00990                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00991 #else
00992         throw();
00993 #endif
00994  template <class VS1,class VS2> friend   VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2)
00995 #if(CXSC_INDEX_CHECK)
00996                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00997 #else
00998         throw();
00999 #endif
01000  template <class VS1,class VS2> friend   VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2)
01001 #if(CXSC_INDEX_CHECK)
01002                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01003 #else
01004         throw();
01005 #endif
01006 #endif
01007         
01008         //--------------------- Konstruktoren -----------------------------------
01010         explicit INLINE l_rvector_slice(l_rvector &a, const int &lb, const int &ub) throw():dat(a.dat),l(a.l),u(a.u),size(ub-lb+1),start(lb),end(ub) { }
01012         explicit INLINE l_rvector_slice(l_rvector_slice &a, const int &lb, const int &ub) throw():dat(a.dat),l(a.l),u(a.u),size(ub-lb+1),start(lb),end(ub) { }
01013         public:
01015         INLINE l_rvector_slice(const l_rvector_slice &a) throw():dat(a.dat),l(a.l),u(a.u),size(a.size),start(a.start),end(a.end) { }
01016         public:
01017         // l_real
01019         INLINE l_rvector_slice & operator =(const l_rvector_slice &sl)
01020 #if(CXSC_INDEX_CHECK)
01021         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01022 #else
01023         throw();
01024 #endif
01025 
01026         INLINE l_rvector_slice & operator =(const l_rvector &rv)
01027 #if(CXSC_INDEX_CHECK)
01028         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01029 #else
01030         throw();
01031 #endif
01032 
01033         INLINE l_rvector_slice & operator =(const l_real &r) throw();
01035         INLINE l_rvector_slice & operator =(const l_rmatrix &m)
01036 #if(CXSC_INDEX_CHECK)
01037         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>,ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ);
01038 #else
01039         throw();
01040 #endif
01041 
01042         INLINE l_rvector_slice & operator =(const l_rmatrix_slice &m)
01043 #if(CXSC_INDEX_CHECK)
01044         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>,ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ);
01045 #else
01046         throw();
01047 #endif
01048 
01049         INLINE l_rvector_slice &operator =(const l_rmatrix_subv &) throw();
01050         // Real
01052         INLINE l_rvector_slice & operator =(const rvector_slice &sl)
01053 #if(CXSC_INDEX_CHECK)
01054         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01055 #else
01056         throw();
01057 #endif
01058 
01059         INLINE l_rvector_slice & operator =(const rvector &rv)
01060 #if(CXSC_INDEX_CHECK)
01061         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01062 #else
01063         throw();
01064 #endif
01065 
01066         INLINE l_rvector_slice & operator =(const real &r) throw();
01068         INLINE l_rvector_slice & operator =(const rmatrix &m)
01069 #if(CXSC_INDEX_CHECK)
01070         throw(ERROR__OP_WITH_WRONG_DIM<rvector>,ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
01071 #else
01072         throw();
01073 #endif
01074 
01075         INLINE l_rvector_slice & operator =(const rmatrix_slice &m)
01076 #if(CXSC_INDEX_CHECK)
01077         throw(ERROR__OP_WITH_WRONG_DIM<rvector>,ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
01078 #else
01079         throw();
01080 #endif
01081 
01082         INLINE l_rvector_slice &operator =(const rmatrix_subv &mv) throw();
01083 
01084         // l_interval --------
01085  template <class V,class VS> friend      V &_vvssetinf(V &rv, const VS &sl)
01086 #if(CXSC_INDEX_CHECK)
01087                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01088 #else
01089         throw();
01090 #endif
01091  template <class V,class VS> friend      V &_vvssetsup(V &rv, const VS &sl)
01092 #if(CXSC_INDEX_CHECK)
01093                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01094 #else
01095         throw();
01096 #endif
01097  template <class V,class VS> friend      V &_vvsusetinf(V &rv, const VS &sl)
01098 #if(CXSC_INDEX_CHECK)
01099                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01100 #else
01101         throw();
01102 #endif
01103  template <class V,class VS> friend      V &_vvsusetsup(V &rv, const VS &sl)
01104 #if(CXSC_INDEX_CHECK)
01105                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01106 #else
01107         throw();
01108 #endif
01109  template <class VS1,class VS2> friend   VS1 &_vsvssetinf(VS1 &sl1, const VS2 &sl2)
01110 #if(CXSC_INDEX_CHECK)
01111                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01112 #else
01113         throw();
01114 #endif
01115  template <class VS1,class VS2> friend   VS1 &_vsvssetsup(VS1 &sl1, const VS2 &sl2)
01116 #if(CXSC_INDEX_CHECK)
01117                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01118 #else
01119         throw();
01120 #endif
01121  template <class VS1,class VS2> friend   VS1 &_vsvsusetinf(VS1 &sl1, const VS2 &sl2)
01122 #if(CXSC_INDEX_CHECK)
01123                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01124 #else
01125         throw();
01126 #endif
01127  template <class VS1,class VS2> friend   VS1 &_vsvsusetsup(VS1 &sl1, const VS2 &sl2)
01128 #if(CXSC_INDEX_CHECK)
01129                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01130 #else
01131         throw();
01132 #endif
01133 
01134         // l_interval -- vector-vector
01135  template <class V,class MS,class E> friend      E _vmslimult(const V &v,const MS &ms)
01136 #if(CXSC_INDEX_CHECK)
01137                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01138 #else
01139         throw();
01140 #endif
01141         // l_interval -- vector-matrix
01142 
01143 
01144         //--------------------- Standardfunktionen ------------------------------
01145 
01146         friend INLINE l_real::l_real(const l_rvector_slice &sl)
01147 #if(CXSC_INDEX_CHECK)
01148         throw(ERROR_LRVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_LRVECTOR_USE_OF_UNINITIALIZED_OBJ);
01149 #else
01150         throw();
01151 #endif
01152 
01153         friend INLINE int Lb(const l_rvector_slice &sl) throw() { return sl.start; }
01155         friend INLINE int Ub(const l_rvector_slice &sl) throw() { return sl.end; }
01157         friend INLINE int VecLen(const l_rvector_slice &sl) throw() { return sl.end-sl.start+1; }
01159         INLINE l_real & operator [](const int &i) const
01160 #if(CXSC_INDEX_CHECK)
01161         throw(ERROR_LRVECTOR_ELEMENT_NOT_IN_VEC);
01162 #else
01163         throw();
01164 #endif
01165 
01166         INLINE l_rvector_slice & operator ()() throw() { return *this; }
01168         INLINE l_rvector_slice operator ()(const int &i)
01169 #if(CXSC_INDEX_CHECK)
01170         throw(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG);
01171 #else
01172         throw();
01173 #endif
01174 
01175         INLINE l_rvector_slice operator ()(const int &i1,const int &i2)
01176 #if(CXSC_INDEX_CHECK)
01177         throw(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG);
01178 #else
01179         throw();
01180 #endif
01181         
01183         INLINE l_rvector_slice &operator /=(const l_real &r) throw();
01185         INLINE l_rvector_slice &operator /=(const real &r) throw();
01187         INLINE l_rvector_slice &operator *=(const l_real &r) throw();
01189         INLINE l_rvector_slice &operator *=(const l_rmatrix &m)
01190 #if(CXSC_INDEX_CHECK)
01191         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
01192 #else
01193         throw();
01194 #endif
01195 
01196         INLINE l_rvector_slice &operator *=(const rmatrix &m)
01197 #if(CXSC_INDEX_CHECK)
01198         throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
01199 #else
01200         throw();
01201 #endif
01202 
01203         INLINE l_rvector_slice &operator *=(const real &r) throw();
01205         INLINE l_rvector_slice &operator +=(const l_rvector &rv)
01206 #if(CXSC_INDEX_CHECK)
01207         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01208 #else
01209         throw();
01210 #endif
01211 
01212         INLINE l_rvector_slice &operator +=(const l_rvector_slice &sl2)
01213 #if(CXSC_INDEX_CHECK)
01214         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01215 #else
01216         throw();
01217 #endif
01218 
01219         INLINE l_rvector_slice &operator -=(const l_rvector &rv)
01220 #if(CXSC_INDEX_CHECK)
01221         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01222 #else
01223         throw();
01224 #endif
01225 
01226         INLINE l_rvector_slice &operator -=(const l_rvector_slice &sl2)
01227 #if(CXSC_INDEX_CHECK)
01228         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01229 #else
01230         throw();
01231 #endif
01232 
01233         INLINE l_rvector_slice &operator |=(const l_rvector &rv)
01234 #if(CXSC_INDEX_CHECK)
01235         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01236 #else
01237         throw();
01238 #endif
01239 
01240         INLINE l_rvector_slice &operator |=(const l_rvector_slice &sl2)
01241 #if(CXSC_INDEX_CHECK)
01242         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01243 #else
01244         throw();
01245 #endif
01246 
01247         INLINE l_rvector_slice &operator &=(const l_rvector &rv)
01248 #if(CXSC_INDEX_CHECK)
01249         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01250 #else
01251         throw();
01252 #endif
01253 
01254         INLINE l_rvector_slice &operator &=(const l_rvector_slice &sl2)
01255 #if(CXSC_INDEX_CHECK)
01256         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01257 #else
01258         throw();
01259 #endif
01260         
01262         INLINE l_rvector_slice &operator +=(const rvector &rv)
01263 #if(CXSC_INDEX_CHECK)
01264         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01265 #else
01266         throw();
01267 #endif
01268 
01269         INLINE l_rvector_slice &operator +=(const rvector_slice &sl2)
01270 #if(CXSC_INDEX_CHECK)
01271         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01272 #else
01273         throw();
01274 #endif
01275 
01276         INLINE l_rvector_slice &operator -=(const rvector &rv)
01277 #if(CXSC_INDEX_CHECK)
01278         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01279 #else
01280         throw();
01281 #endif
01282 
01283         INLINE l_rvector_slice &operator -=(const rvector_slice &sl2)
01284 #if(CXSC_INDEX_CHECK)
01285         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01286 #else
01287         throw();
01288 #endif
01289 
01290         INLINE l_rvector_slice &operator |=(const rvector &rv)
01291 #if(CXSC_INDEX_CHECK)
01292         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01293 #else
01294         throw();
01295 #endif
01296 
01297         INLINE l_rvector_slice &operator |=(const rvector_slice &sl2)
01298 #if(CXSC_INDEX_CHECK)
01299         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01300 #else
01301         throw();
01302 #endif
01303 
01304         INLINE l_rvector_slice &operator &=(const rvector &rv)
01305 #if(CXSC_INDEX_CHECK)
01306         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01307 #else
01308         throw();
01309 #endif
01310 
01311         INLINE l_rvector_slice &operator &=(const rvector_slice &sl2)
01312 #if(CXSC_INDEX_CHECK)
01313         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01314 #else
01315         throw();
01316 #endif
01317         INLINE operator void*() throw();
01318 //#else
01319 //#endif
01320 };
01321 
01322 //=======================================================================
01323 //======================== Vector Functions =============================
01324 
01326         INLINE l_rvector _l_rvector(const l_real &r) throw();
01327 //      INLINE l_rvector _l_rvector(const l_rmatrix &m) throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ);
01328 //      INLINE l_rvector _l_rvector(const l_rmatrix_slice &sl) throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ);
01330         INLINE l_rvector _l_rvector(const real &r) throw();
01332         INLINE l_rvector _l_rvector(const rvector_slice &rs) throw();
01334         INLINE l_rvector _l_rvector(const rvector &rs) throw();
01335 //      INLINE l_rvector _l_rvector(const rmatrix &m) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
01336 //      INLINE l_rvector _l_rvector(const rmatrix_slice &sl) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
01338         INLINE l_rvector _l_rvector(const rmatrix_subv &rs) throw();
01339 
01341         INLINE void Resize(l_rvector &rv) throw();
01343         INLINE void Resize(l_rvector &rv, const int &len)
01344 #if(CXSC_INDEX_CHECK)
01345         throw(ERROR__WRONG_BOUNDARIES<l_rvector>);
01346 #else
01347         throw();
01348 #endif
01349 
01350         INLINE void Resize(l_rvector &rv, const int &lb, const int &ub)
01351 #if(CXSC_INDEX_CHECK)
01352         throw(ERROR__WRONG_BOUNDARIES<l_rvector>);
01353 #else
01354         throw();
01355 #endif
01356         
01358         INLINE l_rvector abs(const l_rvector &rv) throw();
01360         INLINE l_rvector abs(const l_rvector_slice &sl) throw();
01362         INLINE bool operator !(const l_rvector &rv) throw();
01364         INLINE bool operator !(const l_rvector_slice &sl) throw();
01365 
01366 //======================= Vector / Scalar ===============================
01367 
01368 //----------------------------- l_real ---------------------------
01369 
01371         INLINE l_rvector operator *(const l_rvector &rv, const l_real &s) throw();
01373         INLINE l_rvector operator *(const l_rvector_slice &sl, const l_real &s) throw();
01375         INLINE l_rvector operator *(const l_real &s, const l_rvector &rv) throw();
01377         INLINE l_rvector operator *(const l_real &s, const l_rvector_slice &sl) throw();
01379         INLINE l_rvector &operator *=(l_rvector &rv,const l_real &r) throw();
01380 
01382         INLINE l_rvector operator /(const l_rvector &rv, const l_real &s) throw();
01384         INLINE l_rvector operator /(const l_rvector_slice &sl, const l_real &s) throw();
01386         INLINE l_rvector &operator /=(l_rvector &rv,const l_real &r) throw();
01387 
01388 //---------------------------- Real --------------------------------------
01389 
01391         INLINE l_rvector operator *(const l_rvector &rv, const real &s) throw();
01393         INLINE l_rvector operator *(const l_rvector_slice &sl, const real &s) throw();
01395         INLINE l_rvector operator *(const real &s, const l_rvector &rv) throw();
01397         INLINE l_rvector operator *(const real &s, const l_rvector_slice &sl) throw();
01399         INLINE l_rvector &operator *=(l_rvector &rv,const real &r) throw();
01400 
01402         INLINE l_rvector operator /(const l_rvector &rv, const real &s) throw();
01404         INLINE l_rvector operator /(const l_rvector_slice &sl, const real &s) throw();
01406         INLINE l_rvector &operator /=(l_rvector &rv,const real &r) throw();
01407 
01409         INLINE l_rvector operator *(const rvector &rv, const l_real &s) throw();
01411         INLINE l_rvector operator *(const rvector_slice &sl, const l_real &s) throw();
01413         INLINE l_rvector operator *(const l_real &s, const rvector &rv) throw();
01415         INLINE l_rvector operator *(const l_real &s, const rvector_slice &sl) throw();
01416 
01418         INLINE l_rvector operator /(const rvector &rv, const l_real &s) throw();
01420         INLINE l_rvector operator /(const rvector_slice &sl, const l_real &s) throw();
01421 
01422 //======================= Vector / Vector ===============================
01423 
01424 
01426         INLINE std::ostream &operator <<(std::ostream &s, const l_rvector &rv) throw();
01428         INLINE std::ostream &operator <<(std::ostream &o, const l_rvector_slice &sl) throw();
01430         INLINE std::istream &operator >>(std::istream &s, l_rvector &rv) throw();
01432         INLINE std::istream &operator >>(std::istream &s, l_rvector_slice &rv) throw();
01433         
01434 //----------------------- l_real / l_real ---------------------------
01435 
01437         INLINE void accumulate(dotprecision &dp, const l_rvector & rv1, const l_rvector &rv2)
01438 #if(CXSC_INDEX_CHECK)
01439         throw(OP_WITH_WRONG_DIM);
01440 #else
01441         throw();
01442 #endif
01443 
01444         INLINE void accumulate(dotprecision &dp, const l_rvector_slice & sl, const l_rvector &rv)
01445 #if(CXSC_INDEX_CHECK)
01446         throw(OP_WITH_WRONG_DIM);
01447 #else
01448         throw();
01449 #endif
01450 
01451         INLINE void accumulate(dotprecision &dp, const l_rvector &rv, const l_rvector_slice &sl)
01452 #if(CXSC_INDEX_CHECK)
01453         throw(OP_WITH_WRONG_DIM);
01454 #else
01455         throw();
01456 #endif
01457 
01458         INLINE void accumulate(dotprecision &dp, const l_rvector & rv1, const l_rmatrix_subv &rv2)
01459 #if(CXSC_INDEX_CHECK)
01460         throw(OP_WITH_WRONG_DIM);
01461 #else
01462         throw();
01463 #endif
01464 
01465         INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const l_rvector &rv2)
01466 #if(CXSC_INDEX_CHECK)
01467         throw(OP_WITH_WRONG_DIM);
01468 #else
01469         throw();
01470 #endif
01471 
01472         INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const l_rmatrix_subv &rv2)
01473 #if(CXSC_INDEX_CHECK)
01474         throw(OP_WITH_WRONG_DIM);
01475 #else
01476         throw();
01477 #endif
01478 
01479         INLINE void accumulate(dotprecision &dp, const l_rvector_slice & sl1, const l_rvector_slice &sl2)
01480 #if(CXSC_INDEX_CHECK)
01481         throw(OP_WITH_WRONG_DIM);
01482 #else
01483         throw();
01484 #endif
01485 
01486         INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const l_rvector &rv2)
01487 #if(CXSC_INDEX_CHECK)
01488         throw(OP_WITH_WRONG_DIM);
01489 #else
01490         throw();
01491 #endif
01492 
01493         INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl, const l_rvector &rv)
01494 #if(CXSC_INDEX_CHECK)
01495         throw(OP_WITH_WRONG_DIM);
01496 #else
01497         throw();
01498 #endif
01499 
01500         INLINE void accumulate(idotprecision &dp, const l_rvector &rv, const l_rvector_slice &sl)
01501 #if(CXSC_INDEX_CHECK)
01502         throw(OP_WITH_WRONG_DIM);
01503 #else
01504         throw();
01505 #endif
01506 
01507         INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const l_rmatrix_subv &rv2)
01508 #if(CXSC_INDEX_CHECK)
01509         throw(OP_WITH_WRONG_DIM);
01510 #else
01511         throw();
01512 #endif
01513 
01514         INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const l_rvector &rv2)
01515 #if(CXSC_INDEX_CHECK)
01516         throw(OP_WITH_WRONG_DIM);
01517 #else
01518         throw();
01519 #endif
01520 
01521         INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl1, const l_rvector_slice &sl2)
01522 #if(CXSC_INDEX_CHECK)
01523         throw(OP_WITH_WRONG_DIM);
01524 #else
01525         throw();
01526 #endif
01527 
01528         INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const l_rmatrix_subv &rv2)
01529 #if(CXSC_INDEX_CHECK)
01530         throw(OP_WITH_WRONG_DIM);
01531 #else
01532         throw();
01533 #endif
01534 
01535 
01537         INLINE l_real operator *(const l_rvector & rv1, const l_rvector &rv2)
01538 #if(CXSC_INDEX_CHECK)
01539         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01540 #else
01541         throw();
01542 #endif
01543 
01544         INLINE l_real operator *(const l_rvector_slice &sl, const l_rvector &rv)
01545 #if(CXSC_INDEX_CHECK)
01546         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01547 #else
01548         throw();
01549 #endif
01550 
01551         INLINE l_real operator *(const l_rvector &rv, const l_rvector_slice &sl)
01552 #if(CXSC_INDEX_CHECK)
01553         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01554 #else
01555         throw();
01556 #endif
01557 
01558         INLINE l_real operator *(const l_rvector_slice & sl1, const l_rvector_slice &sl2)
01559 #if(CXSC_INDEX_CHECK)
01560         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01561 #else
01562         throw();
01563 #endif
01564         
01566         INLINE const l_rvector &operator +(const l_rvector &rv) throw();
01568         INLINE l_rvector operator +(const l_rvector_slice &sl) throw();
01569 
01571         INLINE l_rvector operator +(const l_rvector &rv1, const l_rvector &rv2)
01572 #if(CXSC_INDEX_CHECK)
01573         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01574 #else
01575         throw();
01576 #endif
01577 
01578         INLINE l_rvector operator +(const l_rvector &rv, const l_rvector_slice &sl)
01579 #if(CXSC_INDEX_CHECK)
01580         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01581 #else
01582         throw();
01583 #endif
01584 
01585         INLINE l_rvector operator +(const l_rvector_slice &sl, const l_rvector &rv)
01586 #if(CXSC_INDEX_CHECK)
01587         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01588 #else
01589         throw();
01590 #endif
01591 
01592         INLINE l_rvector operator +(const l_rvector_slice &sl1, const l_rvector_slice &sl2)
01593 #if(CXSC_INDEX_CHECK)
01594         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01595 #else
01596         throw();
01597 #endif
01598 
01599         INLINE l_rvector & operator +=(l_rvector &rv1, const l_rvector &rv2)
01600 #if(CXSC_INDEX_CHECK)
01601         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01602 #else
01603         throw();
01604 #endif
01605 
01606         INLINE l_rvector &operator +=(l_rvector &rv, const l_rvector_slice &sl)
01607 #if(CXSC_INDEX_CHECK)
01608         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01609 #else
01610         throw();
01611 #endif
01612 
01614         INLINE l_rvector operator -(const l_rvector &rv) throw();
01616         INLINE l_rvector operator -(const l_rvector_slice &sl) throw();
01618         INLINE l_rvector operator -(const l_rvector &rv1, const l_rvector &rv2)
01619 #if(CXSC_INDEX_CHECK)
01620         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01621 #else
01622         throw();
01623 #endif
01624 
01625         INLINE l_rvector operator -(const l_rvector &rv, const l_rvector_slice &sl)
01626 #if(CXSC_INDEX_CHECK)
01627         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01628 #else
01629         throw();
01630 #endif
01631 
01632         INLINE l_rvector operator -(const l_rvector_slice &sl, const l_rvector &rv)
01633 #if(CXSC_INDEX_CHECK)
01634         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01635 #else
01636         throw();
01637 #endif
01638 
01639         INLINE l_rvector operator -(const l_rvector_slice &sl1, const l_rvector_slice &sl2)
01640 #if(CXSC_INDEX_CHECK)
01641         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01642 #else
01643         throw();
01644 #endif
01645 
01646         INLINE l_rvector & operator -=(l_rvector &rv1, const l_rvector &rv2)
01647 #if(CXSC_INDEX_CHECK)
01648         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01649 #else
01650         throw();
01651 #endif
01652 
01653         INLINE l_rvector &operator -=(l_rvector &rv, const l_rvector_slice &sl)
01654 #if(CXSC_INDEX_CHECK)
01655         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01656 #else
01657         throw();
01658 #endif
01659 
01661         INLINE bool operator ==(const l_rvector &rv1, const l_rvector &rv2) throw();
01663         INLINE bool operator ==(const l_rvector_slice &sl1, const l_rvector_slice &sl2) throw();
01665         INLINE bool operator ==(const l_rvector_slice &sl, const l_rvector &rv) throw();
01667         INLINE bool operator ==(const l_rvector &rv, const l_rvector_slice &sl) throw();
01669         INLINE bool operator !=(const l_rvector &rv1, const l_rvector &rv2) throw();
01671         INLINE bool operator !=(const l_rvector_slice &sl1, const l_rvector_slice &sl2) throw();
01673         INLINE bool operator !=(const l_rvector_slice &sl, const l_rvector &rv) throw();
01675         INLINE bool operator !=(const l_rvector &rv, const l_rvector_slice &sl) throw();
01677         INLINE bool operator <(const l_rvector &rv1, const l_rvector &rv2) throw();
01679         INLINE bool operator <(const l_rvector_slice &sl1, const l_rvector_slice &sl2) throw();
01681         INLINE bool operator < (const l_rvector_slice &sl, const l_rvector &rv) throw();
01683         INLINE bool operator < (const l_rvector &rv, const l_rvector_slice &sl) throw();
01685         INLINE bool operator <=(const l_rvector &rv1, const l_rvector &rv2) throw();
01687         INLINE bool operator <=(const l_rvector_slice &sl1, const l_rvector_slice &sl2) throw();
01689         INLINE bool operator <=(const l_rvector_slice &sl, const l_rvector &rv) throw();
01691         INLINE bool operator <=(const l_rvector &rv, const l_rvector_slice &sl) throw();
01693         INLINE bool operator >(const l_rvector &rv1, const l_rvector &rv2) throw();
01695         INLINE bool operator >(const l_rvector_slice &sl1, const l_rvector_slice &sl2) throw();
01697         INLINE bool operator >(const l_rvector_slice &sl, const l_rvector &rv) throw();
01699         INLINE bool operator >(const l_rvector &rv, const l_rvector_slice &sl) throw();
01701         INLINE bool operator >=(const l_rvector &rv1, const l_rvector &rv2) throw();
01703         INLINE bool operator >=(const l_rvector_slice &sl1, const l_rvector_slice &sl2) throw();
01705         INLINE bool operator >=(const l_rvector_slice &sl, const l_rvector &rv) throw();
01707         INLINE bool operator >=(const l_rvector &rv, const l_rvector_slice &sl) throw();
01708 
01709 //-------------------------------- l_real / Real --------------------------------
01710 
01711 
01713         INLINE void accumulate(dotprecision &dp, const l_rvector & rv1, const rvector &rv2)
01714 #if(CXSC_INDEX_CHECK)
01715         throw(OP_WITH_WRONG_DIM);
01716 #else
01717         throw();
01718 #endif
01719 
01720         INLINE void accumulate(dotprecision &dp, const rvector & rv1, const l_rvector &rv2)
01721 #if(CXSC_INDEX_CHECK)
01722         throw(OP_WITH_WRONG_DIM);
01723 #else
01724         throw();
01725 #endif
01726 
01727         INLINE void accumulate(dotprecision &dp, const rvector_slice & sl, const l_rvector &rv)
01728 #if(CXSC_INDEX_CHECK)
01729         throw(OP_WITH_WRONG_DIM);
01730 #else
01731         throw();
01732 #endif
01733 
01734         INLINE void accumulate(dotprecision &dp,const l_rvector_slice &sl,const rvector &rv)
01735 #if(CXSC_INDEX_CHECK)
01736         throw(OP_WITH_WRONG_DIM);
01737 #else
01738         throw();
01739 #endif
01740 
01741         INLINE void accumulate(dotprecision &dp, const rvector &rv, const l_rvector_slice &sl)
01742 #if(CXSC_INDEX_CHECK)
01743         throw(OP_WITH_WRONG_DIM);
01744 #else
01745         throw();
01746 #endif
01747 
01748         INLINE void accumulate(dotprecision &dp, const rvector & rv1, const l_rmatrix_subv &rv2)
01749 #if(CXSC_INDEX_CHECK)
01750         throw(OP_WITH_WRONG_DIM);
01751 #else
01752         throw();
01753 #endif
01754 
01755         INLINE void accumulate(dotprecision &dp, const l_rvector & rv1, const rmatrix_subv &rv2)
01756 #if(CXSC_INDEX_CHECK)
01757         throw(OP_WITH_WRONG_DIM);
01758 #else
01759         throw();
01760 #endif
01761 
01762         INLINE void accumulate(dotprecision &dp, const rvector_slice & rv1, const l_rmatrix_subv &rv2)
01763 #if(CXSC_INDEX_CHECK)
01764         throw(OP_WITH_WRONG_DIM);
01765 #else
01766         throw();
01767 #endif
01768 
01769         INLINE void accumulate(dotprecision &dp, const l_rvector_slice & rv1, const rmatrix_subv &rv2)
01770 #if(CXSC_INDEX_CHECK)
01771         throw(OP_WITH_WRONG_DIM);
01772 #else
01773         throw();
01774 #endif
01775 
01776         INLINE void accumulate(dotprecision &dp,const l_rvector &rv,const rvector_slice &sl)
01777 #if(CXSC_INDEX_CHECK)
01778         throw(OP_WITH_WRONG_DIM);
01779 #else
01780         throw();
01781 #endif
01782 
01783         INLINE void accumulate(dotprecision &dp, const rmatrix_subv & rv1, const l_rvector &rv2)
01784 #if(CXSC_INDEX_CHECK)
01785         throw(OP_WITH_WRONG_DIM);
01786 #else
01787         throw();
01788 #endif
01789 
01790         INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const rvector &rv2)
01791 #if(CXSC_INDEX_CHECK)
01792         throw(OP_WITH_WRONG_DIM);
01793 #else
01794         throw();
01795 #endif
01796 
01797         INLINE void accumulate(dotprecision &dp, const rmatrix_subv & rv1, const l_rvector_slice &rv2)
01798 #if(CXSC_INDEX_CHECK)
01799         throw(OP_WITH_WRONG_DIM);
01800 #else
01801         throw();
01802 #endif
01803 
01804         INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const rvector_slice &rv2)
01805 #if(CXSC_INDEX_CHECK)
01806         throw(OP_WITH_WRONG_DIM);
01807 #else
01808         throw();
01809 #endif
01810 
01811         INLINE void accumulate(dotprecision &dp, const l_rvector_slice & sl1, const rvector_slice &sl2)
01812 #if(CXSC_INDEX_CHECK)
01813         throw(OP_WITH_WRONG_DIM);
01814 #else
01815         throw();
01816 #endif
01817 
01818         INLINE void accumulate(dotprecision &dp, const rvector_slice & sl1, const l_rvector_slice &sl2)
01819 #if(CXSC_INDEX_CHECK)
01820         throw(OP_WITH_WRONG_DIM);
01821 #else
01822         throw();
01823 #endif
01824 
01825         INLINE void accumulate(dotprecision &dp, const rmatrix_subv & rv1, const l_rmatrix_subv &rv2)
01826 #if(CXSC_INDEX_CHECK)
01827         throw(OP_WITH_WRONG_DIM);
01828 #else
01829         throw();
01830 #endif
01831 
01832         INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const rmatrix_subv &rv2)
01833 #if(CXSC_INDEX_CHECK)
01834         throw(OP_WITH_WRONG_DIM);
01835 #else
01836         throw();
01837 #endif
01838 
01840         INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const rvector &rv2)
01841 #if(CXSC_INDEX_CHECK)
01842         throw(OP_WITH_WRONG_DIM);
01843 #else
01844         throw();
01845 #endif
01846 
01847         INLINE void accumulate(idotprecision &dp, const rvector & rv1, const l_rvector &rv2)
01848 #if(CXSC_INDEX_CHECK)
01849         throw(OP_WITH_WRONG_DIM);
01850 #else
01851         throw();
01852 #endif
01853 
01854         INLINE void accumulate(idotprecision &dp, const rvector_slice & sl, const l_rvector &rv)
01855 #if(CXSC_INDEX_CHECK)
01856         throw(OP_WITH_WRONG_DIM);
01857 #else
01858         throw();
01859 #endif
01860 
01861         INLINE void accumulate(idotprecision &dp,const l_rvector_slice &sl,const rvector &rv)
01862 #if(CXSC_INDEX_CHECK)
01863         throw(OP_WITH_WRONG_DIM);
01864 #else
01865         throw();
01866 #endif
01867 
01868         INLINE void accumulate(idotprecision &dp, const rvector &rv, const l_rvector_slice &sl)
01869 #if(CXSC_INDEX_CHECK)
01870         throw(OP_WITH_WRONG_DIM);
01871 #else
01872         throw();
01873 #endif
01874 
01875         INLINE void accumulate(idotprecision &dp, const rvector & rv1, const l_rmatrix_subv &rv2)
01876 #if(CXSC_INDEX_CHECK)
01877         throw(OP_WITH_WRONG_DIM);
01878 #else
01879         throw();
01880 #endif
01881 
01882         INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const rmatrix_subv &rv2)
01883 #if(CXSC_INDEX_CHECK)
01884         throw(OP_WITH_WRONG_DIM);
01885 #else
01886         throw();
01887 #endif
01888 
01889         INLINE void accumulate(idotprecision &dp, const rvector_slice & rv1, const l_rmatrix_subv &rv2)
01890 #if(CXSC_INDEX_CHECK)
01891         throw(OP_WITH_WRONG_DIM);
01892 #else
01893         throw();
01894 #endif
01895 
01896         INLINE void accumulate(idotprecision &dp, const l_rvector_slice & rv1, const rmatrix_subv &rv2)
01897 #if(CXSC_INDEX_CHECK)
01898         throw(OP_WITH_WRONG_DIM);
01899 #else
01900         throw();
01901 #endif
01902 
01903         INLINE void accumulate(idotprecision &dp,const l_rvector &rv,const rvector_slice &sl)
01904 #if(CXSC_INDEX_CHECK)
01905         throw(OP_WITH_WRONG_DIM);
01906 #else
01907         throw();
01908 #endif
01909 
01910         INLINE void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const l_rvector &rv2)
01911 #if(CXSC_INDEX_CHECK)
01912         throw(OP_WITH_WRONG_DIM);
01913 #else
01914         throw();
01915 #endif
01916 
01917         INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const rvector &rv2)
01918 #if(CXSC_INDEX_CHECK)
01919         throw(OP_WITH_WRONG_DIM);
01920 #else
01921         throw();
01922 #endif
01923 
01924         INLINE void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const l_rvector_slice &rv2)
01925 #if(CXSC_INDEX_CHECK)
01926         throw(OP_WITH_WRONG_DIM);
01927 #else
01928         throw();
01929 #endif
01930 
01931         INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const rvector_slice &rv2)
01932 #if(CXSC_INDEX_CHECK)
01933         throw(OP_WITH_WRONG_DIM);
01934 #else
01935         throw();
01936 #endif
01937 
01938         INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl1, const rvector_slice &sl2)
01939 #if(CXSC_INDEX_CHECK)
01940         throw(OP_WITH_WRONG_DIM);
01941 #else
01942         throw();
01943 #endif
01944 
01945         INLINE void accumulate(idotprecision &dp, const rvector_slice & sl1, const l_rvector_slice &sl2)
01946 #if(CXSC_INDEX_CHECK)
01947         throw(OP_WITH_WRONG_DIM);
01948 #else
01949         throw();
01950 #endif
01951 
01952         INLINE void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const l_rmatrix_subv &rv2)
01953 #if(CXSC_INDEX_CHECK)
01954         throw(OP_WITH_WRONG_DIM);
01955 #else
01956         throw();
01957 #endif
01958 
01959         INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const rmatrix_subv &rv2)
01960 #if(CXSC_INDEX_CHECK)
01961         throw(OP_WITH_WRONG_DIM);
01962 #else
01963         throw();
01964 #endif
01965 
01967         INLINE l_real operator *(const rvector & rv1, const l_rvector &rv2)
01968 #if(CXSC_INDEX_CHECK)
01969         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01970 #else
01971         throw();
01972 #endif
01973 
01974         INLINE l_real operator *(const rvector_slice &sl, const l_rvector &rv)
01975 #if(CXSC_INDEX_CHECK)
01976         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01977 #else
01978         throw();
01979 #endif
01980 
01981         INLINE l_real operator *(const rvector &rv, const l_rvector_slice &sl)
01982 #if(CXSC_INDEX_CHECK)
01983         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01984 #else
01985         throw();
01986 #endif
01987 
01988         INLINE l_real operator *(const rvector_slice & sl1, const l_rvector_slice &sl2)
01989 #if(CXSC_INDEX_CHECK)
01990         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01991 #else
01992         throw();
01993 #endif
01994         
01996         INLINE l_real operator *(const l_rvector & rv1, const rvector &rv2)
01997 #if(CXSC_INDEX_CHECK)
01998         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
01999 #else
02000         throw();
02001 #endif
02002 
02003         INLINE l_real operator *(const l_rvector_slice &sl, const rvector &rv)
02004 #if(CXSC_INDEX_CHECK)
02005         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
02006 #else
02007         throw();
02008 #endif
02009 
02010         INLINE l_real operator *(const l_rvector &rv, const rvector_slice &sl)
02011 #if(CXSC_INDEX_CHECK)
02012         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
02013 #else
02014         throw();
02015 #endif
02016 
02017         INLINE l_real operator *(const l_rvector_slice & sl1, const rvector_slice &sl2)
02018 #if(CXSC_INDEX_CHECK)
02019         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
02020 #else
02021         throw();
02022 #endif
02023         
02025         INLINE l_rvector operator +(const rvector &rv1, const l_rvector &rv2)
02026 #if(CXSC_INDEX_CHECK)
02027         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
02028 #else
02029         throw();
02030 #endif
02031 
02032         INLINE l_rvector operator +(const rvector &rv, const l_rvector_slice &sl)
02033 #if(CXSC_INDEX_CHECK)
02034         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
02035 #else
02036         throw();
02037 #endif
02038 
02039         INLINE l_rvector operator +(const rvector_slice &sl, const l_rvector &rv)
02040 #if(CXSC_INDEX_CHECK)
02041         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
02042 #else
02043         throw();
02044 #endif
02045 
02046         INLINE l_rvector operator +(const rvector_slice &sl1, const l_rvector_slice &sl2)
02047 #if(CXSC_INDEX_CHECK)
02048         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
02049 #else
02050         throw();
02051 #endif
02052 
02054         INLINE l_rvector operator +(const l_rvector &rv1, const rvector &rv2)
02055 #if(CXSC_INDEX_CHECK)
02056         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
02057 #else
02058         throw();
02059 #endif
02060 
02061         INLINE l_rvector operator +(const l_rvector &rv, const rvector_slice &sl)
02062 #if(CXSC_INDEX_CHECK)
02063         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
02064 #else
02065         throw();
02066 #endif
02067 
02068         INLINE l_rvector operator +(const l_rvector_slice &sl, const rvector &rv)
02069 #if(CXSC_INDEX_CHECK)
02070         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
02071 #else
02072         throw();
02073 #endif
02074 
02075         INLINE l_rvector operator +(const l_rvector_slice &sl1, const rvector_slice &sl2)
02076 #if(CXSC_INDEX_CHECK)
02077         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
02078 #else
02079         throw();
02080 #endif
02081 
02083         INLINE l_rvector & operator +=(l_rvector &rv1, const rvector &rv2)
02084 #if(CXSC_INDEX_CHECK)
02085         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
02086 #else
02087         throw();
02088 #endif
02089 
02090         INLINE l_rvector &operator +=(l_rvector &rv, const rvector_slice &sl)
02091 #if(CXSC_INDEX_CHECK)
02092         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
02093 #else
02094         throw();
02095 #endif
02096 
02098         INLINE l_rvector operator -(const rvector &rv1, const l_rvector &rv2)
02099 #if(CXSC_INDEX_CHECK)
02100         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
02101 #else
02102         throw();
02103 #endif
02104 
02105         INLINE l_rvector operator -(const rvector &rv, const l_rvector_slice &sl)
02106 #if(CXSC_INDEX_CHECK)
02107         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
02108 #else
02109         throw();
02110 #endif
02111 
02112         INLINE l_rvector operator -(const rvector_slice &sl, const l_rvector &rv)
02113 #if(CXSC_INDEX_CHECK)
02114         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
02115 #else
02116         throw();
02117 #endif
02118 
02119         INLINE l_rvector operator -(const rvector_slice &sl1, const l_rvector_slice &sl2)
02120 #if(CXSC_INDEX_CHECK)
02121         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
02122 #else
02123         throw();
02124 #endif
02125 
02127         INLINE l_rvector operator -(const l_rvector &rv1, const rvector &rv2)
02128 #if(CXSC_INDEX_CHECK)
02129         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
02130 #else
02131         throw();
02132 #endif
02133 
02134         INLINE l_rvector operator -(const l_rvector &rv, const rvector_slice &sl)
02135 #if(CXSC_INDEX_CHECK)
02136         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
02137 #else
02138         throw();
02139 #endif
02140 
02141         INLINE l_rvector operator -(const l_rvector_slice &sl, const rvector &rv)
02142 #if(CXSC_INDEX_CHECK)
02143         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
02144 #else
02145         throw();
02146 #endif
02147 
02148         INLINE l_rvector operator -(const l_rvector_slice &sl1, const rvector_slice &sl2)
02149 #if(CXSC_INDEX_CHECK)
02150         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
02151 #else
02152         throw();
02153 #endif
02154 
02155         INLINE l_rvector & operator -=(l_rvector &rv1, const rvector &rv2)
02156 #if(CXSC_INDEX_CHECK)
02157         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
02158 #else
02159         throw();
02160 #endif
02161 
02162         INLINE l_rvector &operator -=(l_rvector &rv, const rvector_slice &sl)
02163 #if(CXSC_INDEX_CHECK)
02164         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
02165 #else
02166         throw();
02167 #endif
02168 
02169 } // namespace cxsc 
02170 
02171 #ifdef _CXSC_INCL_INL
02172 #include "vector.inl"
02173 #include "l_rvector.inl"
02174 #endif
02175                 
02176 #ifdef _CXSC_RMATRIX_HPP_INCLUDED
02177 # ifdef _CXSC_INCL_INL
02178 #  include "lrvecrmat.inl"
02179 # else
02180 #  include "lrvecrmat.hpp"
02181 # endif
02182 #endif
02183 
02184 #ifdef _CXSC_IMATRIX_HPP_INCLUDED
02185 # ifdef _CXSC_INCL_INL
02186 #  include "cvecimat.inl"
02187 # else
02188 #  include "cvecimat.hpp"
02189 # endif
02190 #endif
02191 
02192 #ifdef _CXSC_IVECTOR_HPP_INCLUDED
02193 # ifdef _CXSC_INCL_INL
02194 #  include "lrvecivec.inl"
02195 # else
02196 #  include "lrvecivec.hpp"
02197 # endif
02198 #endif
02199 
02200 
02201 #endif
02202