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
39namespace cxsc {
40
41class srvector;
42class srvector_slice;
43class rvector_slice;
44
46
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
77template <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
83template <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
111template <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
117template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) noexcept;
118template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
119#if(CXSC_INDEX_CHECK)
120;
121#else
122 noexcept;
123#endif
124template <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
260template <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
466template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
467#if(CXSC_INDEX_CHECK)
468;
469#else
470 noexcept;
471#endif
472template <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
492template <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
527template <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
532template <class MV,class V> friend MV &_mvvconvassign(MV &v,const V &rv)
533#if(CXSC_INDEX_CHECK)
534;
535#else
536 noexcept;
537#endif
538template <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
594template <class MV,class V> friend MV &_mvvsetinf(MV &v,const V &rv)
595#if(CXSC_INDEX_CHECK)
596;
597#else
598 noexcept;
599#endif
600template <class MV,class V> friend MV &_mvvusetinf(MV &v,const V &rv)
601#if(CXSC_INDEX_CHECK)
602;
603#else
604 noexcept;
605#endif
606template <class MV,class V> friend MV &_mvvsetsup(MV &v,const V &rv)
607#if(CXSC_INDEX_CHECK)
608;
609#else
610 noexcept;
611#endif
612template <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;
626template <class MV,class V> friend V _mvdiam(const MV &mv) noexcept;
627template <class MV,class V> friend V _mvmid(const MV &mv) noexcept;
628template <class MV,class V> friend V _mvinf(const MV &mv) noexcept;
629template <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;
711template <class MV,class V> friend V _mvim(const MV &mv) noexcept;
712template <class MV,class V> friend V _mvre(const MV &mv) noexcept;
713template <class MV,class V> friend MV &_mvvsetim(MV &v,const V &rv)
714#if(CXSC_INDEX_CHECK)
715;
716#else
717 noexcept;
718#endif
719template <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.
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.
The Data Type intvector.
Definition intvector.hpp:52
The Data Type ivector.
Definition ivector.hpp:55
The Multiple-Precision Data Type l_imatrix.
The Multiple-Precision Data Type l_ivector.
Definition l_ivector.hpp:55
The Multiple-Precision Data Type l_rmatrix.
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
rvector_slice & operator()() noexcept
Operator for accessing the whole vector.
Definition rvector.hpp:1514
friend int Ub(const rvector_slice &sl) noexcept
Returns the upper bound of the vector.
Definition rvector.hpp:1494
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
friend rvector & SetLb(rvector &rv, const int &l) noexcept
Sets the lower bound of the vector.
Definition rvector.hpp:1007
rvector & operator+=(const srvector &rv)
Implementation of addition and allocation operation.
Definition srvector.hpp:578
friend rvector InfIm(const civector &v) noexcept
Returns componentwise the infimum of the imaginary part.
Definition civector.inl:616
rvector & operator=(const rvector &rv) noexcept
Implementation of standard assigning operator.
Definition rvector.inl:254
friend int VecLen(const rvector &rv) noexcept
Returns the dimension of the vector.
Definition rvector.hpp:1005
real & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector (read-only)
Definition rvector.inl:102
friend rvector InfRe(const civector &v) noexcept
Returns componentwise the infimum of the real part.
Definition civector.inl:576
friend rvector SupIm(const civector &v) noexcept
Returns componentwise the supremum of the imaginary part.
Definition civector.inl:637
rvector & operator()() noexcept
Operator for accessing the whole vector.
Definition rvector.hpp:1027
friend rvector SupRe(const civector &v) noexcept
Returns componentwise the supremum of the real part.
Definition civector.inl:659
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
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc) noexcept
Implementation of standard algebraic addition and allocation operation.
Definition cdot.inl:251
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
cimatrix & operator*=(cimatrix &m, const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
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.
cimatrix & operator/=(cimatrix &m, const cinterval &c) noexcept
Implementation of division and allocation operation.