C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
l_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: l_imatrix.hpp,v 1.22 2014/01/30 17:23:46 cxsc Exp $ */
25 
26 #ifndef _CXSC_LIMATRIX_HPP_INCLUDED
27 #define _CXSC_LIMATRIX_HPP_INCLUDED
28 
29 #include "xscclass.hpp"
30 #include "idot.hpp"
31 #include "l_ivector.hpp"
32 #include "except.hpp"
33 #include "matrix.hpp"
34 #include "imatrix.hpp"
35 #include "l_rmatrix.hpp"
36 
37 namespace cxsc {
38 
39 class l_imatrix;
40 class l_imatrix_slice;
41 
43 
47 {
48  friend class l_ivector;
49  friend class l_imatrix;
50  friend class l_imatrix_slice;
51  private:
52  l_interval *dat;
53  int lb,ub;
54  int size,start,offset; // start=first element index 0..n-1
55 
56  public:
58  friend INLINE l_imatrix_subv Row(l_imatrix &m,const int &i)
59 #if(CXSC_INDEX_CHECK)
60 ;
61 #else
62  noexcept;
63 #endif
65  friend INLINE l_imatrix_subv Col(l_imatrix &m,const int &i)
66 #if(CXSC_INDEX_CHECK)
67 ;
68 #else
69  noexcept;
70 #endif
72  friend INLINE l_imatrix_subv Row(const l_imatrix &m,const int &i)
73 #if(CXSC_INDEX_CHECK)
74 ;
75 #else
76  noexcept;
77 #endif
79  friend INLINE l_imatrix_subv Col(const l_imatrix &m,const int &i)
80 #if(CXSC_INDEX_CHECK)
81 ;
82 #else
83  noexcept;
84 #endif
85 //#if(CXSC_INDEX_CHECK)
86 #ifdef _CXSC_FRIEND_TPL
87  //----------------- Templates ---------------------------------------
88 template <class MV1,class MV2> friend MV1 &_mvmvassign(MV1 &v,const MV2 &rv)
89 #if(CXSC_INDEX_CHECK)
90 ;
91 #else
92  noexcept;
93 #endif
94 template <class MV,class S> friend MV &_mvsassign(MV &v,const S &r) noexcept;
95 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
96 #if(CXSC_INDEX_CHECK)
97 ;
98 #else
99  noexcept;
100 #endif
101 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) noexcept;
102 template <class MV,class V> friend MV &_mvvsetinf(MV &v,const V &rv)
103 #if(CXSC_INDEX_CHECK)
104 ;
105 #else
106  noexcept;
107 #endif
108 template <class MV,class V> friend MV &_mvvsetsup(MV &v,const V &rv)
109 #if(CXSC_INDEX_CHECK)
110 ;
111 #else
112  noexcept;
113 #endif
114 template <class MV,class V> friend MV &_mvvusetinf(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 &_mvvusetsup(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 &_mvvsetre(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 &_mvvsetim(MV &v,const V &rv)
133 #if(CXSC_INDEX_CHECK)
134 ;
135 #else
136  noexcept;
137 #endif
138 template <class MV,class V> friend V _mvabs(const MV &mv) noexcept;
139 template <class MV,class V> friend V _mvdiam(const MV &mv) noexcept;
140 template <class MV,class V> friend V _mvmid(const MV &mv) noexcept;
141 template <class MV,class V> friend V _mvinf(const MV &mv) noexcept;
142 template <class MV,class V> friend V _mvsup(const MV &mv) noexcept;
143 
144  template <class MV,class S> friend MV &_mvssetinf(MV &mv, const S &s) noexcept;
145  template <class MV,class S> friend MV &_mvssetsup(MV &mv, const S &s) noexcept;
146  template <class MV,class S> friend MV &_mvsusetinf(MV &mv, const S &s) noexcept;
147  template <class MV,class S> friend MV &_mvsusetsup(MV &mv, const S &s) noexcept;
148 
149 template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
150 #if(CXSC_INDEX_CHECK)
151  ;
152 #else
153  noexcept;
154 #endif
155 template <class DP,class MV1,class MV2> friend void _mvmvaccu(DP &dp, const MV1 & rv1, const MV2 &rv2)
156 #if(CXSC_INDEX_CHECK)
157  ;
158 #else
159  noexcept;
160 #endif
161  template <class MV1,class MV2,class S> friend S _mvmvlimult(const MV1 & rv1, const MV2 &rv2)
162 #if(CXSC_INDEX_CHECK)
163  ;
164 #else
165  noexcept;
166 #endif
167  template <class V,class MV,class S> friend S _vmvlimult(const V &rv1, const MV &rv2)
168 #if(CXSC_INDEX_CHECK)
169  ;
170 #else
171  noexcept;
172 #endif
173  template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) noexcept;
174  template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
175 #if(CXSC_INDEX_CHECK)
176  ;
177 #else
178  noexcept;
179 #endif
180  template <class MV1,class MV2,class E> friend E _mvmvminus(const MV1 &rv1, const MV2 &rv2)
181 #if(CXSC_INDEX_CHECK)
182  ;
183 #else
184  noexcept;
185 #endif
186  template <class MV,class V,class E> friend E _mvvplus(const MV &rv1, const V &rv2)
187 #if(CXSC_INDEX_CHECK)
188  ;
189 #else
190  noexcept;
191 #endif
192  template <class MV,class V,class E> friend E _mvvminus(const MV &rv1, const V &rv2)
193 #if(CXSC_INDEX_CHECK)
194  ;
195 #else
196  noexcept;
197 #endif
198  template <class V,class MV,class E> friend E _vmvminus(const V &rv1, const MV &rv2)
199 #if(CXSC_INDEX_CHECK)
200  ;
201 #else
202  noexcept;
203 #endif
204  template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) noexcept;
205 template <class MV,class S> friend MV &_mvsmultassign(MV &v,const S &r) noexcept;
206 template <class MV, class S> friend MV &_mvsplusassign(MV &v,const S &r) noexcept;
207 template <class MV,class S> friend MV &_mvsminusassign(MV &v,const S &r) noexcept;
208 template <class MV,class S> friend MV &_mvsdivassign(MV &v,const S &r) noexcept;
209 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
210 #if(CXSC_INDEX_CHECK)
211 ;
212 #else
213  noexcept;
214 #endif
215 template <class V,class MV> friend V &_vmvplusassign(V &rv,const MV &v)
216 #if(CXSC_INDEX_CHECK)
217 ;
218 #else
219  noexcept;
220 #endif
221 template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv)
222 #if(CXSC_INDEX_CHECK)
223 ;
224 #else
225  noexcept;
226 #endif
227 template <class V,class MV> friend V &_vmvminusassign(V &rv,const MV &v)
228 #if(CXSC_INDEX_CHECK)
229 ;
230 #else
231  noexcept;
232 #endif
233  template <class MV1,class MV2,class E> friend E _mvmvconv(const MV1 &rv1, const MV2 &rv2)
234 #if(CXSC_INDEX_CHECK)
235  ;
236 #else
237  noexcept;
238 #endif
239  template <class MV,class V,class E> friend E _mvvconv(const MV &rv1, const V &rv2)
240 #if(CXSC_INDEX_CHECK)
241  ;
242 #else
243  noexcept;
244 #endif
245 template <class MV,class V> friend MV &_mvvconvassign(MV &v,const V &rv)
246 #if(CXSC_INDEX_CHECK)
247 ;
248 #else
249  noexcept;
250 #endif
251  template <class MV1,class MV2,class E> friend E _mvmvsect(const MV1 &rv1, const MV2 &rv2)
252 #if(CXSC_INDEX_CHECK)
253  ;
254 #else
255  noexcept;
256 #endif
257  template <class MV,class V,class E> friend E _mvvsect(const MV &rv1, const V &rv2)
258 #if(CXSC_INDEX_CHECK)
259  ;
260 #else
261  noexcept;
262 #endif
263 template <class MV,class V> friend MV &_mvvsectassign(MV &v,const V &rv)
264 #if(CXSC_INDEX_CHECK)
265 ;
266 #else
267  noexcept;
268 #endif
269 template <class V,class MV> friend V &_vmvsectassign(V &rv,const MV &v)
270 #if(CXSC_INDEX_CHECK)
271 ;
272 #else
273  noexcept;
274 #endif
275 
276 
277 #endif
278 
279  //----------------- Konstruktoren ----------------------------------
280 
282  explicit INLINE l_imatrix_subv (l_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) { }
283  public:
285  INLINE l_imatrix_subv(const l_imatrix_subv &v) noexcept:dat(v.dat),lb(v.lb),ub(v.ub),size(v.size),start(v.start),offset(v.offset) { }
286  public:
287 
288  //---------------------- Standardfunktionen ------------------------
289 
291  INLINE l_imatrix_subv &operator =(const l_imatrix_subv &rv) noexcept;
293  INLINE l_imatrix_subv &operator =(const l_interval &r) noexcept;
295  INLINE l_imatrix_subv &operator =(const l_imatrix &m)
296 #if(CXSC_INDEX_CHECK)
297 ;
298 #else
299  noexcept;
300 #endif
302  INLINE l_imatrix_subv &operator =(const l_imatrix_slice &m)
303 #if(CXSC_INDEX_CHECK)
304 ;
305 #else
306  noexcept;
307 #endif
309  INLINE l_imatrix_subv &operator =(const l_ivector &v)
310 #if(CXSC_INDEX_CHECK)
311 ;
312 #else
313  noexcept;
314 #endif
316  INLINE l_imatrix_subv &operator =(const l_ivector_slice &v)
317 #if(CXSC_INDEX_CHECK)
318 ;
319 #else
320  noexcept;
321 #endif
322  // Real
324  INLINE l_imatrix_subv &operator =(const real &r) noexcept;
326  INLINE l_imatrix_subv &operator =(const rmatrix &m)
327 #if(CXSC_INDEX_CHECK)
328 ;
329 #else
330  noexcept;
331 #endif
333  INLINE l_imatrix_subv &operator =(const rmatrix_slice &m)
334 #if(CXSC_INDEX_CHECK)
335 ;
336 #else
337  noexcept;
338 #endif
340  INLINE l_imatrix_subv &operator =(const rvector &v)
341 #if(CXSC_INDEX_CHECK)
342 ;
343 #else
344  noexcept;
345 #endif
347  INLINE l_imatrix_subv &operator =(const rvector_slice &v)
348 #if(CXSC_INDEX_CHECK)
349 ;
350 #else
351  noexcept;
352 #endif
354  INLINE l_imatrix_subv &operator =(const rmatrix_subv &rv) noexcept;
355 
356  // l_real
358  INLINE l_imatrix_subv &operator =(const l_real &r) noexcept;
360  INLINE l_imatrix_subv &operator =(const l_rmatrix &m)
361 #if(CXSC_INDEX_CHECK)
362 ;
363 #else
364  noexcept;
365 #endif
367  INLINE l_imatrix_subv &operator =(const l_rmatrix_slice &m)
368 #if(CXSC_INDEX_CHECK)
369 ;
370 #else
371  noexcept;
372 #endif
374  INLINE l_imatrix_subv &operator =(const l_rvector &v)
375 #if(CXSC_INDEX_CHECK)
376 ;
377 #else
378  noexcept;
379 #endif
381  INLINE l_imatrix_subv &operator =(const l_rvector_slice &v)
382 #if(CXSC_INDEX_CHECK)
383 ;
384 #else
385  noexcept;
386 #endif
388  INLINE l_imatrix_subv &operator =(const l_rmatrix_subv &rv) noexcept;
389 
390  // interval
392  INLINE l_imatrix_subv &operator =(const interval &r) noexcept;
394  INLINE l_imatrix_subv &operator =(const imatrix &m)
395 #if(CXSC_INDEX_CHECK)
396 ;
397 #else
398  noexcept;
399 #endif
401  INLINE l_imatrix_subv &operator =(const imatrix_slice &m)
402 #if(CXSC_INDEX_CHECK)
403 ;
404 #else
405  noexcept;
406 #endif
408  INLINE l_imatrix_subv &operator =(const ivector &v)
409 #if(CXSC_INDEX_CHECK)
410 ;
411 #else
412  noexcept;
413 #endif
415  INLINE l_imatrix_subv &operator =(const ivector_slice &v)
416 #if(CXSC_INDEX_CHECK)
417 ;
418 #else
419  noexcept;
420 #endif
422  INLINE l_imatrix_subv &operator =(const imatrix_subv &rv) noexcept;
423 
425  friend INLINE int Lb(const l_imatrix_subv &rv) noexcept { return rv.lb; }
427  friend INLINE int Ub(const l_imatrix_subv &rv) noexcept { return rv.ub; }
429  INLINE l_interval &operator [](const int &i) const
430 #if(CXSC_INDEX_CHECK)
431 ;
432 #else
433  noexcept;
434 #endif
436  INLINE l_imatrix_subv &operator ()() noexcept { return *this; }
438  INLINE l_imatrix_subv operator ()(const int &i)
439 #if(CXSC_INDEX_CHECK)
440 ;
441 #else
442  noexcept;
443 #endif
445  INLINE l_imatrix_subv operator ()(const int &i1,const int &i2)
446 #if(CXSC_INDEX_CHECK)
447 ;
448 #else
449  noexcept;
450 #endif
451 
453  INLINE l_imatrix_subv &operator *=(const l_interval &c) noexcept;
455  INLINE l_imatrix_subv &operator +=(const l_interval &c) noexcept;
457  INLINE l_imatrix_subv &operator -=(const l_interval &c) noexcept;
459  INLINE l_imatrix_subv &operator /=(const l_interval &c) noexcept;
461  INLINE l_imatrix_subv &operator -=(const l_ivector &rv)
462 #if(CXSC_INDEX_CHECK)
463 ;
464 #else
465  noexcept;
466 #endif
468  INLINE l_imatrix_subv &operator +=(const l_ivector &rv)
469 #if(CXSC_INDEX_CHECK)
470 ;
471 #else
472  noexcept;
473 #endif
475  INLINE l_imatrix_subv &operator -=(const l_ivector_slice &rv)
476 #if(CXSC_INDEX_CHECK)
477 ;
478 #else
479  noexcept;
480 #endif
482  INLINE l_imatrix_subv &operator +=(const l_ivector_slice &rv)
483 #if(CXSC_INDEX_CHECK)
484 ;
485 #else
486  noexcept;
487 #endif
489  INLINE l_imatrix_subv &operator |=(const l_ivector &rv)
490 #if(CXSC_INDEX_CHECK)
491 ;
492 #else
493  noexcept;
494 #endif
496  INLINE l_imatrix_subv &operator |=(const l_ivector_slice &rv)
497 #if(CXSC_INDEX_CHECK)
498 ;
499 #else
500  noexcept;
501 #endif
503  INLINE l_imatrix_subv &operator &=(const l_ivector &rv)
504 #if(CXSC_INDEX_CHECK)
505 ;
506 #else
507  noexcept;
508 #endif
510  INLINE l_imatrix_subv &operator &=(const l_ivector_slice &rv)
511 #if(CXSC_INDEX_CHECK)
512 ;
513 #else
514  noexcept;
515 #endif
516  // real
518  INLINE l_imatrix_subv &operator *=(const real &c) noexcept;
520  INLINE l_imatrix_subv &operator +=(const real &c) noexcept;
522  INLINE l_imatrix_subv &operator -=(const real &c) noexcept;
524  INLINE l_imatrix_subv &operator /=(const real &c) noexcept;
526  INLINE l_imatrix_subv &operator -=(const rvector &rv)
527 #if(CXSC_INDEX_CHECK)
528 ;
529 #else
530  noexcept;
531 #endif
533  INLINE l_imatrix_subv &operator +=(const rvector &rv)
534 #if(CXSC_INDEX_CHECK)
535 ;
536 #else
537  noexcept;
538 #endif
540  INLINE l_imatrix_subv &operator -=(const rvector_slice &rv)
541 #if(CXSC_INDEX_CHECK)
542 ;
543 #else
544  noexcept;
545 #endif
547  INLINE l_imatrix_subv &operator +=(const rvector_slice &rv)
548 #if(CXSC_INDEX_CHECK)
549 ;
550 #else
551  noexcept;
552 #endif
554  INLINE l_imatrix_subv &operator |=(const rvector &rv)
555 #if(CXSC_INDEX_CHECK)
556 ;
557 #else
558  noexcept;
559 #endif
561  INLINE l_imatrix_subv &operator |=(const rvector_slice &rv)
562 #if(CXSC_INDEX_CHECK)
563 ;
564 #else
565  noexcept;
566 #endif
568  INLINE l_imatrix_subv &operator &=(const rvector &rv)
569 #if(CXSC_INDEX_CHECK)
570 ;
571 #else
572  noexcept;
573 #endif
575  INLINE l_imatrix_subv &operator &=(const rvector_slice &rv)
576 #if(CXSC_INDEX_CHECK)
577 ;
578 #else
579  noexcept;
580 #endif
581  // l_real
583  INLINE l_imatrix_subv &operator *=(const l_real &c) noexcept;
585  INLINE l_imatrix_subv &operator +=(const l_real &c) noexcept;
587  INLINE l_imatrix_subv &operator -=(const l_real &c) noexcept;
589  INLINE l_imatrix_subv &operator /=(const l_real &c) noexcept;
591  INLINE l_imatrix_subv &operator -=(const l_rvector &rv)
592 #if(CXSC_INDEX_CHECK)
593 ;
594 #else
595  noexcept;
596 #endif
598  INLINE l_imatrix_subv &operator +=(const l_rvector &rv)
599 #if(CXSC_INDEX_CHECK)
600 ;
601 #else
602  noexcept;
603 #endif
605  INLINE l_imatrix_subv &operator -=(const l_rvector_slice &rv)
606 #if(CXSC_INDEX_CHECK)
607 ;
608 #else
609  noexcept;
610 #endif
612  INLINE l_imatrix_subv &operator +=(const l_rvector_slice &rv)
613 #if(CXSC_INDEX_CHECK)
614 ;
615 #else
616  noexcept;
617 #endif
619  INLINE l_imatrix_subv &operator |=(const l_rvector &rv)
620 #if(CXSC_INDEX_CHECK)
621 ;
622 #else
623  noexcept;
624 #endif
626  INLINE l_imatrix_subv &operator |=(const l_rvector_slice &rv)
627 #if(CXSC_INDEX_CHECK)
628 ;
629 #else
630  noexcept;
631 #endif
633  INLINE l_imatrix_subv &operator &=(const l_rvector &rv)
634 #if(CXSC_INDEX_CHECK)
635 ;
636 #else
637  noexcept;
638 #endif
640  INLINE l_imatrix_subv &operator &=(const l_rvector_slice &rv)
641 #if(CXSC_INDEX_CHECK)
642 ;
643 #else
644  noexcept;
645 #endif
646  // interval
648  INLINE l_imatrix_subv &operator *=(const interval &c) noexcept;
650  INLINE l_imatrix_subv &operator +=(const interval &c) noexcept;
652  INLINE l_imatrix_subv &operator -=(const interval &c) noexcept;
654  INLINE l_imatrix_subv &operator /=(const interval &c) noexcept;
656  INLINE l_imatrix_subv &operator -=(const ivector &rv)
657 #if(CXSC_INDEX_CHECK)
658 ;
659 #else
660  noexcept;
661 #endif
663  INLINE l_imatrix_subv &operator +=(const ivector &rv)
664 #if(CXSC_INDEX_CHECK)
665 ;
666 #else
667  noexcept;
668 #endif
670  INLINE l_imatrix_subv &operator -=(const ivector_slice &rv)
671 #if(CXSC_INDEX_CHECK)
672 ;
673 #else
674  noexcept;
675 #endif
677  INLINE l_imatrix_subv &operator +=(const ivector_slice &rv)
678 #if(CXSC_INDEX_CHECK)
679 ;
680 #else
681  noexcept;
682 #endif
684  INLINE l_imatrix_subv &operator |=(const ivector &rv)
685 #if(CXSC_INDEX_CHECK)
686 ;
687 #else
688  noexcept;
689 #endif
691  INLINE l_imatrix_subv &operator |=(const ivector_slice &rv)
692 #if(CXSC_INDEX_CHECK)
693 ;
694 #else
695  noexcept;
696 #endif
698  INLINE l_imatrix_subv &operator &=(const ivector &rv)
699 #if(CXSC_INDEX_CHECK)
700 ;
701 #else
702  noexcept;
703 #endif
705  INLINE l_imatrix_subv &operator &=(const ivector_slice &rv)
706 #if(CXSC_INDEX_CHECK)
707 ;
708 #else
709  noexcept;
710 #endif
711 //#else
712 //#endif
713 
714 };
715 
716 
717 //----------------------- Matrix -----------------------------------------------
718 
719 class l_imatrix_slice;
720 
722 
726 {
727  friend class l_imatrix_slice;
728  friend class l_imatrix_subv;
729  private:
730  l_interval *dat;
731  int lb1,ub1,lb2,ub2,xsize,ysize;
732 
733  public:
734 //#if(CXSC_INDEX_CHECK)
735 #ifdef _CXSC_FRIEND_TPL
736  //----------------- Templates ---------------------------------------
737 template <class S,class M> friend void _smconstr(S &s,const M &m)
738 #if(CXSC_INDEX_CHECK)
739 ;
740 #else
741  noexcept;
742 #endif
743 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
744 #if(CXSC_INDEX_CHECK)
745 ;
746 #else
747  noexcept;
748 #endif
749  template <class M1,class M2,class S> friend M1 &_mmassign(M1 &m1,const M2 &m,S ms) noexcept;
750  template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) noexcept;
751  template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m)
752 #if(CXSC_INDEX_CHECK)
753  ;
754 #else
755  noexcept;
756 #endif
757  template <class M,class S> friend M &_msassign(M &m,const S &r) noexcept;
758 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m)
759 #if(CXSC_INDEX_CHECK)
760 ;
761 #else
762  noexcept;
763 #endif
764 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) noexcept;
765  template <class M> friend int _mlb(const M &m, const int &i)
766 #if(CXSC_INDEX_CHECK)
767 ;
768 #else
769  noexcept;
770 #endif
771  template <class M> friend int _mub(const M &m, const int &i)
772 #if(CXSC_INDEX_CHECK)
773 ;
774 #else
775  noexcept;
776 #endif
777  template <class M> friend M &_msetlb(M &m, const int &i,const int &j)
778 #if(CXSC_INDEX_CHECK)
779 ;
780 #else
781  noexcept;
782 #endif
783  template <class M> friend M &_msetub(M &m, const int &i,const int &j)
784 #if(CXSC_INDEX_CHECK)
785 ;
786 #else
787  noexcept;
788 #endif
789  template <class M> friend void _mresize(M &A) noexcept;
790  template <class M,class S> friend void _mresize(M &A,const int &m, const int &n)
791 #if(CXSC_INDEX_CHECK)
792  ;
793 #else
794  noexcept;
795 #endif
796  template <class M,class S> friend void _mresize(M &A,const int &m1, const int &m2,const int &n1,const int &n2)
797 #if(CXSC_INDEX_CHECK)
798  ;
799 #else
800  noexcept;
801 #endif
802  template <class M,class E> friend E _mabs(const M &m) noexcept;
803  template <class MS,class E> friend E _msabs(const MS &ms) noexcept;
804  template <class M,class E> friend E _mdiam(const M &m) noexcept;
805  template <class M,class E> friend E _mmid(const M &m) noexcept;
806  template <class M,class E> friend E _minf(const M &m) noexcept;
807  template <class M,class E> friend E _msup(const M &m) noexcept;
808  template <class M1,class M2> friend M1 &_mmsetinf(M1 &m1,const M2 &m2)
809 #if(CXSC_INDEX_CHECK)
810  ;
811 #else
812  noexcept;
813 #endif
814  template <class M1,class M2> friend M1 &_mmsetsup(M1 &m1,const M2 &m2)
815 #if(CXSC_INDEX_CHECK)
816  ;
817 #else
818  noexcept;
819 #endif
820  template <class M1,class MS2> friend M1 &_mmssetinf(M1 &m1,const MS2 &ms2)
821 #if(CXSC_INDEX_CHECK)
822  ;
823 #else
824  noexcept;
825 #endif
826  template <class M1,class MS2> friend M1 &_mmssetsup(M1 &m1,const MS2 &ms2)
827 #if(CXSC_INDEX_CHECK)
828  ;
829 #else
830  noexcept;
831 #endif
832  template <class M1,class M2> friend M1 &_mmusetinf(M1 &m1,const M2 &m2)
833 #if(CXSC_INDEX_CHECK)
834  ;
835 #else
836  noexcept;
837 #endif
838  template <class M1,class M2> friend M1 &_mmusetsup(M1 &m1,const M2 &m2)
839 #if(CXSC_INDEX_CHECK)
840  ;
841 #else
842  noexcept;
843 #endif
844  template <class M1,class MS2> friend M1 &_mmsusetinf(M1 &m1,const MS2 &ms2)
845 #if(CXSC_INDEX_CHECK)
846  ;
847 #else
848  noexcept;
849 #endif
850  template <class M1,class MS2> friend M1 &_mmsusetsup(M1 &m1,const MS2 &ms2)
851 #if(CXSC_INDEX_CHECK)
852  ;
853 #else
854  noexcept;
855 #endif
856  //-------------- matrix-matrix -------------
857  template <class M1,class M2,class E> friend E _mmplus(const M1 &m1,const M2 &m2)
858 #if(CXSC_INDEX_CHECK)
859  ;
860 #else
861  noexcept;
862 #endif
863  template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms)
864 #if(CXSC_INDEX_CHECK)
865  ;
866 #else
867  noexcept;
868 #endif
869  template <class M> friend M _mminus(const M &m) noexcept;
870  template <class MS,class E> friend E _msminus(const MS &ms) noexcept;
871  template <class M1,class M2,class E> friend E _mmminus(const M1 &m1,const M2 &m2)
872 #if(CXSC_INDEX_CHECK)
873  ;
874 #else
875  noexcept;
876 #endif
877  template <class M1,class M2> friend M1 &_mmplusassign(M1 &m1,const M2 &m2)
878 #if(CXSC_INDEX_CHECK)
879  ;
880 #else
881  noexcept;
882 #endif
883  template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms)
884 #if(CXSC_INDEX_CHECK)
885  ;
886 #else
887  noexcept;
888 #endif
889  template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1)
890 #if(CXSC_INDEX_CHECK)
891  ;
892 #else
893  noexcept;
894 #endif
895  template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2)
896 #if(CXSC_INDEX_CHECK)
897  ;
898 #else
899  noexcept;
900 #endif
901  template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms)
902 #if(CXSC_INDEX_CHECK)
903  ;
904 #else
905  noexcept;
906 #endif
907  template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m)
908 #if(CXSC_INDEX_CHECK)
909  ;
910 #else
911  noexcept;
912 #endif
913  template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2)
914 #if(CXSC_INDEX_CHECK)
915  ;
916 #else
917  noexcept;
918 #endif
919  template <class M1,class M2> friend M1 &_mmminusassign(M1 &m1,const M2 &m2)
920 #if(CXSC_INDEX_CHECK)
921  ;
922 #else
923  noexcept;
924 #endif
925  template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms)
926 #if(CXSC_INDEX_CHECK)
927  ;
928 #else
929  noexcept;
930 #endif
931  template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1)
932 #if(CXSC_INDEX_CHECK)
933  ;
934 #else
935  noexcept;
936 #endif
937  template <class M1,class M2,class E> friend E _mmlimult(const M1 &m1, const M2 &m2)
938 #if(CXSC_INDEX_CHECK)
939  ;
940 #else
941  noexcept;
942 #endif
943  template <class M1,class M2,class S> friend M1 &_mmlimultassign(M1 &m1,const M2 &m2)
944 #if(CXSC_INDEX_CHECK)
945  ;
946 #else
947  noexcept;
948 #endif
949  template <class M,class MS,class E> friend E _mmslimult(const M &m1, const MS &ms)
950 #if(CXSC_INDEX_CHECK)
951  ;
952 #else
953  noexcept;
954 #endif
955  template <class MS,class M,class E> friend E _msmlimult(const MS &ms, const M &m2)
956 #if(CXSC_INDEX_CHECK)
957  ;
958 #else
959  noexcept;
960 #endif
961  template <class M,class MS,class S> friend M &_mmslimultassign(M &m1,const MS &ms)
962 #if(CXSC_INDEX_CHECK)
963  ;
964 #else
965  noexcept;
966 #endif
967  template <class MS1,class MS2,class E> friend E _msmslimult(const MS1 &ms1, const MS2 &ms2)
968 #if(CXSC_INDEX_CHECK)
969  ;
970 #else
971  noexcept;
972 #endif
973  template <class M1,class M2,class E> friend E _mmconv(const M1 &m1,const M2 &m2)
974 #if(CXSC_INDEX_CHECK)
975  ;
976 #else
977  noexcept;
978 #endif
979  template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms)
980 #if(CXSC_INDEX_CHECK)
981  ;
982 #else
983  noexcept;
984 #endif
985  template <class M1,class M2> friend M1 &_mmconvassign(M1 &m1,const M2 &m2)
986 #if(CXSC_INDEX_CHECK)
987  ;
988 #else
989  noexcept;
990 #endif
991  template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms)
992 #if(CXSC_INDEX_CHECK)
993  ;
994 #else
995  noexcept;
996 #endif
997  template <class MS,class M> friend MS &_msmconvassign(MS &ms,const M &m1)
998 #if(CXSC_INDEX_CHECK)
999  ;
1000 #else
1001  noexcept;
1002 #endif
1003  template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2)
1004 #if(CXSC_INDEX_CHECK)
1005  ;
1006 #else
1007  noexcept;
1008 #endif
1009  template <class M1,class M2,class E> friend E _mmsect(const M1 &m1,const M2 &m2)
1010 #if(CXSC_INDEX_CHECK)
1011  ;
1012 #else
1013  noexcept;
1014 #endif
1015  template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms)
1016 #if(CXSC_INDEX_CHECK)
1017  ;
1018 #else
1019  noexcept;
1020 #endif
1021  template <class M1,class M2> friend M1 &_mmsectassign(M1 &m1,const M2 &m2)
1022 #if(CXSC_INDEX_CHECK)
1023  ;
1024 #else
1025  noexcept;
1026 #endif
1027  template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms)
1028 #if(CXSC_INDEX_CHECK)
1029  ;
1030 #else
1031  noexcept;
1032 #endif
1033  template <class MS,class M> friend MS &_msmsectassign(MS &ms,const M &m1)
1034 #if(CXSC_INDEX_CHECK)
1035  ;
1036 #else
1037  noexcept;
1038 #endif
1039  template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2)
1040 #if(CXSC_INDEX_CHECK)
1041  ;
1042 #else
1043  noexcept;
1044 #endif
1045  //-------- matrix-scalar -----------------
1046  template <class S,class M,class E> friend E _smmult(const S &c, const M &m) noexcept;
1047  template <class M,class S> friend M &_msmultassign(M &m,const S &c) noexcept;
1048  template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) noexcept;
1049  template <class M,class S,class E> friend E _msdiv(const M &m,const S &c) noexcept;
1050  template <class M,class S> friend M &_msdivassign(M &m,const S &c) noexcept;
1051  template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) noexcept;
1052  //-------- matrix-vector ---------------------
1053  template <class M,class V,class E> friend E _mvlimult(const M &m,const V &v)
1054 #if(CXSC_INDEX_CHECK)
1055  ;
1056 #else
1057  noexcept;
1058 #endif
1059  template <class V,class M,class E> friend E _vmlimult(const V &v,const M &m)
1060 #if(CXSC_INDEX_CHECK)
1061  ;
1062 #else
1063  noexcept;
1064 #endif
1065  template <class V,class M,class S> friend V &_vmlimultassign(V &v,const M &m)
1066 #if(CXSC_INDEX_CHECK)
1067  ;
1068 #else
1069  noexcept;
1070 #endif
1071  template <class VS,class M,class S> friend VS &_vsmlimultassign(VS &v,const M &m)
1072 #if(CXSC_INDEX_CHECK)
1073  ;
1074 #else
1075  noexcept;
1076 #endif
1077 
1078  template <class M> friend void *_mvoid(const M &m) noexcept;
1079  template <class M> friend bool _mnot(const M &m) noexcept;
1080  template <class MS> friend void *_msvoid(const MS &ms) noexcept;
1081  template <class MS> friend bool _msnot(const MS &ms) noexcept;
1082  template <class M1,class M2> friend bool _mmeq(const M1 &m1,const M2 &m2) noexcept;
1083  template <class M1,class M2> friend bool _mmneq(const M1 &m1,const M2 &m2) noexcept;
1084  template <class M1,class M2> friend bool _mmless(const M1 &m1,const M2 &m2) noexcept;
1085  template <class M1,class M2> friend bool _mmleq(const M1 &m1,const M2 &m2) noexcept;
1086  template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) noexcept;
1087  template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) noexcept;
1088  template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) noexcept;
1089  template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) noexcept;
1090  template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) noexcept;
1091  template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) noexcept;
1092  template <class M> friend std::ostream &_mout(std::ostream &s,const M &r) noexcept;
1093  template <class M> friend std::istream &_min(std::istream &s,M &r) noexcept;
1094 
1095  //--- Real --------- matrix-scalar ----------------------
1096  template <class M1,class MS2> friend M1 &_mmssetre(M1 &m1,const MS2 &ms2)
1097 #if(CXSC_INDEX_CHECK)
1098  ;
1099 #else
1100  noexcept;
1101 #endif
1102  template <class M1,class MS2> friend M1 &_mmssetim(M1 &m1,const MS2 &ms2)
1103 #if(CXSC_INDEX_CHECK)
1104  ;
1105 #else
1106  noexcept;
1107 #endif
1108 
1109  //--- Real --------- matrix-vector ----------------------
1110  template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v)
1111 #if(CXSC_INDEX_CHECK)
1112  ;
1113 #else
1114  noexcept;
1115 #endif
1116  template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms)
1117 #if(CXSC_INDEX_CHECK)
1118  ;
1119 #else
1120  noexcept;
1121 #endif
1122 
1123 
1124 #endif
1125 
1126  //-------------------------- Konstruktoren ----------------------------
1127 
1128 // l_interval
1130  INLINE l_imatrix(const l_imatrix &rm) noexcept;
1132  INLINE l_imatrix(const l_imatrix_slice &rm) noexcept;
1134  INLINE l_imatrix() noexcept;
1136  explicit INLINE l_imatrix(const int &m, const int &n)
1137 #if(CXSC_INDEX_CHECK)
1138 ;
1139 #else
1140  noexcept;
1141 #endif
1143  explicit INLINE l_imatrix(const int &m1, const int &n1, const int &m2, const int &n2)
1144 #if(CXSC_INDEX_CHECK)
1145 ;
1146 #else
1147  noexcept;
1148 #endif
1150  explicit INLINE l_imatrix(const l_ivector &v) noexcept;
1152  explicit INLINE l_imatrix(const l_ivector_slice &v) noexcept;
1154  explicit INLINE l_imatrix(const l_interval &r) noexcept;
1156  INLINE l_imatrix &operator =(const l_interval &r) noexcept;
1158  INLINE l_imatrix &operator =(const l_imatrix &m) noexcept;
1160  INLINE l_imatrix &operator =(const l_imatrix_slice &ms) noexcept;
1162  INLINE l_imatrix &operator =(const l_ivector &v) noexcept;
1164  INLINE l_imatrix &operator =(const l_ivector_slice &v) noexcept;
1165 // real
1167  explicit INLINE l_imatrix(const real &r) noexcept;
1169  explicit INLINE l_imatrix(const rmatrix &rm) noexcept;
1171  explicit INLINE l_imatrix(const rmatrix_slice &rm) noexcept;
1173  explicit INLINE l_imatrix(const rvector &v) noexcept;
1175  explicit INLINE l_imatrix(const rvector_slice &v) noexcept;
1177  INLINE l_imatrix &operator =(const real &r) noexcept;
1179  INLINE l_imatrix &operator =(const rmatrix &m) noexcept;
1181  INLINE l_imatrix &operator =(const rmatrix_slice &ms) noexcept;
1183  INLINE l_imatrix &operator =(const rvector &v) noexcept;
1185  INLINE l_imatrix &operator =(const rvector_slice &v) noexcept;
1186 
1187 // l_real
1189  explicit INLINE l_imatrix(const l_real &r) noexcept;
1191  explicit INLINE l_imatrix(const l_rmatrix &rm) noexcept;
1193  explicit INLINE l_imatrix(const l_rmatrix_slice &rm) noexcept;
1195  explicit INLINE l_imatrix(const l_rvector &v) noexcept;
1197  explicit INLINE l_imatrix(const l_rvector_slice &v) noexcept;
1199  INLINE l_imatrix &operator =(const l_real &r) noexcept;
1201  INLINE l_imatrix &operator =(const l_rmatrix &m) noexcept;
1203  INLINE l_imatrix &operator =(const l_rmatrix_slice &ms) noexcept;
1205  INLINE l_imatrix &operator =(const l_rvector &v) noexcept;
1207  INLINE l_imatrix &operator =(const l_rvector_slice &v) noexcept;
1208 
1209 // interval
1211  explicit INLINE l_imatrix(const interval &r) noexcept;
1213  explicit INLINE l_imatrix(const imatrix &rm) noexcept;
1215  explicit INLINE l_imatrix(const imatrix_slice &rm) noexcept;
1217  explicit INLINE l_imatrix(const ivector &v) noexcept;
1219  explicit INLINE l_imatrix(const ivector_slice &v) noexcept;
1221  INLINE l_imatrix &operator =(const interval &r) noexcept;
1223  INLINE l_imatrix &operator =(const imatrix &m) noexcept;
1225  INLINE l_imatrix &operator =(const imatrix_slice &ms) noexcept;
1227  INLINE l_imatrix &operator =(const ivector &v) noexcept;
1229  INLINE l_imatrix &operator =(const ivector_slice &v) noexcept;
1230 
1231  //--------------------------- Destruktoren -----------------------------
1232 
1233  INLINE ~l_imatrix() noexcept { delete [] dat; }
1234 
1235  //------------------------- Standardfunktionen -------------------------
1236 
1238  INLINE l_imatrix_subv operator [](const int &i) const
1239 #if(CXSC_INDEX_CHECK)
1240 ;
1241 #else
1242  noexcept;
1243 #endif
1245  INLINE l_imatrix_subv operator [](const cxscmatrix_column &i) const
1246 #if(CXSC_INDEX_CHECK)
1247 ;
1248 #else
1249  noexcept;
1250 #endif
1252  INLINE l_imatrix &operator ()() noexcept { return *this; }
1254  INLINE l_imatrix_slice operator ()(const int &m, const int &n)
1255 #if(CXSC_INDEX_CHECK)
1256 ;
1257 #else
1258  noexcept;
1259 #endif
1261  INLINE l_imatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
1262 #if(CXSC_INDEX_CHECK)
1263 ;
1264 #else
1265  noexcept;
1266 #endif
1267  INLINE operator void*() noexcept;
1268 //#else
1269 //#endif
1270 };
1271 
1272 
1274 
1280 {
1281  friend class l_imatrix;
1282  private:
1283  l_interval *dat;
1284  int offset1,offset2,mxsize,mysize;
1285  int start1,end1,start2,end2,sxsize,sysize; // slice size
1286 
1287  public:
1288 //#if(CXSC_INDEX_CHECK)
1289 #ifdef _CXSC_FRIEND_TPL
1290  //----------------- Templates ---------------------------------------
1291 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m)
1292 #if(CXSC_INDEX_CHECK)
1293 ;
1294 #else
1295  noexcept;
1296 #endif
1297  template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m)
1298 #if(CXSC_INDEX_CHECK)
1299  ;
1300 #else
1301  noexcept;
1302 #endif
1303  template <class MS1,class MS2> friend MS1 &_msmsassign(MS1 &ms1,const MS2 &ms)
1304 #if(CXSC_INDEX_CHECK)
1305  ;
1306 #else
1307  noexcept;
1308 #endif
1309  template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) noexcept;
1310  template <class MS,class S> friend MS &_mssassign(MS &ms,const S &r) noexcept;
1311  template <class MS> friend int _mslb(const MS &ms, const int &i)
1312 #if(CXSC_INDEX_CHECK)
1313 ;
1314 #else
1315  noexcept;
1316 #endif
1317  template <class MS> friend int _msub(const MS &ms, const int &i)
1318 #if(CXSC_INDEX_CHECK)
1319 ;
1320 #else
1321  noexcept;
1322 #endif
1323  template <class MS,class E> friend E _msabs(const MS &ms) noexcept;
1324  template <class MS,class E> friend E _msinf(const MS &ms) noexcept;
1325  template <class MS,class E> friend E _mssup(const MS &ms) noexcept;
1326  template <class MS,class E> friend E _msdiam(const MS &ms) noexcept;
1327  template <class MS,class E> friend E _msmid(const MS &ms) noexcept;
1328  template <class MS1,class M2> friend MS1 &_msmsetinf(MS1 &ms1,const M2 &m2)
1329 #if(CXSC_INDEX_CHECK)
1330  ;
1331 #else
1332  noexcept;
1333 #endif
1334  template <class MS1,class M2> friend MS1 &_msmsetsup(MS1 &ms1,const M2 &m2)
1335 #if(CXSC_INDEX_CHECK)
1336  ;
1337 #else
1338  noexcept;
1339 #endif
1340  template <class MS1,class MS2> friend MS1 &_msmssetinf(MS1 &ms1,const MS2 &ms2)
1341 #if(CXSC_INDEX_CHECK)
1342  ;
1343 #else
1344  noexcept;
1345 #endif
1346  template <class MS1,class MS2> friend MS1 &_msmssetsup(MS1 &ms1,const MS2 &ms2)
1347 #if(CXSC_INDEX_CHECK)
1348  ;
1349 #else
1350  noexcept;
1351 #endif
1352  template <class MS1,class M2> friend MS1 &_msmusetinf(MS1 &ms1,const M2 &m2)
1353 #if(CXSC_INDEX_CHECK)
1354  ;
1355 #else
1356  noexcept;
1357 #endif
1358  template <class MS1,class M2> friend MS1 &_msmusetsup(MS1 &ms1,const M2 &m2)
1359 #if(CXSC_INDEX_CHECK)
1360  ;
1361 #else
1362  noexcept;
1363 #endif
1364  template <class MS1,class MS2> friend MS1 &_msmsusetinf(MS1 &ms1,const MS2 &ms2)
1365 #if(CXSC_INDEX_CHECK)
1366  ;
1367 #else
1368  noexcept;
1369 #endif
1370  template <class MS1,class MS2> friend MS1 &_msmsusetsup(MS1 &ms1,const MS2 &ms2)
1371 #if(CXSC_INDEX_CHECK)
1372  ;
1373 #else
1374  noexcept;
1375 #endif
1376  //-------- matrix-matrix --------------
1377  template <class MS,class E> friend E _msminus(const MS &ms) noexcept;
1378  template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms)
1379 #if(CXSC_INDEX_CHECK)
1380  ;
1381 #else
1382  noexcept;
1383 #endif
1384  template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2)
1385 #if(CXSC_INDEX_CHECK)
1386  ;
1387 #else
1388  noexcept;
1389 #endif
1390  template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms)
1391 #if(CXSC_INDEX_CHECK)
1392  ;
1393 #else
1394  noexcept;
1395 #endif
1396  template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1)
1397 #if(CXSC_INDEX_CHECK)
1398  ;
1399 #else
1400  noexcept;
1401 #endif
1402  template <class MS1,class MS2> friend MS1 &_msmsplusassign(MS1 &ms1,const MS2 &ms2)
1403 #if(CXSC_INDEX_CHECK)
1404  ;
1405 #else
1406  noexcept;
1407 #endif
1408  template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms)
1409 #if(CXSC_INDEX_CHECK)
1410  ;
1411 #else
1412  noexcept;
1413 #endif
1414  template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m)
1415 #if(CXSC_INDEX_CHECK)
1416  ;
1417 #else
1418  noexcept;
1419 #endif
1420  template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2)
1421 #if(CXSC_INDEX_CHECK)
1422  ;
1423 #else
1424  noexcept;
1425 #endif
1426  template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms)
1427 #if(CXSC_INDEX_CHECK)
1428  ;
1429 #else
1430  noexcept;
1431 #endif
1432  template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1)
1433 #if(CXSC_INDEX_CHECK)
1434  ;
1435 #else
1436  noexcept;
1437 #endif
1438  template <class MS1,class MS2> friend MS1 &_msmsminusassign(MS1 &ms1,const MS2 &ms2)
1439 #if(CXSC_INDEX_CHECK)
1440  ;
1441 #else
1442  noexcept;
1443 #endif
1444  template <class M,class MS,class E> friend E _mmslimult(const M &m1, const MS &ms)
1445 #if(CXSC_INDEX_CHECK)
1446  ;
1447 #else
1448  noexcept;
1449 #endif
1450  template <class MS,class M,class E> friend E _msmlimult(const MS &ms, const M &m2)
1451 #if(CXSC_INDEX_CHECK)
1452  ;
1453 #else
1454  noexcept;
1455 #endif
1456  template <class M,class MS,class S> friend M &_mmslimultassign(M &m1,const MS &ms)
1457 #if(CXSC_INDEX_CHECK)
1458  ;
1459 #else
1460  noexcept;
1461 #endif
1462  template <class MS1,class MS2,class E> friend E _msmslimult(const MS1 &ms1, const MS2 &ms2)
1463 #if(CXSC_INDEX_CHECK)
1464  ;
1465 #else
1466  noexcept;
1467 #endif
1468  template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms)
1469 #if(CXSC_INDEX_CHECK)
1470  ;
1471 #else
1472  noexcept;
1473 #endif
1474  template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms)
1475 #if(CXSC_INDEX_CHECK)
1476  ;
1477 #else
1478  noexcept;
1479 #endif
1480  template <class MS,class M> friend MS &_msmconvassign(MS &ms,const M &m1)
1481 #if(CXSC_INDEX_CHECK)
1482  ;
1483 #else
1484  noexcept;
1485 #endif
1486  template <class MS1,class MS2> friend MS1 &_msmsconvassign(MS1 &ms1,const MS2 &ms2)
1487 #if(CXSC_INDEX_CHECK)
1488  ;
1489 #else
1490  noexcept;
1491 #endif
1492  template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2)
1493 #if(CXSC_INDEX_CHECK)
1494  ;
1495 #else
1496  noexcept;
1497 #endif
1498  template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms)
1499 #if(CXSC_INDEX_CHECK)
1500  ;
1501 #else
1502  noexcept;
1503 #endif
1504  template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms)
1505 #if(CXSC_INDEX_CHECK)
1506  ;
1507 #else
1508  noexcept;
1509 #endif
1510  template <class MS,class M> friend MS &_msmsectassign(MS &ms,const M &m1)
1511 #if(CXSC_INDEX_CHECK)
1512  ;
1513 #else
1514  noexcept;
1515 #endif
1516  template <class MS1,class MS2> friend MS1 &_msmssectassign(MS1 &ms1,const MS2 &ms2)
1517 #if(CXSC_INDEX_CHECK)
1518  ;
1519 #else
1520  noexcept;
1521 #endif
1522  template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2)
1523 #if(CXSC_INDEX_CHECK)
1524  ;
1525 #else
1526  noexcept;
1527 #endif
1528  //--------- matrix-vector --------------
1529  template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v)
1530 #if(CXSC_INDEX_CHECK)
1531  ;
1532 #else
1533  noexcept;
1534 #endif
1535  template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms)
1536 #if(CXSC_INDEX_CHECK)
1537  ;
1538 #else
1539  noexcept;
1540 #endif
1541  template <class V,class MS,class S> friend V &_vmslimultassign(V &v,const MS &ms)
1542 #if(CXSC_INDEX_CHECK)
1543  ;
1544 #else
1545  noexcept;
1546 #endif
1547  //--------- matrix-scalar --------------
1548  template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) noexcept;
1549  template <class MS,class S> friend MS &_mssmultassign(MS &ms,const S &c) noexcept;
1550  template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) noexcept;
1551  template <class MS,class S> friend MS &_mssdivassign(MS &ms,const S &c) noexcept;
1552 
1553  template <class MS> friend void *_msvoid(const MS &ms) noexcept;
1554  template <class MS> friend bool _msnot(const MS &ms) noexcept;
1555  template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) noexcept;
1556  template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) noexcept;
1557  template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) noexcept;
1558  template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) noexcept;
1559  template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) noexcept;
1560  template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) noexcept;
1561  template <class MS1,class MS2> friend bool _msmseq(const MS1 &ms1,const MS2 &ms2) noexcept;
1562  template <class MS1,class MS2> friend bool _msmsneq(const MS1 &ms1,const MS2 &ms2) noexcept;
1563  template <class MS1,class MS2> friend bool _msmsless(const MS1 &ms1,const MS2 &ms2) noexcept;
1564  template <class MS1,class MS2> friend bool _msmsleq(const MS1 &ms1,const MS2 &ms2) noexcept;
1565  template <class MS> friend std::ostream &_msout(std::ostream &s,const MS &r) noexcept;
1566  template <class MS> friend std::istream &_msin(std::istream &s,MS &r) noexcept;
1567 
1568 
1569 #endif
1570 
1571  //--------------- Konstruktoren ----------------------------------------
1572 
1574  explicit INLINE l_imatrix_slice(l_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) { }
1576  explicit INLINE l_imatrix_slice(l_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) { }
1577  public:
1579  INLINE l_imatrix_slice(const l_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) { }
1580  public:
1581 
1582  //---------------- Standardfunktionen -----------------------------------
1583 
1584  friend INLINE l_ivector::l_ivector(const l_imatrix_slice &sl)
1585 #if(CXSC_INDEX_CHECK)
1586 ;
1587 #else
1588  noexcept;
1589 #endif
1590  friend INLINE l_imatrix::l_imatrix(const l_imatrix_slice &) noexcept;
1592  INLINE l_imatrix_slice &operator =(const l_imatrix &m)
1593 #if(CXSC_INDEX_CHECK)
1594 ;
1595 #else
1596  noexcept;
1597 #endif
1599  INLINE l_imatrix_slice &operator =(const l_imatrix_slice &ms)
1600 #if(CXSC_INDEX_CHECK)
1601 ;
1602 #else
1603  noexcept;
1604 #endif
1606  INLINE l_imatrix_slice &operator =(const l_interval &r) noexcept;
1608  INLINE l_imatrix_slice &operator =(const l_ivector &v)
1609 #if(CXSC_INDEX_CHECK)
1610 ;
1611 #else
1612  noexcept;
1613 #endif
1615  INLINE l_imatrix_slice &operator =(const l_ivector_slice &v)
1616 #if(CXSC_INDEX_CHECK)
1617 ;
1618 #else
1619  noexcept;
1620 #endif
1622  INLINE l_imatrix_slice &operator =(const l_imatrix_subv &v)
1623 #if(CXSC_INDEX_CHECK)
1624 ;
1625 #else
1626  noexcept;
1627 #endif
1628  // real
1630  INLINE l_imatrix_slice &operator =(const rmatrix &m)
1631 #if(CXSC_INDEX_CHECK)
1632 ;
1633 #else
1634  noexcept;
1635 #endif
1637  INLINE l_imatrix_slice &operator =(const rmatrix_slice &ms)
1638 #if(CXSC_INDEX_CHECK)
1639 ;
1640 #else
1641  noexcept;
1642 #endif
1644  INLINE l_imatrix_slice &operator =(const real &r) noexcept;
1646  INLINE l_imatrix_slice &operator =(const rvector &v)
1647 #if(CXSC_INDEX_CHECK)
1648 ;
1649 #else
1650  noexcept;
1651 #endif
1653  INLINE l_imatrix_slice &operator =(const rvector_slice &v)
1654 #if(CXSC_INDEX_CHECK)
1655 ;
1656 #else
1657  noexcept;
1658 #endif
1660  INLINE l_imatrix_slice &operator =(const rmatrix_subv &v)
1661 #if(CXSC_INDEX_CHECK)
1662 ;
1663 #else
1664  noexcept;
1665 #endif
1666 
1667  // interval
1669  INLINE l_imatrix_slice &operator =(const imatrix &m)
1670 #if(CXSC_INDEX_CHECK)
1671 ;
1672 #else
1673  noexcept;
1674 #endif
1676  INLINE l_imatrix_slice &operator =(const imatrix_slice &ms)
1677 #if(CXSC_INDEX_CHECK)
1678 ;
1679 #else
1680  noexcept;
1681 #endif
1683  INLINE l_imatrix_slice &operator =(const interval &r) noexcept;
1685  INLINE l_imatrix_slice &operator =(const ivector &v)
1686 #if(CXSC_INDEX_CHECK)
1687 ;
1688 #else
1689  noexcept;
1690 #endif
1692  INLINE l_imatrix_slice &operator =(const ivector_slice &v)
1693 #if(CXSC_INDEX_CHECK)
1694 ;
1695 #else
1696  noexcept;
1697 #endif
1699  INLINE l_imatrix_slice &operator =(const imatrix_subv &v)
1700 #if(CXSC_INDEX_CHECK)
1701 ;
1702 #else
1703  noexcept;
1704 #endif
1705 
1706  // l_real
1708  INLINE l_imatrix_slice &operator =(const l_rmatrix &m)
1709 #if(CXSC_INDEX_CHECK)
1710 ;
1711 #else
1712  noexcept;
1713 #endif
1715  INLINE l_imatrix_slice &operator =(const l_rmatrix_slice &ms)
1716 #if(CXSC_INDEX_CHECK)
1717 ;
1718 #else
1719  noexcept;
1720 #endif
1722  INLINE l_imatrix_slice &operator =(const l_real &r) noexcept;
1724  INLINE l_imatrix_slice &operator =(const l_rvector &v)
1725 #if(CXSC_INDEX_CHECK)
1726 ;
1727 #else
1728  noexcept;
1729 #endif
1731  INLINE l_imatrix_slice &operator =(const l_rvector_slice &v)
1732 #if(CXSC_INDEX_CHECK)
1733 ;
1734 #else
1735  noexcept;
1736 #endif
1738  INLINE l_imatrix_slice &operator =(const l_rmatrix_subv &v)
1739 #if(CXSC_INDEX_CHECK)
1740 ;
1741 #else
1742  noexcept;
1743 #endif
1744 
1746  INLINE l_imatrix_subv operator [](const int &i)
1747 #if(CXSC_INDEX_CHECK)
1748 ;
1749 #else
1750  noexcept;
1751 #endif
1753  INLINE l_imatrix_subv operator [](const cxscmatrix_column &i)
1754 #if(CXSC_INDEX_CHECK)
1755 ;
1756 #else
1757  noexcept;
1758 #endif
1760  INLINE l_imatrix_slice &operator ()() noexcept { return *this; }
1762  INLINE l_imatrix_slice operator ()(const int &m, const int &n)
1763 #if(CXSC_INDEX_CHECK)
1764 ;
1765 #else
1766  noexcept;
1767 #endif
1769  INLINE l_imatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
1770 #if(CXSC_INDEX_CHECK)
1771 ;
1772 #else
1773  noexcept;
1774 #endif
1775  INLINE operator void*() noexcept;
1776 
1778  INLINE l_imatrix_slice &operator +=(const l_interval &c) noexcept;
1780  INLINE l_imatrix_slice &operator -=(const l_interval &c) noexcept;
1782  INLINE l_imatrix_slice &operator *=(const l_interval &c) noexcept;
1784  INLINE l_imatrix_slice &operator /=(const l_interval &c) noexcept;
1786  INLINE l_imatrix_slice &operator +=(const l_imatrix &m1)
1787 #if(CXSC_INDEX_CHECK)
1788 ;
1789 #else
1790  noexcept;
1791 #endif
1793  INLINE l_imatrix_slice &operator +=(const l_imatrix_slice &ms2)
1794 #if(CXSC_INDEX_CHECK)
1795 ;
1796 #else
1797  noexcept;
1798 #endif
1800  INLINE l_imatrix_slice &operator -=(const l_imatrix &m1)
1801 #if(CXSC_INDEX_CHECK)
1802 ;
1803 #else
1804  noexcept;
1805 #endif
1807  INLINE l_imatrix_slice &operator -=(const l_imatrix_slice &ms2)
1808 #if(CXSC_INDEX_CHECK)
1809 ;
1810 #else
1811  noexcept;
1812 #endif
1814  INLINE l_imatrix_slice &operator |=(const l_imatrix &m1)
1815 #if(CXSC_INDEX_CHECK)
1816 ;
1817 #else
1818  noexcept;
1819 #endif
1821  INLINE l_imatrix_slice &operator |=(const l_imatrix_slice &ms2)
1822 #if(CXSC_INDEX_CHECK)
1823 ;
1824 #else
1825  noexcept;
1826 #endif
1828  INLINE l_imatrix_slice &operator &=(const l_imatrix &m1)
1829 #if(CXSC_INDEX_CHECK)
1830 ;
1831 #else
1832  noexcept;
1833 #endif
1835  INLINE l_imatrix_slice &operator &=(const l_imatrix_slice &ms2)
1836 #if(CXSC_INDEX_CHECK)
1837 ;
1838 #else
1839  noexcept;
1840 #endif
1842  INLINE l_imatrix_slice &operator *=(const l_imatrix &m)
1843 #if(CXSC_INDEX_CHECK)
1844 ;
1845 #else
1846  noexcept;
1847 #endif
1849  INLINE l_imatrix_slice &operator *=(const l_imatrix_slice &ms2)
1850 #if(CXSC_INDEX_CHECK)
1851 ;
1852 #else
1853  noexcept;
1854 #endif
1855 
1857  INLINE l_imatrix_slice &operator +=(const real &c) noexcept;
1859  INLINE l_imatrix_slice &operator -=(const real &c) noexcept;
1861  INLINE l_imatrix_slice &operator *=(const real &c) noexcept;
1863  INLINE l_imatrix_slice &operator /=(const real &c) noexcept;
1865  INLINE l_imatrix_slice &operator +=(const rmatrix_slice &ms2)
1866 #if(CXSC_INDEX_CHECK)
1867 ;
1868 #else
1869  noexcept;
1870 #endif
1872  INLINE l_imatrix_slice &operator +=(const rmatrix &m1)
1873 #if(CXSC_INDEX_CHECK)
1874 ;
1875 #else
1876  noexcept;
1877 #endif
1879  INLINE l_imatrix_slice &operator -=(const rmatrix &m1)
1880 #if(CXSC_INDEX_CHECK)
1881 ;
1882 #else
1883  noexcept;
1884 #endif
1886  INLINE l_imatrix_slice &operator -=(const rmatrix_slice &ms2)
1887 #if(CXSC_INDEX_CHECK)
1888 ;
1889 #else
1890  noexcept;
1891 #endif
1893  INLINE l_imatrix_slice &operator |=(const rmatrix &m1)
1894 #if(CXSC_INDEX_CHECK)
1895 ;
1896 #else
1897  noexcept;
1898 #endif
1900  INLINE l_imatrix_slice &operator |=(const rmatrix_slice &ms2)
1901 #if(CXSC_INDEX_CHECK)
1902 ;
1903 #else
1904  noexcept;
1905 #endif
1907  INLINE l_imatrix_slice &operator &=(const rmatrix &m1)
1908 #if(CXSC_INDEX_CHECK)
1909 ;
1910 #else
1911  noexcept;
1912 #endif
1914  INLINE l_imatrix_slice &operator &=(const rmatrix_slice &ms2)
1915 #if(CXSC_INDEX_CHECK)
1916 ;
1917 #else
1918  noexcept;
1919 #endif
1921  INLINE l_imatrix_slice &operator *=(const rmatrix &m)
1922 #if(CXSC_INDEX_CHECK)
1923 ;
1924 #else
1925  noexcept;
1926 #endif
1928  INLINE l_imatrix_slice &operator *=(const rmatrix_slice &ms2)
1929 #if(CXSC_INDEX_CHECK)
1930 ;
1931 #else
1932  noexcept;
1933 #endif
1934 
1936  INLINE l_imatrix_slice &operator +=(const l_real &c) noexcept;
1938  INLINE l_imatrix_slice &operator -=(const l_real &c) noexcept;
1940  INLINE l_imatrix_slice &operator *=(const l_real &c) noexcept;
1942  INLINE l_imatrix_slice &operator /=(const l_real &c) noexcept;
1944  INLINE l_imatrix_slice &operator +=(const l_rmatrix_slice &ms2)
1945 #if(CXSC_INDEX_CHECK)
1946 ;
1947 #else
1948  noexcept;
1949 #endif
1951  INLINE l_imatrix_slice &operator +=(const l_rmatrix &m1)
1952 #if(CXSC_INDEX_CHECK)
1953 ;
1954 #else
1955  noexcept;
1956 #endif
1958  INLINE l_imatrix_slice &operator -=(const l_rmatrix &m1)
1959 #if(CXSC_INDEX_CHECK)
1960 ;
1961 #else
1962  noexcept;
1963 #endif
1965  INLINE l_imatrix_slice &operator -=(const l_rmatrix_slice &ms2)
1966 #if(CXSC_INDEX_CHECK)
1967 ;
1968 #else
1969  noexcept;
1970 #endif
1972  INLINE l_imatrix_slice &operator |=(const l_rmatrix &m1)
1973 #if(CXSC_INDEX_CHECK)
1974 ;
1975 #else
1976  noexcept;
1977 #endif
1979  INLINE l_imatrix_slice &operator |=(const l_rmatrix_slice &ms2)
1980 #if(CXSC_INDEX_CHECK)
1981 ;
1982 #else
1983  noexcept;
1984 #endif
1986  INLINE l_imatrix_slice &operator &=(const l_rmatrix &m1)
1987 #if(CXSC_INDEX_CHECK)
1988 ;
1989 #else
1990  noexcept;
1991 #endif
1993  INLINE l_imatrix_slice &operator &=(const l_rmatrix_slice &ms2)
1994 #if(CXSC_INDEX_CHECK)
1995 ;
1996 #else
1997  noexcept;
1998 #endif
2000  INLINE l_imatrix_slice &operator *=(const l_rmatrix &m)
2001 #if(CXSC_INDEX_CHECK)
2002 ;
2003 #else
2004  noexcept;
2005 #endif
2007  INLINE l_imatrix_slice &operator *=(const l_rmatrix_slice &ms2)
2008 #if(CXSC_INDEX_CHECK)
2009 ;
2010 #else
2011  noexcept;
2012 #endif
2013 
2015  INLINE l_imatrix_slice &operator +=(const interval &c) noexcept;
2017  INLINE l_imatrix_slice &operator -=(const interval &c) noexcept;
2019  INLINE l_imatrix_slice &operator *=(const interval &c) noexcept;
2021  INLINE l_imatrix_slice &operator /=(const interval &c) noexcept;
2023  INLINE l_imatrix_slice &operator +=(const imatrix_slice &ms2)
2024 #if(CXSC_INDEX_CHECK)
2025 ;
2026 #else
2027  noexcept;
2028 #endif
2030  INLINE l_imatrix_slice &operator +=(const imatrix &m1)
2031 #if(CXSC_INDEX_CHECK)
2032 ;
2033 #else
2034  noexcept;
2035 #endif
2037  INLINE l_imatrix_slice &operator -=(const imatrix &m1)
2038 #if(CXSC_INDEX_CHECK)
2039 ;
2040 #else
2041  noexcept;
2042 #endif
2044  INLINE l_imatrix_slice &operator -=(const imatrix_slice &ms2)
2045 #if(CXSC_INDEX_CHECK)
2046 ;
2047 #else
2048  noexcept;
2049 #endif
2051  INLINE l_imatrix_slice &operator |=(const imatrix &m1)
2052 #if(CXSC_INDEX_CHECK)
2053 ;
2054 #else
2055  noexcept;
2056 #endif
2058  INLINE l_imatrix_slice &operator |=(const imatrix_slice &ms2)
2059 #if(CXSC_INDEX_CHECK)
2060 ;
2061 #else
2062  noexcept;
2063 #endif
2065  INLINE l_imatrix_slice &operator &=(const imatrix &m1)
2066 #if(CXSC_INDEX_CHECK)
2067 ;
2068 #else
2069  noexcept;
2070 #endif
2072  INLINE l_imatrix_slice &operator &=(const imatrix_slice &ms2)
2073 #if(CXSC_INDEX_CHECK)
2074 ;
2075 #else
2076  noexcept;
2077 #endif
2079  INLINE l_imatrix_slice &operator *=(const imatrix &m)
2080 #if(CXSC_INDEX_CHECK)
2081 ;
2082 #else
2083  noexcept;
2084 #endif
2086  INLINE l_imatrix_slice &operator *=(const imatrix_slice &ms2)
2087 #if(CXSC_INDEX_CHECK)
2088 ;
2089 #else
2090  noexcept;
2091 #endif
2092 
2093 //#else
2094 //#endif
2095 };
2096 
2097 //================================================================
2098 //====================== Subvector Functions =====================
2099 
2100 //=======================Vector / Scalar =========================
2101 
2103  INLINE l_ivector operator /(const l_imatrix_subv &rv, const l_interval &s) noexcept;
2105  INLINE l_ivector operator *(const l_imatrix_subv &rv, const l_interval &s) noexcept;
2107  INLINE l_ivector operator *(const l_interval &s, const l_imatrix_subv &rv) noexcept;
2109  INLINE l_ivector abs(const l_imatrix_subv &mv) noexcept;
2111  INLINE l_rvector diam(const l_imatrix_subv &mv) noexcept;
2113  INLINE l_rvector mid(const l_imatrix_subv &mv) noexcept;
2115  INLINE l_rvector Inf(const l_imatrix_subv &mv) noexcept;
2117  INLINE l_rvector Sup(const l_imatrix_subv &mv) noexcept;
2119  INLINE l_imatrix_subv &SetInf(l_imatrix_subv &iv,const l_rvector &rv)
2120 #if(CXSC_INDEX_CHECK)
2121 ;
2122 #else
2123  noexcept;
2124 #endif
2126  INLINE l_imatrix_subv &SetSup(l_imatrix_subv &iv,const l_rvector &rv)
2127 #if(CXSC_INDEX_CHECK)
2128 ;
2129 #else
2130  noexcept;
2131 #endif
2133  INLINE l_imatrix_subv &UncheckedSetInf(l_imatrix_subv &iv,const l_rvector &rv)
2134 #if(CXSC_INDEX_CHECK)
2135 ;
2136 #else
2137  noexcept;
2138 #endif
2140  INLINE l_imatrix_subv &UncheckedSetSup(l_imatrix_subv &iv,const l_rvector &rv)
2141 #if(CXSC_INDEX_CHECK)
2142 ;
2143 #else
2144  noexcept;
2145 #endif
2146 
2148  INLINE l_imatrix_subv &SetSup(l_imatrix_subv &iv,const l_real &r) noexcept;
2150  INLINE l_imatrix_subv &SetInf(l_imatrix_subv &iv,const l_real &r) noexcept;
2152  INLINE l_imatrix_subv &UncheckedSetSup(l_imatrix_subv &iv,const l_real &r) noexcept;
2154  INLINE l_imatrix_subv &SetUncheckedInf(l_imatrix_subv &iv,const l_real &r) noexcept;
2155 
2156 //======================== Vector / Vector ========================
2157 
2158 
2160  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_imatrix_subv &rv2)
2161 #if(CXSC_INDEX_CHECK)
2162 ;
2163 #else
2164  noexcept;
2165 #endif
2167  INLINE void accumulate(idotprecision &dp, const l_ivector & rv1, const l_imatrix_subv &rv2)
2168 #if(CXSC_INDEX_CHECK)
2169 ;
2170 #else
2171  noexcept;
2172 #endif
2174  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_ivector &rv2)
2175 #if(CXSC_INDEX_CHECK)
2176 ;
2177 #else
2178  noexcept;
2179 #endif
2181  INLINE void accumulate(idotprecision &dp, const l_ivector_slice & sl1, const l_imatrix_subv &rv2)
2182 #if(CXSC_INDEX_CHECK)
2183 ;
2184 #else
2185  noexcept;
2186 #endif
2188  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_ivector_slice &sl2)
2189 #if(CXSC_INDEX_CHECK)
2190 ;
2191 #else
2192  noexcept;
2193 #endif
2194 
2196  INLINE l_interval operator *(const l_imatrix_subv & rv1, const l_imatrix_subv &rv2)
2197 #if(CXSC_INDEX_CHECK)
2198 ;
2199 #else
2200  noexcept;
2201 #endif
2203  INLINE l_interval operator *(const l_ivector & rv1, const l_imatrix_subv &rv2)
2204 #if(CXSC_INDEX_CHECK)
2205 ;
2206 #else
2207  noexcept;
2208 #endif
2210  INLINE l_interval operator *(const l_imatrix_subv &rv1,const l_ivector &rv2)
2211 #if(CXSC_INDEX_CHECK)
2212 ;
2213 #else
2214  noexcept;
2215 #endif
2217  INLINE l_interval operator *(const l_ivector_slice &sl,const l_imatrix_subv &sv)
2218 #if(CXSC_INDEX_CHECK)
2219 ;
2220 #else
2221  noexcept;
2222 #endif
2224  INLINE l_interval operator *(const l_imatrix_subv &mv,const l_ivector_slice &vs)
2225 #if(CXSC_INDEX_CHECK)
2226 ;
2227 #else
2228  noexcept;
2229 #endif
2230 
2232  INLINE l_ivector operator +(const l_imatrix_subv & rv1, const l_imatrix_subv &rv2)
2233 #if(CXSC_INDEX_CHECK)
2234 ;
2235 #else
2236  noexcept;
2237 #endif
2239  INLINE l_ivector operator +(const l_imatrix_subv &rv1,const l_ivector &rv2)
2240 #if(CXSC_INDEX_CHECK)
2241 ;
2242 #else
2243  noexcept;
2244 #endif
2246  INLINE l_ivector operator +(const l_ivector & rv1, const l_imatrix_subv &rv2)
2247 #if(CXSC_INDEX_CHECK)
2248 ;
2249 #else
2250  noexcept;
2251 #endif
2253  INLINE l_ivector operator +(const l_ivector_slice &sl,const l_imatrix_subv &mv)
2254 #if(CXSC_INDEX_CHECK)
2255 ;
2256 #else
2257  noexcept;
2258 #endif
2260  INLINE l_ivector operator +(const l_imatrix_subv &mv,const l_ivector_slice &sl)
2261 #if(CXSC_INDEX_CHECK)
2262 ;
2263 #else
2264  noexcept;
2265 #endif
2266 
2268  INLINE l_ivector operator -(const l_imatrix_subv & rv1, const l_imatrix_subv &rv2)
2269 #if(CXSC_INDEX_CHECK)
2270 ;
2271 #else
2272  noexcept;
2273 #endif
2275  INLINE l_ivector operator -(const l_ivector & rv1, const l_imatrix_subv &rv2)
2276 #if(CXSC_INDEX_CHECK)
2277 ;
2278 #else
2279  noexcept;
2280 #endif
2282  INLINE l_ivector operator -(const l_imatrix_subv &rv1,const l_ivector &rv2)
2283 #if(CXSC_INDEX_CHECK)
2284 ;
2285 #else
2286  noexcept;
2287 #endif
2289  INLINE l_ivector operator -(const l_ivector_slice &sl,const l_imatrix_subv &mv)
2290 #if(CXSC_INDEX_CHECK)
2291 ;
2292 #else
2293  noexcept;
2294 #endif
2296  INLINE l_ivector operator -(const l_imatrix_subv &mv,const l_ivector_slice &sl)
2297 #if(CXSC_INDEX_CHECK)
2298 ;
2299 #else
2300  noexcept;
2301 #endif
2302 
2303 // real
2304 
2306  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const rmatrix_subv &rv2)
2307 #if(CXSC_INDEX_CHECK)
2308 ;
2309 #else
2310  noexcept;
2311 #endif
2313  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const rvector_slice &sl2)
2314 #if(CXSC_INDEX_CHECK)
2315 ;
2316 #else
2317  noexcept;
2318 #endif
2320  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const rvector &rv2)
2321 #if(CXSC_INDEX_CHECK)
2322 ;
2323 #else
2324  noexcept;
2325 #endif
2327  INLINE void accumulate(idotprecision &dp, const rvector & rv1, const l_imatrix_subv &rv2)
2328 #if(CXSC_INDEX_CHECK)
2329 ;
2330 #else
2331  noexcept;
2332 #endif
2334  INLINE void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const l_imatrix_subv &rv2)
2335 #if(CXSC_INDEX_CHECK)
2336 ;
2337 #else
2338  noexcept;
2339 #endif
2341  INLINE void accumulate(idotprecision &dp, const rvector_slice & sl1, const l_imatrix_subv &rv2)
2342 #if(CXSC_INDEX_CHECK)
2343 ;
2344 #else
2345  noexcept;
2346 #endif
2347 
2348 // l_real
2349 
2351  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_rmatrix_subv &rv2)
2352 #if(CXSC_INDEX_CHECK)
2353 ;
2354 #else
2355  noexcept;
2356 #endif
2358  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_rvector_slice &sl2)
2359 #if(CXSC_INDEX_CHECK)
2360 ;
2361 #else
2362  noexcept;
2363 #endif
2365  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const l_rvector &rv2)
2366 #if(CXSC_INDEX_CHECK)
2367 ;
2368 #else
2369  noexcept;
2370 #endif
2372  INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const l_imatrix_subv &rv2)
2373 #if(CXSC_INDEX_CHECK)
2374 ;
2375 #else
2376  noexcept;
2377 #endif
2379  INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const l_imatrix_subv &rv2)
2380 #if(CXSC_INDEX_CHECK)
2381 ;
2382 #else
2383  noexcept;
2384 #endif
2386  INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl1, const l_imatrix_subv &rv2)
2387 #if(CXSC_INDEX_CHECK)
2388 ;
2389 #else
2390  noexcept;
2391 #endif
2392 
2393 // interval
2394 
2396  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const imatrix_subv &rv2)
2397 #if(CXSC_INDEX_CHECK)
2398 ;
2399 #else
2400  noexcept;
2401 #endif
2403  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const ivector_slice &sl2)
2404 #if(CXSC_INDEX_CHECK)
2405 ;
2406 #else
2407  noexcept;
2408 #endif
2410  INLINE void accumulate(idotprecision &dp, const l_imatrix_subv & rv1, const ivector &rv2)
2411 #if(CXSC_INDEX_CHECK)
2412 ;
2413 #else
2414  noexcept;
2415 #endif
2417  INLINE void accumulate(idotprecision &dp, const ivector & rv1, const l_imatrix_subv &rv2)
2418 #if(CXSC_INDEX_CHECK)
2419 ;
2420 #else
2421  noexcept;
2422 #endif
2424  INLINE void accumulate(idotprecision &dp, const imatrix_subv & rv1, const l_imatrix_subv &rv2)
2425 #if(CXSC_INDEX_CHECK)
2426 ;
2427 #else
2428  noexcept;
2429 #endif
2431  INLINE void accumulate(idotprecision &dp, const ivector_slice & sl1, const l_imatrix_subv &rv2)
2432 #if(CXSC_INDEX_CHECK)
2433 ;
2434 #else
2435  noexcept;
2436 #endif
2437 
2438 
2439 //====================================================================
2440 //===================== Matrix Functions =============================
2441 
2443  INLINE l_imatrix _imatrix(const l_imatrix &rm) noexcept;
2445  INLINE l_imatrix _imatrix(const l_ivector &v) noexcept;
2447  INLINE l_imatrix _imatrix(const l_ivector_slice &v) noexcept;
2449  INLINE l_imatrix _imatrix(const l_interval &r) noexcept;
2450 
2452  INLINE int Lb(const l_imatrix &rm, const int &i)
2453 #if(CXSC_INDEX_CHECK)
2454 ;
2455 #else
2456  noexcept;
2457 #endif
2459  INLINE int Ub(const l_imatrix &rm, const int &i)
2460 #if(CXSC_INDEX_CHECK)
2461 ;
2462 #else
2463  noexcept;
2464 #endif
2466  INLINE int Lb(const l_imatrix_slice &rm, const int &i)
2467 #if(CXSC_INDEX_CHECK)
2468 ;
2469 #else
2470  noexcept;
2471 #endif
2473  INLINE int Ub(const l_imatrix_slice &rm, const int &i)
2474 #if(CXSC_INDEX_CHECK)
2475 ;
2476 #else
2477  noexcept;
2478 #endif
2480  INLINE l_imatrix &SetLb(l_imatrix &m, const int &i,const int &j)
2481 #if(CXSC_INDEX_CHECK)
2482 ;
2483 #else
2484  noexcept;
2485 #endif
2487  INLINE l_imatrix &SetUb(l_imatrix &m, const int &i,const int &j)
2488 #if(CXSC_INDEX_CHECK)
2489 ;
2490 #else
2491  noexcept;
2492 #endif
2494  INLINE void Resize(l_imatrix &A) noexcept;
2496  INLINE void Resize(l_imatrix &A,const int &m, const int &n)
2497 #if(CXSC_INDEX_CHECK)
2498 ;
2499 #else
2500  noexcept;
2501 #endif
2503  INLINE void Resize(l_imatrix &A,const int &m1, const int &m2,const int &n1,const int &n2)
2504 #if(CXSC_INDEX_CHECK)
2505 ;
2506 #else
2507  noexcept;
2508 #endif
2509 
2511  INLINE l_imatrix abs(const l_imatrix &m) noexcept;
2513  INLINE l_imatrix abs(const l_imatrix_slice &ms) noexcept;
2515  INLINE l_rmatrix diam(const l_imatrix &m) noexcept;
2517  INLINE l_rmatrix diam(const l_imatrix_slice &m) noexcept;
2519  INLINE l_rmatrix mid(const l_imatrix &m) noexcept;
2521  INLINE l_rmatrix mid(const l_imatrix_slice &m) noexcept;
2523  INLINE l_rmatrix Inf(const l_imatrix &m) noexcept;
2525  INLINE l_rmatrix Sup(const l_imatrix &m) noexcept;
2527  INLINE l_rmatrix Inf(const l_imatrix_slice &m) noexcept;
2529  INLINE l_rmatrix Sup(const l_imatrix_slice &m) noexcept;
2531  INLINE l_imatrix &SetInf(l_imatrix &cm,const l_rmatrix &rm)
2532 #if(CXSC_INDEX_CHECK)
2533 ;
2534 #else
2535  noexcept;
2536 #endif
2538  INLINE l_imatrix_slice &SetInf(l_imatrix_slice &cm,const l_rmatrix &rm)
2539 #if(CXSC_INDEX_CHECK)
2540 ;
2541 #else
2542  noexcept;
2543 #endif
2545  INLINE l_imatrix &SetInf(l_imatrix &cm,const l_rmatrix_slice &rm)
2546 #if(CXSC_INDEX_CHECK)
2547 ;
2548 #else
2549  noexcept;
2550 #endif
2552  INLINE l_imatrix_slice &SetInf(l_imatrix_slice &cm,const l_rmatrix_slice &rm)
2553 #if(CXSC_INDEX_CHECK)
2554 ;
2555 #else
2556  noexcept;
2557 #endif
2559  INLINE l_imatrix &SetSup(l_imatrix &cm,const l_rmatrix &rm)
2560 #if(CXSC_INDEX_CHECK)
2561 ;
2562 #else
2563  noexcept;
2564 #endif
2566  INLINE l_imatrix_slice &SetSup(l_imatrix_slice &cm,const l_rmatrix &rm)
2567 #if(CXSC_INDEX_CHECK)
2568 ;
2569 #else
2570  noexcept;
2571 #endif
2573  INLINE l_imatrix &SetSup(l_imatrix &cm,const l_rmatrix_slice &rm)
2574 #if(CXSC_INDEX_CHECK)
2575 ;
2576 #else
2577  noexcept;
2578 #endif
2580  INLINE l_imatrix_slice &SetSup(l_imatrix_slice &cm,const l_rmatrix_slice &rm)
2581 #if(CXSC_INDEX_CHECK)
2582 ;
2583 #else
2584  noexcept;
2585 #endif
2587  INLINE l_imatrix &UncheckedSetInf(l_imatrix &cm,const l_rmatrix &rm)
2588 #if(CXSC_INDEX_CHECK)
2589 ;
2590 #else
2591  noexcept;
2592 #endif
2594  INLINE l_imatrix_slice &UncheckedSetInf(l_imatrix_slice &cm,const l_rmatrix &rm)
2595 #if(CXSC_INDEX_CHECK)
2596 ;
2597 #else
2598  noexcept;
2599 #endif
2601  INLINE l_imatrix &UncheckedSetInf(l_imatrix &cm,const l_rmatrix_slice &rm)
2602 #if(CXSC_INDEX_CHECK)
2603 ;
2604 #else
2605  noexcept;
2606 #endif
2608  INLINE l_imatrix_slice &UncheckedSetInf(l_imatrix_slice &cm,const l_rmatrix_slice &rm)
2609 #if(CXSC_INDEX_CHECK)
2610 ;
2611 #else
2612  noexcept;
2613 #endif
2615  INLINE l_imatrix &UncheckedSetSup(l_imatrix &cm,const l_rmatrix &rm)
2616 #if(CXSC_INDEX_CHECK)
2617 ;
2618 #else
2619  noexcept;
2620 #endif
2622  INLINE l_imatrix_slice &UncheckedSetSup(l_imatrix_slice &cm,const l_rmatrix &rm)
2623 #if(CXSC_INDEX_CHECK)
2624 ;
2625 #else
2626  noexcept;
2627 #endif
2629  INLINE l_imatrix &UncheckedSetSup(l_imatrix &cm,const l_rmatrix_slice &rm)
2630 #if(CXSC_INDEX_CHECK)
2631 ;
2632 #else
2633  noexcept;
2634 #endif
2636  INLINE l_imatrix_slice &UncheckedSetSup(l_imatrix_slice &cm,const l_rmatrix_slice &rm)
2637 #if(CXSC_INDEX_CHECK)
2638 ;
2639 #else
2640  noexcept;
2641 #endif
2642 
2643 //===================== Matrix / Scalar ===============================
2644 
2646  INLINE l_imatrix operator *(const l_interval &c, const l_imatrix &m) noexcept;
2648  INLINE l_imatrix operator *(const l_interval &c, const l_imatrix_slice &ms) noexcept;
2650  INLINE l_imatrix operator *(const l_imatrix &m,const l_interval &c) noexcept;
2652  INLINE l_imatrix operator *(const l_imatrix_slice &ms,const l_interval &c) noexcept;
2654  INLINE l_imatrix &operator *=(l_imatrix &m,const l_interval &c) noexcept;
2656  INLINE l_imatrix operator /(const l_imatrix &m,const l_interval &c) noexcept;
2658  INLINE l_imatrix operator /(const l_imatrix_slice &ms, const l_interval &c) noexcept;
2660  INLINE l_imatrix &operator /=(l_imatrix &m,const l_interval &c) noexcept;
2661 
2662 //------------ real - l_imatrix -----------------------------------------------
2663 
2665  INLINE l_imatrix operator *(const real &c, const l_imatrix &m) noexcept;
2667  INLINE l_imatrix operator *(const real &c, const l_imatrix_slice &ms) noexcept;
2669  INLINE l_imatrix operator *(const l_imatrix &m,const real &c) noexcept;
2671  INLINE l_imatrix operator *(const l_imatrix_slice &ms,const real &c) noexcept;
2673  INLINE l_imatrix &operator *=(l_imatrix &m,const real &c) noexcept;
2675  INLINE l_imatrix operator /(const l_imatrix &m,const real &c) noexcept;
2677  INLINE l_imatrix operator /(const l_imatrix_slice &ms, const real &c) noexcept;
2679  INLINE l_imatrix &operator /=(l_imatrix &m,const real &c) noexcept;
2680 //----------------- rmatrix - l_interval ----------------
2681 
2683  INLINE l_imatrix operator *(const l_interval &c, const rmatrix &m) noexcept;
2685  INLINE l_imatrix operator *(const l_interval &c, const rmatrix_slice &ms) noexcept;
2687  INLINE l_imatrix operator *(const rmatrix &m,const l_interval &c) noexcept;
2689  INLINE l_imatrix operator *(const rmatrix_slice &ms,const l_interval &c) noexcept;
2691  INLINE l_imatrix operator /(const rmatrix &m,const l_interval &c) noexcept;
2693  INLINE l_imatrix operator /(const rmatrix_slice &ms, const l_interval &c) noexcept;
2694 
2695 //------------ l_real - l_imatrix -----------------------------------------------
2696 
2698  INLINE l_imatrix operator *(const l_real &c, const l_imatrix &m) noexcept;
2700  INLINE l_imatrix operator *(const l_real &c, const l_imatrix_slice &ms) noexcept;
2702  INLINE l_imatrix operator *(const l_imatrix &m,const l_real &c) noexcept;
2704  INLINE l_imatrix operator *(const l_imatrix_slice &ms,const l_real &c) noexcept;
2706  INLINE l_imatrix &operator *=(l_imatrix &m,const l_real &c) noexcept;
2708  INLINE l_imatrix operator /(const l_imatrix &m,const l_real &c) noexcept;
2710  INLINE l_imatrix operator /(const l_imatrix_slice &ms, const l_real &c) noexcept;
2712  INLINE l_imatrix &operator /=(l_imatrix &m,const l_real &c) noexcept;
2713 //----------------- l_rmatrix - l_interval ----------------
2714 
2716  INLINE l_imatrix operator *(const l_interval &c, const l_rmatrix &m) noexcept;
2718  INLINE l_imatrix operator *(const l_interval &c, const l_rmatrix_slice &ms) noexcept;
2720  INLINE l_imatrix operator *(const l_rmatrix &m,const l_interval &c) noexcept;
2722  INLINE l_imatrix operator *(const l_rmatrix_slice &ms,const l_interval &c) noexcept;
2724  INLINE l_imatrix operator /(const l_rmatrix &m,const l_interval &c) noexcept;
2726  INLINE l_imatrix operator /(const l_rmatrix_slice &ms, const l_interval &c) noexcept;
2727 
2728 //------------ interval - l_imatrix -----------------------------------------------
2729 
2731  INLINE l_imatrix operator *(const interval &c, const l_imatrix &m) noexcept;
2733  INLINE l_imatrix operator *(const interval &c, const l_imatrix_slice &ms) noexcept;
2735  INLINE l_imatrix operator *(const l_imatrix &m,const interval &c) noexcept;
2737  INLINE l_imatrix operator *(const l_imatrix_slice &ms,const interval &c) noexcept;
2739  INLINE l_imatrix &operator *=(l_imatrix &m,const interval &c) noexcept;
2741  INLINE l_imatrix operator /(const l_imatrix &m,const interval &c) noexcept;
2743  INLINE l_imatrix operator /(const l_imatrix_slice &ms, const interval &c) noexcept;
2745  INLINE l_imatrix &operator /=(l_imatrix &m,const interval &c) noexcept;
2746 //----------------- imatrix - l_interval ----------------
2747 
2749  INLINE l_imatrix operator *(const l_interval &c, const imatrix &m) noexcept;
2751  INLINE l_imatrix operator *(const l_interval &c, const imatrix_slice &ms) noexcept;
2753  INLINE l_imatrix operator *(const imatrix &m,const l_interval &c) noexcept;
2755  INLINE l_imatrix operator *(const imatrix_slice &ms,const l_interval &c) noexcept;
2757  INLINE l_imatrix operator /(const imatrix &m,const l_interval &c) noexcept;
2759  INLINE l_imatrix operator /(const imatrix_slice &ms, const l_interval &c) noexcept;
2760 
2761 
2762 //============================ Matrix / Vector ===================================
2763 
2764 
2766  INLINE l_ivector operator *(const l_imatrix &m,const l_ivector &v)
2767 #if(CXSC_INDEX_CHECK)
2768 ;
2769 #else
2770  noexcept;
2771 #endif
2773  INLINE l_ivector operator *(const l_imatrix_slice &ms,const l_ivector &v)
2774 #if(CXSC_INDEX_CHECK)
2775 ;
2776 #else
2777  noexcept;
2778 #endif
2780  INLINE l_ivector operator *(const l_ivector &v,const l_imatrix &m)
2781 #if(CXSC_INDEX_CHECK)
2782 ;
2783 #else
2784  noexcept;
2785 #endif
2787  INLINE l_ivector operator *(const l_ivector &v,const l_imatrix_slice &ms)
2788 #if(CXSC_INDEX_CHECK)
2789 ;
2790 #else
2791  noexcept;
2792 #endif
2794  INLINE l_ivector &operator *=(l_ivector &v,const l_imatrix &m)
2795 #if(CXSC_INDEX_CHECK)
2796 ;
2797 #else
2798  noexcept;
2799 #endif
2801  INLINE l_ivector &operator *=(l_ivector &v,const l_imatrix_slice &ms)
2802 #if(CXSC_INDEX_CHECK)
2803 ;
2804 #else
2805  noexcept;
2806 #endif
2807 
2809  INLINE l_ivector operator *(const l_ivector_slice &v,const l_imatrix &m)
2810 #if(CXSC_INDEX_CHECK)
2811 ;
2812 #else
2813  noexcept;
2814 #endif
2816  INLINE l_ivector operator *(const l_ivector_slice &v,const l_imatrix_slice &m)
2817 #if(CXSC_INDEX_CHECK)
2818 ;
2819 #else
2820  noexcept;
2821 #endif
2822 
2823 //----------------- real -------------------------------------
2824 
2826  INLINE l_ivector operator *(const rvector &v,const l_imatrix &m)
2827 #if(CXSC_INDEX_CHECK)
2828 ;
2829 #else
2830  noexcept;
2831 #endif
2833  INLINE l_ivector operator *(const rvector &v,const l_imatrix_slice &ms)
2834 #if(CXSC_INDEX_CHECK)
2835 ;
2836 #else
2837  noexcept;
2838 #endif
2840  INLINE l_ivector operator *(const rvector_slice &v,const l_imatrix &m)
2841 #if(CXSC_INDEX_CHECK)
2842 ;
2843 #else
2844  noexcept;
2845 #endif
2846 
2848  INLINE l_ivector operator *(const l_imatrix &m,const rvector &v)
2849 #if(CXSC_INDEX_CHECK)
2850 ;
2851 #else
2852  noexcept;
2853 #endif
2855  INLINE l_ivector operator *(const l_imatrix_slice &ms,const rvector &v)
2856 #if(CXSC_INDEX_CHECK)
2857 ;
2858 #else
2859  noexcept;
2860 #endif
2861 
2862 //----------------- l_real -------------------------------------
2863 
2865  INLINE l_ivector operator *(const l_rvector &v,const l_imatrix &m)
2866 #if(CXSC_INDEX_CHECK)
2867 ;
2868 #else
2869  noexcept;
2870 #endif
2872  INLINE l_ivector operator *(const l_rvector &v,const l_imatrix_slice &ms)
2873 #if(CXSC_INDEX_CHECK)
2874 ;
2875 #else
2876  noexcept;
2877 #endif
2879  INLINE l_ivector operator *(const l_rvector_slice &v,const l_imatrix &m)
2880 #if(CXSC_INDEX_CHECK)
2881 ;
2882 #else
2883  noexcept;
2884 #endif
2885 
2887  INLINE l_ivector operator *(const l_imatrix &m,const l_rvector &v)
2888 #if(CXSC_INDEX_CHECK)
2889 ;
2890 #else
2891  noexcept;
2892 #endif
2894  INLINE l_ivector operator *(const l_imatrix_slice &ms,const l_rvector &v)
2895 #if(CXSC_INDEX_CHECK)
2896 ;
2897 #else
2898  noexcept;
2899 #endif
2900 
2901 //----------------- interval -------------------------------------
2902 
2904  INLINE l_ivector operator *(const ivector &v,const l_imatrix &m)
2905 #if(CXSC_INDEX_CHECK)
2906 ;
2907 #else
2908  noexcept;
2909 #endif
2911  INLINE l_ivector operator *(const ivector &v,const l_imatrix_slice &ms)
2912 #if(CXSC_INDEX_CHECK)
2913 ;
2914 #else
2915  noexcept;
2916 #endif
2918  INLINE l_ivector operator *(const ivector_slice &v,const l_imatrix &m)
2919 #if(CXSC_INDEX_CHECK)
2920 ;
2921 #else
2922  noexcept;
2923 #endif
2924 
2926  INLINE l_ivector operator *(const l_imatrix &m,const ivector &v)
2927 #if(CXSC_INDEX_CHECK)
2928 ;
2929 #else
2930  noexcept;
2931 #endif
2933  INLINE l_ivector operator *(const l_imatrix_slice &ms,const ivector &v)
2934 #if(CXSC_INDEX_CHECK)
2935 ;
2936 #else
2937  noexcept;
2938 #endif
2939 
2940 
2941 //================ Matrix / Matrix ============================
2942 
2944  INLINE const l_imatrix &operator +(const l_imatrix &m1) noexcept;
2946  INLINE l_imatrix operator +(const l_imatrix_slice &ms) noexcept;
2948  INLINE l_imatrix operator +(const l_imatrix &m1,const l_imatrix &m2)
2949 #if(CXSC_INDEX_CHECK)
2950 ;
2951 #else
2952  noexcept;
2953 #endif
2955  INLINE l_imatrix operator +(const l_imatrix &m,const l_imatrix_slice &ms)
2956 #if(CXSC_INDEX_CHECK)
2957 ;
2958 #else
2959  noexcept;
2960 #endif
2962  INLINE l_imatrix operator +(const l_imatrix_slice &ms,const l_imatrix &m)
2963 #if(CXSC_INDEX_CHECK)
2964 ;
2965 #else
2966  noexcept;
2967 #endif
2969  INLINE l_imatrix operator +(const l_imatrix_slice &m1,const l_imatrix_slice &m2)
2970 #if(CXSC_INDEX_CHECK)
2971 ;
2972 #else
2973  noexcept;
2974 #endif
2976  INLINE l_imatrix &operator +=(l_imatrix &m1,const l_imatrix &m2)
2977 #if(CXSC_INDEX_CHECK)
2978 ;
2979 #else
2980  noexcept;
2981 #endif
2983  INLINE l_imatrix &operator +=(l_imatrix &m1,const l_imatrix_slice &ms)
2984 #if(CXSC_INDEX_CHECK)
2985 ;
2986 #else
2987  noexcept;
2988 #endif
2989 
2991  INLINE l_imatrix operator -(const l_imatrix &m) noexcept;
2993  INLINE l_imatrix operator -(const l_imatrix_slice &ms) noexcept;
2995  INLINE l_imatrix operator -(const l_imatrix &m1,const l_imatrix &m2)
2996 #if(CXSC_INDEX_CHECK)
2997 ;
2998 #else
2999  noexcept;
3000 #endif
3002  INLINE l_imatrix operator -(const l_imatrix &m,const l_imatrix_slice &ms)
3003 #if(CXSC_INDEX_CHECK)
3004 ;
3005 #else
3006  noexcept;
3007 #endif
3009  INLINE l_imatrix operator -(const l_imatrix_slice &ms,const l_imatrix &m)
3010 #if(CXSC_INDEX_CHECK)
3011 ;
3012 #else
3013  noexcept;
3014 #endif
3016  INLINE l_imatrix operator -(const l_imatrix_slice &ms1,const l_imatrix_slice &ms2)
3017 #if(CXSC_INDEX_CHECK)
3018 ;
3019 #else
3020  noexcept;
3021 #endif
3023  INLINE l_imatrix &operator -=(l_imatrix &m1,const l_imatrix &m2)
3024 #if(CXSC_INDEX_CHECK)
3025 ;
3026 #else
3027  noexcept;
3028 #endif
3030  INLINE l_imatrix &operator -=(l_imatrix &m1,const l_imatrix_slice &ms)
3031 #if(CXSC_INDEX_CHECK)
3032 ;
3033 #else
3034  noexcept;
3035 #endif
3036 
3038  INLINE l_imatrix operator *(const l_imatrix &m1, const l_imatrix &m2)
3039 #if(CXSC_INDEX_CHECK)
3040 ;
3041 #else
3042  noexcept;
3043 #endif
3045  INLINE l_imatrix operator *(const l_imatrix &m1, const l_imatrix_slice &ms)
3046 #if(CXSC_INDEX_CHECK)
3047 ;
3048 #else
3049  noexcept;
3050 #endif
3052  INLINE l_imatrix operator *(const l_imatrix_slice &ms, const l_imatrix &m1)
3053 #if(CXSC_INDEX_CHECK)
3054 ;
3055 #else
3056  noexcept;
3057 #endif
3059  INLINE l_imatrix operator *(const l_imatrix_slice &ms1, const l_imatrix_slice &ms2)
3060 #if(CXSC_INDEX_CHECK)
3061 ;
3062 #else
3063  noexcept;
3064 #endif
3066  INLINE l_imatrix &operator *=(l_imatrix &m1,const l_imatrix &m2)
3067 #if(CXSC_INDEX_CHECK)
3068 ;
3069 #else
3070  noexcept;
3071 #endif
3073  INLINE l_imatrix &operator *=(l_imatrix &m1,const l_imatrix_slice &ms)
3074 #if(CXSC_INDEX_CHECK)
3075 ;
3076 #else
3077  noexcept;
3078 #endif
3079 
3080 
3082  INLINE l_imatrix operator |(const l_imatrix &m1,const l_imatrix &m2)
3083 #if(CXSC_INDEX_CHECK)
3084 ;
3085 #else
3086  noexcept;
3087 #endif
3089  INLINE l_imatrix operator |(const l_imatrix &m,const l_imatrix_slice &ms)
3090 #if(CXSC_INDEX_CHECK)
3091 ;
3092 #else
3093  noexcept;
3094 #endif
3096  INLINE l_imatrix operator |(const l_imatrix_slice &ms,const l_imatrix &m)
3097 #if(CXSC_INDEX_CHECK)
3098 ;
3099 #else
3100  noexcept;
3101 #endif
3103  INLINE l_imatrix operator |(const l_imatrix_slice &m1,const l_imatrix_slice &m2)
3104 #if(CXSC_INDEX_CHECK)
3105 ;
3106 #else
3107  noexcept;
3108 #endif
3110  INLINE l_imatrix &operator |=(l_imatrix &m1,const l_imatrix &m2)
3111 #if(CXSC_INDEX_CHECK)
3112 ;
3113 #else
3114  noexcept;
3115 #endif
3117  INLINE l_imatrix &operator |=(l_imatrix &m1,const l_imatrix_slice &ms)
3118 #if(CXSC_INDEX_CHECK)
3119 ;
3120 #else
3121  noexcept;
3122 #endif
3123 
3125  INLINE l_imatrix operator &(const l_imatrix &m1,const l_imatrix &m2)
3126 #if(CXSC_INDEX_CHECK)
3127 ;
3128 #else
3129  noexcept;
3130 #endif
3132  INLINE l_imatrix operator &(const l_imatrix &m,const l_imatrix_slice &ms)
3133 #if(CXSC_INDEX_CHECK)
3134 ;
3135 #else
3136  noexcept;
3137 #endif
3139  INLINE l_imatrix operator &(const l_imatrix_slice &ms,const l_imatrix &m)
3140 #if(CXSC_INDEX_CHECK)
3141 ;
3142 #else
3143  noexcept;
3144 #endif
3146  INLINE l_imatrix operator &(const l_imatrix_slice &m1,const l_imatrix_slice &m2)
3147 #if(CXSC_INDEX_CHECK)
3148 ;
3149 #else
3150  noexcept;
3151 #endif
3153  INLINE l_imatrix &operator &=(l_imatrix &m1,const l_imatrix &m2)
3154 #if(CXSC_INDEX_CHECK)
3155 ;
3156 #else
3157  noexcept;
3158 #endif
3160  INLINE l_imatrix &operator &=(l_imatrix &m1,const l_imatrix_slice &ms)
3161 #if(CXSC_INDEX_CHECK)
3162 ;
3163 #else
3164  noexcept;
3165 #endif
3166 
3167  //---------- rmatrix-l_imatrix ------------------
3169  INLINE l_imatrix operator +(const rmatrix &m1,const l_imatrix &m2)
3170 #if(CXSC_INDEX_CHECK)
3171 ;
3172 #else
3173  noexcept;
3174 #endif
3176  INLINE l_imatrix operator +(const l_imatrix &m1,const rmatrix &m2)
3177 #if(CXSC_INDEX_CHECK)
3178 ;
3179 #else
3180  noexcept;
3181 #endif
3183  INLINE l_imatrix operator +(const rmatrix &m,const l_imatrix_slice &ms)
3184 #if(CXSC_INDEX_CHECK)
3185 ;
3186 #else
3187  noexcept;
3188 #endif
3190  INLINE l_imatrix operator +(const l_imatrix &m,const rmatrix_slice &ms)
3191 #if(CXSC_INDEX_CHECK)
3192 ;
3193 #else
3194  noexcept;
3195 #endif
3197  INLINE l_imatrix operator +(const rmatrix_slice &ms,const l_imatrix &m)
3198 #if(CXSC_INDEX_CHECK)
3199 ;
3200 #else
3201  noexcept;
3202 #endif
3204  INLINE l_imatrix operator +(const l_imatrix_slice &ms,const rmatrix &m)
3205 #if(CXSC_INDEX_CHECK)
3206 ;
3207 #else
3208  noexcept;
3209 #endif
3211  INLINE l_imatrix operator +(const rmatrix_slice &m1,const l_imatrix_slice &m2)
3212 #if(CXSC_INDEX_CHECK)
3213 ;
3214 #else
3215  noexcept;
3216 #endif
3218  INLINE l_imatrix operator +(const l_imatrix_slice &m1,const rmatrix_slice &m2)
3219 #if(CXSC_INDEX_CHECK)
3220 ;
3221 #else
3222  noexcept;
3223 #endif
3225  INLINE l_imatrix &operator +=(l_imatrix &m1,const rmatrix &m2)
3226 #if(CXSC_INDEX_CHECK)
3227 ;
3228 #else
3229  noexcept;
3230 #endif
3232  INLINE l_imatrix &operator +=(l_imatrix &m1,const rmatrix_slice &ms)
3233 #if(CXSC_INDEX_CHECK)
3234 ;
3235 #else
3236  noexcept;
3237 #endif
3238 
3240  INLINE l_imatrix operator -(const rmatrix &m1,const l_imatrix &m2)
3241 #if(CXSC_INDEX_CHECK)
3242 ;
3243 #else
3244  noexcept;
3245 #endif
3247  INLINE l_imatrix operator -(const l_imatrix &m1,const rmatrix &m2)
3248 #if(CXSC_INDEX_CHECK)
3249 ;
3250 #else
3251  noexcept;
3252 #endif
3254  INLINE l_imatrix operator -(const rmatrix &m,const l_imatrix_slice &ms)
3255 #if(CXSC_INDEX_CHECK)
3256 ;
3257 #else
3258  noexcept;
3259 #endif
3261  INLINE l_imatrix operator -(const l_imatrix &m,const rmatrix_slice &ms)
3262 #if(CXSC_INDEX_CHECK)
3263 ;
3264 #else
3265  noexcept;
3266 #endif
3268  INLINE l_imatrix operator -(const rmatrix_slice &ms,const l_imatrix &m)
3269 #if(CXSC_INDEX_CHECK)
3270 ;
3271 #else
3272  noexcept;
3273 #endif
3275  INLINE l_imatrix operator -(const l_imatrix_slice &ms,const rmatrix &m)
3276 #if(CXSC_INDEX_CHECK)
3277 ;
3278 #else
3279  noexcept;
3280 #endif
3282  INLINE l_imatrix operator -(const rmatrix_slice &ms1,const l_imatrix_slice &ms2)
3283 #if(CXSC_INDEX_CHECK)
3284 ;
3285 #else
3286  noexcept;
3287 #endif
3289  INLINE l_imatrix operator -(const l_imatrix_slice &ms1,const rmatrix_slice &ms2)
3290 #if(CXSC_INDEX_CHECK)
3291 ;
3292 #else
3293  noexcept;
3294 #endif
3296  INLINE l_imatrix &operator -=(l_imatrix &m1,const rmatrix &m2)
3297 #if(CXSC_INDEX_CHECK)
3298 ;
3299 #else
3300  noexcept;
3301 #endif
3303  INLINE l_imatrix &operator -=(l_imatrix &m1,const rmatrix_slice &ms)
3304 #if(CXSC_INDEX_CHECK)
3305 ;
3306 #else
3307  noexcept;
3308 #endif
3309 
3311  INLINE l_imatrix operator *(const rmatrix &m1, const l_imatrix &m2)
3312 #if(CXSC_INDEX_CHECK)
3313 ;
3314 #else
3315  noexcept;
3316 #endif
3318  INLINE l_imatrix operator *(const l_imatrix &m1, const rmatrix &m2)
3319 #if(CXSC_INDEX_CHECK)
3320 ;
3321 #else
3322  noexcept;
3323 #endif
3325  INLINE l_imatrix operator *(const rmatrix &m1, const l_imatrix_slice &ms)
3326 #if(CXSC_INDEX_CHECK)
3327 ;
3328 #else
3329  noexcept;
3330 #endif
3332  INLINE l_imatrix operator *(const l_imatrix &m1, const rmatrix_slice &ms)
3333 #if(CXSC_INDEX_CHECK)
3334 ;
3335 #else
3336  noexcept;
3337 #endif
3339  INLINE l_imatrix operator *(const rmatrix_slice &ms, const l_imatrix &m1)
3340 #if(CXSC_INDEX_CHECK)
3341 ;
3342 #else
3343  noexcept;
3344 #endif
3346  INLINE l_imatrix operator *(const l_imatrix_slice &ms, const rmatrix &m1)
3347 #if(CXSC_INDEX_CHECK)
3348 ;
3349 #else
3350  noexcept;
3351 #endif
3353  INLINE l_imatrix operator *(const rmatrix_slice &ms1, const l_imatrix_slice &ms2)
3354 #if(CXSC_INDEX_CHECK)
3355 ;
3356 #else
3357  noexcept;
3358 #endif
3360  INLINE l_imatrix operator *(const l_imatrix_slice &ms1, const rmatrix_slice &ms2)
3361 #if(CXSC_INDEX_CHECK)
3362 ;
3363 #else
3364  noexcept;
3365 #endif
3367  INLINE l_imatrix &operator *=(l_imatrix &m1,const rmatrix &m2)
3368 #if(CXSC_INDEX_CHECK)
3369 ;
3370 #else
3371  noexcept;
3372 #endif
3374  INLINE l_imatrix &operator *=(l_imatrix &m1,const rmatrix_slice &ms)
3375 #if(CXSC_INDEX_CHECK)
3376 ;
3377 #else
3378  noexcept;
3379 #endif
3380 
3382  INLINE l_imatrix operator |(const rmatrix &m1,const l_imatrix &m2)
3383 #if(CXSC_INDEX_CHECK)
3384 ;
3385 #else
3386  noexcept;
3387 #endif
3389  INLINE l_imatrix operator |(const l_imatrix &m1,const rmatrix &m2)
3390 #if(CXSC_INDEX_CHECK)
3391 ;
3392 #else
3393  noexcept;
3394 #endif
3396  INLINE l_imatrix operator |(const rmatrix &m,const l_imatrix_slice &ms)
3397 #if(CXSC_INDEX_CHECK)
3398 ;
3399 #else
3400  noexcept;
3401 #endif
3403  INLINE l_imatrix operator |(const l_imatrix &m,const rmatrix_slice &ms)
3404 #if(CXSC_INDEX_CHECK)
3405 ;
3406 #else
3407  noexcept;
3408 #endif
3410  INLINE l_imatrix operator |(const rmatrix_slice &ms,const l_imatrix &m)
3411 #if(CXSC_INDEX_CHECK)
3412 ;
3413 #else
3414  noexcept;
3415 #endif
3417  INLINE l_imatrix operator |(const l_imatrix_slice &ms,const rmatrix &m)
3418 #if(CXSC_INDEX_CHECK)
3419 ;
3420 #else
3421  noexcept;
3422 #endif
3424  INLINE l_imatrix operator |(const rmatrix_slice &m1,const l_imatrix_slice &m2)
3425 #if(CXSC_INDEX_CHECK)
3426 ;
3427 #else
3428  noexcept;
3429 #endif
3431  INLINE l_imatrix operator |(const l_imatrix_slice &m1,const rmatrix_slice &m2)
3432 #if(CXSC_INDEX_CHECK)
3433 ;
3434 #else
3435  noexcept;
3436 #endif
3438  INLINE l_imatrix &operator |=(l_imatrix &m1,const rmatrix &m2)
3439 #if(CXSC_INDEX_CHECK)
3440 ;
3441 #else
3442  noexcept;
3443 #endif
3445  INLINE l_imatrix &operator |=(l_imatrix &m1,const rmatrix_slice &ms)
3446 #if(CXSC_INDEX_CHECK)
3447 ;
3448 #else
3449  noexcept;
3450 #endif
3451 
3453  INLINE l_imatrix operator &(const rmatrix &m1,const l_imatrix &m2)
3454 #if(CXSC_INDEX_CHECK)
3455 ;
3456 #else
3457  noexcept;
3458 #endif
3460  INLINE l_imatrix operator &(const l_imatrix &m1,const rmatrix &m2)
3461 #if(CXSC_INDEX_CHECK)
3462 ;
3463 #else
3464  noexcept;
3465 #endif
3467  INLINE l_imatrix operator &(const rmatrix &m,const l_imatrix_slice &ms)
3468 #if(CXSC_INDEX_CHECK)
3469 ;
3470 #else
3471  noexcept;
3472 #endif
3474  INLINE l_imatrix operator &(const l_imatrix &m,const rmatrix_slice &ms)
3475 #if(CXSC_INDEX_CHECK)
3476 ;
3477 #else
3478  noexcept;
3479 #endif
3481  INLINE l_imatrix operator &(const rmatrix_slice &ms,const l_imatrix &m)
3482 #if(CXSC_INDEX_CHECK)
3483 ;
3484 #else
3485  noexcept;
3486 #endif
3488  INLINE l_imatrix operator &(const l_imatrix_slice &ms,const rmatrix &m)
3489 #if(CXSC_INDEX_CHECK)
3490 ;
3491 #else
3492  noexcept;
3493 #endif
3495  INLINE l_imatrix operator &(const rmatrix_slice &m1,const l_imatrix_slice &m2)
3496 #if(CXSC_INDEX_CHECK)
3497 ;
3498 #else
3499  noexcept;
3500 #endif
3502  INLINE l_imatrix operator &(const l_imatrix_slice &m1,const rmatrix_slice &m2)
3503 #if(CXSC_INDEX_CHECK)
3504 ;
3505 #else
3506  noexcept;
3507 #endif
3509  INLINE l_imatrix &operator &=(l_imatrix &m1,const rmatrix &m2)
3510 #if(CXSC_INDEX_CHECK)
3511 ;
3512 #else
3513  noexcept;
3514 #endif
3516  INLINE l_imatrix &operator &=(l_imatrix &m1,const rmatrix_slice &ms)
3517 #if(CXSC_INDEX_CHECK)
3518 ;
3519 #else
3520  noexcept;
3521 #endif
3522 
3523  //---------- l_rmatrix-l_imatrix ------------------
3525  INLINE l_imatrix operator +(const l_rmatrix &m1,const l_imatrix &m2)
3526 #if(CXSC_INDEX_CHECK)
3527 ;
3528 #else
3529  noexcept;
3530 #endif
3532  INLINE l_imatrix operator +(const l_imatrix &m1,const l_rmatrix &m2)
3533 #if(CXSC_INDEX_CHECK)
3534 ;
3535 #else
3536  noexcept;
3537 #endif
3539  INLINE l_imatrix operator +(const l_rmatrix &m,const l_imatrix_slice &ms)
3540 #if(CXSC_INDEX_CHECK)
3541 ;
3542 #else
3543  noexcept;
3544 #endif
3546  INLINE l_imatrix operator +(const l_imatrix &m,const l_rmatrix_slice &ms)
3547 #if(CXSC_INDEX_CHECK)
3548 ;
3549 #else
3550  noexcept;
3551 #endif
3553  INLINE l_imatrix operator +(const l_rmatrix_slice &ms,const l_imatrix &m)
3554 #if(CXSC_INDEX_CHECK)
3555 ;
3556 #else
3557  noexcept;
3558 #endif
3560  INLINE l_imatrix operator +(const l_imatrix_slice &ms,const l_rmatrix &m)
3561 #if(CXSC_INDEX_CHECK)
3562 ;
3563 #else
3564  noexcept;
3565 #endif
3567  INLINE l_imatrix operator +(const l_rmatrix_slice &m1,const l_imatrix_slice &m2)
3568 #if(CXSC_INDEX_CHECK)
3569 ;
3570 #else
3571  noexcept;
3572 #endif
3574  INLINE l_imatrix operator +(const l_imatrix_slice &m1,const l_rmatrix_slice &m2)
3575 #if(CXSC_INDEX_CHECK)
3576 ;
3577 #else
3578  noexcept;
3579 #endif
3581  INLINE l_imatrix &operator +=(l_imatrix &m1,const l_rmatrix &m2)
3582 #if(CXSC_INDEX_CHECK)
3583 ;
3584 #else
3585  noexcept;
3586 #endif
3588  INLINE l_imatrix &operator +=(l_imatrix &m1,const l_rmatrix_slice &ms)
3589 #if(CXSC_INDEX_CHECK)
3590 ;
3591 #else
3592  noexcept;
3593 #endif
3594 
3596  INLINE l_imatrix operator -(const l_rmatrix &m1,const l_imatrix &m2)
3597 #if(CXSC_INDEX_CHECK)
3598 ;
3599 #else
3600  noexcept;
3601 #endif
3603  INLINE l_imatrix operator -(const l_imatrix &m1,const l_rmatrix &m2)
3604 #if(CXSC_INDEX_CHECK)
3605 ;
3606 #else
3607  noexcept;
3608 #endif
3610  INLINE l_imatrix operator -(const l_rmatrix &m,const l_imatrix_slice &ms)
3611 #if(CXSC_INDEX_CHECK)
3612 ;
3613 #else
3614  noexcept;
3615 #endif
3617  INLINE l_imatrix operator -(const l_imatrix &m,const l_rmatrix_slice &ms)
3618 #if(CXSC_INDEX_CHECK)
3619 ;
3620 #else
3621  noexcept;
3622 #endif
3624  INLINE l_imatrix operator -(const l_rmatrix_slice &ms,const l_imatrix &m)
3625 #if(CXSC_INDEX_CHECK)
3626 ;
3627 #else
3628  noexcept;
3629 #endif
3631  INLINE l_imatrix operator -(const l_imatrix_slice &ms,const l_rmatrix &m)
3632 #if(CXSC_INDEX_CHECK)
3633 ;
3634 #else
3635  noexcept;
3636 #endif
3638  INLINE l_imatrix operator -(const l_rmatrix_slice &ms1,const l_imatrix_slice &ms2)
3639 #if(CXSC_INDEX_CHECK)
3640 ;
3641 #else
3642  noexcept;
3643 #endif
3645  INLINE l_imatrix operator -(const l_imatrix_slice &ms1,const l_rmatrix_slice &ms2)
3646 #if(CXSC_INDEX_CHECK)
3647 ;
3648 #else
3649  noexcept;
3650 #endif
3652  INLINE l_imatrix &operator -=(l_imatrix &m1,const l_rmatrix &m2)
3653 #if(CXSC_INDEX_CHECK)
3654 ;
3655 #else
3656  noexcept;
3657 #endif
3659  INLINE l_imatrix &operator -=(l_imatrix &m1,const l_rmatrix_slice &ms)
3660 #if(CXSC_INDEX_CHECK)
3661 ;
3662 #else
3663  noexcept;
3664 #endif
3665 
3667  INLINE l_imatrix operator *(const l_rmatrix &m1, const l_imatrix &m2)
3668 #if(CXSC_INDEX_CHECK)
3669 ;
3670 #else
3671  noexcept;
3672 #endif
3674  INLINE l_imatrix operator *(const l_imatrix &m1, const l_rmatrix &m2)
3675 #if(CXSC_INDEX_CHECK)
3676 ;
3677 #else
3678  noexcept;
3679 #endif
3681  INLINE l_imatrix operator *(const l_rmatrix &m1, const l_imatrix_slice &ms)
3682 #if(CXSC_INDEX_CHECK)
3683 ;
3684 #else
3685  noexcept;
3686 #endif
3688  INLINE l_imatrix operator *(const l_imatrix &m1, const l_rmatrix_slice &ms)
3689 #if(CXSC_INDEX_CHECK)
3690 ;
3691 #else
3692  noexcept;
3693 #endif
3695  INLINE l_imatrix operator *(const l_rmatrix_slice &ms, const l_imatrix &m1)
3696 #if(CXSC_INDEX_CHECK)
3697 ;
3698 #else
3699  noexcept;
3700 #endif
3702  INLINE l_imatrix operator *(const l_imatrix_slice &ms, const l_rmatrix &m1)
3703 #if(CXSC_INDEX_CHECK)
3704 ;
3705 #else
3706  noexcept;
3707 #endif
3709  INLINE l_imatrix operator *(const l_rmatrix_slice &ms1, const l_imatrix_slice &ms2)
3710 #if(CXSC_INDEX_CHECK)
3711 ;
3712 #else
3713  noexcept;
3714 #endif
3716  INLINE l_imatrix operator *(const l_imatrix_slice &ms1, const l_rmatrix_slice &ms2)
3717 #if(CXSC_INDEX_CHECK)
3718 ;
3719 #else
3720  noexcept;
3721 #endif
3723  INLINE l_imatrix &operator *=(l_imatrix &m1,const l_rmatrix &m2)
3724 #if(CXSC_INDEX_CHECK)
3725 ;
3726 #else
3727  noexcept;
3728 #endif
3730  INLINE l_imatrix &operator *=(l_imatrix &m1,const l_rmatrix_slice &ms)
3731 #if(CXSC_INDEX_CHECK)
3732 ;
3733 #else
3734  noexcept;
3735 #endif
3736 
3738  INLINE l_imatrix operator |(const l_rmatrix &m1,const l_imatrix &m2)
3739 #if(CXSC_INDEX_CHECK)
3740 ;
3741 #else
3742  noexcept;
3743 #endif
3745  INLINE l_imatrix operator |(const l_imatrix &m1,const l_rmatrix &m2)
3746 #if(CXSC_INDEX_CHECK)
3747 ;
3748 #else
3749  noexcept;
3750 #endif
3752  INLINE l_imatrix operator |(const l_rmatrix &m,const l_imatrix_slice &ms)
3753 #if(CXSC_INDEX_CHECK)
3754 ;
3755 #else
3756  noexcept;
3757 #endif
3759  INLINE l_imatrix operator |(const l_imatrix &m,const l_rmatrix_slice &ms)
3760 #if(CXSC_INDEX_CHECK)
3761 ;
3762 #else
3763  noexcept;
3764 #endif
3766  INLINE l_imatrix operator |(const l_rmatrix_slice &ms,const l_imatrix &m)
3767 #if(CXSC_INDEX_CHECK)
3768 ;
3769 #else
3770  noexcept;
3771 #endif
3773  INLINE l_imatrix operator |(const l_imatrix_slice &ms,const l_rmatrix &m)
3774 #if(CXSC_INDEX_CHECK)
3775 ;
3776 #else
3777  noexcept;
3778 #endif
3780  INLINE l_imatrix operator |(const l_rmatrix_slice &m1,const l_imatrix_slice &m2)
3781 #if(CXSC_INDEX_CHECK)
3782 ;
3783 #else
3784  noexcept;
3785 #endif
3787  INLINE l_imatrix operator |(const l_imatrix_slice &m1,const l_rmatrix_slice &m2)
3788 #if(CXSC_INDEX_CHECK)
3789 ;
3790 #else
3791  noexcept;
3792 #endif
3794  INLINE l_imatrix &operator |=(l_imatrix &m1,const l_rmatrix &m2)
3795 #if(CXSC_INDEX_CHECK)
3796 ;
3797 #else
3798  noexcept;
3799 #endif
3801  INLINE l_imatrix &operator |=(l_imatrix &m1,const l_rmatrix_slice &ms)
3802 #if(CXSC_INDEX_CHECK)
3803 ;
3804 #else
3805  noexcept;
3806 #endif
3807 
3809  INLINE l_imatrix operator &(const l_rmatrix &m1,const l_imatrix &m2)
3810 #if(CXSC_INDEX_CHECK)
3811 ;
3812 #else
3813  noexcept;
3814 #endif
3816  INLINE l_imatrix operator &(const l_imatrix &m1,const l_rmatrix &m2)
3817 #if(CXSC_INDEX_CHECK)
3818 ;
3819 #else
3820  noexcept;
3821 #endif
3823  INLINE l_imatrix operator &(const l_rmatrix &m,const l_imatrix_slice &ms)
3824 #if(CXSC_INDEX_CHECK)
3825 ;
3826 #else
3827  noexcept;
3828 #endif
3830  INLINE l_imatrix operator &(const l_imatrix &m,const l_rmatrix_slice &ms)
3831 #if(CXSC_INDEX_CHECK)
3832 ;
3833 #else
3834  noexcept;
3835 #endif
3837  INLINE l_imatrix operator &(const l_rmatrix_slice &ms,const l_imatrix &m)
3838 #if(CXSC_INDEX_CHECK)
3839 ;
3840 #else
3841  noexcept;
3842 #endif
3844  INLINE l_imatrix operator &(const l_imatrix_slice &ms,const l_rmatrix &m)
3845 #if(CXSC_INDEX_CHECK)
3846 ;
3847 #else
3848  noexcept;
3849 #endif
3851  INLINE l_imatrix operator &(const l_rmatrix_slice &m1,const l_imatrix_slice &m2)
3852 #if(CXSC_INDEX_CHECK)
3853 ;
3854 #else
3855  noexcept;
3856 #endif
3858  INLINE l_imatrix operator &(const l_imatrix_slice &m1,const l_rmatrix_slice &m2)
3859 #if(CXSC_INDEX_CHECK)
3860 ;
3861 #else
3862  noexcept;
3863 #endif
3865  INLINE l_imatrix &operator &=(l_imatrix &m1,const l_rmatrix &m2)
3866 #if(CXSC_INDEX_CHECK)
3867 ;
3868 #else
3869  noexcept;
3870 #endif
3872  INLINE l_imatrix &operator &=(l_imatrix &m1,const l_rmatrix_slice &ms)
3873 #if(CXSC_INDEX_CHECK)
3874 ;
3875 #else
3876  noexcept;
3877 #endif
3878 
3879  //---------- imatrix-l_imatrix ------------------
3881  INLINE l_imatrix operator +(const imatrix &m1,const l_imatrix &m2)
3882 #if(CXSC_INDEX_CHECK)
3883 ;
3884 #else
3885  noexcept;
3886 #endif
3888  INLINE l_imatrix operator +(const l_imatrix &m1,const imatrix &m2)
3889 #if(CXSC_INDEX_CHECK)
3890 ;
3891 #else
3892  noexcept;
3893 #endif
3895  INLINE l_imatrix operator +(const imatrix &m,const l_imatrix_slice &ms)
3896 #if(CXSC_INDEX_CHECK)
3897 ;
3898 #else
3899  noexcept;
3900 #endif
3902  INLINE l_imatrix operator +(const l_imatrix &m,const imatrix_slice &ms)
3903 #if(CXSC_INDEX_CHECK)
3904 ;
3905 #else
3906  noexcept;
3907 #endif
3909  INLINE l_imatrix operator +(const imatrix_slice &ms,const l_imatrix &m)
3910 #if(CXSC_INDEX_CHECK)
3911 ;
3912 #else
3913  noexcept;
3914 #endif
3916  INLINE l_imatrix operator +(const l_imatrix_slice &ms,const imatrix &m)
3917 #if(CXSC_INDEX_CHECK)
3918 ;
3919 #else
3920  noexcept;
3921 #endif
3923  INLINE l_imatrix operator +(const imatrix_slice &m1,const l_imatrix_slice &m2)
3924 #if(CXSC_INDEX_CHECK)
3925 ;
3926 #else
3927  noexcept;
3928 #endif
3930  INLINE l_imatrix operator +(const l_imatrix_slice &m1,const imatrix_slice &m2)
3931 #if(CXSC_INDEX_CHECK)
3932 ;
3933 #else
3934  noexcept;
3935 #endif
3937  INLINE l_imatrix &operator +=(l_imatrix &m1,const imatrix &m2)
3938 #if(CXSC_INDEX_CHECK)
3939 ;
3940 #else
3941  noexcept;
3942 #endif
3944  INLINE l_imatrix &operator +=(l_imatrix &m1,const imatrix_slice &ms)
3945 #if(CXSC_INDEX_CHECK)
3946 ;
3947 #else
3948  noexcept;
3949 #endif
3950 
3952  INLINE l_imatrix operator -(const imatrix &m1,const l_imatrix &m2)
3953 #if(CXSC_INDEX_CHECK)
3954 ;
3955 #else
3956  noexcept;
3957 #endif
3959  INLINE l_imatrix operator -(const l_imatrix &m1,const imatrix &m2)
3960 #if(CXSC_INDEX_CHECK)
3961 ;
3962 #else
3963  noexcept;
3964 #endif
3966  INLINE l_imatrix operator -(const imatrix &m,const l_imatrix_slice &ms)
3967 #if(CXSC_INDEX_CHECK)
3968 ;
3969 #else
3970  noexcept;
3971 #endif
3973  INLINE l_imatrix operator -(const l_imatrix &m,const imatrix_slice &ms)
3974 #if(CXSC_INDEX_CHECK)
3975 ;
3976 #else
3977  noexcept;
3978 #endif
3980  INLINE l_imatrix operator -(const imatrix_slice &ms,const l_imatrix &m)
3981 #if(CXSC_INDEX_CHECK)
3982 ;
3983 #else
3984  noexcept;
3985 #endif
3987  INLINE l_imatrix operator -(const l_imatrix_slice &ms,const imatrix &m)
3988 #if(CXSC_INDEX_CHECK)
3989 ;
3990 #else
3991  noexcept;
3992 #endif
3994  INLINE l_imatrix operator -(const imatrix_slice &ms1,const l_imatrix_slice &ms2)
3995 #if(CXSC_INDEX_CHECK)
3996 ;
3997 #else
3998  noexcept;
3999 #endif
4001  INLINE l_imatrix operator -(const l_imatrix_slice &ms1,const imatrix_slice &ms2)
4002 #if(CXSC_INDEX_CHECK)
4003 ;
4004 #else
4005  noexcept;
4006 #endif
4008  INLINE l_imatrix &operator -=(l_imatrix &m1,const imatrix &m2)
4009 #if(CXSC_INDEX_CHECK)
4010 ;
4011 #else
4012  noexcept;
4013 #endif
4015  INLINE l_imatrix &operator -=(l_imatrix &m1,const imatrix_slice &ms)
4016 #if(CXSC_INDEX_CHECK)
4017 ;
4018 #else
4019  noexcept;
4020 #endif
4021 
4023  INLINE l_imatrix operator *(const imatrix &m1, const l_imatrix &m2)
4024 #if(CXSC_INDEX_CHECK)
4025 ;
4026 #else
4027  noexcept;
4028 #endif
4030  INLINE l_imatrix operator *(const l_imatrix &m1, const imatrix &m2)
4031 #if(CXSC_INDEX_CHECK)
4032 ;
4033 #else
4034  noexcept;
4035 #endif
4037  INLINE l_imatrix operator *(const imatrix &m1, const l_imatrix_slice &ms)
4038 #if(CXSC_INDEX_CHECK)
4039 ;
4040 #else
4041  noexcept;
4042 #endif
4044  INLINE l_imatrix operator *(const l_imatrix &m1, const imatrix_slice &ms)
4045 #if(CXSC_INDEX_CHECK)
4046 ;
4047 #else
4048  noexcept;
4049 #endif
4051  INLINE l_imatrix operator *(const imatrix_slice &ms, const l_imatrix &m1)
4052 #if(CXSC_INDEX_CHECK)
4053 ;
4054 #else
4055  noexcept;
4056 #endif
4058  INLINE l_imatrix operator *(const l_imatrix_slice &ms, const imatrix &m1)
4059 #if(CXSC_INDEX_CHECK)
4060 ;
4061 #else
4062  noexcept;
4063 #endif
4065  INLINE l_imatrix operator *(const imatrix_slice &ms1, const l_imatrix_slice &ms2)
4066 #if(CXSC_INDEX_CHECK)
4067 ;
4068 #else
4069  noexcept;
4070 #endif
4072  INLINE l_imatrix operator *(const l_imatrix_slice &ms1, const imatrix_slice &ms2)
4073 #if(CXSC_INDEX_CHECK)
4074 ;
4075 #else
4076  noexcept;
4077 #endif
4079  INLINE l_imatrix &operator *=(l_imatrix &m1,const imatrix &m2)
4080 #if(CXSC_INDEX_CHECK)
4081 ;
4082 #else
4083  noexcept;
4084 #endif
4086  INLINE l_imatrix &operator *=(l_imatrix &m1,const imatrix_slice &ms)
4087 #if(CXSC_INDEX_CHECK)
4088 ;
4089 #else
4090  noexcept;
4091 #endif
4092 
4094  INLINE l_imatrix operator |(const imatrix &m1,const l_imatrix &m2)
4095 #if(CXSC_INDEX_CHECK)
4096 ;
4097 #else
4098  noexcept;
4099 #endif
4101  INLINE l_imatrix operator |(const l_imatrix &m1,const imatrix &m2)
4102 #if(CXSC_INDEX_CHECK)
4103 ;
4104 #else
4105  noexcept;
4106 #endif
4108  INLINE l_imatrix operator |(const imatrix &m,const l_imatrix_slice &ms)
4109 #if(CXSC_INDEX_CHECK)
4110 ;
4111 #else
4112  noexcept;
4113 #endif
4115  INLINE l_imatrix operator |(const l_imatrix &m,const imatrix_slice &ms)
4116 #if(CXSC_INDEX_CHECK)
4117 ;
4118 #else
4119  noexcept;
4120 #endif
4122  INLINE l_imatrix operator |(const imatrix_slice &ms,const l_imatrix &m)
4123 #if(CXSC_INDEX_CHECK)
4124 ;
4125 #else
4126  noexcept;
4127 #endif
4129  INLINE l_imatrix operator |(const l_imatrix_slice &ms,const imatrix &m)
4130 #if(CXSC_INDEX_CHECK)
4131 ;
4132 #else
4133  noexcept;
4134 #endif
4136  INLINE l_imatrix operator |(const imatrix_slice &m1,const l_imatrix_slice &m2)
4137 #if(CXSC_INDEX_CHECK)
4138 ;
4139 #else
4140  noexcept;
4141 #endif
4143  INLINE l_imatrix operator |(const l_imatrix_slice &m1,const imatrix_slice &m2)
4144 #if(CXSC_INDEX_CHECK)
4145 ;
4146 #else
4147  noexcept;
4148 #endif
4150  INLINE l_imatrix &operator |=(l_imatrix &m1,const imatrix &m2)
4151 #if(CXSC_INDEX_CHECK)
4152 ;
4153 #else
4154  noexcept;
4155 #endif
4157  INLINE l_imatrix &operator |=(l_imatrix &m1,const imatrix_slice &ms)
4158 #if(CXSC_INDEX_CHECK)
4159 ;
4160 #else
4161  noexcept;
4162 #endif
4163 
4165  INLINE l_imatrix operator &(const imatrix &m1,const l_imatrix &m2)
4166 #if(CXSC_INDEX_CHECK)
4167 ;
4168 #else
4169  noexcept;
4170 #endif
4172  INLINE l_imatrix operator &(const l_imatrix &m1,const imatrix &m2)
4173 #if(CXSC_INDEX_CHECK)
4174 ;
4175 #else
4176  noexcept;
4177 #endif
4179  INLINE l_imatrix operator &(const imatrix &m,const l_imatrix_slice &ms)
4180 #if(CXSC_INDEX_CHECK)
4181 ;
4182 #else
4183  noexcept;
4184 #endif
4186  INLINE l_imatrix operator &(const l_imatrix &m,const imatrix_slice &ms)
4187 #if(CXSC_INDEX_CHECK)
4188 ;
4189 #else
4190  noexcept;
4191 #endif
4193  INLINE l_imatrix operator &(const imatrix_slice &ms,const l_imatrix &m)
4194 #if(CXSC_INDEX_CHECK)
4195 ;
4196 #else
4197  noexcept;
4198 #endif
4200  INLINE l_imatrix operator &(const l_imatrix_slice &ms,const imatrix &m)
4201 #if(CXSC_INDEX_CHECK)
4202 ;
4203 #else
4204  noexcept;
4205 #endif
4207  INLINE l_imatrix operator &(const imatrix_slice &m1,const l_imatrix_slice &m2)
4208 #if(CXSC_INDEX_CHECK)
4209 ;
4210 #else
4211  noexcept;
4212 #endif
4214  INLINE l_imatrix operator &(const l_imatrix_slice &m1,const imatrix_slice &m2)
4215 #if(CXSC_INDEX_CHECK)
4216 ;
4217 #else
4218  noexcept;
4219 #endif
4221  INLINE l_imatrix &operator &=(l_imatrix &m1,const imatrix &m2)
4222 #if(CXSC_INDEX_CHECK)
4223 ;
4224 #else
4225  noexcept;
4226 #endif
4228  INLINE l_imatrix &operator &=(l_imatrix &m1,const imatrix_slice &ms)
4229 #if(CXSC_INDEX_CHECK)
4230 ;
4231 #else
4232  noexcept;
4233 #endif
4234 
4235  //---------- l_rmatrix-imatrix ------------------
4237  INLINE l_imatrix operator +(const l_rmatrix &m1,const imatrix &m2)
4238 #if(CXSC_INDEX_CHECK)
4239 ;
4240 #else
4241  noexcept;
4242 #endif
4244  INLINE l_imatrix operator +(const imatrix &m1,const l_rmatrix &m2)
4245 #if(CXSC_INDEX_CHECK)
4246 ;
4247 #else
4248  noexcept;
4249 #endif
4251  INLINE l_imatrix operator +(const l_rmatrix &m,const imatrix_slice &ms)
4252 #if(CXSC_INDEX_CHECK)
4253 ;
4254 #else
4255  noexcept;
4256 #endif
4258  INLINE l_imatrix operator +(const imatrix &m,const l_rmatrix_slice &ms)
4259 #if(CXSC_INDEX_CHECK)
4260 ;
4261 #else
4262  noexcept;
4263 #endif
4265  INLINE l_imatrix operator +(const l_rmatrix_slice &ms,const imatrix &m)
4266 #if(CXSC_INDEX_CHECK)
4267 ;
4268 #else
4269  noexcept;
4270 #endif
4272  INLINE l_imatrix operator +(const imatrix_slice &ms,const l_rmatrix &m)
4273 #if(CXSC_INDEX_CHECK)
4274 ;
4275 #else
4276  noexcept;
4277 #endif
4279  INLINE l_imatrix operator +(const l_rmatrix_slice &m1,const imatrix_slice &m2)
4280 #if(CXSC_INDEX_CHECK)
4281 ;
4282 #else
4283  noexcept;
4284 #endif
4286  INLINE l_imatrix operator +(const imatrix_slice &m1,const l_rmatrix_slice &m2)
4287 #if(CXSC_INDEX_CHECK)
4288 ;
4289 #else
4290  noexcept;
4291 #endif
4292 
4294  INLINE l_imatrix operator -(const l_rmatrix &m1,const imatrix &m2)
4295 #if(CXSC_INDEX_CHECK)
4296 ;
4297 #else
4298  noexcept;
4299 #endif
4301  INLINE l_imatrix operator -(const imatrix &m1,const l_rmatrix &m2)
4302 #if(CXSC_INDEX_CHECK)
4303 ;
4304 #else
4305  noexcept;
4306 #endif
4308  INLINE l_imatrix operator -(const l_rmatrix &m,const imatrix_slice &ms)
4309 #if(CXSC_INDEX_CHECK)
4310 ;
4311 #else
4312  noexcept;
4313 #endif
4315  INLINE l_imatrix operator -(const imatrix &m,const l_rmatrix_slice &ms)
4316 #if(CXSC_INDEX_CHECK)
4317 ;
4318 #else
4319  noexcept;
4320 #endif
4322  INLINE l_imatrix operator -(const l_rmatrix_slice &ms,const imatrix &m)
4323 #if(CXSC_INDEX_CHECK)
4324 ;
4325 #else
4326  noexcept;
4327 #endif
4329  INLINE l_imatrix operator -(const imatrix_slice &ms,const l_rmatrix &m)
4330 #if(CXSC_INDEX_CHECK)
4331 ;
4332 #else
4333  noexcept;
4334 #endif
4336  INLINE l_imatrix operator -(const l_rmatrix_slice &ms1,const imatrix_slice &ms2)
4337 #if(CXSC_INDEX_CHECK)
4338 ;
4339 #else
4340  noexcept;
4341 #endif
4343  INLINE l_imatrix operator -(const imatrix_slice &ms1,const l_rmatrix_slice &ms2)
4344 #if(CXSC_INDEX_CHECK)
4345 ;
4346 #else
4347  noexcept;
4348 #endif
4349 
4351  INLINE l_imatrix operator *(const l_rmatrix &m1, const imatrix &m2)
4352 #if(CXSC_INDEX_CHECK)
4353 ;
4354 #else
4355  noexcept;
4356 #endif
4358  INLINE l_imatrix operator *(const imatrix &m1, const l_rmatrix &m2)
4359 #if(CXSC_INDEX_CHECK)
4360 ;
4361 #else
4362  noexcept;
4363 #endif
4365  INLINE l_imatrix operator *(const l_rmatrix &m1, const imatrix_slice &ms)
4366 #if(CXSC_INDEX_CHECK)
4367 ;
4368 #else
4369  noexcept;
4370 #endif
4372  INLINE l_imatrix operator *(const imatrix &m1, const l_rmatrix_slice &ms)
4373 #if(CXSC_INDEX_CHECK)
4374 ;
4375 #else
4376  noexcept;
4377 #endif
4379  INLINE l_imatrix operator *(const l_rmatrix_slice &ms, const imatrix &m1)
4380 #if(CXSC_INDEX_CHECK)
4381 ;
4382 #else
4383  noexcept;
4384 #endif
4386  INLINE l_imatrix operator *(const imatrix_slice &ms, const l_rmatrix &m1)
4387 #if(CXSC_INDEX_CHECK)
4388 ;
4389 #else
4390  noexcept;
4391 #endif
4393  INLINE l_imatrix operator *(const l_rmatrix_slice &ms1, const imatrix_slice &ms2)
4394 #if(CXSC_INDEX_CHECK)
4395 ;
4396 #else
4397  noexcept;
4398 #endif
4400  INLINE l_imatrix operator *(const imatrix_slice &ms1, const l_rmatrix_slice &ms2)
4401 #if(CXSC_INDEX_CHECK)
4402 ;
4403 #else
4404  noexcept;
4405 #endif
4406 
4408  INLINE l_imatrix operator |(const l_rmatrix &m1,const imatrix &m2)
4409 #if(CXSC_INDEX_CHECK)
4410 ;
4411 #else
4412  noexcept;
4413 #endif
4415  INLINE l_imatrix operator |(const imatrix &m1,const l_rmatrix &m2)
4416 #if(CXSC_INDEX_CHECK)
4417 ;
4418 #else
4419  noexcept;
4420 #endif
4422  INLINE l_imatrix operator |(const l_rmatrix &m,const imatrix_slice &ms)
4423 #if(CXSC_INDEX_CHECK)
4424 ;
4425 #else
4426  noexcept;
4427 #endif
4429  INLINE l_imatrix operator |(const imatrix &m,const l_rmatrix_slice &ms)
4430 #if(CXSC_INDEX_CHECK)
4431 ;
4432 #else
4433  noexcept;
4434 #endif
4436  INLINE l_imatrix operator |(const l_rmatrix_slice &ms,const imatrix &m)
4437 #if(CXSC_INDEX_CHECK)
4438 ;
4439 #else
4440  noexcept;
4441 #endif
4443  INLINE l_imatrix operator |(const imatrix_slice &ms,const l_rmatrix &m)
4444 #if(CXSC_INDEX_CHECK)
4445 ;
4446 #else
4447  noexcept;
4448 #endif
4450  INLINE l_imatrix operator |(const l_rmatrix_slice &m1,const imatrix_slice &m2)
4451 #if(CXSC_INDEX_CHECK)
4452 ;
4453 #else
4454  noexcept;
4455 #endif
4457  INLINE l_imatrix operator |(const imatrix_slice &m1,const l_rmatrix_slice &m2)
4458 #if(CXSC_INDEX_CHECK)
4459 ;
4460 #else
4461  noexcept;
4462 #endif
4463 
4465  INLINE l_imatrix operator &(const l_rmatrix &m1,const imatrix &m2)
4466 #if(CXSC_INDEX_CHECK)
4467 ;
4468 #else
4469  noexcept;
4470 #endif
4472  INLINE l_imatrix operator &(const imatrix &m1,const l_rmatrix &m2)
4473 #if(CXSC_INDEX_CHECK)
4474 ;
4475 #else
4476  noexcept;
4477 #endif
4479  INLINE l_imatrix operator &(const l_rmatrix &m,const imatrix_slice &ms)
4480 #if(CXSC_INDEX_CHECK)
4481 ;
4482 #else
4483  noexcept;
4484 #endif
4486  INLINE l_imatrix operator &(const imatrix &m,const l_rmatrix_slice &ms)
4487 #if(CXSC_INDEX_CHECK)
4488 ;
4489 #else
4490  noexcept;
4491 #endif
4493  INLINE l_imatrix operator &(const l_rmatrix_slice &ms,const imatrix &m)
4494 #if(CXSC_INDEX_CHECK)
4495 ;
4496 #else
4497  noexcept;
4498 #endif
4500  INLINE l_imatrix operator &(const imatrix_slice &ms,const l_rmatrix &m)
4501 #if(CXSC_INDEX_CHECK)
4502 ;
4503 #else
4504  noexcept;
4505 #endif
4507  INLINE l_imatrix operator &(const l_rmatrix_slice &m1,const imatrix_slice &m2)
4508 #if(CXSC_INDEX_CHECK)
4509 ;
4510 #else
4511  noexcept;
4512 #endif
4514  INLINE l_imatrix operator &(const imatrix_slice &m1,const l_rmatrix_slice &m2)
4515 #if(CXSC_INDEX_CHECK)
4516 ;
4517 #else
4518  noexcept;
4519 #endif
4520 
4521 //------------- real x l_real ------------------------
4523  INLINE l_imatrix operator |(const rmatrix &rv1, const l_rmatrix &rv2)
4524 #if(CXSC_INDEX_CHECK)
4525 ;
4526 #else
4527  noexcept;
4528 #endif
4530  INLINE l_imatrix operator |(const l_rmatrix &rv1, const rmatrix &rv2)
4531 #if(CXSC_INDEX_CHECK)
4532 ;
4533 #else
4534  noexcept;
4535 #endif
4537  INLINE l_imatrix operator |(const l_rmatrix &rv, const rmatrix_slice &sl)
4538 #if(CXSC_INDEX_CHECK)
4539 ;
4540 #else
4541  noexcept;
4542 #endif
4544  INLINE l_imatrix operator |(const rmatrix_slice &sl,const l_rmatrix &rv)
4545 #if(CXSC_INDEX_CHECK)
4546 ;
4547 #else
4548  noexcept;
4549 #endif
4551  INLINE l_imatrix operator |(const l_rmatrix_slice &sl, const rmatrix &rv)
4552 #if(CXSC_INDEX_CHECK)
4553 ;
4554 #else
4555  noexcept;
4556 #endif
4558  INLINE l_imatrix operator |(const rmatrix &rv,const l_rmatrix_slice &sl)
4559 #if(CXSC_INDEX_CHECK)
4560 ;
4561 #else
4562  noexcept;
4563 #endif
4565  INLINE l_imatrix operator |(const l_rmatrix_slice &sl1, const rmatrix_slice &sl2)
4566 #if(CXSC_INDEX_CHECK)
4567 ;
4568 #else
4569  noexcept;
4570 #endif
4572  INLINE l_imatrix operator |(const rmatrix_slice &sl1, const l_rmatrix_slice &sl2)
4573 #if(CXSC_INDEX_CHECK)
4574 ;
4575 #else
4576  noexcept;
4577 #endif
4578 
4579 
4580 //------------- l_real x l_real ------------------------
4582  INLINE l_imatrix operator |(const l_rmatrix &rv1, const l_rmatrix &rv2)
4583 #if(CXSC_INDEX_CHECK)
4584 ;
4585 #else
4586  noexcept;
4587 #endif
4589  INLINE l_imatrix operator |(const l_rmatrix &rv1, const l_rmatrix &rv2)
4590 #if(CXSC_INDEX_CHECK)
4591 ;
4592 #else
4593  noexcept;
4594 #endif
4596  INLINE l_imatrix operator |(const l_rmatrix &rv, const l_rmatrix_slice &sl)
4597 #if(CXSC_INDEX_CHECK)
4598 ;
4599 #else
4600  noexcept;
4601 #endif
4603  INLINE l_imatrix operator |(const l_rmatrix_slice &sl,const l_rmatrix &rv)
4604 #if(CXSC_INDEX_CHECK)
4605 ;
4606 #else
4607  noexcept;
4608 #endif
4610  INLINE l_imatrix operator |(const l_rmatrix_slice &sl, const l_rmatrix &rv)
4611 #if(CXSC_INDEX_CHECK)
4612 ;
4613 #else
4614  noexcept;
4615 #endif
4617  INLINE l_imatrix operator |(const l_rmatrix &rv,const l_rmatrix_slice &sl)
4618 #if(CXSC_INDEX_CHECK)
4619 ;
4620 #else
4621  noexcept;
4622 #endif
4624  INLINE l_imatrix operator |(const l_rmatrix_slice &sl1, const l_rmatrix_slice &sl2)
4625 #if(CXSC_INDEX_CHECK)
4626 ;
4627 #else
4628  noexcept;
4629 #endif
4631  INLINE l_imatrix operator |(const l_rmatrix_slice &sl1, const l_rmatrix_slice &sl2)
4632 #if(CXSC_INDEX_CHECK)
4633 ;
4634 #else
4635  noexcept;
4636 #endif
4637 
4638 
4639 //============== Compare Operator ==========================
4640 
4641 //-------------- Matrix - Matrix -------------------------
4642 
4644  INLINE bool operator ==(const l_imatrix &m1,const l_imatrix &m2) noexcept;
4646  INLINE bool operator !=(const l_imatrix &m1,const l_imatrix &m2) noexcept;
4648  INLINE bool operator <(const l_imatrix &m1,const l_imatrix &m2) noexcept;
4650  INLINE bool operator <=(const l_imatrix &m1,const l_imatrix &m2) noexcept;
4652  INLINE bool operator >(const l_imatrix &m1,const l_imatrix &m2) noexcept;
4654  INLINE bool operator >=(const l_imatrix &m1,const l_imatrix &m2) noexcept;
4656  INLINE bool operator ==(const l_imatrix &m1,const l_imatrix_slice &ms) noexcept;
4658  INLINE bool operator !=(const l_imatrix &m1,const l_imatrix_slice &ms) noexcept;
4660  INLINE bool operator <(const l_imatrix &m1,const l_imatrix_slice &ms) noexcept;
4662  INLINE bool operator <=(const l_imatrix &m1,const l_imatrix_slice &ms) noexcept;
4664  INLINE bool operator >(const l_imatrix &m1,const l_imatrix_slice &ms) noexcept;
4666  INLINE bool operator >=(const l_imatrix &m1,const l_imatrix_slice &ms) noexcept;
4667 
4668 //---------------- Matrix - Matrix_slice ----------------------
4669 
4671  INLINE bool operator ==(const l_imatrix_slice &m1,const l_imatrix_slice &m2) noexcept;
4673  INLINE bool operator !=(const l_imatrix_slice &m1,const l_imatrix_slice &m2) noexcept;
4675  INLINE bool operator <(const l_imatrix_slice &m1,const l_imatrix_slice &m2) noexcept;
4677  INLINE bool operator <=(const l_imatrix_slice &m1,const l_imatrix_slice &m2) noexcept;
4679  INLINE bool operator >(const l_imatrix_slice &m1,const l_imatrix_slice &m2) noexcept;
4681  INLINE bool operator >=(const l_imatrix_slice &m1,const l_imatrix_slice &m2) noexcept;
4682 
4683 //=================== Not Operator =============================
4684 
4686  INLINE bool operator !(const l_imatrix &ms) noexcept;
4688  INLINE bool operator !(const l_imatrix_slice &ms) noexcept;
4689 
4690 //======================== Input / Output ========================
4691 
4693  INLINE std::ostream &operator <<(std::ostream &s,const l_imatrix &r) noexcept;
4695  INLINE std::ostream &operator <<(std::ostream &s,const l_imatrix_slice &r) noexcept;
4697  INLINE std::istream &operator >>(std::istream &s,l_imatrix &r) noexcept;
4699  INLINE std::istream &operator >>(std::istream &s,l_imatrix_slice &r) noexcept;
4700 
4702  l_imatrix Id ( const l_imatrix& );
4704  l_imatrix transp ( const l_imatrix& );
4706  l_real MaxRelDiam ( const l_imatrix_subv& );
4708  INLINE int RowLen ( const l_imatrix& );
4710  INLINE int ColLen ( const l_imatrix& );
4712  INLINE int RowLen ( const l_imatrix_slice& );
4714  INLINE int ColLen ( const l_imatrix_slice& );
4716  void DoubleSize ( l_imatrix& );
4717 
4718 } // namespace cxsc
4719 
4720 #ifdef _CXSC_INCL_INL
4721 #include "matrix.inl"
4722 #include "l_imatrix.inl"
4723 #endif
4724 
4725 
4726 #endif
4727 
The Data Type idotprecision.
Definition: idot.hpp:48
The Data Type imatrix_slice.
Definition: imatrix.hpp:1442
The Data Type imatrix_subv.
Definition: imatrix.hpp:56
The Data Type imatrix.
Definition: imatrix.hpp:660
The Scalar Type interval.
Definition: interval.hpp:55
The Data Type ivector_slice.
Definition: ivector.hpp:963
The Data Type ivector.
Definition: ivector.hpp:55
The Multiple-Precision Data Type l_imatrix_slice.
Definition: l_imatrix.hpp:1280
l_imatrix_subv operator[](const int &i) noexcept
Operator for accessing a single row of the matrix.
Definition: l_imatrix.inl:348
l_imatrix_slice & operator/=(const l_interval &c) noexcept
Implementation of division and allocation operation.
Definition: l_imatrix.inl:1553
l_imatrix_slice & operator+=(const l_interval &c) noexcept
Implementation of addition and allocation operation.
l_imatrix_slice & operator=(const l_imatrix &m) noexcept
Implementation of standard assigning operator.
Definition: l_imatrix.inl:522
l_imatrix_slice(l_imatrix_slice &a, const int &l1, const int &u1, const int &l2, const int &u2) noexcept
Constructor of class l_imatrix_slice.
Definition: l_imatrix.hpp:1576
l_imatrix_slice & operator*=(const l_interval &c) noexcept
Implementation of multiplication and allocation operation.
Definition: l_imatrix.inl:1549
l_imatrix_slice(const l_imatrix_slice &ms) noexcept
Constructor of class l_imatrix_slice.
Definition: l_imatrix.hpp:1579
l_imatrix_slice & operator&=(const l_imatrix &m1) noexcept
Allocates the intersection of the arguments to the first argument.
Definition: l_imatrix.inl:2173
l_imatrix_slice & operator|=(const l_imatrix &m1) noexcept
Allocates the convex hull of the arguments to the first argument.
Definition: l_imatrix.inl:2117
l_imatrix_slice & operator()() noexcept
Operator for accessing the whole matrix.
Definition: l_imatrix.hpp:1760
l_imatrix_slice(l_imatrix &a, const int &l1, const int &u1, const int &l2, const int &u2) noexcept
Constructor of class l_imatrix_slice.
Definition: l_imatrix.hpp:1574
l_imatrix_slice & operator-=(const l_interval &c) noexcept
Implementation of subtraction and allocation operation.
The Multiple-Precision Data Type l_imatrix_subv.
Definition: l_imatrix.hpp:47
l_imatrix_subv & operator/=(const l_interval &c) noexcept
Implementation of division and allocation operation.
Definition: l_imatrix.inl:677
l_interval & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector.
Definition: l_imatrix.inl:185
l_imatrix_subv & operator()() noexcept
Operator for accessing the whole vector.
Definition: l_imatrix.hpp:436
friend int Lb(const l_imatrix_subv &rv) noexcept
Returns the lower bound of the vector.
Definition: l_imatrix.hpp:425
l_imatrix_subv & operator&=(const l_ivector &rv) noexcept
Allocates the intersection of the arguments to the first argument.
Definition: l_imatrix.inl:972
l_imatrix_subv(l_interval *d, const int &l, const int &u, const int &s, const int &st, const int &o) noexcept
Constructor of class l_imatrix_subv.
Definition: l_imatrix.hpp:282
l_imatrix_subv & operator=(const l_imatrix_subv &rv) noexcept
Implementation of standard assigning operator.
Definition: l_imatrix.inl:428
friend l_imatrix_subv Row(l_imatrix &m, const int &i) noexcept
Returns one row of the matrix as a vector.
Definition: l_imatrix.inl:252
l_imatrix_subv(const l_imatrix_subv &v) noexcept
Constructor of class l_imatrix_subv.
Definition: l_imatrix.hpp:285
l_imatrix_subv & operator+=(const l_interval &c) noexcept
Implementation of addition and allocation operation.
Definition: l_imatrix.inl:675
friend l_imatrix_subv Col(l_imatrix &m, const int &i) noexcept
Returns one column of the matrix as a vector.
Definition: l_imatrix.inl:263
l_imatrix_subv & operator-=(const l_interval &c) noexcept
Implementation of subtraction and allocation operation.
Definition: l_imatrix.inl:676
l_imatrix_subv & operator*=(const l_interval &c) noexcept
Implementation of multiplication and allocation operation.
Definition: l_imatrix.inl:674
friend int Ub(const l_imatrix_subv &rv) noexcept
Returns the upper bound of the vector.
Definition: l_imatrix.hpp:427
l_imatrix_subv & operator|=(const l_ivector &rv) noexcept
Allocates the convex hull of the arguments to the first argument.
Definition: l_imatrix.inl:923
The Multiple-Precision Data Type l_imatrix.
Definition: l_imatrix.hpp:726
l_imatrix & operator()() noexcept
Operator for accessing the whole matrix.
Definition: l_imatrix.hpp:1252
l_imatrix & operator=(const l_interval &r) noexcept
Implementation of standard assigning operator.
Definition: l_imatrix.inl:496
l_imatrix_subv operator[](const int &i) const noexcept
Operator for accessing a single row of the matrix.
Definition: l_imatrix.inl:296
l_imatrix() noexcept
Constructor of class l_imatrix.
Definition: l_imatrix.inl:31
The Multiple-Precision Data Type l_interval.
Definition: l_interval.hpp:72
The Multiple-Precision Data Type l_ivector_slice.
Definition: l_ivector.hpp:871
The Multiple-Precision Data Type l_ivector.
Definition: l_ivector.hpp:55
l_ivector() noexcept
Constructor of class l_ivector.
Definition: l_ivector.inl:31
The Multiple-Precision Data Type l_real.
Definition: l_real.hpp:78
The Multiple-Precision Data Type l_rmatrix_slice.
Definition: l_rmatrix.hpp:1000
The Multiple-Precision Data Type l_rmatrix_subv.
Definition: l_rmatrix.hpp:47
The Multiple-Precision Data Type l_rmatrix.
Definition: l_rmatrix.hpp:416
The Multiple-Precision Data Type l_rvector_slice.
Definition: l_rvector.hpp:745
The Multiple-Precision Data Type l_rvector.
Definition: l_rvector.hpp:54
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
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
int ColLen(const cimatrix &)
Returns the column dimension.
Definition: cimatrix.inl:1202
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
int Ub(const cimatrix &rm, const int &i) noexcept
Returns the upper bound index.
Definition: cimatrix.inl:1163
cimatrix & SetLb(cimatrix &m, const int &i, const int &j) noexcept
Sets the lower bound index.
Definition: cimatrix.inl:1184
int RowLen(const cimatrix &)
Returns the row dimension.
Definition: cimatrix.inl:1199
void DoubleSize(cimatrix &A)
Doubles the size of the matrix.
Definition: cimatrix.cpp:83
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc) noexcept
Implementation of standard algebraic addition and allocation operation.
Definition: cdot.inl:251
cimatrix Id(const cimatrix &A)
Returns the Identity matrix.
Definition: cimatrix.cpp:61
cimatrix _imatrix(const cimatrix &rm) noexcept
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC.
Definition: cimatrix.inl:1137
cimatrix & operator*=(cimatrix &m, const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
Definition: cimatrix.inl:1605
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737
cvector mid(const cimatrix_subv &mv) noexcept
Returns the middle of the matrix.
Definition: cimatrix.inl:739
civector operator*(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of multiplication operation.
Definition: cimatrix.inl:731
void Resize(cimatrix &A) noexcept
Resizes the matrix.
Definition: cimatrix.inl:1211
cimatrix_subv & SetUncheckedInf(cimatrix_subv &iv, const complex &r) noexcept
Returns the matrix with the new unchecked given infimum value.
Definition: cimatrix.inl:890
cimatrix & SetUb(cimatrix &m, const int &i, const int &j) noexcept
Sets the upper bound index.
Definition: cimatrix.inl:1191
int Lb(const cimatrix &rm, const int &i) noexcept
Returns the lower bound index.
Definition: cimatrix.inl:1156
cimatrix & operator/=(cimatrix &m, const cinterval &c) noexcept
Implementation of division and allocation operation.
Definition: cimatrix.inl:1623