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 
37 namespace cxsc {
38 
39 class cmatrix;
40 class cmatrix_slice;
41 class srmatrix;
42 class srmatrix_slice;
43 class srmatrix_subv;
44 class scmatrix;
45 class scmatrix_slice;
46 class 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
72  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
85  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 ---------------------------------------
95 template <class MV1,class MV2> friend MV1 &_mvmvassign(MV1 &v,const MV2 &rv)
96 #if(CXSC_INDEX_CHECK)
97 ;
98 #else
99  noexcept;
100 #endif
101 template <class MV,class S> friend MV &_mvsassign(MV &v,const S &r) noexcept;
102 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
103 #if(CXSC_INDEX_CHECK)
104 ;
105 #else
106  noexcept;
107 #endif
108 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) noexcept;
109 template <class MV,class V> friend V _mvabs(const MV &mv) noexcept;
110 template <class MV,class V> friend V _mvim(const MV &mv) noexcept;
111 template <class MV,class V> friend V _mvre(const MV &mv) noexcept;
112 template <class MV,class V> friend MV &_mvvsetim(MV &v,const V &rv)
113 #if(CXSC_INDEX_CHECK)
114 ;
115 #else
116  noexcept;
117 #endif
118 template <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;
126 template <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
132 template <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;
195 template <class MV,class S> friend MV &_mvsmultassign(MV &v,const S &r) noexcept;
196 template <class MV, class S> friend MV &_mvsplusassign(MV &v,const S &r) noexcept;
197 template <class MV,class S> friend MV &_mvsminusassign(MV &v,const S &r) noexcept;
198 template <class MV,class S> friend MV &_mvsdivassign(MV &v,const S &r) noexcept;
199 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
200 #if(CXSC_INDEX_CHECK)
201 ;
202 #else
203  noexcept;
204 #endif
205 template <class V,class MV> friend V &_vmvplusassign(V &rv,const MV &v)
206 #if(CXSC_INDEX_CHECK)
207 ;
208 #else
209  noexcept;
210 #endif
211 template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv)
212 #if(CXSC_INDEX_CHECK)
213 ;
214 #else
215  noexcept;
216 #endif
217 template <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 
228 template <class V,class MV> friend V &_vmvsetinf(V &rv,const MV &v)
229 #if(CXSC_INDEX_CHECK)
230 ;
231 #else
232  noexcept;
233 #endif
234 template <class V,class MV> friend V &_vmvsetsup(V &rv,const MV &v)
235 #if(CXSC_INDEX_CHECK)
236 ;
237 #else
238  noexcept;
239 #endif
240 template <class V,class MV> friend V &_vmvusetinf(V &rv,const MV &v)
241 #if(CXSC_INDEX_CHECK)
242 ;
243 #else
244  noexcept;
245 #endif
246 template <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
297  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
329  INLINE cmatrix_subv &operator =(const cmatrix_slice &m)
331 #if(CXSC_INDEX_CHECK)
332 ;
333 #else
334  noexcept;
335 #endif
336  INLINE cmatrix_subv &operator =(const cvector &v)
338 #if(CXSC_INDEX_CHECK)
339 ;
340 #else
341  noexcept;
342 #endif
343  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);
367  INLINE cmatrix_subv &operator -=(const scvector &r);
371  INLINE cmatrix_subv &operator -=(const srmatrix_subv &rv);
373  INLINE cmatrix_subv &operator -=(const srvector &r);
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
392  INLINE cmatrix_subv &operator +=(const cvector &rv)
394 #if(CXSC_INDEX_CHECK)
395 ;
396 #else
397  noexcept;
398 #endif
399  INLINE cmatrix_subv &operator -=(const cvector_slice &rv)
401 #if(CXSC_INDEX_CHECK)
402 ;
403 #else
404  noexcept;
405 #endif
406  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
425  INLINE cmatrix_subv &operator =(const rmatrix_slice &m)
427 #if(CXSC_INDEX_CHECK)
428 ;
429 #else
430  noexcept;
431 #endif
432  INLINE cmatrix_subv &operator =(const rvector &v)
434 #if(CXSC_INDEX_CHECK)
435 ;
436 #else
437  noexcept;
438 #endif
439  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
462  INLINE cmatrix_subv &operator +=(const rvector &rv)
464 #if(CXSC_INDEX_CHECK)
465 ;
466 #else
467  noexcept;
468 #endif
469  INLINE cmatrix_subv &operator -=(const rvector_slice &rv)
471 #if(CXSC_INDEX_CHECK)
472 ;
473 #else
474  noexcept;
475 #endif
476  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 
489 INLINE cmatrix_subv Row(cmatrix &m,const int &i)
490 #if(CXSC_INDEX_CHECK)
491 ;
492 #else
493  noexcept;
494 #endif
495 INLINE 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 
507 class cmatrix_slice;
508 
510 
513 class cmatrix
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 ---------------------------------------
527 template <class S,class M> friend void _smconstr(S &s,const M &m)
528 #if(CXSC_INDEX_CHECK)
529 ;
530 #else
531  noexcept;
532 #endif
533 template <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;
548 template <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
554 template <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
1046  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
1053  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
1153  INLINE cmatrix_subv operator [](const cxscmatrix_column &i) const
1155 #if(CXSC_INDEX_CHECK)
1156 ;
1157 #else
1158  noexcept;
1159 #endif
1160  INLINE cmatrix_subv operator [](const int &i)
1162 #if(CXSC_INDEX_CHECK)
1163 ;
1164 #else
1165  noexcept;
1166 #endif
1167  INLINE cmatrix_subv operator [](const cxscmatrix_column &i)
1169 #if(CXSC_INDEX_CHECK)
1170 ;
1171 #else
1172  noexcept;
1173 #endif
1174  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
1183  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 ---------------------------------------
1215 template <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
1622  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
1631  INLINE cmatrix_slice &operator =(const cvector_slice &v)
1633 #if(CXSC_INDEX_CHECK)
1634 ;
1635 #else
1636  noexcept;
1637 #endif
1638  INLINE cmatrix_slice &operator =(const rmatrix &m)
1640 #if(CXSC_INDEX_CHECK)
1641 ;
1642 #else
1643  noexcept;
1644 #endif
1645  INLINE cmatrix_slice &operator =(const rmatrix_slice &ms)
1647 #if(CXSC_INDEX_CHECK)
1648 ;
1649 #else
1650  noexcept;
1651 #endif
1652  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
1661  INLINE cmatrix_slice &operator =(const rvector_slice &v)
1663 #if(CXSC_INDEX_CHECK)
1664 ;
1665 #else
1666  noexcept;
1667 #endif
1668  INLINE cmatrix_subv operator [](const int &i)
1670 #if(CXSC_INDEX_CHECK)
1671 ;
1672 #else
1673  noexcept;
1674 #endif
1675  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
1690  INLINE cmatrix_subv operator [](const cxscmatrix_column &i) const
1692 #if(CXSC_INDEX_CHECK)
1693 ;
1694 #else
1695  noexcept;
1696 #endif
1697  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
1706  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
1747  INLINE cmatrix_slice &operator *=(const rmatrix &m)
1749 #if(CXSC_INDEX_CHECK)
1750 ;
1751 #else
1752  noexcept;
1753 #endif
1754  INLINE cmatrix_slice &operator *=(const cmatrix_slice &ms2)
1756 #if(CXSC_INDEX_CHECK)
1757 ;
1758 #else
1759  noexcept;
1760 #endif
1761  INLINE cmatrix_slice &operator *=(const rmatrix_slice &ms2)
1763 #if(CXSC_INDEX_CHECK)
1764 ;
1765 #else
1766  noexcept;
1767 #endif
1768  INLINE cmatrix_slice &operator +=(const cmatrix &m1)
1770 #if(CXSC_INDEX_CHECK)
1771 ;
1772 #else
1773  noexcept;
1774 #endif
1775  INLINE cmatrix_slice &operator +=(const rmatrix &m1)
1777 #if(CXSC_INDEX_CHECK)
1778 ;
1779 #else
1780  noexcept;
1781 #endif
1782  INLINE cmatrix_slice &operator +=(const cmatrix_slice &ms2)
1784 #if(CXSC_INDEX_CHECK)
1785 ;
1786 #else
1787  noexcept;
1788 #endif
1789  INLINE cmatrix_slice &operator +=(const rmatrix_slice &ms2)
1791 #if(CXSC_INDEX_CHECK)
1792 ;
1793 #else
1794  noexcept;
1795 #endif
1796  INLINE cmatrix_slice &operator -=(const cmatrix &m1)
1798 #if(CXSC_INDEX_CHECK)
1799 ;
1800 #else
1801  noexcept;
1802 #endif
1803  INLINE cmatrix_slice &operator -=(const rmatrix &m1)
1805 #if(CXSC_INDEX_CHECK)
1806 ;
1807 #else
1808  noexcept;
1809 #endif
1810  INLINE cmatrix_slice &operator -=(const cmatrix_slice &ms2)
1812 #if(CXSC_INDEX_CHECK)
1813 ;
1814 #else
1815  noexcept;
1816 #endif
1817  INLINE cmatrix_slice &operator -=(const rmatrix_slice &ms2)
1819 #if(CXSC_INDEX_CHECK)
1820 ;
1821 #else
1822  noexcept;
1823 #endif
1824  INLINE cmatrix_slice &operator |=(const cmatrix &m1)
1826 #if(CXSC_INDEX_CHECK)
1827 ;
1828 #else
1829  noexcept;
1830 #endif
1831  INLINE cmatrix_slice &operator |=(const rmatrix &m1)
1833 #if(CXSC_INDEX_CHECK)
1834 ;
1835 #else
1836  noexcept;
1837 #endif
1838  INLINE cmatrix_slice &operator |=(const cmatrix_slice &ms2)
1840 #if(CXSC_INDEX_CHECK)
1841 ;
1842 #else
1843  noexcept;
1844 #endif
1845  INLINE cmatrix_slice &operator |=(const rmatrix_slice &ms2)
1847 #if(CXSC_INDEX_CHECK)
1848 ;
1849 #else
1850  noexcept;
1851 #endif
1852  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
1892  INLINE cmatrix_subv &SetRe(cmatrix_subv &mv,const rvector &rv)
1894 #if(CXSC_INDEX_CHECK)
1895 ;
1896 #else
1897  noexcept;
1898 #endif
1899  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
1968  void accumulate(cidotprecision &dp, const cvector & rv1, const cmatrix_subv &rv2)
1970 #if(CXSC_INDEX_CHECK)
1971 ;
1972 #else
1973  noexcept;
1974 #endif
1975  void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const cvector &rv2)
1977 #if(CXSC_INDEX_CHECK)
1978 ;
1979 #else
1980  noexcept;
1981 #endif
1982  void accumulate(cidotprecision &dp, const cvector_slice & sl1, const cmatrix_subv &rv2)
1984 #if(CXSC_INDEX_CHECK)
1985 ;
1986 #else
1987  noexcept;
1988 #endif
1989  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
2004  INLINE complex operator *(const cvector & rv1, const cmatrix_subv &rv2)
2006 #if(CXSC_INDEX_CHECK)
2007 ;
2008 #else
2009  noexcept;
2010 #endif
2011  INLINE complex operator *(const cmatrix_subv &rv1,const cvector &rv2)
2013 #if(CXSC_INDEX_CHECK)
2014 ;
2015 #else
2016  noexcept;
2017 #endif
2018  INLINE complex operator *(const cvector_slice &sl,const cmatrix_subv &sv)
2020 #if(CXSC_INDEX_CHECK)
2021 ;
2022 #else
2023  noexcept;
2024 #endif
2025  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
2040  INLINE cvector operator +(const cmatrix_subv &rv1,const cvector &rv2)
2042 #if(CXSC_INDEX_CHECK)
2043 ;
2044 #else
2045  noexcept;
2046 #endif
2047  INLINE cvector operator +(const cvector & rv1, const cmatrix_subv &rv2)
2049 #if(CXSC_INDEX_CHECK)
2050 ;
2051 #else
2052  noexcept;
2053 #endif
2054  INLINE cvector operator +(const cvector_slice &sl,const cmatrix_subv &mv)
2056 #if(CXSC_INDEX_CHECK)
2057 ;
2058 #else
2059  noexcept;
2060 #endif
2061  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
2076  INLINE cvector operator -(const cvector & rv1, const cmatrix_subv &rv2)
2078 #if(CXSC_INDEX_CHECK)
2079 ;
2080 #else
2081  noexcept;
2082 #endif
2083  INLINE cvector operator -(const cmatrix_subv &rv1,const cvector &rv2)
2085 #if(CXSC_INDEX_CHECK)
2086 ;
2087 #else
2088  noexcept;
2089 #endif
2090  INLINE cvector operator -(const cvector_slice &sl,const cmatrix_subv &mv)
2092 #if(CXSC_INDEX_CHECK)
2093 ;
2094 #else
2095  noexcept;
2096 #endif
2097  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
2124  INLINE int Ub(const cmatrix &rm, const int &i)
2126 #if(CXSC_INDEX_CHECK)
2127 ;
2128 #else
2129  noexcept;
2130 #endif
2131  INLINE int Lb(const cmatrix_slice &rm, const int &i)
2133 #if(CXSC_INDEX_CHECK)
2134 ;
2135 #else
2136  noexcept;
2137 #endif
2138  INLINE int Ub(const cmatrix_slice &rm, const int &i)
2140 #if(CXSC_INDEX_CHECK)
2141 ;
2142 #else
2143  noexcept;
2144 #endif
2145  INLINE cmatrix &SetLb(cmatrix &m, const int &i,const int &j)
2147 #if(CXSC_INDEX_CHECK)
2148 ;
2149 #else
2150  noexcept;
2151 #endif
2152  INLINE cmatrix &SetUb(cmatrix &m, const int &i,const int &j)
2154 #if(CXSC_INDEX_CHECK)
2155 ;
2156 #else
2157  noexcept;
2158 #endif
2159  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
2168  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
2195  INLINE cmatrix_slice &SetIm(cmatrix_slice &cm,const rmatrix &rm)
2197 #if(CXSC_INDEX_CHECK)
2198 ;
2199 #else
2200  noexcept;
2201 #endif
2202  INLINE cmatrix &SetIm(cmatrix &cm,const rmatrix_slice &rm)
2204 #if(CXSC_INDEX_CHECK)
2205 ;
2206 #else
2207  noexcept;
2208 #endif
2209  INLINE cmatrix_slice &SetIm(cmatrix_slice &cm,const rmatrix_slice &rm)
2211 #if(CXSC_INDEX_CHECK)
2212 ;
2213 #else
2214  noexcept;
2215 #endif
2216  INLINE cmatrix &SetRe(cmatrix &cm,const rmatrix &rm)
2218 #if(CXSC_INDEX_CHECK)
2219 ;
2220 #else
2221  noexcept;
2222 #endif
2223  INLINE cmatrix_slice &SetRe(cmatrix_slice &cm,const rmatrix &rm)
2225 #if(CXSC_INDEX_CHECK)
2226 ;
2227 #else
2228  noexcept;
2229 #endif
2230  INLINE cmatrix &SetRe(cmatrix &cm,const rmatrix_slice &rm)
2232 #if(CXSC_INDEX_CHECK)
2233 ;
2234 #else
2235  noexcept;
2236 #endif
2237  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
2308  INLINE cvector operator *(const cmatrix_slice &ms,const cvector &v)
2310 #if(CXSC_INDEX_CHECK)
2311 ;
2312 #else
2313  noexcept;
2314 #endif
2315  INLINE cvector operator *(const cvector &v,const cmatrix &m)
2317 #if(CXSC_INDEX_CHECK)
2318 ;
2319 #else
2320  noexcept;
2321 #endif
2322  INLINE cvector operator *(const cvector &v,const cmatrix_slice &ms)
2324 #if(CXSC_INDEX_CHECK)
2325 ;
2326 #else
2327  noexcept;
2328 #endif
2329  INLINE cvector &operator *=(cvector &v,const cmatrix &m)
2331 #if(CXSC_INDEX_CHECK)
2332 ;
2333 #else
2334  noexcept;
2335 #endif
2336  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
2351  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
2368  INLINE cvector operator *(const rvector &v,const cmatrix_slice &ms)
2370 #if(CXSC_INDEX_CHECK)
2371 ;
2372 #else
2373  noexcept;
2374 #endif
2375  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
2390  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
2412  INLINE cmatrix operator +(const cmatrix &m,const cmatrix_slice &ms)
2414 #if(CXSC_INDEX_CHECK)
2415 ;
2416 #else
2417  noexcept;
2418 #endif
2419  INLINE cmatrix operator +(const cmatrix_slice &ms,const cmatrix &m)
2421 #if(CXSC_INDEX_CHECK)
2422 ;
2423 #else
2424  noexcept;
2425 #endif
2426  INLINE cmatrix operator +(const cmatrix_slice &m1,const cmatrix_slice &m2)
2428 #if(CXSC_INDEX_CHECK)
2429 ;
2430 #else
2431  noexcept;
2432 #endif
2433  INLINE cmatrix &operator +=(cmatrix &m1,const cmatrix &m2)
2435 #if(CXSC_INDEX_CHECK)
2436 ;
2437 #else
2438  noexcept;
2439 #endif
2440  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
2459  INLINE cmatrix operator -(const cmatrix &m,const cmatrix_slice &ms)
2461 #if(CXSC_INDEX_CHECK)
2462 ;
2463 #else
2464  noexcept;
2465 #endif
2466  INLINE cmatrix operator -(const cmatrix_slice &ms,const cmatrix &m)
2468 #if(CXSC_INDEX_CHECK)
2469 ;
2470 #else
2471  noexcept;
2472 #endif
2473  INLINE cmatrix operator -(const cmatrix_slice &ms1,const cmatrix_slice &ms2)
2475 #if(CXSC_INDEX_CHECK)
2476 ;
2477 #else
2478  noexcept;
2479 #endif
2480  INLINE cmatrix &operator -=(cmatrix &m1,const cmatrix &m2)
2482 #if(CXSC_INDEX_CHECK)
2483 ;
2484 #else
2485  noexcept;
2486 #endif
2487  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
2502  INLINE cmatrix operator *(const cmatrix &m1, const cmatrix_slice &ms)
2504 #if(CXSC_INDEX_CHECK)
2505 ;
2506 #else
2507  noexcept;
2508 #endif
2509  INLINE cmatrix operator *(const cmatrix_slice &ms, const cmatrix &m1)
2511 #if(CXSC_INDEX_CHECK)
2512 ;
2513 #else
2514  noexcept;
2515 #endif
2516  INLINE cmatrix operator *(const cmatrix_slice &ms1, const cmatrix_slice &ms2)
2518 #if(CXSC_INDEX_CHECK)
2519 ;
2520 #else
2521  noexcept;
2522 #endif
2523  INLINE cmatrix &operator *=(cmatrix &m1,const cmatrix &m2)
2525 #if(CXSC_INDEX_CHECK)
2526 ;
2527 #else
2528  noexcept;
2529 #endif
2530  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
2547  INLINE cmatrix operator +(const cmatrix &m1,const rmatrix &m2)
2549 #if(CXSC_INDEX_CHECK)
2550 ;
2551 #else
2552  noexcept;
2553 #endif
2554  INLINE cmatrix operator +(const rmatrix &m,const cmatrix_slice &ms)
2556 #if(CXSC_INDEX_CHECK)
2557 ;
2558 #else
2559  noexcept;
2560 #endif
2561  INLINE cmatrix operator +(const cmatrix &m,const rmatrix_slice &ms)
2563 #if(CXSC_INDEX_CHECK)
2564 ;
2565 #else
2566  noexcept;
2567 #endif
2568  INLINE cmatrix operator +(const rmatrix_slice &ms,const cmatrix &m)
2570 #if(CXSC_INDEX_CHECK)
2571 ;
2572 #else
2573  noexcept;
2574 #endif
2575  INLINE cmatrix operator +(const cmatrix_slice &ms,const rmatrix &m)
2577 #if(CXSC_INDEX_CHECK)
2578 ;
2579 #else
2580  noexcept;
2581 #endif
2582  INLINE cmatrix operator +(const rmatrix_slice &m1,const cmatrix_slice &m2)
2584 #if(CXSC_INDEX_CHECK)
2585 ;
2586 #else
2587  noexcept;
2588 #endif
2589  INLINE cmatrix operator +(const cmatrix_slice &m1,const rmatrix_slice &m2)
2591 #if(CXSC_INDEX_CHECK)
2592 ;
2593 #else
2594  noexcept;
2595 #endif
2596  INLINE cmatrix &operator +=(cmatrix &m1,const rmatrix &m2)
2598 #if(CXSC_INDEX_CHECK)
2599 ;
2600 #else
2601  noexcept;
2602 #endif
2603  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
2618  INLINE cmatrix operator -(const cmatrix &m1,const rmatrix &m2)
2620 #if(CXSC_INDEX_CHECK)
2621 ;
2622 #else
2623  noexcept;
2624 #endif
2625  INLINE cmatrix operator -(const rmatrix &m,const cmatrix_slice &ms)
2627 #if(CXSC_INDEX_CHECK)
2628 ;
2629 #else
2630  noexcept;
2631 #endif
2632  INLINE cmatrix operator -(const cmatrix &m,const rmatrix_slice &ms)
2634 #if(CXSC_INDEX_CHECK)
2635 ;
2636 #else
2637  noexcept;
2638 #endif
2639  INLINE cmatrix operator -(const rmatrix_slice &ms,const cmatrix &m)
2641 #if(CXSC_INDEX_CHECK)
2642 ;
2643 #else
2644  noexcept;
2645 #endif
2646  INLINE cmatrix operator -(const cmatrix_slice &ms,const rmatrix &m)
2648 #if(CXSC_INDEX_CHECK)
2649 ;
2650 #else
2651  noexcept;
2652 #endif
2653  INLINE cmatrix operator -(const rmatrix_slice &ms1,const cmatrix_slice &ms2)
2655 #if(CXSC_INDEX_CHECK)
2656 ;
2657 #else
2658  noexcept;
2659 #endif
2660  INLINE cmatrix operator -(const cmatrix_slice &ms1,const rmatrix_slice &ms2)
2662 #if(CXSC_INDEX_CHECK)
2663 ;
2664 #else
2665  noexcept;
2666 #endif
2667  INLINE cmatrix &operator -=(cmatrix &m1,const rmatrix &m2)
2669 #if(CXSC_INDEX_CHECK)
2670 ;
2671 #else
2672  noexcept;
2673 #endif
2674  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
2689  INLINE cmatrix operator *(const cmatrix &m1, const rmatrix &m2)
2691 #if(CXSC_INDEX_CHECK)
2692 ;
2693 #else
2694  noexcept;
2695 #endif
2696  INLINE cmatrix operator *(const rmatrix &m1, const cmatrix_slice &ms)
2698 #if(CXSC_INDEX_CHECK)
2699 ;
2700 #else
2701  noexcept;
2702 #endif
2703  INLINE cmatrix operator *(const cmatrix &m1, const rmatrix_slice &ms)
2705 #if(CXSC_INDEX_CHECK)
2706 ;
2707 #else
2708  noexcept;
2709 #endif
2710  INLINE cmatrix operator *(const rmatrix_slice &ms, const cmatrix &m1)
2712 #if(CXSC_INDEX_CHECK)
2713 ;
2714 #else
2715  noexcept;
2716 #endif
2717  INLINE cmatrix operator *(const cmatrix_slice &ms, const rmatrix &m1)
2719 #if(CXSC_INDEX_CHECK)
2720 ;
2721 #else
2722  noexcept;
2723 #endif
2724  INLINE cmatrix operator *(const rmatrix_slice &ms1, const cmatrix_slice &ms2)
2726 #if(CXSC_INDEX_CHECK)
2727 ;
2728 #else
2729  noexcept;
2730 #endif
2731  INLINE cmatrix operator *(const cmatrix_slice &ms1, const rmatrix_slice &ms2)
2733 #if(CXSC_INDEX_CHECK)
2734 ;
2735 #else
2736  noexcept;
2737 #endif
2738  INLINE cmatrix &operator *=(cmatrix &m1,const rmatrix &m2)
2740 #if(CXSC_INDEX_CHECK)
2741 ;
2742 #else
2743  noexcept;
2744 #endif
2745  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
cxsc::cmatrix::operator()
cmatrix & operator()() noexcept
Operator for accessing the whole matrix.
Definition: cmatrix.hpp:1175
cxsc::cmatrix::operator+=
cmatrix & operator+=(const srmatrix &m)
Implementation of addition and assignment operator.
Definition: scmatrix.hpp:1728
cxsc::srvector
A sparse real vector.
Definition: srvector.hpp:58
cxsc::scvector
A sparse complex vector.
Definition: scvector.hpp:58
cxsc::cmatrix_subv::VecLen
friend int VecLen(const cmatrix_subv &rv) noexcept
Returns the size of the vector.
Definition: cmatrix.hpp:270
cxsc::cmatrix_subv::Row
friend cmatrix_subv Row(cmatrix &m, const int &i) noexcept
Returns one row of the matrix as a vector.
Definition: cmatrix.inl:151
cxsc::CompMat
rmatrix CompMat(const cimatrix &A)
Returns Ostrowski's comparison matrix.
Definition: cimatrix.cpp:45
cxsc::srmatrix_subv
Represents a row or column vector of a sparse matrix.
Definition: srmatrix.hpp:2157
cxsc::cmatrix_slice::operator/=
cmatrix_slice & operator/=(const complex &c) noexcept
Implementation of division and allocation operation.
Definition: cmatrix.inl:890
cxsc::cmatrix_subv::operator+=
cmatrix_subv & operator+=(const scmatrix_subv &rv)
Implementation of standard assigning operator.
Definition: scmatrix.hpp:4326
cxsc::cmatrix
The Data Type cmatrix.
Definition: cmatrix.hpp:514
cxsc::cmatrix::operator[]
cmatrix_subv operator[](const int &i) const noexcept
Operator for accessing a single row of the matrix.
Definition: cmatrix.inl:222
cxsc::RowLen
int RowLen(const cimatrix &)
Returns the row dimension.
Definition: cimatrix.inl:1199
cxsc::scmatrix_slice
A slice of a sparse complex matrix.
Definition: scmatrix.hpp:1956
cxsc::srmatrix
A sparse real matrix.
Definition: srmatrix.hpp:77
cxsc::Ub
int Ub(const cimatrix &rm, const int &i) noexcept
Returns the upper bound index.
Definition: cimatrix.inl:1163
cxsc::operator*=
cimatrix & operator*=(cimatrix &m, const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
Definition: cimatrix.inl:1605
cxsc::operator/
civector operator/(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of division operation.
Definition: cimatrix.inl:730
cxsc::intvector
The Data Type intvector.
Definition: intvector.hpp:52
cxsc::rmatrix
The Data Type rmatrix.
Definition: rmatrix.hpp:471
cxsc::cvector
The Data Type cvector.
Definition: cvector.hpp:58
cxsc::srvector_slice
Helper class for slices of sparse vectors.
Definition: srvector.hpp:868
cxsc::abs
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737
cxsc::operator/=
cimatrix & operator/=(cimatrix &m, const cinterval &c) noexcept
Implementation of division and allocation operation.
Definition: cimatrix.inl:1623
cxsc::ColLen
int ColLen(const cimatrix &)
Returns the column dimension.
Definition: cimatrix.inl:1202
cxsc::cmatrix_subv::operator[]
complex & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector (read-only)
Definition: cmatrix.inl:195
cxsc::rvector
The Data Type rvector.
Definition: rvector.hpp:58
cxsc::cmatrix_slice::operator*=
cmatrix_slice & operator*=(const srmatrix &m)
Implementation of addition and assignment operator.
Definition: scmatrix.hpp:1768
cxsc::cmatrix_subv::operator*=
cmatrix_subv & operator*=(const complex &c) noexcept
Implementation of multiplication and allocation operation.
Definition: cmatrix.inl:512
cxsc::cmatrix::cmatrix
cmatrix() noexcept
Constructor of class cmatrix.
Definition: cmatrix.inl:31
cxsc::Col
cimatrix_subv Col(cimatrix &m, const int &i) noexcept
Returns one column of the matrix as a vector.
Definition: cimatrix.inl:242
cxsc::scmatrix_subv
Represents a row or column vector of a sparse matrix.
Definition: scmatrix.hpp:3345
cxsc::scmatrix
A sparse complex matrix.
Definition: scmatrix.hpp:69
cxsc::cmatrix_slice
The Data Type cmatrix_slice.
Definition: cmatrix.hpp:1203
cxsc::cmatrix_subv::cmatrix_subv
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
cxsc::cmatrix_slice::cmatrix_slice
cmatrix_slice(const cmatrix_slice &ms) noexcept
Constructor of class cmatrix_slice.
Definition: cmatrix.hpp:1584
cxsc::SetUb
cimatrix & SetUb(cimatrix &m, const int &i, const int &j) noexcept
Sets the upper bound index.
Definition: cimatrix.inl:1191
cxsc::rvector_slice
The Data Type rvector_slice.
Definition: rvector.hpp:1064
cxsc::cmatrix_slice::operator|=
cmatrix_slice & operator|=(const cmatrix &m1) noexcept
Allocates the convex hull of the arguments to the first argument.
cxsc::cmatrix_subv::Lb
friend int Lb(const cmatrix_subv &rv) noexcept
Returns the lower bound of the vector.
Definition: cmatrix.hpp:266
cxsc::operator*
civector operator*(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of multiplication operation.
Definition: cimatrix.inl:731
cxsc::Lb
int Lb(const cimatrix &rm, const int &i) noexcept
Returns the lower bound index.
Definition: cimatrix.inl:1156
cxsc::accumulate_approx
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
cxsc::cmatrix_subv::operator()
cmatrix_subv & operator()() noexcept
Operator for accessing the whole vector.
Definition: cmatrix.hpp:289
cxsc::cmatrix_slice::operator[]
cmatrix_subv operator[](const int &i) noexcept
Operator for accessing a single row of the matrix.
Definition: cmatrix.inl:300
cxsc::cmatrix_slice::operator-=
cmatrix_slice & operator-=(const srmatrix &m)
Implementation of addition and assignment operator.
Definition: scmatrix.hpp:1752
cxsc::cmatrix_slice::operator=
cmatrix_slice & operator=(const cmatrix &m) noexcept
Implementation of standard assigning operator.
Definition: cmatrix.inl:450
cxsc::SetLb
cimatrix & SetLb(cimatrix &m, const int &i, const int &j) noexcept
Sets the lower bound index.
Definition: cimatrix.inl:1184
cxsc::scvector_slice
Helper class for slices of sparse vectors.
Definition: scvector.hpp:1245
cxsc::cmatrix::operator*=
cmatrix & operator*=(const srmatrix &m)
Implementation of addition and assignment operator.
Definition: scmatrix.hpp:1760
cxsc::_cmatrix
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
cxsc::rmatrix_subv
The Data Type rmatrix_subv.
Definition: rmatrix.hpp:54
cxsc::cmatrix::operator=
cmatrix & operator=(const complex &r) noexcept
Implementation of standard assigning operator.
Definition: cmatrix.inl:438
cxsc::cmatrix_slice::cmatrix_slice
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
cxsc
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
cxsc::cmatrix_subv::Col
friend cmatrix_subv Col(cmatrix &m, const int &i) noexcept
Returns one column of the matrix as a vector.
Definition: cmatrix.inl:162
cxsc::operator+=
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc) noexcept
Implementation of standard algebraic addition and allocation operation.
Definition: cdot.inl:251
cxsc::cmatrix_subv::operator-=
cmatrix_subv & operator-=(const scmatrix_subv &rv)
Implementation of standard assigning operator.
Definition: scmatrix.hpp:4356
cxsc::cmatrix_subv::cmatrix_subv
cmatrix_subv(const cmatrix_subv &v) noexcept
Constructor of class cmatrix_subv.
Definition: cmatrix.hpp:261
cxsc::DoubleSize
void DoubleSize(cimatrix &A)
Doubles the size of the matrix.
Definition: cimatrix.cpp:83
cxsc::transp
cimatrix transp(const cimatrix &A)
Returns the transposed matrix.
Definition: cimatrix.cpp:74
cxsc::cmatrix_subv::operator=
cmatrix_subv & operator=(const scmatrix_subv &rv)
Implementation of standard assigning operator.
Definition: scmatrix.hpp:4386
cxsc::rmatrix_slice
The Data Type rmatrix_slice.
Definition: rmatrix.hpp:1443
cxsc::cmatrix_subv
The Data Type cmatrix_subv.
Definition: cmatrix.hpp:54
cxsc::cmatrix_slice::cmatrix_slice
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
cxsc::cmatrix::operator-=
cmatrix & operator-=(const srmatrix &m)
Implementation of addition and assignment operator.
Definition: scmatrix.hpp:1744
cxsc::cimatrix
The Data Type cimatrix.
Definition: cimatrix.hpp:908
cxsc::Id
cimatrix Id(const cimatrix &A)
Returns the Identity matrix.
Definition: cimatrix.cpp:61
cxsc::cmatrix_subv::Ub
friend int Ub(const cmatrix_subv &rv) noexcept
Returns the upper bound of the vector.
Definition: cmatrix.hpp:268
cxsc::Resize
void Resize(cimatrix &A) noexcept
Resizes the matrix.
Definition: cimatrix.inl:1211
cxsc::complex
The Scalar Type complex.
Definition: complex.hpp:50
cxsc::cvector_slice
The Data Type cvector_slice.
Definition: cvector.hpp:845
cxsc::cmatrix_slice::operator+=
cmatrix_slice & operator+=(const srmatrix &m)
Implementation of addition and assignment operator.
Definition: scmatrix.hpp:1736
cxsc::civector
The Data Type civector.
Definition: civector.hpp:57
cxsc::Row
cimatrix_subv Row(cimatrix &m, const int &i) noexcept
Returns one row of the matrix as a vector.
Definition: cimatrix.inl:231
cxsc::intmatrix
The Data Type intmatrix.
Definition: intmatrix.hpp:314
cxsc::cvector::cvector
cvector() noexcept
Constructor of class cvector.
Definition: cvector.inl:31
cxsc::cmatrix_subv::operator/=
cmatrix_subv & operator/=(const complex &c) noexcept
Implementation of division and allocation operation.
Definition: cmatrix.inl:515
cxsc::cmatrix_slice::operator()
cmatrix_slice & operator()() noexcept
Operator for accessing the whole matrix.
Definition: cmatrix.hpp:1698
cxsc::real
The Scalar Type real.
Definition: real.hpp:114
cxsc::srmatrix_slice
A slice of a sparse real matrix.
Definition: srmatrix.hpp:1360