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 
44 namespace cxsc {
45 
46 class civector_slice;
47 class scivector;
48 class scivector_slice;
49 
51 
56 class civector
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
70 template <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
76 template <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
104 template <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
110 template <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
135 template <class V,class MV> friend V &_vmvsetinf(V &rv,const MV &v)
136 #if(CXSC_INDEX_CHECK)
137 ;
138 #else
139  noexcept;
140 #endif
141 template <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
171 template <class V,class MV> friend V &_vmvusetinf(V &rv,const MV &v)
172 #if(CXSC_INDEX_CHECK)
173 ;
174 #else
175  noexcept;
176 #endif
177 template <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;
193 template <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
232 template <class V,class MV> friend V &_vmvsetim(V &rv,const MV &v)
233 #if(CXSC_INDEX_CHECK)
234 ;
235 #else
236  noexcept;
237 #endif
238 template <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
461 template <class MV,class V> friend MV &_mvvsectassign(MV &v,const V &rv)
462 #if(CXSC_INDEX_CHECK)
463 ;
464 #else
465  noexcept;
466 #endif
467 template <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
485 template <class MV,class V> friend MV &_mvvconvassign(MV &v,const V &rv)
486 #if(CXSC_INDEX_CHECK)
487 ;
488 #else
489  noexcept;
490 #endif
491 template <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
540 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
541 #if(CXSC_INDEX_CHECK)
542 ;
543 #else
544  noexcept;
545 #endif
546 template <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;
553 template <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 ---------------
582 template <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 
589 template <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
663 template<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&);
916  civector& operator+=(const scvector&);
917  civector& operator+=(const sivector&);
918  civector& operator+=(const scivector&);
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 
1350 template <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
1356 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) noexcept;
1357 template <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 ----------
1423 template <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
1429 template <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.
Definition: cimatrix.hpp:1651
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.
Definition: civector.hpp:1015
friend rvector InfRe(const civector_slice &v) noexcept
Returns the infimum of real part of the vector.
Definition: civector.inl:586
friend rvector InfIm(const civector_slice &v) noexcept
Returns the infimum of imaginary part of the vector.
Definition: civector.inl:626
civector_slice & operator|=(const civector &rv) noexcept
Allocates the convex hull of the arguments to the first argument.
Definition: civector.inl:994
friend cvector Sup(const civector_slice &v) noexcept
Returns the supremum of the vector.
Definition: civector.inl:707
civector_slice(const civector_slice &a) noexcept
Constructor of class civector_slice.
Definition: civector.hpp:1518
friend int Lb(const civector_slice &sl) noexcept
Returns the lower bound of the vector.
Definition: civector.hpp:1684
civector_slice & operator&=(const civector &rv) noexcept
Allocates the intersection of the arguments to the first argument.
Definition: civector.inl:1051
civector_slice & operator()() noexcept
Operator for accessing the whole vector.
Definition: civector.hpp:1707
civector_slice & operator*=(const cinterval &r) noexcept
Implementation of multiplication and allocation operation.
Definition: civector.inl:720
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
Implementation of addition and allocation operation.
Definition: civector.inl:878
civector_slice(civector &a, const int &lb, const int &ub) noexcept
Constructor of class civector_slice.
Definition: civector.hpp:1513
civector_slice & operator=(const scivector_slice &sl)
Implementation of standard assigning operator.
Definition: scivector.hpp:4688
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 cvector Inf(const civector_slice &v) noexcept
Returns the infimum of the vector.
Definition: civector.inl:705
friend int VecLen(const civector_slice &sl) noexcept
Returns the size of the vector.
Definition: civector.hpp:1688
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.
Definition: civector.hpp:1515
friend int Ub(const civector_slice &sl) noexcept
Returns the upper bound of the vector.
Definition: civector.hpp:1686
The Data Type civector.
Definition: civector.hpp:57
friend cvector Inf(const civector &v) noexcept
Returns the infimum of the vector.
Definition: civector.inl:704
civector & operator=(const civector &rv) noexcept
Implementation of standard assigning operator.
Definition: civector.inl:339
friend civector & SetLb(civector &rv, const int &l) noexcept
Sets the lower bound of the vector.
Definition: civector.hpp:967
friend cvector Sup(const civector &v) noexcept
Returns the supremum of the vector.
Definition: civector.inl:706
friend int Ub(const civector &rv) noexcept
Returns the upper bound of the vector.
Definition: civector.hpp:963
friend rvector SupIm(const civector &v) noexcept
Returns the supremum of imaginary part of the vector.
Definition: civector.inl:637
friend int VecLen(const civector &rv) noexcept
Returns the dimension of the vector.
Definition: civector.hpp:965
friend civector & SetUb(civector &rv, const int &u) noexcept
Sets the upper bound of the vector.
Definition: civector.hpp:969
civector & operator()() noexcept
Operator for accessing the whole vector.
Definition: civector.hpp:987
friend rvector InfRe(const civector &v) noexcept
Returns the infimum of real part of the vector.
Definition: civector.inl:576
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 rvector SupRe(const civector &v) noexcept
Returns the supremum of real part of the vector.
Definition: civector.inl:659
friend rvector InfIm(const civector &v) noexcept
Returns the infimum of imaginary part of the vector.
Definition: civector.inl:616
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.
Definition: intmatrix.hpp:314
The Data Type intvector.
Definition: intvector.hpp:52
The Data Type ivector_slice.
Definition: ivector.hpp:963
The Data Type ivector.
Definition: ivector.hpp:55
The Scalar Type real.
Definition: real.hpp:114
The Data Type rmatrix_slice.
Definition: rmatrix.hpp:1443
The Data Type rmatrix_subv.
Definition: rmatrix.hpp:54
The Data Type rmatrix.
Definition: rmatrix.hpp:471
The Data Type rvector_slice.
Definition: rvector.hpp:1064
The Data Type rvector.
Definition: rvector.hpp:58
Helper class for slices of sparse vectors.
Definition: scivector.hpp:4063
A sparse complex interval vector.
Definition: scivector.hpp:62
Helper class for slices of sparse vectors.
Definition: scvector.hpp:1245
A sparse complex vector.
Definition: scvector.hpp:58
Helper class for slices of sparse vectors.
Definition: sivector.hpp:1831
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
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.
Definition: cinterval.cpp:654
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc) noexcept
Implementation of standard algebraic addition and allocation operation.
Definition: cdot.inl:251
cimatrix & operator*=(cimatrix &m, const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
Definition: cimatrix.inl:1605
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737
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.
Definition: cimatrix.inl:1211
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.
Definition: cimatrix.inl:1623