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