C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
l_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: l_ivector.hpp,v 1.19 2014/01/30 17:23:46 cxsc Exp $ */
25 
26 #ifndef _CXSC_LIVECTOR_HPP_INCLUDED
27 #define _CXSC_LIVECTOR_HPP_INCLUDED
28 
29 #include "xscclass.hpp"
30 #include "except.hpp"
31 #include "idot.hpp"
32 #include "l_interval.hpp" // used for declaration of Inf, Sup,...
33 //#include "cxscmatr.hpp"
34 #include "rvector.hpp"
35 #include "ivector.hpp"
36 #include "l_rvector.hpp"
37 #include "vector.hpp"
38 
39 
40 #include <iostream>
41 
42 //#include "matrix.hpp" // hat hier eigentlich nichts zu suchen, sonst aber Internal Compiler Error #9
43 
44 namespace cxsc {
45 
46 class l_ivector_slice;
47 
49 
54 class l_ivector
55 {
56  friend class l_ivector_slice;
57  friend class l_imatrix;
58  friend class l_imatrix_subv;
59  private:
60  l_interval *dat;
61  int l,u,size;
62 
63  public:
64 //#if(CXSC_INDEX_CHECK)
65 #ifdef _CXSC_FRIEND_TPL
66  //------------ Templates --------------------------------------------------
67  // l_interval
68 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m)
69 #if(CXSC_INDEX_CHECK)
70  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>);
71 #else
72  throw();
73 #endif
74 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
75 #if(CXSC_INDEX_CHECK)
76  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
77 #else
78  throw();
79 #endif
80  template <class V> friend void _vresize(V &rv) throw();
81  template <class V,class S> friend void _vresize(V &rv, const int &len)
82 #if(CXSC_INDEX_CHECK)
83  throw(ERROR__WRONG_BOUNDARIES<V>);
84 #else
85  throw();
86 #endif
87  template <class V,class S> friend void _vresize(V &rv, const int &lb, const int &ub)
88 #if(CXSC_INDEX_CHECK)
89  throw(ERROR__WRONG_BOUNDARIES<V>);
90 #else
91  throw();
92 #endif
93  template <class V1,class V2,class S> friend V1 &_vvassign(V1 &rv1,const V2 &rv2) throw();
94  template <class V,class S> friend V & _vsassign(V &rv,const S &r) throw();
95  template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) throw();
96  template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv)
97 #if(CXSC_INDEX_CHECK)
98  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
99 #else
100  throw();
101 #endif
102 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m)
103 #if(CXSC_INDEX_CHECK)
104  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
105 #else
106  throw();
107 #endif
108 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) throw();
109  template <class V1,class V2> friend V1 &_vvsetinf(V1 &rv1, const V2 &rv2)
110 #if(CXSC_INDEX_CHECK)
111  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
112 #else
113  throw();
114 #endif
115  template <class V1,class V2> friend V1 &_vvsetsup(V1 &rv1, const V2 &rv2)
116 #if(CXSC_INDEX_CHECK)
117  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
118 #else
119  throw();
120 #endif
121  template <class V,class VS> friend V &_vvssetinf(V &rv, const VS &sl)
122 #if(CXSC_INDEX_CHECK)
123  throw(ERROR__OP_WITH_WRONG_DIM<V>);
124 #else
125  throw();
126 #endif
127  template <class V,class VS> friend V &_vvssetsup(V &rv, const VS &sl)
128 #if(CXSC_INDEX_CHECK)
129  throw(ERROR__OP_WITH_WRONG_DIM<V>);
130 #else
131  throw();
132 #endif
133 template <class V,class MV> friend V &_vmvsetinf(V &rv,const MV &v)
134 #if(CXSC_INDEX_CHECK)
135  throw(ERROR__OP_WITH_WRONG_DIM<V>);
136 #else
137  throw();
138 #endif
139 template <class V,class MV> friend V &_vmvsetsup(V &rv,const MV &v)
140 #if(CXSC_INDEX_CHECK)
141  throw(ERROR__OP_WITH_WRONG_DIM<V>);
142 #else
143  throw();
144 #endif
145  template <class V1,class V2> friend V1 &_vvusetinf(V1 &rv1, const V2 &rv2)
146 #if(CXSC_INDEX_CHECK)
147  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
148 #else
149  throw();
150 #endif
151  template <class V1,class V2> friend V1 &_vvusetsup(V1 &rv1, const V2 &rv2)
152 #if(CXSC_INDEX_CHECK)
153  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
154 #else
155  throw();
156 #endif
157  template <class V,class VS> friend V &_vvsusetinf(V &rv, const VS &sl)
158 #if(CXSC_INDEX_CHECK)
159  throw(ERROR__OP_WITH_WRONG_DIM<V>);
160 #else
161  throw();
162 #endif
163  template <class V,class VS> friend V &_vvsusetsup(V &rv, const VS &sl)
164 #if(CXSC_INDEX_CHECK)
165  throw(ERROR__OP_WITH_WRONG_DIM<V>);
166 #else
167  throw();
168 #endif
169 template <class V,class MV> friend V &_vmvusetinf(V &rv,const MV &v)
170 #if(CXSC_INDEX_CHECK)
171  throw(ERROR__OP_WITH_WRONG_DIM<V>);
172 #else
173  throw();
174 #endif
175 template <class V,class MV> friend V &_vmvusetsup(V &rv,const MV &v)
176 #if(CXSC_INDEX_CHECK)
177  throw(ERROR__OP_WITH_WRONG_DIM<V>);
178 #else
179  throw();
180 #endif
181  template <class V,class S> friend V &_vssetinf(V &v, const S &s) throw();
182  template <class V,class S> friend V &_vssetsup(V &v, const S &s) throw();
183  template <class V,class S> friend V &_vsusetinf(V &v, const S &s) throw();
184  template <class V,class S> friend V &_vsusetsup(V &v, const S &s) throw();
185  template <class V,class E> friend E _vabs(const V &rv) throw();
186  template <class VS,class E> friend E _vsabs(const VS &sl) throw();
187 template <class MV,class V> friend V _mvabs(const MV &mv) throw();
188  template <class V,class E> friend E _vdiam(const V &rv) throw();
189  template <class V,class E> friend E _vmid(const V &rv) throw();
190  template <class V,class E> friend E _vinf(const V &rv) throw();
191  template <class V,class E> friend E _vsup(const V &rv) throw();
192 
193 //-------- vector-vector -----------------------
194  template <class DP,class V1,class V2> friend void _vvaccu(DP &dp, const V1 & rv1, const V2 &rv2)
195 #if(CXSC_INDEX_CHECK)
196  throw(OP_WITH_WRONG_DIM);
197 #else
198  throw();
199 #endif
200  template <class DP,class VS,class V> friend void _vsvaccu(DP &dp, const VS & sl, const V &rv)
201 #if(CXSC_INDEX_CHECK)
202  throw(OP_WITH_WRONG_DIM);
203 #else
204  throw();
205 #endif
206 
207  template <class V1,class V2,class E> friend E _vvlimult(const V1 & rv1, const V2 &rv2)
208 #if(CXSC_INDEX_CHECK)
209  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
210 #else
211  throw();
212 #endif
213  template <class VS,class V,class E> friend E _vsvlimult(const VS & sl, const V &rv)
214 #if(CXSC_INDEX_CHECK)
215  throw(ERROR__OP_WITH_WRONG_DIM<V>);
216 #else
217  throw();
218 #endif
219 
220  template <class V,class S> friend V &_vsmultassign(V &rv,const S &r) throw();
221  template <class V1,class V2,class E> friend E _vvplus(const V1 &rv1, const V2 &rv2)
222 #if(CXSC_INDEX_CHECK)
223  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
224 #else
225  throw();
226 #endif
227  template <class V,class VS,class E> friend E _vvsplus(const V &rv,const VS &sl)
228 #if(CXSC_INDEX_CHECK)
229  throw(ERROR__OP_WITH_WRONG_DIM<V>);
230 #else
231  throw();
232 #endif
233  template <class VS1,class VS2,class E> friend E _vsvsplus(const VS1 &s1,const VS2 &s2)
234 #if(CXSC_INDEX_CHECK)
235  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
236 #else
237  throw();
238 #endif
239  template <class VS1,class VS2,class E> friend E _vsvsminus(const VS1 &s1,const VS2 &s2)
240 #if(CXSC_INDEX_CHECK)
241  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
242 #else
243  throw();
244 #endif
245  template <class V1,class V2> friend V1 &_vvplusassign(V1 &rv1, const V2 &rv2)
246 #if(CXSC_INDEX_CHECK)
247  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
248 #else
249  throw();
250 #endif
251  template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl)
252 #if(CXSC_INDEX_CHECK)
253  throw(ERROR__OP_WITH_WRONG_DIM<V>);
254 #else
255  throw();
256 #endif
257  template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv)
258 #if(CXSC_INDEX_CHECK)
259  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
260 #else
261  throw();
262 #endif
263  template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
264 #if(CXSC_INDEX_CHECK)
265  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
266 #else
267  throw();
268 #endif
269  template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
270 #if(CXSC_INDEX_CHECK)
271  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
272 #else
273  throw();
274 #endif
275  template <class V1,class V2> friend V1 &_vvminusassign(V1 &rv1, const V2 &rv2)
276 #if(CXSC_INDEX_CHECK)
277  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
278 #else
279  throw();
280 #endif
281  template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl)
282 #if(CXSC_INDEX_CHECK)
283  throw(ERROR__OP_WITH_WRONG_DIM<V>);
284 #else
285  throw();
286 #endif
287  template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv)
288 #if(CXSC_INDEX_CHECK)
289  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
290 #else
291  throw();
292 #endif
293  template <class V> friend V _vminus(const V &rv) throw();
294  template <class VS,class V> friend V _vsminus(const VS &sl) throw();
295  template <class V1,class V2,class E> friend E _vvminus(const V1 &rv1, const V2 &rv2)
296 #if(CXSC_INDEX_CHECK)
297  throw(ERROR__OP_WITH_WRONG_DIM<E>);
298 #else
299  throw();
300 #endif
301  template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl)
302 #if(CXSC_INDEX_CHECK)
303  throw(ERROR__OP_WITH_WRONG_DIM<E>);
304 #else
305  throw();
306 #endif
307  template <class VS,class V,class E> friend E _vsvminus(const VS &sl,const V &rv)
308 #if(CXSC_INDEX_CHECK)
309  throw(ERROR__OP_WITH_WRONG_DIM<E>);
310 #else
311  throw();
312 #endif
313  template <class V1,class V2,class E> friend E _vvconv(const V1 &rv1, const V2 &rv2)
314 #if(CXSC_INDEX_CHECK)
315  throw(ERROR__OP_WITH_WRONG_DIM<E>);
316 #else
317  throw();
318 #endif
319  template <class V,class VS,class E> friend E _vvsconv(const V &rv,const VS &sl)
320 #if(CXSC_INDEX_CHECK)
321  throw(ERROR__OP_WITH_WRONG_DIM<E>);
322 #else
323  throw();
324 #endif
325  template <class VS1,class VS2,class E> friend E _vsvsconv(const VS1 &s1,const VS2 &s2)
326 #if(CXSC_INDEX_CHECK)
327  throw(ERROR__OP_WITH_WRONG_DIM<E>);
328 #else
329  throw();
330 #endif
331  template <class V1,class V2> friend V1 &_vvconvassign(V1 &rv1, const V2 &rv2)
332 #if(CXSC_INDEX_CHECK)
333  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
334 #else
335  throw();
336 #endif
337  template <class V,class VS> friend V &_vvsconvassign(V &rv, const VS &sl)
338 #if(CXSC_INDEX_CHECK)
339  throw(ERROR__OP_WITH_WRONG_DIM<V>);
340 #else
341  throw();
342 #endif
343  template <class VS,class V> friend VS &_vsvconvassign(VS &sl, const V &rv)
344 #if(CXSC_INDEX_CHECK)
345  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
346 #else
347  throw();
348 #endif
349  template <class VS1,class VS2> friend VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2)
350 #if(CXSC_INDEX_CHECK)
351  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
352 #else
353  throw();
354 #endif
355  template <class V1,class V2,class E> friend E _vvsect(const V1 &rv1, const V2 &rv2)
356 #if(CXSC_INDEX_CHECK)
357  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
358 #else
359  throw();
360 #endif
361  template <class V,class VS,class E> friend E _vvssect(const V &rv,const VS &sl)
362 #if(CXSC_INDEX_CHECK)
363  throw(ERROR__OP_WITH_WRONG_DIM<E>);
364 #else
365  throw();
366 #endif
367  template <class VS1,class VS2,class E> friend E _vsvssect(const VS1 &s1,const VS2 &s2)
368 #if(CXSC_INDEX_CHECK)
369  throw(ERROR__OP_WITH_WRONG_DIM<E>);
370 #else
371  throw();
372 #endif
373  template <class V1,class V2> friend V1 &_vvsectassign(V1 &rv1, const V2 &rv2)
374 #if(CXSC_INDEX_CHECK)
375  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
376 #else
377  throw();
378 #endif
379  template <class V,class VS> friend V &_vvssectassign(V &rv, const VS &sl)
380 #if(CXSC_INDEX_CHECK)
381  throw(ERROR__OP_WITH_WRONG_DIM<V>);
382 #else
383  throw();
384 #endif
385  template <class VS,class V> friend VS &_vsvsectassign(VS &sl, const V &rv)
386 #if(CXSC_INDEX_CHECK)
387  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
388 #else
389  throw();
390 #endif
391  template <class VS1,class VS2> friend VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2)
392 #if(CXSC_INDEX_CHECK)
393  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
394 #else
395  throw();
396 #endif
397  template <class MV1,class MV2,class E> friend E _mvmvsect(const MV1 &rv1, const MV2 &rv2)
398 #if(CXSC_INDEX_CHECK)
399  throw(ERROR__OP_WITH_WRONG_DIM<E>);
400 #else
401  throw();
402 #endif
403  template <class MV,class V,class E> friend E _mvvsect(const MV &rv1, const V &rv2)
404 #if(CXSC_INDEX_CHECK)
405  throw(ERROR__OP_WITH_WRONG_DIM<E>);
406 #else
407  throw();
408 #endif
409 template <class MV,class V> friend MV &_mvvsectassign(MV &v,const V &rv)
410 #if(CXSC_INDEX_CHECK)
411  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
412 #else
413  throw();
414 #endif
415 template <class V,class MV> friend V &_vmvsectassign(V &rv,const MV &v)
416 #if(CXSC_INDEX_CHECK)
417  throw(ERROR__OP_WITH_WRONG_DIM<V>);
418 #else
419  throw();
420 #endif
421  template <class MV1,class MV2,class E> friend E _mvmvconv(const MV1 &rv1, const MV2 &rv2)
422 #if(CXSC_INDEX_CHECK)
423  throw(ERROR__OP_WITH_WRONG_DIM<E>);
424 #else
425  throw();
426 #endif
427  template <class MV,class V,class E> friend E _mvvconv(const MV &rv1, const V &rv2)
428 #if(CXSC_INDEX_CHECK)
429  throw(ERROR__OP_WITH_WRONG_DIM<E>);
430 #else
431  throw();
432 #endif
433 template <class MV,class V> friend MV &_mvvconvassign(MV &v,const V &rv)
434 #if(CXSC_INDEX_CHECK)
435  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
436 #else
437  throw();
438 #endif
439 template <class V,class MV> friend V &_vmvconvassign(V &rv,const MV &v)
440 #if(CXSC_INDEX_CHECK)
441  throw(ERROR__OP_WITH_WRONG_DIM<V>);
442 #else
443  throw();
444 #endif
445  template <class V,class MV,class S> friend S _vmvlimult(const V &rv1, const MV &rv2)
446 #if(CXSC_INDEX_CHECK)
447  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
448 #else
449  throw();
450 #endif
451  //--------- vector-scalar -----------------
452  template <class V,class S,class E> friend E _vsdiv(const V &rv, const S &s) throw();
453  template <class V,class S> friend V &_vsdivassign(V &rv,const S &r) throw();
454  template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) throw();
455  template <class V,class S,class E> friend E _vsmult(const V &rv, const S &s) throw();
456  template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) throw();
457  template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) throw();
458  template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
459 #if(CXSC_INDEX_CHECK)
460  throw(ERROR__OP_WITH_WRONG_DIM<E>);
461 #else
462  throw();
463 #endif
464  template <class MV,class V,class E> friend E _mvvplus(const MV &rv1, const V &rv2)
465 #if(CXSC_INDEX_CHECK)
466  throw(ERROR__OP_WITH_WRONG_DIM<E>);
467 #else
468  throw();
469 #endif
470  template <class MV,class V,class E> friend E _mvvminus(const MV &rv1, const V &rv2)
471 #if(CXSC_INDEX_CHECK)
472  throw(ERROR__OP_WITH_WRONG_DIM<E>);
473 #else
474  throw();
475 #endif
476  template <class V,class MV,class E> friend E _vmvminus(const V &rv1, const MV &rv2)
477 #if(CXSC_INDEX_CHECK)
478  throw(ERROR__OP_WITH_WRONG_DIM<E>);
479 #else
480  throw();
481 #endif
482  template <class MV1,class MV2,class E> friend E _mvmvminus(const MV1 &rv1, const MV2 &rv2)
483 #if(CXSC_INDEX_CHECK)
484  throw(ERROR__OP_WITH_WRONG_DIM<E>);
485 #else
486  throw();
487 #endif
488 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
489 #if(CXSC_INDEX_CHECK)
490  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
491 #else
492  throw();
493 #endif
494 template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv)
495 #if(CXSC_INDEX_CHECK)
496  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
497 #else
498  throw();
499 #endif
500  template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) throw();
501 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
502 #if(CXSC_INDEX_CHECK)
503  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
504 #else
505  throw();
506 #endif
507 
508  template <class V1,class V2> friend bool _vveq(const V1 &rv1, const V2 &rv2) throw();
509  template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) throw();
510  template <class V1,class V2> friend bool _vvneq(const V1 &rv1, const V2 &rv2) throw();
511  template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) throw();
512  template <class V1,class V2> friend bool _vvless(const V1 &rv1, const V2 &rv2) throw();
513  template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) throw();
514  template <class V1,class V2> friend bool _vvleq(const V1 &rv1, const V2 &rv2) throw();
515  template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) throw();
516  template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) throw();
517  template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) throw();
518  template <class V> friend bool _vnot(const V &rv) throw();
519  template <class V> friend void *_vvoid(const V &rv) throw();
520  template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw();
521  template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw();
522  template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw();
523  template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw();
524  template <class VS> friend bool _vsnot(const VS &sl) throw();
525  template <class VS> friend void *_vsvoid(const VS &sl) throw();
526  template <class V> friend std::ostream &_vout(std::ostream &s, const V &rv) throw();
527  template <class V> friend std::istream &_vin(std::istream &s, V &rv) throw();
528 
529  //------------- vector-matrix ---------------
530 template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
531 #if(CXSC_INDEX_CHECK)
532  throw(OP_WITH_WRONG_DIM);
533 #else
534  throw();
535 #endif
536 
537 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) throw();
538  template <class M,class V,class E> friend E _mvlimult(const M &m,const V &v)
539 #if(CXSC_INDEX_CHECK)
540  throw(ERROR__OP_WITH_WRONG_DIM<M>);
541 #else
542  throw();
543 #endif
544  template <class V,class M,class E> friend E _vmlimult(const V &v,const M &m)
545 #if(CXSC_INDEX_CHECK)
546  throw(ERROR__OP_WITH_WRONG_DIM<M>);
547 #else
548  throw();
549 #endif
550  template <class V,class M,class S> friend V &_vmimultassign(V &v,const M &m)
551 #if(CXSC_INDEX_CHECK)
552  throw(ERROR__OP_WITH_WRONG_DIM<M>);
553 #else
554  throw();
555 #endif
556  template <class V,class M,class S> friend V &_vmlimultassign(V &v,const M &m)
557 #if(CXSC_INDEX_CHECK)
558  throw(ERROR__OP_WITH_WRONG_DIM<M>);
559 #else
560  throw();
561 #endif
562  template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v)
563 #if(CXSC_INDEX_CHECK)
564  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
565 #else
566  throw();
567 #endif
568  template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms)
569 #if(CXSC_INDEX_CHECK)
570  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
571 #else
572  throw();
573 #endif
574  template <class V,class MS,class S> friend V &_vmslimultassign(V &v,const MS &ms)
575 #if(CXSC_INDEX_CHECK)
576  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
577 #else
578  throw();
579 #endif
580 
581  // Real
582  template <class DP,class VS1,class VS2> friend void _vsvsaccu(DP &dp, const VS1 & sl1, const VS2 &sl2)
583 #if(CXSC_INDEX_CHECK)
584  throw(OP_WITH_WRONG_DIM);
585 #else
586  throw();
587 #endif
588 
589  // l_rvector x ivector ----------------
590  // vector - matrix ------------
591  /* friend TINLINE l_ivector _mvslimult<imatrix,l_rvector_slice,l_ivector>(const imatrix &m,const l_rvector_slice &v)
592 #if(CXSC_INDEX_CHECK)
593  throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
594 #else
595  throw();
596  #endif */
597  /* friend TINLINE l_ivector _vsmlimult<l_rvector_slice,imatrix,l_ivector>(const l_rvector_slice &v,const imatrix &m)
598 #if(CXSC_INDEX_CHECK)
599  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
600 #else
601  throw();
602  #endif */
603 
604 
605 #endif
606 
607 
608  //------ Konstruktoren ----------------------------------------------------
610  INLINE l_ivector () throw();
612  explicit INLINE l_ivector(const int &i) throw();
613 #ifdef OLD_CXSC
614  explicit INLINE l_ivector(const class index &i) throw(); // for backwards compatibility
616 #endif
617  explicit INLINE l_ivector(const int &i1,const int &i2)
619 #if(CXSC_INDEX_CHECK)
620  throw(ERROR_LIVECTOR_WRONG_BOUNDARIES,ERROR_LIVECTOR_NO_MORE_MEMORY);
621 #else
622  throw();
623 #endif
624  INLINE l_ivector(const l_imatrix_subv &) throw();
627  explicit INLINE l_ivector(const l_interval &) throw();
629  explicit INLINE l_ivector(const l_imatrix &)
630 #if(CXSC_INDEX_CHECK)
631  throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
632 #else
633  throw();
634 #endif
635  explicit INLINE l_ivector(const l_imatrix_slice &sl)
637 #if(CXSC_INDEX_CHECK)
638  throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
639 #else
640  throw();
641 #endif
642  INLINE l_ivector(const l_ivector_slice &rs) throw();
645  INLINE l_ivector(const l_ivector &v) throw();
646  // Real
648  explicit INLINE l_ivector(const real &) throw();
650  explicit INLINE l_ivector(const rvector_slice &rs) throw();
652  explicit INLINE l_ivector(const rvector &v) throw();
654  explicit INLINE l_ivector(const rmatrix &)
655 #if(CXSC_INDEX_CHECK)
656  throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
657 #else
658  throw();
659 #endif
660  explicit INLINE l_ivector(const rmatrix_slice &sl)
662 #if(CXSC_INDEX_CHECK)
663  throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
664 #else
665  throw();
666 #endif
667  explicit INLINE l_ivector(const rmatrix_subv &) throw();
669 
670  // l_real
672  explicit INLINE l_ivector(const l_real &) throw();
674  explicit INLINE l_ivector(const l_rvector_slice &rs) throw();
676  explicit INLINE l_ivector(const l_rvector &v) throw();
678  explicit INLINE l_ivector(const l_rmatrix &)
679 #if(CXSC_INDEX_CHECK)
680  throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ);
681 #else
682  throw();
683 #endif
684  explicit INLINE l_ivector(const l_rmatrix_slice &sl)
686 #if(CXSC_INDEX_CHECK)
687  throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ);
688 #else
689  throw();
690 #endif
691  explicit INLINE l_ivector(const l_rmatrix_subv &) throw();
693 
694  // interval
696  explicit INLINE l_ivector(const interval &) throw();
698  explicit INLINE l_ivector(const ivector_slice &rs) throw();
700  explicit INLINE l_ivector(const ivector &v) throw();
702  explicit INLINE l_ivector(const imatrix &)
703 #if(CXSC_INDEX_CHECK)
704  throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
705 #else
706  throw();
707 #endif
708  explicit INLINE l_ivector(const imatrix_slice &sl)
710 #if(CXSC_INDEX_CHECK)
711  throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
712 #else
713  throw();
714 #endif
715  explicit INLINE l_ivector(const imatrix_subv &) throw();
717 
718  // l_interval
720  INLINE l_ivector &operator =(const l_ivector &rv) throw();
722  INLINE l_ivector &operator =(const l_ivector_slice &sl) throw();
724  INLINE l_ivector &operator =(const l_interval &r) throw();
726  INLINE l_ivector &operator =(const l_imatrix &m)
727 #if(CXSC_INDEX_CHECK)
728  throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
729 #else
730  throw();
731 #endif
732  INLINE l_ivector &operator =(const l_imatrix_slice &)
734 #if(CXSC_INDEX_CHECK)
735  throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
736 #else
737  throw();
738 #endif
739  INLINE l_ivector &operator =(const l_imatrix_subv &) throw();
741  // Real
743  INLINE l_ivector &operator =(const rvector &rv) throw();
745  INLINE l_ivector &operator =(const rvector_slice &sl) throw();
747  INLINE l_ivector &operator =(const real &r) throw();
749  INLINE l_ivector &operator =(const rmatrix &m)
750 #if(CXSC_INDEX_CHECK)
751  throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
752 #else
753  throw();
754 #endif
755  INLINE l_ivector &operator =(const rmatrix_slice &)
757 #if(CXSC_INDEX_CHECK)
758  throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
759 #else
760  throw();
761 #endif
762  INLINE l_ivector &operator =(const rmatrix_subv &) throw();
764 
765  // l_real
767  INLINE l_ivector &operator =(const l_rvector &rv) throw();
769  INLINE l_ivector &operator =(const l_rvector_slice &sl) throw();
771  INLINE l_ivector &operator =(const l_real &r) throw();
773  INLINE l_ivector &operator =(const l_rmatrix &m)
774 #if(CXSC_INDEX_CHECK)
775  throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ);
776 #else
777  throw();
778 #endif
779  INLINE l_ivector &operator =(const l_rmatrix_slice &)
781 #if(CXSC_INDEX_CHECK)
782  throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ);
783 #else
784  throw();
785 #endif
786  INLINE l_ivector &operator =(const l_rmatrix_subv &) throw();
788 
789  // interval
791  INLINE l_ivector &operator =(const ivector &rv) throw();
793  INLINE l_ivector &operator =(const ivector_slice &sl) throw();
795  INLINE l_ivector &operator =(const interval &r) throw();
797  INLINE l_ivector &operator =(const imatrix &m)
798 #if(CXSC_INDEX_CHECK)
799  throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
800 #else
801  throw();
802 #endif
803  INLINE l_ivector &operator =(const imatrix_slice &)
805 #if(CXSC_INDEX_CHECK)
806  throw(ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
807 #else
808  throw();
809 #endif
810  INLINE l_ivector &operator =(const imatrix_subv &) throw();
812 
813  //--------- Destruktor ----------------------------------------------------
814  INLINE ~l_ivector() { delete [] dat; }
815 
816  //------ Standardfunktionen -----------------------------------------------
817 
818  friend INLINE l_interval::l_interval(const l_ivector &)
819 #if(CXSC_INDEX_CHECK)
820  throw(ERROR_LIVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_LIVECTOR_USE_OF_UNINITIALIZED_OBJ);
821 #else
822  throw();
823 #endif
824  friend INLINE int Lb(const l_ivector &rv) throw() { return rv.l; }
827  friend INLINE int Ub(const l_ivector &rv) throw() { return rv.u; }
829  friend INLINE int VecLen(const l_ivector &rv) throw() { return rv.size; }
831  friend INLINE l_ivector & SetLb(l_ivector &rv, const int &l) throw() { rv.l=l; rv.u=l+rv.size-1; return rv;}
833  friend INLINE l_ivector & SetUb(l_ivector &rv, const int &u) throw() { rv.u=u; rv.l=u-rv.size+1; return rv;}
835  INLINE l_interval & operator [](const int &i) const
836 #if(CXSC_INDEX_CHECK)
837  throw(ERROR_LIVECTOR_ELEMENT_NOT_IN_VEC);
838 #else
839  throw();
840 #endif
841  INLINE l_ivector & operator ()() throw() { return *this; }
844  INLINE l_ivector_slice operator ()(const int &i)
845 #if(CXSC_INDEX_CHECK)
846  throw(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG);
847 #else
848  throw();
849 #endif
850  INLINE l_ivector_slice operator ()(const int &i1,const int &i2)
852 #if(CXSC_INDEX_CHECK)
853  throw(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG);
854 #else
855  throw();
856 #endif
857 
858  INLINE operator void*() throw();
859 //#else
860 //#endif
861 };
862 
863 
865 
871 {
872  friend class l_ivector;
873  friend class l_imatrix;
874  private:
875  l_interval *dat;
876  int l,u,size;
877  int start,end;
878 
879  public:
880 //#if(CXSC_INDEX_CHECK)
881 #ifdef _CXSC_FRIEND_TPL
882 //------------------------- Templates -------------------------------------------
883 // l_interval / l_interval
884 
885  template <class VS1,class VS2> friend VS1 & _vsvsassign(VS1 &sl1,const VS2 &sl2)
886 #if(CXSC_INDEX_CHECK)
887  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
888 #else
889  throw();
890 #endif
891  template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) throw();
892  template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv)
893 #if(CXSC_INDEX_CHECK)
894  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
895 #else
896  throw();
897 #endif
898  template <class VS,class S> friend VS & _vssassign(VS &sl,const S &r) throw();
899  template <class VS,class V> friend VS &_vsvsetinf(VS &sl, const V &rv)
900 #if(CXSC_INDEX_CHECK)
901  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
902 #else
903  throw();
904 #endif
905  template <class VS,class V> friend VS &_vsvsetsup(VS &sl, const V &rv)
906 #if(CXSC_INDEX_CHECK)
907  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
908 #else
909  throw();
910 #endif
911  template <class VS1,class VS2> friend VS1 &_vsvssetinf(VS1 &sl1, const VS2 &sl2)
912 #if(CXSC_INDEX_CHECK)
913  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
914 #else
915  throw();
916 #endif
917  template <class VS1,class VS2> friend VS1 &_vsvssetsup(VS1 &sl1, const VS2 &sl2)
918 #if(CXSC_INDEX_CHECK)
919  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
920 #else
921  throw();
922 #endif
923  template <class VS,class V> friend VS &_vsvusetinf(VS &sl, const V &rv)
924 #if(CXSC_INDEX_CHECK)
925  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
926 #else
927  throw();
928 #endif
929  template <class VS,class V> friend VS &_vsvusetsup(VS &sl, const V &rv)
930 #if(CXSC_INDEX_CHECK)
931  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
932 #else
933  throw();
934 #endif
935  template <class VS1,class VS2> friend VS1 &_vsvsusetinf(VS1 &sl1, const VS2 &sl2)
936 #if(CXSC_INDEX_CHECK)
937  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
938 #else
939  throw();
940 #endif
941  template <class VS1,class VS2> friend VS1 &_vsvsusetsup(VS1 &sl1, const VS2 &sl2)
942 #if(CXSC_INDEX_CHECK)
943  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
944 #else
945  throw();
946 #endif
947 
948  template <class VS,class E> friend E _vsabs(const VS &sl) throw();
949  template <class VS,class E> friend E _vsdiam(const VS &sl) throw();
950  template <class VS,class E> friend E _vsmid(const VS &sl) throw();
951  template <class VS,class E> friend E _vsinf(const VS &sl) throw();
952  template <class VS,class E> friend E _vssup(const VS &sl) throw();
953  template <class VS,class S> friend VS &_vsssetinf(VS &vs, const S &s) throw();
954  template <class VS,class S> friend VS &_vsssetsup(VS &vs, const S &s) throw();
955  template <class VS,class S> friend VS &_vssusetinf(VS &vs, const S &s) throw();
956  template <class VS,class S> friend VS &_vssusetsup(VS &vs, const S &s) throw();
957 
958  template <class DP,class VS,class V> friend void _vsvaccu(DP &dp, const VS & sl, const V &rv)
959 #if(CXSC_INDEX_CHECK)
960  throw(OP_WITH_WRONG_DIM);
961 #else
962  throw();
963 #endif
964  template <class DP,class VS1,class VS2> friend void _vsvsaccu(DP &dp, const VS1 & sl1, const VS2 &sl2)
965 #if(CXSC_INDEX_CHECK)
966  throw(OP_WITH_WRONG_DIM);
967 #else
968  throw();
969 #endif
970 
971  template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) throw();
972  template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) throw();
973  template <class VS,class V,class E> friend E _vsvlimult(const VS & sl, const V &rv)
974 #if(CXSC_INDEX_CHECK)
975  throw(ERROR__OP_WITH_WRONG_DIM<V>);
976 #else
977  throw();
978 #endif
979  template <class VS,class S> friend VS &_vssmultassign(VS &rv,const S &r) throw();
980  template <class VS,class S> friend VS &_vssdivassign(VS &rv,const S &r) throw();
981  template <class V,class VS,class E> friend E _vvsplus(const V &rv,const VS &sl)
982 #if(CXSC_INDEX_CHECK)
983  throw(ERROR__OP_WITH_WRONG_DIM<V>);
984 #else
985  throw();
986 #endif
987  template <class VS1,class VS2,class E> friend E _vsvsplus(const VS1 &s1,const VS2 &s2)
988 #if(CXSC_INDEX_CHECK)
989  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
990 #else
991  throw();
992 #endif
993  template <class VS1,class VS2,class E> friend E _vsvsminus(const VS1 &s1,const VS2 &s2)
994 #if(CXSC_INDEX_CHECK)
995  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
996 #else
997  throw();
998 #endif
999  template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl)
1000 #if(CXSC_INDEX_CHECK)
1001  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1002 #else
1003  throw();
1004 #endif
1005  template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv)
1006 #if(CXSC_INDEX_CHECK)
1007  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
1008 #else
1009  throw();
1010 #endif
1011  template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
1012 #if(CXSC_INDEX_CHECK)
1013  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1014 #else
1015  throw();
1016 #endif
1017  template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
1018 #if(CXSC_INDEX_CHECK)
1019  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1020 #else
1021  throw();
1022 #endif
1023  template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl)
1024 #if(CXSC_INDEX_CHECK)
1025  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1026 #else
1027  throw();
1028 #endif
1029  template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv)
1030 #if(CXSC_INDEX_CHECK)
1031  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
1032 #else
1033  throw();
1034 #endif
1035  template <class VS,class V> friend V _vsminus(const VS &sl) throw();
1036  template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl)
1037 #if(CXSC_INDEX_CHECK)
1038  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1039 #else
1040  throw();
1041 #endif
1042  template <class VS,class V,class E> friend E _vsvminus(const VS &sl,const V &rv)
1043 #if(CXSC_INDEX_CHECK)
1044  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1045 #else
1046  throw();
1047 #endif
1048  template <class V,class VS,class E> friend E _vvssect(const V &rv,const VS &sl)
1049 #if(CXSC_INDEX_CHECK)
1050  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1051 #else
1052  throw();
1053 #endif
1054  template <class VS1,class VS2,class E> friend E _vsvssect(const VS1 &s1,const VS2 &s2)
1055 #if(CXSC_INDEX_CHECK)
1056  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1057 #else
1058  throw();
1059 #endif
1060  template <class V,class VS> friend V &_vvssectassign(V &rv, const VS &sl)
1061 #if(CXSC_INDEX_CHECK)
1062  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1063 #else
1064  throw();
1065 #endif
1066  template <class VS,class V> friend VS &_vsvsectassign(VS &sl, const V &rv)
1067 #if(CXSC_INDEX_CHECK)
1068  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
1069 #else
1070  throw();
1071 #endif
1072  template <class VS1,class VS2> friend VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2)
1073 #if(CXSC_INDEX_CHECK)
1074  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1075 #else
1076  throw();
1077 #endif
1078  template <class V,class VS,class E> friend E _vvsconv(const V &rv,const VS &sl)
1079 #if(CXSC_INDEX_CHECK)
1080  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1081 #else
1082  throw();
1083 #endif
1084  template <class VS1,class VS2,class E> friend E _vsvsconv(const VS1 &s1,const VS2 &s2)
1085 #if(CXSC_INDEX_CHECK)
1086  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1087 #else
1088  throw();
1089 #endif
1090  template <class V,class VS> friend V &_vvsconvassign(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 &_vsvconvassign(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 &_vsvsconvassign(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 VS,class M,class S> friend VS &_vsmlimultassign(VS &v,const M &m)
1109 #if(CXSC_INDEX_CHECK)
1110  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1111 #else
1112  throw();
1113 #endif
1114 
1115  template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) throw();
1116  template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) throw();
1117  template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) throw();
1118  template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) throw();
1119  template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) throw();
1120  template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) throw();
1121  template <class VS1,class VS2,class E> friend E _vsvslimult(const VS1 & sl1, const VS2 &sl2)
1122 #if(CXSC_INDEX_CHECK)
1123  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1124 #else
1125  throw();
1126 #endif
1127  template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw();
1128  template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw();
1129  template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw();
1130  template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw();
1131  template <class VS> friend bool _vsnot(const VS &sl) throw();
1132  template <class VS> friend void *_vsvoid(const VS &sl) throw();
1133  template <class V> friend std::ostream &_vsout(std::ostream &s, const V &rv) throw();
1134  template <class V> friend std::istream &_vsin(std::istream &s, V &rv) throw();
1135 
1136  // l_interval / Real
1137  template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms)
1138 #if(CXSC_INDEX_CHECK)
1139  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1140 #else
1141  throw();
1142 #endif
1143  // l_interval / l_real
1144  template <class DP,class V1,class V2> friend void _vvaccu(DP &dp, const V1 & rv1, const V2 &rv2)
1145 #if(CXSC_INDEX_CHECK)
1146  throw(OP_WITH_WRONG_DIM);
1147 #else
1148  throw();
1149 #endif
1150 
1151  // l_real
1152  template <class V1,class V2,class S> friend V1 &_vvassign(V1 &rv1,const V2 &rv2) throw();
1153  template <class V,class S> friend V & _vsassign(V &rv,const S &r) throw();
1154 
1155 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m)
1156 #if(CXSC_INDEX_CHECK)
1157  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
1158 #else
1159  throw();
1160 #endif
1161 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) throw();
1162 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) throw();
1163 
1164  template <class V1,class V2,class E> friend E _vvconv(const V1 &rv1, const V2 &rv2)
1165 #if(CXSC_INDEX_CHECK)
1166  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1167 #else
1168  throw();
1169 #endif
1170 
1171  //--l_real -------- vector-scalar ------------
1172  template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) throw();
1173  template <class V,class S,class E> friend E _vsmult(const V &rv, const S &s) throw();
1174  template <class V,class S,class E> friend E _vsdiv(const V &rv, const S &s) throw();
1175  template <class V,class S> friend V &_vsdivassign(V &rv,const S &r) throw();
1176  template <class V,class S> friend V &_vsmultassign(V &rv,const S &r) throw();
1177 
1178  //--l_real--------- Vector-vector---------
1179  template <class V1,class V2,class E> friend E _vvlimult(const V1 & rv1, const V2 &rv2)
1180 #if(CXSC_INDEX_CHECK)
1181  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
1182 #else
1183  throw();
1184 #endif
1185  template <class V1,class V2,class E> friend E _vvplus(const V1 &rv1, const V2 &rv2)
1186 #if(CXSC_INDEX_CHECK)
1187  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
1188 #else
1189  throw();
1190 #endif
1191  template <class V1,class V2> friend V1 &_vvplusassign(V1 &rv1, const V2 &rv2)
1192 #if(CXSC_INDEX_CHECK)
1193  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
1194 #else
1195  throw();
1196 #endif
1197  template <class V1,class V2> friend V1 &_vvminusassign(V1 &rv1, const V2 &rv2)
1198 #if(CXSC_INDEX_CHECK)
1199  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
1200 #else
1201  throw();
1202 #endif
1203  template <class V1,class V2,class E> friend E _vvminus(const V1 &rv1, const V2 &rv2)
1204 #if(CXSC_INDEX_CHECK)
1205  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1206 #else
1207  throw();
1208 #endif
1209  template <class V1,class V2> friend V1 &_vvconvassign(V1 &rv1, const V2 &rv2)
1210 #if(CXSC_INDEX_CHECK)
1211  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
1212 #else
1213  throw();
1214 #endif
1215  template <class V1,class V2,class E> friend E _vvsect(const V1 &rv1, const V2 &rv2)
1216 #if(CXSC_INDEX_CHECK)
1217  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
1218 #else
1219  throw();
1220 #endif
1221  template <class V1,class V2> friend V1 &_vvsectassign(V1 &rv1, const V2 &rv2)
1222 #if(CXSC_INDEX_CHECK)
1223  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
1224 #else
1225  throw();
1226 #endif
1227 
1228  //-- l_real -------- Vector-matrix ----------
1229 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m)
1230 #if(CXSC_INDEX_CHECK)
1231  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>);
1232 #else
1233  throw();
1234 #endif
1235 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
1236 #if(CXSC_INDEX_CHECK)
1237  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
1238 #else
1239  throw();
1240 #endif
1241  template <class M,class V,class E> friend E _mvlimult(const M &m,const V &v)
1242 #if(CXSC_INDEX_CHECK)
1243  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1244 #else
1245  throw();
1246 #endif
1247  template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v)
1248 #if(CXSC_INDEX_CHECK)
1249  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1250 #else
1251  throw();
1252 #endif
1253  template <class V,class M,class E> friend E _vmlimult(const V &v,const M &m)
1254 #if(CXSC_INDEX_CHECK)
1255  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1256 #else
1257  throw();
1258 #endif
1259  template <class V,class MS,class S> friend V &_vmslimultassign(V &v,const MS &ms)
1260 #if(CXSC_INDEX_CHECK)
1261  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1262 #else
1263  throw();
1264 #endif
1265  template <class V,class M,class S> friend V &_vmlimultassign(V &v,const M &m)
1266 #if(CXSC_INDEX_CHECK)
1267  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1268 #else
1269  throw();
1270 #endif
1271 
1272  /* friend TINLINE l_ivector &_vsmassign<l_ivector_slice,imatrix,l_interval>(l_ivector_slice &v,const imatrix &m)
1273 #if(CXSC_INDEX_CHECK)
1274  throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
1275 #else
1276  throw();
1277  #endif */
1278 
1279  //-- interval -------- Vector-matrix ----------
1280  /* friend TINLINE l_ivector _mvslimult<imatrix,l_ivector_slice,l_ivector>(const imatrix &m,const l_ivector_slice &v)
1281 #if(CXSC_INDEX_CHECK)
1282  throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
1283 #else
1284  throw();
1285  #endif */
1286  /* friend TINLINE l_ivector _msvslimult<imatrix_slice,l_ivector_slice,l_ivector>(const imatrix_slice &ms,const l_ivector_slice &v)
1287 #if(CXSC_INDEX_CHECK)
1288  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1289 #else
1290  throw();
1291  #endif */
1292  /* friend TINLINE l_ivector _vsmlimult<l_ivector_slice,imatrix,l_ivector>(const l_ivector_slice &v,const imatrix &m)
1293 #if(CXSC_INDEX_CHECK)
1294  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1295 #else
1296  throw();
1297  #endif */
1298  /* friend TINLINE l_ivector _vsmslimult<l_ivector_slice,imatrix_slice,l_ivector>(const l_ivector_slice &v,const imatrix_slice &ms)
1299 #if(CXSC_INDEX_CHECK)
1300  throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
1301 #else
1302  throw();
1303  #endif */
1304  /* friend TINLINE l_ivector &_vsmslimultassign<l_ivector_slice,imatrix_slice,l_interval>(l_ivector_slice &v,const imatrix_slice &m)
1305 #if(CXSC_INDEX_CHECK)
1306  throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
1307 #else
1308  throw();
1309  #endif */
1310 
1311 #endif
1312 
1313  //--------------------- Konstruktoren -----------------------------------
1315  explicit INLINE l_ivector_slice(l_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) { }
1317  explicit INLINE l_ivector_slice(l_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) { }
1318  public:
1320  INLINE l_ivector_slice(const l_ivector_slice &a) throw():dat(a.dat),l(a.l),u(a.u),size(a.size),start(a.start),end(a.end) { }
1321  public:
1322  // l_interval
1324  INLINE l_ivector_slice & operator =(const l_ivector_slice &sl)
1325 #if(CXSC_INDEX_CHECK)
1326  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1327 #else
1328  throw();
1329 #endif
1330  INLINE l_ivector_slice & operator =(const l_ivector &rv)
1332 #if(CXSC_INDEX_CHECK)
1333  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1334 #else
1335  throw();
1336 #endif
1337  INLINE l_ivector_slice & operator =(const l_interval &r) throw();
1340  INLINE l_ivector_slice & operator =(const l_imatrix &m)
1341 #if(CXSC_INDEX_CHECK)
1342  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>,ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
1343 #else
1344  throw();
1345 #endif
1346  INLINE l_ivector_slice & operator =(const l_imatrix_slice &m)
1348 #if(CXSC_INDEX_CHECK)
1349  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>,ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
1350 #else
1351  throw();
1352 #endif
1353  INLINE l_ivector_slice &operator =(const l_imatrix_subv &) throw();
1355  // Real
1357  INLINE l_ivector_slice & operator =(const rvector_slice &sl)
1358 #if(CXSC_INDEX_CHECK)
1359  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1360 #else
1361  throw();
1362 #endif
1363  INLINE l_ivector_slice & operator =(const rvector &rv)
1365 #if(CXSC_INDEX_CHECK)
1366  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1367 #else
1368  throw();
1369 #endif
1370  INLINE l_ivector_slice & operator =(const real &r) throw();
1373  INLINE l_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 l_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 l_ivector_slice &operator =(const rmatrix_subv &mv) throw();
1388 
1389  // l_real
1391  INLINE l_ivector_slice & operator =(const l_rvector_slice &sl)
1392 #if(CXSC_INDEX_CHECK)
1393  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1394 #else
1395  throw();
1396 #endif
1397  INLINE l_ivector_slice & operator =(const l_rvector &rv)
1399 #if(CXSC_INDEX_CHECK)
1400  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1401 #else
1402  throw();
1403 #endif
1404  INLINE l_ivector_slice & operator =(const l_real &r) throw();
1407  INLINE l_ivector_slice & operator =(const l_rmatrix &m)
1408 #if(CXSC_INDEX_CHECK)
1409  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>,ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ);
1410 #else
1411  throw();
1412 #endif
1413  INLINE l_ivector_slice & operator =(const l_rmatrix_slice &m)
1415 #if(CXSC_INDEX_CHECK)
1416  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>,ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ);
1417 #else
1418  throw();
1419 #endif
1420  INLINE l_ivector_slice &operator =(const l_rmatrix_subv &mv) throw();
1422 
1423  // interval
1425  INLINE l_ivector_slice & operator =(const ivector_slice &sl)
1426 #if(CXSC_INDEX_CHECK)
1427  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1428 #else
1429  throw();
1430 #endif
1431  INLINE l_ivector_slice & operator =(const ivector &rv)
1433 #if(CXSC_INDEX_CHECK)
1434  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1435 #else
1436  throw();
1437 #endif
1438  INLINE l_ivector_slice & operator =(const interval &r) throw();
1441  INLINE l_ivector_slice & operator =(const imatrix &m)
1442 #if(CXSC_INDEX_CHECK)
1443  throw(ERROR__OP_WITH_WRONG_DIM<ivector>,ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
1444 #else
1445  throw();
1446 #endif
1447  INLINE l_ivector_slice & operator =(const imatrix_slice &m)
1449 #if(CXSC_INDEX_CHECK)
1450  throw(ERROR__OP_WITH_WRONG_DIM<ivector>,ERROR_IMATRIX_TYPE_CAST_OF_THICK_OBJ);
1451 #else
1452  throw();
1453 #endif
1454  INLINE l_ivector_slice &operator =(const imatrix_subv &mv) throw();
1456 
1457  //--------------------- Standardfunktionen ------------------------------
1458 
1459  friend INLINE l_interval::l_interval(const l_ivector_slice &sl)
1460 #if(CXSC_INDEX_CHECK)
1461  throw(ERROR_LIVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_LIVECTOR_USE_OF_UNINITIALIZED_OBJ);
1462 #else
1463  throw();
1464 #endif
1465  friend INLINE int Lb(const l_ivector_slice &sl) throw() { return sl.start; }
1468  friend INLINE int Ub(const l_ivector_slice &sl) throw() { return sl.end; }
1470  friend INLINE int VecLen(const l_ivector_slice &sl) throw() { return sl.end-sl.start+1; }
1472  INLINE l_interval & operator [](const int &i) const
1473 #if(CXSC_INDEX_CHECK)
1474  throw(ERROR_LIVECTOR_ELEMENT_NOT_IN_VEC);
1475 #else
1476  throw();
1477 #endif
1478  INLINE l_ivector_slice & operator ()() throw() { return *this; }
1481  INLINE l_ivector_slice operator ()(const int &i)
1482 #if(CXSC_INDEX_CHECK)
1483  throw(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG);
1484 #else
1485  throw();
1486 #endif
1487  INLINE l_ivector_slice operator ()(const int &i1,const int &i2)
1489 #if(CXSC_INDEX_CHECK)
1490  throw(ERROR_LIVECTOR_SUB_ARRAY_TOO_BIG);
1491 #else
1492  throw();
1493 #endif
1494  INLINE operator void*() throw();
1495 
1497  INLINE l_ivector_slice &operator *=(const l_interval &r) throw();
1499  INLINE l_ivector_slice &operator /=(const l_interval &r) throw();
1501  INLINE l_ivector_slice &operator *=(const l_imatrix &m)
1502 #if(CXSC_INDEX_CHECK)
1503  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1504 #else
1505  throw();
1506 #endif
1507  INLINE l_ivector_slice &operator *=(const l_imatrix_slice &m)
1509 #if(CXSC_INDEX_CHECK)
1510  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1511 #else
1512  throw();
1513 #endif
1514  INLINE l_ivector_slice &operator +=(const l_ivector &rv)
1516 #if(CXSC_INDEX_CHECK)
1517  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1518 #else
1519  throw();
1520 #endif
1521  INLINE l_ivector_slice &operator +=(const l_ivector_slice &sl2)
1523 #if(CXSC_INDEX_CHECK)
1524  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1525 #else
1526  throw();
1527 #endif
1528  INLINE l_ivector_slice &operator -=(const l_ivector &rv)
1530 #if(CXSC_INDEX_CHECK)
1531  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1532 #else
1533  throw();
1534 #endif
1535  INLINE l_ivector_slice &operator -=(const l_ivector_slice &sl2)
1537 #if(CXSC_INDEX_CHECK)
1538  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1539 #else
1540  throw();
1541 #endif
1542  INLINE l_ivector_slice &operator |=(const l_ivector &rv)
1544 #if(CXSC_INDEX_CHECK)
1545  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1546 #else
1547  throw();
1548 #endif
1549  INLINE l_ivector_slice &operator |=(const l_ivector_slice &sl2)
1551 #if(CXSC_INDEX_CHECK)
1552  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1553 #else
1554  throw();
1555 #endif
1556  INLINE l_ivector_slice &operator &=(const l_ivector &rv)
1558 #if(CXSC_INDEX_CHECK)
1559  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1560 #else
1561  throw();
1562 #endif
1563  INLINE l_ivector_slice &operator &=(const l_ivector_slice &sl2)
1565 #if(CXSC_INDEX_CHECK)
1566  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1567 #else
1568  throw();
1569 #endif
1570 
1572  INLINE l_ivector_slice &operator *=(const real &r) throw();
1574  INLINE l_ivector_slice &operator /=(const real &r) throw();
1576  INLINE l_ivector_slice &operator +=(const rvector &rv)
1577 #if(CXSC_INDEX_CHECK)
1578  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1579 #else
1580  throw();
1581 #endif
1582  INLINE l_ivector_slice &operator +=(const rvector_slice &sl2)
1584 #if(CXSC_INDEX_CHECK)
1585  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1586 #else
1587  throw();
1588 #endif
1589  INLINE l_ivector_slice &operator -=(const rvector &rv)
1591 #if(CXSC_INDEX_CHECK)
1592  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1593 #else
1594  throw();
1595 #endif
1596  INLINE l_ivector_slice &operator -=(const rvector_slice &sl2)
1598 #if(CXSC_INDEX_CHECK)
1599  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1600 #else
1601  throw();
1602 #endif
1603  INLINE l_ivector_slice &operator |=(const rvector &rv)
1605 #if(CXSC_INDEX_CHECK)
1606  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1607 #else
1608  throw();
1609 #endif
1610  INLINE l_ivector_slice &operator |=(const rvector_slice &sl2)
1612 #if(CXSC_INDEX_CHECK)
1613  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1614 #else
1615  throw();
1616 #endif
1617  INLINE l_ivector_slice &operator &=(const rvector &rv)
1619 #if(CXSC_INDEX_CHECK)
1620  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1621 #else
1622  throw();
1623 #endif
1624  INLINE l_ivector_slice &operator &=(const rvector_slice &sl2)
1626 #if(CXSC_INDEX_CHECK)
1627  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1628 #else
1629  throw();
1630 #endif
1631  INLINE l_ivector_slice &operator *=(const rmatrix &m)
1633 #if(CXSC_INDEX_CHECK)
1634  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
1635 #else
1636  throw();
1637 #endif
1638  INLINE l_ivector_slice &operator *=(const rmatrix_slice &m)
1640 #if(CXSC_INDEX_CHECK)
1641  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
1642 #else
1643  throw();
1644 #endif
1645 
1647  INLINE l_ivector_slice &operator *=(const l_real &r) throw();
1649  INLINE l_ivector_slice &operator /=(const l_real &r) throw();
1651  INLINE l_ivector_slice &operator +=(const l_rvector &rv)
1652 #if(CXSC_INDEX_CHECK)
1653  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1654 #else
1655  throw();
1656 #endif
1657  INLINE l_ivector_slice &operator +=(const l_rvector_slice &sl2)
1659 #if(CXSC_INDEX_CHECK)
1660  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1661 #else
1662  throw();
1663 #endif
1664  INLINE l_ivector_slice &operator -=(const l_rvector &rv)
1666 #if(CXSC_INDEX_CHECK)
1667  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1668 #else
1669  throw();
1670 #endif
1671  INLINE l_ivector_slice &operator -=(const l_rvector_slice &sl2)
1673 #if(CXSC_INDEX_CHECK)
1674  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1675 #else
1676  throw();
1677 #endif
1678  INLINE l_ivector_slice &operator |=(const l_rvector &rv)
1680 #if(CXSC_INDEX_CHECK)
1681  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1682 #else
1683  throw();
1684 #endif
1685  INLINE l_ivector_slice &operator |=(const l_rvector_slice &sl2)
1687 #if(CXSC_INDEX_CHECK)
1688  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1689 #else
1690  throw();
1691 #endif
1692  INLINE l_ivector_slice &operator &=(const l_rvector &rv)
1694 #if(CXSC_INDEX_CHECK)
1695  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1696 #else
1697  throw();
1698 #endif
1699  INLINE l_ivector_slice &operator &=(const l_rvector_slice &sl2)
1701 #if(CXSC_INDEX_CHECK)
1702  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1703 #else
1704  throw();
1705 #endif
1706  INLINE l_ivector_slice &operator *=(const l_rmatrix &m)
1708 #if(CXSC_INDEX_CHECK)
1709  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1710 #else
1711  throw();
1712 #endif
1713  INLINE l_ivector_slice &operator *=(const l_rmatrix_slice &m)
1715 #if(CXSC_INDEX_CHECK)
1716  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1717 #else
1718  throw();
1719 #endif
1720 
1722  INLINE l_ivector_slice &operator *=(const interval &r) throw();
1724  INLINE l_ivector_slice &operator /=(const interval &r) throw();
1726  INLINE l_ivector_slice &operator +=(const ivector &rv)
1727 #if(CXSC_INDEX_CHECK)
1728  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1729 #else
1730  throw();
1731 #endif
1732  INLINE l_ivector_slice &operator +=(const ivector_slice &sl2)
1734 #if(CXSC_INDEX_CHECK)
1735  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1736 #else
1737  throw();
1738 #endif
1739  INLINE l_ivector_slice &operator -=(const ivector &rv)
1741 #if(CXSC_INDEX_CHECK)
1742  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1743 #else
1744  throw();
1745 #endif
1746  INLINE l_ivector_slice &operator -=(const ivector_slice &sl2)
1748 #if(CXSC_INDEX_CHECK)
1749  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1750 #else
1751  throw();
1752 #endif
1753  INLINE l_ivector_slice &operator |=(const ivector &rv)
1755 #if(CXSC_INDEX_CHECK)
1756  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1757 #else
1758  throw();
1759 #endif
1760  INLINE l_ivector_slice &operator |=(const ivector_slice &sl2)
1762 #if(CXSC_INDEX_CHECK)
1763  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1764 #else
1765  throw();
1766 #endif
1767  INLINE l_ivector_slice &operator &=(const ivector &rv)
1769 #if(CXSC_INDEX_CHECK)
1770  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1771 #else
1772  throw();
1773 #endif
1774  INLINE l_ivector_slice &operator &=(const ivector_slice &sl2)
1776 #if(CXSC_INDEX_CHECK)
1777  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
1778 #else
1779  throw();
1780 #endif
1781  INLINE l_ivector_slice &operator *=(const imatrix &m)
1783 #if(CXSC_INDEX_CHECK)
1784  throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
1785 #else
1786  throw();
1787 #endif
1788  INLINE l_ivector_slice &operator *=(const imatrix_slice &m)
1790 #if(CXSC_INDEX_CHECK)
1791  throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
1792 #else
1793  throw();
1794 #endif
1795 //#else
1796 //#endif
1797 };
1798 
1799 //=======================================================================
1800 //======================== Vector Functions =============================
1801 
1803  INLINE l_ivector _l_ivector(const l_interval &r) throw();
1804 // INLINE l_ivector _l_ivector(const l_imatrix &m) throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
1805 // INLINE l_ivector _l_ivector(const l_imatrix_slice &sl) throw(ERROR_LIMATRIX_TYPE_CAST_OF_THICK_OBJ);
1807  INLINE l_ivector _l_ivector(const real &r) throw();
1809  INLINE l_ivector _l_ivector(const rvector_slice &rs) throw();
1811  INLINE l_ivector _l_ivector(const rvector &rs) throw();
1812 // INLINE l_ivector _l_ivector(const rmatrix &m) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
1813 // INLINE l_ivector _l_ivector(const rmatrix_slice &sl) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
1815  INLINE l_ivector _l_ivector(const rmatrix_subv &rs) throw();
1816 
1818  INLINE l_ivector &SetInf(l_ivector &iv,const l_rvector &rv)
1819 #if(CXSC_INDEX_CHECK)
1820  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
1821 #else
1822  throw();
1823 #endif
1824  INLINE l_ivector_slice &SetInf(l_ivector_slice &iv,const l_rvector &rv)
1826 #if(CXSC_INDEX_CHECK)
1827  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
1828 #else
1829  throw();
1830 #endif
1831  INLINE l_ivector &SetInf(l_ivector &iv,const l_rvector_slice &rv)
1833 #if(CXSC_INDEX_CHECK)
1834  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
1835 #else
1836  throw();
1837 #endif
1838  INLINE l_ivector_slice &SetInf(l_ivector_slice &iv,const l_rvector_slice &rv)
1840 #if(CXSC_INDEX_CHECK)
1841  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
1842 #else
1843  throw();
1844 #endif
1845  INLINE l_ivector &UncheckedSetInf(l_ivector &iv,const l_rvector &rv)
1847 #if(CXSC_INDEX_CHECK)
1848  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
1849 #else
1850  throw();
1851 #endif
1852  INLINE l_ivector_slice &UncheckedSetInf(l_ivector_slice &iv,const l_rvector &rv)
1854 #if(CXSC_INDEX_CHECK)
1855  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
1856 #else
1857  throw();
1858 #endif
1859  INLINE l_ivector &UncheckedSetInf(l_ivector &iv,const l_rvector_slice &rv)
1861 #if(CXSC_INDEX_CHECK)
1862  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
1863 #else
1864  throw();
1865 #endif
1866  INLINE l_ivector_slice &UncheckedSetInf(l_ivector_slice &iv,const l_rvector_slice &rv)
1868 #if(CXSC_INDEX_CHECK)
1869  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
1870 #else
1871  throw();
1872 #endif
1873 
1875  INLINE l_ivector &SetSup(l_ivector &iv,const l_rvector &rv)
1876 #if(CXSC_INDEX_CHECK)
1877  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
1878 #else
1879  throw();
1880 #endif
1881  INLINE l_ivector_slice &SetSup(l_ivector_slice &iv,const l_rvector &rv)
1883 #if(CXSC_INDEX_CHECK)
1884  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
1885 #else
1886  throw();
1887 #endif
1888  INLINE l_ivector &SetSup(l_ivector &iv,const l_rvector_slice &rv)
1890 #if(CXSC_INDEX_CHECK)
1891  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
1892 #else
1893  throw();
1894 #endif
1895  INLINE l_ivector_slice &SetSup(l_ivector_slice &iv,const l_rvector_slice &rv)
1897 #if(CXSC_INDEX_CHECK)
1898  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
1899 #else
1900  throw();
1901 #endif
1902  INLINE l_ivector &UncheckedSetSup(l_ivector &iv,const l_rvector &rv)
1904 #if(CXSC_INDEX_CHECK)
1905  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
1906 #else
1907  throw();
1908 #endif
1909  INLINE l_ivector_slice &UncheckedSetSup(l_ivector_slice &iv,const l_rvector &rv)
1911 #if(CXSC_INDEX_CHECK)
1912  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
1913 #else
1914  throw();
1915 #endif
1916  INLINE l_ivector &UncheckedSetSup(l_ivector &iv,const l_rvector_slice &rv)
1918 #if(CXSC_INDEX_CHECK)
1919  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
1920 #else
1921  throw();
1922 #endif
1923  INLINE l_ivector_slice &UncheckedSetSup(l_ivector_slice &iv,const l_rvector_slice &rv)
1925 #if(CXSC_INDEX_CHECK)
1926  throw(ERROR_LIVECTOR_OP_WITH_WRONG_DIM);
1927 #else
1928  throw();
1929 #endif
1930 
1932  INLINE l_ivector &SetSup(l_ivector &iv,const l_real &r) throw();
1934  INLINE l_ivector &SetInf(l_ivector &iv,const l_real &r) throw();
1936  INLINE l_ivector &UncheckedSetSup(l_ivector &iv,const l_real &r) throw();
1938  INLINE l_ivector &SetUncheckedInf(l_ivector &iv,const l_real &r) throw();
1939 
1941  INLINE l_ivector_slice &SetSup(l_ivector_slice &iv,const l_real &r) throw();
1943  INLINE l_ivector_slice &SetInf(l_ivector_slice &iv,const l_real &r) throw();
1945  INLINE l_ivector_slice &UncheckedSetSup(l_ivector_slice &iv,const l_real &r) throw();
1947  INLINE l_ivector_slice &SetUncheckedInf(l_ivector_slice &iv,const l_real &r) throw();
1948 
1950  INLINE void Resize(l_ivector &rv) throw();
1952  INLINE void Resize(l_ivector &rv, const int &len)
1953 #if(CXSC_INDEX_CHECK)
1954  throw(ERROR__WRONG_BOUNDARIES<l_ivector>);
1955 #else
1956  throw();
1957 #endif
1958  INLINE void Resize(l_ivector &rv, const int &lb, const int &ub)
1960 #if(CXSC_INDEX_CHECK)
1961  throw(ERROR__WRONG_BOUNDARIES<l_ivector>);
1962 #else
1963  throw();
1964 #endif
1965 
1967  INLINE l_ivector abs(const l_ivector &rv) throw();
1969  INLINE l_ivector abs(const l_ivector_slice &sl) throw();
1971  INLINE l_rvector diam(const l_ivector &v) throw();
1973  INLINE l_rvector diam(const l_ivector_slice &v) throw();
1975  INLINE l_rvector mid(const l_ivector &v) throw();
1977  INLINE l_rvector mid(const l_ivector_slice &v) throw();
1979  INLINE l_rvector Inf(const l_ivector &v) throw();
1981  INLINE l_rvector Inf(const l_ivector_slice &v) throw();
1983  INLINE l_rvector Sup(const l_ivector &v) throw();
1985  INLINE l_rvector Sup(const l_ivector_slice &v) throw();
1987  INLINE bool operator !(const l_ivector &rv) throw();
1989  INLINE bool operator !(const l_ivector_slice &sl) throw();
1990 
1991 //======================= Vector / Scalar ===============================
1992 
1993 //----------------------------- l_interval ---------------------------
1994 
1996  INLINE l_ivector operator *(const l_ivector &rv, const l_interval &s) throw();
1998  INLINE l_ivector operator *(const l_ivector_slice &sl, const l_interval &s) throw();
2000  INLINE l_ivector operator *(const l_interval &s, const l_ivector &rv) throw();
2002  INLINE l_ivector operator *(const l_interval &s, const l_ivector_slice &sl) throw();
2004  INLINE l_ivector &operator *=(l_ivector &rv,const l_interval &r) throw();
2005 
2007  INLINE l_ivector operator /(const l_ivector &rv, const l_interval &s) throw();
2009  INLINE l_ivector operator /(const l_ivector_slice &sl, const l_interval &s) throw();
2011  INLINE l_ivector &operator /=(l_ivector &rv,const l_interval &r) throw();
2012 
2013 //---------------------------- Real --------------------------------------
2014 
2016  INLINE l_ivector operator *(const l_ivector &rv, const real &s) throw();
2018  INLINE l_ivector operator *(const l_ivector_slice &sl, const real &s) throw();
2020  INLINE l_ivector operator *(const real &s, const l_ivector &rv) throw();
2022  INLINE l_ivector operator *(const real &s, const l_ivector_slice &sl) throw();
2024  INLINE l_ivector &operator *=(l_ivector &rv,const real &r) throw();
2025 
2027  INLINE l_ivector operator /(const l_ivector &rv, const real &s) throw();
2029  INLINE l_ivector operator /(const l_ivector_slice &sl, const real &s) throw();
2031  INLINE l_ivector &operator /=(l_ivector &rv,const real &r) throw();
2032 
2034  INLINE l_ivector operator *(const rvector &rv, const l_interval &s) throw();
2036  INLINE l_ivector operator *(const rvector_slice &sl, const l_interval &s) throw();
2038  INLINE l_ivector operator *(const l_interval &s, const rvector &rv) throw();
2040  INLINE l_ivector operator *(const l_interval &s, const rvector_slice &sl) throw();
2041 
2043  INLINE l_ivector operator /(const rvector &rv, const l_interval &s) throw();
2045  INLINE l_ivector operator /(const rvector_slice &sl, const l_interval &s) throw();
2046 
2047 //---------------------------- Complex --------------------------------------
2048 
2050  INLINE l_ivector operator *(const l_ivector &rv, const l_real &s) throw();
2052  INLINE l_ivector operator *(const l_ivector_slice &sl, const l_real &s) throw();
2054  INLINE l_ivector operator *(const l_real &s, const l_ivector &rv) throw();
2056  INLINE l_ivector operator *(const l_real &s, const l_ivector_slice &sl) throw();
2058  INLINE l_ivector &operator *=(l_ivector &rv,const l_real &r) throw();
2059 
2061  INLINE l_ivector operator /(const l_ivector &rv, const l_real &s) throw();
2063  INLINE l_ivector operator /(const l_ivector_slice &sl, const l_real &s) throw();
2065  INLINE l_ivector &operator /=(l_ivector &rv,const l_real &r) throw();
2066 
2068  INLINE l_ivector operator *(const l_rvector &rv, const l_interval &s) throw();
2070  INLINE l_ivector operator *(const l_rvector_slice &sl, const l_interval &s) throw();
2072  INLINE l_ivector operator *(const l_interval &s, const l_rvector &rv) throw();
2074  INLINE l_ivector operator *(const l_interval &s, const l_rvector_slice &sl) throw();
2075 
2077  INLINE l_ivector operator /(const l_rvector &rv, const l_interval &s) throw();
2079  INLINE l_ivector operator /(const l_rvector_slice &sl, const l_interval &s) throw();
2080 
2081 //---------------------------- interval --------------------------------------
2082 
2084  INLINE l_ivector operator *(const l_ivector &rv, const interval &s) throw();
2086  INLINE l_ivector operator *(const l_ivector_slice &sl, const interval &s) throw();
2088  INLINE l_ivector operator *(const interval &s, const l_ivector &rv) throw();
2090  INLINE l_ivector operator *(const interval &s, const l_ivector_slice &sl) throw();
2092  INLINE l_ivector &operator *=(l_ivector &rv,const interval &r) throw();
2093 
2095  INLINE l_ivector operator /(const l_ivector &rv, const interval &s) throw();
2097  INLINE l_ivector operator /(const l_ivector_slice &sl, const interval &s) throw();
2099  INLINE l_ivector &operator /=(l_ivector &rv,const interval &r) throw();
2100 
2102  INLINE l_ivector operator *(const ivector &rv, const l_interval &s) throw();
2104  INLINE l_ivector operator *(const ivector_slice &sl, const l_interval &s) throw();
2106  INLINE l_ivector operator *(const l_interval &s, const ivector &rv) throw();
2108  INLINE l_ivector operator *(const l_interval &s, const ivector_slice &sl) throw();
2109 
2111  INLINE l_ivector operator /(const ivector &rv, const l_interval &s) throw();
2113  INLINE l_ivector operator /(const ivector_slice &sl, const l_interval &s) throw();
2114 
2115 //======================= Vector / Vector ===============================
2116 
2117 
2119  INLINE std::ostream &operator <<(std::ostream &s, const l_ivector &rv) throw();
2121  INLINE std::ostream &operator <<(std::ostream &o, const l_ivector_slice &sl) throw();
2123  INLINE std::istream &operator >>(std::istream &s, l_ivector &rv) throw();
2125  INLINE std::istream &operator >>(std::istream &s, l_ivector_slice &rv) throw();
2126 
2127 //----------------------- l_interval / l_interval ---------------------------
2128 
2130  INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const l_ivector &rv2)
2131 #if(CXSC_INDEX_CHECK)
2132  throw(OP_WITH_WRONG_DIM);
2133 #else
2134  throw();
2135 #endif
2136  INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl, const l_ivector &rv)
2138 #if(CXSC_INDEX_CHECK)
2139  throw(OP_WITH_WRONG_DIM);
2140 #else
2141  throw();
2142 #endif
2143  INLINE void accumulate(idotprecision &dp, const l_ivector &rv, const l_ivector_slice &sl)
2145 #if(CXSC_INDEX_CHECK)
2146  throw(OP_WITH_WRONG_DIM);
2147 #else
2148  throw();
2149 #endif
2150  INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const l_imatrix_subv &rv2)
2152 #if(CXSC_INDEX_CHECK)
2153  throw(OP_WITH_WRONG_DIM);
2154 #else
2155  throw();
2156 #endif
2157  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_ivector &rv2)
2159 #if(CXSC_INDEX_CHECK)
2160  throw(OP_WITH_WRONG_DIM);
2161 #else
2162  throw();
2163 #endif
2164  INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl1, const l_ivector_slice &sl2)
2166 #if(CXSC_INDEX_CHECK)
2167  throw(OP_WITH_WRONG_DIM);
2168 #else
2169  throw();
2170 #endif
2171 
2173  INLINE l_interval operator *(const l_ivector & rv1, const l_ivector &rv2)
2174 #if(CXSC_INDEX_CHECK)
2175  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2176 #else
2177  throw();
2178 #endif
2179  INLINE l_interval operator *(const l_ivector_slice &sl, const l_ivector &rv)
2181 #if(CXSC_INDEX_CHECK)
2182  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2183 #else
2184  throw();
2185 #endif
2186  INLINE l_interval operator *(const l_ivector &rv, const l_ivector_slice &sl)
2188 #if(CXSC_INDEX_CHECK)
2189  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2190 #else
2191  throw();
2192 #endif
2193  INLINE l_interval operator *(const l_ivector_slice & sl1, const l_ivector_slice &sl2)
2195 #if(CXSC_INDEX_CHECK)
2196  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2197 #else
2198  throw();
2199 #endif
2200 
2202  INLINE const l_ivector &operator +(const l_ivector &rv) throw();
2204  INLINE l_ivector operator +(const l_ivector_slice &sl) throw();
2205 
2207  INLINE l_ivector operator +(const l_ivector &rv1, const l_ivector &rv2)
2208 #if(CXSC_INDEX_CHECK)
2209  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2210 #else
2211  throw();
2212 #endif
2213  INLINE l_ivector operator +(const l_ivector &rv, const l_ivector_slice &sl)
2215 #if(CXSC_INDEX_CHECK)
2216  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2217 #else
2218  throw();
2219 #endif
2220  INLINE l_ivector operator +(const l_ivector_slice &sl, const l_ivector &rv)
2222 #if(CXSC_INDEX_CHECK)
2223  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2224 #else
2225  throw();
2226 #endif
2227  INLINE l_ivector operator +(const l_ivector_slice &sl1, const l_ivector_slice &sl2)
2229 #if(CXSC_INDEX_CHECK)
2230  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2231 #else
2232  throw();
2233 #endif
2234  INLINE l_ivector & operator +=(l_ivector &rv1, const l_ivector &rv2)
2236 #if(CXSC_INDEX_CHECK)
2237  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2238 #else
2239  throw();
2240 #endif
2241  INLINE l_ivector &operator +=(l_ivector &rv, const l_ivector_slice &sl)
2243 #if(CXSC_INDEX_CHECK)
2244  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2245 #else
2246  throw();
2247 #endif
2248 
2250  INLINE l_ivector operator -(const l_ivector &rv) throw();
2252  INLINE l_ivector operator -(const l_ivector_slice &sl) throw();
2254  INLINE l_ivector operator -(const l_ivector &rv1, const l_ivector &rv2)
2255 #if(CXSC_INDEX_CHECK)
2256  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2257 #else
2258  throw();
2259 #endif
2260  INLINE l_ivector operator -(const l_ivector &rv, const l_ivector_slice &sl)
2262 #if(CXSC_INDEX_CHECK)
2263  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2264 #else
2265  throw();
2266 #endif
2267  INLINE l_ivector operator -(const l_ivector_slice &sl, const l_ivector &rv)
2269 #if(CXSC_INDEX_CHECK)
2270  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2271 #else
2272  throw();
2273 #endif
2274  INLINE l_ivector operator -(const l_ivector_slice &sl1, const l_ivector_slice &sl2)
2276 #if(CXSC_INDEX_CHECK)
2277  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2278 #else
2279  throw();
2280 #endif
2281  INLINE l_ivector & operator -=(l_ivector &rv1, const l_ivector &rv2)
2283 #if(CXSC_INDEX_CHECK)
2284  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2285 #else
2286  throw();
2287 #endif
2288  INLINE l_ivector &operator -=(l_ivector &rv, const l_ivector_slice &sl)
2290 #if(CXSC_INDEX_CHECK)
2291  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2292 #else
2293  throw();
2294 #endif
2295 
2297  INLINE l_ivector operator |(const l_ivector &rv1, const l_ivector &rv2)
2298 #if(CXSC_INDEX_CHECK)
2299  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2300 #else
2301  throw();
2302 #endif
2303  INLINE l_ivector operator |(const l_ivector &rv, const l_ivector_slice &sl)
2305 #if(CXSC_INDEX_CHECK)
2306  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2307 #else
2308  throw();
2309 #endif
2310  INLINE l_ivector operator |(const l_ivector_slice &sl, const l_ivector &rv)
2312 #if(CXSC_INDEX_CHECK)
2313  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2314 #else
2315  throw();
2316 #endif
2317  INLINE l_ivector operator |(const l_ivector_slice &sl1, const l_ivector_slice &sl2)
2319 #if(CXSC_INDEX_CHECK)
2320  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2321 #else
2322  throw();
2323 #endif
2324  INLINE l_ivector & operator |=(l_ivector &rv1, const l_ivector &rv2)
2326 #if(CXSC_INDEX_CHECK)
2327  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2328 #else
2329  throw();
2330 #endif
2331  INLINE l_ivector &operator |=(l_ivector &rv, const l_ivector_slice &sl)
2333 #if(CXSC_INDEX_CHECK)
2334  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2335 #else
2336  throw();
2337 #endif
2338 
2340  INLINE l_ivector operator &(const l_ivector &rv1, const l_ivector &rv2)
2341 #if(CXSC_INDEX_CHECK)
2342  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2343 #else
2344  throw();
2345 #endif
2346  INLINE l_ivector operator &(const l_ivector &rv, const l_ivector_slice &sl)
2348 #if(CXSC_INDEX_CHECK)
2349  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2350 #else
2351  throw();
2352 #endif
2353  INLINE l_ivector operator &(const l_ivector_slice &sl, const l_ivector &rv)
2355 #if(CXSC_INDEX_CHECK)
2356  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2357 #else
2358  throw();
2359 #endif
2360  INLINE l_ivector operator &(const l_ivector_slice &sl1, const l_ivector_slice &sl2)
2362 #if(CXSC_INDEX_CHECK)
2363  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2364 #else
2365  throw();
2366 #endif
2367  INLINE l_ivector & operator &=(l_ivector &rv1, const l_ivector &rv2)
2369 #if(CXSC_INDEX_CHECK)
2370  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2371 #else
2372  throw();
2373 #endif
2374  INLINE l_ivector &operator &=(l_ivector &rv, const l_ivector_slice &sl)
2376 #if(CXSC_INDEX_CHECK)
2377  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2378 #else
2379  throw();
2380 #endif
2381 
2383  INLINE bool operator ==(const l_ivector &rv1, const l_ivector &rv2) throw();
2385  INLINE bool operator ==(const l_ivector_slice &sl1, const l_ivector_slice &sl2) throw();
2387  INLINE bool operator ==(const l_ivector_slice &sl, const l_ivector &rv) throw();
2389  INLINE bool operator ==(const l_ivector &rv, const l_ivector_slice &sl) throw();
2391  INLINE bool operator !=(const l_ivector &rv1, const l_ivector &rv2) throw();
2393  INLINE bool operator !=(const l_ivector_slice &sl1, const l_ivector_slice &sl2) throw();
2395  INLINE bool operator !=(const l_ivector_slice &sl, const l_ivector &rv) throw();
2397  INLINE bool operator !=(const l_ivector &rv, const l_ivector_slice &sl) throw();
2399  INLINE bool operator <(const l_ivector &rv1, const l_ivector &rv2) throw();
2401  INLINE bool operator <(const l_ivector_slice &sl1, const l_ivector_slice &sl2) throw();
2403  INLINE bool operator < (const l_ivector_slice &sl, const l_ivector &rv) throw();
2405  INLINE bool operator < (const l_ivector &rv, const l_ivector_slice &sl) throw();
2407  INLINE bool operator <=(const l_ivector &rv1, const l_ivector &rv2) throw();
2409  INLINE bool operator <=(const l_ivector_slice &sl1, const l_ivector_slice &sl2) throw();
2411  INLINE bool operator <=(const l_ivector_slice &sl, const l_ivector &rv) throw();
2413  INLINE bool operator <=(const l_ivector &rv, const l_ivector_slice &sl) throw();
2415  INLINE bool operator >(const l_ivector &rv1, const l_ivector &rv2) throw();
2417  INLINE bool operator >(const l_ivector_slice &sl1, const l_ivector_slice &sl2) throw();
2419  INLINE bool operator >(const l_ivector_slice &sl, const l_ivector &rv) throw();
2421  INLINE bool operator >(const l_ivector &rv, const l_ivector_slice &sl) throw();
2423  INLINE bool operator >=(const l_ivector &rv1, const l_ivector &rv2) throw();
2425  INLINE bool operator >=(const l_ivector_slice &sl1, const l_ivector_slice &sl2) throw();
2427  INLINE bool operator >=(const l_ivector_slice &sl, const l_ivector &rv) throw();
2429  INLINE bool operator >=(const l_ivector &rv, const l_ivector_slice &sl) throw();
2430 
2431 //-------------------------------- l_interval / Real --------------------------------
2432 
2434  INLINE void accumulate(idotprecision &dp, const rvector & rv1, const l_ivector &rv2)
2435 #if(CXSC_INDEX_CHECK)
2436  throw(OP_WITH_WRONG_DIM);
2437 #else
2438  throw();
2439 #endif
2440  INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const rvector &rv2)
2442 #if(CXSC_INDEX_CHECK)
2443  throw(OP_WITH_WRONG_DIM);
2444 #else
2445  throw();
2446 #endif
2447  INLINE void accumulate(idotprecision &dp, const rvector_slice & sl, const l_ivector &rv)
2449 #if(CXSC_INDEX_CHECK)
2450  throw(OP_WITH_WRONG_DIM);
2451 #else
2452  throw();
2453 #endif
2454  INLINE void accumulate(idotprecision &dp,const l_ivector_slice &sl,const rvector &rv)
2456 #if(CXSC_INDEX_CHECK)
2457  throw(OP_WITH_WRONG_DIM);
2458 #else
2459  throw();
2460 #endif
2461  INLINE void accumulate(idotprecision &dp, const rvector &rv, const l_ivector_slice &sl)
2463 #if(CXSC_INDEX_CHECK)
2464  throw(OP_WITH_WRONG_DIM);
2465 #else
2466  throw();
2467 #endif
2468  INLINE void accumulate(idotprecision &dp, const rvector & rv1, const l_imatrix_subv &rv2)
2470 #if(CXSC_INDEX_CHECK)
2471  throw(OP_WITH_WRONG_DIM);
2472 #else
2473  throw();
2474 #endif
2475  INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const rmatrix_subv &rv2)
2477 #if(CXSC_INDEX_CHECK)
2478  throw(OP_WITH_WRONG_DIM);
2479 #else
2480  throw();
2481 #endif
2482  INLINE void accumulate(idotprecision &dp,const l_ivector &rv,const rvector_slice &sl)
2484 #if(CXSC_INDEX_CHECK)
2485  throw(OP_WITH_WRONG_DIM);
2486 #else
2487  throw();
2488 #endif
2489  INLINE void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const l_ivector &rv2)
2491 #if(CXSC_INDEX_CHECK)
2492  throw(OP_WITH_WRONG_DIM);
2493 #else
2494  throw();
2495 #endif
2496  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const rvector &rv2)
2498 #if(CXSC_INDEX_CHECK)
2499  throw(OP_WITH_WRONG_DIM);
2500 #else
2501  throw();
2502 #endif
2503  INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl1, const rvector_slice &sl2)
2505 #if(CXSC_INDEX_CHECK)
2506  throw(OP_WITH_WRONG_DIM);
2507 #else
2508  throw();
2509 #endif
2510  INLINE void accumulate(idotprecision &dp, const rvector_slice & sl1, const l_ivector_slice &sl2)
2512 #if(CXSC_INDEX_CHECK)
2513  throw(OP_WITH_WRONG_DIM);
2514 #else
2515  throw();
2516 #endif
2517 
2519  INLINE l_interval operator *(const rvector & rv1, const l_ivector &rv2)
2520 #if(CXSC_INDEX_CHECK)
2521  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2522 #else
2523  throw();
2524 #endif
2525  INLINE l_interval operator *(const rvector_slice &sl, const l_ivector &rv)
2527 #if(CXSC_INDEX_CHECK)
2528  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2529 #else
2530  throw();
2531 #endif
2532  INLINE l_interval operator *(const rvector &rv, const l_ivector_slice &sl)
2534 #if(CXSC_INDEX_CHECK)
2535  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2536 #else
2537  throw();
2538 #endif
2539  INLINE l_interval operator *(const rvector_slice & sl1, const l_ivector_slice &sl2)
2541 #if(CXSC_INDEX_CHECK)
2542  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2543 #else
2544  throw();
2545 #endif
2546 
2548  INLINE l_interval operator *(const l_ivector & rv1, const rvector &rv2)
2549 #if(CXSC_INDEX_CHECK)
2550  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2551 #else
2552  throw();
2553 #endif
2554  INLINE l_interval operator *(const l_ivector_slice &sl, const rvector &rv)
2556 #if(CXSC_INDEX_CHECK)
2557  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2558 #else
2559  throw();
2560 #endif
2561  INLINE l_interval operator *(const l_ivector &rv, const rvector_slice &sl)
2563 #if(CXSC_INDEX_CHECK)
2564  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2565 #else
2566  throw();
2567 #endif
2568  INLINE l_interval operator *(const l_ivector_slice & sl1, const rvector_slice &sl2)
2570 #if(CXSC_INDEX_CHECK)
2571  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2572 #else
2573  throw();
2574 #endif
2575 
2577  INLINE l_ivector operator +(const rvector &rv1, const l_ivector &rv2)
2578 #if(CXSC_INDEX_CHECK)
2579  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2580 #else
2581  throw();
2582 #endif
2583  INLINE l_ivector operator +(const rvector &rv, const l_ivector_slice &sl)
2585 #if(CXSC_INDEX_CHECK)
2586  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2587 #else
2588  throw();
2589 #endif
2590  INLINE l_ivector operator +(const rvector_slice &sl, const l_ivector &rv)
2592 #if(CXSC_INDEX_CHECK)
2593  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2594 #else
2595  throw();
2596 #endif
2597  INLINE l_ivector operator +(const rvector_slice &sl1, const l_ivector_slice &sl2)
2599 #if(CXSC_INDEX_CHECK)
2600  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2601 #else
2602  throw();
2603 #endif
2604 
2606  INLINE l_ivector operator +(const l_ivector &rv1, const rvector &rv2)
2607 #if(CXSC_INDEX_CHECK)
2608  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2609 #else
2610  throw();
2611 #endif
2612  INLINE l_ivector operator +(const l_ivector &rv, const rvector_slice &sl)
2614 #if(CXSC_INDEX_CHECK)
2615  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2616 #else
2617  throw();
2618 #endif
2619  INLINE l_ivector operator +(const l_ivector_slice &sl, const rvector &rv)
2621 #if(CXSC_INDEX_CHECK)
2622  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2623 #else
2624  throw();
2625 #endif
2626  INLINE l_ivector operator +(const l_ivector_slice &sl1, const rvector_slice &sl2)
2628 #if(CXSC_INDEX_CHECK)
2629  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2630 #else
2631  throw();
2632 #endif
2633 
2635  INLINE l_ivector & operator +=(l_ivector &rv1, const rvector &rv2)
2636 #if(CXSC_INDEX_CHECK)
2637  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2638 #else
2639  throw();
2640 #endif
2641  INLINE l_ivector &operator +=(l_ivector &rv, const rvector_slice &sl)
2643 #if(CXSC_INDEX_CHECK)
2644  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2645 #else
2646  throw();
2647 #endif
2648 
2650  INLINE l_ivector operator -(const rvector &rv1, const l_ivector &rv2)
2651 #if(CXSC_INDEX_CHECK)
2652  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2653 #else
2654  throw();
2655 #endif
2656  INLINE l_ivector operator -(const rvector &rv, const l_ivector_slice &sl)
2658 #if(CXSC_INDEX_CHECK)
2659  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2660 #else
2661  throw();
2662 #endif
2663  INLINE l_ivector operator -(const rvector_slice &sl, const l_ivector &rv)
2665 #if(CXSC_INDEX_CHECK)
2666  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2667 #else
2668  throw();
2669 #endif
2670  INLINE l_ivector operator -(const rvector_slice &sl1, const l_ivector_slice &sl2)
2672 #if(CXSC_INDEX_CHECK)
2673  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2674 #else
2675  throw();
2676 #endif
2677 
2679  INLINE l_ivector operator -(const l_ivector &rv1, const rvector &rv2)
2680 #if(CXSC_INDEX_CHECK)
2681  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2682 #else
2683  throw();
2684 #endif
2685  INLINE l_ivector operator -(const l_ivector &rv, const rvector_slice &sl)
2687 #if(CXSC_INDEX_CHECK)
2688  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2689 #else
2690  throw();
2691 #endif
2692  INLINE l_ivector operator -(const l_ivector_slice &sl, const rvector &rv)
2694 #if(CXSC_INDEX_CHECK)
2695  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2696 #else
2697  throw();
2698 #endif
2699  INLINE l_ivector operator -(const l_ivector_slice &sl1, const rvector_slice &sl2)
2701 #if(CXSC_INDEX_CHECK)
2702  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2703 #else
2704  throw();
2705 #endif
2706 
2708  INLINE l_ivector & operator -=(l_ivector &rv1, const rvector &rv2)
2709 #if(CXSC_INDEX_CHECK)
2710  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2711 #else
2712  throw();
2713 #endif
2714  INLINE l_ivector &operator -=(l_ivector &rv, const rvector_slice &sl)
2716 #if(CXSC_INDEX_CHECK)
2717  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2718 #else
2719  throw();
2720 #endif
2721 
2723  INLINE l_ivector operator |(const rvector &rv1, const l_ivector &rv2)
2724 #if(CXSC_INDEX_CHECK)
2725  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2726 #else
2727  throw();
2728 #endif
2729  INLINE l_ivector operator |(const rvector &rv, const l_ivector_slice &sl)
2731 #if(CXSC_INDEX_CHECK)
2732  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2733 #else
2734  throw();
2735 #endif
2736  INLINE l_ivector operator |(const rvector_slice &sl, const l_ivector &rv)
2738 #if(CXSC_INDEX_CHECK)
2739  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2740 #else
2741  throw();
2742 #endif
2743  INLINE l_ivector operator |(const rvector_slice &sl1, const l_ivector_slice &sl2)
2745 #if(CXSC_INDEX_CHECK)
2746  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2747 #else
2748  throw();
2749 #endif
2750 
2752  INLINE l_ivector operator |(const l_ivector &rv1, const rvector &rv2)
2753 #if(CXSC_INDEX_CHECK)
2754  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2755 #else
2756  throw();
2757 #endif
2758  INLINE l_ivector operator |(const l_ivector &rv, const rvector_slice &sl)
2760 #if(CXSC_INDEX_CHECK)
2761  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2762 #else
2763  throw();
2764 #endif
2765  INLINE l_ivector operator |(const l_ivector_slice &sl, const rvector &rv)
2767 #if(CXSC_INDEX_CHECK)
2768  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2769 #else
2770  throw();
2771 #endif
2772  INLINE l_ivector operator |(const l_ivector_slice &sl1, const rvector_slice &sl2)
2774 #if(CXSC_INDEX_CHECK)
2775  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2776 #else
2777  throw();
2778 #endif
2779 
2781  INLINE l_ivector & operator |=(l_ivector &rv1, const rvector &rv2)
2782 #if(CXSC_INDEX_CHECK)
2783  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2784 #else
2785  throw();
2786 #endif
2787  INLINE l_ivector &operator |=(l_ivector &rv, const rvector_slice &sl)
2789 #if(CXSC_INDEX_CHECK)
2790  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2791 #else
2792  throw();
2793 #endif
2794 
2796  INLINE l_ivector operator &(const rvector &rv1, const l_ivector &rv2)
2797 #if(CXSC_INDEX_CHECK)
2798  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2799 #else
2800  throw();
2801 #endif
2802  INLINE l_ivector operator &(const rvector &rv, const l_ivector_slice &sl)
2804 #if(CXSC_INDEX_CHECK)
2805  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2806 #else
2807  throw();
2808 #endif
2809  INLINE l_ivector operator &(const rvector_slice &sl, const l_ivector &rv)
2811 #if(CXSC_INDEX_CHECK)
2812  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2813 #else
2814  throw();
2815 #endif
2816  INLINE l_ivector operator &(const rvector_slice &sl1, const l_ivector_slice &sl2)
2818 #if(CXSC_INDEX_CHECK)
2819  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2820 #else
2821  throw();
2822 #endif
2823 
2825  INLINE l_ivector operator &(const l_ivector &rv1, const rvector &rv2)
2826 #if(CXSC_INDEX_CHECK)
2827  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2828 #else
2829  throw();
2830 #endif
2831  INLINE l_ivector operator &(const l_ivector &rv, const rvector_slice &sl)
2833 #if(CXSC_INDEX_CHECK)
2834  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2835 #else
2836  throw();
2837 #endif
2838  INLINE l_ivector operator &(const l_ivector_slice &sl, const rvector &rv)
2840 #if(CXSC_INDEX_CHECK)
2841  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2842 #else
2843  throw();
2844 #endif
2845  INLINE l_ivector operator &(const l_ivector_slice &sl1, const rvector_slice &sl2)
2847 #if(CXSC_INDEX_CHECK)
2848  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2849 #else
2850  throw();
2851 #endif
2852 
2854  INLINE l_ivector & operator &=(l_ivector &rv1, const rvector &rv2)
2855 #if(CXSC_INDEX_CHECK)
2856  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2857 #else
2858  throw();
2859 #endif
2860  INLINE l_ivector &operator &=(l_ivector &rv, const rvector_slice &sl)
2862 #if(CXSC_INDEX_CHECK)
2863  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2864 #else
2865  throw();
2866 #endif
2867 //-------------------------------- l_interval / l_real --------------------------------
2868 
2870  INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const l_ivector &rv2)
2871 #if(CXSC_INDEX_CHECK)
2872  throw(OP_WITH_WRONG_DIM);
2873 #else
2874  throw();
2875 #endif
2876  INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const l_rvector &rv2)
2878 #if(CXSC_INDEX_CHECK)
2879  throw(OP_WITH_WRONG_DIM);
2880 #else
2881  throw();
2882 #endif
2883  INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl, const l_ivector &rv)
2885 #if(CXSC_INDEX_CHECK)
2886  throw(OP_WITH_WRONG_DIM);
2887 #else
2888  throw();
2889 #endif
2890  INLINE void accumulate(idotprecision &dp,const l_ivector_slice &sl,const l_rvector &rv)
2892 #if(CXSC_INDEX_CHECK)
2893  throw(OP_WITH_WRONG_DIM);
2894 #else
2895  throw();
2896 #endif
2897  INLINE void accumulate(idotprecision &dp, const l_rvector &rv, const l_ivector_slice &sl)
2899 #if(CXSC_INDEX_CHECK)
2900  throw(OP_WITH_WRONG_DIM);
2901 #else
2902  throw();
2903 #endif
2904  INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const l_imatrix_subv &rv2)
2906 #if(CXSC_INDEX_CHECK)
2907  throw(OP_WITH_WRONG_DIM);
2908 #else
2909  throw();
2910 #endif
2911  INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const l_rmatrix_subv &rv2)
2913 #if(CXSC_INDEX_CHECK)
2914  throw(OP_WITH_WRONG_DIM);
2915 #else
2916  throw();
2917 #endif
2918  INLINE void accumulate(idotprecision &dp,const l_ivector &rv,const l_rvector_slice &sl)
2920 #if(CXSC_INDEX_CHECK)
2921  throw(OP_WITH_WRONG_DIM);
2922 #else
2923  throw();
2924 #endif
2925  INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const l_ivector &rv2)
2927 #if(CXSC_INDEX_CHECK)
2928  throw(OP_WITH_WRONG_DIM);
2929 #else
2930  throw();
2931 #endif
2932  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_rvector &rv2)
2934 #if(CXSC_INDEX_CHECK)
2935  throw(OP_WITH_WRONG_DIM);
2936 #else
2937  throw();
2938 #endif
2939  INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl1, const l_rvector_slice &sl2)
2941 #if(CXSC_INDEX_CHECK)
2942  throw(OP_WITH_WRONG_DIM);
2943 #else
2944  throw();
2945 #endif
2946  INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl1, const l_ivector_slice &sl2)
2948 #if(CXSC_INDEX_CHECK)
2949  throw(OP_WITH_WRONG_DIM);
2950 #else
2951  throw();
2952 #endif
2953 
2955  INLINE l_interval operator *(const l_rvector & rv1, const l_ivector &rv2)
2956 #if(CXSC_INDEX_CHECK)
2957  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2958 #else
2959  throw();
2960 #endif
2961  INLINE l_interval operator *(const l_rvector_slice &sl, const l_ivector &rv)
2963 #if(CXSC_INDEX_CHECK)
2964  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2965 #else
2966  throw();
2967 #endif
2968  INLINE l_interval operator *(const l_rvector &rv, const l_ivector_slice &sl)
2970 #if(CXSC_INDEX_CHECK)
2971  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2972 #else
2973  throw();
2974 #endif
2975  INLINE l_interval operator *(const l_rvector_slice & sl1, const l_ivector_slice &sl2)
2977 #if(CXSC_INDEX_CHECK)
2978  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2979 #else
2980  throw();
2981 #endif
2982 
2984  INLINE l_interval operator *(const l_ivector & rv1, const l_rvector &rv2)
2985 #if(CXSC_INDEX_CHECK)
2986  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2987 #else
2988  throw();
2989 #endif
2990  INLINE l_interval operator *(const l_ivector_slice &sl, const l_rvector &rv)
2992 #if(CXSC_INDEX_CHECK)
2993  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
2994 #else
2995  throw();
2996 #endif
2997  INLINE l_interval operator *(const l_ivector &rv, const l_rvector_slice &sl)
2999 #if(CXSC_INDEX_CHECK)
3000  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3001 #else
3002  throw();
3003 #endif
3004  INLINE l_interval operator *(const l_ivector_slice & sl1, const l_rvector_slice &sl2)
3006 #if(CXSC_INDEX_CHECK)
3007  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3008 #else
3009  throw();
3010 #endif
3011 
3013  INLINE l_ivector operator +(const l_rvector &rv1, const l_ivector &rv2)
3014 #if(CXSC_INDEX_CHECK)
3015  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3016 #else
3017  throw();
3018 #endif
3019  INLINE l_ivector operator +(const l_rvector &rv, const l_ivector_slice &sl)
3021 #if(CXSC_INDEX_CHECK)
3022  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3023 #else
3024  throw();
3025 #endif
3026  INLINE l_ivector operator +(const l_rvector_slice &sl, const l_ivector &rv)
3028 #if(CXSC_INDEX_CHECK)
3029  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3030 #else
3031  throw();
3032 #endif
3033  INLINE l_ivector operator +(const l_rvector_slice &sl1, const l_ivector_slice &sl2)
3035 #if(CXSC_INDEX_CHECK)
3036  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3037 #else
3038  throw();
3039 #endif
3040 
3042  INLINE l_ivector operator +(const l_ivector &rv1, const l_rvector &rv2)
3043 #if(CXSC_INDEX_CHECK)
3044  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3045 #else
3046  throw();
3047 #endif
3048  INLINE l_ivector operator +(const l_ivector &rv, const l_rvector_slice &sl)
3050 #if(CXSC_INDEX_CHECK)
3051  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3052 #else
3053  throw();
3054 #endif
3055  INLINE l_ivector operator +(const l_ivector_slice &sl, const l_rvector &rv)
3057 #if(CXSC_INDEX_CHECK)
3058  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3059 #else
3060  throw();
3061 #endif
3062  INLINE l_ivector operator +(const l_ivector_slice &sl1, const l_rvector_slice &sl2)
3064 #if(CXSC_INDEX_CHECK)
3065  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3066 #else
3067  throw();
3068 #endif
3069 
3071  INLINE l_ivector & operator +=(l_ivector &rv1, const l_rvector &rv2)
3072 #if(CXSC_INDEX_CHECK)
3073  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3074 #else
3075  throw();
3076 #endif
3077  INLINE l_ivector &operator +=(l_ivector &rv, const l_rvector_slice &sl)
3079 #if(CXSC_INDEX_CHECK)
3080  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3081 #else
3082  throw();
3083 #endif
3084 
3086  INLINE l_ivector operator -(const l_rvector &rv1, const l_ivector &rv2)
3087 #if(CXSC_INDEX_CHECK)
3088  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3089 #else
3090  throw();
3091 #endif
3092  INLINE l_ivector operator -(const l_rvector &rv, const l_ivector_slice &sl)
3094 #if(CXSC_INDEX_CHECK)
3095  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3096 #else
3097  throw();
3098 #endif
3099  INLINE l_ivector operator -(const l_rvector_slice &sl, const l_ivector &rv)
3101 #if(CXSC_INDEX_CHECK)
3102  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3103 #else
3104  throw();
3105 #endif
3106  INLINE l_ivector operator -(const l_rvector_slice &sl1, const l_ivector_slice &sl2)
3108 #if(CXSC_INDEX_CHECK)
3109  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3110 #else
3111  throw();
3112 #endif
3113 
3115  INLINE l_ivector operator -(const l_ivector &rv1, const l_rvector &rv2)
3116 #if(CXSC_INDEX_CHECK)
3117  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3118 #else
3119  throw();
3120 #endif
3121  INLINE l_ivector operator -(const l_ivector &rv, const l_rvector_slice &sl)
3123 #if(CXSC_INDEX_CHECK)
3124  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3125 #else
3126  throw();
3127 #endif
3128  INLINE l_ivector operator -(const l_ivector_slice &sl, const l_rvector &rv)
3130 #if(CXSC_INDEX_CHECK)
3131  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3132 #else
3133  throw();
3134 #endif
3135  INLINE l_ivector operator -(const l_ivector_slice &sl1, const l_rvector_slice &sl2)
3137 #if(CXSC_INDEX_CHECK)
3138  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3139 #else
3140  throw();
3141 #endif
3142 
3144  INLINE l_ivector & operator -=(l_ivector &rv1, const l_rvector &rv2)
3145 #if(CXSC_INDEX_CHECK)
3146  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3147 #else
3148  throw();
3149 #endif
3150  INLINE l_ivector &operator -=(l_ivector &rv, const l_rvector_slice &sl)
3152 #if(CXSC_INDEX_CHECK)
3153  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3154 #else
3155  throw();
3156 #endif
3157 
3159  INLINE l_ivector operator |(const l_rvector &rv1, const l_ivector &rv2)
3160 #if(CXSC_INDEX_CHECK)
3161  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3162 #else
3163  throw();
3164 #endif
3165  INLINE l_ivector operator |(const l_rvector &rv, const l_ivector_slice &sl)
3167 #if(CXSC_INDEX_CHECK)
3168  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3169 #else
3170  throw();
3171 #endif
3172  INLINE l_ivector operator |(const l_rvector_slice &sl, const l_ivector &rv)
3174 #if(CXSC_INDEX_CHECK)
3175  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3176 #else
3177  throw();
3178 #endif
3179  INLINE l_ivector operator |(const l_rvector_slice &sl1, const l_ivector_slice &sl2)
3181 #if(CXSC_INDEX_CHECK)
3182  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3183 #else
3184  throw();
3185 #endif
3186 
3188  INLINE l_ivector operator |(const l_ivector &rv1, const l_rvector &rv2)
3189 #if(CXSC_INDEX_CHECK)
3190  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3191 #else
3192  throw();
3193 #endif
3194  INLINE l_ivector operator |(const l_ivector &rv, const l_rvector_slice &sl)
3196 #if(CXSC_INDEX_CHECK)
3197  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3198 #else
3199  throw();
3200 #endif
3201  INLINE l_ivector operator |(const l_ivector_slice &sl, const l_rvector &rv)
3203 #if(CXSC_INDEX_CHECK)
3204  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3205 #else
3206  throw();
3207 #endif
3208  INLINE l_ivector operator |(const l_ivector_slice &sl1, const l_rvector_slice &sl2)
3210 #if(CXSC_INDEX_CHECK)
3211  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3212 #else
3213  throw();
3214 #endif
3215 
3217  INLINE l_ivector & operator |=(l_ivector &rv1, const l_rvector &rv2)
3218 #if(CXSC_INDEX_CHECK)
3219  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3220 #else
3221  throw();
3222 #endif
3223  INLINE l_ivector &operator |=(l_ivector &rv, const l_rvector_slice &sl)
3225 #if(CXSC_INDEX_CHECK)
3226  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3227 #else
3228  throw();
3229 #endif
3230 
3232  INLINE l_ivector operator &(const l_rvector &rv1, const l_ivector &rv2)
3233 #if(CXSC_INDEX_CHECK)
3234  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3235 #else
3236  throw();
3237 #endif
3238  INLINE l_ivector operator &(const l_rvector &rv, const l_ivector_slice &sl)
3240 #if(CXSC_INDEX_CHECK)
3241  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3242 #else
3243  throw();
3244 #endif
3245  INLINE l_ivector operator &(const l_rvector_slice &sl, const l_ivector &rv)
3247 #if(CXSC_INDEX_CHECK)
3248  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3249 #else
3250  throw();
3251 #endif
3252  INLINE l_ivector operator &(const l_rvector_slice &sl1, const l_ivector_slice &sl2)
3254 #if(CXSC_INDEX_CHECK)
3255  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3256 #else
3257  throw();
3258 #endif
3259 
3261  INLINE l_ivector operator &(const l_ivector &rv1, const l_rvector &rv2)
3262 #if(CXSC_INDEX_CHECK)
3263  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3264 #else
3265  throw();
3266 #endif
3267  INLINE l_ivector operator &(const l_ivector &rv, const l_rvector_slice &sl)
3269 #if(CXSC_INDEX_CHECK)
3270  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3271 #else
3272  throw();
3273 #endif
3274  INLINE l_ivector operator &(const l_ivector_slice &sl, const l_rvector &rv)
3276 #if(CXSC_INDEX_CHECK)
3277  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3278 #else
3279  throw();
3280 #endif
3281  INLINE l_ivector operator &(const l_ivector_slice &sl1, const l_rvector_slice &sl2)
3283 #if(CXSC_INDEX_CHECK)
3284  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3285 #else
3286  throw();
3287 #endif
3288 
3290  INLINE l_ivector & operator &=(l_ivector &rv1, const l_rvector &rv2)
3291 #if(CXSC_INDEX_CHECK)
3292  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3293 #else
3294  throw();
3295 #endif
3296  INLINE l_ivector &operator &=(l_ivector &rv, const l_rvector_slice &sl)
3298 #if(CXSC_INDEX_CHECK)
3299  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3300 #else
3301  throw();
3302 #endif
3303 
3304 //-------------------------------- l_interval / interval --------------------------------
3305 
3307  INLINE void accumulate(idotprecision &dp, const ivector & rv1, const l_ivector &rv2)
3308 #if(CXSC_INDEX_CHECK)
3309  throw(OP_WITH_WRONG_DIM);
3310 #else
3311  throw();
3312 #endif
3313  INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const ivector &rv2)
3315 #if(CXSC_INDEX_CHECK)
3316  throw(OP_WITH_WRONG_DIM);
3317 #else
3318  throw();
3319 #endif
3320  INLINE void accumulate(idotprecision &dp, const ivector_slice & sl, const l_ivector &rv)
3322 #if(CXSC_INDEX_CHECK)
3323  throw(OP_WITH_WRONG_DIM);
3324 #else
3325  throw();
3326 #endif
3327  INLINE void accumulate(idotprecision &dp,const l_ivector_slice &sl,const ivector &rv)
3329 #if(CXSC_INDEX_CHECK)
3330  throw(OP_WITH_WRONG_DIM);
3331 #else
3332  throw();
3333 #endif
3334  INLINE void accumulate(idotprecision &dp, const ivector &rv, const l_ivector_slice &sl)
3336 #if(CXSC_INDEX_CHECK)
3337  throw(OP_WITH_WRONG_DIM);
3338 #else
3339  throw();
3340 #endif
3341  INLINE void accumulate(idotprecision &dp, const ivector & rv1, const l_imatrix_subv &rv2)
3343 #if(CXSC_INDEX_CHECK)
3344  throw(OP_WITH_WRONG_DIM);
3345 #else
3346  throw();
3347 #endif
3348  INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const imatrix_subv &rv2)
3350 #if(CXSC_INDEX_CHECK)
3351  throw(OP_WITH_WRONG_DIM);
3352 #else
3353  throw();
3354 #endif
3355  INLINE void accumulate(idotprecision &dp,const l_ivector &rv,const ivector_slice &sl)
3357 #if(CXSC_INDEX_CHECK)
3358  throw(OP_WITH_WRONG_DIM);
3359 #else
3360  throw();
3361 #endif
3362  INLINE void accumulate(idotprecision &dp, const imatrix_subv & rv1, const l_ivector &rv2)
3364 #if(CXSC_INDEX_CHECK)
3365  throw(OP_WITH_WRONG_DIM);
3366 #else
3367  throw();
3368 #endif
3369  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const ivector &rv2)
3371 #if(CXSC_INDEX_CHECK)
3372  throw(OP_WITH_WRONG_DIM);
3373 #else
3374  throw();
3375 #endif
3376  INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl1, const ivector_slice &sl2)
3378 #if(CXSC_INDEX_CHECK)
3379  throw(OP_WITH_WRONG_DIM);
3380 #else
3381  throw();
3382 #endif
3383  INLINE void accumulate(idotprecision &dp, const ivector_slice & sl1, const l_ivector_slice &sl2)
3385 #if(CXSC_INDEX_CHECK)
3386  throw(OP_WITH_WRONG_DIM);
3387 #else
3388  throw();
3389 #endif
3390 
3392  INLINE l_interval operator *(const ivector & rv1, const l_ivector &rv2)
3393 #if(CXSC_INDEX_CHECK)
3394  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3395 #else
3396  throw();
3397 #endif
3398  INLINE l_interval operator *(const ivector_slice &sl, const l_ivector &rv)
3400 #if(CXSC_INDEX_CHECK)
3401  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3402 #else
3403  throw();
3404 #endif
3405  INLINE l_interval operator *(const ivector &rv, const l_ivector_slice &sl)
3407 #if(CXSC_INDEX_CHECK)
3408  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3409 #else
3410  throw();
3411 #endif
3412  INLINE l_interval operator *(const ivector_slice & sl1, const l_ivector_slice &sl2)
3414 #if(CXSC_INDEX_CHECK)
3415  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3416 #else
3417  throw();
3418 #endif
3419 
3421  INLINE l_interval operator *(const l_ivector & rv1, const ivector &rv2)
3422 #if(CXSC_INDEX_CHECK)
3423  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3424 #else
3425  throw();
3426 #endif
3427  INLINE l_interval operator *(const l_ivector_slice &sl, const ivector &rv)
3429 #if(CXSC_INDEX_CHECK)
3430  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3431 #else
3432  throw();
3433 #endif
3434  INLINE l_interval operator *(const l_ivector &rv, const ivector_slice &sl)
3436 #if(CXSC_INDEX_CHECK)
3437  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3438 #else
3439  throw();
3440 #endif
3441  INLINE l_interval operator *(const l_ivector_slice & sl1, const ivector_slice &sl2)
3443 #if(CXSC_INDEX_CHECK)
3444  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3445 #else
3446  throw();
3447 #endif
3448 
3450  INLINE l_ivector operator +(const ivector &rv1, const l_ivector &rv2)
3451 #if(CXSC_INDEX_CHECK)
3452  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3453 #else
3454  throw();
3455 #endif
3456  INLINE l_ivector operator +(const ivector &rv, const l_ivector_slice &sl)
3458 #if(CXSC_INDEX_CHECK)
3459  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3460 #else
3461  throw();
3462 #endif
3463  INLINE l_ivector operator +(const ivector_slice &sl, const l_ivector &rv)
3465 #if(CXSC_INDEX_CHECK)
3466  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3467 #else
3468  throw();
3469 #endif
3470  INLINE l_ivector operator +(const ivector_slice &sl1, const l_ivector_slice &sl2)
3472 #if(CXSC_INDEX_CHECK)
3473  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3474 #else
3475  throw();
3476 #endif
3477 
3479  INLINE l_ivector operator +(const l_ivector &rv1, const ivector &rv2)
3480 #if(CXSC_INDEX_CHECK)
3481  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3482 #else
3483  throw();
3484 #endif
3485  INLINE l_ivector operator +(const l_ivector &rv, const ivector_slice &sl)
3487 #if(CXSC_INDEX_CHECK)
3488  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3489 #else
3490  throw();
3491 #endif
3492  INLINE l_ivector operator +(const l_ivector_slice &sl, const ivector &rv)
3494 #if(CXSC_INDEX_CHECK)
3495  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3496 #else
3497  throw();
3498 #endif
3499  INLINE l_ivector operator +(const l_ivector_slice &sl1, const ivector_slice &sl2)
3501 #if(CXSC_INDEX_CHECK)
3502  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3503 #else
3504  throw();
3505 #endif
3506 
3508  INLINE l_ivector & operator +=(l_ivector &rv1, const ivector &rv2)
3509 #if(CXSC_INDEX_CHECK)
3510  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3511 #else
3512  throw();
3513 #endif
3514  INLINE l_ivector &operator +=(l_ivector &rv, const ivector_slice &sl)
3516 #if(CXSC_INDEX_CHECK)
3517  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3518 #else
3519  throw();
3520 #endif
3521 
3523  INLINE l_ivector operator -(const ivector &rv1, const l_ivector &rv2)
3524 #if(CXSC_INDEX_CHECK)
3525  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3526 #else
3527  throw();
3528 #endif
3529  INLINE l_ivector operator -(const ivector &rv, const l_ivector_slice &sl)
3531 #if(CXSC_INDEX_CHECK)
3532  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3533 #else
3534  throw();
3535 #endif
3536  INLINE l_ivector operator -(const ivector_slice &sl, const l_ivector &rv)
3538 #if(CXSC_INDEX_CHECK)
3539  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3540 #else
3541  throw();
3542 #endif
3543  INLINE l_ivector operator -(const ivector_slice &sl1, const l_ivector_slice &sl2)
3545 #if(CXSC_INDEX_CHECK)
3546  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3547 #else
3548  throw();
3549 #endif
3550 
3552  INLINE l_ivector operator -(const l_ivector &rv1, const ivector &rv2)
3553 #if(CXSC_INDEX_CHECK)
3554  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3555 #else
3556  throw();
3557 #endif
3558  INLINE l_ivector operator -(const l_ivector &rv, const ivector_slice &sl)
3560 #if(CXSC_INDEX_CHECK)
3561  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3562 #else
3563  throw();
3564 #endif
3565  INLINE l_ivector operator -(const l_ivector_slice &sl, const ivector &rv)
3567 #if(CXSC_INDEX_CHECK)
3568  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3569 #else
3570  throw();
3571 #endif
3572  INLINE l_ivector operator -(const l_ivector_slice &sl1, const ivector_slice &sl2)
3574 #if(CXSC_INDEX_CHECK)
3575  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3576 #else
3577  throw();
3578 #endif
3579 
3581  INLINE l_ivector & operator -=(l_ivector &rv1, const ivector &rv2)
3582 #if(CXSC_INDEX_CHECK)
3583  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3584 #else
3585  throw();
3586 #endif
3587  INLINE l_ivector &operator -=(l_ivector &rv, const ivector_slice &sl)
3589 #if(CXSC_INDEX_CHECK)
3590  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3591 #else
3592  throw();
3593 #endif
3594 
3596  INLINE l_ivector operator |(const ivector &rv1, const l_ivector &rv2)
3597 #if(CXSC_INDEX_CHECK)
3598  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3599 #else
3600  throw();
3601 #endif
3602  INLINE l_ivector operator |(const ivector &rv, const l_ivector_slice &sl)
3604 #if(CXSC_INDEX_CHECK)
3605  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3606 #else
3607  throw();
3608 #endif
3609  INLINE l_ivector operator |(const ivector_slice &sl, const l_ivector &rv)
3611 #if(CXSC_INDEX_CHECK)
3612  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3613 #else
3614  throw();
3615 #endif
3616  INLINE l_ivector operator |(const ivector_slice &sl1, const l_ivector_slice &sl2)
3618 #if(CXSC_INDEX_CHECK)
3619  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3620 #else
3621  throw();
3622 #endif
3623 
3625  INLINE l_ivector operator |(const l_ivector &rv1, const ivector &rv2)
3626 #if(CXSC_INDEX_CHECK)
3627  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3628 #else
3629  throw();
3630 #endif
3631  INLINE l_ivector operator |(const l_ivector &rv, const ivector_slice &sl)
3633 #if(CXSC_INDEX_CHECK)
3634  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3635 #else
3636  throw();
3637 #endif
3638  INLINE l_ivector operator |(const l_ivector_slice &sl, const ivector &rv)
3640 #if(CXSC_INDEX_CHECK)
3641  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3642 #else
3643  throw();
3644 #endif
3645  INLINE l_ivector operator |(const l_ivector_slice &sl1, const ivector_slice &sl2)
3647 #if(CXSC_INDEX_CHECK)
3648  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3649 #else
3650  throw();
3651 #endif
3652 
3654  INLINE l_ivector & operator |=(l_ivector &rv1, const ivector &rv2)
3655 #if(CXSC_INDEX_CHECK)
3656  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3657 #else
3658  throw();
3659 #endif
3660  INLINE l_ivector &operator |=(l_ivector &rv, const ivector_slice &sl)
3662 #if(CXSC_INDEX_CHECK)
3663  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3664 #else
3665  throw();
3666 #endif
3667 
3669  INLINE l_ivector operator &(const ivector &rv1, const l_ivector &rv2)
3670 #if(CXSC_INDEX_CHECK)
3671  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3672 #else
3673  throw();
3674 #endif
3675  INLINE l_ivector operator &(const ivector &rv, const l_ivector_slice &sl)
3677 #if(CXSC_INDEX_CHECK)
3678  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3679 #else
3680  throw();
3681 #endif
3682  INLINE l_ivector operator &(const ivector_slice &sl, const l_ivector &rv)
3684 #if(CXSC_INDEX_CHECK)
3685  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3686 #else
3687  throw();
3688 #endif
3689  INLINE l_ivector operator &(const ivector_slice &sl1, const l_ivector_slice &sl2)
3691 #if(CXSC_INDEX_CHECK)
3692  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3693 #else
3694  throw();
3695 #endif
3696 
3698  INLINE l_ivector operator &(const l_ivector &rv1, const ivector &rv2)
3699 #if(CXSC_INDEX_CHECK)
3700  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3701 #else
3702  throw();
3703 #endif
3704  INLINE l_ivector operator &(const l_ivector &rv, const ivector_slice &sl)
3706 #if(CXSC_INDEX_CHECK)
3707  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3708 #else
3709  throw();
3710 #endif
3711  INLINE l_ivector operator &(const l_ivector_slice &sl, const ivector &rv)
3713 #if(CXSC_INDEX_CHECK)
3714  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3715 #else
3716  throw();
3717 #endif
3718  INLINE l_ivector operator &(const l_ivector_slice &sl1, const ivector_slice &sl2)
3720 #if(CXSC_INDEX_CHECK)
3721  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3722 #else
3723  throw();
3724 #endif
3725 
3727  INLINE l_ivector & operator &=(l_ivector &rv1, const ivector &rv2)
3728 #if(CXSC_INDEX_CHECK)
3729  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3730 #else
3731  throw();
3732 #endif
3733  INLINE l_ivector &operator &=(l_ivector &rv, const ivector_slice &sl)
3735 #if(CXSC_INDEX_CHECK)
3736  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3737 #else
3738  throw();
3739 #endif
3740 
3741 //------------- real x l_real ------------------------
3743  INLINE l_ivector operator |(const rvector &rv1, const l_rvector &rv2)
3744 #if(CXSC_INDEX_CHECK)
3745  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3746 #else
3747  throw();
3748 #endif
3749  INLINE l_ivector operator |(const l_rvector &rv1, const rvector &rv2)
3751 #if(CXSC_INDEX_CHECK)
3752  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3753 #else
3754  throw();
3755 #endif
3756  INLINE l_ivector operator |(const l_rvector &rv, const rvector_slice &sl)
3758 #if(CXSC_INDEX_CHECK)
3759  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3760 #else
3761  throw();
3762 #endif
3763  INLINE l_ivector operator |(const rvector_slice &sl,const l_rvector &rv)
3765 #if(CXSC_INDEX_CHECK)
3766  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3767 #else
3768  throw();
3769 #endif
3770  INLINE l_ivector operator |(const l_rvector_slice &sl, const rvector &rv)
3772 #if(CXSC_INDEX_CHECK)
3773  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3774 #else
3775  throw();
3776 #endif
3777  INLINE l_ivector operator |(const rvector &rv,const l_rvector_slice &sl)
3779 #if(CXSC_INDEX_CHECK)
3780  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3781 #else
3782  throw();
3783 #endif
3784  INLINE l_ivector operator |(const l_rvector_slice &sl1, const rvector_slice &sl2)
3786 #if(CXSC_INDEX_CHECK)
3787  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3788 #else
3789  throw();
3790 #endif
3791  INLINE l_ivector operator |(const rvector_slice &sl1, const l_rvector_slice &sl2)
3793 #if(CXSC_INDEX_CHECK)
3794  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3795 #else
3796  throw();
3797 #endif
3798 
3799 //------------- l_real x l_real ------------------------
3801  INLINE l_ivector operator |(const l_rvector &rv1, const l_rvector &rv2)
3802 #if(CXSC_INDEX_CHECK)
3803  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3804 #else
3805  throw();
3806 #endif
3807  INLINE l_ivector operator |(const l_rvector_slice &sl, const l_rvector &rv)
3809 #if(CXSC_INDEX_CHECK)
3810  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3811 #else
3812  throw();
3813 #endif
3814  INLINE l_ivector operator |(const l_rvector &rv,const l_rvector_slice &sl)
3816 #if(CXSC_INDEX_CHECK)
3817  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3818 #else
3819  throw();
3820 #endif
3821  INLINE l_ivector operator |(const l_rvector_slice &sl1, const l_rvector_slice &sl2)
3823 #if(CXSC_INDEX_CHECK)
3824  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3825 #else
3826  throw();
3827 #endif
3828 
3829 //-------------------------------- interval / l_real --------------------------------
3830 
3831  // multiplication in lrvecivec.hpp
3832 
3834  INLINE l_ivector operator +(const l_rvector &rv1, const ivector &rv2)
3835 #if(CXSC_INDEX_CHECK)
3836  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3837 #else
3838  throw();
3839 #endif
3840  INLINE l_ivector operator +(const l_rvector &rv, const ivector_slice &sl)
3842 #if(CXSC_INDEX_CHECK)
3843  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3844 #else
3845  throw();
3846 #endif
3847  INLINE l_ivector operator +(const l_rvector_slice &sl, const ivector &rv)
3849 #if(CXSC_INDEX_CHECK)
3850  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3851 #else
3852  throw();
3853 #endif
3854  INLINE l_ivector operator +(const l_rvector_slice &sl1, const ivector_slice &sl2)
3856 #if(CXSC_INDEX_CHECK)
3857  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3858 #else
3859  throw();
3860 #endif
3861 
3863  INLINE l_ivector operator +(const ivector &rv1, const l_rvector &rv2)
3864 #if(CXSC_INDEX_CHECK)
3865  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3866 #else
3867  throw();
3868 #endif
3869  INLINE l_ivector operator +(const ivector &rv, const l_rvector_slice &sl)
3871 #if(CXSC_INDEX_CHECK)
3872  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3873 #else
3874  throw();
3875 #endif
3876  INLINE l_ivector operator +(const ivector_slice &sl, const l_rvector &rv)
3878 #if(CXSC_INDEX_CHECK)
3879  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3880 #else
3881  throw();
3882 #endif
3883  INLINE l_ivector operator +(const ivector_slice &sl1, const l_rvector_slice &sl2)
3885 #if(CXSC_INDEX_CHECK)
3886  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3887 #else
3888  throw();
3889 #endif
3890 
3891 
3893  INLINE l_ivector operator -(const l_rvector &rv1, const ivector &rv2)
3894 #if(CXSC_INDEX_CHECK)
3895  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3896 #else
3897  throw();
3898 #endif
3899  INLINE l_ivector operator -(const l_rvector &rv, const ivector_slice &sl)
3901 #if(CXSC_INDEX_CHECK)
3902  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3903 #else
3904  throw();
3905 #endif
3906  INLINE l_ivector operator -(const l_rvector_slice &sl, const ivector &rv)
3908 #if(CXSC_INDEX_CHECK)
3909  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3910 #else
3911  throw();
3912 #endif
3913  INLINE l_ivector operator -(const l_rvector_slice &sl1, const ivector_slice &sl2)
3915 #if(CXSC_INDEX_CHECK)
3916  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3917 #else
3918  throw();
3919 #endif
3920 
3922  INLINE l_ivector operator -(const ivector &rv1, const l_rvector &rv2)
3923 #if(CXSC_INDEX_CHECK)
3924  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3925 #else
3926  throw();
3927 #endif
3928  INLINE l_ivector operator -(const ivector &rv, const l_rvector_slice &sl)
3930 #if(CXSC_INDEX_CHECK)
3931  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3932 #else
3933  throw();
3934 #endif
3935  INLINE l_ivector operator -(const ivector_slice &sl, const l_rvector &rv)
3937 #if(CXSC_INDEX_CHECK)
3938  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3939 #else
3940  throw();
3941 #endif
3942  INLINE l_ivector operator -(const ivector_slice &sl1, const l_rvector_slice &sl2)
3944 #if(CXSC_INDEX_CHECK)
3945  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3946 #else
3947  throw();
3948 #endif
3949 
3950 
3952  INLINE l_ivector operator |(const l_rvector &rv1, const ivector &rv2)
3953 #if(CXSC_INDEX_CHECK)
3954  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3955 #else
3956  throw();
3957 #endif
3958  INLINE l_ivector operator |(const l_rvector &rv, const ivector_slice &sl)
3960 #if(CXSC_INDEX_CHECK)
3961  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3962 #else
3963  throw();
3964 #endif
3965  INLINE l_ivector operator |(const l_rvector_slice &sl, const ivector &rv)
3967 #if(CXSC_INDEX_CHECK)
3968  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3969 #else
3970  throw();
3971 #endif
3972  INLINE l_ivector operator |(const l_rvector_slice &sl1, const ivector_slice &sl2)
3974 #if(CXSC_INDEX_CHECK)
3975  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3976 #else
3977  throw();
3978 #endif
3979 
3981  INLINE l_ivector operator |(const ivector &rv1, const l_rvector &rv2)
3982 #if(CXSC_INDEX_CHECK)
3983  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3984 #else
3985  throw();
3986 #endif
3987  INLINE l_ivector operator |(const ivector &rv, const l_rvector_slice &sl)
3989 #if(CXSC_INDEX_CHECK)
3990  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3991 #else
3992  throw();
3993 #endif
3994  INLINE l_ivector operator |(const ivector_slice &sl, const l_rvector &rv)
3996 #if(CXSC_INDEX_CHECK)
3997  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
3998 #else
3999  throw();
4000 #endif
4001  INLINE l_ivector operator |(const ivector_slice &sl1, const l_rvector_slice &sl2)
4003 #if(CXSC_INDEX_CHECK)
4004  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
4005 #else
4006  throw();
4007 #endif
4008 
4010  INLINE l_ivector operator &(const l_rvector &rv1, const ivector &rv2)
4011 #if(CXSC_INDEX_CHECK)
4012  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
4013 #else
4014  throw();
4015 #endif
4016  INLINE l_ivector operator &(const l_rvector &rv, const ivector_slice &sl)
4018 #if(CXSC_INDEX_CHECK)
4019  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
4020 #else
4021  throw();
4022 #endif
4023  INLINE l_ivector operator &(const l_rvector_slice &sl, const ivector &rv)
4025 #if(CXSC_INDEX_CHECK)
4026  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
4027 #else
4028  throw();
4029 #endif
4030  INLINE l_ivector operator &(const l_rvector_slice &sl1, const ivector_slice &sl2)
4032 #if(CXSC_INDEX_CHECK)
4033  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
4034 #else
4035  throw();
4036 #endif
4037 
4039  INLINE l_ivector operator &(const ivector &rv1, const l_rvector &rv2)
4040 #if(CXSC_INDEX_CHECK)
4041  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
4042 #else
4043  throw();
4044 #endif
4045  INLINE l_ivector operator &(const ivector &rv, const l_rvector_slice &sl)
4047 #if(CXSC_INDEX_CHECK)
4048  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
4049 #else
4050  throw();
4051 #endif
4052  INLINE l_ivector operator &(const ivector_slice &sl, const l_rvector &rv)
4054 #if(CXSC_INDEX_CHECK)
4055  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
4056 #else
4057  throw();
4058 #endif
4059  INLINE l_ivector operator &(const ivector_slice &sl1, const l_rvector_slice &sl2)
4061 #if(CXSC_INDEX_CHECK)
4062  throw(ERROR__OP_WITH_WRONG_DIM<l_ivector>);
4063 #else
4064  throw();
4065 #endif
4066 
4067 } // namespace cxsc
4068 
4069 #ifdef _CXSC_INCL_INL
4070 #include "vector.inl"
4071 #include "l_ivector.inl"
4072 #endif
4073 
4074 #ifdef _CXSC_RMATRIX_HPP_INCLUDED
4075 # ifdef _CXSC_INCL_INL
4076 # include "livecrmat.inl"
4077 # else
4078 # include "livecrmat.hpp"
4079 # endif
4080 #endif
4081 
4082 #ifdef _CXSC_LRMATRIX_HPP_INCLUDED
4083 # ifdef _CXSC_INCL_INL
4084 # include "liveclrmat.inl"
4085 # else
4086 # include "liveclrmat.hpp"
4087 # endif
4088 #endif
4089 
4090 #ifdef _CXSC_IMATRIX_HPP_INCLUDED
4091 # ifdef _CXSC_INCL_INL
4092 # include "livecimat.inl"
4093 # else
4094 # include "livecimat.hpp"
4095 # endif
4096 #endif
4097 
4098 
4099 #endif
4100 
cxsc::l_ivector_slice::l_ivector_slice
l_ivector_slice(const l_ivector_slice &a)
Constructor of class l_ivector_slice.
Definition: l_ivector.hpp:1320
cxsc::l_rmatrix_slice
The Multiple-Precision Data Type l_rmatrix_slice.
Definition: l_rmatrix.hpp:1000
cxsc::l_ivector::operator()
l_ivector & operator()()
Operator for accessing the whole vector.
Definition: l_ivector.hpp:842
cxsc::imatrix_slice
The Data Type imatrix_slice.
Definition: imatrix.hpp:1442
cxsc::l_ivector_slice::operator[]
l_interval & operator[](const int &i) const
Operator for accessing the single elements of the vector.
Definition: l_ivector.inl:154
cxsc::mid
cvector mid(const cimatrix_subv &mv)
Returns the middle of the matrix.
Definition: cimatrix.inl:739
cxsc::l_ivector::Ub
friend int Ub(const l_ivector &rv)
Returns the upper bound of the vector.
Definition: l_ivector.hpp:827
cxsc::operator*=
cimatrix & operator*=(cimatrix &m, const cinterval &c)
Implementation of multiplication and allocation operation.
Definition: cimatrix.inl:1605
cxsc::l_rmatrix_subv
The Multiple-Precision Data Type l_rmatrix_subv.
Definition: l_rmatrix.hpp:47
cxsc::l_ivector_slice::operator|=
l_ivector_slice & operator|=(const l_ivector &rv)
Allocates the convex hull of the arguments to the first argument.
Definition: l_ivector.inl:813
cxsc::imatrix_subv
The Data Type imatrix_subv.
Definition: imatrix.hpp:56
cxsc::interval
The Scalar Type interval.
Definition: interval.hpp:55
cxsc::l_ivector_slice::l_ivector_slice
l_ivector_slice(l_ivector_slice &a, const int &lb, const int &ub)
Constructor of class l_ivector_slice.
Definition: l_ivector.hpp:1317
cxsc::rmatrix
The Data Type rmatrix.
Definition: rmatrix.hpp:471
cxsc::l_ivector::Lb
friend int Lb(const l_ivector &rv)
Returns the lower bound of the vector.
Definition: l_ivector.hpp:825
cxsc::diam
cvector diam(const cimatrix_subv &mv)
Returns the diameter of the matrix.
Definition: cimatrix.inl:738
cxsc::l_rmatrix
The Multiple-Precision Data Type l_rmatrix.
Definition: l_rmatrix.hpp:416
cxsc::rvector
The Data Type rvector.
Definition: rvector.hpp:58
cxsc::idotprecision
The Data Type idotprecision.
Definition: idot.hpp:48
cxsc::l_ivector::operator[]
l_interval & operator[](const int &i) const
Operator for accessing the single elements of the vector.
Definition: l_ivector.inl:141
cxsc::l_ivector_slice::operator=
l_ivector_slice & operator=(const l_ivector_slice &sl)
Implementation of standard assigning operator.
Definition: l_ivector.inl:314
cxsc::l_ivector_slice::operator+=
l_ivector_slice & operator+=(const l_ivector &rv)
Implementation of addition and allocation operation.
Definition: l_ivector.inl:697
cxsc::l_imatrix
The Multiple-Precision Data Type l_imatrix.
Definition: l_imatrix.hpp:726
cxsc::ivector_slice
The Data Type ivector_slice.
Definition: ivector.hpp:963
cxsc::rvector_slice
The Data Type rvector_slice.
Definition: rvector.hpp:1064
cxsc::SetUncheckedInf
cimatrix_subv & SetUncheckedInf(cimatrix_subv &iv, const complex &r)
Returns the matrix with the new unchecked given infimum value.
Definition: cimatrix.inl:890
cxsc::abs
ivector abs(const cimatrix_subv &mv)
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737
cxsc::imatrix
The Data Type imatrix.
Definition: imatrix.hpp:660
cxsc::l_ivector::VecLen
friend int VecLen(const l_ivector &rv)
Returns the dimension of the vector.
Definition: l_ivector.hpp:829
cxsc::operator*
civector operator*(const cimatrix_subv &rv, const cinterval &s)
Implementation of multiplication operation.
Definition: cimatrix.inl:731
cxsc::l_imatrix_slice
The Multiple-Precision Data Type l_imatrix_slice.
Definition: l_imatrix.hpp:1280
cxsc::l_ivector::SetLb
friend l_ivector & SetLb(l_ivector &rv, const int &l)
Sets the lower bound of the vector.
Definition: l_ivector.hpp:831
cxsc::operator/=
cimatrix & operator/=(cimatrix &m, const cinterval &c)
Implementation of division and allocation operation.
Definition: cimatrix.inl:1623
cxsc::l_interval
The Multiple-Precision Data Type l_interval.
Definition: l_interval.hpp:72
cxsc::ivector
The Data Type ivector.
Definition: ivector.hpp:55
cxsc::l_ivector_slice::operator/=
l_ivector_slice & operator/=(const l_interval &r)
Implementation of division and allocation operation.
Definition: l_ivector.inl:502
cxsc::l_ivector_slice::operator&=
l_ivector_slice & operator&=(const l_ivector &rv)
Allocates the intersection of the arguments to the first argument.
Definition: l_ivector.inl:870
cxsc::l_rvector_slice
The Multiple-Precision Data Type l_rvector_slice.
Definition: l_rvector.hpp:745
cxsc::l_ivector::l_ivector
l_ivector()
Constructor of class l_ivector.
Definition: l_ivector.inl:31
cxsc::rmatrix_subv
The Data Type rmatrix_subv.
Definition: rmatrix.hpp:54
cxsc::l_ivector_slice::VecLen
friend int VecLen(const l_ivector_slice &sl)
Returns the dimension of the vector.
Definition: l_ivector.hpp:1470
cxsc::l_ivector_slice::Lb
friend int Lb(const l_ivector_slice &sl)
Returns the lower bound of the vector.
Definition: l_ivector.hpp:1466
cxsc
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
cxsc::operator+=
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc)
Implementation of standard algebraic addition and allocation operation.
Definition: cdot.inl:251
cxsc::l_real
The Multiple-Precision Data Type l_real.
Definition: l_real.hpp:78
cxsc::rmatrix_slice
The Data Type rmatrix_slice.
Definition: rmatrix.hpp:1443
cxsc::operator/
civector operator/(const cimatrix_subv &rv, const cinterval &s)
Implementation of division operation.
Definition: cimatrix.inl:730
cxsc::l_rvector
The Multiple-Precision Data Type l_rvector.
Definition: l_rvector.hpp:54
cxsc::l_ivector_slice
The Multiple-Precision Data Type l_ivector_slice.
Definition: l_ivector.hpp:871
cxsc::_l_ivector
l_ivector _l_ivector(const l_interval &r)
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC.
Definition: l_ivector.inl:252
cxsc::l_ivector
The Multiple-Precision Data Type l_ivector.
Definition: l_ivector.hpp:55
cxsc::l_ivector::SetUb
friend l_ivector & SetUb(l_ivector &rv, const int &u)
Sets the upper bound of the vector.
Definition: l_ivector.hpp:833
cxsc::l_ivector::operator=
l_ivector & operator=(const l_ivector &rv)
Implementation of standard assigning operator.
Definition: l_ivector.inl:311
cxsc::l_ivector_slice::operator()
l_ivector_slice & operator()()
Operator for accessing the whole vector.
Definition: l_ivector.hpp:1479
cxsc::l_ivector_slice::operator*=
l_ivector_slice & operator*=(const l_interval &r)
Implementation of multiplication and allocation operation.
Definition: l_ivector.inl:497
cxsc::l_imatrix_subv
The Multiple-Precision Data Type l_imatrix_subv.
Definition: l_imatrix.hpp:47
cxsc::l_ivector_slice::l_ivector_slice
l_ivector_slice(l_ivector &a, const int &lb, const int &ub)
Constructor of class l_ivector_slice.
Definition: l_ivector.hpp:1315
cxsc::l_ivector_slice::operator-=
l_ivector_slice & operator-=(const l_ivector &rv)
Implementation of subtraction and allocation operation.
Definition: l_ivector.inl:756
cxsc::l_ivector_slice::Ub
friend int Ub(const l_ivector_slice &sl)
Returns the upper bound of the vector.
Definition: l_ivector.hpp:1468
cxsc::l_interval::l_interval
l_interval()
Constructor of class l_interval.
Definition: l_interval.inl:45
cxsc::Resize
void Resize(cimatrix &A)
Resizes the matrix.
Definition: cimatrix.inl:1211
cxsc::real
The Scalar Type real.
Definition: real.hpp:114