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
43namespace cxsc {
44
45class cvector_slice;
46class scvector;
47class scvector_slice;
48class srvector;
49class srvector_slice;
50
52
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
74template <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
80template <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
108template <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
114template <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;
119template <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
146template <class V,class MV> friend V &_vmvsetim(V &rv,const MV &v)
147#if(CXSC_INDEX_CHECK)
148;
149#else
150 noexcept;
151#endif
152template <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
346template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
347#if(CXSC_INDEX_CHECK)
348;
349#else
350 noexcept;
351#endif
352template <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;
359template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
360#if(CXSC_INDEX_CHECK)
361;
362#else
363 noexcept;
364#endif
365template <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 ---------------
394template <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
562template <class MV,class V> friend MV &_mvvsetinf(MV &v,const V &rv)
563#if(CXSC_INDEX_CHECK)
564;
565#else
566 noexcept;
567#endif
568template <class MV,class V> friend MV &_mvvsetsup(MV &v,const V &rv)
569#if(CXSC_INDEX_CHECK)
570;
571#else
572 noexcept;
573#endif
574template <class MV,class V> friend MV &_mvvusetinf(MV &v,const V &rv)
575#if(CXSC_INDEX_CHECK)
576;
577#else
578 noexcept;
579#endif
580template <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;
594template <class MV,class V> friend V _mvdiam(const MV &mv) noexcept;
595template <class MV,class V> friend V _mvmid(const MV &mv) noexcept;
596template <class MV,class V> friend V _mvinf(const MV &mv) noexcept;
597template <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
624template <class MV,class V> friend MV &_mvvconvassign(MV &v,const V &rv)
625#if(CXSC_INDEX_CHECK)
626;
627#else
628 noexcept;
629#endif
630template <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);
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);
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
1023rmatrix_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
1110imatrix &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
1116cvector_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
1394#if(CXSC_INDEX_CHECK)
1395;
1396#else
1397 noexcept;
1398#endif
1401#if(CXSC_INDEX_CHECK)
1402;
1403#else
1404 noexcept;
1405#endif
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
1451#if(CXSC_INDEX_CHECK)
1452;
1453#else
1454 noexcept;
1455#endif
1458#if(CXSC_INDEX_CHECK)
1459;
1460#else
1461 noexcept;
1462#endif
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
cvector_slice & operator()() noexcept
Operator for accessing the whole vector.
Definition cvector.hpp:1326
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(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
Allocates the convex hull of the arguments to the first argument.
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.
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 & SetUb(cvector &rv, const int &u) noexcept
Sets the upper bound of the vector.
Definition cvector.hpp:799
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 & SetLb(cvector &rv, const int &l) noexcept
Sets the lower bound of the vector.
Definition cvector.hpp:797
The Data Type intmatrix.
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.
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
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc) noexcept
Implementation of standard algebraic addition and allocation operation.
Definition cdot.inl:251
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
cimatrix & operator*=(cimatrix &m, const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
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.
cimatrix & operator/=(cimatrix &m, const cinterval &c) noexcept
Implementation of division and allocation operation.