C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
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: rvector.hpp,v 1.34 2014/01/30 17:23:48 cxsc Exp $ */
25 
26 #ifndef _CXSC_RVECTOR_HPP_INCLUDED
27 #define _CXSC_RVECTOR_HPP_INCLUDED
28 
29 #include "xscclass.hpp"
30 #include "dot.hpp"
31 #include "idot.hpp"
32 #include "cidot.hpp"
33 #include "real.hpp"
34 #include "except.hpp"
35 #include "vector.hpp"
36 
37 #include <iostream>
38 
39 namespace cxsc {
40 
41 class srvector;
42 class srvector_slice;
43 class rvector_slice;
44 
46 
57 class rvector
58 {
59  friend class cvector;
60  friend class cvector_slice;
61  friend class cmatrix;
62  friend class rvector_slice;
63  friend class rmatrix;
64  friend class rmatrix_subv;
65  friend class ivector;
66  friend class imatrix;
67  friend class l_ivector;
68  friend class l_imatrix;
69  friend class l_rvector;
70  friend class l_rmatrix;
71  friend class civector;
72  friend class cimatrix;
73 //#if(CXSC_INDEX_CHECK)
74  //------------ Templates --------------------------------------------------
75 
76 #ifdef _CXSC_FRIEND_TPL
77 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m)
78 #if(CXSC_INDEX_CHECK)
79  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>);
80 #else
81  throw();
82 #endif
83 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
84 #if(CXSC_INDEX_CHECK)
85  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
86 #else
87  throw();
88 #endif
89  template <class V> friend void _vresize(V &rv) throw();
90  template <class V,class S> friend void _vresize(V &rv, const int &len)
91 #if(CXSC_INDEX_CHECK)
92  throw(ERROR__WRONG_BOUNDARIES<V>);
93 #else
94  throw();
95 #endif
96  template <class V,class S> friend void _vresize(V &rv, const int &lb, const int &ub)
97 #if(CXSC_INDEX_CHECK)
98  throw(ERROR__WRONG_BOUNDARIES<V>);
99 #else
100  throw();
101 #endif
102  template <class V1,class V2,class S> friend V1 &_vvassign(V1 &rv1,const V2 &rv2) throw();
103  template <class V,class S> friend V & _vsassign(V &rv,const S &r) throw();
104  template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) throw();
105  template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv)
106 #if(CXSC_INDEX_CHECK)
107  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
108 #else
109  throw();
110 #endif
111 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m)
112 #if(CXSC_INDEX_CHECK)
113  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
114 #else
115  throw();
116 #endif
117 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) throw();
118 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
119 #if(CXSC_INDEX_CHECK)
120  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
121 #else
122  throw();
123 #endif
124 template <class MV,class V> friend V _mvabs(const MV &mv) throw();
125 
126  //-------- vector-vector -----------------
127  template <class DP,class V1,class V2> friend void _vvaccu(DP &dp, const V1 & rv1, const V2 &rv2)
128 #if(CXSC_INDEX_CHECK)
129  throw(OP_WITH_WRONG_DIM);
130 #else
131  throw();
132 #endif
133  template <class DP,class VS,class V> friend void _vsvaccu(DP &dp, const VS & sl, const V &rv)
134 #if(CXSC_INDEX_CHECK)
135  throw(OP_WITH_WRONG_DIM);
136 #else
137  throw();
138 #endif
139 
140 
141  template <class V1,class V2,class E> friend E _vvmult(const V1 & rv1, const V2 &rv2)
142 #if(CXSC_INDEX_CHECK)
143  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
144 #else
145  throw();
146 #endif
147  template <class VS,class V,class E> friend E _vsvmult(const VS & sl, const V &rv)
148 #if(CXSC_INDEX_CHECK)
149  throw(ERROR__OP_WITH_WRONG_DIM<V>);
150 #else
151  throw();
152 #endif
153  template <class V,class S> friend V &_vsmultassign(V &rv,const S &r) throw();
154  template <class VS,class S> friend VS &_vssmultassign(VS &rv,const S &r) throw();
155  template <class VS,class S> friend VS &_vssdivassign(VS &rv,const S &r) throw();
156  template <class V1,class V2,class E> friend E _vvplus(const V1 &rv1, const V2 &rv2)
157 #if(CXSC_INDEX_CHECK)
158  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
159 #else
160  throw();
161 #endif
162  template <class V,class VS,class E> friend E _vvsplus(const V &rv,const VS &sl)
163 #if(CXSC_INDEX_CHECK)
164  throw(ERROR__OP_WITH_WRONG_DIM<V>);
165 #else
166  throw();
167 #endif
168  template <class VS1,class VS2,class E> friend E _vsvsplus(const VS1 &s1,const VS2 &s2)
169 #if(CXSC_INDEX_CHECK)
170  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
171 #else
172  throw();
173 #endif
174  template <class VS1,class VS2,class E> friend E _vsvsminus(const VS1 &s1,const VS2 &s2)
175 #if(CXSC_INDEX_CHECK)
176  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
177 #else
178  throw();
179 #endif
180  template <class V1,class V2> friend V1 &_vvplusassign(V1 &rv1, const V2 &rv2)
181 #if(CXSC_INDEX_CHECK)
182  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
183 #else
184  throw();
185 #endif
186  template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl)
187 #if(CXSC_INDEX_CHECK)
188  throw(ERROR__OP_WITH_WRONG_DIM<V>);
189 #else
190  throw();
191 #endif
192  template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv)
193 #if(CXSC_INDEX_CHECK)
194  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
195 #else
196  throw();
197 #endif
198  template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
199 #if(CXSC_INDEX_CHECK)
200  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
201 #else
202  throw();
203 #endif
204  template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
205 #if(CXSC_INDEX_CHECK)
206  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
207 #else
208  throw();
209 #endif
210  template <class V1,class V2> friend V1 &_vvminusassign(V1 &rv1, const V2 &rv2)
211 #if(CXSC_INDEX_CHECK)
212  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
213 #else
214  throw();
215 #endif
216  template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl)
217 #if(CXSC_INDEX_CHECK)
218  throw(ERROR__OP_WITH_WRONG_DIM<V>);
219 #else
220  throw();
221 #endif
222  template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv)
223 #if(CXSC_INDEX_CHECK)
224  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
225 #else
226  throw();
227 #endif
228  template <class V> friend V _vminus(const V &rv) throw();
229  template <class VS,class V> friend V _vsminus(const VS &sl) throw();
230  template <class V1,class V2,class E> friend E _vvminus(const V1 &rv1, const V2 &rv2)
231 #if(CXSC_INDEX_CHECK)
232  throw(ERROR__OP_WITH_WRONG_DIM<E>);
233 #else
234  throw();
235 #endif
236  template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl)
237 #if(CXSC_INDEX_CHECK)
238  throw(ERROR__OP_WITH_WRONG_DIM<E>);
239 #else
240  throw();
241 #endif
242  template <class VS,class V,class E> friend E _vsvminus(const VS &sl,const V &rv)
243 #if(CXSC_INDEX_CHECK)
244  throw(ERROR__OP_WITH_WRONG_DIM<E>);
245 #else
246  throw();
247 #endif
248  template <class MV1,class MV2,class E> friend E _mvmvconv(const MV1 &rv1, const MV2 &rv2)
249 #if(CXSC_INDEX_CHECK)
250  throw(ERROR__OP_WITH_WRONG_DIM<E>);
251 #else
252  throw();
253 #endif
254  template <class MV,class V,class E> friend E _mvvconv(const MV &rv1, const V &rv2)
255 #if(CXSC_INDEX_CHECK)
256  throw(ERROR__OP_WITH_WRONG_DIM<E>);
257 #else
258  throw();
259 #endif
260 template <class V,class MV> friend V &_vmvconvassign(V &rv,const MV &v)
261 #if(CXSC_INDEX_CHECK)
262  throw(ERROR__OP_WITH_WRONG_DIM<V>);
263 #else
264  throw();
265 #endif
266 
267  template <class M,class V,class E> friend E _mvmult(const M &m,const V &v)
268 #if(CXSC_INDEX_CHECK)
269  throw(ERROR__OP_WITH_WRONG_DIM<M>);
270 #else
271  throw();
272 #endif
273  template <class M,class V,class E> friend E _mvimult(const M &m,const V &v)
274 #if(CXSC_INDEX_CHECK)
275  throw(ERROR__OP_WITH_WRONG_DIM<M>);
276 #else
277  throw();
278 #endif
279  template <class M,class V,class E> friend E _mvcmult(const M &m,const V &v)
280 #if(CXSC_INDEX_CHECK)
281  throw(ERROR__OP_WITH_WRONG_DIM<M>);
282 #else
283  throw();
284 #endif
285  template <class M,class V,class E> friend E _mvcimult(const M &m,const V &v)
286 #if(CXSC_INDEX_CHECK)
287  throw(ERROR__OP_WITH_WRONG_DIM<M>);
288 #else
289  throw();
290 #endif
291  template <class V,class M,class E> friend E _vmmult(const V &v,const M &m)
292 #if(CXSC_INDEX_CHECK)
293  throw(ERROR__OP_WITH_WRONG_DIM<M>);
294 #else
295  throw();
296 #endif
297  template <class V,class M,class E> friend E _vmimult(const V &v,const M &m)
298 #if(CXSC_INDEX_CHECK)
299  throw(ERROR__OP_WITH_WRONG_DIM<M>);
300 #else
301  throw();
302 #endif
303  template <class V,class M,class E> friend E _vmcmult(const V &v,const M &m)
304 #if(CXSC_INDEX_CHECK)
305  throw(ERROR__OP_WITH_WRONG_DIM<M>);
306 #else
307  throw();
308 #endif
309  template <class V,class M,class E> friend E _vmcimult(const V &v,const M &m)
310 #if(CXSC_INDEX_CHECK)
311  throw(ERROR__OP_WITH_WRONG_DIM<M>);
312 #else
313  throw();
314 #endif
315  template <class V,class M,class S> friend V &_vmmultassign(V &v,const M &m)
316 #if(CXSC_INDEX_CHECK)
317  throw(ERROR__OP_WITH_WRONG_DIM<M>);
318 #else
319  throw();
320 #endif
321  template <class V,class M,class S> friend V &_vmimultassign(V &v,const M &m)
322 #if(CXSC_INDEX_CHECK)
323  throw(ERROR__OP_WITH_WRONG_DIM<M>);
324 #else
325  throw();
326 #endif
327  template <class V,class M,class S> friend V &_vmcmultassign(V &v,const M &m)
328 #if(CXSC_INDEX_CHECK)
329  throw(ERROR__OP_WITH_WRONG_DIM<M>);
330 #else
331  throw();
332 #endif
333  template <class V,class M,class S> friend V &_vmcimultassign(V &v,const M &m)
334 #if(CXSC_INDEX_CHECK)
335  throw(ERROR__OP_WITH_WRONG_DIM<M>);
336 #else
337  throw();
338 #endif
339  template <class MS,class V,class E> friend E _msvmult(const MS &ms,const V &v)
340 #if(CXSC_INDEX_CHECK)
341  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
342 #else
343  throw();
344 #endif
345  template <class MS,class V,class E> friend E _msvimult(const MS &ms,const V &v)
346 #if(CXSC_INDEX_CHECK)
347  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
348 #else
349  throw();
350 #endif
351  template <class MS,class V,class E> friend E _msvcmult(const MS &ms,const V &v)
352 #if(CXSC_INDEX_CHECK)
353  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
354 #else
355  throw();
356 #endif
357  template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v)
358 #if(CXSC_INDEX_CHECK)
359  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
360 #else
361  throw();
362 #endif
363  template <class V,class MS,class E> friend E _vmsmult(const V &v,const MS &ms)
364 #if(CXSC_INDEX_CHECK)
365  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
366 #else
367  throw();
368 #endif
369  template <class V,class MS,class E> friend E _vmsimult(const V &v,const MS &ms)
370 #if(CXSC_INDEX_CHECK)
371  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
372 #else
373  throw();
374 #endif
375  template <class V,class MS,class E> friend E _vmscmult(const V &v,const MS &ms)
376 #if(CXSC_INDEX_CHECK)
377  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
378 #else
379  throw();
380 #endif
381  template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms)
382 #if(CXSC_INDEX_CHECK)
383  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
384 #else
385  throw();
386 #endif
387  template <class V,class MS,class S> friend V &_vmsmultassign(V &v,const MS &ms)
388 #if(CXSC_INDEX_CHECK)
389  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
390 #else
391  throw();
392 #endif
393  template <class V,class MS,class S> friend V &_vmsimultassign(V &v,const MS &ms)
394 #if(CXSC_INDEX_CHECK)
395  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
396 #else
397  throw();
398 #endif
399  template <class V,class MS,class S> friend V &_vmscmultassign(V &v,const MS &ms)
400 #if(CXSC_INDEX_CHECK)
401  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
402 #else
403  throw();
404 #endif
405  template <class V,class MS,class S> friend V &_vmscimultassign(V &v,const MS &ms)
406 #if(CXSC_INDEX_CHECK)
407  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
408 #else
409  throw();
410 #endif
411  template <class V,class MV,class S> friend S _vmvmult(const V &rv1, const MV &rv2)
412 #if(CXSC_INDEX_CHECK)
413  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
414 #else
415  throw();
416 #endif
417  template <class V,class MV,class S> friend S _vmvimult(const V &rv1, const MV &rv2)
418 #if(CXSC_INDEX_CHECK)
419  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
420 #else
421  throw();
422 #endif
423  template <class V,class MV,class S> friend S _vmvcmult(const V &rv1, const MV &rv2)
424 #if(CXSC_INDEX_CHECK)
425  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
426 #else
427  throw();
428 #endif
429  template <class V,class MV,class S> friend S _vmvcimult(const V &rv1, const MV &rv2)
430 #if(CXSC_INDEX_CHECK)
431  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
432 #else
433  throw();
434 #endif
435  template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) throw();
436  template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
437 #if(CXSC_INDEX_CHECK)
438  throw(ERROR__OP_WITH_WRONG_DIM<E>);
439 #else
440  throw();
441 #endif
442  template <class MV,class V,class E> friend E _mvvplus(const MV &rv1, const V &rv2)
443 #if(CXSC_INDEX_CHECK)
444  throw(ERROR__OP_WITH_WRONG_DIM<E>);
445 #else
446  throw();
447 #endif
448  template <class MV,class V,class E> friend E _mvvminus(const MV &rv1, const V &rv2)
449 #if(CXSC_INDEX_CHECK)
450  throw(ERROR__OP_WITH_WRONG_DIM<E>);
451 #else
452  throw();
453 #endif
454  template <class V,class MV,class E> friend E _vmvminus(const V &rv1, const MV &rv2)
455 #if(CXSC_INDEX_CHECK)
456  throw(ERROR__OP_WITH_WRONG_DIM<E>);
457 #else
458  throw();
459 #endif
460  template <class MV1,class MV2,class E> friend E _mvmvminus(const MV1 &rv1, const MV2 &rv2)
461 #if(CXSC_INDEX_CHECK)
462  throw(ERROR__OP_WITH_WRONG_DIM<E>);
463 #else
464  throw();
465 #endif
466 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
467 #if(CXSC_INDEX_CHECK)
468  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
469 #else
470  throw();
471 #endif
472 template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv)
473 #if(CXSC_INDEX_CHECK)
474  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
475 #else
476  throw();
477 #endif
478 
479  template <class V1,class V2,class E> friend E _vvconv(const V1 &rv1, const V2 &rv2)
480 #if(CXSC_INDEX_CHECK)
481  throw(ERROR__OP_WITH_WRONG_DIM<E>);
482 #else
483  throw();
484 #endif
485  template <class V,class VS,class E> friend E _vvsconv(const V &rv,const VS &sl)
486 #if(CXSC_INDEX_CHECK)
487  throw(ERROR__OP_WITH_WRONG_DIM<E>);
488 #else
489  throw();
490 #endif
491 
492 template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
493 #if(CXSC_INDEX_CHECK)
494  throw(OP_WITH_WRONG_DIM);
495 #else
496  throw();
497 #endif
498 
499  //--------- vector-scalar ----------------
500  template <class V,class S> friend V &_vsdivassign(V &rv,const S &r) throw();
501  template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) throw();
502  template <class V,class S,class E> friend E _vsmult(const V &rv, const S &s) throw();
503  template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) throw();
504  template <class V1,class V2> friend bool _vveq(const V1 &rv1, const V2 &rv2) throw();
505  template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) throw();
506  template <class V1,class V2> friend bool _vvneq(const V1 &rv1, const V2 &rv2) throw();
507  template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) throw();
508  template <class V1,class V2> friend bool _vvless(const V1 &rv1, const V2 &rv2) throw();
509  template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) throw();
510  template <class V1,class V2> friend bool _vvleq(const V1 &rv1, const V2 &rv2) throw();
511  template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) throw();
512  template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) throw();
513  template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) throw();
514  template <class V> friend bool _vnot(const V &rv) throw();
515  template <class V> friend void *_vvoid(const V &rv) throw();
516  template <class V,class E> friend E _vabs(const V &rv) throw();
517  template <class VS,class E> friend E _vsabs(const VS &sl) throw();
518  template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw();
519  template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw();
520  template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw();
521  template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw();
522  template <class VS> friend bool _vsnot(const VS &sl) throw();
523  template <class VS> friend void *_vsvoid(const VS &sl) throw();
524  template <class V> friend std::ostream &_vout(std::ostream &s, const V &rv) throw();
525  template <class V> friend std::istream &_vin(std::istream &s, V &rv) throw();
526 
527 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) throw();
528  template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) throw();
529  // Interval
530 
531 
532 template <class MV,class V> friend MV &_mvvconvassign(MV &v,const V &rv)
533 #if(CXSC_INDEX_CHECK)
534  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
535 #else
536  throw();
537 #endif
538 template <class MV,class V> friend MV &_mvvsectassign(MV &v,const V &rv)
539 #if(CXSC_INDEX_CHECK)
540  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
541 #else
542  throw();
543 #endif
544 
545  //--- Interval ---- vector-vector ----------
546  template <class V1,class V2> friend V1 &_vvsetinf(V1 &rv1, const V2 &rv2)
547 #if(CXSC_INDEX_CHECK)
548  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
549 #else
550  throw();
551 #endif
552  template <class V1,class V2> friend V1 &_vvusetinf(V1 &rv1, const V2 &rv2)
553 #if(CXSC_INDEX_CHECK)
554  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
555 #else
556  throw();
557 #endif
558  template <class V1,class V2> friend V1 &_vvsetsup(V1 &rv1, const V2 &rv2)
559 #if(CXSC_INDEX_CHECK)
560  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
561 #else
562  throw();
563 #endif
564  template <class V1,class V2> friend V1 &_vvusetsup(V1 &rv1, const V2 &rv2)
565 #if(CXSC_INDEX_CHECK)
566  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
567 #else
568  throw();
569 #endif
570  template <class VS,class V> friend VS &_vsvsetinf(VS &sl, const V &rv)
571 #if(CXSC_INDEX_CHECK)
572  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
573 #else
574  throw();
575 #endif
576  template <class VS,class V> friend VS &_vsvusetinf(VS &sl, const V &rv)
577 #if(CXSC_INDEX_CHECK)
578  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
579 #else
580  throw();
581 #endif
582  template <class VS,class V> friend VS &_vsvsetsup(VS &sl, const V &rv)
583 #if(CXSC_INDEX_CHECK)
584  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
585 #else
586  throw();
587 #endif
588  template <class VS,class V> friend VS &_vsvusetsup(VS &sl, const V &rv)
589 #if(CXSC_INDEX_CHECK)
590  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
591 #else
592  throw();
593 #endif
594 template <class MV,class V> friend MV &_mvvsetinf(MV &v,const V &rv)
595 #if(CXSC_INDEX_CHECK)
596  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
597 #else
598  throw();
599 #endif
600 template <class MV,class V> friend MV &_mvvusetinf(MV &v,const V &rv)
601 #if(CXSC_INDEX_CHECK)
602  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
603 #else
604  throw();
605 #endif
606 template <class MV,class V> friend MV &_mvvsetsup(MV &v,const V &rv)
607 #if(CXSC_INDEX_CHECK)
608  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
609 #else
610  throw();
611 #endif
612 template <class MV,class V> friend MV &_mvvusetsup(MV &v,const V &rv)
613 #if(CXSC_INDEX_CHECK)
614  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
615 #else
616  throw();
617 #endif
618  template <class V,class E> friend E _vdiam(const V &rv) throw();
619  template <class V,class E> friend E _vmid(const V &rv) throw();
620  template <class V,class E> friend E _vinf(const V &rv) throw();
621  template <class V,class E> friend E _vsup(const V &rv) throw();
622  template <class VS,class E> friend E _vsdiam(const VS &sl) throw();
623  template <class VS,class E> friend E _vsmid(const VS &sl) throw();
624  template <class VS,class E> friend E _vsinf(const VS &sl) throw();
625  template <class VS,class E> friend E _vssup(const VS &sl) throw();
626 template <class MV,class V> friend V _mvdiam(const MV &mv) throw();
627 template <class MV,class V> friend V _mvmid(const MV &mv) throw();
628 template <class MV,class V> friend V _mvinf(const MV &mv) throw();
629 template <class MV,class V> friend V _mvsup(const MV &mv) throw();
630 
631 
632  template <class V1,class V2,class E> friend E _vvimult(const V1 & rv1, const V2 &rv2)
633 #if(CXSC_INDEX_CHECK)
634  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
635 #else
636  throw();
637 #endif
638  template <class VS,class V,class E> friend E _vsvimult(const VS & sl, const V &rv)
639 #if(CXSC_INDEX_CHECK)
640  throw(ERROR__OP_WITH_WRONG_DIM<V>);
641 #else
642  throw();
643 #endif
644 
645  template <class V1,class V2> friend V1 &_vvconvassign(V1 &rv1, const V2 &rv2)
646 #if(CXSC_INDEX_CHECK)
647  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
648 #else
649  throw();
650 #endif
651  template <class V1,class V2,class E> friend E _vvsect(const V1 &rv1, const V2 &rv2)
652 #if(CXSC_INDEX_CHECK)
653  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
654 #else
655  throw();
656 #endif
657  template <class V,class VS,class E> friend E _vvssect(const V &rv,const VS &sl)
658 #if(CXSC_INDEX_CHECK)
659  throw(ERROR__OP_WITH_WRONG_DIM<E>);
660 #else
661  throw();
662 #endif
663  template <class V1,class V2> friend V1 &_vvsectassign(V1 &rv1, const V2 &rv2)
664 #if(CXSC_INDEX_CHECK)
665  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
666 #else
667  throw();
668 #endif
669 
670  template <class VS1,class VS2,class E> friend E _vsvsconv(const VS1 &s1,const VS2 &s2)
671 #if(CXSC_INDEX_CHECK)
672  throw(ERROR__OP_WITH_WRONG_DIM<E>);
673 #else
674  throw();
675 #endif
676 
677  template <class V,class VS> friend V &_vvsconvassign(V &rv, const VS &sl)
678 #if(CXSC_INDEX_CHECK)
679  throw(ERROR__OP_WITH_WRONG_DIM<V>);
680 #else
681  throw();
682 #endif
683  template <class VS,class V> friend VS &_vsvconvassign(VS &sl, const V &rv)
684 #if(CXSC_INDEX_CHECK)
685  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
686 #else
687  throw();
688 #endif
689  template <class VS1,class VS2> friend VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2)
690 #if(CXSC_INDEX_CHECK)
691  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
692 #else
693  throw();
694 #endif
695 
696  template <class VS,class V> friend VS &_vsvsectassign(VS &sl, const V &rv)
697 #if(CXSC_INDEX_CHECK)
698  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
699 #else
700  throw();
701 #endif
702  //--- Interval ---- vector-scalar ----------
703 
704  template <class V,class S,class E> friend E _vsdiv(const V &rv, const S &s) throw();
705 
706 
707  // complex
708 
709  template <class V,class E> friend E _vim(const V &rv) throw();
710  template <class V,class E> friend E _vre(const V &rv) throw();
711 template <class MV,class V> friend V _mvim(const MV &mv) throw();
712 template <class MV,class V> friend V _mvre(const MV &mv) throw();
713 template <class MV,class V> friend MV &_mvvsetim(MV &v,const V &rv)
714 #if(CXSC_INDEX_CHECK)
715  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
716 #else
717  throw();
718 #endif
719 template <class MV,class V> friend MV &_mvvsetre(MV &v,const V &rv)
720 #if(CXSC_INDEX_CHECK)
721  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
722 #else
723  throw();
724 #endif
725  template <class V1,class V2> friend V1 &_vvsetim(V1 &rv1, const V2 &rv2)
726 #if(CXSC_INDEX_CHECK)
727  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
728 #else
729  throw();
730 #endif
731  template <class V1,class V2> friend V1 &_vvsetre(V1 &rv1, const V2 &rv2)
732 #if(CXSC_INDEX_CHECK)
733  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
734 #else
735  throw();
736 #endif
737  template <class VS,class E> friend E _vsim(const VS &sl) throw();
738  template <class VS,class E> friend E _vsre(const VS &sl) throw();
739  template <class VS,class V> friend VS &_vsvsetim(VS &sl, const V &rv)
740 #if(CXSC_INDEX_CHECK)
741  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
742 #else
743  throw();
744 #endif
745  template <class VS,class V> friend VS &_vsvsetre(VS &sl, const V &rv)
746 #if(CXSC_INDEX_CHECK)
747  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
748 #else
749  throw();
750 #endif
751 
752  //--- complex ---- vector-vector ----------
753  template <class V1,class V2,class E> friend E _vvcmult(const V1 & rv1, const V2 &rv2)
754 #if(CXSC_INDEX_CHECK)
755  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
756 #else
757  throw();
758 #endif
759  template <class VS,class V,class E> friend E _vsvcmult(const VS & sl, const V &rv)
760 #if(CXSC_INDEX_CHECK)
761  throw(ERROR__OP_WITH_WRONG_DIM<V>);
762 #else
763  throw();
764 #endif
765 
766  // 5.10. S.W.
767 
768  //--- complex ---- vector-scalar ----------
769 
770 
771  // cinterval ------------------------------
773  friend INLINE rvector SupRe(const civector &v) throw();
775  friend INLINE rvector SupIm(const civector &v) throw();
777  friend INLINE rvector InfRe(const civector &v) throw();
779  friend INLINE rvector InfIm(const civector &v) throw();
781  friend INLINE rvector SupRe(const civector_slice &v) throw();
783  friend INLINE rvector SupIm(const civector_slice &v) throw();
785  friend INLINE rvector InfRe(const civector_slice &v) throw();
787  friend INLINE rvector InfIm(const civector_slice &v) throw();
788 
789  // vector-vector // 5.10. S.W.
790 
791  template <class V1,class V2,class E> friend E _vvcimult(const V1 & rv1, const V2 &rv2)
792 #if(CXSC_INDEX_CHECK)
793  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
794 #else
795  throw();
796 #endif
797  template <class VS,class V,class E> friend E _vsvcimult(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 
804  template <class VS1,class VS2,class E> friend E _vsvscimult(const VS1 & sl1, const VS2 &sl2)
805 #if(CXSC_INDEX_CHECK)
806  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
807 #else
808  throw();
809 #endif
810  // 5.10. S.W.
811 
812  // vector-matrix
813 
814  //--- l_real ---- vector-matrix ----------
815  template <class V,class MS,class E> friend E _vmslmult(const V &v,const MS &ms)
816 #if(CXSC_INDEX_CHECK)
817  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
818 #else
819  throw();
820 #endif
821  template <class M,class V,class E> friend E _mvlmult(const M &m,const V &v)
822 #if(CXSC_INDEX_CHECK)
823  throw(ERROR__OP_WITH_WRONG_DIM<M>);
824 #else
825  throw();
826 #endif
827  template <class MS,class V,class E> friend E _msvlmult(const MS &ms,const V &v)
828 #if(CXSC_INDEX_CHECK)
829  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
830 #else
831  throw();
832 #endif
833 
834  template <class V,class M,class E> friend E _vmlmult(const V &v,const M &m)
835 #if(CXSC_INDEX_CHECK)
836  throw(ERROR__OP_WITH_WRONG_DIM<M>);
837 #else
838  throw();
839 #endif
840 
841  //--- l_real ---- vector-vector ----------
842  template <class V1,class V2,class E> friend E _vvlmult(const V1 & rv1, const V2 &rv2)
843 #if(CXSC_INDEX_CHECK)
844  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
845 #else
846  throw();
847 #endif
848  template <class VS,class V,class E> friend E _vsvlmult(const VS & sl, const V &rv)
849 #if(CXSC_INDEX_CHECK)
850  throw(ERROR__OP_WITH_WRONG_DIM<V>);
851 #else
852  throw();
853 #endif
854 
855  // vector-vector
856 
857  template <class V1,class V2,class E> friend E _vvlimult(const V1 & rv1, const V2 &rv2)
858 #if(CXSC_INDEX_CHECK)
859  throw(ERROR__OP_WITH_WRONG_DIM<V1>);
860 #else
861  throw();
862 #endif
863  template <class VS,class V,class E> friend E _vsvlimult(const VS & sl, const V &rv)
864 #if(CXSC_INDEX_CHECK)
865  throw(ERROR__OP_WITH_WRONG_DIM<V>);
866 #else
867  throw();
868 #endif
869 
870  template <class VS1,class VS2,class E> friend E _vsvslimult(const VS1 & sl1, const VS2 &sl2)
871 #if(CXSC_INDEX_CHECK)
872  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
873 #else
874  throw();
875 #endif
876 
877  // vector-matrix
878  template <class M,class V,class E> friend E _mvlimult(const M &m,const V &v)
879 #if(CXSC_INDEX_CHECK)
880  throw(ERROR__OP_WITH_WRONG_DIM<M>);
881 #else
882  throw();
883 #endif
884  template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v)
885 #if(CXSC_INDEX_CHECK)
886  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
887 #else
888  throw();
889 #endif
890  template <class V,class M,class E> friend E _vmlimult(const V &v,const M &m)
891 #if(CXSC_INDEX_CHECK)
892  throw(ERROR__OP_WITH_WRONG_DIM<M>);
893 #else
894  throw();
895 #endif
896  template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms)
897 #if(CXSC_INDEX_CHECK)
898  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
899 #else
900  throw();
901 #endif
902 #endif
903 
904  private:
905  real *dat;
906  int l,u,size;
907 
908  public:
909  double* to_blas_array() const { return (double*)dat; }
910  //------ Konstruktoren ----------------------------------------------------
912  INLINE rvector () throw();
914  explicit INLINE rvector(const int &i) throw();
915 #ifdef OLD_CXSC
916  explicit INLINE rvector(const class index &i) throw(); // for backwards compatibility
918 #endif
919  explicit INLINE rvector(const int &i1,const int &i2)
921 #if(CXSC_INDEX_CHECK)
922  throw(ERROR_RVECTOR_WRONG_BOUNDARIES,ERROR_RVECTOR_NO_MORE_MEMORY);
923 #else
924  throw();
925 #endif
926  INLINE rvector(const rmatrix_subv &) throw();
929  explicit INLINE rvector(const real &) throw();
931  explicit INLINE rvector(const rmatrix &)
932 #if(CXSC_INDEX_CHECK)
933  throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
934 #else
935  throw();
936 #endif
937  explicit INLINE rvector(const rmatrix_slice &sl)
939 #if(CXSC_INDEX_CHECK)
940  throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
941 #else
942  throw();
943 #endif
944 
946  INLINE rvector(const intvector&);
947 
949  INLINE rvector(const rvector_slice &rs) throw();
951  INLINE rvector(const rvector &v) throw();
953  INLINE rvector(const srvector &v);
955  INLINE rvector(const srvector_slice &v);
957  INLINE rvector &operator =(const rvector &rv) throw();
959  INLINE rvector &operator =(const rvector_slice &sl) throw();
961  INLINE rvector &operator =(const srvector &rv);
963  INLINE rvector &operator =(const srvector_slice &sl);
965  INLINE rvector &operator =(const real &r) throw();
967  INLINE rvector &operator =(const rmatrix &)
968 #if(CXSC_INDEX_CHECK)
969  throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
970 #else
971  throw();
972 #endif
973  INLINE rvector &operator =(const rmatrix_slice &)
975 #if(CXSC_INDEX_CHECK)
976  throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
977 #else
978  throw();
979 #endif
980  INLINE rvector &operator =(const rmatrix_subv &) throw();
982 
984  INLINE rvector operator()(const intvector& p);
986  INLINE rvector operator()(const intmatrix& P);
987 
988 
989  //--------- Destruktor ----------------------------------------------------
990  INLINE ~rvector() { delete [] dat; }
991 
992  //------ Standardfunktionen -----------------------------------------------
993 
994  friend INLINE real::real(const rvector &)
995 #if(CXSC_INDEX_CHECK)
996  throw(ERROR_RVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_RVECTOR_USE_OF_UNINITIALIZED_OBJ);
997 #else
998  throw();
999 #endif
1000  friend INLINE int Lb(const rvector &rv) throw() { return rv.l; }
1003  friend INLINE int Ub(const rvector &rv) throw() { return rv.u; }
1005  friend INLINE int VecLen(const rvector &rv) throw() { return rv.size; }
1007  friend INLINE rvector &SetLb(rvector &rv, const int &l) throw() { rv.l=l; rv.u=l+rv.size-1; return rv; }
1009  friend INLINE rvector &SetUb(rvector &rv, const int &u) throw() { rv.u=u; rv.l=u-rv.size+1; return rv; }
1011  INLINE real & operator [](const int &i) const
1012 #if(CXSC_INDEX_CHECK)
1013  throw(ERROR_RVECTOR_ELEMENT_NOT_IN_VEC);
1014 #else
1015  throw();
1016 #endif
1017 
1019  INLINE real & operator [](const int &i)
1020 #if(CXSC_INDEX_CHECK)
1021  throw(ERROR_RVECTOR_ELEMENT_NOT_IN_VEC);
1022 #else
1023  throw();
1024 #endif
1025 
1027  INLINE rvector & operator ()() throw() { return *this; }
1029  INLINE rvector_slice operator ()(const int &i)
1030 #if(CXSC_INDEX_CHECK)
1031  throw(ERROR_RVECTOR_SUB_ARRAY_TOO_BIG);
1032 #else
1033  throw();
1034 #endif
1035  INLINE rvector_slice operator ()(const int &i1,const int &i2)
1037 #if(CXSC_INDEX_CHECK)
1038  throw(ERROR_RVECTOR_SUB_ARRAY_TOO_BIG);
1039 #else
1040  throw();
1041 #endif
1042 
1044  INLINE rvector &operator +=(const srvector &rv);
1046  INLINE rvector &operator +=(const srvector_slice &rv);
1048  INLINE rvector &operator -=(const srvector &rv);
1050  INLINE rvector &operator -=(const srvector_slice &rv);
1051 
1052  INLINE operator void*() throw();
1053 //#else
1054 //#endif
1055 };
1056 
1058 
1064 {
1065  friend class rvector;
1066  friend class rmatrix;
1067  friend class ivector;
1068  friend class imatrix;
1069  friend class cvector;
1070  friend class cmatrix;
1071  friend class civector;
1072  friend class cimatrix;
1073  friend class l_rvector;
1074  friend class l_rmatrix;
1075  friend class l_ivector;
1076  friend class l_imatrix;
1077  private:
1078  real *dat;
1079  int l,u,size;
1080  int start,end;
1081 
1082  public:
1083 //#if(CXSC_INDEX_CHECK)
1084 
1085 #ifdef _CXSC_FRIEND_TPL
1086 //------------------------- Templates -------------------------------------------
1087  template <class VS1,class VS2> friend VS1 & _vsvsassign(VS1 &sl1,const VS2 &sl2)
1088 #if(CXSC_INDEX_CHECK)
1089  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1090 #else
1091  throw();
1092 #endif
1093  template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) throw();
1094  template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv)
1095 #if(CXSC_INDEX_CHECK)
1096  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
1097 #else
1098  throw();
1099 #endif
1100  template <class VS,class S> friend VS & _vssassign(VS &sl,const S &r) throw();
1101  template <class VS,class M,class S> friend VS &_vsmmultassign(VS &v,const M &m)
1102 #if(CXSC_INDEX_CHECK)
1103  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1104 #else
1105  throw();
1106 #endif
1107  //-------- vector-scalar ------------------
1108  template <class VS,class S> friend VS &_vssmultassign(VS &rv,const S &r) throw();
1109  template <class VS,class S> friend VS &_vssdivassign(VS &rv,const S &r) throw();
1110 
1111  template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) throw();
1112  template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) throw();
1113  template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) throw();
1114  template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) throw();
1115  template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) throw();
1116  template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) throw();
1117  template <class VS,class E> friend E _vsabs(const VS &sl) throw();
1118  template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) throw();
1119  template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) throw();
1120  template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) throw();
1121  template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) throw();
1122  template <class VS> friend bool _vsnot(const VS &sl) throw();
1123  template <class VS> friend void *_vsvoid(const VS &sl) throw();
1124  template <class V> friend std::ostream &_vsout(std::ostream &s, const V &rv) throw();
1125  template <class V> friend std::istream &_vsin(std::istream &s, V &rv) throw();
1126  //------- vector-vector -----------------
1127  template <class DP,class VS,class V> friend void _vsvaccu(DP &dp, const VS & sl, const V &rv)
1128 #if(CXSC_INDEX_CHECK)
1129  throw(OP_WITH_WRONG_DIM);
1130 #else
1131  throw();
1132 #endif
1133  template <class DP,class VS1,class VS2> friend void _vsvsaccu(DP &dp, const VS1 & sl1, const VS2 &sl2)
1134 #if(CXSC_INDEX_CHECK)
1135  throw(OP_WITH_WRONG_DIM);
1136 #else
1137  throw();
1138 #endif
1139 
1140  template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) throw();
1141  template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) throw();
1142  template <class VS,class V,class E> friend E _vsvmult(const VS & sl, const V &rv)
1143 #if(CXSC_INDEX_CHECK)
1144  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1145 #else
1146  throw();
1147 #endif
1148  template <class V,class VS,class E> friend E _vvsplus(const V &rv,const VS &sl)
1149 #if(CXSC_INDEX_CHECK)
1150  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1151 #else
1152  throw();
1153 #endif
1154  template <class VS1,class VS2,class E> friend E _vsvsplus(const VS1 &s1,const VS2 &s2)
1155 #if(CXSC_INDEX_CHECK)
1156  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1157 #else
1158  throw();
1159 #endif
1160  template <class VS1,class VS2,class E> friend E _vsvsminus(const VS1 &s1,const VS2 &s2)
1161 #if(CXSC_INDEX_CHECK)
1162  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1163 #else
1164  throw();
1165 #endif
1166  template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl)
1167 #if(CXSC_INDEX_CHECK)
1168  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1169 #else
1170  throw();
1171 #endif
1172  template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv)
1173 #if(CXSC_INDEX_CHECK)
1174  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
1175 #else
1176  throw();
1177 #endif
1178  template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
1179 #if(CXSC_INDEX_CHECK)
1180  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1181 #else
1182  throw();
1183 #endif
1184  template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
1185 #if(CXSC_INDEX_CHECK)
1186  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1187 #else
1188  throw();
1189 #endif
1190  template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl)
1191 #if(CXSC_INDEX_CHECK)
1192  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1193 #else
1194  throw();
1195 #endif
1196  template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv)
1197 #if(CXSC_INDEX_CHECK)
1198  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
1199 #else
1200  throw();
1201 #endif
1202  template <class VS,class V> friend V _vsminus(const VS &sl) throw();
1203  template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl)
1204 #if(CXSC_INDEX_CHECK)
1205  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1206 #else
1207  throw();
1208 #endif
1209  template <class VS,class V,class E> friend E _vsvminus(const VS &sl,const V &rv)
1210 #if(CXSC_INDEX_CHECK)
1211  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1212 #else
1213  throw();
1214 #endif
1215  template <class VS1,class VS2,class E> friend E _vsvsmult(const VS1 & sl1, const VS2 &sl2)
1216 #if(CXSC_INDEX_CHECK)
1217  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1218 #else
1219  throw();
1220 #endif
1221 
1222  template <class V,class VS,class E> friend E _vvsconv(const V &rv,const VS &sl)
1223 #if(CXSC_INDEX_CHECK)
1224  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1225 #else
1226  throw();
1227 #endif
1228  template <class VS1,class VS2,class E> friend E _vsvsconv(const VS1 &s1,const VS2 &s2)
1229 #if(CXSC_INDEX_CHECK)
1230  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1231 #else
1232  throw();
1233 #endif
1234  template <class V,class VS,class E> friend E _vvssect(const V &rv,const VS &sl)
1235 #if(CXSC_INDEX_CHECK)
1236  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1237 #else
1238  throw();
1239 #endif
1240  template <class VS1,class VS2,class E> friend E _vsvssect(const VS1 &s1,const VS2 &s2)
1241 #if(CXSC_INDEX_CHECK)
1242  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1243 #else
1244  throw();
1245 #endif
1246  // interval -----------
1247  template <class V,class VS> friend V &_vvssetinf(V &rv, const VS &sl)
1248 #if(CXSC_INDEX_CHECK)
1249  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1250 #else
1251  throw();
1252 #endif
1253  template <class V,class VS> friend V &_vvsusetinf(V &rv, const VS &sl)
1254 #if(CXSC_INDEX_CHECK)
1255  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1256 #else
1257  throw();
1258 #endif
1259  template <class V,class VS> friend V &_vvssetsup(V &rv, const VS &sl)
1260 #if(CXSC_INDEX_CHECK)
1261  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1262 #else
1263  throw();
1264 #endif
1265  template <class V,class VS> friend V &_vvsusetsup(V &rv, const VS &sl)
1266 #if(CXSC_INDEX_CHECK)
1267  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1268 #else
1269  throw();
1270 #endif
1271  template <class VS1,class VS2> friend VS1 &_vsvssetinf(VS1 &sl1, const VS2 &sl2)
1272 #if(CXSC_INDEX_CHECK)
1273  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1274 #else
1275  throw();
1276 #endif
1277  template <class VS1,class VS2> friend VS1 &_vsvsusetinf(VS1 &sl1, const VS2 &sl2)
1278 #if(CXSC_INDEX_CHECK)
1279  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1280 #else
1281  throw();
1282 #endif
1283  template <class VS1,class VS2> friend VS1 &_vsvssetsup(VS1 &sl1, const VS2 &sl2)
1284 #if(CXSC_INDEX_CHECK)
1285  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1286 #else
1287  throw();
1288 #endif
1289  template <class VS1,class VS2> friend VS1 &_vsvsusetsup(VS1 &sl1, const VS2 &sl2)
1290 #if(CXSC_INDEX_CHECK)
1291  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1292 #else
1293  throw();
1294 #endif
1295  // interval -----------------
1296 
1297 
1298  template <class V,class VS> friend V &_vvsconvassign(V &rv, const VS &sl)
1299 #if(CXSC_INDEX_CHECK)
1300  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1301 #else
1302  throw();
1303 #endif
1304  template <class VS,class V> friend VS &_vsvconvassign(VS &sl, const V &rv)
1305 #if(CXSC_INDEX_CHECK)
1306  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
1307 #else
1308  throw();
1309 #endif
1310  template <class VS1,class VS2> friend VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2)
1311 #if(CXSC_INDEX_CHECK)
1312  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1313 #else
1314  throw();
1315 #endif
1316 
1317  template <class V,class VS> friend V &_vvssectassign(V &rv, const VS &sl)
1318 #if(CXSC_INDEX_CHECK)
1319  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1320 #else
1321  throw();
1322 #endif
1323  template <class VS,class V> friend VS &_vsvsectassign(VS &sl, const V &rv)
1324 #if(CXSC_INDEX_CHECK)
1325  throw(ERROR__OP_WITH_WRONG_DIM<VS>);
1326 #else
1327  throw();
1328 #endif
1329  template <class VS1,class VS2> friend VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2)
1330 #if(CXSC_INDEX_CHECK)
1331  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1332 #else
1333  throw();
1334 #endif
1335  // Interval
1336 
1337  //-- Interval ------- vector-vector ------------
1338 
1339  template <class VS,class V,class E> friend E _vsvimult(const VS & sl, const V &rv)
1340 #if(CXSC_INDEX_CHECK)
1341  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1342 #else
1343  throw();
1344 #endif
1345  template <class VS1,class VS2,class E> friend E _vsvsimult(const VS1 & sl1, const VS2 &sl2)
1346 #if(CXSC_INDEX_CHECK)
1347  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1348 #else
1349  throw();
1350 #endif
1351 
1352  template <class VS1,class VS2> friend VS1 &_vsvssetim(VS1 &sl1, const VS2 &sl2)
1353 #if(CXSC_INDEX_CHECK)
1354  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1355 #else
1356  throw();
1357 #endif
1358  template <class VS1,class VS2> friend VS1 &_vsvssetre(VS1 &sl1, const VS2 &sl2)
1359 #if(CXSC_INDEX_CHECK)
1360  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1361 #else
1362  throw();
1363 #endif
1364  template <class V,class VS> friend V &_vvssetim(V &rv, const VS &sl)
1365 #if(CXSC_INDEX_CHECK)
1366  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1367 #else
1368  throw();
1369 #endif
1370  template <class V,class VS> friend V &_vvssetre(V &rv, const VS &sl)
1371 #if(CXSC_INDEX_CHECK)
1372  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1373 #else
1374  throw();
1375 #endif
1376 
1377  //-- complex ------- vector-vector ------------
1378 
1379  template <class VS,class V,class E> friend E _vsvcmult(const VS & sl, const V &rv)
1380 #if(CXSC_INDEX_CHECK)
1381  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1382 #else
1383  throw();
1384 #endif
1385  template <class VS1,class VS2,class E> friend E _vsvscmult(const VS1 & sl1, const VS2 &sl2)
1386 #if(CXSC_INDEX_CHECK)
1387  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1388 #else
1389  throw();
1390 #endif
1391 
1392  template <class VS,class V,class E> friend E _vsvcimult(const VS & sl, const V &rv)
1393 #if(CXSC_INDEX_CHECK)
1394  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1395 #else
1396  throw();
1397 #endif
1398  template <class VS1,class VS2,class E> friend E _vsvscimult(const VS1 & sl1, const VS2 &sl2)
1399 #if(CXSC_INDEX_CHECK)
1400  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1401 #else
1402  throw();
1403 #endif
1404 
1405  template <class VS,class V,class E> friend E _vsvlmult(const VS & sl, const V &rv)
1406 #if(CXSC_INDEX_CHECK)
1407  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1408 #else
1409  throw();
1410 #endif
1411  template <class VS1,class VS2,class E> friend E _vsvslmult(const VS1 & sl1, const VS2 &sl2)
1412 #if(CXSC_INDEX_CHECK)
1413  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1414 #else
1415  throw();
1416 #endif
1417 
1418  template <class VS,class V,class E> friend E _vsvlimult(const VS & sl, const V &rv)
1419 #if(CXSC_INDEX_CHECK)
1420  throw(ERROR__OP_WITH_WRONG_DIM<V>);
1421 #else
1422  throw();
1423 #endif
1424  template <class VS1,class VS2,class E> friend E _vsvslimult(const VS1 & sl1, const VS2 &sl2)
1425 #if(CXSC_INDEX_CHECK)
1426  throw(ERROR__OP_WITH_WRONG_DIM<VS1>);
1427 #else
1428  throw();
1429 #endif
1430 
1431  // l_interval -- vector-matrix
1432 
1433 
1434 #endif
1435 
1436 
1437  //--------------------- Konstruktoren -----------------------------------
1439  explicit INLINE rvector_slice(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) { }
1441  explicit INLINE rvector_slice(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) { }
1442  public:
1444  INLINE rvector_slice(const rvector_slice &a) throw():dat(a.dat),l(a.l),u(a.u),size(a.size),start(a.start),end(a.end) { }
1445  public:
1447  INLINE rvector_slice & operator =(const rvector_slice &sl)
1448 #if(CXSC_INDEX_CHECK)
1449  throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
1450 #else
1451  throw();
1452 #endif
1453  INLINE rvector_slice & operator =(const rvector &rv)
1455 #if(CXSC_INDEX_CHECK)
1456  throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
1457 #else
1458  throw();
1459 #endif
1460  INLINE rvector_slice & operator =(const srvector &rv);
1463  INLINE rvector_slice & operator =(const srvector_slice &rv);
1465  INLINE rvector_slice & operator =(const real &r) throw();
1467  INLINE rvector_slice & operator =(const rmatrix &m)
1468 #if(CXSC_INDEX_CHECK)
1469  throw(ERROR__OP_WITH_WRONG_DIM<rvector>,ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
1470 #else
1471  throw();
1472 #endif
1473  INLINE rvector_slice & operator =(const rmatrix_slice &m)
1475 #if(CXSC_INDEX_CHECK)
1476  throw(ERROR__OP_WITH_WRONG_DIM<rvector>,ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
1477 #else
1478  throw();
1479 #endif
1480  INLINE rvector_slice &operator =(const rmatrix_subv &) throw();
1482 
1483  //--------------------- Standardfunktionen ------------------------------
1484 
1485  friend INLINE real::real(const rvector_slice &sl)
1486 #if(CXSC_INDEX_CHECK)
1487  throw(ERROR_RVECTOR_TYPE_CAST_OF_THICK_OBJ,ERROR_RVECTOR_USE_OF_UNINITIALIZED_OBJ);
1488 #else
1489  throw();
1490 #endif
1491  friend INLINE int Lb(const rvector_slice &sl) throw() { return sl.start; }
1494  friend INLINE int Ub(const rvector_slice &sl) throw() { return sl.end; }
1496  friend INLINE int VecLen(const rvector_slice &sl) throw() { return sl.end-sl.start+1; }
1498  INLINE real & operator [](const int &i)
1499 #if(CXSC_INDEX_CHECK)
1500  throw(ERROR_RVECTOR_ELEMENT_NOT_IN_VEC);
1501 #else
1502  throw();
1503 #endif
1504 
1506  INLINE real & operator [](const int &i) const
1507 #if(CXSC_INDEX_CHECK)
1508  throw(ERROR_RVECTOR_ELEMENT_NOT_IN_VEC);
1509 #else
1510  throw();
1511 #endif
1512 
1514  INLINE rvector_slice & operator ()() throw() { return *this; }
1516  INLINE rvector_slice operator ()(const int &i)
1517 #if(CXSC_INDEX_CHECK)
1518  throw(ERROR_RVECTOR_SUB_ARRAY_TOO_BIG);
1519 #else
1520  throw();
1521 #endif
1522  INLINE rvector_slice operator ()(const int &i1,const int &i2)
1524 #if(CXSC_INDEX_CHECK)
1525  throw(ERROR_RVECTOR_SUB_ARRAY_TOO_BIG);
1526 #else
1527  throw();
1528 #endif
1529  INLINE rvector_slice &operator /=(const real &r) throw();
1532  INLINE rvector_slice &operator *=(const real &r) throw();
1534  INLINE rvector_slice &operator *=(const rmatrix &m)
1535 #if(CXSC_INDEX_CHECK)
1536  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
1537 #else
1538  throw();
1539 #endif
1540  INLINE rvector_slice &operator +=(const rvector &rv)
1542 #if(CXSC_INDEX_CHECK)
1543  throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
1544 #else
1545  throw();
1546 #endif
1547  INLINE rvector_slice &operator +=(const rvector_slice &sl2)
1549 #if(CXSC_INDEX_CHECK)
1550  throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
1551 #else
1552  throw();
1553 #endif
1554  INLINE rvector_slice &operator -=(const rvector &rv)
1556 #if(CXSC_INDEX_CHECK)
1557  throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
1558 #else
1559  throw();
1560 #endif
1561  INLINE rvector_slice &operator -=(const rvector_slice &sl2)
1563 #if(CXSC_INDEX_CHECK)
1564  throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
1565 #else
1566  throw();
1567 #endif
1568 
1570  INLINE rvector_slice &operator +=(const srvector &rv);
1572  INLINE rvector_slice &operator +=(const srvector_slice &rv);
1574  INLINE rvector_slice &operator -=(const srvector &rv);
1576  INLINE rvector_slice &operator -=(const srvector_slice &rv);
1577 
1578 
1579  INLINE operator void*() throw();
1580 //#else
1581 //#endif
1582 };
1583 
1584 //======================== Vector Functions =============================
1585 
1587  INLINE rvector _rvector(const real &r) throw();
1588 // INLINE rvector _rvector(const rmatrix &m) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
1589 // INLINE rvector _rvector(const rmatrix_slice &sl) throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
1590 
1592  INLINE void Resize(rvector &rv) throw();
1594  INLINE void Resize(rvector &rv, const int &len)
1595 #if(CXSC_INDEX_CHECK)
1596  throw(ERROR__WRONG_BOUNDARIES<rvector>);
1597 #else
1598  throw();
1599 #endif
1600  INLINE void Resize(rvector &rv, const int &lb, const int &ub)
1602 #if(CXSC_INDEX_CHECK)
1603  throw(ERROR__WRONG_BOUNDARIES<rvector>);
1604 #else
1605  throw();
1606 #endif
1607 
1609  INLINE rvector abs(const rvector &rv) throw();
1611  INLINE rvector abs(const rvector_slice &sl) throw();
1613  INLINE bool operator !(const rvector &rv) throw();
1615  INLINE bool operator !(const rvector_slice &sl) throw();
1616 
1617 //======================= Vector / Scalar ===============================
1618 
1620  INLINE rvector operator *(const rvector &rv, const real &s) throw();
1622  INLINE rvector operator *(const rvector_slice &sl, const real &s) throw();
1624  INLINE rvector operator *(const real &s, const rvector &rv) throw();
1626  INLINE rvector operator *(const real &s, const rvector_slice &sl) throw();
1628  INLINE rvector &operator *=(rvector &rv,const real &r) throw();
1629 
1631  INLINE rvector operator /(const rvector &rv, const real &s) throw();
1633  INLINE rvector operator /(const rvector_slice &sl, const real &s) throw();
1635  INLINE rvector &operator /=(rvector &rv,const real &r) throw();
1636 
1637 //======================= Vector / Vector ===============================
1638 
1640  void accumulate(dotprecision &dp, const rvector &);
1641 
1643  void accumulate(dotprecision &dp, const rvector & rv1, const rvector &rv2)
1644 #if(CXSC_INDEX_CHECK)
1645  throw(OP_WITH_WRONG_DIM);
1646 #else
1647  throw();
1648 #endif
1649 
1651  void accumulate_approx(dotprecision &dp, const rvector & rv1, const rvector &rv2);
1652 
1653 
1655  void accumulate(dotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2)
1656 #if(CXSC_INDEX_CHECK)
1657  throw(OP_WITH_WRONG_DIM);
1658 #else
1659  throw();
1660 #endif
1661 
1663  void accumulate_approx(dotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2);
1664 
1665 
1667  void accumulate(dotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2)
1668 #if(CXSC_INDEX_CHECK)
1669  throw(OP_WITH_WRONG_DIM);
1670 #else
1671  throw();
1672 #endif
1673 
1675  void accumulate_approx(dotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2);
1676 
1678  void accumulate(dotprecision &dp,const rvector_slice &sl,const rvector &rv)
1679 #if(CXSC_INDEX_CHECK)
1680  throw(OP_WITH_WRONG_DIM);
1681 #else
1682  throw();
1683 #endif
1684 
1686  void accumulate_approx(dotprecision &dp,const rvector_slice &sl,const rvector &rv);
1687 
1688 
1690  void accumulate(dotprecision &dp,const rvector &rv,const rvector_slice &sl)
1691 #if(CXSC_INDEX_CHECK)
1692  throw(OP_WITH_WRONG_DIM);
1693 #else
1694  throw();
1695 #endif
1696 
1698  void accumulate_approx(dotprecision &dp,const rvector &rv,const rvector_slice &sl);
1699 
1700 
1702  void accumulate(dotprecision &dp, const rvector_slice & sl1, const rvector_slice &sl2)
1703 #if(CXSC_INDEX_CHECK)
1704  throw(OP_WITH_WRONG_DIM);
1705 #else
1706  throw();
1707 #endif
1708 
1710  void accumulate_approx(dotprecision &dp, const rvector_slice & sl1, const rvector_slice &sl2);
1711 
1712 
1714  void accumulate(idotprecision &dp, const rvector & rv1, const rvector &rv2)
1715 #if(CXSC_INDEX_CHECK)
1716  throw(OP_WITH_WRONG_DIM);
1717 #else
1718  throw();
1719 #endif
1720  void accumulate(idotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2)
1722 #if(CXSC_INDEX_CHECK)
1723  throw(OP_WITH_WRONG_DIM);
1724 #else
1725  throw();
1726 #endif
1727  void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2)
1729 #if(CXSC_INDEX_CHECK)
1730  throw(OP_WITH_WRONG_DIM);
1731 #else
1732  throw();
1733 #endif
1734  void accumulate(idotprecision &dp,const rvector_slice &sl,const rvector &rv)
1736 #if(CXSC_INDEX_CHECK)
1737  throw(OP_WITH_WRONG_DIM);
1738 #else
1739  throw();
1740 #endif
1741  void accumulate(idotprecision &dp,const rvector &rv,const rvector_slice &sl)
1743 #if(CXSC_INDEX_CHECK)
1744  throw(OP_WITH_WRONG_DIM);
1745 #else
1746  throw();
1747 #endif
1748  void accumulate(idotprecision &dp, const rvector_slice & sl1, const rvector_slice &sl2)
1750 #if(CXSC_INDEX_CHECK)
1751  throw(OP_WITH_WRONG_DIM);
1752 #else
1753  throw();
1754 #endif
1755 
1757  void accumulate(cdotprecision &dp, const rvector & rv1, const rvector &rv2)
1758 #if(CXSC_INDEX_CHECK)
1759  throw(OP_WITH_WRONG_DIM);
1760 #else
1761  throw();
1762 #endif
1763 
1765  void accumulate_approx(cdotprecision &dp, const rvector & rv1, const rvector &rv2);
1766 
1768  void accumulate(cdotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2)
1769 #if(CXSC_INDEX_CHECK)
1770  throw(OP_WITH_WRONG_DIM);
1771 #else
1772  throw();
1773 #endif
1774 
1776  void accumulate_approx(cdotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2);
1777 
1779  void accumulate(cdotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2)
1780 #if(CXSC_INDEX_CHECK)
1781  throw(OP_WITH_WRONG_DIM);
1782 #else
1783  throw();
1784 #endif
1785 
1787  void accumulate_approx(cdotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2);
1788 
1790  void accumulate(cdotprecision &dp,const rvector_slice &sl,const rvector &rv)
1791 #if(CXSC_INDEX_CHECK)
1792  throw(OP_WITH_WRONG_DIM);
1793 #else
1794  throw();
1795 #endif
1796 
1798  void accumulate_approx(cdotprecision &dp,const rvector_slice &sl,const rvector &rv);
1799 
1801  void accumulate(cdotprecision &dp,const rvector &rv,const rvector_slice &sl)
1802 #if(CXSC_INDEX_CHECK)
1803  throw(OP_WITH_WRONG_DIM);
1804 #else
1805  throw();
1806 #endif
1807 
1809  void accumulate_approx(cdotprecision &dp,const rvector &rv,const rvector_slice &sl);
1810 
1812  void accumulate(cdotprecision &dp, const rvector_slice & sl1, const rvector_slice &sl2)
1813 #if(CXSC_INDEX_CHECK)
1814  throw(OP_WITH_WRONG_DIM);
1815 #else
1816  throw();
1817 #endif
1818 
1820  void accumulate_approx(cdotprecision &dp, const rvector_slice & sl1, const rvector_slice &sl2);
1821 
1823  void accumulate(cidotprecision &dp, const rvector & rv1, const rvector &rv2)
1824 #if(CXSC_INDEX_CHECK)
1825  throw(OP_WITH_WRONG_DIM);
1826 #else
1827  throw();
1828 #endif
1829  void accumulate(cidotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2)
1831 #if(CXSC_INDEX_CHECK)
1832  throw(OP_WITH_WRONG_DIM);
1833 #else
1834  throw();
1835 #endif
1836  void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2)
1838 #if(CXSC_INDEX_CHECK)
1839  throw(OP_WITH_WRONG_DIM);
1840 #else
1841  throw();
1842 #endif
1843  void accumulate(cidotprecision &dp,const rvector_slice &sl,const rvector &rv)
1845 #if(CXSC_INDEX_CHECK)
1846  throw(OP_WITH_WRONG_DIM);
1847 #else
1848  throw();
1849 #endif
1850  void accumulate(cidotprecision &dp,const rvector &rv,const rvector_slice &sl)
1852 #if(CXSC_INDEX_CHECK)
1853  throw(OP_WITH_WRONG_DIM);
1854 #else
1855  throw();
1856 #endif
1857  void accumulate(cidotprecision &dp, const rvector_slice & sl1, const rvector_slice &sl2)
1859 #if(CXSC_INDEX_CHECK)
1860  throw(OP_WITH_WRONG_DIM);
1861 #else
1862  throw();
1863 #endif
1864 
1866  INLINE real operator *(const rvector & rv1, const rvector &rv2)
1867 #if(CXSC_INDEX_CHECK)
1868  throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
1869 #else
1870  throw();
1871 #endif
1872  INLINE real operator *(const rvector_slice &sl, const rvector &rv)
1874 #if(CXSC_INDEX_CHECK)
1875  throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
1876 #else
1877  throw();
1878 #endif
1879  INLINE real operator *(const rvector &rv, const rvector_slice &sl)
1881 #if(CXSC_INDEX_CHECK)
1882  throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
1883 #else
1884  throw();
1885 #endif
1886  INLINE real operator *(const rvector_slice & sl1, const rvector_slice &sl2)
1888 #if(CXSC_INDEX_CHECK)
1889  throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
1890 #else
1891  throw();
1892 #endif
1893 
1895  INLINE const rvector &operator +(const rvector &rv) throw();
1897  INLINE rvector operator +(const rvector_slice &sl) throw();
1899  INLINE rvector operator +(const rvector &rv1, const rvector &rv2)
1900 #if(CXSC_INDEX_CHECK)
1901  throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
1902 #else
1903  throw();
1904 #endif
1905  INLINE rvector operator +(const rvector &rv, const rvector_slice &sl)
1907 #if(CXSC_INDEX_CHECK)
1908  throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
1909 #else
1910  throw();
1911 #endif
1912  INLINE rvector operator +(const rvector_slice &sl, const rvector &rv)
1914 #if(CXSC_INDEX_CHECK)
1915  throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
1916 #else
1917  throw();
1918 #endif
1919  INLINE rvector operator +(const rvector_slice &sl1, const rvector_slice &sl2)
1921 #if(CXSC_INDEX_CHECK)
1922  throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
1923 #else
1924  throw();
1925 #endif
1926  INLINE rvector & operator +=(rvector &rv1, const rvector &rv2)
1928 #if(CXSC_INDEX_CHECK)
1929  throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
1930 #else
1931  throw();
1932 #endif
1933  INLINE rvector &operator +=(rvector &rv, const rvector_slice &sl)
1935 #if(CXSC_INDEX_CHECK)
1936  throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
1937 #else
1938  throw();
1939 #endif
1940 
1942  INLINE rvector operator -(const rvector &rv) throw();
1944  INLINE rvector operator -(const rvector_slice &sl) throw();
1946  INLINE rvector operator -(const rvector &rv1, const rvector &rv2)
1947 #if(CXSC_INDEX_CHECK)
1948  throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
1949 #else
1950  throw();
1951 #endif
1952  INLINE rvector operator -(const rvector &rv, const rvector_slice &sl)
1954 #if(CXSC_INDEX_CHECK)
1955  throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
1956 #else
1957  throw();
1958 #endif
1959  INLINE rvector operator -(const rvector_slice &sl, const rvector &rv)
1961 #if(CXSC_INDEX_CHECK)
1962  throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
1963 #else
1964  throw();
1965 #endif
1966  INLINE rvector operator -(const rvector_slice &sl1, const rvector_slice &sl2)
1968 #if(CXSC_INDEX_CHECK)
1969  throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
1970 #else
1971  throw();
1972 #endif
1973  INLINE rvector & operator -=(rvector &rv1, const rvector &rv2)
1975 #if(CXSC_INDEX_CHECK)
1976  throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
1977 #else
1978  throw();
1979 #endif
1980  INLINE rvector &operator -=(rvector &rv, const rvector_slice &sl)
1982 #if(CXSC_INDEX_CHECK)
1983  throw(ERROR__OP_WITH_WRONG_DIM<rvector>);
1984 #else
1985  throw();
1986 #endif
1987 
1989  INLINE bool operator ==(const rvector &rv1, const rvector &rv2) throw();
1991  INLINE bool operator ==(const rvector_slice &sl1, const rvector_slice &sl2) throw();
1993  INLINE bool operator ==(const rvector_slice &sl, const rvector &rv) throw();
1995  INLINE bool operator ==(const rvector &rv, const rvector_slice &sl) throw();
1997  INLINE bool operator !=(const rvector &rv1, const rvector &rv2) throw();
1999  INLINE bool operator !=(const rvector_slice &sl1, const rvector_slice &sl2) throw();
2001  INLINE bool operator !=(const rvector_slice &sl, const rvector &rv) throw();
2003  INLINE bool operator !=(const rvector &rv, const rvector_slice &sl) throw();
2005  INLINE bool operator <(const rvector &rv1, const rvector &rv2) throw();
2007  INLINE bool operator <(const rvector_slice &sl1, const rvector_slice &sl2) throw();
2009  INLINE bool operator < (const rvector_slice &sl, const rvector &rv) throw();
2011  INLINE bool operator < (const rvector &rv, const rvector_slice &sl) throw();
2013  INLINE bool operator <=(const rvector &rv1, const rvector &rv2) throw();
2015  INLINE bool operator <=(const rvector_slice &sl1, const rvector_slice &sl2) throw();
2017  INLINE bool operator <=(const rvector_slice &sl, const rvector &rv) throw();
2019  INLINE bool operator <=(const rvector &rv, const rvector_slice &sl) throw();
2021  INLINE bool operator >(const rvector &rv1, const rvector &rv2) throw();
2023  INLINE bool operator >(const rvector_slice &sl1, const rvector_slice &sl2) throw();
2025  INLINE bool operator >(const rvector_slice &sl, const rvector &rv) throw();
2027  INLINE bool operator >(const rvector &rv, const rvector_slice &sl) throw();
2029  INLINE bool operator >=(const rvector &rv1, const rvector &rv2) throw();
2031  INLINE bool operator >=(const rvector_slice &sl1, const rvector_slice &sl2) throw();
2033  INLINE bool operator >=(const rvector_slice &sl, const rvector &rv) throw();
2035  INLINE bool operator >=(const rvector &rv, const rvector_slice &sl) throw();
2036 
2038  INLINE std::ostream &operator <<(std::ostream &s, const rvector &rv) throw();
2040  INLINE std::ostream &operator <<(std::ostream &o, const rvector_slice &sl) throw();
2042  INLINE std::istream &operator >>(std::istream &s, rvector &rv) throw();
2044  INLINE std::istream &operator >>(std::istream &s, rvector_slice &rv) throw();
2045 
2046 
2047 } // namespace cxsc
2048 
2049 #ifdef _CXSC_INCL_INL
2050 #include "rvector.inl"
2051 #include "vector.inl"
2052 #endif
2053 
2054 #ifdef CXSC_USE_BLAS
2055 #define _CXSC_BLAS_RVECTOR
2056 #include "cxsc_blas.inl"
2057 #endif
2058 
2059 #endif
cxsc::rvector_slice::operator=
rvector_slice & operator=(const rvector_slice &sl)
Implementation of standard assigning operator.
Definition: rvector.inl:258
cxsc::rvector_slice::Ub
friend int Ub(const rvector_slice &sl)
Returns the upper bound of the vector.
Definition: rvector.hpp:1494
cxsc::civector_slice
The Data Type civector_slice.
Definition: civector.hpp:1014
cxsc::rvector::SetUb
friend rvector & SetUb(rvector &rv, const int &u)
Sets the upper bound of the vector.
Definition: rvector.hpp:1009
cxsc::rvector::SupIm
friend rvector SupIm(const civector &v)
Returns componentwise the supremum of the imaginary part.
Definition: civector.inl:637
cxsc::srvector
A sparse real vector.
Definition: srvector.hpp:58
cxsc::cmatrix
The Data Type cmatrix.
Definition: cmatrix.hpp:513
cxsc::operator*=
cimatrix & operator*=(cimatrix &m, const cinterval &c)
Implementation of multiplication and allocation operation.
Definition: cimatrix.inl:1605
cxsc::rvector::operator=
rvector & operator=(const rvector &rv)
Implementation of standard assigning operator.
Definition: rvector.inl:254
cxsc::rvector_slice::Lb
friend int Lb(const rvector_slice &sl)
Returns the lower bound of the vector.
Definition: rvector.hpp:1492
cxsc::rvector::SetLb
friend rvector & SetLb(rvector &rv, const int &l)
Sets the lower bound of the vector.
Definition: rvector.hpp:1007
cxsc::rvector::rvector
rvector()
Constructor of class rvector.
Definition: rvector.inl:37
cxsc::rvector_slice::VecLen
friend int VecLen(const rvector_slice &sl)
Returns the dimension of the vector.
Definition: rvector.hpp:1496
cxsc::real::real
real(void)
Constructor of class real.
Definition: real.hpp:122
cxsc::intvector
The Data Type intvector.
Definition: intvector.hpp:51
cxsc::rmatrix
The Data Type rmatrix.
Definition: rmatrix.hpp:470
cxsc::cvector
The Data Type cvector.
Definition: cvector.hpp:57
cxsc::rvector_slice::operator[]
real & operator[](const int &i)
Operator for accessing the single elements of the vector.
Definition: rvector.inl:128
cxsc::rvector_slice::rvector_slice
rvector_slice(rvector_slice &a, const int &lb, const int &ub)
Constructor of class rvector_slice.
Definition: rvector.hpp:1441
cxsc::srvector_slice
Helper class for slices of sparse vectors.
Definition: srvector.hpp:868
cxsc::l_rmatrix
The Multiple-Precision Data Type l_rmatrix.
Definition: l_rmatrix.hpp:415
cxsc::rvector
The Data Type rvector.
Definition: rvector.hpp:57
cxsc::rvector_slice::operator+=
rvector_slice & operator+=(const rvector &rv)
Implementation of addition and allocation operation.
Definition: rvector.inl:397
cxsc::l_imatrix
The Multiple-Precision Data Type l_imatrix.
Definition: l_imatrix.hpp:725
cxsc::rvector::SupRe
friend rvector SupRe(const civector &v)
Returns componentwise the supremum of the real part.
Definition: civector.inl:659
cxsc::rvector::InfRe
friend rvector InfRe(const civector &v)
Returns componentwise the infimum of the real part.
Definition: civector.inl:576
cxsc::rvector_slice
The Data Type rvector_slice.
Definition: rvector.hpp:1063
cxsc::abs
ivector abs(const cimatrix_subv &mv)
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737
cxsc::rvector_slice::operator-=
rvector_slice & operator-=(const rvector &rv)
Implementation of subtraction and allocation operation.
Definition: rvector.inl:456
cxsc::imatrix
The Data Type imatrix.
Definition: imatrix.hpp:659
cxsc::rvector_slice::rvector_slice
rvector_slice(rvector &a, const int &lb, const int &ub)
Constructor of class rvector_slice.
Definition: rvector.hpp:1439
cxsc::accumulate_approx
void accumulate_approx(cdotprecision &dp, const cmatrix_subv &rv1, const cmatrix_subv &rv2)
The accurate scalar product of the last two arguments added to the value of the first argument (witho...
Definition: cmatrix.cpp:99
cxsc::operator*
civector operator*(const cimatrix_subv &rv, const cinterval &s)
Implementation of multiplication operation.
Definition: cimatrix.inl:731
cxsc::rvector::operator[]
real & operator[](const int &i) const
Operator for accessing the single elements of the vector (read-only)
Definition: rvector.inl:102
cxsc::rvector::operator-=
rvector & operator-=(const srvector &rv)
Implementation of addition and allocation operation.
Definition: srvector.hpp:586
cxsc::operator/=
cimatrix & operator/=(cimatrix &m, const cinterval &c)
Implementation of division and allocation operation.
Definition: cimatrix.inl:1623
cxsc::ivector
The Data Type ivector.
Definition: ivector.hpp:54
cxsc::rmatrix_subv
The Data Type rmatrix_subv.
Definition: rmatrix.hpp:53
cxsc::rvector::InfIm
friend rvector InfIm(const civector &v)
Returns componentwise the infimum of the imaginary part.
Definition: civector.inl:616
cxsc
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
cxsc::rvector_slice::operator/=
rvector_slice & operator/=(const real &r)
Implementation of division and allocation operation.
Definition: rvector.inl:316
cxsc::rvector::operator+=
rvector & operator+=(const srvector &rv)
Implementation of addition and allocation operation.
Definition: srvector.hpp:578
cxsc::operator+=
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc)
Implementation of standard algebraic addition and allocation operation.
Definition: cdot.inl:251
cxsc::rvector_slice::operator()
rvector_slice & operator()()
Operator for accessing the whole vector.
Definition: rvector.hpp:1514
cxsc::rmatrix_slice
The Data Type rmatrix_slice.
Definition: rmatrix.hpp:1442
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:53
cxsc::rvector::VecLen
friend int VecLen(const rvector &rv)
Returns the dimension of the vector.
Definition: rvector.hpp:1005
cxsc::rvector_slice::rvector_slice
rvector_slice(const rvector_slice &a)
Constructor of class rvector_slice.
Definition: rvector.hpp:1444
cxsc::rvector::Lb
friend int Lb(const rvector &rv)
Returns the lower bound of the vector.
Definition: rvector.hpp:1001
cxsc::l_ivector
The Multiple-Precision Data Type l_ivector.
Definition: l_ivector.hpp:54
cxsc::cimatrix
The Data Type cimatrix.
Definition: cimatrix.hpp:907
cxsc::cvector_slice
The Data Type cvector_slice.
Definition: cvector.hpp:844
cxsc::rvector::operator()
rvector & operator()()
Operator for accessing the whole vector.
Definition: rvector.hpp:1027
cxsc::rvector::Ub
friend int Ub(const rvector &rv)
Returns the upper bound of the vector.
Definition: rvector.hpp:1003
cxsc::civector
The Data Type civector.
Definition: civector.hpp:56
cxsc::rvector_slice::operator*=
rvector_slice & operator*=(const real &r)
Implementation of multiplication and allocation operation.
Definition: rvector.inl:311
cxsc::intmatrix
The Data Type intmatrix.
Definition: intmatrix.hpp:313
cxsc::Resize
void Resize(cimatrix &A)
Resizes the matrix.
Definition: cimatrix.inl:1211
cxsc::real
The Scalar Type real.
Definition: real.hpp:113
cxsc::_rvector
rvector _rvector(const real &r)
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC.
Definition: rvector.inl:281