C-XSC - A C++ Class Library for Extended Scientific Computing 2.5.4
cimatrix.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: cimatrix.hpp,v 1.41 2014/01/30 17:23:43 cxsc Exp $ */
25
26#ifndef _CXSC_CIMATRIX_HPP_INCLUDED
27#define _CXSC_CIMATRIX_HPP_INCLUDED
28
29#include "xscclass.hpp"
30#include "cidot.hpp"
31#include "civector.hpp"
32#include "except.hpp"
33#include "matrix.hpp"
34#include "imatrix.hpp"
35#include "cmatrix.hpp"
36
37
38namespace cxsc {
39
40class cimatrix; // forward declaration
41class cimatrix_slice; // forward declaration
42class srmatrix;
43class srmatrix_slice;
44class srmatrix_subv;
45class simatrix;
46class simatrix_slice;
47class simatrix_subv;
48class scmatrix;
49class scmatrix_slice;
50class scmatrix_subv;
51class scimatrix;
52class scimatrix_slice;
53class scimatrix_subv;
54
55
56
57// ---------------------------------------------------------------------------
58// ---- ----
59// ---- class cimatrix_subv (declaration) ----
60// ---- ----
61// ---------------------------------------------------------------------------
62
64
68{
69 friend class civector;
70 friend class cimatrix;
71 friend class cimatrix_slice;
72
73 private:
74 cinterval *dat;
75 int lb,ub;
76 int size,start,offset; // start=first element index 0..n-1
77
78 public:
80 friend INLINE cimatrix_subv Row(cimatrix &m,const int &i)
81#if(CXSC_INDEX_CHECK)
82 ;
83#else
84 noexcept;
85#endif
86
88 friend INLINE cimatrix_subv Col(cimatrix &m,const int &i)
89#if(CXSC_INDEX_CHECK)
90 ;
91#else
92 noexcept;
93#endif
95 friend INLINE cimatrix_subv Row(const cimatrix &m,const int &i)
96#if(CXSC_INDEX_CHECK)
97 ;
98#else
99 noexcept;
100#endif
101
103 friend INLINE cimatrix_subv Col(const cimatrix &m,const int &i)
104#if(CXSC_INDEX_CHECK)
105 ;
106#else
107 noexcept;
108#endif
109
110
111#ifdef _CXSC_FRIEND_TPL
112 //----------------- Templates ---------------------------------------
113template <class MV1,class MV2> friend MV1 &_mvmvassign(MV1 &v,const MV2 &rv)
114#if(CXSC_INDEX_CHECK)
115;
116#else
117 noexcept;
118#endif
119template <class MV,class S> friend MV &_mvsassign(MV &v,const S &r) noexcept;
120template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
121#if(CXSC_INDEX_CHECK)
122;
123#else
124 noexcept;
125#endif
126template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) noexcept;
127template <class MV,class V> friend MV &_mvvsetinf(MV &v,const V &rv)
128#if(CXSC_INDEX_CHECK)
129;
130#else
131 noexcept;
132#endif
133template <class MV,class V> friend MV &_mvvsetsup(MV &v,const V &rv)
134#if(CXSC_INDEX_CHECK)
135;
136#else
137 noexcept;
138#endif
139template <class MV,class V> friend MV &_mvvusetinf(MV &v,const V &rv)
140#if(CXSC_INDEX_CHECK)
141;
142#else
143 noexcept;
144#endif
145template <class MV,class V> friend MV &_mvvusetsup(MV &v,const V &rv)
146#if(CXSC_INDEX_CHECK)
147;
148#else
149 noexcept;
150#endif
151template <class MV,class V> friend MV &_mvvsetre(MV &v,const V &rv)
152#if(CXSC_INDEX_CHECK)
153;
154#else
155 noexcept;
156#endif
157template <class MV,class V> friend MV &_mvvsetim(MV &v,const V &rv)
158#if(CXSC_INDEX_CHECK)
159;
160#else
161 noexcept;
162#endif
163template <class MV,class V> friend V _mvabs(const MV &mv) noexcept;
164template <class MV,class V> friend V _mvim(const MV &mv) noexcept;
165template <class MV,class V> friend V _mvre(const MV &mv) noexcept;
166template <class MV,class V> friend V _mvdiam(const MV &mv) noexcept;
167template <class MV,class V> friend V _mvmid(const MV &mv) noexcept;
168template <class MV,class V> friend V _mvinf(const MV &mv) noexcept;
169template <class MV,class V> friend V _mvsup(const MV &mv) noexcept;
170
171 template <class MV,class S> friend MV &_mvssetinf(MV &mv, const S &s) noexcept;
172 template <class MV,class S> friend MV &_mvssetsup(MV &mv, const S &s) noexcept;
173 template <class MV,class S> friend MV &_mvsusetinf(MV &mv, const S &s) noexcept;
174 template <class MV,class S> friend MV &_mvsusetsup(MV &mv, const S &s) noexcept;
175 template <class MV,class S> friend MV &_mvssetim(MV &mv, const S &s) noexcept;
176 template <class MV,class S> friend MV &_mvssetre(MV &mv, const S &s) noexcept;
177template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
178#if(CXSC_INDEX_CHECK)
179 ;
180#else
181 noexcept;
182#endif
183template <class DP,class MV1,class MV2> friend void _mvmvaccu(DP &dp, const MV1 & rv1, const MV2 &rv2)
184#if(CXSC_INDEX_CHECK)
185 ;
186#else
187 noexcept;
188#endif
189 template <class MV1,class MV2,class S> friend S _mvmvcimult(const MV1 & rv1, const MV2 &rv2)
190#if(CXSC_INDEX_CHECK)
191 ;
192#else
193 noexcept;
194#endif
195 template <class V,class MV,class S> friend S _vmvcimult(const V &rv1, const MV &rv2)
196#if(CXSC_INDEX_CHECK)
197 ;
198#else
199 noexcept;
200#endif
201 template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) noexcept;
202 template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
203#if(CXSC_INDEX_CHECK)
204 ;
205#else
206 noexcept;
207#endif
208 template <class MV1,class MV2,class E> friend E _mvmvminus(const MV1 &rv1, const MV2 &rv2)
209#if(CXSC_INDEX_CHECK)
210 ;
211#else
212 noexcept;
213#endif
214 template <class MV,class V,class E> friend E _mvvplus(const MV &rv1, const V &rv2)
215#if(CXSC_INDEX_CHECK)
216 ;
217#else
218 noexcept;
219#endif
220 template <class MV,class V,class E> friend E _mvvminus(const MV &rv1, const V &rv2)
221#if(CXSC_INDEX_CHECK)
222 ;
223#else
224 noexcept;
225#endif
226 template <class V,class MV,class E> friend E _vmvminus(const V &rv1, const MV &rv2)
227#if(CXSC_INDEX_CHECK)
228 ;
229#else
230 noexcept;
231#endif
232 template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) noexcept;
233template <class MV,class S> friend MV &_mvsmultassign(MV &v,const S &r) noexcept;
234template <class MV, class S> friend MV &_mvsplusassign(MV &v,const S &r) noexcept;
235template <class MV,class S> friend MV &_mvsminusassign(MV &v,const S &r) noexcept;
236template <class MV,class S> friend MV &_mvsdivassign(MV &v,const S &r) noexcept;
237template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
238#if(CXSC_INDEX_CHECK)
239;
240#else
241 noexcept;
242#endif
243template <class V,class MV> friend V &_vmvplusassign(V &rv,const MV &v)
244#if(CXSC_INDEX_CHECK)
245;
246#else
247 noexcept;
248#endif
249template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv)
250#if(CXSC_INDEX_CHECK)
251;
252#else
253 noexcept;
254#endif
255template <class V,class MV> friend V &_vmvminusassign(V &rv,const MV &v)
256#if(CXSC_INDEX_CHECK)
257;
258#else
259 noexcept;
260#endif
261 template <class MV1,class MV2,class E> friend E _mvmvconv(const MV1 &rv1, const MV2 &rv2)
262#if(CXSC_INDEX_CHECK)
263 ;
264#else
265 noexcept;
266#endif
267 template <class MV,class V,class E> friend E _mvvconv(const MV &rv1, const V &rv2)
268#if(CXSC_INDEX_CHECK)
269 ;
270#else
271 noexcept;
272#endif
273template <class MV,class V> friend MV &_mvvconvassign(MV &v,const V &rv)
274#if(CXSC_INDEX_CHECK)
275;
276#else
277 noexcept;
278#endif
279 template <class MV1,class MV2,class E> friend E _mvmvsect(const MV1 &rv1, const MV2 &rv2)
280#if(CXSC_INDEX_CHECK)
281 ;
282#else
283 noexcept;
284#endif
285 template <class MV,class V,class E> friend E _mvvsect(const MV &rv1, const V &rv2)
286#if(CXSC_INDEX_CHECK)
287 ;
288#else
289 noexcept;
290#endif
291template <class MV,class V> friend MV &_mvvsectassign(MV &v,const V &rv)
292#if(CXSC_INDEX_CHECK)
293;
294#else
295 noexcept;
296#endif
297template <class V,class MV> friend V &_vmvsectassign(V &rv,const MV &v)
298#if(CXSC_INDEX_CHECK)
299;
300#else
301 noexcept;
302#endif
303
304 // Real
305
306 // complex
307
308 // interval
309
310#endif
311
312 //----------------- Konstruktoren ----------------------------------
313
315 explicit INLINE cimatrix_subv (cinterval *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) { }
316 public:
318 INLINE cimatrix_subv(const cimatrix_subv &v) noexcept:dat(v.dat),lb(v.lb),ub(v.ub),size(v.size),start(v.start),offset(v.offset) { }
319 public:
320
321 //---------------------- Standardfunktionen ------------------------
322
331
340
349
351 cimatrix_subv &operator =(const cimatrix_subv &rv) noexcept;
353 cimatrix_subv &operator =(const cinterval &r) noexcept;
356#if(CXSC_INDEX_CHECK)
357;
358#else
359 noexcept;
360#endif
363#if(CXSC_INDEX_CHECK)
364;
365#else
366 noexcept;
367#endif
369 INLINE cimatrix_subv &operator =(const civector &v)
370#if(CXSC_INDEX_CHECK)
371;
372#else
373 noexcept;
374#endif
376 INLINE cimatrix_subv &operator =(const civector_slice &v)
377#if(CXSC_INDEX_CHECK)
378;
379#else
380 noexcept;
381#endif
382 // Real
384 INLINE cimatrix_subv &operator =(const real &r) noexcept;
386 INLINE cimatrix_subv &operator =(const rmatrix &m)
387#if(CXSC_INDEX_CHECK)
388;
389#else
390 noexcept;
391#endif
393 INLINE cimatrix_subv &operator =(const rmatrix_slice &m)
394#if(CXSC_INDEX_CHECK)
395;
396#else
397 noexcept;
398#endif
400 INLINE cimatrix_subv &operator =(const rvector &v)
401#if(CXSC_INDEX_CHECK)
402;
403#else
404 noexcept;
405#endif
407 INLINE cimatrix_subv &operator =(const rvector_slice &v)
408#if(CXSC_INDEX_CHECK)
409;
410#else
411 noexcept;
412#endif
414 INLINE cimatrix_subv &operator =(const rmatrix_subv &rv) noexcept;
415
416 // complex
418 INLINE cimatrix_subv &operator =(const complex &r) noexcept;
420 INLINE cimatrix_subv &operator =(const cmatrix &m)
421#if(CXSC_INDEX_CHECK)
422;
423#else
424 noexcept;
425#endif
427 INLINE cimatrix_subv &operator =(const cmatrix_slice &m)
428#if(CXSC_INDEX_CHECK)
429;
430#else
431 noexcept;
432#endif
434 INLINE cimatrix_subv &operator =(const cvector &v)
435#if(CXSC_INDEX_CHECK)
436;
437#else
438 noexcept;
439#endif
441 INLINE cimatrix_subv &operator =(const cvector_slice &v)
442#if(CXSC_INDEX_CHECK)
443;
444#else
445 noexcept;
446#endif
448 INLINE cimatrix_subv &operator =(const cmatrix_subv &rv) noexcept;
449
450 // interval
452 INLINE cimatrix_subv &operator =(const interval &r) noexcept;
454 INLINE cimatrix_subv &operator =(const imatrix &m)
455#if(CXSC_INDEX_CHECK)
456;
457#else
458 noexcept;
459#endif
461 INLINE cimatrix_subv &operator =(const imatrix_slice &m)
462#if(CXSC_INDEX_CHECK)
463;
464#else
465 noexcept;
466#endif
468 INLINE cimatrix_subv &operator =(const ivector &v)
469#if(CXSC_INDEX_CHECK)
470;
471#else
472 noexcept;
473#endif
475 INLINE cimatrix_subv &operator =(const ivector_slice &v)
476#if(CXSC_INDEX_CHECK)
477;
478#else
479 noexcept;
480#endif
482 INLINE cimatrix_subv &operator =(const imatrix_subv &rv) noexcept;
483
485 friend INLINE int Lb(const cimatrix_subv &rv) noexcept { return rv.lb; }
487 friend INLINE int Ub(const cimatrix_subv &rv) noexcept { return rv.ub; }
489 friend INLINE int VecLen(const cimatrix_subv &rv) noexcept { return rv.size; }
490
492 INLINE cinterval &operator [](const int &i) const
493#if(CXSC_INDEX_CHECK)
494;
495#else
496 noexcept;
497#endif
498
500 INLINE cinterval &operator [](const int &i)
501#if(CXSC_INDEX_CHECK)
502;
503#else
504 noexcept;
505#endif
506
508 INLINE cimatrix_subv &operator ()() noexcept { return *this; }
510 INLINE cimatrix_subv operator ()(const int &i)
511#if(CXSC_INDEX_CHECK)
512;
513#else
514 noexcept;
515#endif
517 INLINE cimatrix_subv operator ()(const int &i1,const int &i2)
518#if(CXSC_INDEX_CHECK)
519;
520#else
521 noexcept;
522#endif
523
525 INLINE cimatrix_subv &operator *=(const cinterval &c) noexcept;
527 INLINE cimatrix_subv &operator +=(const cinterval &c) noexcept;
529 INLINE cimatrix_subv &operator -=(const cinterval &c) noexcept;
531 INLINE cimatrix_subv &operator /=(const cinterval &c) noexcept;
533 INLINE cimatrix_subv &operator -=(const scivector &rv);
535 INLINE cimatrix_subv &operator +=(const scivector &rv);
537 INLINE cimatrix_subv &operator &=(const scivector &rv);
539 INLINE cimatrix_subv &operator |=(const scivector &rv);
541 INLINE cimatrix_subv &operator -=(const scivector_slice &rv);
543 INLINE cimatrix_subv &operator +=(const scivector_slice &rv);
545 INLINE cimatrix_subv &operator &=(const scivector_slice &rv);
547 INLINE cimatrix_subv &operator |=(const scivector_slice &rv);
549 INLINE cimatrix_subv &operator -=(const scimatrix_subv &rv);
551 INLINE cimatrix_subv &operator +=(const scimatrix_subv &rv);
553 INLINE cimatrix_subv &operator &=(const scimatrix_subv &rv);
555 INLINE cimatrix_subv &operator |=(const scimatrix_subv &rv);
556
558 INLINE cimatrix_subv &operator -=(const civector &rv)
559#if(CXSC_INDEX_CHECK)
560;
561#else
562 noexcept;
563#endif
565 INLINE cimatrix_subv &operator +=(const civector &rv)
566#if(CXSC_INDEX_CHECK)
567;
568#else
569 noexcept;
570#endif
572 INLINE cimatrix_subv &operator -=(const civector_slice &rv)
573#if(CXSC_INDEX_CHECK)
574;
575#else
576 noexcept;
577#endif
579 INLINE cimatrix_subv &operator +=(const civector_slice &rv)
580#if(CXSC_INDEX_CHECK)
581;
582#else
583 noexcept;
584#endif
586 INLINE cimatrix_subv &operator |=(const civector &rv)
587#if(CXSC_INDEX_CHECK)
588;
589#else
590 noexcept;
591#endif
593 INLINE cimatrix_subv &operator |=(const civector_slice &rv)
594#if(CXSC_INDEX_CHECK)
595;
596#else
597 noexcept;
598#endif
600 INLINE cimatrix_subv &operator &=(const civector &rv)
601#if(CXSC_INDEX_CHECK)
602;
603#else
604 noexcept;
605#endif
607 INLINE cimatrix_subv &operator &=(const civector_slice &rv)
608#if(CXSC_INDEX_CHECK)
609;
610#else
611 noexcept;
612#endif
613 // real
615 INLINE cimatrix_subv &operator *=(const real &c) noexcept;
617 INLINE cimatrix_subv &operator +=(const real &c) noexcept;
619 INLINE cimatrix_subv &operator -=(const real &c) noexcept;
621 INLINE cimatrix_subv &operator /=(const real &c) noexcept;
623 INLINE cimatrix_subv &operator -=(const srvector &rv);
625 INLINE cimatrix_subv &operator +=(const srvector &rv);
627 INLINE cimatrix_subv &operator |=(const srvector &rv);
629 INLINE cimatrix_subv &operator -=(const srvector_slice &rv);
631 INLINE cimatrix_subv &operator +=(const srvector_slice &rv);
633 INLINE cimatrix_subv &operator |=(const srvector_slice &rv);
635 INLINE cimatrix_subv &operator -=(const srmatrix_subv &rv);
637 INLINE cimatrix_subv &operator +=(const srmatrix_subv &rv);
639 INLINE cimatrix_subv &operator |=(const srmatrix_subv &rv);
641 INLINE cimatrix_subv &operator -=(const rvector &rv)
642#if(CXSC_INDEX_CHECK)
643;
644#else
645 noexcept;
646#endif
648 INLINE cimatrix_subv &operator +=(const rvector &rv)
649#if(CXSC_INDEX_CHECK)
650;
651#else
652 noexcept;
653#endif
655 INLINE cimatrix_subv &operator -=(const rvector_slice &rv)
656#if(CXSC_INDEX_CHECK)
657;
658#else
659 noexcept;
660#endif
662 INLINE cimatrix_subv &operator +=(const rvector_slice &rv)
663#if(CXSC_INDEX_CHECK)
664;
665#else
666 noexcept;
667#endif
669 INLINE cimatrix_subv &operator |=(const rvector &rv)
670#if(CXSC_INDEX_CHECK)
671;
672#else
673 noexcept;
674#endif
676 INLINE cimatrix_subv &operator |=(const rvector_slice &rv)
677#if(CXSC_INDEX_CHECK)
678;
679#else
680 noexcept;
681#endif
683 INLINE cimatrix_subv &operator &=(const rvector &rv)
684#if(CXSC_INDEX_CHECK)
685;
686#else
687 noexcept;
688#endif
690 INLINE cimatrix_subv &operator &=(const rvector_slice &rv)
691#if(CXSC_INDEX_CHECK)
692;
693#else
694 noexcept;
695#endif
696 // complex
698 INLINE cimatrix_subv &operator *=(const complex &c) noexcept;
700 INLINE cimatrix_subv &operator +=(const complex &c) noexcept;
702 INLINE cimatrix_subv &operator -=(const complex &c) noexcept;
704 INLINE cimatrix_subv &operator /=(const complex &c) noexcept;
706 INLINE cimatrix_subv &operator -=(const scvector &rv);
708 INLINE cimatrix_subv &operator +=(const scvector &rv);
710 INLINE cimatrix_subv &operator |=(const scvector &rv);
712 INLINE cimatrix_subv &operator -=(const scvector_slice &rv);
714 INLINE cimatrix_subv &operator +=(const scvector_slice &rv);
716 INLINE cimatrix_subv &operator |=(const scvector_slice &rv);
718 INLINE cimatrix_subv &operator -=(const scmatrix_subv &rv);
720 INLINE cimatrix_subv &operator +=(const scmatrix_subv &rv);
724 INLINE cimatrix_subv &operator |=(const scmatrix_subv &rv);
726 INLINE cimatrix_subv &operator -=(const cvector &rv)
727#if(CXSC_INDEX_CHECK)
728;
729#else
730 noexcept;
731#endif
733 INLINE cimatrix_subv &operator +=(const cvector &rv)
734#if(CXSC_INDEX_CHECK)
735;
736#else
737 noexcept;
738#endif
740 INLINE cimatrix_subv &operator -=(const cvector_slice &rv)
741#if(CXSC_INDEX_CHECK)
742;
743#else
744 noexcept;
745#endif
747 INLINE cimatrix_subv &operator +=(const cvector_slice &rv)
748#if(CXSC_INDEX_CHECK)
749;
750#else
751 noexcept;
752#endif
754 INLINE cimatrix_subv &operator |=(const cvector &rv)
755#if(CXSC_INDEX_CHECK)
756;
757#else
758 noexcept;
759#endif
761 INLINE cimatrix_subv &operator |=(const cvector_slice &rv)
762#if(CXSC_INDEX_CHECK)
763;
764#else
765 noexcept;
766#endif
768 INLINE cimatrix_subv &operator &=(const cvector &rv)
769#if(CXSC_INDEX_CHECK)
770;
771#else
772 noexcept;
773#endif
775 INLINE cimatrix_subv &operator &=(const cvector_slice &rv)
776#if(CXSC_INDEX_CHECK)
777;
778#else
779 noexcept;
780#endif
781 // interval
783 INLINE cimatrix_subv &operator *=(const interval &c) noexcept;
785 INLINE cimatrix_subv &operator +=(const interval &c) noexcept;
787 INLINE cimatrix_subv &operator -=(const interval &c) noexcept;
789 INLINE cimatrix_subv &operator /=(const interval &c) noexcept;
791 INLINE cimatrix_subv &operator -=(const sivector &rv);
793 INLINE cimatrix_subv &operator +=(const sivector &rv);
795 INLINE cimatrix_subv &operator &=(const sivector &rv);
797 INLINE cimatrix_subv &operator |=(const sivector &rv);
799 INLINE cimatrix_subv &operator -=(const sivector_slice &rv);
801 INLINE cimatrix_subv &operator +=(const sivector_slice &rv);
803 INLINE cimatrix_subv &operator &=(const sivector_slice &rv);
805 INLINE cimatrix_subv &operator |=(const sivector_slice &rv);
807 INLINE cimatrix_subv &operator -=(const simatrix_subv &rv);
809 INLINE cimatrix_subv &operator +=(const simatrix_subv &rv);
811 INLINE cimatrix_subv &operator &=(const simatrix_subv &rv);
813 INLINE cimatrix_subv &operator |=(const simatrix_subv &rv);
815 INLINE cimatrix_subv &operator -=(const ivector &rv)
816#if(CXSC_INDEX_CHECK)
817;
818#else
819 noexcept;
820#endif
822 INLINE cimatrix_subv &operator +=(const ivector &rv)
823#if(CXSC_INDEX_CHECK)
824;
825#else
826 noexcept;
827#endif
829 INLINE cimatrix_subv &operator -=(const ivector_slice &rv)
830#if(CXSC_INDEX_CHECK)
831;
832#else
833 noexcept;
834#endif
836 INLINE cimatrix_subv &operator +=(const ivector_slice &rv)
837#if(CXSC_INDEX_CHECK)
838;
839#else
840 noexcept;
841#endif
843 INLINE cimatrix_subv &operator |=(const ivector &rv)
844#if(CXSC_INDEX_CHECK)
845;
846#else
847 noexcept;
848#endif
850 INLINE cimatrix_subv &operator |=(const ivector_slice &rv)
851#if(CXSC_INDEX_CHECK)
852;
853#else
854 noexcept;
855#endif
857 INLINE cimatrix_subv &operator &=(const ivector &rv)
858#if(CXSC_INDEX_CHECK)
859;
860#else
861 noexcept;
862#endif
864 INLINE cimatrix_subv &operator &=(const ivector_slice &rv)
865#if(CXSC_INDEX_CHECK)
866;
867#else
868 noexcept;
869#endif
870//#else
871//#endif
872
873};
874
875
877INLINE cimatrix_subv Row(cimatrix &m,const int &i)
878#if(CXSC_INDEX_CHECK)
879;
880#else
881 noexcept;
882#endif
884INLINE cimatrix_subv Col(cimatrix &m,const int &i)
885#if(CXSC_INDEX_CHECK)
886;
887#else
888 noexcept;
889#endif
890
891
892
893
894class cimatrix_slice;
895
896// ---------------------------------------------------------------------------
897// ---- ----
898// ---- class cimatrix (declaration) ----
899// ---- ----
900// ---------------------------------------------------------------------------
901
902
904
908{
909 friend class cimatrix_slice;
910 friend class cimatrix_subv;
911 private:
912 cinterval *dat;
913 int lb1,ub1,lb2,ub2,xsize,ysize;
914
915 public:
916//#if(CXSC_INDEX_CHECK)
917#ifdef _CXSC_FRIEND_TPL
918 //----------------- Templates ---------------------------------------
919template <class S,class M> friend void _smconstr(S &s,const M &m)
920#if(CXSC_INDEX_CHECK)
921;
922#else
923 noexcept;
924#endif
925template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
926#if(CXSC_INDEX_CHECK)
927;
928#else
929 noexcept;
930#endif
931 template <class M1,class M2,class S> friend M1 &_mmassign(M1 &m1,const M2 &m,S ms) noexcept;
932 template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) noexcept;
933 template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m)
934#if(CXSC_INDEX_CHECK)
935 ;
936#else
937 noexcept;
938#endif
939 template <class M,class S> friend M &_msassign(M &m,const S &r) noexcept;
940template <class V,class M,class S> friend V &_vmassign(V &v,const M &m)
941#if(CXSC_INDEX_CHECK)
942;
943#else
944 noexcept;
945#endif
946template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) noexcept;
947 template <class M> friend int _mlb(const M &m, const int &i)
948#if(CXSC_INDEX_CHECK)
949;
950#else
951 noexcept;
952#endif
953 template <class M> friend int _mub(const M &m, const int &i)
954#if(CXSC_INDEX_CHECK)
955;
956#else
957 noexcept;
958#endif
959 template <class M> friend M &_msetlb(M &m, const int &i,const int &j)
960#if(CXSC_INDEX_CHECK)
961;
962#else
963 noexcept;
964#endif
965 template <class M> friend M &_msetub(M &m, const int &i,const int &j)
966#if(CXSC_INDEX_CHECK)
967;
968#else
969 noexcept;
970#endif
971 template <class M> friend void _mresize(M &A) noexcept;
972 template <class M,class S> friend void _mresize(M &A,const int &m, const int &n)
973#if(CXSC_INDEX_CHECK)
974 ;
975#else
976 noexcept;
977#endif
978 template <class M,class S> friend void _mresize(M &A,const int &m1, const int &m2,const int &n1,const int &n2)
979#if(CXSC_INDEX_CHECK)
980 ;
981#else
982 noexcept;
983#endif
984 template <class M,class E> friend E _mabs(const M &m) noexcept;
985 template <class M,class E> friend E _mdiam(const M &m) noexcept;
986 template <class M,class E> friend E _mmid(const M &m) noexcept;
987 template <class M,class E> friend E _mre(const M &m) noexcept;
988 template <class M,class E> friend E _mim(const M &m) noexcept;
989 friend INLINE rmatrix SupRe(const cimatrix &v) noexcept;
990 friend INLINE rmatrix SupIm(const cimatrix &v) noexcept;
991 friend INLINE rmatrix InfRe(const cimatrix &v) noexcept;
992 friend INLINE rmatrix InfIm(const cimatrix &v) noexcept;
993 template <class M1,class M2> friend M1 &_mmsetre(M1 &m1,const M2 &m2)
994#if(CXSC_INDEX_CHECK)
995 ;
996#else
997 noexcept;
998#endif
999 template <class M1,class M2> friend M1 &_mmsetim(M1 &m1,const M2 &m2)
1000#if(CXSC_INDEX_CHECK)
1001 ;
1002#else
1003 noexcept;
1004#endif
1005 template <class M1,class MS2> friend M1 &_mmssetre(M1 &m1,const MS2 &ms2)
1006#if(CXSC_INDEX_CHECK)
1007 ;
1008#else
1009 noexcept;
1010#endif
1011 template <class M1,class MS2> friend M1 &_mmssetim(M1 &m1,const MS2 &ms2)
1012#if(CXSC_INDEX_CHECK)
1013 ;
1014#else
1015 noexcept;
1016#endif
1017 template <class M,class E> friend E _minf(const M &m) noexcept;
1018 template <class M,class E> friend E _msup(const M &m) noexcept;
1019 template <class M1,class M2> friend M1 &_mmsetinf(M1 &m1,const M2 &m2)
1020#if(CXSC_INDEX_CHECK)
1021 ;
1022#else
1023 noexcept;
1024#endif
1025 template <class M1,class M2> friend M1 &_mmsetsup(M1 &m1,const M2 &m2)
1026#if(CXSC_INDEX_CHECK)
1027 ;
1028#else
1029 noexcept;
1030#endif
1031 template <class M1,class MS2> friend M1 &_mmssetinf(M1 &m1,const MS2 &ms2)
1032#if(CXSC_INDEX_CHECK)
1033 ;
1034#else
1035 noexcept;
1036#endif
1037 template <class M1,class MS2> friend M1 &_mmssetsup(M1 &m1,const MS2 &ms2)
1038#if(CXSC_INDEX_CHECK)
1039 ;
1040#else
1041 noexcept;
1042#endif
1043 template <class M1,class M2> friend M1 &_mmusetinf(M1 &m1,const M2 &m2)
1044#if(CXSC_INDEX_CHECK)
1045 ;
1046#else
1047 noexcept;
1048#endif
1049 template <class M1,class M2> friend M1 &_mmusetsup(M1 &m1,const M2 &m2)
1050#if(CXSC_INDEX_CHECK)
1051 ;
1052#else
1053 noexcept;
1054#endif
1055 template <class M1,class MS2> friend M1 &_mmsusetinf(M1 &m1,const MS2 &ms2)
1056#if(CXSC_INDEX_CHECK)
1057 ;
1058#else
1059 noexcept;
1060#endif
1061 template <class M1,class MS2> friend M1 &_mmsusetsup(M1 &m1,const MS2 &ms2)
1062#if(CXSC_INDEX_CHECK)
1063 ;
1064#else
1065 noexcept;
1066#endif
1067 //-------------- matrix-matrix -------------
1068 template <class M1,class M2,class E> friend E _mmplus(const M1 &m1,const M2 &m2)
1069#if(CXSC_INDEX_CHECK)
1070 ;
1071#else
1072 noexcept;
1073#endif
1074 template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms)
1075#if(CXSC_INDEX_CHECK)
1076 ;
1077#else
1078 noexcept;
1079#endif
1080 template <class M> friend M _mminus(const M &m) noexcept;
1081 template <class MS,class E> friend E _msminus(const MS &ms) noexcept;
1082 template <class M1,class M2,class E> friend E _mmminus(const M1 &m1,const M2 &m2)
1083#if(CXSC_INDEX_CHECK)
1084 ;
1085#else
1086 noexcept;
1087#endif
1088 template <class M1,class M2> friend M1 &_mmplusassign(M1 &m1,const M2 &m2)
1089#if(CXSC_INDEX_CHECK)
1090 ;
1091#else
1092 noexcept;
1093#endif
1094 template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms)
1095#if(CXSC_INDEX_CHECK)
1096 ;
1097#else
1098 noexcept;
1099#endif
1100 template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1)
1101#if(CXSC_INDEX_CHECK)
1102 ;
1103#else
1104 noexcept;
1105#endif
1106 template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2)
1107#if(CXSC_INDEX_CHECK)
1108 ;
1109#else
1110 noexcept;
1111#endif
1112 template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms)
1113#if(CXSC_INDEX_CHECK)
1114 ;
1115#else
1116 noexcept;
1117#endif
1118 template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m)
1119#if(CXSC_INDEX_CHECK)
1120 ;
1121#else
1122 noexcept;
1123#endif
1124 template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2)
1125#if(CXSC_INDEX_CHECK)
1126 ;
1127#else
1128 noexcept;
1129#endif
1130 template <class M1,class M2> friend M1 &_mmminusassign(M1 &m1,const M2 &m2)
1131#if(CXSC_INDEX_CHECK)
1132 ;
1133#else
1134 noexcept;
1135#endif
1136 template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms)
1137#if(CXSC_INDEX_CHECK)
1138 ;
1139#else
1140 noexcept;
1141#endif
1142 template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1)
1143#if(CXSC_INDEX_CHECK)
1144 ;
1145#else
1146 noexcept;
1147#endif
1148 template <class M1,class M2,class E> friend E _mmcimult(const M1 &m1, const M2 &m2)
1149#if(CXSC_INDEX_CHECK)
1150 ;
1151#else
1152 noexcept;
1153#endif
1154 template <class M1,class M2,class S> friend M1 &_mmcimultassign(M1 &m1,const M2 &m2)
1155#if(CXSC_INDEX_CHECK)
1156 ;
1157#else
1158 noexcept;
1159#endif
1160 template <class M,class MS,class E> friend E _mmscimult(const M &m1, const MS &ms)
1161#if(CXSC_INDEX_CHECK)
1162 ;
1163#else
1164 noexcept;
1165#endif
1166 template <class MS,class M,class E> friend E _msmcimult(const MS &ms, const M &m2)
1167#if(CXSC_INDEX_CHECK)
1168 ;
1169#else
1170 noexcept;
1171#endif
1172 template <class M,class MS,class S> friend M &_mmscimultassign(M &m1,const MS &ms)
1173#if(CXSC_INDEX_CHECK)
1174 ;
1175#else
1176 noexcept;
1177#endif
1178 template <class MS1,class MS2,class E> friend E _msmscimult(const MS1 &ms1, const MS2 &ms2)
1179#if(CXSC_INDEX_CHECK)
1180 ;
1181#else
1182 noexcept;
1183#endif
1184 template <class M1,class M2,class E> friend E _mmconv(const M1 &m1,const M2 &m2)
1185#if(CXSC_INDEX_CHECK)
1186 ;
1187#else
1188 noexcept;
1189#endif
1190 template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms)
1191#if(CXSC_INDEX_CHECK)
1192 ;
1193#else
1194 noexcept;
1195#endif
1196 template <class M1,class M2> friend M1 &_mmconvassign(M1 &m1,const M2 &m2)
1197#if(CXSC_INDEX_CHECK)
1198 ;
1199#else
1200 noexcept;
1201#endif
1202 template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms)
1203#if(CXSC_INDEX_CHECK)
1204 ;
1205#else
1206 noexcept;
1207#endif
1208 template <class MS,class M> friend MS &_msmconvassign(MS &ms,const M &m1)
1209#if(CXSC_INDEX_CHECK)
1210 ;
1211#else
1212 noexcept;
1213#endif
1214 template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2)
1215#if(CXSC_INDEX_CHECK)
1216 ;
1217#else
1218 noexcept;
1219#endif
1220 template <class M1,class M2,class E> friend E _mmsect(const M1 &m1,const M2 &m2)
1221#if(CXSC_INDEX_CHECK)
1222 ;
1223#else
1224 noexcept;
1225#endif
1226 template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms)
1227#if(CXSC_INDEX_CHECK)
1228 ;
1229#else
1230 noexcept;
1231#endif
1232 template <class M1,class M2> friend M1 &_mmsectassign(M1 &m1,const M2 &m2)
1233#if(CXSC_INDEX_CHECK)
1234 ;
1235#else
1236 noexcept;
1237#endif
1238 template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms)
1239#if(CXSC_INDEX_CHECK)
1240 ;
1241#else
1242 noexcept;
1243#endif
1244 template <class MS,class M> friend MS &_msmsectassign(MS &ms,const M &m1)
1245#if(CXSC_INDEX_CHECK)
1246 ;
1247#else
1248 noexcept;
1249#endif
1250 template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2)
1251#if(CXSC_INDEX_CHECK)
1252 ;
1253#else
1254 noexcept;
1255#endif
1256 //-------- matrix-scalar -----------------
1257 template <class S,class M,class E> friend E _smmult(const S &c, const M &m) noexcept;
1258 template <class M,class S> friend M &_msmultassign(M &m,const S &c) noexcept;
1259 template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) noexcept;
1260 template <class M,class S,class E> friend E _msdiv(const M &m,const S &c) noexcept;
1261 template <class M,class S> friend M &_msdivassign(M &m,const S &c) noexcept;
1262 template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) noexcept;
1263 //-------- matrix-vector ---------------------
1264 template <class M,class V,class E> friend E _mvcimult(const M &m,const V &v)
1265#if(CXSC_INDEX_CHECK)
1266 ;
1267#else
1268 noexcept;
1269#endif
1270 template <class V,class M,class E> friend E _vmcimult(const V &v,const M &m)
1271#if(CXSC_INDEX_CHECK)
1272 ;
1273#else
1274 noexcept;
1275#endif
1276 template <class V,class M,class S> friend V &_vmcimultassign(V &v,const M &m)
1277#if(CXSC_INDEX_CHECK)
1278 ;
1279#else
1280 noexcept;
1281#endif
1282 template <class VS,class M,class S> friend VS &_vsmcimultassign(VS &v,const M &m)
1283#if(CXSC_INDEX_CHECK)
1284 ;
1285#else
1286 noexcept;
1287#endif
1288
1289 template <class M> friend void *_mvoid(const M &m) noexcept;
1290 template <class M> friend bool _mnot(const M &m) noexcept;
1291 template <class MS> friend void *_msvoid(const MS &ms) noexcept;
1292 template <class MS> friend bool _msnot(const MS &ms) noexcept;
1293 template <class M1,class M2> friend bool _mmeq(const M1 &m1,const M2 &m2) noexcept;
1294 template <class M1,class M2> friend bool _mmneq(const M1 &m1,const M2 &m2) noexcept;
1295 template <class M1,class M2> friend bool _mmless(const M1 &m1,const M2 &m2) noexcept;
1296 template <class M1,class M2> friend bool _mmleq(const M1 &m1,const M2 &m2) noexcept;
1297 template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) noexcept;
1298 template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) noexcept;
1299 template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) noexcept;
1300 template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) noexcept;
1301 template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) noexcept;
1302 template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) noexcept;
1303 template <class M> friend std::ostream &_mout(std::ostream &s,const M &r) noexcept;
1304 template <class M> friend std::istream &_min(std::istream &s,M &r) noexcept;
1305
1306 // Real
1307
1308 //--- Real --------- matrix-matrix ----------------------
1309
1310 //--- Real --------- matrix-scalar ----------------------
1311
1312 //--- Real --------- matrix-vector ----------------------
1313 template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v)
1314#if(CXSC_INDEX_CHECK)
1315 ;
1316#else
1317 noexcept;
1318#endif
1319 template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms)
1320#if(CXSC_INDEX_CHECK)
1321 ;
1322#else
1323 noexcept;
1324#endif
1325
1326 // interval
1327
1328 //--- interval --------- matrix-matrix ----------------------
1329
1330 //--- interval --------- matrix-scalar ----------------------
1331
1332
1333 //--- interval --------- matrix-vector ----------------------
1334
1335 // complex
1336
1337 //--- complex --------- matrix-matrix ----------------------
1338
1339 //--- complex --------- matrix-scalar ----------------------
1340
1341 //--- complex --------- matrix-vector ----------------------
1342
1343 // --- complex x real ----------------
1344 // -- complex x interval ----------------------
1345 // ---- complex x interval --- scalar--------
1346
1347
1348 // ---- complex x interval --- vector --------
1349 // ---- complex x interval --- matrix ------------
1350
1351 // complex x complex --------------------
1352
1353
1354#endif
1355
1356 //-------------------------- Konstruktoren ----------------------------
1357
1358// cinterval
1360 INLINE cimatrix(const cimatrix &rm) noexcept;
1362 INLINE cimatrix(const cimatrix_slice &rm) noexcept;
1364 INLINE cimatrix(const scimatrix &rm);
1366 INLINE cimatrix(const scimatrix_slice &rm);
1368 INLINE cimatrix() noexcept;
1370 explicit INLINE cimatrix(const int &m, const int &n)
1371#if(CXSC_INDEX_CHECK)
1372;
1373#else
1374 noexcept;
1375#endif
1377 explicit INLINE cimatrix(const int &m1, const int &n1, const int &m2, const int &n2)
1378#if(CXSC_INDEX_CHECK)
1379;
1380#else
1381 noexcept;
1382#endif
1384 explicit INLINE cimatrix(const civector &v) noexcept;
1386 explicit INLINE cimatrix(const civector_slice &v) noexcept;
1388 explicit INLINE cimatrix(const cinterval &r) noexcept;
1390 INLINE cimatrix &operator =(const cinterval &r) noexcept;
1392 INLINE cimatrix &operator =(const cimatrix &m) noexcept;
1394 INLINE cimatrix &operator =(const cimatrix_slice &ms) noexcept;
1396 INLINE cimatrix &operator =(const scimatrix &m);
1398 INLINE cimatrix &operator =(const scimatrix_slice &ms);
1400 INLINE cimatrix &operator =(const civector &v) noexcept;
1402 INLINE cimatrix &operator =(const civector_slice &v) noexcept;
1403// real
1405 explicit INLINE cimatrix(const real &r) noexcept;
1407 explicit INLINE cimatrix(const rmatrix &rm) noexcept;
1409 explicit INLINE cimatrix(const rmatrix_slice &rm) noexcept;
1411 explicit INLINE cimatrix(const srmatrix &rm);
1413 explicit INLINE cimatrix(const srmatrix_slice &rm);
1415 explicit INLINE cimatrix(const rvector &v) noexcept;
1417 explicit INLINE cimatrix(const rvector_slice &v) noexcept;
1419 INLINE cimatrix &operator =(const real &r) noexcept;
1421 INLINE cimatrix &operator =(const rmatrix &m) noexcept;
1423 INLINE cimatrix &operator =(const rmatrix_slice &ms) noexcept;
1425 INLINE cimatrix &operator =(const srmatrix &m);
1427 INLINE cimatrix &operator =(const srmatrix_slice &ms);
1429 INLINE cimatrix &operator =(const rvector &v) noexcept;
1431 INLINE cimatrix &operator =(const rvector_slice &v) noexcept;
1432
1433// complex
1435 explicit INLINE cimatrix(const complex &r) noexcept;
1437 explicit INLINE cimatrix(const cmatrix &rm) noexcept;
1439 explicit INLINE cimatrix(const cmatrix_slice &rm) noexcept;
1441 explicit INLINE cimatrix(const scmatrix &rm);
1443 explicit INLINE cimatrix(const scmatrix_slice &rm);
1445 explicit INLINE cimatrix(const cvector &v) noexcept;
1447 explicit INLINE cimatrix(const cvector_slice &v) noexcept;
1449 INLINE cimatrix &operator =(const complex &r) noexcept;
1451 INLINE cimatrix &operator =(const cmatrix &m) noexcept;
1453 INLINE cimatrix &operator =(const cmatrix_slice &ms) noexcept;
1455 INLINE cimatrix &operator =(const scmatrix &m);
1457 INLINE cimatrix &operator =(const scmatrix_slice &ms);
1459 INLINE cimatrix &operator =(const cvector &v) noexcept;
1461 INLINE cimatrix &operator =(const cvector_slice &v) noexcept;
1462
1463// interval
1465 explicit INLINE cimatrix(const interval &r) noexcept;
1467 explicit INLINE cimatrix(const imatrix &rm) noexcept;
1469 explicit INLINE cimatrix(const imatrix_slice &rm) noexcept;
1471 explicit INLINE cimatrix(const simatrix &rm);
1473 explicit INLINE cimatrix(const simatrix_slice &rm);
1475 explicit INLINE cimatrix(const ivector &v) noexcept;
1477 explicit INLINE cimatrix(const ivector_slice &v) noexcept;
1479 INLINE cimatrix &operator =(const interval &r) noexcept;
1481 INLINE cimatrix &operator =(const imatrix &m) noexcept;
1483 INLINE cimatrix &operator =(const imatrix_slice &ms) noexcept;
1485 INLINE cimatrix &operator =(const simatrix &m);
1487 INLINE cimatrix &operator =(const simatrix_slice &ms);
1489 INLINE cimatrix &operator =(const ivector &v) noexcept;
1491 INLINE cimatrix &operator =(const ivector_slice &v) noexcept;
1492
1493 //--------------------------- Destruktoren -----------------------------
1494
1495 INLINE ~cimatrix() noexcept { delete [] dat; }
1496
1497 //--------------------------- Operatoren -----------------------------
1499 INLINE cimatrix &operator +=(const scimatrix &m1);
1501 INLINE cimatrix &operator +=(const scimatrix_slice &m1);
1503 INLINE cimatrix &operator -=(const scimatrix &m1);
1505 INLINE cimatrix &operator -=(const scimatrix_slice &m1);
1507 INLINE cimatrix &operator |=(const scimatrix &m1);
1509 INLINE cimatrix &operator |=(const scimatrix_slice &m1);
1511 INLINE cimatrix &operator &=(const scimatrix &m1);
1513 INLINE cimatrix &operator &=(const scimatrix_slice &m1);
1515 INLINE cimatrix &operator *=(const scimatrix &m1);
1517 INLINE cimatrix &operator *=(const scimatrix_slice &m1);
1518
1520 INLINE cimatrix &operator +=(const srmatrix &m1);
1522 INLINE cimatrix &operator +=(const srmatrix_slice &m1);
1524 INLINE cimatrix &operator -=(const srmatrix &m1);
1526 INLINE cimatrix &operator -=(const srmatrix_slice &m1);
1528 INLINE cimatrix &operator |=(const srmatrix &m1);
1530 INLINE cimatrix &operator |=(const srmatrix_slice &m1);
1532 INLINE cimatrix &operator &=(const srmatrix &m1);
1536 INLINE cimatrix &operator *=(const srmatrix &m1);
1538 INLINE cimatrix &operator *=(const srmatrix_slice &m1);
1539
1541 INLINE cimatrix &operator +=(const scmatrix &m1);
1543 INLINE cimatrix &operator +=(const scmatrix_slice &m1);
1545 INLINE cimatrix &operator -=(const scmatrix &m1);
1547 INLINE cimatrix &operator -=(const scmatrix_slice &m1);
1549 INLINE cimatrix &operator |=(const scmatrix &m1);
1551 INLINE cimatrix &operator |=(const scmatrix_slice &m1);
1553 INLINE cimatrix &operator &=(const scmatrix &m1);
1557 INLINE cimatrix &operator *=(const scmatrix &m1);
1559 INLINE cimatrix &operator *=(const scmatrix_slice &m1);
1560
1562 INLINE cimatrix &operator +=(const simatrix &m1);
1564 INLINE cimatrix &operator +=(const simatrix_slice &m1);
1566 INLINE cimatrix &operator -=(const simatrix &m1);
1568 INLINE cimatrix &operator -=(const simatrix_slice &m1);
1570 INLINE cimatrix &operator |=(const simatrix &m1);
1572 INLINE cimatrix &operator |=(const simatrix_slice &m1);
1574 INLINE cimatrix &operator &=(const simatrix &m1);
1576 INLINE cimatrix &operator &=(const simatrix_slice &m1);
1578 INLINE cimatrix &operator *=(const simatrix &m1);
1580 INLINE cimatrix &operator *=(const simatrix_slice &m1);
1581
1583 INLINE cimatrix operator()(const intvector& p, const intvector& q);
1585 INLINE cimatrix operator()(const intmatrix& P, const intmatrix& Q);
1587 INLINE cimatrix operator()(const intvector& p);
1589 INLINE cimatrix operator()(const intmatrix& P);
1590
1591 //------------------------- Standardfunktionen -------------------------
1592
1594 INLINE cimatrix_subv operator [](const int &i) const
1595#if(CXSC_INDEX_CHECK)
1596;
1597#else
1598 noexcept;
1599#endif
1601 INLINE cimatrix_subv operator [](const cxscmatrix_column &i) const
1602#if(CXSC_INDEX_CHECK)
1603;
1604#else
1605 noexcept;
1606#endif
1608 INLINE cimatrix_subv operator [](const int &i)
1609#if(CXSC_INDEX_CHECK)
1610;
1611#else
1612 noexcept;
1613#endif
1615 INLINE cimatrix_subv operator [](const cxscmatrix_column &i)
1616#if(CXSC_INDEX_CHECK)
1617;
1618#else
1619 noexcept;
1620#endif
1621
1623 INLINE cimatrix &operator ()() noexcept { return *this; }
1625 INLINE cimatrix_slice operator ()(const int &m, const int &n)
1626#if(CXSC_INDEX_CHECK)
1627;
1628#else
1629 noexcept;
1630#endif
1632 INLINE cimatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
1633#if(CXSC_INDEX_CHECK)
1634;
1635#else
1636 noexcept;
1637#endif
1638 INLINE operator void*() noexcept;
1639//#else
1640//#endif
1641};
1642
1643
1645
1651{
1652 friend class cimatrix;
1653 private:
1654 cinterval *dat;
1655 int offset1,offset2,mxsize,mysize;
1656 int start1,end1,start2,end2,sxsize,sysize; // slice size
1657
1658 public:
1659//#if(CXSC_INDEX_CHECK)
1660#ifdef _CXSC_FRIEND_TPL
1661 //----------------- Templates ---------------------------------------
1662template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m)
1663#if(CXSC_INDEX_CHECK)
1664;
1665#else
1666 noexcept;
1667#endif
1668 template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m)
1669#if(CXSC_INDEX_CHECK)
1670 ;
1671#else
1672 noexcept;
1673#endif
1674 template <class MS1,class MS2> friend MS1 &_msmsassign(MS1 &ms1,const MS2 &ms)
1675#if(CXSC_INDEX_CHECK)
1676 ;
1677#else
1678 noexcept;
1679#endif
1680 template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) noexcept;
1681 template <class MS,class S> friend MS &_mssassign(MS &ms,const S &r) noexcept;
1682 template <class MS> friend int _mslb(const MS &ms, const int &i)
1683#if(CXSC_INDEX_CHECK)
1684;
1685#else
1686 noexcept;
1687#endif
1688 template <class MS> friend int _msub(const MS &ms, const int &i)
1689#if(CXSC_INDEX_CHECK)
1690;
1691#else
1692 noexcept;
1693#endif
1694 template <class MS,class E> friend E _msabs(const MS &ms) noexcept;
1695 template <class MS,class E> friend E _msinf(const MS &ms) noexcept;
1696 template <class MS,class E> friend E _mssup(const MS &ms) noexcept;
1697 template <class MS,class E> friend E _msdiam(const MS &ms) noexcept;
1698 template <class MS,class E> friend E _msmid(const MS &ms) noexcept;
1699 template <class MS,class E> friend E _msre(const MS &ms) noexcept;
1700 template <class MS,class E> friend E _msim(const MS &ms) noexcept;
1701 friend INLINE rmatrix SupRe(const cimatrix_slice &v) noexcept;
1702 friend INLINE rmatrix SupIm(const cimatrix_slice &v) noexcept;
1703 friend INLINE rmatrix InfRe(const cimatrix_slice &v) noexcept;
1704 friend INLINE rmatrix InfIm(const cimatrix_slice &v) noexcept;
1705 template <class MS1,class M2> friend MS1 &_msmsetre(MS1 &ms1,const M2 &m2)
1706#if(CXSC_INDEX_CHECK)
1707 ;
1708#else
1709 noexcept;
1710#endif
1711 template <class MS1,class M2> friend MS1 &_msmsetim(MS1 &ms1,const M2 &m2)
1712#if(CXSC_INDEX_CHECK)
1713 ;
1714#else
1715 noexcept;
1716#endif
1717 template <class MS1,class MS2> friend MS1 &_msmssetre(MS1 &ms1,const MS2 &ms2)
1718#if(CXSC_INDEX_CHECK)
1719 ;
1720#else
1721 noexcept;
1722#endif
1723 template <class MS1,class MS2> friend MS1 &_msmssetim(MS1 &ms1,const MS2 &ms2)
1724#if(CXSC_INDEX_CHECK)
1725 ;
1726#else
1727 noexcept;
1728#endif
1729 template <class MS1,class M2> friend MS1 &_msmsetinf(MS1 &ms1,const M2 &m2)
1730#if(CXSC_INDEX_CHECK)
1731 ;
1732#else
1733 noexcept;
1734#endif
1735 template <class MS1,class M2> friend MS1 &_msmsetsup(MS1 &ms1,const M2 &m2)
1736#if(CXSC_INDEX_CHECK)
1737 ;
1738#else
1739 noexcept;
1740#endif
1741 template <class MS1,class MS2> friend MS1 &_msmssetinf(MS1 &ms1,const MS2 &ms2)
1742#if(CXSC_INDEX_CHECK)
1743 ;
1744#else
1745 noexcept;
1746#endif
1747 template <class MS1,class MS2> friend MS1 &_msmssetsup(MS1 &ms1,const MS2 &ms2)
1748#if(CXSC_INDEX_CHECK)
1749 ;
1750#else
1751 noexcept;
1752#endif
1753 template <class MS1,class M2> friend MS1 &_msmusetinf(MS1 &ms1,const M2 &m2)
1754#if(CXSC_INDEX_CHECK)
1755 ;
1756#else
1757 noexcept;
1758#endif
1759 template <class MS1,class M2> friend MS1 &_msmusetsup(MS1 &ms1,const M2 &m2)
1760#if(CXSC_INDEX_CHECK)
1761 ;
1762#else
1763 noexcept;
1764#endif
1765 template <class MS1,class MS2> friend MS1 &_msmsusetinf(MS1 &ms1,const MS2 &ms2)
1766#if(CXSC_INDEX_CHECK)
1767 ;
1768#else
1769 noexcept;
1770#endif
1771 template <class MS1,class MS2> friend MS1 &_msmsusetsup(MS1 &ms1,const MS2 &ms2)
1772#if(CXSC_INDEX_CHECK)
1773 ;
1774#else
1775 noexcept;
1776#endif
1777 //-------- matrix-matrix --------------
1778 template <class MS,class E> friend E _msminus(const MS &ms) noexcept;
1779 template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms)
1780#if(CXSC_INDEX_CHECK)
1781 ;
1782#else
1783 noexcept;
1784#endif
1785 template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2)
1786#if(CXSC_INDEX_CHECK)
1787 ;
1788#else
1789 noexcept;
1790#endif
1791 template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms)
1792#if(CXSC_INDEX_CHECK)
1793 ;
1794#else
1795 noexcept;
1796#endif
1797 template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1)
1798#if(CXSC_INDEX_CHECK)
1799 ;
1800#else
1801 noexcept;
1802#endif
1803 template <class MS1,class MS2> friend MS1 &_msmsplusassign(MS1 &ms1,const MS2 &ms2)
1804#if(CXSC_INDEX_CHECK)
1805 ;
1806#else
1807 noexcept;
1808#endif
1809 template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms)
1810#if(CXSC_INDEX_CHECK)
1811 ;
1812#else
1813 noexcept;
1814#endif
1815 template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m)
1816#if(CXSC_INDEX_CHECK)
1817 ;
1818#else
1819 noexcept;
1820#endif
1821 template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2)
1822#if(CXSC_INDEX_CHECK)
1823 ;
1824#else
1825 noexcept;
1826#endif
1827 template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms)
1828#if(CXSC_INDEX_CHECK)
1829 ;
1830#else
1831 noexcept;
1832#endif
1833 template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1)
1834#if(CXSC_INDEX_CHECK)
1835 ;
1836#else
1837 noexcept;
1838#endif
1839 template <class MS1,class MS2> friend MS1 &_msmsminusassign(MS1 &ms1,const MS2 &ms2)
1840#if(CXSC_INDEX_CHECK)
1841 ;
1842#else
1843 noexcept;
1844#endif
1845 template <class M,class MS,class E> friend E _mmscimult(const M &m1, const MS &ms)
1846#if(CXSC_INDEX_CHECK)
1847 ;
1848#else
1849 noexcept;
1850#endif
1851 template <class MS,class M,class E> friend E _msmcimult(const MS &ms, const M &m2)
1852#if(CXSC_INDEX_CHECK)
1853 ;
1854#else
1855 noexcept;
1856#endif
1857 template <class M,class MS,class S> friend M &_mmscimultassign(M &m1,const MS &ms)
1858#if(CXSC_INDEX_CHECK)
1859 ;
1860#else
1861 noexcept;
1862#endif
1863 template <class MS1,class MS2,class E> friend E _msmscimult(const MS1 &ms1, const MS2 &ms2)
1864#if(CXSC_INDEX_CHECK)
1865 ;
1866#else
1867 noexcept;
1868#endif
1869 template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms)
1870#if(CXSC_INDEX_CHECK)
1871 ;
1872#else
1873 noexcept;
1874#endif
1875 template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms)
1876#if(CXSC_INDEX_CHECK)
1877 ;
1878#else
1879 noexcept;
1880#endif
1881 template <class MS,class M> friend MS &_msmconvassign(MS &ms,const M &m1)
1882#if(CXSC_INDEX_CHECK)
1883 ;
1884#else
1885 noexcept;
1886#endif
1887 template <class MS1,class MS2> friend MS1 &_msmsconvassign(MS1 &ms1,const MS2 &ms2)
1888#if(CXSC_INDEX_CHECK)
1889 ;
1890#else
1891 noexcept;
1892#endif
1893 template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2)
1894#if(CXSC_INDEX_CHECK)
1895 ;
1896#else
1897 noexcept;
1898#endif
1899 template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms)
1900#if(CXSC_INDEX_CHECK)
1901 ;
1902#else
1903 noexcept;
1904#endif
1905 template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms)
1906#if(CXSC_INDEX_CHECK)
1907 ;
1908#else
1909 noexcept;
1910#endif
1911 template <class MS,class M> friend MS &_msmsectassign(MS &ms,const M &m1)
1912#if(CXSC_INDEX_CHECK)
1913 ;
1914#else
1915 noexcept;
1916#endif
1917 template <class MS1,class MS2> friend MS1 &_msmssectassign(MS1 &ms1,const MS2 &ms2)
1918#if(CXSC_INDEX_CHECK)
1919 ;
1920#else
1921 noexcept;
1922#endif
1923 template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2)
1924#if(CXSC_INDEX_CHECK)
1925 ;
1926#else
1927 noexcept;
1928#endif
1929 //--------- matrix-vector --------------
1930 template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v)
1931#if(CXSC_INDEX_CHECK)
1932 ;
1933#else
1934 noexcept;
1935#endif
1936 template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms)
1937#if(CXSC_INDEX_CHECK)
1938 ;
1939#else
1940 noexcept;
1941#endif
1942 template <class V,class MS,class S> friend V &_vmscimultassign(V &v,const MS &ms)
1943#if(CXSC_INDEX_CHECK)
1944 ;
1945#else
1946 noexcept;
1947#endif
1948 //--------- matrix-scalar --------------
1949 template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) noexcept;
1950 template <class MS,class S> friend MS &_mssmultassign(MS &ms,const S &c) noexcept;
1951 template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) noexcept;
1952 template <class MS,class S> friend MS &_mssdivassign(MS &ms,const S &c) noexcept;
1953
1954 template <class MS> friend void *_msvoid(const MS &ms) noexcept;
1955 template <class MS> friend bool _msnot(const MS &ms) noexcept;
1956 template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) noexcept;
1957 template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) noexcept;
1958 template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) noexcept;
1959 template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) noexcept;
1960 template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) noexcept;
1961 template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) noexcept;
1962 template <class MS1,class MS2> friend bool _msmseq(const MS1 &ms1,const MS2 &ms2) noexcept;
1963 template <class MS1,class MS2> friend bool _msmsneq(const MS1 &ms1,const MS2 &ms2) noexcept;
1964 template <class MS1,class MS2> friend bool _msmsless(const MS1 &ms1,const MS2 &ms2) noexcept;
1965 template <class MS1,class MS2> friend bool _msmsleq(const MS1 &ms1,const MS2 &ms2) noexcept;
1966 template <class MS> friend std::ostream &_msout(std::ostream &s,const MS &r) noexcept;
1967 template <class MS> friend std::istream &_msin(std::istream &s,MS &r) noexcept;
1968
1969 // Real
1970
1971 //--- Real ------------ matrix-scalar -----------
1972
1973
1974 //--- Real ------------ matrix-vector -----------
1975
1976 //--- Real ------------ matrix-matrix -----------
1977
1978 // interval
1979
1980 //--- interval ------------ matrix-scalar -----------
1981
1982
1983 //--- interval ------------ matrix-vector -----------
1984
1985 //--- interval ------------ matrix-matrix -----------
1986
1987 // complex
1988
1989 //--- complex ------------ matrix-scalar -----------
1990
1991
1992 //--- complex ------------ matrix-vector -----------
1993
1994
1995 //--- complex ------------ matrix-matrix -----------
1996
1997
1998#endif
1999
2000 //--------------- Konstruktoren ----------------------------------------
2001
2003 explicit INLINE cimatrix_slice(cimatrix &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) { }
2005 explicit INLINE cimatrix_slice(cimatrix_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) { }
2006 public:
2008 INLINE cimatrix_slice(const cimatrix_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) { }
2009 public:
2010
2011 //---------------- Standardfunktionen -----------------------------------
2012
2013 friend INLINE civector::civector(const cimatrix_slice &sl)
2014#if(CXSC_INDEX_CHECK)
2015;
2016#else
2017 noexcept;
2018#endif
2019 friend INLINE cimatrix::cimatrix(const cimatrix_slice &) noexcept;
2021 INLINE cimatrix_slice &operator =(const cimatrix &m)
2022#if(CXSC_INDEX_CHECK)
2023;
2024#else
2025 noexcept;
2026#endif
2028 INLINE cimatrix_slice &operator =(const cimatrix_slice &ms)
2029#if(CXSC_INDEX_CHECK)
2030;
2031#else
2032 noexcept;
2033#endif
2035 INLINE cimatrix_slice &operator =(const cinterval &r) noexcept;
2037 INLINE cimatrix_slice &operator =(const scimatrix &v);
2041 INLINE cimatrix_slice &operator =(const scimatrix_slice &v);
2043 INLINE cimatrix_slice &operator =(const civector &v)
2044#if(CXSC_INDEX_CHECK)
2045;
2046#else
2047 noexcept;
2048#endif
2050 INLINE cimatrix_slice &operator =(const civector_slice &v)
2051#if(CXSC_INDEX_CHECK)
2052;
2053#else
2054 noexcept;
2055#endif
2057 INLINE cimatrix_slice &operator =(const cimatrix_subv &v)
2058#if(CXSC_INDEX_CHECK)
2059;
2060#else
2061 noexcept;
2062#endif
2063 // real
2065 INLINE cimatrix_slice &operator =(const srmatrix &v);
2069 INLINE cimatrix_slice &operator =(const srmatrix_slice &v);
2071 INLINE cimatrix_slice &operator =(const rmatrix &m)
2072#if(CXSC_INDEX_CHECK)
2073;
2074#else
2075 noexcept;
2076#endif
2078 INLINE cimatrix_slice &operator =(const rmatrix_slice &ms)
2079#if(CXSC_INDEX_CHECK)
2080;
2081#else
2082 noexcept;
2083#endif
2085 INLINE cimatrix_slice &operator =(const real &r) noexcept;
2087 INLINE cimatrix_slice &operator =(const rvector &v)
2088#if(CXSC_INDEX_CHECK)
2089;
2090#else
2091 noexcept;
2092#endif
2094 INLINE cimatrix_slice &operator =(const rvector_slice &v)
2095#if(CXSC_INDEX_CHECK)
2096;
2097#else
2098 noexcept;
2099#endif
2101 INLINE cimatrix_slice &operator =(const rmatrix_subv &v)
2102#if(CXSC_INDEX_CHECK)
2103;
2104#else
2105 noexcept;
2106#endif
2107
2108 // interval
2112 INLINE cimatrix_slice &operator =(const simatrix &v);
2114 INLINE cimatrix_slice &operator =(const simatrix_slice &v);
2116 INLINE cimatrix_slice &operator =(const imatrix &m)
2117#if(CXSC_INDEX_CHECK)
2118;
2119#else
2120 noexcept;
2121#endif
2123 INLINE cimatrix_slice &operator =(const imatrix_slice &ms)
2124#if(CXSC_INDEX_CHECK)
2125;
2126#else
2127 noexcept;
2128#endif
2130 INLINE cimatrix_slice &operator =(const interval &r) noexcept;
2132 INLINE cimatrix_slice &operator =(const ivector &v)
2133#if(CXSC_INDEX_CHECK)
2134;
2135#else
2136 noexcept;
2137#endif
2139 INLINE cimatrix_slice &operator =(const ivector_slice &v)
2140#if(CXSC_INDEX_CHECK)
2141;
2142#else
2143 noexcept;
2144#endif
2146 INLINE cimatrix_slice &operator =(const imatrix_subv &v)
2147#if(CXSC_INDEX_CHECK)
2148;
2149#else
2150 noexcept;
2151#endif
2152
2153 // complex
2155 INLINE cimatrix_slice &operator =(const scmatrix &v);
2159 INLINE cimatrix_slice &operator =(const scmatrix_slice &v);
2161 INLINE cimatrix_slice &operator =(const cmatrix &m)
2162#if(CXSC_INDEX_CHECK)
2163;
2164#else
2165 noexcept;
2166#endif
2168 INLINE cimatrix_slice &operator =(const cmatrix_slice &ms)
2169#if(CXSC_INDEX_CHECK)
2170;
2171#else
2172 noexcept;
2173#endif
2175 INLINE cimatrix_slice &operator =(const complex &r) noexcept;
2177 INLINE cimatrix_slice &operator =(const cvector &v)
2178#if(CXSC_INDEX_CHECK)
2179;
2180#else
2181 noexcept;
2182#endif
2184 INLINE cimatrix_slice &operator =(const cvector_slice &v)
2185#if(CXSC_INDEX_CHECK)
2186;
2187#else
2188 noexcept;
2189#endif
2191 INLINE cimatrix_slice &operator =(const cmatrix_subv &v)
2192#if(CXSC_INDEX_CHECK)
2193;
2194#else
2195 noexcept;
2196#endif
2197
2199 INLINE cimatrix_subv operator [](const int &i)
2200#if(CXSC_INDEX_CHECK)
2201;
2202#else
2203 noexcept;
2204#endif
2206 INLINE cimatrix_subv operator [](const cxscmatrix_column &i)
2207#if(CXSC_INDEX_CHECK)
2208;
2209#else
2210 noexcept;
2211#endif
2212
2214 INLINE cimatrix_subv operator [](const int &i) const
2215#if(CXSC_INDEX_CHECK)
2216;
2217#else
2218 noexcept;
2219#endif
2221 INLINE cimatrix_subv operator [](const cxscmatrix_column &i) const
2222#if(CXSC_INDEX_CHECK)
2223;
2224#else
2225 noexcept;
2226#endif
2227
2229 INLINE cimatrix_slice &operator ()() noexcept { return *this; }
2231 INLINE cimatrix_slice operator ()(const int &m, const int &n)
2232#if(CXSC_INDEX_CHECK)
2233;
2234#else
2235 noexcept;
2236#endif
2238 INLINE cimatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
2239#if(CXSC_INDEX_CHECK)
2240;
2241#else
2242 noexcept;
2243#endif
2244 INLINE operator void*() noexcept;
2245
2247 INLINE cimatrix_slice &operator +=(const cinterval &c) noexcept;
2249 INLINE cimatrix_slice &operator -=(const cinterval &c) noexcept;
2251 INLINE cimatrix_slice &operator *=(const cinterval &c) noexcept;
2253 INLINE cimatrix_slice &operator /=(const cinterval &c) noexcept;
2255 INLINE cimatrix_slice &operator +=(const scimatrix &m1);
2257 INLINE cimatrix_slice &operator +=(const scimatrix_slice &m1);
2259 INLINE cimatrix_slice &operator -=(const scimatrix &m1);
2261 INLINE cimatrix_slice &operator -=(const scimatrix_slice &m1);
2263 INLINE cimatrix_slice &operator |=(const scimatrix &m1);
2265 INLINE cimatrix_slice &operator |=(const scimatrix_slice &m1);
2267 INLINE cimatrix_slice &operator &=(const scimatrix &m1);
2269 INLINE cimatrix_slice &operator &=(const scimatrix_slice &m1);
2271 INLINE cimatrix_slice &operator *=(const scimatrix &m1);
2273 INLINE cimatrix_slice &operator *=(const scimatrix_slice &m1);
2274
2276 INLINE cimatrix_slice &operator +=(const cimatrix &m1)
2277#if(CXSC_INDEX_CHECK)
2278;
2279#else
2280 noexcept;
2281#endif
2283 INLINE cimatrix_slice &operator +=(const cimatrix_slice &ms2)
2284#if(CXSC_INDEX_CHECK)
2285;
2286#else
2287 noexcept;
2288#endif
2290 INLINE cimatrix_slice &operator -=(const cimatrix &m1)
2291#if(CXSC_INDEX_CHECK)
2292;
2293#else
2294 noexcept;
2295#endif
2297 INLINE cimatrix_slice &operator -=(const cimatrix_slice &ms2)
2298#if(CXSC_INDEX_CHECK)
2299;
2300#else
2301 noexcept;
2302#endif
2304 INLINE cimatrix_slice &operator |=(const cimatrix &m1)
2305#if(CXSC_INDEX_CHECK)
2306;
2307#else
2308 noexcept;
2309#endif
2311 INLINE cimatrix_slice &operator |=(const cimatrix_slice &ms2)
2312#if(CXSC_INDEX_CHECK)
2313;
2314#else
2315 noexcept;
2316#endif
2318 INLINE cimatrix_slice &operator &=(const cimatrix &m1)
2319#if(CXSC_INDEX_CHECK)
2320;
2321#else
2322 noexcept;
2323#endif
2325 INLINE cimatrix_slice &operator &=(const cimatrix_slice &ms2)
2326#if(CXSC_INDEX_CHECK)
2327;
2328#else
2329 noexcept;
2330#endif
2332 INLINE cimatrix_slice &operator *=(const cimatrix &m)
2333#if(CXSC_INDEX_CHECK)
2334;
2335#else
2336 noexcept;
2337#endif
2339 INLINE cimatrix_slice &operator *=(const cimatrix_slice &ms2)
2340#if(CXSC_INDEX_CHECK)
2341;
2342#else
2343 noexcept;
2344#endif
2345
2347 INLINE cimatrix_slice &operator +=(const real &c) noexcept;
2349 INLINE cimatrix_slice &operator -=(const real &c) noexcept;
2351 INLINE cimatrix_slice &operator *=(const real &c) noexcept;
2353 INLINE cimatrix_slice &operator /=(const real &c) noexcept;
2355 INLINE cimatrix_slice &operator +=(const srmatrix &m1);
2357 INLINE cimatrix_slice &operator +=(const srmatrix_slice &m1);
2359 INLINE cimatrix_slice &operator -=(const srmatrix &m1);
2361 INLINE cimatrix_slice &operator -=(const srmatrix_slice &m1);
2363 INLINE cimatrix_slice &operator |=(const srmatrix &m1);
2365 INLINE cimatrix_slice &operator |=(const srmatrix_slice &m1);
2371 INLINE cimatrix_slice &operator *=(const srmatrix &m1);
2373 INLINE cimatrix_slice &operator *=(const srmatrix_slice &m1);
2374
2376 INLINE cimatrix_slice &operator +=(const rmatrix_slice &ms2)
2377#if(CXSC_INDEX_CHECK)
2378;
2379#else
2380 noexcept;
2381#endif
2383 INLINE cimatrix_slice &operator +=(const rmatrix &m1)
2384#if(CXSC_INDEX_CHECK)
2385;
2386#else
2387 noexcept;
2388#endif
2390 INLINE cimatrix_slice &operator -=(const rmatrix &m1)
2391#if(CXSC_INDEX_CHECK)
2392;
2393#else
2394 noexcept;
2395#endif
2397 INLINE cimatrix_slice &operator -=(const rmatrix_slice &ms2)
2398#if(CXSC_INDEX_CHECK)
2399;
2400#else
2401 noexcept;
2402#endif
2404 INLINE cimatrix_slice &operator |=(const rmatrix &m1)
2405#if(CXSC_INDEX_CHECK)
2406;
2407#else
2408 noexcept;
2409#endif
2411 INLINE cimatrix_slice &operator |=(const rmatrix_slice &ms2)
2412#if(CXSC_INDEX_CHECK)
2413;
2414#else
2415 noexcept;
2416#endif
2418 INLINE cimatrix_slice &operator &=(const rmatrix &m1)
2419#if(CXSC_INDEX_CHECK)
2420;
2421#else
2422 noexcept;
2423#endif
2425 INLINE cimatrix_slice &operator &=(const rmatrix_slice &ms2)
2426#if(CXSC_INDEX_CHECK)
2427;
2428#else
2429 noexcept;
2430#endif
2432 INLINE cimatrix_slice &operator *=(const rmatrix &m)
2433#if(CXSC_INDEX_CHECK)
2434;
2435#else
2436 noexcept;
2437#endif
2439 INLINE cimatrix_slice &operator *=(const rmatrix_slice &ms2)
2440#if(CXSC_INDEX_CHECK)
2441;
2442#else
2443 noexcept;
2444#endif
2445
2447 INLINE cimatrix_slice &operator +=(const complex &c) noexcept;
2449 INLINE cimatrix_slice &operator -=(const complex &c) noexcept;
2451 INLINE cimatrix_slice &operator *=(const complex &c) noexcept;
2453 INLINE cimatrix_slice &operator /=(const complex &c) noexcept;
2455 INLINE cimatrix_slice &operator +=(const scmatrix &m1);
2457 INLINE cimatrix_slice &operator +=(const scmatrix_slice &m1);
2459 INLINE cimatrix_slice &operator -=(const scmatrix &m1);
2461 INLINE cimatrix_slice &operator -=(const scmatrix_slice &m1);
2463 INLINE cimatrix_slice &operator |=(const scmatrix &m1);
2465 INLINE cimatrix_slice &operator |=(const scmatrix_slice &m1);
2471 INLINE cimatrix_slice &operator *=(const scmatrix &m1);
2473 INLINE cimatrix_slice &operator *=(const scmatrix_slice &m1);
2474
2476 INLINE cimatrix_slice &operator +=(const cmatrix_slice &ms2)
2477#if(CXSC_INDEX_CHECK)
2478;
2479#else
2480 noexcept;
2481#endif
2483 INLINE cimatrix_slice &operator +=(const cmatrix &m1)
2484#if(CXSC_INDEX_CHECK)
2485;
2486#else
2487 noexcept;
2488#endif
2490 INLINE cimatrix_slice &operator -=(const cmatrix &m1)
2491#if(CXSC_INDEX_CHECK)
2492;
2493#else
2494 noexcept;
2495#endif
2497 INLINE cimatrix_slice &operator -=(const cmatrix_slice &ms2)
2498#if(CXSC_INDEX_CHECK)
2499;
2500#else
2501 noexcept;
2502#endif
2504 INLINE cimatrix_slice &operator |=(const cmatrix &m1)
2505#if(CXSC_INDEX_CHECK)
2506;
2507#else
2508 noexcept;
2509#endif
2511 INLINE cimatrix_slice &operator |=(const cmatrix_slice &ms2)
2512#if(CXSC_INDEX_CHECK)
2513;
2514#else
2515 noexcept;
2516#endif
2518 INLINE cimatrix_slice &operator &=(const cmatrix &m1)
2519#if(CXSC_INDEX_CHECK)
2520;
2521#else
2522 noexcept;
2523#endif
2525 INLINE cimatrix_slice &operator &=(const cmatrix_slice &ms2)
2526#if(CXSC_INDEX_CHECK)
2527;
2528#else
2529 noexcept;
2530#endif
2532 INLINE cimatrix_slice &operator *=(const cmatrix &m)
2533#if(CXSC_INDEX_CHECK)
2534;
2535#else
2536 noexcept;
2537#endif
2539 INLINE cimatrix_slice &operator *=(const cmatrix_slice &ms2)
2540#if(CXSC_INDEX_CHECK)
2541;
2542#else
2543 noexcept;
2544#endif
2545
2547 INLINE cimatrix_slice &operator +=(const interval &c) noexcept;
2549 INLINE cimatrix_slice &operator -=(const interval &c) noexcept;
2551 INLINE cimatrix_slice &operator *=(const interval &c) noexcept;
2553 INLINE cimatrix_slice &operator /=(const interval &c) noexcept;
2555 INLINE cimatrix_slice &operator +=(const simatrix &m1);
2557 INLINE cimatrix_slice &operator +=(const simatrix_slice &m1);
2559 INLINE cimatrix_slice &operator -=(const simatrix &m1);
2561 INLINE cimatrix_slice &operator -=(const simatrix_slice &m1);
2563 INLINE cimatrix_slice &operator |=(const simatrix &m1);
2565 INLINE cimatrix_slice &operator |=(const simatrix_slice &m1);
2567 INLINE cimatrix_slice &operator &=(const simatrix &m1);
2569 INLINE cimatrix_slice &operator &=(const simatrix_slice &m1);
2571 INLINE cimatrix_slice &operator *=(const simatrix &m1);
2573 INLINE cimatrix_slice &operator *=(const simatrix_slice &m1);
2574
2576 INLINE cimatrix_slice &operator +=(const imatrix_slice &ms2)
2577#if(CXSC_INDEX_CHECK)
2578;
2579#else
2580 noexcept;
2581#endif
2583 INLINE cimatrix_slice &operator +=(const imatrix &m1)
2584#if(CXSC_INDEX_CHECK)
2585;
2586#else
2587 noexcept;
2588#endif
2590 INLINE cimatrix_slice &operator -=(const imatrix &m1)
2591#if(CXSC_INDEX_CHECK)
2592;
2593#else
2594 noexcept;
2595#endif
2597 INLINE cimatrix_slice &operator -=(const imatrix_slice &ms2)
2598#if(CXSC_INDEX_CHECK)
2599;
2600#else
2601 noexcept;
2602#endif
2604 INLINE cimatrix_slice &operator |=(const imatrix &m1)
2605#if(CXSC_INDEX_CHECK)
2606;
2607#else
2608 noexcept;
2609#endif
2611 INLINE cimatrix_slice &operator |=(const imatrix_slice &ms2)
2612#if(CXSC_INDEX_CHECK)
2613;
2614#else
2615 noexcept;
2616#endif
2618 INLINE cimatrix_slice &operator &=(const imatrix &m1)
2619#if(CXSC_INDEX_CHECK)
2620;
2621#else
2622 noexcept;
2623#endif
2625 INLINE cimatrix_slice &operator &=(const imatrix_slice &ms2)
2626#if(CXSC_INDEX_CHECK)
2627;
2628#else
2629 noexcept;
2630#endif
2632 INLINE cimatrix_slice &operator *=(const imatrix &m)
2633#if(CXSC_INDEX_CHECK)
2634;
2635#else
2636 noexcept;
2637#endif
2639 INLINE cimatrix_slice &operator *=(const imatrix_slice &ms2)
2640#if(CXSC_INDEX_CHECK)
2641;
2642#else
2643 noexcept;
2644#endif
2645
2646//#else
2647//#endif
2648};
2649
2650//================================================================
2651//====================== Subvector Functions =====================
2652
2653//=======================Vector / Scalar =========================
2654
2656 INLINE civector operator /(const cimatrix_subv &rv, const cinterval &s) noexcept;
2658 INLINE civector operator *(const cimatrix_subv &rv, const cinterval &s) noexcept;
2660 INLINE civector operator *(const cinterval &s, const cimatrix_subv &rv) noexcept;
2662 INLINE ivector abs(const cimatrix_subv &mv) noexcept;
2664 INLINE cvector diam(const cimatrix_subv &mv) noexcept;
2666 INLINE cvector mid(const cimatrix_subv &mv) noexcept;
2668 INLINE cvector Inf(const cimatrix_subv &mv) noexcept;
2670 INLINE cvector Sup(const cimatrix_subv &mv) noexcept;
2672 INLINE ivector Im(const cimatrix_subv &mv) noexcept;
2674 INLINE ivector Re(const cimatrix_subv &mv) noexcept;
2676 INLINE rmatrix SupRe(const cimatrix &v) noexcept;
2678 INLINE rmatrix SupIm(const cimatrix &v) noexcept;
2680 INLINE rmatrix InfRe(const cimatrix &v) noexcept;
2682 INLINE rmatrix InfIm(const cimatrix &v) noexcept;
2684 INLINE rmatrix SupRe(const cimatrix_slice &v) noexcept;
2686 INLINE rmatrix SupIm(const cimatrix_slice &v) noexcept;
2688 INLINE rmatrix InfRe(const cimatrix_slice &v) noexcept;
2690 INLINE rmatrix InfIm(const cimatrix_slice &v) noexcept;
2692 INLINE cimatrix_subv &SetInf(cimatrix_subv &iv,const cvector &rv)
2693#if(CXSC_INDEX_CHECK)
2694;
2695#else
2696 noexcept;
2697#endif
2699 INLINE cimatrix_subv &SetSup(cimatrix_subv &iv,const cvector &rv)
2700#if(CXSC_INDEX_CHECK)
2701;
2702#else
2703 noexcept;
2704#endif
2706 INLINE cimatrix_subv &UncheckedSetInf(cimatrix_subv &iv,const cvector &rv)
2707#if(CXSC_INDEX_CHECK)
2708;
2709#else
2710 noexcept;
2711#endif
2713 INLINE cimatrix_subv &UncheckedSetSup(cimatrix_subv &iv,const cvector &rv)
2714#if(CXSC_INDEX_CHECK)
2715;
2716#else
2717 noexcept;
2718#endif
2720 INLINE cimatrix_subv &SetIm(cimatrix_subv &iv,const ivector &rv)
2721#if(CXSC_INDEX_CHECK)
2722;
2723#else
2724 noexcept;
2725#endif
2727 INLINE cimatrix_subv &SetRe(cimatrix_subv &iv,const ivector &rv)
2728#if(CXSC_INDEX_CHECK)
2729;
2730#else
2731 noexcept;
2732#endif
2733
2735 INLINE cimatrix_subv &SetSup(cimatrix_subv &iv,const complex &r) noexcept;
2737 INLINE cimatrix_subv &SetInf(cimatrix_subv &iv,const complex &r) noexcept;
2739 INLINE cimatrix_subv &UncheckedSetSup(cimatrix_subv &iv,const complex &r) noexcept;
2741 INLINE cimatrix_subv &SetUncheckedInf(cimatrix_subv &iv,const complex &r) noexcept;
2743 INLINE cimatrix_subv &SetRe(cimatrix_subv &iv,const interval &r) noexcept;
2745 INLINE cimatrix_subv &SetIm(cimatrix_subv &iv,const interval &r) noexcept;
2746
2747//======================== Vector / Vector ========================
2748
2749
2751 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const cimatrix_subv &rv2)
2752#if(CXSC_INDEX_CHECK)
2753;
2754#else
2755 noexcept;
2756#endif
2758 void accumulate(cidotprecision &dp, const civector & rv1, const cimatrix_subv &rv2)
2759#if(CXSC_INDEX_CHECK)
2760;
2761#else
2762 noexcept;
2763#endif
2765 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const civector &rv2)
2766#if(CXSC_INDEX_CHECK)
2767;
2768#else
2769 noexcept;
2770#endif
2772 void accumulate(cidotprecision &dp, const civector_slice & sl1, const cimatrix_subv &rv2)
2773#if(CXSC_INDEX_CHECK)
2774;
2775#else
2776 noexcept;
2777#endif
2779 void accumulate(cidotprecision &dp, const civector_slice & sl1, const rmatrix_subv &rv2)
2780#if(CXSC_INDEX_CHECK)
2781;
2782#else
2783 noexcept;
2784#endif
2786 void accumulate(cidotprecision &dp, const civector_slice & sl1, const cmatrix_subv &rv2)
2787#if(CXSC_INDEX_CHECK)
2788;
2789#else
2790 noexcept;
2791#endif
2792
2794 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const civector_slice &sl2)
2795#if(CXSC_INDEX_CHECK)
2796;
2797#else
2798 noexcept;
2799#endif
2800
2802 INLINE cinterval operator *(const cimatrix_subv & rv1, const cimatrix_subv &rv2)
2803#if(CXSC_INDEX_CHECK)
2804;
2805#else
2806 noexcept;
2807#endif
2809 INLINE cinterval operator *(const civector & rv1, const cimatrix_subv &rv2)
2810#if(CXSC_INDEX_CHECK)
2811;
2812#else
2813 noexcept;
2814#endif
2816 INLINE cinterval operator *(const cimatrix_subv &rv1,const civector &rv2)
2817#if(CXSC_INDEX_CHECK)
2818;
2819#else
2820 noexcept;
2821#endif
2823 INLINE cinterval operator *(const civector_slice &sl,const cimatrix_subv &sv)
2824#if(CXSC_INDEX_CHECK)
2825;
2826#else
2827 noexcept;
2828#endif
2830 INLINE cinterval operator *(const cimatrix_subv &mv,const civector_slice &vs)
2831#if(CXSC_INDEX_CHECK)
2832;
2833#else
2834 noexcept;
2835#endif
2836
2838 INLINE civector operator +(const cimatrix_subv & rv1, const cimatrix_subv &rv2)
2839#if(CXSC_INDEX_CHECK)
2840;
2841#else
2842 noexcept;
2843#endif
2845 INLINE civector operator +(const cimatrix_subv &rv1,const civector &rv2)
2846#if(CXSC_INDEX_CHECK)
2847;
2848#else
2849 noexcept;
2850#endif
2852 INLINE civector operator +(const civector & rv1, const cimatrix_subv &rv2)
2853#if(CXSC_INDEX_CHECK)
2854;
2855#else
2856 noexcept;
2857#endif
2859 INLINE civector operator +(const civector_slice &sl,const cimatrix_subv &mv)
2860#if(CXSC_INDEX_CHECK)
2861;
2862#else
2863 noexcept;
2864#endif
2866 INLINE civector operator +(const cimatrix_subv &mv,const civector_slice &sl)
2867#if(CXSC_INDEX_CHECK)
2868;
2869#else
2870 noexcept;
2871#endif
2872
2874 INLINE civector operator -(const cimatrix_subv & rv1, const cimatrix_subv &rv2)
2875#if(CXSC_INDEX_CHECK)
2876;
2877#else
2878 noexcept;
2879#endif
2881 INLINE civector operator -(const civector & rv1, const cimatrix_subv &rv2)
2882#if(CXSC_INDEX_CHECK)
2883;
2884#else
2885 noexcept;
2886#endif
2888 INLINE civector operator -(const cimatrix_subv &rv1,const civector &rv2)
2889#if(CXSC_INDEX_CHECK)
2890;
2891#else
2892 noexcept;
2893#endif
2895 INLINE civector operator -(const civector_slice &sl,const cimatrix_subv &mv)
2896#if(CXSC_INDEX_CHECK)
2897;
2898#else
2899 noexcept;
2900#endif
2902 INLINE civector operator -(const cimatrix_subv &mv,const civector_slice &sl)
2903#if(CXSC_INDEX_CHECK)
2904;
2905#else
2906 noexcept;
2907#endif
2908
2909// real
2910
2912 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const rmatrix_subv &rv2)
2913#if(CXSC_INDEX_CHECK)
2914;
2915#else
2916 noexcept;
2917#endif
2919 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const rvector_slice &sl2)
2920#if(CXSC_INDEX_CHECK)
2921;
2922#else
2923 noexcept;
2924#endif
2926 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const rvector &rv2)
2927#if(CXSC_INDEX_CHECK)
2928;
2929#else
2930 noexcept;
2931#endif
2933 void accumulate(cidotprecision &dp, const rvector & rv1, const cimatrix_subv &rv2)
2934#if(CXSC_INDEX_CHECK)
2935;
2936#else
2937 noexcept;
2938#endif
2940 void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const cimatrix_subv &rv2)
2941#if(CXSC_INDEX_CHECK)
2942;
2943#else
2944 noexcept;
2945#endif
2947 void accumulate(cidotprecision &dp, const rvector_slice & sl1, const cimatrix_subv &rv2)
2948#if(CXSC_INDEX_CHECK)
2949;
2950#else
2951 noexcept;
2952#endif
2953
2954// complex
2955
2957 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const cmatrix_subv &rv2)
2958#if(CXSC_INDEX_CHECK)
2959;
2960#else
2961 noexcept;
2962#endif
2964 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const cvector_slice &sl2)
2965#if(CXSC_INDEX_CHECK)
2966;
2967#else
2968 noexcept;
2969#endif
2971 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const cvector &rv2)
2972#if(CXSC_INDEX_CHECK)
2973;
2974#else
2975 noexcept;
2976#endif
2978 void accumulate(cidotprecision &dp, const cvector & rv1, const cimatrix_subv &rv2)
2979#if(CXSC_INDEX_CHECK)
2980;
2981#else
2982 noexcept;
2983#endif
2985 void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const cimatrix_subv &rv2)
2986#if(CXSC_INDEX_CHECK)
2987;
2988#else
2989 noexcept;
2990#endif
2992 void accumulate(cidotprecision &dp, const cvector_slice & sl1, const cimatrix_subv &rv2)
2993#if(CXSC_INDEX_CHECK)
2994;
2995#else
2996 noexcept;
2997#endif
2998
2999// interval
3000
3002 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const imatrix_subv &rv2)
3003#if(CXSC_INDEX_CHECK)
3004;
3005#else
3006 noexcept;
3007#endif
3009 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const ivector_slice &sl2)
3010#if(CXSC_INDEX_CHECK)
3011;
3012#else
3013 noexcept;
3014#endif
3016 void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const ivector &rv2)
3017#if(CXSC_INDEX_CHECK)
3018;
3019#else
3020 noexcept;
3021#endif
3023 void accumulate(cidotprecision &dp, const ivector & rv1, const cimatrix_subv &rv2)
3024#if(CXSC_INDEX_CHECK)
3025;
3026#else
3027 noexcept;
3028#endif
3030 void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const cimatrix_subv &rv2)
3031#if(CXSC_INDEX_CHECK)
3032;
3033#else
3034 noexcept;
3035#endif
3037 void accumulate(cidotprecision &dp, const ivector_slice & sl1, const cimatrix_subv &rv2)
3038#if(CXSC_INDEX_CHECK)
3039;
3040#else
3041 noexcept;
3042#endif
3044 void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const imatrix_subv &rv2)
3045#if(CXSC_INDEX_CHECK)
3046;
3047#else
3048 noexcept;
3049#endif
3051 void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const cmatrix_subv &rv2)
3052#if(CXSC_INDEX_CHECK)
3053;
3054#else
3055 noexcept;
3056#endif
3057
3058
3059//====================================================================
3060//===================== Matrix Functions =============================
3061
3063 INLINE cimatrix _imatrix(const cimatrix &rm) noexcept;
3065 INLINE cimatrix _imatrix(const civector &v) noexcept;
3067 INLINE cimatrix _imatrix(const civector_slice &v) noexcept;
3069 INLINE cimatrix _imatrix(const cinterval &r) noexcept;
3070
3072 INLINE int Lb(const cimatrix &rm, const int &i)
3073#if(CXSC_INDEX_CHECK)
3074;
3075#else
3076 noexcept;
3077#endif
3079 INLINE int Ub(const cimatrix &rm, const int &i)
3080#if(CXSC_INDEX_CHECK)
3081;
3082#else
3083 noexcept;
3084#endif
3086 INLINE int Lb(const cimatrix_slice &rm, const int &i)
3087#if(CXSC_INDEX_CHECK)
3088;
3089#else
3090 noexcept;
3091#endif
3093 INLINE int Ub(const cimatrix_slice &rm, const int &i)
3094#if(CXSC_INDEX_CHECK)
3095;
3096#else
3097 noexcept;
3098#endif
3100 INLINE cimatrix &SetLb(cimatrix &m, const int &i,const int &j)
3101#if(CXSC_INDEX_CHECK)
3102;
3103#else
3104 noexcept;
3105#endif
3107 INLINE cimatrix &SetUb(cimatrix &m, const int &i,const int &j)
3108#if(CXSC_INDEX_CHECK)
3109;
3110#else
3111 noexcept;
3112#endif
3114 INLINE void Resize(cimatrix &A) noexcept;
3116 INLINE void Resize(cimatrix &A,const int &m, const int &n)
3117#if(CXSC_INDEX_CHECK)
3118;
3119#else
3120 noexcept;
3121#endif
3123 INLINE void Resize(cimatrix &A,const int &m1, const int &m2,const int &n1,const int &n2)
3124#if(CXSC_INDEX_CHECK)
3125;
3126#else
3127 noexcept;
3128#endif
3129
3131 INLINE imatrix abs(const cimatrix &m) noexcept;
3133 INLINE imatrix abs(const cimatrix_slice &ms) noexcept;
3135 INLINE cmatrix diam(const cimatrix &m) noexcept;
3137 INLINE cmatrix diam(const cimatrix_slice &m) noexcept;
3139 INLINE cmatrix mid(const cimatrix &m) noexcept;
3141 INLINE cmatrix mid(const cimatrix_slice &m) noexcept;
3143 INLINE cmatrix Inf(const cimatrix &m) noexcept;
3145 INLINE cmatrix Sup(const cimatrix &m) noexcept;
3147 INLINE cmatrix Inf(const cimatrix_slice &m) noexcept;
3149 INLINE cmatrix Sup(const cimatrix_slice &m) noexcept;
3151 INLINE cimatrix &SetInf(cimatrix &cm,const cmatrix &rm)
3152#if(CXSC_INDEX_CHECK)
3153;
3154#else
3155 noexcept;
3156#endif
3158 INLINE cimatrix_slice &SetInf(cimatrix_slice &cm,const cmatrix &rm)
3159#if(CXSC_INDEX_CHECK)
3160;
3161#else
3162 noexcept;
3163#endif
3165 INLINE cimatrix &SetInf(cimatrix &cm,const cmatrix_slice &rm)
3166#if(CXSC_INDEX_CHECK)
3167;
3168#else
3169 noexcept;
3170#endif
3172 INLINE cimatrix_slice &SetInf(cimatrix_slice &cm,const cmatrix_slice &rm)
3173#if(CXSC_INDEX_CHECK)
3174;
3175#else
3176 noexcept;
3177#endif
3179 INLINE cimatrix &SetSup(cimatrix &cm,const cmatrix &rm)
3180#if(CXSC_INDEX_CHECK)
3181;
3182#else
3183 noexcept;
3184#endif
3186 INLINE cimatrix_slice &SetSup(cimatrix_slice &cm,const cmatrix &rm)
3187#if(CXSC_INDEX_CHECK)
3188;
3189#else
3190 noexcept;
3191#endif
3193 INLINE cimatrix &SetSup(cimatrix &cm,const cmatrix_slice &rm)
3194#if(CXSC_INDEX_CHECK)
3195;
3196#else
3197 noexcept;
3198#endif
3200 INLINE cimatrix_slice &SetSup(cimatrix_slice &cm,const cmatrix_slice &rm)
3201#if(CXSC_INDEX_CHECK)
3202;
3203#else
3204 noexcept;
3205#endif
3207 INLINE cimatrix &UncheckedSetInf(cimatrix &cm,const cmatrix &rm)
3208#if(CXSC_INDEX_CHECK)
3209;
3210#else
3211 noexcept;
3212#endif
3214 INLINE cimatrix_slice &UncheckedSetInf(cimatrix_slice &cm,const cmatrix &rm)
3215#if(CXSC_INDEX_CHECK)
3216;
3217#else
3218 noexcept;
3219#endif
3221 INLINE cimatrix &UncheckedSetInf(cimatrix &cm,const cmatrix_slice &rm)
3222#if(CXSC_INDEX_CHECK)
3223;
3224#else
3225 noexcept;
3226#endif
3228 INLINE cimatrix_slice &UncheckedSetInf(cimatrix_slice &cm,const cmatrix_slice &rm)
3229#if(CXSC_INDEX_CHECK)
3230;
3231#else
3232 noexcept;
3233#endif
3235 INLINE cimatrix &UncheckedSetSup(cimatrix &cm,const cmatrix &rm)
3236#if(CXSC_INDEX_CHECK)
3237;
3238#else
3239 noexcept;
3240#endif
3242 INLINE cimatrix_slice &UncheckedSetSup(cimatrix_slice &cm,const cmatrix &rm)
3243#if(CXSC_INDEX_CHECK)
3244;
3245#else
3246 noexcept;
3247#endif
3249 INLINE cimatrix &UncheckedSetSup(cimatrix &cm,const cmatrix_slice &rm)
3250#if(CXSC_INDEX_CHECK)
3251;
3252#else
3253 noexcept;
3254#endif
3256 INLINE cimatrix_slice &UncheckedSetSup(cimatrix_slice &cm,const cmatrix_slice &rm)
3257#if(CXSC_INDEX_CHECK)
3258;
3259#else
3260 noexcept;
3261#endif
3262
3264 INLINE imatrix Im(const cimatrix &m) noexcept;
3266 INLINE imatrix Re(const cimatrix &m) noexcept;
3268 INLINE imatrix Im(const cimatrix_slice &m) noexcept;
3270 INLINE imatrix Re(const cimatrix_slice &m) noexcept;
3272 INLINE cimatrix &SetIm(cimatrix &cm,const imatrix &rm)
3273#if(CXSC_INDEX_CHECK)
3274;
3275#else
3276 noexcept;
3277#endif
3279 INLINE cimatrix_slice &SetIm(cimatrix_slice &cm,const imatrix &rm)
3280#if(CXSC_INDEX_CHECK)
3281;
3282#else
3283 noexcept;
3284#endif
3286 INLINE cimatrix &SetIm(cimatrix &cm,const imatrix_slice &rm)
3287#if(CXSC_INDEX_CHECK)
3288;
3289#else
3290 noexcept;
3291#endif
3293 INLINE cimatrix_slice &SetIm(cimatrix_slice &cm,const imatrix_slice &rm)
3294#if(CXSC_INDEX_CHECK)
3295;
3296#else
3297 noexcept;
3298#endif
3300 INLINE cimatrix &SetRe(cimatrix &cm,const imatrix &rm)
3301#if(CXSC_INDEX_CHECK)
3302;
3303#else
3304 noexcept;
3305#endif
3307 INLINE cimatrix_slice &SetRe(cimatrix_slice &cm,const imatrix &rm)
3308#if(CXSC_INDEX_CHECK)
3309;
3310#else
3311 noexcept;
3312#endif
3314 INLINE cimatrix &SetRe(cimatrix &cm,const imatrix_slice &rm)
3315#if(CXSC_INDEX_CHECK)
3316;
3317#else
3318 noexcept;
3319#endif
3321 INLINE cimatrix_slice &SetRe(cimatrix_slice &cm,const imatrix_slice &rm)
3322#if(CXSC_INDEX_CHECK)
3323;
3324#else
3325 noexcept;
3326#endif
3327
3328//===================== Matrix / Scalar ===============================
3329
3331 INLINE cimatrix operator *(const cinterval &c, const cimatrix &m) noexcept;
3333 INLINE cimatrix operator *(const cinterval &c, const cimatrix_slice &ms) noexcept;
3335 INLINE cimatrix operator *(const cimatrix &m,const cinterval &c) noexcept;
3337 INLINE cimatrix operator *(const cimatrix_slice &ms,const cinterval &c) noexcept;
3339 INLINE cimatrix &operator *=(cimatrix &m,const cinterval &c) noexcept;
3341 INLINE cimatrix operator /(const cimatrix &m,const cinterval &c) noexcept;
3343 INLINE cimatrix operator /(const cimatrix_slice &ms, const cinterval &c) noexcept;
3345 INLINE cimatrix &operator /=(cimatrix &m,const cinterval &c) noexcept;
3346
3347//------------ real - cimatrix -----------------------------------------------
3348
3350 INLINE cimatrix operator *(const real &c, const cimatrix &m) noexcept;
3352 INLINE cimatrix operator *(const real &c, const cimatrix_slice &ms) noexcept;
3354 INLINE cimatrix operator *(const cimatrix &m,const real &c) noexcept;
3356 INLINE cimatrix operator *(const cimatrix_slice &ms,const real &c) noexcept;
3358 INLINE cimatrix &operator *=(cimatrix &m,const real &c) noexcept;
3360 INLINE cimatrix operator /(const cimatrix &m,const real &c) noexcept;
3362 INLINE cimatrix operator /(const cimatrix_slice &ms, const real &c) noexcept;
3364 INLINE cimatrix &operator /=(cimatrix &m,const real &c) noexcept;
3365//----------------- rmatrix - cinterval ----------------
3366
3368 INLINE cimatrix operator *(const cinterval &c, const rmatrix &m) noexcept;
3370 INLINE cimatrix operator *(const cinterval &c, const rmatrix_slice &ms) noexcept;
3372 INLINE cimatrix operator *(const rmatrix &m,const cinterval &c) noexcept;
3374 INLINE cimatrix operator *(const rmatrix_slice &ms,const cinterval &c) noexcept;
3376 INLINE cimatrix operator /(const rmatrix &m,const cinterval &c) noexcept;
3378 INLINE cimatrix operator /(const rmatrix_slice &ms, const cinterval &c) noexcept;
3379
3380//------------ complex - cimatrix -----------------------------------------------
3381
3383 INLINE cimatrix operator *(const complex &c, const cimatrix &m) noexcept;
3385 INLINE cimatrix operator *(const complex &c, const cimatrix_slice &ms) noexcept;
3387 INLINE cimatrix operator *(const cimatrix &m,const complex &c) noexcept;
3389 INLINE cimatrix operator *(const cimatrix_slice &ms,const complex &c) noexcept;
3391 INLINE cimatrix &operator *=(cimatrix &m,const complex &c) noexcept;
3393 INLINE cimatrix operator /(const cimatrix &m,const complex &c) noexcept;
3395 INLINE cimatrix operator /(const cimatrix_slice &ms, const complex &c) noexcept;
3397 INLINE cimatrix &operator /=(cimatrix &m,const complex &c) noexcept;
3398//----------------- cmatrix - cinterval ----------------
3399
3401 INLINE cimatrix operator *(const cinterval &c, const cmatrix &m) noexcept;
3403 INLINE cimatrix operator *(const cinterval &c, const cmatrix_slice &ms) noexcept;
3405 INLINE cimatrix operator *(const cmatrix &m,const cinterval &c) noexcept;
3407 INLINE cimatrix operator *(const cmatrix_slice &ms,const cinterval &c) noexcept;
3409 INLINE cimatrix operator /(const cmatrix &m,const cinterval &c) noexcept;
3411 INLINE cimatrix operator /(const cmatrix_slice &ms, const cinterval &c) noexcept;
3412
3413//------------ interval - cimatrix -----------------------------------------------
3414
3416 INLINE cimatrix operator *(const interval &c, const cimatrix &m) noexcept;
3418 INLINE cimatrix operator *(const interval &c, const cimatrix_slice &ms) noexcept;
3420 INLINE cimatrix operator *(const cimatrix &m,const interval &c) noexcept;
3422 INLINE cimatrix operator *(const cimatrix_slice &ms,const interval &c) noexcept;
3424 INLINE cimatrix &operator *=(cimatrix &m,const interval &c) noexcept;
3426 INLINE cimatrix operator /(const cimatrix &m,const interval &c) noexcept;
3428 INLINE cimatrix operator /(const cimatrix_slice &ms, const interval &c) noexcept;
3430 INLINE cimatrix &operator /=(cimatrix &m,const interval &c) noexcept;
3431//----------------- imatrix - cinterval ----------------
3432
3434 INLINE cimatrix operator *(const cinterval &c, const imatrix &m) noexcept;
3436 INLINE cimatrix operator *(const cinterval &c, const imatrix_slice &ms) noexcept;
3438 INLINE cimatrix operator *(const imatrix &m,const cinterval &c) noexcept;
3440 INLINE cimatrix operator *(const imatrix_slice &ms,const cinterval &c) noexcept;
3442 INLINE cimatrix operator /(const imatrix &m,const cinterval &c) noexcept;
3444 INLINE cimatrix operator /(const imatrix_slice &ms, const cinterval &c) noexcept;
3445
3446
3447//============================ Matrix / Vector ===================================
3448
3449
3451 INLINE civector operator *(const cimatrix &m,const civector &v)
3452#if(CXSC_INDEX_CHECK)
3453;
3454#else
3455 noexcept;
3456#endif
3458 INLINE civector operator *(const cimatrix_slice &ms,const civector &v)
3459#if(CXSC_INDEX_CHECK)
3460;
3461#else
3462 noexcept;
3463#endif
3465 INLINE civector operator *(const civector &v,const cimatrix &m)
3466#if(CXSC_INDEX_CHECK)
3467;
3468#else
3469 noexcept;
3470#endif
3472 INLINE civector operator *(const civector &v,const cimatrix_slice &ms)
3473#if(CXSC_INDEX_CHECK)
3474;
3475#else
3476 noexcept;
3477#endif
3479 INLINE civector &operator *=(civector &v,const cimatrix &m)
3480#if(CXSC_INDEX_CHECK)
3481;
3482#else
3483 noexcept;
3484#endif
3486 INLINE civector &operator *=(civector &v,const cimatrix_slice &ms)
3487#if(CXSC_INDEX_CHECK)
3488;
3489#else
3490 noexcept;
3491#endif
3492
3494 INLINE civector operator *(const civector_slice &v,const cimatrix &m)
3495#if(CXSC_INDEX_CHECK)
3496;
3497#else
3498 noexcept;
3499#endif
3501 INLINE civector operator *(const civector_slice &v,const cimatrix_slice &m)
3502#if(CXSC_INDEX_CHECK)
3503;
3504#else
3505 noexcept;
3506#endif
3507
3508//----------------- real -------------------------------------
3509
3511 INLINE civector operator *(const rvector &v,const cimatrix &m)
3512#if(CXSC_INDEX_CHECK)
3513;
3514#else
3515 noexcept;
3516#endif
3518 INLINE civector operator *(const rvector &v,const cimatrix_slice &ms)
3519#if(CXSC_INDEX_CHECK)
3520;
3521#else
3522 noexcept;
3523#endif
3525 INLINE civector operator *(const rvector_slice &v,const cimatrix &m)
3526#if(CXSC_INDEX_CHECK)
3527;
3528#else
3529 noexcept;
3530#endif
3531
3533 INLINE civector operator *(const cimatrix &m,const rvector &v)
3534#if(CXSC_INDEX_CHECK)
3535;
3536#else
3537 noexcept;
3538#endif
3540 INLINE civector operator *(const cimatrix_slice &ms,const rvector &v)
3541#if(CXSC_INDEX_CHECK)
3542;
3543#else
3544 noexcept;
3545#endif
3546
3547//----------------- complex -------------------------------------
3548
3550 INLINE civector operator *(const cvector &v,const cimatrix &m)
3551#if(CXSC_INDEX_CHECK)
3552;
3553#else
3554 noexcept;
3555#endif
3557 INLINE civector operator *(const cvector &v,const cimatrix_slice &ms)
3558#if(CXSC_INDEX_CHECK)
3559;
3560#else
3561 noexcept;
3562#endif
3564 INLINE civector operator *(const cvector_slice &v,const cimatrix &m)
3565#if(CXSC_INDEX_CHECK)
3566;
3567#else
3568 noexcept;
3569#endif
3570
3572 INLINE civector operator *(const cimatrix &m,const cvector &v)
3573#if(CXSC_INDEX_CHECK)
3574;
3575#else
3576 noexcept;
3577#endif
3579 INLINE civector operator *(const cimatrix_slice &ms,const cvector &v)
3580#if(CXSC_INDEX_CHECK)
3581;
3582#else
3583 noexcept;
3584#endif
3585
3586//----------------- interval -------------------------------------
3587
3589 INLINE civector operator *(const ivector &v,const cimatrix &m)
3590#if(CXSC_INDEX_CHECK)
3591;
3592#else
3593 noexcept;
3594#endif
3596 INLINE civector operator *(const ivector &v,const cimatrix_slice &ms)
3597#if(CXSC_INDEX_CHECK)
3598;
3599#else
3600 noexcept;
3601#endif
3603 INLINE civector operator *(const ivector_slice &v,const cimatrix &m)
3604#if(CXSC_INDEX_CHECK)
3605;
3606#else
3607 noexcept;
3608#endif
3609
3611 INLINE civector operator *(const cimatrix &m,const ivector &v)
3612#if(CXSC_INDEX_CHECK)
3613;
3614#else
3615 noexcept;
3616#endif
3618 INLINE civector operator *(const cimatrix_slice &ms,const ivector &v)
3619#if(CXSC_INDEX_CHECK)
3620;
3621#else
3622 noexcept;
3623#endif
3624
3625
3626//================ Matrix / Matrix ============================
3627
3629 INLINE const cimatrix &operator +(const cimatrix &m1) noexcept;
3631 INLINE cimatrix operator +(const cimatrix_slice &ms) noexcept;
3633 INLINE cimatrix operator +(const cimatrix &m1,const cimatrix &m2)
3634#if(CXSC_INDEX_CHECK)
3635;
3636#else
3637 noexcept;
3638#endif
3640 INLINE cimatrix operator +(const cimatrix &m,const cimatrix_slice &ms)
3641#if(CXSC_INDEX_CHECK)
3642;
3643#else
3644 noexcept;
3645#endif
3647 INLINE cimatrix operator +(const cimatrix_slice &ms,const cimatrix &m)
3648#if(CXSC_INDEX_CHECK)
3649;
3650#else
3651 noexcept;
3652#endif
3654 INLINE cimatrix operator +(const cimatrix_slice &m1,const cimatrix_slice &m2)
3655#if(CXSC_INDEX_CHECK)
3656;
3657#else
3658 noexcept;
3659#endif
3661 INLINE cimatrix &operator +=(cimatrix &m1,const cimatrix &m2)
3662#if(CXSC_INDEX_CHECK)
3663;
3664#else
3665 noexcept;
3666#endif
3668 INLINE cimatrix &operator +=(cimatrix &m1,const cimatrix_slice &ms)
3669#if(CXSC_INDEX_CHECK)
3670;
3671#else
3672 noexcept;
3673#endif
3674
3676 INLINE cimatrix operator -(const cimatrix &m) noexcept;
3678 INLINE cimatrix operator -(const cimatrix_slice &ms) noexcept;
3680 INLINE cimatrix operator -(const cimatrix &m1,const cimatrix &m2)
3681#if(CXSC_INDEX_CHECK)
3682;
3683#else
3684 noexcept;
3685#endif
3687 INLINE cimatrix operator -(const cimatrix &m,const cimatrix_slice &ms)
3688#if(CXSC_INDEX_CHECK)
3689;
3690#else
3691 noexcept;
3692#endif
3694 INLINE cimatrix operator -(const cimatrix_slice &ms,const cimatrix &m)
3695#if(CXSC_INDEX_CHECK)
3696;
3697#else
3698 noexcept;
3699#endif
3701 INLINE cimatrix operator -(const cimatrix_slice &ms1,const cimatrix_slice &ms2)
3702#if(CXSC_INDEX_CHECK)
3703;
3704#else
3705 noexcept;
3706#endif
3708 INLINE cimatrix &operator -=(cimatrix &m1,const cimatrix &m2)
3709#if(CXSC_INDEX_CHECK)
3710;
3711#else
3712 noexcept;
3713#endif
3715 INLINE cimatrix &operator -=(cimatrix &m1,const cimatrix_slice &ms)
3716#if(CXSC_INDEX_CHECK)
3717;
3718#else
3719 noexcept;
3720#endif
3721
3723 INLINE cimatrix operator *(const cimatrix &m1, const cimatrix &m2)
3724#if(CXSC_INDEX_CHECK)
3725;
3726#else
3727 noexcept;
3728#endif
3730 INLINE cimatrix operator *(const cimatrix &m1, const cimatrix_slice &ms)
3731#if(CXSC_INDEX_CHECK)
3732;
3733#else
3734 noexcept;
3735#endif
3737 INLINE cimatrix operator *(const cimatrix_slice &ms, const cimatrix &m1)
3738#if(CXSC_INDEX_CHECK)
3739;
3740#else
3741 noexcept;
3742#endif
3744 INLINE cimatrix operator *(const cimatrix_slice &ms1, const cimatrix_slice &ms2)
3745#if(CXSC_INDEX_CHECK)
3746;
3747#else
3748 noexcept;
3749#endif
3751 INLINE cimatrix &operator *=(cimatrix &m1,const cimatrix &m2)
3752#if(CXSC_INDEX_CHECK)
3753;
3754#else
3755 noexcept;
3756#endif
3758 INLINE cimatrix &operator *=(cimatrix &m1,const cimatrix_slice &ms)
3759#if(CXSC_INDEX_CHECK)
3760;
3761#else
3762 noexcept;
3763#endif
3764
3765
3767 INLINE cimatrix operator |(const cimatrix &m1,const cimatrix &m2)
3768#if(CXSC_INDEX_CHECK)
3769;
3770#else
3771 noexcept;
3772#endif
3774 INLINE cimatrix operator |(const cimatrix &m,const cimatrix_slice &ms)
3775#if(CXSC_INDEX_CHECK)
3776;
3777#else
3778 noexcept;
3779#endif
3781 INLINE cimatrix operator |(const cimatrix_slice &ms,const cimatrix &m)
3782#if(CXSC_INDEX_CHECK)
3783;
3784#else
3785 noexcept;
3786#endif
3788 INLINE cimatrix operator |(const cimatrix_slice &m1,const cimatrix_slice &m2)
3789#if(CXSC_INDEX_CHECK)
3790;
3791#else
3792 noexcept;
3793#endif
3795 INLINE cimatrix &operator |=(cimatrix &m1,const cimatrix &m2)
3796#if(CXSC_INDEX_CHECK)
3797;
3798#else
3799 noexcept;
3800#endif
3802 INLINE cimatrix &operator |=(cimatrix &m1,const cimatrix_slice &ms)
3803#if(CXSC_INDEX_CHECK)
3804;
3805#else
3806 noexcept;
3807#endif
3808
3810 INLINE cimatrix operator &(const cimatrix &m1,const cimatrix &m2)
3811#if(CXSC_INDEX_CHECK)
3812;
3813#else
3814 noexcept;
3815#endif
3817 INLINE cimatrix operator &(const cimatrix &m,const cimatrix_slice &ms)
3818#if(CXSC_INDEX_CHECK)
3819;
3820#else
3821 noexcept;
3822#endif
3824 INLINE cimatrix operator &(const cimatrix_slice &ms,const cimatrix &m)
3825#if(CXSC_INDEX_CHECK)
3826;
3827#else
3828 noexcept;
3829#endif
3831 INLINE cimatrix operator &(const cimatrix_slice &m1,const cimatrix_slice &m2)
3832#if(CXSC_INDEX_CHECK)
3833;
3834#else
3835 noexcept;
3836#endif
3838 INLINE cimatrix &operator &=(cimatrix &m1,const cimatrix &m2)
3839#if(CXSC_INDEX_CHECK)
3840;
3841#else
3842 noexcept;
3843#endif
3845 INLINE cimatrix &operator &=(cimatrix &m1,const cimatrix_slice &ms)
3846#if(CXSC_INDEX_CHECK)
3847;
3848#else
3849 noexcept;
3850#endif
3851
3852 //---------- rmatrix-cimatrix ------------------
3854 INLINE cimatrix operator +(const rmatrix &m1,const cimatrix &m2)
3855#if(CXSC_INDEX_CHECK)
3856;
3857#else
3858 noexcept;
3859#endif
3861 INLINE cimatrix operator +(const cimatrix &m1,const rmatrix &m2)
3862#if(CXSC_INDEX_CHECK)
3863;
3864#else
3865 noexcept;
3866#endif
3868 INLINE cimatrix operator +(const rmatrix &m,const cimatrix_slice &ms)
3869#if(CXSC_INDEX_CHECK)
3870;
3871#else
3872 noexcept;
3873#endif
3875 INLINE cimatrix operator +(const cimatrix &m,const rmatrix_slice &ms)
3876#if(CXSC_INDEX_CHECK)
3877;
3878#else
3879 noexcept;
3880#endif
3882 INLINE cimatrix operator +(const rmatrix_slice &ms,const cimatrix &m)
3883#if(CXSC_INDEX_CHECK)
3884;
3885#else
3886 noexcept;
3887#endif
3889 INLINE cimatrix operator +(const cimatrix_slice &ms,const rmatrix &m)
3890#if(CXSC_INDEX_CHECK)
3891;
3892#else
3893 noexcept;
3894#endif
3896 INLINE cimatrix operator +(const rmatrix_slice &m1,const cimatrix_slice &m2)
3897#if(CXSC_INDEX_CHECK)
3898;
3899#else
3900 noexcept;
3901#endif
3903 INLINE cimatrix operator +(const cimatrix_slice &m1,const rmatrix_slice &m2)
3904#if(CXSC_INDEX_CHECK)
3905;
3906#else
3907 noexcept;
3908#endif
3910 INLINE cimatrix &operator +=(cimatrix &m1,const rmatrix &m2)
3911#if(CXSC_INDEX_CHECK)
3912;
3913#else
3914 noexcept;
3915#endif
3917 INLINE cimatrix &operator +=(cimatrix &m1,const rmatrix_slice &ms)
3918#if(CXSC_INDEX_CHECK)
3919;
3920#else
3921 noexcept;
3922#endif
3923
3925 INLINE cimatrix operator -(const rmatrix &m1,const cimatrix &m2)
3926#if(CXSC_INDEX_CHECK)
3927;
3928#else
3929 noexcept;
3930#endif
3932 INLINE cimatrix operator -(const cimatrix &m1,const rmatrix &m2)
3933#if(CXSC_INDEX_CHECK)
3934;
3935#else
3936 noexcept;
3937#endif
3939 INLINE cimatrix operator -(const rmatrix &m,const cimatrix_slice &ms)
3940#if(CXSC_INDEX_CHECK)
3941;
3942#else
3943 noexcept;
3944#endif
3946 INLINE cimatrix operator -(const cimatrix &m,const rmatrix_slice &ms)
3947#if(CXSC_INDEX_CHECK)
3948;
3949#else
3950 noexcept;
3951#endif
3953 INLINE cimatrix operator -(const rmatrix_slice &ms,const cimatrix &m)
3954#if(CXSC_INDEX_CHECK)
3955;
3956#else
3957 noexcept;
3958#endif
3960 INLINE cimatrix operator -(const cimatrix_slice &ms,const rmatrix &m)
3961#if(CXSC_INDEX_CHECK)
3962;
3963#else
3964 noexcept;
3965#endif
3967 INLINE cimatrix operator -(const rmatrix_slice &ms1,const cimatrix_slice &ms2)
3968#if(CXSC_INDEX_CHECK)
3969;
3970#else
3971 noexcept;
3972#endif
3974 INLINE cimatrix operator -(const cimatrix_slice &ms1,const rmatrix_slice &ms2)
3975#if(CXSC_INDEX_CHECK)
3976;
3977#else
3978 noexcept;
3979#endif
3981 INLINE cimatrix &operator -=(cimatrix &m1,const rmatrix &m2)
3982#if(CXSC_INDEX_CHECK)
3983;
3984#else
3985 noexcept;
3986#endif
3988 INLINE cimatrix &operator -=(cimatrix &m1,const rmatrix_slice &ms)
3989#if(CXSC_INDEX_CHECK)
3990;
3991#else
3992 noexcept;
3993#endif
3994
3996 INLINE cimatrix operator *(const rmatrix &m1, const cimatrix &m2)
3997#if(CXSC_INDEX_CHECK)
3998;
3999#else
4000 noexcept;
4001#endif
4003 INLINE cimatrix operator *(const cimatrix &m1, const rmatrix &m2)
4004#if(CXSC_INDEX_CHECK)
4005;
4006#else
4007 noexcept;
4008#endif
4010 INLINE cimatrix operator *(const rmatrix &m1, const cimatrix_slice &ms)
4011#if(CXSC_INDEX_CHECK)
4012;
4013#else
4014 noexcept;
4015#endif
4017 INLINE cimatrix operator *(const cimatrix &m1, const rmatrix_slice &ms)
4018#if(CXSC_INDEX_CHECK)
4019;
4020#else
4021 noexcept;
4022#endif
4024 INLINE cimatrix operator *(const rmatrix_slice &ms, const cimatrix &m1)
4025#if(CXSC_INDEX_CHECK)
4026;
4027#else
4028 noexcept;
4029#endif
4031 INLINE cimatrix operator *(const cimatrix_slice &ms, const rmatrix &m1)
4032#if(CXSC_INDEX_CHECK)
4033;
4034#else
4035 noexcept;
4036#endif
4038 INLINE cimatrix operator *(const rmatrix_slice &ms1, const cimatrix_slice &ms2)
4039#if(CXSC_INDEX_CHECK)
4040;
4041#else
4042 noexcept;
4043#endif
4045 INLINE cimatrix operator *(const cimatrix_slice &ms1, const rmatrix_slice &ms2)
4046#if(CXSC_INDEX_CHECK)
4047;
4048#else
4049 noexcept;
4050#endif
4052 INLINE cimatrix &operator *=(cimatrix &m1,const rmatrix &m2)
4053#if(CXSC_INDEX_CHECK)
4054;
4055#else
4056 noexcept;
4057#endif
4059 INLINE cimatrix &operator *=(cimatrix &m1,const rmatrix_slice &ms)
4060#if(CXSC_INDEX_CHECK)
4061;
4062#else
4063 noexcept;
4064#endif
4065
4067 INLINE cimatrix operator |(const rmatrix &m1,const cimatrix &m2)
4068#if(CXSC_INDEX_CHECK)
4069;
4070#else
4071 noexcept;
4072#endif
4074 INLINE cimatrix operator |(const cimatrix &m1,const rmatrix &m2)
4075#if(CXSC_INDEX_CHECK)
4076;
4077#else
4078 noexcept;
4079#endif
4081 INLINE cimatrix operator |(const rmatrix &m,const cimatrix_slice &ms)
4082#if(CXSC_INDEX_CHECK)
4083;
4084#else
4085 noexcept;
4086#endif
4088 INLINE cimatrix operator |(const cimatrix &m,const rmatrix_slice &ms)
4089#if(CXSC_INDEX_CHECK)
4090;
4091#else
4092 noexcept;
4093#endif
4095 INLINE cimatrix operator |(const rmatrix_slice &ms,const cimatrix &m)
4096#if(CXSC_INDEX_CHECK)
4097;
4098#else
4099 noexcept;
4100#endif
4102 INLINE cimatrix operator |(const cimatrix_slice &ms,const rmatrix &m)
4103#if(CXSC_INDEX_CHECK)
4104;
4105#else
4106 noexcept;
4107#endif
4109 INLINE cimatrix operator |(const rmatrix_slice &m1,const cimatrix_slice &m2)
4110#if(CXSC_INDEX_CHECK)
4111;
4112#else
4113 noexcept;
4114#endif
4116 INLINE cimatrix operator |(const cimatrix_slice &m1,const rmatrix_slice &m2)
4117#if(CXSC_INDEX_CHECK)
4118;
4119#else
4120 noexcept;
4121#endif
4123 INLINE cimatrix &operator |=(cimatrix &m1,const rmatrix &m2)
4124#if(CXSC_INDEX_CHECK)
4125;
4126#else
4127 noexcept;
4128#endif
4130 INLINE cimatrix &operator |=(cimatrix &m1,const rmatrix_slice &ms)
4131#if(CXSC_INDEX_CHECK)
4132;
4133#else
4134 noexcept;
4135#endif
4136
4138 INLINE cimatrix operator &(const rmatrix &m1,const cimatrix &m2)
4139#if(CXSC_INDEX_CHECK)
4140;
4141#else
4142 noexcept;
4143#endif
4145 INLINE cimatrix operator &(const cimatrix &m1,const rmatrix &m2)
4146#if(CXSC_INDEX_CHECK)
4147;
4148#else
4149 noexcept;
4150#endif
4152 INLINE cimatrix operator &(const rmatrix &m,const cimatrix_slice &ms)
4153#if(CXSC_INDEX_CHECK)
4154;
4155#else
4156 noexcept;
4157#endif
4159 INLINE cimatrix operator &(const cimatrix &m,const rmatrix_slice &ms)
4160#if(CXSC_INDEX_CHECK)
4161;
4162#else
4163 noexcept;
4164#endif
4166 INLINE cimatrix operator &(const rmatrix_slice &ms,const cimatrix &m)
4167#if(CXSC_INDEX_CHECK)
4168;
4169#else
4170 noexcept;
4171#endif
4173 INLINE cimatrix operator &(const cimatrix_slice &ms,const rmatrix &m)
4174#if(CXSC_INDEX_CHECK)
4175;
4176#else
4177 noexcept;
4178#endif
4180 INLINE cimatrix operator &(const rmatrix_slice &m1,const cimatrix_slice &m2)
4181#if(CXSC_INDEX_CHECK)
4182;
4183#else
4184 noexcept;
4185#endif
4187 INLINE cimatrix operator &(const cimatrix_slice &m1,const rmatrix_slice &m2)
4188#if(CXSC_INDEX_CHECK)
4189;
4190#else
4191 noexcept;
4192#endif
4194 INLINE cimatrix &operator &=(cimatrix &m1,const rmatrix &m2)
4195#if(CXSC_INDEX_CHECK)
4196;
4197#else
4198 noexcept;
4199#endif
4201 INLINE cimatrix &operator &=(cimatrix &m1,const rmatrix_slice &ms)
4202#if(CXSC_INDEX_CHECK)
4203;
4204#else
4205 noexcept;
4206#endif
4207
4208 //---------- cmatrix-cimatrix ------------------
4210 INLINE cimatrix operator +(const cmatrix &m1,const cimatrix &m2)
4211#if(CXSC_INDEX_CHECK)
4212;
4213#else
4214 noexcept;
4215#endif
4217 INLINE cimatrix operator +(const cimatrix &m1,const cmatrix &m2)
4218#if(CXSC_INDEX_CHECK)
4219;
4220#else
4221 noexcept;
4222#endif
4224 INLINE cimatrix operator +(const cmatrix &m,const cimatrix_slice &ms)
4225#if(CXSC_INDEX_CHECK)
4226;
4227#else
4228 noexcept;
4229#endif
4231 INLINE cimatrix operator +(const cimatrix &m,const cmatrix_slice &ms)
4232#if(CXSC_INDEX_CHECK)
4233;
4234#else
4235 noexcept;
4236#endif
4238 INLINE cimatrix operator +(const cmatrix_slice &ms,const cimatrix &m)
4239#if(CXSC_INDEX_CHECK)
4240;
4241#else
4242 noexcept;
4243#endif
4245 INLINE cimatrix operator +(const cimatrix_slice &ms,const cmatrix &m)
4246#if(CXSC_INDEX_CHECK)
4247;
4248#else
4249 noexcept;
4250#endif
4252 INLINE cimatrix operator +(const cmatrix_slice &m1,const cimatrix_slice &m2)
4253#if(CXSC_INDEX_CHECK)
4254;
4255#else
4256 noexcept;
4257#endif
4259 INLINE cimatrix operator +(const cimatrix_slice &m1,const cmatrix_slice &m2)
4260#if(CXSC_INDEX_CHECK)
4261;
4262#else
4263 noexcept;
4264#endif
4266 INLINE cimatrix &operator +=(cimatrix &m1,const cmatrix &m2)
4267#if(CXSC_INDEX_CHECK)
4268;
4269#else
4270 noexcept;
4271#endif
4273 INLINE cimatrix &operator +=(cimatrix &m1,const cmatrix_slice &ms)
4274#if(CXSC_INDEX_CHECK)
4275;
4276#else
4277 noexcept;
4278#endif
4279
4281 INLINE cimatrix operator -(const cmatrix &m1,const cimatrix &m2)
4282#if(CXSC_INDEX_CHECK)
4283;
4284#else
4285 noexcept;
4286#endif
4288 INLINE cimatrix operator -(const cimatrix &m1,const cmatrix &m2)
4289#if(CXSC_INDEX_CHECK)
4290;
4291#else
4292 noexcept;
4293#endif
4295 INLINE cimatrix operator -(const cmatrix &m,const cimatrix_slice &ms)
4296#if(CXSC_INDEX_CHECK)
4297;
4298#else
4299 noexcept;
4300#endif
4302 INLINE cimatrix operator -(const cimatrix &m,const cmatrix_slice &ms)
4303#if(CXSC_INDEX_CHECK)
4304;
4305#else
4306 noexcept;
4307#endif
4309 INLINE cimatrix operator -(const cmatrix_slice &ms,const cimatrix &m)
4310#if(CXSC_INDEX_CHECK)
4311;
4312#else
4313 noexcept;
4314#endif
4316 INLINE cimatrix operator -(const cimatrix_slice &ms,const cmatrix &m)
4317#if(CXSC_INDEX_CHECK)
4318;
4319#else
4320 noexcept;
4321#endif
4323 INLINE cimatrix operator -(const cmatrix_slice &ms1,const cimatrix_slice &ms2)
4324#if(CXSC_INDEX_CHECK)
4325;
4326#else
4327 noexcept;
4328#endif
4330 INLINE cimatrix operator -(const cimatrix_slice &ms1,const cmatrix_slice &ms2)
4331#if(CXSC_INDEX_CHECK)
4332;
4333#else
4334 noexcept;
4335#endif
4337 INLINE cimatrix &operator -=(cimatrix &m1,const cmatrix &m2)
4338#if(CXSC_INDEX_CHECK)
4339;
4340#else
4341 noexcept;
4342#endif
4344 INLINE cimatrix &operator -=(cimatrix &m1,const cmatrix_slice &ms)
4345#if(CXSC_INDEX_CHECK)
4346;
4347#else
4348 noexcept;
4349#endif
4350
4352 INLINE cimatrix operator *(const cmatrix &m1, const cimatrix &m2)
4353#if(CXSC_INDEX_CHECK)
4354;
4355#else
4356 noexcept;
4357#endif
4359 INLINE cimatrix operator *(const cimatrix &m1, const cmatrix &m2)
4360#if(CXSC_INDEX_CHECK)
4361;
4362#else
4363 noexcept;
4364#endif
4366 INLINE cimatrix operator *(const cmatrix &m1, const cimatrix_slice &ms)
4367#if(CXSC_INDEX_CHECK)
4368;
4369#else
4370 noexcept;
4371#endif
4373 INLINE cimatrix operator *(const cimatrix &m1, const cmatrix_slice &ms)
4374#if(CXSC_INDEX_CHECK)
4375;
4376#else
4377 noexcept;
4378#endif
4380 INLINE cimatrix operator *(const cmatrix_slice &ms, const cimatrix &m1)
4381#if(CXSC_INDEX_CHECK)
4382;
4383#else
4384 noexcept;
4385#endif
4387 INLINE cimatrix operator *(const cimatrix_slice &ms, const cmatrix &m1)
4388#if(CXSC_INDEX_CHECK)
4389;
4390#else
4391 noexcept;
4392#endif
4394 INLINE cimatrix operator *(const cmatrix_slice &ms1, const cimatrix_slice &ms2)
4395#if(CXSC_INDEX_CHECK)
4396;
4397#else
4398 noexcept;
4399#endif
4401 INLINE cimatrix operator *(const cimatrix_slice &ms1, const cmatrix_slice &ms2)
4402#if(CXSC_INDEX_CHECK)
4403;
4404#else
4405 noexcept;
4406#endif
4408 INLINE cimatrix &operator *=(cimatrix &m1,const cmatrix &m2)
4409#if(CXSC_INDEX_CHECK)
4410;
4411#else
4412 noexcept;
4413#endif
4415 INLINE cimatrix &operator *=(cimatrix &m1,const cmatrix_slice &ms)
4416#if(CXSC_INDEX_CHECK)
4417;
4418#else
4419 noexcept;
4420#endif
4421
4423 INLINE cimatrix operator |(const cmatrix &m1,const cimatrix &m2)
4424#if(CXSC_INDEX_CHECK)
4425;
4426#else
4427 noexcept;
4428#endif
4430 INLINE cimatrix operator |(const cimatrix &m1,const cmatrix &m2)
4431#if(CXSC_INDEX_CHECK)
4432;
4433#else
4434 noexcept;
4435#endif
4437 INLINE cimatrix operator |(const cmatrix &m,const cimatrix_slice &ms)
4438#if(CXSC_INDEX_CHECK)
4439;
4440#else
4441 noexcept;
4442#endif
4444 INLINE cimatrix operator |(const cimatrix &m,const cmatrix_slice &ms)
4445#if(CXSC_INDEX_CHECK)
4446;
4447#else
4448 noexcept;
4449#endif
4451 INLINE cimatrix operator |(const cmatrix_slice &ms,const cimatrix &m)
4452#if(CXSC_INDEX_CHECK)
4453;
4454#else
4455 noexcept;
4456#endif
4458 INLINE cimatrix operator |(const cimatrix_slice &ms,const cmatrix &m)
4459#if(CXSC_INDEX_CHECK)
4460;
4461#else
4462 noexcept;
4463#endif
4465 INLINE cimatrix operator |(const cmatrix_slice &m1,const cimatrix_slice &m2)
4466#if(CXSC_INDEX_CHECK)
4467;
4468#else
4469 noexcept;
4470#endif
4472 INLINE cimatrix operator |(const cimatrix_slice &m1,const cmatrix_slice &m2)
4473#if(CXSC_INDEX_CHECK)
4474;
4475#else
4476 noexcept;
4477#endif
4479 INLINE cimatrix &operator |=(cimatrix &m1,const cmatrix &m2)
4480#if(CXSC_INDEX_CHECK)
4481;
4482#else
4483 noexcept;
4484#endif
4486 INLINE cimatrix &operator |=(cimatrix &m1,const cmatrix_slice &ms)
4487#if(CXSC_INDEX_CHECK)
4488;
4489#else
4490 noexcept;
4491#endif
4492
4494 INLINE cimatrix operator &(const cmatrix &m1,const cimatrix &m2)
4495#if(CXSC_INDEX_CHECK)
4496;
4497#else
4498 noexcept;
4499#endif
4501 INLINE cimatrix operator &(const cimatrix &m1,const cmatrix &m2)
4502#if(CXSC_INDEX_CHECK)
4503;
4504#else
4505 noexcept;
4506#endif
4508 INLINE cimatrix operator &(const cmatrix &m,const cimatrix_slice &ms)
4509#if(CXSC_INDEX_CHECK)
4510;
4511#else
4512 noexcept;
4513#endif
4515 INLINE cimatrix operator &(const cimatrix &m,const cmatrix_slice &ms)
4516#if(CXSC_INDEX_CHECK)
4517;
4518#else
4519 noexcept;
4520#endif
4522 INLINE cimatrix operator &(const cmatrix_slice &ms,const cimatrix &m)
4523#if(CXSC_INDEX_CHECK)
4524;
4525#else
4526 noexcept;
4527#endif
4529 INLINE cimatrix operator &(const cimatrix_slice &ms,const cmatrix &m)
4530#if(CXSC_INDEX_CHECK)
4531;
4532#else
4533 noexcept;
4534#endif
4536 INLINE cimatrix operator &(const cmatrix_slice &m1,const cimatrix_slice &m2)
4537#if(CXSC_INDEX_CHECK)
4538;
4539#else
4540 noexcept;
4541#endif
4543 INLINE cimatrix operator &(const cimatrix_slice &m1,const cmatrix_slice &m2)
4544#if(CXSC_INDEX_CHECK)
4545;
4546#else
4547 noexcept;
4548#endif
4550 INLINE cimatrix &operator &=(cimatrix &m1,const cmatrix &m2)
4551#if(CXSC_INDEX_CHECK)
4552;
4553#else
4554 noexcept;
4555#endif
4557 INLINE cimatrix &operator &=(cimatrix &m1,const cmatrix_slice &ms)
4558#if(CXSC_INDEX_CHECK)
4559;
4560#else
4561 noexcept;
4562#endif
4563
4564 //---------- imatrix-cimatrix ------------------
4566 INLINE cimatrix operator +(const imatrix &m1,const cimatrix &m2)
4567#if(CXSC_INDEX_CHECK)
4568;
4569#else
4570 noexcept;
4571#endif
4573 INLINE cimatrix operator +(const cimatrix &m1,const imatrix &m2)
4574#if(CXSC_INDEX_CHECK)
4575;
4576#else
4577 noexcept;
4578#endif
4580 INLINE cimatrix operator +(const imatrix &m,const cimatrix_slice &ms)
4581#if(CXSC_INDEX_CHECK)
4582;
4583#else
4584 noexcept;
4585#endif
4587 INLINE cimatrix operator +(const cimatrix &m,const imatrix_slice &ms)
4588#if(CXSC_INDEX_CHECK)
4589;
4590#else
4591 noexcept;
4592#endif
4594 INLINE cimatrix operator +(const imatrix_slice &ms,const cimatrix &m)
4595#if(CXSC_INDEX_CHECK)
4596;
4597#else
4598 noexcept;
4599#endif
4601 INLINE cimatrix operator +(const cimatrix_slice &ms,const imatrix &m)
4602#if(CXSC_INDEX_CHECK)
4603;
4604#else
4605 noexcept;
4606#endif
4608 INLINE cimatrix operator +(const imatrix_slice &m1,const cimatrix_slice &m2)
4609#if(CXSC_INDEX_CHECK)
4610;
4611#else
4612 noexcept;
4613#endif
4615 INLINE cimatrix operator +(const cimatrix_slice &m1,const imatrix_slice &m2)
4616#if(CXSC_INDEX_CHECK)
4617;
4618#else
4619 noexcept;
4620#endif
4622 INLINE cimatrix &operator +=(cimatrix &m1,const imatrix &m2)
4623#if(CXSC_INDEX_CHECK)
4624;
4625#else
4626 noexcept;
4627#endif
4629 INLINE cimatrix &operator +=(cimatrix &m1,const imatrix_slice &ms)
4630#if(CXSC_INDEX_CHECK)
4631;
4632#else
4633 noexcept;
4634#endif
4635
4637 INLINE cimatrix operator -(const imatrix &m1,const cimatrix &m2)
4638#if(CXSC_INDEX_CHECK)
4639;
4640#else
4641 noexcept;
4642#endif
4644 INLINE cimatrix operator -(const cimatrix &m1,const imatrix &m2)
4645#if(CXSC_INDEX_CHECK)
4646;
4647#else
4648 noexcept;
4649#endif
4651 INLINE cimatrix operator -(const imatrix &m,const cimatrix_slice &ms)
4652#if(CXSC_INDEX_CHECK)
4653;
4654#else
4655 noexcept;
4656#endif
4658 INLINE cimatrix operator -(const cimatrix &m,const imatrix_slice &ms)
4659#if(CXSC_INDEX_CHECK)
4660;
4661#else
4662 noexcept;
4663#endif
4665 INLINE cimatrix operator -(const imatrix_slice &ms,const cimatrix &m)
4666#if(CXSC_INDEX_CHECK)
4667;
4668#else
4669 noexcept;
4670#endif
4672 INLINE cimatrix operator -(const cimatrix_slice &ms,const imatrix &m)
4673#if(CXSC_INDEX_CHECK)
4674;
4675#else
4676 noexcept;
4677#endif
4679 INLINE cimatrix operator -(const imatrix_slice &ms1,const cimatrix_slice &ms2)
4680#if(CXSC_INDEX_CHECK)
4681;
4682#else
4683 noexcept;
4684#endif
4686 INLINE cimatrix operator -(const cimatrix_slice &ms1,const imatrix_slice &ms2)
4687#if(CXSC_INDEX_CHECK)
4688;
4689#else
4690 noexcept;
4691#endif
4693 INLINE cimatrix &operator -=(cimatrix &m1,const imatrix &m2)
4694#if(CXSC_INDEX_CHECK)
4695;
4696#else
4697 noexcept;
4698#endif
4700 INLINE cimatrix &operator -=(cimatrix &m1,const imatrix_slice &ms)
4701#if(CXSC_INDEX_CHECK)
4702;
4703#else
4704 noexcept;
4705#endif
4706
4708 INLINE cimatrix operator *(const imatrix &m1, const cimatrix &m2)
4709#if(CXSC_INDEX_CHECK)
4710;
4711#else
4712 noexcept;
4713#endif
4715 INLINE cimatrix operator *(const cimatrix &m1, const imatrix &m2)
4716#if(CXSC_INDEX_CHECK)
4717;
4718#else
4719 noexcept;
4720#endif
4722 INLINE cimatrix operator *(const imatrix &m1, const cimatrix_slice &ms)
4723#if(CXSC_INDEX_CHECK)
4724;
4725#else
4726 noexcept;
4727#endif
4729 INLINE cimatrix operator *(const cimatrix &m1, const imatrix_slice &ms)
4730#if(CXSC_INDEX_CHECK)
4731;
4732#else
4733 noexcept;
4734#endif
4736 INLINE cimatrix operator *(const imatrix_slice &ms, const cimatrix &m1)
4737#if(CXSC_INDEX_CHECK)
4738;
4739#else
4740 noexcept;
4741#endif
4743 INLINE cimatrix operator *(const cimatrix_slice &ms, const imatrix &m1)
4744#if(CXSC_INDEX_CHECK)
4745;
4746#else
4747 noexcept;
4748#endif
4750 INLINE cimatrix operator *(const imatrix_slice &ms1, const cimatrix_slice &ms2)
4751#if(CXSC_INDEX_CHECK)
4752;
4753#else
4754 noexcept;
4755#endif
4757 INLINE cimatrix operator *(const cimatrix_slice &ms1, const imatrix_slice &ms2)
4758#if(CXSC_INDEX_CHECK)
4759;
4760#else
4761 noexcept;
4762#endif
4764 INLINE cimatrix &operator *=(cimatrix &m1,const imatrix &m2)
4765#if(CXSC_INDEX_CHECK)
4766;
4767#else
4768 noexcept;
4769#endif
4771 INLINE cimatrix &operator *=(cimatrix &m1,const imatrix_slice &ms)
4772#if(CXSC_INDEX_CHECK)
4773;
4774#else
4775 noexcept;
4776#endif
4777
4779 INLINE cimatrix operator |(const imatrix &m1,const cimatrix &m2)
4780#if(CXSC_INDEX_CHECK)
4781;
4782#else
4783 noexcept;
4784#endif
4786 INLINE cimatrix operator |(const cimatrix &m1,const imatrix &m2)
4787#if(CXSC_INDEX_CHECK)
4788;
4789#else
4790 noexcept;
4791#endif
4793 INLINE cimatrix operator |(const imatrix &m,const cimatrix_slice &ms)
4794#if(CXSC_INDEX_CHECK)
4795;
4796#else
4797 noexcept;
4798#endif
4800 INLINE cimatrix operator |(const cimatrix &m,const imatrix_slice &ms)
4801#if(CXSC_INDEX_CHECK)
4802;
4803#else
4804 noexcept;
4805#endif
4807 INLINE cimatrix operator |(const imatrix_slice &ms,const cimatrix &m)
4808#if(CXSC_INDEX_CHECK)
4809;
4810#else
4811 noexcept;
4812#endif
4814 INLINE cimatrix operator |(const cimatrix_slice &ms,const imatrix &m)
4815#if(CXSC_INDEX_CHECK)
4816;
4817#else
4818 noexcept;
4819#endif
4821 INLINE cimatrix operator |(const imatrix_slice &m1,const cimatrix_slice &m2)
4822#if(CXSC_INDEX_CHECK)
4823;
4824#else
4825 noexcept;
4826#endif
4828 INLINE cimatrix operator |(const cimatrix_slice &m1,const imatrix_slice &m2)
4829#if(CXSC_INDEX_CHECK)
4830;
4831#else
4832 noexcept;
4833#endif
4835 INLINE cimatrix &operator |=(cimatrix &m1,const imatrix &m2)
4836#if(CXSC_INDEX_CHECK)
4837;
4838#else
4839 noexcept;
4840#endif
4842 INLINE cimatrix &operator |=(cimatrix &m1,const imatrix_slice &ms)
4843#if(CXSC_INDEX_CHECK)
4844;
4845#else
4846 noexcept;
4847#endif
4848
4850 INLINE cimatrix operator &(const imatrix &m1,const cimatrix &m2)
4851#if(CXSC_INDEX_CHECK)
4852;
4853#else
4854 noexcept;
4855#endif
4857 INLINE cimatrix operator &(const cimatrix &m1,const imatrix &m2)
4858#if(CXSC_INDEX_CHECK)
4859;
4860#else
4861 noexcept;
4862#endif
4864 INLINE cimatrix operator &(const imatrix &m,const cimatrix_slice &ms)
4865#if(CXSC_INDEX_CHECK)
4866;
4867#else
4868 noexcept;
4869#endif
4871 INLINE cimatrix operator &(const cimatrix &m,const imatrix_slice &ms)
4872#if(CXSC_INDEX_CHECK)
4873;
4874#else
4875 noexcept;
4876#endif
4878 INLINE cimatrix operator &(const imatrix_slice &ms,const cimatrix &m)
4879#if(CXSC_INDEX_CHECK)
4880;
4881#else
4882 noexcept;
4883#endif
4885 INLINE cimatrix operator &(const cimatrix_slice &ms,const imatrix &m)
4886#if(CXSC_INDEX_CHECK)
4887;
4888#else
4889 noexcept;
4890#endif
4892 INLINE cimatrix operator &(const imatrix_slice &m1,const cimatrix_slice &m2)
4893#if(CXSC_INDEX_CHECK)
4894;
4895#else
4896 noexcept;
4897#endif
4899 INLINE cimatrix operator &(const cimatrix_slice &m1,const imatrix_slice &m2)
4900#if(CXSC_INDEX_CHECK)
4901;
4902#else
4903 noexcept;
4904#endif
4906 INLINE cimatrix &operator &=(cimatrix &m1,const imatrix &m2)
4907#if(CXSC_INDEX_CHECK)
4908;
4909#else
4910 noexcept;
4911#endif
4913 INLINE cimatrix &operator &=(cimatrix &m1,const imatrix_slice &ms)
4914#if(CXSC_INDEX_CHECK)
4915;
4916#else
4917 noexcept;
4918#endif
4919
4920 //---------- cmatrix-imatrix ------------------
4922 INLINE cimatrix operator +(const cmatrix &m1,const imatrix &m2)
4923#if(CXSC_INDEX_CHECK)
4924;
4925#else
4926 noexcept;
4927#endif
4929 INLINE cimatrix operator +(const imatrix &m1,const cmatrix &m2)
4930#if(CXSC_INDEX_CHECK)
4931;
4932#else
4933 noexcept;
4934#endif
4936 INLINE cimatrix operator +(const cmatrix &m,const imatrix_slice &ms)
4937#if(CXSC_INDEX_CHECK)
4938;
4939#else
4940 noexcept;
4941#endif
4943 INLINE cimatrix operator +(const imatrix &m,const cmatrix_slice &ms)
4944#if(CXSC_INDEX_CHECK)
4945;
4946#else
4947 noexcept;
4948#endif
4950 INLINE cimatrix operator +(const cmatrix_slice &ms,const imatrix &m)
4951#if(CXSC_INDEX_CHECK)
4952;
4953#else
4954 noexcept;
4955#endif
4957 INLINE cimatrix operator +(const imatrix_slice &ms,const cmatrix &m)
4958#if(CXSC_INDEX_CHECK)
4959;
4960#else
4961 noexcept;
4962#endif
4964 INLINE cimatrix operator +(const cmatrix_slice &m1,const imatrix_slice &m2)
4965#if(CXSC_INDEX_CHECK)
4966;
4967#else
4968 noexcept;
4969#endif
4971 INLINE cimatrix operator +(const imatrix_slice &m1,const cmatrix_slice &m2)
4972#if(CXSC_INDEX_CHECK)
4973;
4974#else
4975 noexcept;
4976#endif
4977
4979 INLINE cimatrix operator -(const cmatrix &m1,const imatrix &m2)
4980#if(CXSC_INDEX_CHECK)
4981;
4982#else
4983 noexcept;
4984#endif
4986 INLINE cimatrix operator -(const imatrix &m1,const cmatrix &m2)
4987#if(CXSC_INDEX_CHECK)
4988;
4989#else
4990 noexcept;
4991#endif
4993 INLINE cimatrix operator -(const cmatrix &m,const imatrix_slice &ms)
4994#if(CXSC_INDEX_CHECK)
4995;
4996#else
4997 noexcept;
4998#endif
5000 INLINE cimatrix operator -(const imatrix &m,const cmatrix_slice &ms)
5001#if(CXSC_INDEX_CHECK)
5002;
5003#else
5004 noexcept;
5005#endif
5007 INLINE cimatrix operator -(const cmatrix_slice &ms,const imatrix &m)
5008#if(CXSC_INDEX_CHECK)
5009;
5010#else
5011 noexcept;
5012#endif
5014 INLINE cimatrix operator -(const imatrix_slice &ms,const cmatrix &m)
5015#if(CXSC_INDEX_CHECK)
5016;
5017#else
5018 noexcept;
5019#endif
5021 INLINE cimatrix operator -(const cmatrix_slice &ms1,const imatrix_slice &ms2)
5022#if(CXSC_INDEX_CHECK)
5023;
5024#else
5025 noexcept;
5026#endif
5028 INLINE cimatrix operator -(const imatrix_slice &ms1,const cmatrix_slice &ms2)
5029#if(CXSC_INDEX_CHECK)
5030;
5031#else
5032 noexcept;
5033#endif
5034
5036 INLINE cimatrix operator *(const cmatrix &m1, const imatrix &m2)
5037#if(CXSC_INDEX_CHECK)
5038;
5039#else
5040 noexcept;
5041#endif
5043 INLINE cimatrix operator *(const imatrix &m1, const cmatrix &m2)
5044#if(CXSC_INDEX_CHECK)
5045;
5046#else
5047 noexcept;
5048#endif
5050 INLINE cimatrix operator *(const cmatrix &m1, const imatrix_slice &ms)
5051#if(CXSC_INDEX_CHECK)
5052;
5053#else
5054 noexcept;
5055#endif
5057 INLINE cimatrix operator *(const imatrix &m1, const cmatrix_slice &ms)
5058#if(CXSC_INDEX_CHECK)
5059;
5060#else
5061 noexcept;
5062#endif
5064 INLINE cimatrix operator *(const cmatrix_slice &ms, const imatrix &m1)
5065#if(CXSC_INDEX_CHECK)
5066;
5067#else
5068 noexcept;
5069#endif
5071 INLINE cimatrix operator *(const imatrix_slice &ms, const cmatrix &m1)
5072#if(CXSC_INDEX_CHECK)
5073;
5074#else
5075 noexcept;
5076#endif
5078 INLINE cimatrix operator *(const cmatrix_slice &ms1, const imatrix_slice &ms2)
5079#if(CXSC_INDEX_CHECK)
5080;
5081#else
5082 noexcept;
5083#endif
5085 INLINE cimatrix operator *(const imatrix_slice &ms1, const cmatrix_slice &ms2)
5086#if(CXSC_INDEX_CHECK)
5087;
5088#else
5089 noexcept;
5090#endif
5091
5093 INLINE cimatrix operator |(const cmatrix &m1,const imatrix &m2)
5094#if(CXSC_INDEX_CHECK)
5095;
5096#else
5097 noexcept;
5098#endif
5100 INLINE cimatrix operator |(const imatrix &m1,const cmatrix &m2)
5101#if(CXSC_INDEX_CHECK)
5102;
5103#else
5104 noexcept;
5105#endif
5107 INLINE cimatrix operator |(const cmatrix &m,const imatrix_slice &ms)
5108#if(CXSC_INDEX_CHECK)
5109;
5110#else
5111 noexcept;
5112#endif
5114 INLINE cimatrix operator |(const imatrix &m,const cmatrix_slice &ms)
5115#if(CXSC_INDEX_CHECK)
5116;
5117#else
5118 noexcept;
5119#endif
5121 INLINE cimatrix operator |(const cmatrix_slice &ms,const imatrix &m)
5122#if(CXSC_INDEX_CHECK)
5123;
5124#else
5125 noexcept;
5126#endif
5128 INLINE cimatrix operator |(const imatrix_slice &ms,const cmatrix &m)
5129#if(CXSC_INDEX_CHECK)
5130;
5131#else
5132 noexcept;
5133#endif
5135 INLINE cimatrix operator |(const cmatrix_slice &m1,const imatrix_slice &m2)
5136#if(CXSC_INDEX_CHECK)
5137;
5138#else
5139 noexcept;
5140#endif
5142 INLINE cimatrix operator |(const imatrix_slice &m1,const cmatrix_slice &m2)
5143#if(CXSC_INDEX_CHECK)
5144;
5145#else
5146 noexcept;
5147#endif
5148
5150 INLINE cimatrix operator &(const cmatrix &m1,const imatrix &m2)
5151#if(CXSC_INDEX_CHECK)
5152;
5153#else
5154 noexcept;
5155#endif
5157 INLINE cimatrix operator &(const imatrix &m1,const cmatrix &m2)
5158#if(CXSC_INDEX_CHECK)
5159;
5160#else
5161 noexcept;
5162#endif
5164 INLINE cimatrix operator &(const cmatrix &m,const imatrix_slice &ms)
5165#if(CXSC_INDEX_CHECK)
5166;
5167#else
5168 noexcept;
5169#endif
5171 INLINE cimatrix operator &(const imatrix &m,const cmatrix_slice &ms)
5172#if(CXSC_INDEX_CHECK)
5173;
5174#else
5175 noexcept;
5176#endif
5178 INLINE cimatrix operator &(const cmatrix_slice &ms,const imatrix &m)
5179#if(CXSC_INDEX_CHECK)
5180;
5181#else
5182 noexcept;
5183#endif
5185 INLINE cimatrix operator &(const imatrix_slice &ms,const cmatrix &m)
5186#if(CXSC_INDEX_CHECK)
5187;
5188#else
5189 noexcept;
5190#endif
5192 INLINE cimatrix operator &(const cmatrix_slice &m1,const imatrix_slice &m2)
5193#if(CXSC_INDEX_CHECK)
5194;
5195#else
5196 noexcept;
5197#endif
5199 INLINE cimatrix operator &(const imatrix_slice &m1,const cmatrix_slice &m2)
5200#if(CXSC_INDEX_CHECK)
5201;
5202#else
5203 noexcept;
5204#endif
5205
5206//------------- real x complex ------------------------
5208 INLINE cimatrix operator |(const rmatrix &rv1, const cmatrix &rv2)
5209#if(CXSC_INDEX_CHECK)
5210;
5211#else
5212 noexcept;
5213#endif
5215 INLINE cimatrix operator |(const cmatrix &rv1, const rmatrix &rv2)
5216#if(CXSC_INDEX_CHECK)
5217;
5218#else
5219 noexcept;
5220#endif
5222 INLINE cimatrix operator |(const cmatrix &rv, const rmatrix_slice &sl)
5223#if(CXSC_INDEX_CHECK)
5224;
5225#else
5226 noexcept;
5227#endif
5229 INLINE cimatrix operator |(const rmatrix_slice &sl,const cmatrix &rv)
5230#if(CXSC_INDEX_CHECK)
5231;
5232#else
5233 noexcept;
5234#endif
5236 INLINE cimatrix operator |(const cmatrix_slice &sl, const rmatrix &rv)
5237#if(CXSC_INDEX_CHECK)
5238;
5239#else
5240 noexcept;
5241#endif
5243 INLINE cimatrix operator |(const rmatrix &rv,const cmatrix_slice &sl)
5244#if(CXSC_INDEX_CHECK)
5245;
5246#else
5247 noexcept;
5248#endif
5250 INLINE cimatrix operator |(const cmatrix_slice &sl1, const rmatrix_slice &sl2)
5251#if(CXSC_INDEX_CHECK)
5252;
5253#else
5254 noexcept;
5255#endif
5257 INLINE cimatrix operator |(const rmatrix_slice &sl1, const cmatrix_slice &sl2)
5258#if(CXSC_INDEX_CHECK)
5259;
5260#else
5261 noexcept;
5262#endif
5263
5264
5265//------------- complex x complex ------------------------
5267 INLINE cimatrix operator |(const cmatrix &rv1, const cmatrix &rv2)
5268#if(CXSC_INDEX_CHECK)
5269;
5270#else
5271 noexcept;
5272#endif
5274 INLINE cimatrix operator |(const cmatrix &rv1, const cmatrix &rv2)
5275#if(CXSC_INDEX_CHECK)
5276;
5277#else
5278 noexcept;
5279#endif
5281 INLINE cimatrix operator |(const cmatrix &rv, const cmatrix_slice &sl)
5282#if(CXSC_INDEX_CHECK)
5283;
5284#else
5285 noexcept;
5286#endif
5288 INLINE cimatrix operator |(const cmatrix_slice &sl,const cmatrix &rv)
5289#if(CXSC_INDEX_CHECK)
5290;
5291#else
5292 noexcept;
5293#endif
5295 INLINE cimatrix operator |(const cmatrix_slice &sl, const cmatrix &rv)
5296#if(CXSC_INDEX_CHECK)
5297;
5298#else
5299 noexcept;
5300#endif
5302 INLINE cimatrix operator |(const cmatrix &rv,const cmatrix_slice &sl)
5303#if(CXSC_INDEX_CHECK)
5304;
5305#else
5306 noexcept;
5307#endif
5309 INLINE cimatrix operator |(const cmatrix_slice &sl1, const cmatrix_slice &sl2)
5310#if(CXSC_INDEX_CHECK)
5311;
5312#else
5313 noexcept;
5314#endif
5316 INLINE cimatrix operator |(const cmatrix_slice &sl1, const cmatrix_slice &sl2)
5317#if(CXSC_INDEX_CHECK)
5318;
5319#else
5320 noexcept;
5321#endif
5322
5323
5324//============== Compare Operator ==========================
5325
5326//-------------- Matrix - Matrix -------------------------
5327
5329 INLINE bool operator ==(const cimatrix &m1,const cimatrix &m2) noexcept;
5331 INLINE bool operator !=(const cimatrix &m1,const cimatrix &m2) noexcept;
5333 INLINE bool operator <(const cimatrix &m1,const cimatrix &m2) noexcept;
5335 INLINE bool operator <=(const cimatrix &m1,const cimatrix &m2) noexcept;
5337 INLINE bool operator >(const cimatrix &m1,const cimatrix &m2) noexcept;
5339 INLINE bool operator >=(const cimatrix &m1,const cimatrix &m2) noexcept;
5341 INLINE bool operator ==(const cimatrix &m1,const cimatrix_slice &ms) noexcept;
5343 INLINE bool operator !=(const cimatrix &m1,const cimatrix_slice &ms) noexcept;
5345 INLINE bool operator <(const cimatrix &m1,const cimatrix_slice &ms) noexcept;
5347 INLINE bool operator <=(const cimatrix &m1,const cimatrix_slice &ms) noexcept;
5349 INLINE bool operator >(const cimatrix &m1,const cimatrix_slice &ms) noexcept;
5351 INLINE bool operator >=(const cimatrix &m1,const cimatrix_slice &ms) noexcept;
5352
5353//---------------- Matrix - Matrix_slice ----------------------
5354
5356 INLINE bool operator ==(const cimatrix_slice &m1,const cimatrix_slice &m2) noexcept;
5358 INLINE bool operator !=(const cimatrix_slice &m1,const cimatrix_slice &m2) noexcept;
5360 INLINE bool operator <(const cimatrix_slice &m1,const cimatrix_slice &m2) noexcept;
5362 INLINE bool operator <=(const cimatrix_slice &m1,const cimatrix_slice &m2) noexcept;
5364 INLINE bool operator >(const cimatrix_slice &m1,const cimatrix_slice &m2) noexcept;
5366 INLINE bool operator >=(const cimatrix_slice &m1,const cimatrix_slice &m2) noexcept;
5367
5368//=================== Not Operator =============================
5369
5371 INLINE bool operator !(const cimatrix &ms) noexcept;
5373 INLINE bool operator !(const cimatrix_slice &ms) noexcept;
5374
5375//======================== Input / Output ========================
5376
5378 INLINE std::ostream &operator <<(std::ostream &s,const cimatrix &r) noexcept;
5380 INLINE std::ostream &operator <<(std::ostream &s,const cimatrix_slice &r) noexcept;
5382 INLINE std::istream &operator >>(std::istream &s,cimatrix &r) noexcept;
5384 INLINE std::istream &operator >>(std::istream &s,cimatrix_slice &r) noexcept;
5385
5387 rmatrix CompMat ( const cimatrix& );
5389 cimatrix Id ( const cimatrix& );
5391 cimatrix transp ( const cimatrix& );
5393 INLINE int RowLen ( const cimatrix& );
5395 INLINE int ColLen ( const cimatrix& );
5397 INLINE int RowLen ( const cimatrix_slice& );
5399 INLINE int ColLen ( const cimatrix_slice& );
5401 void DoubleSize ( cimatrix& );
5402
5403} // namespace cxsc
5404
5405
5406#ifdef _CXSC_INCL_INL
5407#include "matrix.inl"
5408#include "cimatrix.inl"
5409#endif
5410
5411
5412#ifdef CXSC_USE_BLAS
5413#define _CXSC_BLAS_CIMATRIX
5414#include "cxsc_blas.inl"
5415#endif
5416
5417#endif
The Data Type cidotprecision.
Definition cidot.hpp:58
The Data Type cimatrix_slice.
cimatrix_slice & operator|=(const scimatrix &m1)
Implementation of hull and allocation operation.
cimatrix_slice & operator&=(const scimatrix &m1)
Implementation of intersection and allocation operation.
cimatrix_slice & operator*=(const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
friend rmatrix SupRe(const cimatrix_slice &v) noexcept
Returns the supremum of real part of the matrix.
Definition cimatrix.inl:780
cimatrix_slice & operator+=(const cinterval &c) noexcept
Implementation of addition and allocation operation.
friend rmatrix InfIm(const cimatrix_slice &v) noexcept
Returns the infimum of imaginary part of the matrix.
Definition cimatrix.inl:805
cimatrix_subv operator[](const int &i) noexcept
Operator for accessing a single row of the matrix.
Definition cimatrix.inl:380
cimatrix_slice(cimatrix_slice &a, const int &l1, const int &u1, const int &l2, const int &u2) noexcept
Constructor of class cimatrix_slice.
cimatrix_slice & operator=(const cimatrix &m) noexcept
Implementation of standard assigning operator.
Definition cimatrix.inl:581
cimatrix_slice(cimatrix &a, const int &l1, const int &u1, const int &l2, const int &u2) noexcept
Constructor of class cimatrix_slice.
friend rmatrix SupIm(const cimatrix_slice &v) noexcept
Returns the supremum of imaginary part of the matrix.
Definition cimatrix.inl:830
cimatrix_slice & operator/=(const cinterval &c) noexcept
Implementation of division and allocation operation.
cimatrix_slice(const cimatrix_slice &ms) noexcept
Constructor of class cimatrix_slice.
friend rmatrix InfRe(const cimatrix_slice &v) noexcept
Returns the infimum of real part of the matrix.
Definition cimatrix.inl:755
cimatrix_slice & operator-=(const cinterval &c) noexcept
Implementation of subtraction and allocation operation.
cimatrix_slice & operator()() noexcept
Operator for accessing the whole matrix.
The Data Type cimatrix_subv.
Definition cimatrix.hpp:68
cimatrix_subv & operator&=(const scivector &rv)
Implementation of intersection and allocation operation.
cimatrix_subv & operator=(const scimatrix_subv &rv)
Implementation of standard assigning operator.
cimatrix_subv & operator|=(const scivector &rv)
Implementation of hull and allocation operation.
friend cimatrix_subv Row(cimatrix &m, const int &i) noexcept
Returns one row of the matrix as a vector.
Definition cimatrix.inl:231
cimatrix_subv(cinterval *d, const int &l, const int &u, const int &s, const int &st, const int &o) noexcept
Constructor of class cimatrix_subv.
Definition cimatrix.hpp:315
cimatrix_subv & operator*=(const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
Definition cimatrix.inl:733
friend int VecLen(const cimatrix_subv &rv) noexcept
Returns the size of the vector.
Definition cimatrix.hpp:489
friend int Lb(const cimatrix_subv &rv) noexcept
Returns the lower bound of the vector.
Definition cimatrix.hpp:485
friend cimatrix_subv Col(cimatrix &m, const int &i) noexcept
Returns one column of the matrix as a vector.
Definition cimatrix.inl:242
friend int Ub(const cimatrix_subv &rv) noexcept
Returns the upper bound of the vector.
Definition cimatrix.hpp:487
cimatrix_subv & operator/=(const cinterval &c) noexcept
Implementation of division and allocation operation.
Definition cimatrix.inl:736
cimatrix_subv & operator()() noexcept
Operator for accessing the whole vector.
Definition cimatrix.hpp:508
cimatrix_subv(const cimatrix_subv &v) noexcept
Constructor of class cimatrix_subv.
Definition cimatrix.hpp:318
cimatrix_subv & operator+=(const cinterval &c) noexcept
Implementation of addition and allocation operation.
Definition cimatrix.inl:734
cinterval & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector (read-only)
Definition cimatrix.inl:275
cimatrix_subv & operator-=(const cinterval &c) noexcept
Implementation of subtraction and allocation operation.
Definition cimatrix.inl:735
The Data Type cimatrix.
Definition cimatrix.hpp:908
friend rmatrix SupIm(const cimatrix &v) noexcept
Returns the supremum of imaginary part of the matrix.
Definition cimatrix.inl:820
cimatrix & operator()() noexcept
Operator for accessing the whole matrix.
friend rmatrix InfIm(const cimatrix &v) noexcept
Returns the infimum of imaginary part of the matrix.
Definition cimatrix.inl:795
cimatrix & operator*=(const scimatrix &m1)
Implementation of multiplication and allocation operation.
cimatrix & operator=(const cinterval &r) noexcept
Implementation of standard assigning operator.
Definition cimatrix.inl:555
cimatrix() noexcept
Constructor of class cimatrix.
Definition cimatrix.inl:31
friend rmatrix InfRe(const cimatrix &v) noexcept
Returns the infimum of real part of the matrix.
Definition cimatrix.inl:745
cimatrix_subv operator[](const int &i) const noexcept
Operator for accessing a single row of the matrix.
Definition cimatrix.inl:301
cimatrix & operator&=(const scimatrix &m1)
Implementation of intersection and allocation operation.
friend rmatrix SupRe(const cimatrix &v) noexcept
Returns the supremum of real part of the matrix.
Definition cimatrix.inl:770
cimatrix & operator|=(const scimatrix &m1)
Implementation of hull and allocation operation.
cimatrix & operator+=(const scimatrix &m1)
Implementation of addition and allocation operation.
cimatrix & operator-=(const scimatrix &m1)
Implementation of substraction and allocation operation.
The Scalar Type cinterval.
Definition cinterval.hpp:55
The Data Type civector_slice.
The Data Type civector.
Definition civector.hpp:57
civector() noexcept
Constructor of class civector.
Definition civector.inl:31
The Data Type cmatrix_slice.
Definition cmatrix.hpp:1203
The Data Type cmatrix_subv.
Definition cmatrix.hpp:54
The Data Type cmatrix.
Definition cmatrix.hpp:514
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
The Data Type imatrix_slice.
Definition imatrix.hpp:1442
The Data Type imatrix_subv.
Definition imatrix.hpp:56
The Data Type imatrix.
Definition imatrix.hpp:660
The Scalar Type interval.
Definition interval.hpp:55
The Data Type intmatrix.
The Data Type intvector.
Definition intvector.hpp:52
The Data Type ivector_slice.
Definition ivector.hpp:963
The Data Type ivector.
Definition ivector.hpp:55
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 interval matrix.
Represents a row or column vector of a sparse matrix.
A sparse complex interval matrix.
Definition scimatrix.hpp:71
Helper class for slices of sparse vectors.
A sparse complex interval vector.
Definition scivector.hpp:62
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 interval matrix.
Represents a row or column vector of a sparse matrix.
A sparse interval matrix.
Definition simatrix.hpp:69
Helper class for slices of sparse vectors.
A sparse interval vector.
Definition sivector.hpp:59
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
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
cvector diam(const cimatrix_subv &mv) noexcept
Returns the diameter of the matrix.
Definition cimatrix.inl:738
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 _imatrix(const cimatrix &rm) noexcept
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC.
cimatrix & operator*=(cimatrix &m, const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
Definition cimatrix.inl:737
cvector mid(const cimatrix_subv &mv) noexcept
Returns the middle of the matrix.
Definition cimatrix.inl:739
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_subv & SetUncheckedInf(cimatrix_subv &iv, const complex &r) noexcept
Returns the matrix with the new unchecked given infimum value.
Definition cimatrix.inl:890
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.