C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
l_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: l_rmatrix.hpp,v 1.20 2014/01/30 17:23:46 cxsc Exp $ */
25 
26 #ifndef _CXSC_LRMATRIX_HPP_INCLUDED
27 #define _CXSC_LRMATRIX_HPP_INCLUDED
28 
29 #include "xscclass.hpp"
30 #include "dot.hpp"
31 #include "idot.hpp"
32 #include "l_rvector.hpp"
33 #include "except.hpp"
34 #include "matrix.hpp"
35 #include "rmatrix.hpp"
36 
37 namespace cxsc {
38 
39 class l_rmatrix;
40 class l_rmatrix_slice;
41 
43 
47 {
48  friend class l_rvector;
49  friend class l_ivector;
50  friend class l_rmatrix;
51  friend class l_rmatrix_slice;
52  private:
53  l_real *dat;
54  int lb,ub;
55  int size,start,offset; // start=first element index 0..n-1
56 
57  public:
59  friend INLINE l_rmatrix_subv Row(l_rmatrix &m,const int &i)
60 #if(CXSC_INDEX_CHECK)
61  throw(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT);
62 #else
63  throw();
64 #endif
65  friend INLINE l_rmatrix_subv Col(l_rmatrix &m,const int &i)
67 #if(CXSC_INDEX_CHECK)
68  throw(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT);
69 #else
70  throw();
71 #endif
72  friend INLINE l_rmatrix_subv Row(const l_rmatrix &m,const int &i)
74 #if(CXSC_INDEX_CHECK)
75  throw(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT);
76 #else
77  throw();
78 #endif
79  friend INLINE l_rmatrix_subv Col(const l_rmatrix &m,const int &i)
81 #if(CXSC_INDEX_CHECK)
82  throw(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT);
83 #else
84  throw();
85 #endif
86 //#if(CXSC_INDEX_CHECK)
87 
88 template<typename S, typename T>
89 friend inline void addDot(const S &x, const T &y, dotprecision &val);
90 
91 
92 #ifdef _CXSC_FRIEND_TPL
93  //----------------- Templates ---------------------------------------
94 template <class MV1,class MV2> friend MV1 &_mvmvassign(MV1 &v,const MV2 &rv)
95 #if(CXSC_INDEX_CHECK)
96  throw(ERROR__OP_WITH_WRONG_DIM<MV1>);
97 #else
98  throw();
99 #endif
100 template <class MV,class S> friend MV &_mvsassign(MV &v,const S &r) throw();
101 template <class MV,class V> friend MV &_mvvassign(MV &v,const V &rv)
102 #if(CXSC_INDEX_CHECK)
103  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
104 #else
105  throw();
106 #endif
107 template <class V,class MV2,class S> friend V &_vmvassign(V &v,const MV2 &rv) throw();
108 template <class MV,class V> friend V _mvabs(const MV &mv) throw();
109 template <class DP,class V,class SV> friend void _vmvaccu(DP &dp, const V & rv1, const SV &rv2)
110 #if(CXSC_INDEX_CHECK)
111  throw(OP_WITH_WRONG_DIM);
112 #else
113  throw();
114 #endif
115 template <class DP,class MV1,class MV2> friend void _mvmvaccu(DP &dp, const MV1 & rv1, const MV2 &rv2)
116 #if(CXSC_INDEX_CHECK)
117  throw(OP_WITH_WRONG_DIM);
118 #else
119  throw();
120 #endif
121 
122 
123  template <class MV1,class MV2,class S> friend S _mvmvlmult(const MV1 & rv1, const MV2 &rv2)
124 #if(CXSC_INDEX_CHECK)
125  throw(ERROR__OP_WITH_WRONG_DIM<MV1>);
126 #else
127  throw();
128 #endif
129  template <class V,class MV,class S> friend S _vmvlmult(const V &rv1, const MV &rv2)
130 #if(CXSC_INDEX_CHECK)
131  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
132 #else
133  throw();
134 #endif
135  template <class MV,class S,class E> friend E _mvsmult(const MV &rv, const S &s) throw();
136  template <class MV1,class MV2,class E> friend E _mvmvplus(const MV1 &rv1, const MV2 &rv2)
137 #if(CXSC_INDEX_CHECK)
138  throw(ERROR__OP_WITH_WRONG_DIM<E>);
139 #else
140  throw();
141 #endif
142  template <class MV1,class MV2,class E> friend E _mvmvminus(const MV1 &rv1, const MV2 &rv2)
143 #if(CXSC_INDEX_CHECK)
144  throw(ERROR__OP_WITH_WRONG_DIM<E>);
145 #else
146  throw();
147 #endif
148  template <class MV,class V,class E> friend E _mvvplus(const MV &rv1, const V &rv2)
149 #if(CXSC_INDEX_CHECK)
150  throw(ERROR__OP_WITH_WRONG_DIM<E>);
151 #else
152  throw();
153 #endif
154  template <class MV,class V,class E> friend E _mvvminus(const MV &rv1, const V &rv2)
155 #if(CXSC_INDEX_CHECK)
156  throw(ERROR__OP_WITH_WRONG_DIM<E>);
157 #else
158  throw();
159 #endif
160  template <class V,class MV,class E> friend E _vmvminus(const V &rv1, const MV &rv2)
161 #if(CXSC_INDEX_CHECK)
162  throw(ERROR__OP_WITH_WRONG_DIM<E>);
163 #else
164  throw();
165 #endif
166  template <class MV,class S,class E> friend E _mvsdiv(const MV &rv, const S &s) throw();
167 template <class MV,class S> friend MV &_mvsmultassign(MV &v,const S &r) throw();
168 template <class MV, class S> friend MV &_mvsplusassign(MV &v,const S &r) throw();
169 template <class MV,class S> friend MV &_mvsminusassign(MV &v,const S &r) throw();
170 template <class MV,class S> friend MV &_mvsdivassign(MV &v,const S &r) throw();
171 template <class MV,class V> friend MV &_mvvplusassign(MV &v,const V &rv)
172 #if(CXSC_INDEX_CHECK)
173  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
174 #else
175  throw();
176 #endif
177 template <class V,class MV> friend V &_vmvplusassign(V &rv,const MV &v)
178 #if(CXSC_INDEX_CHECK)
179  throw(ERROR__OP_WITH_WRONG_DIM<V>);
180 #else
181  throw();
182 #endif
183 template <class MV,class V> friend MV &_mvvminusassign(MV &v,const V &rv)
184 #if(CXSC_INDEX_CHECK)
185  throw(ERROR__OP_WITH_WRONG_DIM<MV>);
186 #else
187  throw();
188 #endif
189 template <class V,class MV> friend V &_vmvminusassign(V &rv,const MV &v)
190 #if(CXSC_INDEX_CHECK)
191  throw(ERROR__OP_WITH_WRONG_DIM<V>);
192 #else
193  throw();
194 #endif
195 
196 template <class V,class MV> friend V &_vmvsetinf(V &rv,const MV &v)
197 #if(CXSC_INDEX_CHECK)
198  throw(ERROR__OP_WITH_WRONG_DIM<V>);
199 #else
200  throw();
201 #endif
202 template <class V,class MV> friend V &_vmvsetsup(V &rv,const MV &v)
203 #if(CXSC_INDEX_CHECK)
204  throw(ERROR__OP_WITH_WRONG_DIM<V>);
205 #else
206  throw();
207 #endif
208 template <class V,class MV> friend V &_vmvusetinf(V &rv,const MV &v)
209 #if(CXSC_INDEX_CHECK)
210  throw(ERROR__OP_WITH_WRONG_DIM<V>);
211 #else
212  throw();
213 #endif
214 template <class V,class MV> friend V &_vmvusetsup(V &rv,const MV &v)
215 #if(CXSC_INDEX_CHECK)
216  throw(ERROR__OP_WITH_WRONG_DIM<V>);
217 #else
218  throw();
219 #endif
220 
221 #endif
222 
223  //----------------- Konstruktoren ----------------------------------
224 
226  explicit INLINE l_rmatrix_subv (l_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) { }
227  public:
229  INLINE l_rmatrix_subv(const l_rmatrix_subv &v) throw():dat(v.dat),lb(v.lb),ub(v.ub),size(v.size),start(v.start),offset(v.offset) { }
230  public:
231 
232  //---------------------- Standardfunktionen ------------------------
234  friend INLINE int Lb(const l_rmatrix_subv &rv) throw() { return rv.lb; }
236  friend INLINE int Ub(const l_rmatrix_subv &rv) throw() { return rv.ub; }
238  INLINE l_real &operator [](const int &i) const
239 #if(CXSC_INDEX_CHECK)
240  throw(ERROR_LRVECTOR_ELEMENT_NOT_IN_VEC);
241 #else
242  throw();
243 #endif
244  INLINE l_rmatrix_subv &operator ()() throw() { return *this; }
247  INLINE l_rmatrix_subv operator ()(const int &i)
248 #if(CXSC_INDEX_CHECK)
249  throw(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG);
250 #else
251  throw();
252 #endif
253  INLINE l_rmatrix_subv operator ()(const int &i1,const int &i2)
255 #if(CXSC_INDEX_CHECK)
256  throw(ERROR_LRVECTOR_SUB_ARRAY_TOO_BIG);
257 #else
258  throw();
259 #endif
260 
261 
263  INLINE l_rmatrix_subv &operator =(const l_rmatrix_subv &rv) throw();
265  INLINE l_rmatrix_subv &operator =(const l_real &r) throw();
267  INLINE l_rmatrix_subv &operator =(const l_rmatrix &m)
268 #if(CXSC_INDEX_CHECK)
269  throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ);
270 #else
271  throw();
272 #endif
273  INLINE l_rmatrix_subv &operator =(const l_rmatrix_slice &m)
275 #if(CXSC_INDEX_CHECK)
276  throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ);
277 #else
278  throw();
279 #endif
280  INLINE l_rmatrix_subv &operator =(const l_rvector &v)
282 #if(CXSC_INDEX_CHECK)
283  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM);
284 #else
285  throw();
286 #endif
287  INLINE l_rmatrix_subv &operator =(const l_rvector_slice &v)
289 #if(CXSC_INDEX_CHECK)
290  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM);
291 #else
292  throw();
293 #endif
294 
296  INLINE l_rmatrix_subv &operator *=(const l_real &c) throw();
298  INLINE l_rmatrix_subv &operator +=(const l_real &c) throw();
300  INLINE l_rmatrix_subv &operator -=(const l_real &c) throw();
302  INLINE l_rmatrix_subv &operator /=(const l_real &c) throw();
304  INLINE l_rmatrix_subv &operator -=(const l_rvector &rv)
305 #if(CXSC_INDEX_CHECK)
306  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM);
307 #else
308  throw();
309 #endif
310  INLINE l_rmatrix_subv &operator +=(const l_rvector &rv)
312 #if(CXSC_INDEX_CHECK)
313  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM);
314 #else
315  throw();
316 #endif
317  INLINE l_rmatrix_subv &operator -=(const l_rvector_slice &rv)
319 #if(CXSC_INDEX_CHECK)
320  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM);
321 #else
322  throw();
323 #endif
324  INLINE l_rmatrix_subv &operator +=(const l_rvector_slice &rv)
326 #if(CXSC_INDEX_CHECK)
327  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM);
328 #else
329  throw();
330 #endif
331  // Real
333  INLINE l_rmatrix_subv &operator =(const rmatrix_subv &rv) throw();
335  INLINE l_rmatrix_subv &operator =(const real &r) throw();
337  INLINE l_rmatrix_subv &operator =(const rmatrix &m)
338 #if(CXSC_INDEX_CHECK)
339  throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ);
340 #else
341  throw();
342 #endif
343  INLINE l_rmatrix_subv &operator =(const rmatrix_slice &m)
345 #if(CXSC_INDEX_CHECK)
346  throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ);
347 #else
348  throw();
349 #endif
350  INLINE l_rmatrix_subv &operator =(const rvector &v)
352 #if(CXSC_INDEX_CHECK)
353  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM);
354 #else
355  throw();
356 #endif
357  INLINE l_rmatrix_subv &operator =(const rvector_slice &v)
359 #if(CXSC_INDEX_CHECK)
360  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM);
361 #else
362  throw();
363 #endif
364 
366  INLINE l_rmatrix_subv &operator *=(const real &c) throw();
368  INLINE l_rmatrix_subv &operator +=(const real &c) throw();
370  INLINE l_rmatrix_subv &operator -=(const real &c) throw();
372  INLINE l_rmatrix_subv &operator /=(const real &c) throw();
374  INLINE l_rmatrix_subv &operator -=(const rvector &rv)
375 #if(CXSC_INDEX_CHECK)
376  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM);
377 #else
378  throw();
379 #endif
380  INLINE l_rmatrix_subv &operator +=(const rvector &rv)
382 #if(CXSC_INDEX_CHECK)
383  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM);
384 #else
385  throw();
386 #endif
387  INLINE l_rmatrix_subv &operator -=(const rvector_slice &rv)
389 #if(CXSC_INDEX_CHECK)
390  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM);
391 #else
392  throw();
393 #endif
394  INLINE l_rmatrix_subv &operator +=(const rvector_slice &rv)
396 #if(CXSC_INDEX_CHECK)
397  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM);
398 #else
399  throw();
400 #endif
401 //#else
402 //#endif
403 
404 };
405 
406 
407 //----------------------- Matrix -----------------------------------------------
408 
409 class l_rmatrix_slice;
410 
412 
416 {
417  friend class l_rmatrix_slice;
418  friend class l_rmatrix_subv;
419  friend class l_imatrix;
420  private:
421  l_real *dat;
422  int lb1,ub1,lb2,ub2,xsize,ysize;
423 
424  public:
425 //#if(CXSC_INDEX_CHECK)
426 #ifdef _CXSC_FRIEND_TPL
427  //----------------- Templates ---------------------------------------
428 template <class S,class M> friend void _smconstr(S &s,const M &m)
429 #if(CXSC_INDEX_CHECK)
430  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>,ERROR__USE_OF_UNINITIALIZED_OBJ<M>);
431 #else
432  throw();
433 #endif
434 template <class V,class M,class S> friend void _vmconstr(V &v,const M &m)
435 #if(CXSC_INDEX_CHECK)
436  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
437 #else
438  throw();
439 #endif
440  template <class M1,class M2,class S> friend M1 &_mmassign(M1 &m1,const M2 &m,S ms) throw();
441  template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) throw();
442  template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m)
443 #if(CXSC_INDEX_CHECK)
444  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
445 #else
446  throw();
447 #endif
448  template <class M,class S> friend M &_msassign(M &m,const S &r) throw();
449 template <class V,class M,class S> friend V &_vmassign(V &v,const M &m)
450 #if(CXSC_INDEX_CHECK)
451  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<M>);
452 #else
453  throw();
454 #endif
455 template <class M,class V,class S> friend M &_mvassign(M &m,const V &v) throw();
456  template <class M> friend int _mlb(const M &m, const int &i)
457 #if(CXSC_INDEX_CHECK)
458  throw(ERROR__WRONG_ROW_OR_COL<M>);
459 #else
460  throw();
461 #endif
462  template <class M> friend int _mub(const M &m, const int &i)
463 #if(CXSC_INDEX_CHECK)
464  throw(ERROR__WRONG_ROW_OR_COL<M>);
465 #else
466  throw();
467 #endif
468  template <class M> friend M &_msetlb(M &m, const int &i,const int &j)
469 #if(CXSC_INDEX_CHECK)
470  throw(ERROR__WRONG_ROW_OR_COL<M>);
471 #else
472  throw();
473 #endif
474  template <class M> friend M &_msetub(M &m, const int &i,const int &j)
475 #if(CXSC_INDEX_CHECK)
476  throw(ERROR__WRONG_ROW_OR_COL<M>);
477 #else
478  throw();
479 #endif
480  template <class M> friend void _mresize(M &A) throw();
481  template <class M,class S> friend void _mresize(M &A,const int &m, const int &n)
482 #if(CXSC_INDEX_CHECK)
483  throw(ERROR__WRONG_BOUNDARIES<M>);
484 #else
485  throw();
486 #endif
487  template <class M,class S> friend void _mresize(M &A,const int &m1, const int &m2,const int &n1,const int &n2)
488 #if(CXSC_INDEX_CHECK)
489  throw(ERROR__WRONG_BOUNDARIES<M>);
490 #else
491  throw();
492 #endif
493  template <class M,class E> friend E _mabs(const M &m) throw();
494  template <class MS,class E> friend E _msabs(const MS &ms) throw();
495  //-------------- matrix-matrix -------------
496  template <class M1,class M2,class E> friend E _mmplus(const M1 &m1,const M2 &m2)
497 #if(CXSC_INDEX_CHECK)
498  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
499 #else
500  throw();
501 #endif
502  template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms)
503 #if(CXSC_INDEX_CHECK)
504  throw(ERROR__OP_WITH_WRONG_DIM<M>);
505 #else
506  throw();
507 #endif
508  template <class M> friend M _mminus(const M &m) throw();
509  template <class MS,class E> friend E _msminus(const MS &ms) throw();
510  template <class M1,class M2,class E> friend E _mmminus(const M1 &m1,const M2 &m2)
511 #if(CXSC_INDEX_CHECK)
512  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
513 #else
514  throw();
515 #endif
516  template <class M1,class M2> friend M1 &_mmplusassign(M1 &m1,const M2 &m2)
517 #if(CXSC_INDEX_CHECK)
518  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
519 #else
520  throw();
521 #endif
522  template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms)
523 #if(CXSC_INDEX_CHECK)
524  throw(ERROR__OP_WITH_WRONG_DIM<M>);
525 #else
526  throw();
527 #endif
528  template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1)
529 #if(CXSC_INDEX_CHECK)
530  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
531 #else
532  throw();
533 #endif
534  template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2)
535 #if(CXSC_INDEX_CHECK)
536  throw(ERROR__OP_WITH_WRONG_DIM<E>);
537 #else
538  throw();
539 #endif
540  template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms)
541 #if(CXSC_INDEX_CHECK)
542  throw(ERROR__OP_WITH_WRONG_DIM<E>);
543 #else
544  throw();
545 #endif
546  template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m)
547 #if(CXSC_INDEX_CHECK)
548  throw(ERROR__OP_WITH_WRONG_DIM<E>);
549 #else
550  throw();
551 #endif
552  template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2)
553 #if(CXSC_INDEX_CHECK)
554  throw(ERROR__OP_WITH_WRONG_DIM<E>);
555 #else
556  throw();
557 #endif
558  template <class M1,class M2> friend M1 &_mmminusassign(M1 &m1,const M2 &m2)
559 #if(CXSC_INDEX_CHECK)
560  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
561 #else
562  throw();
563 #endif
564  template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms)
565 #if(CXSC_INDEX_CHECK)
566  throw(ERROR__OP_WITH_WRONG_DIM<M>);
567 #else
568  throw();
569 #endif
570  template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1)
571 #if(CXSC_INDEX_CHECK)
572  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
573 #else
574  throw();
575 #endif
576  template <class M1,class M2,class E> friend E _mmlmult(const M1 &m1, const M2 &m2)
577 #if(CXSC_INDEX_CHECK)
578  throw(ERROR__OP_WITH_WRONG_DIM<E>);
579 #else
580  throw();
581 #endif
582  template <class M1,class M2,class S> friend M1 &_mmlmultassign(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,class E> friend E _mmslmult(const M &m1, const MS &ms)
589 #if(CXSC_INDEX_CHECK)
590  throw(ERROR__OP_WITH_WRONG_DIM<E>);
591 #else
592  throw();
593 #endif
594  template <class MS,class M,class E> friend E _msmlmult(const MS &ms, const M &m2)
595 #if(CXSC_INDEX_CHECK)
596  throw(ERROR__OP_WITH_WRONG_DIM<E>);
597 #else
598  throw();
599 #endif
600  template <class M,class MS,class S> friend M &_mmslmultassign(M &m1,const MS &ms)
601 #if(CXSC_INDEX_CHECK)
602  throw(ERROR__OP_WITH_WRONG_DIM<M>);
603 #else
604  throw();
605 #endif
606  template <class MS1,class MS2,class E> friend E _msmslmult(const MS1 &ms1, const MS2 &ms2)
607 #if(CXSC_INDEX_CHECK)
608  throw(ERROR__OP_WITH_WRONG_DIM<E>);
609 #else
610  throw();
611 #endif
612  template <class M1,class M2,class E> friend E _mmconv(const M1 &m1,const M2 &m2)
613 #if(CXSC_INDEX_CHECK)
614  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
615 #else
616  throw();
617 #endif
618  template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms)
619 #if(CXSC_INDEX_CHECK)
620  throw(ERROR__OP_WITH_WRONG_DIM<M>);
621 #else
622  throw();
623 #endif
624  //-------- matrix-scalar -----------------
625  template <class S,class M,class E> friend E _smmult(const S &c, const M &m) throw();
626  template <class M,class S> friend M &_msmultassign(M &m,const S &c) throw();
627  template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) throw();
628  template <class M,class S,class E> friend E _msdiv(const M &m,const S &c) throw();
629  template <class M,class S> friend M &_msdivassign(M &m,const S &c) throw();
630  template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) throw();
631  //-------- matrix-vector ---------------------
632  template <class M,class V,class E> friend E _mvlmult(const M &m,const V &v)
633 #if(CXSC_INDEX_CHECK)
634  throw(ERROR__OP_WITH_WRONG_DIM<M>);
635 #else
636  throw();
637 #endif
638  template <class V,class M,class E> friend E _vmlmult(const V &v,const M &m)
639 #if(CXSC_INDEX_CHECK)
640  throw(ERROR__OP_WITH_WRONG_DIM<M>);
641 #else
642  throw();
643 #endif
644  template <class V,class M,class S> friend V &_vmlmultassign(V &v,const M &m)
645 #if(CXSC_INDEX_CHECK)
646  throw(ERROR__OP_WITH_WRONG_DIM<M>);
647 #else
648  throw();
649 #endif
650  template <class VS,class M,class S> friend VS &_vsmlmultassign(VS &v,const M &m)
651 #if(CXSC_INDEX_CHECK)
652  throw(ERROR__OP_WITH_WRONG_DIM<M>);
653 #else
654  throw();
655 #endif
656 
657  template <class M> friend void *_mvoid(const M &m) throw();
658  template <class M> friend bool _mnot(const M &m) throw();
659  template <class MS> friend void *_msvoid(const MS &ms) throw();
660  template <class MS> friend bool _msnot(const MS &ms) throw();
661  template <class M1,class M2> friend bool _mmeq(const M1 &m1,const M2 &m2) throw();
662  template <class M1,class M2> friend bool _mmneq(const M1 &m1,const M2 &m2) throw();
663  template <class M1,class M2> friend bool _mmless(const M1 &m1,const M2 &m2) throw();
664  template <class M1,class M2> friend bool _mmleq(const M1 &m1,const M2 &m2) throw();
665  template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) throw();
666  template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) throw();
667  template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) throw();
668  template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) throw();
669  template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) throw();
670  template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) throw();
671  template <class M> friend std::ostream &_mout(std::ostream &s,const M &r) throw();
672  template <class M> friend std::istream &_min(std::istream &s,M &r) throw();
673 
674  //--- Real --------- matrix-vector ----------------------
675  template <class MS,class V,class E> friend E _msvlmult(const MS &ms,const V &v)
676 #if(CXSC_INDEX_CHECK)
677  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
678 #else
679  throw();
680 #endif
681  template <class V,class MS,class E> friend E _vmslmult(const V &v,const MS &ms)
682 #if(CXSC_INDEX_CHECK)
683  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
684 #else
685  throw();
686 #endif
687 
688  template <class M1,class M2,class E> friend E _mmlimult(const M1 &m1, const M2 &m2)
689 #if(CXSC_INDEX_CHECK)
690  throw(ERROR__OP_WITH_WRONG_DIM<E>);
691 #else
692  throw();
693 #endif
694 
695  template <class M,class MS,class E> friend E _mmslimult(const M &m1, const MS &ms)
696 #if(CXSC_INDEX_CHECK)
697  throw(ERROR__OP_WITH_WRONG_DIM<E>);
698 #else
699  throw();
700 #endif
701 
702  template <class MS,class M,class E> friend E _msmlimult(const MS &ms, const M &m2)
703 #if(CXSC_INDEX_CHECK)
704  throw(ERROR__OP_WITH_WRONG_DIM<E>);
705 #else
706  throw();
707 #endif
708 
709  template <class MS1,class MS2,class E> friend E _msmslimult(const MS1 &ms1, const MS2 &ms2)
710 #if(CXSC_INDEX_CHECK)
711  throw(ERROR__OP_WITH_WRONG_DIM<E>);
712 #else
713  throw();
714 #endif
715 
716  template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2)
717 #if(CXSC_INDEX_CHECK)
718  throw(ERROR__OP_WITH_WRONG_DIM<E>);
719 #else
720  throw();
721 #endif
722  template <class M1,class M2,class E> friend E _mmsect(const M1 &m1,const M2 &m2)
723 #if(CXSC_INDEX_CHECK)
724  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
725 #else
726  throw();
727 #endif
728  template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms)
729 #if(CXSC_INDEX_CHECK)
730  throw(ERROR__OP_WITH_WRONG_DIM<M>);
731 #else
732  throw();
733 #endif
734 
735  template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2)
736 #if(CXSC_INDEX_CHECK)
737  throw(ERROR__OP_WITH_WRONG_DIM<E>);
738 #else
739  throw();
740 #endif
741  // matrix-scalar
742 
743  // matrix-vector
744 
745  template <class M,class V,class E> friend E _mvlimult(const M &m,const V &v)
746 #if(CXSC_INDEX_CHECK)
747  throw(ERROR__OP_WITH_WRONG_DIM<M>);
748 #else
749  throw();
750 #endif
751  template <class V,class M,class E> friend E _vmlimult(const V &v,const M &m)
752 #if(CXSC_INDEX_CHECK)
753  throw(ERROR__OP_WITH_WRONG_DIM<M>);
754 #else
755  throw();
756 #endif
757  template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v)
758 #if(CXSC_INDEX_CHECK)
759  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
760 #else
761  throw();
762 #endif
763 
764  // l_interval ----------
765 
766  template <class M,class E> friend E _mdiam(const M &m) throw();
767  template <class M,class E> friend E _mmid(const M &m) throw();
768  template <class MS,class E> friend E _msdiam(const MS &ms) throw();
769  template <class MS,class E> friend E _msmid(const MS &ms) throw();
770  template <class M,class E> friend E _minf(const M &m) throw();
771  template <class MS,class E> friend E _msinf(const MS &ms) throw();
772  template <class M,class E> friend E _msup(const M &m) throw();
773  template <class MS,class E> friend E _mssup(const MS &ms) throw();
774  template <class M1,class M2> friend M1 &_mmsetinf(M1 &m1,const M2 &m2)
775 #if(CXSC_INDEX_CHECK)
776  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
777 #else
778  throw();
779 #endif
780  template <class M1,class M2> friend M1 &_mmsetsup(M1 &m1,const M2 &m2)
781 #if(CXSC_INDEX_CHECK)
782  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
783 #else
784  throw();
785 #endif
786  template <class M1,class M2> friend M1 &_mmusetinf(M1 &m1,const M2 &m2)
787 #if(CXSC_INDEX_CHECK)
788  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
789 #else
790  throw();
791 #endif
792  template <class M1,class M2> friend M1 &_mmusetsup(M1 &m1,const M2 &m2)
793 #if(CXSC_INDEX_CHECK)
794  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
795 #else
796  throw();
797 #endif
798  template <class MS1,class M2> friend MS1 &_msmsetinf(MS1 &ms1,const M2 &m2)
799 #if(CXSC_INDEX_CHECK)
800  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
801 #else
802  throw();
803 #endif
804  template <class MS1,class M2> friend MS1 &_msmsetsup(MS1 &ms1,const M2 &m2)
805 #if(CXSC_INDEX_CHECK)
806  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
807 #else
808  throw();
809 #endif
810  template <class MS1,class M2> friend MS1 &_msmusetinf(MS1 &ms1,const M2 &m2)
811 #if(CXSC_INDEX_CHECK)
812  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
813 #else
814  throw();
815 #endif
816  template <class MS1,class M2> friend MS1 &_msmusetsup(MS1 &ms1,const M2 &m2)
817 #if(CXSC_INDEX_CHECK)
818  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
819 #else
820  throw();
821 #endif
822 
823  template <class M1,class M2,class S> friend M1 &_mmlimultassign(M1 &m1,const M2 &m2)
824 #if(CXSC_INDEX_CHECK)
825  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
826 #else
827  throw();
828 #endif
829 
830  template <class M,class MS,class S> friend M &_mmslimultassign(M &m1,const MS &ms)
831 #if(CXSC_INDEX_CHECK)
832  throw(ERROR__OP_WITH_WRONG_DIM<M>);
833 #else
834  throw();
835 #endif
836 
837  template <class M1,class M2> friend M1 &_mmconvassign(M1 &m1,const M2 &m2)
838 #if(CXSC_INDEX_CHECK)
839  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
840 #else
841  throw();
842 #endif
843  template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms)
844 #if(CXSC_INDEX_CHECK)
845  throw(ERROR__OP_WITH_WRONG_DIM<M>);
846 #else
847  throw();
848 #endif
849  template <class MS,class M> friend MS &_msmconvassign(MS &ms,const M &m1)
850 #if(CXSC_INDEX_CHECK)
851  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
852 #else
853  throw();
854 #endif
855 
856  template <class M1,class M2> friend M1 &_mmsectassign(M1 &m1,const M2 &m2)
857 #if(CXSC_INDEX_CHECK)
858  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
859 #else
860  throw();
861 #endif
862  template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms)
863 #if(CXSC_INDEX_CHECK)
864  throw(ERROR__OP_WITH_WRONG_DIM<M>);
865 #else
866  throw();
867 #endif
868  template <class MS,class M> friend MS &_msmsectassign(MS &ms,const M &m1)
869 #if(CXSC_INDEX_CHECK)
870  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
871 #else
872  throw();
873 #endif
874 
875  template <class V,class M,class S> friend V &_vmlimultassign(V &v,const M &m)
876 #if(CXSC_INDEX_CHECK)
877  throw(ERROR__OP_WITH_WRONG_DIM<M>);
878 #else
879  throw();
880 #endif
881  template <class VS,class M,class S> friend VS &_vsmlimultassign(VS &v,const M &m)
882 #if(CXSC_INDEX_CHECK)
883  throw(ERROR__OP_WITH_WRONG_DIM<M>);
884 #else
885  throw();
886 #endif
887 
888 #endif
889 
890  //-------------------------- Konstruktoren ----------------------------
891 
892 // l_real
894  INLINE l_rmatrix(const l_rmatrix &rm) throw();
896  INLINE l_rmatrix(const l_rmatrix_slice &rm) throw();
898  INLINE l_rmatrix() throw();
900  explicit INLINE l_rmatrix(const int &m, const int &n)
901 #if(CXSC_INDEX_CHECK)
902  throw(ERROR_LRMATRIX_WRONG_BOUNDARIES);
903 #else
904  throw();
905 #endif
906  explicit INLINE l_rmatrix(const int &m1, const int &n1, const int &m2, const int &n2)
908 #if(CXSC_INDEX_CHECK)
909  throw(ERROR_LRMATRIX_WRONG_BOUNDARIES);
910 #else
911  throw();
912 #endif
913  explicit INLINE l_rmatrix(const l_rvector &v) throw();
916  explicit INLINE l_rmatrix(const l_rvector_slice &v) throw();
918  explicit INLINE l_rmatrix(const l_real &r) throw();
920  INLINE l_rmatrix &operator =(const l_real &r) throw();
922  INLINE l_rmatrix &operator =(const l_rmatrix &m) throw();
924  INLINE l_rmatrix &operator =(const l_rmatrix_slice &ms) throw();
926  INLINE l_rmatrix &operator =(const l_rvector &v) throw();
928  INLINE l_rmatrix &operator =(const l_rvector_slice &v) throw();
929 // real
931  explicit INLINE l_rmatrix(const real &) throw();
933  explicit INLINE l_rmatrix(const rmatrix &rm) throw();
935  explicit INLINE l_rmatrix(const rmatrix_slice &rm) throw();
937  explicit INLINE l_rmatrix(const rvector &v) throw();
939  explicit INLINE l_rmatrix(const rvector_slice &v) throw();
941  INLINE l_rmatrix &operator =(const real &r) throw();
943  INLINE l_rmatrix &operator =(const rmatrix &m) throw();
945  INLINE l_rmatrix &operator =(const rmatrix_slice &ms) throw();
947  INLINE l_rmatrix &operator =(const rvector &v) throw();
949  INLINE l_rmatrix &operator =(const rvector_slice &v) throw();
950 
951  //--------------------------- Destruktoren -----------------------------
952 
953  INLINE ~l_rmatrix() throw() { delete [] dat; }
954 
955  //------------------------- Standardfunktionen -------------------------
956 
958  INLINE l_rmatrix_subv operator [](const int &i) const
959 #if(CXSC_INDEX_CHECK)
960  throw(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT);
961 #else
962  throw();
963 #endif
964  INLINE l_rmatrix_subv operator [](const cxscmatrix_column &i) const
966 #if(CXSC_INDEX_CHECK)
967  throw(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT);
968 #else
969  throw();
970 #endif
971  INLINE l_rmatrix &operator ()() throw() { return *this; }
974  INLINE l_rmatrix_slice operator ()(const int &m, const int &n)
975 #if(CXSC_INDEX_CHECK)
976  throw(ERROR_LRMATRIX_SUB_ARRAY_TOO_BIG);
977 #else
978  throw();
979 #endif
980  INLINE l_rmatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
982 #if(CXSC_INDEX_CHECK)
983  throw(ERROR_LRMATRIX_SUB_ARRAY_TOO_BIG);
984 #else
985  throw();
986 #endif
987  INLINE operator void*() throw();
988 //#else
989 //#endif
990 };
991 
992 
994 
1000 {
1001  friend class l_rmatrix;
1002  friend class l_imatrix;
1003  private:
1004  l_real *dat;
1005  int offset1,offset2,mxsize,mysize;
1006  int start1,end1,start2,end2,sxsize,sysize; // slice size
1007 
1008  public:
1009 //#if(CXSC_INDEX_CHECK)
1010 #ifdef _CXSC_FRIEND_TPL
1011  //----------------- Templates ---------------------------------------
1012 template <class V,class MS,class S> friend void _vmsconstr(V &v,const MS &m)
1013 #if(CXSC_INDEX_CHECK)
1014  throw(ERROR__TYPE_CAST_OF_THICK_OBJ<MS>);
1015 #else
1016  throw();
1017 #endif
1018  template <class MS,class M> friend MS &_msmassign(MS &ms,const M &m)
1019 #if(CXSC_INDEX_CHECK)
1020  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1021 #else
1022  throw();
1023 #endif
1024  template <class MS1,class MS2> friend MS1 &_msmsassign(MS1 &ms1,const MS2 &ms)
1025 #if(CXSC_INDEX_CHECK)
1026  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1027 #else
1028  throw();
1029 #endif
1030  template <class M,class MS2,class S> friend M &_mmsassign(M &m,const MS2 &ms) throw();
1031  template <class MS,class S> friend MS &_mssassign(MS &ms,const S &r) throw();
1032 
1033  template <class MS> friend int _mslb(const MS &ms, const int &i)
1034 #if(CXSC_INDEX_CHECK)
1035  throw(ERROR__WRONG_ROW_OR_COL<MS>);
1036 #else
1037  throw();
1038 #endif
1039  template <class MS> friend int _msub(const MS &ms, const int &i)
1040 #if(CXSC_INDEX_CHECK)
1041  throw(ERROR__WRONG_ROW_OR_COL<MS>);
1042 #else
1043  throw();
1044 #endif
1045  template <class MS,class E> friend E _msabs(const MS &ms) throw();
1046  //-------- matrix-matrix --------------
1047  template <class MS,class E> friend E _msminus(const MS &ms) throw();
1048  template <class M,class MS,class E> friend E _mmsplus(const M &m,const MS &ms)
1049 #if(CXSC_INDEX_CHECK)
1050  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1051 #else
1052  throw();
1053 #endif
1054  template <class MS1,class MS2,class E> friend E _msmsplus(const MS1 &m1,const MS2 &m2)
1055 #if(CXSC_INDEX_CHECK)
1056  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1057 #else
1058  throw();
1059 #endif
1060  template <class M,class MS> friend M &_mmsplusassign(M &m1,const MS &ms)
1061 #if(CXSC_INDEX_CHECK)
1062  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1063 #else
1064  throw();
1065 #endif
1066  template <class MS,class M> friend MS &_msmplusassign(MS &ms,const M &m1)
1067 #if(CXSC_INDEX_CHECK)
1068  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1069 #else
1070  throw();
1071 #endif
1072  template <class MS1,class MS2> friend MS1 &_msmsplusassign(MS1 &ms1,const MS2 &ms2)
1073 #if(CXSC_INDEX_CHECK)
1074  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1075 #else
1076  throw();
1077 #endif
1078  template <class M,class MS,class E> friend E _mmsminus(const M &m,const MS &ms)
1079 #if(CXSC_INDEX_CHECK)
1080  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1081 #else
1082  throw();
1083 #endif
1084  template <class MS,class M,class E> friend E _msmminus(const MS &ms,const M &m)
1085 #if(CXSC_INDEX_CHECK)
1086  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1087 #else
1088  throw();
1089 #endif
1090  template <class MS1,class MS2,class E> friend E _msmsminus(const MS1 &ms1,const MS2 &ms2)
1091 #if(CXSC_INDEX_CHECK)
1092  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1093 #else
1094  throw();
1095 #endif
1096  template <class M,class MS> friend M &_mmsminusassign(M &m1,const MS &ms)
1097 #if(CXSC_INDEX_CHECK)
1098  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1099 #else
1100  throw();
1101 #endif
1102  template <class MS,class M> friend MS &_msmminusassign(MS &ms,const M &m1)
1103 #if(CXSC_INDEX_CHECK)
1104  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1105 #else
1106  throw();
1107 #endif
1108  template <class MS1,class MS2> friend MS1 &_msmsminusassign(MS1 &ms1,const MS2 &ms2)
1109 #if(CXSC_INDEX_CHECK)
1110  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1111 #else
1112  throw();
1113 #endif
1114  template <class M,class MS,class E> friend E _mmslmult(const M &m1, const MS &ms)
1115 #if(CXSC_INDEX_CHECK)
1116  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1117 #else
1118  throw();
1119 #endif
1120  template <class MS,class M,class E> friend E _msmlmult(const MS &ms, const M &m2)
1121 #if(CXSC_INDEX_CHECK)
1122  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1123 #else
1124  throw();
1125 #endif
1126  template <class M,class MS,class S> friend M &_mmslmultassign(M &m1,const MS &ms)
1127 #if(CXSC_INDEX_CHECK)
1128  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1129 #else
1130  throw();
1131 #endif
1132  template <class MS1,class MS2,class E> friend E _msmslmult(const MS1 &ms1, const MS2 &ms2)
1133 #if(CXSC_INDEX_CHECK)
1134  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1135 #else
1136  throw();
1137 #endif
1138  template <class M,class MS,class E> friend E _mmsconv(const M &m,const MS &ms)
1139 #if(CXSC_INDEX_CHECK)
1140  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1141 #else
1142  throw();
1143 #endif
1144  template <class MS1,class MS2,class E> friend E _msmsconv(const MS1 &m1,const MS2 &m2)
1145 #if(CXSC_INDEX_CHECK)
1146  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1147 #else
1148  throw();
1149 #endif
1150  //--------- matrix-vector --------------
1151  template <class MS,class V,class E> friend E _msvlmult(const MS &ms,const V &v)
1152 #if(CXSC_INDEX_CHECK)
1153  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1154 #else
1155  throw();
1156 #endif
1157  template <class V,class MS,class E> friend E _vmslmult(const V &v,const MS &ms)
1158 #if(CXSC_INDEX_CHECK)
1159  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1160 #else
1161  throw();
1162 #endif
1163  template <class V,class MS,class S> friend V &_vmslmultassign(V &v,const MS &ms)
1164 #if(CXSC_INDEX_CHECK)
1165  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1166 #else
1167  throw();
1168 #endif
1169  //--------- matrix-scalar --------------
1170  template <class S,class MS,class E> friend E _smsmult(const S &c, const MS &ms) throw();
1171  template <class MS,class S> friend MS &_mssmultassign(MS &ms,const S &c) throw();
1172  template <class MS,class S,class E> friend E _mssdiv(const MS &ms, const S &c) throw();
1173  template <class MS,class S> friend MS &_mssdivassign(MS &ms,const S &c) throw();
1174 
1175  template <class MS> friend void *_msvoid(const MS &ms) throw();
1176  template <class MS> friend bool _msnot(const MS &ms) throw();
1177  template <class M,class MS> friend bool _mmseq(const M &m1,const MS &ms) throw();
1178  template <class M,class MS> friend bool _mmsneq(const M &m1,const MS &ms) throw();
1179  template <class M,class MS> friend bool _mmsless(const M &m1,const MS &ms) throw();
1180  template <class M,class MS> friend bool _mmsleq(const M &m1,const MS &ms) throw();
1181  template <class MS,class M> friend bool _msmless(const MS &ms,const M &m1) throw();
1182  template <class MS,class M> friend bool _msmleq(const MS &ms,const M &m1) throw();
1183  template <class MS1,class MS2> friend bool _msmseq(const MS1 &ms1,const MS2 &ms2) throw();
1184  template <class MS1,class MS2> friend bool _msmsneq(const MS1 &ms1,const MS2 &ms2) throw();
1185  template <class MS1,class MS2> friend bool _msmsless(const MS1 &ms1,const MS2 &ms2) throw();
1186  template <class MS1,class MS2> friend bool _msmsleq(const MS1 &ms1,const MS2 &ms2) throw();
1187  template <class MS> friend std::ostream &_msout(std::ostream &s,const MS &r) throw();
1188  template <class MS> friend std::istream &_msin(std::istream &s,MS &r) throw();
1189 
1190  //--- Real ------------ matrix-matrix -----------
1191 
1192  template <class M,class MS,class E> friend E _mmslimult(const M &m1, const MS &ms)
1193 #if(CXSC_INDEX_CHECK)
1194  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1195 #else
1196  throw();
1197 #endif
1198  template <class MS,class M,class E> friend E _msmlimult(const MS &ms, const M &m2)
1199 #if(CXSC_INDEX_CHECK)
1200  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1201 #else
1202  throw();
1203 #endif
1204 
1205  template <class MS1,class MS2,class E> friend E _msmslimult(const MS1 &ms1, const MS2 &ms2)
1206 #if(CXSC_INDEX_CHECK)
1207  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1208 #else
1209  throw();
1210 #endif
1211 
1212  template <class M,class MS,class E> friend E _mmssect(const M &m,const MS &ms)
1213 #if(CXSC_INDEX_CHECK)
1214  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1215 #else
1216  throw();
1217 #endif
1218  template <class MS1,class MS2,class E> friend E _msmssect(const MS1 &m1,const MS2 &m2)
1219 #if(CXSC_INDEX_CHECK)
1220  throw(ERROR__OP_WITH_WRONG_DIM<E>);
1221 #else
1222  throw();
1223 #endif
1224  // matrix-scalar
1225  // matrix-vector
1226 
1227  template <class MS,class V,class E> friend E _msvlimult(const MS &ms,const V &v)
1228 #if(CXSC_INDEX_CHECK)
1229  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1230 #else
1231  throw();
1232 #endif
1233  template <class V,class MS,class E> friend E _vmslimult(const V &v,const MS &ms)
1234 #if(CXSC_INDEX_CHECK)
1235  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1236 #else
1237  throw();
1238 #endif
1239 
1240  // l_interval --------------
1241 
1242  template <class M1,class MS2> friend M1 &_mmssetinf(M1 &m1,const MS2 &ms2)
1243 #if(CXSC_INDEX_CHECK)
1244  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1245 #else
1246  throw();
1247 #endif
1248  template <class M1,class MS2> friend M1 &_mmssetsup(M1 &m1,const MS2 &ms2)
1249 #if(CXSC_INDEX_CHECK)
1250  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1251 #else
1252  throw();
1253 #endif
1254  template <class M1,class MS2> friend M1 &_mmsusetinf(M1 &m1,const MS2 &ms2)
1255 #if(CXSC_INDEX_CHECK)
1256  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1257 #else
1258  throw();
1259 #endif
1260  template <class M1,class MS2> friend M1 &_mmsusetsup(M1 &m1,const MS2 &ms2)
1261 #if(CXSC_INDEX_CHECK)
1262  throw(ERROR__OP_WITH_WRONG_DIM<M1>);
1263 #else
1264  throw();
1265 #endif
1266  template <class MS1,class MS2> friend MS1 &_msmssetinf(MS1 &ms1,const MS2 &ms2)
1267 #if(CXSC_INDEX_CHECK)
1268  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1269 #else
1270  throw();
1271 #endif
1272  template <class MS1,class MS2> friend MS1 &_msmssetsup(MS1 &ms1,const MS2 &ms2)
1273 #if(CXSC_INDEX_CHECK)
1274  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1275 #else
1276  throw();
1277 #endif
1278  template <class MS1,class MS2> friend MS1 &_msmsusetinf(MS1 &ms1,const MS2 &ms2)
1279 #if(CXSC_INDEX_CHECK)
1280  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1281 #else
1282  throw();
1283 #endif
1284  template <class MS1,class MS2> friend MS1 &_msmsusetsup(MS1 &ms1,const MS2 &ms2)
1285 #if(CXSC_INDEX_CHECK)
1286  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1287 #else
1288  throw();
1289 #endif
1290 
1291 
1292  template <class M,class MS,class S> friend M &_mmslimultassign(M &m1,const MS &ms)
1293 #if(CXSC_INDEX_CHECK)
1294  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1295 #else
1296  throw();
1297 #endif
1298 
1299 
1300  template <class M,class MS> friend M &_mmsconvassign(M &m1,const MS &ms)
1301 #if(CXSC_INDEX_CHECK)
1302  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1303 #else
1304  throw();
1305 #endif
1306  template <class MS1,class MS2> friend MS1 &_msmsconvassign(MS1 &ms1,const MS2 &ms2)
1307 #if(CXSC_INDEX_CHECK)
1308  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1309 #else
1310  throw();
1311 #endif
1312 
1313  template <class M,class MS> friend M &_mmssectassign(M &m1,const MS &ms)
1314 #if(CXSC_INDEX_CHECK)
1315  throw(ERROR__OP_WITH_WRONG_DIM<M>);
1316 #else
1317  throw();
1318 #endif
1319  template <class MS1,class MS2> friend MS1 &_msmssectassign(MS1 &ms1,const MS2 &ms2)
1320 #if(CXSC_INDEX_CHECK)
1321  throw(ERROR__OP_WITH_WRONG_DIM<MS1>);
1322 #else
1323  throw();
1324 #endif
1325 
1326  /* friend TINLINE l_ivector &_vsmslimultassign<l_ivector_slice,l_rmatrix_slice,l_interval>(l_ivector_slice &v,const l_rmatrix_slice &ms)
1327 #if(CXSC_INDEX_CHECK)
1328  throw(ERROR_LIMATRIX_OP_WITH_WRONG_DIM);
1329 #else
1330  throw();
1331  #endif */
1332  template <class V,class MS,class S> friend V &_vmslimultassign(V &v,const MS &ms)
1333 #if(CXSC_INDEX_CHECK)
1334  throw(ERROR__OP_WITH_WRONG_DIM<MS>);
1335 #else
1336  throw();
1337 #endif
1338 
1339 #endif
1340 
1341  //--------------- Konstruktoren ----------------------------------------
1342 
1344  explicit INLINE l_rmatrix_slice(l_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) { }
1346  explicit INLINE l_rmatrix_slice(l_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) { }
1347  public:
1349  INLINE l_rmatrix_slice(const l_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) { }
1350  public:
1351 
1352  //---------------- Standardfunktionen -----------------------------------
1353 
1354  friend INLINE l_rvector::l_rvector(const l_rmatrix_slice &sl)
1355 #if(CXSC_INDEX_CHECK)
1356  throw(ERROR_LRMATRIX_TYPE_CAST_OF_THICK_OBJ);
1357 #else
1358  throw();
1359 #endif
1360  friend INLINE l_rmatrix::l_rmatrix(const l_rmatrix_slice &) throw();
1362  INLINE l_rmatrix_slice &operator =(const l_rmatrix &m)
1363 #if(CXSC_INDEX_CHECK)
1364  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1365 #else
1366  throw();
1367 #endif
1368  INLINE l_rmatrix_slice &operator =(const l_rmatrix_slice &ms)
1370 #if(CXSC_INDEX_CHECK)
1371  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1372 #else
1373  throw();
1374 #endif
1375  INLINE l_rmatrix_slice &operator =(const l_real &r) throw();
1378  INLINE l_rmatrix_slice &operator =(const l_rvector &v)
1379 #if(CXSC_INDEX_CHECK)
1380  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1381 #else
1382  throw();
1383 #endif
1384  INLINE l_rmatrix_slice &operator =(const l_rvector_slice &v)
1386 #if(CXSC_INDEX_CHECK)
1387  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1388 #else
1389  throw();
1390 #endif
1391  INLINE l_rmatrix_slice &operator =(const rmatrix &m)
1393 #if(CXSC_INDEX_CHECK)
1394  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1395 #else
1396  throw();
1397 #endif
1398  INLINE l_rmatrix_slice &operator =(const rmatrix_slice &ms)
1400 #if(CXSC_INDEX_CHECK)
1401  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1402 #else
1403  throw();
1404 #endif
1405  INLINE l_rmatrix_slice &operator =(const real &r) throw();
1408  INLINE l_rmatrix_slice &operator =(const rvector &v)
1409 #if(CXSC_INDEX_CHECK)
1410  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1411 #else
1412  throw();
1413 #endif
1414  INLINE l_rmatrix_slice &operator =(const rvector_slice &v)
1416 #if(CXSC_INDEX_CHECK)
1417  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1418 #else
1419  throw();
1420 #endif
1421  INLINE l_rmatrix_subv operator [](const int &i) const
1423 #if(CXSC_INDEX_CHECK)
1424  throw(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT);
1425 #else
1426  throw();
1427 #endif
1428  INLINE l_rmatrix_subv operator [](const cxscmatrix_column &i) const
1430 #if(CXSC_INDEX_CHECK)
1431  throw(ERROR_LRMATRIX_ROW_OR_COL_NOT_IN_MAT);
1432 #else
1433  throw();
1434 #endif
1435  INLINE l_rmatrix_slice &operator ()() throw() { return *this; }
1438  INLINE l_rmatrix_slice operator ()(const int &m, const int &n)
1439 #if(CXSC_INDEX_CHECK)
1440  throw(ERROR_LRMATRIX_SUB_ARRAY_TOO_BIG);
1441 #else
1442  throw();
1443 #endif
1444  INLINE l_rmatrix_slice operator ()(const int &m1, const int &m2, const int &n1, const int &n2)
1446 #if(CXSC_INDEX_CHECK)
1447  throw(ERROR_LRMATRIX_SUB_ARRAY_TOO_BIG);
1448 #else
1449  throw();
1450 #endif
1451  INLINE l_rmatrix_slice &operator *=(const l_rmatrix &m)
1453 #if(CXSC_INDEX_CHECK)
1454  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1455 #else
1456  throw();
1457 #endif
1458  INLINE l_rmatrix_slice &operator *=(const rmatrix &m)
1460 #if(CXSC_INDEX_CHECK)
1461  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1462 #else
1463  throw();
1464 #endif
1465  INLINE l_rmatrix_slice &operator *=(const l_rmatrix_slice &ms2)
1467 #if(CXSC_INDEX_CHECK)
1468  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1469 #else
1470  throw();
1471 #endif
1472  INLINE l_rmatrix_slice &operator *=(const rmatrix_slice &ms2)
1474 #if(CXSC_INDEX_CHECK)
1475  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1476 #else
1477  throw();
1478 #endif
1479  INLINE l_rmatrix_slice &operator +=(const l_rmatrix &m1)
1481 #if(CXSC_INDEX_CHECK)
1482  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1483 #else
1484  throw();
1485 #endif
1486  INLINE l_rmatrix_slice &operator +=(const rmatrix &m1)
1488 #if(CXSC_INDEX_CHECK)
1489  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1490 #else
1491  throw();
1492 #endif
1493  INLINE l_rmatrix_slice &operator +=(const l_rmatrix_slice &ms2)
1495 #if(CXSC_INDEX_CHECK)
1496  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1497 #else
1498  throw();
1499 #endif
1500  INLINE l_rmatrix_slice &operator +=(const rmatrix_slice &ms2)
1502 #if(CXSC_INDEX_CHECK)
1503  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1504 #else
1505  throw();
1506 #endif
1507  INLINE l_rmatrix_slice &operator -=(const l_rmatrix &m1)
1509 #if(CXSC_INDEX_CHECK)
1510  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1511 #else
1512  throw();
1513 #endif
1514  INLINE l_rmatrix_slice &operator -=(const rmatrix &m1)
1516 #if(CXSC_INDEX_CHECK)
1517  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1518 #else
1519  throw();
1520 #endif
1521  INLINE l_rmatrix_slice &operator -=(const l_rmatrix_slice &ms2)
1523 #if(CXSC_INDEX_CHECK)
1524  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1525 #else
1526  throw();
1527 #endif
1528  INLINE l_rmatrix_slice &operator -=(const rmatrix_slice &ms2)
1530 #if(CXSC_INDEX_CHECK)
1531  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1532 #else
1533  throw();
1534 #endif
1535  INLINE l_rmatrix_slice &operator |=(const l_rmatrix &m1)
1537 #if(CXSC_INDEX_CHECK)
1538  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1539 #else
1540  throw();
1541 #endif
1542  INLINE l_rmatrix_slice &operator |=(const rmatrix &m1)
1544 #if(CXSC_INDEX_CHECK)
1545  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1546 #else
1547  throw();
1548 #endif
1549  INLINE l_rmatrix_slice &operator |=(const l_rmatrix_slice &ms2)
1551 #if(CXSC_INDEX_CHECK)
1552  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1553 #else
1554  throw();
1555 #endif
1556  INLINE l_rmatrix_slice &operator |=(const rmatrix_slice &ms2)
1558 #if(CXSC_INDEX_CHECK)
1559  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1560 #else
1561  throw();
1562 #endif
1563  INLINE l_rmatrix_slice &operator *=(const l_real &c) throw();
1566  INLINE l_rmatrix_slice &operator *=(const real &c) throw();
1568  INLINE l_rmatrix_slice &operator /=(const l_real &c) throw();
1570  INLINE l_rmatrix_slice &operator /=(const real &c) throw();
1571  INLINE operator void*() throw();
1572 //#else
1573 //#endif
1574 };
1575 
1576 //================================================================
1577 //====================== Subvector Functions =====================
1578 
1579 //=======================Vector / Scalar =========================
1580 
1582  INLINE l_rvector operator /(const l_rmatrix_subv &rv, const l_real &s) throw();
1584  INLINE l_rvector operator *(const l_rmatrix_subv &rv, const l_real &s) throw();
1586  INLINE l_rvector operator *(const l_real &s, const l_rmatrix_subv &rv) throw();
1587 
1588 //======================== Vector / Vector ========================
1589 
1591  INLINE l_rvector abs(const l_rmatrix_subv &mv) throw();
1592 
1594  INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const l_rmatrix_subv &rv2)
1595 #if(CXSC_INDEX_CHECK)
1596  throw(OP_WITH_WRONG_DIM);
1597 #else
1598  throw();
1599 #endif
1600  INLINE void accumulate(dotprecision &dp, const l_rvector & rv1, const l_rmatrix_subv &rv2)
1602 #if(CXSC_INDEX_CHECK)
1603  throw(OP_WITH_WRONG_DIM);
1604 #else
1605  throw();
1606 #endif
1607  INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const l_rvector &rv2)
1609 #if(CXSC_INDEX_CHECK)
1610  throw(OP_WITH_WRONG_DIM);
1611 #else
1612  throw();
1613 #endif
1614  INLINE void accumulate(dotprecision &dp, const l_rvector_slice & sl1, const l_rmatrix_subv &rv2)
1616 #if(CXSC_INDEX_CHECK)
1617  throw(OP_WITH_WRONG_DIM);
1618 #else
1619  throw();
1620 #endif
1621  INLINE void accumulate(dotprecision &dp, const l_rmatrix_subv & rv1, const l_rvector_slice &sl2)
1623 #if(CXSC_INDEX_CHECK)
1624  throw(OP_WITH_WRONG_DIM);
1625 #else
1626  throw();
1627 #endif
1628 
1630  INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const l_rmatrix_subv &rv2)
1631 #if(CXSC_INDEX_CHECK)
1632  throw(OP_WITH_WRONG_DIM);
1633 #else
1634  throw();
1635 #endif
1636  INLINE void accumulate(idotprecision &dp, const l_rvector & rv1, const l_rmatrix_subv &rv2)
1638 #if(CXSC_INDEX_CHECK)
1639  throw(OP_WITH_WRONG_DIM);
1640 #else
1641  throw();
1642 #endif
1643  INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const l_rvector &rv2)
1645 #if(CXSC_INDEX_CHECK)
1646  throw(OP_WITH_WRONG_DIM);
1647 #else
1648  throw();
1649 #endif
1650  INLINE void accumulate(idotprecision &dp, const l_rvector_slice & sl1, const l_rmatrix_subv &rv2)
1652 #if(CXSC_INDEX_CHECK)
1653  throw(OP_WITH_WRONG_DIM);
1654 #else
1655  throw();
1656 #endif
1657  INLINE void accumulate(idotprecision &dp, const l_rmatrix_subv & rv1, const l_rvector_slice &sl2)
1659 #if(CXSC_INDEX_CHECK)
1660  throw(OP_WITH_WRONG_DIM);
1661 #else
1662  throw();
1663 #endif
1664 
1666  INLINE l_real operator *(const l_rmatrix_subv & rv1, const l_rmatrix_subv &rv2)
1667 #if(CXSC_INDEX_CHECK)
1668  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM);
1669 #else
1670  throw();
1671 #endif
1672  INLINE l_real operator *(const l_rvector & rv1, const l_rmatrix_subv &rv2)
1674 #if(CXSC_INDEX_CHECK)
1675  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM);
1676 #else
1677  throw();
1678 #endif
1679  INLINE l_real operator *(const l_rmatrix_subv &rv1,const l_rvector &rv2)
1681 #if(CXSC_INDEX_CHECK)
1682  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM);
1683 #else
1684  throw();
1685 #endif
1686  INLINE l_real operator *(const l_rvector_slice &sl,const l_rmatrix_subv &sv)
1688 #if(CXSC_INDEX_CHECK)
1689  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM);
1690 #else
1691  throw();
1692 #endif
1693  INLINE l_real operator *(const l_rmatrix_subv &mv,const l_rvector_slice &vs)
1695 #if(CXSC_INDEX_CHECK)
1696  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM);
1697 #else
1698  throw();
1699 #endif
1700 
1702  INLINE l_rvector operator +(const l_rmatrix_subv & rv1, const l_rmatrix_subv &rv2)
1703 #if(CXSC_INDEX_CHECK)
1704  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM);
1705 #else
1706  throw();
1707 #endif
1708  INLINE l_rvector operator +(const l_rmatrix_subv &rv1,const l_rvector &rv2)
1710 #if(CXSC_INDEX_CHECK)
1711  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM);
1712 #else
1713  throw();
1714 #endif
1715  INLINE l_rvector operator +(const l_rvector & rv1, const l_rmatrix_subv &rv2)
1717 #if(CXSC_INDEX_CHECK)
1718  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM);
1719 #else
1720  throw();
1721 #endif
1722  INLINE l_rvector operator +(const l_rvector_slice &sl,const l_rmatrix_subv &mv)
1724 #if(CXSC_INDEX_CHECK)
1725  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM);
1726 #else
1727  throw();
1728 #endif
1729  INLINE l_rvector operator +(const l_rmatrix_subv &mv,const l_rvector_slice &sl)
1731 #if(CXSC_INDEX_CHECK)
1732  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM);
1733 #else
1734  throw();
1735 #endif
1736 
1738  INLINE l_rvector operator -(const l_rmatrix_subv & rv1, const l_rmatrix_subv &rv2)
1739 #if(CXSC_INDEX_CHECK)
1740  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM);
1741 #else
1742  throw();
1743 #endif
1744  INLINE l_rvector operator -(const l_rvector & rv1, const l_rmatrix_subv &rv2)
1746 #if(CXSC_INDEX_CHECK)
1747  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM);
1748 #else
1749  throw();
1750 #endif
1751  INLINE l_rvector operator -(const l_rmatrix_subv &rv1,const l_rvector &rv2)
1753 #if(CXSC_INDEX_CHECK)
1754  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM);
1755 #else
1756  throw();
1757 #endif
1758  INLINE l_rvector operator -(const l_rvector_slice &sl,const l_rmatrix_subv &mv)
1760 #if(CXSC_INDEX_CHECK)
1761  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM);
1762 #else
1763  throw();
1764 #endif
1765  INLINE l_rvector operator -(const l_rmatrix_subv &mv,const l_rvector_slice &sl)
1767 #if(CXSC_INDEX_CHECK)
1768  throw(ERROR_LRVECTOR_OP_WITH_WRONG_DIM);
1769 #else
1770  throw();
1771 #endif
1772 
1773 //====================================================================
1774 //===================== Matrix Functions =============================
1775 
1777  INLINE l_rmatrix _l_rmatrix(const l_rmatrix &rm) throw();
1779  INLINE l_rmatrix _l_rmatrix(const l_rvector &v) throw();
1781  INLINE l_rmatrix _l_rmatrix(const l_rvector_slice &v) throw();
1783  INLINE l_rmatrix _l_rmatrix(const l_real &r) throw();
1784 
1786  INLINE int Lb(const l_rmatrix &rm, const int &i)
1787 #if(CXSC_INDEX_CHECK)
1788  throw(ERROR_LRMATRIX_WRONG_ROW_OR_COL);
1789 #else
1790  throw();
1791 #endif
1792  INLINE int Ub(const l_rmatrix &rm, const int &i)
1794 #if(CXSC_INDEX_CHECK)
1795  throw(ERROR_LRMATRIX_WRONG_ROW_OR_COL);
1796 #else
1797  throw();
1798 #endif
1799  INLINE int Lb(const l_rmatrix_slice &rm, const int &i)
1801 #if(CXSC_INDEX_CHECK)
1802  throw(ERROR_LRMATRIX_WRONG_ROW_OR_COL);
1803 #else
1804  throw();
1805 #endif
1806  INLINE int Ub(const l_rmatrix_slice &rm, const int &i)
1808 #if(CXSC_INDEX_CHECK)
1809  throw(ERROR_LRMATRIX_WRONG_ROW_OR_COL);
1810 #else
1811  throw();
1812 #endif
1813  INLINE l_rmatrix &SetLb(l_rmatrix &m, const int &i,const int &j)
1815 #if(CXSC_INDEX_CHECK)
1816  throw(ERROR_LRMATRIX_WRONG_ROW_OR_COL);
1817 #else
1818  throw();
1819 #endif
1820  INLINE l_rmatrix &SetUb(l_rmatrix &m, const int &i,const int &j)
1822 #if(CXSC_INDEX_CHECK)
1823  throw(ERROR_LRMATRIX_WRONG_ROW_OR_COL);
1824 #else
1825  throw();
1826 #endif
1827  INLINE void Resize(l_rmatrix &A) throw();
1830  INLINE void Resize(l_rmatrix &A,const int &m, const int &n)
1831 #if(CXSC_INDEX_CHECK)
1832  throw(ERROR_LRMATRIX_WRONG_BOUNDARIES);
1833 #else
1834  throw();
1835 #endif
1836  INLINE void Resize(l_rmatrix &A,const int &m1, const int &m2,const int &n1,const int &n2)
1838 #if(CXSC_INDEX_CHECK)
1839  throw(ERROR_LRMATRIX_WRONG_BOUNDARIES);
1840 #else
1841  throw();
1842 #endif
1843 
1845  INLINE l_rmatrix abs(const l_rmatrix &m) throw();
1847  INLINE l_rmatrix abs(const l_rmatrix_slice &ms) throw();
1848 
1849 //===================== Matrix / Scalar ===============================
1850 
1852  INLINE l_rmatrix operator *(const l_real &c, const l_rmatrix &m) throw();
1854  INLINE l_rmatrix operator *(const l_real &c, const l_rmatrix_slice &ms) throw();
1856  INLINE l_rmatrix operator *(const l_rmatrix &m,const l_real &c) throw();
1858  INLINE l_rmatrix operator *(const l_rmatrix_slice &ms,const l_real &c) throw();
1860  INLINE l_rmatrix &operator *=(l_rmatrix &m,const l_real &c) throw();
1862  INLINE l_rmatrix operator /(const l_rmatrix &m,const l_real &c) throw();
1864  INLINE l_rmatrix operator /(const l_rmatrix_slice &ms, const l_real &c) throw();
1866  INLINE l_rmatrix &operator /=(l_rmatrix &m,const l_real &c) throw();
1867 
1868 //------------ real - l_rmatrix -----------------------------------------------
1869 
1871  INLINE l_rmatrix operator *(const real &c, const l_rmatrix &m) throw();
1873  INLINE l_rmatrix operator *(const real &c, const l_rmatrix_slice &ms) throw();
1875  INLINE l_rmatrix operator *(const l_rmatrix &m,const real &c) throw();
1877  INLINE l_rmatrix operator *(const l_rmatrix_slice &ms,const real &c) throw();
1879  INLINE l_rmatrix &operator *=(l_rmatrix &m,const real &c) throw();
1881  INLINE l_rmatrix operator /(const l_rmatrix &m,const real &c) throw();
1883  INLINE l_rmatrix operator /(const l_rmatrix_slice &ms, const real &c) throw();
1885  INLINE l_rmatrix &operator /=(l_rmatrix &m,const real &c) throw();
1886 //----------------- rmatrix - l_real ----------------
1887 
1889  INLINE l_rmatrix operator *(const l_real &c, const rmatrix &m) throw();
1891  INLINE l_rmatrix operator *(const l_real &c, const rmatrix_slice &ms) throw();
1893  INLINE l_rmatrix operator *(const rmatrix &m,const l_real &c) throw();
1895  INLINE l_rmatrix operator *(const rmatrix_slice &ms,const l_real &c) throw();
1897  INLINE l_rmatrix operator /(const rmatrix &m,const l_real &c) throw();
1899  INLINE l_rmatrix operator /(const rmatrix_slice &ms, const l_real &c) throw();
1900 
1901 
1902 //============================ Matrix / Vector ===================================
1903 
1904 
1906  INLINE l_rvector operator *(const l_rmatrix &m,const l_rvector &v)
1907 #if(CXSC_INDEX_CHECK)
1908  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1909 #else
1910  throw();
1911 #endif
1912  INLINE l_rvector operator *(const l_rmatrix_slice &ms,const l_rvector &v)
1914 #if(CXSC_INDEX_CHECK)
1915  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1916 #else
1917  throw();
1918 #endif
1919  INLINE l_rvector operator *(const l_rvector &v,const l_rmatrix &m)
1921 #if(CXSC_INDEX_CHECK)
1922  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1923 #else
1924  throw();
1925 #endif
1926  INLINE l_rvector operator *(const l_rvector &v,const l_rmatrix_slice &ms)
1928 #if(CXSC_INDEX_CHECK)
1929  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1930 #else
1931  throw();
1932 #endif
1933  INLINE l_rvector &operator *=(l_rvector &v,const l_rmatrix &m)
1935 #if(CXSC_INDEX_CHECK)
1936  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1937 #else
1938  throw();
1939 #endif
1940  INLINE l_rvector &operator *=(l_rvector &v,const l_rmatrix_slice &ms)
1942 #if(CXSC_INDEX_CHECK)
1943  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1944 #else
1945  throw();
1946 #endif
1947 
1949  INLINE l_rvector operator *(const l_rvector_slice &v,const l_rmatrix &m)
1950 #if(CXSC_INDEX_CHECK)
1951  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1952 #else
1953  throw();
1954 #endif
1955  INLINE l_rvector operator *(const l_rvector_slice &v,const l_rmatrix_slice &m)
1957 #if(CXSC_INDEX_CHECK)
1958  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1959 #else
1960  throw();
1961 #endif
1962 
1963 //----------------- real -------------------------------------
1964 
1966  INLINE l_rvector operator *(const rvector &v,const l_rmatrix &m)
1967 #if(CXSC_INDEX_CHECK)
1968  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1969 #else
1970  throw();
1971 #endif
1972  INLINE l_rvector operator *(const rvector &v,const l_rmatrix_slice &ms)
1974 #if(CXSC_INDEX_CHECK)
1975  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1976 #else
1977  throw();
1978 #endif
1979  INLINE l_rvector operator *(const rvector_slice &v,const l_rmatrix &m)
1981 #if(CXSC_INDEX_CHECK)
1982  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1983 #else
1984  throw();
1985 #endif
1986 
1988  INLINE l_rvector operator *(const l_rmatrix &m,const rvector &v)
1989 #if(CXSC_INDEX_CHECK)
1990  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1991 #else
1992  throw();
1993 #endif
1994  INLINE l_rvector operator *(const l_rmatrix_slice &ms,const rvector &v)
1996 #if(CXSC_INDEX_CHECK)
1997  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
1998 #else
1999  throw();
2000 #endif
2001 
2002 
2003 //================ Matrix / Matrix ============================
2004 
2006  INLINE const l_rmatrix &operator +(const l_rmatrix &m1) throw();
2008  INLINE l_rmatrix operator +(const l_rmatrix_slice &ms) throw();
2010  INLINE l_rmatrix operator +(const l_rmatrix &m1,const l_rmatrix &m2)
2011 #if(CXSC_INDEX_CHECK)
2012  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2013 #else
2014  throw();
2015 #endif
2016  INLINE l_rmatrix operator +(const l_rmatrix &m,const l_rmatrix_slice &ms)
2018 #if(CXSC_INDEX_CHECK)
2019  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2020 #else
2021  throw();
2022 #endif
2023  INLINE l_rmatrix operator +(const l_rmatrix_slice &ms,const l_rmatrix &m)
2025 #if(CXSC_INDEX_CHECK)
2026  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2027 #else
2028  throw();
2029 #endif
2030  INLINE l_rmatrix operator +(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2)
2032 #if(CXSC_INDEX_CHECK)
2033  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2034 #else
2035  throw();
2036 #endif
2037  INLINE l_rmatrix &operator +=(l_rmatrix &m1,const l_rmatrix &m2)
2039 #if(CXSC_INDEX_CHECK)
2040  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2041 #else
2042  throw();
2043 #endif
2044  INLINE l_rmatrix &operator +=(l_rmatrix &m1,const l_rmatrix_slice &ms)
2046 #if(CXSC_INDEX_CHECK)
2047  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2048 #else
2049  throw();
2050 #endif
2051 
2053  INLINE l_rmatrix operator -(const l_rmatrix &m) throw();
2055  INLINE l_rmatrix operator -(const l_rmatrix_slice &ms) throw();
2057  INLINE l_rmatrix operator -(const l_rmatrix &m1,const l_rmatrix &m2)
2058 #if(CXSC_INDEX_CHECK)
2059  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2060 #else
2061  throw();
2062 #endif
2063  INLINE l_rmatrix operator -(const l_rmatrix &m,const l_rmatrix_slice &ms)
2065 #if(CXSC_INDEX_CHECK)
2066  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2067 #else
2068  throw();
2069 #endif
2070  INLINE l_rmatrix operator -(const l_rmatrix_slice &ms,const l_rmatrix &m)
2072 #if(CXSC_INDEX_CHECK)
2073  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2074 #else
2075  throw();
2076 #endif
2077  INLINE l_rmatrix operator -(const l_rmatrix_slice &ms1,const l_rmatrix_slice &ms2)
2079 #if(CXSC_INDEX_CHECK)
2080  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2081 #else
2082  throw();
2083 #endif
2084  INLINE l_rmatrix &operator -=(l_rmatrix &m1,const l_rmatrix &m2)
2086 #if(CXSC_INDEX_CHECK)
2087  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2088 #else
2089  throw();
2090 #endif
2091  INLINE l_rmatrix &operator -=(l_rmatrix &m1,const l_rmatrix_slice &ms)
2093 #if(CXSC_INDEX_CHECK)
2094  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2095 #else
2096  throw();
2097 #endif
2098 
2100  INLINE l_rmatrix operator *(const l_rmatrix &m1, const l_rmatrix &m2)
2101 #if(CXSC_INDEX_CHECK)
2102  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2103 #else
2104  throw();
2105 #endif
2106  INLINE l_rmatrix operator *(const l_rmatrix &m1, const l_rmatrix_slice &ms)
2108 #if(CXSC_INDEX_CHECK)
2109  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2110 #else
2111  throw();
2112 #endif
2113  INLINE l_rmatrix operator *(const l_rmatrix_slice &ms, const l_rmatrix &m1)
2115 #if(CXSC_INDEX_CHECK)
2116  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2117 #else
2118  throw();
2119 #endif
2120  INLINE l_rmatrix operator *(const l_rmatrix_slice &ms1, const l_rmatrix_slice &ms2)
2122 #if(CXSC_INDEX_CHECK)
2123  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2124 #else
2125  throw();
2126 #endif
2127  INLINE l_rmatrix &operator *=(l_rmatrix &m1,const l_rmatrix &m2)
2129 #if(CXSC_INDEX_CHECK)
2130  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2131 #else
2132  throw();
2133 #endif
2134  INLINE l_rmatrix &operator *=(l_rmatrix &m1,const l_rmatrix_slice &ms)
2136 #if(CXSC_INDEX_CHECK)
2137  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2138 #else
2139  throw();
2140 #endif
2141 
2142 
2143  //---------- rmatrix-l_rmatrix ------------------
2145  INLINE l_rmatrix operator +(const rmatrix &m1,const l_rmatrix &m2)
2146 #if(CXSC_INDEX_CHECK)
2147  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2148 #else
2149  throw();
2150 #endif
2151  INLINE l_rmatrix operator +(const l_rmatrix &m1,const rmatrix &m2)
2153 #if(CXSC_INDEX_CHECK)
2154  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2155 #else
2156  throw();
2157 #endif
2158  INLINE l_rmatrix operator +(const rmatrix &m,const l_rmatrix_slice &ms)
2160 #if(CXSC_INDEX_CHECK)
2161  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2162 #else
2163  throw();
2164 #endif
2165  INLINE l_rmatrix operator +(const l_rmatrix &m,const rmatrix_slice &ms)
2167 #if(CXSC_INDEX_CHECK)
2168  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2169 #else
2170  throw();
2171 #endif
2172  INLINE l_rmatrix operator +(const rmatrix_slice &ms,const l_rmatrix &m)
2174 #if(CXSC_INDEX_CHECK)
2175  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2176 #else
2177  throw();
2178 #endif
2179  INLINE l_rmatrix operator +(const l_rmatrix_slice &ms,const rmatrix &m)
2181 #if(CXSC_INDEX_CHECK)
2182  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2183 #else
2184  throw();
2185 #endif
2186  INLINE l_rmatrix operator +(const rmatrix_slice &m1,const l_rmatrix_slice &m2)
2188 #if(CXSC_INDEX_CHECK)
2189  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2190 #else
2191  throw();
2192 #endif
2193  INLINE l_rmatrix operator +(const l_rmatrix_slice &m1,const rmatrix_slice &m2)
2195 #if(CXSC_INDEX_CHECK)
2196  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2197 #else
2198  throw();
2199 #endif
2200  INLINE l_rmatrix &operator +=(l_rmatrix &m1,const rmatrix &m2)
2202 #if(CXSC_INDEX_CHECK)
2203  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2204 #else
2205  throw();
2206 #endif
2207  INLINE l_rmatrix &operator +=(l_rmatrix &m1,const rmatrix_slice &ms)
2209 #if(CXSC_INDEX_CHECK)
2210  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2211 #else
2212  throw();
2213 #endif
2214 
2216  INLINE l_rmatrix operator -(const rmatrix &m1,const l_rmatrix &m2)
2217 #if(CXSC_INDEX_CHECK)
2218  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2219 #else
2220  throw();
2221 #endif
2222  INLINE l_rmatrix operator -(const l_rmatrix &m1,const rmatrix &m2)
2224 #if(CXSC_INDEX_CHECK)
2225  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2226 #else
2227  throw();
2228 #endif
2229  INLINE l_rmatrix operator -(const rmatrix &m,const l_rmatrix_slice &ms)
2231 #if(CXSC_INDEX_CHECK)
2232  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2233 #else
2234  throw();
2235 #endif
2236  INLINE l_rmatrix operator -(const l_rmatrix &m,const rmatrix_slice &ms)
2238 #if(CXSC_INDEX_CHECK)
2239  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2240 #else
2241  throw();
2242 #endif
2243  INLINE l_rmatrix operator -(const rmatrix_slice &ms,const l_rmatrix &m)
2245 #if(CXSC_INDEX_CHECK)
2246  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2247 #else
2248  throw();
2249 #endif
2250  INLINE l_rmatrix operator -(const l_rmatrix_slice &ms,const rmatrix &m)
2252 #if(CXSC_INDEX_CHECK)
2253  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2254 #else
2255  throw();
2256 #endif
2257  INLINE l_rmatrix operator -(const rmatrix_slice &ms1,const l_rmatrix_slice &ms2)
2259 #if(CXSC_INDEX_CHECK)
2260  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2261 #else
2262  throw();
2263 #endif
2264  INLINE l_rmatrix operator -(const l_rmatrix_slice &ms1,const rmatrix_slice &ms2)
2266 #if(CXSC_INDEX_CHECK)
2267  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2268 #else
2269  throw();
2270 #endif
2271  INLINE l_rmatrix &operator -=(l_rmatrix &m1,const rmatrix &m2)
2273 #if(CXSC_INDEX_CHECK)
2274  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2275 #else
2276  throw();
2277 #endif
2278  INLINE l_rmatrix &operator -=(l_rmatrix &m1,const rmatrix_slice &ms)
2280 #if(CXSC_INDEX_CHECK)
2281  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2282 #else
2283  throw();
2284 #endif
2285 
2287  INLINE l_rmatrix operator *(const rmatrix &m1, const l_rmatrix &m2)
2288 #if(CXSC_INDEX_CHECK)
2289  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2290 #else
2291  throw();
2292 #endif
2293  INLINE l_rmatrix operator *(const l_rmatrix &m1, const rmatrix &m2)
2295 #if(CXSC_INDEX_CHECK)
2296  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2297 #else
2298  throw();
2299 #endif
2300  INLINE l_rmatrix operator *(const rmatrix &m1, const l_rmatrix_slice &ms)
2302 #if(CXSC_INDEX_CHECK)
2303  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2304 #else
2305  throw();
2306 #endif
2307  INLINE l_rmatrix operator *(const l_rmatrix &m1, const rmatrix_slice &ms)
2309 #if(CXSC_INDEX_CHECK)
2310  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2311 #else
2312  throw();
2313 #endif
2314  INLINE l_rmatrix operator *(const rmatrix_slice &ms, const l_rmatrix &m1)
2316 #if(CXSC_INDEX_CHECK)
2317  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2318 #else
2319  throw();
2320 #endif
2321  INLINE l_rmatrix operator *(const l_rmatrix_slice &ms, const rmatrix &m1)
2323 #if(CXSC_INDEX_CHECK)
2324  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2325 #else
2326  throw();
2327 #endif
2328  INLINE l_rmatrix operator *(const rmatrix_slice &ms1, const l_rmatrix_slice &ms2)
2330 #if(CXSC_INDEX_CHECK)
2331  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2332 #else
2333  throw();
2334 #endif
2335  INLINE l_rmatrix operator *(const l_rmatrix_slice &ms1, const rmatrix_slice &ms2)
2337 #if(CXSC_INDEX_CHECK)
2338  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2339 #else
2340  throw();
2341 #endif
2342  INLINE l_rmatrix &operator *=(l_rmatrix &m1,const rmatrix &m2)
2344 #if(CXSC_INDEX_CHECK)
2345  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2346 #else
2347  throw();
2348 #endif
2349  INLINE l_rmatrix &operator *=(l_rmatrix &m1,const rmatrix_slice &ms)
2351 #if(CXSC_INDEX_CHECK)
2352  throw(ERROR_LRMATRIX_OP_WITH_WRONG_DIM);
2353 #else
2354  throw();
2355 #endif
2356 
2357 
2358 //============== Compare Operator ==========================
2359 
2360 //-------------- Matrix - Matrix -------------------------
2361 
2363  INLINE bool operator ==(const l_rmatrix &m1,const l_rmatrix &m2) throw();
2365  INLINE bool operator !=(const l_rmatrix &m1,const l_rmatrix &m2) throw();
2367  INLINE bool operator <(const l_rmatrix &m1,const l_rmatrix &m2) throw();
2369  INLINE bool operator <=(const l_rmatrix &m1,const l_rmatrix &m2) throw();
2371  INLINE bool operator >(const l_rmatrix &m1,const l_rmatrix &m2) throw();
2373  INLINE bool operator >=(const l_rmatrix &m1,const l_rmatrix &m2) throw();
2375  INLINE bool operator ==(const l_rmatrix &m1,const l_rmatrix_slice &ms) throw();
2377  INLINE bool operator !=(const l_rmatrix &m1,const l_rmatrix_slice &ms) throw();
2379  INLINE bool operator <(const l_rmatrix &m1,const l_rmatrix_slice &ms) throw();
2381  INLINE bool operator <=(const l_rmatrix &m1,const l_rmatrix_slice &ms) throw();
2383  INLINE bool operator >(const l_rmatrix &m1,const l_rmatrix_slice &ms) throw();
2385  INLINE bool operator >=(const l_rmatrix &m1,const l_rmatrix_slice &ms) throw();
2386 
2387 //---------------- Matrix - Matrix_slice ----------------------
2388 
2390  INLINE bool operator ==(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2) throw();
2392  INLINE bool operator !=(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2) throw();
2394  INLINE bool operator <(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2) throw();
2396  INLINE bool operator <=(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2) throw();
2398  INLINE bool operator >(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2) throw();
2400  INLINE bool operator >=(const l_rmatrix_slice &m1,const l_rmatrix_slice &m2) throw();
2401 
2402 //=================== Not Operator =============================
2403 
2405  INLINE bool operator !(const l_rmatrix &ms) throw();
2407  INLINE bool operator !(const l_rmatrix_slice &ms) throw();
2408 
2409 //======================== Input / Output ========================
2410 
2412  INLINE std::ostream &operator <<(std::ostream &s,const l_rmatrix &r) throw();
2414  INLINE std::ostream &operator <<(std::ostream &s,const l_rmatrix_slice &r) throw();
2416  INLINE std::istream &operator >>(std::istream &s,l_rmatrix &r) throw();
2418  INLINE std::istream &operator >>(std::istream &s,l_rmatrix_slice &r) throw();
2419 
2421  INLINE int RowLen ( const l_rmatrix& );
2423  INLINE int ColLen ( const l_rmatrix& );
2425  INLINE int RowLen ( const l_rmatrix_slice& );
2427  INLINE int ColLen ( const l_rmatrix_slice& );
2429  l_rmatrix Id ( const l_rmatrix& );
2431  l_rmatrix transp ( const l_rmatrix& );
2433  void DoubleSize ( l_rmatrix& );
2434 
2435 } // namespace cxsc
2436 
2437 #ifdef _CXSC_INCL_INL
2438 #include "matrix.inl"
2439 #include "l_rmatrix.inl"
2440 #endif
2441 
2442 #ifdef _CXSC_LIVECTOR_HPP_INCLUDED
2443 # ifdef _CXSC_INCL_INL
2444 # include "liveclrmat.inl"
2445 # else
2446 # include "liveclrmat.hpp"
2447 # endif
2448 #endif
2449 
2450 #ifdef _CXSC_IVECTOR_HPP_INCLUDED
2451 # ifdef _CXSC_INCL_INL
2452 # include "iveclrmat.inl"
2453 # else
2454 # include "iveclrmat.hpp"
2455 # endif
2456 #endif
2457 
2458 #ifdef _CXSC_IMATRIX_HPP_INCLUDED
2459 # ifdef _CXSC_INCL_INL
2460 # include "lrmatimat.inl"
2461 # else
2462 # include "lrmatimat.hpp"
2463 # endif
2464 #endif
2465 
2466 
2467 #endif
2468 
The Multiple-Precision Data Type l_rmatrix_slice.
Definition: l_rmatrix.hpp:999
The Data Type rmatrix_slice.
Definition: rmatrix.hpp:1442
l_rmatrix_subv(l_real *d, const int &l, const int &u, const int &s, const int &st, const int &o)
Constructor of class l_rmatrix_subv.
Definition: l_rmatrix.hpp:226
The Data Type idotprecision.
Definition: idot.hpp:47
The Multiple-Precision Data Type l_real.
Definition: l_real.hpp:77
The Data Type dotprecision.
Definition: dot.hpp:111
The Multiple-Precision Data Type l_rmatrix_subv.
Definition: l_rmatrix.hpp:46
l_rmatrix_subv & operator()()
Operator for accessing the whole vector.
Definition: l_rmatrix.hpp:245
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
friend int Lb(const l_rmatrix_subv &rv)
Returns the lower bound of the vector.
Definition: l_rmatrix.hpp:234
friend int Ub(const l_rmatrix_subv &rv)
Returns the upper bound of the vector.
Definition: l_rmatrix.hpp:236
cimatrix & SetLb(cimatrix &m, const int &i, const int &j)
Sets the lower bound index.
Definition: cimatrix.inl:1184
l_rmatrix_subv & operator-=(const l_real &c)
Implementation of subtraction and allocation operation.
Definition: l_rmatrix.inl:457
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
l_real & operator[](const int &i) const
Operator for accessing the single elements of the vector.
Definition: l_rmatrix.inl:132
cimatrix Id(const cimatrix &A)
Returns the Identity matrix.
Definition: cimatrix.cpp:61
The Data Type rvector_slice.
Definition: rvector.hpp:1063
The Multiple-Precision Data Type l_imatrix.
Definition: l_imatrix.hpp:725
l_rmatrix_subv & operator*=(const l_real &c)
Implementation of multiplication and allocation operation.
Definition: l_rmatrix.inl:455
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
l_rmatrix_subv & operator+=(const l_real &c)
Implementation of addition and allocation operation.
Definition: l_rmatrix.inl:456
void Resize(cimatrix &A)
Resizes the matrix.
Definition: cimatrix.inl:1211
l_rmatrix _l_rmatrix(const l_rmatrix &rm)
Deprecated typecast, which only exist for the reason of compatibility with older versions of C-XSC...
Definition: l_rmatrix.inl:787
The Data Type rmatrix.
Definition: rmatrix.hpp:470
l_rmatrix_slice(l_rmatrix_slice &a, const int &l1, const int &u1, const int &l2, const int &u2)
Constructor of class l_rmatrix_slice.
Definition: l_rmatrix.hpp:1346
int ColLen(const cimatrix &)
Returns the column dimension.
Definition: cimatrix.inl:1202
l_rmatrix()
Constructor of class l_rmatrix.
Definition: l_rmatrix.inl:31
int RowLen(const cimatrix &)
Returns the row dimension.
Definition: cimatrix.inl:1199
l_rmatrix_subv & operator/=(const l_real &c)
Implementation of division and allocation operation.
Definition: l_rmatrix.inl:458
l_rmatrix_slice(const l_rmatrix_slice &ms)
Constructor of class l_rmatrix_slice.
Definition: l_rmatrix.hpp:1349
l_rvector()
Constructor of class l_rvector.
Definition: l_rvector.inl:31
The Multiple-Precision Data Type l_rvector.
Definition: l_rvector.hpp:53
l_rmatrix_slice(l_rmatrix &a, const int &l1, const int &u1, const int &l2, const int &u2)
Constructor of class l_rmatrix_slice.
Definition: l_rmatrix.hpp:1344
friend l_rmatrix_subv Row(l_rmatrix &m, const int &i)
Returns one row of the matrix as a vector.
Definition: l_rmatrix.inl:173
l_rmatrix_subv & operator=(const l_rmatrix_subv &rv)
Implementation of standard assigning operator.
Definition: l_rmatrix.inl:349
friend l_rmatrix_subv Col(l_rmatrix &m, const int &i)
Returns one column of the matrix as a vector.
Definition: l_rmatrix.inl:184
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
l_rmatrix_subv(const l_rmatrix_subv &v)
Constructor of class l_rmatrix_subv.
Definition: l_rmatrix.hpp:229
The Scalar Type real.
Definition: real.hpp:113
The Multiple-Precision Data Type l_rvector_slice.
Definition: l_rvector.hpp:744
ivector abs(const cimatrix_subv &mv)
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737