l_rvector.inl

00001 /*
00002 **  CXSC is a C++ library for eXtended Scientific Computing (V 2.5.1)
00003 **
00004 **  Copyright (C) 1990-2000 Institut fuer Angewandte Mathematik,
00005 **                          Universitaet Karlsruhe, Germany
00006 **            (C) 2000-2011 Wiss. Rechnen/Softwaretechnologie
00007 **                          Universitaet Wuppertal, Germany   
00008 **
00009 **  This library is free software; you can redistribute it and/or
00010 **  modify it under the terms of the GNU Library General Public
00011 **  License as published by the Free Software Foundation; either
00012 **  version 2 of the License, or (at your option) any later version.
00013 **
00014 **  This library is distributed in the hope that it will be useful,
00015 **  but WITHOUT ANY WARRANTY; without even the implied warranty of
00016 **  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00017 **  Library General Public License for more details.
00018 **
00019 **  You should have received a copy of the GNU Library General Public
00020 **  License along with this library; if not, write to the Free
00021 **  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00022 */
00023 
00024 /* CVS $Id: l_rvector.inl,v 1.15 2011/06/07 15:17:40 cxsc Exp $ */
00025 
00026 #ifndef _CXSC_LRVECTOR_INL_INCLUDED
00027 #define _CXSC_LRVECTOR_INL_INCLUDED
00028 
00029 namespace cxsc {
00030 
00031         INLINE l_rvector::l_rvector () throw():dat(NULL),l(1),u(0),size(0)
00032         {
00033         }
00034 
00035         INLINE l_rvector::l_rvector(const int &i) throw():l(1),u(i),size(i)
00036         {
00037                 dat=new l_real[i];
00038         }
00039 
00040 #ifdef OLD_CXSC
00041         INLINE l_rvector::l_rvector(const class index &i) throw():l(1),u(i._int()),size(i._int())
00042         {
00043                 dat=new l_real[i._int()];
00044         }
00045 #endif
00046 
00047         INLINE l_rvector::l_rvector(const int &i1,const int &i2)
00048 #if(CXSC_INDEX_CHECK)
00049                 throw(ERROR_LRVECTOR_WRONG_BOUNDARIES,ERROR_LRVECTOR_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_LRVECTOR_WRONG_BOUNDARIES("l_rvector::l_rvector(const int &i1,const int &i2)"));
00056 #endif
00057                 dat=new l_real[size];
00058         }
00059 
00060         INLINE l_rvector::l_rvector(const l_rvector_slice &rs) throw():l(rs.start),u(rs.end),size(rs.end-rs.start+1)
00061         {
00062                 dat=new l_real[size];
00063                 for(int i=0, j=l-rs.l;i<size;i++,j++)
00064                         dat[i]=rs.dat[j];
00065         }
00066 
00067         INLINE l_rvector::l_rvector(const l_rvector &v) throw():l(v.l),u(v.u),size(v.size)
00068         {
00069                 dat=new l_real[size];
00070                 for (int i=0;i<size;i++)
00071                         dat[i]=v.dat[i];
00072         }
00073 
00074         INLINE l_rvector::l_rvector(const l_real &r) throw():l(1),u(1),size(1)
00075         {
00076                 dat=new l_real[1];
00077                 *dat=r;
00078         }
00079         
00080         INLINE l_rvector::l_rvector(const rvector_slice &rs) throw():l(rs.start),u(rs.end),size(rs.end-rs.start+1)
00081         {
00082                 dat=new l_real[size];
00083                 for(int i=0, j=l-rs.l;i<size;i++,j++)
00084                         dat[i]=rs.dat[j];
00085         }
00086 
00087         INLINE l_rvector::l_rvector(const rvector &v) throw():l(v.l),u(v.u),size(v.size)
00088         {
00089                 dat=new l_real[size];
00090                 for (int i=0;i<size;i++)
00091                         dat[i]=v.dat[i];
00092         }
00093 
00094         INLINE l_rvector::l_rvector(const real &r) throw():l(1),u(1),size(1)
00095         {
00096                 dat=new l_real[1];
00097                 *dat=r;
00098         }
00099         
00100         INLINE l_real & l_rvector::operator [](const int &i) const
00101 #if(CXSC_INDEX_CHECK)
00102                 throw(ERROR_LRVECTOR_ELEMENT_NOT_IN_VEC)
00103 #else
00104         throw()
00105 #endif
00106         {
00107 #if(CXSC_INDEX_CHECK)
00108                 if(i<l||i>u) cxscthrow(ERROR_LRVECTOR_ELEMENT_NOT_IN_VEC("l_real & l_rvector::operator [](const int &i)"));
00109 #endif
00110                 return dat[i-l];
00111         }
00112         
00113         INLINE l_real & l_rvector_slice::operator [](const int &i) const
00114 #if(CXSC_INDEX_CHECK)
00115                 throw(ERROR_LRVECTOR_ELEMENT_NOT_IN_VEC)
00116 #else
00117         throw()
00118 #endif
00119         {
00120 #if(CXSC_INDEX_CHECK)
00121                 if(i<start||i>end) cxscthrow(ERROR_LRVECTOR_ELEMENT_NOT_IN_VEC("l_real & l_rvector_slice::operator [](const int &i)"));
00122 #endif
00123                 return dat[i-l];
00124         }
00125         
00126         INLINE l_rvector_slice l_rvector::operator ()(const int &i)
00127 #if(CXSC_INDEX_CHECK)
00128                 throw(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG)
00129 #else
00130         throw()
00131 #endif
00132         {
00133 #if(CXSC_INDEX_CHECK)
00134                 if(1<l||i>u) cxscthrow(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG("l_rvector_slice l_rvector::operator ()(const int &i)"));
00135 #endif
00136                 return l_rvector_slice(*this,1,i);
00137         }
00138         
00139    INLINE l_rvector_slice l_rvector::operator ()(const int &i1,const int &i2)
00140 #if(CXSC_INDEX_CHECK)
00141                 throw(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG)
00142 #else
00143         throw()
00144 #endif
00145         {
00146 #if(CXSC_INDEX_CHECK)
00147                 if(i1<l||i2>u) cxscthrow(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG("l_rvector_slice l_rvector::operator ()(const int &i1,const int &i2)"));
00148 #endif
00149                 return l_rvector_slice(*this,i1,i2);
00150         }
00151         
00152         INLINE l_rvector_slice l_rvector_slice::operator ()(const int &i)
00153 #if(CXSC_INDEX_CHECK)
00154                 throw(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG)
00155 #else
00156         throw()
00157 #endif
00158         {
00159 #if(CXSC_INDEX_CHECK)
00160                 if(1<start||i>end) cxscthrow(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG("l_rvector_slice l_rvector_slice::operator ()(const int &i)"));
00161 #endif
00162                 return l_rvector_slice(*this,1,i);
00163         }
00164         
00165    INLINE l_rvector_slice l_rvector_slice::operator ()(const int &i1,const int &i2)
00166 #if(CXSC_INDEX_CHECK)
00167                 throw(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG)
00168 #else
00169         throw()
00170 #endif
00171         {
00172 #if(CXSC_INDEX_CHECK)
00173                 if(i1<start||i2>end) cxscthrow(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG("l_rvector_slice l_rvector_slice::operator ()(const int &i1,const int &i2)"));
00174 #endif
00175                 return l_rvector_slice(*this,i1,i2);
00176         }
00177         
00178         INLINE l_real::l_real(const l_rvector &rv)
00179 #if(CXSC_INDEX_CHECK)
00180                 throw(ERROR_LRVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_LRVECTOR_USE_OF_UNINITIALIZED_OBJ)
00181 #else
00182         throw()
00183 #endif
00184         {
00185 #if(CXSC_INDEX_CHECK)
00186                 if(rv.size>1) cxscthrow(ERROR_LRVECTOR_TYPE_CAST_OF_THICK_OBJ("l_real::l_real(const l_rvector &rv)"));
00187                 else if(rv.size<1) cxscthrow(ERROR_LRVECTOR_USE_OF_UNINITIALIZED_OBJ("l_real::l_real(const l_rvector &rv)"));
00188 #endif
00189                 *this=rv.dat[0];
00190         }
00191         
00192         INLINE l_real::l_real(const l_rvector_slice &sl)
00193 #if(CXSC_INDEX_CHECK)
00194                 throw(ERROR_LRVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_LRVECTOR_USE_OF_UNINITIALIZED_OBJ)
00195 #else
00196         throw()
00197 #endif
00198         {
00199 #if(CXSC_INDEX_CHECK)
00200                 if(sl.size>1) cxscthrow(ERROR_LRVECTOR_TYPE_CAST_OF_THICK_OBJ("l_real::l_real(const l_rvector_slice &sl)"));
00201                 else if(sl.size<1) cxscthrow(ERROR_LRVECTOR_USE_OF_UNINITIALIZED_OBJ("l_real::l_real(const l_rvector_slice &sl)"));
00202 #endif
00203                 *this=sl.dat[sl.start-sl.l];
00204         }
00205         
00211         INLINE l_rvector _l_rvector(const l_real &r) throw() { return l_rvector(r); }
00217         INLINE l_rvector _l_rvector(const real &r) throw() { return l_rvector(r); }
00223         INLINE l_rvector _l_rvector(const rvector_slice &rs) throw() { return l_rvector(rs); }
00229         INLINE l_rvector _l_rvector(const rvector &rs) throw() { return l_rvector(rs); }
00235         INLINE l_rvector &l_rvector::operator =(const l_rvector &rv) throw() { return _vvassign<l_rvector,l_rvector,l_real>(*this,rv); }
00236         INLINE l_rvector &l_rvector::operator =(const l_real &r) throw() { return _vsassign<l_rvector,l_real>(*this,r); }
00237         INLINE l_rvector &l_rvector::operator =(const rvector &rv) throw() { return _vvassign<l_rvector,rvector,l_real>(*this,rv); }
00238         INLINE l_rvector &l_rvector::operator =(const real &r) throw() { return _vsassign<l_rvector,real>(*this,r); }
00239         INLINE l_rvector::operator void*() throw() { return _vvoid(*this); }
00240         INLINE l_rvector_slice & l_rvector_slice::operator =(const l_rvector_slice &sl)
00241 #if(CXSC_INDEX_CHECK)
00242         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00243 #else
00244         throw()
00245 #endif
00246         { return _vsvsassign(*this,sl); }
00247         INLINE l_rvector_slice & l_rvector_slice::operator =(const l_rvector &rv)
00248 #if(CXSC_INDEX_CHECK)
00249         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00250 #else
00251         throw()
00252 #endif
00253         { return _vsvassign(*this,rv); }
00254         INLINE l_rvector_slice & l_rvector_slice::operator =(const l_real &r) throw() { return _vssassign<l_rvector_slice,l_real>(*this,r); }
00255 
00256         INLINE l_rvector_slice & l_rvector_slice::operator =(const rvector_slice &sl)
00257 #if(CXSC_INDEX_CHECK)
00258         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00259 #else
00260         throw()
00261 #endif
00262         { return _vsvsassign(*this,sl); }
00263         INLINE l_rvector_slice & l_rvector_slice::operator =(const rvector &rv)
00264 #if(CXSC_INDEX_CHECK)
00265         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00266 #else
00267         throw()
00268 #endif
00269         { return _vsvassign(*this,rv); }
00270         INLINE l_rvector_slice & l_rvector_slice::operator =(const real &r) throw() { return _vssassign(*this,r); }
00271         INLINE l_rvector_slice::operator void*() throw() { return _vsvoid(*this); }
00272 
00273 //=======================================================================
00274 //======================== Vector Functions =============================
00275 
00276         INLINE void Resize(l_rvector &rv) throw() { _vresize(rv); } 
00277         INLINE void Resize(l_rvector &rv, const int &len)
00278 #if(CXSC_INDEX_CHECK)
00279         throw(ERROR__WRONG_BOUNDARIES<l_rvector>)
00280 #else
00281         throw()
00282 #endif
00283         { _vresize<class l_rvector,class l_real>(rv,len); }
00284         INLINE void Resize(l_rvector &rv, const int &lb, const int &ub)
00285 #if(CXSC_INDEX_CHECK)
00286         throw(ERROR__WRONG_BOUNDARIES<l_rvector>)
00287 #else
00288         throw()
00289 #endif
00290         { _vresize<class l_rvector,class l_real>(rv,lb,ub); }
00291         
00292         INLINE l_rvector abs(const l_rvector &rv) throw() { return _vabs<l_rvector,l_rvector>(rv); }
00293         INLINE l_rvector abs(const l_rvector_slice &sl) throw() { return _vsabs<l_rvector_slice,l_rvector>(sl); }
00294         INLINE bool operator !(const l_rvector &rv) throw() { return _vnot(rv); }
00295         INLINE bool operator !(const l_rvector_slice &sl) throw() { return _vsnot(sl); }
00296 
00297 //======================= Vector / Scalar ===============================
00298 
00299 //----------------------------- l_real ---------------------------
00300 
00301         INLINE l_rvector operator *(const l_rvector &rv, const l_real &s) throw() { return _vsmult<l_rvector,l_real,l_rvector>(rv,s); }
00302         INLINE l_rvector operator *(const l_rvector_slice &sl, const l_real &s) throw() { return _vssmult<l_rvector_slice,l_real,l_rvector>(sl,s); }
00303         INLINE l_rvector operator *(const l_real &s, const l_rvector &rv) throw() { return _vsmult<l_rvector,l_real,l_rvector>(rv,s); }
00304         INLINE l_rvector operator *(const l_real &s, const l_rvector_slice &sl) throw() { return _vssmult<l_rvector_slice,l_real,l_rvector>(sl,s); }
00305         INLINE l_rvector &operator *=(l_rvector &rv,const l_real &r) throw() { return _vsmultassign(rv,r); }
00306         INLINE l_rvector_slice &l_rvector_slice::operator *=(const l_real &r) throw() { return _vssmultassign(*this,r); }
00307 
00308         INLINE l_rvector operator /(const l_rvector &rv, const l_real &s) throw() { return _vsdiv<l_rvector,l_real,l_rvector>(rv,s); }
00309         INLINE l_rvector operator /(const l_rvector_slice &sl, const l_real &s) throw() { return _vssdiv<l_rvector_slice,l_real,l_rvector>(sl,s); }
00310         INLINE l_rvector &operator /=(l_rvector &rv,const l_real &r) throw() { return _vsdivassign(rv,r); }
00311         INLINE l_rvector_slice &l_rvector_slice::operator /=(const l_real &r) throw() { return _vssdivassign(*this,r); }
00312 
00313 //---------------------------- Real --------------------------------------
00314 
00315         INLINE l_rvector operator *(const l_rvector &rv, const real &s) throw() { return _vsmult<l_rvector,real,l_rvector>(rv,s); }
00316         INLINE l_rvector operator *(const l_rvector_slice &sl, const real &s) throw() { return _vssmult<l_rvector_slice,real,l_rvector>(sl,s); }
00317         INLINE l_rvector operator *(const real &s, const l_rvector &rv) throw() { return _vsmult<l_rvector,real,l_rvector>(rv,s); }
00318         INLINE l_rvector operator *(const real &s, const l_rvector_slice &sl) throw() { return _vssmult<l_rvector_slice,real,l_rvector>(sl,s); }
00319         INLINE l_rvector &operator *=(l_rvector &rv,const real &r) throw() { return _vsmultassign(rv,r); }
00320         INLINE l_rvector_slice &l_rvector_slice::operator *=(const real &r) throw() { return _vssmultassign(*this,r); }
00321 
00322         INLINE l_rvector operator /(const l_rvector &rv, const real &s) throw() { return _vsdiv<l_rvector,real,l_rvector>(rv,s); }
00323         INLINE l_rvector operator /(const l_rvector_slice &sl, const real &s) throw() { return _vssdiv<l_rvector_slice,real,l_rvector>(sl,s); }
00324         INLINE l_rvector &operator /=(l_rvector &rv,const real &r) throw() { return _vsdivassign(rv,r); }
00325         INLINE l_rvector_slice &l_rvector_slice::operator /=(const real &r) throw() { return _vssdivassign(*this,r); }
00326 
00327         INLINE l_rvector operator *(const rvector &rv, const l_real &s) throw() { return _vsmult<rvector,l_real,l_rvector>(rv,s); }
00328         INLINE l_rvector operator *(const rvector_slice &sl, const l_real &s) throw() { return _vssmult<rvector_slice,l_real,l_rvector>(sl,s); }
00329         INLINE l_rvector operator *(const l_real &s, const rvector &rv) throw() { return _vsmult<rvector,l_real,l_rvector>(rv,s); }
00330         INLINE l_rvector operator *(const l_real &s, const rvector_slice &sl) throw() { return _vssmult<rvector_slice,l_real,l_rvector>(sl,s); }
00331 
00332         INLINE l_rvector operator /(const rvector &rv, const l_real &s) throw() { return _vsdiv<rvector,l_real,l_rvector>(rv,s); }
00333         INLINE l_rvector operator /(const rvector_slice &sl, const l_real &s) throw() { return _vssdiv<rvector_slice,l_real,l_rvector>(sl,s); }
00334 
00335 //======================= Vector / Vector ===============================
00336 
00337 
00338         INLINE std::ostream &operator <<(std::ostream &s, const l_rvector &rv) throw() { return _vout(s,rv); }
00339         INLINE std::ostream &operator <<(std::ostream &o, const l_rvector_slice &sl) throw() { return _vsout(o,sl); }
00340         INLINE std::istream &operator >>(std::istream &s, l_rvector &rv) throw() { return _vin(s,rv); }
00341         INLINE std::istream &operator >>(std::istream &s, l_rvector_slice &rv) throw() { return _vsin(s,rv); }
00342         
00343 //----------------------- l_real / l_real ---------------------------
00344         INLINE l_rvector & l_rvector::operator =(const l_rvector_slice &sl) throw() { return _vvsassign<l_rvector,l_rvector_slice,l_real>(*this,sl); }
00345 
00346         INLINE void accumulate(dotprecision &dp, const l_rvector & rv1, const l_rvector &rv2)
00347 #if(CXSC_INDEX_CHECK)
00348         throw(OP_WITH_WRONG_DIM)
00349 #else
00350         throw()
00351 #endif
00352         { _vvaccu(dp,rv1,rv2); }
00353         INLINE void accumulate(dotprecision &dp, const l_rvector_slice & sl, const l_rvector &rv)
00354 #if(CXSC_INDEX_CHECK)
00355         throw(OP_WITH_WRONG_DIM)
00356 #else
00357         throw()
00358 #endif
00359         { _vsvaccu(dp,sl,rv); }
00360         INLINE void accumulate(dotprecision &dp, const l_rvector &rv, const l_rvector_slice &sl)
00361 #if(CXSC_INDEX_CHECK)
00362         throw(OP_WITH_WRONG_DIM)
00363 #else
00364         throw()
00365 #endif
00366         { _vsvaccu(dp,sl,rv); }
00367         INLINE void accumulate(dotprecision &dp, const l_rvector & rv1, const l_rmatrix_subv &rv2)
00368 #if(CXSC_INDEX_CHECK)
00369         throw(OP_WITH_WRONG_DIM)
00370 #else
00371         throw()
00372 #endif
00373         ;
00374         INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const l_rvector &rv2)
00375 #if(CXSC_INDEX_CHECK)
00376         throw(OP_WITH_WRONG_DIM)
00377 #else
00378         throw()
00379 #endif
00380         ;
00381         INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const l_rmatrix_subv &rv2)
00382 #if(CXSC_INDEX_CHECK)
00383         throw(OP_WITH_WRONG_DIM)
00384 #else
00385         throw()
00386 #endif
00387         ;
00388         INLINE void accumulate(dotprecision &dp, const l_rvector_slice & sl1, const l_rvector_slice &sl2)
00389 #if(CXSC_INDEX_CHECK)
00390         throw(OP_WITH_WRONG_DIM)
00391 #else
00392         throw()
00393 #endif
00394         { _vsvsaccu(dp,sl1,sl2); }
00395         INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const l_rvector &rv2)
00396 #if(CXSC_INDEX_CHECK)
00397         throw(OP_WITH_WRONG_DIM)
00398 #else
00399         throw()
00400 #endif
00401         { _vvaccu(dp,rv1,rv2); }
00402         INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl, const l_rvector &rv)
00403 #if(CXSC_INDEX_CHECK)
00404         throw(OP_WITH_WRONG_DIM)
00405 #else
00406         throw()
00407 #endif
00408         { _vsvaccu(dp,sl,rv); }
00409         INLINE void accumulate(idotprecision &dp, const l_rvector &rv, const l_rvector_slice &sl)
00410 #if(CXSC_INDEX_CHECK)
00411         throw(OP_WITH_WRONG_DIM)
00412 #else
00413         throw()
00414 #endif
00415         { _vsvaccu(dp,sl,rv); }
00416         INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const l_rmatrix_subv &rv2)
00417 #if(CXSC_INDEX_CHECK)
00418         throw(OP_WITH_WRONG_DIM)
00419 #else
00420         throw()
00421 #endif
00422         ;
00423         INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const l_rvector &rv2)
00424 #if(CXSC_INDEX_CHECK)
00425         throw(OP_WITH_WRONG_DIM)
00426 #else
00427         throw()
00428 #endif
00429         ;
00430         INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const l_rmatrix_subv &rv2)
00431 #if(CXSC_INDEX_CHECK)
00432         throw(OP_WITH_WRONG_DIM)
00433 #else
00434         throw()
00435 #endif
00436         ;
00437         INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl1, const l_rvector_slice &sl2)
00438 #if(CXSC_INDEX_CHECK)
00439         throw(OP_WITH_WRONG_DIM)
00440 #else
00441         throw()
00442 #endif
00443         { _vsvsaccu(dp,sl1,sl2); }
00444 
00445 
00446         INLINE l_real operator *(const l_rvector & rv1, const l_rvector &rv2)
00447 #if(CXSC_INDEX_CHECK)
00448         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00449 #else
00450         throw()
00451 #endif
00452         { return _vvlmult<l_rvector,l_rvector,l_real>(rv1,rv2); }
00453         INLINE l_real operator *(const l_rvector_slice &sl, const l_rvector &rv)
00454 #if(CXSC_INDEX_CHECK)
00455         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00456 #else
00457         throw()
00458 #endif
00459         { return _vsvlmult<l_rvector_slice,l_rvector,l_real>(sl,rv); }
00460         INLINE l_real operator *(const l_rvector &rv, const l_rvector_slice &sl)
00461 #if(CXSC_INDEX_CHECK)
00462         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00463 #else
00464         throw()
00465 #endif
00466         { return _vsvlmult<l_rvector_slice,l_rvector,l_real>(sl,rv); }
00467         INLINE l_real operator *(const l_rvector_slice & sl1, const l_rvector_slice &sl2)
00468 #if(CXSC_INDEX_CHECK)
00469         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00470 #else
00471         throw()
00472 #endif
00473         { return _vsvslmult<l_rvector_slice,l_rvector_slice,l_real>(sl1,sl2); }
00474         
00475         INLINE const l_rvector &operator +(const l_rvector &rv) throw() { return rv; }
00476         INLINE l_rvector operator +(const l_rvector_slice &sl) throw() { return sl; }
00477         INLINE l_rvector operator +(const l_rvector &rv1, const l_rvector &rv2)
00478 #if(CXSC_INDEX_CHECK)
00479         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00480 #else
00481         throw()
00482 #endif
00483         { return _vvplus<l_rvector,l_rvector,l_rvector>(rv1,rv2); }
00484         INLINE l_rvector operator +(const l_rvector &rv, const l_rvector_slice &sl)
00485 #if(CXSC_INDEX_CHECK)
00486         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00487 #else
00488         throw()
00489 #endif
00490         { return _vvsplus<l_rvector,l_rvector_slice,l_rvector>(rv,sl); }
00491         INLINE l_rvector operator +(const l_rvector_slice &sl, const l_rvector &rv)
00492 #if(CXSC_INDEX_CHECK)
00493         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00494 #else
00495         throw()
00496 #endif
00497         { return _vvsplus<l_rvector,l_rvector_slice,l_rvector>(rv,sl); }
00498         INLINE l_rvector operator +(const l_rvector_slice &sl1, const l_rvector_slice &sl2)
00499 #if(CXSC_INDEX_CHECK)
00500         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00501 #else
00502         throw()
00503 #endif
00504         { return _vsvsplus<l_rvector_slice,l_rvector_slice,l_rvector>(sl1,sl2); }
00505         INLINE l_rvector & operator +=(l_rvector &rv1, const l_rvector &rv2)
00506 #if(CXSC_INDEX_CHECK)
00507         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00508 #else
00509         throw()
00510 #endif
00511         { return _vvplusassign(rv1,rv2); }
00512         INLINE l_rvector &operator +=(l_rvector &rv, const l_rvector_slice &sl)
00513 #if(CXSC_INDEX_CHECK)
00514         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00515 #else
00516         throw()
00517 #endif
00518         { return _vvsplusassign(rv,sl); }
00519         INLINE l_rvector_slice &l_rvector_slice::operator +=(const l_rvector &rv)
00520 #if(CXSC_INDEX_CHECK)
00521         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00522 #else
00523         throw()
00524 #endif
00525         { return _vsvplusassign(*this,rv); }
00526         INLINE l_rvector_slice &l_rvector_slice::operator +=(const l_rvector_slice &sl2)
00527 #if(CXSC_INDEX_CHECK)
00528         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00529 #else
00530         throw()
00531 #endif
00532         { return _vsvsplusassign(*this,sl2); }
00533 
00534         INLINE l_rvector operator -(const l_rvector &rv) throw() { return _vminus(rv); }
00535         INLINE l_rvector operator -(const l_rvector_slice &sl) throw() { return _vsminus<l_rvector_slice,l_rvector>(sl); }
00536         INLINE l_rvector operator -(const l_rvector &rv1, const l_rvector &rv2)
00537 #if(CXSC_INDEX_CHECK)
00538         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00539 #else
00540         throw()
00541 #endif
00542         { return _vvminus<l_rvector,l_rvector,l_rvector>(rv1,rv2); }
00543         INLINE l_rvector operator -(const l_rvector &rv, const l_rvector_slice &sl)
00544 #if(CXSC_INDEX_CHECK)
00545         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00546 #else
00547         throw()
00548 #endif
00549         { return _vvsminus<l_rvector,l_rvector_slice,l_rvector>(rv,sl); }
00550         INLINE l_rvector operator -(const l_rvector_slice &sl, const l_rvector &rv)
00551 #if(CXSC_INDEX_CHECK)
00552         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00553 #else
00554         throw()
00555 #endif
00556         { return _vsvminus<l_rvector_slice,l_rvector,l_rvector>(sl,rv); }
00557         INLINE l_rvector operator -(const l_rvector_slice &sl1, const l_rvector_slice &sl2)
00558 #if(CXSC_INDEX_CHECK)
00559         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00560 #else
00561         throw()
00562 #endif
00563         { return _vsvsminus<l_rvector_slice,l_rvector_slice,l_rvector>(sl1,sl2); }
00564         INLINE l_rvector & operator -=(l_rvector &rv1, const l_rvector &rv2)
00565 #if(CXSC_INDEX_CHECK)
00566         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00567 #else
00568         throw()
00569 #endif
00570         { return _vvminusassign(rv1,rv2); }
00571         INLINE l_rvector &operator -=(l_rvector &rv, const l_rvector_slice &sl)
00572 #if(CXSC_INDEX_CHECK)
00573         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00574 #else
00575         throw()
00576 #endif
00577         { return _vvsminusassign(rv,sl); }
00578         INLINE l_rvector_slice &l_rvector_slice::operator -=(const l_rvector &rv)
00579 #if(CXSC_INDEX_CHECK)
00580         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00581 #else
00582         throw()
00583 #endif
00584         { return _vsvminusassign(*this,rv); }
00585         INLINE l_rvector_slice &l_rvector_slice::operator -=(const l_rvector_slice &sl2)
00586 #if(CXSC_INDEX_CHECK)
00587         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00588 #else
00589         throw()
00590 #endif
00591         { return _vsvsminusassign(*this,sl2); }
00592 
00593         INLINE bool operator ==(const l_rvector &rv1, const l_rvector &rv2) throw() { return _vveq(rv1,rv2); }
00594         INLINE bool operator ==(const l_rvector_slice &sl1, const l_rvector_slice &sl2) throw() { return _vsvseq(sl1,sl2); }
00595         INLINE bool operator ==(const l_rvector_slice &sl, const l_rvector &rv) throw() { return _vsveq(sl,rv); }
00596         INLINE bool operator ==(const l_rvector &rv, const l_rvector_slice &sl) throw() { return _vsveq(sl,rv); }
00597         INLINE bool operator !=(const l_rvector &rv1, const l_rvector &rv2) throw() { return _vvneq(rv1,rv2); }
00598         INLINE bool operator !=(const l_rvector_slice &sl1, const l_rvector_slice &sl2) throw() { return _vsvsneq(sl1,sl2); }
00599         INLINE bool operator !=(const l_rvector_slice &sl, const l_rvector &rv) throw() { return _vsvneq(sl,rv); }
00600         INLINE bool operator !=(const l_rvector &rv, const l_rvector_slice &sl) throw() { return _vsvneq(sl,rv); }
00601         INLINE bool operator <(const l_rvector &rv1, const l_rvector &rv2) throw() { return _vvless(rv1,rv2); }
00602         INLINE bool operator <(const l_rvector_slice &sl1, const l_rvector_slice &sl2) throw() { return _vsvsless(sl1,sl2); }
00603         INLINE bool operator < (const l_rvector_slice &sl, const l_rvector &rv) throw() { return _vsvless(sl,rv); }
00604         INLINE bool operator < (const l_rvector &rv, const l_rvector_slice &sl) throw() { return _vvsless(rv,sl); }
00605         INLINE bool operator <=(const l_rvector &rv1, const l_rvector &rv2) throw() { return _vvleq(rv1,rv2); }
00606         INLINE bool operator <=(const l_rvector_slice &sl1, const l_rvector_slice &sl2) throw() { return _vsvsleq(sl1,sl2); }
00607         INLINE bool operator <=(const l_rvector_slice &sl, const l_rvector &rv) throw() { return _vsvleq(sl,rv); }
00608         INLINE bool operator <=(const l_rvector &rv, const l_rvector_slice &sl) throw() { return _vvsleq(rv,sl); }
00609         INLINE bool operator >(const l_rvector &rv1, const l_rvector &rv2) throw() { return _vvless(rv2,rv1); }
00610         INLINE bool operator >(const l_rvector_slice &sl1, const l_rvector_slice &sl2) throw() { return _vsvsless(sl2,sl1); }
00611         INLINE bool operator >(const l_rvector_slice &sl, const l_rvector &rv) throw() { return _vvsless(rv,sl); }
00612         INLINE bool operator >(const l_rvector &rv, const l_rvector_slice &sl) throw() { return _vsvless(sl,rv); }
00613         INLINE bool operator >=(const l_rvector &rv1, const l_rvector &rv2) throw() { return _vvleq(rv2,rv1); }
00614         INLINE bool operator >=(const l_rvector_slice &sl1, const l_rvector_slice &sl2) throw() { return _vsvsleq(sl2,sl1); }
00615         INLINE bool operator >=(const l_rvector_slice &sl, const l_rvector &rv) throw() { return _vvsleq(rv,sl); }
00616         INLINE bool operator >=(const l_rvector &rv, const l_rvector_slice &sl) throw() { return _vsvleq(sl,rv); }
00617 
00618 //-------------------------------- l_real / Real --------------------------------
00619 
00620         INLINE l_rvector & l_rvector::operator =(const rvector_slice &sl) throw() { return _vvsassign<l_rvector,rvector_slice,l_real>(*this,sl); }
00621 
00622         INLINE void accumulate(dotprecision &dp, const l_rvector & rv1, const rvector &rv2)
00623 #if(CXSC_INDEX_CHECK)
00624         throw(OP_WITH_WRONG_DIM)
00625 #else
00626         throw()
00627 #endif
00628         { _vvaccu(dp,rv2,rv1); }
00629         INLINE void accumulate(dotprecision &dp, const rvector & rv1, const l_rvector &rv2)
00630 #if(CXSC_INDEX_CHECK)
00631         throw(OP_WITH_WRONG_DIM)
00632 #else
00633         throw()
00634 #endif
00635         { _vvaccu(dp,rv1,rv2); }
00636         INLINE void accumulate(dotprecision &dp, const rvector_slice & sl, const l_rvector &rv)
00637 #if(CXSC_INDEX_CHECK)
00638         throw(OP_WITH_WRONG_DIM)
00639 #else
00640         throw()
00641 #endif
00642         { _vsvaccu(dp,sl,rv); }
00643         INLINE void accumulate(dotprecision &dp,const l_rvector_slice &sl,const rvector &rv)
00644 #if(CXSC_INDEX_CHECK)
00645         throw(OP_WITH_WRONG_DIM)
00646 #else
00647         throw()
00648 #endif
00649         { _vsvaccu(dp,sl,rv); }
00650         INLINE void accumulate(dotprecision &dp, const rvector &rv, const l_rvector_slice &sl)
00651 #if(CXSC_INDEX_CHECK)
00652         throw(OP_WITH_WRONG_DIM)
00653 #else
00654         throw()
00655 #endif
00656         { _vsvaccu(dp,sl,rv); }
00657         INLINE void accumulate(dotprecision &dp, const rvector & rv1, const l_rmatrix_subv &rv2)
00658 #if(CXSC_INDEX_CHECK)
00659         throw(OP_WITH_WRONG_DIM)
00660 #else
00661         throw()
00662 #endif
00663         ;
00664         INLINE void accumulate(dotprecision &dp, const l_rvector & rv1, const rmatrix_subv &rv2)
00665 #if(CXSC_INDEX_CHECK)
00666         throw(OP_WITH_WRONG_DIM)
00667 #else
00668         throw()
00669 #endif
00670         ;
00671         INLINE void accumulate(dotprecision &dp,const l_rvector &rv,const rvector_slice &sl)
00672 #if(CXSC_INDEX_CHECK)
00673         throw(OP_WITH_WRONG_DIM)
00674 #else
00675         throw()
00676 #endif
00677         { _vsvaccu(dp,sl,rv); }
00678         INLINE void accumulate(dotprecision &dp, const rmatrix_subv & rv1, const l_rvector &rv2)
00679 #if(CXSC_INDEX_CHECK)
00680         throw(OP_WITH_WRONG_DIM)
00681 #else
00682         throw()
00683 #endif
00684         ;
00685         INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const rvector &rv2)
00686 #if(CXSC_INDEX_CHECK)
00687         throw(OP_WITH_WRONG_DIM)
00688 #else
00689         throw()
00690 #endif
00691         ;
00692         INLINE void accumulate(dotprecision &dp, const rmatrix_subv & rv1, const l_rmatrix_subv &rv2)
00693 #if(CXSC_INDEX_CHECK)
00694         throw(OP_WITH_WRONG_DIM)
00695 #else
00696         throw()
00697 #endif
00698         ;
00699         INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const rmatrix_subv &rv2)
00700 #if(CXSC_INDEX_CHECK)
00701         throw(OP_WITH_WRONG_DIM)
00702 #else
00703         throw()
00704 #endif
00705         ;
00706         INLINE void accumulate(dotprecision &dp, const l_rvector_slice & sl1, const rvector_slice &sl2)
00707 #if(CXSC_INDEX_CHECK)
00708         throw(OP_WITH_WRONG_DIM)
00709 #else
00710         throw()
00711 #endif
00712         { _vsvsaccu(dp,sl2,sl1); }
00713         INLINE void accumulate(dotprecision &dp, const rvector_slice & sl1, const l_rvector_slice &sl2)
00714 #if(CXSC_INDEX_CHECK)
00715         throw(OP_WITH_WRONG_DIM)
00716 #else
00717         throw()
00718 #endif
00719         { _vsvsaccu(dp,sl1,sl2); }
00720 
00721         INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const rvector &rv2)
00722 #if(CXSC_INDEX_CHECK)
00723         throw(OP_WITH_WRONG_DIM)
00724 #else
00725         throw()
00726 #endif
00727         { _vvaccu(dp,rv2,rv1); }
00728         INLINE void accumulate(idotprecision &dp, const rvector & rv1, const l_rvector &rv2)
00729 #if(CXSC_INDEX_CHECK)
00730         throw(OP_WITH_WRONG_DIM)
00731 #else
00732         throw()
00733 #endif
00734         { _vvaccu(dp,rv1,rv2); }
00735         INLINE void accumulate(idotprecision &dp, const rvector_slice & sl, const l_rvector &rv)
00736 #if(CXSC_INDEX_CHECK)
00737         throw(OP_WITH_WRONG_DIM)
00738 #else
00739         throw()
00740 #endif
00741         { _vsvaccu(dp,sl,rv); }
00742         INLINE void accumulate(idotprecision &dp,const l_rvector_slice &sl,const rvector &rv)
00743 #if(CXSC_INDEX_CHECK)
00744         throw(OP_WITH_WRONG_DIM)
00745 #else
00746         throw()
00747 #endif
00748         { _vsvaccu(dp,sl,rv); }
00749         INLINE void accumulate(idotprecision &dp, const rvector &rv, const l_rvector_slice &sl)
00750 #if(CXSC_INDEX_CHECK)
00751         throw(OP_WITH_WRONG_DIM)
00752 #else
00753         throw()
00754 #endif
00755         { _vsvaccu(dp,sl,rv); }
00756         INLINE void accumulate(idotprecision &dp, const rvector & rv1, const l_rmatrix_subv &rv2)
00757 #if(CXSC_INDEX_CHECK)
00758         throw(OP_WITH_WRONG_DIM)
00759 #else
00760         throw()
00761 #endif
00762         ;
00763         INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const rmatrix_subv &rv2)
00764 #if(CXSC_INDEX_CHECK)
00765         throw(OP_WITH_WRONG_DIM)
00766 #else
00767         throw()
00768 #endif
00769         ;
00770         INLINE void accumulate(idotprecision &dp,const l_rvector &rv,const rvector_slice &sl)
00771 #if(CXSC_INDEX_CHECK)
00772         throw(OP_WITH_WRONG_DIM)
00773 #else
00774         throw()
00775 #endif
00776         { _vsvaccu(dp,sl,rv); }
00777         INLINE void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const l_rvector &rv2)
00778 #if(CXSC_INDEX_CHECK)
00779         throw(OP_WITH_WRONG_DIM)
00780 #else
00781         throw()
00782 #endif
00783         ;
00784         INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const rvector &rv2)
00785 #if(CXSC_INDEX_CHECK)
00786         throw(OP_WITH_WRONG_DIM)
00787 #else
00788         throw()
00789 #endif
00790         ;
00791         INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl1, const rvector_slice &sl2)
00792 #if(CXSC_INDEX_CHECK)
00793         throw(OP_WITH_WRONG_DIM)
00794 #else
00795         throw()
00796 #endif
00797         { _vsvsaccu(dp,sl2,sl1); }
00798         INLINE void accumulate(idotprecision &dp, const rvector_slice & sl1, const l_rvector_slice &sl2)
00799 #if(CXSC_INDEX_CHECK)
00800         throw(OP_WITH_WRONG_DIM)
00801 #else
00802         throw()
00803 #endif
00804         { _vsvsaccu(dp,sl1,sl2); }
00805 
00806         INLINE l_real operator *(const rvector & rv1, const l_rvector &rv2)
00807 #if(CXSC_INDEX_CHECK)
00808         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00809 #else
00810         throw()
00811 #endif
00812         { return _vvlmult<rvector,l_rvector,l_real>(rv1,rv2); }
00813         INLINE l_real operator *(const rvector_slice &sl, const l_rvector &rv)
00814 #if(CXSC_INDEX_CHECK)
00815         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00816 #else
00817         throw()
00818 #endif
00819         { return _vsvlmult<rvector_slice,l_rvector,l_real>(sl,rv); }
00820         INLINE l_real operator *(const rvector &rv, const l_rvector_slice &sl)
00821 #if(CXSC_INDEX_CHECK)
00822         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00823 #else
00824         throw()
00825 #endif
00826         { return _vsvlmult<l_rvector_slice,rvector,l_real>(sl,rv); }
00827         INLINE l_real operator *(const rvector_slice & sl1, const l_rvector_slice &sl2)
00828 #if(CXSC_INDEX_CHECK)
00829         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00830 #else
00831         throw()
00832 #endif
00833         { return _vsvslmult<rvector_slice,l_rvector_slice,l_real>(sl1,sl2); }
00834         
00835         INLINE l_real operator *(const l_rvector & rv1, const rvector &rv2)
00836 #if(CXSC_INDEX_CHECK)
00837         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00838 #else
00839         throw()
00840 #endif
00841         { return _vvlmult<rvector,l_rvector,l_real>(rv2,rv1); }
00842         INLINE l_real operator *(const l_rvector_slice &sl, const rvector &rv)
00843 #if(CXSC_INDEX_CHECK)
00844         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00845 #else
00846         throw()
00847 #endif
00848         { return _vsvlmult<l_rvector_slice,rvector,l_real>(sl,rv); }
00849         INLINE l_real operator *(const l_rvector &rv, const rvector_slice &sl)
00850 #if(CXSC_INDEX_CHECK)
00851         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00852 #else
00853         throw()
00854 #endif
00855         { return _vsvlmult<rvector_slice,l_rvector,l_real>(sl,rv); }
00856         INLINE l_real operator *(const l_rvector_slice & sl1, const rvector_slice &sl2)
00857 #if(CXSC_INDEX_CHECK)
00858         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00859 #else
00860         throw()
00861 #endif
00862         { return _vsvslmult<rvector_slice,l_rvector_slice,l_real>(sl2,sl1); }
00863         
00864         INLINE l_rvector operator +(const rvector &rv1, const l_rvector &rv2)
00865 #if(CXSC_INDEX_CHECK)
00866         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00867 #else
00868         throw()
00869 #endif
00870         { return _vvplus<rvector,l_rvector,l_rvector>(rv1,rv2); }
00871         INLINE l_rvector operator +(const rvector &rv, const l_rvector_slice &sl)
00872 #if(CXSC_INDEX_CHECK)
00873         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00874 #else
00875         throw()
00876 #endif
00877         { return _vvsplus<rvector,l_rvector_slice,l_rvector>(rv,sl); }
00878         INLINE l_rvector operator +(const rvector_slice &sl, const l_rvector &rv)
00879 #if(CXSC_INDEX_CHECK)
00880         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00881 #else
00882         throw()
00883 #endif
00884         { return _vvsplus<l_rvector,rvector_slice,l_rvector>(rv,sl); }
00885         INLINE l_rvector operator +(const rvector_slice &sl1, const l_rvector_slice &sl2)
00886 #if(CXSC_INDEX_CHECK)
00887         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00888 #else
00889         throw()
00890 #endif
00891         { return _vsvsplus<rvector_slice,l_rvector_slice,l_rvector>(sl1,sl2); }
00892 
00893         INLINE l_rvector operator +(const l_rvector &rv1, const rvector &rv2)
00894 #if(CXSC_INDEX_CHECK)
00895         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00896 #else
00897         throw()
00898 #endif
00899         { return _vvplus<rvector,l_rvector,l_rvector>(rv2,rv1); }
00900         INLINE l_rvector operator +(const l_rvector &rv, const rvector_slice &sl)
00901 #if(CXSC_INDEX_CHECK)
00902         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00903 #else
00904         throw()
00905 #endif
00906         { return _vvsplus<l_rvector,rvector_slice,l_rvector>(rv,sl); }
00907         INLINE l_rvector operator +(const l_rvector_slice &sl, const rvector &rv)
00908 #if(CXSC_INDEX_CHECK)
00909         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00910 #else
00911         throw()
00912 #endif
00913         { return _vvsplus<rvector,l_rvector_slice,l_rvector>(rv,sl); }
00914         INLINE l_rvector operator +(const l_rvector_slice &sl1, const rvector_slice &sl2)
00915 #if(CXSC_INDEX_CHECK)
00916         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00917 #else
00918         throw()
00919 #endif
00920         { return _vsvsplus<rvector_slice,l_rvector_slice,l_rvector>(sl2,sl1); }
00921 
00922         INLINE l_rvector & operator +=(l_rvector &rv1, const rvector &rv2)
00923 #if(CXSC_INDEX_CHECK)
00924         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00925 #else
00926         throw()
00927 #endif
00928         { return _vvplusassign(rv1,rv2); }
00929         INLINE l_rvector &operator +=(l_rvector &rv, const rvector_slice &sl)
00930 #if(CXSC_INDEX_CHECK)
00931         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00932 #else
00933         throw()
00934 #endif
00935         { return _vvsplusassign(rv,sl); }
00936         INLINE l_rvector_slice &l_rvector_slice::operator +=(const rvector &rv)
00937 #if(CXSC_INDEX_CHECK)
00938         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00939 #else
00940         throw()
00941 #endif
00942         { return _vsvplusassign(*this,rv); }
00943         INLINE l_rvector_slice &l_rvector_slice::operator +=(const rvector_slice &sl2)
00944 #if(CXSC_INDEX_CHECK)
00945         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00946 #else
00947         throw()
00948 #endif
00949         { return _vsvsplusassign(*this,sl2); }
00950 
00951         INLINE l_rvector operator -(const rvector &rv1, const l_rvector &rv2)
00952 #if(CXSC_INDEX_CHECK)
00953         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00954 #else
00955         throw()
00956 #endif
00957         { return _vvminus<rvector,l_rvector,l_rvector>(rv1,rv2); }
00958         INLINE l_rvector operator -(const rvector &rv, const l_rvector_slice &sl)
00959 #if(CXSC_INDEX_CHECK)
00960         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00961 #else
00962         throw()
00963 #endif
00964         { return _vvsminus<rvector,l_rvector_slice,l_rvector>(rv,sl); }
00965         INLINE l_rvector operator -(const rvector_slice &sl, const l_rvector &rv)
00966 #if(CXSC_INDEX_CHECK)
00967         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00968 #else
00969         throw()
00970 #endif
00971         { return _vsvminus<rvector_slice,l_rvector,l_rvector>(sl,rv); }
00972         INLINE l_rvector operator -(const rvector_slice &sl1, const l_rvector_slice &sl2)
00973 #if(CXSC_INDEX_CHECK)
00974         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00975 #else
00976         throw()
00977 #endif
00978         { return _vsvsminus<rvector_slice,l_rvector_slice,l_rvector>(sl1,sl2); }
00979 
00980         INLINE l_rvector operator -(const l_rvector &rv1, const rvector &rv2)
00981 #if(CXSC_INDEX_CHECK)
00982         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00983 #else
00984         throw()
00985 #endif
00986         { return _vvminus<l_rvector,rvector,l_rvector>(rv1,rv2); }
00987         INLINE l_rvector operator -(const l_rvector &rv, const rvector_slice &sl)
00988 #if(CXSC_INDEX_CHECK)
00989         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00990 #else
00991         throw()
00992 #endif
00993         { return _vvsminus<l_rvector,rvector_slice,l_rvector>(rv,sl); }
00994         INLINE l_rvector operator -(const l_rvector_slice &sl, const rvector &rv)
00995 #if(CXSC_INDEX_CHECK)
00996         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
00997 #else
00998         throw()
00999 #endif
01000         { return _vsvminus<l_rvector_slice,rvector,l_rvector>(sl,rv); }
01001         INLINE l_rvector operator -(const l_rvector_slice &sl1, const rvector_slice &sl2)
01002 #if(CXSC_INDEX_CHECK)
01003         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
01004 #else
01005         throw()
01006 #endif
01007         { return _vsvsminus<l_rvector_slice,rvector_slice,l_rvector>(sl1,sl2); }
01008 
01009         INLINE l_rvector & operator -=(l_rvector &rv1, const rvector &rv2)
01010 #if(CXSC_INDEX_CHECK)
01011         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
01012 #else
01013         throw()
01014 #endif
01015         { return _vvminusassign(rv1,rv2); }
01016         INLINE l_rvector &operator -=(l_rvector &rv, const rvector_slice &sl)
01017 #if(CXSC_INDEX_CHECK)
01018         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
01019 #else
01020         throw()
01021 #endif
01022         { return _vvsminusassign(rv,sl); }
01023         INLINE l_rvector_slice &l_rvector_slice::operator -=(const rvector &rv)
01024 #if(CXSC_INDEX_CHECK)
01025         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
01026 #else
01027         throw()
01028 #endif
01029         { return _vsvminusassign(*this,rv); }
01030         INLINE l_rvector_slice &l_rvector_slice::operator -=(const rvector_slice &sl2)
01031 #if(CXSC_INDEX_CHECK)
01032         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>)
01033 #else
01034         throw()
01035 #endif
01036         { return _vsvsminusassign(*this,sl2); }
01037 
01038 } // namespace cxsc
01039 
01040 #endif
01041
Generated on Thu Jun 9 11:20:52 2011 for C-XSC - A C++ Class Library for Extended Scientific Computing by  doxygen 1.4.6