C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
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: rvector.hpp,v 1.34 2014/01/30 17:23:48 cxsc Exp $ */
00025 
00026 #ifndef _CXSC_RVECTOR_HPP_INCLUDED
00027 #define _CXSC_RVECTOR_HPP_INCLUDED
00028 
00029 #include "xscclass.hpp"
00030 #include "dot.hpp"
00031 #include "idot.hpp"
00032 #include "cidot.hpp"
00033 #include "real.hpp"
00034 #include "except.hpp"
00035 #include "vector.hpp"
00036 
00037 #include <iostream>
00038 
00039 namespace cxsc {
00040 
00041 class srvector;
00042 class srvector_slice;
00043 class rvector_slice;
00044 
00046 
00057 class rvector
00058 {
00059         friend class cvector;
00060         friend class cvector_slice;
00061         friend class cmatrix;
00062         friend class rvector_slice;
00063         friend class rmatrix;
00064         friend class rmatrix_subv;
00065         friend class ivector;
00066         friend class imatrix;
00067         friend class l_ivector;
00068         friend class l_imatrix;
00069         friend class l_rvector;
00070         friend class l_rmatrix;
00071         friend class civector;
00072         friend class cimatrix;
00073 //#if(CXSC_INDEX_CHECK)
00074         //------------ Templates --------------------------------------------------
00075 
00076 #ifdef _CXSC_FRIEND_TPL
00077 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m)
00078 #if(CXSC_INDEX_CHECK)
00079         throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>);
00080 #else
00081         throw();
00082 #endif
00083 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
00084 #if(CXSC_INDEX_CHECK)
00085         throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
00086 #else
00087         throw();
00088 #endif
00089  template <class V> friend      void _vresize(V &rv) throw();
00090  template <class V,class S> friend      void _vresize(V &rv, const int &len)
00091 #if(CXSC_INDEX_CHECK)
00092                 throw(ERROR__WRONG_BOUNDARIES<V>);
00093 #else
00094         throw();
00095 #endif
00096  template <class V,class S> friend      void _vresize(V &rv, const int &lb, const int &ub)
00097 #if(CXSC_INDEX_CHECK)
00098                 throw(ERROR__WRONG_BOUNDARIES<V>);
00099 #else
00100         throw();
00101 #endif
00102  template <class V1,class V2,class S> friend     V1 &_vvassign(V1 &rv1,const V2 &rv2) throw();
00103  template <class V,class S> friend       V & _vsassign(V &rv,const S &r) throw();
00104  template <class V,class VS,class S> friend      V & _vvsassign(V &rv,const VS &sl) throw();
00105  template <class VS,class V> friend      VS & _vsvassign(VS &sl,const V &rv)
00106 #if(CXSC_INDEX_CHECK)
00107                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00108 #else
00109         throw();
00110 #endif
00111 template <class V,class M,class S> friend  V &_vmassign(V &v,const M &m)
00112 #if(CXSC_INDEX_CHECK)
00113         throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
00114 #else
00115         throw();
00116 #endif
00117 template <class M,class V,class S> friend  M &_mvassign(M &m,const V &v) throw();
00118 template <class MV,class V> friend  MV &_mvvassign(MV &v,const V &rv)
00119 #if(CXSC_INDEX_CHECK)
00120         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00121 #else
00122         throw();
00123 #endif
00124 template <class MV,class V> friend  V _mvabs(const MV &mv) throw();
00125 
00126         //-------- vector-vector -----------------
00127  template <class DP,class V1,class V2> friend   void _vvaccu(DP &dp, const V1 & rv1, const V2 &rv2)
00128 #if(CXSC_INDEX_CHECK)
00129                 throw(OP_WITH_WRONG_DIM);
00130 #else
00131         throw();
00132 #endif
00133  template <class DP,class VS,class V> friend    void _vsvaccu(DP &dp, const VS & sl, const V &rv)
00134 #if(CXSC_INDEX_CHECK)
00135                 throw(OP_WITH_WRONG_DIM);
00136 #else
00137         throw();
00138 #endif
00139 
00140 
00141  template <class V1,class V2,class E> friend     E _vvmult(const V1 & rv1, const V2 &rv2)
00142 #if(CXSC_INDEX_CHECK)
00143                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00144 #else
00145         throw();
00146 #endif
00147  template <class VS,class V,class E> friend      E _vsvmult(const VS & sl, const V &rv)
00148 #if(CXSC_INDEX_CHECK)
00149                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00150 #else
00151         throw();
00152 #endif
00153  template <class V,class S> friend       V &_vsmultassign(V &rv,const S &r) throw();
00154  template <class VS,class S> friend      VS &_vssmultassign(VS &rv,const S &r) throw();
00155  template <class VS,class S> friend      VS &_vssdivassign(VS &rv,const S &r) throw();
00156  template <class V1,class V2,class E> friend     E _vvplus(const V1 &rv1, const V2 &rv2)
00157 #if(CXSC_INDEX_CHECK)
00158                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00159 #else
00160         throw();
00161 #endif
00162  template <class V,class VS,class E> friend      E _vvsplus(const V &rv,const VS &sl)
00163 #if(CXSC_INDEX_CHECK)
00164                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00165 #else
00166         throw();
00167 #endif
00168  template <class VS1,class VS2,class E> friend   E _vsvsplus(const VS1 &s1,const VS2 &s2)
00169 #if(CXSC_INDEX_CHECK)
00170                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00171 #else
00172         throw();
00173 #endif
00174  template <class VS1,class VS2,class E> friend   E _vsvsminus(const VS1 &s1,const VS2 &s2)
00175 #if(CXSC_INDEX_CHECK)
00176                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00177 #else
00178         throw();
00179 #endif
00180  template <class V1,class V2> friend     V1 &_vvplusassign(V1 &rv1, const V2 &rv2)
00181 #if(CXSC_INDEX_CHECK)
00182                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00183 #else
00184         throw();
00185 #endif
00186  template <class V,class VS> friend      V &_vvsplusassign(V &rv, const VS &sl)
00187 #if(CXSC_INDEX_CHECK)
00188                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00189 #else
00190         throw();
00191 #endif
00192  template <class VS,class V> friend      VS &_vsvplusassign(VS &sl, const V &rv)
00193 #if(CXSC_INDEX_CHECK)
00194                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00195 #else
00196         throw();
00197 #endif
00198  template <class VS1,class VS2> friend   VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
00199 #if(CXSC_INDEX_CHECK)
00200                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00201 #else
00202         throw();
00203 #endif
00204  template <class VS1,class VS2> friend   VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
00205 #if(CXSC_INDEX_CHECK)
00206                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00207 #else
00208         throw();
00209 #endif
00210  template <class V1,class V2> friend     V1 &_vvminusassign(V1 &rv1, const V2 &rv2)
00211 #if(CXSC_INDEX_CHECK)
00212                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00213 #else
00214         throw();
00215 #endif
00216  template <class V,class VS> friend      V &_vvsminusassign(V &rv, const VS &sl)
00217 #if(CXSC_INDEX_CHECK)
00218                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00219 #else
00220         throw();
00221 #endif
00222  template <class VS,class V> friend      VS &_vsvminusassign(VS &sl, const V &rv)
00223 #if(CXSC_INDEX_CHECK)
00224                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00225 #else
00226         throw();
00227 #endif
00228  template <class V> friend       V _vminus(const V &rv) throw();
00229  template <class VS,class V> friend      V _vsminus(const VS &sl) throw();
00230  template <class V1,class V2,class E> friend     E _vvminus(const V1 &rv1, const V2 &rv2)
00231 #if(CXSC_INDEX_CHECK)
00232                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00233 #else
00234         throw();
00235 #endif
00236  template <class V,class VS,class E> friend      E _vvsminus(const V &rv, const VS &sl)
00237 #if(CXSC_INDEX_CHECK)
00238                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00239 #else
00240         throw();
00241 #endif
00242  template <class VS,class V,class E> friend      E _vsvminus(const VS &sl,const V &rv)
00243 #if(CXSC_INDEX_CHECK)
00244                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00245 #else
00246         throw();
00247 #endif
00248  template <class MV1,class MV2,class E> friend   E _mvmvconv(const MV1 &rv1, const MV2 &rv2)
00249 #if(CXSC_INDEX_CHECK)
00250                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00251 #else
00252         throw();
00253 #endif
00254  template <class MV,class V,class E> friend      E _mvvconv(const MV &rv1, const V &rv2)
00255 #if(CXSC_INDEX_CHECK)
00256                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00257 #else
00258         throw();
00259 #endif
00260 template <class V,class MV> friend  V &_vmvconvassign(V &rv,const MV &v)
00261 #if(CXSC_INDEX_CHECK)
00262         throw(ERROR__OP_WITH_WRONG_DIM<V>);
00263 #else
00264         throw();
00265 #endif
00266 
00267  template <class M,class V,class E> friend       E _mvmult(const M &m,const V &v)
00268 #if(CXSC_INDEX_CHECK)
00269                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00270 #else
00271         throw();
00272 #endif
00273  template <class M,class V,class E> friend       E _mvimult(const M &m,const V &v)
00274 #if(CXSC_INDEX_CHECK)
00275                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00276 #else
00277         throw();
00278 #endif
00279  template <class M,class V,class E> friend       E _mvcmult(const M &m,const V &v)
00280 #if(CXSC_INDEX_CHECK)
00281                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00282 #else
00283         throw();
00284 #endif
00285  template <class M,class V,class E> friend       E _mvcimult(const M &m,const V &v)
00286 #if(CXSC_INDEX_CHECK)
00287                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00288 #else
00289         throw();
00290 #endif
00291  template <class V,class M,class E> friend       E _vmmult(const V &v,const M &m)
00292 #if(CXSC_INDEX_CHECK)
00293                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00294 #else
00295         throw();
00296 #endif
00297  template <class V,class M,class E> friend       E _vmimult(const V &v,const M &m)
00298 #if(CXSC_INDEX_CHECK)
00299                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00300 #else
00301         throw();
00302 #endif
00303  template <class V,class M,class E> friend       E _vmcmult(const V &v,const M &m)
00304 #if(CXSC_INDEX_CHECK)
00305                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00306 #else
00307         throw();
00308 #endif
00309  template <class V,class M,class E> friend       E _vmcimult(const V &v,const M &m)
00310 #if(CXSC_INDEX_CHECK)
00311                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00312 #else
00313         throw();
00314 #endif
00315  template <class V,class M,class S> friend       V &_vmmultassign(V &v,const M &m)
00316 #if(CXSC_INDEX_CHECK)
00317                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00318 #else
00319         throw();
00320 #endif
00321  template <class V,class M,class S> friend       V &_vmimultassign(V &v,const M &m)
00322 #if(CXSC_INDEX_CHECK)
00323                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00324 #else
00325         throw();
00326 #endif
00327  template <class V,class M,class S> friend       V &_vmcmultassign(V &v,const M &m)
00328 #if(CXSC_INDEX_CHECK)
00329                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00330 #else
00331         throw();
00332 #endif
00333  template <class V,class M,class S> friend       V &_vmcimultassign(V &v,const M &m)
00334 #if(CXSC_INDEX_CHECK)
00335                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00336 #else
00337         throw();
00338 #endif
00339  template <class MS,class V,class E> friend      E _msvmult(const MS &ms,const V &v)
00340 #if(CXSC_INDEX_CHECK)
00341                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00342 #else
00343         throw();
00344 #endif
00345  template <class MS,class V,class E> friend      E _msvimult(const MS &ms,const V &v)
00346 #if(CXSC_INDEX_CHECK)
00347                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00348 #else
00349         throw();
00350 #endif
00351  template <class MS,class V,class E> friend      E _msvcmult(const MS &ms,const V &v)
00352 #if(CXSC_INDEX_CHECK)
00353                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00354 #else
00355         throw();
00356 #endif
00357  template <class MS,class V,class E> friend      E _msvcimult(const MS &ms,const V &v)
00358 #if(CXSC_INDEX_CHECK)
00359                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00360 #else
00361         throw();
00362 #endif
00363  template <class V,class MS,class E> friend      E _vmsmult(const V &v,const MS &ms)
00364 #if(CXSC_INDEX_CHECK)
00365                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00366 #else
00367         throw();
00368 #endif
00369  template <class V,class MS,class E> friend      E _vmsimult(const V &v,const MS &ms)
00370 #if(CXSC_INDEX_CHECK)
00371                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00372 #else
00373         throw();
00374 #endif
00375  template <class V,class MS,class E> friend      E _vmscmult(const V &v,const MS &ms)
00376 #if(CXSC_INDEX_CHECK)
00377                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00378 #else
00379         throw();
00380 #endif
00381  template <class V,class MS,class E> friend      E _vmscimult(const V &v,const MS &ms)
00382 #if(CXSC_INDEX_CHECK)
00383                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00384 #else
00385         throw();
00386 #endif
00387  template <class V,class MS,class S> friend      V &_vmsmultassign(V &v,const MS &ms)
00388 #if(CXSC_INDEX_CHECK)
00389                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00390 #else
00391         throw();
00392 #endif
00393  template <class V,class MS,class S> friend      V &_vmsimultassign(V &v,const MS &ms)
00394 #if(CXSC_INDEX_CHECK)
00395                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00396 #else
00397         throw();
00398 #endif
00399  template <class V,class MS,class S> friend      V &_vmscmultassign(V &v,const MS &ms)
00400 #if(CXSC_INDEX_CHECK)
00401                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00402 #else
00403         throw();
00404 #endif
00405  template <class V,class MS,class S> friend      V &_vmscimultassign(V &v,const MS &ms)
00406 #if(CXSC_INDEX_CHECK)
00407                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00408 #else
00409         throw();
00410 #endif
00411  template <class V,class MV,class S> friend      S _vmvmult(const V &rv1, const MV &rv2)
00412 #if(CXSC_INDEX_CHECK)
00413                 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00414 #else
00415         throw();
00416 #endif
00417  template <class V,class MV,class S> friend      S _vmvimult(const V &rv1, const MV &rv2)
00418 #if(CXSC_INDEX_CHECK)
00419                 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00420 #else
00421         throw();
00422 #endif
00423  template <class V,class MV,class S> friend      S _vmvcmult(const V &rv1, const MV &rv2)
00424 #if(CXSC_INDEX_CHECK)
00425                 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00426 #else
00427         throw();
00428 #endif
00429  template <class V,class MV,class S> friend      S _vmvcimult(const V &rv1, const MV &rv2)
00430 #if(CXSC_INDEX_CHECK)
00431                 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00432 #else
00433         throw();
00434 #endif
00435  template <class MV,class S,class E> friend      E _mvsmult(const MV &rv, const S &s) throw();
00436  template <class MV1,class MV2,class E> friend   E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
00437 #if(CXSC_INDEX_CHECK)
00438                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00439 #else
00440         throw();
00441 #endif
00442  template <class MV,class V,class E> friend      E _mvvplus(const MV &rv1, const V &rv2)
00443 #if(CXSC_INDEX_CHECK)
00444                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00445 #else
00446         throw();
00447 #endif
00448  template <class MV,class V,class E> friend      E _mvvminus(const MV &rv1, const V &rv2)
00449 #if(CXSC_INDEX_CHECK)
00450                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00451 #else
00452         throw();
00453 #endif
00454  template <class V,class MV,class E> friend      E _vmvminus(const V &rv1, const MV &rv2)
00455 #if(CXSC_INDEX_CHECK)
00456                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00457 #else
00458         throw();
00459 #endif
00460  template <class MV1,class MV2,class E> friend   E _mvmvminus(const MV1 &rv1, const MV2 &rv2)
00461 #if(CXSC_INDEX_CHECK)
00462                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00463 #else
00464         throw();
00465 #endif
00466 template <class MV,class V> friend  MV &_mvvplusassign(MV &v,const V &rv)
00467 #if(CXSC_INDEX_CHECK)
00468         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00469 #else
00470         throw();
00471 #endif
00472 template <class MV,class V> friend  MV &_mvvminusassign(MV &v,const V &rv)
00473 #if(CXSC_INDEX_CHECK)
00474         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00475 #else
00476         throw();
00477 #endif
00478 
00479  template <class V1,class V2,class E> friend     E _vvconv(const V1 &rv1, const V2 &rv2)
00480 #if(CXSC_INDEX_CHECK)
00481                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00482 #else
00483         throw();
00484 #endif
00485  template <class V,class VS,class E> friend      E _vvsconv(const V &rv,const VS &sl)
00486 #if(CXSC_INDEX_CHECK)
00487                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00488 #else
00489         throw();
00490 #endif
00491         
00492 template <class DP,class V,class SV> friend     void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
00493 #if(CXSC_INDEX_CHECK)
00494                 throw(OP_WITH_WRONG_DIM);
00495 #else
00496         throw();
00497 #endif
00498 
00499         //--------- vector-scalar ----------------
00500  template <class V,class S> friend       V &_vsdivassign(V &rv,const S &r) throw();
00501  template <class VS,class S,class E> friend      E _vssdiv(const VS &sl, const S &s) throw();
00502  template <class V,class S,class E> friend       E _vsmult(const V &rv, const S &s) throw();
00503  template <class VS,class S,class E> friend      E _vssmult(const VS &sl, const S &s) throw();
00504  template <class V1,class V2> friend     bool _vveq(const V1 &rv1, const V2 &rv2) throw();
00505  template <class VS,class V> friend      bool _vsveq(const VS &sl, const V &rv) throw();
00506  template <class V1,class V2> friend     bool _vvneq(const V1 &rv1, const V2 &rv2) throw();
00507  template <class VS,class V> friend      bool _vsvneq(const VS &sl, const V &rv) throw();
00508  template <class V1,class V2> friend     bool _vvless(const V1 &rv1, const V2 &rv2) throw();
00509  template <class VS,class V> friend      bool _vsvless(const VS &sl, const V &rv) throw();
00510  template <class V1,class V2> friend     bool _vvleq(const V1 &rv1, const V2 &rv2) throw();
00511  template <class VS,class V> friend      bool _vsvleq(const VS &sl, const V &rv) throw();
00512  template <class V,class VS> friend      bool _vvsless(const V &rv, const VS &sl) throw();
00513  template <class V,class VS> friend      bool _vvsleq(const V &rv, const VS &sl) throw();
00514  template <class V> friend       bool _vnot(const V &rv) throw();
00515  template <class V> friend      void *_vvoid(const V &rv) throw();
00516  template <class V,class E> friend       E _vabs(const V &rv) throw();
00517  template <class VS,class E> friend      E _vsabs(const VS &sl) throw();
00518  template <class VS1,class VS2> friend   bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw();
00519  template <class VS1,class VS2> friend   bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw();
00520  template <class VS1,class VS2> friend   bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw();
00521  template <class VS1,class VS2> friend   bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw();
00522  template <class VS> friend      bool _vsnot(const VS &sl) throw();
00523  template <class VS> friend     void *_vsvoid(const VS &sl) throw();
00524  template <class V> friend      std::ostream &_vout(std::ostream &s, const V &rv) throw();
00525  template <class V> friend      std::istream &_vin(std::istream &s, V &rv) throw();
00526 
00527 template <class V,class MV2,class S> friend  V &_vmvassign(V &v,const MV2 &rv) throw();
00528  template <class MV,class S,class E> friend      E _mvsdiv(const MV &rv, const S &s) throw();
00529         // Interval
00530 
00531 
00532 template <class MV,class V> friend  MV &_mvvconvassign(MV &v,const V &rv)
00533 #if(CXSC_INDEX_CHECK)
00534         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00535 #else
00536         throw();
00537 #endif
00538 template <class MV,class V> friend  MV &_mvvsectassign(MV &v,const V &rv)
00539 #if(CXSC_INDEX_CHECK)
00540         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00541 #else
00542         throw();
00543 #endif
00544 
00545         //--- Interval ---- vector-vector ----------
00546  template <class V1,class V2> friend     V1 &_vvsetinf(V1 &rv1, const V2 &rv2)
00547 #if(CXSC_INDEX_CHECK)
00548                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00549 #else
00550         throw();
00551 #endif
00552  template <class V1,class V2> friend     V1 &_vvusetinf(V1 &rv1, const V2 &rv2)
00553 #if(CXSC_INDEX_CHECK)
00554                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00555 #else
00556         throw();
00557 #endif
00558  template <class V1,class V2> friend     V1 &_vvsetsup(V1 &rv1, const V2 &rv2)
00559 #if(CXSC_INDEX_CHECK)
00560                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00561 #else
00562         throw();
00563 #endif
00564  template <class V1,class V2> friend     V1 &_vvusetsup(V1 &rv1, const V2 &rv2)
00565 #if(CXSC_INDEX_CHECK)
00566                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00567 #else
00568         throw();
00569 #endif
00570  template <class VS,class V> friend      VS &_vsvsetinf(VS &sl, const V &rv)
00571 #if(CXSC_INDEX_CHECK)
00572                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00573 #else
00574         throw();
00575 #endif
00576  template <class VS,class V> friend      VS &_vsvusetinf(VS &sl, const V &rv)
00577 #if(CXSC_INDEX_CHECK)
00578                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00579 #else
00580         throw();
00581 #endif
00582  template <class VS,class V> friend      VS &_vsvsetsup(VS &sl, const V &rv)
00583 #if(CXSC_INDEX_CHECK)
00584                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00585 #else
00586         throw();
00587 #endif
00588  template <class VS,class V> friend      VS &_vsvusetsup(VS &sl, const V &rv)
00589 #if(CXSC_INDEX_CHECK)
00590                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00591 #else
00592         throw();
00593 #endif
00594 template <class MV,class V> friend  MV &_mvvsetinf(MV &v,const V &rv)
00595 #if(CXSC_INDEX_CHECK)
00596         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00597 #else
00598         throw();
00599 #endif
00600 template <class MV,class V> friend  MV &_mvvusetinf(MV &v,const V &rv)
00601 #if(CXSC_INDEX_CHECK)
00602         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00603 #else
00604         throw();
00605 #endif
00606 template <class MV,class V> friend  MV &_mvvsetsup(MV &v,const V &rv)
00607 #if(CXSC_INDEX_CHECK)
00608         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00609 #else
00610         throw();
00611 #endif
00612 template <class MV,class V> friend  MV &_mvvusetsup(MV &v,const V &rv)
00613 #if(CXSC_INDEX_CHECK)
00614         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00615 #else
00616         throw();
00617 #endif
00618  template <class V,class E> friend       E _vdiam(const V &rv) throw();
00619  template <class V,class E> friend       E _vmid(const V &rv) throw();
00620  template <class V,class E> friend       E _vinf(const V &rv) throw();
00621  template <class V,class E> friend       E _vsup(const V &rv) throw();
00622  template <class VS,class E> friend      E _vsdiam(const VS &sl) throw();
00623  template <class VS,class E> friend      E _vsmid(const VS &sl) throw();
00624  template <class VS,class E> friend      E _vsinf(const VS &sl) throw();
00625  template <class VS,class E> friend      E _vssup(const VS &sl) throw();
00626 template <class MV,class V> friend  V _mvdiam(const MV &mv) throw();
00627 template <class MV,class V> friend  V _mvmid(const MV &mv) throw();
00628 template <class MV,class V> friend  V _mvinf(const MV &mv) throw();
00629 template <class MV,class V> friend  V _mvsup(const MV &mv) throw();
00630 
00631 
00632  template <class V1,class V2,class E> friend     E _vvimult(const V1 & rv1, const V2 &rv2)
00633 #if(CXSC_INDEX_CHECK)
00634                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00635 #else
00636         throw();
00637 #endif
00638  template <class VS,class V,class E> friend      E _vsvimult(const VS & sl, const V &rv)
00639 #if(CXSC_INDEX_CHECK)
00640                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00641 #else
00642         throw();
00643 #endif
00644 
00645  template <class V1,class V2> friend     V1 &_vvconvassign(V1 &rv1, const V2 &rv2)
00646 #if(CXSC_INDEX_CHECK)
00647                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00648 #else
00649         throw();
00650 #endif
00651  template <class V1,class V2,class E> friend     E _vvsect(const V1 &rv1, const V2 &rv2)
00652 #if(CXSC_INDEX_CHECK)
00653                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00654 #else
00655         throw();
00656 #endif
00657  template <class V,class VS,class E> friend      E _vvssect(const V &rv,const VS &sl)
00658 #if(CXSC_INDEX_CHECK)
00659                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00660 #else
00661         throw();
00662 #endif
00663  template <class V1,class V2> friend     V1 &_vvsectassign(V1 &rv1, const V2 &rv2)
00664 #if(CXSC_INDEX_CHECK)
00665                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00666 #else
00667         throw();
00668 #endif
00669 
00670  template <class VS1,class VS2,class E> friend   E _vsvsconv(const VS1 &s1,const VS2 &s2)
00671 #if(CXSC_INDEX_CHECK)
00672                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00673 #else
00674         throw();
00675 #endif
00676  
00677  template <class V,class VS> friend      V &_vvsconvassign(V &rv, const VS &sl)
00678 #if(CXSC_INDEX_CHECK)
00679                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00680 #else
00681         throw();
00682 #endif
00683  template <class VS,class V> friend      VS &_vsvconvassign(VS &sl, const V &rv)
00684 #if(CXSC_INDEX_CHECK)
00685                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00686 #else
00687         throw();
00688 #endif
00689  template <class VS1,class VS2> friend   VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2)
00690 #if(CXSC_INDEX_CHECK)
00691                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00692 #else
00693         throw();
00694 #endif
00695 
00696  template <class VS,class V> friend      VS &_vsvsectassign(VS &sl, const V &rv)
00697 #if(CXSC_INDEX_CHECK)
00698                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00699 #else
00700         throw();
00701 #endif
00702         //--- Interval ---- vector-scalar ----------
00703         
00704  template <class V,class S,class E> friend       E _vsdiv(const V &rv, const S &s) throw();
00705 
00706         
00707         // complex
00708 
00709  template <class V,class E> friend       E _vim(const V &rv) throw();
00710  template <class V,class E> friend       E _vre(const V &rv) throw();
00711 template <class MV,class V> friend  V _mvim(const MV &mv) throw();
00712 template <class MV,class V> friend  V _mvre(const MV &mv) throw();
00713 template <class MV,class V> friend  MV &_mvvsetim(MV &v,const V &rv)
00714 #if(CXSC_INDEX_CHECK)
00715         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00716 #else
00717         throw();
00718 #endif
00719 template <class MV,class V> friend  MV &_mvvsetre(MV &v,const V &rv)
00720 #if(CXSC_INDEX_CHECK)
00721         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00722 #else
00723         throw();
00724 #endif
00725  template <class V1,class V2> friend     V1 &_vvsetim(V1 &rv1, const V2 &rv2)
00726 #if(CXSC_INDEX_CHECK)
00727                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00728 #else
00729         throw();
00730 #endif
00731  template <class V1,class V2> friend     V1 &_vvsetre(V1 &rv1, const V2 &rv2)
00732 #if(CXSC_INDEX_CHECK)
00733                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00734 #else
00735         throw();
00736 #endif
00737  template <class VS,class E> friend      E _vsim(const VS &sl) throw();
00738  template <class VS,class E> friend      E _vsre(const VS &sl) throw();
00739  template <class VS,class V> friend      VS &_vsvsetim(VS &sl, const V &rv)
00740 #if(CXSC_INDEX_CHECK)
00741                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00742 #else
00743         throw();
00744 #endif
00745  template <class VS,class V> friend      VS &_vsvsetre(VS &sl, const V &rv)
00746 #if(CXSC_INDEX_CHECK)
00747                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00748 #else
00749         throw();
00750 #endif
00751         
00752         //--- complex ---- vector-vector ----------
00753  template <class V1,class V2,class E> friend     E _vvcmult(const V1 & rv1, const V2 &rv2)
00754 #if(CXSC_INDEX_CHECK)
00755                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00756 #else
00757         throw();
00758 #endif
00759  template <class VS,class V,class E> friend      E _vsvcmult(const VS & sl, const V &rv)
00760 #if(CXSC_INDEX_CHECK)
00761                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00762 #else
00763         throw();
00764 #endif
00765 
00766                              // 5.10. S.W.
00767 
00768         //--- complex ---- vector-scalar ----------
00769         
00770         
00771         // cinterval ------------------------------
00773         friend INLINE rvector SupRe(const civector &v) throw();
00775         friend INLINE rvector SupIm(const civector &v) throw();
00777         friend INLINE rvector InfRe(const civector &v) throw();
00779         friend INLINE rvector InfIm(const civector &v) throw();
00781         friend INLINE rvector SupRe(const civector_slice &v) throw();
00783         friend INLINE rvector SupIm(const civector_slice &v) throw();
00785         friend INLINE rvector InfRe(const civector_slice &v) throw();
00787         friend INLINE rvector InfIm(const civector_slice &v) throw();
00788 
00789         // vector-vector                      // 5.10. S.W.
00790 
00791  template <class V1,class V2,class E> friend     E _vvcimult(const V1 & rv1, const V2 &rv2)
00792 #if(CXSC_INDEX_CHECK)
00793                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00794 #else
00795         throw();
00796 #endif
00797  template <class VS,class V,class E> friend      E _vsvcimult(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 
00804  template <class VS1,class VS2,class E> friend   E _vsvscimult(const VS1 & sl1, const VS2 &sl2)
00805 #if(CXSC_INDEX_CHECK)
00806                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00807 #else
00808         throw();
00809 #endif
00810                                                     // 5.10. S.W.
00811 
00812         // vector-matrix
00813 
00814         //--- l_real ---- vector-matrix ----------
00815  template <class V,class MS,class E> friend      E _vmslmult(const V &v,const MS &ms)
00816 #if(CXSC_INDEX_CHECK)
00817                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00818 #else
00819         throw();
00820 #endif
00821  template <class M,class V,class E> friend       E _mvlmult(const M &m,const V &v)
00822 #if(CXSC_INDEX_CHECK)
00823                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00824 #else
00825         throw();
00826 #endif
00827  template <class MS,class V,class E> friend      E _msvlmult(const MS &ms,const V &v)
00828 #if(CXSC_INDEX_CHECK)
00829                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00830 #else
00831         throw();
00832 #endif
00833         
00834  template <class V,class M,class E> friend       E _vmlmult(const V &v,const M &m)
00835 #if(CXSC_INDEX_CHECK)
00836                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00837 #else
00838         throw();
00839 #endif
00840         
00841         //--- l_real ---- vector-vector ----------
00842  template <class V1,class V2,class E> friend     E _vvlmult(const V1 & rv1, const V2 &rv2)
00843 #if(CXSC_INDEX_CHECK)
00844                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00845 #else
00846         throw();
00847 #endif
00848  template <class VS,class V,class E> friend      E _vsvlmult(const VS & sl, const V &rv)
00849 #if(CXSC_INDEX_CHECK)
00850                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00851 #else
00852         throw();
00853 #endif
00854 
00855         // vector-vector
00856 
00857  template <class V1,class V2,class E> friend     E _vvlimult(const V1 & rv1, const V2 &rv2)
00858 #if(CXSC_INDEX_CHECK)
00859                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00860 #else
00861         throw();
00862 #endif
00863  template <class VS,class V,class E> friend      E _vsvlimult(const VS & sl, const V &rv)
00864 #if(CXSC_INDEX_CHECK)
00865                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00866 #else
00867         throw();
00868 #endif
00869 
00870  template <class VS1,class VS2,class E> friend   E _vsvslimult(const VS1 & sl1, const VS2 &sl2)
00871 #if(CXSC_INDEX_CHECK)
00872                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00873 #else
00874         throw();
00875 #endif
00876 
00877         // vector-matrix
00878  template <class M,class V,class E> friend       E _mvlimult(const M &m,const V &v)
00879 #if(CXSC_INDEX_CHECK)
00880                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00881 #else
00882         throw();
00883 #endif
00884  template <class MS,class V,class E> friend      E _msvlimult(const MS &ms,const V &v)
00885 #if(CXSC_INDEX_CHECK)
00886                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00887 #else
00888         throw();
00889 #endif
00890  template <class V,class M,class E> friend       E _vmlimult(const V &v,const M &m)
00891 #if(CXSC_INDEX_CHECK)
00892                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00893 #else
00894         throw();
00895 #endif
00896  template <class V,class MS,class E> friend      E _vmslimult(const V &v,const MS &ms)
00897 #if(CXSC_INDEX_CHECK)
00898                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00899 #else
00900         throw();
00901 #endif
00902 #endif
00903         
00904         private:
00905         real *dat;
00906         int l,u,size;
00907 
00908         public:
00909         double* to_blas_array() const { return (double*)dat; }
00910         //------ Konstruktoren ----------------------------------------------------
00912         INLINE rvector () throw();
00914         explicit INLINE rvector(const int &i) throw();
00915 #ifdef OLD_CXSC
00916 
00917         explicit INLINE rvector(const class index &i) throw(); // for backwards compatibility
00918 #endif
00919 
00920         explicit INLINE rvector(const int &i1,const int &i2)
00921 #if(CXSC_INDEX_CHECK)
00922         throw(ERROR_RVECTOR_WRONG_BOUNDARIES,ERROR_RVECTOR_NO_MORE_MEMORY);
00923 #else
00924         throw();
00925 #endif
00926 
00927         INLINE rvector(const rmatrix_subv &) throw();
00929         explicit INLINE rvector(const real &) throw();
00931         explicit INLINE rvector(const rmatrix &)
00932 #if(CXSC_INDEX_CHECK)
00933         throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
00934 #else
00935         throw();
00936 #endif
00937 
00938         explicit INLINE rvector(const rmatrix_slice &sl)
00939 #if(CXSC_INDEX_CHECK)
00940         throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
00941 #else
00942         throw();
00943 #endif
00944 
00946         INLINE rvector(const intvector&);
00947 
00949         INLINE rvector(const rvector_slice &rs) throw();
00951         INLINE rvector(const rvector &v) throw();
00953         INLINE rvector(const srvector &v);
00955         INLINE rvector(const srvector_slice &v);
00957         INLINE rvector &operator =(const rvector &rv) throw();
00959         INLINE rvector &operator =(const rvector_slice &sl) throw();
00961         INLINE rvector &operator =(const srvector &rv);
00963         INLINE rvector &operator =(const srvector_slice &sl);
00965         INLINE rvector &operator =(const real &r) throw();
00967         INLINE rvector &operator =(const rmatrix &)
00968 #if(CXSC_INDEX_CHECK)
00969         throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
00970 #else
00971         throw();
00972 #endif
00973 
00974         INLINE rvector &operator =(const rmatrix_slice &)
00975 #if(CXSC_INDEX_CHECK)
00976         throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
00977 #else
00978         throw();
00979 #endif
00980 
00981         INLINE rvector &operator =(const rmatrix_subv &) throw();
00982 
00984         INLINE rvector operator()(const intvector& p);
00986         INLINE rvector operator()(const intmatrix& P);
00987 
00988 
00989         //--------- Destruktor ----------------------------------------------------
00990         INLINE ~rvector() { delete [] dat; }
00991 
00992         //------ Standardfunktionen -----------------------------------------------
00993         
00994         friend INLINE real::real(const rvector &)
00995 #if(CXSC_INDEX_CHECK)
00996         throw(ERROR_RVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_RVECTOR_USE_OF_UNINITIALIZED_OBJ);
00997 #else
00998         throw();
00999 #endif
01000 
01001         friend INLINE int Lb(const rvector &rv) throw() { return rv.l; }
01003         friend INLINE int Ub(const rvector &rv) throw() { return rv.u; }
01005         friend INLINE int VecLen(const rvector &rv) throw() { return rv.size; }
01007         friend INLINE rvector &SetLb(rvector &rv, const int &l) throw() { rv.l=l; rv.u=l+rv.size-1; return rv; }
01009         friend INLINE rvector &SetUb(rvector &rv, const int &u) throw() { rv.u=u; rv.l=u-rv.size+1; return rv; }
01011         INLINE real & operator [](const int &i) const
01012 #if(CXSC_INDEX_CHECK)
01013         throw(ERROR_RVECTOR_ELEMENT_NOT_IN_VEC);
01014 #else
01015         throw();
01016 #endif
01017         
01019         INLINE real & operator [](const int &i)
01020 #if(CXSC_INDEX_CHECK)
01021         throw(ERROR_RVECTOR_ELEMENT_NOT_IN_VEC);
01022 #else
01023         throw();
01024 #endif
01025 
01027         INLINE rvector & operator ()() throw() { return *this; }
01029         INLINE rvector_slice operator ()(const int &i)
01030 #if(CXSC_INDEX_CHECK)
01031         throw(ERROR_RVECTOR_SUB_ARRAY_TOO_BIG);
01032 #else
01033         throw();
01034 #endif
01035 
01036         INLINE rvector_slice operator ()(const int &i1,const int &i2)
01037 #if(CXSC_INDEX_CHECK)
01038         throw(ERROR_RVECTOR_SUB_ARRAY_TOO_BIG);
01039 #else
01040         throw();
01041 #endif
01042 
01044         INLINE rvector &operator +=(const srvector &rv);
01046         INLINE rvector &operator +=(const srvector_slice &rv);
01048         INLINE rvector &operator -=(const srvector &rv);
01050         INLINE rvector &operator -=(const srvector_slice &rv);
01051         
01052         INLINE operator void*() throw();
01053 //#else
01054 //#endif
01055 };
01056 
01058 
01063 class rvector_slice
01064 {
01065         friend class rvector;
01066         friend class rmatrix;
01067         friend class ivector;
01068         friend class imatrix;
01069         friend class cvector;
01070         friend class cmatrix;
01071         friend class civector;
01072         friend class cimatrix;
01073         friend class l_rvector;
01074         friend class l_rmatrix;
01075         friend class l_ivector;
01076         friend class l_imatrix;
01077         private:
01078         real *dat;
01079         int l,u,size;
01080         int start,end;
01081 
01082         public:
01083 //#if(CXSC_INDEX_CHECK) 
01084 
01085 #ifdef _CXSC_FRIEND_TPL
01086 //------------------------- Templates -------------------------------------------
01087  template <class VS1,class VS2> friend   VS1 & _vsvsassign(VS1 &sl1,const VS2 &sl2)
01088 #if(CXSC_INDEX_CHECK)
01089                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01090 #else
01091         throw();
01092 #endif
01093  template <class V,class VS,class S> friend      V & _vvsassign(V &rv,const VS &sl) throw();
01094  template <class VS,class V> friend      VS & _vsvassign(VS &sl,const V &rv)
01095 #if(CXSC_INDEX_CHECK)
01096                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01097 #else
01098         throw();
01099 #endif
01100  template <class VS,class S> friend      VS & _vssassign(VS &sl,const S &r) throw();
01101  template <class VS,class M,class S> friend      VS &_vsmmultassign(VS &v,const M &m)
01102 #if(CXSC_INDEX_CHECK)
01103                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01104 #else
01105         throw();
01106 #endif
01107         //-------- vector-scalar ------------------
01108  template <class VS,class S> friend      VS &_vssmultassign(VS &rv,const S &r) throw();
01109  template <class VS,class S> friend      VS &_vssdivassign(VS &rv,const S &r) throw();
01110         
01111  template <class VS,class V> friend      bool _vsveq(const VS &sl, const V &rv) throw();
01112  template <class VS,class V> friend      bool _vsvneq(const VS &sl, const V &rv) throw();
01113  template <class VS,class V> friend      bool _vsvless(const VS &sl, const V &rv) throw();
01114  template <class VS,class V> friend      bool _vsvleq(const VS &sl, const V &rv) throw();
01115  template <class V,class VS> friend      bool _vvsless(const V &rv, const VS &sl) throw();
01116  template <class V,class VS> friend      bool _vvsleq(const V &rv, const VS &sl) throw();
01117  template <class VS,class E> friend      E _vsabs(const VS &sl) throw();
01118  template <class VS1,class VS2> friend   bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw();
01119  template <class VS1,class VS2> friend   bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw();
01120  template <class VS1,class VS2> friend   bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw();
01121  template <class VS1,class VS2> friend   bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw();
01122  template <class VS> friend      bool _vsnot(const VS &sl) throw();
01123  template <class VS> friend     void *_vsvoid(const VS &sl) throw();
01124  template <class V> friend      std::ostream &_vsout(std::ostream &s, const V &rv) throw();
01125  template <class V> friend      std::istream &_vsin(std::istream &s, V &rv) throw();
01126         //------- vector-vector -----------------
01127  template <class DP,class VS,class V> friend    void _vsvaccu(DP &dp, const VS & sl, const V &rv)
01128 #if(CXSC_INDEX_CHECK)
01129                 throw(OP_WITH_WRONG_DIM);
01130 #else
01131         throw();
01132 #endif
01133  template <class DP,class VS1,class VS2> friend         void _vsvsaccu(DP &dp, const VS1 & sl1, const VS2 &sl2)
01134 #if(CXSC_INDEX_CHECK)
01135                 throw(OP_WITH_WRONG_DIM);
01136 #else
01137         throw();
01138 #endif
01139 
01140  template <class VS,class S,class E> friend      E _vssdiv(const VS &sl, const S &s) throw();
01141  template <class VS,class S,class E> friend      E _vssmult(const VS &sl, const S &s) throw();
01142  template <class VS,class V,class E> friend      E _vsvmult(const VS & sl, const V &rv)
01143 #if(CXSC_INDEX_CHECK)
01144                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01145 #else
01146         throw();
01147 #endif
01148  template <class V,class VS,class E> friend      E _vvsplus(const V &rv,const VS &sl)
01149 #if(CXSC_INDEX_CHECK)
01150                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01151 #else
01152         throw();
01153 #endif
01154  template <class VS1,class VS2,class E> friend   E _vsvsplus(const VS1 &s1,const VS2 &s2)
01155 #if(CXSC_INDEX_CHECK)
01156                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01157 #else
01158         throw();
01159 #endif
01160  template <class VS1,class VS2,class E> friend   E _vsvsminus(const VS1 &s1,const VS2 &s2)
01161 #if(CXSC_INDEX_CHECK)
01162                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01163 #else
01164         throw();
01165 #endif
01166  template <class V,class VS> friend      V &_vvsplusassign(V &rv, const VS &sl)
01167 #if(CXSC_INDEX_CHECK)
01168                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01169 #else
01170         throw();
01171 #endif
01172  template <class VS,class V> friend      VS &_vsvplusassign(VS &sl, const V &rv)
01173 #if(CXSC_INDEX_CHECK)
01174                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01175 #else
01176         throw();
01177 #endif
01178  template <class VS1,class VS2> friend   VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
01179 #if(CXSC_INDEX_CHECK)
01180                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01181 #else
01182         throw();
01183 #endif
01184  template <class VS1,class VS2> friend   VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
01185 #if(CXSC_INDEX_CHECK)
01186                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01187 #else
01188         throw();
01189 #endif
01190  template <class V,class VS> friend      V &_vvsminusassign(V &rv, const VS &sl)
01191 #if(CXSC_INDEX_CHECK)
01192                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01193 #else
01194         throw();
01195 #endif
01196  template <class VS,class V> friend      VS &_vsvminusassign(VS &sl, const V &rv)
01197 #if(CXSC_INDEX_CHECK)
01198                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01199 #else
01200         throw();
01201 #endif
01202  template <class VS,class V> friend      V _vsminus(const VS &sl) throw();
01203  template <class V,class VS,class E> friend      E _vvsminus(const V &rv, const VS &sl)
01204 #if(CXSC_INDEX_CHECK)
01205                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01206 #else
01207         throw();
01208 #endif
01209  template <class VS,class V,class E> friend      E _vsvminus(const VS &sl,const V &rv)
01210 #if(CXSC_INDEX_CHECK)
01211                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01212 #else
01213         throw();
01214 #endif
01215  template <class VS1,class VS2,class E> friend   E _vsvsmult(const VS1 & sl1, const VS2 &sl2)
01216 #if(CXSC_INDEX_CHECK)
01217                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01218 #else
01219         throw();
01220 #endif
01221 
01222  template <class V,class VS,class E> friend      E _vvsconv(const V &rv,const VS &sl)
01223 #if(CXSC_INDEX_CHECK)
01224                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01225 #else
01226         throw();
01227 #endif
01228  template <class VS1,class VS2,class E> friend   E _vsvsconv(const VS1 &s1,const VS2 &s2)
01229 #if(CXSC_INDEX_CHECK)
01230                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01231 #else
01232         throw();
01233 #endif
01234  template <class V,class VS,class E> friend      E _vvssect(const V &rv,const VS &sl)
01235 #if(CXSC_INDEX_CHECK)
01236                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01237 #else
01238         throw();
01239 #endif
01240  template <class VS1,class VS2,class E> friend   E _vsvssect(const VS1 &s1,const VS2 &s2)
01241 #if(CXSC_INDEX_CHECK)
01242                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01243 #else
01244         throw();
01245 #endif
01246         // interval -----------
01247  template <class V,class VS> friend      V &_vvssetinf(V &rv, const VS &sl)
01248 #if(CXSC_INDEX_CHECK)
01249                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01250 #else
01251         throw();
01252 #endif
01253  template <class V,class VS> friend      V &_vvsusetinf(V &rv, const VS &sl)
01254 #if(CXSC_INDEX_CHECK)
01255                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01256 #else
01257         throw();
01258 #endif
01259  template <class V,class VS> friend      V &_vvssetsup(V &rv, const VS &sl)
01260 #if(CXSC_INDEX_CHECK)
01261                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01262 #else
01263         throw();
01264 #endif
01265  template <class V,class VS> friend      V &_vvsusetsup(V &rv, const VS &sl)
01266 #if(CXSC_INDEX_CHECK)
01267                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01268 #else
01269         throw();
01270 #endif
01271  template <class VS1,class VS2> friend   VS1 &_vsvssetinf(VS1 &sl1, const VS2 &sl2)
01272 #if(CXSC_INDEX_CHECK)
01273                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01274 #else
01275         throw();
01276 #endif
01277  template <class VS1,class VS2> friend   VS1 &_vsvsusetinf(VS1 &sl1, const VS2 &sl2)
01278 #if(CXSC_INDEX_CHECK)
01279                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01280 #else
01281         throw();
01282 #endif
01283  template <class VS1,class VS2> friend   VS1 &_vsvssetsup(VS1 &sl1, const VS2 &sl2)
01284 #if(CXSC_INDEX_CHECK)
01285                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01286 #else
01287         throw();
01288 #endif
01289  template <class VS1,class VS2> friend   VS1 &_vsvsusetsup(VS1 &sl1, const VS2 &sl2)
01290 #if(CXSC_INDEX_CHECK)
01291                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01292 #else
01293         throw();
01294 #endif
01295         // interval  -----------------
01296 
01297 
01298  template <class V,class VS> friend      V &_vvsconvassign(V &rv, const VS &sl)
01299 #if(CXSC_INDEX_CHECK)
01300                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01301 #else
01302         throw();
01303 #endif
01304  template <class VS,class V> friend      VS &_vsvconvassign(VS &sl, const V &rv)
01305 #if(CXSC_INDEX_CHECK)
01306                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01307 #else
01308         throw();
01309 #endif
01310  template <class VS1,class VS2> friend   VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2)
01311 #if(CXSC_INDEX_CHECK)
01312                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01313 #else
01314         throw();
01315 #endif
01316 
01317  template <class V,class VS> friend      V &_vvssectassign(V &rv, const VS &sl)
01318 #if(CXSC_INDEX_CHECK)
01319                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01320 #else
01321         throw();
01322 #endif
01323  template <class VS,class V> friend      VS &_vsvsectassign(VS &sl, const V &rv)
01324 #if(CXSC_INDEX_CHECK)
01325                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01326 #else
01327         throw();
01328 #endif
01329  template <class VS1,class VS2> friend   VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2)
01330 #if(CXSC_INDEX_CHECK)
01331                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01332 #else
01333         throw();
01334 #endif
01335         // Interval
01336  
01337         //-- Interval ------- vector-vector ------------
01338 
01339  template <class VS,class V,class E> friend      E _vsvimult(const VS & sl, const V &rv)
01340 #if(CXSC_INDEX_CHECK)
01341                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01342 #else
01343         throw();
01344 #endif
01345  template <class VS1,class VS2,class E> friend   E _vsvsimult(const VS1 & sl1, const VS2 &sl2)
01346 #if(CXSC_INDEX_CHECK)
01347                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01348 #else
01349         throw();
01350 #endif
01351 
01352  template <class VS1,class VS2> friend   VS1 &_vsvssetim(VS1 &sl1, const VS2 &sl2)
01353 #if(CXSC_INDEX_CHECK)
01354                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01355 #else
01356         throw();
01357 #endif
01358  template <class VS1,class VS2> friend   VS1 &_vsvssetre(VS1 &sl1, const VS2 &sl2)
01359 #if(CXSC_INDEX_CHECK)
01360                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01361 #else
01362         throw();
01363 #endif
01364  template <class V,class VS> friend      V &_vvssetim(V &rv, const VS &sl)
01365 #if(CXSC_INDEX_CHECK)
01366                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01367 #else
01368         throw();
01369 #endif
01370  template <class V,class VS> friend      V &_vvssetre(V &rv, const VS &sl)
01371 #if(CXSC_INDEX_CHECK)
01372                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01373 #else
01374         throw();
01375 #endif
01376  
01377         //-- complex ------- vector-vector ------------
01378 
01379  template <class VS,class V,class E> friend      E _vsvcmult(const VS & sl, const V &rv)
01380 #if(CXSC_INDEX_CHECK)
01381                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01382 #else
01383         throw();
01384 #endif
01385  template <class VS1,class VS2,class E> friend   E _vsvscmult(const VS1 & sl1, const VS2 &sl2)
01386 #if(CXSC_INDEX_CHECK)
01387                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01388 #else
01389         throw();
01390 #endif
01391 
01392  template <class VS,class V,class E> friend      E _vsvcimult(const VS & sl, const V &rv)
01393 #if(CXSC_INDEX_CHECK)
01394                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01395 #else
01396         throw();
01397 #endif
01398  template <class VS1,class VS2,class E> friend   E _vsvscimult(const VS1 & sl1, const VS2 &sl2)
01399 #if(CXSC_INDEX_CHECK)
01400                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01401 #else
01402         throw();
01403 #endif
01404 
01405  template <class VS,class V,class E> friend      E _vsvlmult(const VS & sl, const V &rv)
01406 #if(CXSC_INDEX_CHECK)
01407                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01408 #else
01409         throw();
01410 #endif
01411  template <class VS1,class VS2,class E> friend   E _vsvslmult(const VS1 & sl1, const VS2 &sl2)
01412 #if(CXSC_INDEX_CHECK)
01413                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01414 #else
01415         throw();
01416 #endif
01417 
01418  template <class VS,class V,class E> friend      E _vsvlimult(const VS & sl, const V &rv)
01419 #if(CXSC_INDEX_CHECK)
01420                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01421 #else
01422         throw();
01423 #endif
01424  template <class VS1,class VS2,class E> friend   E _vsvslimult(const VS1 & sl1, const VS2 &sl2)
01425 #if(CXSC_INDEX_CHECK)
01426                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01427 #else
01428         throw();
01429 #endif
01430 
01431         // l_interval -- vector-matrix
01432 
01433         
01434 #endif
01435         
01436         
01437         //--------------------- Konstruktoren -----------------------------------
01439         explicit INLINE rvector_slice(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) { }
01441         explicit INLINE rvector_slice(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) { }
01442         public: 
01444         INLINE rvector_slice(const rvector_slice &a) throw():dat(a.dat),l(a.l),u(a.u),size(a.size),start(a.start),end(a.end) { }
01445         public:
01447         INLINE rvector_slice & operator =(const rvector_slice &sl)
01448 #if(CXSC_INDEX_CHECK)
01449         throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
01450 #else
01451         throw();
01452 #endif
01453 
01454         INLINE rvector_slice & operator =(const rvector &rv)
01455 #if(CXSC_INDEX_CHECK)
01456         throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
01457 #else
01458         throw();
01459 #endif
01460 
01461         INLINE rvector_slice & operator =(const srvector &rv);
01463         INLINE rvector_slice & operator =(const srvector_slice &rv);
01465         INLINE rvector_slice & operator =(const real &r) throw();
01467         INLINE rvector_slice & operator =(const rmatrix &m)
01468 #if(CXSC_INDEX_CHECK)
01469         throw(ERROR__OP_WITH_WRONG_DIM<rvector>,ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
01470 #else
01471         throw();
01472 #endif
01473 
01474         INLINE rvector_slice & operator =(const rmatrix_slice &m)
01475 #if(CXSC_INDEX_CHECK)
01476         throw(ERROR__OP_WITH_WRONG_DIM<rvector>,ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
01477 #else
01478         throw();
01479 #endif
01480 
01481         INLINE rvector_slice &operator =(const rmatrix_subv &) throw();
01482 
01483         //--------------------- Standardfunktionen ------------------------------
01484 
01485         friend INLINE real::real(const rvector_slice &sl)
01486 #if(CXSC_INDEX_CHECK)
01487         throw(ERROR_RVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_RVECTOR_USE_OF_UNINITIALIZED_OBJ);
01488 #else
01489         throw();
01490 #endif
01491 
01492         friend INLINE int Lb(const rvector_slice &sl) throw() { return sl.start; }
01494         friend INLINE int Ub(const rvector_slice &sl) throw() { return sl.end; }
01496         friend INLINE int VecLen(const rvector_slice &sl) throw() { return sl.end-sl.start+1; }
01498         INLINE real & operator [](const int &i)
01499 #if(CXSC_INDEX_CHECK)
01500         throw(ERROR_RVECTOR_ELEMENT_NOT_IN_VEC);
01501 #else
01502         throw();
01503 #endif
01504         
01506         INLINE real & operator [](const int &i) const
01507 #if(CXSC_INDEX_CHECK)
01508         throw(ERROR_RVECTOR_ELEMENT_NOT_IN_VEC);
01509 #else
01510         throw();
01511 #endif
01512 
01514         INLINE rvector_slice & operator ()() throw() { return *this; }
01516         INLINE rvector_slice operator ()(const int &i)
01517 #if(CXSC_INDEX_CHECK)
01518         throw(ERROR_RVECTOR_SUB_ARRAY_TOO_BIG);
01519 #else
01520         throw();
01521 #endif
01522 
01523         INLINE rvector_slice operator ()(const int &i1,const int &i2)
01524 #if(CXSC_INDEX_CHECK)
01525         throw(ERROR_RVECTOR_SUB_ARRAY_TOO_BIG);
01526 #else
01527         throw();
01528 #endif
01529 
01530         INLINE rvector_slice &operator /=(const real &r) throw();
01532         INLINE rvector_slice &operator *=(const real &r) throw();
01534         INLINE rvector_slice &operator *=(const rmatrix &m)
01535 #if(CXSC_INDEX_CHECK)
01536         throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
01537 #else
01538         throw();
01539 #endif
01540 
01541         INLINE rvector_slice &operator +=(const rvector &rv)
01542 #if(CXSC_INDEX_CHECK)
01543         throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
01544 #else
01545         throw();
01546 #endif
01547 
01548         INLINE rvector_slice &operator +=(const rvector_slice &sl2)
01549 #if(CXSC_INDEX_CHECK)
01550         throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
01551 #else
01552         throw();
01553 #endif
01554 
01555         INLINE rvector_slice &operator -=(const rvector &rv)
01556 #if(CXSC_INDEX_CHECK)
01557         throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
01558 #else
01559         throw();
01560 #endif
01561 
01562         INLINE rvector_slice &operator -=(const rvector_slice &sl2)
01563 #if(CXSC_INDEX_CHECK)
01564         throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
01565 #else
01566         throw();
01567 #endif
01568 
01570         INLINE rvector_slice &operator +=(const srvector &rv);
01572         INLINE rvector_slice &operator +=(const srvector_slice &rv);
01574         INLINE rvector_slice &operator -=(const srvector &rv);
01576         INLINE rvector_slice &operator -=(const srvector_slice &rv);
01577 
01578 
01579         INLINE operator void*() throw();
01580 //#else
01581 //#endif
01582 };
01583 
01584 //======================== Vector Functions =============================
01585 
01587         INLINE rvector _rvector(const real &r) throw(); 
01588 //      INLINE rvector _rvector(const rmatrix &m) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
01589 //      INLINE rvector _rvector(const rmatrix_slice &sl) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
01590 
01592         INLINE void Resize(rvector &rv) throw();
01594         INLINE void Resize(rvector &rv, const int &len)
01595 #if(CXSC_INDEX_CHECK)
01596         throw(ERROR__WRONG_BOUNDARIES<rvector>);
01597 #else
01598         throw();
01599 #endif
01600 
01601         INLINE void Resize(rvector &rv, const int &lb, const int &ub)
01602 #if(CXSC_INDEX_CHECK)
01603         throw(ERROR__WRONG_BOUNDARIES<rvector>);
01604 #else
01605         throw();
01606 #endif
01607         
01609         INLINE rvector abs(const rvector &rv) throw();
01611         INLINE rvector abs(const rvector_slice &sl) throw();
01613         INLINE bool operator !(const rvector &rv) throw();
01615         INLINE bool operator !(const rvector_slice &sl) throw();
01616 
01617 //======================= Vector / Scalar ===============================
01618 
01620         INLINE rvector operator *(const rvector &rv, const real &s) throw();
01622         INLINE rvector operator *(const rvector_slice &sl, const real &s) throw();
01624         INLINE rvector operator *(const real &s, const rvector &rv) throw();
01626         INLINE rvector operator *(const real &s, const rvector_slice &sl) throw();
01628         INLINE rvector &operator *=(rvector &rv,const real &r) throw();
01629 
01631         INLINE rvector operator /(const rvector &rv, const real &s) throw();
01633         INLINE rvector operator /(const rvector_slice &sl, const real &s) throw();
01635         INLINE rvector &operator /=(rvector &rv,const real &r) throw();
01636 
01637 //======================= Vector / Vector ===============================
01638 
01640         void accumulate(dotprecision &dp, const rvector &);
01641 
01643         void accumulate(dotprecision &dp, const rvector & rv1, const rvector &rv2)
01644 #if(CXSC_INDEX_CHECK)
01645         throw(OP_WITH_WRONG_DIM);
01646 #else
01647         throw();
01648 #endif
01649 
01651         void accumulate_approx(dotprecision &dp, const rvector & rv1, const rvector &rv2);
01652 
01653 
01655         void accumulate(dotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2)
01656 #if(CXSC_INDEX_CHECK)
01657         throw(OP_WITH_WRONG_DIM);
01658 #else
01659         throw();
01660 #endif
01661 
01663         void accumulate_approx(dotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2);
01664 
01665 
01667         void accumulate(dotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2)
01668 #if(CXSC_INDEX_CHECK)
01669         throw(OP_WITH_WRONG_DIM);
01670 #else
01671         throw();
01672 #endif
01673 
01675         void accumulate_approx(dotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2);
01676 
01678         void accumulate(dotprecision &dp,const rvector_slice &sl,const rvector &rv)
01679 #if(CXSC_INDEX_CHECK)
01680         throw(OP_WITH_WRONG_DIM);
01681 #else
01682         throw();
01683 #endif
01684 
01686         void accumulate_approx(dotprecision &dp,const rvector_slice &sl,const rvector &rv);
01687 
01688 
01690         void accumulate(dotprecision &dp,const rvector &rv,const rvector_slice &sl)
01691 #if(CXSC_INDEX_CHECK)
01692         throw(OP_WITH_WRONG_DIM);
01693 #else
01694         throw();
01695 #endif
01696 
01698         void accumulate_approx(dotprecision &dp,const rvector &rv,const rvector_slice &sl);
01699 
01700 
01702         void accumulate(dotprecision &dp, const rvector_slice & sl1, const rvector_slice &sl2)
01703 #if(CXSC_INDEX_CHECK)
01704         throw(OP_WITH_WRONG_DIM);
01705 #else
01706         throw();
01707 #endif
01708 
01710         void accumulate_approx(dotprecision &dp, const rvector_slice & sl1, const rvector_slice &sl2);
01711 
01712 
01714         void accumulate(idotprecision &dp, const rvector & rv1, const rvector &rv2)
01715 #if(CXSC_INDEX_CHECK)
01716         throw(OP_WITH_WRONG_DIM);
01717 #else
01718         throw();
01719 #endif
01720 
01721         void accumulate(idotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2)
01722 #if(CXSC_INDEX_CHECK)
01723         throw(OP_WITH_WRONG_DIM);
01724 #else
01725         throw();
01726 #endif
01727 
01728         void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2)
01729 #if(CXSC_INDEX_CHECK)
01730         throw(OP_WITH_WRONG_DIM);
01731 #else
01732         throw();
01733 #endif
01734 
01735         void accumulate(idotprecision &dp,const rvector_slice &sl,const rvector &rv)
01736 #if(CXSC_INDEX_CHECK)
01737         throw(OP_WITH_WRONG_DIM);
01738 #else
01739         throw();
01740 #endif
01741 
01742         void accumulate(idotprecision &dp,const rvector &rv,const rvector_slice &sl)
01743 #if(CXSC_INDEX_CHECK)
01744         throw(OP_WITH_WRONG_DIM);
01745 #else
01746         throw();
01747 #endif
01748 
01749         void accumulate(idotprecision &dp, const rvector_slice & sl1, const rvector_slice &sl2)
01750 #if(CXSC_INDEX_CHECK)
01751         throw(OP_WITH_WRONG_DIM);
01752 #else
01753         throw();
01754 #endif
01755 
01757         void accumulate(cdotprecision &dp, const rvector & rv1, const rvector &rv2)
01758 #if(CXSC_INDEX_CHECK)
01759         throw(OP_WITH_WRONG_DIM);
01760 #else
01761         throw();
01762 #endif
01763 
01765         void accumulate_approx(cdotprecision &dp, const rvector & rv1, const rvector &rv2);
01766 
01768         void accumulate(cdotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2)
01769 #if(CXSC_INDEX_CHECK)
01770         throw(OP_WITH_WRONG_DIM);
01771 #else
01772         throw();
01773 #endif
01774 
01776         void accumulate_approx(cdotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2);
01777 
01779         void accumulate(cdotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2)
01780 #if(CXSC_INDEX_CHECK)
01781         throw(OP_WITH_WRONG_DIM);
01782 #else
01783         throw();
01784 #endif
01785 
01787         void accumulate_approx(cdotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2);
01788 
01790         void accumulate(cdotprecision &dp,const rvector_slice &sl,const rvector &rv)
01791 #if(CXSC_INDEX_CHECK)
01792         throw(OP_WITH_WRONG_DIM);
01793 #else
01794         throw();
01795 #endif
01796 
01798         void accumulate_approx(cdotprecision &dp,const rvector_slice &sl,const rvector &rv);
01799 
01801         void accumulate(cdotprecision &dp,const rvector &rv,const rvector_slice &sl)
01802 #if(CXSC_INDEX_CHECK)
01803         throw(OP_WITH_WRONG_DIM);
01804 #else
01805         throw();
01806 #endif
01807 
01809         void accumulate_approx(cdotprecision &dp,const rvector &rv,const rvector_slice &sl);
01810 
01812         void accumulate(cdotprecision &dp, const rvector_slice & sl1, const rvector_slice &sl2)
01813 #if(CXSC_INDEX_CHECK)
01814         throw(OP_WITH_WRONG_DIM);
01815 #else
01816         throw();
01817 #endif
01818 
01820         void accumulate_approx(cdotprecision &dp, const rvector_slice & sl1, const rvector_slice &sl2);
01821 
01823         void accumulate(cidotprecision &dp, const rvector & rv1, const rvector &rv2)
01824 #if(CXSC_INDEX_CHECK)
01825         throw(OP_WITH_WRONG_DIM);
01826 #else
01827         throw();
01828 #endif
01829 
01830         void accumulate(cidotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2)
01831 #if(CXSC_INDEX_CHECK)
01832         throw(OP_WITH_WRONG_DIM);
01833 #else
01834         throw();
01835 #endif
01836 
01837         void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2)
01838 #if(CXSC_INDEX_CHECK)
01839         throw(OP_WITH_WRONG_DIM);
01840 #else
01841         throw();
01842 #endif
01843 
01844         void accumulate(cidotprecision &dp,const rvector_slice &sl,const rvector &rv)
01845 #if(CXSC_INDEX_CHECK)
01846         throw(OP_WITH_WRONG_DIM);
01847 #else
01848         throw();
01849 #endif
01850 
01851         void accumulate(cidotprecision &dp,const rvector &rv,const rvector_slice &sl)
01852 #if(CXSC_INDEX_CHECK)
01853         throw(OP_WITH_WRONG_DIM);
01854 #else
01855         throw();
01856 #endif
01857 
01858         void accumulate(cidotprecision &dp, const rvector_slice & sl1, const rvector_slice &sl2)
01859 #if(CXSC_INDEX_CHECK)
01860         throw(OP_WITH_WRONG_DIM);
01861 #else
01862         throw();
01863 #endif
01864         
01866         INLINE real operator *(const rvector & rv1, const rvector &rv2)
01867 #if(CXSC_INDEX_CHECK)
01868         throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
01869 #else
01870         throw();
01871 #endif
01872 
01873         INLINE real operator *(const rvector_slice &sl, const rvector &rv)
01874 #if(CXSC_INDEX_CHECK)
01875         throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
01876 #else
01877         throw();
01878 #endif
01879 
01880         INLINE real operator *(const rvector &rv, const rvector_slice &sl)
01881 #if(CXSC_INDEX_CHECK)
01882         throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
01883 #else
01884         throw();
01885 #endif
01886 
01887         INLINE real operator *(const rvector_slice & sl1, const rvector_slice &sl2)
01888 #if(CXSC_INDEX_CHECK)
01889         throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
01890 #else
01891         throw();
01892 #endif
01893         
01895         INLINE const rvector &operator +(const rvector &rv) throw();
01897         INLINE rvector operator +(const rvector_slice &sl) throw();
01899         INLINE rvector operator +(const rvector &rv1, const rvector &rv2)
01900 #if(CXSC_INDEX_CHECK)
01901         throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
01902 #else
01903         throw();
01904 #endif
01905 
01906         INLINE rvector operator +(const rvector &rv, const rvector_slice &sl)
01907 #if(CXSC_INDEX_CHECK)
01908         throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
01909 #else
01910         throw();
01911 #endif
01912 
01913         INLINE rvector operator +(const rvector_slice &sl, const rvector &rv)
01914 #if(CXSC_INDEX_CHECK)
01915         throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
01916 #else
01917         throw();
01918 #endif
01919 
01920         INLINE rvector operator +(const rvector_slice &sl1, const rvector_slice &sl2)
01921 #if(CXSC_INDEX_CHECK)
01922         throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
01923 #else
01924         throw();
01925 #endif
01926 
01927         INLINE rvector & operator +=(rvector &rv1, const rvector &rv2)
01928 #if(CXSC_INDEX_CHECK)
01929         throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
01930 #else
01931         throw();
01932 #endif
01933 
01934         INLINE rvector &operator +=(rvector &rv, const rvector_slice &sl)
01935 #if(CXSC_INDEX_CHECK)
01936         throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
01937 #else
01938         throw();
01939 #endif
01940 
01942         INLINE rvector operator -(const rvector &rv) throw();
01944         INLINE rvector operator -(const rvector_slice &sl) throw();
01946         INLINE rvector operator -(const rvector &rv1, const rvector &rv2)
01947 #if(CXSC_INDEX_CHECK)
01948         throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
01949 #else
01950         throw();
01951 #endif
01952 
01953         INLINE rvector operator -(const rvector &rv, const rvector_slice &sl)
01954 #if(CXSC_INDEX_CHECK)
01955         throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
01956 #else
01957         throw();
01958 #endif
01959 
01960         INLINE rvector operator -(const rvector_slice &sl, const rvector &rv)
01961 #if(CXSC_INDEX_CHECK)
01962         throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
01963 #else
01964         throw();
01965 #endif
01966 
01967         INLINE rvector operator -(const rvector_slice &sl1, const rvector_slice &sl2)
01968 #if(CXSC_INDEX_CHECK)
01969         throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
01970 #else
01971         throw();
01972 #endif
01973 
01974         INLINE rvector & operator -=(rvector &rv1, const rvector &rv2)
01975 #if(CXSC_INDEX_CHECK)
01976         throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
01977 #else
01978         throw();
01979 #endif
01980 
01981         INLINE rvector &operator -=(rvector &rv, const rvector_slice &sl)
01982 #if(CXSC_INDEX_CHECK)
01983         throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
01984 #else
01985         throw();
01986 #endif
01987 
01989         INLINE bool operator ==(const rvector &rv1, const rvector &rv2) throw();
01991         INLINE bool operator ==(const rvector_slice &sl1, const rvector_slice &sl2) throw();
01993         INLINE bool operator ==(const rvector_slice &sl, const rvector &rv) throw();
01995         INLINE bool operator ==(const rvector &rv, const rvector_slice &sl) throw();
01997         INLINE bool operator !=(const rvector &rv1, const rvector &rv2) throw();
01999         INLINE bool operator !=(const rvector_slice &sl1, const rvector_slice &sl2) throw();
02001         INLINE bool operator !=(const rvector_slice &sl, const rvector &rv) throw();
02003         INLINE bool operator !=(const rvector &rv, const rvector_slice &sl) throw();
02005         INLINE bool operator <(const rvector &rv1, const rvector &rv2) throw();
02007         INLINE bool operator <(const rvector_slice &sl1, const rvector_slice &sl2) throw();
02009         INLINE bool operator < (const rvector_slice &sl, const rvector &rv) throw();
02011         INLINE bool operator < (const rvector &rv, const rvector_slice &sl) throw();
02013         INLINE bool operator <=(const rvector &rv1, const rvector &rv2) throw();
02015         INLINE bool operator <=(const rvector_slice &sl1, const rvector_slice &sl2) throw();
02017         INLINE bool operator <=(const rvector_slice &sl, const rvector &rv) throw();
02019         INLINE bool operator <=(const rvector &rv, const rvector_slice &sl) throw();
02021         INLINE bool operator >(const rvector &rv1, const rvector &rv2) throw();
02023         INLINE bool operator >(const rvector_slice &sl1, const rvector_slice &sl2) throw();
02025         INLINE bool operator >(const rvector_slice &sl, const rvector &rv) throw();
02027         INLINE bool operator >(const rvector &rv, const rvector_slice &sl) throw();
02029         INLINE bool operator >=(const rvector &rv1, const rvector &rv2) throw();
02031         INLINE bool operator >=(const rvector_slice &sl1, const rvector_slice &sl2) throw();
02033         INLINE bool operator >=(const rvector_slice &sl, const rvector &rv) throw();
02035         INLINE bool operator >=(const rvector &rv, const rvector_slice &sl) throw();
02036 
02038         INLINE std::ostream &operator <<(std::ostream &s, const rvector &rv) throw();
02040         INLINE std::ostream &operator <<(std::ostream &o, const rvector_slice &sl) throw();
02042         INLINE std::istream &operator >>(std::istream &s, rvector &rv) throw();
02044         INLINE std::istream &operator >>(std::istream &s, rvector_slice &rv) throw();
02045 
02046 
02047 } // namespace cxsc 
02048         
02049 #ifdef _CXSC_INCL_INL
02050 #include "rvector.inl"
02051 #include "vector.inl"
02052 #endif
02053 
02054 #ifdef CXSC_USE_BLAS
02055 #define _CXSC_BLAS_RVECTOR
02056 #include "cxsc_blas.inl"
02057 #endif
02058 
02059 #endif