C-XSC - A C++ Class Library for Extended Scientific Computing 2.5.4
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: ivector.inl,v 1.27 2014/01/30 17:23:46 cxsc Exp $ */
25
26#ifndef _CXSC_IVECTOR_INL_INCLUDED
27#define _CXSC_IVECTOR_INL_INCLUDED
28
29namespace cxsc {
30
31 INLINE ivector::ivector () noexcept:dat(NULL),l(1),u(0),size(0)
32 {
33 }
34
35 INLINE ivector::ivector(const int &i) noexcept:l(1),u(i),size(i)
36 {
37 dat=new interval[i];
38 }
39
40#ifdef OLD_CXSC
41 INLINE ivector::ivector(const class index &i) noexcept:l(1),u(i._int()),size(i._int())
42 {
43 dat=new interval[i._int()];
44 }
45#endif
46
47 INLINE ivector::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_IVECTOR_WRONG_BOUNDARIES("ivector::ivector(const int &i1,const int &i2)"));
56#endif
57 dat=new interval[size];
58 }
59
60 INLINE ivector::ivector(const ivector_slice &rs) noexcept:l(rs.start),u(rs.end),size(rs.end-rs.start+1)
61 {
62 dat=new 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 ivector::ivector(const ivector &v) noexcept:l(v.l),u(v.u),size(v.size)
68 {
69 dat=new interval[size];
70 for (int i=0;i<size;i++)
71 dat[i]=v.dat[i];
72 }
73
74 INLINE ivector::ivector(const interval &r) noexcept:l(1),u(1),size(1)
75 {
76 dat=new interval[1];
77 *dat=r;
78 }
79
80 INLINE ivector::ivector(const rvector_slice &rs) noexcept:l(rs.start),u(rs.end),size(rs.end-rs.start+1)
81 {
82 dat=new interval[size];
83 for(int i=0, j=l-rs.l;i<size;i++,j++)
84 dat[i]=rs.dat[j];
85 }
86
87 INLINE ivector::ivector(const rvector &v) noexcept:l(v.l),u(v.u),size(v.size)
88 {
89 dat=new interval[size];
90 for (int i=0;i<size;i++)
91 dat[i]=v.dat[i];
92 }
93
94 INLINE ivector::ivector(const real &r) noexcept:l(1),u(1),size(1)
95 {
96 dat=new interval[1];
97 *dat=r;
98 }
99
100 INLINE interval & ivector::operator [](const int &i) const
101#if(CXSC_INDEX_CHECK)
102
103#else
104 noexcept
105#endif
106 {
107#if(CXSC_INDEX_CHECK)
108 if(i<l||i>u) cxscthrow(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC("interval & ivector::operator [](const int &i) const"));
109#endif
110 return dat[i-l];
111 }
112
113 INLINE interval & ivector::operator [](const int &i)
114#if(CXSC_INDEX_CHECK)
115
116#else
117 noexcept
118#endif
119 {
120#if(CXSC_INDEX_CHECK)
121 if(i<l||i>u) cxscthrow(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC("interval & ivector::operator [](const int &i)"));
122#endif
123 return dat[i-l];
124 }
125
126 INLINE interval & ivector_slice::operator [](const int &i) const
127#if(CXSC_INDEX_CHECK)
128
129#else
130 noexcept
131#endif
132 {
133#if(CXSC_INDEX_CHECK)
134 if(i<start||i>end) cxscthrow(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC("interval & ivector_slice::operator [](const int &i) const"));
135#endif
136 return dat[i-l];
137 }
138
139 INLINE interval & ivector_slice::operator [](const int &i)
140#if(CXSC_INDEX_CHECK)
141
142#else
143 noexcept
144#endif
145 {
146#if(CXSC_INDEX_CHECK)
147 if(i<start||i>end) cxscthrow(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC("interval & ivector_slice::operator [](const int &i)"));
148#endif
149 return dat[i-l];
150 }
151
152
154#if(CXSC_INDEX_CHECK)
155
156#else
157 noexcept
158#endif
159 {
160#if(CXSC_INDEX_CHECK)
161 if(1<l||i>u) cxscthrow(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG("ivector_slice ivector::operator ()(const int &i)"));
162#endif
163 return ivector_slice(*this,1,i);
164 }
165
166 INLINE ivector_slice ivector::operator ()(const int &i1,const int &i2)
167#if(CXSC_INDEX_CHECK)
168
169#else
170 noexcept
171#endif
172 {
173#if(CXSC_INDEX_CHECK)
174 if(i1<l||i2>u) cxscthrow(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG("ivector_slice ivector::operator ()(const int &i1,const int &i2)"));
175#endif
176 return ivector_slice(*this,i1,i2);
177 }
178
180#if(CXSC_INDEX_CHECK)
181
182#else
183 noexcept
184#endif
185 {
186#if(CXSC_INDEX_CHECK)
187 if(1<start||i>end) cxscthrow(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG("ivector_slice ivector_slice::operator ()(const int &i)"));
188#endif
189 return ivector_slice(*this,1,i);
190 }
191
192 INLINE ivector_slice ivector_slice::operator ()(const int &i1,const int &i2)
193#if(CXSC_INDEX_CHECK)
194
195#else
196 noexcept
197#endif
198 {
199#if(CXSC_INDEX_CHECK)
200 if(i1<start||i2>end) cxscthrow(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG("ivector_slice ivector_slice::operator ()(const int &i1,const int &i2)"));
201#endif
202 return ivector_slice(*this,i1,i2);
203 }
204
205 INLINE interval::interval(const ivector &rv)
206#if(CXSC_INDEX_CHECK)
207
208#else
209 noexcept
210#endif
211 {
212#if(CXSC_INDEX_CHECK)
213 if(rv.size>1) cxscthrow(ERROR_IVECTOR_TYPE_CAST_OF_THICK_OBJ("interval::interval(const ivector &rv)"));
214 else if(rv.size<1) cxscthrow(ERROR_IVECTOR_USE_OF_UNINITIALIZED_OBJ("interval::interval(const ivector &rv)"));
215#endif
216 *this=rv.dat[0];
217 }
218
220#if(CXSC_INDEX_CHECK)
221
222#else
223 noexcept
224#endif
225 {
226#if(CXSC_INDEX_CHECK)
227 if(sl.size>1) cxscthrow(ERROR_IVECTOR_TYPE_CAST_OF_THICK_OBJ("interval::interval(const ivector_slice &sl)"));
228 else if(sl.size<1) cxscthrow(ERROR_IVECTOR_USE_OF_UNINITIALIZED_OBJ("interval::interval(const ivector_slice &sl)"));
229#endif
230 *this=sl.dat[sl.start-sl.l];
231 }
232
238 INLINE ivector _ivector(const interval &r) noexcept { return ivector(r); }
244 INLINE ivector _ivector(const real &r) noexcept { return ivector(r); }
250 INLINE ivector _ivector(const rvector_slice &rs) noexcept { return ivector(rs); }
256 INLINE ivector _ivector(const rvector &rs) noexcept { return ivector(rs); }
262 INLINE ivector _ivector(const rmatrix_subv &rs) noexcept { return ivector(rs); }
263 INLINE ivector &ivector::operator =(const ivector &rv) noexcept { return _vvassign<ivector,ivector,interval>(*this,rv); }
264 INLINE ivector &ivector::operator =(const interval &r) noexcept { return _vsassign<ivector,interval>(*this,r); }
265 INLINE ivector &ivector::operator =(const rvector &rv) noexcept { return _vvassign<ivector,rvector,interval>(*this,rv); }
266 INLINE ivector &ivector::operator =(const real &r) noexcept { return _vsassign<ivector,real>(*this,r); }
267 INLINE ivector::operator void*() noexcept { return _vvoid(*this); }
269#if(CXSC_INDEX_CHECK)
270
271#else
272 noexcept
273#endif
274 { return _vsvsassign(*this,sl); }
276#if(CXSC_INDEX_CHECK)
277
278#else
279 noexcept
280#endif
281 { return _vsvassign(*this,rv); }
282 INLINE ivector_slice & ivector_slice::operator =(const interval &r) noexcept { return _vssassign<ivector_slice,interval>(*this,r); }
284#if(CXSC_INDEX_CHECK)
285
286#else
287 noexcept
288#endif
289 { return _vsvassign(*this,ivector(m)); }
291#if(CXSC_INDEX_CHECK)
292
293#else
294 noexcept
295#endif
296 { return _vsvsassign(*this,sl); }
298#if(CXSC_INDEX_CHECK)
299
300#else
301 noexcept
302#endif
303 { return _vsvassign(*this,rv); }
304 INLINE ivector_slice & ivector_slice::operator =(const real &r) noexcept { return _vssassign(*this,r); }
305 INLINE ivector_slice::operator void*() noexcept { return _vsvoid(*this); }
306
307//=======================================================================
308//======================== Vector Functions =============================
309
310
311 INLINE ivector &SetInf(ivector &iv,const rvector &rv)
312#if(CXSC_INDEX_CHECK)
313
314#else
315 noexcept
316#endif
317 { return _vvsetinf(iv,rv); }
318 INLINE ivector_slice &SetInf(ivector_slice &iv,const rvector &rv)
319#if(CXSC_INDEX_CHECK)
320
321#else
322 noexcept
323#endif
324 { return _vsvsetinf(iv,rv); }
325 INLINE ivector &SetInf(ivector &iv,const rvector_slice &rv)
326#if(CXSC_INDEX_CHECK)
327
328#else
329 noexcept
330#endif
331 { return _vvssetinf(iv,rv); }
332 INLINE ivector_slice &SetInf(ivector_slice &iv,const rvector_slice &rv)
333#if(CXSC_INDEX_CHECK)
334
335#else
336 noexcept
337#endif
338 { return _vsvssetinf(iv,rv); }
339 INLINE ivector &UncheckedSetInf(ivector &iv,const rvector &rv)
340#if(CXSC_INDEX_CHECK)
341
342#else
343 noexcept
344#endif
345 { return _vvusetinf(iv,rv); }
346 INLINE ivector_slice &UncheckedSetInf(ivector_slice &iv,const rvector &rv)
347#if(CXSC_INDEX_CHECK)
348
349#else
350 noexcept
351#endif
352 { return _vsvusetinf(iv,rv); }
353 INLINE ivector &UncheckedSetInf(ivector &iv,const rvector_slice &rv)
354#if(CXSC_INDEX_CHECK)
355
356#else
357 noexcept
358#endif
359 { return _vvsusetinf(iv,rv); }
360 INLINE ivector_slice &UncheckedSetInf(ivector_slice &iv,const rvector_slice &rv)
361#if(CXSC_INDEX_CHECK)
362
363#else
364 noexcept
365#endif
366 { return _vsvsusetinf(iv,rv); }
367
368 INLINE ivector &SetSup(ivector &iv,const rvector &rv)
369#if(CXSC_INDEX_CHECK)
370
371#else
372 noexcept
373#endif
374 { return _vvsetsup(iv,rv); }
375 INLINE ivector_slice &SetSup(ivector_slice &iv,const rvector &rv)
376#if(CXSC_INDEX_CHECK)
377
378#else
379 noexcept
380#endif
381 { return _vsvsetsup(iv,rv); }
382 INLINE ivector &SetSup(ivector &iv,const rvector_slice &rv)
383#if(CXSC_INDEX_CHECK)
384
385#else
386 noexcept
387#endif
388 { return _vvssetsup(iv,rv); }
389 INLINE ivector_slice &SetSup(ivector_slice &iv,const rvector_slice &rv)
390#if(CXSC_INDEX_CHECK)
391
392#else
393 noexcept
394#endif
395 { return _vsvssetsup(iv,rv); }
396 INLINE ivector &UncheckedSetSup(ivector &iv,const rvector &rv)
397#if(CXSC_INDEX_CHECK)
398
399#else
400 noexcept
401#endif
402 { return _vvusetsup(iv,rv); }
403 INLINE ivector_slice &UncheckedSetSup(ivector_slice &iv,const rvector &rv)
404#if(CXSC_INDEX_CHECK)
405
406#else
407 noexcept
408#endif
409 { return _vsvusetsup(iv,rv); }
410 INLINE ivector &UncheckedSetSup(ivector &iv,const rvector_slice &rv)
411#if(CXSC_INDEX_CHECK)
412
413#else
414 noexcept
415#endif
416 { return _vvsusetsup(iv,rv); }
417 INLINE ivector_slice &UncheckedSetSup(ivector_slice &iv,const rvector_slice &rv)
418#if(CXSC_INDEX_CHECK)
419
420#else
421 noexcept
422#endif
423 { return _vsvsusetsup(iv,rv); }
424
425 INLINE ivector &SetSup(ivector &iv,const real &r) noexcept { return _vssetsup(iv,r); }
426 INLINE ivector &SetInf(ivector &iv,const real &r) noexcept { return _vssetinf(iv,r); }
427 INLINE ivector &UncheckedSetSup(ivector &iv,const real &r) noexcept { return _vsusetsup(iv,r); }
428 INLINE ivector &SetUncheckedInf(ivector &iv,const real &r) noexcept { return _vsusetinf(iv,r); }
429 INLINE ivector_slice &SetSup(ivector_slice &iv,const real &r) noexcept { return _vsssetsup(iv,r); }
430 INLINE ivector_slice &SetInf(ivector_slice &iv,const real &r) noexcept { return _vsssetinf(iv,r); }
431 INLINE ivector_slice &UncheckedSetSup(ivector_slice &iv,const real &r) noexcept { return _vssusetsup(iv,r); }
432 INLINE ivector_slice &SetUncheckedInf(ivector_slice &iv,const real &r) noexcept { return _vssusetinf(iv,r); }
433
434 INLINE void Resize(ivector &rv) noexcept { _vresize(rv); }
435 INLINE void Resize(ivector &rv, const int &len)
436#if(CXSC_INDEX_CHECK)
437
438#else
439 noexcept
440#endif
441 { _vresize<class ivector,class interval>(rv,len); }
442 INLINE void Resize(ivector &rv, const int &lb, const int &ub)
443#if(CXSC_INDEX_CHECK)
444
445#else
446 noexcept
447#endif
448 { _vresize<class ivector,class interval>(rv,lb,ub); }
449
450 INLINE ivector abs(const ivector &rv) noexcept { return _vabs<ivector,ivector>(rv); }
451 INLINE ivector abs(const ivector_slice &sl) noexcept { return _vsabs<ivector_slice,ivector>(sl); }
452 INLINE rvector absmin(const ivector &rv) noexcept {
453 rvector x(Lb(rv),Ub(rv));
454 for(int i=Lb(rv) ; i<=Ub(rv) ; i++)
455 x[i] = AbsMin(rv[i]);
456 return x;
457 }
458 INLINE rvector absmin(const ivector_slice &sl) noexcept {
459 rvector x(Lb(sl),Ub(sl));
460 for(int i=Lb(sl) ; i<=Ub(sl) ; i++)
461 x[i] = AbsMin(sl[i]);
462 return x;
463 }
464 INLINE rvector absmax(const ivector &rv) noexcept {
465 rvector x(Lb(rv),Ub(rv));
466 for(int i=Lb(rv) ; i<=Ub(rv) ; i++)
467 x[i] = AbsMax(rv[i]);
468 return x;
469 }
470 INLINE rvector absmax(const ivector_slice &sl) noexcept {
471 rvector x(Lb(sl),Ub(sl));
472 for(int i=Lb(sl) ; i<=Ub(sl) ; i++)
473 x[i] = AbsMax(sl[i]);
474 return x;
475 }
476 INLINE rvector diam(const ivector &v) noexcept { return _vdiam<ivector,rvector>(v); }
477 INLINE rvector diam(const ivector_slice &v) noexcept { return _vsdiam<ivector_slice,rvector>(v); }
478 INLINE rvector mid(const ivector &v) noexcept { return _vmid<ivector,rvector>(v); }
479 INLINE rvector mid(const ivector_slice &v) noexcept { return _vsmid<ivector_slice,rvector>(v); }
480 INLINE rvector Inf(const ivector &v) noexcept { return _vinf<ivector,rvector>(v); }
481 INLINE rvector Inf(const ivector_slice &v) noexcept { return _vsinf<ivector_slice,rvector>(v); }
482 INLINE rvector Sup(const ivector &v) noexcept { return _vsup<ivector,rvector>(v); }
483 INLINE rvector Sup(const ivector_slice &v) noexcept { return _vssup<ivector_slice,rvector>(v); }
484 INLINE bool operator !(const ivector &rv) noexcept { return _vnot(rv); }
485 INLINE bool operator !(const ivector_slice &sl) noexcept { return _vsnot(sl); }
486
487//======================= Vector / Scalar ===============================
488
489//----------------------------- Interval ---------------------------
490
491 INLINE ivector operator *(const ivector &rv, const interval &s) noexcept { return _vsmult<ivector,interval,ivector>(rv,s); }
492 INLINE ivector operator *(const ivector_slice &sl, const interval &s) noexcept { return _vssmult<ivector_slice,interval,ivector>(sl,s); }
493 INLINE ivector operator *(const interval &s, const ivector &rv) noexcept { return _vsmult<ivector,interval,ivector>(rv,s); }
494 INLINE ivector operator *(const interval &s, const ivector_slice &sl) noexcept { return _vssmult<ivector_slice,interval,ivector>(sl,s); }
495 INLINE ivector &operator *=(ivector &rv,const interval &r) noexcept { return _vsmultassign(rv,r); }
496 INLINE ivector_slice &ivector_slice::operator *=(const interval &r) noexcept { return _vssmultassign(*this,r); }
497
498 INLINE ivector operator /(const ivector &rv, const interval &s) noexcept { return _vsdiv<ivector,interval,ivector>(rv,s); }
499 INLINE ivector operator /(const ivector_slice &sl, const interval &s) noexcept { return _vssdiv<ivector_slice,interval,ivector>(sl,s); }
500 INLINE ivector &operator /=(ivector &rv,const interval &r) noexcept { return _vsdivassign(rv,r); }
501 INLINE ivector_slice &ivector_slice::operator /=(const interval &r) noexcept { return _vssdivassign(*this,r); }
502
503//---------------------------- Real --------------------------------------
504
505 INLINE ivector operator *(const ivector &rv, const real &s) noexcept { return _vsmult<ivector,real,ivector>(rv,s); }
506 INLINE ivector operator *(const ivector_slice &sl, const real &s) noexcept { return _vssmult<ivector_slice,real,ivector>(sl,s); }
507 INLINE ivector operator *(const real &s, const ivector &rv) noexcept { return _vsmult<ivector,real,ivector>(rv,s); }
508 INLINE ivector operator *(const real &s, const ivector_slice &sl) noexcept { return _vssmult<ivector_slice,real,ivector>(sl,s); }
509 INLINE ivector &operator *=(ivector &rv,const real &r) noexcept { return _vsmultassign(rv,r); }
510 INLINE ivector_slice &ivector_slice::operator *=(const real &r) noexcept { return _vssmultassign(*this,r); }
511
512 INLINE ivector operator /(const ivector &rv, const real &s) noexcept { return _vsdiv<ivector,real,ivector>(rv,s); }
513 INLINE ivector operator /(const ivector_slice &sl, const real &s) noexcept { return _vssdiv<ivector_slice,real,ivector>(sl,s); }
514 INLINE ivector &operator /=(ivector &rv,const real &r) noexcept { return _vsdivassign(rv,r); }
515 INLINE ivector_slice &ivector_slice::operator /=(const real &r) noexcept { return _vssdivassign(*this,r); }
516
517 INLINE ivector operator *(const rvector &rv, const interval &s) noexcept { return _vsmult<rvector,interval,ivector>(rv,s); }
518 INLINE ivector operator *(const rvector_slice &sl, const interval &s) noexcept { return _vssmult<rvector_slice,interval,ivector>(sl,s); }
519 INLINE ivector operator *(const interval &s, const rvector &rv) noexcept { return _vsmult<rvector,interval,ivector>(rv,s); }
520 INLINE ivector operator *(const interval &s, const rvector_slice &sl) noexcept { return _vssmult<rvector_slice,interval,ivector>(sl,s); }
521
522 INLINE ivector operator /(const rvector &rv, const interval &s) noexcept { return _vsdiv<rvector,interval,ivector>(rv,s); }
523 INLINE ivector operator /(const rvector_slice &sl, const interval &s) noexcept { return _vssdiv<rvector_slice,interval,ivector>(sl,s); }
524
525//======================= Vector / Vector ===============================
526
527
528 INLINE std::ostream &operator <<(std::ostream &s, const ivector &rv) noexcept { return _vout(s,rv); }
529 INLINE std::ostream &operator <<(std::ostream &o, const ivector_slice &sl) noexcept { return _vsout(o,sl); }
530 INLINE std::istream &operator >>(std::istream &s, ivector &rv) noexcept { return _vin(s,rv); }
531 INLINE std::istream &operator >>(std::istream &s, ivector_slice &rv) noexcept { return _vsin(s,rv); }
532
533//----------------------- Interval / Interval ---------------------------
534 INLINE ivector & ivector::operator =(const ivector_slice &sl) noexcept { return _vvsassign<ivector,ivector_slice,interval>(*this,sl); }
535
536
537 INLINE interval operator *(const ivector & rv1, const ivector &rv2)
538#if(CXSC_INDEX_CHECK)
539
540#else
541 noexcept
542#endif
543 { return _vvimult<ivector,ivector,interval>(rv1,rv2); }
544 INLINE interval operator *(const ivector_slice &sl, const ivector &rv)
545#if(CXSC_INDEX_CHECK)
546
547#else
548 noexcept
549#endif
550 { return _vsvimult<ivector_slice,ivector,interval>(sl,rv); }
551 INLINE interval operator *(const ivector &rv, const ivector_slice &sl)
552#if(CXSC_INDEX_CHECK)
553
554#else
555 noexcept
556#endif
557 { return _vsvimult<ivector_slice,ivector,interval>(sl,rv); }
558 INLINE interval operator *(const ivector_slice & sl1, const ivector_slice &sl2)
559#if(CXSC_INDEX_CHECK)
560
561#else
562 noexcept
563#endif
564 { return _vsvsimult<ivector_slice,ivector_slice,interval>(sl1,sl2); }
565
566 INLINE const ivector &operator +(const ivector &rv) noexcept { return rv; }
567 INLINE ivector operator +(const ivector_slice &sl) noexcept { return sl; }
568 INLINE ivector operator +(const ivector &rv1, const ivector &rv2)
569#if(CXSC_INDEX_CHECK)
570
571#else
572 noexcept
573#endif
574 { return _vvplus<ivector,ivector,ivector>(rv1,rv2); }
575 INLINE ivector operator +(const ivector &rv, const ivector_slice &sl)
576#if(CXSC_INDEX_CHECK)
577
578#else
579 noexcept
580#endif
581 { return _vvsplus<ivector,ivector_slice,ivector>(rv,sl); }
582 INLINE ivector operator +(const ivector_slice &sl, const ivector &rv)
583#if(CXSC_INDEX_CHECK)
584
585#else
586 noexcept
587#endif
588 { return _vvsplus<ivector,ivector_slice,ivector>(rv,sl); }
589 INLINE ivector operator +(const ivector_slice &sl1, const ivector_slice &sl2)
590#if(CXSC_INDEX_CHECK)
591
592#else
593 noexcept
594#endif
595 { return _vsvsplus<ivector_slice,ivector_slice,ivector>(sl1,sl2); }
596 INLINE ivector & operator +=(ivector &rv1, const ivector &rv2)
597#if(CXSC_INDEX_CHECK)
598
599#else
600 noexcept
601#endif
602 { return _vvplusassign(rv1,rv2); }
603 INLINE ivector &operator +=(ivector &rv, const ivector_slice &sl)
604#if(CXSC_INDEX_CHECK)
605
606#else
607 noexcept
608#endif
609 { return _vvsplusassign(rv,sl); }
611#if(CXSC_INDEX_CHECK)
612
613#else
614 noexcept
615#endif
616 { return _vsvplusassign(*this,rv); }
618#if(CXSC_INDEX_CHECK)
619
620#else
621 noexcept
622#endif
623 { return _vsvsplusassign(*this,sl2); }
624
625 INLINE ivector operator -(const ivector &rv) noexcept { return _vminus(rv); }
626 INLINE ivector operator -(const ivector_slice &sl) noexcept { return _vsminus<ivector_slice,ivector>(sl); }
627 INLINE ivector operator -(const ivector &rv1, const ivector &rv2)
628#if(CXSC_INDEX_CHECK)
629
630#else
631 noexcept
632#endif
633 { return _vvminus<ivector,ivector,ivector>(rv1,rv2); }
634 INLINE ivector operator -(const ivector &rv, const ivector_slice &sl)
635#if(CXSC_INDEX_CHECK)
636
637#else
638 noexcept
639#endif
640 { return _vvsminus<ivector,ivector_slice,ivector>(rv,sl); }
641 INLINE ivector operator -(const ivector_slice &sl, const ivector &rv)
642#if(CXSC_INDEX_CHECK)
643
644#else
645 noexcept
646#endif
647 { return _vsvminus<ivector_slice,ivector,ivector>(sl,rv); }
648 INLINE ivector operator -(const ivector_slice &sl1, const ivector_slice &sl2)
649#if(CXSC_INDEX_CHECK)
650
651#else
652 noexcept
653#endif
654 { return _vsvsminus<ivector_slice,ivector_slice,ivector>(sl1,sl2); }
655 INLINE ivector & operator -=(ivector &rv1, const ivector &rv2)
656#if(CXSC_INDEX_CHECK)
657
658#else
659 noexcept
660#endif
661 { return _vvminusassign(rv1,rv2); }
662 INLINE ivector &operator -=(ivector &rv, const ivector_slice &sl)
663#if(CXSC_INDEX_CHECK)
664
665#else
666 noexcept
667#endif
668 { return _vvsminusassign(rv,sl); }
670#if(CXSC_INDEX_CHECK)
671
672#else
673 noexcept
674#endif
675 { return _vsvminusassign(*this,rv); }
677#if(CXSC_INDEX_CHECK)
678
679#else
680 noexcept
681#endif
682 { return _vsvsminusassign(*this,sl2); }
683
684 INLINE ivector operator |(const ivector &rv1, const ivector &rv2)
685#if(CXSC_INDEX_CHECK)
686
687#else
688 noexcept
689#endif
690 { return _vvconv<ivector,ivector,ivector>(rv1,rv2); }
691 INLINE ivector operator |(const ivector &rv, const ivector_slice &sl)
692#if(CXSC_INDEX_CHECK)
693
694#else
695 noexcept
696#endif
697 { return _vvsconv<ivector,ivector_slice,ivector>(rv,sl); }
698 INLINE ivector operator |(const ivector_slice &sl, const ivector &rv)
699#if(CXSC_INDEX_CHECK)
700
701#else
702 noexcept
703#endif
704 { return _vvsconv<ivector,ivector_slice,ivector>(rv,sl); }
705 INLINE ivector operator |(const ivector_slice &sl1, const ivector_slice &sl2)
706#if(CXSC_INDEX_CHECK)
707
708#else
709 noexcept
710#endif
711 { return _vsvsconv<ivector_slice,ivector_slice,ivector>(sl1,sl2); }
712 INLINE ivector & operator |=(ivector &rv1, const ivector &rv2)
713#if(CXSC_INDEX_CHECK)
714
715#else
716 noexcept
717#endif
718 { return _vvconvassign(rv1,rv2); }
719 INLINE ivector &operator |=(ivector &rv, const ivector_slice &sl)
720#if(CXSC_INDEX_CHECK)
721
722#else
723 noexcept
724#endif
725 { return _vvsconvassign(rv,sl); }
727#if(CXSC_INDEX_CHECK)
728
729#else
730 noexcept
731#endif
732 { return _vsvconvassign(*this,rv); }
734#if(CXSC_INDEX_CHECK)
735
736#else
737 noexcept
738#endif
739 { return _vsvsconvassign(*this,sl2); }
740
741 INLINE ivector operator &(const ivector &rv1, const ivector &rv2)
742#if(CXSC_INDEX_CHECK)
743
744#else
745 noexcept
746#endif
747 { return _vvsect<ivector,ivector,ivector>(rv1,rv2); }
748 INLINE ivector operator &(const ivector &rv, const ivector_slice &sl)
749#if(CXSC_INDEX_CHECK)
750
751#else
752 noexcept
753#endif
754 { return _vvssect<ivector,ivector_slice,ivector>(rv,sl); }
755 INLINE ivector operator &(const ivector_slice &sl, const ivector &rv)
756#if(CXSC_INDEX_CHECK)
757
758#else
759 noexcept
760#endif
761 { return _vvssect<ivector,ivector_slice,ivector>(rv,sl); }
762 INLINE ivector operator &(const ivector_slice &sl1, const ivector_slice &sl2)
763#if(CXSC_INDEX_CHECK)
764
765#else
766 noexcept
767#endif
768 { return _vsvssect<ivector_slice,ivector_slice,ivector>(sl1,sl2); }
769 INLINE ivector & operator &=(ivector &rv1, const ivector &rv2)
770#if(CXSC_INDEX_CHECK)
771
772#else
773 noexcept
774#endif
775 { return _vvsectassign(rv1,rv2); }
776 INLINE ivector &operator &=(ivector &rv, const ivector_slice &sl)
777#if(CXSC_INDEX_CHECK)
778
779#else
780 noexcept
781#endif
782 { return _vvssectassign(rv,sl); }
784#if(CXSC_INDEX_CHECK)
785
786#else
787 noexcept
788#endif
789 { return _vsvsectassign(*this,rv); }
791#if(CXSC_INDEX_CHECK)
792
793#else
794 noexcept
795#endif
796 { return _vsvssectassign(*this,sl2); }
797
798 INLINE bool operator ==(const ivector &rv1, const ivector &rv2) noexcept { return _vveq(rv1,rv2); }
799 INLINE bool operator ==(const ivector_slice &sl1, const ivector_slice &sl2) noexcept { return _vsvseq(sl1,sl2); }
800 INLINE bool operator ==(const ivector_slice &sl, const ivector &rv) noexcept { return _vsveq(sl,rv); }
801 INLINE bool operator ==(const ivector &rv, const ivector_slice &sl) noexcept { return _vsveq(sl,rv); }
802 INLINE bool operator !=(const ivector &rv1, const ivector &rv2) noexcept { return _vvneq(rv1,rv2); }
803 INLINE bool operator !=(const ivector_slice &sl1, const ivector_slice &sl2) noexcept { return _vsvsneq(sl1,sl2); }
804 INLINE bool operator !=(const ivector_slice &sl, const ivector &rv) noexcept { return _vsvneq(sl,rv); }
805 INLINE bool operator !=(const ivector &rv, const ivector_slice &sl) noexcept { return _vsvneq(sl,rv); }
806 INLINE bool operator <(const ivector &rv1, const ivector &rv2) noexcept { return _vvless(rv1,rv2); }
807 INLINE bool operator <(const ivector_slice &sl1, const ivector_slice &sl2) noexcept { return _vsvsless(sl1,sl2); }
808 INLINE bool operator < (const ivector_slice &sl, const ivector &rv) noexcept { return _vsvless(sl,rv); }
809 INLINE bool operator < (const ivector &rv, const ivector_slice &sl) noexcept { return _vvsless(rv,sl); }
810 INLINE bool operator <=(const ivector &rv1, const ivector &rv2) noexcept { return _vvleq(rv1,rv2); }
811 INLINE bool operator <=(const ivector_slice &sl1, const ivector_slice &sl2) noexcept { return _vsvsleq(sl1,sl2); }
812 INLINE bool operator <=(const ivector_slice &sl, const ivector &rv) noexcept { return _vsvleq(sl,rv); }
813 INLINE bool operator <=(const ivector &rv, const ivector_slice &sl) noexcept { return _vvsleq(rv,sl); }
814 INLINE bool operator >(const ivector &rv1, const ivector &rv2) noexcept { return _vvless(rv2,rv1); }
815 INLINE bool operator >(const ivector_slice &sl1, const ivector_slice &sl2) noexcept { return _vsvsless(sl2,sl1); }
816 INLINE bool operator >(const ivector_slice &sl, const ivector &rv) noexcept { return _vvsless(rv,sl); }
817 INLINE bool operator >(const ivector &rv, const ivector_slice &sl) noexcept { return _vsvless(sl,rv); }
818 INLINE bool operator >=(const ivector &rv1, const ivector &rv2) noexcept { return _vvleq(rv2,rv1); }
819 INLINE bool operator >=(const ivector_slice &sl1, const ivector_slice &sl2) noexcept { return _vsvsleq(sl2,sl1); }
820 INLINE bool operator >=(const ivector_slice &sl, const ivector &rv) noexcept { return _vvsleq(rv,sl); }
821 INLINE bool operator >=(const ivector &rv, const ivector_slice &sl) noexcept { return _vsvleq(sl,rv); }
822
823//-------------------------------- Interval / Real --------------------------------
824
825 INLINE ivector & ivector::operator =(const rvector_slice &sl) noexcept { return _vvsassign<ivector,rvector_slice,interval>(*this,sl); }
826
827
828 INLINE interval operator *(const rvector & rv1, const ivector &rv2)
829#if(CXSC_INDEX_CHECK)
830
831#else
832 noexcept
833#endif
834 { return _vvimult<rvector,ivector,interval>(rv1,rv2); }
835 INLINE interval operator *(const rvector_slice &sl, const ivector &rv)
836#if(CXSC_INDEX_CHECK)
837
838#else
839 noexcept
840#endif
841 { return _vsvimult<rvector_slice,ivector,interval>(sl,rv); }
842 INLINE interval operator *(const rvector &rv, const ivector_slice &sl)
843#if(CXSC_INDEX_CHECK)
844
845#else
846 noexcept
847#endif
848 { return _vsvimult<ivector_slice,rvector,interval>(sl,rv); }
849 INLINE interval operator *(const rvector_slice & sl1, const ivector_slice &sl2)
850#if(CXSC_INDEX_CHECK)
851
852#else
853 noexcept
854#endif
855 { return _vsvsimult<rvector_slice,ivector_slice,interval>(sl1,sl2); }
856
857 INLINE interval operator *(const ivector & rv1, const rvector &rv2)
858#if(CXSC_INDEX_CHECK)
859
860#else
861 noexcept
862#endif
863 { return _vvimult<rvector,ivector,interval>(rv2,rv1); }
864 INLINE interval operator *(const ivector_slice &sl, const rvector &rv)
865#if(CXSC_INDEX_CHECK)
866
867#else
868 noexcept
869#endif
870 { return _vsvimult<ivector_slice,rvector,interval>(sl,rv); }
871 INLINE interval operator *(const ivector &rv, const rvector_slice &sl)
872#if(CXSC_INDEX_CHECK)
873
874#else
875 noexcept
876#endif
877 { return _vsvimult<rvector_slice,ivector,interval>(sl,rv); }
878 INLINE interval operator *(const ivector_slice & sl1, const rvector_slice &sl2)
879#if(CXSC_INDEX_CHECK)
880
881#else
882 noexcept
883#endif
884 { return _vsvsimult<rvector_slice,ivector_slice,interval>(sl2,sl1); }
885
886 INLINE ivector operator +(const rvector &rv1, const ivector &rv2)
887#if(CXSC_INDEX_CHECK)
888
889#else
890 noexcept
891#endif
892 { return _vvplus<rvector,ivector,ivector>(rv1,rv2); }
893 INLINE ivector operator +(const rvector &rv, const ivector_slice &sl)
894#if(CXSC_INDEX_CHECK)
895
896#else
897 noexcept
898#endif
899 { return _vvsplus<rvector,ivector_slice,ivector>(rv,sl); }
900 INLINE ivector operator +(const rvector_slice &sl, const ivector &rv)
901#if(CXSC_INDEX_CHECK)
902
903#else
904 noexcept
905#endif
906 { return _vvsplus<ivector,rvector_slice,ivector>(rv,sl); }
907 INLINE ivector operator +(const rvector_slice &sl1, const ivector_slice &sl2)
908#if(CXSC_INDEX_CHECK)
909
910#else
911 noexcept
912#endif
913 { return _vsvsplus<rvector_slice,ivector_slice,ivector>(sl1,sl2); }
914
915 INLINE ivector operator +(const ivector &rv1, const rvector &rv2)
916#if(CXSC_INDEX_CHECK)
917
918#else
919 noexcept
920#endif
921 { return _vvplus<rvector,ivector,ivector>(rv2,rv1); }
922 INLINE ivector operator +(const ivector &rv, const rvector_slice &sl)
923#if(CXSC_INDEX_CHECK)
924
925#else
926 noexcept
927#endif
928 { return _vvsplus<ivector,rvector_slice,ivector>(rv,sl); }
929 INLINE ivector operator +(const ivector_slice &sl, const rvector &rv)
930#if(CXSC_INDEX_CHECK)
931
932#else
933 noexcept
934#endif
935 { return _vvsplus<rvector,ivector_slice,ivector>(rv,sl); }
936 INLINE ivector operator +(const ivector_slice &sl1, const rvector_slice &sl2)
937#if(CXSC_INDEX_CHECK)
938
939#else
940 noexcept
941#endif
942 { return _vsvsplus<rvector_slice,ivector_slice,ivector>(sl2,sl1); }
943
944 INLINE ivector & operator +=(ivector &rv1, const rvector &rv2)
945#if(CXSC_INDEX_CHECK)
946
947#else
948 noexcept
949#endif
950 { return _vvplusassign(rv1,rv2); }
951 INLINE ivector &operator +=(ivector &rv, const rvector_slice &sl)
952#if(CXSC_INDEX_CHECK)
953
954#else
955 noexcept
956#endif
957 { return _vvsplusassign(rv,sl); }
959#if(CXSC_INDEX_CHECK)
960
961#else
962 noexcept
963#endif
964 { return _vsvplusassign(*this,rv); }
966#if(CXSC_INDEX_CHECK)
967
968#else
969 noexcept
970#endif
971 { return _vsvsplusassign(*this,sl2); }
972
973 INLINE ivector operator -(const rvector &rv1, const ivector &rv2)
974#if(CXSC_INDEX_CHECK)
975
976#else
977 noexcept
978#endif
979 { return _vvminus<rvector,ivector,ivector>(rv1,rv2); }
980 INLINE ivector operator -(const rvector &rv, const ivector_slice &sl)
981#if(CXSC_INDEX_CHECK)
982
983#else
984 noexcept
985#endif
986 { return _vvsminus<rvector,ivector_slice,ivector>(rv,sl); }
987 INLINE ivector operator -(const rvector_slice &sl, const ivector &rv)
988#if(CXSC_INDEX_CHECK)
989
990#else
991 noexcept
992#endif
993 { return _vsvminus<rvector_slice,ivector,ivector>(sl,rv); }
994 INLINE ivector operator -(const rvector_slice &sl1, const ivector_slice &sl2)
995#if(CXSC_INDEX_CHECK)
996
997#else
998 noexcept
999#endif
1000 { return _vsvsminus<rvector_slice,ivector_slice,ivector>(sl1,sl2); }
1001
1002 INLINE ivector operator -(const ivector &rv1, const rvector &rv2)
1003#if(CXSC_INDEX_CHECK)
1004
1005#else
1006 noexcept
1007#endif
1008 { return _vvminus<ivector,rvector,ivector>(rv1,rv2); }
1009 INLINE ivector operator -(const ivector &rv, const rvector_slice &sl)
1010#if(CXSC_INDEX_CHECK)
1011
1012#else
1013 noexcept
1014#endif
1015 { return _vvsminus<ivector,rvector_slice,ivector>(rv,sl); }
1016 INLINE ivector operator -(const ivector_slice &sl, const rvector &rv)
1017#if(CXSC_INDEX_CHECK)
1018
1019#else
1020 noexcept
1021#endif
1022 { return _vsvminus<ivector_slice,rvector,ivector>(sl,rv); }
1023 INLINE ivector operator -(const ivector_slice &sl1, const rvector_slice &sl2)
1024#if(CXSC_INDEX_CHECK)
1025
1026#else
1027 noexcept
1028#endif
1029 { return _vsvsminus<ivector_slice,rvector_slice,ivector>(sl1,sl2); }
1030
1031 INLINE ivector & operator -=(ivector &rv1, const rvector &rv2)
1032#if(CXSC_INDEX_CHECK)
1033
1034#else
1035 noexcept
1036#endif
1037 { return _vvminusassign(rv1,rv2); }
1038 INLINE ivector &operator -=(ivector &rv, const rvector_slice &sl)
1039#if(CXSC_INDEX_CHECK)
1040
1041#else
1042 noexcept
1043#endif
1044 { return _vvsminusassign(rv,sl); }
1046#if(CXSC_INDEX_CHECK)
1047
1048#else
1049 noexcept
1050#endif
1051 { return _vsvminusassign(*this,rv); }
1053#if(CXSC_INDEX_CHECK)
1054
1055#else
1056 noexcept
1057#endif
1058 { return _vsvsminusassign(*this,sl2); }
1059
1060 INLINE ivector operator |(const rvector &rv1, const rvector &rv2)
1061#if(CXSC_INDEX_CHECK)
1062
1063#else
1064 noexcept
1065#endif
1066 { return _vvconv<rvector,rvector,ivector>(rv1,rv2); }
1067 INLINE ivector operator |(const rvector &rv, const rvector_slice &sl)
1068#if(CXSC_INDEX_CHECK)
1069
1070#else
1071 noexcept
1072#endif
1073 { return _vvsconv<rvector,rvector_slice,ivector>(rv,sl); }
1074 INLINE ivector operator |(const rvector_slice &sl, const rvector &rv)
1075#if(CXSC_INDEX_CHECK)
1076
1077#else
1078 noexcept
1079#endif
1080 { return _vvsconv<rvector,rvector_slice,ivector>(rv,sl); }
1081 INLINE ivector operator |(const rvector_slice &sl1, const rvector_slice &sl2)
1082#if(CXSC_INDEX_CHECK)
1083
1084#else
1085 noexcept
1086#endif
1087 { return _vsvsconv<rvector_slice,rvector_slice,ivector>(sl1,sl2); }
1088 INLINE ivector operator |(const rvector &rv1, const ivector &rv2)
1089#if(CXSC_INDEX_CHECK)
1090
1091#else
1092 noexcept
1093#endif
1094 { return _vvconv<rvector,ivector,ivector>(rv1,rv2); }
1095 INLINE ivector operator |(const rvector &rv, const ivector_slice &sl)
1096#if(CXSC_INDEX_CHECK)
1097
1098#else
1099 noexcept
1100#endif
1101 { return _vvsconv<rvector,ivector_slice,ivector>(rv,sl); }
1102 INLINE ivector operator |(const rvector_slice &sl, const ivector &rv)
1103#if(CXSC_INDEX_CHECK)
1104
1105#else
1106 noexcept
1107#endif
1108 { return _vvsconv<ivector,rvector_slice,ivector>(rv,sl); }
1109 INLINE ivector operator |(const rvector_slice &sl1, const ivector_slice &sl2)
1110#if(CXSC_INDEX_CHECK)
1111
1112#else
1113 noexcept
1114#endif
1115 { return _vsvsconv<rvector_slice,ivector_slice,ivector>(sl1,sl2); }
1116
1117 INLINE ivector operator |(const ivector &rv1, const rvector &rv2)
1118#if(CXSC_INDEX_CHECK)
1119
1120#else
1121 noexcept
1122#endif
1123 { return _vvconv<rvector,ivector,ivector>(rv2,rv1); }
1124 INLINE ivector operator |(const ivector &rv, const rvector_slice &sl)
1125#if(CXSC_INDEX_CHECK)
1126
1127#else
1128 noexcept
1129#endif
1130 { return _vvsconv<ivector,rvector_slice,ivector>(rv,sl); }
1131 INLINE ivector operator |(const ivector_slice &sl, const rvector &rv)
1132#if(CXSC_INDEX_CHECK)
1133
1134#else
1135 noexcept
1136#endif
1137 { return _vvsconv<rvector,ivector_slice,ivector>(rv,sl); }
1138 INLINE ivector operator |(const ivector_slice &sl1, const rvector_slice &sl2)
1139#if(CXSC_INDEX_CHECK)
1140
1141#else
1142 noexcept
1143#endif
1144 { return _vsvsconv<rvector_slice,ivector_slice,ivector>(sl2,sl1); }
1145
1146 INLINE ivector & operator |=(ivector &rv1, const rvector &rv2)
1147#if(CXSC_INDEX_CHECK)
1148
1149#else
1150 noexcept
1151#endif
1152 { return _vvconvassign(rv1,rv2); }
1153 INLINE ivector &operator |=(ivector &rv, const rvector_slice &sl)
1154#if(CXSC_INDEX_CHECK)
1155
1156#else
1157 noexcept
1158#endif
1159 { return _vvsconvassign(rv,sl); }
1161#if(CXSC_INDEX_CHECK)
1162
1163#else
1164 noexcept
1165#endif
1166 { return _vsvconvassign(*this,rv); }
1168#if(CXSC_INDEX_CHECK)
1169
1170#else
1171 noexcept
1172#endif
1173 { return _vsvsconvassign(*this,sl2); }
1174
1175 INLINE ivector operator &(const rvector &rv1, const ivector &rv2)
1176#if(CXSC_INDEX_CHECK)
1177
1178#else
1179 noexcept
1180#endif
1181 { return _vvsect<rvector,ivector,ivector>(rv1,rv2); }
1182 INLINE ivector operator &(const rvector &rv, const ivector_slice &sl)
1183#if(CXSC_INDEX_CHECK)
1184
1185#else
1186 noexcept
1187#endif
1188 { return _vvssect<rvector,ivector_slice,ivector>(rv,sl); }
1189 INLINE ivector operator &(const rvector_slice &sl, const ivector &rv)
1190#if(CXSC_INDEX_CHECK)
1191
1192#else
1193 noexcept
1194#endif
1195 { return _vvssect<ivector,rvector_slice,ivector>(rv,sl); }
1196 INLINE ivector operator &(const rvector_slice &sl1, const ivector_slice &sl2)
1197#if(CXSC_INDEX_CHECK)
1198
1199#else
1200 noexcept
1201#endif
1202 { return _vsvssect<rvector_slice,ivector_slice,ivector>(sl1,sl2); }
1203
1204 INLINE ivector operator &(const ivector &rv1, const rvector &rv2)
1205#if(CXSC_INDEX_CHECK)
1206
1207#else
1208 noexcept
1209#endif
1210 { return _vvsect<rvector,ivector,ivector>(rv2,rv1); }
1211 INLINE ivector operator &(const ivector &rv, const rvector_slice &sl)
1212#if(CXSC_INDEX_CHECK)
1213
1214#else
1215 noexcept
1216#endif
1217 { return _vvssect<ivector,rvector_slice,ivector>(rv,sl); }
1218 INLINE ivector operator &(const ivector_slice &sl, const rvector &rv)
1219#if(CXSC_INDEX_CHECK)
1220
1221#else
1222 noexcept
1223#endif
1224 { return _vvssect<rvector,ivector_slice,ivector>(rv,sl); }
1225 INLINE ivector operator &(const ivector_slice &sl1, const rvector_slice &sl2)
1226#if(CXSC_INDEX_CHECK)
1227
1228#else
1229 noexcept
1230#endif
1231 { return _vsvssect<rvector_slice,ivector_slice,ivector>(sl2,sl1); }
1232
1233 INLINE ivector & operator &=(ivector &rv1, const rvector &rv2)
1234#if(CXSC_INDEX_CHECK)
1235
1236#else
1237 noexcept
1238#endif
1239 { return _vvsectassign(rv1,rv2); }
1240 INLINE ivector &operator &=(ivector &rv, const rvector_slice &sl)
1241#if(CXSC_INDEX_CHECK)
1242
1243#else
1244 noexcept
1245#endif
1246 { return _vvssectassign(rv,sl); }
1248#if(CXSC_INDEX_CHECK)
1249
1250#else
1251 noexcept
1252#endif
1253 { return _vsvsectassign(*this,rv); }
1255#if(CXSC_INDEX_CHECK)
1256
1257#else
1258 noexcept
1259#endif
1260 { return _vsvssectassign(*this,sl2); }
1261
1262
1265 ivector x(*this);
1266 for(int i=0 ; i<VecLen(x) ; i++)
1267 x[i+Lb(x)] = (*this)[p[i+Lb(p)]+Lb(*this)];
1268 return x;
1269 }
1270
1271} // namespace cxsc
1272
1273#endif // _CXSC_IVECTOR_INL_INCLUDED
The Data Type imatrix.
Definition imatrix.hpp:660
The Scalar Type interval.
Definition interval.hpp:55
interval()
Constructor of class interval.
Definition interval.hpp:64
The Data Type intvector.
Definition intvector.hpp:52
The Data Type ivector_slice.
Definition ivector.hpp:963
interval & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector (read-only)
Definition ivector.inl:126
ivector_slice & operator|=(const ivector &rv) noexcept
Allocates the convex hull of the arguments to the first argument.
Definition ivector.inl:726
ivector_slice & operator+=(const ivector &rv) noexcept
Implementation of addition and allocation operation.
Definition ivector.inl:610
ivector_slice & operator-=(const ivector &rv) noexcept
Implementation of subtraction and allocation operation.
Definition ivector.inl:669
ivector_slice & operator*=(const interval &r) noexcept
Implementation of multiplication and allocation operation.
Definition ivector.inl:496
ivector_slice & operator=(const sivector &sl)
Implementation of standard assigning operator.
ivector_slice & operator/=(const interval &r) noexcept
Implementation of division and allocation operation.
Definition ivector.inl:501
ivector_slice & operator&=(const ivector &rv) noexcept
Allocates the intersection of the arguments to the first argument.
Definition ivector.inl:783
ivector_slice & operator()() noexcept
Operator for accessing the whole vector.
Definition ivector.hpp:1420
The Data Type ivector.
Definition ivector.hpp:55
ivector & operator=(const ivector &rv) noexcept
Implementation of standard assigning operator.
Definition ivector.inl:263
friend int Lb(const ivector &rv) noexcept
Returns the lower bound of the vector.
Definition ivector.hpp:908
ivector & operator()() noexcept
Operator for accessing the whole vector.
Definition ivector.hpp:934
ivector() noexcept
Constructor of class ivector.
Definition ivector.inl:31
interval & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector (read-only)
Definition ivector.inl:100
friend int VecLen(const ivector &rv) noexcept
Returns the dimension of the vector.
Definition ivector.hpp:912
The Scalar Type real.
Definition real.hpp:114
The Data Type rmatrix_subv.
Definition rmatrix.hpp:54
The Data Type rvector_slice.
Definition rvector.hpp:1064
The Data Type rvector.
Definition rvector.hpp:58
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition cdot.cpp:29
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc) noexcept
Implementation of standard algebraic addition and allocation operation.
Definition cdot.inl:251
INLINE ivector _ivector(const rmatrix &sl) noexcept
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC.
Definition ivecrmat.inl:57
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
rvector absmax(const imatrix_subv &mv) noexcept
Returns the absolute maximum value of the matrix.
Definition imatrix.inl:502
int Ub(const cimatrix &rm, const int &i) noexcept
Returns the upper bound index.
rvector absmin(const imatrix_subv &mv) noexcept
Returns the absolute minimum value of the matrix.
Definition imatrix.inl:496
cimatrix & operator*=(cimatrix &m, const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
real AbsMax(const interval &x)
Computes the greatest absolute value .
Definition interval.cpp:303
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
Definition cimatrix.inl:737
cvector mid(const cimatrix_subv &mv) noexcept
Returns the middle of the matrix.
Definition cimatrix.inl:739
civector operator*(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of multiplication operation.
Definition cimatrix.inl:731
void Resize(cimatrix &A) noexcept
Resizes the matrix.
cimatrix_subv & SetUncheckedInf(cimatrix_subv &iv, const complex &r) noexcept
Returns the matrix with the new unchecked given infimum value.
Definition cimatrix.inl:890
int Lb(const cimatrix &rm, const int &i) noexcept
Returns the lower bound index.
real AbsMin(const interval &x)
Computes the smallest absolute value .
Definition interval.cpp:293
cimatrix & operator/=(cimatrix &m, const cinterval &c) noexcept
Implementation of division and allocation operation.