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 
29 namespace 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); }
1549  INLINE l_interval operator *(const l_rvector_slice & sl1, const l_ivector_slice &sl2)
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); }
1578  INLINE l_interval operator *(const l_ivector_slice & sl1, const l_rvector_slice &sl2)
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.
Definition: l_interval.hpp:72
l_interval() noexcept
Constructor of class l_interval.
Definition: l_interval.inl:45
The Multiple-Precision Data Type l_ivector_slice.
Definition: l_ivector.hpp:871
l_ivector_slice & operator()() noexcept
Operator for accessing the whole vector.
Definition: l_ivector.hpp:1479
l_ivector_slice & operator=(const l_ivector_slice &sl) noexcept
Implementation of standard assigning operator.
Definition: l_ivector.inl:314
l_ivector_slice & operator-=(const l_ivector &rv) noexcept
Implementation of subtraction and allocation operation.
Definition: l_ivector.inl:756
l_ivector_slice & operator|=(const l_ivector &rv) noexcept
Allocates the convex hull of the arguments to the first argument.
Definition: l_ivector.inl:813
l_ivector_slice & operator*=(const l_interval &r) noexcept
Implementation of multiplication and allocation operation.
Definition: l_ivector.inl:497
l_ivector_slice & operator&=(const l_ivector &rv) noexcept
Allocates the intersection of the arguments to the first argument.
Definition: l_ivector.inl:870
l_ivector_slice & operator/=(const l_interval &r) noexcept
Implementation of division and allocation operation.
Definition: l_ivector.inl:502
l_ivector_slice & operator+=(const l_ivector &rv) noexcept
Implementation of addition and allocation operation.
Definition: l_ivector.inl:697
l_interval & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector.
Definition: l_ivector.inl:154
The Multiple-Precision Data Type l_ivector.
Definition: l_ivector.hpp:55
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.
Definition: l_ivector.inl:141
l_ivector & operator=(const l_ivector &rv) noexcept
Implementation of standard assigning operator.
Definition: l_ivector.inl:311
l_ivector & operator()() noexcept
Operator for accessing the whole vector.
Definition: l_ivector.hpp:842
The Multiple-Precision Data Type l_real.
Definition: l_real.hpp:78
The Multiple-Precision Data Type l_rvector_slice.
Definition: l_rvector.hpp:745
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
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.
Definition: l_ivector.inl:252
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc) noexcept
Implementation of standard algebraic addition and allocation operation.
Definition: cdot.inl:251
cimatrix & operator*=(cimatrix &m, const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
Definition: cimatrix.inl:1605
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737
cvector mid(const cimatrix_subv &mv) noexcept
Returns the middle of the matrix.
Definition: cimatrix.inl:739
civector operator*(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of multiplication operation.
Definition: cimatrix.inl:731
void Resize(cimatrix &A) noexcept
Resizes the matrix.
Definition: cimatrix.inl:1211
cimatrix_subv & SetUncheckedInf(cimatrix_subv &iv, const complex &r) noexcept
Returns the matrix with the new unchecked given infimum value.
Definition: cimatrix.inl:890
cimatrix & operator/=(cimatrix &m, const cinterval &c) noexcept
Implementation of division and allocation operation.
Definition: cimatrix.inl:1623