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 ;
80 #else
81  noexcept;
82 #endif
83 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
84 #if(CXSC_INDEX_CHECK)
85 ;
86 #else
87  noexcept;
88 #endif
89  template <class V> friend void _vresize(V &rv) noexcept;
90  template <class V,class S> friend void _vresize(V &rv, const int &len)
91 #if(CXSC_INDEX_CHECK)
92  ;
93 #else
94  noexcept;
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  ;
99 #else
100  noexcept;
101 #endif
102  template <class V1,class V2,class S> friend V1 &_vvassign(V1 &rv1,const V2 &rv2) noexcept;
103  template <class V,class S> friend V & _vsassign(V &rv,const S &r) noexcept;
104  template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) noexcept;
105  template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv)
106 #if(CXSC_INDEX_CHECK)
107  ;
108 #else
109  noexcept;
110 #endif
111 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m)
112 #if(CXSC_INDEX_CHECK)
113 ;
114 #else
115  noexcept;
116 #endif
117 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) noexcept;
118 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
119 #if(CXSC_INDEX_CHECK)
120 ;
121 #else
122  noexcept;
123 #endif
124 template <class MV,class V> friend V _mvabs(const MV &mv) noexcept;
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  ;
130 #else
131  noexcept;
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  ;
136 #else
137  noexcept;
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  ;
144 #else
145  noexcept;
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  ;
150 #else
151  noexcept;
152 #endif
153  template <class V,class S> friend V &_vsmultassign(V &rv,const S &r) noexcept;
154  template <class VS,class S> friend VS &_vssmultassign(VS &rv,const S &r) noexcept;
155  template <class VS,class S> friend VS &_vssdivassign(VS &rv,const S &r) noexcept;
156  template <class V1,class V2,class E> friend E _vvplus(const V1 &rv1, const V2 &rv2)
157 #if(CXSC_INDEX_CHECK)
158  ;
159 #else
160  noexcept;
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  ;
165 #else
166  noexcept;
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  ;
171 #else
172  noexcept;
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  ;
177 #else
178  noexcept;
179 #endif
180  template <class V1,class V2> friend V1 &_vvplusassign(V1 &rv1, const V2 &rv2)
181 #if(CXSC_INDEX_CHECK)
182  ;
183 #else
184  noexcept;
185 #endif
186  template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl)
187 #if(CXSC_INDEX_CHECK)
188  ;
189 #else
190  noexcept;
191 #endif
192  template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv)
193 #if(CXSC_INDEX_CHECK)
194  ;
195 #else
196  noexcept;
197 #endif
198  template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
199 #if(CXSC_INDEX_CHECK)
200  ;
201 #else
202  noexcept;
203 #endif
204  template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
205 #if(CXSC_INDEX_CHECK)
206  ;
207 #else
208  noexcept;
209 #endif
210  template <class V1,class V2> friend V1 &_vvminusassign(V1 &rv1, const V2 &rv2)
211 #if(CXSC_INDEX_CHECK)
212  ;
213 #else
214  noexcept;
215 #endif
216  template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl)
217 #if(CXSC_INDEX_CHECK)
218  ;
219 #else
220  noexcept;
221 #endif
222  template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv)
223 #if(CXSC_INDEX_CHECK)
224  ;
225 #else
226  noexcept;
227 #endif
228  template <class V> friend V _vminus(const V &rv) noexcept;
229  template <class VS,class V> friend V _vsminus(const VS &sl) noexcept;
230  template <class V1,class V2,class E> friend E _vvminus(const V1 &rv1, const V2 &rv2)
231 #if(CXSC_INDEX_CHECK)
232  ;
233 #else
234  noexcept;
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  ;
239 #else
240  noexcept;
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  ;
245 #else
246  noexcept;
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  ;
251 #else
252  noexcept;
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  ;
257 #else
258  noexcept;
259 #endif
260 template <class V,class MV> friend V &_vmvconvassign(V &rv,const MV &v)
261 #if(CXSC_INDEX_CHECK)
262 ;
263 #else
264  noexcept;
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  ;
270 #else
271  noexcept;
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  ;
276 #else
277  noexcept;
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  ;
282 #else
283  noexcept;
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  ;
288 #else
289  noexcept;
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  ;
294 #else
295  noexcept;
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  ;
300 #else
301  noexcept;
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  ;
306 #else
307  noexcept;
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  ;
312 #else
313  noexcept;
314 #endif
315  template <class V,class M,class S> friend V &_vmmultassign(V &v,const M &m)
316 #if(CXSC_INDEX_CHECK)
317  ;
318 #else
319  noexcept;
320 #endif
321  template <class V,class M,class S> friend V &_vmimultassign(V &v,const M &m)
322 #if(CXSC_INDEX_CHECK)
323  ;
324 #else
325  noexcept;
326 #endif
327  template <class V,class M,class S> friend V &_vmcmultassign(V &v,const M &m)
328 #if(CXSC_INDEX_CHECK)
329  ;
330 #else
331  noexcept;
332 #endif
333  template <class V,class M,class S> friend V &_vmcimultassign(V &v,const M &m)
334 #if(CXSC_INDEX_CHECK)
335  ;
336 #else
337  noexcept;
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  ;
342 #else
343  noexcept;
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  ;
348 #else
349  noexcept;
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  ;
354 #else
355  noexcept;
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  ;
360 #else
361  noexcept;
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  ;
366 #else
367  noexcept;
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  ;
372 #else
373  noexcept;
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  ;
378 #else
379  noexcept;
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  ;
384 #else
385  noexcept;
386 #endif
387  template <class V,class MS,class S> friend V &_vmsmultassign(V &v,const MS &ms)
388 #if(CXSC_INDEX_CHECK)
389  ;
390 #else
391  noexcept;
392 #endif
393  template <class V,class MS,class S> friend V &_vmsimultassign(V &v,const MS &ms)
394 #if(CXSC_INDEX_CHECK)
395  ;
396 #else
397  noexcept;
398 #endif
399  template <class V,class MS,class S> friend V &_vmscmultassign(V &v,const MS &ms)
400 #if(CXSC_INDEX_CHECK)
401  ;
402 #else
403  noexcept;
404 #endif
405  template <class V,class MS,class S> friend V &_vmscimultassign(V &v,const MS &ms)
406 #if(CXSC_INDEX_CHECK)
407  ;
408 #else
409  noexcept;
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  ;
414 #else
415  noexcept;
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  ;
420 #else
421  noexcept;
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  ;
426 #else
427  noexcept;
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  ;
432 #else
433  noexcept;
434 #endif
435  template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) noexcept;
436  template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
437 #if(CXSC_INDEX_CHECK)
438  ;
439 #else
440  noexcept;
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  ;
445 #else
446  noexcept;
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  ;
451 #else
452  noexcept;
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  ;
457 #else
458  noexcept;
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  ;
463 #else
464  noexcept;
465 #endif
466 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
467 #if(CXSC_INDEX_CHECK)
468 ;
469 #else
470  noexcept;
471 #endif
472 template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv)
473 #if(CXSC_INDEX_CHECK)
474 ;
475 #else
476  noexcept;
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  ;
482 #else
483  noexcept;
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  ;
488 #else
489  noexcept;
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  ;
495 #else
496  noexcept;
497 #endif
498 
499  //--------- vector-scalar ----------------
500  template <class V,class S> friend V &_vsdivassign(V &rv,const S &r) noexcept;
501  template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) noexcept;
502  template <class V,class S,class E> friend E _vsmult(const V &rv, const S &s) noexcept;
503  template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) noexcept;
504  template <class V1,class V2> friend bool _vveq(const V1 &rv1, const V2 &rv2) noexcept;
505  template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) noexcept;
506  template <class V1,class V2> friend bool _vvneq(const V1 &rv1, const V2 &rv2) noexcept;
507  template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) noexcept;
508  template <class V1,class V2> friend bool _vvless(const V1 &rv1, const V2 &rv2) noexcept;
509  template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) noexcept;
510  template <class V1,class V2> friend bool _vvleq(const V1 &rv1, const V2 &rv2) noexcept;
511  template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) noexcept;
512  template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) noexcept;
513  template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) noexcept;
514  template <class V> friend bool _vnot(const V &rv) noexcept;
515  template <class V> friend void *_vvoid(const V &rv) noexcept;
516  template <class V,class E> friend E _vabs(const V &rv) noexcept;
517  template <class VS,class E> friend E _vsabs(const VS &sl) noexcept;
518  template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) noexcept;
519  template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) noexcept;
520  template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) noexcept;
521  template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) noexcept;
522  template <class VS> friend bool _vsnot(const VS &sl) noexcept;
523  template <class VS> friend void *_vsvoid(const VS &sl) noexcept;
524  template <class V> friend std::ostream &_vout(std::ostream &s, const V &rv) noexcept;
525  template <class V> friend std::istream &_vin(std::istream &s, V &rv) noexcept;
526 
527 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) noexcept;
528  template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) noexcept;
529  // Interval
530 
531 
532 template <class MV,class V> friend MV &_mvvconvassign(MV &v,const V &rv)
533 #if(CXSC_INDEX_CHECK)
534 ;
535 #else
536  noexcept;
537 #endif
538 template <class MV,class V> friend MV &_mvvsectassign(MV &v,const V &rv)
539 #if(CXSC_INDEX_CHECK)
540 ;
541 #else
542  noexcept;
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  ;
549 #else
550  noexcept;
551 #endif
552  template <class V1,class V2> friend V1 &_vvusetinf(V1 &rv1, const V2 &rv2)
553 #if(CXSC_INDEX_CHECK)
554  ;
555 #else
556  noexcept;
557 #endif
558  template <class V1,class V2> friend V1 &_vvsetsup(V1 &rv1, const V2 &rv2)
559 #if(CXSC_INDEX_CHECK)
560  ;
561 #else
562  noexcept;
563 #endif
564  template <class V1,class V2> friend V1 &_vvusetsup(V1 &rv1, const V2 &rv2)
565 #if(CXSC_INDEX_CHECK)
566  ;
567 #else
568  noexcept;
569 #endif
570  template <class VS,class V> friend VS &_vsvsetinf(VS &sl, const V &rv)
571 #if(CXSC_INDEX_CHECK)
572  ;
573 #else
574  noexcept;
575 #endif
576  template <class VS,class V> friend VS &_vsvusetinf(VS &sl, const V &rv)
577 #if(CXSC_INDEX_CHECK)
578  ;
579 #else
580  noexcept;
581 #endif
582  template <class VS,class V> friend VS &_vsvsetsup(VS &sl, const V &rv)
583 #if(CXSC_INDEX_CHECK)
584  ;
585 #else
586  noexcept;
587 #endif
588  template <class VS,class V> friend VS &_vsvusetsup(VS &sl, const V &rv)
589 #if(CXSC_INDEX_CHECK)
590  ;
591 #else
592  noexcept;
593 #endif
594 template <class MV,class V> friend MV &_mvvsetinf(MV &v,const V &rv)
595 #if(CXSC_INDEX_CHECK)
596 ;
597 #else
598  noexcept;
599 #endif
600 template <class MV,class V> friend MV &_mvvusetinf(MV &v,const V &rv)
601 #if(CXSC_INDEX_CHECK)
602 ;
603 #else
604  noexcept;
605 #endif
606 template <class MV,class V> friend MV &_mvvsetsup(MV &v,const V &rv)
607 #if(CXSC_INDEX_CHECK)
608 ;
609 #else
610  noexcept;
611 #endif
612 template <class MV,class V> friend MV &_mvvusetsup(MV &v,const V &rv)
613 #if(CXSC_INDEX_CHECK)
614 ;
615 #else
616  noexcept;
617 #endif
618  template <class V,class E> friend E _vdiam(const V &rv) noexcept;
619  template <class V,class E> friend E _vmid(const V &rv) noexcept;
620  template <class V,class E> friend E _vinf(const V &rv) noexcept;
621  template <class V,class E> friend E _vsup(const V &rv) noexcept;
622  template <class VS,class E> friend E _vsdiam(const VS &sl) noexcept;
623  template <class VS,class E> friend E _vsmid(const VS &sl) noexcept;
624  template <class VS,class E> friend E _vsinf(const VS &sl) noexcept;
625  template <class VS,class E> friend E _vssup(const VS &sl) noexcept;
626 template <class MV,class V> friend V _mvdiam(const MV &mv) noexcept;
627 template <class MV,class V> friend V _mvmid(const MV &mv) noexcept;
628 template <class MV,class V> friend V _mvinf(const MV &mv) noexcept;
629 template <class MV,class V> friend V _mvsup(const MV &mv) noexcept;
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  ;
635 #else
636  noexcept;
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  ;
641 #else
642  noexcept;
643 #endif
644 
645  template <class V1,class V2> friend V1 &_vvconvassign(V1 &rv1, const V2 &rv2)
646 #if(CXSC_INDEX_CHECK)
647  ;
648 #else
649  noexcept;
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  ;
654 #else
655  noexcept;
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  ;
660 #else
661  noexcept;
662 #endif
663  template <class V1,class V2> friend V1 &_vvsectassign(V1 &rv1, const V2 &rv2)
664 #if(CXSC_INDEX_CHECK)
665  ;
666 #else
667  noexcept;
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  ;
673 #else
674  noexcept;
675 #endif
676 
677  template <class V,class VS> friend V &_vvsconvassign(V &rv, const VS &sl)
678 #if(CXSC_INDEX_CHECK)
679  ;
680 #else
681  noexcept;
682 #endif
683  template <class VS,class V> friend VS &_vsvconvassign(VS &sl, const V &rv)
684 #if(CXSC_INDEX_CHECK)
685  ;
686 #else
687  noexcept;
688 #endif
689  template <class VS1,class VS2> friend VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2)
690 #if(CXSC_INDEX_CHECK)
691  ;
692 #else
693  noexcept;
694 #endif
695 
696  template <class VS,class V> friend VS &_vsvsectassign(VS &sl, const V &rv)
697 #if(CXSC_INDEX_CHECK)
698  ;
699 #else
700  noexcept;
701 #endif
702  //--- Interval ---- vector-scalar ----------
703 
704  template <class V,class S,class E> friend E _vsdiv(const V &rv, const S &s) noexcept;
705 
706 
707  // complex
708 
709  template <class V,class E> friend E _vim(const V &rv) noexcept;
710  template <class V,class E> friend E _vre(const V &rv) noexcept;
711 template <class MV,class V> friend V _mvim(const MV &mv) noexcept;
712 template <class MV,class V> friend V _mvre(const MV &mv) noexcept;
713 template <class MV,class V> friend MV &_mvvsetim(MV &v,const V &rv)
714 #if(CXSC_INDEX_CHECK)
715 ;
716 #else
717  noexcept;
718 #endif
719 template <class MV,class V> friend MV &_mvvsetre(MV &v,const V &rv)
720 #if(CXSC_INDEX_CHECK)
721 ;
722 #else
723  noexcept;
724 #endif
725  template <class V1,class V2> friend V1 &_vvsetim(V1 &rv1, const V2 &rv2)
726 #if(CXSC_INDEX_CHECK)
727  ;
728 #else
729  noexcept;
730 #endif
731  template <class V1,class V2> friend V1 &_vvsetre(V1 &rv1, const V2 &rv2)
732 #if(CXSC_INDEX_CHECK)
733  ;
734 #else
735  noexcept;
736 #endif
737  template <class VS,class E> friend E _vsim(const VS &sl) noexcept;
738  template <class VS,class E> friend E _vsre(const VS &sl) noexcept;
739  template <class VS,class V> friend VS &_vsvsetim(VS &sl, const V &rv)
740 #if(CXSC_INDEX_CHECK)
741  ;
742 #else
743  noexcept;
744 #endif
745  template <class VS,class V> friend VS &_vsvsetre(VS &sl, const V &rv)
746 #if(CXSC_INDEX_CHECK)
747  ;
748 #else
749  noexcept;
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  ;
756 #else
757  noexcept;
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  ;
762 #else
763  noexcept;
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) noexcept;
775  friend INLINE rvector SupIm(const civector &v) noexcept;
777  friend INLINE rvector InfRe(const civector &v) noexcept;
779  friend INLINE rvector InfIm(const civector &v) noexcept;
781  friend INLINE rvector SupRe(const civector_slice &v) noexcept;
783  friend INLINE rvector SupIm(const civector_slice &v) noexcept;
785  friend INLINE rvector InfRe(const civector_slice &v) noexcept;
787  friend INLINE rvector InfIm(const civector_slice &v) noexcept;
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  ;
794 #else
795  noexcept;
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  ;
800 #else
801  noexcept;
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  ;
807 #else
808  noexcept;
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  ;
818 #else
819  noexcept;
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  ;
824 #else
825  noexcept;
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  ;
830 #else
831  noexcept;
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  ;
837 #else
838  noexcept;
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  ;
845 #else
846  noexcept;
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  ;
851 #else
852  noexcept;
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  ;
860 #else
861  noexcept;
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  ;
866 #else
867  noexcept;
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  ;
873 #else
874  noexcept;
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  ;
881 #else
882  noexcept;
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  ;
887 #else
888  noexcept;
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  ;
893 #else
894  noexcept;
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  ;
899 #else
900  noexcept;
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 () noexcept;
914  explicit INLINE rvector(const int &i) noexcept;
915 #ifdef OLD_CXSC
917  explicit INLINE rvector(const class index &i) noexcept; // for backwards compatibility
918 #endif
920  explicit INLINE rvector(const int &i1,const int &i2)
921 #if(CXSC_INDEX_CHECK)
922 ;
923 #else
924  noexcept;
925 #endif
927  INLINE rvector(const rmatrix_subv &) noexcept;
929  explicit INLINE rvector(const real &) noexcept;
931  explicit INLINE rvector(const rmatrix &)
932 #if(CXSC_INDEX_CHECK)
933 ;
934 #else
935  noexcept;
936 #endif
938  explicit INLINE rvector(const rmatrix_slice &sl)
939 #if(CXSC_INDEX_CHECK)
940 ;
941 #else
942  noexcept;
943 #endif
944 
946  INLINE rvector(const intvector&);
947 
949  INLINE rvector(const rvector_slice &rs) noexcept;
951  INLINE rvector(const rvector &v) noexcept;
953  INLINE rvector(const srvector &v);
955  INLINE rvector(const srvector_slice &v);
957  INLINE rvector &operator =(const rvector &rv) noexcept;
959  INLINE rvector &operator =(const rvector_slice &sl) noexcept;
961  INLINE rvector &operator =(const srvector &rv);
963  INLINE rvector &operator =(const srvector_slice &sl);
965  INLINE rvector &operator =(const real &r) noexcept;
967  INLINE rvector &operator =(const rmatrix &)
968 #if(CXSC_INDEX_CHECK)
969 ;
970 #else
971  noexcept;
972 #endif
974  INLINE rvector &operator =(const rmatrix_slice &)
975 #if(CXSC_INDEX_CHECK)
976 ;
977 #else
978  noexcept;
979 #endif
981  INLINE rvector &operator =(const rmatrix_subv &) noexcept;
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 ;
997 #else
998  noexcept;
999 #endif
1001  friend INLINE int Lb(const rvector &rv) noexcept { return rv.l; }
1003  friend INLINE int Ub(const rvector &rv) noexcept { return rv.u; }
1005  friend INLINE int VecLen(const rvector &rv) noexcept { return rv.size; }
1007  friend INLINE rvector &SetLb(rvector &rv, const int &l) noexcept { rv.l=l; rv.u=l+rv.size-1; return rv; }
1009  friend INLINE rvector &SetUb(rvector &rv, const int &u) noexcept { 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 ;
1014 #else
1015  noexcept;
1016 #endif
1017 
1019  INLINE real & operator [](const int &i)
1020 #if(CXSC_INDEX_CHECK)
1021 ;
1022 #else
1023  noexcept;
1024 #endif
1025 
1027  INLINE rvector & operator ()() noexcept { return *this; }
1029  INLINE rvector_slice operator ()(const int &i)
1030 #if(CXSC_INDEX_CHECK)
1031 ;
1032 #else
1033  noexcept;
1034 #endif
1036  INLINE rvector_slice operator ()(const int &i1,const int &i2)
1037 #if(CXSC_INDEX_CHECK)
1038 ;
1039 #else
1040  noexcept;
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*() noexcept;
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  ;
1090 #else
1091  noexcept;
1092 #endif
1093  template <class V,class VS,class S> friend V & _vvsassign(V &rv,const VS &sl) noexcept;
1094  template <class VS,class V> friend VS & _vsvassign(VS &sl,const V &rv)
1095 #if(CXSC_INDEX_CHECK)
1096  ;
1097 #else
1098  noexcept;
1099 #endif
1100  template <class VS,class S> friend VS & _vssassign(VS &sl,const S &r) noexcept;
1101  template <class VS,class M,class S> friend VS &_vsmmultassign(VS &v,const M &m)
1102 #if(CXSC_INDEX_CHECK)
1103  ;
1104 #else
1105  noexcept;
1106 #endif
1107  //-------- vector-scalar ------------------
1108  template <class VS,class S> friend VS &_vssmultassign(VS &rv,const S &r) noexcept;
1109  template <class VS,class S> friend VS &_vssdivassign(VS &rv,const S &r) noexcept;
1110 
1111  template <class VS,class V> friend bool _vsveq(const VS &sl, const V &rv) noexcept;
1112  template <class VS,class V> friend bool _vsvneq(const VS &sl, const V &rv) noexcept;
1113  template <class VS,class V> friend bool _vsvless(const VS &sl, const V &rv) noexcept;
1114  template <class VS,class V> friend bool _vsvleq(const VS &sl, const V &rv) noexcept;
1115  template <class V,class VS> friend bool _vvsless(const V &rv, const VS &sl) noexcept;
1116  template <class V,class VS> friend bool _vvsleq(const V &rv, const VS &sl) noexcept;
1117  template <class VS,class E> friend E _vsabs(const VS &sl) noexcept;
1118  template <class VS1,class VS2> friend bool _vsvseq(const VS1 &sl1, const VS2 &sl2) noexcept;
1119  template <class VS1,class VS2> friend bool _vsvsneq(const VS1 &sl1, const VS2 &sl2) noexcept;
1120  template <class VS1,class VS2> friend bool _vsvsless(const VS1 &sl1, const VS2 &sl2) noexcept;
1121  template <class VS1,class VS2> friend bool _vsvsleq(const VS1 &sl1, const VS2 &sl2) noexcept;
1122  template <class VS> friend bool _vsnot(const VS &sl) noexcept;
1123  template <class VS> friend void *_vsvoid(const VS &sl) noexcept;
1124  template <class V> friend std::ostream &_vsout(std::ostream &s, const V &rv) noexcept;
1125  template <class V> friend std::istream &_vsin(std::istream &s, V &rv) noexcept;
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  ;
1130 #else
1131  noexcept;
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  ;
1136 #else
1137  noexcept;
1138 #endif
1139 
1140  template <class VS,class S,class E> friend E _vssdiv(const VS &sl, const S &s) noexcept;
1141  template <class VS,class S,class E> friend E _vssmult(const VS &sl, const S &s) noexcept;
1142  template <class VS,class V,class E> friend E _vsvmult(const VS & sl, const V &rv)
1143 #if(CXSC_INDEX_CHECK)
1144  ;
1145 #else
1146  noexcept;
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  ;
1151 #else
1152  noexcept;
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  ;
1157 #else
1158  noexcept;
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  ;
1163 #else
1164  noexcept;
1165 #endif
1166  template <class V,class VS> friend V &_vvsplusassign(V &rv, const VS &sl)
1167 #if(CXSC_INDEX_CHECK)
1168  ;
1169 #else
1170  noexcept;
1171 #endif
1172  template <class VS,class V> friend VS &_vsvplusassign(VS &sl, const V &rv)
1173 #if(CXSC_INDEX_CHECK)
1174  ;
1175 #else
1176  noexcept;
1177 #endif
1178  template <class VS1,class VS2> friend VS1 &_vsvsplusassign(VS1 &sl1, const VS2 &sl2)
1179 #if(CXSC_INDEX_CHECK)
1180  ;
1181 #else
1182  noexcept;
1183 #endif
1184  template <class VS1,class VS2> friend VS1 &_vsvsminusassign(VS1 &sl1, const VS2 &sl2)
1185 #if(CXSC_INDEX_CHECK)
1186  ;
1187 #else
1188  noexcept;
1189 #endif
1190  template <class V,class VS> friend V &_vvsminusassign(V &rv, const VS &sl)
1191 #if(CXSC_INDEX_CHECK)
1192  ;
1193 #else
1194  noexcept;
1195 #endif
1196  template <class VS,class V> friend VS &_vsvminusassign(VS &sl, const V &rv)
1197 #if(CXSC_INDEX_CHECK)
1198  ;
1199 #else
1200  noexcept;
1201 #endif
1202  template <class VS,class V> friend V _vsminus(const VS &sl) noexcept;
1203  template <class V,class VS,class E> friend E _vvsminus(const V &rv, const VS &sl)
1204 #if(CXSC_INDEX_CHECK)
1205  ;
1206 #else
1207  noexcept;
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  ;
1212 #else
1213  noexcept;
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  ;
1218 #else
1219  noexcept;
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  ;
1225 #else
1226  noexcept;
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  ;
1231 #else
1232  noexcept;
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  ;
1237 #else
1238  noexcept;
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  ;
1243 #else
1244  noexcept;
1245 #endif
1246  // interval -----------
1247  template <class V,class VS> friend V &_vvssetinf(V &rv, const VS &sl)
1248 #if(CXSC_INDEX_CHECK)
1249  ;
1250 #else
1251  noexcept;
1252 #endif
1253  template <class V,class VS> friend V &_vvsusetinf(V &rv, const VS &sl)
1254 #if(CXSC_INDEX_CHECK)
1255  ;
1256 #else
1257  noexcept;
1258 #endif
1259  template <class V,class VS> friend V &_vvssetsup(V &rv, const VS &sl)
1260 #if(CXSC_INDEX_CHECK)
1261  ;
1262 #else
1263  noexcept;
1264 #endif
1265  template <class V,class VS> friend V &_vvsusetsup(V &rv, const VS &sl)
1266 #if(CXSC_INDEX_CHECK)
1267  ;
1268 #else
1269  noexcept;
1270 #endif
1271  template <class VS1,class VS2> friend VS1 &_vsvssetinf(VS1 &sl1, const VS2 &sl2)
1272 #if(CXSC_INDEX_CHECK)
1273  ;
1274 #else
1275  noexcept;
1276 #endif
1277  template <class VS1,class VS2> friend VS1 &_vsvsusetinf(VS1 &sl1, const VS2 &sl2)
1278 #if(CXSC_INDEX_CHECK)
1279  ;
1280 #else
1281  noexcept;
1282 #endif
1283  template <class VS1,class VS2> friend VS1 &_vsvssetsup(VS1 &sl1, const VS2 &sl2)
1284 #if(CXSC_INDEX_CHECK)
1285  ;
1286 #else
1287  noexcept;
1288 #endif
1289  template <class VS1,class VS2> friend VS1 &_vsvsusetsup(VS1 &sl1, const VS2 &sl2)
1290 #if(CXSC_INDEX_CHECK)
1291  ;
1292 #else
1293  noexcept;
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  ;
1301 #else
1302  noexcept;
1303 #endif
1304  template <class VS,class V> friend VS &_vsvconvassign(VS &sl, const V &rv)
1305 #if(CXSC_INDEX_CHECK)
1306  ;
1307 #else
1308  noexcept;
1309 #endif
1310  template <class VS1,class VS2> friend VS1 &_vsvsconvassign(VS1 &sl1, const VS2 &sl2)
1311 #if(CXSC_INDEX_CHECK)
1312  ;
1313 #else
1314  noexcept;
1315 #endif
1316 
1317  template <class V,class VS> friend V &_vvssectassign(V &rv, const VS &sl)
1318 #if(CXSC_INDEX_CHECK)
1319  ;
1320 #else
1321  noexcept;
1322 #endif
1323  template <class VS,class V> friend VS &_vsvsectassign(VS &sl, const V &rv)
1324 #if(CXSC_INDEX_CHECK)
1325  ;
1326 #else
1327  noexcept;
1328 #endif
1329  template <class VS1,class VS2> friend VS1 &_vsvssectassign(VS1 &sl1, const VS2 &sl2)
1330 #if(CXSC_INDEX_CHECK)
1331  ;
1332 #else
1333  noexcept;
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  ;
1342 #else
1343  noexcept;
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  ;
1348 #else
1349  noexcept;
1350 #endif
1351 
1352  template <class VS1,class VS2> friend VS1 &_vsvssetim(VS1 &sl1, const VS2 &sl2)
1353 #if(CXSC_INDEX_CHECK)
1354  ;
1355 #else
1356  noexcept;
1357 #endif
1358  template <class VS1,class VS2> friend VS1 &_vsvssetre(VS1 &sl1, const VS2 &sl2)
1359 #if(CXSC_INDEX_CHECK)
1360  ;
1361 #else
1362  noexcept;
1363 #endif
1364  template <class V,class VS> friend V &_vvssetim(V &rv, const VS &sl)
1365 #if(CXSC_INDEX_CHECK)
1366  ;
1367 #else
1368  noexcept;
1369 #endif
1370  template <class V,class VS> friend V &_vvssetre(V &rv, const VS &sl)
1371 #if(CXSC_INDEX_CHECK)
1372  ;
1373 #else
1374  noexcept;
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  ;
1382 #else
1383  noexcept;
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  ;
1388 #else
1389  noexcept;
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  ;
1395 #else
1396  noexcept;
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  ;
1401 #else
1402  noexcept;
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  ;
1408 #else
1409  noexcept;
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  ;
1414 #else
1415  noexcept;
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  ;
1421 #else
1422  noexcept;
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  ;
1427 #else
1428  noexcept;
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) noexcept: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) noexcept: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) noexcept: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 ;
1450 #else
1451  noexcept;
1452 #endif
1454  INLINE rvector_slice & operator =(const rvector &rv)
1455 #if(CXSC_INDEX_CHECK)
1456 ;
1457 #else
1458  noexcept;
1459 #endif
1461  INLINE rvector_slice & operator =(const srvector &rv);
1463  INLINE rvector_slice & operator =(const srvector_slice &rv);
1465  INLINE rvector_slice & operator =(const real &r) noexcept;
1467  INLINE rvector_slice & operator =(const rmatrix &m)
1468 #if(CXSC_INDEX_CHECK)
1469 ;
1470 #else
1471  noexcept;
1472 #endif
1474  INLINE rvector_slice & operator =(const rmatrix_slice &m)
1475 #if(CXSC_INDEX_CHECK)
1476 ;
1477 #else
1478  noexcept;
1479 #endif
1481  INLINE rvector_slice &operator =(const rmatrix_subv &) noexcept;
1482 
1483  //--------------------- Standardfunktionen ------------------------------
1484 
1485  friend INLINE real::real(const rvector_slice &sl)
1486 #if(CXSC_INDEX_CHECK)
1487 ;
1488 #else
1489  noexcept;
1490 #endif
1492  friend INLINE int Lb(const rvector_slice &sl) noexcept { return sl.start; }
1494  friend INLINE int Ub(const rvector_slice &sl) noexcept { return sl.end; }
1496  friend INLINE int VecLen(const rvector_slice &sl) noexcept { return sl.end-sl.start+1; }
1498  INLINE real & operator [](const int &i)
1499 #if(CXSC_INDEX_CHECK)
1500 ;
1501 #else
1502  noexcept;
1503 #endif
1504 
1506  INLINE real & operator [](const int &i) const
1507 #if(CXSC_INDEX_CHECK)
1508 ;
1509 #else
1510  noexcept;
1511 #endif
1512 
1514  INLINE rvector_slice & operator ()() noexcept { return *this; }
1516  INLINE rvector_slice operator ()(const int &i)
1517 #if(CXSC_INDEX_CHECK)
1518 ;
1519 #else
1520  noexcept;
1521 #endif
1523  INLINE rvector_slice operator ()(const int &i1,const int &i2)
1524 #if(CXSC_INDEX_CHECK)
1525 ;
1526 #else
1527  noexcept;
1528 #endif
1530  INLINE rvector_slice &operator /=(const real &r) noexcept;
1532  INLINE rvector_slice &operator *=(const real &r) noexcept;
1534  INLINE rvector_slice &operator *=(const rmatrix &m)
1535 #if(CXSC_INDEX_CHECK)
1536 ;
1537 #else
1538  noexcept;
1539 #endif
1541  INLINE rvector_slice &operator +=(const rvector &rv)
1542 #if(CXSC_INDEX_CHECK)
1543 ;
1544 #else
1545  noexcept;
1546 #endif
1548  INLINE rvector_slice &operator +=(const rvector_slice &sl2)
1549 #if(CXSC_INDEX_CHECK)
1550 ;
1551 #else
1552  noexcept;
1553 #endif
1555  INLINE rvector_slice &operator -=(const rvector &rv)
1556 #if(CXSC_INDEX_CHECK)
1557 ;
1558 #else
1559  noexcept;
1560 #endif
1562  INLINE rvector_slice &operator -=(const rvector_slice &sl2)
1563 #if(CXSC_INDEX_CHECK)
1564 ;
1565 #else
1566  noexcept;
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*() noexcept;
1580 //#else
1581 //#endif
1582 };
1583 
1584 //======================== Vector Functions =============================
1585 
1587  INLINE rvector _rvector(const real &r) noexcept;
1588 // INLINE rvector _rvector(const rmatrix &m);
1589 // INLINE rvector _rvector(const rmatrix_slice &sl);
1590 
1592  INLINE void Resize(rvector &rv) noexcept;
1594  INLINE void Resize(rvector &rv, const int &len)
1595 #if(CXSC_INDEX_CHECK)
1596 ;
1597 #else
1598  noexcept;
1599 #endif
1601  INLINE void Resize(rvector &rv, const int &lb, const int &ub)
1602 #if(CXSC_INDEX_CHECK)
1603 ;
1604 #else
1605  noexcept;
1606 #endif
1607 
1609  INLINE rvector abs(const rvector &rv) noexcept;
1611  INLINE rvector abs(const rvector_slice &sl) noexcept;
1613  INLINE bool operator !(const rvector &rv) noexcept;
1615  INLINE bool operator !(const rvector_slice &sl) noexcept;
1616 
1617 //======================= Vector / Scalar ===============================
1618 
1620  INLINE rvector operator *(const rvector &rv, const real &s) noexcept;
1622  INLINE rvector operator *(const rvector_slice &sl, const real &s) noexcept;
1624  INLINE rvector operator *(const real &s, const rvector &rv) noexcept;
1626  INLINE rvector operator *(const real &s, const rvector_slice &sl) noexcept;
1628  INLINE rvector &operator *=(rvector &rv,const real &r) noexcept;
1629 
1631  INLINE rvector operator /(const rvector &rv, const real &s) noexcept;
1633  INLINE rvector operator /(const rvector_slice &sl, const real &s) noexcept;
1635  INLINE rvector &operator /=(rvector &rv,const real &r) noexcept;
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 ;
1646 #else
1647  noexcept;
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 ;
1658 #else
1659  noexcept;
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 ;
1670 #else
1671  noexcept;
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 ;
1681 #else
1682  noexcept;
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 ;
1693 #else
1694  noexcept;
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 ;
1705 #else
1706  noexcept;
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 ;
1717 #else
1718  noexcept;
1719 #endif
1721  void accumulate(idotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2)
1722 #if(CXSC_INDEX_CHECK)
1723 ;
1724 #else
1725  noexcept;
1726 #endif
1728  void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2)
1729 #if(CXSC_INDEX_CHECK)
1730 ;
1731 #else
1732  noexcept;
1733 #endif
1735  void accumulate(idotprecision &dp,const rvector_slice &sl,const rvector &rv)
1736 #if(CXSC_INDEX_CHECK)
1737 ;
1738 #else
1739  noexcept;
1740 #endif
1742  void accumulate(idotprecision &dp,const rvector &rv,const rvector_slice &sl)
1743 #if(CXSC_INDEX_CHECK)
1744 ;
1745 #else
1746  noexcept;
1747 #endif
1749  void accumulate(idotprecision &dp, const rvector_slice & sl1, const rvector_slice &sl2)
1750 #if(CXSC_INDEX_CHECK)
1751 ;
1752 #else
1753  noexcept;
1754 #endif
1755 
1757  void accumulate(cdotprecision &dp, const rvector & rv1, const rvector &rv2)
1758 #if(CXSC_INDEX_CHECK)
1759 ;
1760 #else
1761  noexcept;
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 ;
1771 #else
1772  noexcept;
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 ;
1782 #else
1783  noexcept;
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 ;
1793 #else
1794  noexcept;
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 ;
1804 #else
1805  noexcept;
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 ;
1815 #else
1816  noexcept;
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 ;
1826 #else
1827  noexcept;
1828 #endif
1830  void accumulate(cidotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2)
1831 #if(CXSC_INDEX_CHECK)
1832 ;
1833 #else
1834  noexcept;
1835 #endif
1837  void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2)
1838 #if(CXSC_INDEX_CHECK)
1839 ;
1840 #else
1841  noexcept;
1842 #endif
1844  void accumulate(cidotprecision &dp,const rvector_slice &sl,const rvector &rv)
1845 #if(CXSC_INDEX_CHECK)
1846 ;
1847 #else
1848  noexcept;
1849 #endif
1851  void accumulate(cidotprecision &dp,const rvector &rv,const rvector_slice &sl)
1852 #if(CXSC_INDEX_CHECK)
1853 ;
1854 #else
1855  noexcept;
1856 #endif
1858  void accumulate(cidotprecision &dp, const rvector_slice & sl1, const rvector_slice &sl2)
1859 #if(CXSC_INDEX_CHECK)
1860 ;
1861 #else
1862  noexcept;
1863 #endif
1864 
1866  INLINE real operator *(const rvector & rv1, const rvector &rv2)
1867 #if(CXSC_INDEX_CHECK)
1868 ;
1869 #else
1870  noexcept;
1871 #endif
1873  INLINE real operator *(const rvector_slice &sl, const rvector &rv)
1874 #if(CXSC_INDEX_CHECK)
1875 ;
1876 #else
1877  noexcept;
1878 #endif
1880  INLINE real operator *(const rvector &rv, const rvector_slice &sl)
1881 #if(CXSC_INDEX_CHECK)
1882 ;
1883 #else
1884  noexcept;
1885 #endif
1887  INLINE real operator *(const rvector_slice & sl1, const rvector_slice &sl2)
1888 #if(CXSC_INDEX_CHECK)
1889 ;
1890 #else
1891  noexcept;
1892 #endif
1893 
1895  INLINE const rvector &operator +(const rvector &rv) noexcept;
1897  INLINE rvector operator +(const rvector_slice &sl) noexcept;
1899  INLINE rvector operator +(const rvector &rv1, const rvector &rv2)
1900 #if(CXSC_INDEX_CHECK)
1901 ;
1902 #else
1903  noexcept;
1904 #endif
1906  INLINE rvector operator +(const rvector &rv, const rvector_slice &sl)
1907 #if(CXSC_INDEX_CHECK)
1908 ;
1909 #else
1910  noexcept;
1911 #endif
1913  INLINE rvector operator +(const rvector_slice &sl, const rvector &rv)
1914 #if(CXSC_INDEX_CHECK)
1915 ;
1916 #else
1917  noexcept;
1918 #endif
1920  INLINE rvector operator +(const rvector_slice &sl1, const rvector_slice &sl2)
1921 #if(CXSC_INDEX_CHECK)
1922 ;
1923 #else
1924  noexcept;
1925 #endif
1927  INLINE rvector & operator +=(rvector &rv1, const rvector &rv2)
1928 #if(CXSC_INDEX_CHECK)
1929 ;
1930 #else
1931  noexcept;
1932 #endif
1934  INLINE rvector &operator +=(rvector &rv, const rvector_slice &sl)
1935 #if(CXSC_INDEX_CHECK)
1936 ;
1937 #else
1938  noexcept;
1939 #endif
1940 
1942  INLINE rvector operator -(const rvector &rv) noexcept;
1944  INLINE rvector operator -(const rvector_slice &sl) noexcept;
1946  INLINE rvector operator -(const rvector &rv1, const rvector &rv2)
1947 #if(CXSC_INDEX_CHECK)
1948 ;
1949 #else
1950  noexcept;
1951 #endif
1953  INLINE rvector operator -(const rvector &rv, const rvector_slice &sl)
1954 #if(CXSC_INDEX_CHECK)
1955 ;
1956 #else
1957  noexcept;
1958 #endif
1960  INLINE rvector operator -(const rvector_slice &sl, const rvector &rv)
1961 #if(CXSC_INDEX_CHECK)
1962 ;
1963 #else
1964  noexcept;
1965 #endif
1967  INLINE rvector operator -(const rvector_slice &sl1, const rvector_slice &sl2)
1968 #if(CXSC_INDEX_CHECK)
1969 ;
1970 #else
1971  noexcept;
1972 #endif
1974  INLINE rvector & operator -=(rvector &rv1, const rvector &rv2)
1975 #if(CXSC_INDEX_CHECK)
1976 ;
1977 #else
1978  noexcept;
1979 #endif
1981  INLINE rvector &operator -=(rvector &rv, const rvector_slice &sl)
1982 #if(CXSC_INDEX_CHECK)
1983 ;
1984 #else
1985  noexcept;
1986 #endif
1987 
1989  INLINE bool operator ==(const rvector &rv1, const rvector &rv2) noexcept;
1991  INLINE bool operator ==(const rvector_slice &sl1, const rvector_slice &sl2) noexcept;
1993  INLINE bool operator ==(const rvector_slice &sl, const rvector &rv) noexcept;
1995  INLINE bool operator ==(const rvector &rv, const rvector_slice &sl) noexcept;
1997  INLINE bool operator !=(const rvector &rv1, const rvector &rv2) noexcept;
1999  INLINE bool operator !=(const rvector_slice &sl1, const rvector_slice &sl2) noexcept;
2001  INLINE bool operator !=(const rvector_slice &sl, const rvector &rv) noexcept;
2003  INLINE bool operator !=(const rvector &rv, const rvector_slice &sl) noexcept;
2005  INLINE bool operator <(const rvector &rv1, const rvector &rv2) noexcept;
2007  INLINE bool operator <(const rvector_slice &sl1, const rvector_slice &sl2) noexcept;
2009  INLINE bool operator < (const rvector_slice &sl, const rvector &rv) noexcept;
2011  INLINE bool operator < (const rvector &rv, const rvector_slice &sl) noexcept;
2013  INLINE bool operator <=(const rvector &rv1, const rvector &rv2) noexcept;
2015  INLINE bool operator <=(const rvector_slice &sl1, const rvector_slice &sl2) noexcept;
2017  INLINE bool operator <=(const rvector_slice &sl, const rvector &rv) noexcept;
2019  INLINE bool operator <=(const rvector &rv, const rvector_slice &sl) noexcept;
2021  INLINE bool operator >(const rvector &rv1, const rvector &rv2) noexcept;
2023  INLINE bool operator >(const rvector_slice &sl1, const rvector_slice &sl2) noexcept;
2025  INLINE bool operator >(const rvector_slice &sl, const rvector &rv) noexcept;
2027  INLINE bool operator >(const rvector &rv, const rvector_slice &sl) noexcept;
2029  INLINE bool operator >=(const rvector &rv1, const rvector &rv2) noexcept;
2031  INLINE bool operator >=(const rvector_slice &sl1, const rvector_slice &sl2) noexcept;
2033  INLINE bool operator >=(const rvector_slice &sl, const rvector &rv) noexcept;
2035  INLINE bool operator >=(const rvector &rv, const rvector_slice &sl) noexcept;
2036 
2038  INLINE std::ostream &operator <<(std::ostream &s, const rvector &rv) noexcept;
2040  INLINE std::ostream &operator <<(std::ostream &o, const rvector_slice &sl) noexcept;
2042  INLINE std::istream &operator >>(std::istream &s, rvector &rv) noexcept;
2044  INLINE std::istream &operator >>(std::istream &s, rvector_slice &rv) noexcept;
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
The Data Type cimatrix.
Definition: cimatrix.hpp:908
The Data Type civector_slice.
Definition: civector.hpp:1015
The Data Type civector.
Definition: civector.hpp:57
The Data Type cmatrix.
Definition: cmatrix.hpp:514
The Data Type cvector_slice.
Definition: cvector.hpp:845
The Data Type cvector.
Definition: cvector.hpp:58
The Data Type imatrix.
Definition: imatrix.hpp:660
The Data Type intmatrix.
Definition: intmatrix.hpp:314
The Data Type intvector.
Definition: intvector.hpp:52
The Data Type ivector.
Definition: ivector.hpp:55
The Multiple-Precision Data Type l_imatrix.
Definition: l_imatrix.hpp:726
The Multiple-Precision Data Type l_ivector.
Definition: l_ivector.hpp:55
The Multiple-Precision Data Type l_rmatrix.
Definition: l_rmatrix.hpp:416
The Multiple-Precision Data Type l_rvector.
Definition: l_rvector.hpp:54
The Scalar Type real.
Definition: real.hpp:114
real(void) noexcept
Constructor of class real.
Definition: real.hpp:122
The Data Type rmatrix_slice.
Definition: rmatrix.hpp:1443
The Data Type rmatrix_subv.
Definition: rmatrix.hpp:54
The Data Type rmatrix.
Definition: rmatrix.hpp:471
The Data Type rvector_slice.
Definition: rvector.hpp:1064
rvector_slice & operator+=(const rvector &rv) noexcept
Implementation of addition and allocation operation.
Definition: rvector.inl:397
real & operator[](const int &i) noexcept
Operator for accessing the single elements of the vector.
Definition: rvector.inl:128
rvector_slice & operator-=(const rvector &rv) noexcept
Implementation of subtraction and allocation operation.
Definition: rvector.inl:456
rvector_slice & operator/=(const real &r) noexcept
Implementation of division and allocation operation.
Definition: rvector.inl:316
rvector_slice & operator=(const rvector_slice &sl) noexcept
Implementation of standard assigning operator.
Definition: rvector.inl:258
friend int Ub(const rvector_slice &sl) noexcept
Returns the upper bound of the vector.
Definition: rvector.hpp:1494
rvector_slice & operator()() noexcept
Operator for accessing the whole vector.
Definition: rvector.hpp:1514
rvector_slice(const rvector_slice &a) noexcept
Constructor of class rvector_slice.
Definition: rvector.hpp:1444
friend int Lb(const rvector_slice &sl) noexcept
Returns the lower bound of the vector.
Definition: rvector.hpp:1492
rvector_slice(rvector &a, const int &lb, const int &ub) noexcept
Constructor of class rvector_slice.
Definition: rvector.hpp:1439
friend int VecLen(const rvector_slice &sl) noexcept
Returns the dimension of the vector.
Definition: rvector.hpp:1496
rvector_slice & operator*=(const real &r) noexcept
Implementation of multiplication and allocation operation.
Definition: rvector.inl:311
rvector_slice(rvector_slice &a, const int &lb, const int &ub) noexcept
Constructor of class rvector_slice.
Definition: rvector.hpp:1441
The Data Type rvector.
Definition: rvector.hpp:58
rvector & operator-=(const srvector &rv)
Implementation of addition and allocation operation.
Definition: srvector.hpp:586
rvector & operator+=(const srvector &rv)
Implementation of addition and allocation operation.
Definition: srvector.hpp:578
friend rvector SupIm(const civector &v) noexcept
Returns componentwise the supremum of the imaginary part.
Definition: civector.inl:637
friend rvector & SetLb(rvector &rv, const int &l) noexcept
Sets the lower bound of the vector.
Definition: rvector.hpp:1007
rvector & operator=(const rvector &rv) noexcept
Implementation of standard assigning operator.
Definition: rvector.inl:254
rvector & operator()() noexcept
Operator for accessing the whole vector.
Definition: rvector.hpp:1027
friend int VecLen(const rvector &rv) noexcept
Returns the dimension of the vector.
Definition: rvector.hpp:1005
friend rvector InfRe(const civector &v) noexcept
Returns componentwise the infimum of the real part.
Definition: civector.inl:576
real & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector (read-only)
Definition: rvector.inl:102
friend rvector SupRe(const civector &v) noexcept
Returns componentwise the supremum of the real part.
Definition: civector.inl:659
friend rvector InfIm(const civector &v) noexcept
Returns componentwise the infimum of the imaginary part.
Definition: civector.inl:616
friend rvector & SetUb(rvector &rv, const int &u) noexcept
Sets the upper bound of the vector.
Definition: rvector.hpp:1009
rvector() noexcept
Constructor of class rvector.
Definition: rvector.inl:37
friend int Ub(const rvector &rv) noexcept
Returns the upper bound of the vector.
Definition: rvector.hpp:1003
friend int Lb(const rvector &rv) noexcept
Returns the lower bound of the vector.
Definition: rvector.hpp:1001
Helper class for slices of sparse vectors.
Definition: srvector.hpp:868
A sparse real vector.
Definition: srvector.hpp:58
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
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
rvector _rvector(const real &r) noexcept
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC.
Definition: rvector.inl:281
civector operator/(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of division operation.
Definition: cimatrix.inl:730
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc) noexcept
Implementation of standard algebraic addition and allocation operation.
Definition: cdot.inl:251
cimatrix & operator*=(cimatrix &m, const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
Definition: cimatrix.inl:1605
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737
civector operator*(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of multiplication operation.
Definition: cimatrix.inl:731
void Resize(cimatrix &A) noexcept
Resizes the matrix.
Definition: cimatrix.inl:1211
cimatrix & operator/=(cimatrix &m, const cinterval &c) noexcept
Implementation of division and allocation operation.
Definition: cimatrix.inl:1623