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
37namespace cxsc {
38
39class l_imatrix;
40class 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 ---------------------------------------
88template <class MV1,class MV2> friend MV1 &_mvmvassign(MV1 &v,const MV2 &rv)
89#if(CXSC_INDEX_CHECK)
90;
91#else
92 noexcept;
93#endif
94template <class MV,class S> friend MV &_mvsassign(MV &v,const S &r) noexcept;
95template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
96#if(CXSC_INDEX_CHECK)
97;
98#else
99 noexcept;
100#endif
101template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) noexcept;
102template <class MV,class V> friend MV &_mvvsetinf(MV &v,const V &rv)
103#if(CXSC_INDEX_CHECK)
104;
105#else
106 noexcept;
107#endif
108template <class MV,class V> friend MV &_mvvsetsup(MV &v,const V &rv)
109#if(CXSC_INDEX_CHECK)
110;
111#else
112 noexcept;
113#endif
114template <class MV,class V> friend MV &_mvvusetinf(MV &v,const V &rv)
115#if(CXSC_INDEX_CHECK)
116;
117#else
118 noexcept;
119#endif
120template <class MV,class V> friend MV &_mvvusetsup(MV &v,const V &rv)
121#if(CXSC_INDEX_CHECK)
122;
123#else
124 noexcept;
125#endif
126template <class MV,class V> friend MV &_mvvsetre(MV &v,const V &rv)
127#if(CXSC_INDEX_CHECK)
128;
129#else
130 noexcept;
131#endif
132template <class MV,class V> friend MV &_mvvsetim(MV &v,const V &rv)
133#if(CXSC_INDEX_CHECK)
134;
135#else
136 noexcept;
137#endif
138template <class MV,class V> friend V _mvabs(const MV &mv) noexcept;
139template <class MV,class V> friend V _mvdiam(const MV &mv) noexcept;
140template <class MV,class V> friend V _mvmid(const MV &mv) noexcept;
141template <class MV,class V> friend V _mvinf(const MV &mv) noexcept;
142template <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
149template <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
155template <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;
205template <class MV,class S> friend MV &_mvsmultassign(MV &v,const S &r) noexcept;
206template <class MV, class S> friend MV &_mvsplusassign(MV &v,const S &r) noexcept;
207template <class MV,class S> friend MV &_mvsminusassign(MV &v,const S &r) noexcept;
208template <class MV,class S> friend MV &_mvsdivassign(MV &v,const S &r) noexcept;
209template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
210#if(CXSC_INDEX_CHECK)
211;
212#else
213 noexcept;
214#endif
215template <class V,class MV> friend V &_vmvplusassign(V &rv,const MV &v)
216#if(CXSC_INDEX_CHECK)
217;
218#else
219 noexcept;
220#endif
221template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv)
222#if(CXSC_INDEX_CHECK)
223;
224#else
225 noexcept;
226#endif
227template <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
245template <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
263template <class MV,class V> friend MV &_mvvsectassign(MV &v,const V &rv)
264#if(CXSC_INDEX_CHECK)
265;
266#else
267 noexcept;
268#endif
269template <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
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
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
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
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
476#if(CXSC_INDEX_CHECK)
477;
478#else
479 noexcept;
480#endif
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
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
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
606#if(CXSC_INDEX_CHECK)
607;
608#else
609 noexcept;
610#endif
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
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
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
719class 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 ---------------------------------------
737template <class S,class M> friend void _smconstr(S &s,const M &m)
738#if(CXSC_INDEX_CHECK)
739;
740#else
741 noexcept;
742#endif
743template <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;
758template <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
764template <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 ---------------------------------------
1291template <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
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
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.
l_imatrix_subv operator[](const int &i) noexcept
Operator for accessing a single row of the matrix.
l_imatrix_slice & operator/=(const l_interval &c) noexcept
Implementation of division and allocation operation.
l_imatrix_slice & operator=(const l_imatrix &m) noexcept
Implementation of standard assigning operator.
l_imatrix_slice & operator()() noexcept
Operator for accessing the whole matrix.
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.
l_imatrix_slice & operator*=(const l_interval &c) noexcept
Implementation of multiplication and allocation operation.
l_imatrix_slice(const l_imatrix_slice &ms) noexcept
Constructor of class l_imatrix_slice.
l_imatrix_slice & operator&=(const l_imatrix &m1) noexcept
Allocates the intersection of the arguments to the first argument.
l_imatrix_slice & operator|=(const l_imatrix &m1) noexcept
Allocates the convex hull of the arguments to the first argument.
l_imatrix_slice & operator-=(const l_interval &c) noexcept
Implementation of subtraction and allocation operation.
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.
l_imatrix_slice & operator+=(const l_interval &c) noexcept
Implementation of addition 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.
l_interval & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector.
friend l_imatrix_subv Row(l_imatrix &m, const int &i) noexcept
Returns one row of the matrix as a vector.
friend int Lb(const l_imatrix_subv &rv) noexcept
Returns the lower bound of the vector.
l_imatrix_subv & operator()() noexcept
Operator for accessing the whole vector.
l_imatrix_subv & operator&=(const l_ivector &rv) noexcept
Allocates the intersection of the arguments to the first argument.
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.
l_imatrix_subv & operator=(const l_imatrix_subv &rv) noexcept
Implementation of standard assigning operator.
l_imatrix_subv(const l_imatrix_subv &v) noexcept
Constructor of class l_imatrix_subv.
l_imatrix_subv & operator+=(const l_interval &c) noexcept
Implementation of addition and allocation operation.
l_imatrix_subv & operator-=(const l_interval &c) noexcept
Implementation of subtraction and allocation operation.
l_imatrix_subv & operator*=(const l_interval &c) noexcept
Implementation of multiplication and allocation operation.
friend int Ub(const l_imatrix_subv &rv) noexcept
Returns the upper bound of the vector.
friend l_imatrix_subv Col(l_imatrix &m, const int &i) noexcept
Returns one column of the matrix as a vector.
l_imatrix_subv & operator|=(const l_ivector &rv) noexcept
Allocates the convex hull of the arguments to the first argument.
The Multiple-Precision Data Type l_imatrix.
l_imatrix & operator=(const l_interval &r) noexcept
Implementation of standard assigning operator.
l_imatrix_subv operator[](const int &i) const noexcept
Operator for accessing a single row of the matrix.
l_imatrix() noexcept
Constructor of class l_imatrix.
Definition l_imatrix.inl:31
l_imatrix & operator()() noexcept
Operator for accessing the whole matrix.
The Multiple-Precision Data Type l_interval.
The Multiple-Precision Data Type l_ivector_slice.
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.
The Multiple-Precision Data Type l_rmatrix_subv.
Definition l_rmatrix.hpp:47
The Multiple-Precision Data Type l_rmatrix.
The Multiple-Precision Data Type l_rvector_slice.
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
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc) noexcept
Implementation of standard algebraic addition and allocation operation.
Definition cdot.inl:251
int ColLen(const cimatrix &)
Returns the column dimension.
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.
cimatrix & SetLb(cimatrix &m, const int &i, const int &j) noexcept
Sets the lower bound index.
int RowLen(const cimatrix &)
Returns the row dimension.
void DoubleSize(cimatrix &A)
Doubles the size of the matrix.
Definition cimatrix.cpp:83
cimatrix Id(const cimatrix &A)
Returns the Identity matrix.
Definition cimatrix.cpp:61
cimatrix _imatrix(const cimatrix &rm) noexcept
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC.
cimatrix & operator*=(cimatrix &m, const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
Definition cimatrix.inl:737
cvector mid(const cimatrix_subv &mv) noexcept
Returns the middle of the matrix.
Definition cimatrix.inl:739
civector operator*(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of multiplication operation.
Definition cimatrix.inl:731
void Resize(cimatrix &A) noexcept
Resizes the matrix.
cimatrix_subv & SetUncheckedInf(cimatrix_subv &iv, const complex &r) noexcept
Returns the matrix with the new unchecked given infimum value.
Definition cimatrix.inl:890
cimatrix & SetUb(cimatrix &m, const int &i, const int &j) noexcept
Sets the upper bound index.
int Lb(const cimatrix &rm, const int &i) noexcept
Returns the lower bound index.
cimatrix & operator/=(cimatrix &m, const cinterval &c) noexcept
Implementation of division and allocation operation.