C-XSC - A C++ Class Library for Extended Scientific Computing: l

00001 /*
00002 **  CXSC is a C++ library for eXtended Scientific Computing (V 2.5.1)
00003 **
00004 **  Copyright (C) 1990-2000 Institut fuer Angewandte Mathematik,
00005 **                          Universitaet Karlsruhe, Germany
00006 **            (C) 2000-2011 Wiss. Rechnen/Softwaretechnologie
00007 **                          Universitaet Wuppertal, Germany   
00008 **
00009 **  This library is free software; you can redistribute it and/or
00010 **  modify it under the terms of the GNU Library General Public
00011 **  License as published by the Free Software Foundation; either
00012 **  version 2 of the License, or (at your option) any later version.
00013 **
00014 **  This library is distributed in the hope that it will be useful,
00015 **  but WITHOUT ANY WARRANTY; without even the implied warranty of
00016 **  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00017 **  Library General Public License for more details.
00018 **
00019 **  You should have received a copy of the GNU Library General Public
00020 **  License along with this library; if not, write to the Free
00021 **  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00022 */
00023 
00024 /* CVS $Id: l_imatrix.inl,v 1.16 2011/06/07 15:17:40 cxsc Exp $ */
00025 
00026 #ifndef _CXSC_LIMATRIX_INL_INCLUDED
00027 #define _CXSC_LIMATRIX_INL_INCLUDED
00028 
00029 namespace cxsc {
00030 
00031 INLINE l_imatrix::l_imatrix() throw():dat(NULL),lb1(1),ub1(0),lb2(1),ub2(0),xsize(0),ysize(0)
00032 {
00033 }
00034 
00035 INLINE l_imatrix::l_imatrix(const l_interval &r) throw():lb1(1),ub1(1),lb2(1),ub2(1),xsize(1),ysize(1)
00036 {
00037         dat=new l_interval[1];
00038         *dat=r;
00039 }
00040 
00041 INLINE l_imatrix::l_imatrix(const real &r) throw():lb1(1),ub1(1),lb2(1),ub2(1),xsize(1),ysize(1)
00042 {
00043         dat=new l_interval[1];
00044         *dat=r;
00045 }
00046 
00047 INLINE l_imatrix::l_imatrix(const l_real &r) throw():lb1(1),ub1(1),lb2(1),ub2(1),xsize(1),ysize(1)
00048 {
00049         dat=new l_interval[1];
00050         *dat=r;
00051 }
00052 
00053 INLINE l_imatrix::l_imatrix(const interval &r) throw():lb1(1),ub1(1),lb2(1),ub2(1),xsize(1),ysize(1)
00054 {
00055         dat=new l_interval[1];
00056         *dat=r;
00057 }
00058 
00059 INLINE l_imatrix::l_imatrix(const rmatrix &rm) throw():lb1(rm.lb1),ub1(rm.ub1),lb2(rm.lb2),ub2(rm.ub2),xsize(rm.xsize),ysize(rm.ysize)
00060 {
00061         dat=new l_interval[xsize*ysize];
00062         for(int i=0;i<xsize*ysize;i++)
00063                 dat[i]=rm.dat[i];
00064 }
00065 
00066 INLINE l_imatrix::l_imatrix(const l_rmatrix &rm) throw():lb1(rm.lb1),ub1(rm.ub1),lb2(rm.lb2),ub2(rm.ub2),xsize(rm.xsize),ysize(rm.ysize)
00067 {
00068         dat=new l_interval[xsize*ysize];
00069         for(int i=0;i<xsize*ysize;i++)
00070                 dat[i]=rm.dat[i];
00071 }
00072 
00073 INLINE l_imatrix::l_imatrix(const imatrix &rm) throw():lb1(rm.lb1),ub1(rm.ub1),lb2(rm.lb2),ub2(rm.ub2),xsize(rm.xsize),ysize(rm.ysize)
00074 {
00075         dat=new l_interval[xsize*ysize];
00076         for(int i=0;i<xsize*ysize;i++)
00077                 dat[i]=rm.dat[i];
00078 }
00079 
00080 INLINE l_imatrix::l_imatrix(const l_imatrix &rm) throw():lb1(rm.lb1),ub1(rm.ub1),lb2(rm.lb2),ub2(rm.ub2),xsize(rm.xsize),ysize(rm.ysize)
00081 {
00082         dat=new l_interval[xsize*ysize];
00083         for(int i=0;i<xsize*ysize;i++)
00084                 dat[i]=rm.dat[i];
00085 }
00086 
00087 INLINE l_imatrix::l_imatrix(const int &m, const int &n)
00088 #if(CXSC_INDEX_CHECK)
00089         throw(ERROR_LIMATRIX_WRONG_BOUNDARIES):lb1(1),ub1(m),lb2(1),ub2(n),xsize(n),ysize(m)
00090 #else
00091         throw():lb1(1),ub1(m),lb2(1),ub2(n),xsize(n),ysize(m)
00092 #endif
00093 {
00094 #if(CXSC_INDEX_CHECK)
00095         if((n<0)||(m<0)) cxscthrow(ERROR_LIMATRIX_WRONG_BOUNDARIES("l_imatrix::l_imatrix(const int &m, const int &n)"));
00096 #endif
00097         dat=new l_interval[m*n];
00098 }
00099 
00100 INLINE l_imatrix::l_imatrix(const int &m1, const int &m2, const int &n1, const int &n2)
00101 #if(CXSC_INDEX_CHECK)
00102         throw(ERROR_LIMATRIX_WRONG_BOUNDARIES):lb1(m1),ub1(m2),lb2(n1),ub2(n2),xsize(n2-n1+1),ysize(m2-m1+1)
00103 #else
00104         throw():lb1(m1),ub1(m2),lb2(n1),ub2(n2),xsize(n2-n1+1),ysize(m2-m1+1)
00105 #endif
00106 {
00107 #if(CXSC_INDEX_CHECK)
00108         if((m2<m1)||(n2<n1)) cxscthrow(ERROR_LIMATRIX_WRONG_BOUNDARIES("l_imatrix::l_imatrix(const int &m1, const int &n1, const int &m2, const int &n2)"));
00109 #endif
00110         dat=new l_interval[xsize*ysize];
00111 }
00112 
00113 INLINE l_ivector::l_ivector(const l_imatrix_subv &v) throw():l(v.lb),u(v.ub),size(v.size)
00114 {
00115         dat=new l_interval[size];
00116         for (int i=0, j=v.start;i<v.size;i++,j+=v.offset)
00117                 dat[i]=v.dat[j];
00118 }
00119 
00120 INLINE l_ivector_slice & l_ivector_slice::operator =(const l_imatrix &m)
00121 #if(CXSC_INDEX_CHECK)
00122 throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>,ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
00123 #else
00124 throw()
00125 #endif
00126 { return _vsvassign(*this,l_ivector(m)); }
00127 
00128 
00129 INLINE l_imatrix::l_imatrix(const l_ivector &v) throw():lb1(v.l),ub1(v.u),lb2(1),ub2(1),xsize(1),ysize(v.size)
00130 {
00131         dat=new l_interval[v.size];
00132         for(int i=0;i<v.size;i++)
00133                 dat[i]=v.dat[i];
00134 }
00135 
00136 INLINE l_imatrix::l_imatrix(const rvector &v) throw():lb1(v.l),ub1(v.u),lb2(1),ub2(1),xsize(1),ysize(v.size)
00137 {
00138         dat=new l_interval[v.size];
00139         for(int i=0;i<v.size;i++)
00140                 dat[i]=v.dat[i];
00141 }
00142 
00143 INLINE l_imatrix::l_imatrix(const l_rvector &v) throw():lb1(v.l),ub1(v.u),lb2(1),ub2(1),xsize(1),ysize(v.size)
00144 {
00145         dat=new l_interval[v.size];
00146         for(int i=0;i<v.size;i++)
00147                 dat[i]=v.dat[i];
00148 }
00149 
00150 INLINE l_imatrix::l_imatrix(const ivector &v) throw():lb1(v.l),ub1(v.u),lb2(1),ub2(1),xsize(1),ysize(v.size)
00151 {
00152         dat=new l_interval[v.size];
00153         for(int i=0;i<v.size;i++)
00154                 dat[i]=v.dat[i];
00155 }
00156 
00157 INLINE l_imatrix::l_imatrix(const l_ivector_slice &v) throw():lb1(v.start),ub1(v.end),lb2(1),ub2(1),xsize(1),ysize(v.size)
00158 {
00159         dat=new l_interval[v.size];
00160         for(int i=0,j=v.start-v.l;i<v.size;i++,j++)
00161                 dat[i]=v.dat[j];
00162 }
00163 
00164 INLINE l_imatrix::l_imatrix(const rvector_slice &v) throw():lb1(v.start),ub1(v.end),lb2(1),ub2(1),xsize(1),ysize(v.size)
00165 {
00166         dat=new l_interval[v.size];
00167         for(int i=0,j=v.start-v.l;i<v.size;i++,j++)
00168                 dat[i]=v.dat[j];
00169 }
00170 
00171 INLINE l_imatrix::l_imatrix(const ivector_slice &v) throw():lb1(v.start),ub1(v.end),lb2(1),ub2(1),xsize(1),ysize(v.size)
00172 {
00173         dat=new l_interval[v.size];
00174         for(int i=0,j=v.start-v.l;i<v.size;i++,j++)
00175                 dat[i]=v.dat[j];
00176 }
00177 
00178 INLINE l_imatrix::l_imatrix(const l_rvector_slice &v) throw():lb1(v.start),ub1(v.end),lb2(1),ub2(1),xsize(1),ysize(v.size)
00179 {
00180         dat=new l_interval[v.size];
00181         for(int i=0,j=v.start-v.l;i<v.size;i++,j++)
00182                 dat[i]=v.dat[j];
00183 }
00184 
00185         INLINE l_interval &l_imatrix_subv::operator [](const int &i) const
00186 #if(CXSC_INDEX_CHECK)
00187                 throw(ERROR_LIVECTOR_ELEMENT_NOT_IN_VEC)
00188 #else
00189         throw()
00190 #endif
00191         {
00192 #if(CXSC_INDEX_CHECK)
00193                 if((i<lb)||(i>ub)) cxscthrow(ERROR_LIVECTOR_ELEMENT_NOT_IN_VEC("l_interval &l_imatrix_subv::operator [](const int &i)"));
00194 #endif
00195                 return dat[start+((i-lb)*offset)];
00196         }
00197 
00198         INLINE l_imatrix::l_imatrix(const l_imatrix_slice &sl) throw():lb1(sl.start1),ub1(sl.end1),lb2(sl.start2),ub2(sl.end2),xsize(sl.sxsize),ysize(sl.sysize)
00199         {
00200                 int i,j;
00201                 
00202                 dat=new l_interval[xsize*ysize];
00203                 for (i=0;i<ysize;i++)
00204                 {
00205                         for(j=0;j<xsize;j++)
00206                         {
00207                                 dat[i*xsize+j]=sl.dat[(sl.offset1+i)*sl.mxsize+sl.offset2+j];
00208                         }
00209                 }
00210         }
00211 
00212         INLINE l_imatrix::l_imatrix(const rmatrix_slice &sl) throw():lb1(sl.start1),ub1(sl.end1),lb2(sl.start2),ub2(sl.end2),xsize(sl.sxsize),ysize(sl.sysize)
00213         {
00214                 int i,j;
00215                 
00216                 dat=new l_interval[xsize*ysize];
00217                 for (i=0;i<ysize;i++)
00218                 {
00219                         for(j=0;j<xsize;j++)
00220                         {
00221                                 dat[i*xsize+j]=sl.dat[(sl.offset1+i)*sl.mxsize+sl.offset2+j];
00222                         }
00223                 }
00224         }
00225         INLINE l_imatrix::l_imatrix(const l_rmatrix_slice &sl) throw():lb1(sl.start1),ub1(sl.end1),lb2(sl.start2),ub2(sl.end2),xsize(sl.sxsize),ysize(sl.sysize)
00226         {
00227                 int i,j;
00228                 
00229                 dat=new l_interval[xsize*ysize];
00230                 for (i=0;i<ysize;i++)
00231                 {
00232                         for(j=0;j<xsize;j++)
00233                         {
00234                                 dat[i*xsize+j]=sl.dat[(sl.offset1+i)*sl.mxsize+sl.offset2+j];
00235                         }
00236                 }
00237         }
00238         INLINE l_imatrix::l_imatrix(const imatrix_slice &sl) throw():lb1(sl.start1),ub1(sl.end1),lb2(sl.start2),ub2(sl.end2),xsize(sl.sxsize),ysize(sl.sysize)
00239         {
00240                 int i,j;
00241                 
00242                 dat=new l_interval[xsize*ysize];
00243                 for (i=0;i<ysize;i++)
00244                 {
00245                         for(j=0;j<xsize;j++)
00246                         {
00247                                 dat[i*xsize+j]=sl.dat[(sl.offset1+i)*sl.mxsize+sl.offset2+j];
00248                         }
00249                 }
00250         }
00251 
00252         INLINE l_imatrix_subv Row(l_imatrix &m,const int &i)
00253 #if(CXSC_INDEX_CHECK)
00254         throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT)
00255 #else
00256         throw()
00257 #endif
00258         
00259         {
00260                 return m[i];
00261         }
00262 
00263         INLINE l_imatrix_subv Col(l_imatrix &m,const int &i)
00264 #if(CXSC_INDEX_CHECK)
00265         throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT)
00266 #else
00267         throw()
00268 #endif
00269         
00270         {
00271                 return m[Col(i)];
00272         }
00273                 
00274         INLINE l_imatrix_subv Row(const l_imatrix &m,const int &i)
00275 #if(CXSC_INDEX_CHECK)
00276         throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT)
00277 #else
00278         throw()
00279 #endif
00280         
00281         {
00282                 return m[i];
00283         }
00284 
00285         INLINE l_imatrix_subv Col(const l_imatrix &m,const int &i)
00286 #if(CXSC_INDEX_CHECK)
00287         throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT)
00288 #else
00289         throw()
00290 #endif
00291         
00292         {
00293                 return m[Col(i)];
00294         }
00295                 
00296         INLINE l_imatrix_subv l_imatrix::operator [](const int &i) const
00297 #if(CXSC_INDEX_CHECK)
00298                 throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT)
00299 #else
00300         throw()
00301 #endif
00302         {
00303 #if(CXSC_INDEX_CHECK)
00304                 if((i<lb1)||(i>ub1)) cxscthrow(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT("l_imatrix_subv l_imatrix::operator [](const int &i)"));
00305 #endif
00306                 return l_imatrix_subv(dat, lb2, ub2, xsize, xsize*(i-lb1),1);
00307         }
00308         
00309         INLINE l_imatrix_subv l_imatrix::operator [](const cxscmatrix_column &i) const
00310 #if(CXSC_INDEX_CHECK)
00311                 throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT)
00312 #else
00313         throw()
00314 #endif
00315         {
00316 #if(CXSC_INDEX_CHECK)
00317                 if((i.col()<lb2)||(i.col()>ub2)) cxscthrow(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT("l_imatrix_subv l_imatrix::operator [](const cxscmatrix_column &i)"));
00318 #endif
00319                 return l_imatrix_subv(dat, lb1, ub1, ysize, i.col()-lb2, xsize);
00320         }
00321         
00322         INLINE l_imatrix_slice l_imatrix::operator ()(const int &m, const int &n)
00323 #if(CXSC_INDEX_CHECK)
00324                 throw(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG)
00325 #else
00326         throw()
00327 #endif
00328         {
00329 #if(CXSC_INDEX_CHECK)
00330         if((m<1)||(n<1)||(m<lb1)||(n<lb2)||(m>ub1)||(n>ub2)) cxscthrow(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG("l_imatrix_slice l_imatrix::operator ()(const int &m, const int &n)"));
00331 #endif
00332                 return l_imatrix_slice(*this,1,m,1,n);
00333         }
00334         
00335         INLINE l_imatrix_slice l_imatrix::operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
00336 #if(CXSC_INDEX_CHECK)
00337                 throw(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG)
00338 #else
00339         throw()
00340 #endif
00341         {
00342 #if(CXSC_INDEX_CHECK)
00343         if((m1<lb1)||(n1<lb2)||(m2>ub1)||(n2>ub2)) cxscthrow(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG("l_imatrix_slice l_imatrix::operator ()(const int &m1, const int &n1, const int &m2, const int &n2)"));
00344 #endif
00345                 return l_imatrix_slice(*this,m1,m2,n1,n2);
00346         }
00347 
00348         INLINE l_imatrix_subv l_imatrix_slice::operator [](const int &i)
00349 #if(CXSC_INDEX_CHECK)
00350                 throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT)
00351 #else
00352         throw()
00353 #endif
00354         {
00355 #if(CXSC_INDEX_CHECK)
00356                 if((i<start1)||(i>end1)) cxscthrow(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT("l_imatrix_subv l_imatrix_slice::operator [](const int &i)"));
00357 #endif
00358                 return l_imatrix_subv(dat, start2, end2, sxsize, mxsize*(i-start1+offset1)+offset2,1);
00359         }
00360         
00361         INLINE l_imatrix_subv l_imatrix_slice::operator [](const cxscmatrix_column &i)
00362 #if(CXSC_INDEX_CHECK)
00363                 throw(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT)
00364 #else
00365         throw()
00366 #endif
00367         {
00368 #if(CXSC_INDEX_CHECK)
00369                 if((i.col()<start2)||(i.col()>end2)) cxscthrow(ERROR_LIMATRIX_ROW_OR_COL_NOT_IN_MAT("l_imatrix_subv l_imatrix_slice::operator [](const cxscmatrix_column &i)"));
00370 #endif
00371                 return l_imatrix_subv(dat, start1, end1, sysize, offset1*mxsize+i.col()-start2+offset2, mxsize);
00372         }
00373         
00374         INLINE l_imatrix_slice l_imatrix_slice::operator ()(const int &m, const int &n)
00375 #if(CXSC_INDEX_CHECK)
00376                 throw(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG)
00377 #else
00378         throw()
00379 #endif
00380         {
00381 #if(CXSC_INDEX_CHECK)
00382                 if((m<1)||(n<1)||(m<start1)||(n<start2)||(m>end1)||(n>end2)) cxscthrow(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG("l_imatrix_slice l_imatrix_slice::operator ()(const int &m, const int &n)"));
00383 #endif
00384                 return l_imatrix_slice(*this,1,m,1,n);
00385         }
00386         
00387         INLINE l_imatrix_slice l_imatrix_slice::operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
00388 #if(CXSC_INDEX_CHECK)
00389                 throw(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG)
00390 #else
00391         throw()
00392 #endif
00393         {
00394 #if(CXSC_INDEX_CHECK)
00395                 if((m1<start1)||(n1<start2)||(m2>end1)||(n2>end2)) cxscthrow(ERROR_LIMATRIX_SUB_ARRAY_TOO_BIG("l_imatrix_slice l_imatrix_slice::operator ()(const int &m1, const int &m2, const int &n1, const int &n2)"));
00396 #endif
00397                 return l_imatrix_slice(*this,m1,m2,n1,n2);
00398         }
00399 
00400 INLINE l_imatrix_subv l_imatrix_subv::operator ()(const int &i)
00401 #if(CXSC_INDEX_CHECK)
00402         throw(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG)
00403 #else
00404         throw()
00405 #endif
00406 {
00407 #if(CXSC_INDEX_CHECK)
00408         if(1<lb||i>ub) cxscthrow(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG("l_imatrix_subv l_imatrix_subv::operator ()(const int &i)"));
00409 #endif
00410         return l_imatrix_subv(dat,1,i,i,start+(1-lb)*offset,offset);
00411 }
00412 
00413 INLINE l_imatrix_subv l_imatrix_subv::operator ()(const int &i1,const int &i2)
00414 #if(CXSC_INDEX_CHECK)
00415         throw(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG)
00416 #else
00417         throw()
00418 #endif
00419 {
00420 #if(CXSC_INDEX_CHECK)
00421         if(i1<lb||i2>ub) cxscthrow(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG("l_imatrix_subv l_imatrix_subv::operator ()(const int &i1,const int &i2)"));
00422 #endif
00423         return l_imatrix_subv(dat,i1,i2,i2-i1+1,start+(i1-lb)*offset,offset);
00424 }
00425 
00426 
00427 
00428         INLINE l_imatrix_subv &l_imatrix_subv::operator =(const l_imatrix_subv &rv) throw() { return _mvmvassign(*this,rv); }
00429         INLINE l_imatrix_subv &l_imatrix_subv::operator =(const l_interval &r) throw() { return _mvsassign(*this,r); }
00430         INLINE l_imatrix_subv &l_imatrix_subv::operator =(const l_ivector &v)
00431 #if(CXSC_INDEX_CHECK)
00432         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00433 #else
00434         throw()
00435 #endif
00436         { return _mvvassign(*this,v); }
00437         INLINE l_imatrix_subv &l_imatrix_subv::operator =(const l_ivector_slice &v)
00438 #if(CXSC_INDEX_CHECK)
00439         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00440 #else
00441         throw()
00442 #endif
00443         { return _mvvassign(*this,l_ivector(v)); }
00444 
00445         INLINE l_imatrix_subv &l_imatrix_subv::operator =(const rmatrix_subv &rv) throw() { return _mvvassign(*this,rvector(rv)); }
00446         INLINE l_imatrix_subv &l_imatrix_subv::operator =(const real &r) throw() { return _mvsassign(*this,r); }
00447         INLINE l_imatrix_subv &l_imatrix_subv::operator =(const rvector &v)
00448 #if(CXSC_INDEX_CHECK)
00449         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00450 #else
00451         throw()
00452 #endif
00453         { return _mvvassign(*this,v); }
00454         INLINE l_imatrix_subv &l_imatrix_subv::operator =(const rvector_slice &v)
00455 #if(CXSC_INDEX_CHECK)
00456         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00457 #else
00458         throw()
00459 #endif
00460         { return _mvvassign(*this,l_ivector(v)); }
00461 
00462         INLINE l_imatrix_subv &l_imatrix_subv::operator =(const l_rmatrix_subv &rv) throw() { return _mvvassign(*this,l_rvector(rv)); }
00463         INLINE l_imatrix_subv &l_imatrix_subv::operator =(const l_real &r) throw() { return _mvsassign(*this,r); }
00464         INLINE l_imatrix_subv &l_imatrix_subv::operator =(const l_rvector &v)
00465 #if(CXSC_INDEX_CHECK)
00466         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00467 #else
00468         throw()
00469 #endif
00470         { return _mvvassign(*this,v); }
00471         INLINE l_imatrix_subv &l_imatrix_subv::operator =(const l_rvector_slice &v)
00472 #if(CXSC_INDEX_CHECK)
00473         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00474 #else
00475         throw()
00476 #endif
00477         { return _mvvassign(*this,l_ivector(v)); }
00478 
00479         INLINE l_imatrix_subv &l_imatrix_subv::operator =(const imatrix_subv &rv) throw() { return _mvvassign(*this,ivector(rv)); }
00480         INLINE l_imatrix_subv &l_imatrix_subv::operator =(const interval &r) throw() { return _mvsassign(*this,r); }
00481         INLINE l_imatrix_subv &l_imatrix_subv::operator =(const ivector &v)
00482 #if(CXSC_INDEX_CHECK)
00483         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00484 #else
00485         throw()
00486 #endif
00487         { return _mvvassign(*this,v); }
00488         INLINE l_imatrix_subv &l_imatrix_subv::operator =(const ivector_slice &v)
00489 #if(CXSC_INDEX_CHECK)
00490         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00491 #else
00492         throw()
00493 #endif
00494         { return _mvvassign(*this,l_ivector(v)); }
00495 
00496         INLINE l_imatrix &l_imatrix::operator =(const l_interval &r) throw() { return _msassign(*this,r); }
00497         INLINE l_imatrix &l_imatrix::operator =(const l_imatrix &m) throw() { return _mmassign<l_imatrix,l_imatrix,l_interval>(*this,m, l_interval()); }
00498         INLINE l_imatrix &l_imatrix::operator =(const l_imatrix_slice &ms) throw() { return _mmsassign<l_imatrix,l_imatrix_slice,l_interval>(*this,ms); }
00499         INLINE l_imatrix &l_imatrix::operator =(const l_ivector &v) throw() { return _mvassign<l_imatrix,l_ivector,l_interval>(*this,v); }
00500         INLINE l_imatrix &l_imatrix::operator =(const l_ivector_slice &v) throw() { return _mvassign<l_imatrix,l_ivector,l_interval>(*this,l_ivector(v)); }
00501         
00502         INLINE l_imatrix &l_imatrix::operator =(const real &r) throw() { return _msassign(*this,l_interval(r)); }
00503         INLINE l_imatrix &l_imatrix::operator =(const rmatrix &m) throw() { return _mmassign<l_imatrix,rmatrix,l_interval>(*this,m, l_interval()); }
00504         INLINE l_imatrix &l_imatrix::operator =(const rmatrix_slice &ms) throw() { return _mmsassign<l_imatrix,rmatrix_slice,l_interval>(*this,ms); }
00505         INLINE l_imatrix &l_imatrix::operator =(const rvector &v) throw() { return _mvassign<l_imatrix,rvector,l_interval>(*this,v); }
00506         INLINE l_imatrix &l_imatrix::operator =(const rvector_slice &v) throw() { return _mvassign<l_imatrix,rvector,l_interval>(*this,rvector(v)); }
00507         
00508         INLINE l_imatrix &l_imatrix::operator =(const l_real &r) throw() { return _msassign(*this,l_interval(r)); }
00509         INLINE l_imatrix &l_imatrix::operator =(const l_rmatrix &m) throw() { return _mmassign<l_imatrix,l_rmatrix,l_interval>(*this,m, l_interval()); }
00510         INLINE l_imatrix &l_imatrix::operator =(const l_rmatrix_slice &ms) throw() { return _mmsassign<l_imatrix,l_rmatrix_slice,l_interval>(*this,ms); }
00511         INLINE l_imatrix &l_imatrix::operator =(const l_rvector &v) throw() { return _mvassign<l_imatrix,l_rvector,l_interval>(*this,v); }
00512         INLINE l_imatrix &l_imatrix::operator =(const l_rvector_slice &v) throw() { return _mvassign<l_imatrix,l_rvector,l_interval>(*this,l_rvector(v)); }
00513         
00514         INLINE l_imatrix &l_imatrix::operator =(const interval &r) throw() { return _msassign(*this,l_interval(r)); }
00515         INLINE l_imatrix &l_imatrix::operator =(const imatrix &m) throw() { return _mmassign<l_imatrix,imatrix,l_interval>(*this,m, l_interval()); }
00516         INLINE l_imatrix &l_imatrix::operator =(const imatrix_slice &ms) throw() { return _mmsassign<l_imatrix,imatrix_slice,l_interval>(*this,ms); }
00517         INLINE l_imatrix &l_imatrix::operator =(const ivector &v) throw() { return _mvassign<l_imatrix,ivector,l_interval>(*this,v); }
00518         INLINE l_imatrix &l_imatrix::operator =(const ivector_slice &v) throw() { return _mvassign<l_imatrix,ivector,l_interval>(*this,ivector(v)); }
00519         
00520         INLINE l_imatrix::operator void*() throw() { return _mvoid(*this); }
00521 
00522         INLINE l_imatrix_slice &l_imatrix_slice::operator =(const l_imatrix &m)
00523 #if(CXSC_INDEX_CHECK)
00524         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
00525 #else
00526         throw()
00527 #endif
00528         { return _msmassign(*this,m); }
00529         INLINE l_imatrix_slice &l_imatrix_slice::operator =(const l_imatrix_slice &ms)
00530 #if(CXSC_INDEX_CHECK)
00531         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
00532 #else
00533         throw()
00534 #endif
00535         { return _msmsassign(*this,ms); }
00536         INLINE l_imatrix_slice &l_imatrix_slice::operator =(const l_interval &r) throw() { return _mssassign(*this,r); }
00537         INLINE l_imatrix_slice &l_imatrix_slice::operator =(const l_ivector &v)
00538 #if(CXSC_INDEX_CHECK)
00539         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
00540 #else
00541         throw()
00542 #endif
00543         { return _msmassign(*this,l_imatrix(v)); }
00544         INLINE l_imatrix_slice &l_imatrix_slice::operator =(const l_ivector_slice &v)
00545 #if(CXSC_INDEX_CHECK)
00546         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
00547 #else
00548         throw()
00549 #endif
00550         { return _msmassign(*this,l_imatrix(l_ivector(v))); }
00551         INLINE l_imatrix_slice &l_imatrix_slice::operator =(const l_imatrix_subv &v)
00552 #if(CXSC_INDEX_CHECK)
00553         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
00554 #else
00555         throw()
00556 #endif
00557         { return _msmassign(*this,l_imatrix(l_ivector(v))); }
00558 
00559         INLINE l_imatrix_slice &l_imatrix_slice::operator =(const rmatrix &m)
00560 #if(CXSC_INDEX_CHECK)
00561         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
00562 #else
00563         throw()
00564 #endif
00565         { return _msmassign(*this,m); }
00566         INLINE l_imatrix_slice &l_imatrix_slice::operator =(const rmatrix_slice &ms)
00567 #if(CXSC_INDEX_CHECK)
00568         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
00569 #else
00570         throw()
00571 #endif
00572         { return _msmsassign(*this,ms); }
00573         INLINE l_imatrix_slice &l_imatrix_slice::operator =(const real &r) throw() { return _mssassign(*this,r); }
00574         INLINE l_imatrix_slice &l_imatrix_slice::operator =(const rvector &v)
00575 #if(CXSC_INDEX_CHECK)
00576         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
00577 #else
00578         throw()
00579 #endif
00580         { return _msmassign(*this,l_imatrix(v)); }
00581         INLINE l_imatrix_slice &l_imatrix_slice::operator =(const rvector_slice &v)
00582 #if(CXSC_INDEX_CHECK)
00583         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
00584 #else
00585         throw()
00586 #endif
00587         { return _msmassign(*this,l_imatrix(l_ivector(v))); }
00588         INLINE l_imatrix_slice &l_imatrix_slice::operator =(const rmatrix_subv &v)
00589 #if(CXSC_INDEX_CHECK)
00590         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
00591 #else
00592         throw()
00593 #endif
00594         { return _msmassign(*this,l_imatrix(l_ivector(v))); }
00595 
00596         INLINE l_imatrix_slice &l_imatrix_slice::operator =(const l_rmatrix &m)
00597 #if(CXSC_INDEX_CHECK)
00598         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
00599 #else
00600         throw()
00601 #endif
00602         { return _msmassign(*this,m); }
00603         INLINE l_imatrix_slice &l_imatrix_slice::operator =(const l_rmatrix_slice &ms)
00604 #if(CXSC_INDEX_CHECK)
00605         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
00606 #else
00607         throw()
00608 #endif
00609         { return _msmsassign(*this,ms); }
00610         INLINE l_imatrix_slice &l_imatrix_slice::operator =(const l_real &r) throw() { return _mssassign(*this,r); }
00611         INLINE l_imatrix_slice &l_imatrix_slice::operator =(const l_rvector &v)
00612 #if(CXSC_INDEX_CHECK)
00613         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
00614 #else
00615         throw()
00616 #endif
00617         { return _msmassign(*this,l_imatrix(v)); }
00618         INLINE l_imatrix_slice &l_imatrix_slice::operator =(const l_rvector_slice &v)
00619 #if(CXSC_INDEX_CHECK)
00620         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
00621 #else
00622         throw()
00623 #endif
00624         { return _msmassign(*this,l_imatrix(l_ivector(v))); }
00625         INLINE l_imatrix_slice &l_imatrix_slice::operator =(const l_rmatrix_subv &v)
00626 #if(CXSC_INDEX_CHECK)
00627         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
00628 #else
00629         throw()
00630 #endif
00631         { return _msmassign(*this,l_imatrix(l_ivector(v))); }
00632 
00633         INLINE l_imatrix_slice &l_imatrix_slice::operator =(const imatrix &m)
00634 #if(CXSC_INDEX_CHECK)
00635         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
00636 #else
00637         throw()
00638 #endif
00639         { return _msmassign(*this,m); }
00640         INLINE l_imatrix_slice &l_imatrix_slice::operator =(const imatrix_slice &ms)
00641 #if(CXSC_INDEX_CHECK)
00642         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
00643 #else
00644         throw()
00645 #endif
00646         { return _msmsassign(*this,ms); }
00647         INLINE l_imatrix_slice &l_imatrix_slice::operator =(const interval &r) throw() { return _mssassign(*this,r); }
00648         INLINE l_imatrix_slice &l_imatrix_slice::operator =(const ivector &v)
00649 #if(CXSC_INDEX_CHECK)
00650         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
00651 #else
00652         throw()
00653 #endif
00654         { return _msmassign(*this,l_imatrix(v)); }
00655         INLINE l_imatrix_slice &l_imatrix_slice::operator =(const ivector_slice &v)
00656 #if(CXSC_INDEX_CHECK)
00657         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
00658 #else
00659         throw()
00660 #endif
00661         { return _msmassign(*this,l_imatrix(l_ivector(v))); }
00662         INLINE l_imatrix_slice &l_imatrix_slice::operator =(const imatrix_subv &v)
00663 #if(CXSC_INDEX_CHECK)
00664         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
00665 #else
00666         throw()
00667 #endif
00668         { return _msmassign(*this,l_imatrix(l_ivector(v))); }
00669 
00670         INLINE l_imatrix_slice::operator void*() throw() { return _msvoid(*this); }
00671         INLINE l_ivector operator /(const l_imatrix_subv &rv, const l_interval &s) throw() { return _mvsdiv<l_imatrix_subv,l_interval,l_ivector>(rv,s); }
00672         INLINE l_ivector operator *(const l_imatrix_subv &rv, const l_interval &s) throw() { return _mvsmult<l_imatrix_subv,l_interval,l_ivector>(rv,s); }
00673         INLINE l_ivector operator *(const l_interval &s, const l_imatrix_subv &rv) throw() { return _mvsmult<l_imatrix_subv,l_interval,l_ivector>(rv,s); }
00674         INLINE l_imatrix_subv &l_imatrix_subv::operator *=(const l_interval &c) throw() { return _mvsmultassign(*this,c); }
00675         INLINE l_imatrix_subv &l_imatrix_subv::operator +=(const l_interval &c) throw() { return _mvsplusassign(*this,c); }
00676         INLINE l_imatrix_subv &l_imatrix_subv::operator -=(const l_interval &c) throw() { return _mvsminusassign(*this,c); }
00677         INLINE l_imatrix_subv &l_imatrix_subv::operator /=(const l_interval &c) throw() { return _mvsdivassign(*this,c); }
00678         INLINE l_ivector abs(const l_imatrix_subv &mv) throw() { return _mvabs<l_imatrix_subv,l_ivector>(mv); }
00679         INLINE l_rvector diam(const l_imatrix_subv &mv) throw() { return _mvdiam<l_imatrix_subv,l_rvector>(mv); }
00680         INLINE l_rvector mid(const l_imatrix_subv &mv) throw() { return _mvmid<l_imatrix_subv,l_rvector>(mv); }
00681         INLINE l_rvector Inf(const l_imatrix_subv &mv) throw() { return _mvinf<l_imatrix_subv,l_rvector>(mv); }
00682         INLINE l_rvector Sup(const l_imatrix_subv &mv) throw() { return _mvsup<l_imatrix_subv,l_rvector>(mv); }
00683 
00684         INLINE l_imatrix_subv &SetInf(l_imatrix_subv &iv,const l_rvector &rv)
00685 #if(CXSC_INDEX_CHECK)
00686         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
00687 #else
00688         throw()
00689 #endif
00690         { return _mvvsetinf(iv,rv); }
00691         INLINE l_imatrix_subv &SetSup(l_imatrix_subv &iv,const l_rvector &rv)
00692 #if(CXSC_INDEX_CHECK)
00693         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
00694 #else
00695         throw()
00696 #endif
00697         { return _mvvsetsup(iv,rv); }
00698         INLINE l_imatrix_subv &UncheckedSetInf(l_imatrix_subv &iv,const l_rvector &rv)
00699 #if(CXSC_INDEX_CHECK)
00700         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
00701 #else
00702         throw()
00703 #endif
00704         { return _mvvusetinf(iv,rv); }
00705         INLINE l_imatrix_subv &UncheckedSetSup(l_imatrix_subv &iv,const l_rvector &rv)
00706 #if(CXSC_INDEX_CHECK)
00707         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
00708 #else
00709         throw()
00710 #endif
00711         { return _mvvusetsup(iv,rv); }
00712         INLINE l_imatrix_subv &SetSup(l_imatrix_subv &iv,const l_real &r) throw() { return _mvssetsup(iv,r); }
00713         INLINE l_imatrix_subv &SetInf(l_imatrix_subv &iv,const l_real &r) throw() { return _mvssetinf(iv,r); }
00714         INLINE l_imatrix_subv &UncheckedSetSup(l_imatrix_subv &iv,const l_real &r) throw() { return _mvsusetsup(iv,r); }
00715         INLINE l_imatrix_subv &SetUncheckedInf(l_imatrix_subv &iv,const l_real &r) throw() { return _mvsusetinf(iv,r); }
00716         INLINE l_ivector &l_ivector::operator =(const l_imatrix_subv &mv) throw() { return _vmvassign<l_ivector,l_imatrix_subv,l_interval>(*this,mv); }
00717         INLINE l_ivector_slice &l_ivector_slice::operator =(const l_imatrix_subv &mv) throw() { return _vsvassign(*this,l_ivector(mv)); }
00718         
00719         INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_imatrix_subv &rv2)
00720 #if(CXSC_INDEX_CHECK)
00721         throw(OP_WITH_WRONG_DIM)
00722 #else
00723         throw()
00724 #endif
00725         { _mvmvaccu(dp,rv1,rv2); }
00726         INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const l_imatrix_subv &rv2)
00727 #if(CXSC_INDEX_CHECK)
00728         throw(OP_WITH_WRONG_DIM)
00729 #else
00730         throw()
00731 #endif
00732         { _vmvaccu(dp,rv1,rv2); }
00733         INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_ivector &rv2)
00734 #if(CXSC_INDEX_CHECK)
00735         throw(OP_WITH_WRONG_DIM)
00736 #else
00737         throw()
00738 #endif
00739         { _vmvaccu(dp,rv2,rv1); }
00740         INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl1, const l_imatrix_subv &rv2)
00741 #if(CXSC_INDEX_CHECK)
00742         throw(OP_WITH_WRONG_DIM)
00743 #else
00744         throw()
00745 #endif
00746         { _vmvaccu(dp,l_ivector(sl1),rv2); }
00747         INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_ivector_slice &sl2)
00748 #if(CXSC_INDEX_CHECK)
00749         throw(OP_WITH_WRONG_DIM)
00750 #else
00751         throw()
00752 #endif
00753         { _vmvaccu(dp,l_ivector(sl2),rv1); }
00754         
00755         INLINE l_interval operator *(const l_imatrix_subv & rv1, const l_imatrix_subv &rv2)
00756 #if(CXSC_INDEX_CHECK)
00757         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00758 #else
00759         throw()
00760 #endif
00761         { return _mvmvlimult<l_imatrix_subv,l_imatrix_subv,l_interval>(rv1,rv2); }
00762         INLINE l_interval operator *(const l_ivector & rv1, const l_imatrix_subv &rv2)
00763 #if(CXSC_INDEX_CHECK)
00764         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00765 #else
00766         throw()
00767 #endif
00768         { return _vmvlimult<l_ivector,l_imatrix_subv,l_interval>(rv1,rv2); }
00769         INLINE l_interval operator *(const l_imatrix_subv &rv1,const l_ivector &rv2)
00770 #if(CXSC_INDEX_CHECK)
00771         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00772 #else
00773         throw()
00774 #endif
00775         { return _vmvlimult<l_ivector,l_imatrix_subv,l_interval>(rv2,rv1); }
00776         INLINE l_interval operator *(const l_ivector_slice &sl,const l_imatrix_subv &sv)
00777 #if(CXSC_INDEX_CHECK)
00778         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00779 #else
00780         throw()
00781 #endif
00782         { return _vmvlimult<l_ivector,l_imatrix_subv,l_interval>(l_ivector(sl),sv); }
00783         INLINE l_interval operator *(const l_imatrix_subv &mv,const l_ivector_slice &vs)
00784 #if(CXSC_INDEX_CHECK)
00785         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00786 #else
00787         throw()
00788 #endif
00789         { return _vmvlimult<l_ivector,l_imatrix_subv,l_interval>(l_ivector(vs),mv); }
00790         INLINE l_ivector operator +(const l_imatrix_subv & rv1, const l_imatrix_subv &rv2)
00791 #if(CXSC_INDEX_CHECK)
00792         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00793 #else
00794         throw()
00795 #endif
00796         { return _mvmvplus<l_imatrix_subv,l_imatrix_subv,l_ivector>(rv1,rv2); }
00797         INLINE l_ivector operator +(const l_imatrix_subv &rv1,const l_ivector &rv2)
00798 #if(CXSC_INDEX_CHECK)
00799         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00800 #else
00801         throw()
00802 #endif
00803         { return _mvvplus<l_imatrix_subv,l_ivector,l_ivector>(rv1,rv2); }
00804         INLINE l_ivector operator +(const l_ivector & rv1, const l_imatrix_subv &rv2)
00805 #if(CXSC_INDEX_CHECK)
00806         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00807 #else
00808         throw()
00809 #endif
00810         { return _mvvplus<l_imatrix_subv,l_ivector,l_ivector>(rv2,rv1); }
00811         INLINE l_ivector operator +(const l_ivector_slice &sl,const l_imatrix_subv &mv)
00812 #if(CXSC_INDEX_CHECK)
00813         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00814 #else
00815         throw()
00816 #endif
00817         { return _mvvplus<l_imatrix_subv,l_ivector,l_ivector>(mv,l_ivector(sl)); }
00818         INLINE l_ivector operator +(const l_imatrix_subv &mv,const l_ivector_slice &sl)
00819 #if(CXSC_INDEX_CHECK)
00820         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00821 #else
00822         throw()
00823 #endif
00824         { return _mvvplus<l_imatrix_subv,l_ivector,l_ivector>(mv,l_ivector(sl)); }
00825         INLINE l_imatrix_subv &l_imatrix_subv::operator +=(const l_ivector &rv)
00826 #if(CXSC_INDEX_CHECK)
00827         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00828 #else
00829         throw()
00830 #endif
00831         { return _mvvplusassign(*this,rv); }
00832         INLINE l_imatrix_subv &l_imatrix_subv::operator +=(const l_ivector_slice &rv)
00833 #if(CXSC_INDEX_CHECK)
00834         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00835 #else
00836         throw()
00837 #endif
00838         { return _mvvplusassign(*this,l_ivector(rv)); }
00839         INLINE l_ivector operator -(const l_imatrix_subv & rv1, const l_imatrix_subv &rv2)
00840 #if(CXSC_INDEX_CHECK)
00841         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00842 #else
00843         throw()
00844 #endif
00845         { return _mvmvminus<l_imatrix_subv,l_imatrix_subv,l_ivector>(rv1,rv2); }
00846         INLINE l_ivector operator -(const l_ivector & rv1, const l_imatrix_subv &rv2)
00847 #if(CXSC_INDEX_CHECK)
00848         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00849 #else
00850         throw()
00851 #endif
00852         { return _vmvminus<l_ivector,l_imatrix_subv,l_ivector>(rv1,rv2); }
00853         INLINE l_ivector operator -(const l_imatrix_subv &rv1,const l_ivector &rv2)
00854 #if(CXSC_INDEX_CHECK)
00855         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00856 #else
00857         throw()
00858 #endif
00859         { return _mvvminus<l_imatrix_subv,l_ivector,l_ivector>(rv1,rv2); }
00860         INLINE l_ivector operator -(const l_ivector_slice &sl,const l_imatrix_subv &mv)
00861 #if(CXSC_INDEX_CHECK)
00862         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00863 #else
00864         throw()
00865 #endif
00866         { return _vmvminus<l_ivector,l_imatrix_subv,l_ivector>(l_ivector(sl),mv); }
00867         INLINE l_ivector operator -(const l_imatrix_subv &mv,const l_ivector_slice &sl)
00868 #if(CXSC_INDEX_CHECK)
00869         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00870 #else
00871         throw()
00872 #endif
00873         { return _mvvminus<l_imatrix_subv,l_ivector,l_ivector>(mv,l_ivector(sl)); }
00874         INLINE l_imatrix_subv &l_imatrix_subv::operator -=(const l_ivector &rv)
00875 #if(CXSC_INDEX_CHECK)
00876         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00877 #else
00878         throw()
00879 #endif
00880         { return _mvvminusassign(*this,rv); }
00881         INLINE l_imatrix_subv &l_imatrix_subv::operator -=(const l_ivector_slice &rv)
00882 #if(CXSC_INDEX_CHECK)
00883         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00884 #else
00885         throw()
00886 #endif
00887         { return _mvvminusassign(*this,l_ivector(rv)); }
00888         INLINE l_ivector operator |(const l_imatrix_subv & rv1, const l_imatrix_subv &rv2)
00889 #if(CXSC_INDEX_CHECK)
00890         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00891 #else
00892         throw()
00893 #endif
00894         { return _mvmvconv<l_imatrix_subv,l_imatrix_subv,l_ivector>(rv1,rv2); }
00895         INLINE l_ivector operator |(const l_imatrix_subv &rv1,const l_ivector &rv2)
00896 #if(CXSC_INDEX_CHECK)
00897         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00898 #else
00899         throw()
00900 #endif
00901         { return _mvvconv<l_imatrix_subv,l_ivector,l_ivector>(rv1,rv2); }
00902         INLINE l_ivector operator |(const l_ivector & rv1, const l_imatrix_subv &rv2)
00903 #if(CXSC_INDEX_CHECK)
00904         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00905 #else
00906         throw()
00907 #endif
00908         { return _mvvconv<l_imatrix_subv,l_ivector,l_ivector>(rv2,rv1); }
00909         INLINE l_ivector operator |(const l_ivector_slice &sl,const l_imatrix_subv &mv)
00910 #if(CXSC_INDEX_CHECK)
00911         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00912 #else
00913         throw()
00914 #endif
00915         { return _mvvconv<l_imatrix_subv,l_ivector,l_ivector>(mv,l_ivector(sl)); }
00916         INLINE l_ivector operator |(const l_imatrix_subv &mv,const l_ivector_slice &sl)
00917 #if(CXSC_INDEX_CHECK)
00918         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00919 #else
00920         throw()
00921 #endif
00922         { return _mvvconv<l_imatrix_subv,l_ivector,l_ivector>(mv,l_ivector(sl)); }
00923         INLINE l_imatrix_subv &l_imatrix_subv::operator |=(const l_ivector &rv)
00924 #if(CXSC_INDEX_CHECK)
00925         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00926 #else
00927         throw()
00928 #endif
00929         { return _mvvconvassign(*this,rv); }
00930         INLINE l_imatrix_subv &l_imatrix_subv::operator |=(const l_ivector_slice &rv)
00931 #if(CXSC_INDEX_CHECK)
00932         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00933 #else
00934         throw()
00935 #endif
00936         { return _mvvconvassign(*this,l_ivector(rv)); }
00937         INLINE l_ivector operator &(const l_imatrix_subv & rv1, const l_imatrix_subv &rv2)
00938 #if(CXSC_INDEX_CHECK)
00939         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00940 #else
00941         throw()
00942 #endif
00943         { return _mvmvsect<l_imatrix_subv,l_imatrix_subv,l_ivector>(rv1,rv2); }
00944         INLINE l_ivector operator &(const l_imatrix_subv &rv1,const l_ivector &rv2)
00945 #if(CXSC_INDEX_CHECK)
00946         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00947 #else
00948         throw()
00949 #endif
00950         { return _mvvsect<l_imatrix_subv,l_ivector,l_ivector>(rv1,rv2); }
00951         INLINE l_ivector operator &(const l_ivector & rv1, const l_imatrix_subv &rv2)
00952 #if(CXSC_INDEX_CHECK)
00953         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00954 #else
00955         throw()
00956 #endif
00957         { return _mvvsect<l_imatrix_subv,l_ivector,l_ivector>(rv2,rv1); }
00958         INLINE l_ivector operator &(const l_ivector_slice &sl,const l_imatrix_subv &mv)
00959 #if(CXSC_INDEX_CHECK)
00960         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00961 #else
00962         throw()
00963 #endif
00964         { return _mvvsect<l_imatrix_subv,l_ivector,l_ivector>(mv,l_ivector(sl)); }
00965         INLINE l_ivector operator &(const l_imatrix_subv &mv,const l_ivector_slice &sl)
00966 #if(CXSC_INDEX_CHECK)
00967         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00968 #else
00969         throw()
00970 #endif
00971         { return _mvvsect<l_imatrix_subv,l_ivector,l_ivector>(mv,l_ivector(sl)); }
00972         INLINE l_imatrix_subv &l_imatrix_subv::operator &=(const l_ivector &rv)
00973 #if(CXSC_INDEX_CHECK)
00974         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00975 #else
00976         throw()
00977 #endif
00978         { return _mvvsectassign(*this,rv); }
00979         INLINE l_imatrix_subv &l_imatrix_subv::operator &=(const l_ivector_slice &rv)
00980 #if(CXSC_INDEX_CHECK)
00981         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
00982 #else
00983         throw()
00984 #endif
00985         { return _mvvsectassign(*this,l_ivector(rv)); }
00986 
00987 // real
00988         INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const rmatrix_subv &rv2)
00989 #if(CXSC_INDEX_CHECK)
00990         throw(OP_WITH_WRONG_DIM)
00991 #else
00992         throw()
00993 #endif
00994         { _mvmvaccu(dp,rv2,rv1); }
00995         INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const rvector_slice &sl2)
00996 #if(CXSC_INDEX_CHECK)
00997         throw(OP_WITH_WRONG_DIM)
00998 #else
00999         throw()
01000 #endif
01001         { _vmvaccu(dp,rvector(sl2),rv1); }
01002         INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const rvector &rv2)
01003 #if(CXSC_INDEX_CHECK)
01004         throw(OP_WITH_WRONG_DIM)
01005 #else
01006         throw()
01007 #endif
01008         { _vmvaccu(dp,rv2,rv1); }
01009         INLINE void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const l_imatrix_subv &rv2)
01010 #if(CXSC_INDEX_CHECK)
01011         throw(OP_WITH_WRONG_DIM)
01012 #else
01013         throw()
01014 #endif
01015         { _mvmvaccu(dp,rv1,rv2); }
01016         INLINE void accumulate(idotprecision &dp, const rvector_slice & sl1, const l_imatrix_subv &rv2)
01017 #if(CXSC_INDEX_CHECK)
01018         throw(OP_WITH_WRONG_DIM)
01019 #else
01020         throw()
01021 #endif
01022         { _vmvaccu(dp,rvector(sl1),rv2); }
01023         INLINE void accumulate(idotprecision &dp, const rvector & rv1, const l_imatrix_subv &rv2)
01024 #if(CXSC_INDEX_CHECK)
01025         throw(OP_WITH_WRONG_DIM)
01026 #else
01027         throw()
01028 #endif
01029         { _vmvaccu(dp,rv1,rv2); }
01030 // l_real
01031         INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_rmatrix_subv &rv2)
01032 #if(CXSC_INDEX_CHECK)
01033         throw(OP_WITH_WRONG_DIM)
01034 #else
01035         throw()
01036 #endif
01037         { _mvmvaccu(dp,rv2,rv1); }
01038         INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_rvector_slice &sl2)
01039 #if(CXSC_INDEX_CHECK)
01040         throw(OP_WITH_WRONG_DIM)
01041 #else
01042         throw()
01043 #endif
01044         { _vmvaccu(dp,l_rvector(sl2),rv1); }
01045         INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_rvector &rv2)
01046 #if(CXSC_INDEX_CHECK)
01047         throw(OP_WITH_WRONG_DIM)
01048 #else
01049         throw()
01050 #endif
01051         { _vmvaccu(dp,rv2,rv1); }
01052         INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const l_imatrix_subv &rv2)
01053 #if(CXSC_INDEX_CHECK)
01054         throw(OP_WITH_WRONG_DIM)
01055 #else
01056         throw()
01057 #endif
01058         { _mvmvaccu(dp,rv1,rv2); }
01059         INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl1, const l_imatrix_subv &rv2)
01060 #if(CXSC_INDEX_CHECK)
01061         throw(OP_WITH_WRONG_DIM)
01062 #else
01063         throw()
01064 #endif
01065         { _vmvaccu(dp,l_rvector(sl1),rv2); }
01066         INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const l_imatrix_subv &rv2)
01067 #if(CXSC_INDEX_CHECK)
01068         throw(OP_WITH_WRONG_DIM)
01069 #else
01070         throw()
01071 #endif
01072         { _vmvaccu(dp,rv1,rv2); }
01073 // interval
01074         INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const imatrix_subv &rv2)
01075 #if(CXSC_INDEX_CHECK)
01076         throw(OP_WITH_WRONG_DIM)
01077 #else
01078         throw()
01079 #endif
01080         { _mvmvaccu(dp,rv2,rv1); }
01081         INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const ivector_slice &sl2)
01082 #if(CXSC_INDEX_CHECK)
01083         throw(OP_WITH_WRONG_DIM)
01084 #else
01085         throw()
01086 #endif
01087         { _vmvaccu(dp,ivector(sl2),rv1); }
01088         INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const ivector &rv2)
01089 #if(CXSC_INDEX_CHECK)
01090         throw(OP_WITH_WRONG_DIM)
01091 #else
01092         throw()
01093 #endif
01094         { _vmvaccu(dp,rv2,rv1); }
01095         INLINE void accumulate(idotprecision &dp, const imatrix_subv & rv1, const l_imatrix_subv &rv2)
01096 #if(CXSC_INDEX_CHECK)
01097         throw(OP_WITH_WRONG_DIM)
01098 #else
01099         throw()
01100 #endif
01101         { _mvmvaccu(dp,rv1,rv2); }
01102         INLINE void accumulate(idotprecision &dp, const ivector_slice & sl1, const l_imatrix_subv &rv2)
01103 #if(CXSC_INDEX_CHECK)
01104         throw(OP_WITH_WRONG_DIM)
01105 #else
01106         throw()
01107 #endif
01108         { _vmvaccu(dp,ivector(sl1),rv2); }
01109         INLINE void accumulate(idotprecision &dp, const ivector & rv1, const l_imatrix_subv &rv2)
01110 #if(CXSC_INDEX_CHECK)
01111         throw(OP_WITH_WRONG_DIM)
01112 #else
01113         throw()
01114 #endif
01115         { _vmvaccu(dp,rv1,rv2); }
01116         
01117 
01118 
01119 //  matrix x matrix
01125         INLINE l_imatrix _imatrix(const l_imatrix &rm) throw() { return rm; }
01131         INLINE l_imatrix _imatrix(const l_ivector &v) throw() { return l_imatrix(v); }
01137         INLINE l_imatrix _imatrix(const l_ivector_slice &v) throw() { return l_imatrix(v); }
01143         INLINE l_imatrix _imatrix(const l_interval &r) throw() { return l_imatrix(r); }
01144         INLINE int Lb(const l_imatrix &rm, const int &i)
01145 #if(CXSC_INDEX_CHECK)
01146         throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL)
01147 #else
01148         throw()
01149 #endif
01150         { return _mlb(rm,i); }
01151         INLINE int Ub(const l_imatrix &rm, const int &i)
01152 #if(CXSC_INDEX_CHECK)
01153         throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL)
01154 #else
01155         throw()
01156 #endif
01157         { return _mub(rm,i); }
01158         INLINE int Lb(const l_imatrix_slice &rm, const int &i)
01159 #if(CXSC_INDEX_CHECK)
01160         throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL)
01161 #else
01162         throw()
01163 #endif
01164         { return _mslb(rm,i); }
01165         INLINE int Ub(const l_imatrix_slice &rm, const int &i)
01166 #if(CXSC_INDEX_CHECK)
01167         throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL)
01168 #else
01169         throw()
01170 #endif
01171         { return _msub(rm,i); }
01172         INLINE l_imatrix &SetLb(l_imatrix &m, const int &i,const int &j)
01173 #if(CXSC_INDEX_CHECK)
01174         throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL)
01175 #else
01176         throw()
01177 #endif
01178         { return _msetlb(m,i,j); }
01179         INLINE l_imatrix &SetUb(l_imatrix &m, const int &i,const int &j)
01180 #if(CXSC_INDEX_CHECK)
01181         throw(ERROR_LIMATRIX_WRONG_ROW_OR_COL)
01182 #else
01183         throw()
01184 #endif
01185         { return _msetub(m,i,j); }
01186         
01187         
01188         INLINE int RowLen ( const l_imatrix& A ) // Length of the rows of a l_interval matrix
01189         { return Ub(A,2)-Lb(A,2)+1; }            //------------------------------------------
01190 
01191         INLINE int ColLen ( const l_imatrix& A ) // Length of the columns of a l_interval matrix
01192         { return Ub(A,1)-Lb(A,1)+1; }            //---------------------------------------------
01193         
01194         INLINE int RowLen ( const l_imatrix_slice& A ) // Length of the rows of a l_interval matrix
01195         { return Ub(A,2)-Lb(A,2)+1; }                  //------------------------------------------
01196 
01197         INLINE int ColLen ( const l_imatrix_slice& A ) // Length of the columns of a l_interval matrix
01198         { return Ub(A,1)-Lb(A,1)+1; }                  //---------------------------------------------
01199         
01200         INLINE void Resize(l_imatrix &A) throw() { _mresize(A);}
01201         INLINE void Resize(l_imatrix &A,const int &m, const int &n)
01202 #if(CXSC_INDEX_CHECK)
01203         throw(ERROR_LIMATRIX_WRONG_BOUNDARIES)
01204 #else
01205         throw()
01206 #endif
01207         { _mresize<l_imatrix,l_interval>(A,m,n); }
01208         INLINE void Resize(l_imatrix &A,const int &m1, const int &m2,const int &n1,const int &n2)
01209 #if(CXSC_INDEX_CHECK)
01210         throw(ERROR_LIMATRIX_WRONG_BOUNDARIES)
01211 #else
01212         throw()
01213 #endif
01214         { _mresize<l_imatrix,l_interval>(A,m1,m2,n1,n2); }
01215         INLINE l_imatrix abs(const l_imatrix &m) throw() { return _mabs<l_imatrix,l_imatrix>(m); }
01216         INLINE l_imatrix abs(const l_imatrix_slice &ms) throw() { return _msabs<l_imatrix_slice,l_imatrix>(ms); }
01217         INLINE l_rmatrix diam(const l_imatrix &m) throw() { return _mdiam<l_imatrix,l_rmatrix>(m); }
01218         INLINE l_rmatrix diam(const l_imatrix_slice &m) throw() { return _msdiam<l_imatrix_slice,l_rmatrix>(m); }
01219         INLINE l_rmatrix mid(const l_imatrix &m) throw() { return _mmid<l_imatrix,l_rmatrix>(m); }
01220         INLINE l_rmatrix mid(const l_imatrix_slice &m) throw() { return _msmid<l_imatrix_slice,l_rmatrix>(m); }
01221         INLINE l_rmatrix Inf(const l_imatrix &m) throw() { return _minf<l_imatrix,l_rmatrix>(m); }
01222         INLINE l_rmatrix Sup(const l_imatrix &m) throw() { return _msup<l_imatrix,l_rmatrix>(m); }
01223         INLINE l_rmatrix Inf(const l_imatrix_slice &m) throw() { return _msinf<l_imatrix_slice,l_rmatrix>(m); }
01224         INLINE l_rmatrix Sup(const l_imatrix_slice &m) throw() { return _mssup<l_imatrix_slice,l_rmatrix>(m); }
01225         INLINE l_imatrix &SetInf(l_imatrix &cm,const l_rmatrix &rm)
01226 #if(CXSC_INDEX_CHECK)
01227         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01228 #else
01229         throw()
01230 #endif
01231         { return _mmsetinf<l_imatrix,l_rmatrix>(cm,rm); }
01232         INLINE l_imatrix_slice &SetInf(l_imatrix_slice &cm,const l_rmatrix &rm)
01233 #if(CXSC_INDEX_CHECK)
01234         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01235 #else
01236         throw()
01237 #endif
01238         { return _msmsetinf<l_imatrix_slice,l_rmatrix>(cm,rm); }
01239         INLINE l_imatrix &SetInf(l_imatrix &cm,const l_rmatrix_slice &rm)
01240 #if(CXSC_INDEX_CHECK)
01241         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01242 #else
01243         throw()
01244 #endif
01245         { return _mmssetinf<l_imatrix,l_rmatrix_slice>(cm,rm); }
01246         INLINE l_imatrix_slice &SetInf(l_imatrix_slice &cm,const l_rmatrix_slice &rm)
01247 #if(CXSC_INDEX_CHECK)
01248         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01249 #else
01250         throw()
01251 #endif
01252         { return _msmssetinf<l_imatrix_slice,l_rmatrix_slice>(cm,rm); }
01253         INLINE l_imatrix &SetSup(l_imatrix &cm,const l_rmatrix &rm)
01254 #if(CXSC_INDEX_CHECK)
01255         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01256 #else
01257         throw()
01258 #endif
01259         { return _mmsetsup<l_imatrix,l_rmatrix>(cm,rm); }
01260         INLINE l_imatrix_slice &SetSup(l_imatrix_slice &cm,const l_rmatrix &rm)
01261 #if(CXSC_INDEX_CHECK)
01262         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01263 #else
01264         throw()
01265 #endif
01266         { return _msmsetsup<l_imatrix_slice,l_rmatrix>(cm,rm); }
01267         INLINE l_imatrix &SetSup(l_imatrix &cm,const l_rmatrix_slice &rm)
01268 #if(CXSC_INDEX_CHECK)
01269         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01270 #else
01271         throw()
01272 #endif
01273         { return _mmssetsup<l_imatrix,l_rmatrix_slice>(cm,rm); }
01274         INLINE l_imatrix_slice &SetSup(l_imatrix_slice &cm,const l_rmatrix_slice &rm)
01275 #if(CXSC_INDEX_CHECK)
01276         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01277 #else
01278         throw()
01279 #endif
01280         { return _msmssetsup<l_imatrix_slice,l_rmatrix_slice>(cm,rm); }
01281         INLINE l_imatrix &UncheckedSetInf(l_imatrix &cm,const l_rmatrix &rm)
01282 #if(CXSC_INDEX_CHECK)
01283         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01284 #else
01285         throw()
01286 #endif
01287         { return _mmusetinf<l_imatrix,l_rmatrix>(cm,rm); }
01288         INLINE l_imatrix_slice &UncheckedSetInf(l_imatrix_slice &cm,const l_rmatrix &rm)
01289 #if(CXSC_INDEX_CHECK)
01290         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01291 #else
01292         throw()
01293 #endif
01294         { return _msmusetinf<l_imatrix_slice,l_rmatrix>(cm,rm); }
01295         INLINE l_imatrix &UncheckedSetInf(l_imatrix &cm,const l_rmatrix_slice &rm)
01296 #if(CXSC_INDEX_CHECK)
01297         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01298 #else
01299         throw()
01300 #endif
01301         { return _mmsusetinf<l_imatrix,l_rmatrix_slice>(cm,rm); }
01302         INLINE l_imatrix_slice &UncheckedSetInf(l_imatrix_slice &cm,const l_rmatrix_slice &rm)
01303 #if(CXSC_INDEX_CHECK)
01304         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01305 #else
01306         throw()
01307 #endif
01308         { return _msmsusetinf<l_imatrix_slice,l_rmatrix_slice>(cm,rm); }
01309         INLINE l_imatrix &UncheckedSetSup(l_imatrix &cm,const l_rmatrix &rm)
01310 #if(CXSC_INDEX_CHECK)
01311         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01312 #else
01313         throw()
01314 #endif
01315         { return _mmusetsup<l_imatrix,l_rmatrix>(cm,rm); }
01316         INLINE l_imatrix_slice &UncheckedSetSup(l_imatrix_slice &cm,const l_rmatrix &rm)
01317 #if(CXSC_INDEX_CHECK)
01318         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01319 #else
01320         throw()
01321 #endif
01322         { return _msmusetsup<l_imatrix_slice,l_rmatrix>(cm,rm); }
01323         INLINE l_imatrix &UncheckedSetSup(l_imatrix &cm,const l_rmatrix_slice &rm)
01324 #if(CXSC_INDEX_CHECK)
01325         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01326 #else
01327         throw()
01328 #endif
01329         { return _mmsusetsup<l_imatrix,l_rmatrix_slice>(cm,rm); }
01330         INLINE l_imatrix_slice &UncheckedSetSup(l_imatrix_slice &cm,const l_rmatrix_slice &rm)
01331 #if(CXSC_INDEX_CHECK)
01332         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01333 #else
01334         throw()
01335 #endif
01336         { return _msmsusetsup<l_imatrix_slice,l_rmatrix_slice>(cm,rm); }
01337         INLINE l_interval::l_interval(const l_imatrix &m)
01338 #if(CXSC_INDEX_CHECK)
01339         throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ,ERROR_LIMATRIX_USE_OF_UNINITIALIZED_OBJ)
01340 #else
01341         throw()
01342 #endif
01343         { _smconstr(*this,m); }
01344 //      INLINE l_interval l_interval::_interval(const l_imatrix &m) throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ,ERROR_LIMATRIX_USE_OF_UNINITIALIZED_OBJ) { _smconstr(*this,m); return *this; }
01345 
01346         INLINE l_imatrix_subv &l_imatrix_subv::operator *=(const real &c) throw() { return _mvsmultassign(*this,c); }
01347         INLINE l_imatrix_subv &l_imatrix_subv::operator +=(const real &c) throw() { return _mvsplusassign(*this,c); }
01348         INLINE l_imatrix_subv &l_imatrix_subv::operator -=(const real &c) throw() { return _mvsminusassign(*this,c); }
01349         INLINE l_imatrix_subv &l_imatrix_subv::operator /=(const real &c) throw() { return _mvsdivassign(*this,c); }
01350         INLINE l_imatrix_subv &l_imatrix_subv::operator +=(const rvector &rv)
01351 #if(CXSC_INDEX_CHECK)
01352         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
01353 #else
01354         throw()
01355 #endif
01356         { return _mvvplusassign(*this,rv); }
01357         INLINE l_imatrix_subv &l_imatrix_subv::operator +=(const rvector_slice &rv)
01358 #if(CXSC_INDEX_CHECK)
01359         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
01360 #else
01361         throw()
01362 #endif
01363         { return _mvvplusassign(*this,rvector(rv)); }
01364         INLINE l_imatrix_subv &l_imatrix_subv::operator -=(const rvector &rv)
01365 #if(CXSC_INDEX_CHECK)
01366         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
01367 #else
01368         throw()
01369 #endif
01370         { return _mvvminusassign(*this,rv); }
01371         INLINE l_imatrix_subv &l_imatrix_subv::operator -=(const rvector_slice &rv)
01372 #if(CXSC_INDEX_CHECK)
01373         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
01374 #else
01375         throw()
01376 #endif
01377         { return _mvvminusassign(*this,rvector(rv)); }
01378         INLINE l_imatrix_subv &l_imatrix_subv::operator |=(const rvector &rv)
01379 #if(CXSC_INDEX_CHECK)
01380         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
01381 #else
01382         throw()
01383 #endif
01384         { return _mvvconvassign(*this,rv); }
01385         INLINE l_imatrix_subv &l_imatrix_subv::operator |=(const rvector_slice &rv)
01386 #if(CXSC_INDEX_CHECK)
01387         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
01388 #else
01389         throw()
01390 #endif
01391         { return _mvvconvassign(*this,rvector(rv)); }
01392         INLINE l_imatrix_subv &l_imatrix_subv::operator &=(const rvector &rv)
01393 #if(CXSC_INDEX_CHECK)
01394         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
01395 #else
01396         throw()
01397 #endif
01398         { return _mvvsectassign(*this,rv); }
01399         INLINE l_imatrix_subv &l_imatrix_subv::operator &=(const rvector_slice &rv)
01400 #if(CXSC_INDEX_CHECK)
01401         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
01402 #else
01403         throw()
01404 #endif
01405         { return _mvvsectassign(*this,rvector(rv)); }
01406 
01407         INLINE l_imatrix_subv &l_imatrix_subv::operator *=(const l_real &c) throw() { return _mvsmultassign(*this,c); }
01408         INLINE l_imatrix_subv &l_imatrix_subv::operator +=(const l_real &c) throw() { return _mvsplusassign(*this,c); }
01409         INLINE l_imatrix_subv &l_imatrix_subv::operator -=(const l_real &c) throw() { return _mvsminusassign(*this,c); }
01410         INLINE l_imatrix_subv &l_imatrix_subv::operator /=(const l_real &c) throw() { return _mvsdivassign(*this,c); }
01411         INLINE l_imatrix_subv &l_imatrix_subv::operator +=(const l_rvector &rv)
01412 #if(CXSC_INDEX_CHECK)
01413         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
01414 #else
01415         throw()
01416 #endif
01417         { return _mvvplusassign(*this,rv); }
01418         INLINE l_imatrix_subv &l_imatrix_subv::operator +=(const l_rvector_slice &rv)
01419 #if(CXSC_INDEX_CHECK)
01420         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
01421 #else
01422         throw()
01423 #endif
01424         { return _mvvplusassign(*this,l_rvector(rv)); }
01425         INLINE l_imatrix_subv &l_imatrix_subv::operator -=(const l_rvector &rv)
01426 #if(CXSC_INDEX_CHECK)
01427         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
01428 #else
01429         throw()
01430 #endif
01431         { return _mvvminusassign(*this,rv); }
01432         INLINE l_imatrix_subv &l_imatrix_subv::operator -=(const l_rvector_slice &rv)
01433 #if(CXSC_INDEX_CHECK)
01434         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
01435 #else
01436         throw()
01437 #endif
01438         { return _mvvminusassign(*this,l_rvector(rv)); }
01439         INLINE l_imatrix_subv &l_imatrix_subv::operator |=(const l_rvector &rv)
01440 #if(CXSC_INDEX_CHECK)
01441         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
01442 #else
01443         throw()
01444 #endif
01445         { return _mvvconvassign(*this,rv); }
01446         INLINE l_imatrix_subv &l_imatrix_subv::operator |=(const l_rvector_slice &rv)
01447 #if(CXSC_INDEX_CHECK)
01448         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
01449 #else
01450         throw()
01451 #endif
01452         { return _mvvconvassign(*this,l_rvector(rv)); }
01453         INLINE l_imatrix_subv &l_imatrix_subv::operator &=(const l_rvector &rv)
01454 #if(CXSC_INDEX_CHECK)
01455         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
01456 #else
01457         throw()
01458 #endif
01459         { return _mvvsectassign(*this,rv); }
01460         INLINE l_imatrix_subv &l_imatrix_subv::operator &=(const l_rvector_slice &rv)
01461 #if(CXSC_INDEX_CHECK)
01462         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
01463 #else
01464         throw()
01465 #endif
01466         { return _mvvsectassign(*this,l_rvector(rv)); }
01467 
01468         INLINE l_imatrix_subv &l_imatrix_subv::operator *=(const interval &c) throw() { return _mvsmultassign(*this,c); }
01469         INLINE l_imatrix_subv &l_imatrix_subv::operator +=(const interval &c) throw() { return _mvsplusassign(*this,c); }
01470         INLINE l_imatrix_subv &l_imatrix_subv::operator -=(const interval &c) throw() { return _mvsminusassign(*this,c); }
01471         INLINE l_imatrix_subv &l_imatrix_subv::operator /=(const interval &c) throw() { return _mvsdivassign(*this,c); }
01472         INLINE l_imatrix_subv &l_imatrix_subv::operator +=(const ivector &rv)
01473 #if(CXSC_INDEX_CHECK)
01474         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
01475 #else
01476         throw()
01477 #endif
01478         { return _mvvplusassign(*this,rv); }
01479         INLINE l_imatrix_subv &l_imatrix_subv::operator +=(const ivector_slice &rv)
01480 #if(CXSC_INDEX_CHECK)
01481         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
01482 #else
01483         throw()
01484 #endif
01485         { return _mvvplusassign(*this,ivector(rv)); }
01486         INLINE l_imatrix_subv &l_imatrix_subv::operator -=(const ivector &rv)
01487 #if(CXSC_INDEX_CHECK)
01488         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
01489 #else
01490         throw()
01491 #endif
01492         { return _mvvminusassign(*this,rv); }
01493         INLINE l_imatrix_subv &l_imatrix_subv::operator -=(const ivector_slice &rv)
01494 #if(CXSC_INDEX_CHECK)
01495         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
01496 #else
01497         throw()
01498 #endif
01499         { return _mvvminusassign(*this,ivector(rv)); }
01500         INLINE l_imatrix_subv &l_imatrix_subv::operator |=(const ivector &rv)
01501 #if(CXSC_INDEX_CHECK)
01502         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
01503 #else
01504         throw()
01505 #endif
01506         { return _mvvconvassign(*this,rv); }
01507         INLINE l_imatrix_subv &l_imatrix_subv::operator |=(const ivector_slice &rv)
01508 #if(CXSC_INDEX_CHECK)
01509         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
01510 #else
01511         throw()
01512 #endif
01513         { return _mvvconvassign(*this,ivector(rv)); }
01514         INLINE l_imatrix_subv &l_imatrix_subv::operator &=(const ivector &rv)
01515 #if(CXSC_INDEX_CHECK)
01516         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
01517 #else
01518         throw()
01519 #endif
01520         { return _mvvsectassign(*this,rv); }
01521         INLINE l_imatrix_subv &l_imatrix_subv::operator &=(const ivector_slice &rv)
01522 #if(CXSC_INDEX_CHECK)
01523         throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM)
01524 #else
01525         throw()
01526 #endif
01527         { return _mvvsectassign(*this,ivector(rv)); }
01528 
01529 
01530         INLINE l_imatrix operator *(const l_interval &c, const l_imatrix &m) throw() { return _smmult<l_interval,l_imatrix,l_imatrix>(c,m); }
01531         INLINE l_imatrix operator *(const l_interval &c, const l_imatrix_slice &ms) throw() { return _smsmult<l_interval,l_imatrix_slice,l_imatrix>(c,ms); }
01532         INLINE l_imatrix operator *(const l_imatrix &m,const l_interval &c) throw() { return _smmult<l_interval,l_imatrix,l_imatrix>(c,m); }
01533         INLINE l_imatrix operator *(const l_imatrix_slice &ms,const l_interval &c) throw() { return _smsmult<l_interval,l_imatrix_slice,l_imatrix>(c,ms); }
01534         INLINE l_imatrix &operator *=(l_imatrix &m,const l_interval &c) throw() { return _msmultassign(m,c); }
01535         INLINE l_imatrix_slice &l_imatrix_slice::operator *=(const l_imatrix &m)
01536 #if(CXSC_INDEX_CHECK)
01537         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01538 #else
01539         throw()
01540 #endif
01541         { return (*this=*this*m); }
01542         INLINE l_imatrix_slice &l_imatrix_slice::operator *=(const l_imatrix_slice &m)
01543 #if(CXSC_INDEX_CHECK)
01544         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01545 #else
01546         throw()
01547 #endif
01548         { return (*this=*this*m); }
01549         INLINE l_imatrix_slice &l_imatrix_slice::operator *=(const l_interval &c) throw() { return _mssmultassign(*this,c); }
01550         INLINE l_imatrix operator /(const l_imatrix &m,const l_interval &c) throw() { return _msdiv<l_imatrix,l_interval,l_imatrix>(m,c); }
01551         INLINE l_imatrix operator /(const l_imatrix_slice &ms, const l_interval &c) throw() { return _mssdiv<l_imatrix_slice,l_interval,l_imatrix>(ms,c); }
01552         INLINE l_imatrix &operator /=(l_imatrix &m,const l_interval &c) throw() { return _msdivassign(m,c); }
01553         INLINE l_imatrix_slice &l_imatrix_slice::operator /=(const l_interval &c) throw() { return _mssdivassign(*this,c); }
01554         
01555         INLINE l_imatrix operator *(const real &c, const l_imatrix &m) throw() { return _smmult<real,l_imatrix,l_imatrix>(c,m); }
01556         INLINE l_imatrix operator *(const real &c, const l_imatrix_slice &ms) throw() { return _smsmult<real,l_imatrix_slice,l_imatrix>(c,ms); }
01557         INLINE l_imatrix operator *(const l_imatrix &m,const real &c) throw() { return _smmult<real,l_imatrix,l_imatrix>(c,m); }
01558         INLINE l_imatrix operator *(const l_imatrix_slice &ms,const real &c) throw() { return _smsmult<real,l_imatrix_slice,l_imatrix>(c,ms); }
01559         INLINE l_imatrix &operator *=(l_imatrix &m,const real &c) throw() { return _msmultassign(m,c); }
01560         INLINE l_imatrix_slice &l_imatrix_slice::operator *=(const rmatrix &m)
01561 #if(CXSC_INDEX_CHECK)
01562         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01563 #else
01564         throw()
01565 #endif
01566         { return (*this=*this*m); }
01567         INLINE l_imatrix_slice &l_imatrix_slice::operator *=(const rmatrix_slice &m)
01568 #if(CXSC_INDEX_CHECK)
01569         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01570 #else
01571         throw()
01572 #endif
01573         { return (*this=*this*m); }
01574         INLINE l_imatrix_slice &l_imatrix_slice::operator *=(const real &c) throw() { return _mssmultassign(*this,c); }
01575         INLINE l_imatrix operator /(const l_imatrix &m,const real &c) throw() { return _msdiv<l_imatrix,real,l_imatrix>(m,c); }
01576         INLINE l_imatrix operator /(const l_imatrix_slice &ms, const real &c) throw() { return _mssdiv<l_imatrix_slice,real,l_imatrix>(ms,c); }
01577         INLINE l_imatrix &operator /=(l_imatrix &m,const real &c) throw() { return _msdivassign(m,c); }
01578         INLINE l_imatrix_slice &l_imatrix_slice::operator /=(const real &c) throw() { return _mssdivassign(*this,c); }
01579 
01580         INLINE l_imatrix operator *(const l_real &c, const l_imatrix &m) throw() { return _smmult<l_real,l_imatrix,l_imatrix>(c,m); }
01581         INLINE l_imatrix operator *(const l_real &c, const l_imatrix_slice &ms) throw() { return _smsmult<l_real,l_imatrix_slice,l_imatrix>(c,ms); }
01582         INLINE l_imatrix operator *(const l_imatrix &m,const l_real &c) throw() { return _smmult<l_real,l_imatrix,l_imatrix>(c,m); }
01583         INLINE l_imatrix operator *(const l_imatrix_slice &ms,const l_real &c) throw() { return _smsmult<l_real,l_imatrix_slice,l_imatrix>(c,ms); }
01584         INLINE l_imatrix &operator *=(l_imatrix &m,const l_real &c) throw() { return _msmultassign(m,c); }
01585         INLINE l_imatrix_slice &l_imatrix_slice::operator *=(const l_rmatrix &m)
01586 #if(CXSC_INDEX_CHECK)
01587         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01588 #else
01589         throw()
01590 #endif
01591         { return (*this=*this*m); }
01592         INLINE l_imatrix_slice &l_imatrix_slice::operator *=(const l_rmatrix_slice &m)
01593 #if(CXSC_INDEX_CHECK)
01594         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01595 #else
01596         throw()
01597 #endif
01598         { return (*this=*this*m); }
01599         INLINE l_imatrix_slice &l_imatrix_slice::operator *=(const l_real &c) throw() { return _mssmultassign(*this,c); }
01600         INLINE l_imatrix operator /(const l_imatrix &m,const l_real &c) throw() { return _msdiv<l_imatrix,l_real,l_imatrix>(m,c); }
01601         INLINE l_imatrix operator /(const l_imatrix_slice &ms, const l_real &c) throw() { return _mssdiv<l_imatrix_slice,l_real,l_imatrix>(ms,c); }
01602         INLINE l_imatrix &operator /=(l_imatrix &m,const l_real &c) throw() { return _msdivassign(m,c); }
01603         INLINE l_imatrix_slice &l_imatrix_slice::operator /=(const l_real &c) throw() { return _mssdivassign(*this,c); }
01604 
01605         INLINE l_imatrix operator *(const interval &c, const l_imatrix &m) throw() { return _smmult<interval,l_imatrix,l_imatrix>(c,m); }
01606         INLINE l_imatrix operator *(const interval &c, const l_imatrix_slice &ms) throw() { return _smsmult<interval,l_imatrix_slice,l_imatrix>(c,ms); }
01607         INLINE l_imatrix operator *(const l_imatrix &m,const interval &c) throw() { return _smmult<interval,l_imatrix,l_imatrix>(c,m); }
01608         INLINE l_imatrix operator *(const l_imatrix_slice &ms,const interval &c) throw() { return _smsmult<interval,l_imatrix_slice,l_imatrix>(c,ms); }
01609         INLINE l_imatrix &operator *=(l_imatrix &m,const interval &c) throw() { return _msmultassign(m,c); }
01610         INLINE l_imatrix_slice &l_imatrix_slice::operator *=(const imatrix &m)
01611 #if(CXSC_INDEX_CHECK)
01612         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01613 #else
01614         throw()
01615 #endif
01616         { return (*this=*this*m); }
01617         INLINE l_imatrix_slice &l_imatrix_slice::operator *=(const imatrix_slice &m)
01618 #if(CXSC_INDEX_CHECK)
01619         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01620 #else
01621         throw()
01622 #endif
01623         { return (*this=*this*m); }
01624         INLINE l_imatrix_slice &l_imatrix_slice::operator *=(const interval &c) throw() { return _mssmultassign(*this,c); }
01625         INLINE l_imatrix operator /(const l_imatrix &m,const interval &c) throw() { return _msdiv<l_imatrix,interval,l_imatrix>(m,c); }
01626         INLINE l_imatrix operator /(const l_imatrix_slice &ms, const interval &c) throw() { return _mssdiv<l_imatrix_slice,interval,l_imatrix>(ms,c); }
01627         INLINE l_imatrix &operator /=(l_imatrix &m,const interval &c) throw() { return _msdivassign(m,c); }
01628         INLINE l_imatrix_slice &l_imatrix_slice::operator /=(const interval &c) throw() { return _mssdivassign(*this,c); }
01629 
01630 //      INLINE l_interval::l_interval(const rmatrix &m) throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ,ERROR_LIMATRIX_USE_OF_UNINITIALIZED_OBJ) { _smconstr(*this,m); }
01631 //      INLINE l_interval l_interval::_interval(const l_imatrix &m) throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ,ERROR_LIMATRIX_USE_OF_UNINITIALIZED_OBJ) { _smconstr(*this,m); return *this; }
01632 
01633         INLINE l_imatrix operator *(const l_interval &c, const rmatrix &m) throw() { return _smmult<l_interval,rmatrix,l_imatrix>(c,m); }
01634         INLINE l_imatrix operator *(const l_interval &c, const rmatrix_slice &ms) throw() { return _smsmult<l_interval,rmatrix_slice,l_imatrix>(c,ms); }
01635         INLINE l_imatrix operator *(const rmatrix &m,const l_interval &c) throw() { return _smmult<l_interval,rmatrix,l_imatrix>(c,m); }
01636         INLINE l_imatrix operator *(const rmatrix_slice &ms,const l_interval &c) throw() { return _smsmult<l_interval,rmatrix_slice,l_imatrix>(c,ms); }
01637         INLINE l_imatrix operator /(const rmatrix &m,const l_interval &c) throw() { return _msdiv<rmatrix,l_interval,l_imatrix>(m,c); }
01638         INLINE l_imatrix operator /(const rmatrix_slice &ms, const l_interval &c) throw() { return _mssdiv<rmatrix_slice,l_interval,l_imatrix>(ms,c); }
01639 
01640         INLINE l_imatrix operator *(const l_interval &c, const l_rmatrix &m) throw() { return _smmult<l_interval,l_rmatrix,l_imatrix>(c,m); }
01641         INLINE l_imatrix operator *(const l_interval &c, const l_rmatrix_slice &ms) throw() { return _smsmult<l_interval,l_rmatrix_slice,l_imatrix>(c,ms); }
01642         INLINE l_imatrix operator *(const l_rmatrix &m,const l_interval &c) throw() { return _smmult<l_interval,l_rmatrix,l_imatrix>(c,m); }
01643         INLINE l_imatrix operator *(const l_rmatrix_slice &ms,const l_interval &c) throw() { return _smsmult<l_interval,l_rmatrix_slice,l_imatrix>(c,ms); }
01644         INLINE l_imatrix operator /(const l_rmatrix &m,const l_interval &c) throw() { return _msdiv<l_rmatrix,l_interval,l_imatrix>(m,c); }
01645         INLINE l_imatrix operator /(const l_rmatrix_slice &ms, const l_interval &c) throw() { return _mssdiv<l_rmatrix_slice,l_interval,l_imatrix>(ms,c); }
01646 
01647         INLINE l_imatrix operator *(const l_interval &c, const imatrix &m) throw() { return _smmult<l_interval,imatrix,l_imatrix>(c,m); }
01648         INLINE l_imatrix operator *(const l_interval &c, const imatrix_slice &ms) throw() { return _smsmult<l_interval,imatrix_slice,l_imatrix>(c,ms); }
01649         INLINE l_imatrix operator *(const imatrix &m,const l_interval &c) throw() { return _smmult<l_interval,imatrix,l_imatrix>(c,m); }
01650         INLINE l_imatrix operator *(const imatrix_slice &ms,const l_interval &c) throw() { return _smsmult<l_interval,imatrix_slice,l_imatrix>(c,ms); }
01651         INLINE l_imatrix operator /(const imatrix &m,const l_interval &c) throw() { return _msdiv<imatrix,l_interval,l_imatrix>(m,c); }
01652         INLINE l_imatrix operator /(const imatrix_slice &ms, const l_interval &c) throw() { return _mssdiv<imatrix_slice,l_interval,l_imatrix>(ms,c); }
01653 
01654         INLINE l_ivector::l_ivector(const l_imatrix &sl)
01655 #if(CXSC_INDEX_CHECK)
01656         throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
01657 #else
01658         throw()
01659 #endif
01660         { _vmconstr<l_ivector,l_imatrix,l_interval>(*this,sl); }
01661         INLINE l_ivector::l_ivector(const l_imatrix_slice &sl)
01662 #if(CXSC_INDEX_CHECK)
01663         throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
01664 #else
01665         throw()
01666 #endif
01667         { _vmsconstr<l_ivector,l_imatrix_slice,l_interval>(*this,sl); }
01668         INLINE l_ivector &l_ivector::operator =(const l_imatrix &m)
01669 #if(CXSC_INDEX_CHECK)
01670         throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
01671 #else
01672         throw()
01673 #endif
01674         { return _vmassign<l_ivector,l_imatrix,l_interval>(*this,m); }
01675         INLINE l_ivector &l_ivector::operator =(const l_imatrix_slice &m)
01676 #if(CXSC_INDEX_CHECK)
01677         throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
01678 #else
01679         throw()
01680 #endif
01681         { return _vmassign<l_ivector,l_imatrix,l_interval>(*this,l_imatrix(m)); }
01682         INLINE l_ivector_slice & l_ivector_slice::operator =(const l_imatrix_slice &m)
01683 #if(CXSC_INDEX_CHECK)
01684         throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>,ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
01685 #else
01686         throw()
01687 #endif
01688         { return _vsvassign(*this,l_ivector(l_imatrix(m))); }
01689         INLINE l_imatrix_subv &l_imatrix_subv::operator =(const l_imatrix &m)
01690 #if(CXSC_INDEX_CHECK)
01691         throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
01692 #else
01693         throw()
01694 #endif
01695         { return _mvvassign(*this,l_ivector(m)); }
01696         INLINE l_imatrix_subv &l_imatrix_subv::operator =(const l_imatrix_slice &m)
01697 #if(CXSC_INDEX_CHECK)
01698         throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
01699 #else
01700         throw()
01701 #endif
01702         { return _mvvassign(*this,l_ivector(l_imatrix(m))); }
01703         INLINE l_ivector operator *(const l_imatrix &m,const l_ivector &v)
01704 #if(CXSC_INDEX_CHECK)
01705         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01706 #else
01707         throw()
01708 #endif
01709         { return _mvlimult<l_imatrix,l_ivector,l_ivector>(m,v); }
01710         INLINE l_ivector operator *(const l_imatrix_slice &ms,const l_ivector &v)
01711 #if(CXSC_INDEX_CHECK)
01712         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01713 #else
01714         throw()
01715 #endif
01716         { return _msvlimult<l_imatrix_slice,l_ivector,l_ivector>(ms,v); }
01717         INLINE l_ivector operator *(const l_ivector &v,const l_imatrix &m)
01718 #if(CXSC_INDEX_CHECK)
01719         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01720 #else
01721         throw()
01722 #endif
01723         { return _vmlimult<l_ivector,l_imatrix,l_ivector>(v,m); }
01724         INLINE l_ivector operator *(const l_ivector &v,const l_imatrix_slice &ms)
01725 #if(CXSC_INDEX_CHECK)
01726         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01727 #else
01728         throw()
01729 #endif
01730         { return _vmslimult<l_ivector,l_imatrix_slice,l_ivector>(v,ms); }
01731         INLINE l_ivector &operator *=(l_ivector &v,const l_imatrix &m)
01732 #if(CXSC_INDEX_CHECK)
01733         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01734 #else
01735         throw()
01736 #endif
01737         { return _vmlimultassign<l_ivector,l_imatrix,l_interval>(v,m); }
01738         INLINE l_ivector &operator *=(l_ivector &v,const l_imatrix_slice &ms)
01739 #if(CXSC_INDEX_CHECK)
01740         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01741 #else
01742         throw()
01743 #endif
01744         { return _vmslimultassign<l_ivector,l_imatrix_slice,l_interval>(v,ms); }
01745         INLINE l_ivector_slice &l_ivector_slice::operator *=(const l_imatrix &m)
01746 #if(CXSC_INDEX_CHECK)
01747         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01748 #else
01749         throw()
01750 #endif
01751         { return _vsmlimultassign<l_ivector_slice,l_imatrix,l_interval>(*this,m); }
01752         INLINE l_ivector operator *(const l_ivector_slice &v,const l_imatrix &m)
01753 #if(CXSC_INDEX_CHECK)
01754         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01755 #else
01756         throw()
01757 #endif
01758         { return _vmlimult<l_ivector,l_imatrix,l_ivector>(l_ivector(v),m); }
01759         INLINE l_ivector operator *(const l_ivector_slice &v,const l_imatrix_slice &m)
01760 #if(CXSC_INDEX_CHECK)
01761         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01762 #else
01763         throw()
01764 #endif
01765         { return _vmslimult<l_ivector,l_imatrix_slice,l_ivector>(l_ivector(v),m); }
01766 
01767         INLINE l_imatrix_subv &l_imatrix_subv::operator =(const rmatrix &m)
01768 #if(CXSC_INDEX_CHECK)
01769         throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
01770 #else
01771         throw()
01772 #endif
01773         { return _mvvassign(*this,rvector(m)); }
01774         INLINE l_imatrix_subv &l_imatrix_subv::operator =(const rmatrix_slice &m)
01775 #if(CXSC_INDEX_CHECK)
01776         throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
01777 #else
01778         throw()
01779 #endif
01780         { return _mvvassign(*this,rvector(rmatrix(m))); }
01781         INLINE l_ivector operator *(const rvector &v,const l_imatrix &m)
01782 #if(CXSC_INDEX_CHECK)
01783         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01784 #else
01785         throw()
01786 #endif
01787         { return _vmlimult<rvector,l_imatrix,l_ivector>(v,m); }
01788         INLINE l_ivector operator *(const rvector &v,const l_imatrix_slice &ms)
01789 #if(CXSC_INDEX_CHECK)
01790         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01791 #else
01792         throw()
01793 #endif
01794         { return _vmslimult<rvector,l_imatrix_slice,l_ivector>(v,ms); }
01795         INLINE l_ivector operator *(const rvector_slice &v,const l_imatrix &m)
01796 #if(CXSC_INDEX_CHECK)
01797         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01798 #else
01799         throw()
01800 #endif
01801         { return _vmlimult<l_ivector,l_imatrix,l_ivector>(l_ivector(v),m); }
01802         INLINE l_ivector operator *(const l_imatrix &m,const rvector &v)
01803 #if(CXSC_INDEX_CHECK)
01804         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01805 #else
01806         throw()
01807 #endif
01808         { return _mvlimult<l_imatrix,rvector,l_ivector>(m,v); }
01809         INLINE l_ivector operator *(const l_imatrix_slice &ms,const rvector &v)
01810 #if(CXSC_INDEX_CHECK)
01811         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01812 #else
01813         throw()
01814 #endif
01815         { return _msvlimult<l_imatrix_slice,rvector,l_ivector>(ms,v); }
01816 
01817         INLINE l_imatrix_subv &l_imatrix_subv::operator =(const l_rmatrix &m)
01818 #if(CXSC_INDEX_CHECK)
01819         throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
01820 #else
01821         throw()
01822 #endif
01823         { return _mvvassign(*this,l_rvector(m)); }
01824         INLINE l_imatrix_subv &l_imatrix_subv::operator =(const l_rmatrix_slice &m)
01825 #if(CXSC_INDEX_CHECK)
01826         throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
01827 #else
01828         throw()
01829 #endif
01830         { return _mvvassign(*this,l_rvector(l_rmatrix(m))); }
01831         INLINE l_ivector operator *(const l_rvector &v,const l_imatrix &m)
01832 #if(CXSC_INDEX_CHECK)
01833         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01834 #else
01835         throw()
01836 #endif
01837         { return _vmlimult<l_rvector,l_imatrix,l_ivector>(v,m); }
01838         INLINE l_ivector operator *(const l_rvector &v,const l_imatrix_slice &ms)
01839 #if(CXSC_INDEX_CHECK)
01840         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01841 #else
01842         throw()
01843 #endif
01844         { return _vmslimult<l_rvector,l_imatrix_slice,l_ivector>(v,ms); }
01845         INLINE l_ivector operator *(const l_rvector_slice &v,const l_imatrix &m)
01846 #if(CXSC_INDEX_CHECK)
01847         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01848 #else
01849         throw()
01850 #endif
01851         { return _vmlimult<l_ivector,l_imatrix,l_ivector>(l_ivector(v),m); }
01852         INLINE l_ivector operator *(const l_imatrix &m,const l_rvector &v)
01853 #if(CXSC_INDEX_CHECK)
01854         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01855 #else
01856         throw()
01857 #endif
01858         { return _mvlimult<l_imatrix,l_rvector,l_ivector>(m,v); }
01859         INLINE l_ivector operator *(const l_imatrix_slice &ms,const l_rvector &v)
01860 #if(CXSC_INDEX_CHECK)
01861         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01862 #else
01863         throw()
01864 #endif
01865         { return _msvlimult<l_imatrix_slice,l_rvector,l_ivector>(ms,v); }
01866 
01867         INLINE l_imatrix_subv &l_imatrix_subv::operator =(const imatrix &m)
01868 #if(CXSC_INDEX_CHECK)
01869         throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
01870 #else
01871         throw()
01872 #endif
01873         { return _mvvassign(*this,ivector(m)); }
01874         INLINE l_imatrix_subv &l_imatrix_subv::operator =(const imatrix_slice &m)
01875 #if(CXSC_INDEX_CHECK)
01876         throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ)
01877 #else
01878         throw()
01879 #endif
01880         { return _mvvassign(*this,ivector(imatrix(m))); }
01881         INLINE l_ivector operator *(const ivector &v,const l_imatrix &m)
01882 #if(CXSC_INDEX_CHECK)
01883         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01884 #else
01885         throw()
01886 #endif
01887         { return _vmlimult<ivector,l_imatrix,l_ivector>(v,m); }
01888         INLINE l_ivector operator *(const ivector &v,const l_imatrix_slice &ms)
01889 #if(CXSC_INDEX_CHECK)
01890         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01891 #else
01892         throw()
01893 #endif
01894         { return _vmslimult<ivector,l_imatrix_slice,l_ivector>(v,ms); }
01895         INLINE l_ivector operator *(const ivector_slice &v,const l_imatrix &m)
01896 #if(CXSC_INDEX_CHECK)
01897         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01898 #else
01899         throw()
01900 #endif
01901         { return _vmlimult<l_ivector,l_imatrix,l_ivector>(l_ivector(v),m); }
01902         INLINE l_ivector operator *(const l_imatrix &m,const ivector &v)
01903 #if(CXSC_INDEX_CHECK)
01904         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01905 #else
01906         throw()
01907 #endif
01908         { return _mvlimult<l_imatrix,ivector,l_ivector>(m,v); }
01909         INLINE l_ivector operator *(const l_imatrix_slice &ms,const ivector &v)
01910 #if(CXSC_INDEX_CHECK)
01911         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01912 #else
01913         throw()
01914 #endif
01915         { return _msvlimult<l_imatrix_slice,ivector,l_ivector>(ms,v); }
01916 
01917         INLINE const l_imatrix &operator +(const l_imatrix &m) throw() { return m; }
01918         INLINE l_imatrix operator +(const l_imatrix_slice &m) throw() { return l_imatrix(m); }
01919         INLINE l_imatrix operator +(const l_imatrix &m1,const l_imatrix &m2)
01920 #if(CXSC_INDEX_CHECK)
01921         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01922 #else
01923         throw()
01924 #endif
01925         { return _mmplus<l_imatrix,l_imatrix,l_imatrix>(m1,m2); }
01926         INLINE l_imatrix operator +(const l_imatrix &m,const l_imatrix_slice &ms)
01927 #if(CXSC_INDEX_CHECK)
01928         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01929 #else
01930         throw()
01931 #endif
01932         { return _mmsplus<l_imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
01933         INLINE l_imatrix operator +(const l_imatrix_slice &ms,const l_imatrix &m)
01934 #if(CXSC_INDEX_CHECK)
01935         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01936 #else
01937         throw()
01938 #endif
01939         { return _mmsplus<l_imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
01940         INLINE l_imatrix operator +(const l_imatrix_slice &m1,const l_imatrix_slice &m2)
01941 #if(CXSC_INDEX_CHECK)
01942         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01943 #else
01944         throw()
01945 #endif
01946         { return _msmsplus<l_imatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
01947         INLINE l_imatrix &operator +=(l_imatrix &m1,const l_imatrix &m2)
01948 #if(CXSC_INDEX_CHECK)
01949         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01950 #else
01951         throw()
01952 #endif
01953         { return _mmplusassign(m1,m2); }
01954         INLINE l_imatrix &operator +=(l_imatrix &m1,const l_imatrix_slice &ms)
01955 #if(CXSC_INDEX_CHECK)
01956         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01957 #else
01958         throw()
01959 #endif
01960         { return _mmsplusassign(m1,ms); }
01961         INLINE l_imatrix_slice &l_imatrix_slice::operator +=(const l_imatrix &m1)
01962 #if(CXSC_INDEX_CHECK)
01963         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01964 #else
01965         throw()
01966 #endif
01967         { return _msmplusassign(*this,m1); }
01968         INLINE l_imatrix_slice &l_imatrix_slice::operator +=(const l_imatrix_slice &ms2)
01969 #if(CXSC_INDEX_CHECK)
01970         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01971 #else
01972         throw()
01973 #endif
01974         { return _msmsplusassign(*this,ms2); }
01975         INLINE l_imatrix operator -(const l_imatrix &m) throw() { return _mminus(m); }
01976         INLINE l_imatrix operator -(const l_imatrix_slice &m) throw() { return _msminus<l_imatrix_slice,l_imatrix>(m); }
01977         INLINE l_imatrix operator -(const l_imatrix &m1,const l_imatrix &m2)
01978 #if(CXSC_INDEX_CHECK)
01979         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01980 #else
01981         throw()
01982 #endif
01983         { return _mmminus<l_imatrix,l_imatrix,l_imatrix>(m1,m2); }
01984         INLINE l_imatrix operator -(const l_imatrix &m,const l_imatrix_slice &ms)
01985 #if(CXSC_INDEX_CHECK)
01986         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01987 #else
01988         throw()
01989 #endif
01990         { return _mmsminus<l_imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
01991         INLINE l_imatrix operator -(const l_imatrix_slice &ms,const l_imatrix &m)
01992 #if(CXSC_INDEX_CHECK)
01993         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
01994 #else
01995         throw()
01996 #endif
01997         { return _msmminus<l_imatrix_slice,l_imatrix,l_imatrix>(ms,m); }
01998         INLINE l_imatrix operator -(const l_imatrix_slice &ms1,const l_imatrix_slice &ms2)
01999 #if(CXSC_INDEX_CHECK)
02000         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02001 #else
02002         throw()
02003 #endif
02004         { return _msmsminus<l_imatrix_slice,l_imatrix_slice,l_imatrix>(ms1,ms2); }
02005         INLINE l_imatrix &operator -=(l_imatrix &m1,const l_imatrix &m2)
02006 #if(CXSC_INDEX_CHECK)
02007         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02008 #else
02009         throw()
02010 #endif
02011         { return _mmminusassign(m1,m2); }
02012         INLINE l_imatrix &operator -=(l_imatrix &m1,const l_imatrix_slice &ms)
02013 #if(CXSC_INDEX_CHECK)
02014         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02015 #else
02016         throw()
02017 #endif
02018         { return _mmsminusassign(m1,ms); }
02019         INLINE l_imatrix_slice &l_imatrix_slice::operator -=(const l_imatrix &m1)
02020 #if(CXSC_INDEX_CHECK)
02021         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02022 #else
02023         throw()
02024 #endif
02025         { return _msmminusassign(*this,m1); }
02026         INLINE l_imatrix_slice &l_imatrix_slice::operator -=(const l_imatrix_slice &ms2)
02027 #if(CXSC_INDEX_CHECK)
02028         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02029 #else
02030         throw()
02031 #endif
02032         { return _msmsminusassign(*this,ms2); }
02033         INLINE l_imatrix operator *(const l_imatrix &m1, const l_imatrix &m2)
02034 #if(CXSC_INDEX_CHECK)
02035         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02036 #else
02037         throw()
02038 #endif
02039         { return _mmlimult<l_imatrix,l_imatrix,l_imatrix>(m1,m2); }
02040         INLINE l_imatrix operator *(const l_imatrix &m1, const l_imatrix_slice &ms)
02041 #if(CXSC_INDEX_CHECK)
02042         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02043 #else
02044         throw()
02045 #endif
02046         { return _mmslimult<l_imatrix,l_imatrix_slice,l_imatrix>(m1,ms); }
02047         INLINE l_imatrix operator *(const l_imatrix_slice &ms, const l_imatrix &m1)
02048 #if(CXSC_INDEX_CHECK)
02049         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02050 #else
02051         throw()
02052 #endif
02053         { return _msmlimult<l_imatrix_slice,l_imatrix,l_imatrix>(ms,m1); }
02054         INLINE l_imatrix operator *(const l_imatrix_slice &ms1, const l_imatrix_slice &ms2)
02055 #if(CXSC_INDEX_CHECK)
02056         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02057 #else
02058         throw()
02059 #endif
02060         { return _msmslimult<l_imatrix_slice,l_imatrix_slice,l_imatrix>(ms1,ms2); }
02061         INLINE l_imatrix &operator *=(l_imatrix &m1,const l_imatrix &m2)
02062 #if(CXSC_INDEX_CHECK)
02063         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02064 #else
02065         throw()
02066 #endif
02067         { return _mmlimultassign<l_imatrix,l_imatrix,l_interval>(m1,m2); }
02068         INLINE l_imatrix &operator *=(l_imatrix &m1,const l_imatrix_slice &ms)
02069 #if(CXSC_INDEX_CHECK)
02070         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02071 #else
02072         throw()
02073 #endif
02074         { return _mmslimultassign<l_imatrix,l_imatrix_slice,l_interval>(m1,ms); }
02075         INLINE l_imatrix operator |(const l_imatrix &m1,const l_imatrix &m2)
02076 #if(CXSC_INDEX_CHECK)
02077         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02078 #else
02079         throw()
02080 #endif
02081         { return _mmconv<l_imatrix,l_imatrix,l_imatrix>(m1,m2); }
02082         INLINE l_imatrix operator |(const l_imatrix &m,const l_imatrix_slice &ms)
02083 #if(CXSC_INDEX_CHECK)
02084         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02085 #else
02086         throw()
02087 #endif
02088         { return _mmsconv<l_imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
02089         INLINE l_imatrix operator |(const l_imatrix_slice &ms,const l_imatrix &m)
02090 #if(CXSC_INDEX_CHECK)
02091         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02092 #else
02093         throw()
02094 #endif
02095         { return _mmsconv<l_imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
02096         INLINE l_imatrix operator |(const l_imatrix_slice &m1,const l_imatrix_slice &m2)
02097 #if(CXSC_INDEX_CHECK)
02098         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02099 #else
02100         throw()
02101 #endif
02102         { return _msmsconv<l_imatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
02103         INLINE l_imatrix &operator |=(l_imatrix &m1,const l_imatrix &m2)
02104 #if(CXSC_INDEX_CHECK)
02105         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02106 #else
02107         throw()
02108 #endif
02109         { return _mmconvassign(m1,m2); }
02110         INLINE l_imatrix &operator |=(l_imatrix &m1,const l_imatrix_slice &ms)
02111 #if(CXSC_INDEX_CHECK)
02112         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02113 #else
02114         throw()
02115 #endif
02116         { return _mmsconvassign(m1,ms); }
02117         INLINE l_imatrix_slice &l_imatrix_slice::operator |=(const l_imatrix &m1)
02118 #if(CXSC_INDEX_CHECK)
02119         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02120 #else
02121         throw()
02122 #endif
02123         { return _msmconvassign(*this,m1); }
02124         INLINE l_imatrix_slice &l_imatrix_slice::operator |=(const l_imatrix_slice &ms2)
02125 #if(CXSC_INDEX_CHECK)
02126         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02127 #else
02128         throw()
02129 #endif
02130         { return _msmsconvassign(*this,ms2); }
02131         INLINE l_imatrix operator &(const l_imatrix &m1,const l_imatrix &m2)
02132 #if(CXSC_INDEX_CHECK)
02133         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02134 #else
02135         throw()
02136 #endif
02137         { return _mmsect<l_imatrix,l_imatrix,l_imatrix>(m1,m2); }
02138         INLINE l_imatrix operator &(const l_imatrix &m,const l_imatrix_slice &ms)
02139 #if(CXSC_INDEX_CHECK)
02140         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02141 #else
02142         throw()
02143 #endif
02144         { return _mmssect<l_imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
02145         INLINE l_imatrix operator &(const l_imatrix_slice &ms,const l_imatrix &m)
02146 #if(CXSC_INDEX_CHECK)
02147         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02148 #else
02149         throw()
02150 #endif
02151         { return _mmssect<l_imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
02152         INLINE l_imatrix operator &(const l_imatrix_slice &m1,const l_imatrix_slice &m2)
02153 #if(CXSC_INDEX_CHECK)
02154         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02155 #else
02156         throw()
02157 #endif
02158         { return _msmssect<l_imatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
02159         INLINE l_imatrix &operator &=(l_imatrix &m1,const l_imatrix &m2)
02160 #if(CXSC_INDEX_CHECK)
02161         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02162 #else
02163         throw()
02164 #endif
02165         { return _mmsectassign(m1,m2); }
02166         INLINE l_imatrix &operator &=(l_imatrix &m1,const l_imatrix_slice &ms)
02167 #if(CXSC_INDEX_CHECK)
02168         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02169 #else
02170         throw()
02171 #endif
02172         { return _mmssectassign(m1,ms); }
02173         INLINE l_imatrix_slice &l_imatrix_slice::operator &=(const l_imatrix &m1)
02174 #if(CXSC_INDEX_CHECK)
02175         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02176 #else
02177         throw()
02178 #endif
02179         { return _msmsectassign(*this,m1); }
02180         INLINE l_imatrix_slice &l_imatrix_slice::operator &=(const l_imatrix_slice &ms2)
02181 #if(CXSC_INDEX_CHECK)
02182         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02183 #else
02184         throw()
02185 #endif
02186         { return _msmssectassign(*this,ms2); }
02187 
02188         INLINE l_imatrix operator +(const rmatrix &m1,const l_imatrix &m2)
02189 #if(CXSC_INDEX_CHECK)
02190         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02191 #else
02192         throw()
02193 #endif
02194         { return _mmplus<rmatrix,l_imatrix,l_imatrix>(m1,m2); }
02195         INLINE l_imatrix operator +(const l_imatrix &m1,const rmatrix &m2)
02196 #if(CXSC_INDEX_CHECK)
02197         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02198 #else
02199         throw()
02200 #endif
02201         { return _mmplus<rmatrix,l_imatrix,l_imatrix>(m2,m1); }
02202         INLINE l_imatrix operator +(const rmatrix &m,const l_imatrix_slice &ms)
02203 #if(CXSC_INDEX_CHECK)
02204         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02205 #else
02206         throw()
02207 #endif
02208         { return _mmsplus<rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
02209         INLINE l_imatrix operator +(const l_imatrix &m,const rmatrix_slice &ms)
02210 #if(CXSC_INDEX_CHECK)
02211         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02212 #else
02213         throw()
02214 #endif
02215         { return _mmsplus<l_imatrix,rmatrix_slice,l_imatrix>(m,ms); }
02216         INLINE l_imatrix operator +(const rmatrix_slice &ms,const l_imatrix &m)
02217 #if(CXSC_INDEX_CHECK)
02218         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02219 #else
02220         throw()
02221 #endif
02222         { return _mmsplus<l_imatrix,rmatrix_slice,l_imatrix>(m,ms); }
02223         INLINE l_imatrix operator +(const l_imatrix_slice &ms,const rmatrix &m)
02224 #if(CXSC_INDEX_CHECK)
02225         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02226 #else
02227         throw()
02228 #endif
02229         { return _mmsplus<rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
02230         INLINE l_imatrix operator +(const rmatrix_slice &m1,const l_imatrix_slice &m2)
02231 #if(CXSC_INDEX_CHECK)
02232         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02233 #else
02234         throw()
02235 #endif
02236         { return _msmsplus<rmatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
02237         INLINE l_imatrix operator +(const l_imatrix_slice &m1,const rmatrix_slice &m2)
02238 #if(CXSC_INDEX_CHECK)
02239         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02240 #else
02241         throw()
02242 #endif
02243         { return _msmsplus<rmatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
02244         INLINE l_imatrix &operator +=(l_imatrix &m1,const rmatrix &m2)
02245 #if(CXSC_INDEX_CHECK)
02246         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02247 #else
02248         throw()
02249 #endif
02250         { return _mmplusassign(m1,m2); }
02251         INLINE l_imatrix &operator +=(l_imatrix &m1,const rmatrix_slice &ms)
02252 #if(CXSC_INDEX_CHECK)
02253         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02254 #else
02255         throw()
02256 #endif
02257         { return _mmsplusassign(m1,ms); }
02258         INLINE l_imatrix_slice &l_imatrix_slice::operator +=(const rmatrix &m1)
02259 #if(CXSC_INDEX_CHECK)
02260         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02261 #else
02262         throw()
02263 #endif
02264         { return _msmplusassign(*this,m1); }
02265         INLINE l_imatrix_slice &l_imatrix_slice::operator +=(const rmatrix_slice &ms2)
02266 #if(CXSC_INDEX_CHECK)
02267         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02268 #else
02269         throw()
02270 #endif
02271         { return _msmsplusassign(*this,ms2); }
02272         INLINE l_imatrix operator -(const rmatrix &m1,const l_imatrix &m2)
02273 #if(CXSC_INDEX_CHECK)
02274         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02275 #else
02276         throw()
02277 #endif
02278         { return _mmminus<rmatrix,l_imatrix,l_imatrix>(m1,m2); }
02279         INLINE l_imatrix operator -(const l_imatrix &m1,const rmatrix &m2)
02280 #if(CXSC_INDEX_CHECK)
02281         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02282 #else
02283         throw()
02284 #endif
02285         { return _mmminus<l_imatrix,rmatrix,l_imatrix>(m1,m2); }
02286         INLINE l_imatrix operator -(const rmatrix &m,const l_imatrix_slice &ms)
02287 #if(CXSC_INDEX_CHECK)
02288         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02289 #else
02290         throw()
02291 #endif
02292         { return _mmsminus<rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
02293         INLINE l_imatrix operator -(const l_imatrix &m,const rmatrix_slice &ms)
02294 #if(CXSC_INDEX_CHECK)
02295         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02296 #else
02297         throw()
02298 #endif
02299         { return _mmsminus<l_imatrix,rmatrix_slice,l_imatrix>(m,ms); }
02300         INLINE l_imatrix operator -(const rmatrix_slice &ms,const l_imatrix &m)
02301 #if(CXSC_INDEX_CHECK)
02302         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02303 #else
02304         throw()
02305 #endif
02306         { return _msmminus<rmatrix_slice,l_imatrix,l_imatrix>(ms,m); }
02307         INLINE l_imatrix operator -(const l_imatrix_slice &ms,const rmatrix &m)
02308 #if(CXSC_INDEX_CHECK)
02309         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02310 #else
02311         throw()
02312 #endif
02313         { return _msmminus<l_imatrix_slice,rmatrix,l_imatrix>(ms,m); }
02314         INLINE l_imatrix operator -(const rmatrix_slice &ms1,const l_imatrix_slice &ms2)
02315 #if(CXSC_INDEX_CHECK)
02316         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02317 #else
02318         throw()
02319 #endif
02320         { return _msmsminus<rmatrix_slice,l_imatrix_slice,l_imatrix>(ms1,ms2); }
02321         INLINE l_imatrix operator -(const l_imatrix_slice &ms1,const rmatrix_slice &ms2)
02322 #if(CXSC_INDEX_CHECK)
02323         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02324 #else
02325         throw()
02326 #endif
02327         { return _msmsminus<l_imatrix_slice,rmatrix_slice,l_imatrix>(ms1,ms2); }
02328         INLINE l_imatrix &operator -=(l_imatrix &m1,const rmatrix &m2)
02329 #if(CXSC_INDEX_CHECK)
02330         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02331 #else
02332         throw()
02333 #endif
02334         { return _mmminusassign(m1,m2); }
02335         INLINE l_imatrix &operator -=(l_imatrix &m1,const rmatrix_slice &ms)
02336 #if(CXSC_INDEX_CHECK)
02337         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02338 #else
02339         throw()
02340 #endif
02341         { return _mmsminusassign(m1,ms); }
02342         INLINE l_imatrix_slice &l_imatrix_slice::operator -=(const rmatrix &m1)
02343 #if(CXSC_INDEX_CHECK)
02344         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02345 #else
02346         throw()
02347 #endif
02348         { return _msmminusassign(*this,m1); }
02349         INLINE l_imatrix_slice &l_imatrix_slice::operator -=(const rmatrix_slice &ms2)
02350 #if(CXSC_INDEX_CHECK)
02351         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02352 #else
02353         throw()
02354 #endif
02355         { return _msmsminusassign(*this,ms2); }
02356         INLINE l_imatrix operator *(const rmatrix &m1, const l_imatrix &m2)
02357 #if(CXSC_INDEX_CHECK)
02358         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02359 #else
02360         throw()
02361 #endif
02362         { return _mmlimult<rmatrix,l_imatrix,l_imatrix>(m1,m2); }
02363         INLINE l_imatrix operator *(const l_imatrix &m1, const rmatrix &m2)
02364 #if(CXSC_INDEX_CHECK)
02365         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02366 #else
02367         throw()
02368 #endif
02369         { return _mmlimult<l_imatrix,rmatrix,l_imatrix>(m1,m2); }
02370         INLINE l_imatrix operator *(const rmatrix &m1, const l_imatrix_slice &ms)
02371 #if(CXSC_INDEX_CHECK)
02372         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02373 #else
02374         throw()
02375 #endif
02376         { return _mmslimult<rmatrix,l_imatrix_slice,l_imatrix>(m1,ms); }
02377         INLINE l_imatrix operator *(const l_imatrix &m1, const rmatrix_slice &ms)
02378 #if(CXSC_INDEX_CHECK)
02379         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02380 #else
02381         throw()
02382 #endif
02383         { return _mmslimult<l_imatrix,rmatrix_slice,l_imatrix>(m1,ms); }
02384         INLINE l_imatrix operator *(const rmatrix_slice &ms, const l_imatrix &m1)
02385 #if(CXSC_INDEX_CHECK)
02386         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02387 #else
02388         throw()
02389 #endif
02390         { return _msmlimult<rmatrix_slice,l_imatrix,l_imatrix>(ms,m1); }
02391         INLINE l_imatrix operator *(const l_imatrix_slice &ms, const rmatrix &m1)
02392 #if(CXSC_INDEX_CHECK)
02393         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02394 #else
02395         throw()
02396 #endif
02397         { return _msmlimult<l_imatrix_slice,rmatrix,l_imatrix>(ms,m1); }
02398         INLINE l_imatrix operator *(const rmatrix_slice &ms1, const l_imatrix_slice &ms2)
02399 #if(CXSC_INDEX_CHECK)
02400         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02401 #else
02402         throw()
02403 #endif
02404         { return _msmslimult<rmatrix_slice,l_imatrix_slice,l_imatrix>(ms1,ms2); }
02405         INLINE l_imatrix operator *(const l_imatrix_slice &ms1, const rmatrix_slice &ms2)
02406 #if(CXSC_INDEX_CHECK)
02407         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02408 #else
02409         throw()
02410 #endif
02411         { return _msmslimult<l_imatrix_slice,rmatrix_slice,l_imatrix>(ms1,ms2); }
02412         INLINE l_imatrix &operator *=(l_imatrix &m1,const rmatrix &m2)
02413 #if(CXSC_INDEX_CHECK)
02414         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02415 #else
02416         throw()
02417 #endif
02418         { return _mmlimultassign<l_imatrix,rmatrix,l_interval>(m1,m2); }
02419         INLINE l_imatrix &operator *=(l_imatrix &m1,const rmatrix_slice &ms)
02420 #if(CXSC_INDEX_CHECK)
02421         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02422 #else
02423         throw()
02424 #endif
02425         { return _mmslimultassign<l_imatrix,rmatrix_slice,l_interval>(m1,ms); }
02426         INLINE l_imatrix operator |(const rmatrix &m1,const l_imatrix &m2)
02427 #if(CXSC_INDEX_CHECK)
02428         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02429 #else
02430         throw()
02431 #endif
02432         { return _mmconv<rmatrix,l_imatrix,l_imatrix>(m1,m2); }
02433         INLINE l_imatrix operator |(const l_imatrix &m1,const rmatrix &m2)
02434 #if(CXSC_INDEX_CHECK)
02435         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02436 #else
02437         throw()
02438 #endif
02439         { return _mmconv<rmatrix,l_imatrix,l_imatrix>(m2,m1); }
02440         INLINE l_imatrix operator |(const rmatrix &m,const l_imatrix_slice &ms)
02441 #if(CXSC_INDEX_CHECK)
02442         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02443 #else
02444         throw()
02445 #endif
02446         { return _mmsconv<rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
02447         INLINE l_imatrix operator |(const l_imatrix &m,const rmatrix_slice &ms)
02448 #if(CXSC_INDEX_CHECK)
02449         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02450 #else
02451         throw()
02452 #endif
02453         { return _mmsconv<l_imatrix,rmatrix_slice,l_imatrix>(m,ms); }
02454         INLINE l_imatrix operator |(const rmatrix_slice &ms,const l_imatrix &m)
02455 #if(CXSC_INDEX_CHECK)
02456         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02457 #else
02458         throw()
02459 #endif
02460         { return _mmsconv<l_imatrix,rmatrix_slice,l_imatrix>(m,ms); }
02461         INLINE l_imatrix operator |(const l_imatrix_slice &ms,const rmatrix &m)
02462 #if(CXSC_INDEX_CHECK)
02463         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02464 #else
02465         throw()
02466 #endif
02467         { return _mmsconv<rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
02468         INLINE l_imatrix operator |(const rmatrix_slice &m1,const l_imatrix_slice &m2)
02469 #if(CXSC_INDEX_CHECK)
02470         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02471 #else
02472         throw()
02473 #endif
02474         { return _msmsconv<rmatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
02475         INLINE l_imatrix operator |(const l_imatrix_slice &m1,const rmatrix_slice &m2)
02476 #if(CXSC_INDEX_CHECK)
02477         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02478 #else
02479         throw()
02480 #endif
02481         { return _msmsconv<rmatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
02482         INLINE l_imatrix &operator |=(l_imatrix &m1,const rmatrix &m2)
02483 #if(CXSC_INDEX_CHECK)
02484         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02485 #else
02486         throw()
02487 #endif
02488         { return _mmconvassign(m1,m2); }
02489         INLINE l_imatrix &operator |=(l_imatrix &m1,const rmatrix_slice &ms)
02490 #if(CXSC_INDEX_CHECK)
02491         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02492 #else
02493         throw()
02494 #endif
02495         { return _mmsconvassign(m1,ms); }
02496         INLINE l_imatrix_slice &l_imatrix_slice::operator |=(const rmatrix &m1)
02497 #if(CXSC_INDEX_CHECK)
02498         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02499 #else
02500         throw()
02501 #endif
02502         { return _msmconvassign(*this,m1); }
02503         INLINE l_imatrix_slice &l_imatrix_slice::operator |=(const rmatrix_slice &ms2)
02504 #if(CXSC_INDEX_CHECK)
02505         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02506 #else
02507         throw()
02508 #endif
02509         { return _msmsconvassign(*this,ms2); }
02510         INLINE l_imatrix operator &(const rmatrix &m1,const l_imatrix &m2)
02511 #if(CXSC_INDEX_CHECK)
02512         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02513 #else
02514         throw()
02515 #endif
02516         { return _mmsect<rmatrix,l_imatrix,l_imatrix>(m1,m2); }
02517         INLINE l_imatrix operator &(const l_imatrix &m1,const rmatrix &m2)
02518 #if(CXSC_INDEX_CHECK)
02519         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02520 #else
02521         throw()
02522 #endif
02523         { return _mmsect<rmatrix,l_imatrix,l_imatrix>(m2,m1); }
02524         INLINE l_imatrix operator &(const rmatrix &m,const l_imatrix_slice &ms)
02525 #if(CXSC_INDEX_CHECK)
02526         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02527 #else
02528         throw()
02529 #endif
02530         { return _mmssect<rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
02531         INLINE l_imatrix operator &(const l_imatrix &m,const rmatrix_slice &ms)
02532 #if(CXSC_INDEX_CHECK)
02533         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02534 #else
02535         throw()
02536 #endif
02537         { return _mmssect<l_imatrix,rmatrix_slice,l_imatrix>(m,ms); }
02538         INLINE l_imatrix operator &(const rmatrix_slice &ms,const l_imatrix &m)
02539 #if(CXSC_INDEX_CHECK)
02540         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02541 #else
02542         throw()
02543 #endif
02544         { return _mmssect<l_imatrix,rmatrix_slice,l_imatrix>(m,ms); }
02545         INLINE l_imatrix operator &(const l_imatrix_slice &ms,const rmatrix &m)
02546 #if(CXSC_INDEX_CHECK)
02547         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02548 #else
02549         throw()
02550 #endif
02551         { return _mmssect<rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
02552         INLINE l_imatrix operator &(const rmatrix_slice &m1,const l_imatrix_slice &m2)
02553 #if(CXSC_INDEX_CHECK)
02554         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02555 #else
02556         throw()
02557 #endif
02558         { return _msmssect<rmatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
02559         INLINE l_imatrix operator &(const l_imatrix_slice &m1,const rmatrix_slice &m2)
02560 #if(CXSC_INDEX_CHECK)
02561         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02562 #else
02563         throw()
02564 #endif
02565         { return _msmssect<rmatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
02566         INLINE l_imatrix &operator &=(l_imatrix &m1,const rmatrix &m2)
02567 #if(CXSC_INDEX_CHECK)
02568         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02569 #else
02570         throw()
02571 #endif
02572         { return _mmsectassign(m1,m2); }
02573         INLINE l_imatrix &operator &=(l_imatrix &m1,const rmatrix_slice &ms)
02574 #if(CXSC_INDEX_CHECK)
02575         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02576 #else
02577         throw()
02578 #endif
02579         { return _mmssectassign(m1,ms); }
02580         INLINE l_imatrix_slice &l_imatrix_slice::operator &=(const rmatrix &m1)
02581 #if(CXSC_INDEX_CHECK)
02582         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02583 #else
02584         throw()
02585 #endif
02586         { return _msmsectassign(*this,m1); }
02587         INLINE l_imatrix_slice &l_imatrix_slice::operator &=(const rmatrix_slice &ms2)
02588 #if(CXSC_INDEX_CHECK)
02589         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02590 #else
02591         throw()
02592 #endif
02593         { return _msmssectassign(*this,ms2); }
02594 
02595         INLINE l_imatrix operator +(const l_rmatrix &m1,const l_imatrix &m2)
02596 #if(CXSC_INDEX_CHECK)
02597         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02598 #else
02599         throw()
02600 #endif
02601         { return _mmplus<l_rmatrix,l_imatrix,l_imatrix>(m1,m2); }
02602         INLINE l_imatrix operator +(const l_imatrix &m1,const l_rmatrix &m2)
02603 #if(CXSC_INDEX_CHECK)
02604         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02605 #else
02606         throw()
02607 #endif
02608         { return _mmplus<l_rmatrix,l_imatrix,l_imatrix>(m2,m1); }
02609         INLINE l_imatrix operator +(const l_rmatrix &m,const l_imatrix_slice &ms)
02610 #if(CXSC_INDEX_CHECK)
02611         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02612 #else
02613         throw()
02614 #endif
02615         { return _mmsplus<l_rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
02616         INLINE l_imatrix operator +(const l_imatrix &m,const l_rmatrix_slice &ms)
02617 #if(CXSC_INDEX_CHECK)
02618         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02619 #else
02620         throw()
02621 #endif
02622         { return _mmsplus<l_imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
02623         INLINE l_imatrix operator +(const l_rmatrix_slice &ms,const l_imatrix &m)
02624 #if(CXSC_INDEX_CHECK)
02625         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02626 #else
02627         throw()
02628 #endif
02629         { return _mmsplus<l_imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
02630         INLINE l_imatrix operator +(const l_imatrix_slice &ms,const l_rmatrix &m)
02631 #if(CXSC_INDEX_CHECK)
02632         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02633 #else
02634         throw()
02635 #endif
02636         { return _mmsplus<l_rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
02637         INLINE l_imatrix operator +(const l_rmatrix_slice &m1,const l_imatrix_slice &m2)
02638 #if(CXSC_INDEX_CHECK)
02639         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02640 #else
02641         throw()
02642 #endif
02643         { return _msmsplus<l_rmatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
02644         INLINE l_imatrix operator +(const l_imatrix_slice &m1,const l_rmatrix_slice &m2)
02645 #if(CXSC_INDEX_CHECK)
02646         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02647 #else
02648         throw()
02649 #endif
02650         { return _msmsplus<l_rmatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
02651         INLINE l_imatrix &operator +=(l_imatrix &m1,const l_rmatrix &m2)
02652 #if(CXSC_INDEX_CHECK)
02653         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02654 #else
02655         throw()
02656 #endif
02657         { return _mmplusassign(m1,m2); }
02658         INLINE l_imatrix &operator +=(l_imatrix &m1,const l_rmatrix_slice &ms)
02659 #if(CXSC_INDEX_CHECK)
02660         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02661 #else
02662         throw()
02663 #endif
02664         { return _mmsplusassign(m1,ms); }
02665         INLINE l_imatrix_slice &l_imatrix_slice::operator +=(const l_rmatrix &m1)
02666 #if(CXSC_INDEX_CHECK)
02667         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02668 #else
02669         throw()
02670 #endif
02671         { return _msmplusassign(*this,m1); }
02672         INLINE l_imatrix_slice &l_imatrix_slice::operator +=(const l_rmatrix_slice &ms2)
02673 #if(CXSC_INDEX_CHECK)
02674         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02675 #else
02676         throw()
02677 #endif
02678         { return _msmsplusassign(*this,ms2); }
02679         INLINE l_imatrix operator -(const l_rmatrix &m1,const l_imatrix &m2)
02680 #if(CXSC_INDEX_CHECK)
02681         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02682 #else
02683         throw()
02684 #endif
02685         { return _mmminus<l_rmatrix,l_imatrix,l_imatrix>(m1,m2); }
02686         INLINE l_imatrix operator -(const l_imatrix &m1,const l_rmatrix &m2)
02687 #if(CXSC_INDEX_CHECK)
02688         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02689 #else
02690         throw()
02691 #endif
02692         { return _mmminus<l_imatrix,l_rmatrix,l_imatrix>(m1,m2); }
02693         INLINE l_imatrix operator -(const l_rmatrix &m,const l_imatrix_slice &ms)
02694 #if(CXSC_INDEX_CHECK)
02695         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02696 #else
02697         throw()
02698 #endif
02699         { return _mmsminus<l_rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
02700         INLINE l_imatrix operator -(const l_imatrix &m,const l_rmatrix_slice &ms)
02701 #if(CXSC_INDEX_CHECK)
02702         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02703 #else
02704         throw()
02705 #endif
02706         { return _mmsminus<l_imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
02707         INLINE l_imatrix operator -(const l_rmatrix_slice &ms,const l_imatrix &m)
02708 #if(CXSC_INDEX_CHECK)
02709         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02710 #else
02711         throw()
02712 #endif
02713         { return _msmminus<l_rmatrix_slice,l_imatrix,l_imatrix>(ms,m); }
02714         INLINE l_imatrix operator -(const l_imatrix_slice &ms,const l_rmatrix &m)
02715 #if(CXSC_INDEX_CHECK)
02716         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02717 #else
02718         throw()
02719 #endif
02720         { return _msmminus<l_imatrix_slice,l_rmatrix,l_imatrix>(ms,m); }
02721         INLINE l_imatrix operator -(const l_rmatrix_slice &ms1,const l_imatrix_slice &ms2)
02722 #if(CXSC_INDEX_CHECK)
02723         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02724 #else
02725         throw()
02726 #endif
02727         { return _msmsminus<l_rmatrix_slice,l_imatrix_slice,l_imatrix>(ms1,ms2); }
02728         INLINE l_imatrix operator -(const l_imatrix_slice &ms1,const l_rmatrix_slice &ms2)
02729 #if(CXSC_INDEX_CHECK)
02730         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02731 #else
02732         throw()
02733 #endif
02734         { return _msmsminus<l_imatrix_slice,l_rmatrix_slice,l_imatrix>(ms1,ms2); }
02735         INLINE l_imatrix &operator -=(l_imatrix &m1,const l_rmatrix &m2)
02736 #if(CXSC_INDEX_CHECK)
02737         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02738 #else
02739         throw()
02740 #endif
02741         { return _mmminusassign(m1,m2); }
02742         INLINE l_imatrix &operator -=(l_imatrix &m1,const l_rmatrix_slice &ms)
02743 #if(CXSC_INDEX_CHECK)
02744         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02745 #else
02746         throw()
02747 #endif
02748         { return _mmsminusassign(m1,ms); }
02749         INLINE l_imatrix_slice &l_imatrix_slice::operator -=(const l_rmatrix &m1)
02750 #if(CXSC_INDEX_CHECK)
02751         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02752 #else
02753         throw()
02754 #endif
02755         { return _msmminusassign(*this,m1); }
02756         INLINE l_imatrix_slice &l_imatrix_slice::operator -=(const l_rmatrix_slice &ms2)
02757 #if(CXSC_INDEX_CHECK)
02758         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02759 #else
02760         throw()
02761 #endif
02762         { return _msmsminusassign(*this,ms2); }
02763         INLINE l_imatrix operator *(const l_rmatrix &m1, const l_imatrix &m2)
02764 #if(CXSC_INDEX_CHECK)
02765         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02766 #else
02767         throw()
02768 #endif
02769         { return _mmlimult<l_rmatrix,l_imatrix,l_imatrix>(m1,m2); }
02770         INLINE l_imatrix operator *(const l_imatrix &m1, const l_rmatrix &m2)
02771 #if(CXSC_INDEX_CHECK)
02772         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02773 #else
02774         throw()
02775 #endif
02776         { return _mmlimult<l_imatrix,l_rmatrix,l_imatrix>(m1,m2); }
02777         INLINE l_imatrix operator *(const l_rmatrix &m1, const l_imatrix_slice &ms)
02778 #if(CXSC_INDEX_CHECK)
02779         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02780 #else
02781         throw()
02782 #endif
02783         { return _mmslimult<l_rmatrix,l_imatrix_slice,l_imatrix>(m1,ms); }
02784         INLINE l_imatrix operator *(const l_imatrix &m1, const l_rmatrix_slice &ms)
02785 #if(CXSC_INDEX_CHECK)
02786         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02787 #else
02788         throw()
02789 #endif
02790         { return _mmslimult<l_imatrix,l_rmatrix_slice,l_imatrix>(m1,ms); }
02791         INLINE l_imatrix operator *(const l_rmatrix_slice &ms, const l_imatrix &m1)
02792 #if(CXSC_INDEX_CHECK)
02793         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02794 #else
02795         throw()
02796 #endif
02797         { return _msmlimult<l_rmatrix_slice,l_imatrix,l_imatrix>(ms,m1); }
02798         INLINE l_imatrix operator *(const l_imatrix_slice &ms, const l_rmatrix &m1)
02799 #if(CXSC_INDEX_CHECK)
02800         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02801 #else
02802         throw()
02803 #endif
02804         { return _msmlimult<l_imatrix_slice,l_rmatrix,l_imatrix>(ms,m1); }
02805         INLINE l_imatrix operator *(const l_rmatrix_slice &ms1, const l_imatrix_slice &ms2)
02806 #if(CXSC_INDEX_CHECK)
02807         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02808 #else
02809         throw()
02810 #endif
02811         { return _msmslimult<l_rmatrix_slice,l_imatrix_slice,l_imatrix>(ms1,ms2); }
02812         INLINE l_imatrix operator *(const l_imatrix_slice &ms1, const l_rmatrix_slice &ms2)
02813 #if(CXSC_INDEX_CHECK)
02814         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02815 #else
02816         throw()
02817 #endif
02818         { return _msmslimult<l_imatrix_slice,l_rmatrix_slice,l_imatrix>(ms1,ms2); }
02819         INLINE l_imatrix &operator *=(l_imatrix &m1,const l_rmatrix &m2)
02820 #if(CXSC_INDEX_CHECK)
02821         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02822 #else
02823         throw()
02824 #endif
02825         { return _mmlimultassign<l_imatrix,l_rmatrix,l_interval>(m1,m2); }
02826         INLINE l_imatrix &operator *=(l_imatrix &m1,const l_rmatrix_slice &ms)
02827 #if(CXSC_INDEX_CHECK)
02828         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02829 #else
02830         throw()
02831 #endif
02832         { return _mmslimultassign<l_imatrix,l_rmatrix_slice,l_interval>(m1,ms); }
02833         INLINE l_imatrix operator |(const l_rmatrix &m1,const l_imatrix &m2)
02834 #if(CXSC_INDEX_CHECK)
02835         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02836 #else
02837         throw()
02838 #endif
02839         { return _mmconv<l_rmatrix,l_imatrix,l_imatrix>(m1,m2); }
02840         INLINE l_imatrix operator |(const l_imatrix &m1,const l_rmatrix &m2)
02841 #if(CXSC_INDEX_CHECK)
02842         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02843 #else
02844         throw()
02845 #endif
02846         { return _mmconv<l_rmatrix,l_imatrix,l_imatrix>(m2,m1); }
02847         INLINE l_imatrix operator |(const l_rmatrix &m,const l_imatrix_slice &ms)
02848 #if(CXSC_INDEX_CHECK)
02849         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02850 #else
02851         throw()
02852 #endif
02853         { return _mmsconv<l_rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
02854         INLINE l_imatrix operator |(const l_imatrix &m,const l_rmatrix_slice &ms)
02855 #if(CXSC_INDEX_CHECK)
02856         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02857 #else
02858         throw()
02859 #endif
02860         { return _mmsconv<l_imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
02861         INLINE l_imatrix operator |(const l_rmatrix_slice &ms,const l_imatrix &m)
02862 #if(CXSC_INDEX_CHECK)
02863         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02864 #else
02865         throw()
02866 #endif
02867         { return _mmsconv<l_imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
02868         INLINE l_imatrix operator |(const l_imatrix_slice &ms,const l_rmatrix &m)
02869 #if(CXSC_INDEX_CHECK)
02870         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02871 #else
02872         throw()
02873 #endif
02874         { return _mmsconv<l_rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
02875         INLINE l_imatrix operator |(const l_rmatrix_slice &m1,const l_imatrix_slice &m2)
02876 #if(CXSC_INDEX_CHECK)
02877         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02878 #else
02879         throw()
02880 #endif
02881         { return _msmsconv<l_rmatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
02882         INLINE l_imatrix operator |(const l_imatrix_slice &m1,const l_rmatrix_slice &m2)
02883 #if(CXSC_INDEX_CHECK)
02884         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02885 #else
02886         throw()
02887 #endif
02888         { return _msmsconv<l_rmatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
02889         INLINE l_imatrix &operator |=(l_imatrix &m1,const l_rmatrix &m2)
02890 #if(CXSC_INDEX_CHECK)
02891         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02892 #else
02893         throw()
02894 #endif
02895         { return _mmconvassign(m1,m2); }
02896         INLINE l_imatrix &operator |=(l_imatrix &m1,const l_rmatrix_slice &ms)
02897 #if(CXSC_INDEX_CHECK)
02898         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02899 #else
02900         throw()
02901 #endif
02902         { return _mmsconvassign(m1,ms); }
02903         INLINE l_imatrix_slice &l_imatrix_slice::operator |=(const l_rmatrix &m1)
02904 #if(CXSC_INDEX_CHECK)
02905         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02906 #else
02907         throw()
02908 #endif
02909         { return _msmconvassign(*this,m1); }
02910         INLINE l_imatrix_slice &l_imatrix_slice::operator |=(const l_rmatrix_slice &ms2)
02911 #if(CXSC_INDEX_CHECK)
02912         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02913 #else
02914         throw()
02915 #endif
02916         { return _msmsconvassign(*this,ms2); }
02917         INLINE l_imatrix operator &(const l_rmatrix &m1,const l_imatrix &m2)
02918 #if(CXSC_INDEX_CHECK)
02919         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02920 #else
02921         throw()
02922 #endif
02923         { return _mmsect<l_rmatrix,l_imatrix,l_imatrix>(m1,m2); }
02924         INLINE l_imatrix operator &(const l_imatrix &m1,const l_rmatrix &m2)
02925 #if(CXSC_INDEX_CHECK)
02926         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02927 #else
02928         throw()
02929 #endif
02930         { return _mmsect<l_rmatrix,l_imatrix,l_imatrix>(m2,m1); }
02931         INLINE l_imatrix operator &(const l_rmatrix &m,const l_imatrix_slice &ms)
02932 #if(CXSC_INDEX_CHECK)
02933         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02934 #else
02935         throw()
02936 #endif
02937         { return _mmssect<l_rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
02938         INLINE l_imatrix operator &(const l_imatrix &m,const l_rmatrix_slice &ms)
02939 #if(CXSC_INDEX_CHECK)
02940         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02941 #else
02942         throw()
02943 #endif
02944         { return _mmssect<l_imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
02945         INLINE l_imatrix operator &(const l_rmatrix_slice &ms,const l_imatrix &m)
02946 #if(CXSC_INDEX_CHECK)
02947         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02948 #else
02949         throw()
02950 #endif
02951         { return _mmssect<l_imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
02952         INLINE l_imatrix operator &(const l_imatrix_slice &ms,const l_rmatrix &m)
02953 #if(CXSC_INDEX_CHECK)
02954         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02955 #else
02956         throw()
02957 #endif
02958         { return _mmssect<l_rmatrix,l_imatrix_slice,l_imatrix>(m,ms); }
02959         INLINE l_imatrix operator &(const l_rmatrix_slice &m1,const l_imatrix_slice &m2)
02960 #if(CXSC_INDEX_CHECK)
02961         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02962 #else
02963         throw()
02964 #endif
02965         { return _msmssect<l_rmatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
02966         INLINE l_imatrix operator &(const l_imatrix_slice &m1,const l_rmatrix_slice &m2)
02967 #if(CXSC_INDEX_CHECK)
02968         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02969 #else
02970         throw()
02971 #endif
02972         { return _msmssect<l_rmatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
02973         INLINE l_imatrix &operator &=(l_imatrix &m1,const l_rmatrix &m2)
02974 #if(CXSC_INDEX_CHECK)
02975         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02976 #else
02977         throw()
02978 #endif
02979         { return _mmsectassign(m1,m2); }
02980         INLINE l_imatrix &operator &=(l_imatrix &m1,const l_rmatrix_slice &ms)
02981 #if(CXSC_INDEX_CHECK)
02982         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02983 #else
02984         throw()
02985 #endif
02986         { return _mmssectassign(m1,ms); }
02987         INLINE l_imatrix_slice &l_imatrix_slice::operator &=(const l_rmatrix &m1)
02988 #if(CXSC_INDEX_CHECK)
02989         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02990 #else
02991         throw()
02992 #endif
02993         { return _msmsectassign(*this,m1); }
02994         INLINE l_imatrix_slice &l_imatrix_slice::operator &=(const l_rmatrix_slice &ms2)
02995 #if(CXSC_INDEX_CHECK)
02996         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
02997 #else
02998         throw()
02999 #endif
03000         { return _msmssectassign(*this,ms2); }
03001 
03002         INLINE l_imatrix operator +(const imatrix &m1,const l_imatrix &m2)
03003 #if(CXSC_INDEX_CHECK)
03004         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03005 #else
03006         throw()
03007 #endif
03008         { return _mmplus<imatrix,l_imatrix,l_imatrix>(m1,m2); }
03009         INLINE l_imatrix operator +(const l_imatrix &m1,const imatrix &m2)
03010 #if(CXSC_INDEX_CHECK)
03011         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03012 #else
03013         throw()
03014 #endif
03015         { return _mmplus<imatrix,l_imatrix,l_imatrix>(m2,m1); }
03016         INLINE l_imatrix operator +(const imatrix &m,const l_imatrix_slice &ms)
03017 #if(CXSC_INDEX_CHECK)
03018         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03019 #else
03020         throw()
03021 #endif
03022         { return _mmsplus<imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
03023         INLINE l_imatrix operator +(const l_imatrix &m,const imatrix_slice &ms)
03024 #if(CXSC_INDEX_CHECK)
03025         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03026 #else
03027         throw()
03028 #endif
03029         { return _mmsplus<l_imatrix,imatrix_slice,l_imatrix>(m,ms); }
03030         INLINE l_imatrix operator +(const imatrix_slice &ms,const l_imatrix &m)
03031 #if(CXSC_INDEX_CHECK)
03032         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03033 #else
03034         throw()
03035 #endif
03036         { return _mmsplus<l_imatrix,imatrix_slice,l_imatrix>(m,ms); }
03037         INLINE l_imatrix operator +(const l_imatrix_slice &ms,const imatrix &m)
03038 #if(CXSC_INDEX_CHECK)
03039         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03040 #else
03041         throw()
03042 #endif
03043         { return _mmsplus<imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
03044         INLINE l_imatrix operator +(const imatrix_slice &m1,const l_imatrix_slice &m2)
03045 #if(CXSC_INDEX_CHECK)
03046         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03047 #else
03048         throw()
03049 #endif
03050         { return _msmsplus<imatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
03051         INLINE l_imatrix operator +(const l_imatrix_slice &m1,const imatrix_slice &m2)
03052 #if(CXSC_INDEX_CHECK)
03053         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03054 #else
03055         throw()
03056 #endif
03057         { return _msmsplus<imatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
03058         INLINE l_imatrix &operator +=(l_imatrix &m1,const imatrix &m2)
03059 #if(CXSC_INDEX_CHECK)
03060         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03061 #else
03062         throw()
03063 #endif
03064         { return _mmplusassign(m1,m2); }
03065         INLINE l_imatrix &operator +=(l_imatrix &m1,const imatrix_slice &ms)
03066 #if(CXSC_INDEX_CHECK)
03067         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03068 #else
03069         throw()
03070 #endif
03071         { return _mmsplusassign(m1,ms); }
03072         INLINE l_imatrix_slice &l_imatrix_slice::operator +=(const imatrix &m1)
03073 #if(CXSC_INDEX_CHECK)
03074         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03075 #else
03076         throw()
03077 #endif
03078         { return _msmplusassign(*this,m1); }
03079         INLINE l_imatrix_slice &l_imatrix_slice::operator +=(const imatrix_slice &ms2)
03080 #if(CXSC_INDEX_CHECK)
03081         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03082 #else
03083         throw()
03084 #endif
03085         { return _msmsplusassign(*this,ms2); }
03086         INLINE l_imatrix operator -(const imatrix &m1,const l_imatrix &m2)
03087 #if(CXSC_INDEX_CHECK)
03088         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03089 #else
03090         throw()
03091 #endif
03092         { return _mmminus<imatrix,l_imatrix,l_imatrix>(m1,m2); }
03093         INLINE l_imatrix operator -(const l_imatrix &m1,const imatrix &m2)
03094 #if(CXSC_INDEX_CHECK)
03095         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03096 #else
03097         throw()
03098 #endif
03099         { return _mmminus<l_imatrix,imatrix,l_imatrix>(m1,m2); }
03100         INLINE l_imatrix operator -(const imatrix &m,const l_imatrix_slice &ms)
03101 #if(CXSC_INDEX_CHECK)
03102         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03103 #else
03104         throw()
03105 #endif
03106         { return _mmsminus<imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
03107         INLINE l_imatrix operator -(const l_imatrix &m,const imatrix_slice &ms)
03108 #if(CXSC_INDEX_CHECK)
03109         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03110 #else
03111         throw()
03112 #endif
03113         { return _mmsminus<l_imatrix,imatrix_slice,l_imatrix>(m,ms); }
03114         INLINE l_imatrix operator -(const imatrix_slice &ms,const l_imatrix &m)
03115 #if(CXSC_INDEX_CHECK)
03116         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03117 #else
03118         throw()
03119 #endif
03120         { return _msmminus<imatrix_slice,l_imatrix,l_imatrix>(ms,m); }
03121         INLINE l_imatrix operator -(const l_imatrix_slice &ms,const imatrix &m)
03122 #if(CXSC_INDEX_CHECK)
03123         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03124 #else
03125         throw()
03126 #endif
03127         { return _msmminus<l_imatrix_slice,imatrix,l_imatrix>(ms,m); }
03128         INLINE l_imatrix operator -(const imatrix_slice &ms1,const l_imatrix_slice &ms2)
03129 #if(CXSC_INDEX_CHECK)
03130         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03131 #else
03132         throw()
03133 #endif
03134         { return _msmsminus<imatrix_slice,l_imatrix_slice,l_imatrix>(ms1,ms2); }
03135         INLINE l_imatrix operator -(const l_imatrix_slice &ms1,const imatrix_slice &ms2)
03136 #if(CXSC_INDEX_CHECK)
03137         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03138 #else
03139         throw()
03140 #endif
03141         { return _msmsminus<l_imatrix_slice,imatrix_slice,l_imatrix>(ms1,ms2); }
03142         INLINE l_imatrix &operator -=(l_imatrix &m1,const imatrix &m2)
03143 #if(CXSC_INDEX_CHECK)
03144         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03145 #else
03146         throw()
03147 #endif
03148         { return _mmminusassign(m1,m2); }
03149         INLINE l_imatrix &operator -=(l_imatrix &m1,const imatrix_slice &ms)
03150 #if(CXSC_INDEX_CHECK)
03151         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03152 #else
03153         throw()
03154 #endif
03155         { return _mmsminusassign(m1,ms); }
03156         INLINE l_imatrix_slice &l_imatrix_slice::operator -=(const imatrix &m1)
03157 #if(CXSC_INDEX_CHECK)
03158         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03159 #else
03160         throw()
03161 #endif
03162         { return _msmminusassign(*this,m1); }
03163         INLINE l_imatrix_slice &l_imatrix_slice::operator -=(const imatrix_slice &ms2)
03164 #if(CXSC_INDEX_CHECK)
03165         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03166 #else
03167         throw()
03168 #endif
03169         { return _msmsminusassign(*this,ms2); }
03170         INLINE l_imatrix operator *(const imatrix &m1, const l_imatrix &m2)
03171 #if(CXSC_INDEX_CHECK)
03172         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03173 #else
03174         throw()
03175 #endif
03176         { return _mmlimult<imatrix,l_imatrix,l_imatrix>(m1,m2); }
03177         INLINE l_imatrix operator *(const l_imatrix &m1, const imatrix &m2)
03178 #if(CXSC_INDEX_CHECK)
03179         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03180 #else
03181         throw()
03182 #endif
03183         { return _mmlimult<l_imatrix,imatrix,l_imatrix>(m1,m2); }
03184         INLINE l_imatrix operator *(const imatrix &m1, const l_imatrix_slice &ms)
03185 #if(CXSC_INDEX_CHECK)
03186         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03187 #else
03188         throw()
03189 #endif
03190         { return _mmslimult<imatrix,l_imatrix_slice,l_imatrix>(m1,ms); }
03191         INLINE l_imatrix operator *(const l_imatrix &m1, const imatrix_slice &ms)
03192 #if(CXSC_INDEX_CHECK)
03193         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03194 #else
03195         throw()
03196 #endif
03197         { return _mmslimult<l_imatrix,imatrix_slice,l_imatrix>(m1,ms); }
03198         INLINE l_imatrix operator *(const imatrix_slice &ms, const l_imatrix &m1)
03199 #if(CXSC_INDEX_CHECK)
03200         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03201 #else
03202         throw()
03203 #endif
03204         { return _msmlimult<imatrix_slice,l_imatrix,l_imatrix>(ms,m1); }
03205         INLINE l_imatrix operator *(const l_imatrix_slice &ms, const imatrix &m1)
03206 #if(CXSC_INDEX_CHECK)
03207         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03208 #else
03209         throw()
03210 #endif
03211         { return _msmlimult<l_imatrix_slice,imatrix,l_imatrix>(ms,m1); }
03212         INLINE l_imatrix operator *(const imatrix_slice &ms1, const l_imatrix_slice &ms2)
03213 #if(CXSC_INDEX_CHECK)
03214         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03215 #else
03216         throw()
03217 #endif
03218         { return _msmslimult<imatrix_slice,l_imatrix_slice,l_imatrix>(ms1,ms2); }
03219         INLINE l_imatrix operator *(const l_imatrix_slice &ms1, const imatrix_slice &ms2)
03220 #if(CXSC_INDEX_CHECK)
03221         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03222 #else
03223         throw()
03224 #endif
03225         { return _msmslimult<l_imatrix_slice,imatrix_slice,l_imatrix>(ms1,ms2); }
03226         INLINE l_imatrix &operator *=(l_imatrix &m1,const imatrix &m2)
03227 #if(CXSC_INDEX_CHECK)
03228         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03229 #else
03230         throw()
03231 #endif
03232         { return _mmlimultassign<l_imatrix,imatrix,l_interval>(m1,m2); }
03233         INLINE l_imatrix &operator *=(l_imatrix &m1,const imatrix_slice &ms)
03234 #if(CXSC_INDEX_CHECK)
03235         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03236 #else
03237         throw()
03238 #endif
03239         { return _mmslimultassign<l_imatrix,imatrix_slice,l_interval>(m1,ms); }
03240         INLINE l_imatrix operator |(const imatrix &m1,const l_imatrix &m2)
03241 #if(CXSC_INDEX_CHECK)
03242         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03243 #else
03244         throw()
03245 #endif
03246         { return _mmconv<imatrix,l_imatrix,l_imatrix>(m1,m2); }
03247         INLINE l_imatrix operator |(const l_imatrix &m1,const imatrix &m2)
03248 #if(CXSC_INDEX_CHECK)
03249         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03250 #else
03251         throw()
03252 #endif
03253         { return _mmconv<imatrix,l_imatrix,l_imatrix>(m2,m1); }
03254         INLINE l_imatrix operator |(const imatrix &m,const l_imatrix_slice &ms)
03255 #if(CXSC_INDEX_CHECK)
03256         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03257 #else
03258         throw()
03259 #endif
03260         { return _mmsconv<imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
03261         INLINE l_imatrix operator |(const l_imatrix &m,const imatrix_slice &ms)
03262 #if(CXSC_INDEX_CHECK)
03263         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03264 #else
03265         throw()
03266 #endif
03267         { return _mmsconv<l_imatrix,imatrix_slice,l_imatrix>(m,ms); }
03268         INLINE l_imatrix operator |(const imatrix_slice &ms,const l_imatrix &m)
03269 #if(CXSC_INDEX_CHECK)
03270         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03271 #else
03272         throw()
03273 #endif
03274         { return _mmsconv<l_imatrix,imatrix_slice,l_imatrix>(m,ms); }
03275         INLINE l_imatrix operator |(const l_imatrix_slice &ms,const imatrix &m)
03276 #if(CXSC_INDEX_CHECK)
03277         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03278 #else
03279         throw()
03280 #endif
03281         { return _mmsconv<imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
03282         INLINE l_imatrix operator |(const imatrix_slice &m1,const l_imatrix_slice &m2)
03283 #if(CXSC_INDEX_CHECK)
03284         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03285 #else
03286         throw()
03287 #endif
03288         { return _msmsconv<imatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
03289         INLINE l_imatrix operator |(const l_imatrix_slice &m1,const imatrix_slice &m2)
03290 #if(CXSC_INDEX_CHECK)
03291         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03292 #else
03293         throw()
03294 #endif
03295         { return _msmsconv<imatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
03296         INLINE l_imatrix &operator |=(l_imatrix &m1,const imatrix &m2)
03297 #if(CXSC_INDEX_CHECK)
03298         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03299 #else
03300         throw()
03301 #endif
03302         { return _mmconvassign(m1,m2); }
03303         INLINE l_imatrix &operator |=(l_imatrix &m1,const imatrix_slice &ms)
03304 #if(CXSC_INDEX_CHECK)
03305         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03306 #else
03307         throw()
03308 #endif
03309         { return _mmsconvassign(m1,ms); }
03310         INLINE l_imatrix_slice &l_imatrix_slice::operator |=(const imatrix &m1)
03311 #if(CXSC_INDEX_CHECK)
03312         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03313 #else
03314         throw()
03315 #endif
03316         { return _msmconvassign(*this,m1); }
03317         INLINE l_imatrix_slice &l_imatrix_slice::operator |=(const imatrix_slice &ms2)
03318 #if(CXSC_INDEX_CHECK)
03319         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03320 #else
03321         throw()
03322 #endif
03323         { return _msmsconvassign(*this,ms2); }
03324         INLINE l_imatrix operator &(const imatrix &m1,const l_imatrix &m2)
03325 #if(CXSC_INDEX_CHECK)
03326         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03327 #else
03328         throw()
03329 #endif
03330         { return _mmsect<imatrix,l_imatrix,l_imatrix>(m1,m2); }
03331         INLINE l_imatrix operator &(const l_imatrix &m1,const imatrix &m2)
03332 #if(CXSC_INDEX_CHECK)
03333         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03334 #else
03335         throw()
03336 #endif
03337         { return _mmsect<imatrix,l_imatrix,l_imatrix>(m2,m1); }
03338         INLINE l_imatrix operator &(const imatrix &m,const l_imatrix_slice &ms)
03339 #if(CXSC_INDEX_CHECK)
03340         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03341 #else
03342         throw()
03343 #endif
03344         { return _mmssect<imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
03345         INLINE l_imatrix operator &(const l_imatrix &m,const imatrix_slice &ms)
03346 #if(CXSC_INDEX_CHECK)
03347         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03348 #else
03349         throw()
03350 #endif
03351         { return _mmssect<l_imatrix,imatrix_slice,l_imatrix>(m,ms); }
03352         INLINE l_imatrix operator &(const imatrix_slice &ms,const l_imatrix &m)
03353 #if(CXSC_INDEX_CHECK)
03354         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03355 #else
03356         throw()
03357 #endif
03358         { return _mmssect<l_imatrix,imatrix_slice,l_imatrix>(m,ms); }
03359         INLINE l_imatrix operator &(const l_imatrix_slice &ms,const imatrix &m)
03360 #if(CXSC_INDEX_CHECK)
03361         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03362 #else
03363         throw()
03364 #endif
03365         { return _mmssect<imatrix,l_imatrix_slice,l_imatrix>(m,ms); }
03366         INLINE l_imatrix operator &(const imatrix_slice &m1,const l_imatrix_slice &m2)
03367 #if(CXSC_INDEX_CHECK)
03368         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03369 #else
03370         throw()
03371 #endif
03372         { return _msmssect<imatrix_slice,l_imatrix_slice,l_imatrix>(m1,m2); }
03373         INLINE l_imatrix operator &(const l_imatrix_slice &m1,const imatrix_slice &m2)
03374 #if(CXSC_INDEX_CHECK)
03375         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03376 #else
03377         throw()
03378 #endif
03379         { return _msmssect<imatrix_slice,l_imatrix_slice,l_imatrix>(m2,m1); }
03380         INLINE l_imatrix &operator &=(l_imatrix &m1,const imatrix &m2)
03381 #if(CXSC_INDEX_CHECK)
03382         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03383 #else
03384         throw()
03385 #endif
03386         { return _mmsectassign(m1,m2); }
03387         INLINE l_imatrix &operator &=(l_imatrix &m1,const imatrix_slice &ms)
03388 #if(CXSC_INDEX_CHECK)
03389         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03390 #else
03391         throw()
03392 #endif
03393         { return _mmssectassign(m1,ms); }
03394         INLINE l_imatrix_slice &l_imatrix_slice::operator &=(const imatrix &m1)
03395 #if(CXSC_INDEX_CHECK)
03396         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03397 #else
03398         throw()
03399 #endif
03400         { return _msmsectassign(*this,m1); }
03401         INLINE l_imatrix_slice &l_imatrix_slice::operator &=(const imatrix_slice &ms2)
03402 #if(CXSC_INDEX_CHECK)
03403         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03404 #else
03405         throw()
03406 #endif
03407         { return _msmssectassign(*this,ms2); }
03408 
03409         INLINE l_imatrix operator +(const l_rmatrix &m1,const imatrix &m2)
03410 #if(CXSC_INDEX_CHECK)
03411         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03412 #else
03413         throw()
03414 #endif
03415         { return _mmplus<l_rmatrix,imatrix,l_imatrix>(m1,m2); }
03416         INLINE l_imatrix operator +(const imatrix &m1,const l_rmatrix &m2)
03417 #if(CXSC_INDEX_CHECK)
03418         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03419 #else
03420         throw()
03421 #endif
03422         { return _mmplus<l_rmatrix,imatrix,l_imatrix>(m2,m1); }
03423         INLINE l_imatrix operator +(const l_rmatrix &m,const imatrix_slice &ms)
03424 #if(CXSC_INDEX_CHECK)
03425         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03426 #else
03427         throw()
03428 #endif
03429         { return _mmsplus<l_rmatrix,imatrix_slice,l_imatrix>(m,ms); }
03430         INLINE l_imatrix operator +(const imatrix &m,const l_rmatrix_slice &ms)
03431 #if(CXSC_INDEX_CHECK)
03432         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03433 #else
03434         throw()
03435 #endif
03436         { return _mmsplus<imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
03437         INLINE l_imatrix operator +(const l_rmatrix_slice &ms,const imatrix &m)
03438 #if(CXSC_INDEX_CHECK)
03439         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03440 #else
03441         throw()
03442 #endif
03443         { return _mmsplus<imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
03444         INLINE l_imatrix operator +(const imatrix_slice &ms,const l_rmatrix &m)
03445 #if(CXSC_INDEX_CHECK)
03446         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03447 #else
03448         throw()
03449 #endif
03450         { return _mmsplus<l_rmatrix,imatrix_slice,l_imatrix>(m,ms); }
03451         INLINE l_imatrix operator +(const l_rmatrix_slice &m1,const imatrix_slice &m2)
03452 #if(CXSC_INDEX_CHECK)
03453         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03454 #else
03455         throw()
03456 #endif
03457         { return _msmsplus<l_rmatrix_slice,imatrix_slice,l_imatrix>(m1,m2); }
03458         INLINE l_imatrix operator +(const imatrix_slice &m1,const l_rmatrix_slice &m2)
03459 #if(CXSC_INDEX_CHECK)
03460         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03461 #else
03462         throw()
03463 #endif
03464         { return _msmsplus<l_rmatrix_slice,imatrix_slice,l_imatrix>(m2,m1); }
03465         INLINE l_imatrix operator -(const l_rmatrix &m1,const imatrix &m2)
03466 #if(CXSC_INDEX_CHECK)
03467         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03468 #else
03469         throw()
03470 #endif
03471         { return _mmminus<l_rmatrix,imatrix,l_imatrix>(m1,m2); }
03472         INLINE l_imatrix operator -(const imatrix &m1,const l_rmatrix &m2)
03473 #if(CXSC_INDEX_CHECK)
03474         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03475 #else
03476         throw()
03477 #endif
03478         { return _mmminus<imatrix,l_rmatrix,l_imatrix>(m1,m2); }
03479         INLINE l_imatrix operator -(const l_rmatrix &m,const imatrix_slice &ms)
03480 #if(CXSC_INDEX_CHECK)
03481         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03482 #else
03483         throw()
03484 #endif
03485         { return _mmsminus<l_rmatrix,imatrix_slice,l_imatrix>(m,ms); }
03486         INLINE l_imatrix operator -(const imatrix &m,const l_rmatrix_slice &ms)
03487 #if(CXSC_INDEX_CHECK)
03488         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03489 #else
03490         throw()
03491 #endif
03492         { return _mmsminus<imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
03493         INLINE l_imatrix operator -(const l_rmatrix_slice &ms,const imatrix &m)
03494 #if(CXSC_INDEX_CHECK)
03495         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03496 #else
03497         throw()
03498 #endif
03499         { return _msmminus<l_rmatrix_slice,imatrix,l_imatrix>(ms,m); }
03500         INLINE l_imatrix operator -(const imatrix_slice &ms,const l_rmatrix &m)
03501 #if(CXSC_INDEX_CHECK)
03502         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03503 #else
03504         throw()
03505 #endif
03506         { return _msmminus<imatrix_slice,l_rmatrix,l_imatrix>(ms,m); }
03507         INLINE l_imatrix operator -(const l_rmatrix_slice &ms1,const imatrix_slice &ms2)
03508 #if(CXSC_INDEX_CHECK)
03509         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03510 #else
03511         throw()
03512 #endif
03513         { return _msmsminus<l_rmatrix_slice,imatrix_slice,l_imatrix>(ms1,ms2); }
03514         INLINE l_imatrix operator -(const imatrix_slice &ms1,const l_rmatrix_slice &ms2)
03515 #if(CXSC_INDEX_CHECK)
03516         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03517 #else
03518         throw()
03519 #endif
03520         { return _msmsminus<imatrix_slice,l_rmatrix_slice,l_imatrix>(ms1,ms2); }
03521         INLINE l_imatrix operator *(const l_rmatrix &m1, const imatrix &m2)
03522 #if(CXSC_INDEX_CHECK)
03523         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03524 #else
03525         throw()
03526 #endif
03527         { return _mmlimult<l_rmatrix,imatrix,l_imatrix>(m1,m2); }
03528         INLINE l_imatrix operator *(const imatrix &m1, const l_rmatrix &m2)
03529 #if(CXSC_INDEX_CHECK)
03530         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03531 #else
03532         throw()
03533 #endif
03534         { return _mmlimult<imatrix,l_rmatrix,l_imatrix>(m1,m2); }
03535         INLINE l_imatrix operator *(const l_rmatrix &m1, const imatrix_slice &ms)
03536 #if(CXSC_INDEX_CHECK)
03537         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03538 #else
03539         throw()
03540 #endif
03541         { return _mmslimult<l_rmatrix,imatrix_slice,l_imatrix>(m1,ms); }
03542         INLINE l_imatrix operator *(const imatrix &m1, const l_rmatrix_slice &ms)
03543 #if(CXSC_INDEX_CHECK)
03544         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03545 #else
03546         throw()
03547 #endif
03548         { return _mmslimult<imatrix,l_rmatrix_slice,l_imatrix>(m1,ms); }
03549         INLINE l_imatrix operator *(const l_rmatrix_slice &ms, const imatrix &m1)
03550 #if(CXSC_INDEX_CHECK)
03551         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03552 #else
03553         throw()
03554 #endif
03555         { return _msmlimult<l_rmatrix_slice,imatrix,l_imatrix>(ms,m1); }
03556         INLINE l_imatrix operator *(const imatrix_slice &ms, const l_rmatrix &m1)
03557 #if(CXSC_INDEX_CHECK)
03558         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03559 #else
03560         throw()
03561 #endif
03562         { return _msmlimult<imatrix_slice,l_rmatrix,l_imatrix>(ms,m1); }
03563         INLINE l_imatrix operator *(const l_rmatrix_slice &ms1, const imatrix_slice &ms2)
03564 #if(CXSC_INDEX_CHECK)
03565         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03566 #else
03567         throw()
03568 #endif
03569         { return _msmslimult<l_rmatrix_slice,imatrix_slice,l_imatrix>(ms1,ms2); }
03570         INLINE l_imatrix operator *(const imatrix_slice &ms1, const l_rmatrix_slice &ms2)
03571 #if(CXSC_INDEX_CHECK)
03572         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03573 #else
03574         throw()
03575 #endif
03576         { return _msmslimult<imatrix_slice,l_rmatrix_slice,l_imatrix>(ms1,ms2); }
03577         INLINE l_imatrix operator |(const l_rmatrix &m1,const imatrix &m2)
03578 #if(CXSC_INDEX_CHECK)
03579         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03580 #else
03581         throw()
03582 #endif
03583         { return _mmconv<l_rmatrix,imatrix,l_imatrix>(m1,m2); }
03584         INLINE l_imatrix operator |(const imatrix &m1,const l_rmatrix &m2)
03585 #if(CXSC_INDEX_CHECK)
03586         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03587 #else
03588         throw()
03589 #endif
03590         { return _mmconv<l_rmatrix,imatrix,l_imatrix>(m2,m1); }
03591         INLINE l_imatrix operator |(const l_rmatrix &m,const imatrix_slice &ms)
03592 #if(CXSC_INDEX_CHECK)
03593         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03594 #else
03595         throw()
03596 #endif
03597         { return _mmsconv<l_rmatrix,imatrix_slice,l_imatrix>(m,ms); }
03598         INLINE l_imatrix operator |(const imatrix &m,const l_rmatrix_slice &ms)
03599 #if(CXSC_INDEX_CHECK)
03600         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03601 #else
03602         throw()
03603 #endif
03604         { return _mmsconv<imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
03605         INLINE l_imatrix operator |(const l_rmatrix_slice &ms,const imatrix &m)
03606 #if(CXSC_INDEX_CHECK)
03607         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03608 #else
03609         throw()
03610 #endif
03611         { return _mmsconv<imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
03612         INLINE l_imatrix operator |(const imatrix_slice &ms,const l_rmatrix &m)
03613 #if(CXSC_INDEX_CHECK)
03614         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03615 #else
03616         throw()
03617 #endif
03618         { return _mmsconv<l_rmatrix,imatrix_slice,l_imatrix>(m,ms); }
03619         INLINE l_imatrix operator |(const l_rmatrix_slice &m1,const imatrix_slice &m2)
03620 #if(CXSC_INDEX_CHECK)
03621         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03622 #else
03623         throw()
03624 #endif
03625         { return _msmsconv<l_rmatrix_slice,imatrix_slice,l_imatrix>(m1,m2); }
03626         INLINE l_imatrix operator |(const imatrix_slice &m1,const l_rmatrix_slice &m2)
03627 #if(CXSC_INDEX_CHECK)
03628         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03629 #else
03630         throw()
03631 #endif
03632         { return _msmsconv<l_rmatrix_slice,imatrix_slice,l_imatrix>(m2,m1); }
03633         INLINE l_imatrix operator &(const l_rmatrix &m1,const imatrix &m2)
03634 #if(CXSC_INDEX_CHECK)
03635         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03636 #else
03637         throw()
03638 #endif
03639         { return _mmsect<l_rmatrix,imatrix,l_imatrix>(m1,m2); }
03640         INLINE l_imatrix operator &(const imatrix &m1,const l_rmatrix &m2)
03641 #if(CXSC_INDEX_CHECK)
03642         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03643 #else
03644         throw()
03645 #endif
03646         { return _mmsect<l_rmatrix,imatrix,l_imatrix>(m2,m1); }
03647         INLINE l_imatrix operator &(const l_rmatrix &m,const imatrix_slice &ms)
03648 #if(CXSC_INDEX_CHECK)
03649         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03650 #else
03651         throw()
03652 #endif
03653         { return _mmssect<l_rmatrix,imatrix_slice,l_imatrix>(m,ms); }
03654         INLINE l_imatrix operator &(const imatrix &m,const l_rmatrix_slice &ms)
03655 #if(CXSC_INDEX_CHECK)
03656         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03657 #else
03658         throw()
03659 #endif
03660         { return _mmssect<imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
03661         INLINE l_imatrix operator &(const l_rmatrix_slice &ms,const imatrix &m)
03662 #if(CXSC_INDEX_CHECK)
03663         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03664 #else
03665         throw()
03666 #endif
03667         { return _mmssect<imatrix,l_rmatrix_slice,l_imatrix>(m,ms); }
03668         INLINE l_imatrix operator &(const imatrix_slice &ms,const l_rmatrix &m)
03669 #if(CXSC_INDEX_CHECK)
03670         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03671 #else
03672         throw()
03673 #endif
03674         { return _mmssect<l_rmatrix,imatrix_slice,l_imatrix>(m,ms); }
03675         INLINE l_imatrix operator &(const l_rmatrix_slice &m1,const imatrix_slice &m2)
03676 #if(CXSC_INDEX_CHECK)
03677         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03678 #else
03679         throw()
03680 #endif
03681         { return _msmssect<l_rmatrix_slice,imatrix_slice,l_imatrix>(m1,m2); }
03682         INLINE l_imatrix operator &(const imatrix_slice &m1,const l_rmatrix_slice &m2)
03683 #if(CXSC_INDEX_CHECK)
03684         throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM)
03685 #else
03686         throw()
03687 #endif
03688         { return _msmssect<l_rmatrix_slice,imatrix_slice,l_imatrix>(m2,m1); }
03689 
03690 //------------- real x l_real ------------------------
03691         INLINE l_imatrix operator |(const rmatrix &rv1, const l_rmatrix &rv2)
03692 #if(CXSC_INDEX_CHECK)
03693         throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
03694 #else
03695         throw()
03696 #endif
03697         { return _mmconv<rmatrix,l_rmatrix,l_imatrix>(rv1,rv2); }
03698         INLINE l_imatrix operator |(const l_rmatrix &rv1, const rmatrix &rv2)
03699 #if(CXSC_INDEX_CHECK)
03700         throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
03701 #else
03702         throw()
03703 #endif
03704         { return _mmconv<rmatrix,l_rmatrix,l_imatrix>(rv2,rv1); }
03705         INLINE l_imatrix operator |(const l_rmatrix &rv, const rmatrix_slice &sl)
03706 #if(CXSC_INDEX_CHECK)
03707         throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
03708 #else
03709         throw()
03710 #endif
03711         { return _mmsconv<l_rmatrix,rmatrix_slice,l_imatrix>(rv,sl); }
03712         INLINE l_imatrix operator |(const rmatrix_slice &sl,const l_rmatrix &rv)
03713 #if(CXSC_INDEX_CHECK)
03714         throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
03715 #else
03716         throw()
03717 #endif
03718         { return _mmsconv<l_rmatrix,rmatrix_slice,l_imatrix>(rv,sl); }
03719         INLINE l_imatrix operator |(const l_rmatrix_slice &sl, const rmatrix &rv)
03720 #if(CXSC_INDEX_CHECK)
03721         throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
03722 #else
03723         throw()
03724 #endif
03725         { return _mmsconv<rmatrix,l_rmatrix_slice,l_imatrix>(rv,sl); }
03726         INLINE l_imatrix operator |(const rmatrix &rv,const l_rmatrix_slice &sl)
03727 #if(CXSC_INDEX_CHECK)
03728         throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
03729 #else
03730         throw()
03731 #endif
03732         { return _mmsconv<rmatrix,l_rmatrix_slice,l_imatrix>(rv,sl); }
03733         INLINE l_imatrix operator |(const l_rmatrix_slice &sl1, const rmatrix_slice &sl2)
03734 #if(CXSC_INDEX_CHECK)
03735         throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
03736 #else
03737         throw()
03738 #endif
03739         { return _msmsconv<rmatrix_slice,l_rmatrix_slice,l_imatrix>(sl2,sl1); }
03740         INLINE l_imatrix operator |(const rmatrix_slice &sl1, const l_rmatrix_slice &sl2)
03741 #if(CXSC_INDEX_CHECK)
03742         throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
03743 #else
03744         throw()
03745 #endif
03746         { return _msmsconv<rmatrix_slice,l_rmatrix_slice,l_imatrix>(sl1,sl2); }
03747         
03748 //------------- l_real x l_real ------------------------
03749         INLINE l_imatrix operator |(const l_rmatrix &rv1, const l_rmatrix &rv2)
03750 #if(CXSC_INDEX_CHECK)
03751         throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
03752 #else
03753         throw()
03754 #endif
03755         { return _mmconv<l_rmatrix,l_rmatrix,l_imatrix>(rv1,rv2); }
03756         INLINE l_imatrix operator |(const l_rmatrix &rv, const l_rmatrix_slice &sl)
03757 #if(CXSC_INDEX_CHECK)
03758         throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
03759 #else
03760         throw()
03761 #endif
03762         { return _mmsconv<l_rmatrix,l_rmatrix_slice,l_imatrix>(rv,sl); }
03763         INLINE l_imatrix operator |(const l_rmatrix_slice &sl,const l_rmatrix &rv)
03764 #if(CXSC_INDEX_CHECK)
03765         throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
03766 #else
03767         throw()
03768 #endif
03769         { return _mmsconv<l_rmatrix,l_rmatrix_slice,l_imatrix>(rv,sl); }
03770         INLINE l_imatrix operator |(const l_rmatrix_slice &sl1, const l_rmatrix_slice &sl2)
03771 #if(CXSC_INDEX_CHECK)
03772         throw(ERROR__OP_WITH_WRONG_DIM<l_imatrix>)
03773 #else
03774         throw()
03775 #endif
03776         { return _msmsconv<l_rmatrix_slice,l_rmatrix_slice,l_imatrix>(sl1,sl2); }
03777         
03778         INLINE bool operator ==(const l_imatrix &m1,const l_imatrix &m2) throw() { return _mmeq(m1,m2); }
03779         INLINE bool operator !=(const l_imatrix &m1,const l_imatrix &m2) throw() { return _mmneq(m1,m2); }
03780         INLINE bool operator <(const l_imatrix &m1,const l_imatrix &m2) throw() { return _mmless(m1,m2); }
03781         INLINE bool operator <=(const l_imatrix &m1,const l_imatrix &m2) throw() { return _mmleq(m1,m2); }
03782         INLINE bool operator >(const l_imatrix &m1,const l_imatrix &m2) throw() { return _mmless(m2,m1); }
03783         INLINE bool operator >=(const l_imatrix &m1,const l_imatrix &m2) throw() { return _mmleq(m2,m1); }
03784         INLINE bool operator ==(const l_imatrix &m1,const l_imatrix_slice &ms) throw() { return _mmseq(m1,ms); }
03785         INLINE bool operator !=(const l_imatrix &m1,const l_imatrix_slice &ms) throw() { return _mmsneq(m1,ms); }
03786         INLINE bool operator <(const l_imatrix &m1,const l_imatrix_slice &ms) throw() { return _mmsless(m1,ms); }
03787         INLINE bool operator <=(const l_imatrix &m1,const l_imatrix_slice &ms) throw() { return _mmsleq(m1,ms); }
03788         INLINE bool operator >(const l_imatrix &m1,const l_imatrix_slice &ms) throw() { return _msmless(ms,m1); }
03789         INLINE bool operator >=(const l_imatrix &m1,const l_imatrix_slice &ms) throw() { return _msmleq(ms,m1); }
03790         INLINE bool operator ==(const l_imatrix_slice &m1,const l_imatrix_slice &m2) throw() { return _msmseq(m1,m2); }
03791         INLINE bool operator !=(const l_imatrix_slice &m1,const l_imatrix_slice &m2) throw() { return _msmsneq(m1,m2); }
03792         INLINE bool operator <(const l_imatrix_slice &m1,const l_imatrix_slice &m2) throw() { return _msmsless(m1,m2); }
03793         INLINE bool operator <=(const l_imatrix_slice &m1,const l_imatrix_slice &m2) throw() { return _msmsleq(m1,m2); }
03794         INLINE bool operator >(const l_imatrix_slice &m1,const l_imatrix_slice &m2) throw() { return _msmsless(m2,m1); }
03795         INLINE bool operator >=(const l_imatrix_slice &m1,const l_imatrix_slice &m2) throw() { return _msmsleq(m2,m1); }
03796         INLINE bool operator !(const l_imatrix &ms) throw() { return _mnot(ms); }
03797         INLINE bool operator !(const l_imatrix_slice &ms) throw() { return _msnot(ms); }
03798         INLINE std::ostream &operator <<(std::ostream &s,const l_imatrix &r) throw() { return _mout(s,r); }
03799         INLINE std::ostream &operator <<(std::ostream &s,const l_imatrix_slice &r) throw() { return _msout(s,r); }
03800         INLINE std::istream &operator >>(std::istream &s,l_imatrix &r) throw() { return _min(s,r); }
03801         INLINE std::istream &operator >>(std::istream &s,l_imatrix_slice &r) throw() { return _msin(s,r); }
03802 
03803 } // namespace cxsc
03804 
03805 #endif
03806