C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
imatrix.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: imatrix.hpp,v 1.41 2014/01/30 17:23:45 cxsc Exp $ */
25 
26 #ifndef _CXSC_IMATRIX_HPP_INCLUDED
27 #define _CXSC_IMATRIX_HPP_INCLUDED
28 
29 #include "xscclass.hpp"
30 #include "idot.hpp"
31 #include "cidot.hpp"
32 #include "ivector.hpp"
33 #include "except.hpp"
34 #include "matrix.hpp"
35 #include "rmatrix.hpp"
36 
37 
38 namespace cxsc {
39 
40 
41 class imatrix;
42 class imatrix_slice;
43 class simatrix;
44 class simatrix_slice;
45 class simatrix_subv;
46 class srmatrix;
47 class srmatrix_slice;
48 class srmatrix_subv;
49 
50 
52 
56 {
57  friend class ivector;
58  friend class civector;
59  friend class l_ivector;
60  friend class imatrix;
61  friend class imatrix_slice;
62  private:
63  interval *dat;
64  int lb,ub;
65  int size,start,offset; // start=first element index 0..n-1
66 
67  public:
69  friend INLINE imatrix_subv Row(imatrix &m,const int &i)
70 #if(CXSC_INDEX_CHECK)
71 ;
72 #else
73  noexcept;
74 #endif
76  friend INLINE imatrix_subv Col(imatrix &m,const int &i)
77 #if(CXSC_INDEX_CHECK)
78 ;
79 #else
80  noexcept;
81 #endif
83  friend INLINE imatrix_subv Row(const imatrix &m,const int &i)
84 #if(CXSC_INDEX_CHECK)
85 ;
86 #else
87  noexcept;
88 #endif
90  friend INLINE imatrix_subv Col(const imatrix &m,const int &i)
91 #if(CXSC_INDEX_CHECK)
92 ;
93 #else
94  noexcept;
95 #endif
96 
97 //#if(CXSC_INDEX_CHECK)
98 #ifdef _CXSC_FRIEND_TPL
99  //----------------- Templates ---------------------------------------
100 template <class MV1,class MV2> friend MV1 &_mvmvassign(MV1 &v,const MV2 &rv)
101 #if(CXSC_INDEX_CHECK)
102 ;
103 #else
104  noexcept;
105 #endif
106 template <class MV,class S> friend MV &_mvsassign(MV &v,const S &r) noexcept;
107 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
108 #if(CXSC_INDEX_CHECK)
109 ;
110 #else
111  noexcept;
112 #endif
113 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) noexcept;
114 template <class MV,class V> friend MV &_mvvsetinf(MV &v,const V &rv)
115 #if(CXSC_INDEX_CHECK)
116 ;
117 #else
118  noexcept;
119 #endif
120 template <class MV,class V> friend MV &_mvvsetsup(MV &v,const V &rv)
121 #if(CXSC_INDEX_CHECK)
122 ;
123 #else
124  noexcept;
125 #endif
126 template <class MV,class V> friend MV &_mvvusetinf(MV &v,const V &rv)
127 #if(CXSC_INDEX_CHECK)
128 ;
129 #else
130  noexcept;
131 #endif
132 template <class MV,class V> friend MV &_mvvusetsup(MV &v,const V &rv)
133 #if(CXSC_INDEX_CHECK)
134 ;
135 #else
136  noexcept;
137 #endif
138  template <class MV,class S> friend MV &_mvssetinf(MV &mv, const S &s) noexcept;
139  template <class MV,class S> friend MV &_mvssetsup(MV &mv, const S &s) noexcept;
140  template <class MV,class S> friend MV &_mvsusetinf(MV &mv, const S &s) noexcept;
141  template <class MV,class S> friend MV &_mvsusetsup(MV &mv, const S &s) noexcept;
142 template <class MV,class V> friend V _mvabs(const MV &mv) noexcept;
143 template <class MV,class V> friend V _mvdiam(const MV &mv) noexcept;
144 template <class MV,class V> friend V _mvmid(const MV &mv) noexcept;
145 template <class MV,class V> friend V _mvinf(const MV &mv) noexcept;
146 template <class MV,class V> friend V _mvsup(const MV &mv) noexcept;
147 template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
148 #if(CXSC_INDEX_CHECK)
149  ;
150 #else
151  noexcept;
152 #endif
153 template <class DP,class MV1,class MV2> friend void _mvmvaccu(DP &dp, const MV1 & rv1, const MV2 &rv2)
154 #if(CXSC_INDEX_CHECK)
155  ;
156 #else
157  noexcept;
158 #endif
159  template <class MV1,class MV2,class S> friend S _mvmvimult(const MV1 & rv1, const MV2 &rv2)
160 #if(CXSC_INDEX_CHECK)
161  ;
162 #else
163  noexcept;
164 #endif
165  template <class V,class MV,class S> friend S _vmvimult(const V &rv1, const MV &rv2)
166 #if(CXSC_INDEX_CHECK)
167  ;
168 #else
169  noexcept;
170 #endif
171  template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) noexcept;
172  template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
173 #if(CXSC_INDEX_CHECK)
174  ;
175 #else
176  noexcept;
177 #endif
178  template <class MV1,class MV2,class E> friend E _mvmvminus(const MV1 &rv1, const MV2 &rv2)
179 #if(CXSC_INDEX_CHECK)
180  ;
181 #else
182  noexcept;
183 #endif
184  template <class MV,class V,class E> friend E _mvvplus(const MV &rv1, const V &rv2)
185 #if(CXSC_INDEX_CHECK)
186  ;
187 #else
188  noexcept;
189 #endif
190  template <class MV,class V,class E> friend E _mvvminus(const MV &rv1, const V &rv2)
191 #if(CXSC_INDEX_CHECK)
192  ;
193 #else
194  noexcept;
195 #endif
196  template <class V,class MV,class E> friend E _vmvminus(const V &rv1, const MV &rv2)
197 #if(CXSC_INDEX_CHECK)
198  ;
199 #else
200  noexcept;
201 #endif
202  template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) noexcept;
203 template <class MV,class S> friend MV &_mvsmultassign(MV &v,const S &r) noexcept;
204 template <class MV, class S> friend MV &_mvsplusassign(MV &v,const S &r) noexcept;
205 template <class MV,class S> friend MV &_mvsminusassign(MV &v,const S &r) noexcept;
206 template <class MV,class S> friend MV &_mvsdivassign(MV &v,const S &r) noexcept;
207 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
208 #if(CXSC_INDEX_CHECK)
209 ;
210 #else
211  noexcept;
212 #endif
213 template <class V,class MV> friend V &_vmvplusassign(V &rv,const MV &v)
214 #if(CXSC_INDEX_CHECK)
215 ;
216 #else
217  noexcept;
218 #endif
219 template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv)
220 #if(CXSC_INDEX_CHECK)
221 ;
222 #else
223  noexcept;
224 #endif
225 template <class V,class MV> friend V &_vmvminusassign(V &rv,const MV &v)
226 #if(CXSC_INDEX_CHECK)
227 ;
228 #else
229  noexcept;
230 #endif
231  template <class MV1,class MV2,class E> friend E _mvmvconv(const MV1 &rv1, const MV2 &rv2)
232 #if(CXSC_INDEX_CHECK)
233  ;
234 #else
235  noexcept;
236 #endif
237  template <class MV,class V,class E> friend E _mvvconv(const MV &rv1, const V &rv2)
238 #if(CXSC_INDEX_CHECK)
239  ;
240 #else
241  noexcept;
242 #endif
243 template <class MV,class V> friend MV &_mvvconvassign(MV &v,const V &rv)
244 #if(CXSC_INDEX_CHECK)
245 ;
246 #else
247  noexcept;
248 #endif
249  template <class MV1,class MV2,class E> friend E _mvmvsect(const MV1 &rv1, const MV2 &rv2)
250 #if(CXSC_INDEX_CHECK)
251  ;
252 #else
253  noexcept;
254 #endif
255  template <class MV,class V,class E> friend E _mvvsect(const MV &rv1, const V &rv2)
256 #if(CXSC_INDEX_CHECK)
257  ;
258 #else
259  noexcept;
260 #endif
261 template <class MV,class V> friend MV &_mvvsectassign(MV &v,const V &rv)
262 #if(CXSC_INDEX_CHECK)
263 ;
264 #else
265  noexcept;
266 #endif
267 template <class V,class MV> friend V &_vmvsectassign(V &rv,const MV &v)
268 #if(CXSC_INDEX_CHECK)
269 ;
270 #else
271  noexcept;
272 #endif
273 
274  //cinterval
275 template <class V,class MV> friend V &_vmvsetim(V &rv,const MV &v)
276 #if(CXSC_INDEX_CHECK)
277 ;
278 #else
279  noexcept;
280 #endif
281 template <class V,class MV> friend V &_vmvsetre(V &rv,const MV &v)
282 #if(CXSC_INDEX_CHECK)
283 ;
284 #else
285  noexcept;
286 #endif
287  /* friend TINLINE civector_slice &_vsmvsetim(civector_slice &,const imatrix_subv &)
288 #if(CXSC_INDEX_CHECK)
289 ;
290 #else
291  noexcept;
292 #endif
293  friend TINLINE civector_slice &_vsmvsetre(civector_slice &,const imatrix_subv &)
294 #if(CXSC_INDEX_CHECK)
295 ;
296 #else
297  noexcept;
298 #endif
299  */
300 
301 #endif
302 
303  //----------------- Konstruktoren ----------------------------------
304 
306  explicit INLINE imatrix_subv (interval *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) { }
307  public:
309  INLINE imatrix_subv(const imatrix_subv &v) noexcept:dat(v.dat),lb(v.lb),ub(v.ub),size(v.size),start(v.start),offset(v.offset) { }
310  public:
311 
312  //---------------------- Standardfunktionen ------------------------
313 
315  INLINE imatrix_subv &operator =(const simatrix_subv &rv);
317  INLINE imatrix_subv &operator =(const srmatrix_subv &rv);
319  INLINE imatrix_subv &operator =(const srvector &rv);
321  INLINE imatrix_subv &operator =(const sivector &rv);
323  INLINE imatrix_subv &operator =(const srvector_slice &rv);
325  INLINE imatrix_subv &operator =(const sivector_slice &rv);
326 
328  INLINE imatrix_subv &operator =(const imatrix_subv &rv) noexcept;
330  INLINE imatrix_subv &operator =(const interval &r) noexcept;
332  INLINE imatrix_subv &operator =(const imatrix &m)
333 #if(CXSC_INDEX_CHECK)
334 ;
335 #else
336  noexcept;
337 #endif
339  INLINE imatrix_subv &operator =(const imatrix_slice &m)
340 #if(CXSC_INDEX_CHECK)
341 ;
342 #else
343  noexcept;
344 #endif
346  INLINE imatrix_subv &operator =(const ivector &v)
347 #if(CXSC_INDEX_CHECK)
348 ;
349 #else
350  noexcept;
351 #endif
353  INLINE imatrix_subv &operator =(const ivector_slice &v)
354 #if(CXSC_INDEX_CHECK)
355 ;
356 #else
357  noexcept;
358 #endif
359  // Real
361  INLINE imatrix_subv &operator =(const rmatrix_subv &rv) noexcept;
363  INLINE imatrix_subv &operator =(const real &r) noexcept;
365  INLINE imatrix_subv &operator =(const rmatrix &m)
366 #if(CXSC_INDEX_CHECK)
367 ;
368 #else
369  noexcept;
370 #endif
372  INLINE imatrix_subv &operator =(const rmatrix_slice &m)
373 #if(CXSC_INDEX_CHECK)
374 ;
375 #else
376  noexcept;
377 #endif
379  INLINE imatrix_subv &operator =(const rvector &v)
380 #if(CXSC_INDEX_CHECK)
381 ;
382 #else
383  noexcept;
384 #endif
386  INLINE imatrix_subv &operator =(const rvector_slice &v)
387 #if(CXSC_INDEX_CHECK)
388 ;
389 #else
390  noexcept;
391 #endif
392 
394  friend INLINE int Lb(const imatrix_subv &rv) noexcept { return rv.lb; }
396  friend INLINE int Ub(const imatrix_subv &rv) noexcept { return rv.ub; }
398  friend INLINE int VecLen(const imatrix_subv &rv) noexcept { return rv.size; }
399 
401  INLINE interval &operator [](const int &i) const
402 #if(CXSC_INDEX_CHECK)
403 ;
404 #else
405  noexcept;
406 #endif
407 
409  INLINE interval &operator [](const int &i)
410 #if(CXSC_INDEX_CHECK)
411 ;
412 #else
413  noexcept;
414 #endif
415 
417  INLINE imatrix_subv &operator ()() noexcept { return *this; }
419  INLINE imatrix_subv operator ()(const int &i)
420 #if(CXSC_INDEX_CHECK)
421 ;
422 #else
423  noexcept;
424 #endif
426  INLINE imatrix_subv operator ()(const int &i1,const int &i2)
427 #if(CXSC_INDEX_CHECK)
428 ;
429 #else
430  noexcept;
431 #endif
432 
434  INLINE imatrix_subv &operator *=(const interval &c) noexcept;
436  INLINE imatrix_subv &operator +=(const interval &c) noexcept;
438  INLINE imatrix_subv &operator -=(const interval &c) noexcept;
440  INLINE imatrix_subv &operator /=(const interval &c) noexcept;
441 
442  //Sparse
444  INLINE imatrix_subv &operator +=(const sivector &rv);
446  INLINE imatrix_subv &operator -=(const sivector &rv);
448  INLINE imatrix_subv &operator +=(const srvector &rv);
450  INLINE imatrix_subv &operator -=(const srvector &rv);
452  INLINE imatrix_subv &operator +=(const sivector_slice &rv);
454  INLINE imatrix_subv &operator -=(const sivector_slice &rv);
456  INLINE imatrix_subv &operator +=(const srvector_slice &rv);
458  INLINE imatrix_subv &operator -=(const srvector_slice &rv);
460  INLINE imatrix_subv &operator +=(const simatrix_subv &rv);
462  INLINE imatrix_subv &operator -=(const simatrix_subv &rv);
464  INLINE imatrix_subv &operator +=(const srmatrix_subv &rv);
466  INLINE imatrix_subv &operator -=(const srmatrix_subv &rv);
467 
469  INLINE imatrix_subv &operator |=(const sivector &rv);
471  INLINE imatrix_subv &operator &=(const sivector &rv);
473  INLINE imatrix_subv &operator |=(const srvector &rv);
475  INLINE imatrix_subv &operator &=(const srvector &rv);
477  INLINE imatrix_subv &operator |=(const sivector_slice &rv);
479  INLINE imatrix_subv &operator &=(const sivector_slice &rv);
481  INLINE imatrix_subv &operator |=(const srvector_slice &rv);
483  INLINE imatrix_subv &operator &=(const srvector_slice &rv);
485  INLINE imatrix_subv &operator |=(const simatrix_subv &rv);
487  INLINE imatrix_subv &operator &=(const simatrix_subv &rv);
489  INLINE imatrix_subv &operator |=(const srmatrix_subv &rv);
491  INLINE imatrix_subv &operator &=(const srmatrix_subv &rv);
492 
493 
495  INLINE imatrix_subv &operator -=(const ivector &rv)
496 #if(CXSC_INDEX_CHECK)
497 ;
498 #else
499  noexcept;
500 #endif
502  INLINE imatrix_subv &operator +=(const ivector &rv)
503 #if(CXSC_INDEX_CHECK)
504 ;
505 #else
506  noexcept;
507 #endif
509  INLINE imatrix_subv &operator -=(const ivector_slice &rv)
510 #if(CXSC_INDEX_CHECK)
511 ;
512 #else
513  noexcept;
514 #endif
516  INLINE imatrix_subv &operator +=(const ivector_slice &rv)
517 #if(CXSC_INDEX_CHECK)
518 ;
519 #else
520  noexcept;
521 #endif
523  INLINE imatrix_subv &operator |=(const ivector &rv)
524 #if(CXSC_INDEX_CHECK)
525 ;
526 #else
527  noexcept;
528 #endif
530  INLINE imatrix_subv &operator |=(const ivector_slice &rv)
531 #if(CXSC_INDEX_CHECK)
532 ;
533 #else
534  noexcept;
535 #endif
537  INLINE imatrix_subv &operator &=(const ivector &rv)
538 #if(CXSC_INDEX_CHECK)
539 ;
540 #else
541  noexcept;
542 #endif
544  INLINE imatrix_subv &operator &=(const ivector_slice &rv)
545 #if(CXSC_INDEX_CHECK)
546 ;
547 #else
548  noexcept;
549 #endif
550  // real
552  INLINE imatrix_subv &operator *=(const real &c) noexcept;
554  INLINE imatrix_subv &operator +=(const real &c) noexcept;
556  INLINE imatrix_subv &operator -=(const real &c) noexcept;
558  INLINE imatrix_subv &operator /=(const real &c) noexcept;
559 
561  INLINE imatrix_subv &operator +=(const rvector &rv)
562 #if(CXSC_INDEX_CHECK)
563 ;
564 #else
565  noexcept;
566 #endif
568  INLINE imatrix_subv &operator +=(const rvector_slice &rv)
569 #if(CXSC_INDEX_CHECK)
570 ;
571 #else
572  noexcept;
573 #endif
575  INLINE imatrix_subv &operator -=(const rvector &rv)
576 #if(CXSC_INDEX_CHECK)
577 ;
578 #else
579  noexcept;
580 #endif
582  INLINE imatrix_subv &operator -=(const rvector_slice &rv)
583 #if(CXSC_INDEX_CHECK)
584 ;
585 #else
586  noexcept;
587 #endif
589  INLINE imatrix_subv &operator |=(const rvector &rv)
590 #if(CXSC_INDEX_CHECK)
591 ;
592 #else
593  noexcept;
594 #endif
596  INLINE imatrix_subv &operator |=(const rvector_slice &rv)
597 #if(CXSC_INDEX_CHECK)
598 ;
599 #else
600  noexcept;
601 #endif
603  INLINE imatrix_subv &operator &=(const rvector &rv)
604 #if(CXSC_INDEX_CHECK)
605 ;
606 #else
607  noexcept;
608 #endif
610  INLINE imatrix_subv &operator &=(const rvector_slice &rv)
611 #if(CXSC_INDEX_CHECK)
612 ;
613 #else
614  noexcept;
615 #endif
616 //#else
617 //#endif
618 
619 };
620 
621 
623 INLINE imatrix_subv Row(imatrix &m,const int &i)
624 #if(CXSC_INDEX_CHECK)
625 ;
626 #else
627  noexcept;
628 #endif
630 INLINE imatrix_subv Col(imatrix &m,const int &i)
631 #if(CXSC_INDEX_CHECK)
632 ;
633 #else
634  noexcept;
635 #endif
637 INLINE imatrix_subv Row(const imatrix &m,const int &i)
638 #if(CXSC_INDEX_CHECK)
639 ;
640 #else
641  noexcept;
642 #endif
644 INLINE imatrix_subv Col(const imatrix &m,const int &i)
645 #if(CXSC_INDEX_CHECK)
646 ;
647 #else
648  noexcept;
649 #endif
650 
651 //----------------------- Matrix -----------------------------------------------
652 
653 class imatrix_slice;
654 
656 
659 class imatrix
660 {
661  friend class imatrix_slice;
662  friend class imatrix_subv;
663  friend class cimatrix;
664  friend class l_imatrix;
665  private:
666  interval *dat;
667  int lb1,ub1,lb2,ub2,xsize,ysize;
668 
669  public:
670 //#if(CXSC_INDEX_CHECK)
671 #ifdef _CXSC_FRIEND_TPL
672  //----------------- Templates ---------------------------------------
673 template <class S,class M> friend void _smconstr(S &s,const M &m)
674 #if(CXSC_INDEX_CHECK)
675 ;
676 #else
677  noexcept;
678 #endif
679 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
680 #if(CXSC_INDEX_CHECK)
681 ;
682 #else
683  noexcept;
684 #endif
685  template <class M1,class M2,class S> friend M1 &_mmassign(M1 &m1,const M2 &m,S ms) noexcept;
686  template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) noexcept;
687  template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m)
688 #if(CXSC_INDEX_CHECK)
689  ;
690 #else
691  noexcept;
692 #endif
693  template <class M,class S> friend M &_msassign(M &m,const S &r) noexcept;
694 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m)
695 #if(CXSC_INDEX_CHECK)
696 ;
697 #else
698  noexcept;
699 #endif
700 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) noexcept;
701  template <class M> friend int _mlb(const M &m, const int &i)
702 #if(CXSC_INDEX_CHECK)
703 ;
704 #else
705  noexcept;
706 #endif
707  template <class M> friend int _mub(const M &m, const int &i)
708 #if(CXSC_INDEX_CHECK)
709 ;
710 #else
711  noexcept;
712 #endif
713  template <class M> friend M &_msetlb(M &m, const int &i,const int &j)
714 #if(CXSC_INDEX_CHECK)
715 ;
716 #else
717  noexcept;
718 #endif
719  template <class M> friend M &_msetub(M &m, const int &i,const int &j)
720 #if(CXSC_INDEX_CHECK)
721 ;
722 #else
723  noexcept;
724 #endif
725  template <class M> friend void _mresize(M &A) noexcept;
726  template <class M,class S> friend void _mresize(M &A,const int &m, const int &n)
727 #if(CXSC_INDEX_CHECK)
728  ;
729 #else
730  noexcept;
731 #endif
732  template <class M,class S> friend void _mresize(M &A,const int &m1, const int &m2,const int &n1,const int &n2)
733 #if(CXSC_INDEX_CHECK)
734  ;
735 #else
736  noexcept;
737 #endif
738  template <class M,class E> friend E _mabs(const M &m) noexcept;
739  template <class MS,class E> friend E _msabs(const MS &ms) noexcept;
740  template <class M,class E> friend E _mdiam(const M &m) noexcept;
741  template <class M,class E> friend E _mmid(const M &m) noexcept;
742  template <class M,class E> friend E _minf(const M &m) noexcept;
743  template <class M,class E> friend E _msup(const M &m) noexcept;
744  template <class M1,class M2> friend M1 &_mmsetinf(M1 &m1,const M2 &m2)
745 #if(CXSC_INDEX_CHECK)
746  ;
747 #else
748  noexcept;
749 #endif
750  template <class M1,class M2> friend M1 &_mmsetsup(M1 &m1,const M2 &m2)
751 #if(CXSC_INDEX_CHECK)
752  ;
753 #else
754  noexcept;
755 #endif
756  template <class M1,class MS2> friend M1 &_mmssetinf(M1 &m1,const MS2 &ms2)
757 #if(CXSC_INDEX_CHECK)
758  ;
759 #else
760  noexcept;
761 #endif
762  template <class M1,class MS2> friend M1 &_mmssetsup(M1 &m1,const MS2 &ms2)
763 #if(CXSC_INDEX_CHECK)
764  ;
765 #else
766  noexcept;
767 #endif
768  template <class M1,class M2> friend M1 &_mmusetinf(M1 &m1,const M2 &m2)
769 #if(CXSC_INDEX_CHECK)
770  ;
771 #else
772  noexcept;
773 #endif
774  template <class M1,class M2> friend M1 &_mmusetsup(M1 &m1,const M2 &m2)
775 #if(CXSC_INDEX_CHECK)
776  ;
777 #else
778  noexcept;
779 #endif
780  template <class M1,class MS2> friend M1 &_mmsusetinf(M1 &m1,const MS2 &ms2)
781 #if(CXSC_INDEX_CHECK)
782  ;
783 #else
784  noexcept;
785 #endif
786  template <class M1,class MS2> friend M1 &_mmsusetsup(M1 &m1,const MS2 &ms2)
787 #if(CXSC_INDEX_CHECK)
788  ;
789 #else
790  noexcept;
791 #endif
792  //-------------- matrix-matrix -------------
793  template <class M1,class M2,class E> friend E _mmplus(const M1 &m1,const M2 &m2)
794 #if(CXSC_INDEX_CHECK)
795  ;
796 #else
797  noexcept;
798 #endif
799  template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms)
800 #if(CXSC_INDEX_CHECK)
801  ;
802 #else
803  noexcept;
804 #endif
805  template <class M> friend M _mminus(const M &m) noexcept;
806  template <class MS,class E> friend E _msminus(const MS &ms) noexcept;
807  template <class M1,class M2,class E> friend E _mmminus(const M1 &m1,const M2 &m2)
808 #if(CXSC_INDEX_CHECK)
809  ;
810 #else
811  noexcept;
812 #endif
813  template <class M1,class M2> friend M1 &_mmplusassign(M1 &m1,const M2 &m2)
814 #if(CXSC_INDEX_CHECK)
815  ;
816 #else
817  noexcept;
818 #endif
819  template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms)
820 #if(CXSC_INDEX_CHECK)
821  ;
822 #else
823  noexcept;
824 #endif
825  template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1)
826 #if(CXSC_INDEX_CHECK)
827  ;
828 #else
829  noexcept;
830 #endif
831  template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2)
832 #if(CXSC_INDEX_CHECK)
833  ;
834 #else
835  noexcept;
836 #endif
837  template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms)
838 #if(CXSC_INDEX_CHECK)
839  ;
840 #else
841  noexcept;
842 #endif
843  template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m)
844 #if(CXSC_INDEX_CHECK)
845  ;
846 #else
847  noexcept;
848 #endif
849  template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2)
850 #if(CXSC_INDEX_CHECK)
851  ;
852 #else
853  noexcept;
854 #endif
855  template <class M1,class M2> friend M1 &_mmminusassign(M1 &m1,const M2 &m2)
856 #if(CXSC_INDEX_CHECK)
857  ;
858 #else
859  noexcept;
860 #endif
861  template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms)
862 #if(CXSC_INDEX_CHECK)
863  ;
864 #else
865  noexcept;
866 #endif
867  template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1)
868 #if(CXSC_INDEX_CHECK)
869  ;
870 #else
871  noexcept;
872 #endif
873  template <class M1,class M2,class E> friend E _mmimult(const M1 &m1, const M2 &m2)
874 #if(CXSC_INDEX_CHECK)
875  ;
876 #else
877  noexcept;
878 #endif
879  template <class M1,class M2,class S> friend M1 &_mmimultassign(M1 &m1,const M2 &m2)
880 #if(CXSC_INDEX_CHECK)
881  ;
882 #else
883  noexcept;
884 #endif
885  template <class M,class MS,class E> friend E _mmsimult(const M &m1, const MS &ms)
886 #if(CXSC_INDEX_CHECK)
887  ;
888 #else
889  noexcept;
890 #endif
891  template <class MS,class M,class E> friend E _msmimult(const MS &ms, const M &m2)
892 #if(CXSC_INDEX_CHECK)
893  ;
894 #else
895  noexcept;
896 #endif
897  template <class M,class MS,class S> friend M &_mmsimultassign(M &m1,const MS &ms)
898 #if(CXSC_INDEX_CHECK)
899  ;
900 #else
901  noexcept;
902 #endif
903  template <class MS1,class MS2,class E> friend E _msmsimult(const MS1 &ms1, const MS2 &ms2)
904 #if(CXSC_INDEX_CHECK)
905  ;
906 #else
907  noexcept;
908 #endif
909  template <class M1,class M2,class E> friend E _mmconv(const M1 &m1,const M2 &m2)
910 #if(CXSC_INDEX_CHECK)
911  ;
912 #else
913  noexcept;
914 #endif
915  template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms)
916 #if(CXSC_INDEX_CHECK)
917  ;
918 #else
919  noexcept;
920 #endif
921  template <class M1,class M2> friend M1 &_mmconvassign(M1 &m1,const M2 &m2)
922 #if(CXSC_INDEX_CHECK)
923  ;
924 #else
925  noexcept;
926 #endif
927  template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms)
928 #if(CXSC_INDEX_CHECK)
929  ;
930 #else
931  noexcept;
932 #endif
933  template <class MS,class M> friend MS &_msmconvassign(MS &ms,const M &m1)
934 #if(CXSC_INDEX_CHECK)
935  ;
936 #else
937  noexcept;
938 #endif
939  template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2)
940 #if(CXSC_INDEX_CHECK)
941  ;
942 #else
943  noexcept;
944 #endif
945  template <class M1,class M2,class E> friend E _mmsect(const M1 &m1,const M2 &m2)
946 #if(CXSC_INDEX_CHECK)
947  ;
948 #else
949  noexcept;
950 #endif
951  template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms)
952 #if(CXSC_INDEX_CHECK)
953  ;
954 #else
955  noexcept;
956 #endif
957  template <class M1,class M2> friend M1 &_mmsectassign(M1 &m1,const M2 &m2)
958 #if(CXSC_INDEX_CHECK)
959  ;
960 #else
961  noexcept;
962 #endif
963  template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms)
964 #if(CXSC_INDEX_CHECK)
965  ;
966 #else
967  noexcept;
968 #endif
969  template <class MS,class M> friend MS &_msmsectassign(MS &ms,const M &m1)
970 #if(CXSC_INDEX_CHECK)
971  ;
972 #else
973  noexcept;
974 #endif
975  template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2)
976 #if(CXSC_INDEX_CHECK)
977  ;
978 #else
979  noexcept;
980 #endif
981  //-------- matrix-scalar -----------------
982  template <class S,class M,class E> friend E _smmult(const S &c, const M &m) noexcept;
983  template <class M,class S> friend M &_msmultassign(M &m,const S &c) noexcept;
984  template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) noexcept;
985  template <class M,class S,class E> friend E _msdiv(const M &m,const S &c) noexcept;
986  template <class M,class S> friend M &_msdivassign(M &m,const S &c) noexcept;
987  template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) noexcept;
988  //-------- matrix-vector ---------------------
989  template <class M,class V,class E> friend E _mvimult(const M &m,const V &v)
990 #if(CXSC_INDEX_CHECK)
991  ;
992 #else
993  noexcept;
994 #endif
995  template <class V,class M,class E> friend E _vmimult(const V &v,const M &m)
996 #if(CXSC_INDEX_CHECK)
997  ;
998 #else
999  noexcept;
1000 #endif
1001  template <class V,class M,class S> friend V &_vmimultassign(V &v,const M &m)
1002 #if(CXSC_INDEX_CHECK)
1003  ;
1004 #else
1005  noexcept;
1006 #endif
1007  template <class VS,class M,class S> friend VS &_vsmimultassign(VS &v,const M &m)
1008 #if(CXSC_INDEX_CHECK)
1009  ;
1010 #else
1011  noexcept;
1012 #endif
1013 
1014  template <class M> friend void *_mvoid(const M &m) noexcept;
1015  template <class M> friend bool _mnot(const M &m) noexcept;
1016  template <class MS> friend void *_msvoid(const MS &ms) noexcept;
1017  template <class MS> friend bool _msnot(const MS &ms) noexcept;
1018  template <class M1,class M2> friend bool _mmeq(const M1 &m1,const M2 &m2) noexcept;
1019  template <class M1,class M2> friend bool _mmneq(const M1 &m1,const M2 &m2) noexcept;
1020  template <class M1,class M2> friend bool _mmless(const M1 &m1,const M2 &m2) noexcept;
1021  template <class M1,class M2> friend bool _mmleq(const M1 &m1,const M2 &m2) noexcept;
1022  template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) noexcept;
1023  template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) noexcept;
1024  template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) noexcept;
1025  template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) noexcept;
1026  template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) noexcept;
1027  template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) noexcept;
1028  template <class M> friend std::ostream &_mout(std::ostream &s,const M &r) noexcept;
1029  template <class M> friend std::istream &_min(std::istream &s,M &r) noexcept;
1030 
1031  //--- Real --------- matrix-vector ----------------------
1032  template <class MS,class V,class E> friend E _msvimult(const MS &ms,const V &v)
1033 #if(CXSC_INDEX_CHECK)
1034  ;
1035 #else
1036  noexcept;
1037 #endif
1038  template <class V,class MS,class E> friend E _vmsimult(const V &v,const MS &ms)
1039 #if(CXSC_INDEX_CHECK)
1040  ;
1041 #else
1042  noexcept;
1043 #endif
1044 
1045  // complex -----------
1046  // matrix-matrix
1047  template <class M1,class M2,class E> friend E _mmcimult(const M1 &m1, const M2 &m2)
1048 #if(CXSC_INDEX_CHECK)
1049  ;
1050 #else
1051  noexcept;
1052 #endif
1053  template <class M,class MS,class E> friend E _mmscimult(const M &m1, const MS &ms)
1054 #if(CXSC_INDEX_CHECK)
1055  ;
1056 #else
1057  noexcept;
1058 #endif
1059  template <class MS,class M,class E> friend E _msmcimult(const MS &ms, const M &m2)
1060 #if(CXSC_INDEX_CHECK)
1061  ;
1062 #else
1063  noexcept;
1064 #endif
1065  template <class MS1,class MS2,class E> friend E _msmscimult(const MS1 &ms1, const MS2 &ms2)
1066 #if(CXSC_INDEX_CHECK)
1067  ;
1068 #else
1069  noexcept;
1070 #endif
1071 
1072  // matrix-vector
1073  template <class M,class V,class E> friend E _mvcimult(const M &m,const V &v)
1074 #if(CXSC_INDEX_CHECK)
1075  ;
1076 #else
1077  noexcept;
1078 #endif
1079  template <class V,class M,class E> friend E _vmcimult(const V &v,const M &m)
1080 #if(CXSC_INDEX_CHECK)
1081  ;
1082 #else
1083  noexcept;
1084 #endif
1085  /* friend TINLINE civector _mvscimult<imatrix,cvector_slice,civector>(const imatrix &m,const cvector_slice &v)
1086 #if(CXSC_INDEX_CHECK)
1087 ;
1088 #else
1089  noexcept;
1090  #endif */
1091  /* friend TINLINE civector _vsmcimult<cvector_slice,imatrix,civector>(const cvector_slice &v,const imatrix &m)
1092 #if(CXSC_INDEX_CHECK)
1093 ;
1094 #else
1095  noexcept;
1096  #endif */
1097 
1098  // cinterval--------
1099  template <class M,class E> friend E _mre(const M &m) noexcept;
1100  template <class M,class E> friend E _mim(const M &m) noexcept;
1101  template <class MS,class E> friend E _msre(const MS &ms) noexcept;
1102  template <class MS,class E> friend E _msim(const MS &ms) noexcept;
1103  template <class M1,class M2> friend M1 &_mmsetre(M1 &m1,const M2 &m2)
1104 #if(CXSC_INDEX_CHECK)
1105  ;
1106 #else
1107  noexcept;
1108 #endif
1109  template <class M1,class M2> friend M1 &_mmsetim(M1 &m1,const M2 &m2)
1110 #if(CXSC_INDEX_CHECK)
1111  ;
1112 #else
1113  noexcept;
1114 #endif
1115  template <class MS1,class M2> friend MS1 &_msmsetre(MS1 &ms1,const M2 &m2)
1116 #if(CXSC_INDEX_CHECK)
1117  ;
1118 #else
1119  noexcept;
1120 #endif
1121  template <class MS1,class M2> friend MS1 &_msmsetim(MS1 &ms1,const M2 &m2)
1122 #if(CXSC_INDEX_CHECK)
1123  ;
1124 #else
1125  noexcept;
1126 #endif
1127 
1128  // matrix-matrix
1129  template <class M1,class M2,class S> friend M1 &_mmcimultassign(M1 &m1,const M2 &m2)
1130 #if(CXSC_INDEX_CHECK)
1131  ;
1132 #else
1133  noexcept;
1134 #endif
1135  template <class M,class MS,class S> friend M &_mmscimultassign(M &m1,const MS &ms)
1136 #if(CXSC_INDEX_CHECK)
1137  ;
1138 #else
1139  noexcept;
1140 #endif
1141 
1142  // matrix-vector
1143  template <class V,class M,class S> friend V &_vmcimultassign(V &v,const M &m)
1144 #if(CXSC_INDEX_CHECK)
1145  ;
1146 #else
1147  noexcept;
1148 #endif
1149  template <class VS,class M,class S> friend VS &_vsmcimultassign(VS &v,const M &m)
1150 #if(CXSC_INDEX_CHECK)
1151  ;
1152 #else
1153  noexcept;
1154 #endif
1155 
1156  /* friend TINLINE civector _mvscimult<imatrix,civector_slice,civector>(const imatrix &m,const civector_slice &v)
1157 #if(CXSC_INDEX_CHECK)
1158 ;
1159 #else
1160  noexcept;
1161  #endif */
1162  /* friend TINLINE civector _vsmcimult<civector_slice,imatrix,civector>(const civector_slice &v,const imatrix &m)
1163 #if(CXSC_INDEX_CHECK)
1164 ;
1165 #else
1166  noexcept;
1167  #endif */
1168 
1169  // l_real -----------
1170  // matrix-matrix
1171  template <class M1,class M2,class E> friend E _mmlimult(const M1 &m1, const M2 &m2)
1172 #if(CXSC_INDEX_CHECK)
1173  ;
1174 #else
1175  noexcept;
1176 #endif
1177  template <class M,class MS,class E> friend E _mmslimult(const M &m1, const MS &ms)
1178 #if(CXSC_INDEX_CHECK)
1179  ;
1180 #else
1181  noexcept;
1182 #endif
1183  template <class MS,class M,class E> friend E _msmlimult(const MS &ms, const M &m2)
1184 #if(CXSC_INDEX_CHECK)
1185  ;
1186 #else
1187  noexcept;
1188 #endif
1189  template <class MS1,class MS2,class E> friend E _msmslimult(const MS1 &ms1, const MS2 &ms2)
1190 #if(CXSC_INDEX_CHECK)
1191  ;
1192 #else
1193  noexcept;
1194 #endif
1195 
1196  // matrix-vector
1197  template <class M,class V,class E> friend E _mvlimult(const M &m,const V &v)
1198 #if(CXSC_INDEX_CHECK)
1199  ;
1200 #else
1201  noexcept;
1202 #endif
1203  template <class V,class M,class E> friend E _vmlimult(const V &v,const M &m)
1204 #if(CXSC_INDEX_CHECK)
1205  ;
1206 #else
1207  noexcept;
1208 #endif
1209  /* friend TINLINE l_ivector _mvslimult<imatrix,l_rvector_slice,l_ivector>(const imatrix &m,const l_rvector_slice &v)
1210 #if(CXSC_INDEX_CHECK)
1211 ;
1212 #else
1213  noexcept;
1214  #endif */
1215  /* friend TINLINE l_ivector _vsmlimult<l_rvector_slice,imatrix,l_ivector>(const l_rvector_slice &v,const imatrix &m)
1216 #if(CXSC_INDEX_CHECK)
1217 ;
1218 #else
1219  noexcept;
1220  #endif */
1221 
1222  // matrix-matrix
1223  template <class M1,class M2,class S> friend M1 &_mmlimultassign(M1 &m1,const M2 &m2)
1224 #if(CXSC_INDEX_CHECK)
1225  ;
1226 #else
1227  noexcept;
1228 #endif
1229  template <class M,class MS,class S> friend M &_mmslimultassign(M &m1,const MS &ms)
1230 #if(CXSC_INDEX_CHECK)
1231  ;
1232 #else
1233  noexcept;
1234 #endif
1235 
1236  // matrix-vector
1237  template <class V,class M,class S> friend V &_vmlimultassign(V &v,const M &m)
1238 #if(CXSC_INDEX_CHECK)
1239  ;
1240 #else
1241  noexcept;
1242 #endif
1243  template <class VS,class M,class S> friend VS &_vsmlimultassign(VS &v,const M &m)
1244 #if(CXSC_INDEX_CHECK)
1245  ;
1246 #else
1247  noexcept;
1248 #endif
1249 
1250 /* friend TINLINE l_ivector _mvslimult<imatrix,l_ivector_slice,l_ivector>(const imatrix &m,const l_ivector_slice &v)
1251 #if(CXSC_INDEX_CHECK)
1252 ;
1253 #else
1254  noexcept;
1255  #endif */
1256  /* friend TINLINE l_ivector _vsmlimult<l_ivector_slice,imatrix,l_ivector>(const l_ivector_slice &v,const imatrix &m)
1257 #if(CXSC_INDEX_CHECK)
1258 ;
1259 #else
1260  noexcept;
1261  #endif */
1262 
1263 #endif
1264 
1265  //-------------------------- Konstruktoren ----------------------------
1266 
1267 // interval
1269  INLINE imatrix(const imatrix &rm) noexcept;
1271  INLINE imatrix(const imatrix_slice &rm) noexcept;
1273  INLINE imatrix(const simatrix &rm);
1275  INLINE imatrix(const simatrix_slice &rm);
1277  INLINE imatrix() noexcept;
1279  explicit INLINE imatrix(const int &m, const int &n)
1280 #if(CXSC_INDEX_CHECK)
1281 ;
1282 #else
1283  noexcept;
1284 #endif
1286  explicit INLINE imatrix(const int &m1, const int &n1, const int &m2, const int &n2)
1287 #if(CXSC_INDEX_CHECK)
1288 ;
1289 #else
1290  noexcept;
1291 #endif
1293  explicit INLINE imatrix(const ivector &v) noexcept;
1295  explicit INLINE imatrix(const ivector_slice &v) noexcept;
1297  explicit INLINE imatrix(const interval &r) noexcept;
1299  INLINE imatrix &operator =(const interval &r) noexcept;
1301  INLINE imatrix &operator =(const imatrix &m) noexcept;
1303  INLINE imatrix &operator =(const imatrix_slice &ms) noexcept;
1305  INLINE imatrix &operator =(const simatrix &m);
1307  INLINE imatrix &operator =(const simatrix_slice &ms);
1309  INLINE imatrix &operator =(const ivector &v) noexcept;
1311  INLINE imatrix &operator =(const ivector_slice &v) noexcept;
1312 // real
1314  explicit INLINE imatrix(const real &r) noexcept;
1316  explicit INLINE imatrix(const rmatrix &rm) noexcept;
1318  explicit INLINE imatrix(const rmatrix_slice &rm) noexcept;
1320  explicit INLINE imatrix(const srmatrix &rm);
1322  explicit INLINE imatrix(const srmatrix_slice &rm);
1324  explicit INLINE imatrix(const rvector &v) noexcept;
1326  explicit INLINE imatrix(const rvector_slice &v) noexcept;
1328  INLINE imatrix &operator =(const real &r) noexcept;
1330  INLINE imatrix &operator =(const rmatrix &m) noexcept;
1332  INLINE imatrix &operator =(const rmatrix_slice &ms) noexcept;
1334  INLINE imatrix &operator =(const srmatrix &m);
1336  INLINE imatrix &operator =(const srmatrix_slice &ms);
1338  INLINE imatrix &operator =(const rvector &v) noexcept;
1340  INLINE imatrix &operator =(const rvector_slice &v) noexcept;
1341 
1342  //--------------------------- Destruktoren -----------------------------
1343 
1344  INLINE ~imatrix() noexcept { delete [] dat; }
1345 
1346  //--------------------------- Operatoren -----------------------------
1347 
1349  INLINE imatrix &operator+=(const simatrix&);
1351  INLINE imatrix &operator+=(const simatrix_slice&);
1353  INLINE imatrix &operator+=(const srmatrix&);
1355  INLINE imatrix &operator+=(const srmatrix_slice&);
1357  INLINE imatrix &operator-=(const simatrix&);
1359  INLINE imatrix &operator-=(const simatrix_slice&);
1361  INLINE imatrix &operator-=(const srmatrix&);
1363  INLINE imatrix &operator-=(const srmatrix_slice&);
1365  INLINE imatrix &operator*=(const simatrix&);
1367  INLINE imatrix &operator*=(const simatrix_slice&);
1369  INLINE imatrix &operator*=(const srmatrix&);
1371  INLINE imatrix &operator*=(const srmatrix_slice&);
1373  INLINE imatrix &operator|=(const simatrix&);
1375  INLINE imatrix &operator|=(const simatrix_slice&);
1377  INLINE imatrix &operator|=(const srmatrix&);
1379  INLINE imatrix &operator|=(const srmatrix_slice&);
1381  INLINE imatrix &operator&=(const simatrix&);
1383  INLINE imatrix &operator&=(const simatrix_slice&);
1385  INLINE imatrix &operator&=(const srmatrix&);
1387  INLINE imatrix &operator&=(const srmatrix_slice&);
1388 
1390  INLINE imatrix operator()(const intvector& p, const intvector& q);
1392  INLINE imatrix operator()(const intmatrix& P, const intmatrix& Q);
1394  INLINE imatrix operator()(const intvector& p);
1396  INLINE imatrix operator()(const intmatrix& P);
1397 
1398  //------------------------- Standardfunktionen -------------------------
1399 
1401  INLINE imatrix_subv operator [](const int &i) const
1402 #if(CXSC_INDEX_CHECK)
1403 ;
1404 #else
1405  noexcept;
1406 #endif
1408  INLINE imatrix_subv operator [](const cxscmatrix_column &i) const
1409 #if(CXSC_INDEX_CHECK)
1410 ;
1411 #else
1412  noexcept;
1413 #endif
1415  INLINE imatrix &operator ()() noexcept { return *this; }
1417  INLINE imatrix_slice operator ()(const int &m, const int &n)
1418 #if(CXSC_INDEX_CHECK)
1419 ;
1420 #else
1421  noexcept;
1422 #endif
1424  INLINE imatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
1425 #if(CXSC_INDEX_CHECK)
1426 ;
1427 #else
1428  noexcept;
1429 #endif
1430  INLINE operator void*() noexcept;
1431 //#else
1432 //#endif
1433 };
1434 
1436 
1442 {
1443  friend class imatrix;
1444  friend class cimatrix;
1445  friend class l_imatrix;
1446  private:
1447  interval *dat;
1448  int offset1,offset2,mxsize,mysize;
1449  int start1,end1,start2,end2,sxsize,sysize; // slice size
1450 
1451  public:
1452 //#if(CXSC_INDEX_CHECK)
1453 #ifdef _CXSC_FRIEND_TPL
1454  //----------------- Templates ---------------------------------------
1455 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m)
1456 #if(CXSC_INDEX_CHECK)
1457 ;
1458 #else
1459  noexcept;
1460 #endif
1461  template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m)
1462 #if(CXSC_INDEX_CHECK)
1463  ;
1464 #else
1465  noexcept;
1466 #endif
1467  template <class MS1,class MS2> friend MS1 &_msmsassign(MS1 &ms1,const MS2 &ms)
1468 #if(CXSC_INDEX_CHECK)
1469  ;
1470 #else
1471  noexcept;
1472 #endif
1473  template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) noexcept;
1474  template <class MS,class S> friend MS &_mssassign(MS &ms,const S &r) noexcept;
1475  template <class MS> friend int _mslb(const MS &ms, const int &i)
1476 #if(CXSC_INDEX_CHECK)
1477 ;
1478 #else
1479  noexcept;
1480 #endif
1481  template <class MS> friend int _msub(const MS &ms, const int &i)
1482 #if(CXSC_INDEX_CHECK)
1483 ;
1484 #else
1485  noexcept;
1486 #endif
1487  template <class MS,class E> friend E _msabs(const MS &ms) noexcept;
1488  template <class MS,class E> friend E _msdiam(const MS &ms) noexcept;
1489  template <class MS,class E> friend E _msmid(const MS &ms) noexcept;
1490  template <class MS,class E> friend E _msinf(const MS &ms) noexcept;
1491  template <class MS,class E> friend E _mssup(const MS &ms) noexcept;
1492  template <class MS1,class M2> friend MS1 &_msmsetinf(MS1 &ms1,const M2 &m2)
1493 #if(CXSC_INDEX_CHECK)
1494  ;
1495 #else
1496  noexcept;
1497 #endif
1498  template <class MS1,class M2> friend MS1 &_msmsetsup(MS1 &ms1,const M2 &m2)
1499 #if(CXSC_INDEX_CHECK)
1500  ;
1501 #else
1502  noexcept;
1503 #endif
1504  template <class MS1,class MS2> friend MS1 &_msmssetinf(MS1 &ms1,const MS2 &ms2)
1505 #if(CXSC_INDEX_CHECK)
1506  ;
1507 #else
1508  noexcept;
1509 #endif
1510  template <class MS1,class MS2> friend MS1 &_msmssetsup(MS1 &ms1,const MS2 &ms2)
1511 #if(CXSC_INDEX_CHECK)
1512  ;
1513 #else
1514  noexcept;
1515 #endif
1516  template <class MS1,class M2> friend MS1 &_msmusetinf(MS1 &ms1,const M2 &m2)
1517 #if(CXSC_INDEX_CHECK)
1518  ;
1519 #else
1520  noexcept;
1521 #endif
1522  template <class MS1,class M2> friend MS1 &_msmusetsup(MS1 &ms1,const M2 &m2)
1523 #if(CXSC_INDEX_CHECK)
1524  ;
1525 #else
1526  noexcept;
1527 #endif
1528  template <class MS1,class MS2> friend MS1 &_msmsusetinf(MS1 &ms1,const MS2 &ms2)
1529 #if(CXSC_INDEX_CHECK)
1530  ;
1531 #else
1532  noexcept;
1533 #endif
1534  template <class MS1,class MS2> friend MS1 &_msmsusetsup(MS1 &ms1,const MS2 &ms2)
1535 #if(CXSC_INDEX_CHECK)
1536  ;
1537 #else
1538  noexcept;
1539 #endif
1540  //-------- matrix-matrix --------------
1541  template <class MS,class E> friend E _msminus(const MS &ms) noexcept;
1542  template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms)
1543 #if(CXSC_INDEX_CHECK)
1544  ;
1545 #else
1546  noexcept;
1547 #endif
1548  template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2)
1549 #if(CXSC_INDEX_CHECK)
1550  ;
1551 #else
1552  noexcept;
1553 #endif
1554  template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms)
1555 #if(CXSC_INDEX_CHECK)
1556  ;
1557 #else
1558  noexcept;
1559 #endif
1560  template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1)
1561 #if(CXSC_INDEX_CHECK)
1562  ;
1563 #else
1564  noexcept;
1565 #endif
1566  template <class MS1,class MS2> friend MS1 &_msmsplusassign(MS1 &ms1,const MS2 &ms2)
1567 #if(CXSC_INDEX_CHECK)
1568  ;
1569 #else
1570  noexcept;
1571 #endif
1572  template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms)
1573 #if(CXSC_INDEX_CHECK)
1574  ;
1575 #else
1576  noexcept;
1577 #endif
1578  template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m)
1579 #if(CXSC_INDEX_CHECK)
1580  ;
1581 #else
1582  noexcept;
1583 #endif
1584  template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2)
1585 #if(CXSC_INDEX_CHECK)
1586  ;
1587 #else
1588  noexcept;
1589 #endif
1590  template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms)
1591 #if(CXSC_INDEX_CHECK)
1592  ;
1593 #else
1594  noexcept;
1595 #endif
1596  template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1)
1597 #if(CXSC_INDEX_CHECK)
1598  ;
1599 #else
1600  noexcept;
1601 #endif
1602  template <class MS1,class MS2> friend MS1 &_msmsminusassign(MS1 &ms1,const MS2 &ms2)
1603 #if(CXSC_INDEX_CHECK)
1604  ;
1605 #else
1606  noexcept;
1607 #endif
1608  template <class M,class MS,class E> friend E _mmsimult(const M &m1, const MS &ms)
1609 #if(CXSC_INDEX_CHECK)
1610  ;
1611 #else
1612  noexcept;
1613 #endif
1614  template <class MS,class M,class E> friend E _msmimult(const MS &ms, const M &m2)
1615 #if(CXSC_INDEX_CHECK)
1616  ;
1617 #else
1618  noexcept;
1619 #endif
1620  template <class M,class MS,class S> friend M &_mmsimultassign(M &m1,const MS &ms)
1621 #if(CXSC_INDEX_CHECK)
1622  ;
1623 #else
1624  noexcept;
1625 #endif
1626  template <class MS1,class MS2,class E> friend E _msmsimult(const MS1 &ms1, const MS2 &ms2)
1627 #if(CXSC_INDEX_CHECK)
1628  ;
1629 #else
1630  noexcept;
1631 #endif
1632  template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms)
1633 #if(CXSC_INDEX_CHECK)
1634  ;
1635 #else
1636  noexcept;
1637 #endif
1638  template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms)
1639 #if(CXSC_INDEX_CHECK)
1640  ;
1641 #else
1642  noexcept;
1643 #endif
1644  template <class MS,class M> friend MS &_msmconvassign(MS &ms,const M &m1)
1645 #if(CXSC_INDEX_CHECK)
1646  ;
1647 #else
1648  noexcept;
1649 #endif
1650  template <class MS1,class MS2> friend MS1 &_msmsconvassign(MS1 &ms1,const MS2 &ms2)
1651 #if(CXSC_INDEX_CHECK)
1652  ;
1653 #else
1654  noexcept;
1655 #endif
1656  template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2)
1657 #if(CXSC_INDEX_CHECK)
1658  ;
1659 #else
1660  noexcept;
1661 #endif
1662  template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms)
1663 #if(CXSC_INDEX_CHECK)
1664  ;
1665 #else
1666  noexcept;
1667 #endif
1668  template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms)
1669 #if(CXSC_INDEX_CHECK)
1670  ;
1671 #else
1672  noexcept;
1673 #endif
1674  template <class MS,class M> friend MS &_msmsectassign(MS &ms,const M &m1)
1675 #if(CXSC_INDEX_CHECK)
1676  ;
1677 #else
1678  noexcept;
1679 #endif
1680  template <class MS1,class MS2> friend MS1 &_msmssectassign(MS1 &ms1,const MS2 &ms2)
1681 #if(CXSC_INDEX_CHECK)
1682  ;
1683 #else
1684  noexcept;
1685 #endif
1686  template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2)
1687 #if(CXSC_INDEX_CHECK)
1688  ;
1689 #else
1690  noexcept;
1691 #endif
1692  //--------- matrix-vector --------------
1693  template <class MS,class V,class E> friend E _msvimult(const MS &ms,const V &v)
1694 #if(CXSC_INDEX_CHECK)
1695  ;
1696 #else
1697  noexcept;
1698 #endif
1699  template <class V,class MS,class E> friend E _vmsimult(const V &v,const MS &ms)
1700 #if(CXSC_INDEX_CHECK)
1701  ;
1702 #else
1703  noexcept;
1704 #endif
1705  template <class V,class MS,class S> friend V &_vmsimultassign(V &v,const MS &ms)
1706 #if(CXSC_INDEX_CHECK)
1707  ;
1708 #else
1709  noexcept;
1710 #endif
1711  //--------- matrix-scalar --------------
1712  template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) noexcept;
1713  template <class MS,class S> friend MS &_mssmultassign(MS &ms,const S &c) noexcept;
1714  template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) noexcept;
1715  template <class MS,class S> friend MS &_mssdivassign(MS &ms,const S &c) noexcept;
1716 
1717  template <class MS> friend void *_msvoid(const MS &ms) noexcept;
1718  template <class MS> friend bool _msnot(const MS &ms) noexcept;
1719  template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) noexcept;
1720  template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) noexcept;
1721  template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) noexcept;
1722  template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) noexcept;
1723  template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) noexcept;
1724  template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) noexcept;
1725  template <class MS1,class MS2> friend bool _msmseq(const MS1 &ms1,const MS2 &ms2) noexcept;
1726  template <class MS1,class MS2> friend bool _msmsneq(const MS1 &ms1,const MS2 &ms2) noexcept;
1727  template <class MS1,class MS2> friend bool _msmsless(const MS1 &ms1,const MS2 &ms2) noexcept;
1728  template <class MS1,class MS2> friend bool _msmsleq(const MS1 &ms1,const MS2 &ms2) noexcept;
1729  template <class MS> friend std::ostream &_msout(std::ostream &s,const MS &r) noexcept;
1730  template <class MS> friend std::istream &_msin(std::istream &s,MS &r) noexcept;
1731 
1732  // complex ---------
1733  // matrix-matrix
1734  template <class M,class MS,class E> friend E _mmscimult(const M &m1, const MS &ms)
1735 #if(CXSC_INDEX_CHECK)
1736  ;
1737 #else
1738  noexcept;
1739 #endif
1740  template <class MS,class M,class E> friend E _msmcimult(const MS &ms, const M &m2)
1741 #if(CXSC_INDEX_CHECK)
1742  ;
1743 #else
1744  noexcept;
1745 #endif
1746  template <class MS1,class MS2,class E> friend E _msmscimult(const MS1 &ms1, const MS2 &ms2)
1747 #if(CXSC_INDEX_CHECK)
1748  ;
1749 #else
1750  noexcept;
1751 #endif
1752 
1753  // matrix-vector
1754  template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v)
1755 #if(CXSC_INDEX_CHECK)
1756  ;
1757 #else
1758  noexcept;
1759 #endif
1760  template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms)
1761 #if(CXSC_INDEX_CHECK)
1762  ;
1763 #else
1764  noexcept;
1765 #endif
1766 
1767  // civector --------
1768  template <class M1,class MS2> friend M1 &_mmssetre(M1 &m1,const MS2 &ms2)
1769 #if(CXSC_INDEX_CHECK)
1770  ;
1771 #else
1772  noexcept;
1773 #endif
1774  template <class M1,class MS2> friend M1 &_mmssetim(M1 &m1,const MS2 &ms2)
1775 #if(CXSC_INDEX_CHECK)
1776  ;
1777 #else
1778  noexcept;
1779 #endif
1780  template <class MS1,class MS2> friend MS1 &_msmssetre(MS1 &ms1,const MS2 &ms2)
1781 #if(CXSC_INDEX_CHECK)
1782  ;
1783 #else
1784  noexcept;
1785 #endif
1786  template <class MS1,class MS2> friend MS1 &_msmssetim(MS1 &ms1,const MS2 &ms2)
1787 #if(CXSC_INDEX_CHECK)
1788  ;
1789 #else
1790  noexcept;
1791 #endif
1792  // matrix-matrix
1793  template <class M,class MS,class S> friend M &_mmscimultassign(M &m1,const MS &ms)
1794 #if(CXSC_INDEX_CHECK)
1795  ;
1796 #else
1797  noexcept;
1798 #endif
1799 
1800  // matrix-vector
1801  template <class V,class MS,class S> friend V &_vmscimultassign(V &v,const MS &ms)
1802 #if(CXSC_INDEX_CHECK)
1803  ;
1804 #else
1805  noexcept;
1806 #endif
1807 
1808  /* friend TINLINE civector _msvscimult<imatrix_slice,civector_slice,civector>(const imatrix_slice &ms,const civector_slice &v)
1809 #if(CXSC_INDEX_CHECK)
1810 ;
1811 #else
1812  noexcept;
1813  #endif */
1814  /* friend TINLINE civector _vsmscimult<civector_slice,imatrix_slice,civector>(const civector_slice &v,const imatrix_slice &ms)
1815 #if(CXSC_INDEX_CHECK)
1816 ;
1817 #else
1818  noexcept;
1819  #endif */
1820  /* friend TINLINE civector &_vsmscimultassign<civector_slice,imatrix_slice,cinterval>(civector_slice &v,const imatrix_slice &m)
1821 #if(CXSC_INDEX_CHECK)
1822 ;
1823 #else
1824  noexcept;
1825  #endif */
1826 
1827  // l_real ---------
1828  // matrix-matrix
1829  template <class M,class MS,class E> friend E _mmslimult(const M &m1, const MS &ms)
1830 #if(CXSC_INDEX_CHECK)
1831  ;
1832 #else
1833  noexcept;
1834 #endif
1835  template <class MS,class M,class E> friend E _msmlimult(const MS &ms, const M &m2)
1836 #if(CXSC_INDEX_CHECK)
1837  ;
1838 #else
1839  noexcept;
1840 #endif
1841  template <class MS1,class MS2,class E> friend E _msmslimult(const MS1 &ms1, const MS2 &ms2)
1842 #if(CXSC_INDEX_CHECK)
1843  ;
1844 #else
1845  noexcept;
1846 #endif
1847 
1848  // matrix-vector
1849  template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v)
1850 #if(CXSC_INDEX_CHECK)
1851  ;
1852 #else
1853  noexcept;
1854 #endif
1855  template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms)
1856 #if(CXSC_INDEX_CHECK)
1857  ;
1858 #else
1859  noexcept;
1860 #endif
1861 
1862  // matrix-matrix
1863  template <class M,class MS,class S> friend M &_mmslimultassign(M &m1,const MS &ms)
1864 #if(CXSC_INDEX_CHECK)
1865  ;
1866 #else
1867  noexcept;
1868 #endif
1869 
1870  // matrix-vector
1871  template <class V,class MS,class S> friend V &_vmslimultassign(V &v,const MS &ms)
1872 #if(CXSC_INDEX_CHECK)
1873  ;
1874 #else
1875  noexcept;
1876 #endif
1877 
1878  /* friend TINLINE l_ivector _msvslimult<imatrix_slice,l_ivector_slice,l_ivector>(const imatrix_slice &ms,const l_ivector_slice &v)
1879 #if(CXSC_INDEX_CHECK)
1880 ;
1881 #else
1882  noexcept;
1883  #endif */
1884  /* friend TINLINE l_ivector _vsmslimult<l_ivector_slice,imatrix_slice,l_ivector>(const l_ivector_slice &v,const imatrix_slice &ms)
1885 #if(CXSC_INDEX_CHECK)
1886 ;
1887 #else
1888  noexcept;
1889  #endif */
1890  /* friend TINLINE l_ivector &_vsmslimultassign<l_ivector_slice,imatrix_slice,l_interval>(l_ivector_slice &v,const imatrix_slice &m)
1891 #if(CXSC_INDEX_CHECK)
1892 ;
1893 #else
1894  noexcept;
1895  #endif */
1896 #endif
1897 
1898  //--------------- Konstruktoren ----------------------------------------
1899 
1901  explicit INLINE imatrix_slice(imatrix &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) { }
1903  explicit INLINE imatrix_slice(imatrix_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) { }
1904  public:
1906  INLINE imatrix_slice(const imatrix_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) { }
1907  public:
1908 
1909  //---------------- Standardfunktionen -----------------------------------
1910 
1911  friend INLINE ivector::ivector(const imatrix_slice &sl)
1912 #if(CXSC_INDEX_CHECK)
1913 ;
1914 #else
1915  noexcept;
1916 #endif
1917  friend INLINE imatrix::imatrix(const imatrix_slice &) noexcept;
1919  INLINE imatrix_slice &operator =(const imatrix &m)
1920 #if(CXSC_INDEX_CHECK)
1921 ;
1922 #else
1923  noexcept;
1924 #endif
1926  INLINE imatrix_slice &operator =(const imatrix_slice &ms)
1927 #if(CXSC_INDEX_CHECK)
1928 ;
1929 #else
1930  noexcept;
1931 #endif
1933  INLINE imatrix_slice &operator =(const interval &r) noexcept;
1935  INLINE imatrix_slice &operator =(const ivector &v)
1936 #if(CXSC_INDEX_CHECK)
1937 ;
1938 #else
1939  noexcept;
1940 #endif
1942  INLINE imatrix_slice &operator =(const ivector_slice &v)
1943 #if(CXSC_INDEX_CHECK)
1944 ;
1945 #else
1946  noexcept;
1947 #endif
1949  INLINE imatrix_slice &operator =(const rmatrix &m)
1950 #if(CXSC_INDEX_CHECK)
1951 ;
1952 #else
1953  noexcept;
1954 #endif
1956  INLINE imatrix_slice &operator =(const rmatrix_slice &ms)
1957 #if(CXSC_INDEX_CHECK)
1958 ;
1959 #else
1960  noexcept;
1961 #endif
1963  INLINE imatrix_slice &operator =(const real &r) noexcept;
1965  INLINE imatrix_slice &operator =(const rvector &v)
1966 #if(CXSC_INDEX_CHECK)
1967 ;
1968 #else
1969  noexcept;
1970 #endif
1972  INLINE imatrix_slice &operator =(const rvector_slice &v)
1973 #if(CXSC_INDEX_CHECK)
1974 ;
1975 #else
1976  noexcept;
1977 #endif
1979  INLINE imatrix_subv operator [](const int &i)
1980 #if(CXSC_INDEX_CHECK)
1981 ;
1982 #else
1983  noexcept;
1984 #endif
1986  INLINE imatrix_subv operator [](const cxscmatrix_column &i)
1987 #if(CXSC_INDEX_CHECK)
1988 ;
1989 #else
1990  noexcept;
1991 #endif
1992 
1994  INLINE imatrix_subv operator [](const int &i) const
1995 #if(CXSC_INDEX_CHECK)
1996 ;
1997 #else
1998  noexcept;
1999 #endif
2001  INLINE imatrix_subv operator [](const cxscmatrix_column &i) const
2002 #if(CXSC_INDEX_CHECK)
2003 ;
2004 #else
2005  noexcept;
2006 #endif
2007 
2008 
2010  INLINE imatrix_slice &operator ()() noexcept { return *this; }
2012  INLINE imatrix_slice operator ()(const int &m, const int &n)
2013 #if(CXSC_INDEX_CHECK)
2014 ;
2015 #else
2016  noexcept;
2017 #endif
2019  INLINE imatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
2020 #if(CXSC_INDEX_CHECK)
2021 ;
2022 #else
2023  noexcept;
2024 #endif
2026  INLINE imatrix_slice &operator *=(const imatrix &m)
2027 #if(CXSC_INDEX_CHECK)
2028 ;
2029 #else
2030  noexcept;
2031 #endif
2033  INLINE imatrix_slice &operator *=(const rmatrix &m)
2034 #if(CXSC_INDEX_CHECK)
2035 ;
2036 #else
2037  noexcept;
2038 #endif
2040  INLINE imatrix_slice &operator *=(const imatrix_slice &ms2)
2041 #if(CXSC_INDEX_CHECK)
2042 ;
2043 #else
2044  noexcept;
2045 #endif
2047  INLINE imatrix_slice &operator *=(const rmatrix_slice &ms2)
2048 #if(CXSC_INDEX_CHECK)
2049 ;
2050 #else
2051  noexcept;
2052 #endif
2054  INLINE imatrix_slice &operator +=(const imatrix &m1)
2055 #if(CXSC_INDEX_CHECK)
2056 ;
2057 #else
2058  noexcept;
2059 #endif
2061  INLINE imatrix_slice &operator +=(const rmatrix &m1)
2062 #if(CXSC_INDEX_CHECK)
2063 ;
2064 #else
2065  noexcept;
2066 #endif
2068  INLINE imatrix_slice &operator +=(const imatrix_slice &ms2)
2069 #if(CXSC_INDEX_CHECK)
2070 ;
2071 #else
2072  noexcept;
2073 #endif
2075  INLINE imatrix_slice &operator +=(const rmatrix_slice &ms2)
2076 #if(CXSC_INDEX_CHECK)
2077 ;
2078 #else
2079  noexcept;
2080 #endif
2082  INLINE imatrix_slice &operator -=(const imatrix &m1)
2083 #if(CXSC_INDEX_CHECK)
2084 ;
2085 #else
2086  noexcept;
2087 #endif
2089  INLINE imatrix_slice &operator -=(const rmatrix &m1)
2090 #if(CXSC_INDEX_CHECK)
2091 ;
2092 #else
2093  noexcept;
2094 #endif
2096  INLINE imatrix_slice &operator -=(const imatrix_slice &ms2)
2097 #if(CXSC_INDEX_CHECK)
2098 ;
2099 #else
2100  noexcept;
2101 #endif
2103  INLINE imatrix_slice &operator -=(const rmatrix_slice &ms2)
2104 #if(CXSC_INDEX_CHECK)
2105 ;
2106 #else
2107  noexcept;
2108 #endif
2110  INLINE imatrix_slice &operator |=(const imatrix &m1)
2111 #if(CXSC_INDEX_CHECK)
2112 ;
2113 #else
2114  noexcept;
2115 #endif
2117  INLINE imatrix_slice &operator |=(const rmatrix &m1)
2118 #if(CXSC_INDEX_CHECK)
2119 ;
2120 #else
2121  noexcept;
2122 #endif
2124  INLINE imatrix_slice &operator |=(const imatrix_slice &ms2)
2125 #if(CXSC_INDEX_CHECK)
2126 ;
2127 #else
2128  noexcept;
2129 #endif
2131  INLINE imatrix_slice &operator |=(const rmatrix_slice &ms2)
2132 #if(CXSC_INDEX_CHECK)
2133 ;
2134 #else
2135  noexcept;
2136 #endif
2138  INLINE imatrix_slice &operator &=(const imatrix &m1)
2139 #if(CXSC_INDEX_CHECK)
2140 ;
2141 #else
2142  noexcept;
2143 #endif
2145  INLINE imatrix_slice &operator &=(const rmatrix &m1)
2146 #if(CXSC_INDEX_CHECK)
2147 ;
2148 #else
2149  noexcept;
2150 #endif
2152  INLINE imatrix_slice &operator &=(const imatrix_slice &ms2)
2153 #if(CXSC_INDEX_CHECK)
2154 ;
2155 #else
2156  noexcept;
2157 #endif
2159  INLINE imatrix_slice &operator &=(const rmatrix_slice &ms2)
2160 #if(CXSC_INDEX_CHECK)
2161 ;
2162 #else
2163  noexcept;
2164 #endif
2166  INLINE imatrix_slice &operator *=(const interval &c) noexcept;
2168  INLINE imatrix_slice &operator *=(const real &c) noexcept;
2170  INLINE imatrix_slice &operator /=(const interval &c) noexcept;
2172  INLINE imatrix_slice &operator /=(const real &c) noexcept;
2173  INLINE operator void*() noexcept;
2174 
2175  //Sparse operators
2177  INLINE imatrix_slice &operator+=(const simatrix&);
2179  INLINE imatrix_slice &operator+=(const simatrix_slice&);
2181  INLINE imatrix_slice &operator+=(const srmatrix&);
2183  INLINE imatrix_slice &operator+=(const srmatrix_slice&);
2185  INLINE imatrix_slice &operator-=(const simatrix&);
2187  INLINE imatrix_slice &operator-=(const simatrix_slice&);
2189  INLINE imatrix_slice &operator-=(const srmatrix&);
2191  INLINE imatrix_slice &operator-=(const srmatrix_slice&);
2193  INLINE imatrix_slice &operator*=(const simatrix&);
2195  INLINE imatrix_slice &operator*=(const simatrix_slice&);
2197  INLINE imatrix_slice &operator*=(const srmatrix&);
2199  INLINE imatrix_slice &operator*=(const srmatrix_slice&);
2201  INLINE imatrix_slice &operator|=(const simatrix&);
2203  INLINE imatrix_slice &operator|=(const simatrix_slice&);
2205  INLINE imatrix_slice &operator|=(const srmatrix&);
2207  INLINE imatrix_slice &operator|=(const srmatrix_slice&);
2209  INLINE imatrix_slice &operator&=(const simatrix&);
2211  INLINE imatrix_slice &operator&=(const simatrix_slice&);
2213  INLINE imatrix_slice &operator&=(const srmatrix&);
2215  INLINE imatrix_slice &operator&=(const srmatrix_slice&);
2216 
2217 //#else
2218 //#endif
2219 };
2220 
2221 //================================================================
2222 //====================== Subvector Functions =====================
2223 
2224 //=======================Vector / Scalar =========================
2225 
2227  INLINE ivector operator /(const imatrix_subv &rv, const interval &s) noexcept;
2229  INLINE ivector operator *(const imatrix_subv &rv, const interval &s) noexcept;
2231  INLINE ivector operator *(const interval &s, const imatrix_subv &rv) noexcept;
2233  INLINE ivector abs(const imatrix_subv &mv) noexcept;
2235  INLINE rvector absmin(const imatrix_subv &mv) noexcept;
2237  INLINE rvector absmax(const imatrix_subv &mv) noexcept;
2239  INLINE rvector diam(const imatrix_subv &mv) noexcept;
2241  INLINE rvector mid(const imatrix_subv &mv) noexcept;
2243  INLINE rvector Inf(const imatrix_subv &mv) noexcept;
2245  INLINE rvector Sup(const imatrix_subv &mv) noexcept;
2246 
2247 // real
2248 
2249 //======================== Vector / Vector ========================
2250 
2252  INLINE imatrix_subv &SetInf(imatrix_subv &mv,const rvector &rv)
2253 #if(CXSC_INDEX_CHECK)
2254 ;
2255 #else
2256  noexcept;
2257 #endif
2259  INLINE imatrix_subv &SetSup(imatrix_subv &mv,const rvector &rv)
2260 #if(CXSC_INDEX_CHECK)
2261 ;
2262 #else
2263  noexcept;
2264 #endif
2266  INLINE imatrix_subv &UncheckedSetInf(imatrix_subv &mv,const rvector &rv)
2267 #if(CXSC_INDEX_CHECK)
2268 ;
2269 #else
2270  noexcept;
2271 #endif
2273  INLINE imatrix_subv &UncheckedSetSup(imatrix_subv &mv,const rvector &rv)
2274 #if(CXSC_INDEX_CHECK)
2275 ;
2276 #else
2277  noexcept;
2278 #endif
2280  INLINE imatrix_subv &SetSup(imatrix_subv &iv,const real &r) noexcept;
2282  INLINE imatrix_subv &SetInf(imatrix_subv &iv,const real &r) noexcept;
2284  INLINE imatrix_subv &UncheckedSetSup(imatrix_subv &iv,const real &r) noexcept;
2286  INLINE imatrix_subv &SetUncheckedInf(imatrix_subv &iv,const real &r) noexcept;
2287 
2288 
2290  void accumulate(idotprecision &dp, const imatrix_subv & rv1, const imatrix_subv &rv2)
2291 #if(CXSC_INDEX_CHECK)
2292 ;
2293 #else
2294  noexcept;
2295 #endif
2297  void accumulate(idotprecision &dp, const ivector & rv1, const imatrix_subv &rv2)
2298 #if(CXSC_INDEX_CHECK)
2299 ;
2300 #else
2301  noexcept;
2302 #endif
2304  void accumulate(idotprecision &dp, const imatrix_subv & rv1, const ivector &rv2)
2305 #if(CXSC_INDEX_CHECK)
2306 ;
2307 #else
2308  noexcept;
2309 #endif
2311  void accumulate(idotprecision &dp, const ivector_slice & sl1, const imatrix_subv &rv2)
2312 #if(CXSC_INDEX_CHECK)
2313 ;
2314 #else
2315  noexcept;
2316 #endif
2318  void accumulate(idotprecision &dp, const imatrix_subv & rv1, const ivector_slice &sl2)
2319 #if(CXSC_INDEX_CHECK)
2320 ;
2321 #else
2322  noexcept;
2323 #endif
2324 
2326  void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const imatrix_subv &rv2)
2327 #if(CXSC_INDEX_CHECK)
2328 ;
2329 #else
2330  noexcept;
2331 #endif
2333  void accumulate(cidotprecision &dp, const ivector & rv1, const imatrix_subv &rv2)
2334 #if(CXSC_INDEX_CHECK)
2335 ;
2336 #else
2337  noexcept;
2338 #endif
2340  void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const ivector &rv2)
2341 #if(CXSC_INDEX_CHECK)
2342 ;
2343 #else
2344  noexcept;
2345 #endif
2347  void accumulate(cidotprecision &dp, const ivector_slice & sl1, const imatrix_subv &rv2)
2348 #if(CXSC_INDEX_CHECK)
2349 ;
2350 #else
2351  noexcept;
2352 #endif
2354  void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const ivector_slice &sl2)
2355 #if(CXSC_INDEX_CHECK)
2356 ;
2357 #else
2358  noexcept;
2359 #endif
2360 
2362  INLINE interval operator *(const imatrix_subv & rv1, const imatrix_subv &rv2)
2363 #if(CXSC_INDEX_CHECK)
2364 ;
2365 #else
2366  noexcept;
2367 #endif
2369  INLINE interval operator *(const ivector & rv1, const imatrix_subv &rv2)
2370 #if(CXSC_INDEX_CHECK)
2371 ;
2372 #else
2373  noexcept;
2374 #endif
2376  INLINE interval operator *(const imatrix_subv &rv1,const ivector &rv2)
2377 #if(CXSC_INDEX_CHECK)
2378 ;
2379 #else
2380  noexcept;
2381 #endif
2383  INLINE interval operator *(const ivector_slice &sl,const imatrix_subv &sv)
2384 #if(CXSC_INDEX_CHECK)
2385 ;
2386 #else
2387  noexcept;
2388 #endif
2390  INLINE interval operator *(const imatrix_subv &mv,const ivector_slice &vs)
2391 #if(CXSC_INDEX_CHECK)
2392 ;
2393 #else
2394  noexcept;
2395 #endif
2396 
2398  INLINE ivector operator +(const imatrix_subv & rv1, const imatrix_subv &rv2)
2399 #if(CXSC_INDEX_CHECK)
2400 ;
2401 #else
2402  noexcept;
2403 #endif
2405  INLINE ivector operator +(const imatrix_subv &rv1,const ivector &rv2)
2406 #if(CXSC_INDEX_CHECK)
2407 ;
2408 #else
2409  noexcept;
2410 #endif
2412  INLINE ivector operator +(const ivector & rv1, const imatrix_subv &rv2)
2413 #if(CXSC_INDEX_CHECK)
2414 ;
2415 #else
2416  noexcept;
2417 #endif
2419  INLINE ivector operator +(const ivector_slice &sl,const imatrix_subv &mv)
2420 #if(CXSC_INDEX_CHECK)
2421 ;
2422 #else
2423  noexcept;
2424 #endif
2426  INLINE ivector operator +(const imatrix_subv &mv,const ivector_slice &sl)
2427 #if(CXSC_INDEX_CHECK)
2428 ;
2429 #else
2430  noexcept;
2431 #endif
2432 
2434  INLINE ivector operator -(const imatrix_subv & rv1, const imatrix_subv &rv2)
2435 #if(CXSC_INDEX_CHECK)
2436 ;
2437 #else
2438  noexcept;
2439 #endif
2441  INLINE ivector operator -(const ivector & rv1, const imatrix_subv &rv2)
2442 #if(CXSC_INDEX_CHECK)
2443 ;
2444 #else
2445  noexcept;
2446 #endif
2448  INLINE ivector operator -(const imatrix_subv &rv1,const ivector &rv2)
2449 #if(CXSC_INDEX_CHECK)
2450 ;
2451 #else
2452  noexcept;
2453 #endif
2455  INLINE ivector operator -(const ivector_slice &sl,const imatrix_subv &mv)
2456 #if(CXSC_INDEX_CHECK)
2457 ;
2458 #else
2459  noexcept;
2460 #endif
2462  INLINE ivector operator -(const imatrix_subv &mv,const ivector_slice &sl)
2463 #if(CXSC_INDEX_CHECK)
2464 ;
2465 #else
2466  noexcept;
2467 #endif
2468 
2469 // real
2470 
2472  void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const imatrix_subv &rv2)
2473 #if(CXSC_INDEX_CHECK)
2474 ;
2475 #else
2476  noexcept;
2477 #endif
2479  void accumulate(idotprecision &dp, const rvector & rv1, const imatrix_subv &rv2)
2480 #if(CXSC_INDEX_CHECK)
2481 ;
2482 #else
2483  noexcept;
2484 #endif
2486  void accumulate(idotprecision &dp, const rvector_slice & sl1, const imatrix_subv &rv2)
2487 #if(CXSC_INDEX_CHECK)
2488 ;
2489 #else
2490  noexcept;
2491 #endif
2492 
2494  void accumulate(idotprecision &dp, const imatrix_subv & rv1, const rmatrix_subv &rv2)
2495 #if(CXSC_INDEX_CHECK)
2496 ;
2497 #else
2498  noexcept;
2499 #endif
2501  void accumulate(idotprecision &dp, const imatrix_subv & rv1, const rvector &rv2)
2502 #if(CXSC_INDEX_CHECK)
2503 ;
2504 #else
2505  noexcept;
2506 #endif
2508  void accumulate(idotprecision &dp, const imatrix_subv & rv1, const rvector_slice &sl2)
2509 #if(CXSC_INDEX_CHECK)
2510 ;
2511 #else
2512  noexcept;
2513 #endif
2514 
2516  void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const imatrix_subv &rv2)
2517 #if(CXSC_INDEX_CHECK)
2518 ;
2519 #else
2520  noexcept;
2521 #endif
2523  void accumulate(cidotprecision &dp, const rvector & rv1, const imatrix_subv &rv2)
2524 #if(CXSC_INDEX_CHECK)
2525 ;
2526 #else
2527  noexcept;
2528 #endif
2530  void accumulate(cidotprecision &dp, const rvector_slice & sl1, const imatrix_subv &rv2)
2531 #if(CXSC_INDEX_CHECK)
2532 ;
2533 #else
2534  noexcept;
2535 #endif
2536 
2538  void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const rmatrix_subv &rv2)
2539 #if(CXSC_INDEX_CHECK)
2540 ;
2541 #else
2542  noexcept;
2543 #endif
2545  void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const rvector &rv2)
2546 #if(CXSC_INDEX_CHECK)
2547 ;
2548 #else
2549  noexcept;
2550 #endif
2552  void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const rvector_slice &sl2)
2553 #if(CXSC_INDEX_CHECK)
2554 ;
2555 #else
2556  noexcept;
2557 #endif
2558 
2559 // complex
2560 
2562  void accumulate(cidotprecision &dp, const cmatrix_subv & rv1, const imatrix_subv &rv2)
2563 #if(CXSC_INDEX_CHECK)
2564 ;
2565 #else
2566  noexcept;
2567 #endif
2569  void accumulate(cidotprecision &dp, const cvector & rv1, const imatrix_subv &rv2)
2570 #if(CXSC_INDEX_CHECK)
2571 ;
2572 #else
2573  noexcept;
2574 #endif
2576  void accumulate(cidotprecision &dp, const cvector_slice & sl1, const imatrix_subv &rv2)
2577 #if(CXSC_INDEX_CHECK)
2578 ;
2579 #else
2580  noexcept;
2581 #endif
2582 
2584  void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const cmatrix_subv &rv2)
2585 #if(CXSC_INDEX_CHECK)
2586 ;
2587 #else
2588  noexcept;
2589 #endif
2591  void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const cvector &rv2)
2592 #if(CXSC_INDEX_CHECK)
2593 ;
2594 #else
2595  noexcept;
2596 #endif
2598  void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const cvector_slice &sl2)
2599 #if(CXSC_INDEX_CHECK)
2600 ;
2601 #else
2602  noexcept;
2603 #endif
2604 
2605 // cinterval
2606 
2608  void accumulate(cidotprecision &dp, const cimatrix_subv & rv1, const imatrix_subv &rv2)
2609 #if(CXSC_INDEX_CHECK)
2610 ;
2611 #else
2612  noexcept;
2613 #endif
2615  void accumulate(cidotprecision &dp, const civector & rv1, const imatrix_subv &rv2)
2616 #if(CXSC_INDEX_CHECK)
2617 ;
2618 #else
2619  noexcept;
2620 #endif
2622  void accumulate(cidotprecision &dp, const civector_slice & sl1, const imatrix_subv &rv2)
2623 #if(CXSC_INDEX_CHECK)
2624 ;
2625 #else
2626  noexcept;
2627 #endif
2628 
2630  void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const cimatrix_subv &rv2)
2631 #if(CXSC_INDEX_CHECK)
2632 ;
2633 #else
2634  noexcept;
2635 #endif
2637  void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const civector &rv2)
2638 #if(CXSC_INDEX_CHECK)
2639 ;
2640 #else
2641  noexcept;
2642 #endif
2644  void accumulate(cidotprecision &dp, const imatrix_subv & rv1, const civector_slice &sl2)
2645 #if(CXSC_INDEX_CHECK)
2646 ;
2647 #else
2648  noexcept;
2649 #endif
2650 
2651 
2652 //====================================================================
2653 //===================== Matrix Functions =============================
2654 
2656  INLINE imatrix _imatrix(const imatrix &rm) noexcept;
2658  INLINE imatrix _imatrix(const ivector &v) noexcept;
2660  INLINE imatrix _imatrix(const ivector_slice &v) noexcept;
2662  INLINE imatrix _imatrix(const interval &r) noexcept;
2663 
2665  INLINE int Lb(const imatrix &rm, const int &i)
2666 #if(CXSC_INDEX_CHECK)
2667 ;
2668 #else
2669  noexcept;
2670 #endif
2672  INLINE int Ub(const imatrix &rm, const int &i)
2673 #if(CXSC_INDEX_CHECK)
2674 ;
2675 #else
2676  noexcept;
2677 #endif
2679  INLINE int Lb(const imatrix_slice &rm, const int &i)
2680 #if(CXSC_INDEX_CHECK)
2681 ;
2682 #else
2683  noexcept;
2684 #endif
2686  INLINE int Ub(const imatrix_slice &rm, const int &i)
2687 #if(CXSC_INDEX_CHECK)
2688 ;
2689 #else
2690  noexcept;
2691 #endif
2693  INLINE imatrix &SetLb(imatrix &m, const int &i,const int &j)
2694 #if(CXSC_INDEX_CHECK)
2695 ;
2696 #else
2697  noexcept;
2698 #endif
2700  INLINE imatrix &SetUb(imatrix &m, const int &i,const int &j)
2701 #if(CXSC_INDEX_CHECK)
2702 ;
2703 #else
2704  noexcept;
2705 #endif
2707  INLINE void Resize(imatrix &A) noexcept;
2709  INLINE void Resize(imatrix &A,const int &m, const int &n)
2710 #if(CXSC_INDEX_CHECK)
2711 ;
2712 #else
2713  noexcept;
2714 #endif
2716  INLINE void Resize(imatrix &A,const int &m1, const int &m2,const int &n1,const int &n2)
2717 #if(CXSC_INDEX_CHECK)
2718 ;
2719 #else
2720  noexcept;
2721 #endif
2722 
2724  INLINE imatrix abs(const imatrix &m) noexcept;
2726  INLINE rmatrix absmin(const imatrix &m) noexcept;
2728  INLINE rmatrix absmax(const imatrix &m) noexcept;
2730  INLINE imatrix abs(const imatrix_slice &ms) noexcept;
2732  INLINE rmatrix absmin(const imatrix_slice &ms) noexcept;
2734  INLINE rmatrix absmax(const imatrix_slice &ms) noexcept;
2736  INLINE rmatrix diam(const imatrix &m) noexcept;
2738  INLINE rmatrix diam(const imatrix_slice &ms) noexcept;
2740  INLINE rmatrix mid(const imatrix &m) noexcept;
2742  INLINE rmatrix mid(const imatrix_slice &ms) noexcept;
2744  INLINE rmatrix Inf(const imatrix &m) noexcept;
2746  INLINE rmatrix Sup(const imatrix &m) noexcept;
2748  INLINE rmatrix Inf(const imatrix_slice &m) noexcept;
2750  INLINE rmatrix Sup(const imatrix_slice &m) noexcept;
2752  INLINE imatrix &SetInf(imatrix &cm,const rmatrix &rm)
2753 #if(CXSC_INDEX_CHECK)
2754 ;
2755 #else
2756  noexcept;
2757 #endif
2759  INLINE imatrix_slice &SetInf(imatrix_slice &cm,const rmatrix &rm)
2760 #if(CXSC_INDEX_CHECK)
2761 ;
2762 #else
2763  noexcept;
2764 #endif
2766  INLINE imatrix &SetInf(imatrix &cm,const rmatrix_slice &rm)
2767 #if(CXSC_INDEX_CHECK)
2768 ;
2769 #else
2770  noexcept;
2771 #endif
2773  INLINE imatrix_slice &SetInf(imatrix_slice &cm,const rmatrix_slice &rm)
2774 #if(CXSC_INDEX_CHECK)
2775 ;
2776 #else
2777  noexcept;
2778 #endif
2780  INLINE imatrix &SetSup(imatrix &cm,const rmatrix &rm)
2781 #if(CXSC_INDEX_CHECK)
2782 ;
2783 #else
2784  noexcept;
2785 #endif
2787  INLINE imatrix_slice &SetSup(imatrix_slice &cm,const rmatrix &rm)
2788 #if(CXSC_INDEX_CHECK)
2789 ;
2790 #else
2791  noexcept;
2792 #endif
2794  INLINE imatrix &SetSup(imatrix &cm,const rmatrix_slice &rm)
2795 #if(CXSC_INDEX_CHECK)
2796 ;
2797 #else
2798  noexcept;
2799 #endif
2801  INLINE imatrix_slice &SetSup(imatrix_slice &cm,const rmatrix_slice &rm)
2802 #if(CXSC_INDEX_CHECK)
2803 ;
2804 #else
2805  noexcept;
2806 #endif
2808  INLINE imatrix &UncheckedSetInf(imatrix &cm,const rmatrix &rm)
2809 #if(CXSC_INDEX_CHECK)
2810 ;
2811 #else
2812  noexcept;
2813 #endif
2815  INLINE imatrix_slice &UncheckedSetInf(imatrix_slice &cm,const rmatrix &rm)
2816 #if(CXSC_INDEX_CHECK)
2817 ;
2818 #else
2819  noexcept;
2820 #endif
2822  INLINE imatrix &UncheckedSetInf(imatrix &cm,const rmatrix_slice &rm)
2823 #if(CXSC_INDEX_CHECK)
2824 ;
2825 #else
2826  noexcept;
2827 #endif
2829  INLINE imatrix_slice &UncheckedSetInf(imatrix_slice &cm,const rmatrix_slice &rm)
2830 #if(CXSC_INDEX_CHECK)
2831 ;
2832 #else
2833  noexcept;
2834 #endif
2836  INLINE imatrix &UncheckedSetSup(imatrix &cm,const rmatrix &rm)
2837 #if(CXSC_INDEX_CHECK)
2838 ;
2839 #else
2840  noexcept;
2841 #endif
2843  INLINE imatrix_slice &UncheckedSetSup(imatrix_slice &cm,const rmatrix &rm)
2844 #if(CXSC_INDEX_CHECK)
2845 ;
2846 #else
2847  noexcept;
2848 #endif
2850  INLINE imatrix &UncheckedSetSup(imatrix &cm,const rmatrix_slice &rm)
2851 #if(CXSC_INDEX_CHECK)
2852 ;
2853 #else
2854  noexcept;
2855 #endif
2857  INLINE imatrix_slice &UncheckedSetSup(imatrix_slice &cm,const rmatrix_slice &rm)
2858 #if(CXSC_INDEX_CHECK)
2859 ;
2860 #else
2861  noexcept;
2862 #endif
2863 
2864 //===================== Matrix / Scalar ===============================
2865 
2867  INLINE imatrix operator *(const interval &c, const imatrix &m) noexcept;
2869  INLINE imatrix operator *(const interval &c, const imatrix_slice &ms) noexcept;
2871  INLINE imatrix operator *(const imatrix &m,const interval &c) noexcept;
2873  INLINE imatrix operator *(const imatrix_slice &ms,const interval &c) noexcept;
2875  INLINE imatrix &operator *=(imatrix &m,const interval &c) noexcept;
2877  INLINE imatrix operator /(const imatrix &m,const interval &c) noexcept;
2879  INLINE imatrix operator /(const imatrix_slice &ms, const interval &c) noexcept;
2881  INLINE imatrix &operator /=(imatrix &m,const interval &c) noexcept;
2882 
2883 //------------ real - imatrix -----------------------------------------------
2884 
2886  INLINE imatrix operator *(const real &c, const imatrix &m) noexcept;
2888  INLINE imatrix operator *(const real &c, const imatrix_slice &ms) noexcept;
2890  INLINE imatrix operator *(const imatrix &m,const real &c) noexcept;
2892  INLINE imatrix operator *(const imatrix_slice &ms,const real &c) noexcept;
2894  INLINE imatrix &operator *=(imatrix &m,const real &c) noexcept;
2896  INLINE imatrix operator /(const imatrix &m,const real &c) noexcept;
2898  INLINE imatrix operator /(const imatrix_slice &ms, const real &c) noexcept;
2900  INLINE imatrix &operator /=(imatrix &m,const real &c) noexcept;
2901 //----------------- rmatrix - interval ----------------
2902 
2904  INLINE imatrix operator *(const interval &c, const rmatrix &m) noexcept;
2906  INLINE imatrix operator *(const interval &c, const rmatrix_slice &ms) noexcept;
2908  INLINE imatrix operator *(const rmatrix &m,const interval &c) noexcept;
2910  INLINE imatrix operator *(const rmatrix_slice &ms,const interval &c) noexcept;
2912  INLINE imatrix operator /(const rmatrix &m,const interval &c) noexcept;
2914  INLINE imatrix operator /(const rmatrix_slice &ms, const interval &c) noexcept;
2915 
2916 
2917 //============================ Matrix / Vector ===================================
2918 
2919 
2921  INLINE ivector operator *(const imatrix &m,const ivector &v)
2922 #if(CXSC_INDEX_CHECK)
2923 ;
2924 #else
2925  noexcept;
2926 #endif
2928  INLINE ivector operator *(const imatrix_slice &ms,const ivector &v)
2929 #if(CXSC_INDEX_CHECK)
2930 ;
2931 #else
2932  noexcept;
2933 #endif
2935  INLINE ivector operator *(const ivector &v,const imatrix &m)
2936 #if(CXSC_INDEX_CHECK)
2937 ;
2938 #else
2939  noexcept;
2940 #endif
2942  INLINE ivector operator *(const ivector &v,const imatrix_slice &ms)
2943 #if(CXSC_INDEX_CHECK)
2944 ;
2945 #else
2946  noexcept;
2947 #endif
2949  INLINE ivector &operator *=(ivector &v,const imatrix &m)
2950 #if(CXSC_INDEX_CHECK)
2951 ;
2952 #else
2953  noexcept;
2954 #endif
2956  INLINE ivector &operator *=(ivector &v,const imatrix_slice &ms)
2957 #if(CXSC_INDEX_CHECK)
2958 ;
2959 #else
2960  noexcept;
2961 #endif
2962 
2964  INLINE ivector operator *(const ivector_slice &v,const imatrix &m)
2965 #if(CXSC_INDEX_CHECK)
2966 ;
2967 #else
2968  noexcept;
2969 #endif
2971  INLINE ivector operator *(const ivector_slice &v,const imatrix_slice &m)
2972 #if(CXSC_INDEX_CHECK)
2973 ;
2974 #else
2975  noexcept;
2976 #endif
2977 
2978 //----------------- real -------------------------------------
2979 
2980 
2982  INLINE ivector operator *(const rvector &v,const imatrix &m)
2983 #if(CXSC_INDEX_CHECK)
2984 ;
2985 #else
2986  noexcept;
2987 #endif
2989  INLINE ivector operator *(const rvector &v,const imatrix_slice &ms)
2990 #if(CXSC_INDEX_CHECK)
2991 ;
2992 #else
2993  noexcept;
2994 #endif
2996  INLINE ivector operator *(const rvector_slice &v,const imatrix &m)
2997 #if(CXSC_INDEX_CHECK)
2998 ;
2999 #else
3000  noexcept;
3001 #endif
3002 
3004  INLINE ivector operator *(const imatrix &m,const rvector &v)
3005 #if(CXSC_INDEX_CHECK)
3006 ;
3007 #else
3008  noexcept;
3009 #endif
3011  INLINE ivector operator *(const imatrix_slice &ms,const rvector &v)
3012 #if(CXSC_INDEX_CHECK)
3013 ;
3014 #else
3015  noexcept;
3016 #endif
3017 
3018 
3019 //================ Matrix / Matrix ============================
3020 
3022  INLINE const imatrix &operator +(const imatrix &m1) noexcept;
3024  INLINE imatrix operator +(const imatrix_slice &ms) noexcept;
3026  INLINE imatrix operator +(const imatrix &m1,const imatrix &m2)
3027 #if(CXSC_INDEX_CHECK)
3028 ;
3029 #else
3030  noexcept;
3031 #endif
3033  INLINE imatrix operator +(const imatrix &m,const imatrix_slice &ms)
3034 #if(CXSC_INDEX_CHECK)
3035 ;
3036 #else
3037  noexcept;
3038 #endif
3040  INLINE imatrix operator +(const imatrix_slice &ms,const imatrix &m)
3041 #if(CXSC_INDEX_CHECK)
3042 ;
3043 #else
3044  noexcept;
3045 #endif
3047  INLINE imatrix operator +(const imatrix_slice &m1,const imatrix_slice &m2)
3048 #if(CXSC_INDEX_CHECK)
3049 ;
3050 #else
3051  noexcept;
3052 #endif
3054  INLINE imatrix &operator +=(imatrix &m1,const imatrix &m2)
3055 #if(CXSC_INDEX_CHECK)
3056 ;
3057 #else
3058  noexcept;
3059 #endif
3061  INLINE imatrix &operator +=(imatrix &m1,const imatrix_slice &ms)
3062 #if(CXSC_INDEX_CHECK)
3063 ;
3064 #else
3065  noexcept;
3066 #endif
3067 
3069  INLINE imatrix operator -(const imatrix &m) noexcept;
3071  INLINE imatrix operator -(const imatrix_slice &ms) noexcept;
3073  INLINE imatrix operator -(const imatrix &m1,const imatrix &m2)
3074 #if(CXSC_INDEX_CHECK)
3075 ;
3076 #else
3077  noexcept;
3078 #endif
3080  INLINE imatrix operator -(const imatrix &m,const imatrix_slice &ms)
3081 #if(CXSC_INDEX_CHECK)
3082 ;
3083 #else
3084  noexcept;
3085 #endif
3087  INLINE imatrix operator -(const imatrix_slice &ms,const imatrix &m)
3088 #if(CXSC_INDEX_CHECK)
3089 ;
3090 #else
3091  noexcept;
3092 #endif
3094  INLINE imatrix operator -(const imatrix_slice &ms1,const imatrix_slice &ms2)
3095 #if(CXSC_INDEX_CHECK)
3096 ;
3097 #else
3098  noexcept;
3099 #endif
3101  INLINE imatrix &operator -=(imatrix &m1,const imatrix &m2)
3102 #if(CXSC_INDEX_CHECK)
3103 ;
3104 #else
3105  noexcept;
3106 #endif
3108  INLINE imatrix &operator -=(imatrix &m1,const imatrix_slice &ms)
3109 #if(CXSC_INDEX_CHECK)
3110 ;
3111 #else
3112  noexcept;
3113 #endif
3114 
3116  INLINE imatrix operator *(const imatrix &m1, const imatrix &m2)
3117 #if(CXSC_INDEX_CHECK)
3118 ;
3119 #else
3120  noexcept;
3121 #endif
3123  INLINE imatrix operator *(const imatrix &m1, const imatrix_slice &ms)
3124 #if(CXSC_INDEX_CHECK)
3125 ;
3126 #else
3127  noexcept;
3128 #endif
3130  INLINE imatrix operator *(const imatrix_slice &ms, const imatrix &m1)
3131 #if(CXSC_INDEX_CHECK)
3132 ;
3133 #else
3134  noexcept;
3135 #endif
3137  INLINE imatrix operator *(const imatrix_slice &ms1, const imatrix_slice &ms2)
3138 #if(CXSC_INDEX_CHECK)
3139 ;
3140 #else
3141  noexcept;
3142 #endif
3144  INLINE imatrix &operator *=(imatrix &m1,const imatrix &m2)
3145 #if(CXSC_INDEX_CHECK)
3146 ;
3147 #else
3148  noexcept;
3149 #endif
3151  INLINE imatrix &operator *=(imatrix &m1,const imatrix_slice &ms)
3152 #if(CXSC_INDEX_CHECK)
3153 ;
3154 #else
3155  noexcept;
3156 #endif
3157 
3158 
3160  INLINE imatrix operator |(const imatrix &m1,const imatrix &m2)
3161 #if(CXSC_INDEX_CHECK)
3162 ;
3163 #else
3164  noexcept;
3165 #endif
3167  INLINE imatrix operator |(const imatrix &m,const imatrix_slice &ms)
3168 #if(CXSC_INDEX_CHECK)
3169 ;
3170 #else
3171  noexcept;
3172 #endif
3174  INLINE imatrix operator |(const imatrix_slice &ms,const imatrix &m)
3175 #if(CXSC_INDEX_CHECK)
3176 ;
3177 #else
3178  noexcept;
3179 #endif
3181  INLINE imatrix operator |(const imatrix_slice &m1,const imatrix_slice &m2)
3182 #if(CXSC_INDEX_CHECK)
3183 ;
3184 #else
3185  noexcept;
3186 #endif
3188  INLINE imatrix &operator |=(imatrix &m1,const imatrix &m2)
3189 #if(CXSC_INDEX_CHECK)
3190 ;
3191 #else
3192  noexcept;
3193 #endif
3195  INLINE imatrix &operator |=(imatrix &m1,const imatrix_slice &ms)
3196 #if(CXSC_INDEX_CHECK)
3197 ;
3198 #else
3199  noexcept;
3200 #endif
3201 
3203  INLINE imatrix operator &(const imatrix &m1,const imatrix &m2)
3204 #if(CXSC_INDEX_CHECK)
3205 ;
3206 #else
3207  noexcept;
3208 #endif
3210  INLINE imatrix operator &(const imatrix &m,const imatrix_slice &ms)
3211 #if(CXSC_INDEX_CHECK)
3212 ;
3213 #else
3214  noexcept;
3215 #endif
3217  INLINE imatrix operator &(const imatrix_slice &ms,const imatrix &m)
3218 #if(CXSC_INDEX_CHECK)
3219 ;
3220 #else
3221  noexcept;
3222 #endif
3224  INLINE imatrix operator &(const imatrix_slice &m1,const imatrix_slice &m2)
3225 #if(CXSC_INDEX_CHECK)
3226 ;
3227 #else
3228  noexcept;
3229 #endif
3231  INLINE imatrix &operator &=(imatrix &m1,const imatrix &m2)
3232 #if(CXSC_INDEX_CHECK)
3233 ;
3234 #else
3235  noexcept;
3236 #endif
3238  INLINE imatrix &operator &=(imatrix &m1,const imatrix_slice &ms)
3239 #if(CXSC_INDEX_CHECK)
3240 ;
3241 #else
3242  noexcept;
3243 #endif
3244 
3245  //---------- rmatrix-imatrix ------------------
3247  INLINE imatrix operator +(const rmatrix &m1,const imatrix &m2)
3248 #if(CXSC_INDEX_CHECK)
3249 ;
3250 #else
3251  noexcept;
3252 #endif
3254  INLINE imatrix operator +(const imatrix &m1,const rmatrix &m2)
3255 #if(CXSC_INDEX_CHECK)
3256 ;
3257 #else
3258  noexcept;
3259 #endif
3261  INLINE imatrix operator +(const rmatrix &m,const imatrix_slice &ms)
3262 #if(CXSC_INDEX_CHECK)
3263 ;
3264 #else
3265  noexcept;
3266 #endif
3268  INLINE imatrix operator +(const imatrix &m,const rmatrix_slice &ms)
3269 #if(CXSC_INDEX_CHECK)
3270 ;
3271 #else
3272  noexcept;
3273 #endif
3275  INLINE imatrix operator +(const rmatrix_slice &ms,const imatrix &m)
3276 #if(CXSC_INDEX_CHECK)
3277 ;
3278 #else
3279  noexcept;
3280 #endif
3282  INLINE imatrix operator +(const imatrix_slice &ms,const rmatrix &m)
3283 #if(CXSC_INDEX_CHECK)
3284 ;
3285 #else
3286  noexcept;
3287 #endif
3289  INLINE imatrix operator +(const rmatrix_slice &m1,const imatrix_slice &m2)
3290 #if(CXSC_INDEX_CHECK)
3291 ;
3292 #else
3293  noexcept;
3294 #endif
3296  INLINE imatrix operator +(const imatrix_slice &m1,const rmatrix_slice &m2)
3297 #if(CXSC_INDEX_CHECK)
3298 ;
3299 #else
3300  noexcept;
3301 #endif
3303  INLINE imatrix &operator +=(imatrix &m1,const rmatrix &m2)
3304 #if(CXSC_INDEX_CHECK)
3305 ;
3306 #else
3307  noexcept;
3308 #endif
3310  INLINE imatrix &operator +=(imatrix &m1,const rmatrix_slice &ms)
3311 #if(CXSC_INDEX_CHECK)
3312 ;
3313 #else
3314  noexcept;
3315 #endif
3316 
3318  INLINE imatrix operator -(const rmatrix &m1,const imatrix &m2)
3319 #if(CXSC_INDEX_CHECK)
3320 ;
3321 #else
3322  noexcept;
3323 #endif
3325  INLINE imatrix operator -(const imatrix &m1,const rmatrix &m2)
3326 #if(CXSC_INDEX_CHECK)
3327 ;
3328 #else
3329  noexcept;
3330 #endif
3332  INLINE imatrix operator -(const rmatrix &m,const imatrix_slice &ms)
3333 #if(CXSC_INDEX_CHECK)
3334 ;
3335 #else
3336  noexcept;
3337 #endif
3339  INLINE imatrix operator -(const imatrix &m,const rmatrix_slice &ms)
3340 #if(CXSC_INDEX_CHECK)
3341 ;
3342 #else
3343  noexcept;
3344 #endif
3346  INLINE imatrix operator -(const rmatrix_slice &ms,const imatrix &m)
3347 #if(CXSC_INDEX_CHECK)
3348 ;
3349 #else
3350  noexcept;
3351 #endif
3353  INLINE imatrix operator -(const imatrix_slice &ms,const rmatrix &m)
3354 #if(CXSC_INDEX_CHECK)
3355 ;
3356 #else
3357  noexcept;
3358 #endif
3360  INLINE imatrix operator -(const rmatrix_slice &ms1,const imatrix_slice &ms2)
3361 #if(CXSC_INDEX_CHECK)
3362 ;
3363 #else
3364  noexcept;
3365 #endif
3367  INLINE imatrix operator -(const imatrix_slice &ms1,const rmatrix_slice &ms2)
3368 #if(CXSC_INDEX_CHECK)
3369 ;
3370 #else
3371  noexcept;
3372 #endif
3374  INLINE imatrix &operator -=(imatrix &m1,const rmatrix &m2)
3375 #if(CXSC_INDEX_CHECK)
3376 ;
3377 #else
3378  noexcept;
3379 #endif
3381  INLINE imatrix &operator -=(imatrix &m1,const rmatrix_slice &ms)
3382 #if(CXSC_INDEX_CHECK)
3383 ;
3384 #else
3385  noexcept;
3386 #endif
3387 
3389  INLINE imatrix operator *(const rmatrix &m1, const imatrix &m2)
3390 #if(CXSC_INDEX_CHECK)
3391 ;
3392 #else
3393  noexcept;
3394 #endif
3396  INLINE imatrix operator *(const imatrix &m1, const rmatrix &m2)
3397 #if(CXSC_INDEX_CHECK)
3398 ;
3399 #else
3400  noexcept;
3401 #endif
3403  INLINE imatrix operator *(const rmatrix &m1, const imatrix_slice &ms)
3404 #if(CXSC_INDEX_CHECK)
3405 ;
3406 #else
3407  noexcept;
3408 #endif
3410  INLINE imatrix operator *(const imatrix &m1, const rmatrix_slice &ms)
3411 #if(CXSC_INDEX_CHECK)
3412 ;
3413 #else
3414  noexcept;
3415 #endif
3417  INLINE imatrix operator *(const rmatrix_slice &ms, const imatrix &m1)
3418 #if(CXSC_INDEX_CHECK)
3419 ;
3420 #else
3421  noexcept;
3422 #endif
3424  INLINE imatrix operator *(const imatrix_slice &ms, const rmatrix &m1)
3425 #if(CXSC_INDEX_CHECK)
3426 ;
3427 #else
3428  noexcept;
3429 #endif
3431  INLINE imatrix operator *(const rmatrix_slice &ms1, const imatrix_slice &ms2)
3432 #if(CXSC_INDEX_CHECK)
3433 ;
3434 #else
3435  noexcept;
3436 #endif
3438  INLINE imatrix operator *(const imatrix_slice &ms1, const rmatrix_slice &ms2)
3439 #if(CXSC_INDEX_CHECK)
3440 ;
3441 #else
3442  noexcept;
3443 #endif
3445  INLINE imatrix &operator *=(imatrix &m1,const rmatrix &m2)
3446 #if(CXSC_INDEX_CHECK)
3447 ;
3448 #else
3449  noexcept;
3450 #endif
3452  INLINE imatrix &operator *=(imatrix &m1,const rmatrix_slice &ms)
3453 #if(CXSC_INDEX_CHECK)
3454 ;
3455 #else
3456  noexcept;
3457 #endif
3458 
3460  INLINE imatrix operator |(const rmatrix &m1,const imatrix &m2)
3461 #if(CXSC_INDEX_CHECK)
3462 ;
3463 #else
3464  noexcept;
3465 #endif
3467  INLINE imatrix operator |(const imatrix &m1,const rmatrix &m2)
3468 #if(CXSC_INDEX_CHECK)
3469 ;
3470 #else
3471  noexcept;
3472 #endif
3474  INLINE imatrix operator |(const rmatrix &m,const imatrix_slice &ms)
3475 #if(CXSC_INDEX_CHECK)
3476 ;
3477 #else
3478  noexcept;
3479 #endif
3481  INLINE imatrix operator |(const imatrix &m,const rmatrix_slice &ms)
3482 #if(CXSC_INDEX_CHECK)
3483 ;
3484 #else
3485  noexcept;
3486 #endif
3488  INLINE imatrix operator |(const rmatrix_slice &ms,const imatrix &m)
3489 #if(CXSC_INDEX_CHECK)
3490 ;
3491 #else
3492  noexcept;
3493 #endif
3495  INLINE imatrix operator |(const imatrix_slice &ms,const rmatrix &m)
3496 #if(CXSC_INDEX_CHECK)
3497 ;
3498 #else
3499  noexcept;
3500 #endif
3502  INLINE imatrix operator |(const rmatrix_slice &m1,const imatrix_slice &m2)
3503 #if(CXSC_INDEX_CHECK)
3504 ;
3505 #else
3506  noexcept;
3507 #endif
3509  INLINE imatrix operator |(const imatrix_slice &m1,const rmatrix_slice &m2)
3510 #if(CXSC_INDEX_CHECK)
3511 ;
3512 #else
3513  noexcept;
3514 #endif
3516  INLINE imatrix &operator |=(imatrix &m1,const rmatrix &m2)
3517 #if(CXSC_INDEX_CHECK)
3518 ;
3519 #else
3520  noexcept;
3521 #endif
3523  INLINE imatrix &operator |=(imatrix &m1,const rmatrix_slice &ms)
3524 #if(CXSC_INDEX_CHECK)
3525 ;
3526 #else
3527  noexcept;
3528 #endif
3529 
3531  INLINE imatrix operator &(const rmatrix &m1,const imatrix &m2)
3532 #if(CXSC_INDEX_CHECK)
3533 ;
3534 #else
3535  noexcept;
3536 #endif
3538  INLINE imatrix operator &(const imatrix &m1,const rmatrix &m2)
3539 #if(CXSC_INDEX_CHECK)
3540 ;
3541 #else
3542  noexcept;
3543 #endif
3545  INLINE imatrix operator &(const rmatrix &m,const imatrix_slice &ms)
3546 #if(CXSC_INDEX_CHECK)
3547 ;
3548 #else
3549  noexcept;
3550 #endif
3552  INLINE imatrix operator &(const imatrix &m,const rmatrix_slice &ms)
3553 #if(CXSC_INDEX_CHECK)
3554 ;
3555 #else
3556  noexcept;
3557 #endif
3559  INLINE imatrix operator &(const rmatrix_slice &ms,const imatrix &m)
3560 #if(CXSC_INDEX_CHECK)
3561 ;
3562 #else
3563  noexcept;
3564 #endif
3566  INLINE imatrix operator &(const imatrix_slice &ms,const rmatrix &m)
3567 #if(CXSC_INDEX_CHECK)
3568 ;
3569 #else
3570  noexcept;
3571 #endif
3573  INLINE imatrix operator &(const rmatrix_slice &m1,const imatrix_slice &m2)
3574 #if(CXSC_INDEX_CHECK)
3575 ;
3576 #else
3577  noexcept;
3578 #endif
3580  INLINE imatrix operator &(const imatrix_slice &m1,const rmatrix_slice &m2)
3581 #if(CXSC_INDEX_CHECK)
3582 ;
3583 #else
3584  noexcept;
3585 #endif
3587  INLINE imatrix &operator &=(imatrix &m1,const rmatrix &m2)
3588 #if(CXSC_INDEX_CHECK)
3589 ;
3590 #else
3591  noexcept;
3592 #endif
3594  INLINE imatrix &operator &=(imatrix &m1,const rmatrix_slice &ms)
3595 #if(CXSC_INDEX_CHECK)
3596 ;
3597 #else
3598  noexcept;
3599 #endif
3600 
3601  // rmatrix x rmatrix --------------------------------------
3602 
3604  INLINE imatrix operator |(const rmatrix &m1,const rmatrix &m2)
3605 #if(CXSC_INDEX_CHECK)
3606 ;
3607 #else
3608  noexcept;
3609 #endif
3611  INLINE imatrix operator |(const rmatrix &m,const rmatrix_slice &ms)
3612 #if(CXSC_INDEX_CHECK)
3613 ;
3614 #else
3615  noexcept;
3616 #endif
3618  INLINE imatrix operator |(const rmatrix_slice &ms,const rmatrix &m)
3619 #if(CXSC_INDEX_CHECK)
3620 ;
3621 #else
3622  noexcept;
3623 #endif
3625  INLINE imatrix operator |(const rmatrix_slice &m1,const rmatrix_slice &m2)
3626 #if(CXSC_INDEX_CHECK)
3627 ;
3628 #else
3629  noexcept;
3630 #endif
3631 
3632 //============== Compare Operator ==========================
3633 
3634 //-------------- Matrix - Matrix -------------------------
3635 
3637  INLINE bool operator ==(const imatrix &m1,const imatrix &m2) noexcept;
3639  INLINE bool operator !=(const imatrix &m1,const imatrix &m2) noexcept;
3641  INLINE bool operator <(const imatrix &m1,const imatrix &m2) noexcept;
3643  INLINE bool operator <=(const imatrix &m1,const imatrix &m2) noexcept;
3645  INLINE bool operator >(const imatrix &m1,const imatrix &m2) noexcept;
3647  INLINE bool operator >=(const imatrix &m1,const imatrix &m2) noexcept;
3649  INLINE bool operator ==(const imatrix &m1,const imatrix_slice &ms) noexcept;
3651  INLINE bool operator !=(const imatrix &m1,const imatrix_slice &ms) noexcept;
3653  INLINE bool operator <(const imatrix &m1,const imatrix_slice &ms) noexcept;
3655  INLINE bool operator <=(const imatrix &m1,const imatrix_slice &ms) noexcept;
3657  INLINE bool operator >(const imatrix &m1,const imatrix_slice &ms) noexcept;
3659  INLINE bool operator >=(const imatrix &m1,const imatrix_slice &ms) noexcept;
3660 
3661 //---------------- Matrix - Matrix_slice ----------------------
3662 
3664  INLINE bool operator ==(const imatrix_slice &m1,const imatrix_slice &m2) noexcept;
3666  INLINE bool operator !=(const imatrix_slice &m1,const imatrix_slice &m2) noexcept;
3668  INLINE bool operator <(const imatrix_slice &m1,const imatrix_slice &m2) noexcept;
3670  INLINE bool operator <=(const imatrix_slice &m1,const imatrix_slice &m2) noexcept;
3672  INLINE bool operator >(const imatrix_slice &m1,const imatrix_slice &m2) noexcept;
3674  INLINE bool operator >=(const imatrix_slice &m1,const imatrix_slice &m2) noexcept;
3675 
3676 //=================== Not Operator =============================
3677 
3679  INLINE bool operator !(const imatrix &ms) noexcept;
3681  INLINE bool operator !(const imatrix_slice &ms) noexcept;
3682 
3683 //======================== Input / Output ========================
3684 
3686  INLINE std::ostream &operator <<(std::ostream &s,const imatrix &r) noexcept;
3688  INLINE std::ostream &operator <<(std::ostream &s,const imatrix_slice &r) noexcept;
3690  INLINE std::istream &operator >>(std::istream &s,imatrix &r) noexcept;
3692  INLINE std::istream &operator >>(std::istream &s,imatrix_slice &r) noexcept;
3693 
3695  rmatrix CompMat ( const imatrix& );
3697  imatrix Id ( const imatrix& );
3699  imatrix transp ( const imatrix& );
3701  real MaxRelDiam ( const imatrix_subv& );
3703  INLINE int RowLen ( const imatrix& );
3705  INLINE int ColLen ( const imatrix& );
3707  INLINE int RowLen ( const imatrix_slice& );
3709  INLINE int ColLen ( const imatrix_slice& );
3711  void DoubleSize ( imatrix& );
3712 
3713 } // namespace cxsc
3714 
3715 #ifdef _CXSC_INCL_INL
3716 #include "matrix.inl"
3717 #include "imatrix.inl"
3718 #endif
3719 
3720 #ifdef _CXSC_CIVECTOR_HPP_INCLUDED
3721 # ifdef _CXSC_INCL_INL
3722 # include "civecimat.inl"
3723 # else
3724 # include "civecimat.hpp"
3725 # endif
3726 #endif
3727 
3728 #ifdef _CXSC_CVECTOR_HPP_INCLUDED
3729 # ifdef _CXSC_INCL_INL
3730 # include "cvecimat.inl"
3731 # else
3732 # include "cvecimat.hpp"
3733 # endif
3734 #endif
3735 
3736 #ifdef _CXSC_CMATRIX_HPP_INCLUDED
3737 # ifdef _CXSC_INCL_INL
3738 # include "cmatimat.inl"
3739 # else
3740 # include "cmatimat.hpp"
3741 # endif
3742 #endif
3743 
3744 #ifdef _CXSC_LIVECTOR_HPP_INCLUDED
3745 # ifdef _CXSC_INCL_INL
3746 # include "livecimat.inl"
3747 # else
3748 # include "livecimat.hpp"
3749 # endif
3750 #endif
3751 
3752 #ifdef _CXSC_LRVECTOR_HPP_INCLUDED
3753 # ifdef _CXSC_INCL_INL
3754 # include "lrvecimat.inl"
3755 # else
3756 # include "lrvecimat.hpp"
3757 # endif
3758 #endif
3759 
3760 #ifdef _CXSC_LRMATRIX_HPP_INCLUDED
3761 # ifdef _CXSC_INCL_INL
3762 # include "lrmatimat.inl"
3763 # else
3764 # include "lrmatimat.hpp"
3765 # endif
3766 #endif
3767 
3768 
3769 #ifdef CXSC_USE_BLAS
3770 #define _CXSC_BLAS_IMATRIX
3771 #include "cxsc_blas.inl"
3772 #endif
3773 
3774 #endif
The Data Type cimatrix.
Definition: cimatrix.hpp:908
The Data Type civector.
Definition: civector.hpp:57
The Data Type imatrix_slice.
Definition: imatrix.hpp:1442
imatrix_subv operator[](const int &i) noexcept
Operator for accessing a single row of the matrix.
Definition: imatrix.inl:275
imatrix_slice & operator+=(const imatrix &m1) noexcept
Implementation of addition and allocation operation.
Definition: imatrix.inl:1352
imatrix_slice(imatrix_slice &a, const int &l1, const int &u1, const int &l2, const int &u2) noexcept
Constructor of class imatrix_slice.
Definition: imatrix.hpp:1903
imatrix_slice & operator=(const imatrix &m) noexcept
Implementation of standard assigning operator.
Definition: imatrix.inl:428
imatrix_slice & operator/=(const interval &c) noexcept
Implementation of division and allocation operation.
Definition: imatrix.inl:1112
imatrix_slice & operator|=(const imatrix &m1) noexcept
Allocates the convex hull of the arguments to the first argument.
Definition: imatrix.inl:1508
imatrix_slice & operator&=(const imatrix &m1) noexcept
Allocates the intersection of the arguments to the first argument.
Definition: imatrix.inl:1564
imatrix_slice & operator()() noexcept
Operator for accessing the whole matrix.
Definition: imatrix.hpp:2010
imatrix_slice(const imatrix_slice &ms) noexcept
Constructor of class imatrix_slice.
Definition: imatrix.hpp:1906
imatrix_slice & operator-=(const imatrix &m1) noexcept
Implementation of subtraction and allocation operation.
Definition: imatrix.inl:1410
imatrix_slice & operator*=(const imatrix &m) noexcept
Implementation of multiplication and allocation operation.
Definition: imatrix.inl:1094
imatrix_slice(imatrix &a, const int &l1, const int &u1, const int &l2, const int &u2) noexcept
Constructor of class imatrix_slice.
Definition: imatrix.hpp:1901
The Data Type imatrix_subv.
Definition: imatrix.hpp:56
interval & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector (read-only)
Definition: imatrix.inl:196
friend int Lb(const imatrix_subv &rv) noexcept
Returns the lower bound of the vector.
Definition: imatrix.hpp:394
imatrix_subv(const imatrix_subv &v) noexcept
Constructor of class imatrix_subv.
Definition: imatrix.hpp:309
imatrix_subv & operator*=(const interval &c) noexcept
Implementation of multiplication and allocation operation.
Definition: imatrix.inl:491
friend int Ub(const imatrix_subv &rv) noexcept
Returns the upper bound of the vector.
Definition: imatrix.hpp:396
friend int VecLen(const imatrix_subv &rv) noexcept
Returns the size of the vector.
Definition: imatrix.hpp:398
imatrix_subv(interval *d, const int &l, const int &u, const int &s, const int &st, const int &o) noexcept
Constructor of class imatrix_subv.
Definition: imatrix.hpp:306
imatrix_subv & operator()() noexcept
Operator for accessing the whole vector.
Definition: imatrix.hpp:417
imatrix_subv & operator/=(const interval &c) noexcept
Implementation of division and allocation operation.
Definition: imatrix.inl:494
imatrix_subv & operator|=(const sivector &rv)
Implementation of addition and allocation operation.
Definition: simatrix.hpp:5664
imatrix_subv & operator+=(const interval &c) noexcept
Implementation of addition and allocation operation.
Definition: imatrix.inl:492
friend imatrix_subv Row(imatrix &m, const int &i) noexcept
Returns one row of the matrix as a vector.
Definition: imatrix.inl:152
friend imatrix_subv Col(imatrix &m, const int &i) noexcept
Returns one column of the matrix as a vector.
Definition: imatrix.inl:163
imatrix_subv & operator-=(const interval &c) noexcept
Implementation of subtraction and allocation operation.
Definition: imatrix.inl:493
imatrix_subv & operator&=(const sivector &rv)
Implementation of subtraction and allocation operation.
Definition: simatrix.hpp:5694
imatrix_subv & operator=(const simatrix_subv &rv)
Implementation of standard assigning operator.
Definition: simatrix.hpp:5734
The Data Type imatrix.
Definition: imatrix.hpp:660
imatrix & operator+=(const simatrix &)
Implementation of addition and assignment operator.
Definition: simatrix.hpp:1975
imatrix & operator=(const interval &r) noexcept
Implementation of standard assigning operator.
Definition: imatrix.inl:416
imatrix() noexcept
Constructor of class imatrix.
Definition: imatrix.inl:31
imatrix_subv operator[](const int &i) const noexcept
Operator for accessing a single row of the matrix.
Definition: imatrix.inl:223
imatrix & operator&=(const simatrix &)
Implementation of intersection and assignment operator.
Definition: simatrix.hpp:2039
imatrix & operator-=(const simatrix &)
Implementation of substraction and assignment operator.
Definition: simatrix.hpp:1991
imatrix & operator*=(const simatrix &)
Implementation of product and assignment operator.
Definition: simatrix.hpp:2007
imatrix & operator|=(const simatrix &)
Implementation of convex hull and assignment operator.
Definition: simatrix.hpp:2023
imatrix & operator()() noexcept
Operator for accessing the whole matrix.
Definition: imatrix.hpp:1415
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
ivector() noexcept
Constructor of class ivector.
Definition: ivector.inl:31
The Multiple-Precision Data Type l_imatrix.
Definition: l_imatrix.hpp:726
The Multiple-Precision Data Type l_ivector.
Definition: l_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 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
real MaxRelDiam(const imatrix_subv &v)
Computes the relative diameter .
Definition: imatrix.cpp:76
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
rvector absmax(const imatrix_subv &mv) noexcept
Returns the absolute maximum value of the matrix.
Definition: imatrix.inl:502
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
rvector absmin(const imatrix_subv &mv) noexcept
Returns the absolute minimum value of the matrix.
Definition: imatrix.inl:496
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