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