C-XSC - A C++ Class Library for Extended Scientific Computing 2.5.4
civector.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: civector.hpp,v 1.39 2014/01/30 17:23:44 cxsc Exp $ */
25
26#ifndef _CXSC_CIVECTOR_HPP_INCLUDED
27#define _CXSC_CIVECTOR_HPP_INCLUDED
28
29#include "xscclass.hpp"
30#include "except.hpp"
31#include "cidot.hpp"
32#include "cinterval.hpp" // used for declaration of Inf, Sup,...
33//#include "cxscmatr.hpp"
34#include "rvector.hpp"
35#include "ivector.hpp"
36#include "cvector.hpp"
37#include "vector.hpp"
38
39
40#include <iostream>
41
42//#include "matrix.hpp" // hat hier eigentlich nichts zu suchen, sonst aber Internal Compiler Error #9
43
44namespace cxsc {
45
46class civector_slice;
47class scivector;
48class scivector_slice;
49
51
57{
58 friend class civector_slice;
59 friend class cimatrix;
60 friend class cimatrix_subv;
61 private:
62 cinterval *dat;
63 int l,u,size;
64
65 public:
66//#if(CXSC_INDEX_CHECK)
67#ifdef _CXSC_FRIEND_TPL
68 //------------ Templates --------------------------------------------------
69 // cinterval
70template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m)
71#if(CXSC_INDEX_CHECK)
72;
73#else
74 noexcept;
75#endif
76template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
77#if(CXSC_INDEX_CHECK)
78;
79#else
80 noexcept;
81#endif
82 template <class V> friend void _vresize(V &rv) noexcept;
83 template <class V,class S> friend void _vresize(V &rv, const int &len)
84#if(CXSC_INDEX_CHECK)
85 ;
86#else
87 noexcept;
88#endif
89 template <class V,class S> friend void _vresize(V &rv, const int &lb, const int &ub)
90#if(CXSC_INDEX_CHECK)
91 ;
92#else
93 noexcept;
94#endif
95 template <class V1,class V2,class S> friend V1 &_vvassign(V1 &rv1,const V2 &rv2) noexcept;
96 template <class V,class S> friend V & _vsassign(V &rv,const S &r) noexcept;
97 template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) noexcept;
98 template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv)
99#if(CXSC_INDEX_CHECK)
100 ;
101#else
102 noexcept;
103#endif
104template <class V,class M,class S> friend V &_vmassign(V &v,const M &m)
105#if(CXSC_INDEX_CHECK)
106;
107#else
108 noexcept;
109#endif
110template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) noexcept;
111 template <class V1,class V2> friend V1 &_vvsetinf(V1 &rv1, const V2 &rv2)
112#if(CXSC_INDEX_CHECK)
113 ;
114#else
115 noexcept;
116#endif
117 template <class V1,class V2> friend V1 &_vvsetsup(V1 &rv1, const V2 &rv2)
118#if(CXSC_INDEX_CHECK)
119 ;
120#else
121 noexcept;
122#endif
123 template <class V,class VS> friend V &_vvssetinf(V &rv, const VS &sl)
124#if(CXSC_INDEX_CHECK)
125 ;
126#else
127 noexcept;
128#endif
129 template <class V,class VS> friend V &_vvssetsup(V &rv, const VS &sl)
130#if(CXSC_INDEX_CHECK)
131 ;
132#else
133 noexcept;
134#endif
135template <class V,class MV> friend V &_vmvsetinf(V &rv,const MV &v)
136#if(CXSC_INDEX_CHECK)
137;
138#else
139 noexcept;
140#endif
141template <class V,class MV> friend V &_vmvsetsup(V &rv,const MV &v)
142#if(CXSC_INDEX_CHECK)
143;
144#else
145 noexcept;
146#endif
147 template <class V1,class V2> friend V1 &_vvusetinf(V1 &rv1, const V2 &rv2)
148#if(CXSC_INDEX_CHECK)
149 ;
150#else
151 noexcept;
152#endif
153 template <class V1,class V2> friend V1 &_vvusetsup(V1 &rv1, const V2 &rv2)
154#if(CXSC_INDEX_CHECK)
155 ;
156#else
157 noexcept;
158#endif
159 template <class V,class VS> friend V &_vvsusetinf(V &rv, const VS &sl)
160#if(CXSC_INDEX_CHECK)
161 ;
162#else
163 noexcept;
164#endif
165 template <class V,class VS> friend V &_vvsusetsup(V &rv, const VS &sl)
166#if(CXSC_INDEX_CHECK)
167 ;
168#else
169 noexcept;
170#endif
171template <class V,class MV> friend V &_vmvusetinf(V &rv,const MV &v)
172#if(CXSC_INDEX_CHECK)
173;
174#else
175 noexcept;
176#endif
177template <class V,class MV> friend V &_vmvusetsup(V &rv,const MV &v)
178#if(CXSC_INDEX_CHECK)
179;
180#else
181 noexcept;
182#endif
183 template <class V,class S> friend V &_vssetinf(V &v, const S &s) noexcept;
184 template <class V,class S> friend V &_vssetsup(V &v, const S &s) noexcept;
185 template <class V,class S> friend V &_vsusetinf(V &v, const S &s) noexcept;
186 template <class V,class S> friend V &_vsusetsup(V &v, const S &s) noexcept;
187 template <class V,class S> friend V &_vssetim(V &v, const S &s) noexcept;
188 template <class V,class S> friend V &_vssetre(V &v, const S &s) noexcept;
189 template <class V> friend V _vconj(const V &rv) noexcept;
190 template <class VS,class E> friend E _vsconj(const VS &sl) noexcept;
191 template <class V,class E> friend E _vabs(const V &rv) noexcept;
192 template <class VS,class E> friend E _vsabs(const VS &sl) noexcept;
193template <class MV,class V> friend V _mvabs(const MV &mv) noexcept;
194 template <class V,class E> friend E _vdiam(const V &rv) noexcept;
195 template <class V,class E> friend E _vmid(const V &rv) noexcept;
196 template <class V,class E> friend E _vinf(const V &rv) noexcept;
197 template <class V,class E> friend E _vsup(const V &rv) noexcept;
198 template <class V,class E> friend E _vim(const V &rv) noexcept;
199 template <class V,class E> friend E _vre(const V &rv) noexcept;
200 friend INLINE ivector Re(const civector &v) noexcept;
201 friend INLINE ivector Im(const civector &v) noexcept;
202 friend INLINE cvector Inf(const civector &v) noexcept;
203 friend INLINE cvector Sup(const civector &v) noexcept;
204 friend INLINE rvector SupRe(const civector &v) noexcept;
205 friend INLINE rvector SupIm(const civector &v) noexcept;
206 friend INLINE rvector InfRe(const civector &v) noexcept;
207 friend INLINE rvector InfIm(const civector &v) noexcept;
208 template <class V1,class V2> friend V1 &_vvsetim(V1 &rv1, const V2 &rv2)
209#if(CXSC_INDEX_CHECK)
210 ;
211#else
212 noexcept;
213#endif
214 template <class V1,class V2> friend V1 &_vvsetre(V1 &rv1, const V2 &rv2)
215#if(CXSC_INDEX_CHECK)
216 ;
217#else
218 noexcept;
219#endif
220 template <class V,class VS> friend V &_vvssetim(V &rv, const VS &sl)
221#if(CXSC_INDEX_CHECK)
222 ;
223#else
224 noexcept;
225#endif
226 template <class V,class VS> friend V &_vvssetre(V &rv, const VS &sl)
227#if(CXSC_INDEX_CHECK)
228 ;
229#else
230 noexcept;
231#endif
232template <class V,class MV> friend V &_vmvsetim(V &rv,const MV &v)
233#if(CXSC_INDEX_CHECK)
234;
235#else
236 noexcept;
237#endif
238template <class V,class MV> friend V &_vmvsetre(V &rv,const MV &v)
239#if(CXSC_INDEX_CHECK)
240;
241#else
242 noexcept;
243#endif
244
245//-------- vector-vector -----------------------
246 template <class DP,class V1,class V2> friend void _vvaccu(DP &dp, const V1 & rv1, const V2 &rv2)
247#if(CXSC_INDEX_CHECK)
248 ;
249#else
250 noexcept;
251#endif
252 template <class DP,class VS,class V> friend void _vsvaccu(DP &dp, const VS & sl, const V &rv)
253#if(CXSC_INDEX_CHECK)
254 ;
255#else
256 noexcept;
257#endif
258
259 template <class V1,class V2,class E> friend E _vvcimult(const V1 & rv1, const V2 &rv2)
260#if(CXSC_INDEX_CHECK)
261 ;
262#else
263 noexcept;
264#endif
265 template <class VS,class V,class E> friend E _vsvcimult(const VS & sl, const V &rv)
266#if(CXSC_INDEX_CHECK)
267 ;
268#else
269 noexcept;
270#endif
271
272 template <class V,class S> friend V &_vsmultassign(V &rv,const S &r) noexcept;
273 template <class V1,class V2,class E> friend E _vvplus(const V1 &rv1, const V2 &rv2)
274#if(CXSC_INDEX_CHECK)
275 ;
276#else
277 noexcept;
278#endif
279 template <class V,class VS,class E> friend E _vvsplus(const V &rv,const VS &sl)
280#if(CXSC_INDEX_CHECK)
281 ;
282#else
283 noexcept;
284#endif
285 template <class VS1,class VS2,class E> friend E _vsvsplus(const VS1 &s1,const VS2 &s2)
286#if(CXSC_INDEX_CHECK)
287 ;
288#else
289 noexcept;
290#endif
291 template <class VS1,class VS2,class E> friend E _vsvsminus(const VS1 &s1,const VS2 &s2)
292#if(CXSC_INDEX_CHECK)
293 ;
294#else
295 noexcept;
296#endif
297 template <class V1,class V2> friend V1 &_vvplusassign(V1 &rv1, const V2 &rv2)
298#if(CXSC_INDEX_CHECK)
299 ;
300#else
301 noexcept;
302#endif
303 template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl)
304#if(CXSC_INDEX_CHECK)
305 ;
306#else
307 noexcept;
308#endif
309 template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv)
310#if(CXSC_INDEX_CHECK)
311 ;
312#else
313 noexcept;
314#endif
315 template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
316#if(CXSC_INDEX_CHECK)
317 ;
318#else
319 noexcept;
320#endif
321 template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
322#if(CXSC_INDEX_CHECK)
323 ;
324#else
325 noexcept;
326#endif
327 template <class V1,class V2> friend V1 &_vvminusassign(V1 &rv1, const V2 &rv2)
328#if(CXSC_INDEX_CHECK)
329 ;
330#else
331 noexcept;
332#endif
333 template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl)
334#if(CXSC_INDEX_CHECK)
335 ;
336#else
337 noexcept;
338#endif
339 template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv)
340#if(CXSC_INDEX_CHECK)
341 ;
342#else
343 noexcept;
344#endif
345 template <class V> friend V _vminus(const V &rv) noexcept;
346 template <class VS,class V> friend V _vsminus(const VS &sl) noexcept;
347 template <class V1,class V2,class E> friend E _vvminus(const V1 &rv1, const V2 &rv2)
348#if(CXSC_INDEX_CHECK)
349 ;
350#else
351 noexcept;
352#endif
353 template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl)
354#if(CXSC_INDEX_CHECK)
355 ;
356#else
357 noexcept;
358#endif
359 template <class VS,class V,class E> friend E _vsvminus(const VS &sl,const V &rv)
360#if(CXSC_INDEX_CHECK)
361 ;
362#else
363 noexcept;
364#endif
365 template <class V1,class V2,class E> friend E _vvconv(const V1 &rv1, const V2 &rv2)
366#if(CXSC_INDEX_CHECK)
367 ;
368#else
369 noexcept;
370#endif
371 template <class V,class VS,class E> friend E _vvsconv(const V &rv,const VS &sl)
372#if(CXSC_INDEX_CHECK)
373 ;
374#else
375 noexcept;
376#endif
377 template <class VS1,class VS2,class E> friend E _vsvsconv(const VS1 &s1,const VS2 &s2)
378#if(CXSC_INDEX_CHECK)
379 ;
380#else
381 noexcept;
382#endif
383 template <class V1,class V2> friend V1 &_vvconvassign(V1 &rv1, const V2 &rv2)
384#if(CXSC_INDEX_CHECK)
385 ;
386#else
387 noexcept;
388#endif
389 template <class V,class VS> friend V &_vvsconvassign(V &rv, const VS &sl)
390#if(CXSC_INDEX_CHECK)
391 ;
392#else
393 noexcept;
394#endif
395 template <class VS,class V> friend VS &_vsvconvassign(VS &sl, const V &rv)
396#if(CXSC_INDEX_CHECK)
397 ;
398#else
399 noexcept;
400#endif
401 template <class VS1,class VS2> friend VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2)
402#if(CXSC_INDEX_CHECK)
403 ;
404#else
405 noexcept;
406#endif
407 template <class V1,class V2,class E> friend E _vvsect(const V1 &rv1, const V2 &rv2)
408#if(CXSC_INDEX_CHECK)
409 ;
410#else
411 noexcept;
412#endif
413 template <class V,class VS,class E> friend E _vvssect(const V &rv,const VS &sl)
414#if(CXSC_INDEX_CHECK)
415 ;
416#else
417 noexcept;
418#endif
419 template <class VS1,class VS2,class E> friend E _vsvssect(const VS1 &s1,const VS2 &s2)
420#if(CXSC_INDEX_CHECK)
421 ;
422#else
423 noexcept;
424#endif
425 template <class V1,class V2> friend V1 &_vvsectassign(V1 &rv1, const V2 &rv2)
426#if(CXSC_INDEX_CHECK)
427 ;
428#else
429 noexcept;
430#endif
431 template <class V,class VS> friend V &_vvssectassign(V &rv, const VS &sl)
432#if(CXSC_INDEX_CHECK)
433 ;
434#else
435 noexcept;
436#endif
437 template <class VS,class V> friend VS &_vsvsectassign(VS &sl, const V &rv)
438#if(CXSC_INDEX_CHECK)
439 ;
440#else
441 noexcept;
442#endif
443 template <class VS1,class VS2> friend VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2)
444#if(CXSC_INDEX_CHECK)
445 ;
446#else
447 noexcept;
448#endif
449 template <class MV1,class MV2,class E> friend E _mvmvsect(const MV1 &rv1, const MV2 &rv2)
450#if(CXSC_INDEX_CHECK)
451 ;
452#else
453 noexcept;
454#endif
455 template <class MV,class V,class E> friend E _mvvsect(const MV &rv1, const V &rv2)
456#if(CXSC_INDEX_CHECK)
457 ;
458#else
459 noexcept;
460#endif
461template <class MV,class V> friend MV &_mvvsectassign(MV &v,const V &rv)
462#if(CXSC_INDEX_CHECK)
463;
464#else
465 noexcept;
466#endif
467template <class V,class MV> friend V &_vmvsectassign(V &rv,const MV &v)
468#if(CXSC_INDEX_CHECK)
469;
470#else
471 noexcept;
472#endif
473 template <class MV1,class MV2,class E> friend E _mvmvconv(const MV1 &rv1, const MV2 &rv2)
474#if(CXSC_INDEX_CHECK)
475 ;
476#else
477 noexcept;
478#endif
479 template <class MV,class V,class E> friend E _mvvconv(const MV &rv1, const V &rv2)
480#if(CXSC_INDEX_CHECK)
481 ;
482#else
483 noexcept;
484#endif
485template <class MV,class V> friend MV &_mvvconvassign(MV &v,const V &rv)
486#if(CXSC_INDEX_CHECK)
487;
488#else
489 noexcept;
490#endif
491template <class V,class MV> friend V &_vmvconvassign(V &rv,const MV &v)
492#if(CXSC_INDEX_CHECK)
493;
494#else
495 noexcept;
496#endif
497 template <class V,class MV,class S> friend S _vmvcimult(const V &rv1, const MV &rv2)
498#if(CXSC_INDEX_CHECK)
499 ;
500#else
501 noexcept;
502#endif
503 //--------- vector-scalar -----------------
504 template <class V,class S,class E> friend E _vsdiv(const V &rv, const S &s) noexcept;
505 template <class V,class S> friend V &_vsdivassign(V &rv,const S &r) noexcept;
506 template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) noexcept;
507 template <class V,class S,class E> friend E _vsmult(const V &rv, const S &s) noexcept;
508 template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) noexcept;
509 template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) noexcept;
510 template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
511#if(CXSC_INDEX_CHECK)
512 ;
513#else
514 noexcept;
515#endif
516 template <class MV,class V,class E> friend E _mvvplus(const MV &rv1, const V &rv2)
517#if(CXSC_INDEX_CHECK)
518 ;
519#else
520 noexcept;
521#endif
522 template <class MV,class V,class E> friend E _mvvminus(const MV &rv1, const V &rv2)
523#if(CXSC_INDEX_CHECK)
524 ;
525#else
526 noexcept;
527#endif
528 template <class V,class MV,class E> friend E _vmvminus(const V &rv1, const MV &rv2)
529#if(CXSC_INDEX_CHECK)
530 ;
531#else
532 noexcept;
533#endif
534 template <class MV1,class MV2,class E> friend E _mvmvminus(const MV1 &rv1, const MV2 &rv2)
535#if(CXSC_INDEX_CHECK)
536 ;
537#else
538 noexcept;
539#endif
540template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
541#if(CXSC_INDEX_CHECK)
542;
543#else
544 noexcept;
545#endif
546template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv)
547#if(CXSC_INDEX_CHECK)
548;
549#else
550 noexcept;
551#endif
552 template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) noexcept;
553template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
554#if(CXSC_INDEX_CHECK)
555;
556#else
557 noexcept;
558#endif
559
560 template <class V1,class V2> friend bool _vveq(const V1 &rv1, const V2 &rv2) noexcept;
561 template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) noexcept;
562 template <class V1,class V2> friend bool _vvneq(const V1 &rv1, const V2 &rv2) noexcept;
563 template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) noexcept;
564 template <class V1,class V2> friend bool _vvless(const V1 &rv1, const V2 &rv2) noexcept;
565 template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) noexcept;
566 template <class V1,class V2> friend bool _vvleq(const V1 &rv1, const V2 &rv2) noexcept;
567 template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) noexcept;
568 template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) noexcept;
569 template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) noexcept;
570 template <class V> friend bool _vnot(const V &rv) noexcept;
571 template <class V> friend void *_vvoid(const V &rv) noexcept;
572 template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) noexcept;
573 template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) noexcept;
574 template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) noexcept;
575 template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) noexcept;
576 template <class VS> friend bool _vsnot(const VS &sl) noexcept;
577 template <class VS> friend void *_vsvoid(const VS &sl) noexcept;
578 template <class V> friend std::ostream &_vout(std::ostream &s, const V &rv) noexcept;
579 template <class V> friend std::istream &_vin(std::istream &s, V &rv) noexcept;
580
581 //------------- vector-matrix ---------------
582template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
583#if(CXSC_INDEX_CHECK)
584 ;
585#else
586 noexcept;
587#endif
588
589template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) noexcept;
590 template <class M,class V,class E> friend E _mvcimult(const M &m,const V &v)
591#if(CXSC_INDEX_CHECK)
592 ;
593#else
594 noexcept;
595#endif
596 template <class V,class M,class E> friend E _vmcimult(const V &v,const M &m)
597#if(CXSC_INDEX_CHECK)
598 ;
599#else
600 noexcept;
601#endif
602 template <class V,class M,class S> friend V &_vmimultassign(V &v,const M &m)
603#if(CXSC_INDEX_CHECK)
604 ;
605#else
606 noexcept;
607#endif
608 template <class V,class M,class S> friend V &_vmcimultassign(V &v,const M &m)
609#if(CXSC_INDEX_CHECK)
610 ;
611#else
612 noexcept;
613#endif
614 template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v)
615#if(CXSC_INDEX_CHECK)
616 ;
617#else
618 noexcept;
619#endif
620 template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms)
621#if(CXSC_INDEX_CHECK)
622 ;
623#else
624 noexcept;
625#endif
626 template <class V,class MS,class S> friend V &_vmscimultassign(V &v,const MS &ms)
627#if(CXSC_INDEX_CHECK)
628 ;
629#else
630 noexcept;
631#endif
632
633 // Real
634 template <class DP,class VS1,class VS2> friend void _vsvsaccu(DP &dp, const VS1 & sl1, const VS2 &sl2)
635#if(CXSC_INDEX_CHECK)
636 ;
637#else
638 noexcept;
639#endif
640
641 //--Real -------- vector-scalar ------------
642 //--Real--------- Vector-vector---------
643 //-- Real -------- Vector-matrix ----------
644 // complex
645 //--complex -------- vector-scalar ------------
646 //--complex--------- Vector-vector---------
647 //-- complex -------- Vector-matrix ----------
648 // interval
649 //--interval -------- vector-scalar ------------
650 //--interval--------- Vector-vector---------
651 //-- interval -------- Vector-matrix ----------
652 // cvector x ivector ----------------
653 // vector - scalar -------
654 // vector - vector -------------
655 // vector - matrix ------------
656
657/* template<class T1,class T2,class T3> friend T3 _mvscimult(const T1 &m,const T2 &v)
658#if(CXSC_INDEX_CHECK)
659;
660#else
661 noexcept;
662#endif
663template<class T1,class T2,class T3> friend T3 _vsmcimult(const T1 &v,const T2 &m)
664#if(CXSC_INDEX_CHECK)
665;
666#else
667 noexcept;
668#endif */
669
670 // real x complex --------------
671 // vector - vector --------------
672
673#endif
674
675
676 //------ Konstruktoren ----------------------------------------------------
678 INLINE civector () noexcept;
680 explicit INLINE civector(const int &i) noexcept;
681#ifdef OLD_CXSC
683 explicit INLINE civector(const class index &i) noexcept; // for backwards compatibility
684#endif
686 explicit INLINE civector(const int &i1,const int &i2)
687#if(CXSC_INDEX_CHECK)
688;
689#else
690 noexcept;
691#endif
693 INLINE civector(const cimatrix_subv &) noexcept;
695 explicit INLINE civector(const cinterval &) noexcept;
697// explicit INLINE civector(const cimatrix &)
698 explicit civector(const cimatrix &)
699#if(CXSC_INDEX_CHECK)
700;
701#else
702 noexcept;
703#endif
705 explicit INLINE civector(const cimatrix_slice &sl)
706#if(CXSC_INDEX_CHECK)
707;
708#else
709 noexcept;
710#endif
712 INLINE civector(const civector_slice &rs) noexcept;
714 INLINE civector(const civector &v) noexcept;
716 INLINE civector(const scivector_slice &rs);
718 INLINE civector(const scivector &v);
719 // Real
721 explicit INLINE civector(const real &) noexcept;
723 explicit INLINE civector(const rvector_slice &rs) noexcept;
725 explicit INLINE civector(const rvector &v) noexcept;
727 explicit INLINE civector(const srvector_slice &rs);
729 explicit INLINE civector(const srvector &v);
731 explicit INLINE civector(const rmatrix &)
732#if(CXSC_INDEX_CHECK)
733;
734#else
735 noexcept;
736#endif
738 explicit INLINE civector(const rmatrix_slice &sl)
739#if(CXSC_INDEX_CHECK)
740;
741#else
742 noexcept;
743#endif
745 explicit INLINE civector(const rmatrix_subv &) noexcept;
746
747 // complex
749 explicit INLINE civector(const complex &) noexcept;
751 explicit INLINE civector(const cvector_slice &rs) noexcept;
753 explicit INLINE civector(const cvector &v) noexcept;
755 explicit INLINE civector(const scvector_slice &rs);
757 explicit INLINE civector(const scvector &v);
759 explicit INLINE civector(const cmatrix &)
760#if(CXSC_INDEX_CHECK)
761;
762#else
763 noexcept;
764#endif
766 explicit INLINE civector(const cmatrix_slice &sl)
767#if(CXSC_INDEX_CHECK)
768;
769#else
770 noexcept;
771#endif
773 explicit INLINE civector(const cmatrix_subv &) noexcept;
774
775 // interval
777 explicit INLINE civector(const interval &) noexcept;
779 explicit INLINE civector(const ivector_slice &rs) noexcept;
781 explicit INLINE civector(const ivector &v) noexcept;
783 explicit INLINE civector(const sivector_slice &rs);
785 explicit INLINE civector(const sivector &v);
787 explicit INLINE civector(const imatrix &)
788#if(CXSC_INDEX_CHECK)
789;
790#else
791 noexcept;
792#endif
794 explicit INLINE civector(const imatrix_slice &sl)
795#if(CXSC_INDEX_CHECK)
796;
797#else
798 noexcept;
799#endif
801 explicit INLINE civector(const imatrix_subv &) noexcept;
802
803 // cinterval
805 INLINE civector &operator =(const civector &rv) noexcept;
807 INLINE civector &operator =(const civector_slice &sl) noexcept;
809 INLINE civector &operator =(const scivector &rv) ;
811 INLINE civector &operator =(const scivector_slice &sl) ;
813 INLINE civector &operator =(const cinterval &r) noexcept;
815 INLINE civector &operator =(const cimatrix &m)
816#if(CXSC_INDEX_CHECK)
817;
818#else
819 noexcept;
820#endif
822 INLINE civector &operator =(const cimatrix_slice &)
823#if(CXSC_INDEX_CHECK)
824;
825#else
826 noexcept;
827#endif
829 INLINE civector &operator =(const cimatrix_subv &) noexcept;
830 // Real
832 INLINE civector &operator =(const rvector &rv) noexcept;
834 INLINE civector &operator =(const rvector_slice &sl) noexcept;
836 INLINE civector &operator =(const srvector &rv);
838 INLINE civector &operator =(const srvector_slice &sl);
840 INLINE civector &operator =(const real &r) noexcept;
842 INLINE civector &operator =(const rmatrix &m)
843#if(CXSC_INDEX_CHECK)
844;
845#else
846 noexcept;
847#endif
849 INLINE civector &operator =(const rmatrix_slice &)
850#if(CXSC_INDEX_CHECK)
851;
852#else
853 noexcept;
854#endif
856 INLINE civector &operator =(const rmatrix_subv &) noexcept;
857
858 // complex
860 INLINE civector &operator =(const cvector &rv) noexcept;
862 INLINE civector &operator =(const cvector_slice &sl) noexcept;
864 INLINE civector &operator =(const scvector &rv);
866 INLINE civector &operator =(const scvector_slice &sl);
868 INLINE civector &operator =(const complex &r) noexcept;
870 INLINE civector &operator =(const cmatrix &m)
871#if(CXSC_INDEX_CHECK)
872;
873#else
874 noexcept;
875#endif
877 INLINE civector &operator =(const cmatrix_slice &)
878#if(CXSC_INDEX_CHECK)
879;
880#else
881 noexcept;
882#endif
884 INLINE civector &operator =(const cmatrix_subv &) noexcept;
885
886 // interval
888 INLINE civector &operator =(const ivector &rv) noexcept;
890 INLINE civector &operator =(const ivector_slice &sl) noexcept;
892 INLINE civector &operator =(const sivector &rv) ;
894 INLINE civector &operator =(const sivector_slice &sl) ;
896 INLINE civector &operator =(const interval &r) noexcept;
898 INLINE civector &operator =(const imatrix &m)
899#if(CXSC_INDEX_CHECK)
900;
901#else
902 noexcept;
903#endif
905 INLINE civector &operator =(const imatrix_slice &)
906#if(CXSC_INDEX_CHECK)
907;
908#else
909 noexcept;
910#endif
912 INLINE civector &operator =(const imatrix_subv &) noexcept;
913
914
915 civector& operator+=(const srvector&);
919 civector& operator-=(const srvector&);
920 civector& operator-=(const scvector&);
921 civector& operator-=(const sivector&);
922 civector& operator-=(const scivector&);
923 civector& operator|=(const srvector&);
924 civector& operator|=(const scvector&);
925 civector& operator|=(const sivector&);
926 civector& operator|=(const scivector&);
927 civector& operator&=(const sivector&);
928 civector& operator&=(const scivector&);
933 civector& operator-=(const srvector_slice&);
934 civector& operator-=(const scvector_slice&);
935 civector& operator-=(const sivector_slice&);
936 civector& operator-=(const scivector_slice&);
937 civector& operator|=(const srvector_slice&);
938 civector& operator|=(const scvector_slice&);
939 civector& operator|=(const sivector_slice&);
940 civector& operator|=(const scivector_slice&);
941 civector& operator&=(const sivector_slice&);
942 civector& operator&=(const scivector_slice&);
943
945 INLINE civector operator()(const intvector& p);
947 INLINE civector operator()(const intmatrix& P);
948
949 //--------- Destruktor ----------------------------------------------------
950 INLINE ~civector() { delete [] dat; }
951
952 //------ Standardfunktionen -----------------------------------------------
953
954 friend INLINE cinterval::cinterval(const civector &)
955#if(CXSC_INDEX_CHECK)
956;
957#else
958 noexcept;
959#endif
961 friend INLINE int Lb(const civector &rv) noexcept { return rv.l; }
963 friend INLINE int Ub(const civector &rv) noexcept { return rv.u; }
965 friend INLINE int VecLen(const civector &rv) noexcept { return rv.size; }
967 friend INLINE civector & SetLb(civector &rv, const int &l) noexcept { rv.l=l; rv.u=l+rv.size-1; return rv;}
969 friend INLINE civector & SetUb(civector &rv, const int &u) noexcept { rv.u=u; rv.l=u-rv.size+1; return rv;}
971 INLINE cinterval & operator [](const int &i) const
972#if(CXSC_INDEX_CHECK)
973;
974#else
975 noexcept;
976#endif
977
979 INLINE cinterval & operator [](const int &i)
980#if(CXSC_INDEX_CHECK)
981;
982#else
983 noexcept;
984#endif
985
987 INLINE civector & operator ()() noexcept { return *this; }
989 INLINE civector_slice operator ()(const int &i)
990#if(CXSC_INDEX_CHECK)
991;
992#else
993 noexcept;
994#endif
996 civector_slice operator ()(const int &i1,const int &i2)
997#if(CXSC_INDEX_CHECK)
998;
999#else
1000 noexcept;
1001#endif
1002
1003 INLINE operator void*() noexcept;
1004//#else
1005//#endif
1006};
1007
1009
1015{
1016 friend class civector;
1017 friend class cimatrix;
1018 private:
1019 cinterval *dat;
1020 int l,u,size;
1021 int start,end;
1022
1023 public:
1024//#if(CXSC_INDEX_CHECK)
1025#ifdef _CXSC_FRIEND_TPL
1026//------------------------- Templates -------------------------------------------
1027// cinterval / cinterval
1028
1029 template <class VS1,class VS2> friend VS1 & _vsvsassign(VS1 &sl1,const VS2 &sl2)
1030#if(CXSC_INDEX_CHECK)
1031 ;
1032#else
1033 noexcept;
1034#endif
1035 template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) noexcept;
1036 template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv)
1037#if(CXSC_INDEX_CHECK)
1038 ;
1039#else
1040 noexcept;
1041#endif
1042 template <class VS,class S> friend VS & _vssassign(VS &sl,const S &r) noexcept;
1043 template <class VS,class V> friend VS &_vsvsetinf(VS &sl, const V &rv)
1044#if(CXSC_INDEX_CHECK)
1045 ;
1046#else
1047 noexcept;
1048#endif
1049 template <class VS,class V> friend VS &_vsvsetsup(VS &sl, const V &rv)
1050#if(CXSC_INDEX_CHECK)
1051 ;
1052#else
1053 noexcept;
1054#endif
1055 template <class VS1,class VS2> friend VS1 &_vsvssetinf(VS1 &sl1, const VS2 &sl2)
1056#if(CXSC_INDEX_CHECK)
1057 ;
1058#else
1059 noexcept;
1060#endif
1061 template <class VS1,class VS2> friend VS1 &_vsvssetsup(VS1 &sl1, const VS2 &sl2)
1062#if(CXSC_INDEX_CHECK)
1063 ;
1064#else
1065 noexcept;
1066#endif
1067 template <class VS,class V> friend VS &_vsvusetinf(VS &sl, const V &rv)
1068#if(CXSC_INDEX_CHECK)
1069 ;
1070#else
1071 noexcept;
1072#endif
1073 template <class VS,class V> friend VS &_vsvusetsup(VS &sl, const V &rv)
1074#if(CXSC_INDEX_CHECK)
1075 ;
1076#else
1077 noexcept;
1078#endif
1079 template <class VS1,class VS2> friend VS1 &_vsvsusetinf(VS1 &sl1, const VS2 &sl2)
1080#if(CXSC_INDEX_CHECK)
1081 ;
1082#else
1083 noexcept;
1084#endif
1085 template <class VS1,class VS2> friend VS1 &_vsvsusetsup(VS1 &sl1, const VS2 &sl2)
1086#if(CXSC_INDEX_CHECK)
1087 ;
1088#else
1089 noexcept;
1090#endif
1091
1092 template <class VS,class E> friend E _vsconj(const VS &sl) noexcept;
1093 template <class VS,class E> friend E _vsabs(const VS &sl) noexcept;
1094 template <class VS,class E> friend E _vsdiam(const VS &sl) noexcept;
1095 template <class VS,class E> friend E _vsmid(const VS &sl) noexcept;
1096 template <class VS,class E> friend E _vsinf(const VS &sl) noexcept;
1097 template <class VS,class E> friend E _vssup(const VS &sl) noexcept;
1098 template <class VS,class E> friend E _vsim(const VS &sl) noexcept;
1099 template <class VS,class E> friend E _vsre(const VS &sl) noexcept;
1100 friend INLINE ivector Re(const civector_slice &v) noexcept;
1101 friend INLINE ivector Im(const civector_slice &v) noexcept;
1102 friend INLINE cvector Inf(const civector_slice &v) noexcept;
1103 friend INLINE cvector Sup(const civector_slice &v) noexcept;
1104 friend INLINE rvector SupRe(const civector_slice &v) noexcept;
1105 friend INLINE rvector SupIm(const civector_slice &v) noexcept;
1106 friend INLINE rvector InfRe(const civector_slice &v) noexcept;
1107 friend INLINE rvector InfIm(const civector_slice &v) noexcept;
1108 template <class VS,class V> friend VS &_vsvsetim(VS &sl, const V &rv)
1109#if(CXSC_INDEX_CHECK)
1110 ;
1111#else
1112 noexcept;
1113#endif
1114 template <class VS,class V> friend VS &_vsvsetre(VS &sl, const V &rv)
1115#if(CXSC_INDEX_CHECK)
1116 ;
1117#else
1118 noexcept;
1119#endif
1120 template <class VS1,class VS2> friend VS1 &_vsvssetim(VS1 &sl1, const VS2 &sl2)
1121#if(CXSC_INDEX_CHECK)
1122 ;
1123#else
1124 noexcept;
1125#endif
1126 template <class VS1,class VS2> friend VS1 &_vsvssetre(VS1 &sl1, const VS2 &sl2)
1127#if(CXSC_INDEX_CHECK)
1128 ;
1129#else
1130 noexcept;
1131#endif
1132 /* friend TINLINE civector_slice &_vsmvsetim(civector_slice &,const imatrix_subv &)
1133#if(CXSC_INDEX_CHECK)
1134;
1135#else
1136 noexcept;
1137#endif
1138 friend TINLINE civector_slice &_vsmvsetre(civector_slice &,const imatrix_subv &)
1139#if(CXSC_INDEX_CHECK)
1140;
1141#else
1142 noexcept;
1143 #endif */
1144 template <class VS,class S> friend VS &_vsssetinf(VS &vs, const S &s) noexcept;
1145 template <class VS,class S> friend VS &_vsssetsup(VS &vs, const S &s) noexcept;
1146 template <class VS,class S> friend VS &_vssusetinf(VS &vs, const S &s) noexcept;
1147 template <class VS,class S> friend VS &_vssusetsup(VS &vs, const S &s) noexcept;
1148 template <class VS,class S> friend VS &_vsssetim(VS &vs, const S &s) noexcept;
1149 template <class VS,class S> friend VS &_vsssetre(VS &vs, const S &s) noexcept;
1150
1151 template <class DP,class VS,class V> friend void _vsvaccu(DP &dp, const VS & sl, const V &rv)
1152#if(CXSC_INDEX_CHECK)
1153 ;
1154#else
1155 noexcept;
1156#endif
1157 template <class DP,class VS1,class VS2> friend void _vsvsaccu(DP &dp, const VS1 & sl1, const VS2 &sl2)
1158#if(CXSC_INDEX_CHECK)
1159 ;
1160#else
1161 noexcept;
1162#endif
1163
1164 template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) noexcept;
1165 template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) noexcept;
1166
1167 template <class VS,class V,class E> friend E _vsvcimult(const VS & sl, const V &rv)
1168#if(CXSC_INDEX_CHECK)
1169 ;
1170#else
1171 noexcept;
1172#endif
1173 template <class VS,class S> friend VS &_vssmultassign(VS &rv,const S &r) noexcept;
1174 template <class VS,class S> friend VS &_vssdivassign(VS &rv,const S &r) noexcept;
1175 template <class V,class VS,class E> friend E _vvsplus(const V &rv,const VS &sl)
1176#if(CXSC_INDEX_CHECK)
1177 ;
1178#else
1179 noexcept;
1180#endif
1181 template <class VS1,class VS2,class E> friend E _vsvsplus(const VS1 &s1,const VS2 &s2)
1182#if(CXSC_INDEX_CHECK)
1183 ;
1184#else
1185 noexcept;
1186#endif
1187 template <class VS1,class VS2,class E> friend E _vsvsminus(const VS1 &s1,const VS2 &s2)
1188#if(CXSC_INDEX_CHECK)
1189 ;
1190#else
1191 noexcept;
1192#endif
1193 template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl)
1194#if(CXSC_INDEX_CHECK)
1195 ;
1196#else
1197 noexcept;
1198#endif
1199 template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv)
1200#if(CXSC_INDEX_CHECK)
1201 ;
1202#else
1203 noexcept;
1204#endif
1205 template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
1206#if(CXSC_INDEX_CHECK)
1207 ;
1208#else
1209 noexcept;
1210#endif
1211 template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
1212#if(CXSC_INDEX_CHECK)
1213 ;
1214#else
1215 noexcept;
1216#endif
1217 template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl)
1218#if(CXSC_INDEX_CHECK)
1219 ;
1220#else
1221 noexcept;
1222#endif
1223 template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv)
1224#if(CXSC_INDEX_CHECK)
1225 ;
1226#else
1227 noexcept;
1228#endif
1229 template <class VS,class V> friend V _vsminus(const VS &sl) noexcept;
1230 template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl)
1231#if(CXSC_INDEX_CHECK)
1232 ;
1233#else
1234 noexcept;
1235#endif
1236 template <class VS,class V,class E> friend E _vsvminus(const VS &sl,const V &rv)
1237#if(CXSC_INDEX_CHECK)
1238 ;
1239#else
1240 noexcept;
1241#endif
1242 template <class V,class VS,class E> friend E _vvssect(const V &rv,const VS &sl)
1243#if(CXSC_INDEX_CHECK)
1244 ;
1245#else
1246 noexcept;
1247#endif
1248 template <class VS1,class VS2,class E> friend E _vsvssect(const VS1 &s1,const VS2 &s2)
1249#if(CXSC_INDEX_CHECK)
1250 ;
1251#else
1252 noexcept;
1253#endif
1254 template <class V,class VS> friend V &_vvssectassign(V &rv, const VS &sl)
1255#if(CXSC_INDEX_CHECK)
1256 ;
1257#else
1258 noexcept;
1259#endif
1260 template <class VS,class V> friend VS &_vsvsectassign(VS &sl, const V &rv)
1261#if(CXSC_INDEX_CHECK)
1262 ;
1263#else
1264 noexcept;
1265#endif
1266 template <class VS1,class VS2> friend VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2)
1267#if(CXSC_INDEX_CHECK)
1268 ;
1269#else
1270 noexcept;
1271#endif
1272 template <class V,class VS,class E> friend E _vvsconv(const V &rv,const VS &sl)
1273#if(CXSC_INDEX_CHECK)
1274 ;
1275#else
1276 noexcept;
1277#endif
1278 template <class VS1,class VS2,class E> friend E _vsvsconv(const VS1 &s1,const VS2 &s2)
1279#if(CXSC_INDEX_CHECK)
1280 ;
1281#else
1282 noexcept;
1283#endif
1284 template <class V,class VS> friend V &_vvsconvassign(V &rv, const VS &sl)
1285#if(CXSC_INDEX_CHECK)
1286 ;
1287#else
1288 noexcept;
1289#endif
1290 template <class VS,class V> friend VS &_vsvconvassign(VS &sl, const V &rv)
1291#if(CXSC_INDEX_CHECK)
1292 ;
1293#else
1294 noexcept;
1295#endif
1296 template <class VS1,class VS2> friend VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2)
1297#if(CXSC_INDEX_CHECK)
1298 ;
1299#else
1300 noexcept;
1301#endif
1302 template <class VS,class M,class S> friend VS &_vsmcimultassign(VS &v,const M &m)
1303#if(CXSC_INDEX_CHECK)
1304 ;
1305#else
1306 noexcept;
1307#endif
1308
1309 template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) noexcept;
1310 template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) noexcept;
1311 template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) noexcept;
1312 template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) noexcept;
1313 template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) noexcept;
1314 template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) noexcept;
1315 template <class VS1,class VS2,class E> friend E _vsvscimult(const VS1 & sl1, const VS2 &sl2)
1316#if(CXSC_INDEX_CHECK)
1317 ;
1318#else
1319 noexcept;
1320#endif
1321 template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) noexcept;
1322 template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) noexcept;
1323 template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) noexcept;
1324 template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) noexcept;
1325 template <class VS> friend bool _vsnot(const VS &sl) noexcept;
1326 template <class VS> friend void *_vsvoid(const VS &sl) noexcept;
1327 template <class V> friend std::ostream &_vsout(std::ostream &s, const V &rv) noexcept;
1328 template <class V> friend std::istream &_vsin(std::istream &s, V &rv) noexcept;
1329
1330 // cinterval / Real
1331 template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms)
1332#if(CXSC_INDEX_CHECK)
1333 ;
1334#else
1335 noexcept;
1336#endif
1337 // cinterval / complex
1338 template <class DP,class V1,class V2> friend void _vvaccu(DP &dp, const V1 & rv1, const V2 &rv2)
1339#if(CXSC_INDEX_CHECK)
1340 ;
1341#else
1342 noexcept;
1343#endif
1344
1345 // cinterval / interval
1346 // complex
1347 template <class V1,class V2,class S> friend V1 &_vvassign(V1 &rv1,const V2 &rv2) noexcept;
1348 template <class V,class S> friend V & _vsassign(V &rv,const S &r) noexcept;
1349
1350template <class V,class M,class S> friend V &_vmassign(V &v,const M &m)
1351#if(CXSC_INDEX_CHECK)
1352;
1353#else
1354 noexcept;
1355#endif
1356template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) noexcept;
1357template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) noexcept;
1358
1359 template <class V1,class V2,class E> friend E _vvconv(const V1 &rv1, const V2 &rv2)
1360#if(CXSC_INDEX_CHECK)
1361 ;
1362#else
1363 noexcept;
1364#endif
1365
1366 //--complex -------- vector-scalar ------------
1367 template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) noexcept;
1368 template <class V,class S,class E> friend E _vsmult(const V &rv, const S &s) noexcept;
1369 template <class V,class S,class E> friend E _vsdiv(const V &rv, const S &s) noexcept;
1370 template <class V,class S> friend V &_vsdivassign(V &rv,const S &r) noexcept;
1371 template <class V,class S> friend V &_vsmultassign(V &rv,const S &r) noexcept;
1372 //--complex--------- Vector-vector---------
1373 template <class V1,class V2,class E> friend E _vvcimult(const V1 & rv1, const V2 &rv2)
1374#if(CXSC_INDEX_CHECK)
1375 ;
1376#else
1377 noexcept;
1378#endif
1379 template <class V1,class V2,class E> friend E _vvplus(const V1 &rv1, const V2 &rv2)
1380#if(CXSC_INDEX_CHECK)
1381 ;
1382#else
1383 noexcept;
1384#endif
1385 template <class V1,class V2> friend V1 &_vvplusassign(V1 &rv1, const V2 &rv2)
1386#if(CXSC_INDEX_CHECK)
1387 ;
1388#else
1389 noexcept;
1390#endif
1391 template <class V1,class V2> friend V1 &_vvminusassign(V1 &rv1, const V2 &rv2)
1392#if(CXSC_INDEX_CHECK)
1393 ;
1394#else
1395 noexcept;
1396#endif
1397 template <class V1,class V2,class E> friend E _vvminus(const V1 &rv1, const V2 &rv2)
1398#if(CXSC_INDEX_CHECK)
1399 ;
1400#else
1401 noexcept;
1402#endif
1403 template <class V1,class V2> friend V1 &_vvconvassign(V1 &rv1, const V2 &rv2)
1404#if(CXSC_INDEX_CHECK)
1405 ;
1406#else
1407 noexcept;
1408#endif
1409 template <class V1,class V2,class E> friend E _vvsect(const V1 &rv1, const V2 &rv2)
1410#if(CXSC_INDEX_CHECK)
1411 ;
1412#else
1413 noexcept;
1414#endif
1415 template <class V1,class V2> friend V1 &_vvsectassign(V1 &rv1, const V2 &rv2)
1416#if(CXSC_INDEX_CHECK)
1417 ;
1418#else
1419 noexcept;
1420#endif
1421
1422 //-- complex -------- Vector-matrix ----------
1423template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m)
1424#if(CXSC_INDEX_CHECK)
1425;
1426#else
1427 noexcept;
1428#endif
1429template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
1430#if(CXSC_INDEX_CHECK)
1431;
1432#else
1433 noexcept;
1434#endif
1435 template <class M,class V,class E> friend E _mvcimult(const M &m,const V &v)
1436#if(CXSC_INDEX_CHECK)
1437 ;
1438#else
1439 noexcept;
1440#endif
1441 template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v)
1442#if(CXSC_INDEX_CHECK)
1443 ;
1444#else
1445 noexcept;
1446#endif
1447 template <class V,class M,class E> friend E _vmcimult(const V &v,const M &m)
1448#if(CXSC_INDEX_CHECK)
1449 ;
1450#else
1451 noexcept;
1452#endif
1453 template <class V,class MS,class S> friend V &_vmscimultassign(V &v,const MS &ms)
1454#if(CXSC_INDEX_CHECK)
1455 ;
1456#else
1457 noexcept;
1458#endif
1459 template <class V,class M,class S> friend V &_vmcimultassign(V &v,const M &m)
1460#if(CXSC_INDEX_CHECK)
1461 ;
1462#else
1463 noexcept;
1464#endif
1465
1466 // interval
1467 /* friend TINLINE civector &_vsmassign<civector_slice,imatrix,cinterval>(civector_slice &v,const imatrix &m)
1468#if(CXSC_INDEX_CHECK)
1469;
1470#else
1471 noexcept;
1472#endif */
1473
1474 //--interval -------- vector-scalar ------------
1475 //--interval--------- Vector-vector---------
1476 //-- interval -------- Vector-matrix ----------
1477/* friend TINLINE civector _mvscimult<imatrix,civector_slice,civector>(const imatrix &m,const civector_slice &v)
1478#if(CXSC_INDEX_CHECK)
1479;
1480#else
1481 noexcept;
1482#endif */
1483 /* friend TINLINE civector _msvscimult<imatrix_slice,civector_slice,civector>(const imatrix_slice &ms,const civector_slice &v)
1484#if(CXSC_INDEX_CHECK)
1485;
1486#else
1487 noexcept;
1488 #endif */
1489 /* friend TINLINE civector _vsmcimult<civector_slice,imatrix,civector>(const civector_slice &v,const imatrix &m)
1490#if(CXSC_INDEX_CHECK)
1491;
1492#else
1493 noexcept;
1494#endif */
1495 /* friend TINLINE civector _vsmscimult<civector_slice,imatrix_slice,civector>(const civector_slice &v,const imatrix_slice &ms)
1496#if(CXSC_INDEX_CHECK)
1497;
1498#else
1499 noexcept;
1500#endif */
1501 /* friend TINLINE civector &_vsmscimultassign<civector_slice,imatrix_slice,cinterval>(civector_slice &v,const imatrix_slice &m)
1502#if(CXSC_INDEX_CHECK)
1503;
1504#else
1505 noexcept;
1506#endif */
1507
1508
1509#endif
1510
1511 //--------------------- Konstruktoren -----------------------------------
1513 explicit INLINE civector_slice(civector &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) { }
1515 explicit INLINE civector_slice(civector_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) { }
1516 public:
1518 INLINE civector_slice(const civector_slice &a) noexcept:dat(a.dat),l(a.l),u(a.u),size(a.size),start(a.start),end(a.end) { }
1519 public:
1520 // cinterval
1522 INLINE civector_slice & operator =(const scivector_slice &sl);
1524 INLINE civector_slice & operator =(const scivector &sl);
1525
1527 INLINE civector_slice & operator =(const civector_slice &sl)
1528#if(CXSC_INDEX_CHECK)
1529;
1530#else
1531 noexcept;
1532#endif
1534 INLINE civector_slice & operator =(const civector &rv)
1535#if(CXSC_INDEX_CHECK)
1536;
1537#else
1538 noexcept;
1539#endif
1541 INLINE civector_slice & operator =(const cinterval &r) noexcept;
1543 INLINE civector_slice & operator =(const cimatrix &m)
1544#if(CXSC_INDEX_CHECK)
1545;
1546#else
1547 noexcept;
1548#endif
1550 INLINE civector_slice & operator =(const cimatrix_slice &m)
1551#if(CXSC_INDEX_CHECK)
1552;
1553#else
1554 noexcept;
1555#endif
1557 INLINE civector_slice &operator =(const cimatrix_subv &) noexcept;
1558 // Real
1560 INLINE civector_slice & operator =(const srvector_slice &sl);
1562 INLINE civector_slice & operator =(const srvector &sl);
1563
1565 INLINE civector_slice & operator =(const rvector_slice &sl)
1566#if(CXSC_INDEX_CHECK)
1567;
1568#else
1569 noexcept;
1570#endif
1572 INLINE civector_slice & operator =(const rvector &rv)
1573#if(CXSC_INDEX_CHECK)
1574;
1575#else
1576 noexcept;
1577#endif
1579 INLINE civector_slice & operator =(const real &r) noexcept;
1581 INLINE civector_slice & operator =(const rmatrix &m)
1582#if(CXSC_INDEX_CHECK)
1583;
1584#else
1585 noexcept;
1586#endif
1588 INLINE civector_slice & operator =(const rmatrix_slice &m)
1589#if(CXSC_INDEX_CHECK)
1590;
1591#else
1592 noexcept;
1593#endif
1595 INLINE civector_slice &operator =(const rmatrix_subv &mv) noexcept;
1596
1597 // complex
1599 INLINE civector_slice & operator =(const scvector_slice &sl);
1601 INLINE civector_slice & operator =(const scvector &sl);
1602
1604 INLINE civector_slice & operator =(const cvector_slice &sl)
1605#if(CXSC_INDEX_CHECK)
1606;
1607#else
1608 noexcept;
1609#endif
1611 INLINE civector_slice & operator =(const cvector &rv)
1612#if(CXSC_INDEX_CHECK)
1613;
1614#else
1615 noexcept;
1616#endif
1618 INLINE civector_slice & operator =(const complex &r) noexcept;
1620 INLINE civector_slice & operator =(const cmatrix &m)
1621#if(CXSC_INDEX_CHECK)
1622;
1623#else
1624 noexcept;
1625#endif
1627 INLINE civector_slice & operator =(const cmatrix_slice &m)
1628#if(CXSC_INDEX_CHECK)
1629;
1630#else
1631 noexcept;
1632#endif
1634 INLINE civector_slice &operator =(const cmatrix_subv &mv) noexcept;
1635
1636 // interval
1638 INLINE civector_slice & operator =(const sivector_slice &sl);
1640 INLINE civector_slice & operator =(const sivector &sl);
1641
1643 INLINE civector_slice & operator =(const ivector_slice &sl)
1644#if(CXSC_INDEX_CHECK)
1645;
1646#else
1647 noexcept;
1648#endif
1650 INLINE civector_slice & operator =(const ivector &rv)
1651#if(CXSC_INDEX_CHECK)
1652;
1653#else
1654 noexcept;
1655#endif
1657 INLINE civector_slice & operator =(const interval &r) noexcept;
1659 INLINE civector_slice & operator =(const imatrix &m)
1660#if(CXSC_INDEX_CHECK)
1661;
1662#else
1663 noexcept;
1664#endif
1666 INLINE civector_slice & operator =(const imatrix_slice &m)
1667#if(CXSC_INDEX_CHECK)
1668;
1669#else
1670 noexcept;
1671#endif
1673 INLINE civector_slice &operator =(const imatrix_subv &mv) noexcept;
1674
1675 //--------------------- Standardfunktionen ------------------------------
1676
1677 friend INLINE cinterval::cinterval(const civector_slice &sl)
1678#if(CXSC_INDEX_CHECK)
1679;
1680#else
1681 noexcept;
1682#endif
1684 friend INLINE int Lb(const civector_slice &sl) noexcept { return sl.start; }
1686 friend INLINE int Ub(const civector_slice &sl) noexcept { return sl.end; }
1688 friend INLINE int VecLen(const civector_slice &sl) noexcept { return sl.size; }
1689
1691 INLINE cinterval & operator [](const int &i) const
1692#if(CXSC_INDEX_CHECK)
1693;
1694#else
1695 noexcept;
1696#endif
1697
1699 INLINE cinterval & operator [](const int &i)
1700#if(CXSC_INDEX_CHECK)
1701;
1702#else
1703 noexcept;
1704#endif
1705
1707 INLINE civector_slice & operator ()() noexcept { return *this; }
1709 INLINE civector_slice operator ()(const int &i)
1710#if(CXSC_INDEX_CHECK)
1711;
1712#else
1713 noexcept;
1714#endif
1716 civector_slice operator ()(const int &i1,const int &i2)
1717#if(CXSC_INDEX_CHECK)
1718;
1719#else
1720 noexcept;
1721#endif
1722 INLINE operator void*() noexcept;
1723
1725 INLINE civector_slice &operator *=(const cinterval &r) noexcept;
1727 INLINE civector_slice &operator /=(const cinterval &r) noexcept;
1729 INLINE civector_slice &operator *=(const cimatrix &m)
1730#if(CXSC_INDEX_CHECK)
1731;
1732#else
1733 noexcept;
1734#endif
1737#if(CXSC_INDEX_CHECK)
1738;
1739#else
1740 noexcept;
1741#endif
1743 INLINE civector_slice &operator +=(const civector &rv)
1744#if(CXSC_INDEX_CHECK)
1745;
1746#else
1747 noexcept;
1748#endif
1750 INLINE civector_slice &operator +=(const civector_slice &sl2)
1751#if(CXSC_INDEX_CHECK)
1752;
1753#else
1754 noexcept;
1755#endif
1757 INLINE civector_slice &operator -=(const civector &rv)
1758#if(CXSC_INDEX_CHECK)
1759;
1760#else
1761 noexcept;
1762#endif
1764 INLINE civector_slice &operator -=(const civector_slice &sl2)
1765#if(CXSC_INDEX_CHECK)
1766;
1767#else
1768 noexcept;
1769#endif
1771 INLINE civector_slice &operator |=(const civector &rv)
1772#if(CXSC_INDEX_CHECK)
1773;
1774#else
1775 noexcept;
1776#endif
1778 INLINE civector_slice &operator |=(const civector_slice &sl2)
1779#if(CXSC_INDEX_CHECK)
1780;
1781#else
1782 noexcept;
1783#endif
1785 INLINE civector_slice &operator &=(const civector &rv)
1786#if(CXSC_INDEX_CHECK)
1787;
1788#else
1789 noexcept;
1790#endif
1792 INLINE civector_slice &operator &=(const civector_slice &sl2)
1793#if(CXSC_INDEX_CHECK)
1794;
1795#else
1796 noexcept;
1797#endif
1798
1800 INLINE civector_slice &operator *=(const real &r) noexcept;
1802 INLINE civector_slice &operator /=(const real &r) noexcept;
1804 INLINE civector_slice &operator +=(const rvector &rv)
1805#if(CXSC_INDEX_CHECK)
1806;
1807#else
1808 noexcept;
1809#endif
1811 INLINE civector_slice &operator +=(const rvector_slice &sl2)
1812#if(CXSC_INDEX_CHECK)
1813;
1814#else
1815 noexcept;
1816#endif
1818 INLINE civector_slice &operator -=(const rvector &rv)
1819#if(CXSC_INDEX_CHECK)
1820;
1821#else
1822 noexcept;
1823#endif
1825 INLINE civector_slice &operator -=(const rvector_slice &sl2)
1826#if(CXSC_INDEX_CHECK)
1827;
1828#else
1829 noexcept;
1830#endif
1832 INLINE civector_slice &operator |=(const rvector &rv)
1833#if(CXSC_INDEX_CHECK)
1834;
1835#else
1836 noexcept;
1837#endif
1839 INLINE civector_slice &operator |=(const rvector_slice &sl2)
1840#if(CXSC_INDEX_CHECK)
1841;
1842#else
1843 noexcept;
1844#endif
1846 INLINE civector_slice &operator &=(const rvector &rv)
1847#if(CXSC_INDEX_CHECK)
1848;
1849#else
1850 noexcept;
1851#endif
1853 INLINE civector_slice &operator &=(const rvector_slice &sl2)
1854#if(CXSC_INDEX_CHECK)
1855;
1856#else
1857 noexcept;
1858#endif
1860 INLINE civector_slice &operator *=(const rmatrix &m)
1861#if(CXSC_INDEX_CHECK)
1862;
1863#else
1864 noexcept;
1865#endif
1868#if(CXSC_INDEX_CHECK)
1869;
1870#else
1871 noexcept;
1872#endif
1873
1875 INLINE civector_slice &operator *=(const complex &r) noexcept;
1877 INLINE civector_slice &operator /=(const complex &r) noexcept;
1879 INLINE civector_slice &operator +=(const cvector &rv)
1880#if(CXSC_INDEX_CHECK)
1881;
1882#else
1883 noexcept;
1884#endif
1886 INLINE civector_slice &operator +=(const cvector_slice &sl2)
1887#if(CXSC_INDEX_CHECK)
1888;
1889#else
1890 noexcept;
1891#endif
1893 INLINE civector_slice &operator -=(const cvector &rv)
1894#if(CXSC_INDEX_CHECK)
1895;
1896#else
1897 noexcept;
1898#endif
1900 INLINE civector_slice &operator -=(const cvector_slice &sl2)
1901#if(CXSC_INDEX_CHECK)
1902;
1903#else
1904 noexcept;
1905#endif
1907 INLINE civector_slice &operator |=(const cvector &rv)
1908#if(CXSC_INDEX_CHECK)
1909;
1910#else
1911 noexcept;
1912#endif
1914 INLINE civector_slice &operator |=(const cvector_slice &sl2)
1915#if(CXSC_INDEX_CHECK)
1916;
1917#else
1918 noexcept;
1919#endif
1921 INLINE civector_slice &operator &=(const cvector &rv)
1922#if(CXSC_INDEX_CHECK)
1923;
1924#else
1925 noexcept;
1926#endif
1928 INLINE civector_slice &operator &=(const cvector_slice &sl2)
1929#if(CXSC_INDEX_CHECK)
1930;
1931#else
1932 noexcept;
1933#endif
1935 INLINE civector_slice &operator *=(const cmatrix &m)
1936#if(CXSC_INDEX_CHECK)
1937;
1938#else
1939 noexcept;
1940#endif
1943#if(CXSC_INDEX_CHECK)
1944;
1945#else
1946 noexcept;
1947#endif
1948
1950 INLINE civector_slice &operator *=(const interval &r) noexcept;
1952 INLINE civector_slice &operator /=(const interval &r) noexcept;
1954 INLINE civector_slice &operator +=(const ivector &rv)
1955#if(CXSC_INDEX_CHECK)
1956;
1957#else
1958 noexcept;
1959#endif
1961 INLINE civector_slice &operator +=(const ivector_slice &sl2)
1962#if(CXSC_INDEX_CHECK)
1963;
1964#else
1965 noexcept;
1966#endif
1968 INLINE civector_slice &operator -=(const ivector &rv)
1969#if(CXSC_INDEX_CHECK)
1970;
1971#else
1972 noexcept;
1973#endif
1975 INLINE civector_slice &operator -=(const ivector_slice &sl2)
1976#if(CXSC_INDEX_CHECK)
1977;
1978#else
1979 noexcept;
1980#endif
1982 INLINE civector_slice &operator |=(const ivector &rv)
1983#if(CXSC_INDEX_CHECK)
1984;
1985#else
1986 noexcept;
1987#endif
1989 INLINE civector_slice &operator |=(const ivector_slice &sl2)
1990#if(CXSC_INDEX_CHECK)
1991;
1992#else
1993 noexcept;
1994#endif
1996 INLINE civector_slice &operator &=(const ivector &rv)
1997#if(CXSC_INDEX_CHECK)
1998;
1999#else
2000 noexcept;
2001#endif
2003 INLINE civector_slice &operator &=(const ivector_slice &sl2)
2004#if(CXSC_INDEX_CHECK)
2005;
2006#else
2007 noexcept;
2008#endif
2010 INLINE civector_slice &operator *=(const imatrix &m)
2011#if(CXSC_INDEX_CHECK)
2012;
2013#else
2014 noexcept;
2015#endif
2018#if(CXSC_INDEX_CHECK)
2019;
2020#else
2021 noexcept;
2022#endif
2023//#else
2024//#endif
2025
2054
2055};
2056
2057//=======================================================================
2058//======================== Vector Functions =============================
2059
2061 INLINE civector _civector(const cinterval &r) noexcept;
2062// INLINE civector _civector(const cimatrix &m);
2063// INLINE civector _civector(const cimatrix_slice &sl);
2065 INLINE civector _civector(const real &r) noexcept;
2067 INLINE civector _civector(const rvector_slice &rs) noexcept;
2069 INLINE civector _civector(const rvector &rs) noexcept;
2070// INLINE civector _civector(const rmatrix &m);
2071// INLINE civector _civector(const rmatrix_slice &sl);
2073 INLINE civector _civector(const rmatrix_subv &rs) noexcept;
2074
2076 INLINE civector &SetInf(civector &iv,const cvector &rv)
2077#if(CXSC_INDEX_CHECK)
2078;
2079#else
2080 noexcept;
2081#endif
2083 INLINE civector_slice &SetInf(civector_slice &iv,const cvector &rv)
2084#if(CXSC_INDEX_CHECK)
2085;
2086#else
2087 noexcept;
2088#endif
2090 INLINE civector &SetInf(civector &iv,const cvector_slice &rv)
2091#if(CXSC_INDEX_CHECK)
2092;
2093#else
2094 noexcept;
2095#endif
2097 INLINE civector_slice &SetInf(civector_slice &iv,const cvector_slice &rv)
2098#if(CXSC_INDEX_CHECK)
2099;
2100#else
2101 noexcept;
2102#endif
2104 INLINE civector &UncheckedSetInf(civector &iv,const cvector &rv)
2105#if(CXSC_INDEX_CHECK)
2106;
2107#else
2108 noexcept;
2109#endif
2111 INLINE civector_slice &UncheckedSetInf(civector_slice &iv,const cvector &rv)
2112#if(CXSC_INDEX_CHECK)
2113;
2114#else
2115 noexcept;
2116#endif
2118 INLINE civector &UncheckedSetInf(civector &iv,const cvector_slice &rv)
2119#if(CXSC_INDEX_CHECK)
2120;
2121#else
2122 noexcept;
2123#endif
2125 INLINE civector_slice &UncheckedSetInf(civector_slice &iv,const cvector_slice &rv)
2126#if(CXSC_INDEX_CHECK)
2127;
2128#else
2129 noexcept;
2130#endif
2131
2133 INLINE civector &SetSup(civector &iv,const cvector &rv)
2134#if(CXSC_INDEX_CHECK)
2135;
2136#else
2137 noexcept;
2138#endif
2140 INLINE civector_slice &SetSup(civector_slice &iv,const cvector &rv)
2141#if(CXSC_INDEX_CHECK)
2142;
2143#else
2144 noexcept;
2145#endif
2147 INLINE civector &SetSup(civector &iv,const cvector_slice &rv)
2148#if(CXSC_INDEX_CHECK)
2149;
2150#else
2151 noexcept;
2152#endif
2154 INLINE civector_slice &SetSup(civector_slice &iv,const cvector_slice &rv)
2155#if(CXSC_INDEX_CHECK)
2156;
2157#else
2158 noexcept;
2159#endif
2161 INLINE civector &UncheckedSetSup(civector &iv,const cvector &rv)
2162#if(CXSC_INDEX_CHECK)
2163;
2164#else
2165 noexcept;
2166#endif
2168 INLINE civector_slice &UncheckedSetSup(civector_slice &iv,const cvector &rv)
2169#if(CXSC_INDEX_CHECK)
2170;
2171#else
2172 noexcept;
2173#endif
2175 INLINE civector &UncheckedSetSup(civector &iv,const cvector_slice &rv)
2176#if(CXSC_INDEX_CHECK)
2177;
2178#else
2179 noexcept;
2180#endif
2182 INLINE civector_slice &UncheckedSetSup(civector_slice &iv,const cvector_slice &rv)
2183#if(CXSC_INDEX_CHECK)
2184;
2185#else
2186 noexcept;
2187#endif
2188
2190 INLINE civector &SetRe(civector &iv,const ivector &rv)
2191#if(CXSC_INDEX_CHECK)
2192;
2193#else
2194 noexcept;
2195#endif
2197 INLINE civector_slice &SetRe(civector_slice &iv,const ivector &rv)
2198#if(CXSC_INDEX_CHECK)
2199;
2200#else
2201 noexcept;
2202#endif
2204 INLINE civector &SetRe(civector &iv,const ivector_slice &rv)
2205#if(CXSC_INDEX_CHECK)
2206;
2207#else
2208 noexcept;
2209#endif
2211 INLINE civector_slice &SetRe(civector_slice &iv,const ivector_slice &rv)
2212#if(CXSC_INDEX_CHECK)
2213;
2214#else
2215 noexcept;
2216#endif
2217
2219 INLINE civector &SetIm(civector &iv,const ivector &rv)
2220#if(CXSC_INDEX_CHECK)
2221;
2222#else
2223 noexcept;
2224#endif
2226 INLINE civector_slice &SetIm(civector_slice &iv,const ivector &rv)
2227#if(CXSC_INDEX_CHECK)
2228;
2229#else
2230 noexcept;
2231#endif
2233 INLINE civector &SetIm(civector &iv,const ivector_slice &rv)
2234#if(CXSC_INDEX_CHECK)
2235;
2236#else
2237 noexcept;
2238#endif
2240 INLINE civector_slice &SetIm(civector_slice &iv,const ivector_slice &rv)
2241#if(CXSC_INDEX_CHECK)
2242;
2243#else
2244 noexcept;
2245#endif
2246
2248 INLINE civector &SetSup(civector &iv,const complex &r) noexcept;
2250 INLINE civector &SetInf(civector &iv,const complex &r) noexcept;
2252 INLINE civector &UncheckedSetSup(civector &iv,const complex &r) noexcept;
2254 INLINE civector &SetUncheckedInf(civector &iv,const complex &r) noexcept;
2256 INLINE civector &SetRe(civector &iv,const interval &r) noexcept;
2258 INLINE civector &SetIm(civector &iv,const interval &r) noexcept;
2259
2261 INLINE civector_slice &SetSup(civector_slice &iv,const complex &r) noexcept;
2263 INLINE civector_slice &SetInf(civector_slice &iv,const complex &r) noexcept;
2265 INLINE civector_slice &UncheckedSetSup(civector_slice &iv,const complex &r) noexcept;
2267 INLINE civector_slice &SetUncheckedInf(civector_slice &iv,const complex &r) noexcept;
2269 INLINE civector_slice &SetRe(civector_slice &iv,const interval &r) noexcept;
2271 INLINE civector_slice &SetIm(civector_slice &iv,const interval &r) noexcept;
2272
2274 INLINE void Resize(civector &rv) noexcept;
2276 INLINE void Resize(civector &rv, const int &len)
2277#if(CXSC_INDEX_CHECK)
2278;
2279#else
2280 noexcept;
2281#endif
2283 INLINE void Resize(civector &rv, const int &lb, const int &ub)
2284#if(CXSC_INDEX_CHECK)
2285;
2286#else
2287 noexcept;
2288#endif
2289
2291 INLINE civector conj(const civector &rv) noexcept;
2293 INLINE civector conj(const civector_slice &sl) noexcept;
2294
2296 INLINE ivector abs(const civector &rv) noexcept;
2298 INLINE ivector abs(const civector_slice &sl) noexcept;
2300 INLINE cvector diam(const civector &v) noexcept;
2302 INLINE cvector diam(const civector_slice &v) noexcept;
2304 INLINE cvector mid(const civector &v) noexcept;
2306 INLINE cvector mid(const civector_slice &v) noexcept;
2308 INLINE cvector Inf(const civector &v) noexcept;
2310 INLINE cvector Inf(const civector_slice &v) noexcept;
2312 INLINE cvector Sup(const civector &v) noexcept;
2314 INLINE cvector Sup(const civector_slice &v) noexcept;
2316 INLINE rvector SupRe(const civector &v) noexcept;
2318 INLINE rvector SupIm(const civector &v) noexcept;
2320 INLINE rvector InfRe(const civector &v) noexcept;
2322 INLINE rvector InfIm(const civector &v) noexcept;
2324 INLINE rvector SupRe(const civector_slice &v) noexcept;
2326 INLINE rvector SupIm(const civector_slice &v) noexcept;
2328 INLINE rvector InfRe(const civector_slice &v) noexcept;
2330 INLINE rvector InfIm(const civector_slice &v) noexcept;
2332 INLINE bool operator !(const civector &rv) noexcept;
2334 INLINE bool operator !(const civector_slice &sl) noexcept;
2335
2336//======================= Vector / Scalar ===============================
2337
2338//----------------------------- cinterval ---------------------------
2339
2341 INLINE civector operator *(const civector &rv, const cinterval &s) noexcept;
2343 INLINE civector operator *(const civector_slice &sl, const cinterval &s) noexcept;
2345 INLINE civector operator *(const cinterval &s, const civector &rv) noexcept;
2347 INLINE civector operator *(const cinterval &s, const civector_slice &sl) noexcept;
2349 INLINE civector &operator *=(civector &rv,const cinterval &r) noexcept;
2350
2352 INLINE civector operator /(const civector &rv, const cinterval &s) noexcept;
2354 INLINE civector operator /(const civector_slice &sl, const cinterval &s) noexcept;
2356 INLINE civector &operator /=(civector &rv,const cinterval &r) noexcept;
2357
2358//---------------------------- Real --------------------------------------
2359
2361 INLINE civector operator *(const civector &rv, const real &s) noexcept;
2363 INLINE civector operator *(const civector_slice &sl, const real &s) noexcept;
2365 INLINE civector operator *(const real &s, const civector &rv) noexcept;
2367 INLINE civector operator *(const real &s, const civector_slice &sl) noexcept;
2369 INLINE civector &operator *=(civector &rv,const real &r) noexcept;
2370
2372 INLINE civector operator /(const civector &rv, const real &s) noexcept;
2374 INLINE civector operator /(const civector_slice &sl, const real &s) noexcept;
2376 INLINE civector &operator /=(civector &rv,const real &r) noexcept;
2377
2379 INLINE civector operator *(const rvector &rv, const cinterval &s) noexcept;
2381 INLINE civector operator *(const rvector_slice &sl, const cinterval &s) noexcept;
2383 INLINE civector operator *(const cinterval &s, const rvector &rv) noexcept;
2385 INLINE civector operator *(const cinterval &s, const rvector_slice &sl) noexcept;
2386
2388 INLINE civector operator /(const rvector &rv, const cinterval &s) noexcept;
2390 INLINE civector operator /(const rvector_slice &sl, const cinterval &s) noexcept;
2391
2392//---------------------------- Complex --------------------------------------
2393
2395 INLINE civector operator *(const civector &rv, const complex &s) noexcept;
2397 INLINE civector operator *(const civector_slice &sl, const complex &s) noexcept;
2399 INLINE civector operator *(const complex &s, const civector &rv) noexcept;
2401 INLINE civector operator *(const complex &s, const civector_slice &sl) noexcept;
2403 INLINE civector &operator *=(civector &rv,const complex &r) noexcept;
2404
2406 INLINE civector operator /(const civector &rv, const complex &s) noexcept;
2408 INLINE civector operator /(const civector_slice &sl, const complex &s) noexcept;
2410 INLINE civector &operator /=(civector &rv,const complex &r) noexcept;
2411
2413 INLINE civector operator *(const cvector &rv, const cinterval &s) noexcept;
2415 INLINE civector operator *(const cvector_slice &sl, const cinterval &s) noexcept;
2417 INLINE civector operator *(const cinterval &s, const cvector &rv) noexcept;
2419 INLINE civector operator *(const cinterval &s, const cvector_slice &sl) noexcept;
2420
2422 INLINE civector operator /(const cvector &rv, const cinterval &s) noexcept;
2424 INLINE civector operator /(const cvector_slice &sl, const cinterval &s) noexcept;
2425
2426//---------------------------- interval --------------------------------------
2427
2429 INLINE civector operator *(const civector &rv, const interval &s) noexcept;
2431 INLINE civector operator *(const civector_slice &sl, const interval &s) noexcept;
2433 INLINE civector operator *(const interval &s, const civector &rv) noexcept;
2435 INLINE civector operator *(const interval &s, const civector_slice &sl) noexcept;
2437 INLINE civector &operator *=(civector &rv,const interval &r) noexcept;
2438
2440 INLINE civector operator /(const civector &rv, const interval &s) noexcept;
2442 INLINE civector operator /(const civector_slice &sl, const interval &s) noexcept;
2444 INLINE civector &operator /=(civector &rv,const interval &r) noexcept;
2445
2447 INLINE civector operator *(const ivector &rv, const cinterval &s) noexcept;
2449 INLINE civector operator *(const ivector_slice &sl, const cinterval &s) noexcept;
2451 INLINE civector operator *(const cinterval &s, const ivector &rv) noexcept;
2453 INLINE civector operator *(const cinterval &s, const ivector_slice &sl) noexcept;
2454
2456 INLINE civector operator /(const ivector &rv, const cinterval &s) noexcept;
2458 INLINE civector operator /(const ivector_slice &sl, const cinterval &s) noexcept;
2459
2460//======================= Vector / Vector ===============================
2461
2462
2464 INLINE std::ostream &operator <<(std::ostream &s, const civector &rv) noexcept;
2466 INLINE std::ostream &operator <<(std::ostream &o, const civector_slice &sl) noexcept;
2468 INLINE std::istream &operator >>(std::istream &s, civector &rv) noexcept;
2470 INLINE std::istream &operator >>(std::istream &s, civector_slice &rv) noexcept;
2471
2472//----------------------- cinterval / cinterval ---------------------------
2473
2475 void accumulate(cidotprecision &dp, const cvector &);
2476
2478 void accumulate(cidotprecision &dp, const rvector &);
2479
2481 void accumulate(cidotprecision &dp, const civector &);
2482
2484 void accumulate(cidotprecision &dp, const ivector &);
2485
2486
2488 void accumulate(cidotprecision &dp, const civector & rv1, const civector &rv2)
2489#if(CXSC_INDEX_CHECK)
2490;
2491#else
2492 noexcept;
2493#endif
2495 void accumulate(cidotprecision &dp, const civector_slice & sl, const civector &rv)
2496#if(CXSC_INDEX_CHECK)
2497;
2498#else
2499 noexcept;
2500#endif
2502 void accumulate(cidotprecision &dp, const civector &rv, const civector_slice &sl)
2503#if(CXSC_INDEX_CHECK)
2504;
2505#else
2506 noexcept;
2507#endif
2509 void accumulate(cidotprecision &dp, const civector & rv1, const cimatrix_subv &rv2)
2510#if(CXSC_INDEX_CHECK)
2511;
2512#else
2513 noexcept;
2514#endif
2516 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const civector &rv2)
2517#if(CXSC_INDEX_CHECK)
2518;
2519#else
2520 noexcept;
2521#endif
2523 void accumulate(cidotprecision &dp, const civector_slice & sl1, const civector_slice &sl2)
2524#if(CXSC_INDEX_CHECK)
2525;
2526#else
2527 noexcept;
2528#endif
2530 void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const cvector &rv2)
2531#if(CXSC_INDEX_CHECK)
2532;
2533#else
2534 noexcept;
2535#endif
2537 void accumulate(cidotprecision &dp, const cvector & rv1, const imatrix_subv &rv2)
2538#if(CXSC_INDEX_CHECK)
2539;
2540#else
2541 noexcept;
2542#endif
2544 void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const cvector_slice &rv2)
2545#if(CXSC_INDEX_CHECK)
2546;
2547#else
2548 noexcept;
2549#endif
2551 void accumulate(cidotprecision &dp, const cvector_slice & rv1, const imatrix_subv &rv2)
2552#if(CXSC_INDEX_CHECK)
2553;
2554#else
2555 noexcept;
2556#endif
2557
2559 INLINE cinterval operator *(const civector & rv1, const civector &rv2)
2560#if(CXSC_INDEX_CHECK)
2561;
2562#else
2563 noexcept;
2564#endif
2566 INLINE cinterval operator *(const civector_slice &sl, const civector &rv)
2567#if(CXSC_INDEX_CHECK)
2568;
2569#else
2570 noexcept;
2571#endif
2573 INLINE cinterval operator *(const civector &rv, const civector_slice &sl)
2574#if(CXSC_INDEX_CHECK)
2575;
2576#else
2577 noexcept;
2578#endif
2580 INLINE cinterval operator *(const civector_slice & sl1, const civector_slice &sl2)
2581#if(CXSC_INDEX_CHECK)
2582;
2583#else
2584 noexcept;
2585#endif
2586
2588 INLINE const civector &operator +(const civector &rv) noexcept;
2590 INLINE civector operator +(const civector_slice &sl) noexcept;
2591
2593 INLINE civector operator +(const civector &rv1, const civector &rv2)
2594#if(CXSC_INDEX_CHECK)
2595;
2596#else
2597 noexcept;
2598#endif
2600 INLINE civector operator +(const civector &rv, const civector_slice &sl)
2601#if(CXSC_INDEX_CHECK)
2602;
2603#else
2604 noexcept;
2605#endif
2607 INLINE civector operator +(const civector_slice &sl, const civector &rv)
2608#if(CXSC_INDEX_CHECK)
2609;
2610#else
2611 noexcept;
2612#endif
2614 INLINE civector operator +(const civector_slice &sl1, const civector_slice &sl2)
2615#if(CXSC_INDEX_CHECK)
2616;
2617#else
2618 noexcept;
2619#endif
2621 INLINE civector & operator +=(civector &rv1, const civector &rv2)
2622#if(CXSC_INDEX_CHECK)
2623;
2624#else
2625 noexcept;
2626#endif
2628 INLINE civector &operator +=(civector &rv, const civector_slice &sl)
2629#if(CXSC_INDEX_CHECK)
2630;
2631#else
2632 noexcept;
2633#endif
2634
2636 INLINE civector operator -(const civector &rv) noexcept;
2638 INLINE civector operator -(const civector_slice &sl) noexcept;
2640 INLINE civector operator -(const civector &rv1, const civector &rv2)
2641#if(CXSC_INDEX_CHECK)
2642;
2643#else
2644 noexcept;
2645#endif
2647 INLINE civector operator -(const civector &rv, const civector_slice &sl)
2648#if(CXSC_INDEX_CHECK)
2649;
2650#else
2651 noexcept;
2652#endif
2654 INLINE civector operator -(const civector_slice &sl, const civector &rv)
2655#if(CXSC_INDEX_CHECK)
2656;
2657#else
2658 noexcept;
2659#endif
2661 INLINE civector operator -(const civector_slice &sl1, const civector_slice &sl2)
2662#if(CXSC_INDEX_CHECK)
2663;
2664#else
2665 noexcept;
2666#endif
2668 INLINE civector & operator -=(civector &rv1, const civector &rv2)
2669#if(CXSC_INDEX_CHECK)
2670;
2671#else
2672 noexcept;
2673#endif
2675 INLINE civector &operator -=(civector &rv, const civector_slice &sl)
2676#if(CXSC_INDEX_CHECK)
2677;
2678#else
2679 noexcept;
2680#endif
2681
2683 INLINE civector operator |(const civector &rv1, const civector &rv2)
2684#if(CXSC_INDEX_CHECK)
2685;
2686#else
2687 noexcept;
2688#endif
2690 INLINE civector operator |(const civector &rv, const civector_slice &sl)
2691#if(CXSC_INDEX_CHECK)
2692;
2693#else
2694 noexcept;
2695#endif
2697 INLINE civector operator |(const civector_slice &sl, const civector &rv)
2698#if(CXSC_INDEX_CHECK)
2699;
2700#else
2701 noexcept;
2702#endif
2704 INLINE civector operator |(const civector_slice &sl1, const civector_slice &sl2)
2705#if(CXSC_INDEX_CHECK)
2706;
2707#else
2708 noexcept;
2709#endif
2711 INLINE civector & operator |=(civector &rv1, const civector &rv2)
2712#if(CXSC_INDEX_CHECK)
2713;
2714#else
2715 noexcept;
2716#endif
2718 INLINE civector &operator |=(civector &rv, const civector_slice &sl)
2719#if(CXSC_INDEX_CHECK)
2720;
2721#else
2722 noexcept;
2723#endif
2724
2726 INLINE civector operator &(const civector &rv1, const civector &rv2)
2727#if(CXSC_INDEX_CHECK)
2728;
2729#else
2730 noexcept;
2731#endif
2733 INLINE civector operator &(const civector &rv, const civector_slice &sl)
2734#if(CXSC_INDEX_CHECK)
2735;
2736#else
2737 noexcept;
2738#endif
2740 INLINE civector operator &(const civector_slice &sl, const civector &rv)
2741#if(CXSC_INDEX_CHECK)
2742;
2743#else
2744 noexcept;
2745#endif
2747 INLINE civector operator &(const civector_slice &sl1, const civector_slice &sl2)
2748#if(CXSC_INDEX_CHECK)
2749;
2750#else
2751 noexcept;
2752#endif
2754 INLINE civector & operator &=(civector &rv1, const civector &rv2)
2755#if(CXSC_INDEX_CHECK)
2756;
2757#else
2758 noexcept;
2759#endif
2761 INLINE civector &operator &=(civector &rv, const civector_slice &sl)
2762#if(CXSC_INDEX_CHECK)
2763;
2764#else
2765 noexcept;
2766#endif
2767
2769 INLINE bool operator ==(const civector &rv1, const civector &rv2) noexcept;
2771 INLINE bool operator ==(const civector_slice &sl1, const civector_slice &sl2) noexcept;
2773 INLINE bool operator ==(const civector_slice &sl, const civector &rv) noexcept;
2775 INLINE bool operator ==(const civector &rv, const civector_slice &sl) noexcept;
2777 INLINE bool operator !=(const civector &rv1, const civector &rv2) noexcept;
2779 INLINE bool operator !=(const civector_slice &sl1, const civector_slice &sl2) noexcept;
2781 INLINE bool operator !=(const civector_slice &sl, const civector &rv) noexcept;
2783 INLINE bool operator !=(const civector &rv, const civector_slice &sl) noexcept;
2785 INLINE bool operator <(const civector &rv1, const civector &rv2) noexcept;
2787 INLINE bool operator <(const civector_slice &sl1, const civector_slice &sl2) noexcept;
2789 INLINE bool operator < (const civector_slice &sl, const civector &rv) noexcept;
2791 INLINE bool operator < (const civector &rv, const civector_slice &sl) noexcept;
2793 INLINE bool operator <=(const civector &rv1, const civector &rv2) noexcept;
2795 INLINE bool operator <=(const civector_slice &sl1, const civector_slice &sl2) noexcept;
2797 INLINE bool operator <=(const civector_slice &sl, const civector &rv) noexcept;
2799 INLINE bool operator <=(const civector &rv, const civector_slice &sl) noexcept;
2801 INLINE bool operator >(const civector &rv1, const civector &rv2) noexcept;
2803 INLINE bool operator >(const civector_slice &sl1, const civector_slice &sl2) noexcept;
2805 INLINE bool operator >(const civector_slice &sl, const civector &rv) noexcept;
2807 INLINE bool operator >(const civector &rv, const civector_slice &sl) noexcept;
2809 INLINE bool operator >=(const civector &rv1, const civector &rv2) noexcept;
2811 INLINE bool operator >=(const civector_slice &sl1, const civector_slice &sl2) noexcept;
2813 INLINE bool operator >=(const civector_slice &sl, const civector &rv) noexcept;
2815 INLINE bool operator >=(const civector &rv, const civector_slice &sl) noexcept;
2816
2817//-------------------------------- cinterval / Real --------------------------------
2818
2820 void accumulate(cidotprecision &dp, const rvector & rv1, const civector &rv2)
2821#if(CXSC_INDEX_CHECK)
2822;
2823#else
2824 noexcept;
2825#endif
2827 void accumulate(cidotprecision &dp, const civector & rv1, const rvector &rv2)
2828#if(CXSC_INDEX_CHECK)
2829;
2830#else
2831 noexcept;
2832#endif
2834 void accumulate(cidotprecision &dp, const rvector_slice & sl, const civector &rv)
2835#if(CXSC_INDEX_CHECK)
2836;
2837#else
2838 noexcept;
2839#endif
2841 void accumulate(cidotprecision &dp,const civector_slice &sl,const rvector &rv)
2842#if(CXSC_INDEX_CHECK)
2843;
2844#else
2845 noexcept;
2846#endif
2848 void accumulate(cidotprecision &dp, const rvector &rv, const civector_slice &sl)
2849#if(CXSC_INDEX_CHECK)
2850;
2851#else
2852 noexcept;
2853#endif
2855 void accumulate(cidotprecision &dp, const rvector & rv1, const cimatrix_subv &rv2)
2856#if(CXSC_INDEX_CHECK)
2857;
2858#else
2859 noexcept;
2860#endif
2862 void accumulate(cidotprecision &dp, const civector & rv1, const rmatrix_subv &rv2)
2863#if(CXSC_INDEX_CHECK)
2864;
2865#else
2866 noexcept;
2867#endif
2869 void accumulate(cidotprecision &dp,const civector &rv,const rvector_slice &sl)
2870#if(CXSC_INDEX_CHECK)
2871;
2872#else
2873 noexcept;
2874#endif
2876 void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const civector &rv2)
2877#if(CXSC_INDEX_CHECK)
2878;
2879#else
2880 noexcept;
2881#endif
2883 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const rvector &rv2)
2884#if(CXSC_INDEX_CHECK)
2885;
2886#else
2887 noexcept;
2888#endif
2890 void accumulate(cidotprecision &dp, const civector_slice & sl1, const rvector_slice &sl2)
2891#if(CXSC_INDEX_CHECK)
2892;
2893#else
2894 noexcept;
2895#endif
2897 void accumulate(cidotprecision &dp, const rvector_slice & sl1, const civector_slice &sl2)
2898#if(CXSC_INDEX_CHECK)
2899;
2900#else
2901 noexcept;
2902#endif
2903
2905 INLINE cinterval operator *(const rvector & rv1, const civector &rv2)
2906#if(CXSC_INDEX_CHECK)
2907;
2908#else
2909 noexcept;
2910#endif
2912 INLINE cinterval operator *(const rvector_slice &sl, const civector &rv)
2913#if(CXSC_INDEX_CHECK)
2914;
2915#else
2916 noexcept;
2917#endif
2919 INLINE cinterval operator *(const rvector &rv, const civector_slice &sl)
2920#if(CXSC_INDEX_CHECK)
2921;
2922#else
2923 noexcept;
2924#endif
2926 INLINE cinterval operator *(const rvector_slice & sl1, const civector_slice &sl2)
2927#if(CXSC_INDEX_CHECK)
2928;
2929#else
2930 noexcept;
2931#endif
2932
2934 INLINE cinterval operator *(const civector & rv1, const rvector &rv2)
2935#if(CXSC_INDEX_CHECK)
2936;
2937#else
2938 noexcept;
2939#endif
2941 INLINE cinterval operator *(const civector_slice &sl, const rvector &rv)
2942#if(CXSC_INDEX_CHECK)
2943;
2944#else
2945 noexcept;
2946#endif
2948 INLINE cinterval operator *(const civector &rv, const rvector_slice &sl)
2949#if(CXSC_INDEX_CHECK)
2950;
2951#else
2952 noexcept;
2953#endif
2955 INLINE cinterval operator *(const civector_slice & sl1, const rvector_slice &sl2)
2956#if(CXSC_INDEX_CHECK)
2957;
2958#else
2959 noexcept;
2960#endif
2961
2963 INLINE civector operator +(const rvector &rv1, const civector &rv2)
2964#if(CXSC_INDEX_CHECK)
2965;
2966#else
2967 noexcept;
2968#endif
2970 INLINE civector operator +(const rvector &rv, const civector_slice &sl)
2971#if(CXSC_INDEX_CHECK)
2972;
2973#else
2974 noexcept;
2975#endif
2977 INLINE civector operator +(const rvector_slice &sl, const civector &rv)
2978#if(CXSC_INDEX_CHECK)
2979;
2980#else
2981 noexcept;
2982#endif
2984 INLINE civector operator +(const rvector_slice &sl1, const civector_slice &sl2)
2985#if(CXSC_INDEX_CHECK)
2986;
2987#else
2988 noexcept;
2989#endif
2990
2992 INLINE civector operator +(const civector &rv1, const rvector &rv2)
2993#if(CXSC_INDEX_CHECK)
2994;
2995#else
2996 noexcept;
2997#endif
2999 INLINE civector operator +(const civector &rv, const rvector_slice &sl)
3000#if(CXSC_INDEX_CHECK)
3001;
3002#else
3003 noexcept;
3004#endif
3006 INLINE civector operator +(const civector_slice &sl, const rvector &rv)
3007#if(CXSC_INDEX_CHECK)
3008;
3009#else
3010 noexcept;
3011#endif
3013 INLINE civector operator +(const civector_slice &sl1, const rvector_slice &sl2)
3014#if(CXSC_INDEX_CHECK)
3015;
3016#else
3017 noexcept;
3018#endif
3019
3021 INLINE civector & operator +=(civector &rv1, const rvector &rv2)
3022#if(CXSC_INDEX_CHECK)
3023;
3024#else
3025 noexcept;
3026#endif
3028 INLINE civector &operator +=(civector &rv, const rvector_slice &sl)
3029#if(CXSC_INDEX_CHECK)
3030;
3031#else
3032 noexcept;
3033#endif
3034
3036 INLINE civector operator -(const rvector &rv1, const civector &rv2)
3037#if(CXSC_INDEX_CHECK)
3038;
3039#else
3040 noexcept;
3041#endif
3043 INLINE civector operator -(const rvector &rv, const civector_slice &sl)
3044#if(CXSC_INDEX_CHECK)
3045;
3046#else
3047 noexcept;
3048#endif
3050 INLINE civector operator -(const rvector_slice &sl, const civector &rv)
3051#if(CXSC_INDEX_CHECK)
3052;
3053#else
3054 noexcept;
3055#endif
3057 INLINE civector operator -(const rvector_slice &sl1, const civector_slice &sl2)
3058#if(CXSC_INDEX_CHECK)
3059;
3060#else
3061 noexcept;
3062#endif
3063
3065 INLINE civector operator -(const civector &rv1, const rvector &rv2)
3066#if(CXSC_INDEX_CHECK)
3067;
3068#else
3069 noexcept;
3070#endif
3072 INLINE civector operator -(const civector &rv, const rvector_slice &sl)
3073#if(CXSC_INDEX_CHECK)
3074;
3075#else
3076 noexcept;
3077#endif
3079 INLINE civector operator -(const civector_slice &sl, const rvector &rv)
3080#if(CXSC_INDEX_CHECK)
3081;
3082#else
3083 noexcept;
3084#endif
3086 INLINE civector operator -(const civector_slice &sl1, const rvector_slice &sl2)
3087#if(CXSC_INDEX_CHECK)
3088;
3089#else
3090 noexcept;
3091#endif
3092
3094 INLINE civector & operator -=(civector &rv1, const rvector &rv2)
3095#if(CXSC_INDEX_CHECK)
3096;
3097#else
3098 noexcept;
3099#endif
3101 INLINE civector &operator -=(civector &rv, const rvector_slice &sl)
3102#if(CXSC_INDEX_CHECK)
3103;
3104#else
3105 noexcept;
3106#endif
3107
3109 INLINE civector operator |(const rvector &rv1, const civector &rv2)
3110#if(CXSC_INDEX_CHECK)
3111;
3112#else
3113 noexcept;
3114#endif
3116 INLINE civector operator |(const rvector &rv, const civector_slice &sl)
3117#if(CXSC_INDEX_CHECK)
3118;
3119#else
3120 noexcept;
3121#endif
3123 INLINE civector operator |(const rvector_slice &sl, const civector &rv)
3124#if(CXSC_INDEX_CHECK)
3125;
3126#else
3127 noexcept;
3128#endif
3130 INLINE civector operator |(const rvector_slice &sl1, const civector_slice &sl2)
3131#if(CXSC_INDEX_CHECK)
3132;
3133#else
3134 noexcept;
3135#endif
3136
3138 INLINE civector operator |(const civector &rv1, const rvector &rv2)
3139#if(CXSC_INDEX_CHECK)
3140;
3141#else
3142 noexcept;
3143#endif
3145 INLINE civector operator |(const civector &rv, const rvector_slice &sl)
3146#if(CXSC_INDEX_CHECK)
3147;
3148#else
3149 noexcept;
3150#endif
3152 INLINE civector operator |(const civector_slice &sl, const rvector &rv)
3153#if(CXSC_INDEX_CHECK)
3154;
3155#else
3156 noexcept;
3157#endif
3159 INLINE civector operator |(const civector_slice &sl1, const rvector_slice &sl2)
3160#if(CXSC_INDEX_CHECK)
3161;
3162#else
3163 noexcept;
3164#endif
3165
3167 INLINE civector & operator |=(civector &rv1, const rvector &rv2)
3168#if(CXSC_INDEX_CHECK)
3169;
3170#else
3171 noexcept;
3172#endif
3174 INLINE civector &operator |=(civector &rv, const rvector_slice &sl)
3175#if(CXSC_INDEX_CHECK)
3176;
3177#else
3178 noexcept;
3179#endif
3180
3182 INLINE civector operator &(const rvector &rv1, const civector &rv2)
3183#if(CXSC_INDEX_CHECK)
3184;
3185#else
3186 noexcept;
3187#endif
3189 INLINE civector operator &(const rvector &rv, const civector_slice &sl)
3190#if(CXSC_INDEX_CHECK)
3191;
3192#else
3193 noexcept;
3194#endif
3196 INLINE civector operator &(const rvector_slice &sl, const civector &rv)
3197#if(CXSC_INDEX_CHECK)
3198;
3199#else
3200 noexcept;
3201#endif
3203 INLINE civector operator &(const rvector_slice &sl1, const civector_slice &sl2)
3204#if(CXSC_INDEX_CHECK)
3205;
3206#else
3207 noexcept;
3208#endif
3209
3211 INLINE civector operator &(const civector &rv1, const rvector &rv2)
3212#if(CXSC_INDEX_CHECK)
3213;
3214#else
3215 noexcept;
3216#endif
3218 INLINE civector operator &(const civector &rv, const rvector_slice &sl)
3219#if(CXSC_INDEX_CHECK)
3220;
3221#else
3222 noexcept;
3223#endif
3225 INLINE civector operator &(const civector_slice &sl, const rvector &rv)
3226#if(CXSC_INDEX_CHECK)
3227;
3228#else
3229 noexcept;
3230#endif
3232 INLINE civector operator &(const civector_slice &sl1, const rvector_slice &sl2)
3233#if(CXSC_INDEX_CHECK)
3234;
3235#else
3236 noexcept;
3237#endif
3238
3240 INLINE civector & operator &=(civector &rv1, const rvector &rv2)
3241#if(CXSC_INDEX_CHECK)
3242;
3243#else
3244 noexcept;
3245#endif
3247 INLINE civector &operator &=(civector &rv, const rvector_slice &sl)
3248#if(CXSC_INDEX_CHECK)
3249;
3250#else
3251 noexcept;
3252#endif
3253//-------------------------------- cinterval / complex --------------------------------
3254
3256 void accumulate(cidotprecision &dp, const cvector & rv1, const civector &rv2)
3257#if(CXSC_INDEX_CHECK)
3258;
3259#else
3260 noexcept;
3261#endif
3263 void accumulate(cidotprecision &dp, const civector & rv1, const cvector &rv2)
3264#if(CXSC_INDEX_CHECK)
3265;
3266#else
3267 noexcept;
3268#endif
3270 void accumulate(cidotprecision &dp, const cvector_slice & sl, const civector &rv)
3271#if(CXSC_INDEX_CHECK)
3272;
3273#else
3274 noexcept;
3275#endif
3277 void accumulate(cidotprecision &dp,const civector_slice &sl,const cvector &rv)
3278#if(CXSC_INDEX_CHECK)
3279;
3280#else
3281 noexcept;
3282#endif
3284 void accumulate(cidotprecision &dp, const cvector &rv, const civector_slice &sl)
3285#if(CXSC_INDEX_CHECK)
3286;
3287#else
3288 noexcept;
3289#endif
3291 void accumulate(cidotprecision &dp, const cvector & rv1, const cimatrix_subv &rv2)
3292#if(CXSC_INDEX_CHECK)
3293;
3294#else
3295 noexcept;
3296#endif
3298 void accumulate(cidotprecision &dp, const civector & rv1, const cmatrix_subv &rv2)
3299#if(CXSC_INDEX_CHECK)
3300;
3301#else
3302 noexcept;
3303#endif
3305 void accumulate(cidotprecision &dp,const civector &rv,const cvector_slice &sl)
3306#if(CXSC_INDEX_CHECK)
3307;
3308#else
3309 noexcept;
3310#endif
3312 void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const civector &rv2)
3313#if(CXSC_INDEX_CHECK)
3314;
3315#else
3316 noexcept;
3317#endif
3319 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const cvector &rv2)
3320#if(CXSC_INDEX_CHECK)
3321;
3322#else
3323 noexcept;
3324#endif
3326 void accumulate(cidotprecision &dp, const civector_slice & sl1, const cvector_slice &sl2)
3327#if(CXSC_INDEX_CHECK)
3328;
3329#else
3330 noexcept;
3331#endif
3333 void accumulate(cidotprecision &dp, const cvector_slice & sl1, const civector_slice &sl2)
3334#if(CXSC_INDEX_CHECK)
3335;
3336#else
3337 noexcept;
3338#endif
3339
3340
3341
3342
3344 INLINE cinterval operator *(const cvector & rv1, const civector &rv2)
3345#if(CXSC_INDEX_CHECK)
3346;
3347#else
3348 noexcept;
3349#endif
3351 INLINE cinterval operator *(const cvector_slice &sl, const civector &rv)
3352#if(CXSC_INDEX_CHECK)
3353;
3354#else
3355 noexcept;
3356#endif
3358 INLINE cinterval operator *(const cvector &rv, const civector_slice &sl)
3359#if(CXSC_INDEX_CHECK)
3360;
3361#else
3362 noexcept;
3363#endif
3365 INLINE cinterval operator *(const cvector_slice & sl1, const civector_slice &sl2)
3366#if(CXSC_INDEX_CHECK)
3367;
3368#else
3369 noexcept;
3370#endif
3371
3373 INLINE cinterval operator *(const civector & rv1, const cvector &rv2)
3374#if(CXSC_INDEX_CHECK)
3375;
3376#else
3377 noexcept;
3378#endif
3380 INLINE cinterval operator *(const civector_slice &sl, const cvector &rv)
3381#if(CXSC_INDEX_CHECK)
3382;
3383#else
3384 noexcept;
3385#endif
3387 INLINE cinterval operator *(const civector &rv, const cvector_slice &sl)
3388#if(CXSC_INDEX_CHECK)
3389;
3390#else
3391 noexcept;
3392#endif
3394 INLINE cinterval operator *(const civector_slice & sl1, const cvector_slice &sl2)
3395#if(CXSC_INDEX_CHECK)
3396;
3397#else
3398 noexcept;
3399#endif
3400
3402 INLINE civector operator +(const cvector &rv1, const civector &rv2)
3403#if(CXSC_INDEX_CHECK)
3404;
3405#else
3406 noexcept;
3407#endif
3409 INLINE civector operator +(const cvector &rv, const civector_slice &sl)
3410#if(CXSC_INDEX_CHECK)
3411;
3412#else
3413 noexcept;
3414#endif
3416 INLINE civector operator +(const cvector_slice &sl, const civector &rv)
3417#if(CXSC_INDEX_CHECK)
3418;
3419#else
3420 noexcept;
3421#endif
3423 INLINE civector operator +(const cvector_slice &sl1, const civector_slice &sl2)
3424#if(CXSC_INDEX_CHECK)
3425;
3426#else
3427 noexcept;
3428#endif
3429
3431 INLINE civector operator +(const civector &rv1, const cvector &rv2)
3432#if(CXSC_INDEX_CHECK)
3433;
3434#else
3435 noexcept;
3436#endif
3438 INLINE civector operator +(const civector &rv, const cvector_slice &sl)
3439#if(CXSC_INDEX_CHECK)
3440;
3441#else
3442 noexcept;
3443#endif
3445 INLINE civector operator +(const civector_slice &sl, const cvector &rv)
3446#if(CXSC_INDEX_CHECK)
3447;
3448#else
3449 noexcept;
3450#endif
3452 INLINE civector operator +(const civector_slice &sl1, const cvector_slice &sl2)
3453#if(CXSC_INDEX_CHECK)
3454;
3455#else
3456 noexcept;
3457#endif
3458
3460 INLINE civector & operator +=(civector &rv1, const cvector &rv2)
3461#if(CXSC_INDEX_CHECK)
3462;
3463#else
3464 noexcept;
3465#endif
3467 INLINE civector &operator +=(civector &rv, const cvector_slice &sl)
3468#if(CXSC_INDEX_CHECK)
3469;
3470#else
3471 noexcept;
3472#endif
3473
3475 INLINE civector operator -(const cvector &rv1, const civector &rv2)
3476#if(CXSC_INDEX_CHECK)
3477;
3478#else
3479 noexcept;
3480#endif
3482 INLINE civector operator -(const cvector &rv, const civector_slice &sl)
3483#if(CXSC_INDEX_CHECK)
3484;
3485#else
3486 noexcept;
3487#endif
3489 INLINE civector operator -(const cvector_slice &sl, const civector &rv)
3490#if(CXSC_INDEX_CHECK)
3491;
3492#else
3493 noexcept;
3494#endif
3496 INLINE civector operator -(const cvector_slice &sl1, const civector_slice &sl2)
3497#if(CXSC_INDEX_CHECK)
3498;
3499#else
3500 noexcept;
3501#endif
3502
3504 INLINE civector operator -(const civector &rv1, const cvector &rv2)
3505#if(CXSC_INDEX_CHECK)
3506;
3507#else
3508 noexcept;
3509#endif
3511 INLINE civector operator -(const civector &rv, const cvector_slice &sl)
3512#if(CXSC_INDEX_CHECK)
3513;
3514#else
3515 noexcept;
3516#endif
3518 INLINE civector operator -(const civector_slice &sl, const cvector &rv)
3519#if(CXSC_INDEX_CHECK)
3520;
3521#else
3522 noexcept;
3523#endif
3525 INLINE civector operator -(const civector_slice &sl1, const cvector_slice &sl2)
3526#if(CXSC_INDEX_CHECK)
3527;
3528#else
3529 noexcept;
3530#endif
3531
3533 INLINE civector & operator -=(civector &rv1, const cvector &rv2)
3534#if(CXSC_INDEX_CHECK)
3535;
3536#else
3537 noexcept;
3538#endif
3540 INLINE civector &operator -=(civector &rv, const cvector_slice &sl)
3541#if(CXSC_INDEX_CHECK)
3542;
3543#else
3544 noexcept;
3545#endif
3546
3548 INLINE civector operator |(const cvector &rv1, const civector &rv2)
3549#if(CXSC_INDEX_CHECK)
3550;
3551#else
3552 noexcept;
3553#endif
3555 INLINE civector operator |(const cvector &rv, const civector_slice &sl)
3556#if(CXSC_INDEX_CHECK)
3557;
3558#else
3559 noexcept;
3560#endif
3562 INLINE civector operator |(const cvector_slice &sl, const civector &rv)
3563#if(CXSC_INDEX_CHECK)
3564;
3565#else
3566 noexcept;
3567#endif
3569 INLINE civector operator |(const cvector_slice &sl1, const civector_slice &sl2)
3570#if(CXSC_INDEX_CHECK)
3571;
3572#else
3573 noexcept;
3574#endif
3575
3577 INLINE civector operator |(const civector &rv1, const cvector &rv2)
3578#if(CXSC_INDEX_CHECK)
3579;
3580#else
3581 noexcept;
3582#endif
3584 INLINE civector operator |(const civector &rv, const cvector_slice &sl)
3585#if(CXSC_INDEX_CHECK)
3586;
3587#else
3588 noexcept;
3589#endif
3591 INLINE civector operator |(const civector_slice &sl, const cvector &rv)
3592#if(CXSC_INDEX_CHECK)
3593;
3594#else
3595 noexcept;
3596#endif
3598 INLINE civector operator |(const civector_slice &sl1, const cvector_slice &sl2)
3599#if(CXSC_INDEX_CHECK)
3600;
3601#else
3602 noexcept;
3603#endif
3604
3606 INLINE civector & operator |=(civector &rv1, const cvector &rv2)
3607#if(CXSC_INDEX_CHECK)
3608;
3609#else
3610 noexcept;
3611#endif
3613 INLINE civector &operator |=(civector &rv, const cvector_slice &sl)
3614#if(CXSC_INDEX_CHECK)
3615;
3616#else
3617 noexcept;
3618#endif
3619
3621 INLINE civector operator &(const cvector &rv1, const civector &rv2)
3622#if(CXSC_INDEX_CHECK)
3623;
3624#else
3625 noexcept;
3626#endif
3628 INLINE civector operator &(const cvector &rv, const civector_slice &sl)
3629#if(CXSC_INDEX_CHECK)
3630;
3631#else
3632 noexcept;
3633#endif
3635 INLINE civector operator &(const cvector_slice &sl, const civector &rv)
3636#if(CXSC_INDEX_CHECK)
3637;
3638#else
3639 noexcept;
3640#endif
3642 INLINE civector operator &(const cvector_slice &sl1, const civector_slice &sl2)
3643#if(CXSC_INDEX_CHECK)
3644;
3645#else
3646 noexcept;
3647#endif
3648
3650 INLINE civector operator &(const civector &rv1, const cvector &rv2)
3651#if(CXSC_INDEX_CHECK)
3652;
3653#else
3654 noexcept;
3655#endif
3657 INLINE civector operator &(const civector &rv, const cvector_slice &sl)
3658#if(CXSC_INDEX_CHECK)
3659;
3660#else
3661 noexcept;
3662#endif
3664 INLINE civector operator &(const civector_slice &sl, const cvector &rv)
3665#if(CXSC_INDEX_CHECK)
3666;
3667#else
3668 noexcept;
3669#endif
3671 INLINE civector operator &(const civector_slice &sl1, const cvector_slice &sl2)
3672#if(CXSC_INDEX_CHECK)
3673;
3674#else
3675 noexcept;
3676#endif
3677
3679 INLINE civector & operator &=(civector &rv1, const cvector &rv2)
3680#if(CXSC_INDEX_CHECK)
3681;
3682#else
3683 noexcept;
3684#endif
3686 INLINE civector &operator &=(civector &rv, const cvector_slice &sl)
3687#if(CXSC_INDEX_CHECK)
3688;
3689#else
3690 noexcept;
3691#endif
3692
3693//-------------------------------- cinterval / interval --------------------------------
3694
3696 void accumulate(cidotprecision &dp, const ivector & rv1, const civector &rv2)
3697#if(CXSC_INDEX_CHECK)
3698;
3699#else
3700 noexcept;
3701#endif
3703 void accumulate(cidotprecision &dp, const civector & rv1, const ivector &rv2)
3704#if(CXSC_INDEX_CHECK)
3705;
3706#else
3707 noexcept;
3708#endif
3710 void accumulate(cidotprecision &dp, const ivector_slice & sl, const civector &rv)
3711#if(CXSC_INDEX_CHECK)
3712;
3713#else
3714 noexcept;
3715#endif
3717 void accumulate(cidotprecision &dp,const civector_slice &sl,const ivector &rv)
3718#if(CXSC_INDEX_CHECK)
3719;
3720#else
3721 noexcept;
3722#endif
3724 void accumulate(cidotprecision &dp, const ivector &rv, const civector_slice &sl)
3725#if(CXSC_INDEX_CHECK)
3726;
3727#else
3728 noexcept;
3729#endif
3731 void accumulate(cidotprecision &dp, const ivector & rv1, const cimatrix_subv &rv2)
3732#if(CXSC_INDEX_CHECK)
3733;
3734#else
3735 noexcept;
3736#endif
3738 void accumulate(cidotprecision &dp, const civector & rv1, const imatrix_subv &rv2)
3739#if(CXSC_INDEX_CHECK)
3740;
3741#else
3742 noexcept;
3743#endif
3745 void accumulate(cidotprecision &dp,const civector &rv,const ivector_slice &sl)
3746#if(CXSC_INDEX_CHECK)
3747;
3748#else
3749 noexcept;
3750#endif
3752 void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const civector &rv2)
3753#if(CXSC_INDEX_CHECK)
3754;
3755#else
3756 noexcept;
3757#endif
3759 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const ivector &rv2)
3760#if(CXSC_INDEX_CHECK)
3761;
3762#else
3763 noexcept;
3764#endif
3766 void accumulate(cidotprecision &dp, const civector_slice & sl1, const ivector_slice &sl2)
3767#if(CXSC_INDEX_CHECK)
3768;
3769#else
3770 noexcept;
3771#endif
3773 void accumulate(cidotprecision &dp, const ivector_slice & sl1, const civector_slice &sl2)
3774#if(CXSC_INDEX_CHECK)
3775;
3776#else
3777 noexcept;
3778#endif
3780 void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const civector &rv2)
3781#if(CXSC_INDEX_CHECK)
3782;
3783#else
3784 noexcept;
3785#endif
3787 void accumulate(cidotprecision &dp, const civector & rv1, const cmatrix_subv &rv2)
3788#if(CXSC_INDEX_CHECK)
3789;
3790#else
3791 noexcept;
3792#endif
3794 void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const civector_slice &rv2)
3795#if(CXSC_INDEX_CHECK)
3796;
3797#else
3798 noexcept;
3799#endif
3801 void accumulate(cidotprecision &dp, const civector_slice & rv1, const cmatrix_subv &rv2)
3802#if(CXSC_INDEX_CHECK)
3803;
3804#else
3805 noexcept;
3806#endif
3807
3809 void accumulate(cidotprecision &dp, const civector_slice & sl1, const rmatrix_subv &sl2)
3810#if(CXSC_INDEX_CHECK)
3811;
3812#else
3813 noexcept;
3814#endif
3816 void accumulate(cidotprecision &dp, const rmatrix_subv & sl1, const civector_slice &sl2)
3817#if(CXSC_INDEX_CHECK)
3818;
3819#else
3820 noexcept;
3821#endif
3822
3824 INLINE cinterval operator *(const ivector & rv1, const civector &rv2)
3825#if(CXSC_INDEX_CHECK)
3826;
3827#else
3828 noexcept;
3829#endif
3831 INLINE cinterval operator *(const ivector_slice &sl, const civector &rv)
3832#if(CXSC_INDEX_CHECK)
3833;
3834#else
3835 noexcept;
3836#endif
3838 INLINE cinterval operator *(const ivector &rv, const civector_slice &sl)
3839#if(CXSC_INDEX_CHECK)
3840;
3841#else
3842 noexcept;
3843#endif
3845 INLINE cinterval operator *(const ivector_slice & sl1, const civector_slice &sl2)
3846#if(CXSC_INDEX_CHECK)
3847;
3848#else
3849 noexcept;
3850#endif
3851
3853 INLINE cinterval operator *(const civector & rv1, const ivector &rv2)
3854#if(CXSC_INDEX_CHECK)
3855;
3856#else
3857 noexcept;
3858#endif
3860 INLINE cinterval operator *(const civector_slice &sl, const ivector &rv)
3861#if(CXSC_INDEX_CHECK)
3862;
3863#else
3864 noexcept;
3865#endif
3867 INLINE cinterval operator *(const civector &rv, const ivector_slice &sl)
3868#if(CXSC_INDEX_CHECK)
3869;
3870#else
3871 noexcept;
3872#endif
3874 INLINE cinterval operator *(const civector_slice & sl1, const ivector_slice &sl2)
3875#if(CXSC_INDEX_CHECK)
3876;
3877#else
3878 noexcept;
3879#endif
3880
3882 INLINE civector operator +(const ivector &rv1, const civector &rv2)
3883#if(CXSC_INDEX_CHECK)
3884;
3885#else
3886 noexcept;
3887#endif
3889 INLINE civector operator +(const ivector &rv, const civector_slice &sl)
3890#if(CXSC_INDEX_CHECK)
3891;
3892#else
3893 noexcept;
3894#endif
3896 INLINE civector operator +(const ivector_slice &sl, const civector &rv)
3897#if(CXSC_INDEX_CHECK)
3898;
3899#else
3900 noexcept;
3901#endif
3903 INLINE civector operator +(const ivector_slice &sl1, const civector_slice &sl2)
3904#if(CXSC_INDEX_CHECK)
3905;
3906#else
3907 noexcept;
3908#endif
3909
3911 INLINE civector operator +(const civector &rv1, const ivector &rv2)
3912#if(CXSC_INDEX_CHECK)
3913;
3914#else
3915 noexcept;
3916#endif
3918 INLINE civector operator +(const civector &rv, const ivector_slice &sl)
3919#if(CXSC_INDEX_CHECK)
3920;
3921#else
3922 noexcept;
3923#endif
3925 INLINE civector operator +(const civector_slice &sl, const ivector &rv)
3926#if(CXSC_INDEX_CHECK)
3927;
3928#else
3929 noexcept;
3930#endif
3932 INLINE civector operator +(const civector_slice &sl1, const ivector_slice &sl2)
3933#if(CXSC_INDEX_CHECK)
3934;
3935#else
3936 noexcept;
3937#endif
3938
3940 INLINE civector & operator +=(civector &rv1, const ivector &rv2)
3941#if(CXSC_INDEX_CHECK)
3942;
3943#else
3944 noexcept;
3945#endif
3947 INLINE civector &operator +=(civector &rv, const ivector_slice &sl)
3948#if(CXSC_INDEX_CHECK)
3949;
3950#else
3951 noexcept;
3952#endif
3953
3955 INLINE civector operator -(const ivector &rv1, const civector &rv2)
3956#if(CXSC_INDEX_CHECK)
3957;
3958#else
3959 noexcept;
3960#endif
3962 INLINE civector operator -(const ivector &rv, const civector_slice &sl)
3963#if(CXSC_INDEX_CHECK)
3964;
3965#else
3966 noexcept;
3967#endif
3969 INLINE civector operator -(const ivector_slice &sl, const civector &rv)
3970#if(CXSC_INDEX_CHECK)
3971;
3972#else
3973 noexcept;
3974#endif
3976 INLINE civector operator -(const ivector_slice &sl1, const civector_slice &sl2)
3977#if(CXSC_INDEX_CHECK)
3978;
3979#else
3980 noexcept;
3981#endif
3982
3984 INLINE civector operator -(const civector &rv1, const ivector &rv2)
3985#if(CXSC_INDEX_CHECK)
3986;
3987#else
3988 noexcept;
3989#endif
3991 INLINE civector operator -(const civector &rv, const ivector_slice &sl)
3992#if(CXSC_INDEX_CHECK)
3993;
3994#else
3995 noexcept;
3996#endif
3998 INLINE civector operator -(const civector_slice &sl, const ivector &rv)
3999#if(CXSC_INDEX_CHECK)
4000;
4001#else
4002 noexcept;
4003#endif
4005 INLINE civector operator -(const civector_slice &sl1, const ivector_slice &sl2)
4006#if(CXSC_INDEX_CHECK)
4007;
4008#else
4009 noexcept;
4010#endif
4011
4013 INLINE civector & operator -=(civector &rv1, const ivector &rv2)
4014#if(CXSC_INDEX_CHECK)
4015;
4016#else
4017 noexcept;
4018#endif
4020 INLINE civector &operator -=(civector &rv, const ivector_slice &sl)
4021#if(CXSC_INDEX_CHECK)
4022;
4023#else
4024 noexcept;
4025#endif
4026
4028 INLINE civector operator |(const ivector &rv1, const civector &rv2)
4029#if(CXSC_INDEX_CHECK)
4030;
4031#else
4032 noexcept;
4033#endif
4035 INLINE civector operator |(const ivector &rv, const civector_slice &sl)
4036#if(CXSC_INDEX_CHECK)
4037;
4038#else
4039 noexcept;
4040#endif
4042 INLINE civector operator |(const ivector_slice &sl, const civector &rv)
4043#if(CXSC_INDEX_CHECK)
4044;
4045#else
4046 noexcept;
4047#endif
4049 INLINE civector operator |(const ivector_slice &sl1, const civector_slice &sl2)
4050#if(CXSC_INDEX_CHECK)
4051;
4052#else
4053 noexcept;
4054#endif
4055
4057 INLINE civector operator |(const civector &rv1, const ivector &rv2)
4058#if(CXSC_INDEX_CHECK)
4059;
4060#else
4061 noexcept;
4062#endif
4064 INLINE civector operator |(const civector &rv, const ivector_slice &sl)
4065#if(CXSC_INDEX_CHECK)
4066;
4067#else
4068 noexcept;
4069#endif
4071 INLINE civector operator |(const civector_slice &sl, const ivector &rv)
4072#if(CXSC_INDEX_CHECK)
4073;
4074#else
4075 noexcept;
4076#endif
4078 INLINE civector operator |(const civector_slice &sl1, const ivector_slice &sl2)
4079#if(CXSC_INDEX_CHECK)
4080;
4081#else
4082 noexcept;
4083#endif
4084
4086 INLINE civector & operator |=(civector &rv1, const ivector &rv2)
4087#if(CXSC_INDEX_CHECK)
4088;
4089#else
4090 noexcept;
4091#endif
4093 INLINE civector &operator |=(civector &rv, const ivector_slice &sl)
4094#if(CXSC_INDEX_CHECK)
4095;
4096#else
4097 noexcept;
4098#endif
4099
4101 INLINE civector operator &(const ivector &rv1, const civector &rv2)
4102#if(CXSC_INDEX_CHECK)
4103;
4104#else
4105 noexcept;
4106#endif
4108 INLINE civector operator &(const ivector &rv, const civector_slice &sl)
4109#if(CXSC_INDEX_CHECK)
4110;
4111#else
4112 noexcept;
4113#endif
4115 INLINE civector operator &(const ivector_slice &sl, const civector &rv)
4116#if(CXSC_INDEX_CHECK)
4117;
4118#else
4119 noexcept;
4120#endif
4122 INLINE civector operator &(const ivector_slice &sl1, const civector_slice &sl2)
4123#if(CXSC_INDEX_CHECK)
4124;
4125#else
4126 noexcept;
4127#endif
4128
4130 INLINE civector operator &(const civector &rv1, const ivector &rv2)
4131#if(CXSC_INDEX_CHECK)
4132;
4133#else
4134 noexcept;
4135#endif
4137 INLINE civector operator &(const civector &rv, const ivector_slice &sl)
4138#if(CXSC_INDEX_CHECK)
4139;
4140#else
4141 noexcept;
4142#endif
4144 INLINE civector operator &(const civector_slice &sl, const ivector &rv)
4145#if(CXSC_INDEX_CHECK)
4146;
4147#else
4148 noexcept;
4149#endif
4151 INLINE civector operator &(const civector_slice &sl1, const ivector_slice &sl2)
4152#if(CXSC_INDEX_CHECK)
4153;
4154#else
4155 noexcept;
4156#endif
4157
4159 INLINE civector & operator &=(civector &rv1, const ivector &rv2)
4160#if(CXSC_INDEX_CHECK)
4161;
4162#else
4163 noexcept;
4164#endif
4166 INLINE civector &operator &=(civector &rv, const ivector_slice &sl)
4167#if(CXSC_INDEX_CHECK)
4168;
4169#else
4170 noexcept;
4171#endif
4172
4173//------------- real x complex ------------------------
4175 INLINE civector operator |(const rvector &rv1, const cvector &rv2)
4176#if(CXSC_INDEX_CHECK)
4177;
4178#else
4179 noexcept;
4180#endif
4182 INLINE civector operator |(const cvector &rv1, const rvector &rv2)
4183#if(CXSC_INDEX_CHECK)
4184;
4185#else
4186 noexcept;
4187#endif
4189 INLINE civector operator |(const cvector &rv, const rvector_slice &sl)
4190#if(CXSC_INDEX_CHECK)
4191;
4192#else
4193 noexcept;
4194#endif
4196 INLINE civector operator |(const rvector_slice &sl,const cvector &rv)
4197#if(CXSC_INDEX_CHECK)
4198;
4199#else
4200 noexcept;
4201#endif
4203 INLINE civector operator |(const cvector_slice &sl, const rvector &rv)
4204#if(CXSC_INDEX_CHECK)
4205;
4206#else
4207 noexcept;
4208#endif
4210 INLINE civector operator |(const rvector &rv,const cvector_slice &sl)
4211#if(CXSC_INDEX_CHECK)
4212;
4213#else
4214 noexcept;
4215#endif
4217 INLINE civector operator |(const cvector_slice &sl1, const rvector_slice &sl2)
4218#if(CXSC_INDEX_CHECK)
4219;
4220#else
4221 noexcept;
4222#endif
4224 INLINE civector operator |(const rvector_slice &sl1, const cvector_slice &sl2)
4225#if(CXSC_INDEX_CHECK)
4226;
4227#else
4228 noexcept;
4229#endif
4230
4231//------------- complex x complex ------------------------
4233 INLINE civector operator |(const cvector &rv1, const cvector &rv2)
4234#if(CXSC_INDEX_CHECK)
4235;
4236#else
4237 noexcept;
4238#endif
4240 INLINE civector operator |(const cvector_slice &sl, const cvector &rv)
4241#if(CXSC_INDEX_CHECK)
4242;
4243#else
4244 noexcept;
4245#endif
4247 INLINE civector operator |(const cvector &rv,const cvector_slice &sl)
4248#if(CXSC_INDEX_CHECK)
4249;
4250#else
4251 noexcept;
4252#endif
4254 INLINE civector operator |(const cvector_slice &sl1, const cvector_slice &sl2)
4255#if(CXSC_INDEX_CHECK)
4256;
4257#else
4258 noexcept;
4259#endif
4260
4261//-------------------------------- interval / complex --------------------------------
4262
4263// multiplication in iveccvec.hpp
4264
4266 INLINE civector operator +(const cvector &rv1, const ivector &rv2)
4267#if(CXSC_INDEX_CHECK)
4268;
4269#else
4270 noexcept;
4271#endif
4273 INLINE civector operator +(const cvector &rv, const ivector_slice &sl)
4274#if(CXSC_INDEX_CHECK)
4275;
4276#else
4277 noexcept;
4278#endif
4280 INLINE civector operator +(const cvector_slice &sl, const ivector &rv)
4281#if(CXSC_INDEX_CHECK)
4282;
4283#else
4284 noexcept;
4285#endif
4287 INLINE civector operator +(const cvector_slice &sl1, const ivector_slice &sl2)
4288#if(CXSC_INDEX_CHECK)
4289;
4290#else
4291 noexcept;
4292#endif
4293
4295 INLINE civector operator +(const ivector &rv1, const cvector &rv2)
4296#if(CXSC_INDEX_CHECK)
4297;
4298#else
4299 noexcept;
4300#endif
4302 INLINE civector operator +(const ivector &rv, const cvector_slice &sl)
4303#if(CXSC_INDEX_CHECK)
4304;
4305#else
4306 noexcept;
4307#endif
4309 INLINE civector operator +(const ivector_slice &sl, const cvector &rv)
4310#if(CXSC_INDEX_CHECK)
4311;
4312#else
4313 noexcept;
4314#endif
4316 INLINE civector operator +(const ivector_slice &sl1, const cvector_slice &sl2)
4317#if(CXSC_INDEX_CHECK)
4318;
4319#else
4320 noexcept;
4321#endif
4322
4323
4325 INLINE civector operator -(const cvector &rv1, const ivector &rv2)
4326#if(CXSC_INDEX_CHECK)
4327;
4328#else
4329 noexcept;
4330#endif
4332 INLINE civector operator -(const cvector &rv, const ivector_slice &sl)
4333#if(CXSC_INDEX_CHECK)
4334;
4335#else
4336 noexcept;
4337#endif
4339 INLINE civector operator -(const cvector_slice &sl, const ivector &rv)
4340#if(CXSC_INDEX_CHECK)
4341;
4342#else
4343 noexcept;
4344#endif
4346 INLINE civector operator -(const cvector_slice &sl1, const ivector_slice &sl2)
4347#if(CXSC_INDEX_CHECK)
4348;
4349#else
4350 noexcept;
4351#endif
4352
4354 INLINE civector operator -(const ivector &rv1, const cvector &rv2)
4355#if(CXSC_INDEX_CHECK)
4356;
4357#else
4358 noexcept;
4359#endif
4361 INLINE civector operator -(const ivector &rv, const cvector_slice &sl)
4362#if(CXSC_INDEX_CHECK)
4363;
4364#else
4365 noexcept;
4366#endif
4368 INLINE civector operator -(const ivector_slice &sl, const cvector &rv)
4369#if(CXSC_INDEX_CHECK)
4370;
4371#else
4372 noexcept;
4373#endif
4375 INLINE civector operator -(const ivector_slice &sl1, const cvector_slice &sl2)
4376#if(CXSC_INDEX_CHECK)
4377;
4378#else
4379 noexcept;
4380#endif
4381
4382
4384 INLINE civector operator |(const cvector &rv1, const ivector &rv2)
4385#if(CXSC_INDEX_CHECK)
4386;
4387#else
4388 noexcept;
4389#endif
4391 INLINE civector operator |(const cvector &rv, const ivector_slice &sl)
4392#if(CXSC_INDEX_CHECK)
4393;
4394#else
4395 noexcept;
4396#endif
4398 INLINE civector operator |(const cvector_slice &sl, const ivector &rv)
4399#if(CXSC_INDEX_CHECK)
4400;
4401#else
4402 noexcept;
4403#endif
4405 INLINE civector operator |(const cvector_slice &sl1, const ivector_slice &sl2)
4406#if(CXSC_INDEX_CHECK)
4407;
4408#else
4409 noexcept;
4410#endif
4411
4413 INLINE civector operator |(const ivector &rv1, const cvector &rv2)
4414#if(CXSC_INDEX_CHECK)
4415;
4416#else
4417 noexcept;
4418#endif
4420 INLINE civector operator |(const ivector &rv, const cvector_slice &sl)
4421#if(CXSC_INDEX_CHECK)
4422;
4423#else
4424 noexcept;
4425#endif
4427 INLINE civector operator |(const ivector_slice &sl, const cvector &rv)
4428#if(CXSC_INDEX_CHECK)
4429;
4430#else
4431 noexcept;
4432#endif
4434 INLINE civector operator |(const ivector_slice &sl1, const cvector_slice &sl2)
4435#if(CXSC_INDEX_CHECK)
4436;
4437#else
4438 noexcept;
4439#endif
4440
4442 INLINE civector operator &(const cvector &rv1, const ivector &rv2)
4443#if(CXSC_INDEX_CHECK)
4444;
4445#else
4446 noexcept;
4447#endif
4449 INLINE civector operator &(const cvector &rv, const ivector_slice &sl)
4450#if(CXSC_INDEX_CHECK)
4451;
4452#else
4453 noexcept;
4454#endif
4456 INLINE civector operator &(const cvector_slice &sl, const ivector &rv)
4457#if(CXSC_INDEX_CHECK)
4458;
4459#else
4460 noexcept;
4461#endif
4463 INLINE civector operator &(const cvector_slice &sl1, const ivector_slice &sl2)
4464#if(CXSC_INDEX_CHECK)
4465;
4466#else
4467 noexcept;
4468#endif
4469
4471 INLINE civector operator &(const ivector &rv1, const cvector &rv2)
4472#if(CXSC_INDEX_CHECK)
4473;
4474#else
4475 noexcept;
4476#endif
4478 INLINE civector operator &(const ivector &rv, const cvector_slice &sl)
4479#if(CXSC_INDEX_CHECK)
4480;
4481#else
4482 noexcept;
4483#endif
4485 INLINE civector operator &(const ivector_slice &sl, const cvector &rv)
4486#if(CXSC_INDEX_CHECK)
4487;
4488#else
4489 noexcept;
4490#endif
4492 INLINE civector operator &(const ivector_slice &sl1, const cvector_slice &sl2)
4493#if(CXSC_INDEX_CHECK)
4494;
4495#else
4496 noexcept;
4497#endif
4498
4500 INLINE bool in(const civector& v1, const civector& v2);
4501
4502} // namespace cxsc
4503
4504#ifdef _CXSC_INCL_INL
4505#include "vector.inl"
4506#include "civector.inl"
4507#endif
4508
4509#ifdef _CXSC_RMATRIX_HPP_INCLUDED
4510# ifdef _CXSC_INCL_INL
4511# include "civecrmat.inl"
4512# else
4513# include "civecrmat.hpp"
4514# endif
4515#endif
4516
4517#ifdef _CXSC_CMATRIX_HPP_INCLUDED
4518# ifdef _CXSC_INCL_INL
4519# include "civeccmat.inl"
4520# else
4521# include "civeccmat.hpp"
4522# endif
4523#endif
4524
4525#ifdef _CXSC_IMATRIX_HPP_INCLUDED
4526# ifdef _CXSC_INCL_INL
4527# include "civecimat.inl"
4528# else
4529# include "civecimat.hpp"
4530# endif
4531#endif
4532
4533#ifdef CXSC_USE_BLAS
4534#define _CXSC_BLAS_CIVECTOR
4535#include "cxsc_blas.inl"
4536#endif
4537
4538
4539#endif
The Data Type cidotprecision.
Definition cidot.hpp:58
The Data Type cimatrix_slice.
The Data Type cimatrix_subv.
Definition cimatrix.hpp:68
The Data Type cimatrix.
Definition cimatrix.hpp:908
The Scalar Type cinterval.
Definition cinterval.hpp:55
cinterval(void) noexcept
Constructor of class cinterval.
Definition cinterval.hpp:64
The Data Type civector_slice.
friend rvector SupIm(const civector_slice &v) noexcept
Returns the supremum of imaginary part of the vector.
Definition civector.inl:647
friend rvector SupRe(const civector_slice &v) noexcept
Returns the supremum of real part of the vector.
Definition civector.inl:669
civector_slice & operator|=(const civector &rv) noexcept
Allocates the convex hull of the arguments to the first argument.
Definition civector.inl:994
civector_slice(const civector_slice &a) noexcept
Constructor of class civector_slice.
friend int Lb(const civector_slice &sl) noexcept
Returns the lower bound of the vector.
civector_slice & operator&=(const civector &rv) noexcept
Allocates the intersection of the arguments to the first argument.
civector_slice & operator*=(const cinterval &r) noexcept
Implementation of multiplication and allocation operation.
Definition civector.inl:720
civector_slice & operator+=(const civector &rv) noexcept
Implementation of addition and allocation operation.
Definition civector.inl:878
friend rvector InfIm(const civector_slice &v) noexcept
Returns the infimum of imaginary part of the vector.
Definition civector.inl:626
civector_slice & operator()() noexcept
Operator for accessing the whole vector.
civector_slice(civector &a, const int &lb, const int &ub) noexcept
Constructor of class civector_slice.
friend cvector Inf(const civector_slice &v) noexcept
Returns the infimum of the vector.
Definition civector.inl:705
civector_slice & operator=(const scivector_slice &sl)
Implementation of standard assigning operator.
civector_slice & operator/=(const cinterval &r) noexcept
Implementation of division and allocation operation.
Definition civector.inl:725
civector_slice & operator-=(const civector &rv) noexcept
Implementation of subtraction and allocation operation.
Definition civector.inl:937
friend rvector InfRe(const civector_slice &v) noexcept
Returns the infimum of real part of the vector.
Definition civector.inl:586
friend int VecLen(const civector_slice &sl) noexcept
Returns the size of the vector.
friend cvector Sup(const civector_slice &v) noexcept
Returns the supremum of the vector.
Definition civector.inl:707
cinterval & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector (read-only)
Definition civector.inl:166
civector_slice(civector_slice &a, const int &lb, const int &ub) noexcept
Constructor of class civector_slice.
friend int Ub(const civector_slice &sl) noexcept
Returns the upper bound of the vector.
The Data Type civector.
Definition civector.hpp:57
civector & operator=(const civector &rv) noexcept
Implementation of standard assigning operator.
Definition civector.inl:339
friend int Ub(const civector &rv) noexcept
Returns the upper bound of the vector.
Definition civector.hpp:963
friend civector & SetUb(civector &rv, const int &u) noexcept
Sets the upper bound of the vector.
Definition civector.hpp:969
friend rvector InfIm(const civector &v) noexcept
Returns the infimum of imaginary part of the vector.
Definition civector.inl:616
friend int VecLen(const civector &rv) noexcept
Returns the dimension of the vector.
Definition civector.hpp:965
friend cvector Inf(const civector &v) noexcept
Returns the infimum of the vector.
Definition civector.inl:704
civector & operator()() noexcept
Operator for accessing the whole vector.
Definition civector.hpp:987
friend cvector Sup(const civector &v) noexcept
Returns the supremum of the vector.
Definition civector.inl:706
cinterval & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector (read-only)
Definition civector.inl:140
friend int Lb(const civector &rv) noexcept
Returns the lower bound of the vector.
Definition civector.hpp:961
friend civector & SetLb(civector &rv, const int &l) noexcept
Sets the lower bound of the vector.
Definition civector.hpp:967
friend rvector InfRe(const civector &v) noexcept
Returns the infimum of real part of the vector.
Definition civector.inl:576
friend rvector SupIm(const civector &v) noexcept
Returns the supremum of imaginary part of the vector.
Definition civector.inl:637
friend rvector SupRe(const civector &v) noexcept
Returns the supremum of real part of the vector.
Definition civector.inl:659
civector() noexcept
Constructor of class civector.
Definition civector.inl:31
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
The Data Type cvector_slice.
Definition cvector.hpp:845
The Data Type cvector.
Definition cvector.hpp:58
The Data Type imatrix_slice.
Definition imatrix.hpp:1442
The Data Type imatrix_subv.
Definition imatrix.hpp:56
The Data Type imatrix.
Definition imatrix.hpp:660
The Scalar Type interval.
Definition interval.hpp:55
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 interval vector.
Definition scivector.hpp:62
Helper class for slices of sparse vectors.
A sparse complex vector.
Definition scvector.hpp:58
Helper class for slices of sparse vectors.
A sparse interval vector.
Definition sivector.hpp:59
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
civector operator/(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of division operation.
Definition cimatrix.inl:730
cvector diam(const cimatrix_subv &mv) noexcept
Returns the diameter of the matrix.
Definition cimatrix.inl:738
int in(const cinterval &x, const cinterval &y)
Checks if first argument is part of second argument.
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
cvector mid(const cimatrix_subv &mv) noexcept
Returns the middle of the matrix.
Definition cimatrix.inl:739
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_subv & SetUncheckedInf(cimatrix_subv &iv, const complex &r) noexcept
Returns the matrix with the new unchecked given infimum value.
Definition cimatrix.inl:890
cimatrix & operator/=(cimatrix &m, const cinterval &c) noexcept
Implementation of division and allocation operation.