C-XSC - A C++ Class Library for Extended Scientific Computing
2.5.4
|
00001 /* 00002 ** CXSC is a C++ library for eXtended Scientific Computing (V 2.5.4) 00003 ** 00004 ** Copyright (C) 1990-2000 Institut fuer Angewandte Mathematik, 00005 ** Universitaet Karlsruhe, Germany 00006 ** (C) 2000-2014 Wiss. Rechnen/Softwaretechnologie 00007 ** Universitaet Wuppertal, Germany 00008 ** 00009 ** This library is free software; you can redistribute it and/or 00010 ** modify it under the terms of the GNU Library General Public 00011 ** License as published by the Free Software Foundation; either 00012 ** version 2 of the License, or (at your option) any later version. 00013 ** 00014 ** This library is distributed in the hope that it will be useful, 00015 ** but WITHOUT ANY WARRANTY; without even the implied warranty of 00016 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00017 ** Library General Public License for more details. 00018 ** 00019 ** You should have received a copy of the GNU Library General Public 00020 ** License along with this library; if not, write to the Free 00021 ** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 00022 */ 00023 00024 /* CVS $Id: cimatrix.inl,v 1.30 2014/01/30 17:23:44 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