C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
l_rvector.hpp
1 /*
2 ** CXSC is a C++ library for eXtended Scientific Computing (V 2.5.4)
3 **
4 ** Copyright (C) 1990-2000 Institut fuer Angewandte Mathematik,
5 ** Universitaet Karlsruhe, Germany
6 ** (C) 2000-2014 Wiss. Rechnen/Softwaretechnologie
7 ** Universitaet Wuppertal, Germany
8 **
9 ** This library is free software; you can redistribute it and/or
10 ** modify it under the terms of the GNU Library General Public
11 ** License as published by the Free Software Foundation; either
12 ** version 2 of the License, or (at your option) any later version.
13 **
14 ** This library is distributed in the hope that it will be useful,
15 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
16 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 ** Library General Public License for more details.
18 **
19 ** You should have received a copy of the GNU Library General Public
20 ** License along with this library; if not, write to the Free
21 ** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23 
24 /* CVS $Id: l_rvector.hpp,v 1.19 2014/01/30 17:23:46 cxsc Exp $ */
25 
26 #ifndef _CXSC_LRVECTOR_HPP_INCLUDED
27 #define _CXSC_LRVECTOR_HPP_INCLUDED
28 
29 #include "xscclass.hpp"
30 #include "except.hpp"
31 #include "dot.hpp"
32 #include "idot.hpp"
33 #include "l_real.hpp" // used for declaration of Inf, Sup,...
34 //#include "cxscmatr.hpp"
35 #include "rvector.hpp"
36 #include "vector.hpp"
37 
38 
39 #include <iostream>
40 
41 //#include "matrix.hpp" // hat hier eigentlich nichts zu suchen, sonst aber Internal Compiler Error #9
42 
43 namespace cxsc {
44 
45 class l_rvector_slice;
46 
48 
53 class l_rvector
54 {
55  friend class l_rvector_slice;
56  friend class l_rmatrix;
57  friend class l_rmatrix_subv;
58  friend class l_ivector;
59  friend class l_imatrix;
60  private:
61  l_real *dat;
62  int l,u,size;
63 
64  public:
65 //#if(CXSC_INDEX_CHECK)
66 
67 template<typename S, typename T>
68 friend inline void addDot(const S &x, const T &y, dotprecision &val);
69 
70 
71 #ifdef _CXSC_FRIEND_TPL
72  //------------ Templates --------------------------------------------------
73  // l_real
74 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m)
75 #if(CXSC_INDEX_CHECK)
76 ;
77 #else
78  noexcept;
79 #endif
80 template <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
108 template <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
114 template <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;
119 template <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
300 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
301 #if(CXSC_INDEX_CHECK)
302 ;
303 #else
304  noexcept;
305 #endif
306 template <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;
313 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
314 #if(CXSC_INDEX_CHECK)
315 ;
316 #else
317  noexcept;
318 #endif
319 template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
320 #if(CXSC_INDEX_CHECK)
321  ;
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 ---------------
348 template <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
500 template <class MV,class V> friend MV &_mvvsetinf(MV &v,const V &rv)
501 #if(CXSC_INDEX_CHECK)
502 ;
503 #else
504  noexcept;
505 #endif
506 template <class MV,class V> friend MV &_mvvsetsup(MV &v,const V &rv)
507 #if(CXSC_INDEX_CHECK)
508 ;
509 #else
510  noexcept;
511 #endif
512 template <class MV,class V> friend MV &_mvvusetinf(MV &v,const V &rv)
513 #if(CXSC_INDEX_CHECK)
514 ;
515 #else
516  noexcept;
517 #endif
518 template <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;
532 template <class MV,class V> friend V _mvdiam(const MV &mv) noexcept;
533 template <class MV,class V> friend V _mvmid(const MV &mv) noexcept;
534 template <class MV,class V> friend V _mvinf(const MV &mv) noexcept;
535 template <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 
563 template <class MV,class V> friend MV &_mvvconvassign(MV &v,const V &rv)
564 #if(CXSC_INDEX_CHECK)
565 ;
566 #else
567  noexcept;
568 #endif
569 template <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
585  explicit INLINE l_rvector(const class index &i) noexcept; // for backwards compatibility
587 #endif
588  explicit INLINE l_rvector(const int &i1,const int &i2)
590 #if(CXSC_INDEX_CHECK)
591 ;
592 #else
593  noexcept;
594 #endif
595  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
606  explicit INLINE l_rvector(const l_rmatrix_slice &sl)
608 #if(CXSC_INDEX_CHECK)
609 ;
610 #else
611  noexcept;
612 #endif
613  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
631  explicit INLINE l_rvector(const rmatrix_slice &sl)
633 #if(CXSC_INDEX_CHECK)
634 ;
635 #else
636  noexcept;
637 #endif
638  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
655  INLINE l_rvector &operator =(const l_rmatrix_slice &)
657 #if(CXSC_INDEX_CHECK)
658 ;
659 #else
660  noexcept;
661 #endif
662  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
678  INLINE l_rvector &operator =(const rmatrix_slice &)
680 #if(CXSC_INDEX_CHECK)
681 ;
682 #else
683  noexcept;
684 #endif
685  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
699  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
716  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
725  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 
758 template<typename S, typename T>
759 friend inline void addDot(const S &x, const T &y, dotprecision &val);
760 
761 
762 #ifdef _CXSC_FRIEND_TPL
763 //------------------------- Templates -------------------------------------------
764 // l_real / l_real
765 
766  template <class VS1,class VS2> friend VS1 & _vsvsassign(VS1 &sl1,const VS2 &sl2)
767 #if(CXSC_INDEX_CHECK)
768  ;
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
1025  INLINE l_rvector_slice & operator =(const l_rvector &rv)
1027 #if(CXSC_INDEX_CHECK)
1028 ;
1029 #else
1030  noexcept;
1031 #endif
1032  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
1041  INLINE l_rvector_slice & operator =(const l_rmatrix_slice &m)
1043 #if(CXSC_INDEX_CHECK)
1044 ;
1045 #else
1046  noexcept;
1047 #endif
1048  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
1058  INLINE l_rvector_slice & operator =(const rvector &rv)
1060 #if(CXSC_INDEX_CHECK)
1061 ;
1062 #else
1063  noexcept;
1064 #endif
1065  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
1074  INLINE l_rvector_slice & operator =(const rmatrix_slice &m)
1076 #if(CXSC_INDEX_CHECK)
1077 ;
1078 #else
1079  noexcept;
1080 #endif
1081  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
1152  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
1165  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
1174  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
1195  INLINE l_rvector_slice &operator *=(const rmatrix &m)
1197 #if(CXSC_INDEX_CHECK)
1198 ;
1199 #else
1200  noexcept;
1201 #endif
1202  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
1211  INLINE l_rvector_slice &operator +=(const l_rvector_slice &sl2)
1213 #if(CXSC_INDEX_CHECK)
1214 ;
1215 #else
1216  noexcept;
1217 #endif
1218  INLINE l_rvector_slice &operator -=(const l_rvector &rv)
1220 #if(CXSC_INDEX_CHECK)
1221 ;
1222 #else
1223  noexcept;
1224 #endif
1225  INLINE l_rvector_slice &operator -=(const l_rvector_slice &sl2)
1227 #if(CXSC_INDEX_CHECK)
1228 ;
1229 #else
1230  noexcept;
1231 #endif
1232  INLINE l_rvector_slice &operator |=(const l_rvector &rv)
1234 #if(CXSC_INDEX_CHECK)
1235 ;
1236 #else
1237  noexcept;
1238 #endif
1239  INLINE l_rvector_slice &operator |=(const l_rvector_slice &sl2)
1241 #if(CXSC_INDEX_CHECK)
1242 ;
1243 #else
1244  noexcept;
1245 #endif
1246  INLINE l_rvector_slice &operator &=(const l_rvector &rv)
1248 #if(CXSC_INDEX_CHECK)
1249 ;
1250 #else
1251  noexcept;
1252 #endif
1253  INLINE l_rvector_slice &operator &=(const l_rvector_slice &sl2)
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
1268  INLINE l_rvector_slice &operator +=(const rvector_slice &sl2)
1270 #if(CXSC_INDEX_CHECK)
1271 ;
1272 #else
1273  noexcept;
1274 #endif
1275  INLINE l_rvector_slice &operator -=(const rvector &rv)
1277 #if(CXSC_INDEX_CHECK)
1278 ;
1279 #else
1280  noexcept;
1281 #endif
1282  INLINE l_rvector_slice &operator -=(const rvector_slice &sl2)
1284 #if(CXSC_INDEX_CHECK)
1285 ;
1286 #else
1287  noexcept;
1288 #endif
1289  INLINE l_rvector_slice &operator |=(const rvector &rv)
1291 #if(CXSC_INDEX_CHECK)
1292 ;
1293 #else
1294  noexcept;
1295 #endif
1296  INLINE l_rvector_slice &operator |=(const rvector_slice &sl2)
1298 #if(CXSC_INDEX_CHECK)
1299 ;
1300 #else
1301  noexcept;
1302 #endif
1303  INLINE l_rvector_slice &operator &=(const rvector &rv)
1305 #if(CXSC_INDEX_CHECK)
1306 ;
1307 #else
1308  noexcept;
1309 #endif
1310  INLINE l_rvector_slice &operator &=(const rvector_slice &sl2)
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
1349  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
1443  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
1450  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
1457  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
1464  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
1471  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
1478  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
1485  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
1492  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
1499  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
1506  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
1513  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
1520  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
1527  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
1543  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
1550  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
1557  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
1577  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
1584  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
1591  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
1598  INLINE l_rvector & operator +=(l_rvector &rv1, const l_rvector &rv2)
1600 #if(CXSC_INDEX_CHECK)
1601 ;
1602 #else
1603  noexcept;
1604 #endif
1605  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
1624  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
1631  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
1638  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
1645  INLINE l_rvector & operator -=(l_rvector &rv1, const l_rvector &rv2)
1647 #if(CXSC_INDEX_CHECK)
1648 ;
1649 #else
1650  noexcept;
1651 #endif
1652  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
1719  INLINE void accumulate(dotprecision &dp, const rvector & rv1, const l_rvector &rv2)
1721 #if(CXSC_INDEX_CHECK)
1722 ;
1723 #else
1724  noexcept;
1725 #endif
1726  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
1733  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
1740  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
1747  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
1754  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
1761  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
1768  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
1775  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
1782  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
1789  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
1796  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
1803  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
1810  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
1817  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
1824  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
1831  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
1846  INLINE void accumulate(idotprecision &dp, const rvector & rv1, const l_rvector &rv2)
1848 #if(CXSC_INDEX_CHECK)
1849 ;
1850 #else
1851  noexcept;
1852 #endif
1853  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
1860  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
1867  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
1874  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
1881  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
1888  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
1895  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
1902  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
1909  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
1916  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
1923  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
1930  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
1937  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
1944  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
1951  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
1958  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
1973  INLINE l_real operator *(const rvector_slice &sl, const l_rvector &rv)
1975 #if(CXSC_INDEX_CHECK)
1976 ;
1977 #else
1978  noexcept;
1979 #endif
1980  INLINE l_real operator *(const rvector &rv, const l_rvector_slice &sl)
1982 #if(CXSC_INDEX_CHECK)
1983 ;
1984 #else
1985  noexcept;
1986 #endif
1987  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
2002  INLINE l_real operator *(const l_rvector_slice &sl, const rvector &rv)
2004 #if(CXSC_INDEX_CHECK)
2005 ;
2006 #else
2007  noexcept;
2008 #endif
2009  INLINE l_real operator *(const l_rvector &rv, const rvector_slice &sl)
2011 #if(CXSC_INDEX_CHECK)
2012 ;
2013 #else
2014  noexcept;
2015 #endif
2016  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
2031  INLINE l_rvector operator +(const rvector &rv, const l_rvector_slice &sl)
2033 #if(CXSC_INDEX_CHECK)
2034 ;
2035 #else
2036  noexcept;
2037 #endif
2038  INLINE l_rvector operator +(const rvector_slice &sl, const l_rvector &rv)
2040 #if(CXSC_INDEX_CHECK)
2041 ;
2042 #else
2043  noexcept;
2044 #endif
2045  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
2060  INLINE l_rvector operator +(const l_rvector &rv, const rvector_slice &sl)
2062 #if(CXSC_INDEX_CHECK)
2063 ;
2064 #else
2065  noexcept;
2066 #endif
2067  INLINE l_rvector operator +(const l_rvector_slice &sl, const rvector &rv)
2069 #if(CXSC_INDEX_CHECK)
2070 ;
2071 #else
2072  noexcept;
2073 #endif
2074  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
2089  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
2104  INLINE l_rvector operator -(const rvector &rv, const l_rvector_slice &sl)
2106 #if(CXSC_INDEX_CHECK)
2107 ;
2108 #else
2109  noexcept;
2110 #endif
2111  INLINE l_rvector operator -(const rvector_slice &sl, const l_rvector &rv)
2113 #if(CXSC_INDEX_CHECK)
2114 ;
2115 #else
2116  noexcept;
2117 #endif
2118  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
2133  INLINE l_rvector operator -(const l_rvector &rv, const rvector_slice &sl)
2135 #if(CXSC_INDEX_CHECK)
2136 ;
2137 #else
2138  noexcept;
2139 #endif
2140  INLINE l_rvector operator -(const l_rvector_slice &sl, const rvector &rv)
2142 #if(CXSC_INDEX_CHECK)
2143 ;
2144 #else
2145  noexcept;
2146 #endif
2147  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
2154  INLINE l_rvector & operator -=(l_rvector &rv1, const rvector &rv2)
2156 #if(CXSC_INDEX_CHECK)
2157 ;
2158 #else
2159  noexcept;
2160 #endif
2161  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 
cxsc::l_rvector_slice::Lb
friend int Lb(const l_rvector_slice &sl) noexcept
Returns the lower bound of the vector.
Definition: l_rvector.hpp:1153
cxsc::l_rvector_slice::Ub
friend int Ub(const l_rvector_slice &sl) noexcept
Returns the upper bound of the vector.
Definition: l_rvector.hpp:1155
cxsc::l_rmatrix_slice
The Multiple-Precision Data Type l_rmatrix_slice.
Definition: l_rmatrix.hpp:1000
cxsc::l_rvector_slice::operator|=
l_rvector_slice & operator|=(const l_rvector &rv) noexcept
Allocates the convex hull of the arguments to the first argument.
cxsc::l_rvector_slice::l_rvector_slice
l_rvector_slice(const l_rvector_slice &a) noexcept
Constructor of class l_rvector_slice.
Definition: l_rvector.hpp:1015
cxsc::l_rvector::operator()
l_rvector & operator()() noexcept
Operator for accessing the whole vector.
Definition: l_rvector.hpp:717
cxsc::l_rvector_slice::VecLen
friend int VecLen(const l_rvector_slice &sl) noexcept
Returns the dimension of the vector.
Definition: l_rvector.hpp:1157
cxsc::l_rvector::Lb
friend int Lb(const l_rvector &rv) noexcept
Returns the lower bound of the vector.
Definition: l_rvector.hpp:700
cxsc::_l_rvector
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.
Definition: l_rmatrix.inl:102
cxsc::l_rmatrix_subv
The Multiple-Precision Data Type l_rmatrix_subv.
Definition: l_rmatrix.hpp:47
cxsc::operator*=
cimatrix & operator*=(cimatrix &m, const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
Definition: cimatrix.inl:1605
cxsc::operator/
civector operator/(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of division operation.
Definition: cimatrix.inl:730
cxsc::l_rvector_slice::l_rvector_slice
l_rvector_slice(l_rvector &a, const int &lb, const int &ub) noexcept
Constructor of class l_rvector_slice.
Definition: l_rvector.hpp:1010
cxsc::l_real::l_real
l_real(void) noexcept
Constructor of class l_real.
Definition: l_real.cpp:174
cxsc::rmatrix
The Data Type rmatrix.
Definition: rmatrix.hpp:471
cxsc::abs
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737
cxsc::operator/=
cimatrix & operator/=(cimatrix &m, const cinterval &c) noexcept
Implementation of division and allocation operation.
Definition: cimatrix.inl:1623
cxsc::l_rmatrix
The Multiple-Precision Data Type l_rmatrix.
Definition: l_rmatrix.hpp:416
cxsc::rvector
The Data Type rvector.
Definition: rvector.hpp:58
cxsc::l_rvector::VecLen
friend int VecLen(const l_rvector &rv) noexcept
Returns the dimension of the vector.
Definition: l_rvector.hpp:704
cxsc::l_rvector::SetUb
friend l_rvector & SetUb(l_rvector &rv, const int &u) noexcept
Sets the upper bound of the vector.
Definition: l_rvector.hpp:708
cxsc::l_imatrix
The Multiple-Precision Data Type l_imatrix.
Definition: l_imatrix.hpp:726
cxsc::rvector_slice
The Data Type rvector_slice.
Definition: rvector.hpp:1064
cxsc::l_rvector_slice::operator*=
l_rvector_slice & operator*=(const l_real &r) noexcept
Implementation of multiplication and allocation operation.
Definition: l_rvector.inl:306
cxsc::operator*
civector operator*(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of multiplication operation.
Definition: cimatrix.inl:731
cxsc::dotprecision
The Data Type dotprecision.
Definition: dot.hpp:112
cxsc::l_rvector_slice::operator+=
l_rvector_slice & operator+=(const l_rvector &rv) noexcept
Implementation of addition and allocation operation.
Definition: l_rvector.inl:519
cxsc::l_rvector_slice::l_rvector_slice
l_rvector_slice(l_rvector_slice &a, const int &lb, const int &ub) noexcept
Constructor of class l_rvector_slice.
Definition: l_rvector.hpp:1012
cxsc::l_rvector::operator[]
l_real & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector.
Definition: l_rvector.inl:100
cxsc::l_rvector::Ub
friend int Ub(const l_rvector &rv) noexcept
Returns the upper bound of the vector.
Definition: l_rvector.hpp:702
cxsc::l_rvector::operator=
l_rvector & operator=(const l_rvector &rv) noexcept
Implementation of standard assigning operator.
Definition: l_rvector.inl:235
cxsc::l_rvector_slice::operator&=
l_rvector_slice & operator&=(const l_rvector &rv) noexcept
Allocates the intersection of the arguments to the first argument.
cxsc::l_rvector_slice
The Multiple-Precision Data Type l_rvector_slice.
Definition: l_rvector.hpp:745
cxsc::rmatrix_subv
The Data Type rmatrix_subv.
Definition: rmatrix.hpp:54
cxsc
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
cxsc::l_rvector_slice::operator-=
l_rvector_slice & operator-=(const l_rvector &rv) noexcept
Implementation of subtraction and allocation operation.
Definition: l_rvector.inl:578
cxsc::operator+=
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc) noexcept
Implementation of standard algebraic addition and allocation operation.
Definition: cdot.inl:251
cxsc::l_real
The Multiple-Precision Data Type l_real.
Definition: l_real.hpp:78
cxsc::l_rvector::SetLb
friend l_rvector & SetLb(l_rvector &rv, const int &l) noexcept
Sets the lower bound of the vector.
Definition: l_rvector.hpp:706
cxsc::l_rvector_slice::operator=
l_rvector_slice & operator=(const l_rvector_slice &sl) noexcept
Implementation of standard assigning operator.
Definition: l_rvector.inl:240
cxsc::l_rvector_slice::operator/=
l_rvector_slice & operator/=(const l_real &r) noexcept
Implementation of division and allocation operation.
Definition: l_rvector.inl:311
cxsc::rmatrix_slice
The Data Type rmatrix_slice.
Definition: rmatrix.hpp:1443
cxsc::l_rvector
The Multiple-Precision Data Type l_rvector.
Definition: l_rvector.hpp:54
cxsc::l_ivector
The Multiple-Precision Data Type l_ivector.
Definition: l_ivector.hpp:55
cxsc::l_rvector_slice::operator()
l_rvector_slice & operator()() noexcept
Operator for accessing the whole vector.
Definition: l_rvector.hpp:1166
cxsc::Resize
void Resize(cimatrix &A) noexcept
Resizes the matrix.
Definition: cimatrix.inl:1211
cxsc::l_rvector_slice::operator[]
l_real & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector.
Definition: l_rvector.inl:113
cxsc::real
The Scalar Type real.
Definition: real.hpp:114
cxsc::l_rvector::l_rvector
l_rvector() noexcept
Constructor of class l_rvector.
Definition: l_rvector.inl:31