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