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