C-XSC - A C++ Class Library for Extended Scientific Computing: cimatrix.inl Source File

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