C-XSC - A C++ Class Library for Extended Scientific Computing 2.5.4
cmatrix.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: cmatrix.hpp,v 1.37 2014/01/30 17:23:44 cxsc Exp $ */
25
26#ifndef _CXSC_CMATRIX_HPP_INCLUDED
27#define _CXSC_CMATRIX_HPP_INCLUDED
28
29#include "xscclass.hpp"
30#include "cdot.hpp"
31#include "cidot.hpp"
32#include "cvector.hpp"
33#include "except.hpp"
34#include "matrix.hpp"
35#include "rmatrix.hpp"
36
37namespace cxsc {
38
39class cmatrix;
40class cmatrix_slice;
41class srmatrix;
42class srmatrix_slice;
43class srmatrix_subv;
44class scmatrix;
45class scmatrix_slice;
46class scmatrix_subv;
47
48
50
54{
55 friend class cvector;
56 friend class civector;
57 friend class cmatrix;
58 friend class cmatrix_slice;
59 private:
60 complex *dat;
61 int lb,ub;
62 int size,start,offset; // start=first element index 0..n-1
63
64 public:
66 friend INLINE cmatrix_subv Row(cmatrix &m,const int &i)
67#if(CXSC_INDEX_CHECK)
68;
69#else
70 noexcept;
71#endif
73 friend INLINE cmatrix_subv Col(cmatrix &m,const int &i)
74#if(CXSC_INDEX_CHECK)
75;
76#else
77 noexcept;
78#endif
79 friend INLINE cmatrix_subv Row(const cmatrix &m,const int &i)
80#if(CXSC_INDEX_CHECK)
81;
82#else
83 noexcept;
84#endif
86 friend INLINE cmatrix_subv Col(const cmatrix &m,const int &i)
87#if(CXSC_INDEX_CHECK)
88;
89#else
90 noexcept;
91#endif
92//#if(CXSC_INDEX_CHECK)
93#ifdef _CXSC_FRIEND_TPL
94 //----------------- Templates ---------------------------------------
95template <class MV1,class MV2> friend MV1 &_mvmvassign(MV1 &v,const MV2 &rv)
96#if(CXSC_INDEX_CHECK)
97;
98#else
99 noexcept;
100#endif
101template <class MV,class S> friend MV &_mvsassign(MV &v,const S &r) noexcept;
102template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
103#if(CXSC_INDEX_CHECK)
104;
105#else
106 noexcept;
107#endif
108template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) noexcept;
109template <class MV,class V> friend V _mvabs(const MV &mv) noexcept;
110template <class MV,class V> friend V _mvim(const MV &mv) noexcept;
111template <class MV,class V> friend V _mvre(const MV &mv) noexcept;
112template <class MV,class V> friend MV &_mvvsetim(MV &v,const V &rv)
113#if(CXSC_INDEX_CHECK)
114;
115#else
116 noexcept;
117#endif
118template <class MV,class V> friend MV &_mvvsetre(MV &v,const V &rv)
119#if(CXSC_INDEX_CHECK)
120;
121#else
122 noexcept;
123#endif
124 template <class MV,class S> friend MV &_mvssetim(MV &mv, const S &s) noexcept;
125 template <class MV,class S> friend MV &_mvssetre(MV &mv, const S &s) noexcept;
126template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
127#if(CXSC_INDEX_CHECK)
128 ;
129#else
130 noexcept;
131#endif
132template <class DP,class MV1,class MV2> friend void _mvmvaccu(DP &dp, const MV1 & rv1, const MV2 &rv2)
133#if(CXSC_INDEX_CHECK)
134 ;
135#else
136 noexcept;
137#endif
138
139 template <class MV1,class MV2,class S> friend S _mvmvcmult(const MV1 & rv1, const MV2 &rv2)
140#if(CXSC_INDEX_CHECK)
141 ;
142#else
143 noexcept;
144#endif
145 template <class MV1,class MV2,class S> friend S _mvmvcimult(const MV1 & rv1, const MV2 &rv2)
146#if(CXSC_INDEX_CHECK)
147 ;
148#else
149 noexcept;
150#endif
151 template <class V,class MV,class S> friend S _vmvcmult(const V &rv1, const MV &rv2)
152#if(CXSC_INDEX_CHECK)
153 ;
154#else
155 noexcept;
156#endif
157 template <class V,class MV,class S> friend S _vmvcimult(const V &rv1, const MV &rv2)
158#if(CXSC_INDEX_CHECK)
159 ;
160#else
161 noexcept;
162#endif
163 template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) noexcept;
164 template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
165#if(CXSC_INDEX_CHECK)
166 ;
167#else
168 noexcept;
169#endif
170 template <class MV1,class MV2,class E> friend E _mvmvminus(const MV1 &rv1, const MV2 &rv2)
171#if(CXSC_INDEX_CHECK)
172 ;
173#else
174 noexcept;
175#endif
176 template <class MV,class V,class E> friend E _mvvplus(const MV &rv1, const V &rv2)
177#if(CXSC_INDEX_CHECK)
178 ;
179#else
180 noexcept;
181#endif
182 template <class MV,class V,class E> friend E _mvvminus(const MV &rv1, const V &rv2)
183#if(CXSC_INDEX_CHECK)
184 ;
185#else
186 noexcept;
187#endif
188 template <class V,class MV,class E> friend E _vmvminus(const V &rv1, const MV &rv2)
189#if(CXSC_INDEX_CHECK)
190 ;
191#else
192 noexcept;
193#endif
194 template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) noexcept;
195template <class MV,class S> friend MV &_mvsmultassign(MV &v,const S &r) noexcept;
196template <class MV, class S> friend MV &_mvsplusassign(MV &v,const S &r) noexcept;
197template <class MV,class S> friend MV &_mvsminusassign(MV &v,const S &r) noexcept;
198template <class MV,class S> friend MV &_mvsdivassign(MV &v,const S &r) noexcept;
199template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
200#if(CXSC_INDEX_CHECK)
201;
202#else
203 noexcept;
204#endif
205template <class V,class MV> friend V &_vmvplusassign(V &rv,const MV &v)
206#if(CXSC_INDEX_CHECK)
207;
208#else
209 noexcept;
210#endif
211template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv)
212#if(CXSC_INDEX_CHECK)
213;
214#else
215 noexcept;
216#endif
217template <class V,class MV> friend V &_vmvminusassign(V &rv,const MV &v)
218#if(CXSC_INDEX_CHECK)
219;
220#else
221 noexcept;
222#endif
223 // Real
224
225
226 // interval
227
228template <class V,class MV> friend V &_vmvsetinf(V &rv,const MV &v)
229#if(CXSC_INDEX_CHECK)
230;
231#else
232 noexcept;
233#endif
234template <class V,class MV> friend V &_vmvsetsup(V &rv,const MV &v)
235#if(CXSC_INDEX_CHECK)
236;
237#else
238 noexcept;
239#endif
240template <class V,class MV> friend V &_vmvusetinf(V &rv,const MV &v)
241#if(CXSC_INDEX_CHECK)
242;
243#else
244 noexcept;
245#endif
246template <class V,class MV> friend V &_vmvusetsup(V &rv,const MV &v)
247#if(CXSC_INDEX_CHECK)
248;
249#else
250 noexcept;
251#endif
252
253#endif
254
255 //----------------- Konstruktoren ----------------------------------
256
258 explicit INLINE cmatrix_subv (complex *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) { }
259 public:
261 INLINE cmatrix_subv(const cmatrix_subv &v) noexcept:dat(v.dat),lb(v.lb),ub(v.ub),size(v.size),start(v.start),offset(v.offset) { }
262 public:
263
264 //---------------------- Standardfunktionen ------------------------
266 friend INLINE int Lb(const cmatrix_subv &rv) noexcept { return rv.lb; }
268 friend INLINE int Ub(const cmatrix_subv &rv) noexcept { return rv.ub; }
270 friend INLINE int VecLen(const cmatrix_subv &rv) noexcept { return rv.size; }
271
273 INLINE complex& operator [](const int &i) const
274#if(CXSC_INDEX_CHECK)
275;
276#else
277 noexcept;
278#endif
279
281 INLINE complex& operator [](const int &i)
282#if(CXSC_INDEX_CHECK)
283;
284#else
285 noexcept;
286#endif
287
289 INLINE cmatrix_subv &operator ()() noexcept { return *this; }
291 INLINE cmatrix_subv operator ()(const int &i)
292#if(CXSC_INDEX_CHECK)
293;
294#else
295 noexcept;
296#endif
298 INLINE cmatrix_subv operator ()(const int &i1,const int &i2)
299#if(CXSC_INDEX_CHECK)
300;
301#else
302 noexcept;
303#endif
304
306 INLINE cmatrix_subv &operator =(const scmatrix_subv &rv);
308 INLINE cmatrix_subv &operator =(const scvector &r);
310 INLINE cmatrix_subv &operator =(const scvector_slice &r);
312 INLINE cmatrix_subv &operator =(const srmatrix_subv &rv);
314 INLINE cmatrix_subv &operator =(const srvector &r);
316 INLINE cmatrix_subv &operator =(const srvector_slice &r);
317
319 INLINE cmatrix_subv &operator =(const cmatrix_subv &rv) noexcept;
321 INLINE cmatrix_subv &operator =(const complex &r) noexcept;
323 INLINE cmatrix_subv &operator =(const cmatrix &m)
324#if(CXSC_INDEX_CHECK)
325;
326#else
327 noexcept;
328#endif
330 INLINE cmatrix_subv &operator =(const cmatrix_slice &m)
331#if(CXSC_INDEX_CHECK)
332;
333#else
334 noexcept;
335#endif
337 INLINE cmatrix_subv &operator =(const cvector &v)
338#if(CXSC_INDEX_CHECK)
339;
340#else
341 noexcept;
342#endif
344 INLINE cmatrix_subv &operator =(const cvector_slice &v)
345#if(CXSC_INDEX_CHECK)
346;
347#else
348 noexcept;
349#endif
350
351 //Sparse
353 INLINE cmatrix_subv &operator +=(const scmatrix_subv &rv);
355 INLINE cmatrix_subv &operator +=(const scvector &r);
357 INLINE cmatrix_subv &operator +=(const scvector_slice &r);
359 INLINE cmatrix_subv &operator +=(const srmatrix_subv &rv);
361 INLINE cmatrix_subv &operator +=(const srvector &r);
363 INLINE cmatrix_subv &operator +=(const srvector_slice &r);
365 INLINE cmatrix_subv &operator -=(const scmatrix_subv &rv);
371 INLINE cmatrix_subv &operator -=(const srmatrix_subv &rv);
376
378 INLINE cmatrix_subv &operator *=(const complex &c) noexcept;
380 INLINE cmatrix_subv &operator +=(const complex &c) noexcept;
382 INLINE cmatrix_subv &operator -=(const complex &c) noexcept;
384 INLINE cmatrix_subv &operator /=(const complex &c) noexcept;
386 INLINE cmatrix_subv &operator -=(const cvector &rv)
387#if(CXSC_INDEX_CHECK)
388;
389#else
390 noexcept;
391#endif
393 INLINE cmatrix_subv &operator +=(const cvector &rv)
394#if(CXSC_INDEX_CHECK)
395;
396#else
397 noexcept;
398#endif
400 INLINE cmatrix_subv &operator -=(const cvector_slice &rv)
401#if(CXSC_INDEX_CHECK)
402;
403#else
404 noexcept;
405#endif
407 INLINE cmatrix_subv &operator +=(const cvector_slice &rv)
408#if(CXSC_INDEX_CHECK)
409;
410#else
411 noexcept;
412#endif
413 // Real
415 INLINE cmatrix_subv &operator =(const rmatrix_subv &rv) noexcept;
417 INLINE cmatrix_subv &operator =(const real &r) noexcept;
419 INLINE cmatrix_subv &operator =(const rmatrix &m)
420#if(CXSC_INDEX_CHECK)
421;
422#else
423 noexcept;
424#endif
426 INLINE cmatrix_subv &operator =(const rmatrix_slice &m)
427#if(CXSC_INDEX_CHECK)
428;
429#else
430 noexcept;
431#endif
433 INLINE cmatrix_subv &operator =(const rvector &v)
434#if(CXSC_INDEX_CHECK)
435;
436#else
437 noexcept;
438#endif
440 INLINE cmatrix_subv &operator =(const rvector_slice &v)
441#if(CXSC_INDEX_CHECK)
442;
443#else
444 noexcept;
445#endif
446
448 INLINE cmatrix_subv &operator *=(const real &c) noexcept;
450 INLINE cmatrix_subv &operator +=(const real &c) noexcept;
452 INLINE cmatrix_subv &operator -=(const real &c) noexcept;
454 INLINE cmatrix_subv &operator /=(const real &c) noexcept;
456 INLINE cmatrix_subv &operator -=(const rvector &rv)
457#if(CXSC_INDEX_CHECK)
458;
459#else
460 noexcept;
461#endif
463 INLINE cmatrix_subv &operator +=(const rvector &rv)
464#if(CXSC_INDEX_CHECK)
465;
466#else
467 noexcept;
468#endif
470 INLINE cmatrix_subv &operator -=(const rvector_slice &rv)
471#if(CXSC_INDEX_CHECK)
472;
473#else
474 noexcept;
475#endif
477 INLINE cmatrix_subv &operator +=(const rvector_slice &rv)
478#if(CXSC_INDEX_CHECK)
479;
480#else
481 noexcept;
482#endif
483//#else
484//#endif
485
486};
487
489INLINE cmatrix_subv Row(cmatrix &m,const int &i)
490#if(CXSC_INDEX_CHECK)
491;
492#else
493 noexcept;
494#endif
496INLINE cmatrix_subv Col(cmatrix &m,const int &i)
497#if(CXSC_INDEX_CHECK)
498;
499#else
500 noexcept;
501#endif
502
503
504
505//----------------------- Matrix -----------------------------------------------
506
507class cmatrix_slice;
508
510
514{
515 friend class cmatrix_slice;
516 friend class cmatrix_subv;
517 friend class cimatrix;
518 private:
519 complex *dat;
520 int lb1,ub1,lb2,ub2,xsize,ysize;
521
522 public:
523 double* to_blas_array() const { return (double*)dat; }
524//#if(CXSC_INDEX_CHECK)
525#ifdef _CXSC_FRIEND_TPL
526 //----------------- Templates ---------------------------------------
527template <class S,class M> friend void _smconstr(S &s,const M &m)
528#if(CXSC_INDEX_CHECK)
529;
530#else
531 noexcept;
532#endif
533template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
534#if(CXSC_INDEX_CHECK)
535;
536#else
537 noexcept;
538#endif
539 template <class M1,class M2,class S> friend M1 &_mmassign(M1 &m1,const M2 &m,S ms) noexcept;
540 template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) noexcept;
541 template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m)
542#if(CXSC_INDEX_CHECK)
543 ;
544#else
545 noexcept;
546#endif
547 template <class M,class S> friend M &_msassign(M &m,const S &r) noexcept;
548template <class V,class M,class S> friend V &_vmassign(V &v,const M &m)
549#if(CXSC_INDEX_CHECK)
550;
551#else
552 noexcept;
553#endif
554template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) noexcept;
555 template <class M> friend int _mlb(const M &m, const int &i)
556#if(CXSC_INDEX_CHECK)
557;
558#else
559 noexcept;
560#endif
561 template <class M> friend int _mub(const M &m, const int &i)
562#if(CXSC_INDEX_CHECK)
563;
564#else
565 noexcept;
566#endif
567 template <class M> friend M &_msetlb(M &m, const int &i,const int &j)
568#if(CXSC_INDEX_CHECK)
569;
570#else
571 noexcept;
572#endif
573 template <class M> friend M &_msetub(M &m, const int &i,const int &j)
574#if(CXSC_INDEX_CHECK)
575;
576#else
577 noexcept;
578#endif
579 template <class M,class E> friend E _mre(const M &m) noexcept;
580 template <class M,class E> friend E _mim(const M &m) noexcept;
581 template <class M1,class M2> friend M1 &_mmsetre(M1 &m1,const M2 &m2)
582#if(CXSC_INDEX_CHECK)
583 ;
584#else
585 noexcept;
586#endif
587 template <class M1,class M2> friend M1 &_mmsetim(M1 &m1,const M2 &m2)
588#if(CXSC_INDEX_CHECK)
589 ;
590#else
591 noexcept;
592#endif
593 template <class M1,class MS2> friend M1 &_mmssetre(M1 &m1,const MS2 &ms2)
594#if(CXSC_INDEX_CHECK)
595 ;
596#else
597 noexcept;
598#endif
599 template <class M1,class MS2> friend M1 &_mmssetim(M1 &m1,const MS2 &ms2)
600#if(CXSC_INDEX_CHECK)
601 ;
602#else
603 noexcept;
604#endif
605 template <class M> friend void _mresize(M &A) noexcept;
606 template <class M,class S> friend void _mresize(M &A,const int &m, const int &n)
607#if(CXSC_INDEX_CHECK)
608 ;
609#else
610 noexcept;
611#endif
612 template <class M,class S> friend void _mresize(M &A,const int &m1, const int &m2,const int &n1,const int &n2)
613#if(CXSC_INDEX_CHECK)
614 ;
615#else
616 noexcept;
617#endif
618 template <class M,class E> friend E _mabs(const M &m) noexcept;
619 //-------------- matrix-matrix -------------
620 template <class M1,class M2,class E> friend E _mmplus(const M1 &m1,const M2 &m2)
621#if(CXSC_INDEX_CHECK)
622 ;
623#else
624 noexcept;
625#endif
626 template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms)
627#if(CXSC_INDEX_CHECK)
628 ;
629#else
630 noexcept;
631#endif
632 template <class M> friend M _mminus(const M &m) noexcept;
633 template <class MS,class E> friend E _msminus(const MS &ms) noexcept;
634 template <class M1,class M2,class E> friend E _mmminus(const M1 &m1,const M2 &m2)
635#if(CXSC_INDEX_CHECK)
636 ;
637#else
638 noexcept;
639#endif
640 template <class M1,class M2> friend M1 &_mmplusassign(M1 &m1,const M2 &m2)
641#if(CXSC_INDEX_CHECK)
642 ;
643#else
644 noexcept;
645#endif
646 template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms)
647#if(CXSC_INDEX_CHECK)
648 ;
649#else
650 noexcept;
651#endif
652 template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1)
653#if(CXSC_INDEX_CHECK)
654 ;
655#else
656 noexcept;
657#endif
658 template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2)
659#if(CXSC_INDEX_CHECK)
660 ;
661#else
662 noexcept;
663#endif
664 template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms)
665#if(CXSC_INDEX_CHECK)
666 ;
667#else
668 noexcept;
669#endif
670 template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m)
671#if(CXSC_INDEX_CHECK)
672 ;
673#else
674 noexcept;
675#endif
676 template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2)
677#if(CXSC_INDEX_CHECK)
678 ;
679#else
680 noexcept;
681#endif
682 template <class M1,class M2> friend M1 &_mmminusassign(M1 &m1,const M2 &m2)
683#if(CXSC_INDEX_CHECK)
684 ;
685#else
686 noexcept;
687#endif
688 template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms)
689#if(CXSC_INDEX_CHECK)
690 ;
691#else
692 noexcept;
693#endif
694 template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1)
695#if(CXSC_INDEX_CHECK)
696 ;
697#else
698 noexcept;
699#endif
700 template <class M1,class M2,class E> friend E _mmcmult(const M1 &m1, const M2 &m2)
701#if(CXSC_INDEX_CHECK)
702 ;
703#else
704 noexcept;
705#endif
706 template <class M1,class M2,class E> friend E _mmcimult(const M1 &m1, const M2 &m2)
707#if(CXSC_INDEX_CHECK)
708 ;
709#else
710 noexcept;
711#endif
712 template <class M1,class M2,class S> friend M1 &_mmcmultassign(M1 &m1,const M2 &m2)
713#if(CXSC_INDEX_CHECK)
714 ;
715#else
716 noexcept;
717#endif
718 template <class M1,class M2,class S> friend M1 &_mmcimultassign(M1 &m1,const M2 &m2)
719#if(CXSC_INDEX_CHECK)
720 ;
721#else
722 noexcept;
723#endif
724 template <class M,class MS,class E> friend E _mmscmult(const M &m1, const MS &ms)
725#if(CXSC_INDEX_CHECK)
726 ;
727#else
728 noexcept;
729#endif
730 template <class M,class MS,class E> friend E _mmscimult(const M &m1, const MS &ms)
731#if(CXSC_INDEX_CHECK)
732 ;
733#else
734 noexcept;
735#endif
736 template <class MS,class M,class E> friend E _msmcmult(const MS &ms, const M &m2)
737#if(CXSC_INDEX_CHECK)
738 ;
739#else
740 noexcept;
741#endif
742 template <class MS,class M,class E> friend E _msmcimult(const MS &ms, const M &m2)
743#if(CXSC_INDEX_CHECK)
744 ;
745#else
746 noexcept;
747#endif
748 template <class M,class MS,class S> friend M &_mmscmultassign(M &m1,const MS &ms)
749#if(CXSC_INDEX_CHECK)
750 ;
751#else
752 noexcept;
753#endif
754 template <class M,class MS,class S> friend M &_mmscimultassign(M &m1,const MS &ms)
755#if(CXSC_INDEX_CHECK)
756 ;
757#else
758 noexcept;
759#endif
760 template <class MS1,class MS2,class E> friend E _msmscmult(const MS1 &ms1, const MS2 &ms2)
761#if(CXSC_INDEX_CHECK)
762 ;
763#else
764 noexcept;
765#endif
766 template <class MS1,class MS2,class E> friend E _msmscimult(const MS1 &ms1, const MS2 &ms2)
767#if(CXSC_INDEX_CHECK)
768 ;
769#else
770 noexcept;
771#endif
772 template <class M1,class M2,class E> friend E _mmconv(const M1 &m1,const M2 &m2)
773#if(CXSC_INDEX_CHECK)
774 ;
775#else
776 noexcept;
777#endif
778 template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms)
779#if(CXSC_INDEX_CHECK)
780 ;
781#else
782 noexcept;
783#endif
784 //-------- matrix-scalar -----------------
785 template <class S,class M,class E> friend E _smmult(const S &c, const M &m) noexcept;
786 template <class M,class S> friend M &_msmultassign(M &m,const S &c) noexcept;
787 template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) noexcept;
788 template <class M,class S,class E> friend E _msdiv(const M &m,const S &c) noexcept;
789 template <class M,class S> friend M &_msdivassign(M &m,const S &c) noexcept;
790 template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) noexcept;
791 //-------- matrix-vector ---------------------
792 template <class M,class V,class E> friend E _mvcmult(const M &m,const V &v)
793#if(CXSC_INDEX_CHECK)
794 ;
795#else
796 noexcept;
797#endif
798 template <class M,class V,class E> friend E _mvcimult(const M &m,const V &v)
799#if(CXSC_INDEX_CHECK)
800 ;
801#else
802 noexcept;
803#endif
804 template <class V,class M,class E> friend E _vmcmult(const V &v,const M &m)
805#if(CXSC_INDEX_CHECK)
806 ;
807#else
808 noexcept;
809#endif
810 template <class V,class M,class E> friend E _vmcimult(const V &v,const M &m)
811#if(CXSC_INDEX_CHECK)
812 ;
813#else
814 noexcept;
815#endif
816 template <class V,class M,class S> friend V &_vmcmultassign(V &v,const M &m)
817#if(CXSC_INDEX_CHECK)
818 ;
819#else
820 noexcept;
821#endif
822 template <class V,class M,class S> friend V &_vmcimultassign(V &v,const M &m)
823#if(CXSC_INDEX_CHECK)
824 ;
825#else
826 noexcept;
827#endif
828 template <class VS,class M,class S> friend VS &_vsmcmultassign(VS &v,const M &m)
829#if(CXSC_INDEX_CHECK)
830 ;
831#else
832 noexcept;
833#endif
834 template <class VS,class M,class S> friend VS &_vsmcimultassign(VS &v,const M &m)
835#if(CXSC_INDEX_CHECK)
836 ;
837#else
838 noexcept;
839#endif
840
841 template <class M> friend void *_mvoid(const M &m) noexcept;
842 template <class M> friend bool _mnot(const M &m) noexcept;
843 template <class MS> friend void *_msvoid(const MS &ms) noexcept;
844 template <class MS> friend bool _msnot(const MS &ms) noexcept;
845 template <class M1,class M2> friend bool _mmeq(const M1 &m1,const M2 &m2) noexcept;
846 template <class M1,class M2> friend bool _mmneq(const M1 &m1,const M2 &m2) noexcept;
847 template <class M1,class M2> friend bool _mmless(const M1 &m1,const M2 &m2) noexcept;
848 template <class M1,class M2> friend bool _mmleq(const M1 &m1,const M2 &m2) noexcept;
849 template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) noexcept;
850 template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) noexcept;
851 template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) noexcept;
852 template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) noexcept;
853 template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) noexcept;
854 template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) noexcept;
855 template <class M> friend std::ostream &_mout(std::ostream &s,const M &r) noexcept;
856 template <class M> friend std::istream &_min(std::istream &s,M &r) noexcept;
857
858 // Real
859
860 //--- Real --------- matrix-matrix ----------------------
861
862 //--- Real --------- matrix-scalar ----------------------
863
864 //--- Real --------- matrix-vector ----------------------
865 template <class MS,class V,class E> friend E _msvcmult(const MS &ms,const V &v)
866#if(CXSC_INDEX_CHECK)
867 ;
868#else
869 noexcept;
870#endif
871 template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v)
872#if(CXSC_INDEX_CHECK)
873 ;
874#else
875 noexcept;
876#endif
877 template <class V,class MS,class E> friend E _vmscmult(const V &v,const MS &ms)
878#if(CXSC_INDEX_CHECK)
879 ;
880#else
881 noexcept;
882#endif
883 template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms)
884#if(CXSC_INDEX_CHECK)
885 ;
886#else
887 noexcept;
888#endif
889
890 // interval --------
891 // matrix-matrix
892
893 template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2)
894#if(CXSC_INDEX_CHECK)
895 ;
896#else
897 noexcept;
898#endif
899 template <class M1,class M2,class E> friend E _mmsect(const M1 &m1,const M2 &m2)
900#if(CXSC_INDEX_CHECK)
901 ;
902#else
903 noexcept;
904#endif
905 template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms)
906#if(CXSC_INDEX_CHECK)
907 ;
908#else
909 noexcept;
910#endif
911
912 template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2)
913#if(CXSC_INDEX_CHECK)
914 ;
915#else
916 noexcept;
917#endif
918 // matrix-scalar
919
920 // matrix-vector
921
922 // cinterval ----------
923
924 template <class M,class E> friend E _mdiam(const M &m) noexcept;
925 template <class M,class E> friend E _mmid(const M &m) noexcept;
926 template <class MS,class E> friend E _msdiam(const MS &ms) noexcept;
927 template <class MS,class E> friend E _msmid(const MS &ms) noexcept;
928 template <class M,class E> friend E _minf(const M &m) noexcept;
929 template <class MS,class E> friend E _msinf(const MS &ms) noexcept;
930 template <class M,class E> friend E _msup(const M &m) noexcept;
931 template <class MS,class E> friend E _mssup(const MS &ms) noexcept;
932 template <class M1,class M2> friend M1 &_mmsetinf(M1 &m1,const M2 &m2)
933#if(CXSC_INDEX_CHECK)
934 ;
935#else
936 noexcept;
937#endif
938 template <class M1,class M2> friend M1 &_mmsetsup(M1 &m1,const M2 &m2)
939#if(CXSC_INDEX_CHECK)
940 ;
941#else
942 noexcept;
943#endif
944 template <class M1,class M2> friend M1 &_mmusetinf(M1 &m1,const M2 &m2)
945#if(CXSC_INDEX_CHECK)
946 ;
947#else
948 noexcept;
949#endif
950 template <class M1,class M2> friend M1 &_mmusetsup(M1 &m1,const M2 &m2)
951#if(CXSC_INDEX_CHECK)
952 ;
953#else
954 noexcept;
955#endif
956 template <class MS1,class M2> friend MS1 &_msmsetinf(MS1 &ms1,const M2 &m2)
957#if(CXSC_INDEX_CHECK)
958 ;
959#else
960 noexcept;
961#endif
962 template <class MS1,class M2> friend MS1 &_msmsetsup(MS1 &ms1,const M2 &m2)
963#if(CXSC_INDEX_CHECK)
964 ;
965#else
966 noexcept;
967#endif
968 template <class MS1,class M2> friend MS1 &_msmusetinf(MS1 &ms1,const M2 &m2)
969#if(CXSC_INDEX_CHECK)
970 ;
971#else
972 noexcept;
973#endif
974 template <class MS1,class M2> friend MS1 &_msmusetsup(MS1 &ms1,const M2 &m2)
975#if(CXSC_INDEX_CHECK)
976 ;
977#else
978 noexcept;
979#endif
980
981 // matrix-matrix
982
983 template <class M1,class M2> friend M1 &_mmconvassign(M1 &m1,const M2 &m2)
984#if(CXSC_INDEX_CHECK)
985 ;
986#else
987 noexcept;
988#endif
989 template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms)
990#if(CXSC_INDEX_CHECK)
991 ;
992#else
993 noexcept;
994#endif
995 template <class MS,class M> friend MS &_msmconvassign(MS &ms,const M &m1)
996#if(CXSC_INDEX_CHECK)
997 ;
998#else
999 noexcept;
1000#endif
1001
1002 template <class M1,class M2> friend M1 &_mmsectassign(M1 &m1,const M2 &m2)
1003#if(CXSC_INDEX_CHECK)
1004 ;
1005#else
1006 noexcept;
1007#endif
1008 template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms)
1009#if(CXSC_INDEX_CHECK)
1010 ;
1011#else
1012 noexcept;
1013#endif
1014 template <class MS,class M> friend MS &_msmsectassign(MS &ms,const M &m1)
1015#if(CXSC_INDEX_CHECK)
1016 ;
1017#else
1018 noexcept;
1019#endif
1020 // matrix-scalar
1021
1022 // matrix-vector
1023
1024#endif
1025
1026 //-------------------------- Konstruktoren ----------------------------
1027
1028// complex
1030 INLINE cmatrix(const cmatrix &rm) noexcept;
1032 INLINE cmatrix(const cmatrix_slice &rm) noexcept;
1034 INLINE cmatrix(const scmatrix &rm);
1036 INLINE cmatrix(const scmatrix_slice &rm);
1038 INLINE cmatrix() noexcept;
1040 explicit INLINE cmatrix(const int &m, const int &n)
1041#if(CXSC_INDEX_CHECK)
1042;
1043#else
1044 noexcept;
1045#endif
1047 explicit INLINE cmatrix(const int &m1, const int &n1, const int &m2, const int &n2)
1048#if(CXSC_INDEX_CHECK)
1049;
1050#else
1051 noexcept;
1052#endif
1054 explicit INLINE cmatrix(const cvector &v) noexcept;
1056 explicit INLINE cmatrix(const cvector_slice &v) noexcept;
1058 explicit INLINE cmatrix(const complex &r) noexcept;
1060 INLINE cmatrix &operator =(const complex &r) noexcept;
1062 INLINE cmatrix &operator =(const cmatrix &m) noexcept;
1064 INLINE cmatrix &operator =(const cmatrix_slice &ms) noexcept;
1066 INLINE cmatrix &operator =(const scmatrix &m);
1068 INLINE cmatrix &operator =(const scmatrix_slice &ms);
1070 INLINE cmatrix &operator =(const cvector &v) noexcept;
1072 INLINE cmatrix &operator =(const cvector_slice &v) noexcept;
1073// real
1075 explicit INLINE cmatrix(const real &) noexcept;
1077 explicit INLINE cmatrix(const rmatrix &rm) noexcept;
1079 explicit INLINE cmatrix(const rmatrix_slice &rm) noexcept;
1081 explicit INLINE cmatrix(const srmatrix &rm);
1083 explicit INLINE cmatrix(const srmatrix_slice &rm);
1085 explicit INLINE cmatrix(const rvector &v) noexcept;
1087 explicit INLINE cmatrix(const rvector_slice &v) noexcept;
1089 INLINE cmatrix &operator =(const real &r) noexcept;
1091 INLINE cmatrix &operator =(const rmatrix &m) noexcept;
1093 INLINE cmatrix &operator =(const rmatrix_slice &ms) noexcept;
1095 INLINE cmatrix &operator =(const srmatrix &m);
1097 INLINE cmatrix &operator =(const srmatrix_slice &ms);
1099 INLINE cmatrix &operator =(const rvector &v) noexcept;
1101 INLINE cmatrix &operator =(const rvector_slice &v) noexcept;
1102
1103 //--------------------------- Destruktoren -----------------------------
1104
1105 INLINE ~cmatrix() noexcept { delete [] dat; }
1106
1107
1108 //--------------------------- Operatoren -----------------------------
1110 INLINE cmatrix &operator +=(const srmatrix &m);
1112 INLINE cmatrix &operator +=(const srmatrix_slice &ms);
1114 INLINE cmatrix &operator +=(const scmatrix &m);
1116 INLINE cmatrix &operator +=(const scmatrix_slice &ms);
1118 INLINE cmatrix &operator -=(const srmatrix &m);
1120 INLINE cmatrix &operator -=(const srmatrix_slice &ms);
1122 INLINE cmatrix &operator -=(const scmatrix &m);
1124 INLINE cmatrix &operator -=(const scmatrix_slice &ms);
1126 INLINE cmatrix &operator *=(const srmatrix &m);
1128 INLINE cmatrix &operator *=(const srmatrix_slice &ms);
1130 INLINE cmatrix &operator *=(const scmatrix &m);
1132 INLINE cmatrix &operator *=(const scmatrix_slice &ms);
1133
1135 INLINE cmatrix operator()(const intvector& p, const intvector& q);
1137 INLINE cmatrix operator()(const intmatrix& P, const intmatrix& Q);
1139 INLINE cmatrix operator()(const intvector& p);
1141 INLINE cmatrix operator()(const intmatrix& P);
1142
1143
1144 //------------------------- Standardfunktionen -------------------------
1145
1147 INLINE cmatrix_subv operator [](const int &i) const
1148#if(CXSC_INDEX_CHECK)
1149;
1150#else
1151 noexcept;
1152#endif
1154 INLINE cmatrix_subv operator [](const cxscmatrix_column &i) const
1155#if(CXSC_INDEX_CHECK)
1156;
1157#else
1158 noexcept;
1159#endif
1161 INLINE cmatrix_subv operator [](const int &i)
1162#if(CXSC_INDEX_CHECK)
1163;
1164#else
1165 noexcept;
1166#endif
1168 INLINE cmatrix_subv operator [](const cxscmatrix_column &i)
1169#if(CXSC_INDEX_CHECK)
1170;
1171#else
1172 noexcept;
1173#endif
1175 INLINE cmatrix &operator ()() noexcept { return *this; }
1177 INLINE cmatrix_slice operator ()(const int &m, const int &n)
1178#if(CXSC_INDEX_CHECK)
1179;
1180#else
1181 noexcept;
1182#endif
1184 INLINE cmatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
1185#if(CXSC_INDEX_CHECK)
1186;
1187#else
1188 noexcept;
1189#endif
1190 INLINE operator void*() noexcept;
1191//#else
1192//#endif
1193};
1194
1195
1197
1203{
1204 friend class cmatrix;
1205 friend class cimatrix;
1206 private:
1207 complex *dat;
1208 int offset1,offset2,mxsize,mysize;
1209 int start1,end1,start2,end2,sxsize,sysize; // slice size
1210
1211 public:
1212//#if(CXSC_INDEX_CHECK)
1213#ifdef _CXSC_FRIEND_TPL
1214 //----------------- Templates ---------------------------------------
1215template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m)
1216#if(CXSC_INDEX_CHECK)
1217;
1218#else
1219 noexcept;
1220#endif
1221 template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m)
1222#if(CXSC_INDEX_CHECK)
1223 ;
1224#else
1225 noexcept;
1226#endif
1227 template <class MS1,class MS2> friend MS1 &_msmsassign(MS1 &ms1,const MS2 &ms)
1228#if(CXSC_INDEX_CHECK)
1229 ;
1230#else
1231 noexcept;
1232#endif
1233 template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) noexcept;
1234 template <class MS,class S> friend MS &_mssassign(MS &ms,const S &r) noexcept;
1235
1236 template <class MS> friend int _mslb(const MS &ms, const int &i)
1237#if(CXSC_INDEX_CHECK)
1238;
1239#else
1240 noexcept;
1241#endif
1242 template <class MS> friend int _msub(const MS &ms, const int &i)
1243#if(CXSC_INDEX_CHECK)
1244;
1245#else
1246 noexcept;
1247#endif
1248 template <class MS,class E> friend E _msre(const MS &ms) noexcept;
1249 template <class MS,class E> friend E _msim(const MS &ms) noexcept;
1250 template <class MS1,class M2> friend MS1 &_msmsetre(MS1 &ms1,const M2 &m2)
1251#if(CXSC_INDEX_CHECK)
1252 ;
1253#else
1254 noexcept;
1255#endif
1256 template <class MS1,class M2> friend MS1 &_msmsetim(MS1 &ms1,const M2 &m2)
1257#if(CXSC_INDEX_CHECK)
1258 ;
1259#else
1260 noexcept;
1261#endif
1262 template <class MS1,class MS2> friend MS1 &_msmssetre(MS1 &ms1,const MS2 &ms2)
1263#if(CXSC_INDEX_CHECK)
1264 ;
1265#else
1266 noexcept;
1267#endif
1268 template <class MS1,class MS2> friend MS1 &_msmssetim(MS1 &ms1,const MS2 &ms2)
1269#if(CXSC_INDEX_CHECK)
1270 ;
1271#else
1272 noexcept;
1273#endif
1274 template <class MS,class E> friend E _msabs(const MS &ms) noexcept;
1275 //-------- matrix-matrix --------------
1276 template <class MS,class E> friend E _msminus(const MS &ms) noexcept;
1277 template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms)
1278#if(CXSC_INDEX_CHECK)
1279 ;
1280#else
1281 noexcept;
1282#endif
1283 template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2)
1284#if(CXSC_INDEX_CHECK)
1285 ;
1286#else
1287 noexcept;
1288#endif
1289 template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms)
1290#if(CXSC_INDEX_CHECK)
1291 ;
1292#else
1293 noexcept;
1294#endif
1295 template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1)
1296#if(CXSC_INDEX_CHECK)
1297 ;
1298#else
1299 noexcept;
1300#endif
1301 template <class MS1,class MS2> friend MS1 &_msmsplusassign(MS1 &ms1,const MS2 &ms2)
1302#if(CXSC_INDEX_CHECK)
1303 ;
1304#else
1305 noexcept;
1306#endif
1307 template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms)
1308#if(CXSC_INDEX_CHECK)
1309 ;
1310#else
1311 noexcept;
1312#endif
1313 template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m)
1314#if(CXSC_INDEX_CHECK)
1315 ;
1316#else
1317 noexcept;
1318#endif
1319 template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2)
1320#if(CXSC_INDEX_CHECK)
1321 ;
1322#else
1323 noexcept;
1324#endif
1325 template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms)
1326#if(CXSC_INDEX_CHECK)
1327 ;
1328#else
1329 noexcept;
1330#endif
1331 template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1)
1332#if(CXSC_INDEX_CHECK)
1333 ;
1334#else
1335 noexcept;
1336#endif
1337 template <class MS1,class MS2> friend MS1 &_msmsminusassign(MS1 &ms1,const MS2 &ms2)
1338#if(CXSC_INDEX_CHECK)
1339 ;
1340#else
1341 noexcept;
1342#endif
1343 template <class M,class MS,class E> friend E _mmscmult(const M &m1, const MS &ms)
1344#if(CXSC_INDEX_CHECK)
1345 ;
1346#else
1347 noexcept;
1348#endif
1349 template <class M,class MS,class E> friend E _mmscimult(const M &m1, const MS &ms)
1350#if(CXSC_INDEX_CHECK)
1351 ;
1352#else
1353 noexcept;
1354#endif
1355 template <class MS,class M,class E> friend E _msmcmult(const MS &ms, const M &m2)
1356#if(CXSC_INDEX_CHECK)
1357 ;
1358#else
1359 noexcept;
1360#endif
1361 template <class MS,class M,class E> friend E _msmcimult(const MS &ms, const M &m2)
1362#if(CXSC_INDEX_CHECK)
1363 ;
1364#else
1365 noexcept;
1366#endif
1367 template <class M,class MS,class S> friend M &_mmscmultassign(M &m1,const MS &ms)
1368#if(CXSC_INDEX_CHECK)
1369 ;
1370#else
1371 noexcept;
1372#endif
1373 template <class M,class MS,class S> friend M &_mmscimultassign(M &m1,const MS &ms)
1374#if(CXSC_INDEX_CHECK)
1375 ;
1376#else
1377 noexcept;
1378#endif
1379 template <class MS1,class MS2,class E> friend E _msmscmult(const MS1 &ms1, const MS2 &ms2)
1380#if(CXSC_INDEX_CHECK)
1381 ;
1382#else
1383 noexcept;
1384#endif
1385 template <class MS1,class MS2,class E> friend E _msmscimult(const MS1 &ms1, const MS2 &ms2)
1386#if(CXSC_INDEX_CHECK)
1387 ;
1388#else
1389 noexcept;
1390#endif
1391 template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms)
1392#if(CXSC_INDEX_CHECK)
1393 ;
1394#else
1395 noexcept;
1396#endif
1397 template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2)
1398#if(CXSC_INDEX_CHECK)
1399 ;
1400#else
1401 noexcept;
1402#endif
1403 //--------- matrix-vector --------------
1404 template <class MS,class V,class E> friend E _msvcmult(const MS &ms,const V &v)
1405#if(CXSC_INDEX_CHECK)
1406 ;
1407#else
1408 noexcept;
1409#endif
1410 template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v)
1411#if(CXSC_INDEX_CHECK)
1412 ;
1413#else
1414 noexcept;
1415#endif
1416 template <class V,class MS,class E> friend E _vmscmult(const V &v,const MS &ms)
1417#if(CXSC_INDEX_CHECK)
1418 ;
1419#else
1420 noexcept;
1421#endif
1422 template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms)
1423#if(CXSC_INDEX_CHECK)
1424 ;
1425#else
1426 noexcept;
1427#endif
1428 template <class V,class MS,class S> friend V &_vmscmultassign(V &v,const MS &ms)
1429#if(CXSC_INDEX_CHECK)
1430 ;
1431#else
1432 noexcept;
1433#endif
1434 template <class V,class MS,class S> friend V &_vmscimultassign(V &v,const MS &ms)
1435#if(CXSC_INDEX_CHECK)
1436 ;
1437#else
1438 noexcept;
1439#endif
1440 //--------- matrix-scalar --------------
1441 template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) noexcept;
1442 template <class MS,class S> friend MS &_mssmultassign(MS &ms,const S &c) noexcept;
1443 template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) noexcept;
1444 template <class MS,class S> friend MS &_mssdivassign(MS &ms,const S &c) noexcept;
1445
1446 template <class MS> friend void *_msvoid(const MS &ms) noexcept;
1447 template <class MS> friend bool _msnot(const MS &ms) noexcept;
1448 template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) noexcept;
1449 template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) noexcept;
1450 template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) noexcept;
1451 template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) noexcept;
1452 template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) noexcept;
1453 template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) noexcept;
1454 template <class MS1,class MS2> friend bool _msmseq(const MS1 &ms1,const MS2 &ms2) noexcept;
1455 template <class MS1,class MS2> friend bool _msmsneq(const MS1 &ms1,const MS2 &ms2) noexcept;
1456 template <class MS1,class MS2> friend bool _msmsless(const MS1 &ms1,const MS2 &ms2) noexcept;
1457 template <class MS1,class MS2> friend bool _msmsleq(const MS1 &ms1,const MS2 &ms2) noexcept;
1458 template <class MS> friend std::ostream &_msout(std::ostream &s,const MS &r) noexcept;
1459 template <class MS> friend std::istream &_msin(std::istream &s,MS &r) noexcept;
1460
1461 // Real
1462
1463 //--- Real ------------ matrix-scalar -----------
1464 //--- Real ------------ matrix-vector -----------
1465 //--- Real ------------ matrix-matrix -----------
1466 // interval ----------------
1467 // matrix-matrix
1468
1469 template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms)
1470#if(CXSC_INDEX_CHECK)
1471 ;
1472#else
1473 noexcept;
1474#endif
1475 template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2)
1476#if(CXSC_INDEX_CHECK)
1477 ;
1478#else
1479 noexcept;
1480#endif
1481 // matrix-scalar
1482 // matrix-vector
1483
1484 // cinterval --------------
1485
1486 template <class M1,class MS2> friend M1 &_mmssetinf(M1 &m1,const MS2 &ms2)
1487#if(CXSC_INDEX_CHECK)
1488 ;
1489#else
1490 noexcept;
1491#endif
1492 template <class M1,class MS2> friend M1 &_mmssetsup(M1 &m1,const MS2 &ms2)
1493#if(CXSC_INDEX_CHECK)
1494 ;
1495#else
1496 noexcept;
1497#endif
1498 template <class M1,class MS2> friend M1 &_mmsusetinf(M1 &m1,const MS2 &ms2)
1499#if(CXSC_INDEX_CHECK)
1500 ;
1501#else
1502 noexcept;
1503#endif
1504 template <class M1,class MS2> friend M1 &_mmsusetsup(M1 &m1,const MS2 &ms2)
1505#if(CXSC_INDEX_CHECK)
1506 ;
1507#else
1508 noexcept;
1509#endif
1510 template <class MS1,class MS2> friend MS1 &_msmssetinf(MS1 &ms1,const MS2 &ms2)
1511#if(CXSC_INDEX_CHECK)
1512 ;
1513#else
1514 noexcept;
1515#endif
1516 template <class MS1,class MS2> friend MS1 &_msmssetsup(MS1 &ms1,const MS2 &ms2)
1517#if(CXSC_INDEX_CHECK)
1518 ;
1519#else
1520 noexcept;
1521#endif
1522 template <class MS1,class MS2> friend MS1 &_msmsusetinf(MS1 &ms1,const MS2 &ms2)
1523#if(CXSC_INDEX_CHECK)
1524 ;
1525#else
1526 noexcept;
1527#endif
1528 template <class MS1,class MS2> friend MS1 &_msmsusetsup(MS1 &ms1,const MS2 &ms2)
1529#if(CXSC_INDEX_CHECK)
1530 ;
1531#else
1532 noexcept;
1533#endif
1534
1535 // matrix-matrix
1536
1537 template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms)
1538#if(CXSC_INDEX_CHECK)
1539 ;
1540#else
1541 noexcept;
1542#endif
1543 template <class MS1,class MS2> friend MS1 &_msmsconvassign(MS1 &ms1,const MS2 &ms2)
1544#if(CXSC_INDEX_CHECK)
1545 ;
1546#else
1547 noexcept;
1548#endif
1549
1550 template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms)
1551#if(CXSC_INDEX_CHECK)
1552 ;
1553#else
1554 noexcept;
1555#endif
1556 template <class MS1,class MS2> friend MS1 &_msmssectassign(MS1 &ms1,const MS2 &ms2)
1557#if(CXSC_INDEX_CHECK)
1558 ;
1559#else
1560 noexcept;
1561#endif
1562
1563 // matrix-scalar
1564 // cinterval -- matrix-vector
1565
1566
1567 /* friend TINLINE civector &_vsmscimultassign<civector_slice,cmatrix_slice,cinterval>(civector_slice &v,const cmatrix_slice &ms)
1568#if(CXSC_INDEX_CHECK)
1569;
1570#else
1571 noexcept;
1572 #endif */
1573
1574#endif
1575
1576 //--------------- Konstruktoren ----------------------------------------
1577
1579 explicit INLINE cmatrix_slice(cmatrix &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) { }
1581 explicit INLINE cmatrix_slice(cmatrix_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) { }
1582 public:
1584 INLINE cmatrix_slice(const cmatrix_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) { }
1585 public:
1586
1587 //---------------- Standardfunktionen -----------------------------------
1588
1589 friend cvector::cvector(const cmatrix_slice &sl)
1590#if(CXSC_INDEX_CHECK)
1591;
1592#else
1593 noexcept;
1594#endif
1595 friend INLINE cmatrix::cmatrix(const cmatrix_slice &) noexcept;
1597 INLINE cmatrix_slice &operator =(const cmatrix &m)
1598#if(CXSC_INDEX_CHECK)
1599;
1600#else
1601 noexcept;
1602#endif
1603
1604 //Sparse
1606 INLINE cmatrix_slice &operator =(const scmatrix &ms);
1610 INLINE cmatrix_slice &operator =(const srmatrix &ms);
1613
1614
1616 INLINE cmatrix_slice &operator =(const cmatrix_slice &ms)
1617#if(CXSC_INDEX_CHECK)
1618;
1619#else
1620 noexcept;
1621#endif
1623 INLINE cmatrix_slice &operator =(const complex &r) noexcept;
1625 INLINE cmatrix_slice &operator =(const cvector &v)
1626#if(CXSC_INDEX_CHECK)
1627;
1628#else
1629 noexcept;
1630#endif
1632 INLINE cmatrix_slice &operator =(const cvector_slice &v)
1633#if(CXSC_INDEX_CHECK)
1634;
1635#else
1636 noexcept;
1637#endif
1639 INLINE cmatrix_slice &operator =(const rmatrix &m)
1640#if(CXSC_INDEX_CHECK)
1641;
1642#else
1643 noexcept;
1644#endif
1646 INLINE cmatrix_slice &operator =(const rmatrix_slice &ms)
1647#if(CXSC_INDEX_CHECK)
1648;
1649#else
1650 noexcept;
1651#endif
1653 INLINE cmatrix_slice &operator =(const real &r) noexcept;
1655 INLINE cmatrix_slice &operator =(const rvector &v)
1656#if(CXSC_INDEX_CHECK)
1657;
1658#else
1659 noexcept;
1660#endif
1662 INLINE cmatrix_slice &operator =(const rvector_slice &v)
1663#if(CXSC_INDEX_CHECK)
1664;
1665#else
1666 noexcept;
1667#endif
1669 INLINE cmatrix_subv operator [](const int &i)
1670#if(CXSC_INDEX_CHECK)
1671;
1672#else
1673 noexcept;
1674#endif
1676 INLINE cmatrix_subv operator [](const cxscmatrix_column &i)
1677#if(CXSC_INDEX_CHECK)
1678;
1679#else
1680 noexcept;
1681#endif
1682
1684 INLINE cmatrix_subv operator [](const int &i) const
1685#if(CXSC_INDEX_CHECK)
1686;
1687#else
1688 noexcept;
1689#endif
1691 INLINE cmatrix_subv operator [](const cxscmatrix_column &i) const
1692#if(CXSC_INDEX_CHECK)
1693;
1694#else
1695 noexcept;
1696#endif
1698 INLINE cmatrix_slice &operator ()() noexcept { return *this; }
1700 INLINE cmatrix_slice operator ()(const int &m, const int &n)
1701#if(CXSC_INDEX_CHECK)
1702;
1703#else
1704 noexcept;
1705#endif
1707 INLINE cmatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
1708#if(CXSC_INDEX_CHECK)
1709;
1710#else
1711 noexcept;
1712#endif
1713
1714 //Sparse
1716 INLINE cmatrix_slice &operator +=(const srmatrix &m);
1718 INLINE cmatrix_slice &operator +=(const srmatrix_slice &ms);
1720 INLINE cmatrix_slice &operator +=(const scmatrix &m);
1722 INLINE cmatrix_slice &operator +=(const scmatrix_slice &ms);
1724 INLINE cmatrix_slice &operator -=(const srmatrix &m);
1726 INLINE cmatrix_slice &operator -=(const srmatrix_slice &ms);
1728 INLINE cmatrix_slice &operator -=(const scmatrix &m);
1730 INLINE cmatrix_slice &operator -=(const scmatrix_slice &ms);
1732 INLINE cmatrix_slice &operator *=(const srmatrix &m);
1734 INLINE cmatrix_slice &operator *=(const srmatrix_slice &ms);
1736 INLINE cmatrix_slice &operator *=(const scmatrix &m);
1738 INLINE cmatrix_slice &operator *=(const scmatrix_slice &ms);
1739
1741 INLINE cmatrix_slice &operator *=(const cmatrix &m)
1742#if(CXSC_INDEX_CHECK)
1743;
1744#else
1745 noexcept;
1746#endif
1748 INLINE cmatrix_slice &operator *=(const rmatrix &m)
1749#if(CXSC_INDEX_CHECK)
1750;
1751#else
1752 noexcept;
1753#endif
1755 INLINE cmatrix_slice &operator *=(const cmatrix_slice &ms2)
1756#if(CXSC_INDEX_CHECK)
1757;
1758#else
1759 noexcept;
1760#endif
1762 INLINE cmatrix_slice &operator *=(const rmatrix_slice &ms2)
1763#if(CXSC_INDEX_CHECK)
1764;
1765#else
1766 noexcept;
1767#endif
1769 INLINE cmatrix_slice &operator +=(const cmatrix &m1)
1770#if(CXSC_INDEX_CHECK)
1771;
1772#else
1773 noexcept;
1774#endif
1776 INLINE cmatrix_slice &operator +=(const rmatrix &m1)
1777#if(CXSC_INDEX_CHECK)
1778;
1779#else
1780 noexcept;
1781#endif
1783 INLINE cmatrix_slice &operator +=(const cmatrix_slice &ms2)
1784#if(CXSC_INDEX_CHECK)
1785;
1786#else
1787 noexcept;
1788#endif
1790 INLINE cmatrix_slice &operator +=(const rmatrix_slice &ms2)
1791#if(CXSC_INDEX_CHECK)
1792;
1793#else
1794 noexcept;
1795#endif
1797 INLINE cmatrix_slice &operator -=(const cmatrix &m1)
1798#if(CXSC_INDEX_CHECK)
1799;
1800#else
1801 noexcept;
1802#endif
1804 INLINE cmatrix_slice &operator -=(const rmatrix &m1)
1805#if(CXSC_INDEX_CHECK)
1806;
1807#else
1808 noexcept;
1809#endif
1811 INLINE cmatrix_slice &operator -=(const cmatrix_slice &ms2)
1812#if(CXSC_INDEX_CHECK)
1813;
1814#else
1815 noexcept;
1816#endif
1818 INLINE cmatrix_slice &operator -=(const rmatrix_slice &ms2)
1819#if(CXSC_INDEX_CHECK)
1820;
1821#else
1822 noexcept;
1823#endif
1826#if(CXSC_INDEX_CHECK)
1827;
1828#else
1829 noexcept;
1830#endif
1833#if(CXSC_INDEX_CHECK)
1834;
1835#else
1836 noexcept;
1837#endif
1840#if(CXSC_INDEX_CHECK)
1841;
1842#else
1843 noexcept;
1844#endif
1847#if(CXSC_INDEX_CHECK)
1848;
1849#else
1850 noexcept;
1851#endif
1853 INLINE cmatrix_slice &operator *=(const complex &c) noexcept;
1855 INLINE cmatrix_slice &operator *=(const real &c) noexcept;
1857 INLINE cmatrix_slice &operator /=(const complex &c) noexcept;
1859 INLINE cmatrix_slice &operator /=(const real &c) noexcept;
1860 INLINE operator void*() noexcept;
1861//#else
1862//#endif
1863};
1864
1865//================================================================
1866//====================== Subvector Functions =====================
1867
1868//=======================Vector / Scalar =========================
1869
1871 INLINE cvector operator /(const cmatrix_subv &rv, const complex &s) noexcept;
1873 INLINE cvector operator *(const cmatrix_subv &rv, const complex &s) noexcept;
1875 INLINE cvector operator *(const complex &s, const cmatrix_subv &rv) noexcept;
1876
1877//======================== Vector / Vector ========================
1878
1880 INLINE rvector abs(const cmatrix_subv &mv) noexcept;
1882 INLINE rvector Im(const cmatrix_subv &mv) noexcept;
1884 INLINE rvector Re(const cmatrix_subv &mv) noexcept;
1886 INLINE cmatrix_subv &SetIm(cmatrix_subv &mv,const rvector &rv)
1887#if(CXSC_INDEX_CHECK)
1888;
1889#else
1890 noexcept;
1891#endif
1893 INLINE cmatrix_subv &SetRe(cmatrix_subv &mv,const rvector &rv)
1894#if(CXSC_INDEX_CHECK)
1895;
1896#else
1897 noexcept;
1898#endif
1900 INLINE cmatrix_subv &SetRe(cmatrix_subv &iv,const real &r) noexcept;
1902 INLINE cmatrix_subv &SetIm(cmatrix_subv &iv,const real &r) noexcept;
1903
1904
1906 void accumulate(cdotprecision &dp, const cmatrix_subv & rv1, const cmatrix_subv &rv2)
1907#if(CXSC_INDEX_CHECK)
1908;
1909#else
1910 noexcept;
1911#endif
1912
1914 void accumulate_approx(cdotprecision &dp, const cmatrix_subv & rv1, const cmatrix_subv &rv2);
1915
1917 void accumulate(cdotprecision &dp, const cvector & rv1, const cmatrix_subv &rv2)
1918#if(CXSC_INDEX_CHECK)
1919;
1920#else
1921 noexcept;
1922#endif
1923
1925 void accumulate_approx(cdotprecision &dp, const cvector & rv1, const cmatrix_subv &rv2);
1926
1928 void accumulate(cdotprecision &dp, const cmatrix_subv & rv1, const cvector &rv2)
1929#if(CXSC_INDEX_CHECK)
1930;
1931#else
1932 noexcept;
1933#endif
1934
1936 void accumulate_approx(cdotprecision &dp, const cmatrix_subv & rv1, const cvector &rv2);
1937
1939 void accumulate(cdotprecision &dp, const cvector_slice & sl1, const cmatrix_subv &rv2)
1940#if(CXSC_INDEX_CHECK)
1941;
1942#else
1943 noexcept;
1944#endif
1945
1947 void accumulate_approx(cdotprecision &dp, const cvector_slice & sl1, const cmatrix_subv &rv2);
1948
1950 void accumulate(cdotprecision &dp, const cmatrix_subv & rv1, const cvector_slice &sl2)
1951#if(CXSC_INDEX_CHECK)
1952;
1953#else
1954 noexcept;
1955#endif
1956
1958 void accumulate_approx(cdotprecision &dp, const cmatrix_subv & rv1, const cvector_slice &sl2);
1959
1960
1962 void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const cmatrix_subv &rv2)
1963#if(CXSC_INDEX_CHECK)
1964;
1965#else
1966 noexcept;
1967#endif
1969 void accumulate(cidotprecision &dp, const cvector & rv1, const cmatrix_subv &rv2)
1970#if(CXSC_INDEX_CHECK)
1971;
1972#else
1973 noexcept;
1974#endif
1976 void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const cvector &rv2)
1977#if(CXSC_INDEX_CHECK)
1978;
1979#else
1980 noexcept;
1981#endif
1983 void accumulate(cidotprecision &dp, const cvector_slice & sl1, const cmatrix_subv &rv2)
1984#if(CXSC_INDEX_CHECK)
1985;
1986#else
1987 noexcept;
1988#endif
1990 void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const cvector_slice &sl2)
1991#if(CXSC_INDEX_CHECK)
1992;
1993#else
1994 noexcept;
1995#endif
1996
1998 INLINE complex operator *(const cmatrix_subv & rv1, const cmatrix_subv &rv2)
1999#if(CXSC_INDEX_CHECK)
2000;
2001#else
2002 noexcept;
2003#endif
2005 INLINE complex operator *(const cvector & rv1, const cmatrix_subv &rv2)
2006#if(CXSC_INDEX_CHECK)
2007;
2008#else
2009 noexcept;
2010#endif
2012 INLINE complex operator *(const cmatrix_subv &rv1,const cvector &rv2)
2013#if(CXSC_INDEX_CHECK)
2014;
2015#else
2016 noexcept;
2017#endif
2019 INLINE complex operator *(const cvector_slice &sl,const cmatrix_subv &sv)
2020#if(CXSC_INDEX_CHECK)
2021;
2022#else
2023 noexcept;
2024#endif
2026 INLINE complex operator *(const cmatrix_subv &mv,const cvector_slice &vs)
2027#if(CXSC_INDEX_CHECK)
2028;
2029#else
2030 noexcept;
2031#endif
2032
2034 INLINE cvector operator +(const cmatrix_subv & rv1, const cmatrix_subv &rv2)
2035#if(CXSC_INDEX_CHECK)
2036;
2037#else
2038 noexcept;
2039#endif
2041 INLINE cvector operator +(const cmatrix_subv &rv1,const cvector &rv2)
2042#if(CXSC_INDEX_CHECK)
2043;
2044#else
2045 noexcept;
2046#endif
2048 INLINE cvector operator +(const cvector & rv1, const cmatrix_subv &rv2)
2049#if(CXSC_INDEX_CHECK)
2050;
2051#else
2052 noexcept;
2053#endif
2055 INLINE cvector operator +(const cvector_slice &sl,const cmatrix_subv &mv)
2056#if(CXSC_INDEX_CHECK)
2057;
2058#else
2059 noexcept;
2060#endif
2062 INLINE cvector operator +(const cmatrix_subv &mv,const cvector_slice &sl)
2063#if(CXSC_INDEX_CHECK)
2064;
2065#else
2066 noexcept;
2067#endif
2068
2070 INLINE cvector operator -(const cmatrix_subv & rv1, const cmatrix_subv &rv2)
2071#if(CXSC_INDEX_CHECK)
2072;
2073#else
2074 noexcept;
2075#endif
2077 INLINE cvector operator -(const cvector & rv1, const cmatrix_subv &rv2)
2078#if(CXSC_INDEX_CHECK)
2079;
2080#else
2081 noexcept;
2082#endif
2084 INLINE cvector operator -(const cmatrix_subv &rv1,const cvector &rv2)
2085#if(CXSC_INDEX_CHECK)
2086;
2087#else
2088 noexcept;
2089#endif
2091 INLINE cvector operator -(const cvector_slice &sl,const cmatrix_subv &mv)
2092#if(CXSC_INDEX_CHECK)
2093;
2094#else
2095 noexcept;
2096#endif
2098 INLINE cvector operator -(const cmatrix_subv &mv,const cvector_slice &sl)
2099#if(CXSC_INDEX_CHECK)
2100;
2101#else
2102 noexcept;
2103#endif
2104
2105//====================================================================
2106//===================== Matrix Functions =============================
2107
2109 INLINE cmatrix _cmatrix(const cmatrix &rm) noexcept;
2111 INLINE cmatrix _cmatrix(const cvector &v) noexcept;
2113 INLINE cmatrix _cmatrix(const cvector_slice &v) noexcept;
2115 INLINE cmatrix _cmatrix(const complex &r) noexcept;
2116
2118 INLINE int Lb(const cmatrix &rm, const int &i)
2119#if(CXSC_INDEX_CHECK)
2120;
2121#else
2122 noexcept;
2123#endif
2125 INLINE int Ub(const cmatrix &rm, const int &i)
2126#if(CXSC_INDEX_CHECK)
2127;
2128#else
2129 noexcept;
2130#endif
2132 INLINE int Lb(const cmatrix_slice &rm, const int &i)
2133#if(CXSC_INDEX_CHECK)
2134;
2135#else
2136 noexcept;
2137#endif
2139 INLINE int Ub(const cmatrix_slice &rm, const int &i)
2140#if(CXSC_INDEX_CHECK)
2141;
2142#else
2143 noexcept;
2144#endif
2146 INLINE cmatrix &SetLb(cmatrix &m, const int &i,const int &j)
2147#if(CXSC_INDEX_CHECK)
2148;
2149#else
2150 noexcept;
2151#endif
2153 INLINE cmatrix &SetUb(cmatrix &m, const int &i,const int &j)
2154#if(CXSC_INDEX_CHECK)
2155;
2156#else
2157 noexcept;
2158#endif
2160 INLINE void Resize(cmatrix &A) noexcept;
2162 INLINE void Resize(cmatrix &A,const int &m, const int &n)
2163#if(CXSC_INDEX_CHECK)
2164;
2165#else
2166 noexcept;
2167#endif
2169 INLINE void Resize(cmatrix &A,const int &m1, const int &m2,const int &n1,const int &n2)
2170#if(CXSC_INDEX_CHECK)
2171;
2172#else
2173 noexcept;
2174#endif
2175
2177 INLINE rmatrix abs(const cmatrix &m) noexcept;
2179 INLINE rmatrix abs(const cmatrix_slice &ms) noexcept;
2181 INLINE rmatrix Im(const cmatrix &m) noexcept;
2183 INLINE rmatrix Re(const cmatrix &m) noexcept;
2185 INLINE rmatrix Im(const cmatrix_slice &m) noexcept;
2187 INLINE rmatrix Re(const cmatrix_slice &m) noexcept;
2189 INLINE cmatrix &SetIm(cmatrix &cm,const rmatrix &rm)
2190#if(CXSC_INDEX_CHECK)
2191;
2192#else
2193 noexcept;
2194#endif
2196 INLINE cmatrix_slice &SetIm(cmatrix_slice &cm,const rmatrix &rm)
2197#if(CXSC_INDEX_CHECK)
2198;
2199#else
2200 noexcept;
2201#endif
2203 INLINE cmatrix &SetIm(cmatrix &cm,const rmatrix_slice &rm)
2204#if(CXSC_INDEX_CHECK)
2205;
2206#else
2207 noexcept;
2208#endif
2210 INLINE cmatrix_slice &SetIm(cmatrix_slice &cm,const rmatrix_slice &rm)
2211#if(CXSC_INDEX_CHECK)
2212;
2213#else
2214 noexcept;
2215#endif
2217 INLINE cmatrix &SetRe(cmatrix &cm,const rmatrix &rm)
2218#if(CXSC_INDEX_CHECK)
2219;
2220#else
2221 noexcept;
2222#endif
2224 INLINE cmatrix_slice &SetRe(cmatrix_slice &cm,const rmatrix &rm)
2225#if(CXSC_INDEX_CHECK)
2226;
2227#else
2228 noexcept;
2229#endif
2231 INLINE cmatrix &SetRe(cmatrix &cm,const rmatrix_slice &rm)
2232#if(CXSC_INDEX_CHECK)
2233;
2234#else
2235 noexcept;
2236#endif
2238 INLINE cmatrix_slice &SetRe(cmatrix_slice &cm,const rmatrix_slice &rm)
2239#if(CXSC_INDEX_CHECK)
2240;
2241#else
2242 noexcept;
2243#endif
2244
2245//===================== Matrix / Scalar ===============================
2246
2248 INLINE cmatrix operator *(const complex &c, const cmatrix &m) noexcept;
2250 INLINE cmatrix operator *(const complex &c, const cmatrix_slice &ms) noexcept;
2252 INLINE cmatrix operator *(const cmatrix &m,const complex &c) noexcept;
2254 INLINE cmatrix operator *(const cmatrix_slice &ms,const complex &c) noexcept;
2256 INLINE cmatrix &operator *=(cmatrix &m,const complex &c) noexcept;
2258 INLINE cmatrix operator /(const cmatrix &m,const complex &c) noexcept;
2260 INLINE cmatrix operator /(const cmatrix_slice &ms, const complex &c) noexcept;
2262 INLINE cmatrix &operator /=(cmatrix &m,const complex &c) noexcept;
2263
2264//------------ real - cmatrix -----------------------------------------------
2265
2267 INLINE cmatrix operator *(const real &c, const cmatrix &m) noexcept;
2269 INLINE cmatrix operator *(const real &c, const cmatrix_slice &ms) noexcept;
2271 INLINE cmatrix operator *(const cmatrix &m,const real &c) noexcept;
2273 INLINE cmatrix operator *(const cmatrix_slice &ms,const real &c) noexcept;
2275 INLINE cmatrix &operator *=(cmatrix &m,const real &c) noexcept;
2277 INLINE cmatrix operator /(const cmatrix &m,const real &c) noexcept;
2279 INLINE cmatrix operator /(const cmatrix_slice &ms, const real &c) noexcept;
2281 INLINE cmatrix &operator /=(cmatrix &m,const real &c) noexcept;
2282//----------------- rmatrix - complex ----------------
2283
2285 INLINE cmatrix operator *(const complex &c, const rmatrix &m) noexcept;
2287 INLINE cmatrix operator *(const complex &c, const rmatrix_slice &ms) noexcept;
2289 INLINE cmatrix operator *(const rmatrix &m,const complex &c) noexcept;
2291 INLINE cmatrix operator *(const rmatrix_slice &ms,const complex &c) noexcept;
2293 INLINE cmatrix operator /(const rmatrix &m,const complex &c) noexcept;
2295 INLINE cmatrix operator /(const rmatrix_slice &ms, const complex &c) noexcept;
2296
2297
2298//============================ Matrix / Vector ===================================
2299
2300
2302 INLINE cvector operator *(const cmatrix &m,const cvector &v)
2303#if(CXSC_INDEX_CHECK)
2304;
2305#else
2306 noexcept;
2307#endif
2309 INLINE cvector operator *(const cmatrix_slice &ms,const cvector &v)
2310#if(CXSC_INDEX_CHECK)
2311;
2312#else
2313 noexcept;
2314#endif
2316 INLINE cvector operator *(const cvector &v,const cmatrix &m)
2317#if(CXSC_INDEX_CHECK)
2318;
2319#else
2320 noexcept;
2321#endif
2323 INLINE cvector operator *(const cvector &v,const cmatrix_slice &ms)
2324#if(CXSC_INDEX_CHECK)
2325;
2326#else
2327 noexcept;
2328#endif
2330 INLINE cvector &operator *=(cvector &v,const cmatrix &m)
2331#if(CXSC_INDEX_CHECK)
2332;
2333#else
2334 noexcept;
2335#endif
2337 INLINE cvector &operator *=(cvector &v,const cmatrix_slice &ms)
2338#if(CXSC_INDEX_CHECK)
2339;
2340#else
2341 noexcept;
2342#endif
2343
2345 INLINE cvector operator *(const cvector_slice &v,const cmatrix &m)
2346#if(CXSC_INDEX_CHECK)
2347;
2348#else
2349 noexcept;
2350#endif
2352 INLINE cvector operator *(const cvector_slice &v,const cmatrix_slice &m)
2353#if(CXSC_INDEX_CHECK)
2354;
2355#else
2356 noexcept;
2357#endif
2358
2359//----------------- real -------------------------------------
2360
2362 INLINE cvector operator *(const rvector &v,const cmatrix &m)
2363#if(CXSC_INDEX_CHECK)
2364;
2365#else
2366 noexcept;
2367#endif
2369 INLINE cvector operator *(const rvector &v,const cmatrix_slice &ms)
2370#if(CXSC_INDEX_CHECK)
2371;
2372#else
2373 noexcept;
2374#endif
2376 INLINE cvector operator *(const rvector_slice &v,const cmatrix &m)
2377#if(CXSC_INDEX_CHECK)
2378;
2379#else
2380 noexcept;
2381#endif
2382
2384 INLINE cvector operator *(const cmatrix &m,const rvector &v)
2385#if(CXSC_INDEX_CHECK)
2386;
2387#else
2388 noexcept;
2389#endif
2391 INLINE cvector operator *(const cmatrix_slice &ms,const rvector &v)
2392#if(CXSC_INDEX_CHECK)
2393;
2394#else
2395 noexcept;
2396#endif
2397
2398
2399//================ Matrix / Matrix ============================
2400
2402 INLINE const cmatrix &operator +(const cmatrix &m1) noexcept;
2404 INLINE cmatrix operator +(const cmatrix_slice &ms) noexcept;
2406 INLINE cmatrix operator +(const cmatrix &m1,const cmatrix &m2)
2407#if(CXSC_INDEX_CHECK)
2408;
2409#else
2410 noexcept;
2411#endif
2413 INLINE cmatrix operator +(const cmatrix &m,const cmatrix_slice &ms)
2414#if(CXSC_INDEX_CHECK)
2415;
2416#else
2417 noexcept;
2418#endif
2420 INLINE cmatrix operator +(const cmatrix_slice &ms,const cmatrix &m)
2421#if(CXSC_INDEX_CHECK)
2422;
2423#else
2424 noexcept;
2425#endif
2427 INLINE cmatrix operator +(const cmatrix_slice &m1,const cmatrix_slice &m2)
2428#if(CXSC_INDEX_CHECK)
2429;
2430#else
2431 noexcept;
2432#endif
2434 INLINE cmatrix &operator +=(cmatrix &m1,const cmatrix &m2)
2435#if(CXSC_INDEX_CHECK)
2436;
2437#else
2438 noexcept;
2439#endif
2441 INLINE cmatrix &operator +=(cmatrix &m1,const cmatrix_slice &ms)
2442#if(CXSC_INDEX_CHECK)
2443;
2444#else
2445 noexcept;
2446#endif
2447
2449 INLINE cmatrix operator -(const cmatrix &m) noexcept;
2451 INLINE cmatrix operator -(const cmatrix_slice &ms) noexcept;
2453 INLINE cmatrix operator -(const cmatrix &m1,const cmatrix &m2)
2454#if(CXSC_INDEX_CHECK)
2455;
2456#else
2457 noexcept;
2458#endif
2460 INLINE cmatrix operator -(const cmatrix &m,const cmatrix_slice &ms)
2461#if(CXSC_INDEX_CHECK)
2462;
2463#else
2464 noexcept;
2465#endif
2467 INLINE cmatrix operator -(const cmatrix_slice &ms,const cmatrix &m)
2468#if(CXSC_INDEX_CHECK)
2469;
2470#else
2471 noexcept;
2472#endif
2474 INLINE cmatrix operator -(const cmatrix_slice &ms1,const cmatrix_slice &ms2)
2475#if(CXSC_INDEX_CHECK)
2476;
2477#else
2478 noexcept;
2479#endif
2481 INLINE cmatrix &operator -=(cmatrix &m1,const cmatrix &m2)
2482#if(CXSC_INDEX_CHECK)
2483;
2484#else
2485 noexcept;
2486#endif
2488 INLINE cmatrix &operator -=(cmatrix &m1,const cmatrix_slice &ms)
2489#if(CXSC_INDEX_CHECK)
2490;
2491#else
2492 noexcept;
2493#endif
2494
2496 INLINE cmatrix operator *(const cmatrix &m1, const cmatrix &m2)
2497#if(CXSC_INDEX_CHECK)
2498;
2499#else
2500 noexcept;
2501#endif
2503 INLINE cmatrix operator *(const cmatrix &m1, const cmatrix_slice &ms)
2504#if(CXSC_INDEX_CHECK)
2505;
2506#else
2507 noexcept;
2508#endif
2510 INLINE cmatrix operator *(const cmatrix_slice &ms, const cmatrix &m1)
2511#if(CXSC_INDEX_CHECK)
2512;
2513#else
2514 noexcept;
2515#endif
2517 INLINE cmatrix operator *(const cmatrix_slice &ms1, const cmatrix_slice &ms2)
2518#if(CXSC_INDEX_CHECK)
2519;
2520#else
2521 noexcept;
2522#endif
2524 INLINE cmatrix &operator *=(cmatrix &m1,const cmatrix &m2)
2525#if(CXSC_INDEX_CHECK)
2526;
2527#else
2528 noexcept;
2529#endif
2531 INLINE cmatrix &operator *=(cmatrix &m1,const cmatrix_slice &ms)
2532#if(CXSC_INDEX_CHECK)
2533;
2534#else
2535 noexcept;
2536#endif
2537
2538
2539 //---------- rmatrix-cmatrix ------------------
2541 INLINE cmatrix operator +(const rmatrix &m1,const cmatrix &m2)
2542#if(CXSC_INDEX_CHECK)
2543;
2544#else
2545 noexcept;
2546#endif
2548 INLINE cmatrix operator +(const cmatrix &m1,const rmatrix &m2)
2549#if(CXSC_INDEX_CHECK)
2550;
2551#else
2552 noexcept;
2553#endif
2555 INLINE cmatrix operator +(const rmatrix &m,const cmatrix_slice &ms)
2556#if(CXSC_INDEX_CHECK)
2557;
2558#else
2559 noexcept;
2560#endif
2562 INLINE cmatrix operator +(const cmatrix &m,const rmatrix_slice &ms)
2563#if(CXSC_INDEX_CHECK)
2564;
2565#else
2566 noexcept;
2567#endif
2569 INLINE cmatrix operator +(const rmatrix_slice &ms,const cmatrix &m)
2570#if(CXSC_INDEX_CHECK)
2571;
2572#else
2573 noexcept;
2574#endif
2576 INLINE cmatrix operator +(const cmatrix_slice &ms,const rmatrix &m)
2577#if(CXSC_INDEX_CHECK)
2578;
2579#else
2580 noexcept;
2581#endif
2583 INLINE cmatrix operator +(const rmatrix_slice &m1,const cmatrix_slice &m2)
2584#if(CXSC_INDEX_CHECK)
2585;
2586#else
2587 noexcept;
2588#endif
2590 INLINE cmatrix operator +(const cmatrix_slice &m1,const rmatrix_slice &m2)
2591#if(CXSC_INDEX_CHECK)
2592;
2593#else
2594 noexcept;
2595#endif
2597 INLINE cmatrix &operator +=(cmatrix &m1,const rmatrix &m2)
2598#if(CXSC_INDEX_CHECK)
2599;
2600#else
2601 noexcept;
2602#endif
2604 INLINE cmatrix &operator +=(cmatrix &m1,const rmatrix_slice &ms)
2605#if(CXSC_INDEX_CHECK)
2606;
2607#else
2608 noexcept;
2609#endif
2610
2612 INLINE cmatrix operator -(const rmatrix &m1,const cmatrix &m2)
2613#if(CXSC_INDEX_CHECK)
2614;
2615#else
2616 noexcept;
2617#endif
2619 INLINE cmatrix operator -(const cmatrix &m1,const rmatrix &m2)
2620#if(CXSC_INDEX_CHECK)
2621;
2622#else
2623 noexcept;
2624#endif
2626 INLINE cmatrix operator -(const rmatrix &m,const cmatrix_slice &ms)
2627#if(CXSC_INDEX_CHECK)
2628;
2629#else
2630 noexcept;
2631#endif
2633 INLINE cmatrix operator -(const cmatrix &m,const rmatrix_slice &ms)
2634#if(CXSC_INDEX_CHECK)
2635;
2636#else
2637 noexcept;
2638#endif
2640 INLINE cmatrix operator -(const rmatrix_slice &ms,const cmatrix &m)
2641#if(CXSC_INDEX_CHECK)
2642;
2643#else
2644 noexcept;
2645#endif
2647 INLINE cmatrix operator -(const cmatrix_slice &ms,const rmatrix &m)
2648#if(CXSC_INDEX_CHECK)
2649;
2650#else
2651 noexcept;
2652#endif
2654 INLINE cmatrix operator -(const rmatrix_slice &ms1,const cmatrix_slice &ms2)
2655#if(CXSC_INDEX_CHECK)
2656;
2657#else
2658 noexcept;
2659#endif
2661 INLINE cmatrix operator -(const cmatrix_slice &ms1,const rmatrix_slice &ms2)
2662#if(CXSC_INDEX_CHECK)
2663;
2664#else
2665 noexcept;
2666#endif
2668 INLINE cmatrix &operator -=(cmatrix &m1,const rmatrix &m2)
2669#if(CXSC_INDEX_CHECK)
2670;
2671#else
2672 noexcept;
2673#endif
2675 INLINE cmatrix &operator -=(cmatrix &m1,const rmatrix_slice &ms)
2676#if(CXSC_INDEX_CHECK)
2677;
2678#else
2679 noexcept;
2680#endif
2681
2683 INLINE cmatrix operator *(const rmatrix &m1, const cmatrix &m2)
2684#if(CXSC_INDEX_CHECK)
2685;
2686#else
2687 noexcept;
2688#endif
2690 INLINE cmatrix operator *(const cmatrix &m1, const rmatrix &m2)
2691#if(CXSC_INDEX_CHECK)
2692;
2693#else
2694 noexcept;
2695#endif
2697 INLINE cmatrix operator *(const rmatrix &m1, const cmatrix_slice &ms)
2698#if(CXSC_INDEX_CHECK)
2699;
2700#else
2701 noexcept;
2702#endif
2704 INLINE cmatrix operator *(const cmatrix &m1, const rmatrix_slice &ms)
2705#if(CXSC_INDEX_CHECK)
2706;
2707#else
2708 noexcept;
2709#endif
2711 INLINE cmatrix operator *(const rmatrix_slice &ms, const cmatrix &m1)
2712#if(CXSC_INDEX_CHECK)
2713;
2714#else
2715 noexcept;
2716#endif
2718 INLINE cmatrix operator *(const cmatrix_slice &ms, const rmatrix &m1)
2719#if(CXSC_INDEX_CHECK)
2720;
2721#else
2722 noexcept;
2723#endif
2725 INLINE cmatrix operator *(const rmatrix_slice &ms1, const cmatrix_slice &ms2)
2726#if(CXSC_INDEX_CHECK)
2727;
2728#else
2729 noexcept;
2730#endif
2732 INLINE cmatrix operator *(const cmatrix_slice &ms1, const rmatrix_slice &ms2)
2733#if(CXSC_INDEX_CHECK)
2734;
2735#else
2736 noexcept;
2737#endif
2739 INLINE cmatrix &operator *=(cmatrix &m1,const rmatrix &m2)
2740#if(CXSC_INDEX_CHECK)
2741;
2742#else
2743 noexcept;
2744#endif
2746 INLINE cmatrix &operator *=(cmatrix &m1,const rmatrix_slice &ms)
2747#if(CXSC_INDEX_CHECK)
2748;
2749#else
2750 noexcept;
2751#endif
2752
2753
2754//============== Compare Operator ==========================
2755
2756//-------------- Matrix - Matrix -------------------------
2757
2759 INLINE bool operator ==(const cmatrix &m1,const cmatrix &m2) noexcept;
2761 INLINE bool operator !=(const cmatrix &m1,const cmatrix &m2) noexcept;
2762/* INLINE bool operator <(const cmatrix &m1,const cmatrix &m2) noexcept;
2763 INLINE bool operator <=(const cmatrix &m1,const cmatrix &m2) noexcept;
2764 INLINE bool operator >(const cmatrix &m1,const cmatrix &m2) noexcept;
2765 INLINE bool operator >=(const cmatrix &m1,const cmatrix &m2) noexcept;*/
2767 INLINE bool operator ==(const cmatrix &m1,const cmatrix_slice &ms) noexcept;
2769 INLINE bool operator !=(const cmatrix &m1,const cmatrix_slice &ms) noexcept;
2770/* INLINE bool operator <(const cmatrix &m1,const cmatrix_slice &ms) noexcept;
2771 INLINE bool operator <=(const cmatrix &m1,const cmatrix_slice &ms) noexcept;
2772 INLINE bool operator >(const cmatrix &m1,const cmatrix_slice &ms) noexcept;
2773 INLINE bool operator >=(const cmatrix &m1,const cmatrix_slice &ms) noexcept;
2774*/
2775//---------------- Matrix - Matrix_slice ----------------------
2776
2778 INLINE bool operator ==(const cmatrix_slice &m1,const cmatrix_slice &m2) noexcept;
2780 INLINE bool operator !=(const cmatrix_slice &m1,const cmatrix_slice &m2) noexcept;
2781/* INLINE bool operator <(const cmatrix_slice &m1,const cmatrix_slice &m2) noexcept;
2782 INLINE bool operator <=(const cmatrix_slice &m1,const cmatrix_slice &m2) noexcept;
2783 INLINE bool operator >(const cmatrix_slice &m1,const cmatrix_slice &m2) noexcept;
2784 INLINE bool operator >=(const cmatrix_slice &m1,const cmatrix_slice &m2) noexcept;
2785*/
2786//=================== Not Operator =============================
2787
2789 INLINE bool operator !(const cmatrix &ms) noexcept;
2791 INLINE bool operator !(const cmatrix_slice &ms) noexcept;
2792
2793//======================== Input / Output ========================
2794
2796 INLINE std::ostream &operator <<(std::ostream &s,const cmatrix &r) noexcept;
2798 INLINE std::ostream &operator <<(std::ostream &s,const cmatrix_slice &r) noexcept;
2800 INLINE std::istream &operator >>(std::istream &s,cmatrix &r) noexcept;
2802 INLINE std::istream &operator >>(std::istream &s,cmatrix_slice &r) noexcept;
2803
2805 INLINE int RowLen ( const cmatrix& );
2807 INLINE int ColLen ( const cmatrix& );
2809 INLINE int RowLen ( const cmatrix_slice& );
2811 INLINE int ColLen ( const cmatrix_slice& );
2813 rmatrix CompMat ( const cmatrix& );
2815 cmatrix Id ( cmatrix& );
2817 cmatrix transp ( const cmatrix& );
2819 void DoubleSize ( cmatrix& );
2820
2821} // namespace cxsc
2822
2823
2824#ifdef _CXSC_INCL_INL
2825#include "matrix.inl"
2826#include "cmatrix.inl"
2827#endif
2828
2829#ifdef _CXSC_CIVECTOR_HPP_INCLUDED
2830# ifdef _CXSC_INCL_INL
2831# include "civeccmat.inl"
2832# else
2833# include "civeccmat.hpp"
2834# endif
2835#endif
2836
2837#ifdef _CXSC_IVECTOR_HPP_INCLUDED
2838# ifdef _CXSC_INCL_INL
2839# include "iveccmat.inl"
2840# else
2841# include "iveccmat.hpp"
2842# endif
2843#endif
2844
2845#ifdef _CXSC_IMATRIX_HPP_INCLUDED
2846# ifdef _CXSC_INCL_INL
2847# include "cmatimat.inl"
2848# else
2849# include "cmatimat.hpp"
2850# endif
2851#endif
2852
2853
2854#ifdef CXSC_USE_BLAS
2855#define _CXSC_BLAS_CMATRIX
2856#include "cxsc_blas.inl"
2857#endif
2858
2859#endif
The Data Type cdotprecision.
Definition cdot.hpp:61
The Data Type cidotprecision.
Definition cidot.hpp:58
The Data Type cimatrix.
Definition cimatrix.hpp:908
The Data Type civector.
Definition civector.hpp:57
The Data Type cmatrix_slice.
Definition cmatrix.hpp:1203
cmatrix_slice & operator=(const cmatrix &m) noexcept
Implementation of standard assigning operator.
Definition cmatrix.inl:450
cmatrix_slice & operator-=(const srmatrix &m)
Implementation of addition and assignment operator.
cmatrix_slice(const cmatrix_slice &ms) noexcept
Constructor of class cmatrix_slice.
Definition cmatrix.hpp:1584
cmatrix_subv operator[](const int &i) noexcept
Operator for accessing a single row of the matrix.
Definition cmatrix.inl:300
cmatrix_slice(cmatrix_slice &a, const int &l1, const int &u1, const int &l2, const int &u2) noexcept
Constructor of class cmatrix_slice.
Definition cmatrix.hpp:1581
cmatrix_slice & operator/=(const complex &c) noexcept
Implementation of division and allocation operation.
Definition cmatrix.inl:890
cmatrix_slice & operator*=(const srmatrix &m)
Implementation of addition and assignment operator.
cmatrix_slice & operator()() noexcept
Operator for accessing the whole matrix.
Definition cmatrix.hpp:1698
cmatrix_slice(cmatrix &a, const int &l1, const int &u1, const int &l2, const int &u2) noexcept
Constructor of class cmatrix_slice.
Definition cmatrix.hpp:1579
cmatrix_slice & operator+=(const srmatrix &m)
Implementation of addition and assignment operator.
cmatrix_slice & operator|=(const cmatrix &m1) noexcept
Allocates the convex hull of the arguments to the first argument.
The Data Type cmatrix_subv.
Definition cmatrix.hpp:54
friend int VecLen(const cmatrix_subv &rv) noexcept
Returns the size of the vector.
Definition cmatrix.hpp:270
friend int Lb(const cmatrix_subv &rv) noexcept
Returns the lower bound of the vector.
Definition cmatrix.hpp:266
cmatrix_subv(complex *d, const int &l, const int &u, const int &s, const int &st, const int &o) noexcept
Constructor of class cmatrix_subv.
Definition cmatrix.hpp:258
cmatrix_subv & operator=(const scmatrix_subv &rv)
Implementation of standard assigning operator.
cmatrix_subv & operator/=(const complex &c) noexcept
Implementation of division and allocation operation.
Definition cmatrix.inl:515
cmatrix_subv(const cmatrix_subv &v) noexcept
Constructor of class cmatrix_subv.
Definition cmatrix.hpp:261
cmatrix_subv & operator-=(const scmatrix_subv &rv)
Implementation of standard assigning operator.
cmatrix_subv & operator+=(const scmatrix_subv &rv)
Implementation of standard assigning operator.
complex & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector (read-only)
Definition cmatrix.inl:195
cmatrix_subv & operator*=(const complex &c) noexcept
Implementation of multiplication and allocation operation.
Definition cmatrix.inl:512
cmatrix_subv & operator()() noexcept
Operator for accessing the whole vector.
Definition cmatrix.hpp:289
friend int Ub(const cmatrix_subv &rv) noexcept
Returns the upper bound of the vector.
Definition cmatrix.hpp:268
friend cmatrix_subv Col(cmatrix &m, const int &i) noexcept
Returns one column of the matrix as a vector.
Definition cmatrix.inl:162
friend cmatrix_subv Row(cmatrix &m, const int &i) noexcept
Returns one row of the matrix as a vector.
Definition cmatrix.inl:151
The Data Type cmatrix.
Definition cmatrix.hpp:514
cmatrix() noexcept
Constructor of class cmatrix.
Definition cmatrix.inl:31
cmatrix & operator()() noexcept
Operator for accessing the whole matrix.
Definition cmatrix.hpp:1175
cmatrix & operator+=(const srmatrix &m)
Implementation of addition and assignment operator.
cmatrix & operator*=(const srmatrix &m)
Implementation of addition and assignment operator.
cmatrix & operator-=(const srmatrix &m)
Implementation of addition and assignment operator.
cmatrix_subv operator[](const int &i) const noexcept
Operator for accessing a single row of the matrix.
Definition cmatrix.inl:222
cmatrix & operator=(const complex &r) noexcept
Implementation of standard assigning operator.
Definition cmatrix.inl:438
The Scalar Type complex.
Definition complex.hpp:50
The Data Type cvector_slice.
Definition cvector.hpp:845
The Data Type cvector.
Definition cvector.hpp:58
cvector() noexcept
Constructor of class cvector.
Definition cvector.inl:31
The Data Type intmatrix.
The Data Type intvector.
Definition intvector.hpp:52
The Scalar Type real.
Definition real.hpp:114
The Data Type rmatrix_slice.
Definition rmatrix.hpp:1443
The Data Type rmatrix_subv.
Definition rmatrix.hpp:54
The Data Type rmatrix.
Definition rmatrix.hpp:471
The Data Type rvector_slice.
Definition rvector.hpp:1064
The Data Type rvector.
Definition rvector.hpp:58
A slice of a sparse complex matrix.
Represents a row or column vector of a sparse matrix.
A sparse complex matrix.
Definition scmatrix.hpp:69
Helper class for slices of sparse vectors.
A sparse complex vector.
Definition scvector.hpp:58
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
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
cmatrix _cmatrix(const cmatrix &rm) noexcept
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC.
Definition cmatrix.inl:708
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.