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