- 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: cvector.hpp,v 1.31 2014/01/30 17:23:44 cxsc Exp $ */ 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" // used for declaration of Inf, Sup,... 00034 //#include "cxscmatr.hpp" 00035 #include "rvector.hpp" 00036 #include "vector.hpp" 00037 00038 00039 #include <iostream> 00040 00041 //#include "matrix.hpp" // hat hier eigentlich nichts zu suchen, sonst aber Internal Compiler Error #9 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 //#if(CXSC_INDEX_CHECK) 00071 #ifdef _CXSC_FRIEND_TPL 00072 //------------ Templates -------------------------------------------------- 00073 // complex 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 //-------- vector-vector ----------------------- 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 //--------- vector-scalar ----------------- 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 //------------- vector-matrix --------------- 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 // Real 00469 //--Real -------- vector-scalar ------------ 00470 //--Real--------- Vector-vector--------- 00471 //-- Real -------- Vector-matrix ---------- 00472 // interval ----------------- 00473 // vector-scalar 00474 // vector-vector 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 // vector-matrix 00513 // cinterval ----------------- 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 // vector-vector 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 //------ Konstruktoren ---------------------------------------------------- 00642 cvector () throw(); 00644 explicit cvector(const int &i) throw(); 00645 #ifdef OLD_CXSC 00646 00647 explicit cvector(const class index &i) throw(); // for backwards compatibility 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 // Real 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 // complex 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 // Real 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 //--------- Destruktor ---------------------------------------------------- 00780 INLINE ~cvector() { delete [] dat; } 00781 00782 //------ Standardfunktionen ----------------------------------------------- 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 //#else 00834 //#endif 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 //#if(CXSC_INDEX_CHECK) 00857 #ifdef _CXSC_FRIEND_TPL 00858 //------------------------- Templates ------------------------------------------- 00859 // complex / complex 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 /* friend TINLINE cvector_slice &_vsmvsetim(cvector_slice &,const 01023 rmatrix_subv &) #if(CXSC_INDEX_CHECK) 01024 throw(ERROR__OP_WITH_WRONG_DIM<cvector_slice>); #else throw(); 01025 #endif 01026 friend TINLINE cvector_slice &_vsmvsetre(cvector_slice &,const rmatrix_subv &) 01027 #if(CXSC_INDEX_CHECK) 01028 throw(ERROR__OP_WITH_WRONG_DIM<cvector_slice>); 01029 #else 01030 throw(); 01031 #endif */ // 4.10.00 S.W. 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 // complex / Real 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 // interval ----------- 01076 // vector-vector ------- 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 // vector-matrix ------- 01109 /* friend TINLINE civector _mvscimult<imatrix,cvector_slice,civector>(const 01110 imatrix &m,const cvector_slice &v) #if(CXSC_INDEX_CHECK) 01111 throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM); 01112 #else 01113 throw(); 01114 #endif */ // 4.10.00. S.W. 01115 /* friend TINLINE civector _vsmcimult<cvector_slice,imatrix,civector>(const 01116 cvector_slice &v,const imatrix &m) #if(CXSC_INDEX_CHECK) 01117 throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM); 01118 #else 01119 throw(); 01120 #endif 01121 */ // 4.10.00 S.W. 01122 01123 // cinterval 01124 // cinterval -- vector-vector 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 //--------------------- Konstruktoren ----------------------------------- 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 // complex 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 // Real 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 // cinterval -------- 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 // cinterval -- vector-vector 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 //--------------------- Standardfunktionen ------------------------------ 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 //#else 01489 //#endif 01490 }; 01491 01492 //======================================================================= 01493 //======================== Vector Functions ============================= 01494 01496 INLINE cvector _cvector(const complex &r) throw(); 01497 // INLINE cvector _cvector(const cmatrix &m) throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ); 01498 // INLINE cvector _cvector(const cmatrix_slice &sl) throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ); 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 // INLINE cvector _cvector(const rmatrix &m) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 01506 // INLINE cvector _cvector(const rmatrix_slice &sl) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ); 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 //======================= Vector / Scalar =============================== 01617 01618 //----------------------------- complex --------------------------- 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 //---------------------------- Real -------------------------------------- 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 //======================= Vector / Vector =============================== 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 //----------------------- complex / complex --------------------------- 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 /* INLINE bool operator <(const cvector &rv1, const cvector &rv2) throw(); 01961 INLINE bool operator <(const cvector_slice &sl1, const cvector_slice &sl2) throw(); 01962 INLINE bool operator < (const cvector_slice &sl, const cvector &rv) throw(); 01963 INLINE bool operator < (const cvector &rv, const cvector_slice &sl) throw(); 01964 INLINE bool operator <=(const cvector &rv1, const cvector &rv2) throw(); 01965 INLINE bool operator <=(const cvector_slice &sl1, const cvector_slice &sl2) throw(); 01966 INLINE bool operator <=(const cvector_slice &sl, const cvector &rv) throw(); 01967 INLINE bool operator <=(const cvector &rv, const cvector_slice &sl) throw(); 01968 INLINE bool operator >(const cvector &rv1, const cvector &rv2) throw(); 01969 INLINE bool operator >(const cvector_slice &sl1, const cvector_slice &sl2) throw(); 01970 INLINE bool operator >(const cvector_slice &sl, const cvector &rv) throw(); 01971 INLINE bool operator >(const cvector &rv, const cvector_slice &sl) throw(); 01972 INLINE bool operator >=(const cvector &rv1, const cvector &rv2) throw(); 01973 INLINE bool operator >=(const cvector_slice &sl1, const cvector_slice &sl2) throw(); 01974 INLINE bool operator >=(const cvector_slice &sl, const cvector &rv) throw(); 01975 INLINE bool operator >=(const cvector &rv, const cvector_slice &sl) throw(); 01976 */ 01977 //-------------------------------- complex / Real -------------------------------- 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 } // namespace cxsc 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
1.7.5.1