C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
l_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: l_ivector.hpp,v 1.19 2014/01/30 17:23:46 cxsc Exp $ */
25 
26 #ifndef _CXSC_LIVECTOR_HPP_INCLUDED
27 #define _CXSC_LIVECTOR_HPP_INCLUDED
28 
29 #include "xscclass.hpp"
30 #include "except.hpp"
31 #include "idot.hpp"
32 #include "l_interval.hpp" // used for declaration of Inf, Sup,...
33 //#include "cxscmatr.hpp"
34 #include "rvector.hpp"
35 #include "ivector.hpp"
36 #include "l_rvector.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 l_ivector_slice;
47 
49 
54 class l_ivector
55 {
56  friend class l_ivector_slice;
57  friend class l_imatrix;
58  friend class l_imatrix_subv;
59  private:
60  l_interval *dat;
61  int l,u,size;
62 
63  public:
64 //#if(CXSC_INDEX_CHECK)
65 #ifdef _CXSC_FRIEND_TPL
66  //------------ Templates --------------------------------------------------
67  // l_interval
68 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m)
69 #if(CXSC_INDEX_CHECK)
70 ;
71 #else
72  noexcept;
73 #endif
74 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
75 #if(CXSC_INDEX_CHECK)
76 ;
77 #else
78  noexcept;
79 #endif
80  template <class V> friend void _vresize(V &rv) noexcept;
81  template <class V,class S> friend void _vresize(V &rv, const int &len)
82 #if(CXSC_INDEX_CHECK)
83  ;
84 #else
85  noexcept;
86 #endif
87  template <class V,class S> friend void _vresize(V &rv, const int &lb, const int &ub)
88 #if(CXSC_INDEX_CHECK)
89  ;
90 #else
91  noexcept;
92 #endif
93  template <class V1,class V2,class S> friend V1 &_vvassign(V1 &rv1,const V2 &rv2) noexcept;
94  template <class V,class S> friend V & _vsassign(V &rv,const S &r) noexcept;
95  template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) noexcept;
96  template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv)
97 #if(CXSC_INDEX_CHECK)
98  ;
99 #else
100  noexcept;
101 #endif
102 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m)
103 #if(CXSC_INDEX_CHECK)
104 ;
105 #else
106  noexcept;
107 #endif
108 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) noexcept;
109  template <class V1,class V2> friend V1 &_vvsetinf(V1 &rv1, const V2 &rv2)
110 #if(CXSC_INDEX_CHECK)
111  ;
112 #else
113  noexcept;
114 #endif
115  template <class V1,class V2> friend V1 &_vvsetsup(V1 &rv1, const V2 &rv2)
116 #if(CXSC_INDEX_CHECK)
117  ;
118 #else
119  noexcept;
120 #endif
121  template <class V,class VS> friend V &_vvssetinf(V &rv, const VS &sl)
122 #if(CXSC_INDEX_CHECK)
123  ;
124 #else
125  noexcept;
126 #endif
127  template <class V,class VS> friend V &_vvssetsup(V &rv, const VS &sl)
128 #if(CXSC_INDEX_CHECK)
129  ;
130 #else
131  noexcept;
132 #endif
133 template <class V,class MV> friend V &_vmvsetinf(V &rv,const MV &v)
134 #if(CXSC_INDEX_CHECK)
135 ;
136 #else
137  noexcept;
138 #endif
139 template <class V,class MV> friend V &_vmvsetsup(V &rv,const MV &v)
140 #if(CXSC_INDEX_CHECK)
141 ;
142 #else
143  noexcept;
144 #endif
145  template <class V1,class V2> friend V1 &_vvusetinf(V1 &rv1, const V2 &rv2)
146 #if(CXSC_INDEX_CHECK)
147  ;
148 #else
149  noexcept;
150 #endif
151  template <class V1,class V2> friend V1 &_vvusetsup(V1 &rv1, const V2 &rv2)
152 #if(CXSC_INDEX_CHECK)
153  ;
154 #else
155  noexcept;
156 #endif
157  template <class V,class VS> friend V &_vvsusetinf(V &rv, const VS &sl)
158 #if(CXSC_INDEX_CHECK)
159  ;
160 #else
161  noexcept;
162 #endif
163  template <class V,class VS> friend V &_vvsusetsup(V &rv, const VS &sl)
164 #if(CXSC_INDEX_CHECK)
165  ;
166 #else
167  noexcept;
168 #endif
169 template <class V,class MV> friend V &_vmvusetinf(V &rv,const MV &v)
170 #if(CXSC_INDEX_CHECK)
171 ;
172 #else
173  noexcept;
174 #endif
175 template <class V,class MV> friend V &_vmvusetsup(V &rv,const MV &v)
176 #if(CXSC_INDEX_CHECK)
177 ;
178 #else
179  noexcept;
180 #endif
181  template <class V,class S> friend V &_vssetinf(V &v, const S &s) noexcept;
182  template <class V,class S> friend V &_vssetsup(V &v, const S &s) noexcept;
183  template <class V,class S> friend V &_vsusetinf(V &v, const S &s) noexcept;
184  template <class V,class S> friend V &_vsusetsup(V &v, const S &s) noexcept;
185  template <class V,class E> friend E _vabs(const V &rv) noexcept;
186  template <class VS,class E> friend E _vsabs(const VS &sl) noexcept;
187 template <class MV,class V> friend V _mvabs(const MV &mv) noexcept;
188  template <class V,class E> friend E _vdiam(const V &rv) noexcept;
189  template <class V,class E> friend E _vmid(const V &rv) noexcept;
190  template <class V,class E> friend E _vinf(const V &rv) noexcept;
191  template <class V,class E> friend E _vsup(const V &rv) noexcept;
192 
193 //-------- vector-vector -----------------------
194  template <class DP,class V1,class V2> friend void _vvaccu(DP &dp, const V1 & rv1, const V2 &rv2)
195 #if(CXSC_INDEX_CHECK)
196  ;
197 #else
198  noexcept;
199 #endif
200  template <class DP,class VS,class V> friend void _vsvaccu(DP &dp, const VS & sl, const V &rv)
201 #if(CXSC_INDEX_CHECK)
202  ;
203 #else
204  noexcept;
205 #endif
206 
207  template <class V1,class V2,class E> friend E _vvlimult(const V1 & rv1, const V2 &rv2)
208 #if(CXSC_INDEX_CHECK)
209  ;
210 #else
211  noexcept;
212 #endif
213  template <class VS,class V,class E> friend E _vsvlimult(const VS & sl, const V &rv)
214 #if(CXSC_INDEX_CHECK)
215  ;
216 #else
217  noexcept;
218 #endif
219 
220  template <class V,class S> friend V &_vsmultassign(V &rv,const S &r) noexcept;
221  template <class V1,class V2,class E> friend E _vvplus(const V1 &rv1, const V2 &rv2)
222 #if(CXSC_INDEX_CHECK)
223  ;
224 #else
225  noexcept;
226 #endif
227  template <class V,class VS,class E> friend E _vvsplus(const V &rv,const VS &sl)
228 #if(CXSC_INDEX_CHECK)
229  ;
230 #else
231  noexcept;
232 #endif
233  template <class VS1,class VS2,class E> friend E _vsvsplus(const VS1 &s1,const VS2 &s2)
234 #if(CXSC_INDEX_CHECK)
235  ;
236 #else
237  noexcept;
238 #endif
239  template <class VS1,class VS2,class E> friend E _vsvsminus(const VS1 &s1,const VS2 &s2)
240 #if(CXSC_INDEX_CHECK)
241  ;
242 #else
243  noexcept;
244 #endif
245  template <class V1,class V2> friend V1 &_vvplusassign(V1 &rv1, const V2 &rv2)
246 #if(CXSC_INDEX_CHECK)
247  ;
248 #else
249  noexcept;
250 #endif
251  template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl)
252 #if(CXSC_INDEX_CHECK)
253  ;
254 #else
255  noexcept;
256 #endif
257  template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv)
258 #if(CXSC_INDEX_CHECK)
259  ;
260 #else
261  noexcept;
262 #endif
263  template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
264 #if(CXSC_INDEX_CHECK)
265  ;
266 #else
267  noexcept;
268 #endif
269  template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
270 #if(CXSC_INDEX_CHECK)
271  ;
272 #else
273  noexcept;
274 #endif
275  template <class V1,class V2> friend V1 &_vvminusassign(V1 &rv1, const V2 &rv2)
276 #if(CXSC_INDEX_CHECK)
277  ;
278 #else
279  noexcept;
280 #endif
281  template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl)
282 #if(CXSC_INDEX_CHECK)
283  ;
284 #else
285  noexcept;
286 #endif
287  template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv)
288 #if(CXSC_INDEX_CHECK)
289  ;
290 #else
291  noexcept;
292 #endif
293  template <class V> friend V _vminus(const V &rv) noexcept;
294  template <class VS,class V> friend V _vsminus(const VS &sl) noexcept;
295  template <class V1,class V2,class E> friend E _vvminus(const V1 &rv1, const V2 &rv2)
296 #if(CXSC_INDEX_CHECK)
297  ;
298 #else
299  noexcept;
300 #endif
301  template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl)
302 #if(CXSC_INDEX_CHECK)
303  ;
304 #else
305  noexcept;
306 #endif
307  template <class VS,class V,class E> friend E _vsvminus(const VS &sl,const V &rv)
308 #if(CXSC_INDEX_CHECK)
309  ;
310 #else
311  noexcept;
312 #endif
313  template <class V1,class V2,class E> friend E _vvconv(const V1 &rv1, const V2 &rv2)
314 #if(CXSC_INDEX_CHECK)
315  ;
316 #else
317  noexcept;
318 #endif
319  template <class V,class VS,class E> friend E _vvsconv(const V &rv,const VS &sl)
320 #if(CXSC_INDEX_CHECK)
321  ;
322 #else
323  noexcept;
324 #endif
325  template <class VS1,class VS2,class E> friend E _vsvsconv(const VS1 &s1,const VS2 &s2)
326 #if(CXSC_INDEX_CHECK)
327  ;
328 #else
329  noexcept;
330 #endif
331  template <class V1,class V2> friend V1 &_vvconvassign(V1 &rv1, const V2 &rv2)
332 #if(CXSC_INDEX_CHECK)
333  ;
334 #else
335  noexcept;
336 #endif
337  template <class V,class VS> friend V &_vvsconvassign(V &rv, const VS &sl)
338 #if(CXSC_INDEX_CHECK)
339  ;
340 #else
341  noexcept;
342 #endif
343  template <class VS,class V> friend VS &_vsvconvassign(VS &sl, const V &rv)
344 #if(CXSC_INDEX_CHECK)
345  ;
346 #else
347  noexcept;
348 #endif
349  template <class VS1,class VS2> friend VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2)
350 #if(CXSC_INDEX_CHECK)
351  ;
352 #else
353  noexcept;
354 #endif
355  template <class V1,class V2,class E> friend E _vvsect(const V1 &rv1, const V2 &rv2)
356 #if(CXSC_INDEX_CHECK)
357  ;
358 #else
359  noexcept;
360 #endif
361  template <class V,class VS,class E> friend E _vvssect(const V &rv,const VS &sl)
362 #if(CXSC_INDEX_CHECK)
363  ;
364 #else
365  noexcept;
366 #endif
367  template <class VS1,class VS2,class E> friend E _vsvssect(const VS1 &s1,const VS2 &s2)
368 #if(CXSC_INDEX_CHECK)
369  ;
370 #else
371  noexcept;
372 #endif
373  template <class V1,class V2> friend V1 &_vvsectassign(V1 &rv1, const V2 &rv2)
374 #if(CXSC_INDEX_CHECK)
375  ;
376 #else
377  noexcept;
378 #endif
379  template <class V,class VS> friend V &_vvssectassign(V &rv, const VS &sl)
380 #if(CXSC_INDEX_CHECK)
381  ;
382 #else
383  noexcept;
384 #endif
385  template <class VS,class V> friend VS &_vsvsectassign(VS &sl, const V &rv)
386 #if(CXSC_INDEX_CHECK)
387  ;
388 #else
389  noexcept;
390 #endif
391  template <class VS1,class VS2> friend VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2)
392 #if(CXSC_INDEX_CHECK)
393  ;
394 #else
395  noexcept;
396 #endif
397  template <class MV1,class MV2,class E> friend E _mvmvsect(const MV1 &rv1, const MV2 &rv2)
398 #if(CXSC_INDEX_CHECK)
399  ;
400 #else
401  noexcept;
402 #endif
403  template <class MV,class V,class E> friend E _mvvsect(const MV &rv1, const V &rv2)
404 #if(CXSC_INDEX_CHECK)
405  ;
406 #else
407  noexcept;
408 #endif
409 template <class MV,class V> friend MV &_mvvsectassign(MV &v,const V &rv)
410 #if(CXSC_INDEX_CHECK)
411 ;
412 #else
413  noexcept;
414 #endif
415 template <class V,class MV> friend V &_vmvsectassign(V &rv,const MV &v)
416 #if(CXSC_INDEX_CHECK)
417 ;
418 #else
419  noexcept;
420 #endif
421  template <class MV1,class MV2,class E> friend E _mvmvconv(const MV1 &rv1, const MV2 &rv2)
422 #if(CXSC_INDEX_CHECK)
423  ;
424 #else
425  noexcept;
426 #endif
427  template <class MV,class V,class E> friend E _mvvconv(const MV &rv1, const V &rv2)
428 #if(CXSC_INDEX_CHECK)
429  ;
430 #else
431  noexcept;
432 #endif
433 template <class MV,class V> friend MV &_mvvconvassign(MV &v,const V &rv)
434 #if(CXSC_INDEX_CHECK)
435 ;
436 #else
437  noexcept;
438 #endif
439 template <class V,class MV> friend V &_vmvconvassign(V &rv,const MV &v)
440 #if(CXSC_INDEX_CHECK)
441 ;
442 #else
443  noexcept;
444 #endif
445  template <class V,class MV,class S> friend S _vmvlimult(const V &rv1, const MV &rv2)
446 #if(CXSC_INDEX_CHECK)
447  ;
448 #else
449  noexcept;
450 #endif
451  //--------- vector-scalar -----------------
452  template <class V,class S,class E> friend E _vsdiv(const V &rv, const S &s) noexcept;
453  template <class V,class S> friend V &_vsdivassign(V &rv,const S &r) noexcept;
454  template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) noexcept;
455  template <class V,class S,class E> friend E _vsmult(const V &rv, const S &s) noexcept;
456  template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) noexcept;
457  template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) noexcept;
458  template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
459 #if(CXSC_INDEX_CHECK)
460  ;
461 #else
462  noexcept;
463 #endif
464  template <class MV,class V,class E> friend E _mvvplus(const MV &rv1, const V &rv2)
465 #if(CXSC_INDEX_CHECK)
466  ;
467 #else
468  noexcept;
469 #endif
470  template <class MV,class V,class E> friend E _mvvminus(const MV &rv1, const V &rv2)
471 #if(CXSC_INDEX_CHECK)
472  ;
473 #else
474  noexcept;
475 #endif
476  template <class V,class MV,class E> friend E _vmvminus(const V &rv1, const MV &rv2)
477 #if(CXSC_INDEX_CHECK)
478  ;
479 #else
480  noexcept;
481 #endif
482  template <class MV1,class MV2,class E> friend E _mvmvminus(const MV1 &rv1, const MV2 &rv2)
483 #if(CXSC_INDEX_CHECK)
484  ;
485 #else
486  noexcept;
487 #endif
488 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
489 #if(CXSC_INDEX_CHECK)
490 ;
491 #else
492  noexcept;
493 #endif
494 template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv)
495 #if(CXSC_INDEX_CHECK)
496 ;
497 #else
498  noexcept;
499 #endif
500  template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) noexcept;
501 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
502 #if(CXSC_INDEX_CHECK)
503 ;
504 #else
505  noexcept;
506 #endif
507 
508  template <class V1,class V2> friend bool _vveq(const V1 &rv1, const V2 &rv2) noexcept;
509  template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) noexcept;
510  template <class V1,class V2> friend bool _vvneq(const V1 &rv1, const V2 &rv2) noexcept;
511  template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) noexcept;
512  template <class V1,class V2> friend bool _vvless(const V1 &rv1, const V2 &rv2) noexcept;
513  template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) noexcept;
514  template <class V1,class V2> friend bool _vvleq(const V1 &rv1, const V2 &rv2) noexcept;
515  template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) noexcept;
516  template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) noexcept;
517  template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) noexcept;
518  template <class V> friend bool _vnot(const V &rv) noexcept;
519  template <class V> friend void *_vvoid(const V &rv) noexcept;
520  template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) noexcept;
521  template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) noexcept;
522  template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) noexcept;
523  template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) noexcept;
524  template <class VS> friend bool _vsnot(const VS &sl) noexcept;
525  template <class VS> friend void *_vsvoid(const VS &sl) noexcept;
526  template <class V> friend std::ostream &_vout(std::ostream &s, const V &rv) noexcept;
527  template <class V> friend std::istream &_vin(std::istream &s, V &rv) noexcept;
528 
529  //------------- vector-matrix ---------------
530 template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
531 #if(CXSC_INDEX_CHECK)
532  ;
533 #else
534  noexcept;
535 #endif
536 
537 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) noexcept;
538  template <class M,class V,class E> friend E _mvlimult(const M &m,const V &v)
539 #if(CXSC_INDEX_CHECK)
540  ;
541 #else
542  noexcept;
543 #endif
544  template <class V,class M,class E> friend E _vmlimult(const V &v,const M &m)
545 #if(CXSC_INDEX_CHECK)
546  ;
547 #else
548  noexcept;
549 #endif
550  template <class V,class M,class S> friend V &_vmimultassign(V &v,const M &m)
551 #if(CXSC_INDEX_CHECK)
552  ;
553 #else
554  noexcept;
555 #endif
556  template <class V,class M,class S> friend V &_vmlimultassign(V &v,const M &m)
557 #if(CXSC_INDEX_CHECK)
558  ;
559 #else
560  noexcept;
561 #endif
562  template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v)
563 #if(CXSC_INDEX_CHECK)
564  ;
565 #else
566  noexcept;
567 #endif
568  template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms)
569 #if(CXSC_INDEX_CHECK)
570  ;
571 #else
572  noexcept;
573 #endif
574  template <class V,class MS,class S> friend V &_vmslimultassign(V &v,const MS &ms)
575 #if(CXSC_INDEX_CHECK)
576  ;
577 #else
578  noexcept;
579 #endif
580 
581  // Real
582  template <class DP,class VS1,class VS2> friend void _vsvsaccu(DP &dp, const VS1 & sl1, const VS2 &sl2)
583 #if(CXSC_INDEX_CHECK)
584  ;
585 #else
586  noexcept;
587 #endif
588 
589  // l_rvector x ivector ----------------
590  // vector - matrix ------------
591  /* friend TINLINE l_ivector _mvslimult<imatrix,l_rvector_slice,l_ivector>(const imatrix &m,const l_rvector_slice &v)
592 #if(CXSC_INDEX_CHECK)
593 ;
594 #else
595  noexcept;
596  #endif */
597  /* friend TINLINE l_ivector _vsmlimult<l_rvector_slice,imatrix,l_ivector>(const l_rvector_slice &v,const imatrix &m)
598 #if(CXSC_INDEX_CHECK)
599 ;
600 #else
601  noexcept;
602  #endif */
603 
604 
605 #endif
606 
607 
608  //------ Konstruktoren ----------------------------------------------------
610  INLINE l_ivector () noexcept;
612  explicit INLINE l_ivector(const int &i) noexcept;
613 #ifdef OLD_CXSC
614  explicit INLINE l_ivector(const class index &i) noexcept; // for backwards compatibility
616 #endif
617  explicit INLINE l_ivector(const int &i1,const int &i2)
619 #if(CXSC_INDEX_CHECK)
620 ;
621 #else
622  noexcept;
623 #endif
624  INLINE l_ivector(const l_imatrix_subv &) noexcept;
627  explicit INLINE l_ivector(const l_interval &) noexcept;
629  explicit INLINE l_ivector(const l_imatrix &)
630 #if(CXSC_INDEX_CHECK)
631 ;
632 #else
633  noexcept;
634 #endif
635  explicit INLINE l_ivector(const l_imatrix_slice &sl)
637 #if(CXSC_INDEX_CHECK)
638 ;
639 #else
640  noexcept;
641 #endif
642  INLINE l_ivector(const l_ivector_slice &rs) noexcept;
645  INLINE l_ivector(const l_ivector &v) noexcept;
646  // Real
648  explicit INLINE l_ivector(const real &) noexcept;
650  explicit INLINE l_ivector(const rvector_slice &rs) noexcept;
652  explicit INLINE l_ivector(const rvector &v) noexcept;
654  explicit INLINE l_ivector(const rmatrix &)
655 #if(CXSC_INDEX_CHECK)
656 ;
657 #else
658  noexcept;
659 #endif
660  explicit INLINE l_ivector(const rmatrix_slice &sl)
662 #if(CXSC_INDEX_CHECK)
663 ;
664 #else
665  noexcept;
666 #endif
667  explicit INLINE l_ivector(const rmatrix_subv &) noexcept;
669 
670  // l_real
672  explicit INLINE l_ivector(const l_real &) noexcept;
674  explicit INLINE l_ivector(const l_rvector_slice &rs) noexcept;
676  explicit INLINE l_ivector(const l_rvector &v) noexcept;
678  explicit INLINE l_ivector(const l_rmatrix &)
679 #if(CXSC_INDEX_CHECK)
680 ;
681 #else
682  noexcept;
683 #endif
684  explicit INLINE l_ivector(const l_rmatrix_slice &sl)
686 #if(CXSC_INDEX_CHECK)
687 ;
688 #else
689  noexcept;
690 #endif
691  explicit INLINE l_ivector(const l_rmatrix_subv &) noexcept;
693 
694  // interval
696  explicit INLINE l_ivector(const interval &) noexcept;
698  explicit INLINE l_ivector(const ivector_slice &rs) noexcept;
700  explicit INLINE l_ivector(const ivector &v) noexcept;
702  explicit INLINE l_ivector(const imatrix &)
703 #if(CXSC_INDEX_CHECK)
704 ;
705 #else
706  noexcept;
707 #endif
708  explicit INLINE l_ivector(const imatrix_slice &sl)
710 #if(CXSC_INDEX_CHECK)
711 ;
712 #else
713  noexcept;
714 #endif
715  explicit INLINE l_ivector(const imatrix_subv &) noexcept;
717 
718  // l_interval
720  INLINE l_ivector &operator =(const l_ivector &rv) noexcept;
722  INLINE l_ivector &operator =(const l_ivector_slice &sl) noexcept;
724  INLINE l_ivector &operator =(const l_interval &r) noexcept;
726  INLINE l_ivector &operator =(const l_imatrix &m)
727 #if(CXSC_INDEX_CHECK)
728 ;
729 #else
730  noexcept;
731 #endif
732  INLINE l_ivector &operator =(const l_imatrix_slice &)
734 #if(CXSC_INDEX_CHECK)
735 ;
736 #else
737  noexcept;
738 #endif
739  INLINE l_ivector &operator =(const l_imatrix_subv &) noexcept;
741  // Real
743  INLINE l_ivector &operator =(const rvector &rv) noexcept;
745  INLINE l_ivector &operator =(const rvector_slice &sl) noexcept;
747  INLINE l_ivector &operator =(const real &r) noexcept;
749  INLINE l_ivector &operator =(const rmatrix &m)
750 #if(CXSC_INDEX_CHECK)
751 ;
752 #else
753  noexcept;
754 #endif
755  INLINE l_ivector &operator =(const rmatrix_slice &)
757 #if(CXSC_INDEX_CHECK)
758 ;
759 #else
760  noexcept;
761 #endif
762  INLINE l_ivector &operator =(const rmatrix_subv &) noexcept;
764 
765  // l_real
767  INLINE l_ivector &operator =(const l_rvector &rv) noexcept;
769  INLINE l_ivector &operator =(const l_rvector_slice &sl) noexcept;
771  INLINE l_ivector &operator =(const l_real &r) noexcept;
773  INLINE l_ivector &operator =(const l_rmatrix &m)
774 #if(CXSC_INDEX_CHECK)
775 ;
776 #else
777  noexcept;
778 #endif
779  INLINE l_ivector &operator =(const l_rmatrix_slice &)
781 #if(CXSC_INDEX_CHECK)
782 ;
783 #else
784  noexcept;
785 #endif
786  INLINE l_ivector &operator =(const l_rmatrix_subv &) noexcept;
788 
789  // interval
791  INLINE l_ivector &operator =(const ivector &rv) noexcept;
793  INLINE l_ivector &operator =(const ivector_slice &sl) noexcept;
795  INLINE l_ivector &operator =(const interval &r) noexcept;
797  INLINE l_ivector &operator =(const imatrix &m)
798 #if(CXSC_INDEX_CHECK)
799 ;
800 #else
801  noexcept;
802 #endif
803  INLINE l_ivector &operator =(const imatrix_slice &)
805 #if(CXSC_INDEX_CHECK)
806 ;
807 #else
808  noexcept;
809 #endif
810  INLINE l_ivector &operator =(const imatrix_subv &) noexcept;
812 
813  //--------- Destruktor ----------------------------------------------------
814  INLINE ~l_ivector() { delete [] dat; }
815 
816  //------ Standardfunktionen -----------------------------------------------
817 
818  friend INLINE l_interval::l_interval(const l_ivector &)
819 #if(CXSC_INDEX_CHECK)
820 ;
821 #else
822  noexcept;
823 #endif
824  friend INLINE int Lb(const l_ivector &rv) noexcept { return rv.l; }
827  friend INLINE int Ub(const l_ivector &rv) noexcept { return rv.u; }
829  friend INLINE int VecLen(const l_ivector &rv) noexcept { return rv.size; }
831  friend INLINE l_ivector & SetLb(l_ivector &rv, const int &l) noexcept { rv.l=l; rv.u=l+rv.size-1; return rv;}
833  friend INLINE l_ivector & SetUb(l_ivector &rv, const int &u) noexcept { rv.u=u; rv.l=u-rv.size+1; return rv;}
835  INLINE l_interval & operator [](const int &i) const
836 #if(CXSC_INDEX_CHECK)
837 ;
838 #else
839  noexcept;
840 #endif
841  INLINE l_ivector & operator ()() noexcept { return *this; }
844  INLINE l_ivector_slice operator ()(const int &i)
845 #if(CXSC_INDEX_CHECK)
846 ;
847 #else
848  noexcept;
849 #endif
850  INLINE l_ivector_slice operator ()(const int &i1,const int &i2)
852 #if(CXSC_INDEX_CHECK)
853 ;
854 #else
855  noexcept;
856 #endif
857 
858  INLINE operator void*() noexcept;
859 //#else
860 //#endif
861 };
862 
863 
865 
871 {
872  friend class l_ivector;
873  friend class l_imatrix;
874  private:
875  l_interval *dat;
876  int l,u,size;
877  int start,end;
878 
879  public:
880 //#if(CXSC_INDEX_CHECK)
881 #ifdef _CXSC_FRIEND_TPL
882 //------------------------- Templates -------------------------------------------
883 // l_interval / l_interval
884 
885  template <class VS1,class VS2> friend VS1 & _vsvsassign(VS1 &sl1,const VS2 &sl2)
886 #if(CXSC_INDEX_CHECK)
887  ;
888 #else
889  noexcept;
890 #endif
891  template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) noexcept;
892  template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv)
893 #if(CXSC_INDEX_CHECK)
894  ;
895 #else
896  noexcept;
897 #endif
898  template <class VS,class S> friend VS & _vssassign(VS &sl,const S &r) noexcept;
899  template <class VS,class V> friend VS &_vsvsetinf(VS &sl, const V &rv)
900 #if(CXSC_INDEX_CHECK)
901  ;
902 #else
903  noexcept;
904 #endif
905  template <class VS,class V> friend VS &_vsvsetsup(VS &sl, const V &rv)
906 #if(CXSC_INDEX_CHECK)
907  ;
908 #else
909  noexcept;
910 #endif
911  template <class VS1,class VS2> friend VS1 &_vsvssetinf(VS1 &sl1, const VS2 &sl2)
912 #if(CXSC_INDEX_CHECK)
913  ;
914 #else
915  noexcept;
916 #endif
917  template <class VS1,class VS2> friend VS1 &_vsvssetsup(VS1 &sl1, const VS2 &sl2)
918 #if(CXSC_INDEX_CHECK)
919  ;
920 #else
921  noexcept;
922 #endif
923  template <class VS,class V> friend VS &_vsvusetinf(VS &sl, const V &rv)
924 #if(CXSC_INDEX_CHECK)
925  ;
926 #else
927  noexcept;
928 #endif
929  template <class VS,class V> friend VS &_vsvusetsup(VS &sl, const V &rv)
930 #if(CXSC_INDEX_CHECK)
931  ;
932 #else
933  noexcept;
934 #endif
935  template <class VS1,class VS2> friend VS1 &_vsvsusetinf(VS1 &sl1, const VS2 &sl2)
936 #if(CXSC_INDEX_CHECK)
937  ;
938 #else
939  noexcept;
940 #endif
941  template <class VS1,class VS2> friend VS1 &_vsvsusetsup(VS1 &sl1, const VS2 &sl2)
942 #if(CXSC_INDEX_CHECK)
943  ;
944 #else
945  noexcept;
946 #endif
947 
948  template <class VS,class E> friend E _vsabs(const VS &sl) noexcept;
949  template <class VS,class E> friend E _vsdiam(const VS &sl) noexcept;
950  template <class VS,class E> friend E _vsmid(const VS &sl) noexcept;
951  template <class VS,class E> friend E _vsinf(const VS &sl) noexcept;
952  template <class VS,class E> friend E _vssup(const VS &sl) noexcept;
953  template <class VS,class S> friend VS &_vsssetinf(VS &vs, const S &s) noexcept;
954  template <class VS,class S> friend VS &_vsssetsup(VS &vs, const S &s) noexcept;
955  template <class VS,class S> friend VS &_vssusetinf(VS &vs, const S &s) noexcept;
956  template <class VS,class S> friend VS &_vssusetsup(VS &vs, const S &s) noexcept;
957 
958  template <class DP,class VS,class V> friend void _vsvaccu(DP &dp, const VS & sl, const V &rv)
959 #if(CXSC_INDEX_CHECK)
960  ;
961 #else
962  noexcept;
963 #endif
964  template <class DP,class VS1,class VS2> friend void _vsvsaccu(DP &dp, const VS1 & sl1, const VS2 &sl2)
965 #if(CXSC_INDEX_CHECK)
966  ;
967 #else
968  noexcept;
969 #endif
970 
971  template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) noexcept;
972  template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) noexcept;
973  template <class VS,class V,class E> friend E _vsvlimult(const VS & sl, const V &rv)
974 #if(CXSC_INDEX_CHECK)
975  ;
976 #else
977  noexcept;
978 #endif
979  template <class VS,class S> friend VS &_vssmultassign(VS &rv,const S &r) noexcept;
980  template <class VS,class S> friend VS &_vssdivassign(VS &rv,const S &r) noexcept;
981  template <class V,class VS,class E> friend E _vvsplus(const V &rv,const VS &sl)
982 #if(CXSC_INDEX_CHECK)
983  ;
984 #else
985  noexcept;
986 #endif
987  template <class VS1,class VS2,class E> friend E _vsvsplus(const VS1 &s1,const VS2 &s2)
988 #if(CXSC_INDEX_CHECK)
989  ;
990 #else
991  noexcept;
992 #endif
993  template <class VS1,class VS2,class E> friend E _vsvsminus(const VS1 &s1,const VS2 &s2)
994 #if(CXSC_INDEX_CHECK)
995  ;
996 #else
997  noexcept;
998 #endif
999  template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl)
1000 #if(CXSC_INDEX_CHECK)
1001  ;
1002 #else
1003  noexcept;
1004 #endif
1005  template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv)
1006 #if(CXSC_INDEX_CHECK)
1007  ;
1008 #else
1009  noexcept;
1010 #endif
1011  template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
1012 #if(CXSC_INDEX_CHECK)
1013  ;
1014 #else
1015  noexcept;
1016 #endif
1017  template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
1018 #if(CXSC_INDEX_CHECK)
1019  ;
1020 #else
1021  noexcept;
1022 #endif
1023  template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl)
1024 #if(CXSC_INDEX_CHECK)
1025  ;
1026 #else
1027  noexcept;
1028 #endif
1029  template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv)
1030 #if(CXSC_INDEX_CHECK)
1031  ;
1032 #else
1033  noexcept;
1034 #endif
1035  template <class VS,class V> friend V _vsminus(const VS &sl) noexcept;
1036  template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl)
1037 #if(CXSC_INDEX_CHECK)
1038  ;
1039 #else
1040  noexcept;
1041 #endif
1042  template <class VS,class V,class E> friend E _vsvminus(const VS &sl,const V &rv)
1043 #if(CXSC_INDEX_CHECK)
1044  ;
1045 #else
1046  noexcept;
1047 #endif
1048  template <class V,class VS,class E> friend E _vvssect(const V &rv,const VS &sl)
1049 #if(CXSC_INDEX_CHECK)
1050  ;
1051 #else
1052  noexcept;
1053 #endif
1054  template <class VS1,class VS2,class E> friend E _vsvssect(const VS1 &s1,const VS2 &s2)
1055 #if(CXSC_INDEX_CHECK)
1056  ;
1057 #else
1058  noexcept;
1059 #endif
1060  template <class V,class VS> friend V &_vvssectassign(V &rv, const VS &sl)
1061 #if(CXSC_INDEX_CHECK)
1062  ;
1063 #else
1064  noexcept;
1065 #endif
1066  template <class VS,class V> friend VS &_vsvsectassign(VS &sl, const V &rv)
1067 #if(CXSC_INDEX_CHECK)
1068  ;
1069 #else
1070  noexcept;
1071 #endif
1072  template <class VS1,class VS2> friend VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2)
1073 #if(CXSC_INDEX_CHECK)
1074  ;
1075 #else
1076  noexcept;
1077 #endif
1078  template <class V,class VS,class E> friend E _vvsconv(const V &rv,const VS &sl)
1079 #if(CXSC_INDEX_CHECK)
1080  ;
1081 #else
1082  noexcept;
1083 #endif
1084  template <class VS1,class VS2,class E> friend E _vsvsconv(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 &_vvsconvassign(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 &_vsvconvassign(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 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2)
1103 #if(CXSC_INDEX_CHECK)
1104  ;
1105 #else
1106  noexcept;
1107 #endif
1108  template <class VS,class M,class S> friend VS &_vsmlimultassign(VS &v,const M &m)
1109 #if(CXSC_INDEX_CHECK)
1110  ;
1111 #else
1112  noexcept;
1113 #endif
1114 
1115  template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) noexcept;
1116  template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) noexcept;
1117  template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) noexcept;
1118  template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) noexcept;
1119  template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) noexcept;
1120  template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) noexcept;
1121  template <class VS1,class VS2,class E> friend E _vsvslimult(const VS1 & sl1, const VS2 &sl2)
1122 #if(CXSC_INDEX_CHECK)
1123  ;
1124 #else
1125  noexcept;
1126 #endif
1127  template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) noexcept;
1128  template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) noexcept;
1129  template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) noexcept;
1130  template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) noexcept;
1131  template <class VS> friend bool _vsnot(const VS &sl) noexcept;
1132  template <class VS> friend void *_vsvoid(const VS &sl) noexcept;
1133  template <class V> friend std::ostream &_vsout(std::ostream &s, const V &rv) noexcept;
1134  template <class V> friend std::istream &_vsin(std::istream &s, V &rv) noexcept;
1135 
1136  // l_interval / Real
1137  template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms)
1138 #if(CXSC_INDEX_CHECK)
1139  ;
1140 #else
1141  noexcept;
1142 #endif
1143  // l_interval / l_real
1144  template <class DP,class V1,class V2> friend void _vvaccu(DP &dp, const V1 & rv1, const V2 &rv2)
1145 #if(CXSC_INDEX_CHECK)
1146  ;
1147 #else
1148  noexcept;
1149 #endif
1150 
1151  // l_real
1152  template <class V1,class V2,class S> friend V1 &_vvassign(V1 &rv1,const V2 &rv2) noexcept;
1153  template <class V,class S> friend V & _vsassign(V &rv,const S &r) noexcept;
1154 
1155 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m)
1156 #if(CXSC_INDEX_CHECK)
1157 ;
1158 #else
1159  noexcept;
1160 #endif
1161 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) noexcept;
1162 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) noexcept;
1163 
1164  template <class V1,class V2,class E> friend E _vvconv(const V1 &rv1, const V2 &rv2)
1165 #if(CXSC_INDEX_CHECK)
1166  ;
1167 #else
1168  noexcept;
1169 #endif
1170 
1171  //--l_real -------- vector-scalar ------------
1172  template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) noexcept;
1173  template <class V,class S,class E> friend E _vsmult(const V &rv, const S &s) noexcept;
1174  template <class V,class S,class E> friend E _vsdiv(const V &rv, const S &s) noexcept;
1175  template <class V,class S> friend V &_vsdivassign(V &rv,const S &r) noexcept;
1176  template <class V,class S> friend V &_vsmultassign(V &rv,const S &r) noexcept;
1177 
1178  //--l_real--------- Vector-vector---------
1179  template <class V1,class V2,class E> friend E _vvlimult(const V1 & rv1, const V2 &rv2)
1180 #if(CXSC_INDEX_CHECK)
1181  ;
1182 #else
1183  noexcept;
1184 #endif
1185  template <class V1,class V2,class E> friend E _vvplus(const V1 &rv1, const V2 &rv2)
1186 #if(CXSC_INDEX_CHECK)
1187  ;
1188 #else
1189  noexcept;
1190 #endif
1191  template <class V1,class V2> friend V1 &_vvplusassign(V1 &rv1, const V2 &rv2)
1192 #if(CXSC_INDEX_CHECK)
1193  ;
1194 #else
1195  noexcept;
1196 #endif
1197  template <class V1,class V2> friend V1 &_vvminusassign(V1 &rv1, const V2 &rv2)
1198 #if(CXSC_INDEX_CHECK)
1199  ;
1200 #else
1201  noexcept;
1202 #endif
1203  template <class V1,class V2,class E> friend E _vvminus(const V1 &rv1, const V2 &rv2)
1204 #if(CXSC_INDEX_CHECK)
1205  ;
1206 #else
1207  noexcept;
1208 #endif
1209  template <class V1,class V2> friend V1 &_vvconvassign(V1 &rv1, const V2 &rv2)
1210 #if(CXSC_INDEX_CHECK)
1211  ;
1212 #else
1213  noexcept;
1214 #endif
1215  template <class V1,class V2,class E> friend E _vvsect(const V1 &rv1, const V2 &rv2)
1216 #if(CXSC_INDEX_CHECK)
1217  ;
1218 #else
1219  noexcept;
1220 #endif
1221  template <class V1,class V2> friend V1 &_vvsectassign(V1 &rv1, const V2 &rv2)
1222 #if(CXSC_INDEX_CHECK)
1223  ;
1224 #else
1225  noexcept;
1226 #endif
1227 
1228  //-- l_real -------- Vector-matrix ----------
1229 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m)
1230 #if(CXSC_INDEX_CHECK)
1231 ;
1232 #else
1233  noexcept;
1234 #endif
1235 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
1236 #if(CXSC_INDEX_CHECK)
1237 ;
1238 #else
1239  noexcept;
1240 #endif
1241  template <class M,class V,class E> friend E _mvlimult(const M &m,const V &v)
1242 #if(CXSC_INDEX_CHECK)
1243  ;
1244 #else
1245  noexcept;
1246 #endif
1247  template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v)
1248 #if(CXSC_INDEX_CHECK)
1249  ;
1250 #else
1251  noexcept;
1252 #endif
1253  template <class V,class M,class E> friend E _vmlimult(const V &v,const M &m)
1254 #if(CXSC_INDEX_CHECK)
1255  ;
1256 #else
1257  noexcept;
1258 #endif
1259  template <class V,class MS,class S> friend V &_vmslimultassign(V &v,const MS &ms)
1260 #if(CXSC_INDEX_CHECK)
1261  ;
1262 #else
1263  noexcept;
1264 #endif
1265  template <class V,class M,class S> friend V &_vmlimultassign(V &v,const M &m)
1266 #if(CXSC_INDEX_CHECK)
1267  ;
1268 #else
1269  noexcept;
1270 #endif
1271 
1272  /* friend TINLINE l_ivector &_vsmassign<l_ivector_slice,imatrix,l_interval>(l_ivector_slice &v,const imatrix &m)
1273 #if(CXSC_INDEX_CHECK)
1274 ;
1275 #else
1276  noexcept;
1277  #endif */
1278 
1279  //-- interval -------- Vector-matrix ----------
1280  /* friend TINLINE l_ivector _mvslimult<imatrix,l_ivector_slice,l_ivector>(const imatrix &m,const l_ivector_slice &v)
1281 #if(CXSC_INDEX_CHECK)
1282 ;
1283 #else
1284  noexcept;
1285  #endif */
1286  /* friend TINLINE l_ivector _msvslimult<imatrix_slice,l_ivector_slice,l_ivector>(const imatrix_slice &ms,const l_ivector_slice &v)
1287 #if(CXSC_INDEX_CHECK)
1288 ;
1289 #else
1290  noexcept;
1291  #endif */
1292  /* friend TINLINE l_ivector _vsmlimult<l_ivector_slice,imatrix,l_ivector>(const l_ivector_slice &v,const imatrix &m)
1293 #if(CXSC_INDEX_CHECK)
1294 ;
1295 #else
1296  noexcept;
1297  #endif */
1298  /* friend TINLINE l_ivector _vsmslimult<l_ivector_slice,imatrix_slice,l_ivector>(const l_ivector_slice &v,const imatrix_slice &ms)
1299 #if(CXSC_INDEX_CHECK)
1300 ;
1301 #else
1302  noexcept;
1303  #endif */
1304  /* friend TINLINE l_ivector &_vsmslimultassign<l_ivector_slice,imatrix_slice,l_interval>(l_ivector_slice &v,const imatrix_slice &m)
1305 #if(CXSC_INDEX_CHECK)
1306 ;
1307 #else
1308  noexcept;
1309  #endif */
1310 
1311 #endif
1312 
1313  //--------------------- Konstruktoren -----------------------------------
1315  explicit INLINE l_ivector_slice(l_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) { }
1317  explicit INLINE l_ivector_slice(l_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) { }
1318  public:
1320  INLINE l_ivector_slice(const l_ivector_slice &a) noexcept:dat(a.dat),l(a.l),u(a.u),size(a.size),start(a.start),end(a.end) { }
1321  public:
1322  // l_interval
1324  INLINE l_ivector_slice & operator =(const l_ivector_slice &sl)
1325 #if(CXSC_INDEX_CHECK)
1326 ;
1327 #else
1328  noexcept;
1329 #endif
1330  INLINE l_ivector_slice & operator =(const l_ivector &rv)
1332 #if(CXSC_INDEX_CHECK)
1333 ;
1334 #else
1335  noexcept;
1336 #endif
1337  INLINE l_ivector_slice & operator =(const l_interval &r) noexcept;
1340  INLINE l_ivector_slice & operator =(const l_imatrix &m)
1341 #if(CXSC_INDEX_CHECK)
1342 ;
1343 #else
1344  noexcept;
1345 #endif
1346  INLINE l_ivector_slice & operator =(const l_imatrix_slice &m)
1348 #if(CXSC_INDEX_CHECK)
1349 ;
1350 #else
1351  noexcept;
1352 #endif
1353  INLINE l_ivector_slice &operator =(const l_imatrix_subv &) noexcept;
1355  // Real
1357  INLINE l_ivector_slice & operator =(const rvector_slice &sl)
1358 #if(CXSC_INDEX_CHECK)
1359 ;
1360 #else
1361  noexcept;
1362 #endif
1363  INLINE l_ivector_slice & operator =(const rvector &rv)
1365 #if(CXSC_INDEX_CHECK)
1366 ;
1367 #else
1368  noexcept;
1369 #endif
1370  INLINE l_ivector_slice & operator =(const real &r) noexcept;
1373  INLINE l_ivector_slice & operator =(const rmatrix &m)
1374 #if(CXSC_INDEX_CHECK)
1375 ;
1376 #else
1377  noexcept;
1378 #endif
1379  INLINE l_ivector_slice & operator =(const rmatrix_slice &m)
1381 #if(CXSC_INDEX_CHECK)
1382 ;
1383 #else
1384  noexcept;
1385 #endif
1386  INLINE l_ivector_slice &operator =(const rmatrix_subv &mv) noexcept;
1388 
1389  // l_real
1391  INLINE l_ivector_slice & operator =(const l_rvector_slice &sl)
1392 #if(CXSC_INDEX_CHECK)
1393 ;
1394 #else
1395  noexcept;
1396 #endif
1397  INLINE l_ivector_slice & operator =(const l_rvector &rv)
1399 #if(CXSC_INDEX_CHECK)
1400 ;
1401 #else
1402  noexcept;
1403 #endif
1404  INLINE l_ivector_slice & operator =(const l_real &r) noexcept;
1407  INLINE l_ivector_slice & operator =(const l_rmatrix &m)
1408 #if(CXSC_INDEX_CHECK)
1409 ;
1410 #else
1411  noexcept;
1412 #endif
1413  INLINE l_ivector_slice & operator =(const l_rmatrix_slice &m)
1415 #if(CXSC_INDEX_CHECK)
1416 ;
1417 #else
1418  noexcept;
1419 #endif
1420  INLINE l_ivector_slice &operator =(const l_rmatrix_subv &mv) noexcept;
1422 
1423  // interval
1425  INLINE l_ivector_slice & operator =(const ivector_slice &sl)
1426 #if(CXSC_INDEX_CHECK)
1427 ;
1428 #else
1429  noexcept;
1430 #endif
1431  INLINE l_ivector_slice & operator =(const ivector &rv)
1433 #if(CXSC_INDEX_CHECK)
1434 ;
1435 #else
1436  noexcept;
1437 #endif
1438  INLINE l_ivector_slice & operator =(const interval &r) noexcept;
1441  INLINE l_ivector_slice & operator =(const imatrix &m)
1442 #if(CXSC_INDEX_CHECK)
1443 ;
1444 #else
1445  noexcept;
1446 #endif
1447  INLINE l_ivector_slice & operator =(const imatrix_slice &m)
1449 #if(CXSC_INDEX_CHECK)
1450 ;
1451 #else
1452  noexcept;
1453 #endif
1454  INLINE l_ivector_slice &operator =(const imatrix_subv &mv) noexcept;
1456 
1457  //--------------------- Standardfunktionen ------------------------------
1458 
1459  friend INLINE l_interval::l_interval(const l_ivector_slice &sl)
1460 #if(CXSC_INDEX_CHECK)
1461 ;
1462 #else
1463  noexcept;
1464 #endif
1465  friend INLINE int Lb(const l_ivector_slice &sl) noexcept { return sl.start; }
1468  friend INLINE int Ub(const l_ivector_slice &sl) noexcept { return sl.end; }
1470  friend INLINE int VecLen(const l_ivector_slice &sl) noexcept { return sl.end-sl.start+1; }
1472  INLINE l_interval & operator [](const int &i) const
1473 #if(CXSC_INDEX_CHECK)
1474 ;
1475 #else
1476  noexcept;
1477 #endif
1478  INLINE l_ivector_slice & operator ()() noexcept { return *this; }
1481  INLINE l_ivector_slice operator ()(const int &i)
1482 #if(CXSC_INDEX_CHECK)
1483 ;
1484 #else
1485  noexcept;
1486 #endif
1487  INLINE l_ivector_slice operator ()(const int &i1,const int &i2)
1489 #if(CXSC_INDEX_CHECK)
1490 ;
1491 #else
1492  noexcept;
1493 #endif
1494  INLINE operator void*() noexcept;
1495 
1497  INLINE l_ivector_slice &operator *=(const l_interval &r) noexcept;
1499  INLINE l_ivector_slice &operator /=(const l_interval &r) noexcept;
1501  INLINE l_ivector_slice &operator *=(const l_imatrix &m)
1502 #if(CXSC_INDEX_CHECK)
1503 ;
1504 #else
1505  noexcept;
1506 #endif
1507  INLINE l_ivector_slice &operator *=(const l_imatrix_slice &m)
1509 #if(CXSC_INDEX_CHECK)
1510 ;
1511 #else
1512  noexcept;
1513 #endif
1514  INLINE l_ivector_slice &operator +=(const l_ivector &rv)
1516 #if(CXSC_INDEX_CHECK)
1517 ;
1518 #else
1519  noexcept;
1520 #endif
1521  INLINE l_ivector_slice &operator +=(const l_ivector_slice &sl2)
1523 #if(CXSC_INDEX_CHECK)
1524 ;
1525 #else
1526  noexcept;
1527 #endif
1528  INLINE l_ivector_slice &operator -=(const l_ivector &rv)
1530 #if(CXSC_INDEX_CHECK)
1531 ;
1532 #else
1533  noexcept;
1534 #endif
1535  INLINE l_ivector_slice &operator -=(const l_ivector_slice &sl2)
1537 #if(CXSC_INDEX_CHECK)
1538 ;
1539 #else
1540  noexcept;
1541 #endif
1542  INLINE l_ivector_slice &operator |=(const l_ivector &rv)
1544 #if(CXSC_INDEX_CHECK)
1545 ;
1546 #else
1547  noexcept;
1548 #endif
1549  INLINE l_ivector_slice &operator |=(const l_ivector_slice &sl2)
1551 #if(CXSC_INDEX_CHECK)
1552 ;
1553 #else
1554  noexcept;
1555 #endif
1556  INLINE l_ivector_slice &operator &=(const l_ivector &rv)
1558 #if(CXSC_INDEX_CHECK)
1559 ;
1560 #else
1561  noexcept;
1562 #endif
1563  INLINE l_ivector_slice &operator &=(const l_ivector_slice &sl2)
1565 #if(CXSC_INDEX_CHECK)
1566 ;
1567 #else
1568  noexcept;
1569 #endif
1570 
1572  INLINE l_ivector_slice &operator *=(const real &r) noexcept;
1574  INLINE l_ivector_slice &operator /=(const real &r) noexcept;
1576  INLINE l_ivector_slice &operator +=(const rvector &rv)
1577 #if(CXSC_INDEX_CHECK)
1578 ;
1579 #else
1580  noexcept;
1581 #endif
1582  INLINE l_ivector_slice &operator +=(const rvector_slice &sl2)
1584 #if(CXSC_INDEX_CHECK)
1585 ;
1586 #else
1587  noexcept;
1588 #endif
1589  INLINE l_ivector_slice &operator -=(const rvector &rv)
1591 #if(CXSC_INDEX_CHECK)
1592 ;
1593 #else
1594  noexcept;
1595 #endif
1596  INLINE l_ivector_slice &operator -=(const rvector_slice &sl2)
1598 #if(CXSC_INDEX_CHECK)
1599 ;
1600 #else
1601  noexcept;
1602 #endif
1603  INLINE l_ivector_slice &operator |=(const rvector &rv)
1605 #if(CXSC_INDEX_CHECK)
1606 ;
1607 #else
1608  noexcept;
1609 #endif
1610  INLINE l_ivector_slice &operator |=(const rvector_slice &sl2)
1612 #if(CXSC_INDEX_CHECK)
1613 ;
1614 #else
1615  noexcept;
1616 #endif
1617  INLINE l_ivector_slice &operator &=(const rvector &rv)
1619 #if(CXSC_INDEX_CHECK)
1620 ;
1621 #else
1622  noexcept;
1623 #endif
1624  INLINE l_ivector_slice &operator &=(const rvector_slice &sl2)
1626 #if(CXSC_INDEX_CHECK)
1627 ;
1628 #else
1629  noexcept;
1630 #endif
1631  INLINE l_ivector_slice &operator *=(const rmatrix &m)
1633 #if(CXSC_INDEX_CHECK)
1634 ;
1635 #else
1636  noexcept;
1637 #endif
1638  INLINE l_ivector_slice &operator *=(const rmatrix_slice &m)
1640 #if(CXSC_INDEX_CHECK)
1641 ;
1642 #else
1643  noexcept;
1644 #endif
1645 
1647  INLINE l_ivector_slice &operator *=(const l_real &r) noexcept;
1649  INLINE l_ivector_slice &operator /=(const l_real &r) noexcept;
1651  INLINE l_ivector_slice &operator +=(const l_rvector &rv)
1652 #if(CXSC_INDEX_CHECK)
1653 ;
1654 #else
1655  noexcept;
1656 #endif
1657  INLINE l_ivector_slice &operator +=(const l_rvector_slice &sl2)
1659 #if(CXSC_INDEX_CHECK)
1660 ;
1661 #else
1662  noexcept;
1663 #endif
1664  INLINE l_ivector_slice &operator -=(const l_rvector &rv)
1666 #if(CXSC_INDEX_CHECK)
1667 ;
1668 #else
1669  noexcept;
1670 #endif
1671  INLINE l_ivector_slice &operator -=(const l_rvector_slice &sl2)
1673 #if(CXSC_INDEX_CHECK)
1674 ;
1675 #else
1676  noexcept;
1677 #endif
1678  INLINE l_ivector_slice &operator |=(const l_rvector &rv)
1680 #if(CXSC_INDEX_CHECK)
1681 ;
1682 #else
1683  noexcept;
1684 #endif
1685  INLINE l_ivector_slice &operator |=(const l_rvector_slice &sl2)
1687 #if(CXSC_INDEX_CHECK)
1688 ;
1689 #else
1690  noexcept;
1691 #endif
1692  INLINE l_ivector_slice &operator &=(const l_rvector &rv)
1694 #if(CXSC_INDEX_CHECK)
1695 ;
1696 #else
1697  noexcept;
1698 #endif
1699  INLINE l_ivector_slice &operator &=(const l_rvector_slice &sl2)
1701 #if(CXSC_INDEX_CHECK)
1702 ;
1703 #else
1704  noexcept;
1705 #endif
1706  INLINE l_ivector_slice &operator *=(const l_rmatrix &m)
1708 #if(CXSC_INDEX_CHECK)
1709 ;
1710 #else
1711  noexcept;
1712 #endif
1713  INLINE l_ivector_slice &operator *=(const l_rmatrix_slice &m)
1715 #if(CXSC_INDEX_CHECK)
1716 ;
1717 #else
1718  noexcept;
1719 #endif
1720 
1722  INLINE l_ivector_slice &operator *=(const interval &r) noexcept;
1724  INLINE l_ivector_slice &operator /=(const interval &r) noexcept;
1726  INLINE l_ivector_slice &operator +=(const ivector &rv)
1727 #if(CXSC_INDEX_CHECK)
1728 ;
1729 #else
1730  noexcept;
1731 #endif
1732  INLINE l_ivector_slice &operator +=(const ivector_slice &sl2)
1734 #if(CXSC_INDEX_CHECK)
1735 ;
1736 #else
1737  noexcept;
1738 #endif
1739  INLINE l_ivector_slice &operator -=(const ivector &rv)
1741 #if(CXSC_INDEX_CHECK)
1742 ;
1743 #else
1744  noexcept;
1745 #endif
1746  INLINE l_ivector_slice &operator -=(const ivector_slice &sl2)
1748 #if(CXSC_INDEX_CHECK)
1749 ;
1750 #else
1751  noexcept;
1752 #endif
1753  INLINE l_ivector_slice &operator |=(const ivector &rv)
1755 #if(CXSC_INDEX_CHECK)
1756 ;
1757 #else
1758  noexcept;
1759 #endif
1760  INLINE l_ivector_slice &operator |=(const ivector_slice &sl2)
1762 #if(CXSC_INDEX_CHECK)
1763 ;
1764 #else
1765  noexcept;
1766 #endif
1767  INLINE l_ivector_slice &operator &=(const ivector &rv)
1769 #if(CXSC_INDEX_CHECK)
1770 ;
1771 #else
1772  noexcept;
1773 #endif
1774  INLINE l_ivector_slice &operator &=(const ivector_slice &sl2)
1776 #if(CXSC_INDEX_CHECK)
1777 ;
1778 #else
1779  noexcept;
1780 #endif
1781  INLINE l_ivector_slice &operator *=(const imatrix &m)
1783 #if(CXSC_INDEX_CHECK)
1784 ;
1785 #else
1786  noexcept;
1787 #endif
1788  INLINE l_ivector_slice &operator *=(const imatrix_slice &m)
1790 #if(CXSC_INDEX_CHECK)
1791 ;
1792 #else
1793  noexcept;
1794 #endif
1795 //#else
1796 //#endif
1797 };
1798 
1799 //=======================================================================
1800 //======================== Vector Functions =============================
1801 
1803  INLINE l_ivector _l_ivector(const l_interval &r) noexcept;
1804 // INLINE l_ivector _l_ivector(const l_imatrix &m);
1805 // INLINE l_ivector _l_ivector(const l_imatrix_slice &sl);
1807  INLINE l_ivector _l_ivector(const real &r) noexcept;
1809  INLINE l_ivector _l_ivector(const rvector_slice &rs) noexcept;
1811  INLINE l_ivector _l_ivector(const rvector &rs) noexcept;
1812 // INLINE l_ivector _l_ivector(const rmatrix &m);
1813 // INLINE l_ivector _l_ivector(const rmatrix_slice &sl);
1815  INLINE l_ivector _l_ivector(const rmatrix_subv &rs) noexcept;
1816 
1818  INLINE l_ivector &SetInf(l_ivector &iv,const l_rvector &rv)
1819 #if(CXSC_INDEX_CHECK)
1820 ;
1821 #else
1822  noexcept;
1823 #endif
1824  INLINE l_ivector_slice &SetInf(l_ivector_slice &iv,const l_rvector &rv)
1826 #if(CXSC_INDEX_CHECK)
1827 ;
1828 #else
1829  noexcept;
1830 #endif
1831  INLINE l_ivector &SetInf(l_ivector &iv,const l_rvector_slice &rv)
1833 #if(CXSC_INDEX_CHECK)
1834 ;
1835 #else
1836  noexcept;
1837 #endif
1838  INLINE l_ivector_slice &SetInf(l_ivector_slice &iv,const l_rvector_slice &rv)
1840 #if(CXSC_INDEX_CHECK)
1841 ;
1842 #else
1843  noexcept;
1844 #endif
1845  INLINE l_ivector &UncheckedSetInf(l_ivector &iv,const l_rvector &rv)
1847 #if(CXSC_INDEX_CHECK)
1848 ;
1849 #else
1850  noexcept;
1851 #endif
1852  INLINE l_ivector_slice &UncheckedSetInf(l_ivector_slice &iv,const l_rvector &rv)
1854 #if(CXSC_INDEX_CHECK)
1855 ;
1856 #else
1857  noexcept;
1858 #endif
1859  INLINE l_ivector &UncheckedSetInf(l_ivector &iv,const l_rvector_slice &rv)
1861 #if(CXSC_INDEX_CHECK)
1862 ;
1863 #else
1864  noexcept;
1865 #endif
1866  INLINE l_ivector_slice &UncheckedSetInf(l_ivector_slice &iv,const l_rvector_slice &rv)
1868 #if(CXSC_INDEX_CHECK)
1869 ;
1870 #else
1871  noexcept;
1872 #endif
1873 
1875  INLINE l_ivector &SetSup(l_ivector &iv,const l_rvector &rv)
1876 #if(CXSC_INDEX_CHECK)
1877 ;
1878 #else
1879  noexcept;
1880 #endif
1881  INLINE l_ivector_slice &SetSup(l_ivector_slice &iv,const l_rvector &rv)
1883 #if(CXSC_INDEX_CHECK)
1884 ;
1885 #else
1886  noexcept;
1887 #endif
1888  INLINE l_ivector &SetSup(l_ivector &iv,const l_rvector_slice &rv)
1890 #if(CXSC_INDEX_CHECK)
1891 ;
1892 #else
1893  noexcept;
1894 #endif
1895  INLINE l_ivector_slice &SetSup(l_ivector_slice &iv,const l_rvector_slice &rv)
1897 #if(CXSC_INDEX_CHECK)
1898 ;
1899 #else
1900  noexcept;
1901 #endif
1902  INLINE l_ivector &UncheckedSetSup(l_ivector &iv,const l_rvector &rv)
1904 #if(CXSC_INDEX_CHECK)
1905 ;
1906 #else
1907  noexcept;
1908 #endif
1909  INLINE l_ivector_slice &UncheckedSetSup(l_ivector_slice &iv,const l_rvector &rv)
1911 #if(CXSC_INDEX_CHECK)
1912 ;
1913 #else
1914  noexcept;
1915 #endif
1916  INLINE l_ivector &UncheckedSetSup(l_ivector &iv,const l_rvector_slice &rv)
1918 #if(CXSC_INDEX_CHECK)
1919 ;
1920 #else
1921  noexcept;
1922 #endif
1923  INLINE l_ivector_slice &UncheckedSetSup(l_ivector_slice &iv,const l_rvector_slice &rv)
1925 #if(CXSC_INDEX_CHECK)
1926 ;
1927 #else
1928  noexcept;
1929 #endif
1930 
1932  INLINE l_ivector &SetSup(l_ivector &iv,const l_real &r) noexcept;
1934  INLINE l_ivector &SetInf(l_ivector &iv,const l_real &r) noexcept;
1936  INLINE l_ivector &UncheckedSetSup(l_ivector &iv,const l_real &r) noexcept;
1938  INLINE l_ivector &SetUncheckedInf(l_ivector &iv,const l_real &r) noexcept;
1939 
1941  INLINE l_ivector_slice &SetSup(l_ivector_slice &iv,const l_real &r) noexcept;
1943  INLINE l_ivector_slice &SetInf(l_ivector_slice &iv,const l_real &r) noexcept;
1945  INLINE l_ivector_slice &UncheckedSetSup(l_ivector_slice &iv,const l_real &r) noexcept;
1947  INLINE l_ivector_slice &SetUncheckedInf(l_ivector_slice &iv,const l_real &r) noexcept;
1948 
1950  INLINE void Resize(l_ivector &rv) noexcept;
1952  INLINE void Resize(l_ivector &rv, const int &len)
1953 #if(CXSC_INDEX_CHECK)
1954 ;
1955 #else
1956  noexcept;
1957 #endif
1958  INLINE void Resize(l_ivector &rv, const int &lb, const int &ub)
1960 #if(CXSC_INDEX_CHECK)
1961 ;
1962 #else
1963  noexcept;
1964 #endif
1965 
1967  INLINE l_ivector abs(const l_ivector &rv) noexcept;
1969  INLINE l_ivector abs(const l_ivector_slice &sl) noexcept;
1971  INLINE l_rvector diam(const l_ivector &v) noexcept;
1973  INLINE l_rvector diam(const l_ivector_slice &v) noexcept;
1975  INLINE l_rvector mid(const l_ivector &v) noexcept;
1977  INLINE l_rvector mid(const l_ivector_slice &v) noexcept;
1979  INLINE l_rvector Inf(const l_ivector &v) noexcept;
1981  INLINE l_rvector Inf(const l_ivector_slice &v) noexcept;
1983  INLINE l_rvector Sup(const l_ivector &v) noexcept;
1985  INLINE l_rvector Sup(const l_ivector_slice &v) noexcept;
1987  INLINE bool operator !(const l_ivector &rv) noexcept;
1989  INLINE bool operator !(const l_ivector_slice &sl) noexcept;
1990 
1991 //======================= Vector / Scalar ===============================
1992 
1993 //----------------------------- l_interval ---------------------------
1994 
1996  INLINE l_ivector operator *(const l_ivector &rv, const l_interval &s) noexcept;
1998  INLINE l_ivector operator *(const l_ivector_slice &sl, const l_interval &s) noexcept;
2000  INLINE l_ivector operator *(const l_interval &s, const l_ivector &rv) noexcept;
2002  INLINE l_ivector operator *(const l_interval &s, const l_ivector_slice &sl) noexcept;
2004  INLINE l_ivector &operator *=(l_ivector &rv,const l_interval &r) noexcept;
2005 
2007  INLINE l_ivector operator /(const l_ivector &rv, const l_interval &s) noexcept;
2009  INLINE l_ivector operator /(const l_ivector_slice &sl, const l_interval &s) noexcept;
2011  INLINE l_ivector &operator /=(l_ivector &rv,const l_interval &r) noexcept;
2012 
2013 //---------------------------- Real --------------------------------------
2014 
2016  INLINE l_ivector operator *(const l_ivector &rv, const real &s) noexcept;
2018  INLINE l_ivector operator *(const l_ivector_slice &sl, const real &s) noexcept;
2020  INLINE l_ivector operator *(const real &s, const l_ivector &rv) noexcept;
2022  INLINE l_ivector operator *(const real &s, const l_ivector_slice &sl) noexcept;
2024  INLINE l_ivector &operator *=(l_ivector &rv,const real &r) noexcept;
2025 
2027  INLINE l_ivector operator /(const l_ivector &rv, const real &s) noexcept;
2029  INLINE l_ivector operator /(const l_ivector_slice &sl, const real &s) noexcept;
2031  INLINE l_ivector &operator /=(l_ivector &rv,const real &r) noexcept;
2032 
2034  INLINE l_ivector operator *(const rvector &rv, const l_interval &s) noexcept;
2036  INLINE l_ivector operator *(const rvector_slice &sl, const l_interval &s) noexcept;
2038  INLINE l_ivector operator *(const l_interval &s, const rvector &rv) noexcept;
2040  INLINE l_ivector operator *(const l_interval &s, const rvector_slice &sl) noexcept;
2041 
2043  INLINE l_ivector operator /(const rvector &rv, const l_interval &s) noexcept;
2045  INLINE l_ivector operator /(const rvector_slice &sl, const l_interval &s) noexcept;
2046 
2047 //---------------------------- Complex --------------------------------------
2048 
2050  INLINE l_ivector operator *(const l_ivector &rv, const l_real &s) noexcept;
2052  INLINE l_ivector operator *(const l_ivector_slice &sl, const l_real &s) noexcept;
2054  INLINE l_ivector operator *(const l_real &s, const l_ivector &rv) noexcept;
2056  INLINE l_ivector operator *(const l_real &s, const l_ivector_slice &sl) noexcept;
2058  INLINE l_ivector &operator *=(l_ivector &rv,const l_real &r) noexcept;
2059 
2061  INLINE l_ivector operator /(const l_ivector &rv, const l_real &s) noexcept;
2063  INLINE l_ivector operator /(const l_ivector_slice &sl, const l_real &s) noexcept;
2065  INLINE l_ivector &operator /=(l_ivector &rv,const l_real &r) noexcept;
2066 
2068  INLINE l_ivector operator *(const l_rvector &rv, const l_interval &s) noexcept;
2070  INLINE l_ivector operator *(const l_rvector_slice &sl, const l_interval &s) noexcept;
2072  INLINE l_ivector operator *(const l_interval &s, const l_rvector &rv) noexcept;
2074  INLINE l_ivector operator *(const l_interval &s, const l_rvector_slice &sl) noexcept;
2075 
2077  INLINE l_ivector operator /(const l_rvector &rv, const l_interval &s) noexcept;
2079  INLINE l_ivector operator /(const l_rvector_slice &sl, const l_interval &s) noexcept;
2080 
2081 //---------------------------- interval --------------------------------------
2082 
2084  INLINE l_ivector operator *(const l_ivector &rv, const interval &s) noexcept;
2086  INLINE l_ivector operator *(const l_ivector_slice &sl, const interval &s) noexcept;
2088  INLINE l_ivector operator *(const interval &s, const l_ivector &rv) noexcept;
2090  INLINE l_ivector operator *(const interval &s, const l_ivector_slice &sl) noexcept;
2092  INLINE l_ivector &operator *=(l_ivector &rv,const interval &r) noexcept;
2093 
2095  INLINE l_ivector operator /(const l_ivector &rv, const interval &s) noexcept;
2097  INLINE l_ivector operator /(const l_ivector_slice &sl, const interval &s) noexcept;
2099  INLINE l_ivector &operator /=(l_ivector &rv,const interval &r) noexcept;
2100 
2102  INLINE l_ivector operator *(const ivector &rv, const l_interval &s) noexcept;
2104  INLINE l_ivector operator *(const ivector_slice &sl, const l_interval &s) noexcept;
2106  INLINE l_ivector operator *(const l_interval &s, const ivector &rv) noexcept;
2108  INLINE l_ivector operator *(const l_interval &s, const ivector_slice &sl) noexcept;
2109 
2111  INLINE l_ivector operator /(const ivector &rv, const l_interval &s) noexcept;
2113  INLINE l_ivector operator /(const ivector_slice &sl, const l_interval &s) noexcept;
2114 
2115 //======================= Vector / Vector ===============================
2116 
2117 
2119  INLINE std::ostream &operator <<(std::ostream &s, const l_ivector &rv) noexcept;
2121  INLINE std::ostream &operator <<(std::ostream &o, const l_ivector_slice &sl) noexcept;
2123  INLINE std::istream &operator >>(std::istream &s, l_ivector &rv) noexcept;
2125  INLINE std::istream &operator >>(std::istream &s, l_ivector_slice &rv) noexcept;
2126 
2127 //----------------------- l_interval / l_interval ---------------------------
2128 
2130  INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const l_ivector &rv2)
2131 #if(CXSC_INDEX_CHECK)
2132 ;
2133 #else
2134  noexcept;
2135 #endif
2136  INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl, const l_ivector &rv)
2138 #if(CXSC_INDEX_CHECK)
2139 ;
2140 #else
2141  noexcept;
2142 #endif
2143  INLINE void accumulate(idotprecision &dp, const l_ivector &rv, const l_ivector_slice &sl)
2145 #if(CXSC_INDEX_CHECK)
2146 ;
2147 #else
2148  noexcept;
2149 #endif
2150  INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const l_imatrix_subv &rv2)
2152 #if(CXSC_INDEX_CHECK)
2153 ;
2154 #else
2155  noexcept;
2156 #endif
2157  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_ivector &rv2)
2159 #if(CXSC_INDEX_CHECK)
2160 ;
2161 #else
2162  noexcept;
2163 #endif
2164  INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl1, const l_ivector_slice &sl2)
2166 #if(CXSC_INDEX_CHECK)
2167 ;
2168 #else
2169  noexcept;
2170 #endif
2171 
2173  INLINE l_interval operator *(const l_ivector & rv1, const l_ivector &rv2)
2174 #if(CXSC_INDEX_CHECK)
2175 ;
2176 #else
2177  noexcept;
2178 #endif
2179  INLINE l_interval operator *(const l_ivector_slice &sl, const l_ivector &rv)
2181 #if(CXSC_INDEX_CHECK)
2182 ;
2183 #else
2184  noexcept;
2185 #endif
2186  INLINE l_interval operator *(const l_ivector &rv, const l_ivector_slice &sl)
2188 #if(CXSC_INDEX_CHECK)
2189 ;
2190 #else
2191  noexcept;
2192 #endif
2193  INLINE l_interval operator *(const l_ivector_slice & sl1, const l_ivector_slice &sl2)
2195 #if(CXSC_INDEX_CHECK)
2196 ;
2197 #else
2198  noexcept;
2199 #endif
2200 
2202  INLINE const l_ivector &operator +(const l_ivector &rv) noexcept;
2204  INLINE l_ivector operator +(const l_ivector_slice &sl) noexcept;
2205 
2207  INLINE l_ivector operator +(const l_ivector &rv1, const l_ivector &rv2)
2208 #if(CXSC_INDEX_CHECK)
2209 ;
2210 #else
2211  noexcept;
2212 #endif
2213  INLINE l_ivector operator +(const l_ivector &rv, const l_ivector_slice &sl)
2215 #if(CXSC_INDEX_CHECK)
2216 ;
2217 #else
2218  noexcept;
2219 #endif
2220  INLINE l_ivector operator +(const l_ivector_slice &sl, const l_ivector &rv)
2222 #if(CXSC_INDEX_CHECK)
2223 ;
2224 #else
2225  noexcept;
2226 #endif
2227  INLINE l_ivector operator +(const l_ivector_slice &sl1, const l_ivector_slice &sl2)
2229 #if(CXSC_INDEX_CHECK)
2230 ;
2231 #else
2232  noexcept;
2233 #endif
2234  INLINE l_ivector & operator +=(l_ivector &rv1, const l_ivector &rv2)
2236 #if(CXSC_INDEX_CHECK)
2237 ;
2238 #else
2239  noexcept;
2240 #endif
2241  INLINE l_ivector &operator +=(l_ivector &rv, const l_ivector_slice &sl)
2243 #if(CXSC_INDEX_CHECK)
2244 ;
2245 #else
2246  noexcept;
2247 #endif
2248 
2250  INLINE l_ivector operator -(const l_ivector &rv) noexcept;
2252  INLINE l_ivector operator -(const l_ivector_slice &sl) noexcept;
2254  INLINE l_ivector operator -(const l_ivector &rv1, const l_ivector &rv2)
2255 #if(CXSC_INDEX_CHECK)
2256 ;
2257 #else
2258  noexcept;
2259 #endif
2260  INLINE l_ivector operator -(const l_ivector &rv, const l_ivector_slice &sl)
2262 #if(CXSC_INDEX_CHECK)
2263 ;
2264 #else
2265  noexcept;
2266 #endif
2267  INLINE l_ivector operator -(const l_ivector_slice &sl, const l_ivector &rv)
2269 #if(CXSC_INDEX_CHECK)
2270 ;
2271 #else
2272  noexcept;
2273 #endif
2274  INLINE l_ivector operator -(const l_ivector_slice &sl1, const l_ivector_slice &sl2)
2276 #if(CXSC_INDEX_CHECK)
2277 ;
2278 #else
2279  noexcept;
2280 #endif
2281  INLINE l_ivector & operator -=(l_ivector &rv1, const l_ivector &rv2)
2283 #if(CXSC_INDEX_CHECK)
2284 ;
2285 #else
2286  noexcept;
2287 #endif
2288  INLINE l_ivector &operator -=(l_ivector &rv, const l_ivector_slice &sl)
2290 #if(CXSC_INDEX_CHECK)
2291 ;
2292 #else
2293  noexcept;
2294 #endif
2295 
2297  INLINE l_ivector operator |(const l_ivector &rv1, const l_ivector &rv2)
2298 #if(CXSC_INDEX_CHECK)
2299 ;
2300 #else
2301  noexcept;
2302 #endif
2303  INLINE l_ivector operator |(const l_ivector &rv, const l_ivector_slice &sl)
2305 #if(CXSC_INDEX_CHECK)
2306 ;
2307 #else
2308  noexcept;
2309 #endif
2310  INLINE l_ivector operator |(const l_ivector_slice &sl, const l_ivector &rv)
2312 #if(CXSC_INDEX_CHECK)
2313 ;
2314 #else
2315  noexcept;
2316 #endif
2317  INLINE l_ivector operator |(const l_ivector_slice &sl1, const l_ivector_slice &sl2)
2319 #if(CXSC_INDEX_CHECK)
2320 ;
2321 #else
2322  noexcept;
2323 #endif
2324  INLINE l_ivector & operator |=(l_ivector &rv1, const l_ivector &rv2)
2326 #if(CXSC_INDEX_CHECK)
2327 ;
2328 #else
2329  noexcept;
2330 #endif
2331  INLINE l_ivector &operator |=(l_ivector &rv, const l_ivector_slice &sl)
2333 #if(CXSC_INDEX_CHECK)
2334 ;
2335 #else
2336  noexcept;
2337 #endif
2338 
2340  INLINE l_ivector operator &(const l_ivector &rv1, const l_ivector &rv2)
2341 #if(CXSC_INDEX_CHECK)
2342 ;
2343 #else
2344  noexcept;
2345 #endif
2346  INLINE l_ivector operator &(const l_ivector &rv, const l_ivector_slice &sl)
2348 #if(CXSC_INDEX_CHECK)
2349 ;
2350 #else
2351  noexcept;
2352 #endif
2353  INLINE l_ivector operator &(const l_ivector_slice &sl, const l_ivector &rv)
2355 #if(CXSC_INDEX_CHECK)
2356 ;
2357 #else
2358  noexcept;
2359 #endif
2360  INLINE l_ivector operator &(const l_ivector_slice &sl1, const l_ivector_slice &sl2)
2362 #if(CXSC_INDEX_CHECK)
2363 ;
2364 #else
2365  noexcept;
2366 #endif
2367  INLINE l_ivector & operator &=(l_ivector &rv1, const l_ivector &rv2)
2369 #if(CXSC_INDEX_CHECK)
2370 ;
2371 #else
2372  noexcept;
2373 #endif
2374  INLINE l_ivector &operator &=(l_ivector &rv, const l_ivector_slice &sl)
2376 #if(CXSC_INDEX_CHECK)
2377 ;
2378 #else
2379  noexcept;
2380 #endif
2381 
2383  INLINE bool operator ==(const l_ivector &rv1, const l_ivector &rv2) noexcept;
2385  INLINE bool operator ==(const l_ivector_slice &sl1, const l_ivector_slice &sl2) noexcept;
2387  INLINE bool operator ==(const l_ivector_slice &sl, const l_ivector &rv) noexcept;
2389  INLINE bool operator ==(const l_ivector &rv, const l_ivector_slice &sl) noexcept;
2391  INLINE bool operator !=(const l_ivector &rv1, const l_ivector &rv2) noexcept;
2393  INLINE bool operator !=(const l_ivector_slice &sl1, const l_ivector_slice &sl2) noexcept;
2395  INLINE bool operator !=(const l_ivector_slice &sl, const l_ivector &rv) noexcept;
2397  INLINE bool operator !=(const l_ivector &rv, const l_ivector_slice &sl) noexcept;
2399  INLINE bool operator <(const l_ivector &rv1, const l_ivector &rv2) noexcept;
2401  INLINE bool operator <(const l_ivector_slice &sl1, const l_ivector_slice &sl2) noexcept;
2403  INLINE bool operator < (const l_ivector_slice &sl, const l_ivector &rv) noexcept;
2405  INLINE bool operator < (const l_ivector &rv, const l_ivector_slice &sl) noexcept;
2407  INLINE bool operator <=(const l_ivector &rv1, const l_ivector &rv2) noexcept;
2409  INLINE bool operator <=(const l_ivector_slice &sl1, const l_ivector_slice &sl2) noexcept;
2411  INLINE bool operator <=(const l_ivector_slice &sl, const l_ivector &rv) noexcept;
2413  INLINE bool operator <=(const l_ivector &rv, const l_ivector_slice &sl) noexcept;
2415  INLINE bool operator >(const l_ivector &rv1, const l_ivector &rv2) noexcept;
2417  INLINE bool operator >(const l_ivector_slice &sl1, const l_ivector_slice &sl2) noexcept;
2419  INLINE bool operator >(const l_ivector_slice &sl, const l_ivector &rv) noexcept;
2421  INLINE bool operator >(const l_ivector &rv, const l_ivector_slice &sl) noexcept;
2423  INLINE bool operator >=(const l_ivector &rv1, const l_ivector &rv2) noexcept;
2425  INLINE bool operator >=(const l_ivector_slice &sl1, const l_ivector_slice &sl2) noexcept;
2427  INLINE bool operator >=(const l_ivector_slice &sl, const l_ivector &rv) noexcept;
2429  INLINE bool operator >=(const l_ivector &rv, const l_ivector_slice &sl) noexcept;
2430 
2431 //-------------------------------- l_interval / Real --------------------------------
2432 
2434  INLINE void accumulate(idotprecision &dp, const rvector & rv1, const l_ivector &rv2)
2435 #if(CXSC_INDEX_CHECK)
2436 ;
2437 #else
2438  noexcept;
2439 #endif
2440  INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const rvector &rv2)
2442 #if(CXSC_INDEX_CHECK)
2443 ;
2444 #else
2445  noexcept;
2446 #endif
2447  INLINE void accumulate(idotprecision &dp, const rvector_slice & sl, const l_ivector &rv)
2449 #if(CXSC_INDEX_CHECK)
2450 ;
2451 #else
2452  noexcept;
2453 #endif
2454  INLINE void accumulate(idotprecision &dp,const l_ivector_slice &sl,const rvector &rv)
2456 #if(CXSC_INDEX_CHECK)
2457 ;
2458 #else
2459  noexcept;
2460 #endif
2461  INLINE void accumulate(idotprecision &dp, const rvector &rv, const l_ivector_slice &sl)
2463 #if(CXSC_INDEX_CHECK)
2464 ;
2465 #else
2466  noexcept;
2467 #endif
2468  INLINE void accumulate(idotprecision &dp, const rvector & rv1, const l_imatrix_subv &rv2)
2470 #if(CXSC_INDEX_CHECK)
2471 ;
2472 #else
2473  noexcept;
2474 #endif
2475  INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const rmatrix_subv &rv2)
2477 #if(CXSC_INDEX_CHECK)
2478 ;
2479 #else
2480  noexcept;
2481 #endif
2482  INLINE void accumulate(idotprecision &dp,const l_ivector &rv,const rvector_slice &sl)
2484 #if(CXSC_INDEX_CHECK)
2485 ;
2486 #else
2487  noexcept;
2488 #endif
2489  INLINE void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const l_ivector &rv2)
2491 #if(CXSC_INDEX_CHECK)
2492 ;
2493 #else
2494  noexcept;
2495 #endif
2496  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const rvector &rv2)
2498 #if(CXSC_INDEX_CHECK)
2499 ;
2500 #else
2501  noexcept;
2502 #endif
2503  INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl1, const rvector_slice &sl2)
2505 #if(CXSC_INDEX_CHECK)
2506 ;
2507 #else
2508  noexcept;
2509 #endif
2510  INLINE void accumulate(idotprecision &dp, const rvector_slice & sl1, const l_ivector_slice &sl2)
2512 #if(CXSC_INDEX_CHECK)
2513 ;
2514 #else
2515  noexcept;
2516 #endif
2517 
2519  INLINE l_interval operator *(const rvector & rv1, const l_ivector &rv2)
2520 #if(CXSC_INDEX_CHECK)
2521 ;
2522 #else
2523  noexcept;
2524 #endif
2525  INLINE l_interval operator *(const rvector_slice &sl, const l_ivector &rv)
2527 #if(CXSC_INDEX_CHECK)
2528 ;
2529 #else
2530  noexcept;
2531 #endif
2532  INLINE l_interval operator *(const rvector &rv, const l_ivector_slice &sl)
2534 #if(CXSC_INDEX_CHECK)
2535 ;
2536 #else
2537  noexcept;
2538 #endif
2539  INLINE l_interval operator *(const rvector_slice & sl1, const l_ivector_slice &sl2)
2541 #if(CXSC_INDEX_CHECK)
2542 ;
2543 #else
2544  noexcept;
2545 #endif
2546 
2548  INLINE l_interval operator *(const l_ivector & rv1, const rvector &rv2)
2549 #if(CXSC_INDEX_CHECK)
2550 ;
2551 #else
2552  noexcept;
2553 #endif
2554  INLINE l_interval operator *(const l_ivector_slice &sl, const rvector &rv)
2556 #if(CXSC_INDEX_CHECK)
2557 ;
2558 #else
2559  noexcept;
2560 #endif
2561  INLINE l_interval operator *(const l_ivector &rv, const rvector_slice &sl)
2563 #if(CXSC_INDEX_CHECK)
2564 ;
2565 #else
2566  noexcept;
2567 #endif
2568  INLINE l_interval operator *(const l_ivector_slice & sl1, const rvector_slice &sl2)
2570 #if(CXSC_INDEX_CHECK)
2571 ;
2572 #else
2573  noexcept;
2574 #endif
2575 
2577  INLINE l_ivector operator +(const rvector &rv1, const l_ivector &rv2)
2578 #if(CXSC_INDEX_CHECK)
2579 ;
2580 #else
2581  noexcept;
2582 #endif
2583  INLINE l_ivector operator +(const rvector &rv, const l_ivector_slice &sl)
2585 #if(CXSC_INDEX_CHECK)
2586 ;
2587 #else
2588  noexcept;
2589 #endif
2590  INLINE l_ivector operator +(const rvector_slice &sl, const l_ivector &rv)
2592 #if(CXSC_INDEX_CHECK)
2593 ;
2594 #else
2595  noexcept;
2596 #endif
2597  INLINE l_ivector operator +(const rvector_slice &sl1, const l_ivector_slice &sl2)
2599 #if(CXSC_INDEX_CHECK)
2600 ;
2601 #else
2602  noexcept;
2603 #endif
2604 
2606  INLINE l_ivector operator +(const l_ivector &rv1, const rvector &rv2)
2607 #if(CXSC_INDEX_CHECK)
2608 ;
2609 #else
2610  noexcept;
2611 #endif
2612  INLINE l_ivector operator +(const l_ivector &rv, const rvector_slice &sl)
2614 #if(CXSC_INDEX_CHECK)
2615 ;
2616 #else
2617  noexcept;
2618 #endif
2619  INLINE l_ivector operator +(const l_ivector_slice &sl, const rvector &rv)
2621 #if(CXSC_INDEX_CHECK)
2622 ;
2623 #else
2624  noexcept;
2625 #endif
2626  INLINE l_ivector operator +(const l_ivector_slice &sl1, const rvector_slice &sl2)
2628 #if(CXSC_INDEX_CHECK)
2629 ;
2630 #else
2631  noexcept;
2632 #endif
2633 
2635  INLINE l_ivector & operator +=(l_ivector &rv1, const rvector &rv2)
2636 #if(CXSC_INDEX_CHECK)
2637 ;
2638 #else
2639  noexcept;
2640 #endif
2641  INLINE l_ivector &operator +=(l_ivector &rv, const rvector_slice &sl)
2643 #if(CXSC_INDEX_CHECK)
2644 ;
2645 #else
2646  noexcept;
2647 #endif
2648 
2650  INLINE l_ivector operator -(const rvector &rv1, const l_ivector &rv2)
2651 #if(CXSC_INDEX_CHECK)
2652 ;
2653 #else
2654  noexcept;
2655 #endif
2656  INLINE l_ivector operator -(const rvector &rv, const l_ivector_slice &sl)
2658 #if(CXSC_INDEX_CHECK)
2659 ;
2660 #else
2661  noexcept;
2662 #endif
2663  INLINE l_ivector operator -(const rvector_slice &sl, const l_ivector &rv)
2665 #if(CXSC_INDEX_CHECK)
2666 ;
2667 #else
2668  noexcept;
2669 #endif
2670  INLINE l_ivector operator -(const rvector_slice &sl1, const l_ivector_slice &sl2)
2672 #if(CXSC_INDEX_CHECK)
2673 ;
2674 #else
2675  noexcept;
2676 #endif
2677 
2679  INLINE l_ivector operator -(const l_ivector &rv1, const rvector &rv2)
2680 #if(CXSC_INDEX_CHECK)
2681 ;
2682 #else
2683  noexcept;
2684 #endif
2685  INLINE l_ivector operator -(const l_ivector &rv, const rvector_slice &sl)
2687 #if(CXSC_INDEX_CHECK)
2688 ;
2689 #else
2690  noexcept;
2691 #endif
2692  INLINE l_ivector operator -(const l_ivector_slice &sl, const rvector &rv)
2694 #if(CXSC_INDEX_CHECK)
2695 ;
2696 #else
2697  noexcept;
2698 #endif
2699  INLINE l_ivector operator -(const l_ivector_slice &sl1, const rvector_slice &sl2)
2701 #if(CXSC_INDEX_CHECK)
2702 ;
2703 #else
2704  noexcept;
2705 #endif
2706 
2708  INLINE l_ivector & operator -=(l_ivector &rv1, const rvector &rv2)
2709 #if(CXSC_INDEX_CHECK)
2710 ;
2711 #else
2712  noexcept;
2713 #endif
2714  INLINE l_ivector &operator -=(l_ivector &rv, const rvector_slice &sl)
2716 #if(CXSC_INDEX_CHECK)
2717 ;
2718 #else
2719  noexcept;
2720 #endif
2721 
2723  INLINE l_ivector operator |(const rvector &rv1, const l_ivector &rv2)
2724 #if(CXSC_INDEX_CHECK)
2725 ;
2726 #else
2727  noexcept;
2728 #endif
2729  INLINE l_ivector operator |(const rvector &rv, const l_ivector_slice &sl)
2731 #if(CXSC_INDEX_CHECK)
2732 ;
2733 #else
2734  noexcept;
2735 #endif
2736  INLINE l_ivector operator |(const rvector_slice &sl, const l_ivector &rv)
2738 #if(CXSC_INDEX_CHECK)
2739 ;
2740 #else
2741  noexcept;
2742 #endif
2743  INLINE l_ivector operator |(const rvector_slice &sl1, const l_ivector_slice &sl2)
2745 #if(CXSC_INDEX_CHECK)
2746 ;
2747 #else
2748  noexcept;
2749 #endif
2750 
2752  INLINE l_ivector operator |(const l_ivector &rv1, const rvector &rv2)
2753 #if(CXSC_INDEX_CHECK)
2754 ;
2755 #else
2756  noexcept;
2757 #endif
2758  INLINE l_ivector operator |(const l_ivector &rv, const rvector_slice &sl)
2760 #if(CXSC_INDEX_CHECK)
2761 ;
2762 #else
2763  noexcept;
2764 #endif
2765  INLINE l_ivector operator |(const l_ivector_slice &sl, const rvector &rv)
2767 #if(CXSC_INDEX_CHECK)
2768 ;
2769 #else
2770  noexcept;
2771 #endif
2772  INLINE l_ivector operator |(const l_ivector_slice &sl1, const rvector_slice &sl2)
2774 #if(CXSC_INDEX_CHECK)
2775 ;
2776 #else
2777  noexcept;
2778 #endif
2779 
2781  INLINE l_ivector & operator |=(l_ivector &rv1, const rvector &rv2)
2782 #if(CXSC_INDEX_CHECK)
2783 ;
2784 #else
2785  noexcept;
2786 #endif
2787  INLINE l_ivector &operator |=(l_ivector &rv, const rvector_slice &sl)
2789 #if(CXSC_INDEX_CHECK)
2790 ;
2791 #else
2792  noexcept;
2793 #endif
2794 
2796  INLINE l_ivector operator &(const rvector &rv1, const l_ivector &rv2)
2797 #if(CXSC_INDEX_CHECK)
2798 ;
2799 #else
2800  noexcept;
2801 #endif
2802  INLINE l_ivector operator &(const rvector &rv, const l_ivector_slice &sl)
2804 #if(CXSC_INDEX_CHECK)
2805 ;
2806 #else
2807  noexcept;
2808 #endif
2809  INLINE l_ivector operator &(const rvector_slice &sl, const l_ivector &rv)
2811 #if(CXSC_INDEX_CHECK)
2812 ;
2813 #else
2814  noexcept;
2815 #endif
2816  INLINE l_ivector operator &(const rvector_slice &sl1, const l_ivector_slice &sl2)
2818 #if(CXSC_INDEX_CHECK)
2819 ;
2820 #else
2821  noexcept;
2822 #endif
2823 
2825  INLINE l_ivector operator &(const l_ivector &rv1, const rvector &rv2)
2826 #if(CXSC_INDEX_CHECK)
2827 ;
2828 #else
2829  noexcept;
2830 #endif
2831  INLINE l_ivector operator &(const l_ivector &rv, const rvector_slice &sl)
2833 #if(CXSC_INDEX_CHECK)
2834 ;
2835 #else
2836  noexcept;
2837 #endif
2838  INLINE l_ivector operator &(const l_ivector_slice &sl, const rvector &rv)
2840 #if(CXSC_INDEX_CHECK)
2841 ;
2842 #else
2843  noexcept;
2844 #endif
2845  INLINE l_ivector operator &(const l_ivector_slice &sl1, const rvector_slice &sl2)
2847 #if(CXSC_INDEX_CHECK)
2848 ;
2849 #else
2850  noexcept;
2851 #endif
2852 
2854  INLINE l_ivector & operator &=(l_ivector &rv1, const rvector &rv2)
2855 #if(CXSC_INDEX_CHECK)
2856 ;
2857 #else
2858  noexcept;
2859 #endif
2860  INLINE l_ivector &operator &=(l_ivector &rv, const rvector_slice &sl)
2862 #if(CXSC_INDEX_CHECK)
2863 ;
2864 #else
2865  noexcept;
2866 #endif
2867 //-------------------------------- l_interval / l_real --------------------------------
2868 
2870  INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const l_ivector &rv2)
2871 #if(CXSC_INDEX_CHECK)
2872 ;
2873 #else
2874  noexcept;
2875 #endif
2876  INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const l_rvector &rv2)
2878 #if(CXSC_INDEX_CHECK)
2879 ;
2880 #else
2881  noexcept;
2882 #endif
2883  INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl, const l_ivector &rv)
2885 #if(CXSC_INDEX_CHECK)
2886 ;
2887 #else
2888  noexcept;
2889 #endif
2890  INLINE void accumulate(idotprecision &dp,const l_ivector_slice &sl,const l_rvector &rv)
2892 #if(CXSC_INDEX_CHECK)
2893 ;
2894 #else
2895  noexcept;
2896 #endif
2897  INLINE void accumulate(idotprecision &dp, const l_rvector &rv, const l_ivector_slice &sl)
2899 #if(CXSC_INDEX_CHECK)
2900 ;
2901 #else
2902  noexcept;
2903 #endif
2904  INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const l_imatrix_subv &rv2)
2906 #if(CXSC_INDEX_CHECK)
2907 ;
2908 #else
2909  noexcept;
2910 #endif
2911  INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const l_rmatrix_subv &rv2)
2913 #if(CXSC_INDEX_CHECK)
2914 ;
2915 #else
2916  noexcept;
2917 #endif
2918  INLINE void accumulate(idotprecision &dp,const l_ivector &rv,const l_rvector_slice &sl)
2920 #if(CXSC_INDEX_CHECK)
2921 ;
2922 #else
2923  noexcept;
2924 #endif
2925  INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const l_ivector &rv2)
2927 #if(CXSC_INDEX_CHECK)
2928 ;
2929 #else
2930  noexcept;
2931 #endif
2932  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_rvector &rv2)
2934 #if(CXSC_INDEX_CHECK)
2935 ;
2936 #else
2937  noexcept;
2938 #endif
2939  INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl1, const l_rvector_slice &sl2)
2941 #if(CXSC_INDEX_CHECK)
2942 ;
2943 #else
2944  noexcept;
2945 #endif
2946  INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl1, const l_ivector_slice &sl2)
2948 #if(CXSC_INDEX_CHECK)
2949 ;
2950 #else
2951  noexcept;
2952 #endif
2953 
2955  INLINE l_interval operator *(const l_rvector & rv1, const l_ivector &rv2)
2956 #if(CXSC_INDEX_CHECK)
2957 ;
2958 #else
2959  noexcept;
2960 #endif
2961  INLINE l_interval operator *(const l_rvector_slice &sl, const l_ivector &rv)
2963 #if(CXSC_INDEX_CHECK)
2964 ;
2965 #else
2966  noexcept;
2967 #endif
2968  INLINE l_interval operator *(const l_rvector &rv, const l_ivector_slice &sl)
2970 #if(CXSC_INDEX_CHECK)
2971 ;
2972 #else
2973  noexcept;
2974 #endif
2975  INLINE l_interval operator *(const l_rvector_slice & sl1, const l_ivector_slice &sl2)
2977 #if(CXSC_INDEX_CHECK)
2978 ;
2979 #else
2980  noexcept;
2981 #endif
2982 
2984  INLINE l_interval operator *(const l_ivector & rv1, const l_rvector &rv2)
2985 #if(CXSC_INDEX_CHECK)
2986 ;
2987 #else
2988  noexcept;
2989 #endif
2990  INLINE l_interval operator *(const l_ivector_slice &sl, const l_rvector &rv)
2992 #if(CXSC_INDEX_CHECK)
2993 ;
2994 #else
2995  noexcept;
2996 #endif
2997  INLINE l_interval operator *(const l_ivector &rv, const l_rvector_slice &sl)
2999 #if(CXSC_INDEX_CHECK)
3000 ;
3001 #else
3002  noexcept;
3003 #endif
3004  INLINE l_interval operator *(const l_ivector_slice & sl1, const l_rvector_slice &sl2)
3006 #if(CXSC_INDEX_CHECK)
3007 ;
3008 #else
3009  noexcept;
3010 #endif
3011 
3013  INLINE l_ivector operator +(const l_rvector &rv1, const l_ivector &rv2)
3014 #if(CXSC_INDEX_CHECK)
3015 ;
3016 #else
3017  noexcept;
3018 #endif
3019  INLINE l_ivector operator +(const l_rvector &rv, const l_ivector_slice &sl)
3021 #if(CXSC_INDEX_CHECK)
3022 ;
3023 #else
3024  noexcept;
3025 #endif
3026  INLINE l_ivector operator +(const l_rvector_slice &sl, const l_ivector &rv)
3028 #if(CXSC_INDEX_CHECK)
3029 ;
3030 #else
3031  noexcept;
3032 #endif
3033  INLINE l_ivector operator +(const l_rvector_slice &sl1, const l_ivector_slice &sl2)
3035 #if(CXSC_INDEX_CHECK)
3036 ;
3037 #else
3038  noexcept;
3039 #endif
3040 
3042  INLINE l_ivector operator +(const l_ivector &rv1, const l_rvector &rv2)
3043 #if(CXSC_INDEX_CHECK)
3044 ;
3045 #else
3046  noexcept;
3047 #endif
3048  INLINE l_ivector operator +(const l_ivector &rv, const l_rvector_slice &sl)
3050 #if(CXSC_INDEX_CHECK)
3051 ;
3052 #else
3053  noexcept;
3054 #endif
3055  INLINE l_ivector operator +(const l_ivector_slice &sl, const l_rvector &rv)
3057 #if(CXSC_INDEX_CHECK)
3058 ;
3059 #else
3060  noexcept;
3061 #endif
3062  INLINE l_ivector operator +(const l_ivector_slice &sl1, const l_rvector_slice &sl2)
3064 #if(CXSC_INDEX_CHECK)
3065 ;
3066 #else
3067  noexcept;
3068 #endif
3069 
3071  INLINE l_ivector & operator +=(l_ivector &rv1, const l_rvector &rv2)
3072 #if(CXSC_INDEX_CHECK)
3073 ;
3074 #else
3075  noexcept;
3076 #endif
3077  INLINE l_ivector &operator +=(l_ivector &rv, const l_rvector_slice &sl)
3079 #if(CXSC_INDEX_CHECK)
3080 ;
3081 #else
3082  noexcept;
3083 #endif
3084 
3086  INLINE l_ivector operator -(const l_rvector &rv1, const l_ivector &rv2)
3087 #if(CXSC_INDEX_CHECK)
3088 ;
3089 #else
3090  noexcept;
3091 #endif
3092  INLINE l_ivector operator -(const l_rvector &rv, const l_ivector_slice &sl)
3094 #if(CXSC_INDEX_CHECK)
3095 ;
3096 #else
3097  noexcept;
3098 #endif
3099  INLINE l_ivector operator -(const l_rvector_slice &sl, const l_ivector &rv)
3101 #if(CXSC_INDEX_CHECK)
3102 ;
3103 #else
3104  noexcept;
3105 #endif
3106  INLINE l_ivector operator -(const l_rvector_slice &sl1, const l_ivector_slice &sl2)
3108 #if(CXSC_INDEX_CHECK)
3109 ;
3110 #else
3111  noexcept;
3112 #endif
3113 
3115  INLINE l_ivector operator -(const l_ivector &rv1, const l_rvector &rv2)
3116 #if(CXSC_INDEX_CHECK)
3117 ;
3118 #else
3119  noexcept;
3120 #endif
3121  INLINE l_ivector operator -(const l_ivector &rv, const l_rvector_slice &sl)
3123 #if(CXSC_INDEX_CHECK)
3124 ;
3125 #else
3126  noexcept;
3127 #endif
3128  INLINE l_ivector operator -(const l_ivector_slice &sl, const l_rvector &rv)
3130 #if(CXSC_INDEX_CHECK)
3131 ;
3132 #else
3133  noexcept;
3134 #endif
3135  INLINE l_ivector operator -(const l_ivector_slice &sl1, const l_rvector_slice &sl2)
3137 #if(CXSC_INDEX_CHECK)
3138 ;
3139 #else
3140  noexcept;
3141 #endif
3142 
3144  INLINE l_ivector & operator -=(l_ivector &rv1, const l_rvector &rv2)
3145 #if(CXSC_INDEX_CHECK)
3146 ;
3147 #else
3148  noexcept;
3149 #endif
3150  INLINE l_ivector &operator -=(l_ivector &rv, const l_rvector_slice &sl)
3152 #if(CXSC_INDEX_CHECK)
3153 ;
3154 #else
3155  noexcept;
3156 #endif
3157 
3159  INLINE l_ivector operator |(const l_rvector &rv1, const l_ivector &rv2)
3160 #if(CXSC_INDEX_CHECK)
3161 ;
3162 #else
3163  noexcept;
3164 #endif
3165  INLINE l_ivector operator |(const l_rvector &rv, const l_ivector_slice &sl)
3167 #if(CXSC_INDEX_CHECK)
3168 ;
3169 #else
3170  noexcept;
3171 #endif
3172  INLINE l_ivector operator |(const l_rvector_slice &sl, const l_ivector &rv)
3174 #if(CXSC_INDEX_CHECK)
3175 ;
3176 #else
3177  noexcept;
3178 #endif
3179  INLINE l_ivector operator |(const l_rvector_slice &sl1, const l_ivector_slice &sl2)
3181 #if(CXSC_INDEX_CHECK)
3182 ;
3183 #else
3184  noexcept;
3185 #endif
3186 
3188  INLINE l_ivector operator |(const l_ivector &rv1, const l_rvector &rv2)
3189 #if(CXSC_INDEX_CHECK)
3190 ;
3191 #else
3192  noexcept;
3193 #endif
3194  INLINE l_ivector operator |(const l_ivector &rv, const l_rvector_slice &sl)
3196 #if(CXSC_INDEX_CHECK)
3197 ;
3198 #else
3199  noexcept;
3200 #endif
3201  INLINE l_ivector operator |(const l_ivector_slice &sl, const l_rvector &rv)
3203 #if(CXSC_INDEX_CHECK)
3204 ;
3205 #else
3206  noexcept;
3207 #endif
3208  INLINE l_ivector operator |(const l_ivector_slice &sl1, const l_rvector_slice &sl2)
3210 #if(CXSC_INDEX_CHECK)
3211 ;
3212 #else
3213  noexcept;
3214 #endif
3215 
3217  INLINE l_ivector & operator |=(l_ivector &rv1, const l_rvector &rv2)
3218 #if(CXSC_INDEX_CHECK)
3219 ;
3220 #else
3221  noexcept;
3222 #endif
3223  INLINE l_ivector &operator |=(l_ivector &rv, const l_rvector_slice &sl)
3225 #if(CXSC_INDEX_CHECK)
3226 ;
3227 #else
3228  noexcept;
3229 #endif
3230 
3232  INLINE l_ivector operator &(const l_rvector &rv1, const l_ivector &rv2)
3233 #if(CXSC_INDEX_CHECK)
3234 ;
3235 #else
3236  noexcept;
3237 #endif
3238  INLINE l_ivector operator &(const l_rvector &rv, const l_ivector_slice &sl)
3240 #if(CXSC_INDEX_CHECK)
3241 ;
3242 #else
3243  noexcept;
3244 #endif
3245  INLINE l_ivector operator &(const l_rvector_slice &sl, const l_ivector &rv)
3247 #if(CXSC_INDEX_CHECK)
3248 ;
3249 #else
3250  noexcept;
3251 #endif
3252  INLINE l_ivector operator &(const l_rvector_slice &sl1, const l_ivector_slice &sl2)
3254 #if(CXSC_INDEX_CHECK)
3255 ;
3256 #else
3257  noexcept;
3258 #endif
3259 
3261  INLINE l_ivector operator &(const l_ivector &rv1, const l_rvector &rv2)
3262 #if(CXSC_INDEX_CHECK)
3263 ;
3264 #else
3265  noexcept;
3266 #endif
3267  INLINE l_ivector operator &(const l_ivector &rv, const l_rvector_slice &sl)
3269 #if(CXSC_INDEX_CHECK)
3270 ;
3271 #else
3272  noexcept;
3273 #endif
3274  INLINE l_ivector operator &(const l_ivector_slice &sl, const l_rvector &rv)
3276 #if(CXSC_INDEX_CHECK)
3277 ;
3278 #else
3279  noexcept;
3280 #endif
3281  INLINE l_ivector operator &(const l_ivector_slice &sl1, const l_rvector_slice &sl2)
3283 #if(CXSC_INDEX_CHECK)
3284 ;
3285 #else
3286  noexcept;
3287 #endif
3288 
3290  INLINE l_ivector & operator &=(l_ivector &rv1, const l_rvector &rv2)
3291 #if(CXSC_INDEX_CHECK)
3292 ;
3293 #else
3294  noexcept;
3295 #endif
3296  INLINE l_ivector &operator &=(l_ivector &rv, const l_rvector_slice &sl)
3298 #if(CXSC_INDEX_CHECK)
3299 ;
3300 #else
3301  noexcept;
3302 #endif
3303 
3304 //-------------------------------- l_interval / interval --------------------------------
3305 
3307  INLINE void accumulate(idotprecision &dp, const ivector & rv1, const l_ivector &rv2)
3308 #if(CXSC_INDEX_CHECK)
3309 ;
3310 #else
3311  noexcept;
3312 #endif
3313  INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const ivector &rv2)
3315 #if(CXSC_INDEX_CHECK)
3316 ;
3317 #else
3318  noexcept;
3319 #endif
3320  INLINE void accumulate(idotprecision &dp, const ivector_slice & sl, const l_ivector &rv)
3322 #if(CXSC_INDEX_CHECK)
3323 ;
3324 #else
3325  noexcept;
3326 #endif
3327  INLINE void accumulate(idotprecision &dp,const l_ivector_slice &sl,const ivector &rv)
3329 #if(CXSC_INDEX_CHECK)
3330 ;
3331 #else
3332  noexcept;
3333 #endif
3334  INLINE void accumulate(idotprecision &dp, const ivector &rv, const l_ivector_slice &sl)
3336 #if(CXSC_INDEX_CHECK)
3337 ;
3338 #else
3339  noexcept;
3340 #endif
3341  INLINE void accumulate(idotprecision &dp, const ivector & rv1, const l_imatrix_subv &rv2)
3343 #if(CXSC_INDEX_CHECK)
3344 ;
3345 #else
3346  noexcept;
3347 #endif
3348  INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const imatrix_subv &rv2)
3350 #if(CXSC_INDEX_CHECK)
3351 ;
3352 #else
3353  noexcept;
3354 #endif
3355  INLINE void accumulate(idotprecision &dp,const l_ivector &rv,const ivector_slice &sl)
3357 #if(CXSC_INDEX_CHECK)
3358 ;
3359 #else
3360  noexcept;
3361 #endif
3362  INLINE void accumulate(idotprecision &dp, const imatrix_subv & rv1, const l_ivector &rv2)
3364 #if(CXSC_INDEX_CHECK)
3365 ;
3366 #else
3367  noexcept;
3368 #endif
3369  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const ivector &rv2)
3371 #if(CXSC_INDEX_CHECK)
3372 ;
3373 #else
3374  noexcept;
3375 #endif
3376  INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl1, const ivector_slice &sl2)
3378 #if(CXSC_INDEX_CHECK)
3379 ;
3380 #else
3381  noexcept;
3382 #endif
3383  INLINE void accumulate(idotprecision &dp, const ivector_slice & sl1, const l_ivector_slice &sl2)
3385 #if(CXSC_INDEX_CHECK)
3386 ;
3387 #else
3388  noexcept;
3389 #endif
3390 
3392  INLINE l_interval operator *(const ivector & rv1, const l_ivector &rv2)
3393 #if(CXSC_INDEX_CHECK)
3394 ;
3395 #else
3396  noexcept;
3397 #endif
3398  INLINE l_interval operator *(const ivector_slice &sl, const l_ivector &rv)
3400 #if(CXSC_INDEX_CHECK)
3401 ;
3402 #else
3403  noexcept;
3404 #endif
3405  INLINE l_interval operator *(const ivector &rv, const l_ivector_slice &sl)
3407 #if(CXSC_INDEX_CHECK)
3408 ;
3409 #else
3410  noexcept;
3411 #endif
3412  INLINE l_interval operator *(const ivector_slice & sl1, const l_ivector_slice &sl2)
3414 #if(CXSC_INDEX_CHECK)
3415 ;
3416 #else
3417  noexcept;
3418 #endif
3419 
3421  INLINE l_interval operator *(const l_ivector & rv1, const ivector &rv2)
3422 #if(CXSC_INDEX_CHECK)
3423 ;
3424 #else
3425  noexcept;
3426 #endif
3427  INLINE l_interval operator *(const l_ivector_slice &sl, const ivector &rv)
3429 #if(CXSC_INDEX_CHECK)
3430 ;
3431 #else
3432  noexcept;
3433 #endif
3434  INLINE l_interval operator *(const l_ivector &rv, const ivector_slice &sl)
3436 #if(CXSC_INDEX_CHECK)
3437 ;
3438 #else
3439  noexcept;
3440 #endif
3441  INLINE l_interval operator *(const l_ivector_slice & sl1, const ivector_slice &sl2)
3443 #if(CXSC_INDEX_CHECK)
3444 ;
3445 #else
3446  noexcept;
3447 #endif
3448 
3450  INLINE l_ivector operator +(const ivector &rv1, const l_ivector &rv2)
3451 #if(CXSC_INDEX_CHECK)
3452 ;
3453 #else
3454  noexcept;
3455 #endif
3456  INLINE l_ivector operator +(const ivector &rv, const l_ivector_slice &sl)
3458 #if(CXSC_INDEX_CHECK)
3459 ;
3460 #else
3461  noexcept;
3462 #endif
3463  INLINE l_ivector operator +(const ivector_slice &sl, const l_ivector &rv)
3465 #if(CXSC_INDEX_CHECK)
3466 ;
3467 #else
3468  noexcept;
3469 #endif
3470  INLINE l_ivector operator +(const ivector_slice &sl1, const l_ivector_slice &sl2)
3472 #if(CXSC_INDEX_CHECK)
3473 ;
3474 #else
3475  noexcept;
3476 #endif
3477 
3479  INLINE l_ivector operator +(const l_ivector &rv1, const ivector &rv2)
3480 #if(CXSC_INDEX_CHECK)
3481 ;
3482 #else
3483  noexcept;
3484 #endif
3485  INLINE l_ivector operator +(const l_ivector &rv, const ivector_slice &sl)
3487 #if(CXSC_INDEX_CHECK)
3488 ;
3489 #else
3490  noexcept;
3491 #endif
3492  INLINE l_ivector operator +(const l_ivector_slice &sl, const ivector &rv)
3494 #if(CXSC_INDEX_CHECK)
3495 ;
3496 #else
3497  noexcept;
3498 #endif
3499  INLINE l_ivector operator +(const l_ivector_slice &sl1, const ivector_slice &sl2)
3501 #if(CXSC_INDEX_CHECK)
3502 ;
3503 #else
3504  noexcept;
3505 #endif
3506 
3508  INLINE l_ivector & operator +=(l_ivector &rv1, const ivector &rv2)
3509 #if(CXSC_INDEX_CHECK)
3510 ;
3511 #else
3512  noexcept;
3513 #endif
3514  INLINE l_ivector &operator +=(l_ivector &rv, const ivector_slice &sl)
3516 #if(CXSC_INDEX_CHECK)
3517 ;
3518 #else
3519  noexcept;
3520 #endif
3521 
3523  INLINE l_ivector operator -(const ivector &rv1, const l_ivector &rv2)
3524 #if(CXSC_INDEX_CHECK)
3525 ;
3526 #else
3527  noexcept;
3528 #endif
3529  INLINE l_ivector operator -(const ivector &rv, const l_ivector_slice &sl)
3531 #if(CXSC_INDEX_CHECK)
3532 ;
3533 #else
3534  noexcept;
3535 #endif
3536  INLINE l_ivector operator -(const ivector_slice &sl, const l_ivector &rv)
3538 #if(CXSC_INDEX_CHECK)
3539 ;
3540 #else
3541  noexcept;
3542 #endif
3543  INLINE l_ivector operator -(const ivector_slice &sl1, const l_ivector_slice &sl2)
3545 #if(CXSC_INDEX_CHECK)
3546 ;
3547 #else
3548  noexcept;
3549 #endif
3550 
3552  INLINE l_ivector operator -(const l_ivector &rv1, const ivector &rv2)
3553 #if(CXSC_INDEX_CHECK)
3554 ;
3555 #else
3556  noexcept;
3557 #endif
3558  INLINE l_ivector operator -(const l_ivector &rv, const ivector_slice &sl)
3560 #if(CXSC_INDEX_CHECK)
3561 ;
3562 #else
3563  noexcept;
3564 #endif
3565  INLINE l_ivector operator -(const l_ivector_slice &sl, const ivector &rv)
3567 #if(CXSC_INDEX_CHECK)
3568 ;
3569 #else
3570  noexcept;
3571 #endif
3572  INLINE l_ivector operator -(const l_ivector_slice &sl1, const ivector_slice &sl2)
3574 #if(CXSC_INDEX_CHECK)
3575 ;
3576 #else
3577  noexcept;
3578 #endif
3579 
3581  INLINE l_ivector & operator -=(l_ivector &rv1, const ivector &rv2)
3582 #if(CXSC_INDEX_CHECK)
3583 ;
3584 #else
3585  noexcept;
3586 #endif
3587  INLINE l_ivector &operator -=(l_ivector &rv, const ivector_slice &sl)
3589 #if(CXSC_INDEX_CHECK)
3590 ;
3591 #else
3592  noexcept;
3593 #endif
3594 
3596  INLINE l_ivector operator |(const ivector &rv1, const l_ivector &rv2)
3597 #if(CXSC_INDEX_CHECK)
3598 ;
3599 #else
3600  noexcept;
3601 #endif
3602  INLINE l_ivector operator |(const ivector &rv, const l_ivector_slice &sl)
3604 #if(CXSC_INDEX_CHECK)
3605 ;
3606 #else
3607  noexcept;
3608 #endif
3609  INLINE l_ivector operator |(const ivector_slice &sl, const l_ivector &rv)
3611 #if(CXSC_INDEX_CHECK)
3612 ;
3613 #else
3614  noexcept;
3615 #endif
3616  INLINE l_ivector operator |(const ivector_slice &sl1, const l_ivector_slice &sl2)
3618 #if(CXSC_INDEX_CHECK)
3619 ;
3620 #else
3621  noexcept;
3622 #endif
3623 
3625  INLINE l_ivector operator |(const l_ivector &rv1, const ivector &rv2)
3626 #if(CXSC_INDEX_CHECK)
3627 ;
3628 #else
3629  noexcept;
3630 #endif
3631  INLINE l_ivector operator |(const l_ivector &rv, const ivector_slice &sl)
3633 #if(CXSC_INDEX_CHECK)
3634 ;
3635 #else
3636  noexcept;
3637 #endif
3638  INLINE l_ivector operator |(const l_ivector_slice &sl, const ivector &rv)
3640 #if(CXSC_INDEX_CHECK)
3641 ;
3642 #else
3643  noexcept;
3644 #endif
3645  INLINE l_ivector operator |(const l_ivector_slice &sl1, const ivector_slice &sl2)
3647 #if(CXSC_INDEX_CHECK)
3648 ;
3649 #else
3650  noexcept;
3651 #endif
3652 
3654  INLINE l_ivector & operator |=(l_ivector &rv1, const ivector &rv2)
3655 #if(CXSC_INDEX_CHECK)
3656 ;
3657 #else
3658  noexcept;
3659 #endif
3660  INLINE l_ivector &operator |=(l_ivector &rv, const ivector_slice &sl)
3662 #if(CXSC_INDEX_CHECK)
3663 ;
3664 #else
3665  noexcept;
3666 #endif
3667 
3669  INLINE l_ivector operator &(const ivector &rv1, const l_ivector &rv2)
3670 #if(CXSC_INDEX_CHECK)
3671 ;
3672 #else
3673  noexcept;
3674 #endif
3675  INLINE l_ivector operator &(const ivector &rv, const l_ivector_slice &sl)
3677 #if(CXSC_INDEX_CHECK)
3678 ;
3679 #else
3680  noexcept;
3681 #endif
3682  INLINE l_ivector operator &(const ivector_slice &sl, const l_ivector &rv)
3684 #if(CXSC_INDEX_CHECK)
3685 ;
3686 #else
3687  noexcept;
3688 #endif
3689  INLINE l_ivector operator &(const ivector_slice &sl1, const l_ivector_slice &sl2)
3691 #if(CXSC_INDEX_CHECK)
3692 ;
3693 #else
3694  noexcept;
3695 #endif
3696 
3698  INLINE l_ivector operator &(const l_ivector &rv1, const ivector &rv2)
3699 #if(CXSC_INDEX_CHECK)
3700 ;
3701 #else
3702  noexcept;
3703 #endif
3704  INLINE l_ivector operator &(const l_ivector &rv, const ivector_slice &sl)
3706 #if(CXSC_INDEX_CHECK)
3707 ;
3708 #else
3709  noexcept;
3710 #endif
3711  INLINE l_ivector operator &(const l_ivector_slice &sl, const ivector &rv)
3713 #if(CXSC_INDEX_CHECK)
3714 ;
3715 #else
3716  noexcept;
3717 #endif
3718  INLINE l_ivector operator &(const l_ivector_slice &sl1, const ivector_slice &sl2)
3720 #if(CXSC_INDEX_CHECK)
3721 ;
3722 #else
3723  noexcept;
3724 #endif
3725 
3727  INLINE l_ivector & operator &=(l_ivector &rv1, const ivector &rv2)
3728 #if(CXSC_INDEX_CHECK)
3729 ;
3730 #else
3731  noexcept;
3732 #endif
3733  INLINE l_ivector &operator &=(l_ivector &rv, const ivector_slice &sl)
3735 #if(CXSC_INDEX_CHECK)
3736 ;
3737 #else
3738  noexcept;
3739 #endif
3740 
3741 //------------- real x l_real ------------------------
3743  INLINE l_ivector operator |(const rvector &rv1, const l_rvector &rv2)
3744 #if(CXSC_INDEX_CHECK)
3745 ;
3746 #else
3747  noexcept;
3748 #endif
3749  INLINE l_ivector operator |(const l_rvector &rv1, const rvector &rv2)
3751 #if(CXSC_INDEX_CHECK)
3752 ;
3753 #else
3754  noexcept;
3755 #endif
3756  INLINE l_ivector operator |(const l_rvector &rv, const rvector_slice &sl)
3758 #if(CXSC_INDEX_CHECK)
3759 ;
3760 #else
3761  noexcept;
3762 #endif
3763  INLINE l_ivector operator |(const rvector_slice &sl,const l_rvector &rv)
3765 #if(CXSC_INDEX_CHECK)
3766 ;
3767 #else
3768  noexcept;
3769 #endif
3770  INLINE l_ivector operator |(const l_rvector_slice &sl, const rvector &rv)
3772 #if(CXSC_INDEX_CHECK)
3773 ;
3774 #else
3775  noexcept;
3776 #endif
3777  INLINE l_ivector operator |(const rvector &rv,const l_rvector_slice &sl)
3779 #if(CXSC_INDEX_CHECK)
3780 ;
3781 #else
3782  noexcept;
3783 #endif
3784  INLINE l_ivector operator |(const l_rvector_slice &sl1, const rvector_slice &sl2)
3786 #if(CXSC_INDEX_CHECK)
3787 ;
3788 #else
3789  noexcept;
3790 #endif
3791  INLINE l_ivector operator |(const rvector_slice &sl1, const l_rvector_slice &sl2)
3793 #if(CXSC_INDEX_CHECK)
3794 ;
3795 #else
3796  noexcept;
3797 #endif
3798 
3799 //------------- l_real x l_real ------------------------
3801  INLINE l_ivector operator |(const l_rvector &rv1, const l_rvector &rv2)
3802 #if(CXSC_INDEX_CHECK)
3803 ;
3804 #else
3805  noexcept;
3806 #endif
3807  INLINE l_ivector operator |(const l_rvector_slice &sl, const l_rvector &rv)
3809 #if(CXSC_INDEX_CHECK)
3810 ;
3811 #else
3812  noexcept;
3813 #endif
3814  INLINE l_ivector operator |(const l_rvector &rv,const l_rvector_slice &sl)
3816 #if(CXSC_INDEX_CHECK)
3817 ;
3818 #else
3819  noexcept;
3820 #endif
3821  INLINE l_ivector operator |(const l_rvector_slice &sl1, const l_rvector_slice &sl2)
3823 #if(CXSC_INDEX_CHECK)
3824 ;
3825 #else
3826  noexcept;
3827 #endif
3828 
3829 //-------------------------------- interval / l_real --------------------------------
3830 
3831  // multiplication in lrvecivec.hpp
3832 
3834  INLINE l_ivector operator +(const l_rvector &rv1, const ivector &rv2)
3835 #if(CXSC_INDEX_CHECK)
3836 ;
3837 #else
3838  noexcept;
3839 #endif
3840  INLINE l_ivector operator +(const l_rvector &rv, const ivector_slice &sl)
3842 #if(CXSC_INDEX_CHECK)
3843 ;
3844 #else
3845  noexcept;
3846 #endif
3847  INLINE l_ivector operator +(const l_rvector_slice &sl, const ivector &rv)
3849 #if(CXSC_INDEX_CHECK)
3850 ;
3851 #else
3852  noexcept;
3853 #endif
3854  INLINE l_ivector operator +(const l_rvector_slice &sl1, const ivector_slice &sl2)
3856 #if(CXSC_INDEX_CHECK)
3857 ;
3858 #else
3859  noexcept;
3860 #endif
3861 
3863  INLINE l_ivector operator +(const ivector &rv1, const l_rvector &rv2)
3864 #if(CXSC_INDEX_CHECK)
3865 ;
3866 #else
3867  noexcept;
3868 #endif
3869  INLINE l_ivector operator +(const ivector &rv, const l_rvector_slice &sl)
3871 #if(CXSC_INDEX_CHECK)
3872 ;
3873 #else
3874  noexcept;
3875 #endif
3876  INLINE l_ivector operator +(const ivector_slice &sl, const l_rvector &rv)
3878 #if(CXSC_INDEX_CHECK)
3879 ;
3880 #else
3881  noexcept;
3882 #endif
3883  INLINE l_ivector operator +(const ivector_slice &sl1, const l_rvector_slice &sl2)
3885 #if(CXSC_INDEX_CHECK)
3886 ;
3887 #else
3888  noexcept;
3889 #endif
3890 
3891 
3893  INLINE l_ivector operator -(const l_rvector &rv1, const ivector &rv2)
3894 #if(CXSC_INDEX_CHECK)
3895 ;
3896 #else
3897  noexcept;
3898 #endif
3899  INLINE l_ivector operator -(const l_rvector &rv, const ivector_slice &sl)
3901 #if(CXSC_INDEX_CHECK)
3902 ;
3903 #else
3904  noexcept;
3905 #endif
3906  INLINE l_ivector operator -(const l_rvector_slice &sl, const ivector &rv)
3908 #if(CXSC_INDEX_CHECK)
3909 ;
3910 #else
3911  noexcept;
3912 #endif
3913  INLINE l_ivector operator -(const l_rvector_slice &sl1, const ivector_slice &sl2)
3915 #if(CXSC_INDEX_CHECK)
3916 ;
3917 #else
3918  noexcept;
3919 #endif
3920 
3922  INLINE l_ivector operator -(const ivector &rv1, const l_rvector &rv2)
3923 #if(CXSC_INDEX_CHECK)
3924 ;
3925 #else
3926  noexcept;
3927 #endif
3928  INLINE l_ivector operator -(const ivector &rv, const l_rvector_slice &sl)
3930 #if(CXSC_INDEX_CHECK)
3931 ;
3932 #else
3933  noexcept;
3934 #endif
3935  INLINE l_ivector operator -(const ivector_slice &sl, const l_rvector &rv)
3937 #if(CXSC_INDEX_CHECK)
3938 ;
3939 #else
3940  noexcept;
3941 #endif
3942  INLINE l_ivector operator -(const ivector_slice &sl1, const l_rvector_slice &sl2)
3944 #if(CXSC_INDEX_CHECK)
3945 ;
3946 #else
3947  noexcept;
3948 #endif
3949 
3950 
3952  INLINE l_ivector operator |(const l_rvector &rv1, const ivector &rv2)
3953 #if(CXSC_INDEX_CHECK)
3954 ;
3955 #else
3956  noexcept;
3957 #endif
3958  INLINE l_ivector operator |(const l_rvector &rv, const ivector_slice &sl)
3960 #if(CXSC_INDEX_CHECK)
3961 ;
3962 #else
3963  noexcept;
3964 #endif
3965  INLINE l_ivector operator |(const l_rvector_slice &sl, const ivector &rv)
3967 #if(CXSC_INDEX_CHECK)
3968 ;
3969 #else
3970  noexcept;
3971 #endif
3972  INLINE l_ivector operator |(const l_rvector_slice &sl1, const ivector_slice &sl2)
3974 #if(CXSC_INDEX_CHECK)
3975 ;
3976 #else
3977  noexcept;
3978 #endif
3979 
3981  INLINE l_ivector operator |(const ivector &rv1, const l_rvector &rv2)
3982 #if(CXSC_INDEX_CHECK)
3983 ;
3984 #else
3985  noexcept;
3986 #endif
3987  INLINE l_ivector operator |(const ivector &rv, const l_rvector_slice &sl)
3989 #if(CXSC_INDEX_CHECK)
3990 ;
3991 #else
3992  noexcept;
3993 #endif
3994  INLINE l_ivector operator |(const ivector_slice &sl, const l_rvector &rv)
3996 #if(CXSC_INDEX_CHECK)
3997 ;
3998 #else
3999  noexcept;
4000 #endif
4001  INLINE l_ivector operator |(const ivector_slice &sl1, const l_rvector_slice &sl2)
4003 #if(CXSC_INDEX_CHECK)
4004 ;
4005 #else
4006  noexcept;
4007 #endif
4008 
4010  INLINE l_ivector operator &(const l_rvector &rv1, const ivector &rv2)
4011 #if(CXSC_INDEX_CHECK)
4012 ;
4013 #else
4014  noexcept;
4015 #endif
4016  INLINE l_ivector operator &(const l_rvector &rv, const ivector_slice &sl)
4018 #if(CXSC_INDEX_CHECK)
4019 ;
4020 #else
4021  noexcept;
4022 #endif
4023  INLINE l_ivector operator &(const l_rvector_slice &sl, const ivector &rv)
4025 #if(CXSC_INDEX_CHECK)
4026 ;
4027 #else
4028  noexcept;
4029 #endif
4030  INLINE l_ivector operator &(const l_rvector_slice &sl1, const ivector_slice &sl2)
4032 #if(CXSC_INDEX_CHECK)
4033 ;
4034 #else
4035  noexcept;
4036 #endif
4037 
4039  INLINE l_ivector operator &(const ivector &rv1, const l_rvector &rv2)
4040 #if(CXSC_INDEX_CHECK)
4041 ;
4042 #else
4043  noexcept;
4044 #endif
4045  INLINE l_ivector operator &(const ivector &rv, const l_rvector_slice &sl)
4047 #if(CXSC_INDEX_CHECK)
4048 ;
4049 #else
4050  noexcept;
4051 #endif
4052  INLINE l_ivector operator &(const ivector_slice &sl, const l_rvector &rv)
4054 #if(CXSC_INDEX_CHECK)
4055 ;
4056 #else
4057  noexcept;
4058 #endif
4059  INLINE l_ivector operator &(const ivector_slice &sl1, const l_rvector_slice &sl2)
4061 #if(CXSC_INDEX_CHECK)
4062 ;
4063 #else
4064  noexcept;
4065 #endif
4066 
4067 } // namespace cxsc
4068 
4069 #ifdef _CXSC_INCL_INL
4070 #include "vector.inl"
4071 #include "l_ivector.inl"
4072 #endif
4073 
4074 #ifdef _CXSC_RMATRIX_HPP_INCLUDED
4075 # ifdef _CXSC_INCL_INL
4076 # include "livecrmat.inl"
4077 # else
4078 # include "livecrmat.hpp"
4079 # endif
4080 #endif
4081 
4082 #ifdef _CXSC_LRMATRIX_HPP_INCLUDED
4083 # ifdef _CXSC_INCL_INL
4084 # include "liveclrmat.inl"
4085 # else
4086 # include "liveclrmat.hpp"
4087 # endif
4088 #endif
4089 
4090 #ifdef _CXSC_IMATRIX_HPP_INCLUDED
4091 # ifdef _CXSC_INCL_INL
4092 # include "livecimat.inl"
4093 # else
4094 # include "livecimat.hpp"
4095 # endif
4096 #endif
4097 
4098 
4099 #endif
4100 
cxsc::mid
cvector mid(const cimatrix_subv &mv) noexcept
Returns the middle of the matrix.
Definition: cimatrix.inl:739
cxsc::l_ivector_slice::operator+=
l_ivector_slice & operator+=(const l_ivector &rv) noexcept
Implementation of addition and allocation operation.
Definition: l_ivector.inl:697
cxsc::l_rmatrix_slice
The Multiple-Precision Data Type l_rmatrix_slice.
Definition: l_rmatrix.hpp:1000
cxsc::l_ivector::Lb
friend int Lb(const l_ivector &rv) noexcept
Returns the lower bound of the vector.
Definition: l_ivector.hpp:825
cxsc::imatrix_slice
The Data Type imatrix_slice.
Definition: imatrix.hpp:1442
cxsc::l_ivector_slice::operator|=
l_ivector_slice & operator|=(const l_ivector &rv) noexcept
Allocates the convex hull of the arguments to the first argument.
Definition: l_ivector.inl:813
cxsc::l_ivector_slice::operator/=
l_ivector_slice & operator/=(const l_interval &r) noexcept
Implementation of division and allocation operation.
Definition: l_ivector.inl:502
cxsc::l_rmatrix_subv
The Multiple-Precision Data Type l_rmatrix_subv.
Definition: l_rmatrix.hpp:47
cxsc::imatrix_subv
The Data Type imatrix_subv.
Definition: imatrix.hpp:56
cxsc::interval
The Scalar Type interval.
Definition: interval.hpp:55
cxsc::operator*=
cimatrix & operator*=(cimatrix &m, const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
Definition: cimatrix.inl:1605
cxsc::operator/
civector operator/(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of division operation.
Definition: cimatrix.inl:730
cxsc::rmatrix
The Data Type rmatrix.
Definition: rmatrix.hpp:471
cxsc::l_ivector::VecLen
friend int VecLen(const l_ivector &rv) noexcept
Returns the dimension of the vector.
Definition: l_ivector.hpp:829
cxsc::l_ivector_slice::l_ivector_slice
l_ivector_slice(const l_ivector_slice &a) noexcept
Constructor of class l_ivector_slice.
Definition: l_ivector.hpp:1320
cxsc::l_ivector::operator[]
l_interval & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector.
Definition: l_ivector.inl:141
cxsc::abs
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737
cxsc::operator/=
cimatrix & operator/=(cimatrix &m, const cinterval &c) noexcept
Implementation of division and allocation operation.
Definition: cimatrix.inl:1623
cxsc::l_ivector_slice::Ub
friend int Ub(const l_ivector_slice &sl) noexcept
Returns the upper bound of the vector.
Definition: l_ivector.hpp:1468
cxsc::l_rmatrix
The Multiple-Precision Data Type l_rmatrix.
Definition: l_rmatrix.hpp:416
cxsc::rvector
The Data Type rvector.
Definition: rvector.hpp:58
cxsc::l_ivector::SetLb
friend l_ivector & SetLb(l_ivector &rv, const int &l) noexcept
Sets the lower bound of the vector.
Definition: l_ivector.hpp:831
cxsc::idotprecision
The Data Type idotprecision.
Definition: idot.hpp:48
cxsc::l_ivector_slice::operator&=
l_ivector_slice & operator&=(const l_ivector &rv) noexcept
Allocates the intersection of the arguments to the first argument.
Definition: l_ivector.inl:870
cxsc::_l_ivector
l_ivector _l_ivector(const l_interval &r) noexcept
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC.
Definition: l_ivector.inl:252
cxsc::l_imatrix
The Multiple-Precision Data Type l_imatrix.
Definition: l_imatrix.hpp:726
cxsc::ivector_slice
The Data Type ivector_slice.
Definition: ivector.hpp:963
cxsc::l_ivector_slice::VecLen
friend int VecLen(const l_ivector_slice &sl) noexcept
Returns the dimension of the vector.
Definition: l_ivector.hpp:1470
cxsc::rvector_slice
The Data Type rvector_slice.
Definition: rvector.hpp:1064
cxsc::imatrix
The Data Type imatrix.
Definition: imatrix.hpp:660
cxsc::operator*
civector operator*(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of multiplication operation.
Definition: cimatrix.inl:731
cxsc::l_ivector_slice::operator[]
l_interval & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector.
Definition: l_ivector.inl:154
cxsc::l_imatrix_slice
The Multiple-Precision Data Type l_imatrix_slice.
Definition: l_imatrix.hpp:1280
cxsc::l_interval
The Multiple-Precision Data Type l_interval.
Definition: l_interval.hpp:72
cxsc::ivector
The Data Type ivector.
Definition: ivector.hpp:55
cxsc::l_rvector_slice
The Multiple-Precision Data Type l_rvector_slice.
Definition: l_rvector.hpp:745
cxsc::l_ivector_slice::operator()
l_ivector_slice & operator()() noexcept
Operator for accessing the whole vector.
Definition: l_ivector.hpp:1479
cxsc::rmatrix_subv
The Data Type rmatrix_subv.
Definition: rmatrix.hpp:54
cxsc::SetUncheckedInf
cimatrix_subv & SetUncheckedInf(cimatrix_subv &iv, const complex &r) noexcept
Returns the matrix with the new unchecked given infimum value.
Definition: cimatrix.inl:890
cxsc
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
cxsc::l_ivector_slice::l_ivector_slice
l_ivector_slice(l_ivector &a, const int &lb, const int &ub) noexcept
Constructor of class l_ivector_slice.
Definition: l_ivector.hpp:1315
cxsc::operator+=
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc) noexcept
Implementation of standard algebraic addition and allocation operation.
Definition: cdot.inl:251
cxsc::l_real
The Multiple-Precision Data Type l_real.
Definition: l_real.hpp:78
cxsc::l_ivector_slice::Lb
friend int Lb(const l_ivector_slice &sl) noexcept
Returns the lower bound of the vector.
Definition: l_ivector.hpp:1466
cxsc::diam
cvector diam(const cimatrix_subv &mv) noexcept
Returns the diameter of the matrix.
Definition: cimatrix.inl:738
cxsc::rmatrix_slice
The Data Type rmatrix_slice.
Definition: rmatrix.hpp:1443
cxsc::l_ivector::operator()
l_ivector & operator()() noexcept
Operator for accessing the whole vector.
Definition: l_ivector.hpp:842
cxsc::l_rvector
The Multiple-Precision Data Type l_rvector.
Definition: l_rvector.hpp:54
cxsc::l_ivector_slice::operator-=
l_ivector_slice & operator-=(const l_ivector &rv) noexcept
Implementation of subtraction and allocation operation.
Definition: l_ivector.inl:756
cxsc::l_ivector_slice
The Multiple-Precision Data Type l_ivector_slice.
Definition: l_ivector.hpp:871
cxsc::l_ivector
The Multiple-Precision Data Type l_ivector.
Definition: l_ivector.hpp:55
cxsc::l_ivector_slice::operator=
l_ivector_slice & operator=(const l_ivector_slice &sl) noexcept
Implementation of standard assigning operator.
Definition: l_ivector.inl:314
cxsc::Resize
void Resize(cimatrix &A) noexcept
Resizes the matrix.
Definition: cimatrix.inl:1211
cxsc::l_ivector::SetUb
friend l_ivector & SetUb(l_ivector &rv, const int &u) noexcept
Sets the upper bound of the vector.
Definition: l_ivector.hpp:833
cxsc::l_ivector::Ub
friend int Ub(const l_ivector &rv) noexcept
Returns the upper bound of the vector.
Definition: l_ivector.hpp:827
cxsc::l_ivector::l_ivector
l_ivector() noexcept
Constructor of class l_ivector.
Definition: l_ivector.inl:31
cxsc::l_imatrix_subv
The Multiple-Precision Data Type l_imatrix_subv.
Definition: l_imatrix.hpp:47
cxsc::l_ivector_slice::l_ivector_slice
l_ivector_slice(l_ivector_slice &a, const int &lb, const int &ub) noexcept
Constructor of class l_ivector_slice.
Definition: l_ivector.hpp:1317
cxsc::l_interval::l_interval
l_interval() noexcept
Constructor of class l_interval.
Definition: l_interval.inl:45
cxsc::l_ivector::operator=
l_ivector & operator=(const l_ivector &rv) noexcept
Implementation of standard assigning operator.
Definition: l_ivector.inl:311
cxsc::l_ivector_slice::operator*=
l_ivector_slice & operator*=(const l_interval &r) noexcept
Implementation of multiplication and allocation operation.
Definition: l_ivector.inl:497
cxsc::real
The Scalar Type real.
Definition: real.hpp:114