C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
civector.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: civector.hpp,v 1.39 2014/01/30 17:23:44 cxsc Exp $ */
00025 
00026 #ifndef _CXSC_CIVECTOR_HPP_INCLUDED
00027 #define _CXSC_CIVECTOR_HPP_INCLUDED
00028 
00029 #include "xscclass.hpp"
00030 #include "except.hpp"
00031 #include "cidot.hpp"
00032 #include "cinterval.hpp" // used for declaration of Inf, Sup,...
00033 //#include "cxscmatr.hpp"
00034 #include "rvector.hpp"
00035 #include "ivector.hpp"
00036 #include "cvector.hpp"
00037 #include "vector.hpp"
00038 
00039 
00040 #include <iostream>
00041 
00042 //#include "matrix.hpp" // hat hier eigentlich nichts zu suchen, sonst aber Internal Compiler Error #9
00043 
00044 namespace cxsc {
00045 
00046 class civector_slice;
00047 class scivector;
00048 class scivector_slice;
00049 
00051 
00056 class civector
00057 {
00058         friend class civector_slice;
00059         friend class cimatrix;
00060         friend class cimatrix_subv;
00061         private:
00062         cinterval *dat;
00063         int l,u,size;
00064 
00065         public:
00066 //#if(CXSC_INDEX_CHECK)
00067 #ifdef _CXSC_FRIEND_TPL
00068         //------------ Templates --------------------------------------------------
00069         // cinterval
00070 template <class V,class MS,class S> friend  void _vmsconstr(V &v,const MS &m)
00071 #if(CXSC_INDEX_CHECK)
00072         throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>);
00073 #else
00074         throw();
00075 #endif
00076 template <class V,class M,class S> friend  void _vmconstr(V &v,const M &m)
00077 #if(CXSC_INDEX_CHECK)
00078         throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
00079 #else
00080         throw();
00081 #endif
00082  template <class V> friend       void _vresize(V &rv) throw();
00083  template <class V,class S> friend       void _vresize(V &rv, const int &len)
00084 #if(CXSC_INDEX_CHECK)
00085                 throw(ERROR__WRONG_BOUNDARIES<V>);
00086 #else
00087         throw();
00088 #endif
00089  template <class V,class S> friend       void _vresize(V &rv, const int &lb, const int &ub)
00090 #if(CXSC_INDEX_CHECK)
00091                 throw(ERROR__WRONG_BOUNDARIES<V>);
00092 #else
00093         throw();
00094 #endif
00095  template <class V1,class V2,class S> friend     V1 &_vvassign(V1 &rv1,const V2 &rv2) throw();
00096  template <class V,class S> friend       V & _vsassign(V &rv,const S &r) throw();
00097  template <class V,class VS,class S> friend      V & _vvsassign(V &rv,const VS &sl) throw();
00098  template <class VS,class V> friend      VS & _vsvassign(VS &sl,const V &rv)
00099 #if(CXSC_INDEX_CHECK)
00100                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00101 #else
00102         throw();
00103 #endif
00104 template <class V,class M,class S> friend  V &_vmassign(V &v,const M &m)
00105 #if(CXSC_INDEX_CHECK)
00106         throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
00107 #else
00108         throw();
00109 #endif
00110 template <class M,class V,class S> friend  M &_mvassign(M &m,const V &v) throw();
00111  template <class V1,class V2> friend     V1 &_vvsetinf(V1 &rv1, const V2 &rv2)
00112 #if(CXSC_INDEX_CHECK)
00113                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00114 #else
00115         throw();
00116 #endif
00117  template <class V1,class V2> friend     V1 &_vvsetsup(V1 &rv1, const V2 &rv2)
00118 #if(CXSC_INDEX_CHECK)
00119                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00120 #else
00121         throw();
00122 #endif
00123  template <class V,class VS> friend      V &_vvssetinf(V &rv, const VS &sl)
00124 #if(CXSC_INDEX_CHECK)
00125                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00126 #else
00127         throw();
00128 #endif
00129  template <class V,class VS> friend      V &_vvssetsup(V &rv, const VS &sl)
00130 #if(CXSC_INDEX_CHECK)
00131                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00132 #else
00133         throw();
00134 #endif
00135 template <class V,class MV> friend  V &_vmvsetinf(V &rv,const MV &v)
00136 #if(CXSC_INDEX_CHECK)
00137         throw(ERROR__OP_WITH_WRONG_DIM<V>);
00138 #else
00139         throw();
00140 #endif
00141 template <class V,class MV> friend  V &_vmvsetsup(V &rv,const MV &v)
00142 #if(CXSC_INDEX_CHECK)
00143         throw(ERROR__OP_WITH_WRONG_DIM<V>);
00144 #else
00145         throw();
00146 #endif
00147  template <class V1,class V2> friend     V1 &_vvusetinf(V1 &rv1, const V2 &rv2)
00148 #if(CXSC_INDEX_CHECK)
00149                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00150 #else
00151         throw();
00152 #endif
00153  template <class V1,class V2> friend     V1 &_vvusetsup(V1 &rv1, const V2 &rv2)
00154 #if(CXSC_INDEX_CHECK)
00155                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00156 #else
00157         throw();
00158 #endif
00159  template <class V,class VS> friend      V &_vvsusetinf(V &rv, const VS &sl)
00160 #if(CXSC_INDEX_CHECK)
00161                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00162 #else
00163         throw();
00164 #endif
00165  template <class V,class VS> friend      V &_vvsusetsup(V &rv, const VS &sl)
00166 #if(CXSC_INDEX_CHECK)
00167                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00168 #else
00169         throw();
00170 #endif
00171 template <class V,class MV> friend  V &_vmvusetinf(V &rv,const MV &v)
00172 #if(CXSC_INDEX_CHECK)
00173         throw(ERROR__OP_WITH_WRONG_DIM<V>);
00174 #else
00175         throw();
00176 #endif
00177 template <class V,class MV> friend  V &_vmvusetsup(V &rv,const MV &v)
00178 #if(CXSC_INDEX_CHECK)
00179         throw(ERROR__OP_WITH_WRONG_DIM<V>);
00180 #else
00181         throw();
00182 #endif
00183  template <class V,class S> friend       V &_vssetinf(V &v, const S &s) throw();
00184  template <class V,class S> friend       V &_vssetsup(V &v, const S &s) throw();
00185  template <class V,class S> friend       V &_vsusetinf(V &v, const S &s) throw();
00186  template <class V,class S> friend       V &_vsusetsup(V &v, const S &s) throw();
00187  template <class V,class S> friend       V &_vssetim(V &v, const S &s) throw();
00188  template <class V,class S> friend       V &_vssetre(V &v, const S &s) throw();
00189  template <class V> friend       V _vconj(const V &rv) throw();
00190  template <class VS,class E> friend      E _vsconj(const VS &sl) throw();
00191  template <class V,class E> friend       E _vabs(const V &rv) throw();
00192  template <class VS,class E> friend      E _vsabs(const VS &sl) throw();
00193 template <class MV,class V> friend  V _mvabs(const MV &mv) throw();
00194  template <class V,class E> friend       E _vdiam(const V &rv) throw();
00195  template <class V,class E> friend       E _vmid(const V &rv) throw();
00196  template <class V,class E> friend       E _vinf(const V &rv) throw();
00197  template <class V,class E> friend       E _vsup(const V &rv) throw();
00198  template <class V,class E> friend       E _vim(const V &rv) throw();
00199  template <class V,class E> friend       E _vre(const V &rv) throw();
00200         friend INLINE ivector Re(const civector &v) throw();
00201         friend INLINE ivector Im(const civector &v) throw();
00202         friend INLINE cvector Inf(const civector &v) throw();
00203         friend INLINE cvector Sup(const civector &v) throw();
00204         friend INLINE rvector SupRe(const civector &v) throw();
00205         friend INLINE rvector SupIm(const civector &v) throw();
00206         friend INLINE rvector InfRe(const civector &v) throw();
00207         friend INLINE rvector InfIm(const civector &v) throw();
00208  template <class V1,class V2> friend     V1 &_vvsetim(V1 &rv1, const V2 &rv2)
00209 #if(CXSC_INDEX_CHECK)
00210                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00211 #else
00212         throw();
00213 #endif
00214  template <class V1,class V2> friend     V1 &_vvsetre(V1 &rv1, const V2 &rv2)
00215 #if(CXSC_INDEX_CHECK)
00216                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00217 #else
00218         throw();
00219 #endif
00220  template <class V,class VS> friend      V &_vvssetim(V &rv, const VS &sl)
00221 #if(CXSC_INDEX_CHECK)
00222                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00223 #else
00224         throw();
00225 #endif
00226  template <class V,class VS> friend      V &_vvssetre(V &rv, const VS &sl)
00227 #if(CXSC_INDEX_CHECK)
00228                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00229 #else
00230         throw();
00231 #endif
00232 template <class V,class MV> friend  V &_vmvsetim(V &rv,const MV &v)
00233 #if(CXSC_INDEX_CHECK)
00234         throw(ERROR__OP_WITH_WRONG_DIM<V>);
00235 #else
00236         throw();
00237 #endif
00238 template <class V,class MV> friend  V &_vmvsetre(V &rv,const MV &v)
00239 #if(CXSC_INDEX_CHECK)
00240         throw(ERROR__OP_WITH_WRONG_DIM<V>);
00241 #else
00242         throw();
00243 #endif
00244 
00245 //-------- vector-vector -----------------------
00246  template <class DP,class V1,class V2> friend    void _vvaccu(DP &dp, const V1 & rv1, const V2 &rv2)
00247 #if(CXSC_INDEX_CHECK)
00248                 throw(OP_WITH_WRONG_DIM);
00249 #else
00250         throw();
00251 #endif
00252  template <class DP,class VS,class V> friend     void _vsvaccu(DP &dp, const VS & sl, const V &rv)
00253 #if(CXSC_INDEX_CHECK)
00254                 throw(OP_WITH_WRONG_DIM);
00255 #else
00256         throw();
00257 #endif
00258 
00259  template <class V1,class V2,class E> friend     E _vvcimult(const V1 & rv1, const V2 &rv2)
00260 #if(CXSC_INDEX_CHECK)
00261                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00262 #else
00263         throw();
00264 #endif
00265  template <class VS,class V,class E> friend      E _vsvcimult(const VS & sl, const V &rv)
00266 #if(CXSC_INDEX_CHECK)
00267                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00268 #else
00269         throw();
00270 #endif
00271         
00272  template <class V,class S> friend       V &_vsmultassign(V &rv,const S &r) throw();
00273  template <class V1,class V2,class E> friend     E _vvplus(const V1 &rv1, const V2 &rv2)
00274 #if(CXSC_INDEX_CHECK)
00275                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00276 #else
00277         throw();
00278 #endif
00279  template <class V,class VS,class E> friend      E _vvsplus(const V &rv,const VS &sl)
00280 #if(CXSC_INDEX_CHECK)
00281                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00282 #else
00283         throw();
00284 #endif
00285  template <class VS1,class VS2,class E> friend   E _vsvsplus(const VS1 &s1,const VS2 &s2)
00286 #if(CXSC_INDEX_CHECK)
00287                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00288 #else
00289         throw();
00290 #endif
00291  template <class VS1,class VS2,class E> friend   E _vsvsminus(const VS1 &s1,const VS2 &s2)
00292 #if(CXSC_INDEX_CHECK)
00293                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00294 #else
00295         throw();
00296 #endif
00297  template <class V1,class V2> friend     V1 &_vvplusassign(V1 &rv1, const V2 &rv2)
00298 #if(CXSC_INDEX_CHECK)
00299                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00300 #else
00301         throw();
00302 #endif
00303  template <class V,class VS> friend      V &_vvsplusassign(V &rv, const VS &sl)
00304 #if(CXSC_INDEX_CHECK)
00305                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00306 #else
00307         throw();
00308 #endif
00309  template <class VS,class V> friend      VS &_vsvplusassign(VS &sl, const V &rv)
00310 #if(CXSC_INDEX_CHECK)
00311                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00312 #else
00313         throw();
00314 #endif
00315  template <class VS1,class VS2> friend   VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
00316 #if(CXSC_INDEX_CHECK)
00317                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00318 #else
00319         throw();
00320 #endif
00321  template <class VS1,class VS2> friend   VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
00322 #if(CXSC_INDEX_CHECK)
00323                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00324 #else
00325         throw();
00326 #endif
00327  template <class V1,class V2> friend     V1 &_vvminusassign(V1 &rv1, const V2 &rv2)
00328 #if(CXSC_INDEX_CHECK)
00329                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00330 #else
00331         throw();
00332 #endif
00333  template <class V,class VS> friend      V &_vvsminusassign(V &rv, const VS &sl)
00334 #if(CXSC_INDEX_CHECK)
00335                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00336 #else
00337         throw();
00338 #endif
00339  template <class VS,class V> friend      VS &_vsvminusassign(VS &sl, const V &rv)
00340 #if(CXSC_INDEX_CHECK)
00341                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00342 #else
00343         throw();
00344 #endif
00345  template <class V> friend       V _vminus(const V &rv) throw();
00346  template <class VS,class V> friend      V _vsminus(const VS &sl) throw();
00347  template <class V1,class V2,class E> friend     E _vvminus(const V1 &rv1, const V2 &rv2)
00348 #if(CXSC_INDEX_CHECK)
00349                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00350 #else
00351         throw();
00352 #endif
00353  template <class V,class VS,class E> friend      E _vvsminus(const V &rv, const VS &sl)
00354 #if(CXSC_INDEX_CHECK)
00355                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00356 #else
00357         throw();
00358 #endif
00359  template <class VS,class V,class E> friend      E _vsvminus(const VS &sl,const V &rv)
00360 #if(CXSC_INDEX_CHECK)
00361                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00362 #else
00363         throw();
00364 #endif
00365  template <class V1,class V2,class E> friend     E _vvconv(const V1 &rv1, const V2 &rv2)
00366 #if(CXSC_INDEX_CHECK)
00367                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00368 #else
00369         throw();
00370 #endif
00371  template <class V,class VS,class E> friend      E _vvsconv(const V &rv,const VS &sl)
00372 #if(CXSC_INDEX_CHECK)
00373                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00374 #else
00375         throw();
00376 #endif
00377  template <class VS1,class VS2,class E> friend   E _vsvsconv(const VS1 &s1,const VS2 &s2)
00378 #if(CXSC_INDEX_CHECK)
00379                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00380 #else
00381         throw();
00382 #endif
00383  template <class V1,class V2> friend     V1 &_vvconvassign(V1 &rv1, const V2 &rv2)
00384 #if(CXSC_INDEX_CHECK)
00385                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00386 #else
00387         throw();
00388 #endif
00389  template <class V,class VS> friend      V &_vvsconvassign(V &rv, const VS &sl)
00390 #if(CXSC_INDEX_CHECK)
00391                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00392 #else
00393         throw();
00394 #endif
00395  template <class VS,class V> friend      VS &_vsvconvassign(VS &sl, const V &rv)
00396 #if(CXSC_INDEX_CHECK)
00397                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00398 #else
00399         throw();
00400 #endif
00401  template <class VS1,class VS2> friend   VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2)
00402 #if(CXSC_INDEX_CHECK)
00403                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00404 #else
00405         throw();
00406 #endif
00407  template <class V1,class V2,class E> friend     E _vvsect(const V1 &rv1, const V2 &rv2)
00408 #if(CXSC_INDEX_CHECK)
00409                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00410 #else
00411         throw();
00412 #endif
00413  template <class V,class VS,class E> friend      E _vvssect(const V &rv,const VS &sl)
00414 #if(CXSC_INDEX_CHECK)
00415                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00416 #else
00417         throw();
00418 #endif
00419  template <class VS1,class VS2,class E> friend   E _vsvssect(const VS1 &s1,const VS2 &s2)
00420 #if(CXSC_INDEX_CHECK)
00421                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00422 #else
00423         throw();
00424 #endif
00425  template <class V1,class V2> friend     V1 &_vvsectassign(V1 &rv1, const V2 &rv2)
00426 #if(CXSC_INDEX_CHECK)
00427                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00428 #else
00429         throw();
00430 #endif
00431  template <class V,class VS> friend      V &_vvssectassign(V &rv, const VS &sl)
00432 #if(CXSC_INDEX_CHECK)
00433                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00434 #else
00435         throw();
00436 #endif
00437  template <class VS,class V> friend      VS &_vsvsectassign(VS &sl, const V &rv)
00438 #if(CXSC_INDEX_CHECK)
00439                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00440 #else
00441         throw();
00442 #endif
00443  template <class VS1,class VS2> friend   VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2)
00444 #if(CXSC_INDEX_CHECK)
00445                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00446 #else
00447         throw();
00448 #endif
00449  template <class MV1,class MV2,class E> friend   E _mvmvsect(const MV1 &rv1, const MV2 &rv2)
00450 #if(CXSC_INDEX_CHECK)
00451                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00452 #else
00453         throw();
00454 #endif
00455  template <class MV,class V,class E> friend      E _mvvsect(const MV &rv1, const V &rv2)
00456 #if(CXSC_INDEX_CHECK)
00457                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00458 #else
00459         throw();
00460 #endif
00461 template <class MV,class V> friend  MV &_mvvsectassign(MV &v,const V &rv)
00462 #if(CXSC_INDEX_CHECK)
00463         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00464 #else
00465         throw();
00466 #endif
00467 template <class V,class MV> friend  V &_vmvsectassign(V &rv,const MV &v)
00468 #if(CXSC_INDEX_CHECK)
00469         throw(ERROR__OP_WITH_WRONG_DIM<V>);
00470 #else
00471         throw();
00472 #endif
00473  template <class MV1,class MV2,class E> friend   E _mvmvconv(const MV1 &rv1, const MV2 &rv2)
00474 #if(CXSC_INDEX_CHECK)
00475                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00476 #else
00477         throw();
00478 #endif
00479  template <class MV,class V,class E> friend      E _mvvconv(const MV &rv1, const V &rv2)
00480 #if(CXSC_INDEX_CHECK)
00481                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00482 #else
00483         throw();
00484 #endif
00485 template <class MV,class V> friend  MV &_mvvconvassign(MV &v,const V &rv)
00486 #if(CXSC_INDEX_CHECK)
00487         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00488 #else
00489         throw();
00490 #endif
00491 template <class V,class MV> friend  V &_vmvconvassign(V &rv,const MV &v)
00492 #if(CXSC_INDEX_CHECK)
00493         throw(ERROR__OP_WITH_WRONG_DIM<V>);
00494 #else
00495         throw();
00496 #endif
00497  template <class V,class MV,class S> friend      S _vmvcimult(const V &rv1, const MV &rv2)
00498 #if(CXSC_INDEX_CHECK)
00499                 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00500 #else
00501         throw();
00502 #endif
00503         //--------- vector-scalar -----------------
00504  template <class V,class S,class E> friend       E _vsdiv(const V &rv, const S &s) throw();
00505  template <class V,class S> friend       V &_vsdivassign(V &rv,const S &r) throw();
00506  template <class VS,class S,class E> friend      E _vssdiv(const VS &sl, const S &s) throw();
00507  template <class V,class S,class E> friend       E _vsmult(const V &rv, const S &s) throw();
00508  template <class VS,class S,class E> friend      E _vssmult(const VS &sl, const S &s) throw();
00509  template <class MV,class S,class E> friend      E _mvsmult(const MV &rv, const S &s) throw();
00510  template <class MV1,class MV2,class E> friend   E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
00511 #if(CXSC_INDEX_CHECK)
00512                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00513 #else
00514         throw();
00515 #endif
00516  template <class MV,class V,class E> friend      E _mvvplus(const MV &rv1, const V &rv2)
00517 #if(CXSC_INDEX_CHECK)
00518                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00519 #else
00520         throw();
00521 #endif
00522  template <class MV,class V,class E> friend      E _mvvminus(const MV &rv1, const V &rv2)
00523 #if(CXSC_INDEX_CHECK)
00524                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00525 #else
00526         throw();
00527 #endif
00528  template <class V,class MV,class E> friend      E _vmvminus(const V &rv1, const MV &rv2)
00529 #if(CXSC_INDEX_CHECK)
00530                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00531 #else
00532         throw();
00533 #endif
00534  template <class MV1,class MV2,class E> friend   E _mvmvminus(const MV1 &rv1, const MV2 &rv2)
00535 #if(CXSC_INDEX_CHECK)
00536                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00537 #else
00538         throw();
00539 #endif
00540 template <class MV,class V> friend  MV &_mvvplusassign(MV &v,const V &rv)
00541 #if(CXSC_INDEX_CHECK)
00542         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00543 #else
00544         throw();
00545 #endif
00546 template <class MV,class V> friend  MV &_mvvminusassign(MV &v,const V &rv)
00547 #if(CXSC_INDEX_CHECK)
00548         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00549 #else
00550         throw();
00551 #endif
00552  template <class MV,class S,class E> friend      E _mvsdiv(const MV &rv, const S &s) throw();
00553 template <class MV,class V> friend  MV &_mvvassign(MV &v,const V &rv)
00554 #if(CXSC_INDEX_CHECK)
00555         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00556 #else
00557         throw();
00558 #endif
00559 
00560  template <class V1,class V2> friend     bool _vveq(const V1 &rv1, const V2 &rv2) throw();
00561  template <class VS,class V> friend      bool _vsveq(const VS &sl, const V &rv) throw();
00562  template <class V1,class V2> friend     bool _vvneq(const V1 &rv1, const V2 &rv2) throw();
00563  template <class VS,class V> friend      bool _vsvneq(const VS &sl, const V &rv) throw();
00564  template <class V1,class V2> friend     bool _vvless(const V1 &rv1, const V2 &rv2) throw();
00565  template <class VS,class V> friend      bool _vsvless(const VS &sl, const V &rv) throw();
00566  template <class V1,class V2> friend     bool _vvleq(const V1 &rv1, const V2 &rv2) throw();
00567  template <class VS,class V> friend      bool _vsvleq(const VS &sl, const V &rv) throw();
00568  template <class V,class VS> friend      bool _vvsless(const V &rv, const VS &sl) throw();
00569  template <class V,class VS> friend      bool _vvsleq(const V &rv, const VS &sl) throw();
00570  template <class V> friend       bool _vnot(const V &rv) throw();
00571  template <class V> friend       void *_vvoid(const V &rv) throw();
00572  template <class VS1,class VS2> friend   bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw();
00573  template <class VS1,class VS2> friend   bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw();
00574  template <class VS1,class VS2> friend   bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw();
00575  template <class VS1,class VS2> friend   bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw();
00576  template <class VS> friend      bool _vsnot(const VS &sl) throw();
00577  template <class VS> friend      void *_vsvoid(const VS &sl) throw();
00578  template <class V> friend      std::ostream &_vout(std::ostream &s, const V &rv) throw();
00579  template <class V> friend      std::istream &_vin(std::istream &s, V &rv) throw();
00580 
00581         //------------- vector-matrix ---------------
00582 template <class DP,class V,class SV> friend      void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
00583 #if(CXSC_INDEX_CHECK)
00584                 throw(OP_WITH_WRONG_DIM);
00585 #else
00586         throw();
00587 #endif
00588         
00589 template <class V,class MV2,class S> friend  V &_vmvassign(V &v,const MV2 &rv) throw();
00590  template <class M,class V,class E> friend       E _mvcimult(const M &m,const V &v)
00591 #if(CXSC_INDEX_CHECK)
00592                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00593 #else
00594         throw();
00595 #endif
00596  template <class V,class M,class E> friend       E _vmcimult(const V &v,const M &m)
00597 #if(CXSC_INDEX_CHECK)
00598                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00599 #else
00600         throw();
00601 #endif
00602  template <class V,class M,class S> friend       V &_vmimultassign(V &v,const M &m)
00603 #if(CXSC_INDEX_CHECK)
00604                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00605 #else
00606         throw();
00607 #endif
00608  template <class V,class M,class S> friend       V &_vmcimultassign(V &v,const M &m)
00609 #if(CXSC_INDEX_CHECK)
00610                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00611 #else
00612         throw();
00613 #endif
00614  template <class MS,class V,class E> friend      E _msvcimult(const MS &ms,const V &v)
00615 #if(CXSC_INDEX_CHECK)
00616                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00617 #else
00618         throw();
00619 #endif
00620  template <class V,class MS,class E> friend      E _vmscimult(const V &v,const MS &ms)
00621 #if(CXSC_INDEX_CHECK)
00622                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00623 #else
00624         throw();
00625 #endif
00626  template <class V,class MS,class S> friend      V &_vmscimultassign(V &v,const MS &ms)
00627 #if(CXSC_INDEX_CHECK)
00628                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00629 #else
00630         throw();
00631 #endif
00632 
00633         // Real
00634  template <class DP,class VS1,class VS2> friend          void _vsvsaccu(DP &dp, const VS1 & sl1, const VS2 &sl2)
00635 #if(CXSC_INDEX_CHECK)
00636                 throw(OP_WITH_WRONG_DIM);
00637 #else
00638         throw();
00639 #endif
00640 
00641         //--Real -------- vector-scalar ------------
00642         //--Real--------- Vector-vector---------
00643         //-- Real -------- Vector-matrix ----------
00644         // complex
00645         //--complex -------- vector-scalar ------------
00646         //--complex--------- Vector-vector---------
00647         //-- complex -------- Vector-matrix ----------
00648         // interval
00649         //--interval -------- vector-scalar ------------
00650         //--interval--------- Vector-vector---------
00651         //-- interval -------- Vector-matrix ----------
00652         // cvector x ivector ----------------
00653         // vector - scalar -------
00654         // vector - vector -------------
00655         // vector - matrix ------------
00656 
00657 /* template<class T1,class T2,class T3>   friend T3 _mvscimult(const T1 &m,const T2 &v)
00658 #if(CXSC_INDEX_CHECK)
00659         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
00660 #else
00661         throw();
00662 #endif  
00663 template<class T1,class T2,class T3> friend T3 _vsmcimult(const T1 &v,const T2 &m)
00664 #if(CXSC_INDEX_CHECK)
00665         throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
00666 #else
00667         throw();
00668 #endif */
00669         
00670         //  real x complex --------------
00671         // vector - vector --------------
00672 
00673 #endif
00674         
00675 
00676         //------ Konstruktoren ----------------------------------------------------
00678         INLINE civector () throw();
00680         explicit INLINE civector(const int &i) throw();
00681 #ifdef OLD_CXSC
00682 
00683         explicit INLINE civector(const class index &i) throw(); // for backwards compatibility
00684 #endif
00685 
00686         explicit INLINE civector(const int &i1,const int &i2)
00687 #if(CXSC_INDEX_CHECK)
00688         throw(ERROR_CIVECTOR_WRONG_BOUNDARIES,ERROR_CIVECTOR_NO_MORE_MEMORY);
00689 #else
00690         throw();
00691 #endif
00692 
00693         INLINE civector(const cimatrix_subv &) throw();
00695         explicit INLINE civector(const cinterval &) throw();
00697 //      explicit INLINE civector(const cimatrix &)
00698         explicit        civector(const cimatrix &)
00699 #if(CXSC_INDEX_CHECK)
00700         throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00701 #else
00702         throw();
00703 #endif
00704 
00705         explicit INLINE civector(const cimatrix_slice &sl)
00706 #if(CXSC_INDEX_CHECK)
00707         throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00708 #else
00709         throw();
00710 #endif
00711 
00712         INLINE civector(const civector_slice &rs) throw();
00714         INLINE civector(const civector &v) throw();
00716         INLINE civector(const scivector_slice &rs);
00718         INLINE civector(const scivector &v);
00719         // Real
00721         explicit INLINE civector(const real &) throw();
00723         explicit INLINE civector(const rvector_slice &rs) throw();
00725         explicit INLINE civector(const rvector &v) throw();
00727         explicit INLINE civector(const srvector_slice &rs);
00729         explicit INLINE civector(const srvector &v);
00731         explicit INLINE civector(const rmatrix &)
00732 #if(CXSC_INDEX_CHECK)
00733         throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
00734 #else
00735         throw();
00736 #endif
00737 
00738         explicit INLINE civector(const rmatrix_slice &sl)
00739 #if(CXSC_INDEX_CHECK)
00740         throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
00741 #else
00742         throw();
00743 #endif
00744 
00745         explicit INLINE civector(const rmatrix_subv &) throw();
00746         
00747         // complex
00749         explicit INLINE civector(const complex &) throw();
00751         explicit INLINE civector(const cvector_slice &rs) throw();
00753         explicit INLINE civector(const cvector &v) throw();
00755         explicit INLINE civector(const scvector_slice &rs);
00757         explicit INLINE civector(const scvector &v);
00759         explicit INLINE civector(const cmatrix &)
00760 #if(CXSC_INDEX_CHECK)
00761         throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
00762 #else
00763         throw();
00764 #endif
00765 
00766         explicit INLINE civector(const cmatrix_slice &sl)
00767 #if(CXSC_INDEX_CHECK)
00768         throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
00769 #else
00770         throw();
00771 #endif
00772 
00773         explicit INLINE civector(const cmatrix_subv &) throw();
00774         
00775         // interval
00777         explicit INLINE civector(const interval &) throw();
00779         explicit INLINE civector(const ivector_slice &rs) throw();
00781         explicit INLINE civector(const ivector &v) throw();
00783         explicit INLINE civector(const sivector_slice &rs);
00785         explicit INLINE civector(const sivector &v);
00787         explicit INLINE civector(const imatrix &)
00788 #if(CXSC_INDEX_CHECK)
00789         throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
00790 #else
00791         throw();
00792 #endif
00793 
00794         explicit INLINE civector(const imatrix_slice &sl)
00795 #if(CXSC_INDEX_CHECK)
00796         throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
00797 #else
00798         throw();
00799 #endif
00800 
00801         explicit INLINE civector(const imatrix_subv &) throw();
00802         
00803         // cinterval
00805         INLINE civector &operator =(const civector &rv) throw();
00807         INLINE civector &operator =(const civector_slice &sl) throw();
00809         INLINE civector &operator =(const scivector &rv) ;
00811         INLINE civector &operator =(const scivector_slice &sl) ;
00813         INLINE civector &operator =(const cinterval &r) throw();
00815         INLINE civector &operator =(const cimatrix &m)
00816 #if(CXSC_INDEX_CHECK)
00817         throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00818 #else
00819         throw();
00820 #endif
00821 
00822         INLINE civector &operator =(const cimatrix_slice &)
00823 #if(CXSC_INDEX_CHECK)
00824         throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00825 #else
00826         throw();
00827 #endif
00828 
00829         INLINE civector &operator =(const cimatrix_subv &) throw();
00830         // Real
00832         INLINE civector &operator =(const rvector &rv) throw();
00834         INLINE civector &operator =(const rvector_slice &sl) throw();
00836         INLINE civector &operator =(const srvector &rv);
00838         INLINE civector &operator =(const srvector_slice &sl);
00840         INLINE civector &operator =(const real &r) throw();
00842         INLINE civector &operator =(const rmatrix &m)
00843 #if(CXSC_INDEX_CHECK)
00844         throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
00845 #else
00846         throw();
00847 #endif
00848 
00849         INLINE civector &operator =(const rmatrix_slice &)
00850 #if(CXSC_INDEX_CHECK)
00851         throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
00852 #else
00853         throw();
00854 #endif
00855 
00856         INLINE civector &operator =(const rmatrix_subv &) throw();
00857 
00858         // complex
00860         INLINE civector &operator =(const cvector &rv) throw();
00862         INLINE civector &operator =(const cvector_slice &sl) throw();
00864         INLINE civector &operator =(const scvector &rv);
00866         INLINE civector &operator =(const scvector_slice &sl);
00868         INLINE civector &operator =(const complex &r) throw();
00870         INLINE civector &operator =(const cmatrix &m)
00871 #if(CXSC_INDEX_CHECK)
00872         throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
00873 #else
00874         throw();
00875 #endif
00876 
00877         INLINE civector &operator =(const cmatrix_slice &)
00878 #if(CXSC_INDEX_CHECK)
00879         throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
00880 #else
00881         throw();
00882 #endif
00883 
00884         INLINE civector &operator =(const cmatrix_subv &) throw();
00885 
00886         // interval
00888         INLINE civector &operator =(const ivector &rv) throw();
00890         INLINE civector &operator =(const ivector_slice &sl) throw();
00892         INLINE civector &operator =(const sivector &rv) ;
00894         INLINE civector &operator =(const sivector_slice &sl) ;
00896         INLINE civector &operator =(const interval &r) throw();
00898         INLINE civector &operator =(const imatrix &m)
00899 #if(CXSC_INDEX_CHECK)
00900         throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
00901 #else
00902         throw();
00903 #endif
00904 
00905         INLINE civector &operator =(const imatrix_slice &)
00906 #if(CXSC_INDEX_CHECK)
00907         throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
00908 #else
00909         throw();
00910 #endif
00911 
00912         INLINE civector &operator =(const imatrix_subv &) throw();
00913 
00914 
00915         civector& operator+=(const srvector&);
00916         civector& operator+=(const scvector&);
00917         civector& operator+=(const sivector&);
00918         civector& operator+=(const scivector&);
00919         civector& operator-=(const srvector&);
00920         civector& operator-=(const scvector&);
00921         civector& operator-=(const sivector&);
00922         civector& operator-=(const scivector&);
00923         civector& operator|=(const srvector&);
00924         civector& operator|=(const scvector&);
00925         civector& operator|=(const sivector&);
00926         civector& operator|=(const scivector&);
00927         civector& operator&=(const sivector&);
00928         civector& operator&=(const scivector&);
00929         civector& operator+=(const srvector_slice&);
00930         civector& operator+=(const scvector_slice&);
00931         civector& operator+=(const sivector_slice&);
00932         civector& operator+=(const scivector_slice&);
00933         civector& operator-=(const srvector_slice&);
00934         civector& operator-=(const scvector_slice&);
00935         civector& operator-=(const sivector_slice&);
00936         civector& operator-=(const scivector_slice&);
00937         civector& operator|=(const srvector_slice&);
00938         civector& operator|=(const scvector_slice&);
00939         civector& operator|=(const sivector_slice&);
00940         civector& operator|=(const scivector_slice&);
00941         civector& operator&=(const sivector_slice&);
00942         civector& operator&=(const scivector_slice&);
00943 
00945         INLINE civector operator()(const intvector& p);
00947         INLINE civector operator()(const intmatrix& P);
00948 
00949         //--------- Destruktor ----------------------------------------------------
00950         INLINE ~civector() { delete [] dat; }
00951 
00952         //------ Standardfunktionen -----------------------------------------------
00953         
00954         friend INLINE cinterval::cinterval(const civector &)
00955 #if(CXSC_INDEX_CHECK)
00956         throw(ERROR_CIVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_CIVECTOR_USE_OF_UNINITIALIZED_OBJ);
00957 #else
00958         throw();
00959 #endif
00960 
00961         friend INLINE int Lb(const civector &rv) throw() { return rv.l; }
00963         friend INLINE int Ub(const civector &rv) throw() { return rv.u; }
00965         friend INLINE int VecLen(const civector &rv) throw() { return rv.size; }
00967         friend INLINE civector & SetLb(civector &rv, const int &l) throw() { rv.l=l; rv.u=l+rv.size-1; return rv;}
00969         friend INLINE civector & SetUb(civector &rv, const int &u) throw() { rv.u=u; rv.l=u-rv.size+1; return rv;}
00971         INLINE cinterval & operator [](const int &i) const
00972 #if(CXSC_INDEX_CHECK)
00973         throw(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC);
00974 #else
00975         throw();
00976 #endif
00977 
00979         INLINE cinterval & operator [](const int &i) 
00980 #if(CXSC_INDEX_CHECK)
00981         throw(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC);
00982 #else
00983         throw();
00984 #endif
00985 
00987         INLINE civector & operator ()() throw() { return *this; }
00989         INLINE civector_slice operator ()(const int &i)
00990 #if(CXSC_INDEX_CHECK)
00991         throw(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG);
00992 #else
00993         throw();
00994 #endif
00995 
00996         civector_slice operator ()(const int &i1,const int &i2)
00997 #if(CXSC_INDEX_CHECK)
00998         throw(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG);
00999 #else
01000         throw();
01001 #endif
01002         
01003         INLINE operator void*() throw();
01004 //#else
01005 //#endif
01006 };
01007 
01009 
01014 class civector_slice
01015 {
01016         friend class civector;
01017         friend class cimatrix;
01018         private:
01019         cinterval *dat;
01020         int l,u,size;
01021         int start,end;
01022 
01023         public:
01024 //#if(CXSC_INDEX_CHECK) 
01025 #ifdef _CXSC_FRIEND_TPL
01026 //------------------------- Templates -------------------------------------------
01027 // cinterval / cinterval
01028 
01029  template <class VS1,class VS2> friend   VS1 & _vsvsassign(VS1 &sl1,const VS2 &sl2)
01030 #if(CXSC_INDEX_CHECK)
01031                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01032 #else
01033         throw();
01034 #endif
01035  template <class V,class VS,class S> friend      V & _vvsassign(V &rv,const VS &sl) throw();
01036  template <class VS,class V> friend      VS & _vsvassign(VS &sl,const V &rv)
01037 #if(CXSC_INDEX_CHECK)
01038                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01039 #else
01040         throw();
01041 #endif
01042  template <class VS,class S> friend      VS & _vssassign(VS &sl,const S &r) throw();
01043  template <class VS,class V> friend      VS &_vsvsetinf(VS &sl, const V &rv)
01044 #if(CXSC_INDEX_CHECK)
01045                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01046 #else
01047         throw();
01048 #endif
01049  template <class VS,class V> friend      VS &_vsvsetsup(VS &sl, const V &rv)
01050 #if(CXSC_INDEX_CHECK)
01051                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01052 #else
01053         throw();
01054 #endif
01055  template <class VS1,class VS2> friend   VS1 &_vsvssetinf(VS1 &sl1, const VS2 &sl2)
01056 #if(CXSC_INDEX_CHECK)
01057                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01058 #else
01059         throw();
01060 #endif
01061  template <class VS1,class VS2> friend   VS1 &_vsvssetsup(VS1 &sl1, const VS2 &sl2)
01062 #if(CXSC_INDEX_CHECK)
01063                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01064 #else
01065         throw();
01066 #endif
01067  template <class VS,class V> friend      VS &_vsvusetinf(VS &sl, const V &rv)
01068 #if(CXSC_INDEX_CHECK)
01069                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01070 #else
01071         throw();
01072 #endif
01073  template <class VS,class V> friend      VS &_vsvusetsup(VS &sl, const V &rv)
01074 #if(CXSC_INDEX_CHECK)
01075                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01076 #else
01077         throw();
01078 #endif
01079  template <class VS1,class VS2> friend   VS1 &_vsvsusetinf(VS1 &sl1, const VS2 &sl2)
01080 #if(CXSC_INDEX_CHECK)
01081                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01082 #else
01083         throw();
01084 #endif
01085  template <class VS1,class VS2> friend   VS1 &_vsvsusetsup(VS1 &sl1, const VS2 &sl2)
01086 #if(CXSC_INDEX_CHECK)
01087                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01088 #else
01089         throw();
01090 #endif
01091 
01092  template <class VS,class E> friend      E _vsconj(const VS &sl) throw();
01093  template <class VS,class E> friend      E _vsabs(const VS &sl) throw();
01094  template <class VS,class E> friend      E _vsdiam(const VS &sl) throw();
01095  template <class VS,class E> friend      E _vsmid(const VS &sl) throw();
01096  template <class VS,class E> friend      E _vsinf(const VS &sl) throw();
01097  template <class VS,class E> friend      E _vssup(const VS &sl) throw();
01098  template <class VS,class E> friend      E _vsim(const VS &sl) throw();
01099  template <class VS,class E> friend      E _vsre(const VS &sl) throw();
01100         friend INLINE ivector Re(const civector_slice &v) throw();
01101         friend INLINE ivector Im(const civector_slice &v) throw();
01102         friend INLINE cvector Inf(const civector_slice &v) throw();
01103         friend INLINE cvector Sup(const civector_slice &v) throw();
01104         friend INLINE rvector SupRe(const civector_slice &v) throw();
01105         friend INLINE rvector SupIm(const civector_slice &v) throw();
01106         friend INLINE rvector InfRe(const civector_slice &v) throw();
01107         friend INLINE rvector InfIm(const civector_slice &v) throw();
01108  template <class VS,class V> friend      VS &_vsvsetim(VS &sl, const V &rv)
01109 #if(CXSC_INDEX_CHECK)
01110                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01111 #else
01112         throw();
01113 #endif
01114  template <class VS,class V> friend      VS &_vsvsetre(VS &sl, const V &rv)
01115 #if(CXSC_INDEX_CHECK)
01116                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01117 #else
01118         throw();
01119 #endif
01120  template <class VS1,class VS2> friend   VS1 &_vsvssetim(VS1 &sl1, const VS2 &sl2)
01121 #if(CXSC_INDEX_CHECK)
01122                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01123 #else
01124         throw();
01125 #endif
01126  template <class VS1,class VS2> friend   VS1 &_vsvssetre(VS1 &sl1, const VS2 &sl2)
01127 #if(CXSC_INDEX_CHECK)
01128                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01129 #else
01130         throw();
01131 #endif
01132   /*    friend TINLINE civector_slice &_vsmvsetim(civector_slice &,const imatrix_subv &)
01133 #if(CXSC_INDEX_CHECK)
01134         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01135 #else
01136         throw();
01137 #endif
01138         friend TINLINE civector_slice &_vsmvsetre(civector_slice &,const imatrix_subv &)
01139 #if(CXSC_INDEX_CHECK)
01140         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01141 #else
01142         throw();
01143         #endif */
01144  template <class VS,class S> friend      VS &_vsssetinf(VS &vs, const S &s) throw();
01145  template <class VS,class S> friend      VS &_vsssetsup(VS &vs, const S &s) throw();
01146  template <class VS,class S> friend      VS &_vssusetinf(VS &vs, const S &s) throw();
01147  template <class VS,class S> friend      VS &_vssusetsup(VS &vs, const S &s) throw();
01148  template <class VS,class S> friend      VS &_vsssetim(VS &vs, const S &s) throw();
01149  template <class VS,class S> friend      VS &_vsssetre(VS &vs, const S &s) throw();
01150 
01151  template <class DP,class VS,class V> friend     void _vsvaccu(DP &dp, const VS & sl, const V &rv)
01152 #if(CXSC_INDEX_CHECK)
01153                 throw(OP_WITH_WRONG_DIM);
01154 #else
01155         throw();
01156 #endif
01157  template <class DP,class VS1,class VS2> friend          void _vsvsaccu(DP &dp, const VS1 & sl1, const VS2 &sl2)
01158 #if(CXSC_INDEX_CHECK)
01159                 throw(OP_WITH_WRONG_DIM);
01160 #else
01161         throw();
01162 #endif
01163         
01164  template <class VS,class S,class E> friend      E _vssdiv(const VS &sl, const S &s) throw();
01165  template <class VS,class S,class E> friend      E _vssmult(const VS &sl, const S &s) throw();
01166 
01167  template <class VS,class V,class E> friend      E _vsvcimult(const VS & sl, const V &rv)
01168 #if(CXSC_INDEX_CHECK)
01169                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01170 #else
01171         throw();
01172 #endif
01173  template <class VS,class S> friend      VS &_vssmultassign(VS &rv,const S &r) throw();
01174  template <class VS,class S> friend      VS &_vssdivassign(VS &rv,const S &r) throw();
01175  template <class V,class VS,class E> friend      E _vvsplus(const V &rv,const VS &sl)
01176 #if(CXSC_INDEX_CHECK)
01177                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01178 #else
01179         throw();
01180 #endif
01181  template <class VS1,class VS2,class E> friend   E _vsvsplus(const VS1 &s1,const VS2 &s2)
01182 #if(CXSC_INDEX_CHECK)
01183                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01184 #else
01185         throw();
01186 #endif
01187  template <class VS1,class VS2,class E> friend   E _vsvsminus(const VS1 &s1,const VS2 &s2)
01188 #if(CXSC_INDEX_CHECK)
01189                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01190 #else
01191         throw();
01192 #endif
01193  template <class V,class VS> friend      V &_vvsplusassign(V &rv, const VS &sl)
01194 #if(CXSC_INDEX_CHECK)
01195                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01196 #else
01197         throw();
01198 #endif
01199  template <class VS,class V> friend      VS &_vsvplusassign(VS &sl, const V &rv)
01200 #if(CXSC_INDEX_CHECK)
01201                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01202 #else
01203         throw();
01204 #endif
01205  template <class VS1,class VS2> friend   VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
01206 #if(CXSC_INDEX_CHECK)
01207                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01208 #else
01209         throw();
01210 #endif
01211  template <class VS1,class VS2> friend   VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
01212 #if(CXSC_INDEX_CHECK)
01213                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01214 #else
01215         throw();
01216 #endif
01217  template <class V,class VS> friend      V &_vvsminusassign(V &rv, const VS &sl)
01218 #if(CXSC_INDEX_CHECK)
01219                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01220 #else
01221         throw();
01222 #endif
01223  template <class VS,class V> friend      VS &_vsvminusassign(VS &sl, const V &rv)
01224 #if(CXSC_INDEX_CHECK)
01225                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01226 #else
01227         throw();
01228 #endif
01229  template <class VS,class V> friend      V _vsminus(const VS &sl) throw();
01230  template <class V,class VS,class E> friend      E _vvsminus(const V &rv, const VS &sl)
01231 #if(CXSC_INDEX_CHECK)
01232                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01233 #else
01234         throw();
01235 #endif
01236  template <class VS,class V,class E> friend      E _vsvminus(const VS &sl,const V &rv)
01237 #if(CXSC_INDEX_CHECK)
01238                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01239 #else
01240         throw();
01241 #endif
01242  template <class V,class VS,class E> friend      E _vvssect(const V &rv,const VS &sl)
01243 #if(CXSC_INDEX_CHECK)
01244                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01245 #else
01246         throw();
01247 #endif
01248  template <class VS1,class VS2,class E> friend   E _vsvssect(const VS1 &s1,const VS2 &s2)
01249 #if(CXSC_INDEX_CHECK)
01250                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01251 #else
01252         throw();
01253 #endif
01254  template <class V,class VS> friend      V &_vvssectassign(V &rv, const VS &sl)
01255 #if(CXSC_INDEX_CHECK)
01256                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01257 #else
01258         throw();
01259 #endif
01260  template <class VS,class V> friend      VS &_vsvsectassign(VS &sl, const V &rv)
01261 #if(CXSC_INDEX_CHECK)
01262                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01263 #else
01264         throw();
01265 #endif
01266  template <class VS1,class VS2> friend   VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2)
01267 #if(CXSC_INDEX_CHECK)
01268                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01269 #else
01270         throw();
01271 #endif
01272  template <class V,class VS,class E> friend      E _vvsconv(const V &rv,const VS &sl)
01273 #if(CXSC_INDEX_CHECK)
01274                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01275 #else
01276         throw();
01277 #endif
01278  template <class VS1,class VS2,class E> friend   E _vsvsconv(const VS1 &s1,const VS2 &s2)
01279 #if(CXSC_INDEX_CHECK)
01280                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01281 #else
01282         throw();
01283 #endif
01284  template <class V,class VS> friend      V &_vvsconvassign(V &rv, const VS &sl)
01285 #if(CXSC_INDEX_CHECK)
01286                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01287 #else
01288         throw();
01289 #endif
01290  template <class VS,class V> friend      VS &_vsvconvassign(VS &sl, const V &rv)
01291 #if(CXSC_INDEX_CHECK)
01292                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01293 #else
01294         throw();
01295 #endif
01296  template <class VS1,class VS2> friend   VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2)
01297 #if(CXSC_INDEX_CHECK)
01298                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01299 #else
01300         throw();
01301 #endif
01302  template <class VS,class M,class S> friend      VS &_vsmcimultassign(VS &v,const M &m)
01303 #if(CXSC_INDEX_CHECK)
01304                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01305 #else
01306         throw();
01307 #endif
01308 
01309  template <class VS,class V> friend      bool _vsveq(const VS &sl, const V &rv) throw();
01310  template <class VS,class V> friend      bool _vsvneq(const VS &sl, const V &rv) throw();
01311  template <class VS,class V> friend      bool _vsvless(const VS &sl, const V &rv) throw();
01312  template <class VS,class V> friend      bool _vsvleq(const VS &sl, const V &rv) throw();
01313  template <class V,class VS> friend      bool _vvsless(const V &rv, const VS &sl) throw();
01314  template <class V,class VS> friend      bool _vvsleq(const V &rv, const VS &sl) throw();
01315  template <class VS1,class VS2,class E> friend   E _vsvscimult(const VS1 & sl1, const VS2 &sl2)
01316 #if(CXSC_INDEX_CHECK)
01317                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01318 #else
01319         throw();
01320 #endif
01321  template <class VS1,class VS2> friend   bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw();
01322  template <class VS1,class VS2> friend   bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw();
01323  template <class VS1,class VS2> friend   bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw();
01324  template <class VS1,class VS2> friend   bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw();
01325  template <class VS> friend      bool _vsnot(const VS &sl) throw();
01326  template <class VS> friend      void *_vsvoid(const VS &sl) throw();
01327  template <class V> friend      std::ostream &_vsout(std::ostream &s, const V &rv) throw();
01328  template <class V> friend      std::istream &_vsin(std::istream &s, V &rv) throw();
01329         
01330         // cinterval / Real
01331  template <class V,class MS,class E> friend      E _vmscimult(const V &v,const MS &ms)
01332 #if(CXSC_INDEX_CHECK)
01333                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01334 #else
01335         throw();
01336 #endif
01337         // cinterval / complex
01338  template <class DP,class V1,class V2> friend    void _vvaccu(DP &dp, const V1 & rv1, const V2 &rv2)
01339 #if(CXSC_INDEX_CHECK)
01340                 throw(OP_WITH_WRONG_DIM);
01341 #else
01342         throw();
01343 #endif
01344 
01345         // cinterval / interval
01346         // complex
01347  template <class V1,class V2,class S> friend     V1 &_vvassign(V1 &rv1,const V2 &rv2) throw();
01348  template <class V,class S> friend       V & _vsassign(V &rv,const S &r) throw();
01349 
01350 template <class V,class M,class S> friend  V &_vmassign(V &v,const M &m)
01351 #if(CXSC_INDEX_CHECK)
01352         throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
01353 #else
01354         throw();
01355 #endif
01356 template <class M,class V,class S> friend  M &_mvassign(M &m,const V &v) throw();
01357 template <class V,class MV2,class S> friend  V &_vmvassign(V &v,const MV2 &rv) throw();
01358 
01359  template <class V1,class V2,class E> friend     E _vvconv(const V1 &rv1, const V2 &rv2)
01360 #if(CXSC_INDEX_CHECK)
01361                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01362 #else
01363         throw();
01364 #endif
01365 
01366         //--complex -------- vector-scalar ------------
01367  template <class MV,class S,class E> friend      E _mvsmult(const MV &rv, const S &s) throw();
01368  template <class V,class S,class E> friend       E _vsmult(const V &rv, const S &s) throw();
01369  template <class V,class S,class E> friend       E _vsdiv(const V &rv, const S &s) throw();
01370  template <class V,class S> friend       V &_vsdivassign(V &rv,const S &r) throw();
01371  template <class V,class S> friend       V &_vsmultassign(V &rv,const S &r) throw();
01372         //--complex--------- Vector-vector---------
01373  template <class V1,class V2,class E> friend     E _vvcimult(const V1 & rv1, const V2 &rv2)
01374 #if(CXSC_INDEX_CHECK)
01375                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
01376 #else
01377         throw();
01378 #endif
01379  template <class V1,class V2,class E> friend     E _vvplus(const V1 &rv1, const V2 &rv2)
01380 #if(CXSC_INDEX_CHECK)
01381                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
01382 #else
01383         throw();
01384 #endif
01385  template <class V1,class V2> friend     V1 &_vvplusassign(V1 &rv1, const V2 &rv2)
01386 #if(CXSC_INDEX_CHECK)
01387                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
01388 #else
01389         throw();
01390 #endif
01391  template <class V1,class V2> friend     V1 &_vvminusassign(V1 &rv1, const V2 &rv2)
01392 #if(CXSC_INDEX_CHECK)
01393                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
01394 #else
01395         throw();
01396 #endif
01397  template <class V1,class V2,class E> friend     E _vvminus(const V1 &rv1, const V2 &rv2)
01398 #if(CXSC_INDEX_CHECK)
01399                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01400 #else
01401         throw();
01402 #endif
01403  template <class V1,class V2> friend     V1 &_vvconvassign(V1 &rv1, const V2 &rv2)
01404 #if(CXSC_INDEX_CHECK)
01405                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
01406 #else
01407         throw();
01408 #endif
01409  template <class V1,class V2,class E> friend     E _vvsect(const V1 &rv1, const V2 &rv2)
01410 #if(CXSC_INDEX_CHECK)
01411                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
01412 #else
01413         throw();
01414 #endif
01415  template <class V1,class V2> friend     V1 &_vvsectassign(V1 &rv1, const V2 &rv2)
01416 #if(CXSC_INDEX_CHECK)
01417                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
01418 #else
01419         throw();
01420 #endif
01421         
01422         //-- complex -------- Vector-matrix ----------
01423 template <class V,class MS,class S> friend  void _vmsconstr(V &v,const MS &m)
01424 #if(CXSC_INDEX_CHECK)
01425         throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>);
01426 #else
01427         throw();
01428 #endif
01429 template <class V,class M,class S> friend  void _vmconstr(V &v,const M &m)
01430 #if(CXSC_INDEX_CHECK)
01431         throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
01432 #else
01433         throw();
01434 #endif
01435  template <class M,class V,class E> friend       E _mvcimult(const M &m,const V &v)
01436 #if(CXSC_INDEX_CHECK)
01437                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01438 #else
01439         throw();
01440 #endif
01441  template <class MS,class V,class E> friend      E _msvcimult(const MS &ms,const V &v)
01442 #if(CXSC_INDEX_CHECK)
01443                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01444 #else
01445         throw();
01446 #endif
01447  template <class V,class M,class E> friend       E _vmcimult(const V &v,const M &m)
01448 #if(CXSC_INDEX_CHECK)
01449                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01450 #else
01451         throw();
01452 #endif
01453  template <class V,class MS,class S> friend      V &_vmscimultassign(V &v,const MS &ms)
01454 #if(CXSC_INDEX_CHECK)
01455                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01456 #else
01457         throw();
01458 #endif
01459  template <class V,class M,class S> friend       V &_vmcimultassign(V &v,const M &m)
01460 #if(CXSC_INDEX_CHECK)
01461                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01462 #else
01463         throw();
01464 #endif
01465 
01466         // interval
01467   /*    friend TINLINE civector &_vsmassign<civector_slice,imatrix,cinterval>(civector_slice &v,const imatrix &m)
01468 #if(CXSC_INDEX_CHECK)
01469         throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
01470 #else
01471         throw();
01472 #endif */
01473 
01474         //--interval -------- vector-scalar ------------
01475         //--interval--------- Vector-vector---------
01476         //-- interval -------- Vector-matrix ----------
01477 /*  friend TINLINE civector _mvscimult<imatrix,civector_slice,civector>(const imatrix &m,const civector_slice &v)
01478 #if(CXSC_INDEX_CHECK)
01479         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01480 #else
01481         throw();
01482 #endif */
01483   /*   friend TINLINE civector _msvscimult<imatrix_slice,civector_slice,civector>(const imatrix_slice &ms,const civector_slice &v)
01484 #if(CXSC_INDEX_CHECK)
01485         throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
01486 #else
01487         throw();
01488         #endif */
01489   /*   friend TINLINE civector _vsmcimult<civector_slice,imatrix,civector>(const civector_slice &v,const imatrix &m)
01490 #if(CXSC_INDEX_CHECK)
01491         throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
01492 #else
01493         throw();
01494 #endif */
01495   /*   friend TINLINE civector _vsmscimult<civector_slice,imatrix_slice,civector>(const civector_slice &v,const imatrix_slice &ms)
01496 #if(CXSC_INDEX_CHECK)
01497         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01498 #else
01499         throw();
01500 #endif */
01501   /*  friend TINLINE civector &_vsmscimultassign<civector_slice,imatrix_slice,cinterval>(civector_slice &v,const imatrix_slice &m)
01502 #if(CXSC_INDEX_CHECK)
01503         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01504 #else
01505         throw();
01506 #endif */
01507 
01508 
01509 #endif
01510         
01511         //--------------------- Konstruktoren -----------------------------------
01513         explicit INLINE civector_slice(civector &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) { }
01515         explicit INLINE civector_slice(civector_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) { }
01516         public: 
01518         INLINE civector_slice(const civector_slice &a) throw():dat(a.dat),l(a.l),u(a.u),size(a.size),start(a.start),end(a.end) { }
01519         public:
01520         // cinterval
01522         INLINE civector_slice & operator =(const scivector_slice &sl);
01524         INLINE civector_slice & operator =(const scivector &sl);
01525 
01527         INLINE civector_slice & operator =(const civector_slice &sl)
01528 #if(CXSC_INDEX_CHECK)
01529         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01530 #else
01531         throw();
01532 #endif
01533 
01534         INLINE civector_slice & operator =(const civector &rv)
01535 #if(CXSC_INDEX_CHECK)
01536         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01537 #else
01538         throw();
01539 #endif
01540 
01541         INLINE civector_slice & operator =(const cinterval &r) throw();
01543         INLINE civector_slice & operator =(const cimatrix &m)
01544 #if(CXSC_INDEX_CHECK)
01545         throw(ERROR__OP_WITH_WRONG_DIM<civector>,ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
01546 #else
01547         throw();
01548 #endif
01549 
01550         INLINE civector_slice & operator =(const cimatrix_slice &m)
01551 #if(CXSC_INDEX_CHECK)
01552         throw(ERROR__OP_WITH_WRONG_DIM<civector>,ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
01553 #else
01554         throw();
01555 #endif
01556 
01557         INLINE civector_slice &operator =(const cimatrix_subv &) throw();
01558         // Real
01560         INLINE civector_slice & operator =(const srvector_slice &sl);
01562         INLINE civector_slice & operator =(const srvector &sl);
01563 
01565         INLINE civector_slice & operator =(const rvector_slice &sl)
01566 #if(CXSC_INDEX_CHECK)
01567         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01568 #else
01569         throw();
01570 #endif
01571 
01572         INLINE civector_slice & operator =(const rvector &rv)
01573 #if(CXSC_INDEX_CHECK)
01574         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01575 #else
01576         throw();
01577 #endif
01578 
01579         INLINE civector_slice & operator =(const real &r) throw();
01581         INLINE civector_slice & operator =(const rmatrix &m)
01582 #if(CXSC_INDEX_CHECK)
01583         throw(ERROR__OP_WITH_WRONG_DIM<rvector>,ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
01584 #else
01585         throw();
01586 #endif
01587 
01588         INLINE civector_slice & operator =(const rmatrix_slice &m)
01589 #if(CXSC_INDEX_CHECK)
01590         throw(ERROR__OP_WITH_WRONG_DIM<rvector>,ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
01591 #else
01592         throw();
01593 #endif
01594 
01595         INLINE civector_slice &operator =(const rmatrix_subv &mv) throw();
01596 
01597         // complex
01599         INLINE civector_slice & operator =(const scvector_slice &sl);
01601         INLINE civector_slice & operator =(const scvector &sl);
01602 
01604         INLINE civector_slice & operator =(const cvector_slice &sl)
01605 #if(CXSC_INDEX_CHECK)
01606         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01607 #else
01608         throw();
01609 #endif
01610 
01611         INLINE civector_slice & operator =(const cvector &rv)
01612 #if(CXSC_INDEX_CHECK)
01613         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01614 #else
01615         throw();
01616 #endif
01617 
01618         INLINE civector_slice & operator =(const complex &r) throw();
01620         INLINE civector_slice & operator =(const cmatrix &m)
01621 #if(CXSC_INDEX_CHECK)
01622         throw(ERROR__OP_WITH_WRONG_DIM<cvector>,ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
01623 #else
01624         throw();
01625 #endif
01626 
01627         INLINE civector_slice & operator =(const cmatrix_slice &m)
01628 #if(CXSC_INDEX_CHECK)
01629         throw(ERROR__OP_WITH_WRONG_DIM<cvector>,ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
01630 #else
01631         throw();
01632 #endif
01633 
01634         INLINE civector_slice &operator =(const cmatrix_subv &mv) throw();
01635 
01636         // interval
01638         INLINE civector_slice & operator =(const sivector_slice &sl);
01640         INLINE civector_slice & operator =(const sivector &sl);
01641 
01643         INLINE civector_slice & operator =(const ivector_slice &sl)
01644 #if(CXSC_INDEX_CHECK)
01645         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01646 #else
01647         throw();
01648 #endif
01649 
01650         INLINE civector_slice & operator =(const ivector &rv)
01651 #if(CXSC_INDEX_CHECK)
01652         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01653 #else
01654         throw();
01655 #endif
01656 
01657         INLINE civector_slice & operator =(const interval &r) throw();
01659         INLINE civector_slice & operator =(const imatrix &m)
01660 #if(CXSC_INDEX_CHECK)
01661         throw(ERROR__OP_WITH_WRONG_DIM<ivector>,ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
01662 #else
01663         throw();
01664 #endif
01665 
01666         INLINE civector_slice & operator =(const imatrix_slice &m)
01667 #if(CXSC_INDEX_CHECK)
01668         throw(ERROR__OP_WITH_WRONG_DIM<ivector>,ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
01669 #else
01670         throw();
01671 #endif
01672 
01673         INLINE civector_slice &operator =(const imatrix_subv &mv) throw();
01674 
01675         //--------------------- Standardfunktionen ------------------------------
01676 
01677         friend INLINE cinterval::cinterval(const civector_slice &sl)
01678 #if(CXSC_INDEX_CHECK)
01679         throw(ERROR_CIVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_CIVECTOR_USE_OF_UNINITIALIZED_OBJ);
01680 #else
01681         throw();
01682 #endif
01683 
01684         friend INLINE int Lb(const civector_slice &sl) throw() { return sl.start; }
01686         friend INLINE int Ub(const civector_slice &sl) throw() { return sl.end; }
01688         friend INLINE int VecLen(const civector_slice &sl) throw() { return sl.size; }
01689 
01691         INLINE cinterval & operator [](const int &i) const
01692 #if(CXSC_INDEX_CHECK)
01693         throw(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC);
01694 #else
01695         throw();
01696 #endif
01697 
01699         INLINE cinterval & operator [](const int &i) 
01700 #if(CXSC_INDEX_CHECK)
01701         throw(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC);
01702 #else
01703         throw();
01704 #endif
01705 
01707         INLINE civector_slice & operator ()() throw() { return *this; }
01709         INLINE civector_slice operator ()(const int &i)
01710 #if(CXSC_INDEX_CHECK)
01711         throw(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG);
01712 #else
01713         throw();
01714 #endif
01715 
01716         civector_slice operator ()(const int &i1,const int &i2)
01717 #if(CXSC_INDEX_CHECK)
01718         throw(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG);
01719 #else
01720         throw();
01721 #endif
01722         INLINE operator void*() throw();
01723         
01725         INLINE civector_slice &operator *=(const cinterval &r) throw();
01727         INLINE civector_slice &operator /=(const cinterval &r) throw();
01729         INLINE civector_slice &operator *=(const cimatrix &m)
01730 #if(CXSC_INDEX_CHECK)
01731         throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
01732 #else
01733         throw();
01734 #endif
01735 
01736         INLINE civector_slice &operator *=(const cimatrix_slice &m)
01737 #if(CXSC_INDEX_CHECK)
01738         throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
01739 #else
01740         throw();
01741 #endif
01742 
01743         INLINE civector_slice &operator +=(const civector &rv)
01744 #if(CXSC_INDEX_CHECK)
01745         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01746 #else
01747         throw();
01748 #endif
01749 
01750         INLINE civector_slice &operator +=(const civector_slice &sl2)
01751 #if(CXSC_INDEX_CHECK)
01752         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01753 #else
01754         throw();
01755 #endif
01756 
01757         INLINE civector_slice &operator -=(const civector &rv)
01758 #if(CXSC_INDEX_CHECK)
01759         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01760 #else
01761         throw();
01762 #endif
01763 
01764         INLINE civector_slice &operator -=(const civector_slice &sl2)
01765 #if(CXSC_INDEX_CHECK)
01766         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01767 #else
01768         throw();
01769 #endif
01770 
01771         INLINE civector_slice &operator |=(const civector &rv)
01772 #if(CXSC_INDEX_CHECK)
01773         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01774 #else
01775         throw();
01776 #endif
01777 
01778         INLINE civector_slice &operator |=(const civector_slice &sl2)
01779 #if(CXSC_INDEX_CHECK)
01780         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01781 #else
01782         throw();
01783 #endif
01784 
01785         INLINE civector_slice &operator &=(const civector &rv)
01786 #if(CXSC_INDEX_CHECK)
01787         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01788 #else
01789         throw();
01790 #endif
01791 
01792         INLINE civector_slice &operator &=(const civector_slice &sl2)
01793 #if(CXSC_INDEX_CHECK)
01794         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01795 #else
01796         throw();
01797 #endif
01798         
01800         INLINE civector_slice &operator *=(const real &r) throw();
01802         INLINE civector_slice &operator /=(const real &r) throw();
01804         INLINE civector_slice &operator +=(const rvector &rv)
01805 #if(CXSC_INDEX_CHECK)
01806         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01807 #else
01808         throw();
01809 #endif
01810 
01811         INLINE civector_slice &operator +=(const rvector_slice &sl2)
01812 #if(CXSC_INDEX_CHECK)
01813         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01814 #else
01815         throw();
01816 #endif
01817 
01818         INLINE civector_slice &operator -=(const rvector &rv)
01819 #if(CXSC_INDEX_CHECK)
01820         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01821 #else
01822         throw();
01823 #endif
01824 
01825         INLINE civector_slice &operator -=(const rvector_slice &sl2)
01826 #if(CXSC_INDEX_CHECK)
01827         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01828 #else
01829         throw();
01830 #endif
01831 
01832         INLINE civector_slice &operator |=(const rvector &rv)
01833 #if(CXSC_INDEX_CHECK)
01834         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01835 #else
01836         throw();
01837 #endif
01838 
01839         INLINE civector_slice &operator |=(const rvector_slice &sl2)
01840 #if(CXSC_INDEX_CHECK)
01841         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01842 #else
01843         throw();
01844 #endif
01845 
01846         INLINE civector_slice &operator &=(const rvector &rv)
01847 #if(CXSC_INDEX_CHECK)
01848         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01849 #else
01850         throw();
01851 #endif
01852 
01853         INLINE civector_slice &operator &=(const rvector_slice &sl2)
01854 #if(CXSC_INDEX_CHECK)
01855         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01856 #else
01857         throw();
01858 #endif
01859 
01860         INLINE civector_slice &operator *=(const rmatrix &m)
01861 #if(CXSC_INDEX_CHECK)
01862         throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
01863 #else
01864         throw();
01865 #endif
01866 
01867         INLINE civector_slice &operator *=(const rmatrix_slice &m)
01868 #if(CXSC_INDEX_CHECK)
01869         throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
01870 #else
01871         throw();
01872 #endif
01873 
01875         INLINE civector_slice &operator *=(const complex &r) throw();
01877         INLINE civector_slice &operator /=(const complex &r) throw();
01879         INLINE civector_slice &operator +=(const cvector &rv)
01880 #if(CXSC_INDEX_CHECK)
01881         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01882 #else
01883         throw();
01884 #endif
01885 
01886         INLINE civector_slice &operator +=(const cvector_slice &sl2)
01887 #if(CXSC_INDEX_CHECK)
01888         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01889 #else
01890         throw();
01891 #endif
01892 
01893         INLINE civector_slice &operator -=(const cvector &rv)
01894 #if(CXSC_INDEX_CHECK)
01895         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01896 #else
01897         throw();
01898 #endif
01899 
01900         INLINE civector_slice &operator -=(const cvector_slice &sl2)
01901 #if(CXSC_INDEX_CHECK)
01902         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01903 #else
01904         throw();
01905 #endif
01906 
01907         INLINE civector_slice &operator |=(const cvector &rv)
01908 #if(CXSC_INDEX_CHECK)
01909         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01910 #else
01911         throw();
01912 #endif
01913 
01914         INLINE civector_slice &operator |=(const cvector_slice &sl2)
01915 #if(CXSC_INDEX_CHECK)
01916         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01917 #else
01918         throw();
01919 #endif
01920 
01921         INLINE civector_slice &operator &=(const cvector &rv)
01922 #if(CXSC_INDEX_CHECK)
01923         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01924 #else
01925         throw();
01926 #endif
01927 
01928         INLINE civector_slice &operator &=(const cvector_slice &sl2)
01929 #if(CXSC_INDEX_CHECK)
01930         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01931 #else
01932         throw();
01933 #endif
01934 
01935         INLINE civector_slice &operator *=(const cmatrix &m)
01936 #if(CXSC_INDEX_CHECK)
01937         throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
01938 #else
01939         throw();
01940 #endif
01941 
01942         INLINE civector_slice &operator *=(const cmatrix_slice &m)
01943 #if(CXSC_INDEX_CHECK)
01944         throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
01945 #else
01946         throw();
01947 #endif
01948 
01950         INLINE civector_slice &operator *=(const interval &r) throw();
01952         INLINE civector_slice &operator /=(const interval &r) throw();
01954         INLINE civector_slice &operator +=(const ivector &rv)
01955 #if(CXSC_INDEX_CHECK)
01956         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01957 #else
01958         throw();
01959 #endif
01960 
01961         INLINE civector_slice &operator +=(const ivector_slice &sl2)
01962 #if(CXSC_INDEX_CHECK)
01963         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01964 #else
01965         throw();
01966 #endif
01967 
01968         INLINE civector_slice &operator -=(const ivector &rv)
01969 #if(CXSC_INDEX_CHECK)
01970         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01971 #else
01972         throw();
01973 #endif
01974 
01975         INLINE civector_slice &operator -=(const ivector_slice &sl2)
01976 #if(CXSC_INDEX_CHECK)
01977         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01978 #else
01979         throw();
01980 #endif
01981 
01982         INLINE civector_slice &operator |=(const ivector &rv)
01983 #if(CXSC_INDEX_CHECK)
01984         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01985 #else
01986         throw();
01987 #endif
01988 
01989         INLINE civector_slice &operator |=(const ivector_slice &sl2)
01990 #if(CXSC_INDEX_CHECK)
01991         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01992 #else
01993         throw();
01994 #endif
01995 
01996         INLINE civector_slice &operator &=(const ivector &rv)
01997 #if(CXSC_INDEX_CHECK)
01998         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
01999 #else
02000         throw();
02001 #endif
02002 
02003         INLINE civector_slice &operator &=(const ivector_slice &sl2)
02004 #if(CXSC_INDEX_CHECK)
02005         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02006 #else
02007         throw();
02008 #endif
02009 
02010         INLINE civector_slice &operator *=(const imatrix &m)
02011 #if(CXSC_INDEX_CHECK)
02012         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02013 #else
02014         throw();
02015 #endif
02016 
02017         INLINE civector_slice &operator *=(const imatrix_slice &m)
02018 #if(CXSC_INDEX_CHECK)
02019         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
02020 #else
02021         throw();
02022 #endif
02023 //#else
02024 //#endif
02025 
02026         civector_slice& operator+=(const srvector&);
02027         civector_slice& operator+=(const scvector&);
02028         civector_slice& operator+=(const sivector&);
02029         civector_slice& operator+=(const scivector&);
02030         civector_slice& operator-=(const srvector&);
02031         civector_slice& operator-=(const scvector&);
02032         civector_slice& operator-=(const sivector&);
02033         civector_slice& operator-=(const scivector&);
02034         civector_slice& operator|=(const srvector&);
02035         civector_slice& operator|=(const scvector&);
02036         civector_slice& operator|=(const sivector&);
02037         civector_slice& operator|=(const scivector&);
02038         civector_slice& operator&=(const sivector&);
02039         civector_slice& operator&=(const scivector&);
02040         civector_slice& operator+=(const srvector_slice&);
02041         civector_slice& operator+=(const scvector_slice&);
02042         civector_slice& operator+=(const sivector_slice&);
02043         civector_slice& operator+=(const scivector_slice&);
02044         civector_slice& operator-=(const srvector_slice&);
02045         civector_slice& operator-=(const scvector_slice&);
02046         civector_slice& operator-=(const sivector_slice&);
02047         civector_slice& operator-=(const scivector_slice&);
02048         civector_slice& operator|=(const srvector_slice&);
02049         civector_slice& operator|=(const scvector_slice&);
02050         civector_slice& operator|=(const sivector_slice&);
02051         civector_slice& operator|=(const scivector_slice&);
02052         civector_slice& operator&=(const sivector_slice&);
02053         civector_slice& operator&=(const scivector_slice&);
02054 
02055 };
02056 
02057 //=======================================================================
02058 //======================== Vector Functions =============================
02059 
02061         INLINE civector _civector(const cinterval &r) throw();
02062 //      INLINE civector _civector(const cimatrix &m) throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
02063 //      INLINE civector _civector(const cimatrix_slice &sl) throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
02065         INLINE civector _civector(const real &r) throw();
02067         INLINE civector _civector(const rvector_slice &rs) throw();
02069         INLINE civector _civector(const rvector &rs) throw();
02070 //      INLINE civector _civector(const rmatrix &m) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
02071 //      INLINE civector _civector(const rmatrix_slice &sl) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
02073         INLINE civector _civector(const rmatrix_subv &rs) throw();
02074 
02076         INLINE civector &SetInf(civector &iv,const cvector &rv)
02077 #if(CXSC_INDEX_CHECK)
02078         throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02079 #else
02080         throw();
02081 #endif
02082 
02083         INLINE civector_slice &SetInf(civector_slice &iv,const cvector &rv)
02084 #if(CXSC_INDEX_CHECK)
02085         throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02086 #else
02087         throw();
02088 #endif
02089 
02090         INLINE civector &SetInf(civector &iv,const cvector_slice &rv)
02091 #if(CXSC_INDEX_CHECK)
02092         throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02093 #else
02094         throw();
02095 #endif
02096 
02097         INLINE civector_slice &SetInf(civector_slice &iv,const cvector_slice &rv)
02098 #if(CXSC_INDEX_CHECK)
02099         throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02100 #else
02101         throw();
02102 #endif
02103 
02104         INLINE civector &UncheckedSetInf(civector &iv,const cvector &rv)
02105 #if(CXSC_INDEX_CHECK)
02106         throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02107 #else
02108         throw();
02109 #endif
02110 
02111         INLINE civector_slice &UncheckedSetInf(civector_slice &iv,const cvector &rv)
02112 #if(CXSC_INDEX_CHECK)
02113         throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02114 #else
02115         throw();
02116 #endif
02117 
02118         INLINE civector &UncheckedSetInf(civector &iv,const cvector_slice &rv)
02119 #if(CXSC_INDEX_CHECK)
02120         throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02121 #else
02122         throw();
02123 #endif
02124 
02125         INLINE civector_slice &UncheckedSetInf(civector_slice &iv,const cvector_slice &rv)
02126 #if(CXSC_INDEX_CHECK)
02127         throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02128 #else
02129         throw();
02130 #endif
02131 
02133         INLINE civector &SetSup(civector &iv,const cvector &rv)
02134 #if(CXSC_INDEX_CHECK)
02135         throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02136 #else
02137         throw();
02138 #endif
02139 
02140         INLINE civector_slice &SetSup(civector_slice &iv,const cvector &rv)
02141 #if(CXSC_INDEX_CHECK)
02142         throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02143 #else
02144         throw();
02145 #endif
02146 
02147         INLINE civector &SetSup(civector &iv,const cvector_slice &rv)
02148 #if(CXSC_INDEX_CHECK)
02149         throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02150 #else
02151         throw();
02152 #endif
02153 
02154         INLINE civector_slice &SetSup(civector_slice &iv,const cvector_slice &rv)
02155 #if(CXSC_INDEX_CHECK)
02156         throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02157 #else
02158         throw();
02159 #endif
02160 
02161         INLINE civector &UncheckedSetSup(civector &iv,const cvector &rv)
02162 #if(CXSC_INDEX_CHECK)
02163         throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02164 #else
02165         throw();
02166 #endif
02167 
02168         INLINE civector_slice &UncheckedSetSup(civector_slice &iv,const cvector &rv)
02169 #if(CXSC_INDEX_CHECK)
02170         throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02171 #else
02172         throw();
02173 #endif
02174 
02175         INLINE civector &UncheckedSetSup(civector &iv,const cvector_slice &rv)
02176 #if(CXSC_INDEX_CHECK)
02177         throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02178 #else
02179         throw();
02180 #endif
02181 
02182         INLINE civector_slice &UncheckedSetSup(civector_slice &iv,const cvector_slice &rv)
02183 #if(CXSC_INDEX_CHECK)
02184         throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02185 #else
02186         throw();
02187 #endif
02188 
02190         INLINE civector &SetRe(civector &iv,const ivector &rv)
02191 #if(CXSC_INDEX_CHECK)
02192         throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02193 #else
02194         throw();
02195 #endif
02196 
02197         INLINE civector_slice &SetRe(civector_slice &iv,const ivector &rv)
02198 #if(CXSC_INDEX_CHECK)
02199         throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02200 #else
02201         throw();
02202 #endif
02203 
02204         INLINE civector &SetRe(civector &iv,const ivector_slice &rv)
02205 #if(CXSC_INDEX_CHECK)
02206         throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02207 #else
02208         throw();
02209 #endif
02210 
02211         INLINE civector_slice &SetRe(civector_slice &iv,const ivector_slice &rv)
02212 #if(CXSC_INDEX_CHECK)
02213         throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02214 #else
02215         throw();
02216 #endif
02217 
02219         INLINE civector &SetIm(civector &iv,const ivector &rv)
02220 #if(CXSC_INDEX_CHECK)
02221         throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02222 #else
02223         throw();
02224 #endif
02225 
02226         INLINE civector_slice &SetIm(civector_slice &iv,const ivector &rv)
02227 #if(CXSC_INDEX_CHECK)
02228         throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02229 #else
02230         throw();
02231 #endif
02232 
02233         INLINE civector &SetIm(civector &iv,const ivector_slice &rv)
02234 #if(CXSC_INDEX_CHECK)
02235         throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02236 #else
02237         throw();
02238 #endif
02239 
02240         INLINE civector_slice &SetIm(civector_slice &iv,const ivector_slice &rv)
02241 #if(CXSC_INDEX_CHECK)
02242         throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
02243 #else
02244         throw();
02245 #endif
02246 
02248         INLINE civector &SetSup(civector &iv,const complex &r) throw();
02250         INLINE civector &SetInf(civector &iv,const complex &r) throw();
02252         INLINE civector &UncheckedSetSup(civector &iv,const complex &r) throw();
02254         INLINE civector &SetUncheckedInf(civector &iv,const complex &r) throw();
02256         INLINE civector &SetRe(civector &iv,const interval &r) throw();
02258         INLINE civector &SetIm(civector &iv,const interval &r) throw();
02259 
02261         INLINE civector_slice &SetSup(civector_slice &iv,const complex &r) throw();
02263         INLINE civector_slice &SetInf(civector_slice &iv,const complex &r) throw();
02265         INLINE civector_slice &UncheckedSetSup(civector_slice &iv,const complex &r) throw();
02267         INLINE civector_slice &SetUncheckedInf(civector_slice &iv,const complex &r) throw();
02269         INLINE civector_slice &SetRe(civector_slice &iv,const interval &r) throw();
02271         INLINE civector_slice &SetIm(civector_slice &iv,const interval &r) throw();
02272 
02274         INLINE void Resize(civector &rv) throw();
02276         INLINE void Resize(civector &rv, const int &len)
02277 #if(CXSC_INDEX_CHECK)
02278         throw(ERROR__WRONG_BOUNDARIES<civector>);
02279 #else
02280         throw();
02281 #endif
02282 
02283         INLINE void Resize(civector &rv, const int &lb, const int &ub)
02284 #if(CXSC_INDEX_CHECK)
02285         throw(ERROR__WRONG_BOUNDARIES<civector>);
02286 #else
02287         throw();
02288 #endif
02289         
02291         INLINE civector conj(const civector &rv) throw();
02293         INLINE civector conj(const civector_slice &sl) throw();
02294         
02296         INLINE ivector abs(const civector &rv) throw();
02298         INLINE ivector abs(const civector_slice &sl) throw();
02300         INLINE cvector diam(const civector &v) throw();
02302         INLINE cvector diam(const civector_slice &v) throw();
02304         INLINE cvector mid(const civector &v) throw();
02306         INLINE cvector mid(const civector_slice &v) throw();
02308         INLINE cvector Inf(const civector &v) throw();
02310         INLINE cvector Inf(const civector_slice &v) throw();
02312         INLINE cvector Sup(const civector &v) throw();
02314         INLINE cvector Sup(const civector_slice &v) throw();
02316         INLINE rvector SupRe(const civector &v) throw();
02318         INLINE rvector SupIm(const civector &v) throw();
02320         INLINE rvector InfRe(const civector &v) throw();
02322         INLINE rvector InfIm(const civector &v) throw();
02324         INLINE rvector SupRe(const civector_slice &v) throw();
02326         INLINE rvector SupIm(const civector_slice &v) throw();
02328         INLINE rvector InfRe(const civector_slice &v) throw();
02330         INLINE rvector InfIm(const civector_slice &v) throw();
02332         INLINE bool operator !(const civector &rv) throw();
02334         INLINE bool operator !(const civector_slice &sl) throw();
02335 
02336 //======================= Vector / Scalar ===============================
02337 
02338 //----------------------------- cinterval ---------------------------
02339 
02341         INLINE civector operator *(const civector &rv, const cinterval &s) throw();
02343         INLINE civector operator *(const civector_slice &sl, const cinterval &s) throw();
02345         INLINE civector operator *(const cinterval &s, const civector &rv) throw();
02347         INLINE civector operator *(const cinterval &s, const civector_slice &sl) throw();
02349         INLINE civector &operator *=(civector &rv,const cinterval &r) throw();
02350 
02352         INLINE civector operator /(const civector &rv, const cinterval &s) throw();
02354         INLINE civector operator /(const civector_slice &sl, const cinterval &s) throw();
02356         INLINE civector &operator /=(civector &rv,const cinterval &r) throw();
02357 
02358 //---------------------------- Real --------------------------------------
02359 
02361         INLINE civector operator *(const civector &rv, const real &s) throw();
02363         INLINE civector operator *(const civector_slice &sl, const real &s) throw();
02365         INLINE civector operator *(const real &s, const civector &rv) throw();
02367         INLINE civector operator *(const real &s, const civector_slice &sl) throw();
02369         INLINE civector &operator *=(civector &rv,const real &r) throw();
02370 
02372         INLINE civector operator /(const civector &rv, const real &s) throw();
02374         INLINE civector operator /(const civector_slice &sl, const real &s) throw();
02376         INLINE civector &operator /=(civector &rv,const real &r) throw();
02377 
02379         INLINE civector operator *(const rvector &rv, const cinterval &s) throw();
02381         INLINE civector operator *(const rvector_slice &sl, const cinterval &s) throw();
02383         INLINE civector operator *(const cinterval &s, const rvector &rv) throw();
02385         INLINE civector operator *(const cinterval &s, const rvector_slice &sl) throw();
02386 
02388         INLINE civector operator /(const rvector &rv, const cinterval &s) throw();
02390         INLINE civector operator /(const rvector_slice &sl, const cinterval &s) throw();
02391 
02392 //---------------------------- Complex --------------------------------------
02393 
02395         INLINE civector operator *(const civector &rv, const complex &s) throw();
02397         INLINE civector operator *(const civector_slice &sl, const complex &s) throw();
02399         INLINE civector operator *(const complex &s, const civector &rv) throw();
02401         INLINE civector operator *(const complex &s, const civector_slice &sl) throw();
02403         INLINE civector &operator *=(civector &rv,const complex &r) throw();
02404 
02406         INLINE civector operator /(const civector &rv, const complex &s) throw();
02408         INLINE civector operator /(const civector_slice &sl, const complex &s) throw();
02410         INLINE civector &operator /=(civector &rv,const complex &r) throw();
02411 
02413         INLINE civector operator *(const cvector &rv, const cinterval &s) throw();
02415         INLINE civector operator *(const cvector_slice &sl, const cinterval &s) throw();
02417         INLINE civector operator *(const cinterval &s, const cvector &rv) throw();
02419         INLINE civector operator *(const cinterval &s, const cvector_slice &sl) throw();
02420 
02422         INLINE civector operator /(const cvector &rv, const cinterval &s) throw();
02424         INLINE civector operator /(const cvector_slice &sl, const cinterval &s) throw();
02425 
02426 //---------------------------- interval --------------------------------------
02427 
02429         INLINE civector operator *(const civector &rv, const interval &s) throw();
02431         INLINE civector operator *(const civector_slice &sl, const interval &s) throw();
02433         INLINE civector operator *(const interval &s, const civector &rv) throw();
02435         INLINE civector operator *(const interval &s, const civector_slice &sl) throw();
02437         INLINE civector &operator *=(civector &rv,const interval &r) throw();
02438 
02440         INLINE civector operator /(const civector &rv, const interval &s) throw();
02442         INLINE civector operator /(const civector_slice &sl, const interval &s) throw();
02444         INLINE civector &operator /=(civector &rv,const interval &r) throw();
02445 
02447         INLINE civector operator *(const ivector &rv, const cinterval &s) throw();
02449         INLINE civector operator *(const ivector_slice &sl, const cinterval &s) throw();
02451         INLINE civector operator *(const cinterval &s, const ivector &rv) throw();
02453         INLINE civector operator *(const cinterval &s, const ivector_slice &sl) throw();
02454 
02456         INLINE civector operator /(const ivector &rv, const cinterval &s) throw();
02458         INLINE civector operator /(const ivector_slice &sl, const cinterval &s) throw();
02459 
02460 //======================= Vector / Vector ===============================
02461 
02462 
02464         INLINE std::ostream &operator <<(std::ostream &s, const civector &rv) throw();
02466         INLINE std::ostream &operator <<(std::ostream &o, const civector_slice &sl) throw();
02468         INLINE std::istream &operator >>(std::istream &s, civector &rv) throw();
02470         INLINE std::istream &operator >>(std::istream &s, civector_slice &rv) throw();
02471         
02472 //----------------------- cinterval / cinterval ---------------------------
02473 
02475         void accumulate(cidotprecision &dp, const cvector &);
02476 
02478         void accumulate(cidotprecision &dp, const rvector &);
02479 
02481         void accumulate(cidotprecision &dp, const civector &);
02482 
02484         void accumulate(cidotprecision &dp, const ivector &);
02485 
02486 
02488          void accumulate(cidotprecision &dp, const civector & rv1, const civector &rv2)
02489 #if(CXSC_INDEX_CHECK)
02490         throw(OP_WITH_WRONG_DIM);
02491 #else
02492         throw();
02493 #endif
02494 
02495          void accumulate(cidotprecision &dp, const civector_slice & sl, const civector &rv)
02496 #if(CXSC_INDEX_CHECK)
02497         throw(OP_WITH_WRONG_DIM);
02498 #else
02499         throw();
02500 #endif
02501 
02502          void accumulate(cidotprecision &dp, const civector &rv, const civector_slice &sl)
02503 #if(CXSC_INDEX_CHECK)
02504         throw(OP_WITH_WRONG_DIM);
02505 #else
02506         throw();
02507 #endif
02508 
02509          void accumulate(cidotprecision &dp, const civector & rv1, const cimatrix_subv &rv2)
02510 #if(CXSC_INDEX_CHECK)
02511         throw(OP_WITH_WRONG_DIM);
02512 #else
02513         throw();
02514 #endif
02515 
02516          void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const civector &rv2)
02517 #if(CXSC_INDEX_CHECK)
02518         throw(OP_WITH_WRONG_DIM);
02519 #else
02520         throw();
02521 #endif
02522 
02523          void accumulate(cidotprecision &dp, const civector_slice & sl1, const civector_slice &sl2)
02524 #if(CXSC_INDEX_CHECK)
02525         throw(OP_WITH_WRONG_DIM);
02526 #else
02527         throw();
02528 #endif
02529 
02530         void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const cvector &rv2)
02531 #if(CXSC_INDEX_CHECK)
02532         throw(OP_WITH_WRONG_DIM);
02533 #else
02534         throw();
02535 #endif
02536 
02537         void accumulate(cidotprecision &dp, const cvector & rv1, const imatrix_subv &rv2)
02538 #if(CXSC_INDEX_CHECK)
02539         throw(OP_WITH_WRONG_DIM);
02540 #else
02541         throw();
02542 #endif
02543 
02544         void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const cvector_slice &rv2)
02545 #if(CXSC_INDEX_CHECK)
02546         throw(OP_WITH_WRONG_DIM);
02547 #else
02548         throw();
02549 #endif
02550 
02551         void accumulate(cidotprecision &dp, const cvector_slice & rv1, const imatrix_subv &rv2)
02552 #if(CXSC_INDEX_CHECK)
02553         throw(OP_WITH_WRONG_DIM);
02554 #else
02555         throw();
02556 #endif
02557 
02559         INLINE cinterval operator *(const civector & rv1, const civector &rv2)
02560 #if(CXSC_INDEX_CHECK)
02561         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02562 #else
02563         throw();
02564 #endif
02565 
02566         INLINE cinterval operator *(const civector_slice &sl, const civector &rv)
02567 #if(CXSC_INDEX_CHECK)
02568         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02569 #else
02570         throw();
02571 #endif
02572 
02573         INLINE cinterval operator *(const civector &rv, const civector_slice &sl)
02574 #if(CXSC_INDEX_CHECK)
02575         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02576 #else
02577         throw();
02578 #endif
02579 
02580         INLINE cinterval operator *(const civector_slice & sl1, const civector_slice &sl2)
02581 #if(CXSC_INDEX_CHECK)
02582         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02583 #else
02584         throw();
02585 #endif
02586         
02588         INLINE const civector &operator +(const civector &rv) throw();
02590         INLINE civector operator +(const civector_slice &sl) throw();
02591 
02593         INLINE civector operator +(const civector &rv1, const civector &rv2)
02594 #if(CXSC_INDEX_CHECK)
02595         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02596 #else
02597         throw();
02598 #endif
02599 
02600         INLINE civector operator +(const civector &rv, const civector_slice &sl)
02601 #if(CXSC_INDEX_CHECK)
02602         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02603 #else
02604         throw();
02605 #endif
02606 
02607         INLINE civector operator +(const civector_slice &sl, const civector &rv)
02608 #if(CXSC_INDEX_CHECK)
02609         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02610 #else
02611         throw();
02612 #endif
02613 
02614         INLINE civector operator +(const civector_slice &sl1, const civector_slice &sl2)
02615 #if(CXSC_INDEX_CHECK)
02616         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02617 #else
02618         throw();
02619 #endif
02620 
02621         INLINE civector & operator +=(civector &rv1, const civector &rv2)
02622 #if(CXSC_INDEX_CHECK)
02623         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02624 #else
02625         throw();
02626 #endif
02627 
02628         INLINE civector &operator +=(civector &rv, const civector_slice &sl)
02629 #if(CXSC_INDEX_CHECK)
02630         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02631 #else
02632         throw();
02633 #endif
02634 
02636         INLINE civector operator -(const civector &rv) throw();
02638         INLINE civector operator -(const civector_slice &sl) throw();
02640         INLINE civector operator -(const civector &rv1, const civector &rv2)
02641 #if(CXSC_INDEX_CHECK)
02642         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02643 #else
02644         throw();
02645 #endif
02646 
02647         INLINE civector operator -(const civector &rv, const civector_slice &sl)
02648 #if(CXSC_INDEX_CHECK)
02649         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02650 #else
02651         throw();
02652 #endif
02653 
02654         INLINE civector operator -(const civector_slice &sl, const civector &rv)
02655 #if(CXSC_INDEX_CHECK)
02656         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02657 #else
02658         throw();
02659 #endif
02660 
02661         INLINE civector operator -(const civector_slice &sl1, const civector_slice &sl2)
02662 #if(CXSC_INDEX_CHECK)
02663         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02664 #else
02665         throw();
02666 #endif
02667 
02668         INLINE civector & operator -=(civector &rv1, const civector &rv2)
02669 #if(CXSC_INDEX_CHECK)
02670         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02671 #else
02672         throw();
02673 #endif
02674 
02675         INLINE civector &operator -=(civector &rv, const civector_slice &sl)
02676 #if(CXSC_INDEX_CHECK)
02677         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02678 #else
02679         throw();
02680 #endif
02681 
02683         INLINE civector operator |(const civector &rv1, const civector &rv2)
02684 #if(CXSC_INDEX_CHECK)
02685         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02686 #else
02687         throw();
02688 #endif
02689 
02690         INLINE civector operator |(const civector &rv, const civector_slice &sl)
02691 #if(CXSC_INDEX_CHECK)
02692         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02693 #else
02694         throw();
02695 #endif
02696 
02697         INLINE civector operator |(const civector_slice &sl, const civector &rv)
02698 #if(CXSC_INDEX_CHECK)
02699         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02700 #else
02701         throw();
02702 #endif
02703 
02704         INLINE civector operator |(const civector_slice &sl1, const civector_slice &sl2)
02705 #if(CXSC_INDEX_CHECK)
02706         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02707 #else
02708         throw();
02709 #endif
02710 
02711         INLINE civector & operator |=(civector &rv1, const civector &rv2)
02712 #if(CXSC_INDEX_CHECK)
02713         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02714 #else
02715         throw();
02716 #endif
02717 
02718         INLINE civector &operator |=(civector &rv, const civector_slice &sl)
02719 #if(CXSC_INDEX_CHECK)
02720         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02721 #else
02722         throw();
02723 #endif
02724 
02726         INLINE civector operator &(const civector &rv1, const civector &rv2)
02727 #if(CXSC_INDEX_CHECK)
02728         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02729 #else
02730         throw();
02731 #endif
02732 
02733         INLINE civector operator &(const civector &rv, const civector_slice &sl)
02734 #if(CXSC_INDEX_CHECK)
02735         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02736 #else
02737         throw();
02738 #endif
02739 
02740         INLINE civector operator &(const civector_slice &sl, const civector &rv)
02741 #if(CXSC_INDEX_CHECK)
02742         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02743 #else
02744         throw();
02745 #endif
02746 
02747         INLINE civector operator &(const civector_slice &sl1, const civector_slice &sl2)
02748 #if(CXSC_INDEX_CHECK)
02749         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02750 #else
02751         throw();
02752 #endif
02753 
02754         INLINE civector & operator &=(civector &rv1, const civector &rv2)
02755 #if(CXSC_INDEX_CHECK)
02756         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02757 #else
02758         throw();
02759 #endif
02760 
02761         INLINE civector &operator &=(civector &rv, const civector_slice &sl)
02762 #if(CXSC_INDEX_CHECK)
02763         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02764 #else
02765         throw();
02766 #endif
02767 
02769         INLINE bool operator ==(const civector &rv1, const civector &rv2) throw();
02771         INLINE bool operator ==(const civector_slice &sl1, const civector_slice &sl2) throw();
02773         INLINE bool operator ==(const civector_slice &sl, const civector &rv) throw();
02775         INLINE bool operator ==(const civector &rv, const civector_slice &sl) throw();
02777         INLINE bool operator !=(const civector &rv1, const civector &rv2) throw();
02779         INLINE bool operator !=(const civector_slice &sl1, const civector_slice &sl2) throw();
02781         INLINE bool operator !=(const civector_slice &sl, const civector &rv) throw();
02783         INLINE bool operator !=(const civector &rv, const civector_slice &sl) throw();
02785         INLINE bool operator <(const civector &rv1, const civector &rv2) throw();
02787         INLINE bool operator <(const civector_slice &sl1, const civector_slice &sl2) throw();
02789         INLINE bool operator < (const civector_slice &sl, const civector &rv) throw();
02791         INLINE bool operator < (const civector &rv, const civector_slice &sl) throw();
02793         INLINE bool operator <=(const civector &rv1, const civector &rv2) throw();
02795         INLINE bool operator <=(const civector_slice &sl1, const civector_slice &sl2) throw();
02797         INLINE bool operator <=(const civector_slice &sl, const civector &rv) throw();
02799         INLINE bool operator <=(const civector &rv, const civector_slice &sl) throw();
02801         INLINE bool operator >(const civector &rv1, const civector &rv2) throw();
02803         INLINE bool operator >(const civector_slice &sl1, const civector_slice &sl2) throw();
02805         INLINE bool operator >(const civector_slice &sl, const civector &rv) throw();
02807         INLINE bool operator >(const civector &rv, const civector_slice &sl) throw();
02809         INLINE bool operator >=(const civector &rv1, const civector &rv2) throw();
02811         INLINE bool operator >=(const civector_slice &sl1, const civector_slice &sl2) throw();
02813         INLINE bool operator >=(const civector_slice &sl, const civector &rv) throw();
02815         INLINE bool operator >=(const civector &rv, const civector_slice &sl) throw();
02816 
02817 //-------------------------------- cinterval / Real --------------------------------
02818 
02820          void accumulate(cidotprecision &dp, const rvector & rv1, const civector &rv2)
02821 #if(CXSC_INDEX_CHECK)
02822         throw(OP_WITH_WRONG_DIM);
02823 #else
02824         throw();
02825 #endif
02826 
02827          void accumulate(cidotprecision &dp, const civector & rv1, const rvector &rv2)
02828 #if(CXSC_INDEX_CHECK)
02829         throw(OP_WITH_WRONG_DIM);
02830 #else
02831         throw();
02832 #endif
02833 
02834          void accumulate(cidotprecision &dp, const rvector_slice & sl, const civector &rv)
02835 #if(CXSC_INDEX_CHECK)
02836         throw(OP_WITH_WRONG_DIM);
02837 #else
02838         throw();
02839 #endif
02840 
02841          void accumulate(cidotprecision &dp,const civector_slice &sl,const rvector &rv)
02842 #if(CXSC_INDEX_CHECK)
02843         throw(OP_WITH_WRONG_DIM);
02844 #else
02845         throw();
02846 #endif
02847 
02848          void accumulate(cidotprecision &dp, const rvector &rv, const civector_slice &sl)
02849 #if(CXSC_INDEX_CHECK)
02850         throw(OP_WITH_WRONG_DIM);
02851 #else
02852         throw();
02853 #endif
02854 
02855          void accumulate(cidotprecision &dp, const rvector & rv1, const cimatrix_subv &rv2)
02856 #if(CXSC_INDEX_CHECK)
02857         throw(OP_WITH_WRONG_DIM);
02858 #else
02859         throw();
02860 #endif
02861 
02862          void accumulate(cidotprecision &dp, const civector & rv1, const rmatrix_subv &rv2)
02863 #if(CXSC_INDEX_CHECK)
02864         throw(OP_WITH_WRONG_DIM);
02865 #else
02866         throw();
02867 #endif
02868 
02869          void accumulate(cidotprecision &dp,const civector &rv,const rvector_slice &sl)
02870 #if(CXSC_INDEX_CHECK)
02871         throw(OP_WITH_WRONG_DIM);
02872 #else
02873         throw();
02874 #endif
02875 
02876          void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const civector &rv2)
02877 #if(CXSC_INDEX_CHECK)
02878         throw(OP_WITH_WRONG_DIM);
02879 #else
02880         throw();
02881 #endif
02882 
02883          void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const rvector &rv2)
02884 #if(CXSC_INDEX_CHECK)
02885         throw(OP_WITH_WRONG_DIM);
02886 #else
02887         throw();
02888 #endif
02889 
02890          void accumulate(cidotprecision &dp, const civector_slice & sl1, const rvector_slice &sl2)
02891 #if(CXSC_INDEX_CHECK)
02892         throw(OP_WITH_WRONG_DIM);
02893 #else
02894         throw();
02895 #endif
02896 
02897          void accumulate(cidotprecision &dp, const rvector_slice & sl1, const civector_slice &sl2)
02898 #if(CXSC_INDEX_CHECK)
02899         throw(OP_WITH_WRONG_DIM);
02900 #else
02901         throw();
02902 #endif
02903 
02905         INLINE cinterval operator *(const rvector & rv1, const civector &rv2)
02906 #if(CXSC_INDEX_CHECK)
02907         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02908 #else
02909         throw();
02910 #endif
02911 
02912         INLINE cinterval operator *(const rvector_slice &sl, const civector &rv)
02913 #if(CXSC_INDEX_CHECK)
02914         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02915 #else
02916         throw();
02917 #endif
02918 
02919         INLINE cinterval operator *(const rvector &rv, const civector_slice &sl)
02920 #if(CXSC_INDEX_CHECK)
02921         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02922 #else
02923         throw();
02924 #endif
02925 
02926         INLINE cinterval operator *(const rvector_slice & sl1, const civector_slice &sl2)
02927 #if(CXSC_INDEX_CHECK)
02928         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02929 #else
02930         throw();
02931 #endif
02932         
02934         INLINE cinterval operator *(const civector & rv1, const rvector &rv2)
02935 #if(CXSC_INDEX_CHECK)
02936         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02937 #else
02938         throw();
02939 #endif
02940 
02941         INLINE cinterval operator *(const civector_slice &sl, const rvector &rv)
02942 #if(CXSC_INDEX_CHECK)
02943         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02944 #else
02945         throw();
02946 #endif
02947 
02948         INLINE cinterval operator *(const civector &rv, const rvector_slice &sl)
02949 #if(CXSC_INDEX_CHECK)
02950         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02951 #else
02952         throw();
02953 #endif
02954 
02955         INLINE cinterval operator *(const civector_slice & sl1, const rvector_slice &sl2)
02956 #if(CXSC_INDEX_CHECK)
02957         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02958 #else
02959         throw();
02960 #endif
02961         
02963         INLINE civector operator +(const rvector &rv1, const civector &rv2)
02964 #if(CXSC_INDEX_CHECK)
02965         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02966 #else
02967         throw();
02968 #endif
02969 
02970         INLINE civector operator +(const rvector &rv, const civector_slice &sl)
02971 #if(CXSC_INDEX_CHECK)
02972         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02973 #else
02974         throw();
02975 #endif
02976 
02977         INLINE civector operator +(const rvector_slice &sl, const civector &rv)
02978 #if(CXSC_INDEX_CHECK)
02979         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02980 #else
02981         throw();
02982 #endif
02983 
02984         INLINE civector operator +(const rvector_slice &sl1, const civector_slice &sl2)
02985 #if(CXSC_INDEX_CHECK)
02986         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02987 #else
02988         throw();
02989 #endif
02990 
02992         INLINE civector operator +(const civector &rv1, const rvector &rv2)
02993 #if(CXSC_INDEX_CHECK)
02994         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
02995 #else
02996         throw();
02997 #endif
02998 
02999         INLINE civector operator +(const civector &rv, const rvector_slice &sl)
03000 #if(CXSC_INDEX_CHECK)
03001         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03002 #else
03003         throw();
03004 #endif
03005 
03006         INLINE civector operator +(const civector_slice &sl, const rvector &rv)
03007 #if(CXSC_INDEX_CHECK)
03008         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03009 #else
03010         throw();
03011 #endif
03012 
03013         INLINE civector operator +(const civector_slice &sl1, const rvector_slice &sl2)
03014 #if(CXSC_INDEX_CHECK)
03015         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03016 #else
03017         throw();
03018 #endif
03019 
03021         INLINE civector & operator +=(civector &rv1, const rvector &rv2)
03022 #if(CXSC_INDEX_CHECK)
03023         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03024 #else
03025         throw();
03026 #endif
03027 
03028         INLINE civector &operator +=(civector &rv, const rvector_slice &sl)
03029 #if(CXSC_INDEX_CHECK)
03030         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03031 #else
03032         throw();
03033 #endif
03034 
03036         INLINE civector operator -(const rvector &rv1, const civector &rv2)
03037 #if(CXSC_INDEX_CHECK)
03038         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03039 #else
03040         throw();
03041 #endif
03042 
03043         INLINE civector operator -(const rvector &rv, const civector_slice &sl)
03044 #if(CXSC_INDEX_CHECK)
03045         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03046 #else
03047         throw();
03048 #endif
03049 
03050         INLINE civector operator -(const rvector_slice &sl, const civector &rv)
03051 #if(CXSC_INDEX_CHECK)
03052         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03053 #else
03054         throw();
03055 #endif
03056 
03057         INLINE civector operator -(const rvector_slice &sl1, const civector_slice &sl2)
03058 #if(CXSC_INDEX_CHECK)
03059         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03060 #else
03061         throw();
03062 #endif
03063 
03065         INLINE civector operator -(const civector &rv1, const rvector &rv2)
03066 #if(CXSC_INDEX_CHECK)
03067         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03068 #else
03069         throw();
03070 #endif
03071 
03072         INLINE civector operator -(const civector &rv, const rvector_slice &sl)
03073 #if(CXSC_INDEX_CHECK)
03074         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03075 #else
03076         throw();
03077 #endif
03078 
03079         INLINE civector operator -(const civector_slice &sl, const rvector &rv)
03080 #if(CXSC_INDEX_CHECK)
03081         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03082 #else
03083         throw();
03084 #endif
03085 
03086         INLINE civector operator -(const civector_slice &sl1, const rvector_slice &sl2)
03087 #if(CXSC_INDEX_CHECK)
03088         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03089 #else
03090         throw();
03091 #endif
03092 
03094         INLINE civector & operator -=(civector &rv1, const rvector &rv2)
03095 #if(CXSC_INDEX_CHECK)
03096         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03097 #else
03098         throw();
03099 #endif
03100 
03101         INLINE civector &operator -=(civector &rv, const rvector_slice &sl)
03102 #if(CXSC_INDEX_CHECK)
03103         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03104 #else
03105         throw();
03106 #endif
03107 
03109         INLINE civector operator |(const rvector &rv1, const civector &rv2)
03110 #if(CXSC_INDEX_CHECK)
03111         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03112 #else
03113         throw();
03114 #endif
03115 
03116         INLINE civector operator |(const rvector &rv, const civector_slice &sl)
03117 #if(CXSC_INDEX_CHECK)
03118         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03119 #else
03120         throw();
03121 #endif
03122 
03123         INLINE civector operator |(const rvector_slice &sl, const civector &rv)
03124 #if(CXSC_INDEX_CHECK)
03125         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03126 #else
03127         throw();
03128 #endif
03129 
03130         INLINE civector operator |(const rvector_slice &sl1, const civector_slice &sl2)
03131 #if(CXSC_INDEX_CHECK)
03132         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03133 #else
03134         throw();
03135 #endif
03136 
03138         INLINE civector operator |(const civector &rv1, const rvector &rv2)
03139 #if(CXSC_INDEX_CHECK)
03140         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03141 #else
03142         throw();
03143 #endif
03144 
03145         INLINE civector operator |(const civector &rv, const rvector_slice &sl)
03146 #if(CXSC_INDEX_CHECK)
03147         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03148 #else
03149         throw();
03150 #endif
03151 
03152         INLINE civector operator |(const civector_slice &sl, const rvector &rv)
03153 #if(CXSC_INDEX_CHECK)
03154         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03155 #else
03156         throw();
03157 #endif
03158 
03159         INLINE civector operator |(const civector_slice &sl1, const rvector_slice &sl2)
03160 #if(CXSC_INDEX_CHECK)
03161         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03162 #else
03163         throw();
03164 #endif
03165 
03167         INLINE civector & operator |=(civector &rv1, const rvector &rv2)
03168 #if(CXSC_INDEX_CHECK)
03169         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03170 #else
03171         throw();
03172 #endif
03173 
03174         INLINE civector &operator |=(civector &rv, const rvector_slice &sl)
03175 #if(CXSC_INDEX_CHECK)
03176         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03177 #else
03178         throw();
03179 #endif
03180 
03182         INLINE civector operator &(const rvector &rv1, const civector &rv2)
03183 #if(CXSC_INDEX_CHECK)
03184         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03185 #else
03186         throw();
03187 #endif
03188 
03189         INLINE civector operator &(const rvector &rv, const civector_slice &sl)
03190 #if(CXSC_INDEX_CHECK)
03191         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03192 #else
03193         throw();
03194 #endif
03195 
03196         INLINE civector operator &(const rvector_slice &sl, const civector &rv)
03197 #if(CXSC_INDEX_CHECK)
03198         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03199 #else
03200         throw();
03201 #endif
03202 
03203         INLINE civector operator &(const rvector_slice &sl1, const civector_slice &sl2)
03204 #if(CXSC_INDEX_CHECK)
03205         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03206 #else
03207         throw();
03208 #endif
03209 
03211         INLINE civector operator &(const civector &rv1, const rvector &rv2)
03212 #if(CXSC_INDEX_CHECK)
03213         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03214 #else
03215         throw();
03216 #endif
03217 
03218         INLINE civector operator &(const civector &rv, const rvector_slice &sl)
03219 #if(CXSC_INDEX_CHECK)
03220         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03221 #else
03222         throw();
03223 #endif
03224 
03225         INLINE civector operator &(const civector_slice &sl, const rvector &rv)
03226 #if(CXSC_INDEX_CHECK)
03227         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03228 #else
03229         throw();
03230 #endif
03231 
03232         INLINE civector operator &(const civector_slice &sl1, const rvector_slice &sl2)
03233 #if(CXSC_INDEX_CHECK)
03234         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03235 #else
03236         throw();
03237 #endif
03238 
03240         INLINE civector & operator &=(civector &rv1, const rvector &rv2)
03241 #if(CXSC_INDEX_CHECK)
03242         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03243 #else
03244         throw();
03245 #endif
03246 
03247         INLINE civector &operator &=(civector &rv, const rvector_slice &sl)
03248 #if(CXSC_INDEX_CHECK)
03249         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03250 #else
03251         throw();
03252 #endif
03253 //-------------------------------- cinterval / complex --------------------------------
03254 
03256          void accumulate(cidotprecision &dp, const cvector & rv1, const civector &rv2)
03257 #if(CXSC_INDEX_CHECK)
03258         throw(OP_WITH_WRONG_DIM);
03259 #else
03260         throw();
03261 #endif
03262 
03263          void accumulate(cidotprecision &dp, const civector & rv1, const cvector &rv2)
03264 #if(CXSC_INDEX_CHECK)
03265         throw(OP_WITH_WRONG_DIM);
03266 #else
03267         throw();
03268 #endif
03269 
03270          void accumulate(cidotprecision &dp, const cvector_slice & sl, const civector &rv)
03271 #if(CXSC_INDEX_CHECK)
03272         throw(OP_WITH_WRONG_DIM);
03273 #else
03274         throw();
03275 #endif
03276 
03277          void accumulate(cidotprecision &dp,const civector_slice &sl,const cvector &rv)
03278 #if(CXSC_INDEX_CHECK)
03279         throw(OP_WITH_WRONG_DIM);
03280 #else
03281         throw();
03282 #endif
03283 
03284          void accumulate(cidotprecision &dp, const cvector &rv, const civector_slice &sl)
03285 #if(CXSC_INDEX_CHECK)
03286         throw(OP_WITH_WRONG_DIM);
03287 #else
03288         throw();
03289 #endif
03290 
03291          void accumulate(cidotprecision &dp, const cvector & rv1, const cimatrix_subv &rv2)
03292 #if(CXSC_INDEX_CHECK)
03293         throw(OP_WITH_WRONG_DIM);
03294 #else
03295         throw();
03296 #endif
03297 
03298          void accumulate(cidotprecision &dp, const civector & rv1, const cmatrix_subv &rv2)
03299 #if(CXSC_INDEX_CHECK)
03300         throw(OP_WITH_WRONG_DIM);
03301 #else
03302         throw();
03303 #endif
03304 
03305          void accumulate(cidotprecision &dp,const civector &rv,const cvector_slice &sl)
03306 #if(CXSC_INDEX_CHECK)
03307         throw(OP_WITH_WRONG_DIM);
03308 #else
03309         throw();
03310 #endif
03311 
03312          void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const civector &rv2)
03313 #if(CXSC_INDEX_CHECK)
03314         throw(OP_WITH_WRONG_DIM);
03315 #else
03316         throw();
03317 #endif
03318 
03319          void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const cvector &rv2)
03320 #if(CXSC_INDEX_CHECK)
03321         throw(OP_WITH_WRONG_DIM);
03322 #else
03323         throw();
03324 #endif
03325 
03326          void accumulate(cidotprecision &dp, const civector_slice & sl1, const cvector_slice &sl2)
03327 #if(CXSC_INDEX_CHECK)
03328         throw(OP_WITH_WRONG_DIM);
03329 #else
03330         throw();
03331 #endif
03332 
03333          void accumulate(cidotprecision &dp, const cvector_slice & sl1, const civector_slice &sl2)
03334 #if(CXSC_INDEX_CHECK)
03335         throw(OP_WITH_WRONG_DIM);
03336 #else
03337         throw();
03338 #endif
03339 
03340 
03341 
03342 
03344         INLINE cinterval operator *(const cvector & rv1, const civector &rv2)
03345 #if(CXSC_INDEX_CHECK)
03346         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03347 #else
03348         throw();
03349 #endif
03350 
03351         INLINE cinterval operator *(const cvector_slice &sl, const civector &rv)
03352 #if(CXSC_INDEX_CHECK)
03353         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03354 #else
03355         throw();
03356 #endif
03357 
03358         INLINE cinterval operator *(const cvector &rv, const civector_slice &sl)
03359 #if(CXSC_INDEX_CHECK)
03360         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03361 #else
03362         throw();
03363 #endif
03364 
03365         INLINE cinterval operator *(const cvector_slice & sl1, const civector_slice &sl2)
03366 #if(CXSC_INDEX_CHECK)
03367         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03368 #else
03369         throw();
03370 #endif
03371         
03373         INLINE cinterval operator *(const civector & rv1, const cvector &rv2)
03374 #if(CXSC_INDEX_CHECK)
03375         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03376 #else
03377         throw();
03378 #endif
03379 
03380         INLINE cinterval operator *(const civector_slice &sl, const cvector &rv)
03381 #if(CXSC_INDEX_CHECK)
03382         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03383 #else
03384         throw();
03385 #endif
03386 
03387         INLINE cinterval operator *(const civector &rv, const cvector_slice &sl)
03388 #if(CXSC_INDEX_CHECK)
03389         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03390 #else
03391         throw();
03392 #endif
03393 
03394         INLINE cinterval operator *(const civector_slice & sl1, const cvector_slice &sl2)
03395 #if(CXSC_INDEX_CHECK)
03396         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03397 #else
03398         throw();
03399 #endif
03400         
03402         INLINE civector operator +(const cvector &rv1, const civector &rv2)
03403 #if(CXSC_INDEX_CHECK)
03404         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03405 #else
03406         throw();
03407 #endif
03408 
03409         INLINE civector operator +(const cvector &rv, const civector_slice &sl)
03410 #if(CXSC_INDEX_CHECK)
03411         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03412 #else
03413         throw();
03414 #endif
03415 
03416         INLINE civector operator +(const cvector_slice &sl, const civector &rv)
03417 #if(CXSC_INDEX_CHECK)
03418         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03419 #else
03420         throw();
03421 #endif
03422 
03423         INLINE civector operator +(const cvector_slice &sl1, const civector_slice &sl2)
03424 #if(CXSC_INDEX_CHECK)
03425         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03426 #else
03427         throw();
03428 #endif
03429 
03431         INLINE civector operator +(const civector &rv1, const cvector &rv2)
03432 #if(CXSC_INDEX_CHECK)
03433         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03434 #else
03435         throw();
03436 #endif
03437 
03438         INLINE civector operator +(const civector &rv, const cvector_slice &sl)
03439 #if(CXSC_INDEX_CHECK)
03440         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03441 #else
03442         throw();
03443 #endif
03444 
03445         INLINE civector operator +(const civector_slice &sl, const cvector &rv)
03446 #if(CXSC_INDEX_CHECK)
03447         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03448 #else
03449         throw();
03450 #endif
03451 
03452         INLINE civector operator +(const civector_slice &sl1, const cvector_slice &sl2)
03453 #if(CXSC_INDEX_CHECK)
03454         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03455 #else
03456         throw();
03457 #endif
03458 
03460         INLINE civector & operator +=(civector &rv1, const cvector &rv2)
03461 #if(CXSC_INDEX_CHECK)
03462         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03463 #else
03464         throw();
03465 #endif
03466 
03467         INLINE civector &operator +=(civector &rv, const cvector_slice &sl)
03468 #if(CXSC_INDEX_CHECK)
03469         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03470 #else
03471         throw();
03472 #endif
03473 
03475         INLINE civector operator -(const cvector &rv1, const civector &rv2)
03476 #if(CXSC_INDEX_CHECK)
03477         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03478 #else
03479         throw();
03480 #endif
03481 
03482         INLINE civector operator -(const cvector &rv, const civector_slice &sl)
03483 #if(CXSC_INDEX_CHECK)
03484         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03485 #else
03486         throw();
03487 #endif
03488 
03489         INLINE civector operator -(const cvector_slice &sl, const civector &rv)
03490 #if(CXSC_INDEX_CHECK)
03491         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03492 #else
03493         throw();
03494 #endif
03495 
03496         INLINE civector operator -(const cvector_slice &sl1, const civector_slice &sl2)
03497 #if(CXSC_INDEX_CHECK)
03498         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03499 #else
03500         throw();
03501 #endif
03502 
03504         INLINE civector operator -(const civector &rv1, const cvector &rv2)
03505 #if(CXSC_INDEX_CHECK)
03506         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03507 #else
03508         throw();
03509 #endif
03510 
03511         INLINE civector operator -(const civector &rv, const cvector_slice &sl)
03512 #if(CXSC_INDEX_CHECK)
03513         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03514 #else
03515         throw();
03516 #endif
03517 
03518         INLINE civector operator -(const civector_slice &sl, const cvector &rv)
03519 #if(CXSC_INDEX_CHECK)
03520         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03521 #else
03522         throw();
03523 #endif
03524 
03525         INLINE civector operator -(const civector_slice &sl1, const cvector_slice &sl2)
03526 #if(CXSC_INDEX_CHECK)
03527         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03528 #else
03529         throw();
03530 #endif
03531 
03533         INLINE civector & operator -=(civector &rv1, const cvector &rv2)
03534 #if(CXSC_INDEX_CHECK)
03535         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03536 #else
03537         throw();
03538 #endif
03539 
03540         INLINE civector &operator -=(civector &rv, const cvector_slice &sl)
03541 #if(CXSC_INDEX_CHECK)
03542         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03543 #else
03544         throw();
03545 #endif
03546 
03548         INLINE civector operator |(const cvector &rv1, const civector &rv2)
03549 #if(CXSC_INDEX_CHECK)
03550         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03551 #else
03552         throw();
03553 #endif
03554 
03555         INLINE civector operator |(const cvector &rv, const civector_slice &sl)
03556 #if(CXSC_INDEX_CHECK)
03557         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03558 #else
03559         throw();
03560 #endif
03561 
03562         INLINE civector operator |(const cvector_slice &sl, const civector &rv)
03563 #if(CXSC_INDEX_CHECK)
03564         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03565 #else
03566         throw();
03567 #endif
03568 
03569         INLINE civector operator |(const cvector_slice &sl1, const civector_slice &sl2)
03570 #if(CXSC_INDEX_CHECK)
03571         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03572 #else
03573         throw();
03574 #endif
03575 
03577         INLINE civector operator |(const civector &rv1, const cvector &rv2)
03578 #if(CXSC_INDEX_CHECK)
03579         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03580 #else
03581         throw();
03582 #endif
03583 
03584         INLINE civector operator |(const civector &rv, const cvector_slice &sl)
03585 #if(CXSC_INDEX_CHECK)
03586         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03587 #else
03588         throw();
03589 #endif
03590 
03591         INLINE civector operator |(const civector_slice &sl, const cvector &rv)
03592 #if(CXSC_INDEX_CHECK)
03593         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03594 #else
03595         throw();
03596 #endif
03597 
03598         INLINE civector operator |(const civector_slice &sl1, const cvector_slice &sl2)
03599 #if(CXSC_INDEX_CHECK)
03600         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03601 #else
03602         throw();
03603 #endif
03604 
03606         INLINE civector & operator |=(civector &rv1, const cvector &rv2)
03607 #if(CXSC_INDEX_CHECK)
03608         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03609 #else
03610         throw();
03611 #endif
03612 
03613         INLINE civector &operator |=(civector &rv, const cvector_slice &sl)
03614 #if(CXSC_INDEX_CHECK)
03615         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03616 #else
03617         throw();
03618 #endif
03619 
03621         INLINE civector operator &(const cvector &rv1, const civector &rv2)
03622 #if(CXSC_INDEX_CHECK)
03623         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03624 #else
03625         throw();
03626 #endif
03627 
03628         INLINE civector operator &(const cvector &rv, const civector_slice &sl)
03629 #if(CXSC_INDEX_CHECK)
03630         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03631 #else
03632         throw();
03633 #endif
03634 
03635         INLINE civector operator &(const cvector_slice &sl, const civector &rv)
03636 #if(CXSC_INDEX_CHECK)
03637         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03638 #else
03639         throw();
03640 #endif
03641 
03642         INLINE civector operator &(const cvector_slice &sl1, const civector_slice &sl2)
03643 #if(CXSC_INDEX_CHECK)
03644         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03645 #else
03646         throw();
03647 #endif
03648 
03650         INLINE civector operator &(const civector &rv1, const cvector &rv2)
03651 #if(CXSC_INDEX_CHECK)
03652         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03653 #else
03654         throw();
03655 #endif
03656 
03657         INLINE civector operator &(const civector &rv, const cvector_slice &sl)
03658 #if(CXSC_INDEX_CHECK)
03659         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03660 #else
03661         throw();
03662 #endif
03663 
03664         INLINE civector operator &(const civector_slice &sl, const cvector &rv)
03665 #if(CXSC_INDEX_CHECK)
03666         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03667 #else
03668         throw();
03669 #endif
03670 
03671         INLINE civector operator &(const civector_slice &sl1, const cvector_slice &sl2)
03672 #if(CXSC_INDEX_CHECK)
03673         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03674 #else
03675         throw();
03676 #endif
03677 
03679         INLINE civector & operator &=(civector &rv1, const cvector &rv2)
03680 #if(CXSC_INDEX_CHECK)
03681         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03682 #else
03683         throw();
03684 #endif
03685 
03686         INLINE civector &operator &=(civector &rv, const cvector_slice &sl)
03687 #if(CXSC_INDEX_CHECK)
03688         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03689 #else
03690         throw();
03691 #endif
03692 
03693 //-------------------------------- cinterval / interval --------------------------------
03694 
03696          void accumulate(cidotprecision &dp, const ivector & rv1, const civector &rv2)
03697 #if(CXSC_INDEX_CHECK)
03698         throw(OP_WITH_WRONG_DIM);
03699 #else
03700         throw();
03701 #endif
03702 
03703          void accumulate(cidotprecision &dp, const civector & rv1, const ivector &rv2)
03704 #if(CXSC_INDEX_CHECK)
03705         throw(OP_WITH_WRONG_DIM);
03706 #else
03707         throw();
03708 #endif
03709 
03710          void accumulate(cidotprecision &dp, const ivector_slice & sl, const civector &rv)
03711 #if(CXSC_INDEX_CHECK)
03712         throw(OP_WITH_WRONG_DIM);
03713 #else
03714         throw();
03715 #endif
03716 
03717          void accumulate(cidotprecision &dp,const civector_slice &sl,const ivector &rv)
03718 #if(CXSC_INDEX_CHECK)
03719         throw(OP_WITH_WRONG_DIM);
03720 #else
03721         throw();
03722 #endif
03723 
03724          void accumulate(cidotprecision &dp, const ivector &rv, const civector_slice &sl)
03725 #if(CXSC_INDEX_CHECK)
03726         throw(OP_WITH_WRONG_DIM);
03727 #else
03728         throw();
03729 #endif
03730 
03731          void accumulate(cidotprecision &dp, const ivector & rv1, const cimatrix_subv &rv2)
03732 #if(CXSC_INDEX_CHECK)
03733         throw(OP_WITH_WRONG_DIM);
03734 #else
03735         throw();
03736 #endif
03737 
03738          void accumulate(cidotprecision &dp, const civector & rv1, const imatrix_subv &rv2)
03739 #if(CXSC_INDEX_CHECK)
03740         throw(OP_WITH_WRONG_DIM);
03741 #else
03742         throw();
03743 #endif
03744 
03745          void accumulate(cidotprecision &dp,const civector &rv,const ivector_slice &sl)
03746 #if(CXSC_INDEX_CHECK)
03747         throw(OP_WITH_WRONG_DIM);
03748 #else
03749         throw();
03750 #endif
03751 
03752          void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const civector &rv2)
03753 #if(CXSC_INDEX_CHECK)
03754         throw(OP_WITH_WRONG_DIM);
03755 #else
03756         throw();
03757 #endif
03758 
03759          void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const ivector &rv2)
03760 #if(CXSC_INDEX_CHECK)
03761         throw(OP_WITH_WRONG_DIM);
03762 #else
03763         throw();
03764 #endif
03765 
03766          void accumulate(cidotprecision &dp, const civector_slice & sl1, const ivector_slice &sl2)
03767 #if(CXSC_INDEX_CHECK)
03768         throw(OP_WITH_WRONG_DIM);
03769 #else
03770         throw();
03771 #endif
03772 
03773          void accumulate(cidotprecision &dp, const ivector_slice & sl1, const civector_slice &sl2)
03774 #if(CXSC_INDEX_CHECK)
03775         throw(OP_WITH_WRONG_DIM);
03776 #else
03777         throw();
03778 #endif
03779 
03780         void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const civector &rv2)
03781 #if(CXSC_INDEX_CHECK)
03782         throw(OP_WITH_WRONG_DIM);
03783 #else
03784         throw();
03785 #endif
03786 
03787         void accumulate(cidotprecision &dp, const civector & rv1, const cmatrix_subv &rv2)
03788 #if(CXSC_INDEX_CHECK)
03789         throw(OP_WITH_WRONG_DIM);
03790 #else
03791         throw();
03792 #endif
03793 
03794         void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const civector_slice &rv2)
03795 #if(CXSC_INDEX_CHECK)
03796         throw(OP_WITH_WRONG_DIM);
03797 #else
03798         throw();
03799 #endif
03800 
03801         void accumulate(cidotprecision &dp, const civector_slice & rv1, const cmatrix_subv &rv2)
03802 #if(CXSC_INDEX_CHECK)
03803         throw(OP_WITH_WRONG_DIM);
03804 #else
03805         throw();
03806 #endif
03807 
03809          void accumulate(cidotprecision &dp, const civector_slice & sl1, const rmatrix_subv &sl2)
03810 #if(CXSC_INDEX_CHECK)
03811         throw(OP_WITH_WRONG_DIM);
03812 #else
03813         throw();
03814 #endif
03815 
03816          void accumulate(cidotprecision &dp, const rmatrix_subv & sl1, const civector_slice &sl2)
03817 #if(CXSC_INDEX_CHECK)
03818         throw(OP_WITH_WRONG_DIM);
03819 #else
03820         throw();
03821 #endif
03822 
03824         INLINE cinterval operator *(const ivector & rv1, const civector &rv2)
03825 #if(CXSC_INDEX_CHECK)
03826         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03827 #else
03828         throw();
03829 #endif
03830 
03831         INLINE cinterval operator *(const ivector_slice &sl, const civector &rv)
03832 #if(CXSC_INDEX_CHECK)
03833         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03834 #else
03835         throw();
03836 #endif
03837 
03838         INLINE cinterval operator *(const ivector &rv, const civector_slice &sl)
03839 #if(CXSC_INDEX_CHECK)
03840         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03841 #else
03842         throw();
03843 #endif
03844 
03845         INLINE cinterval operator *(const ivector_slice & sl1, const civector_slice &sl2)
03846 #if(CXSC_INDEX_CHECK)
03847         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03848 #else
03849         throw();
03850 #endif
03851         
03853         INLINE cinterval operator *(const civector & rv1, const ivector &rv2)
03854 #if(CXSC_INDEX_CHECK)
03855         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03856 #else
03857         throw();
03858 #endif
03859 
03860         INLINE cinterval operator *(const civector_slice &sl, const ivector &rv)
03861 #if(CXSC_INDEX_CHECK)
03862         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03863 #else
03864         throw();
03865 #endif
03866 
03867         INLINE cinterval operator *(const civector &rv, const ivector_slice &sl)
03868 #if(CXSC_INDEX_CHECK)
03869         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03870 #else
03871         throw();
03872 #endif
03873 
03874         INLINE cinterval operator *(const civector_slice & sl1, const ivector_slice &sl2)
03875 #if(CXSC_INDEX_CHECK)
03876         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03877 #else
03878         throw();
03879 #endif
03880         
03882         INLINE civector operator +(const ivector &rv1, const civector &rv2)
03883 #if(CXSC_INDEX_CHECK)
03884         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03885 #else
03886         throw();
03887 #endif
03888 
03889         INLINE civector operator +(const ivector &rv, const civector_slice &sl)
03890 #if(CXSC_INDEX_CHECK)
03891         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03892 #else
03893         throw();
03894 #endif
03895 
03896         INLINE civector operator +(const ivector_slice &sl, const civector &rv)
03897 #if(CXSC_INDEX_CHECK)
03898         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03899 #else
03900         throw();
03901 #endif
03902 
03903         INLINE civector operator +(const ivector_slice &sl1, const civector_slice &sl2)
03904 #if(CXSC_INDEX_CHECK)
03905         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03906 #else
03907         throw();
03908 #endif
03909 
03911         INLINE civector operator +(const civector &rv1, const ivector &rv2)
03912 #if(CXSC_INDEX_CHECK)
03913         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03914 #else
03915         throw();
03916 #endif
03917 
03918         INLINE civector operator +(const civector &rv, const ivector_slice &sl)
03919 #if(CXSC_INDEX_CHECK)
03920         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03921 #else
03922         throw();
03923 #endif
03924 
03925         INLINE civector operator +(const civector_slice &sl, const ivector &rv)
03926 #if(CXSC_INDEX_CHECK)
03927         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03928 #else
03929         throw();
03930 #endif
03931 
03932         INLINE civector operator +(const civector_slice &sl1, const ivector_slice &sl2)
03933 #if(CXSC_INDEX_CHECK)
03934         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03935 #else
03936         throw();
03937 #endif
03938 
03940         INLINE civector & operator +=(civector &rv1, const ivector &rv2)
03941 #if(CXSC_INDEX_CHECK)
03942         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03943 #else
03944         throw();
03945 #endif
03946 
03947         INLINE civector &operator +=(civector &rv, const ivector_slice &sl)
03948 #if(CXSC_INDEX_CHECK)
03949         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03950 #else
03951         throw();
03952 #endif
03953 
03955         INLINE civector operator -(const ivector &rv1, const civector &rv2)
03956 #if(CXSC_INDEX_CHECK)
03957         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03958 #else
03959         throw();
03960 #endif
03961 
03962         INLINE civector operator -(const ivector &rv, const civector_slice &sl)
03963 #if(CXSC_INDEX_CHECK)
03964         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03965 #else
03966         throw();
03967 #endif
03968 
03969         INLINE civector operator -(const ivector_slice &sl, const civector &rv)
03970 #if(CXSC_INDEX_CHECK)
03971         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03972 #else
03973         throw();
03974 #endif
03975 
03976         INLINE civector operator -(const ivector_slice &sl1, const civector_slice &sl2)
03977 #if(CXSC_INDEX_CHECK)
03978         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03979 #else
03980         throw();
03981 #endif
03982 
03984         INLINE civector operator -(const civector &rv1, const ivector &rv2)
03985 #if(CXSC_INDEX_CHECK)
03986         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03987 #else
03988         throw();
03989 #endif
03990 
03991         INLINE civector operator -(const civector &rv, const ivector_slice &sl)
03992 #if(CXSC_INDEX_CHECK)
03993         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
03994 #else
03995         throw();
03996 #endif
03997 
03998         INLINE civector operator -(const civector_slice &sl, const ivector &rv)
03999 #if(CXSC_INDEX_CHECK)
04000         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04001 #else
04002         throw();
04003 #endif
04004 
04005         INLINE civector operator -(const civector_slice &sl1, const ivector_slice &sl2)
04006 #if(CXSC_INDEX_CHECK)
04007         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04008 #else
04009         throw();
04010 #endif
04011 
04013         INLINE civector & operator -=(civector &rv1, const ivector &rv2)
04014 #if(CXSC_INDEX_CHECK)
04015         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04016 #else
04017         throw();
04018 #endif
04019 
04020         INLINE civector &operator -=(civector &rv, const ivector_slice &sl)
04021 #if(CXSC_INDEX_CHECK)
04022         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04023 #else
04024         throw();
04025 #endif
04026 
04028         INLINE civector operator |(const ivector &rv1, const civector &rv2)
04029 #if(CXSC_INDEX_CHECK)
04030         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04031 #else
04032         throw();
04033 #endif
04034 
04035         INLINE civector operator |(const ivector &rv, const civector_slice &sl)
04036 #if(CXSC_INDEX_CHECK)
04037         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04038 #else
04039         throw();
04040 #endif
04041 
04042         INLINE civector operator |(const ivector_slice &sl, const civector &rv)
04043 #if(CXSC_INDEX_CHECK)
04044         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04045 #else
04046         throw();
04047 #endif
04048 
04049         INLINE civector operator |(const ivector_slice &sl1, const civector_slice &sl2)
04050 #if(CXSC_INDEX_CHECK)
04051         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04052 #else
04053         throw();
04054 #endif
04055 
04057         INLINE civector operator |(const civector &rv1, const ivector &rv2)
04058 #if(CXSC_INDEX_CHECK)
04059         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04060 #else
04061         throw();
04062 #endif
04063 
04064         INLINE civector operator |(const civector &rv, const ivector_slice &sl)
04065 #if(CXSC_INDEX_CHECK)
04066         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04067 #else
04068         throw();
04069 #endif
04070 
04071         INLINE civector operator |(const civector_slice &sl, const ivector &rv)
04072 #if(CXSC_INDEX_CHECK)
04073         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04074 #else
04075         throw();
04076 #endif
04077 
04078         INLINE civector operator |(const civector_slice &sl1, const ivector_slice &sl2)
04079 #if(CXSC_INDEX_CHECK)
04080         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04081 #else
04082         throw();
04083 #endif
04084 
04086         INLINE civector & operator |=(civector &rv1, const ivector &rv2)
04087 #if(CXSC_INDEX_CHECK)
04088         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04089 #else
04090         throw();
04091 #endif
04092 
04093         INLINE civector &operator |=(civector &rv, const ivector_slice &sl)
04094 #if(CXSC_INDEX_CHECK)
04095         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04096 #else
04097         throw();
04098 #endif
04099 
04101         INLINE civector operator &(const ivector &rv1, const civector &rv2)
04102 #if(CXSC_INDEX_CHECK)
04103         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04104 #else
04105         throw();
04106 #endif
04107 
04108         INLINE civector operator &(const ivector &rv, const civector_slice &sl)
04109 #if(CXSC_INDEX_CHECK)
04110         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04111 #else
04112         throw();
04113 #endif
04114 
04115         INLINE civector operator &(const ivector_slice &sl, const civector &rv)
04116 #if(CXSC_INDEX_CHECK)
04117         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04118 #else
04119         throw();
04120 #endif
04121 
04122         INLINE civector operator &(const ivector_slice &sl1, const civector_slice &sl2)
04123 #if(CXSC_INDEX_CHECK)
04124         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04125 #else
04126         throw();
04127 #endif
04128 
04130         INLINE civector operator &(const civector &rv1, const ivector &rv2)
04131 #if(CXSC_INDEX_CHECK)
04132         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04133 #else
04134         throw();
04135 #endif
04136 
04137         INLINE civector operator &(const civector &rv, const ivector_slice &sl)
04138 #if(CXSC_INDEX_CHECK)
04139         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04140 #else
04141         throw();
04142 #endif
04143 
04144         INLINE civector operator &(const civector_slice &sl, const ivector &rv)
04145 #if(CXSC_INDEX_CHECK)
04146         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04147 #else
04148         throw();
04149 #endif
04150 
04151         INLINE civector operator &(const civector_slice &sl1, const ivector_slice &sl2)
04152 #if(CXSC_INDEX_CHECK)
04153         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04154 #else
04155         throw();
04156 #endif
04157 
04159         INLINE civector & operator &=(civector &rv1, const ivector &rv2)
04160 #if(CXSC_INDEX_CHECK)
04161         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04162 #else
04163         throw();
04164 #endif
04165 
04166         INLINE civector &operator &=(civector &rv, const ivector_slice &sl)
04167 #if(CXSC_INDEX_CHECK)
04168         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04169 #else
04170         throw();
04171 #endif
04172 
04173 //------------- real x complex ------------------------
04175         INLINE civector operator |(const rvector &rv1, const cvector &rv2)
04176 #if(CXSC_INDEX_CHECK)
04177         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04178 #else
04179         throw();
04180 #endif
04181 
04182         INLINE civector operator |(const cvector &rv1, const rvector &rv2)
04183 #if(CXSC_INDEX_CHECK)
04184         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04185 #else
04186         throw();
04187 #endif
04188 
04189         INLINE civector operator |(const cvector &rv, const rvector_slice &sl)
04190 #if(CXSC_INDEX_CHECK)
04191         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04192 #else
04193         throw();
04194 #endif
04195 
04196         INLINE civector operator |(const rvector_slice &sl,const cvector &rv)
04197 #if(CXSC_INDEX_CHECK)
04198         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04199 #else
04200         throw();
04201 #endif
04202 
04203         INLINE civector operator |(const cvector_slice &sl, const rvector &rv)
04204 #if(CXSC_INDEX_CHECK)
04205         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04206 #else
04207         throw();
04208 #endif
04209 
04210         INLINE civector operator |(const rvector &rv,const cvector_slice &sl)
04211 #if(CXSC_INDEX_CHECK)
04212         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04213 #else
04214         throw();
04215 #endif
04216 
04217         INLINE civector operator |(const cvector_slice &sl1, const rvector_slice &sl2)
04218 #if(CXSC_INDEX_CHECK)
04219         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04220 #else
04221         throw();
04222 #endif
04223 
04224         INLINE civector operator |(const rvector_slice &sl1, const cvector_slice &sl2)
04225 #if(CXSC_INDEX_CHECK)
04226         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04227 #else
04228         throw();
04229 #endif
04230 
04231 //------------- complex x complex ------------------------
04233         INLINE civector operator |(const cvector &rv1, const cvector &rv2)
04234 #if(CXSC_INDEX_CHECK)
04235         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04236 #else
04237         throw();
04238 #endif
04239 
04240         INLINE civector operator |(const cvector_slice &sl, const cvector &rv)
04241 #if(CXSC_INDEX_CHECK)
04242         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04243 #else
04244         throw();
04245 #endif
04246 
04247         INLINE civector operator |(const cvector &rv,const cvector_slice &sl)
04248 #if(CXSC_INDEX_CHECK)
04249         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04250 #else
04251         throw();
04252 #endif
04253 
04254         INLINE civector operator |(const cvector_slice &sl1, const cvector_slice &sl2)
04255 #if(CXSC_INDEX_CHECK)
04256         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04257 #else
04258         throw();
04259 #endif
04260 
04261 //-------------------------------- interval / complex --------------------------------
04262 
04263 // multiplication in iveccvec.hpp
04264         
04266         INLINE civector operator +(const cvector &rv1, const ivector &rv2)
04267 #if(CXSC_INDEX_CHECK)
04268         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04269 #else
04270         throw();
04271 #endif
04272 
04273         INLINE civector operator +(const cvector &rv, const ivector_slice &sl)
04274 #if(CXSC_INDEX_CHECK)
04275         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04276 #else
04277         throw();
04278 #endif
04279 
04280         INLINE civector operator +(const cvector_slice &sl, const ivector &rv)
04281 #if(CXSC_INDEX_CHECK)
04282         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04283 #else
04284         throw();
04285 #endif
04286 
04287         INLINE civector operator +(const cvector_slice &sl1, const ivector_slice &sl2)
04288 #if(CXSC_INDEX_CHECK)
04289         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04290 #else
04291         throw();
04292 #endif
04293 
04295         INLINE civector operator +(const ivector &rv1, const cvector &rv2)
04296 #if(CXSC_INDEX_CHECK)
04297         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04298 #else
04299         throw();
04300 #endif
04301 
04302         INLINE civector operator +(const ivector &rv, const cvector_slice &sl)
04303 #if(CXSC_INDEX_CHECK)
04304         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04305 #else
04306         throw();
04307 #endif
04308 
04309         INLINE civector operator +(const ivector_slice &sl, const cvector &rv)
04310 #if(CXSC_INDEX_CHECK)
04311         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04312 #else
04313         throw();
04314 #endif
04315 
04316         INLINE civector operator +(const ivector_slice &sl1, const cvector_slice &sl2)
04317 #if(CXSC_INDEX_CHECK)
04318         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04319 #else
04320         throw();
04321 #endif
04322 
04323 
04325         INLINE civector operator -(const cvector &rv1, const ivector &rv2)
04326 #if(CXSC_INDEX_CHECK)
04327         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04328 #else
04329         throw();
04330 #endif
04331 
04332         INLINE civector operator -(const cvector &rv, const ivector_slice &sl)
04333 #if(CXSC_INDEX_CHECK)
04334         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04335 #else
04336         throw();
04337 #endif
04338 
04339         INLINE civector operator -(const cvector_slice &sl, const ivector &rv)
04340 #if(CXSC_INDEX_CHECK)
04341         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04342 #else
04343         throw();
04344 #endif
04345 
04346         INLINE civector operator -(const cvector_slice &sl1, const ivector_slice &sl2)
04347 #if(CXSC_INDEX_CHECK)
04348         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04349 #else
04350         throw();
04351 #endif
04352 
04354         INLINE civector operator -(const ivector &rv1, const cvector &rv2)
04355 #if(CXSC_INDEX_CHECK)
04356         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04357 #else
04358         throw();
04359 #endif
04360 
04361         INLINE civector operator -(const ivector &rv, const cvector_slice &sl)
04362 #if(CXSC_INDEX_CHECK)
04363         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04364 #else
04365         throw();
04366 #endif
04367 
04368         INLINE civector operator -(const ivector_slice &sl, const cvector &rv)
04369 #if(CXSC_INDEX_CHECK)
04370         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04371 #else
04372         throw();
04373 #endif
04374 
04375         INLINE civector operator -(const ivector_slice &sl1, const cvector_slice &sl2)
04376 #if(CXSC_INDEX_CHECK)
04377         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04378 #else
04379         throw();
04380 #endif
04381 
04382 
04384         INLINE civector operator |(const cvector &rv1, const ivector &rv2)
04385 #if(CXSC_INDEX_CHECK)
04386         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04387 #else
04388         throw();
04389 #endif
04390 
04391         INLINE civector operator |(const cvector &rv, const ivector_slice &sl)
04392 #if(CXSC_INDEX_CHECK)
04393         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04394 #else
04395         throw();
04396 #endif
04397 
04398         INLINE civector operator |(const cvector_slice &sl, const ivector &rv)
04399 #if(CXSC_INDEX_CHECK)
04400         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04401 #else
04402         throw();
04403 #endif
04404 
04405         INLINE civector operator |(const cvector_slice &sl1, const ivector_slice &sl2)
04406 #if(CXSC_INDEX_CHECK)
04407         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04408 #else
04409         throw();
04410 #endif
04411 
04413         INLINE civector operator |(const ivector &rv1, const cvector &rv2)
04414 #if(CXSC_INDEX_CHECK)
04415         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04416 #else
04417         throw();
04418 #endif
04419 
04420         INLINE civector operator |(const ivector &rv, const cvector_slice &sl)
04421 #if(CXSC_INDEX_CHECK)
04422         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04423 #else
04424         throw();
04425 #endif
04426 
04427         INLINE civector operator |(const ivector_slice &sl, const cvector &rv)
04428 #if(CXSC_INDEX_CHECK)
04429         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04430 #else
04431         throw();
04432 #endif
04433 
04434         INLINE civector operator |(const ivector_slice &sl1, const cvector_slice &sl2)
04435 #if(CXSC_INDEX_CHECK)
04436         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04437 #else
04438         throw();
04439 #endif
04440 
04442         INLINE civector operator &(const cvector &rv1, const ivector &rv2)
04443 #if(CXSC_INDEX_CHECK)
04444         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04445 #else
04446         throw();
04447 #endif
04448 
04449         INLINE civector operator &(const cvector &rv, const ivector_slice &sl)
04450 #if(CXSC_INDEX_CHECK)
04451         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04452 #else
04453         throw();
04454 #endif
04455 
04456         INLINE civector operator &(const cvector_slice &sl, const ivector &rv)
04457 #if(CXSC_INDEX_CHECK)
04458         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04459 #else
04460         throw();
04461 #endif
04462 
04463         INLINE civector operator &(const cvector_slice &sl1, const ivector_slice &sl2)
04464 #if(CXSC_INDEX_CHECK)
04465         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04466 #else
04467         throw();
04468 #endif
04469 
04471         INLINE civector operator &(const ivector &rv1, const cvector &rv2)
04472 #if(CXSC_INDEX_CHECK)
04473         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04474 #else
04475         throw();
04476 #endif
04477 
04478         INLINE civector operator &(const ivector &rv, const cvector_slice &sl)
04479 #if(CXSC_INDEX_CHECK)
04480         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04481 #else
04482         throw();
04483 #endif
04484 
04485         INLINE civector operator &(const ivector_slice &sl, const cvector &rv)
04486 #if(CXSC_INDEX_CHECK)
04487         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04488 #else
04489         throw();
04490 #endif
04491 
04492         INLINE civector operator &(const ivector_slice &sl1, const cvector_slice &sl2)
04493 #if(CXSC_INDEX_CHECK)
04494         throw(ERROR__OP_WITH_WRONG_DIM<civector>);
04495 #else
04496         throw();
04497 #endif
04498 
04500         INLINE bool in(const civector& v1, const civector& v2);
04501 
04502 } // namespace cxsc 
04503 
04504 #ifdef _CXSC_INCL_INL
04505 #include "vector.inl"
04506 #include "civector.inl"
04507 #endif
04508 
04509 #ifdef _CXSC_RMATRIX_HPP_INCLUDED
04510 # ifdef _CXSC_INCL_INL
04511 #  include "civecrmat.inl"
04512 # else
04513 #  include "civecrmat.hpp"
04514 # endif
04515 #endif
04516 
04517 #ifdef _CXSC_CMATRIX_HPP_INCLUDED
04518 # ifdef _CXSC_INCL_INL
04519 #  include "civeccmat.inl"
04520 # else
04521 #  include "civeccmat.hpp"
04522 # endif
04523 #endif
04524 
04525 #ifdef _CXSC_IMATRIX_HPP_INCLUDED
04526 # ifdef _CXSC_INCL_INL
04527 #  include "civecimat.inl"
04528 # else
04529 #  include "civecimat.hpp"
04530 # endif
04531 #endif
04532 
04533 #ifdef CXSC_USE_BLAS
04534 #define _CXSC_BLAS_CIVECTOR
04535 #include "cxsc_blas.inl"
04536 #endif
04537 
04538 
04539 #endif