- 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: civector.inl,v 1.28 2014/01/30 17:23:44 cxsc Exp $ */ 00025 00026 #ifndef _CXSC_CIVECTOR_INL_INCLUDED 00027 #define _CXSC_CIVECTOR_INL_INCLUDED 00028 00029 namespace cxsc { 00030 00031 INLINE civector::civector () throw():dat(NULL),l(1),u(0),size(0) 00032 { 00033 } 00034 00035 INLINE civector::civector(const int &i) throw():l(1),u(i),size(i) 00036 { 00037 dat=new cinterval[i]; 00038 } 00039 00040 #ifdef OLD_CXSC 00041 INLINE civector::civector(const class index &i) throw():l(1),u(i._int()),size(i._int()) 00042 { 00043 dat=new cinterval[i._int()]; 00044 } 00045 #endif 00046 00047 INLINE civector::civector(const int &i1,const int &i2) 00048 #if(CXSC_INDEX_CHECK) 00049 throw(ERROR_CIVECTOR_WRONG_BOUNDARIES,ERROR_CIVECTOR_NO_MORE_MEMORY):l(i1),u(i2),size(i2-i1+1) 00050 #else 00051 throw():l(i1),u(i2),size(i2-i1+1) 00052 #endif 00053 { 00054 #if(CXSC_INDEX_CHECK) 00055 if(i1>i2) cxscthrow(ERROR_CIVECTOR_WRONG_BOUNDARIES("civector::civector(const int &i1,const int &i2)")); 00056 #endif 00057 dat=new cinterval[size]; 00058 } 00059 00060 INLINE civector::civector(const civector_slice &rs) throw():l(rs.start),u(rs.end),size(rs.end-rs.start+1) 00061 { 00062 dat=new cinterval[size]; 00063 for(int i=0, j=l-rs.l;i<size;i++,j++) 00064 dat[i]=rs.dat[j]; 00065 } 00066 00067 INLINE civector::civector(const cvector_slice &rs) throw():l(rs.start),u(rs.end),size(rs.end-rs.start+1) 00068 { 00069 dat=new cinterval[size]; 00070 for(int i=0, j=l-rs.l;i<size;i++,j++) 00071 dat[i]=rs.dat[j]; 00072 } 00073 00074 INLINE civector::civector(const ivector_slice &rs) throw():l(rs.start),u(rs.end),size(rs.end-rs.start+1) 00075 { 00076 dat=new cinterval[size]; 00077 for(int i=0, j=l-rs.l;i<size;i++,j++) 00078 dat[i]=rs.dat[j]; 00079 } 00080 00081 INLINE civector::civector(const rvector_slice &rs) throw():l(rs.start),u(rs.end),size(rs.end-rs.start+1) 00082 { 00083 dat=new cinterval[size]; 00084 for(int i=0, j=l-rs.l;i<size;i++,j++) 00085 dat[i]=rs.dat[j]; 00086 } 00087 00088 INLINE civector::civector(const civector &v) throw():l(v.l),u(v.u),size(v.size) 00089 { 00090 dat=new cinterval[size]; 00091 for (int i=0;i<size;i++) 00092 dat[i]=v.dat[i]; 00093 } 00094 00095 INLINE civector::civector(const cinterval &r) throw():l(1),u(1),size(1) 00096 { 00097 dat=new cinterval[1]; 00098 *dat=r; 00099 } 00100 00101 INLINE civector::civector(const cvector &v) throw():l(v.l),u(v.u),size(v.size) 00102 { 00103 dat=new cinterval[size]; 00104 for (int i=0;i<size;i++) 00105 dat[i]=v.dat[i]; 00106 } 00107 00108 INLINE civector::civector(const ivector &v) throw():l(v.l),u(v.u),size(v.size) 00109 { 00110 dat=new cinterval[size]; 00111 for (int i=0;i<size;i++) 00112 dat[i]=v.dat[i]; 00113 } 00114 00115 INLINE civector::civector(const rvector &v) throw():l(v.l),u(v.u),size(v.size) 00116 { 00117 dat=new cinterval[size]; 00118 for (int i=0;i<size;i++) 00119 dat[i]=v.dat[i]; 00120 } 00121 00122 INLINE civector::civector(const real &r) throw():l(1),u(1),size(1) 00123 { 00124 dat=new cinterval[1]; 00125 *dat=r; 00126 } 00127 00128 INLINE civector::civector(const interval &r) throw():l(1),u(1),size(1) 00129 { 00130 dat=new cinterval[1]; 00131 *dat=r; 00132 } 00133 00134 INLINE civector::civector(const complex &r) throw():l(1),u(1),size(1) 00135 { 00136 dat=new cinterval[1]; 00137 *dat=r; 00138 } 00139 00140 INLINE cinterval & civector::operator [](const int &i) const 00141 #if(CXSC_INDEX_CHECK) 00142 throw(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC) 00143 #else 00144 throw() 00145 #endif 00146 { 00147 #if(CXSC_INDEX_CHECK) 00148 if(i<l||i>u) cxscthrow(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC("cinterval & civector::operator [](const int &i)const ")); 00149 #endif 00150 return dat[i-l]; 00151 } 00152 00153 INLINE cinterval & civector::operator [](const int &i) 00154 #if(CXSC_INDEX_CHECK) 00155 throw(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC) 00156 #else 00157 throw() 00158 #endif 00159 { 00160 #if(CXSC_INDEX_CHECK) 00161 if(i<l||i>u) cxscthrow(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC("cinterval & civector::operator [](const int &i)")); 00162 #endif 00163 return dat[i-l]; 00164 } 00165 00166 INLINE cinterval & civector_slice::operator [](const int &i) const 00167 #if(CXSC_INDEX_CHECK) 00168 throw(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC) 00169 #else 00170 throw() 00171 #endif 00172 { 00173 #if(CXSC_INDEX_CHECK) 00174 if(i<start||i>end) cxscthrow(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC("cinterval & civector_slice::operator [](const int &i) const")); 00175 #endif 00176 return dat[i-l]; 00177 } 00178 00179 00180 INLINE cinterval & civector_slice::operator [](const int &i) 00181 #if(CXSC_INDEX_CHECK) 00182 throw(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC) 00183 #else 00184 throw() 00185 #endif 00186 { 00187 #if(CXSC_INDEX_CHECK) 00188 if(i<start||i>end) cxscthrow(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC("cinterval & civector_slice::operator [](const int &i)")); 00189 #endif 00190 return dat[i-l]; 00191 } 00192 00193 00194 00195 INLINE civector_slice civector::operator ()(const int &i) 00196 #if(CXSC_INDEX_CHECK) 00197 throw(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG) 00198 #else 00199 throw() 00200 #endif 00201 { 00202 #if(CXSC_INDEX_CHECK) 00203 if(1<l||i>u) cxscthrow(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG("civector_slice civector::operator ()(const int &i)")); 00204 #endif 00205 return civector_slice(*this,1,i); 00206 } 00207 00208 INLINE civector_slice civector::operator ()(const int &i1,const int &i2) 00209 #if(CXSC_INDEX_CHECK) 00210 throw(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG) 00211 #else 00212 throw() 00213 #endif 00214 { 00215 #if(CXSC_INDEX_CHECK) 00216 if(i1<l||i2>u) cxscthrow(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG("civector_slice civector::operator ()(const int &i1,const int &i2)")); 00217 #endif 00218 return civector_slice(*this,i1,i2); 00219 } 00220 00221 INLINE civector_slice civector_slice::operator ()(const int &i) 00222 #if(CXSC_INDEX_CHECK) 00223 throw(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG) 00224 #else 00225 throw() 00226 #endif 00227 { 00228 #if(CXSC_INDEX_CHECK) 00229 if(1<start||i>end) cxscthrow(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG("civector_slice civector_slice::operator ()(const int &i)")); 00230 #endif 00231 return civector_slice(*this,1,i); 00232 } 00233 00234 INLINE civector_slice civector_slice::operator ()(const int &i1,const int &i2) 00235 #if(CXSC_INDEX_CHECK) 00236 throw(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG) 00237 #else 00238 throw() 00239 #endif 00240 { 00241 #if(CXSC_INDEX_CHECK) 00242 if(i1<start||i2>end) cxscthrow(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG("civector_slice civector_slice::operator ()(const int &i1,const int &i2)")); 00243 #endif 00244 return civector_slice(*this,i1,i2); 00245 } 00246 00247 INLINE cinterval::cinterval(const civector &rv) 00248 #if(CXSC_INDEX_CHECK) 00249 throw(ERROR_CIVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_CIVECTOR_USE_OF_UNINITIALIZED_OBJ) 00250 #else 00251 throw() 00252 #endif 00253 { 00254 #if(CXSC_INDEX_CHECK) 00255 if(rv.size>1) cxscthrow(ERROR_CIVECTOR_TYPE_CAST_OF_THICK_OBJ("cinterval::cinterval(const civector &rv)")); 00256 else if(rv.size<1) cxscthrow(ERROR_CIVECTOR_USE_OF_UNINITIALIZED_OBJ("cinterval::cinterval(const civector &rv)")); 00257 #endif 00258 *this=rv.dat[0]; 00259 } 00260 00261 INLINE cinterval::cinterval(const civector_slice &sl) 00262 #if(CXSC_INDEX_CHECK) 00263 throw(ERROR_CIVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_CIVECTOR_USE_OF_UNINITIALIZED_OBJ) 00264 #else 00265 throw() 00266 #endif 00267 { 00268 #if(CXSC_INDEX_CHECK) 00269 if(sl.size>1) cxscthrow(ERROR_CIVECTOR_TYPE_CAST_OF_THICK_OBJ("cinterval::cinterval(const civector_slice &sl)")); 00270 else if(sl.size<1) cxscthrow(ERROR_CIVECTOR_USE_OF_UNINITIALIZED_OBJ("cinterval::cinterval(const civector_slice &sl)")); 00271 #endif 00272 *this=sl.dat[sl.start-sl.l]; 00273 } 00274 00280 INLINE civector _civector(const cinterval &r) throw() { return civector(r); } 00281 00287 INLINE civector _civector(const real &r) throw() { return civector(r); } 00293 INLINE civector _civector(const rvector_slice &rs) throw() { return civector(rs); } 00299 INLINE civector _civector(const rvector &rs) throw() { return civector(rs); } 00300 00306 INLINE civector _civector(const complex &r) throw() { return civector(r); } 00312 INLINE civector _civector(const cvector_slice &rs) throw() { return civector(rs); } 00318 INLINE civector _civector(const cvector &rs) throw() { return civector(rs); } 00319 00325 INLINE civector _civector(const interval &r) throw() { return civector(r); } 00331 INLINE civector _civector(const ivector_slice &rs) throw() { return civector(rs); } 00337 INLINE civector _civector(const ivector &rs) throw() { return civector(rs); } 00338 00339 INLINE civector &civector::operator =(const civector &rv) throw() { return _vvassign<civector,civector,cinterval>(*this,rv); } 00340 INLINE civector &civector::operator =(const cinterval &r) throw() { return _vsassign<civector,cinterval>(*this,r); } 00341 INLINE civector::operator void*() throw() { return _vvoid(*this); } 00342 INLINE civector_slice & civector_slice::operator =(const civector_slice &sl) 00343 #if(CXSC_INDEX_CHECK) 00344 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 00345 #else 00346 throw() 00347 #endif 00348 { return _vsvsassign(*this,sl); } 00349 INLINE civector_slice & civector_slice::operator =(const civector &rv) 00350 #if(CXSC_INDEX_CHECK) 00351 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 00352 #else 00353 throw() 00354 #endif 00355 { return _vsvassign(*this,rv); } 00356 INLINE civector_slice & civector_slice::operator =(const cinterval &r) throw() { return _vssassign<civector_slice,cinterval>(*this,r); } 00357 INLINE civector_slice & civector_slice::operator =(const cimatrix &m) 00358 #if(CXSC_INDEX_CHECK) 00359 throw(ERROR__OP_WITH_WRONG_DIM<civector>,ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ) 00360 #else 00361 throw() 00362 #endif 00363 { return _vsvassign(*this,civector(m)); } 00364 INLINE civector_slice::operator void*() throw() { return _vsvoid(*this); } 00365 00366 //======================================================================= 00367 //======================== Vector Functions ============================= 00368 00369 00370 INLINE civector &SetInf(civector &iv,const cvector &rv) 00371 #if(CXSC_INDEX_CHECK) 00372 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM) 00373 #else 00374 throw() 00375 #endif 00376 { return _vvsetinf(iv,rv); } 00377 INLINE civector_slice &SetInf(civector_slice &iv,const cvector &rv) 00378 #if(CXSC_INDEX_CHECK) 00379 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM) 00380 #else 00381 throw() 00382 #endif 00383 { return _vsvsetinf(iv,rv); } 00384 INLINE civector &SetInf(civector &iv,const cvector_slice &rv) 00385 #if(CXSC_INDEX_CHECK) 00386 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM) 00387 #else 00388 throw() 00389 #endif 00390 { return _vvssetinf(iv,rv); } 00391 INLINE civector_slice &SetInf(civector_slice &iv,const cvector_slice &rv) 00392 #if(CXSC_INDEX_CHECK) 00393 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM) 00394 #else 00395 throw() 00396 #endif 00397 { return _vsvssetinf(iv,rv); } 00398 INLINE civector &UncheckedSetInf(civector &iv,const cvector &rv) 00399 #if(CXSC_INDEX_CHECK) 00400 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM) 00401 #else 00402 throw() 00403 #endif 00404 { return _vvusetinf(iv,rv); } 00405 INLINE civector_slice &UncheckedSetInf(civector_slice &iv,const cvector &rv) 00406 #if(CXSC_INDEX_CHECK) 00407 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM) 00408 #else 00409 throw() 00410 #endif 00411 { return _vsvusetinf(iv,rv); } 00412 INLINE civector &UncheckedSetInf(civector &iv,const cvector_slice &rv) 00413 #if(CXSC_INDEX_CHECK) 00414 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM) 00415 #else 00416 throw() 00417 #endif 00418 { return _vvsusetinf(iv,rv); } 00419 INLINE civector_slice &UncheckedSetInf(civector_slice &iv,const cvector_slice &rv) 00420 #if(CXSC_INDEX_CHECK) 00421 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM) 00422 #else 00423 throw() 00424 #endif 00425 { return _vsvsusetinf(iv,rv); } 00426 00427 INLINE civector &SetSup(civector &iv,const cvector &rv) 00428 #if(CXSC_INDEX_CHECK) 00429 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM) 00430 #else 00431 throw() 00432 #endif 00433 { return _vvsetsup(iv,rv); } 00434 INLINE civector_slice &SetSup(civector_slice &iv,const cvector &rv) 00435 #if(CXSC_INDEX_CHECK) 00436 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM) 00437 #else 00438 throw() 00439 #endif 00440 { return _vsvsetsup(iv,rv); } 00441 INLINE civector &SetSup(civector &iv,const cvector_slice &rv) 00442 #if(CXSC_INDEX_CHECK) 00443 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM) 00444 #else 00445 throw() 00446 #endif 00447 { return _vvssetsup(iv,rv); } 00448 INLINE civector_slice &SetSup(civector_slice &iv,const cvector_slice &rv) 00449 #if(CXSC_INDEX_CHECK) 00450 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM) 00451 #else 00452 throw() 00453 #endif 00454 { return _vsvssetsup(iv,rv); } 00455 INLINE civector &UncheckedSetSup(civector &iv,const cvector &rv) 00456 #if(CXSC_INDEX_CHECK) 00457 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM) 00458 #else 00459 throw() 00460 #endif 00461 { return _vvusetsup(iv,rv); } 00462 INLINE civector_slice &UncheckedSetSup(civector_slice &iv,const cvector &rv) 00463 #if(CXSC_INDEX_CHECK) 00464 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM) 00465 #else 00466 throw() 00467 #endif 00468 { return _vsvusetsup(iv,rv); } 00469 INLINE civector &UncheckedSetSup(civector &iv,const cvector_slice &rv) 00470 #if(CXSC_INDEX_CHECK) 00471 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM) 00472 #else 00473 throw() 00474 #endif 00475 { return _vvsusetsup(iv,rv); } 00476 INLINE civector_slice &UncheckedSetSup(civector_slice &iv,const cvector_slice &rv) 00477 #if(CXSC_INDEX_CHECK) 00478 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM) 00479 #else 00480 throw() 00481 #endif 00482 { return _vsvsusetsup(iv,rv); } 00483 00484 INLINE civector &SetRe(civector &iv,const ivector &rv) 00485 #if(CXSC_INDEX_CHECK) 00486 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM) 00487 #else 00488 throw() 00489 #endif 00490 { return _vvsetre(iv,rv); } 00491 INLINE civector_slice &SetRe(civector_slice &iv,const ivector &rv) 00492 #if(CXSC_INDEX_CHECK) 00493 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM) 00494 #else 00495 throw() 00496 #endif 00497 { return _vsvsetre(iv,rv); } 00498 INLINE civector &SetRe(civector &iv,const ivector_slice &rv) 00499 #if(CXSC_INDEX_CHECK) 00500 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM) 00501 #else 00502 throw() 00503 #endif 00504 { return _vvssetre(iv,rv); } 00505 INLINE civector_slice &SetRe(civector_slice &iv,const ivector_slice &rv) 00506 #if(CXSC_INDEX_CHECK) 00507 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM) 00508 #else 00509 throw() 00510 #endif 00511 { return _vsvssetre(iv,rv); } 00512 00513 INLINE civector &SetIm(civector &iv,const ivector &rv) 00514 #if(CXSC_INDEX_CHECK) 00515 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM) 00516 #else 00517 throw() 00518 #endif 00519 { return _vvsetim(iv,rv); } 00520 INLINE civector_slice &SetIm(civector_slice &iv,const ivector &rv) 00521 #if(CXSC_INDEX_CHECK) 00522 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM) 00523 #else 00524 throw() 00525 #endif 00526 { return _vsvsetim(iv,rv); } 00527 INLINE civector &SetIm(civector &iv,const ivector_slice &rv) 00528 #if(CXSC_INDEX_CHECK) 00529 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM) 00530 #else 00531 throw() 00532 #endif 00533 { return _vvssetim(iv,rv); } 00534 INLINE civector_slice &SetIm(civector_slice &iv,const ivector_slice &rv) 00535 #if(CXSC_INDEX_CHECK) 00536 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM) 00537 #else 00538 throw() 00539 #endif 00540 { return _vsvssetim(iv,rv); } 00541 00542 INLINE civector &SetSup(civector &iv,const complex &r) throw() { return _vssetsup(iv,r); } 00543 INLINE civector &SetInf(civector &iv,const complex &r) throw() { return _vssetinf(iv,r); } 00544 INLINE civector &UncheckedSetSup(civector &iv,const complex &r) throw() { return _vsusetsup(iv,r); } 00545 INLINE civector &SetUncheckedInf(civector &iv,const complex &r) throw() { return _vsusetinf(iv,r); } 00546 INLINE civector &SetRe(civector &iv,const interval &r) throw() { return _vssetre(iv,r); } 00547 INLINE civector &SetIm(civector &iv,const interval &r) throw() { return _vssetim(iv,r); } 00548 00549 INLINE civector_slice &SetSup(civector_slice &iv,const complex &r) throw() { return _vsssetsup(iv,r); } 00550 INLINE civector_slice &SetInf(civector_slice &iv,const complex &r) throw() { return _vsssetinf(iv,r); } 00551 INLINE civector_slice &UncheckedSetSup(civector_slice &iv,const complex &r) throw() { return _vssusetsup(iv,r); } 00552 INLINE civector_slice &SetUncheckedInf(civector_slice &iv,const complex &r) throw() { return _vssusetinf(iv,r); } 00553 INLINE civector_slice &SetRe(civector_slice &iv,const interval &r) throw() { return _vsssetre(iv,r); } 00554 INLINE civector_slice &SetIm(civector_slice &iv,const interval &r) throw() { return _vsssetim(iv,r); } 00555 00556 INLINE ivector Re(const civector &v) throw() 00557 { 00558 ivector erg(v.l,v.u); 00559 00560 for(int i=0;i<v.size;i++) 00561 erg[i+v.l]=Re(v.dat[i]); 00562 00563 return erg; 00564 } 00565 00566 INLINE ivector Re(const civector_slice &sl) throw() 00567 { 00568 ivector erg(sl.start,sl.end); 00569 00570 for(int i=0,j=sl.start-sl.l;i<sl.size;i++,j++) 00571 erg[i+sl.start]=Re(sl.dat[j]); 00572 00573 return erg; 00574 } 00575 00576 INLINE rvector InfRe(const civector &v) throw() 00577 { 00578 rvector erg(v.l,v.u); 00579 00580 for(int i=0;i<v.size;i++) 00581 erg.dat[i]=InfRe(v.dat[i]); 00582 00583 return erg; 00584 } 00585 00586 INLINE rvector InfRe(const civector_slice &sl) throw() 00587 { 00588 rvector erg(sl.start,sl.end); 00589 00590 for(int i=0,j=sl.start-sl.l;i<sl.size;i++,j++) 00591 erg.dat[i]=InfRe(sl.dat[j]); 00592 00593 return erg; 00594 } 00595 00596 INLINE ivector Im(const civector &v) throw() 00597 { 00598 ivector erg(v.l,v.u); 00599 00600 for(int i=0;i<v.size;i++) 00601 erg[i+v.l]=Im(v.dat[i]); 00602 00603 return erg; 00604 } 00605 00606 INLINE ivector Im(const civector_slice &sl) throw() 00607 { 00608 ivector erg(sl.start,sl.end); 00609 00610 for(int i=0,j=sl.start-sl.l;i<sl.size;i++,j++) 00611 erg[i+sl.start]=Im(sl.dat[j]); 00612 00613 return erg; 00614 } 00615 00616 INLINE rvector InfIm(const civector &v) throw() 00617 { 00618 rvector erg(v.l,v.u); 00619 00620 for(int i=0;i<v.size;i++) 00621 erg.dat[i]=InfIm(v.dat[i]); 00622 00623 return erg; 00624 } 00625 00626 INLINE rvector InfIm(const civector_slice &sl) throw() 00627 { 00628 rvector erg(sl.start,sl.end); 00629 00630 for(int i=0,j=sl.start-sl.l;i<sl.size;i++,j++) 00631 erg.dat[i]=InfIm(sl.dat[j]); 00632 00633 return erg; 00634 } 00635 00636 00637 INLINE rvector SupIm(const civector &v) throw() 00638 { 00639 rvector erg(v.l,v.u); 00640 00641 for(int i=0;i<v.size;i++) 00642 erg.dat[i]=SupIm(v.dat[i]); 00643 00644 return erg; 00645 } 00646 00647 INLINE rvector SupIm(const civector_slice &sl) throw() 00648 { 00649 rvector erg(sl.start,sl.end); 00650 00651 for(int i=0,j=sl.start-sl.l;i<sl.size;i++,j++) 00652 erg.dat[i]=SupIm(sl.dat[j]); 00653 00654 return erg; 00655 } 00656 00657 00658 00659 INLINE rvector SupRe(const civector &v) throw() 00660 { 00661 rvector erg(v.l,v.u); 00662 00663 for(int i=0;i<v.size;i++) 00664 erg.dat[i]=SupRe(v.dat[i]); 00665 00666 return erg; 00667 } 00668 00669 INLINE rvector SupRe(const civector_slice &sl) throw() 00670 { 00671 rvector erg(sl.start,sl.end); 00672 00673 for(int i=0,j=sl.start-sl.l;i<sl.size;i++,j++) 00674 erg.dat[i]=SupRe(sl.dat[j]); 00675 00676 return erg; 00677 } 00678 00679 INLINE void Resize(civector &rv) throw() { _vresize(rv); } 00680 INLINE void Resize(civector &rv, const int &len) 00681 #if(CXSC_INDEX_CHECK) 00682 throw(ERROR__WRONG_BOUNDARIES<civector>) 00683 #else 00684 throw() 00685 #endif 00686 { _vresize<class civector,class cinterval>(rv,len); } 00687 INLINE void Resize(civector &rv, const int &lb, const int &ub) 00688 #if(CXSC_INDEX_CHECK) 00689 throw(ERROR__WRONG_BOUNDARIES<civector>) 00690 #else 00691 throw() 00692 #endif 00693 { _vresize<class civector,class cinterval>(rv,lb,ub); } 00694 00695 INLINE civector conj(const civector &rv) throw() { return _vconj<civector>(rv); } 00696 INLINE civector conj(const civector_slice &sl) throw() { return _vsconj<civector_slice,civector>(sl); } 00697 00698 INLINE ivector abs(const civector &rv) throw() { return _vabs<civector,ivector>(rv); } 00699 INLINE ivector abs(const civector_slice &sl) throw() { return _vsabs<civector_slice,ivector>(sl); } 00700 INLINE cvector diam(const civector &v) throw() { return _vdiam<civector,cvector>(v); } 00701 INLINE cvector diam(const civector_slice &v) throw() { return _vsdiam<civector_slice,cvector>(v); } 00702 INLINE cvector mid(const civector &v) throw() { return _vmid<civector,cvector>(v); } 00703 INLINE cvector mid(const civector_slice &v) throw() { return _vsmid<civector_slice,cvector>(v); } 00704 INLINE cvector Inf(const civector &v) throw() { return _vinf<civector,cvector>(v); } 00705 INLINE cvector Inf(const civector_slice &v) throw() { return _vsinf<civector_slice,cvector>(v); } 00706 INLINE cvector Sup(const civector &v) throw() { return _vsup<civector,cvector>(v); } 00707 INLINE cvector Sup(const civector_slice &v) throw() { return _vssup<civector_slice,cvector>(v); } 00708 INLINE bool operator !(const civector &rv) throw() { return _vnot(rv); } 00709 INLINE bool operator !(const civector_slice &sl) throw() { return _vsnot(sl); } 00710 00711 //======================= Vector / Scalar =============================== 00712 00713 //----------------------------- cinterval --------------------------- 00714 00715 INLINE civector operator *(const civector &rv, const cinterval &s) throw() { return _vsmult<civector,cinterval,civector>(rv,s); } 00716 INLINE civector operator *(const civector_slice &sl, const cinterval &s) throw() { return _vssmult<civector_slice,cinterval,civector>(sl,s); } 00717 INLINE civector operator *(const cinterval &s, const civector &rv) throw() { return _vsmult<civector,cinterval,civector>(rv,s); } 00718 INLINE civector operator *(const cinterval &s, const civector_slice &sl) throw() { return _vssmult<civector_slice,cinterval,civector>(sl,s); } 00719 INLINE civector &operator *=(civector &rv,const cinterval &r) throw() { return _vsmultassign(rv,r); } 00720 INLINE civector_slice &civector_slice::operator *=(const cinterval &r) throw() { return _vssmultassign(*this,r); } 00721 00722 INLINE civector operator /(const civector &rv, const cinterval &s) throw() { return _vsdiv<civector,cinterval,civector>(rv,s); } 00723 INLINE civector operator /(const civector_slice &sl, const cinterval &s) throw() { return _vssdiv<civector_slice,cinterval,civector>(sl,s); } 00724 INLINE civector &operator /=(civector &rv,const cinterval &r) throw() { return _vsdivassign(rv,r); } 00725 INLINE civector_slice &civector_slice::operator /=(const cinterval &r) throw() { return _vssdivassign(*this,r); } 00726 00727 //---------------------------- Real -------------------------------------- 00728 00729 INLINE civector operator *(const civector &rv, const real &s) throw() { return _vsmult<civector,real,civector>(rv,s); } 00730 INLINE civector operator *(const civector_slice &sl, const real &s) throw() { return _vssmult<civector_slice,real,civector>(sl,s); } 00731 INLINE civector operator *(const real &s, const civector &rv) throw() { return _vsmult<civector,real,civector>(rv,s); } 00732 INLINE civector operator *(const real &s, const civector_slice &sl) throw() { return _vssmult<civector_slice,real,civector>(sl,s); } 00733 INLINE civector &operator *=(civector &rv,const real &r) throw() { return _vsmultassign(rv,r); } 00734 INLINE civector_slice &civector_slice::operator *=(const real &r) throw() { return _vssmultassign(*this,r); } 00735 00736 INLINE civector operator /(const civector &rv, const real &s) throw() { return _vsdiv<civector,real,civector>(rv,s); } 00737 INLINE civector operator /(const civector_slice &sl, const real &s) throw() { return _vssdiv<civector_slice,real,civector>(sl,s); } 00738 INLINE civector &operator /=(civector &rv,const real &r) throw() { return _vsdivassign(rv,r); } 00739 INLINE civector_slice &civector_slice::operator /=(const real &r) throw() { return _vssdivassign(*this,r); } 00740 00741 INLINE civector operator *(const rvector &rv, const cinterval &s) throw() { return _vsmult<rvector,cinterval,civector>(rv,s); } 00742 INLINE civector operator *(const rvector_slice &sl, const cinterval &s) throw() { return _vssmult<rvector_slice,cinterval,civector>(sl,s); } 00743 INLINE civector operator *(const cinterval &s, const rvector &rv) throw() { return _vsmult<rvector,cinterval,civector>(rv,s); } 00744 INLINE civector operator *(const cinterval &s, const rvector_slice &sl) throw() { return _vssmult<rvector_slice,cinterval,civector>(sl,s); } 00745 00746 INLINE civector operator /(const rvector &rv, const cinterval &s) throw() { return _vsdiv<rvector,cinterval,civector>(rv,s); } 00747 INLINE civector operator /(const rvector_slice &sl, const cinterval &s) throw() { return _vssdiv<rvector_slice,cinterval,civector>(sl,s); } 00748 00749 //---------------------------- complex -------------------------------------- 00750 00751 INLINE civector operator *(const civector &rv, const complex &s) throw() { return _vsmult<civector,complex,civector>(rv,s); } 00752 INLINE civector operator *(const civector_slice &sl, const complex &s) throw() { return _vssmult<civector_slice,complex,civector>(sl,s); } 00753 INLINE civector operator *(const complex &s, const civector &rv) throw() { return _vsmult<civector,complex,civector>(rv,s); } 00754 INLINE civector operator *(const complex &s, const civector_slice &sl) throw() { return _vssmult<civector_slice,complex,civector>(sl,s); } 00755 INLINE civector &operator *=(civector &rv,const complex &r) throw() { return _vsmultassign(rv,r); } 00756 INLINE civector_slice &civector_slice::operator *=(const complex &r) throw() { return _vssmultassign(*this,r); } 00757 00758 INLINE civector operator /(const civector &rv, const complex &s) throw() { return _vsdiv<civector,complex,civector>(rv,s); } 00759 INLINE civector operator /(const civector_slice &sl, const complex &s) throw() { return _vssdiv<civector_slice,complex,civector>(sl,s); } 00760 INLINE civector &operator /=(civector &rv,const complex &r) throw() { return _vsdivassign(rv,r); } 00761 INLINE civector_slice &civector_slice::operator /=(const complex &r) throw() { return _vssdivassign(*this,r); } 00762 00763 INLINE civector operator *(const cvector &rv, const cinterval &s) throw() { return _vsmult<cvector,cinterval,civector>(rv,s); } 00764 INLINE civector operator *(const cvector_slice &sl, const cinterval &s) throw() { return _vssmult<cvector_slice,cinterval,civector>(sl,s); } 00765 INLINE civector operator *(const cinterval &s, const cvector &rv) throw() { return _vsmult<cvector,cinterval,civector>(rv,s); } 00766 INLINE civector operator *(const cinterval &s, const cvector_slice &sl) throw() { return _vssmult<cvector_slice,cinterval,civector>(sl,s); } 00767 00768 INLINE civector operator /(const cvector &rv, const cinterval &s) throw() { return _vsdiv<cvector,cinterval,civector>(rv,s); } 00769 INLINE civector operator /(const cvector_slice &sl, const cinterval &s) throw() { return _vssdiv<cvector_slice,cinterval,civector>(sl,s); } 00770 00771 //---------------------------- interval -------------------------------------- 00772 00773 INLINE civector operator *(const civector &rv, const interval &s) throw() { return _vsmult<civector,interval,civector>(rv,s); } 00774 INLINE civector operator *(const civector_slice &sl, const interval &s) throw() { return _vssmult<civector_slice,interval,civector>(sl,s); } 00775 INLINE civector operator *(const interval &s, const civector &rv) throw() { return _vsmult<civector,interval,civector>(rv,s); } 00776 INLINE civector operator *(const interval &s, const civector_slice &sl) throw() { return _vssmult<civector_slice,interval,civector>(sl,s); } 00777 INLINE civector &operator *=(civector &rv,const interval &r) throw() { return _vsmultassign(rv,r); } 00778 INLINE civector_slice &civector_slice::operator *=(const interval &r) throw() { return _vssmultassign(*this,r); } 00779 00780 INLINE civector operator /(const civector &rv, const interval &s) throw() { return _vsdiv<civector,interval,civector>(rv,s); } 00781 INLINE civector operator /(const civector_slice &sl, const interval &s) throw() { return _vssdiv<civector_slice,interval,civector>(sl,s); } 00782 INLINE civector &operator /=(civector &rv,const interval &r) throw() { return _vsdivassign(rv,r); } 00783 INLINE civector_slice &civector_slice::operator /=(const interval &r) throw() { return _vssdivassign(*this,r); } 00784 00785 INLINE civector operator *(const ivector &rv, const cinterval &s) throw() { return _vsmult<ivector,cinterval,civector>(rv,s); } 00786 INLINE civector operator *(const ivector_slice &sl, const cinterval &s) throw() { return _vssmult<ivector_slice,cinterval,civector>(sl,s); } 00787 INLINE civector operator *(const cinterval &s, const ivector &rv) throw() { return _vsmult<ivector,cinterval,civector>(rv,s); } 00788 INLINE civector operator *(const cinterval &s, const ivector_slice &sl) throw() { return _vssmult<ivector_slice,cinterval,civector>(sl,s); } 00789 00790 INLINE civector operator /(const ivector &rv, const cinterval &s) throw() { return _vsdiv<ivector,cinterval,civector>(rv,s); } 00791 INLINE civector operator /(const ivector_slice &sl, const cinterval &s) throw() { return _vssdiv<ivector_slice,cinterval,civector>(sl,s); } 00792 00793 //======================= Vector / Vector =============================== 00794 00795 00796 INLINE std::ostream &operator <<(std::ostream &s, const civector &rv) throw() { return _vout(s,rv); } 00797 INLINE std::ostream &operator <<(std::ostream &o, const civector_slice &sl) throw() { return _vsout(o,sl); } 00798 INLINE std::istream &operator >>(std::istream &s, civector &rv) throw() { return _vin(s,rv); } 00799 INLINE std::istream &operator >>(std::istream &s, civector_slice &rv) throw() { return _vsin(s,rv); } 00800 00801 //----------------------- cinterval / cinterval --------------------------- 00802 INLINE civector & civector::operator =(const civector_slice &sl) throw() { return _vvsassign<civector,civector_slice,cinterval>(*this,sl); } 00803 00804 00805 INLINE cinterval operator *(const civector & rv1, const civector &rv2) 00806 #if(CXSC_INDEX_CHECK) 00807 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 00808 #else 00809 throw() 00810 #endif 00811 { return _vvcimult<civector,civector,cinterval>(rv1,rv2); } 00812 INLINE cinterval operator *(const civector_slice &sl, const civector &rv) 00813 #if(CXSC_INDEX_CHECK) 00814 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 00815 #else 00816 throw() 00817 #endif 00818 { return _vsvcimult<civector_slice,civector,cinterval>(sl,rv); } 00819 INLINE cinterval operator *(const civector &rv, const civector_slice &sl) 00820 #if(CXSC_INDEX_CHECK) 00821 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 00822 #else 00823 throw() 00824 #endif 00825 { return _vsvcimult<civector_slice,civector,cinterval>(sl,rv); } 00826 INLINE cinterval operator *(const civector_slice & sl1, const civector_slice &sl2) 00827 #if(CXSC_INDEX_CHECK) 00828 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 00829 #else 00830 throw() 00831 #endif 00832 { return _vsvscimult<civector_slice,civector_slice,cinterval>(sl1,sl2); } 00833 00834 INLINE const civector &operator +(const civector &rv) throw() { return rv; } 00835 INLINE civector operator +(const civector_slice &sl) throw() { return sl; } 00836 INLINE civector operator +(const civector &rv1, const civector &rv2) 00837 #if(CXSC_INDEX_CHECK) 00838 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 00839 #else 00840 throw() 00841 #endif 00842 { return _vvplus<civector,civector,civector>(rv1,rv2); } 00843 INLINE civector operator +(const civector &rv, const civector_slice &sl) 00844 #if(CXSC_INDEX_CHECK) 00845 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 00846 #else 00847 throw() 00848 #endif 00849 { return _vvsplus<civector,civector_slice,civector>(rv,sl); } 00850 INLINE civector operator +(const civector_slice &sl, const civector &rv) 00851 #if(CXSC_INDEX_CHECK) 00852 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 00853 #else 00854 throw() 00855 #endif 00856 { return _vvsplus<civector,civector_slice,civector>(rv,sl); } 00857 INLINE civector operator +(const civector_slice &sl1, const civector_slice &sl2) 00858 #if(CXSC_INDEX_CHECK) 00859 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 00860 #else 00861 throw() 00862 #endif 00863 { return _vsvsplus<civector_slice,civector_slice,civector>(sl1,sl2); } 00864 INLINE civector & operator +=(civector &rv1, const civector &rv2) 00865 #if(CXSC_INDEX_CHECK) 00866 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 00867 #else 00868 throw() 00869 #endif 00870 { return _vvplusassign(rv1,rv2); } 00871 INLINE civector &operator +=(civector &rv, const civector_slice &sl) 00872 #if(CXSC_INDEX_CHECK) 00873 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 00874 #else 00875 throw() 00876 #endif 00877 { return _vvsplusassign(rv,sl); } 00878 INLINE civector_slice &civector_slice::operator +=(const civector &rv) 00879 #if(CXSC_INDEX_CHECK) 00880 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 00881 #else 00882 throw() 00883 #endif 00884 { return _vsvplusassign(*this,rv); } 00885 INLINE civector_slice &civector_slice::operator +=(const civector_slice &sl2) 00886 #if(CXSC_INDEX_CHECK) 00887 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 00888 #else 00889 throw() 00890 #endif 00891 { return _vsvsplusassign(*this,sl2); } 00892 00893 INLINE civector operator -(const civector &rv) throw() { return _vminus(rv); } 00894 INLINE civector operator -(const civector_slice &sl) throw() { return _vsminus<civector_slice,civector>(sl); } 00895 INLINE civector operator -(const civector &rv1, const civector &rv2) 00896 #if(CXSC_INDEX_CHECK) 00897 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 00898 #else 00899 throw() 00900 #endif 00901 { return _vvminus<civector,civector,civector>(rv1,rv2); } 00902 INLINE civector operator -(const civector &rv, const civector_slice &sl) 00903 #if(CXSC_INDEX_CHECK) 00904 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 00905 #else 00906 throw() 00907 #endif 00908 { return _vvsminus<civector,civector_slice,civector>(rv,sl); } 00909 INLINE civector operator -(const civector_slice &sl, const civector &rv) 00910 #if(CXSC_INDEX_CHECK) 00911 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 00912 #else 00913 throw() 00914 #endif 00915 { return _vsvminus<civector_slice,civector,civector>(sl,rv); } 00916 INLINE civector operator -(const civector_slice &sl1, const civector_slice &sl2) 00917 #if(CXSC_INDEX_CHECK) 00918 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 00919 #else 00920 throw() 00921 #endif 00922 { return _vsvsminus<civector_slice,civector_slice,civector>(sl1,sl2); } 00923 INLINE civector & operator -=(civector &rv1, const civector &rv2) 00924 #if(CXSC_INDEX_CHECK) 00925 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 00926 #else 00927 throw() 00928 #endif 00929 { return _vvminusassign(rv1,rv2); } 00930 INLINE civector &operator -=(civector &rv, const civector_slice &sl) 00931 #if(CXSC_INDEX_CHECK) 00932 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 00933 #else 00934 throw() 00935 #endif 00936 { return _vvsminusassign(rv,sl); } 00937 INLINE civector_slice &civector_slice::operator -=(const civector &rv) 00938 #if(CXSC_INDEX_CHECK) 00939 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 00940 #else 00941 throw() 00942 #endif 00943 { return _vsvminusassign(*this,rv); } 00944 INLINE civector_slice &civector_slice::operator -=(const civector_slice &sl2) 00945 #if(CXSC_INDEX_CHECK) 00946 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 00947 #else 00948 throw() 00949 #endif 00950 { return _vsvsminusassign(*this,sl2); } 00951 00952 INLINE civector operator |(const civector &rv1, const civector &rv2) 00953 #if(CXSC_INDEX_CHECK) 00954 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 00955 #else 00956 throw() 00957 #endif 00958 { return _vvconv<civector,civector,civector>(rv1,rv2); } 00959 INLINE civector operator |(const civector &rv, const civector_slice &sl) 00960 #if(CXSC_INDEX_CHECK) 00961 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 00962 #else 00963 throw() 00964 #endif 00965 { return _vvsconv<civector,civector_slice,civector>(rv,sl); } 00966 INLINE civector operator |(const civector_slice &sl, const civector &rv) 00967 #if(CXSC_INDEX_CHECK) 00968 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 00969 #else 00970 throw() 00971 #endif 00972 { return _vvsconv<civector,civector_slice,civector>(rv,sl); } 00973 INLINE civector operator |(const civector_slice &sl1, const civector_slice &sl2) 00974 #if(CXSC_INDEX_CHECK) 00975 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 00976 #else 00977 throw() 00978 #endif 00979 { return _vsvsconv<civector_slice,civector_slice,civector>(sl1,sl2); } 00980 INLINE civector & operator |=(civector &rv1, const civector &rv2) 00981 #if(CXSC_INDEX_CHECK) 00982 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 00983 #else 00984 throw() 00985 #endif 00986 { return _vvconvassign(rv1,rv2); } 00987 INLINE civector &operator |=(civector &rv, const civector_slice &sl) 00988 #if(CXSC_INDEX_CHECK) 00989 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 00990 #else 00991 throw() 00992 #endif 00993 { return _vvsconvassign(rv,sl); } 00994 INLINE civector_slice &civector_slice::operator |=(const civector &rv) 00995 #if(CXSC_INDEX_CHECK) 00996 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 00997 #else 00998 throw() 00999 #endif 01000 { return _vsvconvassign(*this,rv); } 01001 INLINE civector_slice &civector_slice::operator |=(const civector_slice &sl2) 01002 #if(CXSC_INDEX_CHECK) 01003 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01004 #else 01005 throw() 01006 #endif 01007 { return _vsvsconvassign(*this,sl2); } 01008 01009 INLINE civector operator &(const civector &rv1, const civector &rv2) 01010 #if(CXSC_INDEX_CHECK) 01011 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01012 #else 01013 throw() 01014 #endif 01015 { return _vvsect<civector,civector,civector>(rv1,rv2); } 01016 INLINE civector operator &(const civector &rv, const civector_slice &sl) 01017 #if(CXSC_INDEX_CHECK) 01018 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01019 #else 01020 throw() 01021 #endif 01022 { return _vvssect<civector,civector_slice,civector>(rv,sl); } 01023 INLINE civector operator &(const civector_slice &sl, const civector &rv) 01024 #if(CXSC_INDEX_CHECK) 01025 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01026 #else 01027 throw() 01028 #endif 01029 { return _vvssect<civector,civector_slice,civector>(rv,sl); } 01030 INLINE civector operator &(const civector_slice &sl1, const civector_slice &sl2) 01031 #if(CXSC_INDEX_CHECK) 01032 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01033 #else 01034 throw() 01035 #endif 01036 { return _vsvssect<civector_slice,civector_slice,civector>(sl1,sl2); } 01037 INLINE civector & operator &=(civector &rv1, const civector &rv2) 01038 #if(CXSC_INDEX_CHECK) 01039 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01040 #else 01041 throw() 01042 #endif 01043 { return _vvsectassign(rv1,rv2); } 01044 INLINE civector &operator &=(civector &rv, const civector_slice &sl) 01045 #if(CXSC_INDEX_CHECK) 01046 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01047 #else 01048 throw() 01049 #endif 01050 { return _vvssectassign(rv,sl); } 01051 INLINE civector_slice &civector_slice::operator &=(const civector &rv) 01052 #if(CXSC_INDEX_CHECK) 01053 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01054 #else 01055 throw() 01056 #endif 01057 { return _vsvsectassign(*this,rv); } 01058 INLINE civector_slice &civector_slice::operator &=(const civector_slice &sl2) 01059 #if(CXSC_INDEX_CHECK) 01060 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01061 #else 01062 throw() 01063 #endif 01064 { return _vsvssectassign(*this,sl2); } 01065 01066 INLINE bool operator ==(const civector &rv1, const civector &rv2) throw() { return _vveq(rv1,rv2); } 01067 INLINE bool operator ==(const civector_slice &sl1, const civector_slice &sl2) throw() { return _vsvseq(sl1,sl2); } 01068 INLINE bool operator ==(const civector_slice &sl, const civector &rv) throw() { return _vsveq(sl,rv); } 01069 INLINE bool operator ==(const civector &rv, const civector_slice &sl) throw() { return _vsveq(sl,rv); } 01070 INLINE bool operator !=(const civector &rv1, const civector &rv2) throw() { return _vvneq(rv1,rv2); } 01071 INLINE bool operator !=(const civector_slice &sl1, const civector_slice &sl2) throw() { return _vsvsneq(sl1,sl2); } 01072 INLINE bool operator !=(const civector_slice &sl, const civector &rv) throw() { return _vsvneq(sl,rv); } 01073 INLINE bool operator !=(const civector &rv, const civector_slice &sl) throw() { return _vsvneq(sl,rv); } 01074 INLINE bool operator <(const civector &rv1, const civector &rv2) throw() { return _vvless(rv1,rv2); } 01075 INLINE bool operator <(const civector_slice &sl1, const civector_slice &sl2) throw() { return _vsvsless(sl1,sl2); } 01076 INLINE bool operator < (const civector_slice &sl, const civector &rv) throw() { return _vsvless(sl,rv); } 01077 INLINE bool operator < (const civector &rv, const civector_slice &sl) throw() { return _vvsless(rv,sl); } 01078 INLINE bool operator <=(const civector &rv1, const civector &rv2) throw() { return _vvleq(rv1,rv2); } 01079 INLINE bool operator <=(const civector_slice &sl1, const civector_slice &sl2) throw() { return _vsvsleq(sl1,sl2); } 01080 INLINE bool operator <=(const civector_slice &sl, const civector &rv) throw() { return _vsvleq(sl,rv); } 01081 INLINE bool operator <=(const civector &rv, const civector_slice &sl) throw() { return _vvsleq(rv,sl); } 01082 INLINE bool operator >(const civector &rv1, const civector &rv2) throw() { return _vvless(rv2,rv1); } 01083 INLINE bool operator >(const civector_slice &sl1, const civector_slice &sl2) throw() { return _vsvsless(sl2,sl1); } 01084 INLINE bool operator >(const civector_slice &sl, const civector &rv) throw() { return _vvsless(rv,sl); } 01085 INLINE bool operator >(const civector &rv, const civector_slice &sl) throw() { return _vsvless(sl,rv); } 01086 INLINE bool operator >=(const civector &rv1, const civector &rv2) throw() { return _vvleq(rv2,rv1); } 01087 INLINE bool operator >=(const civector_slice &sl1, const civector_slice &sl2) throw() { return _vsvsleq(sl2,sl1); } 01088 INLINE bool operator >=(const civector_slice &sl, const civector &rv) throw() { return _vvsleq(rv,sl); } 01089 INLINE bool operator >=(const civector &rv, const civector_slice &sl) throw() { return _vsvleq(sl,rv); } 01090 01091 //-------------------------------- cinterval / Real -------------------------------- 01092 01093 INLINE civector &civector::operator =(const rvector &rv) throw() { return _vvassign<civector,rvector,cinterval>(*this,rv); } 01094 INLINE civector &civector::operator =(const real &r) throw() { return _vsassign<civector,real>(*this,r); } 01095 INLINE civector & civector::operator =(const rvector_slice &sl) throw() { return _vvsassign<civector,rvector_slice,cinterval>(*this,sl); } 01096 INLINE civector_slice &civector_slice::operator =(const rvector &rv) 01097 #if(CXSC_INDEX_CHECK) 01098 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01099 #else 01100 throw() 01101 #endif 01102 { return _vsvassign(*this,rv); } 01103 INLINE civector_slice &civector_slice::operator =(const real &r) throw() { return _vssassign<civector_slice,real>(*this,r); } 01104 INLINE civector_slice & civector_slice::operator =(const rvector_slice &sl) 01105 #if(CXSC_INDEX_CHECK) 01106 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01107 #else 01108 throw() 01109 #endif 01110 { return _vsvsassign(*this,sl); } 01111 01112 01113 INLINE cinterval operator *(const rvector & rv1, const civector &rv2) 01114 #if(CXSC_INDEX_CHECK) 01115 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01116 #else 01117 throw() 01118 #endif 01119 { return _vvcimult<rvector,civector,cinterval>(rv1,rv2); } 01120 INLINE cinterval operator *(const rvector_slice &sl, const civector &rv) 01121 #if(CXSC_INDEX_CHECK) 01122 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01123 #else 01124 throw() 01125 #endif 01126 { return _vsvcimult<rvector_slice,civector,cinterval>(sl,rv); } 01127 INLINE cinterval operator *(const rvector &rv, const civector_slice &sl) 01128 #if(CXSC_INDEX_CHECK) 01129 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01130 #else 01131 throw() 01132 #endif 01133 { return _vsvcimult<civector_slice,rvector,cinterval>(sl,rv); } 01134 INLINE cinterval operator *(const rvector_slice & sl1, const civector_slice &sl2) 01135 #if(CXSC_INDEX_CHECK) 01136 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01137 #else 01138 throw() 01139 #endif 01140 { return _vsvscimult<rvector_slice,civector_slice,cinterval>(sl1,sl2); } 01141 01142 INLINE cinterval operator *(const civector & rv1, const rvector &rv2) 01143 #if(CXSC_INDEX_CHECK) 01144 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01145 #else 01146 throw() 01147 #endif 01148 { return _vvcimult<rvector,civector,cinterval>(rv2,rv1); } 01149 INLINE cinterval operator *(const civector_slice &sl, const rvector &rv) 01150 #if(CXSC_INDEX_CHECK) 01151 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01152 #else 01153 throw() 01154 #endif 01155 { return _vsvcimult<civector_slice,rvector,cinterval>(sl,rv); } 01156 INLINE cinterval operator *(const civector &rv, const rvector_slice &sl) 01157 #if(CXSC_INDEX_CHECK) 01158 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01159 #else 01160 throw() 01161 #endif 01162 { return _vsvcimult<rvector_slice,civector,cinterval>(sl,rv); } 01163 INLINE cinterval operator *(const civector_slice & sl1, const rvector_slice &sl2) 01164 #if(CXSC_INDEX_CHECK) 01165 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01166 #else 01167 throw() 01168 #endif 01169 { return _vsvscimult<rvector_slice,civector_slice,cinterval>(sl2,sl1); } 01170 01171 INLINE civector operator +(const rvector &rv1, const civector &rv2) 01172 #if(CXSC_INDEX_CHECK) 01173 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01174 #else 01175 throw() 01176 #endif 01177 { return _vvplus<rvector,civector,civector>(rv1,rv2); } 01178 INLINE civector operator +(const rvector &rv, const civector_slice &sl) 01179 #if(CXSC_INDEX_CHECK) 01180 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01181 #else 01182 throw() 01183 #endif 01184 { return _vvsplus<rvector,civector_slice,civector>(rv,sl); } 01185 INLINE civector operator +(const rvector_slice &sl, const civector &rv) 01186 #if(CXSC_INDEX_CHECK) 01187 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01188 #else 01189 throw() 01190 #endif 01191 { return _vvsplus<civector,rvector_slice,civector>(rv,sl); } 01192 INLINE civector operator +(const rvector_slice &sl1, const civector_slice &sl2) 01193 #if(CXSC_INDEX_CHECK) 01194 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01195 #else 01196 throw() 01197 #endif 01198 { return _vsvsplus<rvector_slice,civector_slice,civector>(sl1,sl2); } 01199 01200 INLINE civector operator +(const civector &rv1, const rvector &rv2) 01201 #if(CXSC_INDEX_CHECK) 01202 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01203 #else 01204 throw() 01205 #endif 01206 { return _vvplus<rvector,civector,civector>(rv2,rv1); } 01207 INLINE civector operator +(const civector &rv, const rvector_slice &sl) 01208 #if(CXSC_INDEX_CHECK) 01209 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01210 #else 01211 throw() 01212 #endif 01213 { return _vvsplus<civector,rvector_slice,civector>(rv,sl); } 01214 INLINE civector operator +(const civector_slice &sl, const rvector &rv) 01215 #if(CXSC_INDEX_CHECK) 01216 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01217 #else 01218 throw() 01219 #endif 01220 { return _vvsplus<rvector,civector_slice,civector>(rv,sl); } 01221 INLINE civector operator +(const civector_slice &sl1, const rvector_slice &sl2) 01222 #if(CXSC_INDEX_CHECK) 01223 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01224 #else 01225 throw() 01226 #endif 01227 { return _vsvsplus<rvector_slice,civector_slice,civector>(sl2,sl1); } 01228 01229 INLINE civector & operator +=(civector &rv1, const rvector &rv2) 01230 #if(CXSC_INDEX_CHECK) 01231 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01232 #else 01233 throw() 01234 #endif 01235 { return _vvplusassign(rv1,rv2); } 01236 INLINE civector &operator +=(civector &rv, const rvector_slice &sl) 01237 #if(CXSC_INDEX_CHECK) 01238 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01239 #else 01240 throw() 01241 #endif 01242 { return _vvsplusassign(rv,sl); } 01243 INLINE civector_slice &civector_slice::operator +=(const rvector &rv) 01244 #if(CXSC_INDEX_CHECK) 01245 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01246 #else 01247 throw() 01248 #endif 01249 { return _vsvplusassign(*this,rv); } 01250 INLINE civector_slice &civector_slice::operator +=(const rvector_slice &sl2) 01251 #if(CXSC_INDEX_CHECK) 01252 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01253 #else 01254 throw() 01255 #endif 01256 { return _vsvsplusassign(*this,sl2); } 01257 01258 INLINE civector operator -(const rvector &rv1, const civector &rv2) 01259 #if(CXSC_INDEX_CHECK) 01260 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01261 #else 01262 throw() 01263 #endif 01264 { return _vvminus<rvector,civector,civector>(rv1,rv2); } 01265 INLINE civector operator -(const rvector &rv, const civector_slice &sl) 01266 #if(CXSC_INDEX_CHECK) 01267 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01268 #else 01269 throw() 01270 #endif 01271 { return _vvsminus<rvector,civector_slice,civector>(rv,sl); } 01272 INLINE civector operator -(const rvector_slice &sl, const civector &rv) 01273 #if(CXSC_INDEX_CHECK) 01274 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01275 #else 01276 throw() 01277 #endif 01278 { return _vsvminus<rvector_slice,civector,civector>(sl,rv); } 01279 INLINE civector operator -(const rvector_slice &sl1, const civector_slice &sl2) 01280 #if(CXSC_INDEX_CHECK) 01281 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01282 #else 01283 throw() 01284 #endif 01285 { return _vsvsminus<rvector_slice,civector_slice,civector>(sl1,sl2); } 01286 01287 INLINE civector operator -(const civector &rv1, const rvector &rv2) 01288 #if(CXSC_INDEX_CHECK) 01289 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01290 #else 01291 throw() 01292 #endif 01293 { return _vvminus<civector,rvector,civector>(rv1,rv2); } 01294 INLINE civector operator -(const civector &rv, const rvector_slice &sl) 01295 #if(CXSC_INDEX_CHECK) 01296 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01297 #else 01298 throw() 01299 #endif 01300 { return _vvsminus<civector,rvector_slice,civector>(rv,sl); } 01301 INLINE civector operator -(const civector_slice &sl, const rvector &rv) 01302 #if(CXSC_INDEX_CHECK) 01303 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01304 #else 01305 throw() 01306 #endif 01307 { return _vsvminus<civector_slice,rvector,civector>(sl,rv); } 01308 INLINE civector operator -(const civector_slice &sl1, const rvector_slice &sl2) 01309 #if(CXSC_INDEX_CHECK) 01310 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01311 #else 01312 throw() 01313 #endif 01314 { return _vsvsminus<civector_slice,rvector_slice,civector>(sl1,sl2); } 01315 01316 INLINE civector & operator -=(civector &rv1, const rvector &rv2) 01317 #if(CXSC_INDEX_CHECK) 01318 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01319 #else 01320 throw() 01321 #endif 01322 { return _vvminusassign(rv1,rv2); } 01323 INLINE civector &operator -=(civector &rv, const rvector_slice &sl) 01324 #if(CXSC_INDEX_CHECK) 01325 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01326 #else 01327 throw() 01328 #endif 01329 { return _vvsminusassign(rv,sl); } 01330 INLINE civector_slice &civector_slice::operator -=(const rvector &rv) 01331 #if(CXSC_INDEX_CHECK) 01332 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01333 #else 01334 throw() 01335 #endif 01336 { return _vsvminusassign(*this,rv); } 01337 INLINE civector_slice &civector_slice::operator -=(const rvector_slice &sl2) 01338 #if(CXSC_INDEX_CHECK) 01339 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01340 #else 01341 throw() 01342 #endif 01343 { return _vsvsminusassign(*this,sl2); } 01344 01345 INLINE civector operator |(const rvector &rv1, const civector &rv2) 01346 #if(CXSC_INDEX_CHECK) 01347 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01348 #else 01349 throw() 01350 #endif 01351 { return _vvconv<rvector,civector,civector>(rv1,rv2); } 01352 INLINE civector operator |(const rvector &rv, const civector_slice &sl) 01353 #if(CXSC_INDEX_CHECK) 01354 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01355 #else 01356 throw() 01357 #endif 01358 { return _vvsconv<rvector,civector_slice,civector>(rv,sl); } 01359 INLINE civector operator |(const rvector_slice &sl, const civector &rv) 01360 #if(CXSC_INDEX_CHECK) 01361 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01362 #else 01363 throw() 01364 #endif 01365 { return _vvsconv<civector,rvector_slice,civector>(rv,sl); } 01366 INLINE civector operator |(const rvector_slice &sl1, const civector_slice &sl2) 01367 #if(CXSC_INDEX_CHECK) 01368 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01369 #else 01370 throw() 01371 #endif 01372 { return _vsvsconv<rvector_slice,civector_slice,civector>(sl1,sl2); } 01373 01374 INLINE civector operator |(const civector &rv1, const rvector &rv2) 01375 #if(CXSC_INDEX_CHECK) 01376 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01377 #else 01378 throw() 01379 #endif 01380 { return _vvconv<rvector,civector,civector>(rv2,rv1); } 01381 INLINE civector operator |(const civector &rv, const rvector_slice &sl) 01382 #if(CXSC_INDEX_CHECK) 01383 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01384 #else 01385 throw() 01386 #endif 01387 { return _vvsconv<civector,rvector_slice,civector>(rv,sl); } 01388 INLINE civector operator |(const civector_slice &sl, const rvector &rv) 01389 #if(CXSC_INDEX_CHECK) 01390 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01391 #else 01392 throw() 01393 #endif 01394 { return _vvsconv<rvector,civector_slice,civector>(rv,sl); } 01395 INLINE civector operator |(const civector_slice &sl1, const rvector_slice &sl2) 01396 #if(CXSC_INDEX_CHECK) 01397 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01398 #else 01399 throw() 01400 #endif 01401 { return _vsvsconv<rvector_slice,civector_slice,civector>(sl2,sl1); } 01402 01403 INLINE civector & operator |=(civector &rv1, const rvector &rv2) 01404 #if(CXSC_INDEX_CHECK) 01405 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01406 #else 01407 throw() 01408 #endif 01409 { return _vvconvassign(rv1,rv2); } 01410 INLINE civector &operator |=(civector &rv, const rvector_slice &sl) 01411 #if(CXSC_INDEX_CHECK) 01412 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01413 #else 01414 throw() 01415 #endif 01416 { return _vvsconvassign(rv,sl); } 01417 INLINE civector_slice &civector_slice::operator |=(const rvector &rv) 01418 #if(CXSC_INDEX_CHECK) 01419 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01420 #else 01421 throw() 01422 #endif 01423 { return _vsvconvassign(*this,rv); } 01424 INLINE civector_slice &civector_slice::operator |=(const rvector_slice &sl2) 01425 #if(CXSC_INDEX_CHECK) 01426 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01427 #else 01428 throw() 01429 #endif 01430 { return _vsvsconvassign(*this,sl2); } 01431 01432 INLINE civector operator &(const rvector &rv1, const civector &rv2) 01433 #if(CXSC_INDEX_CHECK) 01434 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01435 #else 01436 throw() 01437 #endif 01438 { return _vvsect<rvector,civector,civector>(rv1,rv2); } 01439 INLINE civector operator &(const rvector &rv, const civector_slice &sl) 01440 #if(CXSC_INDEX_CHECK) 01441 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01442 #else 01443 throw() 01444 #endif 01445 { return _vvssect<rvector,civector_slice,civector>(rv,sl); } 01446 INLINE civector operator &(const rvector_slice &sl, const civector &rv) 01447 #if(CXSC_INDEX_CHECK) 01448 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01449 #else 01450 throw() 01451 #endif 01452 { return _vvssect<civector,rvector_slice,civector>(rv,sl); } 01453 INLINE civector operator &(const rvector_slice &sl1, const civector_slice &sl2) 01454 #if(CXSC_INDEX_CHECK) 01455 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01456 #else 01457 throw() 01458 #endif 01459 { return _vsvssect<rvector_slice,civector_slice,civector>(sl1,sl2); } 01460 01461 INLINE civector operator &(const civector &rv1, const rvector &rv2) 01462 #if(CXSC_INDEX_CHECK) 01463 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01464 #else 01465 throw() 01466 #endif 01467 { return _vvsect<rvector,civector,civector>(rv2,rv1); } 01468 INLINE civector operator &(const civector &rv, const rvector_slice &sl) 01469 #if(CXSC_INDEX_CHECK) 01470 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01471 #else 01472 throw() 01473 #endif 01474 { return _vvssect<civector,rvector_slice,civector>(rv,sl); } 01475 INLINE civector operator &(const civector_slice &sl, const rvector &rv) 01476 #if(CXSC_INDEX_CHECK) 01477 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01478 #else 01479 throw() 01480 #endif 01481 { return _vvssect<rvector,civector_slice,civector>(rv,sl); } 01482 INLINE civector operator &(const civector_slice &sl1, const rvector_slice &sl2) 01483 #if(CXSC_INDEX_CHECK) 01484 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01485 #else 01486 throw() 01487 #endif 01488 { return _vsvssect<rvector_slice,civector_slice,civector>(sl2,sl1); } 01489 01490 INLINE civector & operator &=(civector &rv1, const rvector &rv2) 01491 #if(CXSC_INDEX_CHECK) 01492 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01493 #else 01494 throw() 01495 #endif 01496 { return _vvsectassign(rv1,rv2); } 01497 INLINE civector &operator &=(civector &rv, const rvector_slice &sl) 01498 #if(CXSC_INDEX_CHECK) 01499 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01500 #else 01501 throw() 01502 #endif 01503 { return _vvssectassign(rv,sl); } 01504 INLINE civector_slice &civector_slice::operator &=(const rvector &rv) 01505 #if(CXSC_INDEX_CHECK) 01506 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01507 #else 01508 throw() 01509 #endif 01510 { return _vsvsectassign(*this,rv); } 01511 INLINE civector_slice &civector_slice::operator &=(const rvector_slice &sl2) 01512 #if(CXSC_INDEX_CHECK) 01513 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01514 #else 01515 throw() 01516 #endif 01517 { return _vsvssectassign(*this,sl2); } 01518 01519 //-------------------------------- cinterval / complex -------------------------------- 01520 01521 INLINE civector &civector::operator =(const cvector &rv) throw() { return _vvassign<civector,cvector,cinterval>(*this,rv); } 01522 INLINE civector &civector::operator =(const complex &r) throw() { return _vsassign<civector,complex>(*this,r); } 01523 INLINE civector & civector::operator =(const cvector_slice &sl) throw() { return _vvsassign<civector,cvector_slice,cinterval>(*this,sl); } 01524 INLINE civector_slice &civector_slice::operator =(const cvector &rv) 01525 #if(CXSC_INDEX_CHECK) 01526 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01527 #else 01528 throw() 01529 #endif 01530 { return _vsvassign(*this,rv); } 01531 INLINE civector_slice &civector_slice::operator =(const complex &r) throw() { return _vssassign<civector_slice,complex>(*this,r); } 01532 INLINE civector_slice & civector_slice::operator =(const cvector_slice &sl) 01533 #if(CXSC_INDEX_CHECK) 01534 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01535 #else 01536 throw() 01537 #endif 01538 { return _vsvsassign(*this,sl); } 01539 01540 01541 INLINE cinterval operator *(const cvector & rv1, const civector &rv2) 01542 #if(CXSC_INDEX_CHECK) 01543 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01544 #else 01545 throw() 01546 #endif 01547 { return _vvcimult<cvector,civector,cinterval>(rv1,rv2); } 01548 INLINE cinterval operator *(const cvector_slice &sl, const civector &rv) 01549 #if(CXSC_INDEX_CHECK) 01550 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01551 #else 01552 throw() 01553 #endif 01554 { return _vsvcimult<cvector_slice,civector,cinterval>(sl,rv); } 01555 INLINE cinterval operator *(const cvector &rv, const civector_slice &sl) 01556 #if(CXSC_INDEX_CHECK) 01557 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01558 #else 01559 throw() 01560 #endif 01561 { return _vsvcimult<civector_slice,cvector,cinterval>(sl,rv); } 01562 INLINE cinterval operator *(const cvector_slice & sl1, const civector_slice &sl2) 01563 #if(CXSC_INDEX_CHECK) 01564 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01565 #else 01566 throw() 01567 #endif 01568 { return _vsvscimult<cvector_slice,civector_slice,cinterval>(sl1,sl2); } 01569 01570 INLINE cinterval operator *(const civector & rv1, const cvector &rv2) 01571 #if(CXSC_INDEX_CHECK) 01572 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01573 #else 01574 throw() 01575 #endif 01576 { return _vvcimult<cvector,civector,cinterval>(rv2,rv1); } 01577 INLINE cinterval operator *(const civector_slice &sl, const cvector &rv) 01578 #if(CXSC_INDEX_CHECK) 01579 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01580 #else 01581 throw() 01582 #endif 01583 { return _vsvcimult<civector_slice,cvector,cinterval>(sl,rv); } 01584 INLINE cinterval operator *(const civector &rv, const cvector_slice &sl) 01585 #if(CXSC_INDEX_CHECK) 01586 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01587 #else 01588 throw() 01589 #endif 01590 { return _vsvcimult<cvector_slice,civector,cinterval>(sl,rv); } 01591 INLINE cinterval operator *(const civector_slice & sl1, const cvector_slice &sl2) 01592 #if(CXSC_INDEX_CHECK) 01593 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01594 #else 01595 throw() 01596 #endif 01597 { return _vsvscimult<cvector_slice,civector_slice,cinterval>(sl2,sl1); } 01598 01599 INLINE civector operator +(const cvector &rv1, const civector &rv2) 01600 #if(CXSC_INDEX_CHECK) 01601 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01602 #else 01603 throw() 01604 #endif 01605 { return _vvplus<cvector,civector,civector>(rv1,rv2); } 01606 INLINE civector operator +(const cvector &rv, const civector_slice &sl) 01607 #if(CXSC_INDEX_CHECK) 01608 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01609 #else 01610 throw() 01611 #endif 01612 { return _vvsplus<cvector,civector_slice,civector>(rv,sl); } 01613 INLINE civector operator +(const cvector_slice &sl, const civector &rv) 01614 #if(CXSC_INDEX_CHECK) 01615 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01616 #else 01617 throw() 01618 #endif 01619 { return _vvsplus<civector,cvector_slice,civector>(rv,sl); } 01620 INLINE civector operator +(const cvector_slice &sl1, const civector_slice &sl2) 01621 #if(CXSC_INDEX_CHECK) 01622 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01623 #else 01624 throw() 01625 #endif 01626 { return _vsvsplus<cvector_slice,civector_slice,civector>(sl1,sl2); } 01627 01628 INLINE civector operator +(const civector &rv1, const cvector &rv2) 01629 #if(CXSC_INDEX_CHECK) 01630 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01631 #else 01632 throw() 01633 #endif 01634 { return _vvplus<cvector,civector,civector>(rv2,rv1); } 01635 INLINE civector operator +(const civector &rv, const cvector_slice &sl) 01636 #if(CXSC_INDEX_CHECK) 01637 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01638 #else 01639 throw() 01640 #endif 01641 { return _vvsplus<civector,cvector_slice,civector>(rv,sl); } 01642 INLINE civector operator +(const civector_slice &sl, const cvector &rv) 01643 #if(CXSC_INDEX_CHECK) 01644 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01645 #else 01646 throw() 01647 #endif 01648 { return _vvsplus<cvector,civector_slice,civector>(rv,sl); } 01649 INLINE civector operator +(const civector_slice &sl1, const cvector_slice &sl2) 01650 #if(CXSC_INDEX_CHECK) 01651 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01652 #else 01653 throw() 01654 #endif 01655 { return _vsvsplus<cvector_slice,civector_slice,civector>(sl2,sl1); } 01656 01657 INLINE civector & operator +=(civector &rv1, const cvector &rv2) 01658 #if(CXSC_INDEX_CHECK) 01659 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01660 #else 01661 throw() 01662 #endif 01663 { return _vvplusassign(rv1,rv2); } 01664 INLINE civector &operator +=(civector &rv, const cvector_slice &sl) 01665 #if(CXSC_INDEX_CHECK) 01666 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01667 #else 01668 throw() 01669 #endif 01670 { return _vvsplusassign(rv,sl); } 01671 INLINE civector_slice &civector_slice::operator +=(const cvector &rv) 01672 #if(CXSC_INDEX_CHECK) 01673 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01674 #else 01675 throw() 01676 #endif 01677 { return _vsvplusassign(*this,rv); } 01678 INLINE civector_slice &civector_slice::operator +=(const cvector_slice &sl2) 01679 #if(CXSC_INDEX_CHECK) 01680 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01681 #else 01682 throw() 01683 #endif 01684 { return _vsvsplusassign(*this,sl2); } 01685 01686 INLINE civector operator -(const cvector &rv1, const civector &rv2) 01687 #if(CXSC_INDEX_CHECK) 01688 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01689 #else 01690 throw() 01691 #endif 01692 { return _vvminus<cvector,civector,civector>(rv1,rv2); } 01693 INLINE civector operator -(const cvector &rv, const civector_slice &sl) 01694 #if(CXSC_INDEX_CHECK) 01695 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01696 #else 01697 throw() 01698 #endif 01699 { return _vvsminus<cvector,civector_slice,civector>(rv,sl); } 01700 INLINE civector operator -(const cvector_slice &sl, const civector &rv) 01701 #if(CXSC_INDEX_CHECK) 01702 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01703 #else 01704 throw() 01705 #endif 01706 { return _vsvminus<cvector_slice,civector,civector>(sl,rv); } 01707 INLINE civector operator -(const cvector_slice &sl1, const civector_slice &sl2) 01708 #if(CXSC_INDEX_CHECK) 01709 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01710 #else 01711 throw() 01712 #endif 01713 { return _vsvsminus<cvector_slice,civector_slice,civector>(sl1,sl2); } 01714 01715 INLINE civector operator -(const civector &rv1, const cvector &rv2) 01716 #if(CXSC_INDEX_CHECK) 01717 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01718 #else 01719 throw() 01720 #endif 01721 { return _vvminus<civector,cvector,civector>(rv1,rv2); } 01722 INLINE civector operator -(const civector &rv, const cvector_slice &sl) 01723 #if(CXSC_INDEX_CHECK) 01724 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01725 #else 01726 throw() 01727 #endif 01728 { return _vvsminus<civector,cvector_slice,civector>(rv,sl); } 01729 INLINE civector operator -(const civector_slice &sl, const cvector &rv) 01730 #if(CXSC_INDEX_CHECK) 01731 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01732 #else 01733 throw() 01734 #endif 01735 { return _vsvminus<civector_slice,cvector,civector>(sl,rv); } 01736 INLINE civector operator -(const civector_slice &sl1, const cvector_slice &sl2) 01737 #if(CXSC_INDEX_CHECK) 01738 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01739 #else 01740 throw() 01741 #endif 01742 { return _vsvsminus<civector_slice,cvector_slice,civector>(sl1,sl2); } 01743 01744 INLINE civector & operator -=(civector &rv1, const cvector &rv2) 01745 #if(CXSC_INDEX_CHECK) 01746 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01747 #else 01748 throw() 01749 #endif 01750 { return _vvminusassign(rv1,rv2); } 01751 INLINE civector &operator -=(civector &rv, const cvector_slice &sl) 01752 #if(CXSC_INDEX_CHECK) 01753 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01754 #else 01755 throw() 01756 #endif 01757 { return _vvsminusassign(rv,sl); } 01758 INLINE civector_slice &civector_slice::operator -=(const cvector &rv) 01759 #if(CXSC_INDEX_CHECK) 01760 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01761 #else 01762 throw() 01763 #endif 01764 { return _vsvminusassign(*this,rv); } 01765 INLINE civector_slice &civector_slice::operator -=(const cvector_slice &sl2) 01766 #if(CXSC_INDEX_CHECK) 01767 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01768 #else 01769 throw() 01770 #endif 01771 { return _vsvsminusassign(*this,sl2); } 01772 01773 INLINE civector operator |(const cvector &rv1, const civector &rv2) 01774 #if(CXSC_INDEX_CHECK) 01775 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01776 #else 01777 throw() 01778 #endif 01779 { return _vvconv<cvector,civector,civector>(rv1,rv2); } 01780 INLINE civector operator |(const cvector &rv, const civector_slice &sl) 01781 #if(CXSC_INDEX_CHECK) 01782 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01783 #else 01784 throw() 01785 #endif 01786 { return _vvsconv<cvector,civector_slice,civector>(rv,sl); } 01787 INLINE civector operator |(const cvector_slice &sl, const civector &rv) 01788 #if(CXSC_INDEX_CHECK) 01789 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01790 #else 01791 throw() 01792 #endif 01793 { return _vvsconv<civector,cvector_slice,civector>(rv,sl); } 01794 INLINE civector operator |(const cvector_slice &sl1, const civector_slice &sl2) 01795 #if(CXSC_INDEX_CHECK) 01796 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01797 #else 01798 throw() 01799 #endif 01800 { return _vsvsconv<cvector_slice,civector_slice,civector>(sl1,sl2); } 01801 01802 INLINE civector operator |(const civector &rv1, const cvector &rv2) 01803 #if(CXSC_INDEX_CHECK) 01804 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01805 #else 01806 throw() 01807 #endif 01808 { return _vvconv<cvector,civector,civector>(rv2,rv1); } 01809 INLINE civector operator |(const civector &rv, const cvector_slice &sl) 01810 #if(CXSC_INDEX_CHECK) 01811 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01812 #else 01813 throw() 01814 #endif 01815 { return _vvsconv<civector,cvector_slice,civector>(rv,sl); } 01816 INLINE civector operator |(const civector_slice &sl, const cvector &rv) 01817 #if(CXSC_INDEX_CHECK) 01818 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01819 #else 01820 throw() 01821 #endif 01822 { return _vvsconv<cvector,civector_slice,civector>(rv,sl); } 01823 INLINE civector operator |(const civector_slice &sl1, const cvector_slice &sl2) 01824 #if(CXSC_INDEX_CHECK) 01825 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01826 #else 01827 throw() 01828 #endif 01829 { return _vsvsconv<cvector_slice,civector_slice,civector>(sl2,sl1); } 01830 01831 INLINE civector & operator |=(civector &rv1, const cvector &rv2) 01832 #if(CXSC_INDEX_CHECK) 01833 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01834 #else 01835 throw() 01836 #endif 01837 { return _vvconvassign(rv1,rv2); } 01838 INLINE civector &operator |=(civector &rv, const cvector_slice &sl) 01839 #if(CXSC_INDEX_CHECK) 01840 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01841 #else 01842 throw() 01843 #endif 01844 { return _vvsconvassign(rv,sl); } 01845 INLINE civector_slice &civector_slice::operator |=(const cvector &rv) 01846 #if(CXSC_INDEX_CHECK) 01847 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01848 #else 01849 throw() 01850 #endif 01851 { return _vsvconvassign(*this,rv); } 01852 INLINE civector_slice &civector_slice::operator |=(const cvector_slice &sl2) 01853 #if(CXSC_INDEX_CHECK) 01854 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01855 #else 01856 throw() 01857 #endif 01858 { return _vsvsconvassign(*this,sl2); } 01859 01860 INLINE civector operator &(const cvector &rv1, const civector &rv2) 01861 #if(CXSC_INDEX_CHECK) 01862 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01863 #else 01864 throw() 01865 #endif 01866 { return _vvsect<cvector,civector,civector>(rv1,rv2); } 01867 INLINE civector operator &(const cvector &rv, const civector_slice &sl) 01868 #if(CXSC_INDEX_CHECK) 01869 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01870 #else 01871 throw() 01872 #endif 01873 { return _vvssect<cvector,civector_slice,civector>(rv,sl); } 01874 INLINE civector operator &(const cvector_slice &sl, const civector &rv) 01875 #if(CXSC_INDEX_CHECK) 01876 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01877 #else 01878 throw() 01879 #endif 01880 { return _vvssect<civector,cvector_slice,civector>(rv,sl); } 01881 INLINE civector operator &(const cvector_slice &sl1, const civector_slice &sl2) 01882 #if(CXSC_INDEX_CHECK) 01883 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01884 #else 01885 throw() 01886 #endif 01887 { return _vsvssect<cvector_slice,civector_slice,civector>(sl1,sl2); } 01888 01889 INLINE civector operator &(const civector &rv1, const cvector &rv2) 01890 #if(CXSC_INDEX_CHECK) 01891 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01892 #else 01893 throw() 01894 #endif 01895 { return _vvsect<cvector,civector,civector>(rv2,rv1); } 01896 INLINE civector operator &(const civector &rv, const cvector_slice &sl) 01897 #if(CXSC_INDEX_CHECK) 01898 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01899 #else 01900 throw() 01901 #endif 01902 { return _vvssect<civector,cvector_slice,civector>(rv,sl); } 01903 INLINE civector operator &(const civector_slice &sl, const cvector &rv) 01904 #if(CXSC_INDEX_CHECK) 01905 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01906 #else 01907 throw() 01908 #endif 01909 { return _vvssect<cvector,civector_slice,civector>(rv,sl); } 01910 INLINE civector operator &(const civector_slice &sl1, const cvector_slice &sl2) 01911 #if(CXSC_INDEX_CHECK) 01912 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01913 #else 01914 throw() 01915 #endif 01916 { return _vsvssect<cvector_slice,civector_slice,civector>(sl2,sl1); } 01917 01918 INLINE civector & operator &=(civector &rv1, const cvector &rv2) 01919 #if(CXSC_INDEX_CHECK) 01920 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01921 #else 01922 throw() 01923 #endif 01924 { return _vvsectassign(rv1,rv2); } 01925 INLINE civector &operator &=(civector &rv, const cvector_slice &sl) 01926 #if(CXSC_INDEX_CHECK) 01927 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01928 #else 01929 throw() 01930 #endif 01931 { return _vvssectassign(rv,sl); } 01932 INLINE civector_slice &civector_slice::operator &=(const cvector &rv) 01933 #if(CXSC_INDEX_CHECK) 01934 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01935 #else 01936 throw() 01937 #endif 01938 { return _vsvsectassign(*this,rv); } 01939 INLINE civector_slice &civector_slice::operator &=(const cvector_slice &sl2) 01940 #if(CXSC_INDEX_CHECK) 01941 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01942 #else 01943 throw() 01944 #endif 01945 { return _vsvssectassign(*this,sl2); } 01946 01947 //-------------------------------- cinterval / interval -------------------------------- 01948 01949 INLINE civector &civector::operator =(const ivector &rv) throw() { return _vvassign<civector,ivector,cinterval>(*this,rv); } 01950 INLINE civector &civector::operator =(const interval &r) throw() { return _vsassign<civector,interval>(*this,r); } 01951 INLINE civector & civector::operator =(const ivector_slice &sl) throw() { return _vvsassign<civector,ivector_slice,cinterval>(*this,sl); } 01952 INLINE civector_slice &civector_slice::operator =(const ivector &rv) 01953 #if(CXSC_INDEX_CHECK) 01954 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01955 #else 01956 throw() 01957 #endif 01958 { return _vsvassign(*this,rv); } 01959 INLINE civector_slice &civector_slice::operator =(const interval &r) throw() { return _vssassign<civector_slice,interval>(*this,r); } 01960 INLINE civector_slice & civector_slice::operator =(const ivector_slice &sl) 01961 #if(CXSC_INDEX_CHECK) 01962 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01963 #else 01964 throw() 01965 #endif 01966 { return _vsvsassign(*this,sl); } 01967 01968 01969 INLINE cinterval operator *(const ivector & rv1, const civector &rv2) 01970 #if(CXSC_INDEX_CHECK) 01971 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01972 #else 01973 throw() 01974 #endif 01975 { return _vvcimult<ivector,civector,cinterval>(rv1,rv2); } 01976 INLINE cinterval operator *(const ivector_slice &sl, const civector &rv) 01977 #if(CXSC_INDEX_CHECK) 01978 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01979 #else 01980 throw() 01981 #endif 01982 { return _vsvcimult<ivector_slice,civector,cinterval>(sl,rv); } 01983 INLINE cinterval operator *(const ivector &rv, const civector_slice &sl) 01984 #if(CXSC_INDEX_CHECK) 01985 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01986 #else 01987 throw() 01988 #endif 01989 { return _vsvcimult<civector_slice,ivector,cinterval>(sl,rv); } 01990 INLINE cinterval operator *(const ivector_slice & sl1, const civector_slice &sl2) 01991 #if(CXSC_INDEX_CHECK) 01992 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 01993 #else 01994 throw() 01995 #endif 01996 { return _vsvscimult<ivector_slice,civector_slice,cinterval>(sl1,sl2); } 01997 01998 INLINE cinterval operator *(const civector & rv1, const ivector &rv2) 01999 #if(CXSC_INDEX_CHECK) 02000 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02001 #else 02002 throw() 02003 #endif 02004 { return _vvcimult<ivector,civector,cinterval>(rv2,rv1); } 02005 INLINE cinterval operator *(const civector_slice &sl, const ivector &rv) 02006 #if(CXSC_INDEX_CHECK) 02007 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02008 #else 02009 throw() 02010 #endif 02011 { return _vsvcimult<civector_slice,ivector,cinterval>(sl,rv); } 02012 INLINE cinterval operator *(const civector &rv, const ivector_slice &sl) 02013 #if(CXSC_INDEX_CHECK) 02014 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02015 #else 02016 throw() 02017 #endif 02018 { return _vsvcimult<ivector_slice,civector,cinterval>(sl,rv); } 02019 INLINE cinterval operator *(const civector_slice & sl1, const ivector_slice &sl2) 02020 #if(CXSC_INDEX_CHECK) 02021 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02022 #else 02023 throw() 02024 #endif 02025 { return _vsvscimult<ivector_slice,civector_slice,cinterval>(sl2,sl1); } 02026 02027 INLINE civector operator +(const ivector &rv1, const civector &rv2) 02028 #if(CXSC_INDEX_CHECK) 02029 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02030 #else 02031 throw() 02032 #endif 02033 { return _vvplus<ivector,civector,civector>(rv1,rv2); } 02034 INLINE civector operator +(const ivector &rv, const civector_slice &sl) 02035 #if(CXSC_INDEX_CHECK) 02036 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02037 #else 02038 throw() 02039 #endif 02040 { return _vvsplus<ivector,civector_slice,civector>(rv,sl); } 02041 INLINE civector operator +(const ivector_slice &sl, const civector &rv) 02042 #if(CXSC_INDEX_CHECK) 02043 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02044 #else 02045 throw() 02046 #endif 02047 { return _vvsplus<civector,ivector_slice,civector>(rv,sl); } 02048 INLINE civector operator +(const ivector_slice &sl1, const civector_slice &sl2) 02049 #if(CXSC_INDEX_CHECK) 02050 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02051 #else 02052 throw() 02053 #endif 02054 { return _vsvsplus<ivector_slice,civector_slice,civector>(sl1,sl2); } 02055 02056 INLINE civector operator +(const civector &rv1, const ivector &rv2) 02057 #if(CXSC_INDEX_CHECK) 02058 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02059 #else 02060 throw() 02061 #endif 02062 { return _vvplus<ivector,civector,civector>(rv2,rv1); } 02063 INLINE civector operator +(const civector &rv, const ivector_slice &sl) 02064 #if(CXSC_INDEX_CHECK) 02065 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02066 #else 02067 throw() 02068 #endif 02069 { return _vvsplus<civector,ivector_slice,civector>(rv,sl); } 02070 INLINE civector operator +(const civector_slice &sl, const ivector &rv) 02071 #if(CXSC_INDEX_CHECK) 02072 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02073 #else 02074 throw() 02075 #endif 02076 { return _vvsplus<ivector,civector_slice,civector>(rv,sl); } 02077 INLINE civector operator +(const civector_slice &sl1, const ivector_slice &sl2) 02078 #if(CXSC_INDEX_CHECK) 02079 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02080 #else 02081 throw() 02082 #endif 02083 { return _vsvsplus<ivector_slice,civector_slice,civector>(sl2,sl1); } 02084 02085 INLINE civector & operator +=(civector &rv1, const ivector &rv2) 02086 #if(CXSC_INDEX_CHECK) 02087 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02088 #else 02089 throw() 02090 #endif 02091 { return _vvplusassign(rv1,rv2); } 02092 INLINE civector &operator +=(civector &rv, const ivector_slice &sl) 02093 #if(CXSC_INDEX_CHECK) 02094 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02095 #else 02096 throw() 02097 #endif 02098 { return _vvsplusassign(rv,sl); } 02099 INLINE civector_slice &civector_slice::operator +=(const ivector &rv) 02100 #if(CXSC_INDEX_CHECK) 02101 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02102 #else 02103 throw() 02104 #endif 02105 { return _vsvplusassign(*this,rv); } 02106 INLINE civector_slice &civector_slice::operator +=(const ivector_slice &sl2) 02107 #if(CXSC_INDEX_CHECK) 02108 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02109 #else 02110 throw() 02111 #endif 02112 { return _vsvsplusassign(*this,sl2); } 02113 02114 INLINE civector operator -(const ivector &rv1, const civector &rv2) 02115 #if(CXSC_INDEX_CHECK) 02116 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02117 #else 02118 throw() 02119 #endif 02120 { return _vvminus<ivector,civector,civector>(rv1,rv2); } 02121 INLINE civector operator -(const ivector &rv, const civector_slice &sl) 02122 #if(CXSC_INDEX_CHECK) 02123 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02124 #else 02125 throw() 02126 #endif 02127 { return _vvsminus<ivector,civector_slice,civector>(rv,sl); } 02128 INLINE civector operator -(const ivector_slice &sl, const civector &rv) 02129 #if(CXSC_INDEX_CHECK) 02130 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02131 #else 02132 throw() 02133 #endif 02134 { return _vsvminus<ivector_slice,civector,civector>(sl,rv); } 02135 INLINE civector operator -(const ivector_slice &sl1, const civector_slice &sl2) 02136 #if(CXSC_INDEX_CHECK) 02137 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02138 #else 02139 throw() 02140 #endif 02141 { return _vsvsminus<ivector_slice,civector_slice,civector>(sl1,sl2); } 02142 02143 INLINE civector operator -(const civector &rv1, const ivector &rv2) 02144 #if(CXSC_INDEX_CHECK) 02145 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02146 #else 02147 throw() 02148 #endif 02149 { return _vvminus<civector,ivector,civector>(rv1,rv2); } 02150 INLINE civector operator -(const civector &rv, const ivector_slice &sl) 02151 #if(CXSC_INDEX_CHECK) 02152 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02153 #else 02154 throw() 02155 #endif 02156 { return _vvsminus<civector,ivector_slice,civector>(rv,sl); } 02157 INLINE civector operator -(const civector_slice &sl, const ivector &rv) 02158 #if(CXSC_INDEX_CHECK) 02159 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02160 #else 02161 throw() 02162 #endif 02163 { return _vsvminus<civector_slice,ivector,civector>(sl,rv); } 02164 INLINE civector operator -(const civector_slice &sl1, const ivector_slice &sl2) 02165 #if(CXSC_INDEX_CHECK) 02166 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02167 #else 02168 throw() 02169 #endif 02170 { return _vsvsminus<civector_slice,ivector_slice,civector>(sl1,sl2); } 02171 02172 INLINE civector & operator -=(civector &rv1, const ivector &rv2) 02173 #if(CXSC_INDEX_CHECK) 02174 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02175 #else 02176 throw() 02177 #endif 02178 { return _vvminusassign(rv1,rv2); } 02179 INLINE civector &operator -=(civector &rv, const ivector_slice &sl) 02180 #if(CXSC_INDEX_CHECK) 02181 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02182 #else 02183 throw() 02184 #endif 02185 { return _vvsminusassign(rv,sl); } 02186 INLINE civector_slice &civector_slice::operator -=(const ivector &rv) 02187 #if(CXSC_INDEX_CHECK) 02188 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02189 #else 02190 throw() 02191 #endif 02192 { return _vsvminusassign(*this,rv); } 02193 INLINE civector_slice &civector_slice::operator -=(const ivector_slice &sl2) 02194 #if(CXSC_INDEX_CHECK) 02195 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02196 #else 02197 throw() 02198 #endif 02199 { return _vsvsminusassign(*this,sl2); } 02200 02201 INLINE civector operator |(const ivector &rv1, const civector &rv2) 02202 #if(CXSC_INDEX_CHECK) 02203 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02204 #else 02205 throw() 02206 #endif 02207 { return _vvconv<ivector,civector,civector>(rv1,rv2); } 02208 INLINE civector operator |(const ivector &rv, const civector_slice &sl) 02209 #if(CXSC_INDEX_CHECK) 02210 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02211 #else 02212 throw() 02213 #endif 02214 { return _vvsconv<ivector,civector_slice,civector>(rv,sl); } 02215 INLINE civector operator |(const ivector_slice &sl, const civector &rv) 02216 #if(CXSC_INDEX_CHECK) 02217 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02218 #else 02219 throw() 02220 #endif 02221 { return _vvsconv<civector,ivector_slice,civector>(rv,sl); } 02222 INLINE civector operator |(const ivector_slice &sl1, const civector_slice &sl2) 02223 #if(CXSC_INDEX_CHECK) 02224 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02225 #else 02226 throw() 02227 #endif 02228 { return _vsvsconv<ivector_slice,civector_slice,civector>(sl1,sl2); } 02229 02230 INLINE civector operator |(const civector &rv1, const ivector &rv2) 02231 #if(CXSC_INDEX_CHECK) 02232 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02233 #else 02234 throw() 02235 #endif 02236 { return _vvconv<ivector,civector,civector>(rv2,rv1); } 02237 INLINE civector operator |(const civector &rv, const ivector_slice &sl) 02238 #if(CXSC_INDEX_CHECK) 02239 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02240 #else 02241 throw() 02242 #endif 02243 { return _vvsconv<civector,ivector_slice,civector>(rv,sl); } 02244 INLINE civector operator |(const civector_slice &sl, const ivector &rv) 02245 #if(CXSC_INDEX_CHECK) 02246 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02247 #else 02248 throw() 02249 #endif 02250 { return _vvsconv<ivector,civector_slice,civector>(rv,sl); } 02251 INLINE civector operator |(const civector_slice &sl1, const ivector_slice &sl2) 02252 #if(CXSC_INDEX_CHECK) 02253 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02254 #else 02255 throw() 02256 #endif 02257 { return _vsvsconv<ivector_slice,civector_slice,civector>(sl2,sl1); } 02258 02259 INLINE civector & operator |=(civector &rv1, const ivector &rv2) 02260 #if(CXSC_INDEX_CHECK) 02261 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02262 #else 02263 throw() 02264 #endif 02265 { return _vvconvassign(rv1,rv2); } 02266 INLINE civector &operator |=(civector &rv, const ivector_slice &sl) 02267 #if(CXSC_INDEX_CHECK) 02268 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02269 #else 02270 throw() 02271 #endif 02272 { return _vvsconvassign(rv,sl); } 02273 INLINE civector_slice &civector_slice::operator |=(const ivector &rv) 02274 #if(CXSC_INDEX_CHECK) 02275 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02276 #else 02277 throw() 02278 #endif 02279 { return _vsvconvassign(*this,rv); } 02280 INLINE civector_slice &civector_slice::operator |=(const ivector_slice &sl2) 02281 #if(CXSC_INDEX_CHECK) 02282 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02283 #else 02284 throw() 02285 #endif 02286 { return _vsvsconvassign(*this,sl2); } 02287 02288 INLINE civector operator &(const ivector &rv1, const civector &rv2) 02289 #if(CXSC_INDEX_CHECK) 02290 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02291 #else 02292 throw() 02293 #endif 02294 { return _vvsect<ivector,civector,civector>(rv1,rv2); } 02295 INLINE civector operator &(const ivector &rv, const civector_slice &sl) 02296 #if(CXSC_INDEX_CHECK) 02297 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02298 #else 02299 throw() 02300 #endif 02301 { return _vvssect<ivector,civector_slice,civector>(rv,sl); } 02302 INLINE civector operator &(const ivector_slice &sl, const civector &rv) 02303 #if(CXSC_INDEX_CHECK) 02304 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02305 #else 02306 throw() 02307 #endif 02308 { return _vvssect<civector,ivector_slice,civector>(rv,sl); } 02309 INLINE civector operator &(const ivector_slice &sl1, const civector_slice &sl2) 02310 #if(CXSC_INDEX_CHECK) 02311 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02312 #else 02313 throw() 02314 #endif 02315 { return _vsvssect<ivector_slice,civector_slice,civector>(sl1,sl2); } 02316 02317 INLINE civector operator &(const civector &rv1, const ivector &rv2) 02318 #if(CXSC_INDEX_CHECK) 02319 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02320 #else 02321 throw() 02322 #endif 02323 { return _vvsect<ivector,civector,civector>(rv2,rv1); } 02324 INLINE civector operator &(const civector &rv, const ivector_slice &sl) 02325 #if(CXSC_INDEX_CHECK) 02326 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02327 #else 02328 throw() 02329 #endif 02330 { return _vvssect<civector,ivector_slice,civector>(rv,sl); } 02331 INLINE civector operator &(const civector_slice &sl, const ivector &rv) 02332 #if(CXSC_INDEX_CHECK) 02333 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02334 #else 02335 throw() 02336 #endif 02337 { return _vvssect<ivector,civector_slice,civector>(rv,sl); } 02338 INLINE civector operator &(const civector_slice &sl1, const ivector_slice &sl2) 02339 #if(CXSC_INDEX_CHECK) 02340 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02341 #else 02342 throw() 02343 #endif 02344 { return _vsvssect<ivector_slice,civector_slice,civector>(sl2,sl1); } 02345 02346 INLINE civector & operator &=(civector &rv1, const ivector &rv2) 02347 #if(CXSC_INDEX_CHECK) 02348 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02349 #else 02350 throw() 02351 #endif 02352 { return _vvsectassign(rv1,rv2); } 02353 INLINE civector &operator &=(civector &rv, const ivector_slice &sl) 02354 #if(CXSC_INDEX_CHECK) 02355 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02356 #else 02357 throw() 02358 #endif 02359 { return _vvssectassign(rv,sl); } 02360 INLINE civector_slice &civector_slice::operator &=(const ivector &rv) 02361 #if(CXSC_INDEX_CHECK) 02362 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02363 #else 02364 throw() 02365 #endif 02366 { return _vsvsectassign(*this,rv); } 02367 INLINE civector_slice &civector_slice::operator &=(const ivector_slice &sl2) 02368 #if(CXSC_INDEX_CHECK) 02369 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02370 #else 02371 throw() 02372 #endif 02373 { return _vsvssectassign(*this,sl2); } 02374 02375 //------------- real x complex ------------------------ 02376 INLINE civector operator |(const rvector &rv1, const cvector &rv2) 02377 #if(CXSC_INDEX_CHECK) 02378 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02379 #else 02380 throw() 02381 #endif 02382 { return _vvconv<rvector,cvector,civector>(rv1,rv2); } 02383 INLINE civector operator |(const cvector &rv1, const rvector &rv2) 02384 #if(CXSC_INDEX_CHECK) 02385 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02386 #else 02387 throw() 02388 #endif 02389 { return _vvconv<rvector,cvector,civector>(rv2,rv1); } 02390 INLINE civector operator |(const cvector &rv, const rvector_slice &sl) 02391 #if(CXSC_INDEX_CHECK) 02392 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02393 #else 02394 throw() 02395 #endif 02396 { return _vvsconv<cvector,rvector_slice,civector>(rv,sl); } 02397 INLINE civector operator |(const rvector_slice &sl,const cvector &rv) 02398 #if(CXSC_INDEX_CHECK) 02399 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02400 #else 02401 throw() 02402 #endif 02403 { return _vvsconv<cvector,rvector_slice,civector>(rv,sl); } 02404 INLINE civector operator |(const cvector_slice &sl, const rvector &rv) 02405 #if(CXSC_INDEX_CHECK) 02406 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02407 #else 02408 throw() 02409 #endif 02410 { return _vvsconv<rvector,cvector_slice,civector>(rv,sl); } 02411 INLINE civector operator |(const rvector &rv,const cvector_slice &sl) 02412 #if(CXSC_INDEX_CHECK) 02413 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02414 #else 02415 throw() 02416 #endif 02417 { return _vvsconv<rvector,cvector_slice,civector>(rv,sl); } 02418 INLINE civector operator |(const cvector_slice &sl1, const rvector_slice &sl2) 02419 #if(CXSC_INDEX_CHECK) 02420 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02421 #else 02422 throw() 02423 #endif 02424 { return _vsvsconv<rvector_slice,cvector_slice,civector>(sl2,sl1); } 02425 INLINE civector operator |(const rvector_slice &sl1, const cvector_slice &sl2) 02426 #if(CXSC_INDEX_CHECK) 02427 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02428 #else 02429 throw() 02430 #endif 02431 { return _vsvsconv<rvector_slice,cvector_slice,civector>(sl1,sl2); } 02432 02433 //------------- complex x complex ------------------------ 02434 INLINE civector operator |(const cvector &rv1, const cvector &rv2) 02435 #if(CXSC_INDEX_CHECK) 02436 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02437 #else 02438 throw() 02439 #endif 02440 { return _vvconv<cvector,cvector,civector>(rv2,rv1); } 02441 INLINE civector operator |(const cvector &rv, const cvector_slice &sl) 02442 #if(CXSC_INDEX_CHECK) 02443 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02444 #else 02445 throw() 02446 #endif 02447 { return _vvsconv<cvector,cvector_slice,civector>(rv,sl); } 02448 INLINE civector operator |(const cvector_slice &sl,const cvector &rv) 02449 #if(CXSC_INDEX_CHECK) 02450 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02451 #else 02452 throw() 02453 #endif 02454 { return _vvsconv<cvector,cvector_slice,civector>(rv,sl); } 02455 INLINE civector operator |(const cvector_slice &sl1, const cvector_slice &sl2) 02456 #if(CXSC_INDEX_CHECK) 02457 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02458 #else 02459 throw() 02460 #endif 02461 { return _vsvsconv<cvector_slice,cvector_slice,civector>(sl1,sl2); } 02462 02463 //-------------------------------- interval / complex -------------------------------- 02464 02465 INLINE civector operator +(const cvector &rv1, const ivector &rv2) 02466 #if(CXSC_INDEX_CHECK) 02467 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02468 #else 02469 throw() 02470 #endif 02471 { return _vvplus<cvector,ivector,civector>(rv1,rv2); } 02472 INLINE civector operator +(const cvector &rv, const ivector_slice &sl) 02473 #if(CXSC_INDEX_CHECK) 02474 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02475 #else 02476 throw() 02477 #endif 02478 { return _vvsplus<cvector,ivector_slice,civector>(rv,sl); } 02479 INLINE civector operator +(const cvector_slice &sl, const ivector &rv) 02480 #if(CXSC_INDEX_CHECK) 02481 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02482 #else 02483 throw() 02484 #endif 02485 { return _vvsplus<ivector,cvector_slice,civector>(rv,sl); } 02486 INLINE civector operator +(const cvector_slice &sl1, const ivector_slice &sl2) 02487 #if(CXSC_INDEX_CHECK) 02488 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02489 #else 02490 throw() 02491 #endif 02492 { return _vsvsplus<cvector_slice,ivector_slice,civector>(sl1,sl2); } 02493 02494 INLINE civector operator +(const ivector &rv1, const cvector &rv2) 02495 #if(CXSC_INDEX_CHECK) 02496 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02497 #else 02498 throw() 02499 #endif 02500 { return _vvplus<cvector,ivector,civector>(rv2,rv1); } 02501 INLINE civector operator +(const ivector &rv, const cvector_slice &sl) 02502 #if(CXSC_INDEX_CHECK) 02503 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02504 #else 02505 throw() 02506 #endif 02507 { return _vvsplus<ivector,cvector_slice,civector>(rv,sl); } 02508 INLINE civector operator +(const ivector_slice &sl, const cvector &rv) 02509 #if(CXSC_INDEX_CHECK) 02510 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02511 #else 02512 throw() 02513 #endif 02514 { return _vvsplus<cvector,ivector_slice,civector>(rv,sl); } 02515 INLINE civector operator +(const ivector_slice &sl1, const cvector_slice &sl2) 02516 #if(CXSC_INDEX_CHECK) 02517 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02518 #else 02519 throw() 02520 #endif 02521 { return _vsvsplus<cvector_slice,ivector_slice,civector>(sl2,sl1); } 02522 02523 INLINE civector operator -(const cvector &rv1, const ivector &rv2) 02524 #if(CXSC_INDEX_CHECK) 02525 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02526 #else 02527 throw() 02528 #endif 02529 { return _vvminus<cvector,ivector,civector>(rv1,rv2); } 02530 INLINE civector operator -(const cvector &rv, const ivector_slice &sl) 02531 #if(CXSC_INDEX_CHECK) 02532 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02533 #else 02534 throw() 02535 #endif 02536 { return _vvsminus<cvector,ivector_slice,civector>(rv,sl); } 02537 INLINE civector operator -(const cvector_slice &sl, const ivector &rv) 02538 #if(CXSC_INDEX_CHECK) 02539 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02540 #else 02541 throw() 02542 #endif 02543 { return _vsvminus<cvector_slice,ivector,civector>(sl,rv); } 02544 INLINE civector operator -(const cvector_slice &sl1, const ivector_slice &sl2) 02545 #if(CXSC_INDEX_CHECK) 02546 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02547 #else 02548 throw() 02549 #endif 02550 { return _vsvsminus<cvector_slice,ivector_slice,civector>(sl1,sl2); } 02551 02552 INLINE civector operator -(const ivector &rv1, const cvector &rv2) 02553 #if(CXSC_INDEX_CHECK) 02554 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02555 #else 02556 throw() 02557 #endif 02558 { return _vvminus<ivector,cvector,civector>(rv1,rv2); } 02559 INLINE civector operator -(const ivector &rv, const cvector_slice &sl) 02560 #if(CXSC_INDEX_CHECK) 02561 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02562 #else 02563 throw() 02564 #endif 02565 { return _vvsminus<ivector,cvector_slice,civector>(rv,sl); } 02566 INLINE civector operator -(const ivector_slice &sl, const cvector &rv) 02567 #if(CXSC_INDEX_CHECK) 02568 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02569 #else 02570 throw() 02571 #endif 02572 { return _vsvminus<ivector_slice,cvector,civector>(sl,rv); } 02573 INLINE civector operator -(const ivector_slice &sl1, const cvector_slice &sl2) 02574 #if(CXSC_INDEX_CHECK) 02575 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02576 #else 02577 throw() 02578 #endif 02579 { return _vsvsminus<ivector_slice,cvector_slice,civector>(sl1,sl2); } 02580 02581 INLINE civector operator |(const cvector &rv1, const ivector &rv2) 02582 #if(CXSC_INDEX_CHECK) 02583 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02584 #else 02585 throw() 02586 #endif 02587 { return _vvconv<cvector,ivector,civector>(rv1,rv2); } 02588 INLINE civector operator |(const cvector &rv, const ivector_slice &sl) 02589 #if(CXSC_INDEX_CHECK) 02590 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02591 #else 02592 throw() 02593 #endif 02594 { return _vvsconv<cvector,ivector_slice,civector>(rv,sl); } 02595 INLINE civector operator |(const cvector_slice &sl, const ivector &rv) 02596 #if(CXSC_INDEX_CHECK) 02597 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02598 #else 02599 throw() 02600 #endif 02601 { return _vvsconv<ivector,cvector_slice,civector>(rv,sl); } 02602 INLINE civector operator |(const cvector_slice &sl1, const ivector_slice &sl2) 02603 #if(CXSC_INDEX_CHECK) 02604 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02605 #else 02606 throw() 02607 #endif 02608 { return _vsvsconv<cvector_slice,ivector_slice,civector>(sl1,sl2); } 02609 02610 INLINE civector operator |(const ivector &rv1, const cvector &rv2) 02611 #if(CXSC_INDEX_CHECK) 02612 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02613 #else 02614 throw() 02615 #endif 02616 { return _vvconv<cvector,ivector,civector>(rv2,rv1); } 02617 INLINE civector operator |(const ivector &rv, const cvector_slice &sl) 02618 #if(CXSC_INDEX_CHECK) 02619 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02620 #else 02621 throw() 02622 #endif 02623 { return _vvsconv<ivector,cvector_slice,civector>(rv,sl); } 02624 INLINE civector operator |(const ivector_slice &sl, const cvector &rv) 02625 #if(CXSC_INDEX_CHECK) 02626 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02627 #else 02628 throw() 02629 #endif 02630 { return _vvsconv<cvector,ivector_slice,civector>(rv,sl); } 02631 INLINE civector operator |(const ivector_slice &sl1, const cvector_slice &sl2) 02632 #if(CXSC_INDEX_CHECK) 02633 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02634 #else 02635 throw() 02636 #endif 02637 { return _vsvsconv<cvector_slice,ivector_slice,civector>(sl2,sl1); } 02638 02639 INLINE civector operator &(const cvector &rv1, const ivector &rv2) 02640 #if(CXSC_INDEX_CHECK) 02641 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02642 #else 02643 throw() 02644 #endif 02645 { return _vvsect<cvector,ivector,civector>(rv1,rv2); } 02646 INLINE civector operator &(const cvector &rv, const ivector_slice &sl) 02647 #if(CXSC_INDEX_CHECK) 02648 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02649 #else 02650 throw() 02651 #endif 02652 { return _vvssect<cvector,ivector_slice,civector>(rv,sl); } 02653 INLINE civector operator &(const cvector_slice &sl, const ivector &rv) 02654 #if(CXSC_INDEX_CHECK) 02655 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02656 #else 02657 throw() 02658 #endif 02659 { return _vvssect<ivector,cvector_slice,civector>(rv,sl); } 02660 INLINE civector operator &(const cvector_slice &sl1, const ivector_slice &sl2) 02661 #if(CXSC_INDEX_CHECK) 02662 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02663 #else 02664 throw() 02665 #endif 02666 { return _vsvssect<cvector_slice,ivector_slice,civector>(sl1,sl2); } 02667 02668 INLINE civector operator &(const ivector &rv1, const cvector &rv2) 02669 #if(CXSC_INDEX_CHECK) 02670 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02671 #else 02672 throw() 02673 #endif 02674 { return _vvsect<cvector,ivector,civector>(rv2,rv1); } 02675 INLINE civector operator &(const ivector &rv, const cvector_slice &sl) 02676 #if(CXSC_INDEX_CHECK) 02677 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02678 #else 02679 throw() 02680 #endif 02681 { return _vvssect<ivector,cvector_slice,civector>(rv,sl); } 02682 INLINE civector operator &(const ivector_slice &sl, const cvector &rv) 02683 #if(CXSC_INDEX_CHECK) 02684 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02685 #else 02686 throw() 02687 #endif 02688 { return _vvssect<cvector,ivector_slice,civector>(rv,sl); } 02689 INLINE civector operator &(const ivector_slice &sl1, const cvector_slice &sl2) 02690 #if(CXSC_INDEX_CHECK) 02691 throw(ERROR__OP_WITH_WRONG_DIM<civector>) 02692 #else 02693 throw() 02694 #endif 02695 { return _vsvssect<cvector_slice,ivector_slice,civector>(sl2,sl1); } 02696 02697 02699 INLINE civector civector::operator()(const intvector& p) { 02700 civector x(*this); 02701 for(int i=0 ; i<VecLen(x) ; i++) 02702 x[i+Lb(x)] = (*this)[p[i+Lb(p)]+Lb(*this)]; 02703 return x; 02704 02705 } 02706 02707 INLINE bool in(const civector& v1, const civector& v2) { 02708 int n = VecLen(v1); 02709 bool ret = true; 02710 for(int i=0 ; i<n && ret ; i++) { 02711 ret = in(v1[Lb(v1)+i], v2[Lb(v2)+i]); 02712 } 02713 return ret; 02714 } 02715 02716 02717 } // namespace cxsc 02718 02719 #endif 02720
1.7.5.1