C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
rmatrix.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: rmatrix.hpp,v 1.46 2014/01/30 17:23:48 cxsc Exp $ */
25 
26 #ifndef _CXSC_RMATRIX_HPP_INCLUDED
27 #define _CXSC_RMATRIX_HPP_INCLUDED
28 
29 #include "xscclass.hpp"
30 
31 #include "dot.hpp"
32 #include "idot.hpp"
33 #include "cidot.hpp"
34 #include "rvector.hpp"
35 #include "except.hpp"
36 #include "matrix.hpp"
37 
38 namespace cxsc {
39 
40 class rmatrix;
41 class rmatrix_slice;
42 class srmatrix;
43 class srmatrix_slice;
44 class srmatrix_subv;
45 class srvector;
46 class srvector_slice;
47 
48 
50 
54 {
55  friend class rvector;
56  friend class ivector; // wegen ivector::ivector(const rmatrix_subv &)
57  friend class cvector;
58  friend class civector;
59  friend class l_rvector;
60  friend class l_ivector;
61  friend class rmatrix;
62  friend class rmatrix_slice;
63  private:
64  real *dat;
65  int lb,ub;
66  int size,start,offset; // start=first element index 0..n-1
67 
68  public:
70  friend INLINE rmatrix_subv Row(rmatrix &m,const int &i)
71 #if(CXSC_INDEX_CHECK)
72 ;
73 #else
74  noexcept;
75 #endif
76  friend INLINE rmatrix_subv Col(rmatrix &m,const int &i)
78 #if(CXSC_INDEX_CHECK)
79 ;
80 #else
81  noexcept;
82 #endif
83  friend INLINE rmatrix_subv Row(const rmatrix &m,const int &i)
85 #if(CXSC_INDEX_CHECK)
86 ;
87 #else
88  noexcept;
89 #endif
90  friend INLINE rmatrix_subv Col(const rmatrix &m,const int &i)
92 #if(CXSC_INDEX_CHECK)
93 ;
94 #else
95  noexcept;
96 #endif
97 
98 //#if(CXSC_INDEX_CHECK)
99 
100 
101 #ifdef _CXSC_FRIEND_TPL
102  //----------------- Templates ---------------------------------------
103 template <class MV1,class MV2> friend MV1 &_mvmvassign(MV1 &v,const MV2 &rv)
104 #if(CXSC_INDEX_CHECK)
105 ;
106 #else
107  noexcept;
108 #endif
109 template <class MV,class S> friend MV &_mvsassign(MV &v,const S &r) noexcept;
110 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
111 #if(CXSC_INDEX_CHECK)
112 ;
113 #else
114  noexcept;
115 #endif
116 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) noexcept;
117 template <class MV,class V> friend V _mvabs(const MV &mv) noexcept;
118 template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
119 #if(CXSC_INDEX_CHECK)
120  ;
121 #else
122  noexcept;
123 #endif
124 
125 template <class DP,class MV1,class MV2> friend void _mvmvaccu(DP &dp, const MV1 & rv1, const MV2 &rv2)
126 #if(CXSC_INDEX_CHECK)
127  ;
128 #else
129  noexcept;
130 #endif
131 
132  template <class MV1,class MV2,class S> friend S _mvmvmult(const MV1 & rv1, const MV2 &rv2)
133 #if(CXSC_INDEX_CHECK)
134  ;
135 #else
136  noexcept;
137 #endif
138  template <class V,class MV,class S> friend S _vmvmult(const V &rv1, const MV &rv2)
139 #if(CXSC_INDEX_CHECK)
140  ;
141 #else
142  noexcept;
143 #endif
144  template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) noexcept;
145  template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
146 #if(CXSC_INDEX_CHECK)
147  ;
148 #else
149  noexcept;
150 #endif
151  template <class MV1,class MV2,class E> friend E _mvmvminus(const MV1 &rv1, const MV2 &rv2)
152 #if(CXSC_INDEX_CHECK)
153  ;
154 #else
155  noexcept;
156 #endif
157  template <class MV,class V,class E> friend E _mvvplus(const MV &rv1, const V &rv2)
158 #if(CXSC_INDEX_CHECK)
159  ;
160 #else
161  noexcept;
162 #endif
163  template <class MV,class V,class E> friend E _mvvminus(const MV &rv1, const V &rv2)
164 #if(CXSC_INDEX_CHECK)
165  ;
166 #else
167  noexcept;
168 #endif
169  template <class V,class MV,class E> friend E _vmvminus(const V &rv1, const MV &rv2)
170 #if(CXSC_INDEX_CHECK)
171  ;
172 #else
173  noexcept;
174 #endif
175  template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) noexcept;
176 template <class MV,class S> friend MV &_mvsmultassign(MV &v,const S &r) noexcept;
177 template <class MV, class S> friend MV &_mvsplusassign(MV &v,const S &r) noexcept;
178 template <class MV,class S> friend MV &_mvsminusassign(MV &v,const S &r) noexcept;
179 template <class MV,class S> friend MV &_mvsdivassign(MV &v,const S &r) noexcept;
180 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
181 #if(CXSC_INDEX_CHECK)
182 ;
183 #else
184  noexcept;
185 #endif
186 template <class V,class MV> friend V &_vmvplusassign(V &rv,const MV &v)
187 #if(CXSC_INDEX_CHECK)
188 ;
189 #else
190  noexcept;
191 #endif
192 template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv)
193 #if(CXSC_INDEX_CHECK)
194 ;
195 #else
196  noexcept;
197 #endif
198 template <class V,class MV> friend V &_vmvminusassign(V &rv,const MV &v)
199 #if(CXSC_INDEX_CHECK)
200 ;
201 #else
202  noexcept;
203 #endif
204  template <class MV1,class MV2,class E> friend E _mvmvconv(const MV1 &rv1, const MV2 &rv2)
205 #if(CXSC_INDEX_CHECK)
206  ;
207 #else
208  noexcept;
209 #endif
210  template <class MV,class V,class E> friend E _mvvconv(const MV &rv1, const V &rv2)
211 #if(CXSC_INDEX_CHECK)
212  ;
213 #else
214  noexcept;
215 #endif
216 
217  // interval
218 
219 
220 template <class V,class MV> friend V &_vmvsetinf(V &rv,const MV &v)
221 #if(CXSC_INDEX_CHECK)
222 ;
223 #else
224  noexcept;
225 #endif
226 template <class V,class MV> friend V &_vmvsetsup(V &rv,const MV &v)
227 #if(CXSC_INDEX_CHECK)
228 ;
229 #else
230  noexcept;
231 #endif
232 template <class V,class MV> friend V &_vmvusetinf(V &rv,const MV &v)
233 #if(CXSC_INDEX_CHECK)
234 ;
235 #else
236  noexcept;
237 #endif
238 template <class V,class MV> friend V &_vmvusetsup(V &rv,const MV &v)
239 #if(CXSC_INDEX_CHECK)
240 ;
241 #else
242  noexcept;
243 #endif
244 
245  // complex
246 
247 
248 template <class V,class MV> friend V &_vmvsetim(V &rv,const MV &v)
249 #if(CXSC_INDEX_CHECK)
250 ;
251 #else
252  noexcept;
253 #endif
254 template <class V,class MV> friend V &_vmvsetre(V &rv,const MV &v)
255 #if(CXSC_INDEX_CHECK)
256 ;
257 #else
258  noexcept;
259 #endif
260 
261 #endif
262 
263  //----------------- Konstruktoren ----------------------------------
264 
266  explicit INLINE rmatrix_subv (real *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) { }
267  public:
269  INLINE rmatrix_subv(const rmatrix_subv &v) noexcept:dat(v.dat),lb(v.lb),ub(v.ub),size(v.size),start(v.start),offset(v.offset) { }
270  public:
271 
272  //---------------------- Standardfunktionen ------------------------
273 
274  friend INLINE rvector::rvector(const rmatrix_subv &) noexcept;
276  INLINE rmatrix_subv &operator =(const rmatrix_subv &rv) noexcept;
278  INLINE rmatrix_subv &operator =(const real &r) noexcept;
280  INLINE rmatrix_subv &operator =(const srmatrix_subv &m);
282  INLINE rmatrix_subv &operator =(const srvector &m);
284  INLINE rmatrix_subv &operator =(const srvector_slice &m);
286  INLINE rmatrix_subv &operator =(const rmatrix &m)
287 #if(CXSC_INDEX_CHECK)
288 ;
289 #else
290  noexcept;
291 #endif
292  INLINE rmatrix_subv &operator =(const rmatrix_slice &m)
294 #if(CXSC_INDEX_CHECK)
295 ;
296 #else
297  noexcept;
298 #endif
299  INLINE rmatrix_subv &operator =(const rvector &v)
301 #if(CXSC_INDEX_CHECK)
302 ;
303 #else
304  noexcept;
305 #endif
306  INLINE rmatrix_subv &operator =(const rvector_slice &v)
308 #if(CXSC_INDEX_CHECK)
309 ;
310 #else
311  noexcept;
312 #endif
313  friend INLINE int Lb(const rmatrix_subv &rv) noexcept { return rv.lb; }
316  friend INLINE int Ub(const rmatrix_subv &rv) noexcept { return rv.ub; }
318  friend INLINE int VecLen(const rmatrix_subv &rv) noexcept { return rv.size; }
319 
321  INLINE real &operator [](const int &i) const
322 #if(CXSC_INDEX_CHECK)
323 ;
324 #else
325  noexcept;
326 #endif
327 
329  INLINE real &operator [](const int &i)
330 #if(CXSC_INDEX_CHECK)
331 ;
332 #else
333  noexcept;
334 #endif
335 
337  INLINE rmatrix_subv &operator ()() noexcept { return *this; }
339  INLINE rmatrix_subv operator ()(const int &i)
340 #if(CXSC_INDEX_CHECK)
341 ;
342 #else
343  noexcept;
344 #endif
345  INLINE rmatrix_subv operator ()(const int &i1,const int &i2)
347 #if(CXSC_INDEX_CHECK)
348 ;
349 #else
350  noexcept;
351 #endif
352 
354  INLINE rmatrix_subv &operator *=(const real &c) noexcept;
356  INLINE rmatrix_subv &operator +=(const real &c) noexcept;
358  INLINE rmatrix_subv &operator -=(const real &c) noexcept;
360  INLINE rmatrix_subv &operator /=(const real &c) noexcept;
361 
363  INLINE rmatrix_subv &operator +=(const srvector &rv);
365  INLINE rmatrix_subv &operator +=(const srvector_slice &rv);
367  INLINE rmatrix_subv &operator +=(const srmatrix_subv &rv);
368 
370  INLINE rmatrix_subv &operator -=(const srvector &rv);
374  INLINE rmatrix_subv &operator -=(const srmatrix_subv &rv);
375 
377  INLINE rmatrix_subv &operator -=(const rvector &rv)
378 #if(CXSC_INDEX_CHECK)
379 ;
380 #else
381  noexcept;
382 #endif
383  INLINE rmatrix_subv &operator -=(const rvector_slice &rv)
385 #if(CXSC_INDEX_CHECK)
386 ;
387 #else
388  noexcept;
389 #endif
390  INLINE rmatrix_subv &operator +=(const rvector &rv)
392 #if(CXSC_INDEX_CHECK)
393 ;
394 #else
395  noexcept;
396 #endif
397  INLINE rmatrix_subv &operator +=(const rvector_slice &rv)
399 #if(CXSC_INDEX_CHECK)
400 ;
401 #else
402  noexcept;
403 #endif
404 //#else
405 //#endif
406 
407 };
408 
409 
411 INLINE rmatrix_subv Row(rmatrix &m,const int &i)
412 #if(CXSC_INDEX_CHECK)
413 ;
414 #else
415  noexcept;
416 #endif
417 
419 INLINE rmatrix_subv Col(rmatrix &m,const int &i)
420 #if(CXSC_INDEX_CHECK)
421 ;
422 #else
423  noexcept;
424 #endif
425 
427 INLINE rmatrix_subv Row(const rmatrix &m,const int &i)
428 #if(CXSC_INDEX_CHECK)
429 ;
430 #else
431  noexcept;
432 #endif
433 
435 INLINE rmatrix_subv Col(const rmatrix &m,const int &i)
436 #if(CXSC_INDEX_CHECK)
437 ;
438 #else
439  noexcept;
440 #endif
441 
442 
443 //----------------------- Matrix -----------------------------------------------
444 
445 class rmatrix_slice;
446 
448 
470 class rmatrix
471 {
472  friend class rmatrix_slice;
473  friend class rmatrix_subv;
474  friend class imatrix;
475  friend class cmatrix;
476  friend class cimatrix;
477  friend class l_rmatrix;
478  friend class l_imatrix;
479  private:
480  real *dat;
481  int lb1,ub1,lb2,ub2,xsize,ysize;
482 
483  public:
484  double* to_blas_array() const { return (double*)dat; }
485 //#if(CXSC_INDEX_CHECK)
486 #ifdef _CXSC_FRIEND_TPL
487  //----------------- Templates ---------------------------------------
488 template <class S,class M> friend void _smconstr(S &s,const M &m)
489 #if(CXSC_INDEX_CHECK)
490 ;
491 #else
492  noexcept;
493 #endif
494 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
495 #if(CXSC_INDEX_CHECK)
496 ;
497 #else
498  noexcept;
499 #endif
500  template <class M1,class M2,class S> friend M1 &_mmassign(M1 &m1,const M2 &m,S ms) noexcept;
501  template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) noexcept;
502  template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m)
503 #if(CXSC_INDEX_CHECK)
504  ;
505 #else
506  noexcept;
507 #endif
508  template <class M,class S> friend M &_msassign(M &m,const S &r) noexcept;
509 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m)
510 #if(CXSC_INDEX_CHECK)
511 ;
512 #else
513  noexcept;
514 #endif
515 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) noexcept;
516  template <class M> friend int _mlb(const M &m, const int &i)
517 #if(CXSC_INDEX_CHECK)
518 ;
519 #else
520  noexcept;
521 #endif
522  template <class M> friend int _mub(const M &m, const int &i)
523 #if(CXSC_INDEX_CHECK)
524 ;
525 #else
526  noexcept;
527 #endif
528  template <class M> friend M &_msetlb(M &m, const int &i,const int &j)
529 #if(CXSC_INDEX_CHECK)
530 ;
531 #else
532  noexcept;
533 #endif
534  template <class M> friend M &_msetub(M &m, const int &i,const int &j)
535 #if(CXSC_INDEX_CHECK)
536 ;
537 #else
538  noexcept;
539 #endif
540  template <class M> friend void _mresize(M &A) noexcept;
541  template <class M,class S> friend void _mresize(M &A,const int &m, const int &n)
542 #if(CXSC_INDEX_CHECK)
543  ;
544 #else
545  noexcept;
546 #endif
547  template <class M,class S> friend void _mresize(M &A,const int &m1, const int &m2,const int &n1,const int &n2)
548 #if(CXSC_INDEX_CHECK)
549  ;
550 #else
551  noexcept;
552 #endif
553  template <class M,class E> friend E _mabs(const M &m) noexcept;
554  template <class MS,class E> friend E _msabs(const MS &ms) noexcept;
555  //------- matrix-matrix --------------
556  template <class M1,class M2,class E> friend E _mmplus(const M1 &m1,const M2 &m2)
557 #if(CXSC_INDEX_CHECK)
558  ;
559 #else
560  noexcept;
561 #endif
562  template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms)
563 #if(CXSC_INDEX_CHECK)
564  ;
565 #else
566  noexcept;
567 #endif
568  template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2)
569 #if(CXSC_INDEX_CHECK)
570  ;
571 #else
572  noexcept;
573 #endif
574  template <class M> friend M _mminus(const M &m) noexcept;
575  template <class MS,class E> friend E _msminus(const MS &ms) noexcept;
576  template <class M1,class M2,class E> friend E _mmminus(const M1 &m1,const M2 &m2)
577 #if(CXSC_INDEX_CHECK)
578  ;
579 #else
580  noexcept;
581 #endif
582  template <class M1,class M2> friend M1 &_mmplusassign(M1 &m1,const M2 &m2)
583 #if(CXSC_INDEX_CHECK)
584  ;
585 #else
586  noexcept;
587 #endif
588  template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms)
589 #if(CXSC_INDEX_CHECK)
590  ;
591 #else
592  noexcept;
593 #endif
594  template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1)
595 #if(CXSC_INDEX_CHECK)
596  ;
597 #else
598  noexcept;
599 #endif
600  template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms)
601 #if(CXSC_INDEX_CHECK)
602  ;
603 #else
604  noexcept;
605 #endif
606  template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m)
607 #if(CXSC_INDEX_CHECK)
608  ;
609 #else
610  noexcept;
611 #endif
612  template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2)
613 #if(CXSC_INDEX_CHECK)
614  ;
615 #else
616  noexcept;
617 #endif
618  template <class M1,class M2> friend M1 &_mmminusassign(M1 &m1,const M2 &m2)
619 #if(CXSC_INDEX_CHECK)
620  ;
621 #else
622  noexcept;
623 #endif
624  template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms)
625 #if(CXSC_INDEX_CHECK)
626  ;
627 #else
628  noexcept;
629 #endif
630  template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1)
631 #if(CXSC_INDEX_CHECK)
632  ;
633 #else
634  noexcept;
635 #endif
636  template <class M1,class M2,class E> friend E _mmmult(const M1 &m1, const M2 &m2)
637 #if(CXSC_INDEX_CHECK)
638  ;
639 #else
640  noexcept;
641 #endif
642  template <class M1,class M2,class S> friend M1 &_mmmultassign(M1 &m1,const M2 &m2)
643 #if(CXSC_INDEX_CHECK)
644  ;
645 #else
646  noexcept;
647 #endif
648  template <class M,class MS,class E> friend E _mmsmult(const M &m1, const MS &ms)
649 #if(CXSC_INDEX_CHECK)
650  ;
651 #else
652  noexcept;
653 #endif
654  template <class MS,class M,class E> friend E _msmmult(const MS &ms, const M &m2)
655 #if(CXSC_INDEX_CHECK)
656  ;
657 #else
658  noexcept;
659 #endif
660  template <class M,class MS,class S> friend M &_mmsmultassign(M &m1,const MS &ms)
661 #if(CXSC_INDEX_CHECK)
662  ;
663 #else
664  noexcept;
665 #endif
666  template <class MS1,class MS2,class E> friend E _msmsmult(const MS1 &ms1, const MS2 &ms2)
667 #if(CXSC_INDEX_CHECK)
668  ;
669 #else
670  noexcept;
671 #endif
672  template <class M1,class M2,class E> friend E _mmconv(const M1 &m1,const M2 &m2)
673 #if(CXSC_INDEX_CHECK)
674  ;
675 #else
676  noexcept;
677 #endif
678  template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms)
679 #if(CXSC_INDEX_CHECK)
680  ;
681 #else
682  noexcept;
683 #endif
684  //-------- matrix-scalar ---------------------
685  template <class S,class M,class E> friend E _smmult(const S &c, const M &m) noexcept;
686  template <class M,class S> friend M &_msmultassign(M &m,const S &c) noexcept;
687  template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) noexcept;
688  template <class M,class S,class E> friend E _msdiv(const M &m,const S &c) noexcept;
689  template <class M,class S> friend M &_msdivassign(M &m,const S &c) noexcept;
690  template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) noexcept;
691  //--------- matrix-vector --------------------
692  template <class M,class V,class E> friend E _mvmult(const M &m,const V &v)
693 #if(CXSC_INDEX_CHECK)
694  ;
695 #else
696  noexcept;
697 #endif
698  template <class V,class M,class E> friend E _vmmult(const V &v,const M &m)
699 #if(CXSC_INDEX_CHECK)
700  ;
701 #else
702  noexcept;
703 #endif
704  template <class V,class M,class S> friend V &_vmmultassign(V &v,const M &m)
705 #if(CXSC_INDEX_CHECK)
706  ;
707 #else
708  noexcept;
709 #endif
710  template <class VS,class M,class S> friend VS &_vsmmultassign(VS &v,const M &m)
711 #if(CXSC_INDEX_CHECK)
712  ;
713 #else
714  noexcept;
715 #endif
716 
717  template <class M> friend void *_mvoid(const M &m) noexcept;
718  template <class M> friend bool _mnot(const M &m) noexcept;
719  template <class MS> friend void *_msvoid(const MS &ms) noexcept;
720  template <class MS> friend bool _msnot(const MS &ms) noexcept;
721  template <class M1,class M2> friend bool _mmeq(const M1 &m1,const M2 &m2) noexcept;
722  template <class M1,class M2> friend bool _mmneq(const M1 &m1,const M2 &m2) noexcept;
723  template <class M1,class M2> friend bool _mmless(const M1 &m1,const M2 &m2) noexcept;
724  template <class M1,class M2> friend bool _mmleq(const M1 &m1,const M2 &m2) noexcept;
725  template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) noexcept;
726  template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) noexcept;
727  template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) noexcept;
728  template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) noexcept;
729  template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) noexcept;
730  template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) noexcept;
731  template <class M> friend std::ostream &_mout(std::ostream &s,const M &r) noexcept;
732  template <class M> friend std::istream &_min(std::istream &s,M &r) noexcept;
733 
734  // Interval
735 
736 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
737 #if(CXSC_INDEX_CHECK)
738 ;
739 #else
740  noexcept;
741 #endif
742 
743  template <class M,class E> friend E _mdiam(const M &m) noexcept;
744  template <class M,class E> friend E _mmid(const M &m) noexcept;
745  template <class MS,class E> friend E _msdiam(const MS &ms) noexcept;
746  template <class MS,class E> friend E _msmid(const MS &ms) noexcept;
747  template <class M,class E> friend E _minf(const M &m) noexcept;
748  template <class M,class E> friend E _msup(const M &m) noexcept;
749  template <class M1,class M2> friend M1 &_mmsetinf(M1 &m1,const M2 &m2)
750 #if(CXSC_INDEX_CHECK)
751  ;
752 #else
753  noexcept;
754 #endif
755  template <class M1,class M2> friend M1 &_mmsetsup(M1 &m1,const M2 &m2)
756 #if(CXSC_INDEX_CHECK)
757  ;
758 #else
759  noexcept;
760 #endif
761  template <class M1,class M2> friend M1 &_mmusetinf(M1 &m1,const M2 &m2)
762 #if(CXSC_INDEX_CHECK)
763  ;
764 #else
765  noexcept;
766 #endif
767  template <class M1,class M2> friend M1 &_mmusetsup(M1 &m1,const M2 &m2)
768 #if(CXSC_INDEX_CHECK)
769  ;
770 #else
771  noexcept;
772 #endif
773  template <class MS,class E> friend E _msinf(const MS &ms) noexcept;
774  template <class MS,class E> friend E _mssup(const MS &ms) noexcept;
775  template <class MS1,class M2> friend MS1 &_msmsetinf(MS1 &ms1,const M2 &m2)
776 #if(CXSC_INDEX_CHECK)
777  ;
778 #else
779  noexcept;
780 #endif
781  template <class MS1,class M2> friend MS1 &_msmsetsup(MS1 &ms1,const M2 &m2)
782 #if(CXSC_INDEX_CHECK)
783  ;
784 #else
785  noexcept;
786 #endif
787  template <class MS1,class M2> friend MS1 &_msmusetinf(MS1 &ms1,const M2 &m2)
788 #if(CXSC_INDEX_CHECK)
789  ;
790 #else
791  noexcept;
792 #endif
793  template <class MS1,class M2> friend MS1 &_msmusetsup(MS1 &ms1,const M2 &m2)
794 #if(CXSC_INDEX_CHECK)
795  ;
796 #else
797  noexcept;
798 #endif
799  //--- Interval -------- matrix-matrix --------------
800 
801  template <class M1,class M2,class E> friend E _mmimult(const M1 &m1, const M2 &m2)
802 #if(CXSC_INDEX_CHECK)
803  ;
804 #else
805  noexcept;
806 #endif
807 
808  template <class M1,class M2,class S> friend M1 &_mmimultassign(M1 &m1,const M2 &m2)
809 #if(CXSC_INDEX_CHECK)
810  ;
811 #else
812  noexcept;
813 #endif
814  template <class M,class MS,class E> friend E _mmsimult(const M &m1, const MS &ms)
815 #if(CXSC_INDEX_CHECK)
816  ;
817 #else
818  noexcept;
819 #endif
820 
821  template <class MS,class M,class E> friend E _msmimult(const MS &ms, const M &m2)
822 #if(CXSC_INDEX_CHECK)
823  ;
824 #else
825  noexcept;
826 #endif
827 
828  template <class M,class MS,class S> friend M &_mmsimultassign(M &m1,const MS &ms)
829 #if(CXSC_INDEX_CHECK)
830  ;
831 #else
832  noexcept;
833 #endif
834  template <class MS1,class MS2,class E> friend E _msmsimult(const MS1 &ms1, const MS2 &ms2)
835 #if(CXSC_INDEX_CHECK)
836  ;
837 #else
838  noexcept;
839 #endif
840 
841  template <class M1,class M2> friend M1 &_mmconvassign(M1 &m1,const M2 &m2)
842 #if(CXSC_INDEX_CHECK)
843  ;
844 #else
845  noexcept;
846 #endif
847  template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms)
848 #if(CXSC_INDEX_CHECK)
849  ;
850 #else
851  noexcept;
852 #endif
853  template <class MS,class M> friend MS &_msmconvassign(MS &ms,const M &m1)
854 #if(CXSC_INDEX_CHECK)
855  ;
856 #else
857  noexcept;
858 #endif
859  template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2)
860 #if(CXSC_INDEX_CHECK)
861  ;
862 #else
863  noexcept;
864 #endif
865  template <class M1,class M2,class E> friend E _mmsect(const M1 &m1,const M2 &m2)
866 #if(CXSC_INDEX_CHECK)
867  ;
868 #else
869  noexcept;
870 #endif
871  template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms)
872 #if(CXSC_INDEX_CHECK)
873  ;
874 #else
875  noexcept;
876 #endif
877 
878  template <class M1,class M2> friend M1 &_mmsectassign(M1 &m1,const M2 &m2)
879 #if(CXSC_INDEX_CHECK)
880  ;
881 #else
882  noexcept;
883 #endif
884  template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms)
885 #if(CXSC_INDEX_CHECK)
886  ;
887 #else
888  noexcept;
889 #endif
890  template <class MS,class M> friend MS &_msmsectassign(MS &ms,const M &m1)
891 #if(CXSC_INDEX_CHECK)
892  ;
893 #else
894  noexcept;
895 #endif
896  template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2)
897 #if(CXSC_INDEX_CHECK)
898  ;
899 #else
900  noexcept;
901 #endif
902  //--- Interval -------- matrix-vector --------------
903  template <class M,class V,class E> friend E _mvimult(const M &m,const V &v)
904 #if(CXSC_INDEX_CHECK)
905  ;
906 #else
907  noexcept;
908 #endif
909  template <class MS,class V,class E> friend E _msvimult(const MS &ms,const V &v)
910 #if(CXSC_INDEX_CHECK)
911  ;
912 #else
913  noexcept;
914 #endif
915  template <class V,class MS,class E> friend E _vmsimult(const V &v,const MS &ms)
916 #if(CXSC_INDEX_CHECK)
917  ;
918 #else
919  noexcept;
920 #endif
921 
922 
923  template <class V,class M,class E> friend E _vmimult(const V &v,const M &m)
924 #if(CXSC_INDEX_CHECK)
925  ;
926 #else
927  noexcept;
928 #endif
929  template <class V,class M,class S> friend V &_vmimultassign(V &v,const M &m)
930 #if(CXSC_INDEX_CHECK)
931  ;
932 #else
933  noexcept;
934 #endif
935  template <class VS,class M,class S> friend VS &_vsmimultassign(VS &v,const M &m)
936 #if(CXSC_INDEX_CHECK)
937  ;
938 #else
939  noexcept;
940 #endif
941 
942 
943  // complex
944 
945  template <class M,class E> friend E _mre(const M &m) noexcept;
946  template <class M,class E> friend E _mim(const M &m) noexcept;
947  template <class M1,class M2> friend M1 &_mmsetre(M1 &m1,const M2 &m2)
948 #if(CXSC_INDEX_CHECK)
949  ;
950 #else
951  noexcept;
952 #endif
953  template <class M1,class M2> friend M1 &_mmsetim(M1 &m1,const M2 &m2)
954 #if(CXSC_INDEX_CHECK)
955  ;
956 #else
957  noexcept;
958 #endif
959  template <class MS,class E> friend E _msre(const MS &ms) noexcept;
960  template <class MS,class E> friend E _msim(const MS &ms) noexcept;
961  template <class MS1,class M2> friend MS1 &_msmsetre(MS1 &ms1,const M2 &m2)
962 #if(CXSC_INDEX_CHECK)
963  ;
964 #else
965  noexcept;
966 #endif
967  template <class MS1,class M2> friend MS1 &_msmsetim(MS1 &ms1,const M2 &m2)
968 #if(CXSC_INDEX_CHECK)
969  ;
970 #else
971  noexcept;
972 #endif
973  //--- complex -------- matrix-matrix --------------
974 
975  template <class M1,class M2,class E> friend E _mmcmult(const M1 &m1, const M2 &m2)
976 #if(CXSC_INDEX_CHECK)
977  ;
978 #else
979  noexcept;
980 #endif
981 
982  template <class M1,class M2,class S> friend M1 &_mmcmultassign(M1 &m1,const M2 &m2)
983 #if(CXSC_INDEX_CHECK)
984  ;
985 #else
986  noexcept;
987 #endif
988  template <class M,class MS,class E> friend E _mmscmult(const M &m1, const MS &ms)
989 #if(CXSC_INDEX_CHECK)
990  ;
991 #else
992  noexcept;
993 #endif
994 
995  template <class MS,class M,class E> friend E _msmcmult(const MS &ms, const M &m2)
996 #if(CXSC_INDEX_CHECK)
997  ;
998 #else
999  noexcept;
1000 #endif
1001 
1002  template <class M,class MS,class S> friend M &_mmscmultassign(M &m1,const MS &ms)
1003 #if(CXSC_INDEX_CHECK)
1004  ;
1005 #else
1006  noexcept;
1007 #endif
1008  template <class MS1,class MS2,class E> friend E _msmscmult(const MS1 &ms1, const MS2 &ms2)
1009 #if(CXSC_INDEX_CHECK)
1010  ;
1011 #else
1012  noexcept;
1013 #endif
1014 
1015  //--- complex -------- matrix-vector --------------
1016  template <class M,class V,class E> friend E _mvcmult(const M &m,const V &v)
1017 #if(CXSC_INDEX_CHECK)
1018  ;
1019 #else
1020  noexcept;
1021 #endif
1022  template <class MS,class V,class E> friend E _msvcmult(const MS &ms,const V &v)
1023 #if(CXSC_INDEX_CHECK)
1024  ;
1025 #else
1026  noexcept;
1027 #endif
1028  template <class V,class MS,class E> friend E _vmscmult(const V &v,const MS &ms)
1029 #if(CXSC_INDEX_CHECK)
1030  ;
1031 #else
1032  noexcept;
1033 #endif
1034 
1035  template <class V,class M,class E> friend E _vmcmult(const V &v,const M &m)
1036 #if(CXSC_INDEX_CHECK)
1037  ;
1038 #else
1039  noexcept;
1040 #endif
1041  template <class V,class M,class S> friend V &_vmcmultassign(V &v,const M &m)
1042 #if(CXSC_INDEX_CHECK)
1043  ;
1044 #else
1045  noexcept;
1046 #endif
1047  template <class VS,class M,class S> friend VS &_vsmcmultassign(VS &v,const M &m)
1048 #if(CXSC_INDEX_CHECK)
1049  ;
1050 #else
1051  noexcept;
1052 #endif
1053 
1054 
1055  // cinterval
1056 
1058  friend INLINE rmatrix SupRe(const cimatrix &v) noexcept;
1060  friend INLINE rmatrix SupIm(const cimatrix &v) noexcept;
1062  friend INLINE rmatrix InfRe(const cimatrix &v) noexcept;
1064  friend INLINE rmatrix InfIm(const cimatrix &v) noexcept;
1066  friend INLINE rmatrix SupRe(const cimatrix_slice &v) noexcept;
1068  friend INLINE rmatrix SupIm(const cimatrix_slice &v) noexcept;
1070  friend INLINE rmatrix InfRe(const cimatrix_slice &v) noexcept;
1072  friend INLINE rmatrix InfIm(const cimatrix_slice &v) noexcept;
1073 
1074  //--- cinterval -------- matrix-matrix --------------
1075 
1076  template <class M1,class M2,class E> friend E _mmcimult(const M1 &m1, const M2 &m2)
1077 #if(CXSC_INDEX_CHECK)
1078  ;
1079 #else
1080  noexcept;
1081 #endif
1082  template <class M1,class M2,class S> friend M1 &_mmcimultassign(M1 &m1,const M2 &m2)
1083 #if(CXSC_INDEX_CHECK)
1084  ;
1085 #else
1086  noexcept;
1087 #endif
1088  template <class M,class MS,class E> friend E _mmscimult(const M &m1, const MS &ms)
1089 #if(CXSC_INDEX_CHECK)
1090  ;
1091 #else
1092  noexcept;
1093 #endif
1094  template <class MS,class M,class E> friend E _msmcimult(const MS &ms, const M &m2)
1095 #if(CXSC_INDEX_CHECK)
1096  ;
1097 #else
1098  noexcept;
1099 #endif
1100  template <class M,class MS,class S> friend M &_mmscimultassign(M &m1,const MS &ms)
1101 #if(CXSC_INDEX_CHECK)
1102  ;
1103 #else
1104  noexcept;
1105 #endif
1106  template <class MS1,class MS2,class E> friend E _msmscimult(const MS1 &ms1, const MS2 &ms2)
1107 #if(CXSC_INDEX_CHECK)
1108  ;
1109 #else
1110  noexcept;
1111 #endif
1112 
1113  //--- cinterval -------- matrix-vector --------------
1114  template <class M,class V,class E> friend E _mvcimult(const M &m,const V &v)
1115 #if(CXSC_INDEX_CHECK)
1116  ;
1117 #else
1118  noexcept;
1119 #endif
1120  template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v)
1121 #if(CXSC_INDEX_CHECK)
1122  ;
1123 #else
1124  noexcept;
1125 #endif
1126  template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms)
1127 #if(CXSC_INDEX_CHECK)
1128  ;
1129 #else
1130  noexcept;
1131 #endif
1132 
1133  template <class V,class M,class E> friend E _vmcimult(const V &v,const M &m)
1134 #if(CXSC_INDEX_CHECK)
1135  ;
1136 #else
1137  noexcept;
1138 #endif
1139  template <class V,class M,class S> friend V &_vmcimultassign(V &v,const M &m)
1140 #if(CXSC_INDEX_CHECK)
1141  ;
1142 #else
1143  noexcept;
1144 #endif
1145  template <class VS,class M,class S> friend VS &_vsmcimultassign(VS &v,const M &m)
1146 #if(CXSC_INDEX_CHECK)
1147  ;
1148 #else
1149  noexcept;
1150 #endif
1151 
1152  //--- l_real -------- matrix-matrix --------------
1153 
1154  template <class M1,class M2,class E> friend E _mmlmult(const M1 &m1, const M2 &m2)
1155 #if(CXSC_INDEX_CHECK)
1156  ;
1157 #else
1158  noexcept;
1159 #endif
1160  template <class M1,class M2,class S> friend M1 &_mmlmultassign(M1 &m1,const M2 &m2)
1161 #if(CXSC_INDEX_CHECK)
1162  ;
1163 #else
1164  noexcept;
1165 #endif
1166  template <class M,class MS,class E> friend E _mmslmult(const M &m1, const MS &ms)
1167 #if(CXSC_INDEX_CHECK)
1168  ;
1169 #else
1170  noexcept;
1171 #endif
1172 
1173  template <class MS,class M,class E> friend E _msmlmult(const MS &ms, const M &m2)
1174 #if(CXSC_INDEX_CHECK)
1175  ;
1176 #else
1177  noexcept;
1178 #endif
1179 
1180  template <class M,class MS,class S> friend M &_mmslmultassign(M &m1,const MS &ms)
1181 #if(CXSC_INDEX_CHECK)
1182  ;
1183 #else
1184  noexcept;
1185 #endif
1186  template <class MS1,class MS2,class E> friend E _msmslmult(const MS1 &ms1, const MS2 &ms2)
1187 #if(CXSC_INDEX_CHECK)
1188  ;
1189 #else
1190  noexcept;
1191 #endif
1192  //--- l_real -------- matrix-vector --------------
1193  template <class M,class V,class E> friend E _mvlmult(const M &m,const V &v)
1194 #if(CXSC_INDEX_CHECK)
1195  ;
1196 #else
1197  noexcept;
1198 #endif
1199  template <class MS,class V,class E> friend E _msvlmult(const MS &ms,const V &v)
1200 #if(CXSC_INDEX_CHECK)
1201  ;
1202 #else
1203  noexcept;
1204 #endif
1205  template <class V,class MS,class E> friend E _vmslmult(const V &v,const MS &ms)
1206 #if(CXSC_INDEX_CHECK)
1207  ;
1208 #else
1209  noexcept;
1210 #endif
1211 
1212  template <class V,class M,class E> friend E _vmlmult(const V &v,const M &m)
1213 #if(CXSC_INDEX_CHECK)
1214  ;
1215 #else
1216  noexcept;
1217 #endif
1218  template <class V,class M,class S> friend V &_vmlmultassign(V &v,const M &m)
1219 #if(CXSC_INDEX_CHECK)
1220  ;
1221 #else
1222  noexcept;
1223 #endif
1224 
1225  //--- l_interval -------- matrix-matrix --------------
1226 
1227  template <class M1,class M2,class E> friend E _mmlimult(const M1 &m1, const M2 &m2)
1228 #if(CXSC_INDEX_CHECK)
1229  ;
1230 #else
1231  noexcept;
1232 #endif
1233 
1234  template <class M1,class M2,class S> friend M1 &_mmlimultassign(M1 &m1,const M2 &m2)
1235 #if(CXSC_INDEX_CHECK)
1236  ;
1237 #else
1238  noexcept;
1239 #endif
1240  template <class M,class MS,class E> friend E _mmslimult(const M &m1, const MS &ms)
1241 #if(CXSC_INDEX_CHECK)
1242  ;
1243 #else
1244  noexcept;
1245 #endif
1246 
1247  template <class MS,class M,class E> friend E _msmlimult(const MS &ms, const M &m2)
1248 #if(CXSC_INDEX_CHECK)
1249  ;
1250 #else
1251  noexcept;
1252 #endif
1253 
1254  template <class M,class MS,class S> friend M &_mmslimultassign(M &m1,const MS &ms)
1255 #if(CXSC_INDEX_CHECK)
1256  ;
1257 #else
1258  noexcept;
1259 #endif
1260  template <class MS1,class MS2,class E> friend E _msmslimult(const MS1 &ms1, const MS2 &ms2)
1261 #if(CXSC_INDEX_CHECK)
1262  ;
1263 #else
1264  noexcept;
1265 #endif
1266 
1267 
1268  //--- l_interval -------- matrix-vector --------------
1269  template <class M,class V,class E> friend E _mvlimult(const M &m,const V &v)
1270 #if(CXSC_INDEX_CHECK)
1271  ;
1272 #else
1273  noexcept;
1274 #endif
1275  template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v)
1276 #if(CXSC_INDEX_CHECK)
1277  ;
1278 #else
1279  noexcept;
1280 #endif
1281  template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms)
1282 #if(CXSC_INDEX_CHECK)
1283  ;
1284 #else
1285  noexcept;
1286 #endif
1287 
1288  template <class V,class M,class E> friend E _vmlimult(const V &v,const M &m)
1289 #if(CXSC_INDEX_CHECK)
1290  ;
1291 #else
1292  noexcept;
1293 #endif
1294  template <class V,class M,class S> friend V &_vmlimultassign(V &v,const M &m)
1295 #if(CXSC_INDEX_CHECK)
1296  ;
1297 #else
1298  noexcept;
1299 #endif
1300  template <class VS,class M,class S> friend VS &_vsmlimultassign(VS &v,const M &m)
1301 #if(CXSC_INDEX_CHECK)
1302  ;
1303 #else
1304  noexcept;
1305 #endif
1306 
1307 #endif
1308 
1309  //-------------------------- Konstruktoren ----------------------------
1310 
1312  INLINE rmatrix(const rmatrix &rm) noexcept;
1314  INLINE rmatrix(const rmatrix_slice &rm) noexcept;
1316  INLINE rmatrix() noexcept;
1318  explicit INLINE rmatrix(const int &m, const int &n)
1319 #if(CXSC_INDEX_CHECK)
1320 ;
1321 #else
1322  noexcept;
1323 #endif
1324  explicit INLINE rmatrix(const int &m1, const int &n1, const int &m2, const int &n2)
1326 #if(CXSC_INDEX_CHECK)
1327 ;
1328 #else
1329  noexcept;
1330 #endif
1331  explicit INLINE rmatrix(const rvector &v) noexcept;
1334  explicit INLINE rmatrix(const rvector_slice &v) noexcept;
1336  explicit INLINE rmatrix(const real &r) noexcept;
1338  INLINE rmatrix(const srmatrix&);
1340  INLINE rmatrix(const srmatrix_slice&);
1342  INLINE rmatrix(const intmatrix&);
1343 
1344 
1346  INLINE rmatrix &operator =(const real &r) noexcept;
1348  INLINE rmatrix &operator =(const rmatrix &m) noexcept;
1350  INLINE rmatrix &operator =(const rmatrix_slice &ms) noexcept;
1352  INLINE rmatrix &operator =(const rvector &v) noexcept;
1354  INLINE rmatrix &operator =(const rvector_slice &v) noexcept;
1356  INLINE rmatrix &operator =(const srmatrix&);
1358  INLINE rmatrix &operator =(const srmatrix_slice&);
1359 
1361  INLINE rmatrix &operator *=(const srmatrix &m);
1363  INLINE rmatrix &operator *=(const srmatrix_slice &m);
1365  INLINE rmatrix &operator +=(const srmatrix &m);
1367  INLINE rmatrix &operator +=(const srmatrix_slice &m);
1369  INLINE rmatrix &operator -=(const srmatrix &m);
1371  INLINE rmatrix &operator -=(const srmatrix_slice &m);
1372 
1374  INLINE rmatrix operator()(const intvector& p, const intvector& q);
1376  INLINE rmatrix operator()(const intmatrix& P, const intmatrix& Q);
1378  INLINE rmatrix operator()(const intvector& p);
1380  INLINE rmatrix operator()(const intmatrix& P);
1381 
1382 
1383  //--------------------------- Destruktoren -----------------------------
1384 
1385  INLINE ~rmatrix() noexcept { delete [] dat; }
1386 
1387  //------------------------- Standardfunktionen -------------------------
1388 
1389  friend INLINE real::real(const rmatrix &m)
1390 #if(CXSC_INDEX_CHECK)
1391 ;
1392 #else
1393  noexcept;
1394 #endif
1395  friend INLINE rvector::rvector(const rmatrix &m)
1396 #if(CXSC_INDEX_CHECK)
1397 ;
1398 #else
1399  noexcept;
1400 #endif
1401  INLINE rmatrix_subv operator [](const int &i) const
1403 #if(CXSC_INDEX_CHECK)
1404 ;
1405 #else
1406  noexcept;
1407 #endif
1408  INLINE rmatrix_subv operator [](const cxscmatrix_column &i) const
1410 #if(CXSC_INDEX_CHECK)
1411 ;
1412 #else
1413  noexcept;
1414 #endif
1415  INLINE rmatrix &operator ()() noexcept { return *this; }
1418  INLINE rmatrix_slice operator ()(const int &m, const int &n)
1419 #if(CXSC_INDEX_CHECK)
1420 ;
1421 #else
1422  noexcept;
1423 #endif
1424  INLINE rmatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
1426 #if(CXSC_INDEX_CHECK)
1427 ;
1428 #else
1429  noexcept;
1430 #endif
1431  INLINE operator void*() noexcept;
1432 //#else
1433 //#endif
1434 };
1435 
1437 
1443 {
1444  friend class rmatrix;
1445  friend class imatrix;
1446  friend class cmatrix;
1447  friend class cimatrix;
1448  friend class l_rmatrix;
1449  friend class l_imatrix;
1450  private:
1451  real *dat;
1452  int offset1,offset2,mxsize,mysize;
1453  int start1,end1,start2,end2,sxsize,sysize; // slice size
1454 
1455  public:
1456 //#if(CXSC_INDEX_CHECK)
1457 #ifdef _CXSC_FRIEND_TPL
1458  //----------------- Templates ---------------------------------------
1459 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m)
1460 #if(CXSC_INDEX_CHECK)
1461 ;
1462 #else
1463  noexcept;
1464 #endif
1465  template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m)
1466 #if(CXSC_INDEX_CHECK)
1467  ;
1468 #else
1469  noexcept;
1470 #endif
1471  template <class MS1,class MS2> friend MS1 &_msmsassign(MS1 &ms1,const MS2 &ms)
1472 #if(CXSC_INDEX_CHECK)
1473  ;
1474 #else
1475  noexcept;
1476 #endif
1477  template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) noexcept;
1478  template <class MS,class S> friend MS &_mssassign(MS &ms,const S &r) noexcept;
1479  template <class MS> friend int _mslb(const MS &ms, const int &i)
1480 #if(CXSC_INDEX_CHECK)
1481 ;
1482 #else
1483  noexcept;
1484 #endif
1485  template <class MS> friend int _msub(const MS &ms, const int &i)
1486 #if(CXSC_INDEX_CHECK)
1487 ;
1488 #else
1489  noexcept;
1490 #endif
1491  template <class MS,class E> friend E _msabs(const MS &ms) noexcept;
1492  //------------ matrix-matrix --------------------
1493  template <class MS,class E> friend E _msminus(const MS &ms) noexcept;
1494  template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms)
1495 #if(CXSC_INDEX_CHECK)
1496  ;
1497 #else
1498  noexcept;
1499 #endif
1500  template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2)
1501 #if(CXSC_INDEX_CHECK)
1502  ;
1503 #else
1504  noexcept;
1505 #endif
1506  template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms)
1507 #if(CXSC_INDEX_CHECK)
1508  ;
1509 #else
1510  noexcept;
1511 #endif
1512  template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1)
1513 #if(CXSC_INDEX_CHECK)
1514  ;
1515 #else
1516  noexcept;
1517 #endif
1518  template <class MS1,class MS2> friend MS1 &_msmsplusassign(MS1 &ms1,const MS2 &ms2)
1519 #if(CXSC_INDEX_CHECK)
1520  ;
1521 #else
1522  noexcept;
1523 #endif
1524  template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms)
1525 #if(CXSC_INDEX_CHECK)
1526  ;
1527 #else
1528  noexcept;
1529 #endif
1530  template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m)
1531 #if(CXSC_INDEX_CHECK)
1532  ;
1533 #else
1534  noexcept;
1535 #endif
1536  template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2)
1537 #if(CXSC_INDEX_CHECK)
1538  ;
1539 #else
1540  noexcept;
1541 #endif
1542  template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms)
1543 #if(CXSC_INDEX_CHECK)
1544  ;
1545 #else
1546  noexcept;
1547 #endif
1548  template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1)
1549 #if(CXSC_INDEX_CHECK)
1550  ;
1551 #else
1552  noexcept;
1553 #endif
1554  template <class MS1,class MS2> friend MS1 &_msmsminusassign(MS1 &ms1,const MS2 &ms2)
1555 #if(CXSC_INDEX_CHECK)
1556  ;
1557 #else
1558  noexcept;
1559 #endif
1560  template <class M,class MS,class E> friend E _mmsmult(const M &m1, const MS &ms)
1561 #if(CXSC_INDEX_CHECK)
1562  ;
1563 #else
1564  noexcept;
1565 #endif
1566  template <class MS,class M,class E> friend E _msmmult(const MS &ms, const M &m2)
1567 #if(CXSC_INDEX_CHECK)
1568  ;
1569 #else
1570  noexcept;
1571 #endif
1572  template <class M,class MS,class S> friend M &_mmsmultassign(M &m1,const MS &ms)
1573 #if(CXSC_INDEX_CHECK)
1574  ;
1575 #else
1576  noexcept;
1577 #endif
1578  template <class MS1,class MS2,class E> friend E _msmsmult(const MS1 &ms1, const MS2 &ms2)
1579 #if(CXSC_INDEX_CHECK)
1580  ;
1581 #else
1582  noexcept;
1583 #endif
1584  template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms)
1585 #if(CXSC_INDEX_CHECK)
1586  ;
1587 #else
1588  noexcept;
1589 #endif
1590  template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2)
1591 #if(CXSC_INDEX_CHECK)
1592  ;
1593 #else
1594  noexcept;
1595 #endif
1596  //---------- matrix-vector ------------------------
1597  template <class MS,class V,class E> friend E _msvmult(const MS &ms,const V &v)
1598 #if(CXSC_INDEX_CHECK)
1599  ;
1600 #else
1601  noexcept;
1602 #endif
1603  template <class V,class MS,class E> friend E _vmsmult(const V &v,const MS &ms)
1604 #if(CXSC_INDEX_CHECK)
1605  ;
1606 #else
1607  noexcept;
1608 #endif
1609  template <class V,class MS,class S> friend V &_vmsmultassign(V &v,const MS &ms)
1610 #if(CXSC_INDEX_CHECK)
1611  ;
1612 #else
1613  noexcept;
1614 #endif
1615  //--------- matrix-scalar -----------------
1616  template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) noexcept;
1617  template <class MS,class S> friend MS &_mssmultassign(MS &ms,const S &c) noexcept;
1618  template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) noexcept;
1619  template <class MS,class S> friend MS &_mssdivassign(MS &ms,const S &c) noexcept;
1620 
1621  template <class MS> friend void *_msvoid(const MS &ms) noexcept;
1622  template <class MS> friend bool _msnot(const MS &ms) noexcept;
1623  template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) noexcept;
1624  template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) noexcept;
1625  template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) noexcept;
1626  template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) noexcept;
1627  template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) noexcept;
1628  template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) noexcept;
1629  template <class MS1,class MS2> friend bool _msmseq(const MS1 &ms1,const MS2 &ms2) noexcept;
1630  template <class MS1,class MS2> friend bool _msmsneq(const MS1 &ms1,const MS2 &ms2) noexcept;
1631  template <class MS1,class MS2> friend bool _msmsless(const MS1 &ms1,const MS2 &ms2) noexcept;
1632  template <class MS1,class MS2> friend bool _msmsleq(const MS1 &ms1,const MS2 &ms2) noexcept;
1633  template <class MS> friend std::ostream &_msout(std::ostream &s,const MS &r) noexcept;
1634  template <class MS> friend std::istream &_msin(std::istream &s,MS &r) noexcept;
1635 
1636  // Interval
1637  template <class M1,class MS2> friend M1 &_mmssetinf(M1 &m1,const MS2 &ms2)
1638 #if(CXSC_INDEX_CHECK)
1639  ;
1640 #else
1641  noexcept;
1642 #endif
1643  template <class M1,class MS2> friend M1 &_mmssetsup(M1 &m1,const MS2 &ms2)
1644 #if(CXSC_INDEX_CHECK)
1645  ;
1646 #else
1647  noexcept;
1648 #endif
1649  template <class M1,class MS2> friend M1 &_mmsusetinf(M1 &m1,const MS2 &ms2)
1650 #if(CXSC_INDEX_CHECK)
1651  ;
1652 #else
1653  noexcept;
1654 #endif
1655  template <class M1,class MS2> friend M1 &_mmsusetsup(M1 &m1,const MS2 &ms2)
1656 #if(CXSC_INDEX_CHECK)
1657  ;
1658 #else
1659  noexcept;
1660 #endif
1661  template <class MS1,class MS2> friend MS1 &_msmssetinf(MS1 &ms1,const MS2 &ms2)
1662 #if(CXSC_INDEX_CHECK)
1663  ;
1664 #else
1665  noexcept;
1666 #endif
1667  template <class MS1,class MS2> friend MS1 &_msmssetsup(MS1 &ms1,const MS2 &ms2)
1668 #if(CXSC_INDEX_CHECK)
1669  ;
1670 #else
1671  noexcept;
1672 #endif
1673  template <class MS1,class MS2> friend MS1 &_msmsusetinf(MS1 &ms1,const MS2 &ms2)
1674 #if(CXSC_INDEX_CHECK)
1675  ;
1676 #else
1677  noexcept;
1678 #endif
1679  template <class MS1,class MS2> friend MS1 &_msmsusetsup(MS1 &ms1,const MS2 &ms2)
1680 #if(CXSC_INDEX_CHECK)
1681  ;
1682 #else
1683  noexcept;
1684 #endif
1685  //--- Interval ---------- matrix-vector -----------
1686  template <class MS,class V,class E> friend E _msvimult(const MS &ms,const V &v)
1687 #if(CXSC_INDEX_CHECK)
1688  ;
1689 #else
1690  noexcept;
1691 #endif
1692  template <class V,class MS,class E> friend E _vmsimult(const V &v,const MS &ms)
1693 #if(CXSC_INDEX_CHECK)
1694  ;
1695 #else
1696  noexcept;
1697 #endif
1698  template <class V,class MS,class S> friend V &_vmsimultassign(V &v,const MS &ms)
1699 #if(CXSC_INDEX_CHECK)
1700  ;
1701 #else
1702  noexcept;
1703 #endif
1704  //--- Interval ---------- matrix-matrix ----------
1705 
1706 
1707  template <class M,class MS,class E> friend E _mmsimult(const M &m1, const MS &ms)
1708 #if(CXSC_INDEX_CHECK)
1709  ;
1710 #else
1711  noexcept;
1712 #endif
1713  template <class MS,class M,class E> friend E _msmimult(const MS &ms, const M &m2)
1714 #if(CXSC_INDEX_CHECK)
1715  ;
1716 #else
1717  noexcept;
1718 #endif
1719 
1720  template <class M,class MS,class S> friend M &_mmsimultassign(M &m1,const MS &ms)
1721 #if(CXSC_INDEX_CHECK)
1722  ;
1723 #else
1724  noexcept;
1725 #endif
1726 
1727  template <class MS1,class MS2,class E> friend E _msmsimult(const MS1 &ms1, const MS2 &ms2)
1728 #if(CXSC_INDEX_CHECK)
1729  ;
1730 #else
1731  noexcept;
1732 #endif
1733 
1734  template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms)
1735 #if(CXSC_INDEX_CHECK)
1736  ;
1737 #else
1738  noexcept;
1739 #endif
1740  template <class MS1,class MS2> friend MS1 &_msmsconvassign(MS1 &ms1,const MS2 &ms2)
1741 #if(CXSC_INDEX_CHECK)
1742  ;
1743 #else
1744  noexcept;
1745 #endif
1746  template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms)
1747 #if(CXSC_INDEX_CHECK)
1748  ;
1749 #else
1750  noexcept;
1751 #endif
1752  template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms)
1753 #if(CXSC_INDEX_CHECK)
1754  ;
1755 #else
1756  noexcept;
1757 #endif
1758  template <class MS1,class MS2> friend MS1 &_msmssectassign(MS1 &ms1,const MS2 &ms2)
1759 #if(CXSC_INDEX_CHECK)
1760  ;
1761 #else
1762  noexcept;
1763 #endif
1764  template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2)
1765 #if(CXSC_INDEX_CHECK)
1766  ;
1767 #else
1768  noexcept;
1769 #endif
1770 
1771  // complex
1772 
1773  template <class MS1,class MS2> friend MS1 &_msmssetre(MS1 &ms1,const MS2 &ms2)
1774 #if(CXSC_INDEX_CHECK)
1775  ;
1776 #else
1777  noexcept;
1778 #endif
1779  template <class MS1,class MS2> friend MS1 &_msmssetim(MS1 &ms1,const MS2 &ms2)
1780 #if(CXSC_INDEX_CHECK)
1781  ;
1782 #else
1783  noexcept;
1784 #endif
1785  template <class M1,class MS2> friend M1 &_mmssetre(M1 &m1,const MS2 &ms2)
1786 #if(CXSC_INDEX_CHECK)
1787  ;
1788 #else
1789  noexcept;
1790 #endif
1791  template <class M1,class MS2> friend M1 &_mmssetim(M1 &m1,const MS2 &ms2)
1792 #if(CXSC_INDEX_CHECK)
1793  ;
1794 #else
1795  noexcept;
1796 #endif
1797  //--- complex ---------- matrix-vector -----------
1798  template <class MS,class V,class E> friend E _msvcmult(const MS &ms,const V &v)
1799 #if(CXSC_INDEX_CHECK)
1800  ;
1801 #else
1802  noexcept;
1803 #endif
1804  template <class V,class MS,class E> friend E _vmscmult(const V &v,const MS &ms)
1805 #if(CXSC_INDEX_CHECK)
1806  ;
1807 #else
1808  noexcept;
1809 #endif
1810  template <class V,class MS,class S> friend V &_vmscmultassign(V &v,const MS &ms)
1811 #if(CXSC_INDEX_CHECK)
1812  ;
1813 #else
1814  noexcept;
1815 #endif
1816  //--- complex ---------- matrix-matrix ----------
1817 
1818 
1819  template <class M,class MS,class E> friend E _mmscmult(const M &m1, const MS &ms)
1820 #if(CXSC_INDEX_CHECK)
1821  ;
1822 #else
1823  noexcept;
1824 #endif
1825  template <class MS,class M,class E> friend E _msmcmult(const MS &ms, const M &m2)
1826 #if(CXSC_INDEX_CHECK)
1827  ;
1828 #else
1829  noexcept;
1830 #endif
1831 
1832  template <class M,class MS,class S> friend M &_mmscmultassign(M &m1,const MS &ms)
1833 #if(CXSC_INDEX_CHECK)
1834  ;
1835 #else
1836  noexcept;
1837 #endif
1838  template <class MS1,class MS2,class E> friend E _msmscmult(const MS1 &ms1, const MS2 &ms2)
1839 #if(CXSC_INDEX_CHECK)
1840  ;
1841 #else
1842  noexcept;
1843 #endif
1844 
1845  // cinterval -- matrix-vector
1846  template <class MS,class V,class E> friend E _msvcimult(const MS &ms,const V &v)
1847 #if(CXSC_INDEX_CHECK)
1848  ;
1849 #else
1850  noexcept;
1851 #endif
1852  template <class V,class MS,class E> friend E _vmscimult(const V &v,const MS &ms)
1853 #if(CXSC_INDEX_CHECK)
1854  ;
1855 #else
1856  noexcept;
1857 #endif
1858  template <class V,class MS,class S> friend V &_vmscimultassign(V &v,const MS &ms)
1859 #if(CXSC_INDEX_CHECK)
1860  ;
1861 #else
1862  noexcept;
1863 #endif
1864 
1865  /* friend TINLINE civector _msvscimult<rmatrix_slice,civector_slice,civector>(const rmatrix_slice &ms,const civector_slice &v)
1866 #if(CXSC_INDEX_CHECK)
1867 ;
1868 #else
1869  noexcept;
1870  #endif */
1871  /* friend TINLINE civector _vsmscimult<civector_slice,rmatrix_slice,civector>(const civector_slice &v,const rmatrix_slice &ms)
1872 #if(CXSC_INDEX_CHECK)
1873 ;
1874 #else
1875  noexcept;
1876  #endif */
1877  /* friend TINLINE civector &_vsmscimultassign<civector_slice,rmatrix_slice,interval>(civector_slice &v,const rmatrix_slice &ms)
1878 #if(CXSC_INDEX_CHECK)
1879 ;
1880 #else
1881  noexcept;
1882 #endif */
1883  // cinterval -- matrix-matrix
1884 
1885  template <class M,class MS,class E> friend E _mmscimult(const M &m1, const MS &ms)
1886 #if(CXSC_INDEX_CHECK)
1887  ;
1888 #else
1889  noexcept;
1890 #endif
1891  template <class MS,class M,class E> friend E _msmcimult(const MS &ms, const M &m2)
1892 #if(CXSC_INDEX_CHECK)
1893  ;
1894 #else
1895  noexcept;
1896 #endif
1897  template <class M,class MS,class S> friend M &_mmscimultassign(M &m1,const MS &ms)
1898 #if(CXSC_INDEX_CHECK)
1899  ;
1900 #else
1901  noexcept;
1902 #endif
1903 
1904  template <class MS1,class MS2,class E> friend E _msmscimult(const MS1 &ms1, const MS2 &ms2)
1905 #if(CXSC_INDEX_CHECK)
1906  ;
1907 #else
1908  noexcept;
1909 #endif
1910 
1911  //--- l_real ---------- matrix-vector -----------
1912  template <class MS,class V,class E> friend E _msvlmult(const MS &ms,const V &v)
1913 #if(CXSC_INDEX_CHECK)
1914  ;
1915 #else
1916  noexcept;
1917 #endif
1918  template <class V,class MS,class E> friend E _vmslmult(const V &v,const MS &ms)
1919 #if(CXSC_INDEX_CHECK)
1920  ;
1921 #else
1922  noexcept;
1923 #endif
1924  template <class V,class MS,class S> friend V &_vmslmultassign(V &v,const MS &ms)
1925 #if(CXSC_INDEX_CHECK)
1926  ;
1927 #else
1928  noexcept;
1929 #endif
1930  //--- l_real ---------- matrix-matrix ----------
1931 
1932  template <class M,class MS,class E> friend E _mmslmult(const M &m1, const MS &ms)
1933 #if(CXSC_INDEX_CHECK)
1934  ;
1935 #else
1936  noexcept;
1937 #endif
1938  template <class MS,class M,class E> friend E _msmlmult(const MS &ms, const M &m2)
1939 #if(CXSC_INDEX_CHECK)
1940  ;
1941 #else
1942  noexcept;
1943 #endif
1944 
1945  template <class M,class MS,class S> friend M &_mmslmultassign(M &m1,const MS &ms)
1946 #if(CXSC_INDEX_CHECK)
1947  ;
1948 #else
1949  noexcept;
1950 #endif
1951  template <class MS1,class MS2,class E> friend E _msmslmult(const MS1 &ms1, const MS2 &ms2)
1952 #if(CXSC_INDEX_CHECK)
1953  ;
1954 #else
1955  noexcept;
1956 #endif
1957 
1958  // l_interval -- matrix-vector
1959  template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v)
1960 #if(CXSC_INDEX_CHECK)
1961  ;
1962 #else
1963  noexcept;
1964 #endif
1965  template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms)
1966 #if(CXSC_INDEX_CHECK)
1967  ;
1968 #else
1969  noexcept;
1970 #endif
1971  template <class V,class MS,class S> friend V &_vmslimultassign(V &v,const MS &ms)
1972 #if(CXSC_INDEX_CHECK)
1973  ;
1974 #else
1975  noexcept;
1976 #endif
1977 
1978  /* friend TINLINE l_ivector _msvslimult<rmatrix_slice,l_ivector_slice,l_ivector>(const rmatrix_slice &ms,const l_ivector_slice &v)
1979 #if(CXSC_INDEX_CHECK)
1980 ;
1981 #else
1982  noexcept;
1983  #endif */
1984  /* friend TINLINE l_ivector _vsmslimult<l_ivector_slice,rmatrix_slice,l_ivector>(const l_ivector_slice &v,const rmatrix_slice &ms)
1985 #if(CXSC_INDEX_CHECK)
1986 ;
1987 #else
1988  noexcept;
1989  #endif */
1990  /* friend TINLINE l_ivector &_vsmslimultassign<l_ivector_slice,rmatrix_slice,interval>(l_ivector_slice &v,const rmatrix_slice &ms)
1991 #if(CXSC_INDEX_CHECK)
1992 ;
1993 #else
1994  noexcept;
1995  #endif */
1996  // l_interval -- matrix-matrix
1997 
1998  template <class M,class MS,class E> friend E _mmslimult(const M &m1, const MS &ms)
1999 #if(CXSC_INDEX_CHECK)
2000  ;
2001 #else
2002  noexcept;
2003 #endif
2004  template <class MS,class M,class E> friend E _msmlimult(const MS &ms, const M &m2)
2005 #if(CXSC_INDEX_CHECK)
2006  ;
2007 #else
2008  noexcept;
2009 #endif
2010 
2011  template <class M,class MS,class S> friend M &_mmslimultassign(M &m1,const MS &ms)
2012 #if(CXSC_INDEX_CHECK)
2013  ;
2014 #else
2015  noexcept;
2016 #endif
2017 
2018  template <class MS1,class MS2,class E> friend E _msmslimult(const MS1 &ms1, const MS2 &ms2)
2019 #if(CXSC_INDEX_CHECK)
2020  ;
2021 #else
2022  noexcept;
2023 #endif
2024 
2025 
2026 #endif
2027 
2028 
2029  //--------------- Konstruktoren ----------------------------------------
2030 
2032  explicit INLINE rmatrix_slice(rmatrix &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) { }
2034  explicit INLINE rmatrix_slice(rmatrix_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) { }
2035  public:
2037  INLINE rmatrix_slice(const rmatrix_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) { }
2038  public:
2039 
2040  //---------------- Standardfunktionen -----------------------------------
2041 
2042  friend rvector::rvector(const rmatrix_slice &sl)
2043 #if(CXSC_INDEX_CHECK)
2044 ;
2045 #else
2046  noexcept;
2047 #endif
2048  friend INLINE rmatrix::rmatrix(const rmatrix_slice &) noexcept;
2050  INLINE rmatrix_slice &operator =(const srmatrix &m);
2053 
2055  INLINE rmatrix_slice &operator =(const rmatrix &m)
2056 #if(CXSC_INDEX_CHECK)
2057 ;
2058 #else
2059  noexcept;
2060 #endif
2061  INLINE rmatrix_slice &operator =(const rmatrix_slice &ms)
2063 #if(CXSC_INDEX_CHECK)
2064 ;
2065 #else
2066  noexcept;
2067 #endif
2068  INLINE rmatrix_slice &operator =(const real &r) noexcept;
2071  INLINE rmatrix_slice &operator =(const rvector &v)
2072 #if(CXSC_INDEX_CHECK)
2073 ;
2074 #else
2075  noexcept;
2076 #endif
2077  INLINE rmatrix_slice &operator =(const rvector_slice &v)
2079 #if(CXSC_INDEX_CHECK)
2080 ;
2081 #else
2082  noexcept;
2083 #endif
2084  INLINE rmatrix_slice &operator =(const rmatrix_subv &v)
2086 #if(CXSC_INDEX_CHECK)
2087 ;
2088 #else
2089  noexcept;
2090 #endif
2091  INLINE rmatrix_subv operator [](const int &i) const
2093 #if(CXSC_INDEX_CHECK)
2094 ;
2095 #else
2096  noexcept;
2097 #endif
2098  INLINE rmatrix_subv operator [](const cxscmatrix_column &i) const
2100 #if(CXSC_INDEX_CHECK)
2101 ;
2102 #else
2103  noexcept;
2104 #endif
2105  INLINE rmatrix_slice &operator ()() noexcept { return *this; }
2108  INLINE rmatrix_slice operator ()(const int &m, const int &n)
2109 #if(CXSC_INDEX_CHECK)
2110 ;
2111 #else
2112  noexcept;
2113 #endif
2114  INLINE rmatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
2116 #if(CXSC_INDEX_CHECK)
2117 ;
2118 #else
2119  noexcept;
2120 #endif
2121 
2123  INLINE rmatrix_slice &operator *=(const srmatrix &m);
2125  INLINE rmatrix_slice &operator *=(const srmatrix_slice &m);
2126 
2128  INLINE rmatrix_slice &operator *=(const rmatrix &m)
2129 #if(CXSC_INDEX_CHECK)
2130 ;
2131 #else
2132  noexcept;
2133 #endif
2134  INLINE rmatrix_slice &operator *=(const rmatrix_slice &ms2)
2136 #if(CXSC_INDEX_CHECK)
2137 ;
2138 #else
2139  noexcept;
2140 #endif
2141 
2143  INLINE rmatrix_slice &operator +=(const srmatrix &m);
2145  INLINE rmatrix_slice &operator +=(const srmatrix_slice &m);
2146 
2148  INLINE rmatrix_slice &operator +=(const rmatrix &m1)
2149 #if(CXSC_INDEX_CHECK)
2150 ;
2151 #else
2152  noexcept;
2153 #endif
2154  INLINE rmatrix_slice &operator +=(const rmatrix_slice &ms2)
2156 #if(CXSC_INDEX_CHECK)
2157 ;
2158 #else
2159  noexcept;
2160 #endif
2161 
2163  INLINE rmatrix_slice &operator -=(const srmatrix &m);
2165  INLINE rmatrix_slice &operator -=(const srmatrix_slice &m);
2166 
2168  INLINE rmatrix_slice &operator -=(const rmatrix &m1)
2169 #if(CXSC_INDEX_CHECK)
2170 ;
2171 #else
2172  noexcept;
2173 #endif
2174  INLINE rmatrix_slice &operator -=(const rmatrix_slice &ms2)
2176 #if(CXSC_INDEX_CHECK)
2177 ;
2178 #else
2179  noexcept;
2180 #endif
2181  INLINE rmatrix_slice &operator *=(const real &c) noexcept;
2184  INLINE rmatrix_slice &operator /=(const real &c) noexcept;
2185  INLINE operator void*() noexcept;
2186 //#else
2187 //#endif
2188 };
2189 
2190 //================================================================
2191 //====================== Subvector Functions =====================
2192 
2193 //=======================Vector / Scalar =========================
2194 
2196  INLINE rvector operator /(const rmatrix_subv &rv, const real &s) noexcept;
2198  INLINE rvector operator *(const rmatrix_subv &rv, const real &s) noexcept;
2200  INLINE rvector operator *(const real &s, const rmatrix_subv &rv) noexcept;
2202  INLINE rvector abs(const rmatrix_subv &mv) noexcept;
2203 
2204 //======================== Vector / Vector ========================
2205 
2207  void accumulate(dotprecision &dp, const rmatrix_subv & rv1, const rmatrix_subv &rv2)
2208 #if(CXSC_INDEX_CHECK)
2209 ;
2210 #else
2211  noexcept;
2212 #endif
2213 
2215  void accumulate_approx(dotprecision &dp, const rmatrix_subv & rv1, const rmatrix_subv &rv2);
2216 
2218  void accumulate(dotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2)
2219 #if(CXSC_INDEX_CHECK)
2220 ;
2221 #else
2222  noexcept;
2223 #endif
2224 
2226  void accumulate_approx(dotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2);
2227 
2229  void accumulate(dotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2)
2230 #if(CXSC_INDEX_CHECK)
2231 ;
2232 #else
2233  noexcept;
2234 #endif
2235 
2237  void accumulate_approx(dotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2);
2238 
2240  void accumulate(cdotprecision &dp, const rmatrix_subv & rv1, const rmatrix_subv &rv2)
2241 #if(CXSC_INDEX_CHECK)
2242 ;
2243 #else
2244  noexcept;
2245 #endif
2246 
2248  void accumulate_approx(cdotprecision &dp, const rmatrix_subv & rv1, const rmatrix_subv &rv2);
2249 
2251  void accumulate(cdotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2)
2252 #if(CXSC_INDEX_CHECK)
2253 ;
2254 #else
2255  noexcept;
2256 #endif
2257 
2259  void accumulate_approx(cdotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2);
2260 
2262  void accumulate(cdotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2)
2263 #if(CXSC_INDEX_CHECK)
2264 ;
2265 #else
2266  noexcept;
2267 #endif
2268 
2270  void accumulate_approx(cdotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2);
2271 
2273  void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const rmatrix_subv &rv2)
2274 #if(CXSC_INDEX_CHECK)
2275 ;
2276 #else
2277  noexcept;
2278 #endif
2279  void accumulate(idotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2)
2281 #if(CXSC_INDEX_CHECK)
2282 ;
2283 #else
2284  noexcept;
2285 #endif
2286  void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2)
2288 #if(CXSC_INDEX_CHECK)
2289 ;
2290 #else
2291  noexcept;
2292 #endif
2293  void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const rmatrix_subv &rv2)
2295 #if(CXSC_INDEX_CHECK)
2296 ;
2297 #else
2298  noexcept;
2299 #endif
2300  void accumulate(cidotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2)
2302 #if(CXSC_INDEX_CHECK)
2303 ;
2304 #else
2305  noexcept;
2306 #endif
2307  void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2)
2309 #if(CXSC_INDEX_CHECK)
2310 ;
2311 #else
2312  noexcept;
2313 #endif
2314  void accumulate(dotprecision &dp,const rvector_slice &sl,const rmatrix_subv &sv)
2316 #if(CXSC_INDEX_CHECK)
2317 ;
2318 #else
2319  noexcept;
2320 #endif
2321 
2323  void accumulate_approx(dotprecision &dp,const rvector_slice &sl,const rmatrix_subv &sv);
2324 
2325 
2327  void accumulate(cdotprecision &dp, const rvector_slice & sl1, const rmatrix_subv &rv2)
2328 #if(CXSC_INDEX_CHECK)
2329 ;
2330 #else
2331  noexcept;
2332 #endif
2333 
2335  void accumulate_approx(cdotprecision &dp, const rvector_slice & sl1, const rmatrix_subv &rv2);
2336 
2338  void accumulate(idotprecision &dp, const rvector_slice & sl1, const rmatrix_subv &rv2)
2339 #if(CXSC_INDEX_CHECK)
2340 ;
2341 #else
2342  noexcept;
2343 #endif
2344 
2346  void accumulate(cidotprecision &dp, const rvector_slice & sl1, const rmatrix_subv &rv2)
2347 #if(CXSC_INDEX_CHECK)
2348 ;
2349 #else
2350  noexcept;
2351 #endif
2352 
2354  void accumulate(dotprecision &dp,const rmatrix_subv &mv,const rvector_slice &vs)
2355 #if(CXSC_INDEX_CHECK)
2356 ;
2357 #else
2358  noexcept;
2359 #endif
2360 
2362  void accumulate_approx(dotprecision &dp,const rmatrix_subv &mv,const rvector_slice &vs);
2363 
2364 
2366  void accumulate(cdotprecision &dp, const rmatrix_subv & rv1, const rvector_slice &sl2)
2367 #if(CXSC_INDEX_CHECK)
2368 ;
2369 #else
2370  noexcept;
2371 #endif
2372 
2374  void accumulate_approx(cdotprecision &dp, const rmatrix_subv & rv1, const rvector_slice &sl2);
2375 
2377  void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const rvector_slice &sl2)
2378 #if(CXSC_INDEX_CHECK)
2379 ;
2380 #else
2381  noexcept;
2382 #endif
2383 
2385  void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const rvector_slice &sl2)
2386 #if(CXSC_INDEX_CHECK)
2387 ;
2388 #else
2389  noexcept;
2390 #endif
2391 
2393  INLINE real operator *(const rmatrix_subv & rv1, const rmatrix_subv &rv2)
2394 #if(CXSC_INDEX_CHECK)
2395 ;
2396 #else
2397  noexcept;
2398 #endif
2399  INLINE real operator *(const rvector & rv1, const rmatrix_subv &rv2)
2401 #if(CXSC_INDEX_CHECK)
2402 ;
2403 #else
2404  noexcept;
2405 #endif
2406  INLINE real operator *(const rmatrix_subv &rv1,const rvector &rv2)
2408 #if(CXSC_INDEX_CHECK)
2409 ;
2410 #else
2411  noexcept;
2412 #endif
2413  INLINE real operator *(const rvector_slice &sl,const rmatrix_subv &sv)
2415 #if(CXSC_INDEX_CHECK)
2416 ;
2417 #else
2418  noexcept;
2419 #endif
2420  INLINE real operator *(const rmatrix_subv &mv,const rvector_slice &vs)
2422 #if(CXSC_INDEX_CHECK)
2423 ;
2424 #else
2425  noexcept;
2426 #endif
2427 
2429  INLINE rvector operator +(const rmatrix_subv & rv1, const rmatrix_subv &rv2)
2430 #if(CXSC_INDEX_CHECK)
2431 ;
2432 #else
2433  noexcept;
2434 #endif
2435  INLINE rvector operator +(const rmatrix_subv &rv1,const rvector &rv2)
2437 #if(CXSC_INDEX_CHECK)
2438 ;
2439 #else
2440  noexcept;
2441 #endif
2442  INLINE rvector operator +(const rvector & rv1, const rmatrix_subv &rv2)
2444 #if(CXSC_INDEX_CHECK)
2445 ;
2446 #else
2447  noexcept;
2448 #endif
2449  INLINE rvector operator +(const rvector_slice &sl,const rmatrix_subv &mv)
2451 #if(CXSC_INDEX_CHECK)
2452 ;
2453 #else
2454  noexcept;
2455 #endif
2456  INLINE rvector operator +(const rmatrix_subv &mv,const rvector_slice &sl)
2458 #if(CXSC_INDEX_CHECK)
2459 ;
2460 #else
2461  noexcept;
2462 #endif
2463 
2465  INLINE rvector operator -(const rmatrix_subv & rv1, const rmatrix_subv &rv2)
2466 #if(CXSC_INDEX_CHECK)
2467 ;
2468 #else
2469  noexcept;
2470 #endif
2471  INLINE rvector operator -(const rvector & rv1, const rmatrix_subv &rv2)
2473 #if(CXSC_INDEX_CHECK)
2474 ;
2475 #else
2476  noexcept;
2477 #endif
2478  INLINE rvector operator -(const rmatrix_subv &rv1,const rvector &rv2)
2480 #if(CXSC_INDEX_CHECK)
2481 ;
2482 #else
2483  noexcept;
2484 #endif
2485  INLINE rvector operator -(const rvector_slice &sl,const rmatrix_subv &mv)
2487 #if(CXSC_INDEX_CHECK)
2488 ;
2489 #else
2490  noexcept;
2491 #endif
2492  INLINE rvector operator -(const rmatrix_subv &mv,const rvector_slice &sl)
2494 #if(CXSC_INDEX_CHECK)
2495 ;
2496 #else
2497  noexcept;
2498 #endif
2499 
2500 //====================================================================
2501 //===================== Matrix Functions =============================
2502 
2504  INLINE rmatrix _rmatrix(const rmatrix &rm) noexcept;
2506  INLINE rmatrix _rmatrix(const rvector &v) noexcept;
2508  INLINE rmatrix _rmatrix(const rvector_slice &v) noexcept;
2510  INLINE rmatrix _rmatrix(const real &r) noexcept;
2511 
2513  INLINE int Lb(const rmatrix &rm, const int &i)
2514 #if(CXSC_INDEX_CHECK)
2515 ;
2516 #else
2517  noexcept;
2518 #endif
2519  INLINE int Ub(const rmatrix &rm, const int &i)
2521 #if(CXSC_INDEX_CHECK)
2522 ;
2523 #else
2524  noexcept;
2525 #endif
2526  INLINE int Lb(const rmatrix_slice &rm, const int &i)
2528 #if(CXSC_INDEX_CHECK)
2529 ;
2530 #else
2531  noexcept;
2532 #endif
2533  INLINE int Ub(const rmatrix_slice &rm, const int &i)
2535 #if(CXSC_INDEX_CHECK)
2536 ;
2537 #else
2538  noexcept;
2539 #endif
2540  INLINE rmatrix &SetLb(rmatrix &m, const int &i,const int &j)
2542 #if(CXSC_INDEX_CHECK)
2543 ;
2544 #else
2545  noexcept;
2546 #endif
2547  INLINE rmatrix &SetUb(rmatrix &m, const int &i,const int &j)
2549 #if(CXSC_INDEX_CHECK)
2550 ;
2551 #else
2552  noexcept;
2553 #endif
2554  INLINE void Resize(rmatrix &A) noexcept;
2557  INLINE void Resize(rmatrix &A,const int &m, const int &n)
2558 #if(CXSC_INDEX_CHECK)
2559 ;
2560 #else
2561  noexcept;
2562 #endif
2563  INLINE void Resize(rmatrix &A,const int &m1, const int &m2,const int &n1,const int &n2)
2565 #if(CXSC_INDEX_CHECK)
2566 ;
2567 #else
2568  noexcept;
2569 #endif
2570 
2572  INLINE rmatrix abs(const rmatrix &m) noexcept;
2574  INLINE rmatrix abs(const rmatrix_slice &ms) noexcept;
2576  INLINE rmatrix CompMat(const rmatrix &m) noexcept;
2577 
2578 //===================== Matrix / Scalar ===============================
2579 
2581  INLINE rmatrix operator *(const real &c, const rmatrix &m) noexcept;
2583  INLINE rmatrix operator *(const real &c, const rmatrix_slice &ms) noexcept;
2585  INLINE rmatrix operator *(const rmatrix &m,const real &c) noexcept;
2587  INLINE rmatrix operator *(const rmatrix_slice &ms,const real &c) noexcept;
2589  INLINE rmatrix &operator *=(rmatrix &m,const real &c) noexcept;
2591  INLINE rmatrix operator /(const rmatrix &m,const real &c) noexcept;
2593  INLINE rmatrix operator /(const rmatrix_slice &ms, const real &c) noexcept;
2595  INLINE rmatrix &operator /=(rmatrix &m,const real &c) noexcept;
2596 
2597 //============================ Matrix / Vector ===================================
2598 
2599 //--------------------------- rvector ---------------------------
2600 
2602  INLINE rvector operator *(const rmatrix &m,const rvector &v)
2603 #if(CXSC_INDEX_CHECK)
2604 ;
2605 #else
2606  noexcept;
2607 #endif
2608  INLINE rvector operator *(const rmatrix_slice &ms,const rvector &v)
2610 #if(CXSC_INDEX_CHECK)
2611 ;
2612 #else
2613  noexcept;
2614 #endif
2615  INLINE rvector operator *(const rvector &v,const rmatrix &m)
2617 #if(CXSC_INDEX_CHECK)
2618 ;
2619 #else
2620  noexcept;
2621 #endif
2622  INLINE rvector operator *(const rvector &v,const rmatrix_slice &ms)
2624 #if(CXSC_INDEX_CHECK)
2625 ;
2626 #else
2627  noexcept;
2628 #endif
2629  INLINE rvector &operator *=(rvector &v,const rmatrix &m)
2631 #if(CXSC_INDEX_CHECK)
2632 ;
2633 #else
2634  noexcept;
2635 #endif
2636  INLINE rvector &operator *=(rvector &v,const rmatrix_slice &ms)
2638 #if(CXSC_INDEX_CHECK)
2639 ;
2640 #else
2641  noexcept;
2642 #endif
2643 
2644  // Test
2646  INLINE rvector operator *(const rvector_slice &v,const rmatrix &m)
2647 #if(CXSC_INDEX_CHECK)
2648 ;
2649 #else
2650  noexcept;
2651 #endif
2652 
2653 
2654 
2655 //================ Matrix / Matrix ============================
2656 
2658  INLINE const rmatrix &operator +(const rmatrix &m1) noexcept;
2660  INLINE rmatrix operator +(const rmatrix_slice &ms) noexcept;
2662  INLINE rmatrix operator +(const rmatrix &m1,const rmatrix &m2)
2663 #if(CXSC_INDEX_CHECK)
2664 ;
2665 #else
2666  noexcept;
2667 #endif
2668  INLINE rmatrix operator +(const rmatrix &m,const rmatrix_slice &ms)
2670 #if(CXSC_INDEX_CHECK)
2671 ;
2672 #else
2673  noexcept;
2674 #endif
2675  INLINE rmatrix operator +(const rmatrix_slice &ms,const rmatrix &m)
2677 #if(CXSC_INDEX_CHECK)
2678 ;
2679 #else
2680  noexcept;
2681 #endif
2682  INLINE rmatrix operator +(const rmatrix_slice &m1,const rmatrix_slice &m2)
2684 #if(CXSC_INDEX_CHECK)
2685 ;
2686 #else
2687  noexcept;
2688 #endif
2689  INLINE rmatrix &operator +=(rmatrix &m1,const rmatrix &m2)
2691 #if(CXSC_INDEX_CHECK)
2692 ;
2693 #else
2694  noexcept;
2695 #endif
2696  INLINE rmatrix &operator +=(rmatrix &m1,const rmatrix_slice &ms)
2698 #if(CXSC_INDEX_CHECK)
2699 ;
2700 #else
2701  noexcept;
2702 #endif
2703 
2705  INLINE rmatrix operator -(const rmatrix &m) noexcept;
2707  INLINE rmatrix operator -(const rmatrix_slice &ms) noexcept;
2709  INLINE rmatrix operator -(const rmatrix &m1,const rmatrix &m2)
2710 #if(CXSC_INDEX_CHECK)
2711 ;
2712 #else
2713  noexcept;
2714 #endif
2715  INLINE rmatrix operator -(const rmatrix &m,const rmatrix_slice &ms)
2717 #if(CXSC_INDEX_CHECK)
2718 ;
2719 #else
2720  noexcept;
2721 #endif
2722  INLINE rmatrix operator -(const rmatrix_slice &ms,const rmatrix &m)
2724 #if(CXSC_INDEX_CHECK)
2725 ;
2726 #else
2727  noexcept;
2728 #endif
2729  INLINE rmatrix operator -(const rmatrix_slice &ms1,const rmatrix_slice &ms2)
2731 #if(CXSC_INDEX_CHECK)
2732 ;
2733 #else
2734  noexcept;
2735 #endif
2736  INLINE rmatrix &operator -=(rmatrix &m1,const rmatrix &m2)
2738 #if(CXSC_INDEX_CHECK)
2739 ;
2740 #else
2741  noexcept;
2742 #endif
2743  INLINE rmatrix &operator -=(rmatrix &m1,const rmatrix_slice &ms)
2745 #if(CXSC_INDEX_CHECK)
2746 ;
2747 #else
2748  noexcept;
2749 #endif
2750 
2752  INLINE rmatrix operator *(const rmatrix &m1, const rmatrix &m2)
2753 #if(CXSC_INDEX_CHECK)
2754 ;
2755 #else
2756  noexcept;
2757 #endif
2758  INLINE rmatrix operator *(const rmatrix &m1, const rmatrix_slice &ms)
2760 #if(CXSC_INDEX_CHECK)
2761 ;
2762 #else
2763  noexcept;
2764 #endif
2765  INLINE rmatrix operator *(const rmatrix_slice &ms, const rmatrix &m1)
2767 #if(CXSC_INDEX_CHECK)
2768 ;
2769 #else
2770  noexcept;
2771 #endif
2772  INLINE rmatrix operator *(const rmatrix_slice &ms1, const rmatrix_slice &ms2)
2774 #if(CXSC_INDEX_CHECK)
2775 ;
2776 #else
2777  noexcept;
2778 #endif
2779  INLINE rmatrix &operator *=(rmatrix &m1,const rmatrix &m2)
2781 #if(CXSC_INDEX_CHECK)
2782 ;
2783 #else
2784  noexcept;
2785 #endif
2786  INLINE rmatrix &operator *=(rmatrix &m1,const rmatrix_slice &ms)
2788 #if(CXSC_INDEX_CHECK)
2789 ;
2790 #else
2791  noexcept;
2792 #endif
2793 
2794 
2795 
2796 //============== Compare Operator ==========================
2797 
2798 //-------------- Matrix - Matrix -------------------------
2799 
2801  INLINE bool operator ==(const rmatrix &m1,const rmatrix &m2) noexcept;
2803  INLINE bool operator !=(const rmatrix &m1,const rmatrix &m2) noexcept;
2805  INLINE bool operator <(const rmatrix &m1,const rmatrix &m2) noexcept;
2807  INLINE bool operator <=(const rmatrix &m1,const rmatrix &m2) noexcept;
2809  INLINE bool operator >(const rmatrix &m1,const rmatrix &m2) noexcept;
2811  INLINE bool operator >=(const rmatrix &m1,const rmatrix &m2) noexcept;
2813  INLINE bool operator ==(const rmatrix &m1,const rmatrix_slice &ms) noexcept;
2815  INLINE bool operator !=(const rmatrix &m1,const rmatrix_slice &ms) noexcept;
2817  INLINE bool operator <(const rmatrix &m1,const rmatrix_slice &ms) noexcept;
2819  INLINE bool operator <=(const rmatrix &m1,const rmatrix_slice &ms) noexcept;
2821  INLINE bool operator >(const rmatrix &m1,const rmatrix_slice &ms) noexcept;
2823  INLINE bool operator >=(const rmatrix &m1,const rmatrix_slice &ms) noexcept;
2824 
2825 //---------------- Matrix - Matrix_slice ----------------------
2826 
2828  INLINE bool operator ==(const rmatrix_slice &m1,const rmatrix_slice &m2) noexcept;
2830  INLINE bool operator !=(const rmatrix_slice &m1,const rmatrix_slice &m2) noexcept;
2832  INLINE bool operator <(const rmatrix_slice &m1,const rmatrix_slice &m2) noexcept;
2834  INLINE bool operator <=(const rmatrix_slice &m1,const rmatrix_slice &m2) noexcept;
2836  INLINE bool operator >(const rmatrix_slice &m1,const rmatrix_slice &m2) noexcept;
2838  INLINE bool operator >=(const rmatrix_slice &m1,const rmatrix_slice &m2) noexcept;
2839 
2840 //=================== Not Operator =============================
2841 
2843  INLINE bool operator !(const rmatrix &ms) noexcept;
2845  INLINE bool operator !(const rmatrix_slice &ms) noexcept;
2846 
2847 //======================== Input / Output ========================
2848 
2850  INLINE std::ostream &operator <<(std::ostream &s,const rmatrix &r) noexcept;
2852  INLINE std::ostream &operator <<(std::ostream &s,const rmatrix_slice &r) noexcept;
2854  INLINE std::istream &operator >>(std::istream &s,rmatrix &r) noexcept;
2856  INLINE std::istream &operator >>(std::istream &s,rmatrix_slice &r) noexcept;
2857 
2858 //INLINE rmatrix_subv Row(rmatrix &m,const int &i)
2859 
2861  INLINE int RowLen ( const rmatrix& );
2863  INLINE int ColLen ( const rmatrix& );
2865  INLINE int RowLen ( const rmatrix_slice& );
2867  INLINE int ColLen ( const rmatrix_slice& );
2869  rmatrix Id ( const rmatrix& );
2871  rmatrix transp ( const rmatrix& );
2873  void DoubleSize ( rmatrix& );
2874 
2875 
2876 
2877 } // namespace cxsc
2878 
2879 #ifdef _CXSC_INCL_INL
2880 # include "matrix.inl"
2881 # include "rmatrix.inl"
2882 #endif
2883 
2884 #ifdef _CXSC_IVECTOR_HPP_INCLUDED
2885 # ifdef _CXSC_INCL_INL
2886 # include "ivecrmat.inl"
2887 # else
2888 # include "ivecrmat.hpp"
2889 # endif
2890 #endif
2891 
2892 #ifdef _CXSC_CVECTOR_HPP_INCLUDED
2893 # ifdef _CXSC_INCL_INL
2894 # include "cvecrmat.inl"
2895 # else
2896 # include "cvecrmat.hpp"
2897 # endif
2898 #endif
2899 
2900 #ifdef _CXSC_CIVECTOR_HPP_INCLUDED
2901 # ifdef _CXSC_INCL_INL
2902 # include "civecrmat.inl"
2903 # else
2904 # include "civecrmat.hpp"
2905 # endif
2906 #endif
2907 
2908 #ifdef _CXSC_LIVECTOR_HPP_INCLUDED
2909 # ifdef _CXSC_INCL_INL
2910 # include "livecrmat.inl"
2911 # else
2912 # include "livecrmat.hpp"
2913 # endif
2914 #endif
2915 
2916 #ifdef _CXSC_LRVECTOR_HPP_INCLUDED
2917 # ifdef _CXSC_INCL_INL
2918 # include "lrvecrmat.inl"
2919 # else
2920 # include "lrvecrmat.hpp"
2921 # endif
2922 #endif
2923 
2924 #ifdef CXSC_USE_BLAS
2925 #define _CXSC_BLAS_RMATRIX
2926 #include "cxsc_blas.inl"
2927 #endif
2928 
2929 #endif
cxsc::rmatrix::rmatrix
rmatrix() noexcept
Constructor of class rmatrix.
Definition: rmatrix.inl:33
cxsc::rmatrix_slice::operator+=
rmatrix_slice & operator+=(const srmatrix &m)
Implementation of multiplication and allocation operation.
Definition: srmatrix.hpp:1160
cxsc::rmatrix::operator=
rmatrix & operator=(const real &r) noexcept
Implementation of standard assigning operator.
Definition: rmatrix.inl:338
cxsc::rmatrix_subv::Ub
friend int Ub(const rmatrix_subv &rv) noexcept
Returns the upper bound of the vector.
Definition: rmatrix.hpp:316
cxsc::srvector
A sparse real vector.
Definition: srvector.hpp:58
cxsc::rmatrix::operator*=
rmatrix & operator*=(const srmatrix &m)
Implementation of multiplication and allocation operation.
Definition: srmatrix.hpp:1172
cxsc::_rmatrix
rmatrix _rmatrix(const rmatrix &rm) noexcept
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC.
Definition: rmatrix.inl:574
cxsc::CompMat
rmatrix CompMat(const cimatrix &A)
Returns Ostrowski's comparison matrix.
Definition: cimatrix.cpp:45
cxsc::srmatrix_subv
Represents a row or column vector of a sparse matrix.
Definition: srmatrix.hpp:2157
cxsc::rmatrix::operator+=
rmatrix & operator+=(const srmatrix &m)
Implementation of addition and allocation operation.
Definition: srmatrix.hpp:1156
cxsc::rmatrix_slice::operator-=
rmatrix_slice & operator-=(const srmatrix &m)
Implementation of multiplication and allocation operation.
Definition: srmatrix.hpp:1168
cxsc::cmatrix
The Data Type cmatrix.
Definition: cmatrix.hpp:514
cxsc::rmatrix_slice::rmatrix_slice
rmatrix_slice(rmatrix_slice &a, const int &l1, const int &u1, const int &l2, const int &u2) noexcept
Constructor of class rmatrix_slice.
Definition: rmatrix.hpp:2034
cxsc::rmatrix_subv::Col
friend rmatrix_subv Col(rmatrix &m, const int &i) noexcept
Returns one column of the matrix as a vector.
Definition: rmatrix.inl:130
cxsc::RowLen
int RowLen(const cimatrix &)
Returns the row dimension.
Definition: cimatrix.inl:1199
cxsc::rmatrix_slice::operator=
rmatrix_slice & operator=(const srmatrix &m)
Implementation of standard assigning operator.
Definition: srmatrix.hpp:1151
cxsc::rmatrix::operator[]
rmatrix_subv operator[](const int &i) const noexcept
Operator for accessing a single row of the matrix.
Definition: rmatrix.inl:190
cxsc::rmatrix_slice::operator()
rmatrix_slice & operator()() noexcept
Operator for accessing the whole matrix.
Definition: rmatrix.hpp:2106
cxsc::srmatrix
A sparse real matrix.
Definition: srmatrix.hpp:77
cxsc::Ub
int Ub(const cimatrix &rm, const int &i) noexcept
Returns the upper bound index.
Definition: cimatrix.inl:1163
cxsc::operator*=
cimatrix & operator*=(cimatrix &m, const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
Definition: cimatrix.inl:1605
cxsc::rmatrix_slice::rmatrix_slice
rmatrix_slice(rmatrix &a, const int &l1, const int &u1, const int &l2, const int &u2) noexcept
Constructor of class rmatrix_slice.
Definition: rmatrix.hpp:2032
cxsc::operator/
civector operator/(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of division operation.
Definition: cimatrix.inl:730
cxsc::rmatrix::operator-=
rmatrix & operator-=(const srmatrix &m)
Implementation of substraction and allocation operation.
Definition: srmatrix.hpp:1164
cxsc::rmatrix_slice::operator/=
rmatrix_slice & operator/=(const real &c) noexcept
Implementation of division and allocation operation.
Definition: rmatrix.inl:422
cxsc::intvector
The Data Type intvector.
Definition: intvector.hpp:52
cxsc::rmatrix
The Data Type rmatrix.
Definition: rmatrix.hpp:471
cxsc::cvector
The Data Type cvector.
Definition: cvector.hpp:58
cxsc::srvector_slice
Helper class for slices of sparse vectors.
Definition: srvector.hpp:868
cxsc::abs
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737
cxsc::operator/=
cimatrix & operator/=(cimatrix &m, const cinterval &c) noexcept
Implementation of division and allocation operation.
Definition: cimatrix.inl:1623
cxsc::ColLen
int ColLen(const cimatrix &)
Returns the column dimension.
Definition: cimatrix.inl:1202
cxsc::l_rmatrix
The Multiple-Precision Data Type l_rmatrix.
Definition: l_rmatrix.hpp:416
cxsc::rvector
The Data Type rvector.
Definition: rvector.hpp:58
cxsc::rmatrix::SupRe
friend rmatrix SupRe(const cimatrix &v) noexcept
Returns componentwise the supremum of the real part.
Definition: cimatrix.inl:770
cxsc::rmatrix_subv::rmatrix_subv
rmatrix_subv(const rmatrix_subv &v) noexcept
Constructor of class rmatrix_subv.
Definition: rmatrix.hpp:269
cxsc::Col
cimatrix_subv Col(cimatrix &m, const int &i) noexcept
Returns one column of the matrix as a vector.
Definition: cimatrix.inl:242
cxsc::l_imatrix
The Multiple-Precision Data Type l_imatrix.
Definition: l_imatrix.hpp:726
cxsc::SetUb
cimatrix & SetUb(cimatrix &m, const int &i, const int &j) noexcept
Sets the upper bound index.
Definition: cimatrix.inl:1191
cxsc::rvector_slice
The Data Type rvector_slice.
Definition: rvector.hpp:1064
cxsc::imatrix
The Data Type imatrix.
Definition: imatrix.hpp:660
cxsc::rmatrix_subv::rmatrix_subv
rmatrix_subv(real *d, const int &l, const int &u, const int &s, const int &st, const int &o) noexcept
Constructor of class rmatrix_subv.
Definition: rmatrix.hpp:266
cxsc::rmatrix::InfRe
friend rmatrix InfRe(const cimatrix &v) noexcept
Returns componentwise the infimum of the real part.
Definition: cimatrix.inl:745
cxsc::operator*
civector operator*(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of multiplication operation.
Definition: cimatrix.inl:731
cxsc::Lb
int Lb(const cimatrix &rm, const int &i) noexcept
Returns the lower bound index.
Definition: cimatrix.inl:1156
cxsc::accumulate_approx
void accumulate_approx(cdotprecision &dp, const cmatrix_subv &rv1, const cmatrix_subv &rv2)
The accurate scalar product of the last two arguments added to the value of the first argument (witho...
Definition: cmatrix.cpp:99
cxsc::ivector
The Data Type ivector.
Definition: ivector.hpp:55
cxsc::rmatrix_subv::operator+=
rmatrix_subv & operator+=(const real &c) noexcept
Implementation of addition and allocation operation.
Definition: rmatrix.inl:428
cxsc::SetLb
cimatrix & SetLb(cimatrix &m, const int &i, const int &j) noexcept
Sets the lower bound index.
Definition: cimatrix.inl:1184
cxsc::rvector::rvector
rvector() noexcept
Constructor of class rvector.
Definition: rvector.inl:37
cxsc::rmatrix_subv
The Data Type rmatrix_subv.
Definition: rmatrix.hpp:54
cxsc::rmatrix_slice::operator[]
rmatrix_subv operator[](const int &i) const noexcept
Operator for accessing a single row of the matrix.
Definition: rmatrix.inl:242
cxsc
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
cxsc::rmatrix_subv::Lb
friend int Lb(const rmatrix_subv &rv) noexcept
Returns the lower bound of the vector.
Definition: rmatrix.hpp:314
cxsc::operator+=
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc) noexcept
Implementation of standard algebraic addition and allocation operation.
Definition: cdot.inl:251
cxsc::DoubleSize
void DoubleSize(cimatrix &A)
Doubles the size of the matrix.
Definition: cimatrix.cpp:83
cxsc::transp
cimatrix transp(const cimatrix &A)
Returns the transposed matrix.
Definition: cimatrix.cpp:74
cxsc::rmatrix_subv::operator-=
rmatrix_subv & operator-=(const real &c) noexcept
Implementation of subtraction and allocation operation.
Definition: rmatrix.inl:429
cxsc::rmatrix_slice
The Data Type rmatrix_slice.
Definition: rmatrix.hpp:1443
cxsc::rmatrix_subv::operator/=
rmatrix_subv & operator/=(const real &c) noexcept
Implementation of division and allocation operation.
Definition: rmatrix.inl:430
cxsc::rmatrix_subv::VecLen
friend int VecLen(const rmatrix_subv &rv) noexcept
Returns the size of the vector.
Definition: rmatrix.hpp:318
cxsc::rmatrix_slice::rmatrix_slice
rmatrix_slice(const rmatrix_slice &ms) noexcept
Constructor of class rmatrix_slice.
Definition: rmatrix.hpp:2037
cxsc::l_rvector
The Multiple-Precision Data Type l_rvector.
Definition: l_rvector.hpp:54
cxsc::rmatrix_subv::operator*=
rmatrix_subv & operator*=(const real &c) noexcept
Implementation of multiplication and allocation operation.
Definition: rmatrix.inl:427
cxsc::cimatrix_slice
The Data Type cimatrix_slice.
Definition: cimatrix.hpp:1651
cxsc::rmatrix_subv::operator[]
real & operator[](const int &i) const noexcept
Operator for accessing the single elements of the vector (read-only)
Definition: rmatrix.inl:162
cxsc::rmatrix::SupIm
friend rmatrix SupIm(const cimatrix &v) noexcept
Returns componentwise the supremum of the imaginary part.
Definition: cimatrix.inl:820
cxsc::rmatrix_slice::operator*=
rmatrix_slice & operator*=(const srmatrix &m)
Implementation of multiplication and allocation operation.
Definition: srmatrix.hpp:1176
cxsc::l_ivector
The Multiple-Precision Data Type l_ivector.
Definition: l_ivector.hpp:55
cxsc::cimatrix
The Data Type cimatrix.
Definition: cimatrix.hpp:908
cxsc::Id
cimatrix Id(const cimatrix &A)
Returns the Identity matrix.
Definition: cimatrix.cpp:61
cxsc::Resize
void Resize(cimatrix &A) noexcept
Resizes the matrix.
Definition: cimatrix.inl:1211
cxsc::rmatrix::InfIm
friend rmatrix InfIm(const cimatrix &v) noexcept
Returns componentwise the infimum of the imaginary part.
Definition: cimatrix.inl:795
cxsc::rmatrix_subv::Row
friend rmatrix_subv Row(rmatrix &m, const int &i) noexcept
Returns one row of the matrix as a vector.
Definition: rmatrix.inl:119
cxsc::rmatrix_subv::operator=
rmatrix_subv & operator=(const rmatrix_subv &rv) noexcept
Implementation of standard assigning operator.
Definition: rmatrix.inl:322
cxsc::civector
The Data Type civector.
Definition: civector.hpp:57
cxsc::Row
cimatrix_subv Row(cimatrix &m, const int &i) noexcept
Returns one row of the matrix as a vector.
Definition: cimatrix.inl:231
cxsc::intmatrix
The Data Type intmatrix.
Definition: intmatrix.hpp:314
cxsc::rmatrix_subv::operator()
rmatrix_subv & operator()() noexcept
Operator for accessing the whole vector.
Definition: rmatrix.hpp:337
cxsc::rmatrix::operator()
rmatrix & operator()() noexcept
Operator for accessing the whole matrix.
Definition: rmatrix.hpp:1416
cxsc::real
The Scalar Type real.
Definition: real.hpp:114
cxsc::srmatrix_slice
A slice of a sparse real matrix.
Definition: srmatrix.hpp:1360
cxsc::real::real
real(void) noexcept
Constructor of class real.
Definition: real.hpp:122