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: rmatrix.inl,v 1.29 2014/01/30 17:23:48 cxsc Exp $ */ 00025 00026 #ifndef _CXSC_RMATRIX_INL_INCLUDED 00027 #define _CXSC_RMATRIX_INL_INCLUDED 00028 00029 #include "intmatrix.hpp" 00030 00031 namespace cxsc { 00032 00033 INLINE rmatrix::rmatrix() throw():dat(NULL),lb1(1),ub1(0),lb2(1),ub2(0),xsize(0),ysize(0) 00034 { 00035 } 00036 00037 INLINE rmatrix::rmatrix(const real &r) throw():lb1(1),ub1(1),lb2(1),ub2(1),xsize(1),ysize(1) 00038 { 00039 dat=new real[1]; 00040 *dat=r; 00041 } 00042 00043 INLINE rmatrix::rmatrix(const rmatrix &rm) throw():lb1(rm.lb1),ub1(rm.ub1),lb2(rm.lb2),ub2(rm.ub2),xsize(rm.xsize),ysize(rm.ysize) 00044 { 00045 dat=new real[xsize*ysize]; 00046 for(int i=0;i<xsize*ysize;i++) 00047 dat[i]=rm.dat[i]; 00048 } 00049 00050 INLINE rmatrix::rmatrix(const int &m, const int &n) 00051 #if(CXSC_INDEX_CHECK) 00052 throw(ERROR_RMATRIX_WRONG_BOUNDARIES):lb1(1),ub1(m),lb2(1),ub2(n),xsize(n),ysize(m) 00053 #else 00054 throw():lb1(1),ub1(m),lb2(1),ub2(n),xsize(n),ysize(m) 00055 #endif 00056 { 00057 #if(CXSC_INDEX_CHECK) 00058 if((n<0)||(m<0)) cxscthrow(ERROR_RMATRIX_WRONG_BOUNDARIES("rmatrix::rmatrix(const int &m, const int &n)")); 00059 #endif 00060 dat=new real[m*n]; 00061 } 00062 00063 INLINE rmatrix::rmatrix(const int &m1, const int &m2, const int &n1, const int &n2) 00064 #if(CXSC_INDEX_CHECK) 00065 throw(ERROR_RMATRIX_WRONG_BOUNDARIES):lb1(m1),ub1(m2),lb2(n1),ub2(n2),xsize(n2-n1+1),ysize(m2-m1+1) 00066 #else 00067 throw():lb1(m1),ub1(m2),lb2(n1),ub2(n2),xsize(n2-n1+1),ysize(m2-m1+1) 00068 #endif 00069 { 00070 #if(CXSC_INDEX_CHECK) 00071 if((m2<m1)||(n2<n1)) cxscthrow(ERROR_RMATRIX_WRONG_BOUNDARIES("rmatrix::rmatrix(const int &m1, const int &n1, const int &m2, const int &n2)")); 00072 #endif 00073 dat=new real[xsize*ysize]; 00074 } 00075 00076 INLINE rvector::rvector(const rmatrix_subv &v) throw():l(v.lb),u(v.ub),size(v.size) 00077 { 00078 dat=new real[size]; 00079 for (int i=0, j=v.start;i<v.size;i++,j+=v.offset) 00080 dat[i]=v.dat[j]; 00081 } 00082 00083 INLINE rmatrix::rmatrix(const rvector &v) throw():lb1(v.l),ub1(v.u),lb2(1),ub2(1),xsize(1),ysize(v.size) 00084 { 00085 dat=new real[v.size]; 00086 for(int i=0;i<v.size;i++) 00087 dat[i]=v.dat[i]; 00088 } 00089 00090 INLINE rmatrix::rmatrix(const rvector_slice &v) throw():lb1(v.start),ub1(v.end),lb2(1),ub2(1),xsize(1),ysize(v.size) 00091 { 00092 dat=new real[v.size]; 00093 for(int i=0,j=v.start-v.l;i<v.size;i++,j++) 00094 dat[i]=v.dat[j]; 00095 } 00096 00097 00098 INLINE rmatrix::rmatrix(const rmatrix_slice &sl) throw():lb1(sl.start1),ub1(sl.end1),lb2(sl.start2),ub2(sl.end2),xsize(sl.sxsize),ysize(sl.sysize) 00099 { 00100 int i,j; 00101 00102 dat=new real[xsize*ysize]; 00103 for (i=0;i<ysize;i++) 00104 { 00105 for(j=0;j<xsize;j++) 00106 { 00107 dat[i*xsize+j]=sl.dat[(sl.offset1+i)*sl.mxsize+sl.offset2+j]; 00108 } 00109 } 00110 } 00111 00112 INLINE rmatrix::rmatrix(const intmatrix& I) : lb1(Lb(I,1)),ub1(Ub(I,1)),lb2(Lb(I,2)),ub2(Ub(I,2)),xsize(RowLen(I)),ysize(ColLen(I)) { 00113 dat=new real[xsize*ysize]; 00114 for(int i=0 ; i<ysize ; i++) 00115 for(int j=0 ; j<xsize ; j++) 00116 dat[i*xsize+j] = I[i+lb1][j+lb2]; 00117 } 00118 00119 INLINE rmatrix_subv Row(rmatrix &m,const int &i) 00120 #if(CXSC_INDEX_CHECK) 00121 throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT) 00122 #else 00123 throw() 00124 #endif 00125 00126 { 00127 return m[i]; 00128 } 00129 00130 INLINE rmatrix_subv Col(rmatrix &m,const int &i) 00131 #if(CXSC_INDEX_CHECK) 00132 throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT) 00133 #else 00134 throw() 00135 #endif 00136 00137 { 00138 return m[Col(i)]; 00139 } 00140 INLINE rmatrix_subv Row(const rmatrix &m,const int &i) 00141 #if(CXSC_INDEX_CHECK) 00142 throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT) 00143 #else 00144 throw() 00145 #endif 00146 00147 { 00148 return m[i]; 00149 } 00150 00151 INLINE rmatrix_subv Col(const rmatrix &m,const int &i) 00152 #if(CXSC_INDEX_CHECK) 00153 throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT) 00154 #else 00155 throw() 00156 #endif 00157 00158 { 00159 return m[Col(i)]; 00160 } 00161 00162 INLINE real& rmatrix_subv::operator [](const int &i) const 00163 #if(CXSC_INDEX_CHECK) 00164 throw(ERROR_RVECTOR_ELEMENT_NOT_IN_VEC) 00165 #else 00166 throw() 00167 #endif 00168 { 00169 #if(CXSC_INDEX_CHECK) 00170 if((i<lb)||(i>ub)) cxscthrow(ERROR_RVECTOR_ELEMENT_NOT_IN_VEC("real &rmatrix_subv::operator [](const int &i) const")); 00171 #endif 00172 return dat[start+((i-lb)*offset)]; 00173 } 00174 00175 INLINE real& rmatrix_subv::operator [](const int &i) 00176 #if(CXSC_INDEX_CHECK) 00177 throw(ERROR_RVECTOR_ELEMENT_NOT_IN_VEC) 00178 #else 00179 throw() 00180 #endif 00181 { 00182 #if(CXSC_INDEX_CHECK) 00183 if((i<lb)||(i>ub)) cxscthrow(ERROR_RVECTOR_ELEMENT_NOT_IN_VEC("real &rmatrix_subv::operator [](const int &i)")); 00184 #endif 00185 return dat[start+((i-lb)*offset)]; 00186 } 00187 00188 00189 00190 INLINE rmatrix_subv rmatrix::operator [](const int &i) const 00191 #if(CXSC_INDEX_CHECK) 00192 throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT) 00193 #else 00194 throw() 00195 #endif 00196 { 00197 #if(CXSC_INDEX_CHECK) 00198 if((i<lb1)||(i>ub1)) cxscthrow(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT("rmatrix_subv rmatrix::operator [](const int &i)")); 00199 #endif 00200 return rmatrix_subv(dat, lb2, ub2, xsize, xsize*(i-lb1),1); 00201 } 00202 00203 INLINE rmatrix_subv rmatrix::operator [](const cxscmatrix_column &i) const 00204 #if(CXSC_INDEX_CHECK) 00205 throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT) 00206 #else 00207 throw() 00208 #endif 00209 { 00210 #if(CXSC_INDEX_CHECK) 00211 if((i.col()<lb2)||(i.col()>ub2)) cxscthrow(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT("rmatrix_subv rmatrix::operator [](const cxscmatrix_column &i)")); 00212 #endif 00213 return rmatrix_subv(dat, lb1, ub1, ysize, i.col()-lb2, xsize); 00214 } 00215 00216 INLINE rmatrix_slice rmatrix::operator ()(const int &m, const int &n) 00217 #if(CXSC_INDEX_CHECK) 00218 throw(ERROR_RMATRIX_SUB_ARRAY_TOO_BIG) 00219 #else 00220 throw() 00221 #endif 00222 { 00223 #if(CXSC_INDEX_CHECK) 00224 if((m<1)||(n<1)||(m<lb1)||(n<lb2)||(m>ub1)||(n>ub2)) cxscthrow(ERROR_RMATRIX_SUB_ARRAY_TOO_BIG("rmatrix_slice rmatrix::operator ()(const int &m, const int &n)")); 00225 #endif 00226 return rmatrix_slice(*this,1,m,1,n); 00227 } 00228 00229 INLINE rmatrix_slice rmatrix::operator ()(const int &m1, const int &m2, const int &n1, const int &n2) 00230 #if(CXSC_INDEX_CHECK) 00231 throw(ERROR_RMATRIX_SUB_ARRAY_TOO_BIG) 00232 #else 00233 throw() 00234 #endif 00235 { 00236 #if(CXSC_INDEX_CHECK) 00237 if((m1<lb1)||(n1<lb2)||(m2>ub1)||(n2>ub2)) cxscthrow(ERROR_RMATRIX_SUB_ARRAY_TOO_BIG("rmatrix_slice rmatrix::operator ()(const int &m1, const int &n1, const int &m2, const int &n2)")); 00238 #endif 00239 return rmatrix_slice(*this,m1,m2,n1,n2); 00240 } 00241 00242 INLINE rmatrix_subv rmatrix_slice::operator [](const int &i) const 00243 #if(CXSC_INDEX_CHECK) 00244 throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT) 00245 #else 00246 throw() 00247 #endif 00248 { 00249 #if(CXSC_INDEX_CHECK) 00250 if((i<start1)||(i>end1)) cxscthrow(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT("rmatrix_subv rmatrix_slice::operator [](const int &i)")); 00251 #endif 00252 return rmatrix_subv(dat, start2, end2, sxsize, mxsize*(i-start1+offset1)+offset2,1); 00253 } 00254 00255 INLINE rmatrix_subv rmatrix_slice::operator [](const cxscmatrix_column &i) const 00256 #if(CXSC_INDEX_CHECK) 00257 throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT) 00258 #else 00259 throw() 00260 #endif 00261 { 00262 #if(CXSC_INDEX_CHECK) 00263 if((i.col()<start2)||(i.col()>end2)) cxscthrow(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT("rmatrix_subv rmatrix_slice::operator [](const cxscmatrix_column &i)")); 00264 #endif 00265 return rmatrix_subv(dat, start1, end1, sysize, offset1*mxsize+i.col()-start2+offset2, mxsize); 00266 } 00267 00268 INLINE rmatrix_slice rmatrix_slice::operator ()(const int &m, const int &n) 00269 #if(CXSC_INDEX_CHECK) 00270 throw(ERROR_RMATRIX_SUB_ARRAY_TOO_BIG) 00271 #else 00272 throw() 00273 #endif 00274 { 00275 #if(CXSC_INDEX_CHECK) 00276 if((m<1)||(n<1)||(m<start1)||(n<start2)||(m>end1)||(n>end2)) cxscthrow(ERROR_RMATRIX_SUB_ARRAY_TOO_BIG("rmatrix_slice rmatrix_slice::operator ()(const int &m, const int &n)")); 00277 #endif 00278 return rmatrix_slice(*this,1,m,1,n); 00279 } 00280 00281 INLINE rmatrix_slice rmatrix_slice::operator ()(const int &m1, const int &m2, const int &n1, const int &n2) 00282 #if(CXSC_INDEX_CHECK) 00283 throw(ERROR_RMATRIX_SUB_ARRAY_TOO_BIG) 00284 #else 00285 throw() 00286 #endif 00287 { 00288 #if(CXSC_INDEX_CHECK) 00289 if((m1<start1)||(n1<start2)||(m2>end1)||(n2>end2)) cxscthrow(ERROR_RMATRIX_SUB_ARRAY_TOO_BIG("rmatrix_slice rmatrix_slice::operator ()(const int &m1, const int &m2, const int &n1, const int &n2)")); 00290 #endif 00291 return rmatrix_slice(*this,m1,m2,n1,n2); 00292 } 00293 00294 INLINE rmatrix_subv rmatrix_subv::operator ()(const int &i) 00295 #if(CXSC_INDEX_CHECK) 00296 throw(ERROR_RVECTOR_SUB_ARRAY_TOO_BIG) 00297 #else 00298 throw() 00299 #endif 00300 { 00301 #if(CXSC_INDEX_CHECK) 00302 if(1<lb||i>ub) cxscthrow(ERROR_RVECTOR_SUB_ARRAY_TOO_BIG("rmatrix_subv rmatrix_subv::operator ()(const int &i)")); 00303 #endif 00304 return rmatrix_subv(dat,1,i,i,start+(1-lb)*offset,offset); 00305 } 00306 00307 INLINE rmatrix_subv rmatrix_subv::operator ()(const int &i1,const int &i2) 00308 #if(CXSC_INDEX_CHECK) 00309 throw(ERROR_RVECTOR_SUB_ARRAY_TOO_BIG) 00310 #else 00311 throw() 00312 #endif 00313 { 00314 #if(CXSC_INDEX_CHECK) 00315 if(i1<lb||i2>ub) cxscthrow(ERROR_RVECTOR_SUB_ARRAY_TOO_BIG("rmatrix_subv rmatrix_subv::operator ()(const int &i1,const int &i2)")); 00316 #endif 00317 return rmatrix_subv(dat,i1,i2,i2-i1+1,start+(i1-lb)*offset,offset); 00318 } 00319 00320 // the following is generated from .hpp 00321 00322 INLINE rmatrix_subv &rmatrix_subv::operator =(const rmatrix_subv &rv) throw() { return _mvmvassign(*this,rv); } 00323 INLINE rmatrix_subv &rmatrix_subv::operator =(const real &r) throw() { return _mvsassign(*this,r); } 00324 INLINE rmatrix_subv &rmatrix_subv::operator =(const rvector &v) 00325 #if(CXSC_INDEX_CHECK) 00326 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM) 00327 #else 00328 throw() 00329 #endif 00330 { return _mvvassign(*this,v); } 00331 INLINE rmatrix_subv &rmatrix_subv::operator =(const rvector_slice &v) 00332 #if(CXSC_INDEX_CHECK) 00333 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM) 00334 #else 00335 throw() 00336 #endif 00337 { return _mvvassign(*this,rvector(v)); } 00338 INLINE rmatrix &rmatrix::operator =(const real &r) throw() { return _msassign(*this,r); } 00339 INLINE rmatrix &rmatrix::operator =(const rmatrix &m) throw() { return _mmassign<rmatrix,rmatrix,real>(*this,m,0); } 00340 INLINE rmatrix &rmatrix::operator =(const rvector &v) throw() { return _mvassign<rmatrix,rvector,real>(*this,v); } 00341 INLINE rmatrix &rmatrix::operator =(const rvector_slice &v) throw() { return _mvassign<rmatrix,rvector,real>(*this,rvector(v)); } 00342 INLINE rmatrix::operator void*() throw() { return _mvoid(*this); } 00343 INLINE rmatrix_slice &rmatrix_slice::operator =(const rmatrix &m) 00344 #if(CXSC_INDEX_CHECK) 00345 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00346 #else 00347 throw() 00348 #endif 00349 { return _msmassign(*this,m); } 00350 INLINE rmatrix_slice &rmatrix_slice::operator =(const rmatrix_slice &ms) 00351 #if(CXSC_INDEX_CHECK) 00352 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00353 #else 00354 throw() 00355 #endif 00356 { return _msmsassign(*this,ms); } 00357 INLINE rmatrix_slice &rmatrix_slice::operator =(const real &r) throw() { return _mssassign(*this,r); } 00358 INLINE rmatrix_slice &rmatrix_slice::operator =(const rvector &v) 00359 #if(CXSC_INDEX_CHECK) 00360 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00361 #else 00362 throw() 00363 #endif 00364 { return _msmassign(*this,rmatrix(v)); } 00365 INLINE rmatrix_slice &rmatrix_slice::operator =(const rvector_slice &v) 00366 #if(CXSC_INDEX_CHECK) 00367 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00368 #else 00369 throw() 00370 #endif 00371 { return _msmassign(*this,rmatrix(rvector(v))); } 00372 INLINE rmatrix_slice &rmatrix_slice::operator =(const rmatrix_subv &v) 00373 #if(CXSC_INDEX_CHECK) 00374 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00375 #else 00376 throw() 00377 #endif 00378 { return _msmassign(*this,rmatrix(rvector(v))); } 00379 INLINE rmatrix_slice &rmatrix_slice::operator +=(const rmatrix &m1) 00380 #if(CXSC_INDEX_CHECK) 00381 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00382 #else 00383 throw() 00384 #endif 00385 { return _msmplusassign(*this,m1); } 00386 INLINE rmatrix_slice &rmatrix_slice::operator +=(const rmatrix_slice &ms2) 00387 #if(CXSC_INDEX_CHECK) 00388 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00389 #else 00390 throw() 00391 #endif 00392 { return _msmsplusassign(*this,ms2); } 00393 INLINE rmatrix_slice &rmatrix_slice::operator -=(const rmatrix &m1) 00394 #if(CXSC_INDEX_CHECK) 00395 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00396 #else 00397 throw() 00398 #endif 00399 { return _msmminusassign(*this,m1); } 00400 INLINE rmatrix_slice &rmatrix_slice::operator -=(const rmatrix_slice &ms2) 00401 #if(CXSC_INDEX_CHECK) 00402 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00403 #else 00404 throw() 00405 #endif 00406 { return _msmsminusassign(*this,ms2); } 00407 INLINE rmatrix_slice &rmatrix_slice::operator *=(const rmatrix &m) 00408 #if(CXSC_INDEX_CHECK) 00409 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00410 #else 00411 throw() 00412 #endif 00413 { return (*this=*this*m); } 00414 INLINE rmatrix_slice &rmatrix_slice::operator *=(const rmatrix_slice &m) 00415 #if(CXSC_INDEX_CHECK) 00416 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00417 #else 00418 throw() 00419 #endif 00420 { return (*this=*this*m); } 00421 INLINE rmatrix_slice &rmatrix_slice::operator *=(const real &c) throw() { return _mssmultassign(*this,c); } 00422 INLINE rmatrix_slice &rmatrix_slice::operator /=(const real &c) throw() { return _mssdivassign(*this,c); } 00423 INLINE rmatrix_slice::operator void*() throw() { return _msvoid(*this); } 00424 INLINE rvector operator /(const rmatrix_subv &rv, const real &s) throw() { return _mvsdiv<rmatrix_subv,real,rvector>(rv,s); } 00425 INLINE rvector operator *(const rmatrix_subv &rv, const real &s) throw() { return _mvsmult<rmatrix_subv,real,rvector>(rv,s); } 00426 INLINE rvector operator *(const real &s, const rmatrix_subv &rv) throw() { return _mvsmult<rmatrix_subv,real,rvector>(rv,s); } 00427 INLINE rmatrix_subv &rmatrix_subv::operator *=(const real &c) throw() { return _mvsmultassign(*this,c); } 00428 INLINE rmatrix_subv &rmatrix_subv::operator +=(const real &c) throw() { return _mvsplusassign(*this,c); } 00429 INLINE rmatrix_subv &rmatrix_subv::operator -=(const real &c) throw() { return _mvsminusassign(*this,c); } 00430 INLINE rmatrix_subv &rmatrix_subv::operator /=(const real &c) throw() { return _mvsdivassign(*this,c); } 00431 INLINE rvector abs(const rmatrix_subv &mv) throw() { return _mvabs<rmatrix_subv,rvector>(mv); } 00432 INLINE rvector &rvector::operator =(const rmatrix_subv &mv) throw() { return _vmvassign<rvector,rmatrix_subv,real>(*this,mv); } 00433 INLINE rvector_slice &rvector_slice::operator =(const rmatrix_subv &mv) throw() { return _vsvassign(*this,rvector(mv)); } 00434 00435 00436 INLINE real operator *(const rmatrix_subv & rv1, const rmatrix_subv &rv2) 00437 #if(CXSC_INDEX_CHECK) 00438 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM) 00439 #else 00440 throw() 00441 #endif 00442 { return _mvmvmult<rmatrix_subv,rmatrix_subv,real>(rv1,rv2); } 00443 INLINE real operator *(const rvector & rv1, const rmatrix_subv &rv2) 00444 #if(CXSC_INDEX_CHECK) 00445 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM) 00446 #else 00447 throw() 00448 #endif 00449 { return _vmvmult<rvector,rmatrix_subv,real>(rv1,rv2); } 00450 INLINE real operator *(const rmatrix_subv &rv1,const rvector &rv2) 00451 #if(CXSC_INDEX_CHECK) 00452 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM) 00453 #else 00454 throw() 00455 #endif 00456 { return _vmvmult<rvector,rmatrix_subv,real>(rv2,rv1); } 00457 INLINE real operator *(const rvector_slice &sl,const rmatrix_subv &sv) 00458 #if(CXSC_INDEX_CHECK) 00459 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM) 00460 #else 00461 throw() 00462 #endif 00463 { return _vmvmult<rvector,rmatrix_subv,real>(rvector(sl),sv); } 00464 INLINE real operator *(const rmatrix_subv &mv,const rvector_slice &vs) 00465 #if(CXSC_INDEX_CHECK) 00466 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM) 00467 #else 00468 throw() 00469 #endif 00470 { return _vmvmult<rvector,rmatrix_subv,real>(rvector(vs),mv); } 00471 INLINE rvector operator +(const rmatrix_subv & rv1, const rmatrix_subv &rv2) 00472 #if(CXSC_INDEX_CHECK) 00473 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM) 00474 #else 00475 throw() 00476 #endif 00477 { return _mvmvplus<rmatrix_subv,rmatrix_subv,rvector>(rv1,rv2); } 00478 INLINE rvector operator +(const rmatrix_subv &rv1,const rvector &rv2) 00479 #if(CXSC_INDEX_CHECK) 00480 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM) 00481 #else 00482 throw() 00483 #endif 00484 { return _mvvplus<rmatrix_subv,rvector,rvector>(rv1,rv2); } 00485 INLINE rvector operator +(const rvector & rv1, const rmatrix_subv &rv2) 00486 #if(CXSC_INDEX_CHECK) 00487 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM) 00488 #else 00489 throw() 00490 #endif 00491 { return _mvvplus<rmatrix_subv,rvector,rvector>(rv2,rv1); } 00492 INLINE rvector operator +(const rvector_slice &sl,const rmatrix_subv &mv) 00493 #if(CXSC_INDEX_CHECK) 00494 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM) 00495 #else 00496 throw() 00497 #endif 00498 { return _mvvplus<rmatrix_subv,rvector,rvector>(mv,rvector(sl)); } 00499 INLINE rvector operator +(const rmatrix_subv &mv,const rvector_slice &sl) 00500 #if(CXSC_INDEX_CHECK) 00501 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM) 00502 #else 00503 throw() 00504 #endif 00505 { return _mvvplus<rmatrix_subv,rvector,rvector>(mv,rvector(sl)); } 00506 INLINE rmatrix_subv &rmatrix_subv::operator +=(const rvector &rv) 00507 #if(CXSC_INDEX_CHECK) 00508 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM) 00509 #else 00510 throw() 00511 #endif 00512 { return _mvvplusassign(*this,rv); } 00513 INLINE rmatrix_subv &rmatrix_subv::operator +=(const rvector_slice &rv) 00514 #if(CXSC_INDEX_CHECK) 00515 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM) 00516 #else 00517 throw() 00518 #endif 00519 { return _mvvplusassign(*this,rvector(rv)); } 00520 INLINE rvector operator -(const rmatrix_subv & rv1, const rmatrix_subv &rv2) 00521 #if(CXSC_INDEX_CHECK) 00522 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM) 00523 #else 00524 throw() 00525 #endif 00526 { return _mvmvminus<rmatrix_subv,rmatrix_subv,rvector>(rv1,rv2); } 00527 INLINE rvector operator -(const rvector & rv1, const rmatrix_subv &rv2) 00528 #if(CXSC_INDEX_CHECK) 00529 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM) 00530 #else 00531 throw() 00532 #endif 00533 { return _vmvminus<rvector,rmatrix_subv,rvector>(rv1,rv2); } 00534 INLINE rvector operator -(const rmatrix_subv &rv1,const rvector &rv2) 00535 #if(CXSC_INDEX_CHECK) 00536 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM) 00537 #else 00538 throw() 00539 #endif 00540 { return _mvvminus<rmatrix_subv,rvector,rvector>(rv1,rv2); } 00541 INLINE rvector operator -(const rvector_slice &sl,const rmatrix_subv &mv) 00542 #if(CXSC_INDEX_CHECK) 00543 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM) 00544 #else 00545 throw() 00546 #endif 00547 { return _vmvminus<rvector,rmatrix_subv,rvector>(rvector(sl),mv); } 00548 INLINE rvector operator -(const rmatrix_subv &mv,const rvector_slice &sl) 00549 #if(CXSC_INDEX_CHECK) 00550 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM) 00551 #else 00552 throw() 00553 #endif 00554 { return _mvvminus<rmatrix_subv,rvector,rvector>(mv,rvector(sl)); } 00555 INLINE rmatrix_subv &rmatrix_subv::operator -=(const rvector &rv) 00556 #if(CXSC_INDEX_CHECK) 00557 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM) 00558 #else 00559 throw() 00560 #endif 00561 { return _mvvminusassign(*this,rv); } 00562 INLINE rmatrix_subv &rmatrix_subv::operator -=(const rvector_slice &rv) 00563 #if(CXSC_INDEX_CHECK) 00564 throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM) 00565 #else 00566 throw() 00567 #endif 00568 { return _mvvminusassign(*this,rvector(rv)); } 00574 INLINE rmatrix _rmatrix(const rmatrix &rm) throw() { return rm; } 00580 INLINE rmatrix _rmatrix(const rvector &v) throw() { return rmatrix(v); } 00586 INLINE rmatrix _rmatrix(const rvector_slice &v) throw() { return rmatrix(v); } 00592 INLINE rmatrix _rmatrix(const real &r) throw() { return rmatrix(r); } 00593 INLINE rmatrix &rmatrix::operator =(const rmatrix_slice &ms) throw() { return _mmsassign<rmatrix,rmatrix_slice,real>(*this,ms); } 00594 INLINE int Lb(const rmatrix &rm, const int &i) 00595 #if(CXSC_INDEX_CHECK) 00596 throw(ERROR_RMATRIX_WRONG_ROW_OR_COL) 00597 #else 00598 throw() 00599 #endif 00600 { return _mlb(rm,i); } 00601 INLINE int Ub(const rmatrix &rm, const int &i) 00602 #if(CXSC_INDEX_CHECK) 00603 throw(ERROR_RMATRIX_WRONG_ROW_OR_COL) 00604 #else 00605 throw() 00606 #endif 00607 { return _mub(rm,i); } 00608 INLINE int Lb(const rmatrix_slice &rm, const int &i) 00609 #if(CXSC_INDEX_CHECK) 00610 throw(ERROR_RMATRIX_WRONG_ROW_OR_COL) 00611 #else 00612 throw() 00613 #endif 00614 { return _mslb(rm,i); } 00615 INLINE int Ub(const rmatrix_slice &rm, const int &i) 00616 #if(CXSC_INDEX_CHECK) 00617 throw(ERROR_RMATRIX_WRONG_ROW_OR_COL) 00618 #else 00619 throw() 00620 #endif 00621 { return _msub(rm,i); } 00622 INLINE rmatrix &SetLb(rmatrix &m, const int &i,const int &j) 00623 #if(CXSC_INDEX_CHECK) 00624 throw(ERROR_RMATRIX_WRONG_ROW_OR_COL) 00625 #else 00626 throw() 00627 #endif 00628 { return _msetlb(m,i,j); } 00629 INLINE rmatrix &SetUb(rmatrix &m, const int &i,const int &j) 00630 #if(CXSC_INDEX_CHECK) 00631 throw(ERROR_RMATRIX_WRONG_ROW_OR_COL) 00632 #else 00633 throw() 00634 #endif 00635 { return _msetub(m,i,j); } 00636 00637 00638 INLINE int RowLen ( const rmatrix& A ) // Length of the rows of a real matrix 00639 { return Ub(A,2)-Lb(A,2)+1; } //------------------------------------ 00640 00641 INLINE int ColLen ( const rmatrix& A ) // Length of the columns of a real matrix 00642 { return Ub(A,1)-Lb(A,1)+1; } //--------------------------------------- 00643 00644 INLINE int RowLen ( const rmatrix_slice& A ) // Length of the rows of a real matrix 00645 { return Ub(A,2)-Lb(A,2)+1; } //------------------------------------ 00646 00647 INLINE int ColLen ( const rmatrix_slice& A ) // Length of the columns of a real matrix 00648 { return Ub(A,1)-Lb(A,1)+1; } //--------------------------------------- 00649 00650 INLINE void Resize(rmatrix &A) throw() { _mresize(A); } 00651 INLINE void Resize(rmatrix &A,const int &m, const int &n) 00652 #if(CXSC_INDEX_CHECK) 00653 throw(ERROR_RMATRIX_WRONG_BOUNDARIES) 00654 #else 00655 throw() 00656 #endif 00657 { _mresize<rmatrix,real>(A,m,n); } 00658 INLINE void Resize(rmatrix &A,const int &m1, const int &m2,const int &n1,const int &n2) 00659 #if(CXSC_INDEX_CHECK) 00660 throw(ERROR_RMATRIX_WRONG_BOUNDARIES) 00661 #else 00662 throw() 00663 #endif 00664 { _mresize<rmatrix,real>(A,m1,m2,n1,n2); } 00665 INLINE rmatrix abs(const rmatrix &m) throw() { return _mabs<rmatrix,rmatrix>(m); } 00666 INLINE rmatrix abs(const rmatrix_slice &ms) throw() { return _msabs<rmatrix_slice,rmatrix>(ms); } 00667 INLINE real::real(const rmatrix &m) 00668 #if(CXSC_INDEX_CHECK) 00669 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ,ERROR_RMATRIX_USE_OF_UNINITIALIZED_OBJ) 00670 #else 00671 throw() 00672 #endif 00673 { _smconstr(*this,m); } 00674 // INLINE real real::_real(const rmatrix &m) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ,ERROR_RMATRIX_USE_OF_UNINITIALIZED_OBJ) { _smconstr(*this,m); return *this; } 00675 INLINE rmatrix operator *(const real &c, const rmatrix &m) throw() { return _smmult<real,rmatrix,rmatrix>(c,m); } 00676 INLINE rmatrix operator *(const real &c, const rmatrix_slice &ms) throw() { return _smsmult<real,rmatrix_slice,rmatrix>(c,ms); } 00677 INLINE rmatrix operator *(const rmatrix &m,const real &c) throw() { return _smmult<real,rmatrix,rmatrix>(c,m); } 00678 INLINE rmatrix operator *(const rmatrix_slice &ms,const real &c) throw() { return _smsmult<real,rmatrix_slice,rmatrix>(c,ms); } 00679 INLINE rmatrix &operator *=(rmatrix &m,const real &c) throw() { return _msmultassign(m,c); } 00680 INLINE rmatrix operator /(const rmatrix &m,const real &c) throw() { return _msdiv<rmatrix,real,rmatrix>(m,c); } 00681 INLINE rmatrix operator /(const rmatrix_slice &ms, const real &c) throw() { return _mssdiv<rmatrix_slice,real,rmatrix>(ms,c); } 00682 INLINE rmatrix &operator /=(rmatrix &m,const real &c) throw() { return _msdivassign(m,c); } 00683 INLINE rvector::rvector(const rmatrix &sl) 00684 #if(CXSC_INDEX_CHECK) 00685 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ) 00686 #else 00687 throw() 00688 #endif 00689 { _vmconstr<rvector,rmatrix,real>(*this,sl); } 00690 INLINE rvector::rvector(const rmatrix_slice &sl) 00691 #if(CXSC_INDEX_CHECK) 00692 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ) 00693 #else 00694 throw() 00695 #endif 00696 { _vmsconstr<rvector,rmatrix_slice,real>(*this,sl); } 00697 INLINE rvector &rvector::operator =(const rmatrix &m) 00698 #if(CXSC_INDEX_CHECK) 00699 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ) 00700 #else 00701 throw() 00702 #endif 00703 { return _vmassign<rvector,rmatrix,real>(*this,m); } 00704 INLINE rvector &rvector::operator =(const rmatrix_slice &m) 00705 #if(CXSC_INDEX_CHECK) 00706 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ) 00707 #else 00708 throw() 00709 #endif 00710 { return _vmassign<rvector,rmatrix,real>(*this,rmatrix(m)); } 00711 INLINE rvector_slice &rvector_slice::operator =(const rmatrix &m) 00712 #if(CXSC_INDEX_CHECK) 00713 throw(ERROR__OP_WITH_WRONG_DIM<rvector>,ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ) 00714 #else 00715 throw() 00716 #endif 00717 { return _vsvassign(*this,rvector(m)); } 00718 INLINE rvector_slice & rvector_slice::operator =(const rmatrix_slice &m) 00719 #if(CXSC_INDEX_CHECK) 00720 throw(ERROR__OP_WITH_WRONG_DIM<rvector>,ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ) 00721 #else 00722 throw() 00723 #endif 00724 { return _vsvassign(*this,rvector(rmatrix(m))); } 00725 INLINE rmatrix_subv &rmatrix_subv::operator =(const rmatrix &m) 00726 #if(CXSC_INDEX_CHECK) 00727 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ) 00728 #else 00729 throw() 00730 #endif 00731 { return _mvvassign(*this,rvector(m)); } 00732 INLINE rmatrix_subv &rmatrix_subv::operator =(const rmatrix_slice &m) 00733 #if(CXSC_INDEX_CHECK) 00734 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ) 00735 #else 00736 throw() 00737 #endif 00738 { return _mvvassign(*this,rvector(rmatrix(m))); } 00739 INLINE rvector operator *(const rmatrix &m,const rvector &v) 00740 #if(CXSC_INDEX_CHECK) 00741 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00742 #else 00743 throw() 00744 #endif 00745 { return _mvmult<rmatrix,rvector,rvector>(m,v); }; 00746 INLINE rvector operator *(const rmatrix_slice &ms,const rvector &v) 00747 #if(CXSC_INDEX_CHECK) 00748 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00749 #else 00750 throw() 00751 #endif 00752 { return _msvmult<rmatrix_slice,rvector,rvector>(ms,v); } 00753 INLINE rvector operator *(const rvector &v,const rmatrix &m) 00754 #if(CXSC_INDEX_CHECK) 00755 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00756 #else 00757 throw() 00758 #endif 00759 { return _vmmult<rvector,rmatrix,rvector>(v,m); } 00760 INLINE rvector operator *(const rvector &v,const rmatrix_slice &ms) 00761 #if(CXSC_INDEX_CHECK) 00762 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00763 #else 00764 throw() 00765 #endif 00766 { return _vmsmult<rvector,rmatrix_slice,rvector>(v,ms); } 00767 INLINE rvector &operator *=(rvector &v,const rmatrix &m) 00768 #if(CXSC_INDEX_CHECK) 00769 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00770 #else 00771 throw() 00772 #endif 00773 { return _vmmultassign<rvector,rmatrix,real>(v,m); } 00774 INLINE rvector &operator *=(rvector &v,const rmatrix_slice &ms) 00775 #if(CXSC_INDEX_CHECK) 00776 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00777 #else 00778 throw() 00779 #endif 00780 { return _vmsmultassign<rvector,rmatrix_slice,real>(v,ms); } 00781 INLINE rvector_slice &rvector_slice::operator *=(const rmatrix &m) 00782 #if(CXSC_INDEX_CHECK) 00783 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00784 #else 00785 throw() 00786 #endif 00787 { return _vsmmultassign<rvector_slice,rmatrix,real>(*this,m); } 00788 INLINE rvector operator *(const rvector_slice &v,const rmatrix &m) 00789 #if(CXSC_INDEX_CHECK) 00790 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00791 #else 00792 throw() 00793 #endif 00794 { return _vmmult<rvector,rmatrix,rvector>(rvector(v),m); } 00795 00796 INLINE const rmatrix &operator +(const rmatrix &m) throw() { return m; } 00797 INLINE rmatrix operator +(const rmatrix_slice &m) throw() { return rmatrix(m); } 00798 INLINE rmatrix operator +(const rmatrix &m1,const rmatrix &m2) 00799 #if(CXSC_INDEX_CHECK) 00800 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00801 #else 00802 throw() 00803 #endif 00804 { return _mmplus<rmatrix,rmatrix,rmatrix>(m1,m2); } 00805 INLINE rmatrix operator +(const rmatrix &m,const rmatrix_slice &ms) 00806 #if(CXSC_INDEX_CHECK) 00807 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00808 #else 00809 throw() 00810 #endif 00811 { return _mmsplus<rmatrix,rmatrix_slice,rmatrix>(m,ms); } 00812 INLINE rmatrix operator +(const rmatrix_slice &ms,const rmatrix &m) 00813 #if(CXSC_INDEX_CHECK) 00814 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00815 #else 00816 throw() 00817 #endif 00818 { return _mmsplus<rmatrix,rmatrix_slice,rmatrix>(m,ms); } 00819 INLINE rmatrix operator +(const rmatrix_slice &m1,const rmatrix_slice &m2) 00820 #if(CXSC_INDEX_CHECK) 00821 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00822 #else 00823 throw() 00824 #endif 00825 { return _msmsplus<rmatrix_slice,rmatrix_slice,rmatrix>(m1,m2); } 00826 INLINE rmatrix &operator +=(rmatrix &m1,const rmatrix &m2) 00827 #if(CXSC_INDEX_CHECK) 00828 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00829 #else 00830 throw() 00831 #endif 00832 { return _mmplusassign(m1,m2); } 00833 INLINE rmatrix &operator +=(rmatrix &m1,const rmatrix_slice &ms) 00834 #if(CXSC_INDEX_CHECK) 00835 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00836 #else 00837 throw() 00838 #endif 00839 { return _mmsplusassign(m1,ms); } 00840 INLINE rmatrix operator -(const rmatrix &m) throw() { return _mminus(m); } 00841 INLINE rmatrix operator -(const rmatrix_slice &m) throw() { return _msminus<rmatrix_slice,rmatrix>(m); } 00842 INLINE rmatrix operator -(const rmatrix &m1,const rmatrix &m2) 00843 #if(CXSC_INDEX_CHECK) 00844 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00845 #else 00846 throw() 00847 #endif 00848 { return _mmminus<rmatrix,rmatrix,rmatrix>(m1,m2); } 00849 INLINE rmatrix operator -(const rmatrix &m,const rmatrix_slice &ms) 00850 #if(CXSC_INDEX_CHECK) 00851 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00852 #else 00853 throw() 00854 #endif 00855 { return _mmsminus<rmatrix,rmatrix_slice,rmatrix>(m,ms); } 00856 INLINE rmatrix operator -(const rmatrix_slice &ms,const rmatrix &m) 00857 #if(CXSC_INDEX_CHECK) 00858 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00859 #else 00860 throw() 00861 #endif 00862 { return _msmminus<rmatrix_slice,rmatrix,rmatrix>(ms,m); } 00863 INLINE rmatrix operator -(const rmatrix_slice &ms1,const rmatrix_slice &ms2) 00864 #if(CXSC_INDEX_CHECK) 00865 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00866 #else 00867 throw() 00868 #endif 00869 { return _msmsminus<rmatrix_slice,rmatrix_slice,rmatrix>(ms1,ms2); } 00870 INLINE rmatrix &operator -=(rmatrix &m1,const rmatrix &m2) 00871 #if(CXSC_INDEX_CHECK) 00872 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00873 #else 00874 throw() 00875 #endif 00876 { return _mmminusassign(m1,m2); } 00877 INLINE rmatrix &operator -=(rmatrix &m1,const rmatrix_slice &ms) 00878 #if(CXSC_INDEX_CHECK) 00879 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00880 #else 00881 throw() 00882 #endif 00883 { return _mmsminusassign(m1,ms); } 00884 INLINE rmatrix operator *(const rmatrix &m1, const rmatrix &m2) 00885 #if(CXSC_INDEX_CHECK) 00886 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00887 #else 00888 throw() 00889 #endif 00890 { return _mmmult<rmatrix,rmatrix,rmatrix>(m1,m2); } 00891 INLINE rmatrix operator *(const rmatrix &m1, const rmatrix_slice &ms) 00892 #if(CXSC_INDEX_CHECK) 00893 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00894 #else 00895 throw() 00896 #endif 00897 { return _mmsmult<rmatrix,rmatrix_slice,rmatrix>(m1,ms); } 00898 INLINE rmatrix operator *(const rmatrix_slice &ms, const rmatrix &m1) 00899 #if(CXSC_INDEX_CHECK) 00900 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00901 #else 00902 throw() 00903 #endif 00904 { return _msmmult<rmatrix_slice,rmatrix,rmatrix>(ms,m1); } 00905 INLINE rmatrix operator *(const rmatrix_slice &ms1, const rmatrix_slice &ms2) 00906 #if(CXSC_INDEX_CHECK) 00907 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00908 #else 00909 throw() 00910 #endif 00911 { return _msmsmult<rmatrix_slice,rmatrix_slice,rmatrix>(ms1,ms2); } 00912 INLINE rmatrix &operator *=(rmatrix &m1,const rmatrix &m2) 00913 #if(CXSC_INDEX_CHECK) 00914 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00915 #else 00916 throw() 00917 #endif 00918 { return _mmmultassign<rmatrix,rmatrix,real>(m1,m2); } 00919 INLINE rmatrix &operator *=(rmatrix &m1,const rmatrix_slice &ms) 00920 #if(CXSC_INDEX_CHECK) 00921 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM) 00922 #else 00923 throw() 00924 #endif 00925 { return _mmsmultassign<rmatrix,rmatrix_slice,real>(m1,ms); } 00926 INLINE bool operator ==(const rmatrix &m1,const rmatrix &m2) throw() { return _mmeq(m1,m2); } 00927 INLINE bool operator !=(const rmatrix &m1,const rmatrix &m2) throw() { return _mmneq(m1,m2); } 00928 INLINE bool operator <(const rmatrix &m1,const rmatrix &m2) throw() { return _mmless(m1,m2); } 00929 INLINE bool operator <=(const rmatrix &m1,const rmatrix &m2) throw() { return _mmleq(m1,m2); } 00930 INLINE bool operator >(const rmatrix &m1,const rmatrix &m2) throw() { return _mmless(m2,m1); } 00931 INLINE bool operator >=(const rmatrix &m1,const rmatrix &m2) throw() { return _mmleq(m2,m1); } 00932 INLINE bool operator ==(const rmatrix &m1,const rmatrix_slice &ms) throw() { return _mmseq(m1,ms); } 00933 INLINE bool operator !=(const rmatrix &m1,const rmatrix_slice &ms) throw() { return _mmsneq(m1,ms); } 00934 INLINE bool operator <(const rmatrix &m1,const rmatrix_slice &ms) throw() { return _mmsless(m1,ms); } 00935 INLINE bool operator <=(const rmatrix &m1,const rmatrix_slice &ms) throw() { return _mmsleq(m1,ms); } 00936 INLINE bool operator >(const rmatrix &m1,const rmatrix_slice &ms) throw() { return _msmless(ms,m1); } 00937 INLINE bool operator >=(const rmatrix &m1,const rmatrix_slice &ms) throw() { return _msmleq(ms,m1); } 00938 INLINE bool operator ==(const rmatrix_slice &m1,const rmatrix_slice &m2) throw() { return _msmseq(m1,m2); } 00939 INLINE bool operator !=(const rmatrix_slice &m1,const rmatrix_slice &m2) throw() { return _msmsneq(m1,m2); } 00940 INLINE bool operator <(const rmatrix_slice &m1,const rmatrix_slice &m2) throw() { return _msmsless(m1,m2); } 00941 INLINE bool operator <=(const rmatrix_slice &m1,const rmatrix_slice &m2) throw() { return _msmsleq(m1,m2); } 00942 INLINE bool operator >(const rmatrix_slice &m1,const rmatrix_slice &m2) throw() { return _msmsless(m2,m1); } 00943 INLINE bool operator >=(const rmatrix_slice &m1,const rmatrix_slice &m2) throw() { return _msmsleq(m2,m1); } 00944 INLINE bool operator !(const rmatrix &ms) throw() { return _mnot(ms); } 00945 INLINE bool operator !(const rmatrix_slice &ms) throw() { return _msnot(ms); } 00946 INLINE std::ostream &operator <<(std::ostream &s,const rmatrix &r) throw() { return _mout(s,r); } 00947 INLINE std::ostream &operator <<(std::ostream &s,const rmatrix_slice &r) throw() { return _msout(s,r); } 00948 INLINE std::istream &operator >>(std::istream &s,rmatrix &r) throw() { return _min(s,r); } 00949 INLINE std::istream &operator >>(std::istream &s,rmatrix_slice &r) throw() { return _msin(s,r); } 00950 00952 INLINE rmatrix rmatrix::operator()(const intvector& p, const intvector& q) { 00953 rmatrix A(*this); 00954 for(int i=0 ; i<ColLen(A) ; i++) 00955 for(int j=0 ; j<RowLen(A) ; j++) 00956 A[i+Lb(A,1)][j+Lb(A,2)] = (*this)[p[i+Lb(p)]+Lb(A,1)][q[j+Lb(q)]+Lb(A,2)]; 00957 return A; 00958 } 00959 00961 INLINE rmatrix rmatrix::operator()(const intvector& p) { 00962 rmatrix A(*this); 00963 for(int i=0 ; i<ColLen(A) ; i++) 00964 A[i+Lb(A,1)] = (*this)[p[i+Lb(p)]+Lb(A,1)]; 00965 return A; 00966 } 00967 00969 INLINE rmatrix rmatrix::operator()(const intmatrix& P) { 00970 intvector p = permvec(P); 00971 return (*this)(p); 00972 } 00973 00975 INLINE rmatrix rmatrix::operator()(const intmatrix& P, const intmatrix& Q) { 00976 intvector p = permvec(P); 00977 intvector q = perminv(permvec(Q)); 00978 return (*this)(p,q); 00979 } 00980 00982 INLINE rvector rvector::operator()(const intmatrix& P) { 00983 intvector p = permvec(P); 00984 return (*this)(p); 00985 } 00986 00987 } // namespace cxsc 00988 00989 #endif 00990