C-XSC - A C++ Class Library for Extended Scientific Computing 2.5.4
rmatrix.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: rmatrix.hpp,v 1.46 2014/01/30 17:23:48 cxsc Exp $ */
25
26#ifndef _CXSC_RMATRIX_HPP_INCLUDED
27#define _CXSC_RMATRIX_HPP_INCLUDED
28
29#include "xscclass.hpp"
30
31#include "dot.hpp"
32#include "idot.hpp"
33#include "cidot.hpp"
34#include "rvector.hpp"
35#include "except.hpp"
36#include "matrix.hpp"
37
38namespace cxsc {
39
40class rmatrix;
41class rmatrix_slice;
42class srmatrix;
43class srmatrix_slice;
44class srmatrix_subv;
45class srvector;
46class srvector_slice;
47
48
50
54{
55 friend class rvector;
56 friend class ivector; // wegen ivector::ivector(const rmatrix_subv &)
57 friend class cvector;
58 friend class civector;
59 friend class l_rvector;
60 friend class l_ivector;
61 friend class rmatrix;
62 friend class rmatrix_slice;
63 private:
64 real *dat;
65 int lb,ub;
66 int size,start,offset; // start=first element index 0..n-1
67
68 public:
70 friend INLINE rmatrix_subv Row(rmatrix &m,const int &i)
71#if(CXSC_INDEX_CHECK)
72;
73#else
74 noexcept;
75#endif
77 friend INLINE rmatrix_subv Col(rmatrix &m,const int &i)
78#if(CXSC_INDEX_CHECK)
79;
80#else
81 noexcept;
82#endif
84 friend INLINE rmatrix_subv Row(const rmatrix &m,const int &i)
85#if(CXSC_INDEX_CHECK)
86;
87#else
88 noexcept;
89#endif
91 friend INLINE rmatrix_subv Col(const rmatrix &m,const int &i)
92#if(CXSC_INDEX_CHECK)
93;
94#else
95 noexcept;
96#endif
97
98//#if(CXSC_INDEX_CHECK)
99
100
101#ifdef _CXSC_FRIEND_TPL
102 //----------------- Templates ---------------------------------------
103template <class MV1,class MV2> friend MV1 &_mvmvassign(MV1 &v,const MV2 &rv)
104#if(CXSC_INDEX_CHECK)
105;
106#else
107 noexcept;
108#endif
109template <class MV,class S> friend MV &_mvsassign(MV &v,const S &r) noexcept;
110template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
111#if(CXSC_INDEX_CHECK)
112;
113#else
114 noexcept;
115#endif
116template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) noexcept;
117template <class MV,class V> friend V _mvabs(const MV &mv) noexcept;
118template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
119#if(CXSC_INDEX_CHECK)
120 ;
121#else
122 noexcept;
123#endif
124
125template <class DP,class MV1,class MV2> friend void _mvmvaccu(DP &dp, const MV1 & rv1, const MV2 &rv2)
126#if(CXSC_INDEX_CHECK)
127 ;
128#else
129 noexcept;
130#endif
131
132 template <class MV1,class MV2,class S> friend S _mvmvmult(const MV1 & rv1, const MV2 &rv2)
133#if(CXSC_INDEX_CHECK)
134 ;
135#else
136 noexcept;
137#endif
138 template <class V,class MV,class S> friend S _vmvmult(const V &rv1, const MV &rv2)
139#if(CXSC_INDEX_CHECK)
140 ;
141#else
142 noexcept;
143#endif
144 template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) noexcept;
145 template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
146#if(CXSC_INDEX_CHECK)
147 ;
148#else
149 noexcept;
150#endif
151 template <class MV1,class MV2,class E> friend E _mvmvminus(const MV1 &rv1, const MV2 &rv2)
152#if(CXSC_INDEX_CHECK)
153 ;
154#else
155 noexcept;
156#endif
157 template <class MV,class V,class E> friend E _mvvplus(const MV &rv1, const V &rv2)
158#if(CXSC_INDEX_CHECK)
159 ;
160#else
161 noexcept;
162#endif
163 template <class MV,class V,class E> friend E _mvvminus(const MV &rv1, const V &rv2)
164#if(CXSC_INDEX_CHECK)
165 ;
166#else
167 noexcept;
168#endif
169 template <class V,class MV,class E> friend E _vmvminus(const V &rv1, const MV &rv2)
170#if(CXSC_INDEX_CHECK)
171 ;
172#else
173 noexcept;
174#endif
175 template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) noexcept;
176template <class MV,class S> friend MV &_mvsmultassign(MV &v,const S &r) noexcept;
177template <class MV, class S> friend MV &_mvsplusassign(MV &v,const S &r) noexcept;
178template <class MV,class S> friend MV &_mvsminusassign(MV &v,const S &r) noexcept;
179template <class MV,class S> friend MV &_mvsdivassign(MV &v,const S &r) noexcept;
180template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
181#if(CXSC_INDEX_CHECK)
182;
183#else
184 noexcept;
185#endif
186template <class V,class MV> friend V &_vmvplusassign(V &rv,const MV &v)
187#if(CXSC_INDEX_CHECK)
188;
189#else
190 noexcept;
191#endif
192template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv)
193#if(CXSC_INDEX_CHECK)
194;
195#else
196 noexcept;
197#endif
198template <class V,class MV> friend V &_vmvminusassign(V &rv,const MV &v)
199#if(CXSC_INDEX_CHECK)
200;
201#else
202 noexcept;
203#endif
204 template <class MV1,class MV2,class E> friend E _mvmvconv(const MV1 &rv1, const MV2 &rv2)
205#if(CXSC_INDEX_CHECK)
206 ;
207#else
208 noexcept;
209#endif
210 template <class MV,class V,class E> friend E _mvvconv(const MV &rv1, const V &rv2)
211#if(CXSC_INDEX_CHECK)
212 ;
213#else
214 noexcept;
215#endif
216
217 // interval
218
219
220template <class V,class MV> friend V &_vmvsetinf(V &rv,const MV &v)
221#if(CXSC_INDEX_CHECK)
222;
223#else
224 noexcept;
225#endif
226template <class V,class MV> friend V &_vmvsetsup(V &rv,const MV &v)
227#if(CXSC_INDEX_CHECK)
228;
229#else
230 noexcept;
231#endif
232template <class V,class MV> friend V &_vmvusetinf(V &rv,const MV &v)
233#if(CXSC_INDEX_CHECK)
234;
235#else
236 noexcept;
237#endif
238template <class V,class MV> friend V &_vmvusetsup(V &rv,const MV &v)
239#if(CXSC_INDEX_CHECK)
240;
241#else
242 noexcept;
243#endif
244
245 // complex
246
247
248template <class V,class MV> friend V &_vmvsetim(V &rv,const MV &v)
249#if(CXSC_INDEX_CHECK)
250;
251#else
252 noexcept;
253#endif
254template <class V,class MV> friend V &_vmvsetre(V &rv,const MV &v)
255#if(CXSC_INDEX_CHECK)
256;
257#else
258 noexcept;
259#endif
260
261#endif
262
263 //----------------- Konstruktoren ----------------------------------
264
266 explicit INLINE rmatrix_subv (real *d, const int &l, const int &u, const int &s, const int &st, const int &o) noexcept:dat(d),lb(l),ub(u),size(s),start(st),offset(o) { }
267 public:
269 INLINE rmatrix_subv(const rmatrix_subv &v) noexcept:dat(v.dat),lb(v.lb),ub(v.ub),size(v.size),start(v.start),offset(v.offset) { }
270 public:
271
272 //---------------------- Standardfunktionen ------------------------
273
274 friend INLINE rvector::rvector(const rmatrix_subv &) noexcept;
276 INLINE rmatrix_subv &operator =(const rmatrix_subv &rv) noexcept;
278 INLINE rmatrix_subv &operator =(const real &r) noexcept;
280 INLINE rmatrix_subv &operator =(const srmatrix_subv &m);
282 INLINE rmatrix_subv &operator =(const srvector &m);
284 INLINE rmatrix_subv &operator =(const srvector_slice &m);
286 INLINE rmatrix_subv &operator =(const rmatrix &m)
287#if(CXSC_INDEX_CHECK)
288;
289#else
290 noexcept;
291#endif
293 INLINE rmatrix_subv &operator =(const rmatrix_slice &m)
294#if(CXSC_INDEX_CHECK)
295;
296#else
297 noexcept;
298#endif
300 INLINE rmatrix_subv &operator =(const rvector &v)
301#if(CXSC_INDEX_CHECK)
302;
303#else
304 noexcept;
305#endif
307 INLINE rmatrix_subv &operator =(const rvector_slice &v)
308#if(CXSC_INDEX_CHECK)
309;
310#else
311 noexcept;
312#endif
314 friend INLINE int Lb(const rmatrix_subv &rv) noexcept { return rv.lb; }
316 friend INLINE int Ub(const rmatrix_subv &rv) noexcept { return rv.ub; }
318 friend INLINE int VecLen(const rmatrix_subv &rv) noexcept { return rv.size; }
319
321 INLINE real &operator [](const int &i) const
322#if(CXSC_INDEX_CHECK)
323;
324#else
325 noexcept;
326#endif
327
329 INLINE real &operator [](const int &i)
330#if(CXSC_INDEX_CHECK)
331;
332#else
333 noexcept;
334#endif
335
337 INLINE rmatrix_subv &operator ()() noexcept { return *this; }
339 INLINE rmatrix_subv operator ()(const int &i)
340#if(CXSC_INDEX_CHECK)
341;
342#else
343 noexcept;
344#endif
346 INLINE rmatrix_subv operator ()(const int &i1,const int &i2)
347#if(CXSC_INDEX_CHECK)
348;
349#else
350 noexcept;
351#endif
352
354 INLINE rmatrix_subv &operator *=(const real &c) noexcept;
356 INLINE rmatrix_subv &operator +=(const real &c) noexcept;
358 INLINE rmatrix_subv &operator -=(const real &c) noexcept;
360 INLINE rmatrix_subv &operator /=(const real &c) noexcept;
361
363 INLINE rmatrix_subv &operator +=(const srvector &rv);
365 INLINE rmatrix_subv &operator +=(const srvector_slice &rv);
367 INLINE rmatrix_subv &operator +=(const srmatrix_subv &rv);
368
374 INLINE rmatrix_subv &operator -=(const srmatrix_subv &rv);
375
377 INLINE rmatrix_subv &operator -=(const rvector &rv)
378#if(CXSC_INDEX_CHECK)
379;
380#else
381 noexcept;
382#endif
384 INLINE rmatrix_subv &operator -=(const rvector_slice &rv)
385#if(CXSC_INDEX_CHECK)
386;
387#else
388 noexcept;
389#endif
391 INLINE rmatrix_subv &operator +=(const rvector &rv)
392#if(CXSC_INDEX_CHECK)
393;
394#else
395 noexcept;
396#endif
398 INLINE rmatrix_subv &operator +=(const rvector_slice &rv)
399#if(CXSC_INDEX_CHECK)
400;
401#else
402 noexcept;
403#endif
404//#else
405//#endif
406
407};
408
409
411INLINE rmatrix_subv Row(rmatrix &m,const int &i)
412#if(CXSC_INDEX_CHECK)
413;
414#else
415 noexcept;
416#endif
417
419INLINE rmatrix_subv Col(rmatrix &m,const int &i)
420#if(CXSC_INDEX_CHECK)
421;
422#else
423 noexcept;
424#endif
425
427INLINE rmatrix_subv Row(const rmatrix &m,const int &i)
428#if(CXSC_INDEX_CHECK)
429;
430#else
431 noexcept;
432#endif
433
435INLINE rmatrix_subv Col(const rmatrix &m,const int &i)
436#if(CXSC_INDEX_CHECK)
437;
438#else
439 noexcept;
440#endif
441
442
443//----------------------- Matrix -----------------------------------------------
444
445class rmatrix_slice;
446
448
471{
472 friend class rmatrix_slice;
473 friend class rmatrix_subv;
474 friend class imatrix;
475 friend class cmatrix;
476 friend class cimatrix;
477 friend class l_rmatrix;
478 friend class l_imatrix;
479 private:
480 real *dat;
481 int lb1,ub1,lb2,ub2,xsize,ysize;
482
483 public:
484 double* to_blas_array() const { return (double*)dat; }
485//#if(CXSC_INDEX_CHECK)
486#ifdef _CXSC_FRIEND_TPL
487 //----------------- Templates ---------------------------------------
488template <class S,class M> friend void _smconstr(S &s,const M &m)
489#if(CXSC_INDEX_CHECK)
490;
491#else
492 noexcept;
493#endif
494template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
495#if(CXSC_INDEX_CHECK)
496;
497#else
498 noexcept;
499#endif
500 template <class M1,class M2,class S> friend M1 &_mmassign(M1 &m1,const M2 &m,S ms) noexcept;
501 template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) noexcept;
502 template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m)
503#if(CXSC_INDEX_CHECK)
504 ;
505#else
506 noexcept;
507#endif
508 template <class M,class S> friend M &_msassign(M &m,const S &r) noexcept;
509template <class V,class M,class S> friend V &_vmassign(V &v,const M &m)
510#if(CXSC_INDEX_CHECK)
511;
512#else
513 noexcept;
514#endif
515template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) noexcept;
516 template <class M> friend int _mlb(const M &m, const int &i)
517#if(CXSC_INDEX_CHECK)
518;
519#else
520 noexcept;
521#endif
522 template <class M> friend int _mub(const M &m, const int &i)
523#if(CXSC_INDEX_CHECK)
524;
525#else
526 noexcept;
527#endif
528 template <class M> friend M &_msetlb(M &m, const int &i,const int &j)
529#if(CXSC_INDEX_CHECK)
530;
531#else
532 noexcept;
533#endif
534 template <class M> friend M &_msetub(M &m, const int &i,const int &j)
535#if(CXSC_INDEX_CHECK)
536;
537#else
538 noexcept;
539#endif
540 template <class M> friend void _mresize(M &A) noexcept;
541 template <class M,class S> friend void _mresize(M &A,const int &m, const int &n)
542#if(CXSC_INDEX_CHECK)
543 ;
544#else
545 noexcept;
546#endif
547 template <class M,class S> friend void _mresize(M &A,const int &m1, const int &m2,const int &n1,const int &n2)
548#if(CXSC_INDEX_CHECK)
549 ;
550#else
551 noexcept;
552#endif
553 template <class M,class E> friend E _mabs(const M &m) noexcept;
554 template <class MS,class E> friend E _msabs(const MS &ms) noexcept;
555 //------- matrix-matrix --------------
556 template <class M1,class M2,class E> friend E _mmplus(const M1 &m1,const M2 &m2)
557#if(CXSC_INDEX_CHECK)
558 ;
559#else
560 noexcept;
561#endif
562 template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms)
563#if(CXSC_INDEX_CHECK)
564 ;
565#else
566 noexcept;
567#endif
568 template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2)
569#if(CXSC_INDEX_CHECK)
570 ;
571#else
572 noexcept;
573#endif
574 template <class M> friend M _mminus(const M &m) noexcept;
575 template <class MS,class E> friend E _msminus(const MS &ms) noexcept;
576 template <class M1,class M2,class E> friend E _mmminus(const M1 &m1,const M2 &m2)
577#if(CXSC_INDEX_CHECK)
578 ;
579#else
580 noexcept;
581#endif
582 template <class M1,class M2> friend M1 &_mmplusassign(M1 &m1,const M2 &m2)
583#if(CXSC_INDEX_CHECK)
584 ;
585#else
586 noexcept;
587#endif
588 template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms)
589#if(CXSC_INDEX_CHECK)
590 ;
591#else
592 noexcept;
593#endif
594 template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1)
595#if(CXSC_INDEX_CHECK)
596 ;
597#else
598 noexcept;
599#endif
600 template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms)
601#if(CXSC_INDEX_CHECK)
602 ;
603#else
604 noexcept;
605#endif
606 template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m)
607#if(CXSC_INDEX_CHECK)
608 ;
609#else
610 noexcept;
611#endif
612 template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2)
613#if(CXSC_INDEX_CHECK)
614 ;
615#else
616 noexcept;
617#endif
618 template <class M1,class M2> friend M1 &_mmminusassign(M1 &m1,const M2 &m2)
619#if(CXSC_INDEX_CHECK)
620 ;
621#else
622 noexcept;
623#endif
624 template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms)
625#if(CXSC_INDEX_CHECK)
626 ;
627#else
628 noexcept;
629#endif
630 template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1)
631#if(CXSC_INDEX_CHECK)
632 ;
633#else
634 noexcept;
635#endif
636 template <class M1,class M2,class E> friend E _mmmult(const M1 &m1, const M2 &m2)
637#if(CXSC_INDEX_CHECK)
638 ;
639#else
640 noexcept;
641#endif
642 template <class M1,class M2,class S> friend M1 &_mmmultassign(M1 &m1,const M2 &m2)
643#if(CXSC_INDEX_CHECK)
644 ;
645#else
646 noexcept;
647#endif
648 template <class M,class MS,class E> friend E _mmsmult(const M &m1, const MS &ms)
649#if(CXSC_INDEX_CHECK)
650 ;
651#else
652 noexcept;
653#endif
654 template <class MS,class M,class E> friend E _msmmult(const MS &ms, const M &m2)
655#if(CXSC_INDEX_CHECK)
656 ;
657#else
658 noexcept;
659#endif
660 template <class M,class MS,class S> friend M &_mmsmultassign(M &m1,const MS &ms)
661#if(CXSC_INDEX_CHECK)
662 ;
663#else
664 noexcept;
665#endif
666 template <class MS1,class MS2,class E> friend E _msmsmult(const MS1 &ms1, const MS2 &ms2)
667#if(CXSC_INDEX_CHECK)
668 ;
669#else
670 noexcept;
671#endif
672 template <class M1,class M2,class E> friend E _mmconv(const M1 &m1,const M2 &m2)
673#if(CXSC_INDEX_CHECK)
674 ;
675#else
676 noexcept;
677#endif
678 template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms)
679#if(CXSC_INDEX_CHECK)
680 ;
681#else
682 noexcept;
683#endif
684 //-------- matrix-scalar ---------------------
685 template <class S,class M,class E> friend E _smmult(const S &c, const M &m) noexcept;
686 template <class M,class S> friend M &_msmultassign(M &m,const S &c) noexcept;
687 template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) noexcept;
688 template <class M,class S,class E> friend E _msdiv(const M &m,const S &c) noexcept;
689 template <class M,class S> friend M &_msdivassign(M &m,const S &c) noexcept;
690 template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) noexcept;
691 //--------- matrix-vector --------------------
692 template <class M,class V,class E> friend E _mvmult(const M &m,const V &v)
693#if(CXSC_INDEX_CHECK)
694 ;
695#else
696 noexcept;
697#endif
698 template <class V,class M,class E> friend E _vmmult(const V &v,const M &m)
699#if(CXSC_INDEX_CHECK)
700 ;
701#else
702 noexcept;
703#endif
704 template <class V,class M,class S> friend V &_vmmultassign(V &v,const M &m)
705#if(CXSC_INDEX_CHECK)
706 ;
707#else
708 noexcept;
709#endif
710 template <class VS,class M,class S> friend VS &_vsmmultassign(VS &v,const M &m)
711#if(CXSC_INDEX_CHECK)
712 ;
713#else
714 noexcept;
715#endif
716
717 template <class M> friend void *_mvoid(const M &m) noexcept;
718 template <class M> friend bool _mnot(const M &m) noexcept;
719 template <class MS> friend void *_msvoid(const MS &ms) noexcept;
720 template <class MS> friend bool _msnot(const MS &ms) noexcept;
721 template <class M1,class M2> friend bool _mmeq(const M1 &m1,const M2 &m2) noexcept;
722 template <class M1,class M2> friend bool _mmneq(const M1 &m1,const M2 &m2) noexcept;
723 template <class M1,class M2> friend bool _mmless(const M1 &m1,const M2 &m2) noexcept;
724 template <class M1,class M2> friend bool _mmleq(const M1 &m1,const M2 &m2) noexcept;
725 template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) noexcept;
726 template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) noexcept;
727 template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) noexcept;
728 template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) noexcept;
729 template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) noexcept;
730 template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) noexcept;
731 template <class M> friend std::ostream &_mout(std::ostream &s,const M &r) noexcept;
732 template <class M> friend std::istream &_min(std::istream &s,M &r) noexcept;
733
734 // Interval
735
736template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
737#if(CXSC_INDEX_CHECK)
738;
739#else
740 noexcept;
741#endif
742
743 template <class M,class E> friend E _mdiam(const M &m) noexcept;
744 template <class M,class E> friend E _mmid(const M &m) noexcept;
745 template <class MS,class E> friend E _msdiam(const MS &ms) noexcept;
746 template <class MS,class E> friend E _msmid(const MS &ms) noexcept;
747 template <class M,class E> friend E _minf(const M &m) noexcept;
748 template <class M,class E> friend E _msup(const M &m) noexcept;
749 template <class M1,class M2> friend M1 &_mmsetinf(M1 &m1,const M2 &m2)
750#if(CXSC_INDEX_CHECK)
751 ;
752#else
753 noexcept;
754#endif
755 template <class M1,class M2> friend M1 &_mmsetsup(M1 &m1,const M2 &m2)
756#if(CXSC_INDEX_CHECK)
757 ;
758#else
759 noexcept;
760#endif
761 template <class M1,class M2> friend M1 &_mmusetinf(M1 &m1,const M2 &m2)
762#if(CXSC_INDEX_CHECK)
763 ;
764#else
765 noexcept;
766#endif
767 template <class M1,class M2> friend M1 &_mmusetsup(M1 &m1,const M2 &m2)
768#if(CXSC_INDEX_CHECK)
769 ;
770#else
771 noexcept;
772#endif
773 template <class MS,class E> friend E _msinf(const MS &ms) noexcept;
774 template <class MS,class E> friend E _mssup(const MS &ms) noexcept;
775 template <class MS1,class M2> friend MS1 &_msmsetinf(MS1 &ms1,const M2 &m2)
776#if(CXSC_INDEX_CHECK)
777 ;
778#else
779 noexcept;
780#endif
781 template <class MS1,class M2> friend MS1 &_msmsetsup(MS1 &ms1,const M2 &m2)
782#if(CXSC_INDEX_CHECK)
783 ;
784#else
785 noexcept;
786#endif
787 template <class MS1,class M2> friend MS1 &_msmusetinf(MS1 &ms1,const M2 &m2)
788#if(CXSC_INDEX_CHECK)
789 ;
790#else
791 noexcept;
792#endif
793 template <class MS1,class M2> friend MS1 &_msmusetsup(MS1 &ms1,const M2 &m2)
794#if(CXSC_INDEX_CHECK)
795 ;
796#else
797 noexcept;
798#endif
799 //--- Interval -------- matrix-matrix --------------
800
801 template <class M1,class M2,class E> friend E _mmimult(const M1 &m1, const M2 &m2)
802#if(CXSC_INDEX_CHECK)
803 ;
804#else
805 noexcept;
806#endif
807
808 template <class M1,class M2,class S> friend M1 &_mmimultassign(M1 &m1,const M2 &m2)
809#if(CXSC_INDEX_CHECK)
810 ;
811#else
812 noexcept;
813#endif
814 template <class M,class MS,class E> friend E _mmsimult(const M &m1, const MS &ms)
815#if(CXSC_INDEX_CHECK)
816 ;
817#else
818 noexcept;
819#endif
820
821 template <class MS,class M,class E> friend E _msmimult(const MS &ms, const M &m2)
822#if(CXSC_INDEX_CHECK)
823 ;
824#else
825 noexcept;
826#endif
827
828 template <class M,class MS,class S> friend M &_mmsimultassign(M &m1,const MS &ms)
829#if(CXSC_INDEX_CHECK)
830 ;
831#else
832 noexcept;
833#endif
834 template <class MS1,class MS2,class E> friend E _msmsimult(const MS1 &ms1, const MS2 &ms2)
835#if(CXSC_INDEX_CHECK)
836 ;
837#else
838 noexcept;
839#endif
840
841 template <class M1,class M2> friend M1 &_mmconvassign(M1 &m1,const M2 &m2)
842#if(CXSC_INDEX_CHECK)
843 ;
844#else
845 noexcept;
846#endif
847 template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms)
848#if(CXSC_INDEX_CHECK)
849 ;
850#else
851 noexcept;
852#endif
853 template <class MS,class M> friend MS &_msmconvassign(MS &ms,const M &m1)
854#if(CXSC_INDEX_CHECK)
855 ;
856#else
857 noexcept;
858#endif
859 template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2)
860#if(CXSC_INDEX_CHECK)
861 ;
862#else
863 noexcept;
864#endif
865 template <class M1,class M2,class E> friend E _mmsect(const M1 &m1,const M2 &m2)
866#if(CXSC_INDEX_CHECK)
867 ;
868#else
869 noexcept;
870#endif
871 template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms)
872#if(CXSC_INDEX_CHECK)
873 ;
874#else
875 noexcept;
876#endif
877
878 template <class M1,class M2> friend M1 &_mmsectassign(M1 &m1,const M2 &m2)
879#if(CXSC_INDEX_CHECK)
880 ;
881#else
882 noexcept;
883#endif
884 template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms)
885#if(CXSC_INDEX_CHECK)
886 ;
887#else
888 noexcept;
889#endif
890 template <class MS,class M> friend MS &_msmsectassign(MS &ms,const M &m1)
891#if(CXSC_INDEX_CHECK)
892 ;
893#else
894 noexcept;
895#endif
896 template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2)
897#if(CXSC_INDEX_CHECK)
898 ;
899#else
900 noexcept;
901#endif
902 //--- Interval -------- matrix-vector --------------
903 template <class M,class V,class E> friend E _mvimult(const M &m,const V &v)
904#if(CXSC_INDEX_CHECK)
905 ;
906#else
907 noexcept;
908#endif
909 template <class MS,class V,class E> friend E _msvimult(const MS &ms,const V &v)
910#if(CXSC_INDEX_CHECK)
911 ;
912#else
913 noexcept;
914#endif
915 template <class V,class MS,class E> friend E _vmsimult(const V &v,const MS &ms)
916#if(CXSC_INDEX_CHECK)
917 ;
918#else
919 noexcept;
920#endif
921
922
923 template <class V,class M,class E> friend E _vmimult(const V &v,const M &m)
924#if(CXSC_INDEX_CHECK)
925 ;
926#else
927 noexcept;
928#endif
929 template <class V,class M,class S> friend V &_vmimultassign(V &v,const M &m)
930#if(CXSC_INDEX_CHECK)
931 ;
932#else
933 noexcept;
934#endif
935 template <class VS,class M,class S> friend VS &_vsmimultassign(VS &v,const M &m)
936#if(CXSC_INDEX_CHECK)
937 ;
938#else
939 noexcept;
940#endif
941
942
943 // complex
944
945 template <class M,class E> friend E _mre(const M &m) noexcept;
946 template <class M,class E> friend E _mim(const M &m) noexcept;
947 template <class M1,class M2> friend M1 &_mmsetre(M1 &m1,const M2 &m2)
948#if(CXSC_INDEX_CHECK)
949 ;
950#else
951 noexcept;
952#endif
953 template <class M1,class M2> friend M1 &_mmsetim(M1 &m1,const M2 &m2)
954#if(CXSC_INDEX_CHECK)
955 ;
956#else
957 noexcept;
958#endif
959 template <class MS,class E> friend E _msre(const MS &ms) noexcept;
960 template <class MS,class E> friend E _msim(const MS &ms) noexcept;
961 template <class MS1,class M2> friend MS1 &_msmsetre(MS1 &ms1,const M2 &m2)
962#if(CXSC_INDEX_CHECK)
963 ;
964#else
965 noexcept;
966#endif
967 template <class MS1,class M2> friend MS1 &_msmsetim(MS1 &ms1,const M2 &m2)
968#if(CXSC_INDEX_CHECK)
969 ;
970#else
971 noexcept;
972#endif
973 //--- complex -------- matrix-matrix --------------
974
975 template <class M1,class M2,class E> friend E _mmcmult(const M1 &m1, const M2 &m2)
976#if(CXSC_INDEX_CHECK)
977 ;
978#else
979 noexcept;
980#endif
981
982 template <class M1,class M2,class S> friend M1 &_mmcmultassign(M1 &m1,const M2 &m2)
983#if(CXSC_INDEX_CHECK)
984 ;
985#else
986 noexcept;
987#endif
988 template <class M,class MS,class E> friend E _mmscmult(const M &m1, const MS &ms)
989#if(CXSC_INDEX_CHECK)
990 ;
991#else
992 noexcept;
993#endif
994
995 template <class MS,class M,class E> friend E _msmcmult(const MS &ms, const M &m2)
996#if(CXSC_INDEX_CHECK)
997 ;
998#else
999 noexcept;
1000#endif
1001
1002 template <class M,class MS,class S> friend M &_mmscmultassign(M &m1,const MS &ms)
1003#if(CXSC_INDEX_CHECK)
1004 ;
1005#else
1006 noexcept;
1007#endif
1008 template <class MS1,class MS2,class E> friend E _msmscmult(const MS1 &ms1, const MS2 &ms2)
1009#if(CXSC_INDEX_CHECK)
1010 ;
1011#else
1012 noexcept;
1013#endif
1014
1015 //--- complex -------- matrix-vector --------------
1016 template <class M,class V,class E> friend E _mvcmult(const M &m,const V &v)
1017#if(CXSC_INDEX_CHECK)
1018 ;
1019#else
1020 noexcept;
1021#endif
1022 template <class MS,class V,class E> friend E _msvcmult(const MS &ms,const V &v)
1023#if(CXSC_INDEX_CHECK)
1024 ;
1025#else
1026 noexcept;
1027#endif
1028 template <class V,class MS,class E> friend E _vmscmult(const V &v,const MS &ms)
1029#if(CXSC_INDEX_CHECK)
1030 ;
1031#else
1032 noexcept;
1033#endif
1034
1035 template <class V,class M,class E> friend E _vmcmult(const V &v,const M &m)
1036#if(CXSC_INDEX_CHECK)
1037 ;
1038#else
1039 noexcept;
1040#endif
1041 template <class V,class M,class S> friend V &_vmcmultassign(V &v,const M &m)
1042#if(CXSC_INDEX_CHECK)
1043 ;
1044#else
1045 noexcept;
1046#endif
1047 template <class VS,class M,class S> friend VS &_vsmcmultassign(VS &v,const M &m)
1048#if(CXSC_INDEX_CHECK)
1049 ;
1050#else
1051 noexcept;
1052#endif
1053
1054
1055 // cinterval
1056
1058 friend INLINE rmatrix SupRe(const cimatrix &v) noexcept;
1060 friend INLINE rmatrix SupIm(const cimatrix &v) noexcept;
1062 friend INLINE rmatrix InfRe(const cimatrix &v) noexcept;
1064 friend INLINE rmatrix InfIm(const cimatrix &v) noexcept;
1066 friend INLINE rmatrix SupRe(const cimatrix_slice &v) noexcept;
1068 friend INLINE rmatrix SupIm(const cimatrix_slice &v) noexcept;
1070 friend INLINE rmatrix InfRe(const cimatrix_slice &v) noexcept;
1072 friend INLINE rmatrix InfIm(const cimatrix_slice &v) noexcept;
1073
1074 //--- cinterval -------- matrix-matrix --------------
1075
1076 template <class M1,class M2,class E> friend E _mmcimult(const M1 &m1, const M2 &m2)
1077#if(CXSC_INDEX_CHECK)
1078 ;
1079#else
1080 noexcept;
1081#endif
1082 template <class M1,class M2,class S> friend M1 &_mmcimultassign(M1 &m1,const M2 &m2)
1083#if(CXSC_INDEX_CHECK)
1084 ;
1085#else
1086 noexcept;
1087#endif
1088 template <class M,class MS,class E> friend E _mmscimult(const M &m1, const MS &ms)
1089#if(CXSC_INDEX_CHECK)
1090 ;
1091#else
1092 noexcept;
1093#endif
1094 template <class MS,class M,class E> friend E _msmcimult(const MS &ms, const M &m2)
1095#if(CXSC_INDEX_CHECK)
1096 ;
1097#else
1098 noexcept;
1099#endif
1100 template <class M,class MS,class S> friend M &_mmscimultassign(M &m1,const MS &ms)
1101#if(CXSC_INDEX_CHECK)
1102 ;
1103#else
1104 noexcept;
1105#endif
1106 template <class MS1,class MS2,class E> friend E _msmscimult(const MS1 &ms1, const MS2 &ms2)
1107#if(CXSC_INDEX_CHECK)
1108 ;
1109#else
1110 noexcept;
1111#endif
1112
1113 //--- cinterval -------- matrix-vector --------------
1114 template <class M,class V,class E> friend E _mvcimult(const M &m,const V &v)
1115#if(CXSC_INDEX_CHECK)
1116 ;
1117#else
1118 noexcept;
1119#endif
1120 template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v)
1121#if(CXSC_INDEX_CHECK)
1122 ;
1123#else
1124 noexcept;
1125#endif
1126 template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms)
1127#if(CXSC_INDEX_CHECK)
1128 ;
1129#else
1130 noexcept;
1131#endif
1132
1133 template <class V,class M,class E> friend E _vmcimult(const V &v,const M &m)
1134#if(CXSC_INDEX_CHECK)
1135 ;
1136#else
1137 noexcept;
1138#endif
1139 template <class V,class M,class S> friend V &_vmcimultassign(V &v,const M &m)
1140#if(CXSC_INDEX_CHECK)
1141 ;
1142#else
1143 noexcept;
1144#endif
1145 template <class VS,class M,class S> friend VS &_vsmcimultassign(VS &v,const M &m)
1146#if(CXSC_INDEX_CHECK)
1147 ;
1148#else
1149 noexcept;
1150#endif
1151
1152 //--- l_real -------- matrix-matrix --------------
1153
1154 template <class M1,class M2,class E> friend E _mmlmult(const M1 &m1, const M2 &m2)
1155#if(CXSC_INDEX_CHECK)
1156 ;
1157#else
1158 noexcept;
1159#endif
1160 template <class M1,class M2,class S> friend M1 &_mmlmultassign(M1 &m1,const M2 &m2)
1161#if(CXSC_INDEX_CHECK)
1162 ;
1163#else
1164 noexcept;
1165#endif
1166 template <class M,class MS,class E> friend E _mmslmult(const M &m1, const MS &ms)
1167#if(CXSC_INDEX_CHECK)
1168 ;
1169#else
1170 noexcept;
1171#endif
1172
1173 template <class MS,class M,class E> friend E _msmlmult(const MS &ms, const M &m2)
1174#if(CXSC_INDEX_CHECK)
1175 ;
1176#else
1177 noexcept;
1178#endif
1179
1180 template <class M,class MS,class S> friend M &_mmslmultassign(M &m1,const MS &ms)
1181#if(CXSC_INDEX_CHECK)
1182 ;
1183#else
1184 noexcept;
1185#endif
1186 template <class MS1,class MS2,class E> friend E _msmslmult(const MS1 &ms1, const MS2 &ms2)
1187#if(CXSC_INDEX_CHECK)
1188 ;
1189#else
1190 noexcept;
1191#endif
1192 //--- l_real -------- matrix-vector --------------
1193 template <class M,class V,class E> friend E _mvlmult(const M &m,const V &v)
1194#if(CXSC_INDEX_CHECK)
1195 ;
1196#else
1197 noexcept;
1198#endif
1199 template <class MS,class V,class E> friend E _msvlmult(const MS &ms,const V &v)
1200#if(CXSC_INDEX_CHECK)
1201 ;
1202#else
1203 noexcept;
1204#endif
1205 template <class V,class MS,class E> friend E _vmslmult(const V &v,const MS &ms)
1206#if(CXSC_INDEX_CHECK)
1207 ;
1208#else
1209 noexcept;
1210#endif
1211
1212 template <class V,class M,class E> friend E _vmlmult(const V &v,const M &m)
1213#if(CXSC_INDEX_CHECK)
1214 ;
1215#else
1216 noexcept;
1217#endif
1218 template <class V,class M,class S> friend V &_vmlmultassign(V &v,const M &m)
1219#if(CXSC_INDEX_CHECK)
1220 ;
1221#else
1222 noexcept;
1223#endif
1224
1225 //--- l_interval -------- matrix-matrix --------------
1226
1227 template <class M1,class M2,class E> friend E _mmlimult(const M1 &m1, const M2 &m2)
1228#if(CXSC_INDEX_CHECK)
1229 ;
1230#else
1231 noexcept;
1232#endif
1233
1234 template <class M1,class M2,class S> friend M1 &_mmlimultassign(M1 &m1,const M2 &m2)
1235#if(CXSC_INDEX_CHECK)
1236 ;
1237#else
1238 noexcept;
1239#endif
1240 template <class M,class MS,class E> friend E _mmslimult(const M &m1, const MS &ms)
1241#if(CXSC_INDEX_CHECK)
1242 ;
1243#else
1244 noexcept;
1245#endif
1246
1247 template <class MS,class M,class E> friend E _msmlimult(const MS &ms, const M &m2)
1248#if(CXSC_INDEX_CHECK)
1249 ;
1250#else
1251 noexcept;
1252#endif
1253
1254 template <class M,class MS,class S> friend M &_mmslimultassign(M &m1,const MS &ms)
1255#if(CXSC_INDEX_CHECK)
1256 ;
1257#else
1258 noexcept;
1259#endif
1260 template <class MS1,class MS2,class E> friend E _msmslimult(const MS1 &ms1, const MS2 &ms2)
1261#if(CXSC_INDEX_CHECK)
1262 ;
1263#else
1264 noexcept;
1265#endif
1266
1267
1268 //--- l_interval -------- matrix-vector --------------
1269 template <class M,class V,class E> friend E _mvlimult(const M &m,const V &v)
1270#if(CXSC_INDEX_CHECK)
1271 ;
1272#else
1273 noexcept;
1274#endif
1275 template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v)
1276#if(CXSC_INDEX_CHECK)
1277 ;
1278#else
1279 noexcept;
1280#endif
1281 template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms)
1282#if(CXSC_INDEX_CHECK)
1283 ;
1284#else
1285 noexcept;
1286#endif
1287
1288 template <class V,class M,class E> friend E _vmlimult(const V &v,const M &m)
1289#if(CXSC_INDEX_CHECK)
1290 ;
1291#else
1292 noexcept;
1293#endif
1294 template <class V,class M,class S> friend V &_vmlimultassign(V &v,const M &m)
1295#if(CXSC_INDEX_CHECK)
1296 ;
1297#else
1298 noexcept;
1299#endif
1300 template <class VS,class M,class S> friend VS &_vsmlimultassign(VS &v,const M &m)
1301#if(CXSC_INDEX_CHECK)
1302 ;
1303#else
1304 noexcept;
1305#endif
1306
1307#endif
1308
1309 //-------------------------- Konstruktoren ----------------------------
1310
1312 INLINE rmatrix(const rmatrix &rm) noexcept;
1314 INLINE rmatrix(const rmatrix_slice &rm) noexcept;
1316 INLINE rmatrix() noexcept;
1318 explicit INLINE rmatrix(const int &m, const int &n)
1319#if(CXSC_INDEX_CHECK)
1320;
1321#else
1322 noexcept;
1323#endif
1325 explicit INLINE rmatrix(const int &m1, const int &n1, const int &m2, const int &n2)
1326#if(CXSC_INDEX_CHECK)
1327;
1328#else
1329 noexcept;
1330#endif
1332 explicit INLINE rmatrix(const rvector &v) noexcept;
1334 explicit INLINE rmatrix(const rvector_slice &v) noexcept;
1336 explicit INLINE rmatrix(const real &r) noexcept;
1338 INLINE rmatrix(const srmatrix&);
1340 INLINE rmatrix(const srmatrix_slice&);
1342 INLINE rmatrix(const intmatrix&);
1343
1344
1346 INLINE rmatrix &operator =(const real &r) noexcept;
1348 INLINE rmatrix &operator =(const rmatrix &m) noexcept;
1350 INLINE rmatrix &operator =(const rmatrix_slice &ms) noexcept;
1352 INLINE rmatrix &operator =(const rvector &v) noexcept;
1354 INLINE rmatrix &operator =(const rvector_slice &v) noexcept;
1356 INLINE rmatrix &operator =(const srmatrix&);
1358 INLINE rmatrix &operator =(const srmatrix_slice&);
1359
1361 INLINE rmatrix &operator *=(const srmatrix &m);
1363 INLINE rmatrix &operator *=(const srmatrix_slice &m);
1365 INLINE rmatrix &operator +=(const srmatrix &m);
1367 INLINE rmatrix &operator +=(const srmatrix_slice &m);
1369 INLINE rmatrix &operator -=(const srmatrix &m);
1371 INLINE rmatrix &operator -=(const srmatrix_slice &m);
1372
1374 INLINE rmatrix operator()(const intvector& p, const intvector& q);
1376 INLINE rmatrix operator()(const intmatrix& P, const intmatrix& Q);
1378 INLINE rmatrix operator()(const intvector& p);
1380 INLINE rmatrix operator()(const intmatrix& P);
1381
1382
1383 //--------------------------- Destruktoren -----------------------------
1384
1385 INLINE ~rmatrix() noexcept { delete [] dat; }
1386
1387 //------------------------- Standardfunktionen -------------------------
1388
1389 friend INLINE real::real(const rmatrix &m)
1390#if(CXSC_INDEX_CHECK)
1391;
1392#else
1393 noexcept;
1394#endif
1395 friend INLINE rvector::rvector(const rmatrix &m)
1396#if(CXSC_INDEX_CHECK)
1397;
1398#else
1399 noexcept;
1400#endif
1402 INLINE rmatrix_subv operator [](const int &i) const
1403#if(CXSC_INDEX_CHECK)
1404;
1405#else
1406 noexcept;
1407#endif
1409 INLINE rmatrix_subv operator [](const cxscmatrix_column &i) const
1410#if(CXSC_INDEX_CHECK)
1411;
1412#else
1413 noexcept;
1414#endif
1416 INLINE rmatrix &operator ()() noexcept { return *this; }
1418 INLINE rmatrix_slice operator ()(const int &m, const int &n)
1419#if(CXSC_INDEX_CHECK)
1420;
1421#else
1422 noexcept;
1423#endif
1425 INLINE rmatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
1426#if(CXSC_INDEX_CHECK)
1427;
1428#else
1429 noexcept;
1430#endif
1431 INLINE operator void*() noexcept;
1432//#else
1433//#endif
1434};
1435
1437
1443{
1444 friend class rmatrix;
1445 friend class imatrix;
1446 friend class cmatrix;
1447 friend class cimatrix;
1448 friend class l_rmatrix;
1449 friend class l_imatrix;
1450 private:
1451 real *dat;
1452 int offset1,offset2,mxsize,mysize;
1453 int start1,end1,start2,end2,sxsize,sysize; // slice size
1454
1455 public:
1456//#if(CXSC_INDEX_CHECK)
1457#ifdef _CXSC_FRIEND_TPL
1458 //----------------- Templates ---------------------------------------
1459template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m)
1460#if(CXSC_INDEX_CHECK)
1461;
1462#else
1463 noexcept;
1464#endif
1465 template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m)
1466#if(CXSC_INDEX_CHECK)
1467 ;
1468#else
1469 noexcept;
1470#endif
1471 template <class MS1,class MS2> friend MS1 &_msmsassign(MS1 &ms1,const MS2 &ms)
1472#if(CXSC_INDEX_CHECK)
1473 ;
1474#else
1475 noexcept;
1476#endif
1477 template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) noexcept;
1478 template <class MS,class S> friend MS &_mssassign(MS &ms,const S &r) noexcept;
1479 template <class MS> friend int _mslb(const MS &ms, const int &i)
1480#if(CXSC_INDEX_CHECK)
1481;
1482#else
1483 noexcept;
1484#endif
1485 template <class MS> friend int _msub(const MS &ms, const int &i)
1486#if(CXSC_INDEX_CHECK)
1487;
1488#else
1489 noexcept;
1490#endif
1491 template <class MS,class E> friend E _msabs(const MS &ms) noexcept;
1492 //------------ matrix-matrix --------------------
1493 template <class MS,class E> friend E _msminus(const MS &ms) noexcept;
1494 template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms)
1495#if(CXSC_INDEX_CHECK)
1496 ;
1497#else
1498 noexcept;
1499#endif
1500 template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2)
1501#if(CXSC_INDEX_CHECK)
1502 ;
1503#else
1504 noexcept;
1505#endif
1506 template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms)
1507#if(CXSC_INDEX_CHECK)
1508 ;
1509#else
1510 noexcept;
1511#endif
1512 template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1)
1513#if(CXSC_INDEX_CHECK)
1514 ;
1515#else
1516 noexcept;
1517#endif
1518 template <class MS1,class MS2> friend MS1 &_msmsplusassign(MS1 &ms1,const MS2 &ms2)
1519#if(CXSC_INDEX_CHECK)
1520 ;
1521#else
1522 noexcept;
1523#endif
1524 template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms)
1525#if(CXSC_INDEX_CHECK)
1526 ;
1527#else
1528 noexcept;
1529#endif
1530 template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m)
1531#if(CXSC_INDEX_CHECK)
1532 ;
1533#else
1534 noexcept;
1535#endif
1536 template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2)
1537#if(CXSC_INDEX_CHECK)
1538 ;
1539#else
1540 noexcept;
1541#endif
1542 template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms)
1543#if(CXSC_INDEX_CHECK)
1544 ;
1545#else
1546 noexcept;
1547#endif
1548 template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1)
1549#if(CXSC_INDEX_CHECK)
1550 ;
1551#else
1552 noexcept;
1553#endif
1554 template <class MS1,class MS2> friend MS1 &_msmsminusassign(MS1 &ms1,const MS2 &ms2)
1555#if(CXSC_INDEX_CHECK)
1556 ;
1557#else
1558 noexcept;
1559#endif
1560 template <class M,class MS,class E> friend E _mmsmult(const M &m1, const MS &ms)
1561#if(CXSC_INDEX_CHECK)
1562 ;
1563#else
1564 noexcept;
1565#endif
1566 template <class MS,class M,class E> friend E _msmmult(const MS &ms, const M &m2)
1567#if(CXSC_INDEX_CHECK)
1568 ;
1569#else
1570 noexcept;
1571#endif
1572 template <class M,class MS,class S> friend M &_mmsmultassign(M &m1,const MS &ms)
1573#if(CXSC_INDEX_CHECK)
1574 ;
1575#else
1576 noexcept;
1577#endif
1578 template <class MS1,class MS2,class E> friend E _msmsmult(const MS1 &ms1, const MS2 &ms2)
1579#if(CXSC_INDEX_CHECK)
1580 ;
1581#else
1582 noexcept;
1583#endif
1584 template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms)
1585#if(CXSC_INDEX_CHECK)
1586 ;
1587#else
1588 noexcept;
1589#endif
1590 template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2)
1591#if(CXSC_INDEX_CHECK)
1592 ;
1593#else
1594 noexcept;
1595#endif
1596 //---------- matrix-vector ------------------------
1597 template <class MS,class V,class E> friend E _msvmult(const MS &ms,const V &v)
1598#if(CXSC_INDEX_CHECK)
1599 ;
1600#else
1601 noexcept;
1602#endif
1603 template <class V,class MS,class E> friend E _vmsmult(const V &v,const MS &ms)
1604#if(CXSC_INDEX_CHECK)
1605 ;
1606#else
1607 noexcept;
1608#endif
1609 template <class V,class MS,class S> friend V &_vmsmultassign(V &v,const MS &ms)
1610#if(CXSC_INDEX_CHECK)
1611 ;
1612#else
1613 noexcept;
1614#endif
1615 //--------- matrix-scalar -----------------
1616 template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) noexcept;
1617 template <class MS,class S> friend MS &_mssmultassign(MS &ms,const S &c) noexcept;
1618 template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) noexcept;
1619 template <class MS,class S> friend MS &_mssdivassign(MS &ms,const S &c) noexcept;
1620
1621 template <class MS> friend void *_msvoid(const MS &ms) noexcept;
1622 template <class MS> friend bool _msnot(const MS &ms) noexcept;
1623 template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) noexcept;
1624 template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) noexcept;
1625 template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) noexcept;
1626 template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) noexcept;
1627 template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) noexcept;
1628 template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) noexcept;
1629 template <class MS1,class MS2> friend bool _msmseq(const MS1 &ms1,const MS2 &ms2) noexcept;
1630 template <class MS1,class MS2> friend bool _msmsneq(const MS1 &ms1,const MS2 &ms2) noexcept;
1631 template <class MS1,class MS2> friend bool _msmsless(const MS1 &ms1,const MS2 &ms2) noexcept;
1632 template <class MS1,class MS2> friend bool _msmsleq(const MS1 &ms1,const MS2 &ms2) noexcept;
1633 template <class MS> friend std::ostream &_msout(std::ostream &s,const MS &r) noexcept;
1634 template <class MS> friend std::istream &_msin(std::istream &s,MS &r) noexcept;
1635
1636 // Interval
1637 template <class M1,class MS2> friend M1 &_mmssetinf(M1 &m1,const MS2 &ms2)
1638#if(CXSC_INDEX_CHECK)
1639 ;
1640#else
1641 noexcept;
1642#endif
1643 template <class M1,class MS2> friend M1 &_mmssetsup(M1 &m1,const MS2 &ms2)
1644#if(CXSC_INDEX_CHECK)
1645 ;
1646#else
1647 noexcept;
1648#endif
1649 template <class M1,class MS2> friend M1 &_mmsusetinf(M1 &m1,const MS2 &ms2)
1650#if(CXSC_INDEX_CHECK)
1651 ;
1652#else
1653 noexcept;
1654#endif
1655 template <class M1,class MS2> friend M1 &_mmsusetsup(M1 &m1,const MS2 &ms2)
1656#if(CXSC_INDEX_CHECK)
1657 ;
1658#else
1659 noexcept;
1660#endif
1661 template <class MS1,class MS2> friend MS1 &_msmssetinf(MS1 &ms1,const MS2 &ms2)
1662#if(CXSC_INDEX_CHECK)
1663 ;
1664#else
1665 noexcept;
1666#endif
1667 template <class MS1,class MS2> friend MS1 &_msmssetsup(MS1 &ms1,const MS2 &ms2)
1668#if(CXSC_INDEX_CHECK)
1669 ;
1670#else
1671 noexcept;
1672#endif
1673 template <class MS1,class MS2> friend MS1 &_msmsusetinf(MS1 &ms1,const MS2 &ms2)
1674#if(CXSC_INDEX_CHECK)
1675 ;
1676#else
1677 noexcept;
1678#endif
1679 template <class MS1,class MS2> friend MS1 &_msmsusetsup(MS1 &ms1,const MS2 &ms2)
1680#if(CXSC_INDEX_CHECK)
1681 ;
1682#else
1683 noexcept;
1684#endif
1685 //--- Interval ---------- matrix-vector -----------
1686 template <class MS,class V,class E> friend E _msvimult(const MS &ms,const V &v)
1687#if(CXSC_INDEX_CHECK)
1688 ;
1689#else
1690 noexcept;
1691#endif
1692 template <class V,class MS,class E> friend E _vmsimult(const V &v,const MS &ms)
1693#if(CXSC_INDEX_CHECK)
1694 ;
1695#else
1696 noexcept;
1697#endif
1698 template <class V,class MS,class S> friend V &_vmsimultassign(V &v,const MS &ms)
1699#if(CXSC_INDEX_CHECK)
1700 ;
1701#else
1702 noexcept;
1703#endif
1704 //--- Interval ---------- matrix-matrix ----------
1705
1706
1707 template <class M,class MS,class E> friend E _mmsimult(const M &m1, const MS &ms)
1708#if(CXSC_INDEX_CHECK)
1709 ;
1710#else
1711 noexcept;
1712#endif
1713 template <class MS,class M,class E> friend E _msmimult(const MS &ms, const M &m2)
1714#if(CXSC_INDEX_CHECK)
1715 ;
1716#else
1717 noexcept;
1718#endif
1719
1720 template <class M,class MS,class S> friend M &_mmsimultassign(M &m1,const MS &ms)
1721#if(CXSC_INDEX_CHECK)
1722 ;
1723#else
1724 noexcept;
1725#endif
1726
1727 template <class MS1,class MS2,class E> friend E _msmsimult(const MS1 &ms1, const MS2 &ms2)
1728#if(CXSC_INDEX_CHECK)
1729 ;
1730#else
1731 noexcept;
1732#endif
1733
1734 template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms)
1735#if(CXSC_INDEX_CHECK)
1736 ;
1737#else
1738 noexcept;
1739#endif
1740 template <class MS1,class MS2> friend MS1 &_msmsconvassign(MS1 &ms1,const MS2 &ms2)
1741#if(CXSC_INDEX_CHECK)
1742 ;
1743#else
1744 noexcept;
1745#endif
1746 template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms)
1747#if(CXSC_INDEX_CHECK)
1748 ;
1749#else
1750 noexcept;
1751#endif
1752 template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms)
1753#if(CXSC_INDEX_CHECK)
1754 ;
1755#else
1756 noexcept;
1757#endif
1758 template <class MS1,class MS2> friend MS1 &_msmssectassign(MS1 &ms1,const MS2 &ms2)
1759#if(CXSC_INDEX_CHECK)
1760 ;
1761#else
1762 noexcept;
1763#endif
1764 template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2)
1765#if(CXSC_INDEX_CHECK)
1766 ;
1767#else
1768 noexcept;
1769#endif
1770
1771 // complex
1772
1773 template <class MS1,class MS2> friend MS1 &_msmssetre(MS1 &ms1,const MS2 &ms2)
1774#if(CXSC_INDEX_CHECK)
1775 ;
1776#else
1777 noexcept;
1778#endif
1779 template <class MS1,class MS2> friend MS1 &_msmssetim(MS1 &ms1,const MS2 &ms2)
1780#if(CXSC_INDEX_CHECK)
1781 ;
1782#else
1783 noexcept;
1784#endif
1785 template <class M1,class MS2> friend M1 &_mmssetre(M1 &m1,const MS2 &ms2)
1786#if(CXSC_INDEX_CHECK)
1787 ;
1788#else
1789 noexcept;
1790#endif
1791 template <class M1,class MS2> friend M1 &_mmssetim(M1 &m1,const MS2 &ms2)
1792#if(CXSC_INDEX_CHECK)
1793 ;
1794#else
1795 noexcept;
1796#endif
1797 //--- complex ---------- matrix-vector -----------
1798 template <class MS,class V,class E> friend E _msvcmult(const MS &ms,const V &v)
1799#if(CXSC_INDEX_CHECK)
1800 ;
1801#else
1802 noexcept;
1803#endif
1804 template <class V,class MS,class E> friend E _vmscmult(const V &v,const MS &ms)
1805#if(CXSC_INDEX_CHECK)
1806 ;
1807#else
1808 noexcept;
1809#endif
1810 template <class V,class MS,class S> friend V &_vmscmultassign(V &v,const MS &ms)
1811#if(CXSC_INDEX_CHECK)
1812 ;
1813#else
1814 noexcept;
1815#endif
1816 //--- complex ---------- matrix-matrix ----------
1817
1818
1819 template <class M,class MS,class E> friend E _mmscmult(const M &m1, const MS &ms)
1820#if(CXSC_INDEX_CHECK)
1821 ;
1822#else
1823 noexcept;
1824#endif
1825 template <class MS,class M,class E> friend E _msmcmult(const MS &ms, const M &m2)
1826#if(CXSC_INDEX_CHECK)
1827 ;
1828#else
1829 noexcept;
1830#endif
1831
1832 template <class M,class MS,class S> friend M &_mmscmultassign(M &m1,const MS &ms)
1833#if(CXSC_INDEX_CHECK)
1834 ;
1835#else
1836 noexcept;
1837#endif
1838 template <class MS1,class MS2,class E> friend E _msmscmult(const MS1 &ms1, const MS2 &ms2)
1839#if(CXSC_INDEX_CHECK)
1840 ;
1841#else
1842 noexcept;
1843#endif
1844
1845 // cinterval -- matrix-vector
1846 template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v)
1847#if(CXSC_INDEX_CHECK)
1848 ;
1849#else
1850 noexcept;
1851#endif
1852 template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms)
1853#if(CXSC_INDEX_CHECK)
1854 ;
1855#else
1856 noexcept;
1857#endif
1858 template <class V,class MS,class S> friend V &_vmscimultassign(V &v,const MS &ms)
1859#if(CXSC_INDEX_CHECK)
1860 ;
1861#else
1862 noexcept;
1863#endif
1864
1865 /* friend TINLINE civector _msvscimult<rmatrix_slice,civector_slice,civector>(const rmatrix_slice &ms,const civector_slice &v)
1866#if(CXSC_INDEX_CHECK)
1867;
1868#else
1869 noexcept;
1870 #endif */
1871 /* friend TINLINE civector _vsmscimult<civector_slice,rmatrix_slice,civector>(const civector_slice &v,const rmatrix_slice &ms)
1872#if(CXSC_INDEX_CHECK)
1873;
1874#else
1875 noexcept;
1876 #endif */
1877 /* friend TINLINE civector &_vsmscimultassign<civector_slice,rmatrix_slice,interval>(civector_slice &v,const rmatrix_slice &ms)
1878#if(CXSC_INDEX_CHECK)
1879;
1880#else
1881 noexcept;
1882#endif */
1883 // cinterval -- matrix-matrix
1884
1885 template <class M,class MS,class E> friend E _mmscimult(const M &m1, const MS &ms)
1886#if(CXSC_INDEX_CHECK)
1887 ;
1888#else
1889 noexcept;
1890#endif
1891 template <class MS,class M,class E> friend E _msmcimult(const MS &ms, const M &m2)
1892#if(CXSC_INDEX_CHECK)
1893 ;
1894#else
1895 noexcept;
1896#endif
1897 template <class M,class MS,class S> friend M &_mmscimultassign(M &m1,const MS &ms)
1898#if(CXSC_INDEX_CHECK)
1899 ;
1900#else
1901 noexcept;
1902#endif
1903
1904 template <class MS1,class MS2,class E> friend E _msmscimult(const MS1 &ms1, const MS2 &ms2)
1905#if(CXSC_INDEX_CHECK)
1906 ;
1907#else
1908 noexcept;
1909#endif
1910
1911 //--- l_real ---------- matrix-vector -----------
1912 template <class MS,class V,class E> friend E _msvlmult(const MS &ms,const V &v)
1913#if(CXSC_INDEX_CHECK)
1914 ;
1915#else
1916 noexcept;
1917#endif
1918 template <class V,class MS,class E> friend E _vmslmult(const V &v,const MS &ms)
1919#if(CXSC_INDEX_CHECK)
1920 ;
1921#else
1922 noexcept;
1923#endif
1924 template <class V,class MS,class S> friend V &_vmslmultassign(V &v,const MS &ms)
1925#if(CXSC_INDEX_CHECK)
1926 ;
1927#else
1928 noexcept;
1929#endif
1930 //--- l_real ---------- matrix-matrix ----------
1931
1932 template <class M,class MS,class E> friend E _mmslmult(const M &m1, const MS &ms)
1933#if(CXSC_INDEX_CHECK)
1934 ;
1935#else
1936 noexcept;
1937#endif
1938 template <class MS,class M,class E> friend E _msmlmult(const MS &ms, const M &m2)
1939#if(CXSC_INDEX_CHECK)
1940 ;
1941#else
1942 noexcept;
1943#endif
1944
1945 template <class M,class MS,class S> friend M &_mmslmultassign(M &m1,const MS &ms)
1946#if(CXSC_INDEX_CHECK)
1947 ;
1948#else
1949 noexcept;
1950#endif
1951 template <class MS1,class MS2,class E> friend E _msmslmult(const MS1 &ms1, const MS2 &ms2)
1952#if(CXSC_INDEX_CHECK)
1953 ;
1954#else
1955 noexcept;
1956#endif
1957
1958 // l_interval -- matrix-vector
1959 template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v)
1960#if(CXSC_INDEX_CHECK)
1961 ;
1962#else
1963 noexcept;
1964#endif
1965 template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms)
1966#if(CXSC_INDEX_CHECK)
1967 ;
1968#else
1969 noexcept;
1970#endif
1971 template <class V,class MS,class S> friend V &_vmslimultassign(V &v,const MS &ms)
1972#if(CXSC_INDEX_CHECK)
1973 ;
1974#else
1975 noexcept;
1976#endif
1977
1978 /* friend TINLINE l_ivector _msvslimult<rmatrix_slice,l_ivector_slice,l_ivector>(const rmatrix_slice &ms,const l_ivector_slice &v)
1979#if(CXSC_INDEX_CHECK)
1980;
1981#else
1982 noexcept;
1983 #endif */
1984 /* friend TINLINE l_ivector _vsmslimult<l_ivector_slice,rmatrix_slice,l_ivector>(const l_ivector_slice &v,const rmatrix_slice &ms)
1985#if(CXSC_INDEX_CHECK)
1986;
1987#else
1988 noexcept;
1989 #endif */
1990 /* friend TINLINE l_ivector &_vsmslimultassign<l_ivector_slice,rmatrix_slice,interval>(l_ivector_slice &v,const rmatrix_slice &ms)
1991#if(CXSC_INDEX_CHECK)
1992;
1993#else
1994 noexcept;
1995 #endif */
1996 // l_interval -- matrix-matrix
1997
1998 template <class M,class MS,class E> friend E _mmslimult(const M &m1, const MS &ms)
1999#if(CXSC_INDEX_CHECK)
2000 ;
2001#else
2002 noexcept;
2003#endif
2004 template <class MS,class M,class E> friend E _msmlimult(const MS &ms, const M &m2)
2005#if(CXSC_INDEX_CHECK)
2006 ;
2007#else
2008 noexcept;
2009#endif
2010
2011 template <class M,class MS,class S> friend M &_mmslimultassign(M &m1,const MS &ms)
2012#if(CXSC_INDEX_CHECK)
2013 ;
2014#else
2015 noexcept;
2016#endif
2017
2018 template <class MS1,class MS2,class E> friend E _msmslimult(const MS1 &ms1, const MS2 &ms2)
2019#if(CXSC_INDEX_CHECK)
2020 ;
2021#else
2022 noexcept;
2023#endif
2024
2025
2026#endif
2027
2028
2029 //--------------- Konstruktoren ----------------------------------------
2030
2032 explicit INLINE rmatrix_slice(rmatrix &a,const int &l1,const int &u1,const int &l2, const int &u2) noexcept:dat(a.dat),offset1(l1-a.lb1),offset2(l2-a.lb2),mxsize(a.xsize),mysize(a.ysize),start1(l1),end1(u1),start2(l2),end2(u2),sxsize(u2-l2+1),sysize(u1-l1+1) { }
2034 explicit INLINE rmatrix_slice(rmatrix_slice &a,const int &l1,const int &u1,const int &l2, const int &u2) noexcept:dat(a.dat),offset1(a.offset1+l1-a.start1),offset2(a.offset2+l2-a.start2),mxsize(a.mxsize),mysize(a.mysize),start1(l1),end1(u1),start2(l2),end2(u2),sxsize(u2-l2+1),sysize(u1-l1+1) { }
2035 public:
2037 INLINE rmatrix_slice(const rmatrix_slice &ms) noexcept:dat(ms.dat),offset1(ms.offset1),offset2(ms.offset2),mxsize(ms.mxsize),mysize(ms.mysize),start1(ms.start1),end1(ms.end1),start2(ms.start2),end2(ms.end2),sxsize(ms.sxsize),sysize(ms.sysize) { }
2038 public:
2039
2040 //---------------- Standardfunktionen -----------------------------------
2041
2042 friend rvector::rvector(const rmatrix_slice &sl)
2043#if(CXSC_INDEX_CHECK)
2044;
2045#else
2046 noexcept;
2047#endif
2048 friend INLINE rmatrix::rmatrix(const rmatrix_slice &) noexcept;
2050 INLINE rmatrix_slice &operator =(const srmatrix &m);
2053
2055 INLINE rmatrix_slice &operator =(const rmatrix &m)
2056#if(CXSC_INDEX_CHECK)
2057;
2058#else
2059 noexcept;
2060#endif
2062 INLINE rmatrix_slice &operator =(const rmatrix_slice &ms)
2063#if(CXSC_INDEX_CHECK)
2064;
2065#else
2066 noexcept;
2067#endif
2069 INLINE rmatrix_slice &operator =(const real &r) noexcept;
2071 INLINE rmatrix_slice &operator =(const rvector &v)
2072#if(CXSC_INDEX_CHECK)
2073;
2074#else
2075 noexcept;
2076#endif
2078 INLINE rmatrix_slice &operator =(const rvector_slice &v)
2079#if(CXSC_INDEX_CHECK)
2080;
2081#else
2082 noexcept;
2083#endif
2085 INLINE rmatrix_slice &operator =(const rmatrix_subv &v)
2086#if(CXSC_INDEX_CHECK)
2087;
2088#else
2089 noexcept;
2090#endif
2092 INLINE rmatrix_subv operator [](const int &i) const
2093#if(CXSC_INDEX_CHECK)
2094;
2095#else
2096 noexcept;
2097#endif
2099 INLINE rmatrix_subv operator [](const cxscmatrix_column &i) const
2100#if(CXSC_INDEX_CHECK)
2101;
2102#else
2103 noexcept;
2104#endif
2106 INLINE rmatrix_slice &operator ()() noexcept { return *this; }
2108 INLINE rmatrix_slice operator ()(const int &m, const int &n)
2109#if(CXSC_INDEX_CHECK)
2110;
2111#else
2112 noexcept;
2113#endif
2115 INLINE rmatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
2116#if(CXSC_INDEX_CHECK)
2117;
2118#else
2119 noexcept;
2120#endif
2121
2123 INLINE rmatrix_slice &operator *=(const srmatrix &m);
2125 INLINE rmatrix_slice &operator *=(const srmatrix_slice &m);
2126
2128 INLINE rmatrix_slice &operator *=(const rmatrix &m)
2129#if(CXSC_INDEX_CHECK)
2130;
2131#else
2132 noexcept;
2133#endif
2135 INLINE rmatrix_slice &operator *=(const rmatrix_slice &ms2)
2136#if(CXSC_INDEX_CHECK)
2137;
2138#else
2139 noexcept;
2140#endif
2141
2143 INLINE rmatrix_slice &operator +=(const srmatrix &m);
2145 INLINE rmatrix_slice &operator +=(const srmatrix_slice &m);
2146
2148 INLINE rmatrix_slice &operator +=(const rmatrix &m1)
2149#if(CXSC_INDEX_CHECK)
2150;
2151#else
2152 noexcept;
2153#endif
2155 INLINE rmatrix_slice &operator +=(const rmatrix_slice &ms2)
2156#if(CXSC_INDEX_CHECK)
2157;
2158#else
2159 noexcept;
2160#endif
2161
2163 INLINE rmatrix_slice &operator -=(const srmatrix &m);
2165 INLINE rmatrix_slice &operator -=(const srmatrix_slice &m);
2166
2168 INLINE rmatrix_slice &operator -=(const rmatrix &m1)
2169#if(CXSC_INDEX_CHECK)
2170;
2171#else
2172 noexcept;
2173#endif
2175 INLINE rmatrix_slice &operator -=(const rmatrix_slice &ms2)
2176#if(CXSC_INDEX_CHECK)
2177;
2178#else
2179 noexcept;
2180#endif
2182 INLINE rmatrix_slice &operator *=(const real &c) noexcept;
2184 INLINE rmatrix_slice &operator /=(const real &c) noexcept;
2185 INLINE operator void*() noexcept;
2186//#else
2187//#endif
2188};
2189
2190//================================================================
2191//====================== Subvector Functions =====================
2192
2193//=======================Vector / Scalar =========================
2194
2196 INLINE rvector operator /(const rmatrix_subv &rv, const real &s) noexcept;
2198 INLINE rvector operator *(const rmatrix_subv &rv, const real &s) noexcept;
2200 INLINE rvector operator *(const real &s, const rmatrix_subv &rv) noexcept;
2202 INLINE rvector abs(const rmatrix_subv &mv) noexcept;
2203
2204//======================== Vector / Vector ========================
2205
2207 void accumulate(dotprecision &dp, const rmatrix_subv & rv1, const rmatrix_subv &rv2)
2208#if(CXSC_INDEX_CHECK)
2209;
2210#else
2211 noexcept;
2212#endif
2213
2215 void accumulate_approx(dotprecision &dp, const rmatrix_subv & rv1, const rmatrix_subv &rv2);
2216
2218 void accumulate(dotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2)
2219#if(CXSC_INDEX_CHECK)
2220;
2221#else
2222 noexcept;
2223#endif
2224
2226 void accumulate_approx(dotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2);
2227
2229 void accumulate(dotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2)
2230#if(CXSC_INDEX_CHECK)
2231;
2232#else
2233 noexcept;
2234#endif
2235
2237 void accumulate_approx(dotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2);
2238
2240 void accumulate(cdotprecision &dp, const rmatrix_subv & rv1, const rmatrix_subv &rv2)
2241#if(CXSC_INDEX_CHECK)
2242;
2243#else
2244 noexcept;
2245#endif
2246
2248 void accumulate_approx(cdotprecision &dp, const rmatrix_subv & rv1, const rmatrix_subv &rv2);
2249
2251 void accumulate(cdotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2)
2252#if(CXSC_INDEX_CHECK)
2253;
2254#else
2255 noexcept;
2256#endif
2257
2259 void accumulate_approx(cdotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2);
2260
2262 void accumulate(cdotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2)
2263#if(CXSC_INDEX_CHECK)
2264;
2265#else
2266 noexcept;
2267#endif
2268
2270 void accumulate_approx(cdotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2);
2271
2273 void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const rmatrix_subv &rv2)
2274#if(CXSC_INDEX_CHECK)
2275;
2276#else
2277 noexcept;
2278#endif
2280 void accumulate(idotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2)
2281#if(CXSC_INDEX_CHECK)
2282;
2283#else
2284 noexcept;
2285#endif
2287 void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2)
2288#if(CXSC_INDEX_CHECK)
2289;
2290#else
2291 noexcept;
2292#endif
2294 void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const rmatrix_subv &rv2)
2295#if(CXSC_INDEX_CHECK)
2296;
2297#else
2298 noexcept;
2299#endif
2301 void accumulate(cidotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2)
2302#if(CXSC_INDEX_CHECK)
2303;
2304#else
2305 noexcept;
2306#endif
2308 void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2)
2309#if(CXSC_INDEX_CHECK)
2310;
2311#else
2312 noexcept;
2313#endif
2315 void accumulate(dotprecision &dp,const rvector_slice &sl,const rmatrix_subv &sv)
2316#if(CXSC_INDEX_CHECK)
2317;
2318#else
2319 noexcept;
2320#endif
2321
2323 void accumulate_approx(dotprecision &dp,const rvector_slice &sl,const rmatrix_subv &sv);
2324
2325
2327 void accumulate(cdotprecision &dp, const rvector_slice & sl1, const rmatrix_subv &rv2)
2328#if(CXSC_INDEX_CHECK)
2329;
2330#else
2331 noexcept;
2332#endif
2333
2335 void accumulate_approx(cdotprecision &dp, const rvector_slice & sl1, const rmatrix_subv &rv2);
2336
2338 void accumulate(idotprecision &dp, const rvector_slice & sl1, const rmatrix_subv &rv2)
2339#if(CXSC_INDEX_CHECK)
2340;
2341#else
2342 noexcept;
2343#endif
2344
2346 void accumulate(cidotprecision &dp, const rvector_slice & sl1, const rmatrix_subv &rv2)
2347#if(CXSC_INDEX_CHECK)
2348;
2349#else
2350 noexcept;
2351#endif
2352
2354 void accumulate(dotprecision &dp,const rmatrix_subv &mv,const rvector_slice &vs)
2355#if(CXSC_INDEX_CHECK)
2356;
2357#else
2358 noexcept;
2359#endif
2360
2362 void accumulate_approx(dotprecision &dp,const rmatrix_subv &mv,const rvector_slice &vs);
2363
2364
2366 void accumulate(cdotprecision &dp, const rmatrix_subv & rv1, const rvector_slice &sl2)
2367#if(CXSC_INDEX_CHECK)
2368;
2369#else
2370 noexcept;
2371#endif
2372
2374 void accumulate_approx(cdotprecision &dp, const rmatrix_subv & rv1, const rvector_slice &sl2);
2375
2377 void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const rvector_slice &sl2)
2378#if(CXSC_INDEX_CHECK)
2379;
2380#else
2381 noexcept;
2382#endif
2383
2385 void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const rvector_slice &sl2)
2386#if(CXSC_INDEX_CHECK)
2387;
2388#else
2389 noexcept;
2390#endif
2391
2393 INLINE real operator *(const rmatrix_subv & rv1, const rmatrix_subv &rv2)
2394#if(CXSC_INDEX_CHECK)
2395;
2396#else
2397 noexcept;
2398#endif
2400 INLINE real operator *(const rvector & rv1, const rmatrix_subv &rv2)
2401#if(CXSC_INDEX_CHECK)
2402;
2403#else
2404 noexcept;
2405#endif
2407 INLINE real operator *(const rmatrix_subv &rv1,const rvector &rv2)
2408#if(CXSC_INDEX_CHECK)
2409;
2410#else
2411 noexcept;
2412#endif
2414 INLINE real operator *(const rvector_slice &sl,const rmatrix_subv &sv)
2415#if(CXSC_INDEX_CHECK)
2416;
2417#else
2418 noexcept;
2419#endif
2421 INLINE real operator *(const rmatrix_subv &mv,const rvector_slice &vs)
2422#if(CXSC_INDEX_CHECK)
2423;
2424#else
2425 noexcept;
2426#endif
2427
2429 INLINE rvector operator +(const rmatrix_subv & rv1, const rmatrix_subv &rv2)
2430#if(CXSC_INDEX_CHECK)
2431;
2432#else
2433 noexcept;
2434#endif
2436 INLINE rvector operator +(const rmatrix_subv &rv1,const rvector &rv2)
2437#if(CXSC_INDEX_CHECK)
2438;
2439#else
2440 noexcept;
2441#endif
2443 INLINE rvector operator +(const rvector & rv1, const rmatrix_subv &rv2)
2444#if(CXSC_INDEX_CHECK)
2445;
2446#else
2447 noexcept;
2448#endif
2450 INLINE rvector operator +(const rvector_slice &sl,const rmatrix_subv &mv)
2451#if(CXSC_INDEX_CHECK)
2452;
2453#else
2454 noexcept;
2455#endif
2457 INLINE rvector operator +(const rmatrix_subv &mv,const rvector_slice &sl)
2458#if(CXSC_INDEX_CHECK)
2459;
2460#else
2461 noexcept;
2462#endif
2463
2465 INLINE rvector operator -(const rmatrix_subv & rv1, const rmatrix_subv &rv2)
2466#if(CXSC_INDEX_CHECK)
2467;
2468#else
2469 noexcept;
2470#endif
2472 INLINE rvector operator -(const rvector & rv1, const rmatrix_subv &rv2)
2473#if(CXSC_INDEX_CHECK)
2474;
2475#else
2476 noexcept;
2477#endif
2479 INLINE rvector operator -(const rmatrix_subv &rv1,const rvector &rv2)
2480#if(CXSC_INDEX_CHECK)
2481;
2482#else
2483 noexcept;
2484#endif
2486 INLINE rvector operator -(const rvector_slice &sl,const rmatrix_subv &mv)
2487#if(CXSC_INDEX_CHECK)
2488;
2489#else
2490 noexcept;
2491#endif
2493 INLINE rvector operator -(const rmatrix_subv &mv,const rvector_slice &sl)
2494#if(CXSC_INDEX_CHECK)
2495;
2496#else
2497 noexcept;
2498#endif
2499
2500//====================================================================
2501//===================== Matrix Functions =============================
2502
2504 INLINE rmatrix _rmatrix(const rmatrix &rm) noexcept;
2506 INLINE rmatrix _rmatrix(const rvector &v) noexcept;
2508 INLINE rmatrix _rmatrix(const rvector_slice &v) noexcept;
2510 INLINE rmatrix _rmatrix(const real &r) noexcept;
2511
2513 INLINE int Lb(const rmatrix &rm, const int &i)
2514#if(CXSC_INDEX_CHECK)
2515;
2516#else
2517 noexcept;
2518#endif
2520 INLINE int Ub(const rmatrix &rm, const int &i)
2521#if(CXSC_INDEX_CHECK)
2522;
2523#else
2524 noexcept;
2525#endif
2527 INLINE int Lb(const rmatrix_slice &rm, const int &i)
2528#if(CXSC_INDEX_CHECK)
2529;
2530#else
2531 noexcept;
2532#endif
2534 INLINE int Ub(const rmatrix_slice &rm, const int &i)
2535#if(CXSC_INDEX_CHECK)
2536;
2537#else
2538 noexcept;
2539#endif
2541 INLINE rmatrix &SetLb(rmatrix &m, const int &i,const int &j)
2542#if(CXSC_INDEX_CHECK)
2543;
2544#else
2545 noexcept;
2546#endif
2548 INLINE rmatrix &SetUb(rmatrix &m, const int &i,const int &j)
2549#if(CXSC_INDEX_CHECK)
2550;
2551#else
2552 noexcept;
2553#endif
2555 INLINE void Resize(rmatrix &A) noexcept;
2557 INLINE void Resize(rmatrix &A,const int &m, const int &n)
2558#if(CXSC_INDEX_CHECK)
2559;
2560#else
2561 noexcept;
2562#endif
2564 INLINE void Resize(rmatrix &A,const int &m1, const int &m2,const int &n1,const int &n2)
2565#if(CXSC_INDEX_CHECK)
2566;
2567#else
2568 noexcept;
2569#endif
2570
2572 INLINE rmatrix abs(const rmatrix &m) noexcept;
2574 INLINE rmatrix abs(const rmatrix_slice &ms) noexcept;
2576 INLINE rmatrix CompMat(const rmatrix &m) noexcept;
2577
2578//===================== Matrix / Scalar ===============================
2579
2581 INLINE rmatrix operator *(const real &c, const rmatrix &m) noexcept;
2583 INLINE rmatrix operator *(const real &c, const rmatrix_slice &ms) noexcept;
2585 INLINE rmatrix operator *(const rmatrix &m,const real &c) noexcept;
2587 INLINE rmatrix operator *(const rmatrix_slice &ms,const real &c) noexcept;
2589 INLINE rmatrix &operator *=(rmatrix &m,const real &c) noexcept;
2591 INLINE rmatrix operator /(const rmatrix &m,const real &c) noexcept;
2593 INLINE rmatrix operator /(const rmatrix_slice &ms, const real &c) noexcept;
2595 INLINE rmatrix &operator /=(rmatrix &m,const real &c) noexcept;
2596
2597//============================ Matrix / Vector ===================================
2598
2599//--------------------------- rvector ---------------------------
2600
2602 INLINE rvector operator *(const rmatrix &m,const rvector &v)
2603#if(CXSC_INDEX_CHECK)
2604;
2605#else
2606 noexcept;
2607#endif
2609 INLINE rvector operator *(const rmatrix_slice &ms,const rvector &v)
2610#if(CXSC_INDEX_CHECK)
2611;
2612#else
2613 noexcept;
2614#endif
2616 INLINE rvector operator *(const rvector &v,const rmatrix &m)
2617#if(CXSC_INDEX_CHECK)
2618;
2619#else
2620 noexcept;
2621#endif
2623 INLINE rvector operator *(const rvector &v,const rmatrix_slice &ms)
2624#if(CXSC_INDEX_CHECK)
2625;
2626#else
2627 noexcept;
2628#endif
2630 INLINE rvector &operator *=(rvector &v,const rmatrix &m)
2631#if(CXSC_INDEX_CHECK)
2632;
2633#else
2634 noexcept;
2635#endif
2637 INLINE rvector &operator *=(rvector &v,const rmatrix_slice &ms)
2638#if(CXSC_INDEX_CHECK)
2639;
2640#else
2641 noexcept;
2642#endif
2643
2644 // Test
2646 INLINE rvector operator *(const rvector_slice &v,const rmatrix &m)
2647#if(CXSC_INDEX_CHECK)
2648;
2649#else
2650 noexcept;
2651#endif
2652
2653
2654
2655//================ Matrix / Matrix ============================
2656
2658 INLINE const rmatrix &operator +(const rmatrix &m1) noexcept;
2660 INLINE rmatrix operator +(const rmatrix_slice &ms) noexcept;
2662 INLINE rmatrix operator +(const rmatrix &m1,const rmatrix &m2)
2663#if(CXSC_INDEX_CHECK)
2664;
2665#else
2666 noexcept;
2667#endif
2669 INLINE rmatrix operator +(const rmatrix &m,const rmatrix_slice &ms)
2670#if(CXSC_INDEX_CHECK)
2671;
2672#else
2673 noexcept;
2674#endif
2676 INLINE rmatrix operator +(const rmatrix_slice &ms,const rmatrix &m)
2677#if(CXSC_INDEX_CHECK)
2678;
2679#else
2680 noexcept;
2681#endif
2683 INLINE rmatrix operator +(const rmatrix_slice &m1,const rmatrix_slice &m2)
2684#if(CXSC_INDEX_CHECK)
2685;
2686#else
2687 noexcept;
2688#endif
2690 INLINE rmatrix &operator +=(rmatrix &m1,const rmatrix &m2)
2691#if(CXSC_INDEX_CHECK)
2692;
2693#else
2694 noexcept;
2695#endif
2697 INLINE rmatrix &operator +=(rmatrix &m1,const rmatrix_slice &ms)
2698#if(CXSC_INDEX_CHECK)
2699;
2700#else
2701 noexcept;
2702#endif
2703
2705 INLINE rmatrix operator -(const rmatrix &m) noexcept;
2707 INLINE rmatrix operator -(const rmatrix_slice &ms) noexcept;
2709 INLINE rmatrix operator -(const rmatrix &m1,const rmatrix &m2)
2710#if(CXSC_INDEX_CHECK)
2711;
2712#else
2713 noexcept;
2714#endif
2716 INLINE rmatrix operator -(const rmatrix &m,const rmatrix_slice &ms)
2717#if(CXSC_INDEX_CHECK)
2718;
2719#else
2720 noexcept;
2721#endif
2723 INLINE rmatrix operator -(const rmatrix_slice &ms,const rmatrix &m)
2724#if(CXSC_INDEX_CHECK)
2725;
2726#else
2727 noexcept;
2728#endif
2730 INLINE rmatrix operator -(const rmatrix_slice &ms1,const rmatrix_slice &ms2)
2731#if(CXSC_INDEX_CHECK)
2732;
2733#else
2734 noexcept;
2735#endif
2737 INLINE rmatrix &operator -=(rmatrix &m1,const rmatrix &m2)
2738#if(CXSC_INDEX_CHECK)
2739;
2740#else
2741 noexcept;
2742#endif
2744 INLINE rmatrix &operator -=(rmatrix &m1,const rmatrix_slice &ms)
2745#if(CXSC_INDEX_CHECK)
2746;
2747#else
2748 noexcept;
2749#endif
2750
2752 INLINE rmatrix operator *(const rmatrix &m1, const rmatrix &m2)
2753#if(CXSC_INDEX_CHECK)
2754;
2755#else
2756 noexcept;
2757#endif
2759 INLINE rmatrix operator *(const rmatrix &m1, const rmatrix_slice &ms)
2760#if(CXSC_INDEX_CHECK)
2761;
2762#else
2763 noexcept;
2764#endif
2766 INLINE rmatrix operator *(const rmatrix_slice &ms, const rmatrix &m1)
2767#if(CXSC_INDEX_CHECK)
2768;
2769#else
2770 noexcept;
2771#endif
2773 INLINE rmatrix operator *(const rmatrix_slice &ms1, const rmatrix_slice &ms2)
2774#if(CXSC_INDEX_CHECK)
2775;
2776#else
2777 noexcept;
2778#endif
2780 INLINE rmatrix &operator *=(rmatrix &m1,const rmatrix &m2)
2781#if(CXSC_INDEX_CHECK)
2782;
2783#else
2784 noexcept;
2785#endif
2787 INLINE rmatrix &operator *=(rmatrix &m1,const rmatrix_slice &ms)
2788#if(CXSC_INDEX_CHECK)
2789;
2790#else
2791 noexcept;
2792#endif
2793
2794
2795
2796//============== Compare Operator ==========================
2797
2798//-------------- Matrix - Matrix -------------------------
2799
2801 INLINE bool operator ==(const rmatrix &m1,const rmatrix &m2) noexcept;
2803 INLINE bool operator !=(const rmatrix &m1,const rmatrix &m2) noexcept;
2805 INLINE bool operator <(const rmatrix &m1,const rmatrix &m2) noexcept;
2807 INLINE bool operator <=(const rmatrix &m1,const rmatrix &m2) noexcept;
2809 INLINE bool operator >(const rmatrix &m1,const rmatrix &m2) noexcept;
2811 INLINE bool operator >=(const rmatrix &m1,const rmatrix &m2) noexcept;
2813 INLINE bool operator ==(const rmatrix &m1,const rmatrix_slice &ms) noexcept;
2815 INLINE bool operator !=(const rmatrix &m1,const rmatrix_slice &ms) noexcept;
2817 INLINE bool operator <(const rmatrix &m1,const rmatrix_slice &ms) noexcept;
2819 INLINE bool operator <=(const rmatrix &m1,const rmatrix_slice &ms) noexcept;
2821 INLINE bool operator >(const rmatrix &m1,const rmatrix_slice &ms) noexcept;
2823 INLINE bool operator >=(const rmatrix &m1,const rmatrix_slice &ms) noexcept;
2824
2825//---------------- Matrix - Matrix_slice ----------------------
2826
2828 INLINE bool operator ==(const rmatrix_slice &m1,const rmatrix_slice &m2) noexcept;
2830 INLINE bool operator !=(const rmatrix_slice &m1,const rmatrix_slice &m2) noexcept;
2832 INLINE bool operator <(const rmatrix_slice &m1,const rmatrix_slice &m2) noexcept;
2834 INLINE bool operator <=(const rmatrix_slice &m1,const rmatrix_slice &m2) noexcept;
2836 INLINE bool operator >(const rmatrix_slice &m1,const rmatrix_slice &m2) noexcept;
2838 INLINE bool operator >=(const rmatrix_slice &m1,const rmatrix_slice &m2) noexcept;
2839
2840//=================== Not Operator =============================
2841
2843 INLINE bool operator !(const rmatrix &ms) noexcept;
2845 INLINE bool operator !(const rmatrix_slice &ms) noexcept;
2846
2847//======================== Input / Output ========================
2848
2850 INLINE std::ostream &operator <<(std::ostream &s,const rmatrix &r) noexcept;
2852 INLINE std::ostream &operator <<(std::ostream &s,const rmatrix_slice &r) noexcept;
2854 INLINE std::istream &operator >>(std::istream &s,rmatrix &r) noexcept;
2856 INLINE std::istream &operator >>(std::istream &s,rmatrix_slice &r) noexcept;
2857
2858//INLINE rmatrix_subv Row(rmatrix &m,const int &i)
2859
2861 INLINE int RowLen ( const rmatrix& );
2863 INLINE int ColLen ( const rmatrix& );
2865 INLINE int RowLen ( const rmatrix_slice& );
2867 INLINE int ColLen ( const rmatrix_slice& );
2869 rmatrix Id ( const rmatrix& );
2871 rmatrix transp ( const rmatrix& );
2873 void DoubleSize ( rmatrix& );
2874
2875
2876
2877} // namespace cxsc
2878
2879#ifdef _CXSC_INCL_INL
2880# include "matrix.inl"
2881# include "rmatrix.inl"
2882#endif
2883
2884#ifdef _CXSC_IVECTOR_HPP_INCLUDED
2885# ifdef _CXSC_INCL_INL
2886# include "ivecrmat.inl"
2887# else
2888# include "ivecrmat.hpp"
2889# endif
2890#endif
2891
2892#ifdef _CXSC_CVECTOR_HPP_INCLUDED
2893# ifdef _CXSC_INCL_INL
2894# include "cvecrmat.inl"
2895# else
2896# include "cvecrmat.hpp"
2897# endif
2898#endif
2899
2900#ifdef _CXSC_CIVECTOR_HPP_INCLUDED
2901# ifdef _CXSC_INCL_INL
2902# include "civecrmat.inl"
2903# else
2904# include "civecrmat.hpp"
2905# endif
2906#endif
2907
2908#ifdef _CXSC_LIVECTOR_HPP_INCLUDED
2909# ifdef _CXSC_INCL_INL
2910# include "livecrmat.inl"
2911# else
2912# include "livecrmat.hpp"
2913# endif
2914#endif
2915
2916#ifdef _CXSC_LRVECTOR_HPP_INCLUDED
2917# ifdef _CXSC_INCL_INL
2918# include "lrvecrmat.inl"
2919# else
2920# include "lrvecrmat.hpp"
2921# endif
2922#endif
2923
2924#ifdef CXSC_USE_BLAS
2925#define _CXSC_BLAS_RMATRIX
2926#include "cxsc_blas.inl"
2927#endif
2928
2929#endif
The Data Type cimatrix_slice.
The Data Type cimatrix.
Definition cimatrix.hpp:908
The Data Type civector.
Definition civector.hpp:57
The Data Type cmatrix.
Definition cmatrix.hpp:514
The Data Type cvector.
Definition cvector.hpp:58
The Data Type imatrix.
Definition imatrix.hpp:660
The Data Type intmatrix.
The Data Type intvector.
Definition intvector.hpp:52
The Data Type ivector.
Definition ivector.hpp:55
The Multiple-Precision Data Type l_imatrix.
The Multiple-Precision Data Type l_ivector.
Definition l_ivector.hpp:55
The Multiple-Precision Data Type l_rmatrix.
The Multiple-Precision Data Type l_rvector.
Definition l_rvector.hpp:54
The Scalar Type real.
Definition real.hpp:114
real(void) noexcept
Constructor of class real.
Definition real.hpp:122
The Data Type rmatrix_slice.
Definition rmatrix.hpp:1443
rmatrix_slice & operator=(const srmatrix &m)
Implementation of standard assigning operator.
rmatrix_subv operator[](const int &i) const noexcept
Operator for accessing a single row of the matrix.
Definition rmatrix.inl:242
rmatrix_slice & operator-=(const srmatrix &m)
Implementation of multiplication and allocation operation.
rmatrix_slice & operator*=(const srmatrix &m)
Implementation of multiplication and allocation operation.
rmatrix_slice & operator+=(const srmatrix &m)
Implementation of multiplication and allocation operation.
rmatrix_slice & operator/=(const real &c) noexcept
Implementation of division and allocation operation.
Definition rmatrix.inl:422
rmatrix_slice(const rmatrix_slice &ms) noexcept
Constructor of class rmatrix_slice.
Definition rmatrix.hpp:2037
rmatrix_slice & operator()() noexcept
Operator for accessing the whole matrix.
Definition rmatrix.hpp:2106
rmatrix_slice(rmatrix_slice &a, const int &l1, const int &u1, const int &l2, const int &u2) noexcept
Constructor of class rmatrix_slice.
Definition rmatrix.hpp:2034
rmatrix_slice(rmatrix &a, const int &l1, const int &u1, const int &l2, const int &u2) noexcept
Constructor of class rmatrix_slice.
Definition rmatrix.hpp:2032
The Data Type rmatrix_subv.
Definition rmatrix.hpp:54
rmatrix_subv & operator()() noexcept
Operator for accessing the whole vector.
Definition rmatrix.hpp:337
rmatrix_subv(const rmatrix_subv &v) noexcept
Constructor of class rmatrix_subv.
Definition rmatrix.hpp:269
friend int VecLen(const rmatrix_subv &rv) noexcept
Returns the size of the vector.
Definition rmatrix.hpp:318
rmatrix_subv & operator+=(const real &c) noexcept
Implementation of addition and allocation operation.
Definition rmatrix.inl:428
friend rmatrix_subv Row(rmatrix &m, const int &i) noexcept
Returns one row of the matrix as a vector.
Definition rmatrix.inl:119
rmatrix_subv & operator=(const rmatrix_subv &rv) noexcept
Implementation of standard assigning operator.
Definition rmatrix.inl:322
rmatrix_subv(real *d, const int &l, const int &u, const int &s, const int &st, const int &o) noexcept
Constructor of class rmatrix_subv.
Definition rmatrix.hpp:266
friend int Lb(const rmatrix_subv &rv) noexcept
Returns the lower bound of the vector.
Definition rmatrix.hpp:314
rmatrix_subv & operator/=(const real &c) noexcept
Implementation of division and allocation operation.
Definition rmatrix.inl:430
friend rmatrix_subv Col(rmatrix &m, const int &i) noexcept
Returns one column of the matrix as a vector.
Definition rmatrix.inl:130
rmatrix_subv & operator*=(const real &c) noexcept
Implementation of multiplication and allocation operation.
Definition rmatrix.inl:427
real & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector (read-only)
Definition rmatrix.inl:162
friend int Ub(const rmatrix_subv &rv) noexcept
Returns the upper bound of the vector.
Definition rmatrix.hpp:316
rmatrix_subv & operator-=(const real &c) noexcept
Implementation of subtraction and allocation operation.
Definition rmatrix.inl:429
The Data Type rmatrix.
Definition rmatrix.hpp:471
friend rmatrix SupIm(const cimatrix &v) noexcept
Returns componentwise the supremum of the imaginary part.
Definition cimatrix.inl:820
friend rmatrix InfIm(const cimatrix &v) noexcept
Returns componentwise the infimum of the imaginary part.
Definition cimatrix.inl:795
rmatrix_subv operator[](const int &i) const noexcept
Operator for accessing a single row of the matrix.
Definition rmatrix.inl:190
rmatrix & operator=(const real &r) noexcept
Implementation of standard assigning operator.
Definition rmatrix.inl:338
rmatrix & operator-=(const srmatrix &m)
Implementation of substraction and allocation operation.
rmatrix() noexcept
Constructor of class rmatrix.
Definition rmatrix.inl:33
rmatrix & operator()() noexcept
Operator for accessing the whole matrix.
Definition rmatrix.hpp:1416
friend rmatrix InfRe(const cimatrix &v) noexcept
Returns componentwise the infimum of the real part.
Definition cimatrix.inl:745
friend rmatrix SupRe(const cimatrix &v) noexcept
Returns componentwise the supremum of the real part.
Definition cimatrix.inl:770
rmatrix & operator*=(const srmatrix &m)
Implementation of multiplication and allocation operation.
rmatrix & operator+=(const srmatrix &m)
Implementation of addition and allocation operation.
The Data Type rvector_slice.
Definition rvector.hpp:1064
The Data Type rvector.
Definition rvector.hpp:58
rvector() noexcept
Constructor of class rvector.
Definition rvector.inl:37
A slice of a sparse real matrix.
Represents a row or column vector of a sparse matrix.
A sparse real matrix.
Definition srmatrix.hpp:77
Helper class for slices of sparse vectors.
Definition srvector.hpp:868
A sparse real vector.
Definition srvector.hpp:58
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition cdot.cpp:29
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc) noexcept
Implementation of standard algebraic addition and allocation operation.
Definition cdot.inl:251
void accumulate_approx(cdotprecision &dp, const cmatrix_subv &rv1, const cmatrix_subv &rv2)
The accurate scalar product of the last two arguments added to the value of the first argument (witho...
Definition cmatrix.cpp:99
cimatrix_subv Col(cimatrix &m, const int &i) noexcept
Returns one column of the matrix as a vector.
Definition cimatrix.inl:242
int ColLen(const cimatrix &)
Returns the column dimension.
rmatrix CompMat(const cimatrix &A)
Returns Ostrowski's comparison matrix.
Definition cimatrix.cpp:45
rmatrix _rmatrix(const rmatrix &rm) noexcept
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC.
Definition rmatrix.inl:574
civector operator/(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of division operation.
Definition cimatrix.inl:730
cimatrix transp(const cimatrix &A)
Returns the transposed matrix.
Definition cimatrix.cpp:74
int Ub(const cimatrix &rm, const int &i) noexcept
Returns the upper bound index.
cimatrix & SetLb(cimatrix &m, const int &i, const int &j) noexcept
Sets the lower bound index.
int RowLen(const cimatrix &)
Returns the row dimension.
cimatrix_subv Row(cimatrix &m, const int &i) noexcept
Returns one row of the matrix as a vector.
Definition cimatrix.inl:231
void DoubleSize(cimatrix &A)
Doubles the size of the matrix.
Definition cimatrix.cpp:83
cimatrix Id(const cimatrix &A)
Returns the Identity matrix.
Definition cimatrix.cpp:61
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 & SetUb(cimatrix &m, const int &i, const int &j) noexcept
Sets the upper bound index.
int Lb(const cimatrix &rm, const int &i) noexcept
Returns the lower bound index.
cimatrix & operator/=(cimatrix &m, const cinterval &c) noexcept
Implementation of division and allocation operation.