C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
l_rvector.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_rvector.hpp,v 1.19 2014/01/30 17:23:46 cxsc Exp $ */
25 
26 #ifndef _CXSC_LRVECTOR_HPP_INCLUDED
27 #define _CXSC_LRVECTOR_HPP_INCLUDED
28 
29 #include "xscclass.hpp"
30 #include "except.hpp"
31 #include "dot.hpp"
32 #include "idot.hpp"
33 #include "l_real.hpp" // used for declaration of Inf, Sup,...
34 //#include "cxscmatr.hpp"
35 #include "rvector.hpp"
36 #include "vector.hpp"
37 
38 
39 #include <iostream>
40 
41 //#include "matrix.hpp" // hat hier eigentlich nichts zu suchen, sonst aber Internal Compiler Error #9
42 
43 namespace cxsc {
44 
45 class l_rvector_slice;
46 
48 
53 class l_rvector
54 {
55  friend class l_rvector_slice;
56  friend class l_rmatrix;
57  friend class l_rmatrix_subv;
58  friend class l_ivector;
59  friend class l_imatrix;
60  private:
61  l_real *dat;
62  int l,u,size;
63 
64  public:
65 //#if(CXSC_INDEX_CHECK)
66 
67 template<typename S, typename T>
68 friend inline void addDot(const S &x, const T &y, dotprecision &val);
69 
70 
71 #ifdef _CXSC_FRIEND_TPL
72  //------------ Templates --------------------------------------------------
73  // l_real
74 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m)
75 #if(CXSC_INDEX_CHECK)
76  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>);
77 #else
78  throw();
79 #endif
80 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
81 #if(CXSC_INDEX_CHECK)
82  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
83 #else
84  throw();
85 #endif
86  template <class V> friend void _vresize(V &rv) throw();
87  template <class V,class S> friend void _vresize(V &rv, const int &len)
88 #if(CXSC_INDEX_CHECK)
89  throw(ERROR__WRONG_BOUNDARIES<V>);
90 #else
91  throw();
92 #endif
93  template <class V,class S> friend void _vresize(V &rv, const int &lb, const int &ub)
94 #if(CXSC_INDEX_CHECK)
95  throw(ERROR__WRONG_BOUNDARIES<V>);
96 #else
97  throw();
98 #endif
99  template <class V1,class V2,class S> friend V1 &_vvassign(V1 &rv1,const V2 &rv2) throw();
100  template <class V,class S> friend V & _vsassign(V &rv,const S &r) throw();
101  template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) throw();
102  template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv)
103 #if(CXSC_INDEX_CHECK)
104  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
105 #else
106  throw();
107 #endif
108 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m)
109 #if(CXSC_INDEX_CHECK)
110  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
111 #else
112  throw();
113 #endif
114 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) throw();
115  template <class V> friend V _vconj(const V &rv) throw();
116  template <class VS,class E> friend E _vsconj(const VS &sl) throw();
117  template <class V,class E> friend E _vabs(const V &rv) throw();
118  template <class VS,class E> friend E _vsabs(const VS &sl) throw();
119 template <class MV,class V> friend V _mvabs(const MV &mv) throw();
120 
121 //-------- vector-vector -----------------------
122  template <class DP,class V1,class V2> friend void _vvaccu(DP &dp, const V1 & rv1, const V2 &rv2)
123 #if(CXSC_INDEX_CHECK)
124  throw(OP_WITH_WRONG_DIM);
125 #else
126  throw();
127 #endif
128  template <class DP,class VS,class V> friend void _vsvaccu(DP &dp, const VS & sl, const V &rv)
129 #if(CXSC_INDEX_CHECK)
130  throw(OP_WITH_WRONG_DIM);
131 #else
132  throw();
133 #endif
134  template <class V1,class V2,class E> friend E _vvlmult(const V1 & rv1, const V2 &rv2)
135 #if(CXSC_INDEX_CHECK)
136  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
137 #else
138  throw();
139 #endif
140  template <class VS,class V,class E> friend E _vsvlmult(const VS & sl, const V &rv)
141 #if(CXSC_INDEX_CHECK)
142  throw(ERROR__OP_WITH_WRONG_DIM<V>);
143 #else
144  throw();
145 #endif
146  template <class V,class S> friend V &_vsmultassign(V &rv,const S &r) throw();
147  template <class V1,class V2,class E> friend E _vvplus(const V1 &rv1, const V2 &rv2)
148 #if(CXSC_INDEX_CHECK)
149  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
150 #else
151  throw();
152 #endif
153  template <class V,class VS,class E> friend E _vvsplus(const V &rv,const VS &sl)
154 #if(CXSC_INDEX_CHECK)
155  throw(ERROR__OP_WITH_WRONG_DIM<V>);
156 #else
157  throw();
158 #endif
159  template <class VS1,class VS2,class E> friend E _vsvsplus(const VS1 &s1,const VS2 &s2)
160 #if(CXSC_INDEX_CHECK)
161  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
162 #else
163  throw();
164 #endif
165  template <class VS1,class VS2,class E> friend E _vsvsminus(const VS1 &s1,const VS2 &s2)
166 #if(CXSC_INDEX_CHECK)
167  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
168 #else
169  throw();
170 #endif
171  template <class V1,class V2> friend V1 &_vvplusassign(V1 &rv1, const V2 &rv2)
172 #if(CXSC_INDEX_CHECK)
173  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
174 #else
175  throw();
176 #endif
177  template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl)
178 #if(CXSC_INDEX_CHECK)
179  throw(ERROR__OP_WITH_WRONG_DIM<V>);
180 #else
181  throw();
182 #endif
183  template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv)
184 #if(CXSC_INDEX_CHECK)
185  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
186 #else
187  throw();
188 #endif
189  template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
190 #if(CXSC_INDEX_CHECK)
191  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
192 #else
193  throw();
194 #endif
195  template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
196 #if(CXSC_INDEX_CHECK)
197  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
198 #else
199  throw();
200 #endif
201  template <class V1,class V2> friend V1 &_vvminusassign(V1 &rv1, const V2 &rv2)
202 #if(CXSC_INDEX_CHECK)
203  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
204 #else
205  throw();
206 #endif
207  template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl)
208 #if(CXSC_INDEX_CHECK)
209  throw(ERROR__OP_WITH_WRONG_DIM<V>);
210 #else
211  throw();
212 #endif
213  template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv)
214 #if(CXSC_INDEX_CHECK)
215  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
216 #else
217  throw();
218 #endif
219  template <class V> friend V _vminus(const V &rv) throw();
220  template <class VS,class V> friend V _vsminus(const VS &sl) throw();
221  template <class V1,class V2,class E> friend E _vvminus(const V1 &rv1, const V2 &rv2)
222 #if(CXSC_INDEX_CHECK)
223  throw(ERROR__OP_WITH_WRONG_DIM<E>);
224 #else
225  throw();
226 #endif
227  template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl)
228 #if(CXSC_INDEX_CHECK)
229  throw(ERROR__OP_WITH_WRONG_DIM<E>);
230 #else
231  throw();
232 #endif
233  template <class VS,class V,class E> friend E _vsvminus(const VS &sl,const V &rv)
234 #if(CXSC_INDEX_CHECK)
235  throw(ERROR__OP_WITH_WRONG_DIM<E>);
236 #else
237  throw();
238 #endif
239  template <class V,class MV,class S> friend S _vmvlmult(const V &rv1, const MV &rv2)
240 #if(CXSC_INDEX_CHECK)
241  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
242 #else
243  throw();
244 #endif
245  template <class V1,class V2,class E> friend E _vvconv(const V1 &rv1, const V2 &rv2)
246 #if(CXSC_INDEX_CHECK)
247  throw(ERROR__OP_WITH_WRONG_DIM<E>);
248 #else
249  throw();
250 #endif
251  template <class V,class VS,class E> friend E _vvsconv(const V &rv,const VS &sl)
252 #if(CXSC_INDEX_CHECK)
253  throw(ERROR__OP_WITH_WRONG_DIM<E>);
254 #else
255  throw();
256 #endif
257  template <class VS1,class VS2,class E> friend E _vsvsconv(const VS1 &s1,const VS2 &s2)
258 #if(CXSC_INDEX_CHECK)
259  throw(ERROR__OP_WITH_WRONG_DIM<E>);
260 #else
261  throw();
262 #endif
263  //--------- vector-scalar -----------------
264  template <class V,class S,class E> friend E _vsdiv(const V &rv, const S &s) throw();
265  template <class V,class S> friend V &_vsdivassign(V &rv,const S &r) throw();
266  template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) throw();
267  template <class V,class S,class E> friend E _vsmult(const V &rv, const S &s) throw();
268  template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) throw();
269  template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) throw();
270  template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
271 #if(CXSC_INDEX_CHECK)
272  throw(ERROR__OP_WITH_WRONG_DIM<E>);
273 #else
274  throw();
275 #endif
276  template <class MV,class V,class E> friend E _mvvplus(const MV &rv1, const V &rv2)
277 #if(CXSC_INDEX_CHECK)
278  throw(ERROR__OP_WITH_WRONG_DIM<E>);
279 #else
280  throw();
281 #endif
282  template <class MV,class V,class E> friend E _mvvminus(const MV &rv1, const V &rv2)
283 #if(CXSC_INDEX_CHECK)
284  throw(ERROR__OP_WITH_WRONG_DIM<E>);
285 #else
286  throw();
287 #endif
288  template <class V,class MV,class E> friend E _vmvminus(const V &rv1, const MV &rv2)
289 #if(CXSC_INDEX_CHECK)
290  throw(ERROR__OP_WITH_WRONG_DIM<E>);
291 #else
292  throw();
293 #endif
294  template <class MV1,class MV2,class E> friend E _mvmvminus(const MV1 &rv1, const MV2 &rv2)
295 #if(CXSC_INDEX_CHECK)
296  throw(ERROR__OP_WITH_WRONG_DIM<E>);
297 #else
298  throw();
299 #endif
300 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
301 #if(CXSC_INDEX_CHECK)
302  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
303 #else
304  throw();
305 #endif
306 template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv)
307 #if(CXSC_INDEX_CHECK)
308  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
309 #else
310  throw();
311 #endif
312  template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) throw();
313 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
314 #if(CXSC_INDEX_CHECK)
315  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
316 #else
317  throw();
318 #endif
319 template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
320 #if(CXSC_INDEX_CHECK)
321  throw(OP_WITH_WRONG_DIM);
322 #else
323  throw();
324 #endif
325 
326  template <class V1,class V2> friend bool _vveq(const V1 &rv1, const V2 &rv2) throw();
327  template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) throw();
328  template <class V1,class V2> friend bool _vvneq(const V1 &rv1, const V2 &rv2) throw();
329  template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) throw();
330  template <class V1,class V2> friend bool _vvless(const V1 &rv1, const V2 &rv2) throw();
331  template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) throw();
332  template <class V1,class V2> friend bool _vvleq(const V1 &rv1, const V2 &rv2) throw();
333  template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) throw();
334  template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) throw();
335  template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) throw();
336  template <class V> friend bool _vnot(const V &rv) throw();
337  template <class V> friend void *_vvoid(const V &rv) throw();
338  template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw();
339  template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw();
340  template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw();
341  template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw();
342  template <class VS> friend bool _vsnot(const VS &sl) throw();
343  template <class VS> friend void *_vsvoid(const VS &sl) throw();
344  template <class V> friend std::ostream &_vout(std::ostream &s, const V &rv) throw();
345  template <class V> friend std::istream &_vin(std::istream &s, V &rv) throw();
346 
347  //------------- vector-matrix ---------------
348 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) throw();
349  template <class M,class V,class E> friend E _mvlmult(const M &m,const V &v)
350 #if(CXSC_INDEX_CHECK)
351  throw(ERROR__OP_WITH_WRONG_DIM<M>);
352 #else
353  throw();
354 #endif
355  template <class V,class M,class E> friend E _vmlmult(const V &v,const M &m)
356 #if(CXSC_INDEX_CHECK)
357  throw(ERROR__OP_WITH_WRONG_DIM<M>);
358 #else
359  throw();
360 #endif
361  template <class V,class M,class S> friend V &_vmlmultassign(V &v,const M &m)
362 #if(CXSC_INDEX_CHECK)
363  throw(ERROR__OP_WITH_WRONG_DIM<M>);
364 #else
365  throw();
366 #endif
367  template <class MS,class V,class E> friend E _msvlmult(const MS &ms,const V &v)
368 #if(CXSC_INDEX_CHECK)
369  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
370 #else
371  throw();
372 #endif
373  template <class V,class MS,class E> friend E _vmslmult(const V &v,const MS &ms)
374 #if(CXSC_INDEX_CHECK)
375  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
376 #else
377  throw();
378 #endif
379  template <class V,class MS,class S> friend V &_vmslmultassign(V &v,const MS &ms)
380 #if(CXSC_INDEX_CHECK)
381  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
382 #else
383  throw();
384 #endif
385 
386  // interval -----------------
387  // vector-vector
388  template <class V1,class V2,class E> friend E _vvlimult(const V1 & rv1, const V2 &rv2)
389 #if(CXSC_INDEX_CHECK)
390  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
391 #else
392  throw();
393 #endif
394  template <class VS,class V,class E> friend E _vsvlimult(const VS & sl, const V &rv)
395 #if(CXSC_INDEX_CHECK)
396  throw(ERROR__OP_WITH_WRONG_DIM<V>);
397 #else
398  throw();
399 #endif
400  template <class VS1,class VS2,class E> friend E _vsvslimult(const VS1 & sl1, const VS2 &sl2)
401 #if(CXSC_INDEX_CHECK)
402  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
403 #else
404  throw();
405 #endif
406  template <class V1,class V2,class E> friend E _vvsect(const V1 &rv1, const V2 &rv2)
407 #if(CXSC_INDEX_CHECK)
408  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
409 #else
410  throw();
411 #endif
412  template <class V,class VS,class E> friend E _vvssect(const V &rv,const VS &sl)
413 #if(CXSC_INDEX_CHECK)
414  throw(ERROR__OP_WITH_WRONG_DIM<E>);
415 #else
416  throw();
417 #endif
418  template <class VS1,class VS2,class E> friend E _vsvssect(const VS1 &s1,const VS2 &s2)
419 #if(CXSC_INDEX_CHECK)
420  throw(ERROR__OP_WITH_WRONG_DIM<E>);
421 #else
422  throw();
423 #endif
424 
425  // vector-matrix
426  template <class M,class V,class E> friend E _mvlimult(const M &m,const V &v)
427 #if(CXSC_INDEX_CHECK)
428  throw(ERROR__OP_WITH_WRONG_DIM<M>);
429 #else
430  throw();
431 #endif
432  template <class V,class M,class E> friend E _vmlimult(const V &v,const M &m)
433 #if(CXSC_INDEX_CHECK)
434  throw(ERROR__OP_WITH_WRONG_DIM<M>);
435 #else
436  throw();
437 #endif
438  template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v)
439 #if(CXSC_INDEX_CHECK)
440  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
441 #else
442  throw();
443 #endif
444  template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms)
445 #if(CXSC_INDEX_CHECK)
446  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
447 #else
448  throw();
449 #endif
450 
451  // l_interval -----------------
452  template <class V1,class V2> friend V1 &_vvsetinf(V1 &rv1, const V2 &rv2)
453 #if(CXSC_INDEX_CHECK)
454  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
455 #else
456  throw();
457 #endif
458  template <class V1,class V2> friend V1 &_vvsetsup(V1 &rv1, const V2 &rv2)
459 #if(CXSC_INDEX_CHECK)
460  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
461 #else
462  throw();
463 #endif
464  template <class V1,class V2> friend V1 &_vvusetinf(V1 &rv1, const V2 &rv2)
465 #if(CXSC_INDEX_CHECK)
466  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
467 #else
468  throw();
469 #endif
470  template <class V1,class V2> friend V1 &_vvusetsup(V1 &rv1, const V2 &rv2)
471 #if(CXSC_INDEX_CHECK)
472  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
473 #else
474  throw();
475 #endif
476  template <class VS,class V> friend VS &_vsvsetinf(VS &sl, const V &rv)
477 #if(CXSC_INDEX_CHECK)
478  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
479 #else
480  throw();
481 #endif
482  template <class VS,class V> friend VS &_vsvsetsup(VS &sl, const V &rv)
483 #if(CXSC_INDEX_CHECK)
484  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
485 #else
486  throw();
487 #endif
488  template <class VS,class V> friend VS &_vsvusetinf(VS &sl, const V &rv)
489 #if(CXSC_INDEX_CHECK)
490  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
491 #else
492  throw();
493 #endif
494  template <class VS,class V> friend VS &_vsvusetsup(VS &sl, const V &rv)
495 #if(CXSC_INDEX_CHECK)
496  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
497 #else
498  throw();
499 #endif
500 template <class MV,class V> friend MV &_mvvsetinf(MV &v,const V &rv)
501 #if(CXSC_INDEX_CHECK)
502  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
503 #else
504  throw();
505 #endif
506 template <class MV,class V> friend MV &_mvvsetsup(MV &v,const V &rv)
507 #if(CXSC_INDEX_CHECK)
508  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
509 #else
510  throw();
511 #endif
512 template <class MV,class V> friend MV &_mvvusetinf(MV &v,const V &rv)
513 #if(CXSC_INDEX_CHECK)
514  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
515 #else
516  throw();
517 #endif
518 template <class MV,class V> friend MV &_mvvusetsup(MV &v,const V &rv)
519 #if(CXSC_INDEX_CHECK)
520  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
521 #else
522  throw();
523 #endif
524  template <class V,class E> friend E _vmid(const V &rv) throw();
525  template <class V,class E> friend E _vinf(const V &rv) throw();
526  template <class V,class E> friend E _vsup(const V &rv) throw();
527  template <class V,class E> friend E _vdiam(const V &rv) throw();
528  template <class VS,class E> friend E _vsmid(const VS &sl) throw();
529  template <class VS,class E> friend E _vsinf(const VS &sl) throw();
530  template <class VS,class E> friend E _vssup(const VS &sl) throw();
531  template <class VS,class E> friend E _vsdiam(const VS &sl) throw();
532 template <class MV,class V> friend V _mvdiam(const MV &mv) throw();
533 template <class MV,class V> friend V _mvmid(const MV &mv) throw();
534 template <class MV,class V> friend V _mvinf(const MV &mv) throw();
535 template <class MV,class V> friend V _mvsup(const MV &mv) throw();
536 
537  // vector-vector
538  template <class V1,class V2> friend V1 &_vvconvassign(V1 &rv1, const V2 &rv2)
539 #if(CXSC_INDEX_CHECK)
540  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
541 #else
542  throw();
543 #endif
544  template <class V1,class V2> friend V1 &_vvsectassign(V1 &rv1, const V2 &rv2)
545 #if(CXSC_INDEX_CHECK)
546  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
547 #else
548  throw();
549 #endif
550  template <class VS,class V> friend VS &_vsvconvassign(VS &sl, const V &rv)
551 #if(CXSC_INDEX_CHECK)
552  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
553 #else
554  throw();
555 #endif
556  template <class VS,class V> friend VS &_vsvsectassign(VS &sl, const V &rv)
557 #if(CXSC_INDEX_CHECK)
558  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
559 #else
560  throw();
561 #endif
562 
563 template <class MV,class V> friend MV &_mvvconvassign(MV &v,const V &rv)
564 #if(CXSC_INDEX_CHECK)
565  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
566 #else
567  throw();
568 #endif
569 template <class MV,class V> friend MV &_mvvsectassign(MV &v,const V &rv)
570 #if(CXSC_INDEX_CHECK)
571  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
572 #else
573  throw();
574 #endif
575 
576 
577 #endif
578 
579  //------ Konstruktoren ----------------------------------------------------
581  INLINE l_rvector () throw();
583  explicit INLINE l_rvector(const int &i) throw();
584 #ifdef OLD_CXSC
585  explicit INLINE l_rvector(const class index &i) throw(); // for backwards compatibility
587 #endif
588  explicit INLINE l_rvector(const int &i1,const int &i2)
590 #if(CXSC_INDEX_CHECK)
591  throw(ERROR_LRVECTOR_WRONG_BOUNDARIES,ERROR_LRVECTOR_NO_MORE_MEMORY);
592 #else
593  throw();
594 #endif
595  INLINE l_rvector(const l_rmatrix_subv &) throw();
598  explicit INLINE l_rvector(const l_real &) throw();
600  explicit INLINE l_rvector(const l_rmatrix &)
601 #if(CXSC_INDEX_CHECK)
602  throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ);
603 #else
604  throw();
605 #endif
606  explicit INLINE l_rvector(const l_rmatrix_slice &sl)
608 #if(CXSC_INDEX_CHECK)
609  throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ);
610 #else
611  throw();
612 #endif
613  INLINE l_rvector(const l_rvector_slice &rs) throw();
616  INLINE l_rvector(const l_rvector &v) throw();
617  // Real
619  explicit INLINE l_rvector(const real &) throw();
621  explicit INLINE l_rvector(const rvector_slice &rs) throw();
623  explicit INLINE l_rvector(const rvector &v) throw();
625  explicit INLINE l_rvector(const rmatrix &)
626 #if(CXSC_INDEX_CHECK)
627  throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
628 #else
629  throw();
630 #endif
631  explicit INLINE l_rvector(const rmatrix_slice &sl)
633 #if(CXSC_INDEX_CHECK)
634  throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
635 #else
636  throw();
637 #endif
638  explicit INLINE l_rvector(const rmatrix_subv &) throw();
640 
641  // l_real
643  INLINE l_rvector &operator =(const l_rvector &rv) throw();
645  INLINE l_rvector &operator =(const l_rvector_slice &sl) throw();
647  INLINE l_rvector &operator =(const l_real &r) throw();
649  INLINE l_rvector &operator =(const l_rmatrix &m)
650 #if(CXSC_INDEX_CHECK)
651  throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ);
652 #else
653  throw();
654 #endif
655  INLINE l_rvector &operator =(const l_rmatrix_slice &)
657 #if(CXSC_INDEX_CHECK)
658  throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ);
659 #else
660  throw();
661 #endif
662  INLINE l_rvector &operator =(const l_rmatrix_subv &) throw();
664  // Real
666  INLINE l_rvector &operator =(const rvector &rv) throw();
668  INLINE l_rvector &operator =(const rvector_slice &sl) throw();
670  INLINE l_rvector &operator =(const real &r) throw();
672  INLINE l_rvector &operator =(const rmatrix &m)
673 #if(CXSC_INDEX_CHECK)
674  throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
675 #else
676  throw();
677 #endif
678  INLINE l_rvector &operator =(const rmatrix_slice &)
680 #if(CXSC_INDEX_CHECK)
681  throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
682 #else
683  throw();
684 #endif
685  INLINE l_rvector &operator =(const rmatrix_subv &) throw();
687 
688  //--------- Destruktor ----------------------------------------------------
689  INLINE ~l_rvector() { delete [] dat; }
690 
691  //------ Standardfunktionen -----------------------------------------------
692 
693  friend INLINE l_real::l_real(const l_rvector &)
694 #if(CXSC_INDEX_CHECK)
695  throw(ERROR_LRVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_LRVECTOR_USE_OF_UNINITIALIZED_OBJ);
696 #else
697  throw();
698 #endif
699  friend INLINE int Lb(const l_rvector &rv) throw() { return rv.l; }
702  friend INLINE int Ub(const l_rvector &rv) throw() { return rv.u; }
704  friend INLINE int VecLen(const l_rvector &rv) throw() { return rv.size; }
706  friend INLINE l_rvector & SetLb(l_rvector &rv, const int &l) throw() { rv.l=l; rv.u=l+rv.size-1; return rv;}
708  friend INLINE l_rvector & SetUb(l_rvector &rv, const int &u) throw() { rv.u=u; rv.l=u-rv.size+1; return rv;}
710  INLINE l_real & operator [](const int &i) const
711 #if(CXSC_INDEX_CHECK)
712  throw(ERROR_LRVECTOR_ELEMENT_NOT_IN_VEC);
713 #else
714  throw();
715 #endif
716  INLINE l_rvector & operator ()() throw() { return *this; }
719  INLINE l_rvector_slice operator ()(const int &i)
720 #if(CXSC_INDEX_CHECK)
721  throw(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG);
722 #else
723  throw();
724 #endif
725  INLINE l_rvector_slice operator ()(const int &i1,const int &i2)
727 #if(CXSC_INDEX_CHECK)
728  throw(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG);
729 #else
730  throw();
731 #endif
732  INLINE operator void*() throw();
733 //#else
734 //#endif
735 };
736 
737 
739 
745 {
746  friend class l_rvector;
747  friend class l_rmatrix;
748  friend class l_ivector;
749  friend class l_imatrix;
750  private:
751  l_real *dat;
752  int l,u,size;
753  int start,end;
754 
755  public:
756 //#if(CXSC_INDEX_CHECK)
757 
758 template<typename S, typename T>
759 friend inline void addDot(const S &x, const T &y, dotprecision &val);
760 
761 
762 #ifdef _CXSC_FRIEND_TPL
763 //------------------------- Templates -------------------------------------------
764 // l_real / l_real
765 
766  template <class VS1,class VS2> friend VS1 & _vsvsassign(VS1 &sl1,const VS2 &sl2)
767 #if(CXSC_INDEX_CHECK)
768  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
769 #else
770  throw();
771 #endif
772  template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) throw();
773  template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv)
774 #if(CXSC_INDEX_CHECK)
775  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
776 #else
777  throw();
778 #endif
779  template <class VS,class S> friend VS & _vssassign(VS &sl,const S &r) throw();
780 
781  template <class DP,class VS,class V> friend void _vsvaccu(DP &dp, const VS & sl, const V &rv)
782 #if(CXSC_INDEX_CHECK)
783  throw(OP_WITH_WRONG_DIM);
784 #else
785  throw();
786 #endif
787  template <class DP,class VS1,class VS2> friend void _vsvsaccu(DP &dp, const VS1 & sl1, const VS2 &sl2)
788 #if(CXSC_INDEX_CHECK)
789  throw(OP_WITH_WRONG_DIM);
790 #else
791  throw();
792 #endif
793 
794  template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) throw();
795  template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) throw();
796 
797  template <class VS,class V,class E> friend E _vsvlmult(const VS & sl, const V &rv)
798 #if(CXSC_INDEX_CHECK)
799  throw(ERROR__OP_WITH_WRONG_DIM<V>);
800 #else
801  throw();
802 #endif
803  template <class VS,class S> friend VS &_vssmultassign(VS &rv,const S &r) throw();
804  template <class VS,class S> friend VS &_vssdivassign(VS &rv,const S &r) throw();
805  template <class V,class VS,class E> friend E _vvsplus(const V &rv,const VS &sl)
806 #if(CXSC_INDEX_CHECK)
807  throw(ERROR__OP_WITH_WRONG_DIM<V>);
808 #else
809  throw();
810 #endif
811  template <class VS1,class VS2,class E> friend E _vsvsplus(const VS1 &s1,const VS2 &s2)
812 #if(CXSC_INDEX_CHECK)
813  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
814 #else
815  throw();
816 #endif
817  template <class VS1,class VS2,class E> friend E _vsvsminus(const VS1 &s1,const VS2 &s2)
818 #if(CXSC_INDEX_CHECK)
819  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
820 #else
821  throw();
822 #endif
823  template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl)
824 #if(CXSC_INDEX_CHECK)
825  throw(ERROR__OP_WITH_WRONG_DIM<V>);
826 #else
827  throw();
828 #endif
829  template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv)
830 #if(CXSC_INDEX_CHECK)
831  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
832 #else
833  throw();
834 #endif
835  template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
836 #if(CXSC_INDEX_CHECK)
837  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
838 #else
839  throw();
840 #endif
841  template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
842 #if(CXSC_INDEX_CHECK)
843  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
844 #else
845  throw();
846 #endif
847  template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl)
848 #if(CXSC_INDEX_CHECK)
849  throw(ERROR__OP_WITH_WRONG_DIM<V>);
850 #else
851  throw();
852 #endif
853  template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv)
854 #if(CXSC_INDEX_CHECK)
855  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
856 #else
857  throw();
858 #endif
859  template <class VS,class V> friend V _vsminus(const VS &sl) throw();
860  template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl)
861 #if(CXSC_INDEX_CHECK)
862  throw(ERROR__OP_WITH_WRONG_DIM<E>);
863 #else
864  throw();
865 #endif
866  template <class VS,class V,class E> friend E _vsvminus(const VS &sl,const V &rv)
867 #if(CXSC_INDEX_CHECK)
868  throw(ERROR__OP_WITH_WRONG_DIM<E>);
869 #else
870  throw();
871 #endif
872  template <class V,class VS,class E> friend E _vvsconv(const V &rv,const VS &sl)
873 #if(CXSC_INDEX_CHECK)
874  throw(ERROR__OP_WITH_WRONG_DIM<E>);
875 #else
876  throw();
877 #endif
878  template <class VS1,class VS2,class E> friend E _vsvsconv(const VS1 &s1,const VS2 &s2)
879 #if(CXSC_INDEX_CHECK)
880  throw(ERROR__OP_WITH_WRONG_DIM<E>);
881 #else
882  throw();
883 #endif
884  template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) throw();
885  template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) throw();
886  template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) throw();
887  template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) throw();
888  template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) throw();
889  template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) throw();
890  template <class VS,class E> friend E _vsabs(const VS &sl) throw();
891  template <class VS1,class VS2,class E> friend E _vsvslmult(const VS1 & sl1, const VS2 &sl2)
892 #if(CXSC_INDEX_CHECK)
893  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
894 #else
895  throw();
896 #endif
897  template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw();
898  template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw();
899  template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw();
900  template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw();
901  template <class VS> friend bool _vsnot(const VS &sl) throw();
902  template <class VS> friend void *_vsvoid(const VS &sl) throw();
903  template <class V> friend std::ostream &_vsout(std::ostream &s, const V &rv) throw();
904  template <class V> friend std::istream &_vsin(std::istream &s, V &rv) throw();
905 
906  template <class VS,class M,class S> friend VS &_vsmlmultassign(VS &v,const M &m)
907 #if(CXSC_INDEX_CHECK)
908  throw(ERROR__OP_WITH_WRONG_DIM<M>);
909 #else
910  throw();
911 #endif
912 
913  // l_real / Real
914  template <class V,class MS,class E> friend E _vmslmult(const V &v,const MS &ms)
915 #if(CXSC_INDEX_CHECK)
916  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
917 #else
918  throw();
919 #endif
920 
921  template <class V,class VS,class E> friend E _vvssect(const V &rv,const VS &sl)
922 #if(CXSC_INDEX_CHECK)
923  throw(ERROR__OP_WITH_WRONG_DIM<E>);
924 #else
925  throw();
926 #endif
927  template <class VS1,class VS2,class E> friend E _vsvssect(const VS1 &s1,const VS2 &s2)
928 #if(CXSC_INDEX_CHECK)
929  throw(ERROR__OP_WITH_WRONG_DIM<E>);
930 #else
931  throw();
932 #endif
933 
934  // interval -----------
935  // vector-vector -------
936  template <class V1,class V2,class E> friend E _vvlimult(const V1 & rv1, const V2 &rv2)
937 #if(CXSC_INDEX_CHECK)
938  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
939 #else
940  throw();
941 #endif
942  template <class VS,class V,class E> friend E _vsvlimult(const VS & sl, const V &rv)
943 #if(CXSC_INDEX_CHECK)
944  throw(ERROR__OP_WITH_WRONG_DIM<V>);
945 #else
946  throw();
947 #endif
948  template <class VS1,class VS2,class E> friend E _vsvslimult(const VS1 & sl1, const VS2 &sl2)
949 #if(CXSC_INDEX_CHECK)
950  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
951 #else
952  throw();
953 #endif
954  template <class V1,class V2,class E> friend E _vvplus(const V1 &rv1, const V2 &rv2)
955 #if(CXSC_INDEX_CHECK)
956  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
957 #else
958  throw();
959 #endif
960  template <class V1,class V2,class E> friend E _vvminus(const V1 &rv1, const V2 &rv2)
961 #if(CXSC_INDEX_CHECK)
962  throw(ERROR__OP_WITH_WRONG_DIM<E>);
963 #else
964  throw();
965 #endif
966 
967  // vector-matrix -------
968  /* friend TINLINE l_ivector _mvslimult<imatrix,l_rvector_slice,l_ivector>(const imatrix &m,const l_rvector_slice &v)
969 #if(CXSC_INDEX_CHECK)
970  throw(ERROR_IMATRIX_OP_WITH_WRONG_DIM);
971 #else
972  throw();
973  #endif */
974  /* friend TINLINE l_ivector _vsmlimult<l_rvector_slice,imatrix,l_ivector>(const l_rvector_slice &v,const imatrix &m)
975 #if(CXSC_INDEX_CHECK)
976  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
977 #else
978  throw();
979  #endif */
980 
981  // l_interval -- vector-vector
982  template <class V,class VS> friend V &_vvsconvassign(V &rv, const VS &sl)
983 #if(CXSC_INDEX_CHECK)
984  throw(ERROR__OP_WITH_WRONG_DIM<V>);
985 #else
986  throw();
987 #endif
988  template <class V,class VS> friend V &_vvssectassign(V &rv, const VS &sl)
989 #if(CXSC_INDEX_CHECK)
990  throw(ERROR__OP_WITH_WRONG_DIM<V>);
991 #else
992  throw();
993 #endif
994  template <class VS1,class VS2> friend VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2)
995 #if(CXSC_INDEX_CHECK)
996  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
997 #else
998  throw();
999 #endif
1000  template <class VS1,class VS2> friend VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2)
1001 #if(CXSC_INDEX_CHECK)
1002  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1003 #else
1004  throw();
1005 #endif
1006 #endif
1007 
1008  //--------------------- Konstruktoren -----------------------------------
1010  explicit INLINE l_rvector_slice(l_rvector &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) { }
1012  explicit INLINE l_rvector_slice(l_rvector_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) { }
1013  public:
1015  INLINE l_rvector_slice(const l_rvector_slice &a) throw():dat(a.dat),l(a.l),u(a.u),size(a.size),start(a.start),end(a.end) { }
1016  public:
1017  // l_real
1019  INLINE l_rvector_slice & operator =(const l_rvector_slice &sl)
1020 #if(CXSC_INDEX_CHECK)
1021  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1022 #else
1023  throw();
1024 #endif
1025  INLINE l_rvector_slice & operator =(const l_rvector &rv)
1027 #if(CXSC_INDEX_CHECK)
1028  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1029 #else
1030  throw();
1031 #endif
1032  INLINE l_rvector_slice & operator =(const l_real &r) throw();
1035  INLINE l_rvector_slice & operator =(const l_rmatrix &m)
1036 #if(CXSC_INDEX_CHECK)
1037  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>,ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ);
1038 #else
1039  throw();
1040 #endif
1041  INLINE l_rvector_slice & operator =(const l_rmatrix_slice &m)
1043 #if(CXSC_INDEX_CHECK)
1044  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>,ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ);
1045 #else
1046  throw();
1047 #endif
1048  INLINE l_rvector_slice &operator =(const l_rmatrix_subv &) throw();
1050  // Real
1052  INLINE l_rvector_slice & operator =(const rvector_slice &sl)
1053 #if(CXSC_INDEX_CHECK)
1054  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1055 #else
1056  throw();
1057 #endif
1058  INLINE l_rvector_slice & operator =(const rvector &rv)
1060 #if(CXSC_INDEX_CHECK)
1061  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1062 #else
1063  throw();
1064 #endif
1065  INLINE l_rvector_slice & operator =(const real &r) throw();
1068  INLINE l_rvector_slice & operator =(const rmatrix &m)
1069 #if(CXSC_INDEX_CHECK)
1070  throw(ERROR__OP_WITH_WRONG_DIM<rvector>,ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
1071 #else
1072  throw();
1073 #endif
1074  INLINE l_rvector_slice & operator =(const rmatrix_slice &m)
1076 #if(CXSC_INDEX_CHECK)
1077  throw(ERROR__OP_WITH_WRONG_DIM<rvector>,ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
1078 #else
1079  throw();
1080 #endif
1081  INLINE l_rvector_slice &operator =(const rmatrix_subv &mv) throw();
1083 
1084  // l_interval --------
1085  template <class V,class VS> friend V &_vvssetinf(V &rv, const VS &sl)
1086 #if(CXSC_INDEX_CHECK)
1087  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1088 #else
1089  throw();
1090 #endif
1091  template <class V,class VS> friend V &_vvssetsup(V &rv, const VS &sl)
1092 #if(CXSC_INDEX_CHECK)
1093  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1094 #else
1095  throw();
1096 #endif
1097  template <class V,class VS> friend V &_vvsusetinf(V &rv, const VS &sl)
1098 #if(CXSC_INDEX_CHECK)
1099  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1100 #else
1101  throw();
1102 #endif
1103  template <class V,class VS> friend V &_vvsusetsup(V &rv, const VS &sl)
1104 #if(CXSC_INDEX_CHECK)
1105  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1106 #else
1107  throw();
1108 #endif
1109  template <class VS1,class VS2> friend VS1 &_vsvssetinf(VS1 &sl1, const VS2 &sl2)
1110 #if(CXSC_INDEX_CHECK)
1111  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1112 #else
1113  throw();
1114 #endif
1115  template <class VS1,class VS2> friend VS1 &_vsvssetsup(VS1 &sl1, const VS2 &sl2)
1116 #if(CXSC_INDEX_CHECK)
1117  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1118 #else
1119  throw();
1120 #endif
1121  template <class VS1,class VS2> friend VS1 &_vsvsusetinf(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 VS1 &_vsvsusetsup(VS1 &sl1, const VS2 &sl2)
1128 #if(CXSC_INDEX_CHECK)
1129  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1130 #else
1131  throw();
1132 #endif
1133 
1134  // l_interval -- vector-vector
1135  template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms)
1136 #if(CXSC_INDEX_CHECK)
1137  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1138 #else
1139  throw();
1140 #endif
1141  // l_interval -- vector-matrix
1142 
1143 
1144  //--------------------- Standardfunktionen ------------------------------
1145 
1146  friend INLINE l_real::l_real(const l_rvector_slice &sl)
1147 #if(CXSC_INDEX_CHECK)
1148  throw(ERROR_LRVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_LRVECTOR_USE_OF_UNINITIALIZED_OBJ);
1149 #else
1150  throw();
1151 #endif
1152  friend INLINE int Lb(const l_rvector_slice &sl) throw() { return sl.start; }
1155  friend INLINE int Ub(const l_rvector_slice &sl) throw() { return sl.end; }
1157  friend INLINE int VecLen(const l_rvector_slice &sl) throw() { return sl.end-sl.start+1; }
1159  INLINE l_real & operator [](const int &i) const
1160 #if(CXSC_INDEX_CHECK)
1161  throw(ERROR_LRVECTOR_ELEMENT_NOT_IN_VEC);
1162 #else
1163  throw();
1164 #endif
1165  INLINE l_rvector_slice & operator ()() throw() { return *this; }
1168  INLINE l_rvector_slice operator ()(const int &i)
1169 #if(CXSC_INDEX_CHECK)
1170  throw(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG);
1171 #else
1172  throw();
1173 #endif
1174  INLINE l_rvector_slice operator ()(const int &i1,const int &i2)
1176 #if(CXSC_INDEX_CHECK)
1177  throw(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG);
1178 #else
1179  throw();
1180 #endif
1181 
1183  INLINE l_rvector_slice &operator /=(const l_real &r) throw();
1185  INLINE l_rvector_slice &operator /=(const real &r) throw();
1187  INLINE l_rvector_slice &operator *=(const l_real &r) throw();
1189  INLINE l_rvector_slice &operator *=(const l_rmatrix &m)
1190 #if(CXSC_INDEX_CHECK)
1191  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1192 #else
1193  throw();
1194 #endif
1195  INLINE l_rvector_slice &operator *=(const rmatrix &m)
1197 #if(CXSC_INDEX_CHECK)
1198  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
1199 #else
1200  throw();
1201 #endif
1202  INLINE l_rvector_slice &operator *=(const real &r) throw();
1205  INLINE l_rvector_slice &operator +=(const l_rvector &rv)
1206 #if(CXSC_INDEX_CHECK)
1207  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1208 #else
1209  throw();
1210 #endif
1211  INLINE l_rvector_slice &operator +=(const l_rvector_slice &sl2)
1213 #if(CXSC_INDEX_CHECK)
1214  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1215 #else
1216  throw();
1217 #endif
1218  INLINE l_rvector_slice &operator -=(const l_rvector &rv)
1220 #if(CXSC_INDEX_CHECK)
1221  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1222 #else
1223  throw();
1224 #endif
1225  INLINE l_rvector_slice &operator -=(const l_rvector_slice &sl2)
1227 #if(CXSC_INDEX_CHECK)
1228  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1229 #else
1230  throw();
1231 #endif
1232  INLINE l_rvector_slice &operator |=(const l_rvector &rv)
1234 #if(CXSC_INDEX_CHECK)
1235  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1236 #else
1237  throw();
1238 #endif
1239  INLINE l_rvector_slice &operator |=(const l_rvector_slice &sl2)
1241 #if(CXSC_INDEX_CHECK)
1242  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1243 #else
1244  throw();
1245 #endif
1246  INLINE l_rvector_slice &operator &=(const l_rvector &rv)
1248 #if(CXSC_INDEX_CHECK)
1249  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1250 #else
1251  throw();
1252 #endif
1253  INLINE l_rvector_slice &operator &=(const l_rvector_slice &sl2)
1255 #if(CXSC_INDEX_CHECK)
1256  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1257 #else
1258  throw();
1259 #endif
1260 
1262  INLINE l_rvector_slice &operator +=(const rvector &rv)
1263 #if(CXSC_INDEX_CHECK)
1264  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1265 #else
1266  throw();
1267 #endif
1268  INLINE l_rvector_slice &operator +=(const rvector_slice &sl2)
1270 #if(CXSC_INDEX_CHECK)
1271  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1272 #else
1273  throw();
1274 #endif
1275  INLINE l_rvector_slice &operator -=(const rvector &rv)
1277 #if(CXSC_INDEX_CHECK)
1278  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1279 #else
1280  throw();
1281 #endif
1282  INLINE l_rvector_slice &operator -=(const rvector_slice &sl2)
1284 #if(CXSC_INDEX_CHECK)
1285  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1286 #else
1287  throw();
1288 #endif
1289  INLINE l_rvector_slice &operator |=(const rvector &rv)
1291 #if(CXSC_INDEX_CHECK)
1292  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1293 #else
1294  throw();
1295 #endif
1296  INLINE l_rvector_slice &operator |=(const rvector_slice &sl2)
1298 #if(CXSC_INDEX_CHECK)
1299  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1300 #else
1301  throw();
1302 #endif
1303  INLINE l_rvector_slice &operator &=(const rvector &rv)
1305 #if(CXSC_INDEX_CHECK)
1306  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1307 #else
1308  throw();
1309 #endif
1310  INLINE l_rvector_slice &operator &=(const rvector_slice &sl2)
1312 #if(CXSC_INDEX_CHECK)
1313  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1314 #else
1315  throw();
1316 #endif
1317  INLINE operator void*() throw();
1318 //#else
1319 //#endif
1320 };
1321 
1322 //=======================================================================
1323 //======================== Vector Functions =============================
1324 
1326  INLINE l_rvector _l_rvector(const l_real &r) throw();
1327 // INLINE l_rvector _l_rvector(const l_rmatrix &m) throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ);
1328 // INLINE l_rvector _l_rvector(const l_rmatrix_slice &sl) throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ);
1330  INLINE l_rvector _l_rvector(const real &r) throw();
1332  INLINE l_rvector _l_rvector(const rvector_slice &rs) throw();
1334  INLINE l_rvector _l_rvector(const rvector &rs) throw();
1335 // INLINE l_rvector _l_rvector(const rmatrix &m) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
1336 // INLINE l_rvector _l_rvector(const rmatrix_slice &sl) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
1338  INLINE l_rvector _l_rvector(const rmatrix_subv &rs) throw();
1339 
1341  INLINE void Resize(l_rvector &rv) throw();
1343  INLINE void Resize(l_rvector &rv, const int &len)
1344 #if(CXSC_INDEX_CHECK)
1345  throw(ERROR__WRONG_BOUNDARIES<l_rvector>);
1346 #else
1347  throw();
1348 #endif
1349  INLINE void Resize(l_rvector &rv, const int &lb, const int &ub)
1351 #if(CXSC_INDEX_CHECK)
1352  throw(ERROR__WRONG_BOUNDARIES<l_rvector>);
1353 #else
1354  throw();
1355 #endif
1356 
1358  INLINE l_rvector abs(const l_rvector &rv) throw();
1360  INLINE l_rvector abs(const l_rvector_slice &sl) throw();
1362  INLINE bool operator !(const l_rvector &rv) throw();
1364  INLINE bool operator !(const l_rvector_slice &sl) throw();
1365 
1366 //======================= Vector / Scalar ===============================
1367 
1368 //----------------------------- l_real ---------------------------
1369 
1371  INLINE l_rvector operator *(const l_rvector &rv, const l_real &s) throw();
1373  INLINE l_rvector operator *(const l_rvector_slice &sl, const l_real &s) throw();
1375  INLINE l_rvector operator *(const l_real &s, const l_rvector &rv) throw();
1377  INLINE l_rvector operator *(const l_real &s, const l_rvector_slice &sl) throw();
1379  INLINE l_rvector &operator *=(l_rvector &rv,const l_real &r) throw();
1380 
1382  INLINE l_rvector operator /(const l_rvector &rv, const l_real &s) throw();
1384  INLINE l_rvector operator /(const l_rvector_slice &sl, const l_real &s) throw();
1386  INLINE l_rvector &operator /=(l_rvector &rv,const l_real &r) throw();
1387 
1388 //---------------------------- Real --------------------------------------
1389 
1391  INLINE l_rvector operator *(const l_rvector &rv, const real &s) throw();
1393  INLINE l_rvector operator *(const l_rvector_slice &sl, const real &s) throw();
1395  INLINE l_rvector operator *(const real &s, const l_rvector &rv) throw();
1397  INLINE l_rvector operator *(const real &s, const l_rvector_slice &sl) throw();
1399  INLINE l_rvector &operator *=(l_rvector &rv,const real &r) throw();
1400 
1402  INLINE l_rvector operator /(const l_rvector &rv, const real &s) throw();
1404  INLINE l_rvector operator /(const l_rvector_slice &sl, const real &s) throw();
1406  INLINE l_rvector &operator /=(l_rvector &rv,const real &r) throw();
1407 
1409  INLINE l_rvector operator *(const rvector &rv, const l_real &s) throw();
1411  INLINE l_rvector operator *(const rvector_slice &sl, const l_real &s) throw();
1413  INLINE l_rvector operator *(const l_real &s, const rvector &rv) throw();
1415  INLINE l_rvector operator *(const l_real &s, const rvector_slice &sl) throw();
1416 
1418  INLINE l_rvector operator /(const rvector &rv, const l_real &s) throw();
1420  INLINE l_rvector operator /(const rvector_slice &sl, const l_real &s) throw();
1421 
1422 //======================= Vector / Vector ===============================
1423 
1424 
1426  INLINE std::ostream &operator <<(std::ostream &s, const l_rvector &rv) throw();
1428  INLINE std::ostream &operator <<(std::ostream &o, const l_rvector_slice &sl) throw();
1430  INLINE std::istream &operator >>(std::istream &s, l_rvector &rv) throw();
1432  INLINE std::istream &operator >>(std::istream &s, l_rvector_slice &rv) throw();
1433 
1434 //----------------------- l_real / l_real ---------------------------
1435 
1437  INLINE void accumulate(dotprecision &dp, const l_rvector & rv1, const l_rvector &rv2)
1438 #if(CXSC_INDEX_CHECK)
1439  throw(OP_WITH_WRONG_DIM);
1440 #else
1441  throw();
1442 #endif
1443  INLINE void accumulate(dotprecision &dp, const l_rvector_slice & sl, const l_rvector &rv)
1445 #if(CXSC_INDEX_CHECK)
1446  throw(OP_WITH_WRONG_DIM);
1447 #else
1448  throw();
1449 #endif
1450  INLINE void accumulate(dotprecision &dp, const l_rvector &rv, const l_rvector_slice &sl)
1452 #if(CXSC_INDEX_CHECK)
1453  throw(OP_WITH_WRONG_DIM);
1454 #else
1455  throw();
1456 #endif
1457  INLINE void accumulate(dotprecision &dp, const l_rvector & rv1, const l_rmatrix_subv &rv2)
1459 #if(CXSC_INDEX_CHECK)
1460  throw(OP_WITH_WRONG_DIM);
1461 #else
1462  throw();
1463 #endif
1464  INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const l_rvector &rv2)
1466 #if(CXSC_INDEX_CHECK)
1467  throw(OP_WITH_WRONG_DIM);
1468 #else
1469  throw();
1470 #endif
1471  INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const l_rmatrix_subv &rv2)
1473 #if(CXSC_INDEX_CHECK)
1474  throw(OP_WITH_WRONG_DIM);
1475 #else
1476  throw();
1477 #endif
1478  INLINE void accumulate(dotprecision &dp, const l_rvector_slice & sl1, const l_rvector_slice &sl2)
1480 #if(CXSC_INDEX_CHECK)
1481  throw(OP_WITH_WRONG_DIM);
1482 #else
1483  throw();
1484 #endif
1485  INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const l_rvector &rv2)
1487 #if(CXSC_INDEX_CHECK)
1488  throw(OP_WITH_WRONG_DIM);
1489 #else
1490  throw();
1491 #endif
1492  INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl, const l_rvector &rv)
1494 #if(CXSC_INDEX_CHECK)
1495  throw(OP_WITH_WRONG_DIM);
1496 #else
1497  throw();
1498 #endif
1499  INLINE void accumulate(idotprecision &dp, const l_rvector &rv, const l_rvector_slice &sl)
1501 #if(CXSC_INDEX_CHECK)
1502  throw(OP_WITH_WRONG_DIM);
1503 #else
1504  throw();
1505 #endif
1506  INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const l_rmatrix_subv &rv2)
1508 #if(CXSC_INDEX_CHECK)
1509  throw(OP_WITH_WRONG_DIM);
1510 #else
1511  throw();
1512 #endif
1513  INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const l_rvector &rv2)
1515 #if(CXSC_INDEX_CHECK)
1516  throw(OP_WITH_WRONG_DIM);
1517 #else
1518  throw();
1519 #endif
1520  INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl1, const l_rvector_slice &sl2)
1522 #if(CXSC_INDEX_CHECK)
1523  throw(OP_WITH_WRONG_DIM);
1524 #else
1525  throw();
1526 #endif
1527  INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const l_rmatrix_subv &rv2)
1529 #if(CXSC_INDEX_CHECK)
1530  throw(OP_WITH_WRONG_DIM);
1531 #else
1532  throw();
1533 #endif
1534 
1535 
1537  INLINE l_real operator *(const l_rvector & rv1, const l_rvector &rv2)
1538 #if(CXSC_INDEX_CHECK)
1539  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1540 #else
1541  throw();
1542 #endif
1543  INLINE l_real operator *(const l_rvector_slice &sl, const l_rvector &rv)
1545 #if(CXSC_INDEX_CHECK)
1546  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1547 #else
1548  throw();
1549 #endif
1550  INLINE l_real operator *(const l_rvector &rv, const l_rvector_slice &sl)
1552 #if(CXSC_INDEX_CHECK)
1553  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1554 #else
1555  throw();
1556 #endif
1557  INLINE l_real operator *(const l_rvector_slice & sl1, const l_rvector_slice &sl2)
1559 #if(CXSC_INDEX_CHECK)
1560  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1561 #else
1562  throw();
1563 #endif
1564 
1566  INLINE const l_rvector &operator +(const l_rvector &rv) throw();
1568  INLINE l_rvector operator +(const l_rvector_slice &sl) throw();
1569 
1571  INLINE l_rvector operator +(const l_rvector &rv1, const l_rvector &rv2)
1572 #if(CXSC_INDEX_CHECK)
1573  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1574 #else
1575  throw();
1576 #endif
1577  INLINE l_rvector operator +(const l_rvector &rv, const l_rvector_slice &sl)
1579 #if(CXSC_INDEX_CHECK)
1580  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1581 #else
1582  throw();
1583 #endif
1584  INLINE l_rvector operator +(const l_rvector_slice &sl, const l_rvector &rv)
1586 #if(CXSC_INDEX_CHECK)
1587  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1588 #else
1589  throw();
1590 #endif
1591  INLINE l_rvector operator +(const l_rvector_slice &sl1, const l_rvector_slice &sl2)
1593 #if(CXSC_INDEX_CHECK)
1594  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1595 #else
1596  throw();
1597 #endif
1598  INLINE l_rvector & operator +=(l_rvector &rv1, const l_rvector &rv2)
1600 #if(CXSC_INDEX_CHECK)
1601  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1602 #else
1603  throw();
1604 #endif
1605  INLINE l_rvector &operator +=(l_rvector &rv, const l_rvector_slice &sl)
1607 #if(CXSC_INDEX_CHECK)
1608  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1609 #else
1610  throw();
1611 #endif
1612 
1614  INLINE l_rvector operator -(const l_rvector &rv) throw();
1616  INLINE l_rvector operator -(const l_rvector_slice &sl) throw();
1618  INLINE l_rvector operator -(const l_rvector &rv1, const l_rvector &rv2)
1619 #if(CXSC_INDEX_CHECK)
1620  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1621 #else
1622  throw();
1623 #endif
1624  INLINE l_rvector operator -(const l_rvector &rv, const l_rvector_slice &sl)
1626 #if(CXSC_INDEX_CHECK)
1627  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1628 #else
1629  throw();
1630 #endif
1631  INLINE l_rvector operator -(const l_rvector_slice &sl, const l_rvector &rv)
1633 #if(CXSC_INDEX_CHECK)
1634  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1635 #else
1636  throw();
1637 #endif
1638  INLINE l_rvector operator -(const l_rvector_slice &sl1, const l_rvector_slice &sl2)
1640 #if(CXSC_INDEX_CHECK)
1641  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1642 #else
1643  throw();
1644 #endif
1645  INLINE l_rvector & operator -=(l_rvector &rv1, const l_rvector &rv2)
1647 #if(CXSC_INDEX_CHECK)
1648  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1649 #else
1650  throw();
1651 #endif
1652  INLINE l_rvector &operator -=(l_rvector &rv, const l_rvector_slice &sl)
1654 #if(CXSC_INDEX_CHECK)
1655  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1656 #else
1657  throw();
1658 #endif
1659 
1661  INLINE bool operator ==(const l_rvector &rv1, const l_rvector &rv2) throw();
1663  INLINE bool operator ==(const l_rvector_slice &sl1, const l_rvector_slice &sl2) throw();
1665  INLINE bool operator ==(const l_rvector_slice &sl, const l_rvector &rv) throw();
1667  INLINE bool operator ==(const l_rvector &rv, const l_rvector_slice &sl) throw();
1669  INLINE bool operator !=(const l_rvector &rv1, const l_rvector &rv2) throw();
1671  INLINE bool operator !=(const l_rvector_slice &sl1, const l_rvector_slice &sl2) throw();
1673  INLINE bool operator !=(const l_rvector_slice &sl, const l_rvector &rv) throw();
1675  INLINE bool operator !=(const l_rvector &rv, const l_rvector_slice &sl) throw();
1677  INLINE bool operator <(const l_rvector &rv1, const l_rvector &rv2) throw();
1679  INLINE bool operator <(const l_rvector_slice &sl1, const l_rvector_slice &sl2) throw();
1681  INLINE bool operator < (const l_rvector_slice &sl, const l_rvector &rv) throw();
1683  INLINE bool operator < (const l_rvector &rv, const l_rvector_slice &sl) throw();
1685  INLINE bool operator <=(const l_rvector &rv1, const l_rvector &rv2) throw();
1687  INLINE bool operator <=(const l_rvector_slice &sl1, const l_rvector_slice &sl2) throw();
1689  INLINE bool operator <=(const l_rvector_slice &sl, const l_rvector &rv) throw();
1691  INLINE bool operator <=(const l_rvector &rv, const l_rvector_slice &sl) throw();
1693  INLINE bool operator >(const l_rvector &rv1, const l_rvector &rv2) throw();
1695  INLINE bool operator >(const l_rvector_slice &sl1, const l_rvector_slice &sl2) throw();
1697  INLINE bool operator >(const l_rvector_slice &sl, const l_rvector &rv) throw();
1699  INLINE bool operator >(const l_rvector &rv, const l_rvector_slice &sl) throw();
1701  INLINE bool operator >=(const l_rvector &rv1, const l_rvector &rv2) throw();
1703  INLINE bool operator >=(const l_rvector_slice &sl1, const l_rvector_slice &sl2) throw();
1705  INLINE bool operator >=(const l_rvector_slice &sl, const l_rvector &rv) throw();
1707  INLINE bool operator >=(const l_rvector &rv, const l_rvector_slice &sl) throw();
1708 
1709 //-------------------------------- l_real / Real --------------------------------
1710 
1711 
1713  INLINE void accumulate(dotprecision &dp, const l_rvector & rv1, const rvector &rv2)
1714 #if(CXSC_INDEX_CHECK)
1715  throw(OP_WITH_WRONG_DIM);
1716 #else
1717  throw();
1718 #endif
1719  INLINE void accumulate(dotprecision &dp, const rvector & rv1, const l_rvector &rv2)
1721 #if(CXSC_INDEX_CHECK)
1722  throw(OP_WITH_WRONG_DIM);
1723 #else
1724  throw();
1725 #endif
1726  INLINE void accumulate(dotprecision &dp, const rvector_slice & sl, const l_rvector &rv)
1728 #if(CXSC_INDEX_CHECK)
1729  throw(OP_WITH_WRONG_DIM);
1730 #else
1731  throw();
1732 #endif
1733  INLINE void accumulate(dotprecision &dp,const l_rvector_slice &sl,const rvector &rv)
1735 #if(CXSC_INDEX_CHECK)
1736  throw(OP_WITH_WRONG_DIM);
1737 #else
1738  throw();
1739 #endif
1740  INLINE void accumulate(dotprecision &dp, const rvector &rv, const l_rvector_slice &sl)
1742 #if(CXSC_INDEX_CHECK)
1743  throw(OP_WITH_WRONG_DIM);
1744 #else
1745  throw();
1746 #endif
1747  INLINE void accumulate(dotprecision &dp, const rvector & rv1, const l_rmatrix_subv &rv2)
1749 #if(CXSC_INDEX_CHECK)
1750  throw(OP_WITH_WRONG_DIM);
1751 #else
1752  throw();
1753 #endif
1754  INLINE void accumulate(dotprecision &dp, const l_rvector & rv1, const rmatrix_subv &rv2)
1756 #if(CXSC_INDEX_CHECK)
1757  throw(OP_WITH_WRONG_DIM);
1758 #else
1759  throw();
1760 #endif
1761  INLINE void accumulate(dotprecision &dp, const rvector_slice & rv1, const l_rmatrix_subv &rv2)
1763 #if(CXSC_INDEX_CHECK)
1764  throw(OP_WITH_WRONG_DIM);
1765 #else
1766  throw();
1767 #endif
1768  INLINE void accumulate(dotprecision &dp, const l_rvector_slice & rv1, const rmatrix_subv &rv2)
1770 #if(CXSC_INDEX_CHECK)
1771  throw(OP_WITH_WRONG_DIM);
1772 #else
1773  throw();
1774 #endif
1775  INLINE void accumulate(dotprecision &dp,const l_rvector &rv,const rvector_slice &sl)
1777 #if(CXSC_INDEX_CHECK)
1778  throw(OP_WITH_WRONG_DIM);
1779 #else
1780  throw();
1781 #endif
1782  INLINE void accumulate(dotprecision &dp, const rmatrix_subv & rv1, const l_rvector &rv2)
1784 #if(CXSC_INDEX_CHECK)
1785  throw(OP_WITH_WRONG_DIM);
1786 #else
1787  throw();
1788 #endif
1789  INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const rvector &rv2)
1791 #if(CXSC_INDEX_CHECK)
1792  throw(OP_WITH_WRONG_DIM);
1793 #else
1794  throw();
1795 #endif
1796  INLINE void accumulate(dotprecision &dp, const rmatrix_subv & rv1, const l_rvector_slice &rv2)
1798 #if(CXSC_INDEX_CHECK)
1799  throw(OP_WITH_WRONG_DIM);
1800 #else
1801  throw();
1802 #endif
1803  INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const rvector_slice &rv2)
1805 #if(CXSC_INDEX_CHECK)
1806  throw(OP_WITH_WRONG_DIM);
1807 #else
1808  throw();
1809 #endif
1810  INLINE void accumulate(dotprecision &dp, const l_rvector_slice & sl1, const rvector_slice &sl2)
1812 #if(CXSC_INDEX_CHECK)
1813  throw(OP_WITH_WRONG_DIM);
1814 #else
1815  throw();
1816 #endif
1817  INLINE void accumulate(dotprecision &dp, const rvector_slice & sl1, const l_rvector_slice &sl2)
1819 #if(CXSC_INDEX_CHECK)
1820  throw(OP_WITH_WRONG_DIM);
1821 #else
1822  throw();
1823 #endif
1824  INLINE void accumulate(dotprecision &dp, const rmatrix_subv & rv1, const l_rmatrix_subv &rv2)
1826 #if(CXSC_INDEX_CHECK)
1827  throw(OP_WITH_WRONG_DIM);
1828 #else
1829  throw();
1830 #endif
1831  INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const rmatrix_subv &rv2)
1833 #if(CXSC_INDEX_CHECK)
1834  throw(OP_WITH_WRONG_DIM);
1835 #else
1836  throw();
1837 #endif
1838 
1840  INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const rvector &rv2)
1841 #if(CXSC_INDEX_CHECK)
1842  throw(OP_WITH_WRONG_DIM);
1843 #else
1844  throw();
1845 #endif
1846  INLINE void accumulate(idotprecision &dp, const rvector & rv1, const l_rvector &rv2)
1848 #if(CXSC_INDEX_CHECK)
1849  throw(OP_WITH_WRONG_DIM);
1850 #else
1851  throw();
1852 #endif
1853  INLINE void accumulate(idotprecision &dp, const rvector_slice & sl, const l_rvector &rv)
1855 #if(CXSC_INDEX_CHECK)
1856  throw(OP_WITH_WRONG_DIM);
1857 #else
1858  throw();
1859 #endif
1860  INLINE void accumulate(idotprecision &dp,const l_rvector_slice &sl,const rvector &rv)
1862 #if(CXSC_INDEX_CHECK)
1863  throw(OP_WITH_WRONG_DIM);
1864 #else
1865  throw();
1866 #endif
1867  INLINE void accumulate(idotprecision &dp, const rvector &rv, const l_rvector_slice &sl)
1869 #if(CXSC_INDEX_CHECK)
1870  throw(OP_WITH_WRONG_DIM);
1871 #else
1872  throw();
1873 #endif
1874  INLINE void accumulate(idotprecision &dp, const rvector & rv1, const l_rmatrix_subv &rv2)
1876 #if(CXSC_INDEX_CHECK)
1877  throw(OP_WITH_WRONG_DIM);
1878 #else
1879  throw();
1880 #endif
1881  INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const rmatrix_subv &rv2)
1883 #if(CXSC_INDEX_CHECK)
1884  throw(OP_WITH_WRONG_DIM);
1885 #else
1886  throw();
1887 #endif
1888  INLINE void accumulate(idotprecision &dp, const rvector_slice & rv1, const l_rmatrix_subv &rv2)
1890 #if(CXSC_INDEX_CHECK)
1891  throw(OP_WITH_WRONG_DIM);
1892 #else
1893  throw();
1894 #endif
1895  INLINE void accumulate(idotprecision &dp, const l_rvector_slice & rv1, const rmatrix_subv &rv2)
1897 #if(CXSC_INDEX_CHECK)
1898  throw(OP_WITH_WRONG_DIM);
1899 #else
1900  throw();
1901 #endif
1902  INLINE void accumulate(idotprecision &dp,const l_rvector &rv,const rvector_slice &sl)
1904 #if(CXSC_INDEX_CHECK)
1905  throw(OP_WITH_WRONG_DIM);
1906 #else
1907  throw();
1908 #endif
1909  INLINE void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const l_rvector &rv2)
1911 #if(CXSC_INDEX_CHECK)
1912  throw(OP_WITH_WRONG_DIM);
1913 #else
1914  throw();
1915 #endif
1916  INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const rvector &rv2)
1918 #if(CXSC_INDEX_CHECK)
1919  throw(OP_WITH_WRONG_DIM);
1920 #else
1921  throw();
1922 #endif
1923  INLINE void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const l_rvector_slice &rv2)
1925 #if(CXSC_INDEX_CHECK)
1926  throw(OP_WITH_WRONG_DIM);
1927 #else
1928  throw();
1929 #endif
1930  INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const rvector_slice &rv2)
1932 #if(CXSC_INDEX_CHECK)
1933  throw(OP_WITH_WRONG_DIM);
1934 #else
1935  throw();
1936 #endif
1937  INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl1, const rvector_slice &sl2)
1939 #if(CXSC_INDEX_CHECK)
1940  throw(OP_WITH_WRONG_DIM);
1941 #else
1942  throw();
1943 #endif
1944  INLINE void accumulate(idotprecision &dp, const rvector_slice & sl1, const l_rvector_slice &sl2)
1946 #if(CXSC_INDEX_CHECK)
1947  throw(OP_WITH_WRONG_DIM);
1948 #else
1949  throw();
1950 #endif
1951  INLINE void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const l_rmatrix_subv &rv2)
1953 #if(CXSC_INDEX_CHECK)
1954  throw(OP_WITH_WRONG_DIM);
1955 #else
1956  throw();
1957 #endif
1958  INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const rmatrix_subv &rv2)
1960 #if(CXSC_INDEX_CHECK)
1961  throw(OP_WITH_WRONG_DIM);
1962 #else
1963  throw();
1964 #endif
1965 
1967  INLINE l_real operator *(const rvector & rv1, const l_rvector &rv2)
1968 #if(CXSC_INDEX_CHECK)
1969  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1970 #else
1971  throw();
1972 #endif
1973  INLINE l_real operator *(const rvector_slice &sl, const l_rvector &rv)
1975 #if(CXSC_INDEX_CHECK)
1976  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1977 #else
1978  throw();
1979 #endif
1980  INLINE l_real operator *(const rvector &rv, const l_rvector_slice &sl)
1982 #if(CXSC_INDEX_CHECK)
1983  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1984 #else
1985  throw();
1986 #endif
1987  INLINE l_real operator *(const rvector_slice & sl1, const l_rvector_slice &sl2)
1989 #if(CXSC_INDEX_CHECK)
1990  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1991 #else
1992  throw();
1993 #endif
1994 
1996  INLINE l_real operator *(const l_rvector & rv1, const rvector &rv2)
1997 #if(CXSC_INDEX_CHECK)
1998  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
1999 #else
2000  throw();
2001 #endif
2002  INLINE l_real operator *(const l_rvector_slice &sl, const rvector &rv)
2004 #if(CXSC_INDEX_CHECK)
2005  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
2006 #else
2007  throw();
2008 #endif
2009  INLINE l_real operator *(const l_rvector &rv, const rvector_slice &sl)
2011 #if(CXSC_INDEX_CHECK)
2012  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
2013 #else
2014  throw();
2015 #endif
2016  INLINE l_real operator *(const l_rvector_slice & sl1, const rvector_slice &sl2)
2018 #if(CXSC_INDEX_CHECK)
2019  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
2020 #else
2021  throw();
2022 #endif
2023 
2025  INLINE l_rvector operator +(const rvector &rv1, const l_rvector &rv2)
2026 #if(CXSC_INDEX_CHECK)
2027  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
2028 #else
2029  throw();
2030 #endif
2031  INLINE l_rvector operator +(const rvector &rv, const l_rvector_slice &sl)
2033 #if(CXSC_INDEX_CHECK)
2034  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
2035 #else
2036  throw();
2037 #endif
2038  INLINE l_rvector operator +(const rvector_slice &sl, const l_rvector &rv)
2040 #if(CXSC_INDEX_CHECK)
2041  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
2042 #else
2043  throw();
2044 #endif
2045  INLINE l_rvector operator +(const rvector_slice &sl1, const l_rvector_slice &sl2)
2047 #if(CXSC_INDEX_CHECK)
2048  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
2049 #else
2050  throw();
2051 #endif
2052 
2054  INLINE l_rvector operator +(const l_rvector &rv1, const rvector &rv2)
2055 #if(CXSC_INDEX_CHECK)
2056  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
2057 #else
2058  throw();
2059 #endif
2060  INLINE l_rvector operator +(const l_rvector &rv, const rvector_slice &sl)
2062 #if(CXSC_INDEX_CHECK)
2063  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
2064 #else
2065  throw();
2066 #endif
2067  INLINE l_rvector operator +(const l_rvector_slice &sl, const rvector &rv)
2069 #if(CXSC_INDEX_CHECK)
2070  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
2071 #else
2072  throw();
2073 #endif
2074  INLINE l_rvector operator +(const l_rvector_slice &sl1, const rvector_slice &sl2)
2076 #if(CXSC_INDEX_CHECK)
2077  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
2078 #else
2079  throw();
2080 #endif
2081 
2083  INLINE l_rvector & operator +=(l_rvector &rv1, const rvector &rv2)
2084 #if(CXSC_INDEX_CHECK)
2085  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
2086 #else
2087  throw();
2088 #endif
2089  INLINE l_rvector &operator +=(l_rvector &rv, const rvector_slice &sl)
2091 #if(CXSC_INDEX_CHECK)
2092  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
2093 #else
2094  throw();
2095 #endif
2096 
2098  INLINE l_rvector operator -(const rvector &rv1, const l_rvector &rv2)
2099 #if(CXSC_INDEX_CHECK)
2100  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
2101 #else
2102  throw();
2103 #endif
2104  INLINE l_rvector operator -(const rvector &rv, const l_rvector_slice &sl)
2106 #if(CXSC_INDEX_CHECK)
2107  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
2108 #else
2109  throw();
2110 #endif
2111  INLINE l_rvector operator -(const rvector_slice &sl, const l_rvector &rv)
2113 #if(CXSC_INDEX_CHECK)
2114  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
2115 #else
2116  throw();
2117 #endif
2118  INLINE l_rvector operator -(const rvector_slice &sl1, const l_rvector_slice &sl2)
2120 #if(CXSC_INDEX_CHECK)
2121  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
2122 #else
2123  throw();
2124 #endif
2125 
2127  INLINE l_rvector operator -(const l_rvector &rv1, const rvector &rv2)
2128 #if(CXSC_INDEX_CHECK)
2129  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
2130 #else
2131  throw();
2132 #endif
2133  INLINE l_rvector operator -(const l_rvector &rv, const rvector_slice &sl)
2135 #if(CXSC_INDEX_CHECK)
2136  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
2137 #else
2138  throw();
2139 #endif
2140  INLINE l_rvector operator -(const l_rvector_slice &sl, const rvector &rv)
2142 #if(CXSC_INDEX_CHECK)
2143  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
2144 #else
2145  throw();
2146 #endif
2147  INLINE l_rvector operator -(const l_rvector_slice &sl1, const rvector_slice &sl2)
2149 #if(CXSC_INDEX_CHECK)
2150  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
2151 #else
2152  throw();
2153 #endif
2154  INLINE l_rvector & operator -=(l_rvector &rv1, const rvector &rv2)
2156 #if(CXSC_INDEX_CHECK)
2157  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
2158 #else
2159  throw();
2160 #endif
2161  INLINE l_rvector &operator -=(l_rvector &rv, const rvector_slice &sl)
2163 #if(CXSC_INDEX_CHECK)
2164  throw(ERROR__OP_WITH_WRONG_DIM<l_rvector>);
2165 #else
2166  throw();
2167 #endif
2168 
2169 } // namespace cxsc
2170 
2171 #ifdef _CXSC_INCL_INL
2172 #include "vector.inl"
2173 #include "l_rvector.inl"
2174 #endif
2175 
2176 #ifdef _CXSC_RMATRIX_HPP_INCLUDED
2177 # ifdef _CXSC_INCL_INL
2178 # include "lrvecrmat.inl"
2179 # else
2180 # include "lrvecrmat.hpp"
2181 # endif
2182 #endif
2183 
2184 #ifdef _CXSC_IMATRIX_HPP_INCLUDED
2185 # ifdef _CXSC_INCL_INL
2186 # include "cvecimat.inl"
2187 # else
2188 # include "cvecimat.hpp"
2189 # endif
2190 #endif
2191 
2192 #ifdef _CXSC_IVECTOR_HPP_INCLUDED
2193 # ifdef _CXSC_INCL_INL
2194 # include "lrvecivec.inl"
2195 # else
2196 # include "lrvecivec.hpp"
2197 # endif
2198 #endif
2199 
2200 
2201 #endif
2202 
l_rvector_slice & operator()()
Operator for accessing the whole vector.
Definition: l_rvector.hpp:1166
The Multiple-Precision Data Type l_rmatrix_slice.
Definition: l_rmatrix.hpp:999
The Data Type rmatrix_slice.
Definition: rmatrix.hpp:1442
cimatrix & operator/=(cimatrix &m, const cinterval &c)
Implementation of division and allocation operation.
Definition: cimatrix.inl:1623
l_real & operator[](const int &i) const
Operator for accessing the single elements of the vector.
Definition: l_rvector.inl:113
friend int VecLen(const l_rvector &rv)
Returns the dimension of the vector.
Definition: l_rvector.hpp:704
INLINE l_rvector _l_rvector(const rmatrix_subv &rs)
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC...
Definition: l_rmatrix.inl:102
The Multiple-Precision Data Type l_real.
Definition: l_real.hpp:77
The Data Type dotprecision.
Definition: dot.hpp:111
The Multiple-Precision Data Type l_rmatrix_subv.
Definition: l_rmatrix.hpp:46
l_rvector_slice & operator|=(const l_rvector &rv)
Allocates the convex hull of the arguments to the first argument.
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
civector operator*(const cimatrix_subv &rv, const cinterval &s)
Implementation of multiplication operation.
Definition: cimatrix.inl:731
friend int Ub(const l_rvector_slice &sl)
Returns the upper bound of the vector.
Definition: l_rvector.hpp:1155
friend int Lb(const l_rvector_slice &sl)
Returns the lower bound of the vector.
Definition: l_rvector.hpp:1153
friend int Ub(const l_rvector &rv)
Returns the upper bound of the vector.
Definition: l_rvector.hpp:702
The Multiple-Precision Data Type l_ivector.
Definition: l_ivector.hpp:54
friend l_rvector & SetUb(l_rvector &rv, const int &u)
Sets the upper bound of the vector.
Definition: l_rvector.hpp:708
l_rvector_slice & operator&=(const l_rvector &rv)
Allocates the intersection of the arguments to the first argument.
The Data Type rvector_slice.
Definition: rvector.hpp:1063
The Multiple-Precision Data Type l_imatrix.
Definition: l_imatrix.hpp:725
The Data Type rmatrix_subv.
Definition: rmatrix.hpp:53
The Multiple-Precision Data Type l_rmatrix.
Definition: l_rmatrix.hpp:415
The Data Type rvector.
Definition: rvector.hpp:57
l_rvector_slice & operator+=(const l_rvector &rv)
Implementation of addition and allocation operation.
Definition: l_rvector.inl:519
l_rvector_slice & operator*=(const l_real &r)
Implementation of multiplication and allocation operation.
Definition: l_rvector.inl:306
l_rvector & operator()()
Operator for accessing the whole vector.
Definition: l_rvector.hpp:717
l_rvector_slice & operator-=(const l_rvector &rv)
Implementation of subtraction and allocation operation.
Definition: l_rvector.inl:578
l_rvector_slice & operator/=(const l_real &r)
Implementation of division and allocation operation.
Definition: l_rvector.inl:311
void Resize(cimatrix &A)
Resizes the matrix.
Definition: cimatrix.inl:1211
The Data Type rmatrix.
Definition: rmatrix.hpp:470
l_rvector_slice(const l_rvector_slice &a)
Constructor of class l_rvector_slice.
Definition: l_rvector.hpp:1015
l_rvector_slice(l_rvector &a, const int &lb, const int &ub)
Constructor of class l_rvector_slice.
Definition: l_rvector.hpp:1010
friend l_rvector & SetLb(l_rvector &rv, const int &l)
Sets the lower bound of the vector.
Definition: l_rvector.hpp:706
l_real(void)
Constructor of class l_real.
Definition: l_real.cpp:174
friend int VecLen(const l_rvector_slice &sl)
Returns the dimension of the vector.
Definition: l_rvector.hpp:1157
l_rvector()
Constructor of class l_rvector.
Definition: l_rvector.inl:31
The Multiple-Precision Data Type l_rvector.
Definition: l_rvector.hpp:53
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc)
Implementation of standard algebraic addition and allocation operation.
Definition: cdot.inl:251
l_rvector_slice & operator=(const l_rvector_slice &sl)
Implementation of standard assigning operator.
Definition: l_rvector.inl:240
l_rvector_slice(l_rvector_slice &a, const int &lb, const int &ub)
Constructor of class l_rvector_slice.
Definition: l_rvector.hpp:1012
l_real & operator[](const int &i) const
Operator for accessing the single elements of the vector.
Definition: l_rvector.inl:100
civector operator/(const cimatrix_subv &rv, const cinterval &s)
Implementation of division operation.
Definition: cimatrix.inl:730
cimatrix & operator*=(cimatrix &m, const cinterval &c)
Implementation of multiplication and allocation operation.
Definition: cimatrix.inl:1605
The Scalar Type real.
Definition: real.hpp:113
The Multiple-Precision Data Type l_rvector_slice.
Definition: l_rvector.hpp:744
friend int Lb(const l_rvector &rv)
Returns the lower bound of the vector.
Definition: l_rvector.hpp:700
ivector abs(const cimatrix_subv &mv)
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737
l_rvector & operator=(const l_rvector &rv)
Implementation of standard assigning operator.
Definition: l_rvector.inl:235