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 () throw():dat(NULL),l(1),u(0),size(0)
32  {
33  }
34 
35  INLINE civector::civector(const int &i) throw():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) throw():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  throw(ERROR_CIVECTOR_WRONG_BOUNDARIES,ERROR_CIVECTOR_NO_MORE_MEMORY):l(i1),u(i2),size(i2-i1+1)
50 #else
51  throw():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) throw():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) throw():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) throw():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) throw():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) throw():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) throw():l(1),u(1),size(1)
96  {
97  dat=new cinterval[1];
98  *dat=r;
99  }
100 
101  INLINE civector::civector(const cvector &v) throw():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) throw():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) throw():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) throw():l(1),u(1),size(1)
123  {
124  dat=new cinterval[1];
125  *dat=r;
126  }
127 
128  INLINE civector::civector(const interval &r) throw():l(1),u(1),size(1)
129  {
130  dat=new cinterval[1];
131  *dat=r;
132  }
133 
134  INLINE civector::civector(const complex &r) throw():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  throw(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC)
143 #else
144  throw()
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  throw(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC)
156 #else
157  throw()
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  throw(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC)
169 #else
170  throw()
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  throw(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC)
183 #else
184  throw()
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  throw(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG)
198 #else
199  throw()
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  throw(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG)
211 #else
212  throw()
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  throw(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG)
224 #else
225  throw()
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  throw(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG)
237 #else
238  throw()
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  throw(ERROR_CIVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_CIVECTOR_USE_OF_UNINITIALIZED_OBJ)
250 #else
251  throw()
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  throw(ERROR_CIVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_CIVECTOR_USE_OF_UNINITIALIZED_OBJ)
264 #else
265  throw()
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) throw() { return civector(r); }
281 
287  INLINE civector _civector(const real &r) throw() { return civector(r); }
293  INLINE civector _civector(const rvector_slice &rs) throw() { return civector(rs); }
299  INLINE civector _civector(const rvector &rs) throw() { return civector(rs); }
300 
306  INLINE civector _civector(const complex &r) throw() { return civector(r); }
312  INLINE civector _civector(const cvector_slice &rs) throw() { return civector(rs); }
318  INLINE civector _civector(const cvector &rs) throw() { return civector(rs); }
319 
325  INLINE civector _civector(const interval &r) throw() { return civector(r); }
331  INLINE civector _civector(const ivector_slice &rs) throw() { return civector(rs); }
337  INLINE civector _civector(const ivector &rs) throw() { return civector(rs); }
338 
339  INLINE civector &civector::operator =(const civector &rv) throw() { return _vvassign<civector,civector,cinterval>(*this,rv); }
340  INLINE civector &civector::operator =(const cinterval &r) throw() { return _vsassign<civector,cinterval>(*this,r); }
341  INLINE civector::operator void*() throw() { return _vvoid(*this); }
343 #if(CXSC_INDEX_CHECK)
344  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
345 #else
346  throw()
347 #endif
348  { return _vsvsassign(*this,sl); }
350 #if(CXSC_INDEX_CHECK)
351  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
352 #else
353  throw()
354 #endif
355  { return _vsvassign(*this,rv); }
356  INLINE civector_slice & civector_slice::operator =(const cinterval &r) throw() { return _vssassign<civector_slice,cinterval>(*this,r); }
358 #if(CXSC_INDEX_CHECK)
359  throw(ERROR__OP_WITH_WRONG_DIM<civector>,ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ)
360 #else
361  throw()
362 #endif
363  { return _vsvassign(*this,civector(m)); }
364  INLINE civector_slice::operator void*() throw() { 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  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
373 #else
374  throw()
375 #endif
376  { return _vvsetinf(iv,rv); }
377  INLINE civector_slice &SetInf(civector_slice &iv,const cvector &rv)
378 #if(CXSC_INDEX_CHECK)
379  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
380 #else
381  throw()
382 #endif
383  { return _vsvsetinf(iv,rv); }
384  INLINE civector &SetInf(civector &iv,const cvector_slice &rv)
385 #if(CXSC_INDEX_CHECK)
386  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
387 #else
388  throw()
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  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
394 #else
395  throw()
396 #endif
397  { return _vsvssetinf(iv,rv); }
398  INLINE civector &UncheckedSetInf(civector &iv,const cvector &rv)
399 #if(CXSC_INDEX_CHECK)
400  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
401 #else
402  throw()
403 #endif
404  { return _vvusetinf(iv,rv); }
405  INLINE civector_slice &UncheckedSetInf(civector_slice &iv,const cvector &rv)
406 #if(CXSC_INDEX_CHECK)
407  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
408 #else
409  throw()
410 #endif
411  { return _vsvusetinf(iv,rv); }
412  INLINE civector &UncheckedSetInf(civector &iv,const cvector_slice &rv)
413 #if(CXSC_INDEX_CHECK)
414  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
415 #else
416  throw()
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  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
422 #else
423  throw()
424 #endif
425  { return _vsvsusetinf(iv,rv); }
426 
427  INLINE civector &SetSup(civector &iv,const cvector &rv)
428 #if(CXSC_INDEX_CHECK)
429  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
430 #else
431  throw()
432 #endif
433  { return _vvsetsup(iv,rv); }
434  INLINE civector_slice &SetSup(civector_slice &iv,const cvector &rv)
435 #if(CXSC_INDEX_CHECK)
436  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
437 #else
438  throw()
439 #endif
440  { return _vsvsetsup(iv,rv); }
441  INLINE civector &SetSup(civector &iv,const cvector_slice &rv)
442 #if(CXSC_INDEX_CHECK)
443  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
444 #else
445  throw()
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  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
451 #else
452  throw()
453 #endif
454  { return _vsvssetsup(iv,rv); }
455  INLINE civector &UncheckedSetSup(civector &iv,const cvector &rv)
456 #if(CXSC_INDEX_CHECK)
457  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
458 #else
459  throw()
460 #endif
461  { return _vvusetsup(iv,rv); }
462  INLINE civector_slice &UncheckedSetSup(civector_slice &iv,const cvector &rv)
463 #if(CXSC_INDEX_CHECK)
464  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
465 #else
466  throw()
467 #endif
468  { return _vsvusetsup(iv,rv); }
469  INLINE civector &UncheckedSetSup(civector &iv,const cvector_slice &rv)
470 #if(CXSC_INDEX_CHECK)
471  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
472 #else
473  throw()
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  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
479 #else
480  throw()
481 #endif
482  { return _vsvsusetsup(iv,rv); }
483 
484  INLINE civector &SetRe(civector &iv,const ivector &rv)
485 #if(CXSC_INDEX_CHECK)
486  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
487 #else
488  throw()
489 #endif
490  { return _vvsetre(iv,rv); }
491  INLINE civector_slice &SetRe(civector_slice &iv,const ivector &rv)
492 #if(CXSC_INDEX_CHECK)
493  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
494 #else
495  throw()
496 #endif
497  { return _vsvsetre(iv,rv); }
498  INLINE civector &SetRe(civector &iv,const ivector_slice &rv)
499 #if(CXSC_INDEX_CHECK)
500  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
501 #else
502  throw()
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  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
508 #else
509  throw()
510 #endif
511  { return _vsvssetre(iv,rv); }
512 
513  INLINE civector &SetIm(civector &iv,const ivector &rv)
514 #if(CXSC_INDEX_CHECK)
515  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
516 #else
517  throw()
518 #endif
519  { return _vvsetim(iv,rv); }
520  INLINE civector_slice &SetIm(civector_slice &iv,const ivector &rv)
521 #if(CXSC_INDEX_CHECK)
522  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
523 #else
524  throw()
525 #endif
526  { return _vsvsetim(iv,rv); }
527  INLINE civector &SetIm(civector &iv,const ivector_slice &rv)
528 #if(CXSC_INDEX_CHECK)
529  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
530 #else
531  throw()
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  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM)
537 #else
538  throw()
539 #endif
540  { return _vsvssetim(iv,rv); }
541 
542  INLINE civector &SetSup(civector &iv,const complex &r) throw() { return _vssetsup(iv,r); }
543  INLINE civector &SetInf(civector &iv,const complex &r) throw() { return _vssetinf(iv,r); }
544  INLINE civector &UncheckedSetSup(civector &iv,const complex &r) throw() { return _vsusetsup(iv,r); }
545  INLINE civector &SetUncheckedInf(civector &iv,const complex &r) throw() { return _vsusetinf(iv,r); }
546  INLINE civector &SetRe(civector &iv,const interval &r) throw() { return _vssetre(iv,r); }
547  INLINE civector &SetIm(civector &iv,const interval &r) throw() { return _vssetim(iv,r); }
548 
549  INLINE civector_slice &SetSup(civector_slice &iv,const complex &r) throw() { return _vsssetsup(iv,r); }
550  INLINE civector_slice &SetInf(civector_slice &iv,const complex &r) throw() { return _vsssetinf(iv,r); }
551  INLINE civector_slice &UncheckedSetSup(civector_slice &iv,const complex &r) throw() { return _vssusetsup(iv,r); }
552  INLINE civector_slice &SetUncheckedInf(civector_slice &iv,const complex &r) throw() { return _vssusetinf(iv,r); }
553  INLINE civector_slice &SetRe(civector_slice &iv,const interval &r) throw() { return _vsssetre(iv,r); }
554  INLINE civector_slice &SetIm(civector_slice &iv,const interval &r) throw() { return _vsssetim(iv,r); }
555 
556  INLINE ivector Re(const civector &v) throw()
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) throw()
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) throw()
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) throw()
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) throw()
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) throw()
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) throw()
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) throw()
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) throw()
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) throw()
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) throw()
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) throw()
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) throw() { _vresize(rv); }
680  INLINE void Resize(civector &rv, const int &len)
681 #if(CXSC_INDEX_CHECK)
682  throw(ERROR__WRONG_BOUNDARIES<civector>)
683 #else
684  throw()
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  throw(ERROR__WRONG_BOUNDARIES<civector>)
690 #else
691  throw()
692 #endif
693  { _vresize<class civector,class cinterval>(rv,lb,ub); }
694 
695  INLINE civector conj(const civector &rv) throw() { return _vconj<civector>(rv); }
696  INLINE civector conj(const civector_slice &sl) throw() { return _vsconj<civector_slice,civector>(sl); }
697 
698  INLINE ivector abs(const civector &rv) throw() { return _vabs<civector,ivector>(rv); }
699  INLINE ivector abs(const civector_slice &sl) throw() { return _vsabs<civector_slice,ivector>(sl); }
700  INLINE cvector diam(const civector &v) throw() { return _vdiam<civector,cvector>(v); }
701  INLINE cvector diam(const civector_slice &v) throw() { return _vsdiam<civector_slice,cvector>(v); }
702  INLINE cvector mid(const civector &v) throw() { return _vmid<civector,cvector>(v); }
703  INLINE cvector mid(const civector_slice &v) throw() { return _vsmid<civector_slice,cvector>(v); }
704  INLINE cvector Inf(const civector &v) throw() { return _vinf<civector,cvector>(v); }
705  INLINE cvector Inf(const civector_slice &v) throw() { return _vsinf<civector_slice,cvector>(v); }
706  INLINE cvector Sup(const civector &v) throw() { return _vsup<civector,cvector>(v); }
707  INLINE cvector Sup(const civector_slice &v) throw() { return _vssup<civector_slice,cvector>(v); }
708  INLINE bool operator !(const civector &rv) throw() { return _vnot(rv); }
709  INLINE bool operator !(const civector_slice &sl) throw() { return _vsnot(sl); }
710 
711 //======================= Vector / Scalar ===============================
712 
713 //----------------------------- cinterval ---------------------------
714 
715  INLINE civector operator *(const civector &rv, const cinterval &s) throw() { return _vsmult<civector,cinterval,civector>(rv,s); }
716  INLINE civector operator *(const civector_slice &sl, const cinterval &s) throw() { return _vssmult<civector_slice,cinterval,civector>(sl,s); }
717  INLINE civector operator *(const cinterval &s, const civector &rv) throw() { return _vsmult<civector,cinterval,civector>(rv,s); }
718  INLINE civector operator *(const cinterval &s, const civector_slice &sl) throw() { return _vssmult<civector_slice,cinterval,civector>(sl,s); }
719  INLINE civector &operator *=(civector &rv,const cinterval &r) throw() { return _vsmultassign(rv,r); }
720  INLINE civector_slice &civector_slice::operator *=(const cinterval &r) throw() { return _vssmultassign(*this,r); }
721 
722  INLINE civector operator /(const civector &rv, const cinterval &s) throw() { return _vsdiv<civector,cinterval,civector>(rv,s); }
723  INLINE civector operator /(const civector_slice &sl, const cinterval &s) throw() { return _vssdiv<civector_slice,cinterval,civector>(sl,s); }
724  INLINE civector &operator /=(civector &rv,const cinterval &r) throw() { return _vsdivassign(rv,r); }
725  INLINE civector_slice &civector_slice::operator /=(const cinterval &r) throw() { return _vssdivassign(*this,r); }
726 
727 //---------------------------- Real --------------------------------------
728 
729  INLINE civector operator *(const civector &rv, const real &s) throw() { return _vsmult<civector,real,civector>(rv,s); }
730  INLINE civector operator *(const civector_slice &sl, const real &s) throw() { return _vssmult<civector_slice,real,civector>(sl,s); }
731  INLINE civector operator *(const real &s, const civector &rv) throw() { return _vsmult<civector,real,civector>(rv,s); }
732  INLINE civector operator *(const real &s, const civector_slice &sl) throw() { return _vssmult<civector_slice,real,civector>(sl,s); }
733  INLINE civector &operator *=(civector &rv,const real &r) throw() { return _vsmultassign(rv,r); }
734  INLINE civector_slice &civector_slice::operator *=(const real &r) throw() { return _vssmultassign(*this,r); }
735 
736  INLINE civector operator /(const civector &rv, const real &s) throw() { return _vsdiv<civector,real,civector>(rv,s); }
737  INLINE civector operator /(const civector_slice &sl, const real &s) throw() { return _vssdiv<civector_slice,real,civector>(sl,s); }
738  INLINE civector &operator /=(civector &rv,const real &r) throw() { return _vsdivassign(rv,r); }
739  INLINE civector_slice &civector_slice::operator /=(const real &r) throw() { return _vssdivassign(*this,r); }
740 
741  INLINE civector operator *(const rvector &rv, const cinterval &s) throw() { return _vsmult<rvector,cinterval,civector>(rv,s); }
742  INLINE civector operator *(const rvector_slice &sl, const cinterval &s) throw() { return _vssmult<rvector_slice,cinterval,civector>(sl,s); }
743  INLINE civector operator *(const cinterval &s, const rvector &rv) throw() { return _vsmult<rvector,cinterval,civector>(rv,s); }
744  INLINE civector operator *(const cinterval &s, const rvector_slice &sl) throw() { return _vssmult<rvector_slice,cinterval,civector>(sl,s); }
745 
746  INLINE civector operator /(const rvector &rv, const cinterval &s) throw() { return _vsdiv<rvector,cinterval,civector>(rv,s); }
747  INLINE civector operator /(const rvector_slice &sl, const cinterval &s) throw() { return _vssdiv<rvector_slice,cinterval,civector>(sl,s); }
748 
749 //---------------------------- complex --------------------------------------
750 
751  INLINE civector operator *(const civector &rv, const complex &s) throw() { return _vsmult<civector,complex,civector>(rv,s); }
752  INLINE civector operator *(const civector_slice &sl, const complex &s) throw() { return _vssmult<civector_slice,complex,civector>(sl,s); }
753  INLINE civector operator *(const complex &s, const civector &rv) throw() { return _vsmult<civector,complex,civector>(rv,s); }
754  INLINE civector operator *(const complex &s, const civector_slice &sl) throw() { return _vssmult<civector_slice,complex,civector>(sl,s); }
755  INLINE civector &operator *=(civector &rv,const complex &r) throw() { return _vsmultassign(rv,r); }
756  INLINE civector_slice &civector_slice::operator *=(const complex &r) throw() { return _vssmultassign(*this,r); }
757 
758  INLINE civector operator /(const civector &rv, const complex &s) throw() { return _vsdiv<civector,complex,civector>(rv,s); }
759  INLINE civector operator /(const civector_slice &sl, const complex &s) throw() { return _vssdiv<civector_slice,complex,civector>(sl,s); }
760  INLINE civector &operator /=(civector &rv,const complex &r) throw() { return _vsdivassign(rv,r); }
761  INLINE civector_slice &civector_slice::operator /=(const complex &r) throw() { return _vssdivassign(*this,r); }
762 
763  INLINE civector operator *(const cvector &rv, const cinterval &s) throw() { return _vsmult<cvector,cinterval,civector>(rv,s); }
764  INLINE civector operator *(const cvector_slice &sl, const cinterval &s) throw() { return _vssmult<cvector_slice,cinterval,civector>(sl,s); }
765  INLINE civector operator *(const cinterval &s, const cvector &rv) throw() { return _vsmult<cvector,cinterval,civector>(rv,s); }
766  INLINE civector operator *(const cinterval &s, const cvector_slice &sl) throw() { return _vssmult<cvector_slice,cinterval,civector>(sl,s); }
767 
768  INLINE civector operator /(const cvector &rv, const cinterval &s) throw() { return _vsdiv<cvector,cinterval,civector>(rv,s); }
769  INLINE civector operator /(const cvector_slice &sl, const cinterval &s) throw() { return _vssdiv<cvector_slice,cinterval,civector>(sl,s); }
770 
771 //---------------------------- interval --------------------------------------
772 
773  INLINE civector operator *(const civector &rv, const interval &s) throw() { return _vsmult<civector,interval,civector>(rv,s); }
774  INLINE civector operator *(const civector_slice &sl, const interval &s) throw() { return _vssmult<civector_slice,interval,civector>(sl,s); }
775  INLINE civector operator *(const interval &s, const civector &rv) throw() { return _vsmult<civector,interval,civector>(rv,s); }
776  INLINE civector operator *(const interval &s, const civector_slice &sl) throw() { return _vssmult<civector_slice,interval,civector>(sl,s); }
777  INLINE civector &operator *=(civector &rv,const interval &r) throw() { return _vsmultassign(rv,r); }
778  INLINE civector_slice &civector_slice::operator *=(const interval &r) throw() { return _vssmultassign(*this,r); }
779 
780  INLINE civector operator /(const civector &rv, const interval &s) throw() { return _vsdiv<civector,interval,civector>(rv,s); }
781  INLINE civector operator /(const civector_slice &sl, const interval &s) throw() { return _vssdiv<civector_slice,interval,civector>(sl,s); }
782  INLINE civector &operator /=(civector &rv,const interval &r) throw() { return _vsdivassign(rv,r); }
783  INLINE civector_slice &civector_slice::operator /=(const interval &r) throw() { return _vssdivassign(*this,r); }
784 
785  INLINE civector operator *(const ivector &rv, const cinterval &s) throw() { return _vsmult<ivector,cinterval,civector>(rv,s); }
786  INLINE civector operator *(const ivector_slice &sl, const cinterval &s) throw() { return _vssmult<ivector_slice,cinterval,civector>(sl,s); }
787  INLINE civector operator *(const cinterval &s, const ivector &rv) throw() { return _vsmult<ivector,cinterval,civector>(rv,s); }
788  INLINE civector operator *(const cinterval &s, const ivector_slice &sl) throw() { return _vssmult<ivector_slice,cinterval,civector>(sl,s); }
789 
790  INLINE civector operator /(const ivector &rv, const cinterval &s) throw() { return _vsdiv<ivector,cinterval,civector>(rv,s); }
791  INLINE civector operator /(const ivector_slice &sl, const cinterval &s) throw() { 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) throw() { return _vout(s,rv); }
797  INLINE std::ostream &operator <<(std::ostream &o, const civector_slice &sl) throw() { return _vsout(o,sl); }
798  INLINE std::istream &operator >>(std::istream &s, civector &rv) throw() { return _vin(s,rv); }
799  INLINE std::istream &operator >>(std::istream &s, civector_slice &rv) throw() { return _vsin(s,rv); }
800 
801 //----------------------- cinterval / cinterval ---------------------------
802  INLINE civector & civector::operator =(const civector_slice &sl) throw() { 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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
808 #else
809  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
815 #else
816  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
822 #else
823  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
829 #else
830  throw()
831 #endif
832  { return _vsvscimult<civector_slice,civector_slice,cinterval>(sl1,sl2); }
833 
834  INLINE const civector &operator +(const civector &rv) throw() { return rv; }
835  INLINE civector operator +(const civector_slice &sl) throw() { return sl; }
836  INLINE civector operator +(const civector &rv1, const civector &rv2)
837 #if(CXSC_INDEX_CHECK)
838  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
839 #else
840  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
846 #else
847  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
853 #else
854  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
860 #else
861  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
867 #else
868  throw()
869 #endif
870  { return _vvplusassign(rv1,rv2); }
871  INLINE civector &operator +=(civector &rv, const civector_slice &sl)
872 #if(CXSC_INDEX_CHECK)
873  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
874 #else
875  throw()
876 #endif
877  { return _vvsplusassign(rv,sl); }
879 #if(CXSC_INDEX_CHECK)
880  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
881 #else
882  throw()
883 #endif
884  { return _vsvplusassign(*this,rv); }
886 #if(CXSC_INDEX_CHECK)
887  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
888 #else
889  throw()
890 #endif
891  { return _vsvsplusassign(*this,sl2); }
892 
893  INLINE civector operator -(const civector &rv) throw() { return _vminus(rv); }
894  INLINE civector operator -(const civector_slice &sl) throw() { return _vsminus<civector_slice,civector>(sl); }
895  INLINE civector operator -(const civector &rv1, const civector &rv2)
896 #if(CXSC_INDEX_CHECK)
897  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
898 #else
899  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
905 #else
906  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
912 #else
913  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
919 #else
920  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
926 #else
927  throw()
928 #endif
929  { return _vvminusassign(rv1,rv2); }
930  INLINE civector &operator -=(civector &rv, const civector_slice &sl)
931 #if(CXSC_INDEX_CHECK)
932  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
933 #else
934  throw()
935 #endif
936  { return _vvsminusassign(rv,sl); }
938 #if(CXSC_INDEX_CHECK)
939  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
940 #else
941  throw()
942 #endif
943  { return _vsvminusassign(*this,rv); }
945 #if(CXSC_INDEX_CHECK)
946  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
947 #else
948  throw()
949 #endif
950  { return _vsvsminusassign(*this,sl2); }
951 
952  INLINE civector operator |(const civector &rv1, const civector &rv2)
953 #if(CXSC_INDEX_CHECK)
954  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
955 #else
956  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
962 #else
963  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
969 #else
970  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
976 #else
977  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
983 #else
984  throw()
985 #endif
986  { return _vvconvassign(rv1,rv2); }
987  INLINE civector &operator |=(civector &rv, const civector_slice &sl)
988 #if(CXSC_INDEX_CHECK)
989  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
990 #else
991  throw()
992 #endif
993  { return _vvsconvassign(rv,sl); }
995 #if(CXSC_INDEX_CHECK)
996  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
997 #else
998  throw()
999 #endif
1000  { return _vsvconvassign(*this,rv); }
1002 #if(CXSC_INDEX_CHECK)
1003  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1004 #else
1005  throw()
1006 #endif
1007  { return _vsvsconvassign(*this,sl2); }
1008 
1009  INLINE civector operator &(const civector &rv1, const civector &rv2)
1010 #if(CXSC_INDEX_CHECK)
1011  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1012 #else
1013  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1019 #else
1020  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1026 #else
1027  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1033 #else
1034  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1040 #else
1041  throw()
1042 #endif
1043  { return _vvsectassign(rv1,rv2); }
1044  INLINE civector &operator &=(civector &rv, const civector_slice &sl)
1045 #if(CXSC_INDEX_CHECK)
1046  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1047 #else
1048  throw()
1049 #endif
1050  { return _vvssectassign(rv,sl); }
1052 #if(CXSC_INDEX_CHECK)
1053  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1054 #else
1055  throw()
1056 #endif
1057  { return _vsvsectassign(*this,rv); }
1059 #if(CXSC_INDEX_CHECK)
1060  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1061 #else
1062  throw()
1063 #endif
1064  { return _vsvssectassign(*this,sl2); }
1065 
1066  INLINE bool operator ==(const civector &rv1, const civector &rv2) throw() { return _vveq(rv1,rv2); }
1067  INLINE bool operator ==(const civector_slice &sl1, const civector_slice &sl2) throw() { return _vsvseq(sl1,sl2); }
1068  INLINE bool operator ==(const civector_slice &sl, const civector &rv) throw() { return _vsveq(sl,rv); }
1069  INLINE bool operator ==(const civector &rv, const civector_slice &sl) throw() { return _vsveq(sl,rv); }
1070  INLINE bool operator !=(const civector &rv1, const civector &rv2) throw() { return _vvneq(rv1,rv2); }
1071  INLINE bool operator !=(const civector_slice &sl1, const civector_slice &sl2) throw() { return _vsvsneq(sl1,sl2); }
1072  INLINE bool operator !=(const civector_slice &sl, const civector &rv) throw() { return _vsvneq(sl,rv); }
1073  INLINE bool operator !=(const civector &rv, const civector_slice &sl) throw() { return _vsvneq(sl,rv); }
1074  INLINE bool operator <(const civector &rv1, const civector &rv2) throw() { return _vvless(rv1,rv2); }
1075  INLINE bool operator <(const civector_slice &sl1, const civector_slice &sl2) throw() { return _vsvsless(sl1,sl2); }
1076  INLINE bool operator < (const civector_slice &sl, const civector &rv) throw() { return _vsvless(sl,rv); }
1077  INLINE bool operator < (const civector &rv, const civector_slice &sl) throw() { return _vvsless(rv,sl); }
1078  INLINE bool operator <=(const civector &rv1, const civector &rv2) throw() { return _vvleq(rv1,rv2); }
1079  INLINE bool operator <=(const civector_slice &sl1, const civector_slice &sl2) throw() { return _vsvsleq(sl1,sl2); }
1080  INLINE bool operator <=(const civector_slice &sl, const civector &rv) throw() { return _vsvleq(sl,rv); }
1081  INLINE bool operator <=(const civector &rv, const civector_slice &sl) throw() { return _vvsleq(rv,sl); }
1082  INLINE bool operator >(const civector &rv1, const civector &rv2) throw() { return _vvless(rv2,rv1); }
1083  INLINE bool operator >(const civector_slice &sl1, const civector_slice &sl2) throw() { return _vsvsless(sl2,sl1); }
1084  INLINE bool operator >(const civector_slice &sl, const civector &rv) throw() { return _vvsless(rv,sl); }
1085  INLINE bool operator >(const civector &rv, const civector_slice &sl) throw() { return _vsvless(sl,rv); }
1086  INLINE bool operator >=(const civector &rv1, const civector &rv2) throw() { return _vvleq(rv2,rv1); }
1087  INLINE bool operator >=(const civector_slice &sl1, const civector_slice &sl2) throw() { return _vsvsleq(sl2,sl1); }
1088  INLINE bool operator >=(const civector_slice &sl, const civector &rv) throw() { return _vvsleq(rv,sl); }
1089  INLINE bool operator >=(const civector &rv, const civector_slice &sl) throw() { return _vsvleq(sl,rv); }
1090 
1091 //-------------------------------- cinterval / Real --------------------------------
1092 
1093  INLINE civector &civector::operator =(const rvector &rv) throw() { return _vvassign<civector,rvector,cinterval>(*this,rv); }
1094  INLINE civector &civector::operator =(const real &r) throw() { return _vsassign<civector,real>(*this,r); }
1095  INLINE civector & civector::operator =(const rvector_slice &sl) throw() { return _vvsassign<civector,rvector_slice,cinterval>(*this,sl); }
1097 #if(CXSC_INDEX_CHECK)
1098  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1099 #else
1100  throw()
1101 #endif
1102  { return _vsvassign(*this,rv); }
1103  INLINE civector_slice &civector_slice::operator =(const real &r) throw() { return _vssassign<civector_slice,real>(*this,r); }
1105 #if(CXSC_INDEX_CHECK)
1106  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1107 #else
1108  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1116 #else
1117  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1123 #else
1124  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1130 #else
1131  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1137 #else
1138  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1145 #else
1146  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1152 #else
1153  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1159 #else
1160  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1166 #else
1167  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1174 #else
1175  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1181 #else
1182  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1188 #else
1189  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1195 #else
1196  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1203 #else
1204  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1210 #else
1211  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1217 #else
1218  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1224 #else
1225  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1232 #else
1233  throw()
1234 #endif
1235  { return _vvplusassign(rv1,rv2); }
1236  INLINE civector &operator +=(civector &rv, const rvector_slice &sl)
1237 #if(CXSC_INDEX_CHECK)
1238  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1239 #else
1240  throw()
1241 #endif
1242  { return _vvsplusassign(rv,sl); }
1244 #if(CXSC_INDEX_CHECK)
1245  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1246 #else
1247  throw()
1248 #endif
1249  { return _vsvplusassign(*this,rv); }
1251 #if(CXSC_INDEX_CHECK)
1252  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1253 #else
1254  throw()
1255 #endif
1256  { return _vsvsplusassign(*this,sl2); }
1257 
1258  INLINE civector operator -(const rvector &rv1, const civector &rv2)
1259 #if(CXSC_INDEX_CHECK)
1260  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1261 #else
1262  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1268 #else
1269  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1275 #else
1276  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1282 #else
1283  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1290 #else
1291  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1297 #else
1298  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1304 #else
1305  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1311 #else
1312  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1319 #else
1320  throw()
1321 #endif
1322  { return _vvminusassign(rv1,rv2); }
1323  INLINE civector &operator -=(civector &rv, const rvector_slice &sl)
1324 #if(CXSC_INDEX_CHECK)
1325  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1326 #else
1327  throw()
1328 #endif
1329  { return _vvsminusassign(rv,sl); }
1331 #if(CXSC_INDEX_CHECK)
1332  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1333 #else
1334  throw()
1335 #endif
1336  { return _vsvminusassign(*this,rv); }
1338 #if(CXSC_INDEX_CHECK)
1339  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1340 #else
1341  throw()
1342 #endif
1343  { return _vsvsminusassign(*this,sl2); }
1344 
1345  INLINE civector operator |(const rvector &rv1, const civector &rv2)
1346 #if(CXSC_INDEX_CHECK)
1347  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1348 #else
1349  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1355 #else
1356  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1362 #else
1363  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1369 #else
1370  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1377 #else
1378  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1384 #else
1385  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1391 #else
1392  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1398 #else
1399  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1406 #else
1407  throw()
1408 #endif
1409  { return _vvconvassign(rv1,rv2); }
1410  INLINE civector &operator |=(civector &rv, const rvector_slice &sl)
1411 #if(CXSC_INDEX_CHECK)
1412  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1413 #else
1414  throw()
1415 #endif
1416  { return _vvsconvassign(rv,sl); }
1418 #if(CXSC_INDEX_CHECK)
1419  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1420 #else
1421  throw()
1422 #endif
1423  { return _vsvconvassign(*this,rv); }
1425 #if(CXSC_INDEX_CHECK)
1426  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1427 #else
1428  throw()
1429 #endif
1430  { return _vsvsconvassign(*this,sl2); }
1431 
1432  INLINE civector operator &(const rvector &rv1, const civector &rv2)
1433 #if(CXSC_INDEX_CHECK)
1434  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1435 #else
1436  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1442 #else
1443  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1449 #else
1450  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1456 #else
1457  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1464 #else
1465  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1471 #else
1472  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1478 #else
1479  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1485 #else
1486  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1493 #else
1494  throw()
1495 #endif
1496  { return _vvsectassign(rv1,rv2); }
1497  INLINE civector &operator &=(civector &rv, const rvector_slice &sl)
1498 #if(CXSC_INDEX_CHECK)
1499  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1500 #else
1501  throw()
1502 #endif
1503  { return _vvssectassign(rv,sl); }
1505 #if(CXSC_INDEX_CHECK)
1506  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1507 #else
1508  throw()
1509 #endif
1510  { return _vsvsectassign(*this,rv); }
1512 #if(CXSC_INDEX_CHECK)
1513  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1514 #else
1515  throw()
1516 #endif
1517  { return _vsvssectassign(*this,sl2); }
1518 
1519 //-------------------------------- cinterval / complex --------------------------------
1520 
1521  INLINE civector &civector::operator =(const cvector &rv) throw() { return _vvassign<civector,cvector,cinterval>(*this,rv); }
1522  INLINE civector &civector::operator =(const complex &r) throw() { return _vsassign<civector,complex>(*this,r); }
1523  INLINE civector & civector::operator =(const cvector_slice &sl) throw() { return _vvsassign<civector,cvector_slice,cinterval>(*this,sl); }
1525 #if(CXSC_INDEX_CHECK)
1526  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1527 #else
1528  throw()
1529 #endif
1530  { return _vsvassign(*this,rv); }
1531  INLINE civector_slice &civector_slice::operator =(const complex &r) throw() { return _vssassign<civector_slice,complex>(*this,r); }
1533 #if(CXSC_INDEX_CHECK)
1534  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1535 #else
1536  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1544 #else
1545  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1551 #else
1552  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1558 #else
1559  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1565 #else
1566  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1573 #else
1574  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1580 #else
1581  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1587 #else
1588  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1594 #else
1595  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1602 #else
1603  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1609 #else
1610  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1616 #else
1617  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1623 #else
1624  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1631 #else
1632  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1638 #else
1639  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1645 #else
1646  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1652 #else
1653  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1660 #else
1661  throw()
1662 #endif
1663  { return _vvplusassign(rv1,rv2); }
1664  INLINE civector &operator +=(civector &rv, const cvector_slice &sl)
1665 #if(CXSC_INDEX_CHECK)
1666  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1667 #else
1668  throw()
1669 #endif
1670  { return _vvsplusassign(rv,sl); }
1672 #if(CXSC_INDEX_CHECK)
1673  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1674 #else
1675  throw()
1676 #endif
1677  { return _vsvplusassign(*this,rv); }
1679 #if(CXSC_INDEX_CHECK)
1680  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1681 #else
1682  throw()
1683 #endif
1684  { return _vsvsplusassign(*this,sl2); }
1685 
1686  INLINE civector operator -(const cvector &rv1, const civector &rv2)
1687 #if(CXSC_INDEX_CHECK)
1688  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1689 #else
1690  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1696 #else
1697  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1703 #else
1704  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1710 #else
1711  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1718 #else
1719  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1725 #else
1726  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1732 #else
1733  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1739 #else
1740  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1747 #else
1748  throw()
1749 #endif
1750  { return _vvminusassign(rv1,rv2); }
1751  INLINE civector &operator -=(civector &rv, const cvector_slice &sl)
1752 #if(CXSC_INDEX_CHECK)
1753  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1754 #else
1755  throw()
1756 #endif
1757  { return _vvsminusassign(rv,sl); }
1759 #if(CXSC_INDEX_CHECK)
1760  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1761 #else
1762  throw()
1763 #endif
1764  { return _vsvminusassign(*this,rv); }
1766 #if(CXSC_INDEX_CHECK)
1767  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1768 #else
1769  throw()
1770 #endif
1771  { return _vsvsminusassign(*this,sl2); }
1772 
1773  INLINE civector operator |(const cvector &rv1, const civector &rv2)
1774 #if(CXSC_INDEX_CHECK)
1775  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1776 #else
1777  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1783 #else
1784  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1790 #else
1791  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1797 #else
1798  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1805 #else
1806  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1812 #else
1813  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1819 #else
1820  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1826 #else
1827  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1834 #else
1835  throw()
1836 #endif
1837  { return _vvconvassign(rv1,rv2); }
1838  INLINE civector &operator |=(civector &rv, const cvector_slice &sl)
1839 #if(CXSC_INDEX_CHECK)
1840  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1841 #else
1842  throw()
1843 #endif
1844  { return _vvsconvassign(rv,sl); }
1846 #if(CXSC_INDEX_CHECK)
1847  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1848 #else
1849  throw()
1850 #endif
1851  { return _vsvconvassign(*this,rv); }
1853 #if(CXSC_INDEX_CHECK)
1854  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1855 #else
1856  throw()
1857 #endif
1858  { return _vsvsconvassign(*this,sl2); }
1859 
1860  INLINE civector operator &(const cvector &rv1, const civector &rv2)
1861 #if(CXSC_INDEX_CHECK)
1862  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1863 #else
1864  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1870 #else
1871  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1877 #else
1878  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1884 #else
1885  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1892 #else
1893  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1899 #else
1900  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1906 #else
1907  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1913 #else
1914  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1921 #else
1922  throw()
1923 #endif
1924  { return _vvsectassign(rv1,rv2); }
1925  INLINE civector &operator &=(civector &rv, const cvector_slice &sl)
1926 #if(CXSC_INDEX_CHECK)
1927  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1928 #else
1929  throw()
1930 #endif
1931  { return _vvssectassign(rv,sl); }
1933 #if(CXSC_INDEX_CHECK)
1934  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1935 #else
1936  throw()
1937 #endif
1938  { return _vsvsectassign(*this,rv); }
1940 #if(CXSC_INDEX_CHECK)
1941  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1942 #else
1943  throw()
1944 #endif
1945  { return _vsvssectassign(*this,sl2); }
1946 
1947 //-------------------------------- cinterval / interval --------------------------------
1948 
1949  INLINE civector &civector::operator =(const ivector &rv) throw() { return _vvassign<civector,ivector,cinterval>(*this,rv); }
1950  INLINE civector &civector::operator =(const interval &r) throw() { return _vsassign<civector,interval>(*this,r); }
1951  INLINE civector & civector::operator =(const ivector_slice &sl) throw() { return _vvsassign<civector,ivector_slice,cinterval>(*this,sl); }
1953 #if(CXSC_INDEX_CHECK)
1954  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1955 #else
1956  throw()
1957 #endif
1958  { return _vsvassign(*this,rv); }
1959  INLINE civector_slice &civector_slice::operator =(const interval &r) throw() { return _vssassign<civector_slice,interval>(*this,r); }
1961 #if(CXSC_INDEX_CHECK)
1962  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1963 #else
1964  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1972 #else
1973  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1979 #else
1980  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1986 #else
1987  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
1993 #else
1994  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2001 #else
2002  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2008 #else
2009  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2015 #else
2016  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2022 #else
2023  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2030 #else
2031  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2037 #else
2038  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2044 #else
2045  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2051 #else
2052  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2059 #else
2060  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2066 #else
2067  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2073 #else
2074  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2080 #else
2081  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2088 #else
2089  throw()
2090 #endif
2091  { return _vvplusassign(rv1,rv2); }
2092  INLINE civector &operator +=(civector &rv, const ivector_slice &sl)
2093 #if(CXSC_INDEX_CHECK)
2094  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2095 #else
2096  throw()
2097 #endif
2098  { return _vvsplusassign(rv,sl); }
2100 #if(CXSC_INDEX_CHECK)
2101  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2102 #else
2103  throw()
2104 #endif
2105  { return _vsvplusassign(*this,rv); }
2107 #if(CXSC_INDEX_CHECK)
2108  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2109 #else
2110  throw()
2111 #endif
2112  { return _vsvsplusassign(*this,sl2); }
2113 
2114  INLINE civector operator -(const ivector &rv1, const civector &rv2)
2115 #if(CXSC_INDEX_CHECK)
2116  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2117 #else
2118  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2124 #else
2125  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2131 #else
2132  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2138 #else
2139  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2146 #else
2147  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2153 #else
2154  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2160 #else
2161  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2167 #else
2168  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2175 #else
2176  throw()
2177 #endif
2178  { return _vvminusassign(rv1,rv2); }
2179  INLINE civector &operator -=(civector &rv, const ivector_slice &sl)
2180 #if(CXSC_INDEX_CHECK)
2181  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2182 #else
2183  throw()
2184 #endif
2185  { return _vvsminusassign(rv,sl); }
2187 #if(CXSC_INDEX_CHECK)
2188  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2189 #else
2190  throw()
2191 #endif
2192  { return _vsvminusassign(*this,rv); }
2194 #if(CXSC_INDEX_CHECK)
2195  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2196 #else
2197  throw()
2198 #endif
2199  { return _vsvsminusassign(*this,sl2); }
2200 
2201  INLINE civector operator |(const ivector &rv1, const civector &rv2)
2202 #if(CXSC_INDEX_CHECK)
2203  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2204 #else
2205  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2211 #else
2212  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2218 #else
2219  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2225 #else
2226  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2233 #else
2234  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2240 #else
2241  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2247 #else
2248  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2254 #else
2255  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2262 #else
2263  throw()
2264 #endif
2265  { return _vvconvassign(rv1,rv2); }
2266  INLINE civector &operator |=(civector &rv, const ivector_slice &sl)
2267 #if(CXSC_INDEX_CHECK)
2268  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2269 #else
2270  throw()
2271 #endif
2272  { return _vvsconvassign(rv,sl); }
2274 #if(CXSC_INDEX_CHECK)
2275  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2276 #else
2277  throw()
2278 #endif
2279  { return _vsvconvassign(*this,rv); }
2281 #if(CXSC_INDEX_CHECK)
2282  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2283 #else
2284  throw()
2285 #endif
2286  { return _vsvsconvassign(*this,sl2); }
2287 
2288  INLINE civector operator &(const ivector &rv1, const civector &rv2)
2289 #if(CXSC_INDEX_CHECK)
2290  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2291 #else
2292  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2298 #else
2299  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2305 #else
2306  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2312 #else
2313  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2320 #else
2321  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2327 #else
2328  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2334 #else
2335  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2341 #else
2342  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2349 #else
2350  throw()
2351 #endif
2352  { return _vvsectassign(rv1,rv2); }
2353  INLINE civector &operator &=(civector &rv, const ivector_slice &sl)
2354 #if(CXSC_INDEX_CHECK)
2355  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2356 #else
2357  throw()
2358 #endif
2359  { return _vvssectassign(rv,sl); }
2361 #if(CXSC_INDEX_CHECK)
2362  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2363 #else
2364  throw()
2365 #endif
2366  { return _vsvsectassign(*this,rv); }
2368 #if(CXSC_INDEX_CHECK)
2369  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2370 #else
2371  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2379 #else
2380  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2386 #else
2387  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2393 #else
2394  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2400 #else
2401  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2407 #else
2408  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2414 #else
2415  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2421 #else
2422  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2428 #else
2429  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2437 #else
2438  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2444 #else
2445  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2451 #else
2452  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2458 #else
2459  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2468 #else
2469  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2475 #else
2476  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2482 #else
2483  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2489 #else
2490  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2497 #else
2498  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2504 #else
2505  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2511 #else
2512  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2518 #else
2519  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2526 #else
2527  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2533 #else
2534  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2540 #else
2541  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2547 #else
2548  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2555 #else
2556  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2562 #else
2563  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2569 #else
2570  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2576 #else
2577  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2584 #else
2585  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2591 #else
2592  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2598 #else
2599  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2605 #else
2606  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2613 #else
2614  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2620 #else
2621  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2627 #else
2628  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2634 #else
2635  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2642 #else
2643  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2649 #else
2650  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2656 #else
2657  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2663 #else
2664  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2671 #else
2672  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2678 #else
2679  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2685 #else
2686  throw()
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  throw(ERROR__OP_WITH_WRONG_DIM<civector>)
2692 #else
2693  throw()
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 
cxsc::civector_slice::operator[]
cinterval & operator[](const int &i) const
Operator for accessing the single elements of the vector (read-only)
Definition: civector.inl:166
cxsc::civector_slice::operator-=
civector_slice & operator-=(const civector &rv)
Implementation of subtraction and allocation operation.
Definition: civector.inl:937
cxsc::civector_slice
The Data Type civector_slice.
Definition: civector.hpp:1014
cxsc::civector::operator()
civector & operator()()
Operator for accessing the whole vector.
Definition: civector.hpp:987
cxsc::civector_slice::operator&=
civector_slice & operator&=(const civector &rv)
Allocates the intersection of the arguments to the first argument.
Definition: civector.inl:1051
cxsc::cinterval::cinterval
cinterval(void)
Constructor of class cinterval.
Definition: cinterval.hpp:64
cxsc::civector::operator=
civector & operator=(const civector &rv)
Implementation of standard assigning operator.
Definition: civector.inl:339
cxsc::mid
cvector mid(const cimatrix_subv &mv)
Returns the middle of the matrix.
Definition: cimatrix.inl:739
cxsc::civector_slice::operator+=
civector_slice & operator+=(const civector &rv)
Implementation of addition and allocation operation.
Definition: civector.inl:878
cxsc::operator*=
cimatrix & operator*=(cimatrix &m, const cinterval &c)
Implementation of multiplication and allocation operation.
Definition: cimatrix.inl:1605
cxsc::interval
The Scalar Type interval.
Definition: interval.hpp:54
cxsc::civector_slice::operator()
civector_slice & operator()()
Operator for accessing the whole vector.
Definition: civector.hpp:1707
cxsc::intvector
The Data Type intvector.
Definition: intvector.hpp:51
cxsc::cvector
The Data Type cvector.
Definition: cvector.hpp:57
cxsc::diam
cvector diam(const cimatrix_subv &mv)
Returns the diameter of the matrix.
Definition: cimatrix.inl:738
cxsc::rvector
The Data Type rvector.
Definition: rvector.hpp:57
cxsc::in
int in(const cinterval &x, const cinterval &y)
Checks if first argument is part of second argument.
Definition: cinterval.cpp:654
cxsc::ivector_slice
The Data Type ivector_slice.
Definition: ivector.hpp:962
cxsc::civector_slice::operator|=
civector_slice & operator|=(const civector &rv)
Allocates the convex hull of the arguments to the first argument.
Definition: civector.inl:994
cxsc::rvector_slice
The Data Type rvector_slice.
Definition: rvector.hpp:1063
cxsc::SetUncheckedInf
cimatrix_subv & SetUncheckedInf(cimatrix_subv &iv, const complex &r)
Returns the matrix with the new unchecked given infimum value.
Definition: cimatrix.inl:890
cxsc::abs
ivector abs(const cimatrix_subv &mv)
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737
cxsc::civector_slice::operator=
civector_slice & operator=(const scivector_slice &sl)
Implementation of standard assigning operator.
Definition: scivector.hpp:4688
cxsc::operator*
civector operator*(const cimatrix_subv &rv, const cinterval &s)
Implementation of multiplication operation.
Definition: cimatrix.inl:731
cxsc::operator/=
cimatrix & operator/=(cimatrix &m, const cinterval &c)
Implementation of division and allocation operation.
Definition: cimatrix.inl:1623
cxsc::ivector
The Data Type ivector.
Definition: ivector.hpp:54
cxsc::civector::Lb
friend int Lb(const civector &rv)
Returns the lower bound of the vector.
Definition: civector.hpp:961
cxsc
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
cxsc::Lb
int Lb(const cimatrix &rm, const int &i)
Returns the lower bound index.
Definition: cimatrix.inl:1156
cxsc::operator+=
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc)
Implementation of standard algebraic addition and allocation operation.
Definition: cdot.inl:251
cxsc::civector::operator[]
cinterval & operator[](const int &i) const
Operator for accessing the single elements of the vector (read-only)
Definition: civector.inl:140
cxsc::civector::civector
civector()
Constructor of class civector.
Definition: civector.inl:31
cxsc::operator/
civector operator/(const cimatrix_subv &rv, const cinterval &s)
Implementation of division operation.
Definition: cimatrix.inl:730
cxsc::cimatrix
The Data Type cimatrix.
Definition: cimatrix.hpp:907
cxsc::cinterval
The Scalar Type cinterval.
Definition: cinterval.hpp:54
cxsc::complex
The Scalar Type complex.
Definition: complex.hpp:49
cxsc::cvector_slice
The Data Type cvector_slice.
Definition: cvector.hpp:844
cxsc::civector
The Data Type civector.
Definition: civector.hpp:56
cxsc::civector_slice::operator/=
civector_slice & operator/=(const cinterval &r)
Implementation of division and allocation operation.
Definition: civector.inl:725
cxsc::VecLen
int VecLen(const scimatrix_subv &S)
Returns the length of the subvector.
Definition: scimatrix.hpp:9966
cxsc::civector_slice::operator*=
civector_slice & operator*=(const cinterval &r)
Implementation of multiplication and allocation operation.
Definition: civector.inl:720
cxsc::civector::VecLen
friend int VecLen(const civector &rv)
Returns the dimension of the vector.
Definition: civector.hpp:965
cxsc::Resize
void Resize(cimatrix &A)
Resizes the matrix.
Definition: cimatrix.inl:1211
cxsc::real
The Scalar Type real.
Definition: real.hpp:113