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