C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
cvector.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: cvector.hpp,v 1.31 2014/01/30 17:23:44 cxsc Exp $ */
00025 
00026 #ifndef _CXSC_CVECTOR_HPP_INCLUDED
00027 #define _CXSC_CVECTOR_HPP_INCLUDED
00028 
00029 #include "xscclass.hpp"
00030 #include "except.hpp"
00031 #include "cdot.hpp"
00032 #include "cidot.hpp"
00033 #include "complex.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 cvector_slice;
00046 class scvector;
00047 class scvector_slice;
00048 class srvector;
00049 class srvector_slice;
00050 
00052 
00057 class cvector
00058 {
00059         friend class cvector_slice;
00060         friend class cmatrix;
00061         friend class cmatrix_subv;
00062         friend class civector;
00063         friend class cimatrix;
00064         private:
00065         complex *dat;
00066         int l,u,size;
00067 
00068         public:
00069         double* to_blas_array() const { return (double*)dat; }
00070 //#if(CXSC_INDEX_CHECK)
00071 #ifdef _CXSC_FRIEND_TPL
00072         //------------ Templates --------------------------------------------------
00073         // complex
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  template <class V,class E> friend       E _vim(const V &rv) throw();
00121  template <class V,class E> friend       E _vre(const V &rv) throw();
00122  template <class V1,class V2> friend     V1 &_vvsetim(V1 &rv1, const V2 &rv2)
00123 #if(CXSC_INDEX_CHECK)
00124                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00125 #else
00126         throw();
00127 #endif
00128  template <class V1,class V2> friend     V1 &_vvsetre(V1 &rv1, const V2 &rv2)
00129 #if(CXSC_INDEX_CHECK)
00130                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00131 #else
00132         throw();
00133 #endif
00134  template <class V,class VS> friend      V &_vvssetim(V &rv, const VS &sl)
00135 #if(CXSC_INDEX_CHECK)
00136                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00137 #else
00138         throw();
00139 #endif
00140  template <class V,class VS> friend      V &_vvssetre(V &rv, const VS &sl)
00141 #if(CXSC_INDEX_CHECK)
00142                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00143 #else
00144         throw();
00145 #endif
00146 template <class V,class MV> friend  V &_vmvsetim(V &rv,const MV &v)
00147 #if(CXSC_INDEX_CHECK)
00148         throw(ERROR__OP_WITH_WRONG_DIM<V>);
00149 #else
00150         throw();
00151 #endif
00152 template <class V,class MV> friend  V &_vmvsetre(V &rv,const MV &v)
00153 #if(CXSC_INDEX_CHECK)
00154         throw(ERROR__OP_WITH_WRONG_DIM<V>);
00155 #else
00156         throw();
00157 #endif
00158  template <class V,class S> friend       V &_vssetre(V &v, const S &s) throw();
00159  template <class V,class S> friend       V &_vssetim(V &v, const S &s) throw();
00160 
00161 //-------- vector-vector -----------------------
00162  template <class DP,class V1,class V2> friend   void _vvaccu(DP &dp, const V1 & rv1, const V2 &rv2)
00163 #if(CXSC_INDEX_CHECK)
00164                 throw(OP_WITH_WRONG_DIM);
00165 #else
00166         throw();
00167 #endif
00168  template <class DP,class VS,class V> friend    void _vsvaccu(DP &dp, const VS & sl, const V &rv)
00169 #if(CXSC_INDEX_CHECK)
00170                 throw(OP_WITH_WRONG_DIM);
00171 #else
00172         throw();
00173 #endif
00174  template <class V1,class V2,class E> friend     E _vvcmult(const V1 & rv1, const V2 &rv2)
00175 #if(CXSC_INDEX_CHECK)
00176                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00177 #else
00178         throw();
00179 #endif
00180  template <class VS,class V,class E> friend      E _vsvcmult(const VS & sl, const V &rv)
00181 #if(CXSC_INDEX_CHECK)
00182                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00183 #else
00184         throw();
00185 #endif
00186  template <class V,class S> friend       V &_vsmultassign(V &rv,const S &r) throw();
00187  template <class V1,class V2,class E> friend     E _vvplus(const V1 &rv1, const V2 &rv2)
00188 #if(CXSC_INDEX_CHECK)
00189                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00190 #else
00191         throw();
00192 #endif
00193  template <class V,class VS,class E> friend      E _vvsplus(const V &rv,const VS &sl)
00194 #if(CXSC_INDEX_CHECK)
00195                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00196 #else
00197         throw();
00198 #endif
00199  template <class VS1,class VS2,class E> friend   E _vsvsplus(const VS1 &s1,const VS2 &s2)
00200 #if(CXSC_INDEX_CHECK)
00201                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00202 #else
00203         throw();
00204 #endif
00205  template <class VS1,class VS2,class E> friend   E _vsvsminus(const VS1 &s1,const VS2 &s2)
00206 #if(CXSC_INDEX_CHECK)
00207                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00208 #else
00209         throw();
00210 #endif
00211  template <class V1,class V2> friend     V1 &_vvplusassign(V1 &rv1, const V2 &rv2)
00212 #if(CXSC_INDEX_CHECK)
00213                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00214 #else
00215         throw();
00216 #endif
00217  template <class V,class VS> friend      V &_vvsplusassign(V &rv, const VS &sl)
00218 #if(CXSC_INDEX_CHECK)
00219                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00220 #else
00221         throw();
00222 #endif
00223  template <class VS,class V> friend      VS &_vsvplusassign(VS &sl, const V &rv)
00224 #if(CXSC_INDEX_CHECK)
00225                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00226 #else
00227         throw();
00228 #endif
00229  template <class VS1,class VS2> friend   VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
00230 #if(CXSC_INDEX_CHECK)
00231                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00232 #else
00233         throw();
00234 #endif
00235  template <class VS1,class VS2> friend   VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
00236 #if(CXSC_INDEX_CHECK)
00237                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00238 #else
00239         throw();
00240 #endif
00241  template <class V1,class V2> friend     V1 &_vvminusassign(V1 &rv1, const V2 &rv2)
00242 #if(CXSC_INDEX_CHECK)
00243                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00244 #else
00245         throw();
00246 #endif
00247  template <class V,class VS> friend      V &_vvsminusassign(V &rv, const VS &sl)
00248 #if(CXSC_INDEX_CHECK)
00249                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00250 #else
00251         throw();
00252 #endif
00253  template <class VS,class V> friend      VS &_vsvminusassign(VS &sl, const V &rv)
00254 #if(CXSC_INDEX_CHECK)
00255                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00256 #else
00257         throw();
00258 #endif
00259  template <class V> friend       V _vminus(const V &rv) throw();
00260  template <class VS,class V> friend      V _vsminus(const VS &sl) throw();
00261  template <class V1,class V2,class E> friend     E _vvminus(const V1 &rv1, const V2 &rv2)
00262 #if(CXSC_INDEX_CHECK)
00263                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00264 #else
00265         throw();
00266 #endif
00267  template <class V,class VS,class E> friend      E _vvsminus(const V &rv, const VS &sl)
00268 #if(CXSC_INDEX_CHECK)
00269                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00270 #else
00271         throw();
00272 #endif
00273  template <class VS,class V,class E> friend      E _vsvminus(const VS &sl,const V &rv)
00274 #if(CXSC_INDEX_CHECK)
00275                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00276 #else
00277         throw();
00278 #endif
00279  template <class V,class MV,class S> friend      S _vmvcmult(const V &rv1, const MV &rv2)
00280 #if(CXSC_INDEX_CHECK)
00281                 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00282 #else
00283         throw();
00284 #endif
00285  template <class V,class MV,class S> friend      S _vmvcimult(const V &rv1, const MV &rv2)
00286 #if(CXSC_INDEX_CHECK)
00287                 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00288 #else
00289         throw();
00290 #endif
00291  template <class V1,class V2,class E> friend     E _vvconv(const V1 &rv1, const V2 &rv2)
00292 #if(CXSC_INDEX_CHECK)
00293                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00294 #else
00295         throw();
00296 #endif
00297  template <class V,class VS,class E> friend      E _vvsconv(const V &rv,const VS &sl)
00298 #if(CXSC_INDEX_CHECK)
00299                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00300 #else
00301         throw();
00302 #endif
00303  template <class VS1,class VS2,class E> friend   E _vsvsconv(const VS1 &s1,const VS2 &s2)
00304 #if(CXSC_INDEX_CHECK)
00305                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00306 #else
00307         throw();
00308 #endif
00309         //--------- vector-scalar -----------------
00310  template <class V,class S,class E> friend       E _vsdiv(const V &rv, const S &s) throw();
00311  template <class V,class S> friend       V &_vsdivassign(V &rv,const S &r) throw();
00312  template <class VS,class S,class E> friend      E _vssdiv(const VS &sl, const S &s) throw();
00313  template <class V,class S,class E> friend       E _vsmult(const V &rv, const S &s) throw();
00314  template <class VS,class S,class E> friend      E _vssmult(const VS &sl, const S &s) throw();
00315  template <class MV,class S,class E> friend      E _mvsmult(const MV &rv, const S &s) throw();
00316  template <class MV1,class MV2,class E> friend   E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
00317 #if(CXSC_INDEX_CHECK)
00318                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00319 #else
00320         throw();
00321 #endif
00322  template <class MV,class V,class E> friend      E _mvvplus(const MV &rv1, const V &rv2)
00323 #if(CXSC_INDEX_CHECK)
00324                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00325 #else
00326         throw();
00327 #endif
00328  template <class MV,class V,class E> friend      E _mvvminus(const MV &rv1, const V &rv2)
00329 #if(CXSC_INDEX_CHECK)
00330                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00331 #else
00332         throw();
00333 #endif
00334  template <class V,class MV,class E> friend      E _vmvminus(const V &rv1, const MV &rv2)
00335 #if(CXSC_INDEX_CHECK)
00336                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00337 #else
00338         throw();
00339 #endif
00340  template <class MV1,class MV2,class E> friend   E _mvmvminus(const MV1 &rv1, const MV2 &rv2)
00341 #if(CXSC_INDEX_CHECK)
00342                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00343 #else
00344         throw();
00345 #endif
00346 template <class MV,class V> friend  MV &_mvvplusassign(MV &v,const V &rv)
00347 #if(CXSC_INDEX_CHECK)
00348         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00349 #else
00350         throw();
00351 #endif
00352 template <class MV,class V> friend  MV &_mvvminusassign(MV &v,const V &rv)
00353 #if(CXSC_INDEX_CHECK)
00354         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00355 #else
00356         throw();
00357 #endif
00358  template <class MV,class S,class E> friend      E _mvsdiv(const MV &rv, const S &s) throw();
00359 template <class MV,class V> friend  MV &_mvvassign(MV &v,const V &rv)
00360 #if(CXSC_INDEX_CHECK)
00361         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00362 #else
00363         throw();
00364 #endif
00365 template <class DP,class V,class SV> friend     void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
00366 #if(CXSC_INDEX_CHECK)
00367                 throw(OP_WITH_WRONG_DIM);
00368 #else
00369         throw();
00370 #endif
00371 
00372  template <class V1,class V2> friend     bool _vveq(const V1 &rv1, const V2 &rv2) throw();
00373  template <class VS,class V> friend      bool _vsveq(const VS &sl, const V &rv) throw();
00374  template <class V1,class V2> friend     bool _vvneq(const V1 &rv1, const V2 &rv2) throw();
00375  template <class VS,class V> friend      bool _vsvneq(const VS &sl, const V &rv) throw();
00376  template <class V1,class V2> friend     bool _vvless(const V1 &rv1, const V2 &rv2) throw();
00377  template <class VS,class V> friend      bool _vsvless(const VS &sl, const V &rv) throw();
00378  template <class V1,class V2> friend     bool _vvleq(const V1 &rv1, const V2 &rv2) throw();
00379  template <class VS,class V> friend      bool _vsvleq(const VS &sl, const V &rv) throw();
00380  template <class V,class VS> friend      bool _vvsless(const V &rv, const VS &sl) throw();
00381  template <class V,class VS> friend      bool _vvsleq(const V &rv, const VS &sl) throw();
00382  template <class V> friend       bool _vnot(const V &rv) throw();
00383  template <class V> friend      void *_vvoid(const V &rv) throw();
00384  template <class VS1,class VS2> friend   bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw();
00385  template <class VS1,class VS2> friend   bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw();
00386  template <class VS1,class VS2> friend   bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw();
00387  template <class VS1,class VS2> friend   bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw();
00388  template <class VS> friend      bool _vsnot(const VS &sl) throw();
00389  template <class VS> friend     void *_vsvoid(const VS &sl) throw();
00390  template <class V> friend      std::ostream &_vout(std::ostream &s, const V &rv) throw();
00391  template <class V> friend      std::istream &_vin(std::istream &s, V &rv) throw();
00392 
00393         //------------- vector-matrix ---------------
00394 template <class V,class MV2,class S> friend  V &_vmvassign(V &v,const MV2 &rv) throw();
00395  template <class M,class V,class E> friend       E _mvcmult(const M &m,const V &v)
00396 #if(CXSC_INDEX_CHECK)
00397                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00398 #else
00399         throw();
00400 #endif
00401  template <class M,class V,class E> friend       E _mvcimult(const M &m,const V &v)
00402 #if(CXSC_INDEX_CHECK)
00403                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00404 #else
00405         throw();
00406 #endif
00407  template <class V,class M,class E> friend       E _vmcmult(const V &v,const M &m)
00408 #if(CXSC_INDEX_CHECK)
00409                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00410 #else
00411         throw();
00412 #endif
00413  template <class V,class M,class E> friend       E _vmcimult(const V &v,const M &m)
00414 #if(CXSC_INDEX_CHECK)
00415                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00416 #else
00417         throw();
00418 #endif
00419  template <class V,class M,class S> friend       V &_vmcmultassign(V &v,const M &m)
00420 #if(CXSC_INDEX_CHECK)
00421                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00422 #else
00423         throw();
00424 #endif
00425  template <class V,class M,class S> friend       V &_vmcimultassign(V &v,const M &m)
00426 #if(CXSC_INDEX_CHECK)
00427                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00428 #else
00429         throw();
00430 #endif
00431  template <class MS,class V,class E> friend      E _msvcmult(const MS &ms,const V &v)
00432 #if(CXSC_INDEX_CHECK)
00433                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00434 #else
00435         throw();
00436 #endif
00437  template <class MS,class V,class E> friend      E _msvcimult(const MS &ms,const V &v)
00438 #if(CXSC_INDEX_CHECK)
00439                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00440 #else
00441         throw();
00442 #endif
00443  template <class V,class MS,class E> friend      E _vmscmult(const V &v,const MS &ms)
00444 #if(CXSC_INDEX_CHECK)
00445                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00446 #else
00447         throw();
00448 #endif
00449  template <class V,class MS,class E> friend      E _vmscimult(const V &v,const MS &ms)
00450 #if(CXSC_INDEX_CHECK)
00451                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00452 #else
00453         throw();
00454 #endif
00455  template <class V,class MS,class S> friend      V &_vmscmultassign(V &v,const MS &ms)
00456 #if(CXSC_INDEX_CHECK)
00457                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00458 #else
00459         throw();
00460 #endif
00461  template <class V,class MS,class S> friend      V &_vmscimultassign(V &v,const MS &ms)
00462 #if(CXSC_INDEX_CHECK)
00463                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00464 #else
00465         throw();
00466 #endif
00467 
00468         // Real
00469         //--Real -------- vector-scalar ------------
00470         //--Real--------- Vector-vector---------
00471         //-- Real -------- Vector-matrix ----------
00472         // interval -----------------
00473         // vector-scalar
00474         // vector-vector
00475  template <class V1,class V2,class E> friend     E _vvcimult(const V1 & rv1, const V2 &rv2)
00476 #if(CXSC_INDEX_CHECK)
00477                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00478 #else
00479         throw();
00480 #endif
00481  template <class VS,class V,class E> friend      E _vsvcimult(const VS & sl, const V &rv)
00482 #if(CXSC_INDEX_CHECK)
00483                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00484 #else
00485         throw();
00486 #endif
00487  template <class VS1,class VS2,class E> friend   E _vsvscimult(const VS1 & sl1, const VS2 &sl2)
00488 #if(CXSC_INDEX_CHECK)
00489                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00490 #else
00491         throw();
00492 #endif
00493  template <class V1,class V2,class E> friend     E _vvsect(const V1 &rv1, const V2 &rv2)
00494 #if(CXSC_INDEX_CHECK)
00495                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00496 #else
00497         throw();
00498 #endif
00499  template <class V,class VS,class E> friend      E _vvssect(const V &rv,const VS &sl)
00500 #if(CXSC_INDEX_CHECK)
00501                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00502 #else
00503         throw();
00504 #endif
00505  template <class VS1,class VS2,class E> friend   E _vsvssect(const VS1 &s1,const VS2 &s2)
00506 #if(CXSC_INDEX_CHECK)
00507                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00508 #else
00509         throw();
00510 #endif
00511 
00512         // vector-matrix
00513         // cinterval -----------------
00514  template <class V1,class V2> friend     V1 &_vvsetinf(V1 &rv1, const V2 &rv2)
00515 #if(CXSC_INDEX_CHECK)
00516                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00517 #else
00518         throw();
00519 #endif
00520  template <class V1,class V2> friend     V1 &_vvsetsup(V1 &rv1, const V2 &rv2)
00521 #if(CXSC_INDEX_CHECK)
00522                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00523 #else
00524         throw();
00525 #endif
00526  template <class V1,class V2> friend     V1 &_vvusetinf(V1 &rv1, const V2 &rv2)
00527 #if(CXSC_INDEX_CHECK)
00528                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00529 #else
00530         throw();
00531 #endif
00532  template <class V1,class V2> friend     V1 &_vvusetsup(V1 &rv1, const V2 &rv2)
00533 #if(CXSC_INDEX_CHECK)
00534                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00535 #else
00536         throw();
00537 #endif
00538  template <class VS,class V> friend      VS &_vsvsetinf(VS &sl, const V &rv)
00539 #if(CXSC_INDEX_CHECK)
00540                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00541 #else
00542         throw();
00543 #endif
00544  template <class VS,class V> friend      VS &_vsvsetsup(VS &sl, const V &rv)
00545 #if(CXSC_INDEX_CHECK)
00546                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00547 #else
00548         throw();
00549 #endif
00550  template <class VS,class V> friend      VS &_vsvusetinf(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 &_vsvusetsup(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 template <class MV,class V> friend  MV &_mvvsetinf(MV &v,const V &rv)
00563 #if(CXSC_INDEX_CHECK)
00564         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00565 #else
00566         throw();
00567 #endif
00568 template <class MV,class V> friend  MV &_mvvsetsup(MV &v,const V &rv)
00569 #if(CXSC_INDEX_CHECK)
00570         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00571 #else
00572         throw();
00573 #endif
00574 template <class MV,class V> friend  MV &_mvvusetinf(MV &v,const V &rv)
00575 #if(CXSC_INDEX_CHECK)
00576         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00577 #else
00578         throw();
00579 #endif
00580 template <class MV,class V> friend  MV &_mvvusetsup(MV &v,const V &rv)
00581 #if(CXSC_INDEX_CHECK)
00582         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00583 #else
00584         throw();
00585 #endif
00586  template <class V,class E> friend       E _vmid(const V &rv) throw();
00587  template <class V,class E> friend       E _vinf(const V &rv) throw();
00588  template <class V,class E> friend       E _vsup(const V &rv) throw();
00589  template <class V,class E> friend       E _vdiam(const V &rv) throw();
00590  template <class VS,class E> friend      E _vsmid(const VS &sl) throw();
00591  template <class VS,class E> friend      E _vsinf(const VS &sl) throw();
00592  template <class VS,class E> friend      E _vssup(const VS &sl) throw();
00593  template <class VS,class E> friend      E _vsdiam(const VS &sl) throw();
00594 template <class MV,class V> friend  V _mvdiam(const MV &mv) throw();
00595 template <class MV,class V> friend  V _mvmid(const MV &mv) throw();
00596 template <class MV,class V> friend  V _mvinf(const MV &mv) throw();
00597 template <class MV,class V> friend  V _mvsup(const MV &mv) throw();
00598 
00599         // vector-vector
00600  template <class V1,class V2> friend     V1 &_vvconvassign(V1 &rv1, const V2 &rv2)
00601 #if(CXSC_INDEX_CHECK)
00602                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00603 #else
00604         throw();
00605 #endif
00606  template <class V1,class V2> friend     V1 &_vvsectassign(V1 &rv1, const V2 &rv2)
00607 #if(CXSC_INDEX_CHECK)
00608                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00609 #else
00610         throw();
00611 #endif
00612  template <class VS,class V> friend      VS &_vsvconvassign(VS &sl, const V &rv)
00613 #if(CXSC_INDEX_CHECK)
00614                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00615 #else
00616         throw();
00617 #endif
00618  template <class VS,class V> friend      VS &_vsvsectassign(VS &sl, const V &rv)
00619 #if(CXSC_INDEX_CHECK)
00620                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00621 #else
00622         throw();
00623 #endif
00624 template <class MV,class V> friend  MV &_mvvconvassign(MV &v,const V &rv)
00625 #if(CXSC_INDEX_CHECK)
00626         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00627 #else
00628         throw();
00629 #endif
00630 template <class MV,class V> friend  MV &_mvvsectassign(MV &v,const V &rv)
00631 #if(CXSC_INDEX_CHECK)
00632         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00633 #else
00634         throw();
00635 #endif
00636 
00637 
00638 #endif
00639 
00640         //------ Konstruktoren ----------------------------------------------------
00642         cvector () throw();
00644         explicit cvector(const int &i) throw();
00645 #ifdef OLD_CXSC
00646 
00647         explicit cvector(const class index &i) throw(); // for backwards compatibility
00648 #endif
00649 
00650         explicit cvector(const int &i1,const int &i2)
00651 #if(CXSC_INDEX_CHECK)
00652         throw(ERROR_CVECTOR_WRONG_BOUNDARIES,ERROR_CVECTOR_NO_MORE_MEMORY);
00653 #else
00654         throw();
00655 #endif
00656 
00657         cvector(const cmatrix_subv &) throw();
00659         explicit cvector(const complex& r) throw();
00661         explicit cvector(const cmatrix& )
00662 #if(CXSC_INDEX_CHECK)
00663         throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
00664 #else
00665         throw();
00666 #endif
00667 
00668         explicit cvector(const cmatrix_slice &sl)
00669 #if(CXSC_INDEX_CHECK)
00670         throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
00671 #else
00672         throw();
00673 #endif
00674 
00675         cvector(const cvector_slice &rs) throw();
00677         cvector(const cvector &v) throw();
00679         cvector(const scvector_slice &rs);
00681         cvector(const scvector &v);
00682         // Real
00684         explicit cvector(const srvector_slice &rs);
00686         explicit cvector(const srvector &v);
00688         explicit cvector(const real &) throw();
00690         explicit cvector(const rvector_slice &rs) throw();
00692         explicit cvector(const rvector &v) throw();
00694         explicit cvector(const rmatrix &)
00695 #if(CXSC_INDEX_CHECK)
00696         throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
00697 #else
00698         throw();
00699 #endif
00700 
00701         explicit cvector(const rmatrix_slice &sl)
00702 #if(CXSC_INDEX_CHECK)
00703         throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
00704 #else
00705         throw();
00706 #endif
00707 
00708         explicit cvector(const rmatrix_subv &) throw();
00709         
00710         // complex
00712         cvector &operator =(const cvector &rv) throw();
00714         cvector &operator =(const cvector_slice &sl) throw();
00716         cvector &operator =(const scvector &rv);
00718         cvector &operator =(const scvector_slice &sl);
00720         cvector &operator =(const complex &r) throw();
00722         cvector &operator =(const cmatrix &m)
00723 #if(CXSC_INDEX_CHECK)
00724         throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
00725 #else
00726         throw();
00727 #endif
00728 
00729         cvector &operator =(const cmatrix_slice &)
00730 #if(CXSC_INDEX_CHECK)
00731         throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
00732 #else
00733         throw();
00734 #endif
00735 
00736         cvector &operator =(const cmatrix_subv &) throw();
00737         // Real
00739         cvector &operator =(const rvector &rv) throw();
00741         cvector &operator =(const rvector_slice &sl) throw();
00743         cvector &operator =(const srvector &rv);
00745         cvector &operator =(const srvector_slice &sl);
00747         cvector &operator =(const real &r) throw();
00749         cvector &operator =(const rmatrix &m)
00750 #if(CXSC_INDEX_CHECK)
00751         throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
00752 #else
00753         throw();
00754 #endif
00755 
00756         cvector &operator =(const rmatrix_slice &)
00757 #if(CXSC_INDEX_CHECK)
00758         throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
00759 #else
00760         throw();
00761 #endif
00762 
00763         cvector &operator =(const rmatrix_subv &) throw();
00764 
00765         cvector& operator+=(const srvector&);
00766         cvector& operator+=(const scvector&);
00767         cvector& operator+=(const srvector_slice&);
00768         cvector& operator+=(const scvector_slice&);
00769         cvector& operator-=(const srvector&);
00770         cvector& operator-=(const scvector&);
00771         cvector& operator-=(const srvector_slice&);
00772         cvector& operator-=(const scvector_slice&);
00773 
00775         INLINE cvector operator()(const intvector& p);
00777         INLINE cvector operator()(const intmatrix& P);
00778 
00779         //--------- Destruktor ----------------------------------------------------
00780         INLINE ~cvector() { delete [] dat; }
00781 
00782         //------ Standardfunktionen -----------------------------------------------
00783         
00784         friend INLINE complex::complex(const cvector &)
00785 #if(CXSC_INDEX_CHECK)
00786         throw(ERROR_CVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_CVECTOR_USE_OF_UNINITIALIZED_OBJ);
00787 #else
00788         throw();
00789 #endif
00790 
00791         friend INLINE int Lb(const cvector &rv) throw() { return rv.l; }
00793         friend INLINE int Ub(const cvector &rv) throw() { return rv.u; }
00795         friend INLINE int VecLen(const cvector &rv) throw() { return rv.size; }
00797         friend INLINE cvector & SetLb(cvector &rv, const int &l) throw() { rv.l=l; rv.u=l+rv.size-1; return rv;}
00799         friend INLINE cvector & SetUb(cvector &rv, const int &u) throw() { rv.u=u; rv.l=u-rv.size+1; return rv;}
00801         INLINE complex & operator [](const int &i) const
00802 #if(CXSC_INDEX_CHECK)
00803         throw(ERROR_CVECTOR_ELEMENT_NOT_IN_VEC);
00804 #else
00805         throw();
00806 #endif
00807 
00809         INLINE complex & operator [](const int &i) 
00810 #if(CXSC_INDEX_CHECK)
00811         throw(ERROR_CVECTOR_ELEMENT_NOT_IN_VEC);
00812 #else
00813         throw();
00814 #endif
00815 
00817         INLINE cvector & operator ()() throw() { return *this; }
00819         INLINE cvector_slice operator ()(const int &i)
00820 #if(CXSC_INDEX_CHECK)
00821         throw(ERROR_CVECTOR_SUB_ARRAY_TOO_BIG);
00822 #else
00823         throw();
00824 #endif
00825 
00826         cvector_slice operator ()(const int &i1,const int &i2)
00827 #if(CXSC_INDEX_CHECK)
00828         throw(ERROR_CVECTOR_SUB_ARRAY_TOO_BIG);
00829 #else
00830         throw();
00831 #endif
00832         operator void*() throw();
00833 //#else
00834 //#endif
00835 };
00836 
00837 
00839 
00844 class cvector_slice
00845 {
00846         friend class cvector;
00847         friend class cmatrix;
00848         friend class civector;
00849         friend class cimatrix;
00850         private:
00851         complex *dat;
00852         int l,u,size;
00853         int start,end;
00854 
00855         public:
00856 //#if(CXSC_INDEX_CHECK) 
00857 #ifdef _CXSC_FRIEND_TPL
00858 //------------------------- Templates -------------------------------------------
00859 // complex / complex
00860 
00861  template <class VS1,class VS2> friend   VS1 & _vsvsassign(VS1 &sl1,const VS2 &sl2)
00862 #if(CXSC_INDEX_CHECK)
00863                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00864 #else
00865         throw();
00866 #endif
00867 
00868  template <class V,class VS,class S> friend      V & _vvsassign(V &rv,const VS &sl) throw();
00869 
00870  template <class VS,class V> friend      VS & _vsvassign(VS &sl,const V &rv)
00871 #if(CXSC_INDEX_CHECK)
00872                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00873 #else
00874         throw();
00875 #endif
00876 
00877  template <class VS,class S> friend      VS & _vssassign(VS &sl,const S &r) throw();
00878 
00879  template <class DP,class VS,class V> friend    void _vsvaccu(DP &dp, const VS & sl, const V &rv)
00880 #if(CXSC_INDEX_CHECK)
00881                 throw(OP_WITH_WRONG_DIM);
00882 #else
00883         throw();
00884 #endif
00885  template <class DP,class VS1,class VS2> friend         void _vsvsaccu(DP &dp, const VS1 & sl1, const VS2 &sl2)
00886 #if(CXSC_INDEX_CHECK)
00887                 throw(OP_WITH_WRONG_DIM);
00888 #else
00889         throw();
00890 #endif
00891 
00892  template <class VS,class S,class E> friend      E _vssdiv(const VS &sl, const S &s) throw();
00893  template <class VS,class S,class E> friend      E _vssmult(const VS &sl, const S &s) throw();
00894 
00895  template <class VS,class V,class E> friend      E _vsvcmult(const VS & sl, const V &rv)
00896 #if(CXSC_INDEX_CHECK)
00897                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00898 #else
00899         throw();
00900 #endif
00901  template <class VS,class S> friend      VS &_vssmultassign(VS &rv,const S &r) throw();
00902  template <class VS,class S> friend      VS &_vssdivassign(VS &rv,const S &r) throw();
00903  template <class V,class VS,class E> friend      E _vvsplus(const V &rv,const VS &sl)
00904 #if(CXSC_INDEX_CHECK)
00905                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00906 #else
00907         throw();
00908 #endif
00909  template <class VS1,class VS2,class E> friend   E _vsvsplus(const VS1 &s1,const VS2 &s2)
00910 #if(CXSC_INDEX_CHECK)
00911                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00912 #else
00913         throw();
00914 #endif
00915  template <class VS1,class VS2,class E> friend   E _vsvsminus(const VS1 &s1,const VS2 &s2)
00916 #if(CXSC_INDEX_CHECK)
00917                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00918 #else
00919         throw();
00920 #endif
00921  template <class V,class VS> friend      V &_vvsplusassign(V &rv, const VS &sl)
00922 #if(CXSC_INDEX_CHECK)
00923                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00924 #else
00925         throw();
00926 #endif
00927  template <class VS1,class VS2> friend   VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
00928 #if(CXSC_INDEX_CHECK)
00929                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00930 #else
00931         throw();
00932 #endif
00933  template <class VS1,class VS2> friend   VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
00934 #if(CXSC_INDEX_CHECK)
00935                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00936 #else
00937         throw();
00938 #endif
00939  template <class V,class VS> friend      V &_vvsminusassign(V &rv, const VS &sl)
00940 #if(CXSC_INDEX_CHECK)
00941                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00942 #else
00943         throw();
00944 #endif
00945 
00946  template <class VS,class V> friend      V _vsminus(const VS &sl) throw();
00947 
00948  template <class V,class VS,class E> friend      E _vvsminus(const V &rv, const VS &sl)
00949 #if(CXSC_INDEX_CHECK)
00950                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00951 #else
00952         throw();
00953 #endif
00954  template <class VS,class V,class E> friend      E _vsvminus(const VS &sl,const V &rv)
00955 #if(CXSC_INDEX_CHECK)
00956                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00957 #else
00958         throw();
00959 #endif
00960  template <class V,class VS,class E> friend      E _vvsconv(const V &rv,const VS &sl)
00961 #if(CXSC_INDEX_CHECK)
00962                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00963 #else
00964         throw();
00965 #endif
00966  template <class VS1,class VS2,class E> friend   E _vsvsconv(const VS1 &s1,const VS2 &s2)
00967 #if(CXSC_INDEX_CHECK)
00968                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00969 #else
00970         throw();
00971 #endif
00972  template <class VS,class V> friend      bool _vsveq(const VS &sl, const V &rv) throw();
00973  template <class VS,class V> friend      bool _vsvneq(const VS &sl, const V &rv) throw();
00974  template <class VS,class V> friend      bool _vsvless(const VS &sl, const V &rv) throw();
00975  template <class VS,class V> friend      bool _vsvleq(const VS &sl, const V &rv) throw();
00976  template <class V,class VS> friend      bool _vvsless(const V &rv, const VS &sl) throw();
00977  template <class V,class VS> friend      bool _vvsleq(const V &rv, const VS &sl) throw();
00978  template <class VS,class E> friend      E _vsconj(const VS &sl) throw();
00979  template <class VS,class E> friend      E _vsabs(const VS &sl) throw();
00980 
00981  template <class VS1,class VS2,class E> friend   E _vsvscmult(const VS1 & sl1, const VS2 &sl2)
00982 #if(CXSC_INDEX_CHECK)
00983                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00984 #else
00985         throw();
00986 #endif
00987 
00988  template <class VS1,class VS2> friend   bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw();
00989  template <class VS1,class VS2> friend   bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw();
00990  template <class VS1,class VS2> friend   bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw();
00991  template <class VS1,class VS2> friend   bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw();
00992  template <class VS> friend      bool _vsnot(const VS &sl) throw();
00993  template <class VS> friend     void *_vsvoid(const VS &sl) throw();
00994  template <class V> friend      std::ostream &_vsout(std::ostream &s, const V &rv) throw();
00995  template <class V> friend      std::istream &_vsin(std::istream &s, V &rv) throw();
00996  template <class VS,class E> friend      E _vsim(const VS &sl) throw();
00997  template <class VS,class E> friend      E _vsre(const VS &sl) throw();
00998  template <class VS,class V> friend      VS &_vsvsetim(VS &sl, const V &rv)
00999 #if(CXSC_INDEX_CHECK)
01000                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01001 #else
01002         throw();
01003 #endif
01004  template <class VS,class V> friend      VS &_vsvsetre(VS &sl, const V &rv)
01005 #if(CXSC_INDEX_CHECK)
01006                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01007 #else
01008         throw();
01009 #endif
01010  template <class VS1,class VS2> friend   VS1 &_vsvssetim(VS1 &sl1, const VS2 &sl2)
01011 #if(CXSC_INDEX_CHECK)
01012                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01013 #else
01014         throw();
01015 #endif
01016  template <class VS1,class VS2> friend   VS1 &_vsvssetre(VS1 &sl1, const VS2 &sl2)
01017 #if(CXSC_INDEX_CHECK)
01018                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01019 #else
01020         throw();
01021 #endif
01022 /*      friend TINLINE cvector_slice &_vsmvsetim(cvector_slice &,const
01023 rmatrix_subv &) #if(CXSC_INDEX_CHECK)
01024 throw(ERROR__OP_WITH_WRONG_DIM<cvector_slice>); #else   throw();
01025 #endif
01026         friend TINLINE cvector_slice &_vsmvsetre(cvector_slice &,const rmatrix_subv &)
01027 #if(CXSC_INDEX_CHECK)
01028         throw(ERROR__OP_WITH_WRONG_DIM<cvector_slice>);
01029 #else
01030         throw();
01031 #endif  */     // 4.10.00 S.W.
01032 
01033  template <class VS,class S> friend      VS &_vsssetim(VS &vs, const S &s) throw();
01034  template <class VS,class S> friend      VS &_vsssetre(VS &vs, const S &s) throw();
01035 
01036  template <class VS,class M,class S> friend      VS &_vsmcmultassign(VS &v,const M &m)
01037 #if(CXSC_INDEX_CHECK)
01038                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01039 #else
01040         throw();
01041 #endif
01042         
01043         // complex / Real
01044  template <class VS,class V> friend      VS &_vsvplusassign(VS &sl, const V &rv)
01045 #if(CXSC_INDEX_CHECK)
01046                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01047 #else
01048         throw();
01049 #endif
01050  template <class VS,class V> friend      VS &_vsvminusassign(VS &sl, const V &rv)
01051 #if(CXSC_INDEX_CHECK)
01052                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01053 #else
01054         throw();
01055 #endif
01056  template <class V,class MS,class E> friend      E _vmscmult(const V &v,const MS &ms)
01057 #if(CXSC_INDEX_CHECK)
01058                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01059 #else
01060         throw();
01061 #endif
01062         
01063  template <class V,class VS,class E> friend      E _vvssect(const V &rv,const VS &sl)
01064 #if(CXSC_INDEX_CHECK)
01065                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01066 #else
01067         throw();
01068 #endif
01069  template <class VS1,class VS2,class E> friend   E _vsvssect(const VS1 &s1,const VS2 &s2)
01070 #if(CXSC_INDEX_CHECK)
01071                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01072 #else
01073         throw();
01074 #endif
01075         // interval -----------
01076         // vector-vector -------
01077  template <class V1,class V2,class E> friend     E _vvcimult(const V1 & rv1, const V2 &rv2)
01078 #if(CXSC_INDEX_CHECK)
01079                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
01080 #else
01081         throw();
01082 #endif
01083  template <class VS,class V,class E> friend      E _vsvcimult(const VS & sl, const V &rv)
01084 #if(CXSC_INDEX_CHECK)
01085                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01086 #else
01087         throw();
01088 #endif
01089  template <class VS1,class VS2,class E> friend   E _vsvscimult(const VS1 & sl1, const VS2 &sl2)
01090 #if(CXSC_INDEX_CHECK)
01091                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01092 #else
01093         throw();
01094 #endif
01095  template <class V1,class V2,class E> friend     E _vvplus(const V1 &rv1, const V2 &rv2)
01096 #if(CXSC_INDEX_CHECK)
01097                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
01098 #else
01099         throw();
01100 #endif
01101  template <class V1,class V2,class E> friend     E _vvminus(const V1 &rv1, const V2 &rv2)
01102 #if(CXSC_INDEX_CHECK)
01103                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01104 #else
01105         throw();
01106 #endif
01107 
01108         // vector-matrix -------
01109 /*   friend TINLINE civector _mvscimult<imatrix,cvector_slice,civector>(const
01110 imatrix &m,const cvector_slice &v) #if(CXSC_INDEX_CHECK)
01111         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01112 #else
01113         throw();
01114 #endif */  // 4.10.00. S.W.
01115 /*   friend TINLINE civector _vsmcimult<cvector_slice,imatrix,civector>(const
01116 cvector_slice &v,const imatrix &m) #if(CXSC_INDEX_CHECK)
01117         throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
01118 #else
01119         throw();
01120 #endif
01121 */  // 4.10.00 S.W.
01122 
01123         // cinterval
01124         // cinterval -- vector-vector
01125  template <class V,class VS> friend      V &_vvsconvassign(V &rv, const VS &sl)
01126 #if(CXSC_INDEX_CHECK)
01127                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01128 #else
01129         throw();
01130 #endif
01131  template <class V,class VS> friend      V &_vvssectassign(V &rv, const VS &sl)
01132 #if(CXSC_INDEX_CHECK)
01133                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01134 #else
01135         throw();
01136 #endif
01137  template <class VS1,class VS2> friend   VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2)
01138 #if(CXSC_INDEX_CHECK)
01139                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01140 #else
01141         throw();
01142 #endif
01143  template <class VS1,class VS2> friend   VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2)
01144 #if(CXSC_INDEX_CHECK)
01145                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01146 #else
01147         throw();
01148 #endif
01149 #endif
01150         
01151         //--------------------- Konstruktoren -----------------------------------
01153         explicit INLINE cvector_slice(cvector &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) { }
01155         explicit INLINE cvector_slice(cvector_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) { }
01156         public:
01158         INLINE cvector_slice(const cvector_slice &a) throw():dat(a.dat),l(a.l),u(a.u),size(a.size),start(a.start),end(a.end) { }
01159         public:
01160         // complex
01162         INLINE cvector_slice & operator =(const scvector &sl);
01164         INLINE cvector_slice & operator =(const scvector_slice &sl);
01165 
01167         INLINE cvector_slice & operator =(const cvector_slice &sl)
01168 #if(CXSC_INDEX_CHECK)
01169         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01170 #else
01171         throw();
01172 #endif
01173 
01174         INLINE cvector_slice & operator =(const cvector &rv)
01175 #if(CXSC_INDEX_CHECK)
01176         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01177 #else
01178         throw();
01179 #endif
01180 
01181         INLINE cvector_slice & operator =(const complex &r) throw();
01183         INLINE cvector_slice & operator =(const cmatrix &m)
01184 #if(CXSC_INDEX_CHECK)
01185         throw(ERROR__OP_WITH_WRONG_DIM<cvector>,ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
01186 #else
01187         throw();
01188 #endif
01189 
01190         INLINE cvector_slice & operator =(const cmatrix_slice &m)
01191 #if(CXSC_INDEX_CHECK)
01192         throw(ERROR__OP_WITH_WRONG_DIM<cvector>,ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
01193 #else
01194         throw();
01195 #endif
01196 
01197         INLINE cvector_slice &operator =(const cmatrix_subv &) throw();
01198         // Real
01200         INLINE cvector_slice & operator =(const srvector &rv);
01202         INLINE cvector_slice & operator =(const srvector_slice &rv);
01203 
01205         INLINE cvector_slice & operator =(const rvector_slice &sl)
01206 #if(CXSC_INDEX_CHECK)
01207         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01208 #else
01209         throw();
01210 #endif
01211         INLINE cvector_slice & operator =(const rvector &rv)
01212 #if(CXSC_INDEX_CHECK)
01213         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01214 #else
01215         throw();
01216 #endif
01217 
01218         INLINE cvector_slice & operator =(const real &r) throw();
01220         INLINE cvector_slice & operator =(const rmatrix &m)
01221 #if(CXSC_INDEX_CHECK)
01222         throw(ERROR__OP_WITH_WRONG_DIM<rvector>,ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
01223 #else
01224         throw();
01225 #endif
01226 
01227         INLINE cvector_slice & operator =(const rmatrix_slice &m)
01228 #if(CXSC_INDEX_CHECK)
01229         throw(ERROR__OP_WITH_WRONG_DIM<rvector>,ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
01230 #else
01231         throw();
01232 #endif
01233 
01234         INLINE cvector_slice &operator =(const rmatrix_subv &mv) throw();
01235 
01236         // cinterval --------
01237  template <class V,class VS> friend      V &_vvssetinf(V &rv, const VS &sl)
01238 #if(CXSC_INDEX_CHECK)
01239                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01240 #else
01241         throw();
01242 #endif
01243  template <class V,class VS> friend      V &_vvssetsup(V &rv, const VS &sl)
01244 #if(CXSC_INDEX_CHECK)
01245                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01246 #else
01247         throw();
01248 #endif
01249  template <class V,class VS> friend      V &_vvsusetinf(V &rv, const VS &sl)
01250 #if(CXSC_INDEX_CHECK)
01251                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01252 #else
01253         throw();
01254 #endif
01255  template <class V,class VS> friend      V &_vvsusetsup(V &rv, const VS &sl)
01256 #if(CXSC_INDEX_CHECK)
01257                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01258 #else
01259         throw();
01260 #endif
01261  template <class VS1,class VS2> friend   VS1 &_vsvssetinf(VS1 &sl1, const VS2 &sl2)
01262 #if(CXSC_INDEX_CHECK)
01263                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01264 #else
01265         throw();
01266 #endif
01267  template <class VS1,class VS2> friend   VS1 &_vsvssetsup(VS1 &sl1, const VS2 &sl2)
01268 #if(CXSC_INDEX_CHECK)
01269                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01270 #else
01271         throw();
01272 #endif
01273  template <class VS1,class VS2> friend   VS1 &_vsvsusetinf(VS1 &sl1, const VS2 &sl2)
01274 #if(CXSC_INDEX_CHECK)
01275                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01276 #else
01277         throw();
01278 #endif
01279  template <class VS1,class VS2> friend   VS1 &_vsvsusetsup(VS1 &sl1, const VS2 &sl2)
01280 #if(CXSC_INDEX_CHECK)
01281                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01282 #else
01283         throw();
01284 #endif
01285 
01286         // cinterval -- vector-vector
01287  template <class V,class MS,class E> friend      E _vmscimult(const V &v,const MS &ms)
01288 #if(CXSC_INDEX_CHECK)
01289                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01290 #else
01291         throw();
01292 #endif
01293 
01294 
01295         //--------------------- Standardfunktionen ------------------------------
01296 
01297         friend INLINE complex::complex(const cvector_slice &sl)
01298 #if(CXSC_INDEX_CHECK)
01299         throw(ERROR_CVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_CVECTOR_USE_OF_UNINITIALIZED_OBJ);
01300 #else
01301         throw();
01302 #endif
01303 
01304         friend INLINE int Lb(const cvector_slice &sl) throw() { return sl.start; }
01306         friend INLINE int Ub(const cvector_slice &sl) throw() { return sl.end; }
01308         friend INLINE int VecLen(const cvector_slice &sl) throw() { return sl.end-sl.start+1; }
01310         INLINE complex & operator [](const int &i) const
01311 #if(CXSC_INDEX_CHECK)
01312         throw(ERROR_CVECTOR_ELEMENT_NOT_IN_VEC);
01313 #else
01314         throw();
01315 #endif
01316 
01318         INLINE complex & operator [](const int &i) 
01319 #if(CXSC_INDEX_CHECK)
01320         throw(ERROR_CVECTOR_ELEMENT_NOT_IN_VEC);
01321 #else
01322         throw();
01323 #endif
01324         
01326         INLINE cvector_slice & operator ()() throw() { return *this; }
01328         INLINE cvector_slice operator ()(const int &i)
01329 #if(CXSC_INDEX_CHECK)
01330         throw(ERROR_CVECTOR_SUB_ARRAY_TOO_BIG);
01331 #else
01332         throw();
01333 #endif
01334 
01335         INLINE cvector_slice operator ()(const int &i1,const int &i2)
01336 #if(CXSC_INDEX_CHECK)
01337         throw(ERROR_CVECTOR_SUB_ARRAY_TOO_BIG);
01338 #else
01339         throw();
01340 #endif
01341         
01343         INLINE cvector_slice &operator /=(const complex &r) throw();
01345         INLINE cvector_slice &operator /=(const real &r) throw();
01347         INLINE cvector_slice &operator *=(const complex &r) throw();
01349         INLINE cvector_slice &operator *=(const cmatrix &m)
01350 #if(CXSC_INDEX_CHECK)
01351         throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
01352 #else
01353         throw();
01354 #endif
01355 
01356         INLINE cvector_slice &operator *=(const rmatrix &m)
01357 #if(CXSC_INDEX_CHECK)
01358         throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
01359 #else
01360         throw();
01361 #endif
01362 
01363         INLINE cvector_slice &operator *=(const real &r) throw();
01365         INLINE cvector_slice &operator +=(const cvector &rv)
01366 #if(CXSC_INDEX_CHECK)
01367         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01368 #else
01369         throw();
01370 #endif
01371 
01372         INLINE cvector_slice &operator +=(const cvector_slice &sl2)
01373 #if(CXSC_INDEX_CHECK)
01374         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01375 #else
01376         throw();
01377 #endif
01378 
01379         INLINE cvector_slice &operator -=(const cvector &rv)
01380 #if(CXSC_INDEX_CHECK)
01381         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01382 #else
01383         throw();
01384 #endif
01385 
01386         INLINE cvector_slice &operator -=(const cvector_slice &sl2)
01387 #if(CXSC_INDEX_CHECK)
01388         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01389 #else
01390         throw();
01391 #endif
01392 
01393         INLINE cvector_slice &operator |=(const cvector &rv)
01394 #if(CXSC_INDEX_CHECK)
01395         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01396 #else
01397         throw();
01398 #endif
01399 
01400         INLINE cvector_slice &operator |=(const cvector_slice &sl2)
01401 #if(CXSC_INDEX_CHECK)
01402         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01403 #else
01404         throw();
01405 #endif
01406 
01407         INLINE cvector_slice &operator &=(const cvector &rv)
01408 #if(CXSC_INDEX_CHECK)
01409         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01410 #else
01411         throw();
01412 #endif
01413 
01414         INLINE cvector_slice &operator &=(const cvector_slice &sl2)
01415 #if(CXSC_INDEX_CHECK)
01416         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01417 #else
01418         throw();
01419 #endif
01420         
01422         INLINE cvector_slice &operator +=(const rvector &rv)
01423 #if(CXSC_INDEX_CHECK)
01424         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01425 #else
01426         throw();
01427 #endif
01428 
01429         INLINE cvector_slice &operator +=(const rvector_slice &sl2)
01430 #if(CXSC_INDEX_CHECK)
01431         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01432 #else
01433         throw();
01434 #endif
01435 
01436         INLINE cvector_slice &operator -=(const rvector &rv)
01437 #if(CXSC_INDEX_CHECK)
01438         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01439 #else
01440         throw();
01441 #endif
01442 
01443         INLINE cvector_slice &operator -=(const rvector_slice &sl2)
01444 #if(CXSC_INDEX_CHECK)
01445         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01446 #else
01447         throw();
01448 #endif
01449 
01450         INLINE cvector_slice &operator |=(const rvector &rv)
01451 #if(CXSC_INDEX_CHECK)
01452         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01453 #else
01454         throw();
01455 #endif
01456 
01457         INLINE cvector_slice &operator |=(const rvector_slice &sl2)
01458 #if(CXSC_INDEX_CHECK)
01459         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01460 #else
01461         throw();
01462 #endif
01463 
01464         INLINE cvector_slice &operator &=(const rvector &rv)
01465 #if(CXSC_INDEX_CHECK)
01466         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01467 #else
01468         throw();
01469 #endif
01470 
01471         INLINE cvector_slice &operator &=(const rvector_slice &sl2)
01472 #if(CXSC_INDEX_CHECK)
01473         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01474 #else
01475         throw();
01476 #endif
01477         INLINE operator void*() throw();
01478 
01479         cvector_slice& operator+=(const srvector&);
01480         cvector_slice& operator+=(const scvector&);
01481         cvector_slice& operator+=(const srvector_slice&);
01482         cvector_slice& operator+=(const scvector_slice&);
01483         cvector_slice& operator-=(const srvector&);
01484         cvector_slice& operator-=(const scvector&);
01485         cvector_slice& operator-=(const srvector_slice&);
01486         cvector_slice& operator-=(const scvector_slice&);
01487 
01488 //#else
01489 //#endif
01490 };
01491 
01492 //=======================================================================
01493 //======================== Vector Functions =============================
01494 
01496         INLINE cvector _cvector(const complex &r) throw();
01497 //      INLINE cvector _cvector(const cmatrix &m) throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
01498 //      INLINE cvector _cvector(const cmatrix_slice &sl) throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
01500         INLINE cvector _cvector(const real &r) throw();
01502         INLINE cvector _cvector(const rvector_slice &rs) throw();
01504         INLINE cvector _cvector(const rvector &rs) throw();
01505 //      INLINE cvector _cvector(const rmatrix &m) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
01506 //      INLINE cvector _cvector(const rmatrix_slice &sl) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
01508         INLINE cvector _cvector(const rmatrix_subv &rs) throw();
01509 
01511         INLINE cvector &SetRe(cvector &iv,const rvector &rv)
01512 #if(CXSC_INDEX_CHECK)
01513         throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
01514 #else
01515         throw();
01516 #endif
01517 
01518         INLINE cvector_slice &SetRe(cvector_slice &iv,const rvector &rv)
01519 #if(CXSC_INDEX_CHECK)
01520         throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
01521 #else
01522         throw();
01523 #endif
01524 
01525         INLINE cvector &SetRe(cvector &iv,const rvector_slice &rv)
01526 #if(CXSC_INDEX_CHECK)
01527         throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
01528 #else
01529         throw();
01530 #endif
01531 
01532         INLINE cvector_slice &SetRe(cvector_slice &iv,const rvector_slice &rv)
01533 #if(CXSC_INDEX_CHECK)
01534         throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
01535 #else
01536         throw();
01537 #endif
01538 
01540         INLINE cvector &SetIm(cvector &iv,const rvector &rv)
01541 #if(CXSC_INDEX_CHECK)
01542         throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
01543 #else
01544         throw();
01545 #endif
01546 
01547         INLINE cvector_slice &SetIm(cvector_slice &iv,const rvector &rv)
01548 #if(CXSC_INDEX_CHECK)
01549         throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
01550 #else
01551         throw();
01552 #endif
01553 
01554         INLINE cvector &SetIm(cvector &iv,const rvector_slice &rv)
01555 #if(CXSC_INDEX_CHECK)
01556         throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
01557 #else
01558         throw();
01559 #endif
01560 
01561         INLINE cvector_slice &SetIm(cvector_slice &iv,const rvector_slice &rv)
01562 #if(CXSC_INDEX_CHECK)
01563         throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
01564 #else
01565         throw();
01566 #endif
01567 
01569         INLINE cvector &SetRe(cvector &iv,const real &r) throw();
01571         INLINE cvector &SetIm(cvector &iv,const real &r) throw();
01573         INLINE cvector_slice &SetRe(cvector_slice &iv,const real &r) throw();
01575         INLINE cvector_slice &SetIm(cvector_slice &iv,const real &r) throw();
01576 
01578         INLINE void Resize(cvector &rv) throw();
01580         INLINE void Resize(cvector &rv, const int &len)
01581 #if(CXSC_INDEX_CHECK)
01582         throw(ERROR__WRONG_BOUNDARIES<cvector>);
01583 #else
01584         throw();
01585 #endif
01586 
01587         INLINE void Resize(cvector &rv, const int &lb, const int &ub)
01588 #if(CXSC_INDEX_CHECK)
01589         throw(ERROR__WRONG_BOUNDARIES<cvector>);
01590 #else
01591         throw();
01592 #endif
01593         
01595         INLINE cvector conj(const cvector &rv) throw();
01597         INLINE cvector conj(const cvector_slice &sl) throw();
01598         
01600         INLINE rvector abs(const cvector &rv) throw();
01602         INLINE rvector abs(const cvector_slice &sl) throw();
01604         INLINE rvector Im(const cvector &v) throw();
01606         INLINE rvector Im(const cvector_slice &v) throw();
01608         INLINE rvector Re(const cvector &v) throw();
01610         INLINE rvector Re(const cvector_slice &v) throw();
01612         INLINE bool operator !(const cvector &rv) throw();
01614         INLINE bool operator !(const cvector_slice &sl) throw();
01615 
01616 //======================= Vector / Scalar ===============================
01617 
01618 //----------------------------- complex ---------------------------
01619 
01621         INLINE cvector operator *(const cvector &rv, const complex &s) throw();
01623         INLINE cvector operator *(const cvector_slice &sl, const complex &s) throw();
01625         INLINE cvector operator *(const complex &s, const cvector &rv) throw();
01627         INLINE cvector operator *(const complex &s, const cvector_slice &sl) throw();
01629         INLINE cvector &operator *=(cvector &rv,const complex &r) throw();
01630 
01632         INLINE cvector operator /(const cvector &rv, const complex &s) throw();
01634         INLINE cvector operator /(const cvector_slice &sl, const complex &s) throw();
01636         INLINE cvector &operator /=(cvector &rv,const complex &r) throw();
01637 
01638 //---------------------------- Real --------------------------------------
01639 
01641         INLINE cvector operator *(const cvector &rv, const real &s) throw();
01643         INLINE cvector operator *(const cvector_slice &sl, const real &s) throw();
01645         INLINE cvector operator *(const real &s, const cvector &rv) throw();
01647         INLINE cvector operator *(const real &s, const cvector_slice &sl) throw();
01649         INLINE cvector &operator *=(cvector &rv,const real &r) throw();
01650 
01652         INLINE cvector operator /(const cvector &rv, const real &s) throw();
01654         INLINE cvector operator /(const cvector_slice &sl, const real &s) throw();
01656         INLINE cvector &operator /=(cvector &rv,const real &r) throw();
01657 
01659         INLINE cvector operator *(const rvector &rv, const complex &s) throw();
01661         INLINE cvector operator *(const rvector_slice &sl, const complex &s) throw();
01663         INLINE cvector operator *(const complex &s, const rvector &rv) throw();
01665         INLINE cvector operator *(const complex &s, const rvector_slice &sl) throw();
01666 
01668         INLINE cvector operator /(const rvector &rv, const complex &s) throw();
01670         INLINE cvector operator /(const rvector_slice &sl, const complex &s) throw();
01671 
01672 //======================= Vector / Vector ===============================
01673 
01674 
01676         INLINE std::ostream &operator <<(std::ostream &s, const cvector &rv) throw();
01678         INLINE std::ostream &operator <<(std::ostream &o, const cvector_slice &sl) throw();
01680         INLINE std::istream &operator >>(std::istream &s, cvector &rv) throw();
01682         INLINE std::istream &operator >>(std::istream &s, cvector_slice &rv) throw();
01683         
01684 //----------------------- complex / complex ---------------------------
01685 
01687         void accumulate(cdotprecision &dp, const cvector &);
01688 
01690         void accumulate(cdotprecision &dp, const rvector &);
01691 
01693         void accumulate(cdotprecision &dp, const cvector & rv1, const cvector &rv2)
01694 #if(CXSC_INDEX_CHECK)
01695         throw(OP_WITH_WRONG_DIM);
01696 #else
01697         throw();
01698 #endif
01699 
01701         void accumulate_approx(cdotprecision &dp, const cvector & rv1, const cvector &rv2);
01702 
01704         void accumulate(cdotprecision &dp, const cvector_slice & sl, const cvector &rv)
01705 #if(CXSC_INDEX_CHECK)
01706         throw(OP_WITH_WRONG_DIM);
01707 #else
01708         throw();
01709 #endif
01710 
01712         void accumulate_approx(cdotprecision &dp, const cvector_slice & sl, const cvector &rv);
01713 
01715         void accumulate(cdotprecision &dp, const cvector &rv, const cvector_slice &sl)
01716 #if(CXSC_INDEX_CHECK)
01717         throw(OP_WITH_WRONG_DIM);
01718 #else
01719         throw();
01720 #endif
01721 
01723         void accumulate_approx(cdotprecision &dp, const cvector &rv, const cvector_slice &sl);
01724 
01726         void accumulate(cdotprecision &dp, const cvector & rv1, const cmatrix_subv &rv2)
01727 #if(CXSC_INDEX_CHECK)
01728         throw(OP_WITH_WRONG_DIM);
01729 #else
01730         throw();
01731 #endif
01732 
01734         void accumulate_approx(cdotprecision &dp, const cvector & rv1, const cmatrix_subv &rv2);
01735 
01737         void accumulate(cdotprecision &dp, const cmatrix_subv & rv1, const cvector &rv2)
01738 #if(CXSC_INDEX_CHECK)
01739         throw(OP_WITH_WRONG_DIM);
01740 #else
01741         throw();
01742 #endif
01743 
01745         void accumulate_approx(cdotprecision &dp, const cmatrix_subv & rv1, const cvector &rv2);
01746 
01748         void accumulate(cdotprecision &dp, const cmatrix_subv & rv1, const cmatrix_subv &rv2)
01749 #if(CXSC_INDEX_CHECK)
01750         throw(OP_WITH_WRONG_DIM);
01751 #else
01752         throw();
01753 #endif
01754 
01756         void accumulate_approx(cdotprecision &dp, const cmatrix_subv & rv1, const cmatrix_subv &rv2);
01757 
01759         void accumulate(cdotprecision &dp, const cvector_slice & sl1, const cvector_slice &sl2)
01760 #if(CXSC_INDEX_CHECK)
01761         throw(OP_WITH_WRONG_DIM);
01762 #else
01763         throw();
01764 #endif
01765 
01767         void accumulate_approx(cdotprecision &dp, const cvector_slice & sl1, const cvector_slice &sl2);
01768 
01770         void accumulate(cidotprecision &dp, const cvector & rv1, const cvector &rv2)
01771 #if(CXSC_INDEX_CHECK)
01772         throw(OP_WITH_WRONG_DIM);
01773 #else
01774         throw();
01775 #endif
01776 
01777         void accumulate(cidotprecision &dp, const cvector_slice & sl, const cvector &rv)
01778 #if(CXSC_INDEX_CHECK)
01779         throw(OP_WITH_WRONG_DIM);
01780 #else
01781         throw();
01782 #endif
01783 
01784         void accumulate(cidotprecision &dp, const cvector &rv, const cvector_slice &sl)
01785 #if(CXSC_INDEX_CHECK)
01786         throw(OP_WITH_WRONG_DIM);
01787 #else
01788         throw();
01789 #endif
01790 
01791         void accumulate(cidotprecision &dp, const cvector & rv1, const cmatrix_subv &rv2)
01792 #if(CXSC_INDEX_CHECK)
01793         throw(OP_WITH_WRONG_DIM);
01794 #else
01795         throw();
01796 #endif
01797 
01798         void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const cvector &rv2)
01799 #if(CXSC_INDEX_CHECK)
01800         throw(OP_WITH_WRONG_DIM);
01801 #else
01802         throw();
01803 #endif
01804 
01805         void accumulate(cidotprecision &dp, const cvector_slice & sl1, const cvector_slice &sl2)
01806 #if(CXSC_INDEX_CHECK)
01807         throw(OP_WITH_WRONG_DIM);
01808 #else
01809         throw();
01810 #endif
01811 
01812         void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const cmatrix_subv &rv2)
01813 #if(CXSC_INDEX_CHECK)
01814         throw(OP_WITH_WRONG_DIM);
01815 #else
01816         throw();
01817 #endif
01818 
01819 
01821         INLINE complex operator *(const cvector & rv1, const cvector &rv2)
01822 #if(CXSC_INDEX_CHECK)
01823         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01824 #else
01825         throw();
01826 #endif
01827 
01828         INLINE complex operator *(const cvector_slice &sl, const cvector &rv)
01829 #if(CXSC_INDEX_CHECK)
01830         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01831 #else
01832         throw();
01833 #endif
01834 
01835         INLINE complex operator *(const cvector &rv, const cvector_slice &sl)
01836 #if(CXSC_INDEX_CHECK)
01837         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01838 #else
01839         throw();
01840 #endif
01841 
01842         INLINE complex operator *(const cvector_slice & sl1, const cvector_slice &sl2)
01843 #if(CXSC_INDEX_CHECK)
01844         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01845 #else
01846         throw();
01847 #endif
01848         
01850         INLINE const cvector &operator +(const cvector &rv) throw();
01852         INLINE cvector operator +(const cvector_slice &sl) throw();
01853 
01855         INLINE cvector operator +(const cvector &rv1, const cvector &rv2)
01856 #if(CXSC_INDEX_CHECK)
01857         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01858 #else
01859         throw();
01860 #endif
01861 
01862         INLINE cvector operator +(const cvector &rv, const cvector_slice &sl)
01863 #if(CXSC_INDEX_CHECK)
01864         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01865 #else
01866         throw();
01867 #endif
01868 
01869         INLINE cvector operator +(const cvector_slice &sl, const cvector &rv)
01870 #if(CXSC_INDEX_CHECK)
01871         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01872 #else
01873         throw();
01874 #endif
01875 
01876         INLINE cvector operator +(const cvector_slice &sl1, const cvector_slice &sl2)
01877 #if(CXSC_INDEX_CHECK)
01878         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01879 #else
01880         throw();
01881 #endif
01882 
01883         INLINE cvector & operator +=(cvector &rv1, const cvector &rv2)
01884 #if(CXSC_INDEX_CHECK)
01885         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01886 #else
01887         throw();
01888 #endif
01889 
01890         INLINE cvector &operator +=(cvector &rv, const cvector_slice &sl)
01891 #if(CXSC_INDEX_CHECK)
01892         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01893 #else
01894         throw();
01895 #endif
01896 
01898         INLINE cvector operator -(const cvector &rv) throw();
01900         INLINE cvector operator -(const cvector_slice &sl) throw();
01902         INLINE cvector operator -(const cvector &rv1, const cvector &rv2)
01903 #if(CXSC_INDEX_CHECK)
01904         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01905 #else
01906         throw();
01907 #endif
01908 
01909         INLINE cvector operator -(const cvector &rv, const cvector_slice &sl)
01910 #if(CXSC_INDEX_CHECK)
01911         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01912 #else
01913         throw();
01914 #endif
01915 
01916         INLINE cvector operator -(const cvector_slice &sl, const cvector &rv)
01917 #if(CXSC_INDEX_CHECK)
01918         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01919 #else
01920         throw();
01921 #endif
01922 
01923         INLINE cvector operator -(const cvector_slice &sl1, const cvector_slice &sl2)
01924 #if(CXSC_INDEX_CHECK)
01925         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01926 #else
01927         throw();
01928 #endif
01929 
01930         INLINE cvector & operator -=(cvector &rv1, const cvector &rv2)
01931 #if(CXSC_INDEX_CHECK)
01932         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01933 #else
01934         throw();
01935 #endif
01936 
01937         INLINE cvector &operator -=(cvector &rv, const cvector_slice &sl)
01938 #if(CXSC_INDEX_CHECK)
01939         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
01940 #else
01941         throw();
01942 #endif
01943 
01945         INLINE bool operator ==(const cvector &rv1, const cvector &rv2) throw();
01947         INLINE bool operator ==(const cvector_slice &sl1, const cvector_slice &sl2) throw();
01949         INLINE bool operator ==(const cvector_slice &sl, const cvector &rv) throw();
01951         INLINE bool operator ==(const cvector &rv, const cvector_slice &sl) throw();
01953         INLINE bool operator !=(const cvector &rv1, const cvector &rv2) throw();
01955         INLINE bool operator !=(const cvector_slice &sl1, const cvector_slice &sl2) throw();
01957         INLINE bool operator !=(const cvector_slice &sl, const cvector &rv) throw();
01959         INLINE bool operator !=(const cvector &rv, const cvector_slice &sl) throw();
01960 /*      INLINE bool operator <(const cvector &rv1, const cvector &rv2) throw();
01961         INLINE bool operator <(const cvector_slice &sl1, const cvector_slice &sl2) throw();
01962         INLINE bool operator < (const cvector_slice &sl, const cvector &rv) throw();
01963         INLINE bool operator < (const cvector &rv, const cvector_slice &sl) throw();
01964         INLINE bool operator <=(const cvector &rv1, const cvector &rv2) throw();
01965         INLINE bool operator <=(const cvector_slice &sl1, const cvector_slice &sl2) throw();
01966         INLINE bool operator <=(const cvector_slice &sl, const cvector &rv) throw();
01967         INLINE bool operator <=(const cvector &rv, const cvector_slice &sl) throw();
01968         INLINE bool operator >(const cvector &rv1, const cvector &rv2) throw();
01969         INLINE bool operator >(const cvector_slice &sl1, const cvector_slice &sl2) throw();
01970         INLINE bool operator >(const cvector_slice &sl, const cvector &rv) throw();
01971         INLINE bool operator >(const cvector &rv, const cvector_slice &sl) throw();
01972         INLINE bool operator >=(const cvector &rv1, const cvector &rv2) throw();
01973         INLINE bool operator >=(const cvector_slice &sl1, const cvector_slice &sl2) throw();
01974         INLINE bool operator >=(const cvector_slice &sl, const cvector &rv) throw();
01975         INLINE bool operator >=(const cvector &rv, const cvector_slice &sl) throw();
01976 */
01977 //-------------------------------- complex / Real --------------------------------
01978 
01979 
01981         void accumulate(cdotprecision &dp, const cvector & rv1, const rvector &rv2)
01982 #if(CXSC_INDEX_CHECK)
01983         throw(OP_WITH_WRONG_DIM);
01984 #else
01985         throw();
01986 #endif
01987 
01989         void accumulate_approx(cdotprecision &dp, const cvector & rv1, const rvector &rv2);
01990 
01991 
01993         void accumulate(cdotprecision &dp, const rvector & rv1, const cvector &rv2)
01994 #if(CXSC_INDEX_CHECK)
01995         throw(OP_WITH_WRONG_DIM);
01996 #else
01997         throw();
01998 #endif
01999 
02001         void accumulate_approx(cdotprecision &dp, const rvector & rv1, const cvector &rv2);
02002 
02004         void accumulate(cdotprecision &dp, const rvector_slice & sl, const cvector &rv)
02005 #if(CXSC_INDEX_CHECK)
02006         throw(OP_WITH_WRONG_DIM);
02007 #else
02008         throw();
02009 #endif
02010 
02012         void accumulate_approx(cdotprecision &dp, const rvector_slice & sl, const cvector &rv);
02013 
02015         void accumulate(cdotprecision &dp,const cvector_slice &sl,const rvector &rv)
02016 #if(CXSC_INDEX_CHECK)
02017         throw(OP_WITH_WRONG_DIM);
02018 #else
02019         throw();
02020 #endif
02021 
02023         void accumulate_approx(cdotprecision &dp,const cvector_slice &sl,const rvector &rv);
02024 
02026         void accumulate(cdotprecision &dp, const rvector &rv, const cvector_slice &sl)
02027 #if(CXSC_INDEX_CHECK)
02028         throw(OP_WITH_WRONG_DIM);
02029 #else
02030         throw();
02031 #endif
02032 
02034         void accumulate_approx(cdotprecision &dp, const rvector &rv, const cvector_slice &sl);
02035 
02037         void accumulate(cdotprecision &dp, const rvector & rv1, const cmatrix_subv &rv2)
02038 #if(CXSC_INDEX_CHECK)
02039         throw(OP_WITH_WRONG_DIM);
02040 #else
02041         throw();
02042 #endif
02043 
02045         void accumulate_approx(cdotprecision &dp, const rvector & rv1, const cmatrix_subv &rv2);
02046 
02048         void accumulate(cdotprecision &dp, const cvector & rv1, const rmatrix_subv &rv2)
02049 #if(CXSC_INDEX_CHECK)
02050         throw(OP_WITH_WRONG_DIM);
02051 #else
02052         throw();
02053 #endif
02054 
02056         void accumulate_approx(cdotprecision &dp, const cvector & rv1, const rmatrix_subv &rv2);
02057 
02059         void accumulate(cdotprecision &dp, const rvector_slice & rv1, const cmatrix_subv &rv2)
02060 #if(CXSC_INDEX_CHECK)
02061         throw(OP_WITH_WRONG_DIM);
02062 #else
02063         throw();
02064 #endif
02065 
02067         void accumulate_approx(cdotprecision &dp, const rvector_slice & rv1, const cmatrix_subv &rv2);
02068 
02070         void accumulate(cdotprecision &dp, const cvector_slice & rv1, const rmatrix_subv &rv2)
02071 #if(CXSC_INDEX_CHECK)
02072         throw(OP_WITH_WRONG_DIM);
02073 #else
02074         throw();
02075 #endif
02076 
02078         void accumulate_approx(cdotprecision &dp, const cvector_slice & rv1, const rmatrix_subv &rv2);
02079 
02081         void accumulate(cdotprecision &dp,const cvector &rv,const rvector_slice &sl)
02082 #if(CXSC_INDEX_CHECK)
02083         throw(OP_WITH_WRONG_DIM);
02084 #else
02085         throw();
02086 #endif
02087 
02089         void accumulate_approx(cdotprecision &dp,const cvector &rv,const rvector_slice &sl);
02090 
02092         void accumulate(cdotprecision &dp, const rmatrix_subv & rv1, const cvector &rv2)
02093 #if(CXSC_INDEX_CHECK)
02094         throw(OP_WITH_WRONG_DIM);
02095 #else
02096         throw();
02097 #endif
02098 
02100         void accumulate_approx(cdotprecision &dp, const rmatrix_subv & rv1, const cvector &rv2);
02101 
02103         void accumulate(cdotprecision &dp, const cmatrix_subv & rv1, const rvector &rv2)
02104 #if(CXSC_INDEX_CHECK)
02105         throw(OP_WITH_WRONG_DIM);
02106 #else
02107         throw();
02108 #endif
02109 
02111         void accumulate_approx(cdotprecision &dp, const cmatrix_subv & rv1, const rvector &rv2);
02112 
02114         void accumulate(cdotprecision &dp, const rmatrix_subv & rv1, const cvector_slice &rv2)
02115 #if(CXSC_INDEX_CHECK)
02116         throw(OP_WITH_WRONG_DIM);
02117 #else
02118         throw();
02119 #endif
02120 
02122         void accumulate_approx(cdotprecision &dp, const rmatrix_subv & rv1, const cvector_slice &rv2);
02123 
02125         void accumulate(cdotprecision &dp, const cmatrix_subv & rv1, const rvector_slice &rv2)
02126 #if(CXSC_INDEX_CHECK)
02127         throw(OP_WITH_WRONG_DIM);
02128 #else
02129         throw();
02130 #endif
02131 
02133         void accumulate_approx(cdotprecision &dp, const cmatrix_subv & rv1, const rvector_slice &rv2);
02134 
02136         void accumulate(cdotprecision &dp, const cvector_slice & sl1, const rvector_slice &sl2)
02137 #if(CXSC_INDEX_CHECK)
02138         throw(OP_WITH_WRONG_DIM);
02139 #else
02140         throw();
02141 #endif
02142 
02144         void accumulate_approx(cdotprecision &dp, const cvector_slice & sl1, const rvector_slice &sl2);
02145 
02147         void accumulate(cdotprecision &dp, const rvector_slice & sl1, const cvector_slice &sl2)
02148 #if(CXSC_INDEX_CHECK)
02149         throw(OP_WITH_WRONG_DIM);
02150 #else
02151         throw();
02152 #endif
02153 
02155         void accumulate_approx(cdotprecision &dp, const rvector_slice & sl1, const cvector_slice &sl2);
02156 
02158         void accumulate(cdotprecision &dp, const rmatrix_subv & rv1, const cmatrix_subv &rv2)
02159 #if(CXSC_INDEX_CHECK)
02160         throw(OP_WITH_WRONG_DIM);
02161 #else
02162         throw();
02163 #endif
02164 
02166         void accumulate_approx(cdotprecision &dp, const rmatrix_subv & rv1, const cmatrix_subv &rv2);
02167 
02169         void accumulate(cdotprecision &dp, const cmatrix_subv & rv1, const rmatrix_subv &rv2)
02170 #if(CXSC_INDEX_CHECK)
02171         throw(OP_WITH_WRONG_DIM);
02172 #else
02173         throw();
02174 #endif
02175 
02177         void accumulate_approx(cdotprecision &dp, const cmatrix_subv & rv1, const rmatrix_subv &rv2);
02178 
02180         void accumulate(cidotprecision &dp, const cvector & rv1, const rvector &rv2)
02181 #if(CXSC_INDEX_CHECK)
02182         throw(OP_WITH_WRONG_DIM);
02183 #else
02184         throw();
02185 #endif
02186 
02187         void accumulate(cidotprecision &dp, const rvector & rv1, const cvector &rv2)
02188 #if(CXSC_INDEX_CHECK)
02189         throw(OP_WITH_WRONG_DIM);
02190 #else
02191         throw();
02192 #endif
02193 
02194         void accumulate(cidotprecision &dp, const rvector_slice & sl, const cvector &rv)
02195 #if(CXSC_INDEX_CHECK)
02196         throw(OP_WITH_WRONG_DIM);
02197 #else
02198         throw();
02199 #endif
02200 
02201         void accumulate(cidotprecision &dp,const cvector_slice &sl,const rvector &rv)
02202 #if(CXSC_INDEX_CHECK)
02203         throw(OP_WITH_WRONG_DIM);
02204 #else
02205         throw();
02206 #endif
02207 
02208         void accumulate(cidotprecision &dp, const rvector &rv, const cvector_slice &sl)
02209 #if(CXSC_INDEX_CHECK)
02210         throw(OP_WITH_WRONG_DIM);
02211 #else
02212         throw();
02213 #endif
02214 
02215         void accumulate(cidotprecision &dp, const rvector & rv1, const cmatrix_subv &rv2)
02216 #if(CXSC_INDEX_CHECK)
02217         throw(OP_WITH_WRONG_DIM);
02218 #else
02219         throw();
02220 #endif
02221 
02222         void accumulate(cidotprecision &dp, const cvector & rv1, const rmatrix_subv &rv2)
02223 #if(CXSC_INDEX_CHECK)
02224         throw(OP_WITH_WRONG_DIM);
02225 #else
02226         throw();
02227 #endif
02228 
02229         void accumulate(cidotprecision &dp, const rvector_slice & rv1, const cmatrix_subv &rv2)
02230 #if(CXSC_INDEX_CHECK)
02231         throw(OP_WITH_WRONG_DIM);
02232 #else
02233         throw();
02234 #endif
02235 
02236         void accumulate(cidotprecision &dp, const cvector_slice & rv1, const rmatrix_subv &rv2)
02237 #if(CXSC_INDEX_CHECK)
02238         throw(OP_WITH_WRONG_DIM);
02239 #else
02240         throw();
02241 #endif
02242 
02243         void accumulate(cidotprecision &dp,const cvector &rv,const rvector_slice &sl)
02244 #if(CXSC_INDEX_CHECK)
02245         throw(OP_WITH_WRONG_DIM);
02246 #else
02247         throw();
02248 #endif
02249 
02250         void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const cvector &rv2)
02251 #if(CXSC_INDEX_CHECK)
02252         throw(OP_WITH_WRONG_DIM);
02253 #else
02254         throw();
02255 #endif
02256 
02257         void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const rvector &rv2)
02258 #if(CXSC_INDEX_CHECK)
02259         throw(OP_WITH_WRONG_DIM);
02260 #else
02261         throw();
02262 #endif
02263 
02264         void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const cvector_slice &rv2)
02265 #if(CXSC_INDEX_CHECK)
02266         throw(OP_WITH_WRONG_DIM);
02267 #else
02268         throw();
02269 #endif
02270 
02271         void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const rvector_slice &rv2)
02272 #if(CXSC_INDEX_CHECK)
02273         throw(OP_WITH_WRONG_DIM);
02274 #else
02275         throw();
02276 #endif
02277 
02278         void accumulate(cidotprecision &dp, const cvector_slice & sl1, const rvector_slice &sl2)
02279 #if(CXSC_INDEX_CHECK)
02280         throw(OP_WITH_WRONG_DIM);
02281 #else
02282         throw();
02283 #endif
02284 
02285         void accumulate(cidotprecision &dp, const rvector_slice & sl1, const cvector_slice &sl2)
02286 #if(CXSC_INDEX_CHECK)
02287         throw(OP_WITH_WRONG_DIM);
02288 #else
02289         throw();
02290 #endif
02291 
02292         void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const cmatrix_subv &rv2)
02293 #if(CXSC_INDEX_CHECK)
02294         throw(OP_WITH_WRONG_DIM);
02295 #else
02296         throw();
02297 #endif
02298 
02299         void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const rmatrix_subv &rv2)
02300 #if(CXSC_INDEX_CHECK)
02301         throw(OP_WITH_WRONG_DIM);
02302 #else
02303         throw();
02304 #endif
02305 
02306         void accumulate(cidotprecision &dp, const cvector_slice &, const ivector &)
02307 #if(CXSC_INDEX_CHECK)
02308         throw(OP_WITH_WRONG_DIM);
02309 #else
02310         throw();
02311 #endif
02312 
02313         void accumulate(cidotprecision &dp, const ivector & sl1, const cvector_slice &)
02314 #if(CXSC_INDEX_CHECK)
02315         throw(OP_WITH_WRONG_DIM);
02316 #else
02317         throw();
02318 #endif
02319 
02320         void accumulate(cidotprecision &dp, const cvector &, const ivector &)
02321 #if(CXSC_INDEX_CHECK)
02322         throw(OP_WITH_WRONG_DIM);
02323 #else
02324         throw();
02325 #endif
02326 
02327         void accumulate(cidotprecision &dp, const ivector &, const cvector &)
02328 #if(CXSC_INDEX_CHECK)
02329         throw(OP_WITH_WRONG_DIM);
02330 #else
02331         throw();
02332 #endif
02333 
02334         void accumulate(cidotprecision &dp, const ivector_slice &, const cvector &)
02335 #if(CXSC_INDEX_CHECK)
02336         throw(OP_WITH_WRONG_DIM);
02337 #else
02338         throw();
02339 #endif
02340 
02341         void accumulate(cidotprecision &dp, const cvector &, const ivector_slice &)
02342 #if(CXSC_INDEX_CHECK)
02343         throw(OP_WITH_WRONG_DIM);
02344 #else
02345         throw();
02346 #endif
02347 
02348         void accumulate(cidotprecision &dp, const cvector_slice &, const ivector_slice &)
02349 #if(CXSC_INDEX_CHECK)
02350         throw(OP_WITH_WRONG_DIM);
02351 #else
02352         throw();
02353 #endif
02354 
02355         void accumulate(cidotprecision &dp, const ivector_slice &, const cvector_slice &)
02356 #if(CXSC_INDEX_CHECK)
02357         throw(OP_WITH_WRONG_DIM);
02358 #else
02359         throw();
02360 #endif
02361 
02363         INLINE complex operator *(const rvector & rv1, const cvector &rv2)
02364 #if(CXSC_INDEX_CHECK)
02365         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
02366 #else
02367         throw();
02368 #endif
02369 
02370         INLINE complex operator *(const rvector_slice &sl, const cvector &rv)
02371 #if(CXSC_INDEX_CHECK)
02372         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
02373 #else
02374         throw();
02375 #endif
02376 
02377         INLINE complex operator *(const rvector &rv, const cvector_slice &sl)
02378 #if(CXSC_INDEX_CHECK)
02379         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
02380 #else
02381         throw();
02382 #endif
02383 
02384         INLINE complex operator *(const rvector_slice & sl1, const cvector_slice &sl2)
02385 #if(CXSC_INDEX_CHECK)
02386         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
02387 #else
02388         throw();
02389 #endif
02390         
02392         INLINE complex operator *(const cvector & rv1, const rvector &rv2)
02393 #if(CXSC_INDEX_CHECK)
02394         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
02395 #else
02396         throw();
02397 #endif
02398 
02399         INLINE complex operator *(const cvector_slice &sl, const rvector &rv)
02400 #if(CXSC_INDEX_CHECK)
02401         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
02402 #else
02403         throw();
02404 #endif
02405 
02406         INLINE complex operator *(const cvector &rv, const rvector_slice &sl)
02407 #if(CXSC_INDEX_CHECK)
02408         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
02409 #else
02410         throw();
02411 #endif
02412 
02413         INLINE complex operator *(const cvector_slice & sl1, const rvector_slice &sl2)
02414 #if(CXSC_INDEX_CHECK)
02415         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
02416 #else
02417         throw();
02418 #endif
02419         
02421         INLINE cvector operator +(const rvector &rv1, const cvector &rv2)
02422 #if(CXSC_INDEX_CHECK)
02423         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
02424 #else
02425         throw();
02426 #endif
02427 
02428         INLINE cvector operator +(const rvector &rv, const cvector_slice &sl)
02429 #if(CXSC_INDEX_CHECK)
02430         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
02431 #else
02432         throw();
02433 #endif
02434 
02435         INLINE cvector operator +(const rvector_slice &sl, const cvector &rv)
02436 #if(CXSC_INDEX_CHECK)
02437         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
02438 #else
02439         throw();
02440 #endif
02441 
02442         INLINE cvector operator +(const rvector_slice &sl1, const cvector_slice &sl2)
02443 #if(CXSC_INDEX_CHECK)
02444         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
02445 #else
02446         throw();
02447 #endif
02448 
02450         INLINE cvector operator +(const cvector &rv1, const rvector &rv2)
02451 #if(CXSC_INDEX_CHECK)
02452         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
02453 #else
02454         throw();
02455 #endif
02456 
02457         INLINE cvector operator +(const cvector &rv, const rvector_slice &sl)
02458 #if(CXSC_INDEX_CHECK)
02459         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
02460 #else
02461         throw();
02462 #endif
02463 
02464         INLINE cvector operator +(const cvector_slice &sl, const rvector &rv)
02465 #if(CXSC_INDEX_CHECK)
02466         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
02467 #else
02468         throw();
02469 #endif
02470 
02471         INLINE cvector operator +(const cvector_slice &sl1, const rvector_slice &sl2)
02472 #if(CXSC_INDEX_CHECK)
02473         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
02474 #else
02475         throw();
02476 #endif
02477 
02479         INLINE cvector & operator +=(cvector &rv1, const rvector &rv2)
02480 #if(CXSC_INDEX_CHECK)
02481         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
02482 #else
02483         throw();
02484 #endif
02485 
02486         INLINE cvector &operator +=(cvector &rv, const rvector_slice &sl)
02487 #if(CXSC_INDEX_CHECK)
02488         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
02489 #else
02490         throw();
02491 #endif
02492 
02494         INLINE cvector operator -(const rvector &rv1, const cvector &rv2)
02495 #if(CXSC_INDEX_CHECK)
02496         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
02497 #else
02498         throw();
02499 #endif
02500 
02501         INLINE cvector operator -(const rvector &rv, const cvector_slice &sl)
02502 #if(CXSC_INDEX_CHECK)
02503         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
02504 #else
02505         throw();
02506 #endif
02507 
02508         INLINE cvector operator -(const rvector_slice &sl, const cvector &rv)
02509 #if(CXSC_INDEX_CHECK)
02510         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
02511 #else
02512         throw();
02513 #endif
02514 
02515         INLINE cvector operator -(const rvector_slice &sl1, const cvector_slice &sl2)
02516 #if(CXSC_INDEX_CHECK)
02517         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
02518 #else
02519         throw();
02520 #endif
02521 
02523         INLINE cvector operator -(const cvector &rv1, const rvector &rv2)
02524 #if(CXSC_INDEX_CHECK)
02525         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
02526 #else
02527         throw();
02528 #endif
02529 
02530         INLINE cvector operator -(const cvector &rv, const rvector_slice &sl)
02531 #if(CXSC_INDEX_CHECK)
02532         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
02533 #else
02534         throw();
02535 #endif
02536 
02537         INLINE cvector operator -(const cvector_slice &sl, const rvector &rv)
02538 #if(CXSC_INDEX_CHECK)
02539         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
02540 #else
02541         throw();
02542 #endif
02543 
02544         INLINE cvector operator -(const cvector_slice &sl1, const rvector_slice &sl2)
02545 #if(CXSC_INDEX_CHECK)
02546         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
02547 #else
02548         throw();
02549 #endif
02550 
02551         INLINE cvector & operator -=(cvector &rv1, const rvector &rv2)
02552 #if(CXSC_INDEX_CHECK)
02553         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
02554 #else
02555         throw();
02556 #endif
02557 
02558         INLINE cvector &operator -=(cvector &rv, const rvector_slice &sl)
02559 #if(CXSC_INDEX_CHECK)
02560         throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
02561 #else
02562         throw();
02563 #endif
02564 
02565 } // namespace cxsc 
02566 
02567 #ifdef _CXSC_INCL_INL
02568 #include "vector.inl"
02569 #include "cvector.inl"
02570 #endif
02571                 
02572 #ifdef _CXSC_RMATRIX_HPP_INCLUDED
02573 # ifdef _CXSC_INCL_INL
02574 #  include "cvecrmat.inl"
02575 # else
02576 #  include "cvecrmat.hpp"
02577 # endif
02578 #endif
02579 
02580 #ifdef _CXSC_IMATRIX_HPP_INCLUDED
02581 # ifdef _CXSC_INCL_INL
02582 #  include "cvecimat.inl"
02583 # else
02584 #  include "cvecimat.hpp"
02585 # endif
02586 #endif
02587 
02588 #ifdef _CXSC_IVECTOR_HPP_INCLUDED
02589 # ifdef _CXSC_INCL_INL
02590 #  include "iveccvec.inl"
02591 # else
02592 #  include "iveccvec.hpp"
02593 # endif
02594 #endif
02595 
02596 #ifdef CXSC_USE_BLAS
02597 #define _CXSC_BLAS_CVECTOR
02598 #include "cxsc_blas.inl"
02599 #endif
02600 
02601 
02602 #endif