l_rmatrix.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_rmatrix.inl,v 1.17 2011/06/07 15:17:40 cxsc Exp $ */
00025 
00026 #ifndef _CXSC_LRMATRIX_INL_INCLUDED
00027 #define _CXSC_LRMATRIX_INL_INCLUDED
00028 
00029 namespace cxsc {
00030 
00031 INLINE l_rmatrix::l_rmatrix() throw():dat(NULL),lb1(1),ub1(0),lb2(1),ub2(0),xsize(0),ysize(0)
00032 {
00033 }
00034 
00035 INLINE l_rmatrix::l_rmatrix(const l_real &r) throw():lb1(1),ub1(1),lb2(1),ub2(1),xsize(1),ysize(1)
00036 {
00037         dat=new l_real[1];
00038         *dat=r;
00039 }
00040 
00041 INLINE l_rmatrix::l_rmatrix(const real &r) throw():lb1(1),ub1(1),lb2(1),ub2(1),xsize(1),ysize(1)
00042 {
00043         dat=new l_real[1];
00044         *dat=r;
00045 }
00046 
00047 INLINE l_rmatrix::l_rmatrix(const l_rmatrix &rm) throw():lb1(rm.lb1),ub1(rm.ub1),lb2(rm.lb2),ub2(rm.ub2),xsize(rm.xsize),ysize(rm.ysize)
00048 {
00049         dat=new l_real[xsize*ysize];
00050         for(int i=0;i<xsize*ysize;i++)
00051                 dat[i]=rm.dat[i];
00052 }
00053 
00054 INLINE l_rmatrix::l_rmatrix(const rmatrix &rm) throw():lb1(rm.lb1),ub1(rm.ub1),lb2(rm.lb2),ub2(rm.ub2),xsize(rm.xsize),ysize(rm.ysize)
00055 {
00056         dat=new l_real[xsize*ysize];
00057         for(int i=0;i<xsize*ysize;i++)
00058                 dat[i]=rm.dat[i];
00059 }
00060 
00061 INLINE l_rmatrix::l_rmatrix(const int &m, const int &n)
00062 #if(CXSC_INDEX_CHECK)
00063         throw(ERROR_LRMATRIX_WRONG_BOUNDARIES):lb1(1),ub1(m),lb2(1),ub2(n),xsize(n),ysize(m)
00064 #else
00065         throw():lb1(1),ub1(m),lb2(1),ub2(n),xsize(n),ysize(m)
00066 #endif
00067 {
00068 #if(CXSC_INDEX_CHECK)
00069         if((n<0)||(m<0)) cxscthrow(ERROR_LRMATRIX_WRONG_BOUNDARIES("l_rmatrix::l_rmatrix(const int &m, const int &n)"));
00070 #endif
00071         dat=new l_real[m*n];
00072 }
00073 
00074 INLINE l_rmatrix::l_rmatrix(const int &m1, const int &m2, const int &n1, const int &n2)
00075 #if(CXSC_INDEX_CHECK)
00076         throw(ERROR_LRMATRIX_WRONG_BOUNDARIES):lb1(m1),ub1(m2),lb2(n1),ub2(n2),xsize(n2-n1+1),ysize(m2-m1+1)
00077 #else
00078         throw():lb1(m1),ub1(m2),lb2(n1),ub2(n2),xsize(n2-n1+1),ysize(m2-m1+1)
00079 #endif
00080 {
00081 #if(CXSC_INDEX_CHECK)
00082         if((m2<m1)||(n2<n1)) cxscthrow(ERROR_LRMATRIX_WRONG_BOUNDARIES("l_rmatrix::l_rmatrix(const int &m1, const int &n1, const int &m2, const int &n2)"));
00083 #endif
00084         dat=new l_real[xsize*ysize];
00085 }
00086 
00087 INLINE l_rvector::l_rvector(const l_rmatrix_subv &v) throw():l(v.lb),u(v.ub),size(v.size)
00088 {
00089         dat=new l_real[size];
00090         for (int i=0, j=v.start;i<v.size;i++,j+=v.offset)
00091                 dat[i]=v.dat[j];
00092 }
00093 
00094 INLINE l_rvector_slice & l_rvector_slice::operator =(const l_rmatrix &m)
00095 #if(CXSC_INDEX_CHECK)
00096 throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>,ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ)
00097 #else
00098 throw()
00099 #endif
00100 { return _vsvassign(*this,l_rvector(m)); }
00101 
00102 INLINE l_rvector _l_rvector(const rmatrix_subv &rs) throw() { return l_rvector(rs); }
00103 
00104 INLINE l_rmatrix::l_rmatrix(const l_rvector &v) throw():lb1(v.l),ub1(v.u),lb2(1),ub2(1),xsize(1),ysize(v.size)
00105 {
00106         dat=new l_real[v.size];
00107         for(int i=0;i<v.size;i++)
00108                 dat[i]=v.dat[i];
00109 }
00110 
00111 INLINE l_rmatrix::l_rmatrix(const rvector &v) throw():lb1(v.l),ub1(v.u),lb2(1),ub2(1),xsize(1),ysize(v.size)
00112 {
00113         dat=new l_real[v.size];
00114         for(int i=0;i<v.size;i++)
00115                 dat[i]=v.dat[i];
00116 }
00117 
00118 INLINE l_rmatrix::l_rmatrix(const l_rvector_slice &v) throw():lb1(v.start),ub1(v.end),lb2(1),ub2(1),xsize(1),ysize(v.size)
00119 {
00120         dat=new l_real[v.size];
00121         for(int i=0,j=v.start-v.l;i<v.size;i++,j++)
00122                 dat[i]=v.dat[j];
00123 }
00124 
00125 INLINE l_rmatrix::l_rmatrix(const rvector_slice &v) throw():lb1(v.start),ub1(v.end),lb2(1),ub2(1),xsize(1),ysize(v.size)
00126 {
00127         dat=new l_real[v.size];
00128         for(int i=0,j=v.start-v.l;i<v.size;i++,j++)
00129                 dat[i]=v.dat[j];
00130 }
00131 
00132         INLINE l_real &l_rmatrix_subv::operator [](const int &i) const
00133 #if(CXSC_INDEX_CHECK)
00134                 throw(ERROR_LRVECTOR_ELEMENT_NOT_IN_VEC)
00135 #else
00136         throw()
00137 #endif
00138         {
00139 #if(CXSC_INDEX_CHECK)
00140                 if((i<lb)||(i>ub)) cxscthrow(ERROR_LRVECTOR_ELEMENT_NOT_IN_VEC("l_real &l_rmatrix_subv::operator [](const int &i)"));
00141 #endif
00142                 return dat[start+((i-lb)*offset)];
00143         }
00144 
00145         INLINE l_rmatrix::l_rmatrix(const l_rmatrix_slice &sl) throw():lb1(sl.start1),ub1(sl.end1),lb2(sl.start2),ub2(sl.end2),xsize(sl.sxsize),ysize(sl.sysize)
00146         {
00147                 int i,j;
00148                 
00149                 dat=new l_real[xsize*ysize];
00150                 for (i=0;i<ysize;i++)
00151                 {
00152                         for(j=0;j<xsize;j++)
00153                         {
00154                                 dat[i*xsize+j]=sl.dat[(sl.offset1+i)*sl.mxsize+sl.offset2+j];
00155                         }
00156                 }
00157         }
00158 
00159         INLINE l_rmatrix::l_rmatrix(const rmatrix_slice &sl) throw():lb1(sl.start1),ub1(sl.end1),lb2(sl.start2),ub2(sl.end2),xsize(sl.sxsize),ysize(sl.sysize)
00160         {
00161                 int i,j;
00162                 
00163                 dat=new l_real[xsize*ysize];
00164                 for (i=0;i<ysize;i++)
00165                 {
00166                         for(j=0;j<xsize;j++)
00167                         {
00168                                 dat[i*xsize+j]=sl.dat[(sl.offset1+i)*sl.mxsize+sl.offset2+j];
00169                         }
00170                 }
00171         }
00172 
00173         INLINE l_rmatrix_subv Row(l_rmatrix &m,const int &i)
00174 #if(CXSC_INDEX_CHECK)
00175         throw(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT)
00176 #else
00177         throw()
00178 #endif
00179         
00180         {
00181                 return m[i];
00182         }
00183 
00184         INLINE l_rmatrix_subv Col(l_rmatrix &m,const int &i)
00185 #if(CXSC_INDEX_CHECK)
00186         throw(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT)
00187 #else
00188         throw()
00189 #endif
00190         
00191         {
00192                 return m[Col(i)];
00193         }
00194                 
00195         INLINE l_rmatrix_subv Row(const l_rmatrix &m,const int &i)
00196 #if(CXSC_INDEX_CHECK)
00197         throw(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT)
00198 #else
00199         throw()
00200 #endif
00201         
00202         {
00203                 return m[i];
00204         }
00205 
00206         INLINE l_rmatrix_subv Col(const l_rmatrix &m,const int &i)
00207 #if(CXSC_INDEX_CHECK)
00208         throw(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT)
00209 #else
00210         throw()
00211 #endif
00212         
00213         {
00214                 return m[Col(i)];
00215         }
00216                 
00217         INLINE l_rmatrix_subv l_rmatrix::operator [](const int &i) const
00218 #if(CXSC_INDEX_CHECK)
00219                 throw(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT)
00220 #else
00221         throw()
00222 #endif
00223         {
00224 #if(CXSC_INDEX_CHECK)
00225                 if((i<lb1)||(i>ub1)) cxscthrow(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT("l_rmatrix_subv l_rmatrix::operator [](const int &i)"));
00226 #endif
00227                 return l_rmatrix_subv(dat, lb2, ub2, xsize, xsize*(i-lb1),1);
00228         }
00229         
00230         INLINE l_rmatrix_subv l_rmatrix::operator [](const cxscmatrix_column &i) const
00231 #if(CXSC_INDEX_CHECK)
00232                 throw(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT)
00233 #else
00234         throw()
00235 #endif
00236         {
00237 #if(CXSC_INDEX_CHECK)
00238                 if((i.col()<lb2)||(i.col()>ub2)) cxscthrow(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT("l_rmatrix_subv l_rmatrix::operator [](const cxscmatrix_column &i)"));
00239 #endif
00240                 return l_rmatrix_subv(dat, lb1, ub1, ysize, i.col()-lb2, xsize);
00241         }
00242         
00243         INLINE l_rmatrix_slice l_rmatrix::operator ()(const int &m, const int &n)
00244 #if(CXSC_INDEX_CHECK)
00245                 throw(ERROR_LRMATRIX_SUB_ARRAY_TOO_BIG)
00246 #else
00247         throw()
00248 #endif
00249         {
00250 #if(CXSC_INDEX_CHECK)
00251         if((m<1)||(n<1)||(m<lb1)||(n<lb2)||(m>ub1)||(n>ub2)) cxscthrow(ERROR_LRMATRIX_SUB_ARRAY_TOO_BIG("l_rmatrix_slice l_rmatrix::operator ()(const int &m, const int &n)"));
00252 #endif
00253                 return l_rmatrix_slice(*this,1,m,1,n);
00254         }
00255         
00256         INLINE l_rmatrix_slice l_rmatrix::operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
00257 #if(CXSC_INDEX_CHECK)
00258                 throw(ERROR_LRMATRIX_SUB_ARRAY_TOO_BIG)
00259 #else
00260         throw()
00261 #endif
00262         {
00263 #if(CXSC_INDEX_CHECK)
00264         if((m1<lb1)||(n1<lb2)||(m2>ub1)||(n2>ub2)) cxscthrow(ERROR_LRMATRIX_SUB_ARRAY_TOO_BIG("l_rmatrix_slice l_rmatrix::operator ()(const int &m1, const int &n1, const int &m2, const int &n2)"));
00265 #endif
00266                 return l_rmatrix_slice(*this,m1,m2,n1,n2);
00267         }
00268 
00269         INLINE l_rmatrix_subv l_rmatrix_slice::operator [](const int &i) const
00270 #if(CXSC_INDEX_CHECK)
00271                 throw(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT)
00272 #else
00273         throw()
00274 #endif
00275         {
00276 #if(CXSC_INDEX_CHECK)
00277                 if((i<start1)||(i>end1)) cxscthrow(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT("l_rmatrix_subv l_rmatrix_slice::operator [](const int &i)"));
00278 #endif
00279                 return l_rmatrix_subv(dat, start2, end2, sxsize, mxsize*(i-start1+offset1)+offset2,1);
00280         }
00281         
00282         INLINE l_rmatrix_subv l_rmatrix_slice::operator [](const cxscmatrix_column &i) const
00283 #if(CXSC_INDEX_CHECK)
00284                 throw(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT)
00285 #else
00286         throw()
00287 #endif
00288         {
00289 #if(CXSC_INDEX_CHECK)
00290                 if((i.col()<start2)||(i.col()>end2)) cxscthrow(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT("l_rmatrix_subv l_rmatrix_slice::operator [](const cxscmatrix_column &i)"));
00291 #endif
00292                 return l_rmatrix_subv(dat, start1, end1, sysize, offset1*mxsize+i.col()-start2+offset2, mxsize);
00293         }
00294         
00295         INLINE l_rmatrix_slice l_rmatrix_slice::operator ()(const int &m, const int &n)
00296 #if(CXSC_INDEX_CHECK)
00297                 throw(ERROR_LRMATRIX_SUB_ARRAY_TOO_BIG)
00298 #else
00299         throw()
00300 #endif
00301         {
00302 #if(CXSC_INDEX_CHECK)
00303                 if((m<1)||(n<1)||(m<start1)||(n<start2)||(m>end1)||(n>end2)) cxscthrow(ERROR_LRMATRIX_SUB_ARRAY_TOO_BIG("l_rmatrix_slice l_rmatrix_slice::operator ()(const int &m, const int &n)"));
00304 #endif
00305                 return l_rmatrix_slice(*this,1,m,1,n);
00306         }
00307         
00308         INLINE l_rmatrix_slice l_rmatrix_slice::operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
00309 #if(CXSC_INDEX_CHECK)
00310                 throw(ERROR_LRMATRIX_SUB_ARRAY_TOO_BIG)
00311 #else
00312         throw()
00313 #endif
00314         {
00315 #if(CXSC_INDEX_CHECK)
00316                 if((m1<start1)||(n1<start2)||(m2>end1)||(n2>end2)) cxscthrow(ERROR_LRMATRIX_SUB_ARRAY_TOO_BIG("l_rmatrix_slice l_rmatrix_slice::operator ()(const int &m1, const int &m2, const int &n1, const int &n2)"));
00317 #endif
00318                 return l_rmatrix_slice(*this,m1,m2,n1,n2);
00319         }
00320 
00321 INLINE l_rmatrix_subv l_rmatrix_subv::operator ()(const int &i)
00322 #if(CXSC_INDEX_CHECK)
00323         throw(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG)
00324 #else
00325         throw()
00326 #endif
00327 {
00328 #if(CXSC_INDEX_CHECK)
00329         if(1<lb||i>ub) cxscthrow(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG("l_rmatrix_subv l_rmatrix_subv::operator ()(const int &i)"));
00330 #endif
00331         return l_rmatrix_subv(dat,1,i,i,start+(1-lb)*offset,offset);
00332 }
00333 
00334 INLINE l_rmatrix_subv l_rmatrix_subv::operator ()(const int &i1,const int &i2)
00335 #if(CXSC_INDEX_CHECK)
00336         throw(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG)
00337 #else
00338         throw()
00339 #endif
00340 {
00341 #if(CXSC_INDEX_CHECK)
00342         if(i1<lb||i2>ub) cxscthrow(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG("l_rmatrix_subv l_rmatrix_subv::operator ()(const int &i1,const int &i2)"));
00343 #endif
00344         return l_rmatrix_subv(dat,i1,i2,i2-i1+1,start+(i1-lb)*offset,offset);
00345 }
00346 
00347 
00348 
00349         INLINE l_rmatrix_subv &l_rmatrix_subv::operator =(const l_rmatrix_subv &rv) throw() { return _mvmvassign(*this,rv); }
00350         INLINE l_rmatrix_subv &l_rmatrix_subv::operator =(const l_real &r) throw() { return _mvsassign(*this,r); }
00351         INLINE l_rmatrix_subv &l_rmatrix_subv::operator =(const l_rvector &v)
00352 #if(CXSC_INDEX_CHECK)
00353         throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
00354 #else
00355         throw()
00356 #endif
00357         { return _mvvassign(*this,v); }
00358         INLINE l_rmatrix_subv &l_rmatrix_subv::operator =(const l_rvector_slice &v)
00359 #if(CXSC_INDEX_CHECK)
00360         throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
00361 #else
00362         throw()
00363 #endif
00364         { return _mvvassign(*this,l_rvector(v)); }
00365         INLINE l_rmatrix_subv &l_rmatrix_subv::operator =(const rmatrix_subv &rv) throw() { return _mvvassign(*this,rvector(rv)); }
00366         INLINE l_rmatrix_subv &l_rmatrix_subv::operator =(const real &r) throw() { return _mvsassign(*this,r); }
00367         INLINE l_rmatrix_subv &l_rmatrix_subv::operator =(const rvector &v)
00368 #if(CXSC_INDEX_CHECK)
00369         throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
00370 #else
00371         throw()
00372 #endif
00373         { return _mvvassign(*this,v); }
00374         INLINE l_rmatrix_subv &l_rmatrix_subv::operator =(const rvector_slice &v)
00375 #if(CXSC_INDEX_CHECK)
00376         throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
00377 #else
00378         throw()
00379 #endif
00380         { return _mvvassign(*this,l_rvector(v)); }
00381         INLINE l_rmatrix &l_rmatrix::operator =(const l_real &r) throw() { return _msassign(*this,r); }
00382         INLINE l_rmatrix &l_rmatrix::operator =(const l_rmatrix &m) throw() { return _mmassign<l_rmatrix,l_rmatrix,l_real>(*this,m, l_real(0)); }
00383         INLINE l_rmatrix &l_rmatrix::operator =(const l_rmatrix_slice &ms) throw() { return _mmsassign<l_rmatrix,l_rmatrix_slice,l_real>(*this,ms); }
00384         INLINE l_rmatrix &l_rmatrix::operator =(const l_rvector &v) throw() { return _mvassign<l_rmatrix,l_rvector,l_real>(*this,v); }
00385         INLINE l_rmatrix &l_rmatrix::operator =(const l_rvector_slice &v) throw() { return _mvassign<l_rmatrix,l_rvector,l_real>(*this,l_rvector(v)); }
00386         INLINE l_rmatrix &l_rmatrix::operator =(const real &r) throw() { return _msassign(*this,l_real(r)); }
00387         INLINE l_rmatrix &l_rmatrix::operator =(const rmatrix &m) throw() { return _mmassign<l_rmatrix,rmatrix,l_real>(*this,m, l_real(0)); }
00388         INLINE l_rmatrix &l_rmatrix::operator =(const rmatrix_slice &ms) throw() { return _mmsassign<l_rmatrix,rmatrix_slice,l_real>(*this,ms); }
00389         INLINE l_rmatrix &l_rmatrix::operator =(const rvector &v) throw() { return _mvassign<l_rmatrix,rvector,l_real>(*this,v); }
00390         INLINE l_rmatrix &l_rmatrix::operator =(const rvector_slice &v) throw() { return _mvassign<l_rmatrix,rvector,l_real>(*this,rvector(v)); }
00391         
00392         INLINE l_rmatrix::operator void*() throw() { return _mvoid(*this); }
00393         INLINE l_rmatrix_slice &l_rmatrix_slice::operator =(const l_rmatrix &m)
00394 #if(CXSC_INDEX_CHECK)
00395         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
00396 #else
00397         throw()
00398 #endif
00399         { return _msmassign(*this,m); }
00400         INLINE l_rmatrix_slice &l_rmatrix_slice::operator =(const l_rmatrix_slice &ms)
00401 #if(CXSC_INDEX_CHECK)
00402         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
00403 #else
00404         throw()
00405 #endif
00406         { return _msmsassign(*this,ms); }
00407         INLINE l_rmatrix_slice &l_rmatrix_slice::operator =(const l_real &r) throw() { return _mssassign(*this,r); }
00408         INLINE l_rmatrix_slice &l_rmatrix_slice::operator =(const l_rvector &v)
00409 #if(CXSC_INDEX_CHECK)
00410         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
00411 #else
00412         throw()
00413 #endif
00414         { return _msmassign(*this,l_rmatrix(v)); }
00415         INLINE l_rmatrix_slice &l_rmatrix_slice::operator =(const l_rvector_slice &v)
00416 #if(CXSC_INDEX_CHECK)
00417         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
00418 #else
00419         throw()
00420 #endif
00421         { return _msmassign(*this,l_rmatrix(l_rvector(v))); }
00422         INLINE l_rmatrix_slice &l_rmatrix_slice::operator =(const rmatrix &m)
00423 #if(CXSC_INDEX_CHECK)
00424         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
00425 #else
00426         throw()
00427 #endif
00428         { return _msmassign(*this,m); }
00429         INLINE l_rmatrix_slice &l_rmatrix_slice::operator =(const rmatrix_slice &ms)
00430 #if(CXSC_INDEX_CHECK)
00431         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
00432 #else
00433         throw()
00434 #endif
00435         { return _msmsassign(*this,ms); }
00436         INLINE l_rmatrix_slice &l_rmatrix_slice::operator =(const real &r) throw() { return _mssassign(*this,r); }
00437         INLINE l_rmatrix_slice &l_rmatrix_slice::operator =(const rvector &v)
00438 #if(CXSC_INDEX_CHECK)
00439         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
00440 #else
00441         throw()
00442 #endif
00443         { return _msmassign(*this,rmatrix(v)); }
00444         INLINE l_rmatrix_slice &l_rmatrix_slice::operator =(const rvector_slice &v)
00445 #if(CXSC_INDEX_CHECK)
00446         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
00447 #else
00448         throw()
00449 #endif
00450         { return _msmassign(*this,rmatrix(rvector(v))); }
00451         INLINE l_rmatrix_slice::operator void*() throw() { return _msvoid(*this); }
00452         INLINE l_rvector operator /(const l_rmatrix_subv &rv, const l_real &s) throw() { return _mvsdiv<l_rmatrix_subv,l_real,l_rvector>(rv,s); }
00453         INLINE l_rvector operator *(const l_rmatrix_subv &rv, const l_real &s) throw() { return _mvsmult<l_rmatrix_subv,l_real,l_rvector>(rv,s); }
00454         INLINE l_rvector operator *(const l_real &s, const l_rmatrix_subv &rv) throw() { return _mvsmult<l_rmatrix_subv,l_real,l_rvector>(rv,s); }
00455         INLINE l_rmatrix_subv &l_rmatrix_subv::operator *=(const l_real &c) throw() { return _mvsmultassign(*this,c); }
00456         INLINE l_rmatrix_subv &l_rmatrix_subv::operator +=(const l_real &c) throw() { return _mvsplusassign(*this,c); }
00457         INLINE l_rmatrix_subv &l_rmatrix_subv::operator -=(const l_real &c) throw() { return _mvsminusassign(*this,c); }
00458         INLINE l_rmatrix_subv &l_rmatrix_subv::operator /=(const l_real &c) throw() { return _mvsdivassign(*this,c); }
00459         INLINE l_rvector abs(const l_rmatrix_subv &mv) throw() { return _mvabs<l_rmatrix_subv,l_rvector>(mv); }
00460         INLINE l_rvector &l_rvector::operator =(const l_rmatrix_subv &mv) throw() { return _vmvassign<l_rvector,l_rmatrix_subv,l_real>(*this,mv); }
00461         INLINE l_rvector_slice &l_rvector_slice::operator =(const l_rmatrix_subv &mv) throw() { return _vsvassign(*this,l_rvector(mv)); }
00462         INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const l_rmatrix_subv &rv2)
00463 #if(CXSC_INDEX_CHECK)
00464         throw(OP_WITH_WRONG_DIM)
00465 #else
00466         throw()
00467 #endif
00468         { _mvmvaccu(dp,rv1,rv2); }
00469         INLINE void accumulate(dotprecision &dp, const l_rvector & rv1, const l_rmatrix_subv &rv2)
00470 #if(CXSC_INDEX_CHECK)
00471         throw(OP_WITH_WRONG_DIM)
00472 #else
00473         throw()
00474 #endif
00475         { _vmvaccu(dp,rv1,rv2); }
00476         INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const l_rvector &rv2)
00477 #if(CXSC_INDEX_CHECK)
00478         throw(OP_WITH_WRONG_DIM)
00479 #else
00480         throw()
00481 #endif
00482         { _vmvaccu(dp,rv2,rv1); }
00483         INLINE void accumulate(dotprecision &dp, const l_rvector_slice & sl1, const l_rmatrix_subv &rv2)
00484 #if(CXSC_INDEX_CHECK)
00485         throw(OP_WITH_WRONG_DIM)
00486 #else
00487         throw()
00488 #endif
00489         { _vmvaccu(dp,l_rvector(sl1),rv2); }
00490         INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const l_rvector_slice &sl2)
00491 #if(CXSC_INDEX_CHECK)
00492         throw(OP_WITH_WRONG_DIM)
00493 #else
00494         throw()
00495 #endif
00496         { _vmvaccu(dp,l_rvector(sl2),rv1); }
00497         INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const l_rmatrix_subv &rv2)
00498 #if(CXSC_INDEX_CHECK)
00499         throw(OP_WITH_WRONG_DIM)
00500 #else
00501         throw()
00502 #endif
00503         { _mvmvaccu(dp,rv1,rv2); }
00504         INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const l_rmatrix_subv &rv2)
00505 #if(CXSC_INDEX_CHECK)
00506         throw(OP_WITH_WRONG_DIM)
00507 #else
00508         throw()
00509 #endif
00510         { _vmvaccu(dp,rv1,rv2); }
00511         INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const l_rvector &rv2)
00512 #if(CXSC_INDEX_CHECK)
00513         throw(OP_WITH_WRONG_DIM)
00514 #else
00515         throw()
00516 #endif
00517         { _vmvaccu(dp,rv2,rv1); }
00518         INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl1, const l_rmatrix_subv &rv2)
00519 #if(CXSC_INDEX_CHECK)
00520         throw(OP_WITH_WRONG_DIM)
00521 #else
00522         throw()
00523 #endif
00524         { _vmvaccu(dp,l_rvector(sl1),rv2); }
00525         INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const l_rvector_slice &sl2)
00526 #if(CXSC_INDEX_CHECK)
00527         throw(OP_WITH_WRONG_DIM)
00528 #else
00529         throw()
00530 #endif
00531         { _vmvaccu(dp,l_rvector(sl2),rv1); }
00532         INLINE l_real operator *(const l_rmatrix_subv & rv1, const l_rmatrix_subv &rv2)
00533 #if(CXSC_INDEX_CHECK)
00534         throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
00535 #else
00536         throw()
00537 #endif
00538         { return _mvmvlmult<l_rmatrix_subv,l_rmatrix_subv,l_real>(rv1,rv2); }
00539         INLINE l_real operator *(const l_rvector & rv1, const l_rmatrix_subv &rv2)
00540 #if(CXSC_INDEX_CHECK)
00541         throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
00542 #else
00543         throw()
00544 #endif
00545         { return _vmvlmult<l_rvector,l_rmatrix_subv,l_real>(rv1,rv2); }
00546         INLINE l_real operator *(const l_rmatrix_subv &rv1,const l_rvector &rv2)
00547 #if(CXSC_INDEX_CHECK)
00548         throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
00549 #else
00550         throw()
00551 #endif
00552         { return _vmvlmult<l_rvector,l_rmatrix_subv,l_real>(rv2,rv1); }
00553         INLINE l_real operator *(const l_rvector_slice &sl,const l_rmatrix_subv &sv)
00554 #if(CXSC_INDEX_CHECK)
00555         throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
00556 #else
00557         throw()
00558 #endif
00559         { return _vmvlmult<l_rvector,l_rmatrix_subv,l_real>(l_rvector(sl),sv); }
00560         INLINE l_real operator *(const l_rmatrix_subv &mv,const l_rvector_slice &vs)
00561 #if(CXSC_INDEX_CHECK)
00562         throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
00563 #else
00564         throw()
00565 #endif
00566         { return _vmvlmult<l_rvector,l_rmatrix_subv,l_real>(l_rvector(vs),mv); }
00567         INLINE l_rvector operator +(const l_rmatrix_subv & rv1, const l_rmatrix_subv &rv2)
00568 #if(CXSC_INDEX_CHECK)
00569         throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
00570 #else
00571         throw()
00572 #endif
00573         { return _mvmvplus<l_rmatrix_subv,l_rmatrix_subv,l_rvector>(rv1,rv2); }
00574         INLINE l_rvector operator +(const l_rmatrix_subv &rv1,const l_rvector &rv2)
00575 #if(CXSC_INDEX_CHECK)
00576         throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
00577 #else
00578         throw()
00579 #endif
00580         { return _mvvplus<l_rmatrix_subv,l_rvector,l_rvector>(rv1,rv2); }
00581         INLINE l_rvector operator +(const l_rvector & rv1, const l_rmatrix_subv &rv2)
00582 #if(CXSC_INDEX_CHECK)
00583         throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
00584 #else
00585         throw()
00586 #endif
00587         { return _mvvplus<l_rmatrix_subv,l_rvector,l_rvector>(rv2,rv1); }
00588         INLINE l_rvector operator +(const l_rvector_slice &sl,const l_rmatrix_subv &mv)
00589 #if(CXSC_INDEX_CHECK)
00590         throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
00591 #else
00592         throw()
00593 #endif
00594         { return _mvvplus<l_rmatrix_subv,l_rvector,l_rvector>(mv,l_rvector(sl)); }
00595         INLINE l_rvector operator +(const l_rmatrix_subv &mv,const l_rvector_slice &sl)
00596 #if(CXSC_INDEX_CHECK)
00597         throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
00598 #else
00599         throw()
00600 #endif
00601         { return _mvvplus<l_rmatrix_subv,l_rvector,l_rvector>(mv,l_rvector(sl)); }
00602         INLINE l_rmatrix_subv &l_rmatrix_subv::operator +=(const l_rvector &rv)
00603 #if(CXSC_INDEX_CHECK)
00604         throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
00605 #else
00606         throw()
00607 #endif
00608         { return _mvvplusassign(*this,rv); }
00609         INLINE l_rmatrix_subv &l_rmatrix_subv::operator +=(const l_rvector_slice &rv)
00610 #if(CXSC_INDEX_CHECK)
00611         throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
00612 #else
00613         throw()
00614 #endif
00615         { return _mvvplusassign(*this,l_rvector(rv)); }
00616         INLINE l_rvector operator -(const l_rmatrix_subv & rv1, const l_rmatrix_subv &rv2)
00617 #if(CXSC_INDEX_CHECK)
00618         throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
00619 #else
00620         throw()
00621 #endif
00622         { return _mvmvminus<l_rmatrix_subv,l_rmatrix_subv,l_rvector>(rv1,rv2); }
00623         INLINE l_rvector operator -(const l_rvector & rv1, const l_rmatrix_subv &rv2)
00624 #if(CXSC_INDEX_CHECK)
00625         throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
00626 #else
00627         throw()
00628 #endif
00629         { return _vmvminus<l_rvector,l_rmatrix_subv,l_rvector>(rv1,rv2); }
00630         INLINE l_rvector operator -(const l_rmatrix_subv &rv1,const l_rvector &rv2)
00631 #if(CXSC_INDEX_CHECK)
00632         throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
00633 #else
00634         throw()
00635 #endif
00636         { return _mvvminus<l_rmatrix_subv,l_rvector,l_rvector>(rv1,rv2); }
00637         INLINE l_rvector operator -(const l_rvector_slice &sl,const l_rmatrix_subv &mv)
00638 #if(CXSC_INDEX_CHECK)
00639         throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
00640 #else
00641         throw()
00642 #endif
00643         { return _vmvminus<l_rvector,l_rmatrix_subv,l_rvector>(l_rvector(sl),mv); }
00644         INLINE l_rvector operator -(const l_rmatrix_subv &mv,const l_rvector_slice &sl)
00645 #if(CXSC_INDEX_CHECK)
00646         throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
00647 #else
00648         throw()
00649 #endif
00650         { return _mvvminus<l_rmatrix_subv,l_rvector,l_rvector>(mv,l_rvector(sl)); }
00651         INLINE l_rmatrix_subv &l_rmatrix_subv::operator -=(const l_rvector &rv)
00652 #if(CXSC_INDEX_CHECK)
00653         throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
00654 #else
00655         throw()
00656 #endif
00657         { return _mvvminusassign(*this,rv); }
00658         INLINE l_rmatrix_subv &l_rmatrix_subv::operator -=(const l_rvector_slice &rv)
00659 #if(CXSC_INDEX_CHECK)
00660         throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
00661 #else
00662         throw()
00663 #endif
00664         { return _mvvminusassign(*this,l_rvector(rv)); }
00665 //  real
00666         INLINE void accumulate(dotprecision &dp, const rmatrix_subv & rv1, const l_rmatrix_subv &rv2)
00667 #if(CXSC_INDEX_CHECK)
00668         throw(OP_WITH_WRONG_DIM)
00669 #else
00670         throw()
00671 #endif
00672         { _mvmvaccu(dp,rv1,rv2); }
00673         INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const rmatrix_subv &rv2)
00674 #if(CXSC_INDEX_CHECK)
00675         throw(OP_WITH_WRONG_DIM)
00676 #else
00677         throw()
00678 #endif
00679         { _mvmvaccu(dp,rv2,rv1); }
00680         INLINE void accumulate(dotprecision &dp, const rvector & rv1, const l_rmatrix_subv &rv2)
00681 #if(CXSC_INDEX_CHECK)
00682         throw(OP_WITH_WRONG_DIM)
00683 #else
00684         throw()
00685 #endif
00686         { _vmvaccu(dp,rv1,rv2); }
00687         INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const rvector &rv2)
00688 #if(CXSC_INDEX_CHECK)
00689         throw(OP_WITH_WRONG_DIM)
00690 #else
00691         throw()
00692 #endif
00693         { _vmvaccu(dp,rv2,rv1); }
00694         INLINE void accumulate(dotprecision &dp, const rvector_slice & sl1, const l_rmatrix_subv &rv2)
00695 #if(CXSC_INDEX_CHECK)
00696         throw(OP_WITH_WRONG_DIM)
00697 #else
00698         throw()
00699 #endif
00700         { _vmvaccu(dp,rvector(sl1),rv2); }
00701         INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const rvector_slice &sl2)
00702 #if(CXSC_INDEX_CHECK)
00703         throw(OP_WITH_WRONG_DIM)
00704 #else
00705         throw()
00706 #endif
00707         { _vmvaccu(dp,rvector(sl2),rv1); }
00708 
00709         INLINE void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const l_rmatrix_subv &rv2)
00710 #if(CXSC_INDEX_CHECK)
00711         throw(OP_WITH_WRONG_DIM)
00712 #else
00713         throw()
00714 #endif
00715         { _mvmvaccu(dp,rv1,rv2); }
00716         INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const rmatrix_subv &rv2)
00717 #if(CXSC_INDEX_CHECK)
00718         throw(OP_WITH_WRONG_DIM)
00719 #else
00720         throw()
00721 #endif
00722         { _mvmvaccu(dp,rv2,rv1); }
00723         INLINE void accumulate(idotprecision &dp, const rvector & rv1, const l_rmatrix_subv &rv2)
00724 #if(CXSC_INDEX_CHECK)
00725         throw(OP_WITH_WRONG_DIM)
00726 #else
00727         throw()
00728 #endif
00729         { _vmvaccu(dp,rv1,rv2); }
00730         INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const rvector &rv2)
00731 #if(CXSC_INDEX_CHECK)
00732         throw(OP_WITH_WRONG_DIM)
00733 #else
00734         throw()
00735 #endif
00736         { _vmvaccu(dp,rv2,rv1); }
00737         INLINE void accumulate(idotprecision &dp, const rvector_slice & sl1, const l_rmatrix_subv &rv2)
00738 #if(CXSC_INDEX_CHECK)
00739         throw(OP_WITH_WRONG_DIM)
00740 #else
00741         throw()
00742 #endif
00743         { _vmvaccu(dp,rvector(sl1),rv2); }
00744         INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const rvector_slice &sl2)
00745 #if(CXSC_INDEX_CHECK)
00746         throw(OP_WITH_WRONG_DIM)
00747 #else
00748         throw()
00749 #endif
00750         { _vmvaccu(dp,rvector(sl2),rv1); }
00751 
00752         INLINE l_rmatrix_subv &l_rmatrix_subv::operator +=(const rvector &rv)
00753 #if(CXSC_INDEX_CHECK)
00754         throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
00755 #else
00756         throw()
00757 #endif
00758         { return _mvvplusassign(*this,rv); }
00759         INLINE l_rmatrix_subv &l_rmatrix_subv::operator +=(const rvector_slice &rv)
00760 #if(CXSC_INDEX_CHECK)
00761         throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
00762 #else
00763         throw()
00764 #endif
00765         { return _mvvplusassign(*this,l_rvector(rv)); }
00766         INLINE l_rmatrix_subv &l_rmatrix_subv::operator -=(const rvector &rv)
00767 #if(CXSC_INDEX_CHECK)
00768         throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
00769 #else
00770         throw()
00771 #endif
00772         { return _mvvminusassign(*this,rv); }
00773         INLINE l_rmatrix_subv &l_rmatrix_subv::operator -=(const rvector_slice &rv)
00774 #if(CXSC_INDEX_CHECK)
00775         throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM)
00776 #else
00777         throw()
00778 #endif
00779         { return _mvvminusassign(*this,rvector(rv)); }
00780 
00781 // l_rmatrix x l_rmatrix        
00787         INLINE l_rmatrix _l_rmatrix(const l_rmatrix &rm) throw() { return rm; }
00793         INLINE l_rmatrix _l_rmatrix(const l_rvector &v) throw() { return l_rmatrix(v); }
00799         INLINE l_rmatrix _l_rmatrix(const l_rvector_slice &v) throw() { return l_rmatrix(v); }
00805         INLINE l_rmatrix _l_rmatrix(const l_real &r) throw() { return l_rmatrix(r); }
00806         INLINE int Lb(const l_rmatrix &rm, const int &i)
00807 #if(CXSC_INDEX_CHECK)
00808         throw(ERROR_LRMATRIX_WRONG_ROW_OR_COL)
00809 #else
00810         throw()
00811 #endif
00812         { return _mlb(rm,i); }
00813         INLINE int Ub(const l_rmatrix &rm, const int &i)
00814 #if(CXSC_INDEX_CHECK)
00815         throw(ERROR_LRMATRIX_WRONG_ROW_OR_COL)
00816 #else
00817         throw()
00818 #endif
00819         { return _mub(rm,i); }
00820         INLINE int Lb(const l_rmatrix_slice &rm, const int &i)
00821 #if(CXSC_INDEX_CHECK)
00822         throw(ERROR_LRMATRIX_WRONG_ROW_OR_COL)
00823 #else
00824         throw()
00825 #endif
00826         { return _mslb(rm,i); }
00827         INLINE int Ub(const l_rmatrix_slice &rm, const int &i)
00828 #if(CXSC_INDEX_CHECK)
00829         throw(ERROR_LRMATRIX_WRONG_ROW_OR_COL)
00830 #else
00831         throw()
00832 #endif
00833         { return _msub(rm,i); }
00834         INLINE l_rmatrix &SetLb(l_rmatrix &m, const int &i,const int &j)
00835 #if(CXSC_INDEX_CHECK)
00836         throw(ERROR_LRMATRIX_WRONG_ROW_OR_COL)
00837 #else
00838         throw()
00839 #endif
00840         { return _msetlb(m,i,j); }
00841         INLINE l_rmatrix &SetUb(l_rmatrix &m, const int &i,const int &j)
00842 #if(CXSC_INDEX_CHECK)
00843         throw(ERROR_LRMATRIX_WRONG_ROW_OR_COL)
00844 #else
00845         throw()
00846 #endif
00847         { return _msetub(m,i,j); }
00848         
00849         INLINE int RowLen ( const l_rmatrix& A ) // Length of the rows of a matrix
00850         { return Ub(A,2)-Lb(A,2)+1; }            //-------------------------------
00851       
00852         INLINE int ColLen ( const l_rmatrix& A ) // Length of the columns of a matrix
00853         { return Ub(A,1)-Lb(A,1)+1; }            //----------------------------------
00854 
00855         INLINE int RowLen ( const l_rmatrix_slice& A ) // Length of the rows of a matrix
00856         { return Ub(A,2)-Lb(A,2)+1; }                  //-------------------------------
00857       
00858         INLINE int ColLen ( const l_rmatrix_slice& A ) // Length of the columns of a matrix
00859         { return Ub(A,1)-Lb(A,1)+1; }                  //----------------------------------
00860         
00861         INLINE void Resize(l_rmatrix &A) throw() { _mresize(A);}
00862         INLINE void Resize(l_rmatrix &A,const int &m, const int &n)
00863 #if(CXSC_INDEX_CHECK)
00864         throw(ERROR_LRMATRIX_WRONG_BOUNDARIES)
00865 #else
00866         throw()
00867 #endif
00868         { _mresize<l_rmatrix,l_real>(A,m,n); }
00869         INLINE void Resize(l_rmatrix &A,const int &m1, const int &m2,const int &n1,const int &n2)
00870 #if(CXSC_INDEX_CHECK)
00871         throw(ERROR_LRMATRIX_WRONG_BOUNDARIES)
00872 #else
00873         throw()
00874 #endif
00875         { _mresize<l_rmatrix,l_real>(A,m1,m2,n1,n2); }
00876         INLINE l_rmatrix abs(const l_rmatrix &m) throw() { return _mabs<l_rmatrix,l_rmatrix>(m); }
00877         INLINE l_rmatrix abs(const l_rmatrix_slice &ms) throw() { return _msabs<l_rmatrix_slice,l_rmatrix>(ms); }
00878         INLINE l_real::l_real(const l_rmatrix &m)
00879 #if(CXSC_INDEX_CHECK)
00880         throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ,ERROR_LRMATRIX_USE_OF_UNINITIALIZED_OBJ)
00881 #else
00882         throw()
00883 #endif
00884         { _smconstr(*this,m); }
00885 //      INLINE l_real l_real::_l_real(const l_rmatrix &m) throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ,ERROR_LRMATRIX_USE_OF_UNINITIALIZED_OBJ) { _smconstr(*this,m); return *this; }
00886         INLINE l_rmatrix operator *(const l_real &c, const l_rmatrix &m) throw() { return _smmult<l_real,l_rmatrix,l_rmatrix>(c,m); }
00887         INLINE l_rmatrix operator *(const l_real &c, const l_rmatrix_slice &ms) throw() { return _smsmult<l_real,l_rmatrix_slice,l_rmatrix>(c,ms); }
00888         INLINE l_rmatrix operator *(const l_rmatrix &m,const l_real &c) throw() { return _smmult<l_real,l_rmatrix,l_rmatrix>(c,m); }
00889         INLINE l_rmatrix operator *(const l_rmatrix_slice &ms,const l_real &c) throw() { return _smsmult<l_real,l_rmatrix_slice,l_rmatrix>(c,ms); }
00890         INLINE l_rmatrix &operator *=(l_rmatrix &m,const l_real &c) throw() { return _msmultassign(m,c); }
00891         INLINE l_rmatrix_slice &l_rmatrix_slice::operator *=(const l_rmatrix &m)
00892 #if(CXSC_INDEX_CHECK)
00893         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
00894 #else
00895         throw()
00896 #endif
00897         { return (*this=*this*m); }
00898         INLINE l_rmatrix_slice &l_rmatrix_slice::operator *=(const l_rmatrix_slice &m)
00899 #if(CXSC_INDEX_CHECK)
00900         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
00901 #else
00902         throw()
00903 #endif
00904         { return (*this=*this*m); }
00905         INLINE l_rmatrix_slice &l_rmatrix_slice::operator *=(const l_real &c) throw() { return _mssmultassign(*this,c); }
00906         INLINE l_rmatrix operator /(const l_rmatrix &m,const l_real &c) throw() { return _msdiv<l_rmatrix,l_real,l_rmatrix>(m,c); }
00907         INLINE l_rmatrix operator /(const l_rmatrix_slice &ms, const l_real &c) throw() { return _mssdiv<l_rmatrix_slice,l_real,l_rmatrix>(ms,c); }
00908         INLINE l_rmatrix &operator /=(l_rmatrix &m,const l_real &c) throw() { return _msdivassign(m,c); }
00909         INLINE l_rmatrix_slice &l_rmatrix_slice::operator /=(const l_real &c) throw() { return _mssdivassign(*this,c); }
00910         INLINE l_rmatrix operator *(const real &c, const l_rmatrix &m) throw() { return _smmult<real,l_rmatrix,l_rmatrix>(c,m); }
00911         INLINE l_rmatrix operator *(const real &c, const l_rmatrix_slice &ms) throw() { return _smsmult<real,l_rmatrix_slice,l_rmatrix>(c,ms); }
00912         INLINE l_rmatrix operator *(const l_rmatrix &m,const real &c) throw() { return _smmult<real,l_rmatrix,l_rmatrix>(c,m); }
00913         INLINE l_rmatrix operator *(const l_rmatrix_slice &ms,const real &c) throw() { return _smsmult<real,l_rmatrix_slice,l_rmatrix>(c,ms); }
00914         INLINE l_rmatrix &operator *=(l_rmatrix &m,const real &c) throw() { return _msmultassign(m,c); }
00915         INLINE l_rmatrix_slice &l_rmatrix_slice::operator *=(const rmatrix &m)
00916 #if(CXSC_INDEX_CHECK)
00917         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
00918 #else
00919         throw()
00920 #endif
00921         { return (*this=*this*m); }
00922         INLINE l_rmatrix_slice &l_rmatrix_slice::operator *=(const rmatrix_slice &m)
00923 #if(CXSC_INDEX_CHECK)
00924         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
00925 #else
00926         throw()
00927 #endif
00928         { return (*this=*this*m); }
00929         INLINE l_rmatrix_slice &l_rmatrix_slice::operator *=(const real &c) throw() { return _mssmultassign(*this,c); }
00930         INLINE l_rmatrix operator /(const l_rmatrix &m,const real &c) throw() { return _msdiv<l_rmatrix,real,l_rmatrix>(m,c); }
00931         INLINE l_rmatrix operator /(const l_rmatrix_slice &ms, const real &c) throw() { return _mssdiv<l_rmatrix_slice,real,l_rmatrix>(ms,c); }
00932         INLINE l_rmatrix &operator /=(l_rmatrix &m,const real &c) throw() { return _msdivassign(m,c); }
00933         INLINE l_rmatrix_slice &l_rmatrix_slice::operator /=(const real &c) throw() { return _mssdivassign(*this,c); }
00934 //      INLINE l_real::l_real(const rmatrix &m) throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ,ERROR_LRMATRIX_USE_OF_UNINITIALIZED_OBJ) { _smconstr(*this,m); }
00935 //      INLINE l_real l_real::_l_real(const l_rmatrix &m) throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ,ERROR_LRMATRIX_USE_OF_UNINITIALIZED_OBJ) { _smconstr(*this,m); return *this; }
00936         INLINE l_rmatrix operator *(const l_real &c, const rmatrix &m) throw() { return _smmult<l_real,rmatrix,l_rmatrix>(c,m); }
00937         INLINE l_rmatrix operator *(const l_real &c, const rmatrix_slice &ms) throw() { return _smsmult<l_real,rmatrix_slice,l_rmatrix>(c,ms); }
00938         INLINE l_rmatrix operator *(const rmatrix &m,const l_real &c) throw() { return _smmult<l_real,rmatrix,l_rmatrix>(c,m); }
00939         INLINE l_rmatrix operator *(const rmatrix_slice &ms,const l_real &c) throw() { return _smsmult<l_real,rmatrix_slice,l_rmatrix>(c,ms); }
00940         INLINE l_rmatrix operator /(const rmatrix &m,const l_real &c) throw() { return _msdiv<rmatrix,l_real,l_rmatrix>(m,c); }
00941         INLINE l_rmatrix operator /(const rmatrix_slice &ms, const l_real &c) throw() { return _mssdiv<rmatrix_slice,l_real,l_rmatrix>(ms,c); }
00942         INLINE l_rvector::l_rvector(const l_rmatrix &sl)
00943 #if(CXSC_INDEX_CHECK)
00944         throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ)
00945 #else
00946         throw()
00947 #endif
00948         { _vmconstr<l_rvector,l_rmatrix,l_real>(*this,sl); }
00949         INLINE l_rvector::l_rvector(const l_rmatrix_slice &sl)
00950 #if(CXSC_INDEX_CHECK)
00951         throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ)
00952 #else
00953         throw()
00954 #endif
00955         { _vmsconstr<l_rvector,l_rmatrix_slice,l_real>(*this,sl); }
00956         INLINE l_rvector &l_rvector::operator =(const l_rmatrix &m)
00957 #if(CXSC_INDEX_CHECK)
00958         throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ)
00959 #else
00960         throw()
00961 #endif
00962         { return _vmassign<l_rvector,l_rmatrix,l_real>(*this,m); }
00963         INLINE l_rvector &l_rvector::operator =(const l_rmatrix_slice &m)
00964 #if(CXSC_INDEX_CHECK)
00965         throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ)
00966 #else
00967         throw()
00968 #endif
00969         { return _vmassign<l_rvector,l_rmatrix,l_real>(*this,l_rmatrix(m)); }
00970         INLINE l_rvector_slice & l_rvector_slice::operator =(const l_rmatrix_slice &m)
00971 #if(CXSC_INDEX_CHECK)
00972         throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>,ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ)
00973 #else
00974         throw()
00975 #endif
00976         { return _vsvassign(*this,l_rvector(l_rmatrix(m))); }
00977         INLINE l_rmatrix_subv &l_rmatrix_subv::operator =(const l_rmatrix &m)
00978 #if(CXSC_INDEX_CHECK)
00979         throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ)
00980 #else
00981         throw()
00982 #endif
00983         { return _mvvassign(*this,l_rvector(m)); }
00984         INLINE l_rmatrix_subv &l_rmatrix_subv::operator =(const l_rmatrix_slice &m)
00985 #if(CXSC_INDEX_CHECK)
00986         throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ)
00987 #else
00988         throw()
00989 #endif
00990         { return _mvvassign(*this,l_rvector(l_rmatrix(m))); }
00991         INLINE l_rvector operator *(const l_rmatrix &m,const l_rvector &v)
00992 #if(CXSC_INDEX_CHECK)
00993         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
00994 #else
00995         throw()
00996 #endif
00997         { return _mvlmult<l_rmatrix,l_rvector,l_rvector>(m,v); }
00998         INLINE l_rvector operator *(const l_rmatrix_slice &ms,const l_rvector &v)
00999 #if(CXSC_INDEX_CHECK)
01000         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01001 #else
01002         throw()
01003 #endif
01004         { return _msvlmult<l_rmatrix_slice,l_rvector,l_rvector>(ms,v); }
01005         INLINE l_rvector operator *(const l_rvector &v,const l_rmatrix &m)
01006 #if(CXSC_INDEX_CHECK)
01007         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01008 #else
01009         throw()
01010 #endif
01011         { return _vmlmult<l_rvector,l_rmatrix,l_rvector>(v,m); }
01012         INLINE l_rvector operator *(const l_rvector &v,const l_rmatrix_slice &ms)
01013 #if(CXSC_INDEX_CHECK)
01014         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01015 #else
01016         throw()
01017 #endif
01018         { return _vmslmult<l_rvector,l_rmatrix_slice,l_rvector>(v,ms); }
01019         INLINE l_rvector &operator *=(l_rvector &v,const l_rmatrix &m)
01020 #if(CXSC_INDEX_CHECK)
01021         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01022 #else
01023         throw()
01024 #endif
01025         { return _vmlmultassign<l_rvector,l_rmatrix,l_real>(v,m); }
01026         INLINE l_rvector &operator *=(l_rvector &v,const l_rmatrix_slice &ms)
01027 #if(CXSC_INDEX_CHECK)
01028         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01029 #else
01030         throw()
01031 #endif
01032         { return _vmslmultassign<l_rvector,l_rmatrix_slice,l_real>(v,ms); }
01033         INLINE l_rvector_slice &l_rvector_slice::operator *=(const l_rmatrix &m)
01034 #if(CXSC_INDEX_CHECK)
01035         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01036 #else
01037         throw()
01038 #endif
01039         { return _vsmlmultassign<l_rvector_slice,l_rmatrix,l_real>(*this,m); }
01040         INLINE l_rvector operator *(const l_rvector_slice &v,const l_rmatrix &m)
01041 #if(CXSC_INDEX_CHECK)
01042         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01043 #else
01044         throw()
01045 #endif
01046         { return _vmlmult<l_rvector,l_rmatrix,l_rvector>(l_rvector(v),m); }
01047         INLINE l_rvector operator *(const l_rvector_slice &v,const l_rmatrix_slice &m)
01048 #if(CXSC_INDEX_CHECK)
01049         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01050 #else
01051         throw()
01052 #endif
01053         { return _vmslmult<l_rvector,l_rmatrix_slice,l_rvector>(l_rvector(v),m); }
01054         INLINE l_rmatrix_subv &l_rmatrix_subv::operator =(const rmatrix &m)
01055 #if(CXSC_INDEX_CHECK)
01056         throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ)
01057 #else
01058         throw()
01059 #endif
01060         { return _mvvassign(*this,rvector(m)); }
01061         INLINE l_rmatrix_subv &l_rmatrix_subv::operator =(const rmatrix_slice &m)
01062 #if(CXSC_INDEX_CHECK)
01063         throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ)
01064 #else
01065         throw()
01066 #endif
01067         { return _mvvassign(*this,rvector(rmatrix(m))); }
01068         INLINE l_rvector operator *(const rvector &v,const l_rmatrix &m)
01069 #if(CXSC_INDEX_CHECK)
01070         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01071 #else
01072         throw()
01073 #endif
01074         { return _vmlmult<rvector,l_rmatrix,l_rvector>(v,m); }
01075         INLINE l_rvector operator *(const rvector &v,const l_rmatrix_slice &ms)
01076 #if(CXSC_INDEX_CHECK)
01077         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01078 #else
01079         throw()
01080 #endif
01081         { return _vmslmult<rvector,l_rmatrix_slice,l_rvector>(v,ms); }
01082         INLINE l_rvector operator *(const rvector_slice &v,const l_rmatrix &m)
01083 #if(CXSC_INDEX_CHECK)
01084         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01085 #else
01086         throw()
01087 #endif
01088         { return _vmlmult<l_rvector,l_rmatrix,l_rvector>(l_rvector(v),m); }
01089         INLINE l_rvector operator *(const l_rmatrix &m,const rvector &v)
01090 #if(CXSC_INDEX_CHECK)
01091         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01092 #else
01093         throw()
01094 #endif
01095         { return _mvlmult<l_rmatrix,rvector,l_rvector>(m,v); }
01096         INLINE l_rvector operator *(const l_rmatrix_slice &ms,const rvector &v)
01097 #if(CXSC_INDEX_CHECK)
01098         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01099 #else
01100         throw()
01101 #endif
01102         { return _msvlmult<l_rmatrix_slice,rvector,l_rvector>(ms,v); }
01103 
01104         INLINE const l_rmatrix &operator +(const l_rmatrix &m) throw() { return m; }
01105         INLINE l_rmatrix operator +(const l_rmatrix_slice &m) throw() { return l_rmatrix(m); }
01106         INLINE l_rmatrix operator +(const l_rmatrix &m1,const l_rmatrix &m2)
01107 #if(CXSC_INDEX_CHECK)
01108         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01109 #else
01110         throw()
01111 #endif
01112         { return _mmplus<l_rmatrix,l_rmatrix,l_rmatrix>(m1,m2); }
01113         INLINE l_rmatrix operator +(const l_rmatrix &m,const l_rmatrix_slice &ms)
01114 #if(CXSC_INDEX_CHECK)
01115         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01116 #else
01117         throw()
01118 #endif
01119         { return _mmsplus<l_rmatrix,l_rmatrix_slice,l_rmatrix>(m,ms); }
01120         INLINE l_rmatrix operator +(const l_rmatrix_slice &ms,const l_rmatrix &m)
01121 #if(CXSC_INDEX_CHECK)
01122         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01123 #else
01124         throw()
01125 #endif
01126         { return _mmsplus<l_rmatrix,l_rmatrix_slice,l_rmatrix>(m,ms); }
01127         INLINE l_rmatrix operator +(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2)
01128 #if(CXSC_INDEX_CHECK)
01129         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01130 #else
01131         throw()
01132 #endif
01133         { return _msmsplus<l_rmatrix_slice,l_rmatrix_slice,l_rmatrix>(m1,m2); }
01134         INLINE l_rmatrix &operator +=(l_rmatrix &m1,const l_rmatrix &m2)
01135 #if(CXSC_INDEX_CHECK)
01136         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01137 #else
01138         throw()
01139 #endif
01140         { return _mmplusassign(m1,m2); }
01141         INLINE l_rmatrix &operator +=(l_rmatrix &m1,const l_rmatrix_slice &ms)
01142 #if(CXSC_INDEX_CHECK)
01143         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01144 #else
01145         throw()
01146 #endif
01147         { return _mmsplusassign(m1,ms); }
01148         INLINE l_rmatrix_slice &l_rmatrix_slice::operator +=(const l_rmatrix &m1)
01149 #if(CXSC_INDEX_CHECK)
01150         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01151 #else
01152         throw()
01153 #endif
01154         { return _msmplusassign(*this,m1); }
01155         INLINE l_rmatrix_slice &l_rmatrix_slice::operator +=(const l_rmatrix_slice &ms2)
01156 #if(CXSC_INDEX_CHECK)
01157         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01158 #else
01159         throw()
01160 #endif
01161         { return _msmsplusassign(*this,ms2); }
01162         INLINE l_rmatrix operator -(const l_rmatrix &m) throw() { return _mminus(m); }
01163         INLINE l_rmatrix operator -(const l_rmatrix_slice &m) throw() { return _msminus<l_rmatrix_slice,l_rmatrix>(m); }
01164         INLINE l_rmatrix operator -(const l_rmatrix &m1,const l_rmatrix &m2)
01165 #if(CXSC_INDEX_CHECK)
01166         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01167 #else
01168         throw()
01169 #endif
01170         { return _mmminus<l_rmatrix,l_rmatrix,l_rmatrix>(m1,m2); }
01171         INLINE l_rmatrix operator -(const l_rmatrix &m,const l_rmatrix_slice &ms)
01172 #if(CXSC_INDEX_CHECK)
01173         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01174 #else
01175         throw()
01176 #endif
01177         { return _mmsminus<l_rmatrix,l_rmatrix_slice,l_rmatrix>(m,ms); }
01178         INLINE l_rmatrix operator -(const l_rmatrix_slice &ms,const l_rmatrix &m)
01179 #if(CXSC_INDEX_CHECK)
01180         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01181 #else
01182         throw()
01183 #endif
01184         { return _msmminus<l_rmatrix_slice,l_rmatrix,l_rmatrix>(ms,m); }
01185         INLINE l_rmatrix operator -(const l_rmatrix_slice &ms1,const l_rmatrix_slice &ms2)
01186 #if(CXSC_INDEX_CHECK)
01187         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01188 #else
01189         throw()
01190 #endif
01191         { return _msmsminus<l_rmatrix_slice,l_rmatrix_slice,l_rmatrix>(ms1,ms2); }
01192         INLINE l_rmatrix &operator -=(l_rmatrix &m1,const l_rmatrix &m2)
01193 #if(CXSC_INDEX_CHECK)
01194         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01195 #else
01196         throw()
01197 #endif
01198         { return _mmminusassign(m1,m2); }
01199         INLINE l_rmatrix &operator -=(l_rmatrix &m1,const l_rmatrix_slice &ms)
01200 #if(CXSC_INDEX_CHECK)
01201         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01202 #else
01203         throw()
01204 #endif
01205         { return _mmsminusassign(m1,ms); }
01206         INLINE l_rmatrix_slice &l_rmatrix_slice::operator -=(const l_rmatrix &m1)
01207 #if(CXSC_INDEX_CHECK)
01208         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01209 #else
01210         throw()
01211 #endif
01212         { return _msmminusassign(*this,m1); }
01213         INLINE l_rmatrix_slice &l_rmatrix_slice::operator -=(const l_rmatrix_slice &ms2)
01214 #if(CXSC_INDEX_CHECK)
01215         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01216 #else
01217         throw()
01218 #endif
01219         { return _msmsminusassign(*this,ms2); }
01220         INLINE l_rmatrix operator *(const l_rmatrix &m1, const l_rmatrix &m2)
01221 #if(CXSC_INDEX_CHECK)
01222         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01223 #else
01224         throw()
01225 #endif
01226         { return _mmlmult<l_rmatrix,l_rmatrix,l_rmatrix>(m1,m2); }
01227         INLINE l_rmatrix operator *(const l_rmatrix &m1, const l_rmatrix_slice &ms)
01228 #if(CXSC_INDEX_CHECK)
01229         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01230 #else
01231         throw()
01232 #endif
01233         { return _mmslmult<l_rmatrix,l_rmatrix_slice,l_rmatrix>(m1,ms); }
01234         INLINE l_rmatrix operator *(const l_rmatrix_slice &ms, const l_rmatrix &m1)
01235 #if(CXSC_INDEX_CHECK)
01236         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01237 #else
01238         throw()
01239 #endif
01240         { return _msmlmult<l_rmatrix_slice,l_rmatrix,l_rmatrix>(ms,m1); }
01241         INLINE l_rmatrix operator *(const l_rmatrix_slice &ms1, const l_rmatrix_slice &ms2)
01242 #if(CXSC_INDEX_CHECK)
01243         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01244 #else
01245         throw()
01246 #endif
01247         { return _msmslmult<l_rmatrix_slice,l_rmatrix_slice,l_rmatrix>(ms1,ms2); }
01248         INLINE l_rmatrix &operator *=(l_rmatrix &m1,const l_rmatrix &m2)
01249 #if(CXSC_INDEX_CHECK)
01250         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01251 #else
01252         throw()
01253 #endif
01254         { return _mmlmultassign<l_rmatrix,l_rmatrix,l_real>(m1,m2); }
01255         INLINE l_rmatrix &operator *=(l_rmatrix &m1,const l_rmatrix_slice &ms)
01256 #if(CXSC_INDEX_CHECK)
01257         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01258 #else
01259         throw()
01260 #endif
01261         { return _mmslmultassign<l_rmatrix,l_rmatrix_slice,l_real>(m1,ms); }
01262         INLINE l_rmatrix operator +(const rmatrix &m1,const l_rmatrix &m2)
01263 #if(CXSC_INDEX_CHECK)
01264         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01265 #else
01266         throw()
01267 #endif
01268         { return _mmplus<rmatrix,l_rmatrix,l_rmatrix>(m1,m2); }
01269         INLINE l_rmatrix operator +(const l_rmatrix &m1,const rmatrix &m2)
01270 #if(CXSC_INDEX_CHECK)
01271         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01272 #else
01273         throw()
01274 #endif
01275         { return _mmplus<rmatrix,l_rmatrix,l_rmatrix>(m2,m1); }
01276         INLINE l_rmatrix operator +(const rmatrix &m,const l_rmatrix_slice &ms)
01277 #if(CXSC_INDEX_CHECK)
01278         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01279 #else
01280         throw()
01281 #endif
01282         { return _mmsplus<rmatrix,l_rmatrix_slice,l_rmatrix>(m,ms); }
01283         INLINE l_rmatrix operator +(const l_rmatrix &m,const rmatrix_slice &ms)
01284 #if(CXSC_INDEX_CHECK)
01285         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01286 #else
01287         throw()
01288 #endif
01289         { return _mmsplus<l_rmatrix,rmatrix_slice,l_rmatrix>(m,ms); }
01290         INLINE l_rmatrix operator +(const rmatrix_slice &ms,const l_rmatrix &m)
01291 #if(CXSC_INDEX_CHECK)
01292         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01293 #else
01294         throw()
01295 #endif
01296         { return _mmsplus<l_rmatrix,rmatrix_slice,l_rmatrix>(m,ms); }
01297         INLINE l_rmatrix operator +(const l_rmatrix_slice &ms,const rmatrix &m)
01298 #if(CXSC_INDEX_CHECK)
01299         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01300 #else
01301         throw()
01302 #endif
01303         { return _mmsplus<rmatrix,l_rmatrix_slice,l_rmatrix>(m,ms); }
01304         INLINE l_rmatrix operator +(const rmatrix_slice &m1,const l_rmatrix_slice &m2)
01305 #if(CXSC_INDEX_CHECK)
01306         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01307 #else
01308         throw()
01309 #endif
01310         { return _msmsplus<rmatrix_slice,l_rmatrix_slice,l_rmatrix>(m1,m2); }
01311         INLINE l_rmatrix operator +(const l_rmatrix_slice &m1,const rmatrix_slice &m2)
01312 #if(CXSC_INDEX_CHECK)
01313         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01314 #else
01315         throw()
01316 #endif
01317         { return _msmsplus<rmatrix_slice,l_rmatrix_slice,l_rmatrix>(m2,m1); }
01318         INLINE l_rmatrix &operator +=(l_rmatrix &m1,const rmatrix &m2)
01319 #if(CXSC_INDEX_CHECK)
01320         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01321 #else
01322         throw()
01323 #endif
01324         { return _mmplusassign(m1,m2); }
01325         INLINE l_rmatrix &operator +=(l_rmatrix &m1,const rmatrix_slice &ms)
01326 #if(CXSC_INDEX_CHECK)
01327         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01328 #else
01329         throw()
01330 #endif
01331         { return _mmsplusassign(m1,ms); }
01332         INLINE l_rmatrix_slice &l_rmatrix_slice::operator +=(const rmatrix &m1)
01333 #if(CXSC_INDEX_CHECK)
01334         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01335 #else
01336         throw()
01337 #endif
01338         { return _msmplusassign(*this,m1); }
01339         INLINE l_rmatrix_slice &l_rmatrix_slice::operator +=(const rmatrix_slice &ms2)
01340 #if(CXSC_INDEX_CHECK)
01341         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01342 #else
01343         throw()
01344 #endif
01345         { return _msmsplusassign(*this,ms2); }
01346         INLINE l_rmatrix operator -(const rmatrix &m1,const l_rmatrix &m2)
01347 #if(CXSC_INDEX_CHECK)
01348         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01349 #else
01350         throw()
01351 #endif
01352         { return _mmminus<rmatrix,l_rmatrix,l_rmatrix>(m1,m2); }
01353         INLINE l_rmatrix operator -(const l_rmatrix &m1,const rmatrix &m2)
01354 #if(CXSC_INDEX_CHECK)
01355         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01356 #else
01357         throw()
01358 #endif
01359         { return _mmminus<l_rmatrix,rmatrix,l_rmatrix>(m1,m2); }
01360         INLINE l_rmatrix operator -(const rmatrix &m,const l_rmatrix_slice &ms)
01361 #if(CXSC_INDEX_CHECK)
01362         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01363 #else
01364         throw()
01365 #endif
01366         { return _mmsminus<rmatrix,l_rmatrix_slice,l_rmatrix>(m,ms); }
01367         INLINE l_rmatrix operator -(const l_rmatrix &m,const rmatrix_slice &ms)
01368 #if(CXSC_INDEX_CHECK)
01369         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01370 #else
01371         throw()
01372 #endif
01373         { return _mmsminus<l_rmatrix,rmatrix_slice,l_rmatrix>(m,ms); }
01374         INLINE l_rmatrix operator -(const rmatrix_slice &ms,const l_rmatrix &m)
01375 #if(CXSC_INDEX_CHECK)
01376         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01377 #else
01378         throw()
01379 #endif
01380         { return _msmminus<rmatrix_slice,l_rmatrix,l_rmatrix>(ms,m); }
01381         INLINE l_rmatrix operator -(const l_rmatrix_slice &ms,const rmatrix &m)
01382 #if(CXSC_INDEX_CHECK)
01383         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01384 #else
01385         throw()
01386 #endif
01387         { return _msmminus<l_rmatrix_slice,rmatrix,l_rmatrix>(ms,m); }
01388         INLINE l_rmatrix operator -(const rmatrix_slice &ms1,const l_rmatrix_slice &ms2)
01389 #if(CXSC_INDEX_CHECK)
01390         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01391 #else
01392         throw()
01393 #endif
01394         { return _msmsminus<rmatrix_slice,l_rmatrix_slice,l_rmatrix>(ms1,ms2); }
01395         INLINE l_rmatrix operator -(const l_rmatrix_slice &ms1,const rmatrix_slice &ms2)
01396 #if(CXSC_INDEX_CHECK)
01397         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01398 #else
01399         throw()
01400 #endif
01401         { return _msmsminus<l_rmatrix_slice,rmatrix_slice,l_rmatrix>(ms1,ms2); }
01402         INLINE l_rmatrix &operator -=(l_rmatrix &m1,const rmatrix &m2)
01403 #if(CXSC_INDEX_CHECK)
01404         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01405 #else
01406         throw()
01407 #endif
01408         { return _mmminusassign(m1,m2); }
01409         INLINE l_rmatrix &operator -=(l_rmatrix &m1,const rmatrix_slice &ms)
01410 #if(CXSC_INDEX_CHECK)
01411         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01412 #else
01413         throw()
01414 #endif
01415         { return _mmsminusassign(m1,ms); }
01416         INLINE l_rmatrix_slice &l_rmatrix_slice::operator -=(const rmatrix &m1)
01417 #if(CXSC_INDEX_CHECK)
01418         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01419 #else
01420         throw()
01421 #endif
01422         { return _msmminusassign(*this,m1); }
01423         INLINE l_rmatrix_slice &l_rmatrix_slice::operator -=(const rmatrix_slice &ms2)
01424 #if(CXSC_INDEX_CHECK)
01425         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01426 #else
01427         throw()
01428 #endif
01429         { return _msmsminusassign(*this,ms2); }
01430         INLINE l_rmatrix operator *(const rmatrix &m1, const l_rmatrix &m2)
01431 #if(CXSC_INDEX_CHECK)
01432         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01433 #else
01434         throw()
01435 #endif
01436         { return _mmlmult<rmatrix,l_rmatrix,l_rmatrix>(m1,m2); }
01437         INLINE l_rmatrix operator *(const l_rmatrix &m1, const rmatrix &m2)
01438 #if(CXSC_INDEX_CHECK)
01439         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01440 #else
01441         throw()
01442 #endif
01443         { return _mmlmult<l_rmatrix,rmatrix,l_rmatrix>(m1,m2); }
01444         INLINE l_rmatrix operator *(const rmatrix &m1, const l_rmatrix_slice &ms)
01445 #if(CXSC_INDEX_CHECK)
01446         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01447 #else
01448         throw()
01449 #endif
01450         { return _mmslmult<rmatrix,l_rmatrix_slice,l_rmatrix>(m1,ms); }
01451         INLINE l_rmatrix operator *(const l_rmatrix &m1, const rmatrix_slice &ms)
01452 #if(CXSC_INDEX_CHECK)
01453         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01454 #else
01455         throw()
01456 #endif
01457         { return _mmslmult<l_rmatrix,rmatrix_slice,l_rmatrix>(m1,ms); }
01458         INLINE l_rmatrix operator *(const rmatrix_slice &ms, const l_rmatrix &m1)
01459 #if(CXSC_INDEX_CHECK)
01460         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01461 #else
01462         throw()
01463 #endif
01464         { return _msmlmult<rmatrix_slice,l_rmatrix,l_rmatrix>(ms,m1); }
01465         INLINE l_rmatrix operator *(const l_rmatrix_slice &ms, const rmatrix &m1)
01466 #if(CXSC_INDEX_CHECK)
01467         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01468 #else
01469         throw()
01470 #endif
01471         { return _msmlmult<l_rmatrix_slice,rmatrix,l_rmatrix>(ms,m1); }
01472         INLINE l_rmatrix operator *(const rmatrix_slice &ms1, const l_rmatrix_slice &ms2)
01473 #if(CXSC_INDEX_CHECK)
01474         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01475 #else
01476         throw()
01477 #endif
01478         { return _msmslmult<rmatrix_slice,l_rmatrix_slice,l_rmatrix>(ms1,ms2); }
01479         INLINE l_rmatrix operator *(const l_rmatrix_slice &ms1, const rmatrix_slice &ms2)
01480 #if(CXSC_INDEX_CHECK)
01481         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01482 #else
01483         throw()
01484 #endif
01485         { return _msmslmult<l_rmatrix_slice,rmatrix_slice,l_rmatrix>(ms1,ms2); }
01486         INLINE l_rmatrix &operator *=(l_rmatrix &m1,const rmatrix &m2)
01487 #if(CXSC_INDEX_CHECK)
01488         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01489 #else
01490         throw()
01491 #endif
01492         { return _mmlmultassign<l_rmatrix,rmatrix,l_real>(m1,m2); }
01493         INLINE l_rmatrix &operator *=(l_rmatrix &m1,const rmatrix_slice &ms)
01494 #if(CXSC_INDEX_CHECK)
01495         throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM)
01496 #else
01497         throw()
01498 #endif
01499         { return _mmslmultassign<l_rmatrix,rmatrix_slice,l_real>(m1,ms); }
01500         INLINE bool operator ==(const l_rmatrix &m1,const l_rmatrix &m2) throw() { return _mmeq(m1,m2); }
01501         INLINE bool operator !=(const l_rmatrix &m1,const l_rmatrix &m2) throw() { return _mmneq(m1,m2); }
01502         INLINE bool operator <(const l_rmatrix &m1,const l_rmatrix &m2) throw() { return _mmless(m1,m2); }
01503         INLINE bool operator <=(const l_rmatrix &m1,const l_rmatrix &m2) throw() { return _mmleq(m1,m2); }
01504         INLINE bool operator >(const l_rmatrix &m1,const l_rmatrix &m2) throw() { return _mmless(m2,m1); }
01505         INLINE bool operator >=(const l_rmatrix &m1,const l_rmatrix &m2) throw() { return _mmleq(m2,m1); }
01506         INLINE bool operator ==(const l_rmatrix &m1,const l_rmatrix_slice &ms) throw() { return _mmseq(m1,ms); }
01507         INLINE bool operator !=(const l_rmatrix &m1,const l_rmatrix_slice &ms) throw() { return _mmsneq(m1,ms); }
01508         INLINE bool operator <(const l_rmatrix &m1,const l_rmatrix_slice &ms) throw() { return _mmsless(m1,ms); }
01509         INLINE bool operator <=(const l_rmatrix &m1,const l_rmatrix_slice &ms) throw() { return _mmsleq(m1,ms); }
01510         INLINE bool operator >(const l_rmatrix &m1,const l_rmatrix_slice &ms) throw() { return _msmless(ms,m1); }
01511         INLINE bool operator >=(const l_rmatrix &m1,const l_rmatrix_slice &ms) throw() { return _msmleq(ms,m1); }
01512         INLINE bool operator ==(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2) throw() { return _msmseq(m1,m2); }
01513         INLINE bool operator !=(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2) throw() { return _msmsneq(m1,m2); }
01514         INLINE bool operator <(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2) throw() { return _msmsless(m1,m2); }
01515         INLINE bool operator <=(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2) throw() { return _msmsleq(m1,m2); }
01516         INLINE bool operator >(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2) throw() { return _msmsless(m2,m1); }
01517         INLINE bool operator >=(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2) throw() { return _msmsleq(m2,m1); }
01518         INLINE bool operator !(const l_rmatrix &ms) throw() { return _mnot(ms); }
01519         INLINE bool operator !(const l_rmatrix_slice &ms) throw() { return _msnot(ms); }
01520         INLINE std::ostream &operator <<(std::ostream &s,const l_rmatrix &r) throw() { return _mout(s,r); }
01521         INLINE std::ostream &operator <<(std::ostream &s,const l_rmatrix_slice &r) throw() { return _msout(s,r); }
01522         INLINE std::istream &operator >>(std::istream &s,l_rmatrix &r) throw() { return _min(s,r); }
01523         INLINE std::istream &operator >>(std::istream &s,l_rmatrix_slice &r) throw() { return _msin(s,r); }
01524 
01525 } // namespace cxsc
01526 
01527 #endif
01528
Generated on Thu Jun 9 11:20:51 2011 for C-XSC - A C++ Class Library for Extended Scientific Computing by  doxygen 1.4.6