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