C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
civector.hpp
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.hpp,v 1.39 2014/01/30 17:23:44 cxsc Exp $ */
25 
26 #ifndef _CXSC_CIVECTOR_HPP_INCLUDED
27 #define _CXSC_CIVECTOR_HPP_INCLUDED
28 
29 #include "xscclass.hpp"
30 #include "except.hpp"
31 #include "cidot.hpp"
32 #include "cinterval.hpp" // used for declaration of Inf, Sup,...
33 //#include "cxscmatr.hpp"
34 #include "rvector.hpp"
35 #include "ivector.hpp"
36 #include "cvector.hpp"
37 #include "vector.hpp"
38 
39 
40 #include <iostream>
41 
42 //#include "matrix.hpp" // hat hier eigentlich nichts zu suchen, sonst aber Internal Compiler Error #9
43 
44 namespace cxsc {
45 
46 class civector_slice;
47 class scivector;
48 class scivector_slice;
49 
51 
56 class civector
57 {
58  friend class civector_slice;
59  friend class cimatrix;
60  friend class cimatrix_subv;
61  private:
62  cinterval *dat;
63  int l,u,size;
64 
65  public:
66 //#if(CXSC_INDEX_CHECK)
67 #ifdef _CXSC_FRIEND_TPL
68  //------------ Templates --------------------------------------------------
69  // cinterval
70 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m)
71 #if(CXSC_INDEX_CHECK)
72  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>);
73 #else
74  throw();
75 #endif
76 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
77 #if(CXSC_INDEX_CHECK)
78  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
79 #else
80  throw();
81 #endif
82  template <class V> friend void _vresize(V &rv) throw();
83  template <class V,class S> friend void _vresize(V &rv, const int &len)
84 #if(CXSC_INDEX_CHECK)
85  throw(ERROR__WRONG_BOUNDARIES<V>);
86 #else
87  throw();
88 #endif
89  template <class V,class S> friend void _vresize(V &rv, const int &lb, const int &ub)
90 #if(CXSC_INDEX_CHECK)
91  throw(ERROR__WRONG_BOUNDARIES<V>);
92 #else
93  throw();
94 #endif
95  template <class V1,class V2,class S> friend V1 &_vvassign(V1 &rv1,const V2 &rv2) throw();
96  template <class V,class S> friend V & _vsassign(V &rv,const S &r) throw();
97  template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) throw();
98  template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv)
99 #if(CXSC_INDEX_CHECK)
100  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
101 #else
102  throw();
103 #endif
104 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m)
105 #if(CXSC_INDEX_CHECK)
106  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
107 #else
108  throw();
109 #endif
110 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) throw();
111  template <class V1,class V2> friend V1 &_vvsetinf(V1 &rv1, const V2 &rv2)
112 #if(CXSC_INDEX_CHECK)
113  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
114 #else
115  throw();
116 #endif
117  template <class V1,class V2> friend V1 &_vvsetsup(V1 &rv1, const V2 &rv2)
118 #if(CXSC_INDEX_CHECK)
119  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
120 #else
121  throw();
122 #endif
123  template <class V,class VS> friend V &_vvssetinf(V &rv, const VS &sl)
124 #if(CXSC_INDEX_CHECK)
125  throw(ERROR__OP_WITH_WRONG_DIM<V>);
126 #else
127  throw();
128 #endif
129  template <class V,class VS> friend V &_vvssetsup(V &rv, const VS &sl)
130 #if(CXSC_INDEX_CHECK)
131  throw(ERROR__OP_WITH_WRONG_DIM<V>);
132 #else
133  throw();
134 #endif
135 template <class V,class MV> friend V &_vmvsetinf(V &rv,const MV &v)
136 #if(CXSC_INDEX_CHECK)
137  throw(ERROR__OP_WITH_WRONG_DIM<V>);
138 #else
139  throw();
140 #endif
141 template <class V,class MV> friend V &_vmvsetsup(V &rv,const MV &v)
142 #if(CXSC_INDEX_CHECK)
143  throw(ERROR__OP_WITH_WRONG_DIM<V>);
144 #else
145  throw();
146 #endif
147  template <class V1,class V2> friend V1 &_vvusetinf(V1 &rv1, const V2 &rv2)
148 #if(CXSC_INDEX_CHECK)
149  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
150 #else
151  throw();
152 #endif
153  template <class V1,class V2> friend V1 &_vvusetsup(V1 &rv1, const V2 &rv2)
154 #if(CXSC_INDEX_CHECK)
155  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
156 #else
157  throw();
158 #endif
159  template <class V,class VS> friend V &_vvsusetinf(V &rv, const VS &sl)
160 #if(CXSC_INDEX_CHECK)
161  throw(ERROR__OP_WITH_WRONG_DIM<V>);
162 #else
163  throw();
164 #endif
165  template <class V,class VS> friend V &_vvsusetsup(V &rv, const VS &sl)
166 #if(CXSC_INDEX_CHECK)
167  throw(ERROR__OP_WITH_WRONG_DIM<V>);
168 #else
169  throw();
170 #endif
171 template <class V,class MV> friend V &_vmvusetinf(V &rv,const MV &v)
172 #if(CXSC_INDEX_CHECK)
173  throw(ERROR__OP_WITH_WRONG_DIM<V>);
174 #else
175  throw();
176 #endif
177 template <class V,class MV> friend V &_vmvusetsup(V &rv,const MV &v)
178 #if(CXSC_INDEX_CHECK)
179  throw(ERROR__OP_WITH_WRONG_DIM<V>);
180 #else
181  throw();
182 #endif
183  template <class V,class S> friend V &_vssetinf(V &v, const S &s) throw();
184  template <class V,class S> friend V &_vssetsup(V &v, const S &s) throw();
185  template <class V,class S> friend V &_vsusetinf(V &v, const S &s) throw();
186  template <class V,class S> friend V &_vsusetsup(V &v, const S &s) throw();
187  template <class V,class S> friend V &_vssetim(V &v, const S &s) throw();
188  template <class V,class S> friend V &_vssetre(V &v, const S &s) throw();
189  template <class V> friend V _vconj(const V &rv) throw();
190  template <class VS,class E> friend E _vsconj(const VS &sl) throw();
191  template <class V,class E> friend E _vabs(const V &rv) throw();
192  template <class VS,class E> friend E _vsabs(const VS &sl) throw();
193 template <class MV,class V> friend V _mvabs(const MV &mv) throw();
194  template <class V,class E> friend E _vdiam(const V &rv) throw();
195  template <class V,class E> friend E _vmid(const V &rv) throw();
196  template <class V,class E> friend E _vinf(const V &rv) throw();
197  template <class V,class E> friend E _vsup(const V &rv) throw();
198  template <class V,class E> friend E _vim(const V &rv) throw();
199  template <class V,class E> friend E _vre(const V &rv) throw();
200  friend INLINE ivector Re(const civector &v) throw();
201  friend INLINE ivector Im(const civector &v) throw();
202  friend INLINE cvector Inf(const civector &v) throw();
203  friend INLINE cvector Sup(const civector &v) throw();
204  friend INLINE rvector SupRe(const civector &v) throw();
205  friend INLINE rvector SupIm(const civector &v) throw();
206  friend INLINE rvector InfRe(const civector &v) throw();
207  friend INLINE rvector InfIm(const civector &v) throw();
208  template <class V1,class V2> friend V1 &_vvsetim(V1 &rv1, const V2 &rv2)
209 #if(CXSC_INDEX_CHECK)
210  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
211 #else
212  throw();
213 #endif
214  template <class V1,class V2> friend V1 &_vvsetre(V1 &rv1, const V2 &rv2)
215 #if(CXSC_INDEX_CHECK)
216  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
217 #else
218  throw();
219 #endif
220  template <class V,class VS> friend V &_vvssetim(V &rv, const VS &sl)
221 #if(CXSC_INDEX_CHECK)
222  throw(ERROR__OP_WITH_WRONG_DIM<V>);
223 #else
224  throw();
225 #endif
226  template <class V,class VS> friend V &_vvssetre(V &rv, const VS &sl)
227 #if(CXSC_INDEX_CHECK)
228  throw(ERROR__OP_WITH_WRONG_DIM<V>);
229 #else
230  throw();
231 #endif
232 template <class V,class MV> friend V &_vmvsetim(V &rv,const MV &v)
233 #if(CXSC_INDEX_CHECK)
234  throw(ERROR__OP_WITH_WRONG_DIM<V>);
235 #else
236  throw();
237 #endif
238 template <class V,class MV> friend V &_vmvsetre(V &rv,const MV &v)
239 #if(CXSC_INDEX_CHECK)
240  throw(ERROR__OP_WITH_WRONG_DIM<V>);
241 #else
242  throw();
243 #endif
244 
245 //-------- vector-vector -----------------------
246  template <class DP,class V1,class V2> friend void _vvaccu(DP &dp, const V1 & rv1, const V2 &rv2)
247 #if(CXSC_INDEX_CHECK)
248  throw(OP_WITH_WRONG_DIM);
249 #else
250  throw();
251 #endif
252  template <class DP,class VS,class V> friend void _vsvaccu(DP &dp, const VS & sl, const V &rv)
253 #if(CXSC_INDEX_CHECK)
254  throw(OP_WITH_WRONG_DIM);
255 #else
256  throw();
257 #endif
258 
259  template <class V1,class V2,class E> friend E _vvcimult(const V1 & rv1, const V2 &rv2)
260 #if(CXSC_INDEX_CHECK)
261  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
262 #else
263  throw();
264 #endif
265  template <class VS,class V,class E> friend E _vsvcimult(const VS & sl, const V &rv)
266 #if(CXSC_INDEX_CHECK)
267  throw(ERROR__OP_WITH_WRONG_DIM<V>);
268 #else
269  throw();
270 #endif
271 
272  template <class V,class S> friend V &_vsmultassign(V &rv,const S &r) throw();
273  template <class V1,class V2,class E> friend E _vvplus(const V1 &rv1, const V2 &rv2)
274 #if(CXSC_INDEX_CHECK)
275  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
276 #else
277  throw();
278 #endif
279  template <class V,class VS,class E> friend E _vvsplus(const V &rv,const VS &sl)
280 #if(CXSC_INDEX_CHECK)
281  throw(ERROR__OP_WITH_WRONG_DIM<V>);
282 #else
283  throw();
284 #endif
285  template <class VS1,class VS2,class E> friend E _vsvsplus(const VS1 &s1,const VS2 &s2)
286 #if(CXSC_INDEX_CHECK)
287  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
288 #else
289  throw();
290 #endif
291  template <class VS1,class VS2,class E> friend E _vsvsminus(const VS1 &s1,const VS2 &s2)
292 #if(CXSC_INDEX_CHECK)
293  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
294 #else
295  throw();
296 #endif
297  template <class V1,class V2> friend V1 &_vvplusassign(V1 &rv1, const V2 &rv2)
298 #if(CXSC_INDEX_CHECK)
299  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
300 #else
301  throw();
302 #endif
303  template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl)
304 #if(CXSC_INDEX_CHECK)
305  throw(ERROR__OP_WITH_WRONG_DIM<V>);
306 #else
307  throw();
308 #endif
309  template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv)
310 #if(CXSC_INDEX_CHECK)
311  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
312 #else
313  throw();
314 #endif
315  template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
316 #if(CXSC_INDEX_CHECK)
317  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
318 #else
319  throw();
320 #endif
321  template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
322 #if(CXSC_INDEX_CHECK)
323  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
324 #else
325  throw();
326 #endif
327  template <class V1,class V2> friend V1 &_vvminusassign(V1 &rv1, const V2 &rv2)
328 #if(CXSC_INDEX_CHECK)
329  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
330 #else
331  throw();
332 #endif
333  template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl)
334 #if(CXSC_INDEX_CHECK)
335  throw(ERROR__OP_WITH_WRONG_DIM<V>);
336 #else
337  throw();
338 #endif
339  template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv)
340 #if(CXSC_INDEX_CHECK)
341  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
342 #else
343  throw();
344 #endif
345  template <class V> friend V _vminus(const V &rv) throw();
346  template <class VS,class V> friend V _vsminus(const VS &sl) throw();
347  template <class V1,class V2,class E> friend E _vvminus(const V1 &rv1, const V2 &rv2)
348 #if(CXSC_INDEX_CHECK)
349  throw(ERROR__OP_WITH_WRONG_DIM<E>);
350 #else
351  throw();
352 #endif
353  template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl)
354 #if(CXSC_INDEX_CHECK)
355  throw(ERROR__OP_WITH_WRONG_DIM<E>);
356 #else
357  throw();
358 #endif
359  template <class VS,class V,class E> friend E _vsvminus(const VS &sl,const V &rv)
360 #if(CXSC_INDEX_CHECK)
361  throw(ERROR__OP_WITH_WRONG_DIM<E>);
362 #else
363  throw();
364 #endif
365  template <class V1,class V2,class E> friend E _vvconv(const V1 &rv1, const V2 &rv2)
366 #if(CXSC_INDEX_CHECK)
367  throw(ERROR__OP_WITH_WRONG_DIM<E>);
368 #else
369  throw();
370 #endif
371  template <class V,class VS,class E> friend E _vvsconv(const V &rv,const VS &sl)
372 #if(CXSC_INDEX_CHECK)
373  throw(ERROR__OP_WITH_WRONG_DIM<E>);
374 #else
375  throw();
376 #endif
377  template <class VS1,class VS2,class E> friend E _vsvsconv(const VS1 &s1,const VS2 &s2)
378 #if(CXSC_INDEX_CHECK)
379  throw(ERROR__OP_WITH_WRONG_DIM<E>);
380 #else
381  throw();
382 #endif
383  template <class V1,class V2> friend V1 &_vvconvassign(V1 &rv1, const V2 &rv2)
384 #if(CXSC_INDEX_CHECK)
385  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
386 #else
387  throw();
388 #endif
389  template <class V,class VS> friend V &_vvsconvassign(V &rv, const VS &sl)
390 #if(CXSC_INDEX_CHECK)
391  throw(ERROR__OP_WITH_WRONG_DIM<V>);
392 #else
393  throw();
394 #endif
395  template <class VS,class V> friend VS &_vsvconvassign(VS &sl, const V &rv)
396 #if(CXSC_INDEX_CHECK)
397  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
398 #else
399  throw();
400 #endif
401  template <class VS1,class VS2> friend VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2)
402 #if(CXSC_INDEX_CHECK)
403  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
404 #else
405  throw();
406 #endif
407  template <class V1,class V2,class E> friend E _vvsect(const V1 &rv1, const V2 &rv2)
408 #if(CXSC_INDEX_CHECK)
409  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
410 #else
411  throw();
412 #endif
413  template <class V,class VS,class E> friend E _vvssect(const V &rv,const VS &sl)
414 #if(CXSC_INDEX_CHECK)
415  throw(ERROR__OP_WITH_WRONG_DIM<E>);
416 #else
417  throw();
418 #endif
419  template <class VS1,class VS2,class E> friend E _vsvssect(const VS1 &s1,const VS2 &s2)
420 #if(CXSC_INDEX_CHECK)
421  throw(ERROR__OP_WITH_WRONG_DIM<E>);
422 #else
423  throw();
424 #endif
425  template <class V1,class V2> friend V1 &_vvsectassign(V1 &rv1, const V2 &rv2)
426 #if(CXSC_INDEX_CHECK)
427  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
428 #else
429  throw();
430 #endif
431  template <class V,class VS> friend V &_vvssectassign(V &rv, const VS &sl)
432 #if(CXSC_INDEX_CHECK)
433  throw(ERROR__OP_WITH_WRONG_DIM<V>);
434 #else
435  throw();
436 #endif
437  template <class VS,class V> friend VS &_vsvsectassign(VS &sl, const V &rv)
438 #if(CXSC_INDEX_CHECK)
439  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
440 #else
441  throw();
442 #endif
443  template <class VS1,class VS2> friend VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2)
444 #if(CXSC_INDEX_CHECK)
445  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
446 #else
447  throw();
448 #endif
449  template <class MV1,class MV2,class E> friend E _mvmvsect(const MV1 &rv1, const MV2 &rv2)
450 #if(CXSC_INDEX_CHECK)
451  throw(ERROR__OP_WITH_WRONG_DIM<E>);
452 #else
453  throw();
454 #endif
455  template <class MV,class V,class E> friend E _mvvsect(const MV &rv1, const V &rv2)
456 #if(CXSC_INDEX_CHECK)
457  throw(ERROR__OP_WITH_WRONG_DIM<E>);
458 #else
459  throw();
460 #endif
461 template <class MV,class V> friend MV &_mvvsectassign(MV &v,const V &rv)
462 #if(CXSC_INDEX_CHECK)
463  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
464 #else
465  throw();
466 #endif
467 template <class V,class MV> friend V &_vmvsectassign(V &rv,const MV &v)
468 #if(CXSC_INDEX_CHECK)
469  throw(ERROR__OP_WITH_WRONG_DIM<V>);
470 #else
471  throw();
472 #endif
473  template <class MV1,class MV2,class E> friend E _mvmvconv(const MV1 &rv1, const MV2 &rv2)
474 #if(CXSC_INDEX_CHECK)
475  throw(ERROR__OP_WITH_WRONG_DIM<E>);
476 #else
477  throw();
478 #endif
479  template <class MV,class V,class E> friend E _mvvconv(const MV &rv1, const V &rv2)
480 #if(CXSC_INDEX_CHECK)
481  throw(ERROR__OP_WITH_WRONG_DIM<E>);
482 #else
483  throw();
484 #endif
485 template <class MV,class V> friend MV &_mvvconvassign(MV &v,const V &rv)
486 #if(CXSC_INDEX_CHECK)
487  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
488 #else
489  throw();
490 #endif
491 template <class V,class MV> friend V &_vmvconvassign(V &rv,const MV &v)
492 #if(CXSC_INDEX_CHECK)
493  throw(ERROR__OP_WITH_WRONG_DIM<V>);
494 #else
495  throw();
496 #endif
497  template <class V,class MV,class S> friend S _vmvcimult(const V &rv1, const MV &rv2)
498 #if(CXSC_INDEX_CHECK)
499  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
500 #else
501  throw();
502 #endif
503  //--------- vector-scalar -----------------
504  template <class V,class S,class E> friend E _vsdiv(const V &rv, const S &s) throw();
505  template <class V,class S> friend V &_vsdivassign(V &rv,const S &r) throw();
506  template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) throw();
507  template <class V,class S,class E> friend E _vsmult(const V &rv, const S &s) throw();
508  template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) throw();
509  template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) throw();
510  template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
511 #if(CXSC_INDEX_CHECK)
512  throw(ERROR__OP_WITH_WRONG_DIM<E>);
513 #else
514  throw();
515 #endif
516  template <class MV,class V,class E> friend E _mvvplus(const MV &rv1, const V &rv2)
517 #if(CXSC_INDEX_CHECK)
518  throw(ERROR__OP_WITH_WRONG_DIM<E>);
519 #else
520  throw();
521 #endif
522  template <class MV,class V,class E> friend E _mvvminus(const MV &rv1, const V &rv2)
523 #if(CXSC_INDEX_CHECK)
524  throw(ERROR__OP_WITH_WRONG_DIM<E>);
525 #else
526  throw();
527 #endif
528  template <class V,class MV,class E> friend E _vmvminus(const V &rv1, const MV &rv2)
529 #if(CXSC_INDEX_CHECK)
530  throw(ERROR__OP_WITH_WRONG_DIM<E>);
531 #else
532  throw();
533 #endif
534  template <class MV1,class MV2,class E> friend E _mvmvminus(const MV1 &rv1, const MV2 &rv2)
535 #if(CXSC_INDEX_CHECK)
536  throw(ERROR__OP_WITH_WRONG_DIM<E>);
537 #else
538  throw();
539 #endif
540 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
541 #if(CXSC_INDEX_CHECK)
542  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
543 #else
544  throw();
545 #endif
546 template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv)
547 #if(CXSC_INDEX_CHECK)
548  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
549 #else
550  throw();
551 #endif
552  template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) throw();
553 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
554 #if(CXSC_INDEX_CHECK)
555  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
556 #else
557  throw();
558 #endif
559 
560  template <class V1,class V2> friend bool _vveq(const V1 &rv1, const V2 &rv2) throw();
561  template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) throw();
562  template <class V1,class V2> friend bool _vvneq(const V1 &rv1, const V2 &rv2) throw();
563  template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) throw();
564  template <class V1,class V2> friend bool _vvless(const V1 &rv1, const V2 &rv2) throw();
565  template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) throw();
566  template <class V1,class V2> friend bool _vvleq(const V1 &rv1, const V2 &rv2) throw();
567  template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) throw();
568  template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) throw();
569  template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) throw();
570  template <class V> friend bool _vnot(const V &rv) throw();
571  template <class V> friend void *_vvoid(const V &rv) throw();
572  template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw();
573  template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw();
574  template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw();
575  template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw();
576  template <class VS> friend bool _vsnot(const VS &sl) throw();
577  template <class VS> friend void *_vsvoid(const VS &sl) throw();
578  template <class V> friend std::ostream &_vout(std::ostream &s, const V &rv) throw();
579  template <class V> friend std::istream &_vin(std::istream &s, V &rv) throw();
580 
581  //------------- vector-matrix ---------------
582 template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
583 #if(CXSC_INDEX_CHECK)
584  throw(OP_WITH_WRONG_DIM);
585 #else
586  throw();
587 #endif
588 
589 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) throw();
590  template <class M,class V,class E> friend E _mvcimult(const M &m,const V &v)
591 #if(CXSC_INDEX_CHECK)
592  throw(ERROR__OP_WITH_WRONG_DIM<M>);
593 #else
594  throw();
595 #endif
596  template <class V,class M,class E> friend E _vmcimult(const V &v,const M &m)
597 #if(CXSC_INDEX_CHECK)
598  throw(ERROR__OP_WITH_WRONG_DIM<M>);
599 #else
600  throw();
601 #endif
602  template <class V,class M,class S> friend V &_vmimultassign(V &v,const M &m)
603 #if(CXSC_INDEX_CHECK)
604  throw(ERROR__OP_WITH_WRONG_DIM<M>);
605 #else
606  throw();
607 #endif
608  template <class V,class M,class S> friend V &_vmcimultassign(V &v,const M &m)
609 #if(CXSC_INDEX_CHECK)
610  throw(ERROR__OP_WITH_WRONG_DIM<M>);
611 #else
612  throw();
613 #endif
614  template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v)
615 #if(CXSC_INDEX_CHECK)
616  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
617 #else
618  throw();
619 #endif
620  template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms)
621 #if(CXSC_INDEX_CHECK)
622  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
623 #else
624  throw();
625 #endif
626  template <class V,class MS,class S> friend V &_vmscimultassign(V &v,const MS &ms)
627 #if(CXSC_INDEX_CHECK)
628  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
629 #else
630  throw();
631 #endif
632 
633  // Real
634  template <class DP,class VS1,class VS2> friend void _vsvsaccu(DP &dp, const VS1 & sl1, const VS2 &sl2)
635 #if(CXSC_INDEX_CHECK)
636  throw(OP_WITH_WRONG_DIM);
637 #else
638  throw();
639 #endif
640 
641  //--Real -------- vector-scalar ------------
642  //--Real--------- Vector-vector---------
643  //-- Real -------- Vector-matrix ----------
644  // complex
645  //--complex -------- vector-scalar ------------
646  //--complex--------- Vector-vector---------
647  //-- complex -------- Vector-matrix ----------
648  // interval
649  //--interval -------- vector-scalar ------------
650  //--interval--------- Vector-vector---------
651  //-- interval -------- Vector-matrix ----------
652  // cvector x ivector ----------------
653  // vector - scalar -------
654  // vector - vector -------------
655  // vector - matrix ------------
656 
657 /* template<class T1,class T2,class T3> friend T3 _mvscimult(const T1 &m,const T2 &v)
658 #if(CXSC_INDEX_CHECK)
659  throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
660 #else
661  throw();
662 #endif
663 template<class T1,class T2,class T3> friend T3 _vsmcimult(const T1 &v,const T2 &m)
664 #if(CXSC_INDEX_CHECK)
665  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
666 #else
667  throw();
668 #endif */
669 
670  // real x complex --------------
671  // vector - vector --------------
672 
673 #endif
674 
675 
676  //------ Konstruktoren ----------------------------------------------------
678  INLINE civector () throw();
680  explicit INLINE civector(const int &i) throw();
681 #ifdef OLD_CXSC
682  explicit INLINE civector(const class index &i) throw(); // for backwards compatibility
684 #endif
685  explicit INLINE civector(const int &i1,const int &i2)
687 #if(CXSC_INDEX_CHECK)
688  throw(ERROR_CIVECTOR_WRONG_BOUNDARIES,ERROR_CIVECTOR_NO_MORE_MEMORY);
689 #else
690  throw();
691 #endif
692  INLINE civector(const cimatrix_subv &) throw();
695  explicit INLINE civector(const cinterval &) throw();
697 // explicit INLINE civector(const cimatrix &)
698  explicit civector(const cimatrix &)
699 #if(CXSC_INDEX_CHECK)
700  throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
701 #else
702  throw();
703 #endif
704  explicit INLINE civector(const cimatrix_slice &sl)
706 #if(CXSC_INDEX_CHECK)
707  throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
708 #else
709  throw();
710 #endif
711  INLINE civector(const civector_slice &rs) throw();
714  INLINE civector(const civector &v) throw();
716  INLINE civector(const scivector_slice &rs);
718  INLINE civector(const scivector &v);
719  // Real
721  explicit INLINE civector(const real &) throw();
723  explicit INLINE civector(const rvector_slice &rs) throw();
725  explicit INLINE civector(const rvector &v) throw();
727  explicit INLINE civector(const srvector_slice &rs);
729  explicit INLINE civector(const srvector &v);
731  explicit INLINE civector(const rmatrix &)
732 #if(CXSC_INDEX_CHECK)
733  throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
734 #else
735  throw();
736 #endif
737  explicit INLINE civector(const rmatrix_slice &sl)
739 #if(CXSC_INDEX_CHECK)
740  throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
741 #else
742  throw();
743 #endif
744  explicit INLINE civector(const rmatrix_subv &) throw();
746 
747  // complex
749  explicit INLINE civector(const complex &) throw();
751  explicit INLINE civector(const cvector_slice &rs) throw();
753  explicit INLINE civector(const cvector &v) throw();
755  explicit INLINE civector(const scvector_slice &rs);
757  explicit INLINE civector(const scvector &v);
759  explicit INLINE civector(const cmatrix &)
760 #if(CXSC_INDEX_CHECK)
761  throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
762 #else
763  throw();
764 #endif
765  explicit INLINE civector(const cmatrix_slice &sl)
767 #if(CXSC_INDEX_CHECK)
768  throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
769 #else
770  throw();
771 #endif
772  explicit INLINE civector(const cmatrix_subv &) throw();
774 
775  // interval
777  explicit INLINE civector(const interval &) throw();
779  explicit INLINE civector(const ivector_slice &rs) throw();
781  explicit INLINE civector(const ivector &v) throw();
783  explicit INLINE civector(const sivector_slice &rs);
785  explicit INLINE civector(const sivector &v);
787  explicit INLINE civector(const imatrix &)
788 #if(CXSC_INDEX_CHECK)
789  throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
790 #else
791  throw();
792 #endif
793  explicit INLINE civector(const imatrix_slice &sl)
795 #if(CXSC_INDEX_CHECK)
796  throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
797 #else
798  throw();
799 #endif
800  explicit INLINE civector(const imatrix_subv &) throw();
802 
803  // cinterval
805  INLINE civector &operator =(const civector &rv) throw();
807  INLINE civector &operator =(const civector_slice &sl) throw();
809  INLINE civector &operator =(const scivector &rv) ;
811  INLINE civector &operator =(const scivector_slice &sl) ;
813  INLINE civector &operator =(const cinterval &r) throw();
815  INLINE civector &operator =(const cimatrix &m)
816 #if(CXSC_INDEX_CHECK)
817  throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
818 #else
819  throw();
820 #endif
821  INLINE civector &operator =(const cimatrix_slice &)
823 #if(CXSC_INDEX_CHECK)
824  throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
825 #else
826  throw();
827 #endif
828  INLINE civector &operator =(const cimatrix_subv &) throw();
830  // Real
832  INLINE civector &operator =(const rvector &rv) throw();
834  INLINE civector &operator =(const rvector_slice &sl) throw();
836  INLINE civector &operator =(const srvector &rv);
838  INLINE civector &operator =(const srvector_slice &sl);
840  INLINE civector &operator =(const real &r) throw();
842  INLINE civector &operator =(const rmatrix &m)
843 #if(CXSC_INDEX_CHECK)
844  throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
845 #else
846  throw();
847 #endif
848  INLINE civector &operator =(const rmatrix_slice &)
850 #if(CXSC_INDEX_CHECK)
851  throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
852 #else
853  throw();
854 #endif
855  INLINE civector &operator =(const rmatrix_subv &) throw();
857 
858  // complex
860  INLINE civector &operator =(const cvector &rv) throw();
862  INLINE civector &operator =(const cvector_slice &sl) throw();
864  INLINE civector &operator =(const scvector &rv);
866  INLINE civector &operator =(const scvector_slice &sl);
868  INLINE civector &operator =(const complex &r) throw();
870  INLINE civector &operator =(const cmatrix &m)
871 #if(CXSC_INDEX_CHECK)
872  throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
873 #else
874  throw();
875 #endif
876  INLINE civector &operator =(const cmatrix_slice &)
878 #if(CXSC_INDEX_CHECK)
879  throw(ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
880 #else
881  throw();
882 #endif
883  INLINE civector &operator =(const cmatrix_subv &) throw();
885 
886  // interval
888  INLINE civector &operator =(const ivector &rv) throw();
890  INLINE civector &operator =(const ivector_slice &sl) throw();
892  INLINE civector &operator =(const sivector &rv) ;
894  INLINE civector &operator =(const sivector_slice &sl) ;
896  INLINE civector &operator =(const interval &r) throw();
898  INLINE civector &operator =(const imatrix &m)
899 #if(CXSC_INDEX_CHECK)
900  throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
901 #else
902  throw();
903 #endif
904  INLINE civector &operator =(const imatrix_slice &)
906 #if(CXSC_INDEX_CHECK)
907  throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
908 #else
909  throw();
910 #endif
911  INLINE civector &operator =(const imatrix_subv &) throw();
913 
914 
915  civector& operator+=(const srvector&);
916  civector& operator+=(const scvector&);
917  civector& operator+=(const sivector&);
918  civector& operator+=(const scivector&);
919  civector& operator-=(const srvector&);
920  civector& operator-=(const scvector&);
921  civector& operator-=(const sivector&);
922  civector& operator-=(const scivector&);
923  civector& operator|=(const srvector&);
924  civector& operator|=(const scvector&);
925  civector& operator|=(const sivector&);
926  civector& operator|=(const scivector&);
927  civector& operator&=(const sivector&);
928  civector& operator&=(const scivector&);
933  civector& operator-=(const srvector_slice&);
934  civector& operator-=(const scvector_slice&);
935  civector& operator-=(const sivector_slice&);
936  civector& operator-=(const scivector_slice&);
937  civector& operator|=(const srvector_slice&);
938  civector& operator|=(const scvector_slice&);
939  civector& operator|=(const sivector_slice&);
940  civector& operator|=(const scivector_slice&);
941  civector& operator&=(const sivector_slice&);
942  civector& operator&=(const scivector_slice&);
943 
945  INLINE civector operator()(const intvector& p);
947  INLINE civector operator()(const intmatrix& P);
948 
949  //--------- Destruktor ----------------------------------------------------
950  INLINE ~civector() { delete [] dat; }
951 
952  //------ Standardfunktionen -----------------------------------------------
953 
954  friend INLINE cinterval::cinterval(const civector &)
955 #if(CXSC_INDEX_CHECK)
956  throw(ERROR_CIVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_CIVECTOR_USE_OF_UNINITIALIZED_OBJ);
957 #else
958  throw();
959 #endif
960  friend INLINE int Lb(const civector &rv) throw() { return rv.l; }
963  friend INLINE int Ub(const civector &rv) throw() { return rv.u; }
965  friend INLINE int VecLen(const civector &rv) throw() { return rv.size; }
967  friend INLINE civector & SetLb(civector &rv, const int &l) throw() { rv.l=l; rv.u=l+rv.size-1; return rv;}
969  friend INLINE civector & SetUb(civector &rv, const int &u) throw() { rv.u=u; rv.l=u-rv.size+1; return rv;}
971  INLINE cinterval & operator [](const int &i) const
972 #if(CXSC_INDEX_CHECK)
973  throw(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC);
974 #else
975  throw();
976 #endif
977 
979  INLINE cinterval & operator [](const int &i)
980 #if(CXSC_INDEX_CHECK)
981  throw(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC);
982 #else
983  throw();
984 #endif
985 
987  INLINE civector & operator ()() throw() { return *this; }
989  INLINE civector_slice operator ()(const int &i)
990 #if(CXSC_INDEX_CHECK)
991  throw(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG);
992 #else
993  throw();
994 #endif
995  civector_slice operator ()(const int &i1,const int &i2)
997 #if(CXSC_INDEX_CHECK)
998  throw(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG);
999 #else
1000  throw();
1001 #endif
1002 
1003  INLINE operator void*() throw();
1004 //#else
1005 //#endif
1006 };
1007 
1009 
1015 {
1016  friend class civector;
1017  friend class cimatrix;
1018  private:
1019  cinterval *dat;
1020  int l,u,size;
1021  int start,end;
1022 
1023  public:
1024 //#if(CXSC_INDEX_CHECK)
1025 #ifdef _CXSC_FRIEND_TPL
1026 //------------------------- Templates -------------------------------------------
1027 // cinterval / cinterval
1028 
1029  template <class VS1,class VS2> friend VS1 & _vsvsassign(VS1 &sl1,const VS2 &sl2)
1030 #if(CXSC_INDEX_CHECK)
1031  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1032 #else
1033  throw();
1034 #endif
1035  template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) throw();
1036  template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv)
1037 #if(CXSC_INDEX_CHECK)
1038  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
1039 #else
1040  throw();
1041 #endif
1042  template <class VS,class S> friend VS & _vssassign(VS &sl,const S &r) throw();
1043  template <class VS,class V> friend VS &_vsvsetinf(VS &sl, const V &rv)
1044 #if(CXSC_INDEX_CHECK)
1045  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
1046 #else
1047  throw();
1048 #endif
1049  template <class VS,class V> friend VS &_vsvsetsup(VS &sl, const V &rv)
1050 #if(CXSC_INDEX_CHECK)
1051  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
1052 #else
1053  throw();
1054 #endif
1055  template <class VS1,class VS2> friend VS1 &_vsvssetinf(VS1 &sl1, const VS2 &sl2)
1056 #if(CXSC_INDEX_CHECK)
1057  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1058 #else
1059  throw();
1060 #endif
1061  template <class VS1,class VS2> friend VS1 &_vsvssetsup(VS1 &sl1, const VS2 &sl2)
1062 #if(CXSC_INDEX_CHECK)
1063  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1064 #else
1065  throw();
1066 #endif
1067  template <class VS,class V> friend VS &_vsvusetinf(VS &sl, const V &rv)
1068 #if(CXSC_INDEX_CHECK)
1069  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
1070 #else
1071  throw();
1072 #endif
1073  template <class VS,class V> friend VS &_vsvusetsup(VS &sl, const V &rv)
1074 #if(CXSC_INDEX_CHECK)
1075  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
1076 #else
1077  throw();
1078 #endif
1079  template <class VS1,class VS2> friend VS1 &_vsvsusetinf(VS1 &sl1, const VS2 &sl2)
1080 #if(CXSC_INDEX_CHECK)
1081  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1082 #else
1083  throw();
1084 #endif
1085  template <class VS1,class VS2> friend VS1 &_vsvsusetsup(VS1 &sl1, const VS2 &sl2)
1086 #if(CXSC_INDEX_CHECK)
1087  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1088 #else
1089  throw();
1090 #endif
1091 
1092  template <class VS,class E> friend E _vsconj(const VS &sl) throw();
1093  template <class VS,class E> friend E _vsabs(const VS &sl) throw();
1094  template <class VS,class E> friend E _vsdiam(const VS &sl) throw();
1095  template <class VS,class E> friend E _vsmid(const VS &sl) throw();
1096  template <class VS,class E> friend E _vsinf(const VS &sl) throw();
1097  template <class VS,class E> friend E _vssup(const VS &sl) throw();
1098  template <class VS,class E> friend E _vsim(const VS &sl) throw();
1099  template <class VS,class E> friend E _vsre(const VS &sl) throw();
1100  friend INLINE ivector Re(const civector_slice &v) throw();
1101  friend INLINE ivector Im(const civector_slice &v) throw();
1102  friend INLINE cvector Inf(const civector_slice &v) throw();
1103  friend INLINE cvector Sup(const civector_slice &v) throw();
1104  friend INLINE rvector SupRe(const civector_slice &v) throw();
1105  friend INLINE rvector SupIm(const civector_slice &v) throw();
1106  friend INLINE rvector InfRe(const civector_slice &v) throw();
1107  friend INLINE rvector InfIm(const civector_slice &v) throw();
1108  template <class VS,class V> friend VS &_vsvsetim(VS &sl, const V &rv)
1109 #if(CXSC_INDEX_CHECK)
1110  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
1111 #else
1112  throw();
1113 #endif
1114  template <class VS,class V> friend VS &_vsvsetre(VS &sl, const V &rv)
1115 #if(CXSC_INDEX_CHECK)
1116  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
1117 #else
1118  throw();
1119 #endif
1120  template <class VS1,class VS2> friend VS1 &_vsvssetim(VS1 &sl1, const VS2 &sl2)
1121 #if(CXSC_INDEX_CHECK)
1122  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1123 #else
1124  throw();
1125 #endif
1126  template <class VS1,class VS2> friend VS1 &_vsvssetre(VS1 &sl1, const VS2 &sl2)
1127 #if(CXSC_INDEX_CHECK)
1128  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1129 #else
1130  throw();
1131 #endif
1132  /* friend TINLINE civector_slice &_vsmvsetim(civector_slice &,const imatrix_subv &)
1133 #if(CXSC_INDEX_CHECK)
1134  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1135 #else
1136  throw();
1137 #endif
1138  friend TINLINE civector_slice &_vsmvsetre(civector_slice &,const imatrix_subv &)
1139 #if(CXSC_INDEX_CHECK)
1140  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1141 #else
1142  throw();
1143  #endif */
1144  template <class VS,class S> friend VS &_vsssetinf(VS &vs, const S &s) throw();
1145  template <class VS,class S> friend VS &_vsssetsup(VS &vs, const S &s) throw();
1146  template <class VS,class S> friend VS &_vssusetinf(VS &vs, const S &s) throw();
1147  template <class VS,class S> friend VS &_vssusetsup(VS &vs, const S &s) throw();
1148  template <class VS,class S> friend VS &_vsssetim(VS &vs, const S &s) throw();
1149  template <class VS,class S> friend VS &_vsssetre(VS &vs, const S &s) throw();
1150 
1151  template <class DP,class VS,class V> friend void _vsvaccu(DP &dp, const VS & sl, const V &rv)
1152 #if(CXSC_INDEX_CHECK)
1153  throw(OP_WITH_WRONG_DIM);
1154 #else
1155  throw();
1156 #endif
1157  template <class DP,class VS1,class VS2> friend void _vsvsaccu(DP &dp, const VS1 & sl1, const VS2 &sl2)
1158 #if(CXSC_INDEX_CHECK)
1159  throw(OP_WITH_WRONG_DIM);
1160 #else
1161  throw();
1162 #endif
1163 
1164  template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) throw();
1165  template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) throw();
1166 
1167  template <class VS,class V,class E> friend E _vsvcimult(const VS & sl, const V &rv)
1168 #if(CXSC_INDEX_CHECK)
1169  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1170 #else
1171  throw();
1172 #endif
1173  template <class VS,class S> friend VS &_vssmultassign(VS &rv,const S &r) throw();
1174  template <class VS,class S> friend VS &_vssdivassign(VS &rv,const S &r) throw();
1175  template <class V,class VS,class E> friend E _vvsplus(const V &rv,const VS &sl)
1176 #if(CXSC_INDEX_CHECK)
1177  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1178 #else
1179  throw();
1180 #endif
1181  template <class VS1,class VS2,class E> friend E _vsvsplus(const VS1 &s1,const VS2 &s2)
1182 #if(CXSC_INDEX_CHECK)
1183  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1184 #else
1185  throw();
1186 #endif
1187  template <class VS1,class VS2,class E> friend E _vsvsminus(const VS1 &s1,const VS2 &s2)
1188 #if(CXSC_INDEX_CHECK)
1189  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1190 #else
1191  throw();
1192 #endif
1193  template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl)
1194 #if(CXSC_INDEX_CHECK)
1195  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1196 #else
1197  throw();
1198 #endif
1199  template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv)
1200 #if(CXSC_INDEX_CHECK)
1201  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
1202 #else
1203  throw();
1204 #endif
1205  template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
1206 #if(CXSC_INDEX_CHECK)
1207  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1208 #else
1209  throw();
1210 #endif
1211  template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
1212 #if(CXSC_INDEX_CHECK)
1213  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1214 #else
1215  throw();
1216 #endif
1217  template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl)
1218 #if(CXSC_INDEX_CHECK)
1219  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1220 #else
1221  throw();
1222 #endif
1223  template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv)
1224 #if(CXSC_INDEX_CHECK)
1225  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
1226 #else
1227  throw();
1228 #endif
1229  template <class VS,class V> friend V _vsminus(const VS &sl) throw();
1230  template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl)
1231 #if(CXSC_INDEX_CHECK)
1232  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1233 #else
1234  throw();
1235 #endif
1236  template <class VS,class V,class E> friend E _vsvminus(const VS &sl,const V &rv)
1237 #if(CXSC_INDEX_CHECK)
1238  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1239 #else
1240  throw();
1241 #endif
1242  template <class V,class VS,class E> friend E _vvssect(const V &rv,const VS &sl)
1243 #if(CXSC_INDEX_CHECK)
1244  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1245 #else
1246  throw();
1247 #endif
1248  template <class VS1,class VS2,class E> friend E _vsvssect(const VS1 &s1,const VS2 &s2)
1249 #if(CXSC_INDEX_CHECK)
1250  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1251 #else
1252  throw();
1253 #endif
1254  template <class V,class VS> friend V &_vvssectassign(V &rv, const VS &sl)
1255 #if(CXSC_INDEX_CHECK)
1256  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1257 #else
1258  throw();
1259 #endif
1260  template <class VS,class V> friend VS &_vsvsectassign(VS &sl, const V &rv)
1261 #if(CXSC_INDEX_CHECK)
1262  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
1263 #else
1264  throw();
1265 #endif
1266  template <class VS1,class VS2> friend VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2)
1267 #if(CXSC_INDEX_CHECK)
1268  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1269 #else
1270  throw();
1271 #endif
1272  template <class V,class VS,class E> friend E _vvsconv(const V &rv,const VS &sl)
1273 #if(CXSC_INDEX_CHECK)
1274  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1275 #else
1276  throw();
1277 #endif
1278  template <class VS1,class VS2,class E> friend E _vsvsconv(const VS1 &s1,const VS2 &s2)
1279 #if(CXSC_INDEX_CHECK)
1280  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1281 #else
1282  throw();
1283 #endif
1284  template <class V,class VS> friend V &_vvsconvassign(V &rv, const VS &sl)
1285 #if(CXSC_INDEX_CHECK)
1286  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1287 #else
1288  throw();
1289 #endif
1290  template <class VS,class V> friend VS &_vsvconvassign(VS &sl, const V &rv)
1291 #if(CXSC_INDEX_CHECK)
1292  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
1293 #else
1294  throw();
1295 #endif
1296  template <class VS1,class VS2> friend VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2)
1297 #if(CXSC_INDEX_CHECK)
1298  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1299 #else
1300  throw();
1301 #endif
1302  template <class VS,class M,class S> friend VS &_vsmcimultassign(VS &v,const M &m)
1303 #if(CXSC_INDEX_CHECK)
1304  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1305 #else
1306  throw();
1307 #endif
1308 
1309  template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) throw();
1310  template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) throw();
1311  template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) throw();
1312  template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) throw();
1313  template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) throw();
1314  template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) throw();
1315  template <class VS1,class VS2,class E> friend E _vsvscimult(const VS1 & sl1, const VS2 &sl2)
1316 #if(CXSC_INDEX_CHECK)
1317  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1318 #else
1319  throw();
1320 #endif
1321  template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw();
1322  template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw();
1323  template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw();
1324  template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw();
1325  template <class VS> friend bool _vsnot(const VS &sl) throw();
1326  template <class VS> friend void *_vsvoid(const VS &sl) throw();
1327  template <class V> friend std::ostream &_vsout(std::ostream &s, const V &rv) throw();
1328  template <class V> friend std::istream &_vsin(std::istream &s, V &rv) throw();
1329 
1330  // cinterval / Real
1331  template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms)
1332 #if(CXSC_INDEX_CHECK)
1333  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1334 #else
1335  throw();
1336 #endif
1337  // cinterval / complex
1338  template <class DP,class V1,class V2> friend void _vvaccu(DP &dp, const V1 & rv1, const V2 &rv2)
1339 #if(CXSC_INDEX_CHECK)
1340  throw(OP_WITH_WRONG_DIM);
1341 #else
1342  throw();
1343 #endif
1344 
1345  // cinterval / interval
1346  // complex
1347  template <class V1,class V2,class S> friend V1 &_vvassign(V1 &rv1,const V2 &rv2) throw();
1348  template <class V,class S> friend V & _vsassign(V &rv,const S &r) throw();
1349 
1350 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m)
1351 #if(CXSC_INDEX_CHECK)
1352  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
1353 #else
1354  throw();
1355 #endif
1356 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) throw();
1357 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) throw();
1358 
1359  template <class V1,class V2,class E> friend E _vvconv(const V1 &rv1, const V2 &rv2)
1360 #if(CXSC_INDEX_CHECK)
1361  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1362 #else
1363  throw();
1364 #endif
1365 
1366  //--complex -------- vector-scalar ------------
1367  template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) throw();
1368  template <class V,class S,class E> friend E _vsmult(const V &rv, const S &s) throw();
1369  template <class V,class S,class E> friend E _vsdiv(const V &rv, const S &s) throw();
1370  template <class V,class S> friend V &_vsdivassign(V &rv,const S &r) throw();
1371  template <class V,class S> friend V &_vsmultassign(V &rv,const S &r) throw();
1372  //--complex--------- Vector-vector---------
1373  template <class V1,class V2,class E> friend E _vvcimult(const V1 & rv1, const V2 &rv2)
1374 #if(CXSC_INDEX_CHECK)
1375  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
1376 #else
1377  throw();
1378 #endif
1379  template <class V1,class V2,class E> friend E _vvplus(const V1 &rv1, const V2 &rv2)
1380 #if(CXSC_INDEX_CHECK)
1381  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
1382 #else
1383  throw();
1384 #endif
1385  template <class V1,class V2> friend V1 &_vvplusassign(V1 &rv1, const V2 &rv2)
1386 #if(CXSC_INDEX_CHECK)
1387  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
1388 #else
1389  throw();
1390 #endif
1391  template <class V1,class V2> friend V1 &_vvminusassign(V1 &rv1, const V2 &rv2)
1392 #if(CXSC_INDEX_CHECK)
1393  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
1394 #else
1395  throw();
1396 #endif
1397  template <class V1,class V2,class E> friend E _vvminus(const V1 &rv1, const V2 &rv2)
1398 #if(CXSC_INDEX_CHECK)
1399  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1400 #else
1401  throw();
1402 #endif
1403  template <class V1,class V2> friend V1 &_vvconvassign(V1 &rv1, const V2 &rv2)
1404 #if(CXSC_INDEX_CHECK)
1405  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
1406 #else
1407  throw();
1408 #endif
1409  template <class V1,class V2,class E> friend E _vvsect(const V1 &rv1, const V2 &rv2)
1410 #if(CXSC_INDEX_CHECK)
1411  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
1412 #else
1413  throw();
1414 #endif
1415  template <class V1,class V2> friend V1 &_vvsectassign(V1 &rv1, const V2 &rv2)
1416 #if(CXSC_INDEX_CHECK)
1417  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
1418 #else
1419  throw();
1420 #endif
1421 
1422  //-- complex -------- Vector-matrix ----------
1423 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m)
1424 #if(CXSC_INDEX_CHECK)
1425  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>);
1426 #else
1427  throw();
1428 #endif
1429 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
1430 #if(CXSC_INDEX_CHECK)
1431  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
1432 #else
1433  throw();
1434 #endif
1435  template <class M,class V,class E> friend E _mvcimult(const M &m,const V &v)
1436 #if(CXSC_INDEX_CHECK)
1437  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1438 #else
1439  throw();
1440 #endif
1441  template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v)
1442 #if(CXSC_INDEX_CHECK)
1443  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1444 #else
1445  throw();
1446 #endif
1447  template <class V,class M,class E> friend E _vmcimult(const V &v,const M &m)
1448 #if(CXSC_INDEX_CHECK)
1449  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1450 #else
1451  throw();
1452 #endif
1453  template <class V,class MS,class S> friend V &_vmscimultassign(V &v,const MS &ms)
1454 #if(CXSC_INDEX_CHECK)
1455  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1456 #else
1457  throw();
1458 #endif
1459  template <class V,class M,class S> friend V &_vmcimultassign(V &v,const M &m)
1460 #if(CXSC_INDEX_CHECK)
1461  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1462 #else
1463  throw();
1464 #endif
1465 
1466  // interval
1467  /* friend TINLINE civector &_vsmassign<civector_slice,imatrix,cinterval>(civector_slice &v,const imatrix &m)
1468 #if(CXSC_INDEX_CHECK)
1469  throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
1470 #else
1471  throw();
1472 #endif */
1473 
1474  //--interval -------- vector-scalar ------------
1475  //--interval--------- Vector-vector---------
1476  //-- interval -------- Vector-matrix ----------
1477 /* friend TINLINE civector _mvscimult<imatrix,civector_slice,civector>(const imatrix &m,const civector_slice &v)
1478 #if(CXSC_INDEX_CHECK)
1479  throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
1480 #else
1481  throw();
1482 #endif */
1483  /* friend TINLINE civector _msvscimult<imatrix_slice,civector_slice,civector>(const imatrix_slice &ms,const civector_slice &v)
1484 #if(CXSC_INDEX_CHECK)
1485  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
1486 #else
1487  throw();
1488  #endif */
1489  /* friend TINLINE civector _vsmcimult<civector_slice,imatrix,civector>(const civector_slice &v,const imatrix &m)
1490 #if(CXSC_INDEX_CHECK)
1491  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
1492 #else
1493  throw();
1494 #endif */
1495  /* friend TINLINE civector _vsmscimult<civector_slice,imatrix_slice,civector>(const civector_slice &v,const imatrix_slice &ms)
1496 #if(CXSC_INDEX_CHECK)
1497  throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
1498 #else
1499  throw();
1500 #endif */
1501  /* friend TINLINE civector &_vsmscimultassign<civector_slice,imatrix_slice,cinterval>(civector_slice &v,const imatrix_slice &m)
1502 #if(CXSC_INDEX_CHECK)
1503  throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
1504 #else
1505  throw();
1506 #endif */
1507 
1508 
1509 #endif
1510 
1511  //--------------------- Konstruktoren -----------------------------------
1513  explicit INLINE civector_slice(civector &a, const int &lb, const int &ub) throw():dat(a.dat),l(a.l),u(a.u),size(ub-lb+1),start(lb),end(ub) { }
1515  explicit INLINE civector_slice(civector_slice &a, const int &lb, const int &ub) throw():dat(a.dat),l(a.l),u(a.u),size(ub-lb+1),start(lb),end(ub) { }
1516  public:
1518  INLINE civector_slice(const civector_slice &a) throw():dat(a.dat),l(a.l),u(a.u),size(a.size),start(a.start),end(a.end) { }
1519  public:
1520  // cinterval
1522  INLINE civector_slice & operator =(const scivector_slice &sl);
1524  INLINE civector_slice & operator =(const scivector &sl);
1525 
1527  INLINE civector_slice & operator =(const civector_slice &sl)
1528 #if(CXSC_INDEX_CHECK)
1529  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1530 #else
1531  throw();
1532 #endif
1533  INLINE civector_slice & operator =(const civector &rv)
1535 #if(CXSC_INDEX_CHECK)
1536  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1537 #else
1538  throw();
1539 #endif
1540  INLINE civector_slice & operator =(const cinterval &r) throw();
1543  INLINE civector_slice & operator =(const cimatrix &m)
1544 #if(CXSC_INDEX_CHECK)
1545  throw(ERROR__OP_WITH_WRONG_DIM<civector>,ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
1546 #else
1547  throw();
1548 #endif
1549  INLINE civector_slice & operator =(const cimatrix_slice &m)
1551 #if(CXSC_INDEX_CHECK)
1552  throw(ERROR__OP_WITH_WRONG_DIM<civector>,ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
1553 #else
1554  throw();
1555 #endif
1556  INLINE civector_slice &operator =(const cimatrix_subv &) throw();
1558  // Real
1560  INLINE civector_slice & operator =(const srvector_slice &sl);
1562  INLINE civector_slice & operator =(const srvector &sl);
1563 
1565  INLINE civector_slice & operator =(const rvector_slice &sl)
1566 #if(CXSC_INDEX_CHECK)
1567  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1568 #else
1569  throw();
1570 #endif
1571  INLINE civector_slice & operator =(const rvector &rv)
1573 #if(CXSC_INDEX_CHECK)
1574  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1575 #else
1576  throw();
1577 #endif
1578  INLINE civector_slice & operator =(const real &r) throw();
1581  INLINE civector_slice & operator =(const rmatrix &m)
1582 #if(CXSC_INDEX_CHECK)
1583  throw(ERROR__OP_WITH_WRONG_DIM<rvector>,ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
1584 #else
1585  throw();
1586 #endif
1587  INLINE civector_slice & operator =(const rmatrix_slice &m)
1589 #if(CXSC_INDEX_CHECK)
1590  throw(ERROR__OP_WITH_WRONG_DIM<rvector>,ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
1591 #else
1592  throw();
1593 #endif
1594  INLINE civector_slice &operator =(const rmatrix_subv &mv) throw();
1596 
1597  // complex
1599  INLINE civector_slice & operator =(const scvector_slice &sl);
1601  INLINE civector_slice & operator =(const scvector &sl);
1602 
1604  INLINE civector_slice & operator =(const cvector_slice &sl)
1605 #if(CXSC_INDEX_CHECK)
1606  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1607 #else
1608  throw();
1609 #endif
1610  INLINE civector_slice & operator =(const cvector &rv)
1612 #if(CXSC_INDEX_CHECK)
1613  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1614 #else
1615  throw();
1616 #endif
1617  INLINE civector_slice & operator =(const complex &r) throw();
1620  INLINE civector_slice & operator =(const cmatrix &m)
1621 #if(CXSC_INDEX_CHECK)
1622  throw(ERROR__OP_WITH_WRONG_DIM<cvector>,ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
1623 #else
1624  throw();
1625 #endif
1626  INLINE civector_slice & operator =(const cmatrix_slice &m)
1628 #if(CXSC_INDEX_CHECK)
1629  throw(ERROR__OP_WITH_WRONG_DIM<cvector>,ERROR_CMATRIX_TYPE_CAST_OF_THICK_OBJ);
1630 #else
1631  throw();
1632 #endif
1633  INLINE civector_slice &operator =(const cmatrix_subv &mv) throw();
1635 
1636  // interval
1638  INLINE civector_slice & operator =(const sivector_slice &sl);
1640  INLINE civector_slice & operator =(const sivector &sl);
1641 
1643  INLINE civector_slice & operator =(const ivector_slice &sl)
1644 #if(CXSC_INDEX_CHECK)
1645  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1646 #else
1647  throw();
1648 #endif
1649  INLINE civector_slice & operator =(const ivector &rv)
1651 #if(CXSC_INDEX_CHECK)
1652  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1653 #else
1654  throw();
1655 #endif
1656  INLINE civector_slice & operator =(const interval &r) throw();
1659  INLINE civector_slice & operator =(const imatrix &m)
1660 #if(CXSC_INDEX_CHECK)
1661  throw(ERROR__OP_WITH_WRONG_DIM<ivector>,ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
1662 #else
1663  throw();
1664 #endif
1665  INLINE civector_slice & operator =(const imatrix_slice &m)
1667 #if(CXSC_INDEX_CHECK)
1668  throw(ERROR__OP_WITH_WRONG_DIM<ivector>,ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
1669 #else
1670  throw();
1671 #endif
1672  INLINE civector_slice &operator =(const imatrix_subv &mv) throw();
1674 
1675  //--------------------- Standardfunktionen ------------------------------
1676 
1677  friend INLINE cinterval::cinterval(const civector_slice &sl)
1678 #if(CXSC_INDEX_CHECK)
1679  throw(ERROR_CIVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_CIVECTOR_USE_OF_UNINITIALIZED_OBJ);
1680 #else
1681  throw();
1682 #endif
1683  friend INLINE int Lb(const civector_slice &sl) throw() { return sl.start; }
1686  friend INLINE int Ub(const civector_slice &sl) throw() { return sl.end; }
1688  friend INLINE int VecLen(const civector_slice &sl) throw() { return sl.size; }
1689 
1691  INLINE cinterval & operator [](const int &i) const
1692 #if(CXSC_INDEX_CHECK)
1693  throw(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC);
1694 #else
1695  throw();
1696 #endif
1697 
1699  INLINE cinterval & operator [](const int &i)
1700 #if(CXSC_INDEX_CHECK)
1701  throw(ERROR_CIVECTOR_ELEMENT_NOT_IN_VEC);
1702 #else
1703  throw();
1704 #endif
1705 
1707  INLINE civector_slice & operator ()() throw() { return *this; }
1709  INLINE civector_slice operator ()(const int &i)
1710 #if(CXSC_INDEX_CHECK)
1711  throw(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG);
1712 #else
1713  throw();
1714 #endif
1715  civector_slice operator ()(const int &i1,const int &i2)
1717 #if(CXSC_INDEX_CHECK)
1718  throw(ERROR_CIVECTOR_SUB_ARRAY_TOO_BIG);
1719 #else
1720  throw();
1721 #endif
1722  INLINE operator void*() throw();
1723 
1725  INLINE civector_slice &operator *=(const cinterval &r) throw();
1727  INLINE civector_slice &operator /=(const cinterval &r) throw();
1729  INLINE civector_slice &operator *=(const cimatrix &m)
1730 #if(CXSC_INDEX_CHECK)
1731  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
1732 #else
1733  throw();
1734 #endif
1735  INLINE civector_slice &operator *=(const cimatrix_slice &m)
1737 #if(CXSC_INDEX_CHECK)
1738  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
1739 #else
1740  throw();
1741 #endif
1742  INLINE civector_slice &operator +=(const civector &rv)
1744 #if(CXSC_INDEX_CHECK)
1745  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1746 #else
1747  throw();
1748 #endif
1749  INLINE civector_slice &operator +=(const civector_slice &sl2)
1751 #if(CXSC_INDEX_CHECK)
1752  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1753 #else
1754  throw();
1755 #endif
1756  INLINE civector_slice &operator -=(const civector &rv)
1758 #if(CXSC_INDEX_CHECK)
1759  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1760 #else
1761  throw();
1762 #endif
1763  INLINE civector_slice &operator -=(const civector_slice &sl2)
1765 #if(CXSC_INDEX_CHECK)
1766  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1767 #else
1768  throw();
1769 #endif
1770  INLINE civector_slice &operator |=(const civector &rv)
1772 #if(CXSC_INDEX_CHECK)
1773  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1774 #else
1775  throw();
1776 #endif
1777  INLINE civector_slice &operator |=(const civector_slice &sl2)
1779 #if(CXSC_INDEX_CHECK)
1780  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1781 #else
1782  throw();
1783 #endif
1784  INLINE civector_slice &operator &=(const civector &rv)
1786 #if(CXSC_INDEX_CHECK)
1787  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1788 #else
1789  throw();
1790 #endif
1791  INLINE civector_slice &operator &=(const civector_slice &sl2)
1793 #if(CXSC_INDEX_CHECK)
1794  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1795 #else
1796  throw();
1797 #endif
1798 
1800  INLINE civector_slice &operator *=(const real &r) throw();
1802  INLINE civector_slice &operator /=(const real &r) throw();
1804  INLINE civector_slice &operator +=(const rvector &rv)
1805 #if(CXSC_INDEX_CHECK)
1806  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1807 #else
1808  throw();
1809 #endif
1810  INLINE civector_slice &operator +=(const rvector_slice &sl2)
1812 #if(CXSC_INDEX_CHECK)
1813  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1814 #else
1815  throw();
1816 #endif
1817  INLINE civector_slice &operator -=(const rvector &rv)
1819 #if(CXSC_INDEX_CHECK)
1820  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1821 #else
1822  throw();
1823 #endif
1824  INLINE civector_slice &operator -=(const rvector_slice &sl2)
1826 #if(CXSC_INDEX_CHECK)
1827  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1828 #else
1829  throw();
1830 #endif
1831  INLINE civector_slice &operator |=(const rvector &rv)
1833 #if(CXSC_INDEX_CHECK)
1834  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1835 #else
1836  throw();
1837 #endif
1838  INLINE civector_slice &operator |=(const rvector_slice &sl2)
1840 #if(CXSC_INDEX_CHECK)
1841  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1842 #else
1843  throw();
1844 #endif
1845  INLINE civector_slice &operator &=(const rvector &rv)
1847 #if(CXSC_INDEX_CHECK)
1848  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1849 #else
1850  throw();
1851 #endif
1852  INLINE civector_slice &operator &=(const rvector_slice &sl2)
1854 #if(CXSC_INDEX_CHECK)
1855  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1856 #else
1857  throw();
1858 #endif
1859  INLINE civector_slice &operator *=(const rmatrix &m)
1861 #if(CXSC_INDEX_CHECK)
1862  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
1863 #else
1864  throw();
1865 #endif
1866  INLINE civector_slice &operator *=(const rmatrix_slice &m)
1868 #if(CXSC_INDEX_CHECK)
1869  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
1870 #else
1871  throw();
1872 #endif
1873 
1875  INLINE civector_slice &operator *=(const complex &r) throw();
1877  INLINE civector_slice &operator /=(const complex &r) throw();
1879  INLINE civector_slice &operator +=(const cvector &rv)
1880 #if(CXSC_INDEX_CHECK)
1881  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1882 #else
1883  throw();
1884 #endif
1885  INLINE civector_slice &operator +=(const cvector_slice &sl2)
1887 #if(CXSC_INDEX_CHECK)
1888  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1889 #else
1890  throw();
1891 #endif
1892  INLINE civector_slice &operator -=(const cvector &rv)
1894 #if(CXSC_INDEX_CHECK)
1895  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1896 #else
1897  throw();
1898 #endif
1899  INLINE civector_slice &operator -=(const cvector_slice &sl2)
1901 #if(CXSC_INDEX_CHECK)
1902  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1903 #else
1904  throw();
1905 #endif
1906  INLINE civector_slice &operator |=(const cvector &rv)
1908 #if(CXSC_INDEX_CHECK)
1909  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1910 #else
1911  throw();
1912 #endif
1913  INLINE civector_slice &operator |=(const cvector_slice &sl2)
1915 #if(CXSC_INDEX_CHECK)
1916  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1917 #else
1918  throw();
1919 #endif
1920  INLINE civector_slice &operator &=(const cvector &rv)
1922 #if(CXSC_INDEX_CHECK)
1923  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1924 #else
1925  throw();
1926 #endif
1927  INLINE civector_slice &operator &=(const cvector_slice &sl2)
1929 #if(CXSC_INDEX_CHECK)
1930  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1931 #else
1932  throw();
1933 #endif
1934  INLINE civector_slice &operator *=(const cmatrix &m)
1936 #if(CXSC_INDEX_CHECK)
1937  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1938 #else
1939  throw();
1940 #endif
1941  INLINE civector_slice &operator *=(const cmatrix_slice &m)
1943 #if(CXSC_INDEX_CHECK)
1944  throw(ERROR_CMATRIX_OP_WITH_WRONG_DIM);
1945 #else
1946  throw();
1947 #endif
1948 
1950  INLINE civector_slice &operator *=(const interval &r) throw();
1952  INLINE civector_slice &operator /=(const interval &r) throw();
1954  INLINE civector_slice &operator +=(const ivector &rv)
1955 #if(CXSC_INDEX_CHECK)
1956  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1957 #else
1958  throw();
1959 #endif
1960  INLINE civector_slice &operator +=(const ivector_slice &sl2)
1962 #if(CXSC_INDEX_CHECK)
1963  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1964 #else
1965  throw();
1966 #endif
1967  INLINE civector_slice &operator -=(const ivector &rv)
1969 #if(CXSC_INDEX_CHECK)
1970  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1971 #else
1972  throw();
1973 #endif
1974  INLINE civector_slice &operator -=(const ivector_slice &sl2)
1976 #if(CXSC_INDEX_CHECK)
1977  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1978 #else
1979  throw();
1980 #endif
1981  INLINE civector_slice &operator |=(const ivector &rv)
1983 #if(CXSC_INDEX_CHECK)
1984  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1985 #else
1986  throw();
1987 #endif
1988  INLINE civector_slice &operator |=(const ivector_slice &sl2)
1990 #if(CXSC_INDEX_CHECK)
1991  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1992 #else
1993  throw();
1994 #endif
1995  INLINE civector_slice &operator &=(const ivector &rv)
1997 #if(CXSC_INDEX_CHECK)
1998  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
1999 #else
2000  throw();
2001 #endif
2002  INLINE civector_slice &operator &=(const ivector_slice &sl2)
2004 #if(CXSC_INDEX_CHECK)
2005  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2006 #else
2007  throw();
2008 #endif
2009  INLINE civector_slice &operator *=(const imatrix &m)
2011 #if(CXSC_INDEX_CHECK)
2012  throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
2013 #else
2014  throw();
2015 #endif
2016  INLINE civector_slice &operator *=(const imatrix_slice &m)
2018 #if(CXSC_INDEX_CHECK)
2019  throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
2020 #else
2021  throw();
2022 #endif
2023 //#else
2024 //#endif
2025 
2054 
2055 };
2056 
2057 //=======================================================================
2058 //======================== Vector Functions =============================
2059 
2061  INLINE civector _civector(const cinterval &r) throw();
2062 // INLINE civector _civector(const cimatrix &m) throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
2063 // INLINE civector _civector(const cimatrix_slice &sl) throw(ERROR_CIMATRIX_TYPE_CAST_OF_THICK_OBJ);
2065  INLINE civector _civector(const real &r) throw();
2067  INLINE civector _civector(const rvector_slice &rs) throw();
2069  INLINE civector _civector(const rvector &rs) throw();
2070 // INLINE civector _civector(const rmatrix &m) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
2071 // INLINE civector _civector(const rmatrix_slice &sl) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
2073  INLINE civector _civector(const rmatrix_subv &rs) throw();
2074 
2076  INLINE civector &SetInf(civector &iv,const cvector &rv)
2077 #if(CXSC_INDEX_CHECK)
2078  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2079 #else
2080  throw();
2081 #endif
2082  INLINE civector_slice &SetInf(civector_slice &iv,const cvector &rv)
2084 #if(CXSC_INDEX_CHECK)
2085  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2086 #else
2087  throw();
2088 #endif
2089  INLINE civector &SetInf(civector &iv,const cvector_slice &rv)
2091 #if(CXSC_INDEX_CHECK)
2092  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2093 #else
2094  throw();
2095 #endif
2096  INLINE civector_slice &SetInf(civector_slice &iv,const cvector_slice &rv)
2098 #if(CXSC_INDEX_CHECK)
2099  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2100 #else
2101  throw();
2102 #endif
2103  INLINE civector &UncheckedSetInf(civector &iv,const cvector &rv)
2105 #if(CXSC_INDEX_CHECK)
2106  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2107 #else
2108  throw();
2109 #endif
2110  INLINE civector_slice &UncheckedSetInf(civector_slice &iv,const cvector &rv)
2112 #if(CXSC_INDEX_CHECK)
2113  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2114 #else
2115  throw();
2116 #endif
2117  INLINE civector &UncheckedSetInf(civector &iv,const cvector_slice &rv)
2119 #if(CXSC_INDEX_CHECK)
2120  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2121 #else
2122  throw();
2123 #endif
2124  INLINE civector_slice &UncheckedSetInf(civector_slice &iv,const cvector_slice &rv)
2126 #if(CXSC_INDEX_CHECK)
2127  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2128 #else
2129  throw();
2130 #endif
2131 
2133  INLINE civector &SetSup(civector &iv,const cvector &rv)
2134 #if(CXSC_INDEX_CHECK)
2135  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2136 #else
2137  throw();
2138 #endif
2139  INLINE civector_slice &SetSup(civector_slice &iv,const cvector &rv)
2141 #if(CXSC_INDEX_CHECK)
2142  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2143 #else
2144  throw();
2145 #endif
2146  INLINE civector &SetSup(civector &iv,const cvector_slice &rv)
2148 #if(CXSC_INDEX_CHECK)
2149  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2150 #else
2151  throw();
2152 #endif
2153  INLINE civector_slice &SetSup(civector_slice &iv,const cvector_slice &rv)
2155 #if(CXSC_INDEX_CHECK)
2156  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2157 #else
2158  throw();
2159 #endif
2160  INLINE civector &UncheckedSetSup(civector &iv,const cvector &rv)
2162 #if(CXSC_INDEX_CHECK)
2163  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2164 #else
2165  throw();
2166 #endif
2167  INLINE civector_slice &UncheckedSetSup(civector_slice &iv,const cvector &rv)
2169 #if(CXSC_INDEX_CHECK)
2170  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2171 #else
2172  throw();
2173 #endif
2174  INLINE civector &UncheckedSetSup(civector &iv,const cvector_slice &rv)
2176 #if(CXSC_INDEX_CHECK)
2177  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2178 #else
2179  throw();
2180 #endif
2181  INLINE civector_slice &UncheckedSetSup(civector_slice &iv,const cvector_slice &rv)
2183 #if(CXSC_INDEX_CHECK)
2184  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2185 #else
2186  throw();
2187 #endif
2188 
2190  INLINE civector &SetRe(civector &iv,const ivector &rv)
2191 #if(CXSC_INDEX_CHECK)
2192  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2193 #else
2194  throw();
2195 #endif
2196  INLINE civector_slice &SetRe(civector_slice &iv,const ivector &rv)
2198 #if(CXSC_INDEX_CHECK)
2199  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2200 #else
2201  throw();
2202 #endif
2203  INLINE civector &SetRe(civector &iv,const ivector_slice &rv)
2205 #if(CXSC_INDEX_CHECK)
2206  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2207 #else
2208  throw();
2209 #endif
2210  INLINE civector_slice &SetRe(civector_slice &iv,const ivector_slice &rv)
2212 #if(CXSC_INDEX_CHECK)
2213  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2214 #else
2215  throw();
2216 #endif
2217 
2219  INLINE civector &SetIm(civector &iv,const ivector &rv)
2220 #if(CXSC_INDEX_CHECK)
2221  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2222 #else
2223  throw();
2224 #endif
2225  INLINE civector_slice &SetIm(civector_slice &iv,const ivector &rv)
2227 #if(CXSC_INDEX_CHECK)
2228  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2229 #else
2230  throw();
2231 #endif
2232  INLINE civector &SetIm(civector &iv,const ivector_slice &rv)
2234 #if(CXSC_INDEX_CHECK)
2235  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2236 #else
2237  throw();
2238 #endif
2239  INLINE civector_slice &SetIm(civector_slice &iv,const ivector_slice &rv)
2241 #if(CXSC_INDEX_CHECK)
2242  throw(ERROR_CIVECTOR_OP_WITH_WRONG_DIM);
2243 #else
2244  throw();
2245 #endif
2246 
2248  INLINE civector &SetSup(civector &iv,const complex &r) throw();
2250  INLINE civector &SetInf(civector &iv,const complex &r) throw();
2252  INLINE civector &UncheckedSetSup(civector &iv,const complex &r) throw();
2254  INLINE civector &SetUncheckedInf(civector &iv,const complex &r) throw();
2256  INLINE civector &SetRe(civector &iv,const interval &r) throw();
2258  INLINE civector &SetIm(civector &iv,const interval &r) throw();
2259 
2261  INLINE civector_slice &SetSup(civector_slice &iv,const complex &r) throw();
2263  INLINE civector_slice &SetInf(civector_slice &iv,const complex &r) throw();
2265  INLINE civector_slice &UncheckedSetSup(civector_slice &iv,const complex &r) throw();
2267  INLINE civector_slice &SetUncheckedInf(civector_slice &iv,const complex &r) throw();
2269  INLINE civector_slice &SetRe(civector_slice &iv,const interval &r) throw();
2271  INLINE civector_slice &SetIm(civector_slice &iv,const interval &r) throw();
2272 
2274  INLINE void Resize(civector &rv) throw();
2276  INLINE void Resize(civector &rv, const int &len)
2277 #if(CXSC_INDEX_CHECK)
2278  throw(ERROR__WRONG_BOUNDARIES<civector>);
2279 #else
2280  throw();
2281 #endif
2282  INLINE void Resize(civector &rv, const int &lb, const int &ub)
2284 #if(CXSC_INDEX_CHECK)
2285  throw(ERROR__WRONG_BOUNDARIES<civector>);
2286 #else
2287  throw();
2288 #endif
2289 
2291  INLINE civector conj(const civector &rv) throw();
2293  INLINE civector conj(const civector_slice &sl) throw();
2294 
2296  INLINE ivector abs(const civector &rv) throw();
2298  INLINE ivector abs(const civector_slice &sl) throw();
2300  INLINE cvector diam(const civector &v) throw();
2302  INLINE cvector diam(const civector_slice &v) throw();
2304  INLINE cvector mid(const civector &v) throw();
2306  INLINE cvector mid(const civector_slice &v) throw();
2308  INLINE cvector Inf(const civector &v) throw();
2310  INLINE cvector Inf(const civector_slice &v) throw();
2312  INLINE cvector Sup(const civector &v) throw();
2314  INLINE cvector Sup(const civector_slice &v) throw();
2316  INLINE rvector SupRe(const civector &v) throw();
2318  INLINE rvector SupIm(const civector &v) throw();
2320  INLINE rvector InfRe(const civector &v) throw();
2322  INLINE rvector InfIm(const civector &v) throw();
2324  INLINE rvector SupRe(const civector_slice &v) throw();
2326  INLINE rvector SupIm(const civector_slice &v) throw();
2328  INLINE rvector InfRe(const civector_slice &v) throw();
2330  INLINE rvector InfIm(const civector_slice &v) throw();
2332  INLINE bool operator !(const civector &rv) throw();
2334  INLINE bool operator !(const civector_slice &sl) throw();
2335 
2336 //======================= Vector / Scalar ===============================
2337 
2338 //----------------------------- cinterval ---------------------------
2339 
2341  INLINE civector operator *(const civector &rv, const cinterval &s) throw();
2343  INLINE civector operator *(const civector_slice &sl, const cinterval &s) throw();
2345  INLINE civector operator *(const cinterval &s, const civector &rv) throw();
2347  INLINE civector operator *(const cinterval &s, const civector_slice &sl) throw();
2349  INLINE civector &operator *=(civector &rv,const cinterval &r) throw();
2350 
2352  INLINE civector operator /(const civector &rv, const cinterval &s) throw();
2354  INLINE civector operator /(const civector_slice &sl, const cinterval &s) throw();
2356  INLINE civector &operator /=(civector &rv,const cinterval &r) throw();
2357 
2358 //---------------------------- Real --------------------------------------
2359 
2361  INLINE civector operator *(const civector &rv, const real &s) throw();
2363  INLINE civector operator *(const civector_slice &sl, const real &s) throw();
2365  INLINE civector operator *(const real &s, const civector &rv) throw();
2367  INLINE civector operator *(const real &s, const civector_slice &sl) throw();
2369  INLINE civector &operator *=(civector &rv,const real &r) throw();
2370 
2372  INLINE civector operator /(const civector &rv, const real &s) throw();
2374  INLINE civector operator /(const civector_slice &sl, const real &s) throw();
2376  INLINE civector &operator /=(civector &rv,const real &r) throw();
2377 
2379  INLINE civector operator *(const rvector &rv, const cinterval &s) throw();
2381  INLINE civector operator *(const rvector_slice &sl, const cinterval &s) throw();
2383  INLINE civector operator *(const cinterval &s, const rvector &rv) throw();
2385  INLINE civector operator *(const cinterval &s, const rvector_slice &sl) throw();
2386 
2388  INLINE civector operator /(const rvector &rv, const cinterval &s) throw();
2390  INLINE civector operator /(const rvector_slice &sl, const cinterval &s) throw();
2391 
2392 //---------------------------- Complex --------------------------------------
2393 
2395  INLINE civector operator *(const civector &rv, const complex &s) throw();
2397  INLINE civector operator *(const civector_slice &sl, const complex &s) throw();
2399  INLINE civector operator *(const complex &s, const civector &rv) throw();
2401  INLINE civector operator *(const complex &s, const civector_slice &sl) throw();
2403  INLINE civector &operator *=(civector &rv,const complex &r) throw();
2404 
2406  INLINE civector operator /(const civector &rv, const complex &s) throw();
2408  INLINE civector operator /(const civector_slice &sl, const complex &s) throw();
2410  INLINE civector &operator /=(civector &rv,const complex &r) throw();
2411 
2413  INLINE civector operator *(const cvector &rv, const cinterval &s) throw();
2415  INLINE civector operator *(const cvector_slice &sl, const cinterval &s) throw();
2417  INLINE civector operator *(const cinterval &s, const cvector &rv) throw();
2419  INLINE civector operator *(const cinterval &s, const cvector_slice &sl) throw();
2420 
2422  INLINE civector operator /(const cvector &rv, const cinterval &s) throw();
2424  INLINE civector operator /(const cvector_slice &sl, const cinterval &s) throw();
2425 
2426 //---------------------------- interval --------------------------------------
2427 
2429  INLINE civector operator *(const civector &rv, const interval &s) throw();
2431  INLINE civector operator *(const civector_slice &sl, const interval &s) throw();
2433  INLINE civector operator *(const interval &s, const civector &rv) throw();
2435  INLINE civector operator *(const interval &s, const civector_slice &sl) throw();
2437  INLINE civector &operator *=(civector &rv,const interval &r) throw();
2438 
2440  INLINE civector operator /(const civector &rv, const interval &s) throw();
2442  INLINE civector operator /(const civector_slice &sl, const interval &s) throw();
2444  INLINE civector &operator /=(civector &rv,const interval &r) throw();
2445 
2447  INLINE civector operator *(const ivector &rv, const cinterval &s) throw();
2449  INLINE civector operator *(const ivector_slice &sl, const cinterval &s) throw();
2451  INLINE civector operator *(const cinterval &s, const ivector &rv) throw();
2453  INLINE civector operator *(const cinterval &s, const ivector_slice &sl) throw();
2454 
2456  INLINE civector operator /(const ivector &rv, const cinterval &s) throw();
2458  INLINE civector operator /(const ivector_slice &sl, const cinterval &s) throw();
2459 
2460 //======================= Vector / Vector ===============================
2461 
2462 
2464  INLINE std::ostream &operator <<(std::ostream &s, const civector &rv) throw();
2466  INLINE std::ostream &operator <<(std::ostream &o, const civector_slice &sl) throw();
2468  INLINE std::istream &operator >>(std::istream &s, civector &rv) throw();
2470  INLINE std::istream &operator >>(std::istream &s, civector_slice &rv) throw();
2471 
2472 //----------------------- cinterval / cinterval ---------------------------
2473 
2475  void accumulate(cidotprecision &dp, const cvector &);
2476 
2478  void accumulate(cidotprecision &dp, const rvector &);
2479 
2481  void accumulate(cidotprecision &dp, const civector &);
2482 
2484  void accumulate(cidotprecision &dp, const ivector &);
2485 
2486 
2488  void accumulate(cidotprecision &dp, const civector & rv1, const civector &rv2)
2489 #if(CXSC_INDEX_CHECK)
2490  throw(OP_WITH_WRONG_DIM);
2491 #else
2492  throw();
2493 #endif
2494  void accumulate(cidotprecision &dp, const civector_slice & sl, const civector &rv)
2496 #if(CXSC_INDEX_CHECK)
2497  throw(OP_WITH_WRONG_DIM);
2498 #else
2499  throw();
2500 #endif
2501  void accumulate(cidotprecision &dp, const civector &rv, const civector_slice &sl)
2503 #if(CXSC_INDEX_CHECK)
2504  throw(OP_WITH_WRONG_DIM);
2505 #else
2506  throw();
2507 #endif
2508  void accumulate(cidotprecision &dp, const civector & rv1, const cimatrix_subv &rv2)
2510 #if(CXSC_INDEX_CHECK)
2511  throw(OP_WITH_WRONG_DIM);
2512 #else
2513  throw();
2514 #endif
2515  void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const civector &rv2)
2517 #if(CXSC_INDEX_CHECK)
2518  throw(OP_WITH_WRONG_DIM);
2519 #else
2520  throw();
2521 #endif
2522  void accumulate(cidotprecision &dp, const civector_slice & sl1, const civector_slice &sl2)
2524 #if(CXSC_INDEX_CHECK)
2525  throw(OP_WITH_WRONG_DIM);
2526 #else
2527  throw();
2528 #endif
2529  void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const cvector &rv2)
2531 #if(CXSC_INDEX_CHECK)
2532  throw(OP_WITH_WRONG_DIM);
2533 #else
2534  throw();
2535 #endif
2536  void accumulate(cidotprecision &dp, const cvector & rv1, const imatrix_subv &rv2)
2538 #if(CXSC_INDEX_CHECK)
2539  throw(OP_WITH_WRONG_DIM);
2540 #else
2541  throw();
2542 #endif
2543  void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const cvector_slice &rv2)
2545 #if(CXSC_INDEX_CHECK)
2546  throw(OP_WITH_WRONG_DIM);
2547 #else
2548  throw();
2549 #endif
2550  void accumulate(cidotprecision &dp, const cvector_slice & rv1, const imatrix_subv &rv2)
2552 #if(CXSC_INDEX_CHECK)
2553  throw(OP_WITH_WRONG_DIM);
2554 #else
2555  throw();
2556 #endif
2557 
2559  INLINE cinterval operator *(const civector & rv1, const civector &rv2)
2560 #if(CXSC_INDEX_CHECK)
2561  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2562 #else
2563  throw();
2564 #endif
2565  INLINE cinterval operator *(const civector_slice &sl, const civector &rv)
2567 #if(CXSC_INDEX_CHECK)
2568  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2569 #else
2570  throw();
2571 #endif
2572  INLINE cinterval operator *(const civector &rv, const civector_slice &sl)
2574 #if(CXSC_INDEX_CHECK)
2575  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2576 #else
2577  throw();
2578 #endif
2579  INLINE cinterval operator *(const civector_slice & sl1, const civector_slice &sl2)
2581 #if(CXSC_INDEX_CHECK)
2582  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2583 #else
2584  throw();
2585 #endif
2586 
2588  INLINE const civector &operator +(const civector &rv) throw();
2590  INLINE civector operator +(const civector_slice &sl) throw();
2591 
2593  INLINE civector operator +(const civector &rv1, const civector &rv2)
2594 #if(CXSC_INDEX_CHECK)
2595  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2596 #else
2597  throw();
2598 #endif
2599  INLINE civector operator +(const civector &rv, const civector_slice &sl)
2601 #if(CXSC_INDEX_CHECK)
2602  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2603 #else
2604  throw();
2605 #endif
2606  INLINE civector operator +(const civector_slice &sl, const civector &rv)
2608 #if(CXSC_INDEX_CHECK)
2609  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2610 #else
2611  throw();
2612 #endif
2613  INLINE civector operator +(const civector_slice &sl1, const civector_slice &sl2)
2615 #if(CXSC_INDEX_CHECK)
2616  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2617 #else
2618  throw();
2619 #endif
2620  INLINE civector & operator +=(civector &rv1, const civector &rv2)
2622 #if(CXSC_INDEX_CHECK)
2623  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2624 #else
2625  throw();
2626 #endif
2627  INLINE civector &operator +=(civector &rv, const civector_slice &sl)
2629 #if(CXSC_INDEX_CHECK)
2630  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2631 #else
2632  throw();
2633 #endif
2634 
2636  INLINE civector operator -(const civector &rv) throw();
2638  INLINE civector operator -(const civector_slice &sl) throw();
2640  INLINE civector operator -(const civector &rv1, const civector &rv2)
2641 #if(CXSC_INDEX_CHECK)
2642  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2643 #else
2644  throw();
2645 #endif
2646  INLINE civector operator -(const civector &rv, const civector_slice &sl)
2648 #if(CXSC_INDEX_CHECK)
2649  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2650 #else
2651  throw();
2652 #endif
2653  INLINE civector operator -(const civector_slice &sl, const civector &rv)
2655 #if(CXSC_INDEX_CHECK)
2656  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2657 #else
2658  throw();
2659 #endif
2660  INLINE civector operator -(const civector_slice &sl1, const civector_slice &sl2)
2662 #if(CXSC_INDEX_CHECK)
2663  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2664 #else
2665  throw();
2666 #endif
2667  INLINE civector & operator -=(civector &rv1, const civector &rv2)
2669 #if(CXSC_INDEX_CHECK)
2670  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2671 #else
2672  throw();
2673 #endif
2674  INLINE civector &operator -=(civector &rv, const civector_slice &sl)
2676 #if(CXSC_INDEX_CHECK)
2677  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2678 #else
2679  throw();
2680 #endif
2681 
2683  INLINE civector operator |(const civector &rv1, const civector &rv2)
2684 #if(CXSC_INDEX_CHECK)
2685  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2686 #else
2687  throw();
2688 #endif
2689  INLINE civector operator |(const civector &rv, const civector_slice &sl)
2691 #if(CXSC_INDEX_CHECK)
2692  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2693 #else
2694  throw();
2695 #endif
2696  INLINE civector operator |(const civector_slice &sl, const civector &rv)
2698 #if(CXSC_INDEX_CHECK)
2699  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2700 #else
2701  throw();
2702 #endif
2703  INLINE civector operator |(const civector_slice &sl1, const civector_slice &sl2)
2705 #if(CXSC_INDEX_CHECK)
2706  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2707 #else
2708  throw();
2709 #endif
2710  INLINE civector & operator |=(civector &rv1, const civector &rv2)
2712 #if(CXSC_INDEX_CHECK)
2713  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2714 #else
2715  throw();
2716 #endif
2717  INLINE civector &operator |=(civector &rv, const civector_slice &sl)
2719 #if(CXSC_INDEX_CHECK)
2720  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2721 #else
2722  throw();
2723 #endif
2724 
2726  INLINE civector operator &(const civector &rv1, const civector &rv2)
2727 #if(CXSC_INDEX_CHECK)
2728  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2729 #else
2730  throw();
2731 #endif
2732  INLINE civector operator &(const civector &rv, const civector_slice &sl)
2734 #if(CXSC_INDEX_CHECK)
2735  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2736 #else
2737  throw();
2738 #endif
2739  INLINE civector operator &(const civector_slice &sl, const civector &rv)
2741 #if(CXSC_INDEX_CHECK)
2742  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2743 #else
2744  throw();
2745 #endif
2746  INLINE civector operator &(const civector_slice &sl1, const civector_slice &sl2)
2748 #if(CXSC_INDEX_CHECK)
2749  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2750 #else
2751  throw();
2752 #endif
2753  INLINE civector & operator &=(civector &rv1, const civector &rv2)
2755 #if(CXSC_INDEX_CHECK)
2756  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2757 #else
2758  throw();
2759 #endif
2760  INLINE civector &operator &=(civector &rv, const civector_slice &sl)
2762 #if(CXSC_INDEX_CHECK)
2763  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2764 #else
2765  throw();
2766 #endif
2767 
2769  INLINE bool operator ==(const civector &rv1, const civector &rv2) throw();
2771  INLINE bool operator ==(const civector_slice &sl1, const civector_slice &sl2) throw();
2773  INLINE bool operator ==(const civector_slice &sl, const civector &rv) throw();
2775  INLINE bool operator ==(const civector &rv, const civector_slice &sl) throw();
2777  INLINE bool operator !=(const civector &rv1, const civector &rv2) throw();
2779  INLINE bool operator !=(const civector_slice &sl1, const civector_slice &sl2) throw();
2781  INLINE bool operator !=(const civector_slice &sl, const civector &rv) throw();
2783  INLINE bool operator !=(const civector &rv, const civector_slice &sl) throw();
2785  INLINE bool operator <(const civector &rv1, const civector &rv2) throw();
2787  INLINE bool operator <(const civector_slice &sl1, const civector_slice &sl2) throw();
2789  INLINE bool operator < (const civector_slice &sl, const civector &rv) throw();
2791  INLINE bool operator < (const civector &rv, const civector_slice &sl) throw();
2793  INLINE bool operator <=(const civector &rv1, const civector &rv2) throw();
2795  INLINE bool operator <=(const civector_slice &sl1, const civector_slice &sl2) throw();
2797  INLINE bool operator <=(const civector_slice &sl, const civector &rv) throw();
2799  INLINE bool operator <=(const civector &rv, const civector_slice &sl) throw();
2801  INLINE bool operator >(const civector &rv1, const civector &rv2) throw();
2803  INLINE bool operator >(const civector_slice &sl1, const civector_slice &sl2) throw();
2805  INLINE bool operator >(const civector_slice &sl, const civector &rv) throw();
2807  INLINE bool operator >(const civector &rv, const civector_slice &sl) throw();
2809  INLINE bool operator >=(const civector &rv1, const civector &rv2) throw();
2811  INLINE bool operator >=(const civector_slice &sl1, const civector_slice &sl2) throw();
2813  INLINE bool operator >=(const civector_slice &sl, const civector &rv) throw();
2815  INLINE bool operator >=(const civector &rv, const civector_slice &sl) throw();
2816 
2817 //-------------------------------- cinterval / Real --------------------------------
2818 
2820  void accumulate(cidotprecision &dp, const rvector & rv1, const civector &rv2)
2821 #if(CXSC_INDEX_CHECK)
2822  throw(OP_WITH_WRONG_DIM);
2823 #else
2824  throw();
2825 #endif
2826  void accumulate(cidotprecision &dp, const civector & rv1, const rvector &rv2)
2828 #if(CXSC_INDEX_CHECK)
2829  throw(OP_WITH_WRONG_DIM);
2830 #else
2831  throw();
2832 #endif
2833  void accumulate(cidotprecision &dp, const rvector_slice & sl, const civector &rv)
2835 #if(CXSC_INDEX_CHECK)
2836  throw(OP_WITH_WRONG_DIM);
2837 #else
2838  throw();
2839 #endif
2840  void accumulate(cidotprecision &dp,const civector_slice &sl,const rvector &rv)
2842 #if(CXSC_INDEX_CHECK)
2843  throw(OP_WITH_WRONG_DIM);
2844 #else
2845  throw();
2846 #endif
2847  void accumulate(cidotprecision &dp, const rvector &rv, const civector_slice &sl)
2849 #if(CXSC_INDEX_CHECK)
2850  throw(OP_WITH_WRONG_DIM);
2851 #else
2852  throw();
2853 #endif
2854  void accumulate(cidotprecision &dp, const rvector & rv1, const cimatrix_subv &rv2)
2856 #if(CXSC_INDEX_CHECK)
2857  throw(OP_WITH_WRONG_DIM);
2858 #else
2859  throw();
2860 #endif
2861  void accumulate(cidotprecision &dp, const civector & rv1, const rmatrix_subv &rv2)
2863 #if(CXSC_INDEX_CHECK)
2864  throw(OP_WITH_WRONG_DIM);
2865 #else
2866  throw();
2867 #endif
2868  void accumulate(cidotprecision &dp,const civector &rv,const rvector_slice &sl)
2870 #if(CXSC_INDEX_CHECK)
2871  throw(OP_WITH_WRONG_DIM);
2872 #else
2873  throw();
2874 #endif
2875  void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const civector &rv2)
2877 #if(CXSC_INDEX_CHECK)
2878  throw(OP_WITH_WRONG_DIM);
2879 #else
2880  throw();
2881 #endif
2882  void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const rvector &rv2)
2884 #if(CXSC_INDEX_CHECK)
2885  throw(OP_WITH_WRONG_DIM);
2886 #else
2887  throw();
2888 #endif
2889  void accumulate(cidotprecision &dp, const civector_slice & sl1, const rvector_slice &sl2)
2891 #if(CXSC_INDEX_CHECK)
2892  throw(OP_WITH_WRONG_DIM);
2893 #else
2894  throw();
2895 #endif
2896  void accumulate(cidotprecision &dp, const rvector_slice & sl1, const civector_slice &sl2)
2898 #if(CXSC_INDEX_CHECK)
2899  throw(OP_WITH_WRONG_DIM);
2900 #else
2901  throw();
2902 #endif
2903 
2905  INLINE cinterval operator *(const rvector & rv1, const civector &rv2)
2906 #if(CXSC_INDEX_CHECK)
2907  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2908 #else
2909  throw();
2910 #endif
2911  INLINE cinterval operator *(const rvector_slice &sl, const civector &rv)
2913 #if(CXSC_INDEX_CHECK)
2914  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2915 #else
2916  throw();
2917 #endif
2918  INLINE cinterval operator *(const rvector &rv, const civector_slice &sl)
2920 #if(CXSC_INDEX_CHECK)
2921  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2922 #else
2923  throw();
2924 #endif
2925  INLINE cinterval operator *(const rvector_slice & sl1, const civector_slice &sl2)
2927 #if(CXSC_INDEX_CHECK)
2928  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2929 #else
2930  throw();
2931 #endif
2932 
2934  INLINE cinterval operator *(const civector & rv1, const rvector &rv2)
2935 #if(CXSC_INDEX_CHECK)
2936  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2937 #else
2938  throw();
2939 #endif
2940  INLINE cinterval operator *(const civector_slice &sl, const rvector &rv)
2942 #if(CXSC_INDEX_CHECK)
2943  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2944 #else
2945  throw();
2946 #endif
2947  INLINE cinterval operator *(const civector &rv, const rvector_slice &sl)
2949 #if(CXSC_INDEX_CHECK)
2950  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2951 #else
2952  throw();
2953 #endif
2954  INLINE cinterval operator *(const civector_slice & sl1, const rvector_slice &sl2)
2956 #if(CXSC_INDEX_CHECK)
2957  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2958 #else
2959  throw();
2960 #endif
2961 
2963  INLINE civector operator +(const rvector &rv1, const civector &rv2)
2964 #if(CXSC_INDEX_CHECK)
2965  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2966 #else
2967  throw();
2968 #endif
2969  INLINE civector operator +(const rvector &rv, const civector_slice &sl)
2971 #if(CXSC_INDEX_CHECK)
2972  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2973 #else
2974  throw();
2975 #endif
2976  INLINE civector operator +(const rvector_slice &sl, const civector &rv)
2978 #if(CXSC_INDEX_CHECK)
2979  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2980 #else
2981  throw();
2982 #endif
2983  INLINE civector operator +(const rvector_slice &sl1, const civector_slice &sl2)
2985 #if(CXSC_INDEX_CHECK)
2986  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2987 #else
2988  throw();
2989 #endif
2990 
2992  INLINE civector operator +(const civector &rv1, const rvector &rv2)
2993 #if(CXSC_INDEX_CHECK)
2994  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
2995 #else
2996  throw();
2997 #endif
2998  INLINE civector operator +(const civector &rv, const rvector_slice &sl)
3000 #if(CXSC_INDEX_CHECK)
3001  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3002 #else
3003  throw();
3004 #endif
3005  INLINE civector operator +(const civector_slice &sl, const rvector &rv)
3007 #if(CXSC_INDEX_CHECK)
3008  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3009 #else
3010  throw();
3011 #endif
3012  INLINE civector operator +(const civector_slice &sl1, const rvector_slice &sl2)
3014 #if(CXSC_INDEX_CHECK)
3015  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3016 #else
3017  throw();
3018 #endif
3019 
3021  INLINE civector & operator +=(civector &rv1, const rvector &rv2)
3022 #if(CXSC_INDEX_CHECK)
3023  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3024 #else
3025  throw();
3026 #endif
3027  INLINE civector &operator +=(civector &rv, const rvector_slice &sl)
3029 #if(CXSC_INDEX_CHECK)
3030  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3031 #else
3032  throw();
3033 #endif
3034 
3036  INLINE civector operator -(const rvector &rv1, const civector &rv2)
3037 #if(CXSC_INDEX_CHECK)
3038  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3039 #else
3040  throw();
3041 #endif
3042  INLINE civector operator -(const rvector &rv, const civector_slice &sl)
3044 #if(CXSC_INDEX_CHECK)
3045  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3046 #else
3047  throw();
3048 #endif
3049  INLINE civector operator -(const rvector_slice &sl, const civector &rv)
3051 #if(CXSC_INDEX_CHECK)
3052  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3053 #else
3054  throw();
3055 #endif
3056  INLINE civector operator -(const rvector_slice &sl1, const civector_slice &sl2)
3058 #if(CXSC_INDEX_CHECK)
3059  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3060 #else
3061  throw();
3062 #endif
3063 
3065  INLINE civector operator -(const civector &rv1, const rvector &rv2)
3066 #if(CXSC_INDEX_CHECK)
3067  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3068 #else
3069  throw();
3070 #endif
3071  INLINE civector operator -(const civector &rv, const rvector_slice &sl)
3073 #if(CXSC_INDEX_CHECK)
3074  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3075 #else
3076  throw();
3077 #endif
3078  INLINE civector operator -(const civector_slice &sl, const rvector &rv)
3080 #if(CXSC_INDEX_CHECK)
3081  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3082 #else
3083  throw();
3084 #endif
3085  INLINE civector operator -(const civector_slice &sl1, const rvector_slice &sl2)
3087 #if(CXSC_INDEX_CHECK)
3088  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3089 #else
3090  throw();
3091 #endif
3092 
3094  INLINE civector & operator -=(civector &rv1, const rvector &rv2)
3095 #if(CXSC_INDEX_CHECK)
3096  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3097 #else
3098  throw();
3099 #endif
3100  INLINE civector &operator -=(civector &rv, const rvector_slice &sl)
3102 #if(CXSC_INDEX_CHECK)
3103  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3104 #else
3105  throw();
3106 #endif
3107 
3109  INLINE civector operator |(const rvector &rv1, const civector &rv2)
3110 #if(CXSC_INDEX_CHECK)
3111  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3112 #else
3113  throw();
3114 #endif
3115  INLINE civector operator |(const rvector &rv, const civector_slice &sl)
3117 #if(CXSC_INDEX_CHECK)
3118  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3119 #else
3120  throw();
3121 #endif
3122  INLINE civector operator |(const rvector_slice &sl, const civector &rv)
3124 #if(CXSC_INDEX_CHECK)
3125  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3126 #else
3127  throw();
3128 #endif
3129  INLINE civector operator |(const rvector_slice &sl1, const civector_slice &sl2)
3131 #if(CXSC_INDEX_CHECK)
3132  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3133 #else
3134  throw();
3135 #endif
3136 
3138  INLINE civector operator |(const civector &rv1, const rvector &rv2)
3139 #if(CXSC_INDEX_CHECK)
3140  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3141 #else
3142  throw();
3143 #endif
3144  INLINE civector operator |(const civector &rv, const rvector_slice &sl)
3146 #if(CXSC_INDEX_CHECK)
3147  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3148 #else
3149  throw();
3150 #endif
3151  INLINE civector operator |(const civector_slice &sl, const rvector &rv)
3153 #if(CXSC_INDEX_CHECK)
3154  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3155 #else
3156  throw();
3157 #endif
3158  INLINE civector operator |(const civector_slice &sl1, const rvector_slice &sl2)
3160 #if(CXSC_INDEX_CHECK)
3161  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3162 #else
3163  throw();
3164 #endif
3165 
3167  INLINE civector & operator |=(civector &rv1, const rvector &rv2)
3168 #if(CXSC_INDEX_CHECK)
3169  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3170 #else
3171  throw();
3172 #endif
3173  INLINE civector &operator |=(civector &rv, const rvector_slice &sl)
3175 #if(CXSC_INDEX_CHECK)
3176  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3177 #else
3178  throw();
3179 #endif
3180 
3182  INLINE civector operator &(const rvector &rv1, const civector &rv2)
3183 #if(CXSC_INDEX_CHECK)
3184  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3185 #else
3186  throw();
3187 #endif
3188  INLINE civector operator &(const rvector &rv, const civector_slice &sl)
3190 #if(CXSC_INDEX_CHECK)
3191  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3192 #else
3193  throw();
3194 #endif
3195  INLINE civector operator &(const rvector_slice &sl, const civector &rv)
3197 #if(CXSC_INDEX_CHECK)
3198  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3199 #else
3200  throw();
3201 #endif
3202  INLINE civector operator &(const rvector_slice &sl1, const civector_slice &sl2)
3204 #if(CXSC_INDEX_CHECK)
3205  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3206 #else
3207  throw();
3208 #endif
3209 
3211  INLINE civector operator &(const civector &rv1, const rvector &rv2)
3212 #if(CXSC_INDEX_CHECK)
3213  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3214 #else
3215  throw();
3216 #endif
3217  INLINE civector operator &(const civector &rv, const rvector_slice &sl)
3219 #if(CXSC_INDEX_CHECK)
3220  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3221 #else
3222  throw();
3223 #endif
3224  INLINE civector operator &(const civector_slice &sl, const rvector &rv)
3226 #if(CXSC_INDEX_CHECK)
3227  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3228 #else
3229  throw();
3230 #endif
3231  INLINE civector operator &(const civector_slice &sl1, const rvector_slice &sl2)
3233 #if(CXSC_INDEX_CHECK)
3234  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3235 #else
3236  throw();
3237 #endif
3238 
3240  INLINE civector & operator &=(civector &rv1, const rvector &rv2)
3241 #if(CXSC_INDEX_CHECK)
3242  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3243 #else
3244  throw();
3245 #endif
3246  INLINE civector &operator &=(civector &rv, const rvector_slice &sl)
3248 #if(CXSC_INDEX_CHECK)
3249  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3250 #else
3251  throw();
3252 #endif
3253 //-------------------------------- cinterval / complex --------------------------------
3254 
3256  void accumulate(cidotprecision &dp, const cvector & rv1, const civector &rv2)
3257 #if(CXSC_INDEX_CHECK)
3258  throw(OP_WITH_WRONG_DIM);
3259 #else
3260  throw();
3261 #endif
3262  void accumulate(cidotprecision &dp, const civector & rv1, const cvector &rv2)
3264 #if(CXSC_INDEX_CHECK)
3265  throw(OP_WITH_WRONG_DIM);
3266 #else
3267  throw();
3268 #endif
3269  void accumulate(cidotprecision &dp, const cvector_slice & sl, const civector &rv)
3271 #if(CXSC_INDEX_CHECK)
3272  throw(OP_WITH_WRONG_DIM);
3273 #else
3274  throw();
3275 #endif
3276  void accumulate(cidotprecision &dp,const civector_slice &sl,const cvector &rv)
3278 #if(CXSC_INDEX_CHECK)
3279  throw(OP_WITH_WRONG_DIM);
3280 #else
3281  throw();
3282 #endif
3283  void accumulate(cidotprecision &dp, const cvector &rv, const civector_slice &sl)
3285 #if(CXSC_INDEX_CHECK)
3286  throw(OP_WITH_WRONG_DIM);
3287 #else
3288  throw();
3289 #endif
3290  void accumulate(cidotprecision &dp, const cvector & rv1, const cimatrix_subv &rv2)
3292 #if(CXSC_INDEX_CHECK)
3293  throw(OP_WITH_WRONG_DIM);
3294 #else
3295  throw();
3296 #endif
3297  void accumulate(cidotprecision &dp, const civector & rv1, const cmatrix_subv &rv2)
3299 #if(CXSC_INDEX_CHECK)
3300  throw(OP_WITH_WRONG_DIM);
3301 #else
3302  throw();
3303 #endif
3304  void accumulate(cidotprecision &dp,const civector &rv,const cvector_slice &sl)
3306 #if(CXSC_INDEX_CHECK)
3307  throw(OP_WITH_WRONG_DIM);
3308 #else
3309  throw();
3310 #endif
3311  void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const civector &rv2)
3313 #if(CXSC_INDEX_CHECK)
3314  throw(OP_WITH_WRONG_DIM);
3315 #else
3316  throw();
3317 #endif
3318  void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const cvector &rv2)
3320 #if(CXSC_INDEX_CHECK)
3321  throw(OP_WITH_WRONG_DIM);
3322 #else
3323  throw();
3324 #endif
3325  void accumulate(cidotprecision &dp, const civector_slice & sl1, const cvector_slice &sl2)
3327 #if(CXSC_INDEX_CHECK)
3328  throw(OP_WITH_WRONG_DIM);
3329 #else
3330  throw();
3331 #endif
3332  void accumulate(cidotprecision &dp, const cvector_slice & sl1, const civector_slice &sl2)
3334 #if(CXSC_INDEX_CHECK)
3335  throw(OP_WITH_WRONG_DIM);
3336 #else
3337  throw();
3338 #endif
3339 
3340 
3341 
3342 
3344  INLINE cinterval operator *(const cvector & rv1, const civector &rv2)
3345 #if(CXSC_INDEX_CHECK)
3346  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3347 #else
3348  throw();
3349 #endif
3350  INLINE cinterval operator *(const cvector_slice &sl, const civector &rv)
3352 #if(CXSC_INDEX_CHECK)
3353  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3354 #else
3355  throw();
3356 #endif
3357  INLINE cinterval operator *(const cvector &rv, const civector_slice &sl)
3359 #if(CXSC_INDEX_CHECK)
3360  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3361 #else
3362  throw();
3363 #endif
3364  INLINE cinterval operator *(const cvector_slice & sl1, const civector_slice &sl2)
3366 #if(CXSC_INDEX_CHECK)
3367  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3368 #else
3369  throw();
3370 #endif
3371 
3373  INLINE cinterval operator *(const civector & rv1, const cvector &rv2)
3374 #if(CXSC_INDEX_CHECK)
3375  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3376 #else
3377  throw();
3378 #endif
3379  INLINE cinterval operator *(const civector_slice &sl, const cvector &rv)
3381 #if(CXSC_INDEX_CHECK)
3382  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3383 #else
3384  throw();
3385 #endif
3386  INLINE cinterval operator *(const civector &rv, const cvector_slice &sl)
3388 #if(CXSC_INDEX_CHECK)
3389  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3390 #else
3391  throw();
3392 #endif
3393  INLINE cinterval operator *(const civector_slice & sl1, const cvector_slice &sl2)
3395 #if(CXSC_INDEX_CHECK)
3396  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3397 #else
3398  throw();
3399 #endif
3400 
3402  INLINE civector operator +(const cvector &rv1, const civector &rv2)
3403 #if(CXSC_INDEX_CHECK)
3404  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3405 #else
3406  throw();
3407 #endif
3408  INLINE civector operator +(const cvector &rv, const civector_slice &sl)
3410 #if(CXSC_INDEX_CHECK)
3411  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3412 #else
3413  throw();
3414 #endif
3415  INLINE civector operator +(const cvector_slice &sl, const civector &rv)
3417 #if(CXSC_INDEX_CHECK)
3418  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3419 #else
3420  throw();
3421 #endif
3422  INLINE civector operator +(const cvector_slice &sl1, const civector_slice &sl2)
3424 #if(CXSC_INDEX_CHECK)
3425  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3426 #else
3427  throw();
3428 #endif
3429 
3431  INLINE civector operator +(const civector &rv1, const cvector &rv2)
3432 #if(CXSC_INDEX_CHECK)
3433  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3434 #else
3435  throw();
3436 #endif
3437  INLINE civector operator +(const civector &rv, const cvector_slice &sl)
3439 #if(CXSC_INDEX_CHECK)
3440  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3441 #else
3442  throw();
3443 #endif
3444  INLINE civector operator +(const civector_slice &sl, const cvector &rv)
3446 #if(CXSC_INDEX_CHECK)
3447  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3448 #else
3449  throw();
3450 #endif
3451  INLINE civector operator +(const civector_slice &sl1, const cvector_slice &sl2)
3453 #if(CXSC_INDEX_CHECK)
3454  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3455 #else
3456  throw();
3457 #endif
3458 
3460  INLINE civector & operator +=(civector &rv1, const cvector &rv2)
3461 #if(CXSC_INDEX_CHECK)
3462  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3463 #else
3464  throw();
3465 #endif
3466  INLINE civector &operator +=(civector &rv, const cvector_slice &sl)
3468 #if(CXSC_INDEX_CHECK)
3469  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3470 #else
3471  throw();
3472 #endif
3473 
3475  INLINE civector operator -(const cvector &rv1, const civector &rv2)
3476 #if(CXSC_INDEX_CHECK)
3477  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3478 #else
3479  throw();
3480 #endif
3481  INLINE civector operator -(const cvector &rv, const civector_slice &sl)
3483 #if(CXSC_INDEX_CHECK)
3484  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3485 #else
3486  throw();
3487 #endif
3488  INLINE civector operator -(const cvector_slice &sl, const civector &rv)
3490 #if(CXSC_INDEX_CHECK)
3491  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3492 #else
3493  throw();
3494 #endif
3495  INLINE civector operator -(const cvector_slice &sl1, const civector_slice &sl2)
3497 #if(CXSC_INDEX_CHECK)
3498  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3499 #else
3500  throw();
3501 #endif
3502 
3504  INLINE civector operator -(const civector &rv1, const cvector &rv2)
3505 #if(CXSC_INDEX_CHECK)
3506  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3507 #else
3508  throw();
3509 #endif
3510  INLINE civector operator -(const civector &rv, const cvector_slice &sl)
3512 #if(CXSC_INDEX_CHECK)
3513  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3514 #else
3515  throw();
3516 #endif
3517  INLINE civector operator -(const civector_slice &sl, const cvector &rv)
3519 #if(CXSC_INDEX_CHECK)
3520  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3521 #else
3522  throw();
3523 #endif
3524  INLINE civector operator -(const civector_slice &sl1, const cvector_slice &sl2)
3526 #if(CXSC_INDEX_CHECK)
3527  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3528 #else
3529  throw();
3530 #endif
3531 
3533  INLINE civector & operator -=(civector &rv1, const cvector &rv2)
3534 #if(CXSC_INDEX_CHECK)
3535  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3536 #else
3537  throw();
3538 #endif
3539  INLINE civector &operator -=(civector &rv, const cvector_slice &sl)
3541 #if(CXSC_INDEX_CHECK)
3542  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3543 #else
3544  throw();
3545 #endif
3546 
3548  INLINE civector operator |(const cvector &rv1, const civector &rv2)
3549 #if(CXSC_INDEX_CHECK)
3550  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3551 #else
3552  throw();
3553 #endif
3554  INLINE civector operator |(const cvector &rv, const civector_slice &sl)
3556 #if(CXSC_INDEX_CHECK)
3557  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3558 #else
3559  throw();
3560 #endif
3561  INLINE civector operator |(const cvector_slice &sl, const civector &rv)
3563 #if(CXSC_INDEX_CHECK)
3564  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3565 #else
3566  throw();
3567 #endif
3568  INLINE civector operator |(const cvector_slice &sl1, const civector_slice &sl2)
3570 #if(CXSC_INDEX_CHECK)
3571  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3572 #else
3573  throw();
3574 #endif
3575 
3577  INLINE civector operator |(const civector &rv1, const cvector &rv2)
3578 #if(CXSC_INDEX_CHECK)
3579  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3580 #else
3581  throw();
3582 #endif
3583  INLINE civector operator |(const civector &rv, const cvector_slice &sl)
3585 #if(CXSC_INDEX_CHECK)
3586  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3587 #else
3588  throw();
3589 #endif
3590  INLINE civector operator |(const civector_slice &sl, const cvector &rv)
3592 #if(CXSC_INDEX_CHECK)
3593  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3594 #else
3595  throw();
3596 #endif
3597  INLINE civector operator |(const civector_slice &sl1, const cvector_slice &sl2)
3599 #if(CXSC_INDEX_CHECK)
3600  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3601 #else
3602  throw();
3603 #endif
3604 
3606  INLINE civector & operator |=(civector &rv1, const cvector &rv2)
3607 #if(CXSC_INDEX_CHECK)
3608  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3609 #else
3610  throw();
3611 #endif
3612  INLINE civector &operator |=(civector &rv, const cvector_slice &sl)
3614 #if(CXSC_INDEX_CHECK)
3615  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3616 #else
3617  throw();
3618 #endif
3619 
3621  INLINE civector operator &(const cvector &rv1, const civector &rv2)
3622 #if(CXSC_INDEX_CHECK)
3623  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3624 #else
3625  throw();
3626 #endif
3627  INLINE civector operator &(const cvector &rv, const civector_slice &sl)
3629 #if(CXSC_INDEX_CHECK)
3630  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3631 #else
3632  throw();
3633 #endif
3634  INLINE civector operator &(const cvector_slice &sl, const civector &rv)
3636 #if(CXSC_INDEX_CHECK)
3637  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3638 #else
3639  throw();
3640 #endif
3641  INLINE civector operator &(const cvector_slice &sl1, const civector_slice &sl2)
3643 #if(CXSC_INDEX_CHECK)
3644  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3645 #else
3646  throw();
3647 #endif
3648 
3650  INLINE civector operator &(const civector &rv1, const cvector &rv2)
3651 #if(CXSC_INDEX_CHECK)
3652  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3653 #else
3654  throw();
3655 #endif
3656  INLINE civector operator &(const civector &rv, const cvector_slice &sl)
3658 #if(CXSC_INDEX_CHECK)
3659  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3660 #else
3661  throw();
3662 #endif
3663  INLINE civector operator &(const civector_slice &sl, const cvector &rv)
3665 #if(CXSC_INDEX_CHECK)
3666  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3667 #else
3668  throw();
3669 #endif
3670  INLINE civector operator &(const civector_slice &sl1, const cvector_slice &sl2)
3672 #if(CXSC_INDEX_CHECK)
3673  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3674 #else
3675  throw();
3676 #endif
3677 
3679  INLINE civector & operator &=(civector &rv1, const cvector &rv2)
3680 #if(CXSC_INDEX_CHECK)
3681  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3682 #else
3683  throw();
3684 #endif
3685  INLINE civector &operator &=(civector &rv, const cvector_slice &sl)
3687 #if(CXSC_INDEX_CHECK)
3688  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3689 #else
3690  throw();
3691 #endif
3692 
3693 //-------------------------------- cinterval / interval --------------------------------
3694 
3696  void accumulate(cidotprecision &dp, const ivector & rv1, const civector &rv2)
3697 #if(CXSC_INDEX_CHECK)
3698  throw(OP_WITH_WRONG_DIM);
3699 #else
3700  throw();
3701 #endif
3702  void accumulate(cidotprecision &dp, const civector & rv1, const ivector &rv2)
3704 #if(CXSC_INDEX_CHECK)
3705  throw(OP_WITH_WRONG_DIM);
3706 #else
3707  throw();
3708 #endif
3709  void accumulate(cidotprecision &dp, const ivector_slice & sl, const civector &rv)
3711 #if(CXSC_INDEX_CHECK)
3712  throw(OP_WITH_WRONG_DIM);
3713 #else
3714  throw();
3715 #endif
3716  void accumulate(cidotprecision &dp,const civector_slice &sl,const ivector &rv)
3718 #if(CXSC_INDEX_CHECK)
3719  throw(OP_WITH_WRONG_DIM);
3720 #else
3721  throw();
3722 #endif
3723  void accumulate(cidotprecision &dp, const ivector &rv, const civector_slice &sl)
3725 #if(CXSC_INDEX_CHECK)
3726  throw(OP_WITH_WRONG_DIM);
3727 #else
3728  throw();
3729 #endif
3730  void accumulate(cidotprecision &dp, const ivector & rv1, const cimatrix_subv &rv2)
3732 #if(CXSC_INDEX_CHECK)
3733  throw(OP_WITH_WRONG_DIM);
3734 #else
3735  throw();
3736 #endif
3737  void accumulate(cidotprecision &dp, const civector & rv1, const imatrix_subv &rv2)
3739 #if(CXSC_INDEX_CHECK)
3740  throw(OP_WITH_WRONG_DIM);
3741 #else
3742  throw();
3743 #endif
3744  void accumulate(cidotprecision &dp,const civector &rv,const ivector_slice &sl)
3746 #if(CXSC_INDEX_CHECK)
3747  throw(OP_WITH_WRONG_DIM);
3748 #else
3749  throw();
3750 #endif
3751  void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const civector &rv2)
3753 #if(CXSC_INDEX_CHECK)
3754  throw(OP_WITH_WRONG_DIM);
3755 #else
3756  throw();
3757 #endif
3758  void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const ivector &rv2)
3760 #if(CXSC_INDEX_CHECK)
3761  throw(OP_WITH_WRONG_DIM);
3762 #else
3763  throw();
3764 #endif
3765  void accumulate(cidotprecision &dp, const civector_slice & sl1, const ivector_slice &sl2)
3767 #if(CXSC_INDEX_CHECK)
3768  throw(OP_WITH_WRONG_DIM);
3769 #else
3770  throw();
3771 #endif
3772  void accumulate(cidotprecision &dp, const ivector_slice & sl1, const civector_slice &sl2)
3774 #if(CXSC_INDEX_CHECK)
3775  throw(OP_WITH_WRONG_DIM);
3776 #else
3777  throw();
3778 #endif
3779  void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const civector &rv2)
3781 #if(CXSC_INDEX_CHECK)
3782  throw(OP_WITH_WRONG_DIM);
3783 #else
3784  throw();
3785 #endif
3786  void accumulate(cidotprecision &dp, const civector & rv1, const cmatrix_subv &rv2)
3788 #if(CXSC_INDEX_CHECK)
3789  throw(OP_WITH_WRONG_DIM);
3790 #else
3791  throw();
3792 #endif
3793  void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const civector_slice &rv2)
3795 #if(CXSC_INDEX_CHECK)
3796  throw(OP_WITH_WRONG_DIM);
3797 #else
3798  throw();
3799 #endif
3800  void accumulate(cidotprecision &dp, const civector_slice & rv1, const cmatrix_subv &rv2)
3802 #if(CXSC_INDEX_CHECK)
3803  throw(OP_WITH_WRONG_DIM);
3804 #else
3805  throw();
3806 #endif
3807 
3809  void accumulate(cidotprecision &dp, const civector_slice & sl1, const rmatrix_subv &sl2)
3810 #if(CXSC_INDEX_CHECK)
3811  throw(OP_WITH_WRONG_DIM);
3812 #else
3813  throw();
3814 #endif
3815  void accumulate(cidotprecision &dp, const rmatrix_subv & sl1, const civector_slice &sl2)
3817 #if(CXSC_INDEX_CHECK)
3818  throw(OP_WITH_WRONG_DIM);
3819 #else
3820  throw();
3821 #endif
3822 
3824  INLINE cinterval operator *(const ivector & rv1, const civector &rv2)
3825 #if(CXSC_INDEX_CHECK)
3826  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3827 #else
3828  throw();
3829 #endif
3830  INLINE cinterval operator *(const ivector_slice &sl, const civector &rv)
3832 #if(CXSC_INDEX_CHECK)
3833  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3834 #else
3835  throw();
3836 #endif
3837  INLINE cinterval operator *(const ivector &rv, const civector_slice &sl)
3839 #if(CXSC_INDEX_CHECK)
3840  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3841 #else
3842  throw();
3843 #endif
3844  INLINE cinterval operator *(const ivector_slice & sl1, const civector_slice &sl2)
3846 #if(CXSC_INDEX_CHECK)
3847  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3848 #else
3849  throw();
3850 #endif
3851 
3853  INLINE cinterval operator *(const civector & rv1, const ivector &rv2)
3854 #if(CXSC_INDEX_CHECK)
3855  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3856 #else
3857  throw();
3858 #endif
3859  INLINE cinterval operator *(const civector_slice &sl, const ivector &rv)
3861 #if(CXSC_INDEX_CHECK)
3862  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3863 #else
3864  throw();
3865 #endif
3866  INLINE cinterval operator *(const civector &rv, const ivector_slice &sl)
3868 #if(CXSC_INDEX_CHECK)
3869  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3870 #else
3871  throw();
3872 #endif
3873  INLINE cinterval operator *(const civector_slice & sl1, const ivector_slice &sl2)
3875 #if(CXSC_INDEX_CHECK)
3876  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3877 #else
3878  throw();
3879 #endif
3880 
3882  INLINE civector operator +(const ivector &rv1, const civector &rv2)
3883 #if(CXSC_INDEX_CHECK)
3884  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3885 #else
3886  throw();
3887 #endif
3888  INLINE civector operator +(const ivector &rv, const civector_slice &sl)
3890 #if(CXSC_INDEX_CHECK)
3891  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3892 #else
3893  throw();
3894 #endif
3895  INLINE civector operator +(const ivector_slice &sl, const civector &rv)
3897 #if(CXSC_INDEX_CHECK)
3898  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3899 #else
3900  throw();
3901 #endif
3902  INLINE civector operator +(const ivector_slice &sl1, const civector_slice &sl2)
3904 #if(CXSC_INDEX_CHECK)
3905  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3906 #else
3907  throw();
3908 #endif
3909 
3911  INLINE civector operator +(const civector &rv1, const ivector &rv2)
3912 #if(CXSC_INDEX_CHECK)
3913  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3914 #else
3915  throw();
3916 #endif
3917  INLINE civector operator +(const civector &rv, const ivector_slice &sl)
3919 #if(CXSC_INDEX_CHECK)
3920  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3921 #else
3922  throw();
3923 #endif
3924  INLINE civector operator +(const civector_slice &sl, const ivector &rv)
3926 #if(CXSC_INDEX_CHECK)
3927  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3928 #else
3929  throw();
3930 #endif
3931  INLINE civector operator +(const civector_slice &sl1, const ivector_slice &sl2)
3933 #if(CXSC_INDEX_CHECK)
3934  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3935 #else
3936  throw();
3937 #endif
3938 
3940  INLINE civector & operator +=(civector &rv1, const ivector &rv2)
3941 #if(CXSC_INDEX_CHECK)
3942  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3943 #else
3944  throw();
3945 #endif
3946  INLINE civector &operator +=(civector &rv, const ivector_slice &sl)
3948 #if(CXSC_INDEX_CHECK)
3949  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3950 #else
3951  throw();
3952 #endif
3953 
3955  INLINE civector operator -(const ivector &rv1, const civector &rv2)
3956 #if(CXSC_INDEX_CHECK)
3957  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3958 #else
3959  throw();
3960 #endif
3961  INLINE civector operator -(const ivector &rv, const civector_slice &sl)
3963 #if(CXSC_INDEX_CHECK)
3964  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3965 #else
3966  throw();
3967 #endif
3968  INLINE civector operator -(const ivector_slice &sl, const civector &rv)
3970 #if(CXSC_INDEX_CHECK)
3971  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3972 #else
3973  throw();
3974 #endif
3975  INLINE civector operator -(const ivector_slice &sl1, const civector_slice &sl2)
3977 #if(CXSC_INDEX_CHECK)
3978  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3979 #else
3980  throw();
3981 #endif
3982 
3984  INLINE civector operator -(const civector &rv1, const ivector &rv2)
3985 #if(CXSC_INDEX_CHECK)
3986  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3987 #else
3988  throw();
3989 #endif
3990  INLINE civector operator -(const civector &rv, const ivector_slice &sl)
3992 #if(CXSC_INDEX_CHECK)
3993  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
3994 #else
3995  throw();
3996 #endif
3997  INLINE civector operator -(const civector_slice &sl, const ivector &rv)
3999 #if(CXSC_INDEX_CHECK)
4000  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4001 #else
4002  throw();
4003 #endif
4004  INLINE civector operator -(const civector_slice &sl1, const ivector_slice &sl2)
4006 #if(CXSC_INDEX_CHECK)
4007  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4008 #else
4009  throw();
4010 #endif
4011 
4013  INLINE civector & operator -=(civector &rv1, const ivector &rv2)
4014 #if(CXSC_INDEX_CHECK)
4015  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4016 #else
4017  throw();
4018 #endif
4019  INLINE civector &operator -=(civector &rv, const ivector_slice &sl)
4021 #if(CXSC_INDEX_CHECK)
4022  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4023 #else
4024  throw();
4025 #endif
4026 
4028  INLINE civector operator |(const ivector &rv1, const civector &rv2)
4029 #if(CXSC_INDEX_CHECK)
4030  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4031 #else
4032  throw();
4033 #endif
4034  INLINE civector operator |(const ivector &rv, const civector_slice &sl)
4036 #if(CXSC_INDEX_CHECK)
4037  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4038 #else
4039  throw();
4040 #endif
4041  INLINE civector operator |(const ivector_slice &sl, const civector &rv)
4043 #if(CXSC_INDEX_CHECK)
4044  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4045 #else
4046  throw();
4047 #endif
4048  INLINE civector operator |(const ivector_slice &sl1, const civector_slice &sl2)
4050 #if(CXSC_INDEX_CHECK)
4051  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4052 #else
4053  throw();
4054 #endif
4055 
4057  INLINE civector operator |(const civector &rv1, const ivector &rv2)
4058 #if(CXSC_INDEX_CHECK)
4059  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4060 #else
4061  throw();
4062 #endif
4063  INLINE civector operator |(const civector &rv, const ivector_slice &sl)
4065 #if(CXSC_INDEX_CHECK)
4066  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4067 #else
4068  throw();
4069 #endif
4070  INLINE civector operator |(const civector_slice &sl, const ivector &rv)
4072 #if(CXSC_INDEX_CHECK)
4073  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4074 #else
4075  throw();
4076 #endif
4077  INLINE civector operator |(const civector_slice &sl1, const ivector_slice &sl2)
4079 #if(CXSC_INDEX_CHECK)
4080  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4081 #else
4082  throw();
4083 #endif
4084 
4086  INLINE civector & operator |=(civector &rv1, const ivector &rv2)
4087 #if(CXSC_INDEX_CHECK)
4088  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4089 #else
4090  throw();
4091 #endif
4092  INLINE civector &operator |=(civector &rv, const ivector_slice &sl)
4094 #if(CXSC_INDEX_CHECK)
4095  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4096 #else
4097  throw();
4098 #endif
4099 
4101  INLINE civector operator &(const ivector &rv1, const civector &rv2)
4102 #if(CXSC_INDEX_CHECK)
4103  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4104 #else
4105  throw();
4106 #endif
4107  INLINE civector operator &(const ivector &rv, const civector_slice &sl)
4109 #if(CXSC_INDEX_CHECK)
4110  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4111 #else
4112  throw();
4113 #endif
4114  INLINE civector operator &(const ivector_slice &sl, const civector &rv)
4116 #if(CXSC_INDEX_CHECK)
4117  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4118 #else
4119  throw();
4120 #endif
4121  INLINE civector operator &(const ivector_slice &sl1, const civector_slice &sl2)
4123 #if(CXSC_INDEX_CHECK)
4124  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4125 #else
4126  throw();
4127 #endif
4128 
4130  INLINE civector operator &(const civector &rv1, const ivector &rv2)
4131 #if(CXSC_INDEX_CHECK)
4132  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4133 #else
4134  throw();
4135 #endif
4136  INLINE civector operator &(const civector &rv, const ivector_slice &sl)
4138 #if(CXSC_INDEX_CHECK)
4139  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4140 #else
4141  throw();
4142 #endif
4143  INLINE civector operator &(const civector_slice &sl, const ivector &rv)
4145 #if(CXSC_INDEX_CHECK)
4146  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4147 #else
4148  throw();
4149 #endif
4150  INLINE civector operator &(const civector_slice &sl1, const ivector_slice &sl2)
4152 #if(CXSC_INDEX_CHECK)
4153  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4154 #else
4155  throw();
4156 #endif
4157 
4159  INLINE civector & operator &=(civector &rv1, const ivector &rv2)
4160 #if(CXSC_INDEX_CHECK)
4161  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4162 #else
4163  throw();
4164 #endif
4165  INLINE civector &operator &=(civector &rv, const ivector_slice &sl)
4167 #if(CXSC_INDEX_CHECK)
4168  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4169 #else
4170  throw();
4171 #endif
4172 
4173 //------------- real x complex ------------------------
4175  INLINE civector operator |(const rvector &rv1, const cvector &rv2)
4176 #if(CXSC_INDEX_CHECK)
4177  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4178 #else
4179  throw();
4180 #endif
4181  INLINE civector operator |(const cvector &rv1, const rvector &rv2)
4183 #if(CXSC_INDEX_CHECK)
4184  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4185 #else
4186  throw();
4187 #endif
4188  INLINE civector operator |(const cvector &rv, const rvector_slice &sl)
4190 #if(CXSC_INDEX_CHECK)
4191  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4192 #else
4193  throw();
4194 #endif
4195  INLINE civector operator |(const rvector_slice &sl,const cvector &rv)
4197 #if(CXSC_INDEX_CHECK)
4198  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4199 #else
4200  throw();
4201 #endif
4202  INLINE civector operator |(const cvector_slice &sl, const rvector &rv)
4204 #if(CXSC_INDEX_CHECK)
4205  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4206 #else
4207  throw();
4208 #endif
4209  INLINE civector operator |(const rvector &rv,const cvector_slice &sl)
4211 #if(CXSC_INDEX_CHECK)
4212  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4213 #else
4214  throw();
4215 #endif
4216  INLINE civector operator |(const cvector_slice &sl1, const rvector_slice &sl2)
4218 #if(CXSC_INDEX_CHECK)
4219  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4220 #else
4221  throw();
4222 #endif
4223  INLINE civector operator |(const rvector_slice &sl1, const cvector_slice &sl2)
4225 #if(CXSC_INDEX_CHECK)
4226  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4227 #else
4228  throw();
4229 #endif
4230 
4231 //------------- complex x complex ------------------------
4233  INLINE civector operator |(const cvector &rv1, const cvector &rv2)
4234 #if(CXSC_INDEX_CHECK)
4235  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4236 #else
4237  throw();
4238 #endif
4239  INLINE civector operator |(const cvector_slice &sl, const cvector &rv)
4241 #if(CXSC_INDEX_CHECK)
4242  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4243 #else
4244  throw();
4245 #endif
4246  INLINE civector operator |(const cvector &rv,const cvector_slice &sl)
4248 #if(CXSC_INDEX_CHECK)
4249  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4250 #else
4251  throw();
4252 #endif
4253  INLINE civector operator |(const cvector_slice &sl1, const cvector_slice &sl2)
4255 #if(CXSC_INDEX_CHECK)
4256  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4257 #else
4258  throw();
4259 #endif
4260 
4261 //-------------------------------- interval / complex --------------------------------
4262 
4263 // multiplication in iveccvec.hpp
4264 
4266  INLINE civector operator +(const cvector &rv1, const ivector &rv2)
4267 #if(CXSC_INDEX_CHECK)
4268  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4269 #else
4270  throw();
4271 #endif
4272  INLINE civector operator +(const cvector &rv, const ivector_slice &sl)
4274 #if(CXSC_INDEX_CHECK)
4275  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4276 #else
4277  throw();
4278 #endif
4279  INLINE civector operator +(const cvector_slice &sl, const ivector &rv)
4281 #if(CXSC_INDEX_CHECK)
4282  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4283 #else
4284  throw();
4285 #endif
4286  INLINE civector operator +(const cvector_slice &sl1, const ivector_slice &sl2)
4288 #if(CXSC_INDEX_CHECK)
4289  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4290 #else
4291  throw();
4292 #endif
4293 
4295  INLINE civector operator +(const ivector &rv1, const cvector &rv2)
4296 #if(CXSC_INDEX_CHECK)
4297  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4298 #else
4299  throw();
4300 #endif
4301  INLINE civector operator +(const ivector &rv, const cvector_slice &sl)
4303 #if(CXSC_INDEX_CHECK)
4304  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4305 #else
4306  throw();
4307 #endif
4308  INLINE civector operator +(const ivector_slice &sl, const cvector &rv)
4310 #if(CXSC_INDEX_CHECK)
4311  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4312 #else
4313  throw();
4314 #endif
4315  INLINE civector operator +(const ivector_slice &sl1, const cvector_slice &sl2)
4317 #if(CXSC_INDEX_CHECK)
4318  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4319 #else
4320  throw();
4321 #endif
4322 
4323 
4325  INLINE civector operator -(const cvector &rv1, const ivector &rv2)
4326 #if(CXSC_INDEX_CHECK)
4327  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4328 #else
4329  throw();
4330 #endif
4331  INLINE civector operator -(const cvector &rv, const ivector_slice &sl)
4333 #if(CXSC_INDEX_CHECK)
4334  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4335 #else
4336  throw();
4337 #endif
4338  INLINE civector operator -(const cvector_slice &sl, const ivector &rv)
4340 #if(CXSC_INDEX_CHECK)
4341  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4342 #else
4343  throw();
4344 #endif
4345  INLINE civector operator -(const cvector_slice &sl1, const ivector_slice &sl2)
4347 #if(CXSC_INDEX_CHECK)
4348  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4349 #else
4350  throw();
4351 #endif
4352 
4354  INLINE civector operator -(const ivector &rv1, const cvector &rv2)
4355 #if(CXSC_INDEX_CHECK)
4356  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4357 #else
4358  throw();
4359 #endif
4360  INLINE civector operator -(const ivector &rv, const cvector_slice &sl)
4362 #if(CXSC_INDEX_CHECK)
4363  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4364 #else
4365  throw();
4366 #endif
4367  INLINE civector operator -(const ivector_slice &sl, const cvector &rv)
4369 #if(CXSC_INDEX_CHECK)
4370  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4371 #else
4372  throw();
4373 #endif
4374  INLINE civector operator -(const ivector_slice &sl1, const cvector_slice &sl2)
4376 #if(CXSC_INDEX_CHECK)
4377  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4378 #else
4379  throw();
4380 #endif
4381 
4382 
4384  INLINE civector operator |(const cvector &rv1, const ivector &rv2)
4385 #if(CXSC_INDEX_CHECK)
4386  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4387 #else
4388  throw();
4389 #endif
4390  INLINE civector operator |(const cvector &rv, const ivector_slice &sl)
4392 #if(CXSC_INDEX_CHECK)
4393  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4394 #else
4395  throw();
4396 #endif
4397  INLINE civector operator |(const cvector_slice &sl, const ivector &rv)
4399 #if(CXSC_INDEX_CHECK)
4400  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4401 #else
4402  throw();
4403 #endif
4404  INLINE civector operator |(const cvector_slice &sl1, const ivector_slice &sl2)
4406 #if(CXSC_INDEX_CHECK)
4407  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4408 #else
4409  throw();
4410 #endif
4411 
4413  INLINE civector operator |(const ivector &rv1, const cvector &rv2)
4414 #if(CXSC_INDEX_CHECK)
4415  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4416 #else
4417  throw();
4418 #endif
4419  INLINE civector operator |(const ivector &rv, const cvector_slice &sl)
4421 #if(CXSC_INDEX_CHECK)
4422  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4423 #else
4424  throw();
4425 #endif
4426  INLINE civector operator |(const ivector_slice &sl, const cvector &rv)
4428 #if(CXSC_INDEX_CHECK)
4429  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4430 #else
4431  throw();
4432 #endif
4433  INLINE civector operator |(const ivector_slice &sl1, const cvector_slice &sl2)
4435 #if(CXSC_INDEX_CHECK)
4436  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4437 #else
4438  throw();
4439 #endif
4440 
4442  INLINE civector operator &(const cvector &rv1, const ivector &rv2)
4443 #if(CXSC_INDEX_CHECK)
4444  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4445 #else
4446  throw();
4447 #endif
4448  INLINE civector operator &(const cvector &rv, const ivector_slice &sl)
4450 #if(CXSC_INDEX_CHECK)
4451  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4452 #else
4453  throw();
4454 #endif
4455  INLINE civector operator &(const cvector_slice &sl, const ivector &rv)
4457 #if(CXSC_INDEX_CHECK)
4458  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4459 #else
4460  throw();
4461 #endif
4462  INLINE civector operator &(const cvector_slice &sl1, const ivector_slice &sl2)
4464 #if(CXSC_INDEX_CHECK)
4465  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4466 #else
4467  throw();
4468 #endif
4469 
4471  INLINE civector operator &(const ivector &rv1, const cvector &rv2)
4472 #if(CXSC_INDEX_CHECK)
4473  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4474 #else
4475  throw();
4476 #endif
4477  INLINE civector operator &(const ivector &rv, const cvector_slice &sl)
4479 #if(CXSC_INDEX_CHECK)
4480  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4481 #else
4482  throw();
4483 #endif
4484  INLINE civector operator &(const ivector_slice &sl, const cvector &rv)
4486 #if(CXSC_INDEX_CHECK)
4487  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4488 #else
4489  throw();
4490 #endif
4491  INLINE civector operator &(const ivector_slice &sl1, const cvector_slice &sl2)
4493 #if(CXSC_INDEX_CHECK)
4494  throw(ERROR__OP_WITH_WRONG_DIM<civector>);
4495 #else
4496  throw();
4497 #endif
4498 
4500  INLINE bool in(const civector& v1, const civector& v2);
4501 
4502 } // namespace cxsc
4503 
4504 #ifdef _CXSC_INCL_INL
4505 #include "vector.inl"
4506 #include "civector.inl"
4507 #endif
4508 
4509 #ifdef _CXSC_RMATRIX_HPP_INCLUDED
4510 # ifdef _CXSC_INCL_INL
4511 # include "civecrmat.inl"
4512 # else
4513 # include "civecrmat.hpp"
4514 # endif
4515 #endif
4516 
4517 #ifdef _CXSC_CMATRIX_HPP_INCLUDED
4518 # ifdef _CXSC_INCL_INL
4519 # include "civeccmat.inl"
4520 # else
4521 # include "civeccmat.hpp"
4522 # endif
4523 #endif
4524 
4525 #ifdef _CXSC_IMATRIX_HPP_INCLUDED
4526 # ifdef _CXSC_INCL_INL
4527 # include "civecimat.inl"
4528 # else
4529 # include "civecimat.hpp"
4530 # endif
4531 #endif
4532 
4533 #ifdef CXSC_USE_BLAS
4534 #define _CXSC_BLAS_CIVECTOR
4535 #include "cxsc_blas.inl"
4536 #endif
4537 
4538 
4539 #endif
friend rvector InfRe(const civector_slice &v)
Returns the infimum of real part of the vector.
Definition: civector.inl:586
civector_slice(civector &a, const int &lb, const int &ub)
Constructor of class civector_slice.
Definition: civector.hpp:1513
cinterval(void)
Constructor of class cinterval.
Definition: cinterval.hpp:64
The Data Type rmatrix_slice.
Definition: rmatrix.hpp:1442
friend cvector Sup(const civector_slice &v)
Returns the supremum of the vector.
Definition: civector.inl:707
cimatrix & operator/=(cimatrix &m, const cinterval &c)
Implementation of division and allocation operation.
Definition: cimatrix.inl:1623
The Data Type imatrix_subv.
Definition: imatrix.hpp:55
civector_slice & operator-=(const civector &rv)
Implementation of subtraction and allocation operation.
Definition: civector.inl:937
Helper class for slices of sparse vectors.
Definition: scvector.hpp:1245
friend cvector Inf(const civector_slice &v)
Returns the infimum of the vector.
Definition: civector.inl:705
civector_slice & operator=(const scivector_slice &sl)
Implementation of standard assigning operator.
Definition: scivector.hpp:4688
friend int Ub(const civector &rv)
Returns the upper bound of the vector.
Definition: civector.hpp:963
The Data Type intmatrix.
Definition: intmatrix.hpp:313
cimatrix_subv & SetUncheckedInf(cimatrix_subv &iv, const complex &r)
Returns the matrix with the new unchecked given infimum value.
Definition: cimatrix.inl:890
The Data Type cimatrix_subv.
Definition: cimatrix.hpp:67
friend int Lb(const civector_slice &sl)
Returns the lower bound of the vector.
Definition: civector.hpp:1684
The Data Type cimatrix_slice.
Definition: cimatrix.hpp:1650
friend int VecLen(const civector &rv)
Returns the dimension of the vector.
Definition: civector.hpp:965
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
civector operator*(const cimatrix_subv &rv, const cinterval &s)
Implementation of multiplication operation.
Definition: cimatrix.inl:731
cinterval & operator[](const int &i) const
Operator for accessing the single elements of the vector (read-only)
Definition: civector.inl:166
int in(const cinterval &x, const cinterval &y)
Checks if first argument is part of second argument.
Definition: cinterval.cpp:654
friend rvector SupIm(const civector_slice &v)
Returns the supremum of imaginary part of the vector.
Definition: civector.inl:647
cvector mid(const cimatrix_subv &mv)
Returns the middle of the matrix.
Definition: cimatrix.inl:739
The Scalar Type interval.
Definition: interval.hpp:54
The Data Type civector.
Definition: civector.hpp:56
friend int VecLen(const civector_slice &sl)
Returns the size of the vector.
Definition: civector.hpp:1688
A sparse interval vector.
Definition: sivector.hpp:59
civector_slice & operator+=(const civector &rv)
Implementation of addition and allocation operation.
Definition: civector.inl:878
friend int Lb(const civector &rv)
Returns the lower bound of the vector.
Definition: civector.hpp:961
friend cvector Inf(const civector &v)
Returns the infimum of the vector.
Definition: civector.inl:704
A sparse complex interval vector.
Definition: scivector.hpp:62
The Data Type ivector_slice.
Definition: ivector.hpp:962
The Data Type imatrix_slice.
Definition: imatrix.hpp:1441
A sparse real vector.
Definition: srvector.hpp:58
The Data Type rvector_slice.
Definition: rvector.hpp:1063
A sparse complex vector.
Definition: scvector.hpp:58
The Data Type cvector.
Definition: cvector.hpp:57
The Data Type rmatrix_subv.
Definition: rmatrix.hpp:53
The Data Type rvector.
Definition: rvector.hpp:57
friend rvector SupIm(const civector &v)
Returns the supremum of imaginary part of the vector.
Definition: civector.inl:637
The Data Type cmatrix.
Definition: cmatrix.hpp:513
The Scalar Type cinterval.
Definition: cinterval.hpp:54
void Resize(cimatrix &A)
Resizes the matrix.
Definition: cimatrix.inl:1211
Helper class for slices of sparse vectors.
Definition: sivector.hpp:1831
civector_slice(civector_slice &a, const int &lb, const int &ub)
Constructor of class civector_slice.
Definition: civector.hpp:1515
cvector diam(const cimatrix_subv &mv)
Returns the diameter of the matrix.
Definition: cimatrix.inl:738
friend rvector SupRe(const civector_slice &v)
Returns the supremum of real part of the vector.
Definition: civector.inl:669
friend rvector InfIm(const civector_slice &v)
Returns the infimum of imaginary part of the vector.
Definition: civector.inl:626
The Data Type civector_slice.
Definition: civector.hpp:1014
The Data Type rmatrix.
Definition: rmatrix.hpp:470
civector_slice(const civector_slice &a)
Constructor of class civector_slice.
Definition: civector.hpp:1518
The Scalar Type complex.
Definition: complex.hpp:49
cinterval & operator[](const int &i) const
Operator for accessing the single elements of the vector (read-only)
Definition: civector.inl:140
The Data Type cmatrix_subv.
Definition: cmatrix.hpp:53
civector_slice & operator/=(const cinterval &r)
Implementation of division and allocation operation.
Definition: civector.inl:725
The Data Type ivector.
Definition: ivector.hpp:54
friend civector & SetLb(civector &rv, const int &l)
Sets the lower bound of the vector.
Definition: civector.hpp:967
The Data Type cmatrix_slice.
Definition: cmatrix.hpp:1202
friend rvector InfRe(const civector &v)
Returns the infimum of real part of the vector.
Definition: civector.inl:576
civector_slice & operator&=(const civector &rv)
Allocates the intersection of the arguments to the first argument.
friend rvector InfIm(const civector &v)
Returns the infimum of imaginary part of the vector.
Definition: civector.inl:616
civector_slice & operator()()
Operator for accessing the whole vector.
Definition: civector.hpp:1707
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc)
Implementation of standard algebraic addition and allocation operation.
Definition: cdot.inl:251
friend int Ub(const civector_slice &sl)
Returns the upper bound of the vector.
Definition: civector.hpp:1686
civector_slice & operator*=(const cinterval &r)
Implementation of multiplication and allocation operation.
Definition: civector.inl:720
Helper class for slices of sparse vectors.
Definition: scivector.hpp:4063
The Data Type imatrix.
Definition: imatrix.hpp:659
civector()
Constructor of class civector.
Definition: civector.inl:31
Helper class for slices of sparse vectors.
Definition: srvector.hpp:868
friend rvector SupRe(const civector &v)
Returns the supremum of real part of the vector.
Definition: civector.inl:659
civector operator/(const cimatrix_subv &rv, const cinterval &s)
Implementation of division operation.
Definition: cimatrix.inl:730
The Data Type cvector_slice.
Definition: cvector.hpp:844
civector & operator=(const civector &rv)
Implementation of standard assigning operator.
Definition: civector.inl:339
cimatrix & operator*=(cimatrix &m, const cinterval &c)
Implementation of multiplication and allocation operation.
Definition: cimatrix.inl:1605
The Scalar Type real.
Definition: real.hpp:113
civector & operator()()
Operator for accessing the whole vector.
Definition: civector.hpp:987
friend cvector Sup(const civector &v)
Returns the supremum of the vector.
Definition: civector.inl:706
The Data Type intvector.
Definition: intvector.hpp:51
civector_slice & operator|=(const civector &rv)
Allocates the convex hull of the arguments to the first argument.
Definition: civector.inl:994
friend civector & SetUb(civector &rv, const int &u)
Sets the upper bound of the vector.
Definition: civector.hpp:969
The Data Type cimatrix.
Definition: cimatrix.hpp:907
ivector abs(const cimatrix_subv &mv)
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737