C-XSC - A C++ Class Library for Extended Scientific Computing: l

00001 /*
00002 **  CXSC is a C++ library for eXtended Scientific Computing (V 2.5.1)
00003 **
00004 **  Copyright (C) 1990-2000 Institut fuer Angewandte Mathematik,
00005 **                          Universitaet Karlsruhe, Germany
00006 **            (C) 2000-2011 Wiss. Rechnen/Softwaretechnologie
00007 **                          Universitaet Wuppertal, Germany   
00008 **
00009 **  This library is free software; you can redistribute it and/or
00010 **  modify it under the terms of the GNU Library General Public
00011 **  License as published by the Free Software Foundation; either
00012 **  version 2 of the License, or (at your option) any later version.
00013 **
00014 **  This library is distributed in the hope that it will be useful,
00015 **  but WITHOUT ANY WARRANTY; without even the implied warranty of
00016 **  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00017 **  Library General Public License for more details.
00018 **
00019 **  You should have received a copy of the GNU Library General Public
00020 **  License along with this library; if not, write to the Free
00021 **  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00022 */
00023 
00024 /* CVS $Id: l_ivector.hpp,v 1.15 2011/06/07 15:17:40 cxsc Exp $ */
00025 
00026 #ifndef _CXSC_LIVECTOR_HPP_INCLUDED
00027 #define _CXSC_LIVECTOR_HPP_INCLUDED
00028 
00029 #include "xscclass.hpp"
00030 #include "except.hpp"
00031 #include "idot.hpp"
00032 #include "l_interval.hpp" // used for declaration of Inf, Sup,...
00033 //#include "cxscmatr.hpp"
00034 #include "rvector.hpp"
00035 #include "ivector.hpp"
00036 #include "l_rvector.hpp"
00037 #include "vector.hpp"
00038 
00039 
00040 #include <iostream>
00041 
00042 //#include "matrix.hpp" // hat hier eigentlich nichts zu suchen, sonst aber Internal Compiler Error #9
00043 
00044 namespace cxsc {
00045 
00046 class l_ivector_slice;
00047 
00049 
00054 class l_ivector
00055 {
00056         friend class l_ivector_slice;
00057         friend class l_imatrix;
00058         friend class l_imatrix_subv;
00059         private:
00060         l_interval *dat;
00061         int l,u,size;
00062 
00063         public:
00064 //#if(CXSC_INDEX_CHECK)
00065 #ifdef _CXSC_FRIEND_TPL
00066         //------------ Templates --------------------------------------------------
00067         // l_interval
00068 template <class V,class MS,class S> friend  void _vmsconstr(V &v,const MS &m)
00069 #if(CXSC_INDEX_CHECK)
00070         throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>);
00071 #else
00072         throw();
00073 #endif
00074 template <class V,class M,class S> friend  void _vmconstr(V &v,const M &m)
00075 #if(CXSC_INDEX_CHECK)
00076         throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
00077 #else
00078         throw();
00079 #endif
00080  template <class V> friend       void _vresize(V &rv) throw();
00081  template <class V,class S> friend       void _vresize(V &rv, const int &len)
00082 #if(CXSC_INDEX_CHECK)
00083                 throw(ERROR__WRONG_BOUNDARIES<V>);
00084 #else
00085         throw();
00086 #endif
00087  template <class V,class S> friend       void _vresize(V &rv, const int &lb, const int &ub)
00088 #if(CXSC_INDEX_CHECK)
00089                 throw(ERROR__WRONG_BOUNDARIES<V>);
00090 #else
00091         throw();
00092 #endif
00093  template <class V1,class V2,class S> friend     V1 &_vvassign(V1 &rv1,const V2 &rv2) throw();
00094  template <class V,class S> friend       V & _vsassign(V &rv,const S &r) throw();
00095  template <class V,class VS,class S> friend      V & _vvsassign(V &rv,const VS &sl) throw();
00096  template <class VS,class V> friend      VS & _vsvassign(VS &sl,const V &rv)
00097 #if(CXSC_INDEX_CHECK)
00098                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00099 #else
00100         throw();
00101 #endif
00102 template <class V,class M,class S> friend  V &_vmassign(V &v,const M &m)
00103 #if(CXSC_INDEX_CHECK)
00104         throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
00105 #else
00106         throw();
00107 #endif
00108 template <class M,class V,class S> friend  M &_mvassign(M &m,const V &v) throw();
00109  template <class V1,class V2> friend     V1 &_vvsetinf(V1 &rv1, const V2 &rv2)
00110 #if(CXSC_INDEX_CHECK)
00111                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00112 #else
00113         throw();
00114 #endif
00115  template <class V1,class V2> friend     V1 &_vvsetsup(V1 &rv1, const V2 &rv2)
00116 #if(CXSC_INDEX_CHECK)
00117                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00118 #else
00119         throw();
00120 #endif
00121  template <class V,class VS> friend      V &_vvssetinf(V &rv, const VS &sl)
00122 #if(CXSC_INDEX_CHECK)
00123                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00124 #else
00125         throw();
00126 #endif
00127  template <class V,class VS> friend      V &_vvssetsup(V &rv, const VS &sl)
00128 #if(CXSC_INDEX_CHECK)
00129                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00130 #else
00131         throw();
00132 #endif
00133 template <class V,class MV> friend  V &_vmvsetinf(V &rv,const MV &v)
00134 #if(CXSC_INDEX_CHECK)
00135         throw(ERROR__OP_WITH_WRONG_DIM<V>);
00136 #else
00137         throw();
00138 #endif
00139 template <class V,class MV> friend  V &_vmvsetsup(V &rv,const MV &v)
00140 #if(CXSC_INDEX_CHECK)
00141         throw(ERROR__OP_WITH_WRONG_DIM<V>);
00142 #else
00143         throw();
00144 #endif
00145  template <class V1,class V2> friend     V1 &_vvusetinf(V1 &rv1, const V2 &rv2)
00146 #if(CXSC_INDEX_CHECK)
00147                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00148 #else
00149         throw();
00150 #endif
00151  template <class V1,class V2> friend     V1 &_vvusetsup(V1 &rv1, const V2 &rv2)
00152 #if(CXSC_INDEX_CHECK)
00153                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00154 #else
00155         throw();
00156 #endif
00157  template <class V,class VS> friend      V &_vvsusetinf(V &rv, const VS &sl)
00158 #if(CXSC_INDEX_CHECK)
00159                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00160 #else
00161         throw();
00162 #endif
00163  template <class V,class VS> friend      V &_vvsusetsup(V &rv, const VS &sl)
00164 #if(CXSC_INDEX_CHECK)
00165                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00166 #else
00167         throw();
00168 #endif
00169 template <class V,class MV> friend  V &_vmvusetinf(V &rv,const MV &v)
00170 #if(CXSC_INDEX_CHECK)
00171         throw(ERROR__OP_WITH_WRONG_DIM<V>);
00172 #else
00173         throw();
00174 #endif
00175 template <class V,class MV> friend  V &_vmvusetsup(V &rv,const MV &v)
00176 #if(CXSC_INDEX_CHECK)
00177         throw(ERROR__OP_WITH_WRONG_DIM<V>);
00178 #else
00179         throw();
00180 #endif
00181  template <class V,class S> friend       V &_vssetinf(V &v, const S &s) throw();
00182  template <class V,class S> friend       V &_vssetsup(V &v, const S &s) throw();
00183  template <class V,class S> friend       V &_vsusetinf(V &v, const S &s) throw();
00184  template <class V,class S> friend       V &_vsusetsup(V &v, const S &s) throw();
00185  template <class V,class E> friend       E _vabs(const V &rv) throw();
00186  template <class VS,class E> friend      E _vsabs(const VS &sl) throw();
00187 template <class MV,class V> friend  V _mvabs(const MV &mv) throw();
00188  template <class V,class E> friend       E _vdiam(const V &rv) throw();
00189  template <class V,class E> friend       E _vmid(const V &rv) throw();
00190  template <class V,class E> friend       E _vinf(const V &rv) throw();
00191  template <class V,class E> friend       E _vsup(const V &rv) throw();
00192 
00193 //-------- vector-vector -----------------------
00194  template <class DP,class V1,class V2> friend    void _vvaccu(DP &dp, const V1 & rv1, const V2 &rv2)
00195 #if(CXSC_INDEX_CHECK)
00196                 throw(OP_WITH_WRONG_DIM);
00197 #else
00198         throw();
00199 #endif
00200  template <class DP,class VS,class V> friend     void _vsvaccu(DP &dp, const VS & sl, const V &rv)
00201 #if(CXSC_INDEX_CHECK)
00202                 throw(OP_WITH_WRONG_DIM);
00203 #else
00204         throw();
00205 #endif
00206 
00207  template <class V1,class V2,class E> friend     E _vvlimult(const V1 & rv1, const V2 &rv2)
00208 #if(CXSC_INDEX_CHECK)
00209                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00210 #else
00211         throw();
00212 #endif
00213  template <class VS,class V,class E> friend      E _vsvlimult(const VS & sl, const V &rv)
00214 #if(CXSC_INDEX_CHECK)
00215                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00216 #else
00217         throw();
00218 #endif
00219         
00220  template <class V,class S> friend       V &_vsmultassign(V &rv,const S &r) throw();
00221  template <class V1,class V2,class E> friend     E _vvplus(const V1 &rv1, const V2 &rv2)
00222 #if(CXSC_INDEX_CHECK)
00223                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00224 #else
00225         throw();
00226 #endif
00227  template <class V,class VS,class E> friend      E _vvsplus(const V &rv,const VS &sl)
00228 #if(CXSC_INDEX_CHECK)
00229                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00230 #else
00231         throw();
00232 #endif
00233  template <class VS1,class VS2,class E> friend   E _vsvsplus(const VS1 &s1,const VS2 &s2)
00234 #if(CXSC_INDEX_CHECK)
00235                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00236 #else
00237         throw();
00238 #endif
00239  template <class VS1,class VS2,class E> friend   E _vsvsminus(const VS1 &s1,const VS2 &s2)
00240 #if(CXSC_INDEX_CHECK)
00241                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00242 #else
00243         throw();
00244 #endif
00245  template <class V1,class V2> friend     V1 &_vvplusassign(V1 &rv1, const V2 &rv2)
00246 #if(CXSC_INDEX_CHECK)
00247                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00248 #else
00249         throw();
00250 #endif
00251  template <class V,class VS> friend      V &_vvsplusassign(V &rv, const VS &sl)
00252 #if(CXSC_INDEX_CHECK)
00253                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00254 #else
00255         throw();
00256 #endif
00257  template <class VS,class V> friend      VS &_vsvplusassign(VS &sl, const V &rv)
00258 #if(CXSC_INDEX_CHECK)
00259                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00260 #else
00261         throw();
00262 #endif
00263  template <class VS1,class VS2> friend   VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
00264 #if(CXSC_INDEX_CHECK)
00265                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00266 #else
00267         throw();
00268 #endif
00269  template <class VS1,class VS2> friend   VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
00270 #if(CXSC_INDEX_CHECK)
00271                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00272 #else
00273         throw();
00274 #endif
00275  template <class V1,class V2> friend     V1 &_vvminusassign(V1 &rv1, const V2 &rv2)
00276 #if(CXSC_INDEX_CHECK)
00277                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00278 #else
00279         throw();
00280 #endif
00281  template <class V,class VS> friend      V &_vvsminusassign(V &rv, const VS &sl)
00282 #if(CXSC_INDEX_CHECK)
00283                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00284 #else
00285         throw();
00286 #endif
00287  template <class VS,class V> friend      VS &_vsvminusassign(VS &sl, const V &rv)
00288 #if(CXSC_INDEX_CHECK)
00289                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00290 #else
00291         throw();
00292 #endif
00293  template <class V> friend       V _vminus(const V &rv) throw();
00294  template <class VS,class V> friend      V _vsminus(const VS &sl) throw();
00295  template <class V1,class V2,class E> friend     E _vvminus(const V1 &rv1, const V2 &rv2)
00296 #if(CXSC_INDEX_CHECK)
00297                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00298 #else
00299         throw();
00300 #endif
00301  template <class V,class VS,class E> friend      E _vvsminus(const V &rv, const VS &sl)
00302 #if(CXSC_INDEX_CHECK)
00303                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00304 #else
00305         throw();
00306 #endif
00307  template <class VS,class V,class E> friend      E _vsvminus(const VS &sl,const V &rv)
00308 #if(CXSC_INDEX_CHECK)
00309                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00310 #else
00311         throw();
00312 #endif
00313  template <class V1,class V2,class E> friend     E _vvconv(const V1 &rv1, const V2 &rv2)
00314 #if(CXSC_INDEX_CHECK)
00315                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00316 #else
00317         throw();
00318 #endif
00319  template <class V,class VS,class E> friend      E _vvsconv(const V &rv,const VS &sl)
00320 #if(CXSC_INDEX_CHECK)
00321                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00322 #else
00323         throw();
00324 #endif
00325  template <class VS1,class VS2,class E> friend   E _vsvsconv(const VS1 &s1,const VS2 &s2)
00326 #if(CXSC_INDEX_CHECK)
00327                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00328 #else
00329         throw();
00330 #endif
00331  template <class V1,class V2> friend     V1 &_vvconvassign(V1 &rv1, const V2 &rv2)
00332 #if(CXSC_INDEX_CHECK)
00333                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00334 #else
00335         throw();
00336 #endif
00337  template <class V,class VS> friend      V &_vvsconvassign(V &rv, const VS &sl)
00338 #if(CXSC_INDEX_CHECK)
00339                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00340 #else
00341         throw();
00342 #endif
00343  template <class VS,class V> friend      VS &_vsvconvassign(VS &sl, const V &rv)
00344 #if(CXSC_INDEX_CHECK)
00345                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00346 #else
00347         throw();
00348 #endif
00349  template <class VS1,class VS2> friend   VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2)
00350 #if(CXSC_INDEX_CHECK)
00351                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00352 #else
00353         throw();
00354 #endif
00355  template <class V1,class V2,class E> friend     E _vvsect(const V1 &rv1, const V2 &rv2)
00356 #if(CXSC_INDEX_CHECK)
00357                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00358 #else
00359         throw();
00360 #endif
00361  template <class V,class VS,class E> friend      E _vvssect(const V &rv,const VS &sl)
00362 #if(CXSC_INDEX_CHECK)
00363                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00364 #else
00365         throw();
00366 #endif
00367  template <class VS1,class VS2,class E> friend   E _vsvssect(const VS1 &s1,const VS2 &s2)
00368 #if(CXSC_INDEX_CHECK)
00369                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00370 #else
00371         throw();
00372 #endif
00373  template <class V1,class V2> friend     V1 &_vvsectassign(V1 &rv1, const V2 &rv2)
00374 #if(CXSC_INDEX_CHECK)
00375                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
00376 #else
00377         throw();
00378 #endif
00379  template <class V,class VS> friend      V &_vvssectassign(V &rv, const VS &sl)
00380 #if(CXSC_INDEX_CHECK)
00381                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00382 #else
00383         throw();
00384 #endif
00385  template <class VS,class V> friend      VS &_vsvsectassign(VS &sl, const V &rv)
00386 #if(CXSC_INDEX_CHECK)
00387                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00388 #else
00389         throw();
00390 #endif
00391  template <class VS1,class VS2> friend   VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2)
00392 #if(CXSC_INDEX_CHECK)
00393                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00394 #else
00395         throw();
00396 #endif
00397  template <class MV1,class MV2,class E> friend   E _mvmvsect(const MV1 &rv1, const MV2 &rv2)
00398 #if(CXSC_INDEX_CHECK)
00399                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00400 #else
00401         throw();
00402 #endif
00403  template <class MV,class V,class E> friend      E _mvvsect(const MV &rv1, const V &rv2)
00404 #if(CXSC_INDEX_CHECK)
00405                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00406 #else
00407         throw();
00408 #endif
00409 template <class MV,class V> friend  MV &_mvvsectassign(MV &v,const V &rv)
00410 #if(CXSC_INDEX_CHECK)
00411         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00412 #else
00413         throw();
00414 #endif
00415 template <class V,class MV> friend  V &_vmvsectassign(V &rv,const MV &v)
00416 #if(CXSC_INDEX_CHECK)
00417         throw(ERROR__OP_WITH_WRONG_DIM<V>);
00418 #else
00419         throw();
00420 #endif
00421  template <class MV1,class MV2,class E> friend   E _mvmvconv(const MV1 &rv1, const MV2 &rv2)
00422 #if(CXSC_INDEX_CHECK)
00423                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00424 #else
00425         throw();
00426 #endif
00427  template <class MV,class V,class E> friend      E _mvvconv(const MV &rv1, const V &rv2)
00428 #if(CXSC_INDEX_CHECK)
00429                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00430 #else
00431         throw();
00432 #endif
00433 template <class MV,class V> friend  MV &_mvvconvassign(MV &v,const V &rv)
00434 #if(CXSC_INDEX_CHECK)
00435         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00436 #else
00437         throw();
00438 #endif
00439 template <class V,class MV> friend  V &_vmvconvassign(V &rv,const MV &v)
00440 #if(CXSC_INDEX_CHECK)
00441         throw(ERROR__OP_WITH_WRONG_DIM<V>);
00442 #else
00443         throw();
00444 #endif
00445  template <class V,class MV,class S> friend      S _vmvlimult(const V &rv1, const MV &rv2)
00446 #if(CXSC_INDEX_CHECK)
00447                 throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00448 #else
00449         throw();
00450 #endif
00451         //--------- vector-scalar -----------------
00452  template <class V,class S,class E> friend       E _vsdiv(const V &rv, const S &s) throw();
00453  template <class V,class S> friend       V &_vsdivassign(V &rv,const S &r) throw();
00454  template <class VS,class S,class E> friend      E _vssdiv(const VS &sl, const S &s) throw();
00455  template <class V,class S,class E> friend       E _vsmult(const V &rv, const S &s) throw();
00456  template <class VS,class S,class E> friend      E _vssmult(const VS &sl, const S &s) throw();
00457  template <class MV,class S,class E> friend      E _mvsmult(const MV &rv, const S &s) throw();
00458  template <class MV1,class MV2,class E> friend   E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
00459 #if(CXSC_INDEX_CHECK)
00460                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00461 #else
00462         throw();
00463 #endif
00464  template <class MV,class V,class E> friend      E _mvvplus(const MV &rv1, const V &rv2)
00465 #if(CXSC_INDEX_CHECK)
00466                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00467 #else
00468         throw();
00469 #endif
00470  template <class MV,class V,class E> friend      E _mvvminus(const MV &rv1, const V &rv2)
00471 #if(CXSC_INDEX_CHECK)
00472                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00473 #else
00474         throw();
00475 #endif
00476  template <class V,class MV,class E> friend      E _vmvminus(const V &rv1, const MV &rv2)
00477 #if(CXSC_INDEX_CHECK)
00478                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00479 #else
00480         throw();
00481 #endif
00482  template <class MV1,class MV2,class E> friend   E _mvmvminus(const MV1 &rv1, const MV2 &rv2)
00483 #if(CXSC_INDEX_CHECK)
00484                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
00485 #else
00486         throw();
00487 #endif
00488 template <class MV,class V> friend  MV &_mvvplusassign(MV &v,const V &rv)
00489 #if(CXSC_INDEX_CHECK)
00490         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00491 #else
00492         throw();
00493 #endif
00494 template <class MV,class V> friend  MV &_mvvminusassign(MV &v,const V &rv)
00495 #if(CXSC_INDEX_CHECK)
00496         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00497 #else
00498         throw();
00499 #endif
00500  template <class MV,class S,class E> friend      E _mvsdiv(const MV &rv, const S &s) throw();
00501 template <class MV,class V> friend  MV &_mvvassign(MV &v,const V &rv)
00502 #if(CXSC_INDEX_CHECK)
00503         throw(ERROR__OP_WITH_WRONG_DIM<MV>);
00504 #else
00505         throw();
00506 #endif
00507 
00508  template <class V1,class V2> friend     bool _vveq(const V1 &rv1, const V2 &rv2) throw();
00509  template <class VS,class V> friend      bool _vsveq(const VS &sl, const V &rv) throw();
00510  template <class V1,class V2> friend     bool _vvneq(const V1 &rv1, const V2 &rv2) throw();
00511  template <class VS,class V> friend      bool _vsvneq(const VS &sl, const V &rv) throw();
00512  template <class V1,class V2> friend     bool _vvless(const V1 &rv1, const V2 &rv2) throw();
00513  template <class VS,class V> friend      bool _vsvless(const VS &sl, const V &rv) throw();
00514  template <class V1,class V2> friend     bool _vvleq(const V1 &rv1, const V2 &rv2) throw();
00515  template <class VS,class V> friend      bool _vsvleq(const VS &sl, const V &rv) throw();
00516  template <class V,class VS> friend      bool _vvsless(const V &rv, const VS &sl) throw();
00517  template <class V,class VS> friend      bool _vvsleq(const V &rv, const VS &sl) throw();
00518  template <class V> friend       bool _vnot(const V &rv) throw();
00519  template <class V> friend       void *_vvoid(const V &rv) throw();
00520  template <class VS1,class VS2> friend   bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw();
00521  template <class VS1,class VS2> friend   bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw();
00522  template <class VS1,class VS2> friend   bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw();
00523  template <class VS1,class VS2> friend   bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw();
00524  template <class VS> friend      bool _vsnot(const VS &sl) throw();
00525  template <class VS> friend      void *_vsvoid(const VS &sl) throw();
00526  template <class V> friend      std::ostream &_vout(std::ostream &s, const V &rv) throw();
00527  template <class V> friend      std::istream &_vin(std::istream &s, V &rv) throw();
00528 
00529         //------------- vector-matrix ---------------
00530 template <class DP,class V,class SV> friend      void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
00531 #if(CXSC_INDEX_CHECK)
00532                 throw(OP_WITH_WRONG_DIM);
00533 #else
00534         throw();
00535 #endif
00536         
00537 template <class V,class MV2,class S> friend  V &_vmvassign(V &v,const MV2 &rv) throw();
00538  template <class M,class V,class E> friend       E _mvlimult(const M &m,const V &v)
00539 #if(CXSC_INDEX_CHECK)
00540                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00541 #else
00542         throw();
00543 #endif
00544  template <class V,class M,class E> friend       E _vmlimult(const V &v,const M &m)
00545 #if(CXSC_INDEX_CHECK)
00546                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00547 #else
00548         throw();
00549 #endif
00550  template <class V,class M,class S> friend       V &_vmimultassign(V &v,const M &m)
00551 #if(CXSC_INDEX_CHECK)
00552                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00553 #else
00554         throw();
00555 #endif
00556  template <class V,class M,class S> friend       V &_vmlimultassign(V &v,const M &m)
00557 #if(CXSC_INDEX_CHECK)
00558                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
00559 #else
00560         throw();
00561 #endif
00562  template <class MS,class V,class E> friend      E _msvlimult(const MS &ms,const V &v)
00563 #if(CXSC_INDEX_CHECK)
00564                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00565 #else
00566         throw();
00567 #endif
00568  template <class V,class MS,class E> friend      E _vmslimult(const V &v,const MS &ms)
00569 #if(CXSC_INDEX_CHECK)
00570                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00571 #else
00572         throw();
00573 #endif
00574  template <class V,class MS,class S> friend      V &_vmslimultassign(V &v,const MS &ms)
00575 #if(CXSC_INDEX_CHECK)
00576                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
00577 #else
00578         throw();
00579 #endif
00580 
00581         // Real
00582  template <class DP,class VS1,class VS2> friend          void _vsvsaccu(DP &dp, const VS1 & sl1, const VS2 &sl2)
00583 #if(CXSC_INDEX_CHECK)
00584                 throw(OP_WITH_WRONG_DIM);
00585 #else
00586         throw();
00587 #endif
00588 
00589         // l_rvector x ivector ----------------
00590         // vector - matrix ------------
00591   /*   friend TINLINE l_ivector _mvslimult<imatrix,l_rvector_slice,l_ivector>(const imatrix &m,const l_rvector_slice &v)
00592 #if(CXSC_INDEX_CHECK)
00593         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
00594 #else
00595         throw();
00596         #endif */
00597   /*   friend TINLINE l_ivector _vsmlimult<l_rvector_slice,imatrix,l_ivector>(const l_rvector_slice &v,const imatrix &m)
00598 #if(CXSC_INDEX_CHECK)
00599         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
00600 #else
00601         throw();
00602         #endif */
00603 
00604 
00605 #endif
00606         
00607 
00608         //------ Konstruktoren ----------------------------------------------------
00610         INLINE l_ivector () throw();
00612         explicit INLINE l_ivector(const int &i) throw();
00613 #ifdef OLD_CXSC
00614 
00615         explicit INLINE l_ivector(const class index &i) throw(); // for backwards compatibility
00616 #endif
00617 
00618         explicit INLINE l_ivector(const int &i1,const int &i2)
00619 #if(CXSC_INDEX_CHECK)
00620         throw(ERROR_LIVECTOR_WRONG_BOUNDARIES,ERROR_LIVECTOR_NO_MORE_MEMORY);
00621 #else
00622         throw();
00623 #endif
00624 
00625         INLINE l_ivector(const l_imatrix_subv &) throw();
00627         explicit INLINE l_ivector(const l_interval &) throw();
00629         explicit INLINE l_ivector(const l_imatrix &)
00630 #if(CXSC_INDEX_CHECK)
00631         throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00632 #else
00633         throw();
00634 #endif
00635 
00636         explicit INLINE l_ivector(const l_imatrix_slice &sl)
00637 #if(CXSC_INDEX_CHECK)
00638         throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00639 #else
00640         throw();
00641 #endif
00642 
00643         INLINE l_ivector(const l_ivector_slice &rs) throw();
00645         INLINE l_ivector(const l_ivector &v) throw();
00646         // Real
00648         explicit INLINE l_ivector(const real &) throw();
00650         explicit INLINE l_ivector(const rvector_slice &rs) throw();
00652         explicit INLINE l_ivector(const rvector &v) throw();
00654         explicit INLINE l_ivector(const rmatrix &)
00655 #if(CXSC_INDEX_CHECK)
00656         throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
00657 #else
00658         throw();
00659 #endif
00660 
00661         explicit INLINE l_ivector(const rmatrix_slice &sl)
00662 #if(CXSC_INDEX_CHECK)
00663         throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
00664 #else
00665         throw();
00666 #endif
00667 
00668         explicit INLINE l_ivector(const rmatrix_subv &) throw();
00669         
00670         // l_real
00672         explicit INLINE l_ivector(const l_real &) throw();
00674         explicit INLINE l_ivector(const l_rvector_slice &rs) throw();
00676         explicit INLINE l_ivector(const l_rvector &v) throw();
00678         explicit INLINE l_ivector(const l_rmatrix &)
00679 #if(CXSC_INDEX_CHECK)
00680         throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ);
00681 #else
00682         throw();
00683 #endif
00684 
00685         explicit INLINE l_ivector(const l_rmatrix_slice &sl)
00686 #if(CXSC_INDEX_CHECK)
00687         throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ);
00688 #else
00689         throw();
00690 #endif
00691 
00692         explicit INLINE l_ivector(const l_rmatrix_subv &) throw();
00693         
00694         // interval
00696         explicit INLINE l_ivector(const interval &) throw();
00698         explicit INLINE l_ivector(const ivector_slice &rs) throw();
00700         explicit INLINE l_ivector(const ivector &v) throw();
00702         explicit INLINE l_ivector(const imatrix &)
00703 #if(CXSC_INDEX_CHECK)
00704         throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
00705 #else
00706         throw();
00707 #endif
00708 
00709         explicit INLINE l_ivector(const imatrix_slice &sl)
00710 #if(CXSC_INDEX_CHECK)
00711         throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
00712 #else
00713         throw();
00714 #endif
00715 
00716         explicit INLINE l_ivector(const imatrix_subv &) throw();
00717         
00718         // l_interval
00720         INLINE l_ivector &operator =(const l_ivector &rv) throw();
00722         INLINE l_ivector &operator =(const l_ivector_slice &sl) throw();
00724         INLINE l_ivector &operator =(const l_interval &r) throw();
00726         INLINE l_ivector &operator =(const l_imatrix &m)
00727 #if(CXSC_INDEX_CHECK)
00728         throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00729 #else
00730         throw();
00731 #endif
00732 
00733         INLINE l_ivector &operator =(const l_imatrix_slice &)
00734 #if(CXSC_INDEX_CHECK)
00735         throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
00736 #else
00737         throw();
00738 #endif
00739 
00740         INLINE l_ivector &operator =(const l_imatrix_subv &) throw();
00741         // Real
00743         INLINE l_ivector &operator =(const rvector &rv) throw();
00745         INLINE l_ivector &operator =(const rvector_slice &sl) throw();
00747         INLINE l_ivector &operator =(const real &r) throw();
00749         INLINE l_ivector &operator =(const rmatrix &m)
00750 #if(CXSC_INDEX_CHECK)
00751         throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
00752 #else
00753         throw();
00754 #endif
00755 
00756         INLINE l_ivector &operator =(const rmatrix_slice &)
00757 #if(CXSC_INDEX_CHECK)
00758         throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
00759 #else
00760         throw();
00761 #endif
00762 
00763         INLINE l_ivector &operator =(const rmatrix_subv &) throw();
00764 
00765         // l_real
00767         INLINE l_ivector &operator =(const l_rvector &rv) throw();
00769         INLINE l_ivector &operator =(const l_rvector_slice &sl) throw();
00771         INLINE l_ivector &operator =(const l_real &r) throw();
00773         INLINE l_ivector &operator =(const l_rmatrix &m)
00774 #if(CXSC_INDEX_CHECK)
00775         throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ);
00776 #else
00777         throw();
00778 #endif
00779 
00780         INLINE l_ivector &operator =(const l_rmatrix_slice &)
00781 #if(CXSC_INDEX_CHECK)
00782         throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ);
00783 #else
00784         throw();
00785 #endif
00786 
00787         INLINE l_ivector &operator =(const l_rmatrix_subv &) throw();
00788 
00789         // interval
00791         INLINE l_ivector &operator =(const ivector &rv) throw();
00793         INLINE l_ivector &operator =(const ivector_slice &sl) throw();
00795         INLINE l_ivector &operator =(const interval &r) throw();
00797         INLINE l_ivector &operator =(const imatrix &m)
00798 #if(CXSC_INDEX_CHECK)
00799         throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
00800 #else
00801         throw();
00802 #endif
00803 
00804         INLINE l_ivector &operator =(const imatrix_slice &)
00805 #if(CXSC_INDEX_CHECK)
00806         throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
00807 #else
00808         throw();
00809 #endif
00810 
00811         INLINE l_ivector &operator =(const imatrix_subv &) throw();
00812 
00813         //--------- Destruktor ----------------------------------------------------
00814         INLINE ~l_ivector() { delete [] dat; }
00815 
00816         //------ Standardfunktionen -----------------------------------------------
00817         
00818         friend INLINE l_interval::l_interval(const l_ivector &)
00819 #if(CXSC_INDEX_CHECK)
00820         throw(ERROR_LIVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_LIVECTOR_USE_OF_UNINITIALIZED_OBJ);
00821 #else
00822         throw();
00823 #endif
00824 
00825         friend INLINE int Lb(const l_ivector &rv) throw() { return rv.l; }
00827         friend INLINE int Ub(const l_ivector &rv) throw() { return rv.u; }
00829         friend INLINE int VecLen(const l_ivector &rv) throw() { return rv.size; }
00831         friend INLINE l_ivector & SetLb(l_ivector &rv, const int &l) throw() { rv.l=l; rv.u=l+rv.size-1; return rv;}
00833         friend INLINE l_ivector & SetUb(l_ivector &rv, const int &u) throw() { rv.u=u; rv.l=u-rv.size+1; return rv;}
00835         INLINE l_interval & operator [](const int &i) const
00836 #if(CXSC_INDEX_CHECK)
00837         throw(ERROR_LIVECTOR_ELEMENT_NOT_IN_VEC);
00838 #else
00839         throw();
00840 #endif
00841 
00842         INLINE l_ivector & operator ()() throw() { return *this; }
00844         INLINE l_ivector_slice operator ()(const int &i)
00845 #if(CXSC_INDEX_CHECK)
00846         throw(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG);
00847 #else
00848         throw();
00849 #endif
00850 
00851         INLINE l_ivector_slice operator ()(const int &i1,const int &i2)
00852 #if(CXSC_INDEX_CHECK)
00853         throw(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG);
00854 #else
00855         throw();
00856 #endif
00857         
00858         INLINE operator void*() throw();
00859 //#else
00860 //#endif
00861 };
00862 
00863 
00865 
00870 class l_ivector_slice
00871 {
00872         friend class l_ivector;
00873         friend class l_imatrix;
00874         private:
00875         l_interval *dat;
00876         int l,u,size;
00877         int start,end;
00878 
00879         public:
00880 //#if(CXSC_INDEX_CHECK) 
00881 #ifdef _CXSC_FRIEND_TPL
00882 //------------------------- Templates -------------------------------------------
00883 // l_interval / l_interval
00884 
00885  template <class VS1,class VS2> friend   VS1 & _vsvsassign(VS1 &sl1,const VS2 &sl2)
00886 #if(CXSC_INDEX_CHECK)
00887                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00888 #else
00889         throw();
00890 #endif
00891  template <class V,class VS,class S> friend      V & _vvsassign(V &rv,const VS &sl) throw();
00892  template <class VS,class V> friend      VS & _vsvassign(VS &sl,const V &rv)
00893 #if(CXSC_INDEX_CHECK)
00894                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00895 #else
00896         throw();
00897 #endif
00898  template <class VS,class S> friend      VS & _vssassign(VS &sl,const S &r) throw();
00899  template <class VS,class V> friend      VS &_vsvsetinf(VS &sl, const V &rv)
00900 #if(CXSC_INDEX_CHECK)
00901                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00902 #else
00903         throw();
00904 #endif
00905  template <class VS,class V> friend      VS &_vsvsetsup(VS &sl, const V &rv)
00906 #if(CXSC_INDEX_CHECK)
00907                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00908 #else
00909         throw();
00910 #endif
00911  template <class VS1,class VS2> friend   VS1 &_vsvssetinf(VS1 &sl1, const VS2 &sl2)
00912 #if(CXSC_INDEX_CHECK)
00913                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00914 #else
00915         throw();
00916 #endif
00917  template <class VS1,class VS2> friend   VS1 &_vsvssetsup(VS1 &sl1, const VS2 &sl2)
00918 #if(CXSC_INDEX_CHECK)
00919                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00920 #else
00921         throw();
00922 #endif
00923  template <class VS,class V> friend      VS &_vsvusetinf(VS &sl, const V &rv)
00924 #if(CXSC_INDEX_CHECK)
00925                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00926 #else
00927         throw();
00928 #endif
00929  template <class VS,class V> friend      VS &_vsvusetsup(VS &sl, const V &rv)
00930 #if(CXSC_INDEX_CHECK)
00931                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
00932 #else
00933         throw();
00934 #endif
00935  template <class VS1,class VS2> friend   VS1 &_vsvsusetinf(VS1 &sl1, const VS2 &sl2)
00936 #if(CXSC_INDEX_CHECK)
00937                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00938 #else
00939         throw();
00940 #endif
00941  template <class VS1,class VS2> friend   VS1 &_vsvsusetsup(VS1 &sl1, const VS2 &sl2)
00942 #if(CXSC_INDEX_CHECK)
00943                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00944 #else
00945         throw();
00946 #endif
00947 
00948  template <class VS,class E> friend      E _vsabs(const VS &sl) throw();
00949  template <class VS,class E> friend      E _vsdiam(const VS &sl) throw();
00950  template <class VS,class E> friend      E _vsmid(const VS &sl) throw();
00951  template <class VS,class E> friend      E _vsinf(const VS &sl) throw();
00952  template <class VS,class E> friend      E _vssup(const VS &sl) throw();
00953  template <class VS,class S> friend      VS &_vsssetinf(VS &vs, const S &s) throw();
00954  template <class VS,class S> friend      VS &_vsssetsup(VS &vs, const S &s) throw();
00955  template <class VS,class S> friend      VS &_vssusetinf(VS &vs, const S &s) throw();
00956  template <class VS,class S> friend      VS &_vssusetsup(VS &vs, const S &s) throw();
00957 
00958  template <class DP,class VS,class V> friend     void _vsvaccu(DP &dp, const VS & sl, const V &rv)
00959 #if(CXSC_INDEX_CHECK)
00960                 throw(OP_WITH_WRONG_DIM);
00961 #else
00962         throw();
00963 #endif
00964  template <class DP,class VS1,class VS2> friend          void _vsvsaccu(DP &dp, const VS1 & sl1, const VS2 &sl2)
00965 #if(CXSC_INDEX_CHECK)
00966                 throw(OP_WITH_WRONG_DIM);
00967 #else
00968         throw();
00969 #endif
00970         
00971  template <class VS,class S,class E> friend      E _vssdiv(const VS &sl, const S &s) throw();
00972  template <class VS,class S,class E> friend      E _vssmult(const VS &sl, const S &s) throw();
00973  template <class VS,class V,class E> friend      E _vsvlimult(const VS & sl, const V &rv)
00974 #if(CXSC_INDEX_CHECK)
00975                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00976 #else
00977         throw();
00978 #endif
00979  template <class VS,class S> friend      VS &_vssmultassign(VS &rv,const S &r) throw();
00980  template <class VS,class S> friend      VS &_vssdivassign(VS &rv,const S &r) throw();
00981  template <class V,class VS,class E> friend      E _vvsplus(const V &rv,const VS &sl)
00982 #if(CXSC_INDEX_CHECK)
00983                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
00984 #else
00985         throw();
00986 #endif
00987  template <class VS1,class VS2,class E> friend   E _vsvsplus(const VS1 &s1,const VS2 &s2)
00988 #if(CXSC_INDEX_CHECK)
00989                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00990 #else
00991         throw();
00992 #endif
00993  template <class VS1,class VS2,class E> friend   E _vsvsminus(const VS1 &s1,const VS2 &s2)
00994 #if(CXSC_INDEX_CHECK)
00995                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
00996 #else
00997         throw();
00998 #endif
00999  template <class V,class VS> friend      V &_vvsplusassign(V &rv, const VS &sl)
01000 #if(CXSC_INDEX_CHECK)
01001                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01002 #else
01003         throw();
01004 #endif
01005  template <class VS,class V> friend      VS &_vsvplusassign(VS &sl, const V &rv)
01006 #if(CXSC_INDEX_CHECK)
01007                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01008 #else
01009         throw();
01010 #endif
01011  template <class VS1,class VS2> friend   VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
01012 #if(CXSC_INDEX_CHECK)
01013                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01014 #else
01015         throw();
01016 #endif
01017  template <class VS1,class VS2> friend   VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
01018 #if(CXSC_INDEX_CHECK)
01019                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01020 #else
01021         throw();
01022 #endif
01023  template <class V,class VS> friend      V &_vvsminusassign(V &rv, const VS &sl)
01024 #if(CXSC_INDEX_CHECK)
01025                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01026 #else
01027         throw();
01028 #endif
01029  template <class VS,class V> friend      VS &_vsvminusassign(VS &sl, const V &rv)
01030 #if(CXSC_INDEX_CHECK)
01031                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01032 #else
01033         throw();
01034 #endif
01035  template <class VS,class V> friend      V _vsminus(const VS &sl) throw();
01036  template <class V,class VS,class E> friend      E _vvsminus(const V &rv, const VS &sl)
01037 #if(CXSC_INDEX_CHECK)
01038                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01039 #else
01040         throw();
01041 #endif
01042  template <class VS,class V,class E> friend      E _vsvminus(const VS &sl,const V &rv)
01043 #if(CXSC_INDEX_CHECK)
01044                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01045 #else
01046         throw();
01047 #endif
01048  template <class V,class VS,class E> friend      E _vvssect(const V &rv,const VS &sl)
01049 #if(CXSC_INDEX_CHECK)
01050                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01051 #else
01052         throw();
01053 #endif
01054  template <class VS1,class VS2,class E> friend   E _vsvssect(const VS1 &s1,const VS2 &s2)
01055 #if(CXSC_INDEX_CHECK)
01056                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01057 #else
01058         throw();
01059 #endif
01060  template <class V,class VS> friend      V &_vvssectassign(V &rv, const VS &sl)
01061 #if(CXSC_INDEX_CHECK)
01062                 throw(ERROR__OP_WITH_WRONG_DIM<V>);
01063 #else
01064         throw();
01065 #endif
01066  template <class VS,class V> friend      VS &_vsvsectassign(VS &sl, const V &rv)
01067 #if(CXSC_INDEX_CHECK)
01068                 throw(ERROR__OP_WITH_WRONG_DIM<VS>);
01069 #else
01070         throw();
01071 #endif
01072  template <class VS1,class VS2> friend   VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2)
01073 #if(CXSC_INDEX_CHECK)
01074                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01075 #else
01076         throw();
01077 #endif
01078  template <class V,class VS,class E> friend      E _vvsconv(const V &rv,const VS &sl)
01079 #if(CXSC_INDEX_CHECK)
01080                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01081 #else
01082         throw();
01083 #endif
01084  template <class VS1,class VS2,class E> friend   E _vsvsconv(const VS1 &s1,const VS2 &s2)
01085 #if(CXSC_INDEX_CHECK)
01086                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01087 #else
01088         throw();
01089 #endif
01090  template <class V,class VS> friend      V &_vvsconvassign(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 &_vsvconvassign(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 &_vsvsconvassign(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 VS,class M,class S> friend      VS &_vsmlimultassign(VS &v,const M &m)
01109 #if(CXSC_INDEX_CHECK)
01110                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01111 #else
01112         throw();
01113 #endif
01114 
01115  template <class VS,class V> friend      bool _vsveq(const VS &sl, const V &rv) throw();
01116  template <class VS,class V> friend      bool _vsvneq(const VS &sl, const V &rv) throw();
01117  template <class VS,class V> friend      bool _vsvless(const VS &sl, const V &rv) throw();
01118  template <class VS,class V> friend      bool _vsvleq(const VS &sl, const V &rv) throw();
01119  template <class V,class VS> friend      bool _vvsless(const V &rv, const VS &sl) throw();
01120  template <class V,class VS> friend      bool _vvsleq(const V &rv, const VS &sl) throw();
01121  template <class VS1,class VS2,class E> friend   E _vsvslimult(const VS1 & sl1, const VS2 &sl2)
01122 #if(CXSC_INDEX_CHECK)
01123                 throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
01124 #else
01125         throw();
01126 #endif
01127  template <class VS1,class VS2> friend   bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw();
01128  template <class VS1,class VS2> friend   bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw();
01129  template <class VS1,class VS2> friend   bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw();
01130  template <class VS1,class VS2> friend   bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw();
01131  template <class VS> friend      bool _vsnot(const VS &sl) throw();
01132  template <class VS> friend      void *_vsvoid(const VS &sl) throw();
01133  template <class V> friend      std::ostream &_vsout(std::ostream &s, const V &rv) throw();
01134  template <class V> friend      std::istream &_vsin(std::istream &s, V &rv) throw();
01135         
01136         // l_interval / Real
01137  template <class V,class MS,class E> friend      E _vmslimult(const V &v,const MS &ms)
01138 #if(CXSC_INDEX_CHECK)
01139                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01140 #else
01141         throw();
01142 #endif
01143         // l_interval / l_real
01144          template <class DP,class V1,class V2> friend    void _vvaccu(DP &dp, const V1 & rv1, const V2 &rv2)
01145 #if(CXSC_INDEX_CHECK)
01146                 throw(OP_WITH_WRONG_DIM);
01147 #else
01148         throw();
01149 #endif
01150 
01151         // l_real
01152  template <class V1,class V2,class S> friend     V1 &_vvassign(V1 &rv1,const V2 &rv2) throw();
01153  template <class V,class S> friend       V & _vsassign(V &rv,const S &r) throw();
01154 
01155 template <class V,class M,class S> friend  V &_vmassign(V &v,const M &m)
01156 #if(CXSC_INDEX_CHECK)
01157         throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
01158 #else
01159         throw();
01160 #endif
01161 template <class M,class V,class S> friend  M &_mvassign(M &m,const V &v) throw();
01162 template <class V,class MV2,class S> friend  V &_vmvassign(V &v,const MV2 &rv) throw();
01163 
01164  template <class V1,class V2,class E> friend     E _vvconv(const V1 &rv1, const V2 &rv2)
01165 #if(CXSC_INDEX_CHECK)
01166                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01167 #else
01168         throw();
01169 #endif
01170 
01171         //--l_real -------- vector-scalar ------------
01172  template <class MV,class S,class E> friend      E _mvsmult(const MV &rv, const S &s) throw();
01173  template <class V,class S,class E> friend       E _vsmult(const V &rv, const S &s) throw();
01174  template <class V,class S,class E> friend       E _vsdiv(const V &rv, const S &s) throw();
01175  template <class V,class S> friend       V &_vsdivassign(V &rv,const S &r) throw();
01176  template <class V,class S> friend       V &_vsmultassign(V &rv,const S &r) throw();
01177 
01178         //--l_real--------- Vector-vector---------
01179  template <class V1,class V2,class E> friend     E _vvlimult(const V1 & rv1, const V2 &rv2)
01180 #if(CXSC_INDEX_CHECK)
01181                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
01182 #else
01183         throw();
01184 #endif
01185  template <class V1,class V2,class E> friend     E _vvplus(const V1 &rv1, const V2 &rv2)
01186 #if(CXSC_INDEX_CHECK)
01187                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
01188 #else
01189         throw();
01190 #endif
01191  template <class V1,class V2> friend     V1 &_vvplusassign(V1 &rv1, const V2 &rv2)
01192 #if(CXSC_INDEX_CHECK)
01193                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
01194 #else
01195         throw();
01196 #endif
01197  template <class V1,class V2> friend     V1 &_vvminusassign(V1 &rv1, const V2 &rv2)
01198 #if(CXSC_INDEX_CHECK)
01199                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
01200 #else
01201         throw();
01202 #endif
01203  template <class V1,class V2,class E> friend     E _vvminus(const V1 &rv1, const V2 &rv2)
01204 #if(CXSC_INDEX_CHECK)
01205                 throw(ERROR__OP_WITH_WRONG_DIM<E>);
01206 #else
01207         throw();
01208 #endif
01209  template <class V1,class V2> friend     V1 &_vvconvassign(V1 &rv1, const V2 &rv2)
01210 #if(CXSC_INDEX_CHECK)
01211                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
01212 #else
01213         throw();
01214 #endif
01215  template <class V1,class V2,class E> friend     E _vvsect(const V1 &rv1, const V2 &rv2)
01216 #if(CXSC_INDEX_CHECK)
01217                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
01218 #else
01219         throw();
01220 #endif
01221  template <class V1,class V2> friend     V1 &_vvsectassign(V1 &rv1, const V2 &rv2)
01222 #if(CXSC_INDEX_CHECK)
01223                 throw(ERROR__OP_WITH_WRONG_DIM<V1>);
01224 #else
01225         throw();
01226 #endif
01227         
01228         //-- l_real -------- Vector-matrix ----------
01229 template <class V,class MS,class S> friend  void _vmsconstr(V &v,const MS &m)
01230 #if(CXSC_INDEX_CHECK)
01231         throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>);
01232 #else
01233         throw();
01234 #endif
01235 template <class V,class M,class S> friend  void _vmconstr(V &v,const M &m)
01236 #if(CXSC_INDEX_CHECK)
01237         throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
01238 #else
01239         throw();
01240 #endif
01241  template <class M,class V,class E> friend       E _mvlimult(const M &m,const V &v)
01242 #if(CXSC_INDEX_CHECK)
01243                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01244 #else
01245         throw();
01246 #endif
01247  template <class MS,class V,class E> friend      E _msvlimult(const MS &ms,const V &v)
01248 #if(CXSC_INDEX_CHECK)
01249                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01250 #else
01251         throw();
01252 #endif
01253  template <class V,class M,class E> friend       E _vmlimult(const V &v,const M &m)
01254 #if(CXSC_INDEX_CHECK)
01255                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01256 #else
01257         throw();
01258 #endif
01259  template <class V,class MS,class S> friend      V &_vmslimultassign(V &v,const MS &ms)
01260 #if(CXSC_INDEX_CHECK)
01261                 throw(ERROR__OP_WITH_WRONG_DIM<MS>);
01262 #else
01263         throw();
01264 #endif
01265  template <class V,class M,class S> friend       V &_vmlimultassign(V &v,const M &m)
01266 #if(CXSC_INDEX_CHECK)
01267                 throw(ERROR__OP_WITH_WRONG_DIM<M>);
01268 #else
01269         throw();
01270 #endif
01271 
01272   /*    friend TINLINE l_ivector &_vsmassign<l_ivector_slice,imatrix,l_interval>(l_ivector_slice &v,const imatrix &m)
01273 #if(CXSC_INDEX_CHECK)
01274         throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
01275 #else
01276         throw();
01277         #endif */
01278 
01279         //-- interval -------- Vector-matrix ----------
01280   /*   friend TINLINE l_ivector _mvslimult<imatrix,l_ivector_slice,l_ivector>(const imatrix &m,const l_ivector_slice &v)
01281 #if(CXSC_INDEX_CHECK)
01282         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01283 #else
01284         throw();
01285         #endif */
01286   /*   friend TINLINE l_ivector _msvslimult<imatrix_slice,l_ivector_slice,l_ivector>(const imatrix_slice &ms,const l_ivector_slice &v)
01287 #if(CXSC_INDEX_CHECK)
01288         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01289 #else
01290         throw();
01291         #endif */
01292   /*   friend TINLINE l_ivector _vsmlimult<l_ivector_slice,imatrix,l_ivector>(const l_ivector_slice &v,const imatrix &m)
01293 #if(CXSC_INDEX_CHECK)
01294         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01295 #else
01296         throw();
01297         #endif */
01298   /*   friend TINLINE l_ivector _vsmslimult<l_ivector_slice,imatrix_slice,l_ivector>(const l_ivector_slice &v,const imatrix_slice &ms)
01299 #if(CXSC_INDEX_CHECK)
01300         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01301 #else
01302         throw();
01303         #endif */
01304   /*   friend TINLINE l_ivector &_vsmslimultassign<l_ivector_slice,imatrix_slice,l_interval>(l_ivector_slice &v,const imatrix_slice &m)
01305 #if(CXSC_INDEX_CHECK)
01306         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01307 #else
01308         throw();
01309         #endif */
01310 
01311 #endif
01312         
01313         //--------------------- Konstruktoren -----------------------------------
01315         explicit INLINE l_ivector_slice(l_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) { }
01317         explicit INLINE l_ivector_slice(l_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) { }
01318         public: 
01320         INLINE l_ivector_slice(const l_ivector_slice &a) throw():dat(a.dat),l(a.l),u(a.u),size(a.size),start(a.start),end(a.end) { }
01321         public:
01322         // l_interval
01324         INLINE l_ivector_slice & operator =(const l_ivector_slice &sl)
01325 #if(CXSC_INDEX_CHECK)
01326         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01327 #else
01328         throw();
01329 #endif
01330 
01331         INLINE l_ivector_slice & operator =(const l_ivector &rv)
01332 #if(CXSC_INDEX_CHECK)
01333         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01334 #else
01335         throw();
01336 #endif
01337 
01338         INLINE l_ivector_slice & operator =(const l_interval &r) throw();
01340         INLINE l_ivector_slice & operator =(const l_imatrix &m)
01341 #if(CXSC_INDEX_CHECK)
01342         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>,ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
01343 #else
01344         throw();
01345 #endif
01346 
01347         INLINE l_ivector_slice & operator =(const l_imatrix_slice &m)
01348 #if(CXSC_INDEX_CHECK)
01349         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>,ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
01350 #else
01351         throw();
01352 #endif
01353 
01354         INLINE l_ivector_slice &operator =(const l_imatrix_subv &) throw();
01355         // Real
01357         INLINE l_ivector_slice & operator =(const rvector_slice &sl)
01358 #if(CXSC_INDEX_CHECK)
01359         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01360 #else
01361         throw();
01362 #endif
01363 
01364         INLINE l_ivector_slice & operator =(const rvector &rv)
01365 #if(CXSC_INDEX_CHECK)
01366         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01367 #else
01368         throw();
01369 #endif
01370 
01371         INLINE l_ivector_slice & operator =(const real &r) throw();
01373         INLINE l_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 l_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 l_ivector_slice &operator =(const rmatrix_subv &mv) throw();
01388 
01389         // l_real
01391         INLINE l_ivector_slice & operator =(const l_rvector_slice &sl)
01392 #if(CXSC_INDEX_CHECK)
01393         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01394 #else
01395         throw();
01396 #endif
01397 
01398         INLINE l_ivector_slice & operator =(const l_rvector &rv)
01399 #if(CXSC_INDEX_CHECK)
01400         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01401 #else
01402         throw();
01403 #endif
01404 
01405         INLINE l_ivector_slice & operator =(const l_real &r) throw();
01407         INLINE l_ivector_slice & operator =(const l_rmatrix &m)
01408 #if(CXSC_INDEX_CHECK)
01409         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>,ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ);
01410 #else
01411         throw();
01412 #endif
01413 
01414         INLINE l_ivector_slice & operator =(const l_rmatrix_slice &m)
01415 #if(CXSC_INDEX_CHECK)
01416         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>,ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ);
01417 #else
01418         throw();
01419 #endif
01420 
01421         INLINE l_ivector_slice &operator =(const l_rmatrix_subv &mv) throw();
01422 
01423         // interval
01425         INLINE l_ivector_slice & operator =(const ivector_slice &sl)
01426 #if(CXSC_INDEX_CHECK)
01427         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01428 #else
01429         throw();
01430 #endif
01431 
01432         INLINE l_ivector_slice & operator =(const ivector &rv)
01433 #if(CXSC_INDEX_CHECK)
01434         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01435 #else
01436         throw();
01437 #endif
01438 
01439         INLINE l_ivector_slice & operator =(const interval &r) throw();
01441         INLINE l_ivector_slice & operator =(const imatrix &m)
01442 #if(CXSC_INDEX_CHECK)
01443         throw(ERROR__OP_WITH_WRONG_DIM<ivector>,ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
01444 #else
01445         throw();
01446 #endif
01447 
01448         INLINE l_ivector_slice & operator =(const imatrix_slice &m)
01449 #if(CXSC_INDEX_CHECK)
01450         throw(ERROR__OP_WITH_WRONG_DIM<ivector>,ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
01451 #else
01452         throw();
01453 #endif
01454 
01455         INLINE l_ivector_slice &operator =(const imatrix_subv &mv) throw();
01456 
01457         //--------------------- Standardfunktionen ------------------------------
01458 
01459         friend INLINE l_interval::l_interval(const l_ivector_slice &sl)
01460 #if(CXSC_INDEX_CHECK)
01461         throw(ERROR_LIVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_LIVECTOR_USE_OF_UNINITIALIZED_OBJ);
01462 #else
01463         throw();
01464 #endif
01465 
01466         friend INLINE int Lb(const l_ivector_slice &sl) throw() { return sl.start; }
01468         friend INLINE int Ub(const l_ivector_slice &sl) throw() { return sl.end; }
01470         friend INLINE int VecLen(const l_ivector_slice &sl) throw() { return sl.end-sl.start+1; }
01472         INLINE l_interval & operator [](const int &i) const
01473 #if(CXSC_INDEX_CHECK)
01474         throw(ERROR_LIVECTOR_ELEMENT_NOT_IN_VEC);
01475 #else
01476         throw();
01477 #endif
01478 
01479         INLINE l_ivector_slice & operator ()() throw() { return *this; }
01481         INLINE l_ivector_slice operator ()(const int &i)
01482 #if(CXSC_INDEX_CHECK)
01483         throw(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG);
01484 #else
01485         throw();
01486 #endif
01487 
01488         INLINE l_ivector_slice operator ()(const int &i1,const int &i2)
01489 #if(CXSC_INDEX_CHECK)
01490         throw(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG);
01491 #else
01492         throw();
01493 #endif
01494         INLINE operator void*() throw();
01495         
01497         INLINE l_ivector_slice &operator *=(const l_interval &r) throw();
01499         INLINE l_ivector_slice &operator /=(const l_interval &r) throw();
01501         INLINE l_ivector_slice &operator *=(const l_imatrix &m)
01502 #if(CXSC_INDEX_CHECK)
01503         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01504 #else
01505         throw();
01506 #endif
01507 
01508         INLINE l_ivector_slice &operator *=(const l_imatrix_slice &m)
01509 #if(CXSC_INDEX_CHECK)
01510         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
01511 #else
01512         throw();
01513 #endif
01514 
01515         INLINE l_ivector_slice &operator +=(const l_ivector &rv)
01516 #if(CXSC_INDEX_CHECK)
01517         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01518 #else
01519         throw();
01520 #endif
01521 
01522         INLINE l_ivector_slice &operator +=(const l_ivector_slice &sl2)
01523 #if(CXSC_INDEX_CHECK)
01524         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01525 #else
01526         throw();
01527 #endif
01528 
01529         INLINE l_ivector_slice &operator -=(const l_ivector &rv)
01530 #if(CXSC_INDEX_CHECK)
01531         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01532 #else
01533         throw();
01534 #endif
01535 
01536         INLINE l_ivector_slice &operator -=(const l_ivector_slice &sl2)
01537 #if(CXSC_INDEX_CHECK)
01538         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01539 #else
01540         throw();
01541 #endif
01542 
01543         INLINE l_ivector_slice &operator |=(const l_ivector &rv)
01544 #if(CXSC_INDEX_CHECK)
01545         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01546 #else
01547         throw();
01548 #endif
01549 
01550         INLINE l_ivector_slice &operator |=(const l_ivector_slice &sl2)
01551 #if(CXSC_INDEX_CHECK)
01552         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01553 #else
01554         throw();
01555 #endif
01556 
01557         INLINE l_ivector_slice &operator &=(const l_ivector &rv)
01558 #if(CXSC_INDEX_CHECK)
01559         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01560 #else
01561         throw();
01562 #endif
01563 
01564         INLINE l_ivector_slice &operator &=(const l_ivector_slice &sl2)
01565 #if(CXSC_INDEX_CHECK)
01566         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01567 #else
01568         throw();
01569 #endif
01570         
01572         INLINE l_ivector_slice &operator *=(const real &r) throw();
01574         INLINE l_ivector_slice &operator /=(const real &r) throw();
01576         INLINE l_ivector_slice &operator +=(const rvector &rv)
01577 #if(CXSC_INDEX_CHECK)
01578         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01579 #else
01580         throw();
01581 #endif
01582 
01583         INLINE l_ivector_slice &operator +=(const rvector_slice &sl2)
01584 #if(CXSC_INDEX_CHECK)
01585         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01586 #else
01587         throw();
01588 #endif
01589 
01590         INLINE l_ivector_slice &operator -=(const rvector &rv)
01591 #if(CXSC_INDEX_CHECK)
01592         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01593 #else
01594         throw();
01595 #endif
01596 
01597         INLINE l_ivector_slice &operator -=(const rvector_slice &sl2)
01598 #if(CXSC_INDEX_CHECK)
01599         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01600 #else
01601         throw();
01602 #endif
01603 
01604         INLINE l_ivector_slice &operator |=(const rvector &rv)
01605 #if(CXSC_INDEX_CHECK)
01606         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01607 #else
01608         throw();
01609 #endif
01610 
01611         INLINE l_ivector_slice &operator |=(const rvector_slice &sl2)
01612 #if(CXSC_INDEX_CHECK)
01613         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01614 #else
01615         throw();
01616 #endif
01617 
01618         INLINE l_ivector_slice &operator &=(const rvector &rv)
01619 #if(CXSC_INDEX_CHECK)
01620         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01621 #else
01622         throw();
01623 #endif
01624 
01625         INLINE l_ivector_slice &operator &=(const rvector_slice &sl2)
01626 #if(CXSC_INDEX_CHECK)
01627         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01628 #else
01629         throw();
01630 #endif
01631 
01632         INLINE l_ivector_slice &operator *=(const rmatrix &m)
01633 #if(CXSC_INDEX_CHECK)
01634         throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
01635 #else
01636         throw();
01637 #endif
01638 
01639         INLINE l_ivector_slice &operator *=(const rmatrix_slice &m)
01640 #if(CXSC_INDEX_CHECK)
01641         throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
01642 #else
01643         throw();
01644 #endif
01645 
01647         INLINE l_ivector_slice &operator *=(const l_real &r) throw();
01649         INLINE l_ivector_slice &operator /=(const l_real &r) throw();
01651         INLINE l_ivector_slice &operator +=(const l_rvector &rv)
01652 #if(CXSC_INDEX_CHECK)
01653         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01654 #else
01655         throw();
01656 #endif
01657 
01658         INLINE l_ivector_slice &operator +=(const l_rvector_slice &sl2)
01659 #if(CXSC_INDEX_CHECK)
01660         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01661 #else
01662         throw();
01663 #endif
01664 
01665         INLINE l_ivector_slice &operator -=(const l_rvector &rv)
01666 #if(CXSC_INDEX_CHECK)
01667         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01668 #else
01669         throw();
01670 #endif
01671 
01672         INLINE l_ivector_slice &operator -=(const l_rvector_slice &sl2)
01673 #if(CXSC_INDEX_CHECK)
01674         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01675 #else
01676         throw();
01677 #endif
01678 
01679         INLINE l_ivector_slice &operator |=(const l_rvector &rv)
01680 #if(CXSC_INDEX_CHECK)
01681         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01682 #else
01683         throw();
01684 #endif
01685 
01686         INLINE l_ivector_slice &operator |=(const l_rvector_slice &sl2)
01687 #if(CXSC_INDEX_CHECK)
01688         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01689 #else
01690         throw();
01691 #endif
01692 
01693         INLINE l_ivector_slice &operator &=(const l_rvector &rv)
01694 #if(CXSC_INDEX_CHECK)
01695         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01696 #else
01697         throw();
01698 #endif
01699 
01700         INLINE l_ivector_slice &operator &=(const l_rvector_slice &sl2)
01701 #if(CXSC_INDEX_CHECK)
01702         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01703 #else
01704         throw();
01705 #endif
01706 
01707         INLINE l_ivector_slice &operator *=(const l_rmatrix &m)
01708 #if(CXSC_INDEX_CHECK)
01709         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
01710 #else
01711         throw();
01712 #endif
01713 
01714         INLINE l_ivector_slice &operator *=(const l_rmatrix_slice &m)
01715 #if(CXSC_INDEX_CHECK)
01716         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
01717 #else
01718         throw();
01719 #endif
01720 
01722         INLINE l_ivector_slice &operator *=(const interval &r) throw();
01724         INLINE l_ivector_slice &operator /=(const interval &r) throw();
01726         INLINE l_ivector_slice &operator +=(const ivector &rv)
01727 #if(CXSC_INDEX_CHECK)
01728         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01729 #else
01730         throw();
01731 #endif
01732 
01733         INLINE l_ivector_slice &operator +=(const ivector_slice &sl2)
01734 #if(CXSC_INDEX_CHECK)
01735         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01736 #else
01737         throw();
01738 #endif
01739 
01740         INLINE l_ivector_slice &operator -=(const ivector &rv)
01741 #if(CXSC_INDEX_CHECK)
01742         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01743 #else
01744         throw();
01745 #endif
01746 
01747         INLINE l_ivector_slice &operator -=(const ivector_slice &sl2)
01748 #if(CXSC_INDEX_CHECK)
01749         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01750 #else
01751         throw();
01752 #endif
01753 
01754         INLINE l_ivector_slice &operator |=(const ivector &rv)
01755 #if(CXSC_INDEX_CHECK)
01756         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01757 #else
01758         throw();
01759 #endif
01760 
01761         INLINE l_ivector_slice &operator |=(const ivector_slice &sl2)
01762 #if(CXSC_INDEX_CHECK)
01763         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01764 #else
01765         throw();
01766 #endif
01767 
01768         INLINE l_ivector_slice &operator &=(const ivector &rv)
01769 #if(CXSC_INDEX_CHECK)
01770         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01771 #else
01772         throw();
01773 #endif
01774 
01775         INLINE l_ivector_slice &operator &=(const ivector_slice &sl2)
01776 #if(CXSC_INDEX_CHECK)
01777         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
01778 #else
01779         throw();
01780 #endif
01781 
01782         INLINE l_ivector_slice &operator *=(const imatrix &m)
01783 #if(CXSC_INDEX_CHECK)
01784         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01785 #else
01786         throw();
01787 #endif
01788 
01789         INLINE l_ivector_slice &operator *=(const imatrix_slice &m)
01790 #if(CXSC_INDEX_CHECK)
01791         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
01792 #else
01793         throw();
01794 #endif
01795 //#else
01796 //#endif
01797 };
01798 
01799 //=======================================================================
01800 //======================== Vector Functions =============================
01801 
01803         INLINE l_ivector _l_ivector(const l_interval &r) throw();
01804 //      INLINE l_ivector _l_ivector(const l_imatrix &m) throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
01805 //      INLINE l_ivector _l_ivector(const l_imatrix_slice &sl) throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
01807         INLINE l_ivector _l_ivector(const real &r) throw();
01809         INLINE l_ivector _l_ivector(const rvector_slice &rs) throw();
01811         INLINE l_ivector _l_ivector(const rvector &rs) throw();
01812 //      INLINE l_ivector _l_ivector(const rmatrix &m) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
01813 //      INLINE l_ivector _l_ivector(const rmatrix_slice &sl) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
01815         INLINE l_ivector _l_ivector(const rmatrix_subv &rs) throw();
01816 
01818         INLINE l_ivector &SetInf(l_ivector &iv,const l_rvector &rv)
01819 #if(CXSC_INDEX_CHECK)
01820         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
01821 #else
01822         throw();
01823 #endif
01824 
01825         INLINE l_ivector_slice &SetInf(l_ivector_slice &iv,const l_rvector &rv)
01826 #if(CXSC_INDEX_CHECK)
01827         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
01828 #else
01829         throw();
01830 #endif
01831 
01832         INLINE l_ivector &SetInf(l_ivector &iv,const l_rvector_slice &rv)
01833 #if(CXSC_INDEX_CHECK)
01834         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
01835 #else
01836         throw();
01837 #endif
01838 
01839         INLINE l_ivector_slice &SetInf(l_ivector_slice &iv,const l_rvector_slice &rv)
01840 #if(CXSC_INDEX_CHECK)
01841         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
01842 #else
01843         throw();
01844 #endif
01845 
01846         INLINE l_ivector &UncheckedSetInf(l_ivector &iv,const l_rvector &rv)
01847 #if(CXSC_INDEX_CHECK)
01848         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
01849 #else
01850         throw();
01851 #endif
01852 
01853         INLINE l_ivector_slice &UncheckedSetInf(l_ivector_slice &iv,const l_rvector &rv)
01854 #if(CXSC_INDEX_CHECK)
01855         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
01856 #else
01857         throw();
01858 #endif
01859 
01860         INLINE l_ivector &UncheckedSetInf(l_ivector &iv,const l_rvector_slice &rv)
01861 #if(CXSC_INDEX_CHECK)
01862         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
01863 #else
01864         throw();
01865 #endif
01866 
01867         INLINE l_ivector_slice &UncheckedSetInf(l_ivector_slice &iv,const l_rvector_slice &rv)
01868 #if(CXSC_INDEX_CHECK)
01869         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
01870 #else
01871         throw();
01872 #endif
01873 
01875         INLINE l_ivector &SetSup(l_ivector &iv,const l_rvector &rv)
01876 #if(CXSC_INDEX_CHECK)
01877         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
01878 #else
01879         throw();
01880 #endif
01881 
01882         INLINE l_ivector_slice &SetSup(l_ivector_slice &iv,const l_rvector &rv)
01883 #if(CXSC_INDEX_CHECK)
01884         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
01885 #else
01886         throw();
01887 #endif
01888 
01889         INLINE l_ivector &SetSup(l_ivector &iv,const l_rvector_slice &rv)
01890 #if(CXSC_INDEX_CHECK)
01891         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
01892 #else
01893         throw();
01894 #endif
01895 
01896         INLINE l_ivector_slice &SetSup(l_ivector_slice &iv,const l_rvector_slice &rv)
01897 #if(CXSC_INDEX_CHECK)
01898         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
01899 #else
01900         throw();
01901 #endif
01902 
01903         INLINE l_ivector &UncheckedSetSup(l_ivector &iv,const l_rvector &rv)
01904 #if(CXSC_INDEX_CHECK)
01905         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
01906 #else
01907         throw();
01908 #endif
01909 
01910         INLINE l_ivector_slice &UncheckedSetSup(l_ivector_slice &iv,const l_rvector &rv)
01911 #if(CXSC_INDEX_CHECK)
01912         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
01913 #else
01914         throw();
01915 #endif
01916 
01917         INLINE l_ivector &UncheckedSetSup(l_ivector &iv,const l_rvector_slice &rv)
01918 #if(CXSC_INDEX_CHECK)
01919         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
01920 #else
01921         throw();
01922 #endif
01923 
01924         INLINE l_ivector_slice &UncheckedSetSup(l_ivector_slice &iv,const l_rvector_slice &rv)
01925 #if(CXSC_INDEX_CHECK)
01926         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
01927 #else
01928         throw();
01929 #endif
01930 
01932         INLINE l_ivector &SetSup(l_ivector &iv,const l_real &r) throw();
01934         INLINE l_ivector &SetInf(l_ivector &iv,const l_real &r) throw();
01936         INLINE l_ivector &UncheckedSetSup(l_ivector &iv,const l_real &r) throw();
01938         INLINE l_ivector &SetUncheckedInf(l_ivector &iv,const l_real &r) throw();
01939 
01941         INLINE l_ivector_slice &SetSup(l_ivector_slice &iv,const l_real &r) throw();
01943         INLINE l_ivector_slice &SetInf(l_ivector_slice &iv,const l_real &r) throw();
01945         INLINE l_ivector_slice &UncheckedSetSup(l_ivector_slice &iv,const l_real &r) throw();
01947         INLINE l_ivector_slice &SetUncheckedInf(l_ivector_slice &iv,const l_real &r) throw();
01948 
01950         INLINE void Resize(l_ivector &rv) throw();
01952         INLINE void Resize(l_ivector &rv, const int &len)
01953 #if(CXSC_INDEX_CHECK)
01954         throw(ERROR__WRONG_BOUNDARIES<l_ivector>);
01955 #else
01956         throw();
01957 #endif
01958 
01959         INLINE void Resize(l_ivector &rv, const int &lb, const int &ub)
01960 #if(CXSC_INDEX_CHECK)
01961         throw(ERROR__WRONG_BOUNDARIES<l_ivector>);
01962 #else
01963         throw();
01964 #endif
01965 
01967         INLINE l_ivector abs(const l_ivector &rv) throw();
01969         INLINE l_ivector abs(const l_ivector_slice &sl) throw();
01971         INLINE l_rvector diam(const l_ivector &v) throw();
01973         INLINE l_rvector diam(const l_ivector_slice &v) throw();
01975         INLINE l_rvector mid(const l_ivector &v) throw();
01977         INLINE l_rvector mid(const l_ivector_slice &v) throw();
01979         INLINE l_rvector Inf(const l_ivector &v) throw();
01981         INLINE l_rvector Inf(const l_ivector_slice &v) throw();
01983         INLINE l_rvector Sup(const l_ivector &v) throw();
01985         INLINE l_rvector Sup(const l_ivector_slice &v) throw();
01987         INLINE bool operator !(const l_ivector &rv) throw();
01989         INLINE bool operator !(const l_ivector_slice &sl) throw();
01990 
01991 //======================= Vector / Scalar ===============================
01992 
01993 //----------------------------- l_interval ---------------------------
01994 
01996         INLINE l_ivector operator *(const l_ivector &rv, const l_interval &s) throw();
01998         INLINE l_ivector operator *(const l_ivector_slice &sl, const l_interval &s) throw();
02000         INLINE l_ivector operator *(const l_interval &s, const l_ivector &rv) throw();
02002         INLINE l_ivector operator *(const l_interval &s, const l_ivector_slice &sl) throw();
02004         INLINE l_ivector &operator *=(l_ivector &rv,const l_interval &r) throw();
02005 
02007         INLINE l_ivector operator /(const l_ivector &rv, const l_interval &s) throw();
02009         INLINE l_ivector operator /(const l_ivector_slice &sl, const l_interval &s) throw();
02011         INLINE l_ivector &operator /=(l_ivector &rv,const l_interval &r) throw();
02012 
02013 //---------------------------- Real --------------------------------------
02014 
02016         INLINE l_ivector operator *(const l_ivector &rv, const real &s) throw();
02018         INLINE l_ivector operator *(const l_ivector_slice &sl, const real &s) throw();
02020         INLINE l_ivector operator *(const real &s, const l_ivector &rv) throw();
02022         INLINE l_ivector operator *(const real &s, const l_ivector_slice &sl) throw();
02024         INLINE l_ivector &operator *=(l_ivector &rv,const real &r) throw();
02025 
02027         INLINE l_ivector operator /(const l_ivector &rv, const real &s) throw();
02029         INLINE l_ivector operator /(const l_ivector_slice &sl, const real &s) throw();
02031         INLINE l_ivector &operator /=(l_ivector &rv,const real &r) throw();
02032 
02034         INLINE l_ivector operator *(const rvector &rv, const l_interval &s) throw();
02036         INLINE l_ivector operator *(const rvector_slice &sl, const l_interval &s) throw();
02038         INLINE l_ivector operator *(const l_interval &s, const rvector &rv) throw();
02040         INLINE l_ivector operator *(const l_interval &s, const rvector_slice &sl) throw();
02041 
02043         INLINE l_ivector operator /(const rvector &rv, const l_interval &s) throw();
02045         INLINE l_ivector operator /(const rvector_slice &sl, const l_interval &s) throw();
02046 
02047 //---------------------------- Complex --------------------------------------
02048 
02050         INLINE l_ivector operator *(const l_ivector &rv, const l_real &s) throw();
02052         INLINE l_ivector operator *(const l_ivector_slice &sl, const l_real &s) throw();
02054         INLINE l_ivector operator *(const l_real &s, const l_ivector &rv) throw();
02056         INLINE l_ivector operator *(const l_real &s, const l_ivector_slice &sl) throw();
02058         INLINE l_ivector &operator *=(l_ivector &rv,const l_real &r) throw();
02059 
02061         INLINE l_ivector operator /(const l_ivector &rv, const l_real &s) throw();
02063         INLINE l_ivector operator /(const l_ivector_slice &sl, const l_real &s) throw();
02065         INLINE l_ivector &operator /=(l_ivector &rv,const l_real &r) throw();
02066 
02068         INLINE l_ivector operator *(const l_rvector &rv, const l_interval &s) throw();
02070         INLINE l_ivector operator *(const l_rvector_slice &sl, const l_interval &s) throw();
02072         INLINE l_ivector operator *(const l_interval &s, const l_rvector &rv) throw();
02074         INLINE l_ivector operator *(const l_interval &s, const l_rvector_slice &sl) throw();
02075 
02077         INLINE l_ivector operator /(const l_rvector &rv, const l_interval &s) throw();
02079         INLINE l_ivector operator /(const l_rvector_slice &sl, const l_interval &s) throw();
02080 
02081 //---------------------------- interval --------------------------------------
02082 
02084         INLINE l_ivector operator *(const l_ivector &rv, const interval &s) throw();
02086         INLINE l_ivector operator *(const l_ivector_slice &sl, const interval &s) throw();
02088         INLINE l_ivector operator *(const interval &s, const l_ivector &rv) throw();
02090         INLINE l_ivector operator *(const interval &s, const l_ivector_slice &sl) throw();
02092         INLINE l_ivector &operator *=(l_ivector &rv,const interval &r) throw();
02093 
02095         INLINE l_ivector operator /(const l_ivector &rv, const interval &s) throw();
02097         INLINE l_ivector operator /(const l_ivector_slice &sl, const interval &s) throw();
02099         INLINE l_ivector &operator /=(l_ivector &rv,const interval &r) throw();
02100 
02102         INLINE l_ivector operator *(const ivector &rv, const l_interval &s) throw();
02104         INLINE l_ivector operator *(const ivector_slice &sl, const l_interval &s) throw();
02106         INLINE l_ivector operator *(const l_interval &s, const ivector &rv) throw();
02108         INLINE l_ivector operator *(const l_interval &s, const ivector_slice &sl) throw();
02109 
02111         INLINE l_ivector operator /(const ivector &rv, const l_interval &s) throw();
02113         INLINE l_ivector operator /(const ivector_slice &sl, const l_interval &s) throw();
02114 
02115 //======================= Vector / Vector ===============================
02116 
02117 
02119         INLINE std::ostream &operator <<(std::ostream &s, const l_ivector &rv) throw();
02121         INLINE std::ostream &operator <<(std::ostream &o, const l_ivector_slice &sl) throw();
02123         INLINE std::istream &operator >>(std::istream &s, l_ivector &rv) throw();
02125         INLINE std::istream &operator >>(std::istream &s, l_ivector_slice &rv) throw();
02126         
02127 //----------------------- l_interval / l_interval ---------------------------
02128 
02130         INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const l_ivector &rv2)
02131 #if(CXSC_INDEX_CHECK)
02132         throw(OP_WITH_WRONG_DIM);
02133 #else
02134         throw();
02135 #endif
02136 
02137         INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl, const l_ivector &rv)
02138 #if(CXSC_INDEX_CHECK)
02139         throw(OP_WITH_WRONG_DIM);
02140 #else
02141         throw();
02142 #endif
02143 
02144         INLINE void accumulate(idotprecision &dp, const l_ivector &rv, const l_ivector_slice &sl)
02145 #if(CXSC_INDEX_CHECK)
02146         throw(OP_WITH_WRONG_DIM);
02147 #else
02148         throw();
02149 #endif
02150 
02151         INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const l_imatrix_subv &rv2)
02152 #if(CXSC_INDEX_CHECK)
02153         throw(OP_WITH_WRONG_DIM);
02154 #else
02155         throw();
02156 #endif
02157 
02158         INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_ivector &rv2)
02159 #if(CXSC_INDEX_CHECK)
02160         throw(OP_WITH_WRONG_DIM);
02161 #else
02162         throw();
02163 #endif
02164 
02165         INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl1, const l_ivector_slice &sl2)
02166 #if(CXSC_INDEX_CHECK)
02167         throw(OP_WITH_WRONG_DIM);
02168 #else
02169         throw();
02170 #endif
02171 
02173         INLINE l_interval operator *(const l_ivector & rv1, const l_ivector &rv2)
02174 #if(CXSC_INDEX_CHECK)
02175         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02176 #else
02177         throw();
02178 #endif
02179 
02180         INLINE l_interval operator *(const l_ivector_slice &sl, const l_ivector &rv)
02181 #if(CXSC_INDEX_CHECK)
02182         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02183 #else
02184         throw();
02185 #endif
02186 
02187         INLINE l_interval operator *(const l_ivector &rv, const l_ivector_slice &sl)
02188 #if(CXSC_INDEX_CHECK)
02189         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02190 #else
02191         throw();
02192 #endif
02193 
02194         INLINE l_interval operator *(const l_ivector_slice & sl1, const l_ivector_slice &sl2)
02195 #if(CXSC_INDEX_CHECK)
02196         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02197 #else
02198         throw();
02199 #endif
02200         
02202         INLINE const l_ivector &operator +(const l_ivector &rv) throw();
02204         INLINE l_ivector operator +(const l_ivector_slice &sl) throw();
02205 
02207         INLINE l_ivector operator +(const l_ivector &rv1, const l_ivector &rv2)
02208 #if(CXSC_INDEX_CHECK)
02209         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02210 #else
02211         throw();
02212 #endif
02213 
02214         INLINE l_ivector operator +(const l_ivector &rv, const l_ivector_slice &sl)
02215 #if(CXSC_INDEX_CHECK)
02216         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02217 #else
02218         throw();
02219 #endif
02220 
02221         INLINE l_ivector operator +(const l_ivector_slice &sl, const l_ivector &rv)
02222 #if(CXSC_INDEX_CHECK)
02223         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02224 #else
02225         throw();
02226 #endif
02227 
02228         INLINE l_ivector operator +(const l_ivector_slice &sl1, const l_ivector_slice &sl2)
02229 #if(CXSC_INDEX_CHECK)
02230         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02231 #else
02232         throw();
02233 #endif
02234 
02235         INLINE l_ivector & operator +=(l_ivector &rv1, const l_ivector &rv2)
02236 #if(CXSC_INDEX_CHECK)
02237         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02238 #else
02239         throw();
02240 #endif
02241 
02242         INLINE l_ivector &operator +=(l_ivector &rv, const l_ivector_slice &sl)
02243 #if(CXSC_INDEX_CHECK)
02244         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02245 #else
02246         throw();
02247 #endif
02248 
02250         INLINE l_ivector operator -(const l_ivector &rv) throw();
02252         INLINE l_ivector operator -(const l_ivector_slice &sl) throw();
02254         INLINE l_ivector operator -(const l_ivector &rv1, const l_ivector &rv2)
02255 #if(CXSC_INDEX_CHECK)
02256         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02257 #else
02258         throw();
02259 #endif
02260 
02261         INLINE l_ivector operator -(const l_ivector &rv, const l_ivector_slice &sl)
02262 #if(CXSC_INDEX_CHECK)
02263         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02264 #else
02265         throw();
02266 #endif
02267 
02268         INLINE l_ivector operator -(const l_ivector_slice &sl, const l_ivector &rv)
02269 #if(CXSC_INDEX_CHECK)
02270         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02271 #else
02272         throw();
02273 #endif
02274 
02275         INLINE l_ivector operator -(const l_ivector_slice &sl1, const l_ivector_slice &sl2)
02276 #if(CXSC_INDEX_CHECK)
02277         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02278 #else
02279         throw();
02280 #endif
02281 
02282         INLINE l_ivector & operator -=(l_ivector &rv1, const l_ivector &rv2)
02283 #if(CXSC_INDEX_CHECK)
02284         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02285 #else
02286         throw();
02287 #endif
02288 
02289         INLINE l_ivector &operator -=(l_ivector &rv, const l_ivector_slice &sl)
02290 #if(CXSC_INDEX_CHECK)
02291         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02292 #else
02293         throw();
02294 #endif
02295 
02297         INLINE l_ivector operator |(const l_ivector &rv1, const l_ivector &rv2)
02298 #if(CXSC_INDEX_CHECK)
02299         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02300 #else
02301         throw();
02302 #endif
02303 
02304         INLINE l_ivector operator |(const l_ivector &rv, const l_ivector_slice &sl)
02305 #if(CXSC_INDEX_CHECK)
02306         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02307 #else
02308         throw();
02309 #endif
02310 
02311         INLINE l_ivector operator |(const l_ivector_slice &sl, const l_ivector &rv)
02312 #if(CXSC_INDEX_CHECK)
02313         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02314 #else
02315         throw();
02316 #endif
02317 
02318         INLINE l_ivector operator |(const l_ivector_slice &sl1, const l_ivector_slice &sl2)
02319 #if(CXSC_INDEX_CHECK)
02320         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02321 #else
02322         throw();
02323 #endif
02324 
02325         INLINE l_ivector & operator |=(l_ivector &rv1, const l_ivector &rv2)
02326 #if(CXSC_INDEX_CHECK)
02327         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02328 #else
02329         throw();
02330 #endif
02331 
02332         INLINE l_ivector &operator |=(l_ivector &rv, const l_ivector_slice &sl)
02333 #if(CXSC_INDEX_CHECK)
02334         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02335 #else
02336         throw();
02337 #endif
02338 
02340         INLINE l_ivector operator &(const l_ivector &rv1, const l_ivector &rv2)
02341 #if(CXSC_INDEX_CHECK)
02342         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02343 #else
02344         throw();
02345 #endif
02346 
02347         INLINE l_ivector operator &(const l_ivector &rv, const l_ivector_slice &sl)
02348 #if(CXSC_INDEX_CHECK)
02349         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02350 #else
02351         throw();
02352 #endif
02353 
02354         INLINE l_ivector operator &(const l_ivector_slice &sl, const l_ivector &rv)
02355 #if(CXSC_INDEX_CHECK)
02356         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02357 #else
02358         throw();
02359 #endif
02360 
02361         INLINE l_ivector operator &(const l_ivector_slice &sl1, const l_ivector_slice &sl2)
02362 #if(CXSC_INDEX_CHECK)
02363         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02364 #else
02365         throw();
02366 #endif
02367 
02368         INLINE l_ivector & operator &=(l_ivector &rv1, const l_ivector &rv2)
02369 #if(CXSC_INDEX_CHECK)
02370         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02371 #else
02372         throw();
02373 #endif
02374 
02375         INLINE l_ivector &operator &=(l_ivector &rv, const l_ivector_slice &sl)
02376 #if(CXSC_INDEX_CHECK)
02377         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02378 #else
02379         throw();
02380 #endif
02381 
02383         INLINE bool operator ==(const l_ivector &rv1, const l_ivector &rv2) throw();
02385         INLINE bool operator ==(const l_ivector_slice &sl1, const l_ivector_slice &sl2) throw();
02387         INLINE bool operator ==(const l_ivector_slice &sl, const l_ivector &rv) throw();
02389         INLINE bool operator ==(const l_ivector &rv, const l_ivector_slice &sl) throw();
02391         INLINE bool operator !=(const l_ivector &rv1, const l_ivector &rv2) throw();
02393         INLINE bool operator !=(const l_ivector_slice &sl1, const l_ivector_slice &sl2) throw();
02395         INLINE bool operator !=(const l_ivector_slice &sl, const l_ivector &rv) throw();
02397         INLINE bool operator !=(const l_ivector &rv, const l_ivector_slice &sl) throw();
02399         INLINE bool operator <(const l_ivector &rv1, const l_ivector &rv2) throw();
02401         INLINE bool operator <(const l_ivector_slice &sl1, const l_ivector_slice &sl2) throw();
02403         INLINE bool operator < (const l_ivector_slice &sl, const l_ivector &rv) throw();
02405         INLINE bool operator < (const l_ivector &rv, const l_ivector_slice &sl) throw();
02407         INLINE bool operator <=(const l_ivector &rv1, const l_ivector &rv2) throw();
02409         INLINE bool operator <=(const l_ivector_slice &sl1, const l_ivector_slice &sl2) throw();
02411         INLINE bool operator <=(const l_ivector_slice &sl, const l_ivector &rv) throw();
02413         INLINE bool operator <=(const l_ivector &rv, const l_ivector_slice &sl) throw();
02415         INLINE bool operator >(const l_ivector &rv1, const l_ivector &rv2) throw();
02417         INLINE bool operator >(const l_ivector_slice &sl1, const l_ivector_slice &sl2) throw();
02419         INLINE bool operator >(const l_ivector_slice &sl, const l_ivector &rv) throw();
02421         INLINE bool operator >(const l_ivector &rv, const l_ivector_slice &sl) throw();
02423         INLINE bool operator >=(const l_ivector &rv1, const l_ivector &rv2) throw();
02425         INLINE bool operator >=(const l_ivector_slice &sl1, const l_ivector_slice &sl2) throw();
02427         INLINE bool operator >=(const l_ivector_slice &sl, const l_ivector &rv) throw();
02429         INLINE bool operator >=(const l_ivector &rv, const l_ivector_slice &sl) throw();
02430 
02431 //-------------------------------- l_interval / Real --------------------------------
02432 
02434         INLINE void accumulate(idotprecision &dp, const rvector & rv1, const l_ivector &rv2)
02435 #if(CXSC_INDEX_CHECK)
02436         throw(OP_WITH_WRONG_DIM);
02437 #else
02438         throw();
02439 #endif
02440 
02441         INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const rvector &rv2)
02442 #if(CXSC_INDEX_CHECK)
02443         throw(OP_WITH_WRONG_DIM);
02444 #else
02445         throw();
02446 #endif
02447 
02448         INLINE void accumulate(idotprecision &dp, const rvector_slice & sl, const l_ivector &rv)
02449 #if(CXSC_INDEX_CHECK)
02450         throw(OP_WITH_WRONG_DIM);
02451 #else
02452         throw();
02453 #endif
02454 
02455         INLINE void accumulate(idotprecision &dp,const l_ivector_slice &sl,const rvector &rv)
02456 #if(CXSC_INDEX_CHECK)
02457         throw(OP_WITH_WRONG_DIM);
02458 #else
02459         throw();
02460 #endif
02461 
02462         INLINE void accumulate(idotprecision &dp, const rvector &rv, const l_ivector_slice &sl)
02463 #if(CXSC_INDEX_CHECK)
02464         throw(OP_WITH_WRONG_DIM);
02465 #else
02466         throw();
02467 #endif
02468 
02469         INLINE void accumulate(idotprecision &dp, const rvector & rv1, const l_imatrix_subv &rv2)
02470 #if(CXSC_INDEX_CHECK)
02471         throw(OP_WITH_WRONG_DIM);
02472 #else
02473         throw();
02474 #endif
02475 
02476         INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const rmatrix_subv &rv2)
02477 #if(CXSC_INDEX_CHECK)
02478         throw(OP_WITH_WRONG_DIM);
02479 #else
02480         throw();
02481 #endif
02482 
02483         INLINE void accumulate(idotprecision &dp,const l_ivector &rv,const rvector_slice &sl)
02484 #if(CXSC_INDEX_CHECK)
02485         throw(OP_WITH_WRONG_DIM);
02486 #else
02487         throw();
02488 #endif
02489 
02490         INLINE void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const l_ivector &rv2)
02491 #if(CXSC_INDEX_CHECK)
02492         throw(OP_WITH_WRONG_DIM);
02493 #else
02494         throw();
02495 #endif
02496 
02497         INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const rvector &rv2)
02498 #if(CXSC_INDEX_CHECK)
02499         throw(OP_WITH_WRONG_DIM);
02500 #else
02501         throw();
02502 #endif
02503 
02504         INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl1, const rvector_slice &sl2)
02505 #if(CXSC_INDEX_CHECK)
02506         throw(OP_WITH_WRONG_DIM);
02507 #else
02508         throw();
02509 #endif
02510 
02511         INLINE void accumulate(idotprecision &dp, const rvector_slice & sl1, const l_ivector_slice &sl2)
02512 #if(CXSC_INDEX_CHECK)
02513         throw(OP_WITH_WRONG_DIM);
02514 #else
02515         throw();
02516 #endif
02517 
02519         INLINE l_interval operator *(const rvector & rv1, const l_ivector &rv2)
02520 #if(CXSC_INDEX_CHECK)
02521         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02522 #else
02523         throw();
02524 #endif
02525 
02526         INLINE l_interval operator *(const rvector_slice &sl, const l_ivector &rv)
02527 #if(CXSC_INDEX_CHECK)
02528         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02529 #else
02530         throw();
02531 #endif
02532 
02533         INLINE l_interval operator *(const rvector &rv, const l_ivector_slice &sl)
02534 #if(CXSC_INDEX_CHECK)
02535         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02536 #else
02537         throw();
02538 #endif
02539 
02540         INLINE l_interval operator *(const rvector_slice & sl1, const l_ivector_slice &sl2)
02541 #if(CXSC_INDEX_CHECK)
02542         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02543 #else
02544         throw();
02545 #endif
02546         
02548         INLINE l_interval operator *(const l_ivector & rv1, const rvector &rv2)
02549 #if(CXSC_INDEX_CHECK)
02550         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02551 #else
02552         throw();
02553 #endif
02554 
02555         INLINE l_interval operator *(const l_ivector_slice &sl, const rvector &rv)
02556 #if(CXSC_INDEX_CHECK)
02557         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02558 #else
02559         throw();
02560 #endif
02561 
02562         INLINE l_interval operator *(const l_ivector &rv, const rvector_slice &sl)
02563 #if(CXSC_INDEX_CHECK)
02564         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02565 #else
02566         throw();
02567 #endif
02568 
02569         INLINE l_interval operator *(const l_ivector_slice & sl1, const rvector_slice &sl2)
02570 #if(CXSC_INDEX_CHECK)
02571         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02572 #else
02573         throw();
02574 #endif
02575         
02577         INLINE l_ivector operator +(const rvector &rv1, const l_ivector &rv2)
02578 #if(CXSC_INDEX_CHECK)
02579         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02580 #else
02581         throw();
02582 #endif
02583 
02584         INLINE l_ivector operator +(const rvector &rv, const l_ivector_slice &sl)
02585 #if(CXSC_INDEX_CHECK)
02586         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02587 #else
02588         throw();
02589 #endif
02590 
02591         INLINE l_ivector operator +(const rvector_slice &sl, const l_ivector &rv)
02592 #if(CXSC_INDEX_CHECK)
02593         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02594 #else
02595         throw();
02596 #endif
02597 
02598         INLINE l_ivector operator +(const rvector_slice &sl1, const l_ivector_slice &sl2)
02599 #if(CXSC_INDEX_CHECK)
02600         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02601 #else
02602         throw();
02603 #endif
02604 
02606         INLINE l_ivector operator +(const l_ivector &rv1, const rvector &rv2)
02607 #if(CXSC_INDEX_CHECK)
02608         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02609 #else
02610         throw();
02611 #endif
02612 
02613         INLINE l_ivector operator +(const l_ivector &rv, const rvector_slice &sl)
02614 #if(CXSC_INDEX_CHECK)
02615         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02616 #else
02617         throw();
02618 #endif
02619 
02620         INLINE l_ivector operator +(const l_ivector_slice &sl, const rvector &rv)
02621 #if(CXSC_INDEX_CHECK)
02622         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02623 #else
02624         throw();
02625 #endif
02626 
02627         INLINE l_ivector operator +(const l_ivector_slice &sl1, const rvector_slice &sl2)
02628 #if(CXSC_INDEX_CHECK)
02629         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02630 #else
02631         throw();
02632 #endif
02633 
02635         INLINE l_ivector & operator +=(l_ivector &rv1, const rvector &rv2)
02636 #if(CXSC_INDEX_CHECK)
02637         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02638 #else
02639         throw();
02640 #endif
02641 
02642         INLINE l_ivector &operator +=(l_ivector &rv, const rvector_slice &sl)
02643 #if(CXSC_INDEX_CHECK)
02644         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02645 #else
02646         throw();
02647 #endif
02648 
02650         INLINE l_ivector operator -(const rvector &rv1, const l_ivector &rv2)
02651 #if(CXSC_INDEX_CHECK)
02652         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02653 #else
02654         throw();
02655 #endif
02656 
02657         INLINE l_ivector operator -(const rvector &rv, const l_ivector_slice &sl)
02658 #if(CXSC_INDEX_CHECK)
02659         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02660 #else
02661         throw();
02662 #endif
02663 
02664         INLINE l_ivector operator -(const rvector_slice &sl, const l_ivector &rv)
02665 #if(CXSC_INDEX_CHECK)
02666         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02667 #else
02668         throw();
02669 #endif
02670 
02671         INLINE l_ivector operator -(const rvector_slice &sl1, const l_ivector_slice &sl2)
02672 #if(CXSC_INDEX_CHECK)
02673         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02674 #else
02675         throw();
02676 #endif
02677 
02679         INLINE l_ivector operator -(const l_ivector &rv1, const rvector &rv2)
02680 #if(CXSC_INDEX_CHECK)
02681         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02682 #else
02683         throw();
02684 #endif
02685 
02686         INLINE l_ivector operator -(const l_ivector &rv, const rvector_slice &sl)
02687 #if(CXSC_INDEX_CHECK)
02688         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02689 #else
02690         throw();
02691 #endif
02692 
02693         INLINE l_ivector operator -(const l_ivector_slice &sl, const rvector &rv)
02694 #if(CXSC_INDEX_CHECK)
02695         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02696 #else
02697         throw();
02698 #endif
02699 
02700         INLINE l_ivector operator -(const l_ivector_slice &sl1, const rvector_slice &sl2)
02701 #if(CXSC_INDEX_CHECK)
02702         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02703 #else
02704         throw();
02705 #endif
02706 
02708         INLINE l_ivector & operator -=(l_ivector &rv1, const rvector &rv2)
02709 #if(CXSC_INDEX_CHECK)
02710         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02711 #else
02712         throw();
02713 #endif
02714 
02715         INLINE l_ivector &operator -=(l_ivector &rv, const rvector_slice &sl)
02716 #if(CXSC_INDEX_CHECK)
02717         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02718 #else
02719         throw();
02720 #endif
02721 
02723         INLINE l_ivector operator |(const rvector &rv1, const l_ivector &rv2)
02724 #if(CXSC_INDEX_CHECK)
02725         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02726 #else
02727         throw();
02728 #endif
02729 
02730         INLINE l_ivector operator |(const rvector &rv, const l_ivector_slice &sl)
02731 #if(CXSC_INDEX_CHECK)
02732         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02733 #else
02734         throw();
02735 #endif
02736 
02737         INLINE l_ivector operator |(const rvector_slice &sl, const l_ivector &rv)
02738 #if(CXSC_INDEX_CHECK)
02739         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02740 #else
02741         throw();
02742 #endif
02743 
02744         INLINE l_ivector operator |(const rvector_slice &sl1, const l_ivector_slice &sl2)
02745 #if(CXSC_INDEX_CHECK)
02746         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02747 #else
02748         throw();
02749 #endif
02750 
02752         INLINE l_ivector operator |(const l_ivector &rv1, const rvector &rv2)
02753 #if(CXSC_INDEX_CHECK)
02754         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02755 #else
02756         throw();
02757 #endif
02758 
02759         INLINE l_ivector operator |(const l_ivector &rv, const rvector_slice &sl)
02760 #if(CXSC_INDEX_CHECK)
02761         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02762 #else
02763         throw();
02764 #endif
02765 
02766         INLINE l_ivector operator |(const l_ivector_slice &sl, const rvector &rv)
02767 #if(CXSC_INDEX_CHECK)
02768         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02769 #else
02770         throw();
02771 #endif
02772 
02773         INLINE l_ivector operator |(const l_ivector_slice &sl1, const rvector_slice &sl2)
02774 #if(CXSC_INDEX_CHECK)
02775         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02776 #else
02777         throw();
02778 #endif
02779 
02781         INLINE l_ivector & operator |=(l_ivector &rv1, const rvector &rv2)
02782 #if(CXSC_INDEX_CHECK)
02783         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02784 #else
02785         throw();
02786 #endif
02787 
02788         INLINE l_ivector &operator |=(l_ivector &rv, const rvector_slice &sl)
02789 #if(CXSC_INDEX_CHECK)
02790         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02791 #else
02792         throw();
02793 #endif
02794 
02796         INLINE l_ivector operator &(const rvector &rv1, const l_ivector &rv2)
02797 #if(CXSC_INDEX_CHECK)
02798         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02799 #else
02800         throw();
02801 #endif
02802 
02803         INLINE l_ivector operator &(const rvector &rv, const l_ivector_slice &sl)
02804 #if(CXSC_INDEX_CHECK)
02805         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02806 #else
02807         throw();
02808 #endif
02809 
02810         INLINE l_ivector operator &(const rvector_slice &sl, const l_ivector &rv)
02811 #if(CXSC_INDEX_CHECK)
02812         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02813 #else
02814         throw();
02815 #endif
02816 
02817         INLINE l_ivector operator &(const rvector_slice &sl1, const l_ivector_slice &sl2)
02818 #if(CXSC_INDEX_CHECK)
02819         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02820 #else
02821         throw();
02822 #endif
02823 
02825         INLINE l_ivector operator &(const l_ivector &rv1, const rvector &rv2)
02826 #if(CXSC_INDEX_CHECK)
02827         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02828 #else
02829         throw();
02830 #endif
02831 
02832         INLINE l_ivector operator &(const l_ivector &rv, const rvector_slice &sl)
02833 #if(CXSC_INDEX_CHECK)
02834         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02835 #else
02836         throw();
02837 #endif
02838 
02839         INLINE l_ivector operator &(const l_ivector_slice &sl, const rvector &rv)
02840 #if(CXSC_INDEX_CHECK)
02841         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02842 #else
02843         throw();
02844 #endif
02845 
02846         INLINE l_ivector operator &(const l_ivector_slice &sl1, const rvector_slice &sl2)
02847 #if(CXSC_INDEX_CHECK)
02848         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02849 #else
02850         throw();
02851 #endif
02852 
02854         INLINE l_ivector & operator &=(l_ivector &rv1, const rvector &rv2)
02855 #if(CXSC_INDEX_CHECK)
02856         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02857 #else
02858         throw();
02859 #endif
02860 
02861         INLINE l_ivector &operator &=(l_ivector &rv, const rvector_slice &sl)
02862 #if(CXSC_INDEX_CHECK)
02863         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02864 #else
02865         throw();
02866 #endif
02867 //-------------------------------- l_interval / l_real --------------------------------
02868 
02870         INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const l_ivector &rv2)
02871 #if(CXSC_INDEX_CHECK)
02872         throw(OP_WITH_WRONG_DIM);
02873 #else
02874         throw();
02875 #endif
02876 
02877         INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const l_rvector &rv2)
02878 #if(CXSC_INDEX_CHECK)
02879         throw(OP_WITH_WRONG_DIM);
02880 #else
02881         throw();
02882 #endif
02883 
02884         INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl, const l_ivector &rv)
02885 #if(CXSC_INDEX_CHECK)
02886         throw(OP_WITH_WRONG_DIM);
02887 #else
02888         throw();
02889 #endif
02890 
02891         INLINE void accumulate(idotprecision &dp,const l_ivector_slice &sl,const l_rvector &rv)
02892 #if(CXSC_INDEX_CHECK)
02893         throw(OP_WITH_WRONG_DIM);
02894 #else
02895         throw();
02896 #endif
02897 
02898         INLINE void accumulate(idotprecision &dp, const l_rvector &rv, const l_ivector_slice &sl)
02899 #if(CXSC_INDEX_CHECK)
02900         throw(OP_WITH_WRONG_DIM);
02901 #else
02902         throw();
02903 #endif
02904 
02905         INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const l_imatrix_subv &rv2)
02906 #if(CXSC_INDEX_CHECK)
02907         throw(OP_WITH_WRONG_DIM);
02908 #else
02909         throw();
02910 #endif
02911 
02912         INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const l_rmatrix_subv &rv2)
02913 #if(CXSC_INDEX_CHECK)
02914         throw(OP_WITH_WRONG_DIM);
02915 #else
02916         throw();
02917 #endif
02918 
02919         INLINE void accumulate(idotprecision &dp,const l_ivector &rv,const l_rvector_slice &sl)
02920 #if(CXSC_INDEX_CHECK)
02921         throw(OP_WITH_WRONG_DIM);
02922 #else
02923         throw();
02924 #endif
02925 
02926         INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const l_ivector &rv2)
02927 #if(CXSC_INDEX_CHECK)
02928         throw(OP_WITH_WRONG_DIM);
02929 #else
02930         throw();
02931 #endif
02932 
02933         INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_rvector &rv2)
02934 #if(CXSC_INDEX_CHECK)
02935         throw(OP_WITH_WRONG_DIM);
02936 #else
02937         throw();
02938 #endif
02939 
02940         INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl1, const l_rvector_slice &sl2)
02941 #if(CXSC_INDEX_CHECK)
02942         throw(OP_WITH_WRONG_DIM);
02943 #else
02944         throw();
02945 #endif
02946 
02947         INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl1, const l_ivector_slice &sl2)
02948 #if(CXSC_INDEX_CHECK)
02949         throw(OP_WITH_WRONG_DIM);
02950 #else
02951         throw();
02952 #endif
02953 
02955         INLINE l_interval operator *(const l_rvector & rv1, const l_ivector &rv2)
02956 #if(CXSC_INDEX_CHECK)
02957         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02958 #else
02959         throw();
02960 #endif
02961 
02962         INLINE l_interval operator *(const l_rvector_slice &sl, const l_ivector &rv)
02963 #if(CXSC_INDEX_CHECK)
02964         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02965 #else
02966         throw();
02967 #endif
02968 
02969         INLINE l_interval operator *(const l_rvector &rv, const l_ivector_slice &sl)
02970 #if(CXSC_INDEX_CHECK)
02971         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02972 #else
02973         throw();
02974 #endif
02975 
02976         INLINE l_interval operator *(const l_rvector_slice & sl1, const l_ivector_slice &sl2)
02977 #if(CXSC_INDEX_CHECK)
02978         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02979 #else
02980         throw();
02981 #endif
02982         
02984         INLINE l_interval operator *(const l_ivector & rv1, const l_rvector &rv2)
02985 #if(CXSC_INDEX_CHECK)
02986         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02987 #else
02988         throw();
02989 #endif
02990 
02991         INLINE l_interval operator *(const l_ivector_slice &sl, const l_rvector &rv)
02992 #if(CXSC_INDEX_CHECK)
02993         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
02994 #else
02995         throw();
02996 #endif
02997 
02998         INLINE l_interval operator *(const l_ivector &rv, const l_rvector_slice &sl)
02999 #if(CXSC_INDEX_CHECK)
03000         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03001 #else
03002         throw();
03003 #endif
03004 
03005         INLINE l_interval operator *(const l_ivector_slice & sl1, const l_rvector_slice &sl2)
03006 #if(CXSC_INDEX_CHECK)
03007         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03008 #else
03009         throw();
03010 #endif
03011         
03013         INLINE l_ivector operator +(const l_rvector &rv1, const l_ivector &rv2)
03014 #if(CXSC_INDEX_CHECK)
03015         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03016 #else
03017         throw();
03018 #endif
03019 
03020         INLINE l_ivector operator +(const l_rvector &rv, const l_ivector_slice &sl)
03021 #if(CXSC_INDEX_CHECK)
03022         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03023 #else
03024         throw();
03025 #endif
03026 
03027         INLINE l_ivector operator +(const l_rvector_slice &sl, const l_ivector &rv)
03028 #if(CXSC_INDEX_CHECK)
03029         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03030 #else
03031         throw();
03032 #endif
03033 
03034         INLINE l_ivector operator +(const l_rvector_slice &sl1, const l_ivector_slice &sl2)
03035 #if(CXSC_INDEX_CHECK)
03036         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03037 #else
03038         throw();
03039 #endif
03040 
03042         INLINE l_ivector operator +(const l_ivector &rv1, const l_rvector &rv2)
03043 #if(CXSC_INDEX_CHECK)
03044         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03045 #else
03046         throw();
03047 #endif
03048 
03049         INLINE l_ivector operator +(const l_ivector &rv, const l_rvector_slice &sl)
03050 #if(CXSC_INDEX_CHECK)
03051         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03052 #else
03053         throw();
03054 #endif
03055 
03056         INLINE l_ivector operator +(const l_ivector_slice &sl, const l_rvector &rv)
03057 #if(CXSC_INDEX_CHECK)
03058         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03059 #else
03060         throw();
03061 #endif
03062 
03063         INLINE l_ivector operator +(const l_ivector_slice &sl1, const l_rvector_slice &sl2)
03064 #if(CXSC_INDEX_CHECK)
03065         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03066 #else
03067         throw();
03068 #endif
03069 
03071         INLINE l_ivector & operator +=(l_ivector &rv1, const l_rvector &rv2)
03072 #if(CXSC_INDEX_CHECK)
03073         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03074 #else
03075         throw();
03076 #endif
03077 
03078         INLINE l_ivector &operator +=(l_ivector &rv, const l_rvector_slice &sl)
03079 #if(CXSC_INDEX_CHECK)
03080         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03081 #else
03082         throw();
03083 #endif
03084 
03086         INLINE l_ivector operator -(const l_rvector &rv1, const l_ivector &rv2)
03087 #if(CXSC_INDEX_CHECK)
03088         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03089 #else
03090         throw();
03091 #endif
03092 
03093         INLINE l_ivector operator -(const l_rvector &rv, const l_ivector_slice &sl)
03094 #if(CXSC_INDEX_CHECK)
03095         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03096 #else
03097         throw();
03098 #endif
03099 
03100         INLINE l_ivector operator -(const l_rvector_slice &sl, const l_ivector &rv)
03101 #if(CXSC_INDEX_CHECK)
03102         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03103 #else
03104         throw();
03105 #endif
03106 
03107         INLINE l_ivector operator -(const l_rvector_slice &sl1, const l_ivector_slice &sl2)
03108 #if(CXSC_INDEX_CHECK)
03109         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03110 #else
03111         throw();
03112 #endif
03113 
03115         INLINE l_ivector operator -(const l_ivector &rv1, const l_rvector &rv2)
03116 #if(CXSC_INDEX_CHECK)
03117         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03118 #else
03119         throw();
03120 #endif
03121 
03122         INLINE l_ivector operator -(const l_ivector &rv, const l_rvector_slice &sl)
03123 #if(CXSC_INDEX_CHECK)
03124         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03125 #else
03126         throw();
03127 #endif
03128 
03129         INLINE l_ivector operator -(const l_ivector_slice &sl, const l_rvector &rv)
03130 #if(CXSC_INDEX_CHECK)
03131         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03132 #else
03133         throw();
03134 #endif
03135 
03136         INLINE l_ivector operator -(const l_ivector_slice &sl1, const l_rvector_slice &sl2)
03137 #if(CXSC_INDEX_CHECK)
03138         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03139 #else
03140         throw();
03141 #endif
03142 
03144         INLINE l_ivector & operator -=(l_ivector &rv1, const l_rvector &rv2)
03145 #if(CXSC_INDEX_CHECK)
03146         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03147 #else
03148         throw();
03149 #endif
03150 
03151         INLINE l_ivector &operator -=(l_ivector &rv, const l_rvector_slice &sl)
03152 #if(CXSC_INDEX_CHECK)
03153         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03154 #else
03155         throw();
03156 #endif
03157 
03159         INLINE l_ivector operator |(const l_rvector &rv1, const l_ivector &rv2)
03160 #if(CXSC_INDEX_CHECK)
03161         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03162 #else
03163         throw();
03164 #endif
03165 
03166         INLINE l_ivector operator |(const l_rvector &rv, const l_ivector_slice &sl)
03167 #if(CXSC_INDEX_CHECK)
03168         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03169 #else
03170         throw();
03171 #endif
03172 
03173         INLINE l_ivector operator |(const l_rvector_slice &sl, const l_ivector &rv)
03174 #if(CXSC_INDEX_CHECK)
03175         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03176 #else
03177         throw();
03178 #endif
03179 
03180         INLINE l_ivector operator |(const l_rvector_slice &sl1, const l_ivector_slice &sl2)
03181 #if(CXSC_INDEX_CHECK)
03182         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03183 #else
03184         throw();
03185 #endif
03186 
03188         INLINE l_ivector operator |(const l_ivector &rv1, const l_rvector &rv2)
03189 #if(CXSC_INDEX_CHECK)
03190         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03191 #else
03192         throw();
03193 #endif
03194 
03195         INLINE l_ivector operator |(const l_ivector &rv, const l_rvector_slice &sl)
03196 #if(CXSC_INDEX_CHECK)
03197         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03198 #else
03199         throw();
03200 #endif
03201 
03202         INLINE l_ivector operator |(const l_ivector_slice &sl, const l_rvector &rv)
03203 #if(CXSC_INDEX_CHECK)
03204         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03205 #else
03206         throw();
03207 #endif
03208 
03209         INLINE l_ivector operator |(const l_ivector_slice &sl1, const l_rvector_slice &sl2)
03210 #if(CXSC_INDEX_CHECK)
03211         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03212 #else
03213         throw();
03214 #endif
03215 
03217         INLINE l_ivector & operator |=(l_ivector &rv1, const l_rvector &rv2)
03218 #if(CXSC_INDEX_CHECK)
03219         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03220 #else
03221         throw();
03222 #endif
03223 
03224         INLINE l_ivector &operator |=(l_ivector &rv, const l_rvector_slice &sl)
03225 #if(CXSC_INDEX_CHECK)
03226         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03227 #else
03228         throw();
03229 #endif
03230 
03232         INLINE l_ivector operator &(const l_rvector &rv1, const l_ivector &rv2)
03233 #if(CXSC_INDEX_CHECK)
03234         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03235 #else
03236         throw();
03237 #endif
03238 
03239         INLINE l_ivector operator &(const l_rvector &rv, const l_ivector_slice &sl)
03240 #if(CXSC_INDEX_CHECK)
03241         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03242 #else
03243         throw();
03244 #endif
03245 
03246         INLINE l_ivector operator &(const l_rvector_slice &sl, const l_ivector &rv)
03247 #if(CXSC_INDEX_CHECK)
03248         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03249 #else
03250         throw();
03251 #endif
03252 
03253         INLINE l_ivector operator &(const l_rvector_slice &sl1, const l_ivector_slice &sl2)
03254 #if(CXSC_INDEX_CHECK)
03255         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03256 #else
03257         throw();
03258 #endif
03259 
03261         INLINE l_ivector operator &(const l_ivector &rv1, const l_rvector &rv2)
03262 #if(CXSC_INDEX_CHECK)
03263         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03264 #else
03265         throw();
03266 #endif
03267 
03268         INLINE l_ivector operator &(const l_ivector &rv, const l_rvector_slice &sl)
03269 #if(CXSC_INDEX_CHECK)
03270         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03271 #else
03272         throw();
03273 #endif
03274 
03275         INLINE l_ivector operator &(const l_ivector_slice &sl, const l_rvector &rv)
03276 #if(CXSC_INDEX_CHECK)
03277         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03278 #else
03279         throw();
03280 #endif
03281 
03282         INLINE l_ivector operator &(const l_ivector_slice &sl1, const l_rvector_slice &sl2)
03283 #if(CXSC_INDEX_CHECK)
03284         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03285 #else
03286         throw();
03287 #endif
03288 
03290         INLINE l_ivector & operator &=(l_ivector &rv1, const l_rvector &rv2)
03291 #if(CXSC_INDEX_CHECK)
03292         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03293 #else
03294         throw();
03295 #endif
03296 
03297         INLINE l_ivector &operator &=(l_ivector &rv, const l_rvector_slice &sl)
03298 #if(CXSC_INDEX_CHECK)
03299         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03300 #else
03301         throw();
03302 #endif
03303 
03304 //-------------------------------- l_interval / interval --------------------------------
03305 
03307         INLINE void accumulate(idotprecision &dp, const ivector & rv1, const l_ivector &rv2)
03308 #if(CXSC_INDEX_CHECK)
03309         throw(OP_WITH_WRONG_DIM);
03310 #else
03311         throw();
03312 #endif
03313 
03314         INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const ivector &rv2)
03315 #if(CXSC_INDEX_CHECK)
03316         throw(OP_WITH_WRONG_DIM);
03317 #else
03318         throw();
03319 #endif
03320 
03321         INLINE void accumulate(idotprecision &dp, const ivector_slice & sl, const l_ivector &rv)
03322 #if(CXSC_INDEX_CHECK)
03323         throw(OP_WITH_WRONG_DIM);
03324 #else
03325         throw();
03326 #endif
03327 
03328         INLINE void accumulate(idotprecision &dp,const l_ivector_slice &sl,const ivector &rv)
03329 #if(CXSC_INDEX_CHECK)
03330         throw(OP_WITH_WRONG_DIM);
03331 #else
03332         throw();
03333 #endif
03334 
03335         INLINE void accumulate(idotprecision &dp, const ivector &rv, const l_ivector_slice &sl)
03336 #if(CXSC_INDEX_CHECK)
03337         throw(OP_WITH_WRONG_DIM);
03338 #else
03339         throw();
03340 #endif
03341 
03342         INLINE void accumulate(idotprecision &dp, const ivector & rv1, const l_imatrix_subv &rv2)
03343 #if(CXSC_INDEX_CHECK)
03344         throw(OP_WITH_WRONG_DIM);
03345 #else
03346         throw();
03347 #endif
03348 
03349         INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const imatrix_subv &rv2)
03350 #if(CXSC_INDEX_CHECK)
03351         throw(OP_WITH_WRONG_DIM);
03352 #else
03353         throw();
03354 #endif
03355 
03356         INLINE void accumulate(idotprecision &dp,const l_ivector &rv,const ivector_slice &sl)
03357 #if(CXSC_INDEX_CHECK)
03358         throw(OP_WITH_WRONG_DIM);
03359 #else
03360         throw();
03361 #endif
03362 
03363         INLINE void accumulate(idotprecision &dp, const imatrix_subv & rv1, const l_ivector &rv2)
03364 #if(CXSC_INDEX_CHECK)
03365         throw(OP_WITH_WRONG_DIM);
03366 #else
03367         throw();
03368 #endif
03369 
03370         INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const ivector &rv2)
03371 #if(CXSC_INDEX_CHECK)
03372         throw(OP_WITH_WRONG_DIM);
03373 #else
03374         throw();
03375 #endif
03376 
03377         INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl1, const ivector_slice &sl2)
03378 #if(CXSC_INDEX_CHECK)
03379         throw(OP_WITH_WRONG_DIM);
03380 #else
03381         throw();
03382 #endif
03383 
03384         INLINE void accumulate(idotprecision &dp, const ivector_slice & sl1, const l_ivector_slice &sl2)
03385 #if(CXSC_INDEX_CHECK)
03386         throw(OP_WITH_WRONG_DIM);
03387 #else
03388         throw();
03389 #endif
03390 
03392         INLINE l_interval operator *(const ivector & rv1, const l_ivector &rv2)
03393 #if(CXSC_INDEX_CHECK)
03394         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03395 #else
03396         throw();
03397 #endif
03398 
03399         INLINE l_interval operator *(const ivector_slice &sl, const l_ivector &rv)
03400 #if(CXSC_INDEX_CHECK)
03401         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03402 #else
03403         throw();
03404 #endif
03405 
03406         INLINE l_interval operator *(const ivector &rv, const l_ivector_slice &sl)
03407 #if(CXSC_INDEX_CHECK)
03408         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03409 #else
03410         throw();
03411 #endif
03412 
03413         INLINE l_interval operator *(const ivector_slice & sl1, const l_ivector_slice &sl2)
03414 #if(CXSC_INDEX_CHECK)
03415         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03416 #else
03417         throw();
03418 #endif
03419         
03421         INLINE l_interval operator *(const l_ivector & rv1, const ivector &rv2)
03422 #if(CXSC_INDEX_CHECK)
03423         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03424 #else
03425         throw();
03426 #endif
03427 
03428         INLINE l_interval operator *(const l_ivector_slice &sl, const ivector &rv)
03429 #if(CXSC_INDEX_CHECK)
03430         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03431 #else
03432         throw();
03433 #endif
03434 
03435         INLINE l_interval operator *(const l_ivector &rv, const ivector_slice &sl)
03436 #if(CXSC_INDEX_CHECK)
03437         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03438 #else
03439         throw();
03440 #endif
03441 
03442         INLINE l_interval operator *(const l_ivector_slice & sl1, const ivector_slice &sl2)
03443 #if(CXSC_INDEX_CHECK)
03444         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03445 #else
03446         throw();
03447 #endif
03448         
03450         INLINE l_ivector operator +(const ivector &rv1, const l_ivector &rv2)
03451 #if(CXSC_INDEX_CHECK)
03452         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03453 #else
03454         throw();
03455 #endif
03456 
03457         INLINE l_ivector operator +(const ivector &rv, const l_ivector_slice &sl)
03458 #if(CXSC_INDEX_CHECK)
03459         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03460 #else
03461         throw();
03462 #endif
03463 
03464         INLINE l_ivector operator +(const ivector_slice &sl, const l_ivector &rv)
03465 #if(CXSC_INDEX_CHECK)
03466         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03467 #else
03468         throw();
03469 #endif
03470 
03471         INLINE l_ivector operator +(const ivector_slice &sl1, const l_ivector_slice &sl2)
03472 #if(CXSC_INDEX_CHECK)
03473         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03474 #else
03475         throw();
03476 #endif
03477 
03479         INLINE l_ivector operator +(const l_ivector &rv1, const ivector &rv2)
03480 #if(CXSC_INDEX_CHECK)
03481         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03482 #else
03483         throw();
03484 #endif
03485 
03486         INLINE l_ivector operator +(const l_ivector &rv, const ivector_slice &sl)
03487 #if(CXSC_INDEX_CHECK)
03488         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03489 #else
03490         throw();
03491 #endif
03492 
03493         INLINE l_ivector operator +(const l_ivector_slice &sl, const ivector &rv)
03494 #if(CXSC_INDEX_CHECK)
03495         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03496 #else
03497         throw();
03498 #endif
03499 
03500         INLINE l_ivector operator +(const l_ivector_slice &sl1, const ivector_slice &sl2)
03501 #if(CXSC_INDEX_CHECK)
03502         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03503 #else
03504         throw();
03505 #endif
03506 
03508         INLINE l_ivector & operator +=(l_ivector &rv1, const ivector &rv2)
03509 #if(CXSC_INDEX_CHECK)
03510         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03511 #else
03512         throw();
03513 #endif
03514 
03515         INLINE l_ivector &operator +=(l_ivector &rv, const ivector_slice &sl)
03516 #if(CXSC_INDEX_CHECK)
03517         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03518 #else
03519         throw();
03520 #endif
03521 
03523         INLINE l_ivector operator -(const ivector &rv1, const l_ivector &rv2)
03524 #if(CXSC_INDEX_CHECK)
03525         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03526 #else
03527         throw();
03528 #endif
03529 
03530         INLINE l_ivector operator -(const ivector &rv, const l_ivector_slice &sl)
03531 #if(CXSC_INDEX_CHECK)
03532         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03533 #else
03534         throw();
03535 #endif
03536 
03537         INLINE l_ivector operator -(const ivector_slice &sl, const l_ivector &rv)
03538 #if(CXSC_INDEX_CHECK)
03539         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03540 #else
03541         throw();
03542 #endif
03543 
03544         INLINE l_ivector operator -(const ivector_slice &sl1, const l_ivector_slice &sl2)
03545 #if(CXSC_INDEX_CHECK)
03546         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03547 #else
03548         throw();
03549 #endif
03550 
03552         INLINE l_ivector operator -(const l_ivector &rv1, const ivector &rv2)
03553 #if(CXSC_INDEX_CHECK)
03554         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03555 #else
03556         throw();
03557 #endif
03558 
03559         INLINE l_ivector operator -(const l_ivector &rv, const ivector_slice &sl)
03560 #if(CXSC_INDEX_CHECK)
03561         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03562 #else
03563         throw();
03564 #endif
03565 
03566         INLINE l_ivector operator -(const l_ivector_slice &sl, const ivector &rv)
03567 #if(CXSC_INDEX_CHECK)
03568         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03569 #else
03570         throw();
03571 #endif
03572 
03573         INLINE l_ivector operator -(const l_ivector_slice &sl1, const ivector_slice &sl2)
03574 #if(CXSC_INDEX_CHECK)
03575         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03576 #else
03577         throw();
03578 #endif
03579 
03581         INLINE l_ivector & operator -=(l_ivector &rv1, const ivector &rv2)
03582 #if(CXSC_INDEX_CHECK)
03583         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03584 #else
03585         throw();
03586 #endif
03587 
03588         INLINE l_ivector &operator -=(l_ivector &rv, const ivector_slice &sl)
03589 #if(CXSC_INDEX_CHECK)
03590         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03591 #else
03592         throw();
03593 #endif
03594 
03596         INLINE l_ivector operator |(const ivector &rv1, const l_ivector &rv2)
03597 #if(CXSC_INDEX_CHECK)
03598         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03599 #else
03600         throw();
03601 #endif
03602 
03603         INLINE l_ivector operator |(const ivector &rv, const l_ivector_slice &sl)
03604 #if(CXSC_INDEX_CHECK)
03605         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03606 #else
03607         throw();
03608 #endif
03609 
03610         INLINE l_ivector operator |(const ivector_slice &sl, const l_ivector &rv)
03611 #if(CXSC_INDEX_CHECK)
03612         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03613 #else
03614         throw();
03615 #endif
03616 
03617         INLINE l_ivector operator |(const ivector_slice &sl1, const l_ivector_slice &sl2)
03618 #if(CXSC_INDEX_CHECK)
03619         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03620 #else
03621         throw();
03622 #endif
03623 
03625         INLINE l_ivector operator |(const l_ivector &rv1, const ivector &rv2)
03626 #if(CXSC_INDEX_CHECK)
03627         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03628 #else
03629         throw();
03630 #endif
03631 
03632         INLINE l_ivector operator |(const l_ivector &rv, const ivector_slice &sl)
03633 #if(CXSC_INDEX_CHECK)
03634         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03635 #else
03636         throw();
03637 #endif
03638 
03639         INLINE l_ivector operator |(const l_ivector_slice &sl, const ivector &rv)
03640 #if(CXSC_INDEX_CHECK)
03641         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03642 #else
03643         throw();
03644 #endif
03645 
03646         INLINE l_ivector operator |(const l_ivector_slice &sl1, const ivector_slice &sl2)
03647 #if(CXSC_INDEX_CHECK)
03648         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03649 #else
03650         throw();
03651 #endif
03652 
03654         INLINE l_ivector & operator |=(l_ivector &rv1, const ivector &rv2)
03655 #if(CXSC_INDEX_CHECK)
03656         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03657 #else
03658         throw();
03659 #endif
03660 
03661         INLINE l_ivector &operator |=(l_ivector &rv, const ivector_slice &sl)
03662 #if(CXSC_INDEX_CHECK)
03663         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03664 #else
03665         throw();
03666 #endif
03667 
03669         INLINE l_ivector operator &(const ivector &rv1, const l_ivector &rv2)
03670 #if(CXSC_INDEX_CHECK)
03671         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03672 #else
03673         throw();
03674 #endif
03675 
03676         INLINE l_ivector operator &(const ivector &rv, const l_ivector_slice &sl)
03677 #if(CXSC_INDEX_CHECK)
03678         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03679 #else
03680         throw();
03681 #endif
03682 
03683         INLINE l_ivector operator &(const ivector_slice &sl, const l_ivector &rv)
03684 #if(CXSC_INDEX_CHECK)
03685         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03686 #else
03687         throw();
03688 #endif
03689 
03690         INLINE l_ivector operator &(const ivector_slice &sl1, const l_ivector_slice &sl2)
03691 #if(CXSC_INDEX_CHECK)
03692         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03693 #else
03694         throw();
03695 #endif
03696 
03698         INLINE l_ivector operator &(const l_ivector &rv1, const ivector &rv2)
03699 #if(CXSC_INDEX_CHECK)
03700         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03701 #else
03702         throw();
03703 #endif
03704 
03705         INLINE l_ivector operator &(const l_ivector &rv, const ivector_slice &sl)
03706 #if(CXSC_INDEX_CHECK)
03707         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03708 #else
03709         throw();
03710 #endif
03711 
03712         INLINE l_ivector operator &(const l_ivector_slice &sl, const ivector &rv)
03713 #if(CXSC_INDEX_CHECK)
03714         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03715 #else
03716         throw();
03717 #endif
03718 
03719         INLINE l_ivector operator &(const l_ivector_slice &sl1, const ivector_slice &sl2)
03720 #if(CXSC_INDEX_CHECK)
03721         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03722 #else
03723         throw();
03724 #endif
03725 
03727         INLINE l_ivector & operator &=(l_ivector &rv1, const ivector &rv2)
03728 #if(CXSC_INDEX_CHECK)
03729         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03730 #else
03731         throw();
03732 #endif
03733 
03734         INLINE l_ivector &operator &=(l_ivector &rv, const ivector_slice &sl)
03735 #if(CXSC_INDEX_CHECK)
03736         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03737 #else
03738         throw();
03739 #endif
03740 
03741 //------------- real x l_real ------------------------
03743         INLINE l_ivector operator |(const rvector &rv1, const l_rvector &rv2)
03744 #if(CXSC_INDEX_CHECK)
03745         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03746 #else
03747         throw();
03748 #endif
03749 
03750         INLINE l_ivector operator |(const l_rvector &rv1, const rvector &rv2)
03751 #if(CXSC_INDEX_CHECK)
03752         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03753 #else
03754         throw();
03755 #endif
03756 
03757         INLINE l_ivector operator |(const l_rvector &rv, const rvector_slice &sl)
03758 #if(CXSC_INDEX_CHECK)
03759         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03760 #else
03761         throw();
03762 #endif
03763 
03764         INLINE l_ivector operator |(const rvector_slice &sl,const l_rvector &rv)
03765 #if(CXSC_INDEX_CHECK)
03766         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03767 #else
03768         throw();
03769 #endif
03770 
03771         INLINE l_ivector operator |(const l_rvector_slice &sl, const rvector &rv)
03772 #if(CXSC_INDEX_CHECK)
03773         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03774 #else
03775         throw();
03776 #endif
03777 
03778         INLINE l_ivector operator |(const rvector &rv,const l_rvector_slice &sl)
03779 #if(CXSC_INDEX_CHECK)
03780         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03781 #else
03782         throw();
03783 #endif
03784 
03785         INLINE l_ivector operator |(const l_rvector_slice &sl1, const rvector_slice &sl2)
03786 #if(CXSC_INDEX_CHECK)
03787         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03788 #else
03789         throw();
03790 #endif
03791 
03792         INLINE l_ivector operator |(const rvector_slice &sl1, const l_rvector_slice &sl2)
03793 #if(CXSC_INDEX_CHECK)
03794         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03795 #else
03796         throw();
03797 #endif
03798 
03799 //------------- l_real x l_real ------------------------
03801         INLINE l_ivector operator |(const l_rvector &rv1, const l_rvector &rv2)
03802 #if(CXSC_INDEX_CHECK)
03803         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03804 #else
03805         throw();
03806 #endif
03807 
03808         INLINE l_ivector operator |(const l_rvector_slice &sl, const l_rvector &rv)
03809 #if(CXSC_INDEX_CHECK)
03810         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03811 #else
03812         throw();
03813 #endif
03814 
03815         INLINE l_ivector operator |(const l_rvector &rv,const l_rvector_slice &sl)
03816 #if(CXSC_INDEX_CHECK)
03817         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03818 #else
03819         throw();
03820 #endif
03821 
03822         INLINE l_ivector operator |(const l_rvector_slice &sl1, const l_rvector_slice &sl2)
03823 #if(CXSC_INDEX_CHECK)
03824         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03825 #else
03826         throw();
03827 #endif
03828 
03829 //-------------------------------- interval / l_real --------------------------------
03830 
03831         // multiplication in lrvecivec.hpp
03832         
03834         INLINE l_ivector operator +(const l_rvector &rv1, const ivector &rv2)
03835 #if(CXSC_INDEX_CHECK)
03836         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03837 #else
03838         throw();
03839 #endif
03840 
03841         INLINE l_ivector operator +(const l_rvector &rv, const ivector_slice &sl)
03842 #if(CXSC_INDEX_CHECK)
03843         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03844 #else
03845         throw();
03846 #endif
03847 
03848         INLINE l_ivector operator +(const l_rvector_slice &sl, const ivector &rv)
03849 #if(CXSC_INDEX_CHECK)
03850         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03851 #else
03852         throw();
03853 #endif
03854 
03855         INLINE l_ivector operator +(const l_rvector_slice &sl1, const ivector_slice &sl2)
03856 #if(CXSC_INDEX_CHECK)
03857         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03858 #else
03859         throw();
03860 #endif
03861 
03863         INLINE l_ivector operator +(const ivector &rv1, const l_rvector &rv2)
03864 #if(CXSC_INDEX_CHECK)
03865         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03866 #else
03867         throw();
03868 #endif
03869 
03870         INLINE l_ivector operator +(const ivector &rv, const l_rvector_slice &sl)
03871 #if(CXSC_INDEX_CHECK)
03872         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03873 #else
03874         throw();
03875 #endif
03876 
03877         INLINE l_ivector operator +(const ivector_slice &sl, const l_rvector &rv)
03878 #if(CXSC_INDEX_CHECK)
03879         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03880 #else
03881         throw();
03882 #endif
03883 
03884         INLINE l_ivector operator +(const ivector_slice &sl1, const l_rvector_slice &sl2)
03885 #if(CXSC_INDEX_CHECK)
03886         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03887 #else
03888         throw();
03889 #endif
03890 
03891 
03893         INLINE l_ivector operator -(const l_rvector &rv1, const ivector &rv2)
03894 #if(CXSC_INDEX_CHECK)
03895         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03896 #else
03897         throw();
03898 #endif
03899 
03900         INLINE l_ivector operator -(const l_rvector &rv, const ivector_slice &sl)
03901 #if(CXSC_INDEX_CHECK)
03902         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03903 #else
03904         throw();
03905 #endif
03906 
03907         INLINE l_ivector operator -(const l_rvector_slice &sl, const ivector &rv)
03908 #if(CXSC_INDEX_CHECK)
03909         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03910 #else
03911         throw();
03912 #endif
03913 
03914         INLINE l_ivector operator -(const l_rvector_slice &sl1, const ivector_slice &sl2)
03915 #if(CXSC_INDEX_CHECK)
03916         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03917 #else
03918         throw();
03919 #endif
03920 
03922         INLINE l_ivector operator -(const ivector &rv1, const l_rvector &rv2)
03923 #if(CXSC_INDEX_CHECK)
03924         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03925 #else
03926         throw();
03927 #endif
03928 
03929         INLINE l_ivector operator -(const ivector &rv, const l_rvector_slice &sl)
03930 #if(CXSC_INDEX_CHECK)
03931         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03932 #else
03933         throw();
03934 #endif
03935 
03936         INLINE l_ivector operator -(const ivector_slice &sl, const l_rvector &rv)
03937 #if(CXSC_INDEX_CHECK)
03938         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03939 #else
03940         throw();
03941 #endif
03942 
03943         INLINE l_ivector operator -(const ivector_slice &sl1, const l_rvector_slice &sl2)
03944 #if(CXSC_INDEX_CHECK)
03945         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03946 #else
03947         throw();
03948 #endif
03949 
03950 
03952         INLINE l_ivector operator |(const l_rvector &rv1, const ivector &rv2)
03953 #if(CXSC_INDEX_CHECK)
03954         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03955 #else
03956         throw();
03957 #endif
03958 
03959         INLINE l_ivector operator |(const l_rvector &rv, const ivector_slice &sl)
03960 #if(CXSC_INDEX_CHECK)
03961         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03962 #else
03963         throw();
03964 #endif
03965 
03966         INLINE l_ivector operator |(const l_rvector_slice &sl, const ivector &rv)
03967 #if(CXSC_INDEX_CHECK)
03968         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03969 #else
03970         throw();
03971 #endif
03972 
03973         INLINE l_ivector operator |(const l_rvector_slice &sl1, const ivector_slice &sl2)
03974 #if(CXSC_INDEX_CHECK)
03975         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03976 #else
03977         throw();
03978 #endif
03979 
03981         INLINE l_ivector operator |(const ivector &rv1, const l_rvector &rv2)
03982 #if(CXSC_INDEX_CHECK)
03983         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03984 #else
03985         throw();
03986 #endif
03987 
03988         INLINE l_ivector operator |(const ivector &rv, const l_rvector_slice &sl)
03989 #if(CXSC_INDEX_CHECK)
03990         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03991 #else
03992         throw();
03993 #endif
03994 
03995         INLINE l_ivector operator |(const ivector_slice &sl, const l_rvector &rv)
03996 #if(CXSC_INDEX_CHECK)
03997         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
03998 #else
03999         throw();
04000 #endif
04001 
04002         INLINE l_ivector operator |(const ivector_slice &sl1, const l_rvector_slice &sl2)
04003 #if(CXSC_INDEX_CHECK)
04004         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
04005 #else
04006         throw();
04007 #endif
04008 
04010         INLINE l_ivector operator &(const l_rvector &rv1, const ivector &rv2)
04011 #if(CXSC_INDEX_CHECK)
04012         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
04013 #else
04014         throw();
04015 #endif
04016 
04017         INLINE l_ivector operator &(const l_rvector &rv, const ivector_slice &sl)
04018 #if(CXSC_INDEX_CHECK)
04019         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
04020 #else
04021         throw();
04022 #endif
04023 
04024         INLINE l_ivector operator &(const l_rvector_slice &sl, const ivector &rv)
04025 #if(CXSC_INDEX_CHECK)
04026         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
04027 #else
04028         throw();
04029 #endif
04030 
04031         INLINE l_ivector operator &(const l_rvector_slice &sl1, const ivector_slice &sl2)
04032 #if(CXSC_INDEX_CHECK)
04033         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
04034 #else
04035         throw();
04036 #endif
04037 
04039         INLINE l_ivector operator &(const ivector &rv1, const l_rvector &rv2)
04040 #if(CXSC_INDEX_CHECK)
04041         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
04042 #else
04043         throw();
04044 #endif
04045 
04046         INLINE l_ivector operator &(const ivector &rv, const l_rvector_slice &sl)
04047 #if(CXSC_INDEX_CHECK)
04048         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
04049 #else
04050         throw();
04051 #endif
04052 
04053         INLINE l_ivector operator &(const ivector_slice &sl, const l_rvector &rv)
04054 #if(CXSC_INDEX_CHECK)
04055         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
04056 #else
04057         throw();
04058 #endif
04059 
04060         INLINE l_ivector operator &(const ivector_slice &sl1, const l_rvector_slice &sl2)
04061 #if(CXSC_INDEX_CHECK)
04062         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
04063 #else
04064         throw();
04065 #endif
04066 
04067 } // namespace cxsc 
04068 
04069 #ifdef _CXSC_INCL_INL
04070 #include "vector.inl"
04071 #include "l_ivector.inl"
04072 #endif
04073 
04074 #ifdef _CXSC_RMATRIX_HPP_INCLUDED
04075 # ifdef _CXSC_INCL_INL
04076 #  include "livecrmat.inl"
04077 # else
04078 #  include "livecrmat.hpp"
04079 # endif
04080 #endif
04081 
04082 #ifdef _CXSC_LRMATRIX_HPP_INCLUDED
04083 # ifdef _CXSC_INCL_INL
04084 #  include "liveclrmat.inl"
04085 # else
04086 #  include "liveclrmat.hpp"
04087 # endif
04088 #endif
04089 
04090 #ifdef _CXSC_IMATRIX_HPP_INCLUDED
04091 # ifdef _CXSC_INCL_INL
04092 #  include "livecimat.inl"
04093 # else
04094 #  include "livecimat.hpp"
04095 # endif
04096 #endif
04097 
04098 
04099 #endif
04100