C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
imatrix.inl
00001 /*
00002 **  CXSC is a C++ library for eXtended Scientific Computing (V 2.5.4)
00003 **
00004 **  Copyright (C) 1990-2000 Institut fuer Angewandte Mathematik,
00005 **                          Universitaet Karlsruhe, Germany
00006 **            (C) 2000-2014 Wiss. Rechnen/Softwaretechnologie
00007 **                          Universitaet Wuppertal, Germany   
00008 **
00009 **  This library is free software; you can redistribute it and/or
00010 **  modify it under the terms of the GNU Library General Public
00011 **  License as published by the Free Software Foundation; either
00012 **  version 2 of the License, or (at your option) any later version.
00013 **
00014 **  This library is distributed in the hope that it will be useful,
00015 **  but WITHOUT ANY WARRANTY; without even the implied warranty of
00016 **  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00017 **  Library General Public License for more details.
00018 **
00019 **  You should have received a copy of the GNU Library General Public
00020 **  License along with this library; if not, write to the Free
00021 **  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00022 */
00023 
00024 /* CVS $Id: imatrix.inl,v 1.30 2014/01/30 17:23:45 cxsc Exp $ */
00025 
00026 #ifndef _CXSC_IMATRIX_INL_INCLUDED
00027 #define _CXSC_IMATRIX_INL_INCLUDED
00028 
00029 namespace cxsc {
00030 
00031 INLINE imatrix::imatrix() throw():dat(NULL),lb1(1),ub1(0),lb2(1),ub2(0),xsize(0),ysize(0)
00032 {
00033 }
00034 
00035 INLINE imatrix::imatrix(const interval &r) throw():lb1(1),ub1(1),lb2(1),ub2(1),xsize(1),ysize(1)
00036 {
00037         dat=new interval[1];
00038         *dat=r;
00039 }
00040 
00041 INLINE imatrix::imatrix(const real &r) throw():lb1(1),ub1(1),lb2(1),ub2(1),xsize(1),ysize(1)
00042 {
00043         dat=new interval[1];
00044         *dat=r;
00045 }
00046 
00047 INLINE imatrix::imatrix(const imatrix &rm) throw():lb1(rm.lb1),ub1(rm.ub1),lb2(rm.lb2),ub2(rm.ub2),xsize(rm.xsize),ysize(rm.ysize)
00048 {
00049         dat=new interval[xsize*ysize];
00050         for(int i=0;i<xsize*ysize;i++)
00051                 dat[i]=rm.dat[i];
00052 }
00053 
00054 INLINE imatrix::imatrix(const rmatrix &rm) throw():lb1(rm.lb1),ub1(rm.ub1),lb2(rm.lb2),ub2(rm.ub2),xsize(rm.xsize),ysize(rm.ysize)
00055 {
00056         dat=new interval[xsize*ysize];
00057         for(int i=0;i<xsize*ysize;i++)
00058                 dat[i]=rm.dat[i];
00059 }
00060 
00061 INLINE imatrix::imatrix(const int &m, const int &n)
00062 #if(CXSC_INDEX_CHECK)
00063         throw(ERROR_IMATRIX_WRONG_BOUNDARIES):lb1(1),ub1(m),lb2(1),ub2(n),xsize(n),ysize(m)
00064 #else
00065         throw():lb1(1),ub1(m),lb2(1),ub2(n),xsize(n),ysize(m)
00066 #endif
00067 {
00068 #if(CXSC_INDEX_CHECK)
00069         if((n<0)||(m<0)) cxscthrow(ERROR_IMATRIX_WRONG_BOUNDARIES("imatrix::imatrix(const int &m, const int &n)"));
00070 #endif
00071         dat=new interval[m*n];
00072 }
00073 
00074 INLINE imatrix::imatrix(const int &m1, const int &m2, const int &n1, const int &n2)
00075 #if(CXSC_INDEX_CHECK)
00076         throw(ERROR_IMATRIX_WRONG_BOUNDARIES):lb1(m1),ub1(m2),lb2(n1),ub2(n2),xsize(n2-n1+1),ysize(m2-m1+1)
00077 #else
00078         throw():lb1(m1),ub1(m2),lb2(n1),ub2(n2),xsize(n2-n1+1),ysize(m2-m1+1)
00079 #endif
00080 {
00081 #if(CXSC_INDEX_CHECK)
00082         if((m2<m1)||(n2<n1)) cxscthrow(ERROR_IMATRIX_WRONG_BOUNDARIES("imatrix::imatrix(const int &m1, const int &n1, const int &m2, const int &n2)"));
00083 #endif
00084         dat=new interval[xsize*ysize];
00085 }
00086 
00087 INLINE ivector::ivector(const imatrix_subv &v) throw():l(v.lb),u(v.ub),size(v.size)
00088 {
00089         dat=new interval[size];
00090         for (int i=0, j=v.start;i<v.size;i++,j+=v.offset)
00091                 dat[i]=v.dat[j];
00092 }
00093 
00094 INLINE imatrix::imatrix(const ivector &v) throw():lb1(v.l),ub1(v.u),lb2(1),ub2(1),xsize(1),ysize(v.size)
00095 {
00096         dat=new interval[v.size];
00097         for(int i=0;i<v.size;i++)
00098                 dat[i]=v.dat[i];
00099 }
00100 
00101 INLINE imatrix::imatrix(const rvector &v) throw():lb1(v.l),ub1(v.u),lb2(1),ub2(1),xsize(1),ysize(v.size)
00102 {
00103         dat=new interval[v.size];
00104         for(int i=0;i<v.size;i++)
00105                 dat[i]=v.dat[i];
00106 }
00107 
00108 INLINE imatrix::imatrix(const ivector_slice &v) throw():lb1(v.start),ub1(v.end),lb2(1),ub2(1),xsize(1),ysize(v.size)
00109 {
00110         dat=new interval[v.size];
00111         for(int i=0,j=v.start-v.l;i<v.size;i++,j++)
00112                 dat[i]=v.dat[j];
00113 }
00114 
00115 INLINE imatrix::imatrix(const rvector_slice &v) throw():lb1(v.start),ub1(v.end),lb2(1),ub2(1),xsize(1),ysize(v.size)
00116 {
00117         dat=new interval[v.size];
00118         for(int i=0,j=v.start-v.l;i<v.size;i++,j++)
00119                 dat[i]=v.dat[j];
00120 }
00121 
00122 
00123 
00124         INLINE imatrix::imatrix(const imatrix_slice &sl) throw():lb1(sl.start1),ub1(sl.end1),lb2(sl.start2),ub2(sl.end2),xsize(sl.sxsize),ysize(sl.sysize)
00125         {
00126                 int i,j;
00127                 
00128                 dat=new interval[xsize*ysize];
00129                 for (i=0;i<ysize;i++)
00130                 {
00131                         for(j=0;j<xsize;j++)
00132                         {
00133                                 dat[i*xsize+j]=sl.dat[(sl.offset1+i)*sl.mxsize+sl.offset2+j];
00134                         }
00135                 }
00136         }
00137 
00138         INLINE imatrix::imatrix(const rmatrix_slice &sl) throw():lb1(sl.start1),ub1(sl.end1),lb2(sl.start2),ub2(sl.end2),xsize(sl.sxsize),ysize(sl.sysize)
00139         {
00140                 int i,j;
00141                 
00142                 dat=new interval[xsize*ysize];
00143                 for (i=0;i<ysize;i++)
00144                 {
00145                         for(j=0;j<xsize;j++)
00146                         {
00147                                 dat[i*xsize+j]=sl.dat[(sl.offset1+i)*sl.mxsize+sl.offset2+j];
00148                         }
00149                 }
00150         }
00151 
00152         INLINE imatrix_subv Row(imatrix &m,const int &i)
00153 #if(CXSC_INDEX_CHECK)
00154         throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT)
00155 #else
00156         throw()
00157 #endif
00158         
00159         {
00160                 return m[i];
00161         }
00162 
00163         INLINE imatrix_subv Col(imatrix &m,const int &i)
00164 #if(CXSC_INDEX_CHECK)
00165         throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT)
00166 #else
00167         throw()
00168 #endif
00169         
00170         {
00171                 return m[Col(i)];
00172         }
00173 
00174         INLINE imatrix_subv Row(const imatrix &m,const int &i)
00175 #if(CXSC_INDEX_CHECK)
00176         throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT)
00177 #else
00178         throw()
00179 #endif
00180         
00181         {
00182                 return m[i];
00183         }
00184 
00185         INLINE imatrix_subv Col(const imatrix &m,const int &i)
00186 #if(CXSC_INDEX_CHECK)
00187         throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT)
00188 #else
00189         throw()
00190 #endif
00191         
00192         {
00193                 return m[Col(i)];
00194         }
00195 
00196         INLINE interval& imatrix_subv::operator [](const int &i) const
00197 #if(CXSC_INDEX_CHECK)
00198                 throw(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC)
00199 #else
00200         throw()
00201 #endif
00202         {
00203 #if(CXSC_INDEX_CHECK)
00204                 if((i<lb)||(i>ub)) cxscthrow(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC("interval &imatrix_subv::operator [](const int &i) const"));
00205 #endif
00206                 return dat[start+((i-lb)*offset)];
00207         }
00208 
00209         INLINE interval& imatrix_subv::operator [](const int &i)
00210 #if(CXSC_INDEX_CHECK)
00211                 throw(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC)
00212 #else
00213         throw()
00214 #endif
00215         {
00216 #if(CXSC_INDEX_CHECK)
00217                 if((i<lb)||(i>ub)) cxscthrow(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC("interval &imatrix_subv::operator [](const int &i)"));
00218 #endif
00219                 return dat[start+((i-lb)*offset)];
00220         }
00221 
00222                 
00223         INLINE imatrix_subv imatrix::operator [](const int &i) const
00224 #if(CXSC_INDEX_CHECK)
00225                 throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT)
00226 #else
00227         throw()
00228 #endif
00229         {
00230 #if(CXSC_INDEX_CHECK)
00231                 if((i<lb1)||(i>ub1)) cxscthrow(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT("imatrix_subv imatrix::operator [](const int &i)"));
00232 #endif
00233                 return imatrix_subv(dat, lb2, ub2, xsize, xsize*(i-lb1),1);
00234         }
00235         
00236         INLINE imatrix_subv imatrix::operator [](const cxscmatrix_column &i) const
00237 #if(CXSC_INDEX_CHECK)
00238                 throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT)
00239 #else
00240         throw()
00241 #endif
00242         {
00243 #if(CXSC_INDEX_CHECK)
00244                 if((i.col()<lb2)||(i.col()>ub2)) cxscthrow(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT("imatrix_subv imatrix::operator [](const cxscmatrix_column &i)"));
00245 #endif
00246                 return imatrix_subv(dat, lb1, ub1, ysize, i.col()-lb2, xsize);
00247         }
00248         
00249         INLINE imatrix_slice imatrix::operator ()(const int &m, const int &n)
00250 #if(CXSC_INDEX_CHECK)
00251                 throw(ERROR_IMATRIX_SUB_ARRAY_TOO_BIG)
00252 #else
00253         throw()
00254 #endif
00255         {
00256 #if(CXSC_INDEX_CHECK)
00257         if((m<1)||(n<1)||(m<lb1)||(n<lb2)||(m>ub1)||(n>ub2)) cxscthrow(ERROR_IMATRIX_SUB_ARRAY_TOO_BIG("imatrix_slice imatrix::operator ()(const int &m, const int &n)"));
00258 #endif
00259                 return imatrix_slice(*this,1,m,1,n);
00260         }
00261         
00262         INLINE imatrix_slice imatrix::operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
00263 #if(CXSC_INDEX_CHECK)
00264                 throw(ERROR_IMATRIX_SUB_ARRAY_TOO_BIG)
00265 #else
00266         throw()
00267 #endif
00268         {
00269 #if(CXSC_INDEX_CHECK)
00270         if((m1<lb1)||(n1<lb2)||(m2>ub1)||(n2>ub2)) cxscthrow(ERROR_IMATRIX_SUB_ARRAY_TOO_BIG("imatrix_slice imatrix::operator ()(const int &m1, const int &n1, const int &m2, const int &n2)"));
00271 #endif
00272                 return imatrix_slice(*this,m1,m2,n1,n2);
00273         }
00274 
00275         INLINE imatrix_subv imatrix_slice::operator [](const int &i)
00276 #if(CXSC_INDEX_CHECK)
00277                 throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT)
00278 #else
00279         throw()
00280 #endif
00281         {
00282 #if(CXSC_INDEX_CHECK)
00283                 if((i<start1)||(i>end1)) cxscthrow(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT("imatrix_subv imatrix_slice::operator [](const int &i)"));
00284 #endif
00285                 return imatrix_subv(dat, start2, end2, sxsize, mxsize*(i-start1+offset1)+offset2,1);
00286         }
00287         
00288         INLINE imatrix_subv imatrix_slice::operator [](const cxscmatrix_column &i)
00289 #if(CXSC_INDEX_CHECK)
00290                 throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT)
00291 #else
00292         throw()
00293 #endif
00294         {
00295 #if(CXSC_INDEX_CHECK)
00296                 if((i.col()<start2)||(i.col()>end2)) cxscthrow(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT("imatrix_subv imatrix_slice::operator [](const cxscmatrix_column &i)"));
00297 #endif
00298                 return imatrix_subv(dat, start1, end1, sysize, offset1*mxsize+i.col()-start2+offset2, mxsize);
00299         }
00300 
00301         INLINE imatrix_subv imatrix_slice::operator [](const int &i) const
00302 #if(CXSC_INDEX_CHECK)
00303                 throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT)
00304 #else
00305         throw()
00306 #endif
00307         {
00308 #if(CXSC_INDEX_CHECK)
00309                 if((i<start1)||(i>end1)) cxscthrow(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT("imatrix_subv imatrix_slice::operator [](const int &i)"));
00310 #endif
00311                 return imatrix_subv(dat, start2, end2, sxsize, mxsize*(i-start1+offset1)+offset2,1);
00312         }
00313         
00314         INLINE imatrix_subv imatrix_slice::operator [](const cxscmatrix_column &i) const
00315 #if(CXSC_INDEX_CHECK)
00316                 throw(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT)
00317 #else
00318         throw()
00319 #endif
00320         {
00321 #if(CXSC_INDEX_CHECK)
00322                 if((i.col()<start2)||(i.col()>end2)) cxscthrow(ERROR_IMATRIX_ROW_OR_COL_NOT_IN_MAT("imatrix_subv imatrix_slice::operator [](const cxscmatrix_column &i)"));
00323 #endif
00324                 return imatrix_subv(dat, start1, end1, sysize, offset1*mxsize+i.col()-start2+offset2, mxsize);
00325         }
00326 
00327         
00328         INLINE imatrix_slice imatrix_slice::operator ()(const int &m, const int &n)
00329 #if(CXSC_INDEX_CHECK)
00330                 throw(ERROR_IMATRIX_SUB_ARRAY_TOO_BIG)
00331 #else
00332         throw()
00333 #endif
00334         {
00335 #if(CXSC_INDEX_CHECK)
00336                 if((m<1)||(n<1)||(m<start1)||(n<start2)||(m>end1)||(n>end2)) cxscthrow(ERROR_IMATRIX_SUB_ARRAY_TOO_BIG("imatrix_slice imatrix_slice::operator ()(const int &m, const int &n)"));
00337 #endif
00338                 return imatrix_slice(*this,1,m,1,n);
00339         }
00340         
00341         INLINE imatrix_slice imatrix_slice::operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
00342 #if(CXSC_INDEX_CHECK)
00343                 throw(ERROR_IMATRIX_SUB_ARRAY_TOO_BIG)
00344 #else
00345         throw()
00346 #endif
00347         {
00348 #if(CXSC_INDEX_CHECK)
00349                 if((m1<start1)||(n1<start2)||(m2>end1)||(n2>end2)) cxscthrow(ERROR_IMATRIX_SUB_ARRAY_TOO_BIG("imatrix_slice imatrix_slice::operator ()(const int &m1, const int &m2, const int &n1, const int &n2)"));
00350 #endif
00351                 return imatrix_slice(*this,m1,m2,n1,n2);
00352         }
00353 
00354 INLINE imatrix_subv imatrix_subv::operator ()(const int &i)
00355 #if(CXSC_INDEX_CHECK)
00356         throw(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG)
00357 #else
00358         throw()
00359 #endif
00360 {
00361 #if(CXSC_INDEX_CHECK)
00362         if(1<lb||i>ub) cxscthrow(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG("imatrix_subv imatrix_subv::operator ()(const int &i)"));
00363 #endif
00364         return imatrix_subv(dat,1,i,i,start+(1-lb)*offset,offset);
00365 }
00366 
00367 INLINE imatrix_subv imatrix_subv::operator ()(const int &i1,const int &i2)
00368 #if(CXSC_INDEX_CHECK)
00369         throw(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG)
00370 #else
00371         throw()
00372 #endif
00373 {
00374 #if(CXSC_INDEX_CHECK)
00375         if(i1<lb||i2>ub) cxscthrow(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG("imatrix_subv imatrix_subv::operator ()(const int &i1,const int &i2)"));
00376 #endif
00377         return imatrix_subv(dat,i1,i2,i2-i1+1,start+(i1-lb)*offset,offset);
00378 }
00379 
00380         INLINE imatrix_subv &imatrix_subv::operator =(const imatrix_subv &rv) throw() { return _mvmvassign(*this,rv); }
00381         INLINE imatrix_subv &imatrix_subv::operator =(const interval &r) throw() { return _mvsassign(*this,r); }
00382         INLINE imatrix_subv &imatrix_subv::operator =(const ivector &v)
00383 #if(CXSC_INDEX_CHECK)
00384         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00385 #else
00386         throw()
00387 #endif
00388         { return _mvvassign(*this,v); }
00389         INLINE imatrix_subv &imatrix_subv::operator =(const ivector_slice &v)
00390 #if(CXSC_INDEX_CHECK)
00391         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00392 #else
00393         throw()
00394 #endif
00395         { return _mvvassign(*this,ivector(v)); }
00396         INLINE imatrix_subv &imatrix_subv::operator =(const rmatrix_subv &rv) throw() { return _mvvassign(*this,rvector(rv)); }
00397         INLINE imatrix_subv &imatrix_subv::operator =(const real &r) throw() { return _mvsassign(*this,r); }
00398         INLINE imatrix_subv &imatrix_subv::operator =(const rvector &v)
00399 #if(CXSC_INDEX_CHECK)
00400         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00401 #else
00402         throw()
00403 #endif
00404         { return _mvvassign(*this,v); }
00405         INLINE imatrix_subv &imatrix_subv::operator =(const rvector_slice &v)
00406 #if(CXSC_INDEX_CHECK)
00407         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00408 #else
00409         throw()
00410 #endif
00411         { return _mvvassign(*this,ivector(v)); }
00412         INLINE imatrix_subv &imatrix_subv::operator *=(const real &c) throw() { return _mvsmultassign(*this,c); }
00413         INLINE imatrix_subv &imatrix_subv::operator +=(const real &c) throw() { return _mvsplusassign(*this,c); }
00414         INLINE imatrix_subv &imatrix_subv::operator -=(const real &c) throw() { return _mvsminusassign(*this,c); }
00415         INLINE imatrix_subv &imatrix_subv::operator /=(const real &c) throw() { return _mvsdivassign(*this,c); }
00416         INLINE imatrix &imatrix::operator =(const interval &r) throw() { return _msassign(*this,r); }
00417         INLINE imatrix &imatrix::operator =(const imatrix &m) throw() { return _mmassign<imatrix,imatrix,interval>(*this,m,interval(0,0)); }
00418         INLINE imatrix &imatrix::operator =(const imatrix_slice &ms) throw() { return _mmsassign<imatrix,imatrix_slice,interval>(*this,ms); }
00419         INLINE imatrix &imatrix::operator =(const ivector &v) throw() { return _mvassign<imatrix,ivector,interval>(*this,v); }
00420         INLINE imatrix &imatrix::operator =(const ivector_slice &v) throw() { return _mvassign<imatrix,ivector,interval>(*this,ivector(v)); }
00421         INLINE imatrix &imatrix::operator =(const real &r) throw() { return _msassign(*this,interval(r)); }
00422         INLINE imatrix &imatrix::operator =(const rmatrix &m) throw() { return _mmassign<imatrix,rmatrix,interval>(*this,m,interval(0,0)); }
00423         INLINE imatrix &imatrix::operator =(const rmatrix_slice &ms) throw() { return _mmsassign<imatrix,rmatrix_slice,interval>(*this,ms); }
00424         INLINE imatrix &imatrix::operator =(const rvector &v) throw() { return _mvassign<imatrix,rvector,interval>(*this,v); }
00425         INLINE imatrix &imatrix::operator =(const rvector_slice &v) throw() { return _mvassign<imatrix,rvector,interval>(*this,rvector(v)); }
00426         INLINE imatrix::operator void*() throw() { return _mvoid(*this); }
00427 
00428         INLINE imatrix_slice &imatrix_slice::operator =(const imatrix &m)
00429 #if(CXSC_INDEX_CHECK)
00430         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
00431 #else
00432         throw()
00433 #endif
00434         { return _msmassign(*this,m); }
00435         INLINE imatrix_slice &imatrix_slice::operator =(const imatrix_slice &ms)
00436 #if(CXSC_INDEX_CHECK)
00437         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
00438 #else
00439         throw()
00440 #endif
00441         { return _msmsassign(*this,ms); }
00442         INLINE imatrix_slice &imatrix_slice::operator =(const interval &r) throw() { return _mssassign(*this,r); }
00443         INLINE imatrix_slice &imatrix_slice::operator =(const ivector &v)
00444 #if(CXSC_INDEX_CHECK)
00445         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
00446 #else
00447         throw()
00448 #endif
00449         { return _msmassign(*this,imatrix(v)); }
00450         INLINE imatrix_slice &imatrix_slice::operator =(const ivector_slice &v)
00451 #if(CXSC_INDEX_CHECK)
00452         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
00453 #else
00454         throw()
00455 #endif
00456         { return _msmassign(*this,imatrix(ivector(v))); }
00457         INLINE imatrix_slice &imatrix_slice::operator =(const rmatrix &m)
00458 #if(CXSC_INDEX_CHECK)
00459         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
00460 #else
00461         throw()
00462 #endif
00463         { return _msmassign(*this,m); }
00464         INLINE imatrix_slice &imatrix_slice::operator =(const rmatrix_slice &ms)
00465 #if(CXSC_INDEX_CHECK)
00466         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
00467 #else
00468         throw()
00469 #endif
00470         { return _msmsassign(*this,ms); }
00471         INLINE imatrix_slice &imatrix_slice::operator =(const real &r) throw() { return _mssassign(*this,r); }
00472         INLINE imatrix_slice &imatrix_slice::operator =(const rvector &v)
00473 #if(CXSC_INDEX_CHECK)
00474         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
00475 #else
00476         throw()
00477 #endif
00478         { return _msmassign(*this,rmatrix(v)); }
00479         INLINE imatrix_slice &imatrix_slice::operator =(const rvector_slice &v)
00480 #if(CXSC_INDEX_CHECK)
00481         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
00482 #else
00483         throw()
00484 #endif
00485         { return _msmassign(*this,rmatrix(rvector(v))); }
00486         INLINE imatrix_slice::operator void*() throw() { return _msvoid(*this); }
00487         
00488         INLINE ivector operator /(const imatrix_subv &rv, const interval &s) throw() { return _mvsdiv<imatrix_subv,interval,ivector>(rv,s); }
00489         INLINE ivector operator *(const imatrix_subv &rv, const interval &s) throw() { return _mvsmult<imatrix_subv,interval,ivector>(rv,s); }
00490         INLINE ivector operator *(const interval &s, const imatrix_subv &rv) throw() { return _mvsmult<imatrix_subv,interval,ivector>(rv,s); }
00491         INLINE imatrix_subv &imatrix_subv::operator *=(const interval &c) throw() { return _mvsmultassign(*this,c); }
00492         INLINE imatrix_subv &imatrix_subv::operator +=(const interval &c) throw() { return _mvsplusassign(*this,c); }
00493         INLINE imatrix_subv &imatrix_subv::operator -=(const interval &c) throw() { return _mvsminusassign(*this,c); }
00494         INLINE imatrix_subv &imatrix_subv::operator /=(const interval &c) throw() { return _mvsdivassign(*this,c); }
00495         INLINE ivector abs(const imatrix_subv &mv) throw() { return _mvabs<imatrix_subv,ivector>(mv); }
00496         INLINE rvector absmin(const imatrix_subv &mv) throw() { 
00497           rvector x(Lb(mv),Ub(mv));
00498           for(int i=Lb(mv) ; i<=Ub(mv) ; i++)
00499             x[i] = AbsMin(mv[i]);
00500           return x;
00501         }
00502         INLINE rvector absmax(const imatrix_subv &mv) throw() { 
00503           rvector x(Lb(mv),Ub(mv));
00504           for(int i=Lb(mv) ; i<=Ub(mv) ; i++)
00505             x[i] = AbsMax(mv[i]);
00506           return x;
00507         }
00508         INLINE rvector diam(const imatrix_subv &mv) throw() { return _mvdiam<imatrix_subv,rvector>(mv); }
00509         INLINE rvector mid(const imatrix_subv &mv) throw() { return _mvmid<imatrix_subv,rvector>(mv); }
00510         INLINE rvector Inf(const imatrix_subv &mv) throw() { return _mvinf<imatrix_subv,rvector>(mv); }
00511         INLINE rvector Sup(const imatrix_subv &mv) throw() { return _mvsup<imatrix_subv,rvector>(mv); }
00512         INLINE imatrix_subv &SetInf(imatrix_subv &mv,const rvector &rv)
00513 #if(CXSC_INDEX_CHECK)
00514         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
00515 #else
00516         throw()
00517 #endif
00518         { return _mvvsetinf(mv,rv); }
00519         INLINE imatrix_subv &SetSup(imatrix_subv &mv,const rvector &rv)
00520 #if(CXSC_INDEX_CHECK)
00521         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
00522 #else
00523         throw()
00524 #endif
00525         { return _mvvsetsup(mv,rv); }
00526         INLINE imatrix_subv &UncheckedSetInf(imatrix_subv &mv,const rvector &rv)
00527 #if(CXSC_INDEX_CHECK)
00528         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
00529 #else
00530         throw()
00531 #endif
00532         { return _mvvusetinf(mv,rv); }
00533         INLINE imatrix_subv &UncheckedSetSup(imatrix_subv &mv,const rvector &rv)
00534 #if(CXSC_INDEX_CHECK)
00535         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
00536 #else
00537         throw()
00538 #endif
00539         { return _mvvusetsup(mv,rv); }
00540         INLINE imatrix_subv &SetSup(imatrix_subv &iv,const real &r) throw() { return _mvssetsup(iv,r); }
00541         INLINE imatrix_subv &SetInf(imatrix_subv &iv,const real &r) throw() { return _mvssetinf(iv,r); }
00542         INLINE imatrix_subv &UncheckedSetSup(imatrix_subv &iv,const real &r) throw() { return _mvsusetsup(iv,r); }
00543         INLINE imatrix_subv &SetUncheckedInf(imatrix_subv &iv,const real &r) throw() { return _mvsusetinf(iv,r); }
00544         INLINE ivector &ivector::operator =(const imatrix_subv &mv) throw() { return _vmvassign<ivector,imatrix_subv,interval>(*this,mv); }
00545         INLINE ivector_slice &ivector_slice::operator =(const imatrix_subv &mv) throw() { return _vsvassign(*this,ivector(mv)); }
00546 
00547 
00548         INLINE interval operator *(const imatrix_subv & rv1, const imatrix_subv &rv2)
00549 #if(CXSC_INDEX_CHECK)
00550         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00551 #else
00552         throw()
00553 #endif
00554         { return _mvmvimult<imatrix_subv,imatrix_subv,interval>(rv1,rv2); }
00555         INLINE interval operator *(const ivector & rv1, const imatrix_subv &rv2)
00556 #if(CXSC_INDEX_CHECK)
00557         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00558 #else
00559         throw()
00560 #endif
00561         { return _vmvimult<ivector,imatrix_subv,interval>(rv1,rv2); }
00562         INLINE interval operator *(const imatrix_subv &rv1,const ivector &rv2)
00563 #if(CXSC_INDEX_CHECK)
00564         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00565 #else
00566         throw()
00567 #endif
00568         { return _vmvimult<ivector,imatrix_subv,interval>(rv2,rv1); }
00569         INLINE interval operator *(const ivector_slice &sl,const imatrix_subv &sv)
00570 #if(CXSC_INDEX_CHECK)
00571         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00572 #else
00573         throw()
00574 #endif
00575         { return _vmvimult<ivector,imatrix_subv,interval>(ivector(sl),sv); }
00576         INLINE interval operator *(const imatrix_subv &mv,const ivector_slice &vs)
00577 #if(CXSC_INDEX_CHECK)
00578         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00579 #else
00580         throw()
00581 #endif
00582         { return _vmvimult<ivector,imatrix_subv,interval>(ivector(vs),mv); }
00583         INLINE ivector operator +(const imatrix_subv & rv1, const imatrix_subv &rv2)
00584 #if(CXSC_INDEX_CHECK)
00585         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00586 #else
00587         throw()
00588 #endif
00589         { return _mvmvplus<imatrix_subv,imatrix_subv,ivector>(rv1,rv2); }
00590         INLINE ivector operator +(const imatrix_subv &rv1,const ivector &rv2)
00591 #if(CXSC_INDEX_CHECK)
00592         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00593 #else
00594         throw()
00595 #endif
00596         { return _mvvplus<imatrix_subv,ivector,ivector>(rv1,rv2); }
00597         INLINE ivector operator +(const ivector & rv1, const imatrix_subv &rv2)
00598 #if(CXSC_INDEX_CHECK)
00599         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00600 #else
00601         throw()
00602 #endif
00603         { return _mvvplus<imatrix_subv,ivector,ivector>(rv2,rv1); }
00604         INLINE ivector operator +(const ivector_slice &sl,const imatrix_subv &mv)
00605 #if(CXSC_INDEX_CHECK)
00606         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00607 #else
00608         throw()
00609 #endif
00610         { return _mvvplus<imatrix_subv,ivector,ivector>(mv,ivector(sl)); }
00611         INLINE ivector operator +(const imatrix_subv &mv,const ivector_slice &sl)
00612 #if(CXSC_INDEX_CHECK)
00613         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00614 #else
00615         throw()
00616 #endif
00617         { return _mvvplus<imatrix_subv,ivector,ivector>(mv,ivector(sl)); }
00618         INLINE imatrix_subv &imatrix_subv::operator +=(const ivector &rv)
00619 #if(CXSC_INDEX_CHECK)
00620         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00621 #else
00622         throw()
00623 #endif
00624         { return _mvvplusassign(*this,rv); }
00625         INLINE imatrix_subv &imatrix_subv::operator +=(const ivector_slice &rv)
00626 #if(CXSC_INDEX_CHECK)
00627         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00628 #else
00629         throw()
00630 #endif
00631         { return _mvvplusassign(*this,ivector(rv)); }
00632         INLINE ivector operator -(const imatrix_subv & rv1, const imatrix_subv &rv2)
00633 #if(CXSC_INDEX_CHECK)
00634         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00635 #else
00636         throw()
00637 #endif
00638         { return _mvmvminus<imatrix_subv,imatrix_subv,ivector>(rv1,rv2); }
00639         INLINE ivector operator -(const ivector & rv1, const imatrix_subv &rv2)
00640 #if(CXSC_INDEX_CHECK)
00641         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00642 #else
00643         throw()
00644 #endif
00645         { return _vmvminus<ivector,imatrix_subv,ivector>(rv1,rv2); }
00646         INLINE ivector operator -(const imatrix_subv &rv1,const ivector &rv2)
00647 #if(CXSC_INDEX_CHECK)
00648         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00649 #else
00650         throw()
00651 #endif
00652         { return _mvvminus<imatrix_subv,ivector,ivector>(rv1,rv2); }
00653         INLINE ivector operator -(const ivector_slice &sl,const imatrix_subv &mv)
00654 #if(CXSC_INDEX_CHECK)
00655         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00656 #else
00657         throw()
00658 #endif
00659         { return _vmvminus<ivector,imatrix_subv,ivector>(ivector(sl),mv); }
00660         INLINE ivector operator -(const imatrix_subv &mv,const ivector_slice &sl)
00661 #if(CXSC_INDEX_CHECK)
00662         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00663 #else
00664         throw()
00665 #endif
00666         { return _mvvminus<imatrix_subv,ivector,ivector>(mv,ivector(sl)); }
00667         INLINE imatrix_subv &imatrix_subv::operator -=(const ivector &rv)
00668 #if(CXSC_INDEX_CHECK)
00669         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00670 #else
00671         throw()
00672 #endif
00673         { return _mvvminusassign(*this,rv); }
00674         INLINE imatrix_subv &imatrix_subv::operator -=(const ivector_slice &rv)
00675 #if(CXSC_INDEX_CHECK)
00676         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00677 #else
00678         throw()
00679 #endif
00680         { return _mvvminusassign(*this,ivector(rv)); }
00681         INLINE ivector operator |(const imatrix_subv & rv1, const imatrix_subv &rv2)
00682 #if(CXSC_INDEX_CHECK)
00683         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00684 #else
00685         throw()
00686 #endif
00687         { return _mvmvconv<imatrix_subv,imatrix_subv,ivector>(rv1,rv2); }
00688         INLINE ivector operator |(const imatrix_subv &rv1,const ivector &rv2)
00689 #if(CXSC_INDEX_CHECK)
00690         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00691 #else
00692         throw()
00693 #endif
00694         { return _mvvconv<imatrix_subv,ivector,ivector>(rv1,rv2); }
00695         INLINE ivector operator |(const ivector & rv1, const imatrix_subv &rv2)
00696 #if(CXSC_INDEX_CHECK)
00697         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00698 #else
00699         throw()
00700 #endif
00701         { return _mvvconv<imatrix_subv,ivector,ivector>(rv2,rv1); }
00702         INLINE ivector operator |(const ivector_slice &sl,const imatrix_subv &mv)
00703 #if(CXSC_INDEX_CHECK)
00704         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00705 #else
00706         throw()
00707 #endif
00708         { return _mvvconv<imatrix_subv,ivector,ivector>(mv,ivector(sl)); }
00709         INLINE ivector operator |(const imatrix_subv &mv,const ivector_slice &sl)
00710 #if(CXSC_INDEX_CHECK)
00711         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00712 #else
00713         throw()
00714 #endif
00715         { return _mvvconv<imatrix_subv,ivector,ivector>(mv,ivector(sl)); }
00716         INLINE imatrix_subv &imatrix_subv::operator |=(const ivector &rv)
00717 #if(CXSC_INDEX_CHECK)
00718         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00719 #else
00720         throw()
00721 #endif
00722         { return _mvvconvassign(*this,rv); }
00723         INLINE imatrix_subv &imatrix_subv::operator |=(const ivector_slice &rv)
00724 #if(CXSC_INDEX_CHECK)
00725         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00726 #else
00727         throw()
00728 #endif
00729         { return _mvvconvassign(*this,ivector(rv)); }
00730         INLINE ivector operator &(const imatrix_subv & rv1, const imatrix_subv &rv2)
00731 #if(CXSC_INDEX_CHECK)
00732         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00733 #else
00734         throw()
00735 #endif
00736         { return _mvmvsect<imatrix_subv,imatrix_subv,ivector>(rv1,rv2); }
00737         INLINE ivector operator &(const imatrix_subv &rv1,const ivector &rv2)
00738 #if(CXSC_INDEX_CHECK)
00739         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00740 #else
00741         throw()
00742 #endif
00743         { return _mvvsect<imatrix_subv,ivector,ivector>(rv1,rv2); }
00744         INLINE ivector operator &(const ivector & rv1, const imatrix_subv &rv2)
00745 #if(CXSC_INDEX_CHECK)
00746         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00747 #else
00748         throw()
00749 #endif
00750         { return _mvvsect<imatrix_subv,ivector,ivector>(rv2,rv1); }
00751         INLINE ivector operator &(const ivector_slice &sl,const imatrix_subv &mv)
00752 #if(CXSC_INDEX_CHECK)
00753         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00754 #else
00755         throw()
00756 #endif
00757         { return _mvvsect<imatrix_subv,ivector,ivector>(mv,ivector(sl)); }
00758         INLINE ivector operator &(const imatrix_subv &mv,const ivector_slice &sl)
00759 #if(CXSC_INDEX_CHECK)
00760         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00761 #else
00762         throw()
00763 #endif
00764         { return _mvvsect<imatrix_subv,ivector,ivector>(mv,ivector(sl)); }
00765         INLINE imatrix_subv &imatrix_subv::operator &=(const ivector &rv)
00766 #if(CXSC_INDEX_CHECK)
00767         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00768 #else
00769         throw()
00770 #endif
00771         { return _mvvsectassign(*this,rv); }
00772         INLINE imatrix_subv &imatrix_subv::operator &=(const ivector_slice &rv)
00773 #if(CXSC_INDEX_CHECK)
00774         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00775 #else
00776         throw()
00777 #endif
00778         { return _mvvsectassign(*this,ivector(rv)); }
00779 
00780 
00781         INLINE imatrix_subv &imatrix_subv::operator +=(const rvector &rv)
00782 #if(CXSC_INDEX_CHECK)
00783         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00784 #else
00785         throw()
00786 #endif
00787         { return _mvvplusassign(*this,rv); }
00788         INLINE imatrix_subv &imatrix_subv::operator +=(const rvector_slice &rv)
00789 #if(CXSC_INDEX_CHECK)
00790         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00791 #else
00792         throw()
00793 #endif
00794         { return _mvvplusassign(*this,rvector(rv)); }
00795         INLINE imatrix_subv &imatrix_subv::operator -=(const rvector &rv)
00796 #if(CXSC_INDEX_CHECK)
00797         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00798 #else
00799         throw()
00800 #endif
00801         { return _mvvminusassign(*this,rv); }
00802         INLINE imatrix_subv &imatrix_subv::operator -=(const rvector_slice &rv)
00803 #if(CXSC_INDEX_CHECK)
00804         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00805 #else
00806         throw()
00807 #endif
00808         { return _mvvminusassign(*this,rvector(rv)); }
00809         INLINE imatrix_subv &imatrix_subv::operator |=(const rvector &rv)
00810 #if(CXSC_INDEX_CHECK)
00811         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00812 #else
00813         throw()
00814 #endif
00815         { return _mvvconvassign(*this,rv); }
00816         INLINE imatrix_subv &imatrix_subv::operator |=(const rvector_slice &rv)
00817 #if(CXSC_INDEX_CHECK)
00818         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00819 #else
00820         throw()
00821 #endif
00822         { return _mvvconvassign(*this,rvector(rv)); }
00823         INLINE imatrix_subv &imatrix_subv::operator &=(const rvector &rv)
00824 #if(CXSC_INDEX_CHECK)
00825         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00826 #else
00827         throw()
00828 #endif
00829         { return _mvvsectassign(*this,rv); }
00830         INLINE imatrix_subv &imatrix_subv::operator &=(const rvector_slice &rv)
00831 #if(CXSC_INDEX_CHECK)
00832         throw(ERROR_IVECTOR_OP_WITH_WRONG_DIM)
00833 #else
00834         throw()
00835 #endif
00836         { return _mvvsectassign(*this,rvector(rv)); }
00842         INLINE imatrix _imatrix(const imatrix &rm) throw() { return rm; }
00848         INLINE imatrix _imatrix(const ivector &v) throw() { return imatrix(v); }
00854         INLINE imatrix _imatrix(const ivector_slice &v) throw() { return imatrix(v); }
00860         INLINE imatrix _imatrix(const interval &r) throw() { return imatrix(r); }
00861         INLINE int Lb(const imatrix &rm, const int &i)
00862 #if(CXSC_INDEX_CHECK)
00863         throw(ERROR_IMATRIX_WRONG_ROW_OR_COL)
00864 #else
00865         throw()
00866 #endif
00867         { return _mlb(rm,i); }
00868         INLINE int Ub(const imatrix &rm, const int &i)
00869 #if(CXSC_INDEX_CHECK)
00870         throw(ERROR_IMATRIX_WRONG_ROW_OR_COL)
00871 #else
00872         throw()
00873 #endif
00874         { return _mub(rm,i); }
00875         INLINE int Lb(const imatrix_slice &rm, const int &i)
00876 #if(CXSC_INDEX_CHECK)
00877         throw(ERROR_IMATRIX_WRONG_ROW_OR_COL)
00878 #else
00879         throw()
00880 #endif
00881         { return _mslb(rm,i); }
00882         INLINE int Ub(const imatrix_slice &rm, const int &i)
00883 #if(CXSC_INDEX_CHECK)
00884         throw(ERROR_IMATRIX_WRONG_ROW_OR_COL)
00885 #else
00886         throw()
00887 #endif
00888         { return _msub(rm,i); }
00889         INLINE imatrix &SetLb(imatrix &m, const int &i,const int &j)
00890 #if(CXSC_INDEX_CHECK)
00891         throw(ERROR_IMATRIX_WRONG_ROW_OR_COL)
00892 #else
00893         throw()
00894 #endif
00895         { return _msetlb(m,i,j); }
00896         INLINE imatrix &SetUb(imatrix &m, const int &i,const int &j)
00897 #if(CXSC_INDEX_CHECK)
00898         throw(ERROR_IMATRIX_WRONG_ROW_OR_COL)
00899 #else
00900         throw()
00901 #endif
00902         { return _msetub(m,i,j); }
00903         
00904         INLINE int RowLen ( const imatrix& A )  // Length of the rows of a interval matrix
00905         { return Ub(A,2)-Lb(A,2)+1; }     //----------------------------------------
00906 
00907         INLINE int ColLen ( const imatrix& A )  // Length of the columns of a interval matrix
00908         { return Ub(A,1)-Lb(A,1)+1; }     //-------------------------------------------
00909 
00910         INLINE int RowLen ( const imatrix_slice& A )  // Length of the rows of a interval matrix
00911         { return Ub(A,2)-Lb(A,2)+1; }           //----------------------------------------
00912 
00913         INLINE int ColLen ( const imatrix_slice& A )  // Length of the columns of a interval matrix
00914         { return Ub(A,1)-Lb(A,1)+1; }           //-------------------------------------------
00915         
00916         INLINE void Resize(imatrix &A) throw() { _mresize(A);}
00917         INLINE void Resize(imatrix &A,const int &m, const int &n)
00918 #if(CXSC_INDEX_CHECK)
00919         throw(ERROR_IMATRIX_WRONG_BOUNDARIES)
00920 #else
00921         throw()
00922 #endif
00923         { _mresize<imatrix,interval>(A,m,n); }
00924         INLINE void Resize(imatrix &A,const int &m1, const int &m2,const int &n1,const int &n2)
00925 #if(CXSC_INDEX_CHECK)
00926         throw(ERROR_IMATRIX_WRONG_BOUNDARIES)
00927 #else
00928         throw()
00929 #endif
00930         { _mresize<imatrix,interval>(A,m1,m2,n1,n2); }
00931         INLINE imatrix abs(const imatrix &m) throw() { return _mabs<imatrix,imatrix>(m); }
00932         INLINE rmatrix absmin(const imatrix &m) throw() { 
00933            rmatrix A(Lb(m,1),Ub(m,1),Lb(m,2),Ub(m,2));
00934            for(int i=Lb(m,1) ; i<=Ub(m,1) ; i++)
00935              for(int j=Lb(m,2) ; j<=Ub(m,2) ; j++)
00936                A[i][j] = AbsMin(m[i][j]);
00937            return A;
00938         }
00939         INLINE rmatrix absmax(const imatrix &m) throw() { 
00940            rmatrix A(Lb(m,1),Ub(m,1),Lb(m,2),Ub(m,2));
00941            for(int i=Lb(m,1) ; i<=Ub(m,1) ; i++)
00942              for(int j=Lb(m,2) ; j<=Ub(m,2) ; j++)
00943                A[i][j] = AbsMax(m[i][j]);
00944            return A;
00945         }
00946         INLINE imatrix abs(const imatrix_slice &ms) throw() { return _msabs<imatrix_slice,imatrix>(ms); }
00947         INLINE rmatrix absmin(const imatrix_slice &m) throw() { 
00948            rmatrix A(Lb(m,1),Ub(m,1),Lb(m,2),Ub(m,2));
00949            for(int i=Lb(m,1) ; i<=Ub(m,1) ; i++)
00950              for(int j=Lb(m,2) ; j<=Ub(m,2) ; j++)
00951                A[i][j] = AbsMin(m[i][j]);
00952            return A;
00953         }
00954         INLINE rmatrix absmax(const imatrix_slice &m) throw() { 
00955            rmatrix A(Lb(m,1),Ub(m,1),Lb(m,2),Ub(m,2));
00956            for(int i=Lb(m,1) ; i<=Ub(m,1) ; i++)
00957              for(int j=Lb(m,2) ; j<=Ub(m,2) ; j++)
00958                A[i][j] = AbsMax(m[i][j]);
00959            return A;
00960         }
00961         INLINE rmatrix diam(const imatrix &m) throw() { return _mdiam<imatrix,rmatrix>(m); }
00962         INLINE rmatrix diam(const imatrix_slice &ms) throw() { return _msdiam<imatrix_slice,rmatrix>(ms); }
00963         INLINE rmatrix mid(const imatrix &m) throw() { return _mmid<imatrix,rmatrix>(m); }
00964         INLINE rmatrix mid(const imatrix_slice &ms) throw() { return _msmid<imatrix_slice,rmatrix>(ms); }
00965         INLINE rmatrix Inf(const imatrix &m) throw() { return _minf<imatrix,rmatrix>(m); }
00966         INLINE rmatrix Sup(const imatrix &m) throw() { return _msup<imatrix,rmatrix>(m); }
00967         INLINE rmatrix Inf(const imatrix_slice &m) throw() { return _msinf<imatrix_slice,rmatrix>(m); }
00968         INLINE rmatrix Sup(const imatrix_slice &m) throw() { return _mssup<imatrix_slice,rmatrix>(m); }
00969         INLINE imatrix &SetInf(imatrix &cm,const rmatrix &rm)
00970 #if(CXSC_INDEX_CHECK)
00971         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
00972 #else
00973         throw()
00974 #endif
00975         { return _mmsetinf<imatrix,rmatrix>(cm,rm); }
00976         INLINE imatrix_slice &SetInf(imatrix_slice &cm,const rmatrix &rm)
00977 #if(CXSC_INDEX_CHECK)
00978         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
00979 #else
00980         throw()
00981 #endif
00982         { return _msmsetinf<imatrix_slice,rmatrix>(cm,rm); }
00983         INLINE imatrix &SetInf(imatrix &cm,const rmatrix_slice &rm)
00984 #if(CXSC_INDEX_CHECK)
00985         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
00986 #else
00987         throw()
00988 #endif
00989         { return _mmssetinf<imatrix,rmatrix_slice>(cm,rm); }
00990         INLINE imatrix_slice &SetInf(imatrix_slice &cm,const rmatrix_slice &rm)
00991 #if(CXSC_INDEX_CHECK)
00992         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
00993 #else
00994         throw()
00995 #endif
00996         { return _msmssetinf<imatrix_slice,rmatrix_slice>(cm,rm); }
00997         INLINE imatrix &SetSup(imatrix &cm,const rmatrix &rm)
00998 #if(CXSC_INDEX_CHECK)
00999         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01000 #else
01001         throw()
01002 #endif
01003         { return _mmsetsup<imatrix,rmatrix>(cm,rm); }
01004         INLINE imatrix_slice &SetSup(imatrix_slice &cm,const rmatrix &rm)
01005 #if(CXSC_INDEX_CHECK)
01006         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01007 #else
01008         throw()
01009 #endif
01010         { return _msmsetsup<imatrix_slice,rmatrix>(cm,rm); }
01011         INLINE imatrix &SetSup(imatrix &cm,const rmatrix_slice &rm)
01012 #if(CXSC_INDEX_CHECK)
01013         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01014 #else
01015         throw()
01016 #endif
01017         { return _mmssetsup<imatrix,rmatrix_slice>(cm,rm); }
01018         INLINE imatrix_slice &SetSup(imatrix_slice &cm,const rmatrix_slice &rm)
01019 #if(CXSC_INDEX_CHECK)
01020         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01021 #else
01022         throw()
01023 #endif
01024         { return _msmssetsup<imatrix_slice,rmatrix_slice>(cm,rm); }
01025         INLINE imatrix &UncheckedSetInf(imatrix &cm,const rmatrix &rm)
01026 #if(CXSC_INDEX_CHECK)
01027         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01028 #else
01029         throw()
01030 #endif
01031         { return _mmusetinf<imatrix,rmatrix>(cm,rm); }
01032         INLINE imatrix_slice &UncheckedSetInf(imatrix_slice &cm,const rmatrix &rm)
01033 #if(CXSC_INDEX_CHECK)
01034         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01035 #else
01036         throw()
01037 #endif
01038         { return _msmusetinf<imatrix_slice,rmatrix>(cm,rm); }
01039         INLINE imatrix &UncheckedSetInf(imatrix &cm,const rmatrix_slice &rm)
01040 #if(CXSC_INDEX_CHECK)
01041         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01042 #else
01043         throw()
01044 #endif
01045         { return _mmsusetinf<imatrix,rmatrix_slice>(cm,rm); }
01046         INLINE imatrix_slice &UncheckedSetInf(imatrix_slice &cm,const rmatrix_slice &rm)
01047 #if(CXSC_INDEX_CHECK)
01048         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01049 #else
01050         throw()
01051 #endif
01052         { return _msmsusetinf<imatrix_slice,rmatrix_slice>(cm,rm); }
01053         INLINE imatrix &UncheckedSetSup(imatrix &cm,const rmatrix &rm)
01054 #if(CXSC_INDEX_CHECK)
01055         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01056 #else
01057         throw()
01058 #endif
01059         { return _mmusetsup<imatrix,rmatrix>(cm,rm); }
01060         INLINE imatrix_slice &UncheckedSetSup(imatrix_slice &cm,const rmatrix &rm)
01061 #if(CXSC_INDEX_CHECK)
01062         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01063 #else
01064         throw()
01065 #endif
01066         { return _msmusetsup<imatrix_slice,rmatrix>(cm,rm); }
01067         INLINE imatrix &UncheckedSetSup(imatrix &cm,const rmatrix_slice &rm)
01068 #if(CXSC_INDEX_CHECK)
01069         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01070 #else
01071         throw()
01072 #endif
01073         { return _mmsusetsup<imatrix,rmatrix_slice>(cm,rm); }
01074         INLINE imatrix_slice &UncheckedSetSup(imatrix_slice &cm,const rmatrix_slice &rm)
01075 #if(CXSC_INDEX_CHECK)
01076         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01077 #else
01078         throw()
01079 #endif
01080         { return _msmsusetsup<imatrix_slice,rmatrix_slice>(cm,rm); }
01081         INLINE interval::interval(const imatrix &m)
01082 #if(CXSC_INDEX_CHECK)
01083         throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ,ERROR_IMATRIX_USE_OF_UNINITIALIZED_OBJ)
01084 #else
01085         throw()
01086 #endif
01087         { _smconstr(*this,m); }
01088 //      INLINE interval interval::_interval(const imatrix &m) throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ,ERROR_IMATRIX_USE_OF_UNINITIALIZED_OBJ) { _smconstr(*this,m); return *this; }
01089         INLINE imatrix operator *(const interval &c, const imatrix &m) throw() { return _smmult<interval,imatrix,imatrix>(c,m); }
01090         INLINE imatrix operator *(const interval &c, const imatrix_slice &ms) throw() { return _smsmult<interval,imatrix_slice,imatrix>(c,ms); }
01091         INLINE imatrix operator *(const imatrix &m,const interval &c) throw() { return _smmult<interval,imatrix,imatrix>(c,m); }
01092         INLINE imatrix operator *(const imatrix_slice &ms,const interval &c) throw() { return _smsmult<interval,imatrix_slice,imatrix>(c,ms); }
01093         INLINE imatrix &operator *=(imatrix &m,const interval &c) throw() { return _msmultassign(m,c); }
01094         INLINE imatrix_slice &imatrix_slice::operator *=(const imatrix &m)
01095 #if(CXSC_INDEX_CHECK)
01096         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01097 #else
01098         throw()
01099 #endif
01100         { return (*this=*this*m); }
01101         INLINE imatrix_slice &imatrix_slice::operator *=(const imatrix_slice &m)
01102 #if(CXSC_INDEX_CHECK)
01103         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01104 #else
01105         throw()
01106 #endif
01107         { return (*this=*this*m); }
01108         INLINE imatrix_slice &imatrix_slice::operator *=(const interval &c) throw() { return _mssmultassign(*this,c); }
01109         INLINE imatrix operator /(const imatrix &m,const interval &c) throw() { return _msdiv<imatrix,interval,imatrix>(m,c); }
01110         INLINE imatrix operator /(const imatrix_slice &ms, const interval &c) throw() { return _mssdiv<imatrix_slice,interval,imatrix>(ms,c); }
01111         INLINE imatrix &operator /=(imatrix &m,const interval &c) throw() { return _msdivassign(m,c); }
01112         INLINE imatrix_slice &imatrix_slice::operator /=(const interval &c) throw() { return _mssdivassign(*this,c); }
01113         INLINE imatrix operator *(const real &c, const imatrix &m) throw() { return _smmult<real,imatrix,imatrix>(c,m); }
01114         INLINE imatrix operator *(const real &c, const imatrix_slice &ms) throw() { return _smsmult<real,imatrix_slice,imatrix>(c,ms); }
01115         INLINE imatrix operator *(const imatrix &m,const real &c) throw() { return _smmult<real,imatrix,imatrix>(c,m); }
01116         INLINE imatrix operator *(const imatrix_slice &ms,const real &c) throw() { return _smsmult<real,imatrix_slice,imatrix>(c,ms); }
01117         INLINE imatrix &operator *=(imatrix &m,const real &c) throw() { return _msmultassign(m,c); }
01118         INLINE imatrix_slice &imatrix_slice::operator *=(const rmatrix &m)
01119 #if(CXSC_INDEX_CHECK)
01120         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01121 #else
01122         throw()
01123 #endif
01124         { return (*this=*this*m); }
01125         INLINE imatrix_slice &imatrix_slice::operator *=(const rmatrix_slice &m)
01126 #if(CXSC_INDEX_CHECK)
01127         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01128 #else
01129         throw()
01130 #endif
01131         { return (*this=*this*m); }
01132         INLINE imatrix_slice &imatrix_slice::operator *=(const real &c) throw() { return _mssmultassign(*this,c); }
01133         INLINE imatrix operator /(const imatrix &m,const real &c) throw() { return _msdiv<imatrix,real,imatrix>(m,c); }
01134         INLINE imatrix operator /(const imatrix_slice &ms, const real &c) throw() { return _mssdiv<imatrix_slice,real,imatrix>(ms,c); }
01135         INLINE imatrix &operator /=(imatrix &m,const real &c) throw() { return _msdivassign(m,c); }
01136         INLINE imatrix_slice &imatrix_slice::operator /=(const real &c) throw() { return _mssdivassign(*this,c); }
01137 //      INLINE interval::interval(const rmatrix &m) throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ,ERROR_IMATRIX_USE_OF_UNINITIALIZED_OBJ) { _smconstr(*this,m); }
01138 //      INLINE interval interval::_interval(const imatrix &m) throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ,ERROR_IMATRIX_USE_OF_UNINITIALIZED_OBJ) { _smconstr(*this,m); return *this; }
01139         INLINE imatrix operator *(const interval &c, const rmatrix &m) throw() { return _smmult<interval,rmatrix,imatrix>(c,m); }
01140         INLINE imatrix operator *(const interval &c, const rmatrix_slice &ms) throw() { return _smsmult<interval,rmatrix_slice,imatrix>(c,ms); }
01141         INLINE imatrix operator *(const rmatrix &m,const interval &c) throw() { return _smmult<interval,rmatrix,imatrix>(c,m); }
01142         INLINE imatrix operator *(const rmatrix_slice &ms,const interval &c) throw() { return _smsmult<interval,rmatrix_slice,imatrix>(c,ms); }
01143         INLINE imatrix operator /(const rmatrix &m,const interval &c) throw() { return _msdiv<rmatrix,interval,imatrix>(m,c); }
01144         INLINE imatrix operator /(const rmatrix_slice &ms, const interval &c) throw() { return _mssdiv<rmatrix_slice,interval,imatrix>(ms,c); }
01145         INLINE ivector::ivector(const imatrix &sl)
01146 #if(CXSC_INDEX_CHECK)
01147         throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ)
01148 #else
01149         throw()
01150 #endif
01151         { _vmconstr<ivector,imatrix,interval>(*this,sl); }
01152         INLINE ivector::ivector(const imatrix_slice &sl)
01153 #if(CXSC_INDEX_CHECK)
01154         throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ)
01155 #else
01156         throw()
01157 #endif
01158         { _vmsconstr<ivector,imatrix_slice,interval>(*this,sl); }
01159         INLINE ivector &ivector::operator =(const imatrix &m)
01160 #if(CXSC_INDEX_CHECK)
01161         throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ)
01162 #else
01163         throw()
01164 #endif
01165         { return _vmassign<ivector,imatrix,interval>(*this,m); }
01166         INLINE ivector &ivector::operator =(const imatrix_slice &m)
01167 #if(CXSC_INDEX_CHECK)
01168         throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ)
01169 #else
01170         throw()
01171 #endif
01172         { return _vmassign<ivector,imatrix,interval>(*this,imatrix(m)); }
01173         INLINE ivector_slice & ivector_slice::operator =(const imatrix_slice &m)
01174 #if(CXSC_INDEX_CHECK)
01175         throw(ERROR__OP_WITH_WRONG_DIM<ivector>,ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ)
01176 #else
01177         throw()
01178 #endif
01179         { return _vsvassign(*this,ivector(imatrix(m))); }
01180         INLINE imatrix_subv &imatrix_subv::operator =(const imatrix &m)
01181 #if(CXSC_INDEX_CHECK)
01182         throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ)
01183 #else
01184         throw()
01185 #endif
01186         { return _mvvassign(*this,ivector(m)); }
01187         INLINE imatrix_subv &imatrix_subv::operator =(const imatrix_slice &m)
01188 #if(CXSC_INDEX_CHECK)
01189         throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ)
01190 #else
01191         throw()
01192 #endif
01193         { return _mvvassign(*this,ivector(imatrix(m))); }
01194         INLINE ivector operator *(const imatrix &m,const ivector &v)
01195 #if(CXSC_INDEX_CHECK)
01196         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01197 #else
01198         throw()
01199 #endif
01200         { return _mvimult<imatrix,ivector,ivector>(m,v); }
01201         INLINE ivector operator *(const imatrix_slice &ms,const ivector &v)
01202 #if(CXSC_INDEX_CHECK)
01203         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01204 #else
01205         throw()
01206 #endif
01207         { return _msvimult<imatrix_slice,ivector,ivector>(ms,v); }
01208         INLINE ivector operator *(const ivector &v,const imatrix &m)
01209 #if(CXSC_INDEX_CHECK)
01210         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01211 #else
01212         throw()
01213 #endif
01214         { return _vmimult<ivector,imatrix,ivector>(v,m); }
01215         INLINE ivector operator *(const ivector &v,const imatrix_slice &ms)
01216 #if(CXSC_INDEX_CHECK)
01217         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01218 #else
01219         throw()
01220 #endif
01221         { return _vmsimult<ivector,imatrix_slice,ivector>(v,ms); }
01222         INLINE ivector &operator *=(ivector &v,const imatrix &m)
01223 #if(CXSC_INDEX_CHECK)
01224         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01225 #else
01226         throw()
01227 #endif
01228         { return _vmimultassign<ivector,imatrix,interval>(v,m); }
01229         INLINE ivector &operator *=(ivector &v,const imatrix_slice &ms)
01230 #if(CXSC_INDEX_CHECK)
01231         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01232 #else
01233         throw()
01234 #endif
01235         { return _vmsimultassign<ivector,imatrix_slice,interval>(v,ms); }
01236         INLINE ivector_slice &ivector_slice::operator *=(const imatrix &m)
01237 #if(CXSC_INDEX_CHECK)
01238         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01239 #else
01240         throw()
01241 #endif
01242         { return _vsmimultassign<ivector_slice,imatrix,interval>(*this,m); }
01243         INLINE ivector operator *(const ivector_slice &v,const imatrix &m)
01244 #if(CXSC_INDEX_CHECK)
01245         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01246 #else
01247         throw()
01248 #endif
01249         { return _vmimult<ivector,imatrix,ivector>(ivector(v),m); }
01250         INLINE ivector operator *(const ivector_slice &v,const imatrix_slice &m)
01251 #if(CXSC_INDEX_CHECK)
01252         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01253 #else
01254         throw()
01255 #endif
01256         { return _vmsimult<ivector,imatrix_slice,ivector>(ivector(v),m); }
01257         INLINE imatrix_subv &imatrix_subv::operator =(const rmatrix &m)
01258 #if(CXSC_INDEX_CHECK)
01259         throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ)
01260 #else
01261         throw()
01262 #endif
01263         { return _mvvassign(*this,rvector(m)); }
01264         INLINE imatrix_subv &imatrix_subv::operator =(const rmatrix_slice &m)
01265 #if(CXSC_INDEX_CHECK)
01266         throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ)
01267 #else
01268         throw()
01269 #endif
01270         { return _mvvassign(*this,rvector(rmatrix(m))); }
01271         INLINE ivector operator *(const rvector &v,const imatrix &m)
01272 #if(CXSC_INDEX_CHECK)
01273         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01274 #else
01275         throw()
01276 #endif
01277         { return _vmimult<rvector,imatrix,ivector>(v,m); }
01278         INLINE ivector operator *(const rvector &v,const imatrix_slice &ms)
01279 #if(CXSC_INDEX_CHECK)
01280         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01281 #else
01282         throw()
01283 #endif
01284         { return _vmsimult<rvector,imatrix_slice,ivector>(v,ms); }
01285         INLINE ivector operator *(const rvector_slice &v,const imatrix &m)
01286 #if(CXSC_INDEX_CHECK)
01287         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01288 #else
01289         throw()
01290 #endif
01291         { return _vmimult<ivector,imatrix,ivector>(ivector(v),m); }
01292         INLINE ivector operator *(const imatrix &m,const rvector &v)
01293 #if(CXSC_INDEX_CHECK)
01294         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01295 #else
01296         throw()
01297 #endif
01298         { return _mvimult<imatrix,rvector,ivector>(m,v); }
01299         INLINE ivector operator *(const imatrix_slice &ms,const rvector &v)
01300 #if(CXSC_INDEX_CHECK)
01301         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01302 #else
01303         throw()
01304 #endif
01305         { return _msvimult<imatrix_slice,rvector,ivector>(ms,v); }
01306 
01307 
01308         INLINE const imatrix &operator +(const imatrix &m1) throw() { return m1; }
01309         INLINE imatrix operator +(const imatrix_slice &ms) throw() { return imatrix(ms); }
01310         INLINE imatrix operator +(const imatrix &m1,const imatrix &m2)
01311 #if(CXSC_INDEX_CHECK)
01312         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01313 #else
01314         throw()
01315 #endif
01316         { return _mmplus<imatrix,imatrix,imatrix>(m1,m2); }
01317         INLINE imatrix operator +(const imatrix &m,const imatrix_slice &ms)
01318 #if(CXSC_INDEX_CHECK)
01319         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01320 #else
01321         throw()
01322 #endif
01323         { return _mmsplus<imatrix,imatrix_slice,imatrix>(m,ms); }
01324         INLINE imatrix operator +(const imatrix_slice &ms,const imatrix &m)
01325 #if(CXSC_INDEX_CHECK)
01326         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01327 #else
01328         throw()
01329 #endif
01330         { return _mmsplus<imatrix,imatrix_slice,imatrix>(m,ms); }
01331         INLINE imatrix operator +(const imatrix_slice &m1,const imatrix_slice &m2)
01332 #if(CXSC_INDEX_CHECK)
01333         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01334 #else
01335         throw()
01336 #endif
01337         { return _msmsplus<imatrix_slice,imatrix_slice,imatrix>(m1,m2); }
01338         INLINE imatrix &operator +=(imatrix &m1,const imatrix &m2)
01339 #if(CXSC_INDEX_CHECK)
01340         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01341 #else
01342         throw()
01343 #endif
01344         { return _mmplusassign(m1,m2); }
01345         INLINE imatrix &operator +=(imatrix &m1,const imatrix_slice &ms)
01346 #if(CXSC_INDEX_CHECK)
01347         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01348 #else
01349         throw()
01350 #endif
01351         { return _mmsplusassign(m1,ms); }
01352         INLINE imatrix_slice &imatrix_slice::operator +=(const imatrix &m1)
01353 #if(CXSC_INDEX_CHECK)
01354         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01355 #else
01356         throw()
01357 #endif
01358         { return _msmplusassign(*this,m1); }
01359         INLINE imatrix_slice &imatrix_slice::operator +=(const imatrix_slice &ms2)
01360 #if(CXSC_INDEX_CHECK)
01361         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01362 #else
01363         throw()
01364 #endif
01365         { return _msmsplusassign(*this,ms2); }
01366         INLINE imatrix operator -(const imatrix &m) throw() { return _mminus(m); }
01367         INLINE imatrix operator -(const imatrix_slice &ms) throw() { return _msminus<imatrix_slice,imatrix>(ms); }
01368         INLINE imatrix operator -(const imatrix &m1,const imatrix &m2)
01369 #if(CXSC_INDEX_CHECK)
01370         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01371 #else
01372         throw()
01373 #endif
01374         { return _mmminus<imatrix,imatrix,imatrix>(m1,m2); }
01375         INLINE imatrix operator -(const imatrix &m,const imatrix_slice &ms)
01376 #if(CXSC_INDEX_CHECK)
01377         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01378 #else
01379         throw()
01380 #endif
01381         { return _mmsminus<imatrix,imatrix_slice,imatrix>(m,ms); }
01382         INLINE imatrix operator -(const imatrix_slice &ms,const imatrix &m)
01383 #if(CXSC_INDEX_CHECK)
01384         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01385 #else
01386         throw()
01387 #endif
01388         { return _msmminus<imatrix_slice,imatrix,imatrix>(ms,m); }
01389         INLINE imatrix operator -(const imatrix_slice &ms1,const imatrix_slice &ms2)
01390 #if(CXSC_INDEX_CHECK)
01391         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01392 #else
01393         throw()
01394 #endif
01395         { return _msmsminus<imatrix_slice,imatrix_slice,imatrix>(ms1,ms2); }
01396         INLINE imatrix &operator -=(imatrix &m1,const imatrix &m2)
01397 #if(CXSC_INDEX_CHECK)
01398         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01399 #else
01400         throw()
01401 #endif
01402         { return _mmminusassign(m1,m2); }
01403         INLINE imatrix &operator -=(imatrix &m1,const imatrix_slice &ms)
01404 #if(CXSC_INDEX_CHECK)
01405         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01406 #else
01407         throw()
01408 #endif
01409         { return _mmsminusassign(m1,ms); }
01410         INLINE imatrix_slice &imatrix_slice::operator -=(const imatrix &m1)
01411 #if(CXSC_INDEX_CHECK)
01412         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01413 #else
01414         throw()
01415 #endif
01416         { return _msmminusassign(*this,m1); }
01417         INLINE imatrix_slice &imatrix_slice::operator -=(const imatrix_slice &ms2)
01418 #if(CXSC_INDEX_CHECK)
01419         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01420 #else
01421         throw()
01422 #endif
01423         { return _msmsminusassign(*this,ms2); }
01424         INLINE imatrix operator *(const imatrix &m1, const imatrix &m2)
01425 #if(CXSC_INDEX_CHECK)
01426         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01427 #else
01428         throw()
01429 #endif
01430         { return _mmimult<imatrix,imatrix,imatrix>(m1,m2); }
01431         INLINE imatrix operator *(const imatrix &m1, const imatrix_slice &ms)
01432 #if(CXSC_INDEX_CHECK)
01433         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01434 #else
01435         throw()
01436 #endif
01437         { return _mmsimult<imatrix,imatrix_slice,imatrix>(m1,ms); }
01438         INLINE imatrix operator *(const imatrix_slice &ms, const imatrix &m1)
01439 #if(CXSC_INDEX_CHECK)
01440         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01441 #else
01442         throw()
01443 #endif
01444         { return _msmimult<imatrix_slice,imatrix,imatrix>(ms,m1); }
01445         INLINE imatrix operator *(const imatrix_slice &ms1, const imatrix_slice &ms2)
01446 #if(CXSC_INDEX_CHECK)
01447         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01448 #else
01449         throw()
01450 #endif
01451         { return _msmsimult<imatrix_slice,imatrix_slice,imatrix>(ms1,ms2); }
01452         INLINE imatrix &operator *=(imatrix &m1,const imatrix &m2)
01453 #if(CXSC_INDEX_CHECK)
01454         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01455 #else
01456         throw()
01457 #endif
01458         { return _mmimultassign<imatrix,imatrix,interval>(m1,m2); }
01459         INLINE imatrix &operator *=(imatrix &m1,const imatrix_slice &ms)
01460 #if(CXSC_INDEX_CHECK)
01461         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01462 #else
01463         throw()
01464 #endif
01465         { return _mmsimultassign<imatrix,imatrix_slice,interval>(m1,ms); }
01466         INLINE imatrix operator |(const imatrix &m1,const imatrix &m2)
01467 #if(CXSC_INDEX_CHECK)
01468         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01469 #else
01470         throw()
01471 #endif
01472         { return _mmconv<imatrix,imatrix,imatrix>(m1,m2); }
01473         INLINE imatrix operator |(const imatrix &m,const imatrix_slice &ms)
01474 #if(CXSC_INDEX_CHECK)
01475         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01476 #else
01477         throw()
01478 #endif
01479         { return _mmsconv<imatrix,imatrix_slice,imatrix>(m,ms); }
01480         INLINE imatrix operator |(const imatrix_slice &ms,const imatrix &m)
01481 #if(CXSC_INDEX_CHECK)
01482         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01483 #else
01484         throw()
01485 #endif
01486         { return _mmsconv<imatrix,imatrix_slice,imatrix>(m,ms); }
01487         INLINE imatrix operator |(const imatrix_slice &m1,const imatrix_slice &m2)
01488 #if(CXSC_INDEX_CHECK)
01489         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01490 #else
01491         throw()
01492 #endif
01493         { return _msmsconv<imatrix_slice,imatrix_slice,imatrix>(m1,m2); }
01494         INLINE imatrix &operator |=(imatrix &m1,const imatrix &m2)
01495 #if(CXSC_INDEX_CHECK)
01496         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01497 #else
01498         throw()
01499 #endif
01500         { return _mmconvassign(m1,m2); }
01501         INLINE imatrix &operator |=(imatrix &m1,const imatrix_slice &ms)
01502 #if(CXSC_INDEX_CHECK)
01503         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01504 #else
01505         throw()
01506 #endif
01507         { return _mmsconvassign(m1,ms); }
01508         INLINE imatrix_slice &imatrix_slice::operator |=(const imatrix &m1)
01509 #if(CXSC_INDEX_CHECK)
01510         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01511 #else
01512         throw()
01513 #endif
01514         { return _msmconvassign(*this,m1); }
01515         INLINE imatrix_slice &imatrix_slice::operator |=(const imatrix_slice &ms2)
01516 #if(CXSC_INDEX_CHECK)
01517         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01518 #else
01519         throw()
01520 #endif
01521         { return _msmsconvassign(*this,ms2); }
01522         INLINE imatrix operator &(const imatrix &m1,const imatrix &m2)
01523 #if(CXSC_INDEX_CHECK)
01524         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01525 #else
01526         throw()
01527 #endif
01528         { return _mmsect<imatrix,imatrix,imatrix>(m1,m2); }
01529         INLINE imatrix operator &(const imatrix &m,const imatrix_slice &ms)
01530 #if(CXSC_INDEX_CHECK)
01531         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01532 #else
01533         throw()
01534 #endif
01535         { return _mmssect<imatrix,imatrix_slice,imatrix>(m,ms); }
01536         INLINE imatrix operator &(const imatrix_slice &ms,const imatrix &m)
01537 #if(CXSC_INDEX_CHECK)
01538         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01539 #else
01540         throw()
01541 #endif
01542         { return _mmssect<imatrix,imatrix_slice,imatrix>(m,ms); }
01543         INLINE imatrix operator &(const imatrix_slice &m1,const imatrix_slice &m2)
01544 #if(CXSC_INDEX_CHECK)
01545         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01546 #else
01547         throw()
01548 #endif
01549         { return _msmssect<imatrix_slice,imatrix_slice,imatrix>(m1,m2); }
01550         INLINE imatrix &operator &=(imatrix &m1,const imatrix &m2)
01551 #if(CXSC_INDEX_CHECK)
01552         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01553 #else
01554         throw()
01555 #endif
01556         { return _mmsectassign(m1,m2); }
01557         INLINE imatrix &operator &=(imatrix &m1,const imatrix_slice &ms)
01558 #if(CXSC_INDEX_CHECK)
01559         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01560 #else
01561         throw()
01562 #endif
01563         { return _mmssectassign(m1,ms); }
01564         INLINE imatrix_slice &imatrix_slice::operator &=(const imatrix &m1)
01565 #if(CXSC_INDEX_CHECK)
01566         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01567 #else
01568         throw()
01569 #endif
01570         { return _msmsectassign(*this,m1); }
01571         INLINE imatrix_slice &imatrix_slice::operator &=(const imatrix_slice &ms2)
01572 #if(CXSC_INDEX_CHECK)
01573         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01574 #else
01575         throw()
01576 #endif
01577         { return _msmssectassign(*this,ms2); }
01578         INLINE imatrix operator +(const rmatrix &m1,const imatrix &m2)
01579 #if(CXSC_INDEX_CHECK)
01580         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01581 #else
01582         throw()
01583 #endif
01584         { return _mmplus<rmatrix,imatrix,imatrix>(m1,m2); }
01585         INLINE imatrix operator +(const imatrix &m1,const rmatrix &m2)
01586 #if(CXSC_INDEX_CHECK)
01587         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01588 #else
01589         throw()
01590 #endif
01591         { return _mmplus<rmatrix,imatrix,imatrix>(m2,m1); }
01592         INLINE imatrix operator +(const rmatrix &m,const imatrix_slice &ms)
01593 #if(CXSC_INDEX_CHECK)
01594         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01595 #else
01596         throw()
01597 #endif
01598         { return _mmsplus<rmatrix,imatrix_slice,imatrix>(m,ms); }
01599         INLINE imatrix operator +(const imatrix &m,const rmatrix_slice &ms)
01600 #if(CXSC_INDEX_CHECK)
01601         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01602 #else
01603         throw()
01604 #endif
01605         { return _mmsplus<imatrix,rmatrix_slice,imatrix>(m,ms); }
01606         INLINE imatrix operator +(const rmatrix_slice &ms,const imatrix &m)
01607 #if(CXSC_INDEX_CHECK)
01608         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01609 #else
01610         throw()
01611 #endif
01612         { return _mmsplus<imatrix,rmatrix_slice,imatrix>(m,ms); }
01613         INLINE imatrix operator +(const imatrix_slice &ms,const rmatrix &m)
01614 #if(CXSC_INDEX_CHECK)
01615         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01616 #else
01617         throw()
01618 #endif
01619         { return _mmsplus<rmatrix,imatrix_slice,imatrix>(m,ms); }
01620         INLINE imatrix operator +(const rmatrix_slice &m1,const imatrix_slice &m2)
01621 #if(CXSC_INDEX_CHECK)
01622         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01623 #else
01624         throw()
01625 #endif
01626         { return _msmsplus<rmatrix_slice,imatrix_slice,imatrix>(m1,m2); }
01627         INLINE imatrix operator +(const imatrix_slice &m1,const rmatrix_slice &m2)
01628 #if(CXSC_INDEX_CHECK)
01629         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01630 #else
01631         throw()
01632 #endif
01633         { return _msmsplus<rmatrix_slice,imatrix_slice,imatrix>(m2,m1); }
01634         INLINE imatrix &operator +=(imatrix &m1,const rmatrix &m2)
01635 #if(CXSC_INDEX_CHECK)
01636         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01637 #else
01638         throw()
01639 #endif
01640         { return _mmplusassign(m1,m2); }
01641         INLINE imatrix &operator +=(imatrix &m1,const rmatrix_slice &ms)
01642 #if(CXSC_INDEX_CHECK)
01643         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01644 #else
01645         throw()
01646 #endif
01647         { return _mmsplusassign(m1,ms); }
01648         INLINE imatrix_slice &imatrix_slice::operator +=(const rmatrix &m1)
01649 #if(CXSC_INDEX_CHECK)
01650         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01651 #else
01652         throw()
01653 #endif
01654         { return _msmplusassign(*this,m1); }
01655         INLINE imatrix_slice &imatrix_slice::operator +=(const rmatrix_slice &ms2)
01656 #if(CXSC_INDEX_CHECK)
01657         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01658 #else
01659         throw()
01660 #endif
01661         { return _msmsplusassign(*this,ms2); }
01662         INLINE imatrix operator -(const rmatrix &m1,const imatrix &m2)
01663 #if(CXSC_INDEX_CHECK)
01664         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01665 #else
01666         throw()
01667 #endif
01668         { return _mmminus<rmatrix,imatrix,imatrix>(m1,m2); }
01669         INLINE imatrix operator -(const imatrix &m1,const rmatrix &m2)
01670 #if(CXSC_INDEX_CHECK)
01671         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01672 #else
01673         throw()
01674 #endif
01675         { return _mmminus<imatrix,rmatrix,imatrix>(m1,m2); }
01676         INLINE imatrix operator -(const rmatrix &m,const imatrix_slice &ms)
01677 #if(CXSC_INDEX_CHECK)
01678         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01679 #else
01680         throw()
01681 #endif
01682         { return _mmsminus<rmatrix,imatrix_slice,imatrix>(m,ms); }
01683         INLINE imatrix operator -(const imatrix &m,const rmatrix_slice &ms)
01684 #if(CXSC_INDEX_CHECK)
01685         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01686 #else
01687         throw()
01688 #endif
01689         { return _mmsminus<imatrix,rmatrix_slice,imatrix>(m,ms); }
01690         INLINE imatrix operator -(const rmatrix_slice &ms,const imatrix &m)
01691 #if(CXSC_INDEX_CHECK)
01692         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01693 #else
01694         throw()
01695 #endif
01696         { return _msmminus<rmatrix_slice,imatrix,imatrix>(ms,m); }
01697         INLINE imatrix operator -(const imatrix_slice &ms,const rmatrix &m)
01698 #if(CXSC_INDEX_CHECK)
01699         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01700 #else
01701         throw()
01702 #endif
01703         { return _msmminus<imatrix_slice,rmatrix,imatrix>(ms,m); }
01704         INLINE imatrix operator -(const rmatrix_slice &ms1,const imatrix_slice &ms2)
01705 #if(CXSC_INDEX_CHECK)
01706         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01707 #else
01708         throw()
01709 #endif
01710         { return _msmsminus<rmatrix_slice,imatrix_slice,imatrix>(ms1,ms2); }
01711         INLINE imatrix operator -(const imatrix_slice &ms1,const rmatrix_slice &ms2)
01712 #if(CXSC_INDEX_CHECK)
01713         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01714 #else
01715         throw()
01716 #endif
01717         { return _msmsminus<imatrix_slice,rmatrix_slice,imatrix>(ms1,ms2); }
01718         INLINE imatrix &operator -=(imatrix &m1,const rmatrix &m2)
01719 #if(CXSC_INDEX_CHECK)
01720         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01721 #else
01722         throw()
01723 #endif
01724         { return _mmminusassign(m1,m2); }
01725         INLINE imatrix &operator -=(imatrix &m1,const rmatrix_slice &ms)
01726 #if(CXSC_INDEX_CHECK)
01727         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01728 #else
01729         throw()
01730 #endif
01731         { return _mmsminusassign(m1,ms); }
01732         INLINE imatrix_slice &imatrix_slice::operator -=(const rmatrix &m1)
01733 #if(CXSC_INDEX_CHECK)
01734         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01735 #else
01736         throw()
01737 #endif
01738         { return _msmminusassign(*this,m1); }
01739         INLINE imatrix_slice &imatrix_slice::operator -=(const rmatrix_slice &ms2)
01740 #if(CXSC_INDEX_CHECK)
01741         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01742 #else
01743         throw()
01744 #endif
01745         { return _msmsminusassign(*this,ms2); }
01746         INLINE imatrix operator *(const rmatrix &m1, const imatrix &m2)
01747 #if(CXSC_INDEX_CHECK)
01748         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01749 #else
01750         throw()
01751 #endif
01752         { return _mmimult<rmatrix,imatrix,imatrix>(m1,m2); }
01753         INLINE imatrix operator *(const imatrix &m1, const rmatrix &m2)
01754 #if(CXSC_INDEX_CHECK)
01755         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01756 #else
01757         throw()
01758 #endif
01759         { return _mmimult<imatrix,rmatrix,imatrix>(m1,m2); }
01760         INLINE imatrix operator *(const rmatrix &m1, const imatrix_slice &ms)
01761 #if(CXSC_INDEX_CHECK)
01762         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01763 #else
01764         throw()
01765 #endif
01766         { return _mmsimult<rmatrix,imatrix_slice,imatrix>(m1,ms); }
01767         INLINE imatrix operator *(const imatrix &m1, const rmatrix_slice &ms)
01768 #if(CXSC_INDEX_CHECK)
01769         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01770 #else
01771         throw()
01772 #endif
01773         { return _mmsimult<imatrix,rmatrix_slice,imatrix>(m1,ms); }
01774         INLINE imatrix operator *(const rmatrix_slice &ms, const imatrix &m1)
01775 #if(CXSC_INDEX_CHECK)
01776         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01777 #else
01778         throw()
01779 #endif
01780         { return _msmimult<rmatrix_slice,imatrix,imatrix>(ms,m1); }
01781         INLINE imatrix operator *(const imatrix_slice &ms, const rmatrix &m1)
01782 #if(CXSC_INDEX_CHECK)
01783         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01784 #else
01785         throw()
01786 #endif
01787         { return _msmimult<imatrix_slice,rmatrix,imatrix>(ms,m1); }
01788         INLINE imatrix operator *(const rmatrix_slice &ms1, const imatrix_slice &ms2)
01789 #if(CXSC_INDEX_CHECK)
01790         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01791 #else
01792         throw()
01793 #endif
01794         { return _msmsimult<rmatrix_slice,imatrix_slice,imatrix>(ms1,ms2); }
01795         INLINE imatrix operator *(const imatrix_slice &ms1, const rmatrix_slice &ms2)
01796 #if(CXSC_INDEX_CHECK)
01797         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01798 #else
01799         throw()
01800 #endif
01801         { return _msmsimult<imatrix_slice,rmatrix_slice,imatrix>(ms1,ms2); }
01802         INLINE imatrix &operator *=(imatrix &m1,const rmatrix &m2)
01803 #if(CXSC_INDEX_CHECK)
01804         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01805 #else
01806         throw()
01807 #endif
01808         { return _mmimultassign<imatrix,rmatrix,interval>(m1,m2); }
01809         INLINE imatrix &operator *=(imatrix &m1,const rmatrix_slice &ms)
01810 #if(CXSC_INDEX_CHECK)
01811         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01812 #else
01813         throw()
01814 #endif
01815         { return _mmsimultassign<imatrix,rmatrix_slice,interval>(m1,ms); }
01816         INLINE imatrix operator |(const rmatrix &m1,const rmatrix &m2)
01817 #if(CXSC_INDEX_CHECK)
01818         throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM)
01819 #else
01820         throw()
01821 #endif
01822         { return _mmconv<rmatrix,rmatrix,imatrix>(m1,m2); }
01823         INLINE imatrix operator |(const rmatrix &m,const rmatrix_slice &ms)
01824 #if(CXSC_INDEX_CHECK)
01825         throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM)
01826 #else
01827         throw()
01828 #endif
01829         { return _mmsconv<rmatrix,rmatrix_slice,imatrix>(m,ms); }
01830         INLINE imatrix operator |(const rmatrix_slice &ms,const rmatrix &m)
01831 #if(CXSC_INDEX_CHECK)
01832         throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM)
01833 #else
01834         throw()
01835 #endif
01836         { return _mmsconv<rmatrix,rmatrix_slice,imatrix>(m,ms); }
01837         INLINE imatrix operator |(const rmatrix_slice &m1,const rmatrix_slice &m2)
01838 #if(CXSC_INDEX_CHECK)
01839         throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM)
01840 #else
01841         throw()
01842 #endif
01843         { return _msmsconv<rmatrix_slice,rmatrix_slice,imatrix>(m1,m2); }
01844         INLINE imatrix operator |(const rmatrix &m1,const imatrix &m2)
01845 #if(CXSC_INDEX_CHECK)
01846         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01847 #else
01848         throw()
01849 #endif
01850         { return _mmconv<rmatrix,imatrix,imatrix>(m1,m2); }
01851         INLINE imatrix operator |(const imatrix &m1,const rmatrix &m2)
01852 #if(CXSC_INDEX_CHECK)
01853         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01854 #else
01855         throw()
01856 #endif
01857         { return _mmconv<rmatrix,imatrix,imatrix>(m2,m1); }
01858         INLINE imatrix operator |(const rmatrix &m,const imatrix_slice &ms)
01859 #if(CXSC_INDEX_CHECK)
01860         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01861 #else
01862         throw()
01863 #endif
01864         { return _mmsconv<rmatrix,imatrix_slice,imatrix>(m,ms); }
01865         INLINE imatrix operator |(const imatrix &m,const rmatrix_slice &ms)
01866 #if(CXSC_INDEX_CHECK)
01867         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01868 #else
01869         throw()
01870 #endif
01871         { return _mmsconv<imatrix,rmatrix_slice,imatrix>(m,ms); }
01872         INLINE imatrix operator |(const rmatrix_slice &ms,const imatrix &m)
01873 #if(CXSC_INDEX_CHECK)
01874         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01875 #else
01876         throw()
01877 #endif
01878         { return _mmsconv<imatrix,rmatrix_slice,imatrix>(m,ms); }
01879         INLINE imatrix operator |(const imatrix_slice &ms,const rmatrix &m)
01880 #if(CXSC_INDEX_CHECK)
01881         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01882 #else
01883         throw()
01884 #endif
01885         { return _mmsconv<rmatrix,imatrix_slice,imatrix>(m,ms); }
01886         INLINE imatrix operator |(const rmatrix_slice &m1,const imatrix_slice &m2)
01887 #if(CXSC_INDEX_CHECK)
01888         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01889 #else
01890         throw()
01891 #endif
01892         { return _msmsconv<rmatrix_slice,imatrix_slice,imatrix>(m1,m2); }
01893         INLINE imatrix operator |(const imatrix_slice &m1,const rmatrix_slice &m2)
01894 #if(CXSC_INDEX_CHECK)
01895         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01896 #else
01897         throw()
01898 #endif
01899         { return _msmsconv<rmatrix_slice,imatrix_slice,imatrix>(m2,m1); }
01900         INLINE imatrix &operator |=(imatrix &m1,const rmatrix &m2)
01901 #if(CXSC_INDEX_CHECK)
01902         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01903 #else
01904         throw()
01905 #endif
01906         { return _mmconvassign(m1,m2); }
01907         INLINE imatrix &operator |=(imatrix &m1,const rmatrix_slice &ms)
01908 #if(CXSC_INDEX_CHECK)
01909         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01910 #else
01911         throw()
01912 #endif
01913         { return _mmsconvassign(m1,ms); }
01914         INLINE imatrix_slice &imatrix_slice::operator |=(const rmatrix &m1)
01915 #if(CXSC_INDEX_CHECK)
01916         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01917 #else
01918         throw()
01919 #endif
01920         { return _msmconvassign(*this,m1); }
01921         INLINE imatrix_slice &imatrix_slice::operator |=(const rmatrix_slice &ms2)
01922 #if(CXSC_INDEX_CHECK)
01923         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01924 #else
01925         throw()
01926 #endif
01927         { return _msmsconvassign(*this,ms2); }
01928         INLINE imatrix operator &(const rmatrix &m1,const imatrix &m2)
01929 #if(CXSC_INDEX_CHECK)
01930         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01931 #else
01932         throw()
01933 #endif
01934         { return _mmsect<rmatrix,imatrix,imatrix>(m1,m2); }
01935         INLINE imatrix operator &(const imatrix &m1,const rmatrix &m2)
01936 #if(CXSC_INDEX_CHECK)
01937         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01938 #else
01939         throw()
01940 #endif
01941         { return _mmsect<rmatrix,imatrix,imatrix>(m2,m1); }
01942         INLINE imatrix operator &(const rmatrix &m,const imatrix_slice &ms)
01943 #if(CXSC_INDEX_CHECK)
01944         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01945 #else
01946         throw()
01947 #endif
01948         { return _mmssect<rmatrix,imatrix_slice,imatrix>(m,ms); }
01949         INLINE imatrix operator &(const imatrix &m,const rmatrix_slice &ms)
01950 #if(CXSC_INDEX_CHECK)
01951         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01952 #else
01953         throw()
01954 #endif
01955         { return _mmssect<imatrix,rmatrix_slice,imatrix>(m,ms); }
01956         INLINE imatrix operator &(const rmatrix_slice &ms,const imatrix &m)
01957 #if(CXSC_INDEX_CHECK)
01958         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01959 #else
01960         throw()
01961 #endif
01962         { return _mmssect<imatrix,rmatrix_slice,imatrix>(m,ms); }
01963         INLINE imatrix operator &(const imatrix_slice &ms,const rmatrix &m)
01964 #if(CXSC_INDEX_CHECK)
01965         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01966 #else
01967         throw()
01968 #endif
01969         { return _mmssect<rmatrix,imatrix_slice,imatrix>(m,ms); }
01970         INLINE imatrix operator &(const rmatrix_slice &m1,const imatrix_slice &m2)
01971 #if(CXSC_INDEX_CHECK)
01972         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01973 #else
01974         throw()
01975 #endif
01976         { return _msmssect<rmatrix_slice,imatrix_slice,imatrix>(m1,m2); }
01977         INLINE imatrix operator &(const imatrix_slice &m1,const rmatrix_slice &m2)
01978 #if(CXSC_INDEX_CHECK)
01979         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01980 #else
01981         throw()
01982 #endif
01983         { return _msmssect<rmatrix_slice,imatrix_slice,imatrix>(m2,m1); }
01984         INLINE imatrix &operator &=(imatrix &m1,const rmatrix &m2)
01985 #if(CXSC_INDEX_CHECK)
01986         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01987 #else
01988         throw()
01989 #endif
01990         { return _mmsectassign(m1,m2); }
01991         INLINE imatrix &operator &=(imatrix &m1,const rmatrix_slice &ms)
01992 #if(CXSC_INDEX_CHECK)
01993         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
01994 #else
01995         throw()
01996 #endif
01997         { return _mmssectassign(m1,ms); }
01998         INLINE imatrix_slice &imatrix_slice::operator &=(const rmatrix &m1)
01999 #if(CXSC_INDEX_CHECK)
02000         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
02001 #else
02002         throw()
02003 #endif
02004         { return _msmsectassign(*this,m1); }
02005         INLINE imatrix_slice &imatrix_slice::operator &=(const rmatrix_slice &ms2)
02006 #if(CXSC_INDEX_CHECK)
02007         throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM)
02008 #else
02009         throw()
02010 #endif
02011         { return _msmssectassign(*this,ms2); }
02012         INLINE bool operator ==(const imatrix &m1,const imatrix &m2) throw() { return _mmeq(m1,m2); }
02013         INLINE bool operator !=(const imatrix &m1,const imatrix &m2) throw() { return _mmneq(m1,m2); }
02014         INLINE bool operator <(const imatrix &m1,const imatrix &m2) throw() { return _mmless(m1,m2); }
02015         INLINE bool operator <=(const imatrix &m1,const imatrix &m2) throw() { return _mmleq(m1,m2); }
02016         INLINE bool operator >(const imatrix &m1,const imatrix &m2) throw() { return _mmless(m2,m1); }
02017         INLINE bool operator >=(const imatrix &m1,const imatrix &m2) throw() { return _mmleq(m2,m1); }
02018         INLINE bool operator ==(const imatrix &m1,const imatrix_slice &ms) throw() { return _mmseq(m1,ms); }
02019         INLINE bool operator !=(const imatrix &m1,const imatrix_slice &ms) throw() { return _mmsneq(m1,ms); }
02020         INLINE bool operator <(const imatrix &m1,const imatrix_slice &ms) throw() { return _mmsless(m1,ms); }
02021         INLINE bool operator <=(const imatrix &m1,const imatrix_slice &ms) throw() { return _mmsleq(m1,ms); }
02022         INLINE bool operator >(const imatrix &m1,const imatrix_slice &ms) throw() { return _msmless(ms,m1); }
02023         INLINE bool operator >=(const imatrix &m1,const imatrix_slice &ms) throw() { return _msmleq(ms,m1); }
02024         INLINE bool operator ==(const imatrix_slice &m1,const imatrix_slice &m2) throw() { return _msmseq(m1,m2); }
02025         INLINE bool operator !=(const imatrix_slice &m1,const imatrix_slice &m2) throw() { return _msmsneq(m1,m2); }
02026         INLINE bool operator <(const imatrix_slice &m1,const imatrix_slice &m2) throw() { return _msmsless(m1,m2); }
02027         INLINE bool operator <=(const imatrix_slice &m1,const imatrix_slice &m2) throw() { return _msmsleq(m1,m2); }
02028         INLINE bool operator >(const imatrix_slice &m1,const imatrix_slice &m2) throw() { return _msmsless(m2,m1); }
02029         INLINE bool operator >=(const imatrix_slice &m1,const imatrix_slice &m2) throw() { return _msmsleq(m2,m1); }
02030         INLINE bool operator !(const imatrix &ms) throw() { return _mnot(ms); }
02031         INLINE bool operator !(const imatrix_slice &ms) throw() { return _msnot(ms); }
02032         INLINE std::ostream &operator <<(std::ostream &s,const imatrix &r) throw() { return _mout(s,r); }
02033         INLINE std::ostream &operator <<(std::ostream &s,const imatrix_slice &r) throw() { return _msout(s,r); }
02034         INLINE std::istream &operator >>(std::istream &s,imatrix &r) throw() { return _min(s,r); }
02035         INLINE std::istream &operator >>(std::istream &s,imatrix_slice &r) throw() { return _msin(s,r); }
02036 
02038         INLINE imatrix imatrix::operator()(const intvector& p, const intvector& q) {
02039           imatrix A(*this);
02040           for(int i=0 ; i<ColLen(A) ; i++)
02041             for(int j=0 ; j<RowLen(A) ; j++)
02042               A[i+Lb(A,1)][j+Lb(A,2)] = (*this)[p[i+Lb(p)]+Lb(A,1)][q[j+Lb(q)]+Lb(A,2)];
02043           return A;
02044         }
02045 
02047         INLINE imatrix imatrix::operator()(const intvector& p) {
02048           imatrix A(*this);
02049           for(int i=0 ; i<ColLen(A) ; i++)
02050               A[i+Lb(A,1)] = (*this)[p[i+Lb(p)]+Lb(A,1)];
02051           return A;
02052         }
02053 
02055         INLINE imatrix imatrix::operator()(const intmatrix& P) {
02056           intvector p = permvec(P);
02057           return (*this)(p);
02058         }
02059 
02061         INLINE imatrix imatrix::operator()(const intmatrix& P, const intmatrix& Q) {
02062           intvector p = permvec(P);
02063           intvector q = perminv(permvec(Q));
02064           return (*this)(p,q);
02065         }
02066 
02068         INLINE ivector ivector::operator()(const intmatrix& P) {
02069           intvector p = permvec(P);
02070           return (*this)(p);
02071         }
02072 
02073 } // namespace cxsc
02074 
02075 #endif
02076