C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
ivector.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: ivector.hpp,v 1.36 2014/01/30 17:23:45 cxsc Exp $ */
25 
26 #ifndef _CXSC_IVECTOR_HPP_INCLUDED
27 #define _CXSC_IVECTOR_HPP_INCLUDED
28 
29 #include "xscclass.hpp"
30 #include "except.hpp"
31 #include "idot.hpp"
32 #include "cidot.hpp"
33 #include "interval.hpp" // used for declaration of Inf, Sup,...
34 #include "rvector.hpp"
35 #include "vector.hpp"
36 
37 
38 #include <iostream>
39 
40 namespace cxsc {
41 
42 class srvector;
43 class srvector_slice;
44 class sivector;
45 class sivector_slice;
46 class ivector_slice;
47 
49 
54 class ivector
55 {
56  friend class ivector_slice;
57  friend class imatrix;
58  friend class imatrix_subv;
59  friend class civector;
60  friend class cimatrix;
61  friend class l_ivector;
62  friend class l_imatrix;
63  private:
64  interval *dat;
65  int l,u,size;
66 
67  public:
68 //#if(CXSC_INDEX_CHECK)
69 #ifdef _CXSC_FRIEND_TPL
70  //------------ Templates --------------------------------------------------
71  // Interval
72 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m)
73 #if(CXSC_INDEX_CHECK)
74 ;
75 #else
76  noexcept;
77 #endif
78 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
79 #if(CXSC_INDEX_CHECK)
80 ;
81 #else
82  noexcept;
83 #endif
84  template <class V> friend void _vresize(V &rv) noexcept;
85  template <class V,class S> friend void _vresize(V &rv, const int &len)
86 #if(CXSC_INDEX_CHECK)
87  ;
88 #else
89  noexcept;
90 #endif
91  template <class V,class S> friend void _vresize(V &rv, const int &lb, const int &ub)
92 #if(CXSC_INDEX_CHECK)
93  ;
94 #else
95  noexcept;
96 #endif
97  template <class V1,class V2,class S> friend V1 &_vvassign(V1 &rv1,const V2 &rv2) noexcept;
98  template <class V,class S> friend V & _vsassign(V &rv,const S &r) noexcept;
99  template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) noexcept;
100 template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv)
101 #if(CXSC_INDEX_CHECK)
102  ;
103 #else
104  noexcept;
105 #endif
106 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m)
107 #if(CXSC_INDEX_CHECK)
108 ;
109 #else
110  noexcept;
111 #endif
112 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) noexcept;
113  template <class V1,class V2> friend V1 &_vvsetinf(V1 &rv1, const V2 &rv2)
114 #if(CXSC_INDEX_CHECK)
115  ;
116 #else
117  noexcept;
118 #endif
119  template <class V1,class V2> friend V1 &_vvsetsup(V1 &rv1, const V2 &rv2)
120 #if(CXSC_INDEX_CHECK)
121  ;
122 #else
123  noexcept;
124 #endif
125  template <class V,class VS> friend V &_vvssetinf(V &rv, const VS &sl)
126 #if(CXSC_INDEX_CHECK)
127  ;
128 #else
129  noexcept;
130 #endif
131  template <class V,class VS> friend V &_vvssetsup(V &rv, const VS &sl)
132 #if(CXSC_INDEX_CHECK)
133  ;
134 #else
135  noexcept;
136 #endif
137 template <class V,class MV> friend V &_vmvsetinf(V &rv,const MV &v)
138 #if(CXSC_INDEX_CHECK)
139 ;
140 #else
141  noexcept;
142 #endif
143 template <class V,class MV> friend V &_vmvsetsup(V &rv,const MV &v)
144 #if(CXSC_INDEX_CHECK)
145 ;
146 #else
147  noexcept;
148 #endif
149  template <class V1,class V2> friend V1 &_vvusetinf(V1 &rv1, const V2 &rv2)
150 #if(CXSC_INDEX_CHECK)
151  ;
152 #else
153  noexcept;
154 #endif
155  template <class V1,class V2> friend V1 &_vvusetsup(V1 &rv1, const V2 &rv2)
156 #if(CXSC_INDEX_CHECK)
157  ;
158 #else
159  noexcept;
160 #endif
161  template <class V,class VS> friend V &_vvsusetinf(V &rv, const VS &sl)
162 #if(CXSC_INDEX_CHECK)
163  ;
164 #else
165  noexcept;
166 #endif
167  template <class V,class VS> friend V &_vvsusetsup(V &rv, const VS &sl)
168 #if(CXSC_INDEX_CHECK)
169  ;
170 #else
171  noexcept;
172 #endif
173 template <class V,class MV> friend V &_vmvusetinf(V &rv,const MV &v)
174 #if(CXSC_INDEX_CHECK)
175 ;
176 #else
177  noexcept;
178 #endif
179 template <class V,class MV> friend V &_vmvusetsup(V &rv,const MV &v)
180 #if(CXSC_INDEX_CHECK)
181 ;
182 #else
183  noexcept;
184 #endif
185  template <class V,class S> friend V &_vssetinf(V &v, const S &s) noexcept;
186  template <class V,class S> friend V &_vssetsup(V &v, const S &s) noexcept;
187  template <class V,class S> friend V &_vsusetinf(V &v, const S &s) noexcept;
188  template <class V,class S> friend V &_vsusetsup(V &v, const S &s) noexcept;
189  template <class V,class E> friend E _vabs(const V &rv) noexcept;
190  template <class VS,class E> friend E _vsabs(const VS &sl) noexcept;
191 template <class MV,class V> friend V _mvabs(const MV &mv) noexcept;
192  template <class V,class E> friend E _vdiam(const V &rv) noexcept;
193  template <class V,class E> friend E _vmid(const V &rv) noexcept;
194  template <class V,class E> friend E _vinf(const V &rv) noexcept;
195  template <class V,class E> friend E _vsup(const V &rv) noexcept;
196 
197 //-------- vector-vector -----------------------
198  template <class DP,class V1,class V2> friend void _vvaccu(DP &dp, const V1 & rv1, const V2 &rv2)
199 #if(CXSC_INDEX_CHECK)
200  ;
201 #else
202  noexcept;
203 #endif
204  template <class DP,class VS,class V> friend void _vsvaccu(DP &dp, const VS & sl, const V &rv)
205 #if(CXSC_INDEX_CHECK)
206  ;
207 #else
208  noexcept;
209 #endif
210  template <class V1,class V2,class E> friend E _vvimult(const V1 & rv1, const V2 &rv2)
211 #if(CXSC_INDEX_CHECK)
212  ;
213 #else
214  noexcept;
215 #endif
216  template <class VS,class V,class E> friend E _vsvimult(const VS & sl, const V &rv)
217 #if(CXSC_INDEX_CHECK)
218  ;
219 #else
220  noexcept;
221 #endif
222  template <class V,class S> friend V &_vsmultassign(V &rv,const S &r) noexcept;
223  template <class V1,class V2,class E> friend E _vvplus(const V1 &rv1, const V2 &rv2)
224 #if(CXSC_INDEX_CHECK)
225  ;
226 #else
227  noexcept;
228 #endif
229  template <class V,class VS,class E> friend E _vvsplus(const V &rv,const VS &sl)
230 #if(CXSC_INDEX_CHECK)
231  ;
232 #else
233  noexcept;
234 #endif
235  template <class VS1,class VS2,class E> friend E _vsvsplus(const VS1 &s1,const VS2 &s2)
236 #if(CXSC_INDEX_CHECK)
237  ;
238 #else
239  noexcept;
240 #endif
241  template <class VS1,class VS2,class E> friend E _vsvsminus(const VS1 &s1,const VS2 &s2)
242 #if(CXSC_INDEX_CHECK)
243  ;
244 #else
245  noexcept;
246 #endif
247  template <class V1,class V2> friend V1 &_vvplusassign(V1 &rv1, const V2 &rv2)
248 #if(CXSC_INDEX_CHECK)
249  ;
250 #else
251  noexcept;
252 #endif
253  template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl)
254 #if(CXSC_INDEX_CHECK)
255  ;
256 #else
257  noexcept;
258 #endif
259  template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv)
260 #if(CXSC_INDEX_CHECK)
261  ;
262 #else
263  noexcept;
264 #endif
265  template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
266 #if(CXSC_INDEX_CHECK)
267  ;
268 #else
269  noexcept;
270 #endif
271  template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
272 #if(CXSC_INDEX_CHECK)
273  ;
274 #else
275  noexcept;
276 #endif
277  template <class V1,class V2> friend V1 &_vvminusassign(V1 &rv1, const V2 &rv2)
278 #if(CXSC_INDEX_CHECK)
279  ;
280 #else
281  noexcept;
282 #endif
283  template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl)
284 #if(CXSC_INDEX_CHECK)
285  ;
286 #else
287  noexcept;
288 #endif
289  template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv)
290 #if(CXSC_INDEX_CHECK)
291  ;
292 #else
293  noexcept;
294 #endif
295  template <class V> friend V _vminus(const V &rv) noexcept;
296  template <class VS,class V> friend V _vsminus(const VS &sl) noexcept;
297  template <class V1,class V2,class E> friend E _vvminus(const V1 &rv1, const V2 &rv2)
298 #if(CXSC_INDEX_CHECK)
299  ;
300 #else
301  noexcept;
302 #endif
303  template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl)
304 #if(CXSC_INDEX_CHECK)
305  ;
306 #else
307  noexcept;
308 #endif
309  template <class VS,class V,class E> friend E _vsvminus(const VS &sl,const V &rv)
310 #if(CXSC_INDEX_CHECK)
311  ;
312 #else
313  noexcept;
314 #endif
315  template <class V1,class V2,class E> friend E _vvconv(const V1 &rv1, const V2 &rv2)
316 #if(CXSC_INDEX_CHECK)
317  ;
318 #else
319  noexcept;
320 #endif
321  template <class V,class VS,class E> friend E _vvsconv(const V &rv,const VS &sl)
322 #if(CXSC_INDEX_CHECK)
323  ;
324 #else
325  noexcept;
326 #endif
327  template <class VS1,class VS2,class E> friend E _vsvsconv(const VS1 &s1,const VS2 &s2)
328 #if(CXSC_INDEX_CHECK)
329  ;
330 #else
331  noexcept;
332 #endif
333  template <class V1,class V2> friend V1 &_vvconvassign(V1 &rv1, const V2 &rv2)
334 #if(CXSC_INDEX_CHECK)
335  ;
336 #else
337  noexcept;
338 #endif
339  template <class V,class VS> friend V &_vvsconvassign(V &rv, const VS &sl)
340 #if(CXSC_INDEX_CHECK)
341  ;
342 #else
343  noexcept;
344 #endif
345  template <class VS,class V> friend VS &_vsvconvassign(VS &sl, const V &rv)
346 #if(CXSC_INDEX_CHECK)
347  ;
348 #else
349  noexcept;
350 #endif
351  template <class VS1,class VS2> friend VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2)
352 #if(CXSC_INDEX_CHECK)
353  ;
354 #else
355  noexcept;
356 #endif
357  template <class V1,class V2,class E> friend E _vvsect(const V1 &rv1, const V2 &rv2)
358 #if(CXSC_INDEX_CHECK)
359  ;
360 #else
361  noexcept;
362 #endif
363  template <class V,class VS,class E> friend E _vvssect(const V &rv,const VS &sl)
364 #if(CXSC_INDEX_CHECK)
365  ;
366 #else
367  noexcept;
368 #endif
369  template <class VS1,class VS2,class E> friend E _vsvssect(const VS1 &s1,const VS2 &s2)
370 #if(CXSC_INDEX_CHECK)
371  ;
372 #else
373  noexcept;
374 #endif
375  template <class V1,class V2> friend V1 &_vvsectassign(V1 &rv1, const V2 &rv2)
376 #if(CXSC_INDEX_CHECK)
377  ;
378 #else
379  noexcept;
380 #endif
381  template <class V,class VS> friend V &_vvssectassign(V &rv, const VS &sl)
382 #if(CXSC_INDEX_CHECK)
383  ;
384 #else
385  noexcept;
386 #endif
387  template <class VS,class V> friend VS &_vsvsectassign(VS &sl, const V &rv)
388 #if(CXSC_INDEX_CHECK)
389  ;
390 #else
391  noexcept;
392 #endif
393  template <class VS1,class VS2> friend VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2)
394 #if(CXSC_INDEX_CHECK)
395  ;
396 #else
397  noexcept;
398 #endif
399  template <class MV1,class MV2,class E> friend E _mvmvsect(const MV1 &rv1, const MV2 &rv2)
400 #if(CXSC_INDEX_CHECK)
401  ;
402 #else
403  noexcept;
404 #endif
405  template <class MV,class V,class E> friend E _mvvsect(const MV &rv1, const V &rv2)
406 #if(CXSC_INDEX_CHECK)
407  ;
408 #else
409  noexcept;
410 #endif
411 template <class MV,class V> friend MV &_mvvsectassign(MV &v,const V &rv)
412 #if(CXSC_INDEX_CHECK)
413 ;
414 #else
415  noexcept;
416 #endif
417 template <class V,class MV> friend V &_vmvsectassign(V &rv,const MV &v)
418 #if(CXSC_INDEX_CHECK)
419 ;
420 #else
421  noexcept;
422 #endif
423  template <class MV1,class MV2,class E> friend E _mvmvconv(const MV1 &rv1, const MV2 &rv2)
424 #if(CXSC_INDEX_CHECK)
425  ;
426 #else
427  noexcept;
428 #endif
429  template <class MV,class V,class E> friend E _mvvconv(const MV &rv1, const V &rv2)
430 #if(CXSC_INDEX_CHECK)
431  ;
432 #else
433  noexcept;
434 #endif
435 template <class MV,class V> friend MV &_mvvconvassign(MV &v,const V &rv)
436 #if(CXSC_INDEX_CHECK)
437 ;
438 #else
439  noexcept;
440 #endif
441 template <class V,class MV> friend V &_vmvconvassign(V &rv,const MV &v)
442 #if(CXSC_INDEX_CHECK)
443 ;
444 #else
445  noexcept;
446 #endif
447  template <class V,class MV,class S> friend S _vmvimult(const V &rv1, const MV &rv2)
448 #if(CXSC_INDEX_CHECK)
449  ;
450 #else
451  noexcept;
452 #endif
453  //--------- vector-scalar -----------------
454  template <class V,class S,class E> friend E _vsdiv(const V &rv, const S &s) noexcept;
455  template <class V,class S> friend V &_vsdivassign(V &rv,const S &r) noexcept;
456  template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) noexcept;
457  template <class V,class S,class E> friend E _vsmult(const V &rv, const S &s) noexcept;
458  template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) noexcept;
459  template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) noexcept;
460  template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
461 #if(CXSC_INDEX_CHECK)
462  ;
463 #else
464  noexcept;
465 #endif
466  template <class MV,class V,class E> friend E _mvvplus(const MV &rv1, const V &rv2)
467 #if(CXSC_INDEX_CHECK)
468  ;
469 #else
470  noexcept;
471 #endif
472  template <class MV,class V,class E> friend E _mvvminus(const MV &rv1, const V &rv2)
473 #if(CXSC_INDEX_CHECK)
474  ;
475 #else
476  noexcept;
477 #endif
478  template <class V,class MV,class E> friend E _vmvminus(const V &rv1, const MV &rv2)
479 #if(CXSC_INDEX_CHECK)
480  ;
481 #else
482  noexcept;
483 #endif
484  template <class MV1,class MV2,class E> friend E _mvmvminus(const MV1 &rv1, const MV2 &rv2)
485 #if(CXSC_INDEX_CHECK)
486  ;
487 #else
488  noexcept;
489 #endif
490 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
491 #if(CXSC_INDEX_CHECK)
492 ;
493 #else
494  noexcept;
495 #endif
496 template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv)
497 #if(CXSC_INDEX_CHECK)
498 ;
499 #else
500  noexcept;
501 #endif
502  template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) noexcept;
503 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
504 #if(CXSC_INDEX_CHECK)
505 ;
506 #else
507  noexcept;
508 #endif
509 
510  template <class V1,class V2> friend bool _vveq(const V1 &rv1, const V2 &rv2) noexcept;
511  template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) noexcept;
512  template <class V1,class V2> friend bool _vvneq(const V1 &rv1, const V2 &rv2) noexcept;
513  template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) noexcept;
514  template <class V1,class V2> friend bool _vvless(const V1 &rv1, const V2 &rv2) noexcept;
515  template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) noexcept;
516  template <class V1,class V2> friend bool _vvleq(const V1 &rv1, const V2 &rv2) noexcept;
517  template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) noexcept;
518  template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) noexcept;
519  template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) noexcept;
520  template <class V> friend bool _vnot(const V &rv) noexcept;
521  template <class V> friend void *_vvoid(const V &rv) noexcept;
522  template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) noexcept;
523  template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) noexcept;
524  template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) noexcept;
525  template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) noexcept;
526  template <class VS> friend bool _vsnot(const VS &sl) noexcept;
527  template <class VS> friend void *_vsvoid(const VS &sl) noexcept;
528  template <class V> friend std::ostream &_vout(std::ostream &s, const V &rv) noexcept;
529  template <class V> friend std::istream &_vin(std::istream &s, V &rv) noexcept;
530 
531  //------------- vector-matrix ---------------
532 template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
533 #if(CXSC_INDEX_CHECK)
534  ;
535 #else
536  noexcept;
537 #endif
538 
539 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) noexcept;
540  template <class M,class V,class E> friend E _mvimult(const M &m,const V &v)
541 #if(CXSC_INDEX_CHECK)
542  ;
543 #else
544  noexcept;
545 #endif
546  template <class V,class M,class E> friend E _vmimult(const V &v,const M &m)
547 #if(CXSC_INDEX_CHECK)
548  ;
549 #else
550  noexcept;
551 #endif
552  template <class V,class M,class S> friend V &_vmimultassign(V &v,const M &m)
553 #if(CXSC_INDEX_CHECK)
554  ;
555 #else
556  noexcept;
557 #endif
558  template <class MS,class V,class E> friend E _msvimult(const MS &ms,const V &v)
559 #if(CXSC_INDEX_CHECK)
560  ;
561 #else
562  noexcept;
563 #endif
564  template <class V,class MS,class E> friend E _vmsimult(const V &v,const MS &ms)
565 #if(CXSC_INDEX_CHECK)
566  ;
567 #else
568  noexcept;
569 #endif
570  template <class V,class MS,class S> friend V &_vmsimultassign(V &v,const MS &ms)
571 #if(CXSC_INDEX_CHECK)
572  ;
573 #else
574  noexcept;
575 #endif
576 
577  // Real
578  //--Real -------- vector-scalar ------------
579  //--Real--------- Vector-vector---------
580  //-- Real -------- Vector-matrix ----------
581  // complex
582  //--complex -------- vector-scalar ------------
583  //--complex--------- Vector-vector---------
584 
585  template <class V1,class V2,class E> friend E _vvcimult(const V1 & rv1, const V2 &rv2)
586 #if(CXSC_INDEX_CHECK)
587  ;
588 #else
589  noexcept;
590 #endif
591  template <class VS,class V,class E> friend E _vsvcimult(const VS & sl, const V &rv)
592 #if(CXSC_INDEX_CHECK)
593  ;
594 #else
595  noexcept;
596 #endif
597 
598  //-- complex -------- Vector-matrix ----------
599  template <class M,class V,class E> friend E _mvcimult(const M &m,const V &v)
600 #if(CXSC_INDEX_CHECK)
601  ;
602 #else
603  noexcept;
604 #endif
605  template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v)
606 #if(CXSC_INDEX_CHECK)
607  ;
608 #else
609  noexcept;
610 #endif
611  template <class V,class M,class E> friend E _vmcimult(const V &v,const M &m)
612 #if(CXSC_INDEX_CHECK)
613  ;
614 #else
615  noexcept;
616 #endif
617  template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms)
618 #if(CXSC_INDEX_CHECK)
619  ;
620 #else
621  noexcept;
622 #endif
623 
624  // civector ---------------------
625 template <class V1,class V2> friend V1 &_vvsetim(V1 &rv1, const V2 &rv2)
626 #if(CXSC_INDEX_CHECK)
627  ;
628 #else
629  noexcept;
630 #endif
631 template <class V1,class V2> friend V1 &_vvsetre(V1 &rv1, const V2 &rv2)
632 #if(CXSC_INDEX_CHECK)
633  ;
634 #else
635  noexcept;
636 #endif
637  template <class V,class E> friend E _vim(const V &rv) noexcept;
638  template <class V,class E> friend E _vre(const V &rv) noexcept;
639 
640  template <class VS,class V> friend VS &_vsvsetim(VS &sl, const V &rv)
641 #if(CXSC_INDEX_CHECK)
642  ;
643 #else
644  noexcept;
645 #endif
646  template <class VS,class V> friend VS &_vsvsetre(VS &sl, const V &rv)
647 #if(CXSC_INDEX_CHECK)
648  ;
649 #else
650  noexcept;
651 #endif
652 template <class MV,class V> friend MV &_mvvsetre(MV &v,const V &rv)
653 #if(CXSC_INDEX_CHECK)
654 ;
655 #else
656  noexcept;
657 #endif
658 template <class MV,class V> friend MV &_mvvsetim(MV &v,const V &rv)
659 #if(CXSC_INDEX_CHECK)
660 ;
661 #else
662  noexcept;
663 #endif
664 template <class MV,class V> friend V _mvim(const MV &mv) noexcept;
665 template <class MV,class V> friend V _mvre(const MV &mv) noexcept;
666 
667  // vector-scalar
668  // vector-vector
669  template <class VS1,class VS2,class E> friend E _vsvscimult(const VS1 & sl1, const VS2 &sl2)
670 #if(CXSC_INDEX_CHECK)
671  ;
672 #else
673  noexcept;
674 #endif
675 
676  // vector-matrix
677  // l_real
678  //--l_real -------- vector-scalar ------------
679  //--l_real--------- Vector-vector---------
680 
681  template <class V1,class V2,class E> friend E _vvlimult(const V1 & rv1, const V2 &rv2)
682 #if(CXSC_INDEX_CHECK)
683  ;
684 #else
685  noexcept;
686 #endif
687  template <class VS,class V,class E> friend E _vsvlimult(const VS & sl, const V &rv)
688 #if(CXSC_INDEX_CHECK)
689  ;
690 #else
691  noexcept;
692 #endif
693 
694  //-- l_real -------- Vector-matrix ----------
695  template <class M,class V,class E> friend E _mvlimult(const M &m,const V &v)
696 #if(CXSC_INDEX_CHECK)
697  ;
698 #else
699  noexcept;
700 #endif
701  template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v)
702 #if(CXSC_INDEX_CHECK)
703  ;
704 #else
705  noexcept;
706 #endif
707  template <class V,class M,class E> friend E _vmlimult(const V &v,const M &m)
708 #if(CXSC_INDEX_CHECK)
709  ;
710 #else
711  noexcept;
712 #endif
713  template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms)
714 #if(CXSC_INDEX_CHECK)
715  ;
716 #else
717  noexcept;
718 #endif
719 
720  // l_ivector ---------------------
721  // vector-scalar
722  // vector-vector
723  template <class VS1,class VS2,class E> friend E _vsvslimult(const VS1 & sl1, const VS2 &sl2)
724 #if(CXSC_INDEX_CHECK)
725  ;
726 #else
727  noexcept;
728 #endif
729  // vector-matrix
730 
731 #endif
732 
733  //------ Konstruktoren ----------------------------------------------------
735  INLINE ivector () noexcept;
737  explicit INLINE ivector(const int &i) noexcept;
738 #ifdef OLD_CXSC
740  explicit INLINE ivector(const class index &i) noexcept; // for backwards compatibility
741 #endif
743  explicit INLINE ivector(const int &i1,const int &i2)
744 #if(CXSC_INDEX_CHECK)
745 ;
746 #else
747  noexcept;
748 #endif
750  INLINE ivector(const imatrix_subv &) noexcept;
752  explicit INLINE ivector(const interval &) noexcept;
754 // explicit INLINE ivector(const imatrix &)
755  explicit ivector(const imatrix &)
756 #if(CXSC_INDEX_CHECK)
757 ;
758 #else
759  noexcept;
760 #endif
762  explicit INLINE ivector(const imatrix_slice &sl)
763 #if(CXSC_INDEX_CHECK)
764 ;
765 #else
766  noexcept;
767 #endif
769  INLINE ivector(const ivector_slice &rs) noexcept;
771  INLINE ivector(const ivector &v) noexcept;
773  INLINE ivector(const sivector &rs);
775  INLINE ivector(const sivector_slice &rs);
776 
777  // Real
779  explicit INLINE ivector(const real &) noexcept;
781  explicit INLINE ivector(const rvector_slice &rs) noexcept;
783  explicit INLINE ivector(const srvector &rs);
785  explicit INLINE ivector(const srvector_slice &rs);
786 
788  explicit INLINE ivector(const rvector &v) noexcept;
790  explicit INLINE ivector(const rmatrix &)
791 #if(CXSC_INDEX_CHECK)
792 ;
793 #else
794  noexcept;
795 #endif
797  explicit INLINE ivector(const rmatrix_slice &sl)
798 #if(CXSC_INDEX_CHECK)
799 ;
800 #else
801  noexcept;
802 #endif
804 // explicit INLINE ivector(const rmatrix_subv &) noexcept;
805  explicit ivector(const rmatrix_subv &) noexcept;
806 
807  // Interval
809  INLINE ivector &operator =(const ivector &rv) noexcept;
811  INLINE ivector &operator =(const ivector_slice &sl) noexcept;
813  INLINE ivector &operator =(const sivector &rv);
815  INLINE ivector &operator =(const sivector_slice &sl);
817  INLINE ivector &operator =(const srvector &rv);
819  INLINE ivector &operator =(const srvector_slice &sl);
821  INLINE ivector &operator =(const interval &r) noexcept;
823  INLINE ivector &operator =(const imatrix &m)
824 #if(CXSC_INDEX_CHECK)
825 ;
826 #else
827  noexcept;
828 #endif
830  INLINE ivector &operator =(const imatrix_slice &)
831 #if(CXSC_INDEX_CHECK)
832 ;
833 #else
834  noexcept;
835 #endif
837  INLINE ivector &operator =(const imatrix_subv &) noexcept;
838  // Real
840  INLINE ivector &operator =(const rvector &rv) noexcept;
842  INLINE ivector &operator =(const rvector_slice &sl) noexcept;
844  INLINE ivector &operator =(const real &r) noexcept;
846  INLINE ivector &operator =(const rmatrix &m)
847 #if(CXSC_INDEX_CHECK)
848 ;
849 #else
850  noexcept;
851 #endif
853  INLINE ivector &operator =(const rmatrix_slice &)
854 #if(CXSC_INDEX_CHECK)
855 ;
856 #else
857  noexcept;
858 #endif
860  INLINE ivector &operator =(const rmatrix_subv &) noexcept;
861 
863  INLINE ivector &operator+=(const srvector&);
865  INLINE ivector &operator+=(const sivector&);
867  INLINE ivector &operator+=(const srvector_slice&);
869  INLINE ivector &operator+=(const sivector_slice&);
871  INLINE ivector &operator-=(const srvector&);
873  INLINE ivector &operator-=(const sivector&);
875  INLINE ivector &operator-=(const srvector_slice&);
877  INLINE ivector &operator-=(const sivector_slice&);
879  INLINE ivector &operator|=(const srvector&);
881  INLINE ivector &operator|=(const sivector&);
883  INLINE ivector &operator|=(const srvector_slice&);
885  INLINE ivector &operator|=(const sivector_slice&);
887  INLINE ivector &operator&=(const sivector&);
889  INLINE ivector &operator&=(const sivector_slice&);
890 
892  INLINE ivector operator()(const intvector& p);
894  INLINE ivector operator()(const intmatrix& P);
895 
896  //--------- Destruktor ----------------------------------------------------
897  INLINE ~ivector() { delete [] dat; }
898 
899  //------ Standardfunktionen -----------------------------------------------
900 
901  friend INLINE interval::interval(const ivector &)
902 #if(CXSC_INDEX_CHECK)
903 ;
904 #else
905  noexcept;
906 #endif
908  friend INLINE int Lb(const ivector &rv) noexcept { return rv.l; }
910  friend INLINE int Ub(const ivector &rv) noexcept { return rv.u; }
912  friend INLINE int VecLen(const ivector &rv) noexcept { return rv.size; }
914  friend INLINE ivector &SetLb(ivector &rv, const int &l) noexcept { rv.l=l; rv.u=l+rv.size-1; return rv; }
916  friend INLINE ivector &SetUb(ivector &rv, const int &u) noexcept { rv.u=u; rv.l=u-rv.size+1; return rv; }
918  INLINE interval & operator [](const int &i) const
919 #if(CXSC_INDEX_CHECK)
920 ;
921 #else
922  noexcept;
923 #endif
924 
926  INLINE interval & operator [](const int &i)
927 #if(CXSC_INDEX_CHECK)
928 ;
929 #else
930  noexcept;
931 #endif
932 
934  INLINE ivector & operator ()() noexcept { return *this; }
936  INLINE ivector_slice operator ()(const int &i)
937 #if(CXSC_INDEX_CHECK)
938 ;
939 #else
940  noexcept;
941 #endif
943  INLINE ivector_slice operator ()(const int &i1,const int &i2)
944 #if(CXSC_INDEX_CHECK)
945 ;
946 #else
947  noexcept;
948 #endif
949 
950  INLINE operator void*() noexcept;
951 //#else
952 //#endif
953 };
954 
955 
957 
963 {
964  friend class ivector;
965  friend class imatrix;
966  friend class civector;
967  friend class cimatrix;
968  friend class l_ivector;
969  friend class l_imatrix;
970  private:
971  interval *dat;
972  int l,u,size;
973  int start,end;
974 
975  public:
976 //#if(CXSC_INDEX_CHECK)
977 #ifdef _CXSC_FRIEND_TPL
978 //------------------------- Templates -------------------------------------------
979 // Interval / Interval
980 
981  template <class VS1,class VS2> friend VS1 & _vsvsassign(VS1 &sl1,const VS2 &sl2)
982 #if(CXSC_INDEX_CHECK)
983  ;
984 #else
985  noexcept;
986 #endif
987  template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) noexcept;
988  template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv)
989 #if(CXSC_INDEX_CHECK)
990  ;
991 #else
992  noexcept;
993 #endif
994  template <class VS,class S> friend VS & _vssassign(VS &sl,const S &r) noexcept;
995  template <class VS,class V> friend VS &_vsvsetinf(VS &sl, const V &rv)
996 #if(CXSC_INDEX_CHECK)
997  ;
998 #else
999  noexcept;
1000 #endif
1001  template <class VS,class V> friend VS &_vsvsetsup(VS &sl, const V &rv)
1002 #if(CXSC_INDEX_CHECK)
1003  ;
1004 #else
1005  noexcept;
1006 #endif
1007  template <class VS1,class VS2> friend VS1 &_vsvssetinf(VS1 &sl1, const VS2 &sl2)
1008 #if(CXSC_INDEX_CHECK)
1009  ;
1010 #else
1011  noexcept;
1012 #endif
1013  template <class VS1,class VS2> friend VS1 &_vsvssetsup(VS1 &sl1, const VS2 &sl2)
1014 #if(CXSC_INDEX_CHECK)
1015  ;
1016 #else
1017  noexcept;
1018 #endif
1019  template <class VS,class V> friend VS &_vsvusetinf(VS &sl, const V &rv)
1020 #if(CXSC_INDEX_CHECK)
1021  ;
1022 #else
1023  noexcept;
1024 #endif
1025  template <class VS,class V> friend VS &_vsvusetsup(VS &sl, const V &rv)
1026 #if(CXSC_INDEX_CHECK)
1027  ;
1028 #else
1029  noexcept;
1030 #endif
1031  template <class VS1,class VS2> friend VS1 &_vsvsusetinf(VS1 &sl1, const VS2 &sl2)
1032 #if(CXSC_INDEX_CHECK)
1033  ;
1034 #else
1035  noexcept;
1036 #endif
1037  template <class VS1,class VS2> friend VS1 &_vsvsusetsup(VS1 &sl1, const VS2 &sl2)
1038 #if(CXSC_INDEX_CHECK)
1039  ;
1040 #else
1041  noexcept;
1042 #endif
1043  template <class VS,class S> friend VS &_vsssetinf(VS &vs, const S &s) noexcept;
1044  template <class VS,class S> friend VS &_vsssetsup(VS &vs, const S &s) noexcept;
1045  template <class VS,class S> friend VS &_vssusetinf(VS &vs, const S &s) noexcept;
1046  template <class VS,class S> friend VS &_vssusetsup(VS &vs, const S &s) noexcept;
1047 
1048  template <class DP,class VS,class V> friend void _vsvaccu(DP &dp, const VS & sl, const V &rv)
1049 #if(CXSC_INDEX_CHECK)
1050  ;
1051 #else
1052  noexcept;
1053 #endif
1054  template <class DP,class VS1,class VS2> friend void _vsvsaccu(DP &dp, const VS1 & sl1, const VS2 &sl2)
1055 #if(CXSC_INDEX_CHECK)
1056  ;
1057 #else
1058  noexcept;
1059 #endif
1060 
1061  template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) noexcept;
1062  template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) noexcept;
1063 
1064  template <class VS,class V,class E> friend E _vsvimult(const VS & sl, const V &rv)
1065 #if(CXSC_INDEX_CHECK)
1066  ;
1067 #else
1068  noexcept;
1069 #endif
1070  template <class VS,class S> friend VS &_vssmultassign(VS &rv,const S &r) noexcept;
1071  template <class VS,class S> friend VS &_vssdivassign(VS &rv,const S &r) noexcept;
1072  template <class V,class VS,class E> friend E _vvsplus(const V &rv,const VS &sl)
1073 #if(CXSC_INDEX_CHECK)
1074  ;
1075 #else
1076  noexcept;
1077 #endif
1078  template <class VS1,class VS2,class E> friend E _vsvsplus(const VS1 &s1,const VS2 &s2)
1079 #if(CXSC_INDEX_CHECK)
1080  ;
1081 #else
1082  noexcept;
1083 #endif
1084  template <class VS1,class VS2,class E> friend E _vsvsminus(const VS1 &s1,const VS2 &s2)
1085 #if(CXSC_INDEX_CHECK)
1086  ;
1087 #else
1088  noexcept;
1089 #endif
1090  template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl)
1091 #if(CXSC_INDEX_CHECK)
1092  ;
1093 #else
1094  noexcept;
1095 #endif
1096  template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv)
1097 #if(CXSC_INDEX_CHECK)
1098  ;
1099 #else
1100  noexcept;
1101 #endif
1102  template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
1103 #if(CXSC_INDEX_CHECK)
1104  ;
1105 #else
1106  noexcept;
1107 #endif
1108  template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
1109 #if(CXSC_INDEX_CHECK)
1110  ;
1111 #else
1112  noexcept;
1113 #endif
1114  template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl)
1115 #if(CXSC_INDEX_CHECK)
1116  ;
1117 #else
1118  noexcept;
1119 #endif
1120  template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv)
1121 #if(CXSC_INDEX_CHECK)
1122  ;
1123 #else
1124  noexcept;
1125 #endif
1126  template <class VS,class V> friend V _vsminus(const VS &sl) noexcept;
1127  template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl)
1128 #if(CXSC_INDEX_CHECK)
1129  ;
1130 #else
1131  noexcept;
1132 #endif
1133  template <class VS,class V,class E> friend E _vsvminus(const VS &sl,const V &rv)
1134 #if(CXSC_INDEX_CHECK)
1135  ;
1136 #else
1137  noexcept;
1138 #endif
1139  template <class V,class VS,class E> friend E _vvssect(const V &rv,const VS &sl)
1140 #if(CXSC_INDEX_CHECK)
1141  ;
1142 #else
1143  noexcept;
1144 #endif
1145  template <class VS1,class VS2,class E> friend E _vsvssect(const VS1 &s1,const VS2 &s2)
1146 #if(CXSC_INDEX_CHECK)
1147  ;
1148 #else
1149  noexcept;
1150 #endif
1151  template <class V,class VS> friend V &_vvssectassign(V &rv, const VS &sl)
1152 #if(CXSC_INDEX_CHECK)
1153  ;
1154 #else
1155  noexcept;
1156 #endif
1157  template <class VS,class V> friend VS &_vsvsectassign(VS &sl, const V &rv)
1158 #if(CXSC_INDEX_CHECK)
1159  ;
1160 #else
1161  noexcept;
1162 #endif
1163  template <class VS1,class VS2> friend VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2)
1164 #if(CXSC_INDEX_CHECK)
1165  ;
1166 #else
1167  noexcept;
1168 #endif
1169  template <class V,class VS,class E> friend E _vvsconv(const V &rv,const VS &sl)
1170 #if(CXSC_INDEX_CHECK)
1171  ;
1172 #else
1173  noexcept;
1174 #endif
1175  template <class VS1,class VS2,class E> friend E _vsvsconv(const VS1 &s1,const VS2 &s2)
1176 #if(CXSC_INDEX_CHECK)
1177  ;
1178 #else
1179  noexcept;
1180 #endif
1181  template <class V,class VS> friend V &_vvsconvassign(V &rv, const VS &sl)
1182 #if(CXSC_INDEX_CHECK)
1183  ;
1184 #else
1185  noexcept;
1186 #endif
1187  template <class VS,class V> friend VS &_vsvconvassign(VS &sl, const V &rv)
1188 #if(CXSC_INDEX_CHECK)
1189  ;
1190 #else
1191  noexcept;
1192 #endif
1193  template <class VS1,class VS2> friend VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2)
1194 #if(CXSC_INDEX_CHECK)
1195  ;
1196 #else
1197  noexcept;
1198 #endif
1199  template <class VS,class M,class S> friend VS &_vsmimultassign(VS &v,const M &m)
1200 #if(CXSC_INDEX_CHECK)
1201  ;
1202 #else
1203  noexcept;
1204 #endif
1205 
1206  template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) noexcept;
1207  template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) noexcept;
1208  template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) noexcept;
1209  template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) noexcept;
1210  template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) noexcept;
1211  template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) noexcept;
1212  template <class VS,class E> friend E _vsabs(const VS &sl) noexcept;
1213  template <class VS,class E> friend E _vsdiam(const VS &sl) noexcept;
1214  template <class VS,class E> friend E _vsmid(const VS &sl) noexcept;
1215  template <class VS,class E> friend E _vsinf(const VS &sl) noexcept;
1216  template <class VS,class E> friend E _vssup(const VS &sl) noexcept;
1217  template <class VS1,class VS2,class E> friend E _vsvsimult(const VS1 & sl1, const VS2 &sl2)
1218 #if(CXSC_INDEX_CHECK)
1219  ;
1220 #else
1221  noexcept;
1222 #endif
1223  template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) noexcept;
1224  template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) noexcept;
1225  template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) noexcept;
1226  template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) noexcept;
1227  template <class VS> friend bool _vsnot(const VS &sl) noexcept;
1228  template <class VS> friend void *_vsvoid(const VS &sl) noexcept;
1229  template <class V> friend std::ostream &_vsout(std::ostream &s, const V &rv) noexcept;
1230  template <class V> friend std::istream &_vsin(std::istream &s, V &rv) noexcept;
1231 
1232  // Interval / Real
1233  template <class V,class MS,class E> friend E _vmsimult(const V &v,const MS &ms)
1234 #if(CXSC_INDEX_CHECK)
1235  ;
1236 #else
1237  noexcept;
1238 #endif
1239 
1240  // complex
1241  template <class VS,class V,class E> friend E _vsvcimult(const VS & sl, const V &rv)
1242 #if(CXSC_INDEX_CHECK)
1243  ;
1244 #else
1245  noexcept;
1246 #endif
1247  template <class V,class VS> friend V &_vvssetim(V &rv, const VS &sl)
1248 #if(CXSC_INDEX_CHECK)
1249  ;
1250 #else
1251  noexcept;
1252 #endif
1253  template <class V,class VS> friend V &_vvssetre(V &rv, const VS &sl)
1254 #if(CXSC_INDEX_CHECK)
1255  ;
1256 #else
1257  noexcept;
1258 #endif
1259  template <class VS1,class VS2> friend VS1 &_vsvssetim(VS1 &sl1, const VS2 &sl2)
1260 #if(CXSC_INDEX_CHECK)
1261  ;
1262 #else
1263  noexcept;
1264 #endif
1265  template <class VS1,class VS2> friend VS1 &_vsvssetre(VS1 &sl1, const VS2 &sl2)
1266 #if(CXSC_INDEX_CHECK)
1267  ;
1268 #else
1269  noexcept;
1270 #endif
1271 
1272  // cinterval-- vector-scalar
1273  // cinterval -- vector-vector
1274 template <class VS1,class VS2,class E> friend E _vsvscimult(const VS1 & sl1, const VS2 &sl2)
1275 #if(CXSC_INDEX_CHECK)
1276  ;
1277 #else
1278  noexcept;
1279 #endif
1280 
1281  // cinterval -- vector-matrix
1282  // l_real
1283 
1284  template <class VS1,class VS2,class E> friend E _vsvslimult(const VS1 & sl1, const VS2 &sl2)
1285 #if(CXSC_INDEX_CHECK)
1286  ;
1287 #else
1288  noexcept;
1289 #endif
1290 
1291  // l_interval ----------
1292  // l_interval-- vector-scalar
1293  // l_interval -- vector-vector
1294 template <class VS,class V,class E> friend E _vsvlimult(const VS & sl, const V &rv)
1295 #if(CXSC_INDEX_CHECK)
1296  ;
1297 #else
1298  noexcept;
1299 #endif
1300 
1301 
1302 #endif
1303 
1304  //--------------------- Konstruktoren -----------------------------------
1306  explicit INLINE ivector_slice(ivector &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) { }
1308  explicit INLINE ivector_slice(ivector_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) { }
1309  public:
1311  INLINE ivector_slice(const ivector_slice &a) noexcept:dat(a.dat),l(a.l),u(a.u),size(a.size),start(a.start),end(a.end) { }
1312  public:
1313  // Interval
1315  INLINE ivector_slice & operator =(const sivector &sl);
1317  INLINE ivector_slice & operator =(const sivector_slice &sl);
1319  INLINE ivector_slice & operator =(const srvector &sl);
1321  INLINE ivector_slice & operator =(const srvector_slice &sl);
1322 
1324  INLINE ivector_slice & operator =(const ivector_slice &sl)
1325 #if(CXSC_INDEX_CHECK)
1326 ;
1327 #else
1328  noexcept;
1329 #endif
1331  INLINE ivector_slice & operator =(const ivector &rv)
1332 #if(CXSC_INDEX_CHECK)
1333 ;
1334 #else
1335  noexcept;
1336 #endif
1338  INLINE ivector_slice & operator =(const interval &r) noexcept;
1340  INLINE ivector_slice & operator =(const imatrix &m)
1341 #if(CXSC_INDEX_CHECK)
1342 ;
1343 #else
1344  noexcept;
1345 #endif
1347  INLINE ivector_slice & operator =(const imatrix_slice &m)
1348 #if(CXSC_INDEX_CHECK)
1349 ;
1350 #else
1351  noexcept;
1352 #endif
1354  INLINE ivector_slice &operator =(const imatrix_subv &) noexcept;
1355  // Real
1357  INLINE ivector_slice & operator =(const rvector_slice &sl)
1358 #if(CXSC_INDEX_CHECK)
1359 ;
1360 #else
1361  noexcept;
1362 #endif
1364  INLINE ivector_slice & operator =(const rvector &rv)
1365 #if(CXSC_INDEX_CHECK)
1366 ;
1367 #else
1368  noexcept;
1369 #endif
1371  INLINE ivector_slice & operator =(const real &r) noexcept;
1373  INLINE ivector_slice & operator =(const rmatrix &m)
1374 #if(CXSC_INDEX_CHECK)
1375 ;
1376 #else
1377  noexcept;
1378 #endif
1380  INLINE ivector_slice & operator =(const rmatrix_slice &m)
1381 #if(CXSC_INDEX_CHECK)
1382 ;
1383 #else
1384  noexcept;
1385 #endif
1387  INLINE ivector_slice &operator =(const rmatrix_subv &mv) noexcept;
1388 
1389  //--------------------- Standardfunktionen ------------------------------
1390 
1391  friend INLINE interval::interval(const ivector_slice &sl)
1392 #if(CXSC_INDEX_CHECK)
1393 ;
1394 #else
1395  noexcept;
1396 #endif
1398  friend INLINE int Lb(const ivector_slice &sl) noexcept { return sl.start; }
1400  friend INLINE int Ub(const ivector_slice &sl) noexcept { return sl.end; }
1402  friend INLINE int VecLen(const ivector_slice &sl) noexcept { return sl.end-sl.start+1; }
1404  INLINE interval & operator [](const int &i) const
1405 #if(CXSC_INDEX_CHECK)
1406 ;
1407 #else
1408  noexcept;
1409 #endif
1410 
1412  INLINE interval & operator [](const int &i)
1413 #if(CXSC_INDEX_CHECK)
1414 ;
1415 #else
1416  noexcept;
1417 #endif
1418 
1420  INLINE ivector_slice & operator ()() noexcept { return *this; }
1422  INLINE ivector_slice operator ()(const int &i)
1423 #if(CXSC_INDEX_CHECK)
1424 ;
1425 #else
1426  noexcept;
1427 #endif
1429  INLINE ivector_slice operator ()(const int &i1,const int &i2)
1430 #if(CXSC_INDEX_CHECK)
1431 ;
1432 #else
1433  noexcept;
1434 #endif
1435 
1437  INLINE ivector_slice &operator /=(const interval &r) noexcept;
1439  INLINE ivector_slice &operator /=(const real &r) noexcept;
1441  INLINE ivector_slice &operator *=(const interval &r) noexcept;
1443  INLINE ivector_slice &operator *=(const imatrix &m)
1444 #if(CXSC_INDEX_CHECK)
1445 ;
1446 #else
1447  noexcept;
1448 #endif
1450  INLINE ivector_slice &operator *=(const rmatrix &m)
1451 #if(CXSC_INDEX_CHECK)
1452 ;
1453 #else
1454  noexcept;
1455 #endif
1457  INLINE ivector_slice &operator *=(const real &r) noexcept;
1459  INLINE ivector_slice &operator +=(const ivector &rv)
1460 #if(CXSC_INDEX_CHECK)
1461 ;
1462 #else
1463  noexcept;
1464 #endif
1466  INLINE ivector_slice &operator +=(const ivector_slice &sl2)
1467 #if(CXSC_INDEX_CHECK)
1468 ;
1469 #else
1470  noexcept;
1471 #endif
1473  INLINE ivector_slice &operator -=(const ivector &rv)
1474 #if(CXSC_INDEX_CHECK)
1475 ;
1476 #else
1477  noexcept;
1478 #endif
1480  INLINE ivector_slice &operator -=(const ivector_slice &sl2)
1481 #if(CXSC_INDEX_CHECK)
1482 ;
1483 #else
1484  noexcept;
1485 #endif
1487  INLINE ivector_slice &operator |=(const ivector &rv)
1488 #if(CXSC_INDEX_CHECK)
1489 ;
1490 #else
1491  noexcept;
1492 #endif
1494  INLINE ivector_slice &operator |=(const ivector_slice &sl2)
1495 #if(CXSC_INDEX_CHECK)
1496 ;
1497 #else
1498  noexcept;
1499 #endif
1501  INLINE ivector_slice &operator &=(const ivector &rv)
1502 #if(CXSC_INDEX_CHECK)
1503 ;
1504 #else
1505  noexcept;
1506 #endif
1508  INLINE ivector_slice &operator &=(const ivector_slice &sl2)
1509 #if(CXSC_INDEX_CHECK)
1510 ;
1511 #else
1512  noexcept;
1513 #endif
1514 
1516  INLINE ivector_slice &operator +=(const rvector &rv)
1517 #if(CXSC_INDEX_CHECK)
1518 ;
1519 #else
1520  noexcept;
1521 #endif
1523  INLINE ivector_slice &operator +=(const rvector_slice &sl2)
1524 #if(CXSC_INDEX_CHECK)
1525 ;
1526 #else
1527  noexcept;
1528 #endif
1530  INLINE ivector_slice &operator -=(const rvector &rv)
1531 #if(CXSC_INDEX_CHECK)
1532 ;
1533 #else
1534  noexcept;
1535 #endif
1537  INLINE ivector_slice &operator -=(const rvector_slice &sl2)
1538 #if(CXSC_INDEX_CHECK)
1539 ;
1540 #else
1541  noexcept;
1542 #endif
1544  INLINE ivector_slice &operator |=(const rvector &rv)
1545 #if(CXSC_INDEX_CHECK)
1546 ;
1547 #else
1548  noexcept;
1549 #endif
1551  INLINE ivector_slice &operator |=(const rvector_slice &sl2)
1552 #if(CXSC_INDEX_CHECK)
1553 ;
1554 #else
1555  noexcept;
1556 #endif
1558  INLINE ivector_slice &operator &=(const rvector &rv)
1559 #if(CXSC_INDEX_CHECK)
1560 ;
1561 #else
1562  noexcept;
1563 #endif
1565  INLINE ivector_slice &operator &=(const rvector_slice &sl2)
1566 #if(CXSC_INDEX_CHECK)
1567 ;
1568 #else
1569  noexcept;
1570 #endif
1571  INLINE operator void*() noexcept;
1572 //#else
1573 //#endif
1574 
1576  INLINE ivector_slice &operator+=(const srvector&);
1578  INLINE ivector_slice &operator+=(const sivector&);
1580  INLINE ivector_slice &operator+=(const srvector_slice&);
1582  INLINE ivector_slice &operator+=(const sivector_slice&);
1584  INLINE ivector_slice &operator-=(const srvector&);
1586  INLINE ivector_slice &operator-=(const sivector&);
1588  INLINE ivector_slice &operator-=(const srvector_slice&);
1590  INLINE ivector_slice &operator-=(const sivector_slice&);
1592  INLINE ivector_slice &operator|=(const srvector&);
1594  INLINE ivector_slice &operator|=(const sivector&);
1596  INLINE ivector_slice &operator|=(const srvector_slice&);
1598  INLINE ivector_slice &operator|=(const sivector_slice&);
1600  INLINE ivector_slice &operator&=(const sivector&);
1602  INLINE ivector_slice &operator&=(const sivector_slice&);
1603 
1604 };
1605 
1606 //=======================================================================
1607 //======================== Vector Functions =============================
1608 
1610  INLINE ivector _ivector(const interval &r) noexcept;
1611 // INLINE ivector _ivector(const imatrix &m);
1612 // INLINE ivector _ivector(const imatrix_slice &sl);
1614  INLINE ivector _ivector(const real &r) noexcept;
1616  INLINE ivector _ivector(const rvector_slice &rs) noexcept;
1618  INLINE ivector _ivector(const rvector &rs) noexcept;
1619 // INLINE ivector _ivector(const rmatrix &m);
1620 // INLINE ivector _ivector(const rmatrix_slice &sl);
1622  INLINE ivector _ivector(const rmatrix_subv &rs) noexcept;
1623 
1625  INLINE ivector &SetInf(ivector &iv,const rvector &rv)
1626 #if(CXSC_INDEX_CHECK)
1627 ;
1628 #else
1629  noexcept;
1630 #endif
1632  INLINE ivector_slice &SetInf(ivector_slice &iv,const rvector &rv)
1633 #if(CXSC_INDEX_CHECK)
1634 ;
1635 #else
1636  noexcept;
1637 #endif
1639  INLINE ivector &SetInf(ivector &iv,const rvector_slice &rv)
1640 #if(CXSC_INDEX_CHECK)
1641 ;
1642 #else
1643  noexcept;
1644 #endif
1646  INLINE ivector_slice &SetInf(ivector_slice &iv,const rvector_slice &rv)
1647 #if(CXSC_INDEX_CHECK)
1648 ;
1649 #else
1650  noexcept;
1651 #endif
1653  INLINE ivector &UncheckedSetInf(ivector &iv,const rvector &rv)
1654 #if(CXSC_INDEX_CHECK)
1655 ;
1656 #else
1657  noexcept;
1658 #endif
1660  INLINE ivector_slice &UncheckedSetInf(ivector_slice &iv,const rvector &rv)
1661 #if(CXSC_INDEX_CHECK)
1662 ;
1663 #else
1664  noexcept;
1665 #endif
1667  INLINE ivector &UncheckedSetInf(ivector &iv,const rvector_slice &rv)
1668 #if(CXSC_INDEX_CHECK)
1669 ;
1670 #else
1671  noexcept;
1672 #endif
1674  INLINE ivector_slice &UncheckedSetInf(ivector_slice &iv,const rvector_slice &rv)
1675 #if(CXSC_INDEX_CHECK)
1676 ;
1677 #else
1678  noexcept;
1679 #endif
1680 
1682  INLINE ivector &SetSup(ivector &iv,const rvector &rv)
1683 #if(CXSC_INDEX_CHECK)
1684 ;
1685 #else
1686  noexcept;
1687 #endif
1689  INLINE ivector_slice &SetSup(ivector_slice &iv,const rvector &rv)
1690 #if(CXSC_INDEX_CHECK)
1691 ;
1692 #else
1693  noexcept;
1694 #endif
1696  INLINE ivector &SetSup(ivector &iv,const rvector_slice &rv)
1697 #if(CXSC_INDEX_CHECK)
1698 ;
1699 #else
1700  noexcept;
1701 #endif
1703  INLINE ivector_slice &SetSup(ivector_slice &iv,const rvector_slice &rv)
1704 #if(CXSC_INDEX_CHECK)
1705 ;
1706 #else
1707  noexcept;
1708 #endif
1710  INLINE ivector &UncheckedSetSup(ivector &iv,const rvector &rv)
1711 #if(CXSC_INDEX_CHECK)
1712 ;
1713 #else
1714  noexcept;
1715 #endif
1717  INLINE ivector_slice &UncheckedSetSup(ivector_slice &iv,const rvector &rv)
1718 #if(CXSC_INDEX_CHECK)
1719 ;
1720 #else
1721  noexcept;
1722 #endif
1724  INLINE ivector &UncheckedSetSup(ivector &iv,const rvector_slice &rv)
1725 #if(CXSC_INDEX_CHECK)
1726 ;
1727 #else
1728  noexcept;
1729 #endif
1731  INLINE ivector_slice &UncheckedSetSup(ivector_slice &iv,const rvector_slice &rv)
1732 #if(CXSC_INDEX_CHECK)
1733 ;
1734 #else
1735  noexcept;
1736 #endif
1737 
1739  INLINE ivector &SetSup(ivector &iv,const real &r) noexcept;
1741  INLINE ivector &SetInf(ivector &iv,const real &r) noexcept;
1743  INLINE ivector &UncheckedSetSup(ivector &iv,const real &r) noexcept;
1745  INLINE ivector &SetUncheckedInf(ivector &iv,const real &r) noexcept;
1747  INLINE ivector_slice &SetSup(ivector_slice &iv,const real &r) noexcept;
1749  INLINE ivector_slice &SetInf(ivector_slice &iv,const real &r) noexcept;
1751  INLINE ivector_slice &UncheckedSetSup(ivector_slice &iv,const real &r) noexcept;
1753  INLINE ivector_slice &SetUncheckedInf(ivector_slice &iv,const real &r) noexcept;
1754 
1756  INLINE void Resize(ivector &rv) noexcept;
1758  INLINE void Resize(ivector &rv, const int &len)
1759 #if(CXSC_INDEX_CHECK)
1760 ;
1761 #else
1762  noexcept;
1763 #endif
1765  INLINE void Resize(ivector &rv, const int &lb, const int &ub)
1766 #if(CXSC_INDEX_CHECK)
1767 ;
1768 #else
1769  noexcept;
1770 #endif
1771 
1773  INLINE ivector abs(const ivector &rv) noexcept;
1775  INLINE ivector abs(const ivector_slice &sl) noexcept;
1777  INLINE rvector absmin(const ivector &rv) noexcept;
1779  INLINE rvector absmax(const ivector_slice &sl) noexcept;
1781  INLINE rvector absmin(const ivector &rv) noexcept;
1783  INLINE rvector absmax(const ivector_slice &sl) noexcept;
1785  INLINE rvector diam(const ivector &v) noexcept;
1787  INLINE rvector diam(const ivector_slice &v) noexcept;
1789  INLINE rvector mid(const ivector &v) noexcept;
1791  INLINE rvector mid(const ivector_slice &v) noexcept;
1793  INLINE rvector Inf(const ivector &v) noexcept;
1795  INLINE rvector Inf(const ivector_slice &v) noexcept;
1797  INLINE rvector Sup(const ivector &v) noexcept;
1799  INLINE rvector Sup(const ivector_slice &v) noexcept;
1801  INLINE bool operator !(const ivector &rv) noexcept;
1803  INLINE bool operator !(const ivector_slice &sl) noexcept;
1804 
1805 //======================= Vector / Scalar ===============================
1806 
1807 //----------------------------- Interval ---------------------------
1808 
1810  INLINE ivector operator *(const ivector &rv, const interval &s) noexcept;
1812  INLINE ivector operator *(const ivector_slice &sl, const interval &s) noexcept;
1814  INLINE ivector operator *(const interval &s, const ivector &rv) noexcept;
1816  INLINE ivector operator *(const interval &s, const ivector_slice &sl) noexcept;
1818  INLINE ivector &operator *=(ivector &rv,const interval &r) noexcept;
1819 
1821  INLINE ivector operator /(const ivector &rv, const interval &s) noexcept;
1823  INLINE ivector operator /(const ivector_slice &sl, const interval &s) noexcept;
1825  INLINE ivector &operator /=(ivector &rv,const interval &r) noexcept;
1826 
1827 //---------------------------- Real --------------------------------------
1828 
1830  INLINE ivector operator *(const ivector &rv, const real &s) noexcept;
1832  INLINE ivector operator *(const ivector_slice &sl, const real &s) noexcept;
1834  INLINE ivector operator *(const real &s, const ivector &rv) noexcept;
1836  INLINE ivector operator *(const real &s, const ivector_slice &sl) noexcept;
1838  INLINE ivector &operator *=(ivector &rv,const real &r) noexcept;
1839 
1841  INLINE ivector operator /(const ivector &rv, const real &s) noexcept;
1843  INLINE ivector operator /(const ivector_slice &sl, const real &s) noexcept;
1845  INLINE ivector &operator /=(ivector &rv,const real &r) noexcept;
1846 
1848  INLINE ivector operator *(const rvector &rv, const interval &s) noexcept;
1850  INLINE ivector operator *(const rvector_slice &sl, const interval &s) noexcept;
1852  INLINE ivector operator *(const interval &s, const rvector &rv) noexcept;
1854  INLINE ivector operator *(const interval &s, const rvector_slice &sl) noexcept;
1855 
1857  INLINE ivector operator /(const rvector &rv, const interval &s) noexcept;
1859  INLINE ivector operator /(const rvector_slice &sl, const interval &s) noexcept;
1860 
1861 //======================= Vector / Vector ===============================
1862 
1863 
1865  INLINE std::ostream &operator <<(std::ostream &s, const ivector &rv) noexcept;
1867  INLINE std::ostream &operator <<(std::ostream &o, const ivector_slice &sl) noexcept;
1869  INLINE std::istream &operator >>(std::istream &s, ivector &rv) noexcept;
1871  INLINE std::istream &operator >>(std::istream &s, ivector_slice &rv) noexcept;
1872 
1873 //----------------------- Interval / Interval ---------------------------
1874 
1876  void accumulate(idotprecision &dp, const ivector &);
1877 
1879  void accumulate(idotprecision &dp, const rvector &);
1880 
1882  void accumulate(idotprecision &dp, const ivector & rv1, const ivector &rv2)
1883 #if(CXSC_INDEX_CHECK)
1884 ;
1885 #else
1886  noexcept;
1887 #endif
1889  void accumulate(idotprecision &dp, const ivector_slice & sl, const ivector &rv)
1890 #if(CXSC_INDEX_CHECK)
1891 ;
1892 #else
1893  noexcept;
1894 #endif
1896  void accumulate(idotprecision &dp, const ivector &rv, const ivector_slice &sl)
1897 #if(CXSC_INDEX_CHECK)
1898 ;
1899 #else
1900  noexcept;
1901 #endif
1903  void accumulate(idotprecision &dp, const ivector & rv1, const imatrix_subv &rv2)
1904 #if(CXSC_INDEX_CHECK)
1905 ;
1906 #else
1907  noexcept;
1908 #endif
1910  void accumulate(idotprecision &dp, const imatrix_subv & rv1, const ivector &rv2)
1911 #if(CXSC_INDEX_CHECK)
1912 ;
1913 #else
1914  noexcept;
1915 #endif
1917  void accumulate(idotprecision &dp, const ivector_slice & rv1, const imatrix_subv &rv2)
1918 #if(CXSC_INDEX_CHECK)
1919 ;
1920 #else
1921  noexcept;
1922 #endif
1924  void accumulate(idotprecision &dp, const imatrix_subv & rv1, const ivector_slice &rv2)
1925 #if(CXSC_INDEX_CHECK)
1926 ;
1927 #else
1928  noexcept;
1929 #endif
1931  void accumulate(idotprecision &dp, const ivector_slice & sl1, const ivector_slice &sl2)
1932 #if(CXSC_INDEX_CHECK)
1933 ;
1934 #else
1935  noexcept;
1936 #endif
1938  void accumulate(cidotprecision &dp, const ivector & rv1, const ivector &rv2)
1939 #if(CXSC_INDEX_CHECK)
1940 ;
1941 #else
1942  noexcept;
1943 #endif
1945  void accumulate(cidotprecision &dp, const ivector_slice & sl, const ivector &rv)
1946 #if(CXSC_INDEX_CHECK)
1947 ;
1948 #else
1949  noexcept;
1950 #endif
1952  void accumulate(cidotprecision &dp, const ivector &rv, const ivector_slice &sl)
1953 #if(CXSC_INDEX_CHECK)
1954 ;
1955 #else
1956  noexcept;
1957 #endif
1959  void accumulate(cidotprecision &dp, const ivector & rv1, const imatrix_subv &rv2)
1960 #if(CXSC_INDEX_CHECK)
1961 ;
1962 #else
1963  noexcept;
1964 #endif
1966  void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const ivector &rv2)
1967 #if(CXSC_INDEX_CHECK)
1968 ;
1969 #else
1970  noexcept;
1971 #endif
1973  void accumulate(cidotprecision &dp, const ivector_slice & sl1, const ivector_slice &sl2)
1974 #if(CXSC_INDEX_CHECK)
1975 ;
1976 #else
1977  noexcept;
1978 #endif
1979 
1981  INLINE interval operator *(const ivector & rv1, const ivector &rv2)
1982 #if(CXSC_INDEX_CHECK)
1983 ;
1984 #else
1985  noexcept;
1986 #endif
1988  INLINE interval operator *(const ivector_slice &sl, const ivector &rv)
1989 #if(CXSC_INDEX_CHECK)
1990 ;
1991 #else
1992  noexcept;
1993 #endif
1995  INLINE interval operator *(const ivector &rv, const ivector_slice &sl)
1996 #if(CXSC_INDEX_CHECK)
1997 ;
1998 #else
1999  noexcept;
2000 #endif
2002  INLINE interval operator *(const ivector_slice & sl1, const ivector_slice &sl2)
2003 #if(CXSC_INDEX_CHECK)
2004 ;
2005 #else
2006  noexcept;
2007 #endif
2008 
2010  INLINE const ivector &operator +(const ivector &rv) noexcept;
2012  INLINE ivector operator +(const ivector_slice &sl) noexcept;
2013 
2015  INLINE ivector operator +(const ivector &rv1, const ivector &rv2)
2016 #if(CXSC_INDEX_CHECK)
2017 ;
2018 #else
2019  noexcept;
2020 #endif
2022  INLINE ivector operator +(const ivector &rv, const ivector_slice &sl)
2023 #if(CXSC_INDEX_CHECK)
2024 ;
2025 #else
2026  noexcept;
2027 #endif
2029  INLINE ivector operator +(const ivector_slice &sl, const ivector &rv)
2030 #if(CXSC_INDEX_CHECK)
2031 ;
2032 #else
2033  noexcept;
2034 #endif
2036  INLINE ivector operator +(const ivector_slice &sl1, const ivector_slice &sl2)
2037 #if(CXSC_INDEX_CHECK)
2038 ;
2039 #else
2040  noexcept;
2041 #endif
2043  INLINE ivector & operator +=(ivector &rv1, const ivector &rv2)
2044 #if(CXSC_INDEX_CHECK)
2045 ;
2046 #else
2047  noexcept;
2048 #endif
2050  INLINE ivector &operator +=(ivector &rv, const ivector_slice &sl)
2051 #if(CXSC_INDEX_CHECK)
2052 ;
2053 #else
2054  noexcept;
2055 #endif
2056 
2058  INLINE ivector operator -(const ivector &rv) noexcept;
2060  INLINE ivector operator -(const ivector_slice &sl) noexcept;
2062  INLINE ivector operator -(const ivector &rv1, const ivector &rv2)
2063 #if(CXSC_INDEX_CHECK)
2064 ;
2065 #else
2066  noexcept;
2067 #endif
2069  INLINE ivector operator -(const ivector &rv, const ivector_slice &sl)
2070 #if(CXSC_INDEX_CHECK)
2071 ;
2072 #else
2073  noexcept;
2074 #endif
2076  INLINE ivector operator -(const ivector_slice &sl, const ivector &rv)
2077 #if(CXSC_INDEX_CHECK)
2078 ;
2079 #else
2080  noexcept;
2081 #endif
2083  INLINE ivector operator -(const ivector_slice &sl1, const ivector_slice &sl2)
2084 #if(CXSC_INDEX_CHECK)
2085 ;
2086 #else
2087  noexcept;
2088 #endif
2090  INLINE ivector & operator -=(ivector &rv1, const ivector &rv2)
2091 #if(CXSC_INDEX_CHECK)
2092 ;
2093 #else
2094  noexcept;
2095 #endif
2097  INLINE ivector &operator -=(ivector &rv, const ivector_slice &sl)
2098 #if(CXSC_INDEX_CHECK)
2099 ;
2100 #else
2101  noexcept;
2102 #endif
2103 
2105  INLINE ivector operator |(const ivector &rv1, const ivector &rv2)
2106 #if(CXSC_INDEX_CHECK)
2107 ;
2108 #else
2109  noexcept;
2110 #endif
2112  INLINE ivector operator |(const ivector &rv, const ivector_slice &sl)
2113 #if(CXSC_INDEX_CHECK)
2114 ;
2115 #else
2116  noexcept;
2117 #endif
2119  INLINE ivector operator |(const ivector_slice &sl, const ivector &rv)
2120 #if(CXSC_INDEX_CHECK)
2121 ;
2122 #else
2123  noexcept;
2124 #endif
2126  INLINE ivector operator |(const ivector_slice &sl1, const ivector_slice &sl2)
2127 #if(CXSC_INDEX_CHECK)
2128 ;
2129 #else
2130  noexcept;
2131 #endif
2133  INLINE ivector & operator |=(ivector &rv1, const ivector &rv2)
2134 #if(CXSC_INDEX_CHECK)
2135 ;
2136 #else
2137  noexcept;
2138 #endif
2140  INLINE ivector &operator |=(ivector &rv, const ivector_slice &sl)
2141 #if(CXSC_INDEX_CHECK)
2142 ;
2143 #else
2144  noexcept;
2145 #endif
2146 
2148  INLINE ivector operator &(const ivector &rv1, const ivector &rv2)
2149 #if(CXSC_INDEX_CHECK)
2150 ;
2151 #else
2152  noexcept;
2153 #endif
2155  INLINE ivector operator &(const ivector &rv, const ivector_slice &sl)
2156 #if(CXSC_INDEX_CHECK)
2157 ;
2158 #else
2159  noexcept;
2160 #endif
2162  INLINE ivector operator &(const ivector_slice &sl, const ivector &rv)
2163 #if(CXSC_INDEX_CHECK)
2164 ;
2165 #else
2166  noexcept;
2167 #endif
2169  INLINE ivector operator &(const ivector_slice &sl1, const ivector_slice &sl2)
2170 #if(CXSC_INDEX_CHECK)
2171 ;
2172 #else
2173  noexcept;
2174 #endif
2176  INLINE ivector & operator &=(ivector &rv1, const ivector &rv2)
2177 #if(CXSC_INDEX_CHECK)
2178 ;
2179 #else
2180  noexcept;
2181 #endif
2183  INLINE ivector &operator &=(ivector &rv, const ivector_slice &sl)
2184 #if(CXSC_INDEX_CHECK)
2185 ;
2186 #else
2187  noexcept;
2188 #endif
2189 
2191  INLINE bool operator ==(const ivector &rv1, const ivector &rv2) noexcept;
2193  INLINE bool operator ==(const ivector_slice &sl1, const ivector_slice &sl2) noexcept;
2195  INLINE bool operator ==(const ivector_slice &sl, const ivector &rv) noexcept;
2197  INLINE bool operator ==(const ivector &rv, const ivector_slice &sl) noexcept;
2199  INLINE bool operator !=(const ivector &rv1, const ivector &rv2) noexcept;
2201  INLINE bool operator !=(const ivector_slice &sl1, const ivector_slice &sl2) noexcept;
2203  INLINE bool operator !=(const ivector_slice &sl, const ivector &rv) noexcept;
2205  INLINE bool operator !=(const ivector &rv, const ivector_slice &sl) noexcept;
2207  INLINE bool operator <(const ivector &rv1, const ivector &rv2) noexcept;
2209  INLINE bool operator <(const ivector_slice &sl1, const ivector_slice &sl2) noexcept;
2211  INLINE bool operator < (const ivector_slice &sl, const ivector &rv) noexcept;
2213  INLINE bool operator < (const ivector &rv, const ivector_slice &sl) noexcept;
2215  INLINE bool operator <=(const ivector &rv1, const ivector &rv2) noexcept;
2217  INLINE bool operator <=(const ivector_slice &sl1, const ivector_slice &sl2) noexcept;
2219  INLINE bool operator <=(const ivector_slice &sl, const ivector &rv) noexcept;
2221  INLINE bool operator <=(const ivector &rv, const ivector_slice &sl) noexcept;
2223  INLINE bool operator >(const ivector &rv1, const ivector &rv2) noexcept;
2225  INLINE bool operator >(const ivector_slice &sl1, const ivector_slice &sl2) noexcept;
2227  INLINE bool operator >(const ivector_slice &sl, const ivector &rv) noexcept;
2229  INLINE bool operator >(const ivector &rv, const ivector_slice &sl) noexcept;
2231  INLINE bool operator >=(const ivector &rv1, const ivector &rv2) noexcept;
2233  INLINE bool operator >=(const ivector_slice &sl1, const ivector_slice &sl2) noexcept;
2235  INLINE bool operator >=(const ivector_slice &sl, const ivector &rv) noexcept;
2237  INLINE bool operator >=(const ivector &rv, const ivector_slice &sl) noexcept;
2238 
2239 //-------------------------------- Interval / Real --------------------------------
2240 
2242  void accumulate(idotprecision &dp, const rvector & rv1, const ivector &rv2)
2243 #if(CXSC_INDEX_CHECK)
2244 ;
2245 #else
2246  noexcept;
2247 #endif
2249  void accumulate(idotprecision &dp, const ivector & rv1, const rvector &rv2)
2250 #if(CXSC_INDEX_CHECK)
2251 ;
2252 #else
2253  noexcept;
2254 #endif
2256  void accumulate(idotprecision &dp, const rvector_slice & sl, const ivector &rv)
2257 #if(CXSC_INDEX_CHECK)
2258 ;
2259 #else
2260  noexcept;
2261 #endif
2263  void accumulate(idotprecision &dp,const ivector_slice &sl,const rvector &rv)
2264 #if(CXSC_INDEX_CHECK)
2265 ;
2266 #else
2267  noexcept;
2268 #endif
2270  void accumulate(idotprecision &dp, const rvector &rv, const ivector_slice &sl)
2271 #if(CXSC_INDEX_CHECK)
2272 ;
2273 #else
2274  noexcept;
2275 #endif
2277  void accumulate(idotprecision &dp, const rvector & rv1, const imatrix_subv &rv2)
2278 #if(CXSC_INDEX_CHECK)
2279 ;
2280 #else
2281  noexcept;
2282 #endif
2284  void accumulate(idotprecision &dp, const ivector & rv1, const rmatrix_subv &rv2)
2285 #if(CXSC_INDEX_CHECK)
2286 ;
2287 #else
2288  noexcept;
2289 #endif
2291  void accumulate(idotprecision &dp, const rvector_slice & rv1, const imatrix_subv &rv2)
2292 #if(CXSC_INDEX_CHECK)
2293 ;
2294 #else
2295  noexcept;
2296 #endif
2298  void accumulate(idotprecision &dp, const ivector_slice & rv1, const rmatrix_subv &rv2)
2299 #if(CXSC_INDEX_CHECK)
2300 ;
2301 #else
2302  noexcept;
2303 #endif
2305  void accumulate(idotprecision &dp,const ivector &rv,const rvector_slice &sl)
2306 #if(CXSC_INDEX_CHECK)
2307 ;
2308 #else
2309  noexcept;
2310 #endif
2312  void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const ivector &rv2)
2313 #if(CXSC_INDEX_CHECK)
2314 ;
2315 #else
2316  noexcept;
2317 #endif
2319  void accumulate(idotprecision &dp, const imatrix_subv & rv1, const rvector &rv2)
2320 #if(CXSC_INDEX_CHECK)
2321 ;
2322 #else
2323  noexcept;
2324 #endif
2326  void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const ivector_slice &rv2)
2327 #if(CXSC_INDEX_CHECK)
2328 ;
2329 #else
2330  noexcept;
2331 #endif
2333  void accumulate(idotprecision &dp, const imatrix_subv & rv1, const rvector_slice &rv2)
2334 #if(CXSC_INDEX_CHECK)
2335 ;
2336 #else
2337  noexcept;
2338 #endif
2340  void accumulate(idotprecision &dp, const ivector_slice & sl1, const rvector_slice &sl2)
2341 #if(CXSC_INDEX_CHECK)
2342 ;
2343 #else
2344  noexcept;
2345 #endif
2347  void accumulate(idotprecision &dp, const rvector_slice & sl1, const ivector_slice &sl2)
2348 #if(CXSC_INDEX_CHECK)
2349 ;
2350 #else
2351  noexcept;
2352 #endif
2354  void accumulate(cidotprecision &dp, const rvector & rv1, const ivector &rv2)
2355 #if(CXSC_INDEX_CHECK)
2356 ;
2357 #else
2358  noexcept;
2359 #endif
2361  void accumulate(cidotprecision &dp, const ivector & rv1, const rvector &rv2)
2362 #if(CXSC_INDEX_CHECK)
2363 ;
2364 #else
2365  noexcept;
2366 #endif
2368  void accumulate(cidotprecision &dp, const rvector_slice & sl, const ivector &rv)
2369 #if(CXSC_INDEX_CHECK)
2370 ;
2371 #else
2372  noexcept;
2373 #endif
2375  void accumulate(cidotprecision &dp,const ivector_slice &sl,const rvector &rv)
2376 #if(CXSC_INDEX_CHECK)
2377 ;
2378 #else
2379  noexcept;
2380 #endif
2382  void accumulate(cidotprecision &dp, const rvector &rv, const ivector_slice &sl)
2383 #if(CXSC_INDEX_CHECK)
2384 ;
2385 #else
2386  noexcept;
2387 #endif
2389  void accumulate(cidotprecision &dp, const rvector & rv1, const imatrix_subv &rv2)
2390 #if(CXSC_INDEX_CHECK)
2391 ;
2392 #else
2393  noexcept;
2394 #endif
2396  void accumulate(cidotprecision &dp, const ivector & rv1, const rmatrix_subv &rv2)
2397 #if(CXSC_INDEX_CHECK)
2398 ;
2399 #else
2400  noexcept;
2401 #endif
2403  void accumulate(cidotprecision &dp, const rvector_slice & rv1, const imatrix_subv &rv2)
2404 #if(CXSC_INDEX_CHECK)
2405 ;
2406 #else
2407  noexcept;
2408 #endif
2410  void accumulate(cidotprecision &dp, const ivector_slice & rv1, const rmatrix_subv &rv2)
2411 #if(CXSC_INDEX_CHECK)
2412 ;
2413 #else
2414  noexcept;
2415 #endif
2417  void accumulate(cidotprecision &dp,const ivector &rv,const rvector_slice &sl)
2418 #if(CXSC_INDEX_CHECK)
2419 ;
2420 #else
2421  noexcept;
2422 #endif
2424  void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const ivector &rv2)
2425 #if(CXSC_INDEX_CHECK)
2426 ;
2427 #else
2428  noexcept;
2429 #endif
2431  void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const rvector &rv2)
2432 #if(CXSC_INDEX_CHECK)
2433 ;
2434 #else
2435  noexcept;
2436 #endif
2438  void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const ivector_slice &rv2)
2439 #if(CXSC_INDEX_CHECK)
2440 ;
2441 #else
2442  noexcept;
2443 #endif
2445  void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const rvector_slice &rv2)
2446 #if(CXSC_INDEX_CHECK)
2447 ;
2448 #else
2449  noexcept;
2450 #endif
2452  void accumulate(cidotprecision &dp, const ivector_slice & sl1, const rvector_slice &sl2)
2453 #if(CXSC_INDEX_CHECK)
2454 ;
2455 #else
2456  noexcept;
2457 #endif
2459  void accumulate(cidotprecision &dp, const rvector_slice & sl1, const ivector_slice &sl2)
2460 #if(CXSC_INDEX_CHECK)
2461 ;
2462 #else
2463  noexcept;
2464 #endif
2465 
2467  INLINE interval operator *(const rvector & rv1, const ivector &rv2)
2468 #if(CXSC_INDEX_CHECK)
2469 ;
2470 #else
2471  noexcept;
2472 #endif
2474  INLINE interval operator *(const rvector_slice &sl, const ivector &rv)
2475 #if(CXSC_INDEX_CHECK)
2476 ;
2477 #else
2478  noexcept;
2479 #endif
2481  INLINE interval operator *(const rvector &rv, const ivector_slice &sl)
2482 #if(CXSC_INDEX_CHECK)
2483 ;
2484 #else
2485  noexcept;
2486 #endif
2488  INLINE interval operator *(const rvector_slice & sl1, const ivector_slice &sl2)
2489 #if(CXSC_INDEX_CHECK)
2490 ;
2491 #else
2492  noexcept;
2493 #endif
2494 
2496  INLINE interval operator *(const ivector & rv1, const rvector &rv2)
2497 #if(CXSC_INDEX_CHECK)
2498 ;
2499 #else
2500  noexcept;
2501 #endif
2503  INLINE interval operator *(const ivector_slice &sl, const rvector &rv)
2504 #if(CXSC_INDEX_CHECK)
2505 ;
2506 #else
2507  noexcept;
2508 #endif
2510  INLINE interval operator *(const ivector &rv, const rvector_slice &sl)
2511 #if(CXSC_INDEX_CHECK)
2512 ;
2513 #else
2514  noexcept;
2515 #endif
2517  INLINE interval operator *(const ivector_slice & sl1, const rvector_slice &sl2)
2518 #if(CXSC_INDEX_CHECK)
2519 ;
2520 #else
2521  noexcept;
2522 #endif
2523 
2525  INLINE ivector operator +(const rvector &rv1, const ivector &rv2)
2526 #if(CXSC_INDEX_CHECK)
2527 ;
2528 #else
2529  noexcept;
2530 #endif
2532  INLINE ivector operator +(const rvector &rv, const ivector_slice &sl)
2533 #if(CXSC_INDEX_CHECK)
2534 ;
2535 #else
2536  noexcept;
2537 #endif
2539  INLINE ivector operator +(const rvector_slice &sl, const ivector &rv)
2540 #if(CXSC_INDEX_CHECK)
2541 ;
2542 #else
2543  noexcept;
2544 #endif
2546  INLINE ivector operator +(const rvector_slice &sl1, const ivector_slice &sl2)
2547 #if(CXSC_INDEX_CHECK)
2548 ;
2549 #else
2550  noexcept;
2551 #endif
2552 
2554  INLINE ivector operator +(const ivector &rv1, const rvector &rv2)
2555 #if(CXSC_INDEX_CHECK)
2556 ;
2557 #else
2558  noexcept;
2559 #endif
2561  INLINE ivector operator +(const ivector &rv, const rvector_slice &sl)
2562 #if(CXSC_INDEX_CHECK)
2563 ;
2564 #else
2565  noexcept;
2566 #endif
2568  INLINE ivector operator +(const ivector_slice &sl, const rvector &rv)
2569 #if(CXSC_INDEX_CHECK)
2570 ;
2571 #else
2572  noexcept;
2573 #endif
2575  INLINE ivector operator +(const ivector_slice &sl1, const rvector_slice &sl2)
2576 #if(CXSC_INDEX_CHECK)
2577 ;
2578 #else
2579  noexcept;
2580 #endif
2581 
2583  INLINE ivector & operator +=(ivector &rv1, const rvector &rv2)
2584 #if(CXSC_INDEX_CHECK)
2585 ;
2586 #else
2587  noexcept;
2588 #endif
2590  INLINE ivector &operator +=(ivector &rv, const rvector_slice &sl)
2591 #if(CXSC_INDEX_CHECK)
2592 ;
2593 #else
2594  noexcept;
2595 #endif
2596 
2598  INLINE ivector operator -(const rvector &rv1, const ivector &rv2)
2599 #if(CXSC_INDEX_CHECK)
2600 ;
2601 #else
2602  noexcept;
2603 #endif
2605  INLINE ivector operator -(const rvector &rv, const ivector_slice &sl)
2606 #if(CXSC_INDEX_CHECK)
2607 ;
2608 #else
2609  noexcept;
2610 #endif
2612  INLINE ivector operator -(const rvector_slice &sl, const ivector &rv)
2613 #if(CXSC_INDEX_CHECK)
2614 ;
2615 #else
2616  noexcept;
2617 #endif
2619  INLINE ivector operator -(const rvector_slice &sl1, const ivector_slice &sl2)
2620 #if(CXSC_INDEX_CHECK)
2621 ;
2622 #else
2623  noexcept;
2624 #endif
2625 
2627  INLINE ivector operator -(const ivector &rv1, const rvector &rv2)
2628 #if(CXSC_INDEX_CHECK)
2629 ;
2630 #else
2631  noexcept;
2632 #endif
2634  INLINE ivector operator -(const ivector &rv, const rvector_slice &sl)
2635 #if(CXSC_INDEX_CHECK)
2636 ;
2637 #else
2638  noexcept;
2639 #endif
2641  INLINE ivector operator -(const ivector_slice &sl, const rvector &rv)
2642 #if(CXSC_INDEX_CHECK)
2643 ;
2644 #else
2645  noexcept;
2646 #endif
2648  INLINE ivector operator -(const ivector_slice &sl1, const rvector_slice &sl2)
2649 #if(CXSC_INDEX_CHECK)
2650 ;
2651 #else
2652  noexcept;
2653 #endif
2654 
2656  INLINE ivector & operator -=(ivector &rv1, const rvector &rv2)
2657 #if(CXSC_INDEX_CHECK)
2658 ;
2659 #else
2660  noexcept;
2661 #endif
2663  INLINE ivector &operator -=(ivector &rv, const rvector_slice &sl)
2664 #if(CXSC_INDEX_CHECK)
2665 ;
2666 #else
2667  noexcept;
2668 #endif
2669 
2671  INLINE ivector operator |(const rvector &rv1, const rvector &rv2)
2672 #if(CXSC_INDEX_CHECK)
2673 ;
2674 #else
2675  noexcept;
2676 #endif
2678  INLINE ivector operator |(const rvector &rv, const rvector_slice &sl)
2679 #if(CXSC_INDEX_CHECK)
2680 ;
2681 #else
2682  noexcept;
2683 #endif
2685  INLINE ivector operator |(const rvector_slice &sl, const rvector &rv)
2686 #if(CXSC_INDEX_CHECK)
2687 ;
2688 #else
2689  noexcept;
2690 #endif
2692  INLINE ivector operator |(const rvector_slice &sl1, const rvector_slice &sl2)
2693 #if(CXSC_INDEX_CHECK)
2694 ;
2695 #else
2696  noexcept;
2697 #endif
2699  INLINE ivector operator |(const rvector &rv1, const ivector &rv2)
2700 #if(CXSC_INDEX_CHECK)
2701 ;
2702 #else
2703  noexcept;
2704 #endif
2706  INLINE ivector operator |(const rvector &rv, const ivector_slice &sl)
2707 #if(CXSC_INDEX_CHECK)
2708 ;
2709 #else
2710  noexcept;
2711 #endif
2713  INLINE ivector operator |(const rvector_slice &sl, const ivector &rv)
2714 #if(CXSC_INDEX_CHECK)
2715 ;
2716 #else
2717  noexcept;
2718 #endif
2720  INLINE ivector operator |(const rvector_slice &sl1, const ivector_slice &sl2)
2721 #if(CXSC_INDEX_CHECK)
2722 ;
2723 #else
2724  noexcept;
2725 #endif
2726 
2728  INLINE ivector operator |(const ivector &rv1, const rvector &rv2)
2729 #if(CXSC_INDEX_CHECK)
2730 ;
2731 #else
2732  noexcept;
2733 #endif
2735  INLINE ivector operator |(const ivector &rv, const rvector_slice &sl)
2736 #if(CXSC_INDEX_CHECK)
2737 ;
2738 #else
2739  noexcept;
2740 #endif
2742  INLINE ivector operator |(const ivector_slice &sl, const rvector &rv)
2743 #if(CXSC_INDEX_CHECK)
2744 ;
2745 #else
2746  noexcept;
2747 #endif
2749  INLINE ivector operator |(const ivector_slice &sl1, const rvector_slice &sl2)
2750 #if(CXSC_INDEX_CHECK)
2751 ;
2752 #else
2753  noexcept;
2754 #endif
2755 
2757  INLINE ivector & operator |=(ivector &rv1, const rvector &rv2)
2758 #if(CXSC_INDEX_CHECK)
2759 ;
2760 #else
2761  noexcept;
2762 #endif
2764  INLINE ivector &operator |=(ivector &rv, const rvector_slice &sl)
2765 #if(CXSC_INDEX_CHECK)
2766 ;
2767 #else
2768  noexcept;
2769 #endif
2770 
2772  INLINE ivector operator &(const rvector &rv1, const ivector &rv2)
2773 #if(CXSC_INDEX_CHECK)
2774 ;
2775 #else
2776  noexcept;
2777 #endif
2779  INLINE ivector operator &(const rvector &rv, const ivector_slice &sl)
2780 #if(CXSC_INDEX_CHECK)
2781 ;
2782 #else
2783  noexcept;
2784 #endif
2786  INLINE ivector operator &(const rvector_slice &sl, const ivector &rv)
2787 #if(CXSC_INDEX_CHECK)
2788 ;
2789 #else
2790  noexcept;
2791 #endif
2793  INLINE ivector operator &(const rvector_slice &sl1, const ivector_slice &sl2)
2794 #if(CXSC_INDEX_CHECK)
2795 ;
2796 #else
2797  noexcept;
2798 #endif
2799 
2801  INLINE ivector operator &(const ivector &rv1, const rvector &rv2)
2802 #if(CXSC_INDEX_CHECK)
2803 ;
2804 #else
2805  noexcept;
2806 #endif
2808  INLINE ivector operator &(const ivector &rv, const rvector_slice &sl)
2809 #if(CXSC_INDEX_CHECK)
2810 ;
2811 #else
2812  noexcept;
2813 #endif
2815  INLINE ivector operator &(const ivector_slice &sl, const rvector &rv)
2816 #if(CXSC_INDEX_CHECK)
2817 ;
2818 #else
2819  noexcept;
2820 #endif
2822  INLINE ivector operator &(const ivector_slice &sl1, const rvector_slice &sl2)
2823 #if(CXSC_INDEX_CHECK)
2824 ;
2825 #else
2826  noexcept;
2827 #endif
2828 
2830  INLINE ivector & operator &=(ivector &rv1, const rvector &rv2)
2831 #if(CXSC_INDEX_CHECK)
2832 ;
2833 #else
2834  noexcept;
2835 #endif
2837  INLINE ivector &operator &=(ivector &rv, const rvector_slice &sl)
2838 #if(CXSC_INDEX_CHECK)
2839 ;
2840 #else
2841  noexcept;
2842 #endif
2843 
2845 extern int in ( const ivector&, const ivector& );
2847 extern int in ( int, ivector& );
2849 extern ivector Blow ( const ivector&, real );
2851 extern int Disjoint ( ivector&, ivector& );
2853 extern int Zero ( ivector& );
2855 extern rvector mid ( ivector& );
2857 extern real MaxRelDiam ( const ivector& );
2859 extern real MaxRelDiam ( const ivector_slice& );
2861 extern int UlpAcc ( ivector&, int );
2863 extern void DoubleSize ( ivector& );
2864 
2865 
2866 } // namespace cxsc
2867 
2868 #ifdef _CXSC_INCL_INL
2869 #include "vector.inl"
2870 #include "ivector.inl"
2871 #endif
2872 
2873 #ifdef _CXSC_RMATRIX_HPP_INCLUDED
2874 # ifdef _CXSC_INCL_INL
2875 # include "ivecrmat.inl"
2876 # else
2877 # include "ivecrmat.hpp"
2878 # endif
2879 #endif
2880 
2881 #ifdef _CXSC_CMATRIX_HPP_INCLUDED
2882 # ifdef _CXSC_INCL_INL
2883 # include "iveccmat.inl"
2884 # else
2885 # include "iveccmat.hpp"
2886 # endif
2887 #endif
2888 
2889 #ifdef _CXSC_LRMATRIX_HPP_INCLUDED
2890 # ifdef _CXSC_INCL_INL
2891 # include "iveclrmat.inl"
2892 # else
2893 # include "iveclrmat.hpp"
2894 # endif
2895 #endif
2896 
2897 #ifdef _CXSC_CVECTOR_HPP_INCLUDED
2898 # ifdef _CXSC_INCL_INL
2899 # include "iveccvec.inl"
2900 # else
2901 # include "iveccvec.hpp"
2902 # endif
2903 #endif
2904 
2905 #ifdef _CXSC_LRVECTOR_HPP_INCLUDED
2906 # ifdef _CXSC_INCL_INL
2907 # include "lrvecivec.inl"
2908 # else
2909 # include "lrvecivec.hpp"
2910 # endif
2911 #endif
2912 
2913 #ifdef CXSC_USE_BLAS
2914 #define _CXSC_BLAS_IVECTOR
2915 #include "cxsc_blas.inl"
2916 #endif
2917 
2918 #endif
The Data Type cimatrix.
Definition: cimatrix.hpp:908
The Data Type civector.
Definition: civector.hpp:57
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
interval()
Constructor of class interval.
Definition: interval.hpp:64
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
interval & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector (read-only)
Definition: ivector.inl:126
ivector_slice(const ivector_slice &a) noexcept
Constructor of class ivector_slice.
Definition: ivector.hpp:1311
ivector_slice & operator|=(const ivector &rv) noexcept
Allocates the convex hull of the arguments to the first argument.
Definition: ivector.inl:726
ivector_slice & operator+=(const ivector &rv) noexcept
Implementation of addition and allocation operation.
Definition: ivector.inl:610
ivector_slice & operator-=(const ivector &rv) noexcept
Implementation of subtraction and allocation operation.
Definition: ivector.inl:669
ivector_slice & operator*=(const interval &r) noexcept
Implementation of multiplication and allocation operation.
Definition: ivector.inl:496
ivector_slice & operator=(const sivector &sl)
Implementation of standard assigning operator.
Definition: sivector.hpp:2194
ivector_slice & operator/=(const interval &r) noexcept
Implementation of division and allocation operation.
Definition: ivector.inl:501
ivector_slice(ivector_slice &a, const int &lb, const int &ub) noexcept
Constructor of class ivector_slice.
Definition: ivector.hpp:1308
friend int Lb(const ivector_slice &sl) noexcept
Returns the lower bound of the vector.
Definition: ivector.hpp:1398
friend int VecLen(const ivector_slice &sl) noexcept
Returns the dimension of the vector.
Definition: ivector.hpp:1402
ivector_slice & operator&=(const ivector &rv) noexcept
Allocates the intersection of the arguments to the first argument.
Definition: ivector.inl:783
friend int Ub(const ivector_slice &sl) noexcept
Returns the upper bound of the vector.
Definition: ivector.hpp:1400
ivector_slice & operator()() noexcept
Operator for accessing the whole vector.
Definition: ivector.hpp:1420
ivector_slice(ivector &a, const int &lb, const int &ub) noexcept
Constructor of class ivector_slice.
Definition: ivector.hpp:1306
The Data Type ivector.
Definition: ivector.hpp:55
ivector & operator|=(const srvector &)
Implementation of assignment and hull operator
Definition: sivector.hpp:1221
ivector & operator-=(const srvector &)
Implementation of assignment and substraction operator
Definition: sivector.hpp:1205
ivector & operator&=(const sivector &)
Implementation of assignment and intersection operator
Definition: sivector.hpp:1237
friend ivector & SetLb(ivector &rv, const int &l) noexcept
Sets the lower bound of the vector.
Definition: ivector.hpp:914
friend int Ub(const ivector &rv) noexcept
Returns the upper bound of the vector.
Definition: ivector.hpp:910
ivector & operator=(const ivector &rv) noexcept
Implementation of standard assigning operator.
Definition: ivector.inl:263
friend int Lb(const ivector &rv) noexcept
Returns the lower bound of the vector.
Definition: ivector.hpp:908
friend ivector & SetUb(ivector &rv, const int &u) noexcept
Sets the upper bound of the vector.
Definition: ivector.hpp:916
ivector & operator+=(const srvector &)
Implementation of assignment and addition operator
Definition: sivector.hpp:1189
ivector() noexcept
Constructor of class ivector.
Definition: ivector.inl:31
ivector & operator()() noexcept
Operator for accessing the whole vector.
Definition: ivector.hpp:934
interval & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector (read-only)
Definition: ivector.inl:100
friend int VecLen(const ivector &rv) noexcept
Returns the dimension of the vector.
Definition: ivector.hpp:912
The Multiple-Precision Data Type l_imatrix.
Definition: l_imatrix.hpp:726
The Multiple-Precision Data Type l_ivector.
Definition: l_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: 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
int Disjoint(const interval &a, const interval &b)
Checks arguments for disjointness.
Definition: interval.cpp:288
INLINE ivector _ivector(const rmatrix &sl) noexcept
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC.
Definition: ivecrmat.inl:57
real MaxRelDiam(const imatrix_subv &v)
Computes the relative diameter .
Definition: imatrix.cpp:76
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 UlpAcc(const interval &x, int n)
Checks if the diameter of the interval is ulps.
Definition: interval.cpp:335
rvector absmax(const imatrix_subv &mv) noexcept
Returns the absolute maximum value of the matrix.
Definition: imatrix.inl:502
int in(const cinterval &x, const cinterval &y)
Checks if first argument is part of second argument.
Definition: cinterval.cpp:654
rvector absmin(const imatrix_subv &mv) noexcept
Returns the absolute minimum value of the matrix.
Definition: imatrix.inl:496
void DoubleSize(cimatrix &A)
Doubles the size of the matrix.
Definition: cimatrix.cpp:83
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
int Zero(ivector &x)
Checks if vector is zero vector.
Definition: ivector.cpp:80
cinterval Blow(cinterval x, const real &eps)
Performs an epsilon inflation.
Definition: cinterval.cpp:665
cimatrix & operator/=(cimatrix &m, const cinterval &c) noexcept
Implementation of division and allocation operation.
Definition: cimatrix.inl:1623