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