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 
38 namespace cxsc {
39 
40 class cimatrix; // forward declaration
41 class cimatrix_slice; // forward declaration
42 class srmatrix;
43 class srmatrix_slice;
44 class srmatrix_subv;
45 class simatrix;
46 class simatrix_slice;
47 class simatrix_subv;
48 class scmatrix;
49 class scmatrix_slice;
50 class scmatrix_subv;
51 class scimatrix;
52 class scimatrix_slice;
53 class 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 ---------------------------------------
113 template <class MV1,class MV2> friend MV1 &_mvmvassign(MV1 &v,const MV2 &rv)
114 #if(CXSC_INDEX_CHECK)
115 ;
116 #else
117  noexcept;
118 #endif
119 template <class MV,class S> friend MV &_mvsassign(MV &v,const S &r) noexcept;
120 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
121 #if(CXSC_INDEX_CHECK)
122 ;
123 #else
124  noexcept;
125 #endif
126 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) noexcept;
127 template <class MV,class V> friend MV &_mvvsetinf(MV &v,const V &rv)
128 #if(CXSC_INDEX_CHECK)
129 ;
130 #else
131  noexcept;
132 #endif
133 template <class MV,class V> friend MV &_mvvsetsup(MV &v,const V &rv)
134 #if(CXSC_INDEX_CHECK)
135 ;
136 #else
137  noexcept;
138 #endif
139 template <class MV,class V> friend MV &_mvvusetinf(MV &v,const V &rv)
140 #if(CXSC_INDEX_CHECK)
141 ;
142 #else
143  noexcept;
144 #endif
145 template <class MV,class V> friend MV &_mvvusetsup(MV &v,const V &rv)
146 #if(CXSC_INDEX_CHECK)
147 ;
148 #else
149  noexcept;
150 #endif
151 template <class MV,class V> friend MV &_mvvsetre(MV &v,const V &rv)
152 #if(CXSC_INDEX_CHECK)
153 ;
154 #else
155  noexcept;
156 #endif
157 template <class MV,class V> friend MV &_mvvsetim(MV &v,const V &rv)
158 #if(CXSC_INDEX_CHECK)
159 ;
160 #else
161  noexcept;
162 #endif
163 template <class MV,class V> friend V _mvabs(const MV &mv) noexcept;
164 template <class MV,class V> friend V _mvim(const MV &mv) noexcept;
165 template <class MV,class V> friend V _mvre(const MV &mv) noexcept;
166 template <class MV,class V> friend V _mvdiam(const MV &mv) noexcept;
167 template <class MV,class V> friend V _mvmid(const MV &mv) noexcept;
168 template <class MV,class V> friend V _mvinf(const MV &mv) noexcept;
169 template <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;
177 template <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
183 template <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;
233 template <class MV,class S> friend MV &_mvsmultassign(MV &v,const S &r) noexcept;
234 template <class MV, class S> friend MV &_mvsplusassign(MV &v,const S &r) noexcept;
235 template <class MV,class S> friend MV &_mvsminusassign(MV &v,const S &r) noexcept;
236 template <class MV,class S> friend MV &_mvsdivassign(MV &v,const S &r) noexcept;
237 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
238 #if(CXSC_INDEX_CHECK)
239 ;
240 #else
241  noexcept;
242 #endif
243 template <class V,class MV> friend V &_vmvplusassign(V &rv,const MV &v)
244 #if(CXSC_INDEX_CHECK)
245 ;
246 #else
247  noexcept;
248 #endif
249 template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv)
250 #if(CXSC_INDEX_CHECK)
251 ;
252 #else
253  noexcept;
254 #endif
255 template <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
273 template <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
291 template <class MV,class V> friend MV &_mvvsectassign(MV &v,const V &rv)
292 #if(CXSC_INDEX_CHECK)
293 ;
294 #else
295  noexcept;
296 #endif
297 template <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 
333  cimatrix_subv &operator =(const scivector &rv);
335  cimatrix_subv &operator =(const srvector &rv);
337  cimatrix_subv &operator =(const scvector &rv);
339  cimatrix_subv &operator =(const sivector &rv);
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 
877 INLINE cimatrix_subv Row(cimatrix &m,const int &i)
878 #if(CXSC_INDEX_CHECK)
879 ;
880 #else
881  noexcept;
882 #endif
884 INLINE cimatrix_subv Col(cimatrix &m,const int &i)
885 #if(CXSC_INDEX_CHECK)
886 ;
887 #else
888  noexcept;
889 #endif
890 
891 
892 
893 
894 class cimatrix_slice;
895 
896 // ---------------------------------------------------------------------------
897 // ---- ----
898 // ---- class cimatrix (declaration) ----
899 // ---- ----
900 // ---------------------------------------------------------------------------
901 
902 
904 
907 class cimatrix
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 ---------------------------------------
919 template <class S,class M> friend void _smconstr(S &s,const M &m)
920 #if(CXSC_INDEX_CHECK)
921 ;
922 #else
923  noexcept;
924 #endif
925 template <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;
940 template <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
946 template <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 ---------------------------------------
1662 template <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.
Definition: cimatrix.hpp:1651
cimatrix_slice & operator|=(const scimatrix &m1)
Implementation of hull and allocation operation.
Definition: scimatrix.hpp:3986
cimatrix_slice & operator&=(const scimatrix &m1)
Implementation of intersection and allocation operation.
Definition: scimatrix.hpp:4002
cimatrix_slice & operator*=(const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
Definition: cimatrix.inl:1620
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.
Definition: cimatrix.hpp:2005
friend rmatrix InfRe(const cimatrix_slice &v) noexcept
Returns the infimum of real part of the matrix.
Definition: cimatrix.inl:755
friend rmatrix InfIm(const cimatrix_slice &v) noexcept
Returns the infimum of imaginary part of the matrix.
Definition: cimatrix.inl:805
cimatrix_slice & operator=(const cimatrix &m) noexcept
Implementation of standard assigning operator.
Definition: cimatrix.inl:581
cimatrix_slice & operator-=(const cinterval &c) noexcept
Implementation of subtraction and allocation operation.
cimatrix_slice(cimatrix &a, const int &l1, const int &u1, const int &l2, const int &u2) noexcept
Constructor of class cimatrix_slice.
Definition: cimatrix.hpp:2003
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 addition and allocation operation.
cimatrix_slice & operator/=(const cinterval &c) noexcept
Implementation of division and allocation operation.
Definition: cimatrix.inl:1624
cimatrix_slice(const cimatrix_slice &ms) noexcept
Constructor of class cimatrix_slice.
Definition: cimatrix.hpp:2008
cimatrix_slice & operator()() noexcept
Operator for accessing the whole matrix.
Definition: cimatrix.hpp:2229
friend rmatrix SupRe(const cimatrix_slice &v) noexcept
Returns the supremum of real part of the matrix.
Definition: cimatrix.inl:780
The Data Type cimatrix_subv.
Definition: cimatrix.hpp:68
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 & 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.
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 int Ub(const cimatrix_subv &rv) noexcept
Returns the upper bound of the vector.
Definition: cimatrix.hpp:487
friend cimatrix_subv Col(cimatrix &m, const int &i) noexcept
Returns one column of the matrix as a vector.
Definition: cimatrix.inl:242
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 SupRe(const cimatrix &v) noexcept
Returns the supremum of real part of the matrix.
Definition: cimatrix.inl:770
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.
Definition: scimatrix.hpp:4018
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 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.
Definition: cimatrix.hpp:1623
cimatrix_subv operator[](const int &i) const noexcept
Operator for accessing a single row of the matrix.
Definition: cimatrix.inl:301
friend rmatrix InfRe(const cimatrix &v) noexcept
Returns the infimum of real part of the matrix.
Definition: cimatrix.inl:745
cimatrix & operator&=(const scimatrix &m1)
Implementation of intersection and allocation operation.
Definition: scimatrix.hpp:3994
cimatrix & operator|=(const scimatrix &m1)
Implementation of hull and allocation operation.
Definition: scimatrix.hpp:3970
cimatrix & operator+=(const scimatrix &m1)
Implementation of addition and allocation operation.
Definition: scimatrix.hpp:3906
cimatrix & operator-=(const scimatrix &m1)
Implementation of substraction and allocation operation.
Definition: scimatrix.hpp:3934
The Scalar Type cinterval.
Definition: cinterval.hpp:55
The Data Type civector_slice.
Definition: civector.hpp:1015
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.
Definition: intmatrix.hpp:314
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.
Definition: scimatrix.hpp:4918
Represents a row or column vector of a sparse matrix.
Definition: scimatrix.hpp:9628
A sparse complex interval matrix.
Definition: scimatrix.hpp:71
Helper class for slices of sparse vectors.
Definition: scivector.hpp:4063
A sparse complex interval vector.
Definition: scivector.hpp:62
A slice of a sparse complex matrix.
Definition: scmatrix.hpp:1956
Represents a row or column vector of a sparse matrix.
Definition: scmatrix.hpp:3345
A sparse complex matrix.
Definition: scmatrix.hpp:69
Helper class for slices of sparse vectors.
Definition: scvector.hpp:1245
A sparse complex vector.
Definition: scvector.hpp:58
A slice of a sparse real interval matrix.
Definition: simatrix.hpp:2431
Represents a row or column vector of a sparse matrix.
Definition: simatrix.hpp:4383
A sparse interval matrix.
Definition: simatrix.hpp:69
Helper class for slices of sparse vectors.
Definition: sivector.hpp:1831
A sparse interval vector.
Definition: sivector.hpp:59
A slice of a sparse real matrix.
Definition: srmatrix.hpp:1360
Represents a row or column vector of a sparse matrix.
Definition: srmatrix.hpp:2157
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
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.
Definition: cimatrix.inl:1202
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
cimatrix_subv Row(cimatrix &m, const int &i) noexcept
Returns one row of the matrix as a vector.
Definition: cimatrix.inl:231
int Ub(const cimatrix &rm, const int &i) noexcept
Returns the upper bound index.
Definition: cimatrix.inl:1163
cimatrix & SetLb(cimatrix &m, const int &i, const int &j) noexcept
Sets the lower bound index.
Definition: cimatrix.inl:1184
int RowLen(const cimatrix &)
Returns the row dimension.
Definition: cimatrix.inl:1199
void DoubleSize(cimatrix &A)
Doubles the size of the matrix.
Definition: cimatrix.cpp:83
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc) noexcept
Implementation of standard algebraic addition and allocation operation.
Definition: cdot.inl:251
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.
Definition: cimatrix.inl:1137
cimatrix & operator*=(cimatrix &m, const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
Definition: cimatrix.inl:1605
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.
Definition: cimatrix.inl:1211
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.
Definition: cimatrix.inl:1191
int Lb(const cimatrix &rm, const int &i) noexcept
Returns the lower bound index.
Definition: cimatrix.inl:1156
cimatrix & operator/=(cimatrix &m, const cinterval &c) noexcept
Implementation of division and allocation operation.
Definition: cimatrix.inl:1623