C-XSC - A C++ Class Library for Extended Scientific Computing: civector.inl Source File

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