C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
lrvecivec.inl
00001 /*
00002 **  CXSC is a C++ library for eXtended Scientific Computing (V 2.5.4)
00003 **
00004 **  Copyright (C) 1990-2000 Institut fuer Angewandte Mathematik,
00005 **                          Universitaet Karlsruhe, Germany
00006 **            (C) 2000-2014 Wiss. Rechnen/Softwaretechnologie
00007 **                          Universitaet Wuppertal, Germany   
00008 **
00009 **  This library is free software; you can redistribute it and/or
00010 **  modify it under the terms of the GNU Library General Public
00011 **  License as published by the Free Software Foundation; either
00012 **  version 2 of the License, or (at your option) any later version.
00013 **
00014 **  This library is distributed in the hope that it will be useful,
00015 **  but WITHOUT ANY WARRANTY; without even the implied warranty of
00016 **  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00017 **  Library General Public License for more details.
00018 **
00019 **  You should have received a copy of the GNU Library General Public
00020 **  License along with this library; if not, write to the Free
00021 **  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00022 */
00023 
00024 /* CVS $Id: lrvecivec.inl,v 1.24 2014/01/30 17:23:47 cxsc Exp $ */
00025 
00026 #ifndef _CXSC_LRVECIVEC_INL_INCLUDED
00027 #define _CXSC_LRVECIVEC_INL_INCLUDED
00028 
00029 #include "l_interval.hpp"
00030 
00031 namespace cxsc {
00032 
00033         INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const ivector &rv2)
00034 #if(CXSC_INDEX_CHECK)
00035         throw(OP_WITH_WRONG_DIM)
00036 #else
00037         throw()
00038 #endif
00039         { _vvaccu(dp,rv1,rv2); }
00040         INLINE void accumulate(idotprecision &dp, const ivector & rv1, const l_rvector &rv2)
00041 #if(CXSC_INDEX_CHECK)
00042         throw(OP_WITH_WRONG_DIM)
00043 #else
00044         throw()
00045 #endif
00046         { _vvaccu(dp,rv2,rv1); }
00047         INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl, const ivector &rv)
00048 #if(CXSC_INDEX_CHECK)
00049         throw(OP_WITH_WRONG_DIM)
00050 #else
00051         throw()
00052 #endif
00053         { _vsvaccu(dp,sl,rv); }
00054         INLINE void accumulate(idotprecision &dp,const ivector_slice &sl,const l_rvector &rv)
00055 #if(CXSC_INDEX_CHECK)
00056         throw(OP_WITH_WRONG_DIM)
00057 #else
00058         throw()
00059 #endif
00060         { _vsvaccu(dp,sl,rv); }
00061         INLINE void accumulate(idotprecision &dp, const l_rvector &rv, const ivector_slice &sl)
00062 #if(CXSC_INDEX_CHECK)
00063         throw(OP_WITH_WRONG_DIM)
00064 #else
00065         throw()
00066 #endif
00067         { _vsvaccu(dp,sl,rv); }
00068         INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const imatrix_subv &rv2)
00069 #if(CXSC_INDEX_CHECK)
00070         throw(OP_WITH_WRONG_DIM)
00071 #else
00072         throw()
00073 #endif
00074         ;
00075         INLINE void accumulate(idotprecision &dp, const ivector & rv1, const l_rmatrix_subv &rv2)
00076 #if(CXSC_INDEX_CHECK)
00077         throw(OP_WITH_WRONG_DIM)
00078 #else
00079         throw()
00080 #endif
00081         ;
00082         INLINE void accumulate(idotprecision &dp,const ivector &rv,const l_rvector_slice &sl)
00083 #if(CXSC_INDEX_CHECK)
00084         throw(OP_WITH_WRONG_DIM)
00085 #else
00086         throw()
00087 #endif
00088         { _vsvaccu(dp,sl,rv); }
00089         INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const ivector &rv2)
00090 #if(CXSC_INDEX_CHECK)
00091         throw(OP_WITH_WRONG_DIM)
00092 #else
00093         throw()
00094 #endif
00095         ;
00096         INLINE void accumulate(idotprecision &dp, const imatrix_subv & rv1, const l_rvector &rv2)
00097 #if(CXSC_INDEX_CHECK)
00098         throw(OP_WITH_WRONG_DIM)
00099 #else
00100         throw()
00101 #endif
00102         ;
00103         INLINE void accumulate(idotprecision &dp, const ivector_slice & sl1, const l_rvector_slice &sl2)
00104 #if(CXSC_INDEX_CHECK)
00105         throw(OP_WITH_WRONG_DIM)
00106 #else
00107         throw()
00108 #endif
00109         { _vsvsaccu(dp,sl2,sl1); }
00110         INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl1, const ivector_slice &sl2)
00111 #if(CXSC_INDEX_CHECK)
00112         throw(OP_WITH_WRONG_DIM)
00113 #else
00114         throw()
00115 #endif
00116         { _vsvsaccu(dp,sl1,sl2); }
00117 
00118         INLINE l_interval operator *(const l_rvector & rv1, const ivector &rv2)
00119 #if(CXSC_INDEX_CHECK)
00120         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
00121 #else
00122         throw()
00123 #endif
00124         { return _vvlimult<l_rvector,ivector,l_interval>(rv1,rv2); }
00125         INLINE l_interval operator *(const l_rvector_slice &sl, const ivector &rv)
00126 #if(CXSC_INDEX_CHECK)
00127         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
00128 #else
00129         throw()
00130 #endif
00131         { return _vsvlimult<l_rvector_slice,ivector,l_interval>(sl,rv); }
00132         INLINE l_interval operator *(const l_rvector &rv, const ivector_slice &sl)
00133 #if(CXSC_INDEX_CHECK)
00134         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
00135 #else
00136         throw()
00137 #endif
00138         { return _vsvlimult<ivector_slice,l_rvector,l_interval>(sl,rv); }
00139         INLINE l_interval operator *(const l_rvector_slice & sl1, const ivector_slice &sl2)
00140 #if(CXSC_INDEX_CHECK)
00141         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
00142 #else
00143         throw()
00144 #endif
00145         { return _vsvslimult<l_rvector_slice,ivector_slice,l_interval>(sl1,sl2); }
00146         
00147         INLINE l_interval operator *(const ivector & rv1, const l_rvector &rv2)
00148 #if(CXSC_INDEX_CHECK)
00149         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
00150 #else
00151         throw()
00152 #endif
00153         { return _vvlimult<l_rvector,ivector,l_interval>(rv2,rv1); }
00154         INLINE l_interval operator *(const ivector_slice &sl, const l_rvector &rv)
00155 #if(CXSC_INDEX_CHECK)
00156         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
00157 #else
00158         throw()
00159 #endif
00160         { return _vsvlimult<ivector_slice,l_rvector,l_interval>(sl,rv); }
00161         INLINE l_interval operator *(const ivector &rv, const l_rvector_slice &sl)
00162 #if(CXSC_INDEX_CHECK)
00163         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
00164 #else
00165         throw()
00166 #endif
00167         { return _vsvlimult<l_rvector_slice,ivector,l_interval>(sl,rv); }
00168         INLINE l_interval operator *(const ivector_slice & sl1, const l_rvector_slice &sl2)
00169 #if(CXSC_INDEX_CHECK)
00170         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>)
00171 #else
00172         throw()
00173 #endif
00174         { return _vsvslimult<l_rvector_slice,ivector_slice,l_interval>(sl2,sl1); }
00175 
00176 } // namespace cxsc
00177 
00178 #endif
00179