C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
ivector.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: ivector.hpp,v 1.36 2014/01/30 17:23:45 cxsc Exp $ */
00025 
00026 #ifndef _CXSC_IVECTOR_HPP_INCLUDED
00027 #define _CXSC_IVECTOR_HPP_INCLUDED
00028 
00029 #include "xscclass.hpp"
00030 #include "except.hpp"
00031 #include "idot.hpp"
00032 #include "cidot.hpp"
00033 #include "interval.hpp" // used for declaration of Inf, Sup,...
00034 #include "rvector.hpp"
00035 #include "vector.hpp"
00036 
00037 
00038 #include <iostream>
00039 
00040 namespace cxsc {
00041 
00042 class srvector;
00043 class srvector_slice;
00044 class sivector;
00045 class sivector_slice;
00046 class ivector_slice;
00047 
00049 
00054 class ivector
00055 {
00056         friend class ivector_slice;
00057         friend class imatrix;
00058         friend class imatrix_subv;
00059         friend class civector;
00060         friend class cimatrix;
00061         friend class l_ivector;
00062         friend class l_imatrix;
00063         private:
00064         interval *dat;
00065         int l,u,size;
00066 
00067         public:
00068 //#if(CXSC_INDEX_CHECK)
00069 #ifdef _CXSC_FRIEND_TPL
00070         //------------ Templates --------------------------------------------------
00071         // Interval
00072 template <class V,class MS,class S> friend  void _vmsconstr(V &v,const MS &m)
00073 #if(CXSC_INDEX_CHECK)
00074         throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>);
00075 #else
00076         throw();
00077 #endif
00078 template <class V,class M,class S> friend  void _vmconstr(V &v,const M &m)
00079 #if(CXSC_INDEX_CHECK)
00080         throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
00081 #else
00082         throw();
00083 #endif
00084  template <class V> friend       void _vresize(V &rv) throw();
00085  template <class V,class S> friend       void _vresize(V &rv, const int &len)
00086 #if(CXSC_INDEX_CHECK)
00087                 throw(ERROR__WRONG_BOUNDARIES<V>);
00088 #else
00089         throw();
00090 #endif
00091  template <class V,class S> friend       void _vresize(V &rv, const int &lb, const int &ub)
00092 #if(CXSC_INDEX_CHECK)
00093                 throw(ERROR__WRONG_BOUNDARIES<V>);
00094 #else
00095         throw();
00096 #endif
00097  template <class V1,class V2,class S> friend     V1 &_vvassign(V1 &rv1,const V2 &rv2) throw();
00098  template <class V,class S> friend       V & _vsassign(V &rv,const S &r) throw();
00099  template <class V,class VS,class S> friend      V & _vvsassign(V &rv,const VS &sl) throw();
00100 template <class VS,class V> friend       VS & _vsvassign(VS &sl,const V &rv)
00101 #if(CXSC_INDEX_CHECK)
00102                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00103 #else
00104         throw();
00105 #endif
00106 template <class V,class M,class S> friend  V &_vmassign(V &v,const M &m)
00107 #if(CXSC_INDEX_CHECK)
00108         throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
00109 #else
00110         throw();
00111 #endif
00112 template <class M,class V,class S> friend  M &_mvassign(M &m,const V &v) throw();
00113  template <class V1,class V2> friend     V1 &_vvsetinf(V1 &rv1, const V2 &rv2)
00114 #if(CXSC_INDEX_CHECK)
00115                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00116 #else
00117         throw();
00118 #endif
00119  template <class V1,class V2> friend     V1 &_vvsetsup(V1 &rv1, const V2 &rv2)
00120 #if(CXSC_INDEX_CHECK)
00121                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00122 #else
00123         throw();
00124 #endif
00125  template <class V,class VS> friend      V &_vvssetinf(V &rv, const VS &sl)
00126 #if(CXSC_INDEX_CHECK)
00127                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00128 #else
00129         throw();
00130 #endif
00131  template <class V,class VS> friend      V &_vvssetsup(V &rv, const VS &sl)
00132 #if(CXSC_INDEX_CHECK)
00133                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00134 #else
00135         throw();
00136 #endif
00137 template <class V,class MV> friend  V &_vmvsetinf(V &rv,const MV &v)
00138 #if(CXSC_INDEX_CHECK)
00139         throw(ERROR__OP_WITH_WRONG_DIM<V>);
00140 #else
00141         throw();
00142 #endif
00143 template <class V,class MV> friend  V &_vmvsetsup(V &rv,const MV &v)
00144 #if(CXSC_INDEX_CHECK)
00145         throw(ERROR__OP_WITH_WRONG_DIM<V>);
00146 #else
00147         throw();
00148 #endif
00149  template <class V1,class V2> friend     V1 &_vvusetinf(V1 &rv1, const V2 &rv2)
00150 #if(CXSC_INDEX_CHECK)
00151                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00152 #else
00153         throw();
00154 #endif
00155  template <class V1,class V2> friend     V1 &_vvusetsup(V1 &rv1, const V2 &rv2)
00156 #if(CXSC_INDEX_CHECK)
00157                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00158 #else
00159         throw();
00160 #endif
00161  template <class V,class VS> friend      V &_vvsusetinf(V &rv, const VS &sl)
00162 #if(CXSC_INDEX_CHECK)
00163                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00164 #else
00165         throw();
00166 #endif
00167  template <class V,class VS> friend      V &_vvsusetsup(V &rv, const VS &sl)
00168 #if(CXSC_INDEX_CHECK)
00169                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00170 #else
00171         throw();
00172 #endif
00173 template <class V,class MV> friend  V &_vmvusetinf(V &rv,const MV &v)
00174 #if(CXSC_INDEX_CHECK)
00175         throw(ERROR__OP_WITH_WRONG_DIM<V>);
00176 #else
00177         throw();
00178 #endif
00179 template <class V,class MV> friend  V &_vmvusetsup(V &rv,const MV &v)
00180 #if(CXSC_INDEX_CHECK)
00181         throw(ERROR__OP_WITH_WRONG_DIM<V>);
00182 #else
00183         throw();
00184 #endif
00185  template <class V,class S> friend       V &_vssetinf(V &v, const S &s) throw();
00186  template <class V,class S> friend       V &_vssetsup(V &v, const S &s) throw();
00187  template <class V,class S> friend       V &_vsusetinf(V &v, const S &s) throw();
00188  template <class V,class S> friend       V &_vsusetsup(V &v, const S &s) throw();
00189  template <class V,class E> friend       E _vabs(const V &rv) throw();
00190  template <class VS,class E> friend      E _vsabs(const VS &sl) throw();
00191 template <class MV,class V> friend  V _mvabs(const MV &mv) throw();
00192  template <class V,class E> friend       E _vdiam(const V &rv) throw();
00193  template <class V,class E> friend       E _vmid(const V &rv) throw();
00194  template <class V,class E> friend       E _vinf(const V &rv) throw();
00195  template <class V,class E> friend       E _vsup(const V &rv) throw();
00196 
00197 //-------- vector-vector -----------------------
00198  template <class DP,class V1,class V2> friend    void _vvaccu(DP &dp, const V1 & rv1, const V2 &rv2)
00199 #if(CXSC_INDEX_CHECK)
00200                 throw(OP_WITH_WRONG_DIM);
00201 #else
00202         throw();
00203 #endif
00204  template <class DP,class VS,class V> friend     void _vsvaccu(DP &dp, const VS & sl, const V &rv)
00205 #if(CXSC_INDEX_CHECK)
00206                 throw(OP_WITH_WRONG_DIM);
00207 #else
00208         throw();
00209 #endif
00210  template <class V1,class V2,class E> friend     E _vvimult(const V1 & rv1, const V2 &rv2)
00211 #if(CXSC_INDEX_CHECK)
00212                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00213 #else
00214         throw();
00215 #endif
00216  template <class VS,class V,class E> friend      E _vsvimult(const VS & sl, const V &rv)
00217 #if(CXSC_INDEX_CHECK)
00218                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00219 #else
00220         throw();
00221 #endif
00222  template <class V,class S> friend       V &_vsmultassign(V &rv,const S &r) throw();
00223  template <class V1,class V2,class E> friend     E _vvplus(const V1 &rv1, const V2 &rv2)
00224 #if(CXSC_INDEX_CHECK)
00225                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00226 #else
00227         throw();
00228 #endif
00229  template <class V,class VS,class E> friend      E _vvsplus(const V &rv,const VS &sl)
00230 #if(CXSC_INDEX_CHECK)
00231                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00232 #else
00233         throw();
00234 #endif
00235  template <class VS1,class VS2,class E> friend   E _vsvsplus(const VS1 &s1,const VS2 &s2)
00236 #if(CXSC_INDEX_CHECK)
00237                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00238 #else
00239         throw();
00240 #endif
00241  template <class VS1,class VS2,class E> friend   E _vsvsminus(const VS1 &s1,const VS2 &s2)
00242 #if(CXSC_INDEX_CHECK)
00243                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00244 #else
00245         throw();
00246 #endif
00247  template <class V1,class V2> friend     V1 &_vvplusassign(V1 &rv1, const V2 &rv2)
00248 #if(CXSC_INDEX_CHECK)
00249                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00250 #else
00251         throw();
00252 #endif
00253  template <class V,class VS> friend      V &_vvsplusassign(V &rv, const VS &sl)
00254 #if(CXSC_INDEX_CHECK)
00255                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00256 #else
00257         throw();
00258 #endif
00259  template <class VS,class V> friend      VS &_vsvplusassign(VS &sl, const V &rv)
00260 #if(CXSC_INDEX_CHECK)
00261                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00262 #else
00263         throw();
00264 #endif
00265  template <class VS1,class VS2> friend   VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
00266 #if(CXSC_INDEX_CHECK)
00267                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00268 #else
00269         throw();
00270 #endif
00271  template <class VS1,class VS2> friend   VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
00272 #if(CXSC_INDEX_CHECK)
00273                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00274 #else
00275         throw();
00276 #endif
00277  template <class V1,class V2> friend     V1 &_vvminusassign(V1 &rv1, const V2 &rv2)
00278 #if(CXSC_INDEX_CHECK)
00279                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00280 #else
00281         throw();
00282 #endif
00283  template <class V,class VS> friend      V &_vvsminusassign(V &rv, const VS &sl)
00284 #if(CXSC_INDEX_CHECK)
00285                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00286 #else
00287         throw();
00288 #endif
00289  template <class VS,class V> friend      VS &_vsvminusassign(VS &sl, const V &rv)
00290 #if(CXSC_INDEX_CHECK)
00291                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00292 #else
00293         throw();
00294 #endif
00295  template <class V> friend       V _vminus(const V &rv) throw();
00296  template <class VS,class V> friend      V _vsminus(const VS &sl) throw();
00297  template <class V1,class V2,class E> friend     E _vvminus(const V1 &rv1, const V2 &rv2)
00298 #if(CXSC_INDEX_CHECK)
00299                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00300 #else
00301         throw();
00302 #endif
00303  template <class V,class VS,class E> friend      E _vvsminus(const V &rv, const VS &sl)
00304 #if(CXSC_INDEX_CHECK)
00305                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00306 #else
00307         throw();
00308 #endif
00309  template <class VS,class V,class E> friend      E _vsvminus(const VS &sl,const V &rv)
00310 #if(CXSC_INDEX_CHECK)
00311                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00312 #else
00313         throw();
00314 #endif
00315  template <class V1,class V2,class E> friend     E _vvconv(const V1 &rv1, const V2 &rv2)
00316 #if(CXSC_INDEX_CHECK)
00317                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00318 #else
00319         throw();
00320 #endif
00321  template <class V,class VS,class E> friend      E _vvsconv(const V &rv,const VS &sl)
00322 #if(CXSC_INDEX_CHECK)
00323                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00324 #else
00325         throw();
00326 #endif
00327  template <class VS1,class VS2,class E> friend   E _vsvsconv(const VS1 &s1,const VS2 &s2)
00328 #if(CXSC_INDEX_CHECK)
00329                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00330 #else
00331         throw();
00332 #endif
00333  template <class V1,class V2> friend     V1 &_vvconvassign(V1 &rv1, const V2 &rv2)
00334 #if(CXSC_INDEX_CHECK)
00335                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00336 #else
00337         throw();
00338 #endif
00339  template <class V,class VS> friend      V &_vvsconvassign(V &rv, const VS &sl)
00340 #if(CXSC_INDEX_CHECK)
00341                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00342 #else
00343         throw();
00344 #endif
00345  template <class VS,class V> friend      VS &_vsvconvassign(VS &sl, const V &rv)
00346 #if(CXSC_INDEX_CHECK)
00347                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00348 #else
00349         throw();
00350 #endif
00351  template <class VS1,class VS2> friend   VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2)
00352 #if(CXSC_INDEX_CHECK)
00353                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00354 #else
00355         throw();
00356 #endif
00357  template <class V1,class V2,class E> friend     E _vvsect(const V1 &rv1, const V2 &rv2)
00358 #if(CXSC_INDEX_CHECK)
00359                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00360 #else
00361         throw();
00362 #endif
00363  template <class V,class VS,class E> friend      E _vvssect(const V &rv,const VS &sl)
00364 #if(CXSC_INDEX_CHECK)
00365                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00366 #else
00367         throw();
00368 #endif
00369  template <class VS1,class VS2,class E> friend   E _vsvssect(const VS1 &s1,const VS2 &s2)
00370 #if(CXSC_INDEX_CHECK)
00371                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00372 #else
00373         throw();
00374 #endif
00375  template <class V1,class V2> friend     V1 &_vvsectassign(V1 &rv1, const V2 &rv2)
00376 #if(CXSC_INDEX_CHECK)
00377                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00378 #else
00379         throw();
00380 #endif
00381  template <class V,class VS> friend      V &_vvssectassign(V &rv, const VS &sl)
00382 #if(CXSC_INDEX_CHECK)
00383                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00384 #else
00385         throw();
00386 #endif
00387  template <class VS,class V> friend      VS &_vsvsectassign(VS &sl, const V &rv)
00388 #if(CXSC_INDEX_CHECK)
00389                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00390 #else
00391         throw();
00392 #endif
00393  template <class VS1,class VS2> friend   VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2)
00394 #if(CXSC_INDEX_CHECK)
00395                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00396 #else
00397         throw();
00398 #endif
00399  template <class MV1,class MV2,class E> friend   E _mvmvsect(const MV1 &rv1, const MV2 &rv2)
00400 #if(CXSC_INDEX_CHECK)
00401                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00402 #else
00403         throw();
00404 #endif
00405  template <class MV,class V,class E> friend      E _mvvsect(const MV &rv1, const V &rv2)
00406 #if(CXSC_INDEX_CHECK)
00407                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00408 #else
00409         throw();
00410 #endif
00411 template <class MV,class V> friend  MV &_mvvsectassign(MV &v,const V &rv)
00412 #if(CXSC_INDEX_CHECK)
00413         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00414 #else
00415         throw();
00416 #endif
00417 template <class V,class MV> friend  V &_vmvsectassign(V &rv,const MV &v)
00418 #if(CXSC_INDEX_CHECK)
00419         throw(ERROR__OP_WITH_WRONG_DIM<V>);
00420 #else
00421         throw();
00422 #endif
00423  template <class MV1,class MV2,class E> friend   E _mvmvconv(const MV1 &rv1, const MV2 &rv2)
00424 #if(CXSC_INDEX_CHECK)
00425                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00426 #else
00427         throw();
00428 #endif
00429  template <class MV,class V,class E> friend      E _mvvconv(const MV &rv1, const V &rv2)
00430 #if(CXSC_INDEX_CHECK)
00431                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00432 #else
00433         throw();
00434 #endif
00435 template <class MV,class V> friend  MV &_mvvconvassign(MV &v,const V &rv)
00436 #if(CXSC_INDEX_CHECK)
00437         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00438 #else
00439         throw();
00440 #endif
00441 template <class V,class MV> friend  V &_vmvconvassign(V &rv,const MV &v)
00442 #if(CXSC_INDEX_CHECK)
00443         throw(ERROR__OP_WITH_WRONG_DIM<V>);
00444 #else
00445         throw();
00446 #endif
00447  template <class V,class MV,class S> friend      S _vmvimult(const V &rv1, const MV &rv2)
00448 #if(CXSC_INDEX_CHECK)
00449                 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00450 #else
00451         throw();
00452 #endif
00453         //--------- vector-scalar -----------------
00454  template <class V,class S,class E> friend       E _vsdiv(const V &rv, const S &s) throw();
00455  template <class V,class S> friend       V &_vsdivassign(V &rv,const S &r) throw();
00456  template <class VS,class S,class E> friend      E _vssdiv(const VS &sl, const S &s) throw();
00457  template <class V,class S,class E> friend       E _vsmult(const V &rv, const S &s) throw();
00458  template <class VS,class S,class E> friend      E _vssmult(const VS &sl, const S &s) throw();
00459  template <class MV,class S,class E> friend      E _mvsmult(const MV &rv, const S &s) throw();
00460  template <class MV1,class MV2,class E> friend   E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
00461 #if(CXSC_INDEX_CHECK)
00462                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00463 #else
00464         throw();
00465 #endif
00466  template <class MV,class V,class E> friend      E _mvvplus(const MV &rv1, const V &rv2)
00467 #if(CXSC_INDEX_CHECK)
00468                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00469 #else
00470         throw();
00471 #endif
00472  template <class MV,class V,class E> friend      E _mvvminus(const MV &rv1, const V &rv2)
00473 #if(CXSC_INDEX_CHECK)
00474                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00475 #else
00476         throw();
00477 #endif
00478  template <class V,class MV,class E> friend      E _vmvminus(const V &rv1, const MV &rv2)
00479 #if(CXSC_INDEX_CHECK)
00480                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00481 #else
00482         throw();
00483 #endif
00484  template <class MV1,class MV2,class E> friend   E _mvmvminus(const MV1 &rv1, const MV2 &rv2)
00485 #if(CXSC_INDEX_CHECK)
00486                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00487 #else
00488         throw();
00489 #endif
00490 template <class MV,class V> friend  MV &_mvvplusassign(MV &v,const V &rv)
00491 #if(CXSC_INDEX_CHECK)
00492         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00493 #else
00494         throw();
00495 #endif
00496 template <class MV,class V> friend  MV &_mvvminusassign(MV &v,const V &rv)
00497 #if(CXSC_INDEX_CHECK)
00498         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00499 #else
00500         throw();
00501 #endif
00502  template <class MV,class S,class E> friend      E _mvsdiv(const MV &rv, const S &s) throw();
00503 template <class MV,class V> friend  MV &_mvvassign(MV &v,const V &rv)
00504 #if(CXSC_INDEX_CHECK)
00505         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00506 #else
00507         throw();
00508 #endif
00509 
00510  template <class V1,class V2> friend     bool _vveq(const V1 &rv1, const V2 &rv2) throw();
00511  template <class VS,class V> friend      bool _vsveq(const VS &sl, const V &rv) throw();
00512  template <class V1,class V2> friend     bool _vvneq(const V1 &rv1, const V2 &rv2) throw();
00513  template <class VS,class V> friend      bool _vsvneq(const VS &sl, const V &rv) throw();
00514  template <class V1,class V2> friend     bool _vvless(const V1 &rv1, const V2 &rv2) throw();
00515  template <class VS,class V> friend      bool _vsvless(const VS &sl, const V &rv) throw();
00516  template <class V1,class V2> friend     bool _vvleq(const V1 &rv1, const V2 &rv2) throw();
00517  template <class VS,class V> friend      bool _vsvleq(const VS &sl, const V &rv) throw();
00518  template <class V,class VS> friend      bool _vvsless(const V &rv, const VS &sl) throw();
00519  template <class V,class VS> friend      bool _vvsleq(const V &rv, const VS &sl) throw();
00520  template <class V> friend       bool _vnot(const V &rv) throw();
00521  template <class V> friend       void *_vvoid(const V &rv) throw();
00522  template <class VS1,class VS2> friend   bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw();
00523  template <class VS1,class VS2> friend   bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw();
00524  template <class VS1,class VS2> friend   bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw();
00525  template <class VS1,class VS2> friend   bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw();
00526  template <class VS> friend      bool _vsnot(const VS &sl) throw();
00527  template <class VS> friend      void *_vsvoid(const VS &sl) throw();
00528  template <class V> friend      std::ostream &_vout(std::ostream &s, const V &rv) throw();
00529  template <class V> friend      std::istream &_vin(std::istream &s, V &rv) throw();
00530 
00531         //------------- vector-matrix ---------------
00532 template <class DP,class V,class SV> friend      void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
00533 #if(CXSC_INDEX_CHECK)
00534                 throw(OP_WITH_WRONG_DIM);
00535 #else
00536         throw();
00537 #endif
00538         
00539 template <class V,class MV2,class S> friend  V &_vmvassign(V &v,const MV2 &rv) throw();
00540  template <class M,class V,class E> friend       E _mvimult(const M &m,const V &v)
00541 #if(CXSC_INDEX_CHECK)
00542                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00543 #else
00544         throw();
00545 #endif
00546  template <class V,class M,class E> friend       E _vmimult(const V &v,const M &m)
00547 #if(CXSC_INDEX_CHECK)
00548                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00549 #else
00550         throw();
00551 #endif
00552  template <class V,class M,class S> friend       V &_vmimultassign(V &v,const M &m)
00553 #if(CXSC_INDEX_CHECK)
00554                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00555 #else
00556         throw();
00557 #endif
00558  template <class MS,class V,class E> friend      E _msvimult(const MS &ms,const V &v)
00559 #if(CXSC_INDEX_CHECK)
00560                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00561 #else
00562         throw();
00563 #endif
00564  template <class V,class MS,class E> friend      E _vmsimult(const V &v,const MS &ms)
00565 #if(CXSC_INDEX_CHECK)
00566                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00567 #else
00568         throw();
00569 #endif
00570  template <class V,class MS,class S> friend      V &_vmsimultassign(V &v,const MS &ms)
00571 #if(CXSC_INDEX_CHECK)
00572                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00573 #else
00574         throw();
00575 #endif
00576 
00577         // Real
00578         //--Real -------- vector-scalar ------------
00579         //--Real--------- Vector-vector---------
00580         //-- Real -------- Vector-matrix ----------
00581         // complex
00582         //--complex -------- vector-scalar ------------
00583         //--complex--------- Vector-vector---------
00584 
00585  template <class V1,class V2,class E> friend     E _vvcimult(const V1 & rv1, const V2 &rv2)
00586 #if(CXSC_INDEX_CHECK)
00587                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00588 #else
00589         throw();
00590 #endif
00591  template <class VS,class V,class E> friend      E _vsvcimult(const VS & sl, const V &rv)
00592 #if(CXSC_INDEX_CHECK)
00593                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00594 #else
00595         throw();
00596 #endif
00597         
00598         //-- complex -------- Vector-matrix ----------
00599  template <class M,class V,class E> friend       E _mvcimult(const M &m,const V &v)
00600 #if(CXSC_INDEX_CHECK)
00601                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00602 #else
00603         throw();
00604 #endif
00605  template <class MS,class V,class E> friend      E _msvcimult(const MS &ms,const V &v)
00606 #if(CXSC_INDEX_CHECK)
00607                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00608 #else
00609         throw();
00610 #endif
00611  template <class V,class M,class E> friend       E _vmcimult(const V &v,const M &m)
00612 #if(CXSC_INDEX_CHECK)
00613                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00614 #else
00615         throw();
00616 #endif
00617  template <class V,class MS,class E> friend      E _vmscimult(const V &v,const MS &ms)
00618 #if(CXSC_INDEX_CHECK)
00619                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00620 #else
00621         throw();
00622 #endif
00623         
00624         // civector ---------------------
00625 template <class V1,class V2> friend      V1 &_vvsetim(V1 &rv1, const V2 &rv2)
00626 #if(CXSC_INDEX_CHECK)
00627                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00628 #else
00629         throw();
00630 #endif
00631 template <class V1,class V2> friend      V1 &_vvsetre(V1 &rv1, const V2 &rv2)
00632 #if(CXSC_INDEX_CHECK)
00633                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00634 #else
00635         throw();
00636 #endif
00637  template <class V,class E> friend       E _vim(const V &rv) throw();
00638  template <class V,class E> friend       E _vre(const V &rv) throw();
00639 
00640  template <class VS,class V> friend      VS &_vsvsetim(VS &sl, const V &rv)
00641 #if(CXSC_INDEX_CHECK)
00642                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00643 #else
00644         throw();
00645 #endif
00646  template <class VS,class V> friend      VS &_vsvsetre(VS &sl, const V &rv)
00647 #if(CXSC_INDEX_CHECK)
00648                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00649 #else
00650         throw();
00651 #endif
00652 template <class MV,class V> friend  MV &_mvvsetre(MV &v,const V &rv)
00653 #if(CXSC_INDEX_CHECK)
00654         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00655 #else
00656         throw();
00657 #endif
00658 template <class MV,class V> friend  MV &_mvvsetim(MV &v,const V &rv)
00659 #if(CXSC_INDEX_CHECK)
00660         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00661 #else
00662         throw();
00663 #endif
00664 template <class MV,class V> friend  V _mvim(const MV &mv) throw();
00665 template <class MV,class V> friend  V _mvre(const MV &mv) throw();
00666 
00667         // vector-scalar
00668         // vector-vector
00669  template <class VS1,class VS2,class E> friend   E _vsvscimult(const VS1 & sl1, const VS2 &sl2)
00670 #if(CXSC_INDEX_CHECK)
00671                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00672 #else
00673         throw();
00674 #endif
00675 
00676         // vector-matrix
00677         // l_real
00678         //--l_real -------- vector-scalar ------------
00679         //--l_real--------- Vector-vector---------
00680 
00681  template <class V1,class V2,class E> friend     E _vvlimult(const V1 & rv1, const V2 &rv2)
00682 #if(CXSC_INDEX_CHECK)
00683                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00684 #else
00685         throw();
00686 #endif
00687  template <class VS,class V,class E> friend      E _vsvlimult(const VS & sl, const V &rv)
00688 #if(CXSC_INDEX_CHECK)
00689                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00690 #else
00691         throw();
00692 #endif
00693         
00694         //-- l_real -------- Vector-matrix ----------
00695  template <class M,class V,class E> friend       E _mvlimult(const M &m,const V &v)
00696 #if(CXSC_INDEX_CHECK)
00697                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00698 #else
00699         throw();
00700 #endif
00701  template <class MS,class V,class E> friend      E _msvlimult(const MS &ms,const V &v)
00702 #if(CXSC_INDEX_CHECK)
00703                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00704 #else
00705         throw();
00706 #endif
00707  template <class V,class M,class E> friend       E _vmlimult(const V &v,const M &m)
00708 #if(CXSC_INDEX_CHECK)
00709                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00710 #else
00711         throw();
00712 #endif
00713  template <class V,class MS,class E> friend      E _vmslimult(const V &v,const MS &ms)
00714 #if(CXSC_INDEX_CHECK)
00715                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00716 #else
00717         throw();
00718 #endif
00719         
00720         // l_ivector ---------------------
00721         // vector-scalar
00722         // vector-vector
00723  template <class VS1,class VS2,class E> friend   E _vsvslimult(const VS1 & sl1, const VS2 &sl2)
00724 #if(CXSC_INDEX_CHECK)
00725                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00726 #else
00727         throw();
00728 #endif
00729         // vector-matrix
00730 
00731 #endif
00732 
00733         //------ Konstruktoren ----------------------------------------------------
00735         INLINE ivector () throw();
00737         explicit INLINE ivector(const int &i) throw();
00738 #ifdef OLD_CXSC
00739 
00740         explicit INLINE ivector(const class index &i) throw(); // for backwards compatibility
00741 #endif
00742 
00743         explicit INLINE ivector(const int &i1,const int &i2)
00744 #if(CXSC_INDEX_CHECK)
00745         throw(ERROR_IVECTOR_WRONG_BOUNDARIES,ERROR_IVECTOR_NO_MORE_MEMORY);
00746 #else
00747         throw();
00748 #endif
00749 
00750         INLINE ivector(const imatrix_subv &) throw();
00752         explicit INLINE ivector(const interval &) throw();
00754 //      explicit INLINE ivector(const imatrix &)
00755         explicit        ivector(const imatrix &)
00756 #if(CXSC_INDEX_CHECK)
00757         throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
00758 #else
00759         throw();
00760 #endif
00761 
00762         explicit INLINE ivector(const imatrix_slice &sl)
00763 #if(CXSC_INDEX_CHECK)
00764         throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
00765 #else
00766         throw();
00767 #endif
00768 
00769         INLINE ivector(const ivector_slice &rs) throw();
00771         INLINE ivector(const ivector &v) throw();
00773         INLINE ivector(const sivector &rs);
00775         INLINE ivector(const sivector_slice &rs);
00776 
00777         // Real
00779         explicit INLINE ivector(const real &) throw();
00781         explicit INLINE ivector(const rvector_slice &rs) throw();
00783         explicit INLINE ivector(const srvector &rs);
00785         explicit INLINE ivector(const srvector_slice &rs);
00786 
00788         explicit INLINE ivector(const rvector &v) throw();
00790         explicit INLINE ivector(const rmatrix &)
00791 #if(CXSC_INDEX_CHECK)
00792         throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
00793 #else
00794         throw();
00795 #endif
00796 
00797         explicit INLINE ivector(const rmatrix_slice &sl)
00798 #if(CXSC_INDEX_CHECK)
00799         throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
00800 #else
00801         throw();
00802 #endif
00803 
00804 //      explicit INLINE ivector(const rmatrix_subv &) throw();
00805         explicit        ivector(const rmatrix_subv &) throw();  
00806         
00807         // Interval
00809         INLINE ivector &operator =(const ivector &rv) throw();
00811         INLINE ivector &operator =(const ivector_slice &sl) throw();
00813         INLINE ivector &operator =(const sivector &rv);
00815         INLINE ivector &operator =(const sivector_slice &sl);
00817         INLINE ivector &operator =(const srvector &rv);
00819         INLINE ivector &operator =(const srvector_slice &sl);
00821         INLINE ivector &operator =(const interval &r) throw();
00823         INLINE ivector &operator =(const imatrix &m)
00824 #if(CXSC_INDEX_CHECK)
00825         throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
00826 #else
00827         throw();
00828 #endif
00829 
00830         INLINE ivector &operator =(const imatrix_slice &)
00831 #if(CXSC_INDEX_CHECK)
00832         throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
00833 #else
00834         throw();
00835 #endif
00836 
00837         INLINE ivector &operator =(const imatrix_subv &) throw();
00838         // Real
00840         INLINE ivector &operator =(const rvector &rv) throw();
00842         INLINE ivector &operator =(const rvector_slice &sl) throw();
00844         INLINE ivector &operator =(const real &r) throw();
00846         INLINE ivector &operator =(const rmatrix &m)
00847 #if(CXSC_INDEX_CHECK)
00848         throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
00849 #else
00850         throw();
00851 #endif
00852 
00853         INLINE ivector &operator =(const rmatrix_slice &)
00854 #if(CXSC_INDEX_CHECK)
00855         throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
00856 #else
00857         throw();
00858 #endif
00859 
00860         INLINE ivector &operator =(const rmatrix_subv &) throw();
00861 
00863         INLINE ivector &operator+=(const srvector&);
00865         INLINE ivector &operator+=(const sivector&);
00867         INLINE ivector &operator+=(const srvector_slice&);
00869         INLINE ivector &operator+=(const sivector_slice&);
00871         INLINE ivector &operator-=(const srvector&);
00873         INLINE ivector &operator-=(const sivector&);
00875         INLINE ivector &operator-=(const srvector_slice&);
00877         INLINE ivector &operator-=(const sivector_slice&);
00879         INLINE ivector &operator|=(const srvector&);
00881         INLINE ivector &operator|=(const sivector&);
00883         INLINE ivector &operator|=(const srvector_slice&);
00885         INLINE ivector &operator|=(const sivector_slice&);
00887         INLINE ivector &operator&=(const sivector&);
00889         INLINE ivector &operator&=(const sivector_slice&);
00890 
00892         INLINE ivector operator()(const intvector& p);
00894         INLINE ivector operator()(const intmatrix& P);
00895 
00896         //--------- Destruktor ----------------------------------------------------
00897         INLINE ~ivector() { delete [] dat; }
00898 
00899         //------ Standardfunktionen -----------------------------------------------
00900         
00901         friend INLINE interval::interval(const ivector &)
00902 #if(CXSC_INDEX_CHECK)
00903         throw(ERROR_IVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_IVECTOR_USE_OF_UNINITIALIZED_OBJ);
00904 #else
00905         throw();
00906 #endif
00907 
00908         friend INLINE int Lb(const ivector &rv) throw() { return rv.l; }
00910         friend INLINE int Ub(const ivector &rv) throw() { return rv.u; }
00912         friend INLINE int VecLen(const ivector &rv) throw() { return rv.size; }
00914         friend INLINE ivector &SetLb(ivector &rv, const int &l) throw() { rv.l=l; rv.u=l+rv.size-1; return rv; }
00916         friend INLINE ivector &SetUb(ivector &rv, const int &u) throw() { rv.u=u; rv.l=u-rv.size+1; return rv; }
00918         INLINE interval & operator [](const int &i) const
00919 #if(CXSC_INDEX_CHECK)
00920         throw(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC);
00921 #else
00922         throw();
00923 #endif
00924 
00926         INLINE interval & operator [](const int &i)
00927 #if(CXSC_INDEX_CHECK)
00928         throw(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC);
00929 #else
00930         throw();
00931 #endif
00932         
00934         INLINE ivector & operator ()() throw() { return *this; }
00936         INLINE ivector_slice operator ()(const int &i)
00937 #if(CXSC_INDEX_CHECK)
00938         throw(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG);
00939 #else
00940         throw();
00941 #endif
00942 
00943         INLINE ivector_slice operator ()(const int &i1,const int &i2)
00944 #if(CXSC_INDEX_CHECK)
00945         throw(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG);
00946 #else
00947         throw();
00948 #endif
00949         
00950         INLINE operator void*() throw();
00951 //#else
00952 //#endif
00953 };
00954 
00955 
00957 
00962 class ivector_slice
00963 {
00964         friend class ivector;
00965         friend class imatrix;
00966         friend class civector;
00967         friend class cimatrix;
00968         friend class l_ivector;
00969         friend class l_imatrix;
00970         private:
00971         interval *dat;
00972         int l,u,size;
00973         int start,end;
00974 
00975         public:
00976 //#if(CXSC_INDEX_CHECK) 
00977 #ifdef _CXSC_FRIEND_TPL
00978 //------------------------- Templates -------------------------------------------
00979 // Interval / Interval
00980 
00981  template <class VS1,class VS2> friend   VS1 & _vsvsassign(VS1 &sl1,const VS2 &sl2)
00982 #if(CXSC_INDEX_CHECK)
00983                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00984 #else
00985         throw();
00986 #endif
00987  template <class V,class VS,class S> friend      V & _vvsassign(V &rv,const VS &sl) throw();
00988  template <class VS,class V> friend      VS & _vsvassign(VS &sl,const V &rv)
00989 #if(CXSC_INDEX_CHECK)
00990                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00991 #else
00992         throw();
00993 #endif
00994  template <class VS,class S> friend      VS & _vssassign(VS &sl,const S &r) throw();
00995  template <class VS,class V> friend      VS &_vsvsetinf(VS &sl, const V &rv)
00996 #if(CXSC_INDEX_CHECK)
00997                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00998 #else
00999         throw();
01000 #endif
01001  template <class VS,class V> friend      VS &_vsvsetsup(VS &sl, const V &rv)
01002 #if(CXSC_INDEX_CHECK)
01003                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01004 #else
01005         throw();
01006 #endif
01007  template <class VS1,class VS2> friend   VS1 &_vsvssetinf(VS1 &sl1, const VS2 &sl2)
01008 #if(CXSC_INDEX_CHECK)
01009                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01010 #else
01011         throw();
01012 #endif
01013  template <class VS1,class VS2> friend   VS1 &_vsvssetsup(VS1 &sl1, const VS2 &sl2)
01014 #if(CXSC_INDEX_CHECK)
01015                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01016 #else
01017         throw();
01018 #endif
01019  template <class VS,class V> friend      VS &_vsvusetinf(VS &sl, const V &rv)
01020 #if(CXSC_INDEX_CHECK)
01021                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01022 #else
01023         throw();
01024 #endif
01025  template <class VS,class V> friend      VS &_vsvusetsup(VS &sl, const V &rv)
01026 #if(CXSC_INDEX_CHECK)
01027                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01028 #else
01029         throw();
01030 #endif
01031  template <class VS1,class VS2> friend   VS1 &_vsvsusetinf(VS1 &sl1, const VS2 &sl2)
01032 #if(CXSC_INDEX_CHECK)
01033                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01034 #else
01035         throw();
01036 #endif
01037  template <class VS1,class VS2> friend   VS1 &_vsvsusetsup(VS1 &sl1, const VS2 &sl2)
01038 #if(CXSC_INDEX_CHECK)
01039                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01040 #else
01041         throw();
01042 #endif
01043  template <class VS,class S> friend      VS &_vsssetinf(VS &vs, const S &s) throw();
01044  template <class VS,class S> friend      VS &_vsssetsup(VS &vs, const S &s) throw();
01045  template <class VS,class S> friend      VS &_vssusetinf(VS &vs, const S &s) throw();
01046  template <class VS,class S> friend      VS &_vssusetsup(VS &vs, const S &s) throw();
01047 
01048  template <class DP,class VS,class V> friend     void _vsvaccu(DP &dp, const VS & sl, const V &rv)
01049 #if(CXSC_INDEX_CHECK)
01050                 throw(OP_WITH_WRONG_DIM);
01051 #else
01052         throw();
01053 #endif
01054  template <class DP,class VS1,class VS2> friend          void _vsvsaccu(DP &dp, const VS1 & sl1, const VS2 &sl2)
01055 #if(CXSC_INDEX_CHECK)
01056                 throw(OP_WITH_WRONG_DIM);
01057 #else
01058         throw();
01059 #endif
01060         
01061  template <class VS,class S,class E> friend      E _vssdiv(const VS &sl, const S &s) throw();
01062  template <class VS,class S,class E> friend      E _vssmult(const VS &sl, const S &s) throw();
01063 
01064  template <class VS,class V,class E> friend      E _vsvimult(const VS & sl, const V &rv)
01065 #if(CXSC_INDEX_CHECK)
01066                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01067 #else
01068         throw();
01069 #endif
01070  template <class VS,class S> friend      VS &_vssmultassign(VS &rv,const S &r) throw();
01071  template <class VS,class S> friend      VS &_vssdivassign(VS &rv,const S &r) throw();
01072  template <class V,class VS,class E> friend      E _vvsplus(const V &rv,const VS &sl)
01073 #if(CXSC_INDEX_CHECK)
01074                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01075 #else
01076         throw();
01077 #endif
01078  template <class VS1,class VS2,class E> friend   E _vsvsplus(const VS1 &s1,const VS2 &s2)
01079 #if(CXSC_INDEX_CHECK)
01080                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01081 #else
01082         throw();
01083 #endif
01084  template <class VS1,class VS2,class E> friend   E _vsvsminus(const VS1 &s1,const VS2 &s2)
01085 #if(CXSC_INDEX_CHECK)
01086                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01087 #else
01088         throw();
01089 #endif
01090  template <class V,class VS> friend      V &_vvsplusassign(V &rv, const VS &sl)
01091 #if(CXSC_INDEX_CHECK)
01092                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01093 #else
01094         throw();
01095 #endif
01096  template <class VS,class V> friend      VS &_vsvplusassign(VS &sl, const V &rv)
01097 #if(CXSC_INDEX_CHECK)
01098                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01099 #else
01100         throw();
01101 #endif
01102  template <class VS1,class VS2> friend   VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
01103 #if(CXSC_INDEX_CHECK)
01104                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01105 #else
01106         throw();
01107 #endif
01108  template <class VS1,class VS2> friend   VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
01109 #if(CXSC_INDEX_CHECK)
01110                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01111 #else
01112         throw();
01113 #endif
01114  template <class V,class VS> friend      V &_vvsminusassign(V &rv, const VS &sl)
01115 #if(CXSC_INDEX_CHECK)
01116                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01117 #else
01118         throw();
01119 #endif
01120  template <class VS,class V> friend      VS &_vsvminusassign(VS &sl, const V &rv)
01121 #if(CXSC_INDEX_CHECK)
01122                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01123 #else
01124         throw();
01125 #endif
01126  template <class VS,class V> friend      V _vsminus(const VS &sl) throw();
01127  template <class V,class VS,class E> friend      E _vvsminus(const V &rv, const VS &sl)
01128 #if(CXSC_INDEX_CHECK)
01129                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01130 #else
01131         throw();
01132 #endif
01133  template <class VS,class V,class E> friend      E _vsvminus(const VS &sl,const V &rv)
01134 #if(CXSC_INDEX_CHECK)
01135                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01136 #else
01137         throw();
01138 #endif
01139  template <class V,class VS,class E> friend      E _vvssect(const V &rv,const VS &sl)
01140 #if(CXSC_INDEX_CHECK)
01141                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01142 #else
01143         throw();
01144 #endif
01145  template <class VS1,class VS2,class E> friend   E _vsvssect(const VS1 &s1,const VS2 &s2)
01146 #if(CXSC_INDEX_CHECK)
01147                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01148 #else
01149         throw();
01150 #endif
01151  template <class V,class VS> friend      V &_vvssectassign(V &rv, const VS &sl)
01152 #if(CXSC_INDEX_CHECK)
01153                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01154 #else
01155         throw();
01156 #endif
01157  template <class VS,class V> friend      VS &_vsvsectassign(VS &sl, const V &rv)
01158 #if(CXSC_INDEX_CHECK)
01159                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01160 #else
01161         throw();
01162 #endif
01163  template <class VS1,class VS2> friend   VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2)
01164 #if(CXSC_INDEX_CHECK)
01165                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01166 #else
01167         throw();
01168 #endif
01169  template <class V,class VS,class E> friend      E _vvsconv(const V &rv,const VS &sl)
01170 #if(CXSC_INDEX_CHECK)
01171                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01172 #else
01173         throw();
01174 #endif
01175  template <class VS1,class VS2,class E> friend   E _vsvsconv(const VS1 &s1,const VS2 &s2)
01176 #if(CXSC_INDEX_CHECK)
01177                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01178 #else
01179         throw();
01180 #endif
01181  template <class V,class VS> friend      V &_vvsconvassign(V &rv, const VS &sl)
01182 #if(CXSC_INDEX_CHECK)
01183                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01184 #else
01185         throw();
01186 #endif
01187  template <class VS,class V> friend      VS &_vsvconvassign(VS &sl, const V &rv)
01188 #if(CXSC_INDEX_CHECK)
01189                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01190 #else
01191         throw();
01192 #endif
01193  template <class VS1,class VS2> friend   VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2)
01194 #if(CXSC_INDEX_CHECK)
01195                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01196 #else
01197         throw();
01198 #endif
01199  template <class VS,class M,class S> friend      VS &_vsmimultassign(VS &v,const M &m)
01200 #if(CXSC_INDEX_CHECK)
01201                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01202 #else
01203         throw();
01204 #endif
01205 
01206  template <class VS,class V> friend      bool _vsveq(const VS &sl, const V &rv) throw();
01207  template <class VS,class V> friend      bool _vsvneq(const VS &sl, const V &rv) throw();
01208  template <class VS,class V> friend      bool _vsvless(const VS &sl, const V &rv) throw();
01209  template <class VS,class V> friend      bool _vsvleq(const VS &sl, const V &rv) throw();
01210  template <class V,class VS> friend      bool _vvsless(const V &rv, const VS &sl) throw();
01211  template <class V,class VS> friend      bool _vvsleq(const V &rv, const VS &sl) throw();
01212  template <class VS,class E> friend      E _vsabs(const VS &sl) throw();
01213  template <class VS,class E> friend      E _vsdiam(const VS &sl) throw();
01214  template <class VS,class E> friend      E _vsmid(const VS &sl) throw();
01215  template <class VS,class E> friend      E _vsinf(const VS &sl) throw();
01216  template <class VS,class E> friend      E _vssup(const VS &sl) throw();
01217  template <class VS1,class VS2,class E> friend   E _vsvsimult(const VS1 & sl1, const VS2 &sl2)
01218 #if(CXSC_INDEX_CHECK)
01219                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01220 #else
01221         throw();
01222 #endif
01223  template <class VS1,class VS2> friend   bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw();
01224  template <class VS1,class VS2> friend   bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw();
01225  template <class VS1,class VS2> friend   bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw();
01226  template <class VS1,class VS2> friend   bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw();
01227  template <class VS> friend      bool _vsnot(const VS &sl) throw();
01228  template <class VS> friend      void *_vsvoid(const VS &sl) throw();
01229  template <class V> friend      std::ostream &_vsout(std::ostream &s, const V &rv) throw();
01230  template <class V> friend      std::istream &_vsin(std::istream &s, V &rv) throw();
01231         
01232         // Interval / Real
01233  template <class V,class MS,class E> friend      E _vmsimult(const V &v,const MS &ms)
01234 #if(CXSC_INDEX_CHECK)
01235                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01236 #else
01237         throw();
01238 #endif
01239 
01240         // complex
01241  template <class VS,class V,class E> friend      E _vsvcimult(const VS & sl, const V &rv)
01242 #if(CXSC_INDEX_CHECK)
01243                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01244 #else
01245         throw();
01246 #endif
01247  template <class V,class VS> friend      V &_vvssetim(V &rv, const VS &sl)
01248 #if(CXSC_INDEX_CHECK)
01249                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01250 #else
01251         throw();
01252 #endif
01253  template <class V,class VS> friend      V &_vvssetre(V &rv, const VS &sl)
01254 #if(CXSC_INDEX_CHECK)
01255                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01256 #else
01257         throw();
01258 #endif
01259  template <class VS1,class VS2> friend   VS1 &_vsvssetim(VS1 &sl1, const VS2 &sl2)
01260 #if(CXSC_INDEX_CHECK)
01261                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01262 #else
01263         throw();
01264 #endif
01265  template <class VS1,class VS2> friend   VS1 &_vsvssetre(VS1 &sl1, const VS2 &sl2)
01266 #if(CXSC_INDEX_CHECK)
01267                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01268 #else
01269         throw();
01270 #endif
01271 
01272         // cinterval-- vector-scalar
01273         // cinterval -- vector-vector
01274 template <class VS1,class VS2,class E> friend    E _vsvscimult(const VS1 & sl1, const VS2 &sl2)
01275 #if(CXSC_INDEX_CHECK)
01276                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01277 #else
01278         throw();
01279 #endif
01280 
01281         // cinterval -- vector-matrix
01282         // l_real
01283 
01284  template <class VS1,class VS2,class E> friend   E _vsvslimult(const VS1 & sl1, const VS2 &sl2)
01285 #if(CXSC_INDEX_CHECK)
01286                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01287 #else
01288         throw();
01289 #endif
01290 
01291         // l_interval ----------
01292         // l_interval-- vector-scalar
01293         // l_interval -- vector-vector
01294 template <class VS,class V,class E> friend       E _vsvlimult(const VS & sl, const V &rv)
01295 #if(CXSC_INDEX_CHECK)
01296                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01297 #else
01298         throw();
01299 #endif
01300 
01301 
01302 #endif
01303         
01304         //--------------------- Konstruktoren -----------------------------------
01306         explicit INLINE ivector_slice(ivector &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) { }
01308         explicit INLINE ivector_slice(ivector_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) { }
01309         public: 
01311         INLINE ivector_slice(const ivector_slice &a) throw():dat(a.dat),l(a.l),u(a.u),size(a.size),start(a.start),end(a.end) { }
01312         public:
01313         // Interval
01315         INLINE ivector_slice & operator =(const sivector &sl);
01317         INLINE ivector_slice & operator =(const sivector_slice &sl);
01319         INLINE ivector_slice & operator =(const srvector &sl);
01321         INLINE ivector_slice & operator =(const srvector_slice &sl);
01322 
01324         INLINE ivector_slice & operator =(const ivector_slice &sl)
01325 #if(CXSC_INDEX_CHECK)
01326         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
01327 #else
01328         throw();
01329 #endif
01330 
01331         INLINE ivector_slice & operator =(const ivector &rv)
01332 #if(CXSC_INDEX_CHECK)
01333         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
01334 #else
01335         throw();
01336 #endif
01337 
01338         INLINE ivector_slice & operator =(const interval &r) throw();
01340         INLINE ivector_slice & operator =(const imatrix &m)
01341 #if(CXSC_INDEX_CHECK)
01342         throw(ERROR__OP_WITH_WRONG_DIM<ivector>,ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
01343 #else
01344         throw();
01345 #endif
01346 
01347         INLINE ivector_slice & operator =(const imatrix_slice &m)
01348 #if(CXSC_INDEX_CHECK)
01349         throw(ERROR__OP_WITH_WRONG_DIM<ivector>,ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
01350 #else
01351         throw();
01352 #endif
01353 
01354         INLINE ivector_slice &operator =(const imatrix_subv &) throw();
01355         // Real
01357         INLINE ivector_slice & operator =(const rvector_slice &sl)
01358 #if(CXSC_INDEX_CHECK)
01359         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
01360 #else
01361         throw();
01362 #endif
01363 
01364         INLINE ivector_slice & operator =(const rvector &rv)
01365 #if(CXSC_INDEX_CHECK)
01366         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
01367 #else
01368         throw();
01369 #endif
01370 
01371         INLINE ivector_slice & operator =(const real &r) throw();
01373         INLINE ivector_slice & operator =(const rmatrix &m)
01374 #if(CXSC_INDEX_CHECK)
01375         throw(ERROR__OP_WITH_WRONG_DIM<rvector>,ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
01376 #else
01377         throw();
01378 #endif
01379 
01380         INLINE ivector_slice & operator =(const rmatrix_slice &m)
01381 #if(CXSC_INDEX_CHECK)
01382         throw(ERROR__OP_WITH_WRONG_DIM<rvector>,ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
01383 #else
01384         throw();
01385 #endif
01386 
01387         INLINE ivector_slice &operator =(const rmatrix_subv &mv) throw();
01388 
01389         //--------------------- Standardfunktionen ------------------------------
01390 
01391         friend INLINE interval::interval(const ivector_slice &sl)
01392 #if(CXSC_INDEX_CHECK)
01393         throw(ERROR_IVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_IVECTOR_USE_OF_UNINITIALIZED_OBJ);
01394 #else
01395         throw();
01396 #endif
01397 
01398         friend INLINE int Lb(const ivector_slice &sl) throw() { return sl.start; }
01400         friend INLINE int Ub(const ivector_slice &sl) throw() { return sl.end; }
01402         friend INLINE int VecLen(const ivector_slice &sl) throw() { return sl.end-sl.start+1; }
01404         INLINE interval & operator [](const int &i) const
01405 #if(CXSC_INDEX_CHECK)
01406         throw(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC);
01407 #else
01408         throw();
01409 #endif
01410 
01412         INLINE interval & operator [](const int &i) 
01413 #if(CXSC_INDEX_CHECK)
01414         throw(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC);
01415 #else
01416         throw();
01417 #endif
01418 
01420         INLINE ivector_slice & operator ()() throw() { return *this; }
01422         INLINE ivector_slice operator ()(const int &i)
01423 #if(CXSC_INDEX_CHECK)
01424         throw(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG);
01425 #else
01426         throw();
01427 #endif
01428 
01429         INLINE ivector_slice operator ()(const int &i1,const int &i2)
01430 #if(CXSC_INDEX_CHECK)
01431         throw(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG);
01432 #else
01433         throw();
01434 #endif
01435         
01437         INLINE ivector_slice &operator /=(const interval &r) throw();
01439         INLINE ivector_slice &operator /=(const real &r) throw();
01441         INLINE ivector_slice &operator *=(const interval &r) throw();
01443         INLINE ivector_slice &operator *=(const imatrix &m)
01444 #if(CXSC_INDEX_CHECK)
01445         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01446 #else
01447         throw();
01448 #endif
01449 
01450         INLINE ivector_slice &operator *=(const rmatrix &m)
01451 #if(CXSC_INDEX_CHECK)
01452         throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
01453 #else
01454         throw();
01455 #endif
01456 
01457         INLINE ivector_slice &operator *=(const real &r) throw();
01459         INLINE ivector_slice &operator +=(const ivector &rv)
01460 #if(CXSC_INDEX_CHECK)
01461         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
01462 #else
01463         throw();
01464 #endif
01465 
01466         INLINE ivector_slice &operator +=(const ivector_slice &sl2)
01467 #if(CXSC_INDEX_CHECK)
01468         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
01469 #else
01470         throw();
01471 #endif
01472 
01473         INLINE ivector_slice &operator -=(const ivector &rv)
01474 #if(CXSC_INDEX_CHECK)
01475         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
01476 #else
01477         throw();
01478 #endif
01479 
01480         INLINE ivector_slice &operator -=(const ivector_slice &sl2)
01481 #if(CXSC_INDEX_CHECK)
01482         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
01483 #else
01484         throw();
01485 #endif
01486 
01487         INLINE ivector_slice &operator |=(const ivector &rv)
01488 #if(CXSC_INDEX_CHECK)
01489         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
01490 #else
01491         throw();
01492 #endif
01493 
01494         INLINE ivector_slice &operator |=(const ivector_slice &sl2)
01495 #if(CXSC_INDEX_CHECK)
01496         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
01497 #else
01498         throw();
01499 #endif
01500 
01501         INLINE ivector_slice &operator &=(const ivector &rv)
01502 #if(CXSC_INDEX_CHECK)
01503         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
01504 #else
01505         throw();
01506 #endif
01507 
01508         INLINE ivector_slice &operator &=(const ivector_slice &sl2)
01509 #if(CXSC_INDEX_CHECK)
01510         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
01511 #else
01512         throw();
01513 #endif
01514         
01516         INLINE ivector_slice &operator +=(const rvector &rv)
01517 #if(CXSC_INDEX_CHECK)
01518         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
01519 #else
01520         throw();
01521 #endif
01522 
01523         INLINE ivector_slice &operator +=(const rvector_slice &sl2)
01524 #if(CXSC_INDEX_CHECK)
01525         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
01526 #else
01527         throw();
01528 #endif
01529 
01530         INLINE ivector_slice &operator -=(const rvector &rv)
01531 #if(CXSC_INDEX_CHECK)
01532         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
01533 #else
01534         throw();
01535 #endif
01536 
01537         INLINE ivector_slice &operator -=(const rvector_slice &sl2)
01538 #if(CXSC_INDEX_CHECK)
01539         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
01540 #else
01541         throw();
01542 #endif
01543 
01544         INLINE ivector_slice &operator |=(const rvector &rv)
01545 #if(CXSC_INDEX_CHECK)
01546         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
01547 #else
01548         throw();
01549 #endif
01550 
01551         INLINE ivector_slice &operator |=(const rvector_slice &sl2)
01552 #if(CXSC_INDEX_CHECK)
01553         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
01554 #else
01555         throw();
01556 #endif
01557 
01558         INLINE ivector_slice &operator &=(const rvector &rv)
01559 #if(CXSC_INDEX_CHECK)
01560         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
01561 #else
01562         throw();
01563 #endif
01564 
01565         INLINE ivector_slice &operator &=(const rvector_slice &sl2)
01566 #if(CXSC_INDEX_CHECK)
01567         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
01568 #else
01569         throw();
01570 #endif
01571         INLINE operator void*() throw();
01572 //#else
01573 //#endif
01574 
01576         INLINE ivector_slice &operator+=(const srvector&);
01578         INLINE ivector_slice &operator+=(const sivector&);
01580         INLINE ivector_slice &operator+=(const srvector_slice&);
01582         INLINE ivector_slice &operator+=(const sivector_slice&);
01584         INLINE ivector_slice &operator-=(const srvector&);
01586         INLINE ivector_slice &operator-=(const sivector&);
01588         INLINE ivector_slice &operator-=(const srvector_slice&);
01590         INLINE ivector_slice &operator-=(const sivector_slice&);
01592         INLINE ivector_slice &operator|=(const srvector&);
01594         INLINE ivector_slice &operator|=(const sivector&);
01596         INLINE ivector_slice &operator|=(const srvector_slice&);
01598         INLINE ivector_slice &operator|=(const sivector_slice&);
01600         INLINE ivector_slice &operator&=(const sivector&);
01602         INLINE ivector_slice &operator&=(const sivector_slice&);
01603 
01604 };
01605 
01606 //=======================================================================
01607 //======================== Vector Functions =============================
01608 
01610         INLINE ivector _ivector(const interval &r) throw();
01611 //      INLINE ivector _ivector(const imatrix &m) throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
01612 //      INLINE ivector _ivector(const imatrix_slice &sl) throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
01614         INLINE ivector _ivector(const real &r) throw();
01616         INLINE ivector _ivector(const rvector_slice &rs) throw();
01618         INLINE ivector _ivector(const rvector &rs) throw();
01619 //      INLINE ivector _ivector(const rmatrix &m) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
01620 //      INLINE ivector _ivector(const rmatrix_slice &sl) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
01622         INLINE ivector _ivector(const rmatrix_subv &rs) throw();
01623 
01625         INLINE ivector &SetInf(ivector &iv,const rvector &rv)
01626 #if(CXSC_INDEX_CHECK)
01627         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01628 #else
01629         throw();
01630 #endif
01631 
01632         INLINE ivector_slice &SetInf(ivector_slice &iv,const rvector &rv)
01633 #if(CXSC_INDEX_CHECK)
01634         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01635 #else
01636         throw();
01637 #endif
01638 
01639         INLINE ivector &SetInf(ivector &iv,const rvector_slice &rv)
01640 #if(CXSC_INDEX_CHECK)
01641         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01642 #else
01643         throw();
01644 #endif
01645 
01646         INLINE ivector_slice &SetInf(ivector_slice &iv,const rvector_slice &rv)
01647 #if(CXSC_INDEX_CHECK)
01648         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01649 #else
01650         throw();
01651 #endif
01652 
01653         INLINE ivector &UncheckedSetInf(ivector &iv,const rvector &rv)
01654 #if(CXSC_INDEX_CHECK)
01655         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01656 #else
01657         throw();
01658 #endif
01659 
01660         INLINE ivector_slice &UncheckedSetInf(ivector_slice &iv,const rvector &rv)
01661 #if(CXSC_INDEX_CHECK)
01662         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01663 #else
01664         throw();
01665 #endif
01666 
01667         INLINE ivector &UncheckedSetInf(ivector &iv,const rvector_slice &rv)
01668 #if(CXSC_INDEX_CHECK)
01669         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01670 #else
01671         throw();
01672 #endif
01673 
01674         INLINE ivector_slice &UncheckedSetInf(ivector_slice &iv,const rvector_slice &rv)
01675 #if(CXSC_INDEX_CHECK)
01676         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01677 #else
01678         throw();
01679 #endif
01680 
01682         INLINE ivector &SetSup(ivector &iv,const rvector &rv)
01683 #if(CXSC_INDEX_CHECK)
01684         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01685 #else
01686         throw();
01687 #endif
01688 
01689         INLINE ivector_slice &SetSup(ivector_slice &iv,const rvector &rv)
01690 #if(CXSC_INDEX_CHECK)
01691         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01692 #else
01693         throw();
01694 #endif
01695 
01696         INLINE ivector &SetSup(ivector &iv,const rvector_slice &rv)
01697 #if(CXSC_INDEX_CHECK)
01698         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01699 #else
01700         throw();
01701 #endif
01702 
01703         INLINE ivector_slice &SetSup(ivector_slice &iv,const rvector_slice &rv)
01704 #if(CXSC_INDEX_CHECK)
01705         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01706 #else
01707         throw();
01708 #endif
01709 
01710         INLINE ivector &UncheckedSetSup(ivector &iv,const rvector &rv)
01711 #if(CXSC_INDEX_CHECK)
01712         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01713 #else
01714         throw();
01715 #endif
01716 
01717         INLINE ivector_slice &UncheckedSetSup(ivector_slice &iv,const rvector &rv)
01718 #if(CXSC_INDEX_CHECK)
01719         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01720 #else
01721         throw();
01722 #endif
01723 
01724         INLINE ivector &UncheckedSetSup(ivector &iv,const rvector_slice &rv)
01725 #if(CXSC_INDEX_CHECK)
01726         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01727 #else
01728         throw();
01729 #endif
01730 
01731         INLINE ivector_slice &UncheckedSetSup(ivector_slice &iv,const rvector_slice &rv)
01732 #if(CXSC_INDEX_CHECK)
01733         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01734 #else
01735         throw();
01736 #endif
01737 
01739         INLINE ivector &SetSup(ivector &iv,const real &r) throw();
01741         INLINE ivector &SetInf(ivector &iv,const real &r) throw();
01743         INLINE ivector &UncheckedSetSup(ivector &iv,const real &r) throw();
01745         INLINE ivector &SetUncheckedInf(ivector &iv,const real &r) throw();
01747         INLINE ivector_slice &SetSup(ivector_slice &iv,const real &r) throw();
01749         INLINE ivector_slice &SetInf(ivector_slice &iv,const real &r) throw();
01751         INLINE ivector_slice &UncheckedSetSup(ivector_slice &iv,const real &r) throw();
01753         INLINE ivector_slice &SetUncheckedInf(ivector_slice &iv,const real &r) throw();
01754 
01756         INLINE void Resize(ivector &rv) throw();
01758         INLINE void Resize(ivector &rv, const int &len)
01759 #if(CXSC_INDEX_CHECK)
01760         throw(ERROR__WRONG_BOUNDARIES<ivector>);
01761 #else
01762         throw();
01763 #endif
01764 
01765         INLINE void Resize(ivector &rv, const int &lb, const int &ub)
01766 #if(CXSC_INDEX_CHECK)
01767         throw(ERROR__WRONG_BOUNDARIES<ivector>);
01768 #else
01769         throw();
01770 #endif
01771         
01773         INLINE ivector abs(const ivector &rv) throw();
01775         INLINE ivector abs(const ivector_slice &sl) throw();
01777         INLINE rvector absmin(const ivector &rv) throw();
01779         INLINE rvector absmax(const ivector_slice &sl) throw();
01781         INLINE rvector absmin(const ivector &rv) throw();
01783         INLINE rvector absmax(const ivector_slice &sl) throw();
01785         INLINE rvector diam(const ivector &v) throw();
01787         INLINE rvector diam(const ivector_slice &v) throw();
01789         INLINE rvector mid(const ivector &v) throw();
01791         INLINE rvector mid(const ivector_slice &v) throw();
01793         INLINE rvector Inf(const ivector &v) throw();
01795         INLINE rvector Inf(const ivector_slice &v) throw();
01797         INLINE rvector Sup(const ivector &v) throw();
01799         INLINE rvector Sup(const ivector_slice &v) throw();
01801         INLINE bool operator !(const ivector &rv) throw();
01803         INLINE bool operator !(const ivector_slice &sl) throw();
01804 
01805 //======================= Vector / Scalar ===============================
01806 
01807 //----------------------------- Interval ---------------------------
01808 
01810         INLINE ivector operator *(const ivector &rv, const interval &s) throw();
01812         INLINE ivector operator *(const ivector_slice &sl, const interval &s) throw();
01814         INLINE ivector operator *(const interval &s, const ivector &rv) throw();
01816         INLINE ivector operator *(const interval &s, const ivector_slice &sl) throw();
01818         INLINE ivector &operator *=(ivector &rv,const interval &r) throw();
01819 
01821         INLINE ivector operator /(const ivector &rv, const interval &s) throw();
01823         INLINE ivector operator /(const ivector_slice &sl, const interval &s) throw();
01825         INLINE ivector &operator /=(ivector &rv,const interval &r) throw();
01826 
01827 //---------------------------- Real --------------------------------------
01828 
01830         INLINE ivector operator *(const ivector &rv, const real &s) throw();
01832         INLINE ivector operator *(const ivector_slice &sl, const real &s) throw();
01834         INLINE ivector operator *(const real &s, const ivector &rv) throw();
01836         INLINE ivector operator *(const real &s, const ivector_slice &sl) throw();
01838         INLINE ivector &operator *=(ivector &rv,const real &r) throw();
01839 
01841         INLINE ivector operator /(const ivector &rv, const real &s) throw();
01843         INLINE ivector operator /(const ivector_slice &sl, const real &s) throw();
01845         INLINE ivector &operator /=(ivector &rv,const real &r) throw();
01846 
01848         INLINE ivector operator *(const rvector &rv, const interval &s) throw();
01850         INLINE ivector operator *(const rvector_slice &sl, const interval &s) throw();
01852         INLINE ivector operator *(const interval &s, const rvector &rv) throw();
01854         INLINE ivector operator *(const interval &s, const rvector_slice &sl) throw();
01855 
01857         INLINE ivector operator /(const rvector &rv, const interval &s) throw();
01859         INLINE ivector operator /(const rvector_slice &sl, const interval &s) throw();
01860 
01861 //======================= Vector / Vector ===============================
01862 
01863 
01865         INLINE std::ostream &operator <<(std::ostream &s, const ivector &rv) throw();
01867         INLINE std::ostream &operator <<(std::ostream &o, const ivector_slice &sl) throw();
01869         INLINE std::istream &operator >>(std::istream &s, ivector &rv) throw();
01871         INLINE std::istream &operator >>(std::istream &s, ivector_slice &rv) throw();
01872         
01873 //----------------------- Interval / Interval ---------------------------
01874 
01876         void accumulate(idotprecision &dp, const ivector &);
01877 
01879         void accumulate(idotprecision &dp, const rvector &);
01880 
01882          void accumulate(idotprecision &dp, const ivector & rv1, const ivector &rv2)
01883 #if(CXSC_INDEX_CHECK)
01884         throw(OP_WITH_WRONG_DIM);
01885 #else
01886         throw();
01887 #endif
01888 
01889          void accumulate(idotprecision &dp, const ivector_slice & sl, const ivector &rv)
01890 #if(CXSC_INDEX_CHECK)
01891         throw(OP_WITH_WRONG_DIM);
01892 #else
01893         throw();
01894 #endif
01895 
01896          void accumulate(idotprecision &dp, const ivector &rv, const ivector_slice &sl)
01897 #if(CXSC_INDEX_CHECK)
01898         throw(OP_WITH_WRONG_DIM);
01899 #else
01900         throw();
01901 #endif
01902 
01903          void accumulate(idotprecision &dp, const ivector & rv1, const imatrix_subv &rv2)
01904 #if(CXSC_INDEX_CHECK)
01905         throw(OP_WITH_WRONG_DIM);
01906 #else
01907         throw();
01908 #endif
01909 
01910          void accumulate(idotprecision &dp, const imatrix_subv & rv1, const ivector &rv2)
01911 #if(CXSC_INDEX_CHECK)
01912         throw(OP_WITH_WRONG_DIM);
01913 #else
01914         throw();
01915 #endif
01916 
01917          void accumulate(idotprecision &dp, const ivector_slice & rv1, const imatrix_subv &rv2)
01918 #if(CXSC_INDEX_CHECK)
01919         throw(OP_WITH_WRONG_DIM);
01920 #else
01921         throw();
01922 #endif
01923 
01924          void accumulate(idotprecision &dp, const imatrix_subv & rv1, const ivector_slice &rv2)
01925 #if(CXSC_INDEX_CHECK)
01926         throw(OP_WITH_WRONG_DIM);
01927 #else
01928         throw();
01929 #endif
01930 
01931          void accumulate(idotprecision &dp, const ivector_slice & sl1, const ivector_slice &sl2)
01932 #if(CXSC_INDEX_CHECK)
01933         throw(OP_WITH_WRONG_DIM);
01934 #else
01935         throw();
01936 #endif
01937 
01938          void accumulate(cidotprecision &dp, const ivector & rv1, const ivector &rv2)
01939 #if(CXSC_INDEX_CHECK)
01940         throw(OP_WITH_WRONG_DIM);
01941 #else
01942         throw();
01943 #endif
01944 
01945          void accumulate(cidotprecision &dp, const ivector_slice & sl, const ivector &rv)
01946 #if(CXSC_INDEX_CHECK)
01947         throw(OP_WITH_WRONG_DIM);
01948 #else
01949         throw();
01950 #endif
01951 
01952          void accumulate(cidotprecision &dp, const ivector &rv, const ivector_slice &sl)
01953 #if(CXSC_INDEX_CHECK)
01954         throw(OP_WITH_WRONG_DIM);
01955 #else
01956         throw();
01957 #endif
01958 
01959          void accumulate(cidotprecision &dp, const ivector & rv1, const imatrix_subv &rv2)
01960 #if(CXSC_INDEX_CHECK)
01961         throw(OP_WITH_WRONG_DIM);
01962 #else
01963         throw();
01964 #endif
01965 
01966          void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const ivector &rv2)
01967 #if(CXSC_INDEX_CHECK)
01968         throw(OP_WITH_WRONG_DIM);
01969 #else
01970         throw();
01971 #endif
01972 
01973          void accumulate(cidotprecision &dp, const ivector_slice & sl1, const ivector_slice &sl2)
01974 #if(CXSC_INDEX_CHECK)
01975         throw(OP_WITH_WRONG_DIM);
01976 #else
01977         throw();
01978 #endif
01979 
01981         INLINE interval operator *(const ivector & rv1, const ivector &rv2)
01982 #if(CXSC_INDEX_CHECK)
01983         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
01984 #else
01985         throw();
01986 #endif
01987 
01988         INLINE interval operator *(const ivector_slice &sl, const ivector &rv)
01989 #if(CXSC_INDEX_CHECK)
01990         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
01991 #else
01992         throw();
01993 #endif
01994 
01995         INLINE interval operator *(const ivector &rv, const ivector_slice &sl)
01996 #if(CXSC_INDEX_CHECK)
01997         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
01998 #else
01999         throw();
02000 #endif
02001 
02002         INLINE interval operator *(const ivector_slice & sl1, const ivector_slice &sl2)
02003 #if(CXSC_INDEX_CHECK)
02004         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02005 #else
02006         throw();
02007 #endif
02008         
02010         INLINE const ivector &operator +(const ivector &rv) throw();
02012         INLINE ivector operator +(const ivector_slice &sl) throw();
02013 
02015         INLINE ivector operator +(const ivector &rv1, const ivector &rv2)
02016 #if(CXSC_INDEX_CHECK)
02017         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02018 #else
02019         throw();
02020 #endif
02021 
02022         INLINE ivector operator +(const ivector &rv, const ivector_slice &sl)
02023 #if(CXSC_INDEX_CHECK)
02024         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02025 #else
02026         throw();
02027 #endif
02028 
02029         INLINE ivector operator +(const ivector_slice &sl, const ivector &rv)
02030 #if(CXSC_INDEX_CHECK)
02031         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02032 #else
02033         throw();
02034 #endif
02035 
02036         INLINE ivector operator +(const ivector_slice &sl1, const ivector_slice &sl2)
02037 #if(CXSC_INDEX_CHECK)
02038         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02039 #else
02040         throw();
02041 #endif
02042 
02043         INLINE ivector & operator +=(ivector &rv1, const ivector &rv2)
02044 #if(CXSC_INDEX_CHECK)
02045         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02046 #else
02047         throw();
02048 #endif
02049 
02050         INLINE ivector &operator +=(ivector &rv, const ivector_slice &sl)
02051 #if(CXSC_INDEX_CHECK)
02052         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02053 #else
02054         throw();
02055 #endif
02056 
02058         INLINE ivector operator -(const ivector &rv) throw();
02060         INLINE ivector operator -(const ivector_slice &sl) throw();
02062         INLINE ivector operator -(const ivector &rv1, const ivector &rv2)
02063 #if(CXSC_INDEX_CHECK)
02064         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02065 #else
02066         throw();
02067 #endif
02068 
02069         INLINE ivector operator -(const ivector &rv, const ivector_slice &sl)
02070 #if(CXSC_INDEX_CHECK)
02071         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02072 #else
02073         throw();
02074 #endif
02075 
02076         INLINE ivector operator -(const ivector_slice &sl, const ivector &rv)
02077 #if(CXSC_INDEX_CHECK)
02078         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02079 #else
02080         throw();
02081 #endif
02082 
02083         INLINE ivector operator -(const ivector_slice &sl1, const ivector_slice &sl2)
02084 #if(CXSC_INDEX_CHECK)
02085         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02086 #else
02087         throw();
02088 #endif
02089 
02090         INLINE ivector & operator -=(ivector &rv1, const ivector &rv2)
02091 #if(CXSC_INDEX_CHECK)
02092         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02093 #else
02094         throw();
02095 #endif
02096 
02097         INLINE ivector &operator -=(ivector &rv, const ivector_slice &sl)
02098 #if(CXSC_INDEX_CHECK)
02099         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02100 #else
02101         throw();
02102 #endif
02103 
02105         INLINE ivector operator |(const ivector &rv1, const ivector &rv2)
02106 #if(CXSC_INDEX_CHECK)
02107         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02108 #else
02109         throw();
02110 #endif
02111 
02112         INLINE ivector operator |(const ivector &rv, const ivector_slice &sl)
02113 #if(CXSC_INDEX_CHECK)
02114         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02115 #else
02116         throw();
02117 #endif
02118 
02119         INLINE ivector operator |(const ivector_slice &sl, const ivector &rv)
02120 #if(CXSC_INDEX_CHECK)
02121         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02122 #else
02123         throw();
02124 #endif
02125 
02126         INLINE ivector operator |(const ivector_slice &sl1, const ivector_slice &sl2)
02127 #if(CXSC_INDEX_CHECK)
02128         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02129 #else
02130         throw();
02131 #endif
02132 
02133         INLINE ivector & operator |=(ivector &rv1, const ivector &rv2)
02134 #if(CXSC_INDEX_CHECK)
02135         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02136 #else
02137         throw();
02138 #endif
02139 
02140         INLINE ivector &operator |=(ivector &rv, const ivector_slice &sl)
02141 #if(CXSC_INDEX_CHECK)
02142         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02143 #else
02144         throw();
02145 #endif
02146 
02148         INLINE ivector operator &(const ivector &rv1, const ivector &rv2)
02149 #if(CXSC_INDEX_CHECK)
02150         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02151 #else
02152         throw();
02153 #endif
02154 
02155         INLINE ivector operator &(const ivector &rv, const ivector_slice &sl)
02156 #if(CXSC_INDEX_CHECK)
02157         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02158 #else
02159         throw();
02160 #endif
02161 
02162         INLINE ivector operator &(const ivector_slice &sl, const ivector &rv)
02163 #if(CXSC_INDEX_CHECK)
02164         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02165 #else
02166         throw();
02167 #endif
02168 
02169         INLINE ivector operator &(const ivector_slice &sl1, const ivector_slice &sl2)
02170 #if(CXSC_INDEX_CHECK)
02171         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02172 #else
02173         throw();
02174 #endif
02175 
02176         INLINE ivector & operator &=(ivector &rv1, const ivector &rv2)
02177 #if(CXSC_INDEX_CHECK)
02178         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02179 #else
02180         throw();
02181 #endif
02182 
02183         INLINE ivector &operator &=(ivector &rv, const ivector_slice &sl)
02184 #if(CXSC_INDEX_CHECK)
02185         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02186 #else
02187         throw();
02188 #endif
02189 
02191         INLINE bool operator ==(const ivector &rv1, const ivector &rv2) throw();
02193         INLINE bool operator ==(const ivector_slice &sl1, const ivector_slice &sl2) throw();
02195         INLINE bool operator ==(const ivector_slice &sl, const ivector &rv) throw();
02197         INLINE bool operator ==(const ivector &rv, const ivector_slice &sl) throw();
02199         INLINE bool operator !=(const ivector &rv1, const ivector &rv2) throw();
02201         INLINE bool operator !=(const ivector_slice &sl1, const ivector_slice &sl2) throw();
02203         INLINE bool operator !=(const ivector_slice &sl, const ivector &rv) throw();
02205         INLINE bool operator !=(const ivector &rv, const ivector_slice &sl) throw();
02207         INLINE bool operator <(const ivector &rv1, const ivector &rv2) throw();
02209         INLINE bool operator <(const ivector_slice &sl1, const ivector_slice &sl2) throw();
02211         INLINE bool operator < (const ivector_slice &sl, const ivector &rv) throw();
02213         INLINE bool operator < (const ivector &rv, const ivector_slice &sl) throw();
02215         INLINE bool operator <=(const ivector &rv1, const ivector &rv2) throw();
02217         INLINE bool operator <=(const ivector_slice &sl1, const ivector_slice &sl2) throw();
02219         INLINE bool operator <=(const ivector_slice &sl, const ivector &rv) throw();
02221         INLINE bool operator <=(const ivector &rv, const ivector_slice &sl) throw();
02223         INLINE bool operator >(const ivector &rv1, const ivector &rv2) throw();
02225         INLINE bool operator >(const ivector_slice &sl1, const ivector_slice &sl2) throw();
02227         INLINE bool operator >(const ivector_slice &sl, const ivector &rv) throw();
02229         INLINE bool operator >(const ivector &rv, const ivector_slice &sl) throw();
02231         INLINE bool operator >=(const ivector &rv1, const ivector &rv2) throw();
02233         INLINE bool operator >=(const ivector_slice &sl1, const ivector_slice &sl2) throw();
02235         INLINE bool operator >=(const ivector_slice &sl, const ivector &rv) throw();
02237         INLINE bool operator >=(const ivector &rv, const ivector_slice &sl) throw();
02238 
02239 //-------------------------------- Interval / Real --------------------------------
02240 
02242          void accumulate(idotprecision &dp, const rvector & rv1, const ivector &rv2)
02243 #if(CXSC_INDEX_CHECK)
02244         throw(OP_WITH_WRONG_DIM);
02245 #else
02246         throw();
02247 #endif
02248 
02249          void accumulate(idotprecision &dp, const ivector & rv1, const rvector &rv2)
02250 #if(CXSC_INDEX_CHECK)
02251         throw(OP_WITH_WRONG_DIM);
02252 #else
02253         throw();
02254 #endif
02255 
02256          void accumulate(idotprecision &dp, const rvector_slice & sl, const ivector &rv)
02257 #if(CXSC_INDEX_CHECK)
02258         throw(OP_WITH_WRONG_DIM);
02259 #else
02260         throw();
02261 #endif
02262 
02263          void accumulate(idotprecision &dp,const ivector_slice &sl,const rvector &rv)
02264 #if(CXSC_INDEX_CHECK)
02265         throw(OP_WITH_WRONG_DIM);
02266 #else
02267         throw();
02268 #endif
02269 
02270          void accumulate(idotprecision &dp, const rvector &rv, const ivector_slice &sl)
02271 #if(CXSC_INDEX_CHECK)
02272         throw(OP_WITH_WRONG_DIM);
02273 #else
02274         throw();
02275 #endif
02276 
02277          void accumulate(idotprecision &dp, const rvector & rv1, const imatrix_subv &rv2)
02278 #if(CXSC_INDEX_CHECK)
02279         throw(OP_WITH_WRONG_DIM);
02280 #else
02281         throw();
02282 #endif
02283 
02284          void accumulate(idotprecision &dp, const ivector & rv1, const rmatrix_subv &rv2)
02285 #if(CXSC_INDEX_CHECK)
02286         throw(OP_WITH_WRONG_DIM);
02287 #else
02288         throw();
02289 #endif
02290 
02291          void accumulate(idotprecision &dp, const rvector_slice & rv1, const imatrix_subv &rv2)
02292 #if(CXSC_INDEX_CHECK)
02293         throw(OP_WITH_WRONG_DIM);
02294 #else
02295         throw();
02296 #endif
02297 
02298          void accumulate(idotprecision &dp, const ivector_slice & rv1, const rmatrix_subv &rv2)
02299 #if(CXSC_INDEX_CHECK)
02300         throw(OP_WITH_WRONG_DIM);
02301 #else
02302         throw();
02303 #endif
02304 
02305          void accumulate(idotprecision &dp,const ivector &rv,const rvector_slice &sl)
02306 #if(CXSC_INDEX_CHECK)
02307         throw(OP_WITH_WRONG_DIM);
02308 #else
02309         throw();
02310 #endif
02311 
02312          void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const ivector &rv2)
02313 #if(CXSC_INDEX_CHECK)
02314         throw(OP_WITH_WRONG_DIM);
02315 #else
02316         throw();
02317 #endif
02318 
02319          void accumulate(idotprecision &dp, const imatrix_subv & rv1, const rvector &rv2)
02320 #if(CXSC_INDEX_CHECK)
02321         throw(OP_WITH_WRONG_DIM);
02322 #else
02323         throw();
02324 #endif
02325 
02326          void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const ivector_slice &rv2)
02327 #if(CXSC_INDEX_CHECK)
02328         throw(OP_WITH_WRONG_DIM);
02329 #else
02330         throw();
02331 #endif
02332 
02333          void accumulate(idotprecision &dp, const imatrix_subv & rv1, const rvector_slice &rv2)
02334 #if(CXSC_INDEX_CHECK)
02335         throw(OP_WITH_WRONG_DIM);
02336 #else
02337         throw();
02338 #endif
02339 
02340          void accumulate(idotprecision &dp, const ivector_slice & sl1, const rvector_slice &sl2)
02341 #if(CXSC_INDEX_CHECK)
02342         throw(OP_WITH_WRONG_DIM);
02343 #else
02344         throw();
02345 #endif
02346 
02347          void accumulate(idotprecision &dp, const rvector_slice & sl1, const ivector_slice &sl2)
02348 #if(CXSC_INDEX_CHECK)
02349         throw(OP_WITH_WRONG_DIM);
02350 #else
02351         throw();
02352 #endif
02353 
02354          void accumulate(cidotprecision &dp, const rvector & rv1, const ivector &rv2)
02355 #if(CXSC_INDEX_CHECK)
02356         throw(OP_WITH_WRONG_DIM);
02357 #else
02358         throw();
02359 #endif
02360 
02361          void accumulate(cidotprecision &dp, const ivector & rv1, const rvector &rv2)
02362 #if(CXSC_INDEX_CHECK)
02363         throw(OP_WITH_WRONG_DIM);
02364 #else
02365         throw();
02366 #endif
02367 
02368          void accumulate(cidotprecision &dp, const rvector_slice & sl, const ivector &rv)
02369 #if(CXSC_INDEX_CHECK)
02370         throw(OP_WITH_WRONG_DIM);
02371 #else
02372         throw();
02373 #endif
02374 
02375          void accumulate(cidotprecision &dp,const ivector_slice &sl,const rvector &rv)
02376 #if(CXSC_INDEX_CHECK)
02377         throw(OP_WITH_WRONG_DIM);
02378 #else
02379         throw();
02380 #endif
02381 
02382          void accumulate(cidotprecision &dp, const rvector &rv, const ivector_slice &sl)
02383 #if(CXSC_INDEX_CHECK)
02384         throw(OP_WITH_WRONG_DIM);
02385 #else
02386         throw();
02387 #endif
02388 
02389          void accumulate(cidotprecision &dp, const rvector & rv1, const imatrix_subv &rv2)
02390 #if(CXSC_INDEX_CHECK)
02391         throw(OP_WITH_WRONG_DIM);
02392 #else
02393         throw();
02394 #endif
02395 
02396          void accumulate(cidotprecision &dp, const ivector & rv1, const rmatrix_subv &rv2)
02397 #if(CXSC_INDEX_CHECK)
02398         throw(OP_WITH_WRONG_DIM);
02399 #else
02400         throw();
02401 #endif
02402 
02403          void accumulate(cidotprecision &dp, const rvector_slice & rv1, const imatrix_subv &rv2)
02404 #if(CXSC_INDEX_CHECK)
02405         throw(OP_WITH_WRONG_DIM);
02406 #else
02407         throw();
02408 #endif
02409 
02410          void accumulate(cidotprecision &dp, const ivector_slice & rv1, const rmatrix_subv &rv2)
02411 #if(CXSC_INDEX_CHECK)
02412         throw(OP_WITH_WRONG_DIM);
02413 #else
02414         throw();
02415 #endif
02416 
02417          void accumulate(cidotprecision &dp,const ivector &rv,const rvector_slice &sl)
02418 #if(CXSC_INDEX_CHECK)
02419         throw(OP_WITH_WRONG_DIM);
02420 #else
02421         throw();
02422 #endif
02423 
02424          void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const ivector &rv2)
02425 #if(CXSC_INDEX_CHECK)
02426         throw(OP_WITH_WRONG_DIM);
02427 #else
02428         throw();
02429 #endif
02430 
02431          void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const rvector &rv2)
02432 #if(CXSC_INDEX_CHECK)
02433         throw(OP_WITH_WRONG_DIM);
02434 #else
02435         throw();
02436 #endif
02437 
02438          void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const ivector_slice &rv2)
02439 #if(CXSC_INDEX_CHECK)
02440         throw(OP_WITH_WRONG_DIM);
02441 #else
02442         throw();
02443 #endif
02444 
02445          void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const rvector_slice &rv2)
02446 #if(CXSC_INDEX_CHECK)
02447         throw(OP_WITH_WRONG_DIM);
02448 #else
02449         throw();
02450 #endif
02451 
02452          void accumulate(cidotprecision &dp, const ivector_slice & sl1, const rvector_slice &sl2)
02453 #if(CXSC_INDEX_CHECK)
02454         throw(OP_WITH_WRONG_DIM);
02455 #else
02456         throw();
02457 #endif
02458 
02459          void accumulate(cidotprecision &dp, const rvector_slice & sl1, const ivector_slice &sl2)
02460 #if(CXSC_INDEX_CHECK)
02461         throw(OP_WITH_WRONG_DIM);
02462 #else
02463         throw();
02464 #endif
02465 
02467         INLINE interval operator *(const rvector & rv1, const ivector &rv2)
02468 #if(CXSC_INDEX_CHECK)
02469         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02470 #else
02471         throw();
02472 #endif
02473 
02474         INLINE interval operator *(const rvector_slice &sl, const ivector &rv)
02475 #if(CXSC_INDEX_CHECK)
02476         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02477 #else
02478         throw();
02479 #endif
02480 
02481         INLINE interval operator *(const rvector &rv, const ivector_slice &sl)
02482 #if(CXSC_INDEX_CHECK)
02483         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02484 #else
02485         throw();
02486 #endif
02487 
02488         INLINE interval operator *(const rvector_slice & sl1, const ivector_slice &sl2)
02489 #if(CXSC_INDEX_CHECK)
02490         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02491 #else
02492         throw();
02493 #endif
02494         
02496         INLINE interval operator *(const ivector & rv1, const rvector &rv2)
02497 #if(CXSC_INDEX_CHECK)
02498         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02499 #else
02500         throw();
02501 #endif
02502 
02503         INLINE interval operator *(const ivector_slice &sl, const rvector &rv)
02504 #if(CXSC_INDEX_CHECK)
02505         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02506 #else
02507         throw();
02508 #endif
02509 
02510         INLINE interval operator *(const ivector &rv, const rvector_slice &sl)
02511 #if(CXSC_INDEX_CHECK)
02512         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02513 #else
02514         throw();
02515 #endif
02516 
02517         INLINE interval operator *(const ivector_slice & sl1, const rvector_slice &sl2)
02518 #if(CXSC_INDEX_CHECK)
02519         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02520 #else
02521         throw();
02522 #endif
02523         
02525         INLINE ivector operator +(const rvector &rv1, const ivector &rv2)
02526 #if(CXSC_INDEX_CHECK)
02527         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02528 #else
02529         throw();
02530 #endif
02531 
02532         INLINE ivector operator +(const rvector &rv, const ivector_slice &sl)
02533 #if(CXSC_INDEX_CHECK)
02534         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02535 #else
02536         throw();
02537 #endif
02538 
02539         INLINE ivector operator +(const rvector_slice &sl, const ivector &rv)
02540 #if(CXSC_INDEX_CHECK)
02541         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02542 #else
02543         throw();
02544 #endif
02545 
02546         INLINE ivector operator +(const rvector_slice &sl1, const ivector_slice &sl2)
02547 #if(CXSC_INDEX_CHECK)
02548         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02549 #else
02550         throw();
02551 #endif
02552 
02554         INLINE ivector operator +(const ivector &rv1, const rvector &rv2)
02555 #if(CXSC_INDEX_CHECK)
02556         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02557 #else
02558         throw();
02559 #endif
02560 
02561         INLINE ivector operator +(const ivector &rv, const rvector_slice &sl)
02562 #if(CXSC_INDEX_CHECK)
02563         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02564 #else
02565         throw();
02566 #endif
02567 
02568         INLINE ivector operator +(const ivector_slice &sl, const rvector &rv)
02569 #if(CXSC_INDEX_CHECK)
02570         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02571 #else
02572         throw();
02573 #endif
02574 
02575         INLINE ivector operator +(const ivector_slice &sl1, const rvector_slice &sl2)
02576 #if(CXSC_INDEX_CHECK)
02577         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02578 #else
02579         throw();
02580 #endif
02581 
02583         INLINE ivector & operator +=(ivector &rv1, const rvector &rv2)
02584 #if(CXSC_INDEX_CHECK)
02585         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02586 #else
02587         throw();
02588 #endif
02589 
02590         INLINE ivector &operator +=(ivector &rv, const rvector_slice &sl)
02591 #if(CXSC_INDEX_CHECK)
02592         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02593 #else
02594         throw();
02595 #endif
02596 
02598         INLINE ivector operator -(const rvector &rv1, const ivector &rv2)
02599 #if(CXSC_INDEX_CHECK)
02600         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02601 #else
02602         throw();
02603 #endif
02604 
02605         INLINE ivector operator -(const rvector &rv, const ivector_slice &sl)
02606 #if(CXSC_INDEX_CHECK)
02607         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02608 #else
02609         throw();
02610 #endif
02611 
02612         INLINE ivector operator -(const rvector_slice &sl, const ivector &rv)
02613 #if(CXSC_INDEX_CHECK)
02614         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02615 #else
02616         throw();
02617 #endif
02618 
02619         INLINE ivector operator -(const rvector_slice &sl1, const ivector_slice &sl2)
02620 #if(CXSC_INDEX_CHECK)
02621         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02622 #else
02623         throw();
02624 #endif
02625 
02627         INLINE ivector operator -(const ivector &rv1, const rvector &rv2)
02628 #if(CXSC_INDEX_CHECK)
02629         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02630 #else
02631         throw();
02632 #endif
02633 
02634         INLINE ivector operator -(const ivector &rv, const rvector_slice &sl)
02635 #if(CXSC_INDEX_CHECK)
02636         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02637 #else
02638         throw();
02639 #endif
02640 
02641         INLINE ivector operator -(const ivector_slice &sl, const rvector &rv)
02642 #if(CXSC_INDEX_CHECK)
02643         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02644 #else
02645         throw();
02646 #endif
02647 
02648         INLINE ivector operator -(const ivector_slice &sl1, const rvector_slice &sl2)
02649 #if(CXSC_INDEX_CHECK)
02650         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02651 #else
02652         throw();
02653 #endif
02654 
02656         INLINE ivector & operator -=(ivector &rv1, const rvector &rv2)
02657 #if(CXSC_INDEX_CHECK)
02658         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02659 #else
02660         throw();
02661 #endif
02662 
02663         INLINE ivector &operator -=(ivector &rv, const rvector_slice &sl)
02664 #if(CXSC_INDEX_CHECK)
02665         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02666 #else
02667         throw();
02668 #endif
02669 
02671         INLINE ivector operator |(const rvector &rv1, const rvector &rv2)
02672 #if(CXSC_INDEX_CHECK)
02673         throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
02674 #else
02675         throw();
02676 #endif
02677 
02678         INLINE ivector operator |(const rvector &rv, const rvector_slice &sl)
02679 #if(CXSC_INDEX_CHECK)
02680         throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
02681 #else
02682         throw();
02683 #endif
02684 
02685         INLINE ivector operator |(const rvector_slice &sl, const rvector &rv)
02686 #if(CXSC_INDEX_CHECK)
02687         throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
02688 #else
02689         throw();
02690 #endif
02691 
02692         INLINE ivector operator |(const rvector_slice &sl1, const rvector_slice &sl2)
02693 #if(CXSC_INDEX_CHECK)
02694         throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
02695 #else
02696         throw();
02697 #endif
02698 
02699         INLINE ivector operator |(const rvector &rv1, const ivector &rv2)
02700 #if(CXSC_INDEX_CHECK)
02701         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02702 #else
02703         throw();
02704 #endif
02705 
02706         INLINE ivector operator |(const rvector &rv, const ivector_slice &sl)
02707 #if(CXSC_INDEX_CHECK)
02708         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02709 #else
02710         throw();
02711 #endif
02712 
02713         INLINE ivector operator |(const rvector_slice &sl, const ivector &rv)
02714 #if(CXSC_INDEX_CHECK)
02715         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02716 #else
02717         throw();
02718 #endif
02719 
02720         INLINE ivector operator |(const rvector_slice &sl1, const ivector_slice &sl2)
02721 #if(CXSC_INDEX_CHECK)
02722         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02723 #else
02724         throw();
02725 #endif
02726 
02728         INLINE ivector operator |(const ivector &rv1, const rvector &rv2)
02729 #if(CXSC_INDEX_CHECK)
02730         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02731 #else
02732         throw();
02733 #endif
02734 
02735         INLINE ivector operator |(const ivector &rv, const rvector_slice &sl)
02736 #if(CXSC_INDEX_CHECK)
02737         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02738 #else
02739         throw();
02740 #endif
02741 
02742         INLINE ivector operator |(const ivector_slice &sl, const rvector &rv)
02743 #if(CXSC_INDEX_CHECK)
02744         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02745 #else
02746         throw();
02747 #endif
02748 
02749         INLINE ivector operator |(const ivector_slice &sl1, const rvector_slice &sl2)
02750 #if(CXSC_INDEX_CHECK)
02751         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02752 #else
02753         throw();
02754 #endif
02755 
02757         INLINE ivector & operator |=(ivector &rv1, const rvector &rv2)
02758 #if(CXSC_INDEX_CHECK)
02759         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02760 #else
02761         throw();
02762 #endif
02763 
02764         INLINE ivector &operator |=(ivector &rv, const rvector_slice &sl)
02765 #if(CXSC_INDEX_CHECK)
02766         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02767 #else
02768         throw();
02769 #endif
02770 
02772         INLINE ivector operator &(const rvector &rv1, const ivector &rv2)
02773 #if(CXSC_INDEX_CHECK)
02774         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02775 #else
02776         throw();
02777 #endif
02778 
02779         INLINE ivector operator &(const rvector &rv, const ivector_slice &sl)
02780 #if(CXSC_INDEX_CHECK)
02781         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02782 #else
02783         throw();
02784 #endif
02785 
02786         INLINE ivector operator &(const rvector_slice &sl, const ivector &rv)
02787 #if(CXSC_INDEX_CHECK)
02788         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02789 #else
02790         throw();
02791 #endif
02792 
02793         INLINE ivector operator &(const rvector_slice &sl1, const ivector_slice &sl2)
02794 #if(CXSC_INDEX_CHECK)
02795         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02796 #else
02797         throw();
02798 #endif
02799 
02801         INLINE ivector operator &(const ivector &rv1, const rvector &rv2)
02802 #if(CXSC_INDEX_CHECK)
02803         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02804 #else
02805         throw();
02806 #endif
02807 
02808         INLINE ivector operator &(const ivector &rv, const rvector_slice &sl)
02809 #if(CXSC_INDEX_CHECK)
02810         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02811 #else
02812         throw();
02813 #endif
02814 
02815         INLINE ivector operator &(const ivector_slice &sl, const rvector &rv)
02816 #if(CXSC_INDEX_CHECK)
02817         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02818 #else
02819         throw();
02820 #endif
02821 
02822         INLINE ivector operator &(const ivector_slice &sl1, const rvector_slice &sl2)
02823 #if(CXSC_INDEX_CHECK)
02824         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02825 #else
02826         throw();
02827 #endif
02828 
02830         INLINE ivector & operator &=(ivector &rv1, const rvector &rv2)
02831 #if(CXSC_INDEX_CHECK)
02832         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02833 #else
02834         throw();
02835 #endif
02836 
02837         INLINE ivector &operator &=(ivector &rv, const rvector_slice &sl)
02838 #if(CXSC_INDEX_CHECK)
02839         throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
02840 #else
02841         throw();
02842 #endif
02843 
02845 extern int      in         ( const ivector&, const ivector& );
02847 extern int      in         ( int,      ivector& );
02849 extern ivector  Blow       ( const ivector&, real );
02851 extern int      Disjoint   ( ivector&, ivector& );
02853 extern int      Zero       ( ivector& );
02855 extern rvector  mid        ( ivector& );
02857 extern real     MaxRelDiam ( const ivector& );
02859 extern real     MaxRelDiam ( const ivector_slice& );
02861 extern int      UlpAcc     ( ivector&, int );
02863 extern void     DoubleSize ( ivector& );
02864 
02865 
02866 } // namespace cxsc 
02867 
02868 #ifdef _CXSC_INCL_INL
02869 #include "vector.inl"
02870 #include "ivector.inl"
02871 #endif
02872                 
02873 #ifdef _CXSC_RMATRIX_HPP_INCLUDED
02874 # ifdef _CXSC_INCL_INL
02875 #  include "ivecrmat.inl"
02876 # else
02877 #  include "ivecrmat.hpp"
02878 # endif
02879 #endif
02880                 
02881 #ifdef _CXSC_CMATRIX_HPP_INCLUDED
02882 # ifdef _CXSC_INCL_INL
02883 #  include "iveccmat.inl"
02884 # else
02885 #  include "iveccmat.hpp"
02886 # endif
02887 #endif
02888                 
02889 #ifdef _CXSC_LRMATRIX_HPP_INCLUDED
02890 # ifdef _CXSC_INCL_INL
02891 #  include "iveclrmat.inl"
02892 # else
02893 #  include "iveclrmat.hpp"
02894 # endif
02895 #endif
02896                 
02897 #ifdef _CXSC_CVECTOR_HPP_INCLUDED
02898 # ifdef _CXSC_INCL_INL
02899 #  include "iveccvec.inl"
02900 # else
02901 #  include "iveccvec.hpp"
02902 # endif
02903 #endif
02904 
02905 #ifdef _CXSC_LRVECTOR_HPP_INCLUDED
02906 # ifdef _CXSC_INCL_INL
02907 #  include "lrvecivec.inl"
02908 # else
02909 #  include "lrvecivec.hpp"
02910 # endif
02911 #endif
02912 
02913 #ifdef CXSC_USE_BLAS
02914 #define _CXSC_BLAS_IVECTOR
02915 #include "cxsc_blas.inl"
02916 #endif
02917 
02918 #endif