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 
29 namespace 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 
180  INLINE cinterval & civector_slice::operator [](const int &i)
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 
247  INLINE cinterval::cinterval(const civector &rv)
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); }
871  INLINE civector &operator +=(civector &rv, const civector_slice &sl)
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); }
1236  INLINE civector &operator +=(civector &rv, const rvector_slice &sl)
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); }
1664  INLINE civector &operator +=(civector &rv, const cvector_slice &sl)
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); }
2092  INLINE civector &operator +=(civector &rv, const ivector_slice &sl)
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.
Definition: civector.hpp:1015
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.
Definition: civector.inl:1051
civector_slice & operator()() noexcept
Operator for accessing the whole vector.
Definition: civector.hpp:1707
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=(const scivector_slice &sl)
Implementation of standard assigning operator.
Definition: scivector.hpp:4688
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.
Definition: scimatrix.hpp:9966
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.
Definition: cinterval.cpp:654
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc) noexcept
Implementation of standard algebraic addition and allocation operation.
Definition: cdot.inl:251
cimatrix & operator*=(cimatrix &m, const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
Definition: cimatrix.inl:1605
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737
cvector mid(const cimatrix_subv &mv) noexcept
Returns the middle of the matrix.
Definition: cimatrix.inl:739
civector operator*(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of multiplication operation.
Definition: cimatrix.inl:731
void Resize(cimatrix &A) noexcept
Resizes the matrix.
Definition: cimatrix.inl:1211
cimatrix_subv & SetUncheckedInf(cimatrix_subv &iv, const complex &r) noexcept
Returns the matrix with the new unchecked given infimum value.
Definition: cimatrix.inl:890
int Lb(const cimatrix &rm, const int &i) noexcept
Returns the lower bound index.
Definition: cimatrix.inl:1156
cimatrix & operator/=(cimatrix &m, const cinterval &c) noexcept
Implementation of division and allocation operation.
Definition: cimatrix.inl:1623