- 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.hpp,v 1.39 2014/01/30 17:23:44 cxsc Exp $ */ 00025 00026 #ifndef _CXSC_CIVECTOR_HPP_INCLUDED 00027 #define _CXSC_CIVECTOR_HPP_INCLUDED 00028 00029 #include "xscclass.hpp" 00030 #include "except.hpp" 00031 #include "cidot.hpp" 00032 #include "cinterval.hpp" // used for declaration of Inf, Sup,... 00033 //#include "cxscmatr.hpp" 00034 #include "rvector.hpp" 00035 #include "ivector.hpp" 00036 #include "cvector.hpp" 00037 #include "vector.hpp" 00038 00039 00040 #include <iostream> 00041 00042 //#include "matrix.hpp" // hat hier eigentlich nichts zu suchen, sonst aber Internal Compiler Error #9 00043 00044 namespace cxsc { 00045 00046 class civector_slice; 00047 class scivector; 00048 class scivector_slice; 00049 00051 00056 class civector 00057 { 00058 friend class civector_slice; 00059 friend class cimatrix; 00060 friend class cimatrix_subv; 00061 private: 00062 cinterval *dat; 00063 int l,u,size; 00064 00065 public: 00066 //#if(CXSC_INDEX_CHECK) 00067 #ifdef _CXSC_FRIEND_TPL 00068 //------------ Templates -------------------------------------------------- 00069 // cinterval 00070 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m) 00071 #if(CXSC_INDEX_CHECK) 00072 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>); 00073 #else 00074 throw(); 00075 #endif 00076 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m) 00077 #if(CXSC_INDEX_CHECK) 00078 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>); 00079 #else 00080 throw(); 00081 #endif 00082 template <class V> friend void _vresize(V &rv) throw(); 00083 template <class V,class S> friend void _vresize(V &rv, const int &len) 00084 #if(CXSC_INDEX_CHECK) 00085 throw(ERROR__WRONG_BOUNDARIES<V>); 00086 #else 00087 throw(); 00088 #endif 00089 template <class V,class S> friend void _vresize(V &rv, const int &lb, const int &ub) 00090 #if(CXSC_INDEX_CHECK) 00091 throw(ERROR__WRONG_BOUNDARIES<V>); 00092 #else 00093 throw(); 00094 #endif 00095 template <class V1,class V2,class S> friend V1 &_vvassign(V1 &rv1,const V2 &rv2) throw(); 00096 template <class V,class S> friend V & _vsassign(V &rv,const S &r) throw(); 00097 template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) throw(); 00098 template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv) 00099 #if(CXSC_INDEX_CHECK) 00100 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00101 #else 00102 throw(); 00103 #endif 00104 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m) 00105 #if(CXSC_INDEX_CHECK) 00106 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>); 00107 #else 00108 throw(); 00109 #endif 00110 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) throw(); 00111 template <class V1,class V2> friend V1 &_vvsetinf(V1 &rv1, const V2 &rv2) 00112 #if(CXSC_INDEX_CHECK) 00113 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00114 #else 00115 throw(); 00116 #endif 00117 template <class V1,class V2> friend V1 &_vvsetsup(V1 &rv1, const V2 &rv2) 00118 #if(CXSC_INDEX_CHECK) 00119 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00120 #else 00121 throw(); 00122 #endif 00123 template <class V,class VS> friend V &_vvssetinf(V &rv, const VS &sl) 00124 #if(CXSC_INDEX_CHECK) 00125 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00126 #else 00127 throw(); 00128 #endif 00129 template <class V,class VS> friend V &_vvssetsup(V &rv, const VS &sl) 00130 #if(CXSC_INDEX_CHECK) 00131 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00132 #else 00133 throw(); 00134 #endif 00135 template <class V,class MV> friend V &_vmvsetinf(V &rv,const MV &v) 00136 #if(CXSC_INDEX_CHECK) 00137 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00138 #else 00139 throw(); 00140 #endif 00141 template <class V,class MV> friend V &_vmvsetsup(V &rv,const MV &v) 00142 #if(CXSC_INDEX_CHECK) 00143 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00144 #else 00145 throw(); 00146 #endif 00147 template <class V1,class V2> friend V1 &_vvusetinf(V1 &rv1, const V2 &rv2) 00148 #if(CXSC_INDEX_CHECK) 00149 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00150 #else 00151 throw(); 00152 #endif 00153 template <class V1,class V2> friend V1 &_vvusetsup(V1 &rv1, const V2 &rv2) 00154 #if(CXSC_INDEX_CHECK) 00155 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00156 #else 00157 throw(); 00158 #endif 00159 template <class V,class VS> friend V &_vvsusetinf(V &rv, const VS &sl) 00160 #if(CXSC_INDEX_CHECK) 00161 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00162 #else 00163 throw(); 00164 #endif 00165 template <class V,class VS> friend V &_vvsusetsup(V &rv, const VS &sl) 00166 #if(CXSC_INDEX_CHECK) 00167 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00168 #else 00169 throw(); 00170 #endif 00171 template <class V,class MV> friend V &_vmvusetinf(V &rv,const MV &v) 00172 #if(CXSC_INDEX_CHECK) 00173 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00174 #else 00175 throw(); 00176 #endif 00177 template <class V,class MV> friend V &_vmvusetsup(V &rv,const MV &v) 00178 #if(CXSC_INDEX_CHECK) 00179 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00180 #else 00181 throw(); 00182 #endif 00183 template <class V,class S> friend V &_vssetinf(V &v, const S &s) throw(); 00184 template <class V,class S> friend V &_vssetsup(V &v, const S &s) throw(); 00185 template <class V,class S> friend V &_vsusetinf(V &v, const S &s) throw(); 00186 template <class V,class S> friend V &_vsusetsup(V &v, const S &s) throw(); 00187 template <class V,class S> friend V &_vssetim(V &v, const S &s) throw(); 00188 template <class V,class S> friend V &_vssetre(V &v, const S &s) throw(); 00189 template <class V> friend V _vconj(const V &rv) throw(); 00190 template <class VS,class E> friend E _vsconj(const VS &sl) throw(); 00191 template <class V,class E> friend E _vabs(const V &rv) throw(); 00192 template <class VS,class E> friend E _vsabs(const VS &sl) throw(); 00193 template <class MV,class V> friend V _mvabs(const MV &mv) throw(); 00194 template <class V,class E> friend E _vdiam(const V &rv) throw(); 00195 template <class V,class E> friend E _vmid(const V &rv) throw(); 00196 template <class V,class E> friend E _vinf(const V &rv) throw(); 00197 template <class V,class E> friend E _vsup(const V &rv) throw(); 00198 template <class V,class E> friend E _vim(const V &rv) throw(); 00199 template <class V,class E> friend E _vre(const V &rv) throw(); 00200 friend INLINE ivector Re(const civector &v) throw(); 00201 friend INLINE ivector Im(const civector &v) throw(); 00202 friend INLINE cvector Inf(const civector &v) throw(); 00203 friend INLINE cvector Sup(const civector &v) throw(); 00204 friend INLINE rvector SupRe(const civector &v) throw(); 00205 friend INLINE rvector SupIm(const civector &v) throw(); 00206 friend INLINE rvector InfRe(const civector &v) throw(); 00207 friend INLINE rvector InfIm(const civector &v) throw(); 00208 template <class V1,class V2> friend V1 &_vvsetim(V1 &rv1, const V2 &rv2) 00209 #if(CXSC_INDEX_CHECK) 00210 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00211 #else 00212 throw(); 00213 #endif 00214 template <class V1,class V2> friend V1 &_vvsetre(V1 &rv1, const V2 &rv2) 00215 #if(CXSC_INDEX_CHECK) 00216 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00217 #else 00218 throw(); 00219 #endif 00220 template <class V,class VS> friend V &_vvssetim(V &rv, const VS &sl) 00221 #if(CXSC_INDEX_CHECK) 00222 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00223 #else 00224 throw(); 00225 #endif 00226 template <class V,class VS> friend V &_vvssetre(V &rv, const VS &sl) 00227 #if(CXSC_INDEX_CHECK) 00228 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00229 #else 00230 throw(); 00231 #endif 00232 template <class V,class MV> friend V &_vmvsetim(V &rv,const MV &v) 00233 #if(CXSC_INDEX_CHECK) 00234 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00235 #else 00236 throw(); 00237 #endif 00238 template <class V,class MV> friend V &_vmvsetre(V &rv,const MV &v) 00239 #if(CXSC_INDEX_CHECK) 00240 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00241 #else 00242 throw(); 00243 #endif 00244 00245 //-------- vector-vector ----------------------- 00246 template <class DP,class V1,class V2> friend void _vvaccu(DP &dp, const V1 & rv1, const V2 &rv2) 00247 #if(CXSC_INDEX_CHECK) 00248 throw(OP_WITH_WRONG_DIM); 00249 #else 00250 throw(); 00251 #endif 00252 template <class DP,class VS,class V> friend void _vsvaccu(DP &dp, const VS & sl, const V &rv) 00253 #if(CXSC_INDEX_CHECK) 00254 throw(OP_WITH_WRONG_DIM); 00255 #else 00256 throw(); 00257 #endif 00258 00259 template <class V1,class V2,class E> friend E _vvcimult(const V1 & rv1, const V2 &rv2) 00260 #if(CXSC_INDEX_CHECK) 00261 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00262 #else 00263 throw(); 00264 #endif 00265 template <class VS,class V,class E> friend E _vsvcimult(const VS & sl, const V &rv) 00266 #if(CXSC_INDEX_CHECK) 00267 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00268 #else 00269 throw(); 00270 #endif 00271 00272 template <class V,class S> friend V &_vsmultassign(V &rv,const S &r) throw(); 00273 template <class V1,class V2,class E> friend E _vvplus(const V1 &rv1, const V2 &rv2) 00274 #if(CXSC_INDEX_CHECK) 00275 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00276 #else 00277 throw(); 00278 #endif 00279 template <class V,class VS,class E> friend E _vvsplus(const V &rv,const VS &sl) 00280 #if(CXSC_INDEX_CHECK) 00281 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00282 #else 00283 throw(); 00284 #endif 00285 template <class VS1,class VS2,class E> friend E _vsvsplus(const VS1 &s1,const VS2 &s2) 00286 #if(CXSC_INDEX_CHECK) 00287 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00288 #else 00289 throw(); 00290 #endif 00291 template <class VS1,class VS2,class E> friend E _vsvsminus(const VS1 &s1,const VS2 &s2) 00292 #if(CXSC_INDEX_CHECK) 00293 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00294 #else 00295 throw(); 00296 #endif 00297 template <class V1,class V2> friend V1 &_vvplusassign(V1 &rv1, const V2 &rv2) 00298 #if(CXSC_INDEX_CHECK) 00299 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00300 #else 00301 throw(); 00302 #endif 00303 template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl) 00304 #if(CXSC_INDEX_CHECK) 00305 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00306 #else 00307 throw(); 00308 #endif 00309 template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv) 00310 #if(CXSC_INDEX_CHECK) 00311 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00312 #else 00313 throw(); 00314 #endif 00315 template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2) 00316 #if(CXSC_INDEX_CHECK) 00317 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00318 #else 00319 throw(); 00320 #endif 00321 template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2) 00322 #if(CXSC_INDEX_CHECK) 00323 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00324 #else 00325 throw(); 00326 #endif 00327 template <class V1,class V2> friend V1 &_vvminusassign(V1 &rv1, const V2 &rv2) 00328 #if(CXSC_INDEX_CHECK) 00329 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00330 #else 00331 throw(); 00332 #endif 00333 template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl) 00334 #if(CXSC_INDEX_CHECK) 00335 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00336 #else 00337 throw(); 00338 #endif 00339 template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv) 00340 #if(CXSC_INDEX_CHECK) 00341 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00342 #else 00343 throw(); 00344 #endif 00345 template <class V> friend V _vminus(const V &rv) throw(); 00346 template <class VS,class V> friend V _vsminus(const VS &sl) throw(); 00347 template <class V1,class V2,class E> friend E _vvminus(const V1 &rv1, const V2 &rv2) 00348 #if(CXSC_INDEX_CHECK) 00349 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00350 #else 00351 throw(); 00352 #endif 00353 template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl) 00354 #if(CXSC_INDEX_CHECK) 00355 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00356 #else 00357 throw(); 00358 #endif 00359 template <class VS,class V,class E> friend E _vsvminus(const VS &sl,const V &rv) 00360 #if(CXSC_INDEX_CHECK) 00361 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00362 #else 00363 throw(); 00364 #endif 00365 template <class V1,class V2,class E> friend E _vvconv(const V1 &rv1, const V2 &rv2) 00366 #if(CXSC_INDEX_CHECK) 00367 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00368 #else 00369 throw(); 00370 #endif 00371 template <class V,class VS,class E> friend E _vvsconv(const V &rv,const VS &sl) 00372 #if(CXSC_INDEX_CHECK) 00373 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00374 #else 00375 throw(); 00376 #endif 00377 template <class VS1,class VS2,class E> friend E _vsvsconv(const VS1 &s1,const VS2 &s2) 00378 #if(CXSC_INDEX_CHECK) 00379 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00380 #else 00381 throw(); 00382 #endif 00383 template <class V1,class V2> friend V1 &_vvconvassign(V1 &rv1, const V2 &rv2) 00384 #if(CXSC_INDEX_CHECK) 00385 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00386 #else 00387 throw(); 00388 #endif 00389 template <class V,class VS> friend V &_vvsconvassign(V &rv, const VS &sl) 00390 #if(CXSC_INDEX_CHECK) 00391 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00392 #else 00393 throw(); 00394 #endif 00395 template <class VS,class V> friend VS &_vsvconvassign(VS &sl, const V &rv) 00396 #if(CXSC_INDEX_CHECK) 00397 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00398 #else 00399 throw(); 00400 #endif 00401 template <class VS1,class VS2> friend VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2) 00402 #if(CXSC_INDEX_CHECK) 00403 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00404 #else 00405 throw(); 00406 #endif 00407 template <class V1,class V2,class E> friend E _vvsect(const V1 &rv1, const V2 &rv2) 00408 #if(CXSC_INDEX_CHECK) 00409 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00410 #else 00411 throw(); 00412 #endif 00413 template <class V,class VS,class E> friend E _vvssect(const V &rv,const VS &sl) 00414 #if(CXSC_INDEX_CHECK) 00415 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00416 #else 00417 throw(); 00418 #endif 00419 template <class VS1,class VS2,class E> friend E _vsvssect(const VS1 &s1,const VS2 &s2) 00420 #if(CXSC_INDEX_CHECK) 00421 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00422 #else 00423 throw(); 00424 #endif 00425 template <class V1,class V2> friend V1 &_vvsectassign(V1 &rv1, const V2 &rv2) 00426 #if(CXSC_INDEX_CHECK) 00427 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 00428 #else 00429 throw(); 00430 #endif 00431 template <class V,class VS> friend V &_vvssectassign(V &rv, const VS &sl) 00432 #if(CXSC_INDEX_CHECK) 00433 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00434 #else 00435 throw(); 00436 #endif 00437 template <class VS,class V> friend VS &_vsvsectassign(VS &sl, const V &rv) 00438 #if(CXSC_INDEX_CHECK) 00439 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 00440 #else 00441 throw(); 00442 #endif 00443 template <class VS1,class VS2> friend VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2) 00444 #if(CXSC_INDEX_CHECK) 00445 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 00446 #else 00447 throw(); 00448 #endif 00449 template <class MV1,class MV2,class E> friend E _mvmvsect(const MV1 &rv1, const MV2 &rv2) 00450 #if(CXSC_INDEX_CHECK) 00451 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00452 #else 00453 throw(); 00454 #endif 00455 template <class MV,class V,class E> friend E _mvvsect(const MV &rv1, const V &rv2) 00456 #if(CXSC_INDEX_CHECK) 00457 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00458 #else 00459 throw(); 00460 #endif 00461 template <class MV,class V> friend MV &_mvvsectassign(MV &v,const V &rv) 00462 #if(CXSC_INDEX_CHECK) 00463 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00464 #else 00465 throw(); 00466 #endif 00467 template <class V,class MV> friend V &_vmvsectassign(V &rv,const MV &v) 00468 #if(CXSC_INDEX_CHECK) 00469 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00470 #else 00471 throw(); 00472 #endif 00473 template <class MV1,class MV2,class E> friend E _mvmvconv(const MV1 &rv1, const MV2 &rv2) 00474 #if(CXSC_INDEX_CHECK) 00475 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00476 #else 00477 throw(); 00478 #endif 00479 template <class MV,class V,class E> friend E _mvvconv(const MV &rv1, const V &rv2) 00480 #if(CXSC_INDEX_CHECK) 00481 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00482 #else 00483 throw(); 00484 #endif 00485 template <class MV,class V> friend MV &_mvvconvassign(MV &v,const V &rv) 00486 #if(CXSC_INDEX_CHECK) 00487 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00488 #else 00489 throw(); 00490 #endif 00491 template <class V,class MV> friend V &_vmvconvassign(V &rv,const MV &v) 00492 #if(CXSC_INDEX_CHECK) 00493 throw(ERROR__OP_WITH_WRONG_DIM<V>); 00494 #else 00495 throw(); 00496 #endif 00497 template <class V,class MV,class S> friend S _vmvcimult(const V &rv1, const MV &rv2) 00498 #if(CXSC_INDEX_CHECK) 00499 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00500 #else 00501 throw(); 00502 #endif 00503 //--------- vector-scalar ----------------- 00504 template <class V,class S,class E> friend E _vsdiv(const V &rv, const S &s) throw(); 00505 template <class V,class S> friend V &_vsdivassign(V &rv,const S &r) throw(); 00506 template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) throw(); 00507 template <class V,class S,class E> friend E _vsmult(const V &rv, const S &s) throw(); 00508 template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) throw(); 00509 template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) throw(); 00510 template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2) 00511 #if(CXSC_INDEX_CHECK) 00512 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00513 #else 00514 throw(); 00515 #endif 00516 template <class MV,class V,class E> friend E _mvvplus(const MV &rv1, const V &rv2) 00517 #if(CXSC_INDEX_CHECK) 00518 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00519 #else 00520 throw(); 00521 #endif 00522 template <class MV,class V,class E> friend E _mvvminus(const MV &rv1, const V &rv2) 00523 #if(CXSC_INDEX_CHECK) 00524 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00525 #else 00526 throw(); 00527 #endif 00528 template <class V,class MV,class E> friend E _vmvminus(const V &rv1, const MV &rv2) 00529 #if(CXSC_INDEX_CHECK) 00530 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00531 #else 00532 throw(); 00533 #endif 00534 template <class MV1,class MV2,class E> friend E _mvmvminus(const MV1 &rv1, const MV2 &rv2) 00535 #if(CXSC_INDEX_CHECK) 00536 throw(ERROR__OP_WITH_WRONG_DIM<E>); 00537 #else 00538 throw(); 00539 #endif 00540 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv) 00541 #if(CXSC_INDEX_CHECK) 00542 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00543 #else 00544 throw(); 00545 #endif 00546 template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv) 00547 #if(CXSC_INDEX_CHECK) 00548 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00549 #else 00550 throw(); 00551 #endif 00552 template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) throw(); 00553 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv) 00554 #if(CXSC_INDEX_CHECK) 00555 throw(ERROR__OP_WITH_WRONG_DIM<MV>); 00556 #else 00557 throw(); 00558 #endif 00559 00560 template <class V1,class V2> friend bool _vveq(const V1 &rv1, const V2 &rv2) throw(); 00561 template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) throw(); 00562 template <class V1,class V2> friend bool _vvneq(const V1 &rv1, const V2 &rv2) throw(); 00563 template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) throw(); 00564 template <class V1,class V2> friend bool _vvless(const V1 &rv1, const V2 &rv2) throw(); 00565 template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) throw(); 00566 template <class V1,class V2> friend bool _vvleq(const V1 &rv1, const V2 &rv2) throw(); 00567 template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) throw(); 00568 template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) throw(); 00569 template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) throw(); 00570 template <class V> friend bool _vnot(const V &rv) throw(); 00571 template <class V> friend void *_vvoid(const V &rv) throw(); 00572 template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw(); 00573 template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw(); 00574 template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw(); 00575 template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw(); 00576 template <class VS> friend bool _vsnot(const VS &sl) throw(); 00577 template <class VS> friend void *_vsvoid(const VS &sl) throw(); 00578 template <class V> friend std::ostream &_vout(std::ostream &s, const V &rv) throw(); 00579 template <class V> friend std::istream &_vin(std::istream &s, V &rv) throw(); 00580 00581 //------------- vector-matrix --------------- 00582 template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2) 00583 #if(CXSC_INDEX_CHECK) 00584 throw(OP_WITH_WRONG_DIM); 00585 #else 00586 throw(); 00587 #endif 00588 00589 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) throw(); 00590 template <class M,class V,class E> friend E _mvcimult(const M &m,const V &v) 00591 #if(CXSC_INDEX_CHECK) 00592 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00593 #else 00594 throw(); 00595 #endif 00596 template <class V,class M,class E> friend E _vmcimult(const V &v,const M &m) 00597 #if(CXSC_INDEX_CHECK) 00598 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00599 #else 00600 throw(); 00601 #endif 00602 template <class V,class M,class S> friend V &_vmimultassign(V &v,const M &m) 00603 #if(CXSC_INDEX_CHECK) 00604 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00605 #else 00606 throw(); 00607 #endif 00608 template <class V,class M,class S> friend V &_vmcimultassign(V &v,const M &m) 00609 #if(CXSC_INDEX_CHECK) 00610 throw(ERROR__OP_WITH_WRONG_DIM<M>); 00611 #else 00612 throw(); 00613 #endif 00614 template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v) 00615 #if(CXSC_INDEX_CHECK) 00616 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00617 #else 00618 throw(); 00619 #endif 00620 template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms) 00621 #if(CXSC_INDEX_CHECK) 00622 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00623 #else 00624 throw(); 00625 #endif 00626 template <class V,class MS,class S> friend V &_vmscimultassign(V &v,const MS &ms) 00627 #if(CXSC_INDEX_CHECK) 00628 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 00629 #else 00630 throw(); 00631 #endif 00632 00633 // Real 00634 template <class DP,class VS1,class VS2> friend void _vsvsaccu(DP &dp, const VS1 & sl1, const VS2 &sl2) 00635 #if(CXSC_INDEX_CHECK) 00636 throw(OP_WITH_WRONG_DIM); 00637 #else 00638 throw(); 00639 #endif 00640 00641 //--Real -------- vector-scalar ------------ 00642 //--Real--------- Vector-vector--------- 00643 //-- Real -------- Vector-matrix ---------- 00644 // complex 00645 //--complex -------- vector-scalar ------------ 00646 //--complex--------- Vector-vector--------- 00647 //-- complex -------- Vector-matrix ---------- 00648 // interval 00649 //--interval -------- vector-scalar ------------ 00650 //--interval--------- Vector-vector--------- 00651 //-- interval -------- Vector-matrix ---------- 00652 // cvector x ivector ---------------- 00653 // vector - scalar ------- 00654 // vector - vector ------------- 00655 // vector - matrix ------------ 00656 00657 /* template<class T1,class T2,class T3> friend T3 _mvscimult(const T1 &m,const T2 &v) 00658 #if(CXSC_INDEX_CHECK) 00659 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM); 00660 #else 00661 throw(); 00662 #endif 00663 template<class T1,class T2,class T3> friend T3 _vsmcimult(const T1 &v,const T2 &m) 00664 #if(CXSC_INDEX_CHECK) 00665 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM); 00666 #else 00667 throw(); 00668 #endif */ 00669 00670 // real x complex -------------- 00671 // vector - vector -------------- 00672 00673 #endif 00674 00675 00676 //------ Konstruktoren ---------------------------------------------------- 00678 INLINE civector () throw(); 00680 explicit INLINE civector(const int &i) throw(); 00681 #ifdef OLD_CXSC 00682 00683 explicit INLINE civector(const class index &i) throw(); // for backwards compatibility 00684 #endif 00685 00686 explicit INLINE civector(const int &i1,const int &i2) 00687 #if(CXSC_INDEX_CHECK) 00688 throw(ERROR_CIVECTOR_WRONG_BOUNDARIES,ERROR_CIVECTOR_NO_MORE_MEMORY); 00689 #else 00690 throw(); 00691 #endif 00692 00693 INLINE civector(const cimatrix_subv &) throw(); 00695 explicit INLINE civector(const cinterval &) throw(); 00697 // explicit INLINE civector(const cimatrix &) 00698 explicit civector(const cimatrix &) 00699 #if(CXSC_INDEX_CHECK) 00700 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ); 00701 #else 00702 throw(); 00703 #endif 00704 00705 explicit INLINE civector(const cimatrix_slice &sl) 00706 #if(CXSC_INDEX_CHECK) 00707 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ); 00708 #else 00709 throw(); 00710 #endif 00711 00712 INLINE civector(const civector_slice &rs) throw(); 00714 INLINE civector(const civector &v) throw(); 00716 INLINE civector(const scivector_slice &rs); 00718 INLINE civector(const scivector &v); 00719 // Real 00721 explicit INLINE civector(const real &) throw(); 00723 explicit INLINE civector(const rvector_slice &rs) throw(); 00725 explicit INLINE civector(const rvector &v) throw(); 00727 explicit INLINE civector(const srvector_slice &rs); 00729 explicit INLINE civector(const srvector &v); 00731 explicit INLINE civector(const rmatrix &) 00732 #if(CXSC_INDEX_CHECK) 00733 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 00734 #else 00735 throw(); 00736 #endif 00737 00738 explicit INLINE civector(const rmatrix_slice &sl) 00739 #if(CXSC_INDEX_CHECK) 00740 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 00741 #else 00742 throw(); 00743 #endif 00744 00745 explicit INLINE civector(const rmatrix_subv &) throw(); 00746 00747 // complex 00749 explicit INLINE civector(const complex &) throw(); 00751 explicit INLINE civector(const cvector_slice &rs) throw(); 00753 explicit INLINE civector(const cvector &v) throw(); 00755 explicit INLINE civector(const scvector_slice &rs); 00757 explicit INLINE civector(const scvector &v); 00759 explicit INLINE civector(const cmatrix &) 00760 #if(CXSC_INDEX_CHECK) 00761 throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ); 00762 #else 00763 throw(); 00764 #endif 00765 00766 explicit INLINE civector(const cmatrix_slice &sl) 00767 #if(CXSC_INDEX_CHECK) 00768 throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ); 00769 #else 00770 throw(); 00771 #endif 00772 00773 explicit INLINE civector(const cmatrix_subv &) throw(); 00774 00775 // interval 00777 explicit INLINE civector(const interval &) throw(); 00779 explicit INLINE civector(const ivector_slice &rs) throw(); 00781 explicit INLINE civector(const ivector &v) throw(); 00783 explicit INLINE civector(const sivector_slice &rs); 00785 explicit INLINE civector(const sivector &v); 00787 explicit INLINE civector(const imatrix &) 00788 #if(CXSC_INDEX_CHECK) 00789 throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ); 00790 #else 00791 throw(); 00792 #endif 00793 00794 explicit INLINE civector(const imatrix_slice &sl) 00795 #if(CXSC_INDEX_CHECK) 00796 throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ); 00797 #else 00798 throw(); 00799 #endif 00800 00801 explicit INLINE civector(const imatrix_subv &) throw(); 00802 00803 // cinterval 00805 INLINE civector &operator =(const civector &rv) throw(); 00807 INLINE civector &operator =(const civector_slice &sl) throw(); 00809 INLINE civector &operator =(const scivector &rv) ; 00811 INLINE civector &operator =(const scivector_slice &sl) ; 00813 INLINE civector &operator =(const cinterval &r) throw(); 00815 INLINE civector &operator =(const cimatrix &m) 00816 #if(CXSC_INDEX_CHECK) 00817 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ); 00818 #else 00819 throw(); 00820 #endif 00821 00822 INLINE civector &operator =(const cimatrix_slice &) 00823 #if(CXSC_INDEX_CHECK) 00824 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ); 00825 #else 00826 throw(); 00827 #endif 00828 00829 INLINE civector &operator =(const cimatrix_subv &) throw(); 00830 // Real 00832 INLINE civector &operator =(const rvector &rv) throw(); 00834 INLINE civector &operator =(const rvector_slice &sl) throw(); 00836 INLINE civector &operator =(const srvector &rv); 00838 INLINE civector &operator =(const srvector_slice &sl); 00840 INLINE civector &operator =(const real &r) throw(); 00842 INLINE civector &operator =(const rmatrix &m) 00843 #if(CXSC_INDEX_CHECK) 00844 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 00845 #else 00846 throw(); 00847 #endif 00848 00849 INLINE civector &operator =(const rmatrix_slice &) 00850 #if(CXSC_INDEX_CHECK) 00851 throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 00852 #else 00853 throw(); 00854 #endif 00855 00856 INLINE civector &operator =(const rmatrix_subv &) throw(); 00857 00858 // complex 00860 INLINE civector &operator =(const cvector &rv) throw(); 00862 INLINE civector &operator =(const cvector_slice &sl) throw(); 00864 INLINE civector &operator =(const scvector &rv); 00866 INLINE civector &operator =(const scvector_slice &sl); 00868 INLINE civector &operator =(const complex &r) throw(); 00870 INLINE civector &operator =(const cmatrix &m) 00871 #if(CXSC_INDEX_CHECK) 00872 throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ); 00873 #else 00874 throw(); 00875 #endif 00876 00877 INLINE civector &operator =(const cmatrix_slice &) 00878 #if(CXSC_INDEX_CHECK) 00879 throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ); 00880 #else 00881 throw(); 00882 #endif 00883 00884 INLINE civector &operator =(const cmatrix_subv &) throw(); 00885 00886 // interval 00888 INLINE civector &operator =(const ivector &rv) throw(); 00890 INLINE civector &operator =(const ivector_slice &sl) throw(); 00892 INLINE civector &operator =(const sivector &rv) ; 00894 INLINE civector &operator =(const sivector_slice &sl) ; 00896 INLINE civector &operator =(const interval &r) throw(); 00898 INLINE civector &operator =(const imatrix &m) 00899 #if(CXSC_INDEX_CHECK) 00900 throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ); 00901 #else 00902 throw(); 00903 #endif 00904 00905 INLINE civector &operator =(const imatrix_slice &) 00906 #if(CXSC_INDEX_CHECK) 00907 throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ); 00908 #else 00909 throw(); 00910 #endif 00911 00912 INLINE civector &operator =(const imatrix_subv &) throw(); 00913 00914 00915 civector& operator+=(const srvector&); 00916 civector& operator+=(const scvector&); 00917 civector& operator+=(const sivector&); 00918 civector& operator+=(const scivector&); 00919 civector& operator-=(const srvector&); 00920 civector& operator-=(const scvector&); 00921 civector& operator-=(const sivector&); 00922 civector& operator-=(const scivector&); 00923 civector& operator|=(const srvector&); 00924 civector& operator|=(const scvector&); 00925 civector& operator|=(const sivector&); 00926 civector& operator|=(const scivector&); 00927 civector& operator&=(const sivector&); 00928 civector& operator&=(const scivector&); 00929 civector& operator+=(const srvector_slice&); 00930 civector& operator+=(const scvector_slice&); 00931 civector& operator+=(const sivector_slice&); 00932 civector& operator+=(const scivector_slice&); 00933 civector& operator-=(const srvector_slice&); 00934 civector& operator-=(const scvector_slice&); 00935 civector& operator-=(const sivector_slice&); 00936 civector& operator-=(const scivector_slice&); 00937 civector& operator|=(const srvector_slice&); 00938 civector& operator|=(const scvector_slice&); 00939 civector& operator|=(const sivector_slice&); 00940 civector& operator|=(const scivector_slice&); 00941 civector& operator&=(const sivector_slice&); 00942 civector& operator&=(const scivector_slice&); 00943 00945 INLINE civector operator()(const intvector& p); 00947 INLINE civector operator()(const intmatrix& P); 00948 00949 //--------- Destruktor ---------------------------------------------------- 00950 INLINE ~civector() { delete [] dat; } 00951 00952 //------ Standardfunktionen ----------------------------------------------- 00953 00954 friend INLINE cinterval::cinterval(const civector &) 00955 #if(CXSC_INDEX_CHECK) 00956 throw(ERROR_CIVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_CIVECTOR_USE_OF_UNINITIALIZED_OBJ); 00957 #else 00958 throw(); 00959 #endif 00960 00961 friend INLINE int Lb(const civector &rv) throw() { return rv.l; } 00963 friend INLINE int Ub(const civector &rv) throw() { return rv.u; } 00965 friend INLINE int VecLen(const civector &rv) throw() { return rv.size; } 00967 friend INLINE civector & SetLb(civector &rv, const int &l) throw() { rv.l=l; rv.u=l+rv.size-1; return rv;} 00969 friend INLINE civector & SetUb(civector &rv, const int &u) throw() { rv.u=u; rv.l=u-rv.size+1; return rv;} 00971 INLINE cinterval & operator [](const int &i) const 00972 #if(CXSC_INDEX_CHECK) 00973 throw(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC); 00974 #else 00975 throw(); 00976 #endif 00977 00979 INLINE cinterval & operator [](const int &i) 00980 #if(CXSC_INDEX_CHECK) 00981 throw(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC); 00982 #else 00983 throw(); 00984 #endif 00985 00987 INLINE civector & operator ()() throw() { return *this; } 00989 INLINE civector_slice operator ()(const int &i) 00990 #if(CXSC_INDEX_CHECK) 00991 throw(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG); 00992 #else 00993 throw(); 00994 #endif 00995 00996 civector_slice operator ()(const int &i1,const int &i2) 00997 #if(CXSC_INDEX_CHECK) 00998 throw(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG); 00999 #else 01000 throw(); 01001 #endif 01002 01003 INLINE operator void*() throw(); 01004 //#else 01005 //#endif 01006 }; 01007 01009 01014 class civector_slice 01015 { 01016 friend class civector; 01017 friend class cimatrix; 01018 private: 01019 cinterval *dat; 01020 int l,u,size; 01021 int start,end; 01022 01023 public: 01024 //#if(CXSC_INDEX_CHECK) 01025 #ifdef _CXSC_FRIEND_TPL 01026 //------------------------- Templates ------------------------------------------- 01027 // cinterval / cinterval 01028 01029 template <class VS1,class VS2> friend VS1 & _vsvsassign(VS1 &sl1,const VS2 &sl2) 01030 #if(CXSC_INDEX_CHECK) 01031 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01032 #else 01033 throw(); 01034 #endif 01035 template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) throw(); 01036 template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv) 01037 #if(CXSC_INDEX_CHECK) 01038 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 01039 #else 01040 throw(); 01041 #endif 01042 template <class VS,class S> friend VS & _vssassign(VS &sl,const S &r) throw(); 01043 template <class VS,class V> friend VS &_vsvsetinf(VS &sl, const V &rv) 01044 #if(CXSC_INDEX_CHECK) 01045 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 01046 #else 01047 throw(); 01048 #endif 01049 template <class VS,class V> friend VS &_vsvsetsup(VS &sl, const V &rv) 01050 #if(CXSC_INDEX_CHECK) 01051 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 01052 #else 01053 throw(); 01054 #endif 01055 template <class VS1,class VS2> friend VS1 &_vsvssetinf(VS1 &sl1, const VS2 &sl2) 01056 #if(CXSC_INDEX_CHECK) 01057 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01058 #else 01059 throw(); 01060 #endif 01061 template <class VS1,class VS2> friend VS1 &_vsvssetsup(VS1 &sl1, const VS2 &sl2) 01062 #if(CXSC_INDEX_CHECK) 01063 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01064 #else 01065 throw(); 01066 #endif 01067 template <class VS,class V> friend VS &_vsvusetinf(VS &sl, const V &rv) 01068 #if(CXSC_INDEX_CHECK) 01069 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 01070 #else 01071 throw(); 01072 #endif 01073 template <class VS,class V> friend VS &_vsvusetsup(VS &sl, const V &rv) 01074 #if(CXSC_INDEX_CHECK) 01075 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 01076 #else 01077 throw(); 01078 #endif 01079 template <class VS1,class VS2> friend VS1 &_vsvsusetinf(VS1 &sl1, const VS2 &sl2) 01080 #if(CXSC_INDEX_CHECK) 01081 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01082 #else 01083 throw(); 01084 #endif 01085 template <class VS1,class VS2> friend VS1 &_vsvsusetsup(VS1 &sl1, const VS2 &sl2) 01086 #if(CXSC_INDEX_CHECK) 01087 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01088 #else 01089 throw(); 01090 #endif 01091 01092 template <class VS,class E> friend E _vsconj(const VS &sl) throw(); 01093 template <class VS,class E> friend E _vsabs(const VS &sl) throw(); 01094 template <class VS,class E> friend E _vsdiam(const VS &sl) throw(); 01095 template <class VS,class E> friend E _vsmid(const VS &sl) throw(); 01096 template <class VS,class E> friend E _vsinf(const VS &sl) throw(); 01097 template <class VS,class E> friend E _vssup(const VS &sl) throw(); 01098 template <class VS,class E> friend E _vsim(const VS &sl) throw(); 01099 template <class VS,class E> friend E _vsre(const VS &sl) throw(); 01100 friend INLINE ivector Re(const civector_slice &v) throw(); 01101 friend INLINE ivector Im(const civector_slice &v) throw(); 01102 friend INLINE cvector Inf(const civector_slice &v) throw(); 01103 friend INLINE cvector Sup(const civector_slice &v) throw(); 01104 friend INLINE rvector SupRe(const civector_slice &v) throw(); 01105 friend INLINE rvector SupIm(const civector_slice &v) throw(); 01106 friend INLINE rvector InfRe(const civector_slice &v) throw(); 01107 friend INLINE rvector InfIm(const civector_slice &v) throw(); 01108 template <class VS,class V> friend VS &_vsvsetim(VS &sl, const V &rv) 01109 #if(CXSC_INDEX_CHECK) 01110 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 01111 #else 01112 throw(); 01113 #endif 01114 template <class VS,class V> friend VS &_vsvsetre(VS &sl, const V &rv) 01115 #if(CXSC_INDEX_CHECK) 01116 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 01117 #else 01118 throw(); 01119 #endif 01120 template <class VS1,class VS2> friend VS1 &_vsvssetim(VS1 &sl1, const VS2 &sl2) 01121 #if(CXSC_INDEX_CHECK) 01122 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01123 #else 01124 throw(); 01125 #endif 01126 template <class VS1,class VS2> friend VS1 &_vsvssetre(VS1 &sl1, const VS2 &sl2) 01127 #if(CXSC_INDEX_CHECK) 01128 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01129 #else 01130 throw(); 01131 #endif 01132 /* friend TINLINE civector_slice &_vsmvsetim(civector_slice &,const imatrix_subv &) 01133 #if(CXSC_INDEX_CHECK) 01134 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01135 #else 01136 throw(); 01137 #endif 01138 friend TINLINE civector_slice &_vsmvsetre(civector_slice &,const imatrix_subv &) 01139 #if(CXSC_INDEX_CHECK) 01140 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01141 #else 01142 throw(); 01143 #endif */ 01144 template <class VS,class S> friend VS &_vsssetinf(VS &vs, const S &s) throw(); 01145 template <class VS,class S> friend VS &_vsssetsup(VS &vs, const S &s) throw(); 01146 template <class VS,class S> friend VS &_vssusetinf(VS &vs, const S &s) throw(); 01147 template <class VS,class S> friend VS &_vssusetsup(VS &vs, const S &s) throw(); 01148 template <class VS,class S> friend VS &_vsssetim(VS &vs, const S &s) throw(); 01149 template <class VS,class S> friend VS &_vsssetre(VS &vs, const S &s) throw(); 01150 01151 template <class DP,class VS,class V> friend void _vsvaccu(DP &dp, const VS & sl, const V &rv) 01152 #if(CXSC_INDEX_CHECK) 01153 throw(OP_WITH_WRONG_DIM); 01154 #else 01155 throw(); 01156 #endif 01157 template <class DP,class VS1,class VS2> friend void _vsvsaccu(DP &dp, const VS1 & sl1, const VS2 &sl2) 01158 #if(CXSC_INDEX_CHECK) 01159 throw(OP_WITH_WRONG_DIM); 01160 #else 01161 throw(); 01162 #endif 01163 01164 template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) throw(); 01165 template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) throw(); 01166 01167 template <class VS,class V,class E> friend E _vsvcimult(const VS & sl, const V &rv) 01168 #if(CXSC_INDEX_CHECK) 01169 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01170 #else 01171 throw(); 01172 #endif 01173 template <class VS,class S> friend VS &_vssmultassign(VS &rv,const S &r) throw(); 01174 template <class VS,class S> friend VS &_vssdivassign(VS &rv,const S &r) throw(); 01175 template <class V,class VS,class E> friend E _vvsplus(const V &rv,const VS &sl) 01176 #if(CXSC_INDEX_CHECK) 01177 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01178 #else 01179 throw(); 01180 #endif 01181 template <class VS1,class VS2,class E> friend E _vsvsplus(const VS1 &s1,const VS2 &s2) 01182 #if(CXSC_INDEX_CHECK) 01183 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01184 #else 01185 throw(); 01186 #endif 01187 template <class VS1,class VS2,class E> friend E _vsvsminus(const VS1 &s1,const VS2 &s2) 01188 #if(CXSC_INDEX_CHECK) 01189 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01190 #else 01191 throw(); 01192 #endif 01193 template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl) 01194 #if(CXSC_INDEX_CHECK) 01195 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01196 #else 01197 throw(); 01198 #endif 01199 template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv) 01200 #if(CXSC_INDEX_CHECK) 01201 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 01202 #else 01203 throw(); 01204 #endif 01205 template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2) 01206 #if(CXSC_INDEX_CHECK) 01207 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01208 #else 01209 throw(); 01210 #endif 01211 template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2) 01212 #if(CXSC_INDEX_CHECK) 01213 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01214 #else 01215 throw(); 01216 #endif 01217 template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl) 01218 #if(CXSC_INDEX_CHECK) 01219 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01220 #else 01221 throw(); 01222 #endif 01223 template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv) 01224 #if(CXSC_INDEX_CHECK) 01225 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 01226 #else 01227 throw(); 01228 #endif 01229 template <class VS,class V> friend V _vsminus(const VS &sl) throw(); 01230 template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl) 01231 #if(CXSC_INDEX_CHECK) 01232 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01233 #else 01234 throw(); 01235 #endif 01236 template <class VS,class V,class E> friend E _vsvminus(const VS &sl,const V &rv) 01237 #if(CXSC_INDEX_CHECK) 01238 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01239 #else 01240 throw(); 01241 #endif 01242 template <class V,class VS,class E> friend E _vvssect(const V &rv,const VS &sl) 01243 #if(CXSC_INDEX_CHECK) 01244 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01245 #else 01246 throw(); 01247 #endif 01248 template <class VS1,class VS2,class E> friend E _vsvssect(const VS1 &s1,const VS2 &s2) 01249 #if(CXSC_INDEX_CHECK) 01250 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01251 #else 01252 throw(); 01253 #endif 01254 template <class V,class VS> friend V &_vvssectassign(V &rv, const VS &sl) 01255 #if(CXSC_INDEX_CHECK) 01256 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01257 #else 01258 throw(); 01259 #endif 01260 template <class VS,class V> friend VS &_vsvsectassign(VS &sl, const V &rv) 01261 #if(CXSC_INDEX_CHECK) 01262 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 01263 #else 01264 throw(); 01265 #endif 01266 template <class VS1,class VS2> friend VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2) 01267 #if(CXSC_INDEX_CHECK) 01268 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01269 #else 01270 throw(); 01271 #endif 01272 template <class V,class VS,class E> friend E _vvsconv(const V &rv,const VS &sl) 01273 #if(CXSC_INDEX_CHECK) 01274 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01275 #else 01276 throw(); 01277 #endif 01278 template <class VS1,class VS2,class E> friend E _vsvsconv(const VS1 &s1,const VS2 &s2) 01279 #if(CXSC_INDEX_CHECK) 01280 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01281 #else 01282 throw(); 01283 #endif 01284 template <class V,class VS> friend V &_vvsconvassign(V &rv, const VS &sl) 01285 #if(CXSC_INDEX_CHECK) 01286 throw(ERROR__OP_WITH_WRONG_DIM<V>); 01287 #else 01288 throw(); 01289 #endif 01290 template <class VS,class V> friend VS &_vsvconvassign(VS &sl, const V &rv) 01291 #if(CXSC_INDEX_CHECK) 01292 throw(ERROR__OP_WITH_WRONG_DIM<VS>); 01293 #else 01294 throw(); 01295 #endif 01296 template <class VS1,class VS2> friend VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2) 01297 #if(CXSC_INDEX_CHECK) 01298 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01299 #else 01300 throw(); 01301 #endif 01302 template <class VS,class M,class S> friend VS &_vsmcimultassign(VS &v,const M &m) 01303 #if(CXSC_INDEX_CHECK) 01304 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01305 #else 01306 throw(); 01307 #endif 01308 01309 template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) throw(); 01310 template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) throw(); 01311 template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) throw(); 01312 template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) throw(); 01313 template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) throw(); 01314 template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) throw(); 01315 template <class VS1,class VS2,class E> friend E _vsvscimult(const VS1 & sl1, const VS2 &sl2) 01316 #if(CXSC_INDEX_CHECK) 01317 throw(ERROR__OP_WITH_WRONG_DIM<VS1>); 01318 #else 01319 throw(); 01320 #endif 01321 template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw(); 01322 template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw(); 01323 template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw(); 01324 template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw(); 01325 template <class VS> friend bool _vsnot(const VS &sl) throw(); 01326 template <class VS> friend void *_vsvoid(const VS &sl) throw(); 01327 template <class V> friend std::ostream &_vsout(std::ostream &s, const V &rv) throw(); 01328 template <class V> friend std::istream &_vsin(std::istream &s, V &rv) throw(); 01329 01330 // cinterval / Real 01331 template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms) 01332 #if(CXSC_INDEX_CHECK) 01333 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01334 #else 01335 throw(); 01336 #endif 01337 // cinterval / complex 01338 template <class DP,class V1,class V2> friend void _vvaccu(DP &dp, const V1 & rv1, const V2 &rv2) 01339 #if(CXSC_INDEX_CHECK) 01340 throw(OP_WITH_WRONG_DIM); 01341 #else 01342 throw(); 01343 #endif 01344 01345 // cinterval / interval 01346 // complex 01347 template <class V1,class V2,class S> friend V1 &_vvassign(V1 &rv1,const V2 &rv2) throw(); 01348 template <class V,class S> friend V & _vsassign(V &rv,const S &r) throw(); 01349 01350 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m) 01351 #if(CXSC_INDEX_CHECK) 01352 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>); 01353 #else 01354 throw(); 01355 #endif 01356 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) throw(); 01357 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) throw(); 01358 01359 template <class V1,class V2,class E> friend E _vvconv(const V1 &rv1, const V2 &rv2) 01360 #if(CXSC_INDEX_CHECK) 01361 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01362 #else 01363 throw(); 01364 #endif 01365 01366 //--complex -------- vector-scalar ------------ 01367 template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) throw(); 01368 template <class V,class S,class E> friend E _vsmult(const V &rv, const S &s) throw(); 01369 template <class V,class S,class E> friend E _vsdiv(const V &rv, const S &s) throw(); 01370 template <class V,class S> friend V &_vsdivassign(V &rv,const S &r) throw(); 01371 template <class V,class S> friend V &_vsmultassign(V &rv,const S &r) throw(); 01372 //--complex--------- Vector-vector--------- 01373 template <class V1,class V2,class E> friend E _vvcimult(const V1 & rv1, const V2 &rv2) 01374 #if(CXSC_INDEX_CHECK) 01375 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 01376 #else 01377 throw(); 01378 #endif 01379 template <class V1,class V2,class E> friend E _vvplus(const V1 &rv1, const V2 &rv2) 01380 #if(CXSC_INDEX_CHECK) 01381 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 01382 #else 01383 throw(); 01384 #endif 01385 template <class V1,class V2> friend V1 &_vvplusassign(V1 &rv1, const V2 &rv2) 01386 #if(CXSC_INDEX_CHECK) 01387 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 01388 #else 01389 throw(); 01390 #endif 01391 template <class V1,class V2> friend V1 &_vvminusassign(V1 &rv1, const V2 &rv2) 01392 #if(CXSC_INDEX_CHECK) 01393 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 01394 #else 01395 throw(); 01396 #endif 01397 template <class V1,class V2,class E> friend E _vvminus(const V1 &rv1, const V2 &rv2) 01398 #if(CXSC_INDEX_CHECK) 01399 throw(ERROR__OP_WITH_WRONG_DIM<E>); 01400 #else 01401 throw(); 01402 #endif 01403 template <class V1,class V2> friend V1 &_vvconvassign(V1 &rv1, const V2 &rv2) 01404 #if(CXSC_INDEX_CHECK) 01405 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 01406 #else 01407 throw(); 01408 #endif 01409 template <class V1,class V2,class E> friend E _vvsect(const V1 &rv1, const V2 &rv2) 01410 #if(CXSC_INDEX_CHECK) 01411 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 01412 #else 01413 throw(); 01414 #endif 01415 template <class V1,class V2> friend V1 &_vvsectassign(V1 &rv1, const V2 &rv2) 01416 #if(CXSC_INDEX_CHECK) 01417 throw(ERROR__OP_WITH_WRONG_DIM<V1>); 01418 #else 01419 throw(); 01420 #endif 01421 01422 //-- complex -------- Vector-matrix ---------- 01423 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m) 01424 #if(CXSC_INDEX_CHECK) 01425 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>); 01426 #else 01427 throw(); 01428 #endif 01429 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m) 01430 #if(CXSC_INDEX_CHECK) 01431 throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>); 01432 #else 01433 throw(); 01434 #endif 01435 template <class M,class V,class E> friend E _mvcimult(const M &m,const V &v) 01436 #if(CXSC_INDEX_CHECK) 01437 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01438 #else 01439 throw(); 01440 #endif 01441 template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v) 01442 #if(CXSC_INDEX_CHECK) 01443 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01444 #else 01445 throw(); 01446 #endif 01447 template <class V,class M,class E> friend E _vmcimult(const V &v,const M &m) 01448 #if(CXSC_INDEX_CHECK) 01449 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01450 #else 01451 throw(); 01452 #endif 01453 template <class V,class MS,class S> friend V &_vmscimultassign(V &v,const MS &ms) 01454 #if(CXSC_INDEX_CHECK) 01455 throw(ERROR__OP_WITH_WRONG_DIM<MS>); 01456 #else 01457 throw(); 01458 #endif 01459 template <class V,class M,class S> friend V &_vmcimultassign(V &v,const M &m) 01460 #if(CXSC_INDEX_CHECK) 01461 throw(ERROR__OP_WITH_WRONG_DIM<M>); 01462 #else 01463 throw(); 01464 #endif 01465 01466 // interval 01467 /* friend TINLINE civector &_vsmassign<civector_slice,imatrix,cinterval>(civector_slice &v,const imatrix &m) 01468 #if(CXSC_INDEX_CHECK) 01469 throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ); 01470 #else 01471 throw(); 01472 #endif */ 01473 01474 //--interval -------- vector-scalar ------------ 01475 //--interval--------- Vector-vector--------- 01476 //-- interval -------- Vector-matrix ---------- 01477 /* friend TINLINE civector _mvscimult<imatrix,civector_slice,civector>(const imatrix &m,const civector_slice &v) 01478 #if(CXSC_INDEX_CHECK) 01479 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM); 01480 #else 01481 throw(); 01482 #endif */ 01483 /* friend TINLINE civector _msvscimult<imatrix_slice,civector_slice,civector>(const imatrix_slice &ms,const civector_slice &v) 01484 #if(CXSC_INDEX_CHECK) 01485 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM); 01486 #else 01487 throw(); 01488 #endif */ 01489 /* friend TINLINE civector _vsmcimult<civector_slice,imatrix,civector>(const civector_slice &v,const imatrix &m) 01490 #if(CXSC_INDEX_CHECK) 01491 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM); 01492 #else 01493 throw(); 01494 #endif */ 01495 /* friend TINLINE civector _vsmscimult<civector_slice,imatrix_slice,civector>(const civector_slice &v,const imatrix_slice &ms) 01496 #if(CXSC_INDEX_CHECK) 01497 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM); 01498 #else 01499 throw(); 01500 #endif */ 01501 /* friend TINLINE civector &_vsmscimultassign<civector_slice,imatrix_slice,cinterval>(civector_slice &v,const imatrix_slice &m) 01502 #if(CXSC_INDEX_CHECK) 01503 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM); 01504 #else 01505 throw(); 01506 #endif */ 01507 01508 01509 #endif 01510 01511 //--------------------- Konstruktoren ----------------------------------- 01513 explicit INLINE civector_slice(civector &a, const int &lb, const int &ub) throw():dat(a.dat),l(a.l),u(a.u),size(ub-lb+1),start(lb),end(ub) { } 01515 explicit INLINE civector_slice(civector_slice &a, const int &lb, const int &ub) throw():dat(a.dat),l(a.l),u(a.u),size(ub-lb+1),start(lb),end(ub) { } 01516 public: 01518 INLINE civector_slice(const civector_slice &a) throw():dat(a.dat),l(a.l),u(a.u),size(a.size),start(a.start),end(a.end) { } 01519 public: 01520 // cinterval 01522 INLINE civector_slice & operator =(const scivector_slice &sl); 01524 INLINE civector_slice & operator =(const scivector &sl); 01525 01527 INLINE civector_slice & operator =(const civector_slice &sl) 01528 #if(CXSC_INDEX_CHECK) 01529 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01530 #else 01531 throw(); 01532 #endif 01533 01534 INLINE civector_slice & operator =(const civector &rv) 01535 #if(CXSC_INDEX_CHECK) 01536 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01537 #else 01538 throw(); 01539 #endif 01540 01541 INLINE civector_slice & operator =(const cinterval &r) throw(); 01543 INLINE civector_slice & operator =(const cimatrix &m) 01544 #if(CXSC_INDEX_CHECK) 01545 throw(ERROR__OP_WITH_WRONG_DIM<civector>,ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ); 01546 #else 01547 throw(); 01548 #endif 01549 01550 INLINE civector_slice & operator =(const cimatrix_slice &m) 01551 #if(CXSC_INDEX_CHECK) 01552 throw(ERROR__OP_WITH_WRONG_DIM<civector>,ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ); 01553 #else 01554 throw(); 01555 #endif 01556 01557 INLINE civector_slice &operator =(const cimatrix_subv &) throw(); 01558 // Real 01560 INLINE civector_slice & operator =(const srvector_slice &sl); 01562 INLINE civector_slice & operator =(const srvector &sl); 01563 01565 INLINE civector_slice & operator =(const rvector_slice &sl) 01566 #if(CXSC_INDEX_CHECK) 01567 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01568 #else 01569 throw(); 01570 #endif 01571 01572 INLINE civector_slice & operator =(const rvector &rv) 01573 #if(CXSC_INDEX_CHECK) 01574 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01575 #else 01576 throw(); 01577 #endif 01578 01579 INLINE civector_slice & operator =(const real &r) throw(); 01581 INLINE civector_slice & operator =(const rmatrix &m) 01582 #if(CXSC_INDEX_CHECK) 01583 throw(ERROR__OP_WITH_WRONG_DIM<rvector>,ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 01584 #else 01585 throw(); 01586 #endif 01587 01588 INLINE civector_slice & operator =(const rmatrix_slice &m) 01589 #if(CXSC_INDEX_CHECK) 01590 throw(ERROR__OP_WITH_WRONG_DIM<rvector>,ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 01591 #else 01592 throw(); 01593 #endif 01594 01595 INLINE civector_slice &operator =(const rmatrix_subv &mv) throw(); 01596 01597 // complex 01599 INLINE civector_slice & operator =(const scvector_slice &sl); 01601 INLINE civector_slice & operator =(const scvector &sl); 01602 01604 INLINE civector_slice & operator =(const cvector_slice &sl) 01605 #if(CXSC_INDEX_CHECK) 01606 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01607 #else 01608 throw(); 01609 #endif 01610 01611 INLINE civector_slice & operator =(const cvector &rv) 01612 #if(CXSC_INDEX_CHECK) 01613 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01614 #else 01615 throw(); 01616 #endif 01617 01618 INLINE civector_slice & operator =(const complex &r) throw(); 01620 INLINE civector_slice & operator =(const cmatrix &m) 01621 #if(CXSC_INDEX_CHECK) 01622 throw(ERROR__OP_WITH_WRONG_DIM<cvector>,ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ); 01623 #else 01624 throw(); 01625 #endif 01626 01627 INLINE civector_slice & operator =(const cmatrix_slice &m) 01628 #if(CXSC_INDEX_CHECK) 01629 throw(ERROR__OP_WITH_WRONG_DIM<cvector>,ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ); 01630 #else 01631 throw(); 01632 #endif 01633 01634 INLINE civector_slice &operator =(const cmatrix_subv &mv) throw(); 01635 01636 // interval 01638 INLINE civector_slice & operator =(const sivector_slice &sl); 01640 INLINE civector_slice & operator =(const sivector &sl); 01641 01643 INLINE civector_slice & operator =(const ivector_slice &sl) 01644 #if(CXSC_INDEX_CHECK) 01645 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01646 #else 01647 throw(); 01648 #endif 01649 01650 INLINE civector_slice & operator =(const ivector &rv) 01651 #if(CXSC_INDEX_CHECK) 01652 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01653 #else 01654 throw(); 01655 #endif 01656 01657 INLINE civector_slice & operator =(const interval &r) throw(); 01659 INLINE civector_slice & operator =(const imatrix &m) 01660 #if(CXSC_INDEX_CHECK) 01661 throw(ERROR__OP_WITH_WRONG_DIM<ivector>,ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ); 01662 #else 01663 throw(); 01664 #endif 01665 01666 INLINE civector_slice & operator =(const imatrix_slice &m) 01667 #if(CXSC_INDEX_CHECK) 01668 throw(ERROR__OP_WITH_WRONG_DIM<ivector>,ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ); 01669 #else 01670 throw(); 01671 #endif 01672 01673 INLINE civector_slice &operator =(const imatrix_subv &mv) throw(); 01674 01675 //--------------------- Standardfunktionen ------------------------------ 01676 01677 friend INLINE cinterval::cinterval(const civector_slice &sl) 01678 #if(CXSC_INDEX_CHECK) 01679 throw(ERROR_CIVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_CIVECTOR_USE_OF_UNINITIALIZED_OBJ); 01680 #else 01681 throw(); 01682 #endif 01683 01684 friend INLINE int Lb(const civector_slice &sl) throw() { return sl.start; } 01686 friend INLINE int Ub(const civector_slice &sl) throw() { return sl.end; } 01688 friend INLINE int VecLen(const civector_slice &sl) throw() { return sl.size; } 01689 01691 INLINE cinterval & operator [](const int &i) const 01692 #if(CXSC_INDEX_CHECK) 01693 throw(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC); 01694 #else 01695 throw(); 01696 #endif 01697 01699 INLINE cinterval & operator [](const int &i) 01700 #if(CXSC_INDEX_CHECK) 01701 throw(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC); 01702 #else 01703 throw(); 01704 #endif 01705 01707 INLINE civector_slice & operator ()() throw() { return *this; } 01709 INLINE civector_slice operator ()(const int &i) 01710 #if(CXSC_INDEX_CHECK) 01711 throw(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG); 01712 #else 01713 throw(); 01714 #endif 01715 01716 civector_slice operator ()(const int &i1,const int &i2) 01717 #if(CXSC_INDEX_CHECK) 01718 throw(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG); 01719 #else 01720 throw(); 01721 #endif 01722 INLINE operator void*() throw(); 01723 01725 INLINE civector_slice &operator *=(const cinterval &r) throw(); 01727 INLINE civector_slice &operator /=(const cinterval &r) throw(); 01729 INLINE civector_slice &operator *=(const cimatrix &m) 01730 #if(CXSC_INDEX_CHECK) 01731 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM); 01732 #else 01733 throw(); 01734 #endif 01735 01736 INLINE civector_slice &operator *=(const cimatrix_slice &m) 01737 #if(CXSC_INDEX_CHECK) 01738 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM); 01739 #else 01740 throw(); 01741 #endif 01742 01743 INLINE civector_slice &operator +=(const civector &rv) 01744 #if(CXSC_INDEX_CHECK) 01745 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01746 #else 01747 throw(); 01748 #endif 01749 01750 INLINE civector_slice &operator +=(const civector_slice &sl2) 01751 #if(CXSC_INDEX_CHECK) 01752 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01753 #else 01754 throw(); 01755 #endif 01756 01757 INLINE civector_slice &operator -=(const civector &rv) 01758 #if(CXSC_INDEX_CHECK) 01759 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01760 #else 01761 throw(); 01762 #endif 01763 01764 INLINE civector_slice &operator -=(const civector_slice &sl2) 01765 #if(CXSC_INDEX_CHECK) 01766 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01767 #else 01768 throw(); 01769 #endif 01770 01771 INLINE civector_slice &operator |=(const civector &rv) 01772 #if(CXSC_INDEX_CHECK) 01773 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01774 #else 01775 throw(); 01776 #endif 01777 01778 INLINE civector_slice &operator |=(const civector_slice &sl2) 01779 #if(CXSC_INDEX_CHECK) 01780 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01781 #else 01782 throw(); 01783 #endif 01784 01785 INLINE civector_slice &operator &=(const civector &rv) 01786 #if(CXSC_INDEX_CHECK) 01787 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01788 #else 01789 throw(); 01790 #endif 01791 01792 INLINE civector_slice &operator &=(const civector_slice &sl2) 01793 #if(CXSC_INDEX_CHECK) 01794 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01795 #else 01796 throw(); 01797 #endif 01798 01800 INLINE civector_slice &operator *=(const real &r) throw(); 01802 INLINE civector_slice &operator /=(const real &r) throw(); 01804 INLINE civector_slice &operator +=(const rvector &rv) 01805 #if(CXSC_INDEX_CHECK) 01806 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01807 #else 01808 throw(); 01809 #endif 01810 01811 INLINE civector_slice &operator +=(const rvector_slice &sl2) 01812 #if(CXSC_INDEX_CHECK) 01813 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01814 #else 01815 throw(); 01816 #endif 01817 01818 INLINE civector_slice &operator -=(const rvector &rv) 01819 #if(CXSC_INDEX_CHECK) 01820 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01821 #else 01822 throw(); 01823 #endif 01824 01825 INLINE civector_slice &operator -=(const rvector_slice &sl2) 01826 #if(CXSC_INDEX_CHECK) 01827 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01828 #else 01829 throw(); 01830 #endif 01831 01832 INLINE civector_slice &operator |=(const rvector &rv) 01833 #if(CXSC_INDEX_CHECK) 01834 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01835 #else 01836 throw(); 01837 #endif 01838 01839 INLINE civector_slice &operator |=(const rvector_slice &sl2) 01840 #if(CXSC_INDEX_CHECK) 01841 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01842 #else 01843 throw(); 01844 #endif 01845 01846 INLINE civector_slice &operator &=(const rvector &rv) 01847 #if(CXSC_INDEX_CHECK) 01848 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01849 #else 01850 throw(); 01851 #endif 01852 01853 INLINE civector_slice &operator &=(const rvector_slice &sl2) 01854 #if(CXSC_INDEX_CHECK) 01855 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01856 #else 01857 throw(); 01858 #endif 01859 01860 INLINE civector_slice &operator *=(const rmatrix &m) 01861 #if(CXSC_INDEX_CHECK) 01862 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 01863 #else 01864 throw(); 01865 #endif 01866 01867 INLINE civector_slice &operator *=(const rmatrix_slice &m) 01868 #if(CXSC_INDEX_CHECK) 01869 throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM); 01870 #else 01871 throw(); 01872 #endif 01873 01875 INLINE civector_slice &operator *=(const complex &r) throw(); 01877 INLINE civector_slice &operator /=(const complex &r) throw(); 01879 INLINE civector_slice &operator +=(const cvector &rv) 01880 #if(CXSC_INDEX_CHECK) 01881 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01882 #else 01883 throw(); 01884 #endif 01885 01886 INLINE civector_slice &operator +=(const cvector_slice &sl2) 01887 #if(CXSC_INDEX_CHECK) 01888 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01889 #else 01890 throw(); 01891 #endif 01892 01893 INLINE civector_slice &operator -=(const cvector &rv) 01894 #if(CXSC_INDEX_CHECK) 01895 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01896 #else 01897 throw(); 01898 #endif 01899 01900 INLINE civector_slice &operator -=(const cvector_slice &sl2) 01901 #if(CXSC_INDEX_CHECK) 01902 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01903 #else 01904 throw(); 01905 #endif 01906 01907 INLINE civector_slice &operator |=(const cvector &rv) 01908 #if(CXSC_INDEX_CHECK) 01909 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01910 #else 01911 throw(); 01912 #endif 01913 01914 INLINE civector_slice &operator |=(const cvector_slice &sl2) 01915 #if(CXSC_INDEX_CHECK) 01916 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01917 #else 01918 throw(); 01919 #endif 01920 01921 INLINE civector_slice &operator &=(const cvector &rv) 01922 #if(CXSC_INDEX_CHECK) 01923 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01924 #else 01925 throw(); 01926 #endif 01927 01928 INLINE civector_slice &operator &=(const cvector_slice &sl2) 01929 #if(CXSC_INDEX_CHECK) 01930 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01931 #else 01932 throw(); 01933 #endif 01934 01935 INLINE civector_slice &operator *=(const cmatrix &m) 01936 #if(CXSC_INDEX_CHECK) 01937 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 01938 #else 01939 throw(); 01940 #endif 01941 01942 INLINE civector_slice &operator *=(const cmatrix_slice &m) 01943 #if(CXSC_INDEX_CHECK) 01944 throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM); 01945 #else 01946 throw(); 01947 #endif 01948 01950 INLINE civector_slice &operator *=(const interval &r) throw(); 01952 INLINE civector_slice &operator /=(const interval &r) throw(); 01954 INLINE civector_slice &operator +=(const ivector &rv) 01955 #if(CXSC_INDEX_CHECK) 01956 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01957 #else 01958 throw(); 01959 #endif 01960 01961 INLINE civector_slice &operator +=(const ivector_slice &sl2) 01962 #if(CXSC_INDEX_CHECK) 01963 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01964 #else 01965 throw(); 01966 #endif 01967 01968 INLINE civector_slice &operator -=(const ivector &rv) 01969 #if(CXSC_INDEX_CHECK) 01970 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01971 #else 01972 throw(); 01973 #endif 01974 01975 INLINE civector_slice &operator -=(const ivector_slice &sl2) 01976 #if(CXSC_INDEX_CHECK) 01977 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01978 #else 01979 throw(); 01980 #endif 01981 01982 INLINE civector_slice &operator |=(const ivector &rv) 01983 #if(CXSC_INDEX_CHECK) 01984 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01985 #else 01986 throw(); 01987 #endif 01988 01989 INLINE civector_slice &operator |=(const ivector_slice &sl2) 01990 #if(CXSC_INDEX_CHECK) 01991 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01992 #else 01993 throw(); 01994 #endif 01995 01996 INLINE civector_slice &operator &=(const ivector &rv) 01997 #if(CXSC_INDEX_CHECK) 01998 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 01999 #else 02000 throw(); 02001 #endif 02002 02003 INLINE civector_slice &operator &=(const ivector_slice &sl2) 02004 #if(CXSC_INDEX_CHECK) 02005 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02006 #else 02007 throw(); 02008 #endif 02009 02010 INLINE civector_slice &operator *=(const imatrix &m) 02011 #if(CXSC_INDEX_CHECK) 02012 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM); 02013 #else 02014 throw(); 02015 #endif 02016 02017 INLINE civector_slice &operator *=(const imatrix_slice &m) 02018 #if(CXSC_INDEX_CHECK) 02019 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM); 02020 #else 02021 throw(); 02022 #endif 02023 //#else 02024 //#endif 02025 02026 civector_slice& operator+=(const srvector&); 02027 civector_slice& operator+=(const scvector&); 02028 civector_slice& operator+=(const sivector&); 02029 civector_slice& operator+=(const scivector&); 02030 civector_slice& operator-=(const srvector&); 02031 civector_slice& operator-=(const scvector&); 02032 civector_slice& operator-=(const sivector&); 02033 civector_slice& operator-=(const scivector&); 02034 civector_slice& operator|=(const srvector&); 02035 civector_slice& operator|=(const scvector&); 02036 civector_slice& operator|=(const sivector&); 02037 civector_slice& operator|=(const scivector&); 02038 civector_slice& operator&=(const sivector&); 02039 civector_slice& operator&=(const scivector&); 02040 civector_slice& operator+=(const srvector_slice&); 02041 civector_slice& operator+=(const scvector_slice&); 02042 civector_slice& operator+=(const sivector_slice&); 02043 civector_slice& operator+=(const scivector_slice&); 02044 civector_slice& operator-=(const srvector_slice&); 02045 civector_slice& operator-=(const scvector_slice&); 02046 civector_slice& operator-=(const sivector_slice&); 02047 civector_slice& operator-=(const scivector_slice&); 02048 civector_slice& operator|=(const srvector_slice&); 02049 civector_slice& operator|=(const scvector_slice&); 02050 civector_slice& operator|=(const sivector_slice&); 02051 civector_slice& operator|=(const scivector_slice&); 02052 civector_slice& operator&=(const sivector_slice&); 02053 civector_slice& operator&=(const scivector_slice&); 02054 02055 }; 02056 02057 //======================================================================= 02058 //======================== Vector Functions ============================= 02059 02061 INLINE civector _civector(const cinterval &r) throw(); 02062 // INLINE civector _civector(const cimatrix &m) throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ); 02063 // INLINE civector _civector(const cimatrix_slice &sl) throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ); 02065 INLINE civector _civector(const real &r) throw(); 02067 INLINE civector _civector(const rvector_slice &rs) throw(); 02069 INLINE civector _civector(const rvector &rs) throw(); 02070 // INLINE civector _civector(const rmatrix &m) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 02071 // INLINE civector _civector(const rmatrix_slice &sl) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 02073 INLINE civector _civector(const rmatrix_subv &rs) throw(); 02074 02076 INLINE civector &SetInf(civector &iv,const cvector &rv) 02077 #if(CXSC_INDEX_CHECK) 02078 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM); 02079 #else 02080 throw(); 02081 #endif 02082 02083 INLINE civector_slice &SetInf(civector_slice &iv,const cvector &rv) 02084 #if(CXSC_INDEX_CHECK) 02085 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM); 02086 #else 02087 throw(); 02088 #endif 02089 02090 INLINE civector &SetInf(civector &iv,const cvector_slice &rv) 02091 #if(CXSC_INDEX_CHECK) 02092 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM); 02093 #else 02094 throw(); 02095 #endif 02096 02097 INLINE civector_slice &SetInf(civector_slice &iv,const cvector_slice &rv) 02098 #if(CXSC_INDEX_CHECK) 02099 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM); 02100 #else 02101 throw(); 02102 #endif 02103 02104 INLINE civector &UncheckedSetInf(civector &iv,const cvector &rv) 02105 #if(CXSC_INDEX_CHECK) 02106 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM); 02107 #else 02108 throw(); 02109 #endif 02110 02111 INLINE civector_slice &UncheckedSetInf(civector_slice &iv,const cvector &rv) 02112 #if(CXSC_INDEX_CHECK) 02113 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM); 02114 #else 02115 throw(); 02116 #endif 02117 02118 INLINE civector &UncheckedSetInf(civector &iv,const cvector_slice &rv) 02119 #if(CXSC_INDEX_CHECK) 02120 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM); 02121 #else 02122 throw(); 02123 #endif 02124 02125 INLINE civector_slice &UncheckedSetInf(civector_slice &iv,const cvector_slice &rv) 02126 #if(CXSC_INDEX_CHECK) 02127 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM); 02128 #else 02129 throw(); 02130 #endif 02131 02133 INLINE civector &SetSup(civector &iv,const cvector &rv) 02134 #if(CXSC_INDEX_CHECK) 02135 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM); 02136 #else 02137 throw(); 02138 #endif 02139 02140 INLINE civector_slice &SetSup(civector_slice &iv,const cvector &rv) 02141 #if(CXSC_INDEX_CHECK) 02142 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM); 02143 #else 02144 throw(); 02145 #endif 02146 02147 INLINE civector &SetSup(civector &iv,const cvector_slice &rv) 02148 #if(CXSC_INDEX_CHECK) 02149 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM); 02150 #else 02151 throw(); 02152 #endif 02153 02154 INLINE civector_slice &SetSup(civector_slice &iv,const cvector_slice &rv) 02155 #if(CXSC_INDEX_CHECK) 02156 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM); 02157 #else 02158 throw(); 02159 #endif 02160 02161 INLINE civector &UncheckedSetSup(civector &iv,const cvector &rv) 02162 #if(CXSC_INDEX_CHECK) 02163 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM); 02164 #else 02165 throw(); 02166 #endif 02167 02168 INLINE civector_slice &UncheckedSetSup(civector_slice &iv,const cvector &rv) 02169 #if(CXSC_INDEX_CHECK) 02170 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM); 02171 #else 02172 throw(); 02173 #endif 02174 02175 INLINE civector &UncheckedSetSup(civector &iv,const cvector_slice &rv) 02176 #if(CXSC_INDEX_CHECK) 02177 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM); 02178 #else 02179 throw(); 02180 #endif 02181 02182 INLINE civector_slice &UncheckedSetSup(civector_slice &iv,const cvector_slice &rv) 02183 #if(CXSC_INDEX_CHECK) 02184 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM); 02185 #else 02186 throw(); 02187 #endif 02188 02190 INLINE civector &SetRe(civector &iv,const ivector &rv) 02191 #if(CXSC_INDEX_CHECK) 02192 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM); 02193 #else 02194 throw(); 02195 #endif 02196 02197 INLINE civector_slice &SetRe(civector_slice &iv,const ivector &rv) 02198 #if(CXSC_INDEX_CHECK) 02199 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM); 02200 #else 02201 throw(); 02202 #endif 02203 02204 INLINE civector &SetRe(civector &iv,const ivector_slice &rv) 02205 #if(CXSC_INDEX_CHECK) 02206 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM); 02207 #else 02208 throw(); 02209 #endif 02210 02211 INLINE civector_slice &SetRe(civector_slice &iv,const ivector_slice &rv) 02212 #if(CXSC_INDEX_CHECK) 02213 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM); 02214 #else 02215 throw(); 02216 #endif 02217 02219 INLINE civector &SetIm(civector &iv,const ivector &rv) 02220 #if(CXSC_INDEX_CHECK) 02221 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM); 02222 #else 02223 throw(); 02224 #endif 02225 02226 INLINE civector_slice &SetIm(civector_slice &iv,const ivector &rv) 02227 #if(CXSC_INDEX_CHECK) 02228 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM); 02229 #else 02230 throw(); 02231 #endif 02232 02233 INLINE civector &SetIm(civector &iv,const ivector_slice &rv) 02234 #if(CXSC_INDEX_CHECK) 02235 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM); 02236 #else 02237 throw(); 02238 #endif 02239 02240 INLINE civector_slice &SetIm(civector_slice &iv,const ivector_slice &rv) 02241 #if(CXSC_INDEX_CHECK) 02242 throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM); 02243 #else 02244 throw(); 02245 #endif 02246 02248 INLINE civector &SetSup(civector &iv,const complex &r) throw(); 02250 INLINE civector &SetInf(civector &iv,const complex &r) throw(); 02252 INLINE civector &UncheckedSetSup(civector &iv,const complex &r) throw(); 02254 INLINE civector &SetUncheckedInf(civector &iv,const complex &r) throw(); 02256 INLINE civector &SetRe(civector &iv,const interval &r) throw(); 02258 INLINE civector &SetIm(civector &iv,const interval &r) throw(); 02259 02261 INLINE civector_slice &SetSup(civector_slice &iv,const complex &r) throw(); 02263 INLINE civector_slice &SetInf(civector_slice &iv,const complex &r) throw(); 02265 INLINE civector_slice &UncheckedSetSup(civector_slice &iv,const complex &r) throw(); 02267 INLINE civector_slice &SetUncheckedInf(civector_slice &iv,const complex &r) throw(); 02269 INLINE civector_slice &SetRe(civector_slice &iv,const interval &r) throw(); 02271 INLINE civector_slice &SetIm(civector_slice &iv,const interval &r) throw(); 02272 02274 INLINE void Resize(civector &rv) throw(); 02276 INLINE void Resize(civector &rv, const int &len) 02277 #if(CXSC_INDEX_CHECK) 02278 throw(ERROR__WRONG_BOUNDARIES<civector>); 02279 #else 02280 throw(); 02281 #endif 02282 02283 INLINE void Resize(civector &rv, const int &lb, const int &ub) 02284 #if(CXSC_INDEX_CHECK) 02285 throw(ERROR__WRONG_BOUNDARIES<civector>); 02286 #else 02287 throw(); 02288 #endif 02289 02291 INLINE civector conj(const civector &rv) throw(); 02293 INLINE civector conj(const civector_slice &sl) throw(); 02294 02296 INLINE ivector abs(const civector &rv) throw(); 02298 INLINE ivector abs(const civector_slice &sl) throw(); 02300 INLINE cvector diam(const civector &v) throw(); 02302 INLINE cvector diam(const civector_slice &v) throw(); 02304 INLINE cvector mid(const civector &v) throw(); 02306 INLINE cvector mid(const civector_slice &v) throw(); 02308 INLINE cvector Inf(const civector &v) throw(); 02310 INLINE cvector Inf(const civector_slice &v) throw(); 02312 INLINE cvector Sup(const civector &v) throw(); 02314 INLINE cvector Sup(const civector_slice &v) throw(); 02316 INLINE rvector SupRe(const civector &v) throw(); 02318 INLINE rvector SupIm(const civector &v) throw(); 02320 INLINE rvector InfRe(const civector &v) throw(); 02322 INLINE rvector InfIm(const civector &v) throw(); 02324 INLINE rvector SupRe(const civector_slice &v) throw(); 02326 INLINE rvector SupIm(const civector_slice &v) throw(); 02328 INLINE rvector InfRe(const civector_slice &v) throw(); 02330 INLINE rvector InfIm(const civector_slice &v) throw(); 02332 INLINE bool operator !(const civector &rv) throw(); 02334 INLINE bool operator !(const civector_slice &sl) throw(); 02335 02336 //======================= Vector / Scalar =============================== 02337 02338 //----------------------------- cinterval --------------------------- 02339 02341 INLINE civector operator *(const civector &rv, const cinterval &s) throw(); 02343 INLINE civector operator *(const civector_slice &sl, const cinterval &s) throw(); 02345 INLINE civector operator *(const cinterval &s, const civector &rv) throw(); 02347 INLINE civector operator *(const cinterval &s, const civector_slice &sl) throw(); 02349 INLINE civector &operator *=(civector &rv,const cinterval &r) throw(); 02350 02352 INLINE civector operator /(const civector &rv, const cinterval &s) throw(); 02354 INLINE civector operator /(const civector_slice &sl, const cinterval &s) throw(); 02356 INLINE civector &operator /=(civector &rv,const cinterval &r) throw(); 02357 02358 //---------------------------- Real -------------------------------------- 02359 02361 INLINE civector operator *(const civector &rv, const real &s) throw(); 02363 INLINE civector operator *(const civector_slice &sl, const real &s) throw(); 02365 INLINE civector operator *(const real &s, const civector &rv) throw(); 02367 INLINE civector operator *(const real &s, const civector_slice &sl) throw(); 02369 INLINE civector &operator *=(civector &rv,const real &r) throw(); 02370 02372 INLINE civector operator /(const civector &rv, const real &s) throw(); 02374 INLINE civector operator /(const civector_slice &sl, const real &s) throw(); 02376 INLINE civector &operator /=(civector &rv,const real &r) throw(); 02377 02379 INLINE civector operator *(const rvector &rv, const cinterval &s) throw(); 02381 INLINE civector operator *(const rvector_slice &sl, const cinterval &s) throw(); 02383 INLINE civector operator *(const cinterval &s, const rvector &rv) throw(); 02385 INLINE civector operator *(const cinterval &s, const rvector_slice &sl) throw(); 02386 02388 INLINE civector operator /(const rvector &rv, const cinterval &s) throw(); 02390 INLINE civector operator /(const rvector_slice &sl, const cinterval &s) throw(); 02391 02392 //---------------------------- Complex -------------------------------------- 02393 02395 INLINE civector operator *(const civector &rv, const complex &s) throw(); 02397 INLINE civector operator *(const civector_slice &sl, const complex &s) throw(); 02399 INLINE civector operator *(const complex &s, const civector &rv) throw(); 02401 INLINE civector operator *(const complex &s, const civector_slice &sl) throw(); 02403 INLINE civector &operator *=(civector &rv,const complex &r) throw(); 02404 02406 INLINE civector operator /(const civector &rv, const complex &s) throw(); 02408 INLINE civector operator /(const civector_slice &sl, const complex &s) throw(); 02410 INLINE civector &operator /=(civector &rv,const complex &r) throw(); 02411 02413 INLINE civector operator *(const cvector &rv, const cinterval &s) throw(); 02415 INLINE civector operator *(const cvector_slice &sl, const cinterval &s) throw(); 02417 INLINE civector operator *(const cinterval &s, const cvector &rv) throw(); 02419 INLINE civector operator *(const cinterval &s, const cvector_slice &sl) throw(); 02420 02422 INLINE civector operator /(const cvector &rv, const cinterval &s) throw(); 02424 INLINE civector operator /(const cvector_slice &sl, const cinterval &s) throw(); 02425 02426 //---------------------------- interval -------------------------------------- 02427 02429 INLINE civector operator *(const civector &rv, const interval &s) throw(); 02431 INLINE civector operator *(const civector_slice &sl, const interval &s) throw(); 02433 INLINE civector operator *(const interval &s, const civector &rv) throw(); 02435 INLINE civector operator *(const interval &s, const civector_slice &sl) throw(); 02437 INLINE civector &operator *=(civector &rv,const interval &r) throw(); 02438 02440 INLINE civector operator /(const civector &rv, const interval &s) throw(); 02442 INLINE civector operator /(const civector_slice &sl, const interval &s) throw(); 02444 INLINE civector &operator /=(civector &rv,const interval &r) throw(); 02445 02447 INLINE civector operator *(const ivector &rv, const cinterval &s) throw(); 02449 INLINE civector operator *(const ivector_slice &sl, const cinterval &s) throw(); 02451 INLINE civector operator *(const cinterval &s, const ivector &rv) throw(); 02453 INLINE civector operator *(const cinterval &s, const ivector_slice &sl) throw(); 02454 02456 INLINE civector operator /(const ivector &rv, const cinterval &s) throw(); 02458 INLINE civector operator /(const ivector_slice &sl, const cinterval &s) throw(); 02459 02460 //======================= Vector / Vector =============================== 02461 02462 02464 INLINE std::ostream &operator <<(std::ostream &s, const civector &rv) throw(); 02466 INLINE std::ostream &operator <<(std::ostream &o, const civector_slice &sl) throw(); 02468 INLINE std::istream &operator >>(std::istream &s, civector &rv) throw(); 02470 INLINE std::istream &operator >>(std::istream &s, civector_slice &rv) throw(); 02471 02472 //----------------------- cinterval / cinterval --------------------------- 02473 02475 void accumulate(cidotprecision &dp, const cvector &); 02476 02478 void accumulate(cidotprecision &dp, const rvector &); 02479 02481 void accumulate(cidotprecision &dp, const civector &); 02482 02484 void accumulate(cidotprecision &dp, const ivector &); 02485 02486 02488 void accumulate(cidotprecision &dp, const civector & rv1, const civector &rv2) 02489 #if(CXSC_INDEX_CHECK) 02490 throw(OP_WITH_WRONG_DIM); 02491 #else 02492 throw(); 02493 #endif 02494 02495 void accumulate(cidotprecision &dp, const civector_slice & sl, const civector &rv) 02496 #if(CXSC_INDEX_CHECK) 02497 throw(OP_WITH_WRONG_DIM); 02498 #else 02499 throw(); 02500 #endif 02501 02502 void accumulate(cidotprecision &dp, const civector &rv, const civector_slice &sl) 02503 #if(CXSC_INDEX_CHECK) 02504 throw(OP_WITH_WRONG_DIM); 02505 #else 02506 throw(); 02507 #endif 02508 02509 void accumulate(cidotprecision &dp, const civector & rv1, const cimatrix_subv &rv2) 02510 #if(CXSC_INDEX_CHECK) 02511 throw(OP_WITH_WRONG_DIM); 02512 #else 02513 throw(); 02514 #endif 02515 02516 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const civector &rv2) 02517 #if(CXSC_INDEX_CHECK) 02518 throw(OP_WITH_WRONG_DIM); 02519 #else 02520 throw(); 02521 #endif 02522 02523 void accumulate(cidotprecision &dp, const civector_slice & sl1, const civector_slice &sl2) 02524 #if(CXSC_INDEX_CHECK) 02525 throw(OP_WITH_WRONG_DIM); 02526 #else 02527 throw(); 02528 #endif 02529 02530 void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const cvector &rv2) 02531 #if(CXSC_INDEX_CHECK) 02532 throw(OP_WITH_WRONG_DIM); 02533 #else 02534 throw(); 02535 #endif 02536 02537 void accumulate(cidotprecision &dp, const cvector & rv1, const imatrix_subv &rv2) 02538 #if(CXSC_INDEX_CHECK) 02539 throw(OP_WITH_WRONG_DIM); 02540 #else 02541 throw(); 02542 #endif 02543 02544 void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const cvector_slice &rv2) 02545 #if(CXSC_INDEX_CHECK) 02546 throw(OP_WITH_WRONG_DIM); 02547 #else 02548 throw(); 02549 #endif 02550 02551 void accumulate(cidotprecision &dp, const cvector_slice & rv1, const imatrix_subv &rv2) 02552 #if(CXSC_INDEX_CHECK) 02553 throw(OP_WITH_WRONG_DIM); 02554 #else 02555 throw(); 02556 #endif 02557 02559 INLINE cinterval operator *(const civector & rv1, const civector &rv2) 02560 #if(CXSC_INDEX_CHECK) 02561 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02562 #else 02563 throw(); 02564 #endif 02565 02566 INLINE cinterval operator *(const civector_slice &sl, const civector &rv) 02567 #if(CXSC_INDEX_CHECK) 02568 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02569 #else 02570 throw(); 02571 #endif 02572 02573 INLINE cinterval operator *(const civector &rv, const civector_slice &sl) 02574 #if(CXSC_INDEX_CHECK) 02575 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02576 #else 02577 throw(); 02578 #endif 02579 02580 INLINE cinterval operator *(const civector_slice & sl1, const civector_slice &sl2) 02581 #if(CXSC_INDEX_CHECK) 02582 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02583 #else 02584 throw(); 02585 #endif 02586 02588 INLINE const civector &operator +(const civector &rv) throw(); 02590 INLINE civector operator +(const civector_slice &sl) throw(); 02591 02593 INLINE civector operator +(const civector &rv1, const civector &rv2) 02594 #if(CXSC_INDEX_CHECK) 02595 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02596 #else 02597 throw(); 02598 #endif 02599 02600 INLINE civector operator +(const civector &rv, const civector_slice &sl) 02601 #if(CXSC_INDEX_CHECK) 02602 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02603 #else 02604 throw(); 02605 #endif 02606 02607 INLINE civector operator +(const civector_slice &sl, const civector &rv) 02608 #if(CXSC_INDEX_CHECK) 02609 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02610 #else 02611 throw(); 02612 #endif 02613 02614 INLINE civector operator +(const civector_slice &sl1, const civector_slice &sl2) 02615 #if(CXSC_INDEX_CHECK) 02616 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02617 #else 02618 throw(); 02619 #endif 02620 02621 INLINE civector & operator +=(civector &rv1, const civector &rv2) 02622 #if(CXSC_INDEX_CHECK) 02623 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02624 #else 02625 throw(); 02626 #endif 02627 02628 INLINE civector &operator +=(civector &rv, const civector_slice &sl) 02629 #if(CXSC_INDEX_CHECK) 02630 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02631 #else 02632 throw(); 02633 #endif 02634 02636 INLINE civector operator -(const civector &rv) throw(); 02638 INLINE civector operator -(const civector_slice &sl) throw(); 02640 INLINE civector operator -(const civector &rv1, const civector &rv2) 02641 #if(CXSC_INDEX_CHECK) 02642 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02643 #else 02644 throw(); 02645 #endif 02646 02647 INLINE civector operator -(const civector &rv, const civector_slice &sl) 02648 #if(CXSC_INDEX_CHECK) 02649 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02650 #else 02651 throw(); 02652 #endif 02653 02654 INLINE civector operator -(const civector_slice &sl, const civector &rv) 02655 #if(CXSC_INDEX_CHECK) 02656 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02657 #else 02658 throw(); 02659 #endif 02660 02661 INLINE civector operator -(const civector_slice &sl1, const civector_slice &sl2) 02662 #if(CXSC_INDEX_CHECK) 02663 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02664 #else 02665 throw(); 02666 #endif 02667 02668 INLINE civector & operator -=(civector &rv1, const civector &rv2) 02669 #if(CXSC_INDEX_CHECK) 02670 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02671 #else 02672 throw(); 02673 #endif 02674 02675 INLINE civector &operator -=(civector &rv, const civector_slice &sl) 02676 #if(CXSC_INDEX_CHECK) 02677 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02678 #else 02679 throw(); 02680 #endif 02681 02683 INLINE civector operator |(const civector &rv1, const civector &rv2) 02684 #if(CXSC_INDEX_CHECK) 02685 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02686 #else 02687 throw(); 02688 #endif 02689 02690 INLINE civector operator |(const civector &rv, const civector_slice &sl) 02691 #if(CXSC_INDEX_CHECK) 02692 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02693 #else 02694 throw(); 02695 #endif 02696 02697 INLINE civector operator |(const civector_slice &sl, const civector &rv) 02698 #if(CXSC_INDEX_CHECK) 02699 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02700 #else 02701 throw(); 02702 #endif 02703 02704 INLINE civector operator |(const civector_slice &sl1, const civector_slice &sl2) 02705 #if(CXSC_INDEX_CHECK) 02706 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02707 #else 02708 throw(); 02709 #endif 02710 02711 INLINE civector & operator |=(civector &rv1, const civector &rv2) 02712 #if(CXSC_INDEX_CHECK) 02713 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02714 #else 02715 throw(); 02716 #endif 02717 02718 INLINE civector &operator |=(civector &rv, const civector_slice &sl) 02719 #if(CXSC_INDEX_CHECK) 02720 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02721 #else 02722 throw(); 02723 #endif 02724 02726 INLINE civector operator &(const civector &rv1, const civector &rv2) 02727 #if(CXSC_INDEX_CHECK) 02728 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02729 #else 02730 throw(); 02731 #endif 02732 02733 INLINE civector operator &(const civector &rv, const civector_slice &sl) 02734 #if(CXSC_INDEX_CHECK) 02735 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02736 #else 02737 throw(); 02738 #endif 02739 02740 INLINE civector operator &(const civector_slice &sl, const civector &rv) 02741 #if(CXSC_INDEX_CHECK) 02742 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02743 #else 02744 throw(); 02745 #endif 02746 02747 INLINE civector operator &(const civector_slice &sl1, const civector_slice &sl2) 02748 #if(CXSC_INDEX_CHECK) 02749 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02750 #else 02751 throw(); 02752 #endif 02753 02754 INLINE civector & operator &=(civector &rv1, const civector &rv2) 02755 #if(CXSC_INDEX_CHECK) 02756 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02757 #else 02758 throw(); 02759 #endif 02760 02761 INLINE civector &operator &=(civector &rv, const civector_slice &sl) 02762 #if(CXSC_INDEX_CHECK) 02763 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02764 #else 02765 throw(); 02766 #endif 02767 02769 INLINE bool operator ==(const civector &rv1, const civector &rv2) throw(); 02771 INLINE bool operator ==(const civector_slice &sl1, const civector_slice &sl2) throw(); 02773 INLINE bool operator ==(const civector_slice &sl, const civector &rv) throw(); 02775 INLINE bool operator ==(const civector &rv, const civector_slice &sl) throw(); 02777 INLINE bool operator !=(const civector &rv1, const civector &rv2) throw(); 02779 INLINE bool operator !=(const civector_slice &sl1, const civector_slice &sl2) throw(); 02781 INLINE bool operator !=(const civector_slice &sl, const civector &rv) throw(); 02783 INLINE bool operator !=(const civector &rv, const civector_slice &sl) throw(); 02785 INLINE bool operator <(const civector &rv1, const civector &rv2) throw(); 02787 INLINE bool operator <(const civector_slice &sl1, const civector_slice &sl2) throw(); 02789 INLINE bool operator < (const civector_slice &sl, const civector &rv) throw(); 02791 INLINE bool operator < (const civector &rv, const civector_slice &sl) throw(); 02793 INLINE bool operator <=(const civector &rv1, const civector &rv2) throw(); 02795 INLINE bool operator <=(const civector_slice &sl1, const civector_slice &sl2) throw(); 02797 INLINE bool operator <=(const civector_slice &sl, const civector &rv) throw(); 02799 INLINE bool operator <=(const civector &rv, const civector_slice &sl) throw(); 02801 INLINE bool operator >(const civector &rv1, const civector &rv2) throw(); 02803 INLINE bool operator >(const civector_slice &sl1, const civector_slice &sl2) throw(); 02805 INLINE bool operator >(const civector_slice &sl, const civector &rv) throw(); 02807 INLINE bool operator >(const civector &rv, const civector_slice &sl) throw(); 02809 INLINE bool operator >=(const civector &rv1, const civector &rv2) throw(); 02811 INLINE bool operator >=(const civector_slice &sl1, const civector_slice &sl2) throw(); 02813 INLINE bool operator >=(const civector_slice &sl, const civector &rv) throw(); 02815 INLINE bool operator >=(const civector &rv, const civector_slice &sl) throw(); 02816 02817 //-------------------------------- cinterval / Real -------------------------------- 02818 02820 void accumulate(cidotprecision &dp, const rvector & rv1, const civector &rv2) 02821 #if(CXSC_INDEX_CHECK) 02822 throw(OP_WITH_WRONG_DIM); 02823 #else 02824 throw(); 02825 #endif 02826 02827 void accumulate(cidotprecision &dp, const civector & rv1, const rvector &rv2) 02828 #if(CXSC_INDEX_CHECK) 02829 throw(OP_WITH_WRONG_DIM); 02830 #else 02831 throw(); 02832 #endif 02833 02834 void accumulate(cidotprecision &dp, const rvector_slice & sl, const civector &rv) 02835 #if(CXSC_INDEX_CHECK) 02836 throw(OP_WITH_WRONG_DIM); 02837 #else 02838 throw(); 02839 #endif 02840 02841 void accumulate(cidotprecision &dp,const civector_slice &sl,const rvector &rv) 02842 #if(CXSC_INDEX_CHECK) 02843 throw(OP_WITH_WRONG_DIM); 02844 #else 02845 throw(); 02846 #endif 02847 02848 void accumulate(cidotprecision &dp, const rvector &rv, const civector_slice &sl) 02849 #if(CXSC_INDEX_CHECK) 02850 throw(OP_WITH_WRONG_DIM); 02851 #else 02852 throw(); 02853 #endif 02854 02855 void accumulate(cidotprecision &dp, const rvector & rv1, const cimatrix_subv &rv2) 02856 #if(CXSC_INDEX_CHECK) 02857 throw(OP_WITH_WRONG_DIM); 02858 #else 02859 throw(); 02860 #endif 02861 02862 void accumulate(cidotprecision &dp, const civector & rv1, const rmatrix_subv &rv2) 02863 #if(CXSC_INDEX_CHECK) 02864 throw(OP_WITH_WRONG_DIM); 02865 #else 02866 throw(); 02867 #endif 02868 02869 void accumulate(cidotprecision &dp,const civector &rv,const rvector_slice &sl) 02870 #if(CXSC_INDEX_CHECK) 02871 throw(OP_WITH_WRONG_DIM); 02872 #else 02873 throw(); 02874 #endif 02875 02876 void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const civector &rv2) 02877 #if(CXSC_INDEX_CHECK) 02878 throw(OP_WITH_WRONG_DIM); 02879 #else 02880 throw(); 02881 #endif 02882 02883 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const rvector &rv2) 02884 #if(CXSC_INDEX_CHECK) 02885 throw(OP_WITH_WRONG_DIM); 02886 #else 02887 throw(); 02888 #endif 02889 02890 void accumulate(cidotprecision &dp, const civector_slice & sl1, const rvector_slice &sl2) 02891 #if(CXSC_INDEX_CHECK) 02892 throw(OP_WITH_WRONG_DIM); 02893 #else 02894 throw(); 02895 #endif 02896 02897 void accumulate(cidotprecision &dp, const rvector_slice & sl1, const civector_slice &sl2) 02898 #if(CXSC_INDEX_CHECK) 02899 throw(OP_WITH_WRONG_DIM); 02900 #else 02901 throw(); 02902 #endif 02903 02905 INLINE cinterval operator *(const rvector & rv1, const civector &rv2) 02906 #if(CXSC_INDEX_CHECK) 02907 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02908 #else 02909 throw(); 02910 #endif 02911 02912 INLINE cinterval operator *(const rvector_slice &sl, const civector &rv) 02913 #if(CXSC_INDEX_CHECK) 02914 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02915 #else 02916 throw(); 02917 #endif 02918 02919 INLINE cinterval operator *(const rvector &rv, const civector_slice &sl) 02920 #if(CXSC_INDEX_CHECK) 02921 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02922 #else 02923 throw(); 02924 #endif 02925 02926 INLINE cinterval operator *(const rvector_slice & sl1, const civector_slice &sl2) 02927 #if(CXSC_INDEX_CHECK) 02928 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02929 #else 02930 throw(); 02931 #endif 02932 02934 INLINE cinterval operator *(const civector & rv1, const rvector &rv2) 02935 #if(CXSC_INDEX_CHECK) 02936 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02937 #else 02938 throw(); 02939 #endif 02940 02941 INLINE cinterval operator *(const civector_slice &sl, const rvector &rv) 02942 #if(CXSC_INDEX_CHECK) 02943 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02944 #else 02945 throw(); 02946 #endif 02947 02948 INLINE cinterval operator *(const civector &rv, const rvector_slice &sl) 02949 #if(CXSC_INDEX_CHECK) 02950 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02951 #else 02952 throw(); 02953 #endif 02954 02955 INLINE cinterval operator *(const civector_slice & sl1, const rvector_slice &sl2) 02956 #if(CXSC_INDEX_CHECK) 02957 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02958 #else 02959 throw(); 02960 #endif 02961 02963 INLINE civector operator +(const rvector &rv1, const civector &rv2) 02964 #if(CXSC_INDEX_CHECK) 02965 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02966 #else 02967 throw(); 02968 #endif 02969 02970 INLINE civector operator +(const rvector &rv, const civector_slice &sl) 02971 #if(CXSC_INDEX_CHECK) 02972 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02973 #else 02974 throw(); 02975 #endif 02976 02977 INLINE civector operator +(const rvector_slice &sl, const civector &rv) 02978 #if(CXSC_INDEX_CHECK) 02979 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02980 #else 02981 throw(); 02982 #endif 02983 02984 INLINE civector operator +(const rvector_slice &sl1, const civector_slice &sl2) 02985 #if(CXSC_INDEX_CHECK) 02986 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02987 #else 02988 throw(); 02989 #endif 02990 02992 INLINE civector operator +(const civector &rv1, const rvector &rv2) 02993 #if(CXSC_INDEX_CHECK) 02994 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 02995 #else 02996 throw(); 02997 #endif 02998 02999 INLINE civector operator +(const civector &rv, const rvector_slice &sl) 03000 #if(CXSC_INDEX_CHECK) 03001 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03002 #else 03003 throw(); 03004 #endif 03005 03006 INLINE civector operator +(const civector_slice &sl, const rvector &rv) 03007 #if(CXSC_INDEX_CHECK) 03008 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03009 #else 03010 throw(); 03011 #endif 03012 03013 INLINE civector operator +(const civector_slice &sl1, const rvector_slice &sl2) 03014 #if(CXSC_INDEX_CHECK) 03015 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03016 #else 03017 throw(); 03018 #endif 03019 03021 INLINE civector & operator +=(civector &rv1, const rvector &rv2) 03022 #if(CXSC_INDEX_CHECK) 03023 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03024 #else 03025 throw(); 03026 #endif 03027 03028 INLINE civector &operator +=(civector &rv, const rvector_slice &sl) 03029 #if(CXSC_INDEX_CHECK) 03030 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03031 #else 03032 throw(); 03033 #endif 03034 03036 INLINE civector operator -(const rvector &rv1, const civector &rv2) 03037 #if(CXSC_INDEX_CHECK) 03038 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03039 #else 03040 throw(); 03041 #endif 03042 03043 INLINE civector operator -(const rvector &rv, const civector_slice &sl) 03044 #if(CXSC_INDEX_CHECK) 03045 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03046 #else 03047 throw(); 03048 #endif 03049 03050 INLINE civector operator -(const rvector_slice &sl, const civector &rv) 03051 #if(CXSC_INDEX_CHECK) 03052 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03053 #else 03054 throw(); 03055 #endif 03056 03057 INLINE civector operator -(const rvector_slice &sl1, const civector_slice &sl2) 03058 #if(CXSC_INDEX_CHECK) 03059 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03060 #else 03061 throw(); 03062 #endif 03063 03065 INLINE civector operator -(const civector &rv1, const rvector &rv2) 03066 #if(CXSC_INDEX_CHECK) 03067 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03068 #else 03069 throw(); 03070 #endif 03071 03072 INLINE civector operator -(const civector &rv, const rvector_slice &sl) 03073 #if(CXSC_INDEX_CHECK) 03074 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03075 #else 03076 throw(); 03077 #endif 03078 03079 INLINE civector operator -(const civector_slice &sl, const rvector &rv) 03080 #if(CXSC_INDEX_CHECK) 03081 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03082 #else 03083 throw(); 03084 #endif 03085 03086 INLINE civector operator -(const civector_slice &sl1, const rvector_slice &sl2) 03087 #if(CXSC_INDEX_CHECK) 03088 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03089 #else 03090 throw(); 03091 #endif 03092 03094 INLINE civector & operator -=(civector &rv1, const rvector &rv2) 03095 #if(CXSC_INDEX_CHECK) 03096 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03097 #else 03098 throw(); 03099 #endif 03100 03101 INLINE civector &operator -=(civector &rv, const rvector_slice &sl) 03102 #if(CXSC_INDEX_CHECK) 03103 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03104 #else 03105 throw(); 03106 #endif 03107 03109 INLINE civector operator |(const rvector &rv1, const civector &rv2) 03110 #if(CXSC_INDEX_CHECK) 03111 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03112 #else 03113 throw(); 03114 #endif 03115 03116 INLINE civector operator |(const rvector &rv, const civector_slice &sl) 03117 #if(CXSC_INDEX_CHECK) 03118 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03119 #else 03120 throw(); 03121 #endif 03122 03123 INLINE civector operator |(const rvector_slice &sl, const civector &rv) 03124 #if(CXSC_INDEX_CHECK) 03125 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03126 #else 03127 throw(); 03128 #endif 03129 03130 INLINE civector operator |(const rvector_slice &sl1, const civector_slice &sl2) 03131 #if(CXSC_INDEX_CHECK) 03132 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03133 #else 03134 throw(); 03135 #endif 03136 03138 INLINE civector operator |(const civector &rv1, const rvector &rv2) 03139 #if(CXSC_INDEX_CHECK) 03140 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03141 #else 03142 throw(); 03143 #endif 03144 03145 INLINE civector operator |(const civector &rv, const rvector_slice &sl) 03146 #if(CXSC_INDEX_CHECK) 03147 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03148 #else 03149 throw(); 03150 #endif 03151 03152 INLINE civector operator |(const civector_slice &sl, const rvector &rv) 03153 #if(CXSC_INDEX_CHECK) 03154 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03155 #else 03156 throw(); 03157 #endif 03158 03159 INLINE civector operator |(const civector_slice &sl1, const rvector_slice &sl2) 03160 #if(CXSC_INDEX_CHECK) 03161 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03162 #else 03163 throw(); 03164 #endif 03165 03167 INLINE civector & operator |=(civector &rv1, const rvector &rv2) 03168 #if(CXSC_INDEX_CHECK) 03169 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03170 #else 03171 throw(); 03172 #endif 03173 03174 INLINE civector &operator |=(civector &rv, const rvector_slice &sl) 03175 #if(CXSC_INDEX_CHECK) 03176 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03177 #else 03178 throw(); 03179 #endif 03180 03182 INLINE civector operator &(const rvector &rv1, const civector &rv2) 03183 #if(CXSC_INDEX_CHECK) 03184 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03185 #else 03186 throw(); 03187 #endif 03188 03189 INLINE civector operator &(const rvector &rv, const civector_slice &sl) 03190 #if(CXSC_INDEX_CHECK) 03191 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03192 #else 03193 throw(); 03194 #endif 03195 03196 INLINE civector operator &(const rvector_slice &sl, const civector &rv) 03197 #if(CXSC_INDEX_CHECK) 03198 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03199 #else 03200 throw(); 03201 #endif 03202 03203 INLINE civector operator &(const rvector_slice &sl1, const civector_slice &sl2) 03204 #if(CXSC_INDEX_CHECK) 03205 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03206 #else 03207 throw(); 03208 #endif 03209 03211 INLINE civector operator &(const civector &rv1, const rvector &rv2) 03212 #if(CXSC_INDEX_CHECK) 03213 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03214 #else 03215 throw(); 03216 #endif 03217 03218 INLINE civector operator &(const civector &rv, const rvector_slice &sl) 03219 #if(CXSC_INDEX_CHECK) 03220 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03221 #else 03222 throw(); 03223 #endif 03224 03225 INLINE civector operator &(const civector_slice &sl, const rvector &rv) 03226 #if(CXSC_INDEX_CHECK) 03227 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03228 #else 03229 throw(); 03230 #endif 03231 03232 INLINE civector operator &(const civector_slice &sl1, const rvector_slice &sl2) 03233 #if(CXSC_INDEX_CHECK) 03234 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03235 #else 03236 throw(); 03237 #endif 03238 03240 INLINE civector & operator &=(civector &rv1, const rvector &rv2) 03241 #if(CXSC_INDEX_CHECK) 03242 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03243 #else 03244 throw(); 03245 #endif 03246 03247 INLINE civector &operator &=(civector &rv, const rvector_slice &sl) 03248 #if(CXSC_INDEX_CHECK) 03249 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03250 #else 03251 throw(); 03252 #endif 03253 //-------------------------------- cinterval / complex -------------------------------- 03254 03256 void accumulate(cidotprecision &dp, const cvector & rv1, const civector &rv2) 03257 #if(CXSC_INDEX_CHECK) 03258 throw(OP_WITH_WRONG_DIM); 03259 #else 03260 throw(); 03261 #endif 03262 03263 void accumulate(cidotprecision &dp, const civector & rv1, const cvector &rv2) 03264 #if(CXSC_INDEX_CHECK) 03265 throw(OP_WITH_WRONG_DIM); 03266 #else 03267 throw(); 03268 #endif 03269 03270 void accumulate(cidotprecision &dp, const cvector_slice & sl, const civector &rv) 03271 #if(CXSC_INDEX_CHECK) 03272 throw(OP_WITH_WRONG_DIM); 03273 #else 03274 throw(); 03275 #endif 03276 03277 void accumulate(cidotprecision &dp,const civector_slice &sl,const cvector &rv) 03278 #if(CXSC_INDEX_CHECK) 03279 throw(OP_WITH_WRONG_DIM); 03280 #else 03281 throw(); 03282 #endif 03283 03284 void accumulate(cidotprecision &dp, const cvector &rv, const civector_slice &sl) 03285 #if(CXSC_INDEX_CHECK) 03286 throw(OP_WITH_WRONG_DIM); 03287 #else 03288 throw(); 03289 #endif 03290 03291 void accumulate(cidotprecision &dp, const cvector & rv1, const cimatrix_subv &rv2) 03292 #if(CXSC_INDEX_CHECK) 03293 throw(OP_WITH_WRONG_DIM); 03294 #else 03295 throw(); 03296 #endif 03297 03298 void accumulate(cidotprecision &dp, const civector & rv1, const cmatrix_subv &rv2) 03299 #if(CXSC_INDEX_CHECK) 03300 throw(OP_WITH_WRONG_DIM); 03301 #else 03302 throw(); 03303 #endif 03304 03305 void accumulate(cidotprecision &dp,const civector &rv,const cvector_slice &sl) 03306 #if(CXSC_INDEX_CHECK) 03307 throw(OP_WITH_WRONG_DIM); 03308 #else 03309 throw(); 03310 #endif 03311 03312 void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const civector &rv2) 03313 #if(CXSC_INDEX_CHECK) 03314 throw(OP_WITH_WRONG_DIM); 03315 #else 03316 throw(); 03317 #endif 03318 03319 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const cvector &rv2) 03320 #if(CXSC_INDEX_CHECK) 03321 throw(OP_WITH_WRONG_DIM); 03322 #else 03323 throw(); 03324 #endif 03325 03326 void accumulate(cidotprecision &dp, const civector_slice & sl1, const cvector_slice &sl2) 03327 #if(CXSC_INDEX_CHECK) 03328 throw(OP_WITH_WRONG_DIM); 03329 #else 03330 throw(); 03331 #endif 03332 03333 void accumulate(cidotprecision &dp, const cvector_slice & sl1, const civector_slice &sl2) 03334 #if(CXSC_INDEX_CHECK) 03335 throw(OP_WITH_WRONG_DIM); 03336 #else 03337 throw(); 03338 #endif 03339 03340 03341 03342 03344 INLINE cinterval operator *(const cvector & rv1, const civector &rv2) 03345 #if(CXSC_INDEX_CHECK) 03346 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03347 #else 03348 throw(); 03349 #endif 03350 03351 INLINE cinterval operator *(const cvector_slice &sl, const civector &rv) 03352 #if(CXSC_INDEX_CHECK) 03353 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03354 #else 03355 throw(); 03356 #endif 03357 03358 INLINE cinterval operator *(const cvector &rv, const civector_slice &sl) 03359 #if(CXSC_INDEX_CHECK) 03360 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03361 #else 03362 throw(); 03363 #endif 03364 03365 INLINE cinterval operator *(const cvector_slice & sl1, const civector_slice &sl2) 03366 #if(CXSC_INDEX_CHECK) 03367 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03368 #else 03369 throw(); 03370 #endif 03371 03373 INLINE cinterval operator *(const civector & rv1, const cvector &rv2) 03374 #if(CXSC_INDEX_CHECK) 03375 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03376 #else 03377 throw(); 03378 #endif 03379 03380 INLINE cinterval operator *(const civector_slice &sl, const cvector &rv) 03381 #if(CXSC_INDEX_CHECK) 03382 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03383 #else 03384 throw(); 03385 #endif 03386 03387 INLINE cinterval operator *(const civector &rv, const cvector_slice &sl) 03388 #if(CXSC_INDEX_CHECK) 03389 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03390 #else 03391 throw(); 03392 #endif 03393 03394 INLINE cinterval operator *(const civector_slice & sl1, const cvector_slice &sl2) 03395 #if(CXSC_INDEX_CHECK) 03396 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03397 #else 03398 throw(); 03399 #endif 03400 03402 INLINE civector operator +(const cvector &rv1, const civector &rv2) 03403 #if(CXSC_INDEX_CHECK) 03404 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03405 #else 03406 throw(); 03407 #endif 03408 03409 INLINE civector operator +(const cvector &rv, const civector_slice &sl) 03410 #if(CXSC_INDEX_CHECK) 03411 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03412 #else 03413 throw(); 03414 #endif 03415 03416 INLINE civector operator +(const cvector_slice &sl, const civector &rv) 03417 #if(CXSC_INDEX_CHECK) 03418 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03419 #else 03420 throw(); 03421 #endif 03422 03423 INLINE civector operator +(const cvector_slice &sl1, const civector_slice &sl2) 03424 #if(CXSC_INDEX_CHECK) 03425 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03426 #else 03427 throw(); 03428 #endif 03429 03431 INLINE civector operator +(const civector &rv1, const cvector &rv2) 03432 #if(CXSC_INDEX_CHECK) 03433 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03434 #else 03435 throw(); 03436 #endif 03437 03438 INLINE civector operator +(const civector &rv, const cvector_slice &sl) 03439 #if(CXSC_INDEX_CHECK) 03440 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03441 #else 03442 throw(); 03443 #endif 03444 03445 INLINE civector operator +(const civector_slice &sl, const cvector &rv) 03446 #if(CXSC_INDEX_CHECK) 03447 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03448 #else 03449 throw(); 03450 #endif 03451 03452 INLINE civector operator +(const civector_slice &sl1, const cvector_slice &sl2) 03453 #if(CXSC_INDEX_CHECK) 03454 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03455 #else 03456 throw(); 03457 #endif 03458 03460 INLINE civector & operator +=(civector &rv1, const cvector &rv2) 03461 #if(CXSC_INDEX_CHECK) 03462 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03463 #else 03464 throw(); 03465 #endif 03466 03467 INLINE civector &operator +=(civector &rv, const cvector_slice &sl) 03468 #if(CXSC_INDEX_CHECK) 03469 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03470 #else 03471 throw(); 03472 #endif 03473 03475 INLINE civector operator -(const cvector &rv1, const civector &rv2) 03476 #if(CXSC_INDEX_CHECK) 03477 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03478 #else 03479 throw(); 03480 #endif 03481 03482 INLINE civector operator -(const cvector &rv, const civector_slice &sl) 03483 #if(CXSC_INDEX_CHECK) 03484 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03485 #else 03486 throw(); 03487 #endif 03488 03489 INLINE civector operator -(const cvector_slice &sl, const civector &rv) 03490 #if(CXSC_INDEX_CHECK) 03491 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03492 #else 03493 throw(); 03494 #endif 03495 03496 INLINE civector operator -(const cvector_slice &sl1, const civector_slice &sl2) 03497 #if(CXSC_INDEX_CHECK) 03498 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03499 #else 03500 throw(); 03501 #endif 03502 03504 INLINE civector operator -(const civector &rv1, const cvector &rv2) 03505 #if(CXSC_INDEX_CHECK) 03506 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03507 #else 03508 throw(); 03509 #endif 03510 03511 INLINE civector operator -(const civector &rv, const cvector_slice &sl) 03512 #if(CXSC_INDEX_CHECK) 03513 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03514 #else 03515 throw(); 03516 #endif 03517 03518 INLINE civector operator -(const civector_slice &sl, const cvector &rv) 03519 #if(CXSC_INDEX_CHECK) 03520 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03521 #else 03522 throw(); 03523 #endif 03524 03525 INLINE civector operator -(const civector_slice &sl1, const cvector_slice &sl2) 03526 #if(CXSC_INDEX_CHECK) 03527 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03528 #else 03529 throw(); 03530 #endif 03531 03533 INLINE civector & operator -=(civector &rv1, const cvector &rv2) 03534 #if(CXSC_INDEX_CHECK) 03535 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03536 #else 03537 throw(); 03538 #endif 03539 03540 INLINE civector &operator -=(civector &rv, const cvector_slice &sl) 03541 #if(CXSC_INDEX_CHECK) 03542 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03543 #else 03544 throw(); 03545 #endif 03546 03548 INLINE civector operator |(const cvector &rv1, const civector &rv2) 03549 #if(CXSC_INDEX_CHECK) 03550 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03551 #else 03552 throw(); 03553 #endif 03554 03555 INLINE civector operator |(const cvector &rv, const civector_slice &sl) 03556 #if(CXSC_INDEX_CHECK) 03557 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03558 #else 03559 throw(); 03560 #endif 03561 03562 INLINE civector operator |(const cvector_slice &sl, const civector &rv) 03563 #if(CXSC_INDEX_CHECK) 03564 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03565 #else 03566 throw(); 03567 #endif 03568 03569 INLINE civector operator |(const cvector_slice &sl1, const civector_slice &sl2) 03570 #if(CXSC_INDEX_CHECK) 03571 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03572 #else 03573 throw(); 03574 #endif 03575 03577 INLINE civector operator |(const civector &rv1, const cvector &rv2) 03578 #if(CXSC_INDEX_CHECK) 03579 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03580 #else 03581 throw(); 03582 #endif 03583 03584 INLINE civector operator |(const civector &rv, const cvector_slice &sl) 03585 #if(CXSC_INDEX_CHECK) 03586 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03587 #else 03588 throw(); 03589 #endif 03590 03591 INLINE civector operator |(const civector_slice &sl, const cvector &rv) 03592 #if(CXSC_INDEX_CHECK) 03593 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03594 #else 03595 throw(); 03596 #endif 03597 03598 INLINE civector operator |(const civector_slice &sl1, const cvector_slice &sl2) 03599 #if(CXSC_INDEX_CHECK) 03600 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03601 #else 03602 throw(); 03603 #endif 03604 03606 INLINE civector & operator |=(civector &rv1, const cvector &rv2) 03607 #if(CXSC_INDEX_CHECK) 03608 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03609 #else 03610 throw(); 03611 #endif 03612 03613 INLINE civector &operator |=(civector &rv, const cvector_slice &sl) 03614 #if(CXSC_INDEX_CHECK) 03615 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03616 #else 03617 throw(); 03618 #endif 03619 03621 INLINE civector operator &(const cvector &rv1, const civector &rv2) 03622 #if(CXSC_INDEX_CHECK) 03623 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03624 #else 03625 throw(); 03626 #endif 03627 03628 INLINE civector operator &(const cvector &rv, const civector_slice &sl) 03629 #if(CXSC_INDEX_CHECK) 03630 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03631 #else 03632 throw(); 03633 #endif 03634 03635 INLINE civector operator &(const cvector_slice &sl, const civector &rv) 03636 #if(CXSC_INDEX_CHECK) 03637 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03638 #else 03639 throw(); 03640 #endif 03641 03642 INLINE civector operator &(const cvector_slice &sl1, const civector_slice &sl2) 03643 #if(CXSC_INDEX_CHECK) 03644 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03645 #else 03646 throw(); 03647 #endif 03648 03650 INLINE civector operator &(const civector &rv1, const cvector &rv2) 03651 #if(CXSC_INDEX_CHECK) 03652 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03653 #else 03654 throw(); 03655 #endif 03656 03657 INLINE civector operator &(const civector &rv, const cvector_slice &sl) 03658 #if(CXSC_INDEX_CHECK) 03659 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03660 #else 03661 throw(); 03662 #endif 03663 03664 INLINE civector operator &(const civector_slice &sl, const cvector &rv) 03665 #if(CXSC_INDEX_CHECK) 03666 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03667 #else 03668 throw(); 03669 #endif 03670 03671 INLINE civector operator &(const civector_slice &sl1, const cvector_slice &sl2) 03672 #if(CXSC_INDEX_CHECK) 03673 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03674 #else 03675 throw(); 03676 #endif 03677 03679 INLINE civector & operator &=(civector &rv1, const cvector &rv2) 03680 #if(CXSC_INDEX_CHECK) 03681 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03682 #else 03683 throw(); 03684 #endif 03685 03686 INLINE civector &operator &=(civector &rv, const cvector_slice &sl) 03687 #if(CXSC_INDEX_CHECK) 03688 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03689 #else 03690 throw(); 03691 #endif 03692 03693 //-------------------------------- cinterval / interval -------------------------------- 03694 03696 void accumulate(cidotprecision &dp, const ivector & rv1, const civector &rv2) 03697 #if(CXSC_INDEX_CHECK) 03698 throw(OP_WITH_WRONG_DIM); 03699 #else 03700 throw(); 03701 #endif 03702 03703 void accumulate(cidotprecision &dp, const civector & rv1, const ivector &rv2) 03704 #if(CXSC_INDEX_CHECK) 03705 throw(OP_WITH_WRONG_DIM); 03706 #else 03707 throw(); 03708 #endif 03709 03710 void accumulate(cidotprecision &dp, const ivector_slice & sl, const civector &rv) 03711 #if(CXSC_INDEX_CHECK) 03712 throw(OP_WITH_WRONG_DIM); 03713 #else 03714 throw(); 03715 #endif 03716 03717 void accumulate(cidotprecision &dp,const civector_slice &sl,const ivector &rv) 03718 #if(CXSC_INDEX_CHECK) 03719 throw(OP_WITH_WRONG_DIM); 03720 #else 03721 throw(); 03722 #endif 03723 03724 void accumulate(cidotprecision &dp, const ivector &rv, const civector_slice &sl) 03725 #if(CXSC_INDEX_CHECK) 03726 throw(OP_WITH_WRONG_DIM); 03727 #else 03728 throw(); 03729 #endif 03730 03731 void accumulate(cidotprecision &dp, const ivector & rv1, const cimatrix_subv &rv2) 03732 #if(CXSC_INDEX_CHECK) 03733 throw(OP_WITH_WRONG_DIM); 03734 #else 03735 throw(); 03736 #endif 03737 03738 void accumulate(cidotprecision &dp, const civector & rv1, const imatrix_subv &rv2) 03739 #if(CXSC_INDEX_CHECK) 03740 throw(OP_WITH_WRONG_DIM); 03741 #else 03742 throw(); 03743 #endif 03744 03745 void accumulate(cidotprecision &dp,const civector &rv,const ivector_slice &sl) 03746 #if(CXSC_INDEX_CHECK) 03747 throw(OP_WITH_WRONG_DIM); 03748 #else 03749 throw(); 03750 #endif 03751 03752 void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const civector &rv2) 03753 #if(CXSC_INDEX_CHECK) 03754 throw(OP_WITH_WRONG_DIM); 03755 #else 03756 throw(); 03757 #endif 03758 03759 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const ivector &rv2) 03760 #if(CXSC_INDEX_CHECK) 03761 throw(OP_WITH_WRONG_DIM); 03762 #else 03763 throw(); 03764 #endif 03765 03766 void accumulate(cidotprecision &dp, const civector_slice & sl1, const ivector_slice &sl2) 03767 #if(CXSC_INDEX_CHECK) 03768 throw(OP_WITH_WRONG_DIM); 03769 #else 03770 throw(); 03771 #endif 03772 03773 void accumulate(cidotprecision &dp, const ivector_slice & sl1, const civector_slice &sl2) 03774 #if(CXSC_INDEX_CHECK) 03775 throw(OP_WITH_WRONG_DIM); 03776 #else 03777 throw(); 03778 #endif 03779 03780 void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const civector &rv2) 03781 #if(CXSC_INDEX_CHECK) 03782 throw(OP_WITH_WRONG_DIM); 03783 #else 03784 throw(); 03785 #endif 03786 03787 void accumulate(cidotprecision &dp, const civector & rv1, const cmatrix_subv &rv2) 03788 #if(CXSC_INDEX_CHECK) 03789 throw(OP_WITH_WRONG_DIM); 03790 #else 03791 throw(); 03792 #endif 03793 03794 void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const civector_slice &rv2) 03795 #if(CXSC_INDEX_CHECK) 03796 throw(OP_WITH_WRONG_DIM); 03797 #else 03798 throw(); 03799 #endif 03800 03801 void accumulate(cidotprecision &dp, const civector_slice & rv1, const cmatrix_subv &rv2) 03802 #if(CXSC_INDEX_CHECK) 03803 throw(OP_WITH_WRONG_DIM); 03804 #else 03805 throw(); 03806 #endif 03807 03809 void accumulate(cidotprecision &dp, const civector_slice & sl1, const rmatrix_subv &sl2) 03810 #if(CXSC_INDEX_CHECK) 03811 throw(OP_WITH_WRONG_DIM); 03812 #else 03813 throw(); 03814 #endif 03815 03816 void accumulate(cidotprecision &dp, const rmatrix_subv & sl1, const civector_slice &sl2) 03817 #if(CXSC_INDEX_CHECK) 03818 throw(OP_WITH_WRONG_DIM); 03819 #else 03820 throw(); 03821 #endif 03822 03824 INLINE cinterval operator *(const ivector & rv1, const civector &rv2) 03825 #if(CXSC_INDEX_CHECK) 03826 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03827 #else 03828 throw(); 03829 #endif 03830 03831 INLINE cinterval operator *(const ivector_slice &sl, const civector &rv) 03832 #if(CXSC_INDEX_CHECK) 03833 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03834 #else 03835 throw(); 03836 #endif 03837 03838 INLINE cinterval operator *(const ivector &rv, const civector_slice &sl) 03839 #if(CXSC_INDEX_CHECK) 03840 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03841 #else 03842 throw(); 03843 #endif 03844 03845 INLINE cinterval operator *(const ivector_slice & sl1, const civector_slice &sl2) 03846 #if(CXSC_INDEX_CHECK) 03847 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03848 #else 03849 throw(); 03850 #endif 03851 03853 INLINE cinterval operator *(const civector & rv1, const ivector &rv2) 03854 #if(CXSC_INDEX_CHECK) 03855 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03856 #else 03857 throw(); 03858 #endif 03859 03860 INLINE cinterval operator *(const civector_slice &sl, const ivector &rv) 03861 #if(CXSC_INDEX_CHECK) 03862 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03863 #else 03864 throw(); 03865 #endif 03866 03867 INLINE cinterval operator *(const civector &rv, const ivector_slice &sl) 03868 #if(CXSC_INDEX_CHECK) 03869 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03870 #else 03871 throw(); 03872 #endif 03873 03874 INLINE cinterval operator *(const civector_slice & sl1, const ivector_slice &sl2) 03875 #if(CXSC_INDEX_CHECK) 03876 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03877 #else 03878 throw(); 03879 #endif 03880 03882 INLINE civector operator +(const ivector &rv1, const civector &rv2) 03883 #if(CXSC_INDEX_CHECK) 03884 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03885 #else 03886 throw(); 03887 #endif 03888 03889 INLINE civector operator +(const ivector &rv, const civector_slice &sl) 03890 #if(CXSC_INDEX_CHECK) 03891 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03892 #else 03893 throw(); 03894 #endif 03895 03896 INLINE civector operator +(const ivector_slice &sl, const civector &rv) 03897 #if(CXSC_INDEX_CHECK) 03898 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03899 #else 03900 throw(); 03901 #endif 03902 03903 INLINE civector operator +(const ivector_slice &sl1, const civector_slice &sl2) 03904 #if(CXSC_INDEX_CHECK) 03905 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03906 #else 03907 throw(); 03908 #endif 03909 03911 INLINE civector operator +(const civector &rv1, const ivector &rv2) 03912 #if(CXSC_INDEX_CHECK) 03913 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03914 #else 03915 throw(); 03916 #endif 03917 03918 INLINE civector operator +(const civector &rv, const ivector_slice &sl) 03919 #if(CXSC_INDEX_CHECK) 03920 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03921 #else 03922 throw(); 03923 #endif 03924 03925 INLINE civector operator +(const civector_slice &sl, const ivector &rv) 03926 #if(CXSC_INDEX_CHECK) 03927 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03928 #else 03929 throw(); 03930 #endif 03931 03932 INLINE civector operator +(const civector_slice &sl1, const ivector_slice &sl2) 03933 #if(CXSC_INDEX_CHECK) 03934 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03935 #else 03936 throw(); 03937 #endif 03938 03940 INLINE civector & operator +=(civector &rv1, const ivector &rv2) 03941 #if(CXSC_INDEX_CHECK) 03942 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03943 #else 03944 throw(); 03945 #endif 03946 03947 INLINE civector &operator +=(civector &rv, const ivector_slice &sl) 03948 #if(CXSC_INDEX_CHECK) 03949 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03950 #else 03951 throw(); 03952 #endif 03953 03955 INLINE civector operator -(const ivector &rv1, const civector &rv2) 03956 #if(CXSC_INDEX_CHECK) 03957 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03958 #else 03959 throw(); 03960 #endif 03961 03962 INLINE civector operator -(const ivector &rv, const civector_slice &sl) 03963 #if(CXSC_INDEX_CHECK) 03964 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03965 #else 03966 throw(); 03967 #endif 03968 03969 INLINE civector operator -(const ivector_slice &sl, const civector &rv) 03970 #if(CXSC_INDEX_CHECK) 03971 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03972 #else 03973 throw(); 03974 #endif 03975 03976 INLINE civector operator -(const ivector_slice &sl1, const civector_slice &sl2) 03977 #if(CXSC_INDEX_CHECK) 03978 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03979 #else 03980 throw(); 03981 #endif 03982 03984 INLINE civector operator -(const civector &rv1, const ivector &rv2) 03985 #if(CXSC_INDEX_CHECK) 03986 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03987 #else 03988 throw(); 03989 #endif 03990 03991 INLINE civector operator -(const civector &rv, const ivector_slice &sl) 03992 #if(CXSC_INDEX_CHECK) 03993 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 03994 #else 03995 throw(); 03996 #endif 03997 03998 INLINE civector operator -(const civector_slice &sl, const ivector &rv) 03999 #if(CXSC_INDEX_CHECK) 04000 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04001 #else 04002 throw(); 04003 #endif 04004 04005 INLINE civector operator -(const civector_slice &sl1, const ivector_slice &sl2) 04006 #if(CXSC_INDEX_CHECK) 04007 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04008 #else 04009 throw(); 04010 #endif 04011 04013 INLINE civector & operator -=(civector &rv1, const ivector &rv2) 04014 #if(CXSC_INDEX_CHECK) 04015 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04016 #else 04017 throw(); 04018 #endif 04019 04020 INLINE civector &operator -=(civector &rv, const ivector_slice &sl) 04021 #if(CXSC_INDEX_CHECK) 04022 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04023 #else 04024 throw(); 04025 #endif 04026 04028 INLINE civector operator |(const ivector &rv1, const civector &rv2) 04029 #if(CXSC_INDEX_CHECK) 04030 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04031 #else 04032 throw(); 04033 #endif 04034 04035 INLINE civector operator |(const ivector &rv, const civector_slice &sl) 04036 #if(CXSC_INDEX_CHECK) 04037 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04038 #else 04039 throw(); 04040 #endif 04041 04042 INLINE civector operator |(const ivector_slice &sl, const civector &rv) 04043 #if(CXSC_INDEX_CHECK) 04044 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04045 #else 04046 throw(); 04047 #endif 04048 04049 INLINE civector operator |(const ivector_slice &sl1, const civector_slice &sl2) 04050 #if(CXSC_INDEX_CHECK) 04051 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04052 #else 04053 throw(); 04054 #endif 04055 04057 INLINE civector operator |(const civector &rv1, const ivector &rv2) 04058 #if(CXSC_INDEX_CHECK) 04059 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04060 #else 04061 throw(); 04062 #endif 04063 04064 INLINE civector operator |(const civector &rv, const ivector_slice &sl) 04065 #if(CXSC_INDEX_CHECK) 04066 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04067 #else 04068 throw(); 04069 #endif 04070 04071 INLINE civector operator |(const civector_slice &sl, const ivector &rv) 04072 #if(CXSC_INDEX_CHECK) 04073 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04074 #else 04075 throw(); 04076 #endif 04077 04078 INLINE civector operator |(const civector_slice &sl1, const ivector_slice &sl2) 04079 #if(CXSC_INDEX_CHECK) 04080 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04081 #else 04082 throw(); 04083 #endif 04084 04086 INLINE civector & operator |=(civector &rv1, const ivector &rv2) 04087 #if(CXSC_INDEX_CHECK) 04088 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04089 #else 04090 throw(); 04091 #endif 04092 04093 INLINE civector &operator |=(civector &rv, const ivector_slice &sl) 04094 #if(CXSC_INDEX_CHECK) 04095 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04096 #else 04097 throw(); 04098 #endif 04099 04101 INLINE civector operator &(const ivector &rv1, const civector &rv2) 04102 #if(CXSC_INDEX_CHECK) 04103 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04104 #else 04105 throw(); 04106 #endif 04107 04108 INLINE civector operator &(const ivector &rv, const civector_slice &sl) 04109 #if(CXSC_INDEX_CHECK) 04110 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04111 #else 04112 throw(); 04113 #endif 04114 04115 INLINE civector operator &(const ivector_slice &sl, const civector &rv) 04116 #if(CXSC_INDEX_CHECK) 04117 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04118 #else 04119 throw(); 04120 #endif 04121 04122 INLINE civector operator &(const ivector_slice &sl1, const civector_slice &sl2) 04123 #if(CXSC_INDEX_CHECK) 04124 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04125 #else 04126 throw(); 04127 #endif 04128 04130 INLINE civector operator &(const civector &rv1, const ivector &rv2) 04131 #if(CXSC_INDEX_CHECK) 04132 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04133 #else 04134 throw(); 04135 #endif 04136 04137 INLINE civector operator &(const civector &rv, const ivector_slice &sl) 04138 #if(CXSC_INDEX_CHECK) 04139 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04140 #else 04141 throw(); 04142 #endif 04143 04144 INLINE civector operator &(const civector_slice &sl, const ivector &rv) 04145 #if(CXSC_INDEX_CHECK) 04146 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04147 #else 04148 throw(); 04149 #endif 04150 04151 INLINE civector operator &(const civector_slice &sl1, const ivector_slice &sl2) 04152 #if(CXSC_INDEX_CHECK) 04153 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04154 #else 04155 throw(); 04156 #endif 04157 04159 INLINE civector & operator &=(civector &rv1, const ivector &rv2) 04160 #if(CXSC_INDEX_CHECK) 04161 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04162 #else 04163 throw(); 04164 #endif 04165 04166 INLINE civector &operator &=(civector &rv, const ivector_slice &sl) 04167 #if(CXSC_INDEX_CHECK) 04168 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04169 #else 04170 throw(); 04171 #endif 04172 04173 //------------- real x complex ------------------------ 04175 INLINE civector operator |(const rvector &rv1, const cvector &rv2) 04176 #if(CXSC_INDEX_CHECK) 04177 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04178 #else 04179 throw(); 04180 #endif 04181 04182 INLINE civector operator |(const cvector &rv1, const rvector &rv2) 04183 #if(CXSC_INDEX_CHECK) 04184 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04185 #else 04186 throw(); 04187 #endif 04188 04189 INLINE civector operator |(const cvector &rv, const rvector_slice &sl) 04190 #if(CXSC_INDEX_CHECK) 04191 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04192 #else 04193 throw(); 04194 #endif 04195 04196 INLINE civector operator |(const rvector_slice &sl,const cvector &rv) 04197 #if(CXSC_INDEX_CHECK) 04198 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04199 #else 04200 throw(); 04201 #endif 04202 04203 INLINE civector operator |(const cvector_slice &sl, const rvector &rv) 04204 #if(CXSC_INDEX_CHECK) 04205 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04206 #else 04207 throw(); 04208 #endif 04209 04210 INLINE civector operator |(const rvector &rv,const cvector_slice &sl) 04211 #if(CXSC_INDEX_CHECK) 04212 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04213 #else 04214 throw(); 04215 #endif 04216 04217 INLINE civector operator |(const cvector_slice &sl1, const rvector_slice &sl2) 04218 #if(CXSC_INDEX_CHECK) 04219 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04220 #else 04221 throw(); 04222 #endif 04223 04224 INLINE civector operator |(const rvector_slice &sl1, const cvector_slice &sl2) 04225 #if(CXSC_INDEX_CHECK) 04226 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04227 #else 04228 throw(); 04229 #endif 04230 04231 //------------- complex x complex ------------------------ 04233 INLINE civector operator |(const cvector &rv1, const cvector &rv2) 04234 #if(CXSC_INDEX_CHECK) 04235 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04236 #else 04237 throw(); 04238 #endif 04239 04240 INLINE civector operator |(const cvector_slice &sl, const cvector &rv) 04241 #if(CXSC_INDEX_CHECK) 04242 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04243 #else 04244 throw(); 04245 #endif 04246 04247 INLINE civector operator |(const cvector &rv,const cvector_slice &sl) 04248 #if(CXSC_INDEX_CHECK) 04249 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04250 #else 04251 throw(); 04252 #endif 04253 04254 INLINE civector operator |(const cvector_slice &sl1, const cvector_slice &sl2) 04255 #if(CXSC_INDEX_CHECK) 04256 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04257 #else 04258 throw(); 04259 #endif 04260 04261 //-------------------------------- interval / complex -------------------------------- 04262 04263 // multiplication in iveccvec.hpp 04264 04266 INLINE civector operator +(const cvector &rv1, const ivector &rv2) 04267 #if(CXSC_INDEX_CHECK) 04268 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04269 #else 04270 throw(); 04271 #endif 04272 04273 INLINE civector operator +(const cvector &rv, const ivector_slice &sl) 04274 #if(CXSC_INDEX_CHECK) 04275 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04276 #else 04277 throw(); 04278 #endif 04279 04280 INLINE civector operator +(const cvector_slice &sl, const ivector &rv) 04281 #if(CXSC_INDEX_CHECK) 04282 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04283 #else 04284 throw(); 04285 #endif 04286 04287 INLINE civector operator +(const cvector_slice &sl1, const ivector_slice &sl2) 04288 #if(CXSC_INDEX_CHECK) 04289 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04290 #else 04291 throw(); 04292 #endif 04293 04295 INLINE civector operator +(const ivector &rv1, const cvector &rv2) 04296 #if(CXSC_INDEX_CHECK) 04297 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04298 #else 04299 throw(); 04300 #endif 04301 04302 INLINE civector operator +(const ivector &rv, const cvector_slice &sl) 04303 #if(CXSC_INDEX_CHECK) 04304 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04305 #else 04306 throw(); 04307 #endif 04308 04309 INLINE civector operator +(const ivector_slice &sl, const cvector &rv) 04310 #if(CXSC_INDEX_CHECK) 04311 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04312 #else 04313 throw(); 04314 #endif 04315 04316 INLINE civector operator +(const ivector_slice &sl1, const cvector_slice &sl2) 04317 #if(CXSC_INDEX_CHECK) 04318 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04319 #else 04320 throw(); 04321 #endif 04322 04323 04325 INLINE civector operator -(const cvector &rv1, const ivector &rv2) 04326 #if(CXSC_INDEX_CHECK) 04327 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04328 #else 04329 throw(); 04330 #endif 04331 04332 INLINE civector operator -(const cvector &rv, const ivector_slice &sl) 04333 #if(CXSC_INDEX_CHECK) 04334 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04335 #else 04336 throw(); 04337 #endif 04338 04339 INLINE civector operator -(const cvector_slice &sl, const ivector &rv) 04340 #if(CXSC_INDEX_CHECK) 04341 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04342 #else 04343 throw(); 04344 #endif 04345 04346 INLINE civector operator -(const cvector_slice &sl1, const ivector_slice &sl2) 04347 #if(CXSC_INDEX_CHECK) 04348 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04349 #else 04350 throw(); 04351 #endif 04352 04354 INLINE civector operator -(const ivector &rv1, const cvector &rv2) 04355 #if(CXSC_INDEX_CHECK) 04356 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04357 #else 04358 throw(); 04359 #endif 04360 04361 INLINE civector operator -(const ivector &rv, const cvector_slice &sl) 04362 #if(CXSC_INDEX_CHECK) 04363 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04364 #else 04365 throw(); 04366 #endif 04367 04368 INLINE civector operator -(const ivector_slice &sl, const cvector &rv) 04369 #if(CXSC_INDEX_CHECK) 04370 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04371 #else 04372 throw(); 04373 #endif 04374 04375 INLINE civector operator -(const ivector_slice &sl1, const cvector_slice &sl2) 04376 #if(CXSC_INDEX_CHECK) 04377 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04378 #else 04379 throw(); 04380 #endif 04381 04382 04384 INLINE civector operator |(const cvector &rv1, const ivector &rv2) 04385 #if(CXSC_INDEX_CHECK) 04386 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04387 #else 04388 throw(); 04389 #endif 04390 04391 INLINE civector operator |(const cvector &rv, const ivector_slice &sl) 04392 #if(CXSC_INDEX_CHECK) 04393 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04394 #else 04395 throw(); 04396 #endif 04397 04398 INLINE civector operator |(const cvector_slice &sl, const ivector &rv) 04399 #if(CXSC_INDEX_CHECK) 04400 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04401 #else 04402 throw(); 04403 #endif 04404 04405 INLINE civector operator |(const cvector_slice &sl1, const ivector_slice &sl2) 04406 #if(CXSC_INDEX_CHECK) 04407 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04408 #else 04409 throw(); 04410 #endif 04411 04413 INLINE civector operator |(const ivector &rv1, const cvector &rv2) 04414 #if(CXSC_INDEX_CHECK) 04415 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04416 #else 04417 throw(); 04418 #endif 04419 04420 INLINE civector operator |(const ivector &rv, const cvector_slice &sl) 04421 #if(CXSC_INDEX_CHECK) 04422 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04423 #else 04424 throw(); 04425 #endif 04426 04427 INLINE civector operator |(const ivector_slice &sl, const cvector &rv) 04428 #if(CXSC_INDEX_CHECK) 04429 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04430 #else 04431 throw(); 04432 #endif 04433 04434 INLINE civector operator |(const ivector_slice &sl1, const cvector_slice &sl2) 04435 #if(CXSC_INDEX_CHECK) 04436 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04437 #else 04438 throw(); 04439 #endif 04440 04442 INLINE civector operator &(const cvector &rv1, const ivector &rv2) 04443 #if(CXSC_INDEX_CHECK) 04444 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04445 #else 04446 throw(); 04447 #endif 04448 04449 INLINE civector operator &(const cvector &rv, const ivector_slice &sl) 04450 #if(CXSC_INDEX_CHECK) 04451 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04452 #else 04453 throw(); 04454 #endif 04455 04456 INLINE civector operator &(const cvector_slice &sl, const ivector &rv) 04457 #if(CXSC_INDEX_CHECK) 04458 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04459 #else 04460 throw(); 04461 #endif 04462 04463 INLINE civector operator &(const cvector_slice &sl1, const ivector_slice &sl2) 04464 #if(CXSC_INDEX_CHECK) 04465 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04466 #else 04467 throw(); 04468 #endif 04469 04471 INLINE civector operator &(const ivector &rv1, const cvector &rv2) 04472 #if(CXSC_INDEX_CHECK) 04473 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04474 #else 04475 throw(); 04476 #endif 04477 04478 INLINE civector operator &(const ivector &rv, const cvector_slice &sl) 04479 #if(CXSC_INDEX_CHECK) 04480 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04481 #else 04482 throw(); 04483 #endif 04484 04485 INLINE civector operator &(const ivector_slice &sl, const cvector &rv) 04486 #if(CXSC_INDEX_CHECK) 04487 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04488 #else 04489 throw(); 04490 #endif 04491 04492 INLINE civector operator &(const ivector_slice &sl1, const cvector_slice &sl2) 04493 #if(CXSC_INDEX_CHECK) 04494 throw(ERROR__OP_WITH_WRONG_DIM<civector>); 04495 #else 04496 throw(); 04497 #endif 04498 04500 INLINE bool in(const civector& v1, const civector& v2); 04501 04502 } // namespace cxsc 04503 04504 #ifdef _CXSC_INCL_INL 04505 #include "vector.inl" 04506 #include "civector.inl" 04507 #endif 04508 04509 #ifdef _CXSC_RMATRIX_HPP_INCLUDED 04510 # ifdef _CXSC_INCL_INL 04511 # include "civecrmat.inl" 04512 # else 04513 # include "civecrmat.hpp" 04514 # endif 04515 #endif 04516 04517 #ifdef _CXSC_CMATRIX_HPP_INCLUDED 04518 # ifdef _CXSC_INCL_INL 04519 # include "civeccmat.inl" 04520 # else 04521 # include "civeccmat.hpp" 04522 # endif 04523 #endif 04524 04525 #ifdef _CXSC_IMATRIX_HPP_INCLUDED 04526 # ifdef _CXSC_INCL_INL 04527 # include "civecimat.inl" 04528 # else 04529 # include "civecimat.hpp" 04530 # endif 04531 #endif 04532 04533 #ifdef CXSC_USE_BLAS 04534 #define _CXSC_BLAS_CIVECTOR 04535 #include "cxsc_blas.inl" 04536 #endif 04537 04538 04539 #endif
1.7.5.1