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
44namespace cxsc {
45
46class l_ivector_slice;
47
49
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
68template <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
74template <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
102template <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
108template <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
133template <class V,class MV> friend V &_vmvsetinf(V &rv,const MV &v)
134#if(CXSC_INDEX_CHECK)
135;
136#else
137 noexcept;
138#endif
139template <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
169template <class V,class MV> friend V &_vmvusetinf(V &rv,const MV &v)
170#if(CXSC_INDEX_CHECK)
171;
172#else
173 noexcept;
174#endif
175template <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;
187template <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
409template <class MV,class V> friend MV &_mvvsectassign(MV &v,const V &rv)
410#if(CXSC_INDEX_CHECK)
411;
412#else
413 noexcept;
414#endif
415template <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
433template <class MV,class V> friend MV &_mvvconvassign(MV &v,const V &rv)
434#if(CXSC_INDEX_CHECK)
435;
436#else
437 noexcept;
438#endif
439template <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
488template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
489#if(CXSC_INDEX_CHECK)
490;
491#else
492 noexcept;
493#endif
494template <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;
501template <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 ---------------
530template <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
537template <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
615 explicit INLINE l_ivector(const class index &i) noexcept; // for backwards compatibility
616#endif
618 explicit INLINE l_ivector(const int &i1,const int &i2)
619#if(CXSC_INDEX_CHECK)
620;
621#else
622 noexcept;
623#endif
625 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
636 explicit INLINE l_ivector(const l_imatrix_slice &sl)
637#if(CXSC_INDEX_CHECK)
638;
639#else
640 noexcept;
641#endif
643 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
661 explicit INLINE l_ivector(const rmatrix_slice &sl)
662#if(CXSC_INDEX_CHECK)
663;
664#else
665 noexcept;
666#endif
668 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
685 explicit INLINE l_ivector(const l_rmatrix_slice &sl)
686#if(CXSC_INDEX_CHECK)
687;
688#else
689 noexcept;
690#endif
692 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
709 explicit INLINE l_ivector(const imatrix_slice &sl)
710#if(CXSC_INDEX_CHECK)
711;
712#else
713 noexcept;
714#endif
716 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
733 INLINE l_ivector &operator =(const l_imatrix_slice &)
734#if(CXSC_INDEX_CHECK)
735;
736#else
737 noexcept;
738#endif
740 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
756 INLINE l_ivector &operator =(const rmatrix_slice &)
757#if(CXSC_INDEX_CHECK)
758;
759#else
760 noexcept;
761#endif
763 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
780 INLINE l_ivector &operator =(const l_rmatrix_slice &)
781#if(CXSC_INDEX_CHECK)
782;
783#else
784 noexcept;
785#endif
787 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
804 INLINE l_ivector &operator =(const imatrix_slice &)
805#if(CXSC_INDEX_CHECK)
806;
807#else
808 noexcept;
809#endif
811 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
825 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
842 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
851 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
1155template <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
1161template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) noexcept;
1162template <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 ----------
1229template <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
1235template <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
1331 INLINE l_ivector_slice & operator =(const l_ivector &rv)
1332#if(CXSC_INDEX_CHECK)
1333;
1334#else
1335 noexcept;
1336#endif
1338 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
1347 INLINE l_ivector_slice & operator =(const l_imatrix_slice &m)
1348#if(CXSC_INDEX_CHECK)
1349;
1350#else
1351 noexcept;
1352#endif
1354 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
1364 INLINE l_ivector_slice & operator =(const rvector &rv)
1365#if(CXSC_INDEX_CHECK)
1366;
1367#else
1368 noexcept;
1369#endif
1371 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
1380 INLINE l_ivector_slice & operator =(const rmatrix_slice &m)
1381#if(CXSC_INDEX_CHECK)
1382;
1383#else
1384 noexcept;
1385#endif
1387 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
1398 INLINE l_ivector_slice & operator =(const l_rvector &rv)
1399#if(CXSC_INDEX_CHECK)
1400;
1401#else
1402 noexcept;
1403#endif
1405 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
1414 INLINE l_ivector_slice & operator =(const l_rmatrix_slice &m)
1415#if(CXSC_INDEX_CHECK)
1416;
1417#else
1418 noexcept;
1419#endif
1421 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
1432 INLINE l_ivector_slice & operator =(const ivector &rv)
1433#if(CXSC_INDEX_CHECK)
1434;
1435#else
1436 noexcept;
1437#endif
1439 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
1448 INLINE l_ivector_slice & operator =(const imatrix_slice &m)
1449#if(CXSC_INDEX_CHECK)
1450;
1451#else
1452 noexcept;
1453#endif
1455 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
1466 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
1479 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
1488 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
1509#if(CXSC_INDEX_CHECK)
1510;
1511#else
1512 noexcept;
1513#endif
1515 INLINE l_ivector_slice &operator +=(const l_ivector &rv)
1516#if(CXSC_INDEX_CHECK)
1517;
1518#else
1519 noexcept;
1520#endif
1522 INLINE l_ivector_slice &operator +=(const l_ivector_slice &sl2)
1523#if(CXSC_INDEX_CHECK)
1524;
1525#else
1526 noexcept;
1527#endif
1529 INLINE l_ivector_slice &operator -=(const l_ivector &rv)
1530#if(CXSC_INDEX_CHECK)
1531;
1532#else
1533 noexcept;
1534#endif
1536 INLINE l_ivector_slice &operator -=(const l_ivector_slice &sl2)
1537#if(CXSC_INDEX_CHECK)
1538;
1539#else
1540 noexcept;
1541#endif
1543 INLINE l_ivector_slice &operator |=(const l_ivector &rv)
1544#if(CXSC_INDEX_CHECK)
1545;
1546#else
1547 noexcept;
1548#endif
1550 INLINE l_ivector_slice &operator |=(const l_ivector_slice &sl2)
1551#if(CXSC_INDEX_CHECK)
1552;
1553#else
1554 noexcept;
1555#endif
1557 INLINE l_ivector_slice &operator &=(const l_ivector &rv)
1558#if(CXSC_INDEX_CHECK)
1559;
1560#else
1561 noexcept;
1562#endif
1564 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
1583 INLINE l_ivector_slice &operator +=(const rvector_slice &sl2)
1584#if(CXSC_INDEX_CHECK)
1585;
1586#else
1587 noexcept;
1588#endif
1590 INLINE l_ivector_slice &operator -=(const rvector &rv)
1591#if(CXSC_INDEX_CHECK)
1592;
1593#else
1594 noexcept;
1595#endif
1597 INLINE l_ivector_slice &operator -=(const rvector_slice &sl2)
1598#if(CXSC_INDEX_CHECK)
1599;
1600#else
1601 noexcept;
1602#endif
1604 INLINE l_ivector_slice &operator |=(const rvector &rv)
1605#if(CXSC_INDEX_CHECK)
1606;
1607#else
1608 noexcept;
1609#endif
1611 INLINE l_ivector_slice &operator |=(const rvector_slice &sl2)
1612#if(CXSC_INDEX_CHECK)
1613;
1614#else
1615 noexcept;
1616#endif
1618 INLINE l_ivector_slice &operator &=(const rvector &rv)
1619#if(CXSC_INDEX_CHECK)
1620;
1621#else
1622 noexcept;
1623#endif
1625 INLINE l_ivector_slice &operator &=(const rvector_slice &sl2)
1626#if(CXSC_INDEX_CHECK)
1627;
1628#else
1629 noexcept;
1630#endif
1632 INLINE l_ivector_slice &operator *=(const rmatrix &m)
1633#if(CXSC_INDEX_CHECK)
1634;
1635#else
1636 noexcept;
1637#endif
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
1658 INLINE l_ivector_slice &operator +=(const l_rvector_slice &sl2)
1659#if(CXSC_INDEX_CHECK)
1660;
1661#else
1662 noexcept;
1663#endif
1665 INLINE l_ivector_slice &operator -=(const l_rvector &rv)
1666#if(CXSC_INDEX_CHECK)
1667;
1668#else
1669 noexcept;
1670#endif
1672 INLINE l_ivector_slice &operator -=(const l_rvector_slice &sl2)
1673#if(CXSC_INDEX_CHECK)
1674;
1675#else
1676 noexcept;
1677#endif
1679 INLINE l_ivector_slice &operator |=(const l_rvector &rv)
1680#if(CXSC_INDEX_CHECK)
1681;
1682#else
1683 noexcept;
1684#endif
1686 INLINE l_ivector_slice &operator |=(const l_rvector_slice &sl2)
1687#if(CXSC_INDEX_CHECK)
1688;
1689#else
1690 noexcept;
1691#endif
1693 INLINE l_ivector_slice &operator &=(const l_rvector &rv)
1694#if(CXSC_INDEX_CHECK)
1695;
1696#else
1697 noexcept;
1698#endif
1700 INLINE l_ivector_slice &operator &=(const l_rvector_slice &sl2)
1701#if(CXSC_INDEX_CHECK)
1702;
1703#else
1704 noexcept;
1705#endif
1707 INLINE l_ivector_slice &operator *=(const l_rmatrix &m)
1708#if(CXSC_INDEX_CHECK)
1709;
1710#else
1711 noexcept;
1712#endif
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
1733 INLINE l_ivector_slice &operator +=(const ivector_slice &sl2)
1734#if(CXSC_INDEX_CHECK)
1735;
1736#else
1737 noexcept;
1738#endif
1740 INLINE l_ivector_slice &operator -=(const ivector &rv)
1741#if(CXSC_INDEX_CHECK)
1742;
1743#else
1744 noexcept;
1745#endif
1747 INLINE l_ivector_slice &operator -=(const ivector_slice &sl2)
1748#if(CXSC_INDEX_CHECK)
1749;
1750#else
1751 noexcept;
1752#endif
1754 INLINE l_ivector_slice &operator |=(const ivector &rv)
1755#if(CXSC_INDEX_CHECK)
1756;
1757#else
1758 noexcept;
1759#endif
1761 INLINE l_ivector_slice &operator |=(const ivector_slice &sl2)
1762#if(CXSC_INDEX_CHECK)
1763;
1764#else
1765 noexcept;
1766#endif
1768 INLINE l_ivector_slice &operator &=(const ivector &rv)
1769#if(CXSC_INDEX_CHECK)
1770;
1771#else
1772 noexcept;
1773#endif
1775 INLINE l_ivector_slice &operator &=(const ivector_slice &sl2)
1776#if(CXSC_INDEX_CHECK)
1777;
1778#else
1779 noexcept;
1780#endif
1782 INLINE l_ivector_slice &operator *=(const imatrix &m)
1783#if(CXSC_INDEX_CHECK)
1784;
1785#else
1786 noexcept;
1787#endif
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
1825 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
1832 INLINE l_ivector &SetInf(l_ivector &iv,const l_rvector_slice &rv)
1833#if(CXSC_INDEX_CHECK)
1834;
1835#else
1836 noexcept;
1837#endif
1839 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
1846 INLINE l_ivector &UncheckedSetInf(l_ivector &iv,const l_rvector &rv)
1847#if(CXSC_INDEX_CHECK)
1848;
1849#else
1850 noexcept;
1851#endif
1853 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
1860 INLINE l_ivector &UncheckedSetInf(l_ivector &iv,const l_rvector_slice &rv)
1861#if(CXSC_INDEX_CHECK)
1862;
1863#else
1864 noexcept;
1865#endif
1867 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
1882 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
1889 INLINE l_ivector &SetSup(l_ivector &iv,const l_rvector_slice &rv)
1890#if(CXSC_INDEX_CHECK)
1891;
1892#else
1893 noexcept;
1894#endif
1896 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
1903 INLINE l_ivector &UncheckedSetSup(l_ivector &iv,const l_rvector &rv)
1904#if(CXSC_INDEX_CHECK)
1905;
1906#else
1907 noexcept;
1908#endif
1910 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
1917 INLINE l_ivector &UncheckedSetSup(l_ivector &iv,const l_rvector_slice &rv)
1918#if(CXSC_INDEX_CHECK)
1919;
1920#else
1921 noexcept;
1922#endif
1924 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
1959 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
2137 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
2144 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
2151 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
2158 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
2165 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
2180 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
2187 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
2194 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
2214 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
2221 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
2228 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
2235 INLINE l_ivector & operator +=(l_ivector &rv1, const l_ivector &rv2)
2236#if(CXSC_INDEX_CHECK)
2237;
2238#else
2239 noexcept;
2240#endif
2242 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
2261 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
2268 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
2275 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
2282 INLINE l_ivector & operator -=(l_ivector &rv1, const l_ivector &rv2)
2283#if(CXSC_INDEX_CHECK)
2284;
2285#else
2286 noexcept;
2287#endif
2289 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
2304 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
2311 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
2318 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
2325 INLINE l_ivector & operator |=(l_ivector &rv1, const l_ivector &rv2)
2326#if(CXSC_INDEX_CHECK)
2327;
2328#else
2329 noexcept;
2330#endif
2332 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
2347 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
2354 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
2361 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
2368 INLINE l_ivector & operator &=(l_ivector &rv1, const l_ivector &rv2)
2369#if(CXSC_INDEX_CHECK)
2370;
2371#else
2372 noexcept;
2373#endif
2375 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
2441 INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const rvector &rv2)
2442#if(CXSC_INDEX_CHECK)
2443;
2444#else
2445 noexcept;
2446#endif
2448 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
2455 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
2462 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
2469 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
2476 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
2483 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
2490 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
2497 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
2504 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
2511 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
2526 INLINE l_interval operator *(const rvector_slice &sl, const l_ivector &rv)
2527#if(CXSC_INDEX_CHECK)
2528;
2529#else
2530 noexcept;
2531#endif
2533 INLINE l_interval operator *(const rvector &rv, const l_ivector_slice &sl)
2534#if(CXSC_INDEX_CHECK)
2535;
2536#else
2537 noexcept;
2538#endif
2540 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
2555 INLINE l_interval operator *(const l_ivector_slice &sl, const rvector &rv)
2556#if(CXSC_INDEX_CHECK)
2557;
2558#else
2559 noexcept;
2560#endif
2562 INLINE l_interval operator *(const l_ivector &rv, const rvector_slice &sl)
2563#if(CXSC_INDEX_CHECK)
2564;
2565#else
2566 noexcept;
2567#endif
2569 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
2584 INLINE l_ivector operator +(const rvector &rv, const l_ivector_slice &sl)
2585#if(CXSC_INDEX_CHECK)
2586;
2587#else
2588 noexcept;
2589#endif
2591 INLINE l_ivector operator +(const rvector_slice &sl, const l_ivector &rv)
2592#if(CXSC_INDEX_CHECK)
2593;
2594#else
2595 noexcept;
2596#endif
2598 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
2613 INLINE l_ivector operator +(const l_ivector &rv, const rvector_slice &sl)
2614#if(CXSC_INDEX_CHECK)
2615;
2616#else
2617 noexcept;
2618#endif
2620 INLINE l_ivector operator +(const l_ivector_slice &sl, const rvector &rv)
2621#if(CXSC_INDEX_CHECK)
2622;
2623#else
2624 noexcept;
2625#endif
2627 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
2642 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
2657 INLINE l_ivector operator -(const rvector &rv, const l_ivector_slice &sl)
2658#if(CXSC_INDEX_CHECK)
2659;
2660#else
2661 noexcept;
2662#endif
2664 INLINE l_ivector operator -(const rvector_slice &sl, const l_ivector &rv)
2665#if(CXSC_INDEX_CHECK)
2666;
2667#else
2668 noexcept;
2669#endif
2671 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
2686 INLINE l_ivector operator -(const l_ivector &rv, const rvector_slice &sl)
2687#if(CXSC_INDEX_CHECK)
2688;
2689#else
2690 noexcept;
2691#endif
2693 INLINE l_ivector operator -(const l_ivector_slice &sl, const rvector &rv)
2694#if(CXSC_INDEX_CHECK)
2695;
2696#else
2697 noexcept;
2698#endif
2700 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
2715 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
2730 INLINE l_ivector operator |(const rvector &rv, const l_ivector_slice &sl)
2731#if(CXSC_INDEX_CHECK)
2732;
2733#else
2734 noexcept;
2735#endif
2737 INLINE l_ivector operator |(const rvector_slice &sl, const l_ivector &rv)
2738#if(CXSC_INDEX_CHECK)
2739;
2740#else
2741 noexcept;
2742#endif
2744 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
2759 INLINE l_ivector operator |(const l_ivector &rv, const rvector_slice &sl)
2760#if(CXSC_INDEX_CHECK)
2761;
2762#else
2763 noexcept;
2764#endif
2766 INLINE l_ivector operator |(const l_ivector_slice &sl, const rvector &rv)
2767#if(CXSC_INDEX_CHECK)
2768;
2769#else
2770 noexcept;
2771#endif
2773 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
2788 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
2803 INLINE l_ivector operator &(const rvector &rv, const l_ivector_slice &sl)
2804#if(CXSC_INDEX_CHECK)
2805;
2806#else
2807 noexcept;
2808#endif
2810 INLINE l_ivector operator &(const rvector_slice &sl, const l_ivector &rv)
2811#if(CXSC_INDEX_CHECK)
2812;
2813#else
2814 noexcept;
2815#endif
2817 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
2832 INLINE l_ivector operator &(const l_ivector &rv, const rvector_slice &sl)
2833#if(CXSC_INDEX_CHECK)
2834;
2835#else
2836 noexcept;
2837#endif
2839 INLINE l_ivector operator &(const l_ivector_slice &sl, const rvector &rv)
2840#if(CXSC_INDEX_CHECK)
2841;
2842#else
2843 noexcept;
2844#endif
2846 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
2861 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
2877 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
2884 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
2891 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
2898 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
2905 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
2912 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
2919 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
2926 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
2933 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
2940 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
2947 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
2962 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
2969 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
2976 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
2991 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
2998 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
3005 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
3020 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
3027 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
3034 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
3049 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
3056 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
3063 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
3078 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
3093 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
3100 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
3107 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
3122 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
3129 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
3136 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
3151 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
3166 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
3173 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
3180 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
3195 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
3202 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
3209 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
3224 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
3239 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
3246 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
3253 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
3268 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
3275 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
3282 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
3297 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
3314 INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const ivector &rv2)
3315#if(CXSC_INDEX_CHECK)
3316;
3317#else
3318 noexcept;
3319#endif
3321 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
3328 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
3335 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
3342 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
3349 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
3356 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
3363 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
3370 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
3377 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
3384 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
3399 INLINE l_interval operator *(const ivector_slice &sl, const l_ivector &rv)
3400#if(CXSC_INDEX_CHECK)
3401;
3402#else
3403 noexcept;
3404#endif
3406 INLINE l_interval operator *(const ivector &rv, const l_ivector_slice &sl)
3407#if(CXSC_INDEX_CHECK)
3408;
3409#else
3410 noexcept;
3411#endif
3413 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
3428 INLINE l_interval operator *(const l_ivector_slice &sl, const ivector &rv)
3429#if(CXSC_INDEX_CHECK)
3430;
3431#else
3432 noexcept;
3433#endif
3435 INLINE l_interval operator *(const l_ivector &rv, const ivector_slice &sl)
3436#if(CXSC_INDEX_CHECK)
3437;
3438#else
3439 noexcept;
3440#endif
3442 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
3457 INLINE l_ivector operator +(const ivector &rv, const l_ivector_slice &sl)
3458#if(CXSC_INDEX_CHECK)
3459;
3460#else
3461 noexcept;
3462#endif
3464 INLINE l_ivector operator +(const ivector_slice &sl, const l_ivector &rv)
3465#if(CXSC_INDEX_CHECK)
3466;
3467#else
3468 noexcept;
3469#endif
3471 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
3486 INLINE l_ivector operator +(const l_ivector &rv, const ivector_slice &sl)
3487#if(CXSC_INDEX_CHECK)
3488;
3489#else
3490 noexcept;
3491#endif
3493 INLINE l_ivector operator +(const l_ivector_slice &sl, const ivector &rv)
3494#if(CXSC_INDEX_CHECK)
3495;
3496#else
3497 noexcept;
3498#endif
3500 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
3515 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
3530 INLINE l_ivector operator -(const ivector &rv, const l_ivector_slice &sl)
3531#if(CXSC_INDEX_CHECK)
3532;
3533#else
3534 noexcept;
3535#endif
3537 INLINE l_ivector operator -(const ivector_slice &sl, const l_ivector &rv)
3538#if(CXSC_INDEX_CHECK)
3539;
3540#else
3541 noexcept;
3542#endif
3544 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
3559 INLINE l_ivector operator -(const l_ivector &rv, const ivector_slice &sl)
3560#if(CXSC_INDEX_CHECK)
3561;
3562#else
3563 noexcept;
3564#endif
3566 INLINE l_ivector operator -(const l_ivector_slice &sl, const ivector &rv)
3567#if(CXSC_INDEX_CHECK)
3568;
3569#else
3570 noexcept;
3571#endif
3573 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
3588 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
3603 INLINE l_ivector operator |(const ivector &rv, const l_ivector_slice &sl)
3604#if(CXSC_INDEX_CHECK)
3605;
3606#else
3607 noexcept;
3608#endif
3610 INLINE l_ivector operator |(const ivector_slice &sl, const l_ivector &rv)
3611#if(CXSC_INDEX_CHECK)
3612;
3613#else
3614 noexcept;
3615#endif
3617 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
3632 INLINE l_ivector operator |(const l_ivector &rv, const ivector_slice &sl)
3633#if(CXSC_INDEX_CHECK)
3634;
3635#else
3636 noexcept;
3637#endif
3639 INLINE l_ivector operator |(const l_ivector_slice &sl, const ivector &rv)
3640#if(CXSC_INDEX_CHECK)
3641;
3642#else
3643 noexcept;
3644#endif
3646 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
3661 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
3676 INLINE l_ivector operator &(const ivector &rv, const l_ivector_slice &sl)
3677#if(CXSC_INDEX_CHECK)
3678;
3679#else
3680 noexcept;
3681#endif
3683 INLINE l_ivector operator &(const ivector_slice &sl, const l_ivector &rv)
3684#if(CXSC_INDEX_CHECK)
3685;
3686#else
3687 noexcept;
3688#endif
3690 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
3705 INLINE l_ivector operator &(const l_ivector &rv, const ivector_slice &sl)
3706#if(CXSC_INDEX_CHECK)
3707;
3708#else
3709 noexcept;
3710#endif
3712 INLINE l_ivector operator &(const l_ivector_slice &sl, const ivector &rv)
3713#if(CXSC_INDEX_CHECK)
3714;
3715#else
3716 noexcept;
3717#endif
3719 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
3734 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
3750 INLINE l_ivector operator |(const l_rvector &rv1, const rvector &rv2)
3751#if(CXSC_INDEX_CHECK)
3752;
3753#else
3754 noexcept;
3755#endif
3757 INLINE l_ivector operator |(const l_rvector &rv, const rvector_slice &sl)
3758#if(CXSC_INDEX_CHECK)
3759;
3760#else
3761 noexcept;
3762#endif
3764 INLINE l_ivector operator |(const rvector_slice &sl,const l_rvector &rv)
3765#if(CXSC_INDEX_CHECK)
3766;
3767#else
3768 noexcept;
3769#endif
3771 INLINE l_ivector operator |(const l_rvector_slice &sl, const rvector &rv)
3772#if(CXSC_INDEX_CHECK)
3773;
3774#else
3775 noexcept;
3776#endif
3778 INLINE l_ivector operator |(const rvector &rv,const l_rvector_slice &sl)
3779#if(CXSC_INDEX_CHECK)
3780;
3781#else
3782 noexcept;
3783#endif
3785 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
3792 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
3808 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
3815 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
3822 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
3841 INLINE l_ivector operator +(const l_rvector &rv, const ivector_slice &sl)
3842#if(CXSC_INDEX_CHECK)
3843;
3844#else
3845 noexcept;
3846#endif
3848 INLINE l_ivector operator +(const l_rvector_slice &sl, const ivector &rv)
3849#if(CXSC_INDEX_CHECK)
3850;
3851#else
3852 noexcept;
3853#endif
3855 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
3870 INLINE l_ivector operator +(const ivector &rv, const l_rvector_slice &sl)
3871#if(CXSC_INDEX_CHECK)
3872;
3873#else
3874 noexcept;
3875#endif
3877 INLINE l_ivector operator +(const ivector_slice &sl, const l_rvector &rv)
3878#if(CXSC_INDEX_CHECK)
3879;
3880#else
3881 noexcept;
3882#endif
3884 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
3900 INLINE l_ivector operator -(const l_rvector &rv, const ivector_slice &sl)
3901#if(CXSC_INDEX_CHECK)
3902;
3903#else
3904 noexcept;
3905#endif
3907 INLINE l_ivector operator -(const l_rvector_slice &sl, const ivector &rv)
3908#if(CXSC_INDEX_CHECK)
3909;
3910#else
3911 noexcept;
3912#endif
3914 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
3929 INLINE l_ivector operator -(const ivector &rv, const l_rvector_slice &sl)
3930#if(CXSC_INDEX_CHECK)
3931;
3932#else
3933 noexcept;
3934#endif
3936 INLINE l_ivector operator -(const ivector_slice &sl, const l_rvector &rv)
3937#if(CXSC_INDEX_CHECK)
3938;
3939#else
3940 noexcept;
3941#endif
3943 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
3959 INLINE l_ivector operator |(const l_rvector &rv, const ivector_slice &sl)
3960#if(CXSC_INDEX_CHECK)
3961;
3962#else
3963 noexcept;
3964#endif
3966 INLINE l_ivector operator |(const l_rvector_slice &sl, const ivector &rv)
3967#if(CXSC_INDEX_CHECK)
3968;
3969#else
3970 noexcept;
3971#endif
3973 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
3988 INLINE l_ivector operator |(const ivector &rv, const l_rvector_slice &sl)
3989#if(CXSC_INDEX_CHECK)
3990;
3991#else
3992 noexcept;
3993#endif
3995 INLINE l_ivector operator |(const ivector_slice &sl, const l_rvector &rv)
3996#if(CXSC_INDEX_CHECK)
3997;
3998#else
3999 noexcept;
4000#endif
4002 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
4017 INLINE l_ivector operator &(const l_rvector &rv, const ivector_slice &sl)
4018#if(CXSC_INDEX_CHECK)
4019;
4020#else
4021 noexcept;
4022#endif
4024 INLINE l_ivector operator &(const l_rvector_slice &sl, const ivector &rv)
4025#if(CXSC_INDEX_CHECK)
4026;
4027#else
4028 noexcept;
4029#endif
4031 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
4046 INLINE l_ivector operator &(const ivector &rv, const l_rvector_slice &sl)
4047#if(CXSC_INDEX_CHECK)
4048;
4049#else
4050 noexcept;
4051#endif
4053 INLINE l_ivector operator &(const ivector_slice &sl, const l_rvector &rv)
4054#if(CXSC_INDEX_CHECK)
4055;
4056#else
4057 noexcept;
4058#endif
4060 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
The Data Type idotprecision.
Definition idot.hpp:48
The Data Type imatrix_slice.
Definition imatrix.hpp:1442
The Data Type imatrix_subv.
Definition imatrix.hpp:56
The Data Type imatrix.
Definition imatrix.hpp:660
The Scalar Type interval.
Definition interval.hpp:55
The Data Type ivector_slice.
Definition ivector.hpp:963
The Data Type ivector.
Definition ivector.hpp:55
The Multiple-Precision Data Type l_imatrix_slice.
The Multiple-Precision Data Type l_imatrix_subv.
Definition l_imatrix.hpp:47
The Multiple-Precision Data Type l_imatrix.
The Multiple-Precision Data Type l_interval.
l_interval() noexcept
Constructor of class l_interval.
The Multiple-Precision Data Type l_ivector_slice.
l_ivector_slice & operator=(const l_ivector_slice &sl) noexcept
Implementation of standard assigning operator.
l_ivector_slice & operator-=(const l_ivector &rv) noexcept
Implementation of subtraction and allocation operation.
l_ivector_slice(l_ivector &a, const int &lb, const int &ub) noexcept
Constructor of class l_ivector_slice.
l_ivector_slice & operator()() noexcept
Operator for accessing the whole vector.
l_ivector_slice(l_ivector_slice &a, const int &lb, const int &ub) noexcept
Constructor of class l_ivector_slice.
friend int Lb(const l_ivector_slice &sl) noexcept
Returns the lower bound of the vector.
l_ivector_slice(const l_ivector_slice &a) noexcept
Constructor of class l_ivector_slice.
l_ivector_slice & operator|=(const l_ivector &rv) noexcept
Allocates the convex hull of the arguments to the first argument.
l_ivector_slice & operator*=(const l_interval &r) noexcept
Implementation of multiplication and allocation operation.
l_ivector_slice & operator&=(const l_ivector &rv) noexcept
Allocates the intersection of the arguments to the first argument.
l_ivector_slice & operator/=(const l_interval &r) noexcept
Implementation of division and allocation operation.
l_ivector_slice & operator+=(const l_ivector &rv) noexcept
Implementation of addition and allocation operation.
friend int Ub(const l_ivector_slice &sl) noexcept
Returns the upper bound of the vector.
friend int VecLen(const l_ivector_slice &sl) noexcept
Returns the dimension of the vector.
l_interval & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector.
The Multiple-Precision Data Type l_ivector.
Definition l_ivector.hpp:55
l_ivector & operator()() noexcept
Operator for accessing the whole vector.
l_ivector() noexcept
Constructor of class l_ivector.
Definition l_ivector.inl:31
l_interval & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector.
friend int Lb(const l_ivector &rv) noexcept
Returns the lower bound of the vector.
friend l_ivector & SetUb(l_ivector &rv, const int &u) noexcept
Sets the upper bound of the vector.
l_ivector & operator=(const l_ivector &rv) noexcept
Implementation of standard assigning operator.
friend l_ivector & SetLb(l_ivector &rv, const int &l) noexcept
Sets the lower bound of the vector.
friend int Ub(const l_ivector &rv) noexcept
Returns the upper bound of the vector.
friend int VecLen(const l_ivector &rv) noexcept
Returns the dimension of the vector.
The Multiple-Precision Data Type l_real.
Definition l_real.hpp:78
The Multiple-Precision Data Type l_rmatrix_slice.
The Multiple-Precision Data Type l_rmatrix_subv.
Definition l_rmatrix.hpp:47
The Multiple-Precision Data Type l_rmatrix.
The Multiple-Precision Data Type l_rvector_slice.
The Multiple-Precision Data Type l_rvector.
Definition l_rvector.hpp:54
The Scalar Type real.
Definition real.hpp:114
The Data Type rmatrix_slice.
Definition rmatrix.hpp:1443
The Data Type rmatrix_subv.
Definition rmatrix.hpp:54
The Data Type rmatrix.
Definition rmatrix.hpp:471
The Data Type rvector_slice.
Definition rvector.hpp:1064
The Data Type rvector.
Definition rvector.hpp:58
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition cdot.cpp:29
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc) noexcept
Implementation of standard algebraic addition and allocation operation.
Definition cdot.inl:251
civector operator/(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of division operation.
Definition cimatrix.inl:730
cvector diam(const cimatrix_subv &mv) noexcept
Returns the diameter of the matrix.
Definition cimatrix.inl:738
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.
cimatrix & operator*=(cimatrix &m, const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
Definition cimatrix.inl:737
cvector mid(const cimatrix_subv &mv) noexcept
Returns the middle of the matrix.
Definition cimatrix.inl:739
civector operator*(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of multiplication operation.
Definition cimatrix.inl:731
void Resize(cimatrix &A) noexcept
Resizes the matrix.
cimatrix_subv & SetUncheckedInf(cimatrix_subv &iv, const complex &r) noexcept
Returns the matrix with the new unchecked given infimum value.
Definition cimatrix.inl:890
cimatrix & operator/=(cimatrix &m, const cinterval &c) noexcept
Implementation of division and allocation operation.