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 ;
77 #else
78  noexcept;
79 #endif
80 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
81 #if(CXSC_INDEX_CHECK)
82 ;
83 #else
84  noexcept;
85 #endif
86  template <class V> friend void _vresize(V &rv) noexcept;
87  template <class V,class S> friend void _vresize(V &rv, const int &len)
88 #if(CXSC_INDEX_CHECK)
89  ;
90 #else
91  noexcept;
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  ;
96 #else
97  noexcept;
98 #endif
99  template <class V1,class V2,class S> friend V1 &_vvassign(V1 &rv1,const V2 &rv2) noexcept;
100  template <class V,class S> friend V & _vsassign(V &rv,const S &r) noexcept;
101  template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) noexcept;
102  template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv)
103 #if(CXSC_INDEX_CHECK)
104  ;
105 #else
106  noexcept;
107 #endif
108 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m)
109 #if(CXSC_INDEX_CHECK)
110 ;
111 #else
112  noexcept;
113 #endif
114 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) noexcept;
115  template <class V> friend V _vconj(const V &rv) noexcept;
116  template <class VS,class E> friend E _vsconj(const VS &sl) noexcept;
117  template <class V,class E> friend E _vabs(const V &rv) noexcept;
118  template <class VS,class E> friend E _vsabs(const VS &sl) noexcept;
119 template <class MV,class V> friend V _mvabs(const MV &mv) noexcept;
120  template <class V,class E> friend E _vim(const V &rv) noexcept;
121  template <class V,class E> friend E _vre(const V &rv) noexcept;
122  template <class V1,class V2> friend V1 &_vvsetim(V1 &rv1, const V2 &rv2)
123 #if(CXSC_INDEX_CHECK)
124  ;
125 #else
126  noexcept;
127 #endif
128  template <class V1,class V2> friend V1 &_vvsetre(V1 &rv1, const V2 &rv2)
129 #if(CXSC_INDEX_CHECK)
130  ;
131 #else
132  noexcept;
133 #endif
134  template <class V,class VS> friend V &_vvssetim(V &rv, const VS &sl)
135 #if(CXSC_INDEX_CHECK)
136  ;
137 #else
138  noexcept;
139 #endif
140  template <class V,class VS> friend V &_vvssetre(V &rv, const VS &sl)
141 #if(CXSC_INDEX_CHECK)
142  ;
143 #else
144  noexcept;
145 #endif
146 template <class V,class MV> friend V &_vmvsetim(V &rv,const MV &v)
147 #if(CXSC_INDEX_CHECK)
148 ;
149 #else
150  noexcept;
151 #endif
152 template <class V,class MV> friend V &_vmvsetre(V &rv,const MV &v)
153 #if(CXSC_INDEX_CHECK)
154 ;
155 #else
156  noexcept;
157 #endif
158  template <class V,class S> friend V &_vssetre(V &v, const S &s) noexcept;
159  template <class V,class S> friend V &_vssetim(V &v, const S &s) noexcept;
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  ;
165 #else
166  noexcept;
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  ;
171 #else
172  noexcept;
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  ;
177 #else
178  noexcept;
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  ;
183 #else
184  noexcept;
185 #endif
186  template <class V,class S> friend V &_vsmultassign(V &rv,const S &r) noexcept;
187  template <class V1,class V2,class E> friend E _vvplus(const V1 &rv1, const V2 &rv2)
188 #if(CXSC_INDEX_CHECK)
189  ;
190 #else
191  noexcept;
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  ;
196 #else
197  noexcept;
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  ;
202 #else
203  noexcept;
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  ;
208 #else
209  noexcept;
210 #endif
211  template <class V1,class V2> friend V1 &_vvplusassign(V1 &rv1, const V2 &rv2)
212 #if(CXSC_INDEX_CHECK)
213  ;
214 #else
215  noexcept;
216 #endif
217  template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl)
218 #if(CXSC_INDEX_CHECK)
219  ;
220 #else
221  noexcept;
222 #endif
223  template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv)
224 #if(CXSC_INDEX_CHECK)
225  ;
226 #else
227  noexcept;
228 #endif
229  template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
230 #if(CXSC_INDEX_CHECK)
231  ;
232 #else
233  noexcept;
234 #endif
235  template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
236 #if(CXSC_INDEX_CHECK)
237  ;
238 #else
239  noexcept;
240 #endif
241  template <class V1,class V2> friend V1 &_vvminusassign(V1 &rv1, const V2 &rv2)
242 #if(CXSC_INDEX_CHECK)
243  ;
244 #else
245  noexcept;
246 #endif
247  template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl)
248 #if(CXSC_INDEX_CHECK)
249  ;
250 #else
251  noexcept;
252 #endif
253  template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv)
254 #if(CXSC_INDEX_CHECK)
255  ;
256 #else
257  noexcept;
258 #endif
259  template <class V> friend V _vminus(const V &rv) noexcept;
260  template <class VS,class V> friend V _vsminus(const VS &sl) noexcept;
261  template <class V1,class V2,class E> friend E _vvminus(const V1 &rv1, const V2 &rv2)
262 #if(CXSC_INDEX_CHECK)
263  ;
264 #else
265  noexcept;
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  ;
270 #else
271  noexcept;
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  ;
276 #else
277  noexcept;
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  ;
282 #else
283  noexcept;
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  ;
288 #else
289  noexcept;
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  ;
294 #else
295  noexcept;
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  ;
300 #else
301  noexcept;
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  ;
306 #else
307  noexcept;
308 #endif
309  //--------- vector-scalar -----------------
310  template <class V,class S,class E> friend E _vsdiv(const V &rv, const S &s) noexcept;
311  template <class V,class S> friend V &_vsdivassign(V &rv,const S &r) noexcept;
312  template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) noexcept;
313  template <class V,class S,class E> friend E _vsmult(const V &rv, const S &s) noexcept;
314  template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) noexcept;
315  template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) noexcept;
316  template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
317 #if(CXSC_INDEX_CHECK)
318  ;
319 #else
320  noexcept;
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  ;
325 #else
326  noexcept;
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  ;
331 #else
332  noexcept;
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  ;
337 #else
338  noexcept;
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  ;
343 #else
344  noexcept;
345 #endif
346 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
347 #if(CXSC_INDEX_CHECK)
348 ;
349 #else
350  noexcept;
351 #endif
352 template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv)
353 #if(CXSC_INDEX_CHECK)
354 ;
355 #else
356  noexcept;
357 #endif
358  template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) noexcept;
359 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
360 #if(CXSC_INDEX_CHECK)
361 ;
362 #else
363  noexcept;
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  ;
368 #else
369  noexcept;
370 #endif
371 
372  template <class V1,class V2> friend bool _vveq(const V1 &rv1, const V2 &rv2) noexcept;
373  template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) noexcept;
374  template <class V1,class V2> friend bool _vvneq(const V1 &rv1, const V2 &rv2) noexcept;
375  template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) noexcept;
376  template <class V1,class V2> friend bool _vvless(const V1 &rv1, const V2 &rv2) noexcept;
377  template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) noexcept;
378  template <class V1,class V2> friend bool _vvleq(const V1 &rv1, const V2 &rv2) noexcept;
379  template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) noexcept;
380  template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) noexcept;
381  template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) noexcept;
382  template <class V> friend bool _vnot(const V &rv) noexcept;
383  template <class V> friend void *_vvoid(const V &rv) noexcept;
384  template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) noexcept;
385  template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) noexcept;
386  template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) noexcept;
387  template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) noexcept;
388  template <class VS> friend bool _vsnot(const VS &sl) noexcept;
389  template <class VS> friend void *_vsvoid(const VS &sl) noexcept;
390  template <class V> friend std::ostream &_vout(std::ostream &s, const V &rv) noexcept;
391  template <class V> friend std::istream &_vin(std::istream &s, V &rv) noexcept;
392 
393  //------------- vector-matrix ---------------
394 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) noexcept;
395  template <class M,class V,class E> friend E _mvcmult(const M &m,const V &v)
396 #if(CXSC_INDEX_CHECK)
397  ;
398 #else
399  noexcept;
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  ;
404 #else
405  noexcept;
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  ;
410 #else
411  noexcept;
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  ;
416 #else
417  noexcept;
418 #endif
419  template <class V,class M,class S> friend V &_vmcmultassign(V &v,const M &m)
420 #if(CXSC_INDEX_CHECK)
421  ;
422 #else
423  noexcept;
424 #endif
425  template <class V,class M,class S> friend V &_vmcimultassign(V &v,const M &m)
426 #if(CXSC_INDEX_CHECK)
427  ;
428 #else
429  noexcept;
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  ;
434 #else
435  noexcept;
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  ;
440 #else
441  noexcept;
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  ;
446 #else
447  noexcept;
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  ;
452 #else
453  noexcept;
454 #endif
455  template <class V,class MS,class S> friend V &_vmscmultassign(V &v,const MS &ms)
456 #if(CXSC_INDEX_CHECK)
457  ;
458 #else
459  noexcept;
460 #endif
461  template <class V,class MS,class S> friend V &_vmscimultassign(V &v,const MS &ms)
462 #if(CXSC_INDEX_CHECK)
463  ;
464 #else
465  noexcept;
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  ;
478 #else
479  noexcept;
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  ;
484 #else
485  noexcept;
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  ;
490 #else
491  noexcept;
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  ;
496 #else
497  noexcept;
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  ;
502 #else
503  noexcept;
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  ;
508 #else
509  noexcept;
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  ;
517 #else
518  noexcept;
519 #endif
520  template <class V1,class V2> friend V1 &_vvsetsup(V1 &rv1, const V2 &rv2)
521 #if(CXSC_INDEX_CHECK)
522  ;
523 #else
524  noexcept;
525 #endif
526  template <class V1,class V2> friend V1 &_vvusetinf(V1 &rv1, const V2 &rv2)
527 #if(CXSC_INDEX_CHECK)
528  ;
529 #else
530  noexcept;
531 #endif
532  template <class V1,class V2> friend V1 &_vvusetsup(V1 &rv1, const V2 &rv2)
533 #if(CXSC_INDEX_CHECK)
534  ;
535 #else
536  noexcept;
537 #endif
538  template <class VS,class V> friend VS &_vsvsetinf(VS &sl, const V &rv)
539 #if(CXSC_INDEX_CHECK)
540  ;
541 #else
542  noexcept;
543 #endif
544  template <class VS,class V> friend VS &_vsvsetsup(VS &sl, const V &rv)
545 #if(CXSC_INDEX_CHECK)
546  ;
547 #else
548  noexcept;
549 #endif
550  template <class VS,class V> friend VS &_vsvusetinf(VS &sl, const V &rv)
551 #if(CXSC_INDEX_CHECK)
552  ;
553 #else
554  noexcept;
555 #endif
556  template <class VS,class V> friend VS &_vsvusetsup(VS &sl, const V &rv)
557 #if(CXSC_INDEX_CHECK)
558  ;
559 #else
560  noexcept;
561 #endif
562 template <class MV,class V> friend MV &_mvvsetinf(MV &v,const V &rv)
563 #if(CXSC_INDEX_CHECK)
564 ;
565 #else
566  noexcept;
567 #endif
568 template <class MV,class V> friend MV &_mvvsetsup(MV &v,const V &rv)
569 #if(CXSC_INDEX_CHECK)
570 ;
571 #else
572  noexcept;
573 #endif
574 template <class MV,class V> friend MV &_mvvusetinf(MV &v,const V &rv)
575 #if(CXSC_INDEX_CHECK)
576 ;
577 #else
578  noexcept;
579 #endif
580 template <class MV,class V> friend MV &_mvvusetsup(MV &v,const V &rv)
581 #if(CXSC_INDEX_CHECK)
582 ;
583 #else
584  noexcept;
585 #endif
586  template <class V,class E> friend E _vmid(const V &rv) noexcept;
587  template <class V,class E> friend E _vinf(const V &rv) noexcept;
588  template <class V,class E> friend E _vsup(const V &rv) noexcept;
589  template <class V,class E> friend E _vdiam(const V &rv) noexcept;
590  template <class VS,class E> friend E _vsmid(const VS &sl) noexcept;
591  template <class VS,class E> friend E _vsinf(const VS &sl) noexcept;
592  template <class VS,class E> friend E _vssup(const VS &sl) noexcept;
593  template <class VS,class E> friend E _vsdiam(const VS &sl) noexcept;
594 template <class MV,class V> friend V _mvdiam(const MV &mv) noexcept;
595 template <class MV,class V> friend V _mvmid(const MV &mv) noexcept;
596 template <class MV,class V> friend V _mvinf(const MV &mv) noexcept;
597 template <class MV,class V> friend V _mvsup(const MV &mv) noexcept;
598 
599  // vector-vector
600  template <class V1,class V2> friend V1 &_vvconvassign(V1 &rv1, const V2 &rv2)
601 #if(CXSC_INDEX_CHECK)
602  ;
603 #else
604  noexcept;
605 #endif
606  template <class V1,class V2> friend V1 &_vvsectassign(V1 &rv1, const V2 &rv2)
607 #if(CXSC_INDEX_CHECK)
608  ;
609 #else
610  noexcept;
611 #endif
612  template <class VS,class V> friend VS &_vsvconvassign(VS &sl, const V &rv)
613 #if(CXSC_INDEX_CHECK)
614  ;
615 #else
616  noexcept;
617 #endif
618  template <class VS,class V> friend VS &_vsvsectassign(VS &sl, const V &rv)
619 #if(CXSC_INDEX_CHECK)
620  ;
621 #else
622  noexcept;
623 #endif
624 template <class MV,class V> friend MV &_mvvconvassign(MV &v,const V &rv)
625 #if(CXSC_INDEX_CHECK)
626 ;
627 #else
628  noexcept;
629 #endif
630 template <class MV,class V> friend MV &_mvvsectassign(MV &v,const V &rv)
631 #if(CXSC_INDEX_CHECK)
632 ;
633 #else
634  noexcept;
635 #endif
636 
637 
638 #endif
639 
640  //------ Konstruktoren ----------------------------------------------------
642  cvector () noexcept;
644  explicit cvector(const int &i) noexcept;
645 #ifdef OLD_CXSC
647  explicit cvector(const class index &i) noexcept; // for backwards compatibility
648 #endif
650  explicit cvector(const int &i1,const int &i2)
651 #if(CXSC_INDEX_CHECK)
652 ;
653 #else
654  noexcept;
655 #endif
657  cvector(const cmatrix_subv &) noexcept;
659  explicit cvector(const complex& r) noexcept;
661  explicit cvector(const cmatrix& )
662 #if(CXSC_INDEX_CHECK)
663 ;
664 #else
665  noexcept;
666 #endif
668  explicit cvector(const cmatrix_slice &sl)
669 #if(CXSC_INDEX_CHECK)
670 ;
671 #else
672  noexcept;
673 #endif
675  cvector(const cvector_slice &rs) noexcept;
677  cvector(const cvector &v) noexcept;
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 &) noexcept;
690  explicit cvector(const rvector_slice &rs) noexcept;
692  explicit cvector(const rvector &v) noexcept;
694  explicit cvector(const rmatrix &)
695 #if(CXSC_INDEX_CHECK)
696 ;
697 #else
698  noexcept;
699 #endif
701  explicit cvector(const rmatrix_slice &sl)
702 #if(CXSC_INDEX_CHECK)
703 ;
704 #else
705  noexcept;
706 #endif
708  explicit cvector(const rmatrix_subv &) noexcept;
709 
710  // complex
712  cvector &operator =(const cvector &rv) noexcept;
714  cvector &operator =(const cvector_slice &sl) noexcept;
716  cvector &operator =(const scvector &rv);
718  cvector &operator =(const scvector_slice &sl);
720  cvector &operator =(const complex &r) noexcept;
722  cvector &operator =(const cmatrix &m)
723 #if(CXSC_INDEX_CHECK)
724 ;
725 #else
726  noexcept;
727 #endif
730 #if(CXSC_INDEX_CHECK)
731 ;
732 #else
733  noexcept;
734 #endif
736  cvector &operator =(const cmatrix_subv &) noexcept;
737  // Real
739  cvector &operator =(const rvector &rv) noexcept;
741  cvector &operator =(const rvector_slice &sl) noexcept;
743  cvector &operator =(const srvector &rv);
745  cvector &operator =(const srvector_slice &sl);
747  cvector &operator =(const real &r) noexcept;
749  cvector &operator =(const rmatrix &m)
750 #if(CXSC_INDEX_CHECK)
751 ;
752 #else
753  noexcept;
754 #endif
757 #if(CXSC_INDEX_CHECK)
758 ;
759 #else
760  noexcept;
761 #endif
763  cvector &operator =(const rmatrix_subv &) noexcept;
764 
765  cvector& operator+=(const srvector&);
766  cvector& operator+=(const scvector&);
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 ;
787 #else
788  noexcept;
789 #endif
791  friend INLINE int Lb(const cvector &rv) noexcept { return rv.l; }
793  friend INLINE int Ub(const cvector &rv) noexcept { return rv.u; }
795  friend INLINE int VecLen(const cvector &rv) noexcept { return rv.size; }
797  friend INLINE cvector & SetLb(cvector &rv, const int &l) noexcept { rv.l=l; rv.u=l+rv.size-1; return rv;}
799  friend INLINE cvector & SetUb(cvector &rv, const int &u) noexcept { 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 ;
804 #else
805  noexcept;
806 #endif
807 
809  INLINE complex & operator [](const int &i)
810 #if(CXSC_INDEX_CHECK)
811 ;
812 #else
813  noexcept;
814 #endif
815 
817  INLINE cvector & operator ()() noexcept { return *this; }
819  INLINE cvector_slice operator ()(const int &i)
820 #if(CXSC_INDEX_CHECK)
821 ;
822 #else
823  noexcept;
824 #endif
826  cvector_slice operator ()(const int &i1,const int &i2)
827 #if(CXSC_INDEX_CHECK)
828 ;
829 #else
830  noexcept;
831 #endif
832  operator void*() noexcept;
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  ;
864 #else
865  noexcept;
866 #endif
867 
868  template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) noexcept;
869 
870  template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv)
871 #if(CXSC_INDEX_CHECK)
872  ;
873 #else
874  noexcept;
875 #endif
876 
877  template <class VS,class S> friend VS & _vssassign(VS &sl,const S &r) noexcept;
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  ;
882 #else
883  noexcept;
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  ;
888 #else
889  noexcept;
890 #endif
891 
892  template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) noexcept;
893  template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) noexcept;
894 
895  template <class VS,class V,class E> friend E _vsvcmult(const VS & sl, const V &rv)
896 #if(CXSC_INDEX_CHECK)
897  ;
898 #else
899  noexcept;
900 #endif
901  template <class VS,class S> friend VS &_vssmultassign(VS &rv,const S &r) noexcept;
902  template <class VS,class S> friend VS &_vssdivassign(VS &rv,const S &r) noexcept;
903  template <class V,class VS,class E> friend E _vvsplus(const V &rv,const VS &sl)
904 #if(CXSC_INDEX_CHECK)
905  ;
906 #else
907  noexcept;
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  ;
912 #else
913  noexcept;
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  ;
918 #else
919  noexcept;
920 #endif
921  template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl)
922 #if(CXSC_INDEX_CHECK)
923  ;
924 #else
925  noexcept;
926 #endif
927  template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
928 #if(CXSC_INDEX_CHECK)
929  ;
930 #else
931  noexcept;
932 #endif
933  template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
934 #if(CXSC_INDEX_CHECK)
935  ;
936 #else
937  noexcept;
938 #endif
939  template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl)
940 #if(CXSC_INDEX_CHECK)
941  ;
942 #else
943  noexcept;
944 #endif
945 
946  template <class VS,class V> friend V _vsminus(const VS &sl) noexcept;
947 
948  template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl)
949 #if(CXSC_INDEX_CHECK)
950  ;
951 #else
952  noexcept;
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  ;
957 #else
958  noexcept;
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  ;
963 #else
964  noexcept;
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  ;
969 #else
970  noexcept;
971 #endif
972  template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) noexcept;
973  template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) noexcept;
974  template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) noexcept;
975  template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) noexcept;
976  template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) noexcept;
977  template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) noexcept;
978  template <class VS,class E> friend E _vsconj(const VS &sl) noexcept;
979  template <class VS,class E> friend E _vsabs(const VS &sl) noexcept;
980 
981  template <class VS1,class VS2,class E> friend E _vsvscmult(const VS1 & sl1, const VS2 &sl2)
982 #if(CXSC_INDEX_CHECK)
983  ;
984 #else
985  noexcept;
986 #endif
987 
988  template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) noexcept;
989  template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) noexcept;
990  template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) noexcept;
991  template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) noexcept;
992  template <class VS> friend bool _vsnot(const VS &sl) noexcept;
993  template <class VS> friend void *_vsvoid(const VS &sl) noexcept;
994  template <class V> friend std::ostream &_vsout(std::ostream &s, const V &rv) noexcept;
995  template <class V> friend std::istream &_vsin(std::istream &s, V &rv) noexcept;
996  template <class VS,class E> friend E _vsim(const VS &sl) noexcept;
997  template <class VS,class E> friend E _vsre(const VS &sl) noexcept;
998  template <class VS,class V> friend VS &_vsvsetim(VS &sl, const V &rv)
999 #if(CXSC_INDEX_CHECK)
1000  ;
1001 #else
1002  noexcept;
1003 #endif
1004  template <class VS,class V> friend VS &_vsvsetre(VS &sl, const V &rv)
1005 #if(CXSC_INDEX_CHECK)
1006  ;
1007 #else
1008  noexcept;
1009 #endif
1010  template <class VS1,class VS2> friend VS1 &_vsvssetim(VS1 &sl1, const VS2 &sl2)
1011 #if(CXSC_INDEX_CHECK)
1012  ;
1013 #else
1014  noexcept;
1015 #endif
1016  template <class VS1,class VS2> friend VS1 &_vsvssetre(VS1 &sl1, const VS2 &sl2)
1017 #if(CXSC_INDEX_CHECK)
1018  ;
1019 #else
1020  noexcept;
1021 #endif
1022 /* friend TINLINE cvector_slice &_vsmvsetim(cvector_slice &,const
1023 rmatrix_subv &) #if(CXSC_INDEX_CHECK)
1024 ; #else noexcept;
1025 #endif
1026  friend TINLINE cvector_slice &_vsmvsetre(cvector_slice &,const rmatrix_subv &)
1027 #if(CXSC_INDEX_CHECK)
1028 ;
1029 #else
1030  noexcept;
1031 #endif */ // 4.10.00 S.W.
1032 
1033  template <class VS,class S> friend VS &_vsssetim(VS &vs, const S &s) noexcept;
1034  template <class VS,class S> friend VS &_vsssetre(VS &vs, const S &s) noexcept;
1035 
1036  template <class VS,class M,class S> friend VS &_vsmcmultassign(VS &v,const M &m)
1037 #if(CXSC_INDEX_CHECK)
1038  ;
1039 #else
1040  noexcept;
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  ;
1047 #else
1048  noexcept;
1049 #endif
1050  template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv)
1051 #if(CXSC_INDEX_CHECK)
1052  ;
1053 #else
1054  noexcept;
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  ;
1059 #else
1060  noexcept;
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  ;
1066 #else
1067  noexcept;
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  ;
1072 #else
1073  noexcept;
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  ;
1080 #else
1081  noexcept;
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  ;
1086 #else
1087  noexcept;
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  ;
1092 #else
1093  noexcept;
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  ;
1098 #else
1099  noexcept;
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  ;
1104 #else
1105  noexcept;
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 ;
1112 #else
1113  noexcept;
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 ;
1118 #else
1119  noexcept;
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  ;
1128 #else
1129  noexcept;
1130 #endif
1131  template <class V,class VS> friend V &_vvssectassign(V &rv, const VS &sl)
1132 #if(CXSC_INDEX_CHECK)
1133  ;
1134 #else
1135  noexcept;
1136 #endif
1137  template <class VS1,class VS2> friend VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2)
1138 #if(CXSC_INDEX_CHECK)
1139  ;
1140 #else
1141  noexcept;
1142 #endif
1143  template <class VS1,class VS2> friend VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2)
1144 #if(CXSC_INDEX_CHECK)
1145  ;
1146 #else
1147  noexcept;
1148 #endif
1149 #endif
1150 
1151  //--------------------- Konstruktoren -----------------------------------
1153  explicit INLINE cvector_slice(cvector &a, const int &lb, const int &ub) noexcept: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) noexcept: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) noexcept: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 ;
1170 #else
1171  noexcept;
1172 #endif
1174  INLINE cvector_slice & operator =(const cvector &rv)
1175 #if(CXSC_INDEX_CHECK)
1176 ;
1177 #else
1178  noexcept;
1179 #endif
1181  INLINE cvector_slice & operator =(const complex &r) noexcept;
1183  INLINE cvector_slice & operator =(const cmatrix &m)
1184 #if(CXSC_INDEX_CHECK)
1185 ;
1186 #else
1187  noexcept;
1188 #endif
1190  INLINE cvector_slice & operator =(const cmatrix_slice &m)
1191 #if(CXSC_INDEX_CHECK)
1192 ;
1193 #else
1194  noexcept;
1195 #endif
1197  INLINE cvector_slice &operator =(const cmatrix_subv &) noexcept;
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 ;
1208 #else
1209  noexcept;
1210 #endif
1211  INLINE cvector_slice & operator =(const rvector &rv)
1212 #if(CXSC_INDEX_CHECK)
1213 ;
1214 #else
1215  noexcept;
1216 #endif
1218  INLINE cvector_slice & operator =(const real &r) noexcept;
1220  INLINE cvector_slice & operator =(const rmatrix &m)
1221 #if(CXSC_INDEX_CHECK)
1222 ;
1223 #else
1224  noexcept;
1225 #endif
1227  INLINE cvector_slice & operator =(const rmatrix_slice &m)
1228 #if(CXSC_INDEX_CHECK)
1229 ;
1230 #else
1231  noexcept;
1232 #endif
1234  INLINE cvector_slice &operator =(const rmatrix_subv &mv) noexcept;
1235 
1236  // cinterval --------
1237  template <class V,class VS> friend V &_vvssetinf(V &rv, const VS &sl)
1238 #if(CXSC_INDEX_CHECK)
1239  ;
1240 #else
1241  noexcept;
1242 #endif
1243  template <class V,class VS> friend V &_vvssetsup(V &rv, const VS &sl)
1244 #if(CXSC_INDEX_CHECK)
1245  ;
1246 #else
1247  noexcept;
1248 #endif
1249  template <class V,class VS> friend V &_vvsusetinf(V &rv, const VS &sl)
1250 #if(CXSC_INDEX_CHECK)
1251  ;
1252 #else
1253  noexcept;
1254 #endif
1255  template <class V,class VS> friend V &_vvsusetsup(V &rv, const VS &sl)
1256 #if(CXSC_INDEX_CHECK)
1257  ;
1258 #else
1259  noexcept;
1260 #endif
1261  template <class VS1,class VS2> friend VS1 &_vsvssetinf(VS1 &sl1, const VS2 &sl2)
1262 #if(CXSC_INDEX_CHECK)
1263  ;
1264 #else
1265  noexcept;
1266 #endif
1267  template <class VS1,class VS2> friend VS1 &_vsvssetsup(VS1 &sl1, const VS2 &sl2)
1268 #if(CXSC_INDEX_CHECK)
1269  ;
1270 #else
1271  noexcept;
1272 #endif
1273  template <class VS1,class VS2> friend VS1 &_vsvsusetinf(VS1 &sl1, const VS2 &sl2)
1274 #if(CXSC_INDEX_CHECK)
1275  ;
1276 #else
1277  noexcept;
1278 #endif
1279  template <class VS1,class VS2> friend VS1 &_vsvsusetsup(VS1 &sl1, const VS2 &sl2)
1280 #if(CXSC_INDEX_CHECK)
1281  ;
1282 #else
1283  noexcept;
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  ;
1290 #else
1291  noexcept;
1292 #endif
1293 
1294 
1295  //--------------------- Standardfunktionen ------------------------------
1296 
1297  friend INLINE complex::complex(const cvector_slice &sl)
1298 #if(CXSC_INDEX_CHECK)
1299 ;
1300 #else
1301  noexcept;
1302 #endif
1304  friend INLINE int Lb(const cvector_slice &sl) noexcept { return sl.start; }
1306  friend INLINE int Ub(const cvector_slice &sl) noexcept { return sl.end; }
1308  friend INLINE int VecLen(const cvector_slice &sl) noexcept { return sl.end-sl.start+1; }
1310  INLINE complex & operator [](const int &i) const
1311 #if(CXSC_INDEX_CHECK)
1312 ;
1313 #else
1314  noexcept;
1315 #endif
1316 
1318  INLINE complex & operator [](const int &i)
1319 #if(CXSC_INDEX_CHECK)
1320 ;
1321 #else
1322  noexcept;
1323 #endif
1324 
1326  INLINE cvector_slice & operator ()() noexcept { return *this; }
1328  INLINE cvector_slice operator ()(const int &i)
1329 #if(CXSC_INDEX_CHECK)
1330 ;
1331 #else
1332  noexcept;
1333 #endif
1335  INLINE cvector_slice operator ()(const int &i1,const int &i2)
1336 #if(CXSC_INDEX_CHECK)
1337 ;
1338 #else
1339  noexcept;
1340 #endif
1341 
1343  INLINE cvector_slice &operator /=(const complex &r) noexcept;
1345  INLINE cvector_slice &operator /=(const real &r) noexcept;
1347  INLINE cvector_slice &operator *=(const complex &r) noexcept;
1349  INLINE cvector_slice &operator *=(const cmatrix &m)
1350 #if(CXSC_INDEX_CHECK)
1351 ;
1352 #else
1353  noexcept;
1354 #endif
1356  INLINE cvector_slice &operator *=(const rmatrix &m)
1357 #if(CXSC_INDEX_CHECK)
1358 ;
1359 #else
1360  noexcept;
1361 #endif
1363  INLINE cvector_slice &operator *=(const real &r) noexcept;
1365  INLINE cvector_slice &operator +=(const cvector &rv)
1366 #if(CXSC_INDEX_CHECK)
1367 ;
1368 #else
1369  noexcept;
1370 #endif
1372  INLINE cvector_slice &operator +=(const cvector_slice &sl2)
1373 #if(CXSC_INDEX_CHECK)
1374 ;
1375 #else
1376  noexcept;
1377 #endif
1379  INLINE cvector_slice &operator -=(const cvector &rv)
1380 #if(CXSC_INDEX_CHECK)
1381 ;
1382 #else
1383  noexcept;
1384 #endif
1386  INLINE cvector_slice &operator -=(const cvector_slice &sl2)
1387 #if(CXSC_INDEX_CHECK)
1388 ;
1389 #else
1390  noexcept;
1391 #endif
1393  INLINE cvector_slice &operator |=(const cvector &rv)
1394 #if(CXSC_INDEX_CHECK)
1395 ;
1396 #else
1397  noexcept;
1398 #endif
1401 #if(CXSC_INDEX_CHECK)
1402 ;
1403 #else
1404  noexcept;
1405 #endif
1407  INLINE cvector_slice &operator &=(const cvector &rv)
1408 #if(CXSC_INDEX_CHECK)
1409 ;
1410 #else
1411  noexcept;
1412 #endif
1415 #if(CXSC_INDEX_CHECK)
1416 ;
1417 #else
1418  noexcept;
1419 #endif
1420 
1422  INLINE cvector_slice &operator +=(const rvector &rv)
1423 #if(CXSC_INDEX_CHECK)
1424 ;
1425 #else
1426  noexcept;
1427 #endif
1429  INLINE cvector_slice &operator +=(const rvector_slice &sl2)
1430 #if(CXSC_INDEX_CHECK)
1431 ;
1432 #else
1433  noexcept;
1434 #endif
1436  INLINE cvector_slice &operator -=(const rvector &rv)
1437 #if(CXSC_INDEX_CHECK)
1438 ;
1439 #else
1440  noexcept;
1441 #endif
1443  INLINE cvector_slice &operator -=(const rvector_slice &sl2)
1444 #if(CXSC_INDEX_CHECK)
1445 ;
1446 #else
1447  noexcept;
1448 #endif
1450  INLINE cvector_slice &operator |=(const rvector &rv)
1451 #if(CXSC_INDEX_CHECK)
1452 ;
1453 #else
1454  noexcept;
1455 #endif
1458 #if(CXSC_INDEX_CHECK)
1459 ;
1460 #else
1461  noexcept;
1462 #endif
1464  INLINE cvector_slice &operator &=(const rvector &rv)
1465 #if(CXSC_INDEX_CHECK)
1466 ;
1467 #else
1468  noexcept;
1469 #endif
1472 #if(CXSC_INDEX_CHECK)
1473 ;
1474 #else
1475  noexcept;
1476 #endif
1477  INLINE operator void*() noexcept;
1478 
1487 
1488 //#else
1489 //#endif
1490 };
1491 
1492 //=======================================================================
1493 //======================== Vector Functions =============================
1494 
1496  INLINE cvector _cvector(const complex &r) noexcept;
1497 // INLINE cvector _cvector(const cmatrix &m);
1498 // INLINE cvector _cvector(const cmatrix_slice &sl);
1500  INLINE cvector _cvector(const real &r) noexcept;
1502  INLINE cvector _cvector(const rvector_slice &rs) noexcept;
1504  INLINE cvector _cvector(const rvector &rs) noexcept;
1505 // INLINE cvector _cvector(const rmatrix &m);
1506 // INLINE cvector _cvector(const rmatrix_slice &sl);
1508  INLINE cvector _cvector(const rmatrix_subv &rs) noexcept;
1509 
1511  INLINE cvector &SetRe(cvector &iv,const rvector &rv)
1512 #if(CXSC_INDEX_CHECK)
1513 ;
1514 #else
1515  noexcept;
1516 #endif
1518  INLINE cvector_slice &SetRe(cvector_slice &iv,const rvector &rv)
1519 #if(CXSC_INDEX_CHECK)
1520 ;
1521 #else
1522  noexcept;
1523 #endif
1525  INLINE cvector &SetRe(cvector &iv,const rvector_slice &rv)
1526 #if(CXSC_INDEX_CHECK)
1527 ;
1528 #else
1529  noexcept;
1530 #endif
1532  INLINE cvector_slice &SetRe(cvector_slice &iv,const rvector_slice &rv)
1533 #if(CXSC_INDEX_CHECK)
1534 ;
1535 #else
1536  noexcept;
1537 #endif
1538 
1540  INLINE cvector &SetIm(cvector &iv,const rvector &rv)
1541 #if(CXSC_INDEX_CHECK)
1542 ;
1543 #else
1544  noexcept;
1545 #endif
1547  INLINE cvector_slice &SetIm(cvector_slice &iv,const rvector &rv)
1548 #if(CXSC_INDEX_CHECK)
1549 ;
1550 #else
1551  noexcept;
1552 #endif
1554  INLINE cvector &SetIm(cvector &iv,const rvector_slice &rv)
1555 #if(CXSC_INDEX_CHECK)
1556 ;
1557 #else
1558  noexcept;
1559 #endif
1561  INLINE cvector_slice &SetIm(cvector_slice &iv,const rvector_slice &rv)
1562 #if(CXSC_INDEX_CHECK)
1563 ;
1564 #else
1565  noexcept;
1566 #endif
1567 
1569  INLINE cvector &SetRe(cvector &iv,const real &r) noexcept;
1571  INLINE cvector &SetIm(cvector &iv,const real &r) noexcept;
1573  INLINE cvector_slice &SetRe(cvector_slice &iv,const real &r) noexcept;
1575  INLINE cvector_slice &SetIm(cvector_slice &iv,const real &r) noexcept;
1576 
1578  INLINE void Resize(cvector &rv) noexcept;
1580  INLINE void Resize(cvector &rv, const int &len)
1581 #if(CXSC_INDEX_CHECK)
1582 ;
1583 #else
1584  noexcept;
1585 #endif
1587  INLINE void Resize(cvector &rv, const int &lb, const int &ub)
1588 #if(CXSC_INDEX_CHECK)
1589 ;
1590 #else
1591  noexcept;
1592 #endif
1593 
1595  INLINE cvector conj(const cvector &rv) noexcept;
1597  INLINE cvector conj(const cvector_slice &sl) noexcept;
1598 
1600  INLINE rvector abs(const cvector &rv) noexcept;
1602  INLINE rvector abs(const cvector_slice &sl) noexcept;
1604  INLINE rvector Im(const cvector &v) noexcept;
1606  INLINE rvector Im(const cvector_slice &v) noexcept;
1608  INLINE rvector Re(const cvector &v) noexcept;
1610  INLINE rvector Re(const cvector_slice &v) noexcept;
1612  INLINE bool operator !(const cvector &rv) noexcept;
1614  INLINE bool operator !(const cvector_slice &sl) noexcept;
1615 
1616 //======================= Vector / Scalar ===============================
1617 
1618 //----------------------------- complex ---------------------------
1619 
1621  INLINE cvector operator *(const cvector &rv, const complex &s) noexcept;
1623  INLINE cvector operator *(const cvector_slice &sl, const complex &s) noexcept;
1625  INLINE cvector operator *(const complex &s, const cvector &rv) noexcept;
1627  INLINE cvector operator *(const complex &s, const cvector_slice &sl) noexcept;
1629  INLINE cvector &operator *=(cvector &rv,const complex &r) noexcept;
1630 
1632  INLINE cvector operator /(const cvector &rv, const complex &s) noexcept;
1634  INLINE cvector operator /(const cvector_slice &sl, const complex &s) noexcept;
1636  INLINE cvector &operator /=(cvector &rv,const complex &r) noexcept;
1637 
1638 //---------------------------- Real --------------------------------------
1639 
1641  INLINE cvector operator *(const cvector &rv, const real &s) noexcept;
1643  INLINE cvector operator *(const cvector_slice &sl, const real &s) noexcept;
1645  INLINE cvector operator *(const real &s, const cvector &rv) noexcept;
1647  INLINE cvector operator *(const real &s, const cvector_slice &sl) noexcept;
1649  INLINE cvector &operator *=(cvector &rv,const real &r) noexcept;
1650 
1652  INLINE cvector operator /(const cvector &rv, const real &s) noexcept;
1654  INLINE cvector operator /(const cvector_slice &sl, const real &s) noexcept;
1656  INLINE cvector &operator /=(cvector &rv,const real &r) noexcept;
1657 
1659  INLINE cvector operator *(const rvector &rv, const complex &s) noexcept;
1661  INLINE cvector operator *(const rvector_slice &sl, const complex &s) noexcept;
1663  INLINE cvector operator *(const complex &s, const rvector &rv) noexcept;
1665  INLINE cvector operator *(const complex &s, const rvector_slice &sl) noexcept;
1666 
1668  INLINE cvector operator /(const rvector &rv, const complex &s) noexcept;
1670  INLINE cvector operator /(const rvector_slice &sl, const complex &s) noexcept;
1671 
1672 //======================= Vector / Vector ===============================
1673 
1674 
1676  INLINE std::ostream &operator <<(std::ostream &s, const cvector &rv) noexcept;
1678  INLINE std::ostream &operator <<(std::ostream &o, const cvector_slice &sl) noexcept;
1680  INLINE std::istream &operator >>(std::istream &s, cvector &rv) noexcept;
1682  INLINE std::istream &operator >>(std::istream &s, cvector_slice &rv) noexcept;
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 ;
1696 #else
1697  noexcept;
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 ;
1707 #else
1708  noexcept;
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 ;
1718 #else
1719  noexcept;
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 ;
1729 #else
1730  noexcept;
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 ;
1740 #else
1741  noexcept;
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 ;
1751 #else
1752  noexcept;
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 ;
1762 #else
1763  noexcept;
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 ;
1773 #else
1774  noexcept;
1775 #endif
1777  void accumulate(cidotprecision &dp, const cvector_slice & sl, const cvector &rv)
1778 #if(CXSC_INDEX_CHECK)
1779 ;
1780 #else
1781  noexcept;
1782 #endif
1784  void accumulate(cidotprecision &dp, const cvector &rv, const cvector_slice &sl)
1785 #if(CXSC_INDEX_CHECK)
1786 ;
1787 #else
1788  noexcept;
1789 #endif
1791  void accumulate(cidotprecision &dp, const cvector & rv1, const cmatrix_subv &rv2)
1792 #if(CXSC_INDEX_CHECK)
1793 ;
1794 #else
1795  noexcept;
1796 #endif
1798  void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const cvector &rv2)
1799 #if(CXSC_INDEX_CHECK)
1800 ;
1801 #else
1802  noexcept;
1803 #endif
1805  void accumulate(cidotprecision &dp, const cvector_slice & sl1, const cvector_slice &sl2)
1806 #if(CXSC_INDEX_CHECK)
1807 ;
1808 #else
1809  noexcept;
1810 #endif
1812  void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const cmatrix_subv &rv2)
1813 #if(CXSC_INDEX_CHECK)
1814 ;
1815 #else
1816  noexcept;
1817 #endif
1818 
1819 
1821  INLINE complex operator *(const cvector & rv1, const cvector &rv2)
1822 #if(CXSC_INDEX_CHECK)
1823 ;
1824 #else
1825  noexcept;
1826 #endif
1828  INLINE complex operator *(const cvector_slice &sl, const cvector &rv)
1829 #if(CXSC_INDEX_CHECK)
1830 ;
1831 #else
1832  noexcept;
1833 #endif
1835  INLINE complex operator *(const cvector &rv, const cvector_slice &sl)
1836 #if(CXSC_INDEX_CHECK)
1837 ;
1838 #else
1839  noexcept;
1840 #endif
1842  INLINE complex operator *(const cvector_slice & sl1, const cvector_slice &sl2)
1843 #if(CXSC_INDEX_CHECK)
1844 ;
1845 #else
1846  noexcept;
1847 #endif
1848 
1850  INLINE const cvector &operator +(const cvector &rv) noexcept;
1852  INLINE cvector operator +(const cvector_slice &sl) noexcept;
1853 
1855  INLINE cvector operator +(const cvector &rv1, const cvector &rv2)
1856 #if(CXSC_INDEX_CHECK)
1857 ;
1858 #else
1859  noexcept;
1860 #endif
1862  INLINE cvector operator +(const cvector &rv, const cvector_slice &sl)
1863 #if(CXSC_INDEX_CHECK)
1864 ;
1865 #else
1866  noexcept;
1867 #endif
1869  INLINE cvector operator +(const cvector_slice &sl, const cvector &rv)
1870 #if(CXSC_INDEX_CHECK)
1871 ;
1872 #else
1873  noexcept;
1874 #endif
1876  INLINE cvector operator +(const cvector_slice &sl1, const cvector_slice &sl2)
1877 #if(CXSC_INDEX_CHECK)
1878 ;
1879 #else
1880  noexcept;
1881 #endif
1883  INLINE cvector & operator +=(cvector &rv1, const cvector &rv2)
1884 #if(CXSC_INDEX_CHECK)
1885 ;
1886 #else
1887  noexcept;
1888 #endif
1890  INLINE cvector &operator +=(cvector &rv, const cvector_slice &sl)
1891 #if(CXSC_INDEX_CHECK)
1892 ;
1893 #else
1894  noexcept;
1895 #endif
1896 
1898  INLINE cvector operator -(const cvector &rv) noexcept;
1900  INLINE cvector operator -(const cvector_slice &sl) noexcept;
1902  INLINE cvector operator -(const cvector &rv1, const cvector &rv2)
1903 #if(CXSC_INDEX_CHECK)
1904 ;
1905 #else
1906  noexcept;
1907 #endif
1909  INLINE cvector operator -(const cvector &rv, const cvector_slice &sl)
1910 #if(CXSC_INDEX_CHECK)
1911 ;
1912 #else
1913  noexcept;
1914 #endif
1916  INLINE cvector operator -(const cvector_slice &sl, const cvector &rv)
1917 #if(CXSC_INDEX_CHECK)
1918 ;
1919 #else
1920  noexcept;
1921 #endif
1923  INLINE cvector operator -(const cvector_slice &sl1, const cvector_slice &sl2)
1924 #if(CXSC_INDEX_CHECK)
1925 ;
1926 #else
1927  noexcept;
1928 #endif
1930  INLINE cvector & operator -=(cvector &rv1, const cvector &rv2)
1931 #if(CXSC_INDEX_CHECK)
1932 ;
1933 #else
1934  noexcept;
1935 #endif
1937  INLINE cvector &operator -=(cvector &rv, const cvector_slice &sl)
1938 #if(CXSC_INDEX_CHECK)
1939 ;
1940 #else
1941  noexcept;
1942 #endif
1943 
1945  INLINE bool operator ==(const cvector &rv1, const cvector &rv2) noexcept;
1947  INLINE bool operator ==(const cvector_slice &sl1, const cvector_slice &sl2) noexcept;
1949  INLINE bool operator ==(const cvector_slice &sl, const cvector &rv) noexcept;
1951  INLINE bool operator ==(const cvector &rv, const cvector_slice &sl) noexcept;
1953  INLINE bool operator !=(const cvector &rv1, const cvector &rv2) noexcept;
1955  INLINE bool operator !=(const cvector_slice &sl1, const cvector_slice &sl2) noexcept;
1957  INLINE bool operator !=(const cvector_slice &sl, const cvector &rv) noexcept;
1959  INLINE bool operator !=(const cvector &rv, const cvector_slice &sl) noexcept;
1960 /* INLINE bool operator <(const cvector &rv1, const cvector &rv2) noexcept;
1961  INLINE bool operator <(const cvector_slice &sl1, const cvector_slice &sl2) noexcept;
1962  INLINE bool operator < (const cvector_slice &sl, const cvector &rv) noexcept;
1963  INLINE bool operator < (const cvector &rv, const cvector_slice &sl) noexcept;
1964  INLINE bool operator <=(const cvector &rv1, const cvector &rv2) noexcept;
1965  INLINE bool operator <=(const cvector_slice &sl1, const cvector_slice &sl2) noexcept;
1966  INLINE bool operator <=(const cvector_slice &sl, const cvector &rv) noexcept;
1967  INLINE bool operator <=(const cvector &rv, const cvector_slice &sl) noexcept;
1968  INLINE bool operator >(const cvector &rv1, const cvector &rv2) noexcept;
1969  INLINE bool operator >(const cvector_slice &sl1, const cvector_slice &sl2) noexcept;
1970  INLINE bool operator >(const cvector_slice &sl, const cvector &rv) noexcept;
1971  INLINE bool operator >(const cvector &rv, const cvector_slice &sl) noexcept;
1972  INLINE bool operator >=(const cvector &rv1, const cvector &rv2) noexcept;
1973  INLINE bool operator >=(const cvector_slice &sl1, const cvector_slice &sl2) noexcept;
1974  INLINE bool operator >=(const cvector_slice &sl, const cvector &rv) noexcept;
1975  INLINE bool operator >=(const cvector &rv, const cvector_slice &sl) noexcept;
1976 */
1977 //-------------------------------- complex / Real --------------------------------
1978 
1979 
1981  void accumulate(cdotprecision &dp, const cvector & rv1, const rvector &rv2)
1982 #if(CXSC_INDEX_CHECK)
1983 ;
1984 #else
1985  noexcept;
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 ;
1996 #else
1997  noexcept;
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 ;
2007 #else
2008  noexcept;
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 ;
2018 #else
2019  noexcept;
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 ;
2029 #else
2030  noexcept;
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 ;
2040 #else
2041  noexcept;
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 ;
2051 #else
2052  noexcept;
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 ;
2062 #else
2063  noexcept;
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 ;
2073 #else
2074  noexcept;
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 ;
2084 #else
2085  noexcept;
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 ;
2095 #else
2096  noexcept;
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 ;
2106 #else
2107  noexcept;
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 ;
2117 #else
2118  noexcept;
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 ;
2128 #else
2129  noexcept;
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 ;
2139 #else
2140  noexcept;
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 ;
2150 #else
2151  noexcept;
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 ;
2161 #else
2162  noexcept;
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 ;
2172 #else
2173  noexcept;
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 ;
2183 #else
2184  noexcept;
2185 #endif
2187  void accumulate(cidotprecision &dp, const rvector & rv1, const cvector &rv2)
2188 #if(CXSC_INDEX_CHECK)
2189 ;
2190 #else
2191  noexcept;
2192 #endif
2194  void accumulate(cidotprecision &dp, const rvector_slice & sl, const cvector &rv)
2195 #if(CXSC_INDEX_CHECK)
2196 ;
2197 #else
2198  noexcept;
2199 #endif
2201  void accumulate(cidotprecision &dp,const cvector_slice &sl,const rvector &rv)
2202 #if(CXSC_INDEX_CHECK)
2203 ;
2204 #else
2205  noexcept;
2206 #endif
2208  void accumulate(cidotprecision &dp, const rvector &rv, const cvector_slice &sl)
2209 #if(CXSC_INDEX_CHECK)
2210 ;
2211 #else
2212  noexcept;
2213 #endif
2215  void accumulate(cidotprecision &dp, const rvector & rv1, const cmatrix_subv &rv2)
2216 #if(CXSC_INDEX_CHECK)
2217 ;
2218 #else
2219  noexcept;
2220 #endif
2222  void accumulate(cidotprecision &dp, const cvector & rv1, const rmatrix_subv &rv2)
2223 #if(CXSC_INDEX_CHECK)
2224 ;
2225 #else
2226  noexcept;
2227 #endif
2229  void accumulate(cidotprecision &dp, const rvector_slice & rv1, const cmatrix_subv &rv2)
2230 #if(CXSC_INDEX_CHECK)
2231 ;
2232 #else
2233  noexcept;
2234 #endif
2236  void accumulate(cidotprecision &dp, const cvector_slice & rv1, const rmatrix_subv &rv2)
2237 #if(CXSC_INDEX_CHECK)
2238 ;
2239 #else
2240  noexcept;
2241 #endif
2243  void accumulate(cidotprecision &dp,const cvector &rv,const rvector_slice &sl)
2244 #if(CXSC_INDEX_CHECK)
2245 ;
2246 #else
2247  noexcept;
2248 #endif
2250  void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const cvector &rv2)
2251 #if(CXSC_INDEX_CHECK)
2252 ;
2253 #else
2254  noexcept;
2255 #endif
2257  void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const rvector &rv2)
2258 #if(CXSC_INDEX_CHECK)
2259 ;
2260 #else
2261  noexcept;
2262 #endif
2264  void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const cvector_slice &rv2)
2265 #if(CXSC_INDEX_CHECK)
2266 ;
2267 #else
2268  noexcept;
2269 #endif
2271  void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const rvector_slice &rv2)
2272 #if(CXSC_INDEX_CHECK)
2273 ;
2274 #else
2275  noexcept;
2276 #endif
2278  void accumulate(cidotprecision &dp, const cvector_slice & sl1, const rvector_slice &sl2)
2279 #if(CXSC_INDEX_CHECK)
2280 ;
2281 #else
2282  noexcept;
2283 #endif
2285  void accumulate(cidotprecision &dp, const rvector_slice & sl1, const cvector_slice &sl2)
2286 #if(CXSC_INDEX_CHECK)
2287 ;
2288 #else
2289  noexcept;
2290 #endif
2292  void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const cmatrix_subv &rv2)
2293 #if(CXSC_INDEX_CHECK)
2294 ;
2295 #else
2296  noexcept;
2297 #endif
2299  void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const rmatrix_subv &rv2)
2300 #if(CXSC_INDEX_CHECK)
2301 ;
2302 #else
2303  noexcept;
2304 #endif
2306  void accumulate(cidotprecision &dp, const cvector_slice &, const ivector &)
2307 #if(CXSC_INDEX_CHECK)
2308 ;
2309 #else
2310  noexcept;
2311 #endif
2313  void accumulate(cidotprecision &dp, const ivector & sl1, const cvector_slice &)
2314 #if(CXSC_INDEX_CHECK)
2315 ;
2316 #else
2317  noexcept;
2318 #endif
2320  void accumulate(cidotprecision &dp, const cvector &, const ivector &)
2321 #if(CXSC_INDEX_CHECK)
2322 ;
2323 #else
2324  noexcept;
2325 #endif
2327  void accumulate(cidotprecision &dp, const ivector &, const cvector &)
2328 #if(CXSC_INDEX_CHECK)
2329 ;
2330 #else
2331  noexcept;
2332 #endif
2334  void accumulate(cidotprecision &dp, const ivector_slice &, const cvector &)
2335 #if(CXSC_INDEX_CHECK)
2336 ;
2337 #else
2338  noexcept;
2339 #endif
2341  void accumulate(cidotprecision &dp, const cvector &, const ivector_slice &)
2342 #if(CXSC_INDEX_CHECK)
2343 ;
2344 #else
2345  noexcept;
2346 #endif
2348  void accumulate(cidotprecision &dp, const cvector_slice &, const ivector_slice &)
2349 #if(CXSC_INDEX_CHECK)
2350 ;
2351 #else
2352  noexcept;
2353 #endif
2355  void accumulate(cidotprecision &dp, const ivector_slice &, const cvector_slice &)
2356 #if(CXSC_INDEX_CHECK)
2357 ;
2358 #else
2359  noexcept;
2360 #endif
2361 
2363  INLINE complex operator *(const rvector & rv1, const cvector &rv2)
2364 #if(CXSC_INDEX_CHECK)
2365 ;
2366 #else
2367  noexcept;
2368 #endif
2370  INLINE complex operator *(const rvector_slice &sl, const cvector &rv)
2371 #if(CXSC_INDEX_CHECK)
2372 ;
2373 #else
2374  noexcept;
2375 #endif
2377  INLINE complex operator *(const rvector &rv, const cvector_slice &sl)
2378 #if(CXSC_INDEX_CHECK)
2379 ;
2380 #else
2381  noexcept;
2382 #endif
2384  INLINE complex operator *(const rvector_slice & sl1, const cvector_slice &sl2)
2385 #if(CXSC_INDEX_CHECK)
2386 ;
2387 #else
2388  noexcept;
2389 #endif
2390 
2392  INLINE complex operator *(const cvector & rv1, const rvector &rv2)
2393 #if(CXSC_INDEX_CHECK)
2394 ;
2395 #else
2396  noexcept;
2397 #endif
2399  INLINE complex operator *(const cvector_slice &sl, const rvector &rv)
2400 #if(CXSC_INDEX_CHECK)
2401 ;
2402 #else
2403  noexcept;
2404 #endif
2406  INLINE complex operator *(const cvector &rv, const rvector_slice &sl)
2407 #if(CXSC_INDEX_CHECK)
2408 ;
2409 #else
2410  noexcept;
2411 #endif
2413  INLINE complex operator *(const cvector_slice & sl1, const rvector_slice &sl2)
2414 #if(CXSC_INDEX_CHECK)
2415 ;
2416 #else
2417  noexcept;
2418 #endif
2419 
2421  INLINE cvector operator +(const rvector &rv1, const cvector &rv2)
2422 #if(CXSC_INDEX_CHECK)
2423 ;
2424 #else
2425  noexcept;
2426 #endif
2428  INLINE cvector operator +(const rvector &rv, const cvector_slice &sl)
2429 #if(CXSC_INDEX_CHECK)
2430 ;
2431 #else
2432  noexcept;
2433 #endif
2435  INLINE cvector operator +(const rvector_slice &sl, const cvector &rv)
2436 #if(CXSC_INDEX_CHECK)
2437 ;
2438 #else
2439  noexcept;
2440 #endif
2442  INLINE cvector operator +(const rvector_slice &sl1, const cvector_slice &sl2)
2443 #if(CXSC_INDEX_CHECK)
2444 ;
2445 #else
2446  noexcept;
2447 #endif
2448 
2450  INLINE cvector operator +(const cvector &rv1, const rvector &rv2)
2451 #if(CXSC_INDEX_CHECK)
2452 ;
2453 #else
2454  noexcept;
2455 #endif
2457  INLINE cvector operator +(const cvector &rv, const rvector_slice &sl)
2458 #if(CXSC_INDEX_CHECK)
2459 ;
2460 #else
2461  noexcept;
2462 #endif
2464  INLINE cvector operator +(const cvector_slice &sl, const rvector &rv)
2465 #if(CXSC_INDEX_CHECK)
2466 ;
2467 #else
2468  noexcept;
2469 #endif
2471  INLINE cvector operator +(const cvector_slice &sl1, const rvector_slice &sl2)
2472 #if(CXSC_INDEX_CHECK)
2473 ;
2474 #else
2475  noexcept;
2476 #endif
2477 
2479  INLINE cvector & operator +=(cvector &rv1, const rvector &rv2)
2480 #if(CXSC_INDEX_CHECK)
2481 ;
2482 #else
2483  noexcept;
2484 #endif
2486  INLINE cvector &operator +=(cvector &rv, const rvector_slice &sl)
2487 #if(CXSC_INDEX_CHECK)
2488 ;
2489 #else
2490  noexcept;
2491 #endif
2492 
2494  INLINE cvector operator -(const rvector &rv1, const cvector &rv2)
2495 #if(CXSC_INDEX_CHECK)
2496 ;
2497 #else
2498  noexcept;
2499 #endif
2501  INLINE cvector operator -(const rvector &rv, const cvector_slice &sl)
2502 #if(CXSC_INDEX_CHECK)
2503 ;
2504 #else
2505  noexcept;
2506 #endif
2508  INLINE cvector operator -(const rvector_slice &sl, const cvector &rv)
2509 #if(CXSC_INDEX_CHECK)
2510 ;
2511 #else
2512  noexcept;
2513 #endif
2515  INLINE cvector operator -(const rvector_slice &sl1, const cvector_slice &sl2)
2516 #if(CXSC_INDEX_CHECK)
2517 ;
2518 #else
2519  noexcept;
2520 #endif
2521 
2523  INLINE cvector operator -(const cvector &rv1, const rvector &rv2)
2524 #if(CXSC_INDEX_CHECK)
2525 ;
2526 #else
2527  noexcept;
2528 #endif
2530  INLINE cvector operator -(const cvector &rv, const rvector_slice &sl)
2531 #if(CXSC_INDEX_CHECK)
2532 ;
2533 #else
2534  noexcept;
2535 #endif
2537  INLINE cvector operator -(const cvector_slice &sl, const rvector &rv)
2538 #if(CXSC_INDEX_CHECK)
2539 ;
2540 #else
2541  noexcept;
2542 #endif
2544  INLINE cvector operator -(const cvector_slice &sl1, const rvector_slice &sl2)
2545 #if(CXSC_INDEX_CHECK)
2546 ;
2547 #else
2548  noexcept;
2549 #endif
2551  INLINE cvector & operator -=(cvector &rv1, const rvector &rv2)
2552 #if(CXSC_INDEX_CHECK)
2553 ;
2554 #else
2555  noexcept;
2556 #endif
2558  INLINE cvector &operator -=(cvector &rv, const rvector_slice &sl)
2559 #if(CXSC_INDEX_CHECK)
2560 ;
2561 #else
2562  noexcept;
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 cdotprecision.
Definition: cdot.hpp:61
The Data Type cidotprecision.
Definition: cidot.hpp:58
The Data Type cimatrix.
Definition: cimatrix.hpp:908
The Data Type civector.
Definition: civector.hpp:57
The Data Type cmatrix_slice.
Definition: cmatrix.hpp:1203
The Data Type cmatrix_subv.
Definition: cmatrix.hpp:54
The Data Type cmatrix.
Definition: cmatrix.hpp:514
The Scalar Type complex.
Definition: complex.hpp:50
complex(void) noexcept
Constructor of class complex.
Definition: complex.hpp:59
The Data Type cvector_slice.
Definition: cvector.hpp:845
friend int Ub(const cvector_slice &sl) noexcept
Returns the upper bound of the vector.
Definition: cvector.hpp:1306
friend int Lb(const cvector_slice &sl) noexcept
Returns the lower bound of the vector.
Definition: cvector.hpp:1304
cvector_slice(cvector &a, const int &lb, const int &ub) noexcept
Constructor of class cvector_slice.
Definition: cvector.hpp:1153
cvector_slice(const cvector_slice &a) noexcept
Constructor of class cvector_slice.
Definition: cvector.hpp:1158
cvector_slice & operator/=(const complex &r) noexcept
Implementation of division and allocation operation.
Definition: cvector.inl:428
friend int VecLen(const cvector_slice &sl) noexcept
Returns the dimension of the vector.
Definition: cvector.hpp:1308
cvector_slice & operator-=(const cvector &rv) noexcept
Implementation of subtraction and allocation operation.
Definition: cvector.inl:597
cvector_slice & operator|=(const cvector &rv) noexcept
Allocates the convex hull of the arguments to the first argument.
cvector_slice & operator()() noexcept
Operator for accessing the whole vector.
Definition: cvector.hpp:1326
cvector_slice(cvector_slice &a, const int &lb, const int &ub) noexcept
Constructor of class cvector_slice.
Definition: cvector.hpp:1155
cvector_slice & operator+=(const cvector &rv) noexcept
Implementation of addition and allocation operation.
Definition: cvector.inl:538
cvector_slice & operator&=(const cvector &rv) noexcept
Allocates the intersection of the arguments to the first argument.
cvector_slice & operator=(const scvector &sl)
Implementation of standard assigning operator.
Definition: scvector.hpp:1545
cvector_slice & operator*=(const complex &r) noexcept
Implementation of multiplication and allocation operation.
Definition: cvector.inl:423
complex & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector (read-only)
Definition: cvector.inl:100
The Data Type cvector.
Definition: cvector.hpp:58
friend cvector & SetLb(cvector &rv, const int &l) noexcept
Sets the lower bound of the vector.
Definition: cvector.hpp:797
friend int Lb(const cvector &rv) noexcept
Returns the lower bound of the vector.
Definition: cvector.hpp:791
cvector() noexcept
Constructor of class cvector.
Definition: cvector.inl:31
friend int VecLen(const cvector &rv) noexcept
Returns the dimension of the vector.
Definition: cvector.hpp:795
cvector & operator=(const cvector &rv) noexcept
Implementation of standard assigning operator.
Definition: cvector.inl:276
friend int Ub(const cvector &rv) noexcept
Returns the upper bound of the vector.
Definition: cvector.hpp:793
cvector & operator()() noexcept
Operator for accessing the whole vector.
Definition: cvector.hpp:817
complex & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector (read-only)
Definition: cvector.inl:126
friend cvector & SetUb(cvector &rv, const int &u) noexcept
Sets the upper bound of the vector.
Definition: cvector.hpp:799
The Data Type intmatrix.
Definition: intmatrix.hpp:314
The Data Type intvector.
Definition: intvector.hpp:52
The Data Type ivector_slice.
Definition: ivector.hpp:963
The Data Type ivector.
Definition: ivector.hpp:55
The Scalar Type real.
Definition: real.hpp:114
The Data Type rmatrix_slice.
Definition: rmatrix.hpp:1443
The Data Type rmatrix_subv.
Definition: rmatrix.hpp:54
The Data Type rmatrix.
Definition: rmatrix.hpp:471
The Data Type rvector_slice.
Definition: rvector.hpp:1064
The Data Type rvector.
Definition: rvector.hpp:58
Helper class for slices of sparse vectors.
Definition: scvector.hpp:1245
A sparse complex vector.
Definition: scvector.hpp:58
Helper class for slices of sparse vectors.
Definition: srvector.hpp:868
A sparse real vector.
Definition: srvector.hpp:58
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
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
civector operator/(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of division operation.
Definition: cimatrix.inl:730
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc) noexcept
Implementation of standard algebraic addition and allocation operation.
Definition: cdot.inl:251
cimatrix & operator*=(cimatrix &m, const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
Definition: cimatrix.inl:1605
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737
civector operator*(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of multiplication operation.
Definition: cimatrix.inl:731
void Resize(cimatrix &A) noexcept
Resizes the matrix.
Definition: cimatrix.inl:1211
cimatrix & operator/=(cimatrix &m, const cinterval &c) noexcept
Implementation of division and allocation operation.
Definition: cimatrix.inl:1623