C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
ivector.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: ivector.hpp,v 1.36 2014/01/30 17:23:45 cxsc Exp $ */
25 
26 #ifndef _CXSC_IVECTOR_HPP_INCLUDED
27 #define _CXSC_IVECTOR_HPP_INCLUDED
28 
29 #include "xscclass.hpp"
30 #include "except.hpp"
31 #include "idot.hpp"
32 #include "cidot.hpp"
33 #include "interval.hpp" // used for declaration of Inf, Sup,...
34 #include "rvector.hpp"
35 #include "vector.hpp"
36 
37 
38 #include <iostream>
39 
40 namespace cxsc {
41 
42 class srvector;
43 class srvector_slice;
44 class sivector;
45 class sivector_slice;
46 class ivector_slice;
47 
49 
54 class ivector
55 {
56  friend class ivector_slice;
57  friend class imatrix;
58  friend class imatrix_subv;
59  friend class civector;
60  friend class cimatrix;
61  friend class l_ivector;
62  friend class l_imatrix;
63  private:
64  interval *dat;
65  int l,u,size;
66 
67  public:
68 //#if(CXSC_INDEX_CHECK)
69 #ifdef _CXSC_FRIEND_TPL
70  //------------ Templates --------------------------------------------------
71  // Interval
72 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m)
73 #if(CXSC_INDEX_CHECK)
74  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>);
75 #else
76  throw();
77 #endif
78 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
79 #if(CXSC_INDEX_CHECK)
80  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
81 #else
82  throw();
83 #endif
84  template <class V> friend void _vresize(V &rv) throw();
85  template <class V,class S> friend void _vresize(V &rv, const int &len)
86 #if(CXSC_INDEX_CHECK)
87  throw(ERROR__WRONG_BOUNDARIES<V>);
88 #else
89  throw();
90 #endif
91  template <class V,class S> friend void _vresize(V &rv, const int &lb, const int &ub)
92 #if(CXSC_INDEX_CHECK)
93  throw(ERROR__WRONG_BOUNDARIES<V>);
94 #else
95  throw();
96 #endif
97  template <class V1,class V2,class S> friend V1 &_vvassign(V1 &rv1,const V2 &rv2) throw();
98  template <class V,class S> friend V & _vsassign(V &rv,const S &r) throw();
99  template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) throw();
100 template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv)
101 #if(CXSC_INDEX_CHECK)
102  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
103 #else
104  throw();
105 #endif
106 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m)
107 #if(CXSC_INDEX_CHECK)
108  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
109 #else
110  throw();
111 #endif
112 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) throw();
113  template <class V1,class V2> friend V1 &_vvsetinf(V1 &rv1, const V2 &rv2)
114 #if(CXSC_INDEX_CHECK)
115  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
116 #else
117  throw();
118 #endif
119  template <class V1,class V2> friend V1 &_vvsetsup(V1 &rv1, const V2 &rv2)
120 #if(CXSC_INDEX_CHECK)
121  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
122 #else
123  throw();
124 #endif
125  template <class V,class VS> friend V &_vvssetinf(V &rv, const VS &sl)
126 #if(CXSC_INDEX_CHECK)
127  throw(ERROR__OP_WITH_WRONG_DIM<V>);
128 #else
129  throw();
130 #endif
131  template <class V,class VS> friend V &_vvssetsup(V &rv, const VS &sl)
132 #if(CXSC_INDEX_CHECK)
133  throw(ERROR__OP_WITH_WRONG_DIM<V>);
134 #else
135  throw();
136 #endif
137 template <class V,class MV> friend V &_vmvsetinf(V &rv,const MV &v)
138 #if(CXSC_INDEX_CHECK)
139  throw(ERROR__OP_WITH_WRONG_DIM<V>);
140 #else
141  throw();
142 #endif
143 template <class V,class MV> friend V &_vmvsetsup(V &rv,const MV &v)
144 #if(CXSC_INDEX_CHECK)
145  throw(ERROR__OP_WITH_WRONG_DIM<V>);
146 #else
147  throw();
148 #endif
149  template <class V1,class V2> friend V1 &_vvusetinf(V1 &rv1, const V2 &rv2)
150 #if(CXSC_INDEX_CHECK)
151  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
152 #else
153  throw();
154 #endif
155  template <class V1,class V2> friend V1 &_vvusetsup(V1 &rv1, const V2 &rv2)
156 #if(CXSC_INDEX_CHECK)
157  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
158 #else
159  throw();
160 #endif
161  template <class V,class VS> friend V &_vvsusetinf(V &rv, const VS &sl)
162 #if(CXSC_INDEX_CHECK)
163  throw(ERROR__OP_WITH_WRONG_DIM<V>);
164 #else
165  throw();
166 #endif
167  template <class V,class VS> friend V &_vvsusetsup(V &rv, const VS &sl)
168 #if(CXSC_INDEX_CHECK)
169  throw(ERROR__OP_WITH_WRONG_DIM<V>);
170 #else
171  throw();
172 #endif
173 template <class V,class MV> friend V &_vmvusetinf(V &rv,const MV &v)
174 #if(CXSC_INDEX_CHECK)
175  throw(ERROR__OP_WITH_WRONG_DIM<V>);
176 #else
177  throw();
178 #endif
179 template <class V,class MV> friend V &_vmvusetsup(V &rv,const MV &v)
180 #if(CXSC_INDEX_CHECK)
181  throw(ERROR__OP_WITH_WRONG_DIM<V>);
182 #else
183  throw();
184 #endif
185  template <class V,class S> friend V &_vssetinf(V &v, const S &s) throw();
186  template <class V,class S> friend V &_vssetsup(V &v, const S &s) throw();
187  template <class V,class S> friend V &_vsusetinf(V &v, const S &s) throw();
188  template <class V,class S> friend V &_vsusetsup(V &v, const S &s) throw();
189  template <class V,class E> friend E _vabs(const V &rv) throw();
190  template <class VS,class E> friend E _vsabs(const VS &sl) throw();
191 template <class MV,class V> friend V _mvabs(const MV &mv) throw();
192  template <class V,class E> friend E _vdiam(const V &rv) throw();
193  template <class V,class E> friend E _vmid(const V &rv) throw();
194  template <class V,class E> friend E _vinf(const V &rv) throw();
195  template <class V,class E> friend E _vsup(const V &rv) throw();
196 
197 //-------- vector-vector -----------------------
198  template <class DP,class V1,class V2> friend void _vvaccu(DP &dp, const V1 & rv1, const V2 &rv2)
199 #if(CXSC_INDEX_CHECK)
200  throw(OP_WITH_WRONG_DIM);
201 #else
202  throw();
203 #endif
204  template <class DP,class VS,class V> friend void _vsvaccu(DP &dp, const VS & sl, const V &rv)
205 #if(CXSC_INDEX_CHECK)
206  throw(OP_WITH_WRONG_DIM);
207 #else
208  throw();
209 #endif
210  template <class V1,class V2,class E> friend E _vvimult(const V1 & rv1, const V2 &rv2)
211 #if(CXSC_INDEX_CHECK)
212  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
213 #else
214  throw();
215 #endif
216  template <class VS,class V,class E> friend E _vsvimult(const VS & sl, const V &rv)
217 #if(CXSC_INDEX_CHECK)
218  throw(ERROR__OP_WITH_WRONG_DIM<V>);
219 #else
220  throw();
221 #endif
222  template <class V,class S> friend V &_vsmultassign(V &rv,const S &r) throw();
223  template <class V1,class V2,class E> friend E _vvplus(const V1 &rv1, const V2 &rv2)
224 #if(CXSC_INDEX_CHECK)
225  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
226 #else
227  throw();
228 #endif
229  template <class V,class VS,class E> friend E _vvsplus(const V &rv,const VS &sl)
230 #if(CXSC_INDEX_CHECK)
231  throw(ERROR__OP_WITH_WRONG_DIM<V>);
232 #else
233  throw();
234 #endif
235  template <class VS1,class VS2,class E> friend E _vsvsplus(const VS1 &s1,const VS2 &s2)
236 #if(CXSC_INDEX_CHECK)
237  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
238 #else
239  throw();
240 #endif
241  template <class VS1,class VS2,class E> friend E _vsvsminus(const VS1 &s1,const VS2 &s2)
242 #if(CXSC_INDEX_CHECK)
243  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
244 #else
245  throw();
246 #endif
247  template <class V1,class V2> friend V1 &_vvplusassign(V1 &rv1, const V2 &rv2)
248 #if(CXSC_INDEX_CHECK)
249  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
250 #else
251  throw();
252 #endif
253  template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl)
254 #if(CXSC_INDEX_CHECK)
255  throw(ERROR__OP_WITH_WRONG_DIM<V>);
256 #else
257  throw();
258 #endif
259  template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv)
260 #if(CXSC_INDEX_CHECK)
261  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
262 #else
263  throw();
264 #endif
265  template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
266 #if(CXSC_INDEX_CHECK)
267  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
268 #else
269  throw();
270 #endif
271  template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
272 #if(CXSC_INDEX_CHECK)
273  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
274 #else
275  throw();
276 #endif
277  template <class V1,class V2> friend V1 &_vvminusassign(V1 &rv1, const V2 &rv2)
278 #if(CXSC_INDEX_CHECK)
279  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
280 #else
281  throw();
282 #endif
283  template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl)
284 #if(CXSC_INDEX_CHECK)
285  throw(ERROR__OP_WITH_WRONG_DIM<V>);
286 #else
287  throw();
288 #endif
289  template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv)
290 #if(CXSC_INDEX_CHECK)
291  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
292 #else
293  throw();
294 #endif
295  template <class V> friend V _vminus(const V &rv) throw();
296  template <class VS,class V> friend V _vsminus(const VS &sl) throw();
297  template <class V1,class V2,class E> friend E _vvminus(const V1 &rv1, const V2 &rv2)
298 #if(CXSC_INDEX_CHECK)
299  throw(ERROR__OP_WITH_WRONG_DIM<E>);
300 #else
301  throw();
302 #endif
303  template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl)
304 #if(CXSC_INDEX_CHECK)
305  throw(ERROR__OP_WITH_WRONG_DIM<E>);
306 #else
307  throw();
308 #endif
309  template <class VS,class V,class E> friend E _vsvminus(const VS &sl,const V &rv)
310 #if(CXSC_INDEX_CHECK)
311  throw(ERROR__OP_WITH_WRONG_DIM<E>);
312 #else
313  throw();
314 #endif
315  template <class V1,class V2,class E> friend E _vvconv(const V1 &rv1, const V2 &rv2)
316 #if(CXSC_INDEX_CHECK)
317  throw(ERROR__OP_WITH_WRONG_DIM<E>);
318 #else
319  throw();
320 #endif
321  template <class V,class VS,class E> friend E _vvsconv(const V &rv,const VS &sl)
322 #if(CXSC_INDEX_CHECK)
323  throw(ERROR__OP_WITH_WRONG_DIM<E>);
324 #else
325  throw();
326 #endif
327  template <class VS1,class VS2,class E> friend E _vsvsconv(const VS1 &s1,const VS2 &s2)
328 #if(CXSC_INDEX_CHECK)
329  throw(ERROR__OP_WITH_WRONG_DIM<E>);
330 #else
331  throw();
332 #endif
333  template <class V1,class V2> friend V1 &_vvconvassign(V1 &rv1, const V2 &rv2)
334 #if(CXSC_INDEX_CHECK)
335  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
336 #else
337  throw();
338 #endif
339  template <class V,class VS> friend V &_vvsconvassign(V &rv, const VS &sl)
340 #if(CXSC_INDEX_CHECK)
341  throw(ERROR__OP_WITH_WRONG_DIM<V>);
342 #else
343  throw();
344 #endif
345  template <class VS,class V> friend VS &_vsvconvassign(VS &sl, const V &rv)
346 #if(CXSC_INDEX_CHECK)
347  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
348 #else
349  throw();
350 #endif
351  template <class VS1,class VS2> friend VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2)
352 #if(CXSC_INDEX_CHECK)
353  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
354 #else
355  throw();
356 #endif
357  template <class V1,class V2,class E> friend E _vvsect(const V1 &rv1, const V2 &rv2)
358 #if(CXSC_INDEX_CHECK)
359  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
360 #else
361  throw();
362 #endif
363  template <class V,class VS,class E> friend E _vvssect(const V &rv,const VS &sl)
364 #if(CXSC_INDEX_CHECK)
365  throw(ERROR__OP_WITH_WRONG_DIM<E>);
366 #else
367  throw();
368 #endif
369  template <class VS1,class VS2,class E> friend E _vsvssect(const VS1 &s1,const VS2 &s2)
370 #if(CXSC_INDEX_CHECK)
371  throw(ERROR__OP_WITH_WRONG_DIM<E>);
372 #else
373  throw();
374 #endif
375  template <class V1,class V2> friend V1 &_vvsectassign(V1 &rv1, const V2 &rv2)
376 #if(CXSC_INDEX_CHECK)
377  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
378 #else
379  throw();
380 #endif
381  template <class V,class VS> friend V &_vvssectassign(V &rv, const VS &sl)
382 #if(CXSC_INDEX_CHECK)
383  throw(ERROR__OP_WITH_WRONG_DIM<V>);
384 #else
385  throw();
386 #endif
387  template <class VS,class V> friend VS &_vsvsectassign(VS &sl, const V &rv)
388 #if(CXSC_INDEX_CHECK)
389  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
390 #else
391  throw();
392 #endif
393  template <class VS1,class VS2> friend VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2)
394 #if(CXSC_INDEX_CHECK)
395  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
396 #else
397  throw();
398 #endif
399  template <class MV1,class MV2,class E> friend E _mvmvsect(const MV1 &rv1, const MV2 &rv2)
400 #if(CXSC_INDEX_CHECK)
401  throw(ERROR__OP_WITH_WRONG_DIM<E>);
402 #else
403  throw();
404 #endif
405  template <class MV,class V,class E> friend E _mvvsect(const MV &rv1, const V &rv2)
406 #if(CXSC_INDEX_CHECK)
407  throw(ERROR__OP_WITH_WRONG_DIM<E>);
408 #else
409  throw();
410 #endif
411 template <class MV,class V> friend MV &_mvvsectassign(MV &v,const V &rv)
412 #if(CXSC_INDEX_CHECK)
413  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
414 #else
415  throw();
416 #endif
417 template <class V,class MV> friend V &_vmvsectassign(V &rv,const MV &v)
418 #if(CXSC_INDEX_CHECK)
419  throw(ERROR__OP_WITH_WRONG_DIM<V>);
420 #else
421  throw();
422 #endif
423  template <class MV1,class MV2,class E> friend E _mvmvconv(const MV1 &rv1, const MV2 &rv2)
424 #if(CXSC_INDEX_CHECK)
425  throw(ERROR__OP_WITH_WRONG_DIM<E>);
426 #else
427  throw();
428 #endif
429  template <class MV,class V,class E> friend E _mvvconv(const MV &rv1, const V &rv2)
430 #if(CXSC_INDEX_CHECK)
431  throw(ERROR__OP_WITH_WRONG_DIM<E>);
432 #else
433  throw();
434 #endif
435 template <class MV,class V> friend MV &_mvvconvassign(MV &v,const V &rv)
436 #if(CXSC_INDEX_CHECK)
437  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
438 #else
439  throw();
440 #endif
441 template <class V,class MV> friend V &_vmvconvassign(V &rv,const MV &v)
442 #if(CXSC_INDEX_CHECK)
443  throw(ERROR__OP_WITH_WRONG_DIM<V>);
444 #else
445  throw();
446 #endif
447  template <class V,class MV,class S> friend S _vmvimult(const V &rv1, const MV &rv2)
448 #if(CXSC_INDEX_CHECK)
449  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
450 #else
451  throw();
452 #endif
453  //--------- vector-scalar -----------------
454  template <class V,class S,class E> friend E _vsdiv(const V &rv, const S &s) throw();
455  template <class V,class S> friend V &_vsdivassign(V &rv,const S &r) throw();
456  template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) throw();
457  template <class V,class S,class E> friend E _vsmult(const V &rv, const S &s) throw();
458  template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) throw();
459  template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) throw();
460  template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
461 #if(CXSC_INDEX_CHECK)
462  throw(ERROR__OP_WITH_WRONG_DIM<E>);
463 #else
464  throw();
465 #endif
466  template <class MV,class V,class E> friend E _mvvplus(const MV &rv1, const V &rv2)
467 #if(CXSC_INDEX_CHECK)
468  throw(ERROR__OP_WITH_WRONG_DIM<E>);
469 #else
470  throw();
471 #endif
472  template <class MV,class V,class E> friend E _mvvminus(const MV &rv1, const V &rv2)
473 #if(CXSC_INDEX_CHECK)
474  throw(ERROR__OP_WITH_WRONG_DIM<E>);
475 #else
476  throw();
477 #endif
478  template <class V,class MV,class E> friend E _vmvminus(const V &rv1, const MV &rv2)
479 #if(CXSC_INDEX_CHECK)
480  throw(ERROR__OP_WITH_WRONG_DIM<E>);
481 #else
482  throw();
483 #endif
484  template <class MV1,class MV2,class E> friend E _mvmvminus(const MV1 &rv1, const MV2 &rv2)
485 #if(CXSC_INDEX_CHECK)
486  throw(ERROR__OP_WITH_WRONG_DIM<E>);
487 #else
488  throw();
489 #endif
490 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
491 #if(CXSC_INDEX_CHECK)
492  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
493 #else
494  throw();
495 #endif
496 template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv)
497 #if(CXSC_INDEX_CHECK)
498  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
499 #else
500  throw();
501 #endif
502  template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) throw();
503 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
504 #if(CXSC_INDEX_CHECK)
505  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
506 #else
507  throw();
508 #endif
509 
510  template <class V1,class V2> friend bool _vveq(const V1 &rv1, const V2 &rv2) throw();
511  template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) throw();
512  template <class V1,class V2> friend bool _vvneq(const V1 &rv1, const V2 &rv2) throw();
513  template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) throw();
514  template <class V1,class V2> friend bool _vvless(const V1 &rv1, const V2 &rv2) throw();
515  template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) throw();
516  template <class V1,class V2> friend bool _vvleq(const V1 &rv1, const V2 &rv2) throw();
517  template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) throw();
518  template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) throw();
519  template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) throw();
520  template <class V> friend bool _vnot(const V &rv) throw();
521  template <class V> friend void *_vvoid(const V &rv) throw();
522  template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw();
523  template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw();
524  template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw();
525  template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw();
526  template <class VS> friend bool _vsnot(const VS &sl) throw();
527  template <class VS> friend void *_vsvoid(const VS &sl) throw();
528  template <class V> friend std::ostream &_vout(std::ostream &s, const V &rv) throw();
529  template <class V> friend std::istream &_vin(std::istream &s, V &rv) throw();
530 
531  //------------- vector-matrix ---------------
532 template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
533 #if(CXSC_INDEX_CHECK)
534  throw(OP_WITH_WRONG_DIM);
535 #else
536  throw();
537 #endif
538 
539 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) throw();
540  template <class M,class V,class E> friend E _mvimult(const M &m,const V &v)
541 #if(CXSC_INDEX_CHECK)
542  throw(ERROR__OP_WITH_WRONG_DIM<M>);
543 #else
544  throw();
545 #endif
546  template <class V,class M,class E> friend E _vmimult(const V &v,const M &m)
547 #if(CXSC_INDEX_CHECK)
548  throw(ERROR__OP_WITH_WRONG_DIM<M>);
549 #else
550  throw();
551 #endif
552  template <class V,class M,class S> friend V &_vmimultassign(V &v,const M &m)
553 #if(CXSC_INDEX_CHECK)
554  throw(ERROR__OP_WITH_WRONG_DIM<M>);
555 #else
556  throw();
557 #endif
558  template <class MS,class V,class E> friend E _msvimult(const MS &ms,const V &v)
559 #if(CXSC_INDEX_CHECK)
560  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
561 #else
562  throw();
563 #endif
564  template <class V,class MS,class E> friend E _vmsimult(const V &v,const MS &ms)
565 #if(CXSC_INDEX_CHECK)
566  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
567 #else
568  throw();
569 #endif
570  template <class V,class MS,class S> friend V &_vmsimultassign(V &v,const MS &ms)
571 #if(CXSC_INDEX_CHECK)
572  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
573 #else
574  throw();
575 #endif
576 
577  // Real
578  //--Real -------- vector-scalar ------------
579  //--Real--------- Vector-vector---------
580  //-- Real -------- Vector-matrix ----------
581  // complex
582  //--complex -------- vector-scalar ------------
583  //--complex--------- Vector-vector---------
584 
585  template <class V1,class V2,class E> friend E _vvcimult(const V1 & rv1, const V2 &rv2)
586 #if(CXSC_INDEX_CHECK)
587  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
588 #else
589  throw();
590 #endif
591  template <class VS,class V,class E> friend E _vsvcimult(const VS & sl, const V &rv)
592 #if(CXSC_INDEX_CHECK)
593  throw(ERROR__OP_WITH_WRONG_DIM<V>);
594 #else
595  throw();
596 #endif
597 
598  //-- complex -------- Vector-matrix ----------
599  template <class M,class V,class E> friend E _mvcimult(const M &m,const V &v)
600 #if(CXSC_INDEX_CHECK)
601  throw(ERROR__OP_WITH_WRONG_DIM<M>);
602 #else
603  throw();
604 #endif
605  template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v)
606 #if(CXSC_INDEX_CHECK)
607  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
608 #else
609  throw();
610 #endif
611  template <class V,class M,class E> friend E _vmcimult(const V &v,const M &m)
612 #if(CXSC_INDEX_CHECK)
613  throw(ERROR__OP_WITH_WRONG_DIM<M>);
614 #else
615  throw();
616 #endif
617  template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms)
618 #if(CXSC_INDEX_CHECK)
619  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
620 #else
621  throw();
622 #endif
623 
624  // civector ---------------------
625 template <class V1,class V2> friend V1 &_vvsetim(V1 &rv1, const V2 &rv2)
626 #if(CXSC_INDEX_CHECK)
627  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
628 #else
629  throw();
630 #endif
631 template <class V1,class V2> friend V1 &_vvsetre(V1 &rv1, const V2 &rv2)
632 #if(CXSC_INDEX_CHECK)
633  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
634 #else
635  throw();
636 #endif
637  template <class V,class E> friend E _vim(const V &rv) throw();
638  template <class V,class E> friend E _vre(const V &rv) throw();
639 
640  template <class VS,class V> friend VS &_vsvsetim(VS &sl, const V &rv)
641 #if(CXSC_INDEX_CHECK)
642  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
643 #else
644  throw();
645 #endif
646  template <class VS,class V> friend VS &_vsvsetre(VS &sl, const V &rv)
647 #if(CXSC_INDEX_CHECK)
648  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
649 #else
650  throw();
651 #endif
652 template <class MV,class V> friend MV &_mvvsetre(MV &v,const V &rv)
653 #if(CXSC_INDEX_CHECK)
654  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
655 #else
656  throw();
657 #endif
658 template <class MV,class V> friend MV &_mvvsetim(MV &v,const V &rv)
659 #if(CXSC_INDEX_CHECK)
660  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
661 #else
662  throw();
663 #endif
664 template <class MV,class V> friend V _mvim(const MV &mv) throw();
665 template <class MV,class V> friend V _mvre(const MV &mv) throw();
666 
667  // vector-scalar
668  // vector-vector
669  template <class VS1,class VS2,class E> friend E _vsvscimult(const VS1 & sl1, const VS2 &sl2)
670 #if(CXSC_INDEX_CHECK)
671  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
672 #else
673  throw();
674 #endif
675 
676  // vector-matrix
677  // l_real
678  //--l_real -------- vector-scalar ------------
679  //--l_real--------- Vector-vector---------
680 
681  template <class V1,class V2,class E> friend E _vvlimult(const V1 & rv1, const V2 &rv2)
682 #if(CXSC_INDEX_CHECK)
683  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
684 #else
685  throw();
686 #endif
687  template <class VS,class V,class E> friend E _vsvlimult(const VS & sl, const V &rv)
688 #if(CXSC_INDEX_CHECK)
689  throw(ERROR__OP_WITH_WRONG_DIM<V>);
690 #else
691  throw();
692 #endif
693 
694  //-- l_real -------- Vector-matrix ----------
695  template <class M,class V,class E> friend E _mvlimult(const M &m,const V &v)
696 #if(CXSC_INDEX_CHECK)
697  throw(ERROR__OP_WITH_WRONG_DIM<M>);
698 #else
699  throw();
700 #endif
701  template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v)
702 #if(CXSC_INDEX_CHECK)
703  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
704 #else
705  throw();
706 #endif
707  template <class V,class M,class E> friend E _vmlimult(const V &v,const M &m)
708 #if(CXSC_INDEX_CHECK)
709  throw(ERROR__OP_WITH_WRONG_DIM<M>);
710 #else
711  throw();
712 #endif
713  template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms)
714 #if(CXSC_INDEX_CHECK)
715  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
716 #else
717  throw();
718 #endif
719 
720  // l_ivector ---------------------
721  // vector-scalar
722  // vector-vector
723  template <class VS1,class VS2,class E> friend E _vsvslimult(const VS1 & sl1, const VS2 &sl2)
724 #if(CXSC_INDEX_CHECK)
725  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
726 #else
727  throw();
728 #endif
729  // vector-matrix
730 
731 #endif
732 
733  //------ Konstruktoren ----------------------------------------------------
735  INLINE ivector () throw();
737  explicit INLINE ivector(const int &i) throw();
738 #ifdef OLD_CXSC
739  explicit INLINE ivector(const class index &i) throw(); // for backwards compatibility
741 #endif
742  explicit INLINE ivector(const int &i1,const int &i2)
744 #if(CXSC_INDEX_CHECK)
745  throw(ERROR_IVECTOR_WRONG_BOUNDARIES,ERROR_IVECTOR_NO_MORE_MEMORY);
746 #else
747  throw();
748 #endif
749  INLINE ivector(const imatrix_subv &) throw();
752  explicit INLINE ivector(const interval &) throw();
754 // explicit INLINE ivector(const imatrix &)
755  explicit ivector(const imatrix &)
756 #if(CXSC_INDEX_CHECK)
757  throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
758 #else
759  throw();
760 #endif
761  explicit INLINE ivector(const imatrix_slice &sl)
763 #if(CXSC_INDEX_CHECK)
764  throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
765 #else
766  throw();
767 #endif
768  INLINE ivector(const ivector_slice &rs) throw();
771  INLINE ivector(const ivector &v) throw();
773  INLINE ivector(const sivector &rs);
775  INLINE ivector(const sivector_slice &rs);
776 
777  // Real
779  explicit INLINE ivector(const real &) throw();
781  explicit INLINE ivector(const rvector_slice &rs) throw();
783  explicit INLINE ivector(const srvector &rs);
785  explicit INLINE ivector(const srvector_slice &rs);
786 
788  explicit INLINE ivector(const rvector &v) throw();
790  explicit INLINE ivector(const rmatrix &)
791 #if(CXSC_INDEX_CHECK)
792  throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
793 #else
794  throw();
795 #endif
796  explicit INLINE ivector(const rmatrix_slice &sl)
798 #if(CXSC_INDEX_CHECK)
799  throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
800 #else
801  throw();
802 #endif
803 // explicit INLINE ivector(const rmatrix_subv &) throw();
805  explicit ivector(const rmatrix_subv &) throw();
806 
807  // Interval
809  INLINE ivector &operator =(const ivector &rv) throw();
811  INLINE ivector &operator =(const ivector_slice &sl) throw();
813  INLINE ivector &operator =(const sivector &rv);
815  INLINE ivector &operator =(const sivector_slice &sl);
817  INLINE ivector &operator =(const srvector &rv);
819  INLINE ivector &operator =(const srvector_slice &sl);
821  INLINE ivector &operator =(const interval &r) throw();
823  INLINE ivector &operator =(const imatrix &m)
824 #if(CXSC_INDEX_CHECK)
825  throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
826 #else
827  throw();
828 #endif
829  INLINE ivector &operator =(const imatrix_slice &)
831 #if(CXSC_INDEX_CHECK)
832  throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
833 #else
834  throw();
835 #endif
836  INLINE ivector &operator =(const imatrix_subv &) throw();
838  // Real
840  INLINE ivector &operator =(const rvector &rv) throw();
842  INLINE ivector &operator =(const rvector_slice &sl) throw();
844  INLINE ivector &operator =(const real &r) throw();
846  INLINE ivector &operator =(const rmatrix &m)
847 #if(CXSC_INDEX_CHECK)
848  throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
849 #else
850  throw();
851 #endif
852  INLINE ivector &operator =(const rmatrix_slice &)
854 #if(CXSC_INDEX_CHECK)
855  throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
856 #else
857  throw();
858 #endif
859  INLINE ivector &operator =(const rmatrix_subv &) throw();
861 
863  INLINE ivector &operator+=(const srvector&);
865  INLINE ivector &operator+=(const sivector&);
867  INLINE ivector &operator+=(const srvector_slice&);
869  INLINE ivector &operator+=(const sivector_slice&);
871  INLINE ivector &operator-=(const srvector&);
873  INLINE ivector &operator-=(const sivector&);
875  INLINE ivector &operator-=(const srvector_slice&);
877  INLINE ivector &operator-=(const sivector_slice&);
879  INLINE ivector &operator|=(const srvector&);
881  INLINE ivector &operator|=(const sivector&);
883  INLINE ivector &operator|=(const srvector_slice&);
885  INLINE ivector &operator|=(const sivector_slice&);
887  INLINE ivector &operator&=(const sivector&);
889  INLINE ivector &operator&=(const sivector_slice&);
890 
892  INLINE ivector operator()(const intvector& p);
894  INLINE ivector operator()(const intmatrix& P);
895 
896  //--------- Destruktor ----------------------------------------------------
897  INLINE ~ivector() { delete [] dat; }
898 
899  //------ Standardfunktionen -----------------------------------------------
900 
901  friend INLINE interval::interval(const ivector &)
902 #if(CXSC_INDEX_CHECK)
903  throw(ERROR_IVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_IVECTOR_USE_OF_UNINITIALIZED_OBJ);
904 #else
905  throw();
906 #endif
907  friend INLINE int Lb(const ivector &rv) throw() { return rv.l; }
910  friend INLINE int Ub(const ivector &rv) throw() { return rv.u; }
912  friend INLINE int VecLen(const ivector &rv) throw() { return rv.size; }
914  friend INLINE ivector &SetLb(ivector &rv, const int &l) throw() { rv.l=l; rv.u=l+rv.size-1; return rv; }
916  friend INLINE ivector &SetUb(ivector &rv, const int &u) throw() { rv.u=u; rv.l=u-rv.size+1; return rv; }
918  INLINE interval & operator [](const int &i) const
919 #if(CXSC_INDEX_CHECK)
920  throw(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC);
921 #else
922  throw();
923 #endif
924 
926  INLINE interval & operator [](const int &i)
927 #if(CXSC_INDEX_CHECK)
928  throw(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC);
929 #else
930  throw();
931 #endif
932 
934  INLINE ivector & operator ()() throw() { return *this; }
936  INLINE ivector_slice operator ()(const int &i)
937 #if(CXSC_INDEX_CHECK)
938  throw(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG);
939 #else
940  throw();
941 #endif
942  INLINE ivector_slice operator ()(const int &i1,const int &i2)
944 #if(CXSC_INDEX_CHECK)
945  throw(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG);
946 #else
947  throw();
948 #endif
949 
950  INLINE operator void*() throw();
951 //#else
952 //#endif
953 };
954 
955 
957 
963 {
964  friend class ivector;
965  friend class imatrix;
966  friend class civector;
967  friend class cimatrix;
968  friend class l_ivector;
969  friend class l_imatrix;
970  private:
971  interval *dat;
972  int l,u,size;
973  int start,end;
974 
975  public:
976 //#if(CXSC_INDEX_CHECK)
977 #ifdef _CXSC_FRIEND_TPL
978 //------------------------- Templates -------------------------------------------
979 // Interval / Interval
980 
981  template <class VS1,class VS2> friend VS1 & _vsvsassign(VS1 &sl1,const VS2 &sl2)
982 #if(CXSC_INDEX_CHECK)
983  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
984 #else
985  throw();
986 #endif
987  template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) throw();
988  template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv)
989 #if(CXSC_INDEX_CHECK)
990  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
991 #else
992  throw();
993 #endif
994  template <class VS,class S> friend VS & _vssassign(VS &sl,const S &r) throw();
995  template <class VS,class V> friend VS &_vsvsetinf(VS &sl, const V &rv)
996 #if(CXSC_INDEX_CHECK)
997  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
998 #else
999  throw();
1000 #endif
1001  template <class VS,class V> friend VS &_vsvsetsup(VS &sl, const V &rv)
1002 #if(CXSC_INDEX_CHECK)
1003  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
1004 #else
1005  throw();
1006 #endif
1007  template <class VS1,class VS2> friend VS1 &_vsvssetinf(VS1 &sl1, const VS2 &sl2)
1008 #if(CXSC_INDEX_CHECK)
1009  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1010 #else
1011  throw();
1012 #endif
1013  template <class VS1,class VS2> friend VS1 &_vsvssetsup(VS1 &sl1, const VS2 &sl2)
1014 #if(CXSC_INDEX_CHECK)
1015  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1016 #else
1017  throw();
1018 #endif
1019  template <class VS,class V> friend VS &_vsvusetinf(VS &sl, const V &rv)
1020 #if(CXSC_INDEX_CHECK)
1021  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
1022 #else
1023  throw();
1024 #endif
1025  template <class VS,class V> friend VS &_vsvusetsup(VS &sl, const V &rv)
1026 #if(CXSC_INDEX_CHECK)
1027  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
1028 #else
1029  throw();
1030 #endif
1031  template <class VS1,class VS2> friend VS1 &_vsvsusetinf(VS1 &sl1, const VS2 &sl2)
1032 #if(CXSC_INDEX_CHECK)
1033  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1034 #else
1035  throw();
1036 #endif
1037  template <class VS1,class VS2> friend VS1 &_vsvsusetsup(VS1 &sl1, const VS2 &sl2)
1038 #if(CXSC_INDEX_CHECK)
1039  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1040 #else
1041  throw();
1042 #endif
1043  template <class VS,class S> friend VS &_vsssetinf(VS &vs, const S &s) throw();
1044  template <class VS,class S> friend VS &_vsssetsup(VS &vs, const S &s) throw();
1045  template <class VS,class S> friend VS &_vssusetinf(VS &vs, const S &s) throw();
1046  template <class VS,class S> friend VS &_vssusetsup(VS &vs, const S &s) throw();
1047 
1048  template <class DP,class VS,class V> friend void _vsvaccu(DP &dp, const VS & sl, const V &rv)
1049 #if(CXSC_INDEX_CHECK)
1050  throw(OP_WITH_WRONG_DIM);
1051 #else
1052  throw();
1053 #endif
1054  template <class DP,class VS1,class VS2> friend void _vsvsaccu(DP &dp, const VS1 & sl1, const VS2 &sl2)
1055 #if(CXSC_INDEX_CHECK)
1056  throw(OP_WITH_WRONG_DIM);
1057 #else
1058  throw();
1059 #endif
1060 
1061  template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) throw();
1062  template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) throw();
1063 
1064  template <class VS,class V,class E> friend E _vsvimult(const VS & sl, const V &rv)
1065 #if(CXSC_INDEX_CHECK)
1066  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1067 #else
1068  throw();
1069 #endif
1070  template <class VS,class S> friend VS &_vssmultassign(VS &rv,const S &r) throw();
1071  template <class VS,class S> friend VS &_vssdivassign(VS &rv,const S &r) throw();
1072  template <class V,class VS,class E> friend E _vvsplus(const V &rv,const VS &sl)
1073 #if(CXSC_INDEX_CHECK)
1074  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1075 #else
1076  throw();
1077 #endif
1078  template <class VS1,class VS2,class E> friend E _vsvsplus(const VS1 &s1,const VS2 &s2)
1079 #if(CXSC_INDEX_CHECK)
1080  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1081 #else
1082  throw();
1083 #endif
1084  template <class VS1,class VS2,class E> friend E _vsvsminus(const VS1 &s1,const VS2 &s2)
1085 #if(CXSC_INDEX_CHECK)
1086  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1087 #else
1088  throw();
1089 #endif
1090  template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl)
1091 #if(CXSC_INDEX_CHECK)
1092  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1093 #else
1094  throw();
1095 #endif
1096  template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv)
1097 #if(CXSC_INDEX_CHECK)
1098  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
1099 #else
1100  throw();
1101 #endif
1102  template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
1103 #if(CXSC_INDEX_CHECK)
1104  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1105 #else
1106  throw();
1107 #endif
1108  template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
1109 #if(CXSC_INDEX_CHECK)
1110  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1111 #else
1112  throw();
1113 #endif
1114  template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl)
1115 #if(CXSC_INDEX_CHECK)
1116  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1117 #else
1118  throw();
1119 #endif
1120  template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv)
1121 #if(CXSC_INDEX_CHECK)
1122  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
1123 #else
1124  throw();
1125 #endif
1126  template <class VS,class V> friend V _vsminus(const VS &sl) throw();
1127  template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl)
1128 #if(CXSC_INDEX_CHECK)
1129  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1130 #else
1131  throw();
1132 #endif
1133  template <class VS,class V,class E> friend E _vsvminus(const VS &sl,const V &rv)
1134 #if(CXSC_INDEX_CHECK)
1135  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1136 #else
1137  throw();
1138 #endif
1139  template <class V,class VS,class E> friend E _vvssect(const V &rv,const VS &sl)
1140 #if(CXSC_INDEX_CHECK)
1141  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1142 #else
1143  throw();
1144 #endif
1145  template <class VS1,class VS2,class E> friend E _vsvssect(const VS1 &s1,const VS2 &s2)
1146 #if(CXSC_INDEX_CHECK)
1147  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1148 #else
1149  throw();
1150 #endif
1151  template <class V,class VS> friend V &_vvssectassign(V &rv, const VS &sl)
1152 #if(CXSC_INDEX_CHECK)
1153  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1154 #else
1155  throw();
1156 #endif
1157  template <class VS,class V> friend VS &_vsvsectassign(VS &sl, const V &rv)
1158 #if(CXSC_INDEX_CHECK)
1159  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
1160 #else
1161  throw();
1162 #endif
1163  template <class VS1,class VS2> friend VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2)
1164 #if(CXSC_INDEX_CHECK)
1165  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1166 #else
1167  throw();
1168 #endif
1169  template <class V,class VS,class E> friend E _vvsconv(const V &rv,const VS &sl)
1170 #if(CXSC_INDEX_CHECK)
1171  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1172 #else
1173  throw();
1174 #endif
1175  template <class VS1,class VS2,class E> friend E _vsvsconv(const VS1 &s1,const VS2 &s2)
1176 #if(CXSC_INDEX_CHECK)
1177  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1178 #else
1179  throw();
1180 #endif
1181  template <class V,class VS> friend V &_vvsconvassign(V &rv, const VS &sl)
1182 #if(CXSC_INDEX_CHECK)
1183  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1184 #else
1185  throw();
1186 #endif
1187  template <class VS,class V> friend VS &_vsvconvassign(VS &sl, const V &rv)
1188 #if(CXSC_INDEX_CHECK)
1189  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
1190 #else
1191  throw();
1192 #endif
1193  template <class VS1,class VS2> friend VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2)
1194 #if(CXSC_INDEX_CHECK)
1195  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1196 #else
1197  throw();
1198 #endif
1199  template <class VS,class M,class S> friend VS &_vsmimultassign(VS &v,const M &m)
1200 #if(CXSC_INDEX_CHECK)
1201  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1202 #else
1203  throw();
1204 #endif
1205 
1206  template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) throw();
1207  template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) throw();
1208  template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) throw();
1209  template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) throw();
1210  template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) throw();
1211  template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) throw();
1212  template <class VS,class E> friend E _vsabs(const VS &sl) throw();
1213  template <class VS,class E> friend E _vsdiam(const VS &sl) throw();
1214  template <class VS,class E> friend E _vsmid(const VS &sl) throw();
1215  template <class VS,class E> friend E _vsinf(const VS &sl) throw();
1216  template <class VS,class E> friend E _vssup(const VS &sl) throw();
1217  template <class VS1,class VS2,class E> friend E _vsvsimult(const VS1 & sl1, const VS2 &sl2)
1218 #if(CXSC_INDEX_CHECK)
1219  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1220 #else
1221  throw();
1222 #endif
1223  template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw();
1224  template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw();
1225  template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw();
1226  template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw();
1227  template <class VS> friend bool _vsnot(const VS &sl) throw();
1228  template <class VS> friend void *_vsvoid(const VS &sl) throw();
1229  template <class V> friend std::ostream &_vsout(std::ostream &s, const V &rv) throw();
1230  template <class V> friend std::istream &_vsin(std::istream &s, V &rv) throw();
1231 
1232  // Interval / Real
1233  template <class V,class MS,class E> friend E _vmsimult(const V &v,const MS &ms)
1234 #if(CXSC_INDEX_CHECK)
1235  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1236 #else
1237  throw();
1238 #endif
1239 
1240  // complex
1241  template <class VS,class V,class E> friend E _vsvcimult(const VS & sl, const V &rv)
1242 #if(CXSC_INDEX_CHECK)
1243  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1244 #else
1245  throw();
1246 #endif
1247  template <class V,class VS> friend V &_vvssetim(V &rv, const VS &sl)
1248 #if(CXSC_INDEX_CHECK)
1249  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1250 #else
1251  throw();
1252 #endif
1253  template <class V,class VS> friend V &_vvssetre(V &rv, const VS &sl)
1254 #if(CXSC_INDEX_CHECK)
1255  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1256 #else
1257  throw();
1258 #endif
1259  template <class VS1,class VS2> friend VS1 &_vsvssetim(VS1 &sl1, const VS2 &sl2)
1260 #if(CXSC_INDEX_CHECK)
1261  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1262 #else
1263  throw();
1264 #endif
1265  template <class VS1,class VS2> friend VS1 &_vsvssetre(VS1 &sl1, const VS2 &sl2)
1266 #if(CXSC_INDEX_CHECK)
1267  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1268 #else
1269  throw();
1270 #endif
1271 
1272  // cinterval-- vector-scalar
1273  // cinterval -- vector-vector
1274 template <class VS1,class VS2,class E> friend E _vsvscimult(const VS1 & sl1, const VS2 &sl2)
1275 #if(CXSC_INDEX_CHECK)
1276  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1277 #else
1278  throw();
1279 #endif
1280 
1281  // cinterval -- vector-matrix
1282  // l_real
1283 
1284  template <class VS1,class VS2,class E> friend E _vsvslimult(const VS1 & sl1, const VS2 &sl2)
1285 #if(CXSC_INDEX_CHECK)
1286  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1287 #else
1288  throw();
1289 #endif
1290 
1291  // l_interval ----------
1292  // l_interval-- vector-scalar
1293  // l_interval -- vector-vector
1294 template <class VS,class V,class E> friend E _vsvlimult(const VS & sl, const V &rv)
1295 #if(CXSC_INDEX_CHECK)
1296  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1297 #else
1298  throw();
1299 #endif
1300 
1301 
1302 #endif
1303 
1304  //--------------------- Konstruktoren -----------------------------------
1306  explicit INLINE ivector_slice(ivector &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) { }
1308  explicit INLINE ivector_slice(ivector_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) { }
1309  public:
1311  INLINE ivector_slice(const ivector_slice &a) throw():dat(a.dat),l(a.l),u(a.u),size(a.size),start(a.start),end(a.end) { }
1312  public:
1313  // Interval
1315  INLINE ivector_slice & operator =(const sivector &sl);
1317  INLINE ivector_slice & operator =(const sivector_slice &sl);
1319  INLINE ivector_slice & operator =(const srvector &sl);
1321  INLINE ivector_slice & operator =(const srvector_slice &sl);
1322 
1324  INLINE ivector_slice & operator =(const ivector_slice &sl)
1325 #if(CXSC_INDEX_CHECK)
1326  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
1327 #else
1328  throw();
1329 #endif
1330  INLINE ivector_slice & operator =(const ivector &rv)
1332 #if(CXSC_INDEX_CHECK)
1333  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
1334 #else
1335  throw();
1336 #endif
1337  INLINE ivector_slice & operator =(const interval &r) throw();
1340  INLINE ivector_slice & operator =(const imatrix &m)
1341 #if(CXSC_INDEX_CHECK)
1342  throw(ERROR__OP_WITH_WRONG_DIM<ivector>,ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
1343 #else
1344  throw();
1345 #endif
1346  INLINE ivector_slice & operator =(const imatrix_slice &m)
1348 #if(CXSC_INDEX_CHECK)
1349  throw(ERROR__OP_WITH_WRONG_DIM<ivector>,ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
1350 #else
1351  throw();
1352 #endif
1353  INLINE ivector_slice &operator =(const imatrix_subv &) throw();
1355  // Real
1357  INLINE ivector_slice & operator =(const rvector_slice &sl)
1358 #if(CXSC_INDEX_CHECK)
1359  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
1360 #else
1361  throw();
1362 #endif
1363  INLINE ivector_slice & operator =(const rvector &rv)
1365 #if(CXSC_INDEX_CHECK)
1366  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
1367 #else
1368  throw();
1369 #endif
1370  INLINE ivector_slice & operator =(const real &r) throw();
1373  INLINE ivector_slice & operator =(const rmatrix &m)
1374 #if(CXSC_INDEX_CHECK)
1375  throw(ERROR__OP_WITH_WRONG_DIM<rvector>,ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
1376 #else
1377  throw();
1378 #endif
1379  INLINE ivector_slice & operator =(const rmatrix_slice &m)
1381 #if(CXSC_INDEX_CHECK)
1382  throw(ERROR__OP_WITH_WRONG_DIM<rvector>,ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
1383 #else
1384  throw();
1385 #endif
1386  INLINE ivector_slice &operator =(const rmatrix_subv &mv) throw();
1388 
1389  //--------------------- Standardfunktionen ------------------------------
1390 
1391  friend INLINE interval::interval(const ivector_slice &sl)
1392 #if(CXSC_INDEX_CHECK)
1393  throw(ERROR_IVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_IVECTOR_USE_OF_UNINITIALIZED_OBJ);
1394 #else
1395  throw();
1396 #endif
1397  friend INLINE int Lb(const ivector_slice &sl) throw() { return sl.start; }
1400  friend INLINE int Ub(const ivector_slice &sl) throw() { return sl.end; }
1402  friend INLINE int VecLen(const ivector_slice &sl) throw() { return sl.end-sl.start+1; }
1404  INLINE interval & operator [](const int &i) const
1405 #if(CXSC_INDEX_CHECK)
1406  throw(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC);
1407 #else
1408  throw();
1409 #endif
1410 
1412  INLINE interval & operator [](const int &i)
1413 #if(CXSC_INDEX_CHECK)
1414  throw(ERROR_IVECTOR_ELEMENT_NOT_IN_VEC);
1415 #else
1416  throw();
1417 #endif
1418 
1420  INLINE ivector_slice & operator ()() throw() { return *this; }
1422  INLINE ivector_slice operator ()(const int &i)
1423 #if(CXSC_INDEX_CHECK)
1424  throw(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG);
1425 #else
1426  throw();
1427 #endif
1428  INLINE ivector_slice operator ()(const int &i1,const int &i2)
1430 #if(CXSC_INDEX_CHECK)
1431  throw(ERROR_IVECTOR_SUB_ARRAY_TOO_BIG);
1432 #else
1433  throw();
1434 #endif
1435 
1437  INLINE ivector_slice &operator /=(const interval &r) throw();
1439  INLINE ivector_slice &operator /=(const real &r) throw();
1441  INLINE ivector_slice &operator *=(const interval &r) throw();
1443  INLINE ivector_slice &operator *=(const imatrix &m)
1444 #if(CXSC_INDEX_CHECK)
1445  throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
1446 #else
1447  throw();
1448 #endif
1449  INLINE ivector_slice &operator *=(const rmatrix &m)
1451 #if(CXSC_INDEX_CHECK)
1452  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
1453 #else
1454  throw();
1455 #endif
1456  INLINE ivector_slice &operator *=(const real &r) throw();
1459  INLINE ivector_slice &operator +=(const ivector &rv)
1460 #if(CXSC_INDEX_CHECK)
1461  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
1462 #else
1463  throw();
1464 #endif
1465  INLINE ivector_slice &operator +=(const ivector_slice &sl2)
1467 #if(CXSC_INDEX_CHECK)
1468  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
1469 #else
1470  throw();
1471 #endif
1472  INLINE ivector_slice &operator -=(const ivector &rv)
1474 #if(CXSC_INDEX_CHECK)
1475  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
1476 #else
1477  throw();
1478 #endif
1479  INLINE ivector_slice &operator -=(const ivector_slice &sl2)
1481 #if(CXSC_INDEX_CHECK)
1482  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
1483 #else
1484  throw();
1485 #endif
1486  INLINE ivector_slice &operator |=(const ivector &rv)
1488 #if(CXSC_INDEX_CHECK)
1489  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
1490 #else
1491  throw();
1492 #endif
1493  INLINE ivector_slice &operator |=(const ivector_slice &sl2)
1495 #if(CXSC_INDEX_CHECK)
1496  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
1497 #else
1498  throw();
1499 #endif
1500  INLINE ivector_slice &operator &=(const ivector &rv)
1502 #if(CXSC_INDEX_CHECK)
1503  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
1504 #else
1505  throw();
1506 #endif
1507  INLINE ivector_slice &operator &=(const ivector_slice &sl2)
1509 #if(CXSC_INDEX_CHECK)
1510  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
1511 #else
1512  throw();
1513 #endif
1514 
1516  INLINE ivector_slice &operator +=(const rvector &rv)
1517 #if(CXSC_INDEX_CHECK)
1518  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
1519 #else
1520  throw();
1521 #endif
1522  INLINE ivector_slice &operator +=(const rvector_slice &sl2)
1524 #if(CXSC_INDEX_CHECK)
1525  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
1526 #else
1527  throw();
1528 #endif
1529  INLINE ivector_slice &operator -=(const rvector &rv)
1531 #if(CXSC_INDEX_CHECK)
1532  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
1533 #else
1534  throw();
1535 #endif
1536  INLINE ivector_slice &operator -=(const rvector_slice &sl2)
1538 #if(CXSC_INDEX_CHECK)
1539  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
1540 #else
1541  throw();
1542 #endif
1543  INLINE ivector_slice &operator |=(const rvector &rv)
1545 #if(CXSC_INDEX_CHECK)
1546  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
1547 #else
1548  throw();
1549 #endif
1550  INLINE ivector_slice &operator |=(const rvector_slice &sl2)
1552 #if(CXSC_INDEX_CHECK)
1553  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
1554 #else
1555  throw();
1556 #endif
1557  INLINE ivector_slice &operator &=(const rvector &rv)
1559 #if(CXSC_INDEX_CHECK)
1560  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
1561 #else
1562  throw();
1563 #endif
1564  INLINE ivector_slice &operator &=(const rvector_slice &sl2)
1566 #if(CXSC_INDEX_CHECK)
1567  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
1568 #else
1569  throw();
1570 #endif
1571  INLINE operator void*() throw();
1572 //#else
1573 //#endif
1574 
1576  INLINE ivector_slice &operator+=(const srvector&);
1578  INLINE ivector_slice &operator+=(const sivector&);
1580  INLINE ivector_slice &operator+=(const srvector_slice&);
1582  INLINE ivector_slice &operator+=(const sivector_slice&);
1584  INLINE ivector_slice &operator-=(const srvector&);
1586  INLINE ivector_slice &operator-=(const sivector&);
1588  INLINE ivector_slice &operator-=(const srvector_slice&);
1590  INLINE ivector_slice &operator-=(const sivector_slice&);
1592  INLINE ivector_slice &operator|=(const srvector&);
1594  INLINE ivector_slice &operator|=(const sivector&);
1596  INLINE ivector_slice &operator|=(const srvector_slice&);
1598  INLINE ivector_slice &operator|=(const sivector_slice&);
1600  INLINE ivector_slice &operator&=(const sivector&);
1602  INLINE ivector_slice &operator&=(const sivector_slice&);
1603 
1604 };
1605 
1606 //=======================================================================
1607 //======================== Vector Functions =============================
1608 
1610  INLINE ivector _ivector(const interval &r) throw();
1611 // INLINE ivector _ivector(const imatrix &m) throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
1612 // INLINE ivector _ivector(const imatrix_slice &sl) throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
1614  INLINE ivector _ivector(const real &r) throw();
1616  INLINE ivector _ivector(const rvector_slice &rs) throw();
1618  INLINE ivector _ivector(const rvector &rs) throw();
1619 // INLINE ivector _ivector(const rmatrix &m) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
1620 // INLINE ivector _ivector(const rmatrix_slice &sl) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
1622  INLINE ivector _ivector(const rmatrix_subv &rs) throw();
1623 
1625  INLINE ivector &SetInf(ivector &iv,const rvector &rv)
1626 #if(CXSC_INDEX_CHECK)
1627  throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
1628 #else
1629  throw();
1630 #endif
1631  INLINE ivector_slice &SetInf(ivector_slice &iv,const rvector &rv)
1633 #if(CXSC_INDEX_CHECK)
1634  throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
1635 #else
1636  throw();
1637 #endif
1638  INLINE ivector &SetInf(ivector &iv,const rvector_slice &rv)
1640 #if(CXSC_INDEX_CHECK)
1641  throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
1642 #else
1643  throw();
1644 #endif
1645  INLINE ivector_slice &SetInf(ivector_slice &iv,const rvector_slice &rv)
1647 #if(CXSC_INDEX_CHECK)
1648  throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
1649 #else
1650  throw();
1651 #endif
1652  INLINE ivector &UncheckedSetInf(ivector &iv,const rvector &rv)
1654 #if(CXSC_INDEX_CHECK)
1655  throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
1656 #else
1657  throw();
1658 #endif
1659  INLINE ivector_slice &UncheckedSetInf(ivector_slice &iv,const rvector &rv)
1661 #if(CXSC_INDEX_CHECK)
1662  throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
1663 #else
1664  throw();
1665 #endif
1666  INLINE ivector &UncheckedSetInf(ivector &iv,const rvector_slice &rv)
1668 #if(CXSC_INDEX_CHECK)
1669  throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
1670 #else
1671  throw();
1672 #endif
1673  INLINE ivector_slice &UncheckedSetInf(ivector_slice &iv,const rvector_slice &rv)
1675 #if(CXSC_INDEX_CHECK)
1676  throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
1677 #else
1678  throw();
1679 #endif
1680 
1682  INLINE ivector &SetSup(ivector &iv,const rvector &rv)
1683 #if(CXSC_INDEX_CHECK)
1684  throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
1685 #else
1686  throw();
1687 #endif
1688  INLINE ivector_slice &SetSup(ivector_slice &iv,const rvector &rv)
1690 #if(CXSC_INDEX_CHECK)
1691  throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
1692 #else
1693  throw();
1694 #endif
1695  INLINE ivector &SetSup(ivector &iv,const rvector_slice &rv)
1697 #if(CXSC_INDEX_CHECK)
1698  throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
1699 #else
1700  throw();
1701 #endif
1702  INLINE ivector_slice &SetSup(ivector_slice &iv,const rvector_slice &rv)
1704 #if(CXSC_INDEX_CHECK)
1705  throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
1706 #else
1707  throw();
1708 #endif
1709  INLINE ivector &UncheckedSetSup(ivector &iv,const rvector &rv)
1711 #if(CXSC_INDEX_CHECK)
1712  throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
1713 #else
1714  throw();
1715 #endif
1716  INLINE ivector_slice &UncheckedSetSup(ivector_slice &iv,const rvector &rv)
1718 #if(CXSC_INDEX_CHECK)
1719  throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
1720 #else
1721  throw();
1722 #endif
1723  INLINE ivector &UncheckedSetSup(ivector &iv,const rvector_slice &rv)
1725 #if(CXSC_INDEX_CHECK)
1726  throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
1727 #else
1728  throw();
1729 #endif
1730  INLINE ivector_slice &UncheckedSetSup(ivector_slice &iv,const rvector_slice &rv)
1732 #if(CXSC_INDEX_CHECK)
1733  throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
1734 #else
1735  throw();
1736 #endif
1737 
1739  INLINE ivector &SetSup(ivector &iv,const real &r) throw();
1741  INLINE ivector &SetInf(ivector &iv,const real &r) throw();
1743  INLINE ivector &UncheckedSetSup(ivector &iv,const real &r) throw();
1745  INLINE ivector &SetUncheckedInf(ivector &iv,const real &r) throw();
1747  INLINE ivector_slice &SetSup(ivector_slice &iv,const real &r) throw();
1749  INLINE ivector_slice &SetInf(ivector_slice &iv,const real &r) throw();
1751  INLINE ivector_slice &UncheckedSetSup(ivector_slice &iv,const real &r) throw();
1753  INLINE ivector_slice &SetUncheckedInf(ivector_slice &iv,const real &r) throw();
1754 
1756  INLINE void Resize(ivector &rv) throw();
1758  INLINE void Resize(ivector &rv, const int &len)
1759 #if(CXSC_INDEX_CHECK)
1760  throw(ERROR__WRONG_BOUNDARIES<ivector>);
1761 #else
1762  throw();
1763 #endif
1764  INLINE void Resize(ivector &rv, const int &lb, const int &ub)
1766 #if(CXSC_INDEX_CHECK)
1767  throw(ERROR__WRONG_BOUNDARIES<ivector>);
1768 #else
1769  throw();
1770 #endif
1771 
1773  INLINE ivector abs(const ivector &rv) throw();
1775  INLINE ivector abs(const ivector_slice &sl) throw();
1777  INLINE rvector absmin(const ivector &rv) throw();
1779  INLINE rvector absmax(const ivector_slice &sl) throw();
1781  INLINE rvector absmin(const ivector &rv) throw();
1783  INLINE rvector absmax(const ivector_slice &sl) throw();
1785  INLINE rvector diam(const ivector &v) throw();
1787  INLINE rvector diam(const ivector_slice &v) throw();
1789  INLINE rvector mid(const ivector &v) throw();
1791  INLINE rvector mid(const ivector_slice &v) throw();
1793  INLINE rvector Inf(const ivector &v) throw();
1795  INLINE rvector Inf(const ivector_slice &v) throw();
1797  INLINE rvector Sup(const ivector &v) throw();
1799  INLINE rvector Sup(const ivector_slice &v) throw();
1801  INLINE bool operator !(const ivector &rv) throw();
1803  INLINE bool operator !(const ivector_slice &sl) throw();
1804 
1805 //======================= Vector / Scalar ===============================
1806 
1807 //----------------------------- Interval ---------------------------
1808 
1810  INLINE ivector operator *(const ivector &rv, const interval &s) throw();
1812  INLINE ivector operator *(const ivector_slice &sl, const interval &s) throw();
1814  INLINE ivector operator *(const interval &s, const ivector &rv) throw();
1816  INLINE ivector operator *(const interval &s, const ivector_slice &sl) throw();
1818  INLINE ivector &operator *=(ivector &rv,const interval &r) throw();
1819 
1821  INLINE ivector operator /(const ivector &rv, const interval &s) throw();
1823  INLINE ivector operator /(const ivector_slice &sl, const interval &s) throw();
1825  INLINE ivector &operator /=(ivector &rv,const interval &r) throw();
1826 
1827 //---------------------------- Real --------------------------------------
1828 
1830  INLINE ivector operator *(const ivector &rv, const real &s) throw();
1832  INLINE ivector operator *(const ivector_slice &sl, const real &s) throw();
1834  INLINE ivector operator *(const real &s, const ivector &rv) throw();
1836  INLINE ivector operator *(const real &s, const ivector_slice &sl) throw();
1838  INLINE ivector &operator *=(ivector &rv,const real &r) throw();
1839 
1841  INLINE ivector operator /(const ivector &rv, const real &s) throw();
1843  INLINE ivector operator /(const ivector_slice &sl, const real &s) throw();
1845  INLINE ivector &operator /=(ivector &rv,const real &r) throw();
1846 
1848  INLINE ivector operator *(const rvector &rv, const interval &s) throw();
1850  INLINE ivector operator *(const rvector_slice &sl, const interval &s) throw();
1852  INLINE ivector operator *(const interval &s, const rvector &rv) throw();
1854  INLINE ivector operator *(const interval &s, const rvector_slice &sl) throw();
1855 
1857  INLINE ivector operator /(const rvector &rv, const interval &s) throw();
1859  INLINE ivector operator /(const rvector_slice &sl, const interval &s) throw();
1860 
1861 //======================= Vector / Vector ===============================
1862 
1863 
1865  INLINE std::ostream &operator <<(std::ostream &s, const ivector &rv) throw();
1867  INLINE std::ostream &operator <<(std::ostream &o, const ivector_slice &sl) throw();
1869  INLINE std::istream &operator >>(std::istream &s, ivector &rv) throw();
1871  INLINE std::istream &operator >>(std::istream &s, ivector_slice &rv) throw();
1872 
1873 //----------------------- Interval / Interval ---------------------------
1874 
1876  void accumulate(idotprecision &dp, const ivector &);
1877 
1879  void accumulate(idotprecision &dp, const rvector &);
1880 
1882  void accumulate(idotprecision &dp, const ivector & rv1, const ivector &rv2)
1883 #if(CXSC_INDEX_CHECK)
1884  throw(OP_WITH_WRONG_DIM);
1885 #else
1886  throw();
1887 #endif
1888  void accumulate(idotprecision &dp, const ivector_slice & sl, const ivector &rv)
1890 #if(CXSC_INDEX_CHECK)
1891  throw(OP_WITH_WRONG_DIM);
1892 #else
1893  throw();
1894 #endif
1895  void accumulate(idotprecision &dp, const ivector &rv, const ivector_slice &sl)
1897 #if(CXSC_INDEX_CHECK)
1898  throw(OP_WITH_WRONG_DIM);
1899 #else
1900  throw();
1901 #endif
1902  void accumulate(idotprecision &dp, const ivector & rv1, const imatrix_subv &rv2)
1904 #if(CXSC_INDEX_CHECK)
1905  throw(OP_WITH_WRONG_DIM);
1906 #else
1907  throw();
1908 #endif
1909  void accumulate(idotprecision &dp, const imatrix_subv & rv1, const ivector &rv2)
1911 #if(CXSC_INDEX_CHECK)
1912  throw(OP_WITH_WRONG_DIM);
1913 #else
1914  throw();
1915 #endif
1916  void accumulate(idotprecision &dp, const ivector_slice & rv1, const imatrix_subv &rv2)
1918 #if(CXSC_INDEX_CHECK)
1919  throw(OP_WITH_WRONG_DIM);
1920 #else
1921  throw();
1922 #endif
1923  void accumulate(idotprecision &dp, const imatrix_subv & rv1, const ivector_slice &rv2)
1925 #if(CXSC_INDEX_CHECK)
1926  throw(OP_WITH_WRONG_DIM);
1927 #else
1928  throw();
1929 #endif
1930  void accumulate(idotprecision &dp, const ivector_slice & sl1, const ivector_slice &sl2)
1932 #if(CXSC_INDEX_CHECK)
1933  throw(OP_WITH_WRONG_DIM);
1934 #else
1935  throw();
1936 #endif
1937  void accumulate(cidotprecision &dp, const ivector & rv1, const ivector &rv2)
1939 #if(CXSC_INDEX_CHECK)
1940  throw(OP_WITH_WRONG_DIM);
1941 #else
1942  throw();
1943 #endif
1944  void accumulate(cidotprecision &dp, const ivector_slice & sl, const ivector &rv)
1946 #if(CXSC_INDEX_CHECK)
1947  throw(OP_WITH_WRONG_DIM);
1948 #else
1949  throw();
1950 #endif
1951  void accumulate(cidotprecision &dp, const ivector &rv, const ivector_slice &sl)
1953 #if(CXSC_INDEX_CHECK)
1954  throw(OP_WITH_WRONG_DIM);
1955 #else
1956  throw();
1957 #endif
1958  void accumulate(cidotprecision &dp, const ivector & rv1, const imatrix_subv &rv2)
1960 #if(CXSC_INDEX_CHECK)
1961  throw(OP_WITH_WRONG_DIM);
1962 #else
1963  throw();
1964 #endif
1965  void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const ivector &rv2)
1967 #if(CXSC_INDEX_CHECK)
1968  throw(OP_WITH_WRONG_DIM);
1969 #else
1970  throw();
1971 #endif
1972  void accumulate(cidotprecision &dp, const ivector_slice & sl1, const ivector_slice &sl2)
1974 #if(CXSC_INDEX_CHECK)
1975  throw(OP_WITH_WRONG_DIM);
1976 #else
1977  throw();
1978 #endif
1979 
1981  INLINE interval operator *(const ivector & rv1, const ivector &rv2)
1982 #if(CXSC_INDEX_CHECK)
1983  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
1984 #else
1985  throw();
1986 #endif
1987  INLINE interval operator *(const ivector_slice &sl, const ivector &rv)
1989 #if(CXSC_INDEX_CHECK)
1990  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
1991 #else
1992  throw();
1993 #endif
1994  INLINE interval operator *(const ivector &rv, const ivector_slice &sl)
1996 #if(CXSC_INDEX_CHECK)
1997  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
1998 #else
1999  throw();
2000 #endif
2001  INLINE interval operator *(const ivector_slice & sl1, const ivector_slice &sl2)
2003 #if(CXSC_INDEX_CHECK)
2004  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2005 #else
2006  throw();
2007 #endif
2008 
2010  INLINE const ivector &operator +(const ivector &rv) throw();
2012  INLINE ivector operator +(const ivector_slice &sl) throw();
2013 
2015  INLINE ivector operator +(const ivector &rv1, const ivector &rv2)
2016 #if(CXSC_INDEX_CHECK)
2017  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2018 #else
2019  throw();
2020 #endif
2021  INLINE ivector operator +(const ivector &rv, const ivector_slice &sl)
2023 #if(CXSC_INDEX_CHECK)
2024  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2025 #else
2026  throw();
2027 #endif
2028  INLINE ivector operator +(const ivector_slice &sl, const ivector &rv)
2030 #if(CXSC_INDEX_CHECK)
2031  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2032 #else
2033  throw();
2034 #endif
2035  INLINE ivector operator +(const ivector_slice &sl1, const ivector_slice &sl2)
2037 #if(CXSC_INDEX_CHECK)
2038  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2039 #else
2040  throw();
2041 #endif
2042  INLINE ivector & operator +=(ivector &rv1, const ivector &rv2)
2044 #if(CXSC_INDEX_CHECK)
2045  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2046 #else
2047  throw();
2048 #endif
2049  INLINE ivector &operator +=(ivector &rv, const ivector_slice &sl)
2051 #if(CXSC_INDEX_CHECK)
2052  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2053 #else
2054  throw();
2055 #endif
2056 
2058  INLINE ivector operator -(const ivector &rv) throw();
2060  INLINE ivector operator -(const ivector_slice &sl) throw();
2062  INLINE ivector operator -(const ivector &rv1, const ivector &rv2)
2063 #if(CXSC_INDEX_CHECK)
2064  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2065 #else
2066  throw();
2067 #endif
2068  INLINE ivector operator -(const ivector &rv, const ivector_slice &sl)
2070 #if(CXSC_INDEX_CHECK)
2071  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2072 #else
2073  throw();
2074 #endif
2075  INLINE ivector operator -(const ivector_slice &sl, const ivector &rv)
2077 #if(CXSC_INDEX_CHECK)
2078  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2079 #else
2080  throw();
2081 #endif
2082  INLINE ivector operator -(const ivector_slice &sl1, const ivector_slice &sl2)
2084 #if(CXSC_INDEX_CHECK)
2085  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2086 #else
2087  throw();
2088 #endif
2089  INLINE ivector & operator -=(ivector &rv1, const ivector &rv2)
2091 #if(CXSC_INDEX_CHECK)
2092  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2093 #else
2094  throw();
2095 #endif
2096  INLINE ivector &operator -=(ivector &rv, const ivector_slice &sl)
2098 #if(CXSC_INDEX_CHECK)
2099  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2100 #else
2101  throw();
2102 #endif
2103 
2105  INLINE ivector operator |(const ivector &rv1, const ivector &rv2)
2106 #if(CXSC_INDEX_CHECK)
2107  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2108 #else
2109  throw();
2110 #endif
2111  INLINE ivector operator |(const ivector &rv, const ivector_slice &sl)
2113 #if(CXSC_INDEX_CHECK)
2114  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2115 #else
2116  throw();
2117 #endif
2118  INLINE ivector operator |(const ivector_slice &sl, const ivector &rv)
2120 #if(CXSC_INDEX_CHECK)
2121  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2122 #else
2123  throw();
2124 #endif
2125  INLINE ivector operator |(const ivector_slice &sl1, const ivector_slice &sl2)
2127 #if(CXSC_INDEX_CHECK)
2128  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2129 #else
2130  throw();
2131 #endif
2132  INLINE ivector & operator |=(ivector &rv1, const ivector &rv2)
2134 #if(CXSC_INDEX_CHECK)
2135  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2136 #else
2137  throw();
2138 #endif
2139  INLINE ivector &operator |=(ivector &rv, const ivector_slice &sl)
2141 #if(CXSC_INDEX_CHECK)
2142  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2143 #else
2144  throw();
2145 #endif
2146 
2148  INLINE ivector operator &(const ivector &rv1, const ivector &rv2)
2149 #if(CXSC_INDEX_CHECK)
2150  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2151 #else
2152  throw();
2153 #endif
2154  INLINE ivector operator &(const ivector &rv, const ivector_slice &sl)
2156 #if(CXSC_INDEX_CHECK)
2157  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2158 #else
2159  throw();
2160 #endif
2161  INLINE ivector operator &(const ivector_slice &sl, const ivector &rv)
2163 #if(CXSC_INDEX_CHECK)
2164  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2165 #else
2166  throw();
2167 #endif
2168  INLINE ivector operator &(const ivector_slice &sl1, const ivector_slice &sl2)
2170 #if(CXSC_INDEX_CHECK)
2171  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2172 #else
2173  throw();
2174 #endif
2175  INLINE ivector & operator &=(ivector &rv1, const ivector &rv2)
2177 #if(CXSC_INDEX_CHECK)
2178  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2179 #else
2180  throw();
2181 #endif
2182  INLINE ivector &operator &=(ivector &rv, const ivector_slice &sl)
2184 #if(CXSC_INDEX_CHECK)
2185  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2186 #else
2187  throw();
2188 #endif
2189 
2191  INLINE bool operator ==(const ivector &rv1, const ivector &rv2) throw();
2193  INLINE bool operator ==(const ivector_slice &sl1, const ivector_slice &sl2) throw();
2195  INLINE bool operator ==(const ivector_slice &sl, const ivector &rv) throw();
2197  INLINE bool operator ==(const ivector &rv, const ivector_slice &sl) throw();
2199  INLINE bool operator !=(const ivector &rv1, const ivector &rv2) throw();
2201  INLINE bool operator !=(const ivector_slice &sl1, const ivector_slice &sl2) throw();
2203  INLINE bool operator !=(const ivector_slice &sl, const ivector &rv) throw();
2205  INLINE bool operator !=(const ivector &rv, const ivector_slice &sl) throw();
2207  INLINE bool operator <(const ivector &rv1, const ivector &rv2) throw();
2209  INLINE bool operator <(const ivector_slice &sl1, const ivector_slice &sl2) throw();
2211  INLINE bool operator < (const ivector_slice &sl, const ivector &rv) throw();
2213  INLINE bool operator < (const ivector &rv, const ivector_slice &sl) throw();
2215  INLINE bool operator <=(const ivector &rv1, const ivector &rv2) throw();
2217  INLINE bool operator <=(const ivector_slice &sl1, const ivector_slice &sl2) throw();
2219  INLINE bool operator <=(const ivector_slice &sl, const ivector &rv) throw();
2221  INLINE bool operator <=(const ivector &rv, const ivector_slice &sl) throw();
2223  INLINE bool operator >(const ivector &rv1, const ivector &rv2) throw();
2225  INLINE bool operator >(const ivector_slice &sl1, const ivector_slice &sl2) throw();
2227  INLINE bool operator >(const ivector_slice &sl, const ivector &rv) throw();
2229  INLINE bool operator >(const ivector &rv, const ivector_slice &sl) throw();
2231  INLINE bool operator >=(const ivector &rv1, const ivector &rv2) throw();
2233  INLINE bool operator >=(const ivector_slice &sl1, const ivector_slice &sl2) throw();
2235  INLINE bool operator >=(const ivector_slice &sl, const ivector &rv) throw();
2237  INLINE bool operator >=(const ivector &rv, const ivector_slice &sl) throw();
2238 
2239 //-------------------------------- Interval / Real --------------------------------
2240 
2242  void accumulate(idotprecision &dp, const rvector & rv1, const ivector &rv2)
2243 #if(CXSC_INDEX_CHECK)
2244  throw(OP_WITH_WRONG_DIM);
2245 #else
2246  throw();
2247 #endif
2248  void accumulate(idotprecision &dp, const ivector & rv1, const rvector &rv2)
2250 #if(CXSC_INDEX_CHECK)
2251  throw(OP_WITH_WRONG_DIM);
2252 #else
2253  throw();
2254 #endif
2255  void accumulate(idotprecision &dp, const rvector_slice & sl, const ivector &rv)
2257 #if(CXSC_INDEX_CHECK)
2258  throw(OP_WITH_WRONG_DIM);
2259 #else
2260  throw();
2261 #endif
2262  void accumulate(idotprecision &dp,const ivector_slice &sl,const rvector &rv)
2264 #if(CXSC_INDEX_CHECK)
2265  throw(OP_WITH_WRONG_DIM);
2266 #else
2267  throw();
2268 #endif
2269  void accumulate(idotprecision &dp, const rvector &rv, const ivector_slice &sl)
2271 #if(CXSC_INDEX_CHECK)
2272  throw(OP_WITH_WRONG_DIM);
2273 #else
2274  throw();
2275 #endif
2276  void accumulate(idotprecision &dp, const rvector & rv1, const imatrix_subv &rv2)
2278 #if(CXSC_INDEX_CHECK)
2279  throw(OP_WITH_WRONG_DIM);
2280 #else
2281  throw();
2282 #endif
2283  void accumulate(idotprecision &dp, const ivector & rv1, const rmatrix_subv &rv2)
2285 #if(CXSC_INDEX_CHECK)
2286  throw(OP_WITH_WRONG_DIM);
2287 #else
2288  throw();
2289 #endif
2290  void accumulate(idotprecision &dp, const rvector_slice & rv1, const imatrix_subv &rv2)
2292 #if(CXSC_INDEX_CHECK)
2293  throw(OP_WITH_WRONG_DIM);
2294 #else
2295  throw();
2296 #endif
2297  void accumulate(idotprecision &dp, const ivector_slice & rv1, const rmatrix_subv &rv2)
2299 #if(CXSC_INDEX_CHECK)
2300  throw(OP_WITH_WRONG_DIM);
2301 #else
2302  throw();
2303 #endif
2304  void accumulate(idotprecision &dp,const ivector &rv,const rvector_slice &sl)
2306 #if(CXSC_INDEX_CHECK)
2307  throw(OP_WITH_WRONG_DIM);
2308 #else
2309  throw();
2310 #endif
2311  void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const ivector &rv2)
2313 #if(CXSC_INDEX_CHECK)
2314  throw(OP_WITH_WRONG_DIM);
2315 #else
2316  throw();
2317 #endif
2318  void accumulate(idotprecision &dp, const imatrix_subv & rv1, const rvector &rv2)
2320 #if(CXSC_INDEX_CHECK)
2321  throw(OP_WITH_WRONG_DIM);
2322 #else
2323  throw();
2324 #endif
2325  void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const ivector_slice &rv2)
2327 #if(CXSC_INDEX_CHECK)
2328  throw(OP_WITH_WRONG_DIM);
2329 #else
2330  throw();
2331 #endif
2332  void accumulate(idotprecision &dp, const imatrix_subv & rv1, const rvector_slice &rv2)
2334 #if(CXSC_INDEX_CHECK)
2335  throw(OP_WITH_WRONG_DIM);
2336 #else
2337  throw();
2338 #endif
2339  void accumulate(idotprecision &dp, const ivector_slice & sl1, const rvector_slice &sl2)
2341 #if(CXSC_INDEX_CHECK)
2342  throw(OP_WITH_WRONG_DIM);
2343 #else
2344  throw();
2345 #endif
2346  void accumulate(idotprecision &dp, const rvector_slice & sl1, const ivector_slice &sl2)
2348 #if(CXSC_INDEX_CHECK)
2349  throw(OP_WITH_WRONG_DIM);
2350 #else
2351  throw();
2352 #endif
2353  void accumulate(cidotprecision &dp, const rvector & rv1, const ivector &rv2)
2355 #if(CXSC_INDEX_CHECK)
2356  throw(OP_WITH_WRONG_DIM);
2357 #else
2358  throw();
2359 #endif
2360  void accumulate(cidotprecision &dp, const ivector & rv1, const rvector &rv2)
2362 #if(CXSC_INDEX_CHECK)
2363  throw(OP_WITH_WRONG_DIM);
2364 #else
2365  throw();
2366 #endif
2367  void accumulate(cidotprecision &dp, const rvector_slice & sl, const ivector &rv)
2369 #if(CXSC_INDEX_CHECK)
2370  throw(OP_WITH_WRONG_DIM);
2371 #else
2372  throw();
2373 #endif
2374  void accumulate(cidotprecision &dp,const ivector_slice &sl,const rvector &rv)
2376 #if(CXSC_INDEX_CHECK)
2377  throw(OP_WITH_WRONG_DIM);
2378 #else
2379  throw();
2380 #endif
2381  void accumulate(cidotprecision &dp, const rvector &rv, const ivector_slice &sl)
2383 #if(CXSC_INDEX_CHECK)
2384  throw(OP_WITH_WRONG_DIM);
2385 #else
2386  throw();
2387 #endif
2388  void accumulate(cidotprecision &dp, const rvector & rv1, const imatrix_subv &rv2)
2390 #if(CXSC_INDEX_CHECK)
2391  throw(OP_WITH_WRONG_DIM);
2392 #else
2393  throw();
2394 #endif
2395  void accumulate(cidotprecision &dp, const ivector & rv1, const rmatrix_subv &rv2)
2397 #if(CXSC_INDEX_CHECK)
2398  throw(OP_WITH_WRONG_DIM);
2399 #else
2400  throw();
2401 #endif
2402  void accumulate(cidotprecision &dp, const rvector_slice & rv1, const imatrix_subv &rv2)
2404 #if(CXSC_INDEX_CHECK)
2405  throw(OP_WITH_WRONG_DIM);
2406 #else
2407  throw();
2408 #endif
2409  void accumulate(cidotprecision &dp, const ivector_slice & rv1, const rmatrix_subv &rv2)
2411 #if(CXSC_INDEX_CHECK)
2412  throw(OP_WITH_WRONG_DIM);
2413 #else
2414  throw();
2415 #endif
2416  void accumulate(cidotprecision &dp,const ivector &rv,const rvector_slice &sl)
2418 #if(CXSC_INDEX_CHECK)
2419  throw(OP_WITH_WRONG_DIM);
2420 #else
2421  throw();
2422 #endif
2423  void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const ivector &rv2)
2425 #if(CXSC_INDEX_CHECK)
2426  throw(OP_WITH_WRONG_DIM);
2427 #else
2428  throw();
2429 #endif
2430  void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const rvector &rv2)
2432 #if(CXSC_INDEX_CHECK)
2433  throw(OP_WITH_WRONG_DIM);
2434 #else
2435  throw();
2436 #endif
2437  void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const ivector_slice &rv2)
2439 #if(CXSC_INDEX_CHECK)
2440  throw(OP_WITH_WRONG_DIM);
2441 #else
2442  throw();
2443 #endif
2444  void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const rvector_slice &rv2)
2446 #if(CXSC_INDEX_CHECK)
2447  throw(OP_WITH_WRONG_DIM);
2448 #else
2449  throw();
2450 #endif
2451  void accumulate(cidotprecision &dp, const ivector_slice & sl1, const rvector_slice &sl2)
2453 #if(CXSC_INDEX_CHECK)
2454  throw(OP_WITH_WRONG_DIM);
2455 #else
2456  throw();
2457 #endif
2458  void accumulate(cidotprecision &dp, const rvector_slice & sl1, const ivector_slice &sl2)
2460 #if(CXSC_INDEX_CHECK)
2461  throw(OP_WITH_WRONG_DIM);
2462 #else
2463  throw();
2464 #endif
2465 
2467  INLINE interval operator *(const rvector & rv1, const ivector &rv2)
2468 #if(CXSC_INDEX_CHECK)
2469  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2470 #else
2471  throw();
2472 #endif
2473  INLINE interval operator *(const rvector_slice &sl, const ivector &rv)
2475 #if(CXSC_INDEX_CHECK)
2476  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2477 #else
2478  throw();
2479 #endif
2480  INLINE interval operator *(const rvector &rv, const ivector_slice &sl)
2482 #if(CXSC_INDEX_CHECK)
2483  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2484 #else
2485  throw();
2486 #endif
2487  INLINE interval operator *(const rvector_slice & sl1, const ivector_slice &sl2)
2489 #if(CXSC_INDEX_CHECK)
2490  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2491 #else
2492  throw();
2493 #endif
2494 
2496  INLINE interval operator *(const ivector & rv1, const rvector &rv2)
2497 #if(CXSC_INDEX_CHECK)
2498  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2499 #else
2500  throw();
2501 #endif
2502  INLINE interval operator *(const ivector_slice &sl, const rvector &rv)
2504 #if(CXSC_INDEX_CHECK)
2505  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2506 #else
2507  throw();
2508 #endif
2509  INLINE interval operator *(const ivector &rv, const rvector_slice &sl)
2511 #if(CXSC_INDEX_CHECK)
2512  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2513 #else
2514  throw();
2515 #endif
2516  INLINE interval operator *(const ivector_slice & sl1, const rvector_slice &sl2)
2518 #if(CXSC_INDEX_CHECK)
2519  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2520 #else
2521  throw();
2522 #endif
2523 
2525  INLINE ivector operator +(const rvector &rv1, const ivector &rv2)
2526 #if(CXSC_INDEX_CHECK)
2527  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2528 #else
2529  throw();
2530 #endif
2531  INLINE ivector operator +(const rvector &rv, const ivector_slice &sl)
2533 #if(CXSC_INDEX_CHECK)
2534  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2535 #else
2536  throw();
2537 #endif
2538  INLINE ivector operator +(const rvector_slice &sl, const ivector &rv)
2540 #if(CXSC_INDEX_CHECK)
2541  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2542 #else
2543  throw();
2544 #endif
2545  INLINE ivector operator +(const rvector_slice &sl1, const ivector_slice &sl2)
2547 #if(CXSC_INDEX_CHECK)
2548  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2549 #else
2550  throw();
2551 #endif
2552 
2554  INLINE ivector operator +(const ivector &rv1, const rvector &rv2)
2555 #if(CXSC_INDEX_CHECK)
2556  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2557 #else
2558  throw();
2559 #endif
2560  INLINE ivector operator +(const ivector &rv, const rvector_slice &sl)
2562 #if(CXSC_INDEX_CHECK)
2563  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2564 #else
2565  throw();
2566 #endif
2567  INLINE ivector operator +(const ivector_slice &sl, const rvector &rv)
2569 #if(CXSC_INDEX_CHECK)
2570  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2571 #else
2572  throw();
2573 #endif
2574  INLINE ivector operator +(const ivector_slice &sl1, const rvector_slice &sl2)
2576 #if(CXSC_INDEX_CHECK)
2577  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2578 #else
2579  throw();
2580 #endif
2581 
2583  INLINE ivector & operator +=(ivector &rv1, const rvector &rv2)
2584 #if(CXSC_INDEX_CHECK)
2585  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2586 #else
2587  throw();
2588 #endif
2589  INLINE ivector &operator +=(ivector &rv, const rvector_slice &sl)
2591 #if(CXSC_INDEX_CHECK)
2592  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2593 #else
2594  throw();
2595 #endif
2596 
2598  INLINE ivector operator -(const rvector &rv1, const ivector &rv2)
2599 #if(CXSC_INDEX_CHECK)
2600  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2601 #else
2602  throw();
2603 #endif
2604  INLINE ivector operator -(const rvector &rv, const ivector_slice &sl)
2606 #if(CXSC_INDEX_CHECK)
2607  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2608 #else
2609  throw();
2610 #endif
2611  INLINE ivector operator -(const rvector_slice &sl, const ivector &rv)
2613 #if(CXSC_INDEX_CHECK)
2614  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2615 #else
2616  throw();
2617 #endif
2618  INLINE ivector operator -(const rvector_slice &sl1, const ivector_slice &sl2)
2620 #if(CXSC_INDEX_CHECK)
2621  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2622 #else
2623  throw();
2624 #endif
2625 
2627  INLINE ivector operator -(const ivector &rv1, const rvector &rv2)
2628 #if(CXSC_INDEX_CHECK)
2629  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2630 #else
2631  throw();
2632 #endif
2633  INLINE ivector operator -(const ivector &rv, const rvector_slice &sl)
2635 #if(CXSC_INDEX_CHECK)
2636  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2637 #else
2638  throw();
2639 #endif
2640  INLINE ivector operator -(const ivector_slice &sl, const rvector &rv)
2642 #if(CXSC_INDEX_CHECK)
2643  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2644 #else
2645  throw();
2646 #endif
2647  INLINE ivector operator -(const ivector_slice &sl1, const rvector_slice &sl2)
2649 #if(CXSC_INDEX_CHECK)
2650  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2651 #else
2652  throw();
2653 #endif
2654 
2656  INLINE ivector & operator -=(ivector &rv1, const rvector &rv2)
2657 #if(CXSC_INDEX_CHECK)
2658  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2659 #else
2660  throw();
2661 #endif
2662  INLINE ivector &operator -=(ivector &rv, const rvector_slice &sl)
2664 #if(CXSC_INDEX_CHECK)
2665  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2666 #else
2667  throw();
2668 #endif
2669 
2671  INLINE ivector operator |(const rvector &rv1, const rvector &rv2)
2672 #if(CXSC_INDEX_CHECK)
2673  throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
2674 #else
2675  throw();
2676 #endif
2677  INLINE ivector operator |(const rvector &rv, const rvector_slice &sl)
2679 #if(CXSC_INDEX_CHECK)
2680  throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
2681 #else
2682  throw();
2683 #endif
2684  INLINE ivector operator |(const rvector_slice &sl, const rvector &rv)
2686 #if(CXSC_INDEX_CHECK)
2687  throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
2688 #else
2689  throw();
2690 #endif
2691  INLINE ivector operator |(const rvector_slice &sl1, const rvector_slice &sl2)
2693 #if(CXSC_INDEX_CHECK)
2694  throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
2695 #else
2696  throw();
2697 #endif
2698  INLINE ivector operator |(const rvector &rv1, const ivector &rv2)
2700 #if(CXSC_INDEX_CHECK)
2701  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2702 #else
2703  throw();
2704 #endif
2705  INLINE ivector operator |(const rvector &rv, const ivector_slice &sl)
2707 #if(CXSC_INDEX_CHECK)
2708  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2709 #else
2710  throw();
2711 #endif
2712  INLINE ivector operator |(const rvector_slice &sl, const ivector &rv)
2714 #if(CXSC_INDEX_CHECK)
2715  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2716 #else
2717  throw();
2718 #endif
2719  INLINE ivector operator |(const rvector_slice &sl1, const ivector_slice &sl2)
2721 #if(CXSC_INDEX_CHECK)
2722  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2723 #else
2724  throw();
2725 #endif
2726 
2728  INLINE ivector operator |(const ivector &rv1, const rvector &rv2)
2729 #if(CXSC_INDEX_CHECK)
2730  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2731 #else
2732  throw();
2733 #endif
2734  INLINE ivector operator |(const ivector &rv, const rvector_slice &sl)
2736 #if(CXSC_INDEX_CHECK)
2737  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2738 #else
2739  throw();
2740 #endif
2741  INLINE ivector operator |(const ivector_slice &sl, const rvector &rv)
2743 #if(CXSC_INDEX_CHECK)
2744  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2745 #else
2746  throw();
2747 #endif
2748  INLINE ivector operator |(const ivector_slice &sl1, const rvector_slice &sl2)
2750 #if(CXSC_INDEX_CHECK)
2751  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2752 #else
2753  throw();
2754 #endif
2755 
2757  INLINE ivector & operator |=(ivector &rv1, const rvector &rv2)
2758 #if(CXSC_INDEX_CHECK)
2759  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2760 #else
2761  throw();
2762 #endif
2763  INLINE ivector &operator |=(ivector &rv, const rvector_slice &sl)
2765 #if(CXSC_INDEX_CHECK)
2766  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2767 #else
2768  throw();
2769 #endif
2770 
2772  INLINE ivector operator &(const rvector &rv1, const ivector &rv2)
2773 #if(CXSC_INDEX_CHECK)
2774  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2775 #else
2776  throw();
2777 #endif
2778  INLINE ivector operator &(const rvector &rv, const ivector_slice &sl)
2780 #if(CXSC_INDEX_CHECK)
2781  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2782 #else
2783  throw();
2784 #endif
2785  INLINE ivector operator &(const rvector_slice &sl, const ivector &rv)
2787 #if(CXSC_INDEX_CHECK)
2788  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2789 #else
2790  throw();
2791 #endif
2792  INLINE ivector operator &(const rvector_slice &sl1, const ivector_slice &sl2)
2794 #if(CXSC_INDEX_CHECK)
2795  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2796 #else
2797  throw();
2798 #endif
2799 
2801  INLINE ivector operator &(const ivector &rv1, const rvector &rv2)
2802 #if(CXSC_INDEX_CHECK)
2803  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2804 #else
2805  throw();
2806 #endif
2807  INLINE ivector operator &(const ivector &rv, const rvector_slice &sl)
2809 #if(CXSC_INDEX_CHECK)
2810  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2811 #else
2812  throw();
2813 #endif
2814  INLINE ivector operator &(const ivector_slice &sl, const rvector &rv)
2816 #if(CXSC_INDEX_CHECK)
2817  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2818 #else
2819  throw();
2820 #endif
2821  INLINE ivector operator &(const ivector_slice &sl1, const rvector_slice &sl2)
2823 #if(CXSC_INDEX_CHECK)
2824  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2825 #else
2826  throw();
2827 #endif
2828 
2830  INLINE ivector & operator &=(ivector &rv1, const rvector &rv2)
2831 #if(CXSC_INDEX_CHECK)
2832  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2833 #else
2834  throw();
2835 #endif
2836  INLINE ivector &operator &=(ivector &rv, const rvector_slice &sl)
2838 #if(CXSC_INDEX_CHECK)
2839  throw(ERROR__OP_WITH_WRONG_DIM<ivector>);
2840 #else
2841  throw();
2842 #endif
2843 
2845 extern int in ( const ivector&, const ivector& );
2847 extern int in ( int, ivector& );
2849 extern ivector Blow ( const ivector&, real );
2851 extern int Disjoint ( ivector&, ivector& );
2853 extern int Zero ( ivector& );
2855 extern rvector mid ( ivector& );
2857 extern real MaxRelDiam ( const ivector& );
2859 extern real MaxRelDiam ( const ivector_slice& );
2861 extern int UlpAcc ( ivector&, int );
2863 extern void DoubleSize ( ivector& );
2864 
2865 
2866 } // namespace cxsc
2867 
2868 #ifdef _CXSC_INCL_INL
2869 #include "vector.inl"
2870 #include "ivector.inl"
2871 #endif
2872 
2873 #ifdef _CXSC_RMATRIX_HPP_INCLUDED
2874 # ifdef _CXSC_INCL_INL
2875 # include "ivecrmat.inl"
2876 # else
2877 # include "ivecrmat.hpp"
2878 # endif
2879 #endif
2880 
2881 #ifdef _CXSC_CMATRIX_HPP_INCLUDED
2882 # ifdef _CXSC_INCL_INL
2883 # include "iveccmat.inl"
2884 # else
2885 # include "iveccmat.hpp"
2886 # endif
2887 #endif
2888 
2889 #ifdef _CXSC_LRMATRIX_HPP_INCLUDED
2890 # ifdef _CXSC_INCL_INL
2891 # include "iveclrmat.inl"
2892 # else
2893 # include "iveclrmat.hpp"
2894 # endif
2895 #endif
2896 
2897 #ifdef _CXSC_CVECTOR_HPP_INCLUDED
2898 # ifdef _CXSC_INCL_INL
2899 # include "iveccvec.inl"
2900 # else
2901 # include "iveccvec.hpp"
2902 # endif
2903 #endif
2904 
2905 #ifdef _CXSC_LRVECTOR_HPP_INCLUDED
2906 # ifdef _CXSC_INCL_INL
2907 # include "lrvecivec.inl"
2908 # else
2909 # include "lrvecivec.hpp"
2910 # endif
2911 #endif
2912 
2913 #ifdef CXSC_USE_BLAS
2914 #define _CXSC_BLAS_IVECTOR
2915 #include "cxsc_blas.inl"
2916 #endif
2917 
2918 #endif
cinterval Blow(cinterval x, const real &eps)
Performs an epsilon inflation.
Definition: cinterval.cpp:665
real MaxRelDiam(const imatrix_subv &v)
Computes the relative diameter .
Definition: imatrix.cpp:76
ivector_slice(ivector &a, const int &lb, const int &ub)
Constructor of class ivector_slice.
Definition: ivector.hpp:1306
The Data Type rmatrix_slice.
Definition: rmatrix.hpp:1442
friend int Lb(const ivector &rv)
Returns the lower bound of the vector.
Definition: ivector.hpp:908
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
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
ivector_slice & operator|=(const ivector &rv)
Allocates the convex hull of the arguments to the first argument.
Definition: ivector.inl:726
ivector & operator+=(const srvector &)
Implementation of assignment and addition operator.
Definition: sivector.hpp:1189
ivector_slice & operator*=(const interval &r)
Implementation of multiplication and allocation operation.
Definition: ivector.inl:496
ivector & operator|=(const srvector &)
Implementation of assignment and hull operator.
Definition: sivector.hpp:1221
ivector_slice & operator()()
Operator for accessing the whole vector.
Definition: ivector.hpp:1420
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
int Zero(ivector &x)
Checks if vector is zero vector.
Definition: ivector.cpp:80
civector operator*(const cimatrix_subv &rv, const cinterval &s)
Implementation of multiplication operation.
Definition: cimatrix.inl:731
int in(const cinterval &x, const cinterval &y)
Checks if first argument is part of second argument.
Definition: cinterval.cpp:654
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
A sparse interval vector.
Definition: sivector.hpp:59
friend ivector & SetUb(ivector &rv, const int &u)
Sets the upper bound of the vector.
Definition: ivector.hpp:916
ivector_slice(ivector_slice &a, const int &lb, const int &ub)
Constructor of class ivector_slice.
Definition: ivector.hpp:1308
int UlpAcc(const interval &x, int n)
Checks if the diameter of the interval is ulps.
Definition: interval.cpp:335
The Multiple-Precision Data Type l_ivector.
Definition: l_ivector.hpp:54
friend int Lb(const ivector_slice &sl)
Returns the lower bound of the vector.
Definition: ivector.hpp:1398
void DoubleSize(cimatrix &A)
Doubles the size of the matrix.
Definition: cimatrix.cpp:83
friend int Ub(const ivector_slice &sl)
Returns the upper bound of the vector.
Definition: ivector.hpp:1400
friend int VecLen(const ivector &rv)
Returns the dimension of the vector.
Definition: ivector.hpp:912
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
ivector_slice & operator&=(const ivector &rv)
Allocates the intersection of the arguments to the first argument.
Definition: ivector.inl:783
The Data Type rvector_slice.
Definition: rvector.hpp:1063
The Multiple-Precision Data Type l_imatrix.
Definition: l_imatrix.hpp:725
ivector & operator&=(const sivector &)
Implementation of assignment and intersection operator.
Definition: sivector.hpp:1237
The Data Type rmatrix_subv.
Definition: rmatrix.hpp:53
friend ivector & SetLb(ivector &rv, const int &l)
Sets the lower bound of the vector.
Definition: ivector.hpp:914
The Data Type rvector.
Definition: rvector.hpp:57
ivector_slice & operator+=(const ivector &rv)
Implementation of addition and allocation operation.
Definition: ivector.inl:610
void Resize(cimatrix &A)
Resizes the matrix.
Definition: cimatrix.inl:1211
Helper class for slices of sparse vectors.
Definition: sivector.hpp:1831
cvector diam(const cimatrix_subv &mv)
Returns the diameter of the matrix.
Definition: cimatrix.inl:738
interval & operator[](const int &i) const
Operator for accessing the single elements of the vector (read-only)
Definition: ivector.inl:100
int Disjoint(const interval &a, const interval &b)
Checks arguments for disjointness.
Definition: interval.cpp:288
friend int VecLen(const ivector_slice &sl)
Returns the dimension of the vector.
Definition: ivector.hpp:1402
The Data Type rmatrix.
Definition: rmatrix.hpp:470
interval()
Constructor of class interval.
Definition: interval.hpp:64
interval & operator[](const int &i) const
Operator for accessing the single elements of the vector (read-only)
Definition: ivector.inl:126
The Data Type ivector.
Definition: ivector.hpp:54
ivector & operator=(const ivector &rv)
Implementation of standard assigning operator.
Definition: ivector.inl:263
rvector absmax(const imatrix_subv &mv)
Returns the absolute maximum value of the matrix.
Definition: imatrix.inl:502
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc)
Implementation of standard algebraic addition and allocation operation.
Definition: cdot.inl:251
INLINE ivector _ivector(const rmatrix &sl)
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC.
Definition: ivecrmat.inl:57
The Data Type imatrix.
Definition: imatrix.hpp:659
Helper class for slices of sparse vectors.
Definition: srvector.hpp:868
ivector_slice & operator/=(const interval &r)
Implementation of division and allocation operation.
Definition: ivector.inl:501
ivector_slice(const ivector_slice &a)
Constructor of class ivector_slice.
Definition: ivector.hpp:1311
ivector & operator-=(const srvector &)
Implementation of assignment and substraction operator.
Definition: sivector.hpp:1205
civector operator/(const cimatrix_subv &rv, const cinterval &s)
Implementation of division operation.
Definition: cimatrix.inl:730
ivector_slice & operator=(const sivector &sl)
Implementation of standard assigning operator.
Definition: sivector.hpp:2194
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
friend int Ub(const ivector &rv)
Returns the upper bound of the vector.
Definition: ivector.hpp:910
rvector absmin(const imatrix_subv &mv)
Returns the absolute minimum value of the matrix.
Definition: imatrix.inl:496
The Data Type intvector.
Definition: intvector.hpp:51
ivector()
Constructor of class ivector.
Definition: ivector.inl:31
ivector & operator()()
Operator for accessing the whole vector.
Definition: ivector.hpp:934
ivector_slice & operator-=(const ivector &rv)
Implementation of subtraction and allocation operation.
Definition: ivector.inl:669
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