C-XSC - A C++ Class Library for Extended Scientific Computing 2.5.4
l_ivector.inl
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.inl,v 1.20 2014/01/30 17:23:46 cxsc Exp $ */
25
26#ifndef _CXSC_LIVECTOR_INL_INCLUDED
27#define _CXSC_LIVECTOR_INL_INCLUDED
28
29namespace cxsc {
30
31 INLINE l_ivector::l_ivector () noexcept:dat(NULL),l(1),u(0),size(0)
32 {
33 }
34
35 INLINE l_ivector::l_ivector(const int &i) noexcept:l(1),u(i),size(i)
36 {
37 dat=new l_interval[i];
38 }
39
40#ifdef OLD_CXSC
41 INLINE l_ivector::l_ivector(const class index &i) noexcept:l(1),u(i._int()),size(i._int())
42 {
43 dat=new l_interval[i._int()];
44 }
45#endif
46
47 INLINE l_ivector::l_ivector(const int &i1,const int &i2)
48#if(CXSC_INDEX_CHECK)
49 :l(i1),u(i2),size(i2-i1+1)
50#else
51 noexcept:l(i1),u(i2),size(i2-i1+1)
52#endif
53 {
54#if(CXSC_INDEX_CHECK)
55 if(i1>i2) cxscthrow(ERROR_LIVECTOR_WRONG_BOUNDARIES("l_ivector::l_ivector(const int &i1,const int &i2)"));
56#endif
57 dat=new l_interval[size];
58 }
59
60 INLINE l_ivector::l_ivector(const l_ivector_slice &rs) noexcept:l(rs.start),u(rs.end),size(rs.end-rs.start+1)
61 {
62 dat=new l_interval[size];
63 for(int i=0, j=l-rs.l;i<size;i++,j++)
64 dat[i]=rs.dat[j];
65 }
66
67 INLINE l_ivector::l_ivector(const l_rvector_slice &rs) noexcept:l(rs.start),u(rs.end),size(rs.end-rs.start+1)
68 {
69 dat=new l_interval[size];
70 for(int i=0, j=l-rs.l;i<size;i++,j++)
71 dat[i]=rs.dat[j];
72 }
73
74 INLINE l_ivector::l_ivector(const ivector_slice &rs) noexcept:l(rs.start),u(rs.end),size(rs.end-rs.start+1)
75 {
76 dat=new l_interval[size];
77 for(int i=0, j=l-rs.l;i<size;i++,j++)
78 dat[i]=rs.dat[j];
79 }
80
81 INLINE l_ivector::l_ivector(const rvector_slice &rs) noexcept:l(rs.start),u(rs.end),size(rs.end-rs.start+1)
82 {
83 dat=new l_interval[size];
84 for(int i=0, j=l-rs.l;i<size;i++,j++)
85 dat[i]=rs.dat[j];
86 }
87
88 INLINE l_ivector::l_ivector(const l_ivector &v) noexcept:l(v.l),u(v.u),size(v.size)
89 {
90 dat=new l_interval[size];
91 for (int i=0;i<size;i++)
92 dat[i]=v.dat[i];
93 }
94
95 INLINE l_ivector::l_ivector(const l_interval &r) noexcept:l(1),u(1),size(1)
96 {
97 dat=new l_interval[1];
98 *dat=r;
99 }
100
101 INLINE l_ivector::l_ivector(const l_rvector &v) noexcept:l(v.l),u(v.u),size(v.size)
102 {
103 dat=new l_interval[size];
104 for (int i=0;i<size;i++)
105 dat[i]=v.dat[i];
106 }
107
108 INLINE l_ivector::l_ivector(const ivector &v) noexcept:l(v.l),u(v.u),size(v.size)
109 {
110 dat=new l_interval[size];
111 for (int i=0;i<size;i++)
112 dat[i]=v.dat[i];
113 }
114
115 INLINE l_ivector::l_ivector(const rvector &v) noexcept:l(v.l),u(v.u),size(v.size)
116 {
117 dat=new l_interval[size];
118 for (int i=0;i<size;i++)
119 dat[i]=v.dat[i];
120 }
121
122 INLINE l_ivector::l_ivector(const real &r) noexcept:l(1),u(1),size(1)
123 {
124 dat=new l_interval[1];
125 *dat=r;
126 }
127
128 INLINE l_ivector::l_ivector(const interval &r) noexcept:l(1),u(1),size(1)
129 {
130 dat=new l_interval[1];
131 *dat=r;
132 }
133
134 INLINE l_ivector::l_ivector(const l_real &r) noexcept:l(1),u(1),size(1)
135 {
136 dat=new l_interval[1];
137 *dat=r;
138 }
139
140
141 INLINE l_interval & l_ivector::operator [](const int &i) const
142#if(CXSC_INDEX_CHECK)
143
144#else
145 noexcept
146#endif
147 {
148#if(CXSC_INDEX_CHECK)
149 if(i<l||i>u) cxscthrow(ERROR_LIVECTOR_ELEMENT_NOT_IN_VEC("l_interval & l_ivector::operator [](const int &i)"));
150#endif
151 return dat[i-l];
152 }
153
154 INLINE l_interval & l_ivector_slice::operator [](const int &i) const
155#if(CXSC_INDEX_CHECK)
156
157#else
158 noexcept
159#endif
160 {
161#if(CXSC_INDEX_CHECK)
162 if(i<start||i>end) cxscthrow(ERROR_LIVECTOR_ELEMENT_NOT_IN_VEC("l_interval & l_ivector_slice::operator [](const int &i)"));
163#endif
164 return dat[i-l];
165 }
166
168#if(CXSC_INDEX_CHECK)
169
170#else
171 noexcept
172#endif
173 {
174#if(CXSC_INDEX_CHECK)
175 if(1<l||i>u) cxscthrow(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG("l_ivector_slice l_ivector::operator ()(const int &i)"));
176#endif
177 return l_ivector_slice(*this,1,i);
178 }
179
180 INLINE l_ivector_slice l_ivector::operator ()(const int &i1,const int &i2)
181#if(CXSC_INDEX_CHECK)
182
183#else
184 noexcept
185#endif
186 {
187#if(CXSC_INDEX_CHECK)
188 if(i1<l||i2>u) cxscthrow(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG("l_ivector_slice l_ivector::operator ()(const int &i1,const int &i2)"));
189#endif
190 return l_ivector_slice(*this,i1,i2);
191 }
192
194#if(CXSC_INDEX_CHECK)
195
196#else
197 noexcept
198#endif
199 {
200#if(CXSC_INDEX_CHECK)
201 if(1<start||i>end) cxscthrow(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG("l_ivector_slice l_ivector_slice::operator ()(const int &i)"));
202#endif
203 return l_ivector_slice(*this,1,i);
204 }
205
206 INLINE l_ivector_slice l_ivector_slice::operator ()(const int &i1,const int &i2)
207#if(CXSC_INDEX_CHECK)
208
209#else
210 noexcept
211#endif
212 {
213#if(CXSC_INDEX_CHECK)
214 if(i1<start||i2>end) cxscthrow(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG("l_ivector_slice l_ivector_slice::operator ()(const int &i1,const int &i2)"));
215#endif
216 return l_ivector_slice(*this,i1,i2);
217 }
218
220#if(CXSC_INDEX_CHECK)
221
222#else
223 noexcept
224#endif
225 {
226#if(CXSC_INDEX_CHECK)
227 if(rv.size>1) cxscthrow(ERROR_LIVECTOR_TYPE_CAST_OF_THICK_OBJ("l_interval::l_interval(const l_ivector &rv)"));
228 else if(rv.size<1) cxscthrow(ERROR_LIVECTOR_USE_OF_UNINITIALIZED_OBJ("l_interval::l_interval(const l_ivector &rv)"));
229#endif
230 *this=rv.dat[0];
231 }
232
234#if(CXSC_INDEX_CHECK)
235
236#else
237 noexcept
238#endif
239 {
240#if(CXSC_INDEX_CHECK)
241 if(sl.size>1) cxscthrow(ERROR_LIVECTOR_TYPE_CAST_OF_THICK_OBJ("l_interval::l_interval(const l_ivector_slice &sl)"));
242 else if(sl.size<1) cxscthrow(ERROR_LIVECTOR_USE_OF_UNINITIALIZED_OBJ("l_interval::l_interval(const l_ivector_slice &sl)"));
243#endif
244 *this=sl.dat[sl.start-sl.l];
245 }
246
252 INLINE l_ivector _l_ivector(const l_interval &r) noexcept { return l_ivector(r); }
253
259 INLINE l_ivector _l_ivector(const real &r) noexcept { return l_ivector(r); }
265 INLINE l_ivector _l_ivector(const rvector_slice &rs) noexcept { return l_ivector(rs); }
271 INLINE l_ivector _l_ivector(const rvector &rs) noexcept { return l_ivector(rs); }
272
278 INLINE l_ivector _l_ivector(const l_real &r) noexcept { return l_ivector(r); }
284 INLINE l_ivector _l_ivector(const l_rvector_slice &rs) noexcept { return l_ivector(rs); }
290 INLINE l_ivector _l_ivector(const l_rvector &rs) noexcept { return l_ivector(rs); }
291
297 INLINE l_ivector _l_ivector(const interval &r) noexcept { return l_ivector(r); }
303 INLINE l_ivector _l_ivector(const ivector_slice &rs) noexcept { return l_ivector(rs); }
309 INLINE l_ivector _l_ivector(const ivector &rs) noexcept { return l_ivector(rs); }
310
311 INLINE l_ivector &l_ivector::operator =(const l_ivector &rv) noexcept { return _vvassign<l_ivector,l_ivector,l_interval>(*this,rv); }
312 INLINE l_ivector &l_ivector::operator =(const l_interval &r) noexcept { return _vsassign<l_ivector,l_interval>(*this,r); }
313 INLINE l_ivector::operator void*() noexcept { return _vvoid(*this); }
315#if(CXSC_INDEX_CHECK)
316
317#else
318 noexcept
319#endif
320 { return _vsvsassign(*this,sl); }
322#if(CXSC_INDEX_CHECK)
323
324#else
325 noexcept
326#endif
327 { return _vsvassign(*this,rv); }
328 INLINE l_ivector_slice & l_ivector_slice::operator =(const l_interval &r) noexcept { return _vssassign<l_ivector_slice,l_interval>(*this,r); }
329 INLINE l_ivector_slice::operator void*() noexcept { return _vsvoid(*this); }
330
331//=======================================================================
332//======================== Vector Functions =============================
333
334
335 INLINE l_ivector &SetInf(l_ivector &iv,const l_rvector &rv)
336#if(CXSC_INDEX_CHECK)
337
338#else
339 noexcept
340#endif
341 { return _vvsetinf(iv,rv); }
342 INLINE l_ivector_slice &SetInf(l_ivector_slice &iv,const l_rvector &rv)
343#if(CXSC_INDEX_CHECK)
344
345#else
346 noexcept
347#endif
348 { return _vsvsetinf(iv,rv); }
349 INLINE l_ivector &SetInf(l_ivector &iv,const l_rvector_slice &rv)
350#if(CXSC_INDEX_CHECK)
351
352#else
353 noexcept
354#endif
355 { return _vvssetinf(iv,rv); }
356 INLINE l_ivector_slice &SetInf(l_ivector_slice &iv,const l_rvector_slice &rv)
357#if(CXSC_INDEX_CHECK)
358
359#else
360 noexcept
361#endif
362 { return _vsvssetinf(iv,rv); }
363 INLINE l_ivector &UncheckedSetInf(l_ivector &iv,const l_rvector &rv)
364#if(CXSC_INDEX_CHECK)
365
366#else
367 noexcept
368#endif
369 { return _vvusetinf(iv,rv); }
370 INLINE l_ivector_slice &UncheckedSetInf(l_ivector_slice &iv,const l_rvector &rv)
371#if(CXSC_INDEX_CHECK)
372
373#else
374 noexcept
375#endif
376 { return _vsvusetinf(iv,rv); }
377 INLINE l_ivector &UncheckedSetInf(l_ivector &iv,const l_rvector_slice &rv)
378#if(CXSC_INDEX_CHECK)
379
380#else
381 noexcept
382#endif
383 { return _vvsusetinf(iv,rv); }
384 INLINE l_ivector_slice &UncheckedSetInf(l_ivector_slice &iv,const l_rvector_slice &rv)
385#if(CXSC_INDEX_CHECK)
386
387#else
388 noexcept
389#endif
390 { return _vsvsusetinf(iv,rv); }
391
392 INLINE l_ivector &SetSup(l_ivector &iv,const l_rvector &rv)
393#if(CXSC_INDEX_CHECK)
394
395#else
396 noexcept
397#endif
398 { return _vvsetsup(iv,rv); }
399 INLINE l_ivector_slice &SetSup(l_ivector_slice &iv,const l_rvector &rv)
400#if(CXSC_INDEX_CHECK)
401
402#else
403 noexcept
404#endif
405 { return _vsvsetsup(iv,rv); }
406 INLINE l_ivector &SetSup(l_ivector &iv,const l_rvector_slice &rv)
407#if(CXSC_INDEX_CHECK)
408
409#else
410 noexcept
411#endif
412 { return _vvssetsup(iv,rv); }
413 INLINE l_ivector_slice &SetSup(l_ivector_slice &iv,const l_rvector_slice &rv)
414#if(CXSC_INDEX_CHECK)
415
416#else
417 noexcept
418#endif
419 { return _vsvssetsup(iv,rv); }
420 INLINE l_ivector &UncheckedSetSup(l_ivector &iv,const l_rvector &rv)
421#if(CXSC_INDEX_CHECK)
422
423#else
424 noexcept
425#endif
426 { return _vvusetsup(iv,rv); }
427 INLINE l_ivector_slice &UncheckedSetSup(l_ivector_slice &iv,const l_rvector &rv)
428#if(CXSC_INDEX_CHECK)
429
430#else
431 noexcept
432#endif
433 { return _vsvusetsup(iv,rv); }
434 INLINE l_ivector &UncheckedSetSup(l_ivector &iv,const l_rvector_slice &rv)
435#if(CXSC_INDEX_CHECK)
436
437#else
438 noexcept
439#endif
440 { return _vvsusetsup(iv,rv); }
441 INLINE l_ivector_slice &UncheckedSetSup(l_ivector_slice &iv,const l_rvector_slice &rv)
442#if(CXSC_INDEX_CHECK)
443
444#else
445 noexcept
446#endif
447 { return _vsvsusetsup(iv,rv); }
448
449 INLINE l_ivector &SetSup(l_ivector &iv,const l_real &r) noexcept { return _vssetsup(iv,r); }
450 INLINE l_ivector &SetInf(l_ivector &iv,const l_real &r) noexcept { return _vssetinf(iv,r); }
451 INLINE l_ivector &UncheckedSetSup(l_ivector &iv,const l_real &r) noexcept { return _vsusetsup(iv,r); }
452 INLINE l_ivector &SetUncheckedInf(l_ivector &iv,const l_real &r) noexcept { return _vsusetinf(iv,r); }
453
454 INLINE l_ivector_slice &SetSup(l_ivector_slice &iv,const l_real &r) noexcept { return _vsssetsup(iv,r); }
455 INLINE l_ivector_slice &SetInf(l_ivector_slice &iv,const l_real &r) noexcept { return _vsssetinf(iv,r); }
456 INLINE l_ivector_slice &UncheckedSetSup(l_ivector_slice &iv,const l_real &r) noexcept { return _vssusetsup(iv,r); }
457 INLINE l_ivector_slice &SetUncheckedInf(l_ivector_slice &iv,const l_real &r) noexcept { return _vssusetinf(iv,r); }
458
459 INLINE void Resize(l_ivector &rv) noexcept { _vresize(rv); }
460 INLINE void Resize(l_ivector &rv, const int &len)
461#if(CXSC_INDEX_CHECK)
462
463#else
464 noexcept
465#endif
466 { _vresize<class l_ivector,class l_interval>(rv,len); }
467 INLINE void Resize(l_ivector &rv, const int &lb, const int &ub)
468#if(CXSC_INDEX_CHECK)
469
470#else
471 noexcept
472#endif
473 { _vresize<class l_ivector,class l_interval>(rv,lb,ub); }
474
475 INLINE l_ivector abs(const l_ivector &rv) noexcept { return _vabs<l_ivector,l_ivector>(rv); }
476 INLINE l_ivector abs(const l_ivector_slice &sl) noexcept { return _vsabs<l_ivector_slice,l_ivector>(sl); }
477 INLINE l_rvector diam(const l_ivector &v) noexcept { return _vdiam<l_ivector,l_rvector>(v); }
478 INLINE l_rvector diam(const l_ivector_slice &v) noexcept { return _vsdiam<l_ivector_slice,l_rvector>(v); }
479 INLINE l_rvector mid(const l_ivector &v) noexcept { return _vmid<l_ivector,l_rvector>(v); }
480 INLINE l_rvector mid(const l_ivector_slice &v) noexcept { return _vsmid<l_ivector_slice,l_rvector>(v); }
481 INLINE l_rvector Inf(const l_ivector &v) noexcept { return _vinf<l_ivector,l_rvector>(v); }
482 INLINE l_rvector Inf(const l_ivector_slice &v) noexcept { return _vsinf<l_ivector_slice,l_rvector>(v); }
483 INLINE l_rvector Sup(const l_ivector &v) noexcept { return _vsup<l_ivector,l_rvector>(v); }
484 INLINE l_rvector Sup(const l_ivector_slice &v) noexcept { return _vssup<l_ivector_slice,l_rvector>(v); }
485 INLINE bool operator !(const l_ivector &rv) noexcept { return _vnot(rv); }
486 INLINE bool operator !(const l_ivector_slice &sl) noexcept { return _vsnot(sl); }
487
488//======================= Vector / Scalar ===============================
489
490//----------------------------- l_interval ---------------------------
491
492 INLINE l_ivector operator *(const l_ivector &rv, const l_interval &s) noexcept { return _vsmult<l_ivector,l_interval,l_ivector>(rv,s); }
493 INLINE l_ivector operator *(const l_ivector_slice &sl, const l_interval &s) noexcept { return _vssmult<l_ivector_slice,l_interval,l_ivector>(sl,s); }
494 INLINE l_ivector operator *(const l_interval &s, const l_ivector &rv) noexcept { return _vsmult<l_ivector,l_interval,l_ivector>(rv,s); }
495 INLINE l_ivector operator *(const l_interval &s, const l_ivector_slice &sl) noexcept { return _vssmult<l_ivector_slice,l_interval,l_ivector>(sl,s); }
496 INLINE l_ivector &operator *=(l_ivector &rv,const l_interval &r) noexcept { return _vsmultassign(rv,r); }
497 INLINE l_ivector_slice &l_ivector_slice::operator *=(const l_interval &r) noexcept { return _vssmultassign(*this,r); }
498
499 INLINE l_ivector operator /(const l_ivector &rv, const l_interval &s) noexcept { return _vsdiv<l_ivector,l_interval,l_ivector>(rv,s); }
500 INLINE l_ivector operator /(const l_ivector_slice &sl, const l_interval &s) noexcept { return _vssdiv<l_ivector_slice,l_interval,l_ivector>(sl,s); }
501 INLINE l_ivector &operator /=(l_ivector &rv,const l_interval &r) noexcept { return _vsdivassign(rv,r); }
502 INLINE l_ivector_slice &l_ivector_slice::operator /=(const l_interval &r) noexcept { return _vssdivassign(*this,r); }
503
504//---------------------------- Real --------------------------------------
505
506 INLINE l_ivector operator *(const l_ivector &rv, const real &s) noexcept { return _vsmult<l_ivector,real,l_ivector>(rv,s); }
507 INLINE l_ivector operator *(const l_ivector_slice &sl, const real &s) noexcept { return _vssmult<l_ivector_slice,real,l_ivector>(sl,s); }
508 INLINE l_ivector operator *(const real &s, const l_ivector &rv) noexcept { return _vsmult<l_ivector,real,l_ivector>(rv,s); }
509 INLINE l_ivector operator *(const real &s, const l_ivector_slice &sl) noexcept { return _vssmult<l_ivector_slice,real,l_ivector>(sl,s); }
510 INLINE l_ivector &operator *=(l_ivector &rv,const real &r) noexcept { return _vsmultassign(rv,r); }
511 INLINE l_ivector_slice &l_ivector_slice::operator *=(const real &r) noexcept { return _vssmultassign(*this,r); }
512
513 INLINE l_ivector operator /(const l_ivector &rv, const real &s) noexcept { return _vsdiv<l_ivector,real,l_ivector>(rv,s); }
514 INLINE l_ivector operator /(const l_ivector_slice &sl, const real &s) noexcept { return _vssdiv<l_ivector_slice,real,l_ivector>(sl,s); }
515 INLINE l_ivector &operator /=(l_ivector &rv,const real &r) noexcept { return _vsdivassign(rv,r); }
516 INLINE l_ivector_slice &l_ivector_slice::operator /=(const real &r) noexcept { return _vssdivassign(*this,r); }
517
518 INLINE l_ivector operator *(const rvector &rv, const l_interval &s) noexcept { return _vsmult<rvector,l_interval,l_ivector>(rv,s); }
519 INLINE l_ivector operator *(const rvector_slice &sl, const l_interval &s) noexcept { return _vssmult<rvector_slice,l_interval,l_ivector>(sl,s); }
520 INLINE l_ivector operator *(const l_interval &s, const rvector &rv) noexcept { return _vsmult<rvector,l_interval,l_ivector>(rv,s); }
521 INLINE l_ivector operator *(const l_interval &s, const rvector_slice &sl) noexcept { return _vssmult<rvector_slice,l_interval,l_ivector>(sl,s); }
522
523 INLINE l_ivector operator /(const rvector &rv, const l_interval &s) noexcept { return _vsdiv<rvector,l_interval,l_ivector>(rv,s); }
524 INLINE l_ivector operator /(const rvector_slice &sl, const l_interval &s) noexcept { return _vssdiv<rvector_slice,l_interval,l_ivector>(sl,s); }
525
526//---------------------------- l_real --------------------------------------
527
528 INLINE l_ivector operator *(const l_ivector &rv, const l_real &s) noexcept { return _vsmult<l_ivector,l_real,l_ivector>(rv,s); }
529 INLINE l_ivector operator *(const l_ivector_slice &sl, const l_real &s) noexcept { return _vssmult<l_ivector_slice,l_real,l_ivector>(sl,s); }
530 INLINE l_ivector operator *(const l_real &s, const l_ivector &rv) noexcept { return _vsmult<l_ivector,l_real,l_ivector>(rv,s); }
531 INLINE l_ivector operator *(const l_real &s, const l_ivector_slice &sl) noexcept { return _vssmult<l_ivector_slice,l_real,l_ivector>(sl,s); }
532 INLINE l_ivector &operator *=(l_ivector &rv,const l_real &r) noexcept { return _vsmultassign(rv,r); }
533 INLINE l_ivector_slice &l_ivector_slice::operator *=(const l_real &r) noexcept { return _vssmultassign(*this,r); }
534
535 INLINE l_ivector operator /(const l_ivector &rv, const l_real &s) noexcept { return _vsdiv<l_ivector,l_real,l_ivector>(rv,s); }
536 INLINE l_ivector operator /(const l_ivector_slice &sl, const l_real &s) noexcept { return _vssdiv<l_ivector_slice,l_real,l_ivector>(sl,s); }
537 INLINE l_ivector &operator /=(l_ivector &rv,const l_real &r) noexcept { return _vsdivassign(rv,r); }
538 INLINE l_ivector_slice &l_ivector_slice::operator /=(const l_real &r) noexcept { return _vssdivassign(*this,r); }
539
540 INLINE l_ivector operator *(const l_rvector &rv, const l_interval &s) noexcept { return _vsmult<l_rvector,l_interval,l_ivector>(rv,s); }
541 INLINE l_ivector operator *(const l_rvector_slice &sl, const l_interval &s) noexcept { return _vssmult<l_rvector_slice,l_interval,l_ivector>(sl,s); }
542 INLINE l_ivector operator *(const l_interval &s, const l_rvector &rv) noexcept { return _vsmult<l_rvector,l_interval,l_ivector>(rv,s); }
543 INLINE l_ivector operator *(const l_interval &s, const l_rvector_slice &sl) noexcept { return _vssmult<l_rvector_slice,l_interval,l_ivector>(sl,s); }
544
545 INLINE l_ivector operator /(const l_rvector &rv, const l_interval &s) noexcept { return _vsdiv<l_rvector,l_interval,l_ivector>(rv,s); }
546 INLINE l_ivector operator /(const l_rvector_slice &sl, const l_interval &s) noexcept { return _vssdiv<l_rvector_slice,l_interval,l_ivector>(sl,s); }
547
548//---------------------------- interval --------------------------------------
549
550 INLINE l_ivector operator *(const l_ivector &rv, const interval &s) noexcept { return _vsmult<l_ivector,interval,l_ivector>(rv,s); }
551 INLINE l_ivector operator *(const l_ivector_slice &sl, const interval &s) noexcept { return _vssmult<l_ivector_slice,interval,l_ivector>(sl,s); }
552 INLINE l_ivector operator *(const interval &s, const l_ivector &rv) noexcept { return _vsmult<l_ivector,interval,l_ivector>(rv,s); }
553 INLINE l_ivector operator *(const interval &s, const l_ivector_slice &sl) noexcept { return _vssmult<l_ivector_slice,interval,l_ivector>(sl,s); }
554 INLINE l_ivector &operator *=(l_ivector &rv,const interval &r) noexcept { return _vsmultassign(rv,r); }
555 INLINE l_ivector_slice &l_ivector_slice::operator *=(const interval &r) noexcept { return _vssmultassign(*this,r); }
556
557 INLINE l_ivector operator /(const l_ivector &rv, const interval &s) noexcept { return _vsdiv<l_ivector,interval,l_ivector>(rv,s); }
558 INLINE l_ivector operator /(const l_ivector_slice &sl, const interval &s) noexcept { return _vssdiv<l_ivector_slice,interval,l_ivector>(sl,s); }
559 INLINE l_ivector &operator /=(l_ivector &rv,const interval &r) noexcept { return _vsdivassign(rv,r); }
560 INLINE l_ivector_slice &l_ivector_slice::operator /=(const interval &r) noexcept { return _vssdivassign(*this,r); }
561
562 INLINE l_ivector operator *(const ivector &rv, const l_interval &s) noexcept { return _vsmult<ivector,l_interval,l_ivector>(rv,s); }
563 INLINE l_ivector operator *(const ivector_slice &sl, const l_interval &s) noexcept { return _vssmult<ivector_slice,l_interval,l_ivector>(sl,s); }
564 INLINE l_ivector operator *(const l_interval &s, const ivector &rv) noexcept { return _vsmult<ivector,l_interval,l_ivector>(rv,s); }
565 INLINE l_ivector operator *(const l_interval &s, const ivector_slice &sl) noexcept { return _vssmult<ivector_slice,l_interval,l_ivector>(sl,s); }
566
567 INLINE l_ivector operator /(const ivector &rv, const l_interval &s) noexcept { return _vsdiv<ivector,l_interval,l_ivector>(rv,s); }
568 INLINE l_ivector operator /(const ivector_slice &sl, const l_interval &s) noexcept { return _vssdiv<ivector_slice,l_interval,l_ivector>(sl,s); }
569
570//======================= Vector / Vector ===============================
571
572
573 INLINE std::ostream &operator <<(std::ostream &s, const l_ivector &rv) noexcept { return _vout(s,rv); }
574 INLINE std::ostream &operator <<(std::ostream &o, const l_ivector_slice &sl) noexcept { return _vsout(o,sl); }
575 INLINE std::istream &operator >>(std::istream &s, l_ivector &rv) noexcept { return _vin(s,rv); }
576 INLINE std::istream &operator >>(std::istream &s, l_ivector_slice &rv) noexcept { return _vsin(s,rv); }
577
578//----------------------- l_interval / l_interval ---------------------------
579 INLINE l_ivector & l_ivector::operator =(const l_ivector_slice &sl) noexcept { return _vvsassign<l_ivector,l_ivector_slice,l_interval>(*this,sl); }
580
581 INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const l_ivector &rv2)
582#if(CXSC_INDEX_CHECK)
583
584#else
585 noexcept
586#endif
587 { _vvaccu(dp,rv1,rv2); }
588 INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl, const l_ivector &rv)
589#if(CXSC_INDEX_CHECK)
590
591#else
592 noexcept
593#endif
594 { _vsvaccu(dp,sl,rv); }
595 INLINE void accumulate(idotprecision &dp, const l_ivector &rv, const l_ivector_slice &sl)
596#if(CXSC_INDEX_CHECK)
597
598#else
599 noexcept
600#endif
601 { _vsvaccu(dp,sl,rv); }
602 INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const l_imatrix_subv &rv2)
603#if(CXSC_INDEX_CHECK)
604
605#else
606 noexcept
607#endif
608 ;
609 INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_ivector &rv2)
610#if(CXSC_INDEX_CHECK)
611
612#else
613 noexcept
614#endif
615 ;
616 INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl1, const l_ivector_slice &sl2)
617#if(CXSC_INDEX_CHECK)
618
619#else
620 noexcept
621#endif
622 { _vsvsaccu(dp,sl1,sl2); }
623
624 INLINE l_interval operator *(const l_ivector & rv1, const l_ivector &rv2)
625#if(CXSC_INDEX_CHECK)
626
627#else
628 noexcept
629#endif
630 { return _vvlimult<l_ivector,l_ivector,l_interval>(rv1,rv2); }
631 INLINE l_interval operator *(const l_ivector_slice &sl, const l_ivector &rv)
632#if(CXSC_INDEX_CHECK)
633
634#else
635 noexcept
636#endif
637 { return _vsvlimult<l_ivector_slice,l_ivector,l_interval>(sl,rv); }
638 INLINE l_interval operator *(const l_ivector &rv, const l_ivector_slice &sl)
639#if(CXSC_INDEX_CHECK)
640
641#else
642 noexcept
643#endif
644 { return _vsvlimult<l_ivector_slice,l_ivector,l_interval>(sl,rv); }
645 INLINE l_interval operator *(const l_ivector_slice & sl1, const l_ivector_slice &sl2)
646#if(CXSC_INDEX_CHECK)
647
648#else
649 noexcept
650#endif
651 { return _vsvslimult<l_ivector_slice,l_ivector_slice,l_interval>(sl1,sl2); }
652
653 INLINE const l_ivector &operator +(const l_ivector &rv) noexcept { return rv; }
654 INLINE l_ivector operator +(const l_ivector_slice &sl) noexcept { return sl; }
655 INLINE l_ivector operator +(const l_ivector &rv1, const l_ivector &rv2)
656#if(CXSC_INDEX_CHECK)
657
658#else
659 noexcept
660#endif
661 { return _vvplus<l_ivector,l_ivector,l_ivector>(rv1,rv2); }
662 INLINE l_ivector operator +(const l_ivector &rv, const l_ivector_slice &sl)
663#if(CXSC_INDEX_CHECK)
664
665#else
666 noexcept
667#endif
668 { return _vvsplus<l_ivector,l_ivector_slice,l_ivector>(rv,sl); }
669 INLINE l_ivector operator +(const l_ivector_slice &sl, const l_ivector &rv)
670#if(CXSC_INDEX_CHECK)
671
672#else
673 noexcept
674#endif
675 { return _vvsplus<l_ivector,l_ivector_slice,l_ivector>(rv,sl); }
676 INLINE l_ivector operator +(const l_ivector_slice &sl1, const l_ivector_slice &sl2)
677#if(CXSC_INDEX_CHECK)
678
679#else
680 noexcept
681#endif
682 { return _vsvsplus<l_ivector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
683 INLINE l_ivector & operator +=(l_ivector &rv1, const l_ivector &rv2)
684#if(CXSC_INDEX_CHECK)
685
686#else
687 noexcept
688#endif
689 { return _vvplusassign(rv1,rv2); }
691#if(CXSC_INDEX_CHECK)
692
693#else
694 noexcept
695#endif
696 { return _vvsplusassign(rv,sl); }
698#if(CXSC_INDEX_CHECK)
699
700#else
701 noexcept
702#endif
703 { return _vsvplusassign(*this,rv); }
705#if(CXSC_INDEX_CHECK)
706
707#else
708 noexcept
709#endif
710 { return _vsvsplusassign(*this,sl2); }
711
712 INLINE l_ivector operator -(const l_ivector &rv) noexcept { return _vminus(rv); }
713 INLINE l_ivector operator -(const l_ivector_slice &sl) noexcept { return _vsminus<l_ivector_slice,l_ivector>(sl); }
714 INLINE l_ivector operator -(const l_ivector &rv1, const l_ivector &rv2)
715#if(CXSC_INDEX_CHECK)
716
717#else
718 noexcept
719#endif
720 { return _vvminus<l_ivector,l_ivector,l_ivector>(rv1,rv2); }
721 INLINE l_ivector operator -(const l_ivector &rv, const l_ivector_slice &sl)
722#if(CXSC_INDEX_CHECK)
723
724#else
725 noexcept
726#endif
727 { return _vvsminus<l_ivector,l_ivector_slice,l_ivector>(rv,sl); }
728 INLINE l_ivector operator -(const l_ivector_slice &sl, const l_ivector &rv)
729#if(CXSC_INDEX_CHECK)
730
731#else
732 noexcept
733#endif
734 { return _vsvminus<l_ivector_slice,l_ivector,l_ivector>(sl,rv); }
735 INLINE l_ivector operator -(const l_ivector_slice &sl1, const l_ivector_slice &sl2)
736#if(CXSC_INDEX_CHECK)
737
738#else
739 noexcept
740#endif
741 { return _vsvsminus<l_ivector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
742 INLINE l_ivector & operator -=(l_ivector &rv1, const l_ivector &rv2)
743#if(CXSC_INDEX_CHECK)
744
745#else
746 noexcept
747#endif
748 { return _vvminusassign(rv1,rv2); }
749 INLINE l_ivector &operator -=(l_ivector &rv, const l_ivector_slice &sl)
750#if(CXSC_INDEX_CHECK)
751
752#else
753 noexcept
754#endif
755 { return _vvsminusassign(rv,sl); }
757#if(CXSC_INDEX_CHECK)
758
759#else
760 noexcept
761#endif
762 { return _vsvminusassign(*this,rv); }
764#if(CXSC_INDEX_CHECK)
765
766#else
767 noexcept
768#endif
769 { return _vsvsminusassign(*this,sl2); }
770
771 INLINE l_ivector operator |(const l_ivector &rv1, const l_ivector &rv2)
772#if(CXSC_INDEX_CHECK)
773
774#else
775 noexcept
776#endif
777 { return _vvconv<l_ivector,l_ivector,l_ivector>(rv1,rv2); }
778 INLINE l_ivector operator |(const l_ivector &rv, const l_ivector_slice &sl)
779#if(CXSC_INDEX_CHECK)
780
781#else
782 noexcept
783#endif
784 { return _vvsconv<l_ivector,l_ivector_slice,l_ivector>(rv,sl); }
785 INLINE l_ivector operator |(const l_ivector_slice &sl, const l_ivector &rv)
786#if(CXSC_INDEX_CHECK)
787
788#else
789 noexcept
790#endif
791 { return _vvsconv<l_ivector,l_ivector_slice,l_ivector>(rv,sl); }
792 INLINE l_ivector operator |(const l_ivector_slice &sl1, const l_ivector_slice &sl2)
793#if(CXSC_INDEX_CHECK)
794
795#else
796 noexcept
797#endif
798 { return _vsvsconv<l_ivector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
799 INLINE l_ivector & operator |=(l_ivector &rv1, const l_ivector &rv2)
800#if(CXSC_INDEX_CHECK)
801
802#else
803 noexcept
804#endif
805 { return _vvconvassign(rv1,rv2); }
806 INLINE l_ivector &operator |=(l_ivector &rv, const l_ivector_slice &sl)
807#if(CXSC_INDEX_CHECK)
808
809#else
810 noexcept
811#endif
812 { return _vvsconvassign(rv,sl); }
814#if(CXSC_INDEX_CHECK)
815
816#else
817 noexcept
818#endif
819 { return _vsvconvassign(*this,rv); }
821#if(CXSC_INDEX_CHECK)
822
823#else
824 noexcept
825#endif
826 { return _vsvsconvassign(*this,sl2); }
827
828 INLINE l_ivector operator &(const l_ivector &rv1, const l_ivector &rv2)
829#if(CXSC_INDEX_CHECK)
830
831#else
832 noexcept
833#endif
834 { return _vvsect<l_ivector,l_ivector,l_ivector>(rv1,rv2); }
835 INLINE l_ivector operator &(const l_ivector &rv, const l_ivector_slice &sl)
836#if(CXSC_INDEX_CHECK)
837
838#else
839 noexcept
840#endif
841 { return _vvssect<l_ivector,l_ivector_slice,l_ivector>(rv,sl); }
842 INLINE l_ivector operator &(const l_ivector_slice &sl, const l_ivector &rv)
843#if(CXSC_INDEX_CHECK)
844
845#else
846 noexcept
847#endif
848 { return _vvssect<l_ivector,l_ivector_slice,l_ivector>(rv,sl); }
849 INLINE l_ivector operator &(const l_ivector_slice &sl1, const l_ivector_slice &sl2)
850#if(CXSC_INDEX_CHECK)
851
852#else
853 noexcept
854#endif
855 { return _vsvssect<l_ivector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
856 INLINE l_ivector & operator &=(l_ivector &rv1, const l_ivector &rv2)
857#if(CXSC_INDEX_CHECK)
858
859#else
860 noexcept
861#endif
862 { return _vvsectassign(rv1,rv2); }
863 INLINE l_ivector &operator &=(l_ivector &rv, const l_ivector_slice &sl)
864#if(CXSC_INDEX_CHECK)
865
866#else
867 noexcept
868#endif
869 { return _vvssectassign(rv,sl); }
871#if(CXSC_INDEX_CHECK)
872
873#else
874 noexcept
875#endif
876 { return _vsvsectassign(*this,rv); }
878#if(CXSC_INDEX_CHECK)
879
880#else
881 noexcept
882#endif
883 { return _vsvssectassign(*this,sl2); }
884
885 INLINE bool operator ==(const l_ivector &rv1, const l_ivector &rv2) noexcept { return _vveq(rv1,rv2); }
886 INLINE bool operator ==(const l_ivector_slice &sl1, const l_ivector_slice &sl2) noexcept { return _vsvseq(sl1,sl2); }
887 INLINE bool operator ==(const l_ivector_slice &sl, const l_ivector &rv) noexcept { return _vsveq(sl,rv); }
888 INLINE bool operator ==(const l_ivector &rv, const l_ivector_slice &sl) noexcept { return _vsveq(sl,rv); }
889 INLINE bool operator !=(const l_ivector &rv1, const l_ivector &rv2) noexcept { return _vvneq(rv1,rv2); }
890 INLINE bool operator !=(const l_ivector_slice &sl1, const l_ivector_slice &sl2) noexcept { return _vsvsneq(sl1,sl2); }
891 INLINE bool operator !=(const l_ivector_slice &sl, const l_ivector &rv) noexcept { return _vsvneq(sl,rv); }
892 INLINE bool operator !=(const l_ivector &rv, const l_ivector_slice &sl) noexcept { return _vsvneq(sl,rv); }
893 INLINE bool operator <(const l_ivector &rv1, const l_ivector &rv2) noexcept { return _vvless(rv1,rv2); }
894 INLINE bool operator <(const l_ivector_slice &sl1, const l_ivector_slice &sl2) noexcept { return _vsvsless(sl1,sl2); }
895 INLINE bool operator < (const l_ivector_slice &sl, const l_ivector &rv) noexcept { return _vsvless(sl,rv); }
896 INLINE bool operator < (const l_ivector &rv, const l_ivector_slice &sl) noexcept { return _vvsless(rv,sl); }
897 INLINE bool operator <=(const l_ivector &rv1, const l_ivector &rv2) noexcept { return _vvleq(rv1,rv2); }
898 INLINE bool operator <=(const l_ivector_slice &sl1, const l_ivector_slice &sl2) noexcept { return _vsvsleq(sl1,sl2); }
899 INLINE bool operator <=(const l_ivector_slice &sl, const l_ivector &rv) noexcept { return _vsvleq(sl,rv); }
900 INLINE bool operator <=(const l_ivector &rv, const l_ivector_slice &sl) noexcept { return _vvsleq(rv,sl); }
901 INLINE bool operator >(const l_ivector &rv1, const l_ivector &rv2) noexcept { return _vvless(rv2,rv1); }
902 INLINE bool operator >(const l_ivector_slice &sl1, const l_ivector_slice &sl2) noexcept { return _vsvsless(sl2,sl1); }
903 INLINE bool operator >(const l_ivector_slice &sl, const l_ivector &rv) noexcept { return _vvsless(rv,sl); }
904 INLINE bool operator >(const l_ivector &rv, const l_ivector_slice &sl) noexcept { return _vsvless(sl,rv); }
905 INLINE bool operator >=(const l_ivector &rv1, const l_ivector &rv2) noexcept { return _vvleq(rv2,rv1); }
906 INLINE bool operator >=(const l_ivector_slice &sl1, const l_ivector_slice &sl2) noexcept { return _vsvsleq(sl2,sl1); }
907 INLINE bool operator >=(const l_ivector_slice &sl, const l_ivector &rv) noexcept { return _vvsleq(rv,sl); }
908 INLINE bool operator >=(const l_ivector &rv, const l_ivector_slice &sl) noexcept { return _vsvleq(sl,rv); }
909
910//-------------------------------- l_interval / Real --------------------------------
911
912 INLINE l_ivector &l_ivector::operator =(const rvector &rv) noexcept { return _vvassign<l_ivector,rvector,l_interval>(*this,rv); }
913 INLINE l_ivector &l_ivector::operator =(const real &r) noexcept { return _vsassign<l_ivector,real>(*this,r); }
914 INLINE l_ivector & l_ivector::operator =(const rvector_slice &sl) noexcept { return _vvsassign<l_ivector,rvector_slice,l_interval>(*this,sl); }
916#if(CXSC_INDEX_CHECK)
917
918#else
919 noexcept
920#endif
921 { return _vsvassign(*this,rv); }
922 INLINE l_ivector_slice &l_ivector_slice::operator =(const real &r) noexcept { return _vssassign<l_ivector_slice,real>(*this,r); }
924#if(CXSC_INDEX_CHECK)
925
926#else
927 noexcept
928#endif
929 { return _vsvsassign(*this,sl); }
930
931 INLINE void accumulate(idotprecision &dp, const rvector & rv1, const l_ivector &rv2)
932#if(CXSC_INDEX_CHECK)
933
934#else
935 noexcept
936#endif
937 { _vvaccu(dp,rv1,rv2); }
938 INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const rvector &rv2)
939#if(CXSC_INDEX_CHECK)
940
941#else
942 noexcept
943#endif
944 { _vvaccu(dp,rv2,rv1); }
945 INLINE void accumulate(idotprecision &dp, const rvector_slice & sl, const l_ivector &rv)
946#if(CXSC_INDEX_CHECK)
947
948#else
949 noexcept
950#endif
951 { _vsvaccu(dp,sl,rv); }
952 INLINE void accumulate(idotprecision &dp,const l_ivector_slice &sl,const rvector &rv)
953#if(CXSC_INDEX_CHECK)
954
955#else
956 noexcept
957#endif
958 { _vsvaccu(dp,sl,rv); }
959 INLINE void accumulate(idotprecision &dp, const rvector &rv, const l_ivector_slice &sl)
960#if(CXSC_INDEX_CHECK)
961
962#else
963 noexcept
964#endif
965 { _vsvaccu(dp,sl,rv); }
966 INLINE void accumulate(idotprecision &dp, const rvector & rv1, const l_imatrix_subv &rv2)
967#if(CXSC_INDEX_CHECK)
968
969#else
970 noexcept
971#endif
972 ;
973 INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const rmatrix_subv &rv2)
974#if(CXSC_INDEX_CHECK)
975
976#else
977 noexcept
978#endif
979 ;
980 INLINE void accumulate(idotprecision &dp,const l_ivector &rv,const rvector_slice &sl)
981#if(CXSC_INDEX_CHECK)
982
983#else
984 noexcept
985#endif
986 { _vsvaccu(dp,sl,rv); }
987 INLINE void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const l_ivector &rv2)
988#if(CXSC_INDEX_CHECK)
989
990#else
991 noexcept
992#endif
993 ;
994 INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const rvector &rv2)
995#if(CXSC_INDEX_CHECK)
996
997#else
998 noexcept
999#endif
1000 ;
1001 INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl1, const rvector_slice &sl2)
1002#if(CXSC_INDEX_CHECK)
1003
1004#else
1005 noexcept
1006#endif
1007 { _vsvsaccu(dp,sl2,sl1); }
1008 INLINE void accumulate(idotprecision &dp, const rvector_slice & sl1, const l_ivector_slice &sl2)
1009#if(CXSC_INDEX_CHECK)
1010
1011#else
1012 noexcept
1013#endif
1014 { _vsvsaccu(dp,sl1,sl2); }
1015
1016 INLINE l_interval operator *(const rvector & rv1, const l_ivector &rv2)
1017#if(CXSC_INDEX_CHECK)
1018
1019#else
1020 noexcept
1021#endif
1022 { return _vvlimult<rvector,l_ivector,l_interval>(rv1,rv2); }
1023 INLINE l_interval operator *(const rvector_slice &sl, const l_ivector &rv)
1024#if(CXSC_INDEX_CHECK)
1025
1026#else
1027 noexcept
1028#endif
1029 { return _vsvlimult<rvector_slice,l_ivector,l_interval>(sl,rv); }
1030 INLINE l_interval operator *(const rvector &rv, const l_ivector_slice &sl)
1031#if(CXSC_INDEX_CHECK)
1032
1033#else
1034 noexcept
1035#endif
1036 { return _vsvlimult<l_ivector_slice,rvector,l_interval>(sl,rv); }
1037 INLINE l_interval operator *(const rvector_slice & sl1, const l_ivector_slice &sl2)
1038#if(CXSC_INDEX_CHECK)
1039
1040#else
1041 noexcept
1042#endif
1043 { return _vsvslimult<rvector_slice,l_ivector_slice,l_interval>(sl1,sl2); }
1044
1045 INLINE l_interval operator *(const l_ivector & rv1, const rvector &rv2)
1046#if(CXSC_INDEX_CHECK)
1047
1048#else
1049 noexcept
1050#endif
1051 { return _vvlimult<rvector,l_ivector,l_interval>(rv2,rv1); }
1052 INLINE l_interval operator *(const l_ivector_slice &sl, const rvector &rv)
1053#if(CXSC_INDEX_CHECK)
1054
1055#else
1056 noexcept
1057#endif
1058 { return _vsvlimult<l_ivector_slice,rvector,l_interval>(sl,rv); }
1059 INLINE l_interval operator *(const l_ivector &rv, const rvector_slice &sl)
1060#if(CXSC_INDEX_CHECK)
1061
1062#else
1063 noexcept
1064#endif
1065 { return _vsvlimult<rvector_slice,l_ivector,l_interval>(sl,rv); }
1066 INLINE l_interval operator *(const l_ivector_slice & sl1, const rvector_slice &sl2)
1067#if(CXSC_INDEX_CHECK)
1068
1069#else
1070 noexcept
1071#endif
1072 { return _vsvslimult<rvector_slice,l_ivector_slice,l_interval>(sl2,sl1); }
1073
1074 INLINE l_ivector operator +(const rvector &rv1, const l_ivector &rv2)
1075#if(CXSC_INDEX_CHECK)
1076
1077#else
1078 noexcept
1079#endif
1080 { return _vvplus<rvector,l_ivector,l_ivector>(rv1,rv2); }
1081 INLINE l_ivector operator +(const rvector &rv, const l_ivector_slice &sl)
1082#if(CXSC_INDEX_CHECK)
1083
1084#else
1085 noexcept
1086#endif
1087 { return _vvsplus<rvector,l_ivector_slice,l_ivector>(rv,sl); }
1088 INLINE l_ivector operator +(const rvector_slice &sl, const l_ivector &rv)
1089#if(CXSC_INDEX_CHECK)
1090
1091#else
1092 noexcept
1093#endif
1094 { return _vvsplus<l_ivector,rvector_slice,l_ivector>(rv,sl); }
1095 INLINE l_ivector operator +(const rvector_slice &sl1, const l_ivector_slice &sl2)
1096#if(CXSC_INDEX_CHECK)
1097
1098#else
1099 noexcept
1100#endif
1101 { return _vsvsplus<rvector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
1102
1103 INLINE l_ivector operator +(const l_ivector &rv1, const rvector &rv2)
1104#if(CXSC_INDEX_CHECK)
1105
1106#else
1107 noexcept
1108#endif
1109 { return _vvplus<rvector,l_ivector,l_ivector>(rv2,rv1); }
1110 INLINE l_ivector operator +(const l_ivector &rv, const rvector_slice &sl)
1111#if(CXSC_INDEX_CHECK)
1112
1113#else
1114 noexcept
1115#endif
1116 { return _vvsplus<l_ivector,rvector_slice,l_ivector>(rv,sl); }
1117 INLINE l_ivector operator +(const l_ivector_slice &sl, const rvector &rv)
1118#if(CXSC_INDEX_CHECK)
1119
1120#else
1121 noexcept
1122#endif
1123 { return _vvsplus<rvector,l_ivector_slice,l_ivector>(rv,sl); }
1124 INLINE l_ivector operator +(const l_ivector_slice &sl1, const rvector_slice &sl2)
1125#if(CXSC_INDEX_CHECK)
1126
1127#else
1128 noexcept
1129#endif
1130 { return _vsvsplus<rvector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
1131
1132 INLINE l_ivector & operator +=(l_ivector &rv1, const rvector &rv2)
1133#if(CXSC_INDEX_CHECK)
1134
1135#else
1136 noexcept
1137#endif
1138 { return _vvplusassign(rv1,rv2); }
1140#if(CXSC_INDEX_CHECK)
1141
1142#else
1143 noexcept
1144#endif
1145 { return _vvsplusassign(rv,sl); }
1147#if(CXSC_INDEX_CHECK)
1148
1149#else
1150 noexcept
1151#endif
1152 { return _vsvplusassign(*this,rv); }
1154#if(CXSC_INDEX_CHECK)
1155
1156#else
1157 noexcept
1158#endif
1159 { return _vsvsplusassign(*this,sl2); }
1160
1161 INLINE l_ivector operator -(const rvector &rv1, const l_ivector &rv2)
1162#if(CXSC_INDEX_CHECK)
1163
1164#else
1165 noexcept
1166#endif
1167 { return _vvminus<rvector,l_ivector,l_ivector>(rv1,rv2); }
1168 INLINE l_ivector operator -(const rvector &rv, const l_ivector_slice &sl)
1169#if(CXSC_INDEX_CHECK)
1170
1171#else
1172 noexcept
1173#endif
1174 { return _vvsminus<rvector,l_ivector_slice,l_ivector>(rv,sl); }
1175 INLINE l_ivector operator -(const rvector_slice &sl, const l_ivector &rv)
1176#if(CXSC_INDEX_CHECK)
1177
1178#else
1179 noexcept
1180#endif
1181 { return _vsvminus<rvector_slice,l_ivector,l_ivector>(sl,rv); }
1182 INLINE l_ivector operator -(const rvector_slice &sl1, const l_ivector_slice &sl2)
1183#if(CXSC_INDEX_CHECK)
1184
1185#else
1186 noexcept
1187#endif
1188 { return _vsvsminus<rvector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
1189
1190 INLINE l_ivector operator -(const l_ivector &rv1, const rvector &rv2)
1191#if(CXSC_INDEX_CHECK)
1192
1193#else
1194 noexcept
1195#endif
1196 { return _vvminus<l_ivector,rvector,l_ivector>(rv1,rv2); }
1197 INLINE l_ivector operator -(const l_ivector &rv, const rvector_slice &sl)
1198#if(CXSC_INDEX_CHECK)
1199
1200#else
1201 noexcept
1202#endif
1203 { return _vvsminus<l_ivector,rvector_slice,l_ivector>(rv,sl); }
1204 INLINE l_ivector operator -(const l_ivector_slice &sl, const rvector &rv)
1205#if(CXSC_INDEX_CHECK)
1206
1207#else
1208 noexcept
1209#endif
1210 { return _vsvminus<l_ivector_slice,rvector,l_ivector>(sl,rv); }
1211 INLINE l_ivector operator -(const l_ivector_slice &sl1, const rvector_slice &sl2)
1212#if(CXSC_INDEX_CHECK)
1213
1214#else
1215 noexcept
1216#endif
1217 { return _vsvsminus<l_ivector_slice,rvector_slice,l_ivector>(sl1,sl2); }
1218
1219 INLINE l_ivector & operator -=(l_ivector &rv1, const rvector &rv2)
1220#if(CXSC_INDEX_CHECK)
1221
1222#else
1223 noexcept
1224#endif
1225 { return _vvminusassign(rv1,rv2); }
1226 INLINE l_ivector &operator -=(l_ivector &rv, const rvector_slice &sl)
1227#if(CXSC_INDEX_CHECK)
1228
1229#else
1230 noexcept
1231#endif
1232 { return _vvsminusassign(rv,sl); }
1234#if(CXSC_INDEX_CHECK)
1235
1236#else
1237 noexcept
1238#endif
1239 { return _vsvminusassign(*this,rv); }
1241#if(CXSC_INDEX_CHECK)
1242
1243#else
1244 noexcept
1245#endif
1246 { return _vsvsminusassign(*this,sl2); }
1247
1248 INLINE l_ivector operator |(const rvector &rv1, const l_ivector &rv2)
1249#if(CXSC_INDEX_CHECK)
1250
1251#else
1252 noexcept
1253#endif
1254 { return _vvconv<rvector,l_ivector,l_ivector>(rv1,rv2); }
1255 INLINE l_ivector operator |(const rvector &rv, const l_ivector_slice &sl)
1256#if(CXSC_INDEX_CHECK)
1257
1258#else
1259 noexcept
1260#endif
1261 { return _vvsconv<rvector,l_ivector_slice,l_ivector>(rv,sl); }
1262 INLINE l_ivector operator |(const rvector_slice &sl, const l_ivector &rv)
1263#if(CXSC_INDEX_CHECK)
1264
1265#else
1266 noexcept
1267#endif
1268 { return _vvsconv<l_ivector,rvector_slice,l_ivector>(rv,sl); }
1269 INLINE l_ivector operator |(const rvector_slice &sl1, const l_ivector_slice &sl2)
1270#if(CXSC_INDEX_CHECK)
1271
1272#else
1273 noexcept
1274#endif
1275 { return _vsvsconv<rvector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
1276
1277 INLINE l_ivector operator |(const l_ivector &rv1, const rvector &rv2)
1278#if(CXSC_INDEX_CHECK)
1279
1280#else
1281 noexcept
1282#endif
1283 { return _vvconv<rvector,l_ivector,l_ivector>(rv2,rv1); }
1284 INLINE l_ivector operator |(const l_ivector &rv, const rvector_slice &sl)
1285#if(CXSC_INDEX_CHECK)
1286
1287#else
1288 noexcept
1289#endif
1290 { return _vvsconv<l_ivector,rvector_slice,l_ivector>(rv,sl); }
1291 INLINE l_ivector operator |(const l_ivector_slice &sl, const rvector &rv)
1292#if(CXSC_INDEX_CHECK)
1293
1294#else
1295 noexcept
1296#endif
1297 { return _vvsconv<rvector,l_ivector_slice,l_ivector>(rv,sl); }
1298 INLINE l_ivector operator |(const l_ivector_slice &sl1, const rvector_slice &sl2)
1299#if(CXSC_INDEX_CHECK)
1300
1301#else
1302 noexcept
1303#endif
1304 { return _vsvsconv<rvector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
1305
1306 INLINE l_ivector & operator |=(l_ivector &rv1, const rvector &rv2)
1307#if(CXSC_INDEX_CHECK)
1308
1309#else
1310 noexcept
1311#endif
1312 { return _vvconvassign(rv1,rv2); }
1313 INLINE l_ivector &operator |=(l_ivector &rv, const rvector_slice &sl)
1314#if(CXSC_INDEX_CHECK)
1315
1316#else
1317 noexcept
1318#endif
1319 { return _vvsconvassign(rv,sl); }
1321#if(CXSC_INDEX_CHECK)
1322
1323#else
1324 noexcept
1325#endif
1326 { return _vsvconvassign(*this,rv); }
1328#if(CXSC_INDEX_CHECK)
1329
1330#else
1331 noexcept
1332#endif
1333 { return _vsvsconvassign(*this,sl2); }
1334
1335 INLINE l_ivector operator &(const rvector &rv1, const l_ivector &rv2)
1336#if(CXSC_INDEX_CHECK)
1337
1338#else
1339 noexcept
1340#endif
1341 { return _vvsect<rvector,l_ivector,l_ivector>(rv1,rv2); }
1342 INLINE l_ivector operator &(const rvector &rv, const l_ivector_slice &sl)
1343#if(CXSC_INDEX_CHECK)
1344
1345#else
1346 noexcept
1347#endif
1348 { return _vvssect<rvector,l_ivector_slice,l_ivector>(rv,sl); }
1349 INLINE l_ivector operator &(const rvector_slice &sl, const l_ivector &rv)
1350#if(CXSC_INDEX_CHECK)
1351
1352#else
1353 noexcept
1354#endif
1355 { return _vvssect<l_ivector,rvector_slice,l_ivector>(rv,sl); }
1356 INLINE l_ivector operator &(const rvector_slice &sl1, const l_ivector_slice &sl2)
1357#if(CXSC_INDEX_CHECK)
1358
1359#else
1360 noexcept
1361#endif
1362 { return _vsvssect<rvector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
1363
1364 INLINE l_ivector operator &(const l_ivector &rv1, const rvector &rv2)
1365#if(CXSC_INDEX_CHECK)
1366
1367#else
1368 noexcept
1369#endif
1370 { return _vvsect<rvector,l_ivector,l_ivector>(rv2,rv1); }
1371 INLINE l_ivector operator &(const l_ivector &rv, const rvector_slice &sl)
1372#if(CXSC_INDEX_CHECK)
1373
1374#else
1375 noexcept
1376#endif
1377 { return _vvssect<l_ivector,rvector_slice,l_ivector>(rv,sl); }
1378 INLINE l_ivector operator &(const l_ivector_slice &sl, const rvector &rv)
1379#if(CXSC_INDEX_CHECK)
1380
1381#else
1382 noexcept
1383#endif
1384 { return _vvssect<rvector,l_ivector_slice,l_ivector>(rv,sl); }
1385 INLINE l_ivector operator &(const l_ivector_slice &sl1, const rvector_slice &sl2)
1386#if(CXSC_INDEX_CHECK)
1387
1388#else
1389 noexcept
1390#endif
1391 { return _vsvssect<rvector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
1392
1393 INLINE l_ivector & operator &=(l_ivector &rv1, const rvector &rv2)
1394#if(CXSC_INDEX_CHECK)
1395
1396#else
1397 noexcept
1398#endif
1399 { return _vvsectassign(rv1,rv2); }
1400 INLINE l_ivector &operator &=(l_ivector &rv, const rvector_slice &sl)
1401#if(CXSC_INDEX_CHECK)
1402
1403#else
1404 noexcept
1405#endif
1406 { return _vvssectassign(rv,sl); }
1408#if(CXSC_INDEX_CHECK)
1409
1410#else
1411 noexcept
1412#endif
1413 { return _vsvsectassign(*this,rv); }
1415#if(CXSC_INDEX_CHECK)
1416
1417#else
1418 noexcept
1419#endif
1420 { return _vsvssectassign(*this,sl2); }
1421
1422//-------------------------------- l_interval / l_real --------------------------------
1423
1424 INLINE l_ivector &l_ivector::operator =(const l_rvector &rv) noexcept { return _vvassign<l_ivector,l_rvector,l_interval>(*this,rv); }
1425 INLINE l_ivector &l_ivector::operator =(const l_real &r) noexcept { return _vsassign<l_ivector,l_real>(*this,r); }
1426 INLINE l_ivector & l_ivector::operator =(const l_rvector_slice &sl) noexcept { return _vvsassign<l_ivector,l_rvector_slice,l_interval>(*this,sl); }
1428#if(CXSC_INDEX_CHECK)
1429
1430#else
1431 noexcept
1432#endif
1433 { return _vsvassign(*this,rv); }
1434 INLINE l_ivector_slice &l_ivector_slice::operator =(const l_real &r) noexcept { return _vssassign<l_ivector_slice,l_real>(*this,r); }
1436#if(CXSC_INDEX_CHECK)
1437
1438#else
1439 noexcept
1440#endif
1441 { return _vsvsassign(*this,sl); }
1442
1443 INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const l_ivector &rv2)
1444#if(CXSC_INDEX_CHECK)
1445
1446#else
1447 noexcept
1448#endif
1449 { _vvaccu(dp,rv1,rv2); }
1450 INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const l_rvector &rv2)
1451#if(CXSC_INDEX_CHECK)
1452
1453#else
1454 noexcept
1455#endif
1456 { _vvaccu(dp,rv2,rv1); }
1457 INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl, const l_ivector &rv)
1458#if(CXSC_INDEX_CHECK)
1459
1460#else
1461 noexcept
1462#endif
1463 { _vsvaccu(dp,sl,rv); }
1464 INLINE void accumulate(idotprecision &dp,const l_ivector_slice &sl,const l_rvector &rv)
1465#if(CXSC_INDEX_CHECK)
1466
1467#else
1468 noexcept
1469#endif
1470 { _vsvaccu(dp,sl,rv); }
1471 INLINE void accumulate(idotprecision &dp, const l_rvector &rv, const l_ivector_slice &sl)
1472#if(CXSC_INDEX_CHECK)
1473
1474#else
1475 noexcept
1476#endif
1477 { _vsvaccu(dp,sl,rv); }
1478 INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const l_imatrix_subv &rv2)
1479#if(CXSC_INDEX_CHECK)
1480
1481#else
1482 noexcept
1483#endif
1484 ;
1485 INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const rmatrix_subv &rv2)
1486#if(CXSC_INDEX_CHECK)
1487
1488#else
1489 noexcept
1490#endif
1491 ;
1492 INLINE void accumulate(idotprecision &dp,const l_ivector &rv,const l_rvector_slice &sl)
1493#if(CXSC_INDEX_CHECK)
1494
1495#else
1496 noexcept
1497#endif
1498 { _vsvaccu(dp,sl,rv); }
1499 INLINE void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const l_ivector &rv2)
1500#if(CXSC_INDEX_CHECK)
1501
1502#else
1503 noexcept
1504#endif
1505 ;
1506 INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_rvector &rv2)
1507#if(CXSC_INDEX_CHECK)
1508
1509#else
1510 noexcept
1511#endif
1512 ;
1513 INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl1, const l_rvector_slice &sl2)
1514#if(CXSC_INDEX_CHECK)
1515
1516#else
1517 noexcept
1518#endif
1519 { _vsvsaccu(dp,sl2,sl1); }
1520 INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl1, const l_ivector_slice &sl2)
1521#if(CXSC_INDEX_CHECK)
1522
1523#else
1524 noexcept
1525#endif
1526 { _vsvsaccu(dp,sl1,sl2); }
1527
1528 INLINE l_interval operator *(const l_rvector & rv1, const l_ivector &rv2)
1529#if(CXSC_INDEX_CHECK)
1530
1531#else
1532 noexcept
1533#endif
1534 { return _vvlimult<l_rvector,l_ivector,l_interval>(rv1,rv2); }
1535 INLINE l_interval operator *(const l_rvector_slice &sl, const l_ivector &rv)
1536#if(CXSC_INDEX_CHECK)
1537
1538#else
1539 noexcept
1540#endif
1541 { return _vsvlimult<l_rvector_slice,l_ivector,l_interval>(sl,rv); }
1542 INLINE l_interval operator *(const l_rvector &rv, const l_ivector_slice &sl)
1543#if(CXSC_INDEX_CHECK)
1544
1545#else
1546 noexcept
1547#endif
1548 { return _vsvlimult<l_ivector_slice,l_rvector,l_interval>(sl,rv); }
1550#if(CXSC_INDEX_CHECK)
1551
1552#else
1553 noexcept
1554#endif
1555 { return _vsvslimult<l_rvector_slice,l_ivector_slice,l_interval>(sl1,sl2); }
1556
1557 INLINE l_interval operator *(const l_ivector & rv1, const l_rvector &rv2)
1558#if(CXSC_INDEX_CHECK)
1559
1560#else
1561 noexcept
1562#endif
1563 { return _vvlimult<l_rvector,l_ivector,l_interval>(rv2,rv1); }
1564 INLINE l_interval operator *(const l_ivector_slice &sl, const l_rvector &rv)
1565#if(CXSC_INDEX_CHECK)
1566
1567#else
1568 noexcept
1569#endif
1570 { return _vsvlimult<l_ivector_slice,l_rvector,l_interval>(sl,rv); }
1571 INLINE l_interval operator *(const l_ivector &rv, const l_rvector_slice &sl)
1572#if(CXSC_INDEX_CHECK)
1573
1574#else
1575 noexcept
1576#endif
1577 { return _vsvlimult<l_rvector_slice,l_ivector,l_interval>(sl,rv); }
1579#if(CXSC_INDEX_CHECK)
1580
1581#else
1582 noexcept
1583#endif
1584 { return _vsvslimult<l_rvector_slice,l_ivector_slice,l_interval>(sl2,sl1); }
1585
1586 INLINE l_ivector operator +(const l_rvector &rv1, const l_ivector &rv2)
1587#if(CXSC_INDEX_CHECK)
1588
1589#else
1590 noexcept
1591#endif
1592 { return _vvplus<l_rvector,l_ivector,l_ivector>(rv1,rv2); }
1593 INLINE l_ivector operator +(const l_rvector &rv, const l_ivector_slice &sl)
1594#if(CXSC_INDEX_CHECK)
1595
1596#else
1597 noexcept
1598#endif
1599 { return _vvsplus<l_rvector,l_ivector_slice,l_ivector>(rv,sl); }
1600 INLINE l_ivector operator +(const l_rvector_slice &sl, const l_ivector &rv)
1601#if(CXSC_INDEX_CHECK)
1602
1603#else
1604 noexcept
1605#endif
1606 { return _vvsplus<l_ivector,l_rvector_slice,l_ivector>(rv,sl); }
1607 INLINE l_ivector operator +(const l_rvector_slice &sl1, const l_ivector_slice &sl2)
1608#if(CXSC_INDEX_CHECK)
1609
1610#else
1611 noexcept
1612#endif
1613 { return _vsvsplus<l_rvector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
1614
1615 INLINE l_ivector operator +(const l_ivector &rv1, const l_rvector &rv2)
1616#if(CXSC_INDEX_CHECK)
1617
1618#else
1619 noexcept
1620#endif
1621 { return _vvplus<l_rvector,l_ivector,l_ivector>(rv2,rv1); }
1622 INLINE l_ivector operator +(const l_ivector &rv, const l_rvector_slice &sl)
1623#if(CXSC_INDEX_CHECK)
1624
1625#else
1626 noexcept
1627#endif
1628 { return _vvsplus<l_ivector,l_rvector_slice,l_ivector>(rv,sl); }
1629 INLINE l_ivector operator +(const l_ivector_slice &sl, const l_rvector &rv)
1630#if(CXSC_INDEX_CHECK)
1631
1632#else
1633 noexcept
1634#endif
1635 { return _vvsplus<l_rvector,l_ivector_slice,l_ivector>(rv,sl); }
1636 INLINE l_ivector operator +(const l_ivector_slice &sl1, const l_rvector_slice &sl2)
1637#if(CXSC_INDEX_CHECK)
1638
1639#else
1640 noexcept
1641#endif
1642 { return _vsvsplus<l_rvector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
1643
1644 INLINE l_ivector & operator +=(l_ivector &rv1, const l_rvector &rv2)
1645#if(CXSC_INDEX_CHECK)
1646
1647#else
1648 noexcept
1649#endif
1650 { return _vvplusassign(rv1,rv2); }
1652#if(CXSC_INDEX_CHECK)
1653
1654#else
1655 noexcept
1656#endif
1657 { return _vvsplusassign(rv,sl); }
1659#if(CXSC_INDEX_CHECK)
1660
1661#else
1662 noexcept
1663#endif
1664 { return _vsvplusassign(*this,rv); }
1666#if(CXSC_INDEX_CHECK)
1667
1668#else
1669 noexcept
1670#endif
1671 { return _vsvsplusassign(*this,sl2); }
1672
1673 INLINE l_ivector operator -(const l_rvector &rv1, const l_ivector &rv2)
1674#if(CXSC_INDEX_CHECK)
1675
1676#else
1677 noexcept
1678#endif
1679 { return _vvminus<l_rvector,l_ivector,l_ivector>(rv1,rv2); }
1680 INLINE l_ivector operator -(const l_rvector &rv, const l_ivector_slice &sl)
1681#if(CXSC_INDEX_CHECK)
1682
1683#else
1684 noexcept
1685#endif
1686 { return _vvsminus<l_rvector,l_ivector_slice,l_ivector>(rv,sl); }
1687 INLINE l_ivector operator -(const l_rvector_slice &sl, const l_ivector &rv)
1688#if(CXSC_INDEX_CHECK)
1689
1690#else
1691 noexcept
1692#endif
1693 { return _vsvminus<l_rvector_slice,l_ivector,l_ivector>(sl,rv); }
1694 INLINE l_ivector operator -(const l_rvector_slice &sl1, const l_ivector_slice &sl2)
1695#if(CXSC_INDEX_CHECK)
1696
1697#else
1698 noexcept
1699#endif
1700 { return _vsvsminus<l_rvector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
1701
1702 INLINE l_ivector operator -(const l_ivector &rv1, const l_rvector &rv2)
1703#if(CXSC_INDEX_CHECK)
1704
1705#else
1706 noexcept
1707#endif
1708 { return _vvminus<l_ivector,l_rvector,l_ivector>(rv1,rv2); }
1709 INLINE l_ivector operator -(const l_ivector &rv, const l_rvector_slice &sl)
1710#if(CXSC_INDEX_CHECK)
1711
1712#else
1713 noexcept
1714#endif
1715 { return _vvsminus<l_ivector,l_rvector_slice,l_ivector>(rv,sl); }
1716 INLINE l_ivector operator -(const l_ivector_slice &sl, const l_rvector &rv)
1717#if(CXSC_INDEX_CHECK)
1718
1719#else
1720 noexcept
1721#endif
1722 { return _vsvminus<l_ivector_slice,l_rvector,l_ivector>(sl,rv); }
1723 INLINE l_ivector operator -(const l_ivector_slice &sl1, const l_rvector_slice &sl2)
1724#if(CXSC_INDEX_CHECK)
1725
1726#else
1727 noexcept
1728#endif
1729 { return _vsvsminus<l_ivector_slice,l_rvector_slice,l_ivector>(sl1,sl2); }
1730
1731 INLINE l_ivector & operator -=(l_ivector &rv1, const l_rvector &rv2)
1732#if(CXSC_INDEX_CHECK)
1733
1734#else
1735 noexcept
1736#endif
1737 { return _vvminusassign(rv1,rv2); }
1738 INLINE l_ivector &operator -=(l_ivector &rv, const l_rvector_slice &sl)
1739#if(CXSC_INDEX_CHECK)
1740
1741#else
1742 noexcept
1743#endif
1744 { return _vvsminusassign(rv,sl); }
1746#if(CXSC_INDEX_CHECK)
1747
1748#else
1749 noexcept
1750#endif
1751 { return _vsvminusassign(*this,rv); }
1753#if(CXSC_INDEX_CHECK)
1754
1755#else
1756 noexcept
1757#endif
1758 { return _vsvsminusassign(*this,sl2); }
1759
1760 INLINE l_ivector operator |(const l_rvector &rv1, const l_ivector &rv2)
1761#if(CXSC_INDEX_CHECK)
1762
1763#else
1764 noexcept
1765#endif
1766 { return _vvconv<l_rvector,l_ivector,l_ivector>(rv1,rv2); }
1767 INLINE l_ivector operator |(const l_rvector &rv, const l_ivector_slice &sl)
1768#if(CXSC_INDEX_CHECK)
1769
1770#else
1771 noexcept
1772#endif
1773 { return _vvsconv<l_rvector,l_ivector_slice,l_ivector>(rv,sl); }
1774 INLINE l_ivector operator |(const l_rvector_slice &sl, const l_ivector &rv)
1775#if(CXSC_INDEX_CHECK)
1776
1777#else
1778 noexcept
1779#endif
1780 { return _vvsconv<l_ivector,l_rvector_slice,l_ivector>(rv,sl); }
1781 INLINE l_ivector operator |(const l_rvector_slice &sl1, const l_ivector_slice &sl2)
1782#if(CXSC_INDEX_CHECK)
1783
1784#else
1785 noexcept
1786#endif
1787 { return _vsvsconv<l_rvector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
1788
1789 INLINE l_ivector operator |(const l_ivector &rv1, const l_rvector &rv2)
1790#if(CXSC_INDEX_CHECK)
1791
1792#else
1793 noexcept
1794#endif
1795 { return _vvconv<l_rvector,l_ivector,l_ivector>(rv2,rv1); }
1796 INLINE l_ivector operator |(const l_ivector &rv, const l_rvector_slice &sl)
1797#if(CXSC_INDEX_CHECK)
1798
1799#else
1800 noexcept
1801#endif
1802 { return _vvsconv<l_ivector,l_rvector_slice,l_ivector>(rv,sl); }
1803 INLINE l_ivector operator |(const l_ivector_slice &sl, const l_rvector &rv)
1804#if(CXSC_INDEX_CHECK)
1805
1806#else
1807 noexcept
1808#endif
1809 { return _vvsconv<l_rvector,l_ivector_slice,l_ivector>(rv,sl); }
1810 INLINE l_ivector operator |(const l_ivector_slice &sl1, const l_rvector_slice &sl2)
1811#if(CXSC_INDEX_CHECK)
1812
1813#else
1814 noexcept
1815#endif
1816 { return _vsvsconv<l_rvector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
1817
1818 INLINE l_ivector & operator |=(l_ivector &rv1, const l_rvector &rv2)
1819#if(CXSC_INDEX_CHECK)
1820
1821#else
1822 noexcept
1823#endif
1824 { return _vvconvassign(rv1,rv2); }
1825 INLINE l_ivector &operator |=(l_ivector &rv, const l_rvector_slice &sl)
1826#if(CXSC_INDEX_CHECK)
1827
1828#else
1829 noexcept
1830#endif
1831 { return _vvsconvassign(rv,sl); }
1833#if(CXSC_INDEX_CHECK)
1834
1835#else
1836 noexcept
1837#endif
1838 { return _vsvconvassign(*this,rv); }
1840#if(CXSC_INDEX_CHECK)
1841
1842#else
1843 noexcept
1844#endif
1845 { return _vsvsconvassign(*this,sl2); }
1846
1847 INLINE l_ivector operator &(const l_rvector &rv1, const l_ivector &rv2)
1848#if(CXSC_INDEX_CHECK)
1849
1850#else
1851 noexcept
1852#endif
1853 { return _vvsect<l_rvector,l_ivector,l_ivector>(rv1,rv2); }
1854 INLINE l_ivector operator &(const l_rvector &rv, const l_ivector_slice &sl)
1855#if(CXSC_INDEX_CHECK)
1856
1857#else
1858 noexcept
1859#endif
1860 { return _vvssect<l_rvector,l_ivector_slice,l_ivector>(rv,sl); }
1861 INLINE l_ivector operator &(const l_rvector_slice &sl, const l_ivector &rv)
1862#if(CXSC_INDEX_CHECK)
1863
1864#else
1865 noexcept
1866#endif
1867 { return _vvssect<l_ivector,l_rvector_slice,l_ivector>(rv,sl); }
1868 INLINE l_ivector operator &(const l_rvector_slice &sl1, const l_ivector_slice &sl2)
1869#if(CXSC_INDEX_CHECK)
1870
1871#else
1872 noexcept
1873#endif
1874 { return _vsvssect<l_rvector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
1875
1876 INLINE l_ivector operator &(const l_ivector &rv1, const l_rvector &rv2)
1877#if(CXSC_INDEX_CHECK)
1878
1879#else
1880 noexcept
1881#endif
1882 { return _vvsect<l_rvector,l_ivector,l_ivector>(rv2,rv1); }
1883 INLINE l_ivector operator &(const l_ivector &rv, const l_rvector_slice &sl)
1884#if(CXSC_INDEX_CHECK)
1885
1886#else
1887 noexcept
1888#endif
1889 { return _vvssect<l_ivector,l_rvector_slice,l_ivector>(rv,sl); }
1890 INLINE l_ivector operator &(const l_ivector_slice &sl, const l_rvector &rv)
1891#if(CXSC_INDEX_CHECK)
1892
1893#else
1894 noexcept
1895#endif
1896 { return _vvssect<l_rvector,l_ivector_slice,l_ivector>(rv,sl); }
1897 INLINE l_ivector operator &(const l_ivector_slice &sl1, const l_rvector_slice &sl2)
1898#if(CXSC_INDEX_CHECK)
1899
1900#else
1901 noexcept
1902#endif
1903 { return _vsvssect<l_rvector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
1904
1905 INLINE l_ivector & operator &=(l_ivector &rv1, const l_rvector &rv2)
1906#if(CXSC_INDEX_CHECK)
1907
1908#else
1909 noexcept
1910#endif
1911 { return _vvsectassign(rv1,rv2); }
1912 INLINE l_ivector &operator &=(l_ivector &rv, const l_rvector_slice &sl)
1913#if(CXSC_INDEX_CHECK)
1914
1915#else
1916 noexcept
1917#endif
1918 { return _vvssectassign(rv,sl); }
1920#if(CXSC_INDEX_CHECK)
1921
1922#else
1923 noexcept
1924#endif
1925 { return _vsvsectassign(*this,rv); }
1927#if(CXSC_INDEX_CHECK)
1928
1929#else
1930 noexcept
1931#endif
1932 { return _vsvssectassign(*this,sl2); }
1933
1934//-------------------------------- l_interval / interval --------------------------------
1935
1936 INLINE l_ivector &l_ivector::operator =(const ivector &rv) noexcept { return _vvassign<l_ivector,ivector,l_interval>(*this,rv); }
1937 INLINE l_ivector &l_ivector::operator =(const interval &r) noexcept { return _vsassign<l_ivector,interval>(*this,r); }
1938 INLINE l_ivector & l_ivector::operator =(const ivector_slice &sl) noexcept { return _vvsassign<l_ivector,ivector_slice,l_interval>(*this,sl); }
1940#if(CXSC_INDEX_CHECK)
1941
1942#else
1943 noexcept
1944#endif
1945 { return _vsvassign(*this,rv); }
1946 INLINE l_ivector_slice &l_ivector_slice::operator =(const interval &r) noexcept { return _vssassign<l_ivector_slice,interval>(*this,r); }
1948#if(CXSC_INDEX_CHECK)
1949
1950#else
1951 noexcept
1952#endif
1953 { return _vsvsassign(*this,sl); }
1954
1955 INLINE void accumulate(idotprecision &dp, const ivector & rv1, const l_ivector &rv2)
1956#if(CXSC_INDEX_CHECK)
1957
1958#else
1959 noexcept
1960#endif
1961 { _vvaccu(dp,rv1,rv2); }
1962 INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const ivector &rv2)
1963#if(CXSC_INDEX_CHECK)
1964
1965#else
1966 noexcept
1967#endif
1968 { _vvaccu(dp,rv2,rv1); }
1969 INLINE void accumulate(idotprecision &dp, const ivector_slice & sl, const l_ivector &rv)
1970#if(CXSC_INDEX_CHECK)
1971
1972#else
1973 noexcept
1974#endif
1975 { _vsvaccu(dp,sl,rv); }
1976 INLINE void accumulate(idotprecision &dp,const l_ivector_slice &sl,const ivector &rv)
1977#if(CXSC_INDEX_CHECK)
1978
1979#else
1980 noexcept
1981#endif
1982 { _vsvaccu(dp,sl,rv); }
1983 INLINE void accumulate(idotprecision &dp, const ivector &rv, const l_ivector_slice &sl)
1984#if(CXSC_INDEX_CHECK)
1985
1986#else
1987 noexcept
1988#endif
1989 { _vsvaccu(dp,sl,rv); }
1990 INLINE void accumulate(idotprecision &dp, const ivector & rv1, const l_imatrix_subv &rv2)
1991#if(CXSC_INDEX_CHECK)
1992
1993#else
1994 noexcept
1995#endif
1996 ;
1997 INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const rmatrix_subv &rv2)
1998#if(CXSC_INDEX_CHECK)
1999
2000#else
2001 noexcept
2002#endif
2003 ;
2004 INLINE void accumulate(idotprecision &dp,const l_ivector &rv,const ivector_slice &sl)
2005#if(CXSC_INDEX_CHECK)
2006
2007#else
2008 noexcept
2009#endif
2010 { _vsvaccu(dp,sl,rv); }
2011 INLINE void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const l_ivector &rv2)
2012#if(CXSC_INDEX_CHECK)
2013
2014#else
2015 noexcept
2016#endif
2017 ;
2018 INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const ivector &rv2)
2019#if(CXSC_INDEX_CHECK)
2020
2021#else
2022 noexcept
2023#endif
2024 ;
2025 INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl1, const ivector_slice &sl2)
2026#if(CXSC_INDEX_CHECK)
2027
2028#else
2029 noexcept
2030#endif
2031 { _vsvsaccu(dp,sl2,sl1); }
2032 INLINE void accumulate(idotprecision &dp, const ivector_slice & sl1, const l_ivector_slice &sl2)
2033#if(CXSC_INDEX_CHECK)
2034
2035#else
2036 noexcept
2037#endif
2038 { _vsvsaccu(dp,sl1,sl2); }
2039
2040 INLINE l_interval operator *(const ivector & rv1, const l_ivector &rv2)
2041#if(CXSC_INDEX_CHECK)
2042
2043#else
2044 noexcept
2045#endif
2046 { return _vvlimult<ivector,l_ivector,l_interval>(rv1,rv2); }
2047 INLINE l_interval operator *(const ivector_slice &sl, const l_ivector &rv)
2048#if(CXSC_INDEX_CHECK)
2049
2050#else
2051 noexcept
2052#endif
2053 { return _vsvlimult<ivector_slice,l_ivector,l_interval>(sl,rv); }
2054 INLINE l_interval operator *(const ivector &rv, const l_ivector_slice &sl)
2055#if(CXSC_INDEX_CHECK)
2056
2057#else
2058 noexcept
2059#endif
2060 { return _vsvlimult<l_ivector_slice,ivector,l_interval>(sl,rv); }
2061 INLINE l_interval operator *(const ivector_slice & sl1, const l_ivector_slice &sl2)
2062#if(CXSC_INDEX_CHECK)
2063
2064#else
2065 noexcept
2066#endif
2067 { return _vsvslimult<ivector_slice,l_ivector_slice,l_interval>(sl1,sl2); }
2068
2069 INLINE l_interval operator *(const l_ivector & rv1, const ivector &rv2)
2070#if(CXSC_INDEX_CHECK)
2071
2072#else
2073 noexcept
2074#endif
2075 { return _vvlimult<ivector,l_ivector,l_interval>(rv2,rv1); }
2076 INLINE l_interval operator *(const l_ivector_slice &sl, const ivector &rv)
2077#if(CXSC_INDEX_CHECK)
2078
2079#else
2080 noexcept
2081#endif
2082 { return _vsvlimult<l_ivector_slice,ivector,l_interval>(sl,rv); }
2083 INLINE l_interval operator *(const l_ivector &rv, const ivector_slice &sl)
2084#if(CXSC_INDEX_CHECK)
2085
2086#else
2087 noexcept
2088#endif
2089 { return _vsvlimult<ivector_slice,l_ivector,l_interval>(sl,rv); }
2090 INLINE l_interval operator *(const l_ivector_slice & sl1, const ivector_slice &sl2)
2091#if(CXSC_INDEX_CHECK)
2092
2093#else
2094 noexcept
2095#endif
2096 { return _vsvslimult<ivector_slice,l_ivector_slice,l_interval>(sl2,sl1); }
2097
2098 INLINE l_ivector operator +(const ivector &rv1, const l_ivector &rv2)
2099#if(CXSC_INDEX_CHECK)
2100
2101#else
2102 noexcept
2103#endif
2104 { return _vvplus<ivector,l_ivector,l_ivector>(rv1,rv2); }
2105 INLINE l_ivector operator +(const ivector &rv, const l_ivector_slice &sl)
2106#if(CXSC_INDEX_CHECK)
2107
2108#else
2109 noexcept
2110#endif
2111 { return _vvsplus<ivector,l_ivector_slice,l_ivector>(rv,sl); }
2112 INLINE l_ivector operator +(const ivector_slice &sl, const l_ivector &rv)
2113#if(CXSC_INDEX_CHECK)
2114
2115#else
2116 noexcept
2117#endif
2118 { return _vvsplus<l_ivector,ivector_slice,l_ivector>(rv,sl); }
2119 INLINE l_ivector operator +(const ivector_slice &sl1, const l_ivector_slice &sl2)
2120#if(CXSC_INDEX_CHECK)
2121
2122#else
2123 noexcept
2124#endif
2125 { return _vsvsplus<ivector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
2126
2127 INLINE l_ivector operator +(const l_ivector &rv1, const ivector &rv2)
2128#if(CXSC_INDEX_CHECK)
2129
2130#else
2131 noexcept
2132#endif
2133 { return _vvplus<ivector,l_ivector,l_ivector>(rv2,rv1); }
2134 INLINE l_ivector operator +(const l_ivector &rv, const ivector_slice &sl)
2135#if(CXSC_INDEX_CHECK)
2136
2137#else
2138 noexcept
2139#endif
2140 { return _vvsplus<l_ivector,ivector_slice,l_ivector>(rv,sl); }
2141 INLINE l_ivector operator +(const l_ivector_slice &sl, const ivector &rv)
2142#if(CXSC_INDEX_CHECK)
2143
2144#else
2145 noexcept
2146#endif
2147 { return _vvsplus<ivector,l_ivector_slice,l_ivector>(rv,sl); }
2148 INLINE l_ivector operator +(const l_ivector_slice &sl1, const ivector_slice &sl2)
2149#if(CXSC_INDEX_CHECK)
2150
2151#else
2152 noexcept
2153#endif
2154 { return _vsvsplus<ivector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
2155
2156 INLINE l_ivector & operator +=(l_ivector &rv1, const ivector &rv2)
2157#if(CXSC_INDEX_CHECK)
2158
2159#else
2160 noexcept
2161#endif
2162 { return _vvplusassign(rv1,rv2); }
2164#if(CXSC_INDEX_CHECK)
2165
2166#else
2167 noexcept
2168#endif
2169 { return _vvsplusassign(rv,sl); }
2171#if(CXSC_INDEX_CHECK)
2172
2173#else
2174 noexcept
2175#endif
2176 { return _vsvplusassign(*this,rv); }
2178#if(CXSC_INDEX_CHECK)
2179
2180#else
2181 noexcept
2182#endif
2183 { return _vsvsplusassign(*this,sl2); }
2184
2185 INLINE l_ivector operator -(const ivector &rv1, const l_ivector &rv2)
2186#if(CXSC_INDEX_CHECK)
2187
2188#else
2189 noexcept
2190#endif
2191 { return _vvminus<ivector,l_ivector,l_ivector>(rv1,rv2); }
2192 INLINE l_ivector operator -(const ivector &rv, const l_ivector_slice &sl)
2193#if(CXSC_INDEX_CHECK)
2194
2195#else
2196 noexcept
2197#endif
2198 { return _vvsminus<ivector,l_ivector_slice,l_ivector>(rv,sl); }
2199 INLINE l_ivector operator -(const ivector_slice &sl, const l_ivector &rv)
2200#if(CXSC_INDEX_CHECK)
2201
2202#else
2203 noexcept
2204#endif
2205 { return _vsvminus<ivector_slice,l_ivector,l_ivector>(sl,rv); }
2206 INLINE l_ivector operator -(const ivector_slice &sl1, const l_ivector_slice &sl2)
2207#if(CXSC_INDEX_CHECK)
2208
2209#else
2210 noexcept
2211#endif
2212 { return _vsvsminus<ivector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
2213
2214 INLINE l_ivector operator -(const l_ivector &rv1, const ivector &rv2)
2215#if(CXSC_INDEX_CHECK)
2216
2217#else
2218 noexcept
2219#endif
2220 { return _vvminus<l_ivector,ivector,l_ivector>(rv1,rv2); }
2221 INLINE l_ivector operator -(const l_ivector &rv, const ivector_slice &sl)
2222#if(CXSC_INDEX_CHECK)
2223
2224#else
2225 noexcept
2226#endif
2227 { return _vvsminus<l_ivector,ivector_slice,l_ivector>(rv,sl); }
2228 INLINE l_ivector operator -(const l_ivector_slice &sl, const ivector &rv)
2229#if(CXSC_INDEX_CHECK)
2230
2231#else
2232 noexcept
2233#endif
2234 { return _vsvminus<l_ivector_slice,ivector,l_ivector>(sl,rv); }
2235 INLINE l_ivector operator -(const l_ivector_slice &sl1, const ivector_slice &sl2)
2236#if(CXSC_INDEX_CHECK)
2237
2238#else
2239 noexcept
2240#endif
2241 { return _vsvsminus<l_ivector_slice,ivector_slice,l_ivector>(sl1,sl2); }
2242
2243 INLINE l_ivector & operator -=(l_ivector &rv1, const ivector &rv2)
2244#if(CXSC_INDEX_CHECK)
2245
2246#else
2247 noexcept
2248#endif
2249 { return _vvminusassign(rv1,rv2); }
2250 INLINE l_ivector &operator -=(l_ivector &rv, const ivector_slice &sl)
2251#if(CXSC_INDEX_CHECK)
2252
2253#else
2254 noexcept
2255#endif
2256 { return _vvsminusassign(rv,sl); }
2258#if(CXSC_INDEX_CHECK)
2259
2260#else
2261 noexcept
2262#endif
2263 { return _vsvminusassign(*this,rv); }
2265#if(CXSC_INDEX_CHECK)
2266
2267#else
2268 noexcept
2269#endif
2270 { return _vsvsminusassign(*this,sl2); }
2271
2272 INLINE l_ivector operator |(const ivector &rv1, const l_ivector &rv2)
2273#if(CXSC_INDEX_CHECK)
2274
2275#else
2276 noexcept
2277#endif
2278 { return _vvconv<ivector,l_ivector,l_ivector>(rv1,rv2); }
2279 INLINE l_ivector operator |(const ivector &rv, const l_ivector_slice &sl)
2280#if(CXSC_INDEX_CHECK)
2281
2282#else
2283 noexcept
2284#endif
2285 { return _vvsconv<ivector,l_ivector_slice,l_ivector>(rv,sl); }
2286 INLINE l_ivector operator |(const ivector_slice &sl, const l_ivector &rv)
2287#if(CXSC_INDEX_CHECK)
2288
2289#else
2290 noexcept
2291#endif
2292 { return _vvsconv<l_ivector,ivector_slice,l_ivector>(rv,sl); }
2293 INLINE l_ivector operator |(const ivector_slice &sl1, const l_ivector_slice &sl2)
2294#if(CXSC_INDEX_CHECK)
2295
2296#else
2297 noexcept
2298#endif
2299 { return _vsvsconv<ivector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
2300
2301 INLINE l_ivector operator |(const l_ivector &rv1, const ivector &rv2)
2302#if(CXSC_INDEX_CHECK)
2303
2304#else
2305 noexcept
2306#endif
2307 { return _vvconv<ivector,l_ivector,l_ivector>(rv2,rv1); }
2308 INLINE l_ivector operator |(const l_ivector &rv, const ivector_slice &sl)
2309#if(CXSC_INDEX_CHECK)
2310
2311#else
2312 noexcept
2313#endif
2314 { return _vvsconv<l_ivector,ivector_slice,l_ivector>(rv,sl); }
2315 INLINE l_ivector operator |(const l_ivector_slice &sl, const ivector &rv)
2316#if(CXSC_INDEX_CHECK)
2317
2318#else
2319 noexcept
2320#endif
2321 { return _vvsconv<ivector,l_ivector_slice,l_ivector>(rv,sl); }
2322 INLINE l_ivector operator |(const l_ivector_slice &sl1, const ivector_slice &sl2)
2323#if(CXSC_INDEX_CHECK)
2324
2325#else
2326 noexcept
2327#endif
2328 { return _vsvsconv<ivector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
2329
2330 INLINE l_ivector & operator |=(l_ivector &rv1, const ivector &rv2)
2331#if(CXSC_INDEX_CHECK)
2332
2333#else
2334 noexcept
2335#endif
2336 { return _vvconvassign(rv1,rv2); }
2337 INLINE l_ivector &operator |=(l_ivector &rv, const ivector_slice &sl)
2338#if(CXSC_INDEX_CHECK)
2339
2340#else
2341 noexcept
2342#endif
2343 { return _vvsconvassign(rv,sl); }
2345#if(CXSC_INDEX_CHECK)
2346
2347#else
2348 noexcept
2349#endif
2350 { return _vsvconvassign(*this,rv); }
2352#if(CXSC_INDEX_CHECK)
2353
2354#else
2355 noexcept
2356#endif
2357 { return _vsvsconvassign(*this,sl2); }
2358
2359 INLINE l_ivector operator &(const ivector &rv1, const l_ivector &rv2)
2360#if(CXSC_INDEX_CHECK)
2361
2362#else
2363 noexcept
2364#endif
2365 { return _vvsect<ivector,l_ivector,l_ivector>(rv1,rv2); }
2366 INLINE l_ivector operator &(const ivector &rv, const l_ivector_slice &sl)
2367#if(CXSC_INDEX_CHECK)
2368
2369#else
2370 noexcept
2371#endif
2372 { return _vvssect<ivector,l_ivector_slice,l_ivector>(rv,sl); }
2373 INLINE l_ivector operator &(const ivector_slice &sl, const l_ivector &rv)
2374#if(CXSC_INDEX_CHECK)
2375
2376#else
2377 noexcept
2378#endif
2379 { return _vvssect<l_ivector,ivector_slice,l_ivector>(rv,sl); }
2380 INLINE l_ivector operator &(const ivector_slice &sl1, const l_ivector_slice &sl2)
2381#if(CXSC_INDEX_CHECK)
2382
2383#else
2384 noexcept
2385#endif
2386 { return _vsvssect<ivector_slice,l_ivector_slice,l_ivector>(sl1,sl2); }
2387
2388 INLINE l_ivector operator &(const l_ivector &rv1, const ivector &rv2)
2389#if(CXSC_INDEX_CHECK)
2390
2391#else
2392 noexcept
2393#endif
2394 { return _vvsect<ivector,l_ivector,l_ivector>(rv2,rv1); }
2395 INLINE l_ivector operator &(const l_ivector &rv, const ivector_slice &sl)
2396#if(CXSC_INDEX_CHECK)
2397
2398#else
2399 noexcept
2400#endif
2401 { return _vvssect<l_ivector,ivector_slice,l_ivector>(rv,sl); }
2402 INLINE l_ivector operator &(const l_ivector_slice &sl, const ivector &rv)
2403#if(CXSC_INDEX_CHECK)
2404
2405#else
2406 noexcept
2407#endif
2408 { return _vvssect<ivector,l_ivector_slice,l_ivector>(rv,sl); }
2409 INLINE l_ivector operator &(const l_ivector_slice &sl1, const ivector_slice &sl2)
2410#if(CXSC_INDEX_CHECK)
2411
2412#else
2413 noexcept
2414#endif
2415 { return _vsvssect<ivector_slice,l_ivector_slice,l_ivector>(sl2,sl1); }
2416
2417 INLINE l_ivector & operator &=(l_ivector &rv1, const ivector &rv2)
2418#if(CXSC_INDEX_CHECK)
2419
2420#else
2421 noexcept
2422#endif
2423 { return _vvsectassign(rv1,rv2); }
2424 INLINE l_ivector &operator &=(l_ivector &rv, const ivector_slice &sl)
2425#if(CXSC_INDEX_CHECK)
2426
2427#else
2428 noexcept
2429#endif
2430 { return _vvssectassign(rv,sl); }
2432#if(CXSC_INDEX_CHECK)
2433
2434#else
2435 noexcept
2436#endif
2437 { return _vsvsectassign(*this,rv); }
2439#if(CXSC_INDEX_CHECK)
2440
2441#else
2442 noexcept
2443#endif
2444 { return _vsvssectassign(*this,sl2); }
2445
2446//------------- real x l_real ------------------------
2447 INLINE l_ivector operator |(const rvector &rv1, const l_rvector &rv2)
2448#if(CXSC_INDEX_CHECK)
2449
2450#else
2451 noexcept
2452#endif
2453 { return _vvconv<rvector,l_rvector,l_ivector>(rv1,rv2); }
2454 INLINE l_ivector operator |(const l_rvector &rv1, const rvector &rv2)
2455#if(CXSC_INDEX_CHECK)
2456
2457#else
2458 noexcept
2459#endif
2460 { return _vvconv<rvector,l_rvector,l_ivector>(rv2,rv1); }
2461 INLINE l_ivector operator |(const l_rvector &rv, const rvector_slice &sl)
2462#if(CXSC_INDEX_CHECK)
2463
2464#else
2465 noexcept
2466#endif
2467 { return _vvsconv<l_rvector,rvector_slice,l_ivector>(rv,sl); }
2468 INLINE l_ivector operator |(const rvector_slice &sl,const l_rvector &rv)
2469#if(CXSC_INDEX_CHECK)
2470
2471#else
2472 noexcept
2473#endif
2474 { return _vvsconv<l_rvector,rvector_slice,l_ivector>(rv,sl); }
2475 INLINE l_ivector operator |(const l_rvector_slice &sl, const rvector &rv)
2476#if(CXSC_INDEX_CHECK)
2477
2478#else
2479 noexcept
2480#endif
2481 { return _vvsconv<rvector,l_rvector_slice,l_ivector>(rv,sl); }
2482 INLINE l_ivector operator |(const rvector &rv,const l_rvector_slice &sl)
2483#if(CXSC_INDEX_CHECK)
2484
2485#else
2486 noexcept
2487#endif
2488 { return _vvsconv<rvector,l_rvector_slice,l_ivector>(rv,sl); }
2489 INLINE l_ivector operator |(const l_rvector_slice &sl1, const rvector_slice &sl2)
2490#if(CXSC_INDEX_CHECK)
2491
2492#else
2493 noexcept
2494#endif
2495 { return _vsvsconv<rvector_slice,l_rvector_slice,l_ivector>(sl2,sl1); }
2496 INLINE l_ivector operator |(const rvector_slice &sl1, const l_rvector_slice &sl2)
2497#if(CXSC_INDEX_CHECK)
2498
2499#else
2500 noexcept
2501#endif
2502 { return _vsvsconv<rvector_slice,l_rvector_slice,l_ivector>(sl1,sl2); }
2503
2504//------------- l_real x l_real ------------------------
2505 INLINE l_ivector operator |(const l_rvector &rv1, const l_rvector &rv2)
2506#if(CXSC_INDEX_CHECK)
2507
2508#else
2509 noexcept
2510#endif
2511 { return _vvconv<l_rvector,l_rvector,l_ivector>(rv2,rv1); }
2512 INLINE l_ivector operator |(const l_rvector &rv, const l_rvector_slice &sl)
2513#if(CXSC_INDEX_CHECK)
2514
2515#else
2516 noexcept
2517#endif
2518 { return _vvsconv<l_rvector,l_rvector_slice,l_ivector>(rv,sl); }
2519 INLINE l_ivector operator |(const l_rvector_slice &sl,const l_rvector &rv)
2520#if(CXSC_INDEX_CHECK)
2521
2522#else
2523 noexcept
2524#endif
2525 { return _vvsconv<l_rvector,l_rvector_slice,l_ivector>(rv,sl); }
2526 INLINE l_ivector operator |(const l_rvector_slice &sl1, const l_rvector_slice &sl2)
2527#if(CXSC_INDEX_CHECK)
2528
2529#else
2530 noexcept
2531#endif
2532 { return _vsvsconv<l_rvector_slice,l_rvector_slice,l_ivector>(sl1,sl2); }
2533
2534//-------------------------------- interval / l_real --------------------------------
2535
2536
2537 INLINE l_ivector operator +(const l_rvector &rv1, const ivector &rv2)
2538#if(CXSC_INDEX_CHECK)
2539
2540#else
2541 noexcept
2542#endif
2543 { return _vvplus<l_rvector,ivector,l_ivector>(rv1,rv2); }
2544 INLINE l_ivector operator +(const l_rvector &rv, const ivector_slice &sl)
2545#if(CXSC_INDEX_CHECK)
2546
2547#else
2548 noexcept
2549#endif
2550 { return _vvsplus<l_rvector,ivector_slice,l_ivector>(rv,sl); }
2551 INLINE l_ivector operator +(const l_rvector_slice &sl, const ivector &rv)
2552#if(CXSC_INDEX_CHECK)
2553
2554#else
2555 noexcept
2556#endif
2557 { return _vvsplus<ivector,l_rvector_slice,l_ivector>(rv,sl); }
2558 INLINE l_ivector operator +(const l_rvector_slice &sl1, const ivector_slice &sl2)
2559#if(CXSC_INDEX_CHECK)
2560
2561#else
2562 noexcept
2563#endif
2564 { return _vsvsplus<l_rvector_slice,ivector_slice,l_ivector>(sl1,sl2); }
2565
2566 INLINE l_ivector operator +(const ivector &rv1, const l_rvector &rv2)
2567#if(CXSC_INDEX_CHECK)
2568
2569#else
2570 noexcept
2571#endif
2572 { return _vvplus<l_rvector,ivector,l_ivector>(rv2,rv1); }
2573 INLINE l_ivector operator +(const ivector &rv, const l_rvector_slice &sl)
2574#if(CXSC_INDEX_CHECK)
2575
2576#else
2577 noexcept
2578#endif
2579 { return _vvsplus<ivector,l_rvector_slice,l_ivector>(rv,sl); }
2580 INLINE l_ivector operator +(const ivector_slice &sl, const l_rvector &rv)
2581#if(CXSC_INDEX_CHECK)
2582
2583#else
2584 noexcept
2585#endif
2586 { return _vvsplus<l_rvector,ivector_slice,l_ivector>(rv,sl); }
2587 INLINE l_ivector operator +(const ivector_slice &sl1, const l_rvector_slice &sl2)
2588#if(CXSC_INDEX_CHECK)
2589
2590#else
2591 noexcept
2592#endif
2593 { return _vsvsplus<l_rvector_slice,ivector_slice,l_ivector>(sl2,sl1); }
2594
2595 INLINE l_ivector operator -(const l_rvector &rv1, const ivector &rv2)
2596#if(CXSC_INDEX_CHECK)
2597
2598#else
2599 noexcept
2600#endif
2601 { return _vvminus<l_rvector,ivector,l_ivector>(rv1,rv2); }
2602 INLINE l_ivector operator -(const l_rvector &rv, const ivector_slice &sl)
2603#if(CXSC_INDEX_CHECK)
2604
2605#else
2606 noexcept
2607#endif
2608 { return _vvsminus<l_rvector,ivector_slice,l_ivector>(rv,sl); }
2609 INLINE l_ivector operator -(const l_rvector_slice &sl, const ivector &rv)
2610#if(CXSC_INDEX_CHECK)
2611
2612#else
2613 noexcept
2614#endif
2615 { return _vsvminus<l_rvector_slice,ivector,l_ivector>(sl,rv); }
2616 INLINE l_ivector operator -(const l_rvector_slice &sl1, const ivector_slice &sl2)
2617#if(CXSC_INDEX_CHECK)
2618
2619#else
2620 noexcept
2621#endif
2622 { return _vsvsminus<l_rvector_slice,ivector_slice,l_ivector>(sl1,sl2); }
2623
2624 INLINE l_ivector operator -(const ivector &rv1, const l_rvector &rv2)
2625#if(CXSC_INDEX_CHECK)
2626
2627#else
2628 noexcept
2629#endif
2630 { return _vvminus<ivector,l_rvector,l_ivector>(rv1,rv2); }
2631 INLINE l_ivector operator -(const ivector &rv, const l_rvector_slice &sl)
2632#if(CXSC_INDEX_CHECK)
2633
2634#else
2635 noexcept
2636#endif
2637 { return _vvsminus<ivector,l_rvector_slice,l_ivector>(rv,sl); }
2638 INLINE l_ivector operator -(const ivector_slice &sl, const l_rvector &rv)
2639#if(CXSC_INDEX_CHECK)
2640
2641#else
2642 noexcept
2643#endif
2644 { return _vsvminus<ivector_slice,l_rvector,l_ivector>(sl,rv); }
2645 INLINE l_ivector operator -(const ivector_slice &sl1, const l_rvector_slice &sl2)
2646#if(CXSC_INDEX_CHECK)
2647
2648#else
2649 noexcept
2650#endif
2651 { return _vsvsminus<ivector_slice,l_rvector_slice,l_ivector>(sl1,sl2); }
2652
2653 INLINE l_ivector operator |(const l_rvector &rv1, const ivector &rv2)
2654#if(CXSC_INDEX_CHECK)
2655
2656#else
2657 noexcept
2658#endif
2659 { return _vvconv<l_rvector,ivector,l_ivector>(rv1,rv2); }
2660 INLINE l_ivector operator |(const l_rvector &rv, const ivector_slice &sl)
2661#if(CXSC_INDEX_CHECK)
2662
2663#else
2664 noexcept
2665#endif
2666 { return _vvsconv<l_rvector,ivector_slice,l_ivector>(rv,sl); }
2667 INLINE l_ivector operator |(const l_rvector_slice &sl, const ivector &rv)
2668#if(CXSC_INDEX_CHECK)
2669
2670#else
2671 noexcept
2672#endif
2673 { return _vvsconv<ivector,l_rvector_slice,l_ivector>(rv,sl); }
2674 INLINE l_ivector operator |(const l_rvector_slice &sl1, const ivector_slice &sl2)
2675#if(CXSC_INDEX_CHECK)
2676
2677#else
2678 noexcept
2679#endif
2680 { return _vsvsconv<l_rvector_slice,ivector_slice,l_ivector>(sl1,sl2); }
2681
2682 INLINE l_ivector operator |(const ivector &rv1, const l_rvector &rv2)
2683#if(CXSC_INDEX_CHECK)
2684
2685#else
2686 noexcept
2687#endif
2688 { return _vvconv<l_rvector,ivector,l_ivector>(rv2,rv1); }
2689 INLINE l_ivector operator |(const ivector &rv, const l_rvector_slice &sl)
2690#if(CXSC_INDEX_CHECK)
2691
2692#else
2693 noexcept
2694#endif
2695 { return _vvsconv<ivector,l_rvector_slice,l_ivector>(rv,sl); }
2696 INLINE l_ivector operator |(const ivector_slice &sl, const l_rvector &rv)
2697#if(CXSC_INDEX_CHECK)
2698
2699#else
2700 noexcept
2701#endif
2702 { return _vvsconv<l_rvector,ivector_slice,l_ivector>(rv,sl); }
2703 INLINE l_ivector operator |(const ivector_slice &sl1, const l_rvector_slice &sl2)
2704#if(CXSC_INDEX_CHECK)
2705
2706#else
2707 noexcept
2708#endif
2709 { return _vsvsconv<l_rvector_slice,ivector_slice,l_ivector>(sl2,sl1); }
2710
2711 INLINE l_ivector operator &(const l_rvector &rv1, const ivector &rv2)
2712#if(CXSC_INDEX_CHECK)
2713
2714#else
2715 noexcept
2716#endif
2717 { return _vvsect<l_rvector,ivector,l_ivector>(rv1,rv2); }
2718 INLINE l_ivector operator &(const l_rvector &rv, const ivector_slice &sl)
2719#if(CXSC_INDEX_CHECK)
2720
2721#else
2722 noexcept
2723#endif
2724 { return _vvssect<l_rvector,ivector_slice,l_ivector>(rv,sl); }
2725 INLINE l_ivector operator &(const l_rvector_slice &sl, const ivector &rv)
2726#if(CXSC_INDEX_CHECK)
2727
2728#else
2729 noexcept
2730#endif
2731 { return _vvssect<ivector,l_rvector_slice,l_ivector>(rv,sl); }
2732 INLINE l_ivector operator &(const l_rvector_slice &sl1, const ivector_slice &sl2)
2733#if(CXSC_INDEX_CHECK)
2734
2735#else
2736 noexcept
2737#endif
2738 { return _vsvssect<l_rvector_slice,ivector_slice,l_ivector>(sl1,sl2); }
2739
2740 INLINE l_ivector operator &(const ivector &rv1, const l_rvector &rv2)
2741#if(CXSC_INDEX_CHECK)
2742
2743#else
2744 noexcept
2745#endif
2746 { return _vvsect<l_rvector,ivector,l_ivector>(rv2,rv1); }
2747 INLINE l_ivector operator &(const ivector &rv, const l_rvector_slice &sl)
2748#if(CXSC_INDEX_CHECK)
2749
2750#else
2751 noexcept
2752#endif
2753 { return _vvssect<ivector,l_rvector_slice,l_ivector>(rv,sl); }
2754 INLINE l_ivector operator &(const ivector_slice &sl, const l_rvector &rv)
2755#if(CXSC_INDEX_CHECK)
2756
2757#else
2758 noexcept
2759#endif
2760 { return _vvssect<l_rvector,ivector_slice,l_ivector>(rv,sl); }
2761 INLINE l_ivector operator &(const ivector_slice &sl1, const l_rvector_slice &sl2)
2762#if(CXSC_INDEX_CHECK)
2763
2764#else
2765 noexcept
2766#endif
2767 { return _vsvssect<l_rvector_slice,ivector_slice,l_ivector>(sl2,sl1); }
2768
2769} // namespace cxsc
2770
2771#endif // _CXSC_LIVECTOR_INL_INCLUDED
The Data Type idotprecision.
Definition idot.hpp:48
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_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 & operator()() noexcept
Operator for accessing the whole vector.
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.
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.
l_ivector & operator=(const l_ivector &rv) noexcept
Implementation of standard assigning operator.
The Multiple-Precision Data Type l_real.
Definition l_real.hpp:78
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 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.