C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
cvector.hpp
1 /*
2 ** CXSC is a C++ library for eXtended Scientific Computing (V 2.5.4)
3 **
4 ** Copyright (C) 1990-2000 Institut fuer Angewandte Mathematik,
5 ** Universitaet Karlsruhe, Germany
6 ** (C) 2000-2014 Wiss. Rechnen/Softwaretechnologie
7 ** Universitaet Wuppertal, Germany
8 **
9 ** This library is free software; you can redistribute it and/or
10 ** modify it under the terms of the GNU Library General Public
11 ** License as published by the Free Software Foundation; either
12 ** version 2 of the License, or (at your option) any later version.
13 **
14 ** This library is distributed in the hope that it will be useful,
15 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
16 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 ** Library General Public License for more details.
18 **
19 ** You should have received a copy of the GNU Library General Public
20 ** License along with this library; if not, write to the Free
21 ** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23 
24 /* CVS $Id: cvector.hpp,v 1.31 2014/01/30 17:23:44 cxsc Exp $ */
25 
26 #ifndef _CXSC_CVECTOR_HPP_INCLUDED
27 #define _CXSC_CVECTOR_HPP_INCLUDED
28 
29 #include "xscclass.hpp"
30 #include "except.hpp"
31 #include "cdot.hpp"
32 #include "cidot.hpp"
33 #include "complex.hpp" // used for declaration of Inf, Sup,...
34 //#include "cxscmatr.hpp"
35 #include "rvector.hpp"
36 #include "vector.hpp"
37 
38 
39 #include <iostream>
40 
41 //#include "matrix.hpp" // hat hier eigentlich nichts zu suchen, sonst aber Internal Compiler Error #9
42 
43 namespace cxsc {
44 
45 class cvector_slice;
46 class scvector;
47 class scvector_slice;
48 class srvector;
49 class srvector_slice;
50 
52 
57 class cvector
58 {
59  friend class cvector_slice;
60  friend class cmatrix;
61  friend class cmatrix_subv;
62  friend class civector;
63  friend class cimatrix;
64  private:
65  complex *dat;
66  int l,u,size;
67 
68  public:
69  double* to_blas_array() const { return (double*)dat; }
70 //#if(CXSC_INDEX_CHECK)
71 #ifdef _CXSC_FRIEND_TPL
72  //------------ Templates --------------------------------------------------
73  // complex
74 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m)
75 #if(CXSC_INDEX_CHECK)
76  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>);
77 #else
78  throw();
79 #endif
80 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
81 #if(CXSC_INDEX_CHECK)
82  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
83 #else
84  throw();
85 #endif
86  template <class V> friend void _vresize(V &rv) throw();
87  template <class V,class S> friend void _vresize(V &rv, const int &len)
88 #if(CXSC_INDEX_CHECK)
89  throw(ERROR__WRONG_BOUNDARIES<V>);
90 #else
91  throw();
92 #endif
93  template <class V,class S> friend void _vresize(V &rv, const int &lb, const int &ub)
94 #if(CXSC_INDEX_CHECK)
95  throw(ERROR__WRONG_BOUNDARIES<V>);
96 #else
97  throw();
98 #endif
99  template <class V1,class V2,class S> friend V1 &_vvassign(V1 &rv1,const V2 &rv2) throw();
100  template <class V,class S> friend V & _vsassign(V &rv,const S &r) throw();
101  template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) throw();
102  template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv)
103 #if(CXSC_INDEX_CHECK)
104  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
105 #else
106  throw();
107 #endif
108 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m)
109 #if(CXSC_INDEX_CHECK)
110  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
111 #else
112  throw();
113 #endif
114 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) throw();
115  template <class V> friend V _vconj(const V &rv) throw();
116  template <class VS,class E> friend E _vsconj(const VS &sl) throw();
117  template <class V,class E> friend E _vabs(const V &rv) throw();
118  template <class VS,class E> friend E _vsabs(const VS &sl) throw();
119 template <class MV,class V> friend V _mvabs(const MV &mv) throw();
120  template <class V,class E> friend E _vim(const V &rv) throw();
121  template <class V,class E> friend E _vre(const V &rv) throw();
122  template <class V1,class V2> friend V1 &_vvsetim(V1 &rv1, const V2 &rv2)
123 #if(CXSC_INDEX_CHECK)
124  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
125 #else
126  throw();
127 #endif
128  template <class V1,class V2> friend V1 &_vvsetre(V1 &rv1, const V2 &rv2)
129 #if(CXSC_INDEX_CHECK)
130  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
131 #else
132  throw();
133 #endif
134  template <class V,class VS> friend V &_vvssetim(V &rv, const VS &sl)
135 #if(CXSC_INDEX_CHECK)
136  throw(ERROR__OP_WITH_WRONG_DIM<V>);
137 #else
138  throw();
139 #endif
140  template <class V,class VS> friend V &_vvssetre(V &rv, const VS &sl)
141 #if(CXSC_INDEX_CHECK)
142  throw(ERROR__OP_WITH_WRONG_DIM<V>);
143 #else
144  throw();
145 #endif
146 template <class V,class MV> friend V &_vmvsetim(V &rv,const MV &v)
147 #if(CXSC_INDEX_CHECK)
148  throw(ERROR__OP_WITH_WRONG_DIM<V>);
149 #else
150  throw();
151 #endif
152 template <class V,class MV> friend V &_vmvsetre(V &rv,const MV &v)
153 #if(CXSC_INDEX_CHECK)
154  throw(ERROR__OP_WITH_WRONG_DIM<V>);
155 #else
156  throw();
157 #endif
158  template <class V,class S> friend V &_vssetre(V &v, const S &s) throw();
159  template <class V,class S> friend V &_vssetim(V &v, const S &s) throw();
160 
161 //-------- vector-vector -----------------------
162  template <class DP,class V1,class V2> friend void _vvaccu(DP &dp, const V1 & rv1, const V2 &rv2)
163 #if(CXSC_INDEX_CHECK)
164  throw(OP_WITH_WRONG_DIM);
165 #else
166  throw();
167 #endif
168  template <class DP,class VS,class V> friend void _vsvaccu(DP &dp, const VS & sl, const V &rv)
169 #if(CXSC_INDEX_CHECK)
170  throw(OP_WITH_WRONG_DIM);
171 #else
172  throw();
173 #endif
174  template <class V1,class V2,class E> friend E _vvcmult(const V1 & rv1, const V2 &rv2)
175 #if(CXSC_INDEX_CHECK)
176  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
177 #else
178  throw();
179 #endif
180  template <class VS,class V,class E> friend E _vsvcmult(const VS & sl, const V &rv)
181 #if(CXSC_INDEX_CHECK)
182  throw(ERROR__OP_WITH_WRONG_DIM<V>);
183 #else
184  throw();
185 #endif
186  template <class V,class S> friend V &_vsmultassign(V &rv,const S &r) throw();
187  template <class V1,class V2,class E> friend E _vvplus(const V1 &rv1, const V2 &rv2)
188 #if(CXSC_INDEX_CHECK)
189  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
190 #else
191  throw();
192 #endif
193  template <class V,class VS,class E> friend E _vvsplus(const V &rv,const VS &sl)
194 #if(CXSC_INDEX_CHECK)
195  throw(ERROR__OP_WITH_WRONG_DIM<V>);
196 #else
197  throw();
198 #endif
199  template <class VS1,class VS2,class E> friend E _vsvsplus(const VS1 &s1,const VS2 &s2)
200 #if(CXSC_INDEX_CHECK)
201  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
202 #else
203  throw();
204 #endif
205  template <class VS1,class VS2,class E> friend E _vsvsminus(const VS1 &s1,const VS2 &s2)
206 #if(CXSC_INDEX_CHECK)
207  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
208 #else
209  throw();
210 #endif
211  template <class V1,class V2> friend V1 &_vvplusassign(V1 &rv1, const V2 &rv2)
212 #if(CXSC_INDEX_CHECK)
213  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
214 #else
215  throw();
216 #endif
217  template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl)
218 #if(CXSC_INDEX_CHECK)
219  throw(ERROR__OP_WITH_WRONG_DIM<V>);
220 #else
221  throw();
222 #endif
223  template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv)
224 #if(CXSC_INDEX_CHECK)
225  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
226 #else
227  throw();
228 #endif
229  template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
230 #if(CXSC_INDEX_CHECK)
231  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
232 #else
233  throw();
234 #endif
235  template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
236 #if(CXSC_INDEX_CHECK)
237  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
238 #else
239  throw();
240 #endif
241  template <class V1,class V2> friend V1 &_vvminusassign(V1 &rv1, const V2 &rv2)
242 #if(CXSC_INDEX_CHECK)
243  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
244 #else
245  throw();
246 #endif
247  template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl)
248 #if(CXSC_INDEX_CHECK)
249  throw(ERROR__OP_WITH_WRONG_DIM<V>);
250 #else
251  throw();
252 #endif
253  template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv)
254 #if(CXSC_INDEX_CHECK)
255  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
256 #else
257  throw();
258 #endif
259  template <class V> friend V _vminus(const V &rv) throw();
260  template <class VS,class V> friend V _vsminus(const VS &sl) throw();
261  template <class V1,class V2,class E> friend E _vvminus(const V1 &rv1, const V2 &rv2)
262 #if(CXSC_INDEX_CHECK)
263  throw(ERROR__OP_WITH_WRONG_DIM<E>);
264 #else
265  throw();
266 #endif
267  template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl)
268 #if(CXSC_INDEX_CHECK)
269  throw(ERROR__OP_WITH_WRONG_DIM<E>);
270 #else
271  throw();
272 #endif
273  template <class VS,class V,class E> friend E _vsvminus(const VS &sl,const V &rv)
274 #if(CXSC_INDEX_CHECK)
275  throw(ERROR__OP_WITH_WRONG_DIM<E>);
276 #else
277  throw();
278 #endif
279  template <class V,class MV,class S> friend S _vmvcmult(const V &rv1, const MV &rv2)
280 #if(CXSC_INDEX_CHECK)
281  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
282 #else
283  throw();
284 #endif
285  template <class V,class MV,class S> friend S _vmvcimult(const V &rv1, const MV &rv2)
286 #if(CXSC_INDEX_CHECK)
287  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
288 #else
289  throw();
290 #endif
291  template <class V1,class V2,class E> friend E _vvconv(const V1 &rv1, const V2 &rv2)
292 #if(CXSC_INDEX_CHECK)
293  throw(ERROR__OP_WITH_WRONG_DIM<E>);
294 #else
295  throw();
296 #endif
297  template <class V,class VS,class E> friend E _vvsconv(const V &rv,const VS &sl)
298 #if(CXSC_INDEX_CHECK)
299  throw(ERROR__OP_WITH_WRONG_DIM<E>);
300 #else
301  throw();
302 #endif
303  template <class VS1,class VS2,class E> friend E _vsvsconv(const VS1 &s1,const VS2 &s2)
304 #if(CXSC_INDEX_CHECK)
305  throw(ERROR__OP_WITH_WRONG_DIM<E>);
306 #else
307  throw();
308 #endif
309  //--------- vector-scalar -----------------
310  template <class V,class S,class E> friend E _vsdiv(const V &rv, const S &s) throw();
311  template <class V,class S> friend V &_vsdivassign(V &rv,const S &r) throw();
312  template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) throw();
313  template <class V,class S,class E> friend E _vsmult(const V &rv, const S &s) throw();
314  template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) throw();
315  template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) throw();
316  template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
317 #if(CXSC_INDEX_CHECK)
318  throw(ERROR__OP_WITH_WRONG_DIM<E>);
319 #else
320  throw();
321 #endif
322  template <class MV,class V,class E> friend E _mvvplus(const MV &rv1, const V &rv2)
323 #if(CXSC_INDEX_CHECK)
324  throw(ERROR__OP_WITH_WRONG_DIM<E>);
325 #else
326  throw();
327 #endif
328  template <class MV,class V,class E> friend E _mvvminus(const MV &rv1, const V &rv2)
329 #if(CXSC_INDEX_CHECK)
330  throw(ERROR__OP_WITH_WRONG_DIM<E>);
331 #else
332  throw();
333 #endif
334  template <class V,class MV,class E> friend E _vmvminus(const V &rv1, const MV &rv2)
335 #if(CXSC_INDEX_CHECK)
336  throw(ERROR__OP_WITH_WRONG_DIM<E>);
337 #else
338  throw();
339 #endif
340  template <class MV1,class MV2,class E> friend E _mvmvminus(const MV1 &rv1, const MV2 &rv2)
341 #if(CXSC_INDEX_CHECK)
342  throw(ERROR__OP_WITH_WRONG_DIM<E>);
343 #else
344  throw();
345 #endif
346 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
347 #if(CXSC_INDEX_CHECK)
348  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
349 #else
350  throw();
351 #endif
352 template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv)
353 #if(CXSC_INDEX_CHECK)
354  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
355 #else
356  throw();
357 #endif
358  template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) throw();
359 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
360 #if(CXSC_INDEX_CHECK)
361  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
362 #else
363  throw();
364 #endif
365 template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
366 #if(CXSC_INDEX_CHECK)
367  throw(OP_WITH_WRONG_DIM);
368 #else
369  throw();
370 #endif
371 
372  template <class V1,class V2> friend bool _vveq(const V1 &rv1, const V2 &rv2) throw();
373  template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) throw();
374  template <class V1,class V2> friend bool _vvneq(const V1 &rv1, const V2 &rv2) throw();
375  template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) throw();
376  template <class V1,class V2> friend bool _vvless(const V1 &rv1, const V2 &rv2) throw();
377  template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) throw();
378  template <class V1,class V2> friend bool _vvleq(const V1 &rv1, const V2 &rv2) throw();
379  template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) throw();
380  template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) throw();
381  template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) throw();
382  template <class V> friend bool _vnot(const V &rv) throw();
383  template <class V> friend void *_vvoid(const V &rv) throw();
384  template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw();
385  template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw();
386  template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw();
387  template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw();
388  template <class VS> friend bool _vsnot(const VS &sl) throw();
389  template <class VS> friend void *_vsvoid(const VS &sl) throw();
390  template <class V> friend std::ostream &_vout(std::ostream &s, const V &rv) throw();
391  template <class V> friend std::istream &_vin(std::istream &s, V &rv) throw();
392 
393  //------------- vector-matrix ---------------
394 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) throw();
395  template <class M,class V,class E> friend E _mvcmult(const M &m,const V &v)
396 #if(CXSC_INDEX_CHECK)
397  throw(ERROR__OP_WITH_WRONG_DIM<M>);
398 #else
399  throw();
400 #endif
401  template <class M,class V,class E> friend E _mvcimult(const M &m,const V &v)
402 #if(CXSC_INDEX_CHECK)
403  throw(ERROR__OP_WITH_WRONG_DIM<M>);
404 #else
405  throw();
406 #endif
407  template <class V,class M,class E> friend E _vmcmult(const V &v,const M &m)
408 #if(CXSC_INDEX_CHECK)
409  throw(ERROR__OP_WITH_WRONG_DIM<M>);
410 #else
411  throw();
412 #endif
413  template <class V,class M,class E> friend E _vmcimult(const V &v,const M &m)
414 #if(CXSC_INDEX_CHECK)
415  throw(ERROR__OP_WITH_WRONG_DIM<M>);
416 #else
417  throw();
418 #endif
419  template <class V,class M,class S> friend V &_vmcmultassign(V &v,const M &m)
420 #if(CXSC_INDEX_CHECK)
421  throw(ERROR__OP_WITH_WRONG_DIM<M>);
422 #else
423  throw();
424 #endif
425  template <class V,class M,class S> friend V &_vmcimultassign(V &v,const M &m)
426 #if(CXSC_INDEX_CHECK)
427  throw(ERROR__OP_WITH_WRONG_DIM<M>);
428 #else
429  throw();
430 #endif
431  template <class MS,class V,class E> friend E _msvcmult(const MS &ms,const V &v)
432 #if(CXSC_INDEX_CHECK)
433  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
434 #else
435  throw();
436 #endif
437  template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v)
438 #if(CXSC_INDEX_CHECK)
439  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
440 #else
441  throw();
442 #endif
443  template <class V,class MS,class E> friend E _vmscmult(const V &v,const MS &ms)
444 #if(CXSC_INDEX_CHECK)
445  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
446 #else
447  throw();
448 #endif
449  template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms)
450 #if(CXSC_INDEX_CHECK)
451  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
452 #else
453  throw();
454 #endif
455  template <class V,class MS,class S> friend V &_vmscmultassign(V &v,const MS &ms)
456 #if(CXSC_INDEX_CHECK)
457  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
458 #else
459  throw();
460 #endif
461  template <class V,class MS,class S> friend V &_vmscimultassign(V &v,const MS &ms)
462 #if(CXSC_INDEX_CHECK)
463  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
464 #else
465  throw();
466 #endif
467 
468  // Real
469  //--Real -------- vector-scalar ------------
470  //--Real--------- Vector-vector---------
471  //-- Real -------- Vector-matrix ----------
472  // interval -----------------
473  // vector-scalar
474  // vector-vector
475  template <class V1,class V2,class E> friend E _vvcimult(const V1 & rv1, const V2 &rv2)
476 #if(CXSC_INDEX_CHECK)
477  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
478 #else
479  throw();
480 #endif
481  template <class VS,class V,class E> friend E _vsvcimult(const VS & sl, const V &rv)
482 #if(CXSC_INDEX_CHECK)
483  throw(ERROR__OP_WITH_WRONG_DIM<V>);
484 #else
485  throw();
486 #endif
487  template <class VS1,class VS2,class E> friend E _vsvscimult(const VS1 & sl1, const VS2 &sl2)
488 #if(CXSC_INDEX_CHECK)
489  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
490 #else
491  throw();
492 #endif
493  template <class V1,class V2,class E> friend E _vvsect(const V1 &rv1, const V2 &rv2)
494 #if(CXSC_INDEX_CHECK)
495  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
496 #else
497  throw();
498 #endif
499  template <class V,class VS,class E> friend E _vvssect(const V &rv,const VS &sl)
500 #if(CXSC_INDEX_CHECK)
501  throw(ERROR__OP_WITH_WRONG_DIM<E>);
502 #else
503  throw();
504 #endif
505  template <class VS1,class VS2,class E> friend E _vsvssect(const VS1 &s1,const VS2 &s2)
506 #if(CXSC_INDEX_CHECK)
507  throw(ERROR__OP_WITH_WRONG_DIM<E>);
508 #else
509  throw();
510 #endif
511 
512  // vector-matrix
513  // cinterval -----------------
514  template <class V1,class V2> friend V1 &_vvsetinf(V1 &rv1, const V2 &rv2)
515 #if(CXSC_INDEX_CHECK)
516  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
517 #else
518  throw();
519 #endif
520  template <class V1,class V2> friend V1 &_vvsetsup(V1 &rv1, const V2 &rv2)
521 #if(CXSC_INDEX_CHECK)
522  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
523 #else
524  throw();
525 #endif
526  template <class V1,class V2> friend V1 &_vvusetinf(V1 &rv1, const V2 &rv2)
527 #if(CXSC_INDEX_CHECK)
528  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
529 #else
530  throw();
531 #endif
532  template <class V1,class V2> friend V1 &_vvusetsup(V1 &rv1, const V2 &rv2)
533 #if(CXSC_INDEX_CHECK)
534  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
535 #else
536  throw();
537 #endif
538  template <class VS,class V> friend VS &_vsvsetinf(VS &sl, const V &rv)
539 #if(CXSC_INDEX_CHECK)
540  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
541 #else
542  throw();
543 #endif
544  template <class VS,class V> friend VS &_vsvsetsup(VS &sl, const V &rv)
545 #if(CXSC_INDEX_CHECK)
546  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
547 #else
548  throw();
549 #endif
550  template <class VS,class V> friend VS &_vsvusetinf(VS &sl, const V &rv)
551 #if(CXSC_INDEX_CHECK)
552  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
553 #else
554  throw();
555 #endif
556  template <class VS,class V> friend VS &_vsvusetsup(VS &sl, const V &rv)
557 #if(CXSC_INDEX_CHECK)
558  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
559 #else
560  throw();
561 #endif
562 template <class MV,class V> friend MV &_mvvsetinf(MV &v,const V &rv)
563 #if(CXSC_INDEX_CHECK)
564  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
565 #else
566  throw();
567 #endif
568 template <class MV,class V> friend MV &_mvvsetsup(MV &v,const V &rv)
569 #if(CXSC_INDEX_CHECK)
570  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
571 #else
572  throw();
573 #endif
574 template <class MV,class V> friend MV &_mvvusetinf(MV &v,const V &rv)
575 #if(CXSC_INDEX_CHECK)
576  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
577 #else
578  throw();
579 #endif
580 template <class MV,class V> friend MV &_mvvusetsup(MV &v,const V &rv)
581 #if(CXSC_INDEX_CHECK)
582  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
583 #else
584  throw();
585 #endif
586  template <class V,class E> friend E _vmid(const V &rv) throw();
587  template <class V,class E> friend E _vinf(const V &rv) throw();
588  template <class V,class E> friend E _vsup(const V &rv) throw();
589  template <class V,class E> friend E _vdiam(const V &rv) throw();
590  template <class VS,class E> friend E _vsmid(const VS &sl) throw();
591  template <class VS,class E> friend E _vsinf(const VS &sl) throw();
592  template <class VS,class E> friend E _vssup(const VS &sl) throw();
593  template <class VS,class E> friend E _vsdiam(const VS &sl) throw();
594 template <class MV,class V> friend V _mvdiam(const MV &mv) throw();
595 template <class MV,class V> friend V _mvmid(const MV &mv) throw();
596 template <class MV,class V> friend V _mvinf(const MV &mv) throw();
597 template <class MV,class V> friend V _mvsup(const MV &mv) throw();
598 
599  // vector-vector
600  template <class V1,class V2> friend V1 &_vvconvassign(V1 &rv1, const V2 &rv2)
601 #if(CXSC_INDEX_CHECK)
602  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
603 #else
604  throw();
605 #endif
606  template <class V1,class V2> friend V1 &_vvsectassign(V1 &rv1, const V2 &rv2)
607 #if(CXSC_INDEX_CHECK)
608  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
609 #else
610  throw();
611 #endif
612  template <class VS,class V> friend VS &_vsvconvassign(VS &sl, const V &rv)
613 #if(CXSC_INDEX_CHECK)
614  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
615 #else
616  throw();
617 #endif
618  template <class VS,class V> friend VS &_vsvsectassign(VS &sl, const V &rv)
619 #if(CXSC_INDEX_CHECK)
620  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
621 #else
622  throw();
623 #endif
624 template <class MV,class V> friend MV &_mvvconvassign(MV &v,const V &rv)
625 #if(CXSC_INDEX_CHECK)
626  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
627 #else
628  throw();
629 #endif
630 template <class MV,class V> friend MV &_mvvsectassign(MV &v,const V &rv)
631 #if(CXSC_INDEX_CHECK)
632  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
633 #else
634  throw();
635 #endif
636 
637 
638 #endif
639 
640  //------ Konstruktoren ----------------------------------------------------
642  cvector () throw();
644  explicit cvector(const int &i) throw();
645 #ifdef OLD_CXSC
646  explicit cvector(const class index &i) throw(); // for backwards compatibility
648 #endif
649  explicit cvector(const int &i1,const int &i2)
651 #if(CXSC_INDEX_CHECK)
652  throw(ERROR_CVECTOR_WRONG_BOUNDARIES,ERROR_CVECTOR_NO_MORE_MEMORY);
653 #else
654  throw();
655 #endif
656  cvector(const cmatrix_subv &) throw();
659  explicit cvector(const complex& r) throw();
661  explicit cvector(const cmatrix& )
662 #if(CXSC_INDEX_CHECK)
663  throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
664 #else
665  throw();
666 #endif
667  explicit cvector(const cmatrix_slice &sl)
669 #if(CXSC_INDEX_CHECK)
670  throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
671 #else
672  throw();
673 #endif
674  cvector(const cvector_slice &rs) throw();
677  cvector(const cvector &v) throw();
679  cvector(const scvector_slice &rs);
681  cvector(const scvector &v);
682  // Real
684  explicit cvector(const srvector_slice &rs);
686  explicit cvector(const srvector &v);
688  explicit cvector(const real &) throw();
690  explicit cvector(const rvector_slice &rs) throw();
692  explicit cvector(const rvector &v) throw();
694  explicit cvector(const rmatrix &)
695 #if(CXSC_INDEX_CHECK)
696  throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
697 #else
698  throw();
699 #endif
700  explicit cvector(const rmatrix_slice &sl)
702 #if(CXSC_INDEX_CHECK)
703  throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
704 #else
705  throw();
706 #endif
707  explicit cvector(const rmatrix_subv &) throw();
709 
710  // complex
712  cvector &operator =(const cvector &rv) throw();
714  cvector &operator =(const cvector_slice &sl) throw();
716  cvector &operator =(const scvector &rv);
718  cvector &operator =(const scvector_slice &sl);
720  cvector &operator =(const complex &r) throw();
722  cvector &operator =(const cmatrix &m)
723 #if(CXSC_INDEX_CHECK)
724  throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
725 #else
726  throw();
727 #endif
730 #if(CXSC_INDEX_CHECK)
731  throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
732 #else
733  throw();
734 #endif
735  cvector &operator =(const cmatrix_subv &) throw();
737  // Real
739  cvector &operator =(const rvector &rv) throw();
741  cvector &operator =(const rvector_slice &sl) throw();
743  cvector &operator =(const srvector &rv);
745  cvector &operator =(const srvector_slice &sl);
747  cvector &operator =(const real &r) throw();
749  cvector &operator =(const rmatrix &m)
750 #if(CXSC_INDEX_CHECK)
751  throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
752 #else
753  throw();
754 #endif
757 #if(CXSC_INDEX_CHECK)
758  throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
759 #else
760  throw();
761 #endif
762  cvector &operator =(const rmatrix_subv &) throw();
764 
765  cvector& operator+=(const srvector&);
766  cvector& operator+=(const scvector&);
767  cvector& operator+=(const srvector_slice&);
768  cvector& operator+=(const scvector_slice&);
769  cvector& operator-=(const srvector&);
770  cvector& operator-=(const scvector&);
771  cvector& operator-=(const srvector_slice&);
772  cvector& operator-=(const scvector_slice&);
773 
775  INLINE cvector operator()(const intvector& p);
777  INLINE cvector operator()(const intmatrix& P);
778 
779  //--------- Destruktor ----------------------------------------------------
780  INLINE ~cvector() { delete [] dat; }
781 
782  //------ Standardfunktionen -----------------------------------------------
783 
784  friend INLINE complex::complex(const cvector &)
785 #if(CXSC_INDEX_CHECK)
786  throw(ERROR_CVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_CVECTOR_USE_OF_UNINITIALIZED_OBJ);
787 #else
788  throw();
789 #endif
790  friend INLINE int Lb(const cvector &rv) throw() { return rv.l; }
793  friend INLINE int Ub(const cvector &rv) throw() { return rv.u; }
795  friend INLINE int VecLen(const cvector &rv) throw() { return rv.size; }
797  friend INLINE cvector & SetLb(cvector &rv, const int &l) throw() { rv.l=l; rv.u=l+rv.size-1; return rv;}
799  friend INLINE cvector & SetUb(cvector &rv, const int &u) throw() { rv.u=u; rv.l=u-rv.size+1; return rv;}
801  INLINE complex & operator [](const int &i) const
802 #if(CXSC_INDEX_CHECK)
803  throw(ERROR_CVECTOR_ELEMENT_NOT_IN_VEC);
804 #else
805  throw();
806 #endif
807 
809  INLINE complex & operator [](const int &i)
810 #if(CXSC_INDEX_CHECK)
811  throw(ERROR_CVECTOR_ELEMENT_NOT_IN_VEC);
812 #else
813  throw();
814 #endif
815 
817  INLINE cvector & operator ()() throw() { return *this; }
819  INLINE cvector_slice operator ()(const int &i)
820 #if(CXSC_INDEX_CHECK)
821  throw(ERROR_CVECTOR_SUB_ARRAY_TOO_BIG);
822 #else
823  throw();
824 #endif
825  cvector_slice operator ()(const int &i1,const int &i2)
827 #if(CXSC_INDEX_CHECK)
828  throw(ERROR_CVECTOR_SUB_ARRAY_TOO_BIG);
829 #else
830  throw();
831 #endif
832  operator void*() throw();
833 //#else
834 //#endif
835 };
836 
837 
839 
845 {
846  friend class cvector;
847  friend class cmatrix;
848  friend class civector;
849  friend class cimatrix;
850  private:
851  complex *dat;
852  int l,u,size;
853  int start,end;
854 
855  public:
856 //#if(CXSC_INDEX_CHECK)
857 #ifdef _CXSC_FRIEND_TPL
858 //------------------------- Templates -------------------------------------------
859 // complex / complex
860 
861  template <class VS1,class VS2> friend VS1 & _vsvsassign(VS1 &sl1,const VS2 &sl2)
862 #if(CXSC_INDEX_CHECK)
863  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
864 #else
865  throw();
866 #endif
867 
868  template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) throw();
869 
870  template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv)
871 #if(CXSC_INDEX_CHECK)
872  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
873 #else
874  throw();
875 #endif
876 
877  template <class VS,class S> friend VS & _vssassign(VS &sl,const S &r) throw();
878 
879  template <class DP,class VS,class V> friend void _vsvaccu(DP &dp, const VS & sl, const V &rv)
880 #if(CXSC_INDEX_CHECK)
881  throw(OP_WITH_WRONG_DIM);
882 #else
883  throw();
884 #endif
885  template <class DP,class VS1,class VS2> friend void _vsvsaccu(DP &dp, const VS1 & sl1, const VS2 &sl2)
886 #if(CXSC_INDEX_CHECK)
887  throw(OP_WITH_WRONG_DIM);
888 #else
889  throw();
890 #endif
891 
892  template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) throw();
893  template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) throw();
894 
895  template <class VS,class V,class E> friend E _vsvcmult(const VS & sl, const V &rv)
896 #if(CXSC_INDEX_CHECK)
897  throw(ERROR__OP_WITH_WRONG_DIM<V>);
898 #else
899  throw();
900 #endif
901  template <class VS,class S> friend VS &_vssmultassign(VS &rv,const S &r) throw();
902  template <class VS,class S> friend VS &_vssdivassign(VS &rv,const S &r) throw();
903  template <class V,class VS,class E> friend E _vvsplus(const V &rv,const VS &sl)
904 #if(CXSC_INDEX_CHECK)
905  throw(ERROR__OP_WITH_WRONG_DIM<V>);
906 #else
907  throw();
908 #endif
909  template <class VS1,class VS2,class E> friend E _vsvsplus(const VS1 &s1,const VS2 &s2)
910 #if(CXSC_INDEX_CHECK)
911  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
912 #else
913  throw();
914 #endif
915  template <class VS1,class VS2,class E> friend E _vsvsminus(const VS1 &s1,const VS2 &s2)
916 #if(CXSC_INDEX_CHECK)
917  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
918 #else
919  throw();
920 #endif
921  template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl)
922 #if(CXSC_INDEX_CHECK)
923  throw(ERROR__OP_WITH_WRONG_DIM<V>);
924 #else
925  throw();
926 #endif
927  template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
928 #if(CXSC_INDEX_CHECK)
929  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
930 #else
931  throw();
932 #endif
933  template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
934 #if(CXSC_INDEX_CHECK)
935  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
936 #else
937  throw();
938 #endif
939  template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl)
940 #if(CXSC_INDEX_CHECK)
941  throw(ERROR__OP_WITH_WRONG_DIM<V>);
942 #else
943  throw();
944 #endif
945 
946  template <class VS,class V> friend V _vsminus(const VS &sl) throw();
947 
948  template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl)
949 #if(CXSC_INDEX_CHECK)
950  throw(ERROR__OP_WITH_WRONG_DIM<E>);
951 #else
952  throw();
953 #endif
954  template <class VS,class V,class E> friend E _vsvminus(const VS &sl,const V &rv)
955 #if(CXSC_INDEX_CHECK)
956  throw(ERROR__OP_WITH_WRONG_DIM<E>);
957 #else
958  throw();
959 #endif
960  template <class V,class VS,class E> friend E _vvsconv(const V &rv,const VS &sl)
961 #if(CXSC_INDEX_CHECK)
962  throw(ERROR__OP_WITH_WRONG_DIM<E>);
963 #else
964  throw();
965 #endif
966  template <class VS1,class VS2,class E> friend E _vsvsconv(const VS1 &s1,const VS2 &s2)
967 #if(CXSC_INDEX_CHECK)
968  throw(ERROR__OP_WITH_WRONG_DIM<E>);
969 #else
970  throw();
971 #endif
972  template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) throw();
973  template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) throw();
974  template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) throw();
975  template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) throw();
976  template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) throw();
977  template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) throw();
978  template <class VS,class E> friend E _vsconj(const VS &sl) throw();
979  template <class VS,class E> friend E _vsabs(const VS &sl) throw();
980 
981  template <class VS1,class VS2,class E> friend E _vsvscmult(const VS1 & sl1, const VS2 &sl2)
982 #if(CXSC_INDEX_CHECK)
983  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
984 #else
985  throw();
986 #endif
987 
988  template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw();
989  template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw();
990  template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw();
991  template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw();
992  template <class VS> friend bool _vsnot(const VS &sl) throw();
993  template <class VS> friend void *_vsvoid(const VS &sl) throw();
994  template <class V> friend std::ostream &_vsout(std::ostream &s, const V &rv) throw();
995  template <class V> friend std::istream &_vsin(std::istream &s, V &rv) throw();
996  template <class VS,class E> friend E _vsim(const VS &sl) throw();
997  template <class VS,class E> friend E _vsre(const VS &sl) throw();
998  template <class VS,class V> friend VS &_vsvsetim(VS &sl, const V &rv)
999 #if(CXSC_INDEX_CHECK)
1000  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
1001 #else
1002  throw();
1003 #endif
1004  template <class VS,class V> friend VS &_vsvsetre(VS &sl, const V &rv)
1005 #if(CXSC_INDEX_CHECK)
1006  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
1007 #else
1008  throw();
1009 #endif
1010  template <class VS1,class VS2> friend VS1 &_vsvssetim(VS1 &sl1, const VS2 &sl2)
1011 #if(CXSC_INDEX_CHECK)
1012  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1013 #else
1014  throw();
1015 #endif
1016  template <class VS1,class VS2> friend VS1 &_vsvssetre(VS1 &sl1, const VS2 &sl2)
1017 #if(CXSC_INDEX_CHECK)
1018  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1019 #else
1020  throw();
1021 #endif
1022 /* friend TINLINE cvector_slice &_vsmvsetim(cvector_slice &,const
1023 rmatrix_subv &) #if(CXSC_INDEX_CHECK)
1024 throw(ERROR__OP_WITH_WRONG_DIM<cvector_slice>); #else throw();
1025 #endif
1026  friend TINLINE cvector_slice &_vsmvsetre(cvector_slice &,const rmatrix_subv &)
1027 #if(CXSC_INDEX_CHECK)
1028  throw(ERROR__OP_WITH_WRONG_DIM<cvector_slice>);
1029 #else
1030  throw();
1031 #endif */ // 4.10.00 S.W.
1032 
1033  template <class VS,class S> friend VS &_vsssetim(VS &vs, const S &s) throw();
1034  template <class VS,class S> friend VS &_vsssetre(VS &vs, const S &s) throw();
1035 
1036  template <class VS,class M,class S> friend VS &_vsmcmultassign(VS &v,const M &m)
1037 #if(CXSC_INDEX_CHECK)
1038  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1039 #else
1040  throw();
1041 #endif
1042 
1043  // complex / Real
1044  template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv)
1045 #if(CXSC_INDEX_CHECK)
1046  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
1047 #else
1048  throw();
1049 #endif
1050  template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv)
1051 #if(CXSC_INDEX_CHECK)
1052  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
1053 #else
1054  throw();
1055 #endif
1056  template <class V,class MS,class E> friend E _vmscmult(const V &v,const MS &ms)
1057 #if(CXSC_INDEX_CHECK)
1058  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1059 #else
1060  throw();
1061 #endif
1062 
1063  template <class V,class VS,class E> friend E _vvssect(const V &rv,const VS &sl)
1064 #if(CXSC_INDEX_CHECK)
1065  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1066 #else
1067  throw();
1068 #endif
1069  template <class VS1,class VS2,class E> friend E _vsvssect(const VS1 &s1,const VS2 &s2)
1070 #if(CXSC_INDEX_CHECK)
1071  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1072 #else
1073  throw();
1074 #endif
1075  // interval -----------
1076  // vector-vector -------
1077  template <class V1,class V2,class E> friend E _vvcimult(const V1 & rv1, const V2 &rv2)
1078 #if(CXSC_INDEX_CHECK)
1079  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
1080 #else
1081  throw();
1082 #endif
1083  template <class VS,class V,class E> friend E _vsvcimult(const VS & sl, const V &rv)
1084 #if(CXSC_INDEX_CHECK)
1085  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1086 #else
1087  throw();
1088 #endif
1089  template <class VS1,class VS2,class E> friend E _vsvscimult(const VS1 & sl1, const VS2 &sl2)
1090 #if(CXSC_INDEX_CHECK)
1091  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1092 #else
1093  throw();
1094 #endif
1095  template <class V1,class V2,class E> friend E _vvplus(const V1 &rv1, const V2 &rv2)
1096 #if(CXSC_INDEX_CHECK)
1097  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
1098 #else
1099  throw();
1100 #endif
1101  template <class V1,class V2,class E> friend E _vvminus(const V1 &rv1, const V2 &rv2)
1102 #if(CXSC_INDEX_CHECK)
1103  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1104 #else
1105  throw();
1106 #endif
1107 
1108  // vector-matrix -------
1109 /* friend TINLINE civector _mvscimult<imatrix,cvector_slice,civector>(const
1110 imatrix &m,const cvector_slice &v) #if(CXSC_INDEX_CHECK)
1111  throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
1112 #else
1113  throw();
1114 #endif */ // 4.10.00. S.W.
1115 /* friend TINLINE civector _vsmcimult<cvector_slice,imatrix,civector>(const
1116 cvector_slice &v,const imatrix &m) #if(CXSC_INDEX_CHECK)
1117  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
1118 #else
1119  throw();
1120 #endif
1121 */ // 4.10.00 S.W.
1122 
1123  // cinterval
1124  // cinterval -- vector-vector
1125  template <class V,class VS> friend V &_vvsconvassign(V &rv, const VS &sl)
1126 #if(CXSC_INDEX_CHECK)
1127  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1128 #else
1129  throw();
1130 #endif
1131  template <class V,class VS> friend V &_vvssectassign(V &rv, const VS &sl)
1132 #if(CXSC_INDEX_CHECK)
1133  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1134 #else
1135  throw();
1136 #endif
1137  template <class VS1,class VS2> friend VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2)
1138 #if(CXSC_INDEX_CHECK)
1139  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1140 #else
1141  throw();
1142 #endif
1143  template <class VS1,class VS2> friend VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2)
1144 #if(CXSC_INDEX_CHECK)
1145  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1146 #else
1147  throw();
1148 #endif
1149 #endif
1150 
1151  //--------------------- Konstruktoren -----------------------------------
1153  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) { }
1155  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) { }
1156  public:
1158  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) { }
1159  public:
1160  // complex
1162  INLINE cvector_slice & operator =(const scvector &sl);
1164  INLINE cvector_slice & operator =(const scvector_slice &sl);
1165 
1167  INLINE cvector_slice & operator =(const cvector_slice &sl)
1168 #if(CXSC_INDEX_CHECK)
1169  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1170 #else
1171  throw();
1172 #endif
1173  INLINE cvector_slice & operator =(const cvector &rv)
1175 #if(CXSC_INDEX_CHECK)
1176  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1177 #else
1178  throw();
1179 #endif
1180  INLINE cvector_slice & operator =(const complex &r) throw();
1183  INLINE cvector_slice & operator =(const cmatrix &m)
1184 #if(CXSC_INDEX_CHECK)
1185  throw(ERROR__OP_WITH_WRONG_DIM<cvector>,ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
1186 #else
1187  throw();
1188 #endif
1189  INLINE cvector_slice & operator =(const cmatrix_slice &m)
1191 #if(CXSC_INDEX_CHECK)
1192  throw(ERROR__OP_WITH_WRONG_DIM<cvector>,ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
1193 #else
1194  throw();
1195 #endif
1196  INLINE cvector_slice &operator =(const cmatrix_subv &) throw();
1198  // Real
1200  INLINE cvector_slice & operator =(const srvector &rv);
1202  INLINE cvector_slice & operator =(const srvector_slice &rv);
1203 
1205  INLINE cvector_slice & operator =(const rvector_slice &sl)
1206 #if(CXSC_INDEX_CHECK)
1207  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1208 #else
1209  throw();
1210 #endif
1211  INLINE cvector_slice & operator =(const rvector &rv)
1212 #if(CXSC_INDEX_CHECK)
1213  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1214 #else
1215  throw();
1216 #endif
1217  INLINE cvector_slice & operator =(const real &r) throw();
1220  INLINE cvector_slice & operator =(const rmatrix &m)
1221 #if(CXSC_INDEX_CHECK)
1222  throw(ERROR__OP_WITH_WRONG_DIM<rvector>,ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
1223 #else
1224  throw();
1225 #endif
1226  INLINE cvector_slice & operator =(const rmatrix_slice &m)
1228 #if(CXSC_INDEX_CHECK)
1229  throw(ERROR__OP_WITH_WRONG_DIM<rvector>,ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
1230 #else
1231  throw();
1232 #endif
1233  INLINE cvector_slice &operator =(const rmatrix_subv &mv) throw();
1235 
1236  // cinterval --------
1237  template <class V,class VS> friend V &_vvssetinf(V &rv, const VS &sl)
1238 #if(CXSC_INDEX_CHECK)
1239  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1240 #else
1241  throw();
1242 #endif
1243  template <class V,class VS> friend V &_vvssetsup(V &rv, const VS &sl)
1244 #if(CXSC_INDEX_CHECK)
1245  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1246 #else
1247  throw();
1248 #endif
1249  template <class V,class VS> friend V &_vvsusetinf(V &rv, const VS &sl)
1250 #if(CXSC_INDEX_CHECK)
1251  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1252 #else
1253  throw();
1254 #endif
1255  template <class V,class VS> friend V &_vvsusetsup(V &rv, const VS &sl)
1256 #if(CXSC_INDEX_CHECK)
1257  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1258 #else
1259  throw();
1260 #endif
1261  template <class VS1,class VS2> friend VS1 &_vsvssetinf(VS1 &sl1, const VS2 &sl2)
1262 #if(CXSC_INDEX_CHECK)
1263  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1264 #else
1265  throw();
1266 #endif
1267  template <class VS1,class VS2> friend VS1 &_vsvssetsup(VS1 &sl1, const VS2 &sl2)
1268 #if(CXSC_INDEX_CHECK)
1269  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1270 #else
1271  throw();
1272 #endif
1273  template <class VS1,class VS2> friend VS1 &_vsvsusetinf(VS1 &sl1, const VS2 &sl2)
1274 #if(CXSC_INDEX_CHECK)
1275  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1276 #else
1277  throw();
1278 #endif
1279  template <class VS1,class VS2> friend VS1 &_vsvsusetsup(VS1 &sl1, const VS2 &sl2)
1280 #if(CXSC_INDEX_CHECK)
1281  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1282 #else
1283  throw();
1284 #endif
1285 
1286  // cinterval -- vector-vector
1287  template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms)
1288 #if(CXSC_INDEX_CHECK)
1289  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1290 #else
1291  throw();
1292 #endif
1293 
1294 
1295  //--------------------- Standardfunktionen ------------------------------
1296 
1297  friend INLINE complex::complex(const cvector_slice &sl)
1298 #if(CXSC_INDEX_CHECK)
1299  throw(ERROR_CVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_CVECTOR_USE_OF_UNINITIALIZED_OBJ);
1300 #else
1301  throw();
1302 #endif
1303  friend INLINE int Lb(const cvector_slice &sl) throw() { return sl.start; }
1306  friend INLINE int Ub(const cvector_slice &sl) throw() { return sl.end; }
1308  friend INLINE int VecLen(const cvector_slice &sl) throw() { return sl.end-sl.start+1; }
1310  INLINE complex & operator [](const int &i) const
1311 #if(CXSC_INDEX_CHECK)
1312  throw(ERROR_CVECTOR_ELEMENT_NOT_IN_VEC);
1313 #else
1314  throw();
1315 #endif
1316 
1318  INLINE complex & operator [](const int &i)
1319 #if(CXSC_INDEX_CHECK)
1320  throw(ERROR_CVECTOR_ELEMENT_NOT_IN_VEC);
1321 #else
1322  throw();
1323 #endif
1324 
1326  INLINE cvector_slice & operator ()() throw() { return *this; }
1328  INLINE cvector_slice operator ()(const int &i)
1329 #if(CXSC_INDEX_CHECK)
1330  throw(ERROR_CVECTOR_SUB_ARRAY_TOO_BIG);
1331 #else
1332  throw();
1333 #endif
1334  INLINE cvector_slice operator ()(const int &i1,const int &i2)
1336 #if(CXSC_INDEX_CHECK)
1337  throw(ERROR_CVECTOR_SUB_ARRAY_TOO_BIG);
1338 #else
1339  throw();
1340 #endif
1341 
1343  INLINE cvector_slice &operator /=(const complex &r) throw();
1345  INLINE cvector_slice &operator /=(const real &r) throw();
1347  INLINE cvector_slice &operator *=(const complex &r) throw();
1349  INLINE cvector_slice &operator *=(const cmatrix &m)
1350 #if(CXSC_INDEX_CHECK)
1351  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1352 #else
1353  throw();
1354 #endif
1355  INLINE cvector_slice &operator *=(const rmatrix &m)
1357 #if(CXSC_INDEX_CHECK)
1358  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
1359 #else
1360  throw();
1361 #endif
1362  INLINE cvector_slice &operator *=(const real &r) throw();
1365  INLINE cvector_slice &operator +=(const cvector &rv)
1366 #if(CXSC_INDEX_CHECK)
1367  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1368 #else
1369  throw();
1370 #endif
1371  INLINE cvector_slice &operator +=(const cvector_slice &sl2)
1373 #if(CXSC_INDEX_CHECK)
1374  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1375 #else
1376  throw();
1377 #endif
1378  INLINE cvector_slice &operator -=(const cvector &rv)
1380 #if(CXSC_INDEX_CHECK)
1381  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1382 #else
1383  throw();
1384 #endif
1385  INLINE cvector_slice &operator -=(const cvector_slice &sl2)
1387 #if(CXSC_INDEX_CHECK)
1388  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1389 #else
1390  throw();
1391 #endif
1392  INLINE cvector_slice &operator |=(const cvector &rv)
1394 #if(CXSC_INDEX_CHECK)
1395  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1396 #else
1397  throw();
1398 #endif
1399  INLINE cvector_slice &operator |=(const cvector_slice &sl2)
1401 #if(CXSC_INDEX_CHECK)
1402  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1403 #else
1404  throw();
1405 #endif
1406  INLINE cvector_slice &operator &=(const cvector &rv)
1408 #if(CXSC_INDEX_CHECK)
1409  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1410 #else
1411  throw();
1412 #endif
1413  INLINE cvector_slice &operator &=(const cvector_slice &sl2)
1415 #if(CXSC_INDEX_CHECK)
1416  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1417 #else
1418  throw();
1419 #endif
1420 
1422  INLINE cvector_slice &operator +=(const rvector &rv)
1423 #if(CXSC_INDEX_CHECK)
1424  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1425 #else
1426  throw();
1427 #endif
1428  INLINE cvector_slice &operator +=(const rvector_slice &sl2)
1430 #if(CXSC_INDEX_CHECK)
1431  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1432 #else
1433  throw();
1434 #endif
1435  INLINE cvector_slice &operator -=(const rvector &rv)
1437 #if(CXSC_INDEX_CHECK)
1438  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1439 #else
1440  throw();
1441 #endif
1442  INLINE cvector_slice &operator -=(const rvector_slice &sl2)
1444 #if(CXSC_INDEX_CHECK)
1445  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1446 #else
1447  throw();
1448 #endif
1449  INLINE cvector_slice &operator |=(const rvector &rv)
1451 #if(CXSC_INDEX_CHECK)
1452  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1453 #else
1454  throw();
1455 #endif
1456  INLINE cvector_slice &operator |=(const rvector_slice &sl2)
1458 #if(CXSC_INDEX_CHECK)
1459  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1460 #else
1461  throw();
1462 #endif
1463  INLINE cvector_slice &operator &=(const rvector &rv)
1465 #if(CXSC_INDEX_CHECK)
1466  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1467 #else
1468  throw();
1469 #endif
1470  INLINE cvector_slice &operator &=(const rvector_slice &sl2)
1472 #if(CXSC_INDEX_CHECK)
1473  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1474 #else
1475  throw();
1476 #endif
1477  INLINE operator void*() throw();
1478 
1479  cvector_slice& operator+=(const srvector&);
1480  cvector_slice& operator+=(const scvector&);
1481  cvector_slice& operator+=(const srvector_slice&);
1482  cvector_slice& operator+=(const scvector_slice&);
1483  cvector_slice& operator-=(const srvector&);
1484  cvector_slice& operator-=(const scvector&);
1485  cvector_slice& operator-=(const srvector_slice&);
1486  cvector_slice& operator-=(const scvector_slice&);
1487 
1488 //#else
1489 //#endif
1490 };
1491 
1492 //=======================================================================
1493 //======================== Vector Functions =============================
1494 
1496  INLINE cvector _cvector(const complex &r) throw();
1497 // INLINE cvector _cvector(const cmatrix &m) throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
1498 // INLINE cvector _cvector(const cmatrix_slice &sl) throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
1500  INLINE cvector _cvector(const real &r) throw();
1502  INLINE cvector _cvector(const rvector_slice &rs) throw();
1504  INLINE cvector _cvector(const rvector &rs) throw();
1505 // INLINE cvector _cvector(const rmatrix &m) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
1506 // INLINE cvector _cvector(const rmatrix_slice &sl) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
1508  INLINE cvector _cvector(const rmatrix_subv &rs) throw();
1509 
1511  INLINE cvector &SetRe(cvector &iv,const rvector &rv)
1512 #if(CXSC_INDEX_CHECK)
1513  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1514 #else
1515  throw();
1516 #endif
1517  INLINE cvector_slice &SetRe(cvector_slice &iv,const rvector &rv)
1519 #if(CXSC_INDEX_CHECK)
1520  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1521 #else
1522  throw();
1523 #endif
1524  INLINE cvector &SetRe(cvector &iv,const rvector_slice &rv)
1526 #if(CXSC_INDEX_CHECK)
1527  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1528 #else
1529  throw();
1530 #endif
1531  INLINE cvector_slice &SetRe(cvector_slice &iv,const rvector_slice &rv)
1533 #if(CXSC_INDEX_CHECK)
1534  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1535 #else
1536  throw();
1537 #endif
1538 
1540  INLINE cvector &SetIm(cvector &iv,const rvector &rv)
1541 #if(CXSC_INDEX_CHECK)
1542  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1543 #else
1544  throw();
1545 #endif
1546  INLINE cvector_slice &SetIm(cvector_slice &iv,const rvector &rv)
1548 #if(CXSC_INDEX_CHECK)
1549  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1550 #else
1551  throw();
1552 #endif
1553  INLINE cvector &SetIm(cvector &iv,const rvector_slice &rv)
1555 #if(CXSC_INDEX_CHECK)
1556  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1557 #else
1558  throw();
1559 #endif
1560  INLINE cvector_slice &SetIm(cvector_slice &iv,const rvector_slice &rv)
1562 #if(CXSC_INDEX_CHECK)
1563  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1564 #else
1565  throw();
1566 #endif
1567 
1569  INLINE cvector &SetRe(cvector &iv,const real &r) throw();
1571  INLINE cvector &SetIm(cvector &iv,const real &r) throw();
1573  INLINE cvector_slice &SetRe(cvector_slice &iv,const real &r) throw();
1575  INLINE cvector_slice &SetIm(cvector_slice &iv,const real &r) throw();
1576 
1578  INLINE void Resize(cvector &rv) throw();
1580  INLINE void Resize(cvector &rv, const int &len)
1581 #if(CXSC_INDEX_CHECK)
1582  throw(ERROR__WRONG_BOUNDARIES<cvector>);
1583 #else
1584  throw();
1585 #endif
1586  INLINE void Resize(cvector &rv, const int &lb, const int &ub)
1588 #if(CXSC_INDEX_CHECK)
1589  throw(ERROR__WRONG_BOUNDARIES<cvector>);
1590 #else
1591  throw();
1592 #endif
1593 
1595  INLINE cvector conj(const cvector &rv) throw();
1597  INLINE cvector conj(const cvector_slice &sl) throw();
1598 
1600  INLINE rvector abs(const cvector &rv) throw();
1602  INLINE rvector abs(const cvector_slice &sl) throw();
1604  INLINE rvector Im(const cvector &v) throw();
1606  INLINE rvector Im(const cvector_slice &v) throw();
1608  INLINE rvector Re(const cvector &v) throw();
1610  INLINE rvector Re(const cvector_slice &v) throw();
1612  INLINE bool operator !(const cvector &rv) throw();
1614  INLINE bool operator !(const cvector_slice &sl) throw();
1615 
1616 //======================= Vector / Scalar ===============================
1617 
1618 //----------------------------- complex ---------------------------
1619 
1621  INLINE cvector operator *(const cvector &rv, const complex &s) throw();
1623  INLINE cvector operator *(const cvector_slice &sl, const complex &s) throw();
1625  INLINE cvector operator *(const complex &s, const cvector &rv) throw();
1627  INLINE cvector operator *(const complex &s, const cvector_slice &sl) throw();
1629  INLINE cvector &operator *=(cvector &rv,const complex &r) throw();
1630 
1632  INLINE cvector operator /(const cvector &rv, const complex &s) throw();
1634  INLINE cvector operator /(const cvector_slice &sl, const complex &s) throw();
1636  INLINE cvector &operator /=(cvector &rv,const complex &r) throw();
1637 
1638 //---------------------------- Real --------------------------------------
1639 
1641  INLINE cvector operator *(const cvector &rv, const real &s) throw();
1643  INLINE cvector operator *(const cvector_slice &sl, const real &s) throw();
1645  INLINE cvector operator *(const real &s, const cvector &rv) throw();
1647  INLINE cvector operator *(const real &s, const cvector_slice &sl) throw();
1649  INLINE cvector &operator *=(cvector &rv,const real &r) throw();
1650 
1652  INLINE cvector operator /(const cvector &rv, const real &s) throw();
1654  INLINE cvector operator /(const cvector_slice &sl, const real &s) throw();
1656  INLINE cvector &operator /=(cvector &rv,const real &r) throw();
1657 
1659  INLINE cvector operator *(const rvector &rv, const complex &s) throw();
1661  INLINE cvector operator *(const rvector_slice &sl, const complex &s) throw();
1663  INLINE cvector operator *(const complex &s, const rvector &rv) throw();
1665  INLINE cvector operator *(const complex &s, const rvector_slice &sl) throw();
1666 
1668  INLINE cvector operator /(const rvector &rv, const complex &s) throw();
1670  INLINE cvector operator /(const rvector_slice &sl, const complex &s) throw();
1671 
1672 //======================= Vector / Vector ===============================
1673 
1674 
1676  INLINE std::ostream &operator <<(std::ostream &s, const cvector &rv) throw();
1678  INLINE std::ostream &operator <<(std::ostream &o, const cvector_slice &sl) throw();
1680  INLINE std::istream &operator >>(std::istream &s, cvector &rv) throw();
1682  INLINE std::istream &operator >>(std::istream &s, cvector_slice &rv) throw();
1683 
1684 //----------------------- complex / complex ---------------------------
1685 
1687  void accumulate(cdotprecision &dp, const cvector &);
1688 
1690  void accumulate(cdotprecision &dp, const rvector &);
1691 
1693  void accumulate(cdotprecision &dp, const cvector & rv1, const cvector &rv2)
1694 #if(CXSC_INDEX_CHECK)
1695  throw(OP_WITH_WRONG_DIM);
1696 #else
1697  throw();
1698 #endif
1699 
1701  void accumulate_approx(cdotprecision &dp, const cvector & rv1, const cvector &rv2);
1702 
1704  void accumulate(cdotprecision &dp, const cvector_slice & sl, const cvector &rv)
1705 #if(CXSC_INDEX_CHECK)
1706  throw(OP_WITH_WRONG_DIM);
1707 #else
1708  throw();
1709 #endif
1710 
1712  void accumulate_approx(cdotprecision &dp, const cvector_slice & sl, const cvector &rv);
1713 
1715  void accumulate(cdotprecision &dp, const cvector &rv, const cvector_slice &sl)
1716 #if(CXSC_INDEX_CHECK)
1717  throw(OP_WITH_WRONG_DIM);
1718 #else
1719  throw();
1720 #endif
1721 
1723  void accumulate_approx(cdotprecision &dp, const cvector &rv, const cvector_slice &sl);
1724 
1726  void accumulate(cdotprecision &dp, const cvector & rv1, const cmatrix_subv &rv2)
1727 #if(CXSC_INDEX_CHECK)
1728  throw(OP_WITH_WRONG_DIM);
1729 #else
1730  throw();
1731 #endif
1732 
1734  void accumulate_approx(cdotprecision &dp, const cvector & rv1, const cmatrix_subv &rv2);
1735 
1737  void accumulate(cdotprecision &dp, const cmatrix_subv & rv1, const cvector &rv2)
1738 #if(CXSC_INDEX_CHECK)
1739  throw(OP_WITH_WRONG_DIM);
1740 #else
1741  throw();
1742 #endif
1743 
1745  void accumulate_approx(cdotprecision &dp, const cmatrix_subv & rv1, const cvector &rv2);
1746 
1748  void accumulate(cdotprecision &dp, const cmatrix_subv & rv1, const cmatrix_subv &rv2)
1749 #if(CXSC_INDEX_CHECK)
1750  throw(OP_WITH_WRONG_DIM);
1751 #else
1752  throw();
1753 #endif
1754 
1756  void accumulate_approx(cdotprecision &dp, const cmatrix_subv & rv1, const cmatrix_subv &rv2);
1757 
1759  void accumulate(cdotprecision &dp, const cvector_slice & sl1, const cvector_slice &sl2)
1760 #if(CXSC_INDEX_CHECK)
1761  throw(OP_WITH_WRONG_DIM);
1762 #else
1763  throw();
1764 #endif
1765 
1767  void accumulate_approx(cdotprecision &dp, const cvector_slice & sl1, const cvector_slice &sl2);
1768 
1770  void accumulate(cidotprecision &dp, const cvector & rv1, const cvector &rv2)
1771 #if(CXSC_INDEX_CHECK)
1772  throw(OP_WITH_WRONG_DIM);
1773 #else
1774  throw();
1775 #endif
1776  void accumulate(cidotprecision &dp, const cvector_slice & sl, const cvector &rv)
1778 #if(CXSC_INDEX_CHECK)
1779  throw(OP_WITH_WRONG_DIM);
1780 #else
1781  throw();
1782 #endif
1783  void accumulate(cidotprecision &dp, const cvector &rv, const cvector_slice &sl)
1785 #if(CXSC_INDEX_CHECK)
1786  throw(OP_WITH_WRONG_DIM);
1787 #else
1788  throw();
1789 #endif
1790  void accumulate(cidotprecision &dp, const cvector & rv1, const cmatrix_subv &rv2)
1792 #if(CXSC_INDEX_CHECK)
1793  throw(OP_WITH_WRONG_DIM);
1794 #else
1795  throw();
1796 #endif
1797  void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const cvector &rv2)
1799 #if(CXSC_INDEX_CHECK)
1800  throw(OP_WITH_WRONG_DIM);
1801 #else
1802  throw();
1803 #endif
1804  void accumulate(cidotprecision &dp, const cvector_slice & sl1, const cvector_slice &sl2)
1806 #if(CXSC_INDEX_CHECK)
1807  throw(OP_WITH_WRONG_DIM);
1808 #else
1809  throw();
1810 #endif
1811  void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const cmatrix_subv &rv2)
1813 #if(CXSC_INDEX_CHECK)
1814  throw(OP_WITH_WRONG_DIM);
1815 #else
1816  throw();
1817 #endif
1818 
1819 
1821  INLINE complex operator *(const cvector & rv1, const cvector &rv2)
1822 #if(CXSC_INDEX_CHECK)
1823  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1824 #else
1825  throw();
1826 #endif
1827  INLINE complex operator *(const cvector_slice &sl, const cvector &rv)
1829 #if(CXSC_INDEX_CHECK)
1830  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1831 #else
1832  throw();
1833 #endif
1834  INLINE complex operator *(const cvector &rv, const cvector_slice &sl)
1836 #if(CXSC_INDEX_CHECK)
1837  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1838 #else
1839  throw();
1840 #endif
1841  INLINE complex operator *(const cvector_slice & sl1, const cvector_slice &sl2)
1843 #if(CXSC_INDEX_CHECK)
1844  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1845 #else
1846  throw();
1847 #endif
1848 
1850  INLINE const cvector &operator +(const cvector &rv) throw();
1852  INLINE cvector operator +(const cvector_slice &sl) throw();
1853 
1855  INLINE cvector operator +(const cvector &rv1, const cvector &rv2)
1856 #if(CXSC_INDEX_CHECK)
1857  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1858 #else
1859  throw();
1860 #endif
1861  INLINE cvector operator +(const cvector &rv, const cvector_slice &sl)
1863 #if(CXSC_INDEX_CHECK)
1864  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1865 #else
1866  throw();
1867 #endif
1868  INLINE cvector operator +(const cvector_slice &sl, const cvector &rv)
1870 #if(CXSC_INDEX_CHECK)
1871  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1872 #else
1873  throw();
1874 #endif
1875  INLINE cvector operator +(const cvector_slice &sl1, const cvector_slice &sl2)
1877 #if(CXSC_INDEX_CHECK)
1878  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1879 #else
1880  throw();
1881 #endif
1882  INLINE cvector & operator +=(cvector &rv1, const cvector &rv2)
1884 #if(CXSC_INDEX_CHECK)
1885  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1886 #else
1887  throw();
1888 #endif
1889  INLINE cvector &operator +=(cvector &rv, const cvector_slice &sl)
1891 #if(CXSC_INDEX_CHECK)
1892  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1893 #else
1894  throw();
1895 #endif
1896 
1898  INLINE cvector operator -(const cvector &rv) throw();
1900  INLINE cvector operator -(const cvector_slice &sl) throw();
1902  INLINE cvector operator -(const cvector &rv1, const cvector &rv2)
1903 #if(CXSC_INDEX_CHECK)
1904  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1905 #else
1906  throw();
1907 #endif
1908  INLINE cvector operator -(const cvector &rv, const cvector_slice &sl)
1910 #if(CXSC_INDEX_CHECK)
1911  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1912 #else
1913  throw();
1914 #endif
1915  INLINE cvector operator -(const cvector_slice &sl, const cvector &rv)
1917 #if(CXSC_INDEX_CHECK)
1918  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1919 #else
1920  throw();
1921 #endif
1922  INLINE cvector operator -(const cvector_slice &sl1, const cvector_slice &sl2)
1924 #if(CXSC_INDEX_CHECK)
1925  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1926 #else
1927  throw();
1928 #endif
1929  INLINE cvector & operator -=(cvector &rv1, const cvector &rv2)
1931 #if(CXSC_INDEX_CHECK)
1932  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1933 #else
1934  throw();
1935 #endif
1936  INLINE cvector &operator -=(cvector &rv, const cvector_slice &sl)
1938 #if(CXSC_INDEX_CHECK)
1939  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
1940 #else
1941  throw();
1942 #endif
1943 
1945  INLINE bool operator ==(const cvector &rv1, const cvector &rv2) throw();
1947  INLINE bool operator ==(const cvector_slice &sl1, const cvector_slice &sl2) throw();
1949  INLINE bool operator ==(const cvector_slice &sl, const cvector &rv) throw();
1951  INLINE bool operator ==(const cvector &rv, const cvector_slice &sl) throw();
1953  INLINE bool operator !=(const cvector &rv1, const cvector &rv2) throw();
1955  INLINE bool operator !=(const cvector_slice &sl1, const cvector_slice &sl2) throw();
1957  INLINE bool operator !=(const cvector_slice &sl, const cvector &rv) throw();
1959  INLINE bool operator !=(const cvector &rv, const cvector_slice &sl) throw();
1960 /* INLINE bool operator <(const cvector &rv1, const cvector &rv2) throw();
1961  INLINE bool operator <(const cvector_slice &sl1, const cvector_slice &sl2) throw();
1962  INLINE bool operator < (const cvector_slice &sl, const cvector &rv) throw();
1963  INLINE bool operator < (const cvector &rv, const cvector_slice &sl) throw();
1964  INLINE bool operator <=(const cvector &rv1, const cvector &rv2) throw();
1965  INLINE bool operator <=(const cvector_slice &sl1, const cvector_slice &sl2) throw();
1966  INLINE bool operator <=(const cvector_slice &sl, const cvector &rv) throw();
1967  INLINE bool operator <=(const cvector &rv, const cvector_slice &sl) throw();
1968  INLINE bool operator >(const cvector &rv1, const cvector &rv2) throw();
1969  INLINE bool operator >(const cvector_slice &sl1, const cvector_slice &sl2) throw();
1970  INLINE bool operator >(const cvector_slice &sl, const cvector &rv) throw();
1971  INLINE bool operator >(const cvector &rv, const cvector_slice &sl) throw();
1972  INLINE bool operator >=(const cvector &rv1, const cvector &rv2) throw();
1973  INLINE bool operator >=(const cvector_slice &sl1, const cvector_slice &sl2) throw();
1974  INLINE bool operator >=(const cvector_slice &sl, const cvector &rv) throw();
1975  INLINE bool operator >=(const cvector &rv, const cvector_slice &sl) throw();
1976 */
1977 //-------------------------------- complex / Real --------------------------------
1978 
1979 
1981  void accumulate(cdotprecision &dp, const cvector & rv1, const rvector &rv2)
1982 #if(CXSC_INDEX_CHECK)
1983  throw(OP_WITH_WRONG_DIM);
1984 #else
1985  throw();
1986 #endif
1987 
1989  void accumulate_approx(cdotprecision &dp, const cvector & rv1, const rvector &rv2);
1990 
1991 
1993  void accumulate(cdotprecision &dp, const rvector & rv1, const cvector &rv2)
1994 #if(CXSC_INDEX_CHECK)
1995  throw(OP_WITH_WRONG_DIM);
1996 #else
1997  throw();
1998 #endif
1999 
2001  void accumulate_approx(cdotprecision &dp, const rvector & rv1, const cvector &rv2);
2002 
2004  void accumulate(cdotprecision &dp, const rvector_slice & sl, const cvector &rv)
2005 #if(CXSC_INDEX_CHECK)
2006  throw(OP_WITH_WRONG_DIM);
2007 #else
2008  throw();
2009 #endif
2010 
2012  void accumulate_approx(cdotprecision &dp, const rvector_slice & sl, const cvector &rv);
2013 
2015  void accumulate(cdotprecision &dp,const cvector_slice &sl,const rvector &rv)
2016 #if(CXSC_INDEX_CHECK)
2017  throw(OP_WITH_WRONG_DIM);
2018 #else
2019  throw();
2020 #endif
2021 
2023  void accumulate_approx(cdotprecision &dp,const cvector_slice &sl,const rvector &rv);
2024 
2026  void accumulate(cdotprecision &dp, const rvector &rv, const cvector_slice &sl)
2027 #if(CXSC_INDEX_CHECK)
2028  throw(OP_WITH_WRONG_DIM);
2029 #else
2030  throw();
2031 #endif
2032 
2034  void accumulate_approx(cdotprecision &dp, const rvector &rv, const cvector_slice &sl);
2035 
2037  void accumulate(cdotprecision &dp, const rvector & rv1, const cmatrix_subv &rv2)
2038 #if(CXSC_INDEX_CHECK)
2039  throw(OP_WITH_WRONG_DIM);
2040 #else
2041  throw();
2042 #endif
2043 
2045  void accumulate_approx(cdotprecision &dp, const rvector & rv1, const cmatrix_subv &rv2);
2046 
2048  void accumulate(cdotprecision &dp, const cvector & rv1, const rmatrix_subv &rv2)
2049 #if(CXSC_INDEX_CHECK)
2050  throw(OP_WITH_WRONG_DIM);
2051 #else
2052  throw();
2053 #endif
2054 
2056  void accumulate_approx(cdotprecision &dp, const cvector & rv1, const rmatrix_subv &rv2);
2057 
2059  void accumulate(cdotprecision &dp, const rvector_slice & rv1, const cmatrix_subv &rv2)
2060 #if(CXSC_INDEX_CHECK)
2061  throw(OP_WITH_WRONG_DIM);
2062 #else
2063  throw();
2064 #endif
2065 
2067  void accumulate_approx(cdotprecision &dp, const rvector_slice & rv1, const cmatrix_subv &rv2);
2068 
2070  void accumulate(cdotprecision &dp, const cvector_slice & rv1, const rmatrix_subv &rv2)
2071 #if(CXSC_INDEX_CHECK)
2072  throw(OP_WITH_WRONG_DIM);
2073 #else
2074  throw();
2075 #endif
2076 
2078  void accumulate_approx(cdotprecision &dp, const cvector_slice & rv1, const rmatrix_subv &rv2);
2079 
2081  void accumulate(cdotprecision &dp,const cvector &rv,const rvector_slice &sl)
2082 #if(CXSC_INDEX_CHECK)
2083  throw(OP_WITH_WRONG_DIM);
2084 #else
2085  throw();
2086 #endif
2087 
2089  void accumulate_approx(cdotprecision &dp,const cvector &rv,const rvector_slice &sl);
2090 
2092  void accumulate(cdotprecision &dp, const rmatrix_subv & rv1, const cvector &rv2)
2093 #if(CXSC_INDEX_CHECK)
2094  throw(OP_WITH_WRONG_DIM);
2095 #else
2096  throw();
2097 #endif
2098 
2100  void accumulate_approx(cdotprecision &dp, const rmatrix_subv & rv1, const cvector &rv2);
2101 
2103  void accumulate(cdotprecision &dp, const cmatrix_subv & rv1, const rvector &rv2)
2104 #if(CXSC_INDEX_CHECK)
2105  throw(OP_WITH_WRONG_DIM);
2106 #else
2107  throw();
2108 #endif
2109 
2111  void accumulate_approx(cdotprecision &dp, const cmatrix_subv & rv1, const rvector &rv2);
2112 
2114  void accumulate(cdotprecision &dp, const rmatrix_subv & rv1, const cvector_slice &rv2)
2115 #if(CXSC_INDEX_CHECK)
2116  throw(OP_WITH_WRONG_DIM);
2117 #else
2118  throw();
2119 #endif
2120 
2122  void accumulate_approx(cdotprecision &dp, const rmatrix_subv & rv1, const cvector_slice &rv2);
2123 
2125  void accumulate(cdotprecision &dp, const cmatrix_subv & rv1, const rvector_slice &rv2)
2126 #if(CXSC_INDEX_CHECK)
2127  throw(OP_WITH_WRONG_DIM);
2128 #else
2129  throw();
2130 #endif
2131 
2133  void accumulate_approx(cdotprecision &dp, const cmatrix_subv & rv1, const rvector_slice &rv2);
2134 
2136  void accumulate(cdotprecision &dp, const cvector_slice & sl1, const rvector_slice &sl2)
2137 #if(CXSC_INDEX_CHECK)
2138  throw(OP_WITH_WRONG_DIM);
2139 #else
2140  throw();
2141 #endif
2142 
2144  void accumulate_approx(cdotprecision &dp, const cvector_slice & sl1, const rvector_slice &sl2);
2145 
2147  void accumulate(cdotprecision &dp, const rvector_slice & sl1, const cvector_slice &sl2)
2148 #if(CXSC_INDEX_CHECK)
2149  throw(OP_WITH_WRONG_DIM);
2150 #else
2151  throw();
2152 #endif
2153 
2155  void accumulate_approx(cdotprecision &dp, const rvector_slice & sl1, const cvector_slice &sl2);
2156 
2158  void accumulate(cdotprecision &dp, const rmatrix_subv & rv1, const cmatrix_subv &rv2)
2159 #if(CXSC_INDEX_CHECK)
2160  throw(OP_WITH_WRONG_DIM);
2161 #else
2162  throw();
2163 #endif
2164 
2166  void accumulate_approx(cdotprecision &dp, const rmatrix_subv & rv1, const cmatrix_subv &rv2);
2167 
2169  void accumulate(cdotprecision &dp, const cmatrix_subv & rv1, const rmatrix_subv &rv2)
2170 #if(CXSC_INDEX_CHECK)
2171  throw(OP_WITH_WRONG_DIM);
2172 #else
2173  throw();
2174 #endif
2175 
2177  void accumulate_approx(cdotprecision &dp, const cmatrix_subv & rv1, const rmatrix_subv &rv2);
2178 
2180  void accumulate(cidotprecision &dp, const cvector & rv1, const rvector &rv2)
2181 #if(CXSC_INDEX_CHECK)
2182  throw(OP_WITH_WRONG_DIM);
2183 #else
2184  throw();
2185 #endif
2186  void accumulate(cidotprecision &dp, const rvector & rv1, const cvector &rv2)
2188 #if(CXSC_INDEX_CHECK)
2189  throw(OP_WITH_WRONG_DIM);
2190 #else
2191  throw();
2192 #endif
2193  void accumulate(cidotprecision &dp, const rvector_slice & sl, const cvector &rv)
2195 #if(CXSC_INDEX_CHECK)
2196  throw(OP_WITH_WRONG_DIM);
2197 #else
2198  throw();
2199 #endif
2200  void accumulate(cidotprecision &dp,const cvector_slice &sl,const rvector &rv)
2202 #if(CXSC_INDEX_CHECK)
2203  throw(OP_WITH_WRONG_DIM);
2204 #else
2205  throw();
2206 #endif
2207  void accumulate(cidotprecision &dp, const rvector &rv, const cvector_slice &sl)
2209 #if(CXSC_INDEX_CHECK)
2210  throw(OP_WITH_WRONG_DIM);
2211 #else
2212  throw();
2213 #endif
2214  void accumulate(cidotprecision &dp, const rvector & rv1, const cmatrix_subv &rv2)
2216 #if(CXSC_INDEX_CHECK)
2217  throw(OP_WITH_WRONG_DIM);
2218 #else
2219  throw();
2220 #endif
2221  void accumulate(cidotprecision &dp, const cvector & rv1, const rmatrix_subv &rv2)
2223 #if(CXSC_INDEX_CHECK)
2224  throw(OP_WITH_WRONG_DIM);
2225 #else
2226  throw();
2227 #endif
2228  void accumulate(cidotprecision &dp, const rvector_slice & rv1, const cmatrix_subv &rv2)
2230 #if(CXSC_INDEX_CHECK)
2231  throw(OP_WITH_WRONG_DIM);
2232 #else
2233  throw();
2234 #endif
2235  void accumulate(cidotprecision &dp, const cvector_slice & rv1, const rmatrix_subv &rv2)
2237 #if(CXSC_INDEX_CHECK)
2238  throw(OP_WITH_WRONG_DIM);
2239 #else
2240  throw();
2241 #endif
2242  void accumulate(cidotprecision &dp,const cvector &rv,const rvector_slice &sl)
2244 #if(CXSC_INDEX_CHECK)
2245  throw(OP_WITH_WRONG_DIM);
2246 #else
2247  throw();
2248 #endif
2249  void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const cvector &rv2)
2251 #if(CXSC_INDEX_CHECK)
2252  throw(OP_WITH_WRONG_DIM);
2253 #else
2254  throw();
2255 #endif
2256  void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const rvector &rv2)
2258 #if(CXSC_INDEX_CHECK)
2259  throw(OP_WITH_WRONG_DIM);
2260 #else
2261  throw();
2262 #endif
2263  void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const cvector_slice &rv2)
2265 #if(CXSC_INDEX_CHECK)
2266  throw(OP_WITH_WRONG_DIM);
2267 #else
2268  throw();
2269 #endif
2270  void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const rvector_slice &rv2)
2272 #if(CXSC_INDEX_CHECK)
2273  throw(OP_WITH_WRONG_DIM);
2274 #else
2275  throw();
2276 #endif
2277  void accumulate(cidotprecision &dp, const cvector_slice & sl1, const rvector_slice &sl2)
2279 #if(CXSC_INDEX_CHECK)
2280  throw(OP_WITH_WRONG_DIM);
2281 #else
2282  throw();
2283 #endif
2284  void accumulate(cidotprecision &dp, const rvector_slice & sl1, const cvector_slice &sl2)
2286 #if(CXSC_INDEX_CHECK)
2287  throw(OP_WITH_WRONG_DIM);
2288 #else
2289  throw();
2290 #endif
2291  void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const cmatrix_subv &rv2)
2293 #if(CXSC_INDEX_CHECK)
2294  throw(OP_WITH_WRONG_DIM);
2295 #else
2296  throw();
2297 #endif
2298  void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const rmatrix_subv &rv2)
2300 #if(CXSC_INDEX_CHECK)
2301  throw(OP_WITH_WRONG_DIM);
2302 #else
2303  throw();
2304 #endif
2305  void accumulate(cidotprecision &dp, const cvector_slice &, const ivector &)
2307 #if(CXSC_INDEX_CHECK)
2308  throw(OP_WITH_WRONG_DIM);
2309 #else
2310  throw();
2311 #endif
2312  void accumulate(cidotprecision &dp, const ivector & sl1, const cvector_slice &)
2314 #if(CXSC_INDEX_CHECK)
2315  throw(OP_WITH_WRONG_DIM);
2316 #else
2317  throw();
2318 #endif
2319  void accumulate(cidotprecision &dp, const cvector &, const ivector &)
2321 #if(CXSC_INDEX_CHECK)
2322  throw(OP_WITH_WRONG_DIM);
2323 #else
2324  throw();
2325 #endif
2326  void accumulate(cidotprecision &dp, const ivector &, const cvector &)
2328 #if(CXSC_INDEX_CHECK)
2329  throw(OP_WITH_WRONG_DIM);
2330 #else
2331  throw();
2332 #endif
2333  void accumulate(cidotprecision &dp, const ivector_slice &, const cvector &)
2335 #if(CXSC_INDEX_CHECK)
2336  throw(OP_WITH_WRONG_DIM);
2337 #else
2338  throw();
2339 #endif
2340  void accumulate(cidotprecision &dp, const cvector &, const ivector_slice &)
2342 #if(CXSC_INDEX_CHECK)
2343  throw(OP_WITH_WRONG_DIM);
2344 #else
2345  throw();
2346 #endif
2347  void accumulate(cidotprecision &dp, const cvector_slice &, const ivector_slice &)
2349 #if(CXSC_INDEX_CHECK)
2350  throw(OP_WITH_WRONG_DIM);
2351 #else
2352  throw();
2353 #endif
2354  void accumulate(cidotprecision &dp, const ivector_slice &, const cvector_slice &)
2356 #if(CXSC_INDEX_CHECK)
2357  throw(OP_WITH_WRONG_DIM);
2358 #else
2359  throw();
2360 #endif
2361 
2363  INLINE complex operator *(const rvector & rv1, const cvector &rv2)
2364 #if(CXSC_INDEX_CHECK)
2365  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
2366 #else
2367  throw();
2368 #endif
2369  INLINE complex operator *(const rvector_slice &sl, const cvector &rv)
2371 #if(CXSC_INDEX_CHECK)
2372  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
2373 #else
2374  throw();
2375 #endif
2376  INLINE complex operator *(const rvector &rv, const cvector_slice &sl)
2378 #if(CXSC_INDEX_CHECK)
2379  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
2380 #else
2381  throw();
2382 #endif
2383  INLINE complex operator *(const rvector_slice & sl1, const cvector_slice &sl2)
2385 #if(CXSC_INDEX_CHECK)
2386  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
2387 #else
2388  throw();
2389 #endif
2390 
2392  INLINE complex operator *(const cvector & rv1, const rvector &rv2)
2393 #if(CXSC_INDEX_CHECK)
2394  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
2395 #else
2396  throw();
2397 #endif
2398  INLINE complex operator *(const cvector_slice &sl, const rvector &rv)
2400 #if(CXSC_INDEX_CHECK)
2401  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
2402 #else
2403  throw();
2404 #endif
2405  INLINE complex operator *(const cvector &rv, const rvector_slice &sl)
2407 #if(CXSC_INDEX_CHECK)
2408  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
2409 #else
2410  throw();
2411 #endif
2412  INLINE complex operator *(const cvector_slice & sl1, const rvector_slice &sl2)
2414 #if(CXSC_INDEX_CHECK)
2415  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
2416 #else
2417  throw();
2418 #endif
2419 
2421  INLINE cvector operator +(const rvector &rv1, const cvector &rv2)
2422 #if(CXSC_INDEX_CHECK)
2423  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
2424 #else
2425  throw();
2426 #endif
2427  INLINE cvector operator +(const rvector &rv, const cvector_slice &sl)
2429 #if(CXSC_INDEX_CHECK)
2430  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
2431 #else
2432  throw();
2433 #endif
2434  INLINE cvector operator +(const rvector_slice &sl, const cvector &rv)
2436 #if(CXSC_INDEX_CHECK)
2437  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
2438 #else
2439  throw();
2440 #endif
2441  INLINE cvector operator +(const rvector_slice &sl1, const cvector_slice &sl2)
2443 #if(CXSC_INDEX_CHECK)
2444  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
2445 #else
2446  throw();
2447 #endif
2448 
2450  INLINE cvector operator +(const cvector &rv1, const rvector &rv2)
2451 #if(CXSC_INDEX_CHECK)
2452  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
2453 #else
2454  throw();
2455 #endif
2456  INLINE cvector operator +(const cvector &rv, const rvector_slice &sl)
2458 #if(CXSC_INDEX_CHECK)
2459  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
2460 #else
2461  throw();
2462 #endif
2463  INLINE cvector operator +(const cvector_slice &sl, const rvector &rv)
2465 #if(CXSC_INDEX_CHECK)
2466  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
2467 #else
2468  throw();
2469 #endif
2470  INLINE cvector operator +(const cvector_slice &sl1, const rvector_slice &sl2)
2472 #if(CXSC_INDEX_CHECK)
2473  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
2474 #else
2475  throw();
2476 #endif
2477 
2479  INLINE cvector & operator +=(cvector &rv1, const rvector &rv2)
2480 #if(CXSC_INDEX_CHECK)
2481  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
2482 #else
2483  throw();
2484 #endif
2485  INLINE cvector &operator +=(cvector &rv, const rvector_slice &sl)
2487 #if(CXSC_INDEX_CHECK)
2488  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
2489 #else
2490  throw();
2491 #endif
2492 
2494  INLINE cvector operator -(const rvector &rv1, const cvector &rv2)
2495 #if(CXSC_INDEX_CHECK)
2496  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
2497 #else
2498  throw();
2499 #endif
2500  INLINE cvector operator -(const rvector &rv, const cvector_slice &sl)
2502 #if(CXSC_INDEX_CHECK)
2503  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
2504 #else
2505  throw();
2506 #endif
2507  INLINE cvector operator -(const rvector_slice &sl, const cvector &rv)
2509 #if(CXSC_INDEX_CHECK)
2510  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
2511 #else
2512  throw();
2513 #endif
2514  INLINE cvector operator -(const rvector_slice &sl1, const cvector_slice &sl2)
2516 #if(CXSC_INDEX_CHECK)
2517  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
2518 #else
2519  throw();
2520 #endif
2521 
2523  INLINE cvector operator -(const cvector &rv1, const rvector &rv2)
2524 #if(CXSC_INDEX_CHECK)
2525  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
2526 #else
2527  throw();
2528 #endif
2529  INLINE cvector operator -(const cvector &rv, const rvector_slice &sl)
2531 #if(CXSC_INDEX_CHECK)
2532  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
2533 #else
2534  throw();
2535 #endif
2536  INLINE cvector operator -(const cvector_slice &sl, const rvector &rv)
2538 #if(CXSC_INDEX_CHECK)
2539  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
2540 #else
2541  throw();
2542 #endif
2543  INLINE cvector operator -(const cvector_slice &sl1, const rvector_slice &sl2)
2545 #if(CXSC_INDEX_CHECK)
2546  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
2547 #else
2548  throw();
2549 #endif
2550  INLINE cvector & operator -=(cvector &rv1, const rvector &rv2)
2552 #if(CXSC_INDEX_CHECK)
2553  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
2554 #else
2555  throw();
2556 #endif
2557  INLINE cvector &operator -=(cvector &rv, const rvector_slice &sl)
2559 #if(CXSC_INDEX_CHECK)
2560  throw(ERROR__OP_WITH_WRONG_DIM<cvector>);
2561 #else
2562  throw();
2563 #endif
2564 
2565 } // namespace cxsc
2566 
2567 #ifdef _CXSC_INCL_INL
2568 #include "vector.inl"
2569 #include "cvector.inl"
2570 #endif
2571 
2572 #ifdef _CXSC_RMATRIX_HPP_INCLUDED
2573 # ifdef _CXSC_INCL_INL
2574 # include "cvecrmat.inl"
2575 # else
2576 # include "cvecrmat.hpp"
2577 # endif
2578 #endif
2579 
2580 #ifdef _CXSC_IMATRIX_HPP_INCLUDED
2581 # ifdef _CXSC_INCL_INL
2582 # include "cvecimat.inl"
2583 # else
2584 # include "cvecimat.hpp"
2585 # endif
2586 #endif
2587 
2588 #ifdef _CXSC_IVECTOR_HPP_INCLUDED
2589 # ifdef _CXSC_INCL_INL
2590 # include "iveccvec.inl"
2591 # else
2592 # include "iveccvec.hpp"
2593 # endif
2594 #endif
2595 
2596 #ifdef CXSC_USE_BLAS
2597 #define _CXSC_BLAS_CVECTOR
2598 #include "cxsc_blas.inl"
2599 #endif
2600 
2601 
2602 #endif
The Data Type rmatrix_slice.
Definition: rmatrix.hpp:1442
cimatrix & operator/=(cimatrix &m, const cinterval &c)
Implementation of division and allocation operation.
Definition: cimatrix.inl:1623
friend int Lb(const cvector &rv)
Returns the lower bound of the vector.
Definition: cvector.hpp:791
Helper class for slices of sparse vectors.
Definition: scvector.hpp:1245
friend cvector & SetLb(cvector &rv, const int &l)
Sets the lower bound of the vector.
Definition: cvector.hpp:797
The Data Type intmatrix.
Definition: intmatrix.hpp:313
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
civector operator*(const cimatrix_subv &rv, const cinterval &s)
Implementation of multiplication operation.
Definition: cimatrix.inl:731
friend int Ub(const cvector &rv)
Returns the upper bound of the vector.
Definition: cvector.hpp:793
friend int Ub(const cvector_slice &sl)
Returns the upper bound of the vector.
Definition: cvector.hpp:1306
The Data Type civector.
Definition: civector.hpp:56
void accumulate_approx(cdotprecision &dp, const cmatrix_subv &rv1, const cmatrix_subv &rv2)
The accurate scalar product of the last two arguments added to the value of the first argument (witho...
Definition: cmatrix.cpp:99
cvector & operator()()
Operator for accessing the whole vector.
Definition: cvector.hpp:817
cvector & operator=(const cvector &rv)
Implementation of standard assigning operator.
Definition: cvector.inl:276
cvector_slice(cvector_slice &a, const int &lb, const int &ub)
Constructor of class cvector_slice.
Definition: cvector.hpp:1155
The Data Type ivector_slice.
Definition: ivector.hpp:962
The Data Type cidotprecision.
Definition: cidot.hpp:57
A sparse real vector.
Definition: srvector.hpp:58
The Data Type rvector_slice.
Definition: rvector.hpp:1063
A sparse complex vector.
Definition: scvector.hpp:58
The Data Type cvector.
Definition: cvector.hpp:57
cvector_slice(cvector &a, const int &lb, const int &ub)
Constructor of class cvector_slice.
Definition: cvector.hpp:1153
The Data Type rmatrix_subv.
Definition: rmatrix.hpp:53
The Data Type rvector.
Definition: rvector.hpp:57
friend int VecLen(const cvector_slice &sl)
Returns the dimension of the vector.
Definition: cvector.hpp:1308
The Data Type cmatrix.
Definition: cmatrix.hpp:513
The Data Type cdotprecision.
Definition: cdot.hpp:60
void Resize(cimatrix &A)
Resizes the matrix.
Definition: cimatrix.inl:1211
The Data Type rmatrix.
Definition: rmatrix.hpp:470
friend int VecLen(const cvector &rv)
Returns the dimension of the vector.
Definition: cvector.hpp:795
The Scalar Type complex.
Definition: complex.hpp:49
The Data Type cmatrix_subv.
Definition: cmatrix.hpp:53
cvector()
Constructor of class cvector.
Definition: cvector.inl:31
The Data Type ivector.
Definition: ivector.hpp:54
The Data Type cmatrix_slice.
Definition: cmatrix.hpp:1202
friend cvector & SetUb(cvector &rv, const int &u)
Sets the upper bound of the vector.
Definition: cvector.hpp:799
complex(void)
Constructor of class complex.
Definition: complex.hpp:59
Helper class for slices of sparse vectors.
Definition: srvector.hpp:868
civector operator/(const cimatrix_subv &rv, const cinterval &s)
Implementation of division operation.
Definition: cimatrix.inl:730
The Data Type cvector_slice.
Definition: cvector.hpp:844
cimatrix & operator*=(cimatrix &m, const cinterval &c)
Implementation of multiplication and allocation operation.
Definition: cimatrix.inl:1605
The Scalar Type real.
Definition: real.hpp:113
cvector_slice(const cvector_slice &a)
Constructor of class cvector_slice.
Definition: cvector.hpp:1158
The Data Type intvector.
Definition: intvector.hpp:51
The Data Type cimatrix.
Definition: cimatrix.hpp:907
ivector abs(const cimatrix_subv &mv)
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737
complex & operator[](const int &i) const
Operator for accessing the single elements of the vector (read-only)
Definition: cvector.inl:126