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  throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT);
73 #else
74  throw();
75 #endif
76  friend INLINE rmatrix_subv Col(rmatrix &m,const int &i)
78 #if(CXSC_INDEX_CHECK)
79  throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT);
80 #else
81  throw();
82 #endif
83  friend INLINE rmatrix_subv Row(const rmatrix &m,const int &i)
85 #if(CXSC_INDEX_CHECK)
86  throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT);
87 #else
88  throw();
89 #endif
90  friend INLINE rmatrix_subv Col(const rmatrix &m,const int &i)
92 #if(CXSC_INDEX_CHECK)
93  throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT);
94 #else
95  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<MV1>);
106 #else
107  throw();
108 #endif
109 template <class MV,class S> friend MV &_mvsassign(MV &v,const S &r) throw();
110 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
111 #if(CXSC_INDEX_CHECK)
112  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
113 #else
114  throw();
115 #endif
116 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) throw();
117 template <class MV,class V> friend V _mvabs(const MV &mv) throw();
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  throw(OP_WITH_WRONG_DIM);
121 #else
122  throw();
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  throw(OP_WITH_WRONG_DIM);
128 #else
129  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<MV1>);
135 #else
136  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
141 #else
142  throw();
143 #endif
144  template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) throw();
145  template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
146 #if(CXSC_INDEX_CHECK)
147  throw(ERROR__OP_WITH_WRONG_DIM<E>);
148 #else
149  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
154 #else
155  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
160 #else
161  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
166 #else
167  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
172 #else
173  throw();
174 #endif
175  template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) throw();
176 template <class MV,class S> friend MV &_mvsmultassign(MV &v,const S &r) throw();
177 template <class MV, class S> friend MV &_mvsplusassign(MV &v,const S &r) throw();
178 template <class MV,class S> friend MV &_mvsminusassign(MV &v,const S &r) throw();
179 template <class MV,class S> friend MV &_mvsdivassign(MV &v,const S &r) throw();
180 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
181 #if(CXSC_INDEX_CHECK)
182  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
183 #else
184  throw();
185 #endif
186 template <class V,class MV> friend V &_vmvplusassign(V &rv,const MV &v)
187 #if(CXSC_INDEX_CHECK)
188  throw(ERROR__OP_WITH_WRONG_DIM<V>);
189 #else
190  throw();
191 #endif
192 template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv)
193 #if(CXSC_INDEX_CHECK)
194  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
195 #else
196  throw();
197 #endif
198 template <class V,class MV> friend V &_vmvminusassign(V &rv,const MV &v)
199 #if(CXSC_INDEX_CHECK)
200  throw(ERROR__OP_WITH_WRONG_DIM<V>);
201 #else
202  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
207 #else
208  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
213 #else
214  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<V>);
223 #else
224  throw();
225 #endif
226 template <class V,class MV> friend V &_vmvsetsup(V &rv,const MV &v)
227 #if(CXSC_INDEX_CHECK)
228  throw(ERROR__OP_WITH_WRONG_DIM<V>);
229 #else
230  throw();
231 #endif
232 template <class V,class MV> friend V &_vmvusetinf(V &rv,const MV &v)
233 #if(CXSC_INDEX_CHECK)
234  throw(ERROR__OP_WITH_WRONG_DIM<V>);
235 #else
236  throw();
237 #endif
238 template <class V,class MV> friend V &_vmvusetsup(V &rv,const MV &v)
239 #if(CXSC_INDEX_CHECK)
240  throw(ERROR__OP_WITH_WRONG_DIM<V>);
241 #else
242  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<V>);
251 #else
252  throw();
253 #endif
254 template <class V,class MV> friend V &_vmvsetre(V &rv,const MV &v)
255 #if(CXSC_INDEX_CHECK)
256  throw(ERROR__OP_WITH_WRONG_DIM<V>);
257 #else
258  throw();
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) throw():dat(d),lb(l),ub(u),size(s),start(st),offset(o) { }
267  public:
269  INLINE rmatrix_subv(const rmatrix_subv &v) throw():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 &) throw();
276  INLINE rmatrix_subv &operator =(const rmatrix_subv &rv) throw();
278  INLINE rmatrix_subv &operator =(const real &r) throw();
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  throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
289 #else
290  throw();
291 #endif
292  INLINE rmatrix_subv &operator =(const rmatrix_slice &m)
294 #if(CXSC_INDEX_CHECK)
295  throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
296 #else
297  throw();
298 #endif
299  INLINE rmatrix_subv &operator =(const rvector &v)
301 #if(CXSC_INDEX_CHECK)
302  throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
303 #else
304  throw();
305 #endif
306  INLINE rmatrix_subv &operator =(const rvector_slice &v)
308 #if(CXSC_INDEX_CHECK)
309  throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
310 #else
311  throw();
312 #endif
313  friend INLINE int Lb(const rmatrix_subv &rv) throw() { return rv.lb; }
316  friend INLINE int Ub(const rmatrix_subv &rv) throw() { return rv.ub; }
318  friend INLINE int VecLen(const rmatrix_subv &rv) throw() { return rv.size; }
319 
321  INLINE real &operator [](const int &i) const
322 #if(CXSC_INDEX_CHECK)
323  throw(ERROR_RVECTOR_ELEMENT_NOT_IN_VEC);
324 #else
325  throw();
326 #endif
327 
329  INLINE real &operator [](const int &i)
330 #if(CXSC_INDEX_CHECK)
331  throw(ERROR_RVECTOR_ELEMENT_NOT_IN_VEC);
332 #else
333  throw();
334 #endif
335 
337  INLINE rmatrix_subv &operator ()() throw() { return *this; }
339  INLINE rmatrix_subv operator ()(const int &i)
340 #if(CXSC_INDEX_CHECK)
341  throw(ERROR_RVECTOR_SUB_ARRAY_TOO_BIG);
342 #else
343  throw();
344 #endif
345  INLINE rmatrix_subv operator ()(const int &i1,const int &i2)
347 #if(CXSC_INDEX_CHECK)
348  throw(ERROR_RVECTOR_SUB_ARRAY_TOO_BIG);
349 #else
350  throw();
351 #endif
352 
354  INLINE rmatrix_subv &operator *=(const real &c) throw();
356  INLINE rmatrix_subv &operator +=(const real &c) throw();
358  INLINE rmatrix_subv &operator -=(const real &c) throw();
360  INLINE rmatrix_subv &operator /=(const real &c) throw();
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);
372  INLINE rmatrix_subv &operator -=(const srvector_slice &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  throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
380 #else
381  throw();
382 #endif
383  INLINE rmatrix_subv &operator -=(const rvector_slice &rv)
385 #if(CXSC_INDEX_CHECK)
386  throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
387 #else
388  throw();
389 #endif
390  INLINE rmatrix_subv &operator +=(const rvector &rv)
392 #if(CXSC_INDEX_CHECK)
393  throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
394 #else
395  throw();
396 #endif
397  INLINE rmatrix_subv &operator +=(const rvector_slice &rv)
399 #if(CXSC_INDEX_CHECK)
400  throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
401 #else
402  throw();
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  throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT);
414 #else
415  throw();
416 #endif
417 
419 INLINE rmatrix_subv Col(rmatrix &m,const int &i)
420 #if(CXSC_INDEX_CHECK)
421  throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT);
422 #else
423  throw();
424 #endif
425 
427 INLINE rmatrix_subv Row(const rmatrix &m,const int &i)
428 #if(CXSC_INDEX_CHECK)
429  throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT);
430 #else
431  throw();
432 #endif
433 
435 INLINE rmatrix_subv Col(const rmatrix &m,const int &i)
436 #if(CXSC_INDEX_CHECK)
437  throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT);
438 #else
439  throw();
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  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>,ERROR__USE_OF_UNINITIALIZED_OBJ<M>);
491 #else
492  throw();
493 #endif
494 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
495 #if(CXSC_INDEX_CHECK)
496  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
497 #else
498  throw();
499 #endif
500  template <class M1,class M2,class S> friend M1 &_mmassign(M1 &m1,const M2 &m,S ms) throw();
501  template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) throw();
502  template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m)
503 #if(CXSC_INDEX_CHECK)
504  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
505 #else
506  throw();
507 #endif
508  template <class M,class S> friend M &_msassign(M &m,const S &r) throw();
509 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m)
510 #if(CXSC_INDEX_CHECK)
511  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
512 #else
513  throw();
514 #endif
515 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) throw();
516  template <class M> friend int _mlb(const M &m, const int &i)
517 #if(CXSC_INDEX_CHECK)
518  throw(ERROR__WRONG_ROW_OR_COL<M>);
519 #else
520  throw();
521 #endif
522  template <class M> friend int _mub(const M &m, const int &i)
523 #if(CXSC_INDEX_CHECK)
524  throw(ERROR__WRONG_ROW_OR_COL<M>);
525 #else
526  throw();
527 #endif
528  template <class M> friend M &_msetlb(M &m, const int &i,const int &j)
529 #if(CXSC_INDEX_CHECK)
530  throw(ERROR__WRONG_ROW_OR_COL<M>);
531 #else
532  throw();
533 #endif
534  template <class M> friend M &_msetub(M &m, const int &i,const int &j)
535 #if(CXSC_INDEX_CHECK)
536  throw(ERROR__WRONG_ROW_OR_COL<M>);
537 #else
538  throw();
539 #endif
540  template <class M> friend void _mresize(M &A) throw();
541  template <class M,class S> friend void _mresize(M &A,const int &m, const int &n)
542 #if(CXSC_INDEX_CHECK)
543  throw(ERROR__WRONG_BOUNDARIES<M>);
544 #else
545  throw();
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  throw(ERROR__WRONG_BOUNDARIES<M>);
550 #else
551  throw();
552 #endif
553  template <class M,class E> friend E _mabs(const M &m) throw();
554  template <class MS,class E> friend E _msabs(const MS &ms) throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
559 #else
560  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<M>);
565 #else
566  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
571 #else
572  throw();
573 #endif
574  template <class M> friend M _mminus(const M &m) throw();
575  template <class MS,class E> friend E _msminus(const MS &ms) throw();
576  template <class M1,class M2,class E> friend E _mmminus(const M1 &m1,const M2 &m2)
577 #if(CXSC_INDEX_CHECK)
578  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
579 #else
580  throw();
581 #endif
582  template <class M1,class M2> friend M1 &_mmplusassign(M1 &m1,const M2 &m2)
583 #if(CXSC_INDEX_CHECK)
584  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
585 #else
586  throw();
587 #endif
588  template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms)
589 #if(CXSC_INDEX_CHECK)
590  throw(ERROR__OP_WITH_WRONG_DIM<M>);
591 #else
592  throw();
593 #endif
594  template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1)
595 #if(CXSC_INDEX_CHECK)
596  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
597 #else
598  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
603 #else
604  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
609 #else
610  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
615 #else
616  throw();
617 #endif
618  template <class M1,class M2> friend M1 &_mmminusassign(M1 &m1,const M2 &m2)
619 #if(CXSC_INDEX_CHECK)
620  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
621 #else
622  throw();
623 #endif
624  template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms)
625 #if(CXSC_INDEX_CHECK)
626  throw(ERROR__OP_WITH_WRONG_DIM<M>);
627 #else
628  throw();
629 #endif
630  template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1)
631 #if(CXSC_INDEX_CHECK)
632  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
633 #else
634  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
639 #else
640  throw();
641 #endif
642  template <class M1,class M2,class S> friend M1 &_mmmultassign(M1 &m1,const M2 &m2)
643 #if(CXSC_INDEX_CHECK)
644  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
645 #else
646  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
651 #else
652  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
657 #else
658  throw();
659 #endif
660  template <class M,class MS,class S> friend M &_mmsmultassign(M &m1,const MS &ms)
661 #if(CXSC_INDEX_CHECK)
662  throw(ERROR__OP_WITH_WRONG_DIM<M>);
663 #else
664  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
669 #else
670  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
675 #else
676  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<M>);
681 #else
682  throw();
683 #endif
684  //-------- matrix-scalar ---------------------
685  template <class S,class M,class E> friend E _smmult(const S &c, const M &m) throw();
686  template <class M,class S> friend M &_msmultassign(M &m,const S &c) throw();
687  template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) throw();
688  template <class M,class S,class E> friend E _msdiv(const M &m,const S &c) throw();
689  template <class M,class S> friend M &_msdivassign(M &m,const S &c) throw();
690  template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<M>);
695 #else
696  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<M>);
701 #else
702  throw();
703 #endif
704  template <class V,class M,class S> friend V &_vmmultassign(V &v,const M &m)
705 #if(CXSC_INDEX_CHECK)
706  throw(ERROR__OP_WITH_WRONG_DIM<M>);
707 #else
708  throw();
709 #endif
710  template <class VS,class M,class S> friend VS &_vsmmultassign(VS &v,const M &m)
711 #if(CXSC_INDEX_CHECK)
712  throw(ERROR__OP_WITH_WRONG_DIM<M>);
713 #else
714  throw();
715 #endif
716 
717  template <class M> friend void *_mvoid(const M &m) throw();
718  template <class M> friend bool _mnot(const M &m) throw();
719  template <class MS> friend void *_msvoid(const MS &ms) throw();
720  template <class MS> friend bool _msnot(const MS &ms) throw();
721  template <class M1,class M2> friend bool _mmeq(const M1 &m1,const M2 &m2) throw();
722  template <class M1,class M2> friend bool _mmneq(const M1 &m1,const M2 &m2) throw();
723  template <class M1,class M2> friend bool _mmless(const M1 &m1,const M2 &m2) throw();
724  template <class M1,class M2> friend bool _mmleq(const M1 &m1,const M2 &m2) throw();
725  template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) throw();
726  template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) throw();
727  template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) throw();
728  template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) throw();
729  template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) throw();
730  template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) throw();
731  template <class M> friend std::ostream &_mout(std::ostream &s,const M &r) throw();
732  template <class M> friend std::istream &_min(std::istream &s,M &r) throw();
733 
734  // Interval
735 
736 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
737 #if(CXSC_INDEX_CHECK)
738  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
739 #else
740  throw();
741 #endif
742 
743  template <class M,class E> friend E _mdiam(const M &m) throw();
744  template <class M,class E> friend E _mmid(const M &m) throw();
745  template <class MS,class E> friend E _msdiam(const MS &ms) throw();
746  template <class MS,class E> friend E _msmid(const MS &ms) throw();
747  template <class M,class E> friend E _minf(const M &m) throw();
748  template <class M,class E> friend E _msup(const M &m) throw();
749  template <class M1,class M2> friend M1 &_mmsetinf(M1 &m1,const M2 &m2)
750 #if(CXSC_INDEX_CHECK)
751  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
752 #else
753  throw();
754 #endif
755  template <class M1,class M2> friend M1 &_mmsetsup(M1 &m1,const M2 &m2)
756 #if(CXSC_INDEX_CHECK)
757  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
758 #else
759  throw();
760 #endif
761  template <class M1,class M2> friend M1 &_mmusetinf(M1 &m1,const M2 &m2)
762 #if(CXSC_INDEX_CHECK)
763  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
764 #else
765  throw();
766 #endif
767  template <class M1,class M2> friend M1 &_mmusetsup(M1 &m1,const M2 &m2)
768 #if(CXSC_INDEX_CHECK)
769  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
770 #else
771  throw();
772 #endif
773  template <class MS,class E> friend E _msinf(const MS &ms) throw();
774  template <class MS,class E> friend E _mssup(const MS &ms) throw();
775  template <class MS1,class M2> friend MS1 &_msmsetinf(MS1 &ms1,const M2 &m2)
776 #if(CXSC_INDEX_CHECK)
777  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
778 #else
779  throw();
780 #endif
781  template <class MS1,class M2> friend MS1 &_msmsetsup(MS1 &ms1,const M2 &m2)
782 #if(CXSC_INDEX_CHECK)
783  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
784 #else
785  throw();
786 #endif
787  template <class MS1,class M2> friend MS1 &_msmusetinf(MS1 &ms1,const M2 &m2)
788 #if(CXSC_INDEX_CHECK)
789  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
790 #else
791  throw();
792 #endif
793  template <class MS1,class M2> friend MS1 &_msmusetsup(MS1 &ms1,const M2 &m2)
794 #if(CXSC_INDEX_CHECK)
795  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
796 #else
797  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
804 #else
805  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
811 #else
812  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
817 #else
818  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
824 #else
825  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<M>);
831 #else
832  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
837 #else
838  throw();
839 #endif
840 
841  template <class M1,class M2> friend M1 &_mmconvassign(M1 &m1,const M2 &m2)
842 #if(CXSC_INDEX_CHECK)
843  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
844 #else
845  throw();
846 #endif
847  template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms)
848 #if(CXSC_INDEX_CHECK)
849  throw(ERROR__OP_WITH_WRONG_DIM<M>);
850 #else
851  throw();
852 #endif
853  template <class MS,class M> friend MS &_msmconvassign(MS &ms,const M &m1)
854 #if(CXSC_INDEX_CHECK)
855  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
856 #else
857  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
862 #else
863  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
868 #else
869  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<M>);
874 #else
875  throw();
876 #endif
877 
878  template <class M1,class M2> friend M1 &_mmsectassign(M1 &m1,const M2 &m2)
879 #if(CXSC_INDEX_CHECK)
880  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
881 #else
882  throw();
883 #endif
884  template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms)
885 #if(CXSC_INDEX_CHECK)
886  throw(ERROR__OP_WITH_WRONG_DIM<M>);
887 #else
888  throw();
889 #endif
890  template <class MS,class M> friend MS &_msmsectassign(MS &ms,const M &m1)
891 #if(CXSC_INDEX_CHECK)
892  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
893 #else
894  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
899 #else
900  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<M>);
906 #else
907  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
912 #else
913  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
918 #else
919  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<M>);
926 #else
927  throw();
928 #endif
929  template <class V,class M,class S> friend V &_vmimultassign(V &v,const M &m)
930 #if(CXSC_INDEX_CHECK)
931  throw(ERROR__OP_WITH_WRONG_DIM<M>);
932 #else
933  throw();
934 #endif
935  template <class VS,class M,class S> friend VS &_vsmimultassign(VS &v,const M &m)
936 #if(CXSC_INDEX_CHECK)
937  throw(ERROR__OP_WITH_WRONG_DIM<M>);
938 #else
939  throw();
940 #endif
941 
942 
943  // complex
944 
945  template <class M,class E> friend E _mre(const M &m) throw();
946  template <class M,class E> friend E _mim(const M &m) throw();
947  template <class M1,class M2> friend M1 &_mmsetre(M1 &m1,const M2 &m2)
948 #if(CXSC_INDEX_CHECK)
949  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
950 #else
951  throw();
952 #endif
953  template <class M1,class M2> friend M1 &_mmsetim(M1 &m1,const M2 &m2)
954 #if(CXSC_INDEX_CHECK)
955  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
956 #else
957  throw();
958 #endif
959  template <class MS,class E> friend E _msre(const MS &ms) throw();
960  template <class MS,class E> friend E _msim(const MS &ms) throw();
961  template <class MS1,class M2> friend MS1 &_msmsetre(MS1 &ms1,const M2 &m2)
962 #if(CXSC_INDEX_CHECK)
963  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
964 #else
965  throw();
966 #endif
967  template <class MS1,class M2> friend MS1 &_msmsetim(MS1 &ms1,const M2 &m2)
968 #if(CXSC_INDEX_CHECK)
969  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
970 #else
971  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
978 #else
979  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
985 #else
986  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
991 #else
992  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
998 #else
999  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1005 #else
1006  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1011 #else
1012  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1019 #else
1020  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1025 #else
1026  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1031 #else
1032  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1038 #else
1039  throw();
1040 #endif
1041  template <class V,class M,class S> friend V &_vmcmultassign(V &v,const M &m)
1042 #if(CXSC_INDEX_CHECK)
1043  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1044 #else
1045  throw();
1046 #endif
1047  template <class VS,class M,class S> friend VS &_vsmcmultassign(VS &v,const M &m)
1048 #if(CXSC_INDEX_CHECK)
1049  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1050 #else
1051  throw();
1052 #endif
1053 
1054 
1055  // cinterval
1056 
1058  friend INLINE rmatrix SupRe(const cimatrix &v) throw();
1060  friend INLINE rmatrix SupIm(const cimatrix &v) throw();
1062  friend INLINE rmatrix InfRe(const cimatrix &v) throw();
1064  friend INLINE rmatrix InfIm(const cimatrix &v) throw();
1066  friend INLINE rmatrix SupRe(const cimatrix_slice &v) throw();
1068  friend INLINE rmatrix SupIm(const cimatrix_slice &v) throw();
1070  friend INLINE rmatrix InfRe(const cimatrix_slice &v) throw();
1072  friend INLINE rmatrix InfIm(const cimatrix_slice &v) throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1079 #else
1080  throw();
1081 #endif
1082  template <class M1,class M2,class S> friend M1 &_mmcimultassign(M1 &m1,const M2 &m2)
1083 #if(CXSC_INDEX_CHECK)
1084  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1085 #else
1086  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1091 #else
1092  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1097 #else
1098  throw();
1099 #endif
1100  template <class M,class MS,class S> friend M &_mmscimultassign(M &m1,const MS &ms)
1101 #if(CXSC_INDEX_CHECK)
1102  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1103 #else
1104  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1109 #else
1110  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1117 #else
1118  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1123 #else
1124  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1129 #else
1130  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1136 #else
1137  throw();
1138 #endif
1139  template <class V,class M,class S> friend V &_vmcimultassign(V &v,const M &m)
1140 #if(CXSC_INDEX_CHECK)
1141  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1142 #else
1143  throw();
1144 #endif
1145  template <class VS,class M,class S> friend VS &_vsmcimultassign(VS &v,const M &m)
1146 #if(CXSC_INDEX_CHECK)
1147  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1148 #else
1149  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1157 #else
1158  throw();
1159 #endif
1160  template <class M1,class M2,class S> friend M1 &_mmlmultassign(M1 &m1,const M2 &m2)
1161 #if(CXSC_INDEX_CHECK)
1162  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1163 #else
1164  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1169 #else
1170  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1176 #else
1177  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1183 #else
1184  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1189 #else
1190  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1196 #else
1197  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1202 #else
1203  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1208 #else
1209  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1215 #else
1216  throw();
1217 #endif
1218  template <class V,class M,class S> friend V &_vmlmultassign(V &v,const M &m)
1219 #if(CXSC_INDEX_CHECK)
1220  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1221 #else
1222  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1230 #else
1231  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1237 #else
1238  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1243 #else
1244  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1250 #else
1251  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1257 #else
1258  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1263 #else
1264  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1272 #else
1273  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1278 #else
1279  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1284 #else
1285  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1291 #else
1292  throw();
1293 #endif
1294  template <class V,class M,class S> friend V &_vmlimultassign(V &v,const M &m)
1295 #if(CXSC_INDEX_CHECK)
1296  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1297 #else
1298  throw();
1299 #endif
1300  template <class VS,class M,class S> friend VS &_vsmlimultassign(VS &v,const M &m)
1301 #if(CXSC_INDEX_CHECK)
1302  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1303 #else
1304  throw();
1305 #endif
1306 
1307 #endif
1308 
1309  //-------------------------- Konstruktoren ----------------------------
1310 
1312  INLINE rmatrix(const rmatrix &rm) throw();
1314  INLINE rmatrix(const rmatrix_slice &rm) throw();
1316  INLINE rmatrix() throw();
1318  explicit INLINE rmatrix(const int &m, const int &n)
1319 #if(CXSC_INDEX_CHECK)
1320  throw(ERROR_RMATRIX_WRONG_BOUNDARIES);
1321 #else
1322  throw();
1323 #endif
1324  explicit INLINE rmatrix(const int &m1, const int &n1, const int &m2, const int &n2)
1326 #if(CXSC_INDEX_CHECK)
1327  throw(ERROR_RMATRIX_WRONG_BOUNDARIES);
1328 #else
1329  throw();
1330 #endif
1331  explicit INLINE rmatrix(const rvector &v) throw();
1334  explicit INLINE rmatrix(const rvector_slice &v) throw();
1336  explicit INLINE rmatrix(const real &r) throw();
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) throw();
1348  INLINE rmatrix &operator =(const rmatrix &m) throw();
1350  INLINE rmatrix &operator =(const rmatrix_slice &ms) throw();
1352  INLINE rmatrix &operator =(const rvector &v) throw();
1354  INLINE rmatrix &operator =(const rvector_slice &v) throw();
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() throw() { delete [] dat; }
1386 
1387  //------------------------- Standardfunktionen -------------------------
1388 
1389  friend INLINE real::real(const rmatrix &m)
1390 #if(CXSC_INDEX_CHECK)
1391  throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ,ERROR_RMATRIX_USE_OF_UNINITIALIZED_OBJ);
1392 #else
1393  throw();
1394 #endif
1395  friend INLINE rvector::rvector(const rmatrix &m)
1396 #if(CXSC_INDEX_CHECK)
1397  throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
1398 #else
1399  throw();
1400 #endif
1401  INLINE rmatrix_subv operator [](const int &i) const
1403 #if(CXSC_INDEX_CHECK)
1404  throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT);
1405 #else
1406  throw();
1407 #endif
1408  INLINE rmatrix_subv operator [](const cxscmatrix_column &i) const
1410 #if(CXSC_INDEX_CHECK)
1411  throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT);
1412 #else
1413  throw();
1414 #endif
1415  INLINE rmatrix &operator ()() throw() { return *this; }
1418  INLINE rmatrix_slice operator ()(const int &m, const int &n)
1419 #if(CXSC_INDEX_CHECK)
1420  throw(ERROR_RMATRIX_SUB_ARRAY_TOO_BIG);
1421 #else
1422  throw();
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  throw(ERROR_RMATRIX_SUB_ARRAY_TOO_BIG);
1428 #else
1429  throw();
1430 #endif
1431  INLINE operator void*() throw();
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  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>);
1462 #else
1463  throw();
1464 #endif
1465  template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m)
1466 #if(CXSC_INDEX_CHECK)
1467  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1468 #else
1469  throw();
1470 #endif
1471  template <class MS1,class MS2> friend MS1 &_msmsassign(MS1 &ms1,const MS2 &ms)
1472 #if(CXSC_INDEX_CHECK)
1473  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1474 #else
1475  throw();
1476 #endif
1477  template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) throw();
1478  template <class MS,class S> friend MS &_mssassign(MS &ms,const S &r) throw();
1479  template <class MS> friend int _mslb(const MS &ms, const int &i)
1480 #if(CXSC_INDEX_CHECK)
1481  throw(ERROR__WRONG_ROW_OR_COL<MS>);
1482 #else
1483  throw();
1484 #endif
1485  template <class MS> friend int _msub(const MS &ms, const int &i)
1486 #if(CXSC_INDEX_CHECK)
1487  throw(ERROR__WRONG_ROW_OR_COL<MS>);
1488 #else
1489  throw();
1490 #endif
1491  template <class MS,class E> friend E _msabs(const MS &ms) throw();
1492  //------------ matrix-matrix --------------------
1493  template <class MS,class E> friend E _msminus(const MS &ms) throw();
1494  template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms)
1495 #if(CXSC_INDEX_CHECK)
1496  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1497 #else
1498  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1503 #else
1504  throw();
1505 #endif
1506  template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms)
1507 #if(CXSC_INDEX_CHECK)
1508  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1509 #else
1510  throw();
1511 #endif
1512  template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1)
1513 #if(CXSC_INDEX_CHECK)
1514  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1515 #else
1516  throw();
1517 #endif
1518  template <class MS1,class MS2> friend MS1 &_msmsplusassign(MS1 &ms1,const MS2 &ms2)
1519 #if(CXSC_INDEX_CHECK)
1520  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1521 #else
1522  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1527 #else
1528  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1533 #else
1534  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1539 #else
1540  throw();
1541 #endif
1542  template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms)
1543 #if(CXSC_INDEX_CHECK)
1544  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1545 #else
1546  throw();
1547 #endif
1548  template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1)
1549 #if(CXSC_INDEX_CHECK)
1550  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1551 #else
1552  throw();
1553 #endif
1554  template <class MS1,class MS2> friend MS1 &_msmsminusassign(MS1 &ms1,const MS2 &ms2)
1555 #if(CXSC_INDEX_CHECK)
1556  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1557 #else
1558  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1563 #else
1564  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1569 #else
1570  throw();
1571 #endif
1572  template <class M,class MS,class S> friend M &_mmsmultassign(M &m1,const MS &ms)
1573 #if(CXSC_INDEX_CHECK)
1574  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1575 #else
1576  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1581 #else
1582  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1587 #else
1588  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1593 #else
1594  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1600 #else
1601  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1606 #else
1607  throw();
1608 #endif
1609  template <class V,class MS,class S> friend V &_vmsmultassign(V &v,const MS &ms)
1610 #if(CXSC_INDEX_CHECK)
1611  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1612 #else
1613  throw();
1614 #endif
1615  //--------- matrix-scalar -----------------
1616  template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) throw();
1617  template <class MS,class S> friend MS &_mssmultassign(MS &ms,const S &c) throw();
1618  template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) throw();
1619  template <class MS,class S> friend MS &_mssdivassign(MS &ms,const S &c) throw();
1620 
1621  template <class MS> friend void *_msvoid(const MS &ms) throw();
1622  template <class MS> friend bool _msnot(const MS &ms) throw();
1623  template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) throw();
1624  template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) throw();
1625  template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) throw();
1626  template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) throw();
1627  template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) throw();
1628  template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) throw();
1629  template <class MS1,class MS2> friend bool _msmseq(const MS1 &ms1,const MS2 &ms2) throw();
1630  template <class MS1,class MS2> friend bool _msmsneq(const MS1 &ms1,const MS2 &ms2) throw();
1631  template <class MS1,class MS2> friend bool _msmsless(const MS1 &ms1,const MS2 &ms2) throw();
1632  template <class MS1,class MS2> friend bool _msmsleq(const MS1 &ms1,const MS2 &ms2) throw();
1633  template <class MS> friend std::ostream &_msout(std::ostream &s,const MS &r) throw();
1634  template <class MS> friend std::istream &_msin(std::istream &s,MS &r) throw();
1635 
1636  // Interval
1637  template <class M1,class MS2> friend M1 &_mmssetinf(M1 &m1,const MS2 &ms2)
1638 #if(CXSC_INDEX_CHECK)
1639  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1640 #else
1641  throw();
1642 #endif
1643  template <class M1,class MS2> friend M1 &_mmssetsup(M1 &m1,const MS2 &ms2)
1644 #if(CXSC_INDEX_CHECK)
1645  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1646 #else
1647  throw();
1648 #endif
1649  template <class M1,class MS2> friend M1 &_mmsusetinf(M1 &m1,const MS2 &ms2)
1650 #if(CXSC_INDEX_CHECK)
1651  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1652 #else
1653  throw();
1654 #endif
1655  template <class M1,class MS2> friend M1 &_mmsusetsup(M1 &m1,const MS2 &ms2)
1656 #if(CXSC_INDEX_CHECK)
1657  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1658 #else
1659  throw();
1660 #endif
1661  template <class MS1,class MS2> friend MS1 &_msmssetinf(MS1 &ms1,const MS2 &ms2)
1662 #if(CXSC_INDEX_CHECK)
1663  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1664 #else
1665  throw();
1666 #endif
1667  template <class MS1,class MS2> friend MS1 &_msmssetsup(MS1 &ms1,const MS2 &ms2)
1668 #if(CXSC_INDEX_CHECK)
1669  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1670 #else
1671  throw();
1672 #endif
1673  template <class MS1,class MS2> friend MS1 &_msmsusetinf(MS1 &ms1,const MS2 &ms2)
1674 #if(CXSC_INDEX_CHECK)
1675  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1676 #else
1677  throw();
1678 #endif
1679  template <class MS1,class MS2> friend MS1 &_msmsusetsup(MS1 &ms1,const MS2 &ms2)
1680 #if(CXSC_INDEX_CHECK)
1681  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1682 #else
1683  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1689 #else
1690  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1695 #else
1696  throw();
1697 #endif
1698  template <class V,class MS,class S> friend V &_vmsimultassign(V &v,const MS &ms)
1699 #if(CXSC_INDEX_CHECK)
1700  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1701 #else
1702  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1710 #else
1711  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1716 #else
1717  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1723 #else
1724  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1730 #else
1731  throw();
1732 #endif
1733 
1734  template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms)
1735 #if(CXSC_INDEX_CHECK)
1736  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1737 #else
1738  throw();
1739 #endif
1740  template <class MS1,class MS2> friend MS1 &_msmsconvassign(MS1 &ms1,const MS2 &ms2)
1741 #if(CXSC_INDEX_CHECK)
1742  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1743 #else
1744  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1749 #else
1750  throw();
1751 #endif
1752  template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms)
1753 #if(CXSC_INDEX_CHECK)
1754  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1755 #else
1756  throw();
1757 #endif
1758  template <class MS1,class MS2> friend MS1 &_msmssectassign(MS1 &ms1,const MS2 &ms2)
1759 #if(CXSC_INDEX_CHECK)
1760  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1761 #else
1762  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1767 #else
1768  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1776 #else
1777  throw();
1778 #endif
1779  template <class MS1,class MS2> friend MS1 &_msmssetim(MS1 &ms1,const MS2 &ms2)
1780 #if(CXSC_INDEX_CHECK)
1781  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1782 #else
1783  throw();
1784 #endif
1785  template <class M1,class MS2> friend M1 &_mmssetre(M1 &m1,const MS2 &ms2)
1786 #if(CXSC_INDEX_CHECK)
1787  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1788 #else
1789  throw();
1790 #endif
1791  template <class M1,class MS2> friend M1 &_mmssetim(M1 &m1,const MS2 &ms2)
1792 #if(CXSC_INDEX_CHECK)
1793  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1794 #else
1795  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1801 #else
1802  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1807 #else
1808  throw();
1809 #endif
1810  template <class V,class MS,class S> friend V &_vmscmultassign(V &v,const MS &ms)
1811 #if(CXSC_INDEX_CHECK)
1812  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1813 #else
1814  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1822 #else
1823  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1828 #else
1829  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1835 #else
1836  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1841 #else
1842  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1849 #else
1850  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1855 #else
1856  throw();
1857 #endif
1858  template <class V,class MS,class S> friend V &_vmscimultassign(V &v,const MS &ms)
1859 #if(CXSC_INDEX_CHECK)
1860  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1861 #else
1862  throw();
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  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
1868 #else
1869  throw();
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  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
1874 #else
1875  throw();
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  throw(ERROR_CIMATRIX_OP_WITH_WRONG_DIM);
1880 #else
1881  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1888 #else
1889  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1894 #else
1895  throw();
1896 #endif
1897  template <class M,class MS,class S> friend M &_mmscimultassign(M &m1,const MS &ms)
1898 #if(CXSC_INDEX_CHECK)
1899  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1900 #else
1901  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1907 #else
1908  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1915 #else
1916  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1921 #else
1922  throw();
1923 #endif
1924  template <class V,class MS,class S> friend V &_vmslmultassign(V &v,const MS &ms)
1925 #if(CXSC_INDEX_CHECK)
1926  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1927 #else
1928  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1935 #else
1936  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1941 #else
1942  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1948 #else
1949  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1954 #else
1955  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1962 #else
1963  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1968 #else
1969  throw();
1970 #endif
1971  template <class V,class MS,class S> friend V &_vmslimultassign(V &v,const MS &ms)
1972 #if(CXSC_INDEX_CHECK)
1973  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1974 #else
1975  throw();
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  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1981 #else
1982  throw();
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  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1987 #else
1988  throw();
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  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1993 #else
1994  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
2001 #else
2002  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
2007 #else
2008  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<M>);
2014 #else
2015  throw();
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  throw(ERROR__OP_WITH_WRONG_DIM<E>);
2021 #else
2022  throw();
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) throw():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) throw():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) throw():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  throw(ERROR_RMATRIX_TYPE_CAST_OF_THICK_OBJ);
2045 #else
2046  throw();
2047 #endif
2048  friend INLINE rmatrix::rmatrix(const rmatrix_slice &) throw();
2050  INLINE rmatrix_slice &operator =(const srmatrix &m);
2052  INLINE rmatrix_slice &operator =(const srmatrix_slice &m);
2053 
2055  INLINE rmatrix_slice &operator =(const rmatrix &m)
2056 #if(CXSC_INDEX_CHECK)
2057  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2058 #else
2059  throw();
2060 #endif
2061  INLINE rmatrix_slice &operator =(const rmatrix_slice &ms)
2063 #if(CXSC_INDEX_CHECK)
2064  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2065 #else
2066  throw();
2067 #endif
2068  INLINE rmatrix_slice &operator =(const real &r) throw();
2071  INLINE rmatrix_slice &operator =(const rvector &v)
2072 #if(CXSC_INDEX_CHECK)
2073  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2074 #else
2075  throw();
2076 #endif
2077  INLINE rmatrix_slice &operator =(const rvector_slice &v)
2079 #if(CXSC_INDEX_CHECK)
2080  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2081 #else
2082  throw();
2083 #endif
2084  INLINE rmatrix_slice &operator =(const rmatrix_subv &v)
2086 #if(CXSC_INDEX_CHECK)
2087  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2088 #else
2089  throw();
2090 #endif
2091  INLINE rmatrix_subv operator [](const int &i) const
2093 #if(CXSC_INDEX_CHECK)
2094  throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT);
2095 #else
2096  throw();
2097 #endif
2098  INLINE rmatrix_subv operator [](const cxscmatrix_column &i) const
2100 #if(CXSC_INDEX_CHECK)
2101  throw(ERROR_RMATRIX_ROW_OR_COL_NOT_IN_MAT);
2102 #else
2103  throw();
2104 #endif
2105  INLINE rmatrix_slice &operator ()() throw() { return *this; }
2108  INLINE rmatrix_slice operator ()(const int &m, const int &n)
2109 #if(CXSC_INDEX_CHECK)
2110  throw(ERROR_RMATRIX_SUB_ARRAY_TOO_BIG);
2111 #else
2112  throw();
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  throw(ERROR_RMATRIX_SUB_ARRAY_TOO_BIG);
2118 #else
2119  throw();
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  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2131 #else
2132  throw();
2133 #endif
2134  INLINE rmatrix_slice &operator *=(const rmatrix_slice &ms2)
2136 #if(CXSC_INDEX_CHECK)
2137  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2138 #else
2139  throw();
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  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2151 #else
2152  throw();
2153 #endif
2154  INLINE rmatrix_slice &operator +=(const rmatrix_slice &ms2)
2156 #if(CXSC_INDEX_CHECK)
2157  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2158 #else
2159  throw();
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  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2171 #else
2172  throw();
2173 #endif
2174  INLINE rmatrix_slice &operator -=(const rmatrix_slice &ms2)
2176 #if(CXSC_INDEX_CHECK)
2177  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2178 #else
2179  throw();
2180 #endif
2181  INLINE rmatrix_slice &operator *=(const real &c) throw();
2184  INLINE rmatrix_slice &operator /=(const real &c) throw();
2185  INLINE operator void*() throw();
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) throw();
2198  INLINE rvector operator *(const rmatrix_subv &rv, const real &s) throw();
2200  INLINE rvector operator *(const real &s, const rmatrix_subv &rv) throw();
2202  INLINE rvector abs(const rmatrix_subv &mv) throw();
2203 
2204 //======================== Vector / Vector ========================
2205 
2207  void accumulate(dotprecision &dp, const rmatrix_subv & rv1, const rmatrix_subv &rv2)
2208 #if(CXSC_INDEX_CHECK)
2209  throw(OP_WITH_WRONG_DIM);
2210 #else
2211  throw();
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  throw(OP_WITH_WRONG_DIM);
2221 #else
2222  throw();
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  throw(OP_WITH_WRONG_DIM);
2232 #else
2233  throw();
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  throw(OP_WITH_WRONG_DIM);
2243 #else
2244  throw();
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  throw(OP_WITH_WRONG_DIM);
2254 #else
2255  throw();
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  throw(OP_WITH_WRONG_DIM);
2265 #else
2266  throw();
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  throw(OP_WITH_WRONG_DIM);
2276 #else
2277  throw();
2278 #endif
2279  void accumulate(idotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2)
2281 #if(CXSC_INDEX_CHECK)
2282  throw(OP_WITH_WRONG_DIM);
2283 #else
2284  throw();
2285 #endif
2286  void accumulate(idotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2)
2288 #if(CXSC_INDEX_CHECK)
2289  throw(OP_WITH_WRONG_DIM);
2290 #else
2291  throw();
2292 #endif
2293  void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const rmatrix_subv &rv2)
2295 #if(CXSC_INDEX_CHECK)
2296  throw(OP_WITH_WRONG_DIM);
2297 #else
2298  throw();
2299 #endif
2300  void accumulate(cidotprecision &dp, const rvector & rv1, const rmatrix_subv &rv2)
2302 #if(CXSC_INDEX_CHECK)
2303  throw(OP_WITH_WRONG_DIM);
2304 #else
2305  throw();
2306 #endif
2307  void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const rvector &rv2)
2309 #if(CXSC_INDEX_CHECK)
2310  throw(OP_WITH_WRONG_DIM);
2311 #else
2312  throw();
2313 #endif
2314  void accumulate(dotprecision &dp,const rvector_slice &sl,const rmatrix_subv &sv)
2316 #if(CXSC_INDEX_CHECK)
2317  throw(OP_WITH_WRONG_DIM);
2318 #else
2319  throw();
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  throw(OP_WITH_WRONG_DIM);
2330 #else
2331  throw();
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  throw(OP_WITH_WRONG_DIM);
2341 #else
2342  throw();
2343 #endif
2344 
2346  void accumulate(cidotprecision &dp, const rvector_slice & sl1, const rmatrix_subv &rv2)
2347 #if(CXSC_INDEX_CHECK)
2348  throw(OP_WITH_WRONG_DIM);
2349 #else
2350  throw();
2351 #endif
2352 
2354  void accumulate(dotprecision &dp,const rmatrix_subv &mv,const rvector_slice &vs)
2355 #if(CXSC_INDEX_CHECK)
2356  throw(OP_WITH_WRONG_DIM);
2357 #else
2358  throw();
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  throw(OP_WITH_WRONG_DIM);
2369 #else
2370  throw();
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  throw(OP_WITH_WRONG_DIM);
2380 #else
2381  throw();
2382 #endif
2383 
2385  void accumulate(cidotprecision &dp, const rmatrix_subv & rv1, const rvector_slice &sl2)
2386 #if(CXSC_INDEX_CHECK)
2387  throw(OP_WITH_WRONG_DIM);
2388 #else
2389  throw();
2390 #endif
2391 
2393  INLINE real operator *(const rmatrix_subv & rv1, const rmatrix_subv &rv2)
2394 #if(CXSC_INDEX_CHECK)
2395  throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
2396 #else
2397  throw();
2398 #endif
2399  INLINE real operator *(const rvector & rv1, const rmatrix_subv &rv2)
2401 #if(CXSC_INDEX_CHECK)
2402  throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
2403 #else
2404  throw();
2405 #endif
2406  INLINE real operator *(const rmatrix_subv &rv1,const rvector &rv2)
2408 #if(CXSC_INDEX_CHECK)
2409  throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
2410 #else
2411  throw();
2412 #endif
2413  INLINE real operator *(const rvector_slice &sl,const rmatrix_subv &sv)
2415 #if(CXSC_INDEX_CHECK)
2416  throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
2417 #else
2418  throw();
2419 #endif
2420  INLINE real operator *(const rmatrix_subv &mv,const rvector_slice &vs)
2422 #if(CXSC_INDEX_CHECK)
2423  throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
2424 #else
2425  throw();
2426 #endif
2427 
2429  INLINE rvector operator +(const rmatrix_subv & rv1, const rmatrix_subv &rv2)
2430 #if(CXSC_INDEX_CHECK)
2431  throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
2432 #else
2433  throw();
2434 #endif
2435  INLINE rvector operator +(const rmatrix_subv &rv1,const rvector &rv2)
2437 #if(CXSC_INDEX_CHECK)
2438  throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
2439 #else
2440  throw();
2441 #endif
2442  INLINE rvector operator +(const rvector & rv1, const rmatrix_subv &rv2)
2444 #if(CXSC_INDEX_CHECK)
2445  throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
2446 #else
2447  throw();
2448 #endif
2449  INLINE rvector operator +(const rvector_slice &sl,const rmatrix_subv &mv)
2451 #if(CXSC_INDEX_CHECK)
2452  throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
2453 #else
2454  throw();
2455 #endif
2456  INLINE rvector operator +(const rmatrix_subv &mv,const rvector_slice &sl)
2458 #if(CXSC_INDEX_CHECK)
2459  throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
2460 #else
2461  throw();
2462 #endif
2463 
2465  INLINE rvector operator -(const rmatrix_subv & rv1, const rmatrix_subv &rv2)
2466 #if(CXSC_INDEX_CHECK)
2467  throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
2468 #else
2469  throw();
2470 #endif
2471  INLINE rvector operator -(const rvector & rv1, const rmatrix_subv &rv2)
2473 #if(CXSC_INDEX_CHECK)
2474  throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
2475 #else
2476  throw();
2477 #endif
2478  INLINE rvector operator -(const rmatrix_subv &rv1,const rvector &rv2)
2480 #if(CXSC_INDEX_CHECK)
2481  throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
2482 #else
2483  throw();
2484 #endif
2485  INLINE rvector operator -(const rvector_slice &sl,const rmatrix_subv &mv)
2487 #if(CXSC_INDEX_CHECK)
2488  throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
2489 #else
2490  throw();
2491 #endif
2492  INLINE rvector operator -(const rmatrix_subv &mv,const rvector_slice &sl)
2494 #if(CXSC_INDEX_CHECK)
2495  throw(ERROR_RVECTOR_OP_WITH_WRONG_DIM);
2496 #else
2497  throw();
2498 #endif
2499 
2500 //====================================================================
2501 //===================== Matrix Functions =============================
2502 
2504  INLINE rmatrix _rmatrix(const rmatrix &rm) throw();
2506  INLINE rmatrix _rmatrix(const rvector &v) throw();
2508  INLINE rmatrix _rmatrix(const rvector_slice &v) throw();
2510  INLINE rmatrix _rmatrix(const real &r) throw();
2511 
2513  INLINE int Lb(const rmatrix &rm, const int &i)
2514 #if(CXSC_INDEX_CHECK)
2515  throw(ERROR_RMATRIX_WRONG_ROW_OR_COL);
2516 #else
2517  throw();
2518 #endif
2519  INLINE int Ub(const rmatrix &rm, const int &i)
2521 #if(CXSC_INDEX_CHECK)
2522  throw(ERROR_RMATRIX_WRONG_ROW_OR_COL);
2523 #else
2524  throw();
2525 #endif
2526  INLINE int Lb(const rmatrix_slice &rm, const int &i)
2528 #if(CXSC_INDEX_CHECK)
2529  throw(ERROR_RMATRIX_WRONG_ROW_OR_COL);
2530 #else
2531  throw();
2532 #endif
2533  INLINE int Ub(const rmatrix_slice &rm, const int &i)
2535 #if(CXSC_INDEX_CHECK)
2536  throw(ERROR_RMATRIX_WRONG_ROW_OR_COL);
2537 #else
2538  throw();
2539 #endif
2540  INLINE rmatrix &SetLb(rmatrix &m, const int &i,const int &j)
2542 #if(CXSC_INDEX_CHECK)
2543  throw(ERROR_RMATRIX_WRONG_ROW_OR_COL);
2544 #else
2545  throw();
2546 #endif
2547  INLINE rmatrix &SetUb(rmatrix &m, const int &i,const int &j)
2549 #if(CXSC_INDEX_CHECK)
2550  throw(ERROR_RMATRIX_WRONG_ROW_OR_COL);
2551 #else
2552  throw();
2553 #endif
2554  INLINE void Resize(rmatrix &A) throw();
2557  INLINE void Resize(rmatrix &A,const int &m, const int &n)
2558 #if(CXSC_INDEX_CHECK)
2559  throw(ERROR_RMATRIX_WRONG_BOUNDARIES);
2560 #else
2561  throw();
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  throw(ERROR_RMATRIX_WRONG_BOUNDARIES);
2567 #else
2568  throw();
2569 #endif
2570 
2572  INLINE rmatrix abs(const rmatrix &m) throw();
2574  INLINE rmatrix abs(const rmatrix_slice &ms) throw();
2576  INLINE rmatrix CompMat(const rmatrix &m) throw();
2577 
2578 //===================== Matrix / Scalar ===============================
2579 
2581  INLINE rmatrix operator *(const real &c, const rmatrix &m) throw();
2583  INLINE rmatrix operator *(const real &c, const rmatrix_slice &ms) throw();
2585  INLINE rmatrix operator *(const rmatrix &m,const real &c) throw();
2587  INLINE rmatrix operator *(const rmatrix_slice &ms,const real &c) throw();
2589  INLINE rmatrix &operator *=(rmatrix &m,const real &c) throw();
2591  INLINE rmatrix operator /(const rmatrix &m,const real &c) throw();
2593  INLINE rmatrix operator /(const rmatrix_slice &ms, const real &c) throw();
2595  INLINE rmatrix &operator /=(rmatrix &m,const real &c) throw();
2596 
2597 //============================ Matrix / Vector ===================================
2598 
2599 //--------------------------- rvector ---------------------------
2600 
2602  INLINE rvector operator *(const rmatrix &m,const rvector &v)
2603 #if(CXSC_INDEX_CHECK)
2604  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2605 #else
2606  throw();
2607 #endif
2608  INLINE rvector operator *(const rmatrix_slice &ms,const rvector &v)
2610 #if(CXSC_INDEX_CHECK)
2611  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2612 #else
2613  throw();
2614 #endif
2615  INLINE rvector operator *(const rvector &v,const rmatrix &m)
2617 #if(CXSC_INDEX_CHECK)
2618  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2619 #else
2620  throw();
2621 #endif
2622  INLINE rvector operator *(const rvector &v,const rmatrix_slice &ms)
2624 #if(CXSC_INDEX_CHECK)
2625  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2626 #else
2627  throw();
2628 #endif
2629  INLINE rvector &operator *=(rvector &v,const rmatrix &m)
2631 #if(CXSC_INDEX_CHECK)
2632  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2633 #else
2634  throw();
2635 #endif
2636  INLINE rvector &operator *=(rvector &v,const rmatrix_slice &ms)
2638 #if(CXSC_INDEX_CHECK)
2639  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2640 #else
2641  throw();
2642 #endif
2643 
2644  // Test
2646  INLINE rvector operator *(const rvector_slice &v,const rmatrix &m)
2647 #if(CXSC_INDEX_CHECK)
2648  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2649 #else
2650  throw();
2651 #endif
2652 
2653 
2654 
2655 //================ Matrix / Matrix ============================
2656 
2658  INLINE const rmatrix &operator +(const rmatrix &m1) throw();
2660  INLINE rmatrix operator +(const rmatrix_slice &ms) throw();
2662  INLINE rmatrix operator +(const rmatrix &m1,const rmatrix &m2)
2663 #if(CXSC_INDEX_CHECK)
2664  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2665 #else
2666  throw();
2667 #endif
2668  INLINE rmatrix operator +(const rmatrix &m,const rmatrix_slice &ms)
2670 #if(CXSC_INDEX_CHECK)
2671  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2672 #else
2673  throw();
2674 #endif
2675  INLINE rmatrix operator +(const rmatrix_slice &ms,const rmatrix &m)
2677 #if(CXSC_INDEX_CHECK)
2678  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2679 #else
2680  throw();
2681 #endif
2682  INLINE rmatrix operator +(const rmatrix_slice &m1,const rmatrix_slice &m2)
2684 #if(CXSC_INDEX_CHECK)
2685  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2686 #else
2687  throw();
2688 #endif
2689  INLINE rmatrix &operator +=(rmatrix &m1,const rmatrix &m2)
2691 #if(CXSC_INDEX_CHECK)
2692  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2693 #else
2694  throw();
2695 #endif
2696  INLINE rmatrix &operator +=(rmatrix &m1,const rmatrix_slice &ms)
2698 #if(CXSC_INDEX_CHECK)
2699  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2700 #else
2701  throw();
2702 #endif
2703 
2705  INLINE rmatrix operator -(const rmatrix &m) throw();
2707  INLINE rmatrix operator -(const rmatrix_slice &ms) throw();
2709  INLINE rmatrix operator -(const rmatrix &m1,const rmatrix &m2)
2710 #if(CXSC_INDEX_CHECK)
2711  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2712 #else
2713  throw();
2714 #endif
2715  INLINE rmatrix operator -(const rmatrix &m,const rmatrix_slice &ms)
2717 #if(CXSC_INDEX_CHECK)
2718  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2719 #else
2720  throw();
2721 #endif
2722  INLINE rmatrix operator -(const rmatrix_slice &ms,const rmatrix &m)
2724 #if(CXSC_INDEX_CHECK)
2725  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2726 #else
2727  throw();
2728 #endif
2729  INLINE rmatrix operator -(const rmatrix_slice &ms1,const rmatrix_slice &ms2)
2731 #if(CXSC_INDEX_CHECK)
2732  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2733 #else
2734  throw();
2735 #endif
2736  INLINE rmatrix &operator -=(rmatrix &m1,const rmatrix &m2)
2738 #if(CXSC_INDEX_CHECK)
2739  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2740 #else
2741  throw();
2742 #endif
2743  INLINE rmatrix &operator -=(rmatrix &m1,const rmatrix_slice &ms)
2745 #if(CXSC_INDEX_CHECK)
2746  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2747 #else
2748  throw();
2749 #endif
2750 
2752  INLINE rmatrix operator *(const rmatrix &m1, const rmatrix &m2)
2753 #if(CXSC_INDEX_CHECK)
2754  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2755 #else
2756  throw();
2757 #endif
2758  INLINE rmatrix operator *(const rmatrix &m1, const rmatrix_slice &ms)
2760 #if(CXSC_INDEX_CHECK)
2761  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2762 #else
2763  throw();
2764 #endif
2765  INLINE rmatrix operator *(const rmatrix_slice &ms, const rmatrix &m1)
2767 #if(CXSC_INDEX_CHECK)
2768  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2769 #else
2770  throw();
2771 #endif
2772  INLINE rmatrix operator *(const rmatrix_slice &ms1, const rmatrix_slice &ms2)
2774 #if(CXSC_INDEX_CHECK)
2775  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2776 #else
2777  throw();
2778 #endif
2779  INLINE rmatrix &operator *=(rmatrix &m1,const rmatrix &m2)
2781 #if(CXSC_INDEX_CHECK)
2782  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2783 #else
2784  throw();
2785 #endif
2786  INLINE rmatrix &operator *=(rmatrix &m1,const rmatrix_slice &ms)
2788 #if(CXSC_INDEX_CHECK)
2789  throw(ERROR_RMATRIX_OP_WITH_WRONG_DIM);
2790 #else
2791  throw();
2792 #endif
2793 
2794 
2795 
2796 //============== Compare Operator ==========================
2797 
2798 //-------------- Matrix - Matrix -------------------------
2799 
2801  INLINE bool operator ==(const rmatrix &m1,const rmatrix &m2) throw();
2803  INLINE bool operator !=(const rmatrix &m1,const rmatrix &m2) throw();
2805  INLINE bool operator <(const rmatrix &m1,const rmatrix &m2) throw();
2807  INLINE bool operator <=(const rmatrix &m1,const rmatrix &m2) throw();
2809  INLINE bool operator >(const rmatrix &m1,const rmatrix &m2) throw();
2811  INLINE bool operator >=(const rmatrix &m1,const rmatrix &m2) throw();
2813  INLINE bool operator ==(const rmatrix &m1,const rmatrix_slice &ms) throw();
2815  INLINE bool operator !=(const rmatrix &m1,const rmatrix_slice &ms) throw();
2817  INLINE bool operator <(const rmatrix &m1,const rmatrix_slice &ms) throw();
2819  INLINE bool operator <=(const rmatrix &m1,const rmatrix_slice &ms) throw();
2821  INLINE bool operator >(const rmatrix &m1,const rmatrix_slice &ms) throw();
2823  INLINE bool operator >=(const rmatrix &m1,const rmatrix_slice &ms) throw();
2824 
2825 //---------------- Matrix - Matrix_slice ----------------------
2826 
2828  INLINE bool operator ==(const rmatrix_slice &m1,const rmatrix_slice &m2) throw();
2830  INLINE bool operator !=(const rmatrix_slice &m1,const rmatrix_slice &m2) throw();
2832  INLINE bool operator <(const rmatrix_slice &m1,const rmatrix_slice &m2) throw();
2834  INLINE bool operator <=(const rmatrix_slice &m1,const rmatrix_slice &m2) throw();
2836  INLINE bool operator >(const rmatrix_slice &m1,const rmatrix_slice &m2) throw();
2838  INLINE bool operator >=(const rmatrix_slice &m1,const rmatrix_slice &m2) throw();
2839 
2840 //=================== Not Operator =============================
2841 
2843  INLINE bool operator !(const rmatrix &ms) throw();
2845  INLINE bool operator !(const rmatrix_slice &ms) throw();
2846 
2847 //======================== Input / Output ========================
2848 
2850  INLINE std::ostream &operator <<(std::ostream &s,const rmatrix &r) throw();
2852  INLINE std::ostream &operator <<(std::ostream &s,const rmatrix_slice &r) throw();
2854  INLINE std::istream &operator >>(std::istream &s,rmatrix &r) throw();
2856  INLINE std::istream &operator >>(std::istream &s,rmatrix_slice &r) throw();
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
rmatrix_subv & operator=(const rmatrix_subv &rv)
Implementation of standard assigning operator.
Definition: rmatrix.inl:322
friend int Lb(const rmatrix_subv &rv)
Returns the lower bound of the vector.
Definition: rmatrix.hpp:314
The Data Type rmatrix_slice.
Definition: rmatrix.hpp:1442
The Data Type idotprecision.
Definition: idot.hpp:47
The Data Type dotprecision.
Definition: dot.hpp:111
The Data Type intmatrix.
Definition: intmatrix.hpp:313
friend int VecLen(const rmatrix_subv &rv)
Returns the size of the vector.
Definition: rmatrix.hpp:318
The Data Type cimatrix_slice.
Definition: cimatrix.hpp:1650
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
civector operator*(const cimatrix_subv &rv, const cinterval &s)
Implementation of multiplication operation.
Definition: cimatrix.inl:731
rmatrix _rmatrix(const rmatrix &rm)
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC...
Definition: rmatrix.inl:574
The Data Type civector.
Definition: civector.hpp:56
cimatrix & SetLb(cimatrix &m, const int &i, const int &j)
Sets the lower bound index.
Definition: cimatrix.inl:1184
rmatrix_subv(const rmatrix_subv &v)
Constructor of class rmatrix_subv.
Definition: rmatrix.hpp:269
rmatrix_slice(rmatrix &a, const int &l1, const int &u1, const int &l2, const int &u2)
Constructor of class rmatrix_slice.
Definition: rmatrix.hpp:2032
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
A sparse real matrix.
Definition: srmatrix.hpp:77
The Multiple-Precision Data Type l_ivector.
Definition: l_ivector.hpp:54
void DoubleSize(cimatrix &A)
Doubles the size of the matrix.
Definition: cimatrix.cpp:83
rmatrix_subv & operator/=(const real &c)
Implementation of division and allocation operation.
Definition: rmatrix.inl:430
The Data Type cidotprecision.
Definition: cidot.hpp:57
A sparse real vector.
Definition: srvector.hpp:58
cimatrix Id(const cimatrix &A)
Returns the Identity matrix.
Definition: cimatrix.cpp:61
The Data Type rvector_slice.
Definition: rvector.hpp:1063
The Data Type cvector.
Definition: cvector.hpp:57
The Multiple-Precision Data Type l_imatrix.
Definition: l_imatrix.hpp:725
cimatrix & SetUb(cimatrix &m, const int &i, const int &j)
Sets the upper bound index.
Definition: cimatrix.inl:1191
The Data Type rmatrix_subv.
Definition: rmatrix.hpp:53
The Multiple-Precision Data Type l_rmatrix.
Definition: l_rmatrix.hpp:415
The Data Type rvector.
Definition: rvector.hpp:57
The Data Type cmatrix.
Definition: cmatrix.hpp:513
A slice of a sparse real matrix.
Definition: srmatrix.hpp:1360
The Data Type cdotprecision.
Definition: cdot.hpp:60
void Resize(cimatrix &A)
Resizes the matrix.
Definition: cimatrix.inl:1211
rmatrix_subv & operator-=(const real &c)
Implementation of subtraction and allocation operation.
Definition: rmatrix.inl:429
Represents a row or column vector of a sparse matrix.
Definition: srmatrix.hpp:2157
The Data Type rmatrix.
Definition: rmatrix.hpp:470
int ColLen(const cimatrix &)
Returns the column dimension.
Definition: cimatrix.inl:1202
rmatrix_subv & operator+=(const real &c)
Implementation of addition and allocation operation.
Definition: rmatrix.inl:428
rmatrix_subv & operator()()
Operator for accessing the whole vector.
Definition: rmatrix.hpp:337
real & operator[](const int &i) const
Operator for accessing the single elements of the vector (read-only)
Definition: rmatrix.inl:162
int RowLen(const cimatrix &)
Returns the row dimension.
Definition: cimatrix.inl:1199
friend rmatrix_subv Row(rmatrix &m, const int &i)
Returns one row of the matrix as a vector.
Definition: rmatrix.inl:119
The Data Type ivector.
Definition: ivector.hpp:54
rmatrix CompMat(const cimatrix &A)
Returns Ostrowski&#39;s comparison matrix.
Definition: cimatrix.cpp:45
real(void)
Constructor of class real.
Definition: real.hpp:122
The Multiple-Precision Data Type l_rvector.
Definition: l_rvector.hpp:53
rmatrix_subv & operator*=(const real &c)
Implementation of multiplication and allocation operation.
Definition: rmatrix.inl:427
rvector()
Constructor of class rvector.
Definition: rvector.inl:37
The Data Type imatrix.
Definition: imatrix.hpp:659
friend rmatrix_subv Col(rmatrix &m, const int &i)
Returns one column of the matrix as a vector.
Definition: rmatrix.inl:130
rmatrix_subv(real *d, const int &l, const int &u, const int &s, const int &st, const int &o)
Constructor of class rmatrix_subv.
Definition: rmatrix.hpp:266
Helper class for slices of sparse vectors.
Definition: srvector.hpp:868
rmatrix_slice(rmatrix_slice &a, const int &l1, const int &u1, const int &l2, const int &u2)
Constructor of class rmatrix_slice.
Definition: rmatrix.hpp:2034
rmatrix_slice(const rmatrix_slice &ms)
Constructor of class rmatrix_slice.
Definition: rmatrix.hpp:2037
rmatrix()
Constructor of class rmatrix.
Definition: rmatrix.inl:33
civector operator/(const cimatrix_subv &rv, const cinterval &s)
Implementation of division operation.
Definition: cimatrix.inl:730
cimatrix transp(const cimatrix &A)
Returns the transposed matrix.
Definition: cimatrix.cpp:74
The Scalar Type real.
Definition: real.hpp:113
The Data Type intvector.
Definition: intvector.hpp:51
friend int Ub(const rmatrix_subv &rv)
Returns the upper bound of the vector.
Definition: rmatrix.hpp:316
The Data Type cimatrix.
Definition: cimatrix.hpp:907
ivector abs(const cimatrix_subv &mv)
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737